0101    	    THEN FLAG(32)	% NOPE. TOO BAD
0107    	    ELSE GETNEXT	% SCAN IT
0114    	    END;
0116 4  	  GO LDOT		% FINISH OFF THE PRIMARY
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76        PAGE 82


	IT WAS NECESSARY TO REDUCE THE SIZE OF THE LISTING FILE TO MAKE IT
	FIT ON A SINGLE DEC-TAPE. THIS WAS ONE OF THE PAGES THAT
	VOLUNTEERED TO GO.
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76        PAGE 83


0421    	  BLOK(0);	% FAKE A NEW BLOCK
0425    	  GO EXIT;
0427    24:	  BEGIN
0431 4  	    DEFINE SEGMENT = #;
   001155-P = B.0013
                                                  B.0013 IS SEGMENT 066 ********
0000    	    GETNEXT;
0005    	    IF CLASS = LFTPAREN
0006    	    THEN BEGIN
0012 5  	      GETNEXT;
0015    	      J:=6;	% COULD BE POINTER,REAL OR BOOLEAN
0020    	      IF NOT EACHCASE(J)% SEE WHICH
0023    	      THEN
0027    		IF J EQL 2	% POINTER
0031    		THEN
0034    		  IF CLASS NEQ COMMA	% FOLLOWED BY ',' ?
0035    		  THEN FLAG(37)
0043    		  ELSE BEGIN
0047 6  		    GETNEXT;	% REAL(<PE>,<AE>)
0052    		    AEXP;
0055    		    EMIT(PLOD)	% LOAD POINTER VALUE
0057    		    END;
0061 6  	      IF CLASS NEQ RTPAREN
0062    	      THEN ERROR(32)
0070    	      ELSE GETNEXT;
0077    	      GO LDOT;
0113    	      END;
0113 5  	    GO LB;
0127    	    END;
                             B.0013(066) IS 0140 LONG, NEXT SEGMENT 064 ********
0442 4  25:	  BEGIN
0444 4  	    DEFINE SEGMENT=#;
   001161-P = B.0014
                                                  B.0014 IS SEGMENT 067 ********
0000    	    GETNEXT;		% SCAN THE 'INTEGER'
0005    	    IF CLASS EQL LFTPAREN
0006    	    THEN BEGIN
0012 5  	      GETNEXT;		% SCAN THE '('
0015    	      J:=5;		% COULD BE REAL OR POINTER
0020    	      IF NOT EACHCASE(J)% NO ERRORS
0023    	      THEN BEGIN
0027 6  		IF J EQL 2	% POINTER
0031    		THEN BEGIN
0034 7  		  IF CLASS NEQ COMMA
0035    		  THEN FLAG(37) % COMMA EXPECTED
0043    		  ELSE BEGIN
0047 8  		    GETNEXT;	% SCAN THE ','
0052    		    AEXP;	% GET LENGTH
0055    		    EMITPAIR(3"13",COM)% CONVERT
0060    		    END
0062 8  		  END;
0062 7  		IF CLASS NEQ RTPAREN
0063    		THEN FLAG(32)	% ')' EXPECTED
0071    		ELSE GETNEXT
0076    		END
0100 6  	      END
0100 5  	    ELSE GO LB
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76        PAGE 84


0116    	    END
0116 4  	  END OF CASE;
                             B.0014(067) IS 0127 LONG, NEXT SEGMENT 064 ********
0511 3  LDOT:	IF CLASS = DOTOP THEN DOT;
0521    EXIT:	IF CLASS EQL EXPOP
0522    	THEN BEGIN
0526 3  	  GETNEXT;
0531    	  PRIMARY;
0534    	  EMIT(EXP)
0536    	  END;
0540 3  	IF CLASS EQL AMPER		% CONCAT !
0541    	THEN CONCAT(FALSE);		% FROM PRIMARY
0551    	END OF PRIMARY;
                            PRIMARY(064) IS 0552 LONG, NEXT SEGMENT 001 ********
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76        PAGE 85


0513 2  PROCEDURE TERM(B);
0513    	VALUE B;
0513    	BOOLEAN	B;
0513    	BEGIN
0513 2  	  INTEGER TIMES;
                                                    TERM IS SEGMENT 070 ********
   030005-S = TIMES
0002    	  IF B
0004    	  THEN PRIMARY;
0012    	  WHILE	CLASS IN OPS
0015    	  DO BEGIN
0017 3  	    TIMES:=REAL(CLASS EQL MULOP OR CLASS EQL FACTOP) +
0026    		2*REAL(CLASS EQL MODV)+3*REAL(CLASS EQL	DIVV);
0044    	    GETNEXT;
0047    	    PRIMARY;
0052    	    EMIT(CASE TIMES OF (DIVR,MUL,MD,DIVT))
0077    	    END
0101 3  	  END OF TERM;
                               TERM(070) IS 0104 LONG, NEXT SEGMENT 001 ********
0513 2  PROCEDURE ARITHSEC;
0513    	BEGIN
0513 2  	  BOOLEAN B;
                                                ARITHSEC IS SEGMENT 071 ********
   030005-S = B
0002    	  WHILE	CLASS EQL ADDOP	OR B:=CLASS EQL	SUBOP
0010    	  DO BEGIN		% SCAN WHILE ADDING OR SUBTRACTING
0017 3  	    GETNEXT;
0022    	    TERM(TRUE);
0026    	    EMIT(IF B THEN SUB ELSE ADD)	% SUB IT OR ADD	IT
0036    	    END
0040 3  	  END OF ARITHSEC;
                           ARITHSEC(071) IS 0043 LONG, NEXT SEGMENT 001 ********
0513 2  PROCEDURE AEXP;
0513    	BEGIN
0513 2  	  BOOLEAN B;
                                                    AEXP IS SEGMENT 072 ********
   030005-S = B
0002    	  INTEGER I:=REAL(CLASS EQL IFV);
   030006-S = I
0005    	  IF BOOLEAN(I)		% IF EXPRESSION
0010    	  THEN CASEORIF(I)
0014    	  ELSE BEGIN
0020 3  	    IF CLASS EQL ADDOP OR B:=CLASS EQL SUBOP
0024    	    THEN GETNEXT;
0036    	    TERM(TRUE);
0042    	    IF B		% WAS A	MINUS SIGHN
0042    	    THEN EMIT(CHS);	% SO CHANGE IT
0051    	    ARITHSEC
0052    	    END
0054 3  	  END OF AEXP;
                               AEXP(072) IS 0055 LONG, NEXT SEGMENT 001 ********
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76        PAGE 86


0513 2  PROCEDURE BOOPTRPRIM(X);	% PARSES BOOLEAN POINTER PRIMARYS
0513    	VALUE X;
0513    	BOOLEAN	X;
0513    	BEGIN
0513 2  	  BOOLEAN P1UP,P2UP,B,F,SPECIALCASE,S;
                                              BOOPTRPRIM IS SEGMENT 073 ********
   030005-S = P1UP
   030006-S = P2UP
   030007-S = B
   030010-S = F
   030011-S = SPECIALCASE
   030012-S = S
0003    	  INTEGER T,ROPV;
   030013-S = T
   030014-S = ROPV
0003    	  IF X			% SEE IF WE ARE	TO SCAN	THE 1ST	POINTER
0005    	  THEN BEGIN		% OR IF	IT WAS SCANNED FOR US (IF X TRUE)
0010 3  	    IF B:=CLASS	EQL STRINGID AND REAL(P,1) EQL ":"
0020    	    THEN BEGIN
0026 4  	      T:=INFO;
0031    	      GETNEXT;		% SEE IF : OR :=
0034    	      IF P1UP:=CLASS EQL COLON	% UPDATE OF 1ST	POINTER
0035    	      THEN EMITADDRESS(T,0);	% PUT IT'S ADDRESS OUT THERE
0050    	      GETNEXT		% SCAN THE ':' OR ':='
0051    	      END;
0053 4  	    PEXP;			% NOW A	POINTER	EXPRESSION
0056    	    IF B AND NOT P1UP	% OTHER	WAS AN ASSIGNMENT
0057    	    THEN BEGIN
0064 4  	      EMITADDRESS(T,0);	% ADDRESS OF POINTER IN	QUESTION
0071    	      EMIT(PSTN)		% STORE	AND LEAVE
0073    	      END
0075 4  	    END;
0075 3  	  IF ROPV:=CLASS LSS NEQOP OR CLASS GTR	LEQOP	% RELATIONAL OP	?
0103    	  THEN			% SEE IF 'IN' OR ERROR
0110    	    IF CLASS EQL INV AND NOT P1UP  % IN
0113    	    THEN BEGIN
0120 3  	      GETNEXT;		% SCAN IT
0123    	      IF CLASS NEQ TRUTHID	% SHOULD BE FOLLOWED BY	A TRUTHSET ID
0124    	      THEN FLAG(106)	% TELL THE GUY
0132    	      ELSE BEGIN
0136 4  		EMITL(3);	% LENGTH OF POINTER VALUE IS 3
0142    		EMIT(PLOD);	% LOAD POINTER VALUE
0146    		EMITADDRESS(INFO,0);	% ADDRESS OF TRUTHSET
0153    		EMIT(INOP);	% SEE IF IN !
0157    		GETNEXT		% SCAN THE TRUTHID
0160    		END
0162 4  	      END
0162 3  	    ELSE FLAG(114)
0166    	  ELSE BEGIN
0172 3  	    GETNEXT;		% SCAN IT
0175    	    IF B:=CLASS	EQL STRINGID AND REAL(P,1) EQL ":"
0205    	    THEN BEGIN		% COULD	BE ANOTHER UPDATE!
0213 4  	      T:=INFO;		% SAVE POINTER TO THIS ID
0216    	      GETNEXT;		% SEE IF ":" OR	":="
0221    	      IF P2UP:=CLASS EQL COLON	% ":". IE. AN UPDATE
0222    	      THEN BEGIN
0230 5  		EMITADDRESS(T,0);% ADDRESS OF POINTER
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76        PAGE 87


0235    		EMIT(RSDN)	% ROTATE STACK DOWN (POINTER ADDRESS PRIOR TO
0237    		END;		% POINTER EXPRESSION ON	TOS
0241 5  	      GETNEXT		% SCAN THE THINGIE
0242    	      END;
0244 4  	    IF B OR CLASS NEQ IFV AND CLASS NEQ	CASEV
0251    	    THEN
0257    	      IF S:=F:=CLASS EQL QUOTEOP AND NOT B
0262    	      THEN QUOTE	% RELATED TO A QUOTED STRING
0274    	      ELSE PEXP		% RELATED TO A POINTER EXPRESSION
0301    	    ELSE BEGIN		% FOR CASE OF IFS
0305 4  	      S:=SPECIALCASE:=BOOLEAN(T:=7);
0314    	      IF P2UP		% 2ND POINTER IS UPDATED
0314    	      THEN T:=2;	% SO CASE OR IF	MUST RETURN A POINTER
0322    	      CASEORIF(T);	% MUST BE SE OR	PE
0326    	      F:=T EQL 0	% SE (LENGTH ON	TOS)
0330    	      END;
0333 4  	    IF B AND NOT P2UP	% POINTER ASSIGNMENT
0334    	    THEN BEGIN
0341 4  	      EMITADDRESS(T,0);	% ADDRESS OF POINTER
0346    	      EMIT(PSTN)	% STORE	IT
0350    	      END;
0352 4  	    IF CLASS EQL FORV	% 'FOR'
0353    	    THEN BEGIN		% WOW
0357 4  	      IF F		% SE PREVIOUSLY
0357    	      THEN		% IN CASE OR IF?
0362    		IF SPECIALCASE	% YES
0362    		THEN EMIT(DEL);	% REMOVE OLD LENGTH
0371    	      F:=TRUE;		% SET COMPARE OPERATOR
0374    	      GETNEXT;		% GET TO START OF ARITHMETIC EXPRESSION
0377    	      AEXP		% GET LENGTH OF	COMPARISON
0400    	      END
0402 4  	    ELSE		% IF STRING
0402    	      IF F		% YES
0404    	      THEN EMITL(LENGTH);% PUT OUT THE LENGTH
0413    	    IF F		% COMPARISON OPERATOR
0413    	    THEN BEGIN
0416 4  	      EMITL(SHL(ROPV-NEQOP+2,8)+REAL(S AND TRUE) +
0432    			(REAL(P2UP)+REAL(P1UP)*2)*2);	% CODE FOR
0444    	      EMIT(CMP)		% COMPARE OPERATOR
0446    	      END
0450 4  	    ELSE		% SEE IF POINTER EQUALITY BEING	TESTED
0450    	      IF P1UP OR P2UP OR ROPV NEQ EQLOP	AND ROPV NEQ NEQOP
0461    	      THEN FLAG(115)
0471    	      ELSE BEGIN
0475 4  		EMIT(RSUP);	% GET BOTH INDEXES ON TOS
0501    		EMIT(T:=ROPV-NEQOP+NE);	% TYPE OF EQUALITY TEST
0513    		EMIT(RSDN);	% SAVE IT
0517    		EMIT(T);	% COMPARE THE ARRAY POINTERS
0523    		EMIT(IF	ROPV EQL EQLOP THEN LND	ELSE LOR)  % SEE THAT BOTH
0535    		END		% ARE GOOD !
0537 4  	    END
0537 3  	  END;
                         BOOPTRPRIM(073) IS 0540 LONG, NEXT SEGMENT 001 ********
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76        PAGE 88


0513 2  INTEGER	PROCEDURE BOOPRIM;
0513    	BEGIN
0513 2  	INTEGER	T;
                                                 BOOPRIM IS SEGMENT 074 ********
   030005-S = T
0002    	BOOLEAN	NOTTOG;
   030006-S = NOTTOG
0003    	LABEL LR,LE,L1,L2,L3,L4,L5,RP,L6,L7,L9,BXIT,EXIT,LB;
0003    	LABEL START,BDOT,CHECK;
0003    	SWITCH SW:=LE,L4,L2,L2,L4,L2,L2,L1,L2,L2,L2,L2,L2,L2,L9,
0043    		L9,L5,LE,LE,LE,LE,L6,L7,L2;
0065    START:	IF CLASS EQL FACTOP AND	ASTRISK
0072    	THEN BEGIN		% CODE ALREADY GENERATED BY VARIABLE
0076 3  	  ASTRISK:=FALSE;
0101    	  GETNEXT;		% SKAN TO THE NEXT TOKEN TO MAKE US HAPPY
0104    	  GO BXIT
0106    	  END;
0106 3  	ASTRISK:=FALSE;
0111    	IF CLASS EQL READV OR CLASS EQL	WRITEV	% I/O FUNCTION CALL
0115    	THEN BEGIN
0122 3  	  BOOLREADTOG:=TRUE;		% SET TOGGLE
0125    	  WRITESTMT;			% LET WRITE STATEMENT HANDLE IT
0130    	  GO BDOT END
0132 3  	ELSE
0132    	  IF CLASS EQL FILEID
0135    	  THEN
0141    	    IF FILEATTRIBUTES(FP,TRUE)
0145    	    THEN GO BDOT
0153    	    ELSE GO CHECK;
0155    	IF CLASS EQL STRINGID OR CLASS EQL POINTERV
0161    	THEN BEGIN
0166 3  	  BOOPTRPRIM(TRUE);
0172    	  GO BXIT
0174    	  END;
0174 3  	IF CLASS EQL CASEV	% BOOLEAN CASE EXPRESSION
0175    	THEN BEGIN			% BOOLEAN CASE EXPRESSION
0201 3  	  T:=6;			% COULD	BE POINTER OR BOOLEAN OR ARITHEMETIC
0204    	  CASEORIF(T);		% SEE WHAT WE GOTS
0210    	  IF T EQL 2			% IT WAS POINTER !
0212    	  THEN BOOPTRPRIM(FALSE);	% POINTER ALREADY SCANNED
0221    	  IF T EQL 1			% <ARITHMETIC>
0223    	  THEN GO CHECK
0230    	  ELSE GO BDOT			% COULD	BE BOOLEAN PARTIAL WORD
0232    	  END;
0232 3  	GO SW[CLASS];
0253    	IF CLASS EQL POLISHV
0254    	THEN BEGIN
0260 3  	  VARIABLE(FP);
0264    	  GO BDOT
0266    	  END;
0266 3  	IF CLASS GEQ SIGNV AND CLASS LEQ COMPILTIMEV OR CLASS	EQL VALUEV
0276    	THEN BEGIN
0303 3  	  AEXP;
0306    	  GO L3
0310    	  END;
0310 3  	IF CLASS = NOTV
0311    	THEN BEGIN
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76        PAGE 89


	IT WAS NECESSARY TO REDUCE THE SIZE OF THE LISTING FILE TO MAKE IT
	FIT ON A SINGLE DEC-TAPE. THIS WAS ONE OF THE PAGES THAT
	VOLUNTEERED TO GO.
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76        PAGE 90


0735    	IF CLASS EQL AMPER	% BOOLEAN CONCATENATION
0736    	THEN CONCAT(TRUE);
0746    	IF NOTTOG		% WE HAD A NOT
0746    	THEN EMIT(LNG);		% NOT BAD !
0755    EXIT:	END;
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76        PAGE 91


0755 2  %
                            BOOPRIM(074) IS 0756 LONG, NEXT SEGMENT 001 ********
0513    INTEGER	PROCEDURE BOOSEC;
0513    	BEGIN
0513 2  	  LABEL	EXIT,XIT;
                                                  BOOSEC IS SEGMENT 075 ********
0001    	  IF BOOLEAN(BOOPRIM)
0007    	  THEN
0011    	  ELSE GO XIT;
0013    	  WHILE	CLASS GTR ANDV
0014    	  DO BEGIN
0020 3  	    GETNEXT;
0023    	    IF NOT BOOLEAN(BOOPRIM)
0027    	    THEN ERROR(34);
0035    	    EMIT(LND)
0037    	    END;
0043 3  EXIT:	  BOOSEC:=1;
0046    XIT:	  END;
0046 2
                             BOOSEC(075) IS 0047 LONG, NEXT SEGMENT 001 ********
0513    INTEGER	PROCEDURE EXPRESS;
0513    	BEGIN
0513 2  	  INTEGER T:=6;
                                                 EXPRESS IS SEGMENT 076 ********
   030005-S = T
0002    	  IF CLASS = IFV	% IF EXPRESSION. BUT WHICH TYPE?
0005    	  THEN BEGIN	% COULD	BE POINTER, BOOLEAN OR ARITHMETIC
0011 3  	    CASEORIF(T);% SEE WHICH
0015    	    IF T LSS 2	% POINTER. MAKE	BOOLEAN	!
0017    	    THEN BOOPTRPRIM(FALSE);
0026    	    T:=REAL(T GEQ 2)	% SEE IF BOOLEAN (POINTER OR BOOLEAN) OR REAL
0031    	    END
0033 3  	  ELSE
0033    	    IF BOOLEAN(BOOSEC)
0043    	    THEN
0045    	      WHILE CLASS GTR ORV
0046    	      DO BEGIN
0052 3  		GETNEXT;	% SCAN THE 'OR'
0055    		IF NOT BOOLEAN(BOOSEC)
0063    		THEN ERROR(35)	% BOOLEAN EXPRESSION EXPECTED
0067    		ELSE EMIT(LOR)
0075    		END;
0101 3  	  EXPRESS:=T
0101    	  END OF EXPRESS;
0104 2
0104
                            EXPRESS(076) IS 0105 LONG, NEXT SEGMENT 001 ********
0513    PROCEDURE BEXP;
0513    	IF NOT BOOLEAN(EXPRESS)
                                                    BEXP IS SEGMENT 077 ********
0007    	THEN ERROR(34);
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76        PAGE 92


OMIT    @O
OMIT    <PEXP>::=	<SIMPLE	PE> ! <CONDITIONAL PE>
OMIT    <SIMPLE	PE>::=	<POINTER PRIMARY><SKIP>	!
OMIT    		<POINTER ASSIGNMENT>	!
OMIT    		<ARRAY PART>
OMIT    <CONDITIONAL PE>::= IF <BEXP> THEN <PEXP> ELSE <PEXP>
OMIT    <POINTER PRIMARY>::=	<POINTER ID>	!
OMIT    			( <PEXP> )	!
OMIT    			<POINTER CASE EXPRESSION>  !
OMIT    			POINTER	( <ARRAY PART> )
OMIT    <POINTER ASSIGNMENT>::=	<POINTER ID>:=	<PEXP>
OMIT    <SKIP>::=	<ADDING	OP><PRIMARY>
OMIT    <ADDING	OP>::=	+ ! -
OMIT    <ARRAY PART>::=	<ARRAY ROW DESIGNATOR>	!
OMIT    		<INDEXED ARRAY ROW DESIGNATOR>
0013    @O
                               BEXP(077) IS 0016 LONG, NEXT SEGMENT 001 ********
0513    PROCEDURE PEXP;			% PARSES POINTER EXPRESSIONS
0513    	BEGIN
0513 2  	  INTEGER TTL,TEL,I,RC;
                                                    PEXP IS SEGMENT 100 ********
   030005-S = TTL
   030006-S = TEL
   030007-S = I
   030010-S = RC
0003    	  BOOLEAN NNOT,PVF,OPT;
   030011-S = NNOT
   030012-S = PVF
   030013-S = OPT
0003    	  LABEL	EXIT;
0003    	  IF CLASS EQL FACTOP AND ASTRISK
0010    	  THEN BEGIN
0014 3  	    GETNEXT;		% SCAN THE ASTRISK
0017    	    ASTRISK:=FALSE	% RE-SET TOG
0020    	    END
0022 3  	  ELSE BEGIN
0024 3  	    ASTRISK:=FALSE;
0027    	    IF CLASS EQL CASEV OR PVF:=CLASS EQL IFV	% CASE OR IF EXPRESSIONS
0033    	    THEN BEGIN
0042 4  	      I:=2;		% MUST BE POINTER PRIMARY
0045    	      CASEORIF(I);	% GET IT !
0051    	      IF PVF		% IF EXPRESSIONS ARE FINISHED AT THIS POINT
0051    	      THEN GO EXIT	% BUT CASES CAN	CONTINUE
0056    	      END
0056 4  	    ELSE
0056    	      IF CLASS EQL STRINGID	% POINTER
0061    	      THEN BEGIN
0065 4  		VARIABLE(FP);		% FROM PRIMARY !
0071    		IF NOT PTRPRIM		% IF NOT A POINTER PRIMARY
0071    		THEN GO	EXIT		% THEN WE ARE DONE
0076    		END
0076 4  	      ELSE
0076    		IF CLASS EQL LFTPAREN	% (<PEXP>)
0101    		THEN BEGIN
0105 4  		  GETNEXT;		% SCAN THE '('
0110    		  PEXP;		%('<PEXP>'
0113    		  IF CLASS NEQ RTPAREN%(<PEXP>')'
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76        PAGE 93


0114    		  THEN FLAG(32)	% ')' EXPECTED
0122    		  ELSE GETNEXT;
0131    		  END
0131 4  		ELSE BEGIN		% [POINTER(]ROW-DESIGNATOR[)]
0133 4  		  IF PVF:=CLASS	EQL POINTERV	% POINTER VALUED FUNCTION
0134    		  THEN BEGIN
0142 5  		    GETNEXT;		% SCAN THE 'POINTER'
0145    		    IF CLASS NEQ LFTPAREN	% POINTER '('
0146    		    THEN FLAG(31)	% '(' EXPECTED
0154    		    ELSE GETNEXT
0161    		    END;
0163 5  		  GETROW(FALSE);	% GET ARRAY ROW	AND INDEX
0167    		  IF PVF		% POINTER VALUED FUNCTION
0167    		  THEN		% I.E. POINTER(ROW-DESIGNATOR)
0172    		    IF CLASS NEQ RTPAREN	% CHECK	FOR THE	')'
0173    		    THEN FLAG(32)	% ')' EXPECTED
0201    		    ELSE GETNEXT
0206    		  END
0210 4  	    END;
0210 3  	  IF CLASS EQL ADDOP OR	NNOT:=CLASS EQL	SUBOP	% ADDING OP
0214    	  THEN BEGIN
0223 3  	    GETNEXT;		% SCAN IT
0226    	    L:=L-REAL(EDOC[L] GEQ 0 AND EDOC[L-1] EQL 0 AND NOT NNOT);
0254    	    PRIMARY;		% DO A PRIMARY
0257    	    IF NOT OPT
0257    	    THEN EMIT(IF NNOT THEN SUB ELSE ADD)	% ADD OR SUB IT	FROM INDEX
0272    	    END;
0274 3  EXIT:	  END;
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76        PAGE 94


0274 2  %
0274    %	S T A T	E M E N	T---S C	A N N E	R S
0274    %
                               PEXP(100) IS 0275 LONG, NEXT SEGMENT 001 ********
0513    PROCEDURE COMPOUNDTAIL;
   001165-P = COMPOUNDTAIL
0513    	BEGIN
0513 2  	  LABEL	START;
                                            COMPOUNDTAIL IS SEGMENT 101 ********
0001    	  BEGINCTR:=BEGINCTR +	1;
0010    START:	  ERRORTOG:=TRUE;
0013    	  STMT;
0016    	  IF CLASS EQL SEMICOLON
0017    	  THEN BEGIN
0023 3  	    GETNEXT;		% SCAN THE ';'
0026    	    GO START		% GET NEXT STATEMENT
0030    	    END;
0030 3  	  IF CLASS NEQ ENDV	% NOT A	';'. IS	IT AN 'END' ?
0031    	  THEN BEGIN		% NO.
0035 3  	    ERROR(42);		% ERROR
0041    	    GO START
0043    	    END;
0043 3  	  BEGINCTR:=*-1;
0050    	  DO BEGIN
0050 3  	    STOPDEFINE:=TRUE;	% STOP EXPANSION OF DEFINES
0053    	    GETNEXT		% GET NEXT THING
0054    	    END
0056 3  	  UNTIL	CLASS GEQ ENDV AND CLASS LEQ UNTILV OR CLASS = DOTOP;
0073    	  IF BEGINCTR EQL 0	% HAS TO BE THIS WAY FOR SAKE OF LISTING!
0075    	  THEN
0100    	    IF FUNCTION
0100    	    THEN		% CHECK IS DONE IN PROCDEC.
0103    	    ELSE
0103    	      IF CLASS NEQ DOTOP
0104    	      THEN ERROR(53)	% FINAL END NOT FOLLOWED BY '.'
0112    	  END OF COMPOUND TAIL;
                       COMPOUNDTAIL(101) IS 0115 LONG, NEXT SEGMENT 001 ********
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76        PAGE 95


0513 2  PROCEDURE IFSTMT;
   001171-P = IFSTMT
0513    	BEGIN
0513 2  	  INTEGER THENL,ELSEL;
                                                  IFSTMT IS SEGMENT 102 ********
   030005-S = THENL
   030006-S = ELSEL
0003    	  BOOLEAN NOTTOG,THENTOG,B;
   030007-S = NOTTOG
   030010-S = THENTOG
   030011-S = B
0003    	  GETNEXT;
0010    	  BEXP;				% GET BOOLEAN EXPRESSION
0013    	  IF NOTTOG:=EDOC[L] GEQ 0 AND EDOC[L-1] EQL 1281+4*LNG
0027    	  THEN L:=L-1;			% OPTIMIZE OUT THE NOT'S
0045    	  THENL:=BUMPL;
0054    	  IF CLASS EQL THENV		% SEE IF 'THEN'	FOLLOWING BE
0055    	  THEN GETNEXT
0062    	  ELSE FLAG(39);
0072    	  STMT;				% GET THEN STATEMENT
0075    	  IF B:=THENTOG:=LASTWASAGOGO	% SEE IF LAST STMT WAS A GOTO
0075    	  THEN				% DON'T	EMIT A BRUN
0104    	  ELSE
0104    	    IF THENTOG:=L EQL THENL	% NULL STATEMENT, DON'T	EMIT A BRUN
0105    	    THEN NOTTOG:=NOT NOTTOG;	% EMIT BRANCH OTHER CONDITION
0117    	  ELSEL:=L;			% SAVE CURRENT PC IF NEED A JMP
0122    	  IF CLASS EQL ELSEV		% SEE IF AN ELSE PART
0123    	  THEN BEGIN
0127 3  	    GETNEXT;			% SCAN THE 'ELSE'
0132    	    IF NOT THENTOG		% SEE IF WE SHOULD EMIT	A BRUN
0132    	    THEN ELSEL:=BUMPL;		% YEP
0144    	    STMT;			% GET ELSE STATEMENT
0147    	    IF L EQL ELSEL AND NOT THENTOG % SEE IF A NULL STATEMENT
0152    					% BUT ELSE-STMT	NOT NULL
0152    	    THEN BEGIN			% YEP SO OPTIMIZE
0157 4  	      L:=L-3;			% FORGET THE BRUN
0164    	      THENTOG:=TRUE		% AND INDICATE SUCH
0165    	      END
0167 4  	    END
0167 3  	  ELSE THENTOG:=TRUE;		% NO ELSE PART
0174    	  EMITB(IF NOTTOG
0175    		THEN BRTR
0176    		ELSE BRFL,THENL,IF THENTOG AND NOT B
0206    				THEN L
0213    				ELSE ELSEL);
0221    	  IF THENTOG
0221    	  THEN
0224    	    IF THENL EQL L
0225    	    THEN BEGIN
0231 3  	      L:=L-3;
0236    	      IF EDOC[L-1] EQL 4*STN+1281
0247    	      THEN BEGIN
0253 4  		L:=L-1;
0260    		EMIT(STD)
0262    		END
0264 4  	      ELSE EMIT(DEL)
0270    	      END
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76        PAGE 96


0272 3  	    ELSE
0272    	  ELSE EMITB(BRUN,ELSEL,L);
0302    	  END OF IF STATEMENT;
                             IFSTMT(102) IS 0303 LONG, NEXT SEGMENT 001 ********
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76        PAGE 97


0513 2  PROCEDURE LABELER;
   001175-P = LABELER
0513    	BEGIN
0513 2  	  INTEGER T:=STACK[INFO+4],F;
                                                 LABELER IS SEGMENT 103 ********
   030005-S = T
   030006-S = F
0007    	  IF STACK[INFO+2] NEQ LEVEL
0016    	  THEN FLAG(50)		% LABEL	NOT DECLARED IN	THIS BLOCK
0024    	  ELSE
0026    	    IF ADDRESS LSS 10000	% LABEL	ALREADY	OCCURED
0032    	    THEN FLAG(51)
0037    	    ELSE BEGIN
0043 3  	      IF T NEQ 0	% LABEL HAS BEEN USED ALREADY!
0044
0045    	      THEN
0050    		DO BEGIN
0050 4  		  F:=EDOC[T];		% FORWARD POINTER
0055    		  EMITB(BRUN,T+2,L)	% BRANCH UNCONDITIONAL
0063    		  END
0065 4  		UNTIL T:=F EQL 0;	% CLEAR	OUT
0074    	      STACK[INFO+1]:=L;		% STORE	PC
0102    	      STACK[INFO+4]:=0;		% NO MORE LINKED UP BRANCHES
0110    	      IF T:=STACK[INFO+5] NEQ 0	% NEED ADDRESS IN PRT?
0120    	      THEN PRTA[T]:=(L+1)	% YES. STORE AS	A BRANCH RETURN
0130    	      END;
0133 3  	  GETNEXT;			% SCAN PAST THE	LABEL
0136    	  IF CLASS NEQ COLON		% NOT FOLLOWED BY A ':'
0137    	  THEN FLAG(49)			% MISSING ':'
0145    	  ELSE GETNEXT			% SCAN IT
0152    	  END OF LABELING;
                            LABELER(103) IS 0155 LONG, NEXT SEGMENT 001 ********
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76        PAGE 98


0513 2  PROCEDURE GOSTMT;
0513    	BEGIN
0513 2  	INTEGER	T,TL,A,TINFO;
                                                  GOSTMT IS SEGMENT 104 ********
   030005-S = T
   030006-S = TL
   030007-S = A
   030010-S = TINFO
0003    	BOOLEAN	B,C;
   030011-S = B
   030012-S = C
0003    	LABEL EXIT,ERR;
0003    	IF NOT PARAMTOG
0005    	THEN GETNEXT;
0013    	LASTWASAGOGO:=TRUE;		% SET GO STMT TOG
0016    	IF ACTIONTOG			% SEE IF WE SHOULD BE LOOKING
0016    	THEN ACTIONTOG:=FALSE		% FOR A	'TO'
0022    	ELSE				% OTHERWISE COULD BE A 'TO'
0024    	  IF CLASS = TOV
0027    	  THEN GETNEXT;
0036    	IF CLASS EQL CASEV OR CLASS EQL	IFV
0042    	THEN BEGIN
0047 3  	  T:=3;
0053    	  CASEORIF(T)		% GET DESIGNATIONAL EXPRESSION
0055    	  END
0057 3  	ELSE BEGIN
0061 3  	  IF CLASS NEQ LABELID AND CLASS NEQ SWITCHID
0065    	  THEN GO ERR;
0074    	  IF TL:=T:=STACK[(TINFO:=INFO)+2] NEQ LEVEL % SEE IF SAME LEVEL
0107    	  THEN
0113    	    IF ADRSR[(T-1)*2] NEQ 0	% NOT TO A PROC
0123    	    THEN			% TO A BLOCK WITHIN A PROC
0126    	      IF NOT INLEVEL(INFO,TL)	% SEE IF WITHIN	THIS PROC
0132    	      THEN BEGIN		% NO. BAD BONGOS CHARLIE!
0136 4  		ERROR(112);	% WE CANNOT DO THIS AWFUL THING	!
0142    		GO EXIT
0144    		END;
0144 4  	  IF CLASS = SWITCHID AND NOT SWITCHDECTOG	% SWITCH GO TO
0147    	  THEN BEGIN		% DISALLOW SWITCHING TO	OTHER SWITCHES
0154 4  	    IF T NEQ LEVEL	% SWITCHES LIMITED TO LEVEL DECLARED IN
0155    	    THEN BEGIN
0161 5  	      ERROR(50);		% NO CAN DO THIS EITHER
0165    	      GO EXIT
0167    	      END;
0167 5  	    LASTWASAGOGO:=FALSE;	% NOT GAURANTEED A GOOD	GO TO
0172    	    GETNEXT;
0175    	    IF CLASS NEQ LFTBRKT THEN BEGIN ERROR(40);GO EXIT;END;
0210    	    GETNEXT; AEXP;
0216    	    IF CLASS NEQ RTBRKT	THEN BEGIN ERROR(41); GO EXIT END;
0231    	    GETNEXT;
0234    	    EMIT(DUP); EMIT(DUP); EMITPAIR(1,GE); EMIT(XCH);
0255    	    EMITPAIR(STACK[TINFO+4],LE); EMIT(LND); EMITPAIR((L+8)*2,BRFL);
0303    	    EMITPAIR(2,SHLL);	% TIMES	4 (4 BYTES/BRANCH INSTRUCTION)
0310    	    EMITL(STACK[TINFO+5]);
0320    	    EMIT(ADD);				% ADD TO TABLE START
0324    	    EMIT(BRUN);
0330    	    EMIT(DEL)			% POP INDEX INTO GOTO TABLE
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76        PAGE 99


	IT WAS NECESSARY TO REDUCE THE SIZE OF THE LISTING FILE TO MAKE
	FIT ON A SINGLE DEC-TAPE. THIS WAS ONE OF THE PAGES THAT VOLUNTEERED
	TO GO.
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 100


0730    		STACK[T]:=L; BUMPL;
0741    		CONSTANTCLEAN;	% YOU CAN'T GET	HERE FROM THERE	EITHER
0751    		GETNEXT
0752    		END
0754 5  	      END
0754 4  	    ELSE	%
0754    ERR:	      ERROR(68)
0760    	    END;
0762 3  EXIT: END;
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 101


OMIT 2  @O
OMIT    <SCANSTMT>::=	SCAN <SOURCE><SCAN PART>
OMIT    <SOURCE>::=	<UPDATE	POINTER><PEXP>
OMIT    <UPDATE	POINTER>::=	<EMPTY>	! <POINTER ID> :
OMIT    <SCAN PART>::=	<CONDITION> !
OMIT    		FOR <COUNT PART> <CONDITION>
OMIT    <CONDITION>::=	UNTIL IN <TRUTHSET DESIGNATOR>	!
OMIT    		WHILE IN <TRUTHSET DESIGNATOR>	!
OMIT    		UNTIL <ROP> <AEXP>  !
OMIT    		WHILE <ROP> <AEXP>
OMIT    <COUNT PART>::=	<RESIDUAL COUNT><AEXP>
OMIT    <RESIDUAL COUNT>::=	<EMPTY>	! <SIMPLE ARITHMETIC ID> :
0762    @O
                             GOSTMT(104) IS 1005 LONG, NEXT SEGMENT 001 ********
0513    PROCEDURE SCANSTMT;	% HANDELS THE SCAN STATEMENT
   001201-P = SCANSTMT
0513    	BEGIN
0513 2  	  BOOLEAN PUPDATE,IUPDATE,ROP,CONDITIONAL,B,F,ID,W;
                                                SCANSTMT IS SEGMENT 105 ********
   030005-S = PUPDATE
   030006-S = IUPDATE
   030007-S = ROP
   030010-S = CONDITIONAL
   030011-S = B
   030012-S = F
   030013-S = ID
   030014-S = W
0003    	  INTEGER T,ROPV;
   030015-S = T
   030016-S = ROPV
0003    	  GETNEXT;	% SCAN THE 'SCAN'
0010    	  IF B:=CLASS EQL STRINGID AND REAL(P,1) EQL ":"
0020    	  THEN BEGIN	% COULD	BE UPDATE OR ASSIGNMENT
0026 3  	    T:=INFO;	% SAVE FOR ADDRESS LATER ON
0031    	    GETNEXT;	% SEE WHAT IT WAS
0034    	    IF PUPDATE:=CLASS EQL COLON	% UPDATE!
0035    	    THEN EMITADDRESS(T,0);  % PUT ADDRESS ON TOS
0050    	    GETNEXT	% SCAN TO BEGINING OF POINTER EXPRESSION
0051    	    END;
0053 3  	  PEXP;		% GET POINTER EXPRESSION
0056    	  IF B AND NOT PUPDATE	% THING
0057    	  THEN BEGIN		% WAS
0064 3  	    EMITADDRESS(T,0);	% ONLY
0071    	    EMIT(PSTN)		% AN
0073    	    END;		% ASSIGNMENT
0075 3  	  IF F:=CLASS EQL FORV	% MAX LENGTH OF	SCAN(OPTIONAL)
0076    	  THEN BEGIN
0104 3  	    GETNEXT;		% GET START OF MAX COUNT
0107    	    IF B:=(CLASS EQL INTID OR ID:=CLASS	EQL INTPROCID)
0120    		AND REAL(P,1) EQL ":"
0125    	    THEN BEGIN		% COULD	BE UPDATE OR ASSIGNMENT
0133 4  	      T:=INFO;		% SAVE FOR LATER USE
0136    	      GETNEXT;		% SEE WHAT IT WAS
0141    	      IF IUPDATE:=CLASS	EQL COLON	% UPDATE
0142    	      THEN BEGIN	% 1ST GET ADDRESS
0150 5  		IF ID		% PROC?
0150    		THEN EMITPROCAORV(T,TRUE)	% PROC ADDRESS
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 102


0156    		ELSE EMITADDRESS(T,0);	% INTEGER ID
0167    		EMIT(RSDN)		% PUT PRIOR TO POINTER EXPRESSION
0171    		END;
0173 5  	      GETNEXT		% SCAN THE THING
0174    	      END;
0176 4  	    AEXP;		% GET MAXLENGTH
0201    	    IF B AND NOT IUPDATE	% THING
0202    	    THEN BEGIN			% WAS
0207 4  	      IF ID			% ONLY
0207    	      THEN EMITPROCAORV(T,TRUE)	% AN
0215    	      ELSE EMITADDRESS(T,0);	% ASSIGNMENT
0226    	      EMIT(STN)			% SAVE VALUE
0230    	      END
0232 4  	    END;
0232 3  	  IF CONDITIONAL:=CLASS	EQL UNTILV OR W:=CLASS EQL WHILEV
0236    	  THEN BEGIN	% CONDITIONAL SCAN
0247 3  	    GETNEXT;	% SCAN THE TYPE	OF CONDITION (WHILE OR UNTIL)
0252    	    IF ROP:=CLASS-NEQOP GEQ 0 AND ROPV LEQ 5
0263    	    THEN BEGIN	% SCAN DURING RELATIONAL
0271 4  	      GETNEXT;	% GET TO AE
0274    	      AEXP
0275    	      END
0277 4  	    ELSE	% SHOULD BE AN 'IN'
0277    	      IF CLASS NEQ INV	% IS IT	THERE?
0302    	      THEN FLAG(105)	% NOPE
0310    	      ELSE BEGIN
0314 4  		GETNEXT;	% SEE WHAT WE GOTS
0317    		IF CLASS NEQ TRUTHID	% FOLLOWED BY TRUTHSET ID?
0320    		THEN FLAG(106)		% NO
0326    		ELSE BEGIN
0332 5  		  EMITADDRESS(INFO,0);	% PUT OUT IT'S ADDRESS
0337    		  GETNEXT		% SCAN IT
0340    		  END
0342 5  		END
0342 4  	    END
0342 3  	  ELSE		% SOMETHING AFTER THE SCAN PART?
0342    	    IF NOT F	% NO. ERROR!
0344    	    THEN FLAG(107);
0353    	  EMITNUM((((((SHL(ROPV+2,3)+REAL(ROP))*2+REAL(W))*2+REAL(PUPDATE))*2
0374    		    +REAL(IUPDATE))*2+REAL(F))*2+REAL(CONDITIONAL));
0411    	  EMIT(SCN);	% SCAN IT
0415    	  END OF SCAN STATEMENT;
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 103


OMIT 2  @O
OMIT    <REPLACESTMT>::=  REPLACE <DESTINATION>	BY <SOURCE LIST>
OMIT    <DESTINATION>::=  <SOURCE>
OMIT    <SOURCE	LIST>::=  <SOURCE PART>	! <SOURCE PART>,<SOURCE	LIST>
OMIT    <SOURCE	PART>::=  <SOURCE><TRANSFER PART> !
OMIT    		  <AEXP><OPTIONAL UNIT COUNT>	!
OMIT    		  <CONVERT PART>  !
OMIT    		  <POINTER-VALUED ATTRIBUTE>  !
OMIT    		  <STRING><OPTIONAL UNIT COUNT>
OMIT    <TRANSFER PART>::=<UNIT	COUNT><SCAN PART>
OMIT    <UNIT COUNT>::=	  FOR <AEXP> <UNITS>
OMIT    <UNITS>::=	  WORD ! WORDS
OMIT    <OPTIONAL UNIT COUNT>::=  <EMPTY> ! <UNIT COUNT>
OMIT    <CONVERT PART>::= <AEXP> FOR <BASE><ZSOPTION><LENGTH PART>
OMIT    <BASE>::=	  BINARY ! OCTAL ! HEX ! DECIMAL ! <EMPTY>
OMIT    <ZSOPTION>::=	  <EMPTY> ! ZEROSUPPRESSED
OMIT    <LENGTH	PART>::=  DIGIT	! DIGITS
OMIT    <POINTER-VALUED	ATTRIBUTE>::=	<FILE DESIGNATOR>.TITLE
OMIT
OMIT    % SEE <SCANSTMT> FOR <SOURCE> AND <SCAN	PART>
OMIT
OMIT    <REPLACE FILE STMT>::=	REPLACE	<POINTER-VALUED	ATTRIBUTE> BY <SIMPLE SOU
OMIT    <SIMPLE	SOURCE>::=  <PEXP> ! <STRING>
OMIT
OMIT
0415    @O
                           SCANSTMT(105) IS 0416 LONG, NEXT SEGMENT 001 ********
0513    PROCEDURE REPLACESTMT;
   001205-P = REPLACESTMT
0513    	BEGIN
0513 2  	  INTEGER T,SEAEPE,CODEWORD,ROPV,TC,SE;
                                             REPLACESTMT IS SEGMENT 106 ********
   030005-S = T
   030006-S = SEAEPE
   030007-S = CODEWORD
   030010-S = ROPV
   030011-S = TC
   030012-S = SE
0003    	  BOOLEAN TRN,SRC,RES,B,B1,B2,W,D,C,T1,U,ROP,F,ZS;
   030013-S = TRN
   030014-S = SRC
   030015-S = RES
   030016-S = B
   030017-S = B1
   030020-S = B2
   030021-S = W
   030022-S = D
   030023-S = C
   030024-S = T1
   030025-S = U
   030026-S = ROP
   030027-S = F
   030030-S = ZS
0003    	  LABEL	EXIT,AGAIN,NEXT,SIMPLEAE,OTHERERR;
0003    	  GETNEXT;		% SCAN THE 'REPLACE'
0010    	  IF CLASS EQL FILEID	% REPLACE FILE.TITLE BY	SIMPLE STRING
0011    	  THEN BEGIN
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 104


	IT WAS NECESSARY TO REDUCE THE SIZE OF THE LISTING FILE TO MAKE IT
	FIT ON A SINGLE DEC-TAPE. THIS WAS ONE OF THE PAGES THAT
	VOLUNTEERED TO GO.
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 105


0256 5  		END
0256 4  	      ELSE BEGIN	% SIMPLE POINTER EXPRESSION
0260 4  		PEXP;		% GET POINTER EXPRESSION
0263    		EMIT(XCH);	% GET ADDRESS OF ARRAY ROW ON TOS
0267    		EMIT(DUP);	% DUP IT
0273    		EMITPAIR(6,ADD);% GET TO LOWER LIMIT FIELD OF ROW
0300    		EMIT(LOD);	% LOAD VALUE
0304    		EMIT(RSDN);	% PUT INDEX UNDER THE ROW DESCRIPTOR
0310    		EMIT(ADC);	% GET ADDRESS OF 1ST ELEMENT IN	ROW
0314    		EMIT(ADD);	% ADD ON THE INDEX FROM	POINTER	EXPRESSION
0320    		EMITL(3"40")	% MAX LENGTH OF	FILE NAME IS 3"40"
0322    		END;
0324 4  	    EMITPAIR(8,COM);	% CHANGE NAME
0331    	    GO EXIT		% DONE !
0345    	    END;
                             B.0015(107) IS 0356 LONG, NEXT SEGMENT 106 ********
0026 3  	  IF CLASS EQL STRINGID AND REAL(P,1) EQL ":"
0036    	  THEN BEGIN
0044 3  	    T:=INFO;		% SAVE IN CASE WE NEED
0047    	    GETNEXT;		% SEE WHAT IT REALLY IS
0052    	    IF TRN:=CLASS EQL COLON	% UPDATE
0053    	    THEN EMITADDRESS(T,0);	% PUT OUT ADDRESS
0066    	    GETNEXT
0067    	    END;
0071 3  	  PEXP;			% GET A	POINTER	EXPRESSION
0074    	  IF B AND NOT TRN	% REALLY WAS AN	ASSIGNMENT
0075    	  THEN BEGIN
0102 3  	    EMITADDRESS(T,0);	% GET THING
0107    	    EMIT(PSTN)		% STORE
0111    	    END;
0113 3  	  IF CLASS NEQ BYV		% SEE IF FOLLOWED
0114    	  THEN BEGIN			% BY A 'BY'
0120 3  	    ERROR(103);			% NO =>	ERROR
0124    	    GO EXIT
0126    	    END;
0126 3  AGAIN:	  GETNEXT;		% SCAN THE 'BY'	(OR A COMMA)
0131    	  SEAEPE:=4;			% RESET	TO NOT DEFINED
0134    	  W:=U:=T1:=ZS:=F:=RES:=SRC:=C:=ROP:=BOOLEAN(ROPV:=SE:=0);
0163    	  IF CLASS EQL FILEID		% REPLACE BY FILE NAME !
0164    	  THEN BEGIN
0170 3  	    DEFINE NEWSEG=#;
   001216-P = B.0016
                                                  B.0016 IS SEGMENT 110 ********
0000    	    EMITVALUE(INFO,1);		% GET POINTER TO ALGOL FIB
0007    	    EMITPAIR(6,ADD);		% GET TO START OF NAME
0014    	    EMITL(40);			% MAX LENGTH OF	NAME
0020    	    EMITL(0);			% DO A REPLACE WHILE NEQ NULL
0024    	    T1:=ROP:=U:=BOOLEAN(SE:=1);
0035    	    GETNEXT;			% SEE IF SYNTAX	IS OK
0040    	    IF CLASS NEQ DOTOP
0041    	    THEN
0047    	    ELSE BEGIN			% '.' WAS THERE. GOOD!
0047 4  	      GETATTRIBUTE;		% SEE IF 'TITLE' THERE TO.
0052    	      IF CLASS NEQ TITLEV	% NOPE.	YOU LOSE.
0053    	      THEN
0061    	      ELSE GETNEXT		% SCAN IT
0062    	      END;
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 106


	IT WAS NECESSARY TO REDUCE THE SIZE OF THE LISTING FILE TO MAKE IT
	FIT ON A SINGLE DEC-TAPE. THIS WAS ONE OF THE PAGES THAT
	VOLUNTEERED TO GO.
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 107


0442    	      F:=TRUE;
0445    	      GO SIMPLEAE
0447    	      END
0447 4  	    ELSE BEGIN
0451 4  	      GETNEXT;		% SCAN THE 'FOR'
0454    	      IF B:=(CLASS EQL INTID OR	B1:=CLASS EQL INTPROCID) AND
0465    		  REAL(P,1) EQL	":" AND	SEAEPE EQL 2
0476    	      THEN BEGIN		% COULD	BE AN UPDATE
0504 5  		T:=INFO;		% SAVE POINTER
0507    		GETNEXT;		% SEE WHAT IT IS
0512    		IF RES:=CLASS EQL COLON	% UPDATE
0513    		THEN BEGIN
0521 6  		  EMITD(JUNK);	% SAVE TOP POINTER
0525    		  EMIT(IF SEAEPE EQL 2 THEN PSTD ELSE STD);  % SAVE THERE
0541    		  IF B1		% PROC ID
0541    		  THEN EMITPROCAORV(T,TRUE)	% GET ADDRESS
0547    		  ELSE EMITADDRESS(T,0);
0560    		  EMIT(RSDN);	% PUT ADDRESS UNDER OTHER POINTER
0564    		  EMITO(JUNK);
0570    		  IF SEAEPE EQL	2	% NEED TO GET REST OF
0572    		  THEN EMITO(JUNK+1)% POINTER FROM TEMP	STORE
0601    		  END;
0603 6  		GETNEXT		% SCAN THE ASSIGNMENT
0604    		END;
0606 5  	      AEXP;		% GET FOR COUNT
0611    	      IF B AND NOT RES	% WAS AN ASSIGNMENT
0612    	      THEN BEGIN
0617 5  		IF B1		% PROC ID
0617    		THEN EMITPROCAORV(T,TRUE)	% GET ADDRESS
0625    		ELSE EMITADDRESS(T,0);
0636    		EMIT(STN)		% STORE	IT
0640    		END
0642 5  	      END;
0642 4  	    IF BOOLEAN(SEAEPE)	% <AE>
0643    	    THEN BEGIN
0645 4  	      IF W:=CLASS EQL WORDSV OR	CLASS EQL WORDV	AND EDOC[L-1] EQL 4
0661    	      THEN GETNEXT
0671    	      ELSE BEGIN
0675 5  		IF ZS:=CLASS EQL ZEROSUPV
0676    		THEN GETNEXT;
0707    		IF C:=TC:=CLASS-BINARYV	GEQ 0 AND TC LEQ 3
0720    		THEN BEGIN	% CONVERT
0726 6  		  GETNEXT;	% SCAN IT
0731    		  IF EDOC[L-1] EQL 4 AND CLASS EQL DIGITV OR CLASS EQL DIGITSV
0745    		  THEN GETNEXT
0753    		  ELSE BEGIN
0757 7  		    OTHERERR: ERROR(104);
0763    		    GO EXIT
0765    		    END
0765 7  		  END
0765 6  		ELSE		% SEE IF A DECIMAL CONVERT
0765    		  IF C:=CLASS EQL DIGITV AND EDOC[L-1] EQL 4 OR	CLASS EQL DIGITSV
1003    		  THEN BEGIN	% YEZ !
1012 6  		    TC:=3;	% DEFAULT IS DECIMAL CONVERT
1015    		    GETNEXT	% SCAN THE 'DIGIT'
1016    		    END
1020 6  		  ELSE
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 108


	IT WAS NECESSARY TO REDUCE THE SIZE OF THE LISTING FILE TO MAKE IT
	FIT ON A SINGLE DEC-TAPE. THIS WAS ONE OF THE PAGES THAT
	VOLUNTEERED TO GO.
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 109


1273 3  	    EMIT(DUP);			% MAKE LENGTH THE LENGTH OF STRING
1277    	    F:=TRUE
1300    	    END;
1302 3  	  CODEWORD:=
1302    		(((((((((((REAL(ZS OR SEAEPE EQL 0 OR BOOLEAN(SE))*2+
1313    			   REAL(B:=CLASS NEQ COMMA))*2+REAL(ROP))*2+
1327    			   REAL(U))*2+REAL(TRN AND B))*2+
1341    			   REAL(SRC))*2+REAL(RES))*2+REAL(T1))*2+
1355    			   REAL(BOOLEAN(SE) OR SEAEPE NEQ 1))*2+
1365    			   REAL(C))*2+REAL(W))*2+
1375    			   REAL(F))*2+REAL(T1 OR C OR BOOLEAN(SE))+
1407    			   SHL(ROPV+2,13);
1417    	  EMITNUM(CODEWORD);	% PUSH CODE WORD
1423    	  EMIT(REP);		% EMIT REPLACE OPERATOR
1427    	  IF CLASS EQL COMMA	% MORE ?
1430    	  THEN GO AGAIN; 	% YES !!!
1436    EXIT:	  END OF REPLACE STATEMENT;
                        REPLACESTMT(106) IS 1437 LONG, NEXT SEGMENT 001 ********
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 110


0513 2  PROCEDURE WHILESTMT;
   001223-P = WHILESTMT
0513    	BEGIN
0513 2  	  INTEGER BACK:=L,FRONT;
                                               WHILESTMT IS SEGMENT 111 ********
   030005-S = BACK
   030006-S = FRONT
0003    	  BOOLEAN B;
   030007-S = B
0004    	  LABEL EXIT;
0004    	  GETNEXT;
0011    	  BEXP;		% SCAN THE BOOLEAN EXPRESSION
0014    	  IF B:=EDOC[L-1] EQL 1285+LNG*4 AND EDOC[L] GEQ 0  % OPTIMIZE
0033    	  THEN L:=L-1;
0046    	  FRONT:=BUMPL;
0055    	  IF CLASS NEQ DOV
0056    	  THEN BEGIN
0062 3  	    ERROR(48);
0066    	    GO EXIT
0070    	    END;
0070 3  	  GETNEXT;
0073    	  STMT;		% STATEMENT TO DO OVER AND AGAIN
0076    	  EMITB(BRUN,BUMPL,BACK);
0110    	  CONSTANTCLEAN;
0120    	  EMITB(IF B THEN BRTR ELSE BRFL,FRONT,L);
0134    EXIT:	  END OF WHILESTMT;
0134 2
0134
                          WHILESTMT(111) IS 0135 LONG, NEXT SEGMENT 001 ********
0513    PROCEDURE DOSTMT;
   001227-P = DOSTMT
0513    	BEGIN
0513 2  	  INTEGER F:=L;
                                                  DOSTMT IS SEGMENT 112 ********
   030005-S = F
0002    	  BOOLEAN B;
   030006-S = B
0003    	  LABEL EXIT;
0003    	  GETNEXT;
0010    	  STMT;
0013    	  IF CLASS NEQ UNTILV AND B:=CLASS NEQ WHILEV
0017    	  THEN BEGIN
0026 3  	    ERROR(47);
0032    	    GO EXIT
0034    	    END;
0034 3  	  GETNEXT;
0037    	  BEXP;
0042    	  IF NOT B
0042    	  THEN EMIT(LNG);
0051    	  IF EDOC[L-1] EQL 1285+4*LNG AND EDOC[L] GEQ 0	% OPTIMIZE
0070    	  THEN EMITB(BRTR,L:=L+1,F)
0104    	  ELSE EMITB(BRFL,BUMPL,F);
0122    EXIT:	  END;
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 111


OMIT 2  @O
OMIT
OMIT    <THRUSTMT>::=	THRU <AE> DO <STMT>
OMIT
OMIT    SEMANTICS	-	<AE> IS	EVALUATED ONLY UPON 1ST	ENCOUNTERANCE OF IT
OMIT    			AS LONG	AS IT IS GTR 0 <STMT> IS EXECUTED ONCE
OMIT    			AND THE	VALUE OF THE ORIGIONAL <AE> IS DECREMENTED BY 1
OMIT    			IF INITIAL VALUE IS 0 OR NEGATIVE, <STMT> IS NOT EXECUTED
OMIT
OMIT    PRAGMANTICS	-	A STACK	CELL IS	ALLOCATED FOR THE INITIAL VALUE
OMIT    			OF THE <AE>. THIS IS THE VALUE THAT IS DECREMENTED
OMIT    			UNTIL 0;
OMIT
0122    @O
                             DOSTMT(112) IS 0123 LONG, NEXT SEGMENT 001 ********
0513    PROCEDURE THRUSTMT;		% NEW STMT, LIMITATIONS	-- CANNOT DO
   001233-P = THRUSTMT
0513    				%	MORE THAN 32767. THRU LOOPS
0513    				% CAUSE	INTEGERS >=-32768&<=32767
0513    	BEGIN
0513 2  	  INTEGER LOOPBEGIN,LOOPOUT,TEMPSTORE;
                                                THRUSTMT IS SEGMENT 113 ********
   030005-S = LOOPBEGIN
   030006-S = LOOPOUT
   030007-S = TEMPSTORE
0003    	  WORKCELLCOUNT:=WORKCELLCOUNT+1;
0012    	  GETNEXT;		% GET TO START OF LOOP COUNT
0015    	  AEXP;			% GET LOOP COUNT
0020    	  LOOPBEGIN:=L;		% SAVE ADDRESS OF WHERE	TO JUMP	BACK TO
0023    	  IF PRTTOG
0023    	  THEN REPLACE PS BY "THRU CLAUSE WORK CELL"," " FOR 45;
0042    	  EMITD(TEMPSTORE:=GETSPACE(CLASSF:=0)); % GET ADDRESS OF WORK-CELL
0056    	  IF FUNCTION
0056    	  THEN BEGIN
0061 3  	    REPLACE ESTACK[EI+1] BY "5.TCWC";
0102    	    ESTACK[EI+4]:=INTID;
0110    	    ESTACK[EI+5]:=TEMPSTORE;
0116    	    EI:=*+ESTACK[EI]:=6
0121    	    END;
0126 3  	  EMIT(STN);
0132    	  EMITL(0);		% TO SEE IF IT IS GREATER THAN 0
0136    	  EMIT(GT);
0142    	  LOOPOUT:=BUMPL;	% IF SO	THEN CONTINUE TO EXECUTE THE
0151    	  IF CLASS NEQ DOV
0152    	  THEN FLAG(48)
0160    	  ELSE BEGIN
0164 3  	    GETNEXT;
0167    	    STMT;			% NEXT STATEMENT
0172    	    EMITO(TEMPSTORE);		% GET WORK CELL	COUNT
0176    	    EMITL(1);			% DECREMENT COUNTER ON STACK
0202    	    EMIT(SUB);
0206    	    EMITB(BRUN,BUMPL,LOOPBEGIN);	% BRANCH BACK TO LOOP BEGINING
0220    	    EMITB(BRFL,LOOPOUT,L);	% BRANCH OUT IF	TOS <= 0
0226    	    END
0226 3  	  END OF THRUSTMT;
                           THRUSTMT(113) IS 0251 LONG, NEXT SEGMENT 001 ********
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 112


0513 2  	PROCEDURE CASESTMT;
   001237-P = CASESTMT
0513    	BEGIN
0513 2  	  INTEGER ARRAY	STMTNOS[0:100],STMTENDS[0:100];
                                                CASESTMT IS SEGMENT 114 ********
   030010-S = STMTNOS
   030015-S = STMTENDS
0023    	  INTEGER ENDL,STMTL,MAXSTMTNO,PRENUM,ENDCNT,I,POLISH,TEMP,
   030017-S = ENDL
   030020-S = STMTL
   030021-S = MAXSTMTNO
   030022-S = PRENUM
   030023-S = ENDCNT
   030024-S = I
   030025-S = POLISH
   030026-S = TEMP
0023    		  OCXL,TEMPL,TMPDATA;
   030027-S = OCXL
   030030-S = TEMPL
   030031-S = TMPDATA
0025    	  BOOLEAN NUMBEREDSTMTS;
   030032-S = NUMBEREDSTMTS
0025    	  LABEL	F1,L1;
0025    	  GETNEXT;		% GET TO START OF A.E.
0032    	  STMTL:=(BUMPL)-2;	% ALLOW	FOR STACK BUILDING CODE
0043    	  AEXP;			% GET INDEX INTO CASE BODY
0046    	  ENDCNT:=MAXSTMTNO:=-1;
0054    	  IF CLASS NEQ OFV	% SEE IF AE FOLLOWED BY	'OF'
0055    	  THEN FLAG(97)		% NOPE.	ERROR
0063    	  ELSE GETNEXT;
0072    	  IF CLASS NEQ BEGINV
0073    	  THEN FLAG(29)		% AFTER	AE MUST	BE A BEGIN
0101    	  ELSE BEGIN
0105 3  	    BEGINCTR:=*+1;	% 1 MORE BEGIN LEVEL
0112    	    OCXL:=L;		% SAVE WHERE WE	PUT THE	OCCURS INDEX
0115    	    EMIT(OCX);		% DO OCCURS INDEX INTO CASE BODY
0121    	    GETNEXT;		% SCAN THE BEGIN
0124    	    NUMBEREDSTMTS:=CLASS EQL ICONSTANT;	% SEE IF #-ED CASE STMTS
0131    	    WHILE CLASS	NEQ ENDV
0132    	    DO BEGIN		% SCAN THE CASE	BODY
0136 4  	      PRENUM:=-1;
0142    	      IF NUMBEREDSTMTS	% SEE IF SUPPOSED TO BE	IN #-ED	STMTS
0142    	      THEN
0145    		WHILE CLASS EQL	ICONSTANT	% ALLOW	1:2:43:ECT.
0146    		DO BEGIN
0152 5  		  IF INREAL GTR	100	% MAX #	IS 100
0154    		  THEN F1:FLAG(38)	% ILLEGAL CONSTANT
0161    		  ELSE
0163    		    IF STMTNOS[INREAL]<>0
0171    		    THEN GO F1		% ALREADY DEFINED
0200    		    ELSE BEGIN
0200 6  		      STMTNOS[INREAL]:=PRENUM;	% LINK LIST OF LABLES
0204    		      IF PRENUM:=INREAL	GTR MAXSTMTNO	% FOR MULTIPLY
0207    		      THEN MAXSTMTNO:=INREAL	% LABELED STMTS
0213    		      END;
0216 6  		  GETNEXT;	% SCAN PAST LABEL
0221    		  IF CLASS EQL SUBOP	% LABEL1-LABEL2
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 113


	IT WAS NECESSARY TO REDUCE THE SIZE OF THE LISTING FILE TO MAKE
	FIT ON A SINGLE DEC-TAPE. THIS WAS ONE OF THE PAGES THAT VOLUNTEERED
	TO GO.
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 114


0567    	    L:=STMTL;			% MAXSTMTNO+1 -	LENGTH OF TABLE
0572    	    EMITD(3"1777"+POLISH-L);		% THIS IS STACK	BUILDING CODE
0602    	    EMITL(MAXSTMTNO);		% FOR THE INTERPRETER
0612    	    L:=POLISH;			% GET IT BACK
0615    	    WHILE I:=I+1 LEQ MAXSTMTNO
0622    	    DO BEGIN
0626 4  	      IF TEMP:=STMTNOS[I] EQL 0
0634    	      THEN TEMP:=-1
0640    	      ELSE BEGIN
0645 5  		IF TEMP	LSS 0
0647    		THEN TEMP:=ENDL;		% NULL STMT GOES OUT
0655    		TEMP:=TEMP*2+2			% TO GET RIGHT ADDRESS FOR BRUN
0661    		END;
0664 5  	      IF DEBUGTOG
0664    	      THEN BEGIN
0667 5  		REPLACE	LINEOUT	BY " " FOR 18,O6(L),"  ",
0710    			IF TEMP	LSS 0 THEN "NVLD" ELSE "    ",
0734    			" " FOR	10,O6(TEMPL);
0746    		WRITEALINE(23)
0750    		END;
0752 5  	      EMITC(TEMP)
0754    	      END;
0765 4  	    I:=-1;
0771    	    WHILE I:=I+1 LEQ ENDCNT
0776    	    DO EMITB(BRUN,STMTENDS[I],L);
1014    	    END
1014 3  	  END OF CASESTMT;
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 115


OMIT 2  @O
OMIT
OMIT    <FORSTMT>	::= FOR	<VARIABLE>:=<FOR LIST> DO <STMT>
OMIT    <FOR LIST>	::= <FOR LIST ELEMENT> ! <FOR LIST>,<FOR LIST ELEMENT>
OMIT    <FOR LIST ELEMENT>::= <INITIAL PART><ITERATION PART>
OMIT    <INITIAL PART>	::= <ARITHMETIC	EXPRESSION>
OMIT    <ITERATION PART>::= <EMPTY> !
OMIT    		    STEP <ARITHMETIC EXPRESSION> UNTIL <ARITHEMETIC EXP> !
OMIT    		    STEP <ARITHMETIC EXPRESSION> WHILE <BOOLEAN	EXPRESS> !
OMIT    		    UNTIL <ARITHMETIC EXPRESSION> !
OMIT    		    WHILE <BOOLEAN EXPRESSION>;
OMIT
1014    @O
                           CASESTMT(114) IS 1015 LONG, NEXT SEGMENT 001 ********
0513    PROCEDURE FORSTMT;
   001243-P = FORSTMT
0513    	BEGIN
0513 2  	  INTEGER ARRAY	STMTCASES[0:60],STMTCONNECTS[0:201];
                                                 FORSTMT IS SEGMENT 115 ********
   030010-S = STMTCASES
   030015-S = STMTCONNECTS
0023    	  INTEGER INDEXVARIABLE,WORKCELL,TEMPL,FORINDEXPLACE,
   030017-S = INDEXVARIABLE
   030020-S = WORKCELL
   030021-S = TEMPL
   030022-S = FORINDEXPLACE
0023    		  TMP,LSC:=-1,LCOUNT:=-1;
   030023-S = TMP
   030024-S = LSC
   030025-S = LCOUNT
0031    	  BOOLEAN STEPTOG;
   030026-S = STEPTOG
0032    	  EMITL(0);			% INITIAL CASE INTO FOR	CASES
0040    	  IF PRTTOG
0040    	  THEN REPLACE PS BY "FOR CLAUSE WORK CELL"," " FOR 46;
0057    	  WORKCELLCOUNT:=WORKCELLCOUNT+1;
0064    	  EMITD(WORKCELL:=GETSPACE(CLASSF:=0));
0100    	  IF FUNCTION
0100    	  THEN BEGIN
0103 3  	    REPLACE ESTACK[EI+1] BY "5.FCWC";
0124    	    ESTACK[EI+4]:=INTID;
0132    	    ESTACK[EI+5]:=WORKCELL;
0140    	    EI:=*+ESTACK[EI]:=6
0143    	    END;
0150 3  	  EMIT(STD);			% STORE	IN OUR WORK CELL
0154    	  FORINDEXPLACE:=(BUMPL)-2;	% REMEMBER WHERE TO PUT	STACK
0165    	  EMITO(WORKCELL);		% GET INDEX INTO FOR CASES
0171    	  EMIT(OCX);			% STACK	BUILDING CODE FOR CASES
0175    	  GETNEXT;			% SCAN THE 'FOR'
0200    	  IF CLASS NEQ INTID		% SHOULD BE INTEGER ID FOR
0201    	  THEN ERROR(IF	CLASS EQL 0 THEN 28 ELSE 59)% OUR INDEX	VARIABLE
0242    	  ELSE BEGIN
0246 3  	    INDEXVARIABLE:=INFO;	% STORE	THE INFO
0251    	    GETNEXT;			% AND SEE IF
0254    	    IF CLASS NEQ ASSIGNOP	% FOLLOWED BY A	':='
0255    	    THEN ERROR(60)		% IF NOT THEN ERROR ALSO
0263    	    ELSE BEGIN
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 116


0267 4  	      DEFINE XYZ=#;		% FORCE	A NEW SEGMENT
   001247-P = B.0017
                                                  B.0017 IS SEGMENT 116 ********
0000    	      DO BEGIN
0002 5  		GETNEXT;		% SCAN TO START	OF INITIAL PART
0005    		STMTCASES[LCOUNT:=LCOUNT+1]:=L;	% STORE	START OF THIS CASE
0015    		AEXP;		% GET <INITIAL PART>
0020    		IF CLASS EQL UNTILV OR STEPTOG:=CLASS EQL STEPV
0024    		THEN BEGIN
0033 6  		  IF STEPTOG
0033    		  THEN GETNEXT;		% SCAN 'STEP'
0041    		  EMITL(LCOUNT+1);	% NEXT TIME THRU LOOP GO TO
0047    		  EMITD(WORKCELL);	% THE NEXT CASE	OF FOR CASES
0053    		  EMIT(STD);
0057    		  EMITL(0);		% TO INDICATE THE 1ST TIME THRU
0063    		  TEMPL:=STMTCASES[LCOUNT:=LCOUNT+1]:=BUMPL;
0101    		  EMITVALUE(INDEXVARIABLE,0);	% IN STEP PART START
0104    		  			% WITH OLD VALUE OF INDEX VAR.
0106    		  EMITL(1);		% TO INDICATE NOT 1ST TIME THRU
0112    		  EMITB(BRUN,TEMPL,L);	% WHICH	GETS SKIPPED ON	1ST TIME
0120    		  IF NOT STEPTOG
0120    		  THEN EMITL(1)		% AUTO INDEX BY	1 FOR UNTIL
0125    					% (NO STEP)
0125    		  ELSE AEXP;		% OTHERWISE GET	STEPSIZE
0134    		  EMIT(RSUP);		% GET 1ST TIME CONDITION ON TOS
0140    		  TEMPL:=BUMPL;		% TO DO	A BRTR
0147    		  IF CLASS EQL UNTILV
0150    		  THEN BEGIN
0154 7  		    EMIT(XCH);		% GET STEP
0160    		    EMIT(DUP);		% DUP A	COPY
0164    		    EMIT(RSUP)		% GET INDEX VALUE
0166    		    END;
0170 7  		  EMIT(ADD);
0174    		  EMITB(BRFL,TEMPL,L);	% SKIP THAT IF NOT 1ST TIME
0202    		  EMITADDRESS(INDEXVARIABLE,0);	% AND
0207    		  IF CLASS EQL WHILEV
0210    		  THEN EMIT(STD)	% STORE
0216    		  ELSE EMIT(STN);	% IN INDEX VARIABLE
0226    		  STEPTOG:=FALSE;
0231    		  IF CLASS EQL UNTILV
0232    		  THEN BEGIN
0236 7  		    GETNEXT;		% SCAN THE 'UNTIL'
0241    		    AEXP;		% GET THE UNTIL	VALUE
0244    		    EMIT(SUB);
0250    		    EMIT(MUL);		% TIMES	SIGN OF	STEP
0254    		    EMITPAIR(0,GT);	% SEE IF INDEX > MAXVALUE
0257    					% (OR INDEX < MINVALUE)
0261    		    STEPTOG:=TRUE;
0264    		    STMTCONNECTS[LSC:=LSC+1]:=BUMPL;
0300    		    STMTCONNECTS[LSC:=LSC+1]:=BRFL
0305    		    END
0310 7  		  ELSE
0310    		    IF CLASS NEQ WHILEV	% SHOULD BE STEP WHILE
0313    					% OR STEP UNTIL
0313    		    THEN ERROR(61);	% OR ERROR
0323    		  END
0323 6  		ELSE BEGIN
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 117


	IT WAS NECESSARY TO REDUCE THE SIZE OF THE LISTING FILE TO MAKE
	FIT ON A SINGLE DEC-TAPE. THIS WAS ONE OF THE PAGES THAT VOLUNTEERED
	TO GO.
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 118


0531    		END
0533 5  	      END
0541 4  	    END
0541 3  	  END OF FOR STATEMENT;
                            FORSTMT(115) IS 0542 LONG, NEXT SEGMENT 001 ********
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 119


0513 2  PROCEDURE WRITESTMT;
0513    	BEGIN
0513 2  	INTEGER	W:=REAL(CLASS EQL WRITEV),T1PC:=L,A,T,P,C,T2PC;
                                               WRITESTMT IS SEGMENT 117 ********
   030005-S = W
   030006-S = T1PC
   030007-S = A
   030010-S = T
   030011-S = P
   030012-S = C
   030013-S = T2PC
0007    	LABEL EXIT;
0007    	EMITL(REAL(BOOLREADTOG));
0015    	EMITD(16);
0021    	EMIT(STD);
0025    	GETNEXT;
0030    	IF CLASS NEQ LFTPAREN THEN BEGIN ERROR(72); GO EXIT END;
0043    	GETNEXT;
0046    	IF CLASS NEQ FILEID THEN BEGIN ERROR(73); GO EXIT END;
0061    	A:=INFO;			% SAVE POINTER TO FILE DESCRIPTOR
0064    	GETNEXT;
0067    	IF CLASS = LFTBRKT THEN
0074    	BEGIN
0074 3  	GETNEXT; AEXP;
0102    	IF CLASS NEQ RTBRKT THEN BEGIN ERROR(74); GO EXIT END;
0115    	GETNEXT;
0120    	END
0120 3  	ELSE EMITPAIR(1,CHS);
0127    	IF CLASS NEQ COMMA THEN	BEGIN ERROR(37); GO EXIT END; GETNEXT;
0145    	AEXP;
0150    	IF CLASS NEQ COMMA THEN	BEGIN ERROR(37); GO EXIT END; GETNEXT;
0166    	GETROW(TRUE);	% MUST BE NON-INDEXED ROW DESCRIPTOR
0172    	IF CLASS NEQ RTPAREN THEN BEGIN	ERROR(32);GO EXIT;END;
0205    	GETNEXT;
0210    	EMITL(W);
0214    	EMITADDRESS(A,1);		% PUT OUT ADDRESS OF FILE DESC.
0221    	EMITPAIR(2,COM);
0226    	IF BOOLREADTOG			% SEE IF FROM BOOLEAN PRIMARY
0226    	THEN BEGIN			% GUESS	SO
0231 3  	  EMITO(16);			% GET RESULT OF	I/O
0235    	  BOOLREADTOG:=FALSE		% RESET	TOG
0236    	  END
0240 3  	ELSE
0240    	  IF CLASS EQL LFTBRKT		% CHECK	FOR ACTION LABELS
0243    	  THEN BEGIN			% YEP
0247 3  	    ACTIONTOG:=TRUE;		% SET TOG
0252    	    EMITO(16);			% GET RESULT OF	I/O
0256    	    T2PC:=BUMPL;
0265    	    GOSTMT;			% GET WHERE TO GO TO
0270    	    EMITB(BRFL,T2PC,L);		% CONDITIONAL BRANCH FALSE AROUND
0274    					% ACTION LABLE GO TO
0276    	    T2PC:=L;			% SAVE CURRENT PC
0301    	    L:=T1PC;			% GET OLD L
0304    	    EMITL(1);			% TO EMIT A TRUE (1)
0310    	    L:=T2PC;			% GET OLD NEW PC
0313    	    IF CLASS NEQ RTBRKT		% CHECK	IF LABLE FOLLOWED BY ']'
0314    	    THEN FLAG(77)		% NO SO	ERROR
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 120


0322    	    ELSE GETNEXT;		% YES SO SCAN PAST IT
0331    	    END;
0331 3  EXIT: END;
                          WRITESTMT(117) IS 0332 LONG, NEXT SEGMENT 001 ********
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 121


0513 2  PROCEDURE FILLSTMT;
   001253-P = FILLSTMT
0513    	BEGIN
0513 2  	  INTEGER J,B,T,DC,I,ODA:=DA,K:=-1;
                                                FILLSTMT IS SEGMENT 120 ********
   030005-S = J
   030006-S = B
   030007-S = T
   030010-S = DC
   030011-S = I
   030012-S = ODA
   030013-S = K
0006    	  BOOLEAN M;
   030014-S = M
0007    	  INTEGER ARRAY	TEDOC[0:1023];
   030020-S = TEDOC
0020    	  LABEL	EXIT,XIT,L1;
0020    	  GETNEXT;			% SCAN THE 'FILL'
0025    	  IF CLASS NEQ ARRAYID		% CAN ONLY FILL	ARRAYS
0026    	  THEN BEGIN
0032 3  	    ERROR(69);			% ARRAY	ROW DESIGNATOR EXPECTED
0036    	    GO XIT
0041    	    END;
0041 3  	  REPLACE LINEOUT BY " " FOR 52,"DATA IS SEGMENT ",
0055    	    O3(SGAVL)," ********";
0067    	  WRITEALINE(40);	% NEW SEGMENT FOR EACH FILL
0073    	  GETROW(TRUE);		% MUST BE ROW DESIGNATOR. NO SUBSCRIPT
0077    	  IF CLASS NEQ WITHV	% NO 'WITH'
0100    	  THEN BEGIN
0104 3  	    ERROR(70);		% ERROR
0110    	    GO EXIT
0133    	    END;
0133 3  	  I:=L;			% SAVE FOR LATER.
0136    	  SWAP(TEDOC,EDOC);	% SWAP FILLER ARRAY WITH CODE ARRAY
0141    	  DO BEGIN		% SCAN ALL OF FILLER
0141 3  	    GETNEXT;		% SCAN THE LAST	THING !
0144    	    IF CLASS EQL QUOTEOP% FILL WITH QUOTED STRING
0145    	    THEN BEGIN
0151 4  	      T:=0;		% TOG FOR PACKING 2 CHARS PER WORD
0154    L1:	      J:=NEXTCHAR;	% GET NEXT CHAR
0162    	      DO BEGIN
0162 5  		IF BOOLEAN(T:=T+1)	% 1ST CHAR/WORD
0167    		THEN BEGIN
0171 6  		  IF K:=*+1 EQL	1024	% EDOC FULL
0177    		  THEN BEGIN		% SO MOVE IT OUT
0202 7  		    L:=K;
0205    		    MOVECODE;		% THIS WILL DO IT
0210    		    DC:=DC+1024;	% KEEP TRACK OF	TOTAL AMOUNT TO	FILL
0215    		    L:=I;
0220    		    K:=0		% RESET	TO START OF EDOC
0221    		    END;
0223 7  		  EDOC[K]:=B:=J		% PUT CHAR IN LOWER PORTION OF WORD
0224    		  END
0231 6  		ELSE EDOC[K]:=J*256+B	% PUT IN 2ND CHAR (SAVE	AN INDEX)
0237    		END
0243 5  	      UNTIL J:=NEXTCHAR = """;
0255    	      SKIPSPACES;		% SCAN OUT THE SPACES
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 122


0260    	      GETNEXT;			% SCAN TO NEXT THING (IN CASE OF DEFINES)
0263    	      IF CLASS EQL QUOTEOP	% TO BE	CONTINUED ?
0264    	      THEN GO L1		% YES
0272    	      END
0272 4  	    ELSE BEGIN	% BETTER BE INTEGER CONSTANT
0274 4  	      IF CLASS EQL ADDOP OR M:=CLASS EQL SUBOP	% PRECEDED BY '+' OR '-'
0300    	      THEN GETNEXT;		% SO SCAN THEM
0312    	      IF CLASS EQL ICONSTANT	% WE GOT WHAT WE WANTED
0313    	      THEN BEGIN
0317 5  		IF K:=*+1 EQL 1024	% EDOC FULL SO
0325    		THEN BEGIN		% SO EMPTY IT
0330 6  		  L:=K;
0333    		  MOVECODE;
0336    		  DC:=DC+1024;	% KEEP TRACK OF	TOTAL AMOUNT OF	FILLER FOUND
0347    		  END;
0351 6  		EDOC[K]:=IF M THEN - INREAL ELSE INREAL;  % STORE IN EDOC
0364    		GETNEXT
0365    		END
0367 5  	      ELSE BEGIN
0371 5  		ERROR(38);	% NOT INTEGER CONSTANT
0375    		GO EXIT
0377    		END
0377 5  	      END
0377 4  	    END
0377 3  	  UNTIL	CLASS NEQ COMMA;  % LOOP BACK IF WE GOT	A COMMA
0404    EXIT:	  L:=K;
0407    	  MOVECODE;		% MOVE WHAT WE GOTS LEFT OVER OUT
0412    	  L:=I;			% WHERE	WE WERE	IN ORIGIONAL CODE
0415    	  SWAP(TEDOC,EDOC);	% GET OLD CODE BACK
0420    	  EMITL(T:=K+1+DC);	% # OF WORDS TO	FILL
0432    	  IF EXTERNALCODE	% DO WE NEED THIS FOR THE BINDER?
0432    	  THEN BEGIN		% YEP. BETTER PUT IT IN THEN.
0435 3  	    EMITB(BRUN,BUMPL,L+2);	% JUMP OVER MARK FOR BINDER
0451    	    EMITO(3"1777");	% MARK FOR BINDER
0455    	    EMITC(SGAVL);	% FOR THE BINDER.
0461    	    IF DEBUGTOG
0461    	    THEN BEGIN
0464 4  	      REPLACE LINEOUT BY " " FOR 18,O6(L-1)," " FOR 16,
0507    		      O6(SGAVL);
0514    	      WRITEALINE(23)
0516    	      END
0520 4  	    END;
0520 3  	  EMITL(ODA);		% DISK ADDRESS OF START	OF FILL
0524    	  EMITPAIR(4,COM);	% COMMUNICATE TO FILL IT
0531    	  REPLACE LINEOUT BY " " FOR 31,"DATA(",O3(SGAVL),") IS ",
0557    	    O4(T)," LONG, NEXT SEGMENT ",O3(SGNO)," ********";
0603    	  WRITEALINE(40);
0607    	  SGAVL:=SGAVL + 1;		% UPDATE NEXT AVAILABLE	SEGMENT	#
0614    XIT:	  END OF FILL STATEMENT;
                           FILLSTMT(120) IS 0654 LONG, NEXT SEGMENT 001 ********
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 123


0513 2  PROCEDURE USTMT;
   001257-P = USTMT
0513    	BEGIN
0513 2  	  BOOLEAN B;
                                                   USTMT IS SEGMENT 121 ********
   030005-S = B
0002    	  INTEGER P1,P2:=CLASS;
   030006-S = P1
   030007-S = P2
0004    	  DEFINE CHECKIT(I,J)=IF CLASS NEQ I THEN FLAG(J) ELSE GETNEXT#;
0004    	  GETNEXT;		% SCAN THE STMT	ID
0011    	  CASE P2-LOCKV	OF
0016    	  BEGIN
0017 3  	    BEGIN		% LOCK STATEMENT
0017 4  	      CHECKIT(LFTPAREN,31);
0035    	      IF CLASS EQL ARRAYID OR
0040    		 B:=CLASS GEQ PROCID AND CLASS LEQ INTPROCID
0044    	      THEN BEGIN	% WE CAN LOCK ARRAY ROWS OR PROCS ONLY
0054 5  		IF B
0054    		THEN EMITADDRESS(INFO,0)
0062    		ELSE GETROW(TRUE);
0072    		IF NOT B	% TELL SAVE FUN	WHAT WE'RE SAVING
0072    		THEN EMITL(0);
0101    		EMIT(SAV);
0105    		GETNEXT
0106    		END
0110 5  	      ELSE ERROR(86);
0116    	      CHECKIT(RTPAREN,32)
0132    	      END;
0134 4  	    BEGIN		% RELEASE STMT
0136 4  	      CHECKIT(LFTPAREN,31);
0154    	      IF CLASS GEQ PROCID AND CLASS LEQ	INTPROCID OR
0163    		 B:=CLASS EQL ARRAYID
0164    	      THEN BEGIN
0173 5  		IF B
0173    		THEN GETROW(TRUE)
0200    		ELSE EMITADDRESS(INFO,0);
0211    		EMIT(REL);
0215    		GETNEXT;
0220    		END
0220 5  	      ELSE ERROR(88);
0226    	      CHECKIT(RTPAREN,32)
0242    	      END;
0244 4  	    BEGIN		% SWAP STMT (FOR SWAPING ARRAYS)
0246 4  	      IF CLASS NEQ LFTPAREN	% NOT FOLLOWED BY '('
0247    	      THEN FLAG(31)
0255    	      ELSE GETNEXT;		% SCAN IT
0264    	      IF CLASS	NEQ ARRAYID	% WE CAN ONLY SWAP ARRAYS
0265    	      THEN ERROR(89);
0275    	      P1:=INFO;		% SAVE POINTER TO 1ST ARRAY
0300    	      GETNEXT;
0303    	      IF CLASS NEQ COMMA% ARRAY	NAMES MUST BE SEPARATED	BY ','
0304    	      THEN FLAG(37)
0312    	      ELSE GETNEXT;
0321    	      IF CLASS NEQ ARRAYID	% NOT ARRAY'S
0322    		 OR REAL(BOOLEAN(STACK[4+P2:=INFO]) AND	TRUE) NEQ
0335    		    REAL(BOOLEAN(STACK[P1]) AND	TRUE)	% NOT DIMENSIONED SAME
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 124


	IT WAS NECESSARY TO REDUCE THE SIZE OF THE LISTING FILE TO MAKE
	FIT ON A SINGLE DEC-TAPE. THIS WAS ONE OF THE PAGES THAT VOLUNTEERED
	TO GO.
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 125


0646 7  		    BEXP;
0651    		    EMIT(LNG)
0653    		    END
0655 7  		  ELSE BEGIN
0657 7  		    EMITL(0);	% PURGE THE FILE
0663    		    GETNEXT
0664    		    END;
0666 7  		  EMITL(1);	% DO STOD
0672    		  EMITL(0)	% TO .PRESENT
0674    		  END
0676 6  		ELSE BEGIN
0700 6  		  EMITL(0);	% A 'FALSE'
0704    		  EMITL(1);	% STOD
0710    		  EMITL(1)	% TO .OPEN
0712    		  END;
0714 6  		EMITPAIR(10,COM);	% DO IT
0721    		CHECKIT(RTPAREN,32)
0735    		END
0737 5  	      END
0737 4  	    END	OF CASE
0741 3  	  END OF UNLABELED STATEMENTS;
                              USTMT(121) IS 0747 LONG, NEXT SEGMENT 001 ********
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 126


0513 2  PROCEDURE STMT;
0513    	BEGIN
0513 2  	INTEGER P,J;
                                                    STMT IS SEGMENT 122 ********
   030005-S = P
   030006-S = J
0003    	BOOLEAN B;
   030007-S = B
0003    	LABEL AGAIN,L2,LE,EXIT;
0003    	LASTWASAGOGO:=FALSE;
0010    AGAIN:	IF CLASS EQL FILEID
0011    	THEN B:=FILEATTRIBUTES(FS,TRUE)
0021    	ELSE
0025    	  IF CLASS EQL POLISHV
0030    	  THEN GO L2
0036    	  ELSE
0036    	    IF CLASS GEQ LOCKV AND CLASS LEQ CLOSEV
0042    	    THEN USTMT
0050    	    ELSE
0052    	  IF CLASS GTR LABELID
0055    	  THEN GO LE
0063    	  ELSE
0063    	    IF CLASS GEQ ENDV AND CLASS LEQ UNTILV
0067    	    THEN
0074    	    ELSE
0074    	CASE CLASS OF
0077    	BEGIN		% TO FAKE THE SCANNER
0100 3  0:11-17:
0100    LE:	  ERROR(28+REAL(CLASS NEQ 0)*27);
0112    1:	  ACTUALPARAPART(TRUE);
0120    2-10:
0122    L2:	  VARIABLE(FS);
0126    22:	  BEGINCTR:=BEGINCTR+1;   % FOR THE BENIFIT OF THE LISTING
0135    	  GETNEXT;
0140    	  BEGINCTR:=BEGINCTR-1;   % BACK DOWN CAUSE COMPOUND TAIL KNOCKS UP
0145    	  IF CLASS>=BOOLEANV AND CLASS<=TRUTHSETV OR CLASS=FIELDV
0155    	  THEN BLOK(0)
0164    	  ELSE COMPOUNDTAIL;
0173    23-34:	  FLAG(56); DECLARATION; GO AGAIN;
0206    35-36:	  WRITESTMT;
0213    37:	  FORSTMT;
0220    38:	  WHILESTMT;
0225    39:	  DOSTMT;
0232    40:	  IFSTMT;
0237    41:	  GOSTMT; GO EXIT;
0246    42:	  FILLSTMT;
0253    43:	  CASESTMT;
0260    44:	  REPLACESTMT;
0265    45:	  SCANSTMT;
0272    46:	  THRUSTMT;
0277    47:	  LABELER; GO AGAIN;
0306    	  END OF CASE;
0370 3  	LASTWASAGOGO:=FALSE;
0373    EXIT:	END;
                               STMT(122) IS 0374 LONG, NEXT SEGMENT 001 ********
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 127


0513 2  INTEGER	PROCEDURE MKATOM;
   001263-P = MKATOM
0513    	BEGIN
0513 2  	  INTEGER
0513    	  % GET HASH VALUE
                                                  MKATOM IS SEGMENT 123 ********
0001    	  SCRAM:=REAL(BOOLEAN(SHR(A[0],8)*2+LINSTR) AND BOOLEAN(63));
   030005-S = SCRAM
0014    	  IF I+C+10 >= STACKSIZE
0023    	  THEN ERROR(91);
0033    	  STACK[MKATOM:=I+1]:=SCRAMBLEDEGGS[SCRAM];
0047    	  SCRAMBLEDEGGS[SCRAM]:=I;
0053    	  REPLACE STACK[I+2] BY	POINTER(A) FOR C WORDS;
0074    	  I:=*+1+C
0077    	  END;
0103 2
0103
                             MKATOM(123) IS 0105 LONG, NEXT SEGMENT 001 ********
0513    PROCEDURE ENTRY;
   001267-P = ENTRY
0513    	BEGIN
0513 2  	LABEL EXIT;
                                                   ENTRY IS SEGMENT 124 ********
0001    	INTEGER	T:=INF:=INFO;
   030005-S = T
0004    	IF CLASS EQL 0
0010    	THEN
0013    	  IF INFO GTR LASTI	% CHECK FOR MULTIPLY DECLARED PARAMETERS.
0014    	  THEN FLAG(2)		% DON'T LET THEM GET BY.
0022    	  ELSE
0024    	ELSE
0024    	  IF RESERVED OR SKAN NEQ 1
0031    	  THEN BEGIN
0035 3  	    FLAG(4);		% NON-ID IN ID LIST
0041    	    CLASS:=0		% RE-ENTER AS ID
0042    	    END
0044 3  	  ELSE
0044    	    IF CLASS IN REDEFINABLES	% IS THIS A REDEFINABLE ID?
0051    		OR CLASS GEQ REDEFINABLE AND CLASS LSS CLASSMAX
0055    	    THEN CLASS:=0		% YES. BETTER ENTER INTO
0064    	    ELSE			% SYM TABLE AGAIN TO KEEP FROM
0064    					% SKREWING UP.
0066    	      IF INFO GTR LASTI	% IF TRUE THEN IN THIS LEVEL.
0071    	      THEN FLAG(2)	% RE-DEFINED
0077    	      ELSE
0101    		IF EXTERNALTOG	% THIS IS THE CHECK TO MAKE SURE THAT 2
0103    		THEN		% EXTERNALS WITH THE SAME NAME (IN DIFFERENT
0106    		  DO BEGIN	% LEVELS) ARE DECLARED THE SAME.
0106 3  		    IF T:=STACK[T+3] GEQ EXTERNALSIZE
0115    		    THEN BEGIN	% ALREADY DECLARED EXTERNAL
0121 4  		      IF CLASS NEQ CLASSF
0122    		      THEN FLAG(13)	% NOT COMPATIBLE
0130    		      END;
0132 4  		    IF T < 0
0134    		    THEN T:=REAL(NOT BOOLEAN(T))
0141    		    END
0143 3  		  UNTIL T = 0;
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 128


0150    	STACK[
0150    	STACK[1+(IF CLASS EQL 0 THEN MKATOM ELSE INSYM)]:=INF:=I+1
0170    		]:=CLASSF&(REAL(OWNTOG AND FUNCTION))[13:1]; % CLASS NUMBER
0210    	STACK[I+1]:=ADDRESSF; % ADDRESS FIELD
0216    	STACK[I+2]:=LEVEL ; % CURRENT LEVEL
0224    	STACK[I+3]:=IF CLASS = 0 THEN 0 ELSE INFO; % LINK
0244    	IF EXTERNALTOG OR OWNTOG AND FUNCTION
0246    	THEN STACK[I]:=STACK[I]+EXTERNALSIZE;
0263    EXIT:	GETNEXT;
0266    	ENTRYCOUNT:=*+1	% KEEP TRACK OF HOW MANY ENTITIES ENTERED.
0270    	END;
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 129


0273 2  %
0273    %	ENTER	APPLIES	ENTRY TO LIST OF IDENTIFIERS
0273    %	CALLED ONLY FOR	LABELS,	AND BOOLEAN/REAL/INTEGER IDENTIFIERS
                              ENTRY(124) IS 0274 LONG, NEXT SEGMENT 001 ********
0513    PROCEDURE ENTER;
   001273-P = ENTER
0513    	BEGIN
0513 2  	  INTEGER ICNT;
                                                   ENTER IS SEGMENT 125 ********
   030005-S = ICNT
0002    	  LABEL	START,L1;
0002    	  BOOLEAN B:=NOT LOCAL OR OWNTOG OR EXTERNALTOG;
   030006-S = B
0010    START:	  IF CLASSF NEQ	LABELID
0013    	  THEN BEGIN
0017 3  	    REPLACE PS BY A+1 FOR LINSTR," " FOR 66-LINSTR;
0035    	    POLISH:=PRTTOG;
0036    	    PRTTOG:=FALSE;
0041    	    ADDRESSF:=GETSPACE(REAL(B));
0050    	    PRTTOG:=POLISH
0050    	    END;
0052 3  	  ENTRY;		% PUT INTO THE SYMTABLE
0055    	  IF EXTERNALTOG AND FUNCTION
0056    	  THEN GO L1;
0067    	  IF CLASSF NEQ	LABELID
0070    	  THEN BEGIN
0074 3  	    IF CLASS = ASSIGNOP
0075    	    THEN BEGIN
0101 4  	      IF NOT B AND ICNT	NEQ 0
0105    	      THEN
0111    		IF EDOC[L-1+REAL(L EQL 0)] EQL BPS*4+1281 AND L	NEQ 0
0132    		THEN BEGIN
0136 5  		  EMITL(EDOC[L:=L-2] DIV 4 + ICNT);
0154    		  L:=*+1
0156    		  END
0161 5  		ELSE
0161    		  IF ICNT EQL 1
0165    		  THEN EMITL(0)
0172    		  ELSE EMITPAIR(ICNT-1,BPS);
0205    	      ICNT:=0;
0210    	      GETNEXT;
0213    	      IF OWNTOG	OR EXTERNALTOG
0214    	      THEN BEGIN
0220 5  		IF CLASSF=BOOID
0221    		THEN BEGIN
0225 6  		  IF CLASS NEQ TRUTH AND CLASS NEQ FALSEV
0231    		  THEN FLAG(38);
0242    		  INREAL:=REAL(CLASS=TRUTH)
0245    		  END
0247 6  		ELSE
0247    		  IF CLASS NEQ ICONSTANT
0252    		  THEN FLAG(38);
0262    		PRTA[ADDRESSF]:=INREAL;
0266    		GETNEXT
0267    		END
0271 5  	      ELSE BEGIN
0273 5  		IF CLASSF EQL BOOID
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 130


	IT WAS NECESSARY TO REDUCE THE SIZE OF THE LISTING FILE TO MAKE
	FIT ON A SINGLE DEC-TAPE. THIS WAS ONE OF THE PAGES THAT VOLUNTEERED
	TO GO.
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 131


                              ENTER(125) IS 0722 LONG, NEXT SEGMENT 001 ********
0513 2  PROCEDURE SWITCHDEC;
   001277-P = SWITCHDEC
0513    	BEGIN
0513 2  	  OWN INTEGER TL,PL;
                                               SWITCHDEC IS SEGMENT 126 ********
   001303-P = TL
   001304-P = PL
0001    	  INTEGER T,P;
   030005-S = T
   030006-S = P
0003    	  BOOLEAN B;
   030007-S = B
0003    	  INTEGER ARRAY	A[0:250];
   030013-S = A
0014    	  LABEL	EXIT;
0014    	  TL:=IF IF TL EQL 0 OR	PL NEQ LEVEL	% WANT TO AVOID	INVALID	INDEX
0022    		 THEN FALSE
0030    		 ELSE EDOC[TL-2] EQL (L*2+2)*4	% OPTIMIZE FOR CASE OF
0046    	      THEN TL				% SWITCHDEC FOLLOWING SWITCHDEC
0052    	      ELSE BUMPL;
0064    	  PL:=LEVEL;
0067    	  IF EXTERNALTOG OR SAVETOG OR OWNTOG THEN FLAG(14);
0102    	  STOPDEFINE:=SWITCHDECTOG:=TRUE;	% GET SWITCH NAME
0107    	  GETNEXT;
0112    	  CLASSF:=LABELID; ADDRESSF:=0;
0120    	  ENTRY; STACK[P:=INF]:=SWITCHID;
0131    	  I:=I+2;	% MAKE ROOM FOR	# OF SWITCHES AND BASE ADDRESS
0136    	  IF CLASS NEQ ASSIGNOP	THEN BEGIN ERROR(67);GO	EXIT END;
0151    	  DO BEGIN
0151 3  	    A[T+1]:=L;	% WHERE	EACH DESIGNATIONAL EXPRESSION STARTS
0161    	    ACTIONTOG:=TRUE;	% LET GO-STMT HANDLE THEM
0164    	    GOSTMT;
0167    	    B:=B OR L-A[T] GTR 2	% B INDICATES IF ANY NON-LOCAL BLOCK
0176    	    END			% CHANGES (MORE	CODE) OR EXPRESSIONS
0202 3  	  UNTIL	CLASS NEQ COMMA;	% END OF SWITCH	LIST !
0207    	  STACK[P+4]:=T;		% # OF SWITCHES
0215    	  STACK[P+5]:=(IF B THEN L ELSE	A[1])*2-2;	% WHICH	TABLE TO INDEX INTO
0237    	  P:=1;
0242    	  IF B		% SHOULD WE BUILD A BRANCH TABLE?
0242    	  THEN		% YES
0245    	    DO EMITB(BRUN,BUMPL,A[P])	% BUILD	IT HERE
0257    	    UNTIL P:=P+1 GTR T;
0272    	  EMITB(BRUN,TL,L);		% BRANCH AROUND	THE BRANCHES WE	CREATED
0300    	  SWITCHDECTOG:=FALSE;
0303    EXIT:	  END OF SWITCH	DEC;
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 132


0303 2  %
0303    %	ARRAYDEC	HANDLER	ARRAY DECLARATIONS
0303    %
                          SWITCHDEC(126) IS 0304 LONG, NEXT SEGMENT 001 ********
0513    PROCEDURE ARRAYDEC;
   001305-P = ARRAYDEC
0513    	BEGIN
0513 2  	  INTEGER OLDCLASS:=IF CLASSF EQL 0 THEN INTID ELSE CLASSF,
                                                ARRAYDEC IS SEGMENT 127 ********
   030005-S = OLDCLASS
0012    		  TL:=L,TC:=CLEAN,P,PT,T;	% DEFAULT ARRAY	TYPE IS	INTEGER
   030006-S = TL
   030007-S = TC
   030010-S = P
   030011-S = PT
   030012-S = T
0016    	  BOOLEAN TWODIM,THEREWASACOMMA,
   030013-S = TWODIM
   030014-S = THEREWASACOMMA
0016    		  B:=NOT LOCAL OR EXTERNALTOG OR OWNTOG;  % SET	BLOCK 0	TOGGLE
0022
   030015-S = B
0024    	  LABEL	EXIT;
0024    	  CLASSF:=ARRAYID;		% SET CLASS OF DECLARATION TO BE
0027    					% ARRAY	DECLARATION
0031    	  DO BEGIN
0031 3  	    P:=REAL(THEREWASACOMMA:=TWODIM:=FALSE);  % RESET SWITCHES
0040    	    DO BEGIN
0040 4  	      STOPDEFINE:=TRUE;	% DONT EXPAND DEFINES
0043    	      GETNEXT;			% GET IDENTIFIER
0046    	      IF B			% IN THE PRT
0046    	      THEN PRTMAX:=*+1;	% FOR ARRAY LINKAGE
0056    	      IF PRTTOG
0056    	      THEN REPLACE PS BY A+1 FOR LINSTR," " FOR 66-LINSTR;
0077    	      ADDRESSF:=GETSPACE(REAL(B));
0106    	      ENTRY;			% ENTER	IN THE SYMBOLTABLE
0111    	      I:=I+2;			% LEAVE	ROOM FOR DIM,SAVE,TYPES
0116    	      IF P GTR 0		% 1ST TIME THROUGH?
0120    	      THEN STACK[PT]:=I		% NO. POINT LAST TO THIS ONE.
0124    	      ELSE P:=I;		% INITIALIZE 1ST LINK POINTER.
0134    	      PT:=I;			% SAVE THIS POINTER.
0137    	      IF B			% IN THE PRT
0137    	      THEN
0142    	      ELSE STACKCTR:=STACKCTR+1;% MAKE ROOM FOR	LINK
0147    	      IF CLASS EQL COMMA	% CHECK	FOR MULTIPLY DEFINED DECS
0150    	      THEN THEREWASACOMMA:=TRUE
0155    	      END
0157 4  	    UNTIL NOT CLASS EQL	COMMA;	% CONTINE TO SCAN UNTIL	NO ,'S
0164    	    STACK[PT]:=0;		% SET THE GROUND.
0170    	    IF CLASS NEQ LFTBRKT	% SHOULD BE FOLLOWED BY	'['
0171    	    THEN BEGIN
0175 4  	      ERROR(15);		% NOT GOOD !
0201    	      GO EXIT
0206    	      END;
0206 4  	    GETNEXT;			% SCAN PAST THE	'['
0211    	    AEXP;			% GET LOWER LIMIT
0214    	    IF CLASS NEQ COLON		% FOLLOWED BY ':'
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 133


	IT WAS NECESSARY TO REDUCE THE SIZE OF THE LISTING FILE TO MAKE
	FIT ON A SINGLE DEC-TAPE. THIS WAS ONE OF THE PAGES THAT VOLUNTEERED
	TO GO.
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 134


0517    	    END;
0522 3  EXIT:	  END;
                           ARRAYDEC(127) IS 0523 LONG, NEXT SEGMENT 001 ********
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 135


0513 2  PROCEDURE MEMBERSHIPPRIMARY;
   001311-P = MEMBERSHIPPRIMARY
0513    	BEGIN
0513 2  	  INTEGER I,J;
                                       MEMBERSHIPPRIMARY IS SEGMENT 130 ********
   030005-S = I
   030006-S = J
0003    	  BOOLEAN B1,B:=CLASS EQL NOTV;
   030007-S = B1
   030010-S = B
0006    	  IF B				% SCAN OUT NOT'S
0010    	  THEN GETNEXT;
0016    	  IF CLASS EQL LFTPAREN		% '('
0017    	  THEN BEGIN
0023 3  	    GETNEXT;			% SCAN IT
0026    	    MEMBERSHIPEXP;		% GET MEMBERSHIP EXPRESSION
0031    	    IF B1:=CLASS NEQ RTPAREN	% FOLLOWED BY A	')'?
0032    	    THEN FLAG(32)		% NO
0042    	    END
0044 3  	  ELSE
0044    	    IF CLASS EQL TRUTHID AND STACK[INFO+3] GEQ 0% TRUTHID
0057    	    THEN REPLACE PERMDEC BY POINTER(STACK[INFO+4]) FOR 8 WORDS
0102    	    ELSE
0104    	      IF CLASS EQL QUOTEOP	% QUOTED STRING
0107    	      THEN BEGIN
0113 3  		REPLACE	PERMDEC	BY 0 FOR 8 WORDS;
0126    		I:=NEXTCHAR;		% IN CASE 1ST CHAR IS A	"""
0134    		DO BEGIN
0134 4  		  J:=REAL(BOOLEAN(I) AND BOOLEAN(15));	% I MOD	16
0141    		  PERMDEC[SHR(I,4)]:=REAL(BOOLEAN(PERMDEC[I]) OR
0151    			 BOOLEAN(SHL(1,J)))
0155    		  END			% OR IN	THIS CHARACTER INTO TRUTHSET
0157 4  		UNTIL NEXTCHAR EQL """;
0171    		SKIPSPACES
0172    		END
0174 3  	      ELSE
0174    		IF CLASS EQL ICONSTANT	% CONSTANTS ALLOWED ALSO
0177    		THEN BEGIN
0203 3  		  REPLACE PERMDEC BY 0 FOR 8 WORDS;
0216    		  PERMDEC[SHR(REAL(BOOLEAN(INREAL) AND BOOLEAN(127)),4)]
0225    		  :=SHL(1,REAL(BOOLEAN(I) AND BOOLEAN(15)))
0232    		  END
0234 3  		ELSE ERROR(REAL(B1:=BOOLEAN(113)));	% BAD BONGO'S CHARLIE
0244    	  IF NOT B1		% NO ERROR
0244    	  THEN GETNEXT;		% SO SCAN THE TOKEN!
0252    	  IF B		% NOT TOG
0252    	  THEN BEGIN	% RESET	THE TEMPORARY DECLARATION
0260 3  	    DO PERMDEC[I]:=REAL(NOT BOOLEAN(PERMDEC[I]))
0265    	    UNTIL I+1 EQL 8
0275    	    END
0300 3  	  END OF MEMBERSHIP PRIMARIES;
0300 2
                  MEMBERSHIPPRIMARY(130) IS 0304 LONG, NEXT SEGMENT 001 ********
0513    PROCEDURE MEMBERSHIPEXP;	% PARSES MEMBERSHIP EXPRESSIONS
0513    	BEGIN
0513 2  	  INTEGER ARRAY	TEMPDEC[0:7];	% FOR RECURSIVE	PURPOSES
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 136


                                           MEMBERSHIPEXP IS SEGMENT 131 ********
   030010-S = TEMPDEC
0012    	  BOOLEAN LAND;
   030012-S = LAND
0013    	  INTEGER I;
   030013-S = I
0014    	  MEMBERSHIPPRIMARY;	% GET PRIMARY EXPRESSION
0021    	  WHILE	CLASS EQL ORV OR LAND:=CLASS EQL ANDV
0025    	  DO BEGIN		% AND &	OR IN LEFT TO RIGHT ORDER
0034 3  	    SWAP(TEMPDEC,PERMDEC);	% SWAP THE NEW ARRAY OUT & OLD ONE IN
0037    	    GETNEXT;		% SCAN THE LOGICAL OPERATOR
0042    	    MEMBERSHIPPRIMARY;	% SHOULD BE FOLLOWED BY	ANOTHER	PRIMARY
0045    	    SWAP(TEMPDEC,PERMDEC);	% SWAP ARRAYS BACK TO ORIGIONAL	ORDER
0050    	    I:=0;		% CLEAR	I
0053    	    DO PERMDEC[I]:=	% AND OR OR THE	OLD VALUES IN
0054    	      IF LAND		% AND THEM
0054    	      THEN REAL(BOOLEAN(PERMDEC[I]) AND	BOOLEAN(TEMPDEC[I]))
0066    	      ELSE REAL(BOOLEAN(PERMDEC[I]) OR	BOOLEAN(TEMPDEC[I]))
0100    	    UNTIL I:=I+1 EQL 8
0110    	    END
0113 3  	  END OF MEMBERSHIP EXPRESSIONS;
0115 2
                      MEMBERSHIPEXP(131) IS 0116 LONG, NEXT SEGMENT 001 ********
0513    PROCEDURE TRUTHSETDEC;		% FINALLY, THE ONE YOU ALL BEEN	WAITING	FOR
   001315-P = TRUTHSETDEC
0513    	BEGIN
0513 2  	  LABEL L1;
                                             TRUTHSETDEC IS SEGMENT 132 ********
0001    	  INTEGER TINFO,X,J;
   030005-S = TINFO
   030006-S = X
   030007-S = J
0003    	  BOOLEAN B:=NOT LOCAL OR EXTERNALTOG OR OWNTOG;
   030010-S = B
0011    	  CLASSF:=TRUTHID;	% SET CLASS AS TRUTHSET	ID
0016    	  DO BEGIN		% SCAN THE ID LIST
0016 3  	    STOPDEFINE:=TRUE;	% STOP EXPANSION OF DEFINES IN ID LIST
0021    	    GETNEXT;		% GET ID
0024    	    IF PRTTOG
0024    	    THEN REPLACE PS BY A+1 FOR LINSTR," " FOR 66-LINSTR;
0045    	    J:=(ADDRESSF:=GETSPACE(REAL(B)))-1;
0060    	    ENTRY;		% PUT IN THE SYMBOL TABLE
0063    	    IF EXTERNALTOG AND FUNCTION	% IS THIS THE DECLARATION?
0064    	    THEN GO L1;			% NOPE. JUST GET AN ADDRESS.
0075    	    I:=(TINFO:=I)+X:=8;	% INIT VARIABLES
0106    	    IF CLASS EQL LFTPAREN	% OK
0107    	    THEN BEGIN
0113 4  	      MEMBERSHIPPRIMARY;    % SCAN THE TRUTHSET	DEC
0116    	      DO BEGIN
0116 5  		STACK[TINFO+X]:=PERMDEC[X:=X-1];  % PUT	IN SYMBOL TABLE
0132    		IF B		% PUT IN THE PRT
0132    		THEN PRTA[J:=J+1]:=PERMDEC[7-X]	    % GET FROM TEMP DEC
0145    		ELSE EMITNUM(PERMDEC[X])	% ELSE PUSH INTO THE STACK
0157    		END
0161 5  	      UNTIL X EQL 0
0163    	      END
0166 4  	    ELSE ERROR(31);
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 137


0174    L1:	    END
0174 3  	  UNTIL	CLASS NEQ COMMA
0175    	  END OF TRUTH SET DECLARATIONS;
                        TRUTHSETDEC(132) IS 0202 LONG, NEXT SEGMENT 001 ********
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 138


0513 2  PROCEDURE POINTERDEC;
   001321-P = POINTERDEC
0513    	BEGIN
0513 2  	  BOOLEAN B:=NOT LOCAL OR EXTERNALTOG OR OWNTOG;
                                              POINTERDEC IS SEGMENT 133 ********
   030005-S = B
0007    	  LABEL	OWNPTR,L1;
0007    	  CLASSF:=STRINGID;
0014    	  DO BEGIN		% SCAN POINTER-IDENTIFIER LIST
0014 3  	    STOPDEFINE:=TRUE;	% STOP EXPANSION OF DEFINES
0017    	    GETNEXT;		% GET NEXT IDENTIFIER IN LIST
0022    	    REPLACE PS BY A+1 FOR LINSTR," " FOR 66-LINSTR;
0040    	    POLISH:=PRTTOG;
0041    	    PRTTOG:=FALSE;
0044    	    ADDRESSF:=GETSPACE(REAL(B));  % GET	ADDRESS	FOR ID
0053    	    PRTTOG:=POLISH;
0055    	    ENTRY;		% PUT IN THE SYMBOL TABLE
0060    	    IF EXTERNALTOG AND FUNCTION	% IS THIS THE DECLARATION?
0061    	    THEN GO L1;			% NO. JUST GET AN ADDRESS.
0072    	    IF OWNTOG
0072    	    THEN GO OWNPTR;
0077    	    IF CLASS EQL EQLOP	% SEE IF EQUIVALANCE
0100    	    THEN BEGIN
0104 4  	      GETNEXT;		% YES. SEE IF EQUIVALANCED TO A	POINTER
0107    	      IF CLASS NEQ STRINGID
0110    	      THEN FLAG(108)	% POINTER IDENTIFIER EXPECTED
0116    	      ELSE BEGIN
0122 5  		STACK[INF+1]:=STACK[INFO+1];	% COPY ADDRESS
0134    		STACK[INF+2]:=STACK[INFO+2];	% AND LEVEL OF OTHER DECLARATION
0146    		IF B		% UNALLOCATE AREA WHERE	WE WERE	GOING TO
0146    				% PUT THIS
0146    		THEN PRTMAX:=PRTMAX-3
0153    		ELSE STACKCTR:=STACKCTR-3;
0165    		GETNEXT		% SCAN THE ID
0166    		END
0170 5  	      END
0170 4  	    ELSE BEGIN		% NOT EQUIVALANCED
0172 4  	      IF NOT B		% IN STACK
0172    	      THEN EMITL(0);	% FOR LINKAGE
0201    	      IF CLASS EQL ASSIGNOP	% BUILD	ONE NOW	?
0202    	      THEN BEGIN
0206 5  		GETNEXT;	% SCAN THE ':='
0211    		PEXP;		% EXPECTING A POINTER EXPRESSION
0214    		IF B		% IN PRT ?
0214    		THEN BEGIN	% YES
0217 6  		  EMITADDRESS(INF,0);	% STORE	THERE
0224    		  EMIT(PSTD)
0226    		  END
0230 6  		ELSE EMIT(XCH)	% PUT IN PROPER	ORDER FOR POINTER
0234    		END
0236 5  	      ELSE
0236    		IF NOT	B	% IN THE STACK?
0240    		THEN BEGIN	% YES
0243 5  		  EMITL(0);	% OTHER	WISE BUILD A VIRGIN POINTER
0247    		  EMITL(0)
0251    		  END;
0253 5  OWNPTR:	      EMITL(REAL(OWNTOG));		% FOR THE BUILDER
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 139


0257    	      EMITD(ADDRESSF-2+4*REAL(B	AND TRUE));	% WHERE	TO LINK	TO
0273    	      EMIT(PLNK)	% AND LINK UP THE POINTERS.
0275    	      END;
0277 4  L1:	    IF PRTTOG		% FIX UP LISTING.
0277    	    THEN BEGIN
0302 4  	      REPLACE LINEOUT BY "   ",O6(STACK[INF+1]),"-",
0327    		    IF STACK[INF+1] LEQ 3"17777"
0335    		    THEN
0336    		      IF FUNCTION
0340    		      THEN "X"
0343    		      ELSE "P"
0355    		    ELSE "S",
0367    		  " = ", PS FOR 33 WORDS;
0401    	      WRITEALINE(40)
0403    	      END
0405 4  	    END
0405 3  	  UNTIL	CLASS NEQ COMMA;
0412    	  END OF POINTER DEFINITIONS;
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 140


OMIT 2  @O
OMIT    %		D E F I N E   D E C L A R A T I O N S
OMIT    %		===========   =======================
OMIT    %
OMIT    %	UN-NECESSARY SPACES ARE TAKEN OUT OF THE DEFINED TEXT AND STORED
OMIT    %	IN THE SYMBOL TABLE. DEFINES MAY HAVE UP TO 10 PARAMETERS,
OMIT    %	THOUGHT OF BY THE COMPILER AS 0 THRU 9. THE LEFT MOST PARAMETER
OMIT    %	IS PARAMETER # 0. ANY NON-RESERVED WORD MAY BE A PARAMETER
OMIT    %	TO THE DEFINE (INCLUDING THE NAME OF THE DEFINE ITSELF).
OMIT    %	IF AN IDENTIFIER IS USED IN MORE THAN ONE DEFINE POSITION,
OMIT    %	THEN IT IS TAKEN TO REFERENCE THE LEFT-MOST PARAMETER POSITION
OMIT    %	IN ITS CONTEXT WITHIN THE DEFINED TEXT. PARAMETERS IN THE
OMIT    %	DEFINED TEXT ARE STORED AS 3"177" FOLLOWED BY THE PARAMETER
OMIT    %	NUMBER ("0" TO "9"). DEFINE DECLARATIONS MAY BE
OMIT    %	NESTED WITHIN DEFINED TEXT.
OMIT
OMIT    %
OMIT    %	EXAMPLE -
OMIT    %		DEFINE A(B,C,B) = INTEGER B; BOOLEAN C;#;
OMIT    %		A(I,J,K); % EXPANDS TO "INTEGER I; BOOLEAN J;"
OMIT    %
OMIT    %	EXAMPLE -
OMIT    %
OMIT    %		DEFINE FORCEASEGMENT = DEFINE XXXXX = # #;
OMIT    %
OMIT    %	IF I LEQ J
OMIT    %	THEN BEGIN	% WISH TO FORCE A SEGMENT HERE
OMIT    %	  FORCEASEGMENT;% THIS EXPANDS INTO "DEFINE XXXXX = #"
OMIT    %
0412    @O
                         POINTERDEC(133) IS 0421 LONG, NEXT SEGMENT 001 ********
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 141


0513    PROCEDURE DEFINEDEC;		% DECLARES DEFINES (INCLUDING
   001325-P = DEFINEDEC
0513    	BEGIN			% THOSE	WITH PARAMETERS)
0513 2  	  INTEGER ARRAY	ELBAT[0:180];	% OUR OWN SYMBOLTABLE FOR FASTNESS
                                               DEFINEDEC IS SEGMENT 134 ********
   030010-S = ELBAT
0012    	  INTEGER LINK,TCOUNT,COUNT,INP,PARAMNO,X,TX,TEMP,B,NESTLEVEL;
   030012-S = LINK
   030013-S = TCOUNT
   030014-S = COUNT
   030015-S = INP
   030016-S = PARAMNO
   030017-S = X
   030020-S = TX
   030021-S = TEMP
   030022-S = B
   030023-S = NESTLEVEL
0014    	  BOOLEAN DONE,FOUND,WEMAYNEEDASPACE;
   030024-S = DONE
   030025-S = FOUND
   030026-S = WEMAYNEEDASPACE
0014    	  LABEL	XIT;
0014    	  CLASSF:=DEFINEID;	ADDRESSF:=0;
0024    	  DO BEGIN
0024 3  	    GETNEXT;		% GET ID (NAME OF DEFINE)
0027    	    ENTRY;		% PUT IN THE SYMBOL TABLE
0032    	    INP:=INF+1;		% WHERE	TO PUT PARAMETER COUNT
0037    	    I:=I+1;		% WHERE	TO PUT LENGTH OF DEFINE	(IN WORDS)
0044    	    NESTLEVEL:=COUNT:=PARAMNO:=LINK:=
0044    			      REAL(DONE:=WEMAYNEEDASPACE:=FALSE);
0061    	    IF CLASS EQL LFTPAREN	% PARAMETERS YET! WELL WE CAN
0062    	    THEN BEGIN			% DIG IT !!!
0066 4  	      DO BEGIN
0066 5  		STOPDEFINE:=TRUE;	% STOP EXPANSION OF DEFINES
0071    		GETNEXT;		% GET NEXT PARAMETER NAME
0074    		IF RESERVED OR SKAN NEQ	1	% MAKE SURE IT'S AN ID
0077    		THEN BEGIN			% WHATS	THIS GARBAGE ?
0103 6  		  ERROR(99);
0107    		  GO XIT
0112    		  END;
0112 6  		REPLACE	ELBAT[LINK+1] BY POINTER(A) FOR	C WORDS;
0133    		ELBAT[LINK]:=LINK:=*+C+1;
0145    		PARAMNO:=PARAMNO+1;	% KEEP TRACT HOW MANY WE GOTS
0152    		GETNEXT			% GET NEXT THING
0153    		END
0155 5  	      UNTIL PARAMNO EQL	10 OR CLASS NEQ	COMMA;
0166    	      IF CLASS NEQ RTPAREN	% EITHER ',' EXPECTED
0167    	      THEN BEGIN		% OR TO	MANY PARAMS ( ')' EXPT)
0173 5  		ERROR(5*REAL(PARAMNO EQL 10));
0205    		GO XIT
0210    		END;
0210 5  	      GETNEXT			% SCAN TO WHAT SHOULD BE A '='
0211    	      END;
0213 4  	    IF CLASS NEQ EQLOP		% SEE IF IT IS
0214    	    THEN BEGIN
0220 4  	      ERROR(52);		% TELL HIM ABOUT OUR COMPLAINT
0224    	      GO XIT
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 142


	IT WAS NECESSARY TO REDUCE THE SIZE OF THE LISTING FILE TO MAKE
	FIT ON A SINGLE DEC-TAPE. THIS WAS ONE OF THE PAGES THAT VOLUNTEERED
	TO GO.
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 143


0647    		      IF I+1 GTR STACKSIZE	% SEE IF STACK OVERFLOW
0654    		      THEN ERROR(91)
0662    		      ELSE STACK[I+1]:=B+256*REAL(POINTER(INSTR)+X,1);
0707    		  WEMAYNEEDASPACE:=SKAN	EQL 1
0711    		  END
0714 5  	      END
0714 4  	    UNTIL DONE;		% END OF CRUNCHER
0717    	    IF BOOLEAN(COUNT)	% SEE WHAT TO DO WITH LAST CHAR
0720    	    THEN		% IF IT	EXISTS
0722    	      IF I+1 GTR STACKSIZE	% CHECK	FOR SYMTBL OFLOW
0725    	      THEN ERROR(91)
0733    	      ELSE STACK[I:=I+1]:=B;	% STORE	IT
0747    	    STACK[INP]:=PARAMNO;	% STORE	THE # OF PARAMETERS
0753    	    STACK[INP+3]:=COUNT;	% STORE	# OF CHARS LONG
0761    	    GETNEXT		% GET PAST THE '#'
0762    	    END
0764 3  	  UNTIL	CLASS NEQ COMMA;	% IF FOLLOWED BY A COMMA THEN MORE
0771    XIT:	  END OF DEFINEDEC;
                          DEFINEDEC(134) IS 0772 LONG, NEXT SEGMENT 001 ********
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 144


0513 2  PROCEDURE FILEDEC;	% FOR DECLARING	FILES
   001331-P = FILEDEC
0513    	BEGIN
0513 2  	  LABEL	E1,E2,L1;
                                                 FILEDEC IS SEGMENT 135 ********
0001    	  BOOLEAN BL=LINSTR,B:=NOT LOCAL OR EXTERNALTOG OR OWNTOG,
   000116-P = BL
   030005-S = B
0007    		  U,M,K,T,E,MR;
   030006-S = U
   030007-S = M
   030010-S = K
   030011-S = T
   030012-S = E
   030013-S = MR
0011    	  INTEGER USE,MAX,KND,MAXSIZ;
   030014-S = USE
   030015-S = MAX
   030016-S = KND
   030017-S = MAXSIZ
0011    	  ARRAY	NAME[0:33];	% FOR DEFAULT EXTERNAL FILE NAME
   030023-S = NAME
0022    	  POINTER Q;
   030027-S = Q
0030    	  CLASSF:=FILEID;
0035    	  DO BEGIN	% SCAN THE LIST
0035 3  	    STOPDEFINE:=TRUE;	% STOP EXPANSION OF DEFINES
0040    	    GETNEXT;		% GET FILE NAME
0043    	    IF PRTTOG
0043    	    THEN REPLACE PS BY A+1 FOR LINSTR," " FOR 66-LINSTR;
0064    	    ADDRESSF:=GETSPACE(REAL(B));	% GET SPACE FOR	IT SOMEWHERE
0073    	    REPLACE NAME BY A+1 FOR LINSTR,	% GET DEFAULT NAME
0102    			" " FOR	1-REAL(BL AND TRUE),""..";
0120    	    ENTRY;		% PUT INTO THE SYMBOL TABLE
0123    	    IF EXTERNALTOG AND FUNCTION	% IS THIS A DECLARATION?
0124    	    THEN GO L1;		% NO. SKIP THE DECLARATION THEN.
0144    	    MR:=U:=M:=K:=T:=E:=BOOLEAN(USE:=0);% INITIALIZATION
0163    	    MAX:=36;		% DEFAULT MAXREC
0166    	    MAXSIZ:=0;		% DEFAULT SIZE
0171    	    KND:=7;
0174    	    IF B		% THIS ONE GOES	INTO THE PRT
0174    	    THEN
0177    	    ELSE EMITPAIR(4,BPS);	% MAKE SPACE FOR FILE
0204    	    EMITD(ADDRESSF);		% GET ADDRESS OF FILE DESCRIPTOR
0210    	    IF CLASS EQL LFTPAREN	% INITIAL ATTRIBUTE LIST !
0211    	    THEN BEGIN
0215 4  	      DO BEGIN			% SCAN THE ENTIRE LIST
0215 5  		GETATTRIBUTE;		% SEE WHAT ATTRIBUTE IS
0220    		IF CLASS EQL MYUSEV
0221    		THEN			% MYUSE	=
0225    		  IF U:=NOT U		% DEFINED BEFORE ?
0225    		  THEN BEGIN		% NO SO	OK
0233 6  		    GETNEXT;		% SEE WHAT FOLLOWS
0236    		    IF CLASS NEQ EQLOP	% FOLLOWED BY AN EQUIVALENCE OP	?
0237    		    THEN
0243    		      E1:BEGIN
0243 7  			E:=TRUE;
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 145


0246    			FLAG(52)
0250    			END
0252 7  		    ELSE BEGIN
0254 7  		      GETATTRIBUTE;		% SCAN THE '='
0257    		      IF CLASS GEQ INV AND CLASS LEQ IOV
0263    		      THEN USE:=CLASS-INV+1
0274    		      ELSE		% IN,OUT,IO
0277    			IF CLASS NEQ ICONSTANT
0302    			THEN FLAG(20)
0310    			ELSE USE:=INREAL;
0317    		      IF NOT E
0317    		      THEN GETNEXT	% SCAN THE INITIAL VALUE
0323    		      END
0325 7  		    END
0325 6  		  ELSE E2: FLAG(REAL(E:=BOOLEAN(21)))
0333    		ELSE			% NOT MYUSE
0335    		  IF CLASS EQL TITLEV	% INITIAL TITLE
0340    		  THEN
0344    		    IF T:=NOT T		% RE DEFINED?
0344    		    THEN BEGIN
0352 6  		      GETNEXT;		% SCAN IT
0355    		      IF CLASS NEQ EQLOP
0356    		      THEN GO E1;	% ERROR
0364    		      GETNEXT;		% SCAN THE '='
0367    		      IF E:=CLASS NEQ QUOTEOP	% FOLLOWED BY A	'"'
0370    		      THEN FLAG(118)	% STRING EXPECTED
0400    		      ELSE BEGIN
0404 7  			QUOTE;
0407    			IF BOOLEAN(LENGTH)	% LENGTH WAS ODD
0410    			THEN			% SO OK
0412    			ELSE BEGIN
0412 8  			  CONST[CLEAN-LENGTH DIV 2]:=(LENGTH+2)DIV 2;
0426    			  CONST[CLEAN+1]:=0
0434    			  END;
0436 8  			EMITL(LENGTH)
0440    			END
0442 7  		      END
0442 6  		    ELSE GO E2		% WAS RE-DEFINED !
0446    		  ELSE			% NOT TITLE
0446    		    IF CLASS EQL MAXRECV
0451    		    THEN
0455    		      IF M:=NOT	M	% RE-DEFINED?
0455    		      THEN BEGIN	% NO
0463 6  			GETNEXT;	% SCAN IT
0466    			IF CLASS NEQ EQLOP
0467    			THEN GO	E1;
0475    			GETNEXT;	% SCAN IT TOO!
0500    			IF E:=CLASS NEQ	ICONSTANT	% NOT INTEGER CONSTANT
0501    			THEN FLAG(38)	% ICONSTANT EXPECTED
0511    			ELSE BEGIN
0515 7  			  MAX:=INREAL;	% GET VALUE
0520    			  GETNEXT
0521    			  END
0523 7  			END
0523 6  		      ELSE GO E2	% RE-DEFINED
0527    		    ELSE		% NOT EITHER
0527    		      IF CLASS NEQ KINDV	% NOT EVEN KIND	AND THAT'S NOT NICE
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 146


	IT WAS NECESSARY TO REDUCE THE SIZE OF THE LISTING FILE TO MAKE
	FIT ON A SINGLE DEC-TAPE. THIS WAS ONE OF THE PAGES THAT VOLUNTEERED
	TO GO.
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 147


1033    	      P:=NAME;		% THIS IS WHERE	THE DEFAULT EXTERNAL NAME IS
1037    	      POLISH:=NEWCARD;	% SAVE THIS BOOLEAN ALSO
1040    	      NEWCARD:=FALSE;
1043    	      POLISH:=CLASS;	% SAVE 'CAUSE QUOTE WILL DESTROY IT
1044    	      QUOTE;		% GET IT OUT.
1047    	      CLASS:=POLISH;	% RE-STORE OLD CLASS
1051    	      NEWCARD:=POLISH;	% OLD NEW-CARD VALUE
1053    	      EMITL(LENGTH);	% AND ITS LENGTH
1057    	      END;
1063 4  	    EMITL(KND);		% FILE KIND
1067    	    EMITL(MAX);		% MAX REC SIZE
1073    	    EMITL(MAXSIZ);	% MAXRECNO
1077    	    EMITL(USE);		% MYUSE
1103    	    EMITL(REAL(OWNTOG));% ALLOW	FOR OWN	FILES
1107    	    EMITPAIR(2,COM);	% BUILD	A DESCRIPTOR
1114    	    SAVEIT:=*+26;	% 8 FOR	SYSTEM FIB; 16 FOR ALGOL FIB
1121    L1:	    END
1121 3  	  UNTIL	CLASS NEQ COMMA
1122    	  END OF FILE DECLARATIONS;
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 148


OMIT 2  @O
OMIT    	E X T E R N A L   S Y M B O L   T A B L E   F O R M A T
OMIT    	= = = = = = = =   = = = = = =   = = = = =   = = = = = =
OMIT
OMIT
OMIT    	THIS IS HERE BECAUSE IT HAS NO BETTER PLACE TO BE.
OMIT
OMIT    	THE FORMAT OF THE EXTERNAL SYMBOL TABLE IS RELATIVELY STRAIGHT
OMIT    	FORWARD. THE EXTERNAL SYMBOL TABLE IS COMPOSED OF ONE OR MORE
OMIT    	ENTRYS. EACH ENTRY DESCRIBES ONE IDENTIFIER. THE FORMAT OF AN
OMIT    	ENTRY IS AS FOLLOWS.
OMIT
OMIT    	   THE FIRST WORD IS THE LENGTH OF THE ENTRY IN WORDS. THIS
OMIT    	LENGTH INCLUDES THIS WORD IN ITS COUNT.
OMIT
OMIT    	   THE NEXT PART OF THE ENTRY IS THE SYMBOL NAME. THE FORMAT
OMIT    	OF THE SYMBOL NAME IS IDENTICAL TO THE FORMAT OF SYMBOL NAMES
OMIT    	IN THE REGULAR SYMBOL TABLE.
OMIT
OMIT    	   THE NEXT WORD CONTAINS THE CLASS TYPE AND THE EXTERNAL INFO
OMIT    	BITS. THE FORMAT OF THIS WORD IS IDENTICAL TO THE FORMAT OF THE
OMIT    	FIRTS WORD OF A SYMBOL INFO BLOCK.
OMIT
OMIT    	   THE NEXT WORD IS THE ADDRESS OF THE SYMBOL IN THE PRT. THIS
OMIT    	IS THE ADDRESS WHICH MUST GET RELOCATED FROM/TO WHEN THIS
OMIT    	SYMBOL IS BOUND.
OMIT
OMIT    	   IF THE SYMBOL IS AN ARRAY IDENTIFIER, THEN THERE ARE TWO MORE
OMIT    	WORDS. THE FIRST CONTAINS THE # OF DIMENSIONS AND IS IDENTICAL
OMIT    	TO THE FOURTH WORD OF THE ARRAY IDENTIFIER INFO BLOCK. THE SECOND
OMIT    	WORD CONTAINS THE CLASS OF THE ARRAY AND IS IDENTICAL TO THE
OMIT    	FIFTH WORD OF THE ARRAY DESCRIPTOR BLOCK. THESE TWO WORDS ARE PUT
OMIT    	HERE BASICALLY TO GAURANTEE THAT A TWO DIMENSIONAL ARRAY GETS
OMIT    	BOUND INTO A TWO DIMENSIONAL ARRAY AND THE SAME FOR A ONE DIMEN-
OMIT    	SIONAL ARRAY.
OMIT
OMIT    	   IF THE SYMBOL IS A PROCEDURE DECLARATION (EITHER TYPED OR
OMIT    	UNTYPED) THEN THERE ARE A FEW WORDS FOLLOWING. THERE ARE TWO
OMIT    	CASES.
OMIT    		CASE 1: ALL PARAMETERS ARE INTEGER BY VALUE.
OMIT    			THERE IS ONLY ONE WORD IN THIS CASE. IT IS THE
OMIT    			NUMBER OF PARAMETERS. IF THERE ARE NO PARAMETERS
OMIT    			THEN THIS WORD WILL CONTAIN A ZERO.
OMIT    		CASE 2: ALL OTHER CASES.
OMIT    			THERE ARE N PLUS TWO (N+2) WORDS FOLLOWING.
OMIT    			THE FIRST WORD IS A MINUS ONE (-1).
OMIT    			THE NEXT N WORDS ARE THE CLASS TYPES AND CALL
OMIT    			BY NAME/VALUE INDICATORS. BIT #15 INDICATES
OMIT    			THAT THE PARAMETER IS BY NAME IF ON, AND BY
OMIT    			VALUE IF OFF. BITS [14:15] IS THE CLASS OF THE
OMIT    			PARAMETER.
OMIT    			THE N+2ND WORD IS A ZERO.
OMIT
OMIT    	   THE EXTERNAL SYMBOL TABLE IS TERMINATED BY AN ENTRY OF ZERO
OMIT    	LENGTH. IE. A SINGLE ZERO (0).
1126    @O
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 149


1126
                            FILEDEC(135) IS 1127 LONG, NEXT SEGMENT 001 ********
0513    	PROCEDURE PURGEIT;		% CLEANS DECLARATIONS OF THIS LEVEL
   001335-P = PURGEIT
0513    					% OUT OF SYMBOL TABLE
0513    					% 'I' POINTS TO THE INDEX BELOW
0513    					% ANYTHING TO BE FREED.
0513    	BEGIN
0513 2  	  INTEGER T,R,C,P,PT,J;		% TEMPS AND POINTERS AND STUFF.
                                                 PURGEIT IS SEGMENT 136 ********
   030005-S = T
   030006-S = R
   030007-S = C
   030010-S = P
   030011-S = PT
   030012-S = J
0003    	  BOOLEAN B;			% FOR FASTERNESS.
   030013-S = B
0003    	  LABEL EXIT;
0003    	  IF ENTRYCOUNT EQL 0	% NOTHING TO TAKE OUT!
0007    	  THEN GO EXIT;		% SO DONT DO ANY THING.
0014    	  DO			% JUST ONE BIG LOOP.
0014    				% CYCLE THRU USER HASH TABLE.
0014    	    IF T:=SCRAMBLEDEGGS[J] GTR SYMBOLTABLESIZE	% IS THERE SOME HASH?
0021    	    THEN				% YUP.
0025    	      DO		% A SECOND BIG LOOP.
0025    				% FOLLOW LINKS OF SYMBOL TABLE ENTRIES.
0025    				% LOOK AT EACH ENTRY AND DETERMINE
0025    				% IF IT SHOULD GO.
0025    		IF R:=STACK[T+1] > I	% IS THE INFO BLOCK BEYOUND
0034    					% WHERE WE WILL CUT THE SYMBOL TABLE
0034    					% BACK TO?
0034    		THEN BEGIN		% YES ==> THIS ID MUST GO.
0040    		  % GET CLASS INTO 'C' AND SEE IF PROCEDURE OR LABEL.
0040 3  		  IF (B:=C:=REAL(BOOLEAN(STACK[R]) AND BOOLEAN(255)) GEQ
0047    			 PROCID AND C LEQ INTPROCID) OR C EQL LABELID
0060    		  THEN			% IT IS. WELL WHATDAYANO!
0065    		    IF
0065    		      % NOW SEE IF PROCEDURES WERE DECLARED FORWARD
0065    		      % AND NOT DEFINED OR LABELS DECLARED AND USED BUT
0065    		      % NOT DEFINED.
0065    		      IF B
0065    		      THEN STACK[R+1] LEQ 0	% FORWARD PROC NOT DCLED.
0076    		      ELSE STACK[R+1] EQL 10000	% LABEL NOT DECLARED
0107    				AND
0110    			REAL(BOOLEAN(STACK[R+4])OR BOOLEAN(STACK[R+5]))
0123    				NEQ 0		% BUT USED ANY WAYS.
0124    		    THEN BEGIN		% WELL TELL THE USER WHAT'S WRONG.
0130    		      % PUT THE NAME IN THE A ARRAY WHERE 'FLAG' WANTS IT.
0130 4  		      REPLACE A BY POINTER(STACK[T+2]) FOR
0146    			(LINSTR:=REAL(BOOLEAN(STACK[T+2])AND BOOLEAN(255))
0155    			    -"0")+SKAN:=1;	% RESET 'SKAN' FOR FLAG.
0167    		      POLISH:=LASTCOL;	% SAVE LASTCOL IN CASE OTHER ERRORS.
0170    		      LASTCOL:=10;		% PRINT NAME IN COL 10.
0173    		      FLAG(64+REAL(B));		% FLAG THE NAME.
0201    		      LASTCOL:=POLISH		% RECOVER LASTCOL.
0201    		      END;
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 150


0203 4  		  IF P:=STACK[R+3] LSS 0		% REVERT PARAM BY NAME TOG.
0213    		  THEN P:=REAL(NOT BOOLEAN(P))
0220    		  ELSE
0222    		    IF P GEQ EXTERNALSIZE	% IS ID AN EXTERNAL?
0225    		    THEN BEGIN		% MOVE SOME INFO OUT TO EXTERNAL
0231    					% SYMBOL TABLE.
0231 4  		      INTEGER N,TEMP:=EI;	% TO FORCE A NEW SEGMENT.
   001341-P = B.0018
                                                  B.0018 IS SEGMENT 137 ********
   030016-S = N
0001    					% WANT TO KEEP PURGEIT SMALL AS CAN.
   030017-S = TEMP
0002    		      P:=P-EXTERNALSIZE;	% RESTORE THE LINK.
0011    		      REPLACE ESTACK[EI+1] BY POINTER(STACK[T+2]) FOR
0041    			% MOVE THE NAME.
0041    			N:=REAL(BOOLEAN(STACK[T+2])AND BOOLEAN(255))-"0"+1;
0060    		      ESTACK[EI+SHR(N+3,1)]:=STACK[R];	% STORE CLASS.
0076    		      ESTACK[EI:=*+1]:=STACK[R+1];	% SAVE ADDRESS FOR BINDER
0112    		      IF C GEQ PROCID AND C LEQ INTPROCID
0116    		      THEN BEGIN	% EXTERNAL PROC.
0123 5  			IF N:=STACK[R+4] LSS CLASSMAX	% ALL BY VALUE?
0132    			THEN ESTACK[EI:=*+1]:=N		% YES.
0143    			ELSE BEGIN
0150 6  			  N:=*-1;		% BACK UP TO BEFORE THE (-1)
0152    			  % COPY ENTIRE PACKED LIST STARTING WITH THE (-1)
0155    			  DO T:=ESTACK[EI:=*+1]:=STACK[N:=*+1]
0164    			  % AND ENDING WITH THE (0)
0167    			  UNTIL T EQL 0
0177    			  END
0202 6  			END
0202 5  		      ELSE		% NOT A PROC.
0202    			IF C EQL ARRAYID	% HOW ABOUT ARRAY ID?
0205    			 THEN BEGIN		% YEP.
0211    			  % COPY THE 2 ARRAY DESCRIPTOR WORDS.
0211 5  			  ESTACK[EI+1]:=STACK[R+4];
0223    			  ESTACK[EI:=*+2]:=STACK[R+5]
0233    			  END;
0237 5  		      ESTACK[TEMP]:=(EI:=*+1)-TEMP	% STORE LENGTH
0245    		      END OF EXTERNAL PACKING;
                             B.0018(137) IS 0263 LONG, NEXT SEGMENT 136 ********
0245 4  		  IF STACK[T+1]:=P EQL 0	% ANY MORE OTHER OCCURENCES
0253    						% OF THIS ID?
0254    		  THEN				% NO ==> TAKE OUT OF HASHISH TABLE.
0257    		    IF SCRAMBLEDEGGS[J] EQL T	% POINTED TO BY USER'S HASH?
0262    		    THEN SCRAMBLEDEGGS[J]:=STACK[T]	% YES. LINK OVER IT.
0270    		    ELSE STACK[PT]:=STACK[T];		% OTHER WISE LINK AROUND IT.
0304    		    IF ENTRYCOUNT:=*-1 EQL 0		% DONE YET?
0312    		    THEN GO EXIT			% YEP. THEN EXIT.
0317    		  END
0317    	      % GET NEXT LINK, SAVE THIS LINK, AND SEE IF DONE.
0317 3  	      UNTIL T:=STACK[T] LEQ SYMBOLTABLESIZE
0326    	  % LOOP UNTIL TRIED ALL 64 HASH TABLE ENTRIES.
0326    	  UNTIL J:=*+1 GTR 63;
0343    EXIT:	  END OF PURGEIT;
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 151


OMIT 2  @O
OMIT    	E X T E R N A L   D E C L A R A T I O N S
OMIT    	= = = = = = = =   = = = = = = = = = = = =
OMIT
OMIT    	I'M NOT SURE WHY I CHOSE TO PUT THIS HERE. THE INFORMATION
OMIT    	IN THIS SECTION PERTAINS TO VARIOUS DIFFERENT TYPES OF
OMIT    	EXTERNAL DECLARATIONS.
OMIT
OMIT    	   ANY VARIABLE, OTHER THAN A PROCEDURE, MAY BE DECLARED TO BE
OMIT    	EXTERNAL AT ANY LEVEL SIMPLY BY PREFIXING THE DECLARATION WITH
OMIT    	THE WORD 'EXTERNAL'. ALL EXTERNAL DECLARATIONS ARE ALLOCATED
OMIT    	ARE ALLOCATED STORAGE IN THE PRT EVEN THOUGH THE SCOPE OF THE
OMIT    	IDENTIFIER IS LOCAL TO THE BLOCK IN WHCH IT IS DECLARED.
OMIT
OMIT    	   BINDABLE PROCEDURES DECLARED TO BE EXTERNAL MUST BE DECLARED
OMIT    	AT LEVEL 1 AND PREFIXED BY THE RESERVED WORD 'EXTERNAL' OR MUST
OMIT    	BE COMPILED SEPARATELY.
OMIT
OMIT    	   A BINDABLE PROCEDURE SOURCE PROGRAM WHICH IS COMPILED
OMIT    	SEPARATELY HAS THE FOLLOWING SYNTAX:
OMIT    		[<TYPE>] PROCEDURE <NAME> [<PARAMETER-LIST>] ;
OMIT    		[ <FORMAL-PARAMETER DECLARATIONS> ]
OMIT    		[ <PROCEDURE-BODY>] <END-THING>
OMIT
OMIT    	     WHERE <END-THING>::= ; ! .
OMIT
OMIT    	     IE. IT MAY BE FOLLOWED BY EITHER A SEMICOLON OR A PERIOD.
OMIT
OMIT
OMIT    	   THE DECLARATION FOR A PROCEDURE WHICH IS TO BE BOUND IN LATER
OMIT    	IS IDENTICAL TO A FORWARD PROCEDURE DECLARATION WITH THE RESERVED
OMIT    	WORD 'EXTERNAL' IN PLACE OF THE RESERVED WORD 'FORWARD'.
OMIT
OMIT    	   EXTERNAL DECLARATIONS IN A BINDABLE PROCEDURE (IE. ONE
OMIT    	DECLARED WITH THE PREFIXED RESERVED WORD 'EXTERNAL') GERERATE
OMIT    	NO CODE. THE REASON FOR THIS SHOULD BE OBVIOUS. THEY ARE NOT
OMIT    	BEING DECLARED HERE, MERELY DEFINED SO THAT THEY MAY BE
OMIT    	REFERENCED. HENCE THE FOLLOWING RESTRICTION APPLIES TO THESE
OMIT    	DECLARATIONS. IF THE DECLARATION IS A BOOLEAN, INTEGER, REAL,
OMIT    	OR POINTER IT MAY NOT HAVE AN INITIAL VALUE OPTION, IT MAY
OMIT    	NOT BE ADDRESS EQUATED TO ANY THING ELSE (OTHER VARIABLES,
OMIT    	THOUGH, MAY BE ADDRESS EQUATED TO IT).
OMIT    	IF THE DECLARATION IS A TRUTHSET IT DOES NOT HAVE A TRUTHSET-BODY,
OMIT    	IF THE DECLARATION IS A FILE, IT DOES NOT HAVE INITIAL ATTRIBUTES.
OMIT    	NO EXTERNAL DECLARATIONS MAY BE DECLARED OWN OR SAVE.
OMIT    	A BINDABLE PROCEDURE MAY NOT BE DECLARED TO BE EXTERNAL.
OMIT    	IE. EXTERNAL PROCEDURE FOO; EXTERNAL; IS INVALID.
0343    @O
                            PURGEIT(136) IS 0344 LONG, NEXT SEGMENT 001 ********
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 152


0513    PROCEDURE PROCDEC(X);
   001345-P = PROCDEC
0513    	VALUE X;
0513    	INTEGER	X;
0513    	BEGIN
0513 2  	BOOLEAN	LOCALO:=LOCAL,ETOG:=EXTERNALTOG,ECTOG:=EXTERNALCODE,F;
                                                 PROCDEC IS SEGMENT 140 ********
   030005-S = LOCALO
   030006-S = ETOG
   030007-S = ECTOG
   030010-S = F
0005    	INTEGER	T,TPC,PINFO,PLIST,P,J,EC,STACKCT:=STACKCTR,LASTIO:=LASTI;
   030011-S = T
   030012-S = TPC
   030013-S = PINFO
   030014-S = PLIST
   030015-S = P
   030016-S = J
   030017-S = EC
   030020-S = STACKCT
   030021-S = LASTIO
0011    	LABEL L1;
0011    	LOCAL:=FALSE;
0016    	STACKCTR:=LOCALSPACE;
0021    	IF OWNTOG THEN FLAG(11);
0030    	IF EXTERNALTOG AND LEVEL NEQ 1
0033    	THEN BEGIN
0037 3  	  FLAG(125);	% EXTERNAL PROCEDURES MUST BE DECLARED AT LEVEL 1.
0043    	  EXTERNALTOG:=FALSE
0044    	  END;
0046 3  	IF FUNCTION AND LEVEL EQL 1	% IS THIS EXTERNALLY DECLARED?
0051    	THEN EXTERNALTOG:=TRUE;		% YES.
0060    	STOPDEFINE:=TRUE;	% ALLOW	NAME OF	PROC NOT TO GET	EXPANDED
0063    	GETNEXT;		% GET NAME
0066    	REPLACE PS BY A+1 FOR LINSTR," " FOR 66 - T;
0102
0106    	IF CLASS GEQ PROCID AND	% SEE IF FORWARD DECLARATION
0111    		? EXTERNALTOG AND	% NOT GLOBAL
0114    		STACK[INFO+2] =	LEVEL AND % IN THIS LEVEL
0124    		 CLASS LEQ INTPROCID AND ADDRESS < 0
0132    	THEN BEGIN	% YES. DONT ENTER INTO THE SYMBOL TABLE
0136 3  	  STACK[(PINF:=INFO)+1]:=- ADDRESS;% FIX ADDRESS (- ADDRESS ==> FORWARD
0147    	  GETNEXT;		% SCAN THE NAME	BECAUSE	ENTRY WOULD DO IT
0152    	  F:=TRUE;		% SET FORWARD TOG TO TRUE
0155    	  END
0155 3  	ELSE BEGIN		% REGULAR DEC.
0157 3  	  IF FUNCTION		% WE HAVE TO GET THIS IN THE EXTERNAL TABLE.
0157    				% DONT SET BOTH EXTERNALTOG AND OWNTOG.
0157    	  THEN OWNTOG:=NOT EXTERNALTOG;	% TO FAKE OUT ENTRY.
0166    	  CLASSF:=X;
0171    	  ADDRESSF:=GETSPACE(1);	% GET PLACE FOR	DESCRIPTOR IN PRT
0200    	  ENTRY; PINF:=INF; I:=I + 2;% PUT IN THE SYMBOL TABLE
0213    	  END;
0213 3  	REPLACE PS+T BY 0 FOR 1;  % PUT NULL IN FOR BLOK
0230    	EC:=ENTRYCOUNT;	% SAVE # OF ENTRIES INTO SYM TABLE SO FAR.
0233    	T:=LASTI;	% SAVE SYMBOL TABLE POINTER AND PROC ADDRESS
0240    	PROADDRESS:=STACK[PINF+1];
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 153


0247    	IF NOT F	% ONLY DO THIS THE FIRST TIME.
0247    	THEN STACK[PINF].[14:1]:=REAL(EXTERNALTOG);	% SET THE DEFINED BIT.
0264    	EXTERNALCODE:=* OR EXTERNALTOG;	% SAVE FOR THE REST OF US.
0271    	EXTERNALTOG:=OWNTOG:=FALSE;	% RESET	EXTERNAL TOG
0276    	PINFO:=PINF;	% SAVE IN CASE OF RECURSION.
0301    	J:=ENTRYCOUNT:=0;	% # OF PARAMS ENCOUNTERED THUS FAR
0306    	IF CLASS = LFTPAREN THEN	  % WE HAVE PARAMS
0313    	BEGIN
0313 3  	  INTEGER C,D,SP,OLDCLASS,D1,DIMCODE,LBDIM1,LBDIM2;
   001351-P = B.0019
                                                  B.0019 IS SEGMENT 141 ********
   030024-S = C
   030025-S = D
   030026-S = SP
   030027-S = OLDCLASS
   030030-S = D1
   030031-S = DIMCODE
   030032-S = LBDIM1
   030033-S = LBDIM2
0002    	  BOOLEAN AA,B,MINUS;
   030034-S = AA
   030035-S = B
   030036-S = MINUS
0002    	  LABEL	L1,L2,L3,EXIT;
0002    	  LABEL	S0,S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,L6,S12A;
0002    	  SWITCH SW:=S1,S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12A;
0034    	  LEVEL:=LEVEL + 1;		% ENTER	PARAMS IN THE NEXT LEVEL
0043    	  PLIST:=STACK[P:=PINF+4];	% POINT	TO POINTER IN DATA BLOCK OF PROC NAM
0054    	  CLASSF :=ADDRESSF:=0;
0061    	  DO BEGIN	% ENTER	NAME OF	EACH PARAM INTO	THE SYMBOL TABLE
0061 4  	    STOPDEFINE:=TRUE;	% STOP EXPANSION OF NAMES
0064    	    GETNEXT;		% GET ID
0067    	    ENTRY;		% ADD TO SYMTABLE
0072    	    STACK[STACK[P]:=P:=I+5]:=0;	% LINK UP TO PREVIOUS PARAMETER
0107    	    J:=J+1		% # OF PARAMS
0111    	    END
0114 4  	  UNTIL	CLASS NEQ  COMMA OR J >= CLASSMAX;
0125    	  LEVEL:=LEVEL - 1;		% DROP LEVEL BACK TO OUR LEVEL
0132    	  TPC:=J;	% TRUE PARAMETER COUNT:=J FOR	STARTERS
0132    			% ARRAY	PARAMETERS WILL	BUMP THIS
0135    	  IF J >= CLASSMAX THEN	ERROR(92) ELSE	% TOO MANY PARAMS
0146    	  IF CLASS NEQ RTPAREN THEN FLAG(6) ELSE GETNEXT;	% NO ')'
0166    	  IF CLASS NEQ SEMICOLON THEN FLAG(7) ELSE % NO	';' AFTER PARAM	LIST
0177    	  GETNEXT;		% SCAN THE ';'
0204    	  IF CLASS = VALUEV	% VALUE	DECLARATIONS?
0205    	  THEN BEGIN		% YES
0211 4  	    DO BEGIN		% SCAN THE ENTIRE VALUE	LIST
0211 5  	      GETNEXT;		% GET ID
0214    	      IF CLASS NEQ 0 OR	STACK[INFO+2] NEQ LEVEL+1  % IN	PARAM LIST?
0226    	      THEN FLAG(8)	% NO. ERROR
0235    	      ELSE		% SET VALUE TOG.
0237    		IF P:=STACK[INFO+3] GEQ 0	% SET YET ?
0251    		THEN STACK[INFO+3]:=REAL(NOT BOOLEAN(P));  % SET IT
0263    	      GETNEXT;		% SEE IF FOLLOWED BY A ','
0266    	      END
0266 5  	    UNTIL CLASS	NEQ COMMA;
0273    	    IF CLASS NEQ SEMICOLON
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 154


0274    	    THEN ERROR(9)
0302    	    ELSE
0304    	      L1: GETNEXT;
0311    	    END;
0311 4  	  B:=FALSE;		% RESET	NAME TOG
0314    	  GO TO	SW[CLASS-BEGINV];	% SEE WHAT KIND	OF DECLARATION WE GOTS
0337    	  GO TO	L2;		% DONE !
0341    S1:	  C:=BOOID; 	GO TO S0;
0346    S2:	  C:=REALID;	GO TO S0;
0353    S3:	  C:=INTID;
0356    S0:	  GETNEXT;	% SEE IF PROC DECLARATION OR ARRAY DECLARATION
0361    	  IF CLASS = PROCEDUREV		% TYPED	PROCEDURE PASSED THRU
0362    	  THEN BEGIN
0366 4  	    C:=PROCID+C-INTPROCID;
0375    	    GO TO S12
0377    	    END
0377 4  	  ELSE		% NOW SEE IF TYPED ARRAY
0377    	    IF CLASS EQL ARRAYV	% YES
0402    	    THEN BEGIN
0406 4  	      OLDCLASS:=C;
0411    	      C:=ARRAYID;
0414    	      GO TO S12		% MUST BE NAME
0416    	      END;
0416 4  	  AA:=AA OR C NEQ INTID;	% A INDICATED ALL PARAMS INTEGER
0425    	  GO TO	L6;
0427    S4:	  IF A[0] = "8E" THEN GO TO L2;	% EXTERNAL FOR PROC NOT	PARMS => DON
0441    	  FLAG(IF A[0] = "3O" THEN 11 ELSE 12); % PARAMS CANNOT BE SAVE OR OWN
0460    	  GO TO	L1;		% TRY AGAIN
0462    S5:	  % LABELS. NOT	IMPLEMENTED YET%  C:=LABELID;	GO TO S13;
0462    	  % LABELS CAN BE NAME OR VALUE
0462    S6:	  % SWITCHES NOT IMPLEMENTED YET EITHER	% C:=SWITCHID;GO S12;
0462    	  % MUST BE NAME
0462    S7:	  C:=ARRAYID;	% ARRAY'S
0465    	  OLDCLASS:=INTID;	% DE-FALUT CLASS OF ARRAYS IS INTEGER
0466    %%%%%%%	  OLDCLASS:=REALID;	% DE-FAULT CLASS OF ARRAYS IS REAL
0470    	  GO TO	S12;	% MUST BE NAME ALSO
0472    S8:	  GO TO	L2;	% PARAMS CANNOT	BE DEFINES => DONE
0474    S9:	  C:=FILEID;	% FILES
0477    	  GO TO	S12;	% MUST BE NAME ALSO
0501    S10:	  C:=PROCID;	% SO MUST PROC IDS
0504    	  GO S12;
0506    S12A:	  C:=TRUTHID;	% TRUTHSET PASSED IN
0507    			% BETTER BE BY NAME
0511    S12:	  B:=AA:=TRUE;	% SET NAME TOG.	RE-SET ALL VALUE INTEGER TOG.
0516    	  GO L3;	% SCAN THE SPECIFICATION LIST
0520    S11:	  C:=STRINGID;	% POINTERS CAN BE EITHER
0523    S13:	  AA:=TRUE;	% RE-SET INTEGER-VALUE TOG
0526    L3:	  P:=0;		% USED OCCATIONALLY FOR	A LINK POINTER
0531    	  DO BEGIN	% SCAN THE IDENTIFIER LIST
0531 4  	    GETNEXT;	% GET IDENTIFIER IN SPECIFICATION LIST
0534    L6:	    IF CLASS NEQ 0 OR STACK[INFO+2] NEQ	LEVEL+1
0545    	    % EITHER NOT FORMAL	PARAMETER OR REDEFINED
0546    	    THEN FLAG(3)
0555    	    ELSE STACK[INFO]:=C;	% STORE	SPECIFYCATION TYPE IN ID BLOCK
0565    	    IF C=ARRAYID
0566    	    THEN BEGIN
0572 5  	      STACK[INFO+4]:=P;	TPC:=TPC+1; P:=INFO;	% LINK THEM UP
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 155


0610    	      END
0610 5  	    ELSE
0610    	      IF C GEQ PROCID AND C LEQ	INTPROCID
0616    	      THEN STACK[INFO+4]:=STACK[INFO+5]:=0;% NO	PARAMS ON PROCS	PASSED
0636    	    IF B AND STACK[INFO+3] < 0	% VALUED AND MUST BE NAME
0645    	    THEN BEGIN	% UN-VALUE THEM
0651 5  	      FLAG(10);	STACK[INFO+3]:=-STACK[INFO+3]-1END;
0672 5  	    SP:=SP+(IF STACK[INFO+3] < 0	% IF VALUE THEN	REALS
0700    		% GET 2	WORDS, POINTERS	GET 3 (1 FOR LINK)
0701    		    THEN REAL(C	EQL REALID)+REAL(C EQL STRINGID)*2
0713    		    ELSE 0) + 1;	% OTHER	CALL BY	VALUE GET 1
0725    	    GETNEXT
0726    	    END
0730 4  	  UNTIL	CLASS NEQ COMMA;
0735    	  IF BOOLEAN(D1:=REAL(C	EQL ARRAYID))	% UNLINK THE ARRAY ID'S
0742    	  THEN BEGIN
0744 4  	    LABEL L5;
   001355-P = MARKSTACK DESCRIPTOR FOR LEVEL 3
   001356-P = B.0020
                                                  B.0020 IS SEGMENT 142 ********
0000    	    IF CLASS NEQ LFTBRKT	% SHOULD BE A '['
0003    	    THEN BEGIN
0007 5  	      ERROR(15);		% '[' EXPECTED
0013    	      GO L5
0015    	      END
0015 5  	    ELSE GETNEXT;
0022    	    DIMCODE:=0;
0025    	    IF CLASS NEQ FACTOP		% BOTTOM NOT RE-DEFINED	?
0026    	    THEN BEGIN
0032 5  	      IF MINUS:=CLASS EQL SUBOP	% NEGATIVE BOTTOM LIMIT
0033    	      THEN GETNEXT;
0044    	      IF CLASS NEQ ICONSTANT	% SHOULD BE INTEGER CONSTANT
0045    	      THEN FLAG(38);
0055    	      DIMCODE:=2;	% 1ST DIM RE-MAPPED
0060    	      LBDIM1:=IF MINUS THEN -INREAL ELSE INREAL	 % LOWER BOUND
0067    	      END;
0072 5  	    GETNEXT;		% SCAN TO NEXT THINGIE
0075    	    IF CLASS EQL COMMA	% 2-DIM.
0076    	    THEN BEGIN
0102 5  	      D1:=2;		% SET 2	DIM INDICATOR
0105    	      DIMCODE:=DIMCODE+1;% SET 2-DIM BIT
0112    	      GETNEXT;		% SCAN THE COMMA
0115    	      IF CLASS EQL FACTOP	% NO RE-MAP OF ROWS
0116    	      THEN
0122    	      ELSE BEGIN
0122 6  		IF MINUS:=CLASS	EQL SUBOP	% NEGATIVE LL
0123    		THEN GETNEXT;
0134    		IF CLASS NEQ ICONSTANT	% LOWER	LIMIT NOT A CONSTANT
0135    		THEN FLAG(38);
0145    		DIMCODE:=DIMCODE+4;	% SET RE-MAP 2ND DIM BIT
0152    		LBDIM2:=IF MINUS THEN -INREAL ELSE INREAL
0161    		END;
0164 6  	      GETNEXT			% SCAN THE 2ND DIM LB
0165    	      END;
0167 5  L5:	    DO BEGIN
0167 5  	      STACK[P+7]:=LBDIM2;	% LOWER	BOUND 2
0175    	      STACK[P+6]:=LBDIM1;	% LOWER	BOUND OF 1ST DIM
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 156


0203    	      STACK[P+5]:=OLDCLASS;	% TYPE OF ARRAY
0211    	      P:=STACK[4+D:=P];		% GET LINK
0222    	      STACK[D+4]:=DIMCODE;	% STORE	OUR CODE THERE
0230    	      SP:=SP+D1			% UPDATE STACK SPACE COUNTER
0231    	      END			% 1 WORD FOR EACH DIMENSION
0235 5  	    UNTIL P EQL	0;	% LOOP UNTIL DONE LINK LIST
0242    	    IF CLASS NEQ RTBRKT	THEN ERROR(17) ELSE GETNEXT;
0260    	    IF CLASS = COMMA THEN GO TO	L3;
0301    	    END;
                             B.0020(142) IS 0312 LONG, NEXT SEGMENT 141 ********
0755 4  	  IF CLASS = SEMICOLON THEN GO TO L1;
0764    	  ERROR(1);
0770    L2:	  D:=SP+1; C:=0;% MAX ADDRESS OFFSET (PLUS 1)
1000    	  IF F THEN	% CHECK	PARAMETER COUNT
1003    	    IF PLIST LSS CLASSMAX AND PLIST NEQ J OR
1012    		PLIST GTR CLASSMAX AND STACK[PLIST+TPC+1] NEQ 0
1025    	    THEN BEGIN
1032 4  	      FLAG(25);	% FORWARD REF DESAGREES	WITH ACTUAL DECLARATION
1036    	      F:=FALSE
1037    	      END;
1041 4  	  STACK[1+P:=PINF+4]:=SP;% # OF	WORDS FOR PROC PARAMS
1053    	  DO BEGIN		% ASSIGN ADDRESKIES TO EACH PARAM
1053 4  	    STACK[(SP:=STACK[P]-8)+1]:=3"34002"+D:=D-1;	% SET ADDRESS
1075    	    IF D1:=STACK[SP] = 0  % ID NOT IN SPECIFYCATION LIST
1103    	    THEN BEGIN
1106 5  	      FLAG(83);
1112    	      STACK[SP]:=INTID;	% DEFAULT TO INTEGER
1116    	      END
1116 5  	    ELSE
1116    	      IF STACK[SP+3] LSS 0	% VALUE
1126    	      THEN			% SEE IF MULTI WORD PARAMS
1131    		IF D1 EQL REALID OR B:=D1 EQL STRINGID
1135    		THEN STACK[SP+1]:=3"34002"+D:=D-1-REAL(B)% FIX UP ADDRESS
1154    		ELSE			% SEE IF ARRAYS
1162    	      ELSE
1162    		IF D1 EQL ARRAYID	% FIX ADDRESS AND LEAV ROOM
1165    		THEN STACK[SP+1]:=3"34002"+D:=
1175    			D-REAL(BOOLEAN(STACK[SP+4]) AND	TRUE) -	1;
1207    	% INVERT TOGGLE	FROM VALUE TO NAME
1215    	    IF STACK[SP+3]:=REAL(NOT BOOLEAN(STACK[SP+3])) < 0
1231    	    THEN AA:=TRUE;		% RESET	ALL-VALUE TOG
1237    	    IF F
1237    	    THEN BEGIN		% CHECK	SPECIFICATIONS WITH FORWARD
1242 5  	      IF PLIST < CLASSMAX
1243    	      THEN BEGIN	% INTEGER CALL BY VALUE
1247 6  		IF STACK[SP] NEQ INTID
1252    		THEN FLAG(26);		% SPECIFYCALION	DISAGREES IN CLASS
1262    		IF STACK[SP+3] < 0
1270    		THEN FLAG(27);		% SPECIFYCATION	DISAGREES IN REFERENCE
1277    		END
1277 6  	      ELSE BEGIN
1301 6  		IF STACK[SP] NEQ STACK[PLIST+C:=C+1].[13:14]
1320    		THEN FLAG(26);		% NOT BOTH SAME	TYPE OF	CALL
1327    		IF STACK[SP+3].[15:1] NEQ STACK[PLIST+C].[15:1]
1347    		THEN FLAG(27);		% DIFFERENT CLASS TYPES
1356    		IF STACK[PLIST+C].[13:14] EQL ARRAYID
1366    		THEN BEGIN
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 157


1372 7  		  IF REAL(BOOLEAN(D1:=STACK[PLIST+C:=C+1]) AND BOOLEAN(255))
1407    			NEQ STACK[SP+4]		% DIFFERENT DECLARATIONS
1412    		  THEN FLAG(110);	% # OF DIMS OR ROW DESIGNATION DIFFERENT
1423    		  IF SHR(D1,8) NEQ STACK[SP+5]	% DIFFERENT TYPES OF ARRAYS
1431    		  THEN FLAG(109);
1442    		  END;
1442 7  		END;
1442 6  	      END
1442 5  	    END
1442 4  	  UNTIL	STACK[P:=STACK[P]] EQL 0;    % LOOP UNTIL LAST POINTER IS 0
1455    	  IF NOT AA		% IF ALL INTEGER AND VALUE THEN
1455    	  THEN STACK[PINF+4]:=J;	% SUPER	PACK LIST
1466    EXIT:	  END
1466 3  	ELSE BEGIN
                             B.0019(141) IS 1477 LONG, NEXT SEGMENT 140 ********
0334 3  	  STACK[PINF+4]:=STACK[PINF+5]:=0;	% NO PARAMS
0347    	  IF CLASS NEQ SEMICOLON
0350    	  THEN FLAG(5);
0360    	  GETNEXT
0361    	  END;
0363 3  	IF CLASS = EXTERNALV
0364    	THEN BEGIN
0370 3  	  INTEGER P1,P2;
   001362-P = B.0021
                                                  B.0021 IS SEGMENT 143 ********
   030024-S = P1
   030025-S = P2
0002    	  EPROC:=TRUE;
0007    	  IF ETOG
0007    	  THEN FLAG(14)
0014    	  ELSE
0016    	    IF STACK[PINF+3] < EXTERNALSIZE
0025    	    THEN STACK[PINF+3]:=STACK[PINF+3]+EXTERNALSIZE;
0045    	  STACK[PINF].[13:1]:=0;	% INDICATE NOT LOCAL.
0057    	  GETNEXT
0060    	  END
0062 3  	ELSE
                             B.0021(143) IS 0073 LONG, NEXT SEGMENT 140 ********
0401    	  IF CLASS = FORWARDV
0404    	  THEN BEGIN
0410 3  	    STACK[PINF+1]:=-STACK[PINF+1];	% TOG ADDRESS => FORWARD DEC
0423    	    GETNEXT		% SEE IF FOLLOWED BY SEMI-COLON
0424    	    END
0426 3  	  ELSE
0426    	    IF CLASS = BEGINV
0431    	    THEN BEGIN
0435 3  	      POLISH:=BEGINCTR;
0436    	      BEGINCTR:=*+1;		% FOR THE BENIFIT OF THE LISTING.
0443    	      GETNEXT;		% SCAN THE 'BEGIN'
0446    	      BEGINCTR:=POLISH;
0450    	      BLOK(REAL(LOCAL:=TRUE))	% PROC WITH BLOCK
0454    	      END
0456 3  	    ELSE BLOK(2);		% PROC WITH STATEMENT
0464    	IF FUNCTION AND LEVEL EQL 1
0467    	THEN
0473    	  IF CLASS NEQ SEMICOLON AND CLASS NEQ DOTOP
0477    	  THEN FLAG(42)
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 158


0506    	  ELSE
0510    	ELSE
0510    	  IF CLASS NEQ SEMICOLON
0513    	  THEN FLAG(42)
0521    	  ELSE GETNEXT;
0526    	% RESTORE ALL THE ORIGIONAL UN-NESTED THINGS
0530    	EXTERNALCODE:=ECTOG;
0533    	LOCAL:=LOCALO;
0536    	STACKCTR:=STACKCT;
0541    	LASTI:=LASTIO;
0544    	I:=T;		% GET ORIGIONAL SYMBOLTABLE POINTER.
0544    	% COLAPSE SYMBOLTABLE.
0547    	PURGEIT;
0552    	ENTRYCOUNT:=EC;	% UNSTACK THE # OF SYM TABLE ENTRIES.
0552    	% COLASPE PLIST	TABLE
0555    	IF P:=STACK[PINFO+4] > CLASSMAX
0564    	THEN BEGIN		% WE HAVE TABLE
0570 3  	  T:=STACK[PINFO+4]:=I+1;		% WHERE	TO MARK	TOP OF LIST
0575    						% FOR ACTUALPARAPART
0604    	  DO BEGIN
0604 4  	    STACK[I+1]:=(J:=STACK[P-8])+3"100000"*	% SAVE CLASS
0621    		    REAL(STACK[P-5] <0);		% AND NAME TOG
0634    	    IF J EQL ARRAYID		% SAVE INFO ON ARRAYS
0635    	    % SAVE TYPE	AND DIM	INFO
0635    	    THEN STACK[I+1]:=SHL(STACK[P-3],8)+STACK[P-4];
0665    	    END
0665 4  	  UNTIL	P:=STACK[P] = 0;
0676    	  STACK[T]:=-1;		% MARK TOP OF LIST
0703    	  STACK[I+1]:=0	% END OF LIST
0711    	  END
0713 3  	END OF PROCEDURE DECLARATIONS;
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 159


0713 2  %
0713    % *** DECLARATION	HANDLES	DECLARATIONS
0713    %
                            PROCDEC(140) IS 0715 LONG, NEXT SEGMENT 001 ********
0513    PROCEDURE DECLARATION;
0513    	BEGIN
0513 2  	LABEL START,L1,L2,L3,L4,L5,L6,L7,L8,L9,L10,L11,L12,LF,LLS,EXIT;
                                             DECLARATION IS SEGMENT 144 ********
0001    	LABEL LE,LSW;
0001    	SWITCH SW:=L1,L2,L3,L4,L5,L6,L7,L8,L9,L10,L11,L12;
0033    START:	ERRORTOG:=TRUE;
0040    	CLASSF:=REAL(EXTERNALTOG:=OWNTOG:=SAVETOG:=LONGTOG:=FALSE);
0053    LSW:	GO TO SW [CLASS	- BEGINV];
0076    	GO EXIT;
0100    L1:	CLASSF:=BOOID;	GO LF;
0105    L2:	%	CLASSF:=REALID;	GO LF;	% REALS	TREATED	AS INTEGERS FOR	A WHILE
0105    L3:	CLASSF:=INTID;	GO LF;
0112    L4:	IF LINSTR=8 THEN EXTERNALTOG:=TRUE ELSE
0122    	IF LINSTR EQL 3
0126    	THEN OWNTOG:=TRUE
0132    	ELSE
0134    	  IF A[0] EQL "4S"
0142    	  THEN SAVETOG:=TRUE
0146    	  ELSE LONGTOG:=TRUE;
0155    	IF OWNTOG AND EXTERNALTOG THEN FLAG(14);
0166    	GETNEXT;
0171    	IF CLASS LSS BOOLEANV OR CLASS GTR TRUTHSETV THEN
0202    		BEGIN ERROR(14); GO LLS; END;
0211    	GO LSW;
0213    L5:	CLASSF:=LABELID; STOPDEFINE:=TRUE; GETNEXT;
0224    	ADDRESSF:=10000; GO LE;
0231    L6:	SWITCHDEC;	GO LLS;
0236    L7:	ARRAYDEC;	GO LLS;
0243    L8:	DEFINEDEC;	GO LLS;
0250    L9:	FILEDEC;	GO LLS;
0255    L10:	PROCDEC(PROCID); GO START;
0263    L11:	POINTERDEC;	GO LLS;
0270    L12:	TRUTHSETDEC;	GO LLS;
0275    LF:	STOPDEFINE:=TRUE;
0300    	GETNEXT;
0303    	IF CLASS=PROCEDUREV
0304    	THEN BEGIN
0310 3  	  PROCDEC(CLASSF-3);
0316    	  GO TO	START;
0320    	  END;
0320 3  	IF CLASS = ARRAYV THEN GO TO L7;
0327    LE:	ENTER;
0330    %$ PROCEDUREV=32 REALPROCID=3
0332    LLS:	IF CLASS NEQ SEMICOLON
0333    	THEN ERROR(1)
0341    	ELSE GETNEXT;			% SCAN THE ';'
0350    	GO START;
0352    EXIT:	END;
0352 2
0352
                        DECLARATION(144) IS 0353 LONG, NEXT SEGMENT 001 ********
0513    PROCEDURE MOVECODE;
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 160


0513    	BEGIN
0513 2  	IF NOT NOCODEFILE
                                                MOVECODE IS SEGMENT 145 ********
0003    	THEN
0006    	IF WRITE(CODE[DA],REAL(BOOLEAN(L+127) AND BOOLEAN(3"177400")),EDOC)
0020    	THEN ERROR(122);
0033    	DA:=DA+SHR(L+127,8);
0044    	END;
                           MOVECODE(145) IS 0046 LONG, NEXT SEGMENT 001 ********
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 161


0513 2  PROCEDURE BLOK(X);
0513    	VALUE X;
0513    	INTEGER	X;
0513    	BEGIN
0513 2  	LABEL L1,L2;
                                                    BLOK IS SEGMENT 146 ********
0001    	INTEGER	ARRAY SPC[0:32],TEDOC[0:2047];
   030010-S = SPC
   030015-S = TEDOC
0023    	BOOLEAN LOCALO:=LOCAL,B,SAVET;
   030017-S = LOCALO
   030020-S = B
   030021-S = SAVET
0026    	INTEGER	STACKCT,LOLD,T,J,PRO,SGNOO,P,C,POLISH,Z,ADRSO:=ADRS,THISL:=WCL,
   030022-S = STACKCT
   030023-S = LOLD
   030024-S = T
   030025-S = J
   030026-S = PRO
   030027-S = SGNOO
   030030-S = P
   030031-S = C
   030032-S = POLISH
   030033-S = Z
   030034-S = ADRSO
   030035-S = THISL
0030    		THISWC:=WORKCELLCOUNT,EC:=ENTRYCOUNT,LASTIO:=LASTI;
   030036-S = THISWC
   030037-S = EC
   030040-S = LASTIO
0033    	OWN INTEGER BLOCKCTR:=3"177777";
   001366-P = BLOCKCTR
0033    	ADRSR[LEVEL*2]:=IF X = 0 THEN ADRS ELSE	0;
0055    	BEGINCTR:=BEGINCTR+REAL(X NEQ 2);
0064    	LOCAL:=LEVEL NEQ CLASSF:=ENTRYCOUNT:=0;	% BUILD DECLARATIONS IN THE STA
0066    						% IF A NESTED BLOCK OR PROC.
0075    	IF X GTR 0
0077    	THEN REPLACE Q:SPC BY PS UNTIL EQL 0
0110    	ELSE REPLACE Q:SPC BY "B.",(BLOCKCTR:=*+1) FOR 4 DIGITS;
0135    	Z:=66-DELTA(SPC,Q);	% GET LENGTH.
0152    	IF B:=X GEQ 1 OR LEVEL	= 0
0157    	THEN ADRS:=PROADDRESS
0165    	ELSE BEGIN
0172 3  	  LOLD:=L;		% SAVE CURRENT L
0175    	  L:=WCL;		% TO GO	BACK TO	BUILD THE WORK-CELLS
0200    	  IF WORKCELLCOUNT EQL 0  % NONE !
0202    	  THEN EMITB(BRUN,L+2,L+2)
0215    	  ELSE EMITPAIR(WORKCELLCOUNT,BPS);
0230    	  L:=LOLD;		% BACK TO WHERE	WE WERE
0233    	  THISWC:=0;		% RE-INITIALIZE
0236    	  EMIT(MKS);
0242    	  IF LEVELS[LEVEL] EQL 0
0246    	  THEN BEGIN
0251 4  	    IF PRTTOG
0251    	    THEN REPLACE PS BY "MARKSTACK DESCRIPTOR FOR LEVEL",
0263    		ZS(LEVEL,3-REAL(LEVEL < 10)), " " FOR 33+REAL(LEVEL < 10);
0305    	    LEVELS[LEVEL]:=GETSPACE(1);
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 162


0315    	    IF EXTERNALCODE OR NOT FUNCTION	% ALWAYS PUT IN THE HOST.
0316    	    THEN BEGIN
0323 5  	      REPLACE ESTACK[EI+1] BY "5.MD",LEVEL FOR 2 DIGITS;
0351    	      ESTACK[EI+4]:=INTID;		% MAKE EXTERNAL.
0357    	      ESTACK[EI+5]:=LEVELS[LEVEL];
0367    	      EI:=*+ESTACK[EI]:=6
0372    	      END
0377 5  	    END;
0377 4  	  EMITO(LEVELS[LEVEL]);
0405    	  EMITO(0);
0411    	  EMITD(LEVELS[LEVEL]);	EMIT(STD);
0423    	  IF PRTTOG
0423    	  THEN REPLACE PS BY SPC FOR 33 WORDS;
0435    	  CLASSF:=PROCID;		% GET SPACE FOR	A PROC
0440    	  EMITD(ADRS:=GETSPACE(1));
0452    	  EMIT(ENTR);
0456    	  IF EXTERNALCODE	% IS THIS AN EXTERNAL BLOK?
0456    	  THEN BEGIN	% YEP. ADD TO EXTERNAL SYMBOL TABLE.
0461 4  	    REPLACE POINTER(ESTACK[EI+1]) BY "6",SPC FOR 6;
0507    	    ESTACK[EI]:=8;
0513    	    ESTACK[EI+5]:=PROCID+3"20000";
0523    	    ESTACK[EI+6]:=ADRS;
0531    	    ESTACK[EI+7]:=0;	% NO PARAMETERS.
0537    	    EI:=*+8
0541    	    END;
0544 4  	  PROADDRESS:=0
0545    	  END;
0547 3  	ERRORTOG:=TRUE;
0552    	IF SAVET:=SAVETOG
0552    	THEN BEGIN
0557 3  	  EMITD(ADRS);
0563    	  EMIT(SAV)
0565    	  END;
0567 3  	IF CLEAN NEQ 0 THEN
0574    	BEGIN LOLD:=BUMPL; CLEANIT; EMITB(BRUN,LOLD,L) END;
0614    	IF LEVEL:=LEVEL + 1 >	31 THEN	FLAG(23);
0631    	STACKCT:=STACKCTR; LOLD:=L; SGNOO:=SGNO;
0645    	IF X EQL 0	% DONT LET PARAMETERS GET RE-DECLARED.
0647    	THEN LASTI:=I;
0660    	REPLACE LINEOUT BY " " FOR MAX(0,Z-10),
0702    	  SPC FOR MIN(66-Z,56)," IS SEGMENT ",
0727    	  O3(SGAVL)," ********";
0741    	WRITEALINE(40);
0745    	SGNO:=SGAVL; SGAVL:=SGAVL + 1;
0755    	SWAP(TEDOC,EDOC);
0760    	IF B
0760    	THEN BEGIN
0763 3  	  EMITL(LEVEL);			% LEVEL	OF PROCEDURE DECLARATION
0767    	  IF LEVEL NEQ 1		% NOT MAIN BLOCK !
0771    	  THEN
0774    	    IF J:=STACK[PINF+4]	GTR CLASSMAX	% PARAMS TOO !
1003    	    THEN
1007    	      DO			% SEE IF ANY ARE POINTER BY VALUE
1007    		IF STACK[J-8] EQL STRINGID AND	% POINTER
1016    		   STACK[J-5] GEQ 0		% BY VALUE
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 163


1024    		THEN BEGIN
1030 4  		  EMITL(0);		% OWNTOG IS FALSE
1034    		  EMITD(STACK[J-7]+2);	% ADDRESS OF POINTER LINK
1046    		  EMIT(PLNK)		% LINK 'EM UP
1050    		  END
1052 4  	      UNTIL J:=STACK[J]	EQL 0	% UNTIL	LAST PARAMETER !
1060    	  END
1063 3  	ELSE ADRSR[LEVEL*2]:=STACKCTR:=STACKCTR+2;
1101    	WCL:=L;		% SAVE WORK-CELL ALLOCATOR SPACE
1104    	BUMPL;
1111    	WORKCELLCOUNT:=0;
1114    	IF X NEQ 2		% NOT A	BLOCK
1116    	THEN BEGIN
1121 3  	  PRO:=PROADDRESS;	% SAVE PROGRAM ADDRESS FOR RECURSION
1124    	  L:=*-2;		% DECLARATIONS GO BEFORE THE WORK CELLS.
1131    	  DECLARATION;		% SCAN THE DECLARATIONS
1134    	  WCL:=L;		% NOW ALLOCATE THE WORK CELLS!
1137    	  BUMPL;
1144    	  PROADDRESS:=PRO;	% UN RE-CURSE OURSELVES
1147    	  BEGINCTR:=BEGINCTR-1;	% BEGIN	COUNTER	WAS RAISED PRIOR TO OUR	CALL
1154    	  COMPOUNDTAIL		% COMPOUND TAIL	WILL UP	THE BEGIN COUNT
1155    	  END
1157 3  	ELSE STMT;
1164    	POLISH:=L;		% SAVE CURRENT PC
1167    	L:=WCL;			% GO BACK TO BUILD THE WORK-CELLS
1172    	IF WORKCELLCOUNT EQL 0	% NONE !
1174    	THEN EMITB(BRUN,L+2,L+2)
1207    	ELSE EMITPAIR(WORKCELLCOUNT,BPS);
1222    	WORKCELLCOUNT:=THISWC;	% UN STACK FROM	PREVIOUS LEVEL
1225    	WCL:=THISL;		% BOTH OF THESE
1230    	L:=POLISH;		% BACK TO WHERE	WE WERE
1233    	IF LEVEL EQL 1		% MAIN BLOCK
1235    	THEN EMITPAIR(5,COM)	% SYSTEM EXIT
1243    	ELSE BEGIN
1247 3  	  IF X EQL 0		% NOT A	PROC
1251    	  THEN BEGIN
1254 4  	    EMITO(STACKCT+2);	% GET OLD MARK STACK FOR THIS LEVEL
1262    	    EMITD(LEVELS[LEVEL-1]);	% AND RESET MARK STACK CONTROL WORD
1272    	    EMIT(STD);
1276    	    EMITL((1+WCL:=LOLD)*2);	% ADDRESS GOING	TO IN NEXT BLOCK
1310    	    EMITD(ADRSO);	% ADDRESS OF LAST SEGMENT (OUTER BLOCK)
1314    	    EMITL(0);		% INDICATE SUCH	TO GO-TO-SOLVER
1320    	    EMITPAIR(9,COM);	% RE-SET THE STACK
1325    	    LOLD:=LOLD+2	% FOR WORK-CELL	ALLOCATOR
1327    	    END;
1332 4  	  EMIT(RTN)		% RETURN TO OUTER BLOCK
1334    	  END;
1336 3  	CONSTANTCLEAN;		% CLEAN	OUT ANY	CONSTANTS
1346    	SATBLDR(ADRS,DA);	% PUT INFO FOR THIS BLOCK IN THE PRT TABLE
1353    	MOVECODE;
1356    	REPLACE LINEOUT BY " " FOR MAX(0,Z-31),
1400    	  SPC FOR MIN(66-Z,35),"(",O3(SGNO),") IS ",
1437    	  O4(L)," LONG, NEXT SEGMENT ",O3(SGNOO)," ********";
1463    	WRITEALINE(40);
1467    	SWAP(TEDOC,EDOC);
1472    	IF L GTR MAXSEG	THEN MAXSEG:=L;
1502    	TOTSEG:=TOTSEG+L;
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 164


1507    	VM:=VM+L;
1514    	IF SAVETOG:=SAVET THEN SAVEIT:=SAVEIT+L;
1526    	STACKCTR:=STACKCT; SGNO:=SGNOO; L:=LOLD;
1537    	LOCAL:=LOCALO; ADRS:=ADRSO;
1545    	IF SHR(MAXI,1) LSS SHR(I,1)
1553    	THEN MAXI:=I;		% MAXIMUM DEPTH	OF SYMTABLE
1561    	I:=T;			% RESET	STACK POINTER
1564    	IF X EQL 0		% FROM .MAIN.
1566    	THEN BEGIN		% THIS IS A NESTED BLOCK.
1571 3  	  PURGEIT;		% CLEAN THE SYMBOL TABLE.
1574    	  ENTRYCOUNT:=EC	% UNSTACK THE # OF SYM TABLE ENTRIES.
1574    	  END
1577 3  	ELSE ENTRYCOUNT:=*+EC;	% PROCDEC WILL CLEAN THE SYMBOL TABLE.
1602    				% SO TOTAL THE # OF SYM TABLE ENTRIES.
1606    	LASTI:=LASTIO;
1611    	LEVEL:=LEVEL - 1
1613    	END;
                               BLOK(146) IS 1730 LONG, NEXT SEGMENT 001 ********
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 165


0513 2  BOOLEAN	PROCEDURE FILENAMESCAN(A);
0513    	ARRAY A[0];
0513    	BEGIN
0513 2  	  TRUTHSET SEPARATORS("[,<=/" OR 0),
                                            FILENAMESCAN IS SEGMENT 147 ********
   030014-S = SEPARATORS
0011    		   STOPPERS(",<=" OR 0),
   030024-S = STOPPERS
0021    		   PERIODS("." OR 0),
   030034-S = PERIODS
0031    		   RIGHTBRACKETS("]" OR	0);
   030044-S = RIGHTBRACKETS
0041    	  LABEL	L1;
0041    	  POINTER PT;
   030047-S = PT
0047    	  A[0]:=0;		% NO UIC YET.
0062    	  Q:=POINTER(STR);
0066    L1:	  REPLACE Q:Q BY IFP:IFP UNTIL IN SEPARATORS;
0100    	  IF IFP EQL "["
0102    	  THEN BEGIN
0110 3  	    REPLACE A BY IFP:IFP UNTIL IN RIGHTBRACKETS,
0121    	      IFP:IFP FOR 1, 0 FOR 1;
0141    	    GO L1
0152    	    END;
0152 3  	  REPLACE Q BY 0 FOR 1;
0165    	  IF IFP EQL "/"
0167    	  THEN SCAN IFP:IFP+1 UNTIL IN STOPPERS;	% SCAN OUT OPTIONS !
0205    	  IF FILENAMESCAN:=DELTA(STR,Q)	<> 0
0217    	  THEN BEGIN		% CHECK	OUT THE	EXTENSION PART
0224 3  	    SCAN PT:STR UNTIL IN PERIODS;
0232    	    EXTENSION:=PT EQL "."
0234    	    END
0242 3  	  END;
0242 2
0242
                       FILENAMESCAN(147) IS 0250 LONG, NEXT SEGMENT 001 ********
0513    INTEGER	PROCEDURE OPTION;
   001367-P = OPTION
0513    	BEGIN
0513 2  	  TRUTHSET STOPPERS(",/<=" OR 0),
                                                  OPTION IS SEGMENT 150 ********
   030014-S = STOPPERS
0011    		   SLASHES("/" OR 0);
   030024-S = SLASHES
0021    	  SCAN IFP:IFP UNTIL IN SLASHES;
0031    	  IF IFP EQL "/"		% WE FOUND AN OPTION !
0033    	  THEN BEGIN
0041 3  	    OPTION:=REAL(IFP+1,1);	% GET IT'S VALUE
0051    	    SCAN IFP:IFP+1 UNTIL IN STOPPERS
0057    	    END
0061 3  	  END;
                             OPTION(150) IS 0067 LONG, NEXT SEGMENT 001 ********
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 166


0513 2  	TRUTHSET SPACING(SPACES	OR 0);
   001373-P = SPACING
0513    	LABEL WRAPUP,MP,NADZ,TRYAGAIN,L1,L2,L3,L4,L5,AGAIN;
0513    	BOOLEAN	BMP,TOG;
   001403-P = BMP
   001404-P = TOG
0513    	INTEGER	T,R;
   001405-P = T
   001406-P = R
0513    TRYAGAIN:
0515    	REPLACE	CSI BY "ALGOL  V0",REVNO FOR 1,".",SHR(REVNO,8)	FOR 1,
0551    		"." UPDATE,3"12" FOR 1,3"15" FOR 1,"#",3"200" FOR 1;
0616    	WRITE(TTY[0],10,CSI);			% ASK FOR COMMAND STRING
0630    	READ(TTY,39,CSI);
0643    	T:=0;			% DEPTH OF INDIRECT FILE NESTING.
0646    AGAIN:	IFP:=Q:=POINTER(CSI);
0654    	DO BEGIN	% TAKE SPACES AND TABS OUT OF COMMAND STRING
0654 2  	  REPLACE IFP:IFP BY Q:Q UNTIL IN SPACING;
0666    	  SCAN Q:Q+1 WHILE IN SPACES
0674    	  END
0676 2  	UNTIL REAL(Q,1)	EQL 0;
0706    	REPLACE	IFP BY 0 FOR 2;		% TO TERMINATE THE FILE-NAME SCANNER
0721    	IF IFP:=POINTER(CSI) EQL "@"	% CHECK FOR INDIRECT FILE SPECIFICATION.
0725    	THEN			% LOOKS LIKE WE HAVE ONE!
0733    	  IF T:=*+1 GTR 5	% ALLOW AT MOST 5 LEVELS.
0741    	  THEN BEGIN		% WOOPS. HE BLEW IT!
0744 2  	    REPLACE STR BY "INDIRECT FILE NESTED MORE THAN 5";
0753    	    WRITE(TTY,16,STR);
0766    	    GO TRYAGAIN
1040    	    END
1040 2  	  ELSE BEGIN		% NOW TO CHECK IT OUT.
1042 2  	    REPLACE CARDIN.TITLE BY IFP+1;% USE CARD FILE TO GET COMMAND STRING
1062    	    IF CARDIN.PRESENT		% SEE IF FILE EXISTS
1062    	    THEN BEGIN			% YES. GOOD.
1070 3  	      READ(CARDIN,39,CSI);	% READ IN NEW COMMAND STRING
1103    	      CLOSE(CARDIN);		% CLOSE FILE.
1111    	      GO AGAIN			% TRY AGAIN. (MIGHT BE ANOTHER INDIRECT).
1113    	      END
1113 3  	    ELSE BEGIN		% INDIRECT FILE WAS NOT PRESENT
1115 3  	      REPLACE STR BY " " FOR 42;
1124    	      REPLACE STR BY "INDIRECT FILE ",CARDIN.TITLE," NOT PRESENT";
1147    	      WRITE(TTY,24,STR);	% TELL HIM OFF.
1162    	      GO TRYAGAIN	% LET HIM TRYAGAIN.
1206    	      END
1206 3  	    END;
1206 2  	% SCAN FOR SWITCHES
1206    	% INIT THINGS (INCASE OF RESTART)
1206    	EIGHTYCOL:=FORMOPTION:=NOT
1206    	PRTTOG:=COMPILEANDGO:=EOPTION:=DEBUGTOG:=CRUNCHOPTION:=FALSE;
1226    	WHILE T:=OPTION	> 0 DO
1240    	BEGIN
1240 2  	  LABEL	SCREW, EXIT;
   001407-P = MARKSTACK DESCRIPTOR FOR LEVEL 1
   001410-P = B.0022
                                                  B.0022 IS SEGMENT 151 ********
0000    	  IF T<67 OR T>80 THEN GO SCREW;
0015    	  CASE T-67 OF BEGIN
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 167


0023 3  	    5-8: 10-12:	GO SCREW;
0025    	    0: CRUNCHOPTION:=TRUE;
0032    	    1: DEBUGTOG:=PRTTOG:=TRUE;
0041    	    2: EOPTION:=TRUE;
0046    	    3: FORMOPTION:=FALSE;
0053    	    4: COMPILEANDGO:=TRUE;
0060    	    9: EIGHTYCOL:=FALSE;
0065    	   13: PRTTOG:=TRUE;
0072    	  END;
0112 3  	  GO EXIT;
0114    	SCREW:
0114    	  REPLACE STR BY "ERROR ... ILLEGAL SWITCH.";
0123    	  WRITE(TTY,12,STR);	% PRINT THE ERROR MESSAGE.
0136    	  GO TRYAGAIN;		% AND TRYAGAIN.
0152    	EXIT:
0152    	END;
                             B.0022(151) IS 0201 LONG, NEXT SEGMENT 001 ********
1253 2  	IFP:=POINTER(CSI);
1257    	IF FILENAMESCAN(A)
1267    	THEN BEGIN
1273 2  	  REPLACE Q BY ".ALG" FOR 4*(1-REAL(EXTENSION)),
1306    		A UNTIL EQL 0, 0 FOR 1;
1324    	  REPLACE CODE.TITLE BY	POINTER(STR);
1342    	  NOCODEFILE:=FALSE	% ASSIGN TO NOCODEFILE IN CASE 2ND TIME	AROUND
1343    	  END
1345 2  	ELSE NOCODEFILE:=NOT COMPILEANDGO:=FALSE;
1355    	IF IFP EQL ","
1357    	THEN BEGIN
1365 2  	  IFP:=*+1;
1372    	  IF FILENAMESCAN(A)
1402    	  THEN BEGIN
1406 3  	    REPLACE Q BY ".LST" FOR 4*(1-REAL(EXTENSION)),
1421    		A UNTIL EQL 0, 0 FOR 1;
1437    	    REPLACE LINE.TITLE BY POINTER(STR);
1455    	    NOLISTFILE:=FALSE;		% IN CASE HE BLEW CSI 1ST TIME
1460    	    LINE.KIND:=VALUE(ASCII)
1462    	    END
1466 3  	  ELSE GO L1
1505    	  END
1505 2  	ELSE BEGIN
1507 2  	  L1: NOLISTFILE:=NOT EIGHTYCOL:=FALSE;
1515    	  LINE.KIND:=VALUE(KB)
1517    	  END;
1523 2  	IF IFP EQL "<" OR IFP EQL "="
1533    	THEN BEGIN
1542 2  	  P:=IFP:=*+1;
1552    L4:	  IF FILENAMESCAN(A)
1562    	  THEN BEGIN
1566 3  	    IF NOT EXTENSION
1566    	    THEN BEGIN
1571 4  	      REPLACE Q	BY ".SRC", A UNTIL EQL 0, 0 FOR	1;
1616    	      REPLACE CARDIN.TITLE BY STR;
1634    	      IF NOT CARDIN.PRESENT
1634    	      THEN GO L3
1653    	      END
1653 4  	    ELSE BEGIN
1655 4  	      L3: REPLACE Q BY A UNTIL EQL 0, 0 FOR 1;	% FIX UP NAME
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 168


1675    	      REPLACE CARDIN.TITLE BY STR;	% GET NAME
1713    	      IF NOT CARDIN.PRESENT		% SEE IF ON DISK.
1713    	      THEN BEGIN
1721 5  		REPLACE STR BY " " FOR 78;
1730    		REPLACE STR BY "FILE ",CARDIN.TITLE," NOT PRESENT.";
1753    		WRITE(TTY,39,STR);
1766    		GO TRYAGAIN
2011    		END
2011 5  	      END
2011 4  	    END
2011 3  	  ELSE GO L2;
2015    	  IF IFP EQL ","	% MORE THAN ONE INPUT FILE?
2017    	  THEN BEGIN		% YEP.
2025 3  	    IFP:=*+1;		% SCAN THE ","
2032    	    GO L4		% SEE IF THIS FILE AROUND.
2035    	    END
2035 3  	  ELSE			% SEE IF DONE SCANNING THE INPUT STRING
2035    	    IF REAL(IFP,1) NEQ 0	% DONE?
2044    	    THEN BEGIN		% BAD CHARACTER!
2047 3  	      REPLACE STR BY "ILLEGAL CHARACTER IN INPUT STRING.";
2056    	      WRITE(TTY,17,STR);
2071    	      GO TRYAGAIN
2115    	      END
2115 3  	  END
2115 2  	ELSE BEGIN
2117 2  	  L2: REPLACE STR BY "ERROR ... MISSING INPUT FILE. ";
2126    	  WRITE(TTY,15,STR);
2141    	  GO TRYAGAIN
2163    	  END;
2163 2  	IFP:=P;		% RE-SCAN THE FILE NAME STRING.
2167    	FILENAMESCAN(A);
2202    L5:	REPLACE Q BY ".SRC" FOR 4*(1-REAL(EXTENSION)),
2215    	    A UNTIL EQL 0,0 FOR 1;
2233    	REPLACE CARDIN.TITLE BY STR;
2251    	IF NOT CARDIN.PRESENT	% MUST BE THE ONE WITH A NULL EXTENSION.
2251    	THEN BEGIN
2257 2  	  EXTENSION:=TRUE;	% FOR ABOVE!
2262    	  GO L5
2271    	  END;
2271 2  	TIME1:=60*TIME(2)+TIME(1);	% TIME AT START	OF COMPILE
2304    	IF EIGHTYCOL THEN LINE.MAXRECSIZE:=40
2311    	  ELSE LINE.MAXRECSIZE:=66;
2325    	IF EOPTION THEN	NOHEADING:=TRUE	ELSE DAYTIME;
2340    	P:=CARD+72;
2344    	PGCT:=1;
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 169


2347    	FILL STACK[*] WITH 0,
                                                    DATA IS SEGMENT 152 ********
2350    	000,	IFV	, "2IF"		, %  1
2350    	167,	GOV	, "2GO"		, %  5
2350    	000,	WHILEV	, "5WHILE"	, %  9
2350    	000,	DOV	, "2DO"		, % 14
2350    	000,	FORV	, "3FOR"	, % 18
2350    	009,	WRITEV	, "5WRITE"	, % 22	(REDEFINABLE)
2350    	126,	READV	, "4READ"	, % 27	(REDEFINABLE)
2350    	161,	ELSEV	, "4ELSE"	, % 32
2350    	000,	PURGEV	, "5PURGE"	, % 37	(REDEFINABLE)
2350    	197,	HEXV	, "3HEX"	, % 42	(REDEFINABLE)
2350    	000,	OCTALV	, "5OCTAL"	, % 46	(REDEFINABLE)
2350    	218,	STEPV	, "4STEP"	, % 51
2350    	051,	TOV	, "2TO"		, % 56	(REDEFINABLE)
2350    	144,	THENV	, "4THEN"	, % 60
2350    	000,	ANDV	, "3AND"	, % 65	(REDEFINABLE)
2350    	252,	ORV	, "2OR"		, % 69	(REDEFINABLE)
2350    	000,	NOTV	, "3NOT"	, % 73	(REDEFINABLE)
2350    	106,	EQLOP	, "3EQL"	, % 77	(REDEFINABLE)
2350    	073,	NEQOP	, "3NEQ"	, % 81	(REDEFINABLE)
2350    	089,	LSSOP	, "3LSS"	, % 85	(REDEFINABLE)
2350    	000,	LEQOP	, "3LEQ"	, % 89	(REDEFINABLE)
2350    	097,	GEQOP	, "3GEQ"	, % 93	(REDEFINABLE)
2350    	539,	GTROP	, "3GTR"	, % 97	(REDEFINABLE)
2350    	000,	BEGINV	, "5BEGIN"	, %101
2350    	227,	ENDV	, "3END"	, %106
2350    	000,	UNTILV	, "5UNTIL"	, %110
2350    	000,	LABELV	, "5LABEL"	, %115
2350    	000,	BOOLEANV, "7BOOLEAN"	, %120
2350    	000,	REALV	, "4REAL"	, %126
2350    	000,	INTEGERV, "7INTEGER"	, %131
2350    	000,	EXTERNALV,"8EXTERNAL"	, %137
2350    	179,	SWITCHV	, "6SWITCH"	, %144
2350    	000,	ARRAYV	, "5ARRAY"	, %150
2350    	018,	DECIMALV, "7DECIMAL"	, %155	(REDEFINABLE)
2350    	000,	DEFINEV	, "6DEFINE"	, %161
2350    	000,	FILEV	, "4FILE"	, %167
2350    	000,	PROCEDUREV,"9PROCEDURE"	, %172
2350    	000,	TRUTH	, "4TRUE"	, %179
2350    	233,	FALSEV	, "5FALSE"	, %184
2350    	369, 	INV	, "2IN"		, %189	(REDEFINABLE)
2350    	338,	BYV	, "2BY"		, %193	(REDEFINABLE)
2350    	000,	FORWARDV, "7FORWARD"	, %197
2350    	005,	FILLV	, "4FILL"	, %203	(REDEFINABLE)
2350    	000,	WITHV	, "4WITH"	, %208	(REDEFINABLE)
2350    	000,	VALUEV	, "5VALUE"	, %213
2350    	000,	SAVEV	, "4SAVE"	, %218
2350    	000,	OWNV	, "3OWN"	, %223
2350    	000,	COMMENTV, "7COMMENT"	, %227
2350    	000,	FIELDV	, "5FIELD"	, %233
2350    	523,	CASEV	, "4CASE"	, %238	(REDEFINABLE)
2350    	247,	DIVV	, "3DIV"	, %243	(REDEFINABLE)
2350    	120,	CLOSEV	, "5CLOSE"	, %247	(REDEFINABLE)
2350    	000,	OFV	, "2OF"		, %252	(REDEFINABLE)
2350    	312,	LISTV	, "4LIST"	, %256
2350    	256,	LOCKV	, "4LOCK"	, %261	(REDEFINABLE)
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 170


2350    	060,	THRUV	, "4THRU"	, %266	(REDEFINABLE)
2350    	000,	POINTERV, "7POINTER"	, %271
2350    	000,	REPLACEV, "7REPLACE"	, %277	(REDEFINABLE)
2350    	329,	RELEASEV, "7RELEASE"	, %283	(REDEFINABLE)
2350    	293,	SHLV	, "3SHL"	, %289	(REDEFINABLE)
2350    	172,	SHRV	, "3SHR"	, %293	(REDEFINABLE)
2350    	266,	TIMEV	, "4TIME"	, %297	(REDEFINABLE)
2350    	307,	SCANV	, "4SCAN"	, %302	(REDEFINABLE)
2350    	056,	SIZEV	, "4SIZE"	, %307	(REDEFINABLE)
2350    	000,	LONGV	, "4LONG"	, %312
2350    	321,	MAXV	, "3MAX"	, %317	(REDEFINABLE)
2350    	325,	MODV	, "3MOD"	, %321	(REDEFINABLE)
2350    	115,	MINV	, "3MIN"	, %325	(REDEFINABLE)
2350    	277,	SHIFTV	, "5SHIFT"	, %329	(REDEFINABLE)
2350    	065,	ABSV	, "3ABS"	, %334	(REDEFINABLE)
2350    	000,	ADDRV	, "4ADDR"	, %338	(REDEFINABLE)
2350    	077,	DELTAV	, "5DELTA"	, %343	(REDEFINABLE)
2350    	000,	POLISHV	, "6POLISH"	, %348	(REDEFINABLE)
2350    	376,	SIGNV	, "4SIGN"	, %354	(REDEFINABLE)
2350    	243,	CHAINV	, "5CHAIN"	, %359	(REDEFINABLE)
2350    	000,	ONESV	, "4ONES"	, %364	(REDEFINABLE)
2350    	001,	FONEV	, "8FIRSTONE"	, %369	(REDEFINABLE)
2350    	302,	SWAPV	, "4SWAP"	, %376	(REDEFINABLE)
2350    	000,	TRUTHSETV,"8TRUTHSET"	, %381
2350    	208,	WORDV	, "4WORD"	, %388	(REDEFINABLE)
2350    	022,	WORDSV	, "5WORDS"	, %393	(REDEFINABLE)
2350    	343,	DIGITV	, "5DIGIT"	, %398	(REDEFINABLE)
2350    	439,	DIGITSV	, "6DIGITS"	, %403	(REDEFINABLE)
2350    	150,	487	, "5ALPHA"	, %409	(PRE-DEFINED TRUTHSET)	A-Z,0-9
2350    	046,	475	, "7NUMERIC"	, %414	(PRE-DEFINED TRUTHSET)	0-9
2350    	000,	511	, "7SPECIAL"	, %420	(PRE-DEFINED TRUTHSET)
2350    	359,	463	, "9ALPHAONLY"	, %426	(PRE-DEFINED TRUTHSET)	A-Z
2350    	271,	459	, "7PRTBASE"	, %433	(PRE-DEFINED INTEGER ID)
2350    	032,	499	, "<ALPHANUMERIC",%439	(PRE-DEFINED TRUTHSET)	A-Z,0-9
2350    	000,	454	, "6TOGGLE"	, %448	(PRE-DEFINED BOOLEAN ID)
2350
2350    		BOOPROCID,17,0,0,0	, %454	(DEFINITION OF TOGGLE)
2350    		INTID,0,0,0		, %459	(DEFINITION OF PRTBASE)
2350    		TRUTHID,18,0,0		, %463	ALPHAONLY
2350    		    0,0,0,0		, %467
2350    		    3"177776",3"3777"	, %471	(UPPER CASE)
2350    		    3"177776",3"3777"	, %473	(LOWER CASE)
2350    		TRUTHID,26,0,0		, %475	NUMERIC
2350    		    0,0,0,3"1777",0,0,0,0,%479	(NUMBERS)
2350    		TRUTHID,34,0,0		, %487	ALPHA
2350    		    0,0,0,3"1777"	, %491	(NUMBERS)
2350    		    3"177776",3"3777"	, %495	(UPPER CASE)
2350    		    3"177776",3"3777"	, %497	(LOWER CASE)
2350    		TRUTHID,34,0,0		, %499	ALPHANUMERIC
2350    		    0,0,0,3"1777"	, %503	    DITTO AS ABOVE
2350    		    3"177776",3"3777"	, %507
2350    		    3"177776",3"3777"	, %509
2350    		TRUTHID,42,0,0		, %511	SPECIAL
2350    		    0,0,3"177776",3"176000",%515
2350    		    1,3"174000",1,3"174000",%519
2350    	014,	BINARYV	, "6BINARY"	, %523	(REDEFINABLE)
2350    	000,	ZEROSUPV, ">ZEROSUPPRESSED",%529(REDEFINABLE)
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 171


2350    	184,	COMPILTIMEV,";COMPILETIME"; %539(REDEFINABLE)
                               DATA(152) IS 1043 LONG, NEXT SEGMENT 001 ********
2354    		SYMBOLTABLESIZE:=I:=546;	% SYMBOL TABLE STACK POINTER
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 172


2361    	FILL ATTRIBUTEDHASH[*] WITH	% CLASS	(3,F) RESERVED WORDS
                                                    DATA IS SEGMENT 153 ********
2362    					% (CONTEXT SENSITIVE).
2362    	004,	IOV	, "2IO"		, %000
2362    	008,	INV	, "2IN"		, %004
2362    	012,	OUTV	, "3OUT"	, %008
2362    	017,	DISKV	, "4DISK"	, %012
2362    	023,	TTYV	, "6REMOTE"	, %017
2362    	028,	DISKV	, "5ASCII"	, %023
2362    	034,	BINV	, "6BINARY"	, %028
2362    	039,	KINDV	, "4KIND"	, %034
2362    	044,	TEKTV	, "4TEKT"	, %039
2362    	050,	LPV	, "7PRINTER"	, %044
2362    	054,	LPV	, "2LP"		, %050
2362    	060,	PRESENTV, "7PRESENT"	, %054
2362    	065,	OPENV	, "4OPEN"	, %060
2362    	070,	MYUSEV	, "5MYUSE"	, %065
2362    	075,	TITLEV	, "5TITLE"	, %070
2362    	082,	MAXSIZEV, "8MAXRECNO"	, %075
2362    	091,	CURRECV	, "<CURRENTRECNO",%082
2362    	099,	MAXRECV	, ":MAXRECSIZE"	, %091
2362    	103,	TTYV	, "3TTY"	, %099
2362    	107,	TTYV	, "2KB"		, %103
2362    	000,	TTYV	, "2TT"		; %107
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 173


2362    	% POINTER TO RESERVED WORDS FOR	SPEEDER	LOOK UP
                               DATA(153) IS 0157 LONG, NEXT SEGMENT 001 ********
2366    	FILL SAUSAGE[*]	WITH		% HASHING TABLE	FOR RESERVED WORDS
                                                    DATA IS SEGMENT 154 ********
2367    	000,000,000,000,000,000,000,000,000,271,126,172,051,000,060,
2367    	000,000,000,000,000,000,000,000,000,271,126,172,051,000,060,
2367    	000,000,000,000,000,000,000,000,000,271,126,172,051,000,060,
2367    	000,000,000,000,000,000,000,000,000,271,126,172,051,000,060,
2367    	000,000,000,000;
2367
                               DATA(154) IS 0100 LONG, NEXT SEGMENT 001 ********
2373    	FILL SCRAMBLEDEGGS[*] WITH	% HASHING TABLE	FOR REDEFINEABLES AND IDENTI
                                                    DATA IS SEGMENT 155 ********
2374    	155,203,093,137,042,189,000,000,000,000,131,312,085,261,317,
2374    	000,000,529,000,000,334,193,409,000,101,238,426,000,398,403,
2374    	420,448,110,381,213,388,393,000,000,000,000,000,000,000,000,
2374    	000,081,069,223,364,414,000,037,348,433,027,289,354,283,297,
2374    	000,000,000,000;
2374
                               DATA(155) IS 0100 LONG, NEXT SEGMENT 001 ********
2400    	FILL SPECIAL[*]	WITH		% HASHING TABLE	FOR SPECIAL CHARACTERS
                                                    DATA IS SEGMENT 156 ********
2401    	LFTBRKT, MULOP,	RTBRKT,	NOTV, ASSIGNOP,	0, ORV,	QUOTEOP, POUND,
2401    	0, 0, AMPER, 0,	LFTPAREN, RTPAREN, FACTOP, ADDOP, COMMA, SUBOP,
2401    	DOTOP, DIVOP, 0, 0, 0, 0, 0, 0,	0, 0, 0, 0,
2401    	COLON, SEMICOLON, LSSOP, EQLOP,	GTROP, NOTV;
                               DATA(156) IS 0045 LONG, NEXT SEGMENT 001 ********
2405    	FILL OP	WITH
                                                    DATA IS SEGMENT 157 ********
2406    	"ADD AOC ASD ASN BRUNBRTRBRFLENTRCHSNCOMMDEL DIV DUP "
2406    	"NEQ EQL GEQ LSS GTR LEQ LOADLOR AND MKS REP MUL NEG "
2406    	"REL RTN SAVESBR SHL SHR STODSTONSUB XCH SCANMOD ADC "
2406    	"FDI BSP SWAPEXP FID RSDNRSUP IN OCX LODBDIVTISOLISOD"
2406    	"FINDONESFONEBL1DBL2DDUPLBLDAPLODPARTPSTNPSTDCMP PLNK";
2406    	% MAKE IT SUCH THAT IF COMPILER	FAILS USER
2406    	% STILL	CAN NOT	EXECUTE	CODE FILE
                               DATA(157) IS 0202 LONG, NEXT SEGMENT 001 ********
2412    	FILL PRTA[*] WITH
                                                    DATA IS SEGMENT 160 ********
2413    	    0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,
2413    	    0,		% I/O TOG
2413    	    0,		% TOGGLE
2413    	    0,0,0,0,3"177776",3"3777",3"177776",3"3777"	, % ALPHAONLY
2413    	    0,0,0,3"1777",0,0,0,0			, % NUMERIC
2413    	    0,0,0,3"1777",3"177776",3"3777",3"177776",3"3777", % ALPHANUMERIC
2413    	    0,0,3"177776",3"176000",1,3"174000",1,3"174000"	; % SPECIAL
                               DATA(160) IS 0062 LONG, NEXT SEGMENT 001 ********
2417    	IF NOT NOCODEFILE
2417    	THEN WRITE(CODE[0],7,PRTA[*]);
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 174


2434    	PROADDRESS:=12; PRTMAX:=49;
2442    	DA:=SGAVL:=LEVEL:=REAL(FUNCTION:=ERRORTOG:=TRUE);
2455    	STACKCTR:=LOCALSPACE;
2460    	GETNEXT;
2463    	IF CLASSF:=CLASS GEQ BOOLEANV AND CLASS LEQ INTEGERV
2471    	THEN BEGIN
2476 2  	  GETNEXT;
2501    	  IF CLASS EQL PROCEDUREV
2502    	  THEN PROCDEC(CLASSF-BOOLEANV+BOOPROCID)
2514    	  ELSE FLAG(124)
2522    	  END
2524 2  	ELSE
2524    	  IF CLASS EQL PROCEDUREV
2527    	  THEN PROCDEC(PROCID)
2535    	  ELSE
2537    	    IF CLASS NEQ BEGINV
2542    	    THEN FLAG(124)
2550    	    ELSE BEGIN
2554 2  	      BEGINCTR:=1;
2557    	      GETNEXT;
2562    	      BLOK(LEVEL:=BEGINCTR:=REAL(FUNCTION:=FALSE))
2572    	      END;
2574 2  	IF FUNCTION
2574    	THEN BEGIN	% ADD DECLARATION OF EXTERNAL PROCEDURE
2577 2  	  I:=SYMBOLTABLESIZE;
2602    	  PURGEIT	% TO EXTERNAL SYMBOLTABLE.
2603    	  END;
2605 2  	IF ERRORCOUNT NEQ 0 OR NOCODEFILE
2610    	THEN BEGIN
2614 2  	  J:=DA+(PRTMAX+1) DIV 256;
2627    	  GO WRAPUP	% THIS ALSO FIXES CONSTANTCLEAN	PROB
2631    	  END;
2631 2  	T:=PRTMAX:=PRTMAX+1;
2640    	WRITE(CODE[J:=DA],T,PRTA[*]);
2654    	J:=J+(T+255) DIV 256;
2665    	PRTA[0]:=DA; PRTA[1]:=PRTMAX;
2675    	PRTA[7]:=PLL; PRTA[8]:=SGAVL-1;
2707    	IF EI>0	AND (FUNCTION !	EPROC)		% EXTERNAL TABLE
2715    	THEN BEGIN
2720 2  	  PRTA[4]:=J; PRTA[5]:=EI:=*+1;
2734    	  WRITE(CODE[J],REAL(BOOLEAN(EI+255) AND BOOLEAN(3"177400"))
2745    		,ESTACK);
2752    	  J:=*+(EI+255) DIV 256
2757    	  END;
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 175


2763 2  WRAPUP:
2763    EOJ:
2763    	PRTA[2]:=ERRORCOUNT;
2767    	PRTA[3]:=REAL(LEVEL=0);	% INHIBIT SEPARATELY
2773    				% COMPILED PROCS FROM RUNNING.
2775    	PRTA[6]:=-1;
OMIT    @O
OMIT    	IF CRUNCHOPTION	AND NOT	NOCODEFILE	% /C OPTION
OMIT    	THEN BEGIN
OMIT    	  READ(CODE[0],256*J,STACK);		% READ IT ALL IN
OMIT    	  CLOSE(CODE,PURGE);			% DELETE CODE FILE
OMIT    	  CODE.MAXRECNO:=J-1;			% ACTUAL MAX-REC-NO
OMIT    	  WRITE(CODE,256*J,STACK)		% WRITE	IT BACK	OUT
OMIT    	  END;
2777    @O
3002    	IF NOT NOLISTFILE
3002    	THEN BEGIN		% FINISH UP NOW	!
3005 2  	  BOOLEAN B;
   001414-P = B.0023
                                                  B.0023 IS SEGMENT 161 ********
   030007-S = B
0001    	  LABEL	L;
0001    	  EOPTION:=FALSE;
0006    	  REPLACE LINEOUT BY ZS(ERRORCOUNT,5),"  ERRORS" FOR 7+
0020    		REAL(ERRORCOUNT	NEQ 1)," DETECTED.  ";
0033    	  IF ERRORCOUNT	> 0
0035    	  THEN WRITE(TTY,12,LINEOUT);
0053    	  WRITEALINE(12);
0057    	  REPLACE LINEOUT BY "NUMBER OF SEGMENTS =",ZS(SGAVL-1,4),
0075    		". DISK SIZE =",ZS(J,4)," BLOCKS. ";
0114    	  WRITEALINE(25);
0120    	  REPLACE LINEOUT BY "SYMBOL TABLE REQUIRED ",ZS(MAXI,5)," WORDS."
0134    		" PRT SIZE = ",ZS(PRTMAX,4)," WORDS. ";
0153    	  WRITEALINE(29);
0155    	  % CALCULATE ELAPSED TIME
0157    	  IF J:=TIME(2)*60+TIME(1) < TIME1
0172    	  THEN J:=J+24*60;
0205    	  IF J:=J-TIME1	EQL 0
0213    	  THEN J:=1;
0221    	  REPLACE LINEOUT BY "CARD IMAGES SCANNED =",ZS(LINECOUNT,5),
0235    		" AT",ZS(LINECOUNT DIV J,4)," CARDS/MINUTE. ";
0256    	  WRITEALINE(24);
0262    	  REPLACE LINEOUT BY "ELAPSED TIME =",ZS(J,4)," MINUTES" FOR
0300    		7+REAL(J NEQ 1),". ";
0314    	  WRITEALINE(13+REAL(J NEQ 1));
0324    	  REPLACE LINEOUT BY "CODE SEGMENT SIZE =",O6(TOTSEG)," WORDS."
0340    		" LARGEST SEGMENT SIZE =",O6(MAXSEG)," WORDS.";
0357    	  WRITEALINE(34);
0363    	  REPLACE LINEOUT BY "VIRTUAL MEMORY REQUIREMENT =",ZS(VM,7),
0377    		" WORDS. ";
0404    	  WRITEALINE(21);
0410    	  REPLACE LINEOUT BY "ESTIMATED WORKING SET =",ZS(PRTA[9]:=
0417    		((SGAVL-1) DIV 4*(TOTSEG DIV (SGAVL-1))+5\MAXDATA+
0417    		SAVEIT+3"3000"+500+PRTMAX) DIV 1000,4),
0457    		" K WORDS.";
0464    	  LNCT:=0;
0467    	  WRITEALINE(18);
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 176


0473    	  REPLACE LINEOUT BY " " FOR 80;
0502    	  REPLACE LINEOUT BY CSI UNTIL EQL 0;
0511    	  WRITEALINE(40);
0515    	  LINEOUT[0]:=3"14";		% FINAL	FORM
0521    	  WRITEALINE(1)
0523    	  END;
                             B.0023(161) IS 1032 LONG, NEXT SEGMENT 001 ********
3033 2  	IF NOT NOCODEFILE
3033    	THEN WRITE(CODE[0],11,PRTA[*]);
3044    	% IF COMPILE-AND-GO OPTION WAS SET, THEN CHAIN THE CODE FILE
3050    	CHAIN CODE,COMPILEANDGO;
3056    NADZ:
3056    END.
                             B.0000(001) IS 3060 LONG, NEXT SEGMENT 000 ********
    0  ERRORS DETECTED.
NUMBER OF SEGMENTS = 113. DISK SIZE = 173 BLOCKS.
SYMBOL TABLE REQUIRED  6009 WORDS. PRT SIZE =  784 WORDS.
CARD IMAGES SCANNED = 7272 AT 227 CARDS/MINUTE.
ELAPSED TIME =  32 MINUTES.
CODE SEGMENT SIZE =061311 WORDS. LARGEST SEGMENT SIZE =003060 WORDS.
VIRTUAL MEMORY REQUIREMENT =  25289 WORDS.
ESTIMATED WORKING SET =  11 K WORDS.
ALGOL,ALGOL=ALGOL/L/P

DISK.
1713    	      THEN BEGIN
1721 5  		REPLACE STR BY " " FOR 78;
1730    		REPLACE STR BY "FILE ",CARDIN.TITLE," NOT PRESENT.";
1753    		WRITE(TTY,39,STR);
1766    		GO TRYAGAIN
2011    		END
2011 5  	      END
2011 4  	    END
2011 3  	  ELSE GO L2;
2015    	  IF IFP EQL ","	% MORE THAN ONE INPUT FILE?
2017    	  THEN BEGIN		% YEP.
2025 3  	    IFP:=*+1;		% SCAN THE ","
2032    	    GO L4		% SEE IF THIS FILE AROUND.
2035    	    END
2035 3  	  ELSE			% SEE IF DONE SCANNING THE INPUT STRING
2035    	    IF REAL(IFP,1) NEQ 0	% DONE?
2044    	    THEN BEGIN		% BAD CHARACTER!
2047 3  	      REPLACE STR BY "ILLEGAL CHARACTER IN INPUT STRING.";
2056    	      WRITE(TTY,17,STR);
2071    	      GO TRYAGAIN
2115    	      END
2115 3  	  END
2115 2  	ELSE BEGIN
2117 2  	  L2: REPLACE STR BY "ERROR ... MISSING INPUT FILE. ";
2126    	  WRITE(TTY,15,STR);
2141    	  GO TRYAGAIN
2163    	  END;
2163 2  	IFP:=P;		% RE-SCAN THE FILE NAME STRING.
2167    	FILENAMESCAN(A);
2202    L5:	REPLACE Q BY ".SRC" FOR 4*(1-REAL(EXTENSION)),
2215    	    A UNTIL EQL 0,0 FOR 1;
2233    	REPLACE CARDIN.TITLE BY STR;
2251    	IF NOT CARDIN.PRESENT	% MUST BE THE ONE WITH A NULL EXTENSION.
2251    	THEN BEGIN
2257 2  	  EXTENSION:=TRUE;	% FOR ABOVE!
2262    	  GO L5
2271    	  END;
2271 2  	TIME1:=60*TIME(2)+TIME(1);	% TIME AT START	OF COMPILE
2304    	IF EIGHTYCOL THEN LINE.MAXRECSIZE:=40
2311    	  ELSE LINE.MAXRECSIZE:=66;
2325    	IF EOPTION THEN	NOHEADING:=TRUE	ELSE DAYTIME;
2340    	P:=CARD+72;
2344    	PGCT:=1;
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 169


2347    	FILL STACK[*] WITH 0,
                                                    DATA IS SEGMENT 152 ********
2350    	000,	IFV	, "2IF"		, %  1
2350    	167,	GOV	, "2GO"		, %  5
2350    	000,	WHILEV	, "5WHILE"	, %  9
2350    	000,	DOV	, "2DO"		, % 14
2350    	000,	FORV	, "3FOR"	, % 18
2350    	009,	WRITEV	, "5WRITE"	, % 22	(REDEFINABLE)
2350    	126,	READV	, "4READ"	, % 27	(REDEFINABLE)
2350    	161,	ELSEV	, "4ELSE"	, % 32
2350    	000,	PURGEV	, "5PURGE"	, % 37	(REDEFINABLE)
2350    	197,	HEXV	, "3HEX"	, % 42	(REDEFINABLE)
2350    	000,	OCTALV	, "5OCTAL"	, % 46	(REDEFINABLE)
2350    	218,	STEPV	, "4STEP"	, % 51
2350    	051,	TOV	, "2TO"		, % 56	(REDEFINABLE)
2350    	144,	THENV	, "4THEN"	, % 60
2350    	000,	ANDV	, "3AND"	, % 65	(REDEFINABLE)
2350    	252,	ORV	, "2OR"		, % 69	(REDEFINABLE)
2350    	000,	NOTV	, "3NOT"	, % 73	(REDEFINABLE)
2350    	106,	EQLOP	, "3EQL"	, % 77	(REDEFINABLE)
2350    	073,	NEQOP	, "3NEQ"	, % 81	(REDEFINABLE)
2350    	089,	LSSOP	, "3LSS"	, % 85	(REDEFINABLE)
2350    	000,	LEQOP	, "3LEQ"	, % 89	(REDEFINABLE)
2350    	097,	GEQOP	, "3GEQ"	, % 93	(REDEFINABLE)
2350    	539,	GTROP	, "3GTR"	, % 97	(REDEFINABLE)
2350    	000,	BEGINV	, "5BEGIN"	, %101
2350    	227,	ENDV	, "3END"	, %106
2350    	000,	UNTILV	, "5UNTIL"	, %110
2350    	000,	LABELV	, "5LABEL"	, %115
2350    	000,	BOOLEANV, "7BOOLEAN"	, %120
2350    	000,	REALV	, "4REAL"	, %126
2350    	000,	INTEGERV, "7INTEGER"	, %131
2350    	000,	EXTERNALV,"8EXTERNAL"	, %137
2350    	179,	SWITCHV	, "6SWITCH"	, %144
2350    	000,	ARRAYV	, "5ARRAY"	, %150
2350    	018,	DECIMALV, "7DECIMAL"	, %155	(REDEFINABLE)
2350    	000,	DEFINEV	, "6DEFINE"	, %161
2350    	000,	FILEV	, "4FILE"	, %167
2350    	000,	PROCEDUREV,"9PROCEDURE"	, %172
2350    	000,	TRUTH	, "4TRUE"	, %179
2350    	233,	FALSEV	, "5FALSE"	, %184
2350    	369, 	INV	, "2IN"		, %189	(REDEFINABLE)
2350    	338,	BYV	, "2BY"		, %193	(REDEFINABLE)
2350    	000,	FORWARDV, "7FORWARD"	, %197
2350    	005,	FILLV	, "4FILL"	, %203	(REDEFINABLE)
2350    	000,	WITHV	, "4WITH"	, %208	(REDEFINABLE)
2350    	000,	VALUEV	, "5VALUE"	, %213
2350    	000,	SAVEV	, "4SAVE"	, %218
2350    	000,	OWNV	, "3OWN"	, %223
2350    	000,	COMMENTV, "7COMMENT"	, %227
2350    	000,	FIELDV	, "5FIELD"	, %233
2350    	523,	CASEV	, "4CASE"	, %238	(REDEFINABLE)
2350    	247,	DIVV	, "3DIV"	, %243	(REDEFINABLE)
2350    	120,	CLOSEV	, "5CLOSE"	, %247	(REDEFINABLE)
2350    	000,	OFV	, "2OF"		, %252	(REDEFINABLE)
2350    	312,	LISTV	, "4LIST"	, %256
2350    	256,	LOCKV	, "4LOCK"	, %261	(REDEFINABLE)
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 170


2350    	060,	THRUV	, "4THRU"	, %266	(REDEFINABLE)
2350    	000,	POINTERV, "7POINTER"	, %271
2350    	000,	REPLACEV, "7REPLACE"	, %277	(REDEFINABLE)
2350    	329,	RELEASEV, "7RELEASE"	, %283	(REDEFINABLE)
2350    	293,	SHLV	, "3SHL"	, %289	(REDEFINABLE)
2350    	172,	SHRV	, "3SHR"	, %293	(REDEFINABLE)
2350    	266,	TIMEV	, "4TIME"	, %297	(REDEFINABLE)
2350    	307,	SCANV	, "4SCAN"	, %302	(REDEFINABLE)
2350    	056,	SIZEV	, "4SIZE"	, %307	(REDEFINABLE)
2350    	000,	LONGV	, "4LONG"	, %312
2350    	321,	MAXV	, "3MAX"	, %317	(REDEFINABLE)
2350    	325,	MODV	, "3MOD"	, %321	(REDEFINABLE)
2350    	115,	MINV	, "3MIN"	, %325	(REDEFINABLE)
2350    	277,	SHIFTV	, "5SHIFT"	, %329	(REDEFINABLE)
2350    	065,	ABSV	, "3ABS"	, %334	(REDEFINABLE)
2350    	000,	ADDRV	, "4ADDR"	, %338	(REDEFINABLE)
2350    	077,	DELTAV	, "5DELTA"	, %343	(REDEFINABLE)
2350    	000,	POLISHV	, "6POLISH"	, %348	(REDEFINABLE)
2350    	376,	SIGNV	, "4SIGN"	, %354	(REDEFINABLE)
2350    	243,	CHAINV	, "5CHAIN"	, %359	(REDEFINABLE)
2350    	000,	ONESV	, "4ONES"	, %364	(REDEFINABLE)
2350    	001,	FONEV	, "8FIRSTONE"	, %369	(REDEFINABLE)
2350    	302,	SWAPV	, "4SWAP"	, %376	(REDEFINABLE)
2350    	000,	TRUTHSETV,"8TRUTHSET"	, %381
2350    	208,	WORDV	, "4WORD"	, %388	(REDEFINABLE)
2350    	022,	WORDSV	, "5WORDS"	, %393	(REDEFINABLE)
2350    	343,	DIGITV	, "5DIGIT"	, %398	(REDEFINABLE)
2350    	439,	DIGITSV	, "6DIGITS"	, %403	(REDEFINABLE)
2350    	150,	487	, "5ALPHA"	, %409	(PRE-DEFINED TRUTHSET)	A-Z,0-9
2350    	046,	475	, "7NUMERIC"	, %414	(PRE-DEFINED TRUTHSET)	0-9
2350    	000,	511	, "7SPECIAL"	, %420	(PRE-DEFINED TRUTHSET)
2350    	359,	463	, "9ALPHAONLY"	, %426	(PRE-DEFINED TRUTHSET)	A-Z
2350    	271,	459	, "7PRTBASE"	, %433	(PRE-DEFINED INTEGER ID)
2350    	032,	499	, "<ALPHANUMERIC",%439	(PRE-DEFINED TRUTHSET)	A-Z,0-9
2350    	000,	454	, "6TOGGLE"	, %448	(PRE-DEFINED BOOLEAN ID)
2350
2350    		BOOPROCID,17,0,0,0	, %454	(DEFINITION OF TOGGLE)
2350    		INTID,0,0,0		, %459	(DEFINITION OF PRTBASE)
2350    		TRUTHID,18,0,0		, %463	ALPHAONLY
2350    		    0,0,0,0		, %467
2350    		    3"177776",3"3777"	, %471	(UPPER CASE)
2350    		    3"177776",3"3777"	, %473	(LOWER CASE)
2350    		TRUTHID,26,0,0		, %475	NUMERIC
2350    		    0,0,0,3"1777",0,0,0,0,%479	(NUMBERS)
2350    		TRUTHID,34,0,0		, %487	ALPHA
2350    		    0,0,0,3"1777"	, %491	(NUMBERS)
2350    		    3"177776",3"3777"	, %495	(UPPER CASE)
2350    		    3"177776",3"3777"	, %497	(LOWER CASE)
2350    		TRUTHID,34,0,0		, %499	ALPHANUMERIC
2350    		    0,0,0,3"1777"	, %503	    DITTO AS ABOVE
2350    		    3"177776",3"3777"	, %507
2350    		    3"177776",3"3777"	, %509
2350    		TRUTHID,42,0,0		, %511	SPECIAL
2350    		    0,0,3"177776",3"176000",%515
2350    		    1,3"174000",1,3"174000",%519
2350    	014,	BINARYV	, "6BINARY"	, %523	(REDEFINABLE)
2350    	000,	ZEROSUPV, ">ZEROSUPPRESSED",%529(REDEFINABLE)
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 171


2350    	184,	COMPILTIMEV,";COMPILETIME"; %539(REDEFINABLE)
                               DATA(152) IS 1043 LONG, NEXT SEGMENT 001 ********
2354    		SYMBOLTABLESIZE:=I:=546;	% SYMBOL TABLE STACK POINTER
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 172


2361    	FILL ATTRIBUTEDHASH[*] WITH	% CLASS	(3,F) RESERVED WORDS
                                                    DATA IS SEGMENT 153 ********
2362    					% (CONTEXT SENSITIVE).
2362    	004,	IOV	, "2IO"		, %000
2362    	008,	INV	, "2IN"		, %004
2362    	012,	OUTV	, "3OUT"	, %008
2362    	017,	DISKV	, "4DISK"	, %012
2362    	023,	TTYV	, "6REMOTE"	, %017
2362    	028,	DISKV	, "5ASCII"	, %023
2362    	034,	BINV	, "6BINARY"	, %028
2362    	039,	KINDV	, "4KIND"	, %034
2362    	044,	TEKTV	, "4TEKT"	, %039
2362    	050,	LPV	, "7PRINTER"	, %044
2362    	054,	LPV	, "2LP"		, %050
2362    	060,	PRESENTV, "7PRESENT"	, %054
2362    	065,	OPENV	, "4OPEN"	, %060
2362    	070,	MYUSEV	, "5MYUSE"	, %065
2362    	075,	TITLEV	, "5TITLE"	, %070
2362    	082,	MAXSIZEV, "8MAXRECNO"	, %075
2362    	091,	CURRECV	, "<CURRENTRECNO",%082
2362    	099,	MAXRECV	, ":MAXRECSIZE"	, %091
2362    	103,	TTYV	, "3TTY"	, %099
2362    	107,	TTYV	, "2KB"		, %103
2362    	000,	TTYV	, "2TT"		; %107
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 173


2362    	% POINTER TO RESERVED WORDS FOR	SPEEDER	LOOK UP
                               DATA(153) IS 0157 LONG, NEXT SEGMENT 001 ********
2366    	FILL SAUSAGE[*]	WITH		% HASHING TABLE	FOR RESERVED WORDS
                                                    DATA IS SEGMENT 154 ********
2367    	000,000,000,000,000,000,000,000,000,271,126,172,051,000,060,
2367    	000,000,000,000,000,000,000,000,000,271,126,172,051,000,060,
2367    	000,000,000,000,000,000,000,000,000,271,126,172,051,000,060,
2367    	000,000,000,000,000,000,000,000,000,271,126,172,051,000,060,
2367    	000,000,000,000;
2367
                               DATA(154) IS 0100 LONG, NEXT SEGMENT 001 ********
2373    	FILL SCRAMBLEDEGGS[*] WITH	% HASHING TABLE	FOR REDEFINEABLES AND IDENTI
                                                    DATA IS SEGMENT 155 ********
2374    	155,203,093,137,042,189,000,000,000,000,131,312,085,261,317,
2374    	000,000,529,000,000,334,193,409,000,101,238,426,000,398,403,
2374    	420,448,110,381,213,388,393,000,000,000,000,000,000,000,000,
2374    	000,081,069,223,364,414,000,037,348,433,027,289,354,283,297,
2374    	000,000,000,000;
2374
                               DATA(155) IS 0100 LONG, NEXT SEGMENT 001 ********
2400    	FILL SPECIAL[*]	WITH		% HASHING TABLE	FOR SPECIAL CHARACTERS
                                                    DATA IS SEGMENT 156 ********
2401    	LFTBRKT, MULOP,	RTBRKT,	NOTV, ASSIGNOP,	0, ORV,	QUOTEOP, POUND,
2401    	0, 0, AMPER, 0,	LFTPAREN, RTPAREN, FACTOP, ADDOP, COMMA, SUBOP,
2401    	DOTOP, DIVOP, 0, 0, 0, 0, 0, 0,	0, 0, 0, 0,
2401    	COLON, SEMICOLON, LSSOP, EQLOP,	GTROP, NOTV;
                               DATA(156) IS 0045 LONG, NEXT SEGMENT 001 ********
2405    	FILL OP	WITH
                                                    DATA IS SEGMENT 157 ********
2406    	"ADD AOC ASD ASN BRUNBRTRBRFLENTRCHSNCOMMDEL DIV DUP "
2406    	"NEQ EQL GEQ LSS GTR LEQ LOADLOR AND MKS REP MUL NEG "
2406    	"REL RTN SAVESBR SHL SHR STODSTONSUB XCH SCANMOD ADC "
2406    	"FDI BSP SWAPEXP FID RSDNRSUP IN OCX LODBDIVTISOLISOD"
2406    	"FINDONESFONEBL1DBL2DDUPLBLDAPLODPARTPSTNPSTDCMP PLNK";
2406    	% MAKE IT SUCH THAT IF COMPILER	FAILS USER
2406    	% STILL	CAN NOT	EXECUTE	CODE FILE
                               DATA(157) IS 0202 LONG, NEXT SEGMENT 001 ********
2412    	FILL PRTA[*] WITH
                                                    DATA IS SEGMENT 160 ********
2413    	    0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,
2413    	    0,		% I/O TOG
2413    	    0,		% TOGGLE
2413    	    0,0,0,0,3"177776",3"3777",3"177776",3"3777"	, % ALPHAONLY
2413    	    0,0,0,3"1777",0,0,0,0			, % NUMERIC
2413    	    0,0,0,3"1777",3"177776",3"3777",3"177776",3"3777", % ALPHANUMERIC
2413    	    0,0,3"177776",3"176000",1,3"174000",1,3"174000"	; % SPECIAL
                               DATA(160) IS 0062 LONG, NEXT SEGMENT 001 ********
2417    	IF NOT NOCODEFILE
2417    	THEN WRITE(CODE[0],7,PRTA[*]);
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 174


2434    	PROADDRESS:=12; PRTMAX:=49;
2442    	DA:=SGAVL:=LEVEL:=REAL(FUNCTION:=ERRORTOG:=TRUE);
2455    	STACKCTR:=LOCALSPACE;
2460    	GETNEXT;
2463    	IF CLASSF:=CLASS GEQ BOOLEANV AND CLASS LEQ INTEGERV
2471    	THEN BEGIN
2476 2  	  GETNEXT;
2501    	  IF CLASS EQL PROCEDUREV
2502    	  THEN PROCDEC(CLASSF-BOOLEANV+BOOPROCID)
2514    	  ELSE FLAG(124)
2522    	  END
2524 2  	ELSE
2524    	  IF CLASS EQL PROCEDUREV
2527    	  THEN PROCDEC(PROCID)
2535    	  ELSE
2537    	    IF CLASS NEQ BEGINV
2542    	    THEN FLAG(124)
2550    	    ELSE BEGIN
2554 2  	      BEGINCTR:=1;
2557    	      GETNEXT;
2562    	      BLOK(LEVEL:=BEGINCTR:=REAL(FUNCTION:=FALSE))
2572    	      END;
2574 2  	IF FUNCTION
2574    	THEN BEGIN	% ADD DECLARATION OF EXTERNAL PROCEDURE
2577 2  	  I:=SYMBOLTABLESIZE;
2602    	  PURGEIT	% TO EXTERNAL SYMBOLTABLE.
2603    	  END;
2605 2  	IF ERRORCOUNT NEQ 0 OR NOCODEFILE
2610    	THEN BEGIN
2614 2  	  J:=DA+(PRTMAX+1) DIV 256;
2627    	  GO WRAPUP	% THIS ALSO FIXES CONSTANTCLEAN	PROB
2631    	  END;
2631 2  	T:=PRTMAX:=PRTMAX+1;
2640    	WRITE(CODE[J:=DA],T,PRTA[*]);
2654    	J:=J+(T+255) DIV 256;
2665    	PRTA[0]:=DA; PRTA[1]:=PRTMAX;
2675    	PRTA[7]:=PLL; PRTA[8]:=SGAVL-1;
2707    	IF EI>0	AND (FUNCTION !	EPROC)		% EXTERNAL TABLE
2715    	THEN BEGIN
2720 2  	  PRTA[4]:=J; PRTA[5]:=EI:=*+1;
2734    	  WRITE(CODE[J],REAL(BOOLEAN(EI+255) AND BOOLEAN(3"177400"))
2745    		,ESTACK);
2752    	  J:=*+(EI+255) DIV 256
2757    	  END;
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 175


2763 2  WRAPUP:
2763    EOJ:
2763    	PRTA[2]:=ERRORCOUNT;
2767    	PRTA[3]:=REAL(LEVEL=0);	% INHIBIT SEPARATELY
2773    				% COMPILED PROCS FROM RUNNING.
2775    	PRTA[6]:=-1;
OMIT    @O
OMIT    	IF CRUNCHOPTION	AND NOT	NOCODEFILE	% /C OPTION
OMIT    	THEN BEGIN
OMIT    	  READ(CODE[0],256*J,STACK);		% READ IT ALL IN
OMIT    	  CLOSE(CODE,PURGE);			% DELETE CODE FILE
OMIT    	  CODE.MAXRECNO:=J-1;			% ACTUAL MAX-REC-NO
OMIT    	  WRITE(CODE,256*J,STACK)		% WRITE	IT BACK	OUT
OMIT    	  END;
2777    @O
3002    	IF NOT NOLISTFILE
3002    	THEN BEGIN		% FINISH UP NOW	!
3005 2  	  BOOLEAN B;
   001414-P = B.0023
                                                  B.0023 IS SEGMENT 161 ********
   030007-S = B
0001    	  LABEL	L;
0001    	  EOPTION:=FALSE;
0006    	  REPLACE LINEOUT BY ZS(ERRORCOUNT,5),"  ERRORS" FOR 7+
0020    		REAL(ERRORCOUNT	NEQ 1)," DETECTED.  ";
0033    	  IF ERRORCOUNT	> 0
0035    	  THEN WRITE(TTY,12,LINEOUT);
0053    	  WRITEALINE(12);
0057    	  REPLACE LINEOUT BY "NUMBER OF SEGMENTS =",ZS(SGAVL-1,4),
0075    		". DISK SIZE =",ZS(J,4)," BLOCKS. ";
0114    	  WRITEALINE(25);
0120    	  REPLACE LINEOUT BY "SYMBOL TABLE REQUIRED ",ZS(MAXI,5)," WORDS."
0134    		" PRT SIZE = ",ZS(PRTMAX,4)," WORDS. ";
0153    	  WRITEALINE(29);
0155    	  % CALCULATE ELAPSED TIME
0157    	  IF J:=TIME(2)*60+TIME(1) < TIME1
0172    	  THEN J:=J+24*60;
0205    	  IF J:=J-TIME1	EQL 0
0213    	  THEN J:=1;
0221    	  REPLACE LINEOUT BY "CARD IMAGES SCANNED =",ZS(LINECOUNT,5),
0235    		" AT",ZS(LINECOUNT DIV J,4)," CARDS/MINUTE. ";
0256    	  WRITEALINE(24);
0262    	  REPLACE LINEOUT BY "ELAPSED TIME =",ZS(J,4)," MINUTES" FOR
0300    		7+REAL(J NEQ 1),". ";
0314    	  WRITEALINE(13+REAL(J NEQ 1));
0324    	  REPLACE LINEOUT BY "CODE SEGMENT SIZE =",O6(TOTSEG)," WORDS."
0340    		" LARGEST SEGMENT SIZE =",O6(MAXSEG)," WORDS.";
0357    	  WRITEALINE(34);
0363    	  REPLACE LINEOUT BY "VIRTUAL MEMORY REQUIREMENT =",ZS(VM,7),
0377    		" WORDS. ";
0404    	  WRITEALINE(21);
0410    	  REPLACE LINEOUT BY "ESTIMATED WORKING SET =",ZS(PRTA[9]:=
0417    		((SGAVL-1) DIV 4*(TOTSEG DIV (SGAVL-1))+5\MAXDATA+
0417    		SAVEIT+3"3000"+500+PRTMAX) DIV 1000,4),
0457    		" K WORDS.";
0464    	  LNCT:=0;
0467    	  WRITEALINE(18);
PDP-11 ALGOL COMPILER, VERSION 6.6.019                     3/5/76       PAGE 176


0473    	  REPLACE LINEOUT BY " " FOR 80;
0502    	  REPLACE LINEOUT BY CSI UNTIL EQL 0;
0511    	  WRITEALINE(40);
0515    	  LINEOUT[0]:=3"14";		% FINAL	FORM
0521    	  WRITEALINE(1)
0523    	  END;
                             B.0023(161) IS 1032 LONG, NEXT SEGMENT 001 ********
3033 2  	IF NOT NOCODEFILE
3033    	THEN WRITE(CODE[0],11,PRTA[*]);
3044    	% IF COMPILE-AND-GO OPTION WAS SET, THEN CHAIN THE CODE FILE
3050    	CHAIN CODE,COMPILEANDGO;
3056    NADZ:
3056    END.
                             B.0000(001) IS 3060 LONG, NEXT SEGMENT 000 ********
    0  ERRORS DETECTED.
NUMBER OF SEGMENTS = 113. DISK SIZE = 173 BLOCKS.
SYMBOL TABLE REQUIRED  6009 WORDS. PRT SIZE =  784 WORDS.
CARD IMAGES SCANNED = 7272 AT 227 CARDS/MINUTE.
ELAPSED TIME =  32 MINUTES.
CODE SEGMENT SIZE =061311 WORDS. LARGEST SEGMENT SIZE =003060 WORDS.
VIRTUAL MEMORY REQUIREMENT =  25289 WORDS.
ESTIMATED WORKING SET =  11 K WORDS.
ALGOL,ALGOL=ALGOL/L/P