Wie schreibe ich ein Takefile?
----------------------------------------------------------------------

Ein  Takefile ist eine einfache ASCII-Datei.  Eine solche Datei sollte
die  Extension  *.T  haben.  Pro  Zeile  steht  darin  immer genau ein
Befehl(swort).  Als  Zeilentrenner  versteht Chatwin das auf dem Atari
bliche  CR/LF,  sowie  einzelne  LF.  Die Befehle knnen beliebig mit
Leerzeichen  eingerckt  werden.  Ein Kommentar in einem Takefile wird
mit  einem  Semikolon  ";"  eingeleitet  (eine Zeile kann auch nur aus
einem Kommentar bestehen).

Es gibt mehrere Mglichkeiten,  ein Takefile zu starten.  Die einfach-
sten  sind sicher ber den Menpunkt "anderes Takefile"  (letzter Ein-
trag  im  Take-Men),  sowie durch eintippen des Namens im CLI (analog
zum Aufruf eines Programms). Andere Mglichkeiten bieten sich ber den
takeMAN\TAKE.MAN-Befehl, sowie im Zusammenhang mit dem EditorEDITOR.TXT.

Zunchst  einmal ist es sinnvoll,  sich mit einigen Besonderheiten der
Chatwin-Kommandosprache vertraut zu machen. Es gibt zwei Arten von Be-
fehlen:  Solche,  die  nur  in Takefiles verwendet werden knnen,  und
solche,  die  im  CLI im Direktmodus und in Takefiles verwendet werden
knnen.  Zur ersten Sorte gehren die Befehlsgruppen wie ifMAN\IF.MAN/else/endif
oder  Schleifen  wie  repeatMAN\REPEAT.MAN/until sowie die Befehle forceMAN\FORCE.MAN und appendMAN\APPEND.MAN.
Die Mitglieder der zweiten Gruppe knnen Sie einfach ermitteln,  indem
Sie im CLI die Help-Taste drcken.

Das  zweite  wichtige  Konzept in Chatwin ist das des aktuellen Quell-
textes.  Dieser  wird  mit dem ersten Eintrag im Men "Take" oder ber
den  Befehl  fnameMAN\FNAME.MAN angemeldet.  Ab dann kann diese Datei einfach durch
ein  Prozentzeichen "%" angesprochen werden.  Dabei merkt sich Chatwin
aber  nur  den Pfad- und Dateinamen ohne Extension!  Sind Sie in einer
Situation nur am Dateinamen (ohne Pfad und Extension) interessiert, so
knnen Sie darauf mit einem doppelten Prozentzeichen "%%" zugreifen.

Der  Grund,  warum  die  Extension  nicht  behalten wird,  ist einfach
folgender: Im Normalfall geht es darum, einen Quelltext einer bestimm-
ten  Programmiersprache zunchst in eine Objektdatei  (oder ggfs. noch
in  eine Assemblerdatei)  und schlielich in ein ausfhrbares Programm
zu berfhren. Dabei bleibt der Dateiname selbst erhalten, whrend die
Extension in einem bestimmten Schema wechselt  (z.B. *.C nach *.S nach
*.O nach *.PRG).  Diesen Wechsel wird man dann in einem Takefile "fest
verdrahten", whrend der Dateiname selbst variabel bleibt.

Schlielich  mu man noch wissen,  da jedes aus Chatwin heraus aufge-
rufene  Programm oder Takefile einen Integer-Wert  (also eine Zahl mit
dem  Wertebereich -32768 bis +32767)  zurckgibt.  Dieser Rckgabewert
ist ber die Zeichenfolge $? verfgbar  (bis zum nchsten Aufruf eines
Programms  oder Takes).  Dies gilt auch fr die fest angemeldeten Pro-
gramme,  die ber die Befehle edMAN\ED.MAN, ccMAN\CC.MAN, asMAN\AS.MAN, ldMAN\LD.MAN und dbMAN\DB.MAN aufgerufen werden.
blicherweise bedeutet der Rckgabewert 0,  da keine Fehler aufgetre-
ten  sind,  Werte kleiner als 0 stehen fr bestimmte (Betriebssystem-)
Fehlermeldungen,  whrend Werte grer 0 fr eigene Meldungen zur Ver-
fgung stehen.

Gewappnet  mit  diesen  Informationen  soll nun ein einfaches Takefile
entstehen. Ein blicher Ablauf bei der Programmentwicklung ist folgen-
der: Eine Datei wird in den Editor geladen und verndert. Anschlieend
soll  sie  vom  Compiler  bersetzt und vom Linker in ein ausfhrbares
Programm  verwandelt  werden.  Natrlich  macht der Aufruf des Linkers
keinen  Sinn,  wenn der Compiler einen Fehler gefunden hat.  In diesem
Fall  soll  daher  wieder  der Editor aufgerufen werden.  Hat man sich
Editor,  Compiler  und Linker auf den entsprechenden Menpunkten ange-
whlt,  so  stehen diese Programme nun ber die Befehle ed,  cc und ld
zur  Verfgung.  Im folgenden wird von der Programmiersprache C ausge-
gangen  (da  wir ja eine Extension fr den Quelltext bentigen),  ohne
auf irgendwelche Besonderheiten wie Compileroptionen zu achten.

Eine erste Implementierung knnte so aussehen:

   ed %.c       ; Editor mit Quelltext aufrufen
   repeat       ; wiederhole ...
     cc %.c     ;   Compileraufruf
     if $?!=0   ;   Rckgabewert ungleich 0?
       ed %.c   ;     dann Editor aufrufen
     endif
   until $?==0  ; bis Rckgabe gleich 0 (kein Fehler)
   ld %.prg=%.o ; Linker aufrufen (mit Phantasie-Optionen)

Bei  nherer  Betrachtung  offenbart sich jedoch ein Fehler:  Wenn der
Compiler einen Fehler meldet  (Rckgabewert ungleich Null)  wird zwar,
wie  gewnscht,  der  Editor aufgerufen.  Dieser berschreibt nun aber
durch  seinen  eigenen  Rckgabewert  den  des  Compilers,  so da mit
einiger  Wahrscheinlichkeit  die  Schleife  abgebrochen  wird,  da der
Editor ja keinen Fehler meldet.  Dann wird natrlich der Linker aufge-
rufen,  ohne  da  nochmals der Compiler ber den genderten Quelltext
gelaufen ist.

Nebenbei bemerkt lt sich die etwas kryptisch wirkende Zeile
   if $?!=0
auch krzer als
   if $?
schreiben - die Wirkung ist dieselbe.

Zweiter Versuch:

   repeat
     ed %.c     ; Editor
     cc %.c     ; Compiler
   until $?==0  ; Schleife wiederholen, falls Rckgabe ungleich 0
   ld %.prg=%.o ; Linkeraufruf

Dies  funktioniert  wie  erwnscht.  Man kann dieses einfache Beispiel
noch  ausbauen.  So  knnte man den Editor gleich noch mit einer  (vom
Compiler erzeugten) Liste der Fehlermeldungen aufrufen. Unter den mit-
gelieferten Takefiles befinden sich einige etwas komplexere Beispiele,
die Sie sich einmal ansehen sollten.

Unter  diesen  Beispielen befindet sich auch das Takefile PURE.T,  das
unter `Beispiel-TakefileTAKES\EXAMPLE.TXT' nher erklrt wird.
