Sambar Server CScript Operators

Sambar Server Documentation

CScript Operators

Assignment Operators

Assignment operators are really just binary operators. The simplest example is '=', which takes the value on the right and places it into the variable on the left.

= assignment

+= addition assignment

-= subtraction assignment

*= multiplication assignment

/= division assignment

%= remainder/modulus assignment

&= bitwise AND assignment

|= bitwise OR assignment

^= bitwise exclusive OR assignment

<<= left shift assignment

>>= right shift assignment

So, for example, 'i += j' is equivalent to 'i = i + j' (see complete list of equivalents below). The value to the left of the assignment operator has to be a variable where a result can be stored.

Arithmetic Operators

The following are the most common arithmetic operators:

+ Addition

- Subtraction

* Multiplication

/ Division

% Modulo (remainder from integer division)

+ Addition

Unless parens are used to order evaluation, operator precedence specifies that *, / and % be performed before + or - in an expression. The following table shows the precedence of all operators:

Operator Associativity Description

( ) left-to-right Parenthesis

! ~ ++ -- - * & right-to-left Unary

* / % left-to-right Multiply, Divide Modulus

+ - left-to-right Add, Subtract

>> << left-to-right Shift Right, Left

> < = left-to-right Greater, Less Than

== != left-to-right Equal, Not Equal

& left-to-right Bitwise AND

^ left-to-right Bitwise Exclusive OR

| left-to-right Bitwise OR

&& left-to-right Logical AND

|| left-to-right Logical OR

?: right-to-left Conditional Expression

= += -= etc. right-to-left Assignment

, left-to-right Comma

Note:

The associativity of an operator gives the order in which expressions involving operators of the same precedence are evaluated.
Operators on the same line have the same precedence, and are evaluated in the order given by the associativity.
To specify a different order of evaluation you can use parentheses.
Truth and false in C is represented by numbers being non-zero and zero respectively (although logical operators always return 1 or 0).
Don't make the mistake of using '=' when you meant '=='.
The evaluation of expressions containing the logical AND (&&) and OR (||) operators is always left-to-right, and stops when the outcome is known.

C has some operators which allow abbreviation of certain types of arithmetic assignment statements.

Shorthand Equivalent

i++; i = i + 1;

++i; i = i + 1;

i--; i = i - 1;

--i; i = i - 1;

a += 22; a = a + 22;

a -= 22; a = a - 22;

a *= 22; a = a * 22;

a /= 22; a = a / 22;

a %= 22; a = a % 22;

For auto-increment (++) and decrement (--), if the operator occurs before the variable name (i.e. --i;) change the value of the variable before evaluating the remainder of the expression:

Shorthand Equivalent

a = i-- * b; a = i * b;
i = i - i;

a = --i * b; i = i - 1;
a = i * b

Unary Operators

Unary operators are operators that only take one argument.

sizeof(i) the number of bytes of storage allocated to i

+123 positive 123

-123 negative 123

~i one's complement (bitwise complement)

!i logical negation (i.e., 1 if i is zero, 0 otherwise)

*i returns the value stored at the address pointed to by i NOT SUPPORTED!

&i returns the address in memory of i

++i adds one to i, and returns the new value of i

--i subtracts one from i, and returns the new value of i

i++ adds one to i, and returns the old value of i

i-- subtracts one from i, and returns the old value of i

i[j] array indexing

i (j) calling the function i with argument j

i.j returns member j of structure i NOT SUPPORTED!

i->j returns member j of structure pointed to by i NOT SUPPORTED!

Bit Operators

C has several operators for logical bit-operations. For example,

x = x & 0177;

forms the bit-wise AND of x and 0177, effectively retaining only the last seven bits of x. Other operators are:

Operator Description

| inclusive OR

^ exclusive OR

~ 1's complement

! logical not

<< left shift

>> right shift

Comma Operator

C allows you to put multiple expression in the same statement, separated by a comma. The expressions are evaluated in left-to-right order. The value of the overall expression is then equal to that of the rightmost expression. For example:

Shorthand Equivalent

i = ((j = 2), 3); i = 3; j = 2;

myfunct (i, (j = 2, j + 1), 1); j = 2; myfunct (i, 3, 1);

The comma operator has the lowest precedence, so it is always executed last when evaluating an expression. Both of the above examples are artifical, and not very useful. The comma operator can be useful when used in for and while loops.

=	assignment
+=	addition assignment
-=	subtraction assignment
*=	multiplication assignment
/=	division assignment
%=	remainder/modulus assignment
&=	bitwise AND assignment
\|=	bitwise OR assignment
^=	bitwise exclusive OR assignment
<<=	left shift assignment
>>=	right shift assignment

+	Addition
-	Subtraction
*	Multiplication
/	Division
%	Modulo (remainder from integer division)
+	Addition

Operator	Associativity	Description
( )	left-to-right	Parenthesis
*! ~ ++ -- - &**	right-to-left	Unary
* / %	left-to-right	Multiply, Divide Modulus
+ -	left-to-right	Add, Subtract
>> <<	left-to-right	Shift Right, Left
> < =	left-to-right	Greater, Less Than
== !=	left-to-right	Equal, Not Equal
&	left-to-right	Bitwise AND
^	left-to-right	Bitwise Exclusive OR
\|	left-to-right	Bitwise OR
&&	left-to-right	Logical AND
\|\|	left-to-right	Logical OR
?:	right-to-left	Conditional Expression
= += -= etc.	right-to-left	Assignment
,	left-to-right	Comma

Shorthand	Equivalent
i++;	i = i + 1;
++i;	i = i + 1;
i--;	i = i - 1;
--i;	i = i - 1;
a += 22;	a = a + 22;
a -= 22;	a = a - 22;
*a = 22;**	a = a * 22;
a /= 22;	a = a / 22;
a %= 22;	a = a % 22;

Shorthand	Equivalent
*a = i-- b;**	a = i * b; i = i - i;
*a = --i b;**	i = i - 1; a = i * b

sizeof(i)	the number of bytes of storage allocated to i
+123	positive 123
-123	negative 123
~i	one's complement (bitwise complement)
!i	logical negation (i.e., 1 if i is zero, 0 otherwise)
*i	returns the value stored at the address pointed to by i NOT SUPPORTED!
&i	returns the address in memory of i
++i	adds one to i, and returns the new value of i
--i	subtracts one from i, and returns the new value of i
i++	adds one to i, and returns the old value of i
i--	subtracts one from i, and returns the old value of i
i[j]	array indexing
i (j)	calling the function i with argument j
i.j	returns member j of structure i NOT SUPPORTED!
i->j	returns member j of structure pointed to by i NOT SUPPORTED!

Operator	Description
\|	inclusive OR
^	exclusive OR
~	1's complement
!	logical not
<<	left shift
>>	right shift

Shorthand	Equivalent
i = ((j = 2), 3);	i = 3; j = 2;
myfunct (i, (j = 2, j + 1), 1);	j = 2; myfunct (i, 3, 1);