The integer type represents a number without decimals, as opposed to the float type which can have decimals.

Formally, the integer type is a 32-bit signed integer, which means that its range is from -2147483648 to 2147483647. Integer constants are specified just by entering the digits. They can optionally be preceded with a minus sign for negative numbers, but rigorously speaking, the sign is not part of the number, but an operator, and thus it takes code space. There are two exceptions: if the number is immediately after a type cast prefix, or if it is in the globals initialization, the sign will be part of the number and not take code space.

If an integer constant is out of the range of a 32-bit unsigned integer, the result will automatically be -1; otherwise, the result will be the value taken as a signed 32-bit integer. For example:

integer j = 12345678901234567890;

will set j to -1, but

integer j = 4294967294; // that's 2^32-2

will set j to -2.

Another way to specify an integer constant is in hexadecimal (also called base 16 or radix 16). The digits for hexadecimal are the normal digits from 0 to 9 plus the letters from A to F (case doesn't matter), making a total of 16 digits available (A is ten, B is eleven, and so on until F which is fifteen). In LSL, an hexadecimal number is entered by prefixing it with a zero and an ex; for example, 0x12abcd34 is an integer expressed in hexadecimal, equivalent to the decimal number 313249076. Since case doesn't matter, 0X12AbCd34 is the same number.

Unlike other languages which inspired the syntax of LSL, LSL does not support octal (base 8) constants.

When a float is converted to an integer, the value is rounded towards zero, i.e. truncating the decimals. For example, (integer)-3.7 results in the integer -3, and (integer)3.7 results in the integer 3. If the float is too big to fit in an integer, the result is -2147483648. For example, (integer)1e30 gives the integer -2147483648. Note that that's different from the result of specifying a too big integer constant, which is -1.

For other rounding methods, see llFloor (round a float down towards negative infinity), llCeil (round up towards positive infinity), and llRound (round to closest integer).

Conversion of an integer to string results in the integer being converted to its decimal expression. For example, (string)-12345 results in the string "-12345", and (string)0x12ABCD34 results in the string "313249076".

Conversion of a string to an integer follows some special rules.

• If the string starts with "0x" or "0X", the integer will be taken as hexadecimal, but not if it starts with "-0x" or "-0X".
  • After the "0x" or "0X", a sequence of digits from 0 to 9 and letters from A to F, in either upper or lower case, will be taken as the hexadecimal number.
  • Any remaining characters after the last valid hexadecimal digit will be ignored.
  • If there are no valid hexadecimal characters after the "0x" or "0X", the result will be zero.
  • If the hexadecimal number is too big to fit an integer, the result will be -1.
• Otherwise, it will be taken as decimal. A decimal number consists of:
  • Any number of spaces (or other spacing characters, namely tabs, line feeds, vertical tabs, form feeds, or carriage returns).
  • One optional sign, either plus or minus.
  • One or more decimal digits.
  • Any remaining characters after the last valid decimal digit will be ignored.
  • If the decimal number is not valid (does not follow the above rules), the result will be zero.
  • If the decimal number is too big to fit an integer, the result will be -1.

Type cast of an integer to/from vector, rotation, or key is not supported. Type cast of a list to integer is not supported either. Type cast of an integer to list results in a list containing that integer as the only element, just as when any other type is converted to list.

• 342 is a constant representing the integer 342.
• 0x1 is a constant representing the integer 1.
• 0XA is a constant representing the integer 10.
• 3. is not an integer constant; it is a float constant.

• (string)0xA gives the string "10".
• (integer)"\n +123abc" gives the integer 123. Note that \n is the line feed character (popularly known as newline).
• (integer)" + 123abc" gives the integer 0, because there's a space after the sign.
• (integer)" ++123abc" gives the integer 0, because there's more than one sign.
• (integer)"stuff123" gives the integer 0, because there's no digit at the beginning.
• (integer)"-123" gives the integer -123.
• (integer)"0123" gives the integer 123. Again, octal is not supported here either.
• (integer)"-0x3" gives the integer 0. Since it does not start with "0x" but with a minus sign, it follows decimal rules.
• (integer)"0x3" gives the integer 3.
• (integer)"0x2astuff" gives the integer 42 (0x2A in hexadecimal).
• (integer)"0xcafeteria" gives the integer 51966 (0xCAFE in hexadecimal). The t is not an hexadecimal digit, so the parsing finishes there. However, c, a, f and e are valid hexadecimal digits

• Automatic type conversion between float and integer