LSL Operators

Template:Needs Translation/LSL/es Template:Needs Translation/LSL/el Template:Needs Translation/LSL/he Template:Needs Translation/LSL/it Template:Needs Translation/LSL/nl Template:Needs Translation/LSL/hu Template:Needs Translation/LSL/no Template:Needs Translation/LSL/da Template:Needs Translation/LSL/sv Template:Needs Translation/LSL/tr Template:Needs Translation/LSL/pt Template:Needs Translation/LSL/ru Template:Needs Translation/LSL/th Template:Needs Translation/LSL/uk Template:Needs Translation/LSL/zh-Hans

/LSL

Operators are used to cause an operation (or mathematical action) to be performed on one (such as !) or two operands. The easy and common example is 1 + 2 where 1 and 2 are operands, and the + is the operator. This concept can be extended much further with LSL since operands can be variables with the special case of the assignment operators requiring that the left hand side be a variable.

The following table lists the operators in descending order of evaluation, i.e. higher in the table means higher evaluation precedence. Multiple operators on the same line share evaluation precedence. Parenthesize an expression if you need to force an evaluation order.

Operator	Description	Usage Example
()	parentheses: grouping and evaluation precedence	a * (b + c)
[]	brackets: list constructor	[a, 2, "this", 0.01]
(type)	typecasting	message = "The result is:" + (string)result;
! ~ ++ --	logical NOT, bitwise NOT, increment, decrement	counter++;
* / %	multiply/dot product, divide, modulus/cross product	rollover = (count + 1) % 5;
-	subtraction, negation	one = 3 - 2; neg1 = -1;
+	addition, string concatenation	two = 1 + 1; text = "Hello" + "World";
+	list concatenation	myList = [1, 2, 3] + [4, 5]; newList = oldList + addList;
<< >>	left shift, right shift	eight = 4 << 1;
< <= > >=	less than, less than or equal to, greater than, greater than or equal to	isFalse = (6 <= 4);
== !=	comparison: equal, not equal	isFalse = ("this" == "that");
&	bitwise AND	zero = 4 & 2; four = 4 & 4;
^	bitwise XOR	zero = 4 ^ 4; six = 4 ^ 2;
|	bitwise OR	four = 4 | 4; six = 4 | 2;
||	logical OR	isTrue = (FALSE || TRUE);
&&	logical AND	isFalse = (FALSE && TRUE);
= += -= *= /= %=	assignment	four = 4;

Note: modulus, like integer division cause a Script run-time error. Math Error when second operand equals 0

Note: Unlike all other binary operators, the % operator only allows integer or vector operands.

Note: Unlike most, if not all, other languages that use the C style && and || operators, both operands are always evaluated. For example,

if (TRUE || 1/0) llSay(PUBLIC_CHANNEL, "Aha!");

will cause a Math Error rather than say "Aha".

Note: The ++ (increment) and -- (decrement) have their effect on their number either before or after the number is evaluated when used in conditions dependent on whether they are before or after the number.

integer count;
if(!(++count)) // Is incremented then evaluated.
llSay(PUBLIC_CHANNEL, "Aha"); // Will not be said.

integer count;
if(!(count++)) // Is evaluated then incremented.
llSay(PUBLIC_CHANNEL, "Aha"); // Will be said.

Note: The order of precedence of boolean operators is unclear. It is possible that there is a bug in the expression parser, making precedence inconsistent, or it may simply be that || and && have equal precedence; testing is inconclusive. Thus, when in doubt, parenthesize. SubNote: As the above bug has been closed as expected behavior, one can only assume the boolean operators have equal precedence.

Note: The order of evaluation appears to be backwards from most languages. If the value of x starts as 1 then the first two conditions below evaluate false and the second two evaluate true:

(x && (x = 0) == 0 && x)

(x && (x = 0) == 0 && x == 0)

(x == 0 && (x = 0) == 0)

(x == 0 && (x = 0) == 0 && x)

Both sides are evaluated regardless of the the truth of either side.

Note: Equality test on lists does not compare contents, only the length.

+ Operator

result = left + right

Left Type	Right Type	Result Type	Description
integer	integer	integer	Adds left and right
integer	float	float	Adds left and right
float	integer	float	Adds left and right
string	string	string	Concatenates right onto the end of left.
list	*	list	Concatenates right onto the end of left.
*	list	list	Affixes left onto the start of right.
vector	vector	vector	Adds left and right
rotation	rotation	rotation	Adds left and right Not useful for combining rotations, use * or / instead.

Shorthand Operators

Alternatives to the simple '=' operator...

Simple assignment operator	Shorthand operator
a = a + 1	a += 1
a = a – 1	a -= 1
a = a * (n+1)	a *= (n+1)
a = a / (n+1)	a /= (n+1)
a = a % b	a %= b

 De Morgan's laws

Bitwise Equivalencies

AND	OR
~(a & b)	~a | ~b
~a & ~b	~(a | b)
a & ~b	~(~a | b)
~(a & ~b)	~a | b

Boolean Equivalencies

AND	OR
!(a && b)	!a || !b
!a && !b	!(a || b)
a && !b	!(!a || b)
!(a && !b)	!a || b

Due to  De Morgan's laws, by row, code in the AND column is logically equivalent to code in the OR. a and b need not be variables, they can be expressions. In certain circumstances these equivalencies can be used to simplify complex code. It is important not to confuse the two sets when using them. The first two rows depict De Morgan's laws as it is formulated, the second two build upon it.