[net.sources] Stage2 sources

wje@sii.UUCP (Bill Ezell) (07/17/85)

This is part one of two of the stage2 sources, in shar format.
It has been run on several Unix systems.
You should have a copy of:

	'Implementing Software for Non-Numeric Applications'
	William M. Waite
	Prentice-Hall (C) 1973
	ISBN 0-13-451898-5

in order to use stage2.

	Bill Ezell
	(decvax!sii!wje)
---------------------------CUT HERE-----------------------------
echo x - Makefile
cat >Makefile <<'!Funky!Stuff!'
CFLAGS= -O
LFLAGS= -n

stage2:	stage2.o ioop.o iwrch.o
	cc -o stage2 $(LFLAGS) stage2.o ioop.o iwrch.o

stage2.c: simcomp stage2.sim
	simcomp <stage2.sim >stage2.c

stage2.sim: flub.sim stage2.txt
	cat flub.sim stage2.txt >stage2.sim

simcomp: simcomp.o ioop.o iwrch.o
	cc -o simcomp $(LFLAGS) simcomp.o ioop.o iwrch.o
!Funky!Stuff!
echo x - ReadMe
cat >ReadMe <<'!Funky!Stuff!'
Here is the distribution of stage2, as implemented in C for Unix.
Included are the following files:

ReadMe		this file
Makefile	make file for stage2 and simcomp
flub.sim	simcomp definition of the flub machine
ioop.c		i/o routines for simcomp and stage2
iwrch.c		more i/o routines for simcomp and stage2
simcomp.c	the simcomp text processor written in C (from fortran)
simtest.sim	test suite for simcomp
stage2.sim	macros for stage2, used by simcomp, including C startup
stage2.txt	the stage2 distribution in flub macro form

Most of the stuff will make little to no sense to anyone not reading the
book that describes it:

	'Implementing Software for Non-Numeric Applications'
	William M. Waite
	Prentice-Hall (C) 1973
	ISBN 0-13-451898-5

Have fun,
	Bill Ezell
	(decvax!sii!wje)
!Funky!Stuff!
echo x - flub.sim
cat >flub.sim <<'!Funky!Stuff!'
."$"0
FLG " = 0.
F"10=0;$
$
FLG " = 1.
F"10=1;$
$
FLG " = 2.
F"10=2;$
$
FLG " = 3.
F"10=3;$
$
FLG " = ".
F"10=F"20;$
$
""" " = 0 " 0.
"10"40=0;$
$
""" " = " " 0.
"10"40="10"50;$
$
""" " = 0 " 1.
"10"40= "501;$
$
""" " = " " ".
"10"40="10"50"60"10"70;$
$
PTR " = " " 7.
P"10 = P"20 + 1;$
$
""" " = """ ".
"10"40="50"80;$
$
GET " = ".
{$
register struct memy *p;$
 p = &memory[P"20];$
F"10 = (struct memy *)p->flag;$
V"10 = (struct memy *)p->value;$
P"10 = (struct memy *)p->pointer;$
};$
$
STO " = ".
{$
	register struct memy *p;$
 p = &memory[P"10];
(struct memy *)p->flag = F"20;$
(struct memy *)p->value = V"20;$
(struct memy *)p->pointer = P"20;$
}$
$
TO "" IF """ " = ".
if("30"60=="30"70)goto L"10"20;$
$
TO "" IF """ " NE ".
if("30"60!="30"70)goto L"10"20;$
$
TO "" IF """ " GE ".
if("30"60>="30"70)goto L"10"20;$
$
TO "" BY ".
P"30="00;goto L"10"20;case "00:;$
$
RETURN BY ".
retby=P"10;goto Looptop;$
$
TO "".
goto L"10"20;$
$
STOP.
exit();$
$
VAL " = CHAR.
V"10=lb[lbr++];$
$
CHAR = VAL ".
F"10=iwrch(V"10,lb,&lbw,&lbl);$
$
READ NEXT ".
F"10=ioop(READ,V"10,lb,&ONE,&lbl);lb[lbl]= -1;lbr=1;$
$
WRITE NEXT ".
F"10=ioop(WRITE,V"10,lb,&ONE,&lbl);lbw=1;$
$
REWIND ".
F"10=ioop(CONTROL,V"10,lb,&ONE,&lbl);$
$
LOC "".
L"10"20:$
$
MESSAGE """" TO ".
mb[11]="11;mb[12]="21;mb[13]="31;mb[14]="41;$
F"50=ioop(WRITE,V"50,mb,&ONE,&TWO1);$
$
END PROGRAM.
 }}$
$
MESSAGE """"""".
i=1;$
while(i<10) mb[i++]="11;$
mb[i]="21;i += 5;mb[i++]="21;mb[i++]="31;mb[i++]="41;mb[i++]="51;$
mb[i++]="61;mb[i]="71;$
$$

/* this is the prefix c code for stage2 */

#define READ -1
#define CONTROL 0
#define WRITE 1
#define MEMMAX  12000		/* number of memory cells to use */

int i,lbl,lbr,lbw,retby,ONE,TWO1,lb[124],mb[22],
F0,
V0,
P0,
F1,
V1,
P1,
F2,
V2,
P2,
F3,
V3,
P3,
F4,
V4,
P4,
F5,
V5,
P5,
F6,
V6,
P6,
F7,
V7,
P7,
F8,
V8,
P8,
F9,
V9,
P9,
FA,
VA,
PA,
FB,
VB,
PB,
FC,
VC,
PC,
FD,
VD,
PD,
FE,
VE,
PE,
FF,
VF,
PF,
FG,
VG,
PG,
FH,
VH,
PH,
FI,
VI,
PI,
FJ,
VJ,
PJ,
FK,
VK,
PK,
FL,
VL,
PL,
FM,
VM,
PM,
FN,
VN,
PN,
FO,
VO,
PO,
FP,
VP,
PP,
FQ,
VQ,
PQ,
FR,
VR,
PR,
FS,
VS,
PS,
FT,
VT,
PT,
FU,
VU,
PU,
FV,
VV,
PV,
FW,
VW,
PW,
FX,
VX,
PX,
FY,
VY,
PY,
FZ,
VZ,
PZ;

struct memy {
		short flag;
		short value;
		int pointer;
	    }
		memory[MEMMAX];		/* the pseudo machine memory */

main(argc,argv)
int argc;
char **argv;
{
 F0=0;		/* set up the initial values, per the book */
 F1=1;
 F2=2;
 F3=3;
 V0=0;
 V1=1;
 V2=2;
 V3=3;
 V4=4;
 V5=5;
 V6=6;
 V7=7;
 V8=8;
 V9=9;
 P0=0;
 P1=1;
 P2=2;
 P3=3;
 P5=10;
 P7= 1;		/* Memory increment */
 P8 = 0;	/* Memory start */
 P9 = MEMMAX;	/* Memory end */

 ONE=1; TWO1=21;

lbr=lbw=lbl=1;retby= -1;
Looptop: switch (retby) {
case -1:

MESSAGE * ERROR.
!Funky!Stuff!
echo x - simtest.sim
cat >simtest.sim <<'!Funky!Stuff!'
.'$'0
END PROGRAM.
C END OF SIMCMP TEST. THIS LINE CONTAINS TYPE 0 ELEMENTS ONLY$
        RETURN$
        END$
$
TYPE 2 '.
        TESTC='10$
        TYPE1='11$
$
TEST PARAMETER 0.
        PRINT '00, GEN1$
        PRINT '01, GEN2$
        PRINT '02, GEN3$
        PRINT '03, GEN4$
        PRINT '04, GEN5$
        PRINT '05, GEN6$
        PRINT '06, GEN7$
        PRINT '07, GEN8$
        PRINT '08, GEN9$
        PRINT '09, GEN10$
'00 ZERO$
'01 ONE$
'02 TWO$
'03 THREE$
'04 FOUR$
'05 FIVE$
'06 SIX$
'07 SEVEN$
'08 EIGHT$
'09 NINE$
$
NULL MACRO.
$
NINE PARAMETERS '''''''''.
        NINE='10+'20+'30+'40+'50+'60+'70+'80+'90$
$
CODE BODY LINE WITH NO TERMINATOR.
C       THIS BODY LINE HAS NO TERMINATOR. IT SHOULD HAVE 80 CHARACTERS.
$$
        SUBROUTINE PROGR
C       THIS TEST DATA CHECKS OUT THE WORKINGS OF SIMCMP. THE FIRST THREE
C       LINES WILL NOT BE MATCHED AND SHOULD BE OUTPUT IN THIER ENTIRITY.
TEST PARAMETER 0.
NULL MACRO.
NINE PARAMETERS 123456789.
TYPE 2 A.
CODE BODY LINE WITH NO TERMINATOR.
TYPE 2 0.
TEST PARAMETER 0.
END PROGRAM.
!Funky!Stuff!
echo x - stage2.sim
cat >stage2.sim <<'!Funky!Stuff!'
."$"0
FLG " = 0.
F"10=0;$
$
FLG " = 1.
F"10=1;$
$
FLG " = 2.
F"10=2;$
$
FLG " = 3.
F"10=3;$
$
FLG " = ".
F"10=F"20;$
$
""" " = 0 " 0.
"10"40=0;$
$
""" " = " " 0.
"10"40="10"50;$
$
""" " = 0 " 1.
"10"40= "501;$
$
""" " = " " ".
"10"40="10"50"60"10"70;$
$
PTR " = " " 7.
P"10 = P"20 + 1;$
$
""" " = """ ".
"10"40="50"80;$
$
GET " = ".
{$
register struct memy *p;$
p = &memory[P"20];$
F"10 = p->flag;$
V"10 = p->value;$
P"10 = p->pointer;$
};$
$
STO " = ".
{$
register struct memy *p;$
p = &memory[P"10];
p->flag = F"20;$
p->value = V"20;$
p->pointer = P"20;$
}$
$
TO "" IF """ " = ".
if("30"60=="30"70)goto L"10"20;$
$
TO "" IF """ " NE ".
if("30"60!="30"70)goto L"10"20;$
$
TO "" IF """ " GE ".
if("30"60>="30"70)goto L"10"20;$
$
TO "" BY ".
P"30="00;goto L"10"20;case "00:;$
$
RETURN BY ".
retby=P"10;goto Looptop;$
$
TO "".
goto L"10"20;$
$
STOP.
exit();$
$
VAL " = CHAR.
V"10=lb[lbr++];$
$
CHAR = VAL ".
F"10=iwrch(V"10,lb,&lbw,&lbl);$
$
READ NEXT ".
F"10=ioop(READ,V"10,lb,&ONE,&lbl);lb[lbl]= -1;lbr=1;$
$
WRITE NEXT ".
F"10=ioop(WRITE,V"10,lb,&ONE,&lbl);lbw=1;$
$
REWIND ".
F"10=ioop(CONTROL,V"10,lb,&ONE,&lbl);$
$
LOC "".
L"10"20:$
$
MESSAGE """" TO ".
mb[11]="11;mb[12]="21;mb[13]="31;mb[14]="41;$
F"50=ioop(WRITE,V"50,mb,&ONE,&TWO1);$
$
END PROGRAM.
 }}$
$
MESSAGE """"""".
i=1;$
while(i<10) mb[i++]="11;$
mb[i]="21;i += 5;mb[i++]="21;mb[i++]="31;mb[i++]="41;mb[i++]="51;$
mb[i++]="61;mb[i]="71;$
$$

/* this is the prefix c code for stage2 */

#define READ -1
#define CONTROL 0
#define WRITE 1
#define MEMMAX  12000		/* number of memory cells to use */

int i,lbl,lbr,lbw,retby,ONE,TWO1,lb[124],mb[22],
F0,
V0,
P0,
F1,
V1,
P1,
F2,
V2,
P2,
F3,
V3,
P3,
F4,
V4,
P4,
F5,
V5,
P5,
F6,
V6,
P6,
F7,
V7,
P7,
F8,
V8,
P8,
F9,
V9,
P9,
FA,
VA,
PA,
FB,
VB,
PB,
FC,
VC,
PC,
FD,
VD,
PD,
FE,
VE,
PE,
FF,
VF,
PF,
FG,
VG,
PG,
FH,
VH,
PH,
FI,
VI,
PI,
FJ,
VJ,
PJ,
FK,
VK,
PK,
FL,
VL,
PL,
FM,
VM,
PM,
FN,
VN,
PN,
FO,
VO,
PO,
FP,
VP,
PP,
FQ,
VQ,
PQ,
FR,
VR,
PR,
FS,
VS,
PS,
FT,
VT,
PT,
FU,
VU,
PU,
FV,
VV,
PV,
FW,
VW,
PW,
FX,
VX,
PX,
FY,
VY,
PY,
FZ,
VZ,
PZ;

struct memy {
		int flag;
		int value;
		int pointer;
	    }
		memory[MEMMAX];		/* the pseudo machine memory */

main(argc,argv)
int argc;
char **argv;
{
 F0=0;		/* set up the initial values, per the book */
 F1=1;
 F2=2;
 F3=3;
 V0=0;
 V1=1;
 V2=2;
 V3=3;
 V4=4;
 V5=5;
 V6=6;
 V7=7;
 V8=8;
 V9=9;
 P0=0;
 P1=1;
 P2=2;
 P3=3;
 P5=10;
 P7= 1;		/* Memory increment */
 P8 = 0;	/* Memory start */
 P9 = MEMMAX;	/* Memory end */

 ONE=1; TWO1=21;

lbr=lbw=lbl=1;retby= -1;
Looptop: switch (retby) {
case -1:

MESSAGE * ERROR.
FLG I = 0.              SET UP MACRO CHANNEL.
VAL I = 1 + 0
PTR I = 0 + 0.
READ NEXT I.            GRAB THE FLAG LINE.
TO 98 IF FLG I NE 0.    QUIT UNLESS ALL IS OK.
VAL A = CHAR.           SOURCE EOL.
PTR A = 8 + 0.          SET UP VOID TEMPLATE TREE.
STO A = I.              SAVE THE MACRO CHANNEL SPEC.
FLG B = 2.              PHASE FLAG.
VAL B = CHAR.           SOURCE PARAMETER FLAG.
VAL C = CHAR.           MCT EOL.
PTR C = 9 + 0.          INITIAL TEXT POINTER.
VAL D = CHAR.           MCT PARAMETER FLAG.
VAL E = CHAR.           ZERO CHARACTER.
PTR E = VAL E.          PREPARE FOR NORMALIZATIONS.
VAL F = CHAR.           SPACE CHARACTER.
PTR F = A + 7.          SET UP A VOID SYMBOL TREE.
STO F = 0.
VAL G = 0 + 0.          RESET THE DIGIT COUNT FOR NUMBER CONVERSIONS.
PTR H = 5 * 7.          10* DESCRIPTOR LENGTH.
FLG J = 1.              FLAG TO TERMINATE CREATED SYMBOL.
PTR J = 0 + 0.
FLG L = 1.              END-OF-LINE INDICATOR.
VAL L = 0 - 1.          CHARRIAGE RETURN IS -1.
PTR L = 0 + 0.          LOCATION COUNTER.
VAL M = CHAR.           LEFT PARENTHESIS.
PTR M = 0 + 0.          RESET THE SKIP COUNT.
FLG N = 0.              SET EXPRESSION SIGN POSITIVE.
VAL N = CHAR.           ADDITION OPERATOR.
FLG O = 0.
VAL O = CHAR.           SUBTRACTION OPERATIOR.
VAL P = CHAR.           MULTIPLICATION OPERATOR.
VAL Q = CHAR.           DIVISION OPERATOR.
VAL R = CHAR.           RIGHT PARENTHESIS.
PTR R = 0 + 0.          SET NO REPETITION IN PROGRESS.
PTR 4 = 7 + 7.          LENGTH OF TWO DESCRIPTORS.
PTR 8 = F + 7.          POINT TO THE FIRST AVAILABLE SPACE.
TO 01 BY D.             START WORKING IN EARNEST.
LOC 01.                 ROUTINE TO READ FROM THE INPUT.
GET I = A.              RECALL THE CHANNEL SPEC.
READ NEXT I.            GRAB A LINE.
TO 98 IF FLG I NE 0.    GET OUT UNLESS ALL IS OK.
PTR I = C + 0.
VAL Y = 0 + 0.
PTR Y = C + 0.
TO 02 IF PTR M = 0.     SHOULD THIS LINE BE SKIPPED, NO.
PTR M = M - 1.          YES, DROP THE SKIP COUNT
TO 01.                  TRY AGAIN.
LOC 02.                 READING LOOP.
PTR 9 = I + 0.          ADVANCE THE SPACE POINTER.
VAL I = CHAR.   READ THE NEXT CHARACTER.
PTR I = 9 - 7.          POINT TO THE NEXT CHARACTER SPACE.
TO 97 IF PTR 8 GE I.    HAVE WE OUTRUN THE AREA, YES.
STO 9 = I.              PUT AWAY THE CHARACTER.
TO 04 IF VAL I = L.     WAS THIS A CARRIAGE RETURN, YES.
TO 03 IF VAL I = A.     HAVE WE COMPLETED THE READ, YES.
VAL Y = Y + 1.          BUMP THE INPUT STRING LENGTH.
TO 02 IF VAL I NE B.    NO, IS THIS A PARAMETER FLAG, NO.
PTR B = I + 0.          YES, SET THE PARAMETER POINTER AND
STO 9 = B.              STORE IT WITH THE PHASE FLAG.
TO 02.
LOC 03.                 READ THE REMAINDER OF THE LINE.
PTR 9 = I + 0.          POINT TO THE FIRST FREE SPACE.
VAL I = CHAR.           GRAB ANOTHER CHARACTER.
PTR I = 9 - 7.          SET POINTER TO NEXT CHARACTER
STO 9 = I.
TO 97 IF PTR 8 GE I.    HAVE WE RUN OUT OF SPACE, YES.
TO 03 IF VAL I NE L.    WAS THIS A CARRIAGE RETURN, NO.
LOC 04.                 SCANNER.
PTR U = 9 - 7.          SET ALL PARAMETERS UNDEFINED.
STO U = 3.
PTR U = U - 7.
STO U = 3.
PTR U = U - 7.
STO U = 3.
PTR U = U - 7.
STO U = 3.
PTR U = U - 7.
STO U = 3.
PTR U = U - 7.
STO U = 3.
PTR U = U - 7.
STO U = 3.
PTR U = U - 7.
STO U = 3.
PTR V = U - 7.
STO V = 3.
PTR U = V - 7.
PTR 9 = U + 0.          FREE SPACE POINTER.
TO 97 IF PTR 8 GE 9.
GET W = A.              SET UP THE TEMPLATE TREE POINTER.
GET X = Y.              GRAB THE FIRST INPUT POINTER.
FLG Y = 0.              SET THE STRING UNDEFINED.
PTR Z = A + 0.          SET THE TREE POINTER TO THE TEMPLATE ROOT.
TO 58 BY B.             CALL THE SCANNER.
TO 50 IF FLG B = 2.     IS THIS THE DEFINITION PHASE, YES.
TO 56 IF FLG Y = 0.     WAS THERE A DEFINITION, NO.
STO 9 = 1.              INITIALILY NO CREATED SYMBOLS FOR THIS MACRO
PTR 9 = 9 - H.          SPACE FOR THE CREATED SYMBOLS.
STO 9 = J.              PREVIOUS PARAMETER POINTER.
PTR J = 9 + H.          SET THE CURRENT PARAMETER POINTER.
PTR 9 = 9 - 7.
STO 9 = C.              PREVIOUS TEXT POINTER.
PTR 9 = 9 - 7.
STO 9 = D.              SAVE THE OLD RETURN ADDRESS.
PTR 9 = 9 - 7.
STO 9 = K.              SAVE THE CURRENT TEXT POINTER.
PTR K = U + 0.  SET UP THE NEW TEXT POINTER.
PTR 9 = 9 - 7.
STO 9 = R.              SAVE THE OLD REPETITION POINTER.
PTR R = 0 + 0.          SET NO REPETITION IN PROGRESS.
PTR C = 9 - 7.          NEW TEXT POINTER.
TO 97 IF PTR 8 GE C.    IS THE SPACE FULL ALREAD
TO 05 BY D.             GO PROCESS THE MCT
LOC 05.                 SUB PARAMS IN ONE LINE
PTR 9 = C + 0.          DISCARD ANY JUNK
PTR Y = 0 + 0.          RESET THE LOOP COUNTER.
LOC 06.
TO 07 IF PTR M = 0.     SHOULD WE SKIP LINES, NO.
PTR Z = K + 7.          RETAIN THE CODE BODY POSITINO.
GET K = K.              SKIP A LINE.
GET I = K.              GRAB THE TERMINATOR.
TO 08 IF VAL I = 1.     CHECK FOR THE END OF THE MACRO.
PTR M = M - 1.          DECREMENT THE SKIP COUNT.
GET Z = Z.              GRAB THE FIRST SKIPPED ELEMENT.
TO 06 IF FLG Z NE 3.    IGNORE NON FUNCTION CALLS.
PTR Y = Y + 1.          BUMP THE COUNT OF LOOPS ENTERED.
TO 06 IF VAL Z = 7.     LEAVE THE INCREMENT VALUE IF LOOP ENTERED
PTR Y = Y - 1.          ELSE DECREMENT THE COUNT
TO 06 IF VAL Z NE 8.
PTR Y = Y - 1.
TO 06 IF PTR Y GE 0.    AND GO ON IF SKIPPING AN ENTIRE LOOP.
TO 06 IF PTR R = 0.     OR IF THERE IS NO CURRENT LOOP.
PTR U = R - 7.          ELSE TERMINATE THE LOOP.
GET Y = U.
TO 49 IF FLG Y NE 1.    IS IT COUNT CONTROLLED, NO.
PTR C = R + 0.          YES, RESET THE LINE SPACE POINTER.
GET R = R.              RESOTRE THE ITERATION POINTER.
TO 05.                  IF NOT, CONTINUE
LOC 07.                 CHARACTER PROCESSING LOOP.
PTR K = K + 7.          ADVANCE THE POINTER AND
GET I = K.              FETCH THE NEXT CHARACTER.
TO 09 IF FLG I = 2.     IS THIS A PARAMETER CALL, YES.
TO 22 IF FLG I = 3.     NO, IS IT A COMPILER SWITCH, YES.
PTR I = 9 - 7.          NO, SET THEPOINTER TO THE NEXT SPACE.
STO 9 = I.      PUT THE CHARACTER IN THE PSEUDO-INPUT.
PTR 9 = I + 0.          ASVANCE THE SPACE POONTER.
TO 97 IF PTR 8 GE 9.    IS THE SPCAE EXHAUSTED, YES.
TO 07 IF FLG I = 0.     WAS THAT THE LAST CHARACTER, NO.
PTR Y = C - 9.          SET THE PSEUDO-INPUT LENGTH.
PTR Y = Y / 7.
PTR Y = Y - 1.
VAL Y = PTR Y.
PTR Y = C + 0.
TO 04 IF VAL I NE 1.    WAS THAT THE END OF THE CODE BODY, NO.
LOC 08.
PTR 9 = J - H.          RESTORE FROM THE CORRENT RECURSION.
GET J = 9.
PTR 9 = 9 - 7.
GET C = 9.              TEXT SPACE POINTER.
PTR 9 = 9 - 7.
GET D = 9.              RETURN ADDRESS.
PTR 9 = 9 - 7.  
GET K = 9.              CODE BODY POINTER.
PTR 9 = 9 - 7.
GET R = 9.              ITERATION POINTER.
RETURN BY D.
LOC 09.                 DO PARAMETER CONVERSION.
PTR V = J + I.          NO, FIND PARAMETER POINTER.
TO 21 IF VAL I = 6.     SET A PARAMETER.
GET Y = V.              AND LOAD IT.
TO 45 IF VAL I = 7.     INITIATE REPETITION OVER AN ARGUNET LIST.
TO 23 IF FLG Y = 3.     ERROR IF PARAMETER IS UNDEFINED.
GET X = Y.              GET THE FIRST CHARACTER.
TO 11 IF VAL I = 0.     COPY CONVERSION.
TO 10 IF VAL I = 1.     SYMBOL REFERENCE.
TO 12 IF VAL I = 2.             LOCATION SYMBOL DEFINITION.
TO 15 IF VAL I = 4.             REQUEST FOR EXPRESSION CONVERSION.
PTR X = Y + 0.
TO 20 IF VAL I = 3.             REQUEST THE BREAK CHARACTER.
PTR N = VAL Y.
TO 18 IF VAL I = 5.             REQUEST FO PARAMETER LENGTH.
TO 23 IF VAL Y NE 1.            IF NOT ONE CHARACTER, SIGNAL ERROR.
PTR N = VAL X.
TO 18 IF VAL I = 8.             REQUEST FOR INTERNAL REPRESENTATION.
MESSAGE CONV TO 4.              THE CONVERSION DIGIT IS UNAVAILABLE.
TO 94 BY B.                     CALL ERROR TRACEBACK.
TO 07.                          CONTINUE WITH THE LINE.
LOC 10.                         DEAL WITH A LOCATION SYMBOL.
PTR V = 9 + 7.                  STACK POINTER FOR SCANNER.
GET W = F.                      SET UP THE SYMBOL TREE.
PTR Z = F + 0.                  SET THE TREE POINTER TO THE SYMBOL ROOT
TO 58 BY B.                     CALL ON THE SCANNER.
TO 07 IF FLG Y NE 1.            WAS THE SYMBOL DEFINED, NO.
FLG I = 0.                      PREPARE TO COPY OVER THE SYMBOL VALUE.
GET X = Y.                      NO, GRAB THE FIRST CHARACTER.
LOC 11.
TO 07 IF VAL Y = 0.
GET I = X.                      FETCH NEXT CHAR
PTR X = 9 - 7.                  SET POINTER
STO 9 = X.                      PUT IT IN PSEUDO INPUT
PTR 9 = X + 0.                  POINT TO THE NEXT FREE SPACE.
VAL Y = Y - 1.                  DECREMENT THE CHARACTER COUNT.
TO 07 IF VAL Y = 0.             ARE WE DONE, YES.
GET X = I.                      NO, GET THE NEXT CHARACTER.
PTR I = 9 - 7.                  SET ITS POINTER.
STO 9 = I.                              PUT AWAY THE COPY.
PTR 9 = I + 0.                  POINT TO THE NEXT FREE SPACE.
TO 97 IF PTR 8 GE 9.            HAVE WE EXHAUSTED THE SPACE, YES.
VAL Y = Y - 1.          NO, DROP THE COUNT OF CHARACTERS.
TO 11.
LOC 12.                         MOVE A DEFINITION TO THE OUTPUT.
FLG B = 2.                      ALLOW SYMBOL DEFINITION.
GET W = F.                      SET UP THE SYMBOL TREE.
PTR Z = F + 0.          SET THE TREE POINTER TO THE SYMBOL ROOT.
TO 58 BY B.                     CALL ON THE SCANNER.
FLG B = 0.                      EXIT THE DEFINITION PHASE.
GET X = Y.
TO 11 IF FLG Y = 1.             IS THIS A NEW SYMBOL, NO.
PTR Y = 8 + 0.          YES, SET UP THE DEFINITION POINTER.
FLG Y = 1.              MARK IT AS HAVING BEEN DEFINED.
PTR L = L + 1.          BUMP THE LOCATION COUNTER.
PTR X = L + 0.          AND INSERT IT AS THE DEFINITION.
PTR W = 9 + 7.          USE STORE AT THE TOP AS TERMORARY.
VAL Y = 0 + 0.          COUNT THE DIGITSD.
LOC 13.                 CONVERT ONE DIGIT ATA TIME.
PTR V = X / 5.          GET THE UUOTIENT BY INTERGER DIVISION.
PTR Z = V * 5.          THE REMAINDER MUST BE FOUND BY MULTIPLICATION
PTR X = X - Z.                  AND THEN SUBTRACTING.
VAL X = PTR X.                  MOVE THE RESULT TO THE VALUE FIELD.
PTR X = V + 0.                  THE QUOTIENT IS TO BE OPERATED ON NEX.
PTR W = W - 7.                  ADVANCE THE TERMORARY STORAGE POINTER.
STO W = X.                      AND SALT AWAY THE RESULT.
VAL Y = Y + 1.                  BUMP THE DIGIT COUNT.
TO 97 IF PTR 8 GE W.            HAVE WE RUN OUT OF ROOM, YES.
TO 13 IF PTR X NE 0.            NO, WMUST WE GO ON, YES.
LOC 14.                         MOVE THE DIGITS TO THE DESTINIATION.
GET X = W.                      RECOVER A POSSIBLE DIGIT.
PTR W = W + 7.                  MOVE THE DIGIT POINTER. BACK.
VAL X = X + E.                  MAKE THE DIGITS INTO CHARACTERS.
PTR X = 8 + 7.                  SET UP A POINTER TO THE NEXT SPACE.
STO 8 = X.              PUT AWAY THE CHARACTER.
PTR 8 = X + 0.          BUMP THE SPACE POINTER.
TO 14 IF PTR 9 GE W.            DID WE REALLY HAVE ANOTHER DIGIT, YES.
STO 8 = 0.              PUT IN THE TERMINATOR.
PTR 8 = 8 + 7.          ADVANCE THE SPACE POINTER.
TO 97 IF PTR 8 GE 9.
STO U = Y.              PUT AWAY THE POINTER TO THE DEFINITION.
GET X = Y.              PUCK UP THE FIRST CHAR OF THE DEFINITION.
FLG I = 0.              CLEAN OUT THE INPUT VUFFER.
TO 11.                  COPY OUT THE VALUE.
LOC 15.         PROCESS AN EXPRESSION PARAMETER.
TO 74 BY P.             EVALUATE THE EXPRESSION.
TO 18 IF PTR N GE 0.            AND TEST FOR NON-NEGATIVE.
PTR O = 9 - 7.          IF NEGATIVE, INSERT A MINUS SIGN.
TO 97 IF PTR 8 GE O.
STO 9 = O.
PTR 9 = O + 0.
PTR N = 0 - N.          MAKE THE NUMBE POSITIVE AND
TO 18.          STORE DOWN.
LOC 16.         CONVERSION OF APRM ZERO (LOC. CNTR.
GET Y = V.              GRAB THE NEXT CREATED SYMNBOL.
TO 17 IF FLG Y = 1.             IS THIS A SYMBOL, NO.
PTR V = V - 7.          YES, ADVANCE THE CREATED SYNBOL POINTER.
TO 16 IF VAL Y NE I.            IS THIS THE RIGHT SYMBOLM NO.
PTR N = Y + 0.          YES, SET UP ITS VALUE 
TO 18.          AND INSET IT IN THE LINE.
LOC 17.         CREATE A NEW SYMBOL.
PTR Y = V + H.          CHECK THAT THERE IS AOON FOR IT.
TO 23 IF PTR Y = J.             IF NOT, TREAT AS A CONVERSION ERROR.
PTR L = L + 1.          BUMP THE LOCATION COJNTER.
PTR I = L + 0.          SAVE THE NEW VALUE IN THE NEXT SPACE.
STO V = I.
PTR V = V - 7.          FLAG THE NEXT ENTRY AS NO SYMBOL.
GET Y = V.
FLG Y = 1.
STO V = Y.
PTR N = L + 0.
LOC 18.                 INSERT IN LINE
PTR Y = N / 5.          GET QUOTIENT
PTR Z = Y * 5.          THE REMAINDER MUST VE FOUND BY MULTIPLYING
PTR X = N - Z.          AND THEN SUBTRACTIN.
FLG X = 0.
VAL X = PTR X.          MOVE THE RESULT TO THE VALUE FIELD.
PTR N = Y + 0.          THE QUOTIENT IS TO VBE OPERATED ON NEXT.
VAL G = G + 1.          ADVANCE THE TEMPORRY STORAGE COUNT.
PTR 8 = 8 + 7.
STO 8 = X.              AND SALT AWAY THE RESULT.
TO 18 IF PTR N NE 0.            NO, MUST WE GO ON, YES.
LOC 19.         MOVE THE DIGITS TO THEIR DESTINATION.
GET X = 8.              RECOVER A POSSIBLE DIGIT.
PTR 8 = 8 - 7.          MOVE THE DIGIT POINTER BACK.
VAL G = G - 1.
VAL X = X + E.          MAKE THE DIGITS INTO CHARACTES.
PTR X = 9 - 7.          SET UP A POINTER TO THE NEXT SPACE.
STO 9 = X.              PUT AWAY THE CHARACTER.
PTR 9 = X + 0.          PDROP THE SPACE POINTER.
TO 19 IF VAL G NE 0.            DID WE REALLY HAVE ANOTHE DIGIT, YES.
TO 07.          NO, GO BACK TO THE LINE PROCESSOR.
LOC 20.         ADVANCE TO A BREAK CHARACTER.
GET X = X.              GET THE NEXT CHAR
VAL Y = Y - 1.          AND DROP THE NUMBER REMAINING.
TO 20 IF VAL Y NE L.            WAS THAT THE BREAK, NO.
TO 07 IF FLG X = 1.             END-OF-LINE IS THE NULL BR3EAK.
PTR X = 9 - 7.          SET THE POINTER
TO 97 IF PTR 8 GE X.
STO 9 = X.              AND PUT AWAY THE BREAK CHARACTER.
PTR 9 = X + 0.
TO 07.
LOC 21.         SET A PARAMETER.
STO 9 = L.              TERMINATE THE CURRENT LINE.
PTR K = K + 7.          BYPASS THE NEXT CHAR.
PTR Y = C - 9.                  ET UP THE SPECIFICATION OF THE
PTR Y = Y / 7.          CURRENT STRING.
FLG Y = 0.
VAL Y = PTR Y.          LENGTH IN CHARS.
PTR Y = C + 0.          POINTER T THE FIRST CHAR.
STO V = Y.              SET THE PARM STOR.
PTR C = 9 - 7.          NEXT EMPTY SPACE FOR NEW LINE.
TO 05.
LOC 22.                 DECODE COMPILER SWITCHES.
PTR V = J + 0.          SET A PARM POINTER.
TO 16 IF PTR I = 0.             IS THIS A CALL ON PARM ZERO, YES.
TO 08 IF VAL I = 9.             ESCAPE FROM THE CURRENT MACRO.
PTR V = V + 7.          QDVANCE THE PARMETER POINTER.
PTR K = K + 7.          BYPASS THE CAHR FOLLOWING THE SWITHC.
TO 32 IF VAL I = 1.             OUTPUT A LINE WITHOUT RESCANNING.
TO 32 IF VAL I = 2.             CHANGE I/O UNITS AND COPY.
TO 33 IF VAL I = 3.             REDEFINE A SYMBOL.
TO 42 IF VAL I = 4.             SKIP ARG 1 LINES UNCONDITIONALLY.
TO 36 IF VAL I = 5.             COMPARE ARG 1 AND ARG 2 AS EXPRESSIONG.
TO 39 IF VAL I = 6.
TO 43 IF VAL I = 7.             INITIATE A REPETITION UNDER COUNT CONTROL.
TO 47 IF VAL I = 8.             ADVANCE TO THE NEXT MEMBER OF THE LIST.
TO 23 IF VAL I NE 0.            IF NOT A REQUEST FOR TERMINATION, COMPLAIN
STOP.           ELSE TERMINATE NORMALLY.
LOC 23.         ERROR IN CONVERSION CIFIT.
MESSAGE CONV TO 4.              PUT OUT THE MESSAGE.
TO 94 BY B.             PRODUCE A TRACEBACK
TO 07.          AND THEN CONTINUE.
LOC 32.         CHECK FOR ALTERNATE OUTPUT UNIT.
GET X = K.              THIS MIGHT BE A CHANNEL NUMBER.
VAL W = 3 + 0.                  THE DEFAULT OUTPUT CHANNEL IS 3.
TO 24 IF FLG X = 1.             IF NO CHANNEL NUMBER TAKE THE DEFAULT.
PTR K = K + 7.          ELSE ADVANEC THE DOE BODLY PTR.
VAL W = X - E.          CONVERT THE DIFIT TO AN INTEGER.
GET X = K.              CHECK FOR REWIND REQUEST.
TO 24 IF FLG X = 1.             IF NONE, CONTINUE.
REWIND W.               ELSE REWIND THE OUTPUT CHANNEL.
FLG W = 0.
PTR K = K + 7.          AND ADVANCE THE CONDE BODY PTR.
LOC 24.
TO 31 IF VAL I = 2.     START BLOCK COPY
STO 9 = L.              TERMINATE LINE
PTR X = C + 0.          PT TO START OF LINE
TO 57 IF PTR C NE 9.            PUNCH IT IF IT EXISTS.
PTR K = K + 7.
GET I = K.                      ELSE BACKSPACE THE CODE BODY
TO 25 IF FLG I NE 1.           CONT IF VALID
PTR K = K - 7.
TO 23.
LOC 25.
PTR Z = VAL I.
PTR Z = Z - E.
TO 28 IF PTR Z GE 5.
TO 28 IF PTR 0 GE Z.
VAL X = I + 0.          IF SO, SAVE FOR FUTURE REFERENCE.
PTR Z = Z * 7.          COMPUTE THE PARM LOCATION
PTR Y = J + Z.          AND GRAB ITS SPECIFICATION.
GET Y = Y.
TO 27 IF FLG Y = 3.             TREAT AN UNDEFINED PRAM AS VOID.
GET Z = Y.              PICK UP THE FIRST CHAR.
LOC 26.
TO 27 IF VAL Y = 0.             IS THE PARM V`VOID, YES.
CHAR = VAL Z.           NO, OUTPUT A CHA.
GET Z = Z.              PICK UP THE NEXT CHAR OF THE PARMS
VAL Y = Y - 1.          AND DROP THE NUMVER REMAINING.
PTR K = K + 7.          ADVANCE THE POINTER.
GET I = K.              GRAB THE NEXT CHAR OF THE CODE BODY.
TO 26 IF VAL I = X.             IS IT THE SAME DIGIT, YES.
TO 25.
LOC 27.
CHAR = VAL F.
PTR K = K + 7.
GET I = K.
TO 27 IF VAL I = X.
TO 25.
LOC 28.
TO 57 IF FLG I = 1.
CHAR = VAL I.
PTR K = K + 7.          ELSE ADVANCE ALONG THE CODE BODY.
GET I = K.
TO 25.
LOC 31.
GET I = A.
TO 29 IF PTR C = 9.
GET X = C.              ELSE GRAB THE UNIT NUMBER
VAL I = X - E.          ANE CONVERT IT TO AN INTEGER.
STO A = I.              CHANGE THE CURRENT UNIT IN STOR.
TO 29 IF PTR X = 9.             IF NO REWIND REQUEST, CONTINUE.
REWIND I.               ELSE PERFORN THE REWIND
FLG I = 0.
TO 98 IF FLG I NE 0.            AND QUIT UNLESS IT WAS ALL OK.
LOC 29.         BLOCK COPY FROM INPUT TO OUTPUT.
GET X = V.              PICK UP THE PARM SPEC.
TO 05 IF VAL X = 0.             NO COPYING IF PARM IS VOID.
TO 05 IF FLG X = 3.             OR UNDEFINED.
PTR Y = X + 0.          ELSE SET UP THE ADDRESS OF THE FIRST CHAR.
READ NEXT I.             GET THE NEXT LINE.
TO 98 IF FLG I NE 0.            GET OUT UNLESS ALL IS OK.
LOC 30.         CHECK FOR THE TERMINATOR.
TO 05 IF VAL X = 0.             RETURN IF THE MATCH IS COMPLETE.
VAL X = X - 1.          ELSE DECREMENT THE CHAR COUNT.
GET Y = Y.              PICK UP THE NEXT TERMINATOR CHAR.
VAL Z = CHAR.           AND INPUT CHAR.
TO 30 IF VAL Y = Z.             IF WE ARE STILL MATCHING, GO ON.
WRITE NEXT W.
TO 29 IF FLG W = 0.
STOP.
LOC 33.
GET Y = V.              NAME OF SYMBOL TO BE REDEFINED.
TO 23 IF FLG Y = 3.
TO 05 IF VAL Y = 0.
GET X = Y.
FLG B = 2.              ALLOW SYMBOL ENTRY.
GET W = F.              SET UP THE SYMBOL TREE.
PTR Z = F + 0.          SET THE TREEE POINTER TO THE SYMBOL ROOT.
TO 58 BY B.             CALL ON THE SCANNER.
FLG B = 0.              RESET PAHSE FLAG.
FLG W = Y.              SAVE THE DEFINITIO FLAG.
PTR W = U + 0.          POINT O THE DEFINITIN PTR.
PTR Z = Y + 0.          SET THE SYMBOL POINTER
PTR V = V + 7.          GET THE NEW DEFINITION OF THE SYMBOL.
GET Y = V.
TO 23 IF FLG Y = 3.             ERROR IF PARM IS UNDEFINED.
PTR X = Y + 0.          POINT TO THE FIRST CHAR OF THE
FLG Z = 1.              NEW DEFINITION. CLEAR OUT THE TERM
VAL Z = Y + 0.          SET THE NEW SYMBOL LENGTH.
TO 35 IF FLG W NE 1.            WAS THERE A DEFINITION, NO.
STO W = Z.
TO 05 IF VAL Y = 0.
LOC 34.
GET X = X.
PTR W = Z + 0.
GET Z = W.              GRAB THE OLD CONTENTS OF THE SPACE.
VAL Z = X + 0.          MOVE THE CAHR INTO THE SPACE.
STO W = Z.
VAL Y = Y - 1.
TO 35 IF PTR Z = 0.
TO 34 IF VAL Y NE 0.            YES IS THEERE MOVER DEFINITION, YES.
TO 05.
LOC 35.         CREATE NEW SPACE FOR THE DEFINITION.
PTR Z = 8 + 0.          POINT TO THE NEXT AVAILABLE SPACE.
STO W = Z.      PUT AWAY THE CAHR.
PTR 8 = 8 + 7.          ADVANCE THE POINTER
TO 97 IF PTR 8 GE 9.            AND TEST FOR SPACE OVERFILL.
PTR W = Z + 0.          ADVANCE THE CHAR POIINTER.
GET Z = X.              GRAB THE NEXT DEFINITION CHAR.
PTR X = Z + 0.          DECREMENT THE CHAR COUNT.
VAL Y = Y - 1.
TO 35 IF VAL Y NE L.            CHECK  TERMINATION OF THE DEFINITION.
STO W = 0.              STORE THE TERMINATOR IF THERE IS NO MORE.
TO 05.
LOC 36.         COMPARE TWO STRINGS.
GET I = K.              PICK UP THE CONDITION CODE.
PTR K = K + 7.          BYPASSS THE NEXT CHAR.
GET Y = V.
PTR V = V + 7.
GET Z = V.
TO 23 IF FLG Y = 3.             ERROR IF PARM IS UNDEFINED.
TO 23 IF FLG Z = 3.
PTR V = V + 7.          OTHERWISE PICK UP THE THIRD ARGUMENT
TO 41 IF VAL Y NE Z.            COULD THEY BE EQUAL NO.
TO 38 IF VAL Y = 0.
PTR X = Z + 0.
LOC 37.
GET X = X.
GET Y = Y.
TO 41 IF VAL X NE Y.            ARE THEY EQUAL, NO.
VAL Z = Z - 1.          YES, DROP THE NUMBER REMAINING.
TO 37 IF VAL Z NE 0.            ARE WE DONE, NO.
LOC 38.         THE STRINGS ARE EQUAL.
TO 05 IF VAL I NE E.            IS THE CONDITION CODE EQ, NO.
TO 42.
LOC 39.         COMPARE TWO EXPRESSIONS.
GET I = K.              PICK UP THE CONDITION CODE.
PTR K = K + 7.          BYPASS THE NEXT CHAR.
GET Y = V.              FIRST ARGUMENT SPECIFICATION.
TO 23 IF FLG Y = 3.             ERROR IF PARM IS UNDEFINED.
TO 74 BY P.             EVALUATE THE FIRST PARM.
PTR I = N + 0.          SAVE THE VALUE OF THE FIRST ESPRESSION.
PTR V = J + 4.
GET Y = V.              SET UP THE SECOND PARM.
TO 23 IF FLG Y = 3.             ERROR IF PARM IS UNDEFINED.
TO 74 BY P.             EVALUATE IF.
PTR V = J + 4.
PTR V = V + 7.
PTR N = N - I.          COMPUTE THE DIFFERENCE.
TO 38 IF PTR N = 0.             WERE THE PARMS EQUAL, YES.
TO 40 IF PTR N GE 0.            NO, WAS THE SECOND LARGER, YES.
TO 05 IF VAL I = O.
TO 41.
LOC 40.
TO 05 IF VAL I = N.
LOC 41.
TO 05 IF VAL I = E.             IS THE CONDITION EQ, YES.
LOC 42.         SET UP THE SKIP COUNTER.
GET Y = V.
TO 23 IF FLG Y = 3.             ERROR IF PARM IS UNDEFINED.
TO 05 IF VAL Y = 0.             IS IT VOID, YES.
TO 74 BY P.             CONVERT A POSSIBLE EXPRESSION.
PTR M = N + 0.          SET THE COUNT.
TO 05.
LOC 43.         ITERATE UNDER COUNT CONTROL.
PTR Y = C - 9.          SET UP SPECIFICATION OF THE
PTR Y = Y / 7.          CURRENT STRIN.
VAL Y = PTR Y.          LENGTH IN CAHRS.
TO 07 IF VAL Y = 0.             IF NULL, IGNORE IT.
PTR Y = C + 0.          POINTER TO THE FIRST CAHR.
TO 74 BY P.             EVALUATE THE LINE AS AN EXPRESSION.
FLG Y = 1.              SET UP THE RESULT AS AN ITERATION COUNT.
VAL Y = 0 + 0.
PTR Y = N + 1.
STO C = R.              SAVE THE CURRENT ITERATION POINTER.
PTR Z = R + 0.          PREPARE TO RESTORE IT.
PTR R = C + 0.          SET A NEW ONE.
PTR C = C - 4.
STO C = K.              SAVE THE CURRENT CODE BODY POINTER.
LOC 44.         RE-ENTRY FOR ANOTHER ITERATION.
PTR C = R + 0.          RESET THE TEXT POINTER.
PTR R = Z + 0.          RESET THE ITERATION POINTER.
PTR Y = Y - 1.          DECREMENT THE ITERATION COUNT.
TO 05 IF PTR 0 GE Y.            GET OUT IF NO MORE ARE NEED.
PTR R = C + 0.          ELSE RESET THE ITERATION POINTER.
PTR C = C - 7.
STO C = Y.              SAVE THE CURRENT COUNT.
PTR C = C - 7.          
GET K = C.              RESTORE THE CODE BODY POINTER.
PTR C = C - 7.          NEW SPACE FOR THE NEXT TEXT LINE.
TO 05.
LOC 45.                 ITERATE UNDER CONTEXT CONTROL
STO 9 = L.              TERMINATE THE PARM STRIN.
PTR W = C - 9.          SPECIFY THE CURRENT STRIN.
PTR W = W / 7.          COMPUTE ITS LENGTH IN CHARS.
FLG W = 0.              FLG FOR CONTEXT-CONTROLLED ITERATION.
VAL W = PTR W.          LENGTH IN CHARS.
PTR W = C + 0.          PTR TO THE FIRST CHAR.
PTR 9 = 9 - 7.
FLG B = 2.              CONSTRUCT EH TREE FOR ARGUEMTN SCANNING.
PTR B = 0 + 0.          SET UP THE PARAMETER.
FLG U = 0.              SET UP THE RIGHT PAREN.
VAL U = R + 0.
PTR U = 7 + 0.
FLG Z = 1.              END-OF-LINE.
VAL Z = 0 + 0.          INITIALIZE BREAK COUNT.
PTR Z = 0 + 0.
PTR X = 9 - 7.
LOC 46.                 ADD BREAK CHARS TO THE TREE.
VAL Z = Z + 1.          BUMP THE BREAK COUNT.
STO 9 = Z.              END-OF-LINE.
PTR 9 = 9 - 7.
STO 9 = U.              RIGHT PAREN.
PTR 9 = 9 - 7.
STO 9 = B.              PARM FLAG.
PTR 9 = 9 - 7.
PTR K = K + 7.
GET I = K.              GRAB THE NEXT BREAK.
PTR I = X - 9.          POINT TO THE ALTERNATIVE.
STO 9 = I.              CURRENT BREAK CHAR.
PTR X = 9 + 0.          SAVE THE CURRENT POSITION FOR AN ALTERNATE.
PTR 9 = 9 - 7.
TO 97 IF PTR 8 GE 9.
TO 46 IF FLG I NE 1.
STO 9 = B.              ANOTHER PARM FLAG.
FLG B = 0.              RESET PHASE FLAG.
PTR Z = 9 + 0.          SET UP A POINTER TO THE ROOT LOCATION.
PTR 9 = 9 - 7.
VAL U = M + 0.          SET UP A LEFT PAREN.
STO 9 = U.              TREE ROOT.
PTR 9 = 9 - 7.
STO 9 = R.              PREVIOUS ROOT POINTER
PTR 9 = 9 - 7.
STO 9 = C.              PREVIOUS TEXT PTR.
PTR 9 = 9 - 7.
STO 9 = V.              PTR TO PARM STOE.
PTR 9 = 9 - 7.
STO 9 = Y.              ORIGINAL PARM SPEC.
PTR R = 9 - 7.          NEW REPETITION PTR.
STO R = Z.              NEW ROOT PTR.
PTR 9 = R - 7.          
STO 9 = W.              PARM REMAINDER.
PTR 9 = 9 - 4.
STO 9 = K.              CURRENT EXT PTR.
PTR Z = Z - 7.          FIRST TIME ROOT PTR.
TO 48.
LOC 47.                 RE-ENTER FOR NEXT REPETITION.
TO 05 IF PTR R = 0.             IF THERE IS NO REPETITION, GET OUT.
GET Z = R.              ELSE POINT THE SCANNER TO THE ROOT.
LOC 48.         FIRST TIME ENTRY POINT.
PTR U = R - 7.          REMAINDER OF THE LIST.
GET Y = U.
TO 44 IF FLG Y = 1.             IS THIS ITERATION UNDER COUNT CONTRO, YES.
TO 49 IF VAL Y = 0.             TERMINATER THE ITERATION ON A NULL REMAINDER
STO U = 0.              ELSE SET UP ANOTHER SCAN.
PTR U = U - 4.
GET K = U.              RESET THE CODE BODY POINTER.
PTR V = U + 0.          SET UP THE STACK PTR.
PTR 9 = U - 7.
PTR C = 9 + 0.          RESET THE TEXT ORIGIN.
GET X = Y.              GRAB THE FIRST CHAR AND
TO 99 BY B.             GO CHECK FOR SINGLE-CHAR BREAKOUT.
PTR Y = R + 4.          GET THE ADDRESS OF THE PARM
GET W = Y.
PTR Y = R - 4.          GET THE NEW VALUE OF THE SPEC.
TO 97 IF PTR 8 GE Y.
GET Y = Y.              
STO W = Y.              AND PUT IT IN THE PARM SPACE.
TO 05.          CONTINUE WITH THE CODE BODY.
LOC 99.         ADHCK AND SERVICE SINGLE-CHAR SPLITS.
TO 60 IF VAL Z NE 1.            IF BRAK CHARS USED, GOTO THE SCANNER.
FLG X = 0.              ELSE PICK OFF A SINGLE CHAR.
VAL X = Y - 1.          DROP THE LENGTH OF THE PARM.
VAL Y = 1 + 0.          SET THE NEW PARM LENGHT TO 1.
PTR U = U + 7.          SAVE THE NEW PARM SPEC.
STO U = Y.
PTR U = U + 7.          ALSO SAVE TH E REMAINDER OF THE STRIN.
STO U = X.
RETURN BY B.            RETURN AS THOUGH FROM THE SCANNER.
LOC 49.         TERMINATE THE ITERATION.
TO 44 IF FLG Y = 1.             IS THIS ITERATION UNDER COUNT CONTRL, YES.
PTR R = R + 7.
GET Y = R.              RESTORE THE ORIGINAL VALU OF THE
PTR R = R + 7.                  PARM SPEC.
GET W = R.
STO W = Y.
PTR R = R + 7.
GET C = R.                      RESTORE THE TEXT PTR.
PTR R = R + 7.
GET R = R.
TO 05.
LOC 50.         DEFINE A MACRO.
FLG Y = 1.              MARK IT AS DEFINED.
VAL Y = L + 0.          LINE TERMINATOR.
PTR 8 = 8 - 7.
TO 54.
LOC 51.
VAL I = CHAR.
STO 8 = I.              ASSUMET TAHT IT IS A SPECIAL TO BE SAVE.
TO 52 IF VAL I = C.             IF IT IS REALLY IS AN MCT PARM OR END-
TO 52 IF VAL I = D.             OF-LINE FLAG, THEN GO ON TO THE NEXT CHAR.
VAL I = I - E.          ELSE CONVERT A POSSIBLE DIGIT CHAR.
FLG Z = 3.              ASSUME THAT IT IT S FUNCTION CALL.
VAL Z = CHAR.           GET THE PARM CONVERSION FO FUNCTIL.
VAL Z = Z - E.          CONVERT FROM A CHAR TO A N INTERGER.
PTR Z = VAL I.          PUT AWAY THE SPEC.
STO 8 = Z.
TO 52 IF PTR 0 GE Z.            IF IT IS REALLY A FUNCTION, GO ON.
TO 52 IF PTR Z GE 5.
FLG Z = 2.              OTHERWISE MAKE IT A PARM CONVERSION.
PTR Z = Z * 7.          SET UP THE RELATIVE ADDR OF THE PARM.
STO 8 = Z.
LOC 52.         PROCESS AN MCT LINE.
PTR 8 = 8 + 7.          ADVANCE THE APCE PTR.
TO 97 IF PTR 8 GE 9.            HAVE WE RUN OUT OF ROOM, YES.
VAL I = CHAR.           READ THE NEXT CHAR.
STO 8 = I.              STORE IT.
TO 51 IF VAL I = D.             IS THIS AN ESCAPE CHAR, YES.
TO 53 IF VAL I = L.             RECOGNIZE A CARRIAGE CNOTROL.
TO 52 IF VAL I NE C.            NO, WAS IT AN MCT END-OF-LINE, NO.
LOC 53.
PTR Y = 8 + 0.          POINT TO THE CURRENT LINE TERMINATOR.
STO U = Y.              SET UP THE PREVIOUS TERMINATOR.
PTR U = 8 + 0.          UPDATE THE TERMINATOR ADDRESS.
LOC 54.         READ AND STORE A NEW MCT LINE.
GET I = A.              RECALL THE CHANNEL SPECIFIER.
READ NEXT I.            GRAB THE NEXT LINE.
TO 98 IF FLG I NE 0.            GET OUT UNLESS ALL IS OK.
VAL I = CHAR.           READ THE FIRST CHAR OF LINE.
PTR I = 0 + 0.          CLEAN OUT INPUT REGISTER.
PTR 8 = 8 + 7.          ADVANCE THE SPACE PTR.
STO 8 = I.              PUT IT AWAY.
TO 51 IF VAL I = D.             WAS IT A PARM FLAG, YES.
TO 52 IF VAL I NE C.            WAS IT AN END-OF-LINE, NO.
PTR Y = 8 + 0.                  FILL IN THE PREVIOUS TERMINATOR.
STO U = Y.
STO 8 = 1.
PTR 8 = 8 + 7.                  ADVANCE THE SPACE POINTER.
TO 97 IF PTR 8 GE 9.            HAVE WE OVERRUN THE AREA, YES.
VAL I = CHAR.           GET THE NEXT CHAR.
TO 55 IF VAL I NE C.            DID THAT CLOSE THE DEFINITION PHASE, NO.
FLG B = 0.              YES, RESET TEH PHASE FLAG.
LOC 55.         COMMON SYSTEM RETURN POINT.
RETURN BY D.            REGISTER D IS THE RETURN ADDDRESS.
LOC 56.         PUNCH AN UNRECOGNIZED LINE.
VAL W = 3 + 0.          CHANNEL 3 USED WHDN A LINE IS NOT MATCHED.
PTR X = C + 0.          ADDRESSS THE FIRST CHAR.
LOC 57.         LOOP TO PUT OUT THE CHAR.
GET X = X.              GET THE NEXT ONE.
CHAR = VAL X.           MOVE IT INTO THE LINE BUFFER.
TO 57 IF FLG X NE 1.            HAVE WE REACHED THE DND, NO.
WRITE NEXT W.           YES, PUT IT OUT ON THE DESIGNATE CHANNEL.
TO 98 IF FLG W NE 0.            TREAT ANY ERROR AS FATAL.
TO 55 IF VAL X = L.             ELSE IF THE LINE ID COMPLETE, RETURN.
CHAR = VAL X.           ELSE REPROINT THE LAST CHAR
TO 57.          AND CNOTINUE.
LOC 58.         TRY FOR AN ALTERNATIVE MATCH.
PTR Z = W + Z.          GET THE PTR TO THE ALTERNATIVE.
TO 60 IF PTR W NE 0.            WAS THERE ONE AFTER ALL, YES.
TO 71 IF FLG B = 2.             NO, ARE WE DEFINING, YES.
LOC 59.         TRY EXTERNING THE PREFIOUS PARM.
TO 70 IF PTR V GE 9.            IS THEREO NE TO EXTEND, NO.
GET Z = V.              RECALL THE MACRO POINTER.
GET Y = Q.              YES, RECALL THE INPUT POINTER
GET X = Y.              AND THE CURRENC THAT
TO 63 IF FLG Z = 2.             IS THIS THE FIRST TIMEFOR A PARM, YES.
TO 64 IF FLG Z = 3.             NO, IS ITA PARM EXTERNSION, YES.
PTR V = Q + 7.          ABANDON THE STACK ENTRY.
PTR Q = V + 7.
LOC 60.         TRY AN ALTERNATIVE.
GET W = Z.              GRAB THE MACRO CHAR.
TO 69 IF FLG W = 1.
TO 62 IF FLG W = 2.
TO 58 IF VAL Y = 0.
TO 58 IF VAL X NE W.
TO 61 IF PTR W = 0.             IS THERE AN ALTERNATIVE.
TO 61 IF FLG X = 3.             DI NO STACK ALTERNATIVES FOLLOWING A PARM
TO 61 IF FLG B = 2.             DON STACK ALTERNATIVES DURING DEFINITIONS.
PTR Q = V - 7.
PTR V = Q - 7.
TO 97 IF PTR 8 GE V.
STO Q = Y.              SAVE THE INPUT POINTER.
PTR W = W + Z.          GET THE ADDRESS OF THE ALTERNATIVE.
STO V = W.
LOC 61.
VAL Y = Y - 1.
PTR Y = X + 0.
GET X = X.              ADVANCE THE INPUT POINTER.
PTR Z = Z + 7.          ADVANCE THE MACRO POINTER.
TO 60.          CONTINUE MATCHING.
LOC 62.         SET UP A PARAMETER IF POSSIBLE.
TO 61 IF FLG X = 2.             IS THIS A PARM DEFINITION, NO.
TO 58 IF FLG B = 2.             NO, COULD WE NEED A PARM, NO.
PTR Q = V - 7.          CREATE AN AENTRY FOR TH PARM
PTR V = Q - 7.
TO 97 IF PTR 8 GE V.
STO Q = Y.
FLG Z = 2.              SET UP THE PARM POINTER.
STO V = Z.
FLG X = 3.              DON'T STACK FURTHER ALTERNAIVERS
TO 58.
LOC 63.
FLG Z = 3.
PTR Z = Z + 7.
STO V = Z.
PTR U = U + 7.
FLG W = 0.              
VAL W = 0 + 0.          SET THE PARM LENGTH TO ZERO.
PTR W = Y + 0.          POINT TO THE CURRENT INPUT CHAR.
STO U = W.
TO 60.
LOC 64.                 EXTEND THE CURRENT PARM.
TO 68 IF VAL Y = 0.     CAN IT BE EXTERNED, NO.
TO 68 IF VAL X = R.             VAIL ON AN UNMATCHED CLOSING PARM.
GET W = U.              INCREASE THE PARM LENGTH.
VAL W = W + 1.
VAL Y = Y - 1.
PTR Y = X + 0.
TO 67 IF VAL X NE M.            IS THIS AN OPEN PARN, NO.
VAL Z = 0 + 0.          YES, ZERO THE PAREN COUNT.
LOC 65.         OBTAIN A BALANCED STRING.
VAL Z = Z + 1.          BUMP THE APRENTHESIS COUNT.
LOC 66.
TO 68 IF VAL Y = 0.             FAIL IF THIS IS THE END.
GET X = X.              GRAB THE NEXT INPUT CHAR.
VAL Y = Y - 1.
PTR Y = X + 0.
VAL W = W + 1.          ELSE BUMP THE PARM LENGTH.
TO 65 IF VAL X = M.             IS IT ANOTHER OPEN PAREN, YES.
TO 66 IF VAL X NE R.            NO, IS IT A CLOSE PAREN, NO.
VAL Z = Z - 1.          YES, DROP THE PAREN COUNT.
TO 66 IF VAL Z NE 0.            CONTINUE IF THE COUNT IS NONZERO.
LOC 67.         CONTINUE THE SCAN.
GET X = X.              GET THE NEST INPUT CAHR.
STO Q = Y.              INCREMENT THE INTPUT PTR.
STO U = W.
TO 60.
LOC 68.         ABANDON THE CURRENT PARM.
STO U = 3.              SET THE PARM UNDEFINED.
PTR U = U - 7.          DROP THE PARM STOR PTR BACK.
PTR V = Q + 7.          ABANDON THE STACK ENTRY.
PTR Q = V + 7.
TO 59.          SEE IF THERE ARE OTHERS TO FALL BACK ON.
LOC 69.
TO 58 IF VAL Y NE 0.            IS THIS A FINAL MATCH, NO.
PTR U = Z + 7.          YES, POINT TO THE DEFINITION SPEC.
GET Y = U.
LOC 70.
RETURN BY B.            COMMON RETURN POINRT FOR PTR B RETURNS.
LOC 71.         ROUTINE TO ADD AMCRO DEFINITIONS.
PTR W = 8 - Z.          CREATE THE ALTERNATE PTR.
STO Z = W.              CHANGE THE CURRENT ALTERNATLE.
TO 73 IF VAL Y = 0.             TERMIANTE THE BRANCE IF THIS IS THE END.
LOC 72.         READ THE REMAINDER OF THE TERMOLACTE LINE.
VAL Y = Y - 1.
PTR Y = X + 0.
PTR X = 0 + 0.          RESET THE POINRT OF THE CURRENT CHR.
STO 8 = X.              PUT IT AWAY.
PTR 8 = 8 + 7.          ADVANCE THE SPACE PTR.
TO 97 IF PTR 8 GE 9.            HAVE WE OVERRUN THE AREA, YES.
GET X = Y.              GRAB THE NEXT CHAR.
TO 72 IF VAL Y NE 0.            WAS THAT THE LAST, NO.
LOC 73.         TERMINATE THE TREE BRANCH.
FLG X = 1.              SET THE MACRO TERMINATOR.
PTR X = 0 + 0.          SET FOR NO ALTERNATIVE.
STO 8 = X.
PTR U = 8 + 7.          SET UP A DEFINITION PTR.
FLG Y = 0.
PTR Y = U + 0.
STO U = Y.
PTR 8 = U + 7.
TO 97 IF PTR 8 GE 9.
RETURN BY B.
LOC 74.
PTR O = 9 + 0.          SAVE THE CURRENT TOP OF FREE SPACE.
VAL S = Y + 0.          SET UP THE STRING SPECIFIER.
PTR S = Y + 0.          
PTR T = 0 + 0.          INITIAL VALUE OF THE EXPRESSION IS ZERO.
TO 75 IF VAL Y NE 0.            IS THE EXPRESSION VOID, NO.
PTR N = 0 + 0.          YES, ITS VALUE IS ZERO.
RETURN BY P.
LOC 75.
VAL T = M + 0.          STACK A LEFT PAREN.
LOC 76.
TO 93 IF VAL S = 0.
GET X = S.              ELSE GRAB THE NEXT.
PTR Y = S + 0.          POINT TO A POSSIBLE SECTION START.
VAL Y = 0 + 0.          THE STRINT IS INITIALLY EMPTY.
TO 77 IF VAL X NE M.    IS THE CHAR A LEFT PAREN, NO.
STO 9 = T.              YES PUSH THE STACK.
PTR 9 = 9 - 7.
TO 97 IF PTR 8 GE 9.
VAL S = S - 1.          DROP THE STRINGLENGTH REMAINING.
PTR S = X + 0.          BUMP THE PTR.
TO 75.
LOC 77.         SPECIFY A SECTION.
TO 78 IF VAL X = N.             IS THIS A PLUS, YES.
TO 78 IF VAL X = O.             MINUS.
TO 78 IF VAL X = P.             TIMES.
TO 78 IF VAL X = Q.             DIVIDE.
TO 78 IF VAL X = R.             RIGHT PAREN.
VAL Y = Y + 1.          NOT AN OPERATIR. BUMP SECTION LENGTH.
GET X = X.              GRAB THE NEXT CHAR.
TO 77 IF VAL S NE Y.            IS THE STRING EXHAUSED, NO.
VAL X = R + 0.          YES, SET UP A RIGHT PAREN.
VAL S = S + 1.          PRETEND THAT IT WAS IN THE INPUT STRING.
LOC 78.
VAL J = X + 0.          SET P THE SECTION OPERATOR.
PTR N = 0 + 0.          ZERO THE ACCUMULATOR.
VAL S = S - Y.          UPDATE THE STRING POINTER.
VAL S = S - 1.
PTR S = X + 0.
TO 83 IF VAL Y = 0.             A NULL STRING HAS THE VALUE ZERO.
GET X = Y.              GRAB FIRST CHAR OF NON-NULL STRING.
PTR U = VAL X.          CHECK FOR A DIGIT.
PTR U = U - E.
TO 79 IF PTR U GE 5.
TO 81 IF PTR U GE 0.
LOC 79.         IF FIRST CHAR IS NOT A DIGIT, LOOK UP.
PTR V = 9 + 7.          STACK POINTER FOR SCANNER.
GET W = F.              SET UP THE SYMBOL TREE.
FLG Y = 0.              SET THE RESULTING SYMBOL UNDEFINED.
PTR Z = F + 0.          SET THE TREE PTR TO THE SYMBOL ROOT.
TO 58 BY B.             LOOK UP THE SYMBOL VALUE.
TO 83 IF FLG Y NE 1.            AN UNDEFINED SYMBOL HAS THE VALUE ZERO.
TO 83 IF VAL Y = 0.             A NULL STRING HAS THE VALUE ZERO.
GET X = Y.              GRAB FIRST CHAR OF NON-NULL STRING.
FLG N = 1.              ASSUME IT IS A MINUS SIGN
TO 82 IF VAL X = O.     AND IF IT IS GO ON TO THE NEXT DIGIT.
FLG N = 0.              ELSE RESET THE SIGN TO PLUS.
PTR X = Y + 0.          PREPARE FOR A SPURIOUS FETCH.
LOC 80.         CHECK THE NEXT CHAR FOR DIGIT.
GET X = X.              NO, GRAB THE NEXT CHAR.
PTR U = VAL X.          CHECK FOR A DIGIT.
PTR U = U - E.
TO 81 IF PTR U = 0.
TO 93 IF PTR U GE 5.
TO 93 IF PTR 0 GE U.
LOC 81.         INCORPORATE A DIGITI INTO THE SECITON VALUE.
PTR N = N * 5.          MULTIPLY ACCUMULATOR BY 10.
PTR N = N + U.          ADD CURRENT DIGIT.
LOC 82.
VAL Y = Y - 1.          DROP THE REMAINING LENGTH.
TO 80 IF VAL Y NE 0.            ARE WE DON, NO.
TO 83 IF FLG N = 0.             IS THE ACCUMULATOR NEGATIVE, NO.
FLG N = 0.              YES, RESET THE SIGN BIT.
PTR N = 0 - N.  NEGATE THE CONTENTS.
LOC 83.         EVALUATE THE CURRENT SECTION.
TO 92 IF VAL J = R.             IS THE SECTION OPERATOR A RIGHT PAREN, YES.
TO 90 IF VAL T = M.             NO, IS THE STACK OPERATOR A LEFT PAREN, YES.
TO 89 IF VAL J = P.             NO, IS THE SECTION OPERATOR A TIMES, YES.
TO 89 IF VAL J = Q.             NO, IS IT A DIVIDE, YES.
LOC 84.                         PERFORM A PENDING OPERATION.
TO 87 IF VAL T = Q.             IS THE OPERATOR A DIVIDE, YES.
TO 86 IF VAL T = P.             NO, IS IT A TIMES, YES.
TO 85 IF VAL T = O.             NO, IS IT A MINUS, YES.
PTR T = T + N.          PLUS.
TO 88.
LOC 85.
PTR T = T - N.
TO 88.
LOC 86.
PTR T = T * N.
TO 88.
LOC 87.
PTR T = T / N.
LOC 88.
VAL T = J + 0.
TO 76 IF VAL J NE R.
PTR N = T + 0.
PTR 9 = 9 + 7.
GET T = 9.
TO 92.
LOC 89.
TO 86 IF VAL T = P.
TO 87 IF VAL T = Q.
LOC 90.
STO 9 = T.
PTR 9 = 9 - 7.
TO 97 IF PTR 8 GE 9.
VAL T = J + 0.
PTR T = N + 0.
TO 76.
LOC 91.
TO 93 IF VAL S NE 0.
RETURN BY P.
LOC 92.
TO 84 IF VAL T NE M.
TO 91 IF PTR 9 = O.
PTR 9 = 9 + 7.
GET T = 9.
TO 92 IF VAL S = 0.
GET X = S.
VAL S = S - 1.
PTR S = X + 0.
VAL J = X + 0.
TO 92 IF VAL J = R.
TO 83 IF VAL J = N.
TO 83 IF VAL J = O.
TO 83 IF VAL J = P.
TO 83 IF VAL J = Q.
LOC 93.
MESSAGE EXPR TO 4.
PTR N = 0 + 0.
PTR 9 = O + 0.
TO 94 BY B.
RETURN BY P.
LOC 94.
PTR X = C + 0.
PTR Y = J + 0.
TO 96 IF PTR 9 GE C.
STO 9 = L.
LOC 95.
GET X = X.
CHAR = VAL X.
TO 95 IF FLG X = 0.
WRITE NEXT 4.
TO 98 IF FLG 4 NE 0.
TO 96 IF VAL X = L.
CHAR = VAL X.
TO 95.
LOC 96.
TO 70 IF PTR Y = 0.
PTR Y = Y - H.
PTR X = Y - 7.
GET Y = Y.
GET X = X.
TO 95.
LOC 97.
MESSAGE FULL TO 4.
TO 94 BY B.
STOP.
LOC 98.
MESSAGE IOCH TO 4.
TO 94 BY B.
STOP.
END PROGRAM.
!Funky!Stuff!
echo x - ioop.c
cat >ioop.c <<'!Funky!Stuff!'
/* ioop - Input/output routine for SIMCOMP
 *
 * status=ioop(op,chan,buf,ptr1,ptr2)
 *
 * See the book for details.
 *
*/

#include	<stdio.h>

#define	OK 0
#define	Eof 1
#define	ILLEGAL 2
#define	ERROR 3
#define	READ -1
#define	CONTROL 0
#define	WRITE 1
#define TRUE -1
#define FALSE 0
#define MAXCH 5

int ioop(op,chan,buf,ptr1,ptr2)

int	op,
	chan,
	buf[],
	*ptr1,
	*ptr2
;

{

static FILE *chanid[MAXCH] = {NULL,stdin,NULL,stdout,stderr};

int	tmp;

	switch(chan)
	{

	case 0:	return(op==READ? Eof : OK);
	case 1:	{
		if (op == CONTROL) return(OK);
		if (op == WRITE) return(ILLEGAL);
		goto streamin;
		}

	case 2:	{
		return(ILLEGAL);
		}

	case 3:	{
		if (op == CONTROL) return(OK);
		if (op == READ) return(ILLEGAL);
		goto streamout;
		}

	case 4: {
		if (op == CONTROL) return(OK);
		if (op == READ) return(ILLEGAL);
		goto streamout;
		}


	default:	return(ILLEGAL);
	}

streamin:
		*ptr2 = *ptr1;
		while(TRUE)
		 {
			if ((buf[*ptr2] = getc(chanid[chan])) == EOF)
			  return(Eof);
			if (buf[*ptr2] == '\n')
			  return(OK);
			(*ptr2)++;
		 }

streamout:

		tmp = *ptr1;
		while(tmp < *ptr2)
		 {
			putc(buf[tmp++],chanid[chan]);
		 }
		putc('\n',chanid[chan]);
		return(OK);
}
!Funky!Stuff!
echo x - iwrch.c
cat >iwrch.c <<'!Funky!Stuff!'
/* This is the IWRCH function from the Stage2 book */

int iwrch(chr,buf,idx,len)

int chr,
    buf[],
    *idx,
    *len
;

#define LMAX  120

{
 if (( chr < 0 ) || ( (*idx) > LMAX ))
 {
  buf[*idx]= -1;
  *len= *idx;
  *idx= LMAX+1;
  return (1);
 }

 buf[(*idx)++]=chr;
 return (0);
}
!Funky!Stuff!
echo x - simcomp.c
cat >simcomp.c <<'!Funky!Stuff!'
/* Simcomp.c - Pre-pre processor for generating Stage2 */

#define OK 0
#define Eof 1
#define ILLEGAL 2
#define ERROR 3
#define READ -1
#define CONTROL 0
#define WRITE 1
#define TRUE 1
#define FALSE 0

/* common areas defining various things */


main(argc,argv)

char **argv;
{
int p1;

int list[12000],
    i,j,k,l,m,n,kmax;

  p1=1;

 kmax = 12000-80;

 if(ioop(READ,1,list,&p1,&i)) {printf("Stop 10."); exit(1);}
 list[6]=100;
 k=18;

L1: list[k]= -1;

  p1 = k+1;

 if(ioop(READ,1,list,&p1,&i)) {printf("Stop 11."); exit(1);}

 if(i >= kmax) {printf("Stop 20."); exit(1);}

 list[i]=list[1];
 i=k;

L2: i++;

 if(list[i]-list[1] < 0) goto L2;
 if(list[i]-list[1] > 0) goto L2;
  else goto L13;

L10: i++;

 if(list[i] == list[3]) goto L12;

L11: if(list[i] != list[4]) goto L10;

 list[i] = -2;
 list[i+1] = list[i+1]-list[5]+7;
 i++; i++;
 list[i] = list[i]-list[5];

 if( list[i-1] != 7) goto L10;

 if( list[k] < list[i] ) list[k]=list[i];
 goto L10;

L12: list[i]= -1;

L13: i++;
  if(ioop(READ,1,list,&i,&j)) {printf("Stop 12."); exit(1);}

  if( j >= kmax) {printf("Stop 21."); exit(1);}

 list[j]=list[3];

 if(list[i] != list[3]) goto L11;

 list[k-1] = i;
 k = i+1;

 if( k >= j) goto L1;
 if(list[k] != list[3]) goto L1;

L20: if(ioop(READ,1,list,&i,&n))
        {ioop(CONTROL,3,list,&i,&n);
        exit(0);
        }

 list[n] = list[1];

 m=17;

L30: l=8;
  j=m+1;
 for (k=i; k<=n; k++) {

 j++;


 if(list[j] == list[2]) goto L32;
 if(list[j] != list[k]) goto L31;

 if( list[j] < list[1]) goto L33;
 if( list[j] > list[1]) goto L33;
  else goto L40;

L31: m=list[m];
 if( m < i) goto L30;

 if(ioop(WRITE,3,list,&i,&n)) {printf("Stop 30."); exit(1);}
 goto L20;

L32: if(list[k] == list[1]) goto L31;

 list[l]=list[k];
 l++;

L33: l=l; }

L41: list[k]=list[j];

L42: k++;

L43: j++;

 if(list[m] == j) goto L48;
 if(list[j]+1 < 0) goto L44;
 if(list[j]+1 > 0) goto L41;
  else goto L47;

L44: l=list[j+1];
 j++; j++;

 if(l == 7) goto L45;

 if(list[j] != 0) goto L46;

 list[k]=list[l];
 goto L42;

L45: list[7]=list[j]+list[6];

L46: list[k]=list[5];
 list[k+1]=list[l]/64;
 n=list[l]/8;
 list[k+2]=n-list[k+1]*8+list[5];
 list[k+3]=list[l]-n*8+list[5];
 list[k+1]=list[k+1]+list[5];

 k=k+4;
 goto L43;

L47: if(ioop(WRITE,3,list,&i,&k)) {printf("Stop 31."); exit(1);}

L40: k=i;
 goto L43;

L48: list[6]=list[m+1]+list[6]+1;
 goto L20;

}
!Funky!Stuff!

wje@sii.UUCP (Bill Ezell) (07/17/85)

This is part two of two of the stage2 source distribution. It is NOT
a shar file. Everything after CUT HERE should be placed in a file
called 'stage2.txt'.

	Bill Ezell
	(decvax!sii!wje)

-------------------CUT HERE-----------------------------------------
FLG I = 0.              SET UP MACRO CHANNEL.
VAL I = 1 + 0
PTR I = 0 + 0.
READ NEXT I.            GRAB THE FLAG LINE.
TO 98 IF FLG I NE 0.    QUIT UNLESS ALL IS OK.
VAL A = CHAR.           SOURCE EOL.
PTR A = 8 + 0.          SET UP VOID TEMPLATE TREE.
STO A = I.              SAVE THE MACRO CHANNEL SPEC.
FLG B = 2.              PHASE FLAG.
VAL B = CHAR.           SOURCE PARAMETER FLAG.
VAL C = CHAR.           MCT EOL.
PTR C = 9 + 0.          INITIAL TEXT POINTER.
VAL D = CHAR.           MCT PARAMETER FLAG.
VAL E = CHAR.           ZERO CHARACTER.
PTR E = VAL E.          PREPARE FOR NORMALIZATIONS.
VAL F = CHAR.           SPACE CHARACTER.
PTR F = A + 7.          SET UP A VOID SYMBOL TREE.
STO F = 0.
VAL G = 0 + 0.          RESET THE DIGIT COUNT FOR NUMBER CONVERSIONS.
PTR H = 5 * 7.          10* DESCRIPTOR LENGTH.
FLG J = 1.              FLAG TO TERMINATE CREATED SYMBOL.
PTR J = 0 + 0.
FLG L = 1.              END-OF-LINE INDICATOR.
VAL L = 0 - 1.          CHARRIAGE RETURN IS -1.
PTR L = 0 + 0.          LOCATION COUNTER.
VAL M = CHAR.           LEFT PARENTHESIS.
PTR M = 0 + 0.          RESET THE SKIP COUNT.
FLG N = 0.              SET EXPRESSION SIGN POSITIVE.
VAL N = CHAR.           ADDITION OPERATOR.
FLG O = 0.
VAL O = CHAR.           SUBTRACTION OPERATIOR.
VAL P = CHAR.           MULTIPLICATION OPERATOR.
VAL Q = CHAR.           DIVISION OPERATOR.
VAL R = CHAR.           RIGHT PARENTHESIS.
PTR R = 0 + 0.          SET NO REPETITION IN PROGRESS.
PTR 4 = 7 + 7.          LENGTH OF TWO DESCRIPTORS.
PTR 8 = F + 7.          POINT TO THE FIRST AVAILABLE SPACE.
TO 01 BY D.             START WORKING IN EARNEST.
LOC 01.                 ROUTINE TO READ FROM THE INPUT.
GET I = A.              RECALL THE CHANNEL SPEC.
READ NEXT I.            GRAB A LINE.
TO 98 IF FLG I NE 0.    GET OUT UNLESS ALL IS OK.
PTR I = C + 0.
VAL Y = 0 + 0.
PTR Y = C + 0.
TO 02 IF PTR M = 0.     SHOULD THIS LINE BE SKIPPED, NO.
PTR M = M - 1.          YES, DROP THE SKIP COUNT
TO 01.                  TRY AGAIN.
LOC 02.                 READING LOOP.
PTR 9 = I + 0.          ADVANCE THE SPACE POINTER.
VAL I = CHAR.   READ THE NEXT CHARACTER.
PTR I = 9 - 7.          POINT TO THE NEXT CHARACTER SPACE.
TO 97 IF PTR 8 GE I.    HAVE WE OUTRUN THE AREA, YES.
STO 9 = I.              PUT AWAY THE CHARACTER.
TO 04 IF VAL I = L.     WAS THIS A CARRIAGE RETURN, YES.
TO 03 IF VAL I = A.     HAVE WE COMPLETED THE READ, YES.
VAL Y = Y + 1.          BUMP THE INPUT STRING LENGTH.
TO 02 IF VAL I NE B.    NO, IS THIS A PARAMETER FLAG, NO.
PTR B = I + 0.          YES, SET THE PARAMETER POINTER AND
STO 9 = B.              STORE IT WITH THE PHASE FLAG.
TO 02.
LOC 03.                 READ THE REMAINDER OF THE LINE.
PTR 9 = I + 0.          POINT TO THE FIRST FREE SPACE.
VAL I = CHAR.           GRAB ANOTHER CHARACTER.
PTR I = 9 - 7.          SET POINTER TO NEXT CHARACTER
STO 9 = I.
TO 97 IF PTR 8 GE I.    HAVE WE RUN OUT OF SPACE, YES.
TO 03 IF VAL I NE L.    WAS THIS A CARRIAGE RETURN, NO.
LOC 04.                 SCANNER.
PTR U = 9 - 7.          SET ALL PARAMETERS UNDEFINED.
STO U = 3.
PTR U = U - 7.
STO U = 3.
PTR U = U - 7.
STO U = 3.
PTR U = U - 7.
STO U = 3.
PTR U = U - 7.
STO U = 3.
PTR U = U - 7.
STO U = 3.
PTR U = U - 7.
STO U = 3.
PTR U = U - 7.
STO U = 3.
PTR V = U - 7.
STO V = 3.
PTR U = V - 7.
PTR 9 = U + 0.          FREE SPACE POINTER.
TO 97 IF PTR 8 GE 9.
GET W = A.              SET UP THE TEMPLATE TREE POINTER.
GET X = Y.              GRAB THE FIRST INPUT POINTER.
FLG Y = 0.              SET THE STRING UNDEFINED.
PTR Z = A + 0.          SET THE TREE POINTER TO THE TEMPLATE ROOT.
TO 58 BY B.             CALL THE SCANNER.
TO 50 IF FLG B = 2.     IS THIS THE DEFINITION PHASE, YES.
TO 56 IF FLG Y = 0.     WAS THERE A DEFINITION, NO.
STO 9 = 1.              INITIALILY NO CREATED SYMBOLS FOR THIS MACRO
PTR 9 = 9 - H.          SPACE FOR THE CREATED SYMBOLS.
STO 9 = J.              PREVIOUS PARAMETER POINTER.
PTR J = 9 + H.          SET THE CURRENT PARAMETER POINTER.
PTR 9 = 9 - 7.
STO 9 = C.              PREVIOUS TEXT POINTER.
PTR 9 = 9 - 7.
STO 9 = D.              SAVE THE OLD RETURN ADDRESS.
PTR 9 = 9 - 7.
STO 9 = K.              SAVE THE CURRENT TEXT POINTER.
PTR K = U + 0.  SET UP THE NEW TEXT POINTER.
PTR 9 = 9 - 7.
STO 9 = R.              SAVE THE OLD REPETITION POINTER.
PTR R = 0 + 0.          SET NO REPETITION IN PROGRESS.
PTR C = 9 - 7.          NEW TEXT POINTER.
TO 97 IF PTR 8 GE C.    IS THE SPACE FULL ALREAD
TO 05 BY D.             GO PROCESS THE MCT
LOC 05.                 SUB PARAMS IN ONE LINE
PTR 9 = C + 0.          DISCARD ANY JUNK
PTR Y = 0 + 0.          RESET THE LOOP COUNTER.
LOC 06.
TO 07 IF PTR M = 0.     SHOULD WE SKIP LINES, NO.
PTR Z = K + 7.          RETAIN THE CODE BODY POSITINO.
GET K = K.              SKIP A LINE.
GET I = K.              GRAB THE TERMINATOR.
TO 08 IF VAL I = 1.     CHECK FOR THE END OF THE MACRO.
PTR M = M - 1.          DECREMENT THE SKIP COUNT.
GET Z = Z.              GRAB THE FIRST SKIPPED ELEMENT.
TO 06 IF FLG Z NE 3.    IGNORE NON FUNCTION CALLS.
PTR Y = Y + 1.          BUMP THE COUNT OF LOOPS ENTERED.
TO 06 IF VAL Z = 7.     LEAVE THE INCREMENT VALUE IF LOOP ENTERED
PTR Y = Y - 1.          ELSE DECREMENT THE COUNT
TO 06 IF VAL Z NE 8.
PTR Y = Y - 1.
TO 06 IF PTR Y GE 0.    AND GO ON IF SKIPPING AN ENTIRE LOOP.
TO 06 IF PTR R = 0.     OR IF THERE IS NO CURRENT LOOP.
PTR U = R - 7.          ELSE TERMINATE THE LOOP.
GET Y = U.
TO 49 IF FLG Y NE 1.    IS IT COUNT CONTROLLED, NO.
PTR C = R + 0.          YES, RESET THE LINE SPACE POINTER.
GET R = R.              RESOTRE THE ITERATION POINTER.
TO 05.                  IF NOT, CONTINUE
LOC 07.                 CHARACTER PROCESSING LOOP.
PTR K = K + 7.          ADVANCE THE POINTER AND
GET I = K.              FETCH THE NEXT CHARACTER.
TO 09 IF FLG I = 2.     IS THIS A PARAMETER CALL, YES.
TO 22 IF FLG I = 3.     NO, IS IT A COMPILER SWITCH, YES.
PTR I = 9 - 7.          NO, SET THEPOINTER TO THE NEXT SPACE.
STO 9 = I.      PUT THE CHARACTER IN THE PSEUDO-INPUT.
PTR 9 = I + 0.          ASVANCE THE SPACE POONTER.
TO 97 IF PTR 8 GE 9.    IS THE SPCAE EXHAUSTED, YES.
TO 07 IF FLG I = 0.     WAS THAT THE LAST CHARACTER, NO.
PTR Y = C - 9.          SET THE PSEUDO-INPUT LENGTH.
PTR Y = Y / 7.
PTR Y = Y - 1.
VAL Y = PTR Y.
PTR Y = C + 0.
TO 04 IF VAL I NE 1.    WAS THAT THE END OF THE CODE BODY, NO.
LOC 08.
PTR 9 = J - H.          RESTORE FROM THE CORRENT RECURSION.
GET J = 9.
PTR 9 = 9 - 7.
GET C = 9.              TEXT SPACE POINTER.
PTR 9 = 9 - 7.
GET D = 9.              RETURN ADDRESS.
PTR 9 = 9 - 7.  
GET K = 9.              CODE BODY POINTER.
PTR 9 = 9 - 7.
GET R = 9.              ITERATION POINTER.
RETURN BY D.
LOC 09.                 DO PARAMETER CONVERSION.
PTR V = J + I.          NO, FIND PARAMETER POINTER.
TO 21 IF VAL I = 6.     SET A PARAMETER.
GET Y = V.              AND LOAD IT.
TO 45 IF VAL I = 7.     INITIATE REPETITION OVER AN ARGUNET LIST.
TO 23 IF FLG Y = 3.     ERROR IF PARAMETER IS UNDEFINED.
GET X = Y.              GET THE FIRST CHARACTER.
TO 11 IF VAL I = 0.     COPY CONVERSION.
TO 10 IF VAL I = 1.     SYMBOL REFERENCE.
TO 12 IF VAL I = 2.             LOCATION SYMBOL DEFINITION.
TO 15 IF VAL I = 4.             REQUEST FOR EXPRESSION CONVERSION.
PTR X = Y + 0.
TO 20 IF VAL I = 3.             REQUEST THE BREAK CHARACTER.
PTR N = VAL Y.
TO 18 IF VAL I = 5.             REQUEST FO PARAMETER LENGTH.
TO 23 IF VAL Y NE 1.            IF NOT ONE CHARACTER, SIGNAL ERROR.
PTR N = VAL X.
TO 18 IF VAL I = 8.             REQUEST FOR INTERNAL REPRESENTATION.
MESSAGE CONV TO 4.              THE CONVERSION DIGIT IS UNAVAILABLE.
TO 94 BY B.                     CALL ERROR TRACEBACK.
TO 07.                          CONTINUE WITH THE LINE.
LOC 10.                         DEAL WITH A LOCATION SYMBOL.
PTR V = 9 + 7.                  STACK POINTER FOR SCANNER.
GET W = F.                      SET UP THE SYMBOL TREE.
PTR Z = F + 0.                  SET THE TREE POINTER TO THE SYMBOL ROOT
TO 58 BY B.                     CALL ON THE SCANNER.
TO 07 IF FLG Y NE 1.            WAS THE SYMBOL DEFINED, NO.
FLG I = 0.                      PREPARE TO COPY OVER THE SYMBOL VALUE.
GET X = Y.                      NO, GRAB THE FIRST CHARACTER.
LOC 11.
TO 07 IF VAL Y = 0.
GET I = X.                      FETCH NEXT CHAR
PTR X = 9 - 7.                  SET POINTER
STO 9 = X.                      PUT IT IN PSEUDO INPUT
PTR 9 = X + 0.                  POINT TO THE NEXT FREE SPACE.
VAL Y = Y - 1.                  DECREMENT THE CHARACTER COUNT.
TO 07 IF VAL Y = 0.             ARE WE DONE, YES.
GET X = I.                      NO, GET THE NEXT CHARACTER.
PTR I = 9 - 7.                  SET ITS POINTER.
STO 9 = I.                              PUT AWAY THE COPY.
PTR 9 = I + 0.                  POINT TO THE NEXT FREE SPACE.
TO 97 IF PTR 8 GE 9.            HAVE WE EXHAUSTED THE SPACE, YES.
VAL Y = Y - 1.          NO, DROP THE COUNT OF CHARACTERS.
TO 11.
LOC 12.                         MOVE A DEFINITION TO THE OUTPUT.
FLG B = 2.                      ALLOW SYMBOL DEFINITION.
GET W = F.                      SET UP THE SYMBOL TREE.
PTR Z = F + 0.          SET THE TREE POINTER TO THE SYMBOL ROOT.
TO 58 BY B.                     CALL ON THE SCANNER.
FLG B = 0.                      EXIT THE DEFINITION PHASE.
GET X = Y.
TO 11 IF FLG Y = 1.             IS THIS A NEW SYMBOL, NO.
PTR Y = 8 + 0.          YES, SET UP THE DEFINITION POINTER.
FLG Y = 1.              MARK IT AS HAVING BEEN DEFINED.
PTR L = L + 1.          BUMP THE LOCATION COUNTER.
PTR X = L + 0.          AND INSERT IT AS THE DEFINITION.
PTR W = 9 + 7.          USE STORE AT THE TOP AS TERMORARY.
VAL Y = 0 + 0.          COUNT THE DIGITSD.
LOC 13.                 CONVERT ONE DIGIT ATA TIME.
PTR V = X / 5.          GET THE UUOTIENT BY INTERGER DIVISION.
PTR Z = V * 5.          THE REMAINDER MUST BE FOUND BY MULTIPLICATION
PTR X = X - Z.                  AND THEN SUBTRACTING.
VAL X = PTR X.                  MOVE THE RESULT TO THE VALUE FIELD.
PTR X = V + 0.                  THE QUOTIENT IS TO BE OPERATED ON NEX.
PTR W = W - 7.                  ADVANCE THE TERMORARY STORAGE POINTER.
STO W = X.                      AND SALT AWAY THE RESULT.
VAL Y = Y + 1.                  BUMP THE DIGIT COUNT.
TO 97 IF PTR 8 GE W.            HAVE WE RUN OUT OF ROOM, YES.
TO 13 IF PTR X NE 0.            NO, WMUST WE GO ON, YES.
LOC 14.                         MOVE THE DIGITS TO THE DESTINIATION.
GET X = W.                      RECOVER A POSSIBLE DIGIT.
PTR W = W + 7.                  MOVE THE DIGIT POINTER. BACK.
VAL X = X + E.                  MAKE THE DIGITS INTO CHARACTERS.
PTR X = 8 + 7.                  SET UP A POINTER TO THE NEXT SPACE.
STO 8 = X.              PUT AWAY THE CHARACTER.
PTR 8 = X + 0.          BUMP THE SPACE POINTER.
TO 14 IF PTR 9 GE W.            DID WE REALLY HAVE ANOTHER DIGIT, YES.
STO 8 = 0.              PUT IN THE TERMINATOR.
PTR 8 = 8 + 7.          ADVANCE THE SPACE POINTER.
TO 97 IF PTR 8 GE 9.
STO U = Y.              PUT AWAY THE POINTER TO THE DEFINITION.
GET X = Y.              PUCK UP THE FIRST CHAR OF THE DEFINITION.
FLG I = 0.              CLEAN OUT THE INPUT VUFFER.
TO 11.                  COPY OUT THE VALUE.
LOC 15.         PROCESS AN EXPRESSION PARAMETER.
TO 74 BY P.             EVALUATE THE EXPRESSION.
TO 18 IF PTR N GE 0.            AND TEST FOR NON-NEGATIVE.
PTR O = 9 - 7.          IF NEGATIVE, INSERT A MINUS SIGN.
TO 97 IF PTR 8 GE O.
STO 9 = O.
PTR 9 = O + 0.
PTR N = 0 - N.          MAKE THE NUMBE POSITIVE AND
TO 18.          STORE DOWN.
LOC 16.         CONVERSION OF APRM ZERO (LOC. CNTR.
GET Y = V.              GRAB THE NEXT CREATED SYMNBOL.
TO 17 IF FLG Y = 1.             IS THIS A SYMBOL, NO.
PTR V = V - 7.          YES, ADVANCE THE CREATED SYNBOL POINTER.
TO 16 IF VAL Y NE I.            IS THIS THE RIGHT SYMBOLM NO.
PTR N = Y + 0.          YES, SET UP ITS VALUE 
TO 18.          AND INSET IT IN THE LINE.
LOC 17.         CREATE A NEW SYMBOL.
PTR Y = V + H.          CHECK THAT THERE IS AOON FOR IT.
TO 23 IF PTR Y = J.             IF NOT, TREAT AS A CONVERSION ERROR.
PTR L = L + 1.          BUMP THE LOCATION COJNTER.
PTR I = L + 0.          SAVE THE NEW VALUE IN THE NEXT SPACE.
STO V = I.
PTR V = V - 7.          FLAG THE NEXT ENTRY AS NO SYMBOL.
GET Y = V.
FLG Y = 1.
STO V = Y.
PTR N = L + 0.
LOC 18.                 INSERT IN LINE
PTR Y = N / 5.          GET QUOTIENT
PTR Z = Y * 5.          THE REMAINDER MUST VE FOUND BY MULTIPLYING
PTR X = N - Z.          AND THEN SUBTRACTIN.
FLG X = 0.
VAL X = PTR X.          MOVE THE RESULT TO THE VALUE FIELD.
PTR N = Y + 0.          THE QUOTIENT IS TO VBE OPERATED ON NEXT.
VAL G = G + 1.          ADVANCE THE TEMPORRY STORAGE COUNT.
PTR 8 = 8 + 7.
STO 8 = X.              AND SALT AWAY THE RESULT.
TO 18 IF PTR N NE 0.            NO, MUST WE GO ON, YES.
LOC 19.         MOVE THE DIGITS TO THEIR DESTINATION.
GET X = 8.              RECOVER A POSSIBLE DIGIT.
PTR 8 = 8 - 7.          MOVE THE DIGIT POINTER BACK.
VAL G = G - 1.
VAL X = X + E.          MAKE THE DIGITS INTO CHARACTES.
PTR X = 9 - 7.          SET UP A POINTER TO THE NEXT SPACE.
STO 9 = X.              PUT AWAY THE CHARACTER.
PTR 9 = X + 0.          PDROP THE SPACE POINTER.
TO 19 IF VAL G NE 0.            DID WE REALLY HAVE ANOTHE DIGIT, YES.
TO 07.          NO, GO BACK TO THE LINE PROCESSOR.
LOC 20.         ADVANCE TO A BREAK CHARACTER.
GET X = X.              GET THE NEXT CHAR
VAL Y = Y - 1.          AND DROP THE NUMBER REMAINING.
TO 20 IF VAL Y NE L.            WAS THAT THE BREAK, NO.
TO 07 IF FLG X = 1.             END-OF-LINE IS THE NULL BR3EAK.
PTR X = 9 - 7.          SET THE POINTER
TO 97 IF PTR 8 GE X.
STO 9 = X.              AND PUT AWAY THE BREAK CHARACTER.
PTR 9 = X + 0.
TO 07.
LOC 21.         SET A PARAMETER.
STO 9 = L.              TERMINATE THE CURRENT LINE.
PTR K = K + 7.          BYPASS THE NEXT CHAR.
PTR Y = C - 9.                  ET UP THE SPECIFICATION OF THE
PTR Y = Y / 7.          CURRENT STRING.
FLG Y = 0.
VAL Y = PTR Y.          LENGTH IN CHARS.
PTR Y = C + 0.          POINTER T THE FIRST CHAR.
STO V = Y.              SET THE PARM STOR.
PTR C = 9 - 7.          NEXT EMPTY SPACE FOR NEW LINE.
TO 05.
LOC 22.                 DECODE COMPILER SWITCHES.
PTR V = J + 0.          SET A PARM POINTER.
TO 16 IF PTR I = 0.             IS THIS A CALL ON PARM ZERO, YES.
TO 08 IF VAL I = 9.             ESCAPE FROM THE CURRENT MACRO.
PTR V = V + 7.          QDVANCE THE PARMETER POINTER.
PTR K = K + 7.          BYPASS THE CAHR FOLLOWING THE SWITHC.
TO 32 IF VAL I = 1.             OUTPUT A LINE WITHOUT RESCANNING.
TO 32 IF VAL I = 2.             CHANGE I/O UNITS AND COPY.
TO 33 IF VAL I = 3.             REDEFINE A SYMBOL.
TO 42 IF VAL I = 4.             SKIP ARG 1 LINES UNCONDITIONALLY.
TO 36 IF VAL I = 5.             COMPARE ARG 1 AND ARG 2 AS EXPRESSIONG.
TO 39 IF VAL I = 6.
TO 43 IF VAL I = 7.             INITIATE A REPETITION UNDER COUNT CONTROL.
TO 47 IF VAL I = 8.             ADVANCE TO THE NEXT MEMBER OF THE LIST.
TO 23 IF VAL I NE 0.            IF NOT A REQUEST FOR TERMINATION, COMPLAIN
STOP.           ELSE TERMINATE NORMALLY.
LOC 23.         ERROR IN CONVERSION CIFIT.
MESSAGE CONV TO 4.              PUT OUT THE MESSAGE.
TO 94 BY B.             PRODUCE A TRACEBACK
TO 07.          AND THEN CONTINUE.
LOC 32.         CHECK FOR ALTERNATE OUTPUT UNIT.
GET X = K.              THIS MIGHT BE A CHANNEL NUMBER.
VAL W = 3 + 0.                  THE DEFAULT OUTPUT CHANNEL IS 3.
TO 24 IF FLG X = 1.             IF NO CHANNEL NUMBER TAKE THE DEFAULT.
PTR K = K + 7.          ELSE ADVANEC THE DOE BODLY PTR.
VAL W = X - E.          CONVERT THE DIFIT TO AN INTEGER.
GET X = K.              CHECK FOR REWIND REQUEST.
TO 24 IF FLG X = 1.             IF NONE, CONTINUE.
REWIND W.               ELSE REWIND THE OUTPUT CHANNEL.
FLG W = 0.
PTR K = K + 7.          AND ADVANCE THE CONDE BODY PTR.
LOC 24.
TO 31 IF VAL I = 2.     START BLOCK COPY
STO 9 = L.              TERMINATE LINE
PTR X = C + 0.          PT TO START OF LINE
TO 57 IF PTR C NE 9.            PUNCH IT IF IT EXISTS.
PTR K = K + 7.
GET I = K.                      ELSE BACKSPACE THE CODE BODY
TO 25 IF FLG I NE 1.           CONT IF VALID
PTR K = K - 7.
TO 23.
LOC 25.
PTR Z = VAL I.
PTR Z = Z - E.
TO 28 IF PTR Z GE 5.
TO 28 IF PTR 0 GE Z.
VAL X = I + 0.          IF SO, SAVE FOR FUTURE REFERENCE.
PTR Z = Z * 7.          COMPUTE THE PARM LOCATION
PTR Y = J + Z.          AND GRAB ITS SPECIFICATION.
GET Y = Y.
TO 27 IF FLG Y = 3.             TREAT AN UNDEFINED PRAM AS VOID.
GET Z = Y.              PICK UP THE FIRST CHAR.
LOC 26.
TO 27 IF VAL Y = 0.             IS THE PARM V`VOID, YES.
CHAR = VAL Z.           NO, OUTPUT A CHA.
GET Z = Z.              PICK UP THE NEXT CHAR OF THE PARMS
VAL Y = Y - 1.          AND DROP THE NUMVER REMAINING.
PTR K = K + 7.          ADVANCE THE POINTER.
GET I = K.              GRAB THE NEXT CHAR OF THE CODE BODY.
TO 26 IF VAL I = X.             IS IT THE SAME DIGIT, YES.
TO 25.
LOC 27.
CHAR = VAL F.
PTR K = K + 7.
GET I = K.
TO 27 IF VAL I = X.
TO 25.
LOC 28.
TO 57 IF FLG I = 1.
CHAR = VAL I.
PTR K = K + 7.          ELSE ADVANCE ALONG THE CODE BODY.
GET I = K.
TO 25.
LOC 31.
GET I = A.
TO 29 IF PTR C = 9.
GET X = C.              ELSE GRAB THE UNIT NUMBER
VAL I = X - E.          ANE CONVERT IT TO AN INTEGER.
STO A = I.              CHANGE THE CURRENT UNIT IN STOR.
TO 29 IF PTR X = 9.             IF NO REWIND REQUEST, CONTINUE.
REWIND I.               ELSE PERFORN THE REWIND
FLG I = 0.
TO 98 IF FLG I NE 0.            AND QUIT UNLESS IT WAS ALL OK.
LOC 29.         BLOCK COPY FROM INPUT TO OUTPUT.
GET X = V.              PICK UP THE PARM SPEC.
TO 05 IF VAL X = 0.             NO COPYING IF PARM IS VOID.
TO 05 IF FLG X = 3.             OR UNDEFINED.
PTR Y = X + 0.          ELSE SET UP THE ADDRESS OF THE FIRST CHAR.
READ NEXT I.             GET THE NEXT LINE.
TO 98 IF FLG I NE 0.            GET OUT UNLESS ALL IS OK.
LOC 30.         CHECK FOR THE TERMINATOR.
TO 05 IF VAL X = 0.             RETURN IF THE MATCH IS COMPLETE.
VAL X = X - 1.          ELSE DECREMENT THE CHAR COUNT.
GET Y = Y.              PICK UP THE NEXT TERMINATOR CHAR.
VAL Z = CHAR.           AND INPUT CHAR.
TO 30 IF VAL Y = Z.             IF WE ARE STILL MATCHING, GO ON.
WRITE NEXT W.
TO 29 IF FLG W = 0.
STOP.
LOC 33.
GET Y = V.              NAME OF SYMBOL TO BE REDEFINED.
TO 23 IF FLG Y = 3.
TO 05 IF VAL Y = 0.
GET X = Y.
FLG B = 2.              ALLOW SYMBOL ENTRY.
GET W = F.              SET UP THE SYMBOL TREE.
PTR Z = F + 0.          SET THE TREEE POINTER TO THE SYMBOL ROOT.
TO 58 BY B.             CALL ON THE SCANNER.
FLG B = 0.              RESET PAHSE FLAG.
FLG W = Y.              SAVE THE DEFINITIO FLAG.
PTR W = U + 0.          POINT O THE DEFINITIN PTR.
PTR Z = Y + 0.          SET THE SYMBOL POINTER
PTR V = V + 7.          GET THE NEW DEFINITION OF THE SYMBOL.
GET Y = V.
TO 23 IF FLG Y = 3.             ERROR IF PARM IS UNDEFINED.
PTR X = Y + 0.          POINT TO THE FIRST CHAR OF THE
FLG Z = 1.              NEW DEFINITION. CLEAR OUT THE TERM
VAL Z = Y + 0.          SET THE NEW SYMBOL LENGTH.
TO 35 IF FLG W NE 1.            WAS THERE A DEFINITION, NO.
STO W = Z.
TO 05 IF VAL Y = 0.
LOC 34.
GET X = X.
PTR W = Z + 0.
GET Z = W.              GRAB THE OLD CONTENTS OF THE SPACE.
VAL Z = X + 0.          MOVE THE CAHR INTO THE SPACE.
STO W = Z.
VAL Y = Y - 1.
TO 35 IF PTR Z = 0.
TO 34 IF VAL Y NE 0.            YES IS THEERE MOVER DEFINITION, YES.
TO 05.
LOC 35.         CREATE NEW SPACE FOR THE DEFINITION.
PTR Z = 8 + 0.          POINT TO THE NEXT AVAILABLE SPACE.
STO W = Z.      PUT AWAY THE CAHR.
PTR 8 = 8 + 7.          ADVANCE THE POINTER
TO 97 IF PTR 8 GE 9.            AND TEST FOR SPACE OVERFILL.
PTR W = Z + 0.          ADVANCE THE CHAR POIINTER.
GET Z = X.              GRAB THE NEXT DEFINITION CHAR.
PTR X = Z + 0.          DECREMENT THE CHAR COUNT.
VAL Y = Y - 1.
TO 35 IF VAL Y NE L.            CHECK  TERMINATION OF THE DEFINITION.
STO W = 0.              STORE THE TERMINATOR IF THERE IS NO MORE.
TO 05.
LOC 36.         COMPARE TWO STRINGS.
GET I = K.              PICK UP THE CONDITION CODE.
PTR K = K + 7.          BYPASSS THE NEXT CHAR.
GET Y = V.
PTR V = V + 7.
GET Z = V.
TO 23 IF FLG Y = 3.             ERROR IF PARM IS UNDEFINED.
TO 23 IF FLG Z = 3.
PTR V = V + 7.          OTHERWISE PICK UP THE THIRD ARGUMENT
TO 41 IF VAL Y NE Z.            COULD THEY BE EQUAL NO.
TO 38 IF VAL Y = 0.
PTR X = Z + 0.
LOC 37.
GET X = X.
GET Y = Y.
TO 41 IF VAL X NE Y.            ARE THEY EQUAL, NO.
VAL Z = Z - 1.          YES, DROP THE NUMBER REMAINING.
TO 37 IF VAL Z NE 0.            ARE WE DONE, NO.
LOC 38.         THE STRINGS ARE EQUAL.
TO 05 IF VAL I NE E.            IS THE CONDITION CODE EQ, NO.
TO 42.
LOC 39.         COMPARE TWO EXPRESSIONS.
GET I = K.              PICK UP THE CONDITION CODE.
PTR K = K + 7.          BYPASS THE NEXT CHAR.
GET Y = V.              FIRST ARGUMENT SPECIFICATION.
TO 23 IF FLG Y = 3.             ERROR IF PARM IS UNDEFINED.
TO 74 BY P.             EVALUATE THE FIRST PARM.
PTR I = N + 0.          SAVE THE VALUE OF THE FIRST ESPRESSION.
PTR V = J + 4.
GET Y = V.              SET UP THE SECOND PARM.
TO 23 IF FLG Y = 3.             ERROR IF PARM IS UNDEFINED.
TO 74 BY P.             EVALUATE IF.
PTR V = J + 4.
PTR V = V + 7.
PTR N = N - I.          COMPUTE THE DIFFERENCE.
TO 38 IF PTR N = 0.             WERE THE PARMS EQUAL, YES.
TO 40 IF PTR N GE 0.            NO, WAS THE SECOND LARGER, YES.
TO 05 IF VAL I = O.
TO 41.
LOC 40.
TO 05 IF VAL I = N.
LOC 41.
TO 05 IF VAL I = E.             IS THE CONDITION EQ, YES.
LOC 42.         SET UP THE SKIP COUNTER.
GET Y = V.
TO 23 IF FLG Y = 3.             ERROR IF PARM IS UNDEFINED.
TO 05 IF VAL Y = 0.             IS IT VOID, YES.
TO 74 BY P.             CONVERT A POSSIBLE EXPRESSION.
PTR M = N + 0.          SET THE COUNT.
TO 05.
LOC 43.         ITERATE UNDER COUNT CONTROL.
PTR Y = C - 9.          SET UP SPECIFICATION OF THE
PTR Y = Y / 7.          CURRENT STRIN.
VAL Y = PTR Y.          LENGTH IN CAHRS.
TO 07 IF VAL Y = 0.             IF NULL, IGNORE IT.
PTR Y = C + 0.          POINTER TO THE FIRST CAHR.
TO 74 BY P.             EVALUATE THE LINE AS AN EXPRESSION.
FLG Y = 1.              SET UP THE RESULT AS AN ITERATION COUNT.
VAL Y = 0 + 0.
PTR Y = N + 1.
STO C = R.              SAVE THE CURRENT ITERATION POINTER.
PTR Z = R + 0.          PREPARE TO RESTORE IT.
PTR R = C + 0.          SET A NEW ONE.
PTR C = C - 4.
STO C = K.              SAVE THE CURRENT CODE BODY POINTER.
LOC 44.         RE-ENTRY FOR ANOTHER ITERATION.
PTR C = R + 0.          RESET THE TEXT POINTER.
PTR R = Z + 0.          RESET THE ITERATION POINTER.
PTR Y = Y - 1.          DECREMENT THE ITERATION COUNT.
TO 05 IF PTR 0 GE Y.            GET OUT IF NO MORE ARE NEED.
PTR R = C + 0.          ELSE RESET THE ITERATION POINTER.
PTR C = C - 7.
STO C = Y.              SAVE THE CURRENT COUNT.
PTR C = C - 7.          
GET K = C.              RESTORE THE CODE BODY POINTER.
PTR C = C - 7.          NEW SPACE FOR THE NEXT TEXT LINE.
TO 05.
LOC 45.                 ITERATE UNDER CONTEXT CONTROL
STO 9 = L.              TERMINATE THE PARM STRIN.
PTR W = C - 9.          SPECIFY THE CURRENT STRIN.
PTR W = W / 7.          COMPUTE ITS LENGTH IN CHARS.
FLG W = 0.              FLG FOR CONTEXT-CONTROLLED ITERATION.
VAL W = PTR W.          LENGTH IN CHARS.
PTR W = C + 0.          PTR TO THE FIRST CHAR.
PTR 9 = 9 - 7.
FLG B = 2.              CONSTRUCT EH TREE FOR ARGUEMTN SCANNING.
PTR B = 0 + 0.          SET UP THE PARAMETER.
FLG U = 0.              SET UP THE RIGHT PAREN.
VAL U = R + 0.
PTR U = 7 + 0.
FLG Z = 1.              END-OF-LINE.
VAL Z = 0 + 0.          INITIALIZE BREAK COUNT.
PTR Z = 0 + 0.
PTR X = 9 - 7.
LOC 46.                 ADD BREAK CHARS TO THE TREE.
VAL Z = Z + 1.          BUMP THE BREAK COUNT.
STO 9 = Z.              END-OF-LINE.
PTR 9 = 9 - 7.
STO 9 = U.              RIGHT PAREN.
PTR 9 = 9 - 7.
STO 9 = B.              PARM FLAG.
PTR 9 = 9 - 7.
PTR K = K + 7.
GET I = K.              GRAB THE NEXT BREAK.
PTR I = X - 9.          POINT TO THE ALTERNATIVE.
STO 9 = I.              CURRENT BREAK CHAR.
PTR X = 9 + 0.          SAVE THE CURRENT POSITION FOR AN ALTERNATE.
PTR 9 = 9 - 7.
TO 97 IF PTR 8 GE 9.
TO 46 IF FLG I NE 1.
STO 9 = B.              ANOTHER PARM FLAG.
FLG B = 0.              RESET PHASE FLAG.
PTR Z = 9 + 0.          SET UP A POINTER TO THE ROOT LOCATION.
PTR 9 = 9 - 7.
VAL U = M + 0.          SET UP A LEFT PAREN.
STO 9 = U.              TREE ROOT.
PTR 9 = 9 - 7.
STO 9 = R.              PREVIOUS ROOT POINTER
PTR 9 = 9 - 7.
STO 9 = C.              PREVIOUS TEXT PTR.
PTR 9 = 9 - 7.
STO 9 = V.              PTR TO PARM STOE.
PTR 9 = 9 - 7.
STO 9 = Y.              ORIGINAL PARM SPEC.
PTR R = 9 - 7.          NEW REPETITION PTR.
STO R = Z.              NEW ROOT PTR.
PTR 9 = R - 7.          
STO 9 = W.              PARM REMAINDER.
PTR 9 = 9 - 4.
STO 9 = K.              CURRENT EXT PTR.
PTR Z = Z - 7.          FIRST TIME ROOT PTR.
TO 48.
LOC 47.                 RE-ENTER FOR NEXT REPETITION.
TO 05 IF PTR R = 0.             IF THERE IS NO REPETITION, GET OUT.
GET Z = R.              ELSE POINT THE SCANNER TO THE ROOT.
LOC 48.         FIRST TIME ENTRY POINT.
PTR U = R - 7.          REMAINDER OF THE LIST.
GET Y = U.
TO 44 IF FLG Y = 1.             IS THIS ITERATION UNDER COUNT CONTRO, YES.
TO 49 IF VAL Y = 0.             TERMINATER THE ITERATION ON A NULL REMAINDER
STO U = 0.              ELSE SET UP ANOTHER SCAN.
PTR U = U - 4.
GET K = U.              RESET THE CODE BODY POINTER.
PTR V = U + 0.          SET UP THE STACK PTR.
PTR 9 = U - 7.
PTR C = 9 + 0.          RESET THE TEXT ORIGIN.
GET X = Y.              GRAB THE FIRST CHAR AND
TO 99 BY B.             GO CHECK FOR SINGLE-CHAR BREAKOUT.
PTR Y = R + 4.          GET THE ADDRESS OF THE PARM
GET W = Y.
PTR Y = R - 4.          GET THE NEW VALUE OF THE SPEC.
TO 97 IF PTR 8 GE Y.
GET Y = Y.              
STO W = Y.              AND PUT IT IN THE PARM SPACE.
TO 05.          CONTINUE WITH THE CODE BODY.
LOC 99.         ADHCK AND SERVICE SINGLE-CHAR SPLITS.
TO 60 IF VAL Z NE 1.            IF BRAK CHARS USED, GOTO THE SCANNER.
FLG X = 0.              ELSE PICK OFF A SINGLE CHAR.
VAL X = Y - 1.          DROP THE LENGTH OF THE PARM.
VAL Y = 1 + 0.          SET THE NEW PARM LENGHT TO 1.
PTR U = U + 7.          SAVE THE NEW PARM SPEC.
STO U = Y.
PTR U = U + 7.          ALSO SAVE TH E REMAINDER OF THE STRIN.
STO U = X.
RETURN BY B.            RETURN AS THOUGH FROM THE SCANNER.
LOC 49.         TERMINATE THE ITERATION.
TO 44 IF FLG Y = 1.             IS THIS ITERATION UNDER COUNT CONTRL, YES.
PTR R = R + 7.
GET Y = R.              RESTORE THE ORIGINAL VALU OF THE
PTR R = R + 7.                  PARM SPEC.
GET W = R.
STO W = Y.
PTR R = R + 7.
GET C = R.                      RESTORE THE TEXT PTR.
PTR R = R + 7.
GET R = R.
TO 05.
LOC 50.         DEFINE A MACRO.
FLG Y = 1.              MARK IT AS DEFINED.
VAL Y = L + 0.          LINE TERMINATOR.
PTR 8 = 8 - 7.
TO 54.
LOC 51.
VAL I = CHAR.
STO 8 = I.              ASSUMET TAHT IT IS A SPECIAL TO BE SAVE.
TO 52 IF VAL I = C.             IF IT IS REALLY IS AN MCT PARM OR END-
TO 52 IF VAL I = D.             OF-LINE FLAG, THEN GO ON TO THE NEXT CHAR.
VAL I = I - E.          ELSE CONVERT A POSSIBLE DIGIT CHAR.
FLG Z = 3.              ASSUME THAT IT IT S FUNCTION CALL.
VAL Z = CHAR.           GET THE PARM CONVERSION FO FUNCTIL.
VAL Z = Z - E.          CONVERT FROM A CHAR TO A N INTERGER.
PTR Z = VAL I.          PUT AWAY THE SPEC.
STO 8 = Z.
TO 52 IF PTR 0 GE Z.            IF IT IS REALLY A FUNCTION, GO ON.
TO 52 IF PTR Z GE 5.
FLG Z = 2.              OTHERWISE MAKE IT A PARM CONVERSION.
PTR Z = Z * 7.          SET UP THE RELATIVE ADDR OF THE PARM.
STO 8 = Z.
LOC 52.         PROCESS AN MCT LINE.
PTR 8 = 8 + 7.          ADVANCE THE APCE PTR.
TO 97 IF PTR 8 GE 9.            HAVE WE RUN OUT OF ROOM, YES.
VAL I = CHAR.           READ THE NEXT CHAR.
STO 8 = I.              STORE IT.
TO 51 IF VAL I = D.             IS THIS AN ESCAPE CHAR, YES.
TO 53 IF VAL I = L.             RECOGNIZE A CARRIAGE CNOTROL.
TO 52 IF VAL I NE C.            NO, WAS IT AN MCT END-OF-LINE, NO.
LOC 53.
PTR Y = 8 + 0.          POINT TO THE CURRENT LINE TERMINATOR.
STO U = Y.              SET UP THE PREVIOUS TERMINATOR.
PTR U = 8 + 0.          UPDATE THE TERMINATOR ADDRESS.
LOC 54.         READ AND STORE A NEW MCT LINE.
GET I = A.              RECALL THE CHANNEL SPECIFIER.
READ NEXT I.            GRAB THE NEXT LINE.
TO 98 IF FLG I NE 0.            GET OUT UNLESS ALL IS OK.
VAL I = CHAR.           READ THE FIRST CHAR OF LINE.
PTR I = 0 + 0.          CLEAN OUT INPUT REGISTER.
PTR 8 = 8 + 7.          ADVANCE THE SPACE PTR.
STO 8 = I.              PUT IT AWAY.
TO 51 IF VAL I = D.             WAS IT A PARM FLAG, YES.
TO 52 IF VAL I NE C.            WAS IT AN END-OF-LINE, NO.
PTR Y = 8 + 0.                  FILL IN THE PREVIOUS TERMINATOR.
STO U = Y.
STO 8 = 1.
PTR 8 = 8 + 7.                  ADVANCE THE SPACE POINTER.
TO 97 IF PTR 8 GE 9.            HAVE WE OVERRUN THE AREA, YES.
VAL I = CHAR.           GET THE NEXT CHAR.
TO 55 IF VAL I NE C.            DID THAT CLOSE THE DEFINITION PHASE, NO.
FLG B = 0.              YES, RESET TEH PHASE FLAG.
LOC 55.         COMMON SYSTEM RETURN POINT.
RETURN BY D.            REGISTER D IS THE RETURN ADDDRESS.
LOC 56.         PUNCH AN UNRECOGNIZED LINE.
VAL W = 3 + 0.          CHANNEL 3 USED WHDN A LINE IS NOT MATCHED.
PTR X = C + 0.          ADDRESSS THE FIRST CHAR.
LOC 57.         LOOP TO PUT OUT THE CHAR.
GET X = X.              GET THE NEXT ONE.
CHAR = VAL X.           MOVE IT INTO THE LINE BUFFER.
TO 57 IF FLG X NE 1.            HAVE WE REACHED THE DND, NO.
WRITE NEXT W.           YES, PUT IT OUT ON THE DESIGNATE CHANNEL.
TO 98 IF FLG W NE 0.            TREAT ANY ERROR AS FATAL.
TO 55 IF VAL X = L.             ELSE IF THE LINE ID COMPLETE, RETURN.
CHAR = VAL X.           ELSE REPROINT THE LAST CHAR
TO 57.          AND CNOTINUE.
LOC 58.         TRY FOR AN ALTERNATIVE MATCH.
PTR Z = W + Z.          GET THE PTR TO THE ALTERNATIVE.
TO 60 IF PTR W NE 0.            WAS THERE ONE AFTER ALL, YES.
TO 71 IF FLG B = 2.             NO, ARE WE DEFINING, YES.
LOC 59.         TRY EXTERNING THE PREFIOUS PARM.
TO 70 IF PTR V GE 9.            IS THEREO NE TO EXTEND, NO.
GET Z = V.              RECALL THE MACRO POINTER.
GET Y = Q.              YES, RECALL THE INPUT POINTER
GET X = Y.              AND THE CURRENC THAT
TO 63 IF FLG Z = 2.             IS THIS THE FIRST TIMEFOR A PARM, YES.
TO 64 IF FLG Z = 3.             NO, IS ITA PARM EXTERNSION, YES.
PTR V = Q + 7.          ABANDON THE STACK ENTRY.
PTR Q = V + 7.
LOC 60.         TRY AN ALTERNATIVE.
GET W = Z.              GRAB THE MACRO CHAR.
TO 69 IF FLG W = 1.
TO 62 IF FLG W = 2.
TO 58 IF VAL Y = 0.
TO 58 IF VAL X NE W.
TO 61 IF PTR W = 0.             IS THERE AN ALTERNATIVE.
TO 61 IF FLG X = 3.             DI NO STACK ALTERNATIVES FOLLOWING A PARM
TO 61 IF FLG B = 2.             DON STACK ALTERNATIVES DURING DEFINITIONS.
PTR Q = V - 7.
PTR V = Q - 7.
TO 97 IF PTR 8 GE V.
STO Q = Y.              SAVE THE INPUT POINTER.
PTR W = W + Z.          GET THE ADDRESS OF THE ALTERNATIVE.
STO V = W.
LOC 61.
VAL Y = Y - 1.
PTR Y = X + 0.
GET X = X.              ADVANCE THE INPUT POINTER.
PTR Z = Z + 7.          ADVANCE THE MACRO POINTER.
TO 60.          CONTINUE MATCHING.
LOC 62.         SET UP A PARAMETER IF POSSIBLE.
TO 61 IF FLG X = 2.             IS THIS A PARM DEFINITION, NO.
TO 58 IF FLG B = 2.             NO, COULD WE NEED A PARM, NO.
PTR Q = V - 7.          CREATE AN AENTRY FOR TH PARM
PTR V = Q - 7.
TO 97 IF PTR 8 GE V.
STO Q = Y.
FLG Z = 2.              SET UP THE PARM POINTER.
STO V = Z.
FLG X = 3.              DON'T STACK FURTHER ALTERNAIVERS
TO 58.
LOC 63.
FLG Z = 3.
PTR Z = Z + 7.
STO V = Z.
PTR U = U + 7.
FLG W = 0.              
VAL W = 0 + 0.          SET THE PARM LENGTH TO ZERO.
PTR W = Y + 0.          POINT TO THE CURRENT INPUT CHAR.
STO U = W.
TO 60.
LOC 64.                 EXTEND THE CURRENT PARM.
TO 68 IF VAL Y = 0.     CAN IT BE EXTERNED, NO.
TO 68 IF VAL X = R.             VAIL ON AN UNMATCHED CLOSING PARM.
GET W = U.              INCREASE THE PARM LENGTH.
VAL W = W + 1.
VAL Y = Y - 1.
PTR Y = X + 0.
TO 67 IF VAL X NE M.            IS THIS AN OPEN PARN, NO.
VAL Z = 0 + 0.          YES, ZERO THE PAREN COUNT.
LOC 65.         OBTAIN A BALANCED STRING.
VAL Z = Z + 1.          BUMP THE APRENTHESIS COUNT.
LOC 66.
TO 68 IF VAL Y = 0.             FAIL IF THIS IS THE END.
GET X = X.              GRAB THE NEXT INPUT CHAR.
VAL Y = Y - 1.
PTR Y = X + 0.
VAL W = W + 1.          ELSE BUMP THE PARM LENGTH.
TO 65 IF VAL X = M.             IS IT ANOTHER OPEN PAREN, YES.
TO 66 IF VAL X NE R.            NO, IS IT A CLOSE PAREN, NO.
VAL Z = Z - 1.          YES, DROP THE PAREN COUNT.
TO 66 IF VAL Z NE 0.            CONTINUE IF THE COUNT IS NONZERO.
LOC 67.         CONTINUE THE SCAN.
GET X = X.              GET THE NEST INPUT CAHR.
STO Q = Y.              INCREMENT THE INTPUT PTR.
STO U = W.
TO 60.
LOC 68.         ABANDON THE CURRENT PARM.
STO U = 3.              SET THE PARM UNDEFINED.
PTR U = U - 7.          DROP THE PARM STOR PTR BACK.
PTR V = Q + 7.          ABANDON THE STACK ENTRY.
PTR Q = V + 7.
TO 59.          SEE IF THERE ARE OTHERS TO FALL BACK ON.
LOC 69.
TO 58 IF VAL Y NE 0.            IS THIS A FINAL MATCH, NO.
PTR U = Z + 7.          YES, POINT TO THE DEFINITION SPEC.
GET Y = U.
LOC 70.
RETURN BY B.            COMMON RETURN POINRT FOR PTR B RETURNS.
LOC 71.         ROUTINE TO ADD AMCRO DEFINITIONS.
PTR W = 8 - Z.          CREATE THE ALTERNATE PTR.
STO Z = W.              CHANGE THE CURRENT ALTERNATLE.
TO 73 IF VAL Y = 0.             TERMIANTE THE BRANCE IF THIS IS THE END.
LOC 72.         READ THE REMAINDER OF THE TERMOLACTE LINE.
VAL Y = Y - 1.
PTR Y = X + 0.
PTR X = 0 + 0.          RESET THE POINRT OF THE CURRENT CHR.
STO 8 = X.              PUT IT AWAY.
PTR 8 = 8 + 7.          ADVANCE THE SPACE PTR.
TO 97 IF PTR 8 GE 9.            HAVE WE OVERRUN THE AREA, YES.
GET X = Y.              GRAB THE NEXT CHAR.
TO 72 IF VAL Y NE 0.            WAS THAT THE LAST, NO.
LOC 73.         TERMINATE THE TREE BRANCH.
FLG X = 1.              SET THE MACRO TERMINATOR.
PTR X = 0 + 0.          SET FOR NO ALTERNATIVE.
STO 8 = X.
PTR U = 8 + 7.          SET UP A DEFINITION PTR.
FLG Y = 0.
PTR Y = U + 0.
STO U = Y.
PTR 8 = U + 7.
TO 97 IF PTR 8 GE 9.
RETURN BY B.
LOC 74.
PTR O = 9 + 0.          SAVE THE CURRENT TOP OF FREE SPACE.
VAL S = Y + 0.          SET UP THE STRING SPECIFIER.
PTR S = Y + 0.          
PTR T = 0 + 0.          INITIAL VALUE OF THE EXPRESSION IS ZERO.
TO 75 IF VAL Y NE 0.            IS THE EXPRESSION VOID, NO.
PTR N = 0 + 0.          YES, ITS VALUE IS ZERO.
RETURN BY P.
LOC 75.
VAL T = M + 0.          STACK A LEFT PAREN.
LOC 76.
TO 93 IF VAL S = 0.
GET X = S.              ELSE GRAB THE NEXT.
PTR Y = S + 0.          POINT TO A POSSIBLE SECTION START.
VAL Y = 0 + 0.          THE STRINT IS INITIALLY EMPTY.
TO 77 IF VAL X NE M.    IS THE CHAR A LEFT PAREN, NO.
STO 9 = T.              YES PUSH THE STACK.
PTR 9 = 9 - 7.
TO 97 IF PTR 8 GE 9.
VAL S = S - 1.          DROP THE STRINGLENGTH REMAINING.
PTR S = X + 0.          BUMP THE PTR.
TO 75.
LOC 77.         SPECIFY A SECTION.
TO 78 IF VAL X = N.             IS THIS A PLUS, YES.
TO 78 IF VAL X = O.             MINUS.
TO 78 IF VAL X = P.             TIMES.
TO 78 IF VAL X = Q.             DIVIDE.
TO 78 IF VAL X = R.             RIGHT PAREN.
VAL Y = Y + 1.          NOT AN OPERATIR. BUMP SECTION LENGTH.
GET X = X.              GRAB THE NEXT CHAR.
TO 77 IF VAL S NE Y.            IS THE STRING EXHAUSED, NO.
VAL X = R + 0.          YES, SET UP A RIGHT PAREN.
VAL S = S + 1.          PRETEND THAT IT WAS IN THE INPUT STRING.
LOC 78.
VAL J = X + 0.          SET P THE SECTION OPERATOR.
PTR N = 0 + 0.          ZERO THE ACCUMULATOR.
VAL S = S - Y.          UPDATE THE STRING POINTER.
VAL S = S - 1.
PTR S = X + 0.
TO 83 IF VAL Y = 0.             A NULL STRING HAS THE VALUE ZERO.
GET X = Y.              GRAB FIRST CHAR OF NON-NULL STRING.
PTR U = VAL X.          CHECK FOR A DIGIT.
PTR U = U - E.
TO 79 IF PTR U GE 5.
TO 81 IF PTR U GE 0.
LOC 79.         IF FIRST CHAR IS NOT A DIGIT, LOOK UP.
PTR V = 9 + 7.          STACK POINTER FOR SCANNER.
GET W = F.              SET UP THE SYMBOL TREE.
FLG Y = 0.              SET THE RESULTING SYMBOL UNDEFINED.
PTR Z = F + 0.          SET THE TREE PTR TO THE SYMBOL ROOT.
TO 58 BY B.             LOOK UP THE SYMBOL VALUE.
TO 83 IF FLG Y NE 1.            AN UNDEFINED SYMBOL HAS THE VALUE ZERO.
TO 83 IF VAL Y = 0.             A NULL STRING HAS THE VALUE ZERO.
GET X = Y.              GRAB FIRST CHAR OF NON-NULL STRING.
FLG N = 1.              ASSUME IT IS A MINUS SIGN
TO 82 IF VAL X = O.     AND IF IT IS GO ON TO THE NEXT DIGIT.
FLG N = 0.              ELSE RESET THE SIGN TO PLUS.
PTR X = Y + 0.          PREPARE FOR A SPURIOUS FETCH.
LOC 80.         CHECK THE NEXT CHAR FOR DIGIT.
GET X = X.              NO, GRAB THE NEXT CHAR.
PTR U = VAL X.          CHECK FOR A DIGIT.
PTR U = U - E.
TO 81 IF PTR U = 0.
TO 93 IF PTR U GE 5.
TO 93 IF PTR 0 GE U.
LOC 81.         INCORPORATE A DIGITI INTO THE SECITON VALUE.
PTR N = N * 5.          MULTIPLY ACCUMULATOR BY 10.
PTR N = N + U.          ADD CURRENT DIGIT.
LOC 82.
VAL Y = Y - 1.          DROP THE REMAINING LENGTH.
TO 80 IF VAL Y NE 0.            ARE WE DON, NO.
TO 83 IF FLG N = 0.             IS THE ACCUMULATOR NEGATIVE, NO.
FLG N = 0.              YES, RESET THE SIGN BIT.
PTR N = 0 - N.  NEGATE THE CONTENTS.
LOC 83.         EVALUATE THE CURRENT SECTION.
TO 92 IF VAL J = R.             IS THE SECTION OPERATOR A RIGHT PAREN, YES.
TO 90 IF VAL T = M.             NO, IS THE STACK OPERATOR A LEFT PAREN, YES.
TO 89 IF VAL J = P.             NO, IS THE SECTION OPERATOR A TIMES, YES.
TO 89 IF VAL J = Q.             NO, IS IT A DIVIDE, YES.
LOC 84.                         PERFORM A PENDING OPERATION.
TO 87 IF VAL T = Q.             IS THE OPERATOR A DIVIDE, YES.
TO 86 IF VAL T = P.             NO, IS IT A TIMES, YES.
TO 85 IF VAL T = O.             NO, IS IT A MINUS, YES.
PTR T = T + N.          PLUS.
TO 88.
LOC 85.
PTR T = T - N.
TO 88.
LOC 86.
PTR T = T * N.
TO 88.
LOC 87.
PTR T = T / N.
LOC 88.
VAL T = J + 0.
TO 76 IF VAL J NE R.
PTR N = T + 0.
PTR 9 = 9 + 7.
GET T = 9.
TO 92.
LOC 89.
TO 86 IF VAL T = P.
TO 87 IF VAL T = Q.
LOC 90.
STO 9 = T.
PTR 9 = 9 - 7.
TO 97 IF PTR 8 GE 9.
VAL T = J + 0.
PTR T = N + 0.
TO 76.
LOC 91.
TO 93 IF VAL S NE 0.
RETURN BY P.
LOC 92.
TO 84 IF VAL T NE M.
TO 91 IF PTR 9 = O.
PTR 9 = 9 + 7.
GET T = 9.
TO 92 IF VAL S = 0.
GET X = S.
VAL S = S - 1.
PTR S = X + 0.
VAL J = X + 0.
TO 92 IF VAL J = R.
TO 83 IF VAL J = N.
TO 83 IF VAL J = O.
TO 83 IF VAL J = P.
TO 83 IF VAL J = Q.
LOC 93.
MESSAGE EXPR TO 4.
PTR N = 0 + 0.
PTR 9 = O + 0.
TO 94 BY B.
RETURN BY P.
LOC 94.
PTR X = C + 0.
PTR Y = J + 0.
TO 96 IF PTR 9 GE C.
STO 9 = L.
LOC 95.
GET X = X.
CHAR = VAL X.
TO 95 IF FLG X = 0.
WRITE NEXT 4.
TO 98 IF FLG 4 NE 0.
TO 96 IF VAL X = L.
CHAR = VAL X.
TO 95.
LOC 96.
TO 70 IF PTR Y = 0.
PTR Y = Y - H.
PTR X = Y - 7.
GET Y = Y.
GET X = X.
TO 95.
LOC 97.
MESSAGE FULL TO 4.
TO 94 BY B.
STOP.
LOC 98.
MESSAGE IOCH TO 4.
TO 94 BY B.
STOP.
END PROGRAM.