|
|
| Line 1: |
Line 1: |
| <!-- BEGIN EDIT --> | | <hr height=2> |
|
| |
|
| {{NavNextPrev|prefix=LSL in Focus:_|prev=Types|topic=Language Topics in Focus|next=Floats}}
| |
|
| |
|
| __TOC__
| | <!-- table of edits --> |
| | | <table cellpadding=5 cellspacing=0 border=1> |
| Integers in LSL correspond roughly to integers in mathematics. They can be written in either the familiar decimal notation (e.g. 20, 0, -1) or [[#Hexadecimal Notation|hexadecimal]] (e.g. 0x14, 0x0, 0xFFFFFFFF).
| | <tr bgcolor=yellow> |
| | | <th colspan=2>Edits</th> |
| Integers in LSL are used in four distinct ways:
| | <th colspan=2>States</th></tr> |
| * Signed integers
| | <tr bgcolor=lime> |
| * Truth values (Booleans)
| | <td "style:font-color:yellow">Edit: llAbs()</td> |
| * Enumerations
| | <td> --EnCore Mayne 04:11, 10 September 2012 (PDT)</td> |
| * Bit vectors
| | <td valign=top>[[Image:LlAbs_old.jpg|border|40px]]</td> |
| | | <td valign=top>[[Image:LlAbs_edit.jpg|border|40px]]</td> |
| There are a three operators, namely: the assignment (=), the test for equality(==), and the test for inequality (!=) that are common to all uses with integers. Other than those the four different uses of integers generally involve separate sets of operators.
| | </tr></table> |
| | |
| == Signed Integers ==
| |
| This is the use of integers that corresponds to the normal use in mathematics. The only substantive difference is that in mathematics there are an infinite number of integers. In LSL, integers are limited to the range from -2,147,483,648 to 2,147,483,647. No commas or other separators are allowed when writing integers so these numbers would be written -2147483648 and 2147483647.
| |
| | |
| === Arithmetic Operators ===
| |
| LSL has the normal arithmetic operators +, -, *, and /. The first three have the same meaning as what you used in grade school '''as long as the result is in the range -2147483648 to 2147483647'''. If the result is outside that range, different rules apply. The typical scripter doesn't need to use numbers that are so big (or small), so there's no reason to feel you need to learn the details of what happens when the limits are exceeded. There are instances where it is actually useful to allow numbers to exceed the limits. For the details of what happens in that case, see the Integer Overflow section, below.
| |
| | |
| Division of integers in LSL is a variation on what you learned in elementary school. If the division results in a whole number, say 10/2, the answer is 5. But 15/2 is neither 7.5 nor 7 with a remainder of 1. Instead, it is exactly 7. Any remainder is simply thrown away. Alternatively, you can think of it as being rounded toward zero. It's more accurate to say "rounded toward zero" than "rounded down", because -15/2 is -7, not -8. If you're scripting something where you really want 15 divided by 2 to be 7.5, don't despair. You'll just need to use the "float" type instead of integers.
| |
| | |
| Closely related to integer division is the remainder operator, written as %. It gives you what would remain if you were to ask for integer division on the same numbers. Here are some examples:
| |
| <lsl> integer i; | |
| i = 15 % 2; // i is assigned the value 1
| |
| i = 15 % 4; // i is assigned the value 3
| |
| i = -15 % 4; // i is assigned the value -3</lsl>
| |
| | |
| If an attempt is made to divide by 0 (using either / or %), a run-time error occurs and script execution halts.
| |
| | |
| Each of the arithmetic operators also has a corresponding assignment type operation. For example
| |
| <lsl> integer x; | |
| integer y;
| |
| x += y; // Synonymous with x = x + y;
| |
| x -= y; // Synonymous with x = x - y;
| |
| x *= y; // Synonymous with x = x * y;
| |
| x /= y; // Synonymous with x = x / y;</lsl>
| |
| | |
| In addition, since incrementing or decrementing by 1 is quite common, there is a special unary operator for that. The operator is written ++ and is pronounced plus-plus. To increment the variable i by 1, we can write either ++i or i++. So for example
| |
| | |
| <lsl> integer i = 0; | |
| i++; // i now has the value of 1
| |
| ++i; // i now has the value of 2</lsl>
| |
| | |
| But the two operators are not identical, because i++ and ++i are expressions that can occur as part of a larger expression. When used as part of a larger expression, i++ contributes its value to the expression ''before'' it is incremented. For example, the fragment
| |
| | |
| <lsl> integer i = 0;
| |
| if (i++ == 0)
| |
| llSay( 0, "The value of i was 0 when the comparison was done" )
| |
| else
| |
| llSay( 0, "The value of i was 1 when the comparison was done" )</lsl>
| |
| | |
| would chat "The value of i was 0 when the comparison was done" even though i ends up with the value of 1. On the other hand, if we switch i++ to ++i, i.e.
| |
| | |
| <lsl> integer i = 0; | |
| if (++i == 0)
| |
| llSay( 0, "The value of i was 0 when the comparison was done" )
| |
| else
| |
| llSay( 0, "The value of i was 1 when the comparison was done" )</lsl>
| |
| | |
| the chat output would be "The value of i was 1 when the comparison was done".
| |
| | |
| The operator minus-minus (written --) works similarly.
| |
| | |
| === Comparison Operators ===
| |
| In addition to the arithmetic operators, there are also the normal integer comparison operators < (less than) and > (greater than). For "less than or equal", or "greater than or equal", there are two-character operators <= and >=. There can't be any space between the two characters of a two-character operator.
| |
| | |
| The result of a comparison operator is either 0 (representing '''FALSE''') or 1 (representing '''TRUE'''). See [[#Truth Values (Booleans)|Truth Values (Booleans)]].
| |
| | |
| === Integer Overflow ===
| |
| * During script execution, integers wraps from 2147483647 to -2147483648 in the normal way
| |
| * The compiler treats integers outside the range -2147483648 to 2147483647 somewhat strangely. No compile time warning or error is generated. (If the following explanation, doesn't make sense to you don't worry -- just know to avoid using numbers outside the valid range in your script.)
| |
| ** For an integer outside the range -2147483648 to 2147483647, the absolute value of the number is reduced to fall in the range 0 to 4294967295 (0xFFFFFFFF).
| |
| ** This number is then parsed as an unsigned 32 bit integer and cast to the corresponding signed integer.
| |
| ** If the value in the script had a negative sign, the sign of the internal representation is switched.
| |
| ** The net effect is that very large positive numbers get mapped to -1 and very large negative numbers get mapped to 1.
| |
| | |
| == Truth Values (Booleans) ==
| |
| There is not a special type for TRUE and FALSE in LSL. Instead, TRUE is defined to be the integer 1 and FALSE is defined to be the integer 0.
| |
| | |
| This has an interesting consequence in a conditional statement. Consider the following example
| |
| | |
| <lsl> integer i = 3; // 3 is neither TRUE nor FALSE | |
| if (i)
| |
| llSay( 0, "i is treated as being true." );
| |
| else
| |
| llSay( 0, "i is treated as being false." );
| |
| if (i == TRUE)
| |
| llSay( 0, "i is equal to TRUE." );
| |
| else
| |
| llSay( 0, "i is not equal to TRUE." );</lsl>
| |
| | |
| When run, the output will be
| |
| | |
| i is treated as being true.
| |
| i is not equal to TRUE.
| |
| | |
| This is because the condition in the '''if''' statement can be any integer. Any non-zero value will cause the ''true'' block or statement to be executed, while a zero value will cause the ''false'' block or statement to be executed.
| |
| | |
| The same zero/non-zero distinction is made wherever a truth value is expected. In what follows, we'll use the word '''true''' and '''false''' to mean non-zero versus zero, while '''TRUE''' and '''FALSE''' will mean one and zero.
| |
| | |
| === Truth Value Operators ===
| |
| | |
| There are three truth value operators in LSL:
| |
| * ! (representing '''not''')
| |
| * && (representing '''and''')
| |
| * || (representing '''or''')
| |
| | |
| The ! operator takes a single operand and evaluates to '''TRUE''' if the operand is false, and '''FALSE''' otherwise. For example
| |
| | |
| <lsl> integer i;
| |
| i = !(3 == 7); // 3 == 7 is FALSE, so i gets the value TRUE</lsl>
| |
| | |
| The && operator takes two operands and evaluates to '''TRUE''' if both its operands are true, and '''FALSE''' otherwise.
| |
| | |
| <lsl> i = (3 < 7) && (3 > 7); // 3 < 7 is TRUE, but (3 > 7) is FALSE, so i gets the value FALSE</lsl> | |
| | |
| The || operator takes two operands and evaluates to '''TRUE''' if either one of its operands are true, and '''FALSE''' otherwise.
| |
| | |
| <lsl> i = (3 < 7) || (3 > 7); // one of the operands (3 < 7) is TRUE, so i gets the value TRUE</lsl>
| |
| | |
| Like the binary arithmetic operators, && and || have a corresponding assignment type operator.
| |
| | |
| <lsl> integer x; | |
| integer y;
| |
| x &&= y; // Synonymous with x = x && y;
| |
| x ||= y; // Synonymous with x = x || y;</lsl>
| |
| | |
| === Statements Requiring Truth Values ===
| |
| There are four statement types that require a truth value condition:
| |
| * if
| |
| * for
| |
| * while
| |
| * do-while
| |
| | |
| == Enumerations ==
| |
| Many built-in functions have a parameter or return value that takes one of a fixed number of alternatives. For example, [[llAttachToAvatar]] has a single parameter which specifies the attachment point. The attachment point is specified to be an integer, but the specific integer corresponding to each attachment point is arbitrary. Since the numbers themselves have no significance, LSL defines names such as [[ATTACH_HEAD]], [[ATTACH_LFOOT]] and [[ATTACH_BELLY]], which are simply meaningful names for the arbitrary integers. Integers used in this way are called '''enumerations'''.
| |
| | |
| Generally, no operators besides the ubiquitous =, == and != are used with enumerations because there is no expected relationship between the arbitrarily selected integer values.
| |
| | |
| == Bit Vectors ==
| |
| | |
| === Bit Vector Operators ===
| |
| Analogous to the truth value operators, LSL defines three operators specifically for bit vectors:
| |
| | |
| * ~ (bitwise not)
| |
| * & (bitwise and)
| |
| * | (bitwise or)
| |
| | |
| In contract to the truth value operators, these operate independently on each bit position.
| |
| | |
| == Other Uses of Integers ==
| |
| | |
| Although the four uses described above cover all the ways that integers are used with LSL built-in functions, they are not really exhaustive of the ways integers ''can'' be used. There are algorithms in mathematics and computer science that mix arithmetic and bit vector operations, along with bit shift operators. LSL supports this kind of computation with the bit shift operators inherited from C:
| |
| | |
| * << shift bits left
| |
| * >> shift bits right
| |
| | |
| and their assignment analogs
| |
| | |
| * >>=
| |
| * <<=
| |
| | |
| Discussion of these algorithms is beyond the scope of this article, but see [http://graphics.stanford.edu/~seander/bithacks.html Bit Twiddling Hacks] for some examples.
| |
| | |
| == Type conversions ==
| |
| === Other types to integers ===
| |
| Casting a float to an integer has the same end effect as using the [[llFloor]] function.
| |
| === Integers to other types ===
| |
| | |
| == Differences between Integers in LSL and in C ==
| |
| Much of LSL is patterned after the C programming language, and integers are no exception. Programmers who already know C can immediately apply most of their understanding of integers to LSL.
| |
| | |
| Differences to note are
| |
| * The type must be spelled ''integer'' instead of ''int''.
| |
| * There are no size modifiers (short, long, ...). All integers are 32 bits.
| |
| * There is no unsigned modifier. All integers are signed.
| |
| * Comparison operators evaluate to an integer (1 or 0), as they did in C prior to C99.
| |
| * The && and || operators are strict, i.e. both operands are always evaluated, even if the result can be determined after evaluating the left operand.
| |
| | |
| == Hexadecimal Notation ==
| |
| There's actually not much use for hexadecimal notation in LSL. If you do feel a need to use it, you probably already know how it works. If not, you can consult {{Wikipedia|Hexadecimal notation|Wikipedia}}.
| |
| <!-- END EDIT -->
| |
