Ein Blick hinter die Kulissen
Compiler und Assembler sind für die meisten Menschen unbegreifliche Wundersachen. Dabei ist das alles im Fall des RT-Assemblers RTA ganz einfach.
Assemblerzeit und Laufzeit
Zunächst wird das Programm, bevor es gestartet wird, in einen internen Code übersetzt oder „assembliert“. Hierbei liest ein Unterprogramm - der RT-Assembler - das Quellprogramm ein und übersetzt es in einen internen Code. Dieser erste Lebenszyklus des Programmes heißt Assemblerzeit. Die Assemblerzeit dauert nur Sekundebruchteile und erfolgt im Fall von RTA bei Aufruf unmittelbar vor dem Programmstart („just in time“). Aus diesem Grund wird das Assemblieren vom Anwender kaum bemerkt.
Der vom Assembler erzeugte interne Code besteht im Wesentlichen aus zwei Tabellen, der Symboltabelle und der Codetabelle.
Anschließend kommt dieser nun zur eigentlichen Abarbeitung. Hierfür werden die beiden Tabellen an ein zweites Unterprogramm übergeben - den RT-Prozessor. Diesser arbeitet nun den programmierten Algorithmus ab, wobei Eingaben angefordert, Berechnungen ausgeführt die Ergebnisse ausgegeben werden. Das Programm „läuft auf der Maschine.“ Daher heißt dieser Lebenszyklus des Programmes auch Laufzeit.
Das Quellprogramm
Wir demonstrieren die Funktionsweise von RTA an dem kleinen Quellprogramm test_tst0_demo_mittelwert.rta.
;
; test_tst0_demo_mittelwert.rta
; =============================
;
; Demoprogramm. Berechnung des Mittelwertes zweier Zahlen.
;
_name Mittelwertberechnung
_var z1 ; Variable z1 deklarieren
_var z2 ; Variable z2 deklarieren
_var m ; Variable für Mittelwert dekl.
input z1 Erste~Zahl ; Erste Zahl abfragen
input z2 Zweite~Zahl ; Zweie Zahl abfragen
mov m z1 ; z1 nach m transportieren
add m z2 ; z2 zu m addieren
div m 2 ; Division durch 2
output m Mittelwert ; Mittelwert ausgeben
exit ; Abarbeitung beenden
_end ; Das ist die letzte Zeile
Das Quellprogramm trägt den Programmnamen „Mittelwertberechnung“. Es gibt drei Variablen z1, z2 und m. Das Programm
führt eine Mittelwertberechnung nach der Formel m=(z1+z2)/2 aus.
Das Quellprogramm wird nun vom RT-Assembler gelesen und alle Symbole werden in eine Symboltabelle eingetragen. Dann liest der Assembler das Programm in einem zweiten Durchlauf noch einmal und nun werden alle Befehle in die Codetabelle eingetragen ...
Die Symboltabelle
Die Symboltabelle hat zwei Spalten, Symbolname (NAME) und Symbolwert (VALUE). Die Zeilennummer heißt Symboladresse.
Auf den Adressen 0 bis 35 trägt der Assembler immer sog. vordefinierte Symbole ein. Adresse 0 erhält z. B. das Leersymbol „.“. Dessen Wert ist immer Null. Auf Adresse 2 ist ein vordefinierte Symbol „pi“ zu erkennen, das vom Assembler mit dem Wert 3,14... gefüllt wurde. Vielleicht ganz nützlich.
(Anmerkung: Die erste Spalte mit der Symboladresse (ADDR) ist nicht Bestandteil der Symboltabelle. Sie dient hier nur der Erläuterung.)
---------------------------------------------------------------- ADDR NAME VALUE ---------------------------------------------------------------- 000000 . 0 000001 .. 7 000002 pi 3.14159265358979 000003 pi/2 1.5707963267949 000004 pi/4 0.785398163397448 000005 e 2.71828182845906 000006 ® 6371004.2029572 000007 ®f 0 000008 °( 1.74532925199433E-02 000009 (° 57.2957795130824 000010 eps 1E-99 000011 max 9.999999999999E+99 000012 r0 0 000013 r1 0 000014 r2 0 000015 r3 0 000016 r4 0 000017 r5 0 000018 r6 0 000019 r7 0 000020 0 000021 x 0 000022 y 0 000023 z 0 000024 x' 0 000025 y' 0 000026 z' 0 000027 Rx 6371004.2029572 000028 Ry 6371004.2029572 000029 Rx' 6371004.2029572 000030 Ry' 6371004.2029572 000031 Cx 0 000032 Cy 0 000033 Cx' 0 000034 Cy' 0 000035 0 000036 z1 0 000037 z2 6 000038 m 3 000039 Erste~Zahl 0 000040 Zweite~Zahl 0 000041 2 2 000042 Mittelwert 0 ------------------------------------------------------------------
Ab Adresse 36 folgen die quellprogrammeigenen Symbole. Dies sind z1 auf Adresse 36, z2 auf Adresse 37 und m auf Adresse 38. Eine RTA-Spezialität ist in Symbol Nr. 41 zu erkennen. Das Symbol trägt sowohl Namen „2“ als auch den Wert „2“: Der RT-Assembler prüft Symbolnamen, ob diese Zahlen sind und trägt dann den Zahlenwert als Symbolwert ein. So erhalten Zahlen in RTA ihren Wert.
Die Codetabelle
Im 2. Assemblerdurchlauf wird eine Codetabelle gefüllt. Diese hat 4 Spalten. In die Befehlsspalte (INSTR) kommt der Befehlscode und in die 3 Adresspalten (ADDR1/2/3) die Adressen der 3 Operanden des Befehls. Nicht angegebene Operanden werden zum Leersymbol assembliert. In der Spalte LINE steht die Tabellenzeile. Das ist zugleich die Codeadresse. Das ist alles.
(Anmerkung: Die Spalten LINE, SYMBOL1/2/3 und VALUE1/2/3 sind nicht Bestandteil der Codetabelle, sondern hier nur zur Erläuterung aufgeführt.)
------------------------------------------------------------------------------------ LINE INSTR SYMBOL1 SYMBOL2 SYMBOL3 ADDR1 ADDR2 ADDR3 VALUE1 VALUE2 VALUE3 ------------------------------------------------------------------------------------ 0000 init . . . 000000 000000 000000 0 0 0 0001 input z1 Erste~Za . 000036 000039 000000 0 0 0 0002 input z2 Zweite~Z . 000037 000040 000000 6 0 0 0003 mov m z1 . 000038 000036 000000 3 0 0 0004 add m z2 . 000038 000037 000000 3 6 0 0005 div m 2 . 000038 000041 000000 3 2 0 0006 output m Mittelwe . 000038 000042 000000 3 0 0 0007 exit . . . 000000 000000 000000 0 0 0 ------------------------------------------------------------------------------------
Nachdem der RT-Assembler das Quellprogramm zu Symboltabelle und Codetabelle übersetzt hat, beendet er seine Arbeit. Die „Assemblerzeit“ als eine erste Lebenszeit des Programmes im Computer ist zu Ende.
Auf der Maschine
Nach dem Assemblieren kommt das Abarbeiten. Die Symboltabelle und die Codetabelle werden dem RT-Prozessor übergeben. Nun beginnt die Abarbeitung - das eigentliche Leben des Programmes, die „Laufzeit“ auf der Maschine. Wenn man die Codetabelle durchsieht, wird folgende Funktionsweise des Programmes erkennbar:
- Der erste Befehl (den init kann man ignorieren) ist der input-Befehl auf Codeadresse 1. Dieser fragt mit dem Text des Symbolnamen 39 („Erste Zahl“) eine Zahl im Dialog ab. Diese wird dann auf Adresse 36, also Symbol z1 abgespeichert.
- Der input-Befehl auf Codeadresse 2 fragt mit dem Text des Symbolnamen 40 („Zweite Zahl“) eine Zahl ab und speichert diese auf Adresse 37, also Symbol z2.
- Es folgt ein Transportbefehl (mov), der den Symbolwert von Adresse 36 (z1) auf Adresse 38 (m) schafft.
- Ein add addiert den Symbolwert von 37 (z2) auf Symbolwert 38 (m). Der Symbolwert m wird damit zur Summe von z1 und z2.
- Nun dividiert ein div den Symbolwert von 38, also m, durch den auf Adresse 41 stehenden Symbolwert. Dies ist die zum Symbolnamen „2“ gehörige 2. Damit ist der Mittelwert auf m fertig gerechnet.
- Der output-Befehl auf Codeadresse 6 zeigt das Ergebnis m an. Dabei wird als Dialogtext der Symbolnamen von Adresse 42 hingefügt: „Mittelwert“.
- Ein exit-Befehl auf Codeadresse 7 beendet das Programm.
So funktioniert RTA.