Programmer's ROM - The Computer Language Library/programmersrom.iso/ada/crsref/adaref.pas

Pascal/Delphi Source File | 1988-05-03 | 23.2 KB | 696 lines

 PROGRAM ADAREF(INPUT,OUTPUT);




 (* ADAREF - CROSS REFERENCE ADA PROGRAMS.                            *)
 (*                                                                   *)
 (* ORIGINAL PROGRAM (NAMED XREF).                                    *)
 (*    - N. WIRTH 71/01/15, 74/05/07, 75/07/02, 76/02/10.             *)
 (*      (SEE CHAPTER 4 IN "ALGORITHMS + DATA STRUCTURES = PROGRAMS") *)
 (* USE BETTER SORT, CASE STATEMENT IN SCANNER, PROCEDURE MAP,        *)
 (* CONTROL STATEMENT PROCESSING.                                     *)
 (*    - A. MICKEL 75/12/08.                                          *)
 (* USE RING STRUCTURE FOR REFERENCES.                                *)
 (*    - R. CICHELLI 76/11/14.                                        *)
 (* PROCESS LINE NUMBERS.                                             *)
 (*    - D. LALIBERTE 78/03/15.                                       *)
 (* PROCESS COMPILER TITLES, DIFFERENT PRINT DENSITIES,               *)
 (* USE VALUE PART, SORT CORRECTLY, ADD NESTING LEVELS.               *)
 (*   - J. STRAIT 78/12/28.                                           *)
 (* CONVERTED PASREF TO ADAREF TO PROCESS ADA PROGRAMS                *)
 (*  - K. CASSIDY,  C. ANDERSON    USAF ARMAMENT LAB (904-882-8264)   *)
 (*               82/11/30                                            *)
 (*                                                                   *)




 LABEL 99;




 CONST P = 1499;     (*SIZE OF HASH TABLE*)
   NK =126;          (* NO. OF KEYWORDS *)
   KLN= 36;          (* KEYLENGTH *)
   LPPG6 = 63;       (*LINES PER PAGE AT 6 LINES PER INCH*)
   LTPG6 = 3;        (*LINES AT TOP OF PAGE AT 6 LINES PER INCH*)
   LLINMAX = 120;    (*MAXIMUM INPUT LINE LENGTH*)
   LLOUTMAX = 132;   (*MAXIMUM OUTPUT LINE LENGTH*)
   MAXN = 100000;    (*MAX NO. OF LINES*)
   DGPN =  6;        (*NO. OF DIGITS PER NUMBER*)
   STARS = ' *****';



 TYPE INDEX = 0..P;
   INDEX1= -1..P;
   ALFA = PACKED ARRAY [1..KLN] OF CHAR;
   REF = ^ITEM;
   WORD = RECORD KEY: ALFA;
            LAST: REF;
          END ;
   ITEM = PACKED RECORD
            LNO: 0..MAXN;
            NEXT: REF
          END ;
   PROCREF = ^PROC;  (*PROCEDURE OR FUNCTION REFERENCE*)
   PROC = PACKED RECORD
            NAME: ALFA;
            LNO: 0..MAXN;
            NEXT: PROCREF
          END ;




 VAR I: INDEX;
   K: INTEGER;
   M: INTEGER;       (*NO. OF LINES ON PAGE*)
   N: INTEGER;       (*NO. OF LINES INPUT*)
   LPPG: INTEGER;    (*NUMBER OF LINES PER PAGE*)
   LTPG: INTEGER;    (*NUMBER OF BLANK LINES AT TOP OF PAGE*)
   LN: INTEGER;      (*CURRENT LINE NUMBER*)
   LLOUT: INTEGER;   (*LINE LENGTH FOR OUTPUT*)
   LLIN: INTEGER;    (*LINE LENGTH FOR INPUT*)
   CCOUNT: INTEGER;  (*CHARACTER COUNT IN LINE*)
   NOPL: INTEGER;    (*NO. OF LINE-NUMBERS PER LINE*)
   EMPTY: ALFA;
 (*                                                *)
 (* THE NEXT CONSTRUCT FORCES ID.A AND ID.ORD TO SHARE FIRST WORD *)
   ID: RECORD CASE BOOLEAN OF
              FALSE: (A: ALFA);
                TRUE:  (ORD:INTEGER)
       END ;
   T: ARRAY [INDEX] OF WORD;    (*HASH TABLE*)
   KEYINDEX: 0..NK;
   KEY: ARRAY[0..NK] OF RECORD
                          K: ALFA;
                          N: -1..1
                        END;
   PROCKEY,FUNCKEY,ACCEPT_KEY,BEGINKEY,PACKKEY,USE_KEY: ALFA;
   PROCLOW,FUNCLOW,ACCEPTLOW,BEGINLOW,PACKLOW,USELOW: ALFA;
   CASEKEY,IFKEY,LOOPKEY,RECKEY,SELECT_KEY,TASKKEY,WITH_KEY:ALFA;
   CASELOW,IFLOW,LOOPLOW,RECLOW,SELECTLOW,TASKLOW,WITHLOW:ALFA;
   INBODY: BOOLEAN;
   NESTING,NESTCOUNT: INTEGER;
   NEST: ARRAY[1..LLINMAX] OF INTEGER;
   PROCORFUNC,
   PAGINATING: BOOLEAN;
   FIRSTPROC,
   PROCPTR: PROCREF; (*POINTERS TO CHAIN OF PROCEDURES*)




 VALUE EMPTY := (KLN OF ' ');
    T := (P OF ((KLN OF ' '), NIL), ((KLN OF ' '), NIL));
    (*RESERVED WORD TABLE*)
    KEY := (('                                    ', 0),
           ('ABORT                               ', 0),
           ('ABS                                 ', 0),
           ('ACCEPT                              ',+1),
           ('ACCESS                              ', 0),
           ('ALL                                 ', 0),
           ('AND                                 ', 0),
           ('ARRAY                               ', 0),
           ('AT                                  ', 0),
           ('BEGIN                               ',+1),
           ('BODY                                ', 0),
           ('CASE                                ',+1),
           ('CONSTANT                            ', 0),
           ('DECLARE                             ', 0),
           ('DELAY                               ', 0),
           ('DELTA                               ', 0),
           ('DIGITS                              ', 0),
           ('DO                                  ', 0),
           ('ELSE                                ', 0),
           ('ELSIF                               ', 0),
           ('END                                 ',-1),
           ('ENTRY                               ', 0),
           ('EXCEPTION                           ', 0),
           ('EXIT                                ', 0),
           ('FOR                                 ', 0),
           ('FUNCTION                            ', 0),
           ('GENERIC                             ', 0),
           ('GOTO                                ', 0),
           ('IF                                  ',+1),
           ('IN                                  ', 0),
           ('IS                                  ', 0),
           ('LIMITED                             ', 0),
           ('LOOP                                ',+1),
           ('MOD                                 ', 0),
           ('NEW                                 ', 0),
           ('NOT                                 ', 0),
           ('NULL                                ', 0),
           ('OF                                  ', 0),
           ('OR                                  ', 0),
           ('OTHERS                              ', 0),
           ('OUT                                 ', 0),
           ('PACKAGE                             ',+1),
           ('PRAGMA                              ', 0),
           ('PRIVATE                             ', 0),
           ('PROCEDURE                           ', 0),
           ('RAISE                               ', 0),
           ('RANGE                               ', 0),
           ('RECORD                              ',+1),
           ('REM                                 ', 0),
           ('RENAMES                             ', 0),
           ('RETURN                              ', 0),
           ('REVERSE                             ', 0),
           ('SELECT                              ',+1),
           ('SEPARATE                            ', 0),
           ('SUBTYPE                             ', 0),
           ('TASK                                ', 0),
           ('TERMINATE                           ', 0),
           ('THEN                                ', 0),
           ('TYPE                                ', 0),
           ('USE                                 ', 0),
           ('WHEN                                ', 0),
           ('WHILE                               ', 0),
           ('WITH                                ', 0),
           ('X0R                                 ', 0),
           ('abort                               ', 0),
           ('abs                                 ', 0),
           ('accept                              ',+1),
           ('access                              ', 0),
           ('all                                 ', 0),
           ('and                                 ', 0),
           ('array                               ', 0),
           ('at                                  ', 0),
           ('begin                               ',+1),
           ('body                                ', 0),
           ('case                                ',+1),
           ('constant                            ', 0),
           ('declare                             ', 0),
           ('delay                               ', 0),
           ('delta                               ', 0),
           ('digits                              ', 0),
           ('do                                  ', 0),
           ('else                                ', 0),
           ('elsif                               ', 0),
           ('end                                 ',-1),
           ('entry                               ', 0),
           ('exception                           ', 0),
           ('exit                                ', 0),
           ('for                                 ', 0),
           ('function                            ', 0),
           ('generic                             ', 0),
           ('goto                                ', 0),
           ('if                                  ',+1),
           ('in                                  ', 0),
           ('is                                  ', 0),
           ('limited                             ', 0),
           ('loop                                ',+1),
           ('mod                                 ', 0),
           ('new                                 ', 0),
           ('not                                 ', 0),
           ('null                                ', 0),
           ('of                                  ', 0),
           ('or                                  ', 0),
           ('others                              ', 0),
           ('out                                 ', 0),
           ('package                             ',+1),
           ('pragma                              ', 0),
           ('private                             ', 0),
           ('procedure                           ', 0),
           ('raise                               ', 0),
           ('range                               ', 0),
           ('record                              ',+1),
           ('rem                                 ', 0),
           ('renames                             ', 0),
           ('return                              ', 0),
           ('reverse                             ', 0),
           ('select                              ',+1),
           ('separate                            ', 0),
           ('subtype                             ', 0),
           ('task                                ', 0),
           ('terminate                           ', 0),
           ('then                                ', 0),
           ('type                                ', 0),
           ('use                                 ', 0),
           ('when                                ', 0),
           ('while                               ', 0),
           ('with                                ', 0),
           ('xor                                 ', 0));
    PROCKEY := 'PROCEDURE                           ';
    PROCLOW := 'procedure                           ';
    FUNCKEY := 'FUNCTION                            ';
    FUNCLOW := 'function                            ';
    BEGINKEY := 'BEGIN                               ';
    BEGINLOW := 'begin                               ';
    CASEKEY := 'CASE                                ';
    CASELOW := 'case                                ';
    IFKEY := 'IF                                  ';
    IFLOW := 'if                                  ';
    PACKKEY := 'PACKAGE                             ';
    PACKLOW := 'package                             ';
    LOOPKEY := 'LOOP                                ';
    LOOPLOW := 'loop                                ';
    RECKEY := 'RECORD                              ';
    RECLOW := 'record                              ';
    TASKKEY := 'TASK                                ';
    TASKLOW := 'task                                ';
    ACCEPT_KEY := 'ACCEPT                              ';
    ACCEPTLOW := 'accept                              ';
    SELECT_KEY := 'SELECT                              ';
    SELECTLOW := 'select                              ';
    USE_KEY := 'USE                                 ';
    USELOW := 'use                                 ';
    WITH_KEY := 'WITH                                ';
    WITHLOW := 'with                                ';
    N := 0;
    M := 0;
    LLIN := LLINMAX;
    LLOUT := LLOUTMAX;
    PROCORFUNC := TRUE;
    LPPG := LPPG6;
    LTPG := LTPG6;
    NESTING := 0;
    INBODY := FALSE;
    (* CLASSIFY RESERVED WORD  *)
 PROCEDURE CLASSIFY;
   VAR I,J,K: INTEGER;
 BEGIN I := 1; J := NK;   (*BINARY SEARCH*)
   KEYINDEX := 0;
   REPEAT K := (I+J) DIV 2;
     IF KEY[K].K <= ID.A THEN I := K+1 ELSE J := K-1
   UNTIL I > J;
   IF KEY[J].K = ID.A THEN KEYINDEX := J
 END (*CLASSIFY*) ;




 PROCEDURE BEGINLINE;
  VAR I: INTEGER;
 BEGIN
   IF PAGINATING THEN
     BEGIN
       IF M >= LPPG THEN
         BEGIN WRITE(' ');
           FOR I := 1 TO LTPG DO WRITELN;
           M := LTPG
         END;
       M := M + 1
     END
 END (*BEGINLINE*) ;




   (* GET NEXT CHARACTER  *)
 PROCEDURE ADVANCE;
 BEGIN
   IF NOT EOLN THEN
     BEGIN WRITE(INPUT^); GET(INPUT);
       CCOUNT := CCOUNT + 1;
       IF CCOUNT = LLIN THEN
         WHILE NOT EOLN(INPUT) DO
           BEGIN WRITE(INPUT^); GET(INPUT); CCOUNT := CCOUNT + 1 END
     END
 END (*ADVANCE*);




 PROCEDURE SKIP(J: INTEGER);
 BEGIN
   IF M+J >= LPPG THEN M := LPPG
   ELSE
     FOR J := 1 TO J DO BEGIN BEGINLINE; WRITELN END
 END (*SKIP*) ;



PROCEDURE NEWLINE;



 BEGIN CCOUNT := 0;
   NESTCOUNT := 1; NEST[1] := NESTING;
   IF N < MAXN THEN
   BEGIN BEGINLINE;  N := N + 1;
       LN := N;  WRITE(LN:6, ' ')
     END
   ELSE BEGIN
     WRITELN(STARS, ' TEXT TOO LONG', STARS);
     GOTO 99
     END
 END (*NEWLINE*) ;




   (* IF NOT RESERVED WORD,PUT IN TABLE T VIA MODULO P HASHING
   ALGORITM BASED ON ORDINAL VALUE OF WORD TO BE STORED *)
 PROCEDURE SEARCH;   (*MODULO P HASH SEARCH*)
   VAR H,D: INDEX;
       X,Y: REF; F: BOOLEAN;
 BEGIN
    H:= (ABS(ID.ORD) DIV 1024) MOD P;
   F := FALSE; D := 1;
   NEW(X); X^.LNO := LN;
   REPEAT
     IF T[H].KEY = ID.A THEN
     BEGIN (*FOUND*) F := TRUE;
       Y := T[H].LAST; X^.NEXT := Y^.NEXT;
       Y^.NEXT := X; T[H].LAST := X
     END ELSE
     IF T[H].KEY = EMPTY THEN
     BEGIN (*NEW ENTRY*) F := TRUE;
       T[H].KEY := ID.A;
       T[H].LAST := X; X^.NEXT := X
     END ELSE
     BEGIN (*COLLISION*) H := H+D; D := D+2;
       IF H >= P THEN H := H-P;
       IF D = P THEN
         BEGIN WRITELN; WRITELN(STARS,' TABLE FULL',STARS); GOTO 99
         END
     END
   UNTIL F
 END (*SEARCH*) ;




 PROCEDURE SORT(MIN, MAX: INTEGER);
    (* ALPHABETIZE CROSS REFERENCE TABLE (T) VIA QUICK SORT*)
   (* TABLE T HAS BEEN COMPRESSED  *)




 (* QUICKSORT WITH BOUNDED RECURSION DEPTH *)
 (* REQUIRES MIN <= MAX *)




    VAR
          LOW,
         HIGH: INDEX1;
       MIDKEY: ALFA;
         TEMP: WORD;






    BEGIN




   (*                                      *)
       REPEAT (*PICK SPLIT POINT*)
          MIDKEY := T[(MIN + MAX) DIV 2].KEY;
          LOW := MIN;
          HIGH := MAX;
          REPEAT (*PARTITION*)
             WHILE T[LOW].KEY < MIDKEY DO
                LOW := LOW + 1;
             WHILE T[HIGH].KEY > MIDKEY DO
                HIGH := HIGH - 1;
            IF LOW <= HIGH THEN
                BEGIN
                   TEMP := T[LOW];
                   T[LOW] := T[HIGH];
                   T[HIGH] := TEMP;
                   LOW := LOW + 1;
                   HIGH := HIGH - 1
                END;
          UNTIL LOW > HIGH;




          (*RECURSIVELY SORT SHORTER SUB-SEGMENT*)
          IF HIGH - MIN < MAX - LOW
          THEN
             BEGIN
                IF MIN < HIGH THEN
                   SORT(MIN, HIGH);
                MIN := LOW
             END
          ELSE
             BEGIN
                IF LOW < MAX THEN
                   SORT(LOW, MAX);
                MAX := HIGH
             END
       UNTIL MAX <= MIN
    END (*SORT*);








 PROCEDURE NOTEPROC;   (*NOTE INSTANCE OF PROCEDURE OR FUNCTION*)
   VAR P: PROCREF;
 BEGIN PROCORFUNC := FALSE;
   NEW(P); PROCPTR^.NEXT := P;
   P^.NAME := ID.A; P^.LNO := LN; P^.NEXT := NIL;
   PROCPTR := P
 END (*NOTEPROC*) ;




 PROCEDURE PRINTWORD(W: WORD);
   VAR L: INTEGER; X,Y: REF;
       K: ALFA;
 BEGIN K := W.KEY; L := KLN;
   BEGINLINE; WRITE(' ', K);
   X := W.LAST^.NEXT; Y := X;
   L := 0;
   REPEAT
     IF L = NOPL THEN
       BEGIN L := 0; WRITELN; BEGINLINE; WRITE(' ':KLN+1)
       END;
     L := L+1; WRITE(X^.LNO: DGPN); X := X^.NEXT
   UNTIL X = Y;
   WRITELN
 END (*PRINTWORD*) ;




 PROCEDURE PRINTTABLE;
   (* COMPRESS HASH TABLE T AND GO TO SORT TO ALPHABETIZE *)
   VAR I,M: INDEX;


 BEGIN M := 0;    (*COMPRESS TABLE*)
   FOR I := 0 TO P-1 DO
     IF T[I].KEY <> EMPTY THEN
       BEGIN T[M] := T[I]; M := M+1
       END ;




   IF M > 0 THEN SORT(0,M-1);
   NOPL := (LLOUT-KLN-1) DIV DGPN;
   SKIP(2);
   BEGINLINE;
   WRITELN(' CROSS REFERENCE OF IDENTIFIERS,',
           ' AND LABEL DECLARATIONS:');
   SKIP(1);
   FOR I := 0 TO M-1 DO PRINTWORD(T[I])
 END (*PRINTTABLE*) ;




 PROCEDURE PRINTPROCS;
   VAR N: ALFA; L: INTEGER;
 BEGIN SKIP(2); BEGINLINE;
   WRITELN(' LIST OF PROCEDURES, FUNCTIONS, TASKS, AND PACKAGES USED:');
   SKIP(1);
   PROCPTR := FIRSTPROC^.NEXT;
   WHILE PROCPTR <> NIL DO
     WITH PROCPTR^ DO
       BEGIN BEGINLINE;
         N := NAME; L := KLN;
         WRITELN(' ',N:KLN+3, LNO:10);
         PROCPTR := NEXT
       END
 END (*PRINTPROCS*) ;




 PROCEDURE INITIALIZE;


 BEGIN
   NEW(PROCPTR); FIRSTPROC := PROCPTR; PROCPTR^.NEXT := NIL;
     PROCPTR^.NEXT := NIL
 END (*INITIALIZE*) ;




 PROCEDURE SCANANDLISTINPUT;
  (*  EVALUATE CHARACTERS VIA CASE STATEMENT *)
   VAR I,N,NLAST,QUOTECT:INTEGER;
 BEGIN
   WHILE NOT EOF(INPUT) DO
   BEGIN NEWLINE;
     WHILE NOT EOLN(INPUT) DO
   (* VARIABLE, ATTRIBUTE, RESERVED WORD *)
     CASE INPUT^ OF
      'A','B','C','D','E','F','G','H','I','J','K','L','M',
      'N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
      'a','b','c','d','e','f','g','h','i','j','k','l','m',
      'n','o','p','q','r','s','t','u','v','w','x','y','z':
       BEGIN K := 0; ID.A := EMPTY;
         REPEAT
           IF K < KLN THEN
             BEGIN K := K+1; ID.A[K] := INPUT^
             END;
           ADVANCE
          UNTIL NOT(INPUT^ IN['A'..'Z','a'..'z','0'..'9','_','''']);
         CLASSIFY;
         IF KEYINDEX = 0 THEN
           BEGIN SEARCH;
             IF PROCORFUNC THEN NOTEPROC
           END
         ELSE
           (*IF  A RESERVED WORD THEN CHECK FOR NESTING LEVEL*)
           (*OR THE OCCURANCE OF A PROCEDURE OR FUNCTION*)
           IF (ID.A = PROCKEY) OR (ID.A = FUNCKEY) OR (ID.A = TASKKEY)
           OR (ID.A = USE_KEY)  OR (ID.A = WITH_KEY) OR (ID.A = PROCLOW)
           OR (ID.A = FUNCLOW) OR (ID.A = TASKLOW) OR (ID.A = USELOW)
           OR (ID.A = WITHLOW) THEN
             BEGIN PROCORFUNC := TRUE;
               IF NESTCOUNT > 1 THEN NESTCOUNT := NESTCOUNT + 1;
               NEST[NESTCOUNT] := -1
             END
           ELSE
             BEGIN IF (ID.A=BEGINKEY) OR (ID.A=BEGINLOW) THEN INBODY:=TRUE
               ELSE IF (ID.A=ACCEPT_KEY) OR (ID.A=ACCEPTLOW) THEN INBODY:=TRUE
               ELSE IF (ID.A=CASEKEY) OR (ID.A=CASELOW) THEN INBODY:=TRUE
               ELSE IF (ID.A=IFKEY) OR (ID.A=IFLOW) THEN INBODY:=TRUE
               ELSE IF (ID.A=LOOPKEY) OR (ID.A=LOOPLOW) THEN INBODY:=TRUE
               ELSE IF (ID.A=PACKKEY) OR (ID.A=PACKLOW) THEN INBODY:=TRUE
               ELSE IF (ID.A=RECKEY) OR (ID.A=RECLOW) THEN INBODY:=TRUE
               ELSE IF (ID.A=SELECT_KEY) OR (ID.A=SELECTLOW) THEN INBODY:=TRUE;
               IF INBODY THEN
                 BEGIN N := NESTING;
                   NESTING := NESTING + KEY[KEYINDEX].N;
                   IF NESTING <> N THEN
                     BEGIN IF NESTING < 0 THEN NESTING := 0;
                       NESTCOUNT := NESTCOUNT + 1;
                       IF NESTING > N THEN NEST[NESTCOUNT] := NESTING
                       ELSE
                         BEGIN NEST[NESTCOUNT] := N;
                           ADVANCE;
                           WHILE NOT(EOLN(INPUT)) DO
                            ADVANCE;
                        END
                     END
                 END
             END
       END;
   (* NUMBER *)
      '0','1','2','3','4','5','6','7','8','9':
         REPEAT ADVANCE;
       UNTIL NOT (INPUT^ IN ['A','B','C','D','E','F',
           '#','-','+','0'..'9','_']);
  (* STRING OR STRING LITERAL FUNCTION NAME *)
          '"':
    BEGIN
      IF PROCORFUNC THEN
        BEGIN (* STRING LITERAL FUNCTION NAME *)
          K:=0; ID.A:=EMPTY;
          QUOTECT:=1;
          REPEAT
            IF K<KLN THEN
              BEGIN K:=K+1;
                ID.A[K]:=INPUT^;
                ADVANCE;
                IF INPUT^='"' THEN
                  QUOTECT:=QUOTECT+1;
              END;
          UNTIL (QUOTECT MOD 2=0) AND (INPUT^<>'"');
                SEARCH;
                NOTEPROC
        END
      ELSE
        BEGIN
         REPEAT ADVANCE;
           UNTIL(INPUT^= '"') OR EOLN (INPUT);
         IF NOT EOLN(INPUT) THEN
           ADVANCE
        END
    END;
  (*CHARACTER LITERAL*)
     '''':
     BEGIN  ID.A:=EMPTY;
       FOR K:=1 TO 3 DO
          BEGIN
           ID.A[K]:=INPUT^;
           ADVANCE;
          END;
        SEARCH;
     END;
  (*COMMENT*)
      '-':
      BEGIN ADVANCE;
        IF INPUT^='-' THEN
          BEGIN ADVANCE;
            WHILE NOT(EOLN(INPUT))DO
              ADVANCE;
          END;
        END;
  (*SPECIAL CHARACTER*)
       '%',
      '+','*','/',')','$','=',' ',',','.','[',']','(',
      '|',':','!','&','#','?','<','>','@','\','^',';':
      ADVANCE
     END (*CASE*) ;
  (*OUTPUT NESTING LEVEL*)
    IF (LLOUT = LLOUTMAX) AND (NESTCOUNT > 1) THEN
       BEGIN
         IF CCOUNT >= 100 THEN WRITE('  ')
         ELSE WRITE(' ':100-CCOUNT);
         NLAST := NEST[1];
         IF NEST[1] = NEST[2] THEN WRITE(' ');
         FOR I := 2 TO NESTCOUNT DO
           BEGIN N := NEST[I];
             IF N < 0 THEN WRITE(' . ')
             ELSE
               BEGIN
                 IF N > NLAST THEN WRITE('[');
                 IF (N <> NLAST) OR (I = 2) OR (N = 0) THEN
                   IF N > 0 THEN WRITE(N:1)
                   ELSE WRITE('*');
                 IF N <= NLAST THEN WRITE(']')
               END;
             NLAST := N
           END
       END;
     WRITELN; READLN
   END ;
 END (*SCANANDLISTINPUT*) ;




 BEGIN (*CROSSREF*)
   IF NOT EOF(INPUT) THEN
   BEGIN LINELIMIT(OUTPUT, MAXN); INITIALIZE;
     SCANANDLISTINPUT; LINELIMIT(OUTPUT, MAXN);
     IF NOT PAGINATING THEN
       BEGIN PAGINATING := TRUE; M := LPPG END;
     PRINTTABLE; PRINTPROCS
   END ELSE WRITELN(STARS,' NO PROGRAM FOUND TO CROSS REFERENCE',STARS);
 99:END .