Ein Beispiel fr ein Takefile: PURE.T
----------------------------------------------------------------------

Hier  soll  einmal ein Takefile etwas ausfhrlicher besprochen werden.
Es handelt sich um ein Takefile fr Pure C fr Programme,  die nur aus
einem  C-Quelltext  bestehen  (also  gewissermaen  das Gegenstck zum
DEFAULT.PRJ von Pure C).

Bentigt werden insgesamt drei Dateien:
 - PURE.TPURE.T     das eigentliche Takefile
 - PURE.LNKPURE.LNK   eine Liste der Libraries fr den Linker
 - COMPILE.TCOMPILE.T  ein Unter-Takefile zum bersetzen eines C-Quelltexts

Folgende Voraussetzungen mssen gegeben sein:

 - $OBJ ist der Pfad, in dem die Objektfiles abgelegt werden
 - $PRGPATH ist der Pfad, in dem die Programme abgelegt werden
 - $TAKE ist der Pfad, in dem die Takefiles und PURE.LNKPURE.LNK stehen
 - der Quelltext,  der bersetzt werden soll, ist als aktueller Quell-
   text angemeldet;  das fertige Programm bekommt den Namen des Quell-
   textes mit Extension $PRGEXT

Tip:  ffnen Sie sich fr die folgenden Erluterungen ein zweites Fen-
ster,  in  dem Sie sich die jeweils besprochene Datei anzeigen lassen.
Dazu  wird an mehreren Stellen auf dieser Seite auf diese Dateien ver-
wiesen.

Dies ist PURE.TPURE.T:

 ; Einfach-Takefile fr Pure C fr Programme, die nur
 ; aus einem C-Quelltext bestehen.
 ; Bentigt COMPILE.TCOMPILE.T und PURE.LNKPURE.LNK (dort ggfs. Pfade anpassen!).
 ; 
 cls                                  ; CLI-Fenster lschen
 if !$OBJ\%%.o || TIME($OBJ\%%.o<%.c) ; Compilieren ntig?
   $TAKE\compile.t                    ;   ja, auf geht's
   if $?                              ;   alles OK?
     return -1                        ;     nein, Abbruch
   endif
 endif
 if !$PRGPATH\%%.$PRGEXT || TIME($PRGPATH\%%.$PRGEXT<$OBJ\%%.o)
   if $OBJ\a.o
     rm $OBJ\a.o >NIL:
   endif
   ren $OBJ\%%.o $OBJ\a.o             ;     Objektfile umbenennen
   ld #4 -S=8192 -C=$TAKE\PURE.LNK    ;     Linker aufrufen
   ren $OBJ\a.o $OBJ\%%.o
   if $?                              ;     Linker-Fehler aufgetreten?
     echo Linker Error #$?            ;       ja, ausgeben
     return -2
   else
     if $PRGPATH\%%.$PRGEXT
       rm $PRGPATH\%%.$PRGEXT >NIL:
     endif
     ren $PRGPATH\linker.out $PRGPATH\%%.$PRGEXT
   endif
 else
   echo %%.$PRGEXT is up to date!
 endif

Zunchst  wird  berprft,  ob  der  Quelltext berhaupt neu bersetzt
werden mu.  Fehlt das Objektfile [!$OBJ\%%.o] oder ist das Objektfile
lter als der Quelltext [TIME($OBJ\%%.o<%.c)],  dann mu neu bersetzt
werden.  Dazu  wird das Takefile COMPILE.TCOMPILE.T aufgerufen,  das gleich an-
schlieend  besprochen  wird.  Meldet dieses einen Returnwert ungleich
Null zurck [if $?],  so ist ein Fehler aufgetreten und auch das aktu-
elle Takefile wird abgebrochen und meldet eine -1 an den Aufrufer.

Unabhngig  davon,  ob  compiliert wurde oder nicht  (solange nur kein
Fehler aufgetreten ist),  wird nun berprft, ob der Linker aufgerufen
werden mu.  Dies ist dann der Fall,  wenn das Programmfile nicht exi-
stiert  [!$PRGPATH\%%.$PRGEXT]  oder die Programmdatei lter ist,  als
das Objektfile [TIME($PRGPATH\%%.$PRGEXT<$OBJ\%%.o)].

In PURE.LNK stehen die Namen der Dateien, die der Linker zusammenfgen
soll. PURE.LNK sieht so aus (die Pfade men ggfs. angepat werden!):

 -O=d:\pure\exec\linker.out
 d:\pure\lib\pcvstart.o
 d:\pure\obj\a.o
 d:\pure\lib\pcbgilib.lib
 d:\pure\lib\pcfltlib.lib
 d:\pure\lib\pcstdlib.lib
 d:\pure\lib\pcextlib.lib
 d:\pure\lib\pctoslib.lib
 d:\pure\lib\pcgemlib.lib

Die erste Zeile gibt an,  da das fertige Programm "LINKER.OUT" heien
soll  und  in der dritten Zeile wird fr das Objektfile der Name "A.O"
vorausgesetzt.  Da man von einem Takefile aus diese Namen nicht ndern
kann, men die Dateien in PURE.TPURE.T entsprechend umbenannt werden (siehe
dort):

Zunchst wird eine evtl. noch vorhandene Datei A.O gelscht,  dann das
Objektfile in A.O umbenannt.  Anschlieend wird der Linker aufgerufen.
Alle Optionen, die in der Linker-Optionsbox eingestellt wurden, werden
bergeben  [#4],  als Stack werden 8 KByte angegeben [-S=8192] und die
Dateien, die gelinkt werden sollen, stehen in PURE.LNKPURE.LNK im Ordner $TAKE
[-C=$TAKE\PURE.LNK].  Nachdem der Linker fertig ist, erhlt A.O wieder
seinen richtigen Namen. Anschlieend wird der Rckgabewert des Linkers
ausgewertet. Ist er ungleich Null [if $?], so ist ein Fehler aufgetre-
ten.  Die  Nummer des Fehlers wird ausgegeben und das Takefile beendet
(an  den  Aufrufer wird -2 zurckgegeben).  Andernfalls erhlt nun das
fertige  Programm,  das  ja  noch  LINKER.OUT heit,  seinen richtigen
Namen.  Eine  evtl. noch vorhandene ltere Programmversion wird vorher
gelscht.


Kommen wir nun zu COMPILE.T. Dieses Takefile bernimmt die eigentliche
bersetzung des C-Quelltextes und sieht so aus:

 ; Unter-Takefile: C-Quelltext compilieren, rev. 03.02.1994
 env ERRORS=$OBJ\errors.out
 echo Compiling "%%.c"
 repeat
   if env(PROJECT)               ; luft ein Projekt?
     cc $OPTC $* %.c >$ERRORS    ;   ja, Compiler so aufrufen
   else
     cc #2 %.c >$ERRORS          ;   nein, Compileroptionen bernehmen
   endif                        
   if $?==0                      ;  kein Fehler?
     grepr Warning $ERRORS >NIL: ;    Text `Warning' in errors.out?
     if $?==0
       rm $ERRORS >NIL:          ;      nein, lschen
     endif
   endif
   if $ERRORS                    ;  existiert errors.out?
     ed %.c $ERRORS              ;    ja, Editor aufrufen
     if $?==0                    ;    nicht nochmal compilieren?
       return -1                 ;      Abbruch
     endif
   else
     if $OBJ\%%.o
       rm $OBJ\%%.o
     endif
     mv %.o $OBJ\%%.o            ;    *.o-Datei nach $OBJ verschieben
   endif                     
 until !$ERRORS                  ; bis kein errors.out mehr existiert
 env ERRORS

Dieses Takefile ist so ausgelegt, da es auch in anderem Zusammenhang,
nmlich  bei  der  Nachbildung  der Pure-C-Projects,  verwendet werden
kann. Daher die Unterscheidung anhand der Environmentvariable $PROJECT
(unter  den Beispiel-Takefiles,  die Sie zusammen mit Chatwin bekommen
haben, sollte sich auch das Project-Beispiel befinden).

In unserem Zusammenhang ruft  COMPILE.TCOMPILE.T  zunchst den Compiler mit den
Optionen  aus seiner Optionsbox auf (#2).  Die Ausgaben werden in eine
Datei  "ERRORS.OUT"  umgelenkt.  Meldet  der  Compiler  keinen  Fehler
[if $?==0],  so wird diese Datei mit einem Hilfsprogramm nach dem Text
"Warning" durchsucht, da der Compiler leider keinen speziellen Rckga-
bewert fr den Fall kennt,  da nur Warnings, aber keine echten Fehler
aufgetreten sind.  Wurden auch keine Warnings gefunden, wird die Datei
ERRORS.OUT gelscht.

Als  nchstes wird berprft,  ob ERRORS.OUT noch vorhanden ist.  Wenn
ja,  dann  hat der Compiler offenbar Fehler oder Warnings im Quelltext
gefunden.  Daher  wird in diesem Fall der Editor mit dem Quelltext und
der  Fehlerliste  aufgerufen.  Durch den Rckgabewert des Editors wird
nun entschieden, ob der (dann vermutlich genderte) Quelltext nochmals
compiliert  werden soll,  oder ob das Takefile abgebrochen werden soll
[if $?==0 / return -1].

Mute der Editor dagegen gar nicht aufgerufen werden,  so wird nun die
vom  Compiler  erzeugte Objektdatei,  die noch im gleichen Verzeichnis
wie der Quelltext steht,  in das Verzeichnis fr alle Objektfiles ver-
schoben [mv %.o $OBJ\%%.o].

Dieser  ganze Vorgang wird in einer repeat-until-Schleife solange wie-
derholt, bis keine Datei ERRORS.OUT mehr existiert [until !$ERRORS].
