Verwendung einer komfortableren Assemblersprache

Eine komfortablere Assemblersprache

Vielleicht wäre die Funktion des Assemblerprogramms leichter zu verstehen, wenn es etwas anders formuliert wäre, in einer Art "Komfort-Assemblersprache". Zumindest würden sich Ähnlichkeiten von Programmteilen leichter wiedererkennen lassen.

tst x
jmp (+2)
jmp (+3)
dec x
jmp (-4)
# -----------
inc x
inc x
# ==========
tst y
jmp (+2)
jmp (+3)
dec y
jmp (-4)
# -----------
inc y
inc y
inc y
# ==========
tst x
jmp (+2)
jmp (+5)
dec x
inc _h0
inc _h1
jmp (-6)
tst _h1
jmp (+2)
jmp (+4)
dec _h1
inc x
jmp (-5)
# -----------
tst y
jmp (+2)
jmp (+5)
dec y
inc _h0
inc _h1
jmp (-6)
tst _h1
jmp (+2)
jmp (+4)
dec _h1
inc y
jmp (-5)
# -----------
tst z
jmp (+2)
jmp (+3)
dec z
jmp (-4)
# -----------
tst _h0
jmp (+2)
jmp (+4)
dec _h0
inc z
jmp (-5)
hlt 
# ==========
[x=0]
[y=0]
[z=0]
[_h0=0]
[_h1=0]

Aufgabe 1

Beschreibe die Unterschiede der Komfort-Assemblersprache zur eigentlichen Bonsai-Assemblersprache.

Ähnlichkeiten und Unterschiede von Komfort-Assembler zu Bonsai-Assembler

Es fällt auf, dass die Komfort-Assemblersprache der Bonsai-Assemblersprache ähnelt, sich in einigen Punkten aber offensichtlich auch unterscheidet. Im Folgenden werden diese Gemeinsamkeiten und Unterschiede kurz erläutert.

Befehlsumfang

Der Befehlsumfang der Komfort-Assemblersprache ist derselbe wie bei der Bonsai-Assemblersprache. Es werden nur die 5 Befehle inc, dec, jmp, tst und hlt benutzt.

Registerbenennung

Bei den Befehlen inc, dec und tst werden Variablenbezeichner statt Registeradressen benutzt. Jede Variable steht dabei für ein Register. Die genaue Adresse des Registers spielt vorerst noch keine Rolle.

Am Ende des Programms werden alle im Programm benutzten Variablen mit ihren Startwerten aufgelistet.

[x=0]
[y=0]
[z=0]
[_h0=0]
[_h1=0]

Mit dieser Notation wird angezeigt, wie viele Register im Programm verwendet werden und mit welchen Variablen auf die Registerwerte zugegriffen wird. Im vorliegenden Beispiel wird z.B. das erste Register (mit einer noch zu vergebenden Adresse - z.B. der Adresse 0) von der Variablen x verwaltet. Der Anfangswert dieses Registers ist die Zahl 0.

Hinweis: Wie schon gesagt, geht das Beispiel-Programm trotzdem bei jeder Zuweisung "auf Nummer sicher". Das ist in gewisser Weise auch sinnvoll, denn einer Variable können im Programmverlauf ja mehrfach neue Werte zugewiesen werden könnten.

Relative Sprünge

Auch die Adressierung beim jmp-Befehl unterscheidet sich in der Komfort-Assemblersprache von der BonsaiAssemblersprache.

Eine Angabe wie z.B. jmp (-5) bedeutet: Gehe 5 Zeilen im Programm zurück. Entsprechend bedeutet eine Angabe wie z.B. jmp (+5): Gehe 5 Zeilen im Programm weiter vorwärts. Die mit Klammern gekennzeichneten Adressen sind hier also relative Sprungadressen.

Durch die Verwendung relativer Sprungadressen müssen die einzelnen Befehle eines Komfort-Assemblerprogramms nicht durchnummeriert werden. Außerdem lassen sich so in Komfort-Assemblerprogrammen leichter Wiederholungen ähnlicher Befehlsfolgen erkennen.

Kommentare

Beachte, dass die Komfort-Assemblersprache auch Kommentare (# ...) zulässt.

Test von Komfort-Assemberprogrammen

Benutze den Interpreter für Komfort-Assembler, um Programme der Komfort-Assemblersprache zu testen.

Die vier Spalten des Programms beinhalten:

1. Das Komfort-Assembler-Programm mit Anfangswerten der Variablen
2. Das Komfort-Assembler-Programm ohne Kommentare und Anfangswerten
3. Die Werte der Variablen zu Anfang und auch während des Programmablaufs
4. Falls gewünscht, eine Übersetzung in Bonsai-Assembler.

Aufgabe 2

Teste das obige Programm mit dem Interpreter für Komfort-Assembler.

Aufgabe 3

Überlege dir, welche Teile des Codes man in dem Programm weglassen könnte, wenn man die Vorbelegung der Variablen geschickt ausnutzt.

Aufgabe 4

Erzeuge ein Komfort-Assembler-Programm, das dem folgenden MiniPython-Programm entspricht.

x = 5
y = 4
while x != 0:
    x = x - 1
    y = y + 1
#end

Dabei musst du nicht, wie das Beispielprogramm, bei jeder Zuweisung "auf Nummer sicher" gehen, sondern darfst elegant programmieren.
Teste dein Programm.