%BEGIN; !IMP15 COMPILER %OWNINTEGER ERR=0, OBJ=1, MAP=2; !OUTPUT STREAMS %OWNINTEGER PC=37, QU=39; !SPECIAL SYMBOLS %OWNINTEGER MONI=4, NST=5, LE=6, GE=7, AR=8;!PRIM SUBROUTINE TAGS %OWNINTEGER ADEC=9, SH=10 %OWNINTEGER ENT=16, FLT=17, PTXT=25 %OWNINTEGER BAR=20, BGET=21, BPUT=22 %OWNINTEGER BEG=111; !DECL CODE FOR BEGIN %OWNINTEGER LINE=1; !LINE NUMBER %OWNINTEGER SYM; !CURRENT INPUT SYMBOL %OWNINTEGER SYMTYPE; !-2:LET, -1:DIG, 0:TERM, 1:OTHER, 2:KEYLET %OWNINTEGER DECL; !DECLARATOR TYPE %OWNINTEGER SECTION; !0:INSTR, 1:DATA %OWNINTEGER OWN; !OWN COUNT %OWNINTEGER FAULTY; !FAULT INDICATOR %OWNINTEGER POS1; !START-OF-ATOM POSITION %OWNINTEGER POS; !CURRENT CHAR POSITION %INTEGERARRAY CHAR(1:73) %INTEGER KMAX; !KEYDICT MAX (FIXED) %INTEGER DMAX; !NAME DICT MAX %OWNINTEGER DLIM=800; !UPPER BOUND (FIXED) %INTEGERARRAY DICT(32:DLIM) %OWNINTEGER GLOBAL; !ZERO OR ENDOFPRIM TAG %OWNINTEGER TMAX; !TAG MAX %INTEGER X; !CURRENT TAG (WHEN RELEVANT) %OWNINTEGER LMIN=253; !COMP LAB MIN %INTEGERNAME TT0; !==TAGTYPE(0) %INTEGERNAME TTX; !==TAGTYPE(X) %INTEGERARRAY TAGTYPE,INDEX(0:210) ! SIGNIFICANCE OF TAGTYPE VALUES: ! VAL256+ VAL128 VAL64 VAL32 VAL16 VAL8 VAL0:7 ! 0 0 SET 1 0 0 000 LABEL ! BOUNDS AD 0 0 1 0 0 001 SWITCH ! 0 0 0 OWN NAME BYTE 010 VAR ! 0 0 0 OWN NAME BYTE 011 ARRAY ! GRAM AD SAFE/EXT BODY STATIC NAME BYTE 100 MAP ! GRAM AD SAFE/EXT BODY STATIC NAME BYTE? 101 FN ! GRAM AD SAFE/EXT BODY STATIC NAME 0 110 PRED ! GRAM AD SAFE/EXT BODY STATIC NAME 0 111 ROUT ! 0 0 1 1 0 1 111 BEGIN (111) ! OTHER DECL VALUES NOT STORED IN TT ! 0 0 0 0 0 1 110 SPEC (14) ! 1 0 0 0 0 0 100 END (260) ! 1 0 0 0 0 0 101 ENDPROG (261) %INTEGER SS0,SS1,SS2,SS3; !GRAM START POINTS (FIXED) %INTEGER APP; !BASIC APP (FIXED) %INTEGER GMAX1; !ORIGINAL GRAM MAX (FIXED) %INTEGER GMAX; !GRAM MAX %INTEGERNAME P111; !==PHRASE(111) -- APP %INTEGERARRAY ATOMIC(64:111), PHRASE(96:111) %INTEGERARRAY GRAM(1:255) ! GRAM LAYOUT: MORE<1> ORDER<2> LINK<8> CLASS<7> ! LINK = 255: END OF PHRASE ! LINK = 0: END OF SS %INTEGER A; !ATOM NODE POINTER %INTEGER P; !PHRASE NODE POINTER %INTEGER SS; !SS POINTER %OWNINTEGER SSTYPE; !0:LAB, 1:DECL, 2:FPP, 3:STAT %INTEGERARRAY REF,CO,SUB(-100:-1) %ROUTINESPEC COMPILE BLOCK(%INTEGER LEVEL,BTAG %INTEGERNAME BTYPE,GD) READ(GMAX1); GMAX = GMAX1; READ(KMAX); DMAX = KMAX READ(SS0); READ(SS1); READ(SS2); READ(SS3) %CYCLE X = 96,1,111; READ(PHRASE(X)); %REPEAT %CYCLE X = 64,1,111; READ(ATOMIC(X)); %REPEAT %CYCLE X = 1,1,255; READ(GRAM(X)); %REPEAT %CYCLE X = 32,1,511; READ(DICT(X)); %REPEAT P111 == PHRASE(111); APP = P111 TT0 == TAGTYPE(0); TT0 = BEG COMPILE BLOCK(-3,0,TT0,TT0) NEWLINE %MONITOR 192 %IF FAULTY # 0 %ROUTINE COMPILE BLOCK(%INTEGER LEVEL,BTAG %INTEGERNAME BTYPE,GD) %ROUTINESPEC PRINT SS(%INTEGER S) %ROUTINESPEC ANALYSE SS(%INTEGER CONT) %ROUTINESPEC COMPILE SS %INTEGER TBASE,DBASE,LSTACK,ESTACK,PMAX,AC,ATAG,DANGER,ACCESS TBASE = TMAX; DBASE = DMAX LSTACK = 0; ESTACK = 0 %IF BTYPE # BEG %THEN %START; !PROCEDURE (NOT BEGIN) ANALYSE SS(1); !FORMAL PARAMETERS ->9 %IF BTYPE&80 # 64; !SPEC -> %FINISH PRINT SS(MAP); SELECT OUTPUT(OBJ) ACCESS = BTAG; !NON-ZERO EXCEPT AT OUTSET AC = \255; ATAG = 0 DANGER = 0; PMAX = TMAX AC=\PMAX %IF PMAX-1=TBASE %AND TAGTYPE(PMAX)&31=2 1: %IF SYM = NL %AND LINE # 0 %THEN %START LINE = LINE+1; NEWLINE; !LINE-END CODE %FINISH ANALYSE SS(0); COMPILE SS %IF SS # 0 ->1 %IF DECL&4 = 0 %IF DECL&256 = 0 %THEN %START; !BLOCK HEAD COMPILE BLOCK(LEVEL+3,X,TAGTYPE(X),DANGER) ->1 %UNLESS DECL = 261; !PREMATURE ENDOFPROG %FINISH PRINT SS(MAP); SELECT OUTPUT(OBJ) 9: TMAX = TBASE; DMAX = DBASE %RETURN %ROUTINE PRINT SS(%INTEGER S) SELECT OUTPUT(S); %RETURN %IF POS = 0 WRITE(LINE,3); SPACE; SPACE SPACES(LEVEL) %IF S = MAP S = 1 1: ->2 %IF S = POS %OR (S+1=POS %AND CHAR(S)=PC) PRINT SYMBOL(CHAR(S)); S = S+1 ->1 2: NEWLINE %END %ROUTINE PRINT IDENT %INTEGER I,J,K,L I = INDEX(X); J = I>>9 PRINT SYMBOL(J>>3+32) I = I&511+KMAX; J = J&7 1: %RETURN %IF J = 0; J = J-1 %CYCLE L = 12,-6,0 K = DICT(I-J)>>L&63 PRINT SYMBOL(K+32) %IF K # 0 %REPEAT ->1 %END %ROUTINE FAULT(%INTEGER N) %SWITCH S(0:17) PRINT SS(ERR); PRINT SYMBOL('*') ->S(N) S(0): %PRINTTEXT 'FORM'; ->1 S(1): %PRINTTEXT 'ATOM'; ->1 S(2): %PRINTTEXT 'NAME' 1: SPACES(POS1); PRINT SYMBOL(94); !UP-ARROW ->9 S(3): %PRINTTEXT 'DUPLICATE'; ->9 S(4): %PRINTTEXT 'MATCH'; ->9 S(5): %PRINTTEXT '%BEGIN'; ->8 S(6): %PRINTTEXT '%START'; ->8 S(7): %PRINTTEXT '%CYCLE'; ->8 S(8): %PRINTTEXT '%END'; ->8 S(9): %PRINTTEXT '%REPEAT'; ->8 S(10): %PRINTTEXT '%FINISH'; ->8 S(11): %PRINTTEXT '%RESULT'; ->8 S(12): PRINT SYMBOL(QU) PRINT IDENT PRINT SYMBOL(QU) 8: %PRINTTEXT ' MISSING'; ->9 S(13): %PRINTTEXT 'BOUNDS'; ->9 S(14): %PRINTTEXT 'INDEX'; ->9 S(15): %PRINTTEXT 'CONTEXT'; ->10 S(16): %PRINTTEXT 'ACCESS'; ->10 S(17): %PRINTTEXT 'ORDER' 9: FAULTY = 1 10: NEWLINE; SELECT OUTPUT(OBJ) POS = 0 %IF SYMTYPE = 0 %END %ROUTINE ANALYSE SS(%INTEGER CONT) %INTEGER I,ATOM1,ATOM2,SUBATOM,HEAD,MAX,TYPE,DUP,TEXT,CLASS,LIM %OWNINTEGER QUOTE,KEY %INTEGERNAME INDEX0 %ROUTINE READ SYM ->3 %UNLESS SYM = NL 1: POS = 0; POS1 = 0 2: SYMTYPE = 1 3: READ SYMBOL(SYM) 4: POS = POS+1 %UNLESS POS = 73 CHAR(POS) = SYM %RETURN %IF QUOTE # 0 ->2 %IF SYM = ' ' %IF SYM = PC %THEN %START SYMTYPE = 2; READ SYMBOL(SYM) ->4 %UNLESS SYM='C' %AND NEXTSYMBOL=NL READ SYMBOL(SYM) ->1 %FINISH %IF SYM # NL %THEN %START !DICT(33:95) := LINK<9>:CODE<2> SYM = SYM-32 %IF SYM >= 96 KEY = DICT(SYM) SYMTYPE = KEY&3-2 %UNLESS KEY&3=0 %AND SYMTYPE=2 %FINISH %ELSE SYMTYPE = 0 %END; !READ SYM %ROUTINE LOOKUP(%INTEGER P) %INTEGER J,K %INTEGERNAME INDP 1: %RETURN %IF P = LIM INDP == INDEX0++P %IF INDP&(\511) = HEAD %THEN %START ->3 %IF MAX = DMAX J = INDP&511+KMAX; K = MAX 2: %IF DICT(J) = DICT(K) %THEN %START J = J-1; K = K-1 ->2 %UNLESS K = DMAX 3: TYPE = TAGTYPE(P); ATOM2 = TYPE&7+40 SUBATOM = P !GRAM FOR PARAMETERS %IF TYPE&4#0 %THEN P111=TYPE>>8 %ELSE P111=APP %RETURN %FINISH %FINISH P = P-1 ->1 %END; !LOOKUP %ROUTINE DECLARE IDENT %INTEGER T %IF SUBATOM # 0 %THEN %START; !IDENT ALREADY EXISTS T = TYPE&255 %RETURN %IF DECL-64 = T; !LAB AFTER JMP, BODY AFTER SPEC %RETURN %IF DECL=14 %AND T&4#0 %AND TYPE!!T=0; !SPEC DUP = 1; %RETURN %IF DECL = 0 %FINISH DECL = 32 %IF DECL = 0; !JMP LAB TMAX = TMAX+1; SUBATOM = TMAX; DMAX = MAX TAGTYPE(TMAX) = DECL; INDEX(TMAX) = HEAD+MAX-KMAX %END %ROUTINE CODE ATOM %OWNINTEGER PRE %INTEGER I,J,K,LAST POS1 = POS; LAST = ATOM1 ATOM1 = 1; ATOM2 = 0; SUBATOM = 0 %RETURN %IF SYMTYPE = 0; !NL OR SEMI-COLON ->20 %IF SYMTYPE = -2; !LETTER -> ->15 %IF SYMTYPE < 0; !DIGIT -> ->10 %IF QUOTE # 0; !QUOTED STRING -> ->11 %IF SYM = QU; !QUOTE -> !LOCATE ATOM IN FIXED DICT !DICT(96:KMAX) := MORE<1>:0<1>:LINK<9>:SYM<7> ! OR MORE<1>:1<1>:SUBCLASS<10>:CLASS<6> 1: I = KEY>>2; READ SYM 2: J = DICT(I) %IF J&65536 = 0 %THEN %START %IF J&127#SYM %OR SYMTYPE<0 %THEN %START ->99 %UNLESS J < 0; I = I+1 %FINISH %ELSE %START I = J>>7&511; READ SYM %FINISH ->2 %FINISH ATOM1 = J&63; !ATOM CLASS SUBATOM = J>>6&1023 %IF ATOM1 = 0 %THEN %START; !EXT,OWN,BYTE,SHORT ->99 %UNLESS PRE&SUBATOM = 0 PRE = PRE+SUBATOM; ->1 %FINISH ATOM2 = DICT(I+1)&63 %IF J < 0; !VARIANT ATOM CLASS %RETURN %UNLESS ATOM1&(\7) = 32; !DECLARATOR %IF PRE&32 # 0 %THEN %START; !OWN ->99 %UNLESS ATOM1=33 %OR ATOM1=35 ATOM1 = ATOM1+1 %FINISH DECL = SUBATOM+PRE; PRE = 0 DECL = DECL!!48 %IF LAST # 0 %AND DECL&4 # 0; !R PAR: SET DYN,NAME %RETURN 10: %IF LAST # 7 %THEN %START ATOM1 = 7; %RETURN; !INFILTRATE COMMA %FINISH 11: QUOTE = 1; READ SYM %IF LAST # 15 %THEN %START; !LAST ATOM # PTEXT ATOM1 = 50; SUBATOM = SYM; !SCONST READ SYM %IF SYM = QU = NEXT SYMBOL %RETURN %IF NEXT SYMBOL # QU READ SYM %FINISH %ELSE %START ATOM1 = 49; SUBATOM = TEXT; !STRING J = 0 12: %UNLESS SYM=QU#NEXTSYMBOL %THEN %START ->99 %IF TEXT = DMAX; !TOO LONG READ SYM %IF SYM = QU %IF J&(\127) # 0 %THEN %START DICT(TEXT) = J; TEXT = TEXT-1 J = 0 %FINISH J = J<<7+SYM READ SYM ->12 %FINISH DICT(TEXT) = -131072+J; TEXT = TEXT-1 %FINISH QUOTE = 0; READ SYM %RETURN !NUMERIC CONSTANT 15: ->20 %IF (LAST=0 %AND SECTION=0) %OR LAST = 9; !LAB OR JUMP ATOM1 = 50; SUBATOM = SYM-'0'; !SCONST 16: READ SYM ->17 %IF SYMTYPE # -1 SUBATOM = (SUBATOM<<2+SUBATOM)<<1-'0'+SYM ->16 17: %RETURN %UNLESS SYM = '_' !SPECIAL RADIX I = SUBATOM; SUBATOM = 0 READ SYM ->99 %UNLESS SYMTYPE < 0 18: %IF SYMTYPE=-1 %THEN K=SYM-'0' %ELSE K=SYM-55 ->99 %IF K >= I SUBATOM = SUBATOM+K READ SYM ->17 %IF SYMTYPE >= 0 J = I; K = SUBATOM; SUBATOM = 0; !MULTIPLY BY RADIX 19: SUBATOM = SUBATOM+K %IF J&1 # 0 K = K<<1; J = J>>1 ->19 %IF J # 0 ->18 !IDENTIFIER 20: %IF LAST = 50 %THEN %START; !PRECEDED BY CONST ATOM1 = 19; SUBATOM = 12; !IMPLICIT MULT %RETURN %FINISH HEAD = (SYM-32)<<6<<6; MAX = DMAX 21: READ SYM; ->25 %IF SYMTYPE >= 0 HEAD = HEAD+512; MAX = MAX+1 J = SYM-32 READ SYM; ->24 %IF SYMTYPE >= 0 J = J<<6+SYM-32 READ SYM; ->24 %IF SYMTYPE >= 0 DICT(MAX) = J<<6+SYM-32 ->21 24: DICT(MAX) = J 25: ATOM1 = 48; ATOM2 = ATOM1 LIM = TBASE; LOOKUP(TMAX) %RETURN 99: ATOM1 = 0 %END; !CODE ATOM %INTEGERFN GAPP; !GRAMMAR FOR APP %INTEGER I,L %INTEGERFN CLASS(%INTEGER K) %RESULT = K&15+69 %IF K&7 # 2; !A(72),M(73),F(74),P(75), !R(76),BA(80),BM(81) %RESULT = 106 %IF K&16 = 0; !INTEGER->EXP(106) %RESULT = 103 %IF K&8 = 0; !INTEGERNAME->REF(103) %RESULT = 104; !BYTEINTEGERNAME->BREF(104) %END %ROUTINE SET GCELL(%INTEGER C) C = L<<7+C; !LINK + CLASS 1: %IF L # GMAX %THEN %START L = L+1; %RETURN %IF GRAM(L) = C ->1 %FINISH GMAX = GMAX+1; L = GMAX; GRAM(L) = C %END %RESULT = 255 %IF TMAX = TBASE; !NULL APP I = TMAX; L = GMAX1; !RB CELL 1: SET GCELL(CLASS(TAGTYPE(I))) I = I-1 %IF I # TBASE %THEN %START SET GCELL(7); ->1; !COMMA CELL %FINISH SET GCELL(6); !LB CELL %RESULT = L %END %ROUTINE ANALYSE(%INTEGER G) %INTEGER I,J,K,N,A1,NODE %ROUTINE REORDER %OWNINTEGERNAME X,Y !STARTING AT END OF PHRASE, ! 1) CHANGE FROM BACK-LINKED TO FORWARD-LINKED STRUCTURE ! 2) DROP TRANSPARENT ATOMS ! 3) REORDER AS SPECIFIED BY ORDERING CODE K = 0 1: %RETURN %IF N >= 0 I = REF(N); J = CO(N) %IF I&112 # 0 %THEN %START; !CLASS >= 16 X == K; I = I&98304 2: %IF X # 0 %THEN %START Y == REF(X) %IF Y&98304 > I %THEN %START Y = Y-32768; X == CO(X); !DECREMENT ORDERING CODE ->2 %FINISH %FINISH CO(N) = X; X = N %FINISH N = J ->1 %END A = 0; A1 = 0; N = 0; NODE = 0; P = -101 1: J = GRAM(G) K = J&127 ->10 %IF K = 0 CLASS = K CLASS = ATOMIC(CLASS) %IF CLASS&64 # 0 %IF ATOM2=48 %AND 42<=CLASS<=47 %THEN %START LIM = GLOBAL; LOOKUP(TBASE) %FINISH %IF CLASS=ATOM1 %OR CLASS=ATOM2 %THEN %START; !ATOM MATCH DECLARE IDENT %IF CLASS = 48 A = A-1; ->90 %IF A = P REF(A) = J; CO(A) = N SUB(A) = SUBATOM ->15 %IF J&32640 = 0; !END OF SS ->5 %UNLESS K = 5; !AMBIGUOUS '(', ALAS %FINISH %ELSE %START %IF K >= 96 %THEN %START; !PHRASE P = P+1; ->90 %IF P = A REF(P) = J; CO(P) = N N = -P; G = PHRASE(K) ->1 %FINISH %FINISH G = G+1 ->1 %IF J < 0 5: %IF NODE = A1 %THEN %START; !LAST NODE FOR THIS ATOM ->90 %IF NODE = A; !NO NEW NODES ADDED -> A1 = A; CODE ATOM; !READ NEXT ATOM %FINISH NODE = NODE-1; N = NODE ->11 10: REORDER; N = -N; SUB(N) = K 11: G = REF(N)>>7&255; !CONTINUATION ->1 %IF G # 0 15: N = A; REORDER; SS = K FAULT(3) %IF DUP # 0 %RETURN !ERROR 90: ->91 %IF SYM = NL READ SYM ->90 91: %UNLESS ATOM2=48 %AND LIM=GLOBAL %THEN %START %IF ATOM1>0 %THEN FAULT(0) %ELSE FAULT(1) %FINISH %ELSE FAULT(2) QUOTE = 0; SYMTYPE = 0; DECL = 0 %END SS = 0; DECL = 0; ATOM1 = 0; DUP = 0 TEXT = DLIM; INDEX0 == INDEX(0) ->5 %IF CONT # 0 READ SYM %IF SYMTYPE = 0 %IF SYMTYPE=0 %OR SYM='!' %THEN %START 1: %RETURN %IF SYMTYPE = 0; READ SYM ->1 %FINISH CODE ATOM; ->1 %IF ATOM1 = 3; !COMMENT -> %IF ATOM1=48 %AND (SYM=':' %OR ATOM2=41) %THEN %START DECL = 96 SSTYPE = 0; ANALYSE(SS0); !LABEL %FINISH %ELSE %START %IF DECL # 0 %OR SECTION # 0 %THEN %START SSTYPE = 1; ANALYSE(SS1); !DECLARATION %FINISH %ELSE %START SSTYPE = 3; ANALYSE(SS3); !STATEMENT %FINISH %FINISH %RETURN 5: CODE ATOM SSTYPE = 2; ANALYSE(SS2); !FORMAL PARAMETERS I = GAPP<<8 %IF BTYPE&(\255) # 0 %THEN %START FAULT(4) %IF BTYPE&(\255)#I %AND GLOBAL#0 BTYPE = BTYPE+64; !SET 'BODY' %FINISH %ELSE BTYPE = BTYPE+I %END; !ANALYSE SS %ROUTINE COMPILE SS %INTEGER I,J,K,L,LINK,NEXT,CLASS,DCLASS,REFDEST,BOWN,RANGE %INTEGER PEND,APEND,PENDOPR,LABEL,ELSE,LTAG,LNEST,SINGLE %INTEGER CONTROL,START,INC,END,ILIT,ELIT %OWNINTEGER LIT,ACLIT,LIT1 %SWITCH C(0:111), D(32:37) %ROUTINE PR(%INTEGER X) %INTEGER I %RETURN %IF X = 0; I = !X! 1: PRINT SYMBOL(I&15+'0'); !'HEX' DIGIT I = I>>4; ->1 %IF I # 0 PRINT SYMBOL('-') %IF X < 0 %END %ROUTINE SWOP; !SWITCH SECTIONS %OWNINTEGER T %IF LEVEL < 0 %THEN %START %IF SECTION = 0 %THEN %START PRINT SYMBOL('('); T = X %FINISH %ELSE %START PR(T); PRINT SYMBOL(')') %FINISH %FINISH %ELSE PRINT SYMBOL('/') SECTION = SECTION!!1 %END %ROUTINE DEF(%INTEGER T); !DEFINE TAG PR(T); PRINT SYMBOL('.') %RETURN %IF SECTION # 0 ACCESS = 1; AC = \255 %END %ROUTINE PLANT(%INTEGER V); !PLANT VALUE PR(V); PRINT SYMBOL('#') %END %ROUTINE OP(%INTEGER OP); !OUTPUT OP CODE PRINT SYMBOL(OP) %END %ROUTINE PRINT(%INTEGER X) %IF PENDOPR >= 0 %THEN %START SINGLE = 0 %UNLESS NEXT = 0 %AND LINK = 0 PENDOPR = PENDOPR!!SINGLE; !INVERT SKIP IF SINGLE %IF PENDOPR # 0 %THEN %START PR(PENDOPR); OP(79); !OPR %FINISH %IF SINGLE = 0 %THEN %START LABEL = L; PR(LMIN); OP(76); !JMP %FINISH DEF(LTAG-1) %IF LNEST&1 # 0 PENDOPR = -1; ACCESS = 1 %FINISH PR(X) %END %ROUTINE NEST PRINT(NST); OP(66); AC = \AC; !JMS NST %END %ROUTINE EXPEND; !DISCHARGE PENDING LAC %INTEGER T %RETURN %IF PEND < 0 NEST %IF AC >= 0 %IF PEND = 0 %THEN %START; !CONSTANT %UNLESS \AC=0 %AND ACLIT=LIT %THEN %START PRINT(LIT); OP(36); !LAL LIT (PSEUDO-OP) ACLIT = LIT %FINISH %FINISH %ELSE %START %UNLESS \AC = PEND %THEN %START T = PEND&255; PRINT(T) %IF T=PEND %THEN OP(68) %ELSE OP(95); !LAC OR LAD %FINISH %FINISH AC = PEND; PEND = -1 %END %ROUTINE LAC(%INTEGER T); !LOAD AC EXPEND; PEND = T %END %ROUTINE LAL(%INTEGER L); !LOAD AC LITERAL EXPEND; PEND = 0; LIT = L %END %ROUTINE DO(%INTEGER I); !ADD,TAD,AND,XOR,SAD %IF PEND >= 0 %THEN %START %IF PEND = 0 %THEN %START; !CONSTANT PRINT(LIT); OP(I-32); !PSEUDO-OP %FINISH %ELSE %START PRINT(PEND); OP(I) %FINISH PEND = -1 AC = 255 %UNLESS I = 75; !SAD %FINISH %ELSE OP(I+16); !* T0 %END %ROUTINE DAC(%INTEGER T); !DEPOSIT AC %IF PEND = 0 %AND LIT = 0 %THEN %START PEND = -1; AC = \255 %IF \AC = T SINGLE = 512; PRINT(T); OP(67); !DZM T %FINISH %ELSE %START EXPEND AC = T %IF PENDOPR < 0; AC = \AC SINGLE = 512; PRINT(T); OP(65); !DAC T %FINISH %END %ROUTINE OPR(%INTEGER X); !OPERATE-GROUP EXPEND; PRINT(X); OP(79) AC = 255 %IF X&4125 # 0 %END %ROUTINE CMA; !COMPLEMENT AC OPR(1) %END %ROUTINE NEG; !NEGATE %IF PEND # 0 %THEN %START CMA; PRINT(1); OP(39); !CMA:TAD #1 %FINISH %ELSE LIT = -LIT %END %ROUTINE JMS(%INTEGER T); !SUBROUTINE JUMP EXPEND; PRINT(T); OP(66); AC = 255 %END %ROUTINE JMSX(%INTEGER T); !SPECIAL JMS %IF PEND >= 0 %THEN %START; !SECOND PARAM SIMPLE PRINT(2); OP(65); AC = \AC; !DAC T2 %FINISH %ELSE %START DAC(1); OP(84); DAC(2); !DAC T1:LAC* T0:DAC T2 PEND = 1; !LAC T1 %FINISH JMS(T) %END %ROUTINE JMP(%INTEGER T); !JUMP PRINT(T); OP(76) %END %ROUTINE MON(%INTEGER N); !MONITOR PRINT(MONI); OP(82); PLANT(N&255); !JMS* MONI: FLT-NUM AC = \255; ACCESS = 0 %END %ROUTINE AREF; !ARRAY REF %IF TTX&8=0 %THEN JMS(AR) %ELSE JMS(BAR); !WORD,BYTE PRINT(X); OP(95); !LAD X %END %ROUTINE PLANT OWN OWN = OWN-1 %IF OWN&BOWN = 0 %THEN %START LIT = LIT<<9+LIT1 %IF BOWN # 0 PLANT(LIT) %FINISH %ELSE LIT1 = LIT %END %ROUTINE PLANT NAME(%INTEGER OP); !EXTERNALS %INTEGER I,J %ROUTINE NEXT SPACE %IF J # 0 %THEN %START J = J-1; PRINT(DICT(I-J)) %FINISH %END PRINT(X); SPACE; !TAG I = INDEX(X); J = I>>9&7 PRINT(I&(\511)+TTX&63); !SYM1+LENGTH+TYPE I = I&511+KMAX NEXT; NEXT PRINT SYMBOL(OP) %END %ROUTINE COMPILE END %INTEGER I,J,K 1: %IF LSTACK # 0 %THEN %START FAULT(LSTACK&1+9) LMIN = LMIN+2; LSTACK = LSTACK>>2 ->1 %FINISH X = TMAX SWOP; !SELECT DATA SECTION PLANT(0) %IF DANGER # 0; I = -1 6: %IF X # TBASE %THEN %START TTX == TT0++X; K = TTX&255 FAULT(12) %IF K = 32 %OR K&196 = 4; !LABEL OR PROC MISSING %IF K = 33 %THEN %START; !SWITCH J = TTX>>8; ->8 %IF J = 0 SWOP; DEF(X); PLANT(DICT(J-1)) J = DICT(J); PLANT(J) 7: OP(79); J = J-1; ->7 %IF J>0; !NOP (JMP SET BY LOAD) SWOP %FINISH %IF K&32 = 0 %THEN %START; !DYNAMIC %IF K&23 = 2 %AND DANGER = 0 %THEN %START DEF(X); !DEFINE TAG DIRECT %FINISH %ELSE %START DEF(-X); !DEFINE TAG INDIRECT %FINISH %IF K&23 = 2 %AND DANGER # 0 %THEN %START PLANT(-1); !POINTER SLOT %FINISH %ELSE %START PLANT(0) %FINISH I = I-1 %FINISH 8: X = X-1 ->6 %FINISH %IF BTAG # 0 %THEN %START DEF(BTAG); PLANT(0); !ENTRY POINT %IF DANGER = 0 %THEN %START ->25 %IF PMAX = TBASE 16: PRINT(PMAX); OP(93); !DAD PMAX PMAX = PMAX-1 ->25 %IF PMAX = TBASE; OP(84); !LAC* T0 ->16 %FINISH J = PMAX-TBASE; J = J-1 %IF J # 0 JMS(ENT); !JMS ENTRY/EXIT PLANT(I); PLANT(I+J-1); !-SLOTS:-NEST 25: %IF BTAG#DANGER>0 %THEN GD=BTAG %ELSE BTYPE=BTYPE+128 %FINISH SWOP; !REVERT TO INSTR SECTION %END !PROCESS ANALYSIS RECORD PEND = -1; LIT = 0; RANGE = 0 LABEL = 0; ELSE = 0; PENDOPR = -1 %STOP %IF AC >= 0 LINK = 0; NEXT = SS %IF ACCESS=0 %AND SSTYPE=3 %AND REF(-1)&127#58 %THEN %START FAULT(16); ACCESS = -1; !INACCESSIBLE STATEMENT %FINISH 1: X = SUB(NEXT) %IF X < 0 %AND NEXT <= P %THEN %START; !PHRASE %IF CO(NEXT) # 0 %THEN %START SUB(NEXT) = LINK; LINK = NEXT %FINISH NEXT = X ->1 %FINISH CLASS = REF(NEXT)&127; NEXT = CO(NEXT) ->C(X) %IF CLASS <= 29 %OR CLASS = 100 TTX == TT0++X; !FOR USE WHEN X IS TAG ->C(CLASS) %UNLESS CLASS = 48; !IDENT ->D(DCLASS) 8: FAULT(4) %IF TTX&8 # RANGE RANGE = 0 9: ->1 %IF NEXT # 0 ->10 %IF LINK = 0 NEXT = CO(LINK); LINK = SUB(LINK) ->9 10: %RETURN %IF LABEL = 0 JMP(-(LMIN+1)) %IF LABEL = 2; !JUMP BACK FOR LOOPS DEF(LMIN) %UNLESS LABEL = 3 DEF(LMIN+1) %IF ELSE # 0; !PICKUP POINT FOR ELSE %RETURN !COMPILE DECLARATIONS C(32):C(33):C(34):C(35):C(36):C(37): !DECLARATORS DCLASS = CLASS; !FOR FOLLOWING IDENTS ->1 %ROUTINE SET SIZE(%INTEGERNAME I) PEND = -1; I = LIT-LIT1+1 %RETURN %IF 1 <= I <= 4096 FAULT(13); I = 200 %END D(32): !SWITCH DMAX = DMAX+2; TTX = DMAX<<8+TTX DICT(DMAX-1) = -LIT SET SIZE(DICT(DMAX)) ->9 D(33):->9; !INTEGER D(34): !OWNINTEGER SWOP %IF SECTION = 0 X = -X %IF TTX&16 # 0; !NAME DEF(X); PLANT(LIT) OWN = 0; PEND = -1 ->9 D(35): !INTEGERARRAY %IF TTX&8 # 0 %THEN %START PRINT(3); OP(67); !DZM T3 %FINISH %IF AC >= 0 %THEN %START; !FIRST IN GROUP FAULT(17) %IF LSTACK # 0 JMSX(ADEC); !JMS ADEC %FINISH %ELSE %START; !BOUNDS ALREADY SET PEND = 1; JMS(ADEC); !LAC T1:JMS ADEC %FINISH ATAG = X; PRINT(ATAG); OP(93); !DAD ATAG AC = \255 ->9 C(83): !BOUND SEP (COLON) LIT1 = LIT; PEND = -1 ->9 D(36): !OWNINTEGERARRAY SWOP; DEF(X); PLANT(-LIT) SET SIZE(OWN); PLANT(OWN) LIT = 0; BOWN = 0 ->9 %IF TTX&8 = 0 BOWN = 1; OWN = OWN&1+OWN ->9 C(84): !OWNSEP (COMMA) PLANT OWN %IF OWN > 0 LIT = 0; PEND = -1 ->9 C(94): !OWNT (T) 941:%IF OWN > 0 %THEN %START PLANT OWN; LIT = 0 ->941 %FINISH SWOP; PEND = -1; !REVERT TO INSTR SECTION %RETURN D(37): !PROCEDURE %IF DECL&64 = 0 %THEN %START PLANT NAME(',') %IF DECL&128 # 0; !EXT SPEC %FINISH %ELSE %START %IF DECL&128 # 0 %THEN %START FAULT(15) %UNLESS LEVEL < 0 TTX = TTX-128; !REMOVE EXT PLANT NAME('!'); !EXT ENTRY %FINISH PRINT SYMBOL('(') %FINISH %RETURN C(39): !BEGEND: ENDOFPRIM(1), ENDOFPERM(2), BEGIN(111), ! END(260), ENDOFPROGRAM(261) %IF X = 1 %THEN %START TBASE = TMAX %IF TBASE = 0 %FINISH %IF X = 2 %THEN %START GLOBAL = TBASE; TBASE = TMAX; LINE = 0 CLOSE OUTPUT %FINISH %IF X = BEG %THEN %START %IF LEVEL < 0 %THEN %START; !MAIN BEGIN DECL = 0; LINE = 1 ACCESS = 1; LEVEL = 0 PRINT SYMBOL('!'); !ENTRY-POINT %FINISH %ELSE %START TMAX = TMAX+1; X = TMAX TAGTYPE(X) = DECL; INDEX(X) = 0 JMS(X); AC = \255 PRINT SYMBOL('(') %FINISH %FINISH %IF X = 260 %THEN %START FAULT(5) %IF BTAG = 0; !MAIN PROG %IF ACCESS # 0 %THEN %START FAULT(11) %IF BTYPE&7 # 7 %AND GLOBAL # 0 PRINT(BTAG); OP(92); !JMP* BTAG %FINISH DANGER = -ATAG %IF DANGER = 0 COMPILE END PRINT(TBASE); PRINT SYMBOL(')'); !END OF BLOCK %FINISH %IF X = 261 %THEN %START FAULT(8) %IF BTAG # 0 MON(0) %IF ACCESS # 0 DANGER = 0 COMPILE END %UNLESS LEVEL < 0 PRINT SYMBOL(')'); !END OF BLOCK %FINISH %RETURN !LSTACK, ESTACK AND LNEST ARE SINGLE-WORD NESTS !LSTACK (2 BITS) KEEPS TRACK OF STATEMENT BRACKETS !ESTACK (1 BIT) KEEPS TRACK OF ELSE JUMPS !LNEST (3 BITS) DEALS WITH INTERNAL STRUCTURE OF COND STATEMENTS !SIGNIFICANCE OF LSTACK VALUES: ! 01 IF,UNLESS ! 10 CYCLE,WHILE,UNTIL ! 11 ELSE !SIGNIFICANCE OF LNEST VALUES: ! 000 AND AFTER AND,IF ! 001 AS ABOVE + DISCONTINUITY ! 010 OR AFTER OR,UNLESS ! 011 AS ABOVE + DISCONTINUITY ! 100 IF / WHILE / AND AFTER OR,UNLESS ! 101 AS ABOVE + DISCONTINUITY ! 110 UNLESS / OR AFTER AND,IF ! 111 UNTIL / AS ABOVE + DISCONTINUITY %ROUTINE POP LABEL(%INTEGER IND) %IF LSTACK=0 %OR LSTACK&IND # 0 %THEN %START FAULT(IND+6); %RETURN %FINISH LABEL = LSTACK&3; ELSE = ESTACK&1 LSTACK = LSTACK>>2; ESTACK = ESTACK>>1 LMIN = LMIN+2 %END !COMPILE FOR, CYCLE ! ORDER = (START) CONTROL (INC) CSEP1 (END) CSEP2 STARTT C(42): !VARIABLE CONTROL = X START = PEND; LIT1 = LIT; !START VALUE PEND = -1 ->9 %ROUTINE SET(%INTEGERNAME W) %IF PEND # 0 %THEN %START TMAX = TMAX+1; W = TMAX TAGTYPE(W) = 2; INDEX(W) = 0; !DECLARE WL DAC(W) %FINISH %ELSE %START W = 0; PEND = -1 %FINISH %END C(89): !CSEP1 SET(INC); ILIT = LIT; !INCREMENT ->9 C(90): !CSEP2 SET(END); ELIT = LIT; !END VALUE %IF START = INC = 0 %THEN %START LAL(LIT1-ILIT) %FINISH %ELSE %START LAC(INC); LIT = ILIT; !LAC INC NEG %IF START < 0 %THEN %START OP(84) %IF AC < 0; !LAC* T0 %FINISH %ELSE %START LAC(START); LIT = LIT1 %FINISH DO(71); !TAD %FINISH DAC(CONTROL); != START-INC DEF(LMIN+1); !LAB FOR JUMP BACK LAC(CONTROL); !LAC CONTROL LAC(END); LIT = ELIT; DO(75); !SAD END JMP(LMIN); !JMP (NEXT INSTR) LAC(INC); LIT = ILIT; DO(71); !TAD INC DAC(CONTROL); !DAC CONTROL LABEL = 2 ->9 C(57): !REPEAT POP LABEL(1) ->9 !COMPILE CONDITIONS !STAT ORDER = CWORD COND IMP, CWORD COND START, ! CWORD COND IMP ELSE IMP, CWORD COND IMP ELSE START !COND ORDER = AND C1 C2, OR C1 C2, NOT C1 !SCOND ORDER = EXP1 EXP2 COP, EXP1 EXP2 COP EXP3 COP C(56): !LWORD: WHILE(20), UNTIL(23) JMP(LMIN-1) %IF X&1 # 0; !UNTIL: JUMP OVER TEST DEF(LMIN+1); !LABEL FOR LOOPING C(51): !CWORD: IF(12), UNLESS(14) LABEL = 0; L = X>>3; LNEST = X&7 LTAG = LMIN ->9 %ROUTINE PUSH(%INTEGER ANDOR) %IF LNEST&2 # ANDOR %THEN %START ANDOR = ANDOR+4; LNEST = LNEST!1 %FINISH LTAG = -(LNEST&1)+LTAG LNEST = LNEST<<3+ANDOR %END C(52): !AND PUSH(0) ->9 C(53): !OR PUSH(2) ->9 C(54): !NOT LNEST = LNEST!!2 ->9 C(55): !COP: <(64), =(128), <=(192), >=(576), #(640), >(704) PUSH(0) %IF NEXT # 0; !DOUBLE-SIDED %IF PEND = 0 %AND LIT = 0 %THEN %START; !COMPARISON WITH ZERO PEND = -1 X = X+4096 %IF NEXT # 0; !+CLA IF DOUBLE %FINISH %ELSE %START K = PEND %IF X&64 # 0 %THEN %START; !<,<=,>=,> %IF PEND=0 %AND LIT>0 %AND NEXT=0 %THEN %START PRINT(64); OP(79); !SMA LIT = -LIT; DO(71); !TAD (-LIT %FINISH %ELSE %START %IF X&128 # 0 %THEN %START; !<=,> JMSX(LE); X = X!!448; !SZL,SNL %FINISH %ELSE %START JMSX(GE); X = X!!832; !SZL,SNL %FINISH AC = K %IF K >= 0; !ACLIT STILL SET %FINISH %FINISH %ELSE %START; !=,# DO(75); !SAD %IF X = 640 %THEN %START; !# %IF K>=0 %AND NEXT#0 %THEN %START PEND = K; AC = \255 %FINISH X = 0 %FINISH %ELSE X = 512; !SKP %FINISH %FINISH 551:X = X!!512 %IF LNEST&2 # 0; !INVERT %IF LNEST&(\7) # 0 %OR L = 2 %THEN %START OPR(X) %UNLESS X = 0 AC = \AC %UNLESS NEXT # 0 I = LTAG; J = LNEST 552: %IF J&4 = 0 %THEN %START J = J>>3; I = J&1+I ->552 %FINISH JMP(I); LABEL = L %IF I = LMIN DEF(LTAG-1) %IF LNEST&1 # 0 LNEST = LNEST>>3 LTAG = LNEST&1+LTAG %FINISH %ELSE %START PENDOPR = X; SINGLE = 0 AC = \AC; AC = \255 %IF LNEST&1 # 0 %FINISH ->9 !COMPILE START, FINISH, ELSE, EXIT, CONTINUE C(92): !STARTT (T) PRINT(0) %IF PENDOPR >= 0; !DISCHARGE PENDING SKIP %IF LABEL = 0 %THEN %START LABEL = 2; DEF(LMIN+1); !INDEFINITE CYCLE %FINISH LSTACK = LSTACK<<2+LABEL ESTACK = ESTACK<<1+ELSE LMIN = LMIN-2 %RETURN C(58): !FINISH POP LABEL(0) ->9 %IF LABEL # 0 %RETURN C(59): !ELSE POP LABEL(0) %IF LABEL = 0 %IF LABEL = 1 %THEN %START %IF ACCESS # 0 %THEN %START JMP(LMIN+1); ELSE = 1 %FINISH LABEL = 3 DEF(LMIN) ->9 %FINISH FAULT(15) ->10 C(20): C(21): !EXIT, CONTINUE J = LMIN+2; K = LSTACK 201:%IF K&1 # 0 %THEN %START J = J+2; K = K>>2 ->201 %FINISH FAULT(15) %IF K = 0 ACCESS = 0; SINGLE = 512 %IF X = 20 %THEN JMP(J) %ELSE JMP(-(J+1)) ->9 !COMPILE LABELS AND JUMPS C(66): !LAB FAULT(17) %IF X < ATAG TTX = 96; DEF(X) %RETURN C(40):C(65): !L,JLAB ACCESS = 0; SINGLE = 512 JMP(X) ->9 C(64): !SLAB I = TTX>>8; %RETURN %IF I = 0; !POINTER TO BOUNDS LIT = DICT(I-1)+LIT; !INDEX - UPPER %IF LIT <= 0 %THEN %START LIT = DICT(I)+LIT; !+ NUMBER %IF LIT > 0 %THEN %START PRINT(LIT+1); SPACE; DEF(X) %RETURN %FINISH %FINISH FAULT(14) %RETURN C(41): !SNAME AREF PRINT(3); OP(88); MON(135); !XCT* T3:MON 7+128 ->9 !COMPILE PROCEDURE EXITS C(16): !RETURN FAULT(15) %IF BTYPE&15 # 7; !SHOULD BE ROUTINE 161:ACCESS = 0; SINGLE = 512 PRINT(BTAG); OP(92); !JMP* BTAG ->9 C(17): !TRUE OPR(2050); !STL 171:FAULT(15) %IF BTYPE&7 # 6; !SHOULD BE PRED ->161 C(18): !FALSE OPR(2048); !CLL ->171 C(19): !RESULT FAULT(15) %IF BTYPE&6 # 4; !SHOULD BE FN OR MAP %IF BTYPE&7 = 5 %THEN %START J = AC; K = ACLIT; EXPEND AC = J; AC = \255 %IF AC >= 0 ACLIT = K %FINISH %ELSE DAC(3) NEXT = 0 ->161 !COMPILE STOP, FAULT, MONITOR, ETC C(27): !STOP MON(64) ->9 C(28): !FAULT FAULT(15) %IF BTAG # 0; !SHOULD BE MAIN PROG JMS(FLT); PLANT(1); JMP(SUB(NEXT)); !JMS FLT: SLOT FOR NP: JMP AC = \255 %RETURN C(29): !MONITOR PEND = -1; MON(LIT) ->9 C(30): !MCODE (OPERAND AFTER) LIT = SUB(NEXT) C(31): !LMCODE (CONST BEFORE) PRINT(LIT); OP(X) AC = \255; PEND = -1 %RETURN C(49): !STRING (PRINTTEXT) JMS(PTXT); !PTEXT SR (TEXT FOLLOWS) 491:I = DICT(X); PLANT(I); X = X-1 ->491 %UNLESS I < 0 AC = \255 ->9 !COMPILE OPERANDS %ROUTINE CALL JMS(X) %RETURN %IF DANGER # 0 %AND DANGER # BTAG DANGER = X %IF TTX&128=0 %AND X<=PMAX; !NOT SAFE %END C(50): C(105): !CONST, SCONST LAL(X) ->9 C(87): !ASSA: = APEND = PEND; LIT1 = LIT; PEND = -1 ->9 C(69): !DEST: V %IF NEXT # 0 %AND REF(NEXT)&127 # 85 %THEN %START REFDEST = X; FAULT(15) %IF TTX&16 = 0 ->9 %FINISH %IF TTX&8 = 0 %THEN DAC(X) %ELSE %START JMS(BPUT); PRINT(X); OP(95); !JMS BPUT:LAD X AC = \255 %FINISH ->9 C(9): !REFASS: == EXPEND %IF AC # 255 %THEN %START TTX == TT0++(AC&255) %IF TTX&16 = 0 %THEN %START PRINT(-65537); OP(42); !AND #-65537 %FINISH %FINISH PRINT(REFDEST); OP(93); !DAD REFDEST AC = \(256+REFDEST) ->9 C(109): !SEXP: V %IF TTX&8 = 0 %THEN LAC(X) %ELSE %START LAC(256+X); JMS(BGET); !LAD X:JMS BGET %FINISH ->9 C(43): !ARRAY ELEMENT (VAL) AREF ->441 C(44): !MAP ELEMENT (VAL) CALL 441:%IF TTX&8 = 0 %THEN %START PRINT(3); OP(84); !LAC* T3 %FINISH %ELSE JMS(BGET); !JMS BGET ->9 C(70): !ARRAY ELEMENT (DEST) AREF ->711 %IF APEND < 0 AC = \255 PEND = APEND; LIT = LIT1; EXPEND ->712 C(71): !MAP ELEMENT (DEST) CALL 711:OP(84); !LAC* T0 712:%IF TTX&8 = 0 %THEN %START PRINT(3); OP(81); !DAC* T3 AC = \AC %FINISH %ELSE %START JMS(BPUT); PRINT(3); OP(68); !JMS BPUT:LAC T3 AC = \255 %FINISH ->9 C(111): !APP (NULL) EXPEND; NEST %IF AC >= 0 ->9 C(80): C(81): C(82): !BAPAR, BMPAR, BVREF RANGE = 8 C(72):C(73):C(74):C(75):C(76):C(77): !APAR,MPAR,FPAR,PPAR,RPAR,VREF LAC(256+X); !LAD X ->8 C(78): !BYTE AREF RANGE = 8 C(67): !ARRAY ELEMENT (REF) AREF ->8 C(79): !BYTE MREF RANGE = 8 C(68): !MAP ELEMENT (REF) CALL ->8 C(45): !F (CALL) CALL %UNLESS X = 28; !T28: ADDR ->9 C(46): !P (CALL) CALL X = 256; !FOR SNL ->551 C(47): !R (CALL) EXPEND; SINGLE = 512 CALL; AC = \255 ->9 C(85): ->9; !SEP !COMPILE OPERATORS C(88): !MOD OPR(65); OPR(513); !SMA!CMA:SKP!CMA PRINT(1); OP(39); !TAD #1 ->9 C(0): !PLUS-SIGN DO(71) %IF CLASS # 16; !TAD (UNLESS UNARY) ->9 C(1): !MINUS-SIGN %IF CLASS # 16 %THEN %START %IF PEND > 0 %THEN %START PRINT(1); OP(79); !INFILTRATE CMA DO(71); CMA; !TAD: CMA %FINISH %ELSE %START NEG; DO(71) %FINISH %FINISH %ELSE NEG ->9 C(2): !UOP: \ %IF PEND # 0 %THEN CMA %ELSE LIT = \LIT ->9 C(3): C(4): !LEFT-SHIFT, RIGHT-SHIFT %IF PEND=0 %AND LIT&(\7)=0 %THEN %START PEND = -1 31: ->9 %IF LIT = 0 %IF X=3 %THEN OPR(2056) %ELSE OPR(2064); !RCL,RCR LIT = LIT-1 ->31 %FINISH NEG %IF X # 3 JMSX(SH) ->9 C(6): !AND DO(74) ->9 C(10): !XOR DO(69) ->9 C(11):C(12):C(13):C(14):C(15): !OR,MULT,IDIV,DIV,EXP JMSX(X) ->9 C(8): !REFOP -- NEG C(7): !REFOP ++ X = SUB(NEXT); TTX == TT0++X; NEXT = 0 %IF PEND = 0 %AND LIT = 1 %AND REFDEST = X %THEN %START I = CO(LINK) %IF I # 0 %AND REF(I)&127 = 22 %THEN %START; !REFASS CO(LINK) = CO(I); PEND = -1 AC = \255 %IF \(AC&255) = X SINGLE = 512; PRINT(X); OP(89); !ISZ* X (FOR ISZ X) %FINISH %FINISH %ELSE %START EXPEND; AC = 255 PRINT(X); OP(94); !ADA X %FINISH ->8 %END; !COMPILE SS %END; !COMPILE BLOCK %ENDOFPROGRAM