|
DataMuseum.dkPresents historical artifacts from the history of: DKUUG/EUUG Conference tapes |
This is an automatic "excavation" of a thematic subset of
See our Wiki for more about DKUUG/EUUG Conference tapes Excavated with: AutoArchaeologist - Free & Open Source Software. |
top - metrics - downloadIndex: T s
Length: 41678 (0xa2ce)
Types: TextFile
Names: »stage2.sim«
└─⟦87ddcff64⟧ Bits:30001253 CPHDIST85 Tape, 1985 Autumn Conference Copenhagen
└─⟦this⟧ »cph85dist/stage2/stage2.sim«
."$"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.