Die virtuelle Maschine von Aleph, im Folgenden V2M genannt, besitzt nach dem Start einen Satz von Anweisungen (Commands). Diese Anweisungen bilden einen Kern und tragen deshalb auch die Bezeichnung "Kernel" - nicht zu verwechseln mit dem Kernel von Linux!
Im Folgenden werden alle Anweisungen der V2M beschrieben und mit einem Beispiel kurz vorgestellt. Weil einige Befehle nur innerhalb einer Neudefinition Sinn machen, sind diese noch einmal besonders gekennzeichnet. Für andere Commands genügt es, nur ein Beispiel für viele anzuführen.
Eine Zusammenfassung der hier besprochenen Anweisungen mit den Situationen auf dem Stack vor und nach Ausführung ist in der Datei "voc.html" vorhanden. Es handelt sich aber nur um eine Zusammenfassung und enthält keine Erläuterungen.
Es existieren mehrere Arten von Anweisungen. So wird u.a. unterschieden zwischen solchen aus reinem Java-Code und jenen, die aus vorhandenen komponiert wurden. Außerdem gibt es noch unmittelbare und unsichtbare. Ein erster Überblick ist also sinnvoll.
primary Command
Eine Anweisung, die aus Befehlen der untergeordneten Maschine besteht. Bei Aleph handelt es sich also um Java-Sequenzen.
secondary Command
Es handelt sich immer um eine Zusammenstellung aus bestehenden Commands. Die einfachste Analogie ist ein kompiliertes Unterprogramm.
immediate Command
Diese Anweisungen sollten sofort ausgeführt, also auch wenn sie innerhalb einer Kompilierung verwendet werden. Sie erzeugen oft unsichtbare Commands innerhalb der gerade compilierten Sequenz. Dabei handelt es sich oft um Verzweigungsbefehle. Die Beschreibung der "colon"-Anweisung ist für eine genauere Kenntnis hilfreich.
invisible Command
Alle Sprungbefehle sind unsichtbar. Sie sind jedoch für die Steuerung des Programmflusses unverzichtbar. Der Programmierer hat (normalerweise) keine Verwendung für diese Anweisungen, denn sie werden über die entsprechenden immediate Commands (if, else, loop usw.) erzeugt. Auch die Identitätsfunktionen fallen unter die Kategorie "unsichtbar".
Soweit die Einteilung in verschiedene Kategorien. Alle folgenden Abschnitte beschäftigen sich mit den Anweisungen selbst. Wenn möglich und sinnvoll, ist ein Beispiel vorhanden.
Weil Aleph mehrere virtuelle Maschinen bereitstellen kann, muss eine Referenz auf die eigene Instanz ermöglicht werden. So kann ein beliebiges Java-Objekt Zugriff auf V2M-Commands gestattet werden. In dem Java-Objekt arbeiten die Commands wie normale Methoden. So können Programme in Aleph erstellt und in einer Java-Anwendung benutzt werden. Aleph braucht sich nicht einmal mehr an die erstellten Commands zu "erinnern". Ein Beispiel hierzu ist in der Beschreibung der GUI vorhanden.
Dieses Command übergibt die Instanz der virtuellen Aleph-Maschine V2M.
Aleph müssen die vorhandenen Anweisungen bekannt sein. Außerdem müssen Zahlen, Zeichen und andere Objekte voneinander unterschieden werden. Die folgenden Commands erlauben dem Programmierer diese Unterscheidungen in eigenen Programmen zu machen.
Wenn es sich bei der vorliegenden Zeichenfolge um ein Wort aus dem Sprachschatz handelt, dann wird das mit dem compilierten Code auf dem Stack abgelegt und zusätzlich noch true, um den Erfolgsfall mitzuteilen. Im anderen Fall wird nur false abgelegt. Die ursprünglich auf dem Stack vorhandene Zeichenfolge wird entfernt.
".S" find .S drop drop newline . "S." find .S |
führt zu der Anzeige: |
Stack = [ true .S ] Stack = [ false ] |
Wichtig ist hier die Ausgabe. Weil es sich bei dem compilierten Code um ein bekanntes Objekt handelt, wird der Name des entsprechenden Commands ausgegeben und nicht die "Adresse" des Codes.
In allen folgenden Beschreibungen, bei denen zwischen dem Namen und dem Code unterschieden wird, gilt folgende Schreibweise:
Bei name handelt es sich stets um einen String mit dem Namen des Commands.
Bei cmnd (oder cmd) handelt es sich um die compilierte Codesequenz.
In der Terminologie von Aleph symbolisieren manche Zeichenfolgen Werte.
Zahlen symbolisieren artithmetische Werte.
Zeichenfolgen in doppelten Hochkommas symbolisieren Strings.
Zeichen(folgen) in einfachen Hochkommas symbolisieren Character ('\u00F6' für 'Ä').
true/false symbolisieren Wahrheitswerte.
Wenn die vorliegende Zeichenfolge im obigen Sinne zu symbolisieren ist, dann wird das entsprechende Symbol auf dem Stack abgelegt und zusätzlich true. Im anderen Fall wird nur false abgelegt.
"'X'" symbol .S |
führt zu der Anzeige: |
Stack = [ true [c_sym]('X') ]
|
"X" symbol .S |
führt zu der Anzeige: |
Stack = [ false ] |
Ganz genau betrachtet wird eine Identitätsfunktion (hier c_sym) für den symbolisierten Wert (Character 'X') erzeugt. Die im Beispiel vorhandenen doppelten Hochkommas dienen nur der Übergabe einer Zeichenfolge als solche.
Die gezielte Ausführung einzelner Anweisungen ist mit diesem Command möglich. Der compilierte Code wird ausgeführt.
Das folgende Beispiel geht zeigt den Weg sehr detailliert. Der von find gelieferte true-Wert wird einfach vom Stack entfernt (drop), denn er ist in diesem Fall überflüssig.
9999 "." find .S newline . drop execute |
führt zu der Anzeige: |
Stack = [ true . 9999 ] 9999 |
In Aleph werden Daten generell auf dem Stack (genau Datenstack) abgelegt. Bei dieser Organisation handelt es sich um eine Liste, wobei neue Elemente nicht angehängt sondern voran gestellt werden.
Die folgenden Anweisungen sind "Kombinatoren" zur Änderung der vorhandenen Reihenfolge. Auch das Entfernen gilt hier als Änderung der Reihenfolge.
Das erste Objekt wird entfernt. Das erste Objekt wurde als letztes bereitgestellt. Es liegt also an oberster Stelle auf dem Stack (TOS, Top Of Stack).
3 4 5 .S newline . drop .S |
führt zu der Anzeige: |
Stack = [ 5 4 3 ] Stack = [ 4 3 ] |
Das n_te Objekt wird vom Stack entfernt. Die Angabe der Ordinalzahl n wird bei der Indizierung nicht berücksichtigt. Die Zählung beginnt bei 0 (Null).
3 4 5 .S newline . 1 ndrop .S |
führt zu der Anzeige: |
Stack = [ 5 4 3 ] Stack = [ 5 3 ] |
Das oberste Objekt wird dupliziert.
3 4 5 .S newline . dup .S |
führt zu der Anzeige: |
Stack = [ 5 4 3 ] Stack = [ 5 5 4 3 ] |
Das n_te Objekt wird dupliziert und an oberster Stelle auf dem Stack abgelegt. Die Angabe der Ordinalzahl n wird bei der Indizierung nicht berücksichtigt. Die Zählung beginnt bei 0 (Null).
3 4 5 .S newline . 1 ndup .S |
führt zu der Anzeige: |
Stack = [ 5 4 3 ] Stack = [ 4 5 4 3 ] |
Die beiden obersten Objekte auf dem Stack werden vertauscht.
3 4 5 .S newline . swap .S |
führt zu der Anzeige: |
Stack = [ 5 4 3 ] Stack = [ 4 5 3 ] |
Das oberste Element auf dem Stack wird mit dem n_ten Element vertauscht. Die Angabe der Ordinalzahl n wird bei der Indizierung nicht berücksichtigt. Die Zählung beginnt bei 0 (Null).
3 4 5 .S newline . 1 nswap .S |
führt zu der Anzeige: |
Stack = [ 5 4 3 ] Stack = [ 3 4 5 ] |
Diese Kategorie von Commands ist für den Aufbau neuer Anweisungen und die Komposition ihrer Abläufe verantwortlich. Es handelt sich um die komplizierteste, dafür aber interessanteste Gruppe von Anweisungen.
Das oberste Element auf dem Stack wird als Name für ein neues Command in das Wörterbuch (Dictionary, Vokabular) von Aleph eingetragen. Als Namen sollten generell Strings verwendet werden, es sei denn der Programmierer hat eine Alternative.
Der compilierte Code einer Anweisung wird vom Stack an die Stelle "here" gespeichert. Der Ort "here" ist ein dynamischer Bereich im Speicher, der nach Erstellung einer neuen Anweisung neu angelegt wird. Weil dieser Ort vom Speichermanagement des jeweiligen Systems (PC) abhängig ist, lautet der Name einfach "here".
Eingabe: "dup" find drop compile
compiliert den ausführbaren Code von dup als Objekt nach "here". Ist statt eines Commands eine Zahl zu compilieren, so muss statt find die Anweisung symbol verwendet werden. Dann wird ein Symbol (Identitätsfunktion) compiliert.
Der zuletzt gemachte Eintrag im Wörterbuch wird mit dem "here" vorhandenem ausführbaren Code assoziiert. Das neue Command ist nun abgeschlossen und kann benutzt werden.
Das Command wird gelöscht. Der Name wird aus dem Wörterbuch entfernt. Der ausführbare Code wird nur dann aus dem Speicher entfernt, wenn es nicht von anderen Stellen referenziert wird. Dieser Fähigkeit wird im Beispiel GUI besprochen.
Eine ungebundene, freie Variable wird erstellt. Der Name muss als String auf dem Stack liegen.
Eingabe: "X" variable
erzeugt eine Variable X. Sie ist leer. Wird sie in verwendet, sei es aus der direkten Eingabe oder in einer compilierten Sequenz passiert nichts. Die Verwendung freier Variablen ist völlig wirkungslos.
Variablen enthalten nichts, sie sind etwas. Damit eine Variable etwas ist wird is verwendet. Die Sequenz
X . // Variable verwenden
erstellt zunächst die Variable X. Danach wird die Variable durch is und Angabe ihres Names (deshalb als String) als Identität für den Zahlenwert 123 erklärt. Wenn nun einfach X benutzt wird, ist die Indentität von 123 gemeint.
Eine Variable wird befreit. Die Variable deren Name als String auf dem Stack liegen muss, ist nach Ausführung von free leer.
"X" free
Statt endloser Listen von Operatoren wird hier einfach eine Tabelle benutzt. Der Begriff Identität meint hier so etwas wie den Typ in herkömmlichen Sprachen. Die Tabelle zeigt also für jeden Typ die zulässigen Operationen und Relationen.
Die "+"-Operation bei Zeichenketten ist natürlich eine concatenation. Das "+" wurde nur verwendet, weil es sich in allen modernen Sprachen durchgesetzt hat.
Die "*"-Operation für Boolesche Werte ist tatsächlich im Sinne einer Multiplikation zu verstehen. Für den mathematischen Nachweis fehlt hier jedoch der Platz.
Größenrelationen fehlen bei Zeichenketten (Strings) weil zu viele lexikalische Ordungen existieren. Sind sie trotzdem erforderlich, kann sie leicht über die Relationen einzelner Zeichen hergeleitet werden. Hier gilt die Ordinalität des Unicode Zeichensatzes.
|
Identitäten |
Operationen |
Relationen |
|
ganze Zahlen |
+, *, –, /, not, and, or |
=, <=, <, >, >=, <> |
|
Fließkomma |
+, *, –, / |
=, <=, <, >, >=, <> |
|
Wahrheiten |
not, and, or, * |
=, <=, <, >, >=, <> |
|
Zeichenfolgen |
+ |
=, <> |
|
Zeichen |
|
=, <=, <, >, >=, <> |
Es fehlt noch ein Command, das den Relationen zugeordnet wird.
Es testet, ob nichts vorhanden ist. Es prüft, ob das Objekt auf dem Datenstack null ist. Das vorangestellte Zeichen'?' bedeutet, dass ein nicht konsumierender Test stattfindet. Das Objekt bleibt also auf dem Stack erhalten und an oberster Position wird ein true oder false abgelegt.
Wichtig ist diese Anweisung bei der Verarbeitung von Listen. Ein Beispiel für Listen ist in der Dokumentation vorhanden.
Die strukturierte Programmierung wird mit diesen Anweisungen möglich. Die stringente Ablauf der Befehlsfolge ändert sich.
Für die ausführende Maschine (V2M) bedeutet diese Forderung einfach die Verwendung von Sprungbefehlen (goto). Diese Befehle widersprechen dem strukturellen Anspruch.
Aleph löst das Problem über immediate Comands. Diese Anweisungen werden im Quelltext verwendet, erzeugen aber für die Kompilierung die Sprungbefehle. Letztere können direkt im Quelltext verwendet werden und sind deshalb auch nicht im Wortschatz vorhanden. Diese Anweisungen können nur während der Kompilierung eingesetzt werden. Nur hier kann der Ablauf gesteuert werden.
Ein Beispiel zeigt die Verwendung. Hier wird mit dem ':'-Command eine neue Anweisung test erstellt. Alle Angaben zwischen test und dem ';' (ausschließlich) werden compiliert.
: test
if
"ein"
else
"kein"
endif
. " wahres Wort." .
;
2 3.0 < test
newline .
3 2.0 < test
|
Die ':'-Anweisung wird zwar separat besprochen, aber hier ist sie nötig. Um zu sehen, was genau compiliert wurde dient die Anweisung showDef.
Eingabe: "test" find drop showdef
: test
0: [jumpf](3)
1: [s_sym]("ein")
2: [jump](4)
3: [s_sym]("kein")
4: .
5: [s_sym](" wahres Wort.")
6: .
;
|
Wieder ein Verbund aus drei Anweisungen. Erneut zeigt ein Beispiel die Art der Verwendung am besten.
: test_loop
loop // Index liegt auf dem Stack
dup . " " . // Index und Leerzeichen ausgeben
dup 3 = leave // Verlassen, wenn 3 erreicht
1 + // Index inkrementieren
endloop
;
0 test_loop "fertig " . .S
|
Diese Anweisung ist eine Unterbrechung und keine Verzweigung. Das gerade bearbeitete Command wird sofort verlassen. Dieses Command entspricht dem return bei herkömmlichen Sprachen.
Die V2M von Aleph nutzt Java als untergeordnete Maschine. Damit sollte der "Maschinensprache" auch dem "Befehlssatz" entsprechen. Die Commands dieses Abschnitts stellen das Interface bereit.
Für die folgenden Beispiele wird eine Datei namens „xyz.java“ benutzt, in der die nötigen Komponenten vorhanden sind. Auf diese Klasse beziehen sich die hier angegebenen Beispiele.
public class xyz {
public static int Cvalue = -11; // class FIELD
public int Ivalue = -99; // instance FIELD
public void test() { // METHOD
System.out.println( "Funktioniert!");
}
public int add( int a, int b) {
return a+b;
}
}
|
Eine Klasse wird über ihren Namen und diese Anweisung bereitgestellt. Es muss der gesamte Name, also auch der Pfad wenn die Klassendatei in einem anderen "package" ist. Weil "xyz.class" im Verzeichnis von Aleph liegt, genügt hier der einfache Name.
"xyz" classify .S |
führt zu der Anzeige: |
Stack = [ (class xyz) ] |
In der Ausgabe fällt die Klammerung auf. Sie dient zur Vermeidung von Fehlinterpretationen. Wäre dort [ class xyz ] angegeben, sieht es so aus zwei Elemente vorhanden.
In „xyz.java“ sind keine statischen Komponenten vorhanden. Um die Komponenten zugänglich zu machen, muss also eine Instanz der Klasse (Objekt) gebildet werden.
"xyz" classify instantiate .S |
führt zu der Anzeige: |
Stack = [ xyz@1385660 ] |
In der Anzeige ist wieder der Name der Klasse vorhanden, jedoch ergänzt um ein „@“ und eine Ziffernfolge. Es handelt sich dabei um eine von Java erzeugte textuelle Darstellung einer Instanz. Genau genommen ist es eine physische Adresse der Maschine die wiederum der JVM untergeordnet ist – dem PC.
Anzeigen der Adressen von Instanzen sind wenig informativ. Während der Entwicklung ist es aber manchmal wichtig zu wissen, ob eine Instanz oder eine Klasse vorliegt.
Mit "instantiate" werden die Objekte einfach instanziert. Weil keine Creator-Methode vereinbart war, wird der „default creator“ benutzt.
Oft ist die Instanzierung an bestimmte Argumente gebunden. Dann muss die entsprechende Creator-Methode verwendet werden. Genau diese Aufgabe erledigt diese Anweisung. Sie trennt außerdem Argumente und Methodik.
"Fenster aus V2M" // Fenstertitel
"javax.swing.JFrame" // Klasseangabe
classify // Klasse von JFrame
"{String}" // Typ des Arguments
creator // Creator mit entsprechender Argumentliste
|
Auf dem Stack liegt das gewünschte Creator-Objekt und steht zur Benutzung bereit. Wegen des besonderen Status der Creator-Methoden (sie besitzen keine return-types, schon gar nicht void), werden sie auch nicht mit "call" aufgerufen, sondern mit "build".
Diese Anweisung startet eine Creator-Methode. Das entsprechende Objekt muss an oberster Position auf dem Stack liegen, gefolgt von den erforderlichen Argumenten. Beispiele sind in der Dokumentation vorhanden.
Mit dieser Anweisung wird der Inhalt einer Klassen- oder Instanzvariable auf dem Stack abgelegt. Je nach Vereinbarung erfolgt der Zugriff über eine Instanz- oder Klassenangabe. Sollte eine Instanz vorliegen und es genügt eine Klassenangabe (staisches field), kümmert sich die Anweisung selbst darum.
"xyz" classify // class instantiate // instance "Ivalue" // name instance swap // instance name fetch // -99 .S |
führt zu der Anzeige: |
Stack = [ -99 ] |
Das field "value" wird ausgelesen. Die „swap“-Anweisung zwischen der Namensangabe und "fetch" ist erforderlich um die korrekte Reihenfolge der Angaben zu erhalten. Die Kommentare zeigen die jeweilige Situation auf dem Stack, wobei TOS (top of stack) links steht.
Hinweis:
Diese Vorgehensweise ist nur sinnvoll, wenn ein field sehr selten benutzt wird. Wird ein field häufiger benötigt, hilft das Command "field".
Diese Anweisung dient dazu, in einem field etwas speichern zu können.
"object" variable "xyz" classify instantiate "object" is 1234 "Ivalue" object store "Ivalue" object fetch .S |
führt zu der Anzeige: |
Stack = [ 1234 ] |
In diesem Beispiel wird die V2M-Variable "object" zum speichern der Instanz benutzt. Um die Speicherung mit "store" zu überprüfen, muss die Instanz des fields bekannt sein. Wenn einfach wieder "xyz" classify instantiate“ eingegeben wird, schlägt der Versuch fehl, weil eine neue Instanz von „xyz“ erzeugt würde.
Hinweis:
Diese Vorgehensweise ist nur sinnvoll, wenn ein field sehr selten benutzt wird. Wird ein field häufiger benötigt, hilft das Command "field".
Natürlich stehen auch die Methoden aus Java-Klassen oder -Instanzen für eine Verwendung unter Aleph zu Verfügung.
Hier ist es jedoch wichtig, die Argumente zu berücksichtigen. Die Namen von Methoden allein sind nicht unbedingt einmalig. Um die „richtige“ Methode zu finden, müssen auch die Typen der Argumente bekannt sein. In „xyz“ sind zwei Methoden vorhanden. Die erste ohne, die zweite mit Argumenten.
"xyz" classify instantiate
"test{}" call
|
führt zu der Anzeige: |
Funktioniert! |
13 -7
"xyz" classify instantiate
"add{int int}" call
.S
|
führt zu der Anzeige: |
Stack = [ 6 ] |
Vorsicht:
Die Reihenfolge Instanz–Aufruf entspricht nicht der von "fetch".
Hinweis:
Wenn Methoden häufiger benutzt werden sollen, ist diese Vorgehensweise zu umständlich. Wird eine Methode häufiger benötigt, hilft das Command "method".
In Java werden Variablen allgemein als "fields" bezeichnet. Das ist der Oberbegriff für Properties, Klassen- und Objektvariablen. Diese "fields" können Aleph in ähnlicher Weise zur Verfügung gestellt werden wie Variablen.
Die Verhaltensweise von "fields" entspricht denn auch weitgehend der von Aleph-Varablen. Ein wesentlicher Unterschied bleibt jedoch, "fields" sind typenabhängig. Es kann also sein, dass ein entsprechendes casting durchgeführt werden muss.
"java.lang.Math" classify "PI" field pi pi . |
führt zu der Anzeige: |
3.141592653589793 |
Hinweis:
Speichern in "pi" wird fehlschlagen, denn in der Klasse "Math" ist "PI" als "final" deklariert. Dieses Attribut macht in Java aus Variablen Konstanten.
Fields können nur außerhalb einer Compilationsphase deklariert werden. Die Zeichenfolge, welche "field" folgt ist der Name. Das ist ein weiterer, wichtiger Unterschied zu den Aleph-Variablen. Sonst könnten "fields" in Aleph rekursiv deklariert werden, was gewiss zu Komplikationen führt, wenn die entsprechenden Instanzen nicht ebenfalls der Rekursion folgen.
Sollten hier Unsicherheiten bestehen, kann immer noch der Weg über die Aleph-Variablen gewählt werden. Hier bestehen hinsichtlich Rekursion (indirekt oder abhängig) kaum Hindernisse.
Im Gegensatz zu Aleph-Variablen enthalten "fields" etwas. Um den Bezug zu Java deutlich zu machen, wurde "set" als Speicherbefehl gewählt.
"xyz" classify instantiate "Ivalue" field X 123 "X" set X . |
führt zu der Anzeige: |
123 |
Methoden sind der Sammelbegriff für Funktionen in Java. Der alte Begriff "Prozedur" wird vermieden und der erforderliche Rückgabewert "void" (leer, ungültig) genannt.
Wie fields können auch methods aus Java-Instanzen in Aleph verwendet werden.
"java.lang.Math" classify
"sqrt{double}" method wurzel
4 wurzel .
|
führt zu der Anzeige: |
2.0 |
Wie bei "field" gilt auch für dieses Command die automatische Unterscheidung zwischen statischen und instanzierten Methoden. Im Beispiel wird die Methode "sqrt" nur über die Klasse erreicht.
Bei der Verwendung von Methoden der untergeordneten Maschine kann es notwendig sein, bestimmte Datentypen zu beachten. Insbesondere die sog. primitiven Typen sind oft ein Problem. Die folgenden Anweisungen erleichtern dem Anwender die Anpassungen.
Das oberste Element auf dem Stack wird in den entsprechenden Objekttyp von Java umgewandelt. Dabei gelten natürlich die Regelb der untergeordneten Maschine, weshalb eine Wandlung eines Fenstertyps in einen Byte-Typ fehlschlägt.
Die Anweisungen in dieser Kategorie sind sehr übesichtlich.
Die nächste Zeichenfolge ohne "white spaces" wird vom aktuellen Eingabestrom gelesen und als String auf dem Stack abgelegt. Zusätzlich wird noch ein true abgelegt. Es kann sein, dass keine Wörter mehr im Eingabestrom vorhanden sind. In diesem Fall wird nur false auf den Stack übertragen.
word Wort .S |
führt zu der Anzeige: |
Stack = [ true Wort ] |
Eine Datei, dessen Name auf dem Stack als String vorliegt, wird als Eingabestrom verwendet. Nachdem das Ende der Datei erreicht ist, wird mit zum ursprünglichen Eingabestrom zurückgekehrt.
Es ist möglich, in einer Datei weitere "load"-Anweisungen zu verwenden, ihrerseits wieder solche Commands enthalten dürfen usw. usw. Die Tiefe ist nicht beschränkt.
Der Ausgabebefehl schlechthin. Das Objekt auf dem Datenstack wird in best möglicher Form ausgegeben.
Die eigenartige Namensgebung liegt daran, dass Aleph wortorientiert ist. So sollten Sequenzen von Anweisungen als Satz angesehen werden. Am Ende eines Satzes wird eine Reaktion erwartet, die hier eben einer Ausgabe entspricht.
Jedes System benötigt ein paar "Werkzeuge", um die Erstellung neuer Programme zu erleichtern. Hier einige Commands, die helfen den Überblick zu behalten.
Anzeige der aktuellen Situation auf dem Datenstack. Es werden alle Elemente auf dem Stack ausgegeben. Die Anzeige des einzelnen Elements ist so gestaltet, dass maximale Lesbarkeit vorliegt. Darunter fällt z.B. die Klammerung von class und Klassenname wenn eine Klasse vorliegt.
Stack = [ ... (class name) ...] statt Stack = [ ... class name ...].
Eigentlich eine Konstante. Weil beinahe jedes Betriebssystem eigene Vorstellungen vom Ende einer Zeile hat, wird in diesem Command der entsprechende Wert untergebracht.
Prinzipiell einfach der String "\n" vorhanden. Diese Schreibweise aber nicht sonderlich beliebt, weshalb newline eingeführt wurde.
Der Typ des obersten Elements auf dem Stack wird als String auf dem Stack abgelegt. Diese Anweisung ist konsumierend, weshalb das Element selbst entfernt wird.
Handelt es sich bei dem Element um ein Aleph-Command, so wird der Name ausgegeben. In allen anderen Fällen die Bezeichnung der entsprechenden Java-Klasse.
Die Namen aller Commands im Wörterbuch werden ausgegeben. Die Ausgabe beginnt mit dem letzten Eintrag und endet beim ersten (environment).
Die compilierte Sequenz eines Commands wird ausgegeben. Es können natürlich nur secondaries angezeigt werden, denn primäre Anweisungen bestehen aus reinem Byte-Code der virtuellen Java-Maschine. Ein Beispiel wurde im Abschnitt "Steuerung des Ablaufs" unter "if...else...endif" gegeben.