====== Forth Target-, Cross-, Meta-Compiler ======

Klassische Forth-System sind interaktive Programmentwicklungssysteme. Ein kleiner Kern, der den vordefinierten Befehlsumfang festlegt, wird durch zusätzliche anwendungsspezifische Definitionen erweitert. Der Kern enthält zu diesem Zweck den Forth (Outer-)Interpreter. Es ist dessen Aufgabe den Forth-Quelltext zu lesen, zu zerlegen und dann zu verarbeiten. Die daraus hergestellte Anwendung enthälten daher immer auch noch den Forth-Interpreter. Er ist aber in der Anwendung nicht immer zugänglich - Turnkey-Applikation.

Ein anderer Ansatz Forth-Programme zu verarbeiten, der speziell für kleine eingebettete Systeme von Bedeutung ist, bedient sich klassischer Übersetzungstechnik bei der ein Übersetzer (Compiler) Forth-Programme annimmt und daraus Anwendungsprogramme erzeugt. Solche Übersetzungen werden häufig in sogenannten T-Diagrammen beschrieben:

<code>
+---------------------------+
| QUELL     comp       ZIEL |
+---------+       +---------+
          | IMPL  |
          +-------+
          | PLATF |
          +-------+
</code>

Programme in einer Quellsprache QUELL werden in Programme eine Zielsprache ZIEL übersetzt. Der Compiler comp selbst ist in einer Implementierungssprache IMPL programmiert und läuft auf einer Plattform PLATF ab. 
Das folgende Diagramm beschreibt die 8080 Variante tcom80 des Forth-Compilers TCOM:

<code>
+---------------------------+
| TCOM     tcom80      8080 |
+---------+       +---------+
          | F-PC  |
          +-------+
          |DOS/x86|
          +-------+
</code>

Er nimmt Programme im speziellen TCOM-Forth-Dialekt an und übersetzt sie in 8080-Maschinencode, der ablauffähig unter CP/M ist (.COM-Files). TCOM selbst ist dabei in klassischer Weise als Erweiterung des Forth-Systems F-PC programmiert, das unter DOS auf der x86-Plattform abläuft. Andere TCOM-Varianten übersetzen in Maschinencode vom x86, 68HC11 oder vom 6805, usw.

Im Zusammenhang mit dieser Art von Forth-Übersetzung werden Compiler mit unterschiedlichen Eigenschaften unterschiedlich bezeichnet. Man spricht hier oft von Forth Target-, Cross- oder Meta-Compilern. Alle diese Compiler akzeptieren Programme in einem - mehr oder weniger eingeschränkten - Forth-Dialekt und erzeugen daraus Programme in einer Zielsprache.

===== Forth Target-Compiler =====
 
Ein Forth Target-Compiler comp ist in einer nicht weiter eingeschränkten Art und Weise implementiert, häufig in Forth selbst. Die Beziehung zwischen Platform PLATF und Zielsprache ZIEL wird nicht weiter betrachtet. Sie können gleich oder unterschiedlich sein.

<code>
+---------------------------+
| Forth     comp       ZIEL |
+---------+       +---------+
          | IMPL  |
          +-------+
          | PLATF |
          +-------+
</code>

tcom80 im obigen Beispiel ist ein Target-Compiler.
tcom86 (mit 80x86 Maschinencode als Zielsprache) ist ebenfalls ein Target-Compiler.

===== Forth Cross-Compiler =====

Bei einem Forth Cross-Compiler sind Programme in der Ziel-Sprache auf dem Computer, auf dem der Übersetzer abläuft (ohne weiteres) selbst nicht ablauffähig. Die Übersetzung überquert (engl. cross) die Grenze zwischen zwei Platformen - ZIEL und PLATF.

<code>
+------------------------------+
| Forth      comp  ZIEL!=PLATF2|
+----------+       +-----------+
           | IMPL  |
           +-------+
           | PLATF |
           +-------+
</code>

tcom80 im obigen Beispiel ist ein Cross-Compiler, da Programme in seiner Zielsprache 8080 Maschinencode nicht (direkt) unter DOS/x86 ablauffähig sind.

tcom86 aber ist kein Cross-Compiler, da die von tcom86 erzeugten x86-Programme unter DOS ablaufen können.

===== Forth Meta-Compiler =====

Die von einem Forth Meta-Compiler comp erzeugten Programme sind auf der gleichen Plattform ablauffähig, auf der auch der Übersetzer selbst abläuft - ZIEL=PLATF. Zudem ist das zu übersetzende Forth-Programm häufig der Quellcode des Forthsystems selbst, also der Kern eines interaktiven Forth; typischerweise desjenigen Forth-Kerns mit dessen Hilfe der Meta-Compiler implementiert wurde - der Kern auf PLATF wird neu erzeugt und ergänzt.

<code>
          +-----------------------------+
    Kern  | Forth      comp   ZIEL=PLATF|  Kern in PLATF  
in Forth  +----------+       +----------+                
                     | Kern  |                          
                     +-------+                          
                     | PLATF |
                     +-------+
</code>

Der Meta-Compiler übersetzt sich also in gewisser Weise selbst (Bootstrap). Diese Selbstbezüglichkeit wird durch das Wort Meta ausgedrückt.

tcom80 ist kein Meta-Compiler, da seine Zielsprache 8080 Machinencode und seine Plattform x86 unterschiedlich sind. Ausserdem werden von tcom80 typischerweise keine Forth-Kerne übersetzt sondern Anwendungsprogramme.

tcom86 ist auch kein Meta-Compiler, obwohl Programme seiner Zielsprache x86 auf der gleichen Plattform (DOS/x86) ablaufen, auf der auch tcom86 selbst abläuft. tcom86 ist auf Grundlage von F-PC implementiert. Der Kern von F-PC kann von tcom86 nicht übersetzt werden. Von tcom86 werden typischerweise keine Forth-Kerne übersetzt sondern Anwendungsprogramme.

Das F-PC besitzt aber auch einen Meta-Compiler, mit dessen Hilfe der F-PC-Kern neu generiert und modifiziert werden kann:

<code>
            +-----------------------------+
kernel.seq  | Forth      meta     DOS/x86 |  kernel.com     
            +----------+       +----------+                
                       | F-PC  |                          
                       | kernel|                          
                       +-------+                          
                       |DOS/x86|
                       +-------+
</code>

----

Im Gegensatz zur klassischen Forth-Programmentwicklung, sind Target-, Cross-, und Meta-Compiler in der Regel nicht interaktiv, was eine Abkehr von erfolgreichen und überaus beliebten Forth-Prinzipien bedeutet. Eine weitere Richtung der Forth-Übersetzung widmet sich daher der interaktiven Cross-Programmierung - Interactive Remote Target Compilation, umbilical Forth, direct Programming. Damit werden Anwendungsprogramme interaktiv direkt auf dem Zielsystem entwickelt, ohne dass dort ein vollständiger Forth-Interpreter vorhanden sein muss.