Eingebaute Bausteine

Da der Executor ein Java-basierter Interpreter ist, versteht er die meisten Java-Befehle. Darüber hinaus wurde er so konzipiert, dass er mit grundlegender Pascal-Syntax arbeitet.

Referenztabellen

Nachfolgend sind die (nicht notwendigerweise vollständigen) Listen verwendbarer Operatoren und eingebauter Funktionen aufgeführt:

Unterstützte Operatoren

Symbol	Alternative Symbole	Beschreibung (gdw = genau dann wenn)
`<-`	`:=`	Wertzuweisung (einschließlich automatischer Variablendeklaration; `<-` wird im Standard-Hervorhebungsmodus als ← angezeigt, beide werden im C-Operatormodus als `=` angezeigt)
`+`		Addition oder positives Vorzeichen (oder String-Verkettung wie in Java)
`-`		Subtraktion oder negatives Vorzeichen
`*`		Multiplikation
`/`		Division (Wirkung hängt von den Operandentypen ab: bei zwei ganzzahligen Operanden ergibt sich eine Ganzzahldivision)
`div`		Ganzzahldivision (zwischen ganzzahligen Operanden, wie in Pascal; wird im C-Operatormodus als `/` angezeigt)
`mod`	`%`	Modulo-Operation zwischen ganzzahligen Operanden (d. h. ergibt den ganzzahligen Divisionsrest; wird im C-Operatormodus als `%` angezeigt)
`=`	`==`	Vergleichsoperator (wahr gdw beide Operanden gleich sind; wird im C-Operatormodus als `==` angezeigt)
`<>`	`!=`, `≠`	Vergleichsoperator (wahr gdw beide Operanden verschieden sind; wird im Standard-Hervorhebungsmodus als ≠ angezeigt, im C-Operatormodus als `!=`)
`<`		Vergleichsoperator (kleiner als)
`>`		Vergleichsoperator (größer als)
`<=`	`≤`	Vergleichsoperator (kleiner oder gleich; wird im Standard-Hervorhebungsmodus als ≤ angezeigt, im C-Operatormodus als `<=`)
`>=`	`≥`	Vergleichsoperator (größer oder gleich; wird im Standard-Hervorhebungsmodus als ≥ angezeigt, im C-Operatormodus als `>=`)
`and`	`&&`	Logisches UND (wahr gdw beide booleschen Operanden, z. B. Vergleiche, zu wahr ausgewertet werden; wird im C-Operatormodus als `&&` angezeigt)
`or`	`\|\|`	Logisches ODER (wahr gdw mindestens einer der beiden booleschen Operanden zu wahr ausgewertet wird; wird im C-Operatormodus als `\|\|` angezeigt)
`not`	`!`	Logische Negation (wahr gdw der boolesche Operand zu falsch ausgewertet wird; wird im C-Operatormodus als `!` angezeigt)
`xor`	`^`	Bitweises exklusives ODER zwischen ganzzahligen Zahlen (wird im C-Operatormodus als `^` angezeigt); kann auch für logisches XOR verwendet werden, aber einer der Operatoren `<>`, `!=`, `≠` sollte in diesem Fall bevorzugt werden
`&`		Bitweises UND zwischen ganzzahligen Zahlen
`\|`		Bitweises ODER zwischen ganzzahligen Zahlen
`˜`		Bitweise Negation einer ganzzahligen Zahl
`<<`	`shl`	Linksschiebeoperator: `m << n` ergibt den ganzzahligen Wert, bei dem alle Bits der ganzen Zahl `m` um `n` Stellen nach links verschoben wurden
`>>`	`shr`	Rechtsschiebeoperator: `m shr n` ergibt den ganzzahligen Wert, bei dem alle Bits der ganzen Zahl `m` um `n` Stellen nach rechts verschoben wurden
`? :`		Ternärer bedingter Ausdruck: Wenn der boolesche Ausdruck vor dem Fragezeichen wahr ist, ist das Ergebnis der Wert des Ausdrucks zwischen `?` und `:`, andernfalls der Wert des Ausdrucks nach dem Doppelpunkt.

Die meisten Operatoren sind binäre Operatoren in Infixnotation, d. h. das Operatorsymbol steht zwischen seinen beiden Operanden, z. B. a + 3; die Operatoren not und ˜ sind unäre Präfixoperatoren, d. h. sie stehen vor ihrem einzigen Operanden, z. B. not isDifficult, während die Operatorsymbole + und - entweder binäre Infix- (Addition, Verkettung oder Subtraktion) oder unäre Präfixoperanden (Vorzeichen) sein können. Das bedingte Operatorpaar ist ternär, da es drei Ausdrücke als Operanden kombiniert, z. B.: text ← (b > 17.3) ? "large" : "small".

Die Operatorvorrangregeln (für den Executor) ähneln denen von Java oder C:

Operatorvorrang (von höchster zu niedrigster Priorität)

Kategorie	Operatoren	Assoziativität
Unär	`+`, `-`, `!`, `not`, `˜`	← Rechts nach Links
Multiplikativ	`*`, `/`, `div`, `%`, `mod`	→ Links nach Rechts
Additiv	`+`, `-`	→ Links nach Rechts
Schieben	`<<`, `shl`, `>>`, `shr`	→ Links nach Rechts
Relational	`<`, `<=`, `≤`, `>`, `>=`, `≥`	—
Gleichheit	`=`, `==`, `<>`, `!=`, `≠`	→ Links nach Rechts
Bitweises UND	`&`	→ Links nach Rechts
XOR	`^`, `xor`	→ Links nach Rechts
Bitweises ODER	`\|`	→ Links nach Rechts
Logisches UND	`&&`, `and`	→ Links nach Rechts
Logisches ODER	`\|\|`, `or`	→ Links nach Rechts
Bedingt	`? :`	← Rechts nach Links
(Zuweisung)	`<-`, `:=`	—

Das bedeutet z. B., dass logische Operatoren wie and eine niedrigere Priorität haben als Vergleichsoperatoren. Beachten Sie jedoch, dass dies nicht notwendigerweise für Sprachen wie Pascal gilt, die weit weniger Prioritätsstufen haben, sodass z. B. der Operator and ähnlich wie die Multiplikation über den Vergleichsoperatoren eingestuft wird. Daher kann ein Ausdruck wie

a = 3 and b < 5

im Executor einwandfrei funktionieren, im exportierten Pascal-Code jedoch illegal sein! Verwenden Sie daher besser Klammern, um Mehrdeutigkeiten zu vermeiden (die Code-Generatoren können Ihre Absichten kaum erraten):

(a = 3) and (b < 5)

Hinweis: Unvollständige und abgekürzte Vergleiche wie in

a > 2 and < 17

oder

2 < a < 17

(Das obere Beispiel enthält nach dem Operator and einen unvollständigen Vergleich; der untere „Ausdruck" würde tatsächlich versuchen, das boolesche Ergebnis des Vergleichs 2 < a mit dem numerischen Wert 17 zu vergleichen) sind in Structorizer illegal — wie in den meisten (aber nicht allen) Hochsprachen.

Wie in C oder Java können Sie arithmetische Operatoren direkt auf Zeichenwerte anwenden, das Ergebnis ist jedoch immer ein numerischer Wert: Das Subtrahieren zweier Zeichen berechnet deren Codedifferenz, aber das Addieren oder Subtrahieren eines ganzzahligen Offsets zu oder von einem Zeichen ergibt nicht das Zeichen selbst, sondern dessen numerischen Code:

'8' - '0'  ergibt 8 (korrekt),
'A' + 17   ergibt nicht 'R' sondern 82
           (eine eingebaute Funktion ist erforderlich, um das Zeichen selbst zu erhalten: chr('A' + 17))

Eingebaute Funktionen

Eingebaute numerische Funktionen

Funktion	Beschreibung
`abs(x)`	Absolutwert der Zahl `x`; \|x\|
`min(x, y)`	Minimum der Zahlen `x` und `y`
`max(x, y)`	Maximum der Zahlen `x` und `y`
`round(x)`	Nächste ganze Zahl zur Zahl `x` (Ergebnis ist von einem ganzzahligen Typ)
`ceil(x)`	Kleinste ganze Zahl größer oder gleich der Zahl `x` (Ergebnis ist jedoch vom Gleitkommatyp)
`floor(x)`	Größte ganze Zahl kleiner oder gleich der Zahl `x` (Ergebnis ist jedoch vom Gleitkommatyp)
`sgn(x)`	Signum der Zahl `x`: entweder -1, 0 oder 1 (abhängig vom Vorzeichen von `x`)
`signum(x)`	Wie `sgn(x)`, aber mit Gleitkomma-Rückgabewert
`sqr(x)`	Quadrat der Zahl `x`; x * x
`sqrt(x)`	Quadratwurzel der Zahl `x` (unzulässig wenn `x` negativ ist)
`exp(x)`	Exponentialwert mit der Eulerschen Zahl e als Basis und `x` als Exponent: e^x
`log(x)`	Natürlicher Logarithmus (d. h. zur Eulerschen Zahl e) der Zahl `x`; ln x; log_ex
`pow(x, y)`	Berechnet `x` hoch `y` (wobei `x`, `y` und das Ergebnis Gleitkommazahlen sind): x^y
`cos(x)`	Kosinus von `x`, wobei `x` im Bogenmaß angegeben werden muss
`sin(x)`	Sinus von `x`, wobei `x` im Bogenmaß angegeben werden muss
`tan(x)`	Tangens von `x`, wobei `x` im Bogenmaß angegeben werden muss
`acos(x)`	Arkuskosinus von `x` (inverse Kosinus-Funktion), wobei `x` zwischen -1,0 und +1,0 liegen muss; das Ergebnis wird im Bogenmaß angegeben
`asin(x)`	Arkussinus von `x` (inverse Sinus-Funktion), wobei `x` zwischen -1,0 und 1,0 liegen muss; das Ergebnis wird im Bogenmaß angegeben
`atan(x)`	Arkustangens von `x` (inverse Tangens-Funktion); das Ergebnis wird im Bogenmaß angegeben (wie bei `asin`, `acos`)
`toRadians(x)`	Konvertiert den Winkel `x` von Grad in Bogenmaß
`toDegrees(x)`	Konvertiert den Winkel `x` von Bogenmaß in Grad
`random(n)`	Gibt eine ganzzahlige Pseudo-Zufallszahl im Bereich zwischen 0 und n-1 für positives `n` zurück, oder zwischen n+1 und 0 für negatives `n`

Eingebaute nicht-numerische Funktionen

Funktion	Beschreibung
`length(s: string): int`	Gibt die Anzahl der Zeichen zurück, aus denen der String `s` besteht.
`length(a: array): int`	Gibt die Anzahl der Elemente zurück, aus denen das Array `a` besteht.
`lowercase(c: char): char` `lowercase(s: string): string`	Gibt eine Kleinbuchstabendarstellung des Zeichens `c` zurück; gibt eine String-Darstellung von `s` zurück, bei der alle Buchstaben in Kleinbuchstaben umgewandelt sind.
`uppercase(c: char): char` `uppercase(s: string): string`	Gibt eine Großbuchstabendarstellung des Zeichens `c` zurück; gibt eine String-Darstellung von `s` zurück, bei der alle Buchstaben in Großbuchstaben umgewandelt sind.
`pos(sub: string; s: string): int`	Gibt die erste Startposition des Teilstrings `sub` innerhalb des Strings `s` zurück (Position ≥ 1 falls vorhanden, sonst 0).
`copy(s: string; i: int; n: int): string`	Gibt den Teilstring des Strings `s` zurück, der an Zeichenposition `i` (i ≥ 1) beginnt und höchstens `n` Zeichen hat.
`split(s: string; sep: string): array of string` `split(s: string; sep: char): array of string`	Teilt den String `s` an jeder Stelle des Teilstrings oder Zeichens `sep` in Teile (einige können leer sein) und gibt diese als Array zurück.
`trim(s: string): string`	Gibt den gekürzten String `s` zurück, d. h. ohne führende und nachfolgende Leerzeichen.
`strcmp(s1: string, s2: string): int`	Gibt -1, 0 oder +1 zurück, wenn String `s1` lexikografisch kleiner als, gleich oder größer als `s2` ist.
`ord(c: char): int`	Gibt den ASCII-Code des Zeichens `c` (oder des ersten Zeichens des Strings `c`) zurück.
`chr(n: int): char`	Gibt das durch die Zahl `n` kodierte ASCII-Zeichen zurück.
`isArray(value): bool`	Gibt `true` zurück, wenn das Argument ein Array ist.
`isString(value): bool`	Gibt `true` zurück, wenn das Argument ein String ist.
`isNumber(value): bool`	Gibt `true` zurück, wenn das Argument eine ganze Zahl oder eine Gleitkommazahl ist.
`isChar(value): bool`	Gibt `true` zurück, wenn das Argument ein Zeichen ist.
`isBool(value): bool`	Gibt `true` zurück, wenn das Argument ein boolescher Wert ist.

Eingebaute Prozeduren

Prozedur	Beschreibung
`inc(v)`	Erhöht die Variable `v` um eins; äquivalent zu: `v ← v + 1`
`dec(v)`	Verringert die Variable `v` um eins; äquivalent zu: `v ← v - 1`
`inc(v, i)`	Erhöht die Variable `v` um die Zahl `i`; äquivalent zu: `v ← v + i`
`dec(v, d)`	Verringert die Variable `v` um die Zahl `d`; äquivalent zu: `v ← v - d`
`randomize()`	Initialisiert den für `random(n)` verwendeten Pseudozufallszahlengenerator neu.
`insert(w, s, i)`	Fügt den String `w` an Zeichenposition `i` in den String `s` ein (i ≥ 1).
`delete(s, i, n)`	Entfernt die nächsten `n` Zeichen ab Position `i` aus dem String `s` (i ≥ 1).

Datei-Ein-/Ausgabe

Die API für die Arbeit mit Textdateien wurde auf Benutzerwunsch mit Release 3.26 eingeführt und ermöglicht es, Werte zu speichern sowie Textdateien mit Structorizer zu erstellen und zu analysieren – und natürlich den Umgang mit Ressourcen zu demonstrieren, die vom Betriebssystem verwaltet werden.

Nachdem eine Textdatei mit einer der Öffnungsfunktionen fileOpen, fileCreate oder fileAppend geöffnet wurde, kann auf die jeweilige Datei über das erhaltene „Datei-Handle" zugegriffen werden (das tatsächlich eine ganze Zahl > 0 ist, wenn die Dateiakquisition erfolgreich war). Negative Ergebnisse eines Öffnungsversuchs oder 0 stehen für eine Art Fehler und berechtigen zu keinerlei Dateizugriff. Nachdem mit einer erfolgreich erworbenen Datei gearbeitet wurde, muss sie hingegen mit der Prozedur fileClose freigegeben werden.

Datei-API-Unterroutinen

Prozedur / Funktion	Beschreibung
`fileOpen(path: string): int`	Öffnet eine Textdatei zum Lesen (setzt voraus, dass die Datei existiert); gibt ein Datei-Handle zurück (siehe unten)
`fileCreate(path: string): int`	Erstellt eine neue Datei zum Schreiben (kann eine vorhandene überschreiben); gibt ein Datei-Handle zurück (siehe unten)
`fileAppend(path: string): int`	Öffnet eine Datei zum Anhängen (behält den vorherigen Inhalt bei); gibt ein Datei-Handle zurück (siehe unten)
`fileEOF(handle: int): boolean`	Gibt `true` zurück, wenn die Eingabedatei erschöpft ist (keine weiteren Zeichen lesbar)
`fileRead(handle: int): object`	Gibt die nächsten lesbaren Daten als `int`- oder `double`-Wert, flaches Array oder String zurück (siehe unten)
`fileReadChar(handle: int): char`	Gibt das nächste lesbare Zeichen zurück (siehe unten)
`fileReadInt(handle: int): int`	Gibt den Wert des nächsten ganzzahligen Literals zurück, wenn das nächste Token ein ganzzahliges Literal ist (siehe unten)
`fileReadDouble(handle: int): double`	Gibt den Wert des nächsten ganzzahligen Literals zurück, wenn das nächste Token ein ganzzahliges Literal ist (siehe unten)
`fileReadLine(handle: int): string`	Gibt den (Rest der) aktuellen Zeile ohne das Zeilenumbruchzeichen zurück (das dennoch verbraucht wird, siehe unten)
`fileWrite(handle: int; value)`	Schreibt den angegebenen Wert in die Datei, ohne ein Trennzeichen hinzuzufügen
`fileWriteLine(handle: int; value)`	Schreibt den angegebenen Wert in die Datei und fügt ein Zeilenumbruchzeichen an
`fileClose(handle: int)`	Schließt die durch das Handle identifizierte Datei (siehe unten)

(Beachten Sie, dass das „Zeilenumbruchzeichen" eine Abstraktion ist, die auf einigen Plattformen physisch durch eine Zeichenfolge repräsentiert werden kann.)

Eine detaillierte Beschreibung und mehrere Beispiele finden Sie auf der Seite zur Datei-API.

Plugin-Unterroutinen

Zusätzlich zu den direkt eingebauten Funktionen und Prozeduren, die oben beschrieben wurden, verfügt Structorizer über einen Plugin-Mechanismus, in den sogenannte „Diagram Controller" integriert werden können. Diese können weitere Funktionen und Prozeduren hinzufügen, die ähnlich wie eingebaute Funktionen und Prozeduren arbeiten, aber nur dann verwendbar sind, wenn der jeweilige Ausführungskontext des Plugins aktiviert ist. Bisher ist Turtleizer das einzige solche Plugin. Weitere Einzelheiten und Informationen zur Aktivierung des Ausführungskontexts finden Sie auf der entsprechenden Benutzerhandbuchseite.