Im Magazin „CHIP SPECIAL", Ausgabe 1, wurde der folgende Artikel abgedruckt.

Dieses Programm beschreibt eine Methode zur Dokumentation von TURBO-Pascal-Programmen.

PLIST kreiert Spitzen-Listings

*	liefert die schönsten und informativsten Pascal-Listings
*	lückenlose Zeilennummern
*	Markierung der reservierten Wörter
*	an jeden Drucker anzupassen
*	druckt INCLUDE-Files auf Wunsch
*	hält automatisch Abschnitte zusammen
*	zeigt Verschachtelungstiefe
*	voll TLIST kompatibel
*	erzeugt CROSSREFERENZ-Liste
*	durch binäre Suchbäume sehr schnell

Man kann halt nicht alles haben. TURBO-Pascal bietet ein so ausgezeichnetes Preis/Leistungsverhältnis, daß man die Mängel des mitgelieferten Ausdruckprogramms TLIST gern in Kauf nimmt. Denn, ganz abgesehen von den wenigen Möglichkeiten, dieses Programm arbeit zudem noch fehlerhaft. So werden zwar nicht alle reservierten Worte gefunden, dafür aber auch in Kommentaren und Strings unterstrichen. Druckeranpassungen sind nicht vorgesehen. Bei der Zeilenummerierung treten bei Punkt-Kommandos immer Lücken auf. Und je nachdem, ob man INCLUDE-Files ausgedruckt haben will oder nicht, muß man die Aufrufe hierfür im Quelltext hin- und herschieben.

Doch jetzt können Sie dieses Programm getrost löschen. Mit PLIST erhalten Sie einen Pascal-Lister, der auch höchsten Ansprüchen gerecht wird.

Bedienung

Die Anwendung des Programms ist stark an die von TLIST angelehnt. Nach dem Aufruf erscheint auf dem Bildschirm:

  PLIST vers, 3.6
  Programmname oder ? oder RETURN
  fuer Ende

Die Eingabe eines Fragezeichens bewirkt die Anzeige einer kurzen Programmerläuterung mit einer Beschreibung der Formatieranveisungen (siehe Bild).
Wenn Sie einen Programmanmen eingeben und das entsprechende File gefunden wird, können Sie unter folgenden Optionen beliebig viele auswählen:

L	Zeilennummern werden ausgedruckt
M	reservierte Wörter werden markiert
I	Include-Files werden ausgedruckt
A	Textabschnitte werden zusammengehalten
V	Verschachtelungstiefe wird angezeigt
C	Crossreferensliste wird erzeugt

Optionen

Die Optionen L und M entsprechen denen von TLIST. Die Markierung der reservierten Wörter kann im Programm an ihren Drucker angepasst werden. Falls sie mehrere Drucker besitzen, können Sie ja auch mehrere Versionen des Programms erstellen. Die Programme hier im Heft wurden mit einem Typenraddrucker erstellt. Zur Hervorhebung der reservierten Wörter wurde ein dreifacher Schattendruck eingestellt. Bei Matrixdruckern bietet sich auch fett-kursiv oder unterstrichen-kursiv an.

Include-Files werden auf demselben Laufwerk erwartet, auf dem sich auch das Hauptprogramm befindet. Wenn ein Include-file ausgedruckt wird, erscheint auf dem Bildschirm 'Including '. Falls ein File gesucht aber nicht gefunden wird, erfolgt die Meldung 'Include-File not found'.

Die Option A bewirkt, daß Textabschnitte auf einer Seite zusammengehalten werden, wann immer das möglich ist. Erfolgt nämlich ein Seitenumbruch mitten in einer verschachtelten Aaweisungsfolge, so geht der ganze Überblick verloren. Wenn also ein Textabschnitt nicht mehr ganz auf die laufende Seite paßt, so wird gleich eine neue Seite begonnen. Anfang und Ende von Textabschnitten werden durch Leerzeilen, Punktkommandos und Include-Anweisungen definiert. Da Sie innerhalb von kleineren Blöcken kaum Leerzeilen einfügen, entsprechen die Textabschnitte meist unmittelbar auch logischen Abschnitten.

Die Ausgabe der Verschachtelungstiefe ergibt eine zusätzliche Information, der besonders große Bedeutung bei der Fehlersuche in Programmen zukommt. Gerade im Hochschulbereich wird auf die Angabe der Verschachtelungstiefe großer Wert gelegt. Ein vergessenes 'END' oder falsch gasetzte Kommentarzeichen zum Beispiel werden schnell und sicher erkannt.

Eine Crossreferenz-Liste (=Querverweisliste) wird man sich immer dann mit ausdrucken lassen, wenn ein Programm überarbeitet, ergänzt oder woanders eingebaut werden soll. Alle anwenderdefinierten Bezeichner werden alphabetisch sortiert mit Angabe ihrer Vorkommen (=Zeilennummer) ausgedruckt. Dabei wird, wie auch vom Compiler, nicht zwischen Groß- und Kleinschrift unterschieden. Falls ein Bezeichner in einer Zeile mehrfach auftritt, so wird die Zeilennummer nur einmal aufgeführt. Wenn sie sine Crossreferenz-Liste wollen, so fragt das Programm anschließend nach der Zeilenabreite ihres Druckers. Mit dieser Angabe kann der Ausdruck optimal formatiert werden.

Nachdem Sie Ihre Optionen ausgewählt haben, könen Sie noch bestimmen, ob nach jeder Druckseite gewartet werden soll. Dadurch ist aucg Einzelblattverarbeitung möglich.

Alle Programne hier im Heft wurden alt der Optionskombination LMIAV ausgedruckt. Bei PLIST selbst wurde zusätslich noch die Crossreferenz-Liste ausgedruckt. Bei den Demo-Programmen wurde der Ausdruck der Include-Files weggelassen.

Programmtechnische Details

PLIST ist dae komplexeste Programm des Hefts. Wieder einmal sind es dynamische Strukturen, die die Leistungafälligkelt und Flexibilität bewirken. Das Einlesen des Programmtextes erfolgt immer abschnittweiee in einen Einlesepuffer. Ist dieser noch eine einfach, verkettete Liste, so hat die Crossreference-Liste die Struktur eines binären Suchbaums, an dessen Knoten jeweils wieder einfach verkettete Listen (=die Zeilennummern) 'hängen'. Über den Aufbau des binären Suchbaums wird beim Programm BAUMDRMO mehr gesagt. Prinzipiell eignet sich der Aufbau dieser Struktur auch zum Erstellen des Index in Büchern.

Das Zusammenspiel der dynamischen Strukturen demonstriert eindrucksvoll die hervorragende Heap-Verwaltung (= freier Speicher für dynamische Variablen)-Verwaltung in Turbo-Pascal. Der Puffer wird immer wieder gelöscht, der Suchbaum stetig aufgebaut. Die Standardprozedur 'dispose' kann also ohne Einschränkung eingesetzt werden.

Eine besonders angenehme Erweiterung, die Turbo-Pascal gegenüber anderen Versionen bietet, ist die Möglichkeit der 'initialisierten Variablen'. Im Programm kann man sie an verschiedenen Stellen finden, zum Beispiel:


  const PL : integer = 72;

Auch die Felder 'Standardbezeichner' und 'Reswords' sind so aufgebaut. Dabei wird gleich doppelt gespart: Sie sparen Zeit beim Rintippen, da Sie ohne diese Möglichkeit umständliche Initilisierungsroutinen schreiben müßten. Der Compiler spart Speicherplatz ein, indem er diese Variablen gleich im Programa-Code anlegt. Allerdings muß beim Einsaätz von solchen Variablen eine Besonderheit beachtet werden. Die Variablen werden durch den Compiler und nicht durch das Programm initialisiert. Wenn also die Werte verändert wurden, so haben die Variablen beim wiederholten Start des Programms die veränderten Inhalte! Dies gilt natürlich nicht, wenn das Programm neu geladen wurde. Wenn Sie aber kleinere Programme im Speicher compilieren und mehrmals hintereinander mit 'R' starten, kann dieses Phänomen eigenartige Reaktionen hervorrufen.

Die "beiden Felder für die reservierten Wörter and die Standardbezeichner sind alphabetisch geordnet. Das ermöglicht eine schnelle binäre Suche innerhalb dieser Felder. Da diese Methode auf alle geordneten. Strukturen angewandt werden kann, sollten sich Anfänger schnell damit vertraut machen.

Da Pascal eine formatfreie Sprache ist, die einzelnen Prozeduren den Programmtext aber zeilenweise abarbeiten, mußten alle Flags global definiert werden. Zudem wird ganz gezielt mit sog. Seiteneffekten gearbeitet. So berechnet zum Beispiel die Funktion 'reserviert' nebenbei die Verschatelungstiefe. Oder die Funktion 'Sonderzeile' setzt das INCLUDE-Flag. Normalerweise sind solche Beeinflussungen von globalen Variablen durch Punktionen unbedingt zu vermeiden. Eine Ausnahme, wie in diesem Fall, kann höchstens durch erhöhte Effizienz gerechtfertigt werden.

Anregungen

Es gibt kein Programm, das sich nicht verbessern läßt. So kann auch PLIST bei Bedarf noch erweitert und ergänzt werden. Allerdings ist die vorliegende Version bereits sehr ausgetüftelt und dürfte in den allermeisten Fällen gute Ergebnisse liefern. Die hohe Yersionsnmmer ist keine Spielerei: Das Programm wurde immer wieder den eigenen Bedürfnissen entsprechend überarbeitet.

Aus PLIST kann auch BLIST oder CLIST gemacht werden, also ein BASIC- oder C-Ausdruckprogramm. Alle wichtigen Prozeduren sind bereits vorhanden. Sogar ein A(ssembler)-Lister wäre eine sinnvolle Aufgabe.

So hilft Ihnen PLIST

Geben Sie den Programm-Namen ein oder ? oder RETURN für Ende: ?

Um den Ausdruck des Programms zu formatieren, koennen Sie folgende Punktkomnandos benuetzen: (Syntax : {.Kommando})

Kommando	Wirkung		Voreinstellung

PL nn	Seitenlaenge		72
MT nn	Rand oben		3
MB nn	Rand unten		3
PO nn	Rand links		0
CP nn	Neue Seite bei	weniger als n Zeilen	0
PA	Neue Seite
HE	Kopfzeile	Listing of	... PAGE #
FO	Fusszeile		(keine)
L+/L-	Listing ein/aus
A+/A-	Autoblock ein/aus

Alle Kommandos ausser HE und FO koennen auch in eine Zeile geschrieben werden. Beispiel {.PL 64, MT 8, PO 5}
In HE und FO kann # fuer die Seitennumner angegeben werden.

Listing von PLIST.PAS

{****************************************************************************}
{*               PLIST VERSION 3.6 / 1985.3 von Ulrich Kern                 *}
{****************************************************************************}

PROGRAM PLIST; {verbesserte Version von TLIST}
{$V-}   {Kein range-checking vei string-Uebergabe}

   CONST PL : integer = 72;
         MT : integer =  3;
         MB : integer =  3;
         PO : integer =  0;
         CP : integer =  0;
         HE : STRING[128] = '';
         FO : STRING[128] = '';

   TYPE  line            = STRING[128];
         linelength      = 0..128;
         filetype        = (main,include);
         PufferZeiger    = ^Puffer;
         Puffer          = RECORD
                              Eintrag    : line;
                              Naechster  : PufferZeiger
                           END;
         Bez             = STRING[20];

         ZeilenListe     = ^ZeilenEintrag;
         ZeilenEintrag   = RECORD
                              Nummer    : integer;
                              ZNext     : ZeilenListe
                           END;

             IdentList  = ^Bezeichner;
             Bezeichner = RECORD
                             IName : Bez;
                             l,r   : IdentList;
                             ZList : ZeilenListe
                          END;


 VAR     wort,
         zeile           : line;
         MainFile,
         InclFile        : text;
         Options         : SET OF (Cross,LNummer,RMark,FIncl,AutoBlock,Versch);
         MainFileName,
         InclFileName    : STRING[14];
         SeitenZahl,
         SpaltenZahl,
         ZeilenZahl,
         ZeilenNummer,
         PufferGroesse,
         Iter           : integer;
         WarteFlag,
         KommentarFlag,
         StringFlag,
         IncludeFlag,
         AutoBlockFlag,
         ListFlag,
         PufferVoll,
         CaseFlag       : boolean;
         Anfang, p, q   : PufferZeiger;
         CrossList      : IdentList;

(*$I PLIST-1.INC *)
(*$I PLIST-2.INC *)
(*$I PLIST-3.INC *)
(*$I PLIST-4.INC *)
(*$I PLIST-5.INC *)
{****************************************************************************}
{*                             Hauptprogramm                                *}
{****************************************************************************}

BEGIN {Hauptprogramm}

  IncludeFlag:=false;                    ListFlag:=true;
  SeitenZahl:=1;                         StringFlag:=false;
  KommentarFlag:=false;                  PufferVoll:=false;
  CaseFlag:=true;                        Iter:=0;
  ClrScr; writeln('PLIST Vers. 3.6'); writeln;

  REPEAT
    write('Geben Sie den Programm-Namen ein oder ? oder RETURN fuer Ende: ');
    LiesFileName;

    IF MainFileName='?' THEN BEGIN
      ClrScr;
      writeln('Um den Ausdruck des Programms zu formatieren, koennen Sie');
      writeln('folgende Punktkommandos benuetzen: (Syntax : {.Kommando})');
      writeln;
      writeln('Kommando  Wirkung                       Voreinstellung');
      writeln;
      writeln('PL nn     Seitenlaenge                        ',PL);
      writeln('MT nn     Rand oben                           ',MT);
      writeln('MB nn     Rand unten                          ',MB);
      writeln('PO nn     Rand links                          ',PO);
      writeln('CP nn     Neue Seite bei weniger als n Zeilen ',CP);
      writeln('PA        Neue Seite');
      writeln('HE        Kopfzeile          Lising von ...   Seite #');
      writeln('FO        Fusszeile                          (keine)');
      writeln('L+/L-     Listing   ein/aus');
      writeln('A+/A-     Autoblock ein/aus');
      writeln;
      writeln('Alle Kommandos ausser HE und FO koennen auch in eine Zeile');
      writeln('geschrieben werden. Beispiel {.PL 64, MT 8, PO 5}');
      writeln('In HE und FO kann # fuer die Seitennummer angegeben werden.');
      writeln
     END

     ELSE IF (MainFileName<>'') AND FileExists(main) THEN BEGIN
      LiesOptions; CrossList:=NIL; SeitenZahl:=1;
      writeln('Listing of ',MainFileName,'.');
      HE:='Listing of '+MainFileName
          +'                                               PAGE #';
      ZeilenZahl:=0;
      ZeilenNummer:=1;
      WHILE NOT(EOF(MainFile)) OR PufferVoll DO BEGIN
         IF NOT PufferVoll THEN BEGIN LiesPuffer; p:=Anfang END;
         zeile:=p^.Eintrag; p:=p^.Naechster;
         IF p^.Naechster=NIL THEN ClearPuffer;
         IF AutoBlockFlag AND (PufferGroesse>PL-ZeilenZahl-MB-3)
            AND (PufferGroesse<=PL-MT-MB-3) THEN NeueSeite;
         PufferGroesse:=0;
         IF NOT SonderZeile(zeile) THEN BEGIN
          IF ZeilenZahl mod PL = 0 THEN SeitenKopf;
          IF PL - ZeilenZahl   = MB + 3 THEN NeueSeite;
          IF ListFlag THEN BEGIN drucke(zeile); ZeilenZahl:=ZeilenZahl+1 END;
          ZeilenNummer:=ZeilenNummer+1;
         END {if not SonderZeile}
      END; {while} IF cross IN Options THEN SchreibCrossListe;
      close(MainFile);
     END

    ELSE IF MainFileName<>'' THEN writeln('File existiert nicht.')

  UNTIL MainFileName='';
END.

Listing von PLIST-1.INC

{****************************************************************************}
{*             Erzeugung und Ausdruck der Crossreferenz-Liste               *}
{****************************************************************************}

PROCEDURE NeueSeite; FORWARD;
   {Sorgt fuer einen Seitenumbruch. Wird erst spaeter definiert}

FUNCTION gross ( x : line) : line;
     VAR i : linelength;
     BEGIN FOR i:=1 TO length(x) DO x[i]:=upcase(x[i]); gross := x; END;

FUNCTION Standard(VAR n : Bez) : boolean;
  CONST Standardbezeichner : ARRAY[1..87] of Bez =
   ('ABS','ADDR','ARCTAN','ASSIGN',
    'BDOS','BDOSHL','BIOS','BIOSHL','BLOCKREAD','BLOCKWRITE','BOOLEAN','BYTE',
    'CHAIN','CHR','CLOSE','CLREOL','CLRSCR','CONCAT',
    'COPY','COS','CRTEXIT','CRTINIT',
    'DELETE','DELAY','DELLINE','DISPOSE','EOF','EOLN','ERASE','EXECUTE',
    'EXP','FALSE','FILEPOS','FILESIZE','FILLCHAR','FRAC','FREEMEM',
    'GETMEM','GOTOXY','HALT','HI','HIGHVIDEO','INSERT',
    'INSLINE','INT','INTEGER','IORESULT',
    'KEYPRESSED','LENGTH','LN','LO','LOWVIDEO','MARK','MAXAVAIL','MEMAVAIL',
    'MOVE','NEW','NORMVIDEO','ODD','ORD','POS','PRED','PTR',
    'RANDOM','RANDOMIZE','READ','READLN','REAL',
    'RELEASE','RENAME','RESET','REWRITE','ROUND',
    'SEEK','SIN','SIZEOF','SQR','SQRT','STR','SUCC','SWAP','TRUE','TRUNC',
    'UPCASE','VAL','WRITE','WRITELN');
  VAR b : Bez; i,j,m : integer;
    BEGIN b:=gross(n); i:=1; j:=87;
          REPEAT m:=(i+j) DIV 2;
            IF b<=Standardbezeichner[m] THEN j:=m ELSE i:=m+1
          UNTIL i=j;
          Standard:=(Standardbezeichner[i]=b)
    END;

{Die folgenden Prozeduren sind fuer die Crossreferenzliste zustaendig.
 Dabei werden Standardprozeduren und -funktionen nicht! beruecksichtigt.}

 PROCEDURE Einfuegen(w : Bez; ln:integer); LABEL EXIT;
   VAR gefunden : boolean; p,q : IdentList; cl,cnl : ZeilenListe;

   PROCEDURE MachZweig(VAR b : IdentList; w : Bez);
     BEGIN
       new(b); gefunden:=true;
       WITH b^ DO
         BEGIN
          l:=NIL; r:=NIL; IName:=w;
          new(ZList); ZList^.Nummer:=ln; ZList^.ZNext:=NIL
         END
     END;

   BEGIN
     IF Standard(w) THEN GOTO EXIT;
     gefunden:=false; q:=CrossList;
     IF CrossList=NIL
       THEN MachZweig(CrossList,w)
       ELSE
         REPEAT
           IF gross(w)<gross(q^.IName) THEN
              IF q^.l=NIL THEN BEGIN MachZweig(p,w); q^.l:=p END
                          ELSE q:=q^.l
            ELSE
            IF gross(w)>gross(q^.IName) THEN
               IF q^.r=NIL THEN BEGIN MachZweig(p,w); q^.r:=p END
                           ELSE q:=q^.r
            ELSE WITH q^ DO BEGIN
              gefunden:=true; cl:=ZList;
              WHILE cl^.ZNext<>NIL DO cl:=cl^.ZNext;
              IF cl^.Nummer<>ln THEN
               BEGIN
                 new(cnl); cnl^.Nummer:=ln; cnl^.ZNext:=NIL; cl^.ZNext:=cnl
               END
            END
          UNTIL gefunden;
      EXIT:
   END;

 PROCEDURE SchreibListe(l : IdentList; AZ : integer);
  VAR h : ZeilenListe; z : integer;
  BEGIN
    mt:=3; IF PL-ZeilenZahl-MB<8 THEN NeueSeite;
    IF PL-ZeilenZahl-MB<5 THEN NeueSeite;
    write(LST,'':PO,l^.IName,':':20-length(l^.IName));
    h:=l^.ZList; z:=0;
    WHILE h<>NIL DO
      BEGIN
        IF z=AZ THEN BEGIN writeln(LST); ZeilenZahl:=succ(ZeilenZahl);
                          write(LST,'':20+PO); z:=0 END;
        write(LST,h^.Nummer:6); h:=h^.ZNext; z:=succ(z);
      END; writeln(LST); ZeilenZahl:=succ(ZeilenZahl)
  END;

 {$A-}
 PROCEDURE SchreibBaum(b : IdentList; AZ : integer);
   VAR x1,xr : integer;
   BEGIN
     IF b<>NIL
       THEN BEGIN
              IF b^.l<>NIL THEN SchreibBaum(b^.l,AZ);
              SchreibListe(b,az);
              IF b^.r<>NIL THEN SchreibBaum(b^.r,AZ)
            END
   END;
 {$A+*}

 PROCEDURE SchreibCrossListe;
   BEGIN
     MT:=3; IF PL-ZeilenZahl-MT<8 THEN NeueSeite;
     writeln(LST); writeln(LST,'Crossreferenz-Liste:'); writeln(LST);
     ZeilenZahl:=ZeilenZahl+3;
     SchreibBaum(CrossList,(SpaltenZahl-21-PO) DIV 6)
   END;

Listing von PLIST-2.INC

{****************************************************************************}
{*                    Eingabe von Programmnamen und Optionen                *}
{****************************************************************************}

    PROCEDURE LiesFileName;
      VAR  n : STRING[14];
      BEGIN
        readln(n);
        MainFileName:=gross(n);
        writeln
    END;

    PROCEDURE LiesOptions;
      VAR i : 1..6;
          o : STRING[6];
      BEGIN
        writeln('L - Zeilennummern werden mitgedruckt');
        writeln('M - Reservierte Woerter werden markiert');
        writeln('I - Include-Files werden ausgedruckt');
        writeln('A - Absaetze werden zusammengehalten');
        writeln('V - druckt Verschachtelungstiefe');
        writeln('C - generiert Crossreferenzliste');
        writeln;
        write('L, M, I, A, V, C, LM, LI, MI, LMI, ... LMIAVC : ');
        readln(o);
        Options:=[];
        FOR i:=1 TO length(o) DO
           CASE o[i] of
             'L','l': Options:=Options+[LNummer];
             'M','m': Options:=Options+[RMark];
             'I','i': Options:=Options+[FIncl];
             'A','a': Options:=Options+[AutoBlock];
             'V','v': Options:=Options+[Versch];
             'C','c': Options:=Options+[Cross];
           END;
        AutoBlockFlag:=AutoBlock IN Options;
        IF Cross IN Options THEN
          REPEAT
           {$I-} write('Spaltenzahl : '); readln(SpaltenZahl) {$I+}
          UNTIL IOresult=0;
        write('Warten nach jeder Seite (J/N) ? '); readln(o);
        WarteFlag:=(o='J') or (o='j')
      END;

    FUNCTION FileExists( x : filetype ) : boolean;
      {Falls das File existiert, wird es zugleich eroeffnet.}
      BEGIN
        CASE x OF
          main   : BEGIN assign(MainFile,MainFileName);
                         {$I-}; reset(MainFile); {$I+};
                   END;
          include: BEGIN assign(InclFile,InclFileName);
                         {$I-}; reset(InclFile); {$I+};
                   END;
        END;
        FileExists:=(IOresult=0)
      END;

    PROCEDURE SchliessIncludeFile;
      BEGIN
        close(InclFile);
        IncludeFlag:=false
      END;

Listing von PLIST-3.INC

{****************************************************************************}
{*                         Drucker-Ausgabe                                  *}
{****************************************************************************}

   PROCEDURE drucke ( VAR x : line );
     VAR i : linelength;
         a : line;

    FUNCTION reserviert ( VAR x : line ) : boolean;
     CONST ResWords : ARRAY[1..45] of STRING[10] =
                   ('ABSOLUTE','AND','ARRAY','BEGIN','CASE','CONST',
                    'DIV','DO','DOWNTO','ELSE','END','END.','EXTERNAL','FILE',
                    'FOR','FORWARD','FUNCTION','GOTO','IF','IN','INLINE',
                    'LABEL','MOD','NIL','NOT','OF','OR','OVERLAY','PACKED',
                    'PROCEDURE','PROGRAM','RECORD','REPEAT','SET','SHL',
                    'SHR','STRING','THEN','TO','TYPE','UNTIL','VAR',
                    'WHILE','WITH','XOR');
     VAR i,j,m : 1..50; h : boolean; w : line;
     BEGIN
       h:=false; i:=1; j:=45; w:=gross(x);
       IF NOT(KommentarFlag) AND NOT(StringFlag) THEN BEGIN
         REPEAT m:=(i+j) DIV 2; IF w<=ResWords[m] THEN j:=m ELSE i:=m+1
         UNTIL i=j; h:=(ResWords[i]=w) END;
       reserviert:=h;
       IF h
        THEN IF (w='BEGIN') or (w='REPEAT')
               THEN Iter:=Iter+1
               ELSE IF (w='RECORD') THEN
                    BEGIN CaseFlag:=false; Iter:=Iter+1 END
               ELSE IF (w='CASE') AND CaseFlag THEN Iter:=Iter+1
               ELSE IF (w='END') OR (w='UNTIL') OR (w='END.') THEN
                    BEGIN CaseFlag:=true; Iter:=Iter-1 END

     END;

    PROCEDURE markiere (VAR x : line );
     {Hier koennen die gewuenschten Sequenzen zum Markieren der
      reservierten Woerter eingesetzt werden. Hier ein Beispiel
      fuer Typenrad-Drucker: Gross und vierfach.}
     VAR i,j : Byte;
     BEGIN
       IF RMark IN Options
        THEN BEGIN
          FOR i:=1 TO 3 DO
            BEGIN
              write(LST,gross(x)); FOR j:=1 TO length(x) DO write(LST,#8)
            END;
            write(LST,gross(x))
          END
        ELSE write(LST,x)
     END;

    BEGIN {drucke}
       write(LST,'':PO);
       IF LNummer IN Options THEN write(LST,ZeilenNummer:5,': ');
       IF Versch  IN Options THEN write(LST,Iter:2,'  ');
        a:=''; i:=1;
        WHILE i<=length(x) DO
           BEGIN
             IF x[i] IN ['^','A'..'Z','a'..'z'] THEN
                 BEGIN a:=x[i]; i:=succ(i);
                   WHILE (x[i] IN ['.','^','0'..'9','A'..'Z','a'..'z','_'])
                         AND (i<=length(x)) DO
                           BEGIN a:=a+x[i]; i:=succ(i) END
                   END
                ELSE BEGIN
                       IF a<>'' THEN
                         IF reserviert(a) THEN markiere(a)
                                          ELSE BEGIN write(LST,a);
                                          IF Cross IN Options THEN
                                           IF NOT KommentarFlag THEN
                                             IF NOT StringFlag
                                               THEN Einfuegen(a,ZeilenNummer)
                                           END;
                       a:='';
                       write(LST,x[i]);
                       IF NOT(StringFlag) AND ((x[i]='{') OR ((x[i]='(')
                          AND (x[i+1]='*'))) THEN KommentarFlag:=true;
                       IF NOT(StringFlag) AND((x[i]='}') OR ((x[i]='*')
                          AND (x[i+1]=')'))) THEN KommentarFlag:=false;
                       IF NOT(KommentarFlag) AND(x[i]=chr(39))
                          THEN StringFlag:=NOT(StringFlag); i:=succ(i)
                END
           END;
           IF a<>'' THEN IF reserviert(a)
              THEN markiere(a) ELSE
              BEGIN write(LST,a);
                IF NOT(KommentarFlag OR StringFlag) AND (Cross IN Options)
                 THEN Einfuegen(a,ZeilenNummer) END;
           writeln(LST); StringFlag:=false
    END;

   PROCEDURE SeitenKopf;
     VAR i : linelength;
     BEGIN
      IF ListFlag THEN BEGIN
       writeln(LST); write(LST,'':PO);
       FOR i:=1 TO length(HE) DO IF HE[i]='#' THEN write(LST,SeitenZahl)
                                              ELSE write(LST,HE[i]);
       writeln(LST);
       FOR i:=1 TO MT DO writeln(LST);
       ZeilenZahl:=MT+3
      END
     END;

   PROCEDURE NeueSeite;
     VAR i : linelength;
     BEGIN
      PufferGroesse:=0;
      IF ListFlag THEN BEGIN write(LST,'':PO);
       FOR i:=ZeilenZahl TO PL-3 DO writeln(LST);
       FOR i:=1 TO length(FO) DO IF FO[i]='#' THEN write(LST,SeitenZahl)
                                              ELSE write(LST,FO[i]);
       FOR i:=1 TO 3 DO writeln(LST);
       SeitenZahl:=SeitenZahl+1;
       IF WarteFlag THEN BEGIN write('Weiter mit RETURN'); readln END;
       SeitenKopf
      END {if ListFlag}
     END;

Listing von PLIST-4.INC

{****************************************************************************}
{*            Bearbeitung von Punkt- und Compiler-Anweisungen               *}
{****************************************************************************}

   FUNCTION Sonder( VAR x : line ) : boolean;
      BEGIN
        Sonder:=(pos(chr(39),x)=0) AND ((pos('{.',x)>0) OR (pos('(*.',x)>0) OR
           ((FIncl IN Options) AND ((pos('{$I',x)>0) OR (pos('(*$I',x)>0))
            AND (pos('{$I+',x)=0) AND (pos('{$I-',x)=0)
            AND (pos('(*$I+',x)=0) AND (pos('(*$I-',x)=0)))
  END;

  FUNCTION SonderZeile ( VAR x : line ) : boolean;
    {In Sonderzeilen duerfen keine einfachen Anfuehrungszeichen sein!}
    VAR h   : boolean;
        w   : STRING[2];
        z   : STRING[3];
        Fehler,
        i,j,m  : integer;
    BEGIN
      h:=Sonder(x);
      IF h THEN BEGIN
        i:=pos('{.',x) OR pos('(*.',x);
        IF i>0 THEN IF pos('(*.',x)=i THEN m:=1 ELSE m:=0;
        IF i>0 THEN
          REPEAT w:=''; Fehler:=0;
            IF x[i] IN ['A'..'Z','a'..'z'] THEN BEGIN
              w:=x[i]+x[i+1]; i:=i+2;
              IF (w='PL') OR (w='MT') OR (w='MB') OR (w='PO') OR (w='CP')
               THEN BEGIN
                 z:='';
                 WHILE NOT(x[i] IN ['0'..'9']) DO i:=i+1;
                 WHILE x[i] IN ['0'..'9'] DO BEGIN z:=z+x[i]; i:=i+1 END;
                 IF w='PL' THEN val(z,PL,Fehler);
                 IF w='MT' THEN val(z,MT,Fehler);
                 IF w='MB' THEN val(z,MB,Fehler);
                 IF w='PO' THEN val(z,PO,Fehler);
                 IF w='CP' THEN val(z,CP,Fehler);
              END; h:=Fehler=0;
              IF w='HE' THEN BEGIN HE:=copy(x,i,length(x)-i-m); i:=127 END;
              IF w='FO' THEN BEGIN FO:=copy(x,i,length(x)-i-m); i:=127 END;
              IF w='PA' THEN NeueSeite;
              IF w='CP' THEN IF PL-MT-MB-ZeilenZahl<CP THEN NeueSeite;
              IF w='L+' THEN ListFlag:=true;
              IF w='L-' THEN ListFlag:=false;
              IF w='A+' THEN AutoBlockFlag:=true;
              IF w='A-' THEN AutoBlockFlag:=false
            END;
            i:=i+1;
          UNTIL i>length(x)
         ELSE BEGIN
           i:=pos('{$I',x)+2; IF i=2 THEN i:=pos('(*$I',x)+3;
          InclFileName:='';
          WHILE (i<length(x)) AND (length(InclFileName)<12) DO BEGIN
             i:=i+1;
             IF x[i] in['-','.',':','0'..'9','a'..'z','A'..'Z']
               THEN InclFileName:=InclFileName+gross(x[i])
          END;
          IF MainFileName[2]=':' THEN
            IF InclFileName[2]=':' THEN InclFileName[1]:=MainFileName[1]
                      ELSE InclFileName:=MainFileName[1]+':'+InclFileName;
          IncludeFlag:=FileExists(Include); h:=IncludeFlag;
          IF IncludeFlag THEN writeln('Including ',InclFileName)
                         ELSE writeln('File ',InclFileName,' nicht gefunden,');
        END;
     END;
     SonderZeile:=h
   END;

Listing von PLIST-5.INC

{****************************************************************************}
{*                    Puffer-Operationen mit FIFO                           *}
{****************************************************************************}

   FUNCTION leer(VAR x : line) : boolean;
     VAR h : boolean;
         i : integer;
     BEGIN
       h:=true;
       i:=1;
       WHILE h AND (i<=length(x)) DO BEGIN h:=ord(x[i])=32; i:=i+1 END;
       leer:=h
     END;

 FUNCTION EndOfBlock : boolean;
   VAR h : boolean;
   BEGIN
     h:=EOF(MainFile);
     IF IncludeFlag THEN IF EOF(InclFile) THEN BEGIN h:=true;
                                                     IncludeFlag:=false;
                                                     SchliessIncludeFile
                                               END;
     IF NOT(h) THEN h:=leer(zeile);
     IF NOT(h) THEN h:=Sonder(zeile);
     IF PufferGroesse>PL-MT-MB-3 THEN h:=true;
     EndOfBlock:=h
   END;

   PROCEDURE ClearPuffer;
     BEGIN
       p:=Anfang;
       WHILE p^.Naechster<>NIL DO BEGIN
          q:=p; dispose(p); p:=q^.Naechster;
       END; dispose(p);
       PufferVoll:=false
     END;

 PROCEDURE LiesPuffer;
   BEGIN PufferGroesse:=0;
     new(q); Anfang:=q; q^.Naechster:=NIL;
     REPEAT
       IF IncludeFlag THEN readln(InclFile,zeile)
                      ELSE readln(MainFile,zeile);
       q^.Eintrag:=zeile;
       PufferGroesse:=PufferGroesse+1;
       new(p);
       q^.Naechster:=p;
       p^.Naechster:=NIL;
       q:=p;
     UNTIL EndOfBlock;
     PufferVoll:=true
   END;

Das Listing

Listing of PLIST.PAS                                               PAGE 1


    1:  0  {****************************************************************************}
    2:  0  {*               PLIST VERSION 3.6 / 1985.3 von Ulrich Kern                 *}
    3:  0  {****************************************************************************}
    4:  0  
    5:  0  PROGRAM PLIST; {verbesserte Version von TLIST}
    6:  0  {$V-}   {Kein range-checking vei string-Uebergabe}
    7:  0  
    8:  0     CONST PL : integer = 72;
    9:  0           MT : integer =  3;
   10:  0           MB : integer =  3;
   11:  0           PO : integer =  0;
   12:  0           CP : integer =  0;
   13:  0           HE : STRING[128] = '';
   14:  0           FO : STRING[128] = '';
   15:  0  
   16:  0     TYPE  line            = STRING[128];
   17:  0           linelength      = 0..128;
   18:  0           filetype        = (main,include);
   19:  0           PufferZeiger    = ^Puffer;
   20:  0           Puffer          = RECORD
   21:  1                                Eintrag    : line;
   22:  1                                Naechster  : PufferZeiger
   23:  1                             END;
   24:  0           Bez             = STRING[20];
   25:  0  
   26:  0           ZeilenListe     = ^ZeilenEintrag;
   27:  0           ZeilenEintrag   = RECORD
   28:  1                                Nummer    : integer;
   29:  1                                ZNext     : ZeilenListe
   30:  1                             END;
   31:  0  
   32:  0               IdentList  = ^Bezeichner;
   33:  0               Bezeichner = RECORD
   34:  1                               IName : Bez;
   35:  1                               l,r   : IdentList;
   36:  1                               ZList : ZeilenListe
   37:  1                            END;
   38:  0  
   39:  0  
   40:  0   VAR     wort,
   41:  0           zeile           : line;
   42:  0           MainFile,
   43:  0           InclFile        : text;
   44:  0           Options         : SET OF (Cross,LNummer,RMark,FIncl,AutoBlock,Versch);
   45:  0           MainFileName,
   46:  0           InclFileName    : STRING[14];
   47:  0           SeitenZahl,
   48:  0           SpaltenZahl,
   49:  0           ZeilenZahl,
   50:  0           ZeilenNummer,
   51:  0           PufferGroesse,
   52:  0           Iter           : integer;
   53:  0           WarteFlag,
   54:  0           KommentarFlag,
   55:  0           StringFlag,
   56:  0           IncludeFlag,
   57:  0           AutoBlockFlag,
   58:  0           ListFlag,
   59:  0           PufferVoll,
   60:  0           CaseFlag       : boolean;
   61:  0           Anfang, p, q   : PufferZeiger;
   62:  0           CrossList      : IdentList;
   63:  0  
   64:  0  {****************************************************************************}
   65:  0  {*             Erzeugung und Ausdruck der Crossreferenz-Liste               *}
   66:  0  {****************************************************************************}
   67:  0  
   68:  0  PROCEDURE NeueSeite; FORWARD;
   69:  0     {Sorgt fuer einen Seitenumbruch. Wird erst spaeter definiert}
   70:  0  
   71:  0  FUNCTION gross ( x : line) : line;
   72:  0       VAR i : linelength;
   73:  0       BEGIN FOR i:=1 TO length(x) DO x[i]:=upcase(x[i]); gross := x; END;
   74:  0  


Listing of PLIST.PAS                                               PAGE 2


   75:  0  FUNCTION Standard(VAR n : Bez) : boolean;
   76:  0    CONST Standardbezeichner : ARRAY[1..87] of Bez =
   77:  0     ('ABS','ADDR','ARCTAN','ASSIGN',
   78:  0      'BDOS','BDOSHL','BIOS','BIOSHL','BLOCKREAD','BLOCKWRITE','BOOLEAN','BYTE',
   79:  0      'CHAIN','CHR','CLOSE','CLREOL','CLRSCR','CONCAT',
   80:  0      'COPY','COS','CRTEXIT','CRTINIT',
   81:  0      'DELETE','DELAY','DELLINE','DISPOSE','EOF','EOLN','ERASE','EXECUTE',
   82:  0      'EXP','FALSE','FILEPOS','FILESIZE','FILLCHAR','FRAC','FREEMEM',
   83:  0      'GETMEM','GOTOXY','HALT','HI','HIGHVIDEO','INSERT',
   84:  0      'INSLINE','INT','INTEGER','IORESULT',
   85:  0      'KEYPRESSED','LENGTH','LN','LO','LOWVIDEO','MARK','MAXAVAIL','MEMAVAIL',
   86:  0      'MOVE','NEW','NORMVIDEO','ODD','ORD','POS','PRED','PTR',
   87:  0      'RANDOM','RANDOMIZE','READ','READLN','REAL',
   88:  0      'RELEASE','RENAME','RESET','REWRITE','ROUND',
   89:  0      'SEEK','SIN','SIZEOF','SQR','SQRT','STR','SUCC','SWAP','TRUE','TRUNC',
   90:  0      'UPCASE','VAL','WRITE','WRITELN');
   91:  0    VAR b : Bez; i,j,m : integer;
   92:  0      BEGIN b:=gross(n); i:=1; j:=87;
   93:  1            REPEAT m:=(i+j) DIV 2;
   94:  2              IF b<=Standardbezeichner[m] THEN j:=m ELSE i:=m+1
   95:  2            UNTIL i=j;
   96:  1            Standard:=(Standardbezeichner[i]=b)
   97:  1      END;
   98:  0  
   99:  0  {Die folgenden Prozeduren sind fuer die Crossreferenzliste zustaendig.
  100:  0   Dabei werden Standardprozeduren und -funktionen nicht! beruecksichtigt.}
  101:  0  
  102:  0   PROCEDURE Einfuegen(w : Bez; ln:integer); LABEL EXIT;
  103:  0     VAR gefunden : boolean; p,q : IdentList; cl,cnl : ZeilenListe;
  104:  0  
  105:  0     PROCEDURE MachZweig(VAR b : IdentList; w : Bez);
  106:  0       BEGIN
  107:  1         new(b); gefunden:=true;
  108:  1         WITH b^ DO
  109:  1           BEGIN
  110:  2            l:=NIL; r:=NIL; IName:=w;
  111:  2            new(ZList); ZList^.Nummer:=ln; ZList^.ZNext:=NIL
  112:  2           END
  113:  1       END;
  114:  0  
  115:  0     BEGIN
  116:  1       IF Standard(w) THEN GOTO EXIT;
  117:  1       gefunden:=false; q:=CrossList;
  118:  1       IF CrossList=NIL
  119:  1         THEN MachZweig(CrossList,w)
  120:  1         ELSE
  121:  1           REPEAT
  122:  2             IF gross(w)<gross(q^.IName) THEN
  123:  2                IF q^.l=NIL THEN BEGIN MachZweig(p,w); q^.l:=p END
  124:  2                            ELSE q:=q^.l
  125:  2              ELSE
  126:  2              IF gross(w)>gross(q^.IName) THEN
  127:  2                 IF q^.r=NIL THEN BEGIN MachZweig(p,w); q^.r:=p END
  128:  2                             ELSE q:=q^.r
  129:  2              ELSE WITH q^ DO BEGIN
  130:  3                gefunden:=true; cl:=ZList;
  131:  3                WHILE cl^.ZNext<>NIL DO cl:=cl^.ZNext;
  132:  3                IF cl^.Nummer<>ln THEN
  133:  3                 BEGIN
  134:  4                   new(cnl); cnl^.Nummer:=ln; cnl^.ZNext:=NIL; cl^.ZNext:=cnl
  135:  4                 END
  136:  3              END
  137:  2            UNTIL gefunden;
  138:  1        EXIT:
  139:  1     END;
  140:  0  
  141:  0   PROCEDURE SchreibListe(l : IdentList; AZ : integer);
  142:  0    VAR h : ZeilenListe; z : integer;
  143:  0    BEGIN
  144:  1      mt:=3; IF PL-ZeilenZahl-MB<8 THEN NeueSeite;
  145:  1      IF PL-ZeilenZahl-MB<5 THEN NeueSeite;
  146:  1      write(LST,'':PO,l^.IName,':':20-length(l^.IName));
  147:  1      h:=l^.ZList; z:=0;
  148:  1      WHILE h<>NIL DO
  149:  1        BEGIN
  150:  2          IF z=AZ THEN BEGIN writeln(LST); ZeilenZahl:=succ(ZeilenZahl);
  151:  3                            write(LST,'':20+PO); z:=0 END;
  152:  2          write(LST,h^.Nummer:6); h:=h^.ZNext; z:=succ(z);
  153:  2        END; writeln(LST); ZeilenZahl:=succ(ZeilenZahl)
  154:  1    END;
  155:  0  


Listing of PLIST.PAS                                               PAGE 3


  156:  0   {$A-}
  157:  0   PROCEDURE SchreibBaum(b : IdentList; AZ : integer);
  158:  0     VAR x1,xr : integer;
  159:  0     BEGIN
  160:  1       IF b<>NIL
  161:  1         THEN BEGIN
  162:  2                IF b^.l<>NIL THEN SchreibBaum(b^.l,AZ);
  163:  2                SchreibListe(b,az);
  164:  2                IF b^.r<>NIL THEN SchreibBaum(b^.r,AZ)
  165:  2              END
  166:  1     END;
  167:  0   {$A+*}
  168:  0  
  169:  0   PROCEDURE SchreibCrossListe;
  170:  0     BEGIN
  171:  1       MT:=3; IF PL-ZeilenZahl-MT<8 THEN NeueSeite;
  172:  1       writeln(LST); writeln(LST,'Crossreferenz-Liste:'); writeln(LST);
  173:  1       ZeilenZahl:=ZeilenZahl+3;
  174:  1       SchreibBaum(CrossList,(SpaltenZahl-21-PO) DIV 6)
  175:  1     END;
  176:  0  
  177:  0  {****************************************************************************}
  178:  0  {*                    Eingabe von Programmnamen und Optionen                *}
  179:  0  {****************************************************************************}
  180:  0  
  181:  0      PROCEDURE LiesFileName;
  182:  0        VAR  n : STRING[14];
  183:  0        BEGIN
  184:  1          readln(n);
  185:  1          MainFileName:=gross(n);
  186:  1          writeln
  187:  1      END;
  188:  0  
  189:  0      PROCEDURE LiesOptions;
  190:  0        VAR i : 1..6;
  191:  0            o : STRING[6];
  192:  0        BEGIN
  193:  1          writeln('L - Zeilennummern werden mitgedruckt');
  194:  1          writeln('M - Reservierte Woerter werden markiert');
  195:  1          writeln('I - Include-Files werden ausgedruckt');
  196:  1          writeln('A - Absaetze werden zusammengehalten');
  197:  1          writeln('V - druckt Verschachtelungstiefe');
  198:  1          writeln('C - generiert Crossreferenzliste');
  199:  1          writeln;
  200:  1          write('L, M, I, A, V, C, LM, LI, MI, LMI, ... LMIAVC : ');
  201:  1          readln(o);
  202:  1          Options:=[];
  203:  1          FOR i:=1 TO length(o) DO
  204:  1             CASE o[i] of
  205:  2               'L','l': Options:=Options+[LNummer];
  206:  2               'M','m': Options:=Options+[RMark];
  207:  2               'I','i': Options:=Options+[FIncl];
  208:  2               'A','a': Options:=Options+[AutoBlock];
  209:  2               'V','v': Options:=Options+[Versch];
  210:  2               'C','c': Options:=Options+[Cross];
  211:  2             END;
  212:  1          AutoBlockFlag:=AutoBlock IN Options;
  213:  1          IF Cross IN Options THEN
  214:  1            REPEAT
  215:  2             {$I-} write('Spaltenzahl : '); readln(SpaltenZahl) {$I+}
  216:  2            UNTIL IOresult=0;
  217:  1          write('Warten nach jeder Seite (J/N) ? '); readln(o);
  218:  1          WarteFlag:=(o='J') or (o='j')
  219:  1        END;
  220:  0  
  221:  0      FUNCTION FileExists( x : filetype ) : boolean;
  222:  0        {Falls das File existiert, wird es zugleich eroeffnet.}
  223:  0        BEGIN
  224:  1          CASE x OF
  225:  2            main   : BEGIN assign(MainFile,MainFileName);
  226:  3                           {$I-}; reset(MainFile); {$I+};
  227:  3                     END;
  228:  2            include: BEGIN assign(InclFile,InclFileName);
  229:  3                           {$I-}; reset(InclFile); {$I+};
  230:  3                     END;
  231:  2          END;
  232:  1          FileExists:=(IOresult=0)
  233:  1        END;
  234:  0  
  235:  0      PROCEDURE SchliessIncludeFile;
  236:  0        BEGIN
  237:  1          close(InclFile);
  238:  1          IncludeFlag:=false
  239:  1        END;
  240:  0  


Listing of PLIST.PAS                                               PAGE 4


  241:  0  {****************************************************************************}
  242:  0  {*                         Drucker-Ausgabe                                  *}
  243:  0  {****************************************************************************}
  244:  0  
  245:  0     PROCEDURE drucke ( VAR x : line );
  246:  0       VAR i : linelength;
  247:  0           a : line;
  248:  0  
  249:  0      FUNCTION reserviert ( VAR x : line ) : boolean;
  250:  0       CONST ResWords : ARRAY[1..45] of STRING[10] =
  251:  0                     ('ABSOLUTE','AND','ARRAY','BEGIN','CASE','CONST',
  252:  0                      'DIV','DO','DOWNTO','ELSE','END','END.','EXTERNAL','FILE',
  253:  0                      'FOR','FORWARD','FUNCTION','GOTO','IF','IN','INLINE',
  254:  0                      'LABEL','MOD','NIL','NOT','OF','OR','OVERLAY','PACKED',
  255:  0                      'PROCEDURE','PROGRAM','RECORD','REPEAT','SET','SHL',
  256:  0                      'SHR','STRING','THEN','TO','TYPE','UNTIL','VAR',
  257:  0                      'WHILE','WITH','XOR');
  258:  0       VAR i,j,m : 1..50; h : boolean; w : line;
  259:  0       BEGIN
  260:  1         h:=false; i:=1; j:=45; w:=gross(x);
  261:  1         IF NOT(KommentarFlag) AND NOT(StringFlag) THEN BEGIN
  262:  2           REPEAT m:=(i+j) DIV 2; IF w<=ResWords[m] THEN j:=m ELSE i:=m+1
  263:  3           UNTIL i=j; h:=(ResWords[i]=w) END;
  264:  1         reserviert:=h;
  265:  1         IF h
  266:  1          THEN IF (w='BEGIN') or (w='REPEAT')
  267:  1                 THEN Iter:=Iter+1
  268:  1                 ELSE IF (w='RECORD') THEN
  269:  1                      BEGIN CaseFlag:=false; Iter:=Iter+1 END
  270:  1                 ELSE IF (w='CASE') AND CaseFlag THEN Iter:=Iter+1
  271:  1                 ELSE IF (w='END') OR (w='UNTIL') OR (w='END.') THEN
  272:  1                      BEGIN CaseFlag:=true; Iter:=Iter-1 END
  273:  1  
  274:  1       END;
  275:  0  
  276:  0      PROCEDURE markiere (VAR x : line );
  277:  0       {Hier koennen die gewuenschten Sequenzen zum Markieren der
  278:  0        reservierten Woerter eingesetzt werden. Hier ein Beispiel
  279:  0        fuer Typenrad-Drucker: Gross und vierfach.}
  280:  0       VAR i,j : Byte;
  281:  0       BEGIN
  282:  1         IF RMark IN Options
  283:  1          THEN BEGIN
  284:  2            FOR i:=1 TO 3 DO
  285:  2              BEGIN
  286:  3                write(LST,gross(x)); FOR j:=1 TO length(x) DO write(LST,#8)
  287:  3              END;
  288:  2              write(LST,gross(x))
  289:  2            END
  290:  1          ELSE write(LST,x)
  291:  1       END;
  292:  0  


Listing of PLIST.PAS                                               PAGE 5


  293:  0      BEGIN {drucke}
  294:  1         write(LST,'':PO);
  295:  1         IF LNummer IN Options THEN write(LST,ZeilenNummer:5,': ');
  296:  1         IF Versch  IN Options THEN write(LST,Iter:2,'  ');
  297:  1          a:=''; i:=1;
  298:  1          WHILE i<=length(x) DO
  299:  1             BEGIN
  300:  2               IF x[i] IN ['^','A'..'Z','a'..'z'] THEN
  301:  2                   BEGIN a:=x[i]; i:=succ(i);
  302:  3                     WHILE (x[i] IN ['.','^','0'..'9','A'..'Z','a'..'z','_'])
  303:  3                           AND (i<=length(x)) DO
  304:  3                             BEGIN a:=a+x[i]; i:=succ(i) END
  305:  3                     END
  306:  2                  ELSE BEGIN
  307:  3                         IF a<>'' THEN
  308:  3                           IF reserviert(a) THEN markiere(a)
  309:  3                                            ELSE BEGIN write(LST,a);
  310:  4                                            IF Cross IN Options THEN
  311:  4                                             IF NOT KommentarFlag THEN
  312:  4                                               IF NOT StringFlag
  313:  4                                                 THEN Einfuegen(a,ZeilenNummer)
  314:  4                                             END;
  315:  3                         a:='';
  316:  3                         write(LST,x[i]);
  317:  3                         IF NOT(StringFlag) AND ((x[i]='{') OR ((x[i]='(')
  318:  3                            AND (x[i+1]='*'))) THEN KommentarFlag:=true;
  319:  3                         IF NOT(StringFlag) AND((x[i]='}') OR ((x[i]='*')
  320:  3                            AND (x[i+1]=')'))) THEN KommentarFlag:=false;
  321:  3                         IF NOT(KommentarFlag) AND(x[i]=chr(39))
  322:  3                            THEN StringFlag:=NOT(StringFlag); i:=succ(i)
  323:  3                  END
  324:  2             END;
  325:  1             IF a<>'' THEN IF reserviert(a)
  326:  1                THEN markiere(a) ELSE
  327:  1                BEGIN write(LST,a);
  328:  2                  IF NOT(KommentarFlag OR StringFlag) AND (Cross IN Options)
  329:  2                   THEN Einfuegen(a,ZeilenNummer) END;
  330:  1             writeln(LST); StringFlag:=false
  331:  1      END;
  332:  0  
  333:  0     PROCEDURE SeitenKopf;
  334:  0       VAR i : linelength;
  335:  0       BEGIN
  336:  1        IF ListFlag THEN BEGIN
  337:  2         writeln(LST); write(LST,'':PO);
  338:  2         FOR i:=1 TO length(HE) DO IF HE[i]='#' THEN write(LST,SeitenZahl)
  339:  2                                                ELSE write(LST,HE[i]);
  340:  2         writeln(LST);
  341:  2         FOR i:=1 TO MT DO writeln(LST);
  342:  2         ZeilenZahl:=MT+3
  343:  2        END
  344:  1       END;
  345:  0  
  346:  0     PROCEDURE NeueSeite;
  347:  0       VAR i : linelength;
  348:  0       BEGIN
  349:  1        PufferGroesse:=0;
  350:  1        IF ListFlag THEN BEGIN write(LST,'':PO);
  351:  2         FOR i:=ZeilenZahl TO PL-3 DO writeln(LST);
  352:  2         FOR i:=1 TO length(FO) DO IF FO[i]='#' THEN write(LST,SeitenZahl)
  353:  2                                                ELSE write(LST,FO[i]);
  354:  2         FOR i:=1 TO 3 DO writeln(LST);
  355:  2         SeitenZahl:=SeitenZahl+1;
  356:  2         IF WarteFlag THEN BEGIN write('Weiter mit RETURN'); readln END;
  357:  2         SeitenKopf
  358:  2        END {if ListFlag}
  359:  1       END;
  360:  0  
  361:  0  {****************************************************************************}
  362:  0  {*            Bearbeitung von Punkt- und Compiler-Anweisungen               *}
  363:  0  {****************************************************************************}
  364:  0  
  365:  0     FUNCTION Sonder( VAR x : line ) : boolean;
  366:  0        BEGIN
  367:  1          Sonder:=(pos(chr(39),x)=0) AND ((pos('{.',x)>0) OR (pos('(*.',x)>0) OR
  368:  1             ((FIncl IN Options) AND ((pos('{$I',x)>0) OR (pos('(*$I',x)>0))
  369:  1              AND (pos('{$I+',x)=0) AND (pos('{$I-',x)=0)
  370:  1              AND (pos('(*$I+',x)=0) AND (pos('(*$I-',x)=0)))
  371:  1    END;
  372:  0  


Listing of PLIST.PAS                                               PAGE 6


  373:  0    FUNCTION SonderZeile ( VAR x : line ) : boolean;
  374:  0      {In Sonderzeilen duerfen keine einfachen Anfuehrungszeichen sein!}
  375:  0      VAR h   : boolean;
  376:  0          w   : STRING[2];
  377:  0          z   : STRING[3];
  378:  0          Fehler,
  379:  0          i,j,m  : integer;
  380:  0      BEGIN
  381:  1        h:=Sonder(x);
  382:  1        IF h THEN BEGIN
  383:  2          i:=pos('{.',x) OR pos('(*.',x);
  384:  2          IF i>0 THEN IF pos('(*.',x)=i THEN m:=1 ELSE m:=0;
  385:  2          IF i>0 THEN
  386:  2            REPEAT w:=''; Fehler:=0;
  387:  3              IF x[i] IN ['A'..'Z','a'..'z'] THEN BEGIN
  388:  4                w:=x[i]+x[i+1]; i:=i+2;
  389:  4                IF (w='PL') OR (w='MT') OR (w='MB') OR (w='PO') OR (w='CP')
  390:  4                 THEN BEGIN
  391:  5                   z:='';
  392:  5                   WHILE NOT(x[i] IN ['0'..'9']) DO i:=i+1;
  393:  5                   WHILE x[i] IN ['0'..'9'] DO BEGIN z:=z+x[i]; i:=i+1 END;
  394:  5                   IF w='PL' THEN val(z,PL,Fehler);
  395:  5                   IF w='MT' THEN val(z,MT,Fehler);
  396:  5                   IF w='MB' THEN val(z,MB,Fehler);
  397:  5                   IF w='PO' THEN val(z,PO,Fehler);
  398:  5                   IF w='CP' THEN val(z,CP,Fehler);
  399:  5                END; h:=Fehler=0;
  400:  4                IF w='HE' THEN BEGIN HE:=copy(x,i,length(x)-i-m); i:=127 END;
  401:  4                IF w='FO' THEN BEGIN FO:=copy(x,i,length(x)-i-m); i:=127 END;
  402:  4                IF w='PA' THEN NeueSeite;
  403:  4                IF w='CP' THEN IF PL-MT-MB-ZeilenZahl<CP THEN NeueSeite;
  404:  4                IF w='L+' THEN ListFlag:=true;
  405:  4                IF w='L-' THEN ListFlag:=false;
  406:  4                IF w='A+' THEN AutoBlockFlag:=true;
  407:  4                IF w='A-' THEN AutoBlockFlag:=false
  408:  4              END;
  409:  3              i:=i+1;
  410:  3            UNTIL i>length(x)
  411:  2           ELSE BEGIN
  412:  3             i:=pos('{$I',x)+2; IF i=2 THEN i:=pos('(*$I',x)+3;
  413:  3            InclFileName:='';
  414:  3            WHILE (i<length(x)) AND (length(InclFileName)<12) DO BEGIN
  415:  4               i:=i+1;
  416:  4               IF x[i] in['-','.',':','0'..'9','a'..'z','A'..'Z']
  417:  4                 THEN InclFileName:=InclFileName+gross(x[i])
  418:  4            END;
  419:  3            IF MainFileName[2]=':' THEN
  420:  3              IF InclFileName[2]=':' THEN InclFileName[1]:=MainFileName[1]
  421:  3                        ELSE InclFileName:=MainFileName[1]+':'+InclFileName;
  422:  3            IncludeFlag:=FileExists(Include); h:=IncludeFlag;
  423:  3            IF IncludeFlag THEN writeln('Including ',InclFileName)
  424:  3                           ELSE writeln('File ',InclFileName,' nicht gefunden,');
  425:  3          END;
  426:  2       END;
  427:  1       SonderZeile:=h
  428:  1     END;
  429:  0  
  430:  0  {****************************************************************************}
  431:  0  {*                    Puffer-Operationen mit FIFO                           *}
  432:  0  {****************************************************************************}
  433:  0  
  434:  0     FUNCTION leer(VAR x : line) : boolean;
  435:  0       VAR h : boolean;
  436:  0           i : integer;
  437:  0       BEGIN
  438:  1         h:=true;
  439:  1         i:=1;
  440:  1         WHILE h AND (i<=length(x)) DO BEGIN h:=ord(x[i])=32; i:=i+1 END;
  441:  1         leer:=h
  442:  1       END;
  443:  0  
  444:  0   FUNCTION EndOfBlock : boolean;
  445:  0     VAR h : boolean;
  446:  0     BEGIN
  447:  1       h:=EOF(MainFile);
  448:  1       IF IncludeFlag THEN IF EOF(InclFile) THEN BEGIN h:=true;
  449:  2                                                       IncludeFlag:=false;
  450:  2                                                       SchliessIncludeFile
  451:  2                                                 END;
  452:  1       IF NOT(h) THEN h:=leer(zeile);
  453:  1       IF NOT(h) THEN h:=Sonder(zeile);
  454:  1       IF PufferGroesse>PL-MT-MB-3 THEN h:=true;
  455:  1       EndOfBlock:=h
  456:  1     END;
  457:  0  


Listing of PLIST.PAS                                               PAGE 7


  458:  0     PROCEDURE ClearPuffer;
  459:  0       BEGIN
  460:  1         p:=Anfang;
  461:  1         WHILE p^.Naechster<>NIL DO BEGIN
  462:  2            q:=p; dispose(p); p:=q^.Naechster;
  463:  2         END; dispose(p);
  464:  1         PufferVoll:=false
  465:  1       END;
  466:  0  
  467:  0   PROCEDURE LiesPuffer;
  468:  0     BEGIN PufferGroesse:=0;
  469:  1       new(q); Anfang:=q; q^.Naechster:=NIL;
  470:  1       REPEAT
  471:  2         IF IncludeFlag THEN readln(InclFile,zeile)
  472:  2                        ELSE readln(MainFile,zeile);
  473:  2         q^.Eintrag:=zeile;
  474:  2         PufferGroesse:=PufferGroesse+1;
  475:  2         new(p);
  476:  2         q^.Naechster:=p;
  477:  2         p^.Naechster:=NIL;
  478:  2         q:=p;
  479:  2       UNTIL EndOfBlock;
  480:  1       PufferVoll:=true
  481:  1     END;
  482:  0  


Listing of PLIST.PAS                                               PAGE 8


  483:  0  {****************************************************************************}
  484:  0  {*                             Hauptprogramm                                *}
  485:  0  {****************************************************************************}
  486:  0  
  487:  0  BEGIN {Hauptprogramm}
  488:  1  
  489:  1    IncludeFlag:=false;                    ListFlag:=true;
  490:  1    SeitenZahl:=1;                         StringFlag:=false;
  491:  1    KommentarFlag:=false;                  PufferVoll:=false;
  492:  1    CaseFlag:=true;                        Iter:=0;
  493:  1    ClrScr; writeln('PLIST Vers. 3.6'); writeln;
  494:  1  
  495:  1    REPEAT
  496:  2      write('Geben Sie den Programm-Namen ein oder ? oder RETURN fuer Ende: ');
  497:  2      LiesFileName;
  498:  2  
  499:  2      IF MainFileName='?' THEN BEGIN
  500:  3        ClrScr;
  501:  3        writeln('Um den Ausdruck des Programms zu formatieren, koennen Sie');
  502:  3        writeln('folgende Punktkommandos benuetzen: (Syntax : {.Kommando})');
  503:  3        writeln;
  504:  3        writeln('Kommando  Wirkung                       Voreinstellung');
  505:  3        writeln;
  506:  3        writeln('PL nn     Seitenlaenge                        ',PL);
  507:  3        writeln('MT nn     Rand oben                           ',MT);
  508:  3        writeln('MB nn     Rand unten                          ',MB);
  509:  3        writeln('PO nn     Rand links                          ',PO);
  510:  3        writeln('CP nn     Neue Seite bei weniger als n Zeilen ',CP);
  511:  3        writeln('PA        Neue Seite');
  512:  3        writeln('HE        Kopfzeile          Lising von ...   Seite #');
  513:  3        writeln('FO        Fusszeile                          (keine)');
  514:  3        writeln('L+/L-     Listing   ein/aus');
  515:  3        writeln('A+/A-     Autoblock ein/aus');
  516:  3        writeln;
  517:  3        writeln('Alle Kommandos ausser HE und FO koennen auch in eine Zeile');
  518:  3        writeln('geschrieben werden. Beispiel {.PL 64, MT 8, PO 5}');
  519:  3        writeln('In HE und FO kann # fuer die Seitennummer angegeben werden.');
  520:  3        writeln
  521:  3       END
  522:  2  
  523:  2       ELSE IF (MainFileName<>'') AND FileExists(main) THEN BEGIN
  524:  3        LiesOptions; CrossList:=NIL; SeitenZahl:=1;
  525:  3        writeln('Listing of ',MainFileName,'.');
  526:  3        HE:='Listing of '+MainFileName
  527:  3            +'                                               PAGE #';
  528:  3        ZeilenZahl:=0;
  529:  3        ZeilenNummer:=1;
  530:  3        WHILE NOT(EOF(MainFile)) OR PufferVoll DO BEGIN
  531:  4           IF NOT PufferVoll THEN BEGIN LiesPuffer; p:=Anfang END;
  532:  4           zeile:=p^.Eintrag; p:=p^.Naechster;
  533:  4           IF p^.Naechster=NIL THEN ClearPuffer;
  534:  4           IF AutoBlockFlag AND (PufferGroesse>PL-ZeilenZahl-MB-3)
  535:  4              AND (PufferGroesse<=PL-MT-MB-3) THEN NeueSeite;
  536:  4           PufferGroesse:=0;
  537:  4           IF NOT SonderZeile(zeile) THEN BEGIN
  538:  5            IF ZeilenZahl mod PL = 0 THEN SeitenKopf;
  539:  5            IF PL - ZeilenZahl   = MB + 3 THEN NeueSeite;
  540:  5            IF ListFlag THEN BEGIN drucke(zeile); ZeilenZahl:=ZeilenZahl+1 END;
  541:  5            ZeilenNummer:=ZeilenNummer+1;
  542:  5           END {if not SonderZeile}
  543:  4        END; {while} IF cross IN Options THEN SchreibCrossListe;
  544:  3        close(MainFile);
  545:  3       END
  546:  2  
  547:  2      ELSE IF MainFileName<>'' THEN writeln('File existiert nicht.')
  548:  2  
  549:  2    UNTIL MainFileName='';
  550:  1  END.

Die Crossreferenz-Liste

Listing of PLIST.PAS                                               PAGE 9


Crossreferenz-Liste:

a                  :   247   297   301   304   307   308   309   313   315
                       325   326   327   329
Anfang             :    61   460   469   531
AutoBlock          :    44   208   212
AutoBlockFlag      :    57   212   406   407   534
AZ                 :   141   150   157   162   163   164
b                  :    91    92    94    96   105   107   157   160   163
Bez                :    24    34    75    76    91   102   105
Bezeichner         :    33
b^                 :   108
b^.l               :   162
b^.r               :   164
CaseFlag           :    60   269   270   272   492
cl                 :   103   130   131
ClearPuffer        :   458   533
cl^.Nummer         :   132
cl^.ZNext          :   131   134
cnl                :   103   134
cnl^.Nummer        :   134
cnl^.ZNext         :   134
CP                 :    12   398   403   510
Cross              :    44   210   213   310   328   543
CrossList          :    62   117   118   119   174   524
drucke             :   245   540
Einfuegen          :   102   313   329
Eintrag            :    21
EndOfBlock         :   444   455   479
EXIT               :   102   116   138
Fehler             :   378   386   394   395   396   397   398   399
FileExists         :   221   232   422   523
filetype           :    18   221
FIncl              :    44   207   368
FO                 :    14   352   353   401
gefunden           :   103   107   117   130   137
gross              :    71    73    92   122   126   185   260   286   288
                       417
h                  :   142   147   148   152   258   260   263   264   265
                       375   381   382   399   422   427   435   438   440
                       441   445   447   448   452   453   454   455
HE                 :    13   338   339   400   526
h^.Nummer          :   152
h^.ZNext           :   152
i                  :    72    73    91    92    93    94    95    96   190
                       203   204   246   258   260   262   263   280   284
                       297   298   300   301   302   303   304   316   317
                       318   319   320   321   322   334   338   339   341
                       347   351   352   353   354   379   383   384   385
                       387   388   392   393   400   401   409   410   412
                       414   415   416   417   436   439   440
IdentList          :    32    35    62   103   105   141   157
IName              :    34   110
InclFile           :    43   228   229   237   448   471
InclFileName       :    46   228   413   414   417   420   421   423   424
include            :    18   228   422
IncludeFlag        :    56   238   422   423   448   449   471   489
Iter               :    52   267   269   270   272   296   492
j                  :    91    92    93    94    95   258   260   262   263
                       280   286   379
KommentarFlag      :    54   261   311   318   320   321   328   491
l                  :    35   110   141
leer               :   434   441   452
LiesFileName       :   181   497
LiesOptions        :   189   524
LiesPuffer         :   467   531
line               :    16    21    41    71   245   247   249   258   276
                       365   373   434
linelength         :    17    72   246   334   347
ListFlag           :    58   336   350   404   405   489   540
LNummer            :    44   205   295
LST                :   146   150   151   152   153   172   286   288   290
                       294   295   296   309   316   327   330   337   338
                       339   340   341   350   351   352   353   354
l^.IName           :   146
l^.ZList           :   147
m                  :    91    93    94   258   262   379   384   400   401
MachZweig          :   105   119   123   127
main               :    18   225   523
MainFile           :    42   225   226   447   472   530   544
MainFileName       :    45   185   225   419   420   421   499   523   525
                       526   547   549
markiere           :   276   308   326
MB                 :    10   144   145   396   403   454   508   534   535
                       539
MT                 :     9   144   171   341   342   395   403   454   507
                       535
n                  :    75    92   182   184   185
Naechster          :    22
NeueSeite          :    68   144   145   171   346   402   403   535   539
Nummer             :    28
o                  :   191   201   203   204   217   218
Options            :    44   202   205   206   207   208   209   210   212
                       213   282   295   296   310   328   368   543
p                  :    61   103   123   127   460   462   463   475   476
                       478   531   532
PL                 :     8   144   145   171   351   394   403   454   506
                       534   535   538   539
PLIST              :     5
PO                 :    11   146   151   174   294   337   350   397   509
Puffer             :    20
PufferGroesse      :    51   349   454   468   474   534   535   536
PufferVoll         :    59   464   480   491   530   531
PufferZeiger       :    19    22    61
p^.Eintrag         :   532
p^.Naechster       :   461   477   532   533
q                  :    61   103   117   124   128   462   469   478
q^                 :   129
q^.Eintrag         :   473
q^.IName           :   122   126
q^.l               :   123   124
q^.Naechster       :   462   469   476


Listing of PLIST.PAS                                               PAGE 10


q^.r               :   127   128
r                  :    35   110
reserviert         :   249   264   308   325
ResWords           :   250   262   263
RMark              :    44   206   282
SchliessIncludeFile:   235   450
SchreibBaum        :   157   162   164   174
SchreibCrossListe  :   169   543
SchreibListe       :   141   163
SeitenKopf         :   333   357   538
SeitenZahl         :    47   338   352   355   490   524
Sonder             :   365   367   381   453
SonderZeile        :   373   427   537
SpaltenZahl        :    48   174   215
Standard           :    75    96   116
Standardbezeichner :    76    94    96
StringFlag         :    55   261   312   317   319   322   328   330   490
text               :    43
Versch             :    44   209   296
w                  :   102   105   110   116   119   122   123   126   127
                       258   260   262   263   266   268   270   271   376
                       386   388   389   394   395   396   397   398   400
                       401   402   403   404   405   406   407
WarteFlag          :    53   218   356
wort               :    40
x                  :    71    73   221   224   245   249   260   276   286
                       288   290   298   300   301   302   303   304   316
                       317   318   319   320   321   365   367   368   369
                       370   373   381   383   384   387   388   392   393
                       400   401   410   412   414   416   417   434   440
x1                 :   158
xr                 :   158
z                  :   142   147   150   151   152   377   391   393   394
                       395   396   397   398
zeile              :    41   452   453   471   472   473   532   537   540
ZeilenEintrag      :    27
ZeilenListe        :    26    29    36   103   142
ZeilenNummer       :    50   295   313   329   529   541
ZeilenZahl         :    49   144   145   150   153   171   173   342   351
                       403   528   534   538   539   540
ZList              :    36   111   130
ZList^.Nummer      :   111
ZList^.ZNext       :   111
ZNext              :    29
^Bezeichner        :    32
^Puffer            :    19
^ZeilenEintrag     :    26

Die Statische Struktur

Statische Struktur von PLIST.PAS
PLIST.PAS   : PROGRAM PLIST
PLIST-1.INC :    PROCEDURE NeueSeite; FORWARD
PLIST-1.INC :    FUNCTION gross
PLIST-1.INC :    FUNCTION Standard
PLIST-1.INC :    PROCEDURE Einfuegen
PLIST-1.INC :       PROCEDURE MachZweig
PLIST-1.INC :    PROCEDURE SchreibListe
PLIST-1.INC :    PROCEDURE SchreibBaum
PLIST-1.INC :    PROCEDURE SchreibCrossListe
PLIST-2.INC :    PROCEDURE LiesFileName
PLIST-2.INC :    PROCEDURE LiesOptions
PLIST-2.INC :    FUNCTION FileExists
PLIST-2.INC :    PROCEDURE SchliessIncludeFile
PLIST-3.INC :    PROCEDURE drucke
PLIST-3.INC :       FUNCTION reserviert
PLIST-3.INC :       PROCEDURE markiere
PLIST-3.INC :    PROCEDURE SeitenKopf
PLIST-3.INC :    PROCEDURE NeueSeite
PLIST-4.INC :    FUNCTION Sonder
PLIST-4.INC :    FUNCTION SonderZeile
PLIST-5.INC :    FUNCTION leer
PLIST-5.INC :    FUNCTION EndOfBlock
PLIST-5.INC :    PROCEDURE ClearPuffer
PLIST-5.INC :    PROCEDURE LiesPuffer