exp := derefexp '=' exp
exp:= derefexp '<-' exp
squirrel implements 2 kind of assignment: the normal assignment(=)
a=10;
and the "new slot" assignment.
a <- 10;
The new slot expression allows to add a new slot into a table(see Tables). If the slot already exists in the table it behaves like a normal assignment.
exp := exp_cond '?' exp1 ':' exp2
conditionally evaluate an expression depending on the result of an expression.
exp:= 'exp' op 'exp'
Squirrel supports the standard arithmetic operators +, -, *, / and %. Other than that is also supports compact operators (+=,-=,*=,/=,%=) and increment and decrement operators(++ and --);
a+=2; //is the same as writing a=a+2; x++ //is the same as writing x=x+1
All operators work normally with integers and floats; if one operand is an integer and one is a float the result of the expression will be float. The + operator has a special behavior with strings; if one of the operands is a string the operator + will try to convert the other operand to string as well and concatenate both together. For instances and tables, _tostring is invoked.
exp:= 'exp' op 'exp'
Relational operators in Squirrel are : == < <= > >= !=
These operators return null if the expression is false and a value different than null if the expression is true. Internally the VM uses the integer 1 as true but this could change in the future.
exp := exp op exp
exp := '!' exp
Logical operators in Squirrel are : && || !
The operator && (logical and) returns null if its first argument is null, otherwise returns its second argument. The operator || (logical or) returns its first argument if is different than null, otherwise returns the second argument.
The '!' operator will return null if the given value to negate was different than null, or a value different than null if the given value was null.
exp:= keyexp 'in' tableexp
Tests the existence of a slot in a table. Returns a value different than null if keyexp is a valid key in tableexp
local t=
{
foo="I'm foo",
[123]="I'm not foo"
}
if("foo" in t) dostuff("yep");
if(123 in t) dostuff();
exp:= instanceexp 'instanceof' classexp
Tests if a class instance is an instance of a certain class. Returns a value different than null if instanceexp is an instance of classexp.
exp:= 'typeof' exp
returns the type name of a value as string.
local a={},b="squirrel"
print(typeof a); //will print "table"
print(typeof b); //will print "string"
exp:= exp ',' exp
The comma operator evaluates two expression left to right, the result of the operator is the result of the expression on the right; the result of the left expression is discarded.
local j=0,k=0;
for(local i=0; i<10; i++ , j++)
{
k = i + j;
}
local a,k;
a = (k=1,k+2); //a becomes 3
exp:= 'exp' op 'exp'
exp := '~' exp
Squirrel supports the standard c-like bit wise operators &,|,^,~,<<,>> plus the unsigned right shift operator >>>. The unsigned right shift works exactly like the normal right shift operator(>>) except for treating the left operand as an unsigned integer, so is not affected by the sign. Those operators only work on integers values, passing of any other operand type to these operators will cause an exception.
tslots := ( ‘id’ ‘=’ exp | ‘[‘ exp ‘]’ ‘=’ exp ) [‘,’]
exp := ‘{’ [tslots] ‘}’
Creates a new table.
local a={} //create an empty table
A table constructor can also contain slots declaration; With the syntax:
id = exp [',']
a new slot with id as key and exp as value is created
local a=
{
slot1="I'm the slot value"
}
An alternative syntax can be
'[' exp1 ']' = exp2 [',']
A new slot with exp1 as key and exp2 as value is created
local a=
{
[1]="I'm the value"
}
both syntaxes can be mixed
local table=
{
a=10,
b="string",
[10]={},
function bau(a,b)
{
return a+b;
}
}
The comma between slots is optional.
exp:= ‘delegate’ parentexp : exp
Sets the parent of a table. The result of parentexp is set as parent of the result of exp, the result of the expression is exp (see Delegation).
exp:= ‘clone’ exp
Clone performs shallow copy of a table, array or class instance (copies all slots in the new object without recursion). If the source table has a delegate, the same delegate will be assigned as delegate (not copied) to the new table (see Delegation).
After the new object is ready the “_cloned” meta method is called (see Metamethods).
When a class instance is cloned the constructor is not invoked(initializations must rely on _cloned instead