*DECK     INCLGEN 
(*$A+,U+,L'INCLUDE/ERROR DECK PRE-PROCESSOR.'*) 
  
  
PROGRAM INCLUDE(INPUT,LGO,OUTPUT);
  
(*  INCLUDE - PASCAL-6000 INCLUDE/ERROR DECK PRE-PROCESSOR. 
 *  J. P. STRAIT.      1978-07-22.
 *  D. J. BIANCHI.     1982-09-15.
 *
 *  CREATE INCLUDE COMPATIBLE FILE ON LGO FROM COMPILE FORMAT 
 *  FILE ON INPUT:  
 *     1. STRIP SEQUENCING INFORMATION PAST COLUMN 72.
 *     2. TREAT LINES WITH AN ASTERISK IN COLUMN 1 AS INCLUDE 
 *        LEVEL COMMENTS (THEY ARE NOT COPIED TO LGO).
 *     3. LINES WITH AN ASTERISK IN COLUMN 1 FOLLOWED BY
 *        ALPHABETIC CHARACTER DEFINE THE BEGINNING OF A NEW
 *        INCLUDE PACKAGE.  THE (AS MANY AS 7) NON-BLANK
 *        CHARACTERS FOLLOWING THE ASTERISK ARE TAKEN AS THE
 *        NAME OF THE INCLUDE PACKAGE.
 *     4. TREAT LINES WITH A PLUS IN COLUMN 1 AS THE
 *        CONTINUATION OF THE PREVIOUS LINE.
 *) 
  
  
CONST 
  MAXWIDTH = 72  (* WIDTH OF RECOGNIZED TEXT *);
  
  
TYPE
  LINEINDEX = 0 .. MAXWIDTH;
  NATURAL   = 0 .. MAXINT;
  
  
VAR 
  LGO : SEGMENTED TEXT  (* OUTPUT FILE FOR PROCESSED TEXT *); 
  
  COLUMN : LINEINDEX  (* CURRENT COLUMN IN LINE *); 
  BLANKS : NATURAL    (* NUMBER OF BLANKS READ  *); 
  
  FIRSTSEGMENT : BOOLEAN  (* TRUE IF FIRST SEGMENT BEING PROCESSED *);
  COPYINGLINE  : BOOLEAN  (* TRUE IF WRITE, BUT NOT WRITELN DONE   *);
  
  
  
  PROCEDURE SKIPBLANKS; 
  (* SKIP BLANKS, COUNT AS ONLY ONE BLANK *)
  
    BEGIN (* SKIPBLANKS *)
      WHILE NOT EOLN(INPUT) AND (INPUT^ = ' ') AND
            (COLUMN < MAXWIDTH) DO
        BEGIN  COLUMN := COLUMN + 1;  GET(INPUT)  END;
      BLANKS := 1 
    END (* SKIPBLANKS *); 
  
  
  
  PROCEDURE COPYRESTOFLINE; 
  (* COPY FROM CURRENT COLUMN TO MAXWIDTH OR EOLN *)
  
    VAR 
      I : NATURAL;
  
    BEGIN (* COPYRESTOFLINE *)
      WHILE NOT EOLN(INPUT) AND (COLUMN < MAXWIDTH) DO
        BEGIN 
          IF INPUT^ = ' ' THEN BLANKS := BLANKS + 1 
          ELSE
            BEGIN 
              FOR I := 1 TO BLANKS DO WRITE(LGO, ' ');
              BLANKS := 0;  LGO^ := INPUT^;  PUT(LGO) 
            END;
          COLUMN := COLUMN + 1;  GET(INPUT) 
        END 
    END (* COPYRESTOFLINE *); 
  
  
BEGIN (* INCLUDE *) 
  FIRSTSEGMENT := TRUE;  COPYINGLINE := FALSE;
  WHILE NOT EOF(INPUT) DO 
    BEGIN 
      IF INPUT^ = '*' THEN
        BEGIN 
          IF COPYINGLINE THEN WRITELN(LGO); 
          COPYINGLINE := FALSE; 
          GET(INPUT); 
          IF INPUT^ IN ['A'..'Z'] THEN
            BEGIN 
              IF NOT FIRSTSEGMENT THEN PUTSEG(LGO); 
              FIRSTSEGMENT := FALSE;  COLUMN := 0;
              WHILE (INPUT^ <> ' ') AND (COLUMN < 7) DO 
                BEGIN 
                  LGO^ := INPUT^;  COLUMN := COLUMN + 1;
                  PUT(LGO);  GET(INPUT) 
                END;
              WRITELN(LGO)
            END 
        END 
      ELSE
        IF INPUT^ = '+' THEN
          BEGIN 
            IF NOT COPYINGLINE THEN 
              HALT(' CONTINUATION OF NULL LINE'); 
            GET(INPUT);  COLUMN := 1;  BLANKS := 0; 
            SKIPBLANKS;  COPYRESTOFLINE 
          END 
        ELSE
          BEGIN COLUMN := 0;  BLANKS := 0;
            IF COPYINGLINE THEN WRITELN(LGO); 
            COPYINGLINE := TRUE;  COPYRESTOFLINE
          END;
      READLN(INPUT) 
    END;
  IF COPYINGLINE THEN WRITELN(LGO); 
  IF NOT FIRSTSEGMENT THEN PUTSEG(LGO)
END (* INCLUDE *).
