Operators

Operators play an import role in assign-statements and expressions; complex expressions are created by combining two or more expressions using operators.

Operator classes and priorities

Arithmetic and bit operators (+ - * / % | ^ & << >> ~)
Boolean operators (! || && ^^)
Relational operators (== <= != >= < >)
Post- and pre-increment/decrement operators (++ --)
Assignment operators (= *= /= %= &= += -= |= ^= >>= <<=)

High priority : ! ~ -(unary negation)
Medium priority : * / % &
Low priority : + - | ^ || && ^^ == <= != >= < > >> <<

Example:

    // first evaluate the expression 3*2, then subtract the result (6) // from 20, then add 10. Thus, the result is 24.
    int i = 10 + 20 - 3 * 2;

In order to create self contained subexpressions, for instance to assign priorities to them, an expression may be enclosed in () brackets:

Example:

    // first evaluate the expr (20-3), then multiply the result by 2 and // finally add 10. Thus the result is 44.
    int i = 10 + (20-3) * 2;

Assignment operators

The assignment operators are used to store the result value of an expression in a memory location, e.g. global and local variables, array and hashtable elements and class members.

The special assignment operator <= is used to copy objects by reference resp. bind "volatile" objects. Example:

String s,t;
s<=t; // delete previous "s" object, make "s" reference "t" (read-only)
      // "s" is valid until "t" is deleted.
t="hello, world.";
print s;

If the = char is preceded by an arithmetic operator, the previous value of a memory location can be taken into account when calculating its new seizure.

Consequently, the assignment operators are shortforms for the following assignment operations:

    l *= <expression>; equals l = l * <expression>;
    l /= <expression>; equals l = l / <expression>;
    l %= <expression>; equals l = l % <expression>;
    l &= <expression>; equals l = l & <expression>;
    l += <expression>; equals l = l + <expression>;
    l -= <expression>; equals l = l - <expression>;
    l |= <expression>; equals l = l | <expression>;
    l ^= <expression>; equals l = l ^ <expression>;
    l >>= <expression>; equals l = l >> <expression>;
    l <<= <expression>; equals l = l << <expression>;

Caveat: The target of an assignment must not be a complex expression, a.b.c.d=e; is not allowed for instance. The reason for this is that TkScript is not a strictly typed language and it very hard to tell (especially in case of such indirect assignments) which type an object actually has at runtime (i.e. which members/methods are actually available).

The following assignment targets are currently possible:

    myvar <assignop> <expr>;
    MyModule.myvar <assignop> <expr>;
    myclassinstance.member <assignop> <expr>;
    myarrayvar[] <assignop> <expr>;
    myhashvar[] <assignop> <expr>;
    myapiclassinstance.mymember <assignop> <expr>;
    myclassinstance.mymember <assignop> <expr>;
    myclassinstance.myarrayvar[] <assignop> <expr>;
    myclassinstance.myhashvar[] <assignop> <expr>;

The order of evaluation of subexpressions on the same priority level is not defined and rather up to the runtime module being used (e.g. JIT runtime vs. interpreted mode) so please do not assume left-to-right resp. right-to-left order evaluation.

Short-Circuit evaluation is not supported, i.e. all subexpressions are evaluated regardless whether the result of the entire expression could be determined already by its first subexpression:

Example:

    if(i && j && k) { /* ... */ }

This statement can be optimized like this:

Example:

    if i if j if k { /* ... */ }

Unary operators

Unary operators have the highest evaluation priority. In contrary to C++ or Java there is no unary typecast operator; this functionality is rather provided by builtin function calls (tcint(), tcfloat(), tcchar(), tcstring()).

Example:

    int i = -1; // negation, result is -1.

Example:

    int i = ~1; // bitwise not, result is -2 (0xFFFFFFFE on 32bit architectures)

Example:

    int i = !1; // logical not, result is 0

Binary operators

A + B: return sum of exprA and exprB
A - B: return exprA - exprB
A * B: return exprA * exprB
A / B: return exprA divided by exprB
A % B: return exprA modulo exprB
A | B: return exprA bitwise-or exprB
A ^ B: return exprA bitwise-eor exprB
A & B: return exprA bitwise-and exprB
A || B: return exprA logic-or exprB
A && B: return exprA logic-and exprB
A ^^ B: return exprA logic-eor exprB
A == B: return boolean result of comparison A equal B
A <= B: return boolean result of comparison A equal or less than B
A != B: return boolean result of comparison A unequal B
A >= B: return boolean result of comparison A equal or greater than B
A < B: return boolean result of comparison A less than B
A > B: return boolean result of comparison A greater than B

Ternary operators

A ? B : C: This operator is used to choose between two sub-expressions depending on the result of a conditional expression. Example:
```
int b=Arguments.numElements>0;
print "b is "+(b?"true":"false");
```

A <relop> B <relop> C: This operator is used to test ranges. Example:

int b=Arguments.numElements;
if(2<b<=4)
  print "got 3 or 4 arguments.";
else
  print "got "+b+" argument"+(b>1?"s":"")+".";

The streaming << operator

The << operator is used to (de-)serialize objects from and to I/O stream objects.

Example:

    String s="hello, world.";

    Buffer b; b.size=512; // instanciate a Buffer(Stream)

    b << s; // serialize the string into the Buffer(Stream)

    s="..."; trace s; // unset string

    b.offset=0; // reset stream offset

    s << b; // deserialize the string from the Buffer(Stream)

    trace "s="+s;

Also see class serialization.

Example: please see testfileio.tks.html .

back to index