LSL Hacks - Revision history

Gwyneth Llewelyn: /* llGetListLength({{LSL Param|myList}}) and ({{LSL Param|myList}} != []) */ just adding a few `s to enhance readability`


2023-06-11T10:59:46Z
llGetListLength({{LSL Param|myList}}) and ({{LSL Param|myList}} != []):  just adding a few <code>s to enhance readability

				
				
				
				
				
				← Older revision
				Revision as of 03:59, 11 June 2023
				
Line 45:
Line 45:
*Less readable *Less readable
*Will likely be removed in [[LSL3]]{{Footnote|Plans for LSL3 are still being worked out, nothing has been finalized, no release date has been set, LSL3 may in-fact never happen.}} *Will likely be removed in [[LSL3]]{{Footnote|Plans for LSL3 are still being worked out, nothing has been finalized, no release date has been set, LSL3 may in-fact never happen.}}
*Mono's llGetListLength function has been optimized and is about 100% faster than list!=[]; *Mono's [[llGetListLength]] function has been optimized and is about 100% faster than <code>list!=[]</code>;



== ++{{LSL Param|c}} and {{LSL Param|c}}++ == == ++{{LSL Param|c}} and {{LSL Param|c}}++ ==



Gwyneth Llewelyn: Added Ama Omega's archive of MOAP hacks; promoted to LSL Library category
2023-06-11T10:57:16Z
Added Ama Omega's archive of MOAP hacks; promoted to LSL Library category

				
				
				
				
				
				← Older revision
				Revision as of 03:57, 11 June 2023
				
Line 303:
Line 303:
|} |}



Implementations of division as a whole are more complex than implementations of multiplication. This includes the algorithmic implementation on a hardware level. Because of this, multiplication is faster than division. Many compilers will automatically 'optimize' these sort of tiny things where possible. Only 'where possible' because sometimes floating point rounding error can make an output difference. LSL doesn't do it at all. Implementations of division as a whole are more complex than implementations of multiplication. This includes the algorithmic implementation on a hardware level. Because of this, multiplication is faster than division. Many compilers will automatically 'optimize' these sort of tiny things where possible. Only 'where possible' because sometimes floating-point rounding error can make an output difference. LSL doesn't do it at all.



For example, x/2.0 will have the same output as x*0.5, but will run faster. For example, x/2.0 will have the same output as x*0.5, but will run faster.
Line 314:
Line 314:
*May be less intuitive depending on implementation. *May be less intuitive depending on implementation.
*In the scheme of things, the time difference is tiny. Still interesting regardless! *In the scheme of things, the time difference is tiny. Still interesting regardless!

== HTML-on-a-prim hacks ==

All sorts of tricks you never thought that the SL Viewer was able to do with [[MOAP]]:

[[User:Ama_Omega/archive/lsl_hacks]]



= Footnotes = = Footnotes =
{{Footnotes}} {{Footnotes}}

[[Category:LSL Library]]



Gwyneth Llewelyn: /* (c & power_of_two_minus_one) instead of (c % power_of_two) */ Fix confusing mix of  and  which broke formatting
2023-06-10T23:09:15Z
(c & power_of_two_minus_one) instead of (c % power_of_two):  Fix confusing mix of <source> and <syntaxhighlight> which broke formatting

				
				
				
				
				
				← Older revision
				Revision as of 16:09, 10 June 2023
				
Line 287:
Line 287:
Instead of using the modulus operator with a power of two (such as 2^2 or 4), the bitwise AND operator can be used with the value of the power of two minus one (such as 3 instead of 4). Instead of using the modulus operator with a power of two (such as 2^2 or 4), the bitwise AND operator can be used with the value of the power of two minus one (such as 3 instead of 4).



<syntaxhighlight lang="lsl2">if(var & 3);</source> will work the same as <source lang="lsl2">if(var % 4);</syntaxhighlight> <syntaxhighlight lang="lsl2">if(var & 3);</syntaxhighlight> will work the same as <syntaxhighlight lang="lsl2">if(var % 4);</syntaxhighlight>



'''Pros''' '''Pros'''



Jenna Huntsman: Add note about speed claims. Update formatting.
2022-07-14T13:49:01Z
Add note about speed claims. Update formatting.

				
				
				
				
				
				← Older revision
				Revision as of 06:49, 14 July 2022
				
Line 3:
Line 3:
= Hacks = = Hacks =
A page dedicated to LSL Hacks, those things that make your code so much better but at the same time so much worse. A page dedicated to LSL Hacks, those things that make your code so much better but at the same time so much worse.

{{KBwarning|width=55%|The below comments in regards to speed is unverified on modern simulator versions, and thus cannot be assumed to be true.<br>'''Always test execution speed claims for yourself.'''}}
{{#if: {{#if:
Variable hover text stuff. Variable hover text stuff.
Line 18:
Line 20:
Instead of passing a valid key as the forth parameter of the llMessageLinked function, a string value can be used. When the link_message event is triggered, the key can be typecast to a string (implicitly or explicitly) without any value degradation. Instead of passing a valid key as the forth parameter of the llMessageLinked function, a string value can be used. When the link_message event is triggered, the key can be typecast to a string (implicitly or explicitly) without any value degradation.



<source lang="lsl2">llMessageLinked(LINK_THIS, 10, "Hello", "World!")</source> <syntaxhighlight lang="lsl2">llMessageLinked(LINK_THIS, 10, "Hello", "World!")</syntaxhighlight>



'''Pros''' '''Pros'''
Line 83:
Line 85:
By passing the key value to a conditional, if it is valid and not a NULL_KEY then it will execute the true branch.   By passing the key value to a conditional, if it is valid and not a NULL_KEY then it will execute the true branch.  



<source lang="lsl2">integer isKey(key in) { <syntaxhighlight lang="lsl2">integer isKey(key in) {
     if(in) return 2;      if(in) return 2;
     return (in == NULL_KEY);      return (in == NULL_KEY);
}</source> }</syntaxhighlight>



'''Pros''' '''Pros'''
Line 165:
Line 167:



'''Examples:''' '''Examples:'''
<source lang="lsl2"> <syntaxhighlight lang="lsl2">
integer i = (integer)-1; // sets i to -1 and saves 1 byte integer i = (integer)-1; // sets i to -1 and saves 1 byte
float f = (float)-1.0; // sets f to -1.0 and saves 1 byte float f = (float)-1.0; // sets f to -1.0 and saves 1 byte
</source> </syntaxhighlight>



'''Note:''' Don't use <code>(integer)(-1)</code> or <code>(float)(-1.0)</code> as that destroys the magic. Put the minus sign immediately after the closing parenthesis of the type cast. '''Note:''' Don't use <code>(integer)(-1)</code> or <code>(float)(-1.0)</code> as that destroys the magic. Put the minus sign immediately after the closing parenthesis of the type cast.
Line 189:
Line 191:
|} |}



<source lang="lsl2">(llToLower( "Ü" ) == "Ü"); //-- yields TRUE for LSO, and FALSE for MONO. <syntaxhighlight lang="lsl2">(llToLower( "Ü" ) == "Ü"); //-- yields TRUE for LSO, and FALSE for MONO.
(llToLower( "Ü" ) != "Ü"); //-- yields TRUE for MONO, and FALSE for LSO.</source> (llToLower( "Ü" ) != "Ü"); //-- yields TRUE for MONO, and FALSE for LSO.</syntaxhighlight>



'''Pros''' '''Pros'''
Line 205:
Line 207:
|} |}



<source lang="lsl2">(llGetListEntryType( (list)((key)"") ) & 1); //-- yields TRUE for LSO, and FALSE for MONO. <syntaxhighlight lang="lsl2">(llGetListEntryType( (list)((key)"") ) & 1); //-- yields TRUE for LSO, and FALSE for MONO.
(llGetListEntryType( (list)((key)"") ) >> 2); //-- yields TRUE for MONO, and FALSE for LSO.</source> (llGetListEntryType( (list)((key)"") ) >> 2); //-- yields TRUE for MONO, and FALSE for LSO.</syntaxhighlight>



'''Pros''' '''Pros'''
Line 220:
Line 222:
| '''Discoverer''': Pedro Oval | '''Discoverer''': Pedro Oval
|} |}
<source lang="lsl2">(""!="x")  //-- yields -1 for LSO, 1 for MONO</source> <syntaxhighlight lang="lsl2">(""!="x")  //-- yields -1 for LSO, 1 for MONO</syntaxhighlight>
'''Comments''' '''Comments'''



Any nonempty string works for the right hand side. Just keep the empty string on the left. Appears to yield a strcmp of the UTF-8 strings under LSO, and a real boolean result (yielding either 0 or 1 and nothing else) under Mono. Any non-empty string works for the right hand side. Just keep the empty string on the left. Appears to yield a strcmp of the UTF-8 strings under LSO, and a real boolean result (yielding either 0 or 1 and nothing else) under Mono.



'''Pros''' '''Pros'''
Line 233:
Line 235:






<source lang="lsl2">~(""!="x")  //-- yields FALSE for LSO, -2 for MONO</source> <syntaxhighlight lang="lsl2">~(""!="x")  //-- yields FALSE for LSO, -2 for MONO</syntaxhighlight>



'''Pros''' '''Pros'''
Line 240:
Line 242:
* Result is directly usable as an <code>if</code> condition, for example: * Result is directly usable as an <code>if</code> condition, for example:



:<source lang="lsl2">if (~(""!="x")) llOwnerSay("VM is Mono"); else llOwnerSay("VM is LSO");</source> :<syntaxhighlight lang="lsl2">if (~(""!="x")) llOwnerSay("VM is Mono"); else llOwnerSay("VM is LSO");</syntaxhighlight>



'''Cons''' '''Cons'''
Line 246:
Line 248:






<source lang="lsl2">!~(""!="x")  //-- yields TRUE for LSO, FALSE for MONO <syntaxhighlight lang="lsl2">!~(""!="x")  //-- yields TRUE for LSO, FALSE for MONO
!~-(""!="x")  //-- yields FALSE for LSO, TRUE for MONO</source> !~-(""!="x")  //-- yields FALSE for LSO, TRUE for MONO</syntaxhighlight>



'''Pros''' '''Pros'''
Line 257:
Line 259:






<source lang="lsl2">llList2Key([], 0)=="" //-- yields TRUE for MONO, FALSE for LSO</source> <syntaxhighlight lang="lsl2">llList2Key([], 0)=="" //-- yields TRUE for MONO, FALSE for LSO</syntaxhighlight>



'''Cons''' '''Cons'''
Line 285:
Line 287:
Instead of using the modulus operator with a power of two (such as 2^2 or 4), the bitwise AND operator can be used with the value of the power of two minus one (such as 3 instead of 4). Instead of using the modulus operator with a power of two (such as 2^2 or 4), the bitwise AND operator can be used with the value of the power of two minus one (such as 3 instead of 4).



<source lang="lsl2">if(var & 3);</source> will work the same as <source lang="lsl2">if(var % 4);</source> <syntaxhighlight lang="lsl2">if(var & 3);</source> will work the same as <source lang="lsl2">if(var % 4);</syntaxhighlight>



'''Pros''' '''Pros'''



ObviousAltIsObvious Resident:  tag to 
2015-01-25T20:34:33Z
<lsl> tag to <source>

				
				
				
				
				
				← Older revision
				Revision as of 13:34, 25 January 2015
				
Line 18:
Line 18:
Instead of passing a valid key as the forth parameter of the llMessageLinked function, a string value can be used. When the link_message event is triggered, the key can be typecast to a string (implicitly or explicitly) without any value degradation. Instead of passing a valid key as the forth parameter of the llMessageLinked function, a string value can be used. When the link_message event is triggered, the key can be typecast to a string (implicitly or explicitly) without any value degradation.



<lsl>llMessageLinked(LINK_THIS, 10, "Hello", "World!")</lsl> <source lang="lsl2">llMessageLinked(LINK_THIS, 10, "Hello", "World!")</source>



'''Pros''' '''Pros'''
Line 83:
Line 83:
By passing the key value to a conditional, if it is valid and not a NULL_KEY then it will execute the true branch.   By passing the key value to a conditional, if it is valid and not a NULL_KEY then it will execute the true branch.  



<lsl>integer isKey(key in) { <source lang="lsl2">integer isKey(key in) {
     if(in) return 2;      if(in) return 2;
     return (in == NULL_KEY);      return (in == NULL_KEY);
}</lsl> }</source>



'''Pros''' '''Pros'''
Line 165:
Line 165:



'''Examples:''' '''Examples:'''
<lsl> <source lang="lsl2">
integer i = (integer)-1; // sets i to -1 and saves 1 byte integer i = (integer)-1; // sets i to -1 and saves 1 byte
float f = (float)-1.0; // sets f to -1.0 and saves 1 byte float f = (float)-1.0; // sets f to -1.0 and saves 1 byte
</lsl> </source>



'''Note:''' Don't use <code>(integer)(-1)</code> or <code>(float)(-1.0)</code> as that destroys the magic. Put the minus sign immediately after the closing parenthesis of the type cast. '''Note:''' Don't use <code>(integer)(-1)</code> or <code>(float)(-1.0)</code> as that destroys the magic. Put the minus sign immediately after the closing parenthesis of the type cast.
Line 189:
Line 189:
|} |}



<lsl>(llToLower( "Ü" ) == "Ü"); //-- yields TRUE for LSO, and FALSE for MONO. <source lang="lsl2">(llToLower( "Ü" ) == "Ü"); //-- yields TRUE for LSO, and FALSE for MONO.
(llToLower( "Ü" ) != "Ü"); //-- yields TRUE for MONO, and FALSE for LSO.</lsl> (llToLower( "Ü" ) != "Ü"); //-- yields TRUE for MONO, and FALSE for LSO.</source>



'''Pros''' '''Pros'''
Line 205:
Line 205:
|} |}



<lsl>(llGetListEntryType( (list)((key)"") ) & 1); //-- yields TRUE for LSO, and FALSE for MONO. <source lang="lsl2">(llGetListEntryType( (list)((key)"") ) & 1); //-- yields TRUE for LSO, and FALSE for MONO.
(llGetListEntryType( (list)((key)"") ) >> 2); //-- yields TRUE for MONO, and FALSE for LSO.</lsl> (llGetListEntryType( (list)((key)"") ) >> 2); //-- yields TRUE for MONO, and FALSE for LSO.</source>



'''Pros''' '''Pros'''
Line 220:
Line 220:
| '''Discoverer''': Pedro Oval | '''Discoverer''': Pedro Oval
|} |}
<lsl>(""!="x")  //-- yields -1 for LSO, 1 for MONO</lsl> <source lang="lsl2">(""!="x")  //-- yields -1 for LSO, 1 for MONO</source>
'''Comments''' '''Comments'''



Line 233:
Line 233:






<lsl>~(""!="x")  //-- yields FALSE for LSO, -2 for MONO</lsl> <source lang="lsl2">~(""!="x")  //-- yields FALSE for LSO, -2 for MONO</source>



'''Pros''' '''Pros'''
Line 240:
Line 240:
* Result is directly usable as an <code>if</code> condition, for example: * Result is directly usable as an <code>if</code> condition, for example:



:<lsl>if (~(""!="x")) llOwnerSay("VM is Mono"); else llOwnerSay("VM is LSO");</lsl> :<source lang="lsl2">if (~(""!="x")) llOwnerSay("VM is Mono"); else llOwnerSay("VM is LSO");</source>



'''Cons''' '''Cons'''
Line 246:
Line 246:






<lsl>!~(""!="x")  //-- yields TRUE for LSO, FALSE for MONO <source lang="lsl2">!~(""!="x")  //-- yields TRUE for LSO, FALSE for MONO
!~-(""!="x")  //-- yields FALSE for LSO, TRUE for MONO</lsl> !~-(""!="x")  //-- yields FALSE for LSO, TRUE for MONO</source>



'''Pros''' '''Pros'''
Line 257:
Line 257:






<lsl>llList2Key([], 0)=="" //-- yields TRUE for MONO, FALSE for LSO</lsl> <source lang="lsl2">llList2Key([], 0)=="" //-- yields TRUE for MONO, FALSE for LSO</source>



'''Cons''' '''Cons'''
Line 285:
Line 285:
Instead of using the modulus operator with a power of two (such as 2^2 or 4), the bitwise AND operator can be used with the value of the power of two minus one (such as 3 instead of 4). Instead of using the modulus operator with a power of two (such as 2^2 or 4), the bitwise AND operator can be used with the value of the power of two minus one (such as 3 instead of 4).



<lsl>if(var & 3);</lsl> will work the same as <lsl>if(var % 4);</lsl> <source lang="lsl2">if(var & 3);</source> will work the same as <source lang="lsl2">if(var % 4);</source>



'''Pros''' '''Pros'''



Pedro Oval: /* Cast negative integer to integer */ Works for floats too!
2014-07-21T02:20:38Z
Cast negative integer to integer:  Works for floats too!

				
				
				
				
				
				← Older revision
				Revision as of 19:20, 20 July 2014
				
Line 153:
Line 153:
* Harder to read * Harder to read



== Cast negative integer to integer == == Cast negative number to itself ==



{| {{Prettytable|style=margin:0;}} {| {{Prettytable|style=margin:0;}}
Line 162:
Line 162:
When using a negative integer constant, add a type cast to integer. Under Mono, a type cast of a type to itself adds no extra code, and in the case of negatives, it can parse the number as a negative integer rather than adding a negate operator, saving 1 byte and being slightly faster. When using a negative integer constant, add a type cast to integer. Under Mono, a type cast of a type to itself adds no extra code, and in the case of negatives, it can parse the number as a negative integer rather than adding a negate operator, saving 1 byte and being slightly faster.



'''Example''' The same can be done with negative floating point constants: cast them to float.
 
'''Examples:'''
<lsl> <lsl>
integer i = (integer)-1; // sets i to -1 and saves 1 byte integer i = (integer)-1; // sets i to -1 and saves 1 byte
float f = (float)-1.0; // sets f to -1.0 and saves 1 byte
</lsl> </lsl>



'''Note:''' Don't use <code>(integer)(-1)</code> as that destroys the magic. Put the minus sign immediately after the closing parenthesis. '''Note:''' Don't use <code>(integer)(-1)</code> or <code>(float)(-1.0)</code> as that destroys the magic. Put the minus sign immediately after the closing parenthesis of the type cast.



'''Pros''' '''Pros'''
* Easier to read than 0xFFFFFFFF, applicable to more numbers without significant loss of readability * Easier to read than 0xFFFFFFFF
* Applicable to more numbers without significant loss of readability
* Applicable to floats too
* Less byte code under Mono * Less byte code under Mono






Pedro Oval: /* Cast negative integer to integer */ Add caveat
2014-07-21T02:05:45Z
Cast negative integer to integer:  Add caveat

				
				
				
				
				
				← Older revision
				Revision as of 19:05, 20 July 2014
				
Line 166:
Line 166:
integer i = (integer)-1; // sets i to -1 and saves 1 byte integer i = (integer)-1; // sets i to -1 and saves 1 byte
</lsl> </lsl>

'''Note:''' Don't use <code>(integer)(-1)</code> as that destroys the magic. Put the minus sign immediately after the closing parenthesis.



'''Pros''' '''Pros'''



Pedro Oval: Add hack on saving bytes with negative integers; fix 0xFFFFFFFF entry re Mono
2014-07-21T02:00:44Z
Add hack on saving bytes with negative integers; fix 0xFFFFFFFF entry re Mono

				
				
				
				
				
				← Older revision
				Revision as of 19:00, 20 July 2014
				
Line 140:
Line 140:



{| {{Prettytable|style=margin:0;}} {| {{Prettytable|style=margin:0;}}
| '''VM''': LSO (MONO unknown) | '''VM''': LSO, Mono
| '''Discover''': Void Singer | '''Discover''': Void Singer
|} |}



instead of using negative integer constants in code (does not apply to global declarations) use the 32bit hexadecimal notation. Works because the compiler does not optimize out the negation sign for integer literals (LSO confirmed, MONO unknown, but not harmful) instead of using negative integer constants in code (does not apply to global declarations) use the 32bit hexadecimal notation. Works because the compiler does not optimize out the negation sign for integer literals (LSO confirmed, Mono confirmed)



'''Pros''' '''Pros'''
* Faster (one less operation) * Faster (one less operation)
* Less Byte Code (2 bytes saved on the operation) * Less Byte Code (2 bytes saved on the operation under LSO, 1 under Mono)



'''Cons''' '''Cons'''
* Harder to read * Harder to read

== Cast negative integer to integer ==

{| {{Prettytable|style=margin:0;}}
| '''VM''': Mono
| '''Discoverer''': Pedro Oval
|}

When using a negative integer constant, add a type cast to integer. Under Mono, a type cast of a type to itself adds no extra code, and in the case of negatives, it can parse the number as a negative integer rather than adding a negate operator, saving 1 byte and being slightly faster.

'''Example'''
<lsl>
integer i = (integer)-1; // sets i to -1 and saves 1 byte
</lsl>

'''Pros'''
* Easier to read than 0xFFFFFFFF, applicable to more numbers without significant loss of readability
* Less byte code under Mono

'''Cons'''
* Not usable with LSO, as LSO still adds a type cast which is also 2 bytes, thus saving nothing



== VM Detection == == VM Detection ==



Pedro Oval: /* (c & power_of_two_minus_one) instead of (c % power_of_two) */ Mono memory saving advantage
2013-03-13T23:04:55Z
(c & power_of_two_minus_one) instead of (c % power_of_two):  Mono memory saving advantage

				
				
				
				
				
				← Older revision
				Revision as of 16:04, 13 March 2013
				
Line 260:
Line 260:



'''Pros''' '''Pros'''
*Saves one byte *Saves one byte in LSO, four in Mono
*500% faster in Mono. *500% faster in Mono.
*A few percent faster in LSL. *A few percent faster in LSL.



Pedro Oval: /* VM Detection */ Probably not that easy
2013-03-13T23:02:35Z
VM Detection:  Probably not that easy

				
				
				
				
				
				← Older revision
				Revision as of 16:02, 13 March 2013
				
Line 223:
Line 223:
'''Pros''' '''Pros'''
* Small code memory usage, as it uses no function calls (about 23/24 bytes code memory total resp.) * Small code memory usage, as it uses no function calls (about 23/24 bytes code memory total resp.)
* Easy to remember and thus to type 
* Gives a boolean result (0 or 1) in two variations. * Gives a boolean result (0 or 1) in two variations.

← Older revision		Revision as of 03:59, 11 June 2023
Line 45:		Line 45:
	*Less readable		*Less readable
	*Will likely be removed in [[LSL3]]{{Footnote\|Plans for LSL3 are still being worked out, nothing has been finalized, no release date has been set, LSL3 may in-fact never happen.}}		*Will likely be removed in [[LSL3]]{{Footnote\|Plans for LSL3 are still being worked out, nothing has been finalized, no release date has been set, LSL3 may in-fact never happen.}}
	*Mono's llGetListLength function has been optimized and is about 100% faster than list!=[];		*Mono's [[llGetListLength]] function has been optimized and is about 100% faster than <code>list!=[]</code>;

	== ++{{LSL Param\|c}} and {{LSL Param\|c}}++ ==		== ++{{LSL Param\|c}} and {{LSL Param\|c}}++ ==

← Older revision		Revision as of 03:57, 11 June 2023
Line 303:		Line 303:
	\|}		\|}

	Implementations of division as a whole are more complex than implementations of multiplication. This includes the algorithmic implementation on a hardware level. Because of this, multiplication is faster than division. Many compilers will automatically 'optimize' these sort of tiny things where possible. Only 'where possible' because sometimes floating point rounding error can make an output difference. LSL doesn't do it at all.		Implementations of division as a whole are more complex than implementations of multiplication. This includes the algorithmic implementation on a hardware level. Because of this, multiplication is faster than division. Many compilers will automatically 'optimize' these sort of tiny things where possible. Only 'where possible' because sometimes floating-point rounding error can make an output difference. LSL doesn't do it at all.

	For example, x/2.0 will have the same output as x*0.5, but will run faster.		For example, x/2.0 will have the same output as x*0.5, but will run faster.
Line 314:		Line 314:
	*May be less intuitive depending on implementation.		*May be less intuitive depending on implementation.
	*In the scheme of things, the time difference is tiny. Still interesting regardless!		*In the scheme of things, the time difference is tiny. Still interesting regardless!

			== HTML-on-a-prim hacks ==

			All sorts of tricks you never thought that the SL Viewer was able to do with [[MOAP]]:

			[[User:Ama_Omega/archive/lsl_hacks]]

	= Footnotes =		= Footnotes =
	{{Footnotes}}		{{Footnotes}}

			[[Category:LSL Library]]

← Older revision		Revision as of 16:09, 10 June 2023
Line 287:		Line 287:
	Instead of using the modulus operator with a power of two (such as 2^2 or 4), the bitwise AND operator can be used with the value of the power of two minus one (such as 3 instead of 4).		Instead of using the modulus operator with a power of two (such as 2^2 or 4), the bitwise AND operator can be used with the value of the power of two minus one (such as 3 instead of 4).

	<syntaxhighlight lang="lsl2">if(var & 3);</~~source~~> will work the same as <~~source~~ lang="lsl2">if(var % 4);</syntaxhighlight>		<syntaxhighlight lang="lsl2">if(var & 3);</syntaxhighlight> will work the same as <syntaxhighlight lang="lsl2">if(var % 4);</syntaxhighlight>

	'''Pros'''		'''Pros'''

← Older revision		Revision as of 06:49, 14 July 2022
Line 3:		Line 3:
	= Hacks =		= Hacks =
	A page dedicated to LSL Hacks, those things that make your code so much better but at the same time so much worse.		A page dedicated to LSL Hacks, those things that make your code so much better but at the same time so much worse.

			{{KBwarning\|width=55%\|The below comments in regards to speed is unverified on modern simulator versions, and thus cannot be assumed to be true.<br>'''Always test execution speed claims for yourself.'''}}
	{{#if:		{{#if:
	Variable hover text stuff.		Variable hover text stuff.
Line 18:		Line 20:
	Instead of passing a valid key as the forth parameter of the llMessageLinked function, a string value can be used. When the link_message event is triggered, the key can be typecast to a string (implicitly or explicitly) without any value degradation.		Instead of passing a valid key as the forth parameter of the llMessageLinked function, a string value can be used. When the link_message event is triggered, the key can be typecast to a string (implicitly or explicitly) without any value degradation.

	<~~source~~ lang="lsl2">llMessageLinked(LINK_THIS, 10, "Hello", "World!")</~~source~~>		<syntaxhighlight lang="lsl2">llMessageLinked(LINK_THIS, 10, "Hello", "World!")</syntaxhighlight>

	'''Pros'''		'''Pros'''
Line 83:		Line 85:
	By passing the key value to a conditional, if it is valid and not a NULL_KEY then it will execute the true branch.		By passing the key value to a conditional, if it is valid and not a NULL_KEY then it will execute the true branch.

	<~~source~~ lang="lsl2">integer isKey(key in) {		<syntaxhighlight lang="lsl2">integer isKey(key in) {
	if(in) return 2;		if(in) return 2;
	return (in == NULL_KEY);		return (in == NULL_KEY);
	}</~~source~~>		}</syntaxhighlight>

	'''Pros'''		'''Pros'''
Line 165:		Line 167:

	'''Examples:'''		'''Examples:'''
	<~~source~~ lang="lsl2">		<syntaxhighlight lang="lsl2">
	integer i = (integer)-1; // sets i to -1 and saves 1 byte		integer i = (integer)-1; // sets i to -1 and saves 1 byte
	float f = (float)-1.0; // sets f to -1.0 and saves 1 byte		float f = (float)-1.0; // sets f to -1.0 and saves 1 byte
	</~~source~~>		</syntaxhighlight>

	'''Note:''' Don't use <code>(integer)(-1)</code> or <code>(float)(-1.0)</code> as that destroys the magic. Put the minus sign immediately after the closing parenthesis of the type cast.		'''Note:''' Don't use <code>(integer)(-1)</code> or <code>(float)(-1.0)</code> as that destroys the magic. Put the minus sign immediately after the closing parenthesis of the type cast.
Line 189:		Line 191:
	\|}		\|}

	<~~source~~ lang="lsl2">(llToLower( "Ü" ) == "Ü"); //-- yields TRUE for LSO, and FALSE for MONO.		<syntaxhighlight lang="lsl2">(llToLower( "Ü" ) == "Ü"); //-- yields TRUE for LSO, and FALSE for MONO.
	(llToLower( "Ü" ) != "Ü"); //-- yields TRUE for MONO, and FALSE for LSO.</~~source~~>		(llToLower( "Ü" ) != "Ü"); //-- yields TRUE for MONO, and FALSE for LSO.</syntaxhighlight>

	'''Pros'''		'''Pros'''
Line 205:		Line 207:
	\|}		\|}

	<~~source~~ lang="lsl2">(llGetListEntryType( (list)((key)"") ) & 1); //-- yields TRUE for LSO, and FALSE for MONO.		<syntaxhighlight lang="lsl2">(llGetListEntryType( (list)((key)"") ) & 1); //-- yields TRUE for LSO, and FALSE for MONO.
	(llGetListEntryType( (list)((key)"") ) >> 2); //-- yields TRUE for MONO, and FALSE for LSO.</~~source~~>		(llGetListEntryType( (list)((key)"") ) >> 2); //-- yields TRUE for MONO, and FALSE for LSO.</syntaxhighlight>

	'''Pros'''		'''Pros'''
Line 220:		Line 222:
	\| '''Discoverer''': Pedro Oval		\| '''Discoverer''': Pedro Oval
	\|}		\|}
	<~~source~~ lang="lsl2">(""!="x") //-- yields -1 for LSO, 1 for MONO</~~source~~>		<syntaxhighlight lang="lsl2">(""!="x") //-- yields -1 for LSO, 1 for MONO</syntaxhighlight>
	'''Comments'''		'''Comments'''

	Any ~~nonempty~~ string works for the right hand side. Just keep the empty string on the left. Appears to yield a strcmp of the UTF-8 strings under LSO, and a real boolean result (yielding either 0 or 1 and nothing else) under Mono.		Any non-empty string works for the right hand side. Just keep the empty string on the left. Appears to yield a strcmp of the UTF-8 strings under LSO, and a real boolean result (yielding either 0 or 1 and nothing else) under Mono.

	'''Pros'''		'''Pros'''
Line 233:		Line 235:


	<~~source~~ lang="lsl2">~(""!="x") //-- yields FALSE for LSO, -2 for MONO</~~source~~>		<syntaxhighlight lang="lsl2">~(""!="x") //-- yields FALSE for LSO, -2 for MONO</syntaxhighlight>

	'''Pros'''		'''Pros'''
Line 240:		Line 242:
	* Result is directly usable as an <code>if</code> condition, for example:		* Result is directly usable as an <code>if</code> condition, for example:

	:<~~source~~ lang="lsl2">if (~(""!="x")) llOwnerSay("VM is Mono"); else llOwnerSay("VM is LSO");</~~source~~>		:<syntaxhighlight lang="lsl2">if (~(""!="x")) llOwnerSay("VM is Mono"); else llOwnerSay("VM is LSO");</syntaxhighlight>

	'''Cons'''		'''Cons'''
Line 246:		Line 248:


	<~~source~~ lang="lsl2">!~(""!="x") //-- yields TRUE for LSO, FALSE for MONO		<syntaxhighlight lang="lsl2">!~(""!="x") //-- yields TRUE for LSO, FALSE for MONO
	!~-(""!="x") //-- yields FALSE for LSO, TRUE for MONO</~~source~~>		!~-(""!="x") //-- yields FALSE for LSO, TRUE for MONO</syntaxhighlight>

	'''Pros'''		'''Pros'''
Line 257:		Line 259:


	<~~source~~ lang="lsl2">llList2Key([], 0)=="" //-- yields TRUE for MONO, FALSE for LSO</~~source~~>		<syntaxhighlight lang="lsl2">llList2Key([], 0)=="" //-- yields TRUE for MONO, FALSE for LSO</syntaxhighlight>

	'''Cons'''		'''Cons'''
Line 285:		Line 287:
	Instead of using the modulus operator with a power of two (such as 2^2 or 4), the bitwise AND operator can be used with the value of the power of two minus one (such as 3 instead of 4).		Instead of using the modulus operator with a power of two (such as 2^2 or 4), the bitwise AND operator can be used with the value of the power of two minus one (such as 3 instead of 4).

	<~~source~~ lang="lsl2">if(var & 3);</source> will work the same as <source lang="lsl2">if(var % 4);</~~source~~>		<syntaxhighlight lang="lsl2">if(var & 3);</source> will work the same as <source lang="lsl2">if(var % 4);</syntaxhighlight>

	'''Pros'''		'''Pros'''

← Older revision		Revision as of 13:34, 25 January 2015
Line 18:		Line 18:
	Instead of passing a valid key as the forth parameter of the llMessageLinked function, a string value can be used. When the link_message event is triggered, the key can be typecast to a string (implicitly or explicitly) without any value degradation.		Instead of passing a valid key as the forth parameter of the llMessageLinked function, a string value can be used. When the link_message event is triggered, the key can be typecast to a string (implicitly or explicitly) without any value degradation.

	<~~lsl~~>llMessageLinked(LINK_THIS, 10, "Hello", "World!")</~~lsl~~>		<source lang="lsl2">llMessageLinked(LINK_THIS, 10, "Hello", "World!")</source>

	'''Pros'''		'''Pros'''
Line 83:		Line 83:
	By passing the key value to a conditional, if it is valid and not a NULL_KEY then it will execute the true branch.		By passing the key value to a conditional, if it is valid and not a NULL_KEY then it will execute the true branch.

	<~~lsl~~>integer isKey(key in) {		<source lang="lsl2">integer isKey(key in) {
	if(in) return 2;		if(in) return 2;
	return (in == NULL_KEY);		return (in == NULL_KEY);
	}</~~lsl~~>		}</source>

	'''Pros'''		'''Pros'''
Line 165:		Line 165:

	'''Examples:'''		'''Examples:'''
	<~~lsl~~>		<source lang="lsl2">
	integer i = (integer)-1; // sets i to -1 and saves 1 byte		integer i = (integer)-1; // sets i to -1 and saves 1 byte
	float f = (float)-1.0; // sets f to -1.0 and saves 1 byte		float f = (float)-1.0; // sets f to -1.0 and saves 1 byte
	</~~lsl~~>		</source>

	'''Note:''' Don't use <code>(integer)(-1)</code> or <code>(float)(-1.0)</code> as that destroys the magic. Put the minus sign immediately after the closing parenthesis of the type cast.		'''Note:''' Don't use <code>(integer)(-1)</code> or <code>(float)(-1.0)</code> as that destroys the magic. Put the minus sign immediately after the closing parenthesis of the type cast.
Line 189:		Line 189:
	\|}		\|}

	<~~lsl~~>(llToLower( "Ü" ) == "Ü"); //-- yields TRUE for LSO, and FALSE for MONO.		<source lang="lsl2">(llToLower( "Ü" ) == "Ü"); //-- yields TRUE for LSO, and FALSE for MONO.
	(llToLower( "Ü" ) != "Ü"); //-- yields TRUE for MONO, and FALSE for LSO.</~~lsl~~>		(llToLower( "Ü" ) != "Ü"); //-- yields TRUE for MONO, and FALSE for LSO.</source>

	'''Pros'''		'''Pros'''
Line 205:		Line 205:
	\|}		\|}

	<~~lsl~~>(llGetListEntryType( (list)((key)"") ) & 1); //-- yields TRUE for LSO, and FALSE for MONO.		<source lang="lsl2">(llGetListEntryType( (list)((key)"") ) & 1); //-- yields TRUE for LSO, and FALSE for MONO.
	(llGetListEntryType( (list)((key)"") ) >> 2); //-- yields TRUE for MONO, and FALSE for LSO.</~~lsl~~>		(llGetListEntryType( (list)((key)"") ) >> 2); //-- yields TRUE for MONO, and FALSE for LSO.</source>

	'''Pros'''		'''Pros'''
Line 220:		Line 220:
	\| '''Discoverer''': Pedro Oval		\| '''Discoverer''': Pedro Oval
	\|}		\|}
	<~~lsl~~>(""!="x") //-- yields -1 for LSO, 1 for MONO</~~lsl~~>		<source lang="lsl2">(""!="x") //-- yields -1 for LSO, 1 for MONO</source>
	'''Comments'''		'''Comments'''

Line 233:		Line 233:


	<~~lsl~~>~(""!="x") //-- yields FALSE for LSO, -2 for MONO</~~lsl~~>		<source lang="lsl2">~(""!="x") //-- yields FALSE for LSO, -2 for MONO</source>

	'''Pros'''		'''Pros'''
Line 240:		Line 240:
	* Result is directly usable as an <code>if</code> condition, for example:		* Result is directly usable as an <code>if</code> condition, for example:

	:<~~lsl~~>if (~(""!="x")) llOwnerSay("VM is Mono"); else llOwnerSay("VM is LSO");</~~lsl~~>		:<source lang="lsl2">if (~(""!="x")) llOwnerSay("VM is Mono"); else llOwnerSay("VM is LSO");</source>

	'''Cons'''		'''Cons'''
Line 246:		Line 246:


	<~~lsl~~>!~(""!="x") //-- yields TRUE for LSO, FALSE for MONO		<source lang="lsl2">!~(""!="x") //-- yields TRUE for LSO, FALSE for MONO
	!~-(""!="x") //-- yields FALSE for LSO, TRUE for MONO</~~lsl~~>		!~-(""!="x") //-- yields FALSE for LSO, TRUE for MONO</source>

	'''Pros'''		'''Pros'''
Line 257:		Line 257:


	<~~lsl~~>llList2Key([], 0)=="" //-- yields TRUE for MONO, FALSE for LSO</~~lsl~~>		<source lang="lsl2">llList2Key([], 0)=="" //-- yields TRUE for MONO, FALSE for LSO</source>

	'''Cons'''		'''Cons'''
Line 285:		Line 285:
	Instead of using the modulus operator with a power of two (such as 2^2 or 4), the bitwise AND operator can be used with the value of the power of two minus one (such as 3 instead of 4).		Instead of using the modulus operator with a power of two (such as 2^2 or 4), the bitwise AND operator can be used with the value of the power of two minus one (such as 3 instead of 4).

	<~~lsl~~>if(var & 3);</~~lsl~~> will work the same as <~~lsl~~>if(var % 4);</~~lsl~~>		<source lang="lsl2">if(var & 3);</source> will work the same as <source lang="lsl2">if(var % 4);</source>

	'''Pros'''		'''Pros'''

← Older revision		Revision as of 19:20, 20 July 2014
Line 153:		Line 153:
	* Harder to read		* Harder to read

	== Cast negative ~~integer~~ to ~~integer~~ ==		== Cast negative number to itself ==

	{\| {{Prettytable\|style=margin:0;}}		{\| {{Prettytable\|style=margin:0;}}
Line 162:		Line 162:
	When using a negative integer constant, add a type cast to integer. Under Mono, a type cast of a type to itself adds no extra code, and in the case of negatives, it can parse the number as a negative integer rather than adding a negate operator, saving 1 byte and being slightly faster.		When using a negative integer constant, add a type cast to integer. Under Mono, a type cast of a type to itself adds no extra code, and in the case of negatives, it can parse the number as a negative integer rather than adding a negate operator, saving 1 byte and being slightly faster.

	'''~~Example~~'''		The same can be done with negative floating point constants: cast them to float.

			'''Examples:'''
	<lsl>		<lsl>
	integer i = (integer)-1; // sets i to -1 and saves 1 byte		integer i = (integer)-1; // sets i to -1 and saves 1 byte
			float f = (float)-1.0; // sets f to -1.0 and saves 1 byte
	</lsl>		</lsl>

	'''Note:''' Don't use <code>(integer)(-1)</code> as that destroys the magic. Put the minus sign immediately after the closing parenthesis.		'''Note:''' Don't use <code>(integer)(-1)</code> or <code>(float)(-1.0)</code> as that destroys the magic. Put the minus sign immediately after the closing parenthesis of the type cast.

	'''Pros'''		'''Pros'''
	* Easier to read than 0xFFFFFFFF~~, applicable~~ to more numbers without significant loss of readability		* Easier to read than 0xFFFFFFFF
			* Applicable to more numbers without significant loss of readability
			* Applicable to floats too
	* Less byte code under Mono		* Less byte code under Mono

← Older revision		Revision as of 19:05, 20 July 2014
Line 166:		Line 166:
	integer i = (integer)-1; // sets i to -1 and saves 1 byte		integer i = (integer)-1; // sets i to -1 and saves 1 byte
	</lsl>		</lsl>

			'''Note:''' Don't use <code>(integer)(-1)</code> as that destroys the magic. Put the minus sign immediately after the closing parenthesis.

	'''Pros'''		'''Pros'''

← Older revision		Revision as of 19:00, 20 July 2014
Line 140:		Line 140:

	{\| {{Prettytable\|style=margin:0;}}		{\| {{Prettytable\|style=margin:0;}}
	\| '''VM''': LSO ~~(MONO unknown)~~		\| '''VM''': LSO, Mono
	\| '''Discover''': Void Singer		\| '''Discover''': Void Singer
	\|}		\|}

	instead of using negative integer constants in code (does not apply to global declarations) use the 32bit hexadecimal notation. Works because the compiler does not optimize out the negation sign for integer literals (LSO confirmed, ~~MONO unknown, but not harmful~~)		instead of using negative integer constants in code (does not apply to global declarations) use the 32bit hexadecimal notation. Works because the compiler does not optimize out the negation sign for integer literals (LSO confirmed, Mono confirmed)

	'''Pros'''		'''Pros'''
	* Faster (one less operation)		* Faster (one less operation)
	* Less Byte Code (2 bytes saved on the operation)		* Less Byte Code (2 bytes saved on the operation under LSO, 1 under Mono)

	'''Cons'''		'''Cons'''
	* Harder to read		* Harder to read

			== Cast negative integer to integer ==

			{\| {{Prettytable\|style=margin:0;}}
			\| '''VM''': Mono
			\| '''Discoverer''': Pedro Oval
			\|}

			When using a negative integer constant, add a type cast to integer. Under Mono, a type cast of a type to itself adds no extra code, and in the case of negatives, it can parse the number as a negative integer rather than adding a negate operator, saving 1 byte and being slightly faster.

			'''Example'''
			<lsl>
			integer i = (integer)-1; // sets i to -1 and saves 1 byte
			</lsl>

			'''Pros'''
			* Easier to read than 0xFFFFFFFF, applicable to more numbers without significant loss of readability
			* Less byte code under Mono

			'''Cons'''
			* Not usable with LSO, as LSO still adds a type cast which is also 2 bytes, thus saving nothing

	== VM Detection ==		== VM Detection ==

← Older revision		Revision as of 16:04, 13 March 2013
Line 260:		Line 260:

	'''Pros'''		'''Pros'''
	*Saves one byte		*Saves one byte in LSO, four in Mono
	*500% faster in Mono.		*500% faster in Mono.
	*A few percent faster in LSL.		*A few percent faster in LSL.

← Older revision		Revision as of 16:02, 13 March 2013
Line 223:		Line 223:
	'''Pros'''		'''Pros'''
	* Small code memory usage, as it uses no function calls (about 23/24 bytes code memory total resp.)		* Small code memory usage, as it uses no function calls (about 23/24 bytes code memory total resp.)
	* Easy to remember and thus to type
	* Gives a boolean result (0 or 1) in two variations.		* Gives a boolean result (0 or 1) in two variations.

LSL Hacks - Revision history

Gwyneth Llewelyn: /* llGetListLength({{LSL Param|myList}}) and ({{LSL Param|myList}} != []) */ just adding a few s to enhance readability

Gwyneth Llewelyn: Added Ama Omega's archive of MOAP hacks; promoted to LSL Library category

Gwyneth Llewelyn: /* (c & power_of_two_minus_one) instead of (c % power_of_two) */ Fix confusing mix of and which broke formatting

Jenna Huntsman: Add note about speed claims. Update formatting.

ObviousAltIsObvious Resident: tag to

Pedro Oval: /* Cast negative integer to integer */ Works for floats too!

Pedro Oval: /* Cast negative integer to integer */ Add caveat

Pedro Oval: Add hack on saving bytes with negative integers; fix 0xFFFFFFFF entry re Mono

Pedro Oval: /* (c & power_of_two_minus_one) instead of (c % power_of_two) */ Mono memory saving advantage

Pedro Oval: /* VM Detection */ Probably not that easy

Gwyneth Llewelyn: /* llGetListLength({{LSL Param|myList}}) and ({{LSL Param|myList}} != []) */ just adding a few `s to enhance readability`