diff --git a/source/B65SIM/SOURCE.alg_m b/source/B65SIM/SOURCE.alg_m new file mode 100644 index 0000000..70abf75 --- /dev/null +++ b/source/B65SIM/SOURCE.alg_m @@ -0,0 +1,6541 @@ + COMMENT 00099999 + ***************************** 00100000 + ***** B6500 SIMULATOR ***** 00101000 + ***************************** 00102000 + ********************************* 00200000 + ***** ERROR MESSAGE INDEX ***** 00201000 + ********************************* 00202000 + # PROCEDURE EXPLANATION 00203000 + -- --------- ----------- 00204000 + 0 CONTROLSECTION MORE THAN 1 OF VARF,LEEF,TEEF,SEEF ON 00205000 + 1 VARI TRIED TO EXECUTE VARI OPERATOR 00206000 + 2 (RESERVED FOR TEED) 00207000 + 3 (RESERVED FOR TEEU) 00208000 + 4 (RESERVED FOR ILED) 00209000 + 5 (RESERVED FOR ILEU) 00210000 + 6 EXSD TRIED TO EXECUTE EXSD OPERATOR 00211000 + 7 EXSU TRIED TO EXECUTE EXSU OPERATOR 00212000 + 10 ERVSFLOW INVALID CALL ON ERVSFLOW (FELL THRU SWITCH) 00213000 + 11 ERVSFLOW NOT(AROF AND BROF) IN SPECIALINDEX 00214000 + 13 ERVSFLOW STACK UNDERFLOW P22 NOTE THIS WILL BE INTERRUPT 00215000 + 14 ERVSFLOW PAGE 7A AROF TRUE 00216000 + 15 ERVSFLOW BROF FALSE IN NORMALINDEX 00217000 + 98 ADJ INVALID PARAMETERS TO ADJ 00218000 + 99 ADJ ADJ DIDNT PERFORM REQUESTED ACTION 00219000 + 100 RDIV QUOTIENT CANNOT BE INTEGERIZED. 00220000 + 101 INTERRUPTCONTROL INT HAS IMPROPER VALUE. 00221000 + 200 MULTIPLEXOR A NON-EXISTENT HARDWARE TYPE WAS REQUESTED. 00222000 + 201 MULTIPLEXOR THE BUFFER LENGTH FOR A FILE IS TO SMALL. 00223000 + 202 IDLE NO INTERRUPTS PENDING FOR IDLE OPERATOR 00224000 +% ## TYPE OF TRACE 00225000 +% -- ------------- 00226000 +% 0 NO TRACE 00227000 +% 1 A X B Y REGISTERS 00228000 +% 2 C REGISTERS 00229000 +% 3 P REGISTER 00230000 +% 4 DISPLAY REGISTERS 00231000 +% 5 STACK CONTENTS 00232000 +% 6 A X B Y C 00233000 +% 7 A X B Y P 00234000 +% 6 A X B Y DISPLAY 00235000 +% 9 A X B Y STACK 00236000 +% 10 A X B Y C P 00237000 +% 11 A X B Y C DISPLAY 00238000 +% 12 A X B Y C STACK 00239000 +% 13 A X B Y P DISPLAY 00240000 +% 14 A X B Y P STACK 00241000 +% 15 A X B Y DISPLAY STACK 00242000 +% 16 A X B Y C P DISPLAY 00243000 +% 17 A X B Y C P STACK 00244000 +% 18 A X B Y C P DISPLAY STACK 00245000 +% 19 TYPE 18 TRACE AND MEMORY DUMP % 00246000 +% 00247000 +% SIMULATOR DIRECTORY 00248000 +% 00249000 +% SEQ. NR. ITEM 00250000 +% 00200000 ERROR MESSAGE INDEX 00251000 +% 00400000 HARDWARE 00252000 +% 00600000 MISCELLANEOUS DECLARATIONS(SEE ALSO 01000000 AND 01700000)00253000 +% 00700000 B6500 REGISTER,FLIP-FLOP,FLAG,LINE AND BUSS DECLARATIONS 00254000 +% 01000000 MISCELLANEOUS DECLARATIONS(SEE ALSO 00600000 AND 01700000)00255000 +% 01200000 B6500 PARTIAL FIELD DEFINES 00256000 +% 01400000 WORD FORMAT DESCRIPTIONS 00257000 +% 01600000 FORWARD PROCEDURE DECLARATIONS 00258000 +% 01700000 MISCELLANEOUS PROCEDURE,DEFINE AND OTHER DECLARATIONS 00259000 +% (SEE ALSO 00600000 AND 01000000) 00260000 +% 01800000 INTERRUPT CONTROLLER 00261000 +% 02000000 SIMULATOR CONTROL SECTION 00262000 +% 04000000 SIMULATOR UTILITY PROCEDURES(PSYLLABLES, STEPPSR, ETC.) 00263000 +% 07000000 B6500 OPERATOR PROCEDURES 00264000 +% 50000000 ERVSFLOW 00265000 +% 51000000 STORE (STOD, STON, OVRD, OVRN) 00266000 +% 60000000 B6500 MICRO-OPERATORS (ADJ, ETC.) 00267000 +% 71000000 SIMULATOR INITIALIZATION 00268000 +% 72000000 MULTIPLEXOR 00269000 +% 73000000 SIMULATOR 00270000 +% 74000000 TRACE 00271000 +% 75000Q00 B6500 MEMORY DUMP 00272000 +% 76000000 ERROR ROUTINE 00273000 +% 77000000 HEADINGLINE 00274000 +% 78000000 SIMULATOR STARTS ( I.E. DECLARATIONS AND PROCEDURES END) 00275000 +; 00276000 +BEGIN COMMENT SIMULATOR OUTER BLOCK; 00277000 +COMMENT DO NOT CHANGE THE PRT LOCATION OF THE FOLLOWING 5 VARIABLES; 00278000 +INTEGER TRACEWORD % 25 00278001 + ,STATUSWORD % 26 00278002 + ,HALTING % 27 00278003 + ,TRACTER % 30 00278004 + ,MONITORVALUE % PRT 31 THE SIMULATOR READS AND ACCEPTS THIS 00278005 + % VALUE & PLACES IT IN D[31]. THE MCP MOVES IT 00278006 + % FROM D[31] AND PLACES IT IN A GLOBAL 00278007 + ; 00278010 +REAL PROCCLOCK, % PROCESSOR CLOCK RATE IN MEGACYCLES DEFAULT=10 00279000 + MPXQUAN , % NUMBER OF MULTIPLEXORS DEFAULT= 1 00280000 + MPXAOPS , % MAXIMUM OPERATIONS FOR MPXA DEFAULI=10 00281000 + MPXBOPS , % MAXIMUM OPERATIONS FOR MPXB DEFAULT=10 00282000 + MEMMODS , % NUMBER OF 16K MEMORY MODULES DEFAULT= 2 00283000 + MEMTIME , % MEMORY CYCLE TIME DEFAULT=1.200284000 + PROCID , % PROCESSOR IDENTIFICATION DEFAULT = 1 00284500 + DISKLOAD, % ESPOL = 0; ALGOL = 1; COBOL = 2; 00285000 + BUFRMAX , % MAXIMUM BUFFER SIZE 00286000 + ROWLENGTH; % LENGTH OF M ARRAY ROW (6500 WOROS) 00287000 +REAL ETIME, PTIME, STARTDATE; 00288000 +REAL TIMEOFDAY; % WHAT IT SAYS - SEE SCNI - SCNO 00288010 +SAVE ARRAY TBUF [0:16]; % FORMATTING AREA FOR TRACE AND MEMDUMP 00289000 +BOOLEAN PRINTERNOTYETOPENED; 00290000 +REAL STREAM PROCEDURE MKABS (A); BEGIN SI ~ A; MKABS ~ SI END; 00291000 + ARRAY EBCTOBCL [0:31]; % INDEXED BY AN 8 BIT EBCDIC CHARACTER TO 00292000 + % FIND A 6 BIT BCL CHARACTER-MOSTLY INV CHR00293000 +ARRAY BUFFERS [0:3, 0:13]; % BUFFER LENGTHS FOR LOGICAL UNITS 00294000 + % INDEXED BY HDWE TYPE AND SWITCH FILE INDX00295000 +INTEGER NCR; % ABSOLUTE ADDRESS MESS [0] 00296000 +DEFINE FILLBUFFERS = % DEFAULT BUFFER LENGTHS 00297000 + % HDWE TYPES: DSC SPO BIDS LP CR CP TAPE 00298000 + FILL BUFFERS [0,*] WITH 0, 30, 10, 0,0,0,15,0,0,10,10,0,0,1023;00299000 + FILL BUFFERS [1,*] WITH 0, 30, 0, 0,0,0,15,0,0, 0, 0,0,0,1023;00300000 + FILL BUFFERS [2,*] WITH 0, 30, 0, 0,0,0, 0,0,0, 0, 0,0,0,1023;00301000 + FILL BUFFERS [3,*] WITH 0, 30, 0, 0,0,0, 0,0,0, 0, 0,0,0,1023;00302000 + #; 00303000 +ARRAY PERIPHERALT[0:69]; %TIMING CONSTANTS FOR PERIPHERAL UNITS 00304000 +DEFINE FILLT=FILL PERIPHERALT[*] WITH 00305000 + 0,0,0,0,0, %000306000 + 80,2@5,0,0,0, %DISK-MPX CYCLE TIME, LATENCY TIME 100307000 + 0,0,0,0,0, %200308000 + 0,0,0,0,0, %300309000 + 0,0,0,0,0, %400310000 + 0,0,0,0,0, %500311000 + 2.42@4,57.6@4,24.3@4,6.6@4,10@4, %BUFFERED PRINTER 600312000 + %MPX BUSY TIME,DRUM ROTATION TIME, 00313000 + %FIRST SPACING TIME,EACH ADDITIONAL 00314000 + %SPACING TIME 00315000 + 27.1@4,75@4,24.3@4,6.6@4,10@4, %UNBUFFERED PRINTER 700316000 + %SAME AS BUFFERED PRINTER 00317000 + 0,0,0,0,0, %800318000 + 24.3@4,75@4,0.0,0, %CARD READER -EL.CYCLE,ME.CYCLE 900319000 + 24.3@4,6@6,0,0,0, %CARD PUNCH-EL.CYCLE,ME.CYCLE 1000320000 + 0,0,0,0,0, %1100321000 + 0,0,0,0,0, %1200322000 + 120,800,6.7@4,.6,0; %MAGNETIC TAPE- 1300323000 + %SPEED,DENSITY,START TIME,RECORD GAP00324000 + #; 00325000 +ARRAY STATVECTOR [0:7]; % PERIPHERAL STATUS WORDS 00325100 +ARRAY OLDSTATVEC [0:7]; % TO SAVE OFF CHANGED STATUS WORD 00325300 +ALPHA 00326000 +ARRAY MPX [0:6, 0:31]; COMMENT INDEXED BY MULTIPLEXOR 00327000 + AND LOGICAL UNIT NO. CONTAINS: 00328000 + RESULT DESCRIPTOR MPX [MPXUNIT+4,LOGICALUNIT] 00329000 + AND MPX INFO WORD 00330000 + ; 00331000 +BOOLEAN MULTIPLEX; % TRUE FOR SCNO (IIO) 00332000 +BOOLEAN SPOED; % TRUE FOR NOTHINGTODO READ 00333000 +ARRAY CUP[0:11]; 00334000 +REAL TUBA, 00335000 + PID; % PROCESSOR I.D. 00335500 +SAVE ALPHA 00336000 + ARRAY EVENTS [0:31]; COMMENT INDEXED BY LOGICAL UNIT OR SELF. 00337000 + CONTAINS THE REAL TIME FOR THE COMPLETION OF THE I-O 00338000 + BEING PERFORMED ON THIS UNIT AND A LINK TO THE NEXT 00339000 + EVENT AND A MULTIPLEXOR INDICATOR. 00340000 + ; 00341000 + ARRAY UNITAVAILTIME[0:31]; COMMENT-INDEXED BY LOGICAL UNIT. 00342000 + CONTAINS REALTIME WHEN NEXT I/O COULD BE 00343000 + INITIATED ON THIS UNIT.; 00344000 +DEFINE % DEFINES FOR MPX AND EVENTS PARTIAL FIELDS 00345000 + EVTIME = [12:36]#, % I-O COMPLETE TIME 00346000 + EVLINK = [ 7: 5]#, % EVENT LINK 00347000 + EVBUSY = [ 6: 1]#, % BUSY BIT 00348000 + EVMPX = [ 1: 2]#, % MPX FOR THIS I-O 00349000 + RSLTERR = [31:17]#, % ERROR FIELD 00350000 + RSLTUNIT = [23: 8]#, % UNIT 00351000 + TCHRS = [20: 3]#, % RESULT CHRS 00352000 + RSLTADRS = [ 1:19]#, % ADDRESS 00353000 + MPXINT = [38:10]#, % MPX INTERRUPT VALUE 00354000 + MPXHDWE = [32: 6]#, % HARDWARE UNIT TYPE 00355000 + MPXSWFI = [24: 6]#, % SWITCH FILE INDEX 00356000 + MPXWLO = [ 1: 1]#, % 1 = WRITE LOCK-OUT 00357000 + TUB = [ 2:9]#, % TU & BUF ADDRESS 00358000 + MPXBUFF = [14:10]#; % BUFFER LENGTH 00359000 + RSLTUNIT = [23: 8]#, % UNIT 00351000 + TCHRS = [20: 3]#, % RESULT CHRS 00352000 + RSLTADRS = [ 1:19]#, % ADDRESS 00353000 +}?P$5C 7T T 0000 = [38:10]#, % MPX INTERRUPT VALUE 00354000 +REAL CURRENTT, % THE TIME FOR THE NEXT MULTIPLEXOR INTERRUPT 00363000 + CURRENTMPX; % THE MPX FOR THE NEXT MULTIPLEXOR INTERRUPT 00364000 +ARRAY MPXOPS [0:2];%OPERATIONS PER MPX 00365000 +DEFINE DELTAMPX = 4#; % THE INCREMENT REQUIRED TO FIND THE RESULT 00366000 + % DESCRIPTOR IN MPX ARRAY. 00367000 +INTEGER INTTIMER; % THE NEXT REAL TIME FOR A TIME INTERRUPT 00368000 +REAL MONITORMASKOLD;% TEMPORARY MONITOR MASK 00369000 +REAL MONITORMASK; 00369100 +PROCEDURE HARDWARE; 00400000 + BEGIN 00401000 + DEFINE LUNIT= TBUF [0]#, 00402000 + HTYPE= TBUF [1]#, 00403000 + MPXAB= TBUF [2]#, 00404000 + BUFLG= TBUF [3]#, 00405000 + + WLO = TBUF [4]#; 00406000 + INTEGER I, J, S; 00407000 + LABEL EOF; 00408000 + DEFINE 00409000 + TIMEADJUST = ;#; %%%%%%%%%% 00410000 + TBUF [16] ~ MKABS (TBUF); 00411000 + PRINTERNOTYETOPENED ~ TRUE; 00412000 + FILLBUFFERS; 00413000 + FILLT; 00414000 + FILL EBCTOBCL [*] WITH % GRAPHIC UNDER LOW-ORDER OCTADE 00415000 + OCT1414141414141414, 00416000 + OCT1414141414141414, 00417000 + OCT1414141414141414, 00418000 + OCT1414141414141414, 00419000 + OCT1414141414141414, 00420000 + OCT1414141414141414, 00421000 + OCT1414141414141414, 00422000 + OCT1414141414141414, 00423000 + OCT6014141414141414, 00424000 + % BLANK 00425000 + OCT1414143236352037, 00426000 + % . < ( + ~ 00427000 + OCT3414141414141414, 00428000 + % & 00429000 + OCT1414405253555657, 00430000 + % | $ * ) ; { 00431000 + OCT5461141414141414, 00432000 + % - / 00433000 + OCT1414767273741614, 00434000 + % ] , % ! > QUESTION MARK 00435000 + OCT3314141414141414, 00436000 + % [ 00437000 + OCT1414151213177577, 00438000 + % : # @ } = " 00439000 + OCT1414141414141414, 00440000 + OCT1414141414141414, 00441000 + OCT1414141414141414, 00442000 + OCT1414141414141414, 00443000 + OCT1414141414141414, 00444000 + OCT1414141414141414, 00445000 + OCT1414141414141414, 00446000 + OCT1414141414141414, 00447000 + OCT1421222324252627, 00448000 + % A B C D E F G 00449000 + OCT3031141414141414, 00450000 + % H I 00451000 + OCT1441424344454647, 00452000 + % J K L M N O P 00453000 + OCT5051141414141414, 00454000 + % Q R 00455000 + OCT1414626364656667, 00456000 + % S T U V W X 00457000 + OCT7071141414141414, 00458000 + % Y Z 00459000 + OCT0001020304050607, 00460000 + % 0 1 2 3 4 5 6 7 00461000 + OCT1011141414141414; 00462000 + % 8 9 00463000 + BEGIN 00464000 + FILE CONFIGURATION (1, 10); 00465000 + READ (CONFIGURATION, /, PROCCLOCK, MPXQUAN, MPXAOPS, 00466000 + MPXBOPS, MEMMODS, MEMTIME, PROCID, DISKLOAD 00467000 + ,HALTING 00467010 + ,MONITORMASK 00467100 + ,MONITORVALUE 00467200 + ); 00468000 + MONITORMASKOLD ~ MONITORVALUE; 00468900 + IF PROCCLOCK = 0 THEN PROCCLOCK ~ 10; % MEGACYCLES 00469000 + IF MPXQUAN = 0 THEN MPXQUAN ~ 1; % MULTIPLEXORS 00470000 + MPXAOPS ~ 00471000 + MPXOPS [1] ~ IF MPXAOPS = 0 THEN 10 ELSE MPXAOPS; 00472000 + MPXBOPS ~ 00473000 + MPXOPS [2] ~ IF MPXBOPS = 0 THEN 10 ELSE MPXBOPS; 00474000 + IF MEMTIME = 0 THEN MEMTIME ~ 1.2;% MICROSECONDS 00475000 + MEMTIME ~ MEMTIME | 10; 00476000 + MEMMODS ~ (2*14|2|(IF MEMMODS = 0 THEN 2 ELSE MEMMODS))-1; 00477000 + IF PROCID = 0 THEN PID ~ 1 ELSE PID ~ PROCID; 00477500 + IF DISKLOAD > 0 THEN INTTIMER ~ 0 ; 00478000 + END; 00479000 + BEGIN 00480000 + FILE CABLING (2, 10); 00481000 + STREAM PROCEDURE STATUS(SWORD, LUNIT); VALUE LUNIT; 00481100 + BEGIN DI ~ SWORD; SKIP LUNIT DB; DS ~ 1 SET END STATUS; 00481200 + LABEL EOF; 00482000 + STATUSWORD ~ 1; 00482100 + DO BEGIN 00483000 + READ (CABLING, /, LUNIT, HTYPE, MPXAB, BUFLG 00484000 + , WLO , TUBA )[EOF]; 00485000 + IF MPXAB = 0 THEN MPXAB ~ 1; 00486000 + MPX [I ~ MPXAB, J ~ LUNIT].MPXWLO ~ WLO; 00487000 + MPX [I, J].MPXHDWE ~ HTYPE; 00488000 + MPX [I, J].MPXSWFI ~ S ~ MPX [0, HTYPE]; 00489000 + MPX [0, HTYPE] ~ MPX [0, HTYPE] + 1; 00490000 + IF BUFLG ! 0 THEN BUFFERS [S, HTYPE] ~ 00491000 + BUFLG; 00492000 + MPX [I, J].MPXBUFF ~ BUFLG; 00493000 + I ~ 46 - LUNIT; 00493100 + STATUS (STATUSWORD, I); 00493200 + END UNTIL FALSE; 00494000 + EOF: END; 00495000 + S ~ 10; % MINIMUM BUFFER SIZE IS 10 00496000 + FOR I ~ 0 STEP 1 UNTIL 3 DO 00497000 + FOR J ~ 0 STEP 1 UNTIL 13 DO 00498000 + IF BUFFERS [I, J] > S THEN S ~ BUFFERS [I, J]; 00499000 + BUFRMAX ~ S; 00500000 + LUNIT ~ 0; 00501000 + ETIME ~ TIME (1); 00502000 + PTIME ~ TIME (2); 00503000 + STARTDATE ~ TIME (0); 00504000 + TIMEADJUST; 00505000 + ROWLENGTH ~ 256; 00506000 + END OF HARDWARE INITIALIZE; 00507000 +HARDWARE; 00508000 +BEGIN 00509000 +LABEL EOJ; 00600000 +INTEGER T; 00601000 +DEFINE STACKVECTOR = D0+2#; 00602000 + %**************************************** 00700000 + %***** B6500 REGISTER DECLARATIONS ***** 00701000 + %**************************************** 00702000 + %NAME #BITS DESCRIPTION 00703000 +REAL A,AX, % 51 TOP OPERAND IN STACK 00704000 + X,XX, % 51 EXTENSION OF A 00705000 + B,BX, % 51 SECOND OPERAND IN STACK 00706000 + Y,YX, % 51 EXTENSION OF B 00707000 + C,CX, % 51 GENERAL PURPOSE REGISTER 00708000 + P,PX; % 51 PROGRAM REGISTER 00709000 +BOOLEAN AROF, % 1 A REGISTER OCCUPIED 00710000 + BROF, % 1 B REGISTER OCCUPIED 00711000 + PROF; % 1 P REGISTER OCCUPIED 00712000 +DEFINE MEMCYCLE = DELTATIME ~ DELTATIME + MEMTIME;#; 00713000 +LONG ARRAY M [0:MEMMODS]; 00714000 + %NOTE: INDICIES ARE AUTOMATICALLY DOUBLED 00715000 + % AND THE ARRAY IS PARTIONED INTO A 00716000 + % TWO-DIMENSIONAL ARRAY WITH 256-WD ROWS00717000 + % BY SPECIAL COMPILER PATCHES. 00718000 +REAL MA, % 3 MANTISSA EXTENSION OF A 00719000 + MB, % 3 MANTISSA EXTENSION OF B 00720000 + EA, % 1 EXPONENT EXTENSION OF A 00721000 + EB, % 1 EXPONENT EXTENSION OF B 00722000 + AA, % 42 10 MC ADDER CAPTIVE REGISTER (ADDEND) 00723000 + BB, % 42 10 MC ADDER CAPTIVE REGISTER (AUGEND) 00724000 + CC, % 42 10 MC ADDER CAPTIVE REGISTER (IDLER) 00725000 + SGNF, % 1 EXTERNAL SIGN 00726000 + MM, % 20 MAIN MEMORY ADDRESSING REGISTER 00727000 + LL, % 5 LEXIOGRAPHIC LEVEL (DISPLAY MEMORY POINTER) 00728000 + BRS, % 7 BASE READ SELECT (I.C. MEMORY ADDRESSING REG.)00729000 + BWS, % 7 BASE WRITE SELECT (I.C. MEMORY ADDRESSING REG.)00730000 + IRS, % 4 INDEX READ SELECT (I.C. MEMORY ADDRESSING REG.)00731000 + IWS, % 4 INDEX WRITE SELECT (I.C. MEMORY ADDRESSINS REG.)00732000 + OPSR,% 3 OLD PSR 00733000 + PICR,% 20 PROGRAM INDEX COUNTER FOR SINGLE INSTRUCTION 00734000 + DRS; % 6 DISPLAY READ SELECT REGISTER 00735000 +ARRAY D[0:31];%20 I.C. DISPLAY MEMORY 00736000 +DEFINE D0 = D[ 0]#, D8 = D[ 8]#, D16 = D[16]#, D24 = D[24]#, 00737000 + D1 = D[ 1]#, D9 = D[ 9]#, D17 = D[17]#, D25 = D[25]#, 00738000 + D2 = D[ 2]#, D10 = D[10]#, D18 = D[18]#, D26 = D[26]#, 00739000 + D3 = D[ 3]#, D11 = D[11]#, D19 = D[19]#, D27 = D[27]#, 00740000 + D4 = D[ 4]#, D12 = D[12]#, D20 = D[20]#, D28 = D[28]#, 00741000 + D5 = D[ 5]#, D13 = D[13J#, D21 = D[21]#, D29 = D[29]#, 00742000 + D6 = D[ 6]#, D14 = D[14]#, D22 = D[22]#, D30 = D[30]#, 00743000 + D7 = D[ 7]#, D15 = D[15]#, D23 = D[23]#, D31 = D[31]#, 00744000 + D00 = D[ 0]#, D03 = D[03]#, D06 = D[06]#, D09 = D[09]#, 00745000 + D01 = D[ 1]#, D04 = D[04]#, D07 = D[07]#, 00746000 + D02 = D[02]#, D05 = D[05]#, D08 = D[08]#; 00747000 +INTEGER SP, % 6 SOURCE REGISTER POINTER 00748000 + DP, % 6 DESTINATION REGISTER POINTER 00749000 + G, % 6 00750000 + K, % 6 00751000 + TP, % 4 TABLE BASE POINTER 00753000 + PSR; % 3 PROGRAM SYLLABLE REGISTER 00754000 +COMMENT THE FOLLOWING DECLARATION IS FOR THE 8 I.C. BASE REGISTERS00755000 + AND ITS INTERNAL SEQUENCE SHOULD NOT BE DISTURBED WITHOUT 00756000 + CHECKING THE ARRAY BRSR, PROCEDURES RPRR AMD SPRR, ETC.; 00757000 +REAL PBR, SBR, DBR, TBR, S, SNR, PDR, TEMP; %DLK00758000 +DEFINE BUF2 = TBR#; % SHARED REGISTERS 00759000 +REAL TSR; 00760000 +COMMENT THE FOLLOWING DECLARATION IS FOR THE 8 I.C. INDEX REGISTERS00761000 + AND ITS INTERNAL SEQUENCE SHOULD NOT BE DISTURBED WITHOUT 00762000 + CHECKING THE ARRAY BRSR, PROCEDURES RPRR AND SPRR, ETC.; 00763000 +REAL PIR, SIR, DIR, TIR, LOSR, BOSR, F, BUF1; %DLK00764000 +DEFINE BUF3 = TIR#; % SHARED REGISTERS 00765000 +COMMENT ***** EXPLANATORY ONLY (SEE ABOVE) ******************00766000 + PBR, % 20 PROGRAM BASE REGISTER 00767000 + SBR, % 20 SOURCE BASE REGISTER 00768000 + DBR, % 20 DESTINATION BASE REGISTER 00769000 + BUF2, % 20 UTILITY REGISTER - SHARED WITH TBR 00770000 + S, % 20 TOP OF STACK POINTER 00771000 + SNR, % 20 STACK NUMBER REGISTER 00772000 + PDR, % 20 PROGRAM DESCRIPTOR REGISTER 00773000 + TEMP, % 20 TEMPORARY G.P. REGISTER 00774000 + PIR, % 20 PROGRAM INDEX REGISTER 00775000 + PICR, %4 DELTA PIR FOR OPERATOR, USED TO RESTORE PIR 00776000 + SIR, % 20 SOURCE INDEX REGISTER 00777000 + DIR, % 20 DESTINATION INDEX REGISTER 00778000 + TIR, % 20 TABLE INDEX REGISTER 00779000 + BUF3, % 20 UTILITY REGISTER - SHARED WITH TIR 00780000 + LOSR, % 20 LIMIT OF STACK REGISTER 00781000 + BOSR, % 20 BASE OF STACK REGISTER 00782000 + F, % 20 MARK STACK POINTER 00783000 + BUF; % 20 BUFFER G.P. REGISTER 00784000 +DEFINE BUF = BUF1#; % TO OVERCOME NOMENCLATURE DIFFICULTY 00785000 +INTEGER 00786000 + SIB, % 6 SOURCE BIT INDEX REGISTER 00787000 + DIB, % 6 DESTINATION BIT INDEX REGISTER 00788000 + RPF, % 20 REPEAT FIELD REGISTER 00789000 + DIS, % 00790000 + TOM, % 6 TOP OF MASK 00791000 + TOA; % 6 TOP OF APERATURE 00792000 +ARRAY IRSR, BRSR [0:7]; % USED TO HOLD BASE AND INDEX REGISTERS 00793000 +ARRAY MONITOROUTPUT [0:13]; 00793100 +FORMAT MONFMT (X1,A1,A6,X1,I1, X1, 16I1, 7(X2, I5, X1, I5)); 00793200 +DEFINE NULLB=0#,% NULL STATE FOR I.C. MEMORY BASE REGISTERS 00794000 + NULLI=0#;% NULL STATE FOR I.C. MEMORY INDEX REGISTERS 00795000 +REAL AB, % 20 ADDRESS BASE BUSS 00796000 + AI; % 20 ADDRESS INDEX BUSS 00797000 +BOOLEAN NCSF; % 1 NORMAL STATE FF 00798000 +REAL QP; % MISC CONTROL FLIP/FLOPS (STRING OPERATORS) 00798500 +REAL Q; % 18 Q0 AND QC SETS OF G.P. LOGICAL FFS (CLEARED AT SECL) 00799000 +DEFINE Q00F = Q.[47:1]#, Q03F = Q.[44:1]#, Q06F = Q.[41:1]#, 00800000 + Q01F = Q.[46:1]#, Q04F = Q.[43:1]#, Q07F = Q.[40:1]#, 00801000 + Q02F = Q.[45:1]#, Q05F = Q.[42:1]#, Q08F = Q.[39:1]#, 00802000 + QC0F = Q.[38:1]#, QC3F = Q.[35:1]#, QC6F = Q.[32:1]#, 00803000 + QC1F = Q.[37:1]#, QC4F = Q.[34:1]#, QC7F = Q.[31:1]#, 00804000 + QC2F = Q.[36:1]#, QC5F = Q.[33:1]#, QC8F = Q.[30:1]#; 00805000 +REAL N; % 4 G.P. COUNT REGISTER (CLEARED AT SECL) 00806000 +BOOLEAN LPF, % 1 LINE PARITY--READ 00807000 + IIHF, % 1 00807500 + SUFL, % 1 STACK UNDER FLOW FLIP/FLOP 00807600 + EXTF, % 1 ENTERNAL SIGN FLIP FLOP 00808000 + TFFF, % 1 TRUE/FALSE FF 00809000 + OFFF, % 1 OVERFLOW FF 00810000 + FLTF , % 1 FLOAT FLIP FLOP 00811000 + TEEF, % 1 TABLE EDIT ESCAPE 00812500 + LEEF, % 1 LINE EDIT ESCAPE 00813000 + EDITF , % 1 EDIT MODE FLIP FLOP 00814000 + EXSF , % 1 EXECUTE SINGLE SHOT 00815000 + ESPF , % 1 EXECUTE SINGLE POINTER 00815500 + UPDF , % 1 UPDATE 00816000 + SOPF , % 1 SINGLE PRECISION OPERAND 00817000 + RNTF , % 1 RE-ENTER FLIP/FLOP FOR CHARACTER MODE 00818000 + VARF; % 1 VARIANT ESCAPE 00819000 +DEFINE SEEF = EXSF#; 00820000 +REAL SSZ, % 2 SOURCE CHARACTER SIZE 00821000 + DSZ, % 2 DESTINATION CHARACTER SIZE 00822000 + TCS, % 2 TABLE CHARACTER SIZE 00823000 + OFS, % 6 OFFSET REGISTER (SIEERING CONTROL) 00824000 + J1F, % 6 FAMILY 1 SEQUENCE COUNTER 00825000 + J2F; % 6 FAMILY 2 SEQUENCE COUNTER 00826000 +BOOLEAN REQ, % 1 REQUEST (MEM. INTERFACE) 00827000 + WRT, % 1 WRITE (MEM. INTERFACE) 00828000 + PRO, % 1 PROTECT (MEM. INTERFACE) 00829000 + MROF; % 1 MEM. READ OBTAINED (MEM. INTERFACE) 00830000 +BOOLEAN STKOVFF; % ADJ SETS TRUE FOR STACK OVERFLOW 00830100 +DEFINE % ALARM INTERRUPTS 00831000 + LOOPI = 33554433 #, % 2*25+2*0 OPERATOR LOOP 00832000 + MEMPARI = 33554434 #, % 2*25+2*1 MEMORY PARITY 00833000 + MPXPARI = 33554436 #, % 2*25+2*2 MULTIPLEXOR PARITY 00834000 + INVADRI = 33554440 #, % 2*25+2*3 INVALID ADDRESS 00835000 + STKUNFI = 33554448 #, % 2*25+2*4 STACK UNDERFLOW 00836000 + INVOPA = 33554464 #, % 2*25+2*5 UNKNOWN OPERATOR 00837000 + % SYLLABLE DEPENDENT INTERRUPTS 00838000 + MEMPROI = 16777217 #, % 2*24+2*0 MEMORY PROTECT 00839000 + INVOP = 16777218 #, % 2*24+2*1 INVALID OPERATOR 00840000 + DIVZROI = 16777220 #, % 2*24+2*2 DIVIDE BY ZERO 00841000 + EXPOVFI = 16777224 #, % 2*24+2*3 EXPONENT OVERFLOW 00842000 + EXPUNFI = 16777232 #, % 2*24+2*4 EXPONENT UNDERFLOW 00843000 + INVINXI = 16777248 #, % 2*24+2*5 INVALID INDEX 00844000 + INTOVFI = 16777280 #, % 2*24+2*6 INTEGER OVERFLOW 00845000 + BOSINT = 16777344 #, % 2*24+2*7 BOTTOM OF STACK 00846000 + PRESBIT = 16777472 #, % 2*24+2*8 PRESENCE BIT 00847000 + SEQERRI = 16777728 #, % 2*24+2*9 SEQUENCE ERROR 00848000 + % GENERAL CONTROL INTERRUPTS 00849000 + INTTIMI = 4194305 #, % 2*22+2*0 INTERVAL TIMER 00850000 + STKOVFI = 4194306 #, % 2*22+2*1 STACK OVERFLOW 00851000 + % EXTERNAL INTERRUPTS 00852000 + EXTINTI = 1048816#, % BITS 20, 7-4 ON EXTERNAL INTERRUPT 00853000 + %I/O FINISH BEING FORCED, MLC NOT HONORD 00854000 + PTOPI = 2097152 #, % 2*21 PROCESSOR TO PROCESSOR 00855000 + DUMMYI = 0#; 00856000 +REAL INT; % INTERRUPT FLIP/FLOPS 00857000 + % FLIP/FLOP FUNCTION 00858000 +DEFINE EXIA = INT.[27:1]#, % [20:1] EXIA MPXA 00859000 + PTPI = INT.[26:1]#, %[21:1] PTPI PROCESSOR 00860000 + GCIF = INT.[25:1]#, % [22:1] GENERAL CONTROL 00861000 + SDIS = INT.[23:2]#, %[24:2] SDIS SYLLABLE DEPENDENT00862000 + ALRM = INT.[22:1]#, %[25:1] ALRM ALARM INTERRUPT 00863000 + % GCIF & ALRM HAVE NOONES APPROVAL 00864000 + DUMMYF = 0#; 00865000 +REAL E, % 4 MEM. CYCLE REQUEST (MEM. INTERFACE) 00866000 + RF; % 8 REPEAT FIELD REGISTER 00867000 +REAL ICR1; % INTERRUPT CONTROL REGISTER 00868000 +INTEGER 01000000 + NSTACK, % VALUE USED FOR TRACING STACK 01001000 + NDISPLAY; % VALUE USED FOR TRACING DISPLAYS 01002000 +REAL TANK; % ABSOLUTE ADDRESS OF SAVE ARRAY TBUF 01003000 +SAVE 01004000 +ARRAY TBUF[0:16]; % FORMATING AREA FOR TRACE AND MEMDUMP 01005000 +ALPHA MULFILID, FILID; % THE SOURCE FILE FOR INITIALIZE 01005100 +REAL JUNK; 01007000 +INTEGER INTG; 01008000 +ARRAY MNEMONIC[0:2,0:255]; 01009000 +INTEGER TS1; 01010000 +SAVE ARRAY DELTAMASK[0:31]; % MASKS OUT DELTA PART OF ADRCPL FIELDS 01011000 +SAVE ARRAY REFLECTION[0:31];% REFLECTS LL PARTS OF ADRCPL FIELDS 01012000 +FILE TRACK 14(1,5); % DATA COM FILE TO READ TRACE PARAMETERS 01013000 +DEFINE BITS=(IF SB THEN DS:=SET ELSE DS:=RESET; SKIP 1 SB)#, 01014000 + DIG=(DS:=3 RESET; 3 BITS)#, 01015000 + PRINT=WRITE(LP,15,TBUF[*])#; 01016000 +DEFINE HEADING = IF PRINTERNOTYETOPENED THEN 01017000 + IF PRINTERNOTYETOPENED.[46:1] 01017250 + THEN HEADINGLINE(TAPED) 01017500 + ELSE HEADINGLINE(LP)#; 01017750 +REAL INTMASKA, % INTERRUPT MASKS AND REGISTERS FOR MPXA AND MPXB 01018000 + INTMASKB, % 10 BITS EACH 01019000 + INTREGA, 01020000 + INTREGB; 01021000 +REAL SCANBUSA, SCANBUSAX,% SCAN AND DATA BUSES FOR MPXS 01022000 + DATABUSA, DATABUSAX;% WITH MOVE EXTENSIONS 01023000 +REAL ABORTTIME,% THE REAL TIME FOR NEXT ABORT INTERRUPT 01024000 + IDLETIME ;% THE REAL TIME FOR NEXT INTERRUPT 01025000 +REAL REALTIME, COMMENT THE TIME IN 100 NANOSECOND UNITS SINCE THE 01026000 + BEGINNING OF SIMULATION. USED WITH TIMEOFDAY AND 01027000 + REALETIME FOR SCAN IN AND OUT OF TIME OF DAY CLOCK.; 01028000 + TIMEOFDAY, 01029000 + REALETIME, 01030000 + DELTATIME;COMMENT THE TIME INCREMENT SINCE THE REAL TIME CLOCK 01031000 + WAS UPDATED. USUALLY THE TIME REQUIRED FOR AN OPER- 01032000 + ATOR.; 01033000 + %********************************************** 01200000 + %***** B6500 FIELD ABBREVIATION DEFINES ***** 01201000 + %********************************************** 01202000 +DEFINE % ABBR. B5500 B6500 FIELD/BIT NAME 01203000 + TAG = [44: 3]#, % [50: 3] TAG FIELD 01204000 +% TAG VALUES... 01205000 + SINGL = 0#, % SINGLE PRECISION OPERAND 01206000 + IRW = 1#, % INDIRECT REFERENCE WORD 01207000 + DOUBL = 2#, % DOUBLE PRECISION OPERAND 01208000 + MEMLINK= 3#, % STORAGE LINK 01209000 + CODE = 3#, % CODE 01210000 + SEGDESC= 3#, % SEGMENT DESCRIPTOR 01211000 + MSCW = 3#, % MARK STACK CONTROL WORD 01212000 + TOS = 3#, % TOP OF STACK CONTROL WORD 01213000 + RCW = 3#, % RETURN CONTROL WORD 01214000 + SIW = 4#, % STEP INDEX WORD 01214100 + DATADESC=5#, % DATA DESCRIPTOR 01215000 + UNITAL = 6#, % UNINITIALIZED OPERAND 01216000 + PCW = 7#, % PROGRAM CONTROL WORD (PGM DESC) 01217000 +% END TAG VALUES 01218000 + ROBIT = [46:1]#, % [48:1] READ ONLY FIELD 01219000 + LOBIT = [47:1]#, % [0:1] LOW ORDER BIT 01220000 + PBIT = [47: 1]#, % [47: 1] PRESENCE BIT (IN DATADESC,SEGDESC01221000 + DSBIT = [47: 1]#, % [47: 1] DIFFERENT STACK BIT (IN MSCW) 01222000 + SGNFF = [47:1]#, % [47:1] SGNF FIELD IN TOS CONTROL WORD 01223000 + EXPEXT = [ 1: 8]#, % [47: 9] EXPONENT EXTENTION (DBL PREC) 01223100 + INCRF = [ 1:11]#, % [47:12] INCREMENT FIELD (IN STEP INDEX) 01223500 + CBIT = [ 1: 1]#, % [46: 1] COPY BIT (IN DATADESC,SEGDESC) 01224000 + EBIT = [ 1: 1]#, % [46: 1] ENVIRONMENT BIT (IN IRW,MSCW) 01225000 + SOBIT = [ 1: 1]#, % [46:1] SIGN OF OPERAND BIT 01226000 + OFFFF = [1:1]#, % [46:1] OFFF FIELD IN TOS CONTROL WORD 01227000 + IBIT = [ 2: 1]#, % [45: 1] INDEXED BIT 01228000 + SEBIT = [ 2: 1]#, % [45: 1] SIGN OF EXPONENT BIT 01229000 + TFFFF = [2:1]#, % [45:1] TFFF FIELD IN TOS CONTROL WORD 01230000 + STKNR = [ 2:10]#, % [45:10] STACK NR FIELD (IN IRW,MSCW) 01231000 + SBIT = [ 3: 1]#, % [44: 1] SEGMENTED BIT (DATADESC) 01232000 + FLTFF = [ 3: 1]#, % [44: 1] FLOAT FLIP/FLOP 01232500 + EXPF = [ 3: 6]#, % [44: 6] EXPONENT FIELD 01233000 + SEXPF = [2:7]#, % [45:7] SIGNED EXPONENT FIELD 01234000 + RBIT = [ 4: 1]#, % [43: 1] READ-ONLY-DATA BIT 01235000 + SZ = [ 5: 3]#, % [42:3] CHARACTER SIZE FIELD 01236000 + CHRSZ = [ 5: 2]#, % [42:2] CHARACTER SIZE IN DATA DESC. 01237000 + CHARF = [ 8: 4]#, % [39: 4] CHARACTER NUMBER FIELD 01238000 + DBIT = [ 7: 1]#, % [40: 1] DOUBLE PRECISION BIT (IN DATADESC01239000 + SIBF = [ 7: 6]#, % [40: 6] SIB FOR STRING DESCRIPTORS 01240000 + INDEX = [ 8:20]#, % [39:20] INDEX/LENGTH FIELD 01241000 + LENGTH = [ 8:20]#, % [39:20] INDEX/LENGTH FIELD 01242000 + DS = [8:20]#, % [39:20] DISPLACEMENT FIELD IN TOS CW 01243000 + PSRF = [12: 3]#, % [35: 3] PSR FIELD (IN PCW, RCW) 01244000 + MANF = [ 9:39]#, % [38:39] MANTISSA FIELD 01245000 + PIRF = [15:13]#, % [32:13] PIR FIELD (IN PCW, RCW) 01246000 + DISP = [12:16]#, % [35:16] BASE-OF-STACK-RELATIVE DISPLACMNT01247000 + SIRF = [12:16]#, % [35:16] INDEX FIELD FOR STRING DESCRIPTORS01248000 + FVF = [12:16]#, % [35:16] FINAL VALUE FIELD (IN SIW) 01248500 + VBIT = [28: 1]#, % [19: 1] ACC. ENTRY ON VALC OR EVAL 01249000 + NBIT = [28: 1]#, % [19: 1] NORMAL/CONTROL STATE BIT 01250000 + NCSFF = [28:1]#, % [19:1] NCSF FIELD IN TOS CONTROL WORD 01251000 + ADDR = [28:20]#, % [19:20] MEMORY ADDRESS/DISK ADDRESS FIELD01252000 + LLF = [29: 5]#, % [18: 5] LL FIELD 01253000 + CVF = [32:16]#, % [15:16] CURRENT VALUE FIELD (IN SIW) 01253500 + ADRCPL = [34:14]#, % [13:14] ADDRESS COUPLE FIELD (11,DELTA) 01254000 + ADRCPLSIR = [35:13]#, % [12:13] ADDRESS COUPLE STUFFED IRW(DEL) 01255000 + DF = [34:14]#, % [13:14] SELF-RELATIVE INDEX 01256000 + % TO PREVIOUS MSCW (LODELTAF) 01257000 + LEVELPCW = [34:1]#,%[13:1] ONE BIT LEVEL ADDRESS PCW 01258000 + DELTAPCW = [35:13]#,%[12:13] DELTA ADDRESS PCW 01259000 + SDIF = [34:14]#; % [13:14] SEGMENT DICTIONARY INDEX FIELD 01260000 +DEFINE 01261000 + SBRF = ADDR#, 01262000 + DBRF = ADDR#, 01263000 + DIRF = SIRF#, TIRF = SIRF#, 01264000 + DIBF = SIBF#, 01265000 + DSZF = SZ #; 01266000 +DEFINE % FUNCTION CODE DEFINES 6.33 01267000 + MPXAB = [47: 1]#, % [ 0: 1] RESPONDING MULTIPLEXOR(S) 01268000 + MPXFC = [43: 4]#, % [ 4: 4] MPX DESIGNATOR 01269000 + VARIF = [39: 4]#, % [ 8: 4] SCAN VARIANT 01270000 + GCARF = [37: 2]#, % [10: 2] GCA REGISTER 01271000 + REGIV = [39: 1]#, % [ 9: 1] READ REGISTER VARIANT 01272000 + VECTF = [36: 2]#, % [11: 2] VECTOR NUMBER 01273000 + LUNIT = [31: 8]#; % [16: 8] LOGICAL UNIT NUMBER 01274000 +DEFINE % RESULT ERROR DEFINES 01275000 + RSLTPRO= [31: 1]#, % [16: 1] PROTECT TERMINATE ON MEMORY WRITE 01276000 + RSLTEXC= [47: 1]#, % [ 0: 1] EXCEPTION 01277000 + RSLTATT= [46: 1]#, % [ 1: 1] ATTENTION 01278000 + RSLTBSY= [45: 1]#, % [ 2: 1] BUSY 01279000 + RSLTNRY= [44: 1]#, % [ 3: 1] NOT READY 01280000 + RSLTDSC= [43: 1]#, % [ 4: 1] DESCRIPTOR ERROR 01281000 + RSLTMAD= [42: 1]#, % [ 5: 1] MEMORY ADDRESS 01282000 + RSLTPAR= [41: 1]#; % [ 6: 1] MEMORY PARITY 01283000 +DEFINE % RESULT DESCRIPTOR UNIT ERRORS 01284000 + RSLTTO = [32: 1]#, % [15: 1] BLANK TAPE 01285000 + RSLTRW = [33: 1]#, % [14: 1] REWINDING 01286000 + RSLTOP = [34: 1]#, % [13: 1] NON-PRESENT 01287000 + RSLTCR = [35: 1]#, % [12: 1] CRC CORRECTION 01288000 + RSLTOF = [36: 1]#, % [11: 1] OVERFLOW 01289000 + RSLTCC = [37: 1]#, % [10: 1] CONTROL CARD 01290000 + RSLTVY = [38: 1]#, % [ 9: 1] VALIDITY 01291000 + RSLTET = [39: 1]#, % [ 8: 1] END OF TAPE 01292000 + RSLTMA = [40: 1]#, % [ 7: 1] MEMORY ACCESS 01293000 + RSLTUF = RSLTCC#,% UNDERFLOW 01294000 + RSLTWL = RSLTVY#;% WRITE LOCK-OUT 01295000 +DEFINE % I/O CONTROL WORD DEFINES 01296000 + IOABIT = [ 2: 1]#, % [45: 1] ATTENTION 01297000 + IOWBIT = [ 3: 1]#, % [44: 1] MEMORY WRITE 01298000 + IOIBIT = [ 4: 1]#, % [43: 1] MEMORY INHIBIT 01299000 + IOXBIT = [ 5: 1]#, % [42: 1] TRANSLATE 01300000 + IOSBIT = [ 6: 1]#, % [41: 1] FRAME LENGTH (0 = 6 BIT;1= 8 BIT)01301000 + IOPBIT = [ 7: 1]#, % [40: 1] MEMORY PROTECT 01302000 + IOBBIT = [ 8: 1]#, % [39: 1] BACKWARD TRANSFER 01303000 + IOTBIT = [ 9: 1]#, % [38: 1] 01304000 + IOTAGS = [10: 2]#, % [37: 1] & [36:1] TAG TRANSFER 01305000 + IOSKIP = [12: 4]#, % [35: 4] PRINTER SKIP 01306000 + IOSPAC = [16: 2]#; % [31: 2] PRINTER SPACE 01307000 +DEFINE RECS = [24:10]#; % [23:10] TAPE SPACE 01308000 +SAVE ARRAY MESS [0:BUFRMAX-1];%UTILITY INPUT-OUTPUT AREA 01309000 +COMMENT BUFFERS IS INDEXED BY SWITCH FILE INDEX AND HARDWARE TYPE; 01310000 +FILE DISKA DISK RANDOM [20:1000] (1, BUFFERS [0, 1],SAVE 99), 01311000 + DISKB DISK RANDOM [20:1000] (1, BUFFERS [1, 1],SAVE 99), 01312000 + DISKC DISK RANDOM [20:1000] (1, BUFFERS [2, 1],SAVE 99), 01313000 + DISKD DISK RANDOM [20:1000] (1, BUFFERS [3, 1],SAVE 99), 01314000 + SPO 14 (1, BUFFERS [0, 2]), 01315000 + AIDS 14 (1, BUFFERS [0, 3]), 01316000 + LP 4 (1, BUFFERS [0, 6]), 01317000 + SIMLP 14 (1, BUFFERS [1, 6]), 01318000 + CARD (1, BUFFERS [0, 9]), 01319000 + PUNCH 0 (1, BUFFERS [0,10]), 01320000 + TAPEA 2 (1, BUFFERS [0,13], SAVE 1), 01320000 + TAPEB 2 (1, BUFFERS [1,13], SAVE 1), 01321000 + TAPEC 2 (1, BUFFERS [2,13], SAVE 1), 01322000 + TAPED 2 (1, BUFFERS [3,13], SAVE 1); 01323000 +SWITCH FILE TAPES ~ TAPEA, TAPEB, TAPEC, TAPED; 01324000 +SWITCH FILE DISKS ~ DISKA, DISKB, DISKC, DISKD; 01325000 +SWITCH FILE LINES ~ LP, SIMLP; 01326000 + COMMENT 01327000 + ******************************* 01328000 + ***** B6500 WORD FORMAT ***** 01329000 + ******************************* 01330000 + SEGMENT DESCRIPTOR 01331000 + 5 5 4 4 4 4 4 4 4 4 3 2 1 01332000 + 1 0 8 7 6 5 4 3 2 0 9 0 9 0 01333000 + -------------------------------------------------------------- 01334000 + :X:011:P:C: UNUSED : LENGTH : ADDR : 01336000 + -------------------------------------------------------------- 01337000 + INDIRECT REFERENCE WORD (NORMAL) 01338000 + 5 5 4 4 4 4 1 1 01339000 + 1 0 8 7 6 5 4 3 0 01340000 + -------------------------------------------------------------- 01341000 + :X:001:U:0: . . . . . .UNUSED. . . . . . . . :ADDRESSCOUPLE : 01342000 + -------------------------------------------------------------- 01343000 + INDIRECT REFERENCE WORD (STUFFED) 01343100 + 5 5 4 4 4 4 3 3 2 1 1 1 . 01343200 + 1 0 8 7 6 5 6 5 0 9 3 2 0 01343300 + -------------------------------------------------------------- 01343400 + :X:001:U:1: STKNR : DISP :UNUSED :INDEX FIELD : 01343500 + -------------------------------------------------------------- 01343600 + MARK STACK CONTROL WORD 01344000 + 5 5 4 4 4 4 3 3 2 1 1 1 1 01345000 + 1 0 8 7 6 5 6 5 0 9 8 4 3 0 01346000 + -------------------------------------------------------------- 01347000 + :X:011:DS:E: STKNR : DISP :V:LLF: DF : 01348000 + -------------------------------------------------------------- 01349000 + PROGRAM CONTROL WORD 01350000 + 5 5 4 4 4 4 3 3 3 3 2 1 1 1 1 01351000 + 1 0 8 7 6 5 6 5 3 2 0 9 8 4 3 0 01352000 + -------------------------------------------------------------- 01353000 + :X:111:UU : STKNR : PSRF : PIRF :N:LLF: SDIF : 01354000 + -------------------------------------------------------------- 01355000 + RETURN CONTROL WORD 01356000 + 5 5 4 4 4 4 4 4 3 3 3 3 2 1 1 1 1 01357000 + 1 0 8 7 6 5 4 3 6 5 3 2 0 9 8 4 3 0 01358000 + -------------------------------------------------------------- 01359000 + :X:011:X:O:T:F: UNUSED : PSRF : PIRF :N:LLF: SDIF : 01360000 + -------------------------------------------------------------- 01361000 + SINGLE PRECISION OPERAND 01362000 + 5 5 4 4 4 4 4 3 3 01363000 + 1 0 8 7 6 5 4 9 8 01364000 + -------------------------------------------------------------- 01365000 + :X:000:U:SO:SE: EXPF : MANF : 01366000 + -------------------------------------------------------------- 01367000 + DOUBLE PRECISION OPERAND 01368000 + 5 5 4 4 4 4 4 3 3 (FIRST HALF) 01369000 + 1 0 8 7 6 5 4 9 8 0 01370000 + -------------------------------------------------------------- 01371000 + :X:010:U:SO:SE: EXPX : MANF : 01372000 + -------------------------------------------------------------- 01373000 + 5 5 4 4 3 3 (SECOND HALF) 01374000 + 1 0 8 7 9 8 0 01375000 + -------------------------------------------------------------- 01376000 + :X:010: EXPD EXT. : MANF : 01377000 + -------------------------------------------------------------- 01378000 + WORD DATA DESCRIPTOR 01379000 + 5 5 4 4 4 4 4 4 44 4 3 2 1 01380000 + 1 0 8 7 6 5 4 3 21 0 9 0 9 0 01381000 + -------------------------------------------------------------- 01382000 + :X:101:P:C:I:S:R:SZ:D: LENGTH/INDEX : ADDR : 01383000 + -------------------------------------------------------------- 01384000 + STRING DESCRIPTOR (NON-INDEXED) 01385000 + 5 5 4 4 4 4 4 4 44 4 3 2 1 01386000 + 1 0 8 7 6 5 4 3 21 0 9 0 9 0 01387000 + -------------------------------------------------------------- 01388000 + :X:101:P:C:O:S:R: SZ : LENGTH IN CHR : ADDR : 01389000 + -------------------------------------------------------------- 01389000 + STRING DESCRIPTOR (INDEXED) 01391000 + 5 5 4 4 4 4 4 4 44 4 3 3 2 1 01392000 + 1 0 8 7 6 5 4 3 21 0 5 4 0 9 0 01393000 + -------------------------------------------------------------- 01394000 + :X:101:P:C:1:S:R: SZ :BYTE INX:WORD INDEX: ADDR : 01395000 + -------------------------------------------------------------- 01396000 + STEP INDEX WORD 01397000 + 5 5 4 4 3 3 2 1 1 1 01398000 + 1 0 8 7 6 5 0 9 6 5 0 01399000 + -------------------------------------------------------------- 01400000 + :X:100: INCREMENT : FINAL VALUE : U :CURRENT VALUE : 01401000 + -------------------------------------------------------------- 01402000 +; 01403000 + %******************************************** 01600000 + %***** FORWARD PROCEDURE DECLARATIONS ***** 01601000 + %******************************************** 01602000 +%%%%% BEGIN OPERATOR FORWARDS %%%%%%%%%% 01603000 +DEFINE V = PROCEDURE#, W = ; FORWARD;#; 01604000 +V MKST W V IMKS W V NAMC W V VALC W V EVAL W V ENTR W V EXIT W V RETN W 01605000 +V IRWL W V PCWL W V BRUN W V BRTR W V BRFL W V DBUN W V DBTR W V DBFL W 01606000 +V NOOP W V HALT W V NVLD W V VARI W V ADD W V SUBT W V MULT W V MULX W 01607000 +V DIVD W V IDIV W V RDIV W V NTIA W V NTGR W V SNGT W V SNGL W V XTND W 01608000 +V JOIN W V SPLT W V LAND W V LOR W V LNOT W V SAME W V LEQV W V GRTR W 01609000 +V GREQ W V EQUL W V LSEQ W V LESS W V NEQL W V INDX W V STBR W V NXLN W 01610000 +V NXLV W V LOAD W V LODT W V EXCH W V RSDN W V RSUP W V DUPL W V DLET W 01611000 +V MVST W V PUSH W V STOD W V STON W V OVRD W V OVRN W V FLTR W V DFTR W 01612000 +V ISOL W V DISO W V INSR W V DINS W V SRCH W V LLLU W V ZERO W V ONE W 01613000 +V LT8 W V LT16 W V LT48 W V MPCW W V BSET W V DBST W V BRST W V DBRS W 01614000 +V CHSN W V CBON W V LOG2 W V STAG W V RTAG W V SINT W V RDLK W V STFF W 01615000 +V WHOI W V EEXI W V DEXI W V IDLE W V HEYU W V RPRR W V SPRR W V SCNI W 01616000 +V SCNO W V TWSD W V TWSU W V TWOD W V TWOU W V TGTD W V TGTU W V TGED W 01617000 +V TGEU W V TEQD W V TEQU W V TLED W V TLEU W V TLSD W V TLSU W V TNED W 01618000 +V TNEU W V TWTD W V TWTU W V TWFD W V TWFU W V TUND W V TUNU W V SGTD W 01619000 +V SGTU W V SGED W V SGEU W V SEQD W V SEQU W V SLED W V SLEU W V SLSD W 01620000 +V SLSU W V SNED W V SNEU W V SWTD W V SWTU W V SWFD W V SWFU W V CGTD W 01621000 +V CGTU W V CGED W V CGEU W V CEQD W V CEQU W V CLED W V CLEU W V CLSD W 01622000 +V CLSU W V CNED W V CNEU W V UABD W V UABU W V USND W V USNU W V PACD W 01623000 +V PACU W V TRNS W V SCLF W V DSLF W V SCRS W V DSRS W V SCRT W V DSRT W 01624000 +V SCRR W V DSRR W V SCRF W V DSRF W V OCRX W V SISO W V SXSN W V RTFF W 01625000 +V ROFF W V ICVD W V ICVU W V TEED W V TEEU W V EXSD W V EXSU W V EXPU W 01626000 +V MCHR W V MVNU W V SFSC W V SRSC W V SFDC W V SRDC W V INSU W V INSC W 01627000 +V INSG W V INOP W V RSTF W V ENDF W V MINS W V MFLT W V ENDE W 01628000 +%%%%% END OPERATOR FORWARDS %%%%%%%%%% 01629000 +DEFINE CHECOP=( (AX.TAG=SINGL OR AX.TAG=DOUBL ) 01700000 + AND(BX.TAG=SINGL OR BX.TAG=DOUBL))#, 01701000 +CHECOPRNDB=IF NOT (BX.TAG=SINGL OR BX.TAG=DOUBL) 01702000 + THEN BEGIN SETINTERRUPT (INVOP)#, 01703000 +CHECOPRNDA=IF NOT (AX.TAG=SINGL OR AX.TAG=DOUBL) 01704000 + THEN BEGIN SETINTERRUPT(INVOP)#; 01705000 +DEFINE PRESENCEBITINTERRUPT= 01706000 + BEGIN SETINTERRUPT(PRESBIT); GO TO OC END#, 01707000 + INVALIDINDEXINTERRUPT= 01708000 + BEGIN SETINTERRUPT(INVINXI); GO TO OC END#, 01709000 + INVALIDOPERATORINTERRUPT= 01710000 + BEGIN SETINTERRUPT(INVOP); GO TO OC END#; 01711000 +PROCEDURE ADJ(NEWAROF,NEWBROF); VALUE NEWAROF,NEWBROF; 01712000 + INTEGER NEWAROF,NEWBROF; FORWARD; 01713000 +STREAM PROCEDURE MOVE(SOURCE,DESTINATION); 01714000 + BEGIN SI~SOURCE; DI~DESTINATION; DS~2 WDS; END MOVE; 01715000 +PROCEDURE ERROR(ERRNUM); VALUE ERRNUM; REAL ERRNUM; FORWARD; 01716000 +BOOLEAN PROCEDURE EQUAL (A,AX,B,BX); VALUE A,AX,B,BX; REAL A,AX,B,BX; 01717000 + EQUAL ~ (AX.[44:4] = BX.[44:4]) AND 01718000 + (REAL(BOOLEAN(A) EQV BOOLEAN (B)) = REAL (NOT FALSE)); 01719000 +STREAM PROCEDURE DYALS (P, A, N, N1, TURN); VALUE N, N1, TURN; 01720000 + BEGIN 01721000 + DI ~ P; SI ~ P; SI ~ SI + 15; 01722000 + SKIP 5 SB; IF SB THEN DS ~ SET ELSE DS ~ RESET; 01723000 + SI ~ A; SI ~ SI + 15; SKIP 5 SB; 01724000 + DI ~ A; IF SB THEN DS ~ SET ELSE DS ~ RESET; 01725000 + SI ~ P; DI ~ A; SKIP N SB; SKIP N1 DB; TURN BITS; 01726000 + DI ~ A; DI ~ DI + 15; SKIP 5 DB; 01727000 + SI ~ A; IF SB THEN DS ~ SET ELSE DS ~ RESET; 01728000 + DI ~ P; DS ~ RESET; 01729000 + DI ~ A; DS ~ RESET; 01730000 + END OF DYAL; 01731000 +PROCEDURE DYAL (P, A, N, N1, TURN); VALUE N, N1, TURN; 01732000 + REAL P, A; 01733000 + INTEGER N, N1, TURN; 01734000 + BEGIN 01735000 + INTEGER NN, NN1; 01736000 + NN ~ 47-N; 01737000 + NN1 ~ 47-N1; 01738000 + DYALS (P, A, NN, NN1, TURN); 01739000 + END; 01740000 +DEFINE SYLLABLE = (IF PROF THEN SYLLABLES[PSR] ELSE PSYLLABLES)#; 01741000 +INTEGER ARRAY SYLLABLES[0:5]; 01742000 +INTEGER PROCEDURE PSYLLABLES; FORWARD; % RETURNS P[PSR] 01743000 +PROCEDURE STEPPSR(N); VALUE N; INTEGER N; FORWARD; % STEPS PSR+PIR,PROF 01744000 +PROCEDURE TRACE; FORWARD; 01745000 +PROCEDURE MEMDUMP; FORWARD; 01746000 +PROCEDURE SETINTERRUPT(I); VALUE I; INTEGER I; FORWARD; 01747000 +INTEGER PROCEDURE LEVEL(WORD); VALUE WORD; REAL WORD; FORWARD; 01748000 +INTEGER PROCEDURE DELTA(WORD); VALUE WORD; REAL WORD; FORWARD; 01749000 +PROCEDURE ERVSFLOW(OP); VALUE OP; INTEGER OP; FORWARD; 01750000 +BOOLEAN PROCEDURE INTEGERIZE(ROUND,REG);VALUE ROUND; 01751000 + BOOLEAN ROUND; REAL REG; FORWARD; 01752000 +REAL PROCEDURE GETRESULT (MPXAB); VALUE MPXAB; REAL MPXAB; FORWARD; 01753000 +PROCEDURE STORE(OP); VALUE OP; REAL OP; FORWARD; 01754000 +PROCEDURE WRITETIME; FORWARD; % WRITES OUT TIME SINCE INITIALIZATION 01755000 +PROCEDURE HEADINGLINE (LP); FILE LP; FORWARD; 01756000 +PROCEDURE INTFAMD(TYPE); VALUE TYPE; REAL TYPE; 01757000 + BEGIN 01757100 + LABEL INVALIDOP1 , INVALIDOP2 , INVALIDOP3 , INVALIDOP4 , 01757200 + INVALIDOP5 , MEMPROT , 01757300 + INVINDX2 , PRESBIT1 , PRESBIT2 01757400 + ,OC , LO , BACKUP , L2 01757500 + ; 01757600 + SWITCH INTERRUPT ~ 01757700 + INVALIDOP1 , INVALIDOP2 , INVALIDOP3 , INVALIDOP4 , 01757701 + INVALIDOP5 , MEMPROT , 01757702 + INVINDX2 , PRESBIT1 , PRESBIT2 01757703 + ; 01757704 + GO TO INTERRUPT[TYPE]; 01757800 + INVALIDOP1: ADJ(0,0); GO LO; 01757900 + INVALIDOP2: ADJ(0,0); MOVE(C,A); GO LO; 01758000 + INVALIDOP3: MOVE(B,A); GO LO; 01758100 + INVALIDOP4: AROF ~ TRUE; MOVE(B,A); ADJ(1,0); GO LO; 01758200 + INVALIDOP5: ADJ(0,0); MOVE(B,A); 01758300 + LO: BX ~ 0; 01758400 + AROF ~ BROF ~ TRUE; SDIS ~ 1; 01758500 + B ~ INVOP ; 01758600 + BACKUP: 01758700 + PIR ~ PIR - PICR; PSR ~ OPSR; GO OC; 01758800 + MEMPROT: 01758900 + ADJ(0,0); 01759000 + MOVE(C,A); 01759100 + BX ~ 0; 01759200 + AROF~BROF~TRUE; SDIS ~ 1; 01759300 + B ~ MEMPROI; 01759400 + GO BACKUP; 01759500 + INVINDX2: 01759600 + ADJ(0,0); 01759700 + BX ~ A ~ AX ~ 0; 01759800 + AROF~BROF~TRUE; SDIS ~ 1; 01759900 + B ~ INVINXI; 01760000 + GO BACKUP; 01760100 + PRESBIT1: 01760200 + AROF~FALSE; 01760250 + ADJ(0,0); 01760300 + MOVE(C,A); 01760500 + GO L2; 01760600 + PRESBIT2: 01760700 + MOVE(X,A); 01760800 + AROF ~ TRUE; 01760900 + ADJ(0,0); 01761000 + MOVE(C,A); 01761200 + AROF ~ TRUE; 01761300 + ADJ(0,0); 01761400 + L2: 01761500 + BX ~ 0; 01761600 + AROF~BROF~TRUE; SDIS ~ 1; 01761700 + B ~ PRESBIT; 01761800 + B.SOBIT ~ 1; 01761900 + GO BACKUP; 01762000 + OC: 01762100 + END; 01762200 + 01762300 +PROCEDURE INTFAMA(TYPE); VALUE TYPE; REAL TYPE; 01765000 + BEGIN 01765100 + DEFINE CLEARAB = A~AX~B~BX ~ 0#; 01765200 + IF TYPE < 0 THEN 01765300 + BEGIN 01765400 + ADJ(0,0); 01765500 + CLEARAB; 01765600 + B ~ INVOP; 01765700 + 01765800 + END ELSE 01765900 + BEGIN 01766000 + CLEARAB; 01766100 + B ~ ABS(TYPE); 01766200 + END; 01766300 + AROF ~ BROF ~ TRUE; 01766400 + SDIS ~ 1; 01766500 + PIR ~ PIR - PICR; PSR ~ OPSR; 01766600 + END INTFAMD; 01766700 +PROCEDURE INTFAMB(TYPE); VALUE TYPE; REAL TYPE; 01767000 + BEGIN 01767100 + 01767200 + IF TYPE=2 THEN 01767300 + BEGIN 01767400 + ADJ(0,0); MOVE(C,A); 01767500 + END ELSE 01767600 + MOVE(B,A); 01767700 + B ~ BX ~ 0; 01767800 + SDIS ~ 1; 01767900 + BROF ~ AROF ~ TRUE; 01768000 + B ~ INVOP; 01768100 + PIR ~ PIR - PICR; PSR ~ OPSR; 01768200 + END INFAMB; 01768300 +PROCEDURE INTERRUPTCONTROLLER; 01800000 + IF BOOLEAN (PTPI) THEN INT ~ 0 ELSE % IGNORE PROC TO PROC IN SIM01800100 + BEGIN COMMENT INTERRUPT CONTROLLER IS PRIMARILY CONCERNED WITH01801000 + MAKING THE STACK LOOK LIKE A PROCEDURE IS TO BE 01802000 + CALLED AND THEN CALLING IT. MUCH OF THE CURRENT CODE01803000 + IS CONCERNED WITH INFORMING PEOPLE AS TO WHAT IS 01804000 + HAPPENING. 01805000 + 9/12/67; 01806000 + REAL TEMPB, SWFI; 01807000 + DEFINE 01808000 + BASSDI = 0#, 01809000 + BASEXI = 10#, 01810000 + BASGCI = 12#, 01811000 + BASALI = 14#; 01812000 + SWITCH FORMAT INTS 01813000 + ~(10 ("X"), " INTERRUPT ERROR." ,X2,10("X"))01814000 + ,(10 ("X"), " MEMORY PROTECT INTERRUPT." ,X2,10("X"))01815000 + ,(10 ("X"), " INVALID OPERATOR INTERRUPT." ,X2,10("X"))01816000 + ,(10 ("X"), " DIVIDE BY ZERO INTERRUPT." ,X2,10("X"))01817000 + ,(10 ("X"), " EXPONENT OVERFLOW INTERRUPT." ,X2,10("X"))01818000 + ,(10 ("X"), " EXPONENT UNDERFLOW INTERRUPT." ,X2,10("X"))01819000 + ,(10 ("X"), " INVALID INDEX INTERRUPT." ,X2,10("X"))01820000 + ,(10 ("X"), " INTEGER OVERFLOW INTERRUPT." ,X2,10("X"))01821000 + ,(10 ("X"), " BOTTOM OF STACK INTERRUPT." ,X2,10("X"))01822000 + ,(10 ("X"), " PRESENCE BIT INTERRUPT." ,X2,10("X"))01823000 + ,(10 ("X"), " SEQUENCE ERROR INTERRUPT," ,X2,10("X"))01824000 + ,(10 ("X"), " MULTIPLEXOR A INTERRUPT." ,X2,10("X"))01825000 + ,(10 ("X"), " MULTIPLEXOR B INTERRUPT." ,X2,10("X"))01826000 + ,(10 ("X"), " INTERVAL TIMER INTERRURT." ,X2,10("X"))01827000 + ,(10 ("X"), " STACK OVERFLOW INTERRUPT." ,X2,10("X"))01828000 + ,(10 ("X"), " OPERATOR LOOP INTERRUPT." ,X2,10("X"))01829000 + ,(10 ("X"), " MEMORY PARITY INTERRUPT." ,X2,10("X"))01830000 + ,(10 ("X"), " MULTIPLEXOR PARITY INTERRUPT." ,X2,10("X"))01831000 + ,(10 ("X"), " INVALID ADDRESS INTERRUPT." ,X2,10("X"))01832000 + ,(10 ("X"), " STACK UNDERFLOW INTERRUPT." ,X2,10("X"))01833000 + ; 01834000 + IF SDIS ! 0 01835000 + THEN BEGIN 01836000 + TEMPB ~ B; 01837000 + ADJ (0, 0); 01838000 + AX ~ 0; 01839000 + AROF ~ TRUE; 01840000 + A ~ 0 & TEMPB [33:33:15]; 01841000 + LOG2; 01842000 + SWFI ~ B; 01843000 + BROF ~ FALSE; 01844000 + ADJ (1, 1); 01845000 + MOVE (M[D[0] +3], C); 01846000 + IF CX.TAG ! PCW 01847000 + THEN BEGIN 01848000 + WRITE(LP [DBL], INTS [SWFI]); 01849000 + MEMDUMP; 01850000 + GO EOJ; 01851000 + END; 01852000 + END 01853000 + ELSE IF EXIA ! 0 01854000 + THEN BEGIN 01855000 + SWFI ~ BASEXI + B - EXTINTI; 01856000 + IF SWFI > BASGCI THEN SWFI ~ BASEXI + 1; 01856100 + END 01857000 + ELSE IF GCIF ! 0 01858000 + THEN BEGIN 01859000 + SWFI ~ B - INTTIMI + BASGCI + 1; 01860000 + INTTIMER ~ 2*36 ; 01861000 + END 01862000 + ELSE IF INT.[43:5] ! 0 01863000 + %LOOP + MPEI + MPXP + INVA + SUFL !0 01864000 + THEN BEGIN 01865000 + TEMPB ~ B; 01866000 + ADJ (0, 0); 01866100 + A ~ B - LOOPI + 1; AX ~ 0; 01866200 + AROF ~ TRUE; 01866300 + LOG2; 01866400 + SWFI ~ B + BASALI; 01866450 + BROF ~ FALSE; 01866600 + ADJ (1, 1); 01866700 + END 01867000 + ELSE ERROR (101); 01868000 + IMKS; 01869000 + ADJ (0, 1); 01870000 + A ~ 3; 01871000 + AX.TAG ~ IRW; 01872000 + AROF ~ TRUE; 01873000 + RSDN; 01874000 + ENTR; 01875000 + INT ~ 0; 01876000 + IF NOT (TRACEWORD = 0 OR (TRACEWORD } 100 AND TRACTER = 0)) 01877000 + THEN BEGIN 01878000 + WRITE (LP, INTS [SWFI MOD 20]); 01879000 + END; 01880000 + END INTERRUPT CONTROLLER; 01881000 +PROCEDURE TIMING (OP); 01882000 + VALUE OP; 01883000 + INTEGER OP; 01884000 + BEGIN 01885000 + DELTATIME ~ DELTATIME + OP.[41:6]; %%%%%%%%%%% 01886000 + REALTIME ~ REALTIME + DELTATIME; 01887000 + TIMEOFDAY ~ TIMEOFDAY + DELTATIME; 01887100 + DELTATIME ~ 0; 01888000 + END; 01889000 +PROCEDURE CONTROLSECTION; 02000000 + BEGIN 02001000 +DEFINE VARIANTESCAPE = 149#, 02002000 + SINGLESHOTESCAPED = 210#, 02003000 + TRACESCAPE = 202#, 02004000 + SINGLESHOTESCAPEU = 218#; 02005000 +DEFINE XXXX = NVLD#; 02006000 +DEFINE PRIMARYMODETABLE = 02007000 +BEGIN 02008000 + VALC; VALC; VALC; VALC; VALC; VALC; VALC; VALC; 02009000 + VALC; VALC; VALC; VALC; VALC; VALC; VALC; VALC; 02010000 + VALC; VALC; VALC; VALC; VALC; VALC; VALC; VALC; 02011000 + VALC; VALC; VALC; VALC; VALC; VALC; VALC; VALC; 02012000 + VALC; VALC; VALC; VALC; VALC; VALC; VALC; VALC; 02013000 + VALC; VALC; VALC; VALC; VALC; VALC; VALC; VALC; 02014000 + VALC; VALC; VALC; VALC; VALC; VALC; VALC; VALC; 02015000 + VALC; VALC; VALC; VALC; VALC; VALC; VALC; VALC; 02016000 + NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; 02017000 + NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; 02018000 + NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; 02019000 + NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; 02020000 + NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; 02021000 + NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; 02022000 + NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; 02023000 + NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; 02024000 + ADD ; SUBT; MULT; DIVD; IDIV; RDIV; NTIA; NTGR; 02025000 + LESS; GREQ; GRTR; LSEQ; EQUL; NEQL; CHSN; MULX; 02026000 + LAND; LOR ; LNOT; LEQV; SAME; VARI; BSET; DBST; 02027000 + FLTR; DFTR; ISOL; DISO; INSR; DINS; BRST; DBRS; 02028000 + BRFL; BRTR; BRUN; EXIT; STBR; NXLN; INDX; RETN; 02029000 + DBFL; DBTR; DBUN; ENTR; EVAL; NXLV; MKST; STFF; 02030000 + ZERO; ONE ; LT8 ; LT16; PUSH; DLET; EXCH; DUPL; 02031000 + STOD; STON; OVRD; OVRN; XXXX; LOAD; LT48; MPCW; 02032000 + SCLF; DSLF; SCRT; DSRT; SCRS; DSRS; SCRF; DSRF; 02033000 + SCRR; DSRR; ICVD; ICVU; SNGT; SNGL; XTND; IMKS; 02034000 + TEED; PACD; EXSD; TWSD; TWOD; SISO; SXSN; ROFF; 02035000 + TEEU; PACU; EXSU; TWSU; TWOU; EXPU; RTFF; HALT; 02036000 + TLSD; TGED; TGTD; TLED; TEQD; TNED; TUND; XXXX; 02037000 + TLSU; TGEU; TGTU; TLEU; TEQU; TNEU; TUNU; XXXX; 02038000 + CLSD; CGED; CGTD; CLED; CEQD; CNED; XXXX; XXXX; 02039000 + CLSU; CGEU; CGTU; CLEU; CEQU; CNEU; NOOP; NVLD; 02040000 +END#; % OF PRIMARYMODETABLE 02041000 +DEFINE VARIANTMODETABLE = 02042000 +BEGIN 02043000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02044000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02045000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02046000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02047000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02048000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02049000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02050000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02051000 + XXXX; XXXX; JOIN; SPLT; IDLE; SINT; EEXI; DEXI; 02052000 + XXXX; XXXX; SCNI; SCNO; XXXX; XXXX; WHOI; HEYU; 02053000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02054000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02055000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02056000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02057000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02058000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02059000 + XXXX; XXXX; XXXX; XXXX; XXXX; OCRX; XXXX; XXXX; 02060000 + XXXX; XXXX; XXXX; LOG2; XXXX; XXXX; XXXX; XXXX; 02061000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02062000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02063000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02064000 + XXXX; XXXX; XXXX; XXXX; XXXX; IRWL; PCWL; MVST; 02065000 + XXXX; XXXX; XXXX; XXXX; STAG; RTAG; RSUP; RSDN; 02066000 + RPRR; SPRR; RDLK; CBON; LODT; LLLU; SRCH; XXXX; 02067000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02068000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02069000 + USND; UABD; TWFD; TWTD; SWFD; SWTD; XXXX; TRNS; 02070000 + USNU; UABU; TWFU; TWTU; SWFU; SWTU; XXXX; HALT; 02071000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02072000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02073000 + SLSD; SGED; SGTD; SLED; SEQD; SNED; XXXX; XXXX; 02074000 + SLSU; SGEU; SGTU; SLEU; SEQU; SNEU; NOOP; NVLD; 02075000 +END#; % OF VARIANTMODETABLE 02076000 +DEFINE EDITMODETABLE = 02077000 +BEGIN 02078000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02079000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02080000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02081000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02082000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02083000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02084000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02085000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02086000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02087000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02088000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02089000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02090000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02091000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02092000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02093000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02094000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02095000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02096000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02097000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02098000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02099000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02100000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02101000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02102000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02103000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02104000 + MINS; MFLT; SFSC; SRSC; RSTF; ENDF; MVNU; MCHR; 02105000 + INOP; INSG; SFDC; SRDC; INSU; INSC; ENDE; HALT; 02106000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02107000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02108000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02109000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; NOOP; NVLD; 02110000 +END#; % OF EDITMODETABLE 02111000 + LABEL PSC,ESCP; 02112000 +PSC: VARF~FALSE; 02113000 + Q ~ QP ~ N ~ 0; 02114000 + OPSR ~ PSR; 02116000 + PICR ~ 0; 02117000 + ESCP:IF (TS1~REAL(VARF)+REAL(LEEF)+REAL(TEEF)+REAL(SEEF))>1 THEN 02118000 + BEGIN ERROR(0); MEMDUMP; GO TO EOJ; 02119000 + END; 02120000 + T~SYLLABLE; 02121000 + IF TS1=0 THEN 02122000 + IF (VARF~(T=VARIANTESCAPE)) THEN 02123000 + BEGIN 02124000 + STEPPSR (1); 02125000 + GO TO ESCP; 02126000 + END 02127000 + ELSE IF T = TRACESCAPE THEN 02128000 + BEGIN STEPPSR(1); TRACTER ~ SYLLABLE; 02129000 + STEPPSR(1); GO TO PSC; 02130000 + END 02131000 + ELSE IF NOT BOOLEAN(T.[40:1]) THEN DRS.[42:6] ~ T; 02132000 + STEPPSR (1); 02133000 + IF TS1=0 THEN CASE T OF PRIMARYMODETABLE 02134000 + ELSE IF VARF THEN CASE T OF VARIANTMODETABLE 02135000 + ELSE CASE T OF EDITMODETABLE; 02136000 + IF STKOVFF THEN BEGIN SETINTERRUPT(STKOVFI); STKOVFF~FALSE END;02136100 + TIMING (T); 02137000 + END OF CONTROL SECTION; 02138000 +INTEGER PROCEDURE PSYLLABLES; 04000000 + BEGIN 04001000 + IF NOT PROF THEN 04002000 + BEGIN MOVE(M[PIR+PBR],P); MEMCYCLE; 04003000 + IF PX.TAG!CODE THEN SETINTERRUPT(INVOP); 04004000 + PROF:=TRUE; 04005000 + SYLLABLES[0] ~P.[ 1:7] & PX [40:47:1]; 04006000 + SYLLABLES[1] ~ P.[8:8]; 04007000 + SYLLABLES[2] ~ P.[16:8]; 04008000 + SYLLABLES[3] ~ P.[24:8]; 04009000 + SYLLABLES[4] ~ P.[32:8]; 04010000 + SYLLABLES[5] ~ P.[40:8]; 04011000 + END; 04012000 + PSYLLABLES ~ SYLLABLES[PSR]; 04013000 + END PSYLLABLES; 04014000 +PROCEDURE STEPPSR(N); VALUE N; INTEGER N; 04015000 + BEGIN 04016000 +LABEL L; 04017000 +INTEGER PICRT; 04018000 +L: IF (PSR ~ PSR + N) } 6 04019000 + THEN BEGIN 04020000 + PICRT ~ PSR DIV 6; 04021000 + PICR ~ PICR + PICRT; 04022000 + PIR ~ PIR + PICRT; 04023000 + PSR ~ PSR MOD 6; 04024000 + PROF ~ FALSE; 04025000 + END; 04026000 + IF PSR < 0 04027000 + THEN BEGIN 04028000 + PSR ~ PSR + ABS(N); 04029000 + DO PIR ~ PIR - 1 UNTIL N ~ N + 6 } 0; 04030000 + GO L; 04031000 + END; 04032000 + END STEPPSR; 04033000 +PROCEDURE SETINTERRUPT(I); VALUE I; INTEGER I; 04034000 + BEGIN 04035000 + ADJ (0, 0); % TEMPORARY NO FLOWS 04036000 + INT ~ B ~ I; 04037000 + BX ~ 0; 04038000 + BROF ~ TRUE; 04039000 + AROF ~ TRUE; 04040000 + END SETINTERRUPT; 04041000 +PROCEDURE NOTYETCODED; 04042000 + BEGIN 04043000 + FORMAT F (10("X")," OPERATOR NOT YET CODED ",84("X")); 04044000 + WRITETIME; 04045000 + HEADING; 04046000 + WRITE(LP,F); 04047000 + MEMDUMP; 04048000 + GO TO EOJ; 04049000 + END NOTYETCODED; 04050000 +PROCEDURE WRITETIME; 04051000 + BEGIN 04052000 + REAL E,P; 04053000 + FORMAT TIMES (10("-")," B5500 TIME SINCE START OF RUN: ", 04054000 + "PROCESSOR TIME =",F9.3," SECONDS, ", 04055000 + "ELAPSED TIME =",F9.3," SECONDS "8("-")); 04056000 + E~(TIME(1)-ETIME)/60; P~(TIME(2)-PTIME)/60; 04057000 + HEADING; 04058000 + WRITE(LP,TIMES,P,E); 04059000 + END WRITETIME; 04060000 +PROCEDURE MKST ; % MARK STACK 07000000 + BEGIN 07001000 + ERVSFLOW (10); 07002000 + 07003000 + 07004000 + 07005000 + 07006000 + 07007000 + 07008000 + END MKST; 07009000 +PROCEDURE IMKS ; % INSERT MARK STACK * 07010000 + BEGIN 07011000 + % REVISED PER L. HANSON FLOWS 8/8/68 BY B.M.M. 07012000 + ADJ(1,1); 07013000 + MOVE(B,C); 07014000 + BX ~ 2|MSCW; 07015000 + B ~ S + 1 - F; 07016000 + F ~ S + 1; 07017000 + ADJ(1,0); 07018000 + MOVE(C,B); 07019000 + BROF~TRUE; 07020000 + END IMKS; 07021000 +PROCEDURE NAMC ; % NAME CALL 07022000 + BEGIN 07023000 + ADJ(0,2); 07024000 + C ~ SYLLABLE & DRS [34:42:6]; 07025000 + CX ~ 2|IRW; 07026000 + AROF:=TRUE; 07027000 + MOVE (C, A); 07028000 + STEPPSR(1); 07029000 + END NAMC; 07030000 +PROCEDURE VALC ; % VALUE CALL 07031000 + BEGIN 07032000 + ERVSFLOW(1); 07033000 + END VALC; 07034000 +PROCEDURE EVAL ; % EVALUATE DESCRIPTOR 07035000 + BEGIN 07036000 + ERVSFLOW(2); 07037000 + END EVAL; 07038000 +PROCEDURE ENTR ; % ENTER 07039000 + BEGIN 07040000 + ERVSFLOW(3); 07041000 + END ENTR; 07042000 +PROCEDURE EXIT ; % EXIT 07043000 + BEGIN 07044000 + ERVSFLOW(4); 07045000 + END EXIT; 07046000 +PROCEDURE RETN ; % RETURN 07047000 + BEGIN 07048000 + ERVSFLOW(5); 07049000 + END RETN; 07050000 +PROCEDURE IRWL ; % (HARDWARE PSEUDO-INSTRUCTION) 07051000 + BEGIN 07052000 + ERVSFLOW(19); 07053000 + END IRWL; 07054000 +PROCEDURE PCWL ; % (HARDWARE PSEUDO INSTRUCTION) 07055000 + BEGIN 07056000 + ERVSFLOW (20); 07057000 + END PCWL; 07058000 +PROCEDURE BRUN ; % BRANCH UNCONDITIONAL 07059000 + BEGIN 07060000 + ERVSFLOW(17); 07061000 + END BRUN; 07062000 +PROCEDURE BRTR ; % BRANCH TRUE 07063000 + BEGIN 07064000 + ERVSFLOW(15); 07065000 + END BRTR; 07066000 +PROCEDURE BRFL ; % BRANCH FALSE 07067000 + BEGIN 07068000 + ERVSFLOW(16); 07069000 + END BRFL; 07070000 +PROCEDURE PCWORD; % PROGRAM CONTROL WORD 07071000 + BEGIN 07072000 + LABEL OC; 07073000 + IF LL ! C.LLF 07074000 + THEN SETINTERRUPT (INVOP) 07075000 + ELSE BEGIN 07076000 + PDR ~ C.SDIF; 07077000 + PSR ~ C.PSRF; 07078000 + PIR ~ C.PIRF; 07079000 + MOVE (M[D[C.[34:1]] + C.[35:13]], C); 07080000 + MEMCYCLE; 07081000 + IF CX.TAG ! SEGDESC 07082000 + THEN BEGIN 07083000 + SETINTERRUPT (INVOP); 07084000 + GO OC; 07085000 + END 07086000 + ELSE IF CX.PBIT ! 1 07087000 + THEN BEGIN 07088000 + SETINTERRUPT (PRESBIT); 07089000 + GO OC; 07090000 + END 07091000 + ELSE BEGIN 07092000 + PBR ~ C.ADDR; 07093000 + PROF ~ AROF ~ FALSE; 07094000 + END; 07095000 + END; 07096000 +OC: END FETCH OF PROGRAM CONTROL WORD; 07097000 +PROCEDURE DYNAMICBRANCH; % UTILITY PROCEDURE FOR DYNAMIC BRANCHES 07098000 + BEGIN 07099000 + INTEGER TTAG; 07100000 + LABEL IRWORD; 07101000 + IF (TTAG ~ AX.TAG) = SINGL OR TTAG = DOUBL 07102000 + THEN BEGIN 07103000 + IF A < 0 OR A } 2*21 OR INTEGERIZE(TRUE, A) 07104000 + THEN SETINTERRUPT (INVOP) 07105000 + ELSE BEGIN 07106000 + PSR ~ IF BOOLEAN (A)THEN 3 ELSE 0; 07107000 + PIR ~ A.[27:20]; 07108000 + PROF ~ AROF ~ FALSE; 07109000 + END 07110000 + END 07111000 + ELSE BEGIN 07112100 + MOVE (A, C); 07113000 +IRWORD: IF TTAG ~ CX. TAG = IRW 07114000 + THEN BEGIN 07115000 + IF C.EBIT = 0 07116000 + THEN BEGIN 07117000 + MOVE(M[D[LEVEL(C)]+DELTA(C)],C); 07118000 + MEMCYCLE; 07119000 + GO TO IRWORD; 07120000 + END 07121000 + ELSE SETINTERRUPT (INVOP); 07122000 + END 07123000 + ELSE IF TTAG ! PCW 07124000 + THEN SETINTERRUPT (INVOP) 07125000 + ELSE PCWORD; 07126000 + END; 07127000 + END OF DYNAMIC BRANCH UTILITY ROUTINE; 07128000 +PROCEDURE DBUN; % DYNAMIC BRANCH UNCONDITIONAL DBUN07129000 + BEGIN 07130000 + ERVSFLOW(14); 07131000 + END DBUN; 07132000 +PROCEDURE DBTR; % DYNAMIC BRANCH ON TRUE DBTR07133000 + BEGIN 07134000 + ERVSFLOW(12); 07135000 + END DBTR; 07136000 +PROCEDURE DBFL; % DYNAMIC BRANCH ON FALSE 07137000 + BEGIN 07138000 + ERVSFLOW(13); 07139000 + END DBFL; 07140000 +PROCEDURE NOOP ; % NO OPERATION 07141000 + BEGIN 07142000 + END NOOP; 07143000 +PROCEDURE HALT ; % CONDITIONAL HALT 07144000 + BEGIN 07145000 + FILE SPO 11(1,10); 07145010 + FORMAT HALTER("**B6500/SIM: PDR = ",I3,":PIR = ",I4,"~"); 07145020 + IF HALTING=0 THEN WRITE(SPO,HALTER,PDR,PIR); 07145030 + WHILE HALTING=0 DO WHEN(10); 07145040 + CASE HALTING MOD 4 OF 07145050 + BEGIN 07145060 + ; 07145070 + NOTYETCODED; 07145080 + MEMDUMP; 07145090 + ; 07145100 + END; 07146000 + END HALT; 07147000 +PROCEDURE NVLD ; % INVALID OPERATOR 07148000 + BEGIN 07149000 + SETINTERRUPT(INVOP); 07150000 + END NVLD; 07151000 +PROCEDURE VARI ; % ESCAPE TO 16-BIT INSTRUCTION 07156000 + BEGIN 07157000 + ERROR(1); MEMDUMP; GO TO EOJ; 07158000 + END VARI; 07159000 +PROCEDURE ADD ; % ADD 07160000 + BEGIN 07161000 + ADJ(1,1); 07162000 + IF NOT CHECOP THEN INTFAMA(-1) ELSE 07163000 + IF AX.TAG=SINGL AND BX.TAG=SINGL THEN 07164000 + BEGIN 07165000 + B:= B + A; 07166000 + BX.PBIT:= REAL(AROF:=FALSE); 07167000 + END ELSE 07168000 + BEGIN 07169000 + IF AX.TAG=SINGL THEN X:=XX:= 0 ELSE 07170000 + IF BX.TAG=SINGL THEN Y:=YX:= 0; 07171000 + DOUBLE(A,X,B,Y,+,~,B,Y); 07172000 + BX~DOUBL+DOUBL; 07173000 + AROF:=FALSE; 07174000 + END; 07175000 + END ADD ; 07176000 +PROCEDURE SUBT ; % SUBTRACT 07177000 + BEGIN 07178000 + ADJ(1,1); 07179000 + IF NOT CHECOP THEN INTFAMA(-1) ELSE 07180000 + IF AX.TAG=SINGL AND BX.TAG=SINGL THEN 07181000 + BEGIN 07182000 + B:= B - A; 07183000 + BX.PBIT:= REAL(AROF:=FALSE); 07184000 + END ELSE 07185000 + BEGIN 07186000 + IF AX.TAG=SINGL THEN X:=XX:= 0 ELSE 07187000 + IF BX.TAG=SINGL THEN Y:=YX:= 0; 07188000 + DOUBLE(B,Y,A,X,-,~,B,Y); 07189000 + BX~DOUBL+DOUBL; 07190000 + AROF:=FALSE; 07191000 + END; 07192000 + END SUBT; 07193000 +PROCEDURE MULT ; % MULTIPLY 07194000 + BEGIN 07195000 + ADJ(1,1); 07196000 + IF NOT CHECOP THEN INTFAMA(-1) ELSE 07197000 + IF AX.TAG=SINGL AND BX.TAG=SINGL THEN 07198000 + BEGIN 07199000 + B:= B | A; 07200000 + BX.PBIT:= REAL(AROF:=FALSE); 07201000 + END ELSE 07202000 + BEGIN 07203000 + IF AX.TAG=SINGL THEN X:=XX:= 0 ELSE 07204000 + IF BX.TAG=SINGL THEN Y:=YX:= 0; 07205000 + DOUBLE(A,X,B,Y,|,~,B,Y); 07206000 + BX:=YX:=DOUBL+DOUBL; 07207000 + AROF:=FALSE; 07208000 + END; 07209000 + END MULT; 07210000 +PROCEDURE MULX ; % EXTENDED MULTIPLY 07211000 + BEGIN 07212000 + NOTYETCODED; 07213000 + END MULX; 07214000 +PROCEDURE DIVD ; % DIVIDE 07215000 + BEGIN 07216000 + LABEL OC; 07217000 + ADJ(1,1); 07218000 + IF NOT CHECOP THEN INTFAMA(-1) ELSE 07219000 + IF AX.TAG=SINGL AND BX.TAG=SINGL THEN 07220000 + IF A=0 THEN BEGIN INTFAMA( DIVZROI); GO OC END ELSE 07221000 + BEGIN 07222000 + B:= B/A; 07223000 + BX.PBIT:= REAL(AROF:=FALSE); 07224000 + END ELSE 07225000 + BEGIN 07226000 + IF AX.TAG=SINGL THEN X:=XX:= 0 ELSE 07227000 + IF BX.TAG=SINGL THEN Y:=YX:=0; 07228000 + IF A=0 AND X=0 THEN BEGIN INTFAMA(DIVZROI); 07229000 + GO TO OC; 07230000 + END; 07231000 + DOUBLE(B,Y,A,X,/,~,B,Y); 07232000 + BX~DOUBL+DOUBL; 07233000 + AROF:=FALSE; 07234000 + END; 07235000 +OC: 07236000 + END DIVD; 07237000 +PROCEDURE IDIV ; % INTEGER DIVIDE 07238000 + BEGIN 07239000 + DIVD; 07240000 + IF INT =0 07241000 + THEN IF INTEGERIZE(FALSE,B) THEN INTFAMA(INTOVFI); 07242000 + END IDIV; 07243000 +PROCEDURE RDIV ; % REMAINDER DIVIDE 07244000 + BEGIN 07245000 + LABEL OC; 07246000 + INTEGER SIGNQ, SIGNQH; 07247000 + REAL TA, TX, TB, TY; 07248000 + ADJ (1, 1); 07249000 + TA~A; TX~IF AX.TAG!SINGL THEN X ELSE 0; 07250000 + TB~B; TY~IF BX.TAG!SINGL THEN Y ELSE 0; 07251000 + DIVD; 07252000 + IF INT !0 THEN GO TO OC; 07253000 + SIGNQ ~ SIGN(B); 07254000 + B.SOBIT ~ 0; 07255000 + IF INTEGERIZE (FALSE, B) THEN BEGIN ERROR(100); GO OC END; 07256000 + Y ~ 0; 07257000 + DOUBLE (TB, TY, TA, TX, SIGNQ, SIGNQH, B, Y, |,|, -, ~, B, Y); 07258000 + IF INTEGERIZE(FALSE,B) THEN INTFAMA(INTOVFI); 07259000 +OC: 07260000 + END RDIV; 07261000 +PROCEDURE NTIA ; % INTEGER TRUNCATED 07262000 + BEGIN 07263000 + INTEGER EB; % EXPONENT IN B AT ENTRY,IN CODE USED 07264000 + % AS 8-BASED EXPONENT,IN COMMENTS,FOR 07265000 + % CONVENIENCE,REFERENCED AS 2-BASED 07266000 + DEFINE I1INVALIDOPERATOR = BEGIN 07269000 + INTFAMA(-1); 07270000 + GO TO OC END#, 07271000 + I2INTEGEROVERFLOW = BEGIN 07272000 + INTFAMA(INTOVFI); 07273000 + GO TO OC END#; 07274000 + % INTERRUPT PROCESSING TO BE DEFINED 07275000 + LABEL L1,NEGEXPLBL,OC; 07276000 + INTEGER T1,T2; % WORKING LOCAL INTEGERS 07277000 + ADJ(0,1); 07278000 + IF BX.TAG !SINGL AND BX.TAG ! DOUBL THEN I1INVALIDOPERATOR; 07279000 + IF(EB~B.EXPF)=0 THEN GO TO L1; 07280000 + IF BX.TAG = SINGL THEN Y ~ 0; 07281000 + IF B.SEBIT=1 THEN GO TO NEGEXPLBL; 07282000 + IF (T1~B.MANF)>8*(13-EB)-1 THEN I2INTEGEROVERFLOW; % IF EB< NB 07283000 + T1 ~ T1|8*EB; % T1.[36:39-EB] ~ B.[38-EB:39-EB] 07284000 + B.MANF~T1+(T2~Y.MANF) DIV (8*(13-EB));%B~B.[38-EB:39-EB] 07285000 + %+Y.[38-EB] 07286000 + B.SEXPF ~ 0; 07287000 + GO TO L1; 07288000 + NEGEXPLBL: 07289000 + B.MANF~(T1~B.MANF) DIV (8*EB);%B.[38-EB:39-EB]~B.[38:39-EB] 07290000 + % B.[38-EB] ~ 0 IMPLIED 07291000 + B.SEXPF ~ 0; 07292000 + L1: BX.TAG ~ SINGL; 07293000 + OC: 07294000 + END NTIA; 07295000 +PROCEDURE NTGR; % INTEGERISE ROUNDED 07296000 + BEGIN 07297000 + INTEGER EB; % EXPONENT IN B AT ENTRY,IN CODE USED 07298000 + % AS 8-BASED EXPONENT,IN COMMENTS,FOR 07299000 + % CONVENIENCE,REFERENCED AS 2-BASED 07300000 + DEFINE I1INVALIDOPERATOR = BEGIN 07303000 + INTFAMA(-1); 07304000 + GO TO OC END#, 07305000 + I2INTEGEROVERFLOW = BEGIN 07306000 + INTFAMA(INTOVFI); 07307000 + GO TO OC END#; 07308000 + % INTERRUPT PROCESSING TO BE DEFINED 07309000 + LABEL L1,NEGEXPLBL,L2,L3,L4,OC; 07310000 + INTEGER T1,T2; % WORKING LOCAL INTEGERS 07311000 + ADJ(0,1); 07312000 + IF BX.TAG ! SINGL AND BX.TAG ! DOUBL THEN I1INVALIDOPERATOR; 07313000 + IF BX.TAG = SINGL THEN Y ~ 0; 07314000 + IF (EB~B.EXPF) = 0 THEN GO TO L1; 07315000 + IF B.SEBIT =1 THEN GO TO NEGEXPLBL; 07316000 + IF (T1 ~ B.MANF) > 8*(13-EB)-1 THEN I2INTEGEROVERFLOW; % EB{NB 07317000 + T1 ~ T1|8*EB; % T1~ B.[38-EB:39-EB] 07318000 + B.MANF~T1+(T2~Y.MANF) DIV (8*(13-EB));%B~B.[38-EB:39-EB] 07319000 + %+Y.[38:EB] 07320000 + Y ~ (T1 ~ Y.MANF)| 8*EB; % Y.[38:39-EB] ~ Y.[38-EB:39-EB] 07321000 + % Y.[EB:EB] ~ 0 IMPLIED 07322000 + B.SEXPF ~ 0; 07323000 + IF BX.TAG=SINGL THEN GO TO L4; 07324000 + L1: IF B.SOBIT = 0 THEN GO TO L3; 07325000 + IF Y.MANF { 274877906944 THEN GO TO L4; % IF FRACTION { 0.5 07326000 + L2: IF B.MANF = 549755813887 THEN I2INTEGEROVERFLOW; % IF B=2*39-1 07327000 + B.MANF ~ B.MANF+1; 07328000 + GO TO L4; 07329000 + L3: IF Y.MANF } 274877906944 THEN GO TO L2 ELSE GO TO L4; 07330000 + % LAST STATEMENT EQUIVALENT TO IF FRACTION } 0.5.... 07331000 + NEGEXPLBL: 07332000 + B.MANF~(T1~B.MANF) DIV (8*EB);%B.[38-EB:39-EB]~B.[38:39-EB] 07333000 + % B.[38:EB] ~ 0 IMPLIED 07334000 + Y~T1|8*(13-EB); % Y.[38:EB] ~ B.[EB:EB] 07335000 + B.SEXPF ~ 0; 07336000 + GO TO L1; 07337000 + L4: BX.TAG ~ SINGL; 07338000 + OC: 07339000 + END NTGR; 07340000 +PROCEDURE NTGD; % DOUBLE PRECISION INTEGERIZE 07340010 + BEGIN 07340020 + INTEGER XA, XB, KT, LZCT; 07340060 + LABEL OC, L1, L2, L10; 07340070 + ADJ (0,1); 07340080 + CHECOPRNDB END; IF SDIS = 1 THEN GO TO OC; 07340090 + BX.TAG ~ DOUBL; 07340100 + A.SEXPF ~ 013; 07340110 + IF B.MANF = 0 AND Y.MANF = 0 THEN GO TO L10; 07340120 + XA ~ XA & XX[33:47:1] & X[34:1:8] & A[42:3:6]; 07340130 + XB ~ XB & YX[33:47:1] & Y[34:1:8] & A[42:3:6]; 07340140 + IF XA = XB THEN GO TO OC; 07340150 + IF XA > XB THEN 07340160 + BEGIN 07340170 + IF B.SEXPF ! 1 THEN 07340180 + BEGIN 07340190 + FOR KT ~ XA - XB STEP -1 UNTIL 0 DO 07340200 + BEGIN 07340210 + X.[12:36] ~ X.[9:36]; 07340220 + X.[9:3] ~ Y.[45:3]; 07340230 + Y.[12:36] ~ Y.[9:36]; 07340240 + Y.[9:3] ~ B.[45:3]; 07340250 + B.[12:36] ~ B.[9:36]; 07340260 + B.[9:3] ~ 0; 07340270 + END; 07340280 + L1: IF X.[9:3] > 4 THEN 07340290 + BEGIN 07340300 + AX ~ A ~ 0; XX ~ X ~ 0; 07340310 + X ~ 1; AX.TAG ~ DOUBL; 07340320 + AROF ~ TRUE; 07340330 + ADD; 07340340 + END; 07340350 + GO TO L10; 07340360 + END; 07340370 + IF B.MANF ! 0 THEN 07340380 + BEGIN 07340390 + Y.[9:39] ~ B.[9:39]; 07340400 + B.[9:39] ~ 0; 07340410 + XB ~ XB - XA; 07340420 + IF XB < XA THEN 07340430 + BEGIN 07340440 + FOR KT ~ XA - XB STEP -1 UNTIL 0 DO 07340450 + BEGIN 07340460 + X.[9:3] ~ Y.[45:3]; 07340470 + Y.[12:36] ~ Y.[9:36]; 07340480 + Y.[9:3] ~ 0; 07340490 + END; 07340500 + GO TO L1; 07340510 + END; 07340520 + END; 07340530 + Y.[9:39] ~ 0; 07340540 + GO TO L10; 07340550 + END; 07340560 + XB ~ XB - 13; 07340570 + IF XA < XB THEN 07340580 + BEGIN 07340590 + IF B.MANF ! 0 THEN BEGIN 07340600 + SETINTERRUPT (INTOVFI); 07340601 + GO TO OC; END; 07340602 + B.[9:39] ~ Y.[9:39]; 07340610 + Y.[9:39] ~ 0; 07340620 + XB ~ XB - 13; 07340630 + IF XB > XA THEN BEGIN SETINTERRUPT (INTOVFI); 07340640 + GO TO OC; 07340641 + END; 07340642 + END; 07340650 + MOVE (B, JUNK); 07340660 + LZCT ~ 0; 07340670 + L2: IF JUNK.[9:3] = 0 THEN 07340680 + BEGIN 07340690 + LZCT ~ LZCT + 1; 07340700 + JUNK.[9:36] ~ JUNK.[12:36]; 07340710 + GO TO L2; 07340720 + END; 07340730 + IF LZCT < XB THEN BEGIN SETINTERRUPT (INTOVFI); 07340740 + GO TO OC; 07340741 + END; 07340742 + FOR KT ~ XB STEP -1 UNTIL 0 DO 07340750 + BEGIN 07340760 + B.[9:36] ~ B.[12:36]; 07340770 + B.[45:3] ~ Y.[9:3]; 07340780 + Y.[9:36] ~ Y.[12:36]; 07340790 + Y.[45:3] ~ 0; 07340800 + END; 07340810 + B.SEXPF ~ A.SEXPF; 07340820 + GO TO OC; 07340830 + L10: 07340840 + Y.EXPEXT ~ 0; 07340850 + B.SEXPF ~ A.SEXPF; 07340860 + OC: 07340870 + END OF DOUBLE PRECISION INTEGERIZE; 07340880 +PROCEDURE SNGT ; % SET TO SINGLE PRECISION, TRUNCATED 07341000 + BEGIN 07342000 + ADJ(0,1); 07343000 + CHECOPRNDB END; 07344000 + BX.TAG~Y~YX~0 07345000 + END SNGT; 07346000 +PROCEDURE SNGL ; % SET TO SINGLE PRECISION; ROUNDED 07347000 + BEGIN 07348000 + ADJ(0,1); 07349000 + CHECOPRNDB END 07350000 + ELSE IF BX.TAG=DOUBL THEN 07351000 + BEGIN IF X.[9:1]=1 THEN A~ (A+1)&A[1:1:8]; 07352000 + AX.TAG ~ X ~ XX ~0; 07353000 + BX.TAG~Y~YX~0; 07354000 + END; 07355000 + END SNGL; 07356000 +PROCEDURE XTND ; % SET TO DOUBLE PRECISION 07357000 + BEGIN 07358000 + ADJ(0,1); 07359000 + CHECOPRNDB END 07360000 + ELSE IF BX.TAG=SINGL THEN 07361000 + BEGIN BX.TAG~DOUBL; 07362000 + Y~YX~0; 07363000 + END; 07364000 + END XTND; 07365000 +PROCEDURE JOIN; % MAKE TWO SINGLES INTO A DOUBLE PRECISION OPERAND 07366000 + BEGIN 07367000 + ADJ (1,1); 07368000 + IF NOT CHECOP THEN SETINTERRUPT (INVOP) ELSE 07368200 + BEGIN 07368300 + Y ~ A; 07368400 + BX.TAG ~ DOUBL; 07368500 + AROF ~ FALSE 07368600 + END; 07368700 + END JOIN; 07369000 +PROCEDURE SPLT; % MAKE A DOUBLE PRECISION INTO TWO SINGLE OPERANDS 07370000 + BEGIN 07371000 + ADJ (0,1); 07371100 + CHECOPRNDB END 07371200 + ELSE IF BX.TAG = DOUBL THEN A ~ Y 07371300 + ELSE A ~ 0; 07372000 + AX.TAG ~ SINGL; 07372050 + BX.TAG ~ SINGL; 07372100 + AROF ~ TRUE; 07372200 + END SPLT; 07373000 +PROCEDURE LAND ; % LOGICAL AND 07374000 + BEGIN 07375000 + ADJ(1,1); 07376000 + B:=REAL(BOOLEAN(A)AND BOOLEAN(B)); 07377000 + BX ~ REAL(BOOLEAN(AX) AND BOOLEAN(BX)); 07378000 + IF AX.TAG=DOUBL OR BX.TAG=DOUBL THEN 07379000 + BEGIN 07380000 + IF AX.TAG!DOUBL THEN X:=XX:=0; 07381000 + IF BX.TAG!DOUBL THEN Y:=YX:=0; 07382000 + Y:=REAL(BOOLEAN(Y)AND BOOLEAN(X)); 07383000 + YX.PBIT:=REAL(BOOLEAN(YX.PBIT)AND BOOLEAN(XX.PBIT)); 07384000 + BX.TAG~DOUBL; 07385000 + END; 07386000 + AROF:=FALSE; 07387000 + END LAND; 07388000 +PROCEDURE LOR ; % LOGICAL OR 07389000 + BEGIN 07390000 + ADJ(1,1); 07391000 + B:=REAL(BOOLEAN(A) OR BOOLEAN(B)); 07392000 + BX ~ REAL(BOOLEAN(AX) OR BOOLEAN(BX)); 07393000 + IF AX.TAG=DOUBL OR BX.TAG=DOUBL THEN 07394000 + BEGIN 07395000 + IF AX.TAG!DOUBL THEN X:=XX:=0; 07396000 + IF BX.TAG!DOUBL THEN Y:=YX:=0; 07397000 + Y:=REAL(BOOLEAN(Y) OR BOOLEAN(X)); 07398000 + YX.PBIT:=REAL(BOOLEAN(YX.PBIT) OR BOOLEAN(XX.PBIT)); 07399000 + BX.TAG~DOUBL; 07400000 + END; 07401000 + AROF:=FALSE; 07402000 + END LOR ; 07403000 +PROCEDURE LNOT ; % LOGICAL NEGATE 07404000 + BEGIN 07405000 + ADJ(1,2); 07406000 + A:=REAL(NOT BOOLEAN(A)); 07407000 + AX ~ REAL(NOT BOOLEAN(AX)); 07408000 + IF AX.TAG=DOUBL THEN 07409000 + BEGIN 07410000 + X:=REAL(NOT BOOLEAN(X)); 07411000 + XX.PBIT:=REAL(NOT BOOLEAN(XX.PBIT)); 07412000 + END; 07413000 + END LNOT; 07414000 +PROCEDURE SAME ; % LOGICAL EQUAL 07415000 + BEGIN 07416000 + REAL PROCEDURE EQUAL(A,B,C,D);VALUE A,B,C,D; REAL A,B,C,D; 07417000 + EQUAL~ REAL(REAL(BOOLEAN(A)EQV BOOLEAN(B)) = REAL(NOT FALSE) 07418000 + AND C=D); 07419000 + ADJ(1,1); 07420000 + IF AX.TAG!BX.TAG THEN B:=0 ELSE 07421000 + BEGIN 07422000 + B:=EQUAL(A,B,AX.PBIT,BX.PBIT); 07423000 + IF AX.TAG=DOUBL THEN 07424000 + B:=REAL(BOOLEAN(B)AND BOOLEAN(EQUAL(X,Y, 07425000 + XX.PBIT,YX.PBIT))); 07426000 + END; 07427000 + AROF:=FALSE; 07428000 + BX.[44:4]:=0; 07429000 + END SAME; 07430000 +PROCEDURE LEQV ; % LOGICAL EQUIVALENCE 07431000 + BEGIN 07432000 + ADJ(1,1); 07433000 + B:=REAL(BOOLEAN(A)EQV BOOLEAN(B)); 07434000 + BX ~ REAL(BOOLEAN(AX) EQV BOOLEAN(BX)); 07435000 + IF AX.TAG=DOUBL OR BX.TAG=DOUBL THEN 07436000 + BEGIN 07437000 + IF AX.TAG!DOUBL THEN X:=XX:=0; 07438000 + IF BX.TAG!DOUBL THEN Y:=YX:=0; 07439000 + Y:=REAL(BOOLEAN(Y)EQV BOOLEAN(X)); 07440000 + YX.PBIT:=REAL(BOOLEAN(YX.PBIT)EQV BOOLEAN(XX.PBIT)); 07441000 + BX.TAG~DOUBL; 07442000 + END; 07443000 + AROF:=FALSE; 07444000 + END LEQV; 07445000 +DEFINE NOTOPERAND= IF NOT CHECOP THEN BEGIN SETINTERRUPT(INVOP); 07446000 + GO TO OC; END#; 07447000 +PROCEDURE GRTR ; % GREATER THAN 07448000 + BEGIN 07449000 + LABEL OC; 07450000 + ADJ(1,1); 07451000 + NOTOPERAND; 07452000 + C:=B; 07453000 + B:=REAL(B>A); 07454000 + IF (AX.TAG=DOUBL OR BX.TAG=DOUBL) AND (C=A) THEN 07455000 + BEGIN 07456000 + IF AX.TAG!DOUBL THEN X:=XX:=0 ELSE 07457000 + IF BX.TAG!DOUBL THEN Y:=YX:=0; 07458000 + B:= REAL(Y>X); 07459000 + END; 07460000 + BX.[44:4 ]:= REAL(AROF:=FALSE); 07461000 +OC: 07462000 + END GRTR; 07463000 +PROCEDURE GREQ ; % GREATER THAN OR EQUAL 07464000 + BEGIN 07465000 + LABEL OC; 07466000 + ADJ(1,1); 07467000 + NOTOPERAND; 07468000 + C:=B; 07469000 + B:=REAL(B}A); 07470000 + IF (AX.TAG=DOUBL OR BX.TAG=DOUBL) AND (C=A) THEN 07471000 + BEGIN 07472000 + IF AX.TAG!DOUBL THEN X:=XX:=0 ELSE 07473000 + IF BX.TAG!DOUBL THEN Y:=YX:=0; 07474000 + B:=REAL(Y}X); 07475000 + END; 07476000 + BX.[44:4 ]:= REAL(AROF:=FALSE); 07477000 +OC: 07478000 + END GREQ; 07479000 +PROCEDURE EQUL ; % EQUAL 07480000 + BEGIN 07481000 + LABEL OC; 07482000 + ADJ(1,1); 07483000 + NOTOPERAND; 07484000 + B:=REAL(B=A); 07485000 + IF(AX.TAG=DOUBL OR BX.TAG=DOUBL) AND BOOLEAN(B) THEN 07486000 + BEGIN 07487000 + IF AX.TAG!DOUBL THEN X:=XX:=0 ELSE 07488000 + IF BX.TAG!DOUBL THEN Y:=YX:=0; 07489000 + B:=REAL(Y=X); 07490000 + END; 07491000 + BX.[44:4 ]:= REAL(AROF:=FALSE); 07492000 +OC: 07493000 + END EQUL; 07494000 +PROCEDURE LSEQ ; % LESS THAN OR EQUAL 07495000 + BEGIN 07496000 + LABEL OC; 07497000 + ADJ(1,1); 07498000 + NOTOPERAND; 07499000 + C:=B; 07500000 + B:=REAL(B{A); 07501000 + IF (AX.TAG=DOUBL OR BX.TAG=DOUBL) AND (C=A) THEN 07502000 + BEGIN 07503000 + IF AX.TAG!DOUBL THEN X:=XX:=0 ELSE 07504000 + IF BX.TAG!DOUBL THEN Y:=YX:=0; 07505000 + B:=REAL(Y{X); 07506000 + END; 07507000 + BX.[44:4 ]:= REAL(AROF:=FALSE); 07508000 +OC: 07509000 + END LSEQ; 07510000 +PROCEDURE LESS ; % LESS THAN 07511000 + BEGIN 07512000 + LABEL OC; 07513000 + ADJ(1,1); 07514000 + NOTOPERAND; 07515000 + C:=B; 07516000 + B:=REAL(B MEMMODS %LOAD 07594100 + THEN BEGIN 07594200 + SETINTERRUPT (INVADRI); 07594300 + GO OC 07594400 + END; 07594500 + MOVE(M[MM],A); MEMCYCLE; 07595000 + CASE AX.TAG OF 07596000 + BEGIN 07597000 + ; % SINGLE PRECISION OPERAND 07598000 + ; % IRW 07599000 + BEGIN MOVE (M[MM+1], X); MEMCYCLE END; % DOUBLE PRECISION 07600000 + INVALIDOPERATORINTERRUPT; % TAG=3 S.D MSCW RCW 07601000 + ; %UNASSIGNED 07602000 + % D A T A D E S C R I P T O R 07603000 + BEGIN 07603100 + IF (AX.PBIT=0 AND A.CBIT=0) THEN 07604000 + A.ADDR ~ MM; A.CBIT ~ 1 END; 07605000 + ; %UNINITIALIZED OPERAND 07606000 + INVALIDOPERATORINTERRUPT; % PROGRAM CONTROL WORD 07607000 + END; 07608000 +OC: 07609000 + END LOAD; 07610000 +PROCEDURE LODT ; % LOAD TRANSPARENT 07611000 +BEGIN 07612000 + LABEL OC; 07613000 + ADJ(1,2); 07614000 + MOVE(A,C); MM~ C.ADDR; 07615000 + CASE CX.TAG OF 07616000 + BEGIN 07617000 + ; % SINGLE PRECISION OPERAND 07618000 + IF NOT BOOLEAN(C.EBIT) THEN % NORMAL IRW 07619000 + MM~ D[LEVEL(C)] + DELTA(C) 07620000 + ELSE BEGIN % STUFFED IRW 07621000 + IF SNR=C.STKNR THEN TEMP~ BOSR 07622000 + ELSE BEGIN 07623000 + MOVE(M[D0+2],C); MEMCYCLE; 07624000 + IF NOT BOOLEAN(CX.PBIT) THEN 07625000 + PRESENCEBITINTERRUPT; 07626000 + IF C.LENGTH < A.STKNR THEN 07627000 + INVALIDINDEXINTERRUPT; 07628000 + MOVE(M[C.ADDR+A.STKNR],C); MEMCYCLE; 07629000 + IF NOT BOOLEAN(CX.PBIT) THEN 07630000 + PRESENCEBITINTERRUPT; 07631000 + TEMP~ C.ADDR; 07632000 + END; 07633000 + MM~ A.DISP + A.[35:13] + TEMP; 07634000 + END; 07635000 + ; % DOUBLE PRESESION OPERAND 07636000 + ; % TAG = 3 S.D. MSCW RCW 07637000 + ; % UNASSIGNED 07638000 + % D A T A D E S C R I P T O R 07639000 + IF NOT BOOLEAN(CX.PBIT) THEN PRESENCEBITINTERRUPT 07640000 + ELSE IF BOOLEAN(C.IBIT) THEN MM~ C.ADDR + C.LENGTH; 07641000 + ; % UNINITIALIZED OPERAND 07642000 + ; % PROGRAM CONTROL WORD 07643000 + END; 07644000 + IF MM + MM > MEMMODS THEN SETINTERRUPT (INVADRI) ELSE % LODT 07644900 + MOVE(M[MM],A); MEMCYCLE; 07645000 + OC: 07646000 + END LODT; 07647000 +PROCEDURE EXCH ; % EXCHANGE 07648000 + BEGIN 07649000 + REAL T1,T2; 07650000 + ADJ(1,1); 07651000 + MOVE(A,T1); 07652000 + MOVE(B,A); 07653000 + MOVE(T1,B); 07654000 + MOVE(X,T1); 07655000 + MOVE(Y,X); 07656000 + MOVE(T1,Y); 07657000 + END EXCH; 07658000 +PROCEDURE RSDN ; % ROTATE STACK DOWN 07659000 + BEGIN 07660000 + ADJ(1,1); 07661000 + MOVE(B,C); 07662000 + MOVE(Y,AA); 07663000 + BROF:=FALSE; 07664000 + ADJ(1,1); 07665000 + EXCH; 07666000 + ADJ(1,0); 07667000 + MOVE(C,B); 07668000 + BROF~TRUE; 07669000 + MOVE(C,B); 07670000 + MOVE(AA,Y); 07671000 + EXCH; 07672000 + AROF~TRUE; 07673000 + END RSDN; 07674000 +PROCEDURE RSUP ; % ROTATE STACK UP 07675000 + BEGIN 07676000 + ADJ(1,1); 07677000 + MOVE(A,C); 07678000 + MOVE(X,AA); 07679000 + AROF:=FALSE; 07680000 + ADJ(1,1); 07681000 + EXCH; 07682000 + ADJ(1,0); 07683000 + MOVE(C,B); 07684000 + MOVE(AA,Y); 07685000 + BROF:=TRUE; 07686000 + END RSUP; 07687000 +PROCEDURE DUPL ; % DUPLICATE TOP OF STACK 07688000 + BEGIN 07689000 + ADJ(0,1); 07690000 + MOVE(B,A); 07691000 + MOVE(Y,X); 07692000 + AROF:=TRUE; 07693000 + END DUPL; 07694000 +PROCEDURE DLET ; % DELETE TOP OF STACK 07695000 + BEGIN 07696000 + ADJ(1,2); 07697000 + AROF:=FALSE; 07698000 + END DLET; 07699000 +PROCEDURE MVST ; % MOVE STACK 07700000 + BEGIN 07701000 + ERVSFLOW(11); 07702000 + END MVST; 07703000 +PROCEDURE PUSH ; % PUSH DOWN STACK REGISTERS 07704000 + BEGIN 07705000 + ADJ(0,0); 07706000 + END PUSH; 07707000 +PROCEDURE STOD ; % STORE DESTRUCTIVE 07708000 + BEGIN 07709000 + STORE(0); 07710000 + END STOD; 07711000 +PROCEDURE STON ; % STORE NON-DESTRUCTIVE 07712000 + BEGIN 07713000 + STORE(1); 07714000 + END STON; 07715000 +PROCEDURE OVRD ; % OVERWRITE DESTRUCTIVE 07716000 + BEGIN 07717000 + STORE(2); 07718000 + END OVRD; 07719000 +PROCEDURE OVRN ; % OVERWRITE NON-DESTRUCTIVE 07720000 + BEGIN 07721000 + STORE(3); 07722000 + END OVRN; 07723000 +BOOLEAN PROCEDURE GETSYLLABLES (N);% UTILITY FOR FLTR, ISOL AND INSR. 07724000 + VALUE N; INTEGER N; 07725000 + BEGIN 07726000 + DEFINE S = TBUF#; 07727000 + INTEGER I,T,J; 07728000 + BOOLEAN B; 07729000 + LABEL OC; 07729100 + DO BEGIN 07730000 + T ~ S [I] ~ IF PROF THEN SYLLABLES [PSR] 07731000 + ELSE PSYLLABLES; 07732000 + J~IF I=N-1 THEN 48 ELSE 47; 07733000 + IF B~T>J 07734000 + THEN BEGIN INTFAMB(2); GO OC END; 07735000 + STEPPSR (1); 07736000 + END UNTIL I ~ I + 1 } N OR B; 07737000 + GETSYLLABLES ~ B; 07738000 + OC: 07738100 + END GETSYLLABLES; 07739000 +STREAM PROCEDURE MOVEN (S, D, N); VALUE N; 07740000 + BEGIN SI ~ S; DI ~ D; DS~N WDS END MOVE OF N WORDS FROM S TO D; 07741000 +BOOLEAN PROCEDURE GETGKL (N); % UTILITY FOR DFTR, DISO AND DINS. 07742000 + VALUE N; INTEGER N; 07743000 + BEGIN 07744000 + DEFINE GKL = TBUF#; % MOMENTARY STORAGE 07745000 + INTEGER I,J; 07746000 + BOOLEAN BOOLE; 07747000 + LABEL OC; 07747100 + J~48; 07748000 + DO BEGIN 07749000 + ADJ (0, 1); 07750000 + IF BOOLE~INTEGERIZE(TRUE,B) OR B<0 OR B>J 07751000 + THEN BEGIN INTFAMB(3); GO OC END 07752000 + ELSE GKL [I] ~ B; 07753000 + BROF ~ FALSE; 07754000 + J~47; 07755000 + END UNTIL I ~ I + 1 } N OR BOOLE; 07756000 + GETGKL ~ BOOLE; 07757000 + OC: 07757100 + END VALIDATION OF OPERANDS FOR DYNAMIC FIELD OPERATORS; 07758000 +PROCEDURE FLTR ; % FIELD TRANSFER 07759000 + BEGIN 07760000 + DEFINE S = TBUF#; 07761000 + INTEGER K, G, L; 07762000 + IF NOT GETSYLLABLES (3) 07763000 + THEN BEGIN 07764000 + ADJ (1, 1); 07765000 + MOVEN (S[0], K, 3); % SYLLABLES TO LOCALS 07766000 + DYAL (A, B, G, K, L); % B.[K:L]; ~ A.[G:L] 07767000 + AROF ~ FALSE; 07768000 + END; 07769000 + END FLTR; 07770000 +PROCEDURE DFTR ; % DYNAMIC FIELD TRANSFER 07771000 + BEGIN 07772000 + DEFINE LGK = TBUF#; 07773000 + INTEGER L, G, K; % DO NOT DISTURB G, K, OR L 07774000 + IF NOT GETGKL (3) % STACK ADJUST AND VALIDITY 07775000 + THEN BEGIN 07776000 + ADJ (1, 1); 07777000 + MOVEN (LGK [0], L, 3); % OPERANDS TO LOCALS 07778000 + DYAL (A, B, G, K, L); % B.[K:L] ~ A.[G,L] 07779000 + AROF ~ FALSE; 07780000 + END; 07781000 + END DFTR; 07782000 +PROCEDURE ISOL ; % FIELD ISOLATE 07783000 + BEGIN 07784000 + DEFINE S = TBUF#; 07785000 + INTEGER G, L, K ; % DO NOT DISTURB G AND L 07786000 + IF NOT GETSYLLABLES (2) 07787000 + THEN BEGIN 07788000 + ADJ (1, 0); 07789000 + MOVEN (S[0], G, 2); % SYLLABLES TO LOCALS 07790000 + K ~ L - 1; 07791000 + B ~ BX ~ 0; 07792000 + DYAL (A, B, G, K, L); % B.[K:L] ~ A.[G:L] 07793000 + AROF ~ FALSE; 07794000 + BROF ~ TRUE; 07795000 + END; 07796000 + END ISOL; 07797000 +PROCEDURE DISO ; % DYNAMIC FIELD ISOLATE 07798000 + BEGIN 07799000 + DEFINE LG = TBUF#; 07800000 + INTEGER L, G, K; % DO NOT DISTURB L AND G 07801000 + IF NOT GETGKL (2) % STACK ADJ & VALIDITY CHECK07802000 + THEN BEGIN 07803000 + AROF ~ TRUE; % GETGKL SETS FALSE; 07804000 + MOVEN (LG[0], L, 2); % OPERANDS TO LOCALS 07805000 + K ~ L - 1; 07806000 + A ~ AX ~ 0; 07807000 + ADJ(1,1); 07808000 + DYAL (B, A, G, K, L); % A.[K:L] ~ B.[G:L] 07809000 + BROF ~ FALSE; 07810000 + END; 07811000 + END DISO; 07812000 +PROCEDURE INSR ; % FIELD INSERT 07813000 + BEGIN 07814000 + INTEGER K, L; % DO NOT DISTURB ORDER OF K AND L 07815000 + DEFINE S = TBUF#; % ALSO SEE GETSYLLABLES 07816000 + IF NOT GETSYLLABLES (2) 07817000 + THEN BEGIN 07818000 + ADJ (1, 1); 07819000 + MOVEN (S[0], K, 2); % SYLLABLES TO LOCALS 07820000 + G ~ L - 1; 07821000 + DYAL (A, B, G, K, L); % B.[K:L] ~ A.[G:L]; 07822000 + AROF ~ FALSE; 07823000 + END; 07824000 + END INSR; 07825000 +PROCEDURE DINS ; % DYNAMIC FIELD INSERT 07826000 + BEGIN 07827000 + DEFINE LK = TBUF#; 07828000 + INTEGER L, K, G; % DO NOT DISTURB ORDER 07829000 + ADJ (1, 1); % SAVE A WHILE L & K ARE& 07830000 + AROF ~ FALSE; 07831000 + IF NOT GETGKL (2) 07832000 + THEN BEGIN 07833000 + ADJ (0, 1); 07834000 +% AROF ~ TRUE; 07835000 + MOVEN (LK[0], L, 2); % L AND K TO LOCALS 07836000 + G ~ L - 1; 07837000 + DYAL (A, B, G, K, L); % B.[K:L] ~ A.[G:L] 07838000 +% AROF ~ FALSE; 07839000 + END; 07840000 + END DINS; 07841000 +PROCEDURE SRCH ; % MASKED SEARCH FOR EQUAL 07842000 + BEGIN 07843000 + BOOLEAN FINIS; 07844000 + LABEL OC,LOOP,JUMP; 07845000 + ADJ (1, 1); % DESCRIPTOR AND MASK 07846000 + IF AX.TAG ! DATADESC 07847000 + THEN BEGIN 07848000 + SETINTERRUPT (INVOP); 07849000 + GO OC; 07850000 + END; 07851000 + IF AX.PBIT!1 THEN BEGIN SETINTERRUPT(PRESBIT); GO OC END; 07852000 + MOVE (A, C); 07853000 + AROF ~ FALSE; 07854000 + ADJ (1, 1); % MASK AND VALUE 07855000 + MOVE (A, X); 07856000 + IF C.LENGTH=0 THEN GO JUMP; 07857000 +LOOP: 07858000 + C.LENGTH ~ C.LENGTH - 1; 07859000 +JUMP: 07860000 + MOVE (M[C.ADDR + C.LENGTH], A); 07861000 + MEMCYCLE; 07862000 + A ~ REAL (BOOLEAN (A) AND BOOLEAN (X)); 07863000 + AX ~ REAL(BOOLEAN(AX) AND BOOLEAN (XX)); 07864000 + FINIS ~ EQUAL (A, AX, B, BX); 07865000 + IF C.LENGTH!0 AND (NOT FINIS) THEN GO LOOP; 07866000 + IF (NOT FINIS) THEN A~1 ELSE A~0&C[28:8:20]; 07867000 + AX ~ 0; 07868000 + BROF~FALSE; 07869000 +OC: 07870000 + END SRCH; 07871000 +PROCEDURE LLLU ; % LINKED LIST LOOKUP 07872000 + BEGIN 07873000 + LABEL OC,LOOP,NEG; 07874000 + INTEGER PSEUDOA, PSEUDOC; % TO EXPEDITE FLAG BIT TESTING 07875000 + ADJ (1, 1); % INDEX AND DATA DESCRIPTOR 07876000 + IF INTEGERIZE (TRUE, A) 07877000 + THEN BEGIN SETINTERRUPT (INTOVFI); GO OC; END; 07878000 + IF BX.TAG ! DATADESC 07879000 + THEN BEGIN SETINTERRUPT (INVOP); GO OC END; 07880000 + BUF ~ B.ADDR; 07881000 + X ~ A & B [8:8:20]; % INITIAL INDEX AND SIZE 07882000 + BROF ~ FALSE; 07883000 + ADJ (1, 1); % INDEX AND ARGUMENT 07884000 + MOVE (A, C); 07885000 + PSEUDOA ~ B.[20:28]; % ARGUMENT TO A 07886000 +LOOP: IF A.ADDR > X.LENGTH 07887000 + THEN BEGIN SETINTERRUPT (INVINXI);GO OC END; 07888000 + MOVE (M[BUF + A.ADDR], C); % NEW LINK WORD TO C 07889000 + PSEUDOC ~ 0 &C[21:1:27] 07890000 + &CX[20:47:1]; 07891000 + MEMCYCLE; 07892000 + IF PSEUDOA > PSEUDOC 07893000 + THEN BEGIN 07894000 + X.ADDR ~ A.ADDR; % SAVE THIS INDEX 07895000 + A.ADDR ~ C.ADDR; 07896000 + IF(A.ADDR=0)THEN BEGIN A~-1; GO NEG END; 07897000 + GO LOOP; 07898000 + END; 07899000 + A ~ X.ADDR; 07900000 +NEG: 07901000 + AX ~ 0; 07902000 + BROF ~ FALSE; 07903000 +OC: 07904000 + END LLLU; 07905000 +PROCEDURE ZERO ; % LIT CALL ZERO 07906000 + BEGIN 07907000 + ADJ(0,2); 07908000 + AX.[44:4]:=A:=0; 07909000 + AROF:=TRUE; 07910000 + END ZERO; 07911000 +PROCEDURE ONE ; % LIT CALL ONE 07912000 + BEGIN 07913000 + ZERO; 07914000 + A:=1; 07915000 + END ONE ; 07916000 +PROCEDURE LT8 ; % LIT CALL 8 BITS 07917000 + BEGIN 07918000 + ZERO; 07919000 + A:=SYLLABLE; 07920000 + STEPPSR(1); 07921000 + END LT8; 07922000 +PROCEDURE LT16 ; % LIT CALL 16 BITS 07923000 + BEGIN 07924000 + ZERO; 07925000 + A.[32:8]:=SYLLABLE; 07926000 + STEPPSR(1); 07927000 + A.[40:8]:=SYLLABLE; 07928000 + STEPPSR(1); 07929000 + END LT16; 07930000 +PROCEDURE LT48 ; % LIT CALL 48 BITS 07931000 + BEGIN 07932000 + REAL T1,T2; 07933000 + ZERO; 07934000 + IF PSR!0 THEN STEPPSR(6-PSR); T1~SYLLABLE; 07935000 + A:=P; 07936000 + AX:=PX.PBIT; 07937000 + STEPPSR(6); 07938000 + END LT48; 07939000 +PROCEDURE MPCW ; % MAKE PROGRAM CONTROL WORD 07940000 + BEGIN 07941000 + LT48; 07942000 + AX.TAG ~ PCW; 07943000 + END LPCW; 07944000 +PROCEDURE BITSET; % UTILITY FOR BIT SETTING OPERATORS 07945000 + BEGIN 07946000 + INTEGER Z10, Z10X; % Z10X - SAFE IN DYALS 07947000 + Z10 ~ T.[44:1] + 1; % NEGATE BIT 3 OF OPERATOR 07948000 + DYAL (Z10, B, 0, C, 1); 07949000 + END BITSET; 07950000 +PROCEDURE BSET ; % BIT SET 07951000 + BEGIN 07952000 + BRST ; 07953000 + END BSET; 07954000 +PROCEDURE DBST ; % DYNAMIC BIT SET 07955000 + BEGIN 07956000 + DBRS; 07957000 + END DBST; 07958000 +PROCEDURE BRST ; % BIT RESET 07959000 + BEGIN 07960000 + C ~ PSYLLABLES; 07961000 + STEPPSR (1); 07962000 + IF C > 47 THEN INTFAMB(2) ELSE BEGIN 07962100 + ADJ (0, 1); 07963000 + BITSET; 07964000 + END; 07964100 + END BRST; 07965000 +PROCEDURE DBRS ; % DYNAMIC BIT RESET 07966000 + BEGIN 07967000 + ADJ (0, 1); 07968000 + IF INTEGERIZE (TRUE, B) OR B < 0 OR B > 47 07969000 + THEN INTFAMB(3) 07970000 + ELSE BEGIN 07971000 + MOVE (B, C); 07972000 + BROF ~ FALSE; 07973000 + ADJ (0, 1); 07974000 + BITSET; 07975000 + END; 07976000 + END DBRS; 07977000 +PROCEDURE CHSN ; % CHANGE SIGN BIT 07978000 + BEGIN 07979000 + ADJ(1,2); 07980000 + CHECOPRNDA END; 07981000 + A.SOBIT~ REAL(NOT BOOLEAN(A.SOBIT)); 07982000 + END CHSN; 07983000 +PROCEDURE CBON ; % COUNT BINARY ONES 07984000 + BEGIN 07985000 + INTEGER STREAM PROCEDURE COUNT (W); 07986000 + BEGIN 07987000 + SI ~ W; 47 (SKIP SB; IF SB THEN TALLY ~ TALLY + 1); 07988000 + COUNT ~ TALLY; 07989000 + END; 07990000 + CHECOPRNDA END; 07991000 + AA~COUNT(A)+AX.PBIT; 07992000 + IF AX.TAG=DOUBL THEN 07993000 + AA~COUNT(X)+XX.PBIT+AA; 07994000 + AX ~ 0; 07995000 + A~AA; 07996000 + END CBON; 07997000 +PROCEDURE LOG2; % LEADING ONE TEST LOG207998000 + BEGIN 07999000 + INTEGER STREAM PROCEDURE LEADING (ONE); 08000000 + BEGIN 08001000 + SI ~ ONE; 08002000 + 47 (SKIP SB; IF SB THEN JUMP OUT ELSE TALLY ~ TALLY + 1); 08003000 + LEADING ~ TALLY; 08004000 + END LEADING; 08005000 + ADJ(0,1); 08006000 + B~IF BOOLEAN(BX) THEN 48 ELSE 47-LEADING(B); 08007000 + BX~0; 08008000 + END LOG2; 08009000 +PROCEDURE STAG ; % SET TAG FIELD 08010000 + BEGIN 08011000 + ADJ(1,1); 08012000 + BX.TAG:=A.[45:3]; 08013000 + AROF:=FALSE; 08014000 + END STAG; 08015000 +PROCEDURE RTAG ; % READ TAG FIELD 08016000 + BEGIN 08017000 + ADJ(1,2); 08018000 + A:=0&AX[45:44:3]; 08019000 + AX.[44:4]:=0; 08020000 + END RTAG; 08021000 +PROCEDURE SINT ; % SET INTERVAL TIMER 08022000 + BEGIN 08023000 + ADJ (1, 2); % TEMPORARY NO FLOWS 08024000 + INTTIMER ~ (INTTIMER ~ A + .5).[37:11] | 5000 + REALTIME; 08025000 + AX ~ 0; 08026000 + AROF ~ FALSE; 08027000 + IF INTTIMER < IDLETIME OR IDLETIME = 0 THEN IDLETIME~INTTIMER; 08028000 + END SINT; 08029000 +PROCEDURE RDLK ; % READ WITH LOCK 08030000 + BEGIN 08031000 + STORE(7); 08032000 + END RDLK; 08033000 +PROCEDURE STFF ; % STUFF ENVIRONMENT 08034000 + BEGIN 08035000 + ERVSFLOW(18); 08036000 + END STFF; 08037000 +PROCEDURE WHOI ; % READ PROCESSOR IDENTIFICATION 08038000 + BEGIN 08039000 + ADJ (0,2); 08039500 + A ~ AX ~ 0; 08040000 + A ~ PID; AROF ~ TRUE; 08040500 + END WHOI; 08041000 +PROCEDURE EEXI ; % ENABLE EXTERNAL INTERRUPTS 08042000 + BEGIN 08043000 + IF IDLETIME } REALTIME THEN REALTIME ~ IDLETIME; 08043100 + IIHF ~ FALSE; 08044000 + END EEXI; 08045000 +PROCEDURE DEXI ; % DISABLE EXTERNAL IMTERRUPTS 08046000 + BEGIN 08047000 + IIHF ~ TRUE; 08048000 + END DEXI; 08049000 +PROCEDURE IDLE ; % IDLE UNTIL INTERRUPT 08050000 + BEGIN 08051000 + IF NOT NCSF THEN SETINTERRUPT (INVOP) ELSE 08051100 + IF IDLETIME } REALTIME % TEMPORARY - NO FLOWS 08052000 + THEN BEGIN 08053000 + IF DISKLOAD > 0 08054000 + THEN BEGIN 08055000 + DISKLOAD ~ -1 ; 08056000 + INTTIMER ~ IDLETIME ~ CURRENTT ~ 08057000 + REALTIME ~ 1 ; 08058000 + END ; 08059000 + REALTIME ~ IDLETIME; 08060000 +IDLETIME ~ CURRENTT; 08061000 + END 08062000 +ELSE SETINTERRUPT (LOOPI); 08063000 + END IDLE; 08064000 +PROCEDURE HEYU ; % INTERRUPT OTHER PROCESSOR 08065000 + BEGIN 08066000 + PTPI ~ 1; 08067000 + END HEYU; 08068000 +PROCEDURE RPRR ; % READ PROCESSOR REGISTER 08069000 + BEGIN 08070000 +INTEGER I, J, FREG, CHI, PREG, PREGX; 08070050 +LIST MONLIST(M[F+2].[6:6], M[F+2], CX.TAG, CHI, 08070100 + C.[3:3],C.[6:3], C.[9:3], C.[12:3], C.[15:3], C.[18:3],C.[21:3]08070200 + ,C.[24:3],C.[27:3],C.[30:3],C.[33:3],C.[36:3],C.[39:3],C.[42:3]08070300 + ,C.[45:3], FOR J ~ 0 STEP 1 UNTIL I DO MONITOROUTPUT [J]); 08070400 + ADJ (1, 2); 08071000 + MOVE (A, C); 08072000 + IF C = 64 % TO PROVIDE A MEANS OF 08073000 + THEN A ~ TRACTER % PRESERVING TRACTER 08074000 + ELSE IF C =63 08074050 +THEN BEGIN 08074100 +IF PRINTERNOTYETOPENED 08074120 +THEN BEGIN PRINTERNOTYETOPENED.[46:1] ~ TRUE; HEADING END; 08074140 +FREG ~ F - M[F].DF; 08074150 +MOVE (M[F+3], C); 08074200 +CHI ~ C.[1:2] & CX[45:47:1]; 08074250 +WHILE I < 14 AND FREG > BOSR +2 DO 08074300 +BEGIN 08074350 +MOVE(M[FREG+1], PREG); 08074375 +MONITOROUTPUT [I] ~ PREG .SDIF; 08074400 +MONITOROUTPUT[I~I+1] ~ PREG .PIRF; 08074450 +FREG ~ FREG - M[FREG].DF; 08074500 +I ~ I + 1; 08074550 +END; 08074600 +I ~ I - 1; 08074650 +WRITE (TAPED, MONFMT, MONLIST); 08074700 +END ELSE IF C = 62 THEN A ~ IDLETIME ELSE IF C = 61 THEN A ~ REALTIME 08074750 + ELSE 08075000 + IF C < 32 08076000 + THEN A ~ D [C.[43:5]] 08077000 + ELSE IF C.[42:2] = 2 08078000 + THEN BEGIN % THE MOVES ARE THE SIMULATORS 08079000 + %"CORRECTING NETWORK" 08080000 + MOVEN (PIR, IRSR, 8); 08081000 + A ~ IRSR [C.[45:3]]; 08082000 + END 08083000 + ELSE BEGIN 08084000 + MOVEN (PBR, BRSR, 8); 08085000 + A ~ BRSR [C.[45:3]]; 08086000 + END; 08087000 + END RPRR; 08088000 +PROCEDURE SPRR ; % SET PROCESSOR REGISTER 08089000 + BEGIN 08090000 + ADJ (1, 1); 08091000 + MOVE (B, C); 08092000 + IF C = 64 % TO PROVIDE A MEANS OF SETTING 08093000 + THEN TRACTER ~ A % TRACTER 08094000 + ELSE 08095000 + IF C < 32 08096000 + THEN D [C] ~ A. ADDR 08097000 + ELSE IF C.[42:2] = 2 08098000 + THEN BEGIN % THE MOVENS ARE THE SIMULATORS 08099000 + % "CORRECTING NETWORK 08100000 + MOVEN (PIR, IRSR, 8); 08101000 + IRSR [C.[45:3]] ~ A.ADDR; 08102000 + MOVEN (IRSR, PIR, 8); 08103000 + END 08104000 + ELSE BEGIN 08105000 + MOVEN (PBR, BRSR, 8); 08106000 + BRSR [C.[45:3]] ~ A.ADDR; 08107000 + MOVEN (BRSR, PBR, 8); 08108000 + END; 08109000 + AROF ~ BROF ~ FALSE; 08110000 + END SPRR; 08111000 +PROCEDURE SCNI ; % SCAN IN 08112000 + BEGIN 08113000 + DEFINE MBIT = MPXAB#, 08114000 + HTYPE= MPXHDWE#, 08114050 + Z = MPXFC#; 08114100 + ADJ (1, 0); 08114200 + Y ~ 0; 08114300 + CASE A.VARIF OF 08114400 + BEGIN 08114500 + BEGIN % IO PATH INTERROGATE 0 08114600 + IF EVENTS [A.LUNIT].EVBUSY = 0 THEN % UNIT NOT BUSY 08114700 + BEGIN 08114800 + Y.LUNIT ~ A.LUNIT; 08114810 + IF MPX [1, A.LUNIT].HTYPE ! 0 % U CABLED TO MPA08114900 + AND MPXOPS [1] ! 0 % MPXA NOT LOADED08115000 + THEN BEGIN Y.Z ~ 1; Y.MBIT ~ 1 END; 08115100 + IF A.Z = 2 THEN Y ~ 0; 08115150 + IF MPX [2, A.LUNIT].HTYPE ! 0 % U CABLED TO MPB08115200 + AND MPXOPS [2] ! 0 % MPXB NOT LOADED08115300 + THEN BEGIN Y.Z ~ Y.Z + 2; Y.MBIT ~ 1 END; 08115400 + END 08115500 + END PATH INTERROGATE; 08115600 + BEGIN % READ STATUS WORD 1 08115700 + IF A.LUNIT = 0 THEN Y ~ STATUSWORD; 08115800 + % ONLY ONE VECTOR IN SIMULATOR 08115900 + % STATUSWORD BUILT INITIALLY AT CABLING TIME 08116000 + END STATUS; 08116100 + BEGIN % READ RESULT DESCRIPTOR 2 08116200 + Y ~ GETRESULT (A.Z); 08116300 + END READ RESULT DESCRIPTOR; 08116500 + Y ~ ENTIER (TIMEOFDAY DIV 24); % TIME OF DAY 3 08116600 + BEGIN % READ INTERRUPT MASK OR REGISTER 4 08116800 + Y ~ IF BOOLEAN (A.LUNIT) % READ MASK 08116900 + THEN IF A.Z = 1 THEN INTMASKA ELSE INTMASKB 08117000 + ELSE IF A.Z = 1 THEN INTREGA ELSE INTREGB; 08117100 + END; 08117200 + BEGIN % READ GCA 5 08117300 + NOTYETCODED; 08117400 + END; 08117500 + BEGIN % INTERROGATE UNIT TYPE 6 08117600 + IF BOOLEAN (A) 08117700 + THEN Y ~ MPX [A.Z, A.LUNIT].HTYPE 08117800 + ELSE IF Y ~ MPX [1, A.LUNIT].HTYPE = 0 08117900 + THEN Y ~ MPX [2, A.LUNIT].HTYPE; 08118000 + END UNIT TYPE; 08118100 + ; % 7 08118150 + ; % 8 08118200 + ; % 9 08118250 + ; % 10 08118300 + ; % 11 08118350 + ; % 12 08118400 + ; % 13 08118450 + ; % 14 08118500 + BEGIN % READ INTERRUPT LITERAL 15 08118550 + BOOLEAN B; 08118560 + INTEGER I, MPXI; 08118600 + REAL E; 08118605 + MPXI ~A.Z; 08118610 + IF FIRSTEVENT [MPXI] { REALTIME 08118630 + AND FIRSTEVENT[MPXI] !0 08118640 + THEN BEGIN 08118650 + I ~ FIRSTEVENTI[MPXI]; 08118660 + Y ~ MPX[MPXI, I].MPXINT; 08118670 + B ~ Y !0; 08118672 + MPX [MPXI, I].MPXINT ~ 0; 08118675 + WHILE (E ~ EVENTS[I]).EVTIME { REALTIME 08118680 + AND E ! 0 AND NOT B 08118685 + DO BEGIN 08118690 + IF E.EVMPX = MPXI 08118695 + THEN BEGIN 08118700 + Y ~ MPX[MPXI,I].MPXINT;08118705 + B ~ TRUE; 08118707 + MPX[MPXI, I].MPXINT ~0;08118710 + END; 08118715 + I ~ E.EVLINK; 08118720 + END 08118725 + END 08118730 + ELSE Y ~ 0; 08118740 + END; 08118750 + END CASE; 08118800 + B ~ Y; BX ~ 0; 08118850 + AROF ~ FALSE; BROF ~ TRUE; 08118900 + END SCNI; 08119000 +PROCEDURE SCNO ; % SCAN OUT 08120000 + BEGIN 08121000 + DEFINE MBIT = MPXAB#, 08122000 + Z = MPXFC#; 08122200 + INTEGER T; 08122400 + ADJ (1, 1); 08123000 + IF T ~ A.VARIF = 4 OR T = 0 AND NOT NCSF 08124000 + THEN SETINTERRUPT (INVOP) 08124300 + ELSE CASE T OF 08124600 + BEGIN 08124900 + BEGIN% INITIATE I/O 0 08125000 + MOVE (A, SCANBUSA); 08125300 + MOVE (B, DATABUSA); 08125600 + MULTIPLEX ~ TRUE; 08125900 + MOVE (B, DATABUSA); 08126000 + END IIO; 08126300 + ; % 1 08126600 + ; % 2 08126900 + TIMEOFDAY ~ ENTIER (B | 24); % 3 08127000 + IF A.Z = 1 THEN INTMASKA ~ B ELSE INTMASKB ~ B; % 4 08127300 + NOTYETCODED; % SET GCA 5 08127600 + END CASE; 08127900 + AROF ~ BROF ~ FALSE; 08128000 + END SCNO; 08129000 +BOOLEAN SCANORXFER, XLATE, XFERWD, XFERW, SCANWH; 08130000 + 08131000 +DEFINE QF01 = QP.[47:1]#, QF02 = QP.[46:1]#, QF03 = QP.[45:1]#, 08132000 + QF04 = QP.[44:1]#, QH01 = QP.[43:1]#, QH02 = QP.[42:1]#, 08133000 + QH03 = QP.[41:1]#, SPSF = QP.[40:1]#, SPRF = QP.[39:1]#, 08134000 + DPSF = QP.[38:1]#, P2R2 = QP.[37:1]#, P2R3 = QP.[36:1]#, 08135000 + P2R4 = QP.[35:1]#, FWDT = QP.[34:1]#, BKIP = QP.[33:1]#, 08136000 + LHFF = QP.[32:1]#, XROF = QP.[31:1]#, SWPS = QP.[30:1]#; 08137000 +DEFINE INVOPI = BEGIN SETINTERRUPT (INVOP); GO TO OC END#, 08138000 + INTOFL = BEGIN SETINTERRUPT (INTOVFI); GO TO OC END#, 08139000 + INVINX = BEGIN SETINTERRUPT (INVINXI); GO TO OC END#, 08140000 + MEMPRO = BEGIN SETINTERRUPT (MEMPROI); GO TO OC END#, 08141000 + PRESBI = BEGIN SETINTERRUPT (PRESBIT); GO TO OC END#, 08142000 + JFIF = BEGIN 08143000 + ADJ (0,0); BROF ~ TRUE; AROF ~ TRUE; 08144000 + A ~ AX ~ 0; 08144500 + B ~ BX ~ 0; SDIS ~ 1; BKIP ~ 1; 08145000 + IF QF01 = 1 THEN B.[46:1] ~ 1 ELSE 08146000 + IF QF02 = 1 THEN B.[39:1] ~ 1 ELSE 08147000 + IF QF03 = 1 THEN B.[47:1] ~ 1 ELSE 08148000 + B.[37:1] ~ 1; 08149000 + IF P2R2 = 1 THEN A.[46:1] ~ 1 ELSE 08150000 + IF P2R3 = 1 THEN A.[46:2] ~ 3 ELSE 08151000 + A.[45:3] ~ 4; 08152000 + IF QF01 = 1 THEN INVOPI ELSE 08153000 + IF QF02 = 1 THEN PRESBI ELSE 08154000 + IF QF03 = 1 OR QF04 = 1 THEN MEMPRO 08155000 + END#, 08156000 + JGIF = BEGIN 08157000 + ADJ (0,0); A ~ AX + 0; B ~ BX ~ 0; 08158000 + B ~ RPF; BROF ~ TRUE; 08159000 + IF TEEF THEN 08160000 + BEGIN 08161000 + A.ADDR ~ TBR; A.INDEX ~ TIR; 08162000 + A.PSRF ~ PSR; A.SBIT ~ 1; AROF ~ TRUE 08163000 + END ELSE 08164000 + IF FWDT = 1 THEN 08165000 + BEGIN AROF ~ TRUE; MOVE (Y, A) END; 08166000 + JFIF; 08167000 + END#, 08168000 + MEMPROTECT = BEGIN 08168100 + UPDF ~ TRUE; ENDE; 08168200 + QF04 ~ 1; JGIF; 08168300 + GO TO OC; 08168310 + END#, 08168400 + FETCHSOURCE = 08169000 + BEGIN 08170000 + IF SOPF THEN ELSE 08171000 + BEGIN 08172000 + IF NOT AROF THEN 08173000 + BEGIN 08174000 + MM ~ SBR ~ SIR; 08175000 + MOVE (M[MM], A); MEMCYCLE; 08176000 + AROF ~ TRUE; 08177000 + IF BOOLEAN(AX.TAG)THEN MEMPROTECT 08178000 + END; 08179000 + END; 08180000 + END#, 08181000 + FETCHDESTINATION = 08182000 + BEGIN 08183000 + IF NOT BROF THEN 08184000 + BEGIN 08185000 + MM ~ DBR ~ DIR; 08186000 + MOVE (M[MM], B); MEMCYCLE; 08187000 + BROF ~ TRUE; 08188000 + IF BOOLEAN (BX.TAG) THEN MEMPROTECT 08189000 + END; 08190000 + END#, 08191000 + CHARSZ = BEGIN 08192000 + IF SSZ = 0 THEN 08193000 + BEGIN 08194000 + IF DSZ = 0 THEN SSZ ~ DSZ ~ 6 ELSE 08195000 + SSZ ~ DSZ 08196000 + END ELSE 08197000 + IF DSZ = 0 THEN DSZ ~ SSZ 08198000 + END#, 08199000 + 08200000 + 08201000 + 08202000 + 08203000 + COMPARECHAR = IF ACHAR ! BCHAR THEN 08204000 + IF ACHAR > BCHAR THEN 08205000 + IF RELATION < 3 OR RELATION=5 THEN ELSE 08206000 + TFFF ~ FALSE 08207000 + ELSE 08208000 + IF RELATION.[46:1]=1 THEN ELSE 08209000 + TFFF ~ FALSE 08210000 + ELSE 08211000 + IF RELATION> 3 THEN ELSE TFFF~FALSE#, 08218000 + SWITCHSOURCE = 08219000 + BEGIN 08220000 + IF SIB = 0 THEN 08221000 + BEGIN 08222000 + IF SOPF THEN 08223000 + BEGIN 08224000 + IF AX.TAG = DOUBL THEN 08225000 + BEGIN 08226000 + 08227000 + JUNK ~ A; 08228000 + A ~ X; 08229000 + X ~ JUNK; 08230000 + END; 08231000 + END ELSE 08232000 + BEGIN 08232100 + AROF ~ FALSE; 08233000 + SIR ~ SIR + 1; 08234000 + END; 08234100 + END; 08235000 + END#, 08236000 + STOREB = BEGIN 08237000 + MOVE (B, M[DBR + DIR]); MEMCYCLE; 08238000 + BROF ~ FALSE; 08239000 + END#, 08240000 + STEPSP = BEGIN 08241000 + SIB ~ 0; 08242000 + SIR ~ SIR ~ 1; 08243000 + END#, 08244000 + STEPDP = BEGIN 08245000 + DIB ~ 0; 08246000 + DIR ~ DIR + 1; 08247000 + END#, 08248000 + SIBLNG = 2 | REAL (SSZ = 6) + 4 | REAL (SSZ = 8)#, 08249000 + DIBLNG = 2 | REAL (DSZ = 6) + 4 | REAL (DSZ = 8)#, 08250000 + TWOTO20 = 1048576#, 08251000 + DYALSIB = 47 - SIB | SSZ#, 08252000 + DYALDIB = 47 - DIB | SSZ#, 08253000 + DYALSET = SIB| SSZ - 1#, 08253100 + DYALSZ = SIB| SSZ #, 08253200 + DYALSIZ = 48 - SIB | SSZ #, 08253300 + BUMPSIB = SIB ~ (SIB + 1) MOD (48 DIV SSZ)#, 08254000 + BUMPDIB = DIB ~ (DIB + 1) MOD (48 DIV SSZ)#, 08255000 + BASE = (IF SOURCE THEN SBR ELSE DBR)#, 08256000 + WORDZ = (IF SOURCE THEN SIR ELSE DIR)#, 08257000 + BYTE = (IF SOURCE THEN SIB ELSE DIB)#, 08258000 + SYZE = (IF SOURCE THEN SSZ ELSE DSZ)#, 08259000 + SETUPEXSF = IF EXSF THEN ELSE 08260000 + IF NOT RNTF THEN 08261000 + BEGIN 08262000 + C ~ SYLLABLE; 08263000 + CX ~ 0; 08264000 + END ELSE 08265000 + STEPPSR (1)#; 08266000 +PROCEDURE ENTEREDIT (TYPE, UPDATE); 08267000 + VALUE TYPE, UPDATE; 08268000 + INTEGER TYPE; 08269000 + BOOLEAN UPDATE; 08270000 + BEGIN 08271000 + DEFINE TABLENTER = TYPE = 3#, 08272000 + SINGLEPOINT = TYPE = 1#, 08273000 + SINGLESHOT = TYPE = 0#; 08274000 + LABEL OC, L1, L2, L3, L4, L5; 08275000 + IF TABLENTER THEN 08276000 + BEGIN 08277000 + ADJ (0,1); 08278000 + IF BX.TAG ! DATADESC THEN 08279000 + BEGIN 08280000 + QF01 ~ 1; 08281000 + JFIF; 08282000 + GO TO OC 08283000 + END; 08284000 + IF BX.PBIT ! 1 THEN 08285000 + BEGIN 08286000 + QF02 ~ 1; 08287000 + JFIF; 08288000 + GO TO OC 08289000 + END; 08290000 + BROF ~ FALSE; 08291000 + TBR ~ B.ADDR; 08292000 + IF B.IBIT = 1 THEN TIR ~ B.INDEX 08293000 + ELSE TIR ~ 0; 08294000 + IF B.SBIT = 1 THEN RNTF ~ TRUE; 08295000 + MOVE (B, C); 08296000 + GO TO L1; 08297000 + END; 08298000 + ADJ (0,1); 08299000 + IF BX.TAG ! SINGL AND BX.TAG ! DOUBL THEN 08300000 + BEGIN 08301000 + IF NOT SCANORXFER THEN 08302000 + BEGIN 08303000 + QF01 ~ 1; 08304000 + JFIF; 08305000 + GO TO OC 08306000 + END ELSE 08307000 + BEGIN MOVE(C,Y); C~ 0&REAL(NOT BOOLEAN(CX~0)) 08308000 + [28:28:20] END 08308100 + END ELSE 08309000 + BEGIN NTGR; IF SDIS = 1 THEN INTOFL; 08310000 + MOVE (C,Y); MOVE (B,C); 08311000 + BROF ~ FALSE; 08312000 + END; 08313000 + 08314000 + IF SINGLEPOINT THEN 08315000 + BEGIN 08316000 + ADJ (0,1); 08317000 + AROF ~ TRUE; 08318000 + MOVE (B,A) 08319000 + END; 08320000 +L1: 08321000 + ADJ (1,1); 08322000 + 08322100 + SPSF ~ A.SBIT; 08323000 + SPRF ~ A.RBIT; 08324000 + DPSF ~ B.SBIT; 08325000 + IF AX.TAG = SINGL OR AX.TAG = DOUBL THEN 08326000 + BEGIN 08327000 + 08328000 + SSZ ~ 0; 08329000 + SIB ~ 0; 08330000 + SOPF ~ TRUE; 08330500 + IF AX.TAG = SINGL THEN MOVE (A,X); 08331000 + GO TO L2 08332000 + END; 08333000 + IF AX.PBIT ! 1 THEN 08334000 + BEGIN QF02 ~ 1; GO TO L3 END; 08335000 + SBR ~ A.ADDR; 08336000 + SSZ ~ IF A.SZ = 0 THEN 6 ELSE 2|A.SZ; 08337000 + SIB ~ 0; 08338000 + IF A.IBIT ! 0 THEN 08339000 + BEGIN 08340000 + IF A.SZ ! 0 THEN 08341000 + BEGIN 08342000 + SIB ~ A.[8:4]; 08343000 + SIR ~ A.[12:16]; 08344000 + END 08345000 + ELSE 08346000 + SIR ~ A.INDEX 08347000 + END ELSE 08348000 + SIR ~ 0; 08349000 + 08350000 + AROF ~ FALSE; 08351000 + L2: IF SWPS = 1 THEN GO TO L5; 08352000 + IF BX.TAG ! DATADESC THEN 08353000 + BEGIN 08354000 + L4: 08355000 + QF01 ~ 1; 08356000 + L3: 08357000 + IF SINGLEPOINT THEN 08358000 + BROF ~ FALSE; 08359000 + AROF ~ TRUE; 08359500 + ADJ (0,0); 08360000 + MOVE (Y,A); 08360500 + IF TABLENTER THEN AROF ~ TRUE ELSE 08361000 + BEGIN 08361500 + MOVE (C,B); 08362000 + BROF ~ TRUE; 08362500 + IF FWDT = 1 THEN AROF ~ TRUE; 08363000 + END; 08363500 + JFIF; 08364000 + GO TO OC 08365000 + END; 08366000 + IF BX.PBIT ! 1 THEN 08367000 + BEGIN QF02 ~ 1; GO TO L3 END; 08367500 + DBR ~ B.ADDR; 08368000 + DSZ ~ IF B.SZ=0 THEN 6 ELSE 2|B.SZ; 08368500 + IF AX.TAG = DATADESC THEN 08369000 + BEGIN 08369500 + IF NOT XLATE THEN 08370000 + BEGIN 08370500 + IF SSZ ! DSZ THEN GO TO L4 08371000 + END; 08371500 + END; 08372000 + IF NOT XFERWD THEN 08373000 + BEGIN 08374000 + IF B.RBIT = 1 THEN 08375000 + BEGIN 08376000 + QF03 ~ 1; 08377000 + GO TO L3 08378000 + END; 08379000 + END; 08380000 + L5: DBR ~ B.ADDR; 08380500 + DSZ ~ IF B.SZ = 0 THEN 6 ELSE 2 | B.SZ; 08380600 + DIB ~ 0; 08381000 + IF B.IBIT ! 0 THEN 08382000 + BEGIN 08383000 + IF B.SZ ! 0 THEN 08384000 + BEGIN 08385000 + DIB ~ B.[8:4]; 08386000 + DIR ~ B.[12:16] 08387000 + END ELSE 08388000 + DIR ~ B.INDEX 08389000 + END ELSE 08390000 + DIR ~ 0; 08391000 + BROF ~ FALSE; 08392000 + IF UPDATE THEN UPDF ~ TRUE; 08393000 + IF NOT TABLENTER THEN EXSF ~ ESPF ~ TRUE 08394000 + ELSE 08395000 + BEGIN 08396000 + TEEF ~ TRUE; PSR ~ C.[38:3] 08397000 + END; 08398000 + OC: 08399000 + END ENTEREDIT; 08400000 +PROCEDURE XFERWDS (UPDATE,OVERITE); 08400010 + VALUE UPDATE, OVERITE; 08400020 + BOOLEAN UPDATE, OVERITE; 08400030 + BEGIN 08400040 + LABEL OC, L1; 08400050 + XFERWD ~ OVERITE; 08400055 + ENTEREDIT (0,UPDATE); 08400060 + IF SIB ! 0 THEN STEPSP; 08400070 + IF DIB ! 0 THEN STEPDP; 08400080 + IF C.ADDR > 0 THEN 08400090 + BEGIN 08400100 + RPF ~ C.ADDR; 08400110 + WHILE (RPF ~ RPF - 1) } 0 DO 08400120 + BEGIN 08400130 + IF SOPF THEN ELSE 08400140 + BEGIN 08400150 + MM ~ SBR ~ SIR; 08400160 + MOVE (M[MM], A); MEMCYCLE; 08400170 + IF NOT OVERITE THEN 08400180 + IF BOOLEAN (AX.TAG) THEN GO L1;08400190 + END; 08400200 + MM ~ DBR ~ DIR; 08400210 + MOVE (M[MM], C); 08400220 + IF NOT OVERITE THEN 08400230 + BEGIN 08400240 + IF BOOLEAN (CX.TAG) THEN GO TO L1;08400250 + END; 08400260 + MOVE (A, M[MM]); MEMCYCLE; 08400270 + IF SOPF THEN 08400280 + BEGIN 08400290 + IF AX.TAG ! SINGL THEN 08400300 + BEGIN 08400310 + MOVE (A, JUNK); 08400320 + MOVE (X, A); 08400330 + MOVE (JUNK, A); 08400340 + END 08400350 + END ELSE 08400360 + SIR ~ SIR + 1; 08400370 + DIR ~ DIR + 1; 08400380 + END; 08400390 + END; 08400400 + ENDE; GO TO OC; 08400500 + L1: 08400600 + UPDF ~ TRUE; 08400700 + ENDE; 08400750 + QF04 ~ 1; 08400800 + JGIF; 08400850 + 08400900 + OC: 08400950 + END XFERWDS; 08401000 +PROCEDURE XFERWHILE (UPDATE,RELATION); 08402000 + VALUE UPDATE, RELATION; 08403000 + BOOLEAN UPDATE; 08404000 + INTEGER RELATION; 08405000 + BEGIN 08406000 + REAL ACHAR, BCHAR; 08407000 + LABEL OC, L1, L2, L3, L4; 08408000 + ADJ (1,1); 08409000 + IF AX.TAG ! SINGL THEN 08410000 + BEGIN 08411000 + QF01 ~ 1; 08412000 + JFIF; 08413000 + GO TO OC 08414000 + END; 08415000 + MOVE (A, C); 08416000 + AROF ~ FALSE; SCANORXFER ~ TRUE; XFERW ~ TRUE; 08417000 + ENTEREDIT (0, UPDATE); 08418000 + CHARSZ; 08419000 + DYAL (Y, BCHAR, SSZ-1, SSZ-1, SSZ); 08420000 + TFFF ~ TRUE; 08420500 + RPF ~ C.ADDR; 08421000 + IF C.ADDR = 0 THEN 08422000 + BEGIN 08423000 + ENDE; GO TO OC; 08424000 + END; 08425000 + L1: FETCHSOURCE; 08426000 + FETCHDESTINATION; 08427000 + 08428000 + DYAL (A, ACHAR, DYALSIB, SSZ-1, SSZ); 08429000 + COMPARECHAR; 08430000 + IF TFFF THEN 08431000 + BEGIN 08432000 + DYAL (A, B, DYALSIB, DYALDIB, SSZ); 08433000 + RPF ~ RPF - 1; 08434000 + IF RPF = 0 THEN QH03 ~ 1 ELSE 08435000 + L2: BEGIN 08436000 + BUMPSIB; 08437000 + SWITCHSOURCE; 08438000 + BUMPDIB; 08439000 + IF DIB = 0 THEN 08440000 + BEGIN 08440010 + STOREB; DIR ~ DIR + 1 08440020 + END; 08440030 + IF QH03 = 0 THEN GO TO L1; 08440040 + IF UPDF THEN GO TO L3 ELSE GO TO L4; 08440050 + END; 08440060 + END; 08440070 + STOREB; 08440080 + IF TFFF THEN GO TO L2; 08440090 + L3: ENDE; 08440100 + ADJ (0,2); 08440110 + A ~ RPF; AX ~ 0; 08440120 + AROF ~ TRUE; 08440130 + GO TO OC; 08440140 + L4: ENDE; 08440150 + OC: SCANORXFER ~ FALSE; XFERW ~ FALSE; 08440160 + END XFERWHILE; 08440170 +PROCEDURE TWSD; % TRANSFER WORDS, DESTRUCTIVE 08440180 + BEGIN P2R3 ~ 1; 08440190 + XFERWDS (FALSE, FALSE); P2R3 ~ 0; 08440200 + END TWSD; 08440210 +PROCEDURE TWSU; % TRANSFER WORDS, UPDATE 08440220 + BEGIN P2R3 ~ 1; 08440230 + XFERWDS (TRUE, FALSE); P2R3 ~ 0; 08440240 + END TWSU; 08440250 +PROCEDURE TWOD; % TRANSFER WORDS OVERWRITE, DESTRUCTIVE 08440260 + BEGIN P2R3 ~ 1; 08440270 + XFERWDS (FALSE, TRUE); P2R3 ~ 0; 08440280 + END TWOD; 08440290 +PROCEDURE TWOU; % TRANSFER WORDS OVERWRITE, UPDATE 08440300 + BEGIN P2R3 ~ 1; 08440310 + XFERWDS (TRUE, TRUE); P2R3 ~ 0; 08440320 + END TWOU; 08440330 +PROCEDURE TGTD; % TRANSFER WHILE GREATER, DESTRUCTIVE 08440340 + BEGIN P2R4 ~ 1; FWDT ~ 1; 08440350 + XFERWHILE (FALSE, 1); P2R4 ~ 0; FWDT ~ 0; 08440360 + END TGTD; 08440370 +PROCEDURE TGTU; % TRANSFER WHILE GREATER, UPDATE 08440380 + BEGIN P2R4 ~ 1; FWDT ~ 1; 08440390 + XFERWHILE (TRUE, 1); P2R4 ~ 0; FWDT ~ 0; 08440400 + END TGTU; 08440500 +PROCEDURE TGED; % TRANSFER WHILE GREATER OR EQUAL, DESTRUCTIVE 08440600 + BEGIN P2R4 ~ 1; FWDT ~ 1; 08440700 + XFERWHILE (FALSE, 5); P2R4 ~ 0; FWDT ~ 0; 08440800 + END TGED; 08440900 +PROCEDURE TGEU; % TRANSFER WHILE GREATER OR EQUAL, UPDATE 08441000 + BEGIN P2R4 ~ 1; FWDT ~ 1; 08441100 + XFERWHILE (TRUE, 5); P2R4 ~ 0; FWDT ~ 0; 08441200 + END TGEU; 08441300 +PROCEDURE TEQD; % TRANSFER WHILE EQUAL, DESTRUCTIVE 08441400 + BEGIN P2R4 ~ 1; FWDT ~ 1; 08441500 + XFERWHILE (FALSE, 4); P2R4 ~ 0; FWDT ~ 0; 08441600 + END TEQD; 08441700 +PROCEDURE TEQU; % TRANSFER WHILE EQUAL, UPDATE 08441800 + BEGIN P2R4 ~ 1; FWDT ~ 1; 08441900 + XFERWHILE (TRUE, 4); P2R4 ~ 0; FWDT ~ 0; 08442000 + END TEQU; 08442100 +PROCEDURE TLED; % TRANSFER WHILE LESS OR EQUAL, DESTRUCTIVE 08442200 + BEGIN P2R4 ~ 1; FWDT ~ 1; 08442300 + XFERWHILE (FALSE, 6); P2R4 ~ 0; FWDT ~ 0; 08442400 + END TLED; 08442500 +PROCEDURE TLEU; % TRANSFER WHILE LESS OR EQUAL, UPDATE 08442600 + BEGIN P2R4 ~ 1; FWDT ~ 1; 08442700 + XFERWHILE (TRUE, 6); P2R4 ~ 0; FWDT ~ 0; 08442800 + END TLEU; 08442900 +PROCEDURE TLSD; % TRANSFER WHILE LESS, DESTRUCTIVE 08443000 + BEGIN P2R4 ~ 1; FWDT ~ 1; 08444000 + XFERWHILE (FALSE, 3); P2R4 ~ 0; FWDT ~ 0; 08445000 + END TLSD; 08446000 +PROCEDURE TLSU; % TRANSFER WHILE LESS, UPDATE 08447000 + BEGIN P2R4 ~ 1; FWDT ~ 1; 08448000 + XFERWHILE (TRUE, 3); P2R4 ~ 0; FWDT ~ 0; 08448500 + END TLSU; 08449000 +PROCEDURE TNED; % TRANSFER WHILE NOT EQUAL, DESTRUCTIVE 08449500 + BEGIN P2R4 ~ 1; FWDT ~ 1; 08450000 + XFERWHILE (FALSE, 2); P2R4 ~ 0; FWDT ~ 0; 08451000 + END TNED; 08452000 +PROCEDURE TNEU; % TRANSFER WHILE NOT EQUAL, UPDATE 08453000 + BEGIN P2R4 ~ 1; FWDT ~ 1; 08454000 + XFERWHILE (TRUE, 2); P2R4 ~ 0; FWDT ~ 0; 08455000 + END TNEU; 08456000 +DEFINE MEMPROT = MEMPRO #; 08456500 +PROCEDURE XFERWHILETF(TOGLE,UPDATE); 08457000 + VALUE TOGLE,UPDATE; 08458000 + BOOLEAN TOGLE,UPDATE; 08459000 + BEGIN 08460000 + LABEL OC,L12,L13,L14,L100,L1; 08461000 + BOOLEAN LHFF; 08461100 + ADJ (1,2); 08462000 + IF AX.TAG ! DATADESC THEN 08463000 + BEGIN 08464000 + QF01 ~ 1; 08465000 + L1: JFIF; 08466000 + GO OC; 08467000 + END; 08468000 + IF AX.PBIT = 0 THEN 08469000 + BEGIN 08470000 + QF02 ~ 1; 08471000 + 08472000 + GO L1; 08473000 + END; 08474000 + IF A.IBIT ! 1 THEN TIR ~ 0 ELSE 08475000 + TIR ~ IF A.SZ=0 THEN A.[12:16] ELSE A.INDEX; 08476000 + TBR ~ A.ADDR + TIR; 08477000 + MOVE(A,C); 08478000 + AROF ~ FALSE; 08479000 + IF UPDATE THEN EXSU ELSE EXSD; 08480000 + CHARSZ; 08481000 + IF RPF ~ C.ADDR = 0 THEN BEGIN ENDE; GO OC END; 08482000 + QH03 ~ 1; 08483000 + TFFF ~ TRUE; 08484000 + L12: 08484100 + FETCHSOURCE; 08485000 + IF QH03 = 1 THEN QH03 ~ 0; 08486000 + L13: FETCHDESTINATION; 08487000 + L14: 08488000 + MM ~ DIS ~ 0; 08489000 + DYAL(A,MM,DYALSIB,2|REAL(SSZ=8),REAL(SSZ!4)+2|REAL(SSZ=8)); 08490000 + MM ~ MM ~ TBR; 08491000 + DYAL(A,DIS,DYALSIB+1+2|REAL(SSZ=8),4-REAL(SSZ=4), 08492000 + 5-REAL(SSZ=4)); 08493000 + MOVE(M[MM],Y); MEMCYCLE; 08494000 + IF BOOLEAN(YX.TAG) THEN MEMPROTECT; 08495000 + DYAL(Y,AA,DIS,0,1); 08496000 + Q03F ~ REAL(TFFF~ BOOLEAN(AA) EQV TOGLE); 08497000 + IF Q03F=1 THEN DYAL(A,B,DYALSIB,DYALDIB,SSZ); 08498000 + RPF ~ RPF -1; 08499000 + IF RPF = 0 THEN 08500000 + BEGIN 08501000 + LHFF ~ TRUE; 08502000 + STOREB; 08503000 + IF TFFF THEN 08504000 + BEGIN 08505000 + L100: 08506000 + ENDE; 08507000 + ADJ(0,2); 08508000 + A ~ RPF; AX ~ 0; 08509000 + AROF ~ TRUE; 08510000 + GO OC; 08511000 + END; 08512000 + END; 08513000 + BUMPSIB; 08514000 + SWITCHSOURCE; 08514100 + IF BUMPDIB=0 THEN 08514200 + BEGIN 08514300 + STOREB; 08514400 + STEPDP; 08514500 + END; 08514600 + IF LHFF THEN IF UPDF THEN BEGIN ENDE; GO OC END ELSE GO L100; 08514700 + IF SIB=0 THEN GO L12; 08514800 + GO L13; 08514900 + OC: 08515000 + END OF TRANSFER ; 08516000 +PROCEDURE TWTD; % TRANSFER WHILE TRUE, DESTRUCTIVE 7.1.19 08517000 + BEGIN 08518000 + XFERWHILETF( TRUE , FALSE); % TRUE DESTRUCTIVE 08519000 + END TWTD; 08520000 +PROCEDURE TWTU ; % TRANSFER WHILE TRUE, UPDATE 7.1.20 08521000 + BEGIN 08522000 + XFERWHILETF( TRUE , TRUE ); % TRUE UPDATE 08523000 + END TWTU; 08524000 +PROCEDURE TWFD ; % TRANSFER WHILE FALSE, DESTRUCTIVE 7.1.21 08525000 + BEGIN 08526000 + XFERWHILETF( FALSE, FALSE); % FALSE DESTRUCTIVE 08527000 + END TWFD; 08528000 +PROCEDURE TWFU ; % TRANSFER WHILE FALSE, UPDATE 7.1.22 08529000 + BEGIN 08530000 + XFERWHILETF( FALSE, TRUE ); % FALSE UPDATE 08531000 + END TWFU; 08532000 +PROCEDURE TUND ; % TRANSFER UNCONDITIONAL , DESTRUCTIVE 7.1.23 08533000 + BEGIN 08534000 + ADJ(0,2); 08535000 + A ~ AX ~ 0; 08536000 + AROF ~ TRUE; 08537000 + XFERWHILE(FALSE,5); 08538000 + END TUND; 08539000 +PROCEDURE TUNU ; % TRANSFER UNCONDITIONAL , UPDATE 7.1.24 08540000 + BEGIN 08541000 + ADJ(0,2); 08542000 + A~AX~0; 08543000 + AROF~TRUE; 08544000 + XFERWHILE(TRUE,5); 08545000 + END TUNU; 08546000 +PROCEDURE SCANWHILE(UPDATE,RELATION); 08547000 + VALUE UPDATE,RELATION; 08548000 + BOOLEAN UPDATE; 08549000 + INTEGER RELATION; 08550000 + BEGIN 08551000 + REAL ACHAR, BCHAR; 08552000 + LABEL OC, L1, L2; 08553000 + ADJ(1,1); 08553500 + IF AX.TAG ! SINGL THEN 08554000 + BEGIN 08554500 + QF01 ~ 1; 08555000 + JFIF; 08555500 + GO TO OC; 08556000 + END; 08556500 + MOVE(A,C); 08557000 + AROF ~ FALSE; SCANORXFER ~ TRUE; SCANWH ~ TRUE; 08557500 + ENTEREDIT(1,UPDATE); 08558000 + IF SSZ = 0 THEN SSZ ~ 6; 08558500 + DYAL(Y,BCHAR, SSZ - 1, SSZ - 1, SSZ); 08559000 + TFFF ~ TRUE; 08559500 + IF C.ADDR = 0 THEN GO TO L2; 08560000 + L1: FETCHSOURCE; 08561000 + 08562000 + DYAL (A, ACHAR,DYALSIB, SSZ - 1, SSZ); 08563000 + COMPARECHAR; 08564000 + IF NOT TFFF THEN ELSE 08565000 + BEGIN 08566000 + RPF ~ RPF - 1; 08567000 + IF RPF = 0 THEN LHFF ~ 1; 08568000 + BUMPSIB; 08569000 + SWITCHSOURCE; 08570000 + IF LHFF ! 1 THEN GO TO L1; 08571000 + L2: IF NOT UPDF THEN 08572000 + BEGIN 08572100 + ENDE; 08573000 + GO TO OC; 08574000 + END; 08574100 + END; 08575000 + ENDE; 08576000 + ADJ(0,2); 08577000 + A ~ RPF; AX ~ 0; 08578000 + AROF ~ TRUE; 08579000 + OC: SCANORXFER~ SCANWH ~ FALSE; 08580000 + END OF SCANWHILE; 08581000 +PROCEDURE SGTD ; % SCAN WHILE GREATER, DESTRUCTIVE 7.2.1 08582000 + BEGIN P2R3 ~ 1; FWDT ~ 1; 08583000 + SCANWHILE ( FALSE , 1 ); 08584000 + END SGTD; 08585000 +PROCEDURE SGTU ; % SCAN WHILE GREATER, UPDATE 7.2.2 08586000 + BEGIN P2R3 ~ 1; FWDT ~ 1; 08587000 + SCANWHILE ( TRUE , 1 ); 08588000 + END SGTU; 08589000 +PROCEDURE SGED ; % SCAN WHILE GREATER OR EQUAL, DESTRUCTIVE7.2.3 08590000 + BEGIN P2R3 ~ 1; FWDT ~ 1; 08591000 + SCANWHILE ( FALSE , 5 ); 08592000 + END SGED; 08593000 +PROCEDURE SGEU ; % SCAN WHILE GREATER OR EQUAL, UPDATE 7.2.4 08594000 + BEGIN P2R3 ~ 1; FWDT ~ 1; 08595000 + SCANWHILE ( TRUE , 5 ); 08596000 + END SGEU; 08597000 +PROCEDURE SEQD ; % SCAN WHILE EQUAL, DESTRUCTIVE 7.2.5 08598000 + BEGIN P2R3 ~ 1; FWDT ~ 1; 08599000 + SCANWHILE ( FALSE , 4 ); 08600000 + END SEQD; 08601000 +PROCEDURE SEQU ; % SCAN WHILE EQUAL, UPDATE 7.2.6 08602000 + BEGIN P2R3 ~ 1; FWDT ~ 1; 08603000 + SCANWHILE ( TRUE , 4 ); 08604000 + END SEQU; 08605000 +PROCEDURE SLED ; % SCAN WHILE LESS OR EQUAL, DESTRUCTIVE 7.2.7 08606000 + BEGIN P2R3 ~ 1; FWDT ~ 1; 08607000 + SCANWHILE ( FALSE , 6 ); 08608000 + END SLED; 08609000 +PROCEDURE SLEU ; % SCAN WHILE LESS OR EQUAL, UPDATE 7.2.8 08610000 + BEGIN P2R3 ~ 1; FWDT ~ 1; 08611000 + SCANWHILE ( TRUE , 6 ); 08612000 + END SLEU; 08613000 +PROCEDURE SLSD ; % SCAN WHILE LESS, DESTRUCTIVE 7.2.9 08614000 + BEGIN P2R3 ~ 1; FWDT ~ 1; 08615000 + SCANWHILE ( FALSE , 3 ); 08616000 + END SLSD; 08617000 +PROCEDURE SLSU ; % SCAN WHILE LESS, UPDATE 7.2.10 08618000 + BEGIN P2R3 ~ 1; FWDT ~ 1; 08619000 + SCANWHILE ( TRUE , 3 ); 08620000 + END SLSU; 08621000 +PROCEDURE SNED ; % SCAN WHILE NOT EQUAL, DESTRUCTIVE 7.2.11 08622000 + BEGIN P2R3 ~ 1; FWDT ~ 1; 08623000 + SCANWHILE ( FALSE , 2 ); 08624000 + END SNED; 08625000 +PROCEDURE SNEU ; % SCAN WHILE NOT EQUAL, UPDATE 7.2.12 08626000 + BEGIN P2R3 ~ 1; FWDT ~ 1; 08627000 + SCANWHILE ( TRUE , 2 ); 08628000 + END SNEU; 08629000 +PROCEDURE SCANWHILETF(TOGLE,UPDATE); 08630000 + VALUE TOGLE,UPDATE; 08631000 + BOOLEAN TOGLE,UPDATE; 08632000 + BEGIN 08633000 + LABEL OC,L8 ,L100,L21; 08634000 + BOOLEAN LHFF; 08634100 + ADJ(1,2); 08635000 + IF AX.TAG! DATADESC THEN 08636000 + BEGIN 08637000 + QF01 ~ 1; 08638000 + L21: 08639000 + JFIF; 08640000 + GO OC; 08641000 + END; 08642000 + IF AX.PBIT=0 THEN 08643000 + BEGIN 08644000 + QF02~1; 08644100 + GO L21; 08644200 + END; 08644300 + AROF ~ FALSE; 08645000 + IF NOT(BOOLEAN(A.IBIT)) THEN TIR~0 ELSE 08646000 + TIR ~ IF A.CHRSZ = 0 THEN A.INDEX ELSE A.TIRF; 08647000 + TIR~A.ADDR+TIR; 08648000 + ENTEREDIT(1,UPDATE); 08649000 + IF SSZ = 0 THEN SSZ ~ 6; 08650000 + RPF ~ C.ADDR; 08651000 + IF RPF =0 THEN 08652000 + BEGIN 08653000 + L100: 08654000 + ENDE; 08655000 + ADJ(0,2); 08656000 + A ~RPF; AX ~ 0; 08657000 + AROF ~ TRUE; 08658000 + GO OC; 08659000 + END; 08660000 + TFFF ~ TRUE; 08661000 + L8: 08662000 + FETCHSOURCE; 08663000 + MM ~ DIS ~ 0; 08664000 + DYAL(A,MM,DYALSIB,2|REAL(SSZ=8),REAL(SSZ!4)+2|REAL(SSZ=4)); 08665000 + MOVE(M[MM],Y); MEMCYCLE; 08666000 + IF BOOLEAN(YX.TAG) THEN MEMPROTECT; 08667000 + DYAL(Y,AA,DIS,0,1); 08668000 + Q03F ~ REAL(TFFF~BOOLEAN(AA) EQV TOGLE); 08669000 + IF Q03F=0 THEN BEGIN TFFF~FALSE; GO L100 END; 08670000 + RPF ~ RPF -1; 08671000 + IF RPF = 0 THEN LHFF ~ TRUE; 08672000 + BUMPSIB; SWITCHSOURCE; 08673000 + IF LHFF THEN IF UPDF THEN GO L100 ELSE BEGIN ENDE; GO OC END; 08674000 + GO TO L8; 08675000 + 08676000 + OC: 08677000 + END OF SCAN ; 08678000 +PROCEDURE SWTD ; % SCAN WHILE TRUE, DESTRUCTIVE 7.2.13 08679000 + BEGIN 08680000 + SCANWHILETF( TRUE , FALSE); % TRUE DESTRUCTIVE 08681000 + END SWTD; 08682000 +PROCEDURE SWTU ; % SCAN WHILE TRUE, UPDATE 7.2.14 08683000 + BEGIN 08684000 + SCANWHILETF( TRUE , TRUE ); % TRUE UPDATE 08685000 + END SWTU; 08686000 +PROCEDURE SWFD ; % SCAN WHILE FALSE, DESTRUCTIVE 7.2.15 08687000 + BEGIN 08688000 + SCANWHILETF( FALSE, FALSE); % FALSE DESTRUCTIVE 08689000 + END SWFD; 08690000 +PROCEDURE SWFU ; % SCAN WHILE FALSE, UPDATE 7.2.16 08691000 + BEGIN 08692000 + SCANWHILETF( FALSE, TRUE ); % FALSE UPDATE 08693000 + END SWFU; 08694000 +PROCEDURE COMPARECHRS(UPDATE,RELATION); 08695000 + VALUE UPDATE,RELATION; 08696000 + BOOLEAN UPDATE; 08697000 + INTEGER RELATION; 08698000 + BEGIN 08699000 + INTEGER ACHAR, BCHAR; 08700000 + LABEL OC, L1; 08701000 + ENTEREDIT(0,UPDATE); 08702000 + CHARSZ; 08703000 + RPF ~ C.ADDR; 08704000 + IF RPF = 0 THEN 08705000 + BEGIN 08706000 + ENDE; 08707000 + GO TO OC; 08708000 + END; 08709000 + L1: TFFF ~ TRUE; 08710000 + FETCHSOURCE; 08711000 + FETCHDESTINATION; 08712000 + DYAL(A,BCHAR,DYALSIB, SSZ - 1, SSZ); 08713000 + DYAL(B, ACHAR, DYALDIB, SSZ - 1, SSZ); 08714000 + COMPARECHAR; 08715000 + RPF ~ RPF - 1; 08716000 + BUMPSIB; 08717000 + SWITCHSOURCE; 08718000 + IF BUMPDIB = 0 THEN 08719000 + BEGIN 08720000 + STEPDP; 08721000 + BROF ~ FALSE; 08722000 + END; 08723000 + IF RPF = 0 THEN 08724000 + BEGIN 08725000 + BROF ~ FALSE; 08726000 + ENDE; 08727000 + GO TO OC; 08728000 + END; 08729000 + GO TO L1; 08730000 + OC: 08730500 + END OF COMPARE CHARACTERS; 08731000 +PROCEDURE CGTD ; % COMPARE CHARACTERS GREATER, DESTRUCTIVE 7.3.1 08732000 + BEGIN P2R3 ~ 1; 08733000 + COMPARECHRS( FALSE , 1 ); % DESTRUCTIVE GREATER 08734000 + END CGTD; 08735000 +PROCEDURE CGTU ; % COMPARE CHARACTERS GREATER, UPDATE 7.3.2 08736000 + BEGIN P2R3 ~ 1; 08737000 + COMPARECHRS( TRUE , 1 ); % UPDATE GREATER 08738000 + END CGTU; 08739000 +PROCEDURE CGED ; % COMPARE CHARACTERS GREATER OR EQUAL, DST7.3.3 08740000 + BEGIN P2R3 ~ 1; 08741000 + COMPARECHRS( FALSE , 5 ); % DESTRUCTIVE GREATER EQUAL 08742000 + END CGED; 08743000 +PROCEDURE CGEU ; % COMPARE CHARACTERS GREATER OR EQUAL, UPD7.3.4 08744000 + BEGIN P2R3 ~ 1; 08745000 + COMPARECHRS( TRUE , 5 ); % UPDATE GREATER EQUAL 08746000 + END CGEU; 08747000 +PROCEDURE CEQD ; % COMPARE CHARACTERS EQUAL, DESTRUCTIVE 7.3.5 08748000 + BEGIN P2R3 ~ 1; 08749000 + COMPARECHRS( FALSE , 4 ); % DESTRUCTIVE EQUAL 08750000 + END CEQD; 08751000 +PROCEDURE CEQU ; % COMPARE CHARACTERS EQUAL, UPDATE 7.3.6 08752000 + BEGIN P2R3 ~ 1; 08753000 + COMPARECHRS( TRUE , 4 ); % UPDATE EQUAL 08754000 + END CEQU; 08755000 +PROCEDURE CLED ; % COMPARE CHARACTERS LESS OR EQUAL, DST 7.3.7 08756000 + BEGIN P2R3 ~ 1; 08757000 + COMPARECHRS( FALSE , 6 ); % DESTRUCTIVE LESS EQUAL 08758000 + END CLED; 08759000 +PROCEDURE CLEU ; % COMPARE CHARACTERS LESS OR EQUAL, UPD 7.3.8 08760000 + BEGIN P2R3 ~ 1; 08761000 + COMPARECHRS( TRUE , 6 ); % UPDATE LESS EQUAL 08762000 + END CLEU; 08763000 +PROCEDURE CLSD ; % COMPARE CHARACTERS LESS, DESTRUCTIVE 7.3.9 08764000 + BEGIN P2R3 ~ 1; 08765000 + COMPARECHRS( FALSE , 3 ); % DESTRUCTIVE LESS 08766000 + END CLSD; 08767000 +PROCEDURE CLSU ; % COMPARE CHARACTERS LESS, UPDATE 7.3.10 08768000 + BEGIN P2R3 ~ 1; 08769000 + COMPARECHRS( TRUE , 3 ); % UPDATE LESS 08770000 + END CLSU; 08771000 +PROCEDURE CNED ; % COMPARE CHARACTERS NOT EQUAL, DESTRUCTVE7.3.11 08772000 + BEGIN P2R3 ~ 1; 08773000 + COMPARECHRS( FALSE , 2 ); % DESTRUCTIVE NOT EQUAL 08774000 + END CNED; 08775000 +PROCEDURE CNEU ; % COMPARE CHARACTERS NOT EQUAL, UPDATE 7.3.12 08776000 + BEGIN P2R3 ~ 1; 08777000 + COMPARECHRS( TRUE , 2 ); % UPDATE NOT EQUAL 08778000 + END CNEU; 08779000 + DEFINE RPZF = BKIP#; 08779500 +PROCEDURE UNPACKS(SIGNED,UPDATE); 08780000 + VALUE SIGNED,UPDATE; 08781000 + BOOLEAN SIGNED,UPDATE; 08782000 + BEGIN 08783000 + LABEL OC, L1, L2, L3, L4, L5, L6, L7, L8; 08784000 + INTEGER RITEJUSTIFY; 08784500 + ADJ (1,1); 08785000 + IF BX.TAG = SINGL OR BX.TAG = DOUBL THEN ELSE 08785500 + BEGIN 08786000 + QF01 ~ 1; 08786500 + JFIF; 08787000 + GO TO OC; 08787500 + END; 08788000 + ENTEREDIT (0, UPDATE); 08788500 + RPF ~ C.ADDR; 08789000 + IF C.ADDR > 24 THEN 08789500 + BEGIN 08790000 + BROF ~ TRUE; 08790500 + QF01 ~ 1; 08791000 + JFIF; 08791500 + GO TO OC; 08792000 + END; 08792500 + SSZ ~ 4; 08793000 + IF DSZ = 0 THEN DSZ ~ 6; 08793500 + IF RPF = 0 THEN 08794000 + BEGIN 08794500 + ENDE; GO TO OC; 08795000 + END; 08795500 + IF RPF = 1 THEN LHFF ~ 1; 08796000 + IF DSZ = 4 THEN RPZF ~ 1; 08796500 + L4: FETCHDESTINATION; 08797000 + L7: IF DSZ = 4 THEN GO TO L1; 08797500 + IF DSZ = 6 THEN GO TO L2; 08798000 + IF NOT SIGNED THEN ELSE 08798500 + IF LHFF ! 1 THEN ELSE 08799000 + IF EXTF THEN 08799500 + BEGIN 08800000 + RITEJUSTIFY.[40:4] ~ 32; 08800500 + GO TO L3; 08801000 + END; 08801500 + RITEJUSTIFY.[40:4] ~ 36; 08802000 + L3: DYAL (RITEJUSTIFY, B, 40, DYALDIB, 4); 08802500 + DYAL (A, B, DYALSIB, (DYALDIB - 4), 4); 08803000 + GO TO L8; 08803500 + L2: IF NOT SIGNED THEN ELSE 08804000 + IF LHFF ! 1 THEN ELSE 08804500 + IF EXTF THEN 08805000 + BEGIN 08805500 + RITEJUSTIFY.[42:2] ~ 2; 08806000 + GO TO L6; 08806500 + END; 08807000 + RITEJUSTIFY.[42:2] ~ 0; 08807500 + L6: DYAL (RITEJUSTIFY, B, 42, DYALDIB, 2); 08808000 + DYAL (A, B, DYALSIB, (DYALDIB - 2), 4); 08808500 + GO TO L8; 08809000 + L1: IF SIGNED THEN 08809500 + BEGIN 08810000 + IF RPZF = 1 THEN 08810500 + BEGIN 08811000 + IF EXTF THEN RITEJUSTIFY ~ 14 ELSE 08811500 + RITEJUSTIFY ~ 15; 08812000 + DYAL(RITEJUSTIFY,B,3,DYALDIB,4); 08812500 + GO TO L5; 08813000 + END; 08813500 + END; 08814000 + DYAL (A, B, DYALSIB, DYALDIB, 4); 08815000 + L8: BUMPSIB; 08816000 + L5: IF BUMPDIB = 0 THEN 08817000 + BEGIN 08818000 + STOREB; 08819000 + STEPDP; 08820000 + END; 08821000 + BEGIN 08822000 + IF AX.TAG = DOUBL THEN 08822500 + BEGIN 08823000 + MOVE (A, JUNK); 08823500 + MOVE (X, A); 08823800 + MOVE (JUNK, X); 08824000 + END; 08824400 + END; 08824800 + IF RPZF = 1 THEN RPZF ~ 0 ELSE 08825000 + RPF ~ RPF - 1; 08825500 + IF RPF = 0 THEN 08826000 + BEGIN 08827000 + IF DIB ! 0 THEN BROF ~ TRUE; 08828000 + ENDE; 08828500 + GO TO OC; 08829000 + END; 08830000 + IF RPF = 1 THEN LHFF ~ 1; 08831000 + IF DIB = 0 THEN GO TO L4; 08832000 + GO TO L7; 08833000 + OC: 08834000 + END OF UNPACKS; 08835000 +PROCEDURE PACKS (UPDATE); 08835100 + VALUE UPDATE; 08835200 + BOOLEAN UPDATE; 08835300 + BEGIN 08835400 + LABEL OC, L1, L2, L3; 08835500 + ENTEREDIT (1, UPDATE); 08835600 + RPF ~ C.ADDR; 08835700 + IF C.ADDR > 24 THEN 08835800 + BEGIN 08835900 + AROF ~ TRUE; 08836000 + QF01 ~ 1; 08836100 + JFIF; 08836200 + GO TO OC; 08836300 + END; 08836400 + IF C.ADDR = 0 THEN 08836500 + BEGIN 08836600 + ENDE; 08836700 + GO TO OC; 08836800 + END; 08836900 + TFFF~BOOLEAN(B~BX~0); 08836910 + IF RPF > 12 THEN 08837000 + BEGIN 08837100 + BX.TAG ~ DOUBL; 08837200 + QH02 ~ 1; 08837300 + DIB ~ 24 -RPF; 08837400 + END ELSE 08837500 + DIB ~ 12 -RPF; 08837600 + DSZ ~ 4; 08837700 + IF SSZ = 0 THEN 08837800 + BEGIN 08837900 + SSZ ~ 6; 08838000 + MOVE (A, Y); 08838100 + END; 08838200 + QH03 ~ 1; 08838300 + IF NOT SOPF THEN 08838400 + BEGIN 08838500 + L1: MM ~ SBR + SIR; 08838600 + MOVE (M[MM], A); 08838700 + IF BOOLEAN (AX.TAG) THEN 08838800 + BEGIN 08838900 + MOVE (Y, A); 08839000 + MOVE (C, B); 08839100 + AROF ~ BROF ~ TRUE; 08839200 + QF04 ~ 1; 08839300 + JFIF; 08839400 + GO TO OC; 08839500 + END; 08839600 + END; 08839700 + L3: IF SSZ ! 4 THEN 08839800 + BEGIN 08839900 + IF SSZ = 6 THEN 08840000 + BEGIN DYAL(A,B,DYALSIB-2,DYALDIB,4); 08840100 + DYAL(A,INTG,DYALSIB,0,1); TFFF~BOOLEAN(INTG); 08840110 + 08840120 + END ELSE 08840130 + BEGIN DYAL(A,B,DYALSIB-4,DYALDIB,4); 08840200 + DYAL(A,INTG,DYALSIB-2,0,1); 08840210 + TFFF ~ INTG = 0; 08840220 + END; 08840230 + END ELSE 08840300 + IF QH03 = 1 THEN 08840400 + BEGIN 08840500 + QH03 ~ 0; 08840600 + DYAL (A, JUNK, DYALSIB, 44, 4); 08840700 + IF JUNK.[44:4] > 9 THEN TFFF~JUNK.[44:4]=1308840800 + ELSE DYAL(A,B,DYALSIB,DYALDIB,4); 08840900 + END ELSE 08841000 + GO TO L2; 08841100 + BUMPDIB; 08841200 + L2: IF BUMPSIB = 0 THEN 08841300 + BEGIN 08841400 + IF SOPF THEN 08841500 + BEGIN 08841600 + MOVE (A, JUNK); 08841700 + MOVE (X, A); 08841800 + MOVE (JUNK, X); 08841900 + END ELSE 08842000 + SIR ~ SIR + 1; 08842100 + IF DIB ! 0 THEN GO TO L1; 08842200 + IF QH02 = 1 THEN 08842300 + BEGIN 08842400 + QH02 ~ 0; 08842500 + GO TO L1; 08842600 + END ELSE 08842700 + BEGIN 08842800 + BROF ~ TRUE; 08842900 + ADJ (2, 0); 08843000 + ENDE; 08843100 + GO TO OC; 08843200 + END; 08843300 + END ELSE 08843400 + IF DIB ! 0 THEN GO TO L3; 08843500 + BROF ~ TRUE; 08843600 + IF AROF THEN ADJ(1,0) ELSE ADJ(0,0); 08843700 + IF QH02 = 1 THEN 08844000 + BEGIN 08844500 + QH02 ~ 0; 08845000 + GO TO L3; 08845500 + END; 08846000 + TFFF~DSZ=6 AND B.[42:1]=1 OR DSZ =8 AND B.[42:1]=0; 08847000 + ENDE; 08847500 + OC: 08848000 + END OF PACKS; 08848500 + 08849000 +PROCEDURE UABD; % UNPACK ABSOLUTE, DESTRUCTIVE 08849500 + BEGIN P2R3 ~ 1; 08850000 + UNPACKS (FALSE, FALSE); 08850500 + END UABD; 08851000 +PROCEDURE UABU; % UNPACK ABSOLUTE, UPDATE 08851500 + BEGIN P2R3 ~ 1; 08852000 + UNPACKS (FALSE, TRUE); 08852500 + END UABU; 08853000 +PROCEDURE USND; % UNPACK SIGNED, DESTRUCTIVE 08853500 + BEGIN P2R3 ~ 1; 08854000 + UNPACKS (TRUE, FALSE); 08854500 + END USND; 08855000 +PROCEDURE USNU; % UNPACK SIGNED, UPDATE 08855500 + BEGIN P2R3 ~ 1; 08856000 + UNPACKS (TRUE, TRUE); 08856500 + END USNU; 08857000 +PROCEDURE PACD; % PACK DESTRUCTIVE 08857500 + BEGIN SWPS ~ 1; P2R2 ~ 1; 08858000 + PACKS (FALSE); 08858500 + END PACD; 08859000 +PROCEDURE PACU; % PACK UPDATE 08859100 + BEGIN SWPS ~ 1; P2R2 ~ 1; 08859200 + PACKS (TRUE); 08859300 + END PACU; 08859400 +PROCEDURE TRNS ; % TRANSLATE 7.5 08860000 + BEGIN 08861000 + LABEL OC; 08862000 + ADJ(1,2); 08863000 + IF AX.TAG ! DATADESC THEN INVOPI; 08864000 + IF BOOLEAN(AX) THEN ELSE 08865000 + BEGIN 08866000 + ADJ(0,0); 08867000 + AX ~ BX ~ 0; 08868000 + AROF ~ BROF ~ TRUE; 08869000 + A ~ S; 08870000 + SETINTERRUPT(B~PRESBIT); 08871000 + END; 08872000 + AROF ~ FALSE; 08873000 + IF A.IBIT=0 THEN TIR ~ 0 ELSE 08874000 + TIR ~ IF A.CHRSZ = 0 THEN A.INDEX ELSE A.TIRF; 08875000 + TBR ~ TIR + A.ADDR; 08876000 + ENTEREDIT( 0,FALSE); 08877000 + CHARSZ; 08878000 + DIS ~ 7; 08879000 + RPF ~ C.ADDR - 1; 08880000 + WHILE RPF } 0 DO 08881000 + BEGIN 08882000 + FETCHSOURCE; 08883000 + FETCHDESTINATION; 08884000 + MM ~ 0; 08885000 + DYAL(A,JUNK,DYALSIB,5,SSZ-2); 08886000 + IF SSZ=4 THEN MM~JUNK.[42:2] ELSE 08887000 + IF SSZ=6 THEN MM~JUNK.[42:4] ELSE MM~JUNK.[42:6]; 08888000 + MM ~ TBR + MM; 08889000 + DYAL(A,JUNK,DYALSIB-SSZ+2,4,2); 08890000 + DIS.[43:2] ~ REAL(NOT BOOLEAN(JUNK)).[43:2]; 08891000 + MOVE(M[MM],C); MEMCYCLE; 08892000 + DYAL(C,8,DIS,DYALDIB,DSZ); 08893000 + RPF ~ RPF - 1; 08894000 + BUMPSIB; 08895000 + SWITCHSOURCE; 08896000 + IF BUMPSIB = 0 THEN 08897000 + BEGIN 08898000 + STOREB; 08899000 + STEPDP; 08900000 + DIR ~ DIR + 1; 08901000 + END; 08902000 + END; 08903000 + ENDE; 08904000 + OC: 08905000 + END TRNS; 08906000 +PROCEDURE SCALE(TOG); VALUE TOG; BOOLEAN TOG; 08906010 + BEGIN 08906020 + DEFINE DYNAMIC = TOG #, %1 08906030 + SAVER = TOG.[46:1]#, % 2 08906040 + RIGHT = TOG.[45:1]#, % 4 08906050 + FINAL = TOG.[44:1]#, % 6 08906060 + ROUND = TOG.[43:1]#; % 16 08906070 + REAL DIGR, TA, TX; 08906080 + LABEL OC; 08906090 + INTEGER SIGNQ,SIGNQH; 08906100 + DEFINE SETINT = BEGIN 08906110 + SETINTERRUPT(INVOP ); 08906120 + ADJ(0,0); AROF ~ BROF ~ TRUE; 08906130 + GO OC; 08906140 + END#; 08906150 + ADJ(0,1); 08906160 + IF DYNAMIC THEN 08906170 + BEGIN 08906180 + NTGR; 08906190 + IF SDIS=1 THEN 08906200 + BEGIN 08906210 + SETINTERRUPT(INTOVFI); 08906220 + GO OC; 08906230 + END; 08906240 + END ELSE 08906250 + BEGIN 08906260 + C ~ SYLLABLE; CX ~ 0; 08906270 + STEPPSR(1); 08906280 + MOVE(C,A); 08906290 + END; 08906300 + DIGR ~ A.[44:4]; 08906310 + AROF ~ FALSE; 08906320 + IF INTEGERIZE(FALSE,B) THEN 08906330 + BEGIN 08906340 + SETINTERRUPT(INTOVFI); 08906350 + GO OC; 08906360 + END; 08906370 + ADJ(1,0); 08906380 + IF DIGR < 13 THEN ELSE 08906390 + IF RIGHT THEN SETINT ELSE 08906400 + BEGIN 08906410 + OFFF ~ TRUE; 08906420 + GO OC; 08906430 + END; 08906440 + IF RIGHT THEN 08906450 + BEGIN 08906460 + MOVE(A,TA); 08906470 + DOUBLE(A,X,10*DIGR,0,/,~,A,X); 08906480 + SIGNQ ~ SIGN(A); B.SOBIT ~ 0; 08906490 + MOVE(A,SSZ); 08906500 + IF INTEGERIZE(FALSE,SSZ) THEN 08906510 + BEGIN 08906520 + SETINTERRUPT(INTOVFI); 08906530 + GO OC; 08906540 + END; 08906550 + DSZ ~ 0; 08906560 + DOUBLE(TA,TX,10*DIGR,0,SIGNQ,SIGNQH,SSZ,DSZ, 08906570 + |,|,-,~,TA,TX); 08906580 + FOR JUNK~0 STEP 1 UNTIL DIGR-1 DO 08906590 + DYAL(TA,B,36-6|JUNK,4|JUNK,4); 08906600 + END ELSE 08906610 + DOUBLE(A,X,10*DIGR,0,|,~,A,X); 08906620 + IF ROUND THEN ELSE GO OC; 08906630 + IF FINAL THEN 08906640 + BEGIN 08906650 + BROF ~ TRUE; 08906660 + AROF ~ FALSE; EXTF ~ BOOLEAN(SIGN(A)); 08906670 + IF A!0 THEN OFFF ~ TRUE; 08906680 + END ELSE 08906690 + IF SAVER THEN BROF ~ TRUE ELSE 08906700 + IF ROUND THEN 08906710 + IF BX.PBIT=1 OR B.[1:3]>4 THEN X ~ X + 1; 08906720 + OC: 08906730 + END SCALE; 08906740 +PROCEDURE SCLF ; % SCALE LEFT 7.6.1 08907000 + BEGIN 08908000 + SCALE(BOOLEAN( 0)); 08909000 + END SCLF; 08910000 +PROCEDURE DSLF ; % DYNAMIC SCALE LEFT 7.6.2 08911000 + BEGIN 08912000 + SCALE(BOOLEAN( 1)); 08913000 + END DSLF; 08914000 +PROCEDURE SCRS ; % SCALE RIGHT SAVE 7.6.3 08915000 + BEGIN 08916000 + SCALE(BOOLEAN( 6)); 08917000 + END SCRS; 08918000 +PROCEDURE DSRS ; % DYNAMIC SCALE RIGHT SAVE 7.6.4 08919000 + BEGIN 08920000 + SCALE(BOOLEAN( 7)); 08921000 + END DSRS; 08922000 +PROCEDURE SCRT ; % SCALE RIGHT TRUNCATE 7.6.5 08923000 + BEGIN 08924000 + SCALE(BOOLEAN(20)); 08925000 + END SCRT; 08926000 +PROCEDURE DSRT ; % DYNAMIC SCALE RIGHT TRUNCATE 7.6.6 08927000 + BEGIN 08928000 + SCALE(BOOLEAN(21)); 08929000 + END DSRT; 08930000 +PROCEDURE SCRR ; % SCALE RIGHT ROUND 7.6.7 08931000 + BEGIN 08932000 + SCALE(BOOLEAN( 4)); 08933000 + END SCRR; 08934000 +PROCEDURE DSRR ; % DYNAMIC SCALE RIGHT ROUND 7.6.8 08935000 + BEGIN 08936000 + SCALE(BOOLEAN( 5)); 08937000 + END DSRR; 08938000 +PROCEDURE SCRF ; % SCALE RIGHT FINAL 7.6.9 08939000 + BEGIN 08940000 + SCALE(BOOLEAN(12)); 08941000 + END SCRF; 08942000 +PROCEDURE DSRF ; % DYNAMIC SCALE RIGHT FINAL 7.6.10 08943000 + BEGIN 08944000 + SCALE(BOOLEAN(13)); 08945000 + END DSRF; 08946000 +PROCEDURE OCRX ; % OCCURS INDEX 7.7 08947000 + BEGIN 08948000 + LABEL OC; 08949000 + ADJ(1,1); 08950000 + IF AX.TAG=SINGL AND BX.TAG=SINGL OR BX.TAG=DOUBL THEN ELSE 08951000 + BEGIN INTFAMA(-1); GO OC END; 08952000 + MOVE(A,C); A~AX ~X ~ XX ~ 0; 08953000 + A.[32:1] ~ C.[16:16]; 08954000 + X.[32:16] ~ 0&CX [32:47:1]&C[33:1:15]; 08955000 + AROF ~ FALSE; 08956000 + IF INTEGERIZE(FALSE,B) THEN BEGIN INTFAMA(INTOVFI);GO OC END; 08957000 + IF B < 0 AND B > A THEN BEGIN INTFAMA(INVINXI); GO OC END; 08958000 + MOVE(X,A); XX ~ 0; 08959000 + X ~ C.[32:16]; 08960000 + AROF ~ TRUE; 08961000 + B ~ X + A | (B-1); 08962000 + OC: 08966000 + END OCRX; 08967000 +PROCEDURE SISO; % STRING ISOLATE 08968000 + BEGIN 08968100 + LABEL OC, L1, L2, L3; 08968200 + ENTEREDIT (1, FALSE); 08968300 + IF SSZ = 0 THEN SSZ ~ 6; 08968400 + IF C.ADDR > (96 DIV SSZ) THEN 08968500 + BEGIN 08968600 + MOVE (C, A); 08968700 + AROF ~ BROF ~ TRUE; 08968800 + QF01 ~ 1; 08968900 + JFIF; 08969000 + GO TO OC; 08969100 + END; 08969200 + RPF ~ C.ADDR; 08969300 + BX ~ B ~ YX ~ Y ~ 0; 08969400 + IF C.ADDR > (48 DIV SSZ) THEN 08969500 + BEGIN 08969600 + C.ADDR ~ (C.ADDR - 48 DIV SSZ); 08969700 + QH02 ~ 1; 08969800 + END; 08969900 + DIB ~ (48 DIV SSZ - C.ADDR); 08970000 + IF SOPF THEN 08970100 + BEGIN 08970200 + MOVE (A, X); 08970300 + L3: MM ~ SBR + SIR; 08970400 + MOVE (M[MM],A); 08970500 + AROF ~ TRUE; 08970600 + IF BOOLEAN (AX.TAG) THEN 08970700 + BEGIN 08970800 + IF SOPF THEN 08970900 + BEGIN 08971000 + MOVE (X, A); 08971100 + AROF ~ TRUE; 08971200 + END ELSE 08971300 + BEGIN 08971400 + IF QH01 = 1 THEN 08971500 + BEGIN 08971600 + MOVE (A, JUNK); 08971700 + MOVE (X, A); 08971800 + MOVE (JUNK, X); 08971900 + END; 08972000 + END; 08972100 + QF04 ~ 1; 08972200 + JGIF; 08972300 + GO TO OC; 08972400 + END; 08972500 + END; 08972600 + L1: IF LHFF = 1 THEN 08972700 + BEGIN 08972800 + BX.TAG ~ DOUBL; 08972900 + DYAL (A, Y, DYALSIB, DYALDIB, SSZ); 08973000 + END ELSE 08974000 + DYAL (A, B, DYALSIB, DYALDIB, SSZ); 08975000 + IF BUMPDIB = 0 THEN 08976000 + BEGIN 08977000 + IF LHFF ! 0 THEN GO TO L2; 08978000 + IF QH02 ! 1 THEN GO TO L2; 08979000 + LHFF ~ 1; 08980000 + END; 08981000 + IF BUMPSIB = 0 THEN 08982000 + BEGIN 08983000 + QH01 ~ 1; 08984000 + IF NOT SOPF THEN GO TO L3 ELSE 08985000 + BEGIN 08986000 + MOVE (A, JUNK); 08987000 + MOVE (X, A); 08988000 + MOVE (JUNK, X); 08989000 + END; 08990000 + END; 08991000 + GO TO L1; 08992000 + L2: AROF ~ EXSF ~ SOPF ~ FALSE; 08993000 + BROF ~ TRUE; 08994000 + OC: 08995000 + END OF STRING ISOLATE; 08996000 +PROCEDURE SXSN ; % SET EXTERNAL SIGN 7.9 08997000 + BEGIN 08998000 + ADJ(1,2); 08999000 + 09000000 + EXTF ~ BOOLEAN(A.SOBIT); 09001000 + END SXSN; 09002000 +PROCEDURE RTFF ; % READ TRUE/FALSE FLIP-FLOP 7.10 09003000 + BEGIN 09004000 + ADJ(0,2); 09005000 + AX ~ A ~ 0; 09006000 + AROF ~ TRUE; 09006500 + A ~ REAL(TFFF); 09007000 + END RTFF; 09008000 +PROCEDURE ROFF ; % READ AND CLEAR OVERFLOW FLIP-FLOP 7.11 09009000 + BEGIN 09010000 + ADJ(0,2); 09011000 + AX ~ A ~ 0; 09012000 + AROF ~ TRUE; 09012500 + A ~ REAL(OFFF); 09013000 + OFFF ~ FALSE; 09014000 + END ROFF; 09015000 +PROCEDURE INPCONV( UPDATE); VALUE UPDATE; BOOLEAN UPDATE; 09015010 + BEGIN 09015020 + REAL DIGR ; 09015030 + LABEL OC; 09015040 + ADJ(0,1); 09015050 + IF INTEGERIZE(FALSE,B) THEN 09015060 + BEGIN 09015070 + SETINTERRUPT(INTOVFI); 09015080 + ADJ(0,0); AROF ~ BROF ~ TRUE; 09015090 + GO OC; 09015100 + END; 09015110 + ADJ(1,1); 09015120 + IF A.[43:5] > 23 THEN 09015130 + BEGIN 09015140 + SETINTERRUPT(INVOP); 09015150 + ADJ(0,0); AROF ~ BROF ~ TRUE; 09015160 + GO OC; 09015170 + END; 09015180 + IF UPDATE THEN 09015190 + BEGIN 09015200 + PACU; ADJ(1,1); 09015210 + END ELSE 09015220 + BEGIN 09015230 + PACU; ADJ(0,1); 09015240 + END; 09015250 + MOVE(A,C); 09015260 + JUNK ~ DIGR ~ 09015270 + A ~ AX ~ X ~ XX ~ 0; 09015280 + DO BEGIN 09015290 + DOUBLE(A,X,10,0,|,~,A,X); 09015300 + IF DIGR < 12 THEN 09015310 + BEGIN 09015320 + DYAL(B,JUNK,47-4|DIGR,3,4); 09015330 + X ~ X + JUNK.[44:4]; 09015340 + END ELSE 09015350 + BEGIN 09015360 + DYAL(Y,JUNK,48-4|DIGR,3,4); 09015370 + X ~ X + JUNK.[44:4]; 09015380 + END; 09015390 + END UNTIL DIGR ~ DIGR + 1 = 24; 09015400 + MOVE(A,B); MOVE(X,Y); MOVE(C,A); 09015410 + IF B ! 0 THEN 09015420 + BEGIN 09015430 + B.SOBIT ~ 1; 09015440 + TFFF ~ FALSE; 09015450 + BX.TAG ~ DOUBL; 09015460 + 09015470 + END ELSE 09015480 + BEGIN 09015490 + MOVE(Y,B); 09015500 + B.SOBIT ~ REAL(TFFF); 09015510 + TFFF ~ TRUE; 09015520 + BX.TAG ~ SINGL; 09015530 + END; 09015540 + OC: 09015545 + END OF INPCONV; 09015550 +PROCEDURE ICVD ; % INPUT CONVERT, DESTRUCTIVE 7.12.1 09016000 + BEGIN 09017000 + INPCONV(FALSE); 09018000 + END ICVD; 09019000 +PROCEDURE ICVU ; % INPUT CONVERT, UPDATE 7.12.2 09020000 + BEGIN 09021000 + INPCONV(TRUE ); 09022000 + END ICVU; 09023000 +PROCEDURE TEED ; % TABLE ENTER EDIT, DESTRUCTIVE 7.13.1 09024000 + BEGIN 09025000 + ENTEREDIT(3,FALSE); 09026000 + END TEED; 09027000 +PROCEDURE TEEU ; % TABLE ENTER EDIT, UPDATE 7.13.2 09028000 + BEGIN 09029000 + ENTEREDIT(3, TRUE); 09030000 + END TEEU; 09031000 +PROCEDURE ILED ; % IN LINE ENTER EDIT, DESTRUCTIVE 7.13.3 09032000 + BEGIN 09033000 + ENTEREDIT(2,FALSE); 09034000 + END ILED; 09035000 +PROCEDURE ILEU ; % IN LINE ENTER EDIT, UPDATE 7.13.4 09036000 + BEGIN 09037000 + ENTEREDIT(2, TRUE); 09038000 + END ILEU; 09039000 +PROCEDURE EXPU ; % SINGLE PINTER ENTER EDIT 09040000 + BEGIN 09041000 + ENTEREDIT(1,TRUE); 09042000 + END OF SPEE; 09043000 +PROCEDURE EXSD ; % EXECUTE SINGLE MICRO, DESTRUCTIVE 7.13.5 09044000 + BEGIN 09045000 + ENTEREDIT(0,FALSE); 09046000 + END EXSD; 09047000 +PROCEDURE EXSU ; % EXECUTE SINGLE MICRO, UPDATE 7.13.6 09048000 + BEGIN 09049000 + ENTEREDIT(0, TRUE); 09050000 + END EXSU; 09051000 +PROCEDURE MOVES (NUMRIC); 09052000 + VALUE NUMRIC; 09053000 + BOOLEAN NUMRIC; 09054000 + BEGIN 09055000 + INTEGER PLUG; 09055500 + LABEL OC, L1, L2, L3, L4, L5; 09056000 + EDITF ~ TRUE; 09057000 + SETUPEXSF; 09058000 + CHARSZ; 09059000 + IF C.ADDR = 0 THEN GO TO L1; 09060000 + RPF ~ C.ADDR; 09061000 + QH03 ~ 1; 09062000 + L2: IF NOT SOPF THEN 09063000 + BEGIN 09064000 + MM ~ SBR + SIR; 09065000 + MOVE (M[MM], A); MEMCYCLE; 09066000 + IF BOOLEAN (AX.TAG) THEN 09067000 + BEGIN 09068000 + L4: BKIP ~ 1; 09069000 + MEMPROTECT; 09070000 + END; 09071000 + END; 09072000 + IF QH03 = 1 THEN QH03 ~ 0 ELSE 09073000 + L5: IF DIB ! 0 THEN GO TO L3; 09074000 + IF BROF THEN BROF ~ FALSE ELSE 09075000 + BEGIN 09076000 + MM ~ DBR + DIR; 09077000 + MOVE (M[MM], B); MEMCYCLE; 09078000 + IF BOOLEAN (BX.TAG) THEN GO TO L4; 09079000 + END; 09080000 + L3: IF NUMRIC THEN 09081000 + BEGIN 09082000 + IF SSZ = 4 THEN 09083000 + BEGIN 09084000 + DYAL (A, B, DYALSIB, DYALDIB, 4); 09085000 + END ELSE 09086000 + IF SSZ = 6 THEN 09087000 + BEGIN 09088000 + PLUG ~ 0; 09089000 + DYAL (PLUG, B, 46, DYALDIB,2); 09089500 + DYAL (A, B,(DYALSIB - 2), (DYALDIB -2),4); 09090000 + END ELSE 09091000 + BEGIN 09092000 + PLUG ~ 17; 09093000 + DYAL (PLUG, B, 44, DYALDIB, 4); 09093050 + DYAL (A, B,(DYALSIB -4),(DYALDIB -4), 4); 09094000 + END; 09095000 + END ELSE 09096000 + DYAL (A, B, DYALSIB, DYALDIB, SSZ); 09097000 + BUMPSIB; 09098000 + SWITCHSOURCE; 09099000 + RPF ~ RPF - 1; 09100000 + IF RPF = 0 THEN 09101000 + BEGIN 09102000 + MOVE (B, M[DBR + DIR]); MEMCYCLE; 09103000 + LHFF ~ 1; 09104000 + END; 09105000 + IF BUMPDIB = 0 THEN 09106000 + BEGIN 09107000 + MOVE (B, M[DBR + DIR]); MEMCYCLE; 09108000 + END; 09109000 + STEPDP; 09110000 + IF LHFF = 0 THEN 09111000 + BEGIN 09112000 + IF SIB = 0 THEN GO TO L2; 09113000 + GO TO L5; 09114000 + END; 09115000 + L1: IF EXSF THEN ENDE ELSE BROF ~ TRUE; 09116000 + OC: 09117000 + END OF MOVES FOR MOVE CHARAS AND NUMERIC UNCOND; 09118000 +PROCEDURE MCHR; % MOVE CHARACTERS 09119000 + BEGIN 09120000 + P2R3 ~ 1; 09121000 + MOVES (FALSE); 09122000 + END; 09123000 +PROCEDURE MVNU; % MOVE NUMERIC UNCONDITIONAL 09124000 + BEGIN 09125000 + P2R3 ~ 1; 09126000 + MOVES (TRUE); 09127000 + END; 09128000 +PROCEDURE SKIPS (FORWAD, SOURCE); 09130000 + VALUE FORWAD, SOURCE; 09130500 + BOOLEAN FORWAD, SOURCE; 09131000 + BEGIN 09131500 + LABEL OC, L1, L2, L3, MPERR, L4; 09132000 + EDITF ~ TRUE; 09132500 + SETUPEXSF; 09133000 + RPF ~ BUF ~ C.ADDR; 09133500 + IF C.ADDR { 0 THEN GO TO L3; 09134000 + QH03 ~ 1; 09134500 + IF SOURCE THEN 09135000 + BEGIN 09135500 + IF SSZ = 0 THEN SSZ ~ 6; 09136000 + IF NOT SOPF THEN 09136500 + BEGIN 09137000 + L1: MM ~ SBR + SIR; 09137500 + MOVE (M[MM], A); 09138000 + IF BOOLEAN (AX.TAG) THEN GO TO MPERR; 09138500 + IF QH03 = 0 THEN 09139000 + L2: IF FORWAD THEN 09139500 + BEGIN 09140000 + BUF ~ RPF - 1; 09140500 + RPF ~ RPF - 1; 09141000 + IF RPF = 0 THEN GO TO L3; 09141500 + END ELSE 09142000 + BEGIN 09143000 + SIB ~(48 DIV SSZ); 09144000 + END ELSE 09145000 + QH03 ~ 0; 09146000 + END; 09147000 + IF FORWAD THEN RPF ~ RPF -(48 DIV SSZ -(SIB+1)) 09148000 + ELSE 09149000 + BEGIN 09150000 + RPF ~ RPF - SIB; 09151000 + BUF ~ RPF; 09152000 + END; 09153000 + IF RPF < 0 THEN RPZF ~ 1; 09154000 + IF RPF = 0 THEN LHFF ~ 1; 09155000 + IF FORWAD THEN 09156000 + BEGIN 09157000 + IF LHFF = 1 OR RPZF = 1 THEN 09158000 + BEGIN 09159000 + SIB ~ SIB + BUF; 09160000 + GO TO L3; 09161000 + END; 09162000 + SIB ~ 0; 09163000 + IF NOT SOPF THEN 09164000 + BEGIN 09165000 + SIR ~ SIR + 1; 09166000 + GO TO L1 09167000 + END ELSE 09168000 + BEGIN 09169000 + MOVE (A, JUNK); 09170000 + MOVE (X, A); 09171000 + MOVE (JUNK, X); 09172000 + GO TO L2; 09173000 + END; 09174000 + END ELSE 09175000 + BEGIN 09176000 + SIB ~ 0; 09177000 + IF LHFF = 1 OR RPZF = 1 THEN 09178000 + BEGIN 09179000 + SIB ~ ABS (BUF + 0); 09180000 + GO TO L3; 09181000 + END; 09182000 + IF NOT SOPF THEN 09183000 + BEGIN 09184000 + SIR ~ SIR - 1; 09185000 + GO TO L1; 09186000 + END ELSE 09187000 + BEGIN 09188000 + MOVE (A, JUNK); 09189000 + MOVE (X, A); 09190000 + MOVE (JUNK, X); 09191000 + GO TO L2; 09192000 + END; 09193000 + END; 09194000 + END ELSE 09195000 + BEGIN 09196000 + IF DSZ = 0 THEN DSZ ~ 6; 09197000 + IF NOT BROF THEN 09198000 + BEGIN 09199000 + L4: MM ~ DBR + DIR; 09200000 + MOVE (M[MM], B); 09201000 + IF BOOLEAN (BX.TAG) THEN GO TO MPERR; 09202000 + END; 09203000 + IF FORWAD THEN 09204000 + BEGIN 09205000 + IF QH03 = 0 THEN 09206000 + BEGIN 09207000 + BUF ~ RPF - 1; 09208000 + RPF ~ BUF; 09209000 + IF RPF = 0 THEN GO TO L3; 09210000 + END ELSE 09211000 + QH03 ~ 0; 09212000 + RPF ~ RPF - (48 DIV SSZ - (DIB + 1)); 09213000 + END ELSE 09214000 + BEGIN 09215000 + IF QH03 = 0 THEN DIB ~ (48 DIV SSZ) ELSE 09216000 + QH03 ~ 0; 09217000 + RPF ~ RPF - DIB; 09218000 + BUF ~ RPF; 09218500 + END; 09219000 + IF RPF < 0 THEN RPZF ~ 1; 09220000 + IF RPF = 0 THEN LHFF ~ 1; 09221000 + IF FORWAD THEN 09222000 + BEGIN 09223000 + IF LHFF = 1 OR RPZF = 1 THEN 09224000 + BEGIN 09225000 + DIB ~ DIB + BUF; 09226000 + GO TO L3; 09227000 + END ELSE 09228000 + BEGIN 09229000 + DIB ~ 0; 09230000 + BROF ~ FALSE; 09231000 + DIR ~ DIR + 1; 09232000 + GO TO L4; 09233000 + END; 09234000 + END ELSE 09235000 + BEGIN 09235500 + DIB ~ 0; 09236000 + IF LHFF = 1 OR RPZF = 1 THEN 09237000 + BEGIN 09238000 + DIB ~ ABS (RPF + 0); 09239000 + GO TO L3; 09240000 + END ELSE 09241000 + BEGIN 09242000 + BROF ~ FALSE; 09243000 + DIR ~ DIR - 1; 09244000 + GO TO L4; 09245000 + END; 09245500 + END; 09246000 + END; 09246500 + MPERR: 09247000 + UPDF ~ TRUE; 09248000 + ENDE; 09249000 + BKIP ~ 1; QF04 ~ 1; 09250000 + JGIF; 09251000 + GO TO OC; 09252000 + L3: IF EXSF THEN ENDE; 09253000 + OC: 09254000 + END OF SKIPS; 09255000 +PROCEDURE SFSC; % SKIP FORWARD SOURCE CHARACTERS 09255500 + BEGIN P2R3 ~ 1; 09256000 + SKIPS (TRUE, TRUE); 09257000 + END SFSC; 09258000 +PROCEDURE SRSC; % SKIP REVERSE SOURCE CHARACTERS 09259000 + BEGIN P2R3 ~ 1; 09260000 + SKIPS (FALSE, TRUE); 09261000 + END SRSC; 09262000 +PROCEDURE SFDC; % SKIP FORWARD DESTINATION CHARACTERS 09263000 + BEGIN P2R3 ~ 1; 09264000 + SKIPS (TRUE, FALSE); 09265000 + END SFDC; 09265500 +PROCEDURE SRDC; % SKIP REVERSE DESTINATION CHARACTERS 09266000 + BEGIN P2R3 ~ 1; 09267000 + SKIPS (FALSE, FALSE); 09268000 + END SRDC; 09269000 +PROCEDURE INSERTS(CONDITIONAL); 09270000 + VALUE CONDITIONAL; 09271000 + BOOLEAN CONDITIONAL; 09272000 + BEGIN 09273000 + LABEL OC; 09274000 + EDITF ~ TRUE; 09274100 + SETUPEXSF; 09275000 + RPF~C; 09276000 + Y~SYLLABLE; 09277000 + STEPPSR(1); 09278000 + IF CONDITIONAL THEN 09279000 + IF NOT FLTF THEN STEPPSR(1) ELSE 09280000 + BEGIN 09281000 + Y ~ SYLLABLE; YX ~ 0; 09282000 + STEPPSR(1); 09283000 + END; 09284000 + WHILE RPF > 0 DO 09285000 + BEGIN 09286000 + FETCHDESTINATION; 09287000 + DYAL(Y,B,DSZ-1,DYALDIB,DSZ); 09288000 + IF BUMPDIB = 0 THEN 09289000 + BEGIN 09290000 + STOREB; 09291000 + STEPDP; 09292000 + END; 09293000 + RPF ~ RPF - 1; 09294000 + END; 09295000 + IF EXSF THEN ENDE; 09296000 + OC: 09297000 + END OF INSERTS; 09298000 +PROCEDURE INSU ; % INSERT UNCONDITIONAL 8.4.1 09299000 + BEGIN 09300000 + INSERTS(FALSE); 09301000 + END INSU; 09302000 +PROCEDURE INSC ; % INSERT CONDITIONAL 8.4.2 09303000 + BEGIN 09304000 + INSERTS(TRUE ); 09305000 + END INSC; 09306000 +PROCEDURE INSG ; % INSERT DISPLAY SIGN 8.4.3 09307000 + BEGIN 09308000 + LABEL OC; 09309000 + EDITF ~ TRUE; 09309100 + IF DSZ = 0 THEN DSZ ~ 6 ELSE 09310000 + IF DSZ = 4 THEN 09311000 + BEGIN 09311100 + UPDF ~ TRUE; 09311200 + ENDE; 09311300 + QF01 ~ 1; 09311400 + BKIP ~ 1; 09311500 + JGIF; 09311600 + GO OC; 09311700 + END; 09311800 + IF EXTF THEN ELSE STEPPSR(1); 09312000 + Y~ SYLLABLE; YX~0; 09313000 + IF EXTF THEN STEPPSR(2) ELSE STEPPSR(1); 09314000 + FETCHDESTINATION; 09315000 + DYAL(Y,B,DSZ-1,DYALDIB,DSZ); 09316000 + BUMPDIB; 09317000 + IF DIB = 0 THEN 09318000 + BEGIN 09320000 + STOREB; 09321000 + STEPDP; 09322000 + END; 09323000 + IF EXSF THEN ENDE; 09324000 + OC: 09325000 + END INSG; 09326000 +PROCEDURE INOP ; % INSERT OVERPUNCH 8.4.4 09327000 + BEGIN 09328000 + LABEL OC; 09329000 + EDITF ~ TRUE; 09330000 + IF DSZ=0 THEN DSZ~6 ELSE 09331000 + IF DSZ=4 THEN 09332000 + BEGIN 09333000 + UPDF ~ TRUE; ENDE; 09334000 + QF01~ 1; 09335000 + BKIP ~ 1; 09336000 + JGIF; 09337000 + GO OC; 09338000 + END; 09339000 + FETCHDESTINATION; 09340000 + IF EXTF THEN 09341000 + IF (DIB~DIB-DSZ) < 0 THEN 09342000 + IF DSZ=6 THEN DYAL(INTG~2,B,1,DYALDIB,2) 09343000 + ELSE DYAL(INTG~13,B,3,DYALDIB,4); 09344000 + BUMPDIB; 09345000 + IF DIB=0 THEN 09346000 + BEGIN 09347000 + STOREB; 09347100 + STEPDP; 09347200 + END; 09347300 + IF EXSF THEN ENDE; 09347400 + OC: 09348000 + END INOP; 09349000 +PROCEDURE RSTF ; % RESET FLOAT 09350000 + BEGIN 09351000 + FLTF ~ FALSE; 09352000 + END RFLT; 09353000 +PROCEDURE ENDF ; % END FLOAT 8.9 09354000 + BEGIN 09355000 + LABEL OC; 09356000 + EDITF ~ TRUE; 09356100 + IF FLTF THEN 09357000 + BEGIN 09358000 + STEPPSR(2); 09359000 + FLTF ~ FALSE; 09360000 + GO OC; 09361000 + END; 09362000 + IF DSZ=0 THEN DSZ~6; 09363000 + FETCHDESTINATION; 09364000 + Y ~ SYLLABLE; YX ~ 0; 09365000 + STEPPSR(1); 09366000 + IF EXTF THEN Y ~ SYLLABLE; 09367000 + STEPPSR(1); 09368000 + DYAL(Y,B,DSZ-1,DIB,DSZ); 09369000 + BUMPDIB; 09370000 + IF DIB = 0 THEN 09371000 + BEGIN 09372000 + STOREB; 09373000 + STEPDP; 09374000 + END; 09375000 + IF EXSF THEN ENDE; 09376000 + OC: 09377000 + END ENDF; 09378000 +PROCEDURE MINS ; % MOVE WITH INSERT 8.10 09379000 + BEGIN 09380000 + BOOLEAN LHFF; 09381000 + LABEL L12,L8,L10,L14,L20,L11,OC; 09382000 + EDITF ~ TRUE; 09383000 + SETUPEXSF; 09384000 + Y ~ SYLLABLE; YX ~ 0; STEPPSR(1); 09385000 + CHARSZ; 09386000 + IF C = 0 THEN GO TO L11; 09387000 + RPF ~ C.ADDR; 09388000 + QH03 ~ 1; 09389000 + L12: 09390000 + FETCHSOURCE; 09391000 + L8: 09392000 + IF QH03 = 1 THEN QH03~0 ELSE IF DIB!0 THEN GO L14; 09393000 + IF BROF THEN BROF ~ FALSE ELSE 09394000 + L10: 09395000 + FETCHDESTINATION; 09396000 + L14: 09397000 + IF FLTF THEN 09398000 + BEGIN 09399000 + INTG ~ 15|REAL(SSZ=8); 09400000 + IF SSZ!4 THEN DYAL(INTG,B,SSZ-5,DYALDIB,SSZ-4); 09401000 + DYAL(A,8,DYALSIB-SIBLNG,DYALDIB-DIBLNG,4); GO L20; 09402000 + END; 09403000 + 09404000 + DYAL(A,INTG,DYALSIB-SIBLNG,3,4); 09405000 + IF INTG.[44:4] ! 0 THEN BEGIN FLTF~TRUE;GO L14 END; 09406000 + 09407000 + DYAL(Y,B,DSZ-1,DYALDIB,DSZ); 09408000 + L20: BUMPSIB; 09409000 + SWITCHSOURCE; 09410000 + BUMPDIB; 09411000 + RPF ~ RPF - 1; 09412000 + IF RPF = 0 THEN 09413000 + BEGIN 09414000 + STOREB; 09415000 + LHFF ~ TRUE; 09416000 + END; 09417000 + IF DIB = 0 THEN 09418000 + BEGIN 09418100 + STOREB; 09418200 + STEPDP; 09418300 + END; 09418400 + IF NOT LHFF THEN IF SIB=0 THEN GO L12 ELSE 09418500 + GO L10; 09418600 + L11: IF EXSF THEN ENDE ELSE BROF ~ TRUE; 09418700 + OC: 09418800 + END MINS; 09418900 +PROCEDURE MFLT ; % MOVE WITH FLOAT 8.11 09419000 + BEGIN 09420000 + LABEL L11,L9,L14,L15,L22,L10,L12,OC; 09421000 + BOOLEAN LHFF; 09421100 + EDITF ~ TRUE; 09422000 + SETUPEXSF; 09423000 + Y ~ SYLLABLE; YX ~ 0; STEPPSR(1); 09424000 + CHARSZ; 09425000 + IF C = 0 THEN GO TO L10; 09426000 + RPF ~ C.ADDR; 09427000 + QH03 ~ 1; 09428000 + L11: 09429000 + FETCHSOURCE; 09430000 + L9: 09431000 + IF QH03 = 1 THEN QH03 ~ 0 ELSE IF DIB ! 0 THEN GO TO L15; 09432000 + IF BROF THEN BROF ~ FALSE ELSE 09433000 + L14: FETCHDESTINATION; 09434000 + L15: 09435000 + IF FLTF THEN 09436000 + BEGIN 09437000 + INTG ~ 15|REAL(SSZ=8); 09438000 + IF SSZ ! 4 THEN DYAL(INTG,B,SSZ-5,DYALDIB,SSZ-4); 09439000 + DYAL(A,B,DYALSIB-SIBLNG,DYALDIB-DIBLNG,4); 09440000 + END ELSE 09441000 + BEGIN 09442000 + DYAL(A,INTG,DYALSIB-SIBLNG,3,4); 09443000 + IF INTG.[44:4] = 0 THEN 09444000 + DYAL(Y,B,DSZ-1,DYALDIB,DSZ) ELSE 09445000 + BEGIN 09446000 + FLTF ~ TRUE; 09447000 + Y ~ SYLLABLE; YX ~ 0; STEPPSR(1); 09448000 + IF EXTF THEN Y ~ SYLLABLE; STEPPSR(1); 09449000 + DYAL(Y,B,DSZ-1,DYALDIB,DSZ); 09450000 + QH01 ~ 1; 09451000 + GO TO L22; 09452000 + END; 09453000 + END; 09454000 + BUMPSIB; 09455000 + IF SIB=0 AND NOT SOPF THEN SIR ~ SIR + 1; 09456000 + L22: 09457000 + BUMPDIB; 09458000 + IF QH01 = 0 THEN 09459000 + BEGIN 09460000 + RPF ~ RPF - 1; 09461000 + IF RPF = 0 THEN BEGIN STOREB; LHFF~TRUE END; 09462000 + END ELSE QH01 ~ 0; 09463000 + IF DIB = 0 THEN 09464000 + BEGIN 09465000 + STOREB; 09466000 + STEPDP; 09467000 + END; 09468000 + IF LHFF THEN GO L12; 09469000 + IF SIB = 0 THEN GO L11; 09470000 + GO L14; 09471000 + L10: 09472000 + IF QH03 = 0 THEN STEPPSR(2); 09473000 + L12: 09474000 + IF EXSF THEN ENDE ELSE BROF ~ TRUE; 09474100 + OC: 09474200 + END MFLT; 09474300 +PROCEDURE ENDE; % END EDIT 09475000 + BEGIN 09476000 + LABEL OC, L1; 09477000 + IF BROF THEN 09478000 + BEGIN 09479000 + MM ~ DBR + DIR; 09480000 + MOVE (B, M[MM]); MEMCYCLE; 09481000 + BROF ~ FALSE 09482000 + END; 09483000 + IF NOT UPDF THEN 09484000 + BEGIN 09485000 + FLTF ~ FALSE; 09486000 + AROF ~ FALSE; 09487000 + GO TO L1 09488000 + END; 09489000 + BROF ~ TRUE; 09490000 + B ~ BX ~ 0; 09490500 + B ~ DBR; 09491000 + B.DIRF ~ DIR; 09492000 + B.CHARF ~ DIB; 09493000 + B.SZ ~ DSZ DIV 2; 09494000 + BX.TAG ~ DATADESC; 09495000 + B.IBIT ~ 1; 09496000 + BX.PBIT ~ 1; 09497000 + B.CBIT ~ 1; 09498000 + B.SBIT ~ DPSF; 09499000 + 09500000 + IF SOPF THEN 09501000 + BEGIN 09502000 + IF AX.TAG = SINGL THEN 09503000 + BEGIN 09504000 + IF SIB ! 47 THEN 09505000 + BEGIN 09506000 + DYAL (A,C,DYALSIB,47,DYALSIZ); 09507000 + DYAL (A,C,47,DYALSET,DYALSZ); 09508000 + MOVE (C, A); 09509000 + END; 09510000 + AROF ~ TRUE; 09511000 + XROF ~ 0; 09512000 + END ELSE 09513000 + IF SIB ! 47 THEN 09514000 + BEGIN 09515000 + DYAL (A,C,DYALSIB,47,DYALSIZ); 09516000 + DYAL (X,C,47,DYALSET,DYALSZ); 09517000 + DYAL (X,X,DYALSIB,47,DYALSIZ); 09518000 + DYAL (A,X,47,DYALSET,DYALSZ); 09519000 + MOVE (C, A); 09520000 + END; 09521000 + AROF ~ TRUE; 09522000 + XROF ~ 1; GO TO L1; 09523000 + + END ELSE 09524000 + AROF ~ TRUE; 09525000 + A ~ AX ~ 0; 09525500 + A ~ SBR; 09526000 + A.SIRF ~ SIR; 09527000 + A.CHARF ~ SIB; 09528000 + A.SZ ~ SSZ DIV 2; 09529000 + AX.TAG ~ DATADESC; 09530000 + A.IBIT ~ 1; 09531000 + AX.PBIT ~ 1; 09532000 + A.CBIT ~ 1; 09533000 + A.SBIT ~ SPSF; 09534000 + A.RBIT ~ SPRF; 09535000 + L1: IF NOT EDITF THEN 09536000 + BEGIN 09537000 + IF SWPS = 1 THEN BROF ~ FALSE 09538000 + END ELSE 09539000 + IF ESPF THEN AROF ~ FALSE; 09540000 + ESPF ~ EXSF ~ UPDF ~ SOPF ~ EDITF ~ FALSE; 09541000 + OC: 09542000 + END ENDEDIT; 09543000 +PROCEDURE ERVSFLOW(OP); VALUE OP; INTEGER OP; 50000000 + BEGIN 50001000 + LABEL STARTVALC,STARTEVAL,STARTENTR,STARTEXIT,STARTRETN, 50002000 + STARTINDX,STARTNXLN,STARTNXLV,STARTSTBR,STARTMKST, 50003000 + STARTMVST,STARTDBTR,STARTDBFL,STARTDBUN,STARTBRTR, 50004000 + STARTBRFL,STARTBRUN,STARTSTFF,STARTIRWL,STARTPCWL; 50005000 + SWITCH START ~ 50006000 + STARTVALC,STARTEVAL,STARTENTR,STARTEXIT,STARTRETN, 50007000 + STARTINDX,STARTNXLN,STARTNXLV,STARTSTBR, 50008000 + STARTMKST,STARTMVST,STARTDBTR,STARTDBFL, 50009000 + STARTDBUN,STARTBRTR,STARTBRFL,STARTBRUN, 50010000 + STARTSTFF,STARTIRWL,STARTPCWL; 50011000 + DEFINE VALC=OP=1#,EVAL=OP=2#,ENTR=OP=3#,EXIT=OP=4#,RETN=OP=5#, 50012000 + INDX=OP=6#,NXLN=OP=7#,NXLV=OP=8#,STBR=OP=9#, 50013000 + MKST=OP=10#,MVST=OP=11#,DBTR=OP=12#, 50014000 + DBFL=OP=13#,DBUN=OP=14,BRTR=OP=15#,BRFL=OP=16#,50015000 + BRUN=OP=17#,STFF =OP=18#,IRWL = OP=19#, 50016000 + PCWL= OP=20#; 50017000 + LABEL LABELA,LABELB,LABELC,LABELD,LABELE,LABELF,LABELG, 50018000 + LABELH,LABELP,LABELQ,LABELS,LABELT,LABELW,LABELX, 50019000 + LABELZ, L1,L2,L3,L4,L5,L6,L7,L8,L9,L10,L11,L12,L13, 50020000 + L14,L15,L16,L17,L18,DESCPAGE6,INDEXINDESC,NXLNPAGE9, 50021000 + NORMALINDEX,SPECIALINDEX,OPERAND,INDEXWORD,STUFFEDIRW, 50022000 + NORMALIRW,PCWPAGE22,DISPLAYUPDATE,BYPASUPDATE, 50023000 + SEGMENTDESC,PCW2,INVOPLBL,INVINDLBL,STKUNFLBL,BOSLBL, 50024000 + SEQERLBL,INTLBL,PRES10LBL,PRES11LBL,PRES12LBL, 50025000 + PRES13LBL,OC,LABELOPND; 50026000 + 50027000 + REAL TS,T1,T2; 50028000 + DEFINE I1INVALIDOPERATOR = GO TO INVOPLBL#, % ON PAGE 44 50029000 + I2INTEGERIZE = BEGIN B ~ BX ~ 0; 50030000 + GO TO INTLBL END#, % ON PAGE 45 50030500 + I2MULT = I2INTEGERIZE#, 50031000 + I2INTEGERDIV = I2INTEGERIZE#, 50032000 + I3INVALIDINDEX = BEGIN LL ~ X.LLF; 50033000 + GO TO INVINDLBL END#, % PAGE 44 50033500 + I4INVALIDINDEX = GO TO INVINDLBL#, % ON PAGE 44 50034000 + I5BOSERROR = GO TO STKUNFLBL#, % ON PAGE 44 50035000 + I6BOSNORMAL = GO TO BOSLBL#, % ON PAGE 45 50036000 + I7SEQUENCEERROR = BEGIN LL ~ X.LLF; 50037000 + GO TO SEQERLBL END#, % PAGE 45 50037500 + I8SEQUENCEERROR = GO TO SEQERLBL#, % ON PAGE 45 50038000 + I9INVALIDINDEX = BEGIN MOVE (A,C); AROF ~ FALSE; 50039000 + GO TO INVINDLBL END#, % PAGE 44 50040000 + I10PRESENCEBIT = GO TO PRES10LBL#, % ON PAGE 46 50041000 + I11PRESENCEBIT = GO TO PRES11LBL#, % ON PAGE 46 50042000 + I12PRESENCEBIT = GO TO PRES12LBL#, % ON PAGE 46 50043000 + I13PRESENCEBIT = GO TO PRES13LBL#; % ON PAGE 46 50044000 + %%% 50045000 + DEFINE INTFL = SDIS=1#; %TO OVERCOME NOMENCLATURE DIFFICULTY 50046000 + %%% 50047000 + GO TO START[OP]; ERROR(10); MEMDUMP; GO TO EOJ; 50048000 +% PAGE 2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50049000 + STARTEVAL: 50050000 + STARTSTBR: 50051000 + LABELE: 50052000 + ADJ(1,2); 50053000 + GO TO L1; 50054000 + STARTNXLV: 50055000 + STARTNXLN: 50056000 + STARTINDX: 50057000 + ADJ(1,1); 50058000 + IF AX.TAG = SINGL OR AX.TAG = DOUBL THEN EXCH; 50059000 + L1: MOVE(A,C); AROF ~ FALSE; 50060000 + IF AX.TAG = IRW THEN GO TO LABELA ELSE GO TO DESCPAGE6; 50061000 +% PAGE 3 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50062000 + STARTENTR: 50063000 + ADJ(0,0); 50064000 + MOVE(M[F + 1], C); MEMCYCLE; 50065000 + IF CX.TAG ! IRW THEN I1INVALIDOPERATOR; % ON PAGE 44 50066000 + STARTIRWL: 50067000 + LABELA: 50068000 + MOVE (C,A); 50069000 + IF C.EBIT = 1 THEN GO TO STUFFEDIRW ELSE GO TO NORMALIRW; 50070000 +% PAGE 4 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50071000 + STARTVALC: 50072000 + T1 ~ T1&DRS[34:42:6] & SYLLABLE[40:40:8]; STEPPSR(1); 50073000 + BUF2 ~ D[LEVEL(T1)] + DELTA(T1); 50074000 + MOVE(M[D[LEVEL(T1)]+DELTA(T1)],C); MEMCYCLE; 50075000 + QC1F ~ 1; 50076000 + IF AROF THEN ADJ(0,2); 50077000 + IF CX.TAG = SINGL OR CX.TAG = DOUBL THEN 50078000 + BEGIN 50079000 + IF CX.TAG = DOUBL THEN MOVE (M[BUF2 + 1],X); 50080000 + MOVE (C,A); AROF ~ TRUE; 50081000 + GO TO OC; 50082000 + END; 50083000 + IF CX.TAG = IRW THEN GO TO LABELA; % ON PAGE 3 50084000 +% PAGE 6 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50085000 + DESCPAGE6: 50086000 + IF CX.TAG ! DATADESC THEN I1INVALIDOPERATOR; 50087000 + IF C.CHRSZ = 0 THEN 50088000 + BEGIN 50089000 + QC6F ~ 1; QC7F ~ C.DBIT 50090000 + END; 50091000 + IF C.IBIT = 1 THEN GO TO L2; % ON PAGE 7 50092000 + IF EVAL THEN GO TO LABELZ; % ON PAGE 9 50093000 + IF NOT (NXLV OR NXLN OR INDX) THEN I1INVALIDOPERATOR; 50094000 + LABELT: 50095000 + IF C.CHRSZ = 0 OR INDX THEN GO TO NORMALINDEX % ON PAGE 10 50096000 + ELSE I1INVALIDOPERATOR; 50097000 +% PAGE 7 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50098000 + L2: 50099000 + IF INDX THEN I1INVALIDOPERATOR; 50100000 + IF EVAL THEN GO TO LABELZ; % ON PAGE 9 50101000 + INDEXINDESC: 50102000 + IF C.SBIT ! 1 AND C.CHRSZ ! 0 THEN I1INVALIDOPERATOR; 50103000 + IF CX.pBIT ! 1 THEN I11PRESENCEBIT; 50104000 + T1 ~ C.SBIT; 50105000 + MOVE(M[BUF2 ~ C.INDEX + C.ADDR],C); MEMCYCLE; 50106000 + IF T1 = 1 THEN GO TO DESCPAGE6; 50107000 +% PAGE 8 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50108000 + IF NXLN THEN GO TO NXLNPAGE9; 50109000 + LABELC: 50110000 + IF CX.TAG=SINGL OR CX.TAG=DOUBL THEN GO TO OPERAND; % ON PAGE1550111000 + IF CX.TAG = SIW THEN GO TO INDEXWORD; % ON PAGE 17 50112000 + IF NXLV THEN I1INVALIDOPERATOR; 50113000 + GO TO DESCPAGE6; 50114000 +% PAGE 9 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50115000 + NXLNPAGE9: 50116000 + IF CX.TAG ! DATADESC THEN I1INVALIDOPERATOR; 50117000 + IF C.IBIT = 1 THEN I1INVALIDOPERATOR; 50118000 + LABELZ: 50118100 + IF CX.PBIT ! 1 THEN BEGIN 50119000 + IF C.CBIT ! 1 THEN C.ADDR ~ BUF2 50120000 + END; 50121000 + 50122000 + C.CBIT ~ 1; 50123000 + MOVE(C,A); AROF ~ TRUE; 50124000 + GO TO OC; 50125000 +% PAGE 10 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50126000 + NORMALINDEX: 50127000 + NTGR; IF INTFL THEN I2INTEGERIZE; 50128000 + IF B.MANF < 0 OR B.MANF } C.INDEX THEN I4INVALIDINDEX; 50129000 + IF C.SBIT = 1 THEN GO TO LABELP; % ON PAGE 12 50130000 + IF C.CHRSZ ! 0 THEN GO TO LABELQ; % ON PAGE 14 50131000 + IF C.DBIT = 1 THEN B ~ B | 2; 50131000 + C.INDEX ~ B.ADDR; 50132000 +% PAGE 11 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50133000 + SPECIALINDEX: 50134000 + C.IBIT ~ 1; BROF ~ FALSE; 50135000 + IF NOT INDX THEN GO TO INDEXINDESC; % ON PAGE 7 50136000 + GO LABELZ; 50136600 + MOVE (C,A); AROF ~ TRUE; 50137000 + GO TO OC; 50138000 +% PAGE 12 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50139000 + LABELP: 50140000 + CASE C.SZ OF 50141000 + BEGIN 50142000 + % SZ = 000 (DATA DESCRIPTOR) SINGLE PRECISION 50143000 + BEGIN A ~ 256; GO TO L4 END; 50144000 + % SZ = 001 (DATA DESCRIPTOR) DOUBLE PRECISION 50145000 + BEGIN A ~ 128; GO TO L4 END; 50146000 + % SZ = 010 4-BIT CHARACTERS (STRING DESCRIPTOR) 50147000 + BEGIN A ~ 3072; GO TO L4 END; 50148000 + % SZ = 011 6-BIT CHARACTERS (STRING DESCRIPTOR) 50149000 + BEGIN A ~ 2048; GO TO L4 END; 50150000 + % SZ = 100 8-BIT CHARACTERS (STRING DESCRIPTOR) 50151000 + BEGIN A ~ 1536; GO TO L4 END; 50152000 + END; 50153000 +% PAGE 13 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50154000 + L4: 50155000 + AROF ~ TRUE; 50156000 + IDIV; IF INTFL THEN I2INTEGERDIV; 50157000 + C.INDEX ~ B.ADDR; MOVE (A,B); C.IBIT ~ 1; 50158000 + GO TO INDEXINDESC; % ON PAGE 7 50159000 +% PAGE 14 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50160000 + LABELQ: 50161000 + CASE C.SZ OF 50162000 + BEGIN 50163000 + % SZ = 000 NOT POSSIBLE AT THIS POINT 50164000 + ; 50165000 + % SZ = 001 NOT POSSIBLE AT THIS POINT 50166000 + ; 50167000 + % SZ = 010 4-BIT CHARACTERS 50168000 + BEGIN T1 ~ 12; T2 ~ 4 END; 50169000 + % SZ = 011 6-BIT CHARACTERS 50170000 + BEGIN T1 ~ 8; T2 ~ 6 END; 50171000 + % SZ = 100 8-BIT CHARACTERS 50172000 + BEGIN T1 ~ 6; T2 ~ 8 END; 50173000 + END; 50174000 + MOVE (A,B); BROF ~ TRUE; A ~ T1; 50175000 + IDIV; IF INTFL THEN I2INTEGERDIV; 50176000 + C.[13:15] ~ B.[33:15]; AROF ~ TRUE; AX.TAG ~ SINGL; B ~ T2; 50177000 + MULT; IF INTFL THEN I2MULT; 50178000 + MOVE (B,A); B ~ 47; BROF ~ FALSE; 50179000 + B ~ B - A; 50180000 + C.[7:6] ~ B.[42:6]; 50181000 + GO TO SPECIALINDEX; % ON PAGE 11 50182000 +% PAGE 15 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50183000 + OPERAND: 50184000 + IF EVAL THEN GO TO L7; % ON PAGE 16 50185000 + IF QC6F = 1 THEN 50186000 + BEGIN 50187000 + IF QC7F = 1 THEN BEGIN CX.TAG ~ DOUBL; 50188000 + GO TO L5 END ELSE 50189000 + BEGIN CX.TAG ~ SINGL; 50190000 + GO TO L6 END; 50191000 + END; 50192000 + IF CX.TAG ! DOUBL THEN GO TO L6; 50193000 + L5: 50194000 + MOVE (M[BUF2 + 1], X); MEMCYCLE; 50195000 + L6: 50196000 + MOVE (C,A); 50197000 +% PAGE 16 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50198000 + L7: 50199000 + AROF ~ TRUE; 50200000 + IF NOT STBR THEN GO TO OC; 50201000 + ADJ (0,1); 50202000 + A ~ AX ~ 0; AROF ~ TRUE; STEPPSR (2); 50203000 + GO TO OC; 50204000 +% PAGE 17 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50205000 + INDEXWORD: 50206000 + C.CVF ~ C.CVF + C.INCRF; 50207000 + MOVE (C, M[BUF2]); MEMCYCLE; 50208000 + IF C.CVF { C.FVF THEN 50209000 + BEGIN 50210000 + A ~ AX ~ 1; STEPPSR (2); AROF ~ TRUE; 50211000 + GO TO OC 50212000 + END; 50213000 + GO TO STARTBRUN; 50214000 + 50215000 +% PAGE 18 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50216000 + STUFFEDIRW: 50217000 + QC6F ~ 0; Q04F ~ 1; 50218000 + LABELX: 50219000 + IF SNR = C.STKNR THEN 50220000 + BEGIN QC7F ~ 0; TEMP ~ BOSR END 50221000 + ELSE 50222000 + BEGIN 50223000 + MOVE(M[STACKVECTOR],C); MEMCYCLE; QC7F ~ 1; 50224000 + IF CX.PBIT !1 THEN I10PRESENCEBIT; 50225000 + IF C.LENGTH { A.STKNR THEN I4INVALIDINDEX; 50226000 + MOVE (M[C.ADDR + A.STKNR], C); MEMCYCLE; 50227000 + IF CX.PBIT !1 THEN I10PRESENCEBIT; 50228000 + TEMP ~ C.ADDR; 50229000 + END; 50230000 +% PAGE 19 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50231000 + IF Q04F ! 1 THEN 50232000 + IF STFF THEN 50233000 + GO TO LABELW % ON PAGE 42 50234000 + ELSE GO TO LABELD; % ON PAGE 22 50235000 + BUF ~ TEMP + A.DISP; 50236000 + BUF2 ~ BUF + A.ADRCPLSIR; 50237000 + IF IRWL THEN GO TO OC; 50238000 + Q04F ~ 0; MOVE(M[BUF + A.ADRCPLSIR] ,C); MEMCYCLE; 50239000 + IF CX.TAG = IRW AND C.EBIT = 0 THEN I1INVALIDOPERATOR 50240000 + ELSE GO TO LABELH; % ON PAGE 20 50241000 +% PAGE 20 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50242000 + NORMALIRW: 50243000 + BUF ~ D [LEVEL(C)]; BUF2 ~ BUF + DELTA(C); 50244000 + IF IRWL THEN GO TO OC; 50245000 + MOVE (M[BUF + DELTA(C)],C); MEMCYCLE; 50246000 + LABELH: 50247000 + IF CX.TAG = IRW THEN GO TO LABELA; % ON PAGE 3 50248000 + IF CX.TAG = PCW THEN GO TO PCWPAGE22; 50249000 + IF ENTR THEN I1INVALIDOPERATOR; 50250000 + IF NOT (NXLN OR NXLV OR INDX) THEN 50251000 + BEGIN 50252000 + QC6F ~ 0; 50253000 + GO TO LABELC % ON PAGE 8 50254000 + END; 50255000 +% PAGE 21 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50256000 + IF CX.TAG ! DATADESC OR C.IBIT ! 0 THEN I1INVALIDOPERATOR; 50257000 + GO TO DESCPAGE6; % ON PAGE 6 50258000 +% PAGE 22 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50259000 + STARTPCWL: 50260000 + PCWPAGE22: 50261000 + IF NOT (ENTR OR BOOLEAN (QC1F)) THEN 50262000 + BEGIN 50263000 + PIR ~ PIR - PICR; 50264000 + PSR ~ OPSR; 50265000 + END; 50266000 + MOVE (C,X); 50267000 + IF A.EBIT ! 0 THEN GO TO L8; 50268000 + 50269000 + A.STKNR ~ C.STKNR; 50270000 + GO TO LABELX; 50271000 + LABELD: 50272000 + TS ~ D[LEVEL(A)]; 50273000 + A.DISP ~ TS - TEMP; 50274000 + L8: 50275000 + C ~ CX ~ 0; 50276000 + C.NBIT ~ REAL(NCSF); IIHF ~ BOOLEAN(X.NBIT); 50277000 + NCSF ~ BOOLEAN(X.NBIT); 50278000 + C.SDIF ~ PDR; PDR ~ X.SDIF; 50279000 +% PAGE 23 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50280000 + C.PSRF ~ PDR; PDR ~ X.PSRF; 50281000 + C.PIRF ~ PIR; PIR ~ X.PIRF; 50282000 + C.FLTFF ~ REAL (FLTF); 50283000 + C.TFFFF ~ REAL (TFFF); 50284000 + C.OFFFF ~ REAL (OFFF); 50285000 + CX.SGNFF ~ SGNF; 50286000 + C.LLF ~ LL; 50287000 + TS ~ LL; LL ~ X.LLF; X.[10:5] ~ TS; 50288000 + CX.TAG ~ RCW; 50289000 + IF ENTR THEN 50290000 + BEGIN % EXPECTED PROCEDURE ENTRY 50291000 + MOVE (C,M[F + 1]); MEMCYCLE; 50292000 + MOVE (M[F],C); MEMCYCLE; 50293000 + C.STKNR ~ A.STKNR; 50294000 + C.DISP ~ A.DISP; 50295000 + CX.DSBIT ~ QC7F; 50296000 + C.LLF ~ LL; 50297000 + C.EBIT ~ 1; 50298000 + MOVE (C,M[F]); MEMCYCLE; 50299000 + GO TO DISPLAYUPDATE; % ON PAGE 25 50300000 + END; 50300500 +% PAGE 24 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50301000 + % ACCIDENTAL PROCEDURE ENTRY 50302000 + ADJ (0,0); 50303000 + MOVE (A,B); 50304000 + MOVE (C,A); 50305000 + B.DSBIT ~ QC7F; 50306000 + B.DF ~ S + 1 - F; 50307000 + F ~ S + 1; 50308000 + B.VBIT ~ QC1F; 50309000 + BX.TAG ~ MSCW; 50310000 + B.LLF ~ LL; 50311000 + B.EBIT ~ 1; 50312000 + AROF ~ BROF ~ TRUE; 50313000 + ADJ (0,0); 50314000 +% PAGE 25 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50315000 + DISPLAYUPDATE: 50316000 + D [LL] ~ F; 50317000 + X.LLF ~ LL; 50318000 + L9: 50319000 + IF LL = 0 OR QC6F = 1 THEN 50320000 + BEGIN 50321000 + BYPASUPDATE: 50322000 + LL ~ X.LLF; 50323000 + IF MVST THEN GO TO OC 50324000 + ELSE GO TO SEGMENTDESC; % ON PAGE 28 50325000 + END; 50326000 + LL ~ LL - 1; 50327000 + IF D[LL] = BUF AND LL { X.[10:5] THEN GO TO BYPASUPDATE; 50328000 + D[LL] ~ BUF; MOVE (M[BUF], C); MEMCYCLE; 50329000 +% PAGE 26 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50330000 + IF CX.TAG ! MSCW OR LL ! C.LLF THEN 50331000 + BEGIN 50332000 + QC2F ~ 1; I7SEQUENCEERROR; 50333000 + END; 50334000 + LABELF: 50335000 + IF CX.DSBIT = 0 THEN 50336000 + BEGIN 50337000 + BUF ~ TEMP + C.DISP; 50338000 + GO TO L9 50339000 + END; 50340000 + MOVE (C,A); 50341000 + BUF2 ~ D0 + 2; 50342000 + MOVE (M[STACKVECTOR], C); MEMCYCLE; 50343000 + IF CX.PBIT ! 1 THEN I12PRESENCEBIT; 50344000 + IF C.LENGTH { A.STKNR THEN 50345000 + BEGIN 50346000 + QC2F ~ 1; 50347000 + I3INVALIDINDEX; 50348000 + END; 50349000 +% PAGE 27 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50350000 + BUF2 ~ C.ADDR + A.STKNR; 50351000 + MOVE (M[BUF2], C); MEMCYCLE; 50352000 + IF CX.PBIT ! 1 THEN I12PRESENCEBIT; 50353000 + TEMP ~ C.ADDR; 50354000 + BUF ~ TEMP + A.DISP; 50355000 + GO TO L9; 50356000 +% PAGE 28 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50357000 + SEGMENTDESC: 50358000 + C.SDIF ~ PDR; 50359000 + BUF2 ~ D[C.LEVELPCW] + C.DELTAPCW; 50360000 + MOVE (M[D[C.LEVELPCW] + C.DELTAPCW], C); MEMCYCLE; 50361000 + IF CX.TAG ! SEGDESC THEN 50362000 + BEGIN 50363000 + QC2F ~ 1; 50364000 + I8SEQUENCEERROR; 50365000 + END; 50366000 + IF CX.PBIT ! 1 THEN I12PRESENCEBIT; 50367000 + PBR ~ C.ADDR; PROF ~ FALSE; 50368000 + IF NOT RETN THEN GO TO OC; 50369000 +% PAGE 29 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50370000 + IF QC1F ! 1 THEN GO TO OC; 50371000 + OP ~ 1; % FORCE A VALC INTO THE T REGISTER AND CONTINUE THE 50372000 + % PROCESSING AS A VALUE CALL OPERATOR 50373000 + GO TO LABELE; % ON PAGE 2 50374000 +% PAGE 30 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50375000 + STARTRETN: 50376000 + ADJ (0,1); 50377000 + L10: 50378000 + F ~ D[LL]; 50379000 + MOVE (M[F + 1], C); MEMCYCLE; 50380000 + IIHF ~BOOLEAN(C.NBIT); PDR ~ C.SDIF; PIR ~ C.PIRF; 50381000 + PSR ~ C.PSRF; NCSF ~BOOLEAN(C.NBIT); X.[10:5] ~ LL; 50382000 + FLTF ~BOOLEAN(C.FLTFF); TFFF ~BOOLEAN(C.TFFFF); OFFF ~ BOOLEAN 50383000 + (C.OFFFF); SGNF ~ CX.SGNFF; LL ~ C.LLF; 50384000 + S ~ F - 1; 50385000 + TEMP ~ BOSR; X.LLF ~ LL; 50386000 + IF F = BOSR + 1 THEN 50387000 + BEGIN 50388000 + QC2F ~ 1; 50389000 + I6BOSNORMAL; 50390000 + END; 50391000 + GO TO LABELG; % ON PAGE 31 50392000 +% PAGE 31 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50393000 + STARTEXIT: 50394000 + ADJ (0,0); 50395000 + GO TO L10; % ON PAGE 30 50396000 + LABELG: 50397000 + MOVE (M[F], C); MEMCYCLE; 50398000 + IF CX.TAG ! MSCW THEN 50399000 + BEGIN 50400000 + QC2F ~ 1; 50401000 + I8SEQUENCEERROR; 50402000 + END; 50403000 + F ~ F - C.DF; 50404000 + BUF ~ F; QC1F ~ C.VBIT; 50405000 + LABELS: 50406000 + IF BOSR > BUF THEN 50407000 + BEGIN 50408000 + SUFL ~ TRUE; 50409000 + I5BOSERROR; 50410000 + END; 50411000 + D[LL] ~ BUF; MOVE (M[BUF], C); MEMCYCLE; 50412000 +% PAGE 32 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50413000 + IF CX.TAG ! MSCW THEN 50414000 + BEGIN 50415000 + QC2F ~ 1; I8SEQUENCEERROR; 50416000 + END; 50417000 + IF LL = C.LLF AND C.EBIT = 1 THEN GO TO LABELF; % ON PAGE 26 50418000 + BUF ~ D[LL] - C.DF; 50419000 + GO TO LABELS; % ON PAGE 31 50420000 +% PAGE 33 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50421000 + STARTMVST: 50422000 + ADJ (0,1); 50423000 + C.DF ~ S - F; C.LLF ~ LL; C.NBIT ~ REAL (NCSF); 50424000 + C.DS ~ S - BOSR; 50425000 + C.FLTFF ~REAL(FLTF); C.TFFFF ~REAL(TFFF); C.OFFFF ~REAL(OFFF); 50426000 + CX.SGNFF ~ SGNF; CX.TAG ~ TOS; 50427000 + MOVE (M[BOSR], T1); 50428000 + IF T2.ROBIT ! 1 THEN 50429000 + BEGIN MOVE (C,M[BOSR]); MEMCYCLE END; 50430000 + COMMENT THE LAST TWO STATEMENTS USE PSEUDO REGISTER T1,T2 TO 50431000 + SIMULATE PROTECT LOGIC IN MEMORY MODULES; 50432000 + BUF2 ~ D0 + 2; 50433000 + MOVE (M[STACKVECTOR], C); MEMCYCLE; 50434000 + IF CX.PBIT ! 1 THEN I13PRESENCEBIT; 50435000 + NTGR; IF INTFL THEN I2INTEGERIZE; 50436000 + IF B.MANF < 0 OR B.MANF } C.LENGTH THEN I4INVALIDINDEX; 50437000 + BUF2 ~ C.ADDR + B.ADDR; 50438000 + MOVE (M[C.ADDR + B.ADDR], A); MEMCYCLE; 50439000 +% PAGE 34 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50440000 + IF AX.PBIT ! 1 THEN 50441000 + BEGIN MOVE (A,C); I13PRESENCEBIT; END; 50442000 + SNR ~ B.ADDR;BROF ~ FALSE; 50443000 + BOSR ~ A.ADDR; TEMP ~ A.ADDR; LOSR ~ A.ADDR + A.LENGTH; 50444000 + C ~ PID; CX.TAG ~ SINGL; 50445000 + MOVE (M[BOSR], T1); MOVE (C, M[BOSR]); MOVE (T1, C); MEMCYCLE; 50446000 + S ~ C.DS + BOSR; F ~ S - C.DF; BUF ~ S - C.DF; LL ~ C.LLF; 50447000 + X.[10:5] ~ LL; NCSF ~ BOOLEAN (C.NBIT); IIHF ~ BOOLEAN(C.NBIT);50448000 + FLTF ~ BOOLEAN (C.FLTFF); TFFF ~ BOOLEAN (C.TFFFF); 50449000 + OFFF ~ BOOLEAN (C.OFFFF); SGNF ~ C.SGNFF; 50450000 + X.LLF ~ LL; 50451000 + GO TO LABELS; % ON PAGE 31 50452000 +% PAGE 35 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50453000 + STARTDBTR: 50454000 + ADJ (1,1); 50455000 + IF B.LOBIT ! 1 THEN GO TO L11 50456000 + ELSE GO TO L12; 50457000 + STARTDBFL: 50458000 + ADJ (1,1); 50459000 + IF B.LOBIT = 1 THEN 50460000 + L11: BEGIN AROF ~ FALSE; BROF ~ FALSE; GO TO OC END; 50461000 + L12: BROF ~ FALSE; 50462000 + GO TO LABELB; % ON PA6E 36 50463000 +% PAGE 36 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50464000 + STARTDBUN: 50465000 + ADJ (1,2); 50466000 + LABELB: 50467000 + IF AX.TAG = SINGL OR AX.TAG = DOUBL THEN 50468000 + GO TO LABELOPND; % ON PAGE 36 50469000 + MOVE (A,C); 50470000 + L13: IF CX.TAG = IRW THEN 50471000 + BEGIN 50472000 + IF C.EBIT ! 0 THEN 50473000 + BEGIN AROF ~ FALSE; I8SEQUENCEERROR END; 50474000 + MOVE (M[D[LEVEL(C) ] + DELTA(C) ], C);MEMCYCLE; 50475000 + GO TO L13; 50476000 + END; 50477000 +% PAGE 37 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50478000 + IF CX.TAG = PCW THEN GO TO PCW2; % ON PAGE 39 50479000 + AROF ~ FALSE; 50480000 + I1INVALIDOPERATOR; 50481000 +% PAGE 38 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50482000 + LABELOPND: 50483000 + NTGR; IF INTFL THEN I2INTEGERIZE; 50484000 + IF B.MANF < 0 THEN I9INVALIDINDEX; 50485000 + IF B.MANF } 2097152 THEN I9INVALIDINDEX; 50486000 + IF B.LOBIT = 0 THEN PSR ~ 0 50487000 + ELSE PSR ~ 3; 50488000 + PIR ~ B.[27:20]; PROF ~ FALSE; BROF ~ FALSE; 50489000 + GO TO OC; 50490000 +% PAGE 39 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50491000 + PCW2: 50492000 + IF LL ! C.LLF THEN 50493000 + BEGIN AROF ~ FALSE; I8SEQUENCEERROR END; 50494000 + PDR ~ C.SDIF; PSR ~ C.PSRF; PIR ~ C.PIRF; 50495000 + BUF2 ~ D[C.LEVELPCW] + C.DELTAPCW; 50496000 + MOVE (M[D[C.LEVELPCW] + C.DELTAPCW], C); 50497000 + AROF ~ FALSE; 50498000 + IF CX.TAG ! SEGDESC THEN 50499000 + BEGIN QC2F ~ 1; I8SEQUENCEERROR END; 50500000 + IF CX.PBIT ! 1 THEN I12PRESENCEBIT; 50501000 + PBR ~ C.ADDR; PROF ~ FALSE; 50502000 + GO TO OC; 50503000 +% PAGE 40 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50504000 + STARTBRTR: 50505000 + ADJ (1,2); 50506000 + IF A.LOBIT ! 1 THEN 50507000 + L14: BEGIN STEPPSR (2); AROF ~ FALSE; GO TO OC END; 50508000 + L15: 50509000 + AROF ~ FALSE; 50510000 + STARTBRUN: 50511000 + C.[32:8] ~ SYLLABLE; STEPPSR(1); C.[40:8] ~ SYLLABLE; 50512000 + PSR ~ C.[32:3]; PIR ~ C.[35:13]; PROF ~ FALSE; 50513000 + GO TO OC; 50514000 + STARTBRFL: 50515000 + ADJ (1,2); 50516000 + IF A.LOBIT = 0 THEN GO TO L15 ELSE GO TO L14; 50517000 +% PAGE 41 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50518000 + STARTSTFF: 50519000 + ADJ (1,2); 50520000 + IF AX.TAG ! IRW THEN 50521000 + BEGIN MOVE (A, C); I1INVALIDOPERATOR END; 50522000 + BUF ~ BUF2 ~ D[LEVEL(A)]; 50523000 + L16: 50524000 + MOVE (M[BUF2], C); 50525000 + IF CX.TAG ! MSCW THEN I8SEQUENCEERROR; 50526000 + IF CX.DSBIT ! 0 THEN 50527000 + BEGIN BUF2 ~ BUF2 - C.DF; GO TO L16 END; 50528000 + A.STKNR ~ C.STKNR; 50529000 + GO TO LABELX; % ON PAGE 18 50530000 +% PAGE 42 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50531000 + LABELW: 50532000 + A.DISP ~ BUF - TEMP; A.ADRCPL ~ DELTA(A); A.EBIT ~ 1; 50533000 + GO TO OC; 50534000 +% PAGE 43 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50535000 + STARTMKST: 50536000 + ADJ (0,0); 50537000 + B ~ BX ~ 0; 50538000 + B.DF ~ S + 1 - F; F ~ S + 1; BX.TAG ~ MSCW; BROF ~ TRUE; 50539000 + ADJ (0,0); 50540000 + GO TO OC; 50541000 +% PAGE 44 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% SET INTERRUPTS FOR ALL ERVSFLOW50542000 + % SYLLABLE DEPENDENT INTERRUPTS 50543000 + % (NON-PRESENCE BIT) 50544000 + INVOPLBL: 50545000 + ADJ (0,0); 50546000 + B ~ BX ~ 0; 50547000 + B ~ INVOP; 50548000 + GO TO L17; 50549000 + INVINDLBL: 50550000 + ADJ (0,0); 50551000 + B ~ BX ~ 0; 50552000 + B ~ INVINXI; 50553000 + GO TO L17; 50554000 + STKUNFLBL: 50555000 + ADJ (0,0); 50556000 + B ~ BX ~ 0; 50557000 + B ~ STKUNFI; 50558000 + BROF ~ TRUE; 50559000 + GO TO OC; 50560000 +% PAGE 45 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50561000 + BOSLBL: 50562000 + ADJ (0,0); 50563000 + B ~ BX ~ 0; 50564000 + B ~ BOSINT; 50565000 + GO TO L17; 50566000 + SEQERLBL: 50567000 + ADJ (0,0); 50568000 + B ~ BX ~ 0; 50569000 + B ~ SEQERRI; 50570000 + L17: PIR ~ PIR - PICR; PSR ~ OPSR; 50571000 + INTLBL: % SET INTERRUPT FOR INTERRUPT CONDITION RECOGNISED WHEN 50572000 + % INTEGERIZE USED AS SUB-OPERATOR IN ERVSFLOW. NOTE THAT 50573000 + % SETTING OF B WITH INTERRUPT ID AND OTHER NECESSARY OPER-50574000 + % ATIONS TOOK PLACE AT TIME INTERRUPT WAS RECOGNISED IN 50575000 + % INTEGERIZE. 50576000 + BROF ~ TRUE; 50577000 + SDIS ~ 1; MOVE (C,A); AROF ~ TRUE; 50578000 + GO TO OC; 50579000 +% PAGE 46 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50580000 + PRES13LBL: 50581000 + ADJ (0,0); 50582000 + PRES11LBL: 50583000 + IF C.CBIT ! 1 THEN 50584000 + BEGIN C.CBIT ~ 1; C.ADDR ~ BUF2 END; 50585000 + MOVE (C,A); 50586000 + PRES10LBL: 50587000 + ADJ (0,0); 50588000 + IF NOT (VALC OR ENTR OR MVST) THEN T1 ~ 1; % CHECK ** 50589000 + PIR ~ PIR - PICR; PSR ~ OPSR; 50590000 + L18: 50591000 + B ~ BX ~ 0; 50592000 + SDIS ~ 1; AROF ~ BROF ~ TRUE; B.SOBIT ~ T1; 50593000 + B.[18:30] ~ PRESBIT; 50594000 + GO TO OC; 50595000 + PRES12LBL: 50596000 +% PAGE 47 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50597000 + IF C.CBIT ! 1 THEN 50598000 + BEGIN C.CBIT ~ 1; C.ADDR ~ BUF2 END; 50599000 + MOVE (C,A); 50600000 + ADJ (0,0); 50601000 + GO TO L18; % ON PAGE 46 50602000 + OC: 50603000 +END ERVSFLOW; 50604000 +PROCEDURE STORE(OP); VALUE OP; REAL OP; 51000000 +COMMENT OP=0: STORE DESTRUCTIVE 51001000 + OP=1: STORE NON-DESTRUCTIVE 51002000 + OP=2: OVERWRITE DESTRUCTIVE 51003000 + OP=3: OVERWRITE NON-DESTRUCTIVE 51004000 + OP=7: READ-WITH-LOCK; 51005000 + BEGIN 51006000 + LABEL EVALDESC,EVALIRW,TRYWRITE,MIXEDTYPECHECK,FIXROFS, 51007000 + LABELF,ACCIDENTALENTRY, 51008000 + OC; 51009000 + DEFINE INVALIDOP = BEGIN INTFAMD(2); GO OC; END#, 51010000 + PRESENCEBIT = BEGIN INTFAMD(8); GO OC END#, 51011000 + INVALIDINDEX= BEGIN INTFAMD(7); GO OC END#, 51012000 + MEMORYPROTECT=BEGIN INTFAMD(6); GO OC END#; 51013000 + DEFINE OVERWRITE = (OP=2 OR OP=3)#, 51014000 + NONDESTRUCTIVE = BOOLEAN(OP)#, 51015000 + DESTRUCTIVE = NOT NONDESTRUCTIVE#, 51016000 + READWITHLOCK = (OP=7)#; 51017000 +%%%%% PAGE 1 %%%%%%%%%%%%%%% 51018000 + ADJ(1,1); 51026000 + IF AX.TAG=SINGL OR AX.TAG=DOUBL THEN EXCH; 51027000 + MOVE(A,C); 51029000 + IF CX.TAG=IRW THEN GO TO EVALIRW; 51030000 + IF CX.TAG!DATADESC OR C.IBIT!1 THEN INVALIDOP; 51031000 + EVALDESC: 51032000 + IF C.RBIT!0 THEN MEMORYPROTECT; 51033000 + IF CX.PBIT!1 THEN PRESENCEBIT; 51034000 + MM~C.INDEX+C.ADDR; 51035000 +TRYWRITE: 51036000 + IF MM + MM > MEMMODS % INVALID ADDRESS CHECK FOR STORES 51036100 + THEN BEGIN 51036200 + SETINTERRUPT (INVADRI); 51036300 + GO OC 51036400 + END; 51036500 + MOVE(M[MM],C); MEMCYCLE; 51037000 + IF OVERWRITE OR READWITHLOCK OR NOT BOOLEAN(CX.TAG) 51038000 + THEN MOVE(B,M[MM]); 51039000 + IF OVERWRITE OR READWITHLOCK THEN GO TO LABELF; 51040000 +%%%%% PAGE 2 %%%%%%%%%%%%%%% 51041000 + CASE CX.TAG OF 51042000 + BEGIN % CASE TYPE 51043000 + ; % 0 SINGL 51044000 + GO TO EVALIRW; % 1 IRW 51045000 + ; % 2 DOUBL 51046000 + MEMORYPROTECT; % 3 LINKS,CODE,MSCW,RCW,L 51047000 + ; % 4 STEP INDEX WORD 51048000 + IF C.IBIT=1 THEN GO EVALDESC ELSE MEMORYPROTECT; % 5 51049000 + ; % 6 UNINITIALIZED 51050000 + GO TO ACCIDENTALENTRY; % 7 PCW 51051000 + END; 51052000 + MIXEDTYPECHECK: 51053000 + CASE REAL(CX.TAG=DOUBL)|2 + REAL(BX.TAG=DOUBL) OF 51054000 + BEGIN % C B 51055000 + ; % S S 51056000 + BEGIN IF Y.[9:1]=1 THEN B~(B+1)&B[1:1:8]; % S D 51057000 + BX.TAG~0; MOVE(B,M[MM]); MEMCYCLE; % 51058000 + END; % 51059000 + BEGIN BX.TAG~DOUBL; Y~YX~0; YX.TAG~DOUBL; % D S 51060000 + MOVE(B,M[MM ]); MEMCYCLE; % 51061000 + MOVE(Y,M[MM+1]); MEMCYCLE; % 51062000 + END; % 51063000 + BEGIN MOVE(Y,M[MM+1]); MEMCYCLE; % D D 51064000 + END; % 51065000 + END; 51066000 + FIXROFS: 51067000 + AROF~FALSE; 51068000 + BROF~NONDESTRUCTIVE; 51069000 + GO TO OC; 51070000 + LABELF: 51071000 + IF NOT READWITHLOCK THEN GO TO FIXROFS; 51072000 + MOVE(C,A); 51073000 + BROF ~ FALSE; 51073100 + GO TO OC; 51074000 +%%%%% PAGE 3 %%%%%%%%%%%%%%% 51075000 + EVALIRW: 51076000 + IF C.EBIT=0 THEN 51077000 + BEGIN %%%%% NORMAL IRW %%%%% 51078000 + Q02F~1; 51079000 + A.DISP~D[LEVEL(C)] - BOSR; 51080000 + A.STKNR~SNR; 51081000 + TEMP~BOSR; 51082000 + BUF~D[LEVEL(C)]; 51083000 + MM~BUF+DELTA(C); 51084000 + END 51085000 + ELSE 51086000 + BEGIN %%%%% STUFFED IRW %%%%% 51087000 + Q02F~0; 51088000 + MOVE(C,A); 51089000 + IF SNR = C.STKNR THEN TEMP~BOSR 51090000 + ELSE BEGIN 51091000 + MOVE(M[STACKVECTOR],C); MEMCYCLE; 51092000 + IF CX.PBIT=0 THEN PRESENCEBIT; 51093000 + IF C.LENGTH{A.STKNR THEN INVALIDINDEX; 51094000 + MOVE(M[C.ADDR+A.STKNR],C); MEMCYCLE; 51095000 + IF CX.PBIT=0 THEN PRESENCEBIT; 51096000 + TEMP~C.ADDR; 51097000 + END; 51098000 + BUF~TEMP+A.DISP; 51099000 + MM~BUF+A.[35:13]; 51100000 + END; 51101000 + GO TO TRYWRITE; 51102000 + ACCIDENTALENTRY: 51103000 + Q01F~1; 51104000 + NOTYETCODED; 51105000 + OC: 51106000 + END STORE; 51107000 +PROCEDURE ADJ(NEWAROF,NEWBROF); VALUE NEWAROF,NEWBROF; 60000000 + INTEGER NEWAROF,NEWBROF; 60001000 + BEGIN DEFINE 60002000 + PUSHA = 60003000 + BEGIN 60003150 + STKOVFF ~ S ~ S + 1 =LOSR; 60003300 + MOVE(A, M[S]); MEMCYCLE; AROF ~ FALSE; 60004000 + IF AX.TAG = DOUBL 60004300 + THEN BEGIN 60004600 + STKOVFF ~ S ~ S + 1 = LOSR; 60005000 + XX.TAG ~ DOUBL; MOVE(X, M[S]); MEMCYCLE; 60006000 + END 60006300 + END#, 60006600 + PUSHB = 60007000 + BEGIN 60007150 + STKOVFF ~ S ~ S + 1 =LOSR; 60007300 + MOVE(B, M[S]); MEMCYCLE; BROF ~ FALSE; 60008000 + IF BX.TAG = DOUBL 60008300 + THEN BEGIN 60008600 + STKOVFF ~ S ~ S + 1 = LOSR; 60009000 + YX.TAG ~ DOUBL; MOVE(Y, M[S]); MEMCYCLE; 60010000 + END 60010300 + END#, 60010600 + POPA = BEGIN MOVE(M[S],A); S~S-1; MEMCYCLE; AROF~TRUE; 60011000 + IF AX.TAG=DOUBL THEN 60012000 + BEGIN X~A; XX~AX; 60013000 + MOVE(M[S],A); S~S-1; MEMCYCLE; 60014000 + END; 60015000 + END#, 60016000 + POPB = BEGIN MOVE(M[S],B); S~S-1; MEMCYCLE; BROF~TRUE; 60017000 + IF BX.TAG=DOUBL THEN 60018000 + BEGIN Y~B; YX~BX; 60019000 + MOVE(M[S],B); S~S-1; MEMCYCLE; 60020000 + END; 60021000 + END#, 60022000 + ATOB = BEGIN B~A; BX~AX; AROF~FALSE; BROF~TRUE; 60023000 + IF AX.TAG=DOUBL THEN BEGIN Y~x; YX~XX; END; 60024000 + END#, 60025000 + BTOA = BEGIN A~B; AX~BX; AROF~TRUE; BROF~FALSE; 60026000 + IF BX.TAG=DOUBL THEN BEGIN X~Y; XX~YX; END; 60027000 + END#; 60028000 + IF NEWAROF<0 OR NEWAROF>1 OR NEWBROF<0 OR NEWBROF>2 60029000 + THEN BEGIN ERROR(98); GO TO EOJ; END; 60030000 + AROF~AROF AND TRUE; BROF~BROF AND TRUE; 60031000 + CASE (0&NEWAROF[45:47:1]&NEWBROF[43:46:2] 60032000 + &REAL(AROF)[46:47:1]&REAL(BROF)[47:47:1]) OF 60033000 + BEGIN % NEWA NEWB AROF BROF CASE 60034000 + ; % 0 0 0 0 0 60035000 + PUSHB; % 0 0 0 1 1 60036000 + PUSHA; % 0 0 1 0 2 60037000 + BEGIN PUSHB; PUSHA; END; % 0 0 1 1 3 60038000 + POPA; % 1 0 0 0 4 60039000 + BTOA; % 1 0 0 1 5 60040000 + ; % 1 0 1 0 6 60041000 + PUSHB; % 1 0 1 1 7 60042000 + POPB; % 0 1 0 0 8 60043000 + ; % 0 1 0 1 9 60044000 + ATOB; % 0 1 1 0 10 60045000 + BEGIN PUSHB; ATOB; END; % 0 1 1 1 11 60046000 + BEGIN POPA; POPB; END; % 1 1 0 0 12 60047000 + BEGIN BTOA; POPB; END; % 1 1 0 1 13 60048000 + POPB; % 1 1 1 0 14 60049000 + ; % 1 1 1 1 15 60050000 + ; % 0 2 0 0 16 60051000 + ; % 0 2 0 1 17 60052000 + ATOB; % 0 2 1 0 18 60053000 + BEGIN PUSHB; ATOB; END; % 0 2 1 1 19 60054000 + POPA; % 1 2 0 0 20 60055000 + BTOA; % 1 2 0 1 21 60056000 + ; % 1 2 1 0 22 60057000 + ; % 1 2 1 1 23 60058000 + END; 60059000 + IF NOT (NEWAROF=REAL(AROF) AND (NEWBROF=2 OR 60060000 + NEWBROF=REAL(BROF))) 60061000 + THEN BEGIN ERROR(99); MEMDUMP; GO EOJ END; 60062000 + END ADJ; 60063000 +INTEGER PROCEDURE LEVEL(WORD); VALUE WORD; REAL WORD; 60064000 + BEGIN 60065000 + LEVEL ~ REFLECTION[REAL( 60066000 + BOOLEAN(WORD) AND NOT BOOLEAN(DELTAMASK[LL])60067000 + ).[34:5]]; 60068000 + END LEVEL; 60069000 +INTEGER PROCEDURE DELTA(WORD); VALUE WORD; REAL WORD; 60070000 + BEGIN 60071000 + DELTA ~ REAL(BOOLEAN(WORD) AND BOOLEAN(DELTAMASK[LL])); 60072000 + END DELTA; 60073000 +BOOLEAN PROCEDURE INTEGERIZE(ROUND,REG); VALUE ROUND; 60074000 + BOOLEAN ROUND; REAL REG; 60075000 + BEGIN 60076000 + STREAM PROCEDURE M0VE4(S,D); 60077000 + BEGIN SI~S; DI~D; DS~4 WDS; 60078000 + END M0VE4; 60079000 + REAL OWNA,OWNAX,OWNX,OWNXX; 60080000 + INTEGER I; 60081000 + LABEL FINIS; 60082000 + DEFINE MAXNTGR = 549755813887#; 60083000 + M0VE4(REG,OWNA); 60084000 + IF OWNAX.TAG!SINGL AND OWNAX.TAG!DOUBL THEN 60085000 + INTEGERIZE ~ TRUE; 60086000 + IF (INTEGERIZE~ABS(OWNA)>MAXNTGR) THEN GO TO FINIS; 60087000 + IF NOT ROUND THEN 60088000 + I ~ OWNA DIV 1 60089000 + ELSE IF OWNAX.TAG =SINGL THEN 60090000 + I ~ OWNA 60091000 + ELSE % DOUBLE PRECISION ROUNDED CASE 60092000 + BEGIN 60093000 + DOUBLE(OWNA,OWNX,(I~OWNA DIV 1),0,-, 60094000 + ~,OWNAX,OWNXX); 60095000 + IF I}0 AND OWNAX}(0.5) THEN 60096000 + BEGIN 60097000 + IF (INTEGERIZE~(I+1)>+(MAXNTGR)) THEN 60098000 + GO TO FINIS; 60099000 + I~I+1; 60100000 + END 60101000 + ELSE IF I<0 AND OWNAX<-(0.5) THEN 60102000 + BEGIN 60103000 + IF (INTEGERIZE~(I-1)<-(MAXNTGR)) THEN 60104000 + GO TO FINIS; 60105000 + I~I-1; 60106000 + END; 60107000 + END; 60108000 + OWNA~1; OWNAX~SINGL+SINGL; MOVE(OWNA,REG); 60109000 + FINIS: 60110000 + END INTEGERIZE; 60111000 +PROCEDURE INITIALIZE; 71000000 + BEGIN 71001000 + FILE CODE DISK SERIAL (2,30); 71002000 + FORMAT ERROR ("EQUATED FILE IS NOT ON DISK. ", 32("X"), //); 71003000 + LABEL EOF; 71004000 + ARRAY JUNK[0:59],JUNK1[0:29]; 71005000 + ARRAY MEMS[0:89]; 71005100 + LABEL EOF1; 71006000 + INTEGER MSTART; 71007000 + STREAM PROCEDURE MOVEN(S,D,N); VALUE N; 71008000 + BEGIN SI~S; DI~D; DS~N WDS END; 71009000 + STREAM PROCEDURE STRIP(J,M); 71010000 + BEGIN LOCAL S,SS; 71011000 + SI~J; DI~M; 71012000 +45(48 BITS; SKIP 31 DB; 16 BITS; SKIP 1 DB); 71013000 + END; 71014000 +STREAM PROCEDURE NFLAG(M); 71015000 + BEGIN SI~M; DI~M; DI~DI+8; DI~DI+7; SKIP 5 DB; 71016000 + 1 BITS; DI~DI+4; DI~M; DS~1 RESET; END; 71017000 + SEARCH(CODE,TBUF[*]); 71018000 + IF TBUF[0] > 0 THEN 71019000 + BEGIN 71020000 + MULFILID ~ TBUF[1]; 71020100 + FILID ~ TBUF [2]; 71020200 + MSTART~0; 71021000 + DO BEGIN 71022000 + READ(CODE,30,JUNK[*])[EOF]; 71023000 + READ(CODE,30,JUNK1[*])[EOF1]; 71024000 + MOVEN(JUNK1,JUNK[30],30); 71025000 + EOF1: 71026000 + STRIP(JUNK,MEMS); 71027000 + FOR INTG~0 STEP 2 UNTIL 89 DO 71028000 + BEGIN 71028100 + IF MSTART+INTG/2 > 8191 THEN GO EOF; 71028110 + NFLAG(MEMS[INTG]); 71028200 + MOVE(MEMS[INTG],M[MSTART+INTG/2]); 71028300 + END; 71029000 + MSTART~MSTART+45; 71030000 + END UNTIL FALSE; 71031000 +EOF: 71032000 + END ELSE BEGIN WRITE (LP, ERROR); GO EOF END; 71033000 + 71034000 + 71035000 + 71036000 + 71037000 + 71038000 + S~8192; PDR~2; SNR~2; 71039000 + SNR ~0; 71040000 + SETINTERRUPT (EXTINTI + 15); 71045000 + P~0&32768[8:28:20]; 71046000 + PX~11; 71047000 + MOVE(P,M[4]); 71048000 + END OF INITIALIZE; 71049000 +PROCEDURE COBOLSIM; % SPECIAL INITIALIZATION FOR COBOL SIMULATION; 71050000 + BEGIN 71051000 + FILE DK DISK SERIAL "SIM" "INPUT" (2,30,150); 71052000 + ARRAY J[0:29]; 71053000 + REAL SZ; 71054000 + INTEGER I,K; 71055000 +STREAM PROCEDURE MV(F,T); 71056000 + BEGIN 71057000 + SI ~ F; DI ~ T; DS ~2 WDS; 71058000 + END MV; 71059000 + READ(DK,30,J[*]); 71060000 + D0 ~ J[0]; 71061000 + D1 ~ J[2]; 71062000 + D2 ~ J[4]; 71063000 + S ~ (D3 ~F ~ J[6]) + 2; 71064000 + LOSR ~ J[8]; 71065000 + BOSR ~ 0; 71066000 + PBR ~ J[10].[28:20]; 71067000 + LL ~ 3; 71068000 + SZ ~ J[10].[8:20]; 71069000 + I ~ -1; WHILE I ~1 +1 { SZ DO 71070000 + BEGIN 71071000 + K ~-2; WHILE K <30 DO 71072000 + MV(J[K ~ K + 2],M[I]); 71073000 + READ(DK,30,J[*]); 71074000 + END; 71075000 + END COBOLSIM; 71076000 +INTEGER PROCEDURE PROTECT (IOAREA, IOCW, RESULT); 71077000 + VALUE IOAREA, IOCW; 71078000 + REAL IOAREA, IOCW, RESULT; 71079000 + BEGIN COMMENT CHECK AN INPUT AREA FOR THE PRESENCE 0F PROTECTED 71080000 + WORDS AND RETURN THE MAXIMUM NUMBER OF WORDS THAT CAN BE 71081000 + WRITTEN T0 MEMORY. PLACE THE ENDING ADDRESS IN THE RESULT71082000 + DESCRIPTOR.; 71083000 + INTEGER WORDS; 71084000 + REAL R, S; 71085000 + LABEL FINISH; 71086000 + IF BOOLEAN (IOCW.IOPBIT) AND BOOLEAN (IOCW.IOWBIT) 71087000 + THEN BEGIN 71088000 + S ~ IOAREA.ADDR +IOAREA.LENGTH; 71089000 + FOR R ~ IOAREA.ADDR + 1.5 STEP 1 UNTIL S DO 71090000 + IF BOOLEAN (M [R].TAG) 71091000 + THEN BEGIN 71092000 + WORDS ~ R - 1.5 -IOAREA.ADDR; 71093000 + RESULT.RSLTPRO ~ 1; 71094000 + GO FINISH; 71095000 + END; 71096000 + END 71097000 + ELSE WORDS ~ IOAREA.LENGTH - 1; 71098000 +FINISH: 71099000 + RESULT.RSLTADRS ~ IOAREA.ADDR + WORDS + 1; 71100000 + PROTECT ~ WORDS; 71101000 + END PROTECT AND ENDING ADDRESS PROCESSING; 71102000 +REAL PROCEDURE GETRESULT (MPXAB); 71103000 + VALUE MPXAB; 71104000 + REAL MPXAB; 71105000 + BEGIN COMMENT GET THE NEXT RESULT DESCRIPTOR FOR MPXAB AND UPDATE 71106000 + FIRSTEVENT, FIRSTEVENTI, CURRENT TIME AND MPX. THE 71107000 + RESULT DESCRIPTOR THAT IS GOTTEN, IS FORGOTTEN.; 71108000 + REAL R; 71109000 + REAL E, L; 71109100 + INTEGER I, J, F; 71110000 + R ~ MPX [I ~ MPXAB + DELTAMPX, J ~ FIRSTEVENTI [MPXAB]]; 71111000 + IF R.RSLTERR ! 0 THEN R.RSLTEXC ~ 1; 71112000 + F ~ FIRSTEVENTI [MPXAB] ~ EVENTS [J].EVLINK; 71113000 + L ~ J; 71113100 + DO L ~ (E ~ EVENTS[L]).EVLINK UNTIL E =0 OR E.EVMPX =MPXAB; 71113200 + IF E !0 AND MPX[MPXAB, L].MPXINT =0 71113300 + THEN MPX[MPXAB, L].MPXINT ~ MPX[MPXAB, J].MPXINT; 71113400 + MPX [I, J] ~ EVENTS [J] ~ 0; 71114000 + FIRSTEVENT [MPXAB] ~ EVENTS [F].EVTIME; 71115000 + CURRENTT ~ FIRSTEVENT [CURRENTMPX ~ IF J ~ FIRSTEVENT [2] = 0 71116000 + OR (I ~ FIRSTEVENT [1] { J AND I ! 0) THEN 1 ELSE 2];71117000 + IF CURRENTT ! 0 AND(CURRENTT < IDLETIME OR IDLETIME = 0) 71118000 + THEN IDLETIME ~ CURRENTT ELSE IDLETIME ~ INTTIMER; 71119000 + MPXOPS [MPXAB] ~ MPXOPS [MPXAB] + 1; 71120000 + IF CURRENTT = 0 THEN LASTEVENT [MPXAB] ~ 0; 71121000 + GETRESULT ~ R; 71122000 + END GETTING RESULT DESCRIPTOR; 71123000 +PROCEDURE PUTRESULT (LUNIT, MPXAB, IOTIME, RESULT); 71124000 + VALUE LUNIT, MPXAB, IOTIME; 71125000 + REAL RESULT; 71126000 + INTEGER LUNIT, MPXAB, IOTIME; 71127000 + BEGIN COMMENT DO THE LINKED LIST UPDATING BASED ON IOTIME (THE TIME71128000 + INCREMENT FOR AN I/O) AND UPDATE CURRENTT AND 71129000 + CURRENTMPX AS REQUIRED. PUT THE RESULT DESCRIPTOR IN71130000 + MPX BASED ON LUNIT AND MPXAB.; 71131000 + INTEGER T, I, J, K; 71132000 + DEFINE EVERYTHING =MPXAB [1:46:2] 71133000 + &1 [6:47:1] % BUSY 71134000 + &I [7:43:5] % EVENT LINK 71135000 + #; 71136000 + IF T~IOTIME}LASTEVENT [MPXAB] % COMMON CASE 71137000 + THEN BEGIN 71138000 + EVENTS [LASTEVENTI[MPXAB]].EVLINK ~ LUNIT; 71139000 + LASTEVENT [MPXAB] ~ T; 71140000 + LASTEVENTI[MPXAB] ~ LUNIT; 71141000 + IF FIRSTEVENT [MPXAB] = 0 71142000 + THEN BEGIN 71143000 + FIRSTEVENT [MPXAB] ~ T; 71144000 + FIRSTEVENTI[MPXAB] ~ LUNIT; 71145000 + END; 71146000 + END 71147000 + ELSE BEGIN 71148000 + I ~ K ~ FIRSTEVENTI [MPXAB]; 71149000 + WHILE EVENTS [I].EVTIME { T 71150000 + DO I ~ EVENTS [J ~ I].EVLINK; 71151000 + IF I = K % T IS EARLIER THAN EARLIEST 71152000 + THEN BEGIN 71153000 + FIRSTEVENTI [MPXAB] ~ LUNIT; 71154000 + FIRSTEVENT [MPXAB] ~ T; 71155000 + J ~ I; 71156000 + END; 71157000 + EVENTS [J].EVLINK ~ LUNIT 71158000 + END; 71159000 + EVENTS [LUNIT] ~ T & EVERYTHING; 71160000 + RESULT.RSLTUNIT ~ LUNIT; 71161000 + MPX [MPXAB + DELTAMPX, LUNIT] ~ RESULT; 71162000 +MPX[MPXAB, LUNIT].MPXINT ~ MPXAB ~ 240; % INTERRUPT LITERAL 71163000 + IF T < CURRENTT OR CURRENTT = 0 71164000 + THEN BEGIN CURRENTT ~ T; CURRENTMPX ~ MPXAB END; 71165000 + IF T < IDLETIME OR IDLETIME =0 THEN IDLETIME ~ T; 71166000 + MPXOPS [MPXAB] ~ MPXOPS [MPXAB] - 1; 71167000 + END SORTING TIME AND RESULT DESCRIPTOR FOR AN IO; 71168000 +PROCEDURE FLAGHANDLE (MESS, MINDEX, WORDS, IOCW); 71169000 + VALUE MINDEX, WORDS, IOCW; 71170000 + INTEGER MINDEX, WORDS; 71171000 + ARRAY MESS [0]; 71172000 + REAL IOCW; 71173000 + BEGIN COMMENT MOVE INPUT FROM WORK AREA (MESS) TO M ARRAY START-71174000 + ING AT MINDEX + 1 AND MOVE THE FLAG BIT TO THE EXTENSION 71175000 + WORD.; 71176000 + INTEGER I, J, K, MI, R, W; 71177000 + INTEGER JDIV, JMOD, TAG, BCD; 71178000 + DEFINE FLAGGER = 71179000 + DI ~ B; DI ~ DI + 15; SKIP 2 DB; 71180000 + SI ~ LOC TAG; SKIP 45 SB; 71181000 + 3 BITS; SI ~ A; 71182000 + IF SB THEN DS ~ 1 SET ELSE DS ~ 1 RESET; 71183000 + DI ~ A; DS ~ 1 RESET; SI ~ A; DI ~ B; 71184000 + DS ~ WDS; A ~ SI; DI ~ DI + 8; B ~ DI; #; 71185000 + STREAM PROCEDURE FLAGIN (S, D, JDIV, JMOD, TAG); 71186000 + VALUE JDIV, JMOD, TAG; 71187000 + BEGIN 71188000 + LOCAL A, B; 71189000 + SI ~ S; A ~ SI; DI ~ D; B ~ DI; 71190000 + JMOD (FLAGGER); 71191000 + JDIV (32(FLAGGER)); 71192000 + END; 71193000 + DEFINE TAGGERIN = 71194000 + SKIP BCD SB; 71195000 + DI ~ B; DI ~ DI + 15; SKIP 2 DB;#; 71196000 + DI ~ B; DI ~ DI + 15; SKIP 2 DB; 71196000 + BEGIN 71201000 + LOCAL B; 71202000 + SI ~ MESS; DI ~ M; B ~ DI; 71203000 + JMOD (TAGGERIN); 71204000 + JDIV (32(TAGGERIN)); 71205000 + END; 71206000 + DEFINE FLAGGEROUT = 71207000 + SI ~ A; SI ~ SI + 15; SKIP 5 SB; 71208000 + DI ~ A; IF SB THEN DS ~ 1 SET ELSE DS ~ 1 RESET; 71209000 + DI ~ B; SI ~ A; DS ~ WDS; B ~ DI; 71210000 + DI ~ A; DS ~ 1 RESET; 71211000 + SI ~ A; SI ~ SI + 16; A ~ SI;#; 71212000 + STREAM PROCEDURE FLAGOUT (S, D, JDIV, JMOD); 71213000 + VALUE JDIV, JMOD; 71214000 + BEGIN 71215000 + LOCAL A, B; 71216000 + SI ~ S; A ~ SI; DI ~ D; B ~ DI; 71217000 + JMOD (FLAGGEROUT); 71218000 + JDIV (32(FLAGGEROUT)); 71219000 + END; 71220000 + DEFINE TAGGER = 71221000 + SI ~ A; SI ~ SI + 15; SKIP 2 SB; 71222000 + DI ~ B; DS ~ 3 LIT "0"; DI ~ B; SKIP BCD DB;4 BITS;71223000 + SI ~ A; SKIP SB; 47 BITS; SI ~ SI + 8; 71224000 + A ~ SI; B ~ DI;#; 71225000 + STREAM PROCEDURE TAGOUT (M, MESS, JDIV, JMOD, BCD); 71226000 + VALUE JDIV, JMOD, BCD; 71227000 + BEGIN 71228000 + LOCAL A, B; 71229000 + SI ~ M; A ~ SI; DI ~ MESS; B ~ DI; 71230000 + JMOD (TAGGER); 71231000 + JDIV (32(TAGGER)); 71232000 + END; 71233000 + MI ~ MINDEX + 1; 71234000 + W ~ WORDS; 71235000 + TAG ~ IF I ~ IOCW.IOTAGS = 0 THEN SINGL ELSE 71236000 + IF I = 1 THEN CODE ELSE IF I = 3 THEN DOUBL ELSE 4; 71237000 + BCD ~ IF IOCW.IOSBIT = 1 THEN 13 ELSE 9; 71238000 + DO BEGIN 71239000 + I ~ MI MOD ROWLENGTH; 71240000 + J ~ IF (R ~ ROWLENGTH- I) > W THEN W ELSE R; 71241000 + JDIV ~ J DIV 32; 71242000 + JMOD ~ J MOD 32; 71243000 + IF IOCW.IOWBIT = 1 71244000 + THEN BEGIN 71245000 + IF TAG < 4 71246000 + THEN FLAGIN (MESS[K],M[MI],JDIV,JMOD,TAG) 71247000 + ELSE TAGIN (MESS[K],M[MI],JDIV,JMOD,BCD); 71248000 + END 71249000 + ELSE BEGIN 71250000 + IF TAG < 4 71251000 + THEN FLAGOUT (M[MI], MESS[K], JDIV, JMOD) 71252000 + ELSE TAGOUT (M[MI],MESS[K],JDIV,JMOD, BCD);71253000 + END; 71254000 + K ~ K + J; 71255000 + MI ~ MI + J; 71256000 + END UNTIL W ~ W - J { 0; 71257000 + END INPUT FLAG BIT MANIPULATI0NS; 71258000 +INTEGER PROCEDURE MPXTIME(ELTIME,METIME,LUNIT); 71259000 +VALUE ELTIME,METIME,LUNIT; 71260000 +INTEGER ELTIME,METIME,LUNIT; 71261000 +BEGIN 71262000 + IF(EVENTS[LUNIT].EVTIME)REALTIME 71264000 + THEN MPXTIME~UNITAVAILTIME[LUNIT]+ELTIME 71265000 + ELSE MPXTIME~REALTIME+ELTIME; 71266000 + IF (EVENTS[LUNIT].EVTIME)=0 71267000 + THEN UNITAVAILTIME[LUNIT]~REALTIME+METIME 71268000 + ELSE UNITAVAILTIME[LUNIT]~EVENTS[LUNIT].EVTIME+METIME; 71269000 +END EVALUATION OF MPXTIME FOR AN IO; 71270000 +PROCEDURE CARDLOAD; 71271000 + BEGIN 71272000 + FILE EDOC DISK SERIAL (2,3,30); 71273000 + DEFINE CODE = EDOC#; 71273100 + FORMAT ERROR ("EQUATED FILE IS NOT ON DISK. ", 32("X"),//); 71274000 + LABEL EOF; 71275000 + SEARCH (CODE, TBUF[*]); 71276000 + IF TBUF[0] > 0 THEN 71277000 + BEGIN 71278000 + READ (CODE, *, PBR, S, D[0]); 71279000 + DO BEGIN 71280000 + READ (CODE, *, MM, A, AX) [EOF]; 71281000 + MOVE (A, M[MM]); 71282000 + END 71283000 + UNTIL FALSE; 71284000 +EOF: 71285000 + END 71286000 + ELSE 71287000 + BEGIN 71288000 + WRITE (LP, ERROR); GO EOF END 71289000 + END; 71290000 +PROCEDURE MULTIPLEXOR; 72000000 + BEGIN COMMENT MULTIPLEXOR IS CALLED WHEN THE PROCESSOR HAS INITIATED72001000 + AN I/O. A SWITCH BASED ON HARDWARE UNIT TYPE IS INVOKED 72002000 + AND THE SIMULATED I/O IS PERFORMED. TIMING CALCULATIONS 72003000 + ARE COMPLETED AND EXCEPTION CONDITIONS ARE NOTED AND THE 72004000 + RESULT DESCRIPTOR IS LINKED INTO THE EVENTS AND MPX ARRAYS72005000 + BASED ON MPX AND TIME. THE A & B REGISTERS ARE ASSUMED T072006000 + BE FULL.; 72007000 + REAL MPXINFO, RESULT, WORDS, EVENTIME; 72008000 +INTEGER LDIV,LMOD,DESC,SKIP,SWFI, ELTIME,METIME; 72009000 +BOOLEAN SPACLP; 72010000 +REAL FUNCD, FUNCDX, IOAD , IOAREAX, IOCW, IOCWX; 72011000 +LABEL AROUND, PUT, CEOF, OC; 72012000 +DEFINE EBCDIC = 6(DI ~ LOC J; SKIP 43 DB; 5 BITS ; 72013000 + DI ~ LOC K; SKIP 45 DB; 3 BITS ; 72014000 + A ~ SI; 72015000 + SI ~ TABLE; 72016000 + J (SI ~ SI + 8); SI ~ SI + K; 72017000 + DI ~ B; DS ~ CHR; B ~ DI; 72018000 + SI ~ A;)#, 72019000 + WORDIV = WORDS.[38:5], WORDS.[43:5]#; 72020000 +STREAM PROCEDURE EBCOUT (MESS, TABLE, WMOD, WDIV); 72021000 + VALUE WMOD, WDIV; 72022000 + BEGIN 72023000 + LOCAL A, B, J, K; 72024000 + SI ~ MESS; A ~ SI; 72025000 + WMOD (EBCDIC); 72026000 + WDIV (32(EBCDIC)); 72027000 + END CONVERSION OF EBCDIC INTERNAL TO BCL GRAPHIC; 72028000 +DEFINE ERROR201 = 72029000 + IF IOAD.LENGTH - 1 > MPXINFO.MPXBUFF 72030000 + THEN BEGIN ERROR (201); GO EOJ END;#, 72031000 + BADUNIT = 72032000 + BEGIN ERROR (200); MEMDUMP; GO EOJ END#; 72033000 + STREAM PROCEDURE BLANK (M, LMOD, LDIV); VALUE LMOD, LDIV; 72034000 + BEGIN DI ~ M; DS ~ 8 LIT " "; SI ~ M; DS~LMOD WDS; 72035000 + LDIV (DS ~ 32 WDS) END; 72036000 +REAL STREAM PROCEDURE NFLAG(WORD); 72037000 +BEGIN SI ~ WORD; DI~ LOC NFLAG; DS ~ 1 WDS; 72038000 + DI ~ DI - 8; DS ~ 1 RESET; 72039000 +END; 72040000 + DEFINE 72041000 + T=PERIPHERALT#, 72042000 + TSKIP=5|MPXINFO.MPXHDWE#; 72043000 + LABEL EOF,PAR; 72044000 + DEFINE READS = IF BOOLEAN(IOCW.IOBBIT) THEN 72045000 + BEGIN 72046000 + READ REVERSE(TAPES[SWFI], 72047000 + MPXINFO.MPXBUFF,MESS[*]) 72048000 + [EOF:PAR]; 72049000 +IF NFLAG(MESS)=TMK THEN GO EOF; 72050000 + MPX[0,FUNCD.LUNIT] ~ 72051000 + MPX[0,FUNCD.LUNIT] - 1; 72052000 + END ELSE 72053000 + BEGIN 72054000 + READ(TAPES[SWFI],MPXINFO. 72055000 + MPXBUFF,MESS[*])[EOF:PAR]; 72056000 +IF NFLAG(MESS)=TMK THEN GO EOF; 72057000 + BUMPIT; 72058000 + END#, 72059000 + TRANSLATE = IF BOOLEAN(IOCW.IOXBIT) THEN 72060000 + BEGIN 72061000 + FLAGHANDLE(MESS,IOAD.ADDR, 72062000 + WORDS,IOCW); 72063000 + IF BOOLEAN(IOCW.IOSBIT)THEN 72064000 + BEGIN 72065000 + EBCOUT(MESS, 72066000 + EBCTOBCL,WORDIV); 72067000 + WORDS ~ ENTIER 72068000 + (WORDS/.75); 72069000 + END; 72070000 + END #, 72071000 + TIMEIT = ELTIME ~ ELTIME + T[TSKIP]; 72072000 + METIME ~ METIME + T[TSKIP + 1] #, 72073000 + BUMPIT = MPX[0,FUNCD.LUNIT] ~ 72074000 + MPX[0,FUNCD.LUNIT] + 1 #, 72075000 + TMK = "}}}}}}}"&"}"[1:43:5] # , 72076000 + TM = [13:1] #; 72077000 + ALPHA STREAM PROCEDURE EXAMIN (NCR); VALUE NCR; 72078000 + BEGIN SI~NCR; DI~LOC EXAMIN; DI~DI+7; DS~CHR; END EXAMIN; 72079000 +INTEGER STREAM PROCEDURE OUTPCVT(ADDR); VALUE ADDR; 72080000 + BEGIN 72081000 + SI ~ LOC ADDR; DI ~ LOC OUTPCVT; DS ~ 8 OCT; 72082000 + END; 72083000 +REAL SAVIOAD, RECNT; 72084000 + LABEL PRINTERS; 72084100 + MOVE (SCANBUSA, FUNCD); 72085000 + MOVE (DATABUSA, IOAD); 72086000 + MOVE (M[IOAD .ADDR ], IOCW); 72087000 + MEMCYCLE; 72087100 + RESULT.RSLTATT ~ IOCW.IOABIT; 72088000 + MPXINFO ~ MPX [FUNCD.MPXFC, FUNCD.LUNIT]; 72089000 + MULTIPLEX ~ FALSE; 72090000 + IF BOOLEAN (IOCW.IOTBIT) % TEST 72091000 + THEN BEGIN 72092000 + A ~ MPX [FUNCD.MPXFC + DELTAMPX, FUNCD.LUNIT]; 72093000 + A.RSLTBSY ~ EVENTS [FUNCD.LUNIT].EVBUSY; 72094000 + AX ~ 0; 72095000 + AROF ~ TRUE; 72096000 + GO OC; 72097000 + END; 72098000 + CASE MPXINFO.MPXHDWE OF 72099000 + BEGIN % INTERNAL NAME CASE72100000 + BADUNIT;% NONE 0 72101000 + BEGIN% DISK 1 72102000 + IF(JUNK~OUTPCVT(IOCW.[20:28])) < 9999 AND JUNK } 0 THEN 72103000 + BEGIN 72104000 + SAVIOAD ~ IOAD; 72105000 + IOAD.LENGTH ~ 60; 72106000 + RECNT ~ 0 ; 72107000 + ERROR201; 72108000 + IF BOOLEAN (IOCW.IOWBIT) 72109000 + THEN DO BEGIN 72110000 + READ (DISKA[JUNK], 60, MESS[*]); 72111000 + WORDS ~ PROTECT (IOAD, IOCW, RESULT); 72112000 + FLAGHANDLE (MESS, IOAD.ADDR, WORDS, 72113000 + IOCW); 72114000 + RECNT ~ RECNT + 1; 72115000 + JUNK ~ JUNK + WORDS; 72116000 + TIMEIT; 72117000 + END UNTIL SAVIOAD.LENGTH { RECNT 72118000 + OR RESULT.[31:17] ! 0 72119000 + ELSE DO BEGIN 72120000 + FLAGHANDLE (MESS, IOAD.ADDR, 60, 72121000 + IOCW); 72122000 + WRITE (DISKA[JUNK], 60, MESS[*]); 72123000 + RECNT ~ RECNT + 1; 72124000 + JUNK ~ JUNK + WORDS; 72125000 + TIMEIT; 72126000 + END UNTIL SAVIOAD.LENGTH { RECNT 72127000 + OR RESULT.[31:17] ! 0 72128000 + END ELSE 72129000 + BEGIN 72130000 + RESULT.RSLTNRY ~ 1; 72131000 + TIMEIT; 72132000 + END; 72133000 + EVENTIME ~ MPXTIME (ELTIME, METIME, FUNCD.LUNIT); 72134000 + END; 72135000 + BEGIN% SPO 2 72136000 + IF TUBA.[9:9]= 0 THEN RESULT.RSLTNRY ~ 1 ELSE 72137000 + BEGIN 72138000 + ERROR201; 72139000 + WORDS ~ PROTECT(IOAD,IOCW,RESULT); 72140000 + IF BOOLEAN(IOCW.IOWBIT) THEN 72141000 + BEGIN % READ 72142000 + IF SPOED THEN 72143000 + BEGIN 72144000 + FLAGHANDLE(CUP,IOAD. 72145000 + ADDR,WORDS,IOCW); 72146000 + SPOED ~ FALSE; 72147000 + END ELSE 72148000 + BEGIN 72149000 + READ(SPO(TUBA) 72150000 + ,10,MESS[*]); 72151000 + FLAGHANDLE(MESS,IOAD. 72152000 + ADDR,WORDS,IOCW); 72153000 + END 72154000 + END ELSE 72155000 + BEGIN % WRITE 72156000 + FLAGHANDLE(MESS,IOAD.ADDR, 72157000 + WORDS,IOCW); 72158000 + EBCOUT(MESS,EBCTOBCL,WORDIV); 72159000 + WORDS ~ ENTIER(WORDS / .75); 72160000 + WRITE(SPO(TUBA), 72161000 + 10,MESS[*]); 72162000 + END; 72163000 + ELTIME ~ T[TSKIP]; 72164000 + METIME ~ T[TSKIP + 1]; 72165000 + END; 72166000 + END; 72167000 + BEGIN% BIDS 3 72168000 + END; 72169000 + BADUNIT;% 4 72170000 + BADUNIT;% 5 72171000 + BEGIN% LP OR PRINT 6 72172000 + PRINTERS: 72172100 + ERROR201; 72173000 + WORDS ~ PROTECT (IOAD , IOCW, RESULT); 72174000 + IF BOOLEAN (IOCW.IOXBIT) % TRANSLATE 72175000 + THEN BEGIN 72176000 + FLAGHANDLE (MESS, IOAD.ADDR, WORDS, 72177000 + IOCW); 72178000 + IF BOOLEAN (IOCW.IOSBIT) % 8 BIT 72179000 + THEN BEGIN 72180000 + EBCOUT (MESS, EBCTOBCL, WORDIV); 72181000 + WORDS ~ ENTIER (WORDS/.75); 72182000 + END; 72183000 + END 72184000 + ELSE IF NOT BOOLEAN (IOCW.IOIBIT) %MEMORY INHIBIT 72185000 + THEN BEGIN 72186000 + RESULT.RSLTDSC ~ DESC ~ 1; 72187000 + ELTIME~200; METIME~0; GO AROUND; 72188000 + END 72189000 + ELSE BEGIN 72190000 + LDIV ~ (LMOD ~ WORDS ) DIV 32; 72191000 + LMOD ~ LMOD MOD 32 - 1; 72192000 + BLANK (MESS, LMOD, LDIV); 72193000 + END; 72194000 + SWFI ~ MPXINFO.MPXSWFI; 72195000 + IF SKIP ~ IOCW.IOSKIP = 0 72196000 + THEN BEGIN 72197000 + WRITE (LINES[SWFI][NO], WORDS 72198000 + , MESS [*]); 72199000 + SKIP ~ IOCW.IOSPAC; SPACLP ~ TRUE; 72200000 + METIME~METIME+(T[TSKIP+2]+T[TSKIP+3]| 72201000 + (SKIP-1)); 72202000 + WHILE SKIP > 0 72203000 + DO BEGIN 72204000 + WRITE (LINES [SWFI]); 72205000 + SKIP ~ SKIP - 1; 72206000 + END; 72207000 + END 72208000 + ELSE BEGIN 72209000 + WRITE (LINES[SWFI][SKIP], WORDS, 72210000 + MESS [*]); 72211000 + METIME~METIME+T[TSKIP+4]; 72212000 + END; 72213000 + ELTIME~T[TSKIP]; 72214000 + METIME~METIME+T[TSKIP+1]; 72215000 +AROUND: EVENTIME~MPXTIME(ELTIME,METIME,FUNCD.LUNIT); 72216000 + END; 72217000 + BEGIN% LP 7 72218000 + GO PRINTERS; 72218100 + END; 72219000 + BADUNIT;% 8 72220000 + BEGIN% CR 9 72221000 + ERROR201; 72222000 + IF IOCW.IOWBIT = 1 AND (IOCW.IOXBIT = 1 OR 72223000 + IOCW.IOSBIT = 1) 72224000 + THEN BEGIN 72225000 + READ (CARD, MPXINFO.MPXBUFF,MESS[*])[CEOF];72226000 + RESULT.RSLTVY ~ REAL (EXAMIN(NCR)= "~"); 72227000 + RESULT.RSLTCC ~ RESULT.RSLTVY; 72228000 + WORDS ~ PROTECT (IOAD , IOCW, RESULT); 72229000 + FLAGHANDLE (MESS, IOAD.ADDR, WORDS, IOCW); 72230000 + ELTIME~T[TSKIP]; 72231000 + METIME~T[TSKIP+1]; 72232000 + GO PUT; 72233000 + END 72234000 + ELSE BEGIN 72235000 + RESULT.RSLTDSC ~ 1; 72236000 + ELTIME~200; METIME~0; 72237000 + GO PUT; 72238000 + END; 72239000 + CEOF:RESULT.RSLTNRY ~ 1; 72240000 + ELTIME~200; METIME~0; 72241000 +PUT: EVENTIME~MPXTIME(ELTIME,METIME,FUNCD.LUNIT); 72242000 + END; 72243000 + BEGIN% CP 1072244000 + END; 72245000 + BADUNIT;% 1172246000 + BADUNIT;% 1272247000 + BEGIN% MT 1372248000 + ELTIME ~ METIME ~ 0; 72249000 + SWFI ~ MPXINFO.MPXSWFI; 72250000 + CASE 0&IOCW[46:3:2] OF 72251000 + BEGIN 72252000 + % % % % WRITES % % % % 72253000 + IF BOOLEAN(IOCW.TM) THEN 72254000 + BEGIN 72255000 + WRITE(TAPES[SWFI],*,TMK); 72256000 + TIMEIT; 72257000 + BUMPIT; 72258000 + END ELSE 72259000 + BEGIN 72260000 + ERROR201; 72261000 + WORDS ~ PROTECT(IOAD,IOCW,RESULT)72262000 + ;TRANSLATE; 72263000 + WRITE(TAPES[SWFI],WORDS,MESS[*]);72264000 + TIMEIT; 72265000 + BUMPIT; 72266000 + END; 72267000 + % % REWIND OR ERASE % % 72268000 + IF BOOLEAN(IOCW.IOBBIT) THEN 72269000 + BEGIN 72270000 + INTG ~ MPX[0,FUNCD.LUNIT]; 72271000 + ELTIME ~ T[TSKIP]; 72272000 + FOR JUNK~1 STEP 1 UNTIL INTG DO 72273000 + BEGIN 72274000 + READ REVERSE(TAPES 72275000 + [SWFI],1,MESS[*]) 72276000 + [EOF:PAR]; 72277000 +IF NFLAG(MESS)=TMK THEN GO EOF; 72278000 + GO TO EOF; 72279000 + MPX[0,FUNCD.LUNIT] ~ 72280000 + MPX[0,FUNCD.LUNIT] -1; 72281000 + METIME ~ METIME + 72282000 + T[TSKIP + 1]; 72283000 + END; 72284000 + RESULT.RSLTRW ~ 1; 72285000 + END ELSE 72286000 + BEGIN TIMEIT END; 72287000 + % % % % READS % % % % 72288000 + BEGIN 72289000 + ERROR201; 72290000 + READS; 72291000 + IF FALSE THEN 72292000 + PAR: 72293000 + BEGIN 72294000 + RESULT.RSLTMA ~ 1; 72295000 + RESULT.RSLTCC ~ 1; 72296000 + RESULT.RSLTOF ~ 1; 72297000 + END; 72298000 + WORDS ~ PROTECT(IOAD,IOCW,RESULT); 72299000 + FLAGHANDLE(MESS,IOAD.ADDR,WORDS,IOCW);72300000 + TIMEIT; 72301000 + END; 72302000 + % % % % SPACE % % % % 72303000 + BEGIN 72304000 + IF (INTG~IOCW.RECS) =0 THEN INTG~100; 72305000 + FOR JUNK~1 STEP 1 UNTIL INTG DO 72306000 + BEGIN 72307000 + READS; 72308000 + TIMEIT; 72309000 + END; 72310000 + END; 72311000 + END; 72312000 + IF FALSE THEN 72313000 +EOF: BEGIN 72314000 + RESULT.RSLTVY ~ 1; 72315000 + RESULT.RSLTNRY~ 1; 72316000 + TIMEIT; 72317000 + END; 72318000 + EVENTIME ~ MPXTIME(ELTIME,METIME,FUNCD.LUNIT); 72319000 + END; 72320000 + END; 72321000 + PUTRESULT (FUNCD.LUNIT, FUNCD.MPXFC, EVENTIME , RESULT); 72322000 +OC: 72323000 + END MULTIPLEXOR; 72324000 +PROCEDURE NEXTEVENT; 72325000 + BEGIN COMMENT NEXTEVENT WORRIES ABOUT INTERRUPT PRIORITIES AND SETS72326000 + APPROPRIATE INTERRUPTS. PRIORITY (HIGH TO LOW) IS 72327000 + ALARM, SYLLABLE-DEPENDENT, CONTROL AND EXTERNAL. 72328000 + SOME FUNCTIONS OF INTERRUPT CONTROL ARE HANDLED. 72329000 + ; 72330000 + IF ABORTTIME { REALTIME 72331000 + THEN BEGIN 72332000 + END 72333000 +ELSE IF IDLETIME { REALTIME AND SDIS + GCIF = 0 72334000 + 72335000 + THEN BEGIN 72336000 + IF INTTIMER { REALTIME 72337000 + THEN BEGIN 72338000 + SETINTERRUPT (INTTIMI); 72338500 +INTTIMER ~ 2*36; 72339000 +IDLETIME ~ CURRENTT; 72339050 + END 72339500 + ELSE IF NOT IIHF 72340000 +AND CURRENTT { REALTIME 72340100 +AND CURRENTT ! 0 72340200 + THEN BEGIN 72341000 + SETINTERRUPT (EXTINTI + CURRENTMPX); 72342000 + CURRENTT ~ 0; 72342500 +IDLETIME ~ INTTIMER; 72342600 + END; 72343000 + END; 72344000 + END OF NEXT EVENT; 72345000 +PROCEDURE SIMULATOR; 73000000 + BEGIN COMMENT THIS IS THE PRINCIPAL DRIVER FOR THE SIMULATOR. ;73001000 + LABEL NDIN; 73002000 + CASE DISKLOAD OF 73003000 + BEGIN 73004000 + INITIALIZE; % ESPOL 73005000 + CARDLOAD; % ALGOL 73006000 + COBOLSIM; % COBOL 73007000 + END; 73008000 + 73009000 + 73010000 + TBUF[16]:=MKABS(TBUF); 73010100 + ABORTTIME ~ INTTIMER ~ 2*36; 73010200 + IF DISKLOAD = 0 THEN INTTIMER ~ 2*36 73010300 + ELSE IDLETIME ~ 2*36; 73010400 + NCR ~ MKABS (MESS); 73010500 + D31 ~ MONITORVALUE & MONITORMASK[28:38:10]; 73010600 + DO BEGIN 73011000 + IF INT ! 0 73012000 + THEN INTERRUPTCONTROLLER 73013000 + ELSE BEGIN 73014000 + CONTROLSECTION; 73015000 + TRACE; 73016000 + END; 73017000 + IF MONITORVALUE! MONITORMASKOLD 73017100 + THEN D31 ~ MONITORMASKOLD ~ MONITORVALUE; 73017200 + IF MULTIPLEX THEN MULTIPLEXOR; 73018000 + NEXTEVENT; 73019000 + IF TUBA.[9:9]=0 THEN ELSE 73020000 + IF SPOED THEN ELSE 73021000 + BEGIN 73022000 + READ(SPO(TUBA,1),10,CUP[*])[NDIN]; 73023000 + SPOED ~ TRUE; 73024000 + NDIN: 73025000 + END; 73026000 + END UNTIL FALSE; 73027000 + END SIMULATOR CONTROL; 73028000 +PROCEDURE TRACE; 74000000 +BEGIN 74001000 + LABEL EXIT; 74002000 + STREAM PROCEDURE PBIS(SYLL,PBR,PIR,PSR,TANK); 74003000 + VALUE SYLL,PBR,PIR,PSR,TANK; 74004000 + BEGIN 74005000 + DI:=TANK; SI:=LOC SYLL;SI:=SI+4; DS:=4 CHR; DS:=4 LIT" "; 74006000 + DS:=12 LIT ""PBR:PIR:PSR"; DS:=3 LIT ""= "; 74007000 + 2(SI:=SI+4; 8(DS:=3 RESET; 3 BITS); DS:= LIT ":"); 74008000 + SI:=SI+7; DS:=CHR; 2(DS:=39 LIT " "); 74009000 + END OF PBIS; 74010000 + REAL STREAM PROCEDURE OCTIZE(TAG1,WD1,TAG2,WD2,DBLE,TANK); 74011000 + VALUE TAG1,WD1,TAG2,WD2,DBLE,TANK; 74012000 + BEGIN 74013000 + DI:=TANK; SI:=LOC TAG1; 74014000 + DBLE(SKIP 44 SB; DS:=3 RESET; 3 BITS; DS:=LIT " "; 74015000 + DS:=3 RESET; 1 BITS; SKIP SB; 2 BITS; 74016000 + 7(DS:=3 RESET; 3 BITS); DS:=LIT " "; 74017000 + 8(DS:=3 RESET; 3 BITS); DS:=2 LIT " "); 74018000 + OCTIZE:= DI; 74019000 + END OF OCTIZE; 74020000 + STREAM PROCEDURE BLANK(TANK); 74021000 + VALUE TANK; 74022000 + BEGIN LOCAL T; 74023000 + DI:=TANK; T:=DI; DS:=8 LIT " "; SI:=T; DS:=14 WDS; 74024000 + END OF BLANK; 74025000 + PROCEDURE TOS; 74026000 + BEGIN 74027000 + FORMAT TOSREG(X8,"AREG",X17,"XREG",X17,"BREG",X17,"YRE6"); 74028000 + BLANK(TANK); 74029000 + WRITE(LP,TOSREG); 74030000 + IF AROF THEN 74031000 + TANK:=OCTIZE(AX,A,XX,X,2,TANK); 74032000 + IF BROF THEN 74033000 + TANK:=OCTIZE(BX,B,YX,Y,2,TANK+65541|(REAL(NOT AROF)).[47:1]); 74034000 + PRINT; 74035000 + END OF TOS; 74036000 + PROCEDURE REGISTER(TAGE,WORDE,FMTE); 74037000 + VALUE TAGE,WORDE,FMTE; 74038000 + REAL TAGE,WORDE,FMTE; 74039000 + BEGIN 74040000 + SWITCH FORMAT REGS:= 74041000 + ("C = "), 74042000 + ("P = "); 74043000 + REAL STREAM PROCEDURE SYLLABLIZE(PX,P,TANK); VALUE PX,P,TANK; 74044000 + BEGIN 74045000 + DI~ TANK; SI~ LOC PX; 74046000 + SKIP 44 SB; DS~ 3 RESET; 3 BITS; DS~ LIT " "; 74047000 + DS~ 4 RESET; 1 BITS; SKIP SB; 1 BITS; 74048000 + 2(DS~ 3 RESET; 3 BITS); DS~ LIT " "; 74049000 + 5(DS~4 RESET; 2 BITS; 2(DS~3RESET; 3 BITS);DS~LIT" "); 74050000 + END; 74051000 + TANK:=TBUF[16]; 74052000 + WRITE(LP[NO],REGS[FMTE]); 74053000 + BLANK(TANK); 74054000 + IF FMTE=0 THEN TANK~OCTIZE(TAGE,WORDE,0,0,1,TANK+1) ELSE 74055000 + IF FMTE=1 AND PROF THEN TANK~SYLLABLIZE(TAGE,WORDE,TANK+1); 74056000 + PRINT; 74057000 + END OF REGISTER; 74058000 + STREAM PROCEDURE OCTAL(TANK,DPLAY,WRDS); 74059000 + VALUE TANK,WRDS; 74060000 + BEGIN 74061000 + DI~TANK; SI~DPLAY; 74062000 + WRDS(SI:=SI+5; 6(DS:= 3 RESET; 3 BITS); DS:=2 LIT " "; ); 74063000 + END OF OCTAL; 74064000 + PROCEDURE DISPLAY; 74065000 + BEGIN 74066000 + FORMAT DREGS("DISPLAY REGISTERS 0 THROUGH ",I2," LL= ",I2); 74067000 + DEFINE N=NDISPLAY#; 74068000 + INTEGER I,LINES,NMOD15; 74069000 + INTEGER DPLAID; 74070000 + TANK:=TBUF[16]; 74071000 + IF N=0 THEN N:=DPLAID:=31; 74072000 + WRITE(LP,DREGS,N-1,LL); 74073000 + LINES:= N DIV 15; 74074000 + FOR I:=1 STEP 1 UNTIL LINES DO 74075000 + BEGIN 74076000 + BLANK(TANK); 74077000 + OCTAL(TANK,D[(I-1)|15],15); 74078000 + PRINT; 74079000 + END; 74080000 + IF (NMOD15:=N MOD 15)!0 THEN 74081000 + BEGIN 74082000 + BLANK(TANK); 74083000 + OCTAL(TANK,D[LINES|15], NMOD15 ); 74084000 + PRINT; 74085000 + END; 74086000 + IF DPLAID!0 THEN N:=0; 74087000 + END OF DISPLAY; 74088000 + OWN BOOLEAN ASTERICKS; 74089000 + PROCEDURE STACK; 74090000 + BEGIN 74091000 + BOOLEAN STREAM PROCEDURE NOTZERO(ADDR); VALUE ADDR; 74092000 + BEGIN LOCAL L1,L2,L3; 74093000 + DI:=LOC L3; DS:=21 LIT"0 OOOOOOOO 00000000 "; SI:=ADDR; 74094000 + 4(DI:=LOC L3;SI:=SI+1; DI:=DI+1; 74095000 + IF 20 SC!DC THEN BEGIN TALLY:=1; JUMP OUT END); 74095100 + NOTZERO:=TALLY; 74096000 + END OF NOTZERO; 74097000 + STREAM PROCEDURE STARS(ADDR); VALUE ADDR; 74098000 + BEGIN LOCAL T; 74099000 + DI:=ADDR; DS:=21 LIT "* ******** ******** "; 74100000 + SI:=ADDR; 3(DS:=21 CHR); 74101000 + END OF STARS; 74102000 + FORMAT STACKS("STACK CONTENTS WORD F TO F+",I6,X4,"S= ",O, 74103000 + " F= ",O," BOSR= ",O," LOSR= ",O); 74104000 + DEFINE N=NSTACK#; 74105000 + REAL T,T1; INTEGER I,LINES,J; 74106000 + INTEGER ISTACK; 74107000 + STREAM PROCEDURE OCTL(A,B,C,D,E); VALUE A,B,C,D,E; 74108000 + BEGIN DI~A; SI~LOC B; 4(SI~SI+4; 8(DS~3RESET; 3 BITS))END; 74109000 + TANK:=TBUF[16]; 74110000 + IF N=0 THEN N:=ISTACK:= S-F+1; 74111000 + OCTL(TANK,S,F,BOSR,LOSR); 74112000 + WRITE(LP,STACKS,N-1,TBUF[0],TBUF[1],TBUF[2],TBUF[3]); 74113000 + LINES:=N DIV 4; 74114000 + FOR I:=1 STEP 1 UNTIL LINES DO 74115000 + BEGIN 74116000 + TANK:= TBUF[16]; 74117000 + BLANK(TANK); 74118000 + FOR J:=0 STEP 1 UNTIL 3 DO 74119000 + BEGIN 74120000 + MOVE(M[(F+J)+(I-1)|4],T); 74121000 + TANK:=OCTIZE(T1,T,0,0,1,TANK); 74122000 + END; 74123000 + IF NOTZERO(TBUF[16]) THEN 74124000 + BEGIN ASTERICKS:=FALSE; PRINT END ELSE 74125000 + IF NOT ASTERICKS THEN 74126000 + BEGIN STARS(TBUF[16]); PRINT; 74127000 + ASTERICKS:=TRUE; WRITE(LP); 74128000 + END; 74129000 + END; 74130000 + IF (I:=N MOD 4)!0 THEN 74131000 + BEGIN 74132000 + TANK:= TBUF[16]; 74133000 + BLANK(TANK); 74134000 + FOR J:=1 STEP 1 UNTIL I DO 74135000 + BEGIN 74136000 + MOVE(M[(F+(J-1))+ LINES|4],T); 74137000 + TANK:=OCTIZE(T1,T,0,0,1,TANK); 74138000 + END; 74139000 + PRINT; 74140000 + END; 74141000 + IF ISTACK!0 THEN N:=0; 74142000 + END OF STACK; 74143000 + LABEL NONE; 74144000 + FORMAT TOGS ( X43,"VARF = ",I1," , LEEF = ",I1," , TEEF = ",I1, 74145000 + " , SEEE = ",I1," , NCSE = ",I1," UPDF s ",I1 74146000 + ); 74147000 +INTEGER REALTI; 74148000 +MONITOR LP (REALTI); 74149000 +NONE: 74150000 + ASTERICKS:=FALSE; 74151000 + TANK:=TBUF[16]; 74152000 + IF TRACEWORD = 0 OR ( TRACEWORD > 100 AND TRACTER=0) THEN 74153000 + GO TO EXIT; 74154000 + HEADING; 74155000 + IF TS1=0 THEN JUNK:=MNEMONIC[0,T] 74156000 + ELSE IF VARF THEN JUNK:=MNEMONIC[1,T] 74157000 + ELSE JUNK~ MNEMONIC[2,T]; 74158000 + WRITE(LP[NO],TOGS,REAL(VARF),REAL(LEEF),REAL(TEEF),REAL(SEEF), 74159000 + REAL(NCSF),REAL(UPDF)); 74160000 + PBIS(JUNK,PBR,PIR,PSR,TANK); 74161000 + PRINT; 74162000 +REALTI ~ REALTIME; 74163000 + TANK:= TBUF[16]; 74164000 + IF (JUNK~TRACEWORD) } 100 THEN 74165000 + JUNK ~ TRACTER; 74166000 + CASE JUNK OF 74167000 + BEGIN 74168000 + ; 74169000 + TOS; % TRACE OF A,X,B,Y REGISTERS 74170000 + REGISTER(CX,C,0); % TRACE OF C REGISTER 74171000 + REGISTER(PX,P,1); % TRACE OF P REGISTER 74172000 + DISPLAY; % TRACE 0F N DISPLAY REGISTERS 74173000 + STACK; % TRACE 0F N WORDS IN THE STACK 74174000 + BEGIN TOS; REGISTER(CX,C,0) END; % 6 74175000 + BEGIN TOS; REGISTER(PX,P,1) END; % 7 74176000 + BEGIN TOS; DISPLAY END; % 8 74177000 + BEGIN TOS; STACK END; % 9 74178000 + BEGIN TOS; REGISTER(CX,C,0); REGISTER(PX,P,1) END; % 10 74179000 + BEGIN TOS; REGISTER(CX,C,0); DISPLAY END; % 11 74180000 + BEGIN TOS; REGISTER(CX,C,0); STACK END; % 12 74181000 + BEGIN TOS; REGISTER(PX,P,1); DISPLAY END; % 13 74182000 + BEGIN TOS; REGISTER(PX,P,1); STACK END; % 14 74183000 + BEGIN TOS; DISPLAY; STACK END; % 15 74184000 + BEGIN TOS; REGISTER(CX,C,0); REGISTER(PX,P,1); DISPLAY END;%16 74185000 + BEGIN TOS; REGISTER(CX,C,0); REGISTER(PX,P,1); STACK END; % 17 74186000 + BEGIN TOS; REGISTER(CX,C,0); REGISTER(PX,P,1); 74187000 + DISPLAY;STACK; 74188000 + END; % 18 74189000 + MEMDUMP; % 19 74190000 +BEGIN LABEL DUMPER; %%%%%%%%%%%%%%% 74191000 +DUMP LP (MPX, FIRSTEVENT, LASTEVENT, FIRSTEVENTI, LASTEVENTI, 74192000 + CURRENTT,UNITAVAILTIME,EVENTS,CURRENTMPX,MPXOPS, 74193000 + BUFRMAX)DUMPER:1; 74194000 +DUMPER: END; 74195000 + END; 74196000 + WRITE(LP); 74197000 +EXIT: 74198000 +END OF TRACE; 74199000 +PROCEDURE MEMDUMP; 75000000 +BEGIN 75001000 + INTEGER ADDRESS,I,ROW,J,WRDS,TANK; 75002000 + INTEGER SAVETRACEWORD,SAVEN,SAVENN; 75003000 + BOOLEAN ASTERICKS; 75004000 + ARRAY MD[0:9]; 75005000 + ARRAY XMD[0:9]; 75005100 + DEFINE N= NDISPLAY#, NN=NSTACK#; 75006000 + STREAM PROCEDURE OCTIZE(LOCM,ADDR,WRDS,BLK,TANK); 75007000 + VALUE LOCM,WRDS,BLK,TANK; 75008000 + BEGIN 75009000 + DI:=TANK; DS:=4 LIT " "; SI:=LOC LOCM; SI:=SI+4; 75010000 + 8(DS:=3 RESET; 3 BITS); DS:=3 LIT " "; 75011000 + SI:=ADDR; 75012000 + WRDS(SKIP 44 SB; DS:=3 RESET; 3 BITS; DS:=LIT " "; 75013000 + DS:=3 RESET; 1 BITS; SKIP SB; 2 BITS; 75014000 + 7(DS:=3 RESET; 3 BITS); DS:=LIT " "; 75015000 + 8(DS:=3 RESET; 3 BITS); DS:=2 LIT " "); 75016000 + BLK(2(DS:=42 LIT " " )); 75017000 + END OF OCTIZE; 75018000 + BOOLEAN STREAM PROCEDURE NOTSAME(XMD,MD,WRDS); 75019000 + VALUE WRDS; 75020000 + BEGIN LOCAL RPF; 75021000 + SI ~ XMD; DI ~ MD; 75022000 + WRDS(IF 8 SC!DC THEN BEGIN TALLY~1; JUMP OUT END); 75022100 + NOTSAME~ TALLY; RPF ~ TALLY; 75023000 + RPF(SI~MD; DI~XMD; DS~WRDS WDS); 75024000 + END; 75027000 + STREAM PROCEDURE STARS(LOCM,TANK); 75028000 + VALUE LOCM,TANK; 75029000 + BEGIN 75030000 + LOCAL T; 75031000 + DI:=TANK; DS:=4 LIT " "; SI:=LOC LOCM; SI:=SI+4; 75032000 + 8(DS:=3 RESET; 3 BITS); DS:=3 LIT " "; 75033000 + T:=DI; DS:=21 LIT "* ******** ******** "; 75034000 + SI:=T; 4(DS:=21 CHR); 75035000 + END OF STARS; 75036000 + STREAM PROCEDURE MOVIT(HERE,THERE,WORDS); 75037000 + VALUE WORDS; 75038000 + BEGIN 75039000 + SI:=HERE; DI:=THERE; SI:=SI+8; 75040000 + WORDS(DS:=WDS; SI:=SI+8; DI:=DI+8); 75041000 + SI:=HERE; DI:=THERE; DI:=DI+8; 75042000 + WORDS(DS:=WDS; SI:=SI+8; DI:=DI+8;); 75043000 + END OF MOVIT; 75044000 + SAVETRACEWORD:=TRACEWORD; SAVEN:=N; SAVENN:=NN; 75045000 + TRACEWORD:=18; N:=32; NN:=99; 75046000 + TRACE; 75047000 + ADDRESS:=0; ASTERICKS:=FALSE; 75048000 + TANK:=TBUF[16]; 75049000 + FOR I ~ 0 STEP 256 UNTIL (MEMMODS + 1) DIV 2 - 1 DO 75050000 + BEGIN 75051000 + FOR J:=0 STEP 5 UNTIL 255 DO 75052000 + BEGIN 75053000 + WRDS:= IF J=255 THEN 1 ELSE 5; 75054000 + MOVIT(M[I+J],MD, WRDS); 75055000 + IF NOTSAME(XMD,MD,2|WRDS)THEN 75056000 + BEGIN 75057000 + OCTIZE(ADDRESS, MD ,WRDS,WRDS!5,TANK); 75058000 + PRINT; 75059000 + ASTERICKS:=FALSE; 75060000 + END ELSE 75061000 + IF NOT ASTERICKS THEN 75062000 + BEGIN 75063000 + STARS(ADDRESS,TANK); 75064000 + PRINT; 75065000 + ASTERICKS:=TRUE; 75066000 + WRITE(LP); 75067000 + END; 75068000 + ADDRESS:=ADDRESS+WRDS; 75069000 + END; 75070000 + IF NOT ASTERICKS THEN 75071000 + WRITE(LP); 75072000 + END; 75073000 + TRACEWORD:=SAVETRACEWORD; N:=SAVEN; NN:=SAVENN; 75074000 +END OF MEMDUMP; 75075000 +PROCEDURE ERROR(ERRNUM); VALUE ERRNUM; REAL ERRNUM; 76000000 + BEGIN 76001000 + FORMAT ERR("ERROR # ",I3,X2,107("X")); 76002000 + TRACE; 76003000 + WRITE(LP,ERR,ERRNUM); 76004000 + END ERROR; 76005000 +PROCEDURE HEADINGLINE (LP); FILE LP; 77000000 + BEGIN 77001000 + ARRAY DAYS[0:6], MONTHS[0:23]; 77002000 + INTEGER I,Q,P,DAY,MONTH,DATE,YEAR,HOURS,MINUTES; 77003000 + FORMAT CONF (X14, 77004000 + " CLOCK RATE NUMBER OF OPERATIONS/MPX ", 77005000 + " MEMORY SPEED MEMORY SIZE",/, X14, 77006000 + " (MEGACYCLES) MULTIPLEXORS A B ", 77007000 + "(MICROSECONDS) (16K MODULES)", 77008000 + /, X14, I9, X3, I10, I11, I7, X11, 77009000 + F3.1, X9 , I3,/), 77010000 + CABH (X14, 77011000 + " LOGICAL UNIT HARDWARE TYPE MULTIPLEXOR", 77012000 + " BUFFER LENGTH WRITE LOCK-OUT INTERNAL NAME", /), 77013000 + CABF (X14, I9, I11," = ", A4, X7, A6, X3, 77014000 + I10, X10, A5, X12, A6), 77015000 + FILF (/, X14, "SOURCE FILE IS: ", A1, A6, "/", A1, A6, "."), 77015100 + CABT (//////); 77016000 + LIST CONL 77017000 + (PROCCLOCK, MPXQUAN, MPXAOPS, IF MPXQUAN=1 THEN 0 ELSE MPXBOPS,77018000 + MEMTIME/10,(MEMMODS+1)DIV 2*15 ); 77019000 +LIST FILEL (MULFILID.[6:6], MULFILID.[12:36], FILID.[6:6], 77019100 + FILID.[12:36]); 77019200 + ARRAY HT [0:133], NAMES [0:3, 0:13]; 77020000 + ALPHA ALF; 77021000 + REAL MPXI; 77022000 + LABEL OWT; 77023000 + FORMAT HEADFMT(X25,"BURROUGHS B-6500 SIMULATOR " 77024000 + X05,A6,"DAY, ",A3,A6,I3,", ",I4, 77025000 + ", ",I2,":",I2,X1,"M."//); 77026000 + PRINTERNOTYETOPENED~FALSE; 77027000 + FILL DAYS[*] WITH 77028000 + " SUN"," MON"," TUES","WEDNES"," THURS"," FRI", 77029000 + " SATUR"; 77030000 + FILL MONTHS[*] WITH 77031000 + " J","ANUARY"," FE","BRUARY"," "," MARCH", 77032000 + " "," APRIL"," "," MAY"," "," JUNE", 77033000 + " "," JULY"," ","AUGUST"," SEP","TEMBER", 77034000 + " O","CTOBER"," NO","VEMBER"," DE","CEMBER"; 77035000 + I~STARTDATE; 77036000 + DATE~I.[30:6]|100+I.[36:6]|10+I.[42:6]; 77037000 + YEAR~1900+I.[18:6]|10+I.[24:6]; 77038000 + FOR I~31,IF YEAR MOD 4 = 0 THEN 29 ELSE 28,31,30,31,30, 77039000 + 31,31,30,31,30 DO 77040000 + IF DATE{I THEN GO OWT 77041000 + ELSE BEGIN DATE~DATE-I; MONTH~MONTH+1; END; 77042000 + OWT: I~ETIME; 77043000 + HOURS~I DIV (60|60|60); 77044000 + MINUTES~(I DIV (60|60)) MOD 60; 77045000 + IF MONTH<2 THEN BEGIN Q~MONTH+11; P~YEAR-1900-1; END 77046000 + ELSE BEGIN Q~MONTH- 1; P~YEAR-1900 ; END; 77047000 + DAY~((Q|26-2) DIV 10+DATE+P+P.[36:10]+1) MOD 7; 77048000 + WRITE(LP,HEADFMT,DAYS[DAY], 77049000 + MONTHS[MONTH|2],MONTHS[MONTH|2+1],DATE,YEAR, 77050000 + I~HOURS MOD 12, MINUTES, 77051000 + IF HOURS>12 THEN "P" ELSE "A"); 77052000 + FILL HT [*] WITH "NONE", "DISK", "SPO ", "AIDS", "NONE","NONE",77053000 + "LP ","LP ", "NONE", "CR ", "CP ", 0,0,"TAPE"; 77054000 + WRITE (LP, CONF, CONL); 77055000 + WRITE (LP, CABH); 77056000 + FILL NAMES [0, *] WITH 77057000 + "NONE ","DISKA ","SPO ","AIDS ","NONE ","NONE " , 77058000 + "LP ","LP ","NONE ","CARD ","PUNCH ",0,0,"TAPEA ";77059000 + FILL NAMES [1, *] WITH 77060000 + 0,"DISKB ",0,0,0,0,"SIMLP ","SIMLP ",0,0,0,0,0,"TAPEB "; 77061000 + FILL NAMES [2, *] WITH 0,"DISKC ",0,0,0,0,0,0,0,0,0, 77062000 + 0,0,"TAPEC "; 77063000 + FILL NAMES [3, *] WITH 0,"DISKD ",0,0,0,0,0,0,0,0,0, 77064000 + 0,0,"TAPED "; 77065000 + FOR I ~ 1, 2 77066000 + DO BEGIN 77067000 + ALF ~ IF I = 1 THEN "1 = A" ELSE "2 = B"; 77068000 + FOR Q ~ 0 STEP 1 UNTIL 31 77069000 + DO IF MPXI ~ MPX [I, Q] ! 0 77070000 + THEN BEGIN 77071000 + P ~ MPXI.MPXHDWE; 77072000 + WRITE (LP, CABF, Q, P, HT [P], ALF, 77073000 + MPXI.MPXBUFF, 77074000 + IF P ! 13 THEN " N/A " 77075000 + ELSE IF MPXI.MPXWLO = 1 77076000 + THEN "TRUE " ELSE "FALSE", 77077000 + NAMES [MPXI.MPXSWFI, P]); 77078000 + END; 77079000 + END; 77080000 + WRITE (LP, FILF, FILEL); 77080100 + WRITE (LP, CABT); 77081000 + END HEADINGLINE; 77082000 +FILL MNEMONIC[0,*] WITH 78000000 + "VALC","VALC","VALC","VALC","VALC","VALC","VALC","VALC", 78001000 + "VALC","VALC","VALC","VALC","VALC","VALC","VALC","VALC", 78002000 + "VALC","VALC","VALC","VALC","VALC","VALC","VALC","VALC", 78003000 + "VALC","VALC","VALC","VALC","VALC","VALC","VALC","VALC", 78004000 + "VALC","VALC","VALC","VALC","VALC","VALC","VALC","VALC", 78005000 + "VALC","VALC","VALC","VALC","VALC","VALC","VALC","VALC", 78006000 + "VALC","VALC","VALC","VALC","VALC","VALC","VALC","VALC", 78007000 + "VALC","VALC","VALC","VALC","VALC","VALC","VALC","VALC", 78008000 + "NAMC","NAMC","NAMC","NAMC","NAMC","NAMC","NAMC","NAMC", 78009000 + "NAMC","NAMC","NAMC","NAMC","NAMC","NAMC","NAMC","NAMC", 78010000 + "NAMC","NAMC","NAMC","NAMC","NAMC","NAMC","NAMC","NAMC", 78011000 + "NAMC","NAMC","NAMC","NAMC","NAMC","NAMC","NAMC","NAMC", 78012000 + "NAMC","NAMC","NAMC","NAMC","NAMC","NAMC","NAMC","NAMC", 78013000 + "NAMC","NAMC","NAMC","NAMC","NAMC","NAMC","NAMC","NAMC", 78014000 + "NAMC","NAMC","NAMC","NAMC","NAMC","NAMC","NAMC","NAMC", 78015000 + "NAMC","NAMC","NAMC","NAMC","NAMC","NAMC","NAMC","NAMC", 78016000 + "ADD ","SUBT","MULT","DIVD","IDIV","RDIV","NTIA","NTGR", 78017000 + "LESS","GREQ","GRTR","LSEQ","EQUL","NEQL","CHSN","MULX", 78018000 + "LAND","LOR ","LNOT","LEQV","SAME","VARI","BSET","DBST", 78019000 + "FLTR","DFTR","ISOL","DISO","INSR","DINS","BRST","DBRS", 78020000 + "BRFL","BRTR","BRUN","EXIT","STBR","NXLN","INDX","RETN", 78021000 + "DBFL","DBTR","DBUN","ENTR","EVAL","NXLV","MKST","STFF", 78022000 + "ZERO","ONE ","LT8 ","LT16","PUSH","DLET","EXCH","DUPL", 78023000 + "STOD","STON","OVRD","OVRN","XXXX","LOAD","LT48","MPCW", 78024000 + "SCLF","DSLF","SCRT","DSRT","SCRS","DSRS","SCRF","DSRF", 78025000 + "SCRR","DSRR","ICVD","ICVU","SNGT","SNGL","XTND","IMKS", 78026000 + "TEED","PACD","EXSD","TWSD","TWOD","SISO","SXSN","ROFF", 78027000 + "TEEU","PACU","EXSU","TWSU","TWOU","EXPU","RTFF","HALT", 78028000 + "TLSD","TGED","TGTD","TLED","TEQD","TNED","TUND","XXXX", 78029000 + "TLSU","TGEU","TGTU","TLEU","TEQU","TNEU","TUNU","XXXX", 78030000 + "CLSD","CGED","CGTD","CLED","CEQD","CNED","XXXX","XXXX", 78031000 + "CLSU","CGEU","CGTU","CLEU","CEQU","CNEU","NOOP","NVLD"; 78032000 +FILL MNEMONIC[1,*] WITH 78033000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78034000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78035000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78036000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78037000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78038000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78039000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78040000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78041000 + "XXXX","XXXX","JOIN","SPLT","IDLE","SINT","EEXI","DEXI", 78042000 + "XXXX","XXXX","SCNI","SCNO","XXXX","XXXX","WHOI","HEYU", 78043000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78044000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78045000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78046000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78047000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78048000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78049000 + "XXXX","XXXX","XXXX","XXXX","XXXX","OCRX","XXXX","XXXX", 78050000 + "XXXX","XXXX","XXXX","LOG2","XXXX","XXXX","XXXX","XXXX", 78051000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78052000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78053000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78054000 + "XXXX","XXXX","XXXX","XXXX","XXXX","IRWL","PCWL","MVST", 78055000 + "XXXX","XXXX","XXXX","XXXX","STAG","RTAG","RSUP","RSON", 78056000 + "RPRR","SPRR","RDLK","CBON","LODT","LLLU","SRCH","XXXX", 78057000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78058000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78059000 + "USND","UABD","TWFD","TWTD","SWFD","SWTD","XXXX","TRNS", 78060000 + "USNU","UABU","TWFU","TWTU","SWFU","SWTU","XXXX","HALT", 78061000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78062000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78063000 + "SLSD","SGED","SGTD","SLED","SEQD","SNED","XXXX","XXXX", 78064000 + "SLSU","SGEU","SGTU","SLEU","SEQU","SNEU","NOOP","NVLD"; 78065000 +FILL MNEMONIC[2,*] WITH 78066000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78067000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78068000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78069000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78070000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78071000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78072000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78073000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78074000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78075000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78076000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78077000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78078000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78079000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78080000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78081000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78082000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78083000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78084000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78085000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78086000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78087000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78088000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78089000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78090000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78091000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78092000 + "MINS","MFLT","SFSC","SRSC","RSTF","ENDF","MVNU","MCHR", 78093000 + "INOP","INSG","SFDC","SRDC","INSU","INSC","ENDE","HALT", 78094000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78095000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78096000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78097000 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","NOOP","NVLD"; 78098000 +FILL DELTAMASK[*] WITH 78099000 + 8191,8191, % 0 AND 178100000 + 4095,4095, % 2 AND 378101000 + 2047,2047,2047,2047, % 4 THRU 778102000 + 1023,1023,1023,1023,1023,1023,1023,1023, % 8 THRU 1578103000 + 511, 511, 511, 511, 511, 511, 511, 511, % 16 THRU 3178104000 + 511, 511, 511, 511, 511, 511, 511, 511; 78105000 +FILL REFLECTION[*] WITH 78106000 + 0, 16, 8, 24, 4, 20, 12, 28, 78107000 + 2, 18, 10, 26, 6, 22, 14, 30, 78108000 + 1, 17, 9, 25, 5, 21, 13, 29, 78109000 + 3, 19, 11, 27, 7, 23, 15, 31; 78110000 +F:=D[2];%%%%%%%%%%%%%%%%%%%%% 78111000 + PDR ~ 8; 78112000 +SIMULATOR; 78113000 +EOJ:END; 78114000 +END. 78115000