TURBO PASCAL 4.0 -- Zusammenfassung:                                                                        (c) Juli 1988 e. huber
------------------------------------                                                                        ----------------------
TGM_96: TURBO4.TXT
Ernst Huber, N86d, #687
1) Spezielle Symbole/Reservierte Wrter:
----------------------------------------
a) Spezielle Symbole:  +  -  *  /  =  [  ]  .  ,  (  )  :  ;  ^  @  {  }  #    statt { } auch (* *) verwendbar!
b) Reservierte Wrter: ABSOLUTE-AND-ARRAY-BEGIN-CASE-CONST-DIV-DO-DOWNTO-ELSE-END-EXTERNAL-FILE-FOR-FORWARD-FUNCTION-GOTO-IF-
                       IMPLEMENTATION-IN-INLINE-INTERFACE-INTERRUPT-LABEL-MOD-NIL-NOT-OF-OR-PACKED-PROCEDURE-PROGRAM-RECORD-
2) Typen:              REPEAT-SET-SHL-SHR-STRING-THEN-TO-TYPE-UNIT-USES-VAR-WHILE-WITH-XOR
---------
Einfache Typen: SHORTINT, INTEGER, LONGINT, BYTE, WORD, REAL, Single, Double, Extended, Comp;
Ordinale Typen: SHORTINT, INTEGER, LONGINT, BYTE, WORD, Boolean, CHAR;
INTEGER Typen : SHORTINT:       -128 ... +127         8 Bit mit Vz.:   REAL Typen: REAL    :   2.9*E-39 ... 1.7*E+38   11-12 Stellen
                INTEGER :     -32768 ... +32767      16 Bit mit Vz.;               Single  :   1.5*E-45 ... 3.4*E+38    7-8  Stellen
                LONGINT :-2147483648 ... +2147483647 32 Bit mit Vz.;               Double  :  5.0*E-324 ... 1.7*E+308  15-16 Stellen
                Comp    :ca. -9.2E18 ... ca. +9.2E18 64 Bit mit Vz.;               Extended: 1.9*E-4951 ... 1.1*E+4932 19-20 Stellen
                BYTE    :          0 ... +255         8 Bit Vorz.los;
                WORD    :          0 ... +65535      16 Bit Vorz.los;  String Typ: max. Stringlnge: 255 Zeichen (String[255]););
Strukt. Typen : ARRAY Typen :                               RECORD Typen:       Figure = RECORD  (* Variant Record *)
                ARRAY [1..100] OF REAL;                   ! Datum = RECORD    !   Date: Datum;
                ARRAY [Boolean, 1..10, Anzahl] OF REAL    !   Jahr : INTEGER; !   x, y: REAL;
                                                          !   Monat: 1..12;   !   CASE Art OF
                Als Indextyp: Alle ordinalen Typen ausser !   Tag  : 1..31;   !     Rechteck: (Hhe, Breite: REAL);
                SHORTINT, INTEGER, LONGINT!               ! END; (*REC Datum*)!     Dreieck : (Gre1, Gre2, Winkel: REAL);
                                                          !                   ! END; (* REC Figure *)
                Mengen Typen:  gr. und kl. Ordinalzahl des Mengentyps mssen im Bereich von (0..255) liegen; Leere Menge: [];
Zeiger Typen  : Beispiel fr eine einfache Verkettung:                    PointerTyp = ^StackStructure;
                (Aufbau einer einfach verketteten Liste:)                 StackStructure = RECORD
                 ----------     -----------            -----------          Data: CHAR;
                 !Data!Next----->!Data!Next-----> ...-->!Data!NIL!          Next: PointerTyp;
                 ----------     -----------            -----------        END;
Identische Typen:T1 = Char; T3 = Char;   T5 = SET OF Char;  T5, T6 = SET OF Char;  V1, V2: SET OF CHAR;   V1: SET OF Char;  V3: Char;
                 T2 = T1;   T4 = T3;     T6 = SET OF CHAR;  T5, T6 sind ident.     Var1, Var2 sd. ident.  V2: SET OF Char;  V4: Char;
                 T1, T2, T3, T4 sd. id.  T5, T6 nicht id.                                                 Nur V3, V4 sind identisch
Kompatib. von Typen: beide Typen sind gleich;                        !  beide Typen sd. Mengen-Typen mit kompat. Grundtypen
                     beide Typen sind REAL-Typen;                    !  beide Typen sd. gepackte Str.-T. mit gl. Anz. Kompon.
                     beide Typen sind INTEGER-Typen;                 !  ein Typ ist ein Str.-Typ und der andere ist ein
                     ein Typ ist ein Teilbereich eines anderen;      !     Str.-Typ, ein gepackter Str.-Typ od. ein Char-Typ;
                     beide Typen sd. Teilber. derselben Grundmenge;  !  ein Typ ist vordef. Typ Pointer, d. and. ein bel. Zeiger Typ
Zuweisungskompatib.: T1 u. T2 sd. komp. Ordinal-Typen, Wert von T2   !  T1 hat den Typ REAL, T2 den Typ INTEGER;
(fr T1:=T2)!              liegt im Wertebereich von T1;             !  T1 u. T2 sind gepackte String-Typen;
                     T1 u. T2 sd. REAL-Typen; der Wert von T2 fllt  !  T1 ist Str.-Typ, T2 ein gepackter Str.-Typ;
                           in den mgl. Wertebereich von T1;          !  T1 u. T2 sd. komp. Mengen-Typen, alle Elemente des
                     T1 u. T2 sd. String-Typen;                      !     Wertes v. T2 fallen in d. mgl. Werteber. von T1;
                     T1 ist String-Typ, T2 ein Char-Typ;             !  T1 u. T2 sd. komp. Zeiger-Typen;
Typen Definit.teil : TYPE Bereich   = INTEGER;                       !  Stellen   = SET OF 0..9;
                          Farbe     = (rot, grn, blau);             !  TestIndex = 1..100;
                          FArt      = ARRAY [Farbe] OF String [5];   !  TestList  = ARRAY [TestIndex] OF Farbe;

3) Variable: Beispiele fr gltige Variable-Definitionen:
---------------------------------------------------------
VAR  x, y, z: REAL;  !  VAR  Matrix: ARRAY [0..9,0..9] OF REAL;  !  VAR  Hintergrd: SET OF Farbe;  !  VAR  Art          : Farbe;
     Ziffern: 0..9;  !       Op : (plus, minus, mal);            !       Heute    : Datum;         !       Op1, Op2, Op3: WORD;

4) Typisierte Konstanten (Bsp's):
---------------------------------
Einfache Konst.: CONST Max  : INTEGER = 9999                      String Konst.: CONST Titel: String [5] = 'Titel';
                       CtrC : Char    = #3;
Strukt. Typ.: Arrays: CONST FStr  : FArt = ('rot','grn','blau');        Mengen: CONST GerZif: Stellen[0,2,4,6,8];
                            Digits: ARRAY [0..9] OF Char = '0123456789';               HexZif: SET OF '0'..'z'=['0'..'9','A'..'F'];
              Records:      Heute : Datum = (T: 30; M: Jan; J: 1987);    Zeiger:       PList : PointerTyp = nil;
5) Operatoren:                                                                         NoData : StackStructure = (Next: NIL;Data: '');
--------------
Arithmetische Operatoren: binre:               ! Logische Operatoren:                     !  Boolsche Operatoren:
Operator Operation    Operandentyp Ergebnistyp  ! Operator Operation        Op.typ Erg.typ !  Operator Operation    Op.typ   Erg.typ
   +     Addition     INT/REAL     INT/REAL/EXT !   NOT    bitweise Negat.  INT    INT     !    NOT    log. Neg.    BOOLEAN  BOOLEAN
   -     Subtraktion  INT/REAL     INT/REAL/EXT !   AND    bitweise UND     INT    INT     !    AND    log. UND     BOOLEAN  BOOLEAN
   *     Multiplikat. INT/REAL     INT/REAL/EXT !   OR     bitweise ODER    INT    INT     !    OR     log. ODER    BOOLEAN  BOOLEAN
   /     Division     INT/REAL     INT/REAL/EXT !   XOR    bitweise Antival INT    INT     !    XOR    log. Antiv.  BOOLEAN  BOOLEAN
  DIV    Int.division INT          INT          !   SHL    Linksschieben    INT    INT     !
  MOD    Modulo       INT          INT          !   SHR    Rechtsschieben   INT    INT     !
.
.
Arithmetische Operatoren: unre:                ! String Operatoren:                       !  Mengen Operatoren:
Operator Operation    Operandentyp Ergebnistyp  ! Operator Operation   Op.Typ      Erg.typ !  Operator Operation    Op.typ    Erg.typ
   +     Identitt    INT/REAL     INT/REAL/EXT !    +     Verbindung  STRING/CHAR STRING  !     +     Vereinigung  kompatib. Mengen
   -     Negation     INT/REAL     INT/REAL/EXT !                      PACKED STR.         !     -     Differenz    kompatib. Mengen
                                                !                                          !     *     Durchschnitt kompatib. Mengen
Relationale Operatoren:
Operator    Operation          Operandentyp                                                               Ergebnistyp
   =        gleich             kompatible einfache, Zeiger, Mengen-, String oder gepackte String Typen    BOOLEAN
  <>        ungleich           kompatible einfache, Zeiger, Mengen-, String oder gepackte String Typen    BOOLEAN
   <        kleiner            kompatible einfache, Zeiger, Mengen-, String oder gepackte String Typen    BOOLEAN
   >        grer             kompatible einfache, Zeiger, Mengen-, String oder gepackte String Typen    BOOLEAN
  <=        kleiner/gleich     kompatible einfache, Zeiger, Mengen-, String oder gepackte String Typen    BOOLEAN
  >=        grer/gleich      kompatible einfache, Zeiger, Mengen-, String oder gepackte String Typen    BOOLEAN
  <=        Untermenge von     kompatible Mengen Typen                                                    BOOLEAN
  >=        Obermenge von      kompatible Mengen Typen                                                    BOOLEAN
  IN        Element von        linker Operand: bel. Typ t; rechter Operand: SET OF Typ t                  BOOLEAN

Adress-Operator @:
   @        Adressermittlung   Variablenbezug, Funktions oder Prozedurbezeichner                      Pointer (derselbe Variablen-
                                                                                                               typ wie NIL)
6) Anweisungen und Schleifenbefehle / Beispiele:
------------------------------------------------
a) Einfache Anweisung: (Zuweisung x:=y;/Prozeduraufruf siehe unten/GOTO-Statement)
b) Strukturierte Anweisung:
   Verbundanweisung:        !  CASE-Anweisung:                                                    !  REPEAT-Schleife: (mit I=0)
     BEGIN                  !    CASE I OF                              CASE I OF                 !    REPEAT
       <Source>             !      0,2,4,6,8: WriteLn ('gerade');         1: BEGIN                !      Inc (I);
     END;                   !      1,3,5,7,9: WriteLn ('unger.');              WriteLn ('1+1= '); !      Writeln (I);
                            !      10..100  : WriteLn ('zw. 10-100');          WriteLn (2);       !    UNTIL (I > 99);
   Bedingte Anweisung:      !    ELSE BEGIN                                  END;                 !
     IF (x < y) THEN BEGIN  !      WriteLn ('negativ');                      ...                  !  WHILE-Schleife: (mit I=0)
        <Source>            !      WriteLn ('od. >100');                  9: BEGIN                !    WHILE (I <= 100) DO BEGIN
     END                    !    END;                                          WriteLn ('9+9= '); !      Inc (I);
     ELSE BEGIN             !  END; (* CASE I OF *)                            WriteLn (18);      !      WriteLn (I);
        <Source>            !                                                END;                 !    END; (* WHILE I<=100 *)
     END; (* IF (x < y) *)  !                                           END; (* CASE I OF *)      !
                                                                                                  !  FOR-Schleife:
   WITH-Anweisung: (Verkrzung des Bezugsweges auf Recordfeld)         Hinweis:                   !    FOR I:=1 TO 100 DO BEGIN
   ohne WITH:                      mit WITH:  WITH Datum DO BEGIN         ex. eine Variable 'Tag' !      WriteLn (I);
               Datum.Jahr:=1988;                  Jahr:=1988;             so wird trotzdem auf    !    END; (* FOR I *)
               Datum.Monat:=7;                    Monat:=7;               das Record-Element zu-  !    FOR I:=100 DOWNTO 1 DO BEGIN
               Datum.Tag:=22;                     Tag:=22;                gegriffen               !      WriteLn (I);
                                              END; (* WITH Datum *)                               !    END; (* FOR I *)
7) Prozedur- und Funktionsdeklarationen / Beispiele:
----------------------------------------------------
PROCEDURE ADDW (Op1: WORD; VAR Op2: WORD); ! Aufruf:               ! FUNCTION ADDW (Op1,Op2: WORD): WORD; ! Aufruf:
<lok. TYPE/CONST/VAR/PROC./FUNC.-Def.>     !   Op1:=5; Op2:=4;     ! <lok. TYPE/CONST/VAR/PROC./FUNC.-Def>!   Op1:=5; Op2:=4; Op3:=0;
BEGIN                                      !   ADDW (Op1,Op2);     ! BEGIN                                !   Op3:=ADDW (Op1,Op2);
  Op2:=Op1+Op2;                            !   Writeln (Op1); -> 5 !   ADDW:=Op1+Op2;                     !   WriteLn (Op1); -> 5
END; (* PROCEDURE ADDW *)                  !   WriteLn (Op2); -> 9 ! END; (* FUNCTION ADDW *)             !   WriteLn (Op2); -> 4
                                           !                       !                                      !   WriteLn (Op3); -> 9
8) Programme und Units:
-----------------------
Bsp Prg:PROGRAM Test;                         Bsp Unit:   UNIT Example;
          USES  <Liste der benutzten Units>               INTERFACE
          TYPE  <globale Typ-Definit.>                      USES <Liste der benutzten Units>
          VAR   <globale Variablendefinit.>                 <ffentliche Deklarationen> z.B. PROCEDURE Bsp (VAR Lsg: STRING);
          CONST <globale Konstantendefinit.>              IMPLEMENTATION
          <Includes>                                        <nicht ffentliche Deklarationen> z.B. PROCEDURE Bsp;
          <Prozedur- und Funktionsdef.>                                                              <Source>
        BEGIN                                                                                      END; (* PROC Bsp *)
          <Source>                                        BEGIN
        END. (* Test *)                                     <Source - z.B. Initialisierung aller ffentl. Var.>
                                                          END. (* UNIT Example *)
9) Standardprozeduren und Funktionen:
-------------------------------------
D I E   P R O Z E D U R E N   E X I T   U N D   H A L T:
Exit               beendet die Ausf. des mom. Blocks mit sofortiger Wirkung;              Dekl: Exit;
                   (Block: PROCEDURE  -> Sprung in die aufrufende Routine / Hauptprogr -> Programm wird beendet (wie HALT))
Halt               beendet Prgr. u. springt in den bergeordneten Prozess;                Dekl: Halt;
.
.
D Y N A M I S C H E   V E R W A L T U N G   D E S   S P E I C H E R S:
Dispose            gibt den Speicherplatz einer dyn. Var. frei;                            Dekl: Dispose (VAR p: Pointer);
FreeMem            gibt einen dyn. bel. Speicher best. Gr. frei;                           Dekl: FreeMem (VAR p: Pointer; size: WORD);
GetMem             bel. Speicher best. Gr. f. dyn. Var., setzt Zeiger auf d. Anf. d. Ber.; Dekl: GetMem (VAR p: Pointer; size: WORD);
Mark               hlt den Zust. des Heaps in einer Zeigervariablen fest;                 Dekl: Mark (VAR p: Pointer);
MaxAvail           liefert (lft.) d. Gr. d. grten freien Heap-Bereichs, ermittelt,         Dekl: MaxAvail;               Erg: LONGINT;
                   wieviele BYTEs momentan max. fr eine dyn. Var. belegt werden knnen;
MemAvail           lft. die Gesamtzahl der freien BYTEs auf dem Heap;                      Dekl: MemAvail;               Erg: LONGINT;
New                erz. dyn. Var., setzt Zeiger auf d. Anf. des durch diese Var. bel. Ber.;Dekl: New (VAR p: Pointer);
Release            setzt den Heap auf den mit MARK festgehaltenen Zust. zurck;            Dekl: Release (VAR p: Pointer);

T R A N S F E R   F U N K T I O N E N:
Chr                lft. Zeichen mit entspr. Ordinalzahl zurck;                            Dekl: Chr (x: BYTE);    Erg: Char;
Ord                lft. die Ordinalzahl des angeg. (ordinalen) Wertes;                     Dekl: Ord (x);          Erg: LONGINT;
Round              konvertiert REALwert in einen LONGINT, rundet auf oder ab;              Dekl: Round (x: REAL);  Erg: LONGINT;
Trunc              konv. REAL in einen LONGINT, Nachkommast. werden abgeschnitten;         Dekl: Trunc (x: REAL);  Erg: LONGINT;

A R I T H M E T I S C H E   F U N K T I O N E N:
Abs                lft. den absoluten Wert des Arguments;      Dekl: Abs (x);           Erg: derselbe Typ wie Arg.;
Arctan             lft. den Arcustangens des Arg.;             Dekl: ArcTan (x: REAL);  Erg: REAL;
Cos                lft. den Cosinus des Arg.;                  Dekl: Cos (x: REAL);     Erg: REAL;
Exp                e=2.7182..., liefert e hoch Arg.;           Dekl: Exp (x: REAL);     Erg: REAL;
Frac               lft. die Nachkommastellen;                  Dekl: Frac (x: REAL);  Erg: REAL;
Int                lft. ganzzahligen Anteil des Arg.;          Dekl: Int (x: REAL);   Erg: REAL;
Ln                 lft. den natrlichen Logarithmus des Arg.;  Dekl: Ln (x: REAL);    Erg: REAL;
Pi                 lft. den Wert Pi (3.141592...) zurck;      Dekl: Pi;              Erg: 3.14....... (REAL);
Sin                lft. den Wert des Arg. zurck;              Dekl: Sin (x: REAL);   Erg: REAL;
Sqr                lft. das Quadrat des Arg. zurck;           Dekl: Sqr (x);         Erg: hat selben Typ wie Arg.;

O R D I N A L E   P R O Z E D U R E N   U N D   F U N K T I O N E N:
Dec                erniedrigt Variable;                                Dekl: Dec (x [,n]);      Erg: x:=x-1 oder x:=x-n;
Inc                erhht Variable;                                    Dekl: Inc (x [,n]);      Erg: x:=x+1 oder x:=x+n;
Odd                prft ob das Arg. ein unger. Zahl ist (ung->TRUE);  Dekl: Odd (x: LONGINT);  Erg: Boolean;
Pred               lft. den Vorgnger des Arg. zurck;                 Dekl: Pred (x);          Erg: hat denselben Typ wie Arg.;
Succ               lft. den Nachfolger des Arguments zurck;           Dekl: Succ (x);          Erg: hat denselben Typ wie Arg.;

S T R I N G P R O Z E D U R E N   U N D   - F U N K T I O N E N:
Concat             verbindet eine Folge von Strings und liefert das Erg.; Dekl: Concat (s1 [,s2,s3,...]: String);        Erg: String;
Copy               lft. einen Teil (cnt Zeichen ab Pos i) eines Strings;  Dekl: Copy (s: String; i, cnt: INTEGER);       Erg: String;
Delete             lscht einen Teil (cnt Zeichen ab Pos i) eines Str.;   Dekl: Delete (VAR s: String; i, cnt: INTEGER);
Insert             fgt einen Stringteil in einen String (ab Pos i) ein;  Dekl: Insert (source: String; VAR dest: String; i: INTEGER);
Length             lft. die dyn. Lnge des Strings zurck;                Dekl: Length (s: String);                      Erg: INTEGER;
Pos                sucht Zeichenfolge innerhalb eines Str. u. lft. ihre Pos.;   Dekl: Pos (substring: String; s: String);Erg: BYTE;
Str                konvertiert einen numerischen Wert in einen String;    Dekl: Str (x [ :width [ :decimals]], VAR s: String);
Val                konvertiert einen String in einen numerischen Wert;    Dekl: Val (s: String; v; VAR code: INTEGER);

Z E I G E R   U N D   A D R E S S F U N K T I O N E N:
Addr               lft. die Adresse des angeg. Objekts;                                     Dekl: Addr (x);             Erg: Pointer;
CSeg               lft. den mom. Wert des CS-Registers;                                     Dekl: CSeg;                 Erg: WORD;
DSeg               lft. den mom. Wert des DS-Registers;                                     Dekl: DSeg;                 Erg: WORD;
Ofs                lft. d. Offsetadr. des ang. Objekts, dh die Adr. innerh. eines Segments.;Dekl: Ofs (x);              Erg: WORD;
Ptr                konv. 2 Werte fr Segment u. Offset in einen Zeigerwert u. lft. d. Erg.; Dekl: Ptr (seg, ofs: WORD); Erg: Pointer;
Seg                lft. die Segmentadr. des ang. Obj.;                                      Dekl: Seg (x);              Erg: WORD;
SPtr               lft. den mom. Wert des SP-Reg.;                                          Dekl: SPtr;                 Erg: WORD;
SSeg               lft. den mom. Wert des SS-Reg.;                                          Dekl: SSeg;                 Erg: WORD;

P R O Z E D U R E N   U N D   F U N K T I O N E N   Z U R   D A T E I - B E A R B E I T U N G:
Append             ffnet eine Datei f. d. Anhngen weiterer Dateien;                Dekl: Append (VAR f: Text);
Assign             ordnet einer Datei-Var. eine externe Datei zu;                    Dekl: Assign (VAR Name: String);
BlockRead          liest ein od. mehrere Records einer Datei in eine Puffervariable; Dekl: BlockRead (VAR f: File; VAR buf;
                   (result gibt die Anz. der komplett gelesenen Records wieder);                      count: WORD; [,result: WORD]);
BlockWrite         schreibt ein od. mehr. Records aus einer Puffervar.in eine Datei; Dekl: BlockWrite (VAR f:File; VAR buf;
                                                                                                       count: WORD;[,result:WORD]);
ChDir              wechselt das Standard-Directory;                                  Dekl: ChDir (s: STRING);
Close              schliet eine Datei;                                              Dekl: Close (f) (f=DateiVariable);
Eof                prft ob das Ende einer Datei erreicht ist;                       Dekl: Eof(f) / Eof(VAR f: Text); Erg: Boolean;
Eoln               prft ob die Pos. innerh. einer Dat. auf einem Zeilenende steht;  Dekl: Eoln(f); Eoln(VAR f:Text); Erg: Boolean;
Erase              lscht eine Datei;                                                Dekl: Erase (f);
FilePos            liefert die mom. Pos. innerhalb einer Datei;                      Dekl: FilePos (f);  Erg: LONGINT;
FileSize           liefert die Gre einer Datei;                                    Dekl: FileSize (f); Erg:  LONGINT;
.
.
GetDir             ermittelt das mom. ges. Directory eines Lw.;                      Dekl: GetDir (d: BYTE; VAR s: STRING);
IOResult           liefert den Fehlerstatus der letzten I/O-Operation;               Dekl: IOResult; Erg: WORD;
MkDir              erzeugt ein Subdirectory;                                         Dekl: MkDir (s: STRING);
Read               liest eine od. mehr. Komponenten aus einer typisierten Datei bzw. Dekl: Read (f, v1 [,v2,..,vn]);
                   einen od. mehrere Werte aus einer Textdatei in die ang. Variablen;      Read ([VAR f: Text;] v1 [,v2,..,vn]);
ReadLn             fhrt einen Aufruf von READ aus u. springt dann zum Anfang der    Dekl: ReadLn ([VAR f: Text;] v1 [,v2,..,vn]);
                   nchsten Zeile innerhalb der ang. Datei
Rename             gibt einer ext. Diskettendatei einen nen Namen;                  Dekl: Rename (f; newname: STRING);
Reset              ffnet eine exist. Datei (vorher ASSIGN);                         Dekl: Reset (f [:FILE; recsize: WORD]);
Rewrite            erzeugt und erffnet eine ne Datei;                              Dekl: Rewrite (f[: file; recsize: WORD]);
RmDir              lscht ein leeres Subdirectory;                                   Dekl: RmDir (s: STRING);
Seek               setzt den Pos.zeiger in einer Datei auf eine best. Komponente;    Dekl: Seek (f; n: LONGINT);
SeekEof            prft ob sich zw. d. mom. Pos. u. d. Ende einer Datei noch lesbare Daten bef.;    Dekl: SeekEof [(VAR f: Text)];
SeekEoln           prft. ob sich zw.d.mom.Pos.u.d.folg. Zeilenende einer Dat.noch lesbare Daten bef.;Dekl: SeekEoln [(VAR f: Text)];
SetTextBuf         weist einer Textdatei-variablen einen Puffer zu;          Dekl: SetTextBuf (VAR f: Text; VAR buf [; size: WORD]);
Truncate           schneidet eine Datei an der mom. Pos. ab;                         Dekl: Truncate (f);
Write              schreibt Daten in eine Datei;        Dekl: Write (f, v1 [,v2,..,vn]); oder Write ([VAR f: Text;] v1 [,v2,..,vn]);
WriteLn            schreibt Daten in eine Datei und schliet mit einem CReturn ab;   Dekl: WriteLn ([VAR f: Text;] v1 [,v2,..,vn]);

V E R S C H I E D E N A R T I G E   S T A N D A R D P R O Z E D U R E N   U N D   F U N K T I O N E N:
FillChar           fllt Speicherber. (Staddr x) ang. Gr.(cnt) BYTEweise mit best. Wert;   Dekl: FillChar (VAR x, cnt: WORD; ch)
Hi                 lft. das hherwertige BYTE des Arg.;                                    Dekl: Hi (x), x: Int. od WORD; Erg: BYTE;
Lo                 lft. das niederwertige BYTE des Arg.;                                   Dekl: Lo (x), x: Int. od WORD; Erg: BYTE;
Move               kopiert eine Anz. von BYTEs v. einem Speicherber. in einen anderen;     Dekl: Move (VAR source, dest; cnt: WORD);
ParamCount         lft.d. Anz. d. Kommandozeilen-Param. mit denen ein Prg. gestartet wurde;Dekl: ParamCount;         Erg: WORD;
ParamStr           lft. einen Kommandozeilen-Parameter;                                    Dekl: ParamStr (index: WORD);Erg: String;
Random             lft. eine Zufallahl (mit Randomize initialisieren);                    Dekl: Random [(Range: WORD)];
Randomize          initialisiert den eingebauten Zufallahlengenerator;                    Dekl: Randomize;
SizeOf             lft. die Gr. des ang. Obj. in BYTEs;                                    Dekl: SizeOf (x);            Erg: WORD;
Swap               vertauscht hherwert. und niederwert. BYTE des Arg.                     Dekl: Swap (x);              Erg: wie Arg.;
UpCase             konvertiert ein Zeichen in einen Grobuchstaben;                        Dekl: UpCase (ch: Char);     Erg: Char;

10) UNIT DOS:
------------
I N T E R R U P T - P R O Z E D U R E N:
GetIntVec          ermittelt die Adr. auf die ein Intr.-Vektor zeigt; Dekl: GetIntVec (IntNo: BYTE; VAR Vector: Pointer);
Intr               fhrt einen Software-Intr. aus;                    Dekl: Intr (IntNo: BYTE; VAR Regs: Registers);
MsDos              fhrt einen DOS-Funktionsaufruf aus;               Dekl: MsDos (VAR Regs: Registers);
SetIntVec          setzt einen Interrupt-Vektor auf eine best. Adr.;  Dekl: SetIntVec (IntNo: BYTE; Vector :Pointer);

P R O Z E D U R E N   F U E R   D A T U M   U N D   U H R Z E I T:
GetDate            ermittelt das mom. Kalenderdatum des Systems;              Dekl: GetDate (VAR Year, Month, Day, DayOfWeek: WORD);
GetFTime           erm. Datum/Uhrzeit d. letzten Vernd. einer offenen Datei; Dekl: GetFTime (VAR f; VAR Time: LONGINT)
GetTime            ermittelt die mom. gesetzte Uhrzeit des Systems;           Dekl: GetTime (VAR Hour, Min, Second, Sec100: WORD);
PackTime           konv.Rec. d.Typs DATETIME in Strukt. v. 4 BYTEs f.SETFTIME;Dekl: PackTime (VAR DT: DateTime; VAR Time: LONGINT);
SetDate            setzt das KalenderDatum des Systems;                       Dekl: SetDate (Year, Month, Day, DayOfWeek: WORD);
SetFTime           setzt Modifikationsdatum und Uhrzeit einer offenen Datei;  Dekl: SetFTime (VAR f Time: LONGINT);
SetTime            setzt die Uhrzeit des Systems;                             Dekl: SetTime (Hour, minute, Second, Sec100: WORD);
UnpackTime         konv. eine gepackte Struktur von 4 BYTEs in einen Record   Dekl: UnpackTime (Time: LONGINT; VAR DT: DateTime);
                   des Typs DateTime; Derartige Strukturen werden von GetFTime, FindFirst und FindNext erzeugt;

S T A T U S F U N K T I O N E N   F U E R   F D -   U N D   H D - L A U F W E R K E:
DiskFree           lft. die Anz. d. freien BYTEs auf dem ang. Lw.;  Dekl: DiskFree (Drive: WORD); Erg: LONGINT
                   (0..mom. akt. Lw, 1=A, 2=B,...  (gilt auch fr DiskSize));
DiskSize           lft. die Ges.Gr. des Datentrgers im ang. Lw.;  Dekl: DiskSize (Drive: WORD); Erg: LONGINT

P R O Z E D U R E N   Z U R   B E A R B E I T U N G   V O N   D A T E I E I N T R A E G E N:
FindFirst          sucht angeg. bzw. mom. gesetztes Directory nach dem   Dekl: FindFirst (Path: String; Attr: BYTE; VAR S: SearchRec);
                   1. Eintrag ab, der einen best. Dateinamen und festgelegten Attributen entspr.;
                   Attr.konst: ReadOnly =$01, Hidden =$02, SysFile =$04, VolumeID =$08, Directory =$10, Archive =$20, AnyFile =$3F;
FindNext           setzt eine mit FindFirst begonnene Suche fort;        Dekl: FindNext (VAR S: SearchRec);
GetFAttr           ermittelt die Attribute einer Datei;                  Dekl: GetFAttr (VAR f; VAR Attr: WORD); (Attr. wie oben);
SetFAttr           setzt die Attribute einer Datei;                      Dekl: SetFAttr (VAR f; Attr: BYTE); (Attr. wie oben);

P R O C E D U R E N   U N D   F U N K T I O N E N   F U E R   P R O Z E S S E:
DosExitCode        lft. den Exit-Code eines mit Execute gestarteten Progr;                        Dekl: DosExitCode;   Erg: WORD;
Execute            startet ein Progr., dem zus. Kommandozeilen-Param. bergeben werden knnen;    Dekl: Exec (Path, CmdLine: String);
                   (Fehler werden in der globalen Variable 'DosError' gespeichert);
                   Achtung: bei Compil. eines Prgr., d. EXEC/KEEP benutzt mu auf jed. Fall eine Max.Gr. d. Heap festgelegt werden.
Keep               beendet ein Programm und macht es speicherresisdent;                           Dekl: Keep (ExitCode: WORD)
.
.
11) UNIT Crt:
------------
AssignCrt          ordnet dem Bildschirm eine Textdatei-Variable zu;                              Dekl: AssignCrt (VAR f: Text);
ClrEol             lscht smtl. Zeichen ab d. mom. Pos. d. Crs bis zum rechten Fensterrand;      Dekl: ClrEol;
ClrScr             lscht den ges. Fensterinhalt u. setzt d. Curs. in die l.o. Ecke des Fensters  Dekl: ClrScr;
Delay              hlt die Programmausf. fr die ang. Anz. von Millisek. an;                     Dekl: Delay (ms: WORD);
DelLine            lscht Zeile in d. sich d. Crs bef., schiebt d. unteren Zeilen nach; letzte Zeile leer;  Dekl: DelLine;
GotoXY             Setzt d. Text-Crs auf d. ang. Spalten- Zeilenpos., rel. zur linken, ob. Ecke d. Windows; Dekl: GotoXY (x, y: BYTE);
HighVideo          setzt d. Zeichenfarbe auf hervorgehoben (Bsp: glob. Var. TextAttr:=LightGray); Dekl: HighVideo;
InsLine            fgt Leerzeile an d. Cursorpos ein, untere Zeilen werden abwrtsgerollt;       Dekl: InsLine;
KeyPressed         prft die Tast. u. lft. TRUE zurck wenn eine Taste gedr. wurde, ans. FALSE;   Dekl: KeyPressed;
LowVideo           setzt die Zeichenf. auf halbe "Intensit."; (Bsp: glob. Var. TextAttr:=White);  Dekl: LowVideo;
NormVideo          setzt die Zeichenfarbe auf "normal";                                           Dekl: NormVideo;
NoSound            schaltet den eingebauten Lautsprecher ab;                                      Dekl: NoSound;
ReadKey            liest ein Zeichen v. d. Tast., ohne es autom. auf d. Bildschirm auugeben;     Dekl: ReadKey;       Erg: Char;
RestoreCrt         setzt wieder den Videomodus, der beim Start des Programms aktiv war;           Dekl: RestoreCrt;
Sound              erzeugt einen Ton im eingebauten Lautsprecher;                                 Dekl: Sound (Hz: WORD);
TextBackground     setzt die Hintergrundfarbe fr folgende Textausgaben;                          Dekl: TextBackground (Color: BYTE);
TextColor          setzt die Zeichenfarbe fr folgende Textausgaben;                              Dekl: TextColor (Color: BYTE);
                   (Konst.: (Vg/Hg:) Black =0, blue =1, Green =2, Cyan =3, Red =4, Magenta =5, Brown =6, LightGray =7)
                   (Vg:) DarkGrey=8,Lightblue=9,LightGreen=10,LightCyan=11,LightRed=12,LightMagenta=13,Yellow=14,White=15,Blink=128);
TextMode           setzt einen (Text-)Videomodus; Konst.:BW40=0,C40=1,BW80=2,C80=3,Mono=7,Last=-1;Dekl: TextMode (Mode: WORD);
WhereX             lft. d. mom. Spaltenpos.(x) d. Crs rel. zur linken Fensterkante (beginnt mit 1)Dekl: WhereX;  Erg: BYTE;
WhereY             lft. d. mom. Zeilenpos.(y) d. Crs rel. zur oberen Fensterkante (beginnt mit 1);Dekl: WhereY;  Erg: BYTE;
Window             def. ein Textfenster auf d. Screen; (x1,y1: l.o.; x2,y2: r.u.; Crs auf 1,1);   Dekl: Window (x1, y1, x2, y2: BYTE);

12) UNIT Graph:
--------------
Arc                zeichnet einen Kreisbogen v. einem Start- zu einem End-               Dekl: Arc (x,y: INTEGER;
                   winkel u. verw. eine Koord. (x,y) als Kreismittelpkt;                            StartAngle, EndAngle, Radius: WORD);
Bar                zeichnte einen Balken mit d. mom. ges. Farbe u. d. akt. Fllmuster;   Dekl: Bar (x1, y1, x2, y2: INTEGER);
                   (x1,y1: links oben, x2,y2: rechts unten);
Bar3D              zeichnet einen 3-dim. Balken mit der mom. ges. Farbe                  Dekl: Bar3D (x1, y2, x2, y2: INTEGER;
                   u. dem akt. Fllmuster; (Depth: ruml. Tiefe, typ.: 25%  Breite                  Depth: WORD; Top: Boolean);
                   (x2-x1 div 4); Top: Konst: TopOn (TRUE), TopOff (FALSE) (Deckel zeichnen))
Circle             zeichnet einen vollst. Kreis mit geg. Rad. um einen Mittelpkt x,y     Dekl: Circle (x, y: INTEGER; Radius: WORD);
ClearDevice        setzt alle Parameter des Grafikpakets auf Standardwerte;              Dekl: ClearDevice;
ClearViewPort      lscht das mom. gesetzte Grafikfenster;                               Dekl: ClearViewPort;
CloseGraph         beendet das Grafikpaket;                                              Dekl: CloseGraph;
DetectGraph        prft die vorh. Hardware u. best. welcher Grafiktreiber geladen       Dekl: DetectGraph (VAR GraphDriver,
                   u. welcher Modus gesetzt werden mu;                                                         GraphMode: INTEGER);
                   Konst.: Detect=0 (autom. Erkennung), CGA=1, MCGA=2, EGA=3, EGA64=4, EGAMono=5, RESERVED=6, HercMono=7, VGA=9;
DrawPoly           zeichnet den Umri eines Polygons in mom. ges. Linenfarbe und -art;   Dekl: DrawPoly (NuPts: WORD; VAR PolyPoints);
Ellipse            zeichnet einen ellipt. Kreisausschnitt von einem Start zu einem Endwinkel um einen Mittelpunkt (x,y) herum;
                   Dekl: Ellipse (x,y: INTEGER; StartAngle, EndAngle: WORD; XRadius, YRadius: WORD);
FillPoly           fllt ein Polygon;                                                    Dekl: FillPoly (NuPts: WORD; VAR PolyPoints);
FloodFill          fllt einen umschlossenen Bereich mit dem mom. ber                   Dekl: FloodFill (x, y, Border:WORD);
                   SetFillStyle bzw. SetFillPattern gesetzten Muster;
GetArcCoords       bestimmt die Koord. des zuletzt gez. Kreisausschnitts;                Dekl: GetArcCoords (VAR AC: ArcCoordsType);
GetAspectRatio     bestimmt das tatsl. Darstellungsverhltnis des benutzten Bilschirms;  Dekl: GetAspRatio (VAR XAsp, YAsp: WORD);
GetBkColor         lft. die mom. ges. Hintergrundfarbe;                                  Dekl: GetBkColor;  Erg: WORD;
GetColor           lft. die mom. ges. Zeichenfarbe zurck;                               Dekl: GetColor;  Erg: WORD;
GetFillSettings    fragt d. mit SetFillStyle od. SetFillPattern ges. Param. ab;Dekl: GetFillSettings (VAR FillInfo: FillSettingsType);
GetGraphMode       lft. den mom. ges. Grafikmodus zurck;                                Dekl: GetGraphMode;  Erg: INTEGER;
GetImage           speichert den Inhalt eines rechteckigen Bilausschnitts bitweise in einer Puffervariablen;
                   Dekl: GetImage (x1, y1, x2, y2: WORD; VAR BitMap);
GetLineSettings    fragt die durch SetLineStyle gesetzten Parameter ab (Art, Muster, Dicke);
                   Dekl: GetLineSettings (VAR LineInfo: LineSettingsType); Konst: siehe SetLineStyle;
GetMaxX            lft. die grsstmgl. X-Koord. des mom. akt. Grafikmodus;               Dekl: GetMaxX;  Erg: WORD;
GetMaxY            lft. die grsstmgl. Y-Koord. des mom. akt. Grafikmodus;               Dekl: GetMaxY;  Erg: WORD;
GetPalette         ermittelt die mom. gesetzte Farbpalette und ihre Gre;               Dekl: GetPalette (VAR Palette: PaletteType);
GetPixel           lft. die Farbe des Pixels auf den angegebenen Koordinaten zurck;     Dekl: GetPixel (x, y: INTEGER);  Erg: WORD;
GetTextSettings    fragt d. mit SetTextStyle u. SetTextJustify best. Param. ab;Dekl: GetTextSettings (VAR TextInfo: TextSettingsType);
                   Konst: DefaultFont =0, TriplexFont =1, SmallFont=2, SansSerifFont =3, GothicFonst =4;
                   HorizDir =0, VertDir =1, NormSize =1;
GetViewSettings    ermittelt die Grenzen des mom. ges. Grafikfensters und die Bed. fr das Clipping;
                   Dekl: GetViewSettings (VAR ViewPort: ViewPortType);
GetX               lft. die mom. X-Position des Grafik-Cursors;                          Dekl: GetX;  Erg: INTEGER;
GetY               lft. die mom. Y-Position des Grafik-Cursors;                          Dekl: GetY;  Erg: INTEGER;
GraphErrorMsg      lft. die zum ang. Fehlercode gehrige Meldungals String;              Dekl: GrapherrorMsg (ErrorCode: INTEGER);
.
.
GraphResult        lft. den mom. Fehlerstatus des Grafikpakets als INTEGERwert;          Dekl: GraphResult;  Erg: INTEGER;
                   Konst: grOk =0, grNoInitGraph =-1, grNotDetected =-2, grFileNotfound =-3, grInvalidDriver =-4, grNoLoadMem =-5;
                          grNoScanMem =-6, grNoFloodMem =-7, grFontNoFound =-8, grNoFontMem =-9, grInvalidMode =-10;
ImageSize          lft. die Anz. v. BYTEs, die zur Speicherung eines best.               Dekl:ImageSize (x1, y1, x2, y2: WORD);
                   Ausschnitts mit GetImage gebraucht werden;
InitGraph          initialisiert das Grafikpaket und schaltet in den Grafikmodus um; (Konst: Siehe DetectGraph)
                   Dekl: InitGraph (VAR GraphDriver: INTEGER; VAR GraphMode: INTEGER; DrivePath: String);
Line               zeichnet eine Linie von (x1,y1) nach (x2,y2);                         Dekl: Line (x1, y1, x2, y2: INTEGER);
LineRel            zeichnet eine Linie rel. zur mom. Pos. des Grafik-Cursors;            Dekl: LineRel (Dx, Dy: INTEGER);
LineTo             zeichnet eine Linie v. d. mom. Pos. d. Grafik-Crs aus zur ang. Koord.;Dekl: LineTo (x, y: INTEGER);
MoveRel            bewgt. den Grafik-Cursor von seiner mom. Pos. aus um den ang Betrag;  Dekl: MoveRel (Dx, Dy: INTEGER);
MoveTo             setzt den Grafik-Cursor auf den ang. Punkt;                           Dekl: MoveTo (x, y: INTEGER);
OutText            gibt einen String ab der mom. Pos. des Grafik-Cursors aus;            Dekl: OutText (TextString: String);
OutTextXY          gibt einen String ab der ang. Pos. aus;                               Dekl: OutTextXY (x,y: INTEGER; TStr: String);
PieSlice           zeichnet einen Kreisauschnitt, verbindet seine Enden mit dem Mittelstck und fllt die entstandene Flche;
                   Dekl: PieSlice (x, y: INTEGER; StAngle, EndAngle, Radius: WORD);
PutImage           kopiert den Inhalt einer Puffervariablen in einen rechteckigen Ausschnitt des Bildschirms;
                   Dekl: PutImage (x,y: WORD; VAR BitMap; BitBlt: WORD);
                   Konst: NormalPut =0, XorPut =1, OrPut =2, AndPut =3, NotPut =4;
PutPixel           zeichnet einen einz. Punkt auf den ang. Koord.;                       Dekl: PutPixel (x, y,: INTEGER; Color: WORD);
Rectangle          zeichnet ein Rechteck in der mom. ges. Farbe und d. akt. Linienart;   Dekl: Rectangle (x1, y1, x2, y2: INTEGER);
RestoreCrt         setzt den Videomodus der beim Start des Programms aktiv war;          Dekl: RestoreCrt;
RestoreCrtMode     setzt den Videomodus der beim Aufruf von InitGraph aktiv war;         Dekl: RestoreCrtMode;
SetActivePage      setzt eine Bildschirmseite fr folgende Ausgaben;                     Dekl: SetActivePage (Page: WORD);
SetAllPalette      setzt smtl. Eintrge einer Farbpalette neu;                          Dekl: SetAllPalette (VAR Palette);
                   Konst: Black=0, blue =1, Green =2, Cyan =3, Red=4, Magenta =5, Brown =6, LightGrey =7, DarkGrey =8, Lightblue =9,
                          LightGreen =10, LightCyan =11, LightRed =12, LightMagenty =13, Yellow =14, White =15, MaxColors =15;
SetBkColor         setzt die Hintergrundfarbe fr folgende Zeichenaktionen;              Dekl: SetBkColor(Color: WORD);
SetColor           setzt d. Zeichenfarbe f. folg. Zeichenakt.(benutzt akt. Farbpalette); Dekl: SetColor (Color: WORD);
SetFillPattern     setzt ein benutzerdefiniertes Fll-Muster;       Dekl: SetFillPattern (Pattern: FillPatternType); Col: WORD);
SetFillStyle       setzt ein vordef. Fllmuster;                                         Dekl: SetFillStyle (Pattern ,Col: WORD);
                   Konst: EmptyFill =0, SolidFill =1, LineFill =2, LtSlashFill =3, SlashFill =4, BkSlshFill =5, LtBkSlashFill =6;
                          HatchFill =7, XHatchFill =8, InterleaveFill =9, WideDotFill =10, CloseDotFill =11, UserFill =12;
SetGraphMode       setzt einen Grafikmodus und lscht den Bildschirm;                    Dekl: SetGraphMode (Mode: INTEGER);
                   Konst.: EGALo, EGAHi, EGAMonoHi, HercMonoHi;
SetLineStyle       setzt Breite und Muster fr nachfolgende Linien;                      Dekl: SetLineStyle (LnSt,Muster,Dicke: WORD);
                   Konst.:SolidLn =0, DottedLn =1, CenterLn =2, DashedLn =3, UserBitLn =4; NormWidth =1; ThickWidth =3
SetPalette         setzt einen Eintrag in einer Farb-Palette;                            Dekl: SetPalette (ColNum: WORD; Color:BYTE);
SetTextJustify     setzt Param. f. d. Justierung v. Textausg. via OutText und OutTextXY;
                   Dekl: SetTextJustify (Horiz, Vert: WORD); Konst.: LeftText, CenterText, RightText, BottomText, TopText;
SetTextStyle       setzt einen Zeichensatz, den Stil und den Vergrsserungsfaktor;
                   Dekl: SetTextStyle (Font, Direction,: WORD; CharSize: WORD); (Fonts: siehe GetTextSettings);
SetViewPort        setzt ein Zeichenfenster in der Grafik;  Konst: ClipOn, ClipOff;
                   Dekl: SetViewPort (x1, y1, x2, y2: WORD; Clip: Boolean); (x1, y1: links oben; x2, y2: rechts unten);
SetVisualPage      bringt eine von mehreren Grafikseiten auf den Bildschirm;             Dekl: SetVisualPage (Page: WORD);
TextHeight         lft. die Hhe eines Strings (in Punkten);                             Dekl: TextHeight (TxtStrg: STRING); Erg:WORD;
TextWidth          lft. die Breite eines Strings (in Punkten);                           Dekl: TextWidth (TxtStrg: STRING); Erg: WORD;

13) Vordefinierte Typen:
------------------------
SearchRec = RECORD            ! FillSettingsType = RECORD              ! TextSettingsType = RECORD ! ViewPortType = RECORD
   Fill: ARRAY[1..2] OF BYTE; !   Pattern: WORD;                       !    Font     : WORD;       !   x1, y1, x2, y2: WORD;
   Attr: BYTE;                !   Color  : ARRAY [1..8] OF SHORTINT    !    Direction: WORD;       !   Clip          : BOOLEAN;
   Time: LONGINT;             ! END;                                   !    ChartSize: WORD;       ! END;
   Size: LONGINT;             !                                        !    Horiz    : WORD;       !
   Name: STRING [12];         !                                        !    Vert     : WORD;       !
END;                          ! FillPatternType = ARRAY [1..8] OF BYTE ! END;                      !

LineSettingsType = RECORD ! PalleteType = RECORD ! ArcCoordsType = RECORD               ! Register = RECORD
  LineStyle: WORD;        !   Size:   WORD;      !   X, Y      : INTEGER; (Mittelpunkt) !  CASE INTEGER OF
  Pattern  : WORD;        !   Colors: WORD;      !   Xs, Ys,              (Startpunkt)  !  0: (AX,BX,CX,DX,BP,SI,DI,DS,ES,Flags:WORD);
  Thickness: WORD;        ! END;                 !   Xend, Yend: WORD;    (Endpunkt)    !  1: (AL,AZH,BL,BH,CL,CH,DL,DH: BYTE);
END;                      !                      ! END;                                 ! END;
