PSTAT creates overview

PSTAT schafft Übersicht

Programm-Inhaltsverzeichnis

fantastischer Überblick bei langen Programmen

listet alle Prozeduren und Funktionen

optische Darstellung der Blockverschachtelung

Anzeige aller Quelldatelen

wenige Diskettenzugriffe durch eingebauten Puffer

erkennt FORWARD- und EXTERN-Deklarationen

Ein Tip: Auf der Turbo-Originaldiskette befindet sich ein Tabellenkalkulations-Programm. Wollen Sie wissen, wie es aufgebaut ist? Wollen Sie es erweitern, ohne erst 25 Listing-Seiten durchzuarbeiten? Wollen Sie es an Ihre Hardware anpassen, ohne sich durch alle Include-Files zu quälen? Wollen Sie ein wirklich informatives Inhaltsverzeichnis dieses langen Programms? Dann ist PLIST sas richtige Programm für Sie!
Beim Durchblättern dieses Hefts werden Sie schnell seine Vorzüge au schätzen wissen. Es druckt alle Funktionen mnd Prozeduren eines Programms aus, rückt bei Verschachtelungen ein und gibt die Namen der Dateien am, in denen sie sich befinden.
Wenn Sie den mit PSTAT erzeugten überblick der statischen Struktur (deshalb PSTAT) Ihrer Programme zu Ihren Listings heften, haben Sie eine optimale Selbstdokumentation. Alle Programm-Überblicke in diesem Heft wurden mit PSTAT erzeugt.

Bedienung

Nach dem Aufruf meldet sich das Programm mit

PSTAT vers. 2.0 Geben Sie den Programmnamen ein oder RETURN für Ende

Sie müssen nun nur den gewünschten Namen eintippen, und schon läuft alles weitere gang automatisch ab. Include-Files werden immer auf derselben Diskette wie das Programm erwartet.

Programmtechnische Details

Das Programm ist direkt aus PLIST entstanden, wie die Bezeichner unschwer verraten. Der Einlesepuffer ist wesentlich größer geworden. In manchen Fällen belegt er den gesamten Speicher. Die Standardprozedur MEMAVAIL wacht darüber, daß er nicht überläuft. Dieser Puffer ist die Ursache für die wenigen Diskettenzugriffe.

Anregungen

Da PSTAT die Programmtextdateien genauso zeilenweise einliest wie PLIST, können Sie die Zeilennummern mitzählen lassen. Sie können dann eine Option einbauen, die die Zeilennummern bei den Prozeduren und Funktionen mitausdruckt. Dies würde das Wiederfinden in den Listings noch mehr erleichtern.

Listing von PSTAT.PAS

{****************************************************************************}
{*               PSTAT 2.0  copyright 1984 by Ulrich Kern                   *}
{****************************************************************************}

PROGRAM PSTAT; {Gibt die statische Struktur eines Programms wieder}
 {V-}   {Kein range-checking bei string-Uebergabe}

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

   VAR   wort,
         zeile           : line;
         MainFile,
         InclFile        : text;
         MainFilename,
         FileName,
         InclFileName    : STRING[14];
         qq,
         PufferGroesse,
         Iter            : integer;
         IncludeFlag,
         NamenFlag,
         KommFlag, StrFlag,
         PufferVoll      : boolean;
         Anfang, p, q    : PufferZeiger;
         i               : integer;
         a,b             : line;

(*$I PSTAT-1.INC *)
(*$I PSTAT-2.INC *)
(*$I PSTAT-3.INC *)
{****************************************************************************}
{*                        Das Hauptprogramm                                 *}
{****************************************************************************}

BEGIN {Hauptprogramm}

  IncludeFlag:=false;  StrFlag:=false;  Anfang:=NIL;
  PufferVoll:=false;   KommFlag:=false; NamenFlag:=false;
  Iter:=0;             qq:=0;
  writeln('PSTAT vers. 2.0');writeln;
  REPEAT
    write('Geben Sie den Programm-Namen ein oder RETURN fuer Ende: ');
    LiesFileName;

   IF (MainFilename<>'') AND FileExists(main)
    THEN BEGIN
      writeln(LST,'Statische Struktur von ',MainFilename); writeln(LST);
      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 NOT Sonderzeile(zeile)
          THEN BEGIN
             a:='';
             FOR i:=1 TO length(zeile) DO BEGIN
              IF zeile[i] in [#39,'0'..'9','A'..'Z','a'..'z']
               THEN a:=a+zeile[i]
               ELSE IF a<>''
                 THEN
                   BEGIN b:=gross(a);
                    IF (qq>0) AND NOT(StrFlag) AND NOT(KommFlag)
                     THEN
                      BEGIN
                       IF (b='CASE') OR (b='BEGIN') THEN qq:=qq+1;
                       IF b='END' THEN BEGIN
                                        qq:=qq-1;
                                        IF qq=0 THEN Iter:=Iter-1
                                       END
                      END
                     ELSE IF (qq=0) AND NOT(StrFlag) AND NOT(KommFlag)
                      THEN
                       BEGIN
                         IF (b='FORWARD') OR (b='EXTERN') THEN
                            BEGIN write(LST,'; ',b); Iter:=Iter-1 END;
                         IF NamenFlag THEN write(LST,a);
                         NamenFlag:=false;
                         IF (b='PROCEDURE') or(b='FUNCTION')
                            THEN BEGIN
                                   writeln(LST);
                                   Print(b);
                                   Iter:=succ(Iter);
                                   NamenFlag:=true
                                 END;
                         IF (b='PROGRAM')
                            THEN BEGIN
                                   writeln(LST);
                                   Print(b);
                                   Iter:=1;
                                   NamenFlag:=true
                                 END;
                         IF (b='BEGIN') THEN qq:=1
                       END;
                    a:=''
                   END; {else}
                   IF NOT(StrFlag) AND (zeile[i]='{') THEN KommFlag:=true;
                   IF NOT(StrFlag) AND (zeile[i]='}') THEN KommFlag:=false;
                   IF NOT(KommFlag) AND (zeile[i]=chr(39)) THEN StrFlag:=NOT(StrFlag)
             END {for}

          END {if not SonderZeile}
      END; {while}
     close(MainFile); writeln(LST); writeln(LST);
   END {if not EOF...}
   ELSE IF MainFilename<>'' THEN  writeln('File existiert nicht.');

  UNTIL MainFilename=''

END.

Listing von PSTAT-1.INC

{****************************************************************************}
{*                      Utility-Prozeduren                                  *}
{****************************************************************************}

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

   PROCEDURE LiesFileName;
     VAR n : STRING[14];
     BEGIN
       readln(n);
       MainFilename:=gross(n);
       writeln
     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 SchliesseIncludeFile;
     BEGIN
     close(InclFile);
     IncludeFlag:=false
   END;

Listing von PSTAT-2.INC

{****************************************************************************}
{*              Entschluesselung der Include-Anweisungen                    *}
{****************************************************************************}

   FUNCTION Sonder( VAR x : line) : boolean;
   BEGIN
     Sonder:=(pos(chr(39),x)=0) 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;
     VAR h   : boolean;
         i   : integer;
     BEGIN
       h:=Sonder(x);
       IF h THEN BEGIN
         i:=pos('{$I',x)+3; IF i=3 THEN i:=pos('(*$I',x)+4;
         IF i>3 THEN BEGIN
            InclFileName:='';
            WHILE x[i]=' ' DO i:=i+1;
            WHILE (i<length(x)) AND
                   (x[i] in['-','.',':','0'..'9','A'..'Z','a'..'z']) DO
                  BEGIN InclFileName:=InclFileName+gross(x[i]); i:=i+1 END;
            IF MainFilename[2]=':' THEN
              IF InclFileName[2]=':' THEN InclFileName[1]:=MainFilename[1]
                        ELSE InclFileName:=MainFilename[1]+':'+InclFileName;
            IncludeFlag:=FileExists(Include); h:=IncludeFlag;
         END
       END;
       Sonderzeile:=h
     END;

Listing von PSTAT-3.INC

{****************************************************************************}
{*                         Puffer-Operationen                               *}
{****************************************************************************}
   FUNCTION EndOfBlock : boolean;
     VAR h : boolean;
     BEGIN
       h:=EOF(MainFile);
       IF IncludeFlag THEN IF EOF(InclFile) THEN BEGIN h:=true;
                                                       IncludeFlag:=false;
                                                       SchliesseIncludeFile
                                                 END;
       IF NOT(h) THEN h:=Sonder(zeile);
       IF abs(MaxAvail)<500 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; VAR h:boolean;
     BEGIN PufferGroesse:=0;
       new(q); Anfang:=q; q^.Naechster:=NIL;
       REPEAT
         IF IncludeFlag THEN BEGIN readln(InclFile,zeile);
                                   FileName:=InclFileName END
                        ELSE BEGIN readln(MainFile,zeile);
                                   FileName:=MainFilename END;
         q^.Eintrag:=zeile;
         PufferGroesse:=PufferGroesse+1;
         new(p);
         q^.Naechster:=p;
         p^.Naechster:=NIL;
         q:=p;
       UNTIL EndOfBlock;
       PufferVoll:=true
     END;

   PROCEDURE Print(a:line);
     VAR i : integer;
     BEGIN
       IF FileName[2]=':' THEN FileName:=copy(FileName,3,length(FileName)-2);
       write(LST,FileName,': ':14-length(FileName));
       FOR i:=1 TO Iter DO write(LST,'   ');
       write(LST,a,' ')
     END;

Das Listing

Listing of PSTAT.PAS                                               PAGE 1


    1:  0  {****************************************************************************}
    2:  0  {*               PSTAT 2.0  copyright 1984 by Ulrich Kern                   *}
    3:  0  {****************************************************************************}
    4:  0  
    5:  0  PROGRAM PSTAT; {Gibt die statische Struktur eines Programms wieder}
    6:  0   {V-}   {Kein range-checking bei string-Uebergabe}
    7:  0  
    8:  0     TYPE  line            = STRING[128];
    9:  0           linelengt       = 0..128;
   10:  0           filetype        = (main,include);
   11:  0           PufferZeiger    = ^Puffer;
   12:  0           Puffer          = RECORD
   13:  1                                Eintrag   : line;
   14:  1                                Naechster : PufferZeiger
   15:  1                             END;
   16:  0  
   17:  0     VAR   wort,
   18:  0           zeile           : line;
   19:  0           MainFile,
   20:  0           InclFile        : text;
   21:  0           MainFilename,
   22:  0           FileName,
   23:  0           InclFileName    : STRING[14];
   24:  0           qq,
   25:  0           PufferGroesse,
   26:  0           Iter            : integer;
   27:  0           IncludeFlag,
   28:  0           NamenFlag,
   29:  0           KommFlag, StrFlag,
   30:  0           PufferVoll      : boolean;
   31:  0           Anfang, p, q    : PufferZeiger;
   32:  0           i               : integer;
   33:  0           a,b             : line;
   34:  0  
   35:  0  {****************************************************************************}
   36:  0  {*                      Utility-Prozeduren                                  *}
   37:  0  {****************************************************************************}
   38:  0  
   39:  0     FUNCTION gross ( x : line ) : line;
   40:  0       VAR i : integer;
   41:  0       BEGIN FOR i:=1 TO length(x) DO x[i]:=upcase(x[i]); gross:=x; END;
   42:  0  
   43:  0     PROCEDURE LiesFileName;
   44:  0       VAR n : STRING[14];
   45:  0       BEGIN
   46:  1         readln(n);
   47:  1         MainFilename:=gross(n);
   48:  1         writeln
   49:  1       END;
   50:  0  
   51:  0      FUNCTION FileExists ( x : filetype ) : boolean;
   52:  0       {Falls das File existiert, wird es zugleich eroeffnet.}
   53:  0       BEGIN
   54:  1       CASE x OF
   55:  2         main    : BEGIN assign(MainFile,MainFilename);
   56:  3                         {$I-}; reset(MainFile); {$I+};
   57:  3                   END;
   58:  2         include : BEGIN assign(InclFile,InclFileName);
   59:  3                         {$I-}; reset(InclFile); {$I+};
   60:  3                   END;
   61:  2       END;
   62:  1       FileExists:=(ioresult=0)
   63:  1     END;
   64:  0  
   65:  0     PROCEDURE SchliesseIncludeFile;
   66:  0       BEGIN
   67:  1       close(InclFile);
   68:  1       IncludeFlag:=false
   69:  1     END;
   70:  0  
   71:  0  {****************************************************************************}
   72:  0  {*              Entschluesselung der Include-Anweisungen                    *}
   73:  0  {****************************************************************************}
   74:  0  
   75:  0     FUNCTION Sonder( VAR x : line) : boolean;
   76:  0     BEGIN
   77:  1       Sonder:=(pos(chr(39),x)=0) AND
   78:  1          (((pos('{$I',x)>0) OR (pos('(*$I',x)>0))
   79:  1           AND (pos('{$I+',x)=0) AND (pos('{$I-',x)=0)
   80:  1           AND (pos('(*$I+',x)=0) AND (pos('(*$I-',x)=0))
   81:  1      END;
   82:  0  


Listing of PSTAT.PAS                                               PAGE 2


   83:  0     FUNCTION Sonderzeile ( VAR x : line) : boolean;
   84:  0       VAR h   : boolean;
   85:  0           i   : integer;
   86:  0       BEGIN
   87:  1         h:=Sonder(x);
   88:  1         IF h THEN BEGIN
   89:  2           i:=pos('{$I',x)+3; IF i=3 THEN i:=pos('(*$I',x)+4;
   90:  2           IF i>3 THEN BEGIN
   91:  3              InclFileName:='';
   92:  3              WHILE x[i]=' ' DO i:=i+1;
   93:  3              WHILE (i<length(x)) AND
   94:  3                     (x[i] in['-','.',':','0'..'9','A'..'Z','a'..'z']) DO
   95:  3                    BEGIN InclFileName:=InclFileName+gross(x[i]); i:=i+1 END;
   96:  3              IF MainFilename[2]=':' THEN
   97:  3                IF InclFileName[2]=':' THEN InclFileName[1]:=MainFilename[1]
   98:  3                          ELSE InclFileName:=MainFilename[1]+':'+InclFileName;
   99:  3              IncludeFlag:=FileExists(Include); h:=IncludeFlag;
  100:  3           END
  101:  2         END;
  102:  1         Sonderzeile:=h
  103:  1       END;
  104:  0  
  105:  0  {****************************************************************************}
  106:  0  {*                         Puffer-Operationen                               *}
  107:  0  {****************************************************************************}
  108:  0     FUNCTION EndOfBlock : boolean;
  109:  0       VAR h : boolean;
  110:  0       BEGIN
  111:  1         h:=EOF(MainFile);
  112:  1         IF IncludeFlag THEN IF EOF(InclFile) THEN BEGIN h:=true;
  113:  2                                                         IncludeFlag:=false;
  114:  2                                                         SchliesseIncludeFile
  115:  2                                                   END;
  116:  1         IF NOT(h) THEN h:=Sonder(zeile);
  117:  1         IF abs(MaxAvail)<500 THEN h:=true;
  118:  1         EndOfBlock:=h
  119:  1      END;
  120:  0  
  121:  0     PROCEDURE ClearPuffer;
  122:  0       BEGIN
  123:  1         p:=Anfang;
  124:  1         WHILE p^.Naechster<>NIL DO BEGIN
  125:  2         q:=p; dispose(p); p:=q^.Naechster;
  126:  2         END;  dispose(p);
  127:  1         PufferVoll:=false
  128:  1       END;
  129:  0  
  130:  0     PROCEDURE LiesPuffer; VAR h:boolean;
  131:  0       BEGIN PufferGroesse:=0;
  132:  1         new(q); Anfang:=q; q^.Naechster:=NIL;
  133:  1         REPEAT
  134:  2           IF IncludeFlag THEN BEGIN readln(InclFile,zeile);
  135:  3                                     FileName:=InclFileName END
  136:  2                          ELSE BEGIN readln(MainFile,zeile);
  137:  3                                     FileName:=MainFilename END;
  138:  2           q^.Eintrag:=zeile;
  139:  2           PufferGroesse:=PufferGroesse+1;
  140:  2           new(p);
  141:  2           q^.Naechster:=p;
  142:  2           p^.Naechster:=NIL;
  143:  2           q:=p;
  144:  2         UNTIL EndOfBlock;
  145:  1         PufferVoll:=true
  146:  1       END;
  147:  0  
  148:  0     PROCEDURE Print(a:line);
  149:  0       VAR i : integer;
  150:  0       BEGIN
  151:  1         IF FileName[2]=':' THEN FileName:=copy(FileName,3,length(FileName)-2);
  152:  1         write(LST,FileName,': ':14-length(FileName));
  153:  1         FOR i:=1 TO Iter DO write(LST,'   ');
  154:  1         write(LST,a,' ')
  155:  1       END;
  156:  0  


Listing of PSTAT.PAS                                               PAGE 3


  157:  0  {****************************************************************************}
  158:  0  {*                        Das Hauptprogramm                                 *}
  159:  0  {****************************************************************************}
  160:  0  
  161:  0  BEGIN {Hauptprogramm}
  162:  1  
  163:  1    IncludeFlag:=false;  StrFlag:=false;  Anfang:=NIL;
  164:  1    PufferVoll:=false;   KommFlag:=false; NamenFlag:=false;
  165:  1    Iter:=0;             qq:=0;
  166:  1    writeln('PSTAT vers. 2.0');writeln;
  167:  1    REPEAT
  168:  2      write('Geben Sie den Programm-Namen ein oder RETURN fuer Ende: ');
  169:  2      LiesFileName;
  170:  2  
  171:  2     IF (MainFilename<>'') AND FileExists(main)
  172:  2      THEN BEGIN
  173:  3        writeln(LST,'Statische Struktur von ',MainFilename); writeln(LST);
  174:  3        WHILE NOT(EOF(MainFile)) OR PufferVoll DO
  175:  3        BEGIN
  176:  4          IF NOT PufferVoll THEN BEGIN LiesPuffer; p:=Anfang END;
  177:  4          zeile:=p^.Eintrag+' '; p:=p^.Naechster;
  178:  4          IF p^.Naechster=NIL THEN ClearPuffer;
  179:  4          IF NOT Sonderzeile(zeile)
  180:  4            THEN BEGIN
  181:  5               a:='';
  182:  5               FOR i:=1 TO length(zeile) DO BEGIN
  183:  6                IF zeile[i] in [#39,'0'..'9','A'..'Z','a'..'z']
  184:  6                 THEN a:=a+zeile[i]
  185:  6                 ELSE IF a<>''
  186:  6                   THEN
  187:  6                     BEGIN b:=gross(a);
  188:  7                      IF (qq>0) AND NOT(StrFlag) AND NOT(KommFlag)
  189:  7                       THEN
  190:  7                        BEGIN
  191:  8                         IF (b='CASE') OR (b='BEGIN') THEN qq:=qq+1;
  192:  8                         IF b='END' THEN BEGIN
  193:  9                                          qq:=qq-1;
  194:  9                                          IF qq=0 THEN Iter:=Iter-1
  195:  9                                         END
  196:  8                        END
  197:  7                       ELSE IF (qq=0) AND NOT(StrFlag) AND NOT(KommFlag)
  198:  7                        THEN
  199:  7                         BEGIN
  200:  8                           IF (b='FORWARD') OR (b='EXTERN') THEN
  201:  8                              BEGIN write(LST,'; ',b); Iter:=Iter-1 END;
  202:  8                           IF NamenFlag THEN write(LST,a);
  203:  8                           NamenFlag:=false;
  204:  8                           IF (b='PROCEDURE') or(b='FUNCTION')
  205:  8                              THEN BEGIN
  206:  9                                     writeln(LST);
  207:  9                                     Print(b);
  208:  9                                     Iter:=succ(Iter);
  209:  9                                     NamenFlag:=true
  210:  9                                   END;
  211:  8                           IF (b='PROGRAM')
  212:  8                              THEN BEGIN
  213:  9                                     writeln(LST);
  214:  9                                     Print(b);
  215:  9                                     Iter:=1;
  216:  9                                     NamenFlag:=true
  217:  9                                   END;
  218:  8                           IF (b='BEGIN') THEN qq:=1
  219:  8                         END;
  220:  7                      a:=''
  221:  7                     END; {else}
  222:  6                     IF NOT(StrFlag) AND (zeile[i]='{') THEN KommFlag:=true;
  223:  6                     IF NOT(StrFlag) AND (zeile[i]='}') THEN KommFlag:=false;
  224:  6                     IF NOT(KommFlag) AND (zeile[i]=chr(39)) THEN StrFlag:=NOT(StrFlag)
  225:  6               END {for}
  226:  5  
  227:  5            END {if not SonderZeile}
  228:  4        END; {while}
  229:  3       close(MainFile); writeln(LST); writeln(LST);
  230:  3     END {if not EOF...}
  231:  2     ELSE IF MainFilename<>'' THEN  writeln('File existiert nicht.');
  232:  2  
  233:  2    UNTIL MainFilename=''
  234:  1  
  235:  1  END.

Die Statische Struktur