T/%CHARCODE/ R/ISO/EBCDIC/
T/%RANGE/ T+1
I$%DIAGLINEMAP=NO
%DIAGNAMETABLE=NO
$
T/(*#/ P+1
T/PROGRAM/ A/CO/MPILE/ P./ ;/
T/CONST/
TS/WITHTITLE/ PS/PAGEWIDTH/
T/ALFA16/ I/   /
TS/ORDLARGESTCHAR/ R/127/255/ R/ISO/EBCDIC/
T/TYPE/
TS/VADDRESS/ T+1 I/   TEXTPT = @TEXT ;///
TS/PROFILE,/ A/TRACE,/ NOCODEGEN,/
TS/BOOLOPT/
A/;/      (* ) THESE DEFINITIONS APPLY ONLY TO    *)/ T+1
  A/;/    (* ) OPTIONS FOR WHICH PASCAL-SPECIFIC  *)/
T+1 A/;/  (* ) DIRECTIVES ARE AVAILABLE.          *)/
T+1 I/   ALIENBOOLOPTIONTYPE = NOCODEGEN..NOCODEGEN;///
TS/OPTIONSCOPE =/ T+1
I$   DELAYEDLISTINGOPTIONREC =
      RECORD
      CASE OPTION : OPTIONTYPE OF
         MARGIN : (NEWMARGIN : INTEGER);
         TITLE : (NEWTITLE : ALFA);
         NEWPAGE : ()
         (* - NO OTHER OPTION VALUES ARE RELEVANT *)
      END;
$
TS/(*/ A/SOURCE/ & LISTING/
TS/SOURCESTATUS/
I/   EXTERNSOURCESTATUS = (BUFOK, BUFTRUNCATED, BUFTOBEIGNORED,
                         BUFTOBELISTEDONLY, BUFABSENTATEOF);
/
A/(//P./);/I/LINEISABSENT, LINEISTOBEIGNORED, LINEISTOBELISTEDONLY,
                   LINEISBLANK, LINEISNORMAL, LINEISPASCALDIRECTIVE/ T+1
I/   SOURCELINEBUF = PACKED ARRAY [LINEPOSITION] OF CHAR ;///
TS/LINE :/ B/ARRAY// P./ ;/ I/SOURCELINEBUF/
TS/STATUS :/ P+1
TS/LINETOOLONG :/ PS/ERRINX :/
I/                   CHARNUMBER : LINEPOSITION;
                      (*-USED IN ERROR HANDLER*)
                   LINEOVERFLOW, MARGINOVERFLOW : BOOLEAN;
                   OVERFLOWMAX : LINEPOSITION;
                      (*-DEFINED ONLY IF "MARGINOVERFLOW" IS TRUE*)
                   DONEPREMATURELISTING,
                   NEWHEADINGPENDING,
                   DELAYEDOPTIONPENDING : BOOLEAN;
/
TS/END/ A/END/;/ T+1
I/                   CASE STATUS : SOURCESTATUS OF
                      LINEISABSENT,
                      LINEISTOBEIGNORED,
                      LINEISTOBELISTEDONLY,
                      LINEISBLANK:
                         ();
                      LINEISNORMAL,
                      LINEISPASCALDIRECTIVE:
                          (FIRSTNONBLANK, LASTNONBLANK: LINEPOSITION)
/
TS/ERRINXTYPE/
I/   LISTPAGEHEADINGKIND = (SOURCEHEADING, PROGOBJECTHEADING,
                          PROCOBJECTHEADING,FUNCOBJECTHEADING);
   LISTINGSTATUS = (LISTINGYETTOSTART, SOURCELS, OBJECTLS, SUMMARYLS);
   LISTINGCONTROLREC =
      RECORD
         SOURCETITLE : ALFA;
         STATUS : LISTINGSTATUS
      END;
/
TS/COMMA,/ A/PERIOD/,DOTDOTSY/
TS/IDCLASS =/ T+1 I/   BLOCKIDCLASS = PROC..PROG ;///
T/VAR/
TS/(*/ A/SOURCE/ & LISTING/
TS/LINESLEFTONPAGE :/
I/   LISTINGP : TEXTPT;
   LISTINGCONTROL : LISTINGCONTROLREC;
/
PS/STARTCLOCK/ T+1 P+1
TS/LINESTART :/ *2(R/0/1/, R/999/99/, T+1)
TS/ALLGLOBALOPTIONS :/ D/     / T+1
I$   DELAYEDOPTIONINFO : DELAYEDLISTINGOPTIONREC;
$
T/(*----    EXTERNAL SUPPORT/ P+5
I$(*----    EXTERNAL COMPILATION SUPPORT INTERFACE    ----*)
(*        --------------------------------------        *)
  
   (* -IN "CTSYSIF" MODULE -INTERFACE TO ICL CE AND EDINBURGH C-T     *)
   (* ROUTINES -FACILITIES FOR JCL OPTIONS COMMUNICATION, SOURCE      *)
   (* INPUT, LISTING FILE ACCESS AND PAGE HEADING SPECIFICATION,      *)
   (* OBJECT CODE LISTING, COMPILATION ERROR NOTIFICATION, OBJECT     *)
   (* MODULE GENERATION (-THE OLD "LPUT INTERFACE")                   *)
$
TC/P79GIVE/ R/P79/ICL9LPCT/ T+1 I/     / T+1 P+1 T+1 P+1
TC/P79LIST/
I$PROCEDURE ICL9LPCTNEXTSOURCELINE (VAR LINE : SOURCELINEBUF;
                                  VAR LENGTH : LINEPOSITION;
                                  VAR STATUS : EXTERNSOURCESTATUS) ;
   EXTERN ;
  
PROCEDURE ICL9LPCTGETLISTFILEPTR (VAR LISTFILEP : TEXTPT) ;
   EXTERN ;
  
PROCEDURE ICL9LPCTUPDATELISTHEADING (KIND : LISTPAGEHEADINGKIND;
                                     VARIABLEPART : ALFA) ;
   EXTERN ;
    
PROCEDURE ICL9LPCTSUMMARYHEADING (MINLINECOUNT : POSITIVEINTEGER;
                                  THROWPAGE : BOOLEAN) ;
   EXTERN ;
 
$
R/P79LISTPLICODE/ICL9LPCTPLILIST/ *2(T+1, I/ /)
T+1 P+1 T+1 P+1 T/PROC/
I$PROCEDURE ICL9LPNOTECOMPILEERRORS (ERRORCOUNT : POSITIVEINTEGER) ;
   EXTERN ;
   
$
R/P79STARTGENOBJMODULE/ICL9LPOMGINIT/ T+1 P+1 T+1 P+1
TC/P79FINISH/ R/P79FINISHGENOBJMODULE/ICL9LPOMGFINISH/ A/(// P+1 P./STD/
T+1 D/    / T+1 P+1 T+1 P+1
T/PROC/ R/P79NOTEMAINENTRY/ICL9LPOMGMNENTRY/ T+2 P+1 T+1 P+1
T/PROC/ R/P79NOTE/ICL9LPOMG/ T+1 I/  / T+1 P+1 T+1 P+1
T/PROC/ R/P79NOTE/ICL9LPOMG/ T+1 I/  / T+1 P+1 T+1 P+1
T/PROC/ R/P79RELOCATEDAREAREF/ICL9LPOMGRELOC/ *2(T+1,D/     /) T+1 P+1 T+1 P+1
T/PROC/ R/P79NOTENAMEDAREA/ICL9LPOMGAREANAM/ T+3 P+1 T+1 P+1
T/PROC/ R/P79COPYINTOAREA/ICL9LPOMGCOPY/ *3(T+1,D/  /) T+1 P+1 T+1 P+1
*2 (TC/P77CTERROR/, R/P77/ICL9LP/, T+1)
T/%KEYEDENTRY OFF/ T/*)/ T+3
I/PROCEDURE NOTECOMPILATIONERRORCOUNT;
   BEGIN
      ICL9LPNOTECOMPILEERRORS(ERRORCOUNT);
   END (* NOTECOMPILATIONERRORCOUNT *);
   
/
T/PROCEDURE PUTMAPBYTE /
TS/P79/ R/P79COPYINTOAREA/ICL9LPOMGCOPY/
TS/WRITELN/ A/(/LISTINGP@, /
T/PROCEDURE MARKFLOWPOINT /
TS/IF COUNTREQD/ B/COUNT/CODEISTOBEGENERATED AND /
T/PROCEDURE MARKBREAK/
TS/IF COUNTREQD/ B/COUNT/CODEISTOBEGENERATED AND /
T/PROCEDURE PRESERVETOKEN;/
TS/COMMA,/ A/PERIOD/,DOTDOTSY/
T/PROCEDURE PUTOBJECT /
TS/P79/ R/P79COPYINTOAREA/ICL9LPOMGCOPY/ T+1 D/  /
TS/WRITE/ A/(/LISTINGP@, /
*2(TS/WRITE/,A/(/LISTINGP@, /,A/',//,K21,T+1)
*3(TS/WRITE/,A/(/LISTINGP@, /,T+1)
TS/WRITELN/ A/WRITELN/LISTINGP@)/
T/PROCEDURE ENDDIAGNOSTICS /
TS/END;/ P+1 *3(I/   /,T+1) I/      END;///
T/PROCEDURE REINSTATECODEGENERATION /
TS/CODEIS/ A/:=// P.E T+1
I/         NOT (REQD[NOCODEGEN] OR BADGENERATEDCODE) ;///
TS/P79COPY/ R/P79COPYINTOAREA/ICL9LPOMGCOPY/ T+1 D/  /
TS/P79NOTEMAIN/ R/P79NOTEMAIN/ICL9LPOMGMN/
TS/P79NOTEENTRY/ R/P79NOTE/ICL9LPOMG/
TS/P79NOTEEXT/ R/P79NOTE/ICL9LPOMG/
TC/P79RELOC/ R/P79RELOCATEDAREAREF/ICL9LPOMGRELOC/
TS/P79COPY/ R/P79COPYINTOAREA/ICL9LPOMGCOPY/ *4(T+1,D/  /)
T/PROCEDURE INITOBJECTMODULEGEN /
TS/GLOBALSIZE/
I/      IF CODEISTOBEGENERATED THEN
      BEGIN
/
-S/P79START/(I/   /,T+1)
I/   / R/P79STARTGENOBJMODULE/ICL9LPOMGINIT/ T+1
I/      END;
/
TS/GLOBALSIZE :=/
I/      IF CODEISTOBEGENERATED THEN
      BEGIN
/
-S/P79NOTENAMED/(I/   /,T+1)
I/   / R/P79NOTENAMEDAREA/ICL9LPOMGAREANAM/ T+1
-S/P79FINISHGEN/(I/   /,T+1)
I/   / R/P79FINISHGENOBJMODULE/ICL9LPOMGFINISH/
D/ERRORCOUNT, / T+1 I/     END;///
*2 (TS/P79COPY/, R/P79COPYINTOAREA/ICL9LPOMGCOPY/, T+1, D/  /)
*2 (TS/P79RELOC/, R/P79RELOCATEDAREAREF/ICL9LPOMGRELOC/, T+1, D/     /)
TS/P79LISTPLI/ R/P79LISTPLICODE/ICL9LPCTPLILIST/ T+1 I/ /
T/PROCEDURE OPENSTATEMENT /
TS/CLEARPENDING/
B/CLEAR/IF CODEISTOBEGENERATED THEN /
T/PROCEDURE CLOSSTATEMENT /
TS/CLEARPENDING/
B/CLEAR/IF CODEISTOBEGENERATED THEN /
T/PROCEDURE SETCHARSET /
TS/MAX := 64/ R/64/63/
T/PROCEDURE SETBOOLEAN/
I$PROCEDURE INITDELAYEDLISTINGOPTION (THISOPTION : OPTIONTYPE);
 
   BEGIN
   SOURCE.DELAYEDOPTIONPENDING := TRUE;
   DELAYEDOPTIONINFO.OPTION := THISOPTION;
   END (* INITDELAYEDLISTINGOPTION *) ;
 
$
T/PROCEDURE SETINTEGEROPTION /
TS/CHARCODE:/ A/:// P.E T+1
I$         BEGIN
         SETCHARSET(OPTIONVALUE);
         PARMVALUE[CHARCODE] := OPTIONVALUE;
         END;
      MARGIN:
         BEGIN
         IF OPTIONVALUE>MAXMARGIN THEN
$
PS/BEGIN/ -C/(*CASE*)/ (*6(D/ /), T+1)
I$         INITDELAYEDLISTINGOPTION(MARGIN);
            DELAYEDOPTIONINFO.NEWMARGIN := OPTIONVALUE;
         END;
$
T/PROCEDURE STARTNEWPAGE / P+3
TS/BEGIN (*SETSTRINGOPTION/ TS/TITLE:/ TS/STRINGTO/  PS/END;/
I/         INITDELAYEDLISTINGOPTION(TITLE);
         STRINGTOALFA(DELAYEDOPTIONINFO.NEWTITLE);
/
TS/FIRSTOPTION :/ T+1
I$      OBJCODEOPTIONS, DIAGOPTIONS : SETOFOPTIONS;
$
TS/PROCEDURE WRITEOPTION /
*5(TC/WRITE(/,A/WRITE(/LISTINGP@, /,T+1)
TS/BEGIN (*PRINT/ T+1 PS/END (* PRINT/
I$   OBJCODEOPTIONS := [CHECKS, COMPILER, CHARCODE];
   DIAGOPTIONS := [LINEMAP, DUMP, PROFILE..TRACE];
   FIRSTOPTION := TRUE;
   WRITE(LISTINGP@, 'OBJECT CODE OPTIONS = ':25, '(');
   FOR OPTION := CHECKS TO TRACE DO
      IF (OPTION IN OBJCODEOPTIONS) AND REQD[OPTION] THEN WRITEOPTION(OPTION);
   WRITEOPTION(CHARCODE);   WRITELN(LISTINGP@, ')');
   WRITE(LISTINGP@, 'DIAGNOSTICS OPTIONS = ':25);
   IF DIAGOPTIONS*OPTIONSCHOSEN=[] THEN
      WRITELN(LISTINGP@, 'NONE')
   ELSE
      BEGIN
      WRITE(LISTINGP@, '(');
      FIRSTOPTION := TRUE;
      FOR OPTION := CHECKS TO TRACE DO
         IF (OPTION IN DIAGOPTIONS) AND REQD[OPTION] THEN WRITEOPTION(OPTION);
      WRITELN(LISTINGP@, ')');
      END;
$
T/PROCEDURE INITOPTIONS / TC/CHARCODE/
I/   OPTIONNAME[NOCODEGEN] := BLANKALFA16;   (*-NO DIRECTIVE FOR THIS OPTION*)
/
TS/ALLGLOBAL/ A/-// K23 A/,/ NOCODEGEN,/
TS/P79GIVE/ R/P79/ICL9LPCT/
TS/END (* INIT/
I$   REQD[NOCODEGEN] := NOCODEGEN IN OPTIONSCHOSEN;
   IF REQD[NOCODEGEN] THEN CODEISTOBEGENERATED:=FALSE;
$
T/PROCEDURE ENDLISTING;/ I////
T/PROCEDURE READNEXTLINE/ T+1 PS/END (* READNEXTLINE/ I$
   VAR
      RAWSTATUS : EXTERNSOURCESTATUS;
      GOTSIGCHAR : BOOLEAN;
      LENGTH, FIRSTSIGPOS, LASTSIGPOS : LINEPOSITION;
   
   PROCEDURE EARLYEOFERRORSTOP;
      BEGIN
      ERROR(90);
      ENDPROGRAMLISTING;
      ENDLISTING;
      NOTECOMPILATIONERRORCOUNT;
      HALT('PREMATURE END OF SOURCE TEXT');
      END (*EARLYEOFERRORSTOP*);
   
   BEGIN (* READNEXTLINE *)
   WITH SOURCE DO
      BEGIN
      ICL9LPCTNEXTSOURCELINE (LINE, LENGTH, RAWSTATUS);
         (*-N.B.: DEFINITION OF TYPE FOR "LENGTH" MEANS THAT THIS*)
         (*CALL NEVER USES/FILLS THE LAST POSITION IN "LINE".     *)
      IF RAWSTATUS<>BUFABSENTATEOF THEN LINENUMBER:=LINENUMBER+1;
      (*NOTECODEOFFSET(LINENUMBER);*)
      CHARNUMBER := 0;
      LINEOVERFLOW := (RAWSTATUS=BUFTRUNCATED);
      MARGINOVERFLOW := FALSE;
      CASE RAWSTATUS OF
         BUFABSENTATEOF:
            BEGIN
            STATUS := LINEISABSENT;
            EARLYEOFERRORSTOP;
            END;
         BUFTOBELISTEDONLY:
            STATUS := LINEISTOBELISTEDONLY;
         BUFTOBEIGNORED:
            STATUS := LINEISTOBEIGNORED;
         BUFTRUNCATED,
         BUFOK:
            BEGIN
            LINE[LENGTH] := '*';   (*-ANY NON-BLANK*)
            FIRSTSIGPOS := 0;   GOTSIGCHAR := FALSE;
            WHILE NOT GOTSIGCHAR DO
               IF LINE[FIRSTSIGPOS]=BLANK THEN
                  FIRSTSIGPOS := FIRSTSIGPOS + 1
               ELSE
                  GOTSIGCHAR := TRUE;
            LASTSIGPOS := LENGTH;
            IF FIRSTSIGPOS<LENGTH THEN
               BEGIN
               REPEAT LASTSIGPOS:=LASTSIGPOS-1 UNTIL LINE[LASTSIGPOS]<>BLANK;
               IF LASTSIGPOS>=PARMVALUE[MARGIN] THEN
                  BEGIN
                  MARGINOVERFLOW := TRUE;
                  OVERFLOWMAX := LASTSIGPOS;
                  END;
               END;
             IF (FIRSTSIGPOS=LENGTH) OR (FIRSTSIGPOS>=PARMVALUE[MARGIN]) THEN
                STATUS := LINEISBLANK
             ELSE
                BEGIN
                IF LINE[0] = '%' THEN
                   STATUS := LINEISPASCALDIRECTIVE
                ELSE
                   STATUS := LINEISNORMAL;
                FIRSTNONBLANK := FIRSTSIGPOS;
                IF MARGINOVERFLOW THEN
                   BEGIN
                   LASTSIGPOS := PARMVALUE[MARGIN];
                   REPEAT LASTSIGPOS:=LASTSIGPOS-1 UNTIL LINE[LASTSIGPOS]<>BLANK;
                   END;
                LASTNONBLANK := LASTSIGPOS;
                END;
            END;
         END (*CASE*);
      END (*WITH*);
$
T/PROCEDURE STARTNEWPAGE;/
P/PROCEDURE NEWLINE;/ TS/WRITELN;/ B/;/(LISTINGP@)/ T+1 PS/END (* NEW/
T/PROCEDURE LISTTHISLINE ;/
I$PROCEDURE STARTSOURCEHEADING;
   FORWARD;
 
$
TS/NEXTPRINTPOS/ R/LINEPOSITION/POSITIVEINTEGER/
TC/STARTERRORLINE/ *4(TC/WRITE(/,A/WRITE(/LISTINGP@, /,T+1)
TS/END (* PRINTCOMMA/ T+1 I$
      FUNCTION ROOMFORANOTHERNUMBER : BOOLEAN;
         BEGIN
         ROOMFORANOTHERNUMBER := (NEXTPRINTPOSITION<=MAXMARGIN);
         END (*ROOMFORANOTHERNUMBER*);
$
TS/IF ERRORPOS/ B/E/(/ R/ = /=/ R/ THEN/) AND/ T+1 P-1 R/IF /   /
P./ THEN/ I/ROOMFORANOTHERNUMBER/
TS/WRITE(/ A/(/LISTINGP@,/ P.E T+1 P-1 R/WRITE(/      /
TS/NEWLINE/ P+1
T/   BEGIN/
I$   PROCEDURE CHECKLINEOVERFLOW;
      BEGIN
      IF SOURCE.LINEOVERFLOW THEN
         BEGIN
         SOURCE.CHARNUMBER := MAXMARGIN;
         ERROR(LONGLINEERROR);
         END;
      END (*CHECKLINEOVERFLOW*);
   
   PROCEDURE STARTSOURCELISTLINE;
      BEGIN
      WITH SOURCE DO
         BEGIN
         IF NEWHEADINGPENDING THEN
            BEGIN
            STARTSOURCEHEADING;
            NEWHEADINGPENDING := FALSE;
            END;
         WRITE(LISTINGP@, LINENUMBER:5, BLANK:2, MODES:5);
         WITH NESTINGLEVEL DO
            IF LINESTART<>CURRENT THEN
               IF LINESTART<CURRENT THEN
                  WRITE(LISTINGP@, BLANK:3, LINESTART:2, 'B', BAR:2)
               ELSE
                  WRITE(LISTINGP@, BLANK:3, CURRENT:2, 'E', BAR:2)
            ELSE
               WRITE(LISTINGP@, BLANK:6, BAR:2);
         END;
      END (*STARTSOURCELISTLINE*);
   
   PROCEDURE LISTMARGINOVERFLOW;
      VAR
         I, FILL: LINEPOSITION;
      BEGIN
      WITH SOURCE DO
         BEGIN
         IF STATUS=LINEISBLANK THEN
            FILL := PARMVALUE[MARGIN]
         ELSE (*NORMAL OR DIRECTIVE*)
            FILL := PARMVALUE[MARGIN] - 1 - LASTNONBLANK;
         IF FILL>0 THEN WRITE(LISTINGP@, BLANK:FILL);
         WRITE(LISTINGP@, BAR);
         FOR I := PARMVALUE[MARGIN] TO OVERFLOWMAX DO
            WRITE(LISTINGP@, LINE[I]);
         WRITE(LISTINGP@, BAR, '**':PAGEWIDTH-LEFTSPACE-2-(OVERFLOWMAX+1));
         END;
      END (*LISTMARGINOVERFLOW*);
      
   PROCEDURE UPDATEDELAYEDLISTINGOPTION;
      BEGIN
      WITH DELAYEDOPTIONINFO DO
         CASE OPTION OF
            MARGIN : PARMVALUE[MARGIN] := NEWMARGIN;
            NEWPAGE : IF LOCALLYREQD[SOURCELIST] THEN PAGE(LISTINGP@);
            TITLE : BEGIN
                    SOURCE.NEWHEADINGPENDING := TRUE;
                    LISTINGCONTROL.SOURCETITLE := NEWTITLE;
                    END;
            END (*CASE*);
      SOURCE.DELAYEDOPTIONPENDING := FALSE;
      END (*UPDATEDELAYEDLISTINGOPTION*);
 
$
TS/WITH SOURCE/ T+1 PS/END (* LISTTHISLINE/
I$         CASE STATUS OF
            LINEISABSENT,
            LINEISTOBEIGNORED:
               ;
            LINEISTOBELISTEDONLY:
               BEGIN
               STARTSOURCELISTLINE;
               FOR I := 0 TO MAXMARGIN-1 DO WRITE(LISTINGP@, LINE[I]);
               NEWLINE;
               END;
            LINEISBLANK,
            LINEISNORMAL,
            LINEISPASCALDIRECTIVE:
               BEGIN
               CHECKLINEOVERFLOW;
               IF LOCALLYREQD[SOURCELIST] OR (ERRINX>0) THEN
                  BEGIN
                  STARTSOURCELISTLINE;
                  IF STATUS<>LINEISBLANK THEN
                     BEGIN
                     IF FIRSTNONBLANK>0 THEN
                        WRITE(LISTINGP@, BLANK:FIRSTNONBLANK);
                     FOR I:=FIRSTNONBLANK TO LASTNONBLANK DO
                        WRITE(LISTINGP@, LINE[I]);
                     END;
                  IF MARGINOVERFLOW THEN
                     BEGIN
                     ASUFFIXWASIGNORED := TRUE;
                     LISTMARGINOVERFLOW;
                     END;
                  IF ERRINX>0 THEN LISTERRORS;
                  NEWLINE;
                  END;
               IF DELAYEDOPTIONPENDING THEN
                  UPDATEDELAYEDLISTINGOPTION;
               WITH NESTINGLEVEL DO LINESTART :=CURRENT;
               END;
            END (*CASE*);
      END (*ELSE*);
$
T/PROCEDURE FIRSTCHOFNEXTLINE /
TS/WHILE/ B/(// P./ DO/ I/STATUS<>LINEISNORMAL/
TS/IF/ B/(// P./ THEN/ I/STATUS=LINEISPASCALDIRECTIVE/
T/PROCEDURE INITLISTING /
I$PROCEDURE STARTSOURCEHEADING;   (*FORWARD-DECLARED*)
   BEGIN
   WITH LISTINGCONTROL DO
      BEGIN
      STATUS := SOURCELS;
      ICL9LPCTUPDATELISTHEADING(SOURCEHEADING, SOURCETITLE);
      END;
   END (*STARTSOURCEHEADING*);
 
PROCEDURE STARTOBJECTHEADING (CLASS : BLOCKIDCLASS; NAME : ALFA);
   VAR
      KIND : LISTPAGEHEADINGKIND;
   BEGIN
   LISTINGCONTROL.STATUS := OBJECTLS;
   CASE CLASS OF
      PROC: KIND := PROCOBJECTHEADING;
      FUNC: KIND := FUNCOBJECTHEADING;
      PROG: KIND := PROGOBJECTHEADING;
      END (*CASE*);
   ICL9LPCTUPDATELISTHEADING(KIND,NAME);
   END (*SWITCHTOOBJECTLISTHEADING*);
  
PROCEDURE STARTSUMMARYHEADING (MINLINECOUNT : POSITIVEINTEGER;
                               TRYFORCURRENTPAGE : BOOLEAN);
   BEGIN
   LISTINGCONTROL.STATUS := SUMMARYLS;
   ICL9LPCTSUMMARYHEADING (MINLINECOUNT, NOT TRYFORCURRENTPAGE);
   END (*STARTSUMMARYHEADING*);
 
PROCEDURE INCREMENTNESTINGLEVEL;
   BEGIN
   WITH NESTINGLEVEL DO
      IF CURRENT < 99 THEN CURRENT:=CURRENT+1;
   END (* INCREMENTNESTINGLEVEL *);
 
PROCEDURE DECREMENTNESTINGLEVEL;
   BEGIN
   WITH NESTINGLEVEL DO
      IF CURRENT > 1 THEN CURRENT:=CURRENT-1;
   END (* DECREMENTNESTINGLEVEL *);
$
TS/WITH PAGEHEAD/ PS/ERRORCOUNT/
I$   ICL9LPCTGETLISTFILEPTR(LISTINGP);
   WITH LISTINGCONTROL DO
      BEGIN
      STATUS := LISTINGYETTOSTART;
      SOURCETITLE := BLANKALFA;
      END;
$
TC/MODES :=/ B/MODES// P.E
TS/ERRINX :=/
I$      NEWHEADINGPENDING := TRUE;
      DELAYEDOPTIONPENDING := FALSE;
$
T/PROCEDURE BLKENDLIST / TS/STARTNEW/ PS/LISTOBJCODE/
I$      WITH BLKID@ DO
         STARTOBJECTHEADING(KLASS,NAME);
$
T+1 P+1
I$      SOURCE.NEWHEADINGPENDING := TRUE;
$
T/PROCEDURE PRINTERROR/ TS/NEWLINE;/ P+1
TS/WRITE (/ A/(/LISTINGP@, / B/ERR/ / A/ARY/:-/
T+1 A/;// P.E
*2(TS/WRITE (/,A/(/LISTINGP@, /,T+1)
T/PROCEDURE ENDLIST/
TS/PROCEDURE PRINT/
I$   VAR
      MINLINESREQUIRED : POSITIVEINTEGER;
      NEEDOBJDETAILS : BOOLEAN;
 
$
*2 (TS/WRITE(/, A/(/LISTINGP@, /, T+1)
TS/WRITE/ A/(/LISTINGP@, / R/MAP=/LINEMAP=/
*2 (T+1, TS/WRITE(/, A/(/LISTINGP@, /)   R/DUMP=/NAMETABLE=/
*2 (T+1, TS/WRITE(/, A/(/LISTINGP@, /)   R/FLOW=/FLOWANALYSES=/
TS/WRITELN(/ A/(/LISTINGP@, / TS/WRITELN ;/ R/ ;/(LISTINGP@);/
TS/IF LINESLEFT/ P+1
I$   NEEDOBJDETAILS := (ERRORCOUNT=0) AND NOT REQD[NOCODEGEN];
   IF NEEDOBJDETAILS THEN
      MINLINESREQUIRED := 11
   ELSE IF ERRORCOUNT=0 THEN
      MINLINESREQUIRED := 4
   ELSE
      MINLINESREQUIRED := 7 ;
   STARTSUMMARYHEADING (MINLINESREQUIRED, LISTINGCONTROL.STATUS<>OBJECTLS);
$
A/   // P./WRITE(/ A/(/LISTINGP@, / T+1 A/THEN// P.E T+1
I$      WRITE(LISTINGP@, 'NO')
   ELSE
      WRITE(LISTINGP@, ERRORCOUNT:2);
$
A/(/LISTINGP@, / A/NEWLINE;/   NEWLINE;/
T+1 B/E// P./ THEN/ I/NEEDOBJDETAILS/
TS/WRITELN/ P+1 A/(/LISTINGP@, /
TS/WRITELN(/ A/(/LISTINGP@, / TS/WRITELN;/ R/WRITELN/NEWLINE/
*2(TS/WRITELN(/,A/(/LISTINGP@,/,K15,T+1)
TS/ELSE/ A/ELSE/ IF ERRORCOUNT<>0 THEN/
TS/WRITE(/ A/(/LISTINGP@, / T+1 TS/NEWLINE/ P+1
TS/WRITE(/ A/(/LISTINGP@, / B/**/   / T+1
A/IGNORED/ **/ T+1 P+1
TS/ENDCLOCK/ I/   NEWLINE;///
TS/WRITE(/ A/(/LISTINGP@, /
R/COMPILATION TIME/OCP TIME FOR COMPILER/
T/PROCEDURE ANALYSEDIRECTIVE / TS/MARGIN (*,/
I$         NOCODEGEN:
            (*-SHOULD NEVER GET HERE*);
     
$
TS/NEWPAGE:/ TS/STARTNEW/ P+1
I$            INITDELAYEDLISTINGOPTION(NEWPAGE);
$
TS/BEGIN (*ANA/ R/OPTION/DIRECTIVE/
T/PROCEDURE READSYMBOL ;/ TS/DIGIT :/ TS/THEN CH :=/ B/CH// P.E I/PREVCH/
TS/IF CH='E'/ R/CH='E'/(CH='E') OR (CH='e')/
TS/PERIOD :/ TC/COLON/ R/COLON/DOTDOTSY/
TS/LEFTPARENT :/ TS/THEN/ T+2 PC/GOTO 1/
I$               NEXTCH;
               REPEAT
                  WHILE (CH<>'*') AND (CH<>'}') DO NEXTCH;
                  IF CH='*' THEN NEXTCH;
               UNTIL (CH=')') OR (CH='}');
$
TS/LEFTCURLY/ T+2 PC/GOTO 1/
I$            NEXTCH;
            REPEAT
               WHILE (CH<>'*') AND (CH<>'}') DO NEXTCH;
               IF CH='*' THEN NEXTCH;
            UNTIL (CH='}') OR (CH=')');
$
TS/PROCEDURE SUBRNGE/ TS/ACCEPT(/ R/COLON/DOTDOTSY/
TS/BEGIN (* SIMPLETYPE/ TC/[COLON]/ R/COLON/DOTDOTSY/
TS/BEGIN (* TYP/ TS/RECORDSY :/ TS/WITH/ P+2 B/IN// P.E
I/INCREMENTNESTINGLEVEL;/ T+1 P-1
TS/WITH NEST/ P+2 B/ACC// P.E I/DECREMENTNESTINGLEVEL;/ T+1 P-1
TS/PROCEDURE FACTOR (/ TS/LEFTBRACKET :/ TC/,COLON/ R/COLON/DOTDOTSY/
TC/=COLON/ R/COLON/DOTDOTSY/
TS/PROCEDURE COMPOUNDSTATEMENT ;/ TS/WITH NEST/ P+2 B/ACC// P.E
I/DECREMENTNESTINGLEVEL;/ T+1 P-1
TS/PROCEDURE CASESTATEMENT ;/
TS/WITH NEST/ P+2 B/NEXT// P.E I/DECREMENTNESTINGLEVEL;/ T+1 P-1
TS/PROCEDURE REPEATSTATEMENT ;/
TS/WITH NEST/ P+2
TC/ERROR(53)/ A/)/;/ T+1 P-1 B/ELSE// P.E I/DECREMENTNESTINGLEVEL;/ T+1
TS/BEGIN (* STATEMENT/ TS/WITH NEST/ P+1
*3(TS/CURRENT :=/, B/C//, P./;/, I/INCREMENTNESTINGLEVEL/, T+1)
TS/BEGIN (* BODY/ TS/WITH NEST/ P+2 
B/IN// P.E I/INCREMENTNESTINGLEVEL;/ T+1 P-1
TS/WITH NEST/ P+2 B/IN// P.E I/DECREMENTNESTINGLEVEL;/ T+1 P-1
TS/BEGIN (* PROGRAMME/ TS/IF SYMBOL/
I/      CHECKNEXTORCONTEXT ([PROGRAMSY], BLOCKBEGSYS);///
T/      END/ A/END/;/ T+1 PS/OPENSCOPE/
T/END ./
I$   NOTECOMPILATIONERRORCOUNT;
$
TELE