Stage2
utzoo!decvax!ittvax!sii!wje
utzoo!decvax!ittvax!sii!wje
Sat Sep 18 10:00:31 AEST 1982
c
Since I got so many requests for stage2, here it is. Just strip off
the news header and these 3 lines, and run the rest as a shell script.
cat <<EOF >Makefile
stage2: stage2.o ioop.o iwrch.o
cc -i stage2.o ioop.o iwrch.o -o stage2
stage2.o: stage2.c
cc -O -c stage2.c
stage2.c: stage2.sim stage2.txt simcomp
(cat stage2.sim stage2.txt | simcomp >stage2.c)
ioop.o: ioop.c
cc -O -c ioop.c
iwrch.o: iwrch.c
cc -O -c iwrch.c
simcomp: simcomp.o ioop.o iwrch.o
cc -i -o simcomp simcomp.o ioop.o iwrch.o
simcomp.o: simcomp.c
cc -O -c simcomp.c
EOF
cat <<EOF >Readme
Installing Stage2
First, GET THE BOOK!
Implementing Software for Non-Numeric Applications
William M. Waite
Prentice-Hall 1973
ISBN 0-13-451898-5
Appendix A describes what all of these files are for. What goes on is
that a simple macro processor called simcmp is used to take Stage2
source, which is written in 'flub' macros, and convert it into C.
The Makefile should handle the whole thing for you, but the macros are
not optimized in any particular way.
There are a couple of test files, which are described in the appendix.
Once stage2 is compiled, test it with the following:
stage2 <s2test.s2
The next logical step, which I haven't done, is to use Stage2 to bootstrap
itself, using the more sophisticated facilities it has, to produce an
optimized implementation.
As I said, I've seen some truly marvelous things done with this thing, so
it must be good for something.
Given the interest expressed in Stage2 by the usenet community, perhaps
some people can come up with some nifty stage2 examples.
-Bill Ezell
Software Innovations, Inc.
603-883-9300
(decvax,ittvax,harpo,gc49)!sii!wje
EOF
cat <<EOF >ioop.c
/* 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)
register int op,
chan,
buf[],
*ptr1,
*ptr2
;
{
static FILE *chanid[MAXCH] = {NULL,stdin,NULL,stdout,stderr};
register 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: {
if (op == CONTROL) return(OK);
if( op == WRITE ) return(ILLEGAL);
if( !chanid[2] ) /* not open yet */
chanid[2] = fopen("/dev/tty","r");
goto streamin;
}
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);
}
EOF
cat <<EOF >iwrch.c
/* This is the IWRCH function from the Stage2 book */
#define LMAX 120
int iwrch(chr,buf,idx,len)
register int chr,
buf[],
*idx,
*len
;
{
if (( chr < 0 ) || ( (*idx) > LMAX ))
{
buf[*idx]= -1;
*len= *idx;
*idx= LMAX+1;
return (1);
}
buf[(*idx)++]=chr;
return (0);
}
EOF
cat <<EOF >s2test.s2
.'$'0 (+-*/)
END PROGRAM.
4'F7$
THIS LINE REPEATS 4 TIMES UNDER COUNT CONTROL'F1$
'F8$
END OF STAGE2 TEST. THIS LINE CONTAINS TYPE 0 ELEMENTS ONLY$
'F0$
$
TRY USING AN UNDEFINED PARAMETER.
THE UNDEFINED PARAMETER IS '10'F1$
'F1$
UNDEFINED PARAMETER IN FORMATTED OUTPUT 111111111$
$
TYPE 2 '.
TEST CHARACTER IS '10$
TRANSFORMATION 1 YIELDS '11$
TRANSFORMATION 2 YIELDS '12$
TRANSFORMATION 3 YIELDS '13$
TRANSFORMATION 4 YIELDS '14$
TRANSFORMATION 5 YIELDS '15$
PARAMETER 2 WAS SET TO '10'26 '20$
'10'37,$
ITERATION ON '10. NEXT MEMBER '30$
'F8$
TRANSFORMATION 8 YIELDS '18$
$
TEST PARAMETER 0.
'00 IS GENERATED SYMBOL 1$
'01 IS GENERATED SYMBOL 2$
'02 IS GENERATED SYMBOL 3$
'03 IS GENERATED SYMBOL 4$
'04 IS GENERATED SYMBOL 5$
'05 IS GENERATED SYMBOL 6$
'06 IS GENERATED SYMBOL 7$
'07 IS GENERATED SYMBOL 8$
'08 IS GENERATED SYMBOL 9$
'09 IS GENERATED SYMBOL 10$
'00 IS GENERATED SYMBOL 1$
'01 IS GENERATED SYMBOL 2$
'02 IS GENERATED SYMBOL 3$
'03 IS GENERATED SYMBOL 4$
'04 IS GENERATED SYMBOL 5$
'05 IS GENERATED SYMBOL 6$
'06 IS GENERATED SYMBOL 7$
'07 IS GENERATED SYMBOL 8$
'08 IS GENERATED SYMBOL 9$
'09 IS GENERATED SYMBOL 10$
$
NULL MACRO.
$
NINE PARAMETERS ' ' ' ' ' ' ' ' '.
NINE PARAMETERS ARE '10 '20 '30 '40 '50 '60 '70 '80 '90.'F1$
$
CODE BODY LINE WITH NO TERMINATOR.
THIS CODE BODY LINE HAS NO TERMINATOR. IT SHOULD HAVE 80 CHARACTERS.
\$$
C THIS DATA EXERCISES MOST OF THE FEATURES OF STAGE2. THE FIRST TWO
C LINES WILL NOT BE MATCHED, AND SHOULD BE PRINTED OUT UNCHANGED.
TEST PARAMETER 0.
NULL MACRO.
NINE PARAMETERS 1 2 3 4 5 6 7 8 9.
TYPE 2 A.
CODE BODY LINE WITH NO TERMINATOR.
TYPE 2 0.
TYPE 2 13.
TYPE 2 A.
TYPE 2 A+13.
TYPE 2 15/2.
TYPE 2 5*(A+13).
TEST PARAMETER 0.
TYPE 2 THIS IS A LONG STRING.
TYPE 2 L1,L2,(L31,L32,L33),L4,L5.
TYPE 2 (PL1,PL2,PL3,(PL41,PL42,PL43),PL5,PL6,PL7).
TRY USING AN UNDEFINED PARAMETER.
END PROGRAM.
EOF
cat <<EOF >simcomp.c
/* 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 */
#define MEMMAX 12000
int p1;
int list[MEMMAX],
i,j,k,l,m,n,kmax;
main(argc,argv)
char **argv;
{
p1=1;
kmax = MEMMAX-80;
if(ioop(READ,1,list,&p1,&i)) {printf("Stop 10."); exit();}
list[6]=100;
k=18;
L1: list[k]= -1;
p1 = k+1;
if(ioop(READ,1,list,&p1,&i)) {printf("Stop 11."); exit();}
if(i >= kmax) {printf("Stop 20."); exit();}
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();}
if( j >= kmax) {printf("Stop 21."); exit();}
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();
}
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();}
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();}
L40: k=i;
goto L43;
L48: list[6]=list[m+1]+list[6]+1;
goto L20;
}
EOF
cat <<EOF >simtest.sim
.'$'0
END PROGRAM.
C END OF SIMCMP TEST. THIS LINE CONTAINS TYPE O 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, GNE10$
'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.
EOF
cat <<EOF >stage2.sim
.'$'0
DIAG ' '.
printf("Diagnostic %d: mem '20 FVP: %u %u %u\n",'10,F'20,V'20,P'20);
$
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;$
$
''' ' = ''' '.
'10'40='50'80;$
$
GET ' = '.
F'10=MEM[P'20].f; V'10=MEM[P'20].v; P'10=MEM[P'20].p;
$
STO ' = '.
MEM[P'10].f=F'20; MEM[P'10].v=V'20; MEM[P'10].p=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;$
\$$
#define READ -1
#define CONTROL 0
#define WRITE 1
#define MEMMAX 10000
struct {
int f;
int v;
int p;
} MEM[MEMMAX];
int i,lbl,lbr,lbw,retby,ONE,TWO1,lb[124],mb[22],
F0 = 0, V0 = 0, P0 = 0,
F1 = 1, V1 = 1, P1 = 1,
F2 = 2, V2 = 2, P2 = 2,
F3 = 3, V3 = 3, P3 = 3,
F4, V4 = 4, P4,
F5, V5 = 5, P5 = 10,
F6, V6 = 6, P6,
F7, V7 = 7, P7 = 1, /* memory increment */
F8, V8 = 8, P8 = 0, /* memory start */
F9, V9 = 9, P9 = MEMMAX-1, /* memory end */
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;
main(argc,argv)
int argc;
char **argv;
{
ONE=1; TWO1=21;
lbr=lbw=lbl=1;retby= 0;
Looptop: switch (retby) {
case 0:
EOF
cat <<AllDoneNow >stage2.txt
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.
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 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
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.
AllDoneNow
More information about the Comp.sources.unix
mailing list