As the Executor is a Javabased interpreter, it should understand most Java commands. Besides this, it has been designed to work with basic Pascal syntax.
Reference tables
Here are the (not necessarily complete) lists of usable operators and builtin functions:
Supported Operators
Symbol 
Alternative symbols 
Description (iff = if and only if) 
< 
:= 
Value assignment (including automatic variable declaration; < displayed as ← in standard highlighting mode, both displayed as = in C operator mode) 
+ 

Addition or positive sign (or string concatenation as in Java) 
 

Subtraction or negative sign 
* 

Multiplication 
/ 

Division (effect depends on operand types: with two integer operands, it results in an integer division) 
div 

Integer division (among integer operands, as in Pascal; displayed as / in C operator mode) 
mod 
% 
Modulo operation among integer operands (i.e. results in the integral division remainder; displayed as % in C operator mode) 
= 
== 
Comparison operator (true iff both operands are equal; displayed as == in C operator mode) 
<> 
!=, ≠ 
Comparison operator (true iff both operands differ; displayed as ≠ in standard highlighting mode, as != in C operator mode) 
< 

Comparison operator (less than) 
> 

Comparison operator (greater than) 
<= 
≤ 
Comparison operator (less than or equal to; displayed as ≤ in standard highlighting mode, as <= in C operator mode) 
>= 
≥ 
Comparison operator (greater than or equal to; displayed as ≥ in standard highlighting mode, as >= in C operator mode) 
and 
&& 
Logical AND (true iff both Boolean operands, e.g. comparisons, evaluate to true; displayed as && in C operator mode) 
or 
 
Logical OR (true iff at least one of the two Boolean operands evaluates to true; displayed as  in C operator mode) 
not 
! 
Logical negation (true iff the Boolean operand evaluates to false; displayed as ! in C operator mode) 
xor 
^

Bitwise exclusive OR between integral numbers (displayed as ^ in C operator mode), may also be used for logical XOR, but one of <>, !=, ≠ should be preferred in this case

& 

Bitwise AND between integral numbers 
 

Bitwise OR between integral numbers 
˜ 

Bitwise negation of an integral number 
<< 
shl 
Leftshift operator: m << n results in the integer value where all bits of integer m were shifted left by n 
>> 
shr 
Rightshift operator: m shr n results in the integer value where all bits of integer m were shifted right by n

? : 

Ternary conditional expression: If the Boolean expression before the question mark is true, then the result will be the value of the expression between ? and :, otherwise the value of the expression after the colon. 
Most operators are binary operators in infix notation, i.e. the operator symbol is placed between its two operands, e.g. a + 3; the operators not and ~ are unary prefix operators, i.e. they are placed before their single operand, e.g. not isDifficult, whereas the operator symbols + and  may either be binary infix (addition, concatenation, or subtraction) or unary prefix operands (sign). The conditional operator pair is ternary as it combines three expressions as operands, e.g.: text ← (b > 17.3) ? "large" : "small".
Operator precedence rules (for the Executor) are similar to those of Java or C:
Operator Precedence (from highest to lowest)
Category 
Operators 
Associativity 
Unary 
+, , !, not, ˜

← Right to Left

Multiplicative 
*, /, div, %, mod

Left to Right → 
Additive 
+, 

Left to Right → 
Shift 
<<, shl, >>, shr

Left to Right → 
Relational 
<, <=, ≤, >, >=, ≥ 
— 
Equality 
=, ==, <>, !=, ≠ 
Left to Right → 
Bitwise AND

& 
Left to Right → 
XOR

^, xor

Left to Right → 
Bitwise OR



Left to Right → 
Logical AND

&&, and

Left to Right → 
Logical OR

, or

Left to Right → 
Conditional 
? :

← Right to Left 
(Assignment) 
<, :=

— 
This means that e.g. logical operators like and have lower precedence than comparison operators. But be aware that this does not necessarily hold for languages like Pascal, which have much less priority levels, such that e.g. the and operator ranks like multiplication above comparison operators. Hence, an expression like
a = 3 and b < 5
may work perfectly in the Executor but will be illegal in exported Pascal code! So better use parentheses to avoid ambiguity (the code generators can hardly read your intentions):
(a = 3) and (b < 5)
Note: Incomplete and abbreviated comparisons like in
a > 2 and < 17
or
2 < a < 17
(the upper example has an incomplete comparison after the and operator, the lower "expression" would actually try to compare the Boolean result of comparison 2 < a with the numerical value 17) are illegal in Structorizer — as they are in most (but not all) highlevel languages.
Like in C or Java, you may directly apply some arithmetic operators to character values, but the result will always be a numeric value: subtracting two characters will compute their code difference, but adding or subtracting an integer offset to or from a character will not result in a character but in its numerical code:
'8'  '0' evaluates to 8 alright, 'A' + 17 will not result in 'R' but in 82 ( it requires a builtin function to obtain the character itself: chr('A' + 17) )
Builtin Numerical Functions
Function 
Description 
abs(x) 
absolute value of number x; x 
min(x, y) 
minimum of numbers x and y 
max(x, y) 
maximum of numbers x and y 
round(x) 
nearest integral number to number x (result is of an integral type)

ceil(x) 
smallest integral number greater than or equal to number x (result is of a floatingpoint type, though) 
floor(x) 
greatest integral number less than or equal to number x (result is of a floatingpoint type, though) 
sgn(x) 
signum of number x: either 1, 0, or 1 (depending on the sign of x)

signum(x) 
like sgn(x) but returning a floatingpoint value

sqr(x) 
square of number x; x * x 
sqrt(x) 
square root of number x (illegal if x is negative) 
exp(x) 
exponential value with the Euler number e as base and x as exponent: e^{x} 
log(x) 
natural logarithm (i.e. based on the Euler number e) of number x; ln x; log_{e}x

pow(x, y) 
computes x to the power of y (where x, y, and the result are floatingpoint numbers): x^{y} 
cos(x) 
cosine of x where x is to be given in radians 
sin(x) 
sine of x where x is to be given in radians 
tan(x) 
tangent of x where x is to be given in radians 
acos(x) 
arcus cosine of x (inverse cos function) where x must be between 1.0 and +1.0, the result will be in radians

asin(x) 
arcus sine of x (inverse sin function) where x must be between 1.0 and 1.0, the result will be in radians

atan(x) 
arcus tangent of x (inverse tan function), result will be in radians (as with asin, acos)

toRadians(x) 
converts angle x from degrees to radians 
toDegrees(x) 
converts angle x from radians to degrees 
random(n) 
returns an integral pseudorandom number in the range between 0 and n1 for positive n, or between n+1 and 0 for negative n

Builtin Nonnumerical Functions
length(s: string): int 
returns the number of characters the string s consists of. 
length(a: array): int 
returns the number of elements the array a consists of. 
lowercase(c: char): char
lowercase(s: string): string 
returns a lowercase representation of character c
returns a string representation of string s where all letters are converted to lowercase 
uppercase(c: char): char
uppercase(s: string): string 
returns an uppercase representation of character c
returns a string representation of string s where all letters are converted to uppercase 
pos(sub: string; s: string): int 
returns the first starting position of substring sub within string s (position ≥ 1 if any, otherwise 0). 
copy(s: string; i: int; n: int): string 
returns the substring of string s that starts at character postion i (i ≥ 1) and has at most n characters 
split(s: string; sep: string): array of string split(s: string; sep: char ): array of string 
breaks the string s around each occurrence of substring or character sep into pieces (some may be empty) and returns them as array 
trim(s: string): string 
returns the trimmed string s, i.e. without leading and trailing whitespaces

strcmp(s1: string, s2: string): int 
returns 1, 0, or +1 if string s1 is lexicographically less than, equal to, or greater than s2, respectively 
ord(c: char): int 
returns the ASCII code of the character c (or of the first character of string c) 
chr(n: int): char 
returns the ASCII character coded by number n 
isArray(value): bool 
returns true if the argument is an array 
isString(value): bool 
returns true if the argument is a string 
isNumber(value): bool 
returns true if the argument is an integral or floatingpoint number 
isChar(value): bool 
returns true if the argument is a character 
isBool(value): bool 
returns true if the argument is a Boolean value 
Builtin Procedures
Procedure 
Description 
inc(v) 
increments variable v by one; equivalent to: v ← v + 1 
dec(v) 
decrements variable v by one; equivalent to: v ← v  1 
inc(v, i) 
increments variable v by number i; equivalent to: v ← v + i 
dec(v, d) 
decrements variable v by number d; equivalent to: v ← v  d 
randomize() 
is to reinitialize the pseudo number generator used for random(n) 
insert(w, s, i) 
inserts string w at character position i into string s (i ≥ 1)

delete(s, i, n) 
removes the next n characters from position i out of string s (i ≥ 1)

File I/O
The API for working with text files was introduced on user request with release 3.26 and allows to store values as well as to produce and analyse text files with Structorizer. And of course to demonstrate the handling of resources that are controlled by the operating system.
After having opened a text file by means of one of the opening functions fileOpen, fileCreate, or fileAppend, the respective file can be accessed via the obtained "file handle" (which in fact is an integral number > 0 if the acquisition of the file was successful). Negative results of an opening attempt or 0 stand for some kind of failure and do not entitle to any kind of file access. After having worked with a successfully acquired file, on the other hand, it has to be released by means of procedure fileClose.
File API subroutines
Procedure / Function 
Description 
fileOpen(path: string): int 
opens a text file for reading (requires that the file exists), returns a file handle (see below) 
fileCreate(path: string): int 
creates a new file for writing (may override an existing one), returns a file handle (see below) 
fileAppend(path: string): int 
opens a file for writing at end (preserving the previus content), returns a file handle (see below) 
fileEOF(handle: int): boolean 
returns true if the input file is exhausted (no more characters readable) 
fileRead(handle: int): object 
returns the next readable data as int or double value, flat array, or string (see below) 
fileReadChar(handle: int): char 
returns the next readable character (see below) 
fileReadInt(handle: int): int 
returns the value of the next integer literal if the next token is an integer literal (see below) 
fileReadDouble(handle: int): double 
returns the value of the next integer literal if the next token is an integer literal (see below) 
fileReadLine(handle: int): string 
returns the (remainder of) the current line without the newline character (which is yet consumed, see below) 
fileWrite(handle: int; value) 
Writes the given value to the file without adding any separator character 
fileWriteLine(handle: int; value) 
Writes the given value to the file and appends a newline character 
fileClose(handle: int) 
Closes the file identified by the handle (see below) 
(Note that the "newline character" is an abstraction, which may physically be represented by a character sequence on some platforms.)
For a detailed description and several examples see File API .
Plugin subroutines
In addition to the directly builtin functions and procedures described above, Structorizer has a plugin mechanism, where socalled "Diagram Controllers" may be incorporated in. These may add more functions and procedures, which work in a similar way to builtin ones, but are only usable when the respective execution context of the plugin is activated. By now, the only such plugin is Turtleizer, however. See the respective User Guide page for details and how to enable its execution context. 