LIBRARY: reverse Find, and reverse order Functions

so I was needing to find the last instance of a search item for strings and lists, and decided that looping through every element was slow for large inputs, so I threw these together.... just some drop in functions that do what the LLfunctions don't...

UDPATED:2009 June 21 (happy Fathers Day to the dads out there)

/*//-- Get Last Index of String Test in String Source --//*/

integer uGetStrIdxRev( string vStrSrc, string vStrTst ){
	integer vIdxFnd =
	  llStringLength( vStrSrc ) -
	  llStringLength( vStrTst ) -
	  llStringLength(
	    llList2String(
	      llParseStringKeepNulls( vStrSrc, (list)vStrTst, [] ),
	      -1)
	    );
	return (vIdxFnd | (vIdxFnd >> 31));
}

/*//-- Get Last Index of List Test in List Source --//*/

integer uGetLstIdxRev( list vLstSrc, list vLstTst ){
	integer vIdxFnd =
	  (vLstSrc != []) +
	  ([] != vLstTst) +
	  ([] != llParseString2List(
	           llList2String(
	             llParseStringKeepNulls(
	               llDumpList2String( vLstSrc, ";" ),
	               (list)llDumpList2String( vLstTst, ";" ),
	               [] ),
	             -1 ),
	           (list)";",
	           [] ));
	return (vIdxFnd | (vIdxFnd >> 31));
}

NOTE: uGetLstIdxRev only works for string data types, and you may want to modify the separator to suit your needs (it should be something that WON'T be in any of the data)

/*//-- Reverse List Order (fast version) --//*/

list uListRevF( list vLstSrc ){
	integer vIntCnt = (vLstSrc != []);
	@Loop; if (vIntCnt--){
		vLstSrc += llList2List( vLstSrc, vIntCnt, vIntCnt );
		jump Loop;
	}
	return llList2List( vLstSrc, (vLstSrc != []) >> 1, -1 );
}

/*//-- Reverse List Order (small version) --//*/

list uListRevS( list vLstSrc ){
	integer vIntCnt = (vLstSrc != []);
	@Loop; if (vIntCnt--){
		vLstSrc += llList2List( vLstSrc, vIntCnt, vIntCnt );
		vLstSrc = llDeleteSubList( vLstSrc, vIntCnt, vIntCnt );
		jump Loop;
	}
	return vLstSrc;
}

/*//-- Reverse String Order (fast version) --//*/

string uStringRevF( string vStrSrc ){
	integer vIntCnt = llStringLength( vStrSrc );
	@Loop; if (vIntCnt--){
		vStrSrc += llGetSubString( vStrSrc, vIntCnt, vIntCnt );
		jump Loop;
	}
	return llGetSubString( vStrSrc, llStringLength( vStrSrc ) >> 1, -1 );
}

/*//-- Reverse String Order (small version) --//*/

string uStringRevS( string vStrSrc ){
	integer vIntCnt = llStringLength( vStrSrc );
	@Loop; if (vIntCnt--){
		vStrSrc += llGetSubString( vStrSrc, vIntCnt, vIntCnt );
		vStrSrc = llDeleteSubString( vStrSrc, vIntCnt, vIntCnt );
		jump Loop;
	}
	return vStrSrc;
}

the fast versions run at ~double the size, and aren't so much faster (they compile smaller actually), the small versions run a hair slower, but use less memory while running (and compile slightly larger)

all optimized with help from Strife Onizuka (thanks)

Now they have. ^_^

I liked how you reused the last element in the fast versions of the reverse. I thought it was a mistake at first. You didn't need to subtract one, you know the end length is always odd so just shifting it down chops off the bit. I changed them to use --c instead of c--, it simplifies the bytecode and is faster in LSO.

*Since RShift copies the sign bit, we can force any negative number to be -1 with a bitwise-or. This makes the math fundamentally faster.

/*//-- Get Last Index of String Test in String Source --//*/
integer uGetStrIdxRev( string vStrSrc, string vStrTst ){
  integer vIdxFnd =
    llStringLength( vStrSrc ) - llStringLength( vStrTst ) -
    llStringLength( llList2String( llParseStringKeepNulls(
    vStrSrc, (list)vStrTst, [] ), -1) );
  return (vIdxFnd | (vIdxFnd >> 31));
}

/*//-- Get Last Index of List Test in List Source --//*/
integer uGetLstIdxRev( list vLstSrc, list vLstTst ){
  integer vIdxFnd = (vLstSrc != []) - (vLstTst != []) -
    (llParseString2List( llList2String( llParseStringKeepNulls( llDumpList2String( vLstSrc,
    ";" ), (list)llDumpList2String( vLstTst, ";" ), [] ), -1), (list)";", [] ) != []);
  return (vIdxFnd | (vIdxFnd >> 31));
}

NOTE: uGetLstIdxRev only works for string data types, and you may want to modify the separator to suit your needs (it should be something that WON'T be in any of the data)

*I might suggest using "|" instead of ";", or maybe an obscure unicode character.

/*//-- Reverse List Order (fast version) --//*/
list uListRevF( list vLstSrc ){
  integer vIntCnt = (vLstSrc != []) - 1;
  while (vIntCn--){
    vLstSrc += llList2List( vLstSrc, vIntCnt, vIntCnt );
  }
  return llList2List( vLstSrc, (vLstSrc != []) >> 1, -1 );
}

/*//-- Reverse List Order (small version) --//*/
list uListRevS( list vLstSrc ){
  integer vIntCnt = (vLstSrc != []) - 1;
  while (vIntCnt--){
    vLstSrc = llDeleteSubList( vLstSrc + llList2List( vLstSrc, vIntCnt, vIntCnt ), vIntCnt, vIntCnt );
  }
  return vLstSrc;
}

/*//-- Reverse String Order (fast version) --//*/
string uStringRevF( string vStrSrc ){
  integer vIntCnt = llStringLength( vStrSrc ) - 1;
  while(vIntCnt--){
    vStrSrc += llGetSubString( vStrSrc, vIntCnt, vIntCnt );
  }
  return llGetSubString( vStrSrc, llStringLength( vStrSrc ) >> 1, -1);
}

/*//-- Reverse String Order (small version) --//*/
string uStringRevS( string vStrSrc ){
  integer vIntCnt = llStringLength( vStrSrc ) - 1;
  while(vIntCnt--){
    vStrSrc = llDeleteSubString( vStrSrc + llGetSubString( vStrSrc, vIntCnt, vIntCnt ), vIntCnt, vIntCnt );
  }
  return vStrSrc;
}

sweet I like 'em, and I really should've used those OR'd returns...much obliged

ETA:
originally I was using (~(--c)) for the while loops but that just looked sloppy

they'll all get posted to the wiki shortly, and added to the library there, I have no intention of of Licensing them so I'll just add a "please cedit"... it's no big deal to me if people don't, but strife has my explicit permission to add one for his changes (which I'll be crediting anyway)

Further Edit:
well (--c) in the while test fails to catch the leading element, but if it's moved to the first parameter it works... I kinda wanted to avoid that because of the oddity that while order of execution is last to first in math operation, it's first to last in parameter execution

example:
x = "0123456789";
y = 5;
(llGetSubString( x, ++y, y ) == "6"
(llGetSubString( x, y, ++y ) == "56"

and I really hate depending on non-explicit order of execution in LSL, it's just asking for trouble. it works... now... but who could say in the future. (although it *should* be safe considering the layout for prim params, but that could be preserved with a find, whereas the internal math may begin to fail for other things...

not that LL would EVER commit such a heinous act... ::cough-choke-sputter-wipe_beverage_off_screen::

oh yeah, shaving off the last element DOES save about ~2ms in lsl... although ~- is the better way to do it...

I just realized that --c was a mistake. I'm reverting.

It wouldn't copy the first element, I should have realized that immediately.

I needn't take credit, I get around enough, my name's in enough history logs. If people come looking, they will find me. They always find me

lol isn't that the way it always is...

I have a few other functions I just libraried that'll take some of the same optimizations... I don't like how I handled uMatchListFwd, but I couldn't see and easier way, I do need to apply the increment decrement hack (-~/~-) to that one though

ETA: ok it WAS faster to skip the extra element... right until I found the infinite loop on zero element lists =X... throwing in the @-if/jump loop structure for the finals as I update them