void is not really a data type, more like lack of data type. It can only be used to tell the compiler that a function doesn't return any data.bool is a boolean type with only two possible values: true or false. The keywords true and false are constants of type bool that can be used as such in expressions.| type | min value | max value |
int8 | -128 | 127 |
int16 | -32,768 | 32,767 |
int | -2,147,483,648 | 2,147,483,647 |
int64 | -9,223,372,036,854,775,808 | 9,223,372,036,854,775,807 |
uint8 | 0 | 255 |
uint16 | 0 | 65,535 |
uint | 0 | 4,294,967,295 |
uint64 | 0 | 18,446,744,073,709,551,615 |
As the scripting engine has been optimized for 32 bit datatypes, using the smaller variants is only recommended for accessing application specified variables. For local variables it is better to use the 32 bit variant.
int32 is an alias for int, and uint32 is an alias for uint.
| type | range of values | smallest positive value | maximum digits |
float | +/- 3.402823466e+38 | 1.175494351e-38 | 6 |
double | +/- 1.7976931348623158e+308 | 2.2250738585072014e-308 | 15 |
Rounding errors will occur if more digits than the maximum number of digits are used.
Curiousity: Real numbers may also have the additional values of positive and negative 0 or infinite, and NaN (Not-a-Number). For float NaN is represented by the 32 bit data word 0x7fc00000.
When declaring a variable with a type modifier, the type modifier affects the type of all variables in the list. Example:
int[] a, b, c;
a, b, and c are now arrays of integers.
When declaring arrays it is possible to define the initial size of the array by passing the length as a parameter to the constructor. The elements can also be individually initialized by specifying an initialization list. Example:
int[] a; // A zero-length array of integers
int[] b(3); // An array of integers with 3 elements
int[] c = {,3,4,}; // An array of integers with 4 elements, where
// the second and third elements are initialized
Each element in the array is accessed with the indexing operator. The indices are zero based, i.e the range of valid indices are from 0 to length - 1.
a[0] = some_value;
An array also have two methods. length() allow you to determine how many elements are in the array, and resize() lets you resize the array.
Value types behave much like the primitive types, in that they are allocated on the stack and deallocated when the variable goes out of scope. Only the application can register these types, so you need to check with the application's documentation for more information about the registered types.
Reference types are allocated on the memory heap, and may outlive the initial variable that allocates them if another reference to the instance is kept. All script declared classes are reference types. Interfaces are a special form of reference types, that cannot be instanciated, but can be used to access the objects that implement the interfaces without knowing exactly what type of object it is.
obj o; // An object is instanciated
o = obj(); // A temporary instance is created whose
// value is assigned to the variable
null.
obj o; obj@ a; // a is initialized to null obj@ b = @o; // b holds a reference to o
b.ModifyMe(); // The method modifies the original object
if( a is null ) // Verify if the object points to an object
{
@a = @b; // Make a hold a reference to the same object as b
}
Not all types allow a handle to be taken. Neither of the primitive types can have handles, and there may exist some object types that do not allow handles. Which objects allow handles or not, are up to the application that registers them.
Object handle and array type modifiers can be combined to form handles to arrays, or arrays of handles, etc.
There are two types of string constants supported in the AngelScript language, the normal double quoted string, and the documentation strings, called heredoc strings.
The normal strings are written between double quotation marks (") or single quotation marks (')1. Inside the constant strings some escape sequences can be used to write exact byte values that might not be possible to write in your normal editor.
| sequence | value | description
|
\0 | 0 | null character |
\\ | 92 | back-slash |
\' | 39 | single quotation mark (apostrophe) |
\" | 34 | double quotation mark |
\n | 10 | new line feed |
\r | 13 | carriage return |
\t | 9 | tab character |
\xFF | 0xFF | FF should be exchanged for the hexadecimal number representing the byte value wanted |
\uFFFF | 0xFFFF | FFFF should be exchanged for the hexadecimal number representing the unicode code point |
\UFFFFFFFF | 0xFFFFFFFF | FFFFFFFF should be exchanged for the hexadecimal number representing the unicode code point |
string str1 = "This is a string with \"escape sequences\"."; string str2 = 'If single quotes are used then double quotes can be included without "escape sequences".';
The heredoc strings are designed for inclusion of large portions of text without processing of escape sequences. A heredoc string is surrounded by triple double-quotation marks ("""), and can span multiple lines of code. If the characters following the start of the string until the first linebreak only contains white space, it is automatically removed by the compiler. Likewise if the characters following the last line break until the end of the string only contains white space this is also remove, including the linebreak.
string str = """ This is some text without "escape sequences". This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. This is some text. """;
If more than one string constants are written in sequence with only whitespace or comments between them the compiler will concatenate them into one constant.
string str = "First line.\n"
"Second line.\n"
"Third line.\n";
The escape sequences \u and \U will add the specified unicode code point as a UTF8 encoded sequence. Only valid unicode 5.1 code points are accepted, i.e. code points between U+D800 and U+DFFF (reserved for surrogate pairs) or above U+10FFFF are not accepted.
1) The application can change the interpretation of single quoted strings by setting an engine property. If this is done the first character in the single quoted string will be interpreted as a single uint value instead of a string literal.
1.5.9