- Dieser Thread ist der Diskussions-Thread zu Tutorial - Compiler und Virtual Machine:
- Anmerkungen und Kritik, Lob sowie sonstige Meldungen bitte HIER im Diskussionsthread!
Die alten Beiträge lasse ich zu Dokumentationszwecken
Viel Spaß mit dem Tutorial und liebe Grüße
Puretom
------------------------------------------------------------------------------------------
*** IHNHALTSVERZEICHNISSE ***
ÜBERBLICK
1. Vorwort, Ziele
2. Literaturempfehlungen
3. Das große Bild
4. Schrittweise Entwicklung eines lexikalischen Scanners
5. Kurze Einführung in Assembler/Maschinensprache
6. Statements und Blocks: Die Struktur eines Programms
7. Parsen und Kompilieren mathematischer Ausdrücke (Expressions)
8. Module Code und ein erster Zwischenstopp
9. Wesentliche Erweiterung des mathematischen Parsers
10. Variablen, Deklarationen, Zuweisungen (Assignments) oder "Wir erzeugen unser erstes echtes Programm"
GESAMTINHALTSVERZEICHNIS
1. Vorwort, Ziele
- 1.1. Zu meiner Person
1.2. Der Plan
2. Literaturempfehlungen
- 2.1. Literatur, die mir half, meinen ersten Compiler zu programmieren
2.2. Literatur, die hilfreich ist, wenn man schon eine Ahnung von Compilern hat
2.3. Literatur, die mir persönlich überhaupt nichts sagte
2.4. Abschließende zusammenfassende Betrachtungen
3. Das große Bild
- 3.1. Einleitung
3.2. Überlick über die Teile des gesamten Projekts- 3.2.1. Der Compiler
3.2.2. Der Assembler
3.2.3. Die Virtual Machine (VM)
- 3.2.1. Der Compiler
4. Schrittweise Entwicklung eines lexikalischen Scanners
- 4.1. Vorbemerkungen
4.2. Hintergrundgedanken zum Scanvorgang
4.3. Das Grundgerüst des Scanners, laden und testen des Character Streams
4.4. Das Ende einer Programmzeile und Semikolons
4.5. Die Token-Typen und die Is?()-Erkennungsprozeduren
4.6. Die Get()-Prozeduren und die Token-Codes- 4.6.1. GetToken(), GetName(), GetNum(), GetString(), GetOther()
4.6.2. Die Token-Codes()
- 4.7.1. Die neue Start()-Prozedur
4.7.2. Die Token-Lexem-Schleife des späteren Parsers, eine Debug-Prozedur
4.7.3. Erster Testlauf des Scanners
4.7.4. SkipWhite(), das Überspringen von White-Zeichen
4.7.5. SkipLineComment(), das Überspringen von Zeilenkommentaren
4.7.6. SkipBlockComment(), das Überspringen von Kommentarblöcken
4.7.7. Die Error()-Prozeduren
- 4.6.1. GetToken(), GetName(), GetNum(), GetString(), GetOther()
5. Kurze Einführung in Assembler/Maschinensprache
- 5.1. Vorbemerkungen
5.2. Was ist Maschinensprache?
5.3. Was ist ein Stack?
5.4. Auswerten von mathematischen Ausdrücken in Assembler- 5.4.1. Berechnungen in einer Stack Machine
5.4.2. Berechnungen in einer Registermaschine mit wenig Registern
- 5.4.1. Berechnungen in einer Stack Machine
6. Statements und Blocks: Die Struktur eines Programms
- 6.1. Der Plan
6.2. Einleitende Worte zum Aufbau eines Programms
6.3. Start-Gerüst für den Parser des 6. Kapitels
6.4. Compile()-Prozedur: Lesen des Token-Lexem-Stroms
6.5. Ein Statement (Befehl, Anweisung)- 6.5.1. Prozedur Compile() und Prozedur Statement()
6.5.2. Das Erkennen von Befehlswörtern in Statement()
6.7. Der Gesamt-Code von Kapitel 6 (mit dem kompletten Scanner von Kapitel 4) - 6.5.1. Prozedur Compile() und Prozedur Statement()
7. Parsen und Kompilieren mathematischer Ausdrücke (Expressions)
- 7.1. Vorbemerkungen zur Präzedenz von Operatoren
7.2. Das Gerüst des Expression Parsers
7.3. Parsen eines Operanden: ValueFactor()
7.4. Parsen von Addition und Subtraktion: AddExpression()- 7.4.1. Einfachste Ausdrücke mit maximal 2 Operanden und einem Operator
7.4.2. Einfache Ausdrücke mit beliebiger Anzahl von Operatoren
7.6. Wie funktionert der mathematische Parser- 7.6.1. Beispiel 1: Höchste Ebene 1-mal erreicht
7.6.2. Beispiel 2: Höchste Ebene 2-mal erreicht
7.6.3. Zusammenfassende Erklärung mit 2 expliziten Stacks
7.8. Negation: negative Zahlen und Klammerausdrücke- 7.8.1. Negative Zahlen: Unäre Operatoren
7.8.2. Negative Klammerausdrücke
7.10. Code-Teil: Compiler von Kapitel 7 - 7.4.1. Einfachste Ausdrücke mit maximal 2 Operanden und einem Operator
8. Module Code und ein erster Zwischenstopp
- 8.1. Vorbemerkungen
8.2. Module Code- 8.2.1. Code-Ausgabe in die .ta-Datei
8.2.2. Die neuen Hilfsprozeduren zur Label-Verwaltung
- 8.3.1. Die neue Hilfsprozedur SkipToken()
8.4. Das Konzept der Start-Prozeduren
8.5. Das Gerüst des Compilers von Kapitel 8
8.6. Der gesamte Code bis Kapitel 8
8.7. Kurzanleitung für Quereinsteiger - 8.2.1. Code-Ausgabe in die .ta-Datei
9. Wesentliche Erweiterung des mathematischen Parsers
- 9.1. Hinzufügen neuer Operatoren: Vergleiche, boolesche Operatoren wie < <= <> = >= > and or xor
- 9.1.1. Die neue Präzedenztabelle. Eine Diskussion
9.1.2. Mathematischer Parser, Erweiterung um die Operatoren "< <= <> = >= > and or xor"
9.3. Hinzufügen eines neuen Operators: Potenzieren ^- 9.3.1. Erster naiver und falscher Ansatz
9.3.2. Operatorassoziativität und der Vorschlag einer Lösung
9.4. Hinzufügen des unären logischen Not- 9.4.1. Vorüberlegungen
9.4.2. Diskussion: logisches Not und die Operatoren and, or und xor?
9.4.3. Diskussion: logisches Not und die restlichen Operatoren?- 9.4.3.1. Not-Operator mit sehr hoher Präzedenz (ohne Code)
9.4.3.2. Not-Operator mit Präzedenz genau über "and, or, xor" (mit Code)
9.4.3.3. Eine noch niedrigere Präzedenz für not?
9.4.3.4. Einige Worte zur Assoziativität von not
- 9.4.3.1. Not-Operator mit sehr hoher Präzedenz (ohne Code)
9.6. Zusammenfassung
9.7. Code des Compilers von Kapitel 9 - 9.1.1. Die neue Präzedenztabelle. Eine Diskussion
10. Variablen, Deklarationen, Zuweisungen (Assignments) oder "Wir erzeugen unser erstes echtes Programm"
- 10.1. Wichtige taktische Entscheidung: Wer verwaltet die Variablen
- 10.1.1. Der Assembler verwaltet die Variablen (gewählte Variante)
10.1.2. Der Compiler verwaltet die Variablen
10.2. Eine weitere taktische Entscheidung: Müssen Variablen deklariert werden?
10.3. Aussehen einer Variablendeklaration in VM-ASM
10.4. Parsen/Kompilieren eines ersten echten Programms
10.5. Parsen/Kompilieren der Deklaration einer globalen Integer-Variable
10.6. Assignment: Das Zuweisen eines Wertes an eine Variable - 10.1.1. Der Assembler verwaltet die Variablen (gewählte Variante)
... lange Baustelle
*** ENDE IHNHALTSVERZEICHNISSE ***