 
 
 Units - oder: Wie vereinigen wir uns...?
 

 Dieses Kapitel soll die grundlegenden Dinge zur Arbeit mit
 sog. "Units", die in Pascal immer wieder vorkommen, erlutern.

 Beginnen wir mal leicht:
 Man kann Progamme schreiben, die gnzlich ohne Units auskommen,
 doch wird man an ihnen nicht viel Freude haben, da Units als
 ein fester Bestandteil von Pascal-Programmen anzusehen sind.
 Das fngt schon allein mit dem Befehl "ClrScr" in Pascal an.
 Diese Prozedur, die den Bildschirminhalt lscht, ist in der
 Unit CRT "deklariert". Man kann auf diesen Befehl nur dann zu-
 greifen, wenn man die Unit CRT eingebunden hat; und damit wren
 wir auch schon bei der eigentlichen Erklrung fr Units: Units
 sind Dateien, die genau wie ein Pascal-Programm selbst Befehle
 (Prozeduren und Funktionen), Konstanten, Datentypen u.s.w. be-
 inhalten, auf die man zugreifen kann. Eine Unit ist simpler-
 weise nichts anderes als ein Programm selbst, nur hat sie
 den Nachteil, da man aus ihr nicht eine lauffhige EXE-Datei
 erzeugen kann. Doch wenn das schon nicht klappt, was bietet
 eine Unit denn dann fr Vorteile ? Nun, es gibt zwei Dinge, die
 fr Units sprechen. Zum einen wre da natrlich die Sache, da
 die sich die meisten Pascal-Befehle in Units befinden, die man
 zwangslufig einbinden mu, um ein einigermaen funktionstch-
 tiges Programm zu bekommen. Doch bietet sich noch ein weiter
 Vorteil: Jede Unit stellt fr sich ein eigenes Code-Segment zur
 Verfgung und kann bis zu 64 KByte Code umfassen - die Gesamt-
 gre des Programms ist nur noch durch den zu Verfgung stehen-
 den Hauptspeicher begrenzt. Auch sollte der Gliederungsvorteil
 nicht auer acht gelassen werden, denn durch die Aufteilung des
 Hauptprogramms in kleinere Teile (Units) wird der Quell-Code
 wesentlich bersichtlicher.
   Hier noch einmal alle Vorteile von Units im berblick:

   o  Units mssen nicht bei jeder Vernderung des Hauptpro-
      gramms neu compiliert werden - die Compilierungszeiten
      werden krzer (soweit das bei Borland berhaupt noch
      mglich ist...).

   o  Jede Unit stellt ein eigenes Codesegment fr sich zur
      Verfgung, das bis zu 64 KByte umfassen kann. Somit ist
      die Gre des Hauptprogramms nur noch auf den zur Ver-
      fgung stehenden Hauptspeicher begrenzt.

   o  Durch die Aufteilung des Programms in Units wird eine
      wesentlich hhere bersichtlichkeit erreicht.



 Doch genug der Theorie
 

 Schreiben wir unser Programm mit Units...im folgenden gehe ich
 davon aus, da wenigstens die grundlegenden Befehle fr Pascal
 bekannt sind.


 PROGRAM UnitTest;
 USES CRT;
 BEGIN
  ClrScr;
  WriteLn('Hallo');
 END.

 Nun, wahrlich nicht sehr gro, aber es wird eine Unit einge-
 bunden, nmlich "CRT". Diese Unit steht hinter der reservierten
 Anweisung USES, die fr die Einbindung der Units zur Verfgung
 steht. Wollte man mehrere Units einbinden, so geschieht das
 genauso, nur werden die Units durch ein Komma getrennt angege-
 ben ( USES CRT, Dos; ). Nur durch die Einbindung der Unit CRT
 erhalten wir Zugriff auf die Prozedur "ClrScr". Diese ist, wie
 oben schon erwhnt, in dieser Unit deklariert. Doch woher wei
 ich, da ich die Unit CRT einbinden mu ? Es gibt insgesamt 5
 von Borland/Turbo Pascal vordeklarierte Units (von 2 weniger
 gebruchlichen abgesehen). Diese Units sind im einzelnen:

  o  CRT - Diese Unit dient zum steuern des Bildschirms.
     Hier sind die Prozeduren enthalten, die des Aussehen des
     Pogramms im Textmodus ndern, wie z.B. ClrScr , TextColor ,
     TextBackGround...

  o  DOS - Dies ist die Benutzerschnittstelle zum DOS. Hier sind
     alle Prozeduren enthalten, die Dateiverwaltungen unter DOS
     ermglichen, z.B. MkDir, Exec, GetFAttrib...

  o  Graph - Alle Funktionen, Variablen, Konstanten und Proze-
     duren, die fr den Umgang mit dem Grafikmodus von Bedeutung
     sind, sind hier deklariert, z.B. Circle, SetColor, SetLine-
     Style, InitGraph...

  o  Printer - Dies ist die Schnittstelle zum Drucker. Diese Unit
     enthlt nicht viele Befehle. Mit ihrer Hilfe kann man Texte
     auf dem Drucker ausgeben oder den Drucker allgemein steuern.

  o  Overlay - Diese Unit enthlt alle Routinen, die zur Verwal-
     tung von Overlays notwendig sind. In dieser Ausgabe unseres
     Disk-Mags gibt es auch ber Overlays einen Artikel. Schau'
     doch mal rein...

 Um es noch einmal zu verdeutlichen: Units sind Dateien, die 
 Prozeduren, Funktionen und Datentypen beinhalten knnen. Sie
 sind von der Grundlegenden Struktur zwar etwas anders, die pro-
 grammierung der Prozeduren etc. ist aber gleich. Deshalb ist es
 auch ein leichtes, Units selbst zu schreiben, wenn man einige
 grundlegende Dinge beachtet. Der Kopf einer Unit fngt anstelle
 von "PROGRAM" logischerweise mit...na..na..richtig, mit "UNIT"
 fngt er an. Danach folgt ein Teil, der gewhnlicherweise mit
 dem Wort "INTERFACE" bezeichnet wird. Ich habe es noch nicht
 mit einem anderen Wort versucht, aber es wrde sowieso nicht
 klappen. In diesem "INTERFACE" sind alle Datentypen deklariert.
 Weiterhin stehen hier nur die Prozedur- oder Funktionskpfe 
 derjenigen obigen, die sich in der Unit befinden und auf die man
 "ffentlich" zugreifen kann. ffentlich heit hier, da diese im
 "INTERFACE" genannten Prozeduren oder Funktionen im Haupt-
 programm verwendet werden drfen. Denn es gibt natrlich auch
 P+F (so werde ich im folgenden "Prozeduren und Funktionen" ab-
 krzen), die nur fr die Unit bestimmt sind, um z.B. eine klei-
 ne Nebenrechnung auszufhren, die nur fr die Unit relevant ist.
   Auf den "INTERFACE"-Teil folgt der "IMPLEMENTATION"-Teil, in
 dem sich alle P+F befinden. Abgeschlossen wird die Unit mit
 einem "END.", wenn keine Initialisierung beim Aufruf der Pro-
 zedur vorgenommen werden soll. Wenn doch, so endet eine Unit
 mit BEGIN ... END. In den drei Pnktchen knnen dann Initiali-
 sierungen vorgenommen werden, doch dazu kommen wir spter. Ich
 werde ein Beispiel fr eine Unit mit zwei Prozeduren und einer
 Funktion geben:

 ***************************************************************

 UNIT BspUnit;

 INTERFACE

  USES Crt;

  PROCEDURE Wri(x, y : INTEGER; Text : STRING);
  PROCEDURE Ton(Laenge : INTEGER);
  FUNCTION  IstWahr(Zahl : Byte) : BOOLEAN;

 IMPLEMENTATION

 VAR i : BYTE;

  PROCEDURE Wri(x, y : INTEGER; Text : STRING);
  BEGIN
   GotoXY(x, y);
   Write(Text);
  END;

  PROCEDURE Heraufzaehlen;
  BEGIN
   i := i+1;
  END;

  PROCEDURE Ton(Laenge : INTEGER);
  BEGIN
   i := 1;
   REPEAT
    Sound(300);
    Delay(Laenge);
    NoSound;
    Delay(100);
    Heraufzaehlen;
   UNTIL i = 5;
  END;

  FUNCTION IstWahr(Zahl : Byte) : BOOLEAN;
  BEGIN
   IF Zahl = 1 THEN IstWahr := TRUE
   ELSE IstWahr := FALSE;
  END;

 END.

 ***************************************************************

 So, dies wre geschafft. Nun zur Erklrung: Ich werde die Pro-
 zeduren und Funktionen selbst nicht erklren, denn es geht nur
 um den Aufbau von Units.

 1. UNIT : Dies ist der Bezeichner, da es sich um eine Unit
 handelt. Hinter UNIT kommt der Name der Unit. Unter diesem
 Namen mu die Unit nacher auch gespeichert werden.

 2. INTERFACE : Nun folgen die P+F-Deklarationen. Auf diese P+F
 kann man nacher zugreifen, d.h. nur diese kann man vom Haupt-
 programm aus aufrufen. Hier knnen auch ffentliche Datentypen-
 Deklarationen stehen. Fr unsere Unit brauchen wir aber keine.
 Wichtig zu sagen ist noch, da auch Units andere Units verwen-
 den knnen. Die USES-Anweisung steht dafr auch im INTERFACE.

 3. IMPLEMENTATION : Hier sind alle P+F und Datentypen in ihrer
 vollen Lnge aufgefhrt. Hier ist auch die nicht-ffentliche
 Variable "i". Sie kann spter nicht vom Hauptprogramm aus ver-
 ndert werden. Die Prozeduren "Wri" und "Ton" sowie die sehr
 sinnige Funktion "IstWahr" sind ffentlich deklarierte, weil im
 INTERFACE aufgefhrte P+F. Die Prozedur "Heraufzhlen" ist
 nicht-ffentlich, sie kann nur von den P+F der Unit verwendet
 werden.

 4. END. : Unsere Unit braucht keinen Hauptteil oder besser keine
 Initialisierung. Deshalb steht nur ein "END."

 Ich hoffe, es war nicht zu kompliziert. Nun folgt eine weitere
 Aufgabe: Die Nutzung unserer Unit. Ein Programm hilft uns wei-
 ter:

 ***************************************************************

 PROGRAM UnitDemo;

 USES BspUnit, Crt;

 BEGIN
  ClrScr;
  Wri(3,10,'HALLO, ANWENDER!!!');
  Ton(200);
 END.

 ***************************************************************

 In der USES-Anweisung haben wir nun unsere Unit "BspUnit" einge-
 bunden. Wir knnen nun gaaaanz einfach die Prozedur mit den
 Parametern aufrufen, als wren sie im Hauptprogramm deklariert.

 Aber, es mu noch etwas geschehen: Die Unit mu zu einer ".TPU"-
 Datei compiliert werden. Dazu mu das Ziel die Disk sein und
 nicht der Memory. (Compile => Destination Disk  - fr TP6 oder
 Compiler => Ausgabeziel Festplatte  - fr TP7). Dann compilie-
 ren wir mit "F9" und die ".TPU"-Datei befindet sich in dem da-
 fr bestimmten Verzeichnis (Options => Directory Units  - fr
 TP6 oder Option => Verzeichnisse Units  - fr TP7). Zur Kon-
 trolle seht doch mal unter DOS nach. brigens: Sobald eine
 nderung an der Original-Unit im Editor stattfand, mu die Unit
 wieder mit "F9" neu compiliert werden.

 Hoff'ma mal, da es grtenteils klar geworden ist, wie die
 ganze Sache funktioniert. Wenn nicht, die ganze Geschichte am
 besten nochmal durchlesen, die OnLine-Hilfe von Pascal fragen
 oder uns schreiben. Wenn ihr weiter Interesse habt: In dieser
 Ausgabe befindet sich ein Artikel ber "Overlays", die eng mit
 den Units im Zusammenhang stehen, und das nchste Mal gibts
 nochmal was ber Units, da es doch ein etwas komplexeres Thema
 ist.

                                      Nu' denn, euer
                                      Eric der Schreckliche
                                      Ŀ
                                      
                                      
                                      ٳ
                                        
                                        


