From 205a0fdd2bf73d2e7928fd61b6171b020454d72a Mon Sep 17 00:00:00 2001 From: Paul Kimpel Date: Sun, 18 Jun 2017 14:35:41 -0700 Subject: [PATCH] Commit implementation of LONGALG and LONG ARRAYs for use by B65SIM. Commit compile card deck and listing for B65SIM. --- B6500-Simulator/B65SIM-COMPILE-PRT.lst | 7651 ++++++++++++++++++++++++ B6500-Simulator/B65SIM-COMPILE.card | 8 + B6500-Simulator/LONGALG-DELTA.pdf | Bin 0 -> 58699 bytes B6500-Simulator/LONGALG-PATCH.alg_m | 127 + B6500-Simulator/LONGALG.alg_m | 143 +- B6500-Simulator/README.txt | 55 +- 6 files changed, 7946 insertions(+), 38 deletions(-) create mode 100644 B6500-Simulator/B65SIM-COMPILE-PRT.lst create mode 100644 B6500-Simulator/B65SIM-COMPILE.card create mode 100644 B6500-Simulator/LONGALG-DELTA.pdf create mode 100644 B6500-Simulator/LONGALG-PATCH.alg_m diff --git a/B6500-Simulator/B65SIM-COMPILE-PRT.lst b/B6500-Simulator/B65SIM-COMPILE-PRT.lst new file mode 100644 index 0000000..41fe9a3 --- /dev/null +++ b/B6500-Simulator/B65SIM-COMPILE-PRT.lst @@ -0,0 +1,7651 @@ + LABEL 000000000LINE 00187158?COMPILE B65SIM/DISK WITH LONGALG LIBRARY LONGALG/B65SIM + + + + + + RETRO-B5500 LONGALG COMPILER MARK XIII.0 SUNDAY, 06/07/87, 7:30 AM. + + + + + + COMMENT 00099999 T 0000 + ***************************** 00100000 T 0000 + ***** B6500 SIMULATOR ***** 00101000 T 0000 + ***************************** 00102000 T 0000 + ********************************* 00200000 T 0000 + ***** ERROR MESSAGE INDEX ***** 00201000 T 0000 + ********************************* 00202000 T 0000 + # PROCEDURE EXPLANATION 00203000 T 0000 + -- --------- ----------- 00204000 T 0000 + 0 CONTROLSECTION MORE THAN 1 OF VARF,LEEF,TEEF,SEEF ON 00205000 T 0000 + 1 VARI TRIED TO EXECUTE VARI OPERATOR 00206000 T 0000 + 2 (RESERVED FOR TEED) 00207000 T 0000 + 3 (RESERVED FOR TEEU) 00208000 T 0000 + 4 (RESERVED FOR ILED) 00209000 T 0000 + 5 (RESERVED FOR ILEU) 00210000 T 0000 + 6 EXSD TRIED TO EXECUTE EXSD OPERATOR 00211000 T 0000 + 7 EXSU TRIED TO EXECUTE EXSU OPERATOR 00212000 T 0000 + 10 ERVSFLOW INVALID CALL ON ERVSFLOW (FELL THRU SWITCH) 00213000 T 0000 + 11 ERVSFLOW NOT(AROF AND BROF) IN SPECIALINDEX 00214000 T 0000 + 13 ERVSFLOW STACK UNDERFLOW P22 NOTE THIS WILL BE INTERRUPT 00215000 T 0000 + 14 ERVSFLOW PAGE 7A AROF TRUE 00216000 T 0000 + 15 ERVSFLOW BROF FALSE IN NORMALINDEX 00217000 T 0000 + 98 ADJ INVALID PARAMETERS TO ADJ 00218000 T 0000 + 99 ADJ ADJ DIDNT PERFORM REQUESTED ACTION 00219000 T 0000 + 100 RDIV QUOTIENT CANNOT BE INTEGERIZED. 00220000 T 0000 + 101 INTERRUPTCONTROL INT HAS IMPROPER VALUE. 00221000 T 0000 + 200 MULTIPLEXOR A NON-EXISTENT HARDWARE TYPE WAS REQUESTED. 00222000 T 0000 + 201 MULTIPLEXOR THE BUFFER LENGTH FOR A FILE IS TO SMALL. 00223000 T 0000 + 202 IDLE NO INTERRUPTS PENDING FOR IDLE OPERATOR 00224000 T 0000 + % ## TYPE OF TRACE 00225000 T 0000 + % -- ------------- 00226000 T 0000 + % 0 NO TRACE 00227000 T 0000 + % 1 A X B Y REGISTERS 00228000 T 0000 + % 2 C REGISTERS 00229000 T 0000 + % 3 P REGISTER 00230000 T 0000 + % 4 DISPLAY REGISTERS 00231000 T 0000 + % 5 STACK CONTENTS 00232000 T 0000 + % 6 A X B Y C 00233000 T 0000 + % 7 A X B Y P 00234000 T 0000 + % 6 A X B Y DISPLAY 00235000 T 0000 + % 9 A X B Y STACK 00236000 T 0000 + % 10 A X B Y C P 00237000 T 0000 + % 11 A X B Y C DISPLAY 00238000 T 0000 + % 12 A X B Y C STACK 00239000 T 0000 + % 13 A X B Y P DISPLAY 00240000 T 0000 + % 14 A X B Y P STACK 00241000 T 0000 + % 15 A X B Y DISPLAY STACK 00242000 T 0000 + % 16 A X B Y C P DISPLAY 00243000 T 0000 + % 17 A X B Y C P STACK 00244000 T 0000 + % 18 A X B Y C P DISPLAY STACK 00245000 T 0000 + % 19 TYPE 18 TRACE AND MEMORY DUMP % 00246000 T 0000 + % 00247000 T 0000 + % SIMULATOR DIRECTORY 00248000 T 0000 + % 00249000 T 0000 + % SEQ. NR. ITEM 00250000 T 0000 + % 00200000 ERROR MESSAGE INDEX 00251000 T 0000 + % 00400000 HARDWARE 00252000 T 0000 + % 00600000 MISCELLANEOUS DECLARATIONS(SEE ALSO 01000000 AND 01700000) 00253000 T 0000 + % 00700000 B6500 REGISTER,FLIP-FLOP,FLAG,LINE AND BUSS DECLARATIONS 00254000 T 0000 + % 01000000 MISCELLANEOUS DECLARATIONS(SEE ALSO 00600000 AND 01700000) 00255000 T 0000 + % 01200000 B6500 PARTIAL FIELD DEFINES 00256000 T 0000 + % 01400000 WORD FORMAT DESCRIPTIONS 00257000 T 0000 + % 01600000 FORWARD PROCEDURE DECLARATIONS 00258000 T 0000 + % 01700000 MISCELLANEOUS PROCEDURE,DEFINE AND OTHER DECLARATIONS 00259000 T 0000 + % (SEE ALSO 00600000 AND 01000000) 00260000 T 0000 + % 01800000 INTERRUPT CONTROLLER 00261000 T 0000 + % 02000000 SIMULATOR CONTROL SECTION 00262000 T 0000 + % 04000000 SIMULATOR UTILITY PROCEDURES(PSYLLABLES, STEPPSR, ETC.) 00263000 T 0000 + % 07000000 B6500 OPERATOR PROCEDURES 00264000 T 0000 + % 50000000 ERVSFLOW 00265000 T 0000 + % 51000000 STORE (STOD, STON, OVRD, OVRN) 00266000 T 0000 + % 60000000 B6500 MICRO-OPERATORS (ADJ, ETC.) 00267000 T 0000 + % 71000000 SIMULATOR INITIALIZATION 00268000 T 0000 + % 72000000 MULTIPLEXOR 00269000 T 0000 + % 73000000 SIMULATOR 00270000 T 0000 + % 74000000 TRACE 00271000 T 0000 + % 75000Q00 B6500 MEMORY DUMP 00272000 T 0000 + % 76000000 ERROR ROUTINE 00273000 T 0000 + % 77000000 HEADINGLINE 00274000 T 0000 + % 78000000 SIMULATOR STARTS ( I.E. DECLARATIONS AND PROCEDURES END) 00275000 T 0000 + ; 00276000 T 0000 + BEGIN COMMENT SIMULATOR OUTER BLOCK; 00277000 T 0000 +PRT(22) = *LIST, LABEL, OR SEGMENT DESCRIPTOR* +PRT(23) = *OUTER BLOCK DESCRIPTOR* +PRT(24) = *SEGMENT DESCRIPTOR* + START OF SEGMENT ********** 2 + COMMENT DO NOT CHANGE THE PRT LOCATION OF THE FOLLOWING 5 VARIABLES; 00278000 T 0000 + INTEGER TRACEWORD % 25 00278001 T 0000 +PRT(25) = TRACEWORD + ,STATUSWORD % 26 00278002 T 0000 +PRT(26) = STATUSWORD + ,HALTING % 27 00278003 T 0000 +PRT(27) = HALTING + ,TRACTER % 30 00278004 T 0000 +PRT(30) = TRACTER + ,MONITORVALUE % PRT 31 THE SIMULATOR READS AND ACCEPTS THIS 00278005 T 0000 +PRT(31) = MONITORVALUE + % VALUE & PLACES IT IN D[31]. THE MCP MOVES IT 00278006 T 0000 + % FROM D[31] AND PLACES IT IN A GLOBAL 00278007 T 0000 + ; 00278010 T 0000 + REAL PROCCLOCK, % PROCESSOR CLOCK RATE IN MEGACYCLES DEFAULT=10 00279000 T 0000 +PRT(32) = PROCCLOCK + MPXQUAN , % NUMBER OF MULTIPLEXORS DEFAULT= 1 00280000 T 0000 +PRT(33) = MPXQUAN + MPXAOPS , % MAXIMUM OPERATIONS FOR MPXA DEFAULI=10 00281000 T 0000 +PRT(34) = MPXAOPS + MPXBOPS , % MAXIMUM OPERATIONS FOR MPXB DEFAULT=10 00282000 T 0000 +PRT(35) = MPXBOPS + MEMMODS , % NUMBER OF 16K MEMORY MODULES DEFAULT= 2 00283000 T 0000 +PRT(36) = MEMMODS + MEMTIME , % MEMORY CYCLE TIME DEFAULT=1.2 00284000 T 0000 +PRT(37) = MEMTIME + PROCID , % PROCESSOR IDENTIFICATION DEFAULT = 1 00284500 T 0000 +PRT(40) = PROCID + DISKLOAD, % ESPOL = 0; ALGOL = 1; COBOL = 2; 00285000 T 0000 +PRT(41) = DISKLOAD + BUFRMAX , % MAXIMUM BUFFER SIZE 00286000 T 0000 +PRT(42) = BUFRMAX + ROWLENGTH; % LENGTH OF M ARRAY ROW (6500 WORDS) 00287000 T 0000 +PRT(43) = ROWLENGTH + REAL ETIME, PTIME, STARTDATE; 00288000 T 0000 +PRT(44) = ETIME +PRT(45) = PTIME +PRT(46) = STARTDATE + REAL TIMEOFDAY; % WHAT IT SAYS - SEE SCNI - SCNO 00288010 T 0000 +PRT(47) = TIMEOFDAY + SAVE ARRAY TBUF [0:16]; % FORMATTING AREA FOR TRACE AND MEMDUMP 00289000 T 0000 +PRT(50) = TBUF + BOOLEAN PRINTERNOTYETOPENED; 00290000 T 0001 +PRT(51) = PRINTERNOTYETOPENED + REAL STREAM PROCEDURE MKABS (A); BEGIN SI ← A; MKABS ← SI END; 00291000 T 0001 +PRT(52) = MKABS + ARRAY EBCTOBCL [0:31]; % INDEXED BY AN 8 BIT EBCDIC CHARACTER TO 00292000 T 0004 +PRT(53) = EBCTOBCL + % FIND A 6 BIT BCL CHARACTER-MOSTLY INV CHR 00293000 T 0006 + ARRAY BUFFERS [0:3, 0:13]; % BUFFER LENGTHS FOR LOGICAL UNITS 00294000 T 0006 +PRT(54) = BUFFERS + % INDEXED BY HDWE TYPE AND SWITCH FILE INDX 00295000 T 0008 + INTEGER NCR; % ABSOLUTE ADDRESS MESS [0] 00296000 T 0008 +PRT(55) = NCR + DEFINE FILLBUFFERS = % DEFAULT BUFFER LENGTHS 00297000 T 0008 + % HDWE TYPES: DSC SPO BIDS LP CR CP TAPE 00298000 T 0008 + FILL BUFFERS [0,*] WITH 0, 30, 10, 0,0,0,15,0,0,10,10,0,0,1023; 00299000 T 0008 + FILL BUFFERS [1,*] WITH 0, 30, 0, 0,0,0,15,0,0, 0, 0,0,0,1023; 00300000 T 0008 + FILL BUFFERS [2,*] WITH 0, 30, 0, 0,0,0, 0,0,0, 0, 0,0,0,1023; 00301000 T 0008 + FILL BUFFERS [3,*] WITH 0, 30, 0, 0,0,0, 0,0,0, 0, 0,0,0,1023; 00302000 T 0008 + #; 00303000 T 0008 + ARRAY PERIPHERALT[0:69]; %TIMING CONSTANTS FOR PERIPHERAL UNITS 00304000 T 0008 +PRT(56) = PERIPHERALT + DEFINE FILLT=FILL PERIPHERALT[*] WITH 00305000 T 0010 + 0,0,0,0,0, %0 00306000 T 0010 + 80,2@5,0,0,0, %DISK-MPX CYCLE TIME, LATENCY TIME 1 00307000 T 0010 + 0,0,0,0,0, %2 00308000 T 0010 + 0,0,0,0,0, %3 00309000 T 0010 + 0,0,0,0,0, %4 00310000 T 0010 + 0,0,0,0,0, %5 00311000 T 0010 + 2.42@4,57.6@4,24.3@4,6.6@4,10@4, %BUFFERED PRINTER 6 00312000 T 0010 + %MPX BUSY TIME,DRUM ROTATION TIME, 00313000 T 0010 + %FIRST SPACING TIME,EACH ADDITIONAL 00314000 T 0010 + %SPACING TIME 00315000 T 0010 + 27.1@4,75@4,24.3@4,6.6@4,10@4, %UNBUFFERED PRINTER 7 00316000 T 0010 + %SAME AS BUFFERED PRINTER 00317000 T 0010 + 0,0,0,0,0, %8 00318000 T 0010 + 24.3@4,75@4,0.0,0, %CARD READER -EL.CYCLE,ME.CYCLE 9 00319000 T 0010 + 24.3@4,6@6,0,0,0, %CARD PUNCH-EL.CYCLE,ME.CYCLE 10 00320000 T 0010 + 0,0,0,0,0, %11 00321000 T 0010 + 0,0,0,0,0, %12 00322000 T 0010 + 120,800,6.7@4,.6,0; %MAGNETIC TAPE- 13 00323000 T 0010 + %SPEED,DENSITY,START TIME,RECORD GAP 00324000 T 0010 + #; 00325000 T 0010 + ARRAY STATVECTOR [0:7]; % PERIPHERAL STATUS WORDS 00325100 T 0010 +PRT(57) = STATVECTOR + ARRAY OLDSTATVEC [0:7]; % TO SAVE OFF CHANGED STATUS WORD 00325300 T 0012 +PRT(60) = OLDSTATVEC + ALPHA 00326000 T 0014 + ARRAY MPX [0:6, 0:31]; COMMENT INDEXED BY MULTIPLEXOR 00327000 T 0014 +PRT(61) = MPX + AND LOGICAL UNIT NO. CONTAINS: 00328000 T 0016 + RESULT DESCRIPTOR MPX [MPXUNIT+4,LOGICALUNIT] 00329000 T 0016 + AND MPX INFO WORD 00330000 T 0016 + ; 00331000 T 0016 + BOOLEAN MULTIPLEX; % TRUE FOR SCNO (IIO) 00332000 T 0016 +PRT(62) = MULTIPLEX + BOOLEAN SPOED; % TRUE FOR NOTHINGTODO READ 00333000 T 0016 +PRT(63) = SPOED + ARRAY CUP[0:11]; 00334000 T 0016 +PRT(64) = CUP + REAL TUBA, 00335000 T 0017 +PRT(65) = TUBA + PID; % PROCESSOR I.D. 00335500 T 0017 +PRT(66) = PID + SAVE ALPHA 00336000 T 0017 + ARRAY EVENTS [0:31]; COMMENT INDEXED BY LOGICAL UNIT OR SELF. 00337000 T 0017 +PRT(67) = EVENTS + CONTAINS THE REAL TIME FOR THE COMPLETION OF THE I-O 00338000 T 0019 + BEING PERFORMED ON THIS UNIT AND A LINK TO THE NEXT 00339000 T 0019 + EVENT AND A MULTIPLEXOR INDICATOR. 00340000 T 0019 + ; 00341000 T 0019 + ARRAY UNITAVAILTIME[0:31]; COMMENT-INDEXED BY LOGICAL UNIT. 00342000 T 0019 +PRT(70) = UNITAVAILTIME + CONTAINS REALTIME WHEN NEXT I/O COULD BE 00343000 T 0021 + INITIATED ON THIS UNIT.; 00344000 T 0021 + DEFINE % DEFINES FOR MPX AND EVENTS PARTIAL FIELDS 00345000 T 0021 + EVTIME = [12:36]#, % I-O COMPLETE TIME 00346000 T 0021 + EVLINK = [ 7: 5]#, % EVENT LINK 00347000 T 0021 + EVBUSY = [ 6: 1]#, % BUSY BIT 00348000 T 0021 + EVMPX = [ 1: 2]#, % MPX FOR THIS I-O 00349000 T 0021 + RSLTERR = [31:17]#, % ERROR FIELD 00350000 T 0021 + RSLTUNIT = [23: 8]#, % UNIT 00351000 T 0021 + TCHRS = [20: 3]#, % RESULT CHRS 00352000 T 0021 + RSLTADRS = [ 1:19]#, % ADDRESS 00353000 T 0021 + MPXINT = [38:10]#, % MPX INTERRUPT VALUE 00354000 T 0021 + MPXHDWE = [32: 6]#, % HARDWARE UNIT TYPE 00355000 T 0021 + MPXSWFI = [24: 6]#, % SWITCH FILE INDEX 00356000 T 0021 + MPXWLO = [ 1: 1]#, % 1 = WRITE LOCK-OUT 00357000 T 0021 + TUB = [ 2:9]#, % TU & BUF ADDRESS 00358000 T 0021 + MPXBUFF = [14:10]#; % BUFFER LENGTH 00359000 T 0021 + %>RETRO 00360000 T 0021 + REAL ARRAY FIRSTEVENT [0:15], LASTEVENT [0:15]; %>RETRO 00361000 T 0021 +PRT(71) = FIRSTEVENT +PRT(72) = LASTEVENT + INTEGER ARRAY FIRSTEVENTI[0:15], LASTEVENTI[0:15]; %>RETRO 00362000 T 0024 +PRT(73) = FIRSTEVENTI +PRT(74) = LASTEVENTI + REAL CURRENTT, % THE TIME FOR THE NEXT MULTIPLEXOR INTERRUPT 00363000 T 0028 +PRT(75) = CURRENTT + CURRENTMPX; % THE MPX FOR THE NEXT MULTIPLEXOR INTERRUPT 00364000 T 0028 +PRT(76) = CURRENTMPX + ARRAY MPXOPS [0:2];%OPERATIONS PER MPX 00365000 T 0028 +PRT(77) = MPXOPS + DEFINE DELTAMPX = 4#; % THE INCREMENT REQUIRED TO FIND THE RESULT 00366000 T 0030 + % DESCRIPTOR IN MPX ARRAY. 00367000 T 0030 + INTEGER INTTIMER; % THE NEXT REAL TIME FOR A TIME INTERRUPT 00368000 T 0030 +PRT(100) = INTTIMER + REAL MONITORMASKOLD;% TEMPORARY MONITOR MASK 00369000 T 0030 +PRT(101) = MONITORMASKOLD + REAL MONITORMASK; 00369100 T 0030 +PRT(102) = MONITORMASK + PROCEDURE HARDWARE; 00400000 T 0030 +PRT(103) = HARDWARE + BEGIN 00401000 T 0030 + DEFINE LUNIT= TBUF [0]#, 00402000 T 0030 + START OF SEGMENT ********** 3 + HTYPE= TBUF [1]#, 00403000 T 0000 + MPXAB= TBUF [2]#, 00404000 T 0000 + BUFLG= TBUF [3]#, 00405000 T 0000 + WLO = TBUF [4]#; 00406000 T 0000 + INTEGER I, J, S; 00407000 T 0000 +STACK(F+2) = I +STACK(F+3) = J +STACK(F+4) = S + LABEL EOF; 00408000 T 0000 + DEFINE 00409000 T 0000 + TIMEADJUST = ;#; %%%%%%%%%% 00410000 T 0000 + TBUF [16] ← MKABS (TBUF); 00411000 T 0000 + PRINTERNOTYETOPENED ← TRUE; 00412000 T 0002 + FILLBUFFERS; 00413000 T 0003 + START OF SEGMENT ********** 4 + 4 IS 14 LONG, NEXT SEG 3 + START OF SEGMENT ********** 5 + 5 IS 14 LONG, NEXT SEG 3 + START OF SEGMENT ********** 6 + 6 IS 14 LONG, NEXT SEG 3 + START OF SEGMENT ********** 7 + 7 IS 14 LONG, NEXT SEG 3 + FILLT; 00414000 T 0011 + START OF SEGMENT ********** 8 + 8 IS 69 LONG, NEXT SEG 3 + FILL EBCTOBCL [*] WITH % GRAPHIC UNDER LOW-ORDER OCTADE 00415000 T 0013 + OCT1414141414141414, 00416000 T 0013 + START OF SEGMENT ********** 9 + OCT1414141414141414, 00417000 T 0014 + OCT1414141414141414, 00418000 T 0014 + OCT1414141414141414, 00419000 T 0014 + OCT1414141414141414, 00420000 T 0014 + OCT1414141414141414, 00421000 T 0014 + OCT1414141414141414, 00422000 T 0014 + OCT1414141414141414, 00423000 T 0014 + OCT6014141414141414, 00424000 T 0014 + % BLANK 00425000 T 0014 + OCT1414143236352037, 00426000 T 0014 + % . < ( + ← 00427000 T 0014 + OCT3414141414141414, 00428000 T 0014 + % & 00429000 T 0014 + OCT1414405253555657, 00430000 T 0014 + % × $ * ) ; ≤ 00431000 T 0014 + OCT5461141414141414, 00432000 T 0014 + % - / 00433000 T 0014 + OCT1414767273741614, 00434000 T 0014 + % ] , % ≠ > QUESTION MARK 00435000 T 0014 + OCT3314141414141414, 00436000 T 0014 + % [ 00437000 T 0014 + OCT1414151213177577, 00438000 T 0014 + % : # @ ≥ = " 00439000 T 0014 + OCT1414141414141414, 00440000 T 0014 + OCT1414141414141414, 00441000 T 0014 + OCT1414141414141414, 00442000 T 0014 + OCT1414141414141414, 00443000 T 0014 + OCT1414141414141414, 00444000 T 0014 + OCT1414141414141414, 00445000 T 0014 + OCT1414141414141414, 00446000 T 0014 + OCT1414141414141414, 00447000 T 0014 + OCT1421222324252627, 00448000 T 0014 + % A B C D E F G 00449000 T 0014 + OCT3031141414141414, 00450000 T 0014 + % H I 00451000 T 0014 + OCT1441424344454647, 00452000 T 0014 + % J K L M N O P 00453000 T 0014 + OCT5051141414141414, 00454000 T 0014 + % Q R 00455000 T 0014 + OCT1414626364656667, 00456000 T 0014 + % S T U V W X 00457000 T 0014 + OCT7071141414141414, 00458000 T 0014 + % Y Z 00459000 T 0014 + OCT0001020304050607, 00460000 T 0014 + % 0 1 2 3 4 5 6 7 00461000 T 0014 + OCT1011141414141414; 00462000 T 0014 + 9 IS 32 LONG, NEXT SEG 3 + % 8 9 00463000 T 0014 + BEGIN 00464000 T 0014 + FILE CONFIGURATION (1, 10); 00465000 T 0014 +PRT(104) = *SEGMENT DESCRIPTOR* + START OF SEGMENT ********** 10 +STACK(F+5) = CONFIGURATION + READ (CONFIGURATION, /, PROCCLOCK, MPXQUAN, MPXAOPS, 00466000 T 0004 +PRT(105) = +PRT(106) = *LIST, LABEL, OR SEGMENT DESCRIPTOR* + MPXBOPS, MEMMODS, MEMTIME, PROCID, DISKLOAD 00467000 T 0011 + ,HALTING 00467010 T 0017 + ,MONITORMASK 00467100 T 0018 + ,MONITORVALUE 00467200 T 0019 + ); 00468000 T 0020 +PRT(107) = INPUT(W) + MONITORMASKOLD ← MONITORVALUE; 00468900 T 0024 + IF PROCCLOCK = 0 THEN PROCCLOCK ← 10; % MEGACYCLES 00469000 T 0025 + IF MPXQUAN = 0 THEN MPXQUAN ← 1; % MULTIPLEXORS 00470000 T 0027 + MPXAOPS ← 00471000 T 0029 + MPXOPS [1] ← IF MPXAOPS = 0 THEN 10 ELSE MPXAOPS; 00472000 T 0029 + MPXBOPS ← 00473000 T 0033 + MPXOPS [2] ← IF MPXBOPS = 0 THEN 10 ELSE MPXBOPS; 00474000 T 0033 + IF MEMTIME = 0 THEN MEMTIME ← 1.2;% MICROSECONDS 00475000 T 0037 + MEMTIME ← MEMTIME × 10; 00476000 T 0039 + MEMMODS ← (2*14×2×(IF MEMMODS = 0 THEN 2 ELSE MEMMODS))-1; 00477000 T 0040 + IF PROCID = 0 THEN PID ← 1 ELSE PID ← PROCID; 00477500 T 0047 + IF DISKLOAD > 0 THEN INTTIMER ← 0 ; 00478000 T 0051 + END; 00479000 T 0053 +PRT(110) = *SEGMENT DESCRIPTOR* + 10 IS 57 LONG, NEXT SEG 3 + BEGIN 00480000 T 0016 + FILE CABLING (2, 10); 00481000 T 0016 +PRT(111) = *SEGMENT DESCRIPTOR* + START OF SEGMENT ********** 11 +STACK(F+5) = CABLING + STREAM PROCEDURE STATUS(SWORD, LUNIT); VALUE LUNIT; 00481100 T 0004 +PRT(112) = STATUS + BEGIN DI ← SWORD; SKIP LUNIT DB; DS ← 1 SET END STATUS; 00481200 T 0004 + LABEL EOF; 00482000 T 0006 + STATUSWORD ← 1; 00482100 T 0006 + DO BEGIN 00483000 T 0007 + READ (CABLING, /, LUNIT, HTYPE, MPXAB, BUFLG 00484000 T 0007 +PRT(113) = *LIST, LABEL, OR SEGMENT DESCRIPTOR* + , WLO , TUBA )[EOF]; 00485000 T 0017 +PRT(114) = EOF +PRT(115) = GO TO SOLVER + IF MPXAB = 0 THEN MPXAB ← 1; 00486000 T 0025 + MPX [I ← MPXAB, J ← LUNIT].MPXWLO ← WLO; 00487000 T 0028 + MPX [I, J].MPXHDWE ← HTYPE; 00488000 T 0033 + MPX [I, J].MPXSWFI ← S ← MPX [0, HTYPE]; 00489000 T 0036 + MPX [0, HTYPE] ← MPX [0, HTYPE] + 1; 00490000 T 0041 + IF BUFLG ≠ 0 THEN BUFFERS [S, HTYPE] ← 00491000 T 0045 + BUFLG; 00492000 T 0048 + MPX [I, J].MPXBUFF ← BUFLG; 00493000 T 0049 + I ← 46 - LUNIT; 00493100 T 0053 + STATUS (STATUSWORD, I); 00493200 T 0054 + END UNTIL FALSE; 00494000 T 0055 + EOF: END; 00495000 T 0056 +PRT(116) = *SEGMENT DESCRIPTOR* + 11 IS 60 LONG, NEXT SEG 3 + S ← 10; % MINIMUM BUFFER SIZE IS 10 00496000 T 0017 + FOR I ← 0 STEP 1 UNTIL 3 DO 00497000 T 0017 + FOR J ← 0 STEP 1 UNTIL 13 DO 00498000 T 0019 + IF BUFFERS [I, J] > S THEN S ← BUFFERS [I, J]; 00499000 T 0020 + BUFRMAX ← S; 00500000 T 0028 + LUNIT ← 0; 00501000 T 0029 + ETIME ← TIME (1); 00502000 T 0030 + PTIME ← TIME (2); 00503000 T 0031 + STARTDATE ← TIME (0); 00504000 T 0033 + TIMEADJUST; 00505000 T 0034 + ROWLENGTH ← 256; 00506000 T 0034 + END OF HARDWARE INITIALIZE; 00507000 T 0035 + 3 IS 40 LONG, NEXT SEG 2 + HARDWARE; 00508000 T 0030 + BEGIN 00509000 T 0030 + LABEL EOJ; 00600000 T 0030 +PRT(117) = *SEGMENT DESCRIPTOR* + START OF SEGMENT ********** 12 + INTEGER T; 00601000 T 0000 +PRT(120) = T + DEFINE STACKVECTOR = D0+2#; 00602000 T 0000 + %**************************************** 00700000 T 0000 + %***** B6500 REGISTER DECLARATIONS ***** 00701000 T 0000 + %**************************************** 00702000 T 0000 + %NAME #BITS DESCRIPTION 00703000 T 0000 + REAL A,AX, % 51 TOP OPERAND IN STACK 00704000 T 0000 +PRT(121) = A +PRT(122) = AX + X,XX, % 51 EXTENSION OF A 00705000 T 0000 +PRT(123) = X +PRT(124) = XX + B,BX, % 51 SECOND OPERAND IN STACK 00706000 T 0000 +PRT(125) = B +PRT(126) = BX + Y,YX, % 51 EXTENSION OF B 00707000 T 0000 +PRT(127) = Y +PRT(130) = YX + C,CX, % 51 GENERAL PURPOSE REGISTER 00708000 T 0000 +PRT(131) = C +PRT(132) = CX + P,PX; % 51 PROGRAM REGISTER 00709000 T 0000 +PRT(133) = P +PRT(134) = PX + BOOLEAN AROF, % 1 A REGISTER OCCUPIED 00710000 T 0000 +PRT(135) = AROF + BROF, % 1 B REGISTER OCCUPIED 00711000 T 0000 +PRT(136) = BROF + PROF; % 1 P REGISTER OCCUPIED 00712000 T 0000 +PRT(137) = PROF + DEFINE MEMCYCLE = DELTATIME ← DELTATIME + MEMTIME;#; 00713000 T 0000 + LONG ARRAY M [0:MEMMODS]; 00714000 T 0000 +PRT(140) = M + %NOTE: INDICIES ARE AUTOMATICALLY DOUBLED 00715000 T 0005 + % AND THE ARRAY IS PARTIONED INTO A 00716000 T 0005 + % TWO-DIMENSIONAL ARRAY WITH 256-WD ROWS 00717000 T 0005 + % BY SPECIAL COMPILER PATCHES. 00718000 T 0005 + REAL MA, % 3 MANTISSA EXTENSION OF A 00719000 T 0005 +PRT(141) = MA + MB, % 3 MANTISSA EXTENSION OF B 00720000 T 0005 +PRT(142) = MB + EA, % 1 EXPONENT EXTENSION OF A 00721000 T 0005 +PRT(143) = EA + EB, % 1 EXPONENT EXTENSION OF B 00722000 T 0005 +PRT(144) = EB + AA, % 42 10 MC ADDER CAPTIVE REGISTER (ADDEND) 00723000 T 0005 +PRT(145) = AA + BB, % 42 10 MC ADDER CAPTIVE REGISTER (AUGEND) 00724000 T 0005 +PRT(146) = BB + CC, % 42 10 MC ADDER CAPTIVE REGISTER (IDLER) 00725000 T 0005 +PRT(147) = CC + SGNF, % 1 EXTERNAL SIGN 00726000 T 0005 +PRT(150) = SGNF + MM, % 20 MAIN MEMORY ADDRESSING REGISTER 00727000 T 0005 +PRT(151) = MM + LL, % 5 LEXIOGRAPHIC LEVEL (DISPLAY MEMORY POINTER) 00728000 T 0005 +PRT(152) = LL + BRS, % 7 BASE READ SELECT (I.C. MEMORY ADDRESSING REG.) 00729000 T 0005 +PRT(153) = BRS + BWS, % 7 BASE WRITE SELECT (I.C. MEMORY ADDRESSING REG.) 00730000 T 0005 +PRT(154) = BWS + IRS, % 4 INDEX READ SELECT (I.C. MEMORY ADDRESSING REG.) 00731000 T 0005 +PRT(155) = IRS + IWS, % 4 INDEX WRITE SELECT (I.C. MEMORY ADDRESSINS REG.) 00732000 T 0005 +PRT(156) = IWS + OPSR,% 3 OLD PSR 00733000 T 0005 +PRT(157) = OPSR + PICR,% 20 PROGRAM INDEX COUNTER FOR SINGLE INSTRUCTION 00734000 T 0005 +PRT(160) = PICR + DRS; % 6 DISPLAY READ SELECT REGISTER 00735000 T 0005 +PRT(161) = DRS + ARRAY D[0:31];%20 I.C. DISPLAY MEMORY 00736000 T 0005 +PRT(162) = D + DEFINE D0 = D[ 0]#, D8 = D[ 8]#, D16 = D[16]#, D24 = D[24]#, 00737000 T 0007 + D1 = D[ 1]#, D9 = D[ 9]#, D17 = D[17]#, D25 = D[25]#, 00738000 T 0007 + D2 = D[ 2]#, D10 = D[10]#, D18 = D[18]#, D26 = D[26]#, 00739000 T 0007 + D3 = D[ 3]#, D11 = D[11]#, D19 = D[19]#, D27 = D[27]#, 00740000 T 0007 + D4 = D[ 4]#, D12 = D[12]#, D20 = D[20]#, D28 = D[28]#, 00741000 T 0007 + D5 = D[ 5]#, D13 = D[13J#, D21 = D[21]#, D29 = D[29]#, 00742000 T 0007 + D6 = D[ 6]#, D14 = D[14]#, D22 = D[22]#, D30 = D[30]#, 00743000 T 0007 + D7 = D[ 7]#, D15 = D[15]#, D23 = D[23]#, D31 = D[31]#, 00744000 T 0007 + D00 = D[ 0]#, D03 = D[03]#, D06 = D[06]#, D09 = D[09]#, 00745000 T 0007 + D01 = D[ 1]#, D04 = D[04]#, D07 = D[07]#, 00746000 T 0007 + D02 = D[02]#, D05 = D[05]#, D08 = D[08]#; 00747000 T 0007 + INTEGER SP, % 6 SOURCE REGISTER POINTER 00748000 T 0007 +PRT(163) = SP + DP, % 6 DESTINATION REGISTER POINTER 00749000 T 0007 +PRT(164) = DP + G, % 6 00750000 T 0007 +PRT(165) = G + K, % 6 00751000 T 0007 +PRT(166) = K + TP, % 4 TABLE BASE POINTER 00753000 T 0007 +PRT(167) = TP + PSR; % 3 PROGRAM SYLLABLE REGISTER 00754000 T 0007 +PRT(170) = PSR + COMMENT THE FOLLOWING DECLARATION IS FOR THE 8 I.C. BASE REGISTERS 00755000 T 0007 + AND ITS INTERNAL SEQUENCE SHOULD NOT BE DISTURBED WITHOUT 00756000 T 0007 + CHECKING THE ARRAY BRSR, PROCEDURES RPRR AND SPRR, ETC.; 00757000 T 0007 + REAL PBR, SBR, DBR, TBR, S, SNR, PDR, TEMP; %DLK 00758000 T 0007 +PRT(171) = PBR +PRT(172) = SBR +PRT(173) = DBR +PRT(174) = TBR +PRT(175) = S +PRT(176) = SNR +PRT(177) = PDR +PRT(200) = TEMP + DEFINE BUF2 = TBR#; % SHARED REGISTERS 00759000 T 0007 + REAL TSR; 00760000 T 0007 +PRT(201) = TSR + COMMENT THE FOLLOWING DECLARATION IS FOR THE 8 I.C. INDEX REGISTERS 00761000 T 0007 + AND ITS INTERNAL SEQUENCE SHOULD NOT BE DISTURBED WITHOUT 00762000 T 0007 + CHECKING THE ARRAY BRSR, PROCEDURES RPRR AND SPRR, ETC.; 00763000 T 0007 + REAL PIR, SIR, DIR, TIR, LOSR, BOSR, F, BUF1; %DLK 00764000 T 0007 +PRT(202) = PIR +PRT(203) = SIR +PRT(204) = DIR +PRT(205) = TIR +PRT(206) = LOSR +PRT(207) = BOSR +PRT(210) = F +PRT(211) = BUF1 + DEFINE BUF3 = TIR#; % SHARED REGISTERS 00765000 T 0007 + COMMENT ***** EXPLANATORY ONLY (SEE ABOVE) ****************** 00766000 T 0007 + PBR, % 20 PROGRAM BASE REGISTER 00767000 T 0007 + SBR, % 20 SOURCE BASE REGISTER 00768000 T 0007 + DBR, % 20 DESTINATION BASE REGISTER 00769000 T 0007 + BUF2, % 20 UTILITY REGISTER - SHARED WITH TBR 00770000 T 0007 + S, % 20 TOP OF STACK POINTER 00771000 T 0007 + SNR, % 20 STACK NUMBER REGISTER 00772000 T 0007 + PDR, % 20 PROGRAM DESCRIPTOR REGISTER 00773000 T 0007 + TEMP, % 20 TEMPORARY G.P. REGISTER 00774000 T 0007 + PIR, % 20 PROGRAM INDEX REGISTER 00775000 T 0007 + PICR, %4 DELTA PIR FOR OPERATOR, USED TO RESTORE PIR 00776000 T 0007 + SIR, % 20 SOURCE INDEX REGISTER 00777000 T 0007 + DIR, % 20 DESTINATION INDEX REGISTER 00778000 T 0007 + TIR, % 20 TABLE INDEX REGISTER 00779000 T 0007 + BUF3, % 20 UTILITY REGISTER - SHARED WITH TIR 00780000 T 0007 + LOSR, % 20 LIMIT OF STACK REGISTER 00781000 T 0007 + BOSR, % 20 BASE OF STACK REGISTER 00782000 T 0007 + F, % 20 MARK STACK POINTER 00783000 T 0007 + BUF; % 20 BUFFER G.P. REGISTER 00784000 T 0007 + DEFINE BUF = BUF1#; % TO OVERCOME NOMENCLATURE DIFFICULTY 00785000 T 0007 + INTEGER 00786000 T 0007 + SIB, % 6 SOURCE BIT INDEX REGISTER 00787000 T 0007 +PRT(212) = SIB + DIB, % 6 DESTINATION BIT INDEX REGISTER 00788000 T 0007 +PRT(213) = DIB + RPF, % 20 REPEAT FIELD REGISTER 00789000 T 0007 +PRT(214) = RPF + DIS, % 00790000 T 0007 +PRT(215) = DIS + TOM, % 6 TOP OF MASK 00791000 T 0007 +PRT(216) = TOM + TOA; % 6 TOP OF APERATURE 00792000 T 0007 +PRT(217) = TOA + ARRAY IRSR, BRSR [0:7]; % USED TO HOLD BASE AND INDEX REGISTERS 00793000 T 0007 +PRT(220) = IRSR +PRT(221) = BRSR + ARRAY MONITOROUTPUT [0:13]; 00793100 T 0011 +PRT(222) = MONITOROUTPUT + FORMAT MONFMT (X1,A1,A6,X1,I1, X1, 16I1, 7(X2, I5, X1, I5)); 00793200 T 0013 + START OF SEGMENT ********** 13 +PRT(223) = MONFMT + 13 IS 16 LONG, NEXT SEG 12 + DEFINE NULLB=0#,% NULL STATE FOR I.C. MEMORY BASE REGISTERS 00794000 T 0013 + NULLI=0#;% NULL STATE FOR I.C. MEMORY INDEX REGISTERS 00795000 T 0013 + REAL AB, % 20 ADDRESS BASE BUSS 00796000 T 0013 +PRT(224) = AB + AI; % 20 ADDRESS INDEX BUSS 00797000 T 0013 +PRT(225) = AI + BOOLEAN NCSF; % 1 NORMAL STATE FF 00798000 T 0013 +PRT(226) = NCSF + REAL QP; % MISC CONTROL FLIP/FLOPS (STRING OPERATORS) 00798500 T 0013 +PRT(227) = QP + REAL Q; % 18 Q0 AND QC SETS OF G.P. LOGICAL FFS (CLEARED AT SECL) 00799000 T 0013 +PRT(230) = Q + DEFINE Q00F = Q.[47:1]#, Q03F = Q.[44:1]#, Q06F = Q.[41:1]#, 00800000 T 0013 + Q01F = Q.[46:1]#, Q04F = Q.[43:1]#, Q07F = Q.[40:1]#, 00801000 T 0013 + Q02F = Q.[45:1]#, Q05F = Q.[42:1]#, Q08F = Q.[39:1]#, 00802000 T 0013 + QC0F = Q.[38:1]#, QC3F = Q.[35:1]#, QC6F = Q.[32:1]#, 00803000 T 0013 + QC1F = Q.[37:1]#, QC4F = Q.[34:1]#, QC7F = Q.[31:1]#, 00804000 T 0013 + QC2F = Q.[36:1]#, QC5F = Q.[33:1]#, QC8F = Q.[30:1]#; 00805000 T 0013 + REAL N; % 4 G.P. COUNT REGISTER (CLEARED AT SECL) 00806000 T 0013 +PRT(231) = N + BOOLEAN LPF, % 1 LINE PARITY--READ 00807000 T 0013 +PRT(232) = LPF + IIHF, % 1 00807500 T 0013 +PRT(233) = IIHF + SUFL, % 1 STACK UNDER FLOW FLIP/FLOP 00807600 T 0013 +PRT(234) = SUFL + EXTF, % 1 ENTERNAL SIGN FLIP FLOP 00808000 T 0013 +PRT(235) = EXTF + TFFF, % 1 TRUE/FALSE FF 00809000 T 0013 +PRT(236) = TFFF + OFFF, % 1 OVERFLOW FF 00810000 T 0013 +PRT(237) = OFFF + FLTF , % 1 FLOAT FLIP FLOP 00811000 T 0013 +PRT(240) = FLTF + TEEF, % 1 TABLE EDIT ESCAPE 00812500 T 0013 +PRT(241) = TEEF + LEEF, % 1 LINE EDIT ESCAPE 00813000 T 0013 +PRT(242) = LEEF + EDITF , % 1 EDIT MODE FLIP FLOP 00814000 T 0013 +PRT(243) = EDITF + EXSF , % 1 EXECUTE SINGLE SHOT 00815000 T 0013 +PRT(244) = EXSF + ESPF , % 1 EXECUTE SINGLE POINTER 00815500 T 0013 +PRT(245) = ESPF + UPDF , % 1 UPDATE 00816000 T 0013 +PRT(246) = UPDF + SOPF , % 1 SINGLE PRECISION OPERAND 00817000 T 0013 +PRT(247) = SOPF + RNTF , % 1 RE-ENTER FLIP/FLOP FOR CHARACTER MODE 00818000 T 0013 +PRT(250) = RNTF + VARF; % 1 VARIANT ESCAPE 00819000 T 0013 +PRT(251) = VARF + DEFINE SEEF = EXSF#; 00820000 T 0013 + REAL SSZ, % 2 SOURCE CHARACTER SIZE 00821000 T 0013 +PRT(252) = SSZ + DSZ, % 2 DESTINATION CHARACTER SIZE 00822000 T 0013 +PRT(253) = DSZ + TCS, % 2 TABLE CHARACTER SIZE 00823000 T 0013 +PRT(254) = TCS + OFS, % 6 OFFSET REGISTER (SIEERING CONTROL) 00824000 T 0013 +PRT(255) = OFS + J1F, % 6 FAMILY 1 SEQUENCE COUNTER 00825000 T 0013 +PRT(256) = J1F + J2F; % 6 FAMILY 2 SEQUENCE COUNTER 00826000 T 0013 +PRT(257) = J2F + BOOLEAN REQ, % 1 REQUEST (MEM. INTERFACE) 00827000 T 0013 +PRT(260) = REQ + WRT, % 1 WRITE (MEM. INTERFACE) 00828000 T 0013 +PRT(261) = WRT + PRO, % 1 PROTECT (MEM. INTERFACE) 00829000 T 0013 +PRT(262) = PRO + MROF; % 1 MEM. READ OBTAINED (MEM. INTERFACE) 00830000 T 0013 +PRT(263) = MROF + BOOLEAN STKOVFF; % ADJ SETS TRUE FOR STACK OVERFLOW 00830100 T 0013 +PRT(264) = STKOVFF + DEFINE % ALARM INTERRUPTS 00831000 T 0013 + LOOPI = 33554433 #, % 2*25+2*0 OPERATOR LOOP 00832000 T 0013 + MEMPARI = 33554434 #, % 2*25+2*1 MEMORY PARITY 00833000 T 0013 + MPXPARI = 33554436 #, % 2*25+2*2 MULTIPLEXOR PARITY 00834000 T 0013 + INVADRI = 33554440 #, % 2*25+2*3 INVALID ADDRESS 00835000 T 0013 + STKUNFI = 33554448 #, % 2*25+2*4 STACK UNDERFLOW 00836000 T 0013 + INVOPA = 33554464 #, % 2*25+2*5 UNKNOWN OPERATOR 00837000 T 0013 + % SYLLABLE DEPENDENT INTERRUPTS 00838000 T 0013 + MEMPROI = 16777217 #, % 2*24+2*0 MEMORY PROTECT 00839000 T 0013 + INVOP = 16777218 #, % 2*24+2*1 INVALID OPERATOR 00840000 T 0013 + DIVZROI = 16777220 #, % 2*24+2*2 DIVIDE BY ZERO 00841000 T 0013 + EXPOVFI = 16777224 #, % 2*24+2*3 EXPONENT OVERFLOW 00842000 T 0013 + EXPUNFI = 16777232 #, % 2*24+2*4 EXPONENT UNDERFLOW 00843000 T 0013 + INVINXI = 16777248 #, % 2*24+2*5 INVALID INDEX 00844000 T 0013 + INTOVFI = 16777280 #, % 2*24+2*6 INTEGER OVERFLOW 00845000 T 0013 + BOSINT = 16777344 #, % 2*24+2*7 BOTTOM OF STACK 00846000 T 0013 + PRESBIT = 16777472 #, % 2*24+2*8 PRESENCE BIT 00847000 T 0013 + SEQERRI = 16777728 #, % 2*24+2*9 SEQUENCE ERROR 00848000 T 0013 + % GENERAL CONTROL INTERRUPTS 00849000 T 0013 + INTTIMI = 4194305 #, % 2*22+2*0 INTERVAL TIMER 00850000 T 0013 + STKOVFI = 4194306 #, % 2*22+2*1 STACK OVERFLOW 00851000 T 0013 + % EXTERNAL INTERRUPTS 00852000 T 0013 + EXTINTI = 1048816#, % BITS 20, 7-4 ON EXTERNAL INTERRUPT 00853000 T 0013 + %I/O FINISH BEING FORCED, MLC NOT HONORD 00854000 T 0013 + PTOPI = 2097152 #, % 2*21 PROCESSOR TO PROCESSOR 00855000 T 0013 + DUMMYI = 0#; 00856000 T 0013 + REAL INT; % INTERRUPT FLIP/FLOPS 00857000 T 0013 +PRT(265) = INT + % FLIP/FLOP FUNCTION 00858000 T 0013 + DEFINE EXIA = INT.[27:1]#, % [20:1] EXIA MPXA 00859000 T 0013 + PTPI = INT.[26:1]#, %[21:1] PTPI PROCESSOR 00860000 T 0013 + GCIF = INT.[25:1]#, % [22:1] GENERAL CONTROL 00861000 T 0013 + SDIS = INT.[23:2]#, %[24:2] SDIS SYLLABLE DEPENDENT 00862000 T 0013 + ALRM = INT.[22:1]#, %[25:1] ALRM ALARM INTERRUPT 00863000 T 0013 + % GCIF & ALRM HAVE NOONES APPROVAL 00864000 T 0013 + DUMMYF = 0#; 00865000 T 0013 + REAL E, % 4 MEM. CYCLE REQUEST (MEM. INTERFACE) 00866000 T 0013 +PRT(266) = E + RF; % 8 REPEAT FIELD REGISTER 00867000 T 0013 +PRT(267) = RF + REAL ICR1; % INTERRUPT CONTROL REGISTER 00868000 T 0013 +PRT(270) = ICR1 + INTEGER 01000000 T 0013 + NSTACK, % VALUE USED FOR TRACING STACK 01001000 T 0013 +PRT(271) = NSTACK + NDISPLAY; % VALUE USED FOR TRACING DISPLAYS 01002000 T 0013 +PRT(272) = NDISPLAY + REAL TANK; % ABSOLUTE ADDRESS OF SAVE ARRAY TBUF 01003000 T 0013 +PRT(273) = TANK + SAVE 01004000 T 0013 + ARRAY TBUF[0:16]; % FORMATING AREA FOR TRACE AND MEMDUMP 01005000 T 0013 +PRT(274) = TBUF + ALPHA MULFILID, FILID; % THE SOURCE FILE FOR INITIALIZE 01005100 T 0016 +PRT(275) = MULFILID +PRT(276) = FILID + REAL JUNK; 01007000 T 0016 +PRT(277) = JUNK + INTEGER INTG; 01008000 T 0016 +PRT(300) = INTG + ARRAY MNEMONIC[0:2,0:255]; 01009000 T 0016 +PRT(301) = MNEMONIC + INTEGER TS1; 01010000 T 0019 +PRT(302) = TS1 + SAVE ARRAY DELTAMASK[0:31]; % MASKS OUT DELTA PART OF ADRCPL FIELDS 01011000 T 0019 +PRT(303) = DELTAMASK + SAVE ARRAY REFLECTION[0:31];% REFLECTS LL PARTS OF ADRCPL FIELDS 01012000 T 0021 +PRT(304) = REFLECTION + FILE TRACK 14(1,5); % DATA COM FILE TO READ TRACE PARAMETERS 01013000 T 0024 +PRT(305) = TRACK + DEFINE BITS=(IF SB THEN DS:=SET ELSE DS:=RESET; SKIP 1 SB)#, 01014000 T 0028 + DIG=(DS:=3 RESET; 3 BITS)#, 01015000 T 0028 + PRINT=WRITE(LP,15,TBUF[*])#; 01016000 T 0028 + DEFINE HEADING = IF PRINTERNOTYETOPENED THEN 01017000 T 0028 + IF PRINTERNOTYETOPENED.[46:1] 01017250 T 0028 + THEN HEADINGLINE(TAPED) 01017500 T 0028 + ELSE HEADINGLINE(LP)#; 01017750 T 0028 + REAL INTMASKA, % INTERRUPT MASKS AND REGISTERS FOR MPXA AND MPXB 01018000 T 0028 +PRT(306) = INTMASKA + INTMASKB, % 10 BITS EACH 01019000 T 0028 +PRT(307) = INTMASKB + INTREGA, 01020000 T 0028 +PRT(310) = INTREGA + INTREGB; 01021000 T 0028 +PRT(311) = INTREGB + REAL SCANBUSA, SCANBUSAX,% SCAN AND DATA BUSES FOR MPXS 01022000 T 0028 +PRT(312) = SCANBUSA +PRT(313) = SCANBUSAX + DATABUSA, DATABUSAX;% WITH MOVE EXTENSIONS 01023000 T 0028 +PRT(314) = DATABUSA +PRT(315) = DATABUSAX + REAL ABORTTIME,% THE REAL TIME FOR NEXT ABORT INTERRUPT 01024000 T 0028 +PRT(316) = ABORTTIME + IDLETIME ;% THE REAL TIME FOR NEXT INTERRUPT 01025000 T 0028 +PRT(317) = IDLETIME + REAL REALTIME, COMMENT THE TIME IN 100 NANOSECOND UNITS SINCE THE 01026000 T 0028 +PRT(320) = REALTIME + BEGINNING OF SIMULATION. USED WITH TIMEOFDAY AND 01027000 T 0028 + REALETIME FOR SCAN IN AND OUT OF TIME OF DAY CLOCK.; 01028000 T 0028 + TIMEOFDAY, 01029000 T 0028 +PRT(321) = TIMEOFDAY + REALETIME, 01030000 T 0028 +PRT(322) = REALETIME + DELTATIME;COMMENT THE TIME INCREMENT SINCE THE REAL TIME CLOCK 01031000 T 0028 +PRT(323) = DELTATIME + WAS UPDATED. USUALLY THE TIME REQUIRED FOR AN OPER- 01032000 T 0028 + ATOR.; 01033000 T 0028 + %********************************************** 01200000 T 0028 + %***** B6500 FIELD ABBREVIATION DEFINES ***** 01201000 T 0028 + %********************************************** 01202000 T 0028 + DEFINE % ABBR. B5500 B6500 FIELD/BIT NAME 01203000 T 0028 + TAG = [44: 3]#, % [50: 3] TAG FIELD 01204000 T 0028 + % TAG VALUES... 01205000 T 0028 + SINGL = 0#, % SINGLE PRECISION OPERAND 01206000 T 0028 + IRW = 1#, % INDIRECT REFERENCE WORD 01207000 T 0028 + DOUBL = 2#, % DOUBLE PRECISION OPERAND 01208000 T 0028 + MEMLINK= 3#, % STORAGE LINK 01209000 T 0028 + CODE = 3#, % CODE 01210000 T 0028 + SEGDESC= 3#, % SEGMENT DESCRIPTOR 01211000 T 0028 + MSCW = 3#, % MARK STACK CONTROL WORD 01212000 T 0028 + TOS = 3#, % TOP OF STACK CONTROL WORD 01213000 T 0028 + RCW = 3#, % RETURN CONTROL WORD 01214000 T 0028 + SIW = 4#, % STEP INDEX WORD 01214100 T 0028 + DATADESC=5#, % DATA DESCRIPTOR 01215000 T 0028 + UNITAL = 6#, % UNINITIALIZED OPERAND 01216000 T 0028 + PCW = 7#, % PROGRAM CONTROL WORD (PGM DESC) 01217000 T 0028 + % END TAG VALUES 01218000 T 0028 + ROBIT = [46:1]#, % [48:1] READ ONLY FIELD 01219000 T 0028 + LOBIT = [47:1]#, % [0:1] LOW ORDER BIT 01220000 T 0028 + PBIT = [47: 1]#, % [47: 1] PRESENCE BIT (IN DATADESC,SEGDESC 01221000 T 0028 + DSBIT = [47: 1]#, % [47: 1] DIFFERENT STACK BIT (IN MSCW) 01222000 T 0028 + SGNFF = [47:1]#, % [47:1] SGNF FIELD IN TOS CONTROL WORD 01223000 T 0028 + EXPEXT = [ 1: 8]#, % [47: 9] EXPONENT EXTENTION (DBL PREC) 01223100 T 0028 + INCRF = [ 1:11]#, % [47:12] INCREMENT FIELD (IN STEP INDEX) 01223500 T 0028 + CBIT = [ 1: 1]#, % [46: 1] COPY BIT (IN DATADESC,SEGDESC) 01224000 T 0028 + EBIT = [ 1: 1]#, % [46: 1] ENVIRONMENT BIT (IN IRW,MSCW) 01225000 T 0028 + SOBIT = [ 1: 1]#, % [46:1] SIGN OF OPERAND BIT 01226000 T 0028 + OFFFF = [1:1]#, % [46:1] OFFF FIELD IN TOS CONTROL WORD 01227000 T 0028 + IBIT = [ 2: 1]#, % [45: 1] INDEXED BIT 01228000 T 0028 + SEBIT = [ 2: 1]#, % [45: 1] SIGN OF EXPONENT BIT 01229000 T 0028 + TFFFF = [2:1]#, % [45:1] TFFF FIELD IN TOS CONTROL WORD 01230000 T 0028 + STKNR = [ 2:10]#, % [45:10] STACK NR FIELD (IN IRW,MSCW) 01231000 T 0028 + SBIT = [ 3: 1]#, % [44: 1] SEGMENTED BIT (DATADESC) 01232000 T 0028 + FLTFF = [ 3: 1]#, % [44: 1] FLOAT FLIP/FLOP 01232500 T 0028 + EXPF = [ 3: 6]#, % [44: 6] EXPONENT FIELD 01233000 T 0028 + SEXPF = [2:7]#, % [45:7] SIGNED EXPONENT FIELD 01234000 T 0028 + RBIT = [ 4: 1]#, % [43: 1] READ-ONLY-DATA BIT 01235000 T 0028 + SZ = [ 5: 3]#, % [42:3] CHARACTER SIZE FIELD 01236000 T 0028 + CHRSZ = [ 5: 2]#, % [42:2] CHARACTER SIZE IN DATA DESC. 01237000 T 0028 + CHARF = [ 8: 4]#, % [39: 4] CHARACTER NUMBER FIELD 01238000 T 0028 + DBIT = [ 7: 1]#, % [40: 1] DOUBLE PRECISION BIT (IN DATADESC 01239000 T 0028 + SIBF = [ 7: 6]#, % [40: 6] SIB FOR STRING DESCRIPTORS 01240000 T 0028 + INDEX = [ 8:20]#, % [39:20] INDEX/LENGTH FIELD 01241000 T 0028 + LENGTH = [ 8:20]#, % [39:20] INDEX/LENGTH FIELD 01242000 T 0028 + DS = [8:20]#, % [39:20] DISPLACEMENT FIELD IN TOS CW 01243000 T 0028 + PSRF = [12: 3]#, % [35: 3] PSR FIELD (IN PCW, RCW) 01244000 T 0028 + MANF = [ 9:39]#, % [38:39] MANTISSA FIELD 01245000 T 0028 + PIRF = [15:13]#, % [32:13] PIR FIELD (IN PCW, RCW) 01246000 T 0028 + DISP = [12:16]#, % [35:16] BASE-OF-STACK-RELATIVE DISPLACMNT 01247000 T 0028 + SIRF = [12:16]#, % [35:16] INDEX FIELD FOR STRING DESCRIPTORS 01248000 T 0028 + FVF = [12:16]#, % [35:16] FINAL VALUE FIELD (IN SIW) 01248500 T 0028 + VBIT = [28: 1]#, % [19: 1] ACC. ENTRY ON VALC OR EVAL 01249000 T 0028 + NBIT = [28: 1]#, % [19: 1] NORMAL/CONTROL STATE BIT 01250000 T 0028 + NCSFF = [28:1]#, % [19:1] NCSF FIELD IN TOS CONTROL WORD 01251000 T 0028 + ADDR = [28:20]#, % [19:20] MEMORY ADDRESS/DISK ADDRESS FIELD 01252000 T 0028 + LLF = [29: 5]#, % [18: 5] LL FIELD 01253000 T 0028 + CVF = [32:16]#, % [15:16] CURRENT VALUE FIELD (IN SIW) 01253500 T 0028 + ADRCPL = [34:14]#, % [13:14] ADDRESS COUPLE FIELD (11,DELTA) 01254000 T 0028 + ADRCPLSIR = [35:13]#, % [12:13] ADDRESS COUPLE STUFFED IRW(DEL) 01255000 T 0028 + DF = [34:14]#, % [13:14] SELF-RELATIVE INDEX 01256000 T 0028 + % TO PREVIOUS MSCW (LODELTAF) 01257000 T 0028 + LEVELPCW = [34:1]#,%[13:1] ONE BIT LEVEL ADDRESS PCW 01258000 T 0028 + DELTAPCW = [35:13]#,%[12:13] DELTA ADDRESS PCW 01259000 T 0028 + SDIF = [34:14]#; % [13:14] SEGMENT DICTIONARY INDEX FIELD 01260000 T 0028 + DEFINE 01261000 T 0028 + SBRF = ADDR#, 01262000 T 0028 + DBRF = ADDR#, 01263000 T 0028 + DIRF = SIRF#, TIRF = SIRF#, 01264000 T 0028 + DIBF = SIBF#, 01265000 T 0028 + DSZF = SZ #; 01266000 T 0028 + DEFINE % FUNCTION CODE DEFINES 6.33 01267000 T 0028 + MPXAB = [47: 1]#, % [ 0: 1] RESPONDING MULTIPLEXOR(S) 01268000 T 0028 + MPXFC = [43: 4]#, % [ 4: 4] MPX DESIGNATOR 01269000 T 0028 + VARIF = [39: 4]#, % [ 8: 4] SCAN VARIANT 01270000 T 0028 + GCARF = [37: 2]#, % [10: 2] GCA REGISTER 01271000 T 0028 + REGIV = [39: 1]#, % [ 9: 1] READ REGISTER VARIANT 01272000 T 0028 + VECTF = [36: 2]#, % [11: 2] VECTOR NUMBER 01273000 T 0028 + LUNIT = [31: 8]#; % [16: 8] LOGICAL UNIT NUMBER 01274000 T 0028 + DEFINE % RESULT ERROR DEFINES 01275000 T 0028 + RSLTPRO= [31: 1]#, % [16: 1] PROTECT TERMINATE ON MEMORY WRITE 01276000 T 0028 + RSLTEXC= [47: 1]#, % [ 0: 1] EXCEPTION 01277000 T 0028 + RSLTATT= [46: 1]#, % [ 1: 1] ATTENTION 01278000 T 0028 + RSLTBSY= [45: 1]#, % [ 2: 1] BUSY 01279000 T 0028 + RSLTNRY= [44: 1]#, % [ 3: 1] NOT READY 01280000 T 0028 + RSLTDSC= [43: 1]#, % [ 4: 1] DESCRIPTOR ERROR 01281000 T 0028 + RSLTMAD= [42: 1]#, % [ 5: 1] MEMORY ADDRESS 01282000 T 0028 + RSLTPAR= [41: 1]#; % [ 6: 1] MEMORY PARITY 01283000 T 0028 + DEFINE % RESULT DESCRIPTOR UNIT ERRORS 01284000 T 0028 + RSLTTO = [32: 1]#, % [15: 1] BLANK TAPE 01285000 T 0028 + RSLTRW = [33: 1]#, % [14: 1] REWINDING 01286000 T 0028 + RSLTOP = [34: 1]#, % [13: 1] NON-PRESENT 01287000 T 0028 + RSLTCR = [35: 1]#, % [12: 1] CRC CORRECTION 01288000 T 0028 + RSLTOF = [36: 1]#, % [11: 1] OVERFLOW 01289000 T 0028 + RSLTCC = [37: 1]#, % [10: 1] CONTROL CARD 01290000 T 0028 + RSLTVY = [38: 1]#, % [ 9: 1] VALIDITY 01291000 T 0028 + RSLTET = [39: 1]#, % [ 8: 1] END OF TAPE 01292000 T 0028 + RSLTMA = [40: 1]#, % [ 7: 1] MEMORY ACCESS 01293000 T 0028 + RSLTUF = RSLTCC#,% UNDERFLOW 01294000 T 0028 + RSLTWL = RSLTVY#;% WRITE LOCK-OUT 01295000 T 0028 + DEFINE % I/O CONTROL WORD DEFINES 01296000 T 0028 + IOABIT = [ 2: 1]#, % [45: 1] ATTENTION 01297000 T 0028 + IOWBIT = [ 3: 1]#, % [44: 1] MEMORY WRITE 01298000 T 0028 + IOIBIT = [ 4: 1]#, % [43: 1] MEMORY INHIBIT 01299000 T 0028 + IOXBIT = [ 5: 1]#, % [42: 1] TRANSLATE 01300000 T 0028 + IOSBIT = [ 6: 1]#, % [41: 1] FRAME LENGTH (0 = 6 BIT;1= 8 BIT) 01301000 T 0028 + IOPBIT = [ 7: 1]#, % [40: 1] MEMORY PROTECT 01302000 T 0028 + IOBBIT = [ 8: 1]#, % [39: 1] BACKWARD TRANSFER 01303000 T 0028 + IOTBIT = [ 9: 1]#, % [38: 1] 01304000 T 0028 + IOTAGS = [10: 2]#, % [37: 1] & [36:1] TAG TRANSFER 01305000 T 0028 + IOSKIP = [12: 4]#, % [35: 4] PRINTER SKIP 01306000 T 0028 + IOSPAC = [16: 2]#; % [31: 2] PRINTER SPACE 01307000 T 0028 + DEFINE RECS = [24:10]#; % [23:10] TAPE SPACE 01308000 T 0028 + SAVE ARRAY MESS [0:BUFRMAX-1];%UTILITY INPUT-OUTPUT AREA 01309000 T 0028 +PRT(324) = MESS + COMMENT BUFFERS IS INDEXED BY SWITCH FILE INDEX AND HARDWARE TYPE; 01310000 T 0032 + FILE DISKA DISK RANDOM [20:1000] (1, BUFFERS [0, 1],SAVE 99), 01311000 T 0032 +PRT(325) = DISKA +PRT(326) = FILE ATTRBUTS + DISKB DISK RANDOM [20:1000] (1, BUFFERS [1, 1],SAVE 99), 01312000 T 0040 +PRT(327) = DISKB + DISKC DISK RANDOM [20:1000] (1, BUFFERS [2, 1],SAVE 99), 01313000 T 0048 +PRT(330) = DISKC + DISKD DISK RANDOM [20:1000] (1, BUFFERS [3, 1],SAVE 99), 01314000 T 0056 +PRT(331) = DISKD + SPO 14 (1, BUFFERS [0, 2]), 01315000 T 0064 +PRT(332) = SPO + AIDS 14 (1, BUFFERS [0, 3]), 01316000 T 0069 +PRT(333) = AIDS + LP 4 (1, BUFFERS [0, 6]), 01317000 T 0074 +PRT(334) = LP + SIMLP 14 (1, BUFFERS [1, 6]), 01318000 T 0080 +PRT(335) = SIMLP + CARD (1, BUFFERS [0, 9]), 01319000 T 0085 +PRT(336) = CARD + PUNCH 0 (1, BUFFERS [0,10]), 01320000 T 0090 +PRT(337) = PUNCH + TAPEA 2 (1, BUFFERS [0,13], SAVE 1), 01321000 T 0095 +PRT(340) = TAPEA + TAPEB 2 (1, BUFFERS [1,13], SAVE 1), 01322000 T 0103 +PRT(341) = TAPEB + TAPEC 2 (1, BUFFERS [2,13], SAVE 1), 01323000 T 0111 +PRT(342) = TAPEC + TAPED 2 (1, BUFFERS [3,13], SAVE 1); 01324000 T 0119 +PRT(343) = TAPED + SWITCH FILE TAPES ← TAPEA, TAPEB, TAPEC, TAPED; 01325000 T 0127 +PRT(344) = TAPES + SWITCH FILE DISKS ← DISKA, DISKB, DISKC, DISKD; 01326000 T 0135 +PRT(345) = DISKS + SWITCH FILE LINES ← LP, SIMLP; 01327000 T 0142 +PRT(346) = LINES + COMMENT 01328000 T 0147 + ******************************* 01329000 T 0147 + ***** B6500 WORD FORMAT ***** 01330000 T 0147 + ******************************* 01331000 T 0147 + SEGMENT DESCRIPTOR 01332000 T 0147 + 5 5 4 4 4 4 4 4 4 4 3 2 1 01333000 T 0147 + 1 0 8 7 6 5 4 3 2 0 9 0 9 0 01334000 T 0147 + -------------------------------------------------------------- 01335000 T 0147 + :X:011:P:C: UNUSED : LENGTH : ADDR : 01336000 T 0147 + -------------------------------------------------------------- 01337000 T 0147 + INDIRECT REFERENCE WORD (NORMAL) 01338000 T 0147 + 5 5 4 4 4 4 1 1 01339000 T 0147 + 1 0 8 7 6 5 4 3 0 01340000 T 0147 + -------------------------------------------------------------- 01341000 T 0147 + :X:001:U:0: . . . . . .UNUSED. . . . . . . . :ADDRESSCOUPLE : 01342000 T 0147 + -------------------------------------------------------------- 01343000 T 0147 + INDIRECT REFERENCE WORD (STUFFED) 01343100 T 0147 + 5 5 4 4 4 4 3 3 2 1 1 1 . 01343200 T 0147 + 1 0 8 7 6 5 6 5 0 9 3 2 0 01343300 T 0147 + -------------------------------------------------------------- 01343400 T 0147 + :X:001:U:1: STKNR : DISP :UNUSED :INDEX FIELD : 01343500 T 0147 + -------------------------------------------------------------- 01343600 T 0147 + MARK STACK CONTROL WORD 01344000 T 0147 + 5 5 4 4 4 4 3 3 2 1 1 1 1 01345000 T 0147 + 1 0 8 7 6 5 6 5 0 9 8 4 3 0 01346000 T 0147 + -------------------------------------------------------------- 01347000 T 0147 + :X:011:DS:E: STKNR : DISP :V:LLF: DF : 01348000 T 0147 + -------------------------------------------------------------- 01349000 T 0147 + PROGRAM CONTROL WORD 01350000 T 0147 + 5 5 4 4 4 4 3 3 3 3 2 1 1 1 1 01351000 T 0147 + 1 0 8 7 6 5 6 5 3 2 0 9 8 4 3 0 01352000 T 0147 + -------------------------------------------------------------- 01353000 T 0147 + :X:111:UU : STKNR : PSRF : PIRF :N:LLF: SDIF : 01354000 T 0147 + -------------------------------------------------------------- 01355000 T 0147 + RETURN CONTROL WORD 01356000 T 0147 + 5 5 4 4 4 4 4 4 3 3 3 3 2 1 1 1 1 01357000 T 0147 + 1 0 8 7 6 5 4 3 6 5 3 2 0 9 8 4 3 0 01358000 T 0147 + -------------------------------------------------------------- 01359000 T 0147 + :X:011:X:O:T:F: UNUSED : PSRF : PIRF :N:LLF: SDIF : 01360000 T 0147 + -------------------------------------------------------------- 01361000 T 0147 + SINGLE PRECISION OPERAND 01362000 T 0147 + 5 5 4 4 4 4 4 3 3 01363000 T 0147 + 1 0 8 7 6 5 4 9 8 01364000 T 0147 + -------------------------------------------------------------- 01365000 T 0147 + :X:000:U:SO:SE: EXPF : MANF : 01366000 T 0147 + -------------------------------------------------------------- 01367000 T 0147 + DOUBLE PRECISION OPERAND 01368000 T 0147 + 5 5 4 4 4 4 4 3 3 (FIRST HALF) 01369000 T 0147 + 1 0 8 7 6 5 4 9 8 0 01370000 T 0147 + -------------------------------------------------------------- 01371000 T 0147 + :X:010:U:SO:SE: EXPX : MANF : 01372000 T 0147 + -------------------------------------------------------------- 01373000 T 0147 + 5 5 4 4 3 3 (SECOND HALF) 01374000 T 0147 + 1 0 8 7 9 8 0 01375000 T 0147 + -------------------------------------------------------------- 01376000 T 0147 + :X:010: EXPD EXT. : MANF : 01377000 T 0147 + -------------------------------------------------------------- 01378000 T 0147 + WORD DATA DESCRIPTOR 01379000 T 0147 + 5 5 4 4 4 4 4 4 44 4 3 2 1 01380000 T 0147 + 1 0 8 7 6 5 4 3 21 0 9 0 9 0 01381000 T 0147 + -------------------------------------------------------------- 01382000 T 0147 + :X:101:P:C:I:S:R:SZ:D: LENGTH/INDEX : ADDR : 01383000 T 0147 + -------------------------------------------------------------- 01384000 T 0147 + STRING DESCRIPTOR (NON-INDEXED) 01385000 T 0147 + 5 5 4 4 4 4 4 4 44 4 3 2 1 01386000 T 0147 + 1 0 8 7 6 5 4 3 21 0 9 0 9 0 01387000 T 0147 + -------------------------------------------------------------- 01388000 T 0147 + :X:101:P:C:O:S:R: SZ : LENGTH IN CHR : ADDR : 01389000 T 0147 + -------------------------------------------------------------- 01390000 T 0147 + STRING DESCRIPTOR (INDEXED) 01391000 T 0147 + 5 5 4 4 4 4 4 4 44 4 3 3 2 1 01392000 T 0147 + 1 0 8 7 6 5 4 3 21 0 5 4 0 9 0 01393000 T 0147 + -------------------------------------------------------------- 01394000 T 0147 + :X:101:P:C:1:S:R: SZ :BYTE INX:WORD INDEX: ADDR : 01395000 T 0147 + -------------------------------------------------------------- 01396000 T 0147 + STEP INDEX WORD 01397000 T 0147 + 5 5 4 4 3 3 2 1 1 1 01398000 T 0147 + 1 0 8 7 6 5 0 9 6 5 0 01399000 T 0147 + -------------------------------------------------------------- 01400000 T 0147 + :X:100: INCREMENT : FINAL VALUE : U :CURRENT VALUE : 01401000 T 0147 + -------------------------------------------------------------- 01402000 T 0147 + ; 01403000 T 0147 + %******************************************** 01600000 T 0147 + %***** FORWARD PROCEDURE DECLARATIONS ***** 01601000 T 0147 + %******************************************** 01602000 T 0147 + %%%%% BEGIN OPERATOR FORWARDS %%%%%%%%%% 01603000 T 0147 + DEFINE V = PROCEDURE#, W = ; FORWARD;#; 01604000 T 0147 + 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 T 0147 +PRT(347) = MKST +PRT(350) = IMKS +PRT(351) = NAMC +PRT(352) = VALC +PRT(353) = EVAL +PRT(354) = ENTR +PRT(355) = EXIT +PRT(356) = RETN + 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 T 0150 +PRT(357) = IRWL +PRT(360) = PCWL +PRT(361) = BRUN +PRT(362) = BRTR +PRT(363) = BRFL +PRT(364) = DBUN +PRT(365) = DBTR +PRT(366) = DBFL + 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 T 0150 +PRT(367) = NOOP +PRT(370) = HALT +PRT(371) = NVLD +PRT(372) = VARI +PRT(373) = ADD +PRT(374) = SUBT +PRT(375) = MULT +PRT(376) = MULX + 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 T 0150 +PRT(377) = DIVD +PRT(400) = IDIV +PRT(401) = RDIV +PRT(402) = NTIA +PRT(403) = NTGR +PRT(404) = SNGT +PRT(405) = SNGL +PRT(406) = XTND + 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 T 0150 +PRT(407) = JOIN +PRT(410) = SPLT +PRT(411) = LAND +PRT(412) = LOR +PRT(413) = LNOT +PRT(414) = SAME +PRT(415) = LEQV +PRT(416) = GRTR + 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 T 0150 +PRT(417) = GREQ +PRT(420) = EQUL +PRT(421) = LSEQ +PRT(422) = LESS +PRT(423) = NEQL +PRT(424) = INDX +PRT(425) = STBR +PRT(426) = NXLN + 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 T 0150 +PRT(427) = NXLV +PRT(430) = LOAD +PRT(431) = LODT +PRT(432) = EXCH +PRT(433) = RSDN +PRT(434) = RSUP +PRT(435) = DUPL +PRT(436) = DLET + 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 T 0150 +PRT(437) = MVST +PRT(440) = PUSH +PRT(441) = STOD +PRT(442) = STON +PRT(443) = OVRD +PRT(444) = OVRN +PRT(445) = FLTR +PRT(446) = DFTR + 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 T 0150 +PRT(447) = ISOL +PRT(450) = DISO +PRT(451) = INSR +PRT(452) = DINS +PRT(453) = SRCH +PRT(454) = LLLU +PRT(455) = ZERO +PRT(456) = ONE + 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 T 0150 +PRT(457) = LT8 +PRT(460) = LT16 +PRT(461) = LT48 +PRT(462) = MPCW +PRT(463) = BSET +PRT(464) = DBST +PRT(465) = BRST +PRT(466) = DBRS + 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 T 0150 +PRT(467) = CHSN +PRT(470) = CBON +PRT(471) = LOG2 +PRT(472) = STAG +PRT(473) = RTAG +PRT(474) = SINT +PRT(475) = RDLK +PRT(476) = STFF + 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 T 0150 +PRT(477) = WHOI +PRT(500) = EEXI +PRT(501) = DEXI +PRT(502) = IDLE +PRT(503) = HEYU +PRT(504) = RPRR +PRT(505) = SPRR +PRT(506) = SCNI + 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 T 0150 +PRT(507) = SCNO +PRT(510) = TWSD +PRT(511) = TWSU +PRT(512) = TWOD +PRT(513) = TWOU +PRT(514) = TGTD +PRT(515) = TGTU +PRT(516) = TGED + 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 T 0150 +PRT(517) = TGEU +PRT(520) = TEQD +PRT(521) = TEQU +PRT(522) = TLED +PRT(523) = TLEU +PRT(524) = TLSD +PRT(525) = TLSU +PRT(526) = TNED + 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 T 0150 +PRT(527) = TNEU +PRT(530) = TWTD +PRT(531) = TWTU +PRT(532) = TWFD +PRT(533) = TWFU +PRT(534) = TUND +PRT(535) = TUNU +PRT(536) = SGTD + 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 T 0150 +PRT(537) = SGTU +PRT(540) = SGED +PRT(541) = SGEU +PRT(542) = SEQD +PRT(543) = SEQU +PRT(544) = SLED +PRT(545) = SLEU +PRT(546) = SLSD + 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 T 0150 +PRT(547) = SLSU +PRT(550) = SNED +PRT(551) = SNEU +PRT(552) = SWTD +PRT(553) = SWTU +PRT(554) = SWFD +PRT(555) = SWFU +PRT(556) = CGTD + 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 T 0150 +PRT(557) = CGTU +PRT(560) = CGED +PRT(561) = CGEU +PRT(562) = CEQD +PRT(563) = CEQU +PRT(564) = CLED +PRT(565) = CLEU +PRT(566) = CLSD + 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 T 0150 +PRT(567) = CLSU +PRT(570) = CNED +PRT(571) = CNEU +PRT(572) = UABD +PRT(573) = UABU +PRT(574) = USND +PRT(575) = USNU +PRT(576) = PACD + 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 T 0150 +PRT(577) = PACU +PRT(600) = TRNS +PRT(601) = SCLF +PRT(602) = DSLF +PRT(603) = SCRS +PRT(604) = DSRS +PRT(605) = SCRT +PRT(606) = DSRT + 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 T 0150 +PRT(607) = SCRR +PRT(610) = DSRR +PRT(611) = SCRF +PRT(612) = DSRF +PRT(613) = OCRX +PRT(614) = SISO +PRT(615) = SXSN +PRT(616) = RTFF + 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 T 0150 +PRT(617) = ROFF +PRT(620) = ICVD +PRT(621) = ICVU +PRT(622) = TEED +PRT(623) = TEEU +PRT(624) = EXSD +PRT(625) = EXSU +PRT(626) = EXPU + 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 T 0150 +PRT(627) = MCHR +PRT(630) = MVNU +PRT(631) = SFSC +PRT(632) = SRSC +PRT(633) = SFDC +PRT(634) = SRDC +PRT(635) = INSU +PRT(636) = INSC + V INSG W V INOP W V RSTF W V ENDF W V MINS W V MFLT W V ENDE W 01628000 T 0150 +PRT(637) = INSG +PRT(640) = INOP +PRT(641) = RSTF +PRT(642) = ENDF +PRT(643) = MINS +PRT(644) = MFLT +PRT(645) = ENDE + %%%%% END OPERATOR FORWARDS %%%%%%%%%% 01629000 T 0150 + DEFINE CHECOP=( (AX.TAG=SINGL OR AX.TAG=DOUBL ) 01700000 T 0150 + AND(BX.TAG=SINGL OR BX.TAG=DOUBL))#, 01701000 T 0150 + CHECOPRNDB=IF NOT (BX.TAG=SINGL OR BX.TAG=DOUBL) 01702000 T 0150 + THEN BEGIN SETINTERRUPT (INVOP)#, 01703000 T 0150 + CHECOPRNDA=IF NOT (AX.TAG=SINGL OR AX.TAG=DOUBL) 01704000 T 0150 + THEN BEGIN SETINTERRUPT(INVOP)#; 01705000 T 0150 + DEFINE PRESENCEBITINTERRUPT= 01706000 T 0150 + BEGIN SETINTERRUPT(PRESBIT); GO TO OC END#, 01707000 T 0150 + INVALIDINDEXINTERRUPT= 01708000 T 0150 + BEGIN SETINTERRUPT(INVINXI); GO TO OC END#, 01709000 T 0150 + INVALIDOPERATORINTERRUPT= 01710000 T 0150 + BEGIN SETINTERRUPT(INVOP); GO TO OC END#; 01711000 T 0150 + PROCEDURE ADJ(NEWAROF,NEWBROF); VALUE NEWAROF,NEWBROF; 01712000 T 0150 +PRT(646) = ADJ + INTEGER NEWAROF,NEWBROF; FORWARD; 01713000 T 0150 + STREAM PROCEDURE MOVE(SOURCE,DESTINATION); 01714000 T 0150 +PRT(647) = MOVE + BEGIN SI←SOURCE; DI←DESTINATION; DS←2 WDS; END MOVE; 01715000 T 0150 + PROCEDURE ERROR(ERRNUM); VALUE ERRNUM; REAL ERRNUM; FORWARD; 01716000 T 0151 +PRT(650) = ERROR + BOOLEAN PROCEDURE EQUAL (A,AX,B,BX); VALUE A,AX,B,BX; REAL A,AX,B,BX; 01717000 T 0151 +PRT(651) = EQUAL + EQUAL ← (AX.[44:4] = BX.[44:4]) AND 01718000 T 0151 + (REAL(BOOLEAN(A) EQV BOOLEAN (B)) = REAL (NOT FALSE)); 01719000 T 0152 + STREAM PROCEDURE DYALS (P, A, N, N1, TURN); VALUE N, N1, TURN; 01720000 T 0157 +PRT(652) = DYALS + BEGIN 01721000 T 0157 + DI ← P; SI ← P; SI ← SI + 15; 01722000 T 0158 + SKIP 5 SB; IF SB THEN DS ← SET ELSE DS ← RESET; 01723000 T 0158 + SI ← A; SI ← SI + 15; SKIP 5 SB; 01724000 T 0160 + DI ← A; IF SB THEN DS ← SET ELSE DS ← RESET; 01725000 T 0161 + SI ← P; DI ← A; SKIP N SB; SKIP N1 DB; TURN BITS; 01726000 T 0162 + DI ← A; DI ← DI + 15; SKIP 5 DB; 01727000 T 0166 + SI ← A; IF SB THEN DS ← SET ELSE DS ← RESET; 01728000 T 0167 + DI ← P; DS ← RESET; 01729000 T 0169 + DI ← A; DS ← RESET; 01730000 T 0169 + END OF DYAL; 01731000 T 0170 + PROCEDURE DYAL (P, A, N, N1, TURN); VALUE N, N1, TURN; 01732000 T 0170 +PRT(653) = DYAL + REAL P, A; 01733000 T 0170 + INTEGER N, N1, TURN; 01734000 T 0170 + BEGIN 01735000 T 0170 + INTEGER NN, NN1; 01736000 T 0170 + START OF SEGMENT ********** 14 +STACK(F+2) = NN +STACK(F+3) = NN1 + NN ← 47-N; 01737000 T 0000 + NN1 ← 47-N1; 01738000 T 0001 + DYALS (P, A, NN, NN1, TURN); 01739000 T 0002 + END; 01740000 T 0004 + 14 IS 7 LONG, NEXT SEG 12 + DEFINE SYLLABLE = (IF PROF THEN SYLLABLES[PSR] ELSE PSYLLABLES)#; 01741000 T 0170 + INTEGER ARRAY SYLLABLES[0:5]; 01742000 T 0170 +PRT(654) = SYLLABLES + INTEGER PROCEDURE PSYLLABLES; FORWARD; % RETURNS P[PSR] 01743000 T 0173 +PRT(655) = PSYLLABLES + PROCEDURE STEPPSR(N); VALUE N; INTEGER N; FORWARD; % STEPS PSR+PIR,PROF 01744000 T 0173 +PRT(656) = STEPPSR + PROCEDURE TRACE; FORWARD; 01745000 T 0173 +PRT(657) = TRACE + PROCEDURE MEMDUMP; FORWARD; 01746000 T 0173 +PRT(660) = MEMDUMP + PROCEDURE SETINTERRUPT(I); VALUE I; INTEGER I; FORWARD; 01747000 T 0173 +PRT(661) = SETINTERRUPT + INTEGER PROCEDURE LEVEL(WORD); VALUE WORD; REAL WORD; FORWARD; 01748000 T 0173 +PRT(662) = LEVEL + INTEGER PROCEDURE DELTA(WORD); VALUE WORD; REAL WORD; FORWARD; 01749000 T 0173 +PRT(663) = DELTA + PROCEDURE ERVSFLOW(OP); VALUE OP; INTEGER OP; FORWARD; 01750000 T 0173 +PRT(664) = ERVSFLOW + BOOLEAN PROCEDURE INTEGERIZE(ROUND,REG);VALUE ROUND; 01751000 T 0173 +PRT(665) = INTEGERIZE + BOOLEAN ROUND; REAL REG; FORWARD; 01752000 T 0173 + REAL PROCEDURE GETRESULT (MPXAB); VALUE MPXAB; REAL MPXAB; FORWARD; 01753000 T 0173 +PRT(666) = GETRESULT + PROCEDURE STORE(OP); VALUE OP; REAL OP; FORWARD; 01754000 T 0173 +PRT(667) = STORE + PROCEDURE WRITETIME; FORWARD; % WRITES OUT TIME SINCE INITIALIZATION 01755000 T 0173 +PRT(670) = WRITETIME + PROCEDURE HEADINGLINE (LP); FILE LP; FORWARD; 01756000 T 0173 +PRT(671) = HEADINGLINE + PROCEDURE INTFAMD(TYPE); VALUE TYPE; REAL TYPE; 01757000 T 0173 +PRT(672) = INTFAMD + BEGIN 01757100 T 0173 + LABEL INVALIDOP1 , INVALIDOP2 , INVALIDOP3 , INVALIDOP4 , 01757200 T 0173 + START OF SEGMENT ********** 15 + INVALIDOP5 , MEMPROT , 01757300 T 0000 + INVINDX2 , PRESBIT1 , PRESBIT2 01757400 T 0000 + ,OC , LO , BACKUP , L2 01757500 T 0000 + ; 01757600 T 0000 + SWITCH INTERRUPT ← 01757700 T 0000 + INVALIDOP1 , INVALIDOP2 , INVALIDOP3 , INVALIDOP4 , 01757701 T 0002 + INVALIDOP5 , MEMPROT , 01757702 T 0002 + INVINDX2 , PRESBIT1 , PRESBIT2 01757703 T 0002 + ; 01757704 T 0002 + GO TO INTERRUPT[TYPE]; 01757800 T 0007 + INVALIDOP1: ADJ(0,0); GO LO; 01757900 T 0010 + INVALIDOP2: ADJ(0,0); MOVE(C,A); GO LO; 01758000 T 0011 + INVALIDOP3: MOVE(B,A); GO LO; 01758100 T 0014 + INVALIDOP4: AROF ← TRUE; MOVE(B,A); ADJ(1,0); GO LO; 01758200 T 0016 + INVALIDOP5: ADJ(0,0); MOVE(B,A); 01758300 T 0020 + LO: BX ← 0; 01758400 T 0023 + AROF ← BROF ← TRUE; SDIS ← 1; 01758500 T 0023 + B ← INVOP ; 01758600 T 0026 + BACKUP: 01758700 T 0027 + PIR ← PIR - PICR; PSR ← OPSR; GO OC; 01758800 T 0028 + MEMPROT: 01758900 T 0032 + ADJ(0,0); 01759000 T 0032 + MOVE(C,A); 01759100 T 0033 + BX ← 0; 01759200 T 0034 + AROF←BROF←TRUE; SDIS ← 1; 01759300 T 0034 + B ← MEMPROI; 01759400 T 0037 + GO BACKUP; 01759500 T 0038 + INVINDX2: 01759600 T 0040 + ADJ(0,0); 01759700 T 0040 + BX ← A ← AX ← 0; 01759800 T 0041 + AROF←BROF←TRUE; SDIS ← 1; 01759900 T 0042 + B ← INVINXI; 01760000 T 0045 + GO BACKUP; 01760100 T 0046 + PRESBIT1: 01760200 T 0048 + AROF←FALSE; 01760250 T 0048 + ADJ(0,0); 01760300 T 0048 + MOVE(C,A); 01760500 T 0049 + GO L2; 01760600 T 0050 + PRESBIT2: 01760700 T 0051 + MOVE(X,A); 01760800 T 0052 + AROF ← TRUE; 01760900 T 0053 + ADJ(0,0); 01761000 T 0053 + MOVE(C,A); 01761200 T 0054 + AROF ← TRUE; 01761300 T 0055 + ADJ(0,0); 01761400 T 0056 + L2: 01761500 T 0057 + BX ← 0; 01761600 T 0058 + AROF←BROF←TRUE; SDIS ← 1; 01761700 T 0058 + B ← PRESBIT; 01761800 T 0061 + B.SOBIT ← 1; 01761900 T 0062 + GO BACKUP; 01762000 T 0064 + OC: 01762100 T 0066 + END; 01762200 T 0066 + 15 IS 67 LONG, NEXT SEG 12 + 01762300 T 0173 + PROCEDURE INTFAMA(TYPE); VALUE TYPE; REAL TYPE; 01765000 T 0173 +PRT(673) = INTFAMA + BEGIN 01765100 T 0173 + DEFINE CLEARAB = A←AX←B←BX ← 0#; 01765200 T 0173 + START OF SEGMENT ********** 16 + IF TYPE < 0 THEN 01765300 T 0000 + BEGIN 01765400 T 0000 + ADJ(0,0); 01765500 T 0001 + CLEARAB; 01765600 T 0002 + B ← INVOP; 01765700 T 0004 + 01765800 T 0005 + END ELSE 01765900 T 0005 + BEGIN 01766000 T 0005 + CLEARAB; 01766100 T 0007 + B ← ABS(TYPE); 01766200 T 0009 + END; 01766300 T 0010 + AROF ← BROF ← TRUE; 01766400 T 0010 + SDIS ← 1; 01766500 T 0011 + PIR ← PIR - PICR; PSR ← OPSR; 01766600 T 0013 + END INTFAMD; 01766700 T 0015 + 16 IS 16 LONG, NEXT SEG 12 + PROCEDURE INTFAMB(TYPE); VALUE TYPE; REAL TYPE; 01767000 T 0173 +PRT(674) = INTFAMB + BEGIN 01767100 T 0173 + 01767200 T 0173 + IF TYPE=2 THEN 01767300 T 0173 + BEGIN 01767400 T 0174 + ADJ(0,0); MOVE(C,A); 01767500 T 0175 + END ELSE 01767600 T 0177 + MOVE(B,A); 01767700 T 0177 + B ← BX ← 0; 01767800 T 0178 + SDIS ← 1; 01767900 T 0180 + BROF ← AROF ← TRUE; 01768000 T 0181 + B ← INVOP; 01768100 T 0183 + PIR ← PIR - PICR; PSR ← OPSR; 01768200 T 0183 + END INFAMB; 01768300 T 0185 + PROCEDURE INTERRUPTCONTROLLER; 01800000 T 0187 +PRT(675) = INTERRUPTCONTROLLER + IF BOOLEAN (PTPI) THEN INT ← 0 ELSE % IGNORE PROC TO PROC IN SIM 01800100 T 0187 + BEGIN COMMENT INTERRUPT CONTROLLER IS PRIMARILY CONCERNED WITH 01801000 T 0189 + MAKING THE STACK LOOK LIKE A PROCEDURE IS TO BE 01802000 T 0189 + CALLED AND THEN CALLING IT. MUCH OF THE CURRENT CODE 01803000 T 0189 + IS CONCERNED WITH INFORMING PEOPLE AS TO WHAT IS 01804000 T 0189 + HAPPENING. 01805000 T 0189 + 9/12/67; 01806000 T 0189 + REAL TEMPB, SWFI; 01807000 T 0189 +PRT(676) = *SEGMENT DESCRIPTOR* + START OF SEGMENT ********** 17 +STACK(F+2) = TEMPB +STACK(F+3) = SWFI + DEFINE 01808000 T 0000 + BASSDI = 0#, 01809000 T 0000 + BASEXI = 10#, 01810000 T 0000 + BASGCI = 12#, 01811000 T 0000 + BASALI = 14#; 01812000 T 0000 + SWITCH FORMAT INTS 01813000 T 0000 + START OF SEGMENT ********** 18 +PRT(677) = INTS + ←(10 ("X"), " INTERRUPT ERROR." ,X2,10("X")) 01814000 T 0000 + ,(10 ("X"), " MEMORY PROTECT INTERRUPT." ,X2,10("X")) 01815000 T 0000 + ,(10 ("X"), " INVALID OPERATOR INTERRUPT." ,X2,10("X")) 01816000 T 0000 + ,(10 ("X"), " DIVIDE BY ZERO INTERRUPT." ,X2,10("X")) 01817000 T 0000 + ,(10 ("X"), " EXPONENT OVERFLOW INTERRUPT." ,X2,10("X")) 01818000 T 0000 + ,(10 ("X"), " EXPONENT UNDERFLOW INTERRUPT." ,X2,10("X")) 01819000 T 0000 + ,(10 ("X"), " INVALID INDEX INTERRUPT." ,X2,10("X")) 01820000 T 0000 + ,(10 ("X"), " INTEGER OVERFLOW INTERRUPT." ,X2,10("X")) 01821000 T 0000 + ,(10 ("X"), " BOTTOM OF STACK INTERRUPT." ,X2,10("X")) 01822000 T 0000 + ,(10 ("X"), " PRESENCE BIT INTERRUPT." ,X2,10("X")) 01823000 T 0000 + ,(10 ("X"), " SEQUENCE ERROR INTERRUPT," ,X2,10("X")) 01824000 T 0000 + ,(10 ("X"), " MULTIPLEXOR A INTERRUPT." ,X2,10("X")) 01825000 T 0000 + ,(10 ("X"), " MULTIPLEXOR B INTERRUPT." ,X2,10("X")) 01826000 T 0000 + ,(10 ("X"), " INTERVAL TIMER INTERRURT." ,X2,10("X")) 01827000 T 0000 + ,(10 ("X"), " STACK OVERFLOW INTERRUPT." ,X2,10("X")) 01828000 T 0000 + ,(10 ("X"), " OPERATOR LOOP INTERRUPT." ,X2,10("X")) 01829000 T 0000 + ,(10 ("X"), " MEMORY PARITY INTERRUPT." ,X2,10("X")) 01830000 T 0000 + ,(10 ("X"), " MULTIPLEXOR PARITY INTERRUPT." ,X2,10("X")) 01831000 T 0000 + ,(10 ("X"), " INVALID ADDRESS INTERRUPT." ,X2,10("X")) 01832000 T 0000 + ,(10 ("X"), " STACK UNDERFLOW INTERRUPT." ,X2,10("X")) 01833000 T 0000 + ; 01834000 T 0000 + 18 IS 317 LONG, NEXT SEG 17 + IF SDIS ≠ 0 01835000 T 0000 + THEN BEGIN 01836000 T 0000 + TEMPB ← B; 01837000 T 0001 + ADJ (0, 0); 01838000 T 0002 + AX ← 0; 01839000 T 0003 + AROF ← TRUE; 01840000 T 0004 + A ← 0 & TEMPB [33:33:15]; 01841000 T 0005 + LOG2; 01842000 T 0006 + SWFI ← B; 01843000 T 0006 + BROF ← FALSE; 01844000 T 0007 + ADJ (1, 1); 01845000 T 0008 + MOVE (M[D[0] +3], C); 01846000 T 0009 + IF CX.TAG ≠ PCW 01847000 T 0014 + THEN BEGIN 01848000 T 0015 + WRITE(LP [DBL], INTS [SWFI]); 01849000 T 0015 +PRT(700) = OUTPUT(W) + MEMDUMP; 01850000 T 0019 + GO EOJ; 01851000 T 0020 +PRT(701) = EOJ + END; 01852000 T 0022 + END 01853000 T 0022 + ELSE IF EXIA ≠ 0 01854000 T 0022 + THEN BEGIN 01855000 T 0023 + SWFI ← BASEXI + B - EXTINTI; 01856000 T 0024 + IF SWFI > BASGCI THEN SWFI ← BASEXI + 1; 01856100 T 0026 + END 01857000 T 0029 + ELSE IF GCIF ≠ 0 01858000 T 0029 + THEN BEGIN 01859000 T 0031 + SWFI ← B - INTTIMI + BASGCI + 1; 01860000 T 0032 + INTTIMER ← 2*36 ; 01861000 T 0035 + END 01862000 T 0038 + ELSE IF INT.[43:5] ≠ 0 01863000 T 0038 + %LOOP + MPEI + MPXP + INVA + SUFL ≠0 01864000 T 0041 + THEN BEGIN 01865000 T 0042 + TEMPB ← B; 01866000 T 0042 + ADJ (0, 0); 01866100 T 0043 + A ← B - LOOPI + 1; AX ← 0; 01866200 T 0044 + AROF ← TRUE; 01866300 T 0047 + LOG2; 01866400 T 0047 + SWFI ← B + BASALI; 01866450 T 0048 + BROF ← FALSE; 01866600 T 0049 + ADJ (1, 1); 01866700 T 0050 + END 01867000 T 0051 + ELSE ERROR (101); 01868000 T 0051 + IMKS; 01869000 T 0053 + ADJ (0, 1); 01870000 T 0054 + A ← 3; 01871000 T 0055 + AX.TAG ← IRW; 01872000 T 0056 + AROF ← TRUE; 01873000 T 0057 + RSDN; 01874000 T 0058 + ENTR; 01875000 T 0059 + INT ← 0; 01876000 T 0059 + IF NOT (TRACEWORD = 0 OR (TRACEWORD ≥ 100 AND TRACTER = 0)) 01877000 T 0060 + THEN BEGIN 01878000 T 0062 + WRITE (LP, INTS [SWFI MOD 20]); 01879000 T 0063 + END; 01880000 T 0068 + END INTERRUPT CONTROLLER; 01881000 T 0068 +PRT(702) = *SEGMENT DESCRIPTOR* + 17 IS 69 LONG, NEXT SEG 12 + PROCEDURE TIMING (OP); 01882000 T 0192 +PRT(703) = TIMING + VALUE OP; 01883000 T 0192 + INTEGER OP; 01884000 T 0192 + BEGIN 01885000 T 0192 + DELTATIME ← DELTATIME + OP.[41:6]; %%%%%%%%%%% 01886000 T 0192 + REALTIME ← REALTIME + DELTATIME; 01887000 T 0194 + TIMEOFDAY ← TIMEOFDAY + DELTATIME; 01887100 T 0196 + DELTATIME ← 0; 01888000 T 0197 + END; 01889000 T 0198 + PROCEDURE CONTROLSECTION; 02000000 T 0198 +PRT(704) = CONTROLSECTION + BEGIN 02001000 T 0198 + DEFINE VARIANTESCAPE = 149#, 02002000 T 0198 + START OF SEGMENT ********** 19 + SINGLESHOTESCAPED = 210#, 02003000 T 0000 + TRACESCAPE = 202#, 02004000 T 0000 + SINGLESHOTESCAPEU = 218#; 02005000 T 0000 + DEFINE XXXX = NVLD#; 02006000 T 0000 + DEFINE PRIMARYMODETABLE = 02007000 T 0000 + BEGIN 02008000 T 0000 + VALC; VALC; VALC; VALC; VALC; VALC; VALC; VALC; 02009000 T 0000 + VALC; VALC; VALC; VALC; VALC; VALC; VALC; VALC; 02010000 T 0000 + VALC; VALC; VALC; VALC; VALC; VALC; VALC; VALC; 02011000 T 0000 + VALC; VALC; VALC; VALC; VALC; VALC; VALC; VALC; 02012000 T 0000 + VALC; VALC; VALC; VALC; VALC; VALC; VALC; VALC; 02013000 T 0000 + VALC; VALC; VALC; VALC; VALC; VALC; VALC; VALC; 02014000 T 0000 + VALC; VALC; VALC; VALC; VALC; VALC; VALC; VALC; 02015000 T 0000 + VALC; VALC; VALC; VALC; VALC; VALC; VALC; VALC; 02016000 T 0000 + NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; 02017000 T 0000 + NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; 02018000 T 0000 + NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; 02019000 T 0000 + NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; 02020000 T 0000 + NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; 02021000 T 0000 + NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; 02022000 T 0000 + NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; 02023000 T 0000 + NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; NAMC; 02024000 T 0000 + ADD ; SUBT; MULT; DIVD; IDIV; RDIV; NTIA; NTGR; 02025000 T 0000 + LESS; GREQ; GRTR; LSEQ; EQUL; NEQL; CHSN; MULX; 02026000 T 0000 + LAND; LOR ; LNOT; LEQV; SAME; VARI; BSET; DBST; 02027000 T 0000 + FLTR; DFTR; ISOL; DISO; INSR; DINS; BRST; DBRS; 02028000 T 0000 + BRFL; BRTR; BRUN; EXIT; STBR; NXLN; INDX; RETN; 02029000 T 0000 + DBFL; DBTR; DBUN; ENTR; EVAL; NXLV; MKST; STFF; 02030000 T 0000 + ZERO; ONE ; LT8 ; LT16; PUSH; DLET; EXCH; DUPL; 02031000 T 0000 + STOD; STON; OVRD; OVRN; XXXX; LOAD; LT48; MPCW; 02032000 T 0000 + SCLF; DSLF; SCRT; DSRT; SCRS; DSRS; SCRF; DSRF; 02033000 T 0000 + SCRR; DSRR; ICVD; ICVU; SNGT; SNGL; XTND; IMKS; 02034000 T 0000 + TEED; PACD; EXSD; TWSD; TWOD; SISO; SXSN; ROFF; 02035000 T 0000 + TEEU; PACU; EXSU; TWSU; TWOU; EXPU; RTFF; HALT; 02036000 T 0000 + TLSD; TGED; TGTD; TLED; TEQD; TNED; TUND; XXXX; 02037000 T 0000 + TLSU; TGEU; TGTU; TLEU; TEQU; TNEU; TUNU; XXXX; 02038000 T 0000 + CLSD; CGED; CGTD; CLED; CEQD; CNED; XXXX; XXXX; 02039000 T 0000 + CLSU; CGEU; CGTU; CLEU; CEQU; CNEU; NOOP; NVLD; 02040000 T 0000 + END#; % OF PRIMARYMODETABLE 02041000 T 0000 + DEFINE VARIANTMODETABLE = 02042000 T 0000 + BEGIN 02043000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02044000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02045000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02046000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02047000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02048000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02049000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02050000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02051000 T 0000 + XXXX; XXXX; JOIN; SPLT; IDLE; SINT; EEXI; DEXI; 02052000 T 0000 + XXXX; XXXX; SCNI; SCNO; XXXX; XXXX; WHOI; HEYU; 02053000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02054000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02055000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02056000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02057000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02058000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02059000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; OCRX; XXXX; XXXX; 02060000 T 0000 + XXXX; XXXX; XXXX; LOG2; XXXX; XXXX; XXXX; XXXX; 02061000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02062000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02063000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02064000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; IRWL; PCWL; MVST; 02065000 T 0000 + XXXX; XXXX; XXXX; XXXX; STAG; RTAG; RSUP; RSDN; 02066000 T 0000 + RPRR; SPRR; RDLK; CBON; LODT; LLLU; SRCH; XXXX; 02067000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02068000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02069000 T 0000 + USND; UABD; TWFD; TWTD; SWFD; SWTD; XXXX; TRNS; 02070000 T 0000 + USNU; UABU; TWFU; TWTU; SWFU; SWTU; XXXX; HALT; 02071000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02072000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02073000 T 0000 + SLSD; SGED; SGTD; SLED; SEQD; SNED; XXXX; XXXX; 02074000 T 0000 + SLSU; SGEU; SGTU; SLEU; SEQU; SNEU; NOOP; NVLD; 02075000 T 0000 + END#; % OF VARIANTMODETABLE 02076000 T 0000 + DEFINE EDITMODETABLE = 02077000 T 0000 + BEGIN 02078000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02079000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02080000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02081000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02082000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02083000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02084000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02085000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02086000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02087000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02088000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02089000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02090000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02091000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02092000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02093000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02094000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02095000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02096000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02097000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02098000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02099000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02100000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02101000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02102000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02103000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02104000 T 0000 + MINS; MFLT; SFSC; SRSC; RSTF; ENDF; MVNU; MCHR; 02105000 T 0000 + INOP; INSG; SFDC; SRDC; INSU; INSC; ENDE; HALT; 02106000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02107000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02108000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; 02109000 T 0000 + XXXX; XXXX; XXXX; XXXX; XXXX; XXXX; NOOP; NVLD; 02110000 T 0000 + END#; % OF EDITMODETABLE 02111000 T 0000 + LABEL PSC,ESCP; 02112000 T 0000 + PSC: VARF←FALSE; 02113000 T 0000 + Q ← QP ← N ← 0; 02114000 T 0000 + OPSR ← PSR; 02116000 T 0002 + PICR ← 0; 02117000 T 0003 + ESCP:IF (TS1←REAL(VARF)+REAL(LEEF)+REAL(TEEF)+REAL(SEEF))>1 THEN 02118000 T 0004 + BEGIN ERROR(0); MEMDUMP; GO TO EOJ; 02119000 T 0006 + END; 02120000 T 0010 + T←SYLLABLE; 02121000 T 0010 + IF TS1=0 THEN 02122000 T 0013 + IF (VARF←(T=VARIANTESCAPE)) THEN 02123000 T 0014 + BEGIN 02124000 T 0016 + STEPPSR (1); 02125000 T 0016 + GO TO ESCP; 02126000 T 0017 + END 02127000 T 0017 + ELSE IF T = TRACESCAPE THEN 02128000 T 0017 + BEGIN STEPPSR(1); TRACTER ← SYLLABLE; 02129000 T 0019 + STEPPSR(1); GO TO PSC; 02130000 T 0023 + END 02131000 T 0024 + ELSE IF NOT BOOLEAN(T.[40:1]) THEN DRS.[42:6] ← T; 02132000 T 0024 + STEPPSR (1); 02133000 T 0028 + IF TS1=0 THEN CASE T OF PRIMARYMODETABLE 02134000 T 0028 +PRT(705) = *CASE STATEMENT DESCRIPTOR* + ELSE IF VARF THEN CASE T OF VARIANTMODETABLE 02135000 T 0286 + START OF SEGMENT ********** 20 + 20 IS 256 LONG, NEXT SEG 19 +PRT(706) = *CASE STATEMENT DESCRIPTOR* + ELSE CASE T OF EDITMODETABLE; 02136000 T 0545 + START OF SEGMENT ********** 21 + 21 IS 256 LONG, NEXT SEG 19 +PRT(707) = *CASE STATEMENT DESCRIPTOR* + START OF SEGMENT ********** 22 + 22 IS 256 LONG, NEXT SEG 19 + IF STKOVFF THEN BEGIN SETINTERRUPT(STKOVFI); STKOVFF←FALSE END; 02136100 T 0804 + TIMING (T); 02137000 T 0806 + END OF CONTROL SECTION; 02138000 T 0807 + 19 IS 814 LONG, NEXT SEG 12 + INTEGER PROCEDURE PSYLLABLES; 04000000 T 0198 + BEGIN 04001000 T 0198 + IF NOT PROF THEN 04002000 T 0198 + BEGIN MOVE(M[PIR+PBR],P); MEMCYCLE; 04003000 T 0199 + IF PX.TAG≠CODE THEN SETINTERRUPT(INVOP); 04004000 T 0205 + PROF:=TRUE; 04005000 T 0208 + SYLLABLES[0] ←P.[ 1:7] & PX [40:47:1]; 04006000 T 0209 + SYLLABLES[1] ← P.[8:8]; 04007000 T 0211 + SYLLABLES[2] ← P.[16:8]; 04008000 T 0213 + SYLLABLES[3] ← P.[24:8]; 04009000 T 0215 + SYLLABLES[4] ← P.[32:8]; 04010000 T 0217 + SYLLABLES[5] ← P.[40:8]; 04011000 T 0218 + END; 04012000 T 0220 + PSYLLABLES ← SYLLABLES[PSR]; 04013000 T 0220 + END PSYLLABLES; 04014000 T 0221 + PROCEDURE STEPPSR(N); VALUE N; INTEGER N; 04015000 T 0224 + BEGIN 04016000 T 0224 + LABEL L; 04017000 T 0224 + START OF SEGMENT ********** 23 + INTEGER PICRT; 04018000 T 0000 +STACK(F+2) = PICRT + L: IF (PSR ← PSR + N) ≥ 6 04019000 T 0000 + THEN BEGIN 04020000 T 0001 + PICRT ← PSR DIV 6; 04021000 T 0002 + PICR ← PICR + PICRT; 04022000 T 0003 + PIR ← PIR + PICRT; 04023000 T 0004 + PSR ← PSR MOD 6; 04024000 T 0006 + PROF ← FALSE; 04025000 T 0007 + END; 04026000 T 0008 + IF PSR < 0 04027000 T 0008 + THEN BEGIN 04028000 T 0008 + PSR ← PSR + ABS(N); 04029000 T 0009 + DO PIR ← PIR - 1 UNTIL N ← N + 6 ≥ 0; 04030000 T 0010 + GO L; 04031000 T 0014 + END; 04032000 T 0014 + END STEPPSR; 04033000 T 0014 + 23 IS 17 LONG, NEXT SEG 12 + PROCEDURE SETINTERRUPT(I); VALUE I; INTEGER I; 04034000 T 0224 + BEGIN 04035000 T 0224 + ADJ (0, 0); % TEMPORARY NO FLOWS 04036000 T 0224 + INT ← B ← I; 04037000 T 0226 + BX ← 0; 04038000 T 0227 + BROF ← TRUE; 04039000 T 0228 + AROF ← TRUE; 04040000 T 0228 + END SETINTERRUPT; 04041000 T 0229 + PROCEDURE NOTYETCODED; 04042000 T 0229 +PRT(710) = NOTYETCODED + BEGIN 04043000 T 0229 + FORMAT F (10("X")," OPERATOR NOT YET CODED ",84("X")); 04044000 T 0229 + START OF SEGMENT ********** 24 + START OF SEGMENT ********** 25 +PRT(711) = F + 25 IS 14 LONG, NEXT SEG 24 + WRITETIME; 04045000 T 0000 + HEADING; 04046000 T 0000 + WRITE(LP,F); 04047000 T 0005 + MEMDUMP; 04048000 T 0008 + GO TO EOJ; 04049000 T 0008 + END NOTYETCODED; 04050000 T 0010 + 24 IS 11 LONG, NEXT SEG 12 + PROCEDURE WRITETIME; 04051000 T 0229 + BEGIN 04052000 T 0229 + REAL E,P; 04053000 T 0229 + START OF SEGMENT ********** 26 +STACK(F+2) = E +STACK(F+3) = P + FORMAT TIMES (10("-")," B5500 TIME SINCE START OF RUN: ", 04054000 T 0000 + START OF SEGMENT ********** 27 +PRT(712) = TIMES + "PROCESSOR TIME =",F9.3," SECONDS, ", 04055000 T 0000 + "ELAPSED TIME =",F9.3," SECONDS "8("-")); 04056000 T 0000 + 27 IS 27 LONG, NEXT SEG 26 + E←(TIME(1)-ETIME)/60; P←(TIME(2)-PTIME)/60; 04057000 T 0000 + HEADING; 04058000 T 0004 + WRITE(LP,TIMES,P,E); 04059000 T 0009 +PRT(713) = *LIST, LABEL, OR SEGMENT DESCRIPTOR* + END WRITETIME; 04060000 T 0018 + 26 IS 21 LONG, NEXT SEG 12 + PROCEDURE MKST ; % MARK STACK 07000000 T 0229 + BEGIN 07001000 T 0229 + ERVSFLOW (10); 07002000 T 0229 + 07003000 T 0230 + 07004000 T 0230 + 07005000 T 0230 + 07006000 T 0230 + 07007000 T 0230 + 07008000 T 0230 + END MKST; 07009000 T 0230 + PROCEDURE IMKS ; % INSERT MARK STACK * 07010000 T 0231 + BEGIN 07011000 T 0231 + % REVISED PER L. HANSON FLOWS 8/8/68 BY B.M.M. 07012000 T 0231 + ADJ(1,1); 07013000 T 0231 + MOVE(B,C); 07014000 T 0232 + BX ← 2×MSCW; 07015000 T 0233 + B ← S + 1 - F; 07016000 T 0234 + F ← S + 1; 07017000 T 0236 + ADJ(1,0); 07018000 T 0237 + MOVE(C,B); 07019000 T 0238 + BROF←TRUE; 07020000 T 0239 + END IMKS; 07021000 T 0240 + PROCEDURE NAMC ; % NAME CALL 07022000 T 0240 + BEGIN 07023000 T 0240 + ADJ(0,2); 07024000 T 0240 + C ← SYLLABLE & DRS [34:42:6]; 07025000 T 0242 + CX ← 2×IRW; 07026000 T 0245 + AROF:=TRUE; 07027000 T 0247 + MOVE (C, A); 07028000 T 0247 + STEPPSR(1); 07029000 T 0248 + END NAMC; 07030000 T 0249 + PROCEDURE VALC ; % VALUE CALL 07031000 T 0249 + BEGIN 07032000 T 0249 + ERVSFLOW(1); 07033000 T 0249 + END VALC; 07034000 T 0250 + PROCEDURE EVAL ; % EVALUATE DESCRIPTOR 07035000 T 0251 + BEGIN 07036000 T 0251 + ERVSFLOW(2); 07037000 T 0251 + END EVAL; 07038000 T 0251 + PROCEDURE ENTR ; % ENTER 07039000 T 0252 + BEGIN 07040000 T 0252 + ERVSFLOW(3); 07041000 T 0252 + END ENTR; 07042000 T 0252 + PROCEDURE EXIT ; % EXIT 07043000 T 0253 + BEGIN 07044000 T 0253 + ERVSFLOW(4); 07045000 T 0253 + END EXIT; 07046000 T 0253 + PROCEDURE RETN ; % RETURN 07047000 T 0254 + BEGIN 07048000 T 0254 + ERVSFLOW(5); 07049000 T 0254 + END RETN; 07050000 T 0254 + PROCEDURE IRWL ; % (HARDWARE PSEUDO-INSTRUCTION) 07051000 T 0255 + BEGIN 07052000 T 0255 + ERVSFLOW(19); 07053000 T 0255 + END IRWL; 07054000 T 0255 + PROCEDURE PCWL ; % (HARDWARE PSEUDO INSTRUCTION) 07055000 T 0256 + BEGIN 07056000 T 0256 + ERVSFLOW (20); 07057000 T 0256 + END PCWL; 07058000 T 0256 + PROCEDURE BRUN ; % BRANCH UNCONDITIONAL 07059000 T 0257 + BEGIN 07060000 T 0257 + ERVSFLOW(17); 07061000 T 0257 + END BRUN; 07062000 T 0257 + PROCEDURE BRTR ; % BRANCH TRUE 07063000 T 0258 + BEGIN 07064000 T 0258 + ERVSFLOW(15); 07065000 T 0258 + END BRTR; 07066000 T 0258 + PROCEDURE BRFL ; % BRANCH FALSE 07067000 T 0259 + BEGIN 07068000 T 0259 + ERVSFLOW(16); 07069000 T 0259 + END BRFL; 07070000 T 0259 + PROCEDURE PCWORD; % PROGRAM CONTROL WORD 07071000 T 0260 +PRT(714) = PCWORD + BEGIN 07072000 T 0260 + LABEL OC; 07073000 T 0260 + START OF SEGMENT ********** 28 + IF LL ≠ C.LLF 07074000 T 0000 + THEN SETINTERRUPT (INVOP) 07075000 T 0000 + ELSE BEGIN 07076000 T 0002 + PDR ← C.SDIF; 07077000 T 0004 + PSR ← C.PSRF; 07078000 T 0005 + PIR ← C.PIRF; 07079000 T 0006 + MOVE (M[D[C.[34:1]] + C.[35:13]], C); 07080000 T 0007 + MEMCYCLE; 07081000 T 0013 + IF CX.TAG ≠ SEGDESC 07082000 T 0014 + THEN BEGIN 07083000 T 0015 + SETINTERRUPT (INVOP); 07084000 T 0016 + GO OC; 07085000 T 0017 + END 07086000 T 0019 + ELSE IF CX.PBIT ≠ 1 07087000 T 0019 + THEN BEGIN 07088000 T 0020 + SETINTERRUPT (PRESBIT); 07089000 T 0021 + GO OC; 07090000 T 0022 + END 07091000 T 0024 + ELSE BEGIN 07092000 T 0024 + PBR ← C.ADDR; 07093000 T 0024 + PROF ← AROF ← FALSE; 07094000 T 0025 + END; 07095000 T 0027 + END; 07096000 T 0027 + OC: END FETCH OF PROGRAM CONTROL WORD; 07097000 T 0027 + 28 IS 28 LONG, NEXT SEG 12 + PROCEDURE DYNAMICBRANCH; % UTILITY PROCEDURE FOR DYNAMIC BRANCHES 07098000 T 0260 +PRT(715) = DYNAMICBRANCH + BEGIN 07099000 T 0260 + INTEGER TTAG; 07100000 T 0260 + START OF SEGMENT ********** 29 +STACK(F+2) = TTAG + LABEL IRWORD; 07101000 T 0000 + IF (TTAG ← AX.TAG) = SINGL OR TTAG = DOUBL 07102000 T 0000 + THEN BEGIN 07103000 T 0002 + IF A < 0 OR A ≥ 2*21 OR INTEGERIZE(TRUE, A) 07104000 T 0003 + THEN SETINTERRUPT (INVOP) 07105000 T 0008 + ELSE BEGIN 07106000 T 0010 + PSR ← IF BOOLEAN (A)THEN 3 ELSE 0; 07107000 T 0012 + PIR ← A.[27:20]; 07108000 T 0014 + PROF ← AROF ← FALSE; 07109000 T 0015 + END 07110000 T 0016 + END 07111000 T 0016 + ELSE BEGIN 07112100 T 0016 + MOVE (A, C); 07113000 T 0017 + IRWORD: IF TTAG ← CX. TAG = IRW 07114000 T 0018 + THEN BEGIN 07115000 T 0020 + IF C.EBIT = 0 07116000 T 0021 + THEN BEGIN 07117000 T 0022 + MOVE(M[D[LEVEL(C)]+DELTA(C)],C); 07118000 T 0023 + MEMCYCLE; 07119000 T 0028 + GO TO IRWORD; 07120000 T 0030 + END 07121000 T 0030 + ELSE SETINTERRUPT (INVOP); 07122000 T 0030 + END 07123000 T 0031 + ELSE IF TTAG ≠ PCW 07124000 T 0031 + THEN SETINTERRUPT (INVOP) 07125000 T 0034 + ELSE PCWORD; 07126000 T 0035 + END; 07127000 T 0038 + END OF DYNAMIC BRANCH UTILITY ROUTINE; 07128000 T 0038 + 29 IS 41 LONG, NEXT SEG 12 + PROCEDURE DBUN; % DYNAMIC BRANCH UNCONDITIONAL DBUN 07129000 T 0260 + BEGIN 07130000 T 0260 + ERVSFLOW(14); 07131000 T 0260 + END DBUN; 07132000 T 0260 + PROCEDURE DBTR; % DYNAMIC BRANCH ON TRUE DBTR 07133000 T 0261 + BEGIN 07134000 T 0261 + ERVSFLOW(12); 07135000 T 0261 + END DBTR; 07136000 T 0261 + PROCEDURE DBFL; % DYNAMIC BRANCH ON FALSE 07137000 T 0262 + BEGIN 07138000 T 0262 + ERVSFLOW(13); 07139000 T 0262 + END DBFL; 07140000 T 0262 + PROCEDURE NOOP ; % NO OPERATION 07141000 T 0263 + BEGIN 07142000 T 0263 + END NOOP; 07143000 T 0263 + PROCEDURE HALT ; % CONDITIONAL HALT 07144000 T 0263 + BEGIN 07145000 T 0263 + FILE SPO 11(1,10); 07145010 T 0263 + START OF SEGMENT ********** 30 +STACK(F+2) = SPO + FORMAT HALTER("**B6500/SIM: PDR = ",I3,":PIR = ",I4,"←"); 07145020 T 0003 + START OF SEGMENT ********** 31 +PRT(716) = HALTER + 31 IS 12 LONG, NEXT SEG 30 + IF HALTING=0 THEN WRITE(SPO,HALTER,PDR,PIR); 07145030 T 0003 +PRT(717) = *LIST, LABEL, OR SEGMENT DESCRIPTOR* + WHILE HALTING=0 DO WHEN(10); 07145040 T 0014 + CASE HALTING MOD 4 OF 07145050 T 0017 + BEGIN 07145060 T 0017 +PRT(720) = *CASE STATEMENT DESCRIPTOR* + ; 07145070 T 0018 + NOTYETCODED; 07145080 T 0018 + MEMDUMP; 07145090 T 0019 + ; 07145100 T 0020 + END; 07146000 T 0020 + START OF SEGMENT ********** 32 + 32 IS 4 LONG, NEXT SEG 30 + END HALT; 07147000 T 0020 + 30 IS 24 LONG, NEXT SEG 12 + PROCEDURE NVLD ; % INVALID OPERATOR 07148000 T 0263 + BEGIN 07149000 T 0263 + SETINTERRUPT(INVOP); 07150000 T 0263 + END NVLD; 07151000 T 0264 + PROCEDURE VARI ; % ESCAPE TO 16-BIT INSTRUCTION 07156000 T 0266 + BEGIN 07157000 T 0266 + ERROR(1); MEMDUMP; GO TO EOJ; 07158000 T 0266 + END VARI; 07159000 T 0269 + PROCEDURE ADD ; % ADD 07160000 T 0269 + BEGIN 07161000 T 0269 + DEFINE FORCESEGMENTATION = #; %>RETRO 07161099 T 0269 + START OF SEGMENT ********** 33 + ADJ(1,1); 07162000 T 0000 + IF NOT CHECOP THEN INTFAMA(-1) ELSE 07163000 T 0001 + IF AX.TAG=SINGL AND BX.TAG=SINGL THEN 07164000 T 0008 + BEGIN 07165000 T 0011 + B:= B + A; 07166000 T 0012 + BX.PBIT:= REAL(AROF:=FALSE); 07167000 T 0013 + END ELSE 07168000 T 0015 + BEGIN 07169000 T 0015 + IF AX.TAG=SINGL THEN X:=XX:= 0 ELSE 07170000 T 0016 + IF BX.TAG=SINGL THEN Y:=YX:= 0; 07171000 T 0019 + DOUBLE(A,X,B,Y,+,←,B,Y); 07172000 T 0022 + BX←DOUBL+DOUBL; 07173000 T 0025 + AROF:=FALSE; 07174000 T 0026 + END; 07175000 T 0027 + END ADD ; 07176000 T 0027 + 33 IS 28 LONG, NEXT SEG 12 + PROCEDURE SUBT ; % SUBTRACT 07177000 T 0269 + BEGIN 07178000 T 0269 + DEFINE FORCESEGMENTATION = #; %>RETRO 07178099 T 0269 + START OF SEGMENT ********** 34 + ADJ(1,1); 07179000 T 0000 + IF NOT CHECOP THEN INTFAMA(-1) ELSE 07180000 T 0001 + IF AX.TAG=SINGL AND BX.TAG=SINGL THEN 07181000 T 0008 + BEGIN 07182000 T 0011 + B:= B - A; 07183000 T 0012 + BX.PBIT:= REAL(AROF:=FALSE); 07184000 T 0013 + END ELSE 07185000 T 0015 + BEGIN 07186000 T 0015 + IF AX.TAG=SINGL THEN X:=XX:= 0 ELSE 07187000 T 0016 + IF BX.TAG=SINGL THEN Y:=YX:= 0; 07188000 T 0019 + DOUBLE(B,Y,A,X,-,←,B,Y); 07189000 T 0022 + BX←DOUBL+DOUBL; 07190000 T 0025 + AROF:=FALSE; 07191000 T 0026 + END; 07192000 T 0027 + END SUBT; 07193000 T 0027 + 34 IS 28 LONG, NEXT SEG 12 + PROCEDURE MULT ; % MULTIPLY 07194000 T 0269 + BEGIN 07195000 T 0269 + DEFINE FORCESEGMENTATION = #; %>RETRO 07195099 T 0269 + START OF SEGMENT ********** 35 + ADJ(1,1); 07196000 T 0000 + IF NOT CHECOP THEN INTFAMA(-1) ELSE 07197000 T 0001 + IF AX.TAG=SINGL AND BX.TAG=SINGL THEN 07198000 T 0008 + BEGIN 07199000 T 0011 + B:= B × A; 07200000 T 0012 + BX.PBIT:= REAL(AROF:=FALSE); 07201000 T 0013 + END ELSE 07202000 T 0015 + BEGIN 07203000 T 0015 + IF AX.TAG=SINGL THEN X:=XX:= 0 ELSE 07204000 T 0016 + IF BX.TAG=SINGL THEN Y:=YX:= 0; 07205000 T 0019 + DOUBLE(A,X,B,Y,×,←,B,Y); 07206000 T 0022 + BX:=YX:=DOUBL+DOUBL; 07207000 T 0025 + AROF:=FALSE; 07208000 T 0026 + END; 07209000 T 0027 + END MULT; 07210000 T 0027 + 35 IS 28 LONG, NEXT SEG 12 + PROCEDURE MULX ; % EXTENDED MULTIPLY 07211000 T 0269 + BEGIN 07212000 T 0269 + NOTYETCODED; 07213000 T 0269 + END MULX; 07214000 T 0270 + PROCEDURE DIVD ; % DIVIDE 07215000 T 0270 + BEGIN 07216000 T 0270 + LABEL OC; 07217000 T 0270 + START OF SEGMENT ********** 36 + ADJ(1,1); 07218000 T 0000 + IF NOT CHECOP THEN INTFAMA(-1) ELSE 07219000 T 0001 + IF AX.TAG=SINGL AND BX.TAG=SINGL THEN 07220000 T 0008 + IF A=0 THEN BEGIN INTFAMA( DIVZROI); GO OC END ELSE 07221000 T 0011 + BEGIN 07222000 T 0016 + B:= B/A; 07223000 T 0016 + BX.PBIT:= REAL(AROF:=FALSE); 07224000 T 0017 + END ELSE 07225000 T 0020 + BEGIN 07226000 T 0020 + IF AX.TAG=SINGL THEN X:=XX:= 0 ELSE 07227000 T 0020 + IF BX.TAG=SINGL THEN Y:=YX:=0; 07228000 T 0023 + IF A=0 AND X=0 THEN BEGIN INTFAMA(DIVZROI); 07229000 T 0027 + GO TO OC; 07230000 T 0030 + END; 07231000 T 0032 + DOUBLE(B,Y,A,X,/,←,B,Y); 07232000 T 0032 + BX←DOUBL+DOUBL; 07233000 T 0034 + AROF:=FALSE; 07234000 T 0035 + END; 07235000 T 0036 + OC: 07236000 T 0036 + END DIVD; 07237000 T 0037 + 36 IS 38 LONG, NEXT SEG 12 + PROCEDURE IDIV ; % INTEGER DIVIDE 07238000 T 0270 + BEGIN 07239000 T 0270 + DIVD; 07240000 T 0270 + IF INT =0 07241000 T 0271 + THEN IF INTEGERIZE(FALSE,B) THEN INTFAMA(INTOVFI); 07242000 T 0271 + END IDIV; 07243000 T 0275 + PROCEDURE RDIV ; % REMAINDER DIVIDE 07244000 T 0277 + BEGIN 07245000 T 0277 + LABEL OC; 07246000 T 0277 + START OF SEGMENT ********** 37 + INTEGER SIGNQ, SIGNQH; 07247000 T 0000 +STACK(F+2) = SIGNQ +STACK(F+3) = SIGNQH + REAL TA, TX, TB, TY; 07248000 T 0000 +STACK(F+4) = TA +STACK(F+5) = TX +STACK(F+6) = TB +STACK(F+7) = TY + ADJ (1, 1); 07249000 T 0000 + TA←A; TX←IF AX.TAG≠SINGL THEN X ELSE 0; 07250000 T 0001 + TB←B; TY←IF BX.TAG≠SINGL THEN Y ELSE 0; 07251000 T 0005 + DIVD; 07252000 T 0009 + IF INT ≠0 THEN GO TO OC; 07253000 T 0009 + SIGNQ ← SIGN(B); 07254000 T 0010 + B.SOBIT ← 0; 07255000 T 0013 + IF INTEGERIZE (FALSE, B) THEN BEGIN ERROR(100); GO OC END; 07256000 T 0015 + Y ← 0; 07257000 T 0017 + DOUBLE (TB, TY, TA, TX, SIGNQ, SIGNQH, B, Y, ×,×, -, ←, B, Y); 07258000 T 0018 + IF INTEGERIZE(FALSE,B) THEN INTFAMA(INTOVFI); 07259000 T 0022 + OC: 07260000 T 0024 + END RDIV; 07261000 T 0025 + 37 IS 30 LONG, NEXT SEG 12 + PROCEDURE NTIA ; % INTEGER TRUNCATED 07262000 T 0277 + BEGIN 07263000 T 0277 + INTEGER EB; % EXPONENT IN B AT ENTRY,IN CODE USED 07264000 T 0277 + START OF SEGMENT ********** 38 +STACK(F+2) = EB + % AS 8-BASED EXPONENT,IN COMMENTS,FOR 07265000 T 0000 + % CONVENIENCE,REFERENCED AS 2-BASED 07266000 T 0000 + DEFINE I1INVALIDOPERATOR = BEGIN 07269000 T 0000 + INTFAMA(-1); 07270000 T 0000 + GO TO OC END#, 07271000 T 0000 + I2INTEGEROVERFLOW = BEGIN 07272000 T 0000 + INTFAMA(INTOVFI); 07273000 T 0000 + GO TO OC END#; 07274000 T 0000 + % INTERRUPT PROCESSING TO BE DEFINED 07275000 T 0000 + LABEL L1,NEGEXPLBL,OC; 07276000 T 0000 + INTEGER T1,T2; % WORKING LOCAL INTEGERS 07277000 T 0000 +STACK(F+3) = T1 +STACK(F+4) = T2 + ADJ(0,1); 07278000 T 0000 + IF BX.TAG ≠SINGL AND BX.TAG ≠ DOUBL THEN I1INVALIDOPERATOR; 07279000 T 0001 + IF(EB←B.EXPF)=0 THEN GO TO L1; 07280000 T 0005 + IF BX.TAG = SINGL THEN Y ← 0; 07281000 T 0008 + IF B.SEBIT=1 THEN GO TO NEGEXPLBL; 07282000 T 0010 + IF (T1←B.MANF)>8*(13-EB)-1 THEN I2INTEGEROVERFLOW; % IF EB< NB 07283000 T 0012 +PRT(721) = LN +PRT(722) = EXP +PRT(723) = X TO THE I + T1 ← T1×8*EB; % T1.[36:39-EB] ← B.[38-EB:39-EB] 07284000 T 0020 + B.MANF←T1+(T2←Y.MANF) DIV (8*(13-EB));%B←B.[38-EB:39-EB] 07285000 T 0023 + %+Y.[38-EB] 07286000 T 0029 + B.SEXPF ← 0; 07287000 T 0029 + GO TO L1; 07288000 T 0031 + NEGEXPLBL: 07289000 T 0031 + B.MANF←(T1←B.MANF) DIV (8*EB);%B.[38-EB:39-EB]←B.[38:39-EB] 07290000 T 0032 + % B.[38-EB] ← 0 IMPLIED 07291000 T 0037 + B.SEXPF ← 0; 07292000 T 0037 + L1: BX.TAG ← SINGL; 07293000 T 0039 + OC: 07294000 T 0040 + END NTIA; 07295000 T 0041 + 38 IS 44 LONG, NEXT SEG 12 + PROCEDURE NTGR; % INTEGERISE ROUNDED 07296000 T 0277 + BEGIN 07297000 T 0277 + INTEGER EB; % EXPONENT IN B AT ENTRY,IN CODE USED 07298000 T 0277 + START OF SEGMENT ********** 39 +STACK(F+2) = EB + % AS 8-BASED EXPONENT,IN COMMENTS,FOR 07299000 T 0000 + % CONVENIENCE,REFERENCED AS 2-BASED 07300000 T 0000 + DEFINE I1INVALIDOPERATOR = BEGIN 07303000 T 0000 + INTFAMA(-1); 07304000 T 0000 + GO TO OC END#, 07305000 T 0000 + I2INTEGEROVERFLOW = BEGIN 07306000 T 0000 + INTFAMA(INTOVFI); 07307000 T 0000 + GO TO OC END#; 07308000 T 0000 + % INTERRUPT PROCESSING TO BE DEFINED 07309000 T 0000 + LABEL L1,NEGEXPLBL,L2,L3,L4,OC; 07310000 T 0000 + INTEGER T1,T2; % WORKING LOCAL INTEGERS 07311000 T 0000 +STACK(F+3) = T1 +STACK(F+4) = T2 + ADJ(0,1); 07312000 T 0000 + IF BX.TAG ≠ SINGL AND BX.TAG ≠ DOUBL THEN I1INVALIDOPERATOR; 07313000 T 0001 + IF BX.TAG = SINGL THEN Y ← 0; 07314000 T 0005 + IF (EB←B.EXPF) = 0 THEN GO TO L1; 07315000 T 0008 + IF B.SEBIT =1 THEN GO TO NEGEXPLBL; 07316000 T 0010 + IF (T1 ← B.MANF) > 8*(13-EB)-1 THEN I2INTEGEROVERFLOW; % EB≤NB 07317000 T 0012 + T1 ← T1×8*EB; % T1← B.[38-EB:39-EB] 07318000 T 0020 + B.MANF←T1+(T2←Y.MANF) DIV (8*(13-EB));%B←B.[38-EB:39-EB] 07319000 T 0023 + %+Y.[38:EB] 07320000 T 0029 + Y ← (T1 ← Y.MANF)× 8*EB; % Y.[38:39-EB] ← Y.[38-EB:39-EB] 07321000 T 0029 + % Y.[EB:EB] ← 0 IMPLIED 07322000 T 0033 + B.SEXPF ← 0; 07323000 T 0033 + IF BX.TAG=SINGL THEN GO TO L4; 07324000 T 0035 + L1: IF B.SOBIT = 0 THEN GO TO L3; 07325000 T 0037 + IF Y.MANF ≤ 274877906944 THEN GO TO L4; % IF FRACTION ≤ 0.5 07326000 T 0039 + L2: IF B.MANF = 549755813887 THEN I2INTEGEROVERFLOW; % IF B=2*39-1 07327000 T 0041 + B.MANF ← B.MANF+1; 07328000 T 0048 + GO TO L4; 07329000 T 0050 + L3: IF Y.MANF ≥ 274877906944 THEN GO TO L2 ELSE GO TO L4; 07330000 T 0051 + % LAST STATEMENT EQUIVALENT TO IF FRACTION ≥ 0.5.... 07331000 T 0054 + NEGEXPLBL: 07332000 T 0054 + B.MANF←(T1←B.MANF) DIV (8*EB);%B.[38-EB:39-EB]←B.[38:39-EB] 07333000 T 0055 + % B.[38:EB] ← 0 IMPLIED 07334000 T 0060 + Y←T1×8*(13-EB); % Y.[38:EB] ← B.[EB:EB] 07335000 T 0060 + B.SEXPF ← 0; 07336000 T 0064 + GO TO L1; 07337000 T 0065 + L4: BX.TAG ← SINGL; 07338000 T 0068 + OC: 07339000 T 0069 + END NTGR; 07340000 T 0070 + 39 IS 73 LONG, NEXT SEG 12 + PROCEDURE NTGD; % DOUBLE PRECISION INTEGERIZE 07340010 T 0277 +PRT(724) = NTGD + BEGIN 07340020 T 0277 + INTEGER XA, XB, KT, LZCT; 07340060 T 0277 + START OF SEGMENT ********** 40 +STACK(F+2) = XA +STACK(F+3) = XB +STACK(F+4) = KT +STACK(F+5) = LZCT + LABEL OC, L1, L2, L10; 07340070 T 0000 + ADJ (0,1); 07340080 T 0000 + CHECOPRNDB END; IF SDIS = 1 THEN GO TO OC; 07340090 T 0001 + BX.TAG ← DOUBL; 07340100 T 0007 + A.SEXPF ← 013; 07340110 T 0008 + IF B.MANF = 0 AND Y.MANF = 0 THEN GO TO L10; 07340120 T 0010 + XA ← XA & XX[33:47:1] & X[34:1:8] & A[42:3:6]; 07340130 T 0014 + XB ← XB & YX[33:47:1] & Y[34:1:8] & A[42:3:6]; 07340140 T 0017 + IF XA = XB THEN GO TO OC; 07340150 T 0021 + IF XA > XB THEN 07340160 T 0022 + BEGIN 07340170 T 0023 + IF B.SEXPF ≠ 1 THEN 07340180 T 0024 + BEGIN 07340190 T 0025 + FOR KT ← XA - XB STEP -1 UNTIL 0 DO 07340200 T 0025 + BEGIN 07340210 T 0030 + X.[12:36] ← X.[9:36]; 07340220 T 0030 + X.[9:3] ← Y.[45:3]; 07340230 T 0032 + Y.[12:36] ← Y.[9:36]; 07340240 T 0034 + Y.[9:3] ← B.[45:3]; 07340250 T 0036 + B.[12:36] ← B.[9:36]; 07340260 T 0039 + B.[9:3] ← 0; 07340270 T 0041 + END; 07340280 T 0043 + L1: IF X.[9:3] > 4 THEN 07340290 T 0045 + BEGIN 07340300 T 0046 + AX ← A ← 0; XX ← X ← 0; 07340310 T 0046 + X ← 1; AX.TAG ← DOUBL; 07340320 T 0049 + AROF ← TRUE; 07340330 T 0051 + ADD; 07340340 T 0052 + END; 07340350 T 0053 + GO TO L10; 07340360 T 0053 + END; 07340370 T 0053 + IF B.MANF ≠ 0 THEN 07340380 T 0053 + BEGIN 07340390 T 0054 + Y.[9:39] ← B.[9:39]; 07340400 T 0055 + B.[9:39] ← 0; 07340410 T 0057 + XB ← XB - XA; 07340420 T 0059 + IF XB < XA THEN 07340430 T 0060 + BEGIN 07340440 T 0061 + FOR KT ← XA - XB STEP -1 UNTIL 0 DO 07340450 T 0061 + BEGIN 07340460 T 0066 + X.[9:3] ← Y.[45:3]; 07340470 T 0066 + Y.[12:36] ← Y.[9:36]; 07340480 T 0068 + Y.[9:3] ← 0; 07340490 T 0070 + END; 07340500 T 0072 + GO TO L1; 07340510 T 0072 + END; 07340520 T 0073 + END; 07340530 T 0073 + Y.[9:39] ← 0; 07340540 T 0073 + GO TO L10; 07340550 T 0075 + END; 07340560 T 0075 + XB ← XB - 13; 07340570 T 0075 + IF XA < XB THEN 07340580 T 0076 + BEGIN 07340590 T 0077 + IF B.MANF ≠ 0 THEN BEGIN 07340600 T 0078 + SETINTERRUPT (INTOVFI); 07340601 T 0079 + GO TO OC; END; 07340602 T 0080 + B.[9:39] ← Y.[9:39]; 07340610 T 0082 + Y.[9:39] ← 0; 07340620 T 0084 + XB ← XB - 13; 07340630 T 0086 + IF XB > XA THEN BEGIN SETINTERRUPT (INTOVFI); 07340640 T 0087 + GO TO OC; 07340641 T 0089 + END; 07340642 T 0091 + END; 07340650 T 0091 + MOVE (B, JUNK); 07340660 T 0091 + LZCT ← 0; 07340670 T 0092 + L2: IF JUNK.[9:3] = 0 THEN 07340680 T 0092 + BEGIN 07340690 T 0094 + LZCT ← LZCT + 1; 07340700 T 0094 + JUNK.[9:36] ← JUNK.[12:36]; 07340710 T 0096 + GO TO L2; 07340720 T 0098 + END; 07340730 T 0098 + IF LZCT < XB THEN BEGIN SETINTERRUPT (INTOVFI); 07340740 T 0098 + GO TO OC; 07340741 T 0100 + END; 07340742 T 0103 + FOR KT ← XB STEP -1 UNTIL 0 DO 07340750 T 0103 + BEGIN 07340760 T 0104 + B.[9:36] ← B.[12:36]; 07340770 T 0104 + B.[45:3] ← Y.[9:3]; 07340780 T 0106 + Y.[9:36] ← Y.[12:36]; 07340790 T 0108 + Y.[45:3] ← 0; 07340800 T 0110 + END; 07340810 T 0112 + B.SEXPF ← A.SEXPF; 07340820 T 0114 + GO TO OC; 07340830 T 0117 + L10: 07340840 T 0117 + Y.EXPEXT ← 0; 07340850 T 0118 + B.SEXPF ← A.SEXPF; 07340860 T 0119 + OC: 07340870 T 0122 + END OF DOUBLE PRECISION INTEGERIZE; 07340880 T 0122 + 40 IS 125 LONG, NEXT SEG 12 + PROCEDURE SNGT ; % SET TO SINGLE PRECISION, TRUNCATED 07341000 T 0277 + BEGIN 07342000 T 0277 + ADJ(0,1); 07343000 T 0277 + CHECOPRNDB END; 07344000 T 0278 + BX.TAG←Y←YX←0 07345000 T 0282 + END SNGT; 07346000 T 0282 + PROCEDURE SNGL ; % SET TO SINGLE PRECISION; ROUNDED 07347000 T 0287 + BEGIN 07348000 T 0287 + ADJ(0,1); 07349000 T 0287 + CHECOPRNDB END 07350000 T 0288 + ELSE IF BX.TAG=DOUBL THEN 07351000 T 0292 + BEGIN IF X.[9:1]=1 THEN A← (A+1)&A[1:1:8]; 07352000 T 0295 + AX.TAG ← X ← XX ←0; 07353000 T 0299 + BX.TAG←Y←YX←0; 07354000 T 0302 + END; 07355000 T 0305 + END SNGL; 07356000 T 0305 + PROCEDURE XTND ; % SET TO DOUBLE PRECISION 07357000 T 0305 + BEGIN 07358000 T 0305 + ADJ(0,1); 07359000 T 0305 + CHECOPRNDB END 07360000 T 0307 + ELSE IF BX.TAG=SINGL THEN 07361000 T 0311 + BEGIN BX.TAG←DOUBL; 07362000 T 0314 + Y←YX←0; 07363000 T 0316 + END; 07364000 T 0317 + END XTND; 07365000 T 0317 + PROCEDURE JOIN; % MAKE TWO SINGLES INTO A DOUBLE PRECISION OPERAND 07366000 T 0318 + BEGIN 07367000 T 0318 + ADJ (1,1); 07368000 T 0318 + IF NOT CHECOP THEN SETINTERRUPT (INVOP) ELSE 07368200 T 0319 + BEGIN 07368300 T 0326 + Y ← A; 07368400 T 0328 + BX.TAG ← DOUBL; 07368500 T 0328 + AROF ← FALSE 07368600 T 0330 + END; 07368700 T 0330 + END JOIN; 07369000 T 0331 + PROCEDURE SPLT; % MAKE A DOUBLE PRECISION INTO TWO SINGLE OPERANDS 07370000 T 0331 + BEGIN 07371000 T 0331 + ADJ (0,1); 07371100 T 0331 + CHECOPRNDB END 07371200 T 0333 + ELSE IF BX.TAG = DOUBL THEN A ← Y 07371300 T 0337 + ELSE A ← 0; 07372000 T 0340 + AX.TAG ← SINGL; 07372050 T 0342 + BX.TAG ← SINGL; 07372100 T 0344 + AROF ← TRUE; 07372200 T 0346 + END SPLT; 07373000 T 0347 + PROCEDURE LAND ; % LOGICAL AND 07374000 T 0347 + BEGIN 07375000 T 0347 + ADJ(1,1); 07376000 T 0347 + B:=REAL(BOOLEAN(A)AND BOOLEAN(B)); 07377000 T 0349 + BX ← REAL(BOOLEAN(AX) AND BOOLEAN(BX)); 07378000 T 0350 + IF AX.TAG=DOUBL OR BX.TAG=DOUBL THEN 07379000 T 0351 + BEGIN 07380000 T 0354 + IF AX.TAG≠DOUBL THEN X:=XX:=0; 07381000 T 0354 + IF BX.TAG≠DOUBL THEN Y:=YX:=0; 07382000 T 0357 + Y:=REAL(BOOLEAN(Y)AND BOOLEAN(X)); 07383000 T 0360 + YX.PBIT:=REAL(BOOLEAN(YX.PBIT)AND BOOLEAN(XX.PBIT)); 07384000 T 0362 + BX.TAG←DOUBL; 07385000 T 0365 + END; 07386000 T 0367 + AROF:=FALSE; 07387000 T 0367 + END LAND; 07388000 T 0367 + PROCEDURE LOR ; % LOGICAL OR 07389000 T 0368 + BEGIN 07390000 T 0368 + ADJ(1,1); 07391000 T 0368 + B:=REAL(BOOLEAN(A) OR BOOLEAN(B)); 07392000 T 0369 + BX ← REAL(BOOLEAN(AX) OR BOOLEAN(BX)); 07393000 T 0370 + IF AX.TAG=DOUBL OR BX.TAG=DOUBL THEN 07394000 T 0371 + BEGIN 07395000 T 0374 + IF AX.TAG≠DOUBL THEN X:=XX:=0; 07396000 T 0374 + IF BX.TAG≠DOUBL THEN Y:=YX:=0; 07397000 T 0377 + Y:=REAL(BOOLEAN(Y) OR BOOLEAN(X)); 07398000 T 0380 + YX.PBIT:=REAL(BOOLEAN(YX.PBIT) OR BOOLEAN(XX.PBIT)); 07399000 T 0382 + BX.TAG←DOUBL; 07400000 T 0385 + END; 07401000 T 0387 + AROF:=FALSE; 07402000 T 0387 + END LOR ; 07403000 T 0387 + PROCEDURE LNOT ; % LOGICAL NEGATE 07404000 T 0388 + BEGIN 07405000 T 0388 + ADJ(1,2); 07406000 T 0388 + A:=REAL(NOT BOOLEAN(A)); 07407000 T 0389 + AX ← REAL(NOT BOOLEAN(AX)); 07408000 T 0390 + IF AX.TAG=DOUBL THEN 07409000 T 0391 + BEGIN 07410000 T 0392 + X:=REAL(NOT BOOLEAN(X)); 07411000 T 0392 + XX.PBIT:=REAL(NOT BOOLEAN(XX.PBIT)); 07412000 T 0393 + END; 07413000 T 0396 + END LNOT; 07414000 T 0396 + PROCEDURE SAME ; % LOGICAL EQUAL 07415000 T 0396 + BEGIN 07416000 T 0396 + REAL PROCEDURE EQUAL(A,B,C,D);VALUE A,B,C,D; REAL A,B,C,D; 07417000 T 0396 + START OF SEGMENT ********** 41 +PRT(725) = EQUAL + EQUAL← REAL(REAL(BOOLEAN(A)EQV BOOLEAN(B)) = REAL(NOT FALSE) 07418000 T 0000 + AND C=D); 07419000 T 0001 + ADJ(1,1); 07420000 T 0005 + IF AX.TAG≠BX.TAG THEN B:=0 ELSE 07421000 T 0007 + BEGIN 07422000 T 0010 + B:=EQUAL(A,B,AX.PBIT,BX.PBIT); 07423000 T 0010 + IF AX.TAG=DOUBL THEN 07424000 T 0013 + B:=REAL(BOOLEAN(B)AND BOOLEAN(EQUAL(X,Y, 07425000 T 0014 + XX.PBIT,YX.PBIT))); 07426000 T 0016 + END; 07427000 T 0018 + AROF:=FALSE; 07428000 T 0018 + BX.[44:4]:=0; 07429000 T 0019 + END SAME; 07430000 T 0021 + 41 IS 22 LONG, NEXT SEG 12 + PROCEDURE LEQV ; % LOGICAL EQUIVALENCE 07431000 T 0396 + BEGIN 07432000 T 0396 + ADJ(1,1); 07433000 T 0396 + B:=REAL(BOOLEAN(A)EQV BOOLEAN(B)); 07434000 T 0398 + BX ← REAL(BOOLEAN(AX) EQV BOOLEAN(BX)); 07435000 T 0399 + IF AX.TAG=DOUBL OR BX.TAG=DOUBL THEN 07436000 T 0400 + BEGIN 07437000 T 0403 + IF AX.TAG≠DOUBL THEN X:=XX:=0; 07438000 T 0403 + IF BX.TAG≠DOUBL THEN Y:=YX:=0; 07439000 T 0406 + Y:=REAL(BOOLEAN(Y)EQV BOOLEAN(X)); 07440000 T 0409 + YX.PBIT:=REAL(BOOLEAN(YX.PBIT)EQV BOOLEAN(XX.PBIT)); 07441000 T 0411 + BX.TAG←DOUBL; 07442000 T 0414 + END; 07443000 T 0416 + AROF:=FALSE; 07444000 T 0416 + END LEQV; 07445000 T 0416 + DEFINE NOTOPERAND= IF NOT CHECOP THEN BEGIN SETINTERRUPT(INVOP); 07446000 T 0417 + GO TO OC; END#; 07447000 T 0417 + PROCEDURE GRTR ; % GREATER THAN 07448000 T 0417 + BEGIN 07449000 T 0417 + LABEL OC; 07450000 T 0417 + START OF SEGMENT ********** 42 + ADJ(1,1); 07451000 T 0000 + NOTOPERAND; 07452000 T 0001 + C:=B; 07453000 T 0010 + B:=REAL(B>A); 07454000 T 0010 + IF (AX.TAG=DOUBL OR BX.TAG=DOUBL) AND (C=A) THEN 07455000 T 0012 + BEGIN 07456000 T 0015 + IF AX.TAG≠DOUBL THEN X:=XX:=0 ELSE 07457000 T 0016 + IF BX.TAG≠DOUBL THEN Y:=YX:=0; 07458000 T 0019 + B:= REAL(Y>X); 07459000 T 0022 + END; 07460000 T 0024 + BX.[44:4 ]:= REAL(AROF:=FALSE); 07461000 T 0024 + OC: 07462000 T 0026 + END GRTR; 07463000 T 0027 + 42 IS 28 LONG, NEXT SEG 12 + PROCEDURE GREQ ; % GREATER THAN OR EQUAL 07464000 T 0417 + BEGIN 07465000 T 0417 + LABEL OC; 07466000 T 0417 + START OF SEGMENT ********** 43 + ADJ(1,1); 07467000 T 0000 + NOTOPERAND; 07468000 T 0001 + C:=B; 07469000 T 0010 + B:=REAL(B≥A); 07470000 T 0010 + IF (AX.TAG=DOUBL OR BX.TAG=DOUBL) AND (C=A) THEN 07471000 T 0012 + BEGIN 07472000 T 0015 + IF AX.TAG≠DOUBL THEN X:=XX:=0 ELSE 07473000 T 0016 + IF BX.TAG≠DOUBL THEN Y:=YX:=0; 07474000 T 0019 + B:=REAL(Y≥X); 07475000 T 0022 + END; 07476000 T 0024 + BX.[44:4 ]:= REAL(AROF:=FALSE); 07477000 T 0024 + OC: 07478000 T 0026 + END GREQ; 07479000 T 0027 + 43 IS 28 LONG, NEXT SEG 12 + PROCEDURE EQUL ; % EQUAL 07480000 T 0417 + BEGIN 07481000 T 0417 + LABEL OC; 07482000 T 0417 + START OF SEGMENT ********** 44 + ADJ(1,1); 07483000 T 0000 + NOTOPERAND; 07484000 T 0001 + B:=REAL(B=A); 07485000 T 0010 + IF(AX.TAG=DOUBL OR BX.TAG=DOUBL) AND BOOLEAN(B) THEN 07486000 T 0011 + BEGIN 07487000 T 0014 + IF AX.TAG≠DOUBL THEN X:=XX:=0 ELSE 07488000 T 0015 + IF BX.TAG≠DOUBL THEN Y:=YX:=0; 07489000 T 0018 + B:=REAL(Y=X); 07490000 T 0021 + END; 07491000 T 0022 + BX.[44:4 ]:= REAL(AROF:=FALSE); 07492000 T 0022 + OC: 07493000 T 0025 + END EQUL; 07494000 T 0025 + 44 IS 26 LONG, NEXT SEG 12 + PROCEDURE LSEQ ; % LESS THAN OR EQUAL 07495000 T 0417 + BEGIN 07496000 T 0417 + LABEL OC; 07497000 T 0417 + START OF SEGMENT ********** 45 + ADJ(1,1); 07498000 T 0000 + NOTOPERAND; 07499000 T 0001 + C:=B; 07500000 T 0010 + B:=REAL(B≤A); 07501000 T 0010 + IF (AX.TAG=DOUBL OR BX.TAG=DOUBL) AND (C=A) THEN 07502000 T 0012 + BEGIN 07503000 T 0015 + IF AX.TAG≠DOUBL THEN X:=XX:=0 ELSE 07504000 T 0016 + IF BX.TAG≠DOUBL THEN Y:=YX:=0; 07505000 T 0019 + B:=REAL(Y≤X); 07506000 T 0022 + END; 07507000 T 0024 + BX.[44:4 ]:= REAL(AROF:=FALSE); 07508000 T 0024 + OC: 07509000 T 0026 + END LSEQ; 07510000 T 0027 + 45 IS 28 LONG, NEXT SEG 12 + PROCEDURE LESS ; % LESS THAN 07511000 T 0417 + BEGIN 07512000 T 0417 + LABEL OC; 07513000 T 0417 + START OF SEGMENT ********** 46 + ADJ(1,1); 07514000 T 0000 + NOTOPERAND; 07515000 T 0001 + C:=B; 07516000 T 0010 + B:=REAL(B MEMMODS %LOAD 07594100 T 0072 + THEN BEGIN 07594200 T 0073 + SETINTERRUPT (INVADRI); 07594300 T 0074 + GO OC 07594400 T 0075 + END; 07594500 T 0075 + MOVE(M[MM],A); MEMCYCLE; 07595000 T 0077 + CASE AX.TAG OF 07596000 T 0082 + BEGIN 07597000 T 0083 +PRT(727) = *CASE STATEMENT DESCRIPTOR* + ; % SINGLE PRECISION OPERAND 07598000 T 0083 + ; % IRW 07599000 T 0083 + BEGIN MOVE (M[MM+1], X); MEMCYCLE END; % DOUBLE PRECISION 07600000 T 0083 + INVALIDOPERATORINTERRUPT; % TAG=3 S.D MSCW RCW 07601000 T 0089 + ; %UNASSIGNED 07602000 T 0092 + % D A T A D E S C R I P T O R 07603000 T 0092 + BEGIN 07603100 T 0092 + IF (AX.PBIT=0 AND A.CBIT=0) THEN 07604000 T 0092 + A.ADDR ← MM; A.CBIT ← 1 END; 07605000 T 0095 + ; %UNINITIALIZED OPERAND 07606000 T 0099 + INVALIDOPERATORINTERRUPT; % PROGRAM CONTROL WORD 07607000 T 0099 + END; 07608000 T 0102 + START OF SEGMENT ********** 50 + 50 IS 8 LONG, NEXT SEG 48 + OC: 07609000 T 0102 + END LOAD; 07610000 T 0103 + 48 IS 104 LONG, NEXT SEG 12 + PROCEDURE LODT ; % LOAD TRANSPARENT 07611000 T 0421 + BEGIN 07612000 T 0421 + LABEL OC; 07613000 T 0421 + START OF SEGMENT ********** 51 + ADJ(1,2); 07614000 T 0000 + MOVE(A,C); MM← C.ADDR; 07615000 T 0001 + CASE CX.TAG OF 07616000 T 0003 + BEGIN 07617000 T 0004 +PRT(730) = *CASE STATEMENT DESCRIPTOR* + ; % SINGLE PRECISION OPERAND 07618000 T 0004 + IF NOT BOOLEAN(C.EBIT) THEN % NORMAL IRW 07619000 T 0004 + MM← D[LEVEL(C)] + DELTA(C) 07620000 T 0005 + ELSE BEGIN % STUFFED IRW 07621000 T 0007 + IF SNR=C.STKNR THEN TEMP← BOSR 07622000 T 0009 + ELSE BEGIN 07623000 T 0010 + MOVE(M[D0+2],C); MEMCYCLE; 07624000 T 0012 + IF NOT BOOLEAN(CX.PBIT) THEN 07625000 T 0018 + PRESENCEBITINTERRUPT; 07626000 T 0019 + IF C.LENGTH < A.STKNR THEN 07627000 T 0022 + INVALIDINDEXINTERRUPT; 07628000 T 0023 + MOVE(M[C.ADDR+A.STKNR],C); MEMCYCLE; 07629000 T 0027 + IF NOT BOOLEAN(CX.PBIT) THEN 07630000 T 0033 + PRESENCEBITINTERRUPT; 07631000 T 0034 + TEMP← C.ADDR; 07632000 T 0038 + END; 07633000 T 0039 + MM← A.DISP + A.[35:13] + TEMP; 07634000 T 0039 + END; 07635000 T 0042 + ; % DOUBLE PRESESION OPERAND 07636000 T 0042 + ; % TAG = 3 S.D. MSCW RCW 07637000 T 0042 + ; % UNASSIGNED 07638000 T 0042 + % D A T A D E S C R I P T O R 07639000 T 0042 + IF NOT BOOLEAN(CX.PBIT) THEN PRESENCEBITINTERRUPT 07640000 T 0042 + ELSE IF BOOLEAN(C.IBIT) THEN MM← C.ADDR + C.LENGTH; 07641000 T 0047 + ; % UNINITIALIZED OPERAND 07642000 T 0051 + ; % PROGRAM CONTROL WORD 07643000 T 0051 + END; 07644000 T 0051 + START OF SEGMENT ********** 52 + 52 IS 8 LONG, NEXT SEG 51 + IF MM + MM > MEMMODS THEN SETINTERRUPT (INVADRI) ELSE % LODT 07644900 T 0051 + MOVE(M[MM],A); MEMCYCLE; 07645000 T 0054 + OC: 07646000 T 0061 + END LODT; 07647000 T 0062 + 51 IS 63 LONG, NEXT SEG 12 + PROCEDURE EXCH ; % EXCHANGE 07648000 T 0421 + BEGIN 07649000 T 0421 + REAL T1,T2; 07650000 T 0421 + START OF SEGMENT ********** 53 +STACK(F+2) = T1 +STACK(F+3) = T2 + ADJ(1,1); 07651000 T 0000 + MOVE(A,T1); 07652000 T 0001 + MOVE(B,A); 07653000 T 0002 + MOVE(T1,B); 07654000 T 0003 + MOVE(X,T1); 07655000 T 0004 + MOVE(Y,X); 07656000 T 0005 + MOVE(T1,Y); 07657000 T 0006 + END EXCH; 07658000 T 0007 + 53 IS 10 LONG, NEXT SEG 12 + PROCEDURE RSDN ; % ROTATE STACK DOWN 07659000 T 0421 + BEGIN 07660000 T 0421 + ADJ(1,1); 07661000 T 0421 + MOVE(B,C); 07662000 T 0422 + MOVE(Y,AA); 07663000 T 0423 + BROF:=FALSE; 07664000 T 0424 + ADJ(1,1); 07665000 T 0424 + EXCH; 07666000 T 0425 + ADJ(1,0); 07667000 T 0426 + MOVE(C,B); 07668000 T 0427 + BROF←TRUE; 07669000 T 0428 + MOVE(C,B); 07670000 T 0429 + MOVE(AA,Y); 07671000 T 0430 + EXCH; 07672000 T 0431 + AROF←TRUE; 07673000 T 0431 + END RSDN; 07674000 T 0432 + PROCEDURE RSUP ; % ROTATE STACK UP 07675000 T 0432 + BEGIN 07676000 T 0432 + ADJ(1,1); 07677000 T 0432 + MOVE(A,C); 07678000 T 0434 + MOVE(X,AA); 07679000 T 0435 + AROF:=FALSE; 07680000 T 0436 + ADJ(1,1); 07681000 T 0436 + EXCH; 07682000 T 0437 + ADJ(1,0); 07683000 T 0438 + MOVE(C,B); 07684000 T 0439 + MOVE(AA,Y); 07685000 T 0440 + BROF:=TRUE; 07686000 T 0441 + END RSUP; 07687000 T 0442 + PROCEDURE DUPL ; % DUPLICATE TOP OF STACK 07688000 T 0442 + BEGIN 07689000 T 0442 + ADJ(0,1); 07690000 T 0442 + MOVE(B,A); 07691000 T 0444 + MOVE(Y,X); 07692000 T 0445 + AROF:=TRUE; 07693000 T 0446 + END DUPL; 07694000 T 0446 + PROCEDURE DLET ; % DELETE TOP OF STACK 07695000 T 0447 + BEGIN 07696000 T 0447 + ADJ(1,2); 07697000 T 0447 + AROF:=FALSE; 07698000 T 0448 + END DLET; 07699000 T 0448 + PROCEDURE MVST ; % MOVE STACK 07700000 T 0449 + BEGIN 07701000 T 0449 + ERVSFLOW(11); 07702000 T 0449 + END MVST; 07703000 T 0449 + PROCEDURE PUSH ; % PUSH DOWN STACK REGISTERS 07704000 T 0450 + BEGIN 07705000 T 0450 + ADJ(0,0); 07706000 T 0450 + END PUSH; 07707000 T 0451 + PROCEDURE STOD ; % STORE DESTRUCTIVE 07708000 T 0451 + BEGIN 07709000 T 0451 + STORE(0); 07710000 T 0451 + END STOD; 07711000 T 0452 + PROCEDURE STON ; % STORE NON-DESTRUCTIVE 07712000 T 0453 + BEGIN 07713000 T 0453 + STORE(1); 07714000 T 0453 + END STON; 07715000 T 0453 + PROCEDURE OVRD ; % OVERWRITE DESTRUCTIVE 07716000 T 0454 + BEGIN 07717000 T 0454 + STORE(2); 07718000 T 0454 + END OVRD; 07719000 T 0454 + PROCEDURE OVRN ; % OVERWRITE NON-DESTRUCTIVE 07720000 T 0455 + BEGIN 07721000 T 0455 + STORE(3); 07722000 T 0455 + END OVRN; 07723000 T 0455 + BOOLEAN PROCEDURE GETSYLLABLES (N);% UTILITY FOR FLTR, ISOL AND INSR. 07724000 T 0456 +PRT(731) = GETSYLLABLES + VALUE N; INTEGER N; 07725000 T 0456 + BEGIN 07726000 T 0456 + DEFINE S = TBUF#; 07727000 T 0456 + START OF SEGMENT ********** 54 + INTEGER I,T,J; 07728000 T 0000 +STACK(F+3) = I +STACK(F+4) = T +STACK(F+5) = J + BOOLEAN B; 07729000 T 0000 +STACK(F+6) = B + LABEL OC; 07729100 T 0000 + DO BEGIN 07730000 T 0000 + T ← S [I] ← IF PROF THEN SYLLABLES [PSR] 07731000 T 0000 + ELSE PSYLLABLES; 07732000 T 0001 + J←IF I=N-1 THEN 48 ELSE 47; 07733000 T 0003 + IF B←T>J 07734000 T 0007 + THEN BEGIN INTFAMB(2); GO OC END; 07735000 T 0007 + STEPPSR (1); 07736000 T 0010 + END UNTIL I ← I + 1 ≥ N OR B; 07737000 T 0010 + GETSYLLABLES ← B; 07738000 T 0013 + OC: 07738100 T 0014 + END GETSYLLABLES; 07739000 T 0015 + 54 IS 19 LONG, NEXT SEG 12 + STREAM PROCEDURE MOVEN (S, D, N); VALUE N; 07740000 T 0456 +PRT(732) = MOVEN + BEGIN SI ← S; DI ← D; DS←N WDS END MOVE OF N WORDS FROM S TO D; 07741000 T 0456 + BOOLEAN PROCEDURE GETGKL (N); % UTILITY FOR DFTR, DISO AND DINS. 07742000 T 0457 +PRT(733) = GETGKL + VALUE N; INTEGER N; 07743000 T 0457 + BEGIN 07744000 T 0457 + DEFINE GKL = TBUF#; % MOMENTARY STORAGE 07745000 T 0457 + START OF SEGMENT ********** 55 + INTEGER I,J; 07746000 T 0000 +STACK(F+3) = I +STACK(F+4) = J + BOOLEAN BOOLE; 07747000 T 0000 +STACK(F+5) = BOOLE + LABEL OC; 07747100 T 0000 + J←48; 07748000 T 0000 + DO BEGIN 07749000 T 0000 + ADJ (0, 1); 07750000 T 0000 + IF BOOLE←INTEGERIZE(TRUE,B) OR B<0 OR B>J 07751000 T 0001 + THEN BEGIN INTFAMB(3); GO OC END 07752000 T 0004 + ELSE GKL [I] ← B; 07753000 T 0007 + BROF ← FALSE; 07754000 T 0008 + J←47; 07755000 T 0009 + END UNTIL I ← I + 1 ≥ N OR BOOLE; 07756000 T 0010 + GETGKL ← BOOLE; 07757000 T 0013 + OC: 07757100 T 0013 + END VALIDATION OF OPERANDS FOR DYNAMIC FIELD OPERATORS; 07758000 T 0014 + 55 IS 17 LONG, NEXT SEG 12 + PROCEDURE FLTR ; % FIELD TRANSFER 07759000 T 0457 + BEGIN 07760000 T 0457 + DEFINE S = TBUF#; 07761000 T 0457 + START OF SEGMENT ********** 56 + INTEGER K, G, L; 07762000 T 0000 +STACK(F+2) = K +STACK(F+3) = G +STACK(F+4) = L + IF NOT GETSYLLABLES (3) 07763000 T 0000 + THEN BEGIN 07764000 T 0000 + ADJ (1, 1); 07765000 T 0001 + MOVEN (S[0], K, 3); % SYLLABLES TO LOCALS 07766000 T 0002 + DYAL (A, B, G, K, L); % B.[K:L]; ← A.[G:L] 07767000 T 0004 + AROF ← FALSE; 07768000 T 0005 + END; 07769000 T 0006 + END FLTR; 07770000 T 0006 + 56 IS 9 LONG, NEXT SEG 12 + PROCEDURE DFTR ; % DYNAMIC FIELD TRANSFER 07771000 T 0457 + BEGIN 07772000 T 0457 + DEFINE LGK = TBUF#; 07773000 T 0457 + START OF SEGMENT ********** 57 + INTEGER L, G, K; % DO NOT DISTURB G, K, OR L 07774000 T 0000 +STACK(F+2) = L +STACK(F+3) = G +STACK(F+4) = K + IF NOT GETGKL (3) % STACK ADJUST AND VALIDITY 07775000 T 0000 + THEN BEGIN 07776000 T 0000 + ADJ (1, 1); 07777000 T 0001 + MOVEN (LGK [0], L, 3); % OPERANDS TO LOCALS 07778000 T 0002 + DYAL (A, B, G, K, L); % B.[K:L] ← A.[G,L] 07779000 T 0004 + AROF ← FALSE; 07780000 T 0005 + END; 07781000 T 0006 + END DFTR; 07782000 T 0006 + 57 IS 9 LONG, NEXT SEG 12 + PROCEDURE ISOL ; % FIELD ISOLATE 07783000 T 0457 + BEGIN 07784000 T 0457 + DEFINE S = TBUF#; 07785000 T 0457 + START OF SEGMENT ********** 58 + INTEGER G, L, K ; % DO NOT DISTURB G AND L 07786000 T 0000 +STACK(F+2) = G +STACK(F+3) = L +STACK(F+4) = K + IF NOT GETSYLLABLES (2) 07787000 T 0000 + THEN BEGIN 07788000 T 0000 + ADJ (1, 0); 07789000 T 0001 + MOVEN (S[0], G, 2); % SYLLABLES TO LOCALS 07790000 T 0002 + K ← L - 1; 07791000 T 0004 + B ← BX ← 0; 07792000 T 0005 + DYAL (A, B, G, K, L); % B.[K:L] ← A.[G:L] 07793000 T 0006 + AROF ← FALSE; 07794000 T 0008 + BROF ← TRUE; 07795000 T 0009 + END; 07796000 T 0009 + END ISOL; 07797000 T 0009 + 58 IS 12 LONG, NEXT SEG 12 + PROCEDURE DISO ; % DYNAMIC FIELD ISOLATE 07798000 T 0457 + BEGIN 07799000 T 0457 + DEFINE LG = TBUF#; 07800000 T 0457 + START OF SEGMENT ********** 59 + INTEGER L, G, K; % DO NOT DISTURB L AND G 07801000 T 0000 +STACK(F+2) = L +STACK(F+3) = G +STACK(F+4) = K + IF NOT GETGKL (2) % STACK ADJ & VALIDITY CHECK 07802000 T 0000 + THEN BEGIN 07803000 T 0000 + AROF ← TRUE; % GETGKL SETS FALSE; 07804000 T 0001 + MOVEN (LG[0], L, 2); % OPERANDS TO LOCALS 07805000 T 0002 + K ← L - 1; 07806000 T 0003 + A ← AX ← 0; 07807000 T 0005 + ADJ(1,1); 07808000 T 0006 + DYAL (B, A, G, K, L); % A.[K:L] ← B.[G:L] 07809000 T 0007 + BROF ← FALSE; 07810000 T 0009 + END; 07811000 T 0009 + END DISO; 07812000 T 0009 + 59 IS 12 LONG, NEXT SEG 12 + PROCEDURE INSR ; % FIELD INSERT 07813000 T 0457 + BEGIN 07814000 T 0457 + INTEGER K, L; % DO NOT DISTURB ORDER OF K AND L 07815000 T 0457 + START OF SEGMENT ********** 60 +STACK(F+2) = K +STACK(F+3) = L + DEFINE S = TBUF#; % ALSO SEE GETSYLLABLES 07816000 T 0000 + IF NOT GETSYLLABLES (2) 07817000 T 0000 + THEN BEGIN 07818000 T 0000 + ADJ (1, 1); 07819000 T 0001 + MOVEN (S[0], K, 2); % SYLLABLES TO LOCALS 07820000 T 0002 + G ← L - 1; 07821000 T 0004 + DYAL (A, B, G, K, L); % B.[K:L] ← A.[G:L]; 07822000 T 0005 + AROF ← FALSE; 07823000 T 0007 + END; 07824000 T 0007 + END INSR; 07825000 T 0007 + 60 IS 10 LONG, NEXT SEG 12 + PROCEDURE DINS ; % DYNAMIC FIELD INSERT 07826000 T 0457 + BEGIN 07827000 T 0457 + DEFINE LK = TBUF#; 07828000 T 0457 + START OF SEGMENT ********** 61 + INTEGER L, K, G; % DO NOT DISTURB ORDER 07829000 T 0000 +STACK(F+2) = L +STACK(F+3) = K +STACK(F+4) = G + ADJ (1, 1); % SAVE A WHILE L & K ARE& 07830000 T 0000 + AROF ← FALSE; 07831000 T 0001 + IF NOT GETGKL (2) 07832000 T 0001 + THEN BEGIN 07833000 T 0002 + ADJ (0, 1); 07834000 T 0003 + % AROF ← TRUE; 07835000 T 0004 + MOVEN (LK[0], L, 2); % L AND K TO LOCALS 07836000 T 0004 + G ← L - 1; 07837000 T 0005 + DYAL (A, B, G, K, L); % B.[K:L] ← A.[G:L] 07838000 T 0007 + % AROF ← FALSE; 07839000 T 0008 + END; 07840000 T 0008 + END DINS; 07841000 T 0008 + 61 IS 11 LONG, NEXT SEG 12 + PROCEDURE SRCH ; % MASKED SEARCH FOR EQUAL 07842000 T 0457 + BEGIN 07843000 T 0457 + BOOLEAN FINIS; 07844000 T 0457 + START OF SEGMENT ********** 62 +STACK(F+2) = FINIS + LABEL OC,LOOP,JUMP; 07845000 T 0000 + ADJ (1, 1); % DESCRIPTOR AND MASK 07846000 T 0000 + IF AX.TAG ≠ DATADESC 07847000 T 0001 + THEN BEGIN 07848000 T 0002 + SETINTERRUPT (INVOP); 07849000 T 0002 + GO OC; 07850000 T 0003 + END; 07851000 T 0005 + IF AX.PBIT≠1 THEN BEGIN SETINTERRUPT(PRESBIT); GO OC END; 07852000 T 0005 + MOVE (A, C); 07853000 T 0009 + AROF ← FALSE; 07854000 T 0010 + ADJ (1, 1); % MASK AND VALUE 07855000 T 0010 + MOVE (A, X); 07856000 T 0011 + IF C.LENGTH=0 THEN GO JUMP; 07857000 T 0012 + LOOP: 07858000 T 0014 + C.LENGTH ← C.LENGTH - 1; 07859000 T 0015 + JUMP: 07860000 T 0017 + MOVE (M[C.ADDR + C.LENGTH], A); 07861000 T 0018 + MEMCYCLE; 07862000 T 0023 + A ← REAL (BOOLEAN (A) AND BOOLEAN (X)); 07863000 T 0024 + AX ← REAL(BOOLEAN(AX) AND BOOLEAN (XX)); 07864000 T 0026 + FINIS ← EQUAL (A, AX, B, BX); 07865000 T 0027 + IF C.LENGTH≠0 AND (NOT FINIS) THEN GO LOOP; 07866000 T 0029 + IF (NOT FINIS) THEN A←1 ELSE A←0&C[28:8:20]; 07867000 T 0032 + AX ← 0; 07868000 T 0036 + BROF←FALSE; 07869000 T 0036 + OC: 07870000 T 0037 + END SRCH; 07871000 T 0038 + 62 IS 41 LONG, NEXT SEG 12 + PROCEDURE LLLU ; % LINKED LIST LOOKUP 07872000 T 0457 + BEGIN 07873000 T 0457 + LABEL OC,LOOP,NEG; 07874000 T 0457 + START OF SEGMENT ********** 63 + INTEGER PSEUDOA, PSEUDOC; % TO EXPEDITE FLAG BIT TESTING 07875000 T 0000 +STACK(F+2) = PSEUDOA +STACK(F+3) = PSEUDOC + ADJ (1, 1); % INDEX AND DATA DESCRIPTOR 07876000 T 0000 + IF INTEGERIZE (TRUE, A) 07877000 T 0001 + THEN BEGIN SETINTERRUPT (INTOVFI); GO OC; END; 07878000 T 0001 + IF BX.TAG ≠ DATADESC 07879000 T 0005 + THEN BEGIN SETINTERRUPT (INVOP); GO OC END; 07880000 T 0006 + BUF ← B.ADDR; 07881000 T 0009 + X ← A & B [8:8:20]; % INITIAL INDEX AND SIZE 07882000 T 0010 + BROF ← FALSE; 07883000 T 0012 + ADJ (1, 1); % INDEX AND ARGUMENT 07884000 T 0012 + MOVE (A, C); 07885000 T 0013 + PSEUDOA ← B.[20:28]; % ARGUMENT TO A 07886000 T 0014 + LOOP: IF A.ADDR > X.LENGTH 07887000 T 0016 + THEN BEGIN SETINTERRUPT (INVINXI);GO OC END; 07888000 T 0016 + MOVE (M[BUF + A.ADDR], C); % NEW LINK WORD TO C 07889000 T 0021 + PSEUDOC ← 0 &C[21:1:27] 07890000 T 0026 + &CX[20:47:1]; 07891000 T 0027 + MEMCYCLE; 07892000 T 0028 + IF PSEUDOA > PSEUDOC 07893000 T 0030 + THEN BEGIN 07894000 T 0030 + X.ADDR ← A.ADDR; % SAVE THIS INDEX 07895000 T 0031 + A.ADDR ← C.ADDR; 07896000 T 0033 + IF(A.ADDR=0)THEN BEGIN A←-1; GO NEG END; 07897000 T 0035 + GO LOOP; 07898000 T 0039 + END; 07899000 T 0039 + A ← X.ADDR; 07900000 T 0039 + NEG: 07901000 T 0040 + AX ← 0; 07902000 T 0041 + BROF ← FALSE; 07903000 T 0041 + OC: 07904000 T 0042 + END LLLU; 07905000 T 0043 + 63 IS 46 LONG, NEXT SEG 12 + PROCEDURE ZERO ; % LIT CALL ZERO 07906000 T 0457 + BEGIN 07907000 T 0457 + ADJ(0,2); 07908000 T 0457 + AX.[44:4]:=A:=0; 07909000 T 0459 + AROF:=TRUE; 07910000 T 0461 + END ZERO; 07911000 T 0462 + PROCEDURE ONE ; % LIT CALL ONE 07912000 T 0462 + BEGIN 07913000 T 0462 + ZERO; 07914000 T 0462 + A:=1; 07915000 T 0463 + END ONE ; 07916000 T 0464 + PROCEDURE LT8 ; % LIT CALL 8 BITS 07917000 T 0464 + BEGIN 07918000 T 0464 + ZERO; 07919000 T 0464 + A:=SYLLABLE; 07920000 T 0465 + STEPPSR(1); 07921000 T 0468 + END LT8; 07922000 T 0469 + PROCEDURE LT16 ; % LIT CALL 16 BITS 07923000 T 0469 + BEGIN 07924000 T 0469 + ZERO; 07925000 T 0469 + A.[32:8]:=SYLLABLE; 07926000 T 0470 + STEPPSR(1); 07927000 T 0474 + A.[40:8]:=SYLLABLE; 07928000 T 0475 + STEPPSR(1); 07929000 T 0478 + END LT16; 07930000 T 0479 + PROCEDURE LT48 ; % LIT CALL 48 BITS 07931000 T 0479 + BEGIN 07932000 T 0479 + REAL T1,T2; 07933000 T 0479 + START OF SEGMENT ********** 64 +STACK(F+2) = T1 +STACK(F+3) = T2 + ZERO; 07934000 T 0000 + IF PSR≠0 THEN STEPPSR(6-PSR); T1←SYLLABLE; 07935000 T 0000 + A:=P; 07936000 T 0005 + AX:=PX.PBIT; 07937000 T 0006 + STEPPSR(6); 07938000 T 0007 + END LT48; 07939000 T 0008 + 64 IS 11 LONG, NEXT SEG 12 + PROCEDURE MPCW ; % MAKE PROGRAM CONTROL WORD 07940000 T 0479 + BEGIN 07941000 T 0479 + LT48; 07942000 T 0479 + AX.TAG ← PCW; 07943000 T 0480 + END LPCW; 07944000 T 0482 + PROCEDURE BITSET; % UTILITY FOR BIT SETTING OPERATORS 07945000 T 0482 +PRT(734) = BITSET + BEGIN 07946000 T 0482 + INTEGER Z10, Z10X; % Z10X - SAFE IN DYALS 07947000 T 0482 + START OF SEGMENT ********** 65 +STACK(F+2) = Z10 +STACK(F+3) = Z10X + Z10 ← T.[44:1] + 1; % NEGATE BIT 3 OF OPERATOR 07948000 T 0000 + DYAL (Z10, B, 0, C, 1); 07949000 T 0001 + END BITSET; 07950000 T 0003 + 65 IS 6 LONG, NEXT SEG 12 + PROCEDURE BSET ; % BIT SET 07951000 T 0482 + BEGIN 07952000 T 0482 + BRST ; 07953000 T 0482 + END BSET; 07954000 T 0483 + PROCEDURE DBST ; % DYNAMIC BIT SET 07955000 T 0483 + BEGIN 07956000 T 0483 + DBRS; 07957000 T 0483 + END DBST; 07958000 T 0484 + PROCEDURE BRST ; % BIT RESET 07959000 T 0484 + BEGIN 07960000 T 0484 + C ← PSYLLABLES; 07961000 T 0484 + STEPPSR (1); 07962000 T 0486 + IF C > 47 THEN INTFAMB(2) ELSE BEGIN 07962100 T 0486 + ADJ (0, 1); 07963000 T 0489 + BITSET; 07964000 T 0490 + END; 07964100 T 0490 + END BRST; 07965000 T 0490 + PROCEDURE DBRS ; % DYNAMIC BIT RESET 07966000 T 0491 + BEGIN 07967000 T 0491 + ADJ (0, 1); 07968000 T 0491 + IF INTEGERIZE (TRUE, B) OR B < 0 OR B > 47 07969000 T 0492 + THEN INTFAMB(3) 07970000 T 0494 + ELSE BEGIN 07971000 T 0495 + MOVE (B, C); 07972000 T 0496 + BROF ← FALSE; 07973000 T 0497 + ADJ (0, 1); 07974000 T 0498 + BITSET; 07975000 T 0499 + END; 07976000 T 0500 + END DBRS; 07977000 T 0500 + PROCEDURE CHSN ; % CHANGE SIGN BIT 07978000 T 0500 + BEGIN 07979000 T 0500 + ADJ(1,2); 07980000 T 0500 + CHECOPRNDA END; 07981000 T 0502 + A.SOBIT← REAL(NOT BOOLEAN(A.SOBIT)); 07982000 T 0506 + END CHSN; 07983000 T 0508 + PROCEDURE CBON ; % COUNT BINARY ONES 07984000 T 0510 + BEGIN 07985000 T 0510 + INTEGER STREAM PROCEDURE COUNT (W); 07986000 T 0510 + START OF SEGMENT ********** 66 +PRT(735) = COUNT + BEGIN 07987000 T 0000 + SI ← W; 47 (SKIP SB; IF SB THEN TALLY ← TALLY + 1); 07988000 T 0000 + COUNT ← TALLY; 07989000 T 0001 + END; 07990000 T 0002 + CHECOPRNDA END; 07991000 T 0003 + AA←COUNT(A)+AX.PBIT; 07992000 T 0007 + IF AX.TAG=DOUBL THEN 07993000 T 0010 + AA←COUNT(X)+XX.PBIT+AA; 07994000 T 0011 + AX ← 0; 07995000 T 0015 + A←AA; 07996000 T 0015 + END CBON; 07997000 T 0016 + 66 IS 18 LONG, NEXT SEG 12 + PROCEDURE LOG2; % LEADING ONE TEST LOG2 07998000 T 0510 + BEGIN 07999000 T 0510 + INTEGER STREAM PROCEDURE LEADING (ONE); 08000000 T 0510 + START OF SEGMENT ********** 67 +PRT(736) = LEADING + BEGIN 08001000 T 0000 + SI ← ONE; 08002000 T 0000 + 47 (SKIP SB; IF SB THEN JUMP OUT ELSE TALLY ← TALLY + 1); 08003000 T 0000 + LEADING ← TALLY; 08004000 T 0003 + END LEADING; 08005000 T 0003 + ADJ(0,1); 08006000 T 0004 + B←IF BOOLEAN(BX) THEN 48 ELSE 47-LEADING(B); 08007000 T 0006 + BX←0; 08008000 T 0009 + END LOG2; 08009000 T 0010 + 67 IS 11 LONG, NEXT SEG 12 + PROCEDURE STAG ; % SET TAG FIELD 08010000 T 0510 + BEGIN 08011000 T 0510 + ADJ(1,1); 08012000 T 0510 + BX.TAG:=A.[45:3]; 08013000 T 0511 + AROF:=FALSE; 08014000 T 0513 + END STAG; 08015000 T 0514 + PROCEDURE RTAG ; % READ TAG FIELD 08016000 T 0514 + BEGIN 08017000 T 0514 + ADJ(1,2); 08018000 T 0514 + A:=0&AX[45:44:3]; 08019000 T 0516 + AX.[44:4]:=0; 08020000 T 0517 + END RTAG; 08021000 T 0519 + PROCEDURE SINT ; % SET INTERVAL TIMER 08022000 T 0519 + BEGIN 08023000 T 0519 + ADJ (1, 2); % TEMPORARY NO FLOWS 08024000 T 0519 + INTTIMER ← (INTTIMER ← A + .5).[37:11] × 5000 + REALTIME; 08025000 T 0521 + AX ← 0; 08026000 T 0524 + AROF ← FALSE; 08027000 T 0525 + IF INTTIMER < IDLETIME OR IDLETIME = 0 THEN IDLETIME←INTTIMER; 08028000 T 0525 + END SINT; 08029000 T 0528 + PROCEDURE RDLK ; % READ WITH LOCK 08030000 T 0531 + BEGIN 08031000 T 0531 + STORE(7); 08032000 T 0531 + END RDLK; 08033000 T 0531 + PROCEDURE STFF ; % STUFF ENVIRONMENT 08034000 T 0532 + BEGIN 08035000 T 0532 + ERVSFLOW(18); 08036000 T 0532 + END STFF; 08037000 T 0532 + PROCEDURE WHOI ; % READ PROCESSOR IDENTIFICATION 08038000 T 0533 + BEGIN 08039000 T 0533 + ADJ (0,2); 08039500 T 0533 + A ← AX ← 0; 08040000 T 0534 + A ← PID; AROF ← TRUE; 08040500 T 0535 + END WHOI; 08041000 T 0536 + PROCEDURE EEXI ; % ENABLE EXTERNAL INTERRUPTS 08042000 T 0537 + BEGIN 08043000 T 0537 + IF IDLETIME ≥ REALTIME THEN REALTIME ← IDLETIME; 08043100 T 0537 + IIHF ← FALSE; 08044000 T 0539 + END EEXI; 08045000 T 0539 + PROCEDURE DEXI ; % DISABLE EXTERNAL IMTERRUPTS 08046000 T 0540 + BEGIN 08047000 T 0540 + IIHF ← TRUE; 08048000 T 0540 + END DEXI; 08049000 T 0540 + PROCEDURE IDLE ; % IDLE UNTIL INTERRUPT 08050000 T 0541 + BEGIN 08051000 T 0541 + IF NOT NCSF THEN SETINTERRUPT (INVOP) ELSE 08051100 T 0541 + IF IDLETIME ≥ REALTIME % TEMPORARY - NO FLOWS 08052000 T 0542 + THEN BEGIN 08053000 T 0545 + IF DISKLOAD > 0 08054000 T 0546 + THEN BEGIN 08055000 T 0546 + DISKLOAD ← -1 ; 08056000 T 0547 + INTTIMER ← IDLETIME ← CURRENTT ← 08057000 T 0548 + REALTIME ← 1 ; 08058000 T 0548 + END ; 08059000 T 0550 + REALTIME ← IDLETIME; 08060000 T 0550 + IDLETIME ← CURRENTT; 08061000 T 0551 + END 08062000 T 0552 + ELSE SETINTERRUPT (LOOPI); 08063000 T 0552 + END IDLE; 08064000 T 0553 + PROCEDURE HEYU ; % INTERRUPT OTHER PROCESSOR 08065000 T 0555 + BEGIN 08066000 T 0555 + PTPI ← 1; 08067000 T 0555 + END HEYU; 08068000 T 0556 + PROCEDURE RPRR ; % READ PROCESSOR REGISTER 08069000 T 0557 + BEGIN 08070000 T 0557 + INTEGER I, J, FREG, CHI, PREG, PREGX; 08070050 T 0557 + START OF SEGMENT ********** 68 +STACK(F+2) = I +STACK(F+3) = J +STACK(F+4) = FREG +STACK(F+5) = CHI +STACK(F+6) = PREG +STACK(F+7) = PREGX + LIST MONLIST(M[F+2].[6:6], M[F+2], CX.TAG, CHI, 08070100 T 0000 +PRT(737) = *LIST, LABEL, OR SEGMENT DESCRIPTOR* + C.[3:3],C.[6:3], C.[9:3], C.[12:3], C.[15:3], C.[18:3],C.[21:3] 08070200 T 0016 + ,C.[24:3],C.[27:3],C.[30:3],C.[33:3],C.[36:3],C.[39:3],C.[42:3] 08070300 T 0031 + ,C.[45:3], FOR J ← 0 STEP 1 UNTIL I DO MONITOROUTPUT [J]); 08070400 T 0049 +STACK(F+10) = MONLIST + ADJ (1, 2); 08071000 T 0061 + MOVE (A, C); 08072000 T 0062 + IF C = 64 % TO PROVIDE A MEANS OF 08073000 T 0063 + THEN A ← TRACTER % PRESERVING TRACTER 08074000 T 0064 + ELSE IF C =63 08074050 T 0064 + THEN BEGIN 08074100 T 0066 + IF PRINTERNOTYETOPENED 08074120 T 0067 + THEN BEGIN PRINTERNOTYETOPENED.[46:1] ← TRUE; HEADING END; 08074140 T 0067 + FREG ← F - M[F].DF; 08074150 T 0074 + MOVE (M[F+3], C); 08074200 T 0079 + CHI ← C.[1:2] & CX[45:47:1]; 08074250 T 0083 + WHILE I < 14 AND FREG > BOSR +2 DO 08074300 T 0085 + BEGIN 08074350 T 0088 + MOVE(M[FREG+1], PREG); 08074375 T 0088 + MONITOROUTPUT [I] ← PREG .SDIF; 08074400 T 0093 + MONITOROUTPUT[I←I+1] ← PREG .PIRF; 08074450 T 0094 + FREG ← FREG - M[FREG].DF; 08074500 T 0097 + I ← I + 1; 08074550 T 0102 + END; 08074600 T 0103 + I ← I - 1; 08074650 T 0104 + WRITE (TAPED, MONFMT, MONLIST); 08074700 T 0105 + END ELSE IF C = 62 THEN A ← IDLETIME ELSE IF C = 61 THEN A ← REALTIME 08074750 T 0108 + ELSE 08075000 T 0112 + IF C < 32 08076000 T 0113 + THEN A ← D [C.[43:5]] 08077000 T 0114 + ELSE IF C.[42:2] = 2 08078000 T 0116 + THEN BEGIN % THE MOVES ARE THE SIMULATORS 08079000 T 0118 + %"CORRECTING NETWORK" 08080000 T 0119 + MOVEN (PIR, IRSR, 8); 08081000 T 0119 + A ← IRSR [C.[45:3]]; 08082000 T 0120 + END 08083000 T 0122 + ELSE BEGIN 08084000 T 0122 + MOVEN (PBR, BRSR, 8); 08085000 T 0122 + A ← BRSR [C.[45:3]]; 08086000 T 0124 + END; 08087000 T 0125 + END RPRR; 08088000 T 0125 + 68 IS 129 LONG, NEXT SEG 12 + PROCEDURE SPRR ; % SET PROCESSOR REGISTER 08089000 T 0557 + BEGIN 08090000 T 0557 + ADJ (1, 1); 08091000 T 0557 + MOVE (B, C); 08092000 T 0558 + IF C = 64 % TO PROVIDE A MEANS OF SETTING 08093000 T 0559 + THEN TRACTER ← A % TRACTER 08094000 T 0559 + ELSE 08095000 T 0560 + IF C < 32 08096000 T 0561 + THEN D [C] ← A. ADDR 08097000 T 0561 + ELSE IF C.[42:2] = 2 08098000 T 0563 + THEN BEGIN % THE MOVENS ARE THE SIMULATORS 08099000 T 0565 + % "CORRECTING NETWORK 08100000 T 0566 + MOVEN (PIR, IRSR, 8); 08101000 T 0566 + IRSR [C.[45:3]] ← A.ADDR; 08102000 T 0568 + MOVEN (IRSR, PIR, 8); 08103000 T 0570 + END 08104000 T 0572 + ELSE BEGIN 08105000 T 0572 + MOVEN (PBR, BRSR, 8); 08106000 T 0572 + BRSR [C.[45:3]] ← A.ADDR; 08107000 T 0574 + MOVEN (BRSR, PBR, 8); 08108000 T 0576 + END; 08109000 T 0577 + AROF ← BROF ← FALSE; 08110000 T 0577 + END SPRR; 08111000 T 0579 + PROCEDURE SCNI ; % SCAN IN 08112000 T 0579 + BEGIN 08113000 T 0579 + DEFINE MBIT = MPXAB#, 08114000 T 0579 + START OF SEGMENT ********** 69 + HTYPE= MPXHDWE#, 08114050 T 0000 + Z = MPXFC#; 08114100 T 0000 + ADJ (1, 0); 08114200 T 0000 + Y ← 0; 08114300 T 0001 + CASE A.VARIF OF 08114400 T 0001 + BEGIN 08114500 T 0002 +PRT(740) = *CASE STATEMENT DESCRIPTOR* + BEGIN % IO PATH INTERROGATE 0 08114600 T 0003 + IF EVENTS [A.LUNIT].EVBUSY = 0 THEN % UNIT NOT BUSY 08114700 T 0003 + BEGIN 08114800 T 0005 + Y.LUNIT ← A.LUNIT; 08114810 T 0005 + IF MPX [1, A.LUNIT].HTYPE ≠ 0 % U CABLED TO MPA 08114900 T 0007 + AND MPXOPS [1] ≠ 0 % MPXA NOT LOADED 08115000 T 0010 + THEN BEGIN Y.Z ← 1; Y.MBIT ← 1 END; 08115100 T 0011 + IF A.Z = 2 THEN Y ← 0; 08115150 T 0015 + IF MPX [2, A.LUNIT].HTYPE ≠ 0 % U CABLED TO MPB 08115200 T 0018 + AND MPXOPS [2] ≠ 0 % MPXB NOT LOADED 08115300 T 0020 + THEN BEGIN Y.Z ← Y.Z + 2; Y.MBIT ← 1 END; 08115400 T 0021 + END 08115500 T 0027 + END PATH INTERROGATE; 08115600 T 0027 + BEGIN % READ STATUS WORD 1 08115700 T 0027 + IF A.LUNIT = 0 THEN Y ← STATUSWORD; 08115800 T 0027 + % ONLY ONE VECTOR IN SIMULATOR 08115900 T 0030 + % STATUSWORD BUILT INITIALLY AT CABLING TIME 08116000 T 0030 + END STATUS; 08116100 T 0030 + BEGIN % READ RESULT DESCRIPTOR 2 08116200 T 0030 + Y ← GETRESULT (A.Z); 08116300 T 0030 + END READ RESULT DESCRIPTOR; 08116500 T 0032 + Y ← ENTIER (TIMEOFDAY DIV 24); % TIME OF DAY 3 08116600 T 0033 + BEGIN % READ INTERRUPT MASK OR REGISTER 4 08116800 T 0035 + Y ← IF BOOLEAN (A.LUNIT) % READ MASK 08116900 T 0035 + THEN IF A.Z = 1 THEN INTMASKA ELSE INTMASKB 08117000 T 0036 + ELSE IF A.Z = 1 THEN INTREGA ELSE INTREGB; 08117100 T 0039 + END; 08117200 T 0043 + BEGIN % READ GCA 5 08117300 T 0044 + NOTYETCODED; 08117400 T 0044 + END; 08117500 T 0044 + BEGIN % INTERROGATE UNIT TYPE 6 08117600 T 0045 + IF BOOLEAN (A) 08117700 T 0045 + THEN Y ← MPX [A.Z, A.LUNIT].HTYPE 08117800 T 0045 + ELSE IF Y ← MPX [1, A.LUNIT].HTYPE = 0 08117900 T 0047 + THEN Y ← MPX [2, A.LUNIT].HTYPE; 08118000 T 0053 + END UNIT TYPE; 08118100 T 0057 + ; % 7 08118150 T 0058 + ; % 8 08118200 T 0058 + ; % 9 08118250 T 0058 + ; % 10 08118300 T 0058 + ; % 11 08118350 T 0058 + ; % 12 08118400 T 0058 + ; % 13 08118450 T 0058 + ; % 14 08118500 T 0058 + BEGIN % READ INTERRUPT LITERAL 15 08118550 T 0058 + BOOLEAN B; 08118560 T 0058 +PRT(741) = *SEGMENT DESCRIPTOR* + START OF SEGMENT ********** 70 +STACK(F+2) = B + INTEGER I, MPXI; 08118600 T 0000 +STACK(F+3) = I +STACK(F+4) = MPXI + REAL E; 08118605 T 0000 +STACK(F+5) = E + MPXI ←A.Z; 08118610 T 0000 + IF FIRSTEVENT [MPXI] ≤ REALTIME 08118630 T 0001 + AND FIRSTEVENT[MPXI] ≠0 08118640 T 0001 + THEN BEGIN 08118650 T 0002 + I ← FIRSTEVENTI[MPXI]; 08118660 T 0004 + Y ← MPX[MPXI, I].MPXINT; 08118670 T 0005 + B ← Y ≠0; 08118672 T 0007 + MPX [MPXI, I].MPXINT ← 0; 08118675 T 0008 + WHILE (E ← EVENTS[I]).EVTIME ≤ REALTIME 08118680 T 0011 + AND E ≠ 0 AND NOT B 08118685 T 0013 + DO BEGIN 08118690 T 0014 + IF E.EVMPX = MPXI 08118695 T 0016 + THEN BEGIN 08118700 T 0016 + Y ← MPX[MPXI,I].MPXINT; 08118705 T 0017 + B ← TRUE; 08118707 T 0018 + MPX[MPXI, I].MPXINT ←0; 08118710 T 0020 + END; 08118715 T 0022 + I ← E.EVLINK; 08118720 T 0024 + END 08118725 T 0025 + END 08118730 T 0025 + ELSE Y ← 0; 08118740 T 0025 + END; 08118750 T 0027 +PRT(742) = *SEGMENT DESCRIPTOR* + 70 IS 28 LONG, NEXT SEG 69 + END CASE; 08118800 T 0059 + START OF SEGMENT ********** 71 + 71 IS 16 LONG, NEXT SEG 69 + B ← Y; BX ← 0; 08118850 T 0059 + AROF ← FALSE; BROF ← TRUE; 08118900 T 0061 + END SCNI; 08119000 T 0062 + 69 IS 65 LONG, NEXT SEG 12 + PROCEDURE SCNO ; % SCAN OUT 08120000 T 0579 + BEGIN 08121000 T 0579 + DEFINE MBIT = MPXAB#, 08122000 T 0579 + START OF SEGMENT ********** 72 + Z = MPXFC#; 08122200 T 0000 + INTEGER T; 08122400 T 0000 +STACK(F+2) = T + ADJ (1, 1); 08123000 T 0000 + IF T ← A.VARIF = 4 OR T = 0 AND NOT NCSF 08124000 T 0001 + THEN SETINTERRUPT (INVOP) 08124300 T 0003 + ELSE CASE T OF 08124600 T 0005 + BEGIN 08124900 T 0008 +PRT(743) = *CASE STATEMENT DESCRIPTOR* + BEGIN% INITIATE I/O 0 08125000 T 0008 + MOVE (A, SCANBUSA); 08125300 T 0008 + MOVE (B, DATABUSA); 08125600 T 0009 + MULTIPLEX ← TRUE; 08125900 T 0010 + MOVE (B, DATABUSA); 08126000 T 0011 + END IIO; 08126300 T 0012 + ; % 1 08126600 T 0013 + ; % 2 08126900 T 0013 + TIMEOFDAY ← ENTIER (B × 24); % 3 08127000 T 0013 + IF A.Z = 1 THEN INTMASKA ← B ELSE INTMASKB ← B; % 4 08127300 T 0015 + NOTYETCODED; % SET GCA 5 08127600 T 0021 + END CASE; 08127900 T 0022 + START OF SEGMENT ********** 73 + 73 IS 6 LONG, NEXT SEG 72 + AROF ← BROF ← FALSE; 08128000 T 0022 + END SCNO; 08129000 T 0023 + 72 IS 26 LONG, NEXT SEG 12 + BOOLEAN SCANORXFER, XLATE, XFERWD, XFERW, SCANWH; 08130000 T 0579 +PRT(744) = SCANORXFER +PRT(745) = XLATE +PRT(746) = XFERWD +PRT(747) = XFERW +PRT(750) = SCANWH + 08131000 T 0579 + DEFINE QF01 = QP.[47:1]#, QF02 = QP.[46:1]#, QF03 = QP.[45:1]#, 08132000 T 0579 + QF04 = QP.[44:1]#, QH01 = QP.[43:1]#, QH02 = QP.[42:1]#, 08133000 T 0579 + QH03 = QP.[41:1]#, SPSF = QP.[40:1]#, SPRF = QP.[39:1]#, 08134000 T 0579 + DPSF = QP.[38:1]#, P2R2 = QP.[37:1]#, P2R3 = QP.[36:1]#, 08135000 T 0579 + P2R4 = QP.[35:1]#, FWDT = QP.[34:1]#, BKIP = QP.[33:1]#, 08136000 T 0579 + LHFF = QP.[32:1]#, XROF = QP.[31:1]#, SWPS = QP.[30:1]#; 08137000 T 0579 + DEFINE INVOPI = BEGIN SETINTERRUPT (INVOP); GO TO OC END#, 08138000 T 0579 + INTOFL = BEGIN SETINTERRUPT (INTOVFI); GO TO OC END#, 08139000 T 0579 + INVINX = BEGIN SETINTERRUPT (INVINXI); GO TO OC END#, 08140000 T 0579 + MEMPRO = BEGIN SETINTERRUPT (MEMPROI); GO TO OC END#, 08141000 T 0579 + PRESBI = BEGIN SETINTERRUPT (PRESBIT); GO TO OC END#, 08142000 T 0579 + JFIF = BEGIN 08143000 T 0579 + ADJ (0,0); BROF ← TRUE; AROF ← TRUE; 08144000 T 0579 + A ← AX ← 0; 08144500 T 0579 + B ← BX ← 0; SDIS ← 1; BKIP ← 1; 08145000 T 0579 + IF QF01 = 1 THEN B.[46:1] ← 1 ELSE 08146000 T 0579 + IF QF02 = 1 THEN B.[39:1] ← 1 ELSE 08147000 T 0579 + IF QF03 = 1 THEN B.[47:1] ← 1 ELSE 08148000 T 0579 + B.[37:1] ← 1; 08149000 T 0579 + IF P2R2 = 1 THEN A.[46:1] ← 1 ELSE 08150000 T 0579 + IF P2R3 = 1 THEN A.[46:2] ← 3 ELSE 08151000 T 0579 + A.[45:3] ← 4; 08152000 T 0579 + IF QF01 = 1 THEN INVOPI ELSE 08153000 T 0579 + IF QF02 = 1 THEN PRESBI ELSE 08154000 T 0579 + IF QF03 = 1 OR QF04 = 1 THEN MEMPRO 08155000 T 0579 + END#, 08156000 T 0579 + JGIF = BEGIN 08157000 T 0579 + ADJ (0,0); A ← AX + 0; B ← BX ← 0; 08158000 T 0579 + B ← RPF; BROF ← TRUE; 08159000 T 0579 + IF TEEF THEN 08160000 T 0579 + BEGIN 08161000 T 0579 + A.ADDR ← TBR; A.INDEX ← TIR; 08162000 T 0579 + A.PSRF ← PSR; A.SBIT ← 1; AROF ← TRUE 08163000 T 0579 + END ELSE 08164000 T 0579 + IF FWDT = 1 THEN 08165000 T 0579 + BEGIN AROF ← TRUE; MOVE (Y, A) END; 08166000 T 0579 + JFIF; 08167000 T 0579 + END#, 08168000 T 0579 + MEMPROTECT = BEGIN 08168100 T 0579 + UPDF ← TRUE; ENDE; 08168200 T 0579 + QF04 ← 1; JGIF; 08168300 T 0579 + GO TO OC; 08168310 T 0579 + END#, 08168400 T 0579 + FETCHSOURCE = 08169000 T 0579 + BEGIN 08170000 T 0579 + IF SOPF THEN ELSE 08171000 T 0579 + BEGIN 08172000 T 0579 + IF NOT AROF THEN 08173000 T 0579 + BEGIN 08174000 T 0579 + MM ← SBR ← SIR; 08175000 T 0579 + MOVE (M[MM], A); MEMCYCLE; 08176000 T 0579 + AROF ← TRUE; 08177000 T 0579 + IF BOOLEAN(AX.TAG)THEN MEMPROTECT 08178000 T 0579 + END; 08179000 T 0579 + END; 08180000 T 0579 + END#, 08181000 T 0579 + FETCHDESTINATION = 08182000 T 0579 + BEGIN 08183000 T 0579 + IF NOT BROF THEN 08184000 T 0579 + BEGIN 08185000 T 0579 + MM ← DBR ← DIR; 08186000 T 0579 + MOVE (M[MM], B); MEMCYCLE; 08187000 T 0579 + BROF ← TRUE; 08188000 T 0579 + IF BOOLEAN (BX.TAG) THEN MEMPROTECT 08189000 T 0579 + END; 08190000 T 0579 + END#, 08191000 T 0579 + CHARSZ = BEGIN 08192000 T 0579 + IF SSZ = 0 THEN 08193000 T 0579 + BEGIN 08194000 T 0579 + IF DSZ = 0 THEN SSZ ← DSZ ← 6 ELSE 08195000 T 0579 + SSZ ← DSZ 08196000 T 0579 + END ELSE 08197000 T 0579 + IF DSZ = 0 THEN DSZ ← SSZ 08198000 T 0579 + END#, 08199000 T 0579 + 08200000 T 0579 + 08201000 T 0579 + 08202000 T 0579 + 08203000 T 0579 + COMPARECHAR = IF ACHAR ≠ BCHAR THEN 08204000 T 0579 + IF ACHAR > BCHAR THEN 08205000 T 0579 + IF RELATION < 3 OR RELATION=5 THEN ELSE 08206000 T 0579 + TFFF ← FALSE 08207000 T 0579 + ELSE 08208000 T 0579 + IF RELATION.[46:1]=1 THEN ELSE 08209000 T 0579 + TFFF ← FALSE 08210000 T 0579 + ELSE 08211000 T 0579 + IF RELATION> 3 THEN ELSE TFFF←FALSE#, 08218000 T 0579 + SWITCHSOURCE = 08219000 T 0579 + BEGIN 08220000 T 0579 + IF SIB = 0 THEN 08221000 T 0579 + BEGIN 08222000 T 0579 + IF SOPF THEN 08223000 T 0579 + BEGIN 08224000 T 0579 + IF AX.TAG = DOUBL THEN 08225000 T 0579 + BEGIN 08226000 T 0579 + 08227000 T 0579 + JUNK ← A; 08228000 T 0579 + A ← X; 08229000 T 0579 + X ← JUNK; 08230000 T 0579 + END; 08231000 T 0579 + END ELSE 08232000 T 0579 + BEGIN 08232100 T 0579 + AROF ← FALSE; 08233000 T 0579 + SIR ← SIR + 1; 08234000 T 0579 + END; 08234100 T 0579 + END; 08235000 T 0579 + END#, 08236000 T 0579 + STOREB = BEGIN 08237000 T 0579 + MOVE (B, M[DBR + DIR]); MEMCYCLE; 08238000 T 0579 + BROF ← FALSE; 08239000 T 0579 + END#, 08240000 T 0579 + STEPSP = BEGIN 08241000 T 0579 + SIB ← 0; 08242000 T 0579 + SIR ← SIR ← 1; 08243000 T 0579 + END#, 08244000 T 0579 + STEPDP = BEGIN 08245000 T 0579 + DIB ← 0; 08246000 T 0579 + DIR ← DIR + 1; 08247000 T 0579 + END#, 08248000 T 0579 + SIBLNG = 2 × REAL (SSZ = 6) + 4 × REAL (SSZ = 8)#, 08249000 T 0579 + DIBLNG = 2 × REAL (DSZ = 6) + 4 × REAL (DSZ = 8)#, 08250000 T 0579 + TWOTO20 = 1048576#, 08251000 T 0579 + DYALSIB = 47 - SIB × SSZ#, 08252000 T 0579 + DYALDIB = 47 - DIB × SSZ#, 08253000 T 0579 + DYALSET = SIB× SSZ - 1#, 08253100 T 0579 + DYALSZ = SIB× SSZ #, 08253200 T 0579 + DYALSIZ = 48 - SIB × SSZ #, 08253300 T 0579 + BUMPSIB = SIB ← (SIB + 1) MOD (48 DIV SSZ)#, 08254000 T 0579 + BUMPDIB = DIB ← (DIB + 1) MOD (48 DIV SSZ)#, 08255000 T 0579 + BASE = (IF SOURCE THEN SBR ELSE DBR)#, 08256000 T 0579 + WORDZ = (IF SOURCE THEN SIR ELSE DIR)#, 08257000 T 0579 + BYTE = (IF SOURCE THEN SIB ELSE DIB)#, 08258000 T 0579 + SYZE = (IF SOURCE THEN SSZ ELSE DSZ)#, 08259000 T 0579 + SETUPEXSF = IF EXSF THEN ELSE 08260000 T 0579 + IF NOT RNTF THEN 08261000 T 0579 + BEGIN 08262000 T 0579 + C ← SYLLABLE; 08263000 T 0579 + CX ← 0; 08264000 T 0579 + END ELSE 08265000 T 0579 + STEPPSR (1)#; 08266000 T 0579 + PROCEDURE ENTEREDIT (TYPE, UPDATE); 08267000 T 0579 +PRT(751) = ENTEREDIT + VALUE TYPE, UPDATE; 08268000 T 0579 + INTEGER TYPE; 08269000 T 0579 + BOOLEAN UPDATE; 08270000 T 0579 + BEGIN 08271000 T 0579 + DEFINE TABLENTER = TYPE = 3#, 08272000 T 0579 + START OF SEGMENT ********** 74 + SINGLEPOINT = TYPE = 1#, 08273000 T 0000 + SINGLESHOT = TYPE = 0#; 08274000 T 0000 + LABEL OC, L1, L2, L3, L4, L5; 08275000 T 0000 + IF TABLENTER THEN 08276000 T 0000 + BEGIN 08277000 T 0000 + ADJ (0,1); 08278000 T 0001 + IF BX.TAG ≠ DATADESC THEN 08279000 T 0002 + BEGIN 08280000 T 0003 + QF01 ← 1; 08281000 T 0004 + JFIF; 08282000 T 0005 + GO TO OC 08283000 T 0053 + END; 08284000 T 0053 + IF BX.PBIT ≠ 1 THEN 08285000 T 0053 + BEGIN 08286000 T 0054 + QF02 ← 1; 08287000 T 0055 + JFIF; 08288000 T 0057 + GO TO OC 08289000 T 0104 + END; 08290000 T 0104 + BROF ← FALSE; 08291000 T 0104 + TBR ← B.ADDR; 08292000 T 0105 + IF B.IBIT = 1 THEN TIR ← B.INDEX 08293000 T 0106 + ELSE TIR ← 0; 08294000 T 0108 + IF B.SBIT = 1 THEN RNTF ← TRUE; 08295000 T 0110 + MOVE (B, C); 08296000 T 0113 + GO TO L1; 08297000 T 0114 + END; 08298000 T 0114 + ADJ (0,1); 08299000 T 0114 + IF BX.TAG ≠ SINGL AND BX.TAG ≠ DOUBL THEN 08300000 T 0115 + BEGIN 08301000 T 0118 + IF NOT SCANORXFER THEN 08302000 T 0119 + BEGIN 08303000 T 0119 + QF01 ← 1; 08304000 T 0120 + JFIF; 08305000 T 0121 + GO TO OC 08306000 T 0169 + END ELSE 08307000 T 0169 + BEGIN MOVE(C,Y); C← 0&REAL(NOT BOOLEAN(CX←0)) 08308000 T 0169 + [28:28:20] END 08308100 T 0172 + END ELSE 08309000 T 0173 + BEGIN NTGR; IF SDIS = 1 THEN INTOFL; 08310000 T 0173 + MOVE (C,Y); MOVE (B,C); 08311000 T 0179 + BROF ← FALSE; 08312000 T 0181 + END; 08313000 T 0181 + 08314000 T 0181 + IF SINGLEPOINT THEN 08315000 T 0181 + BEGIN 08316000 T 0182 + ADJ (0,1); 08317000 T 0183 + AROF ← TRUE; 08318000 T 0184 + MOVE (B,A) 08319000 T 0184 + END; 08320000 T 0185 + L1: 08321000 T 0185 + ADJ (1,1); 08322000 T 0186 + 08322100 T 0187 + SPSF ← A.SBIT; 08323000 T 0187 + SPRF ← A.RBIT; 08324000 T 0189 + DPSF ← B.SBIT; 08325000 T 0191 + IF AX.TAG = SINGL OR AX.TAG = DOUBL THEN 08326000 T 0193 + BEGIN 08327000 T 0196 + 08328000 T 0197 + SSZ ← 0; 08329000 T 0197 + SIB ← 0; 08330000 T 0197 + SOPF ← TRUE; 08330500 T 0198 + IF AX.TAG = SINGL THEN MOVE (A,X); 08331000 T 0199 + GO TO L2 08332000 T 0202 + END; 08333000 T 0202 + IF AX.PBIT ≠ 1 THEN 08334000 T 0202 + BEGIN QF02 ← 1; GO TO L3 END; 08335000 T 0203 + SBR ← A.ADDR; 08336000 T 0206 + SSZ ← IF A.SZ = 0 THEN 6 ELSE 2×A.SZ; 08337000 T 0207 + SIB ← 0; 08338000 T 0212 + IF A.IBIT ≠ 0 THEN 08339000 T 0212 + BEGIN 08340000 T 0214 + IF A.SZ ≠ 0 THEN 08341000 T 0214 + BEGIN 08342000 T 0215 + SIB ← A.[8:4]; 08343000 T 0216 + SIR ← A.[12:16]; 08344000 T 0217 + END 08345000 T 0218 + ELSE 08346000 T 0218 + SIR ← A.INDEX 08347000 T 0218 + END ELSE 08348000 T 0219 + SIR ← 0; 08349000 T 0220 + 08350000 T 0221 + AROF ← FALSE; 08351000 T 0221 + L2: IF SWPS = 1 THEN GO TO L5; 08352000 T 0222 + IF BX.TAG ≠ DATADESC THEN 08353000 T 0224 + BEGIN 08354000 T 0226 + L4: 08355000 T 0226 + QF01 ← 1; 08356000 T 0227 + L3: 08357000 T 0228 + IF SINGLEPOINT THEN 08358000 T 0229 + BROF ← FALSE; 08359000 T 0229 + AROF ← TRUE; 08359500 T 0231 + ADJ (0,0); 08360000 T 0231 + MOVE (Y,A); 08360500 T 0232 + IF TABLENTER THEN AROF ← TRUE ELSE 08361000 T 0233 + BEGIN 08361500 T 0235 + MOVE (C,B); 08362000 T 0236 + BROF ← TRUE; 08362500 T 0237 + IF FWDT = 1 THEN AROF ← TRUE; 08363000 T 0238 + END; 08363500 T 0240 + JFIF; 08364000 T 0240 + GO TO OC 08365000 T 0288 + END; 08366000 T 0288 + IF BX.PBIT ≠ 1 THEN 08367000 T 0288 + BEGIN QF02 ← 1; GO TO L3 END; 08367500 T 0289 + DBR ← B.ADDR; 08368000 T 0292 + DSZ ← IF B.SZ=0 THEN 6 ELSE 2×B.SZ; 08368500 T 0293 + IF AX.TAG = DATADESC THEN 08369000 T 0298 + BEGIN 08369500 T 0299 + IF NOT XLATE THEN 08370000 T 0299 + BEGIN 08370500 T 0300 + IF SSZ ≠ DSZ THEN GO TO L4 08371000 T 0300 + END; 08371500 T 0301 + END; 08372000 T 0302 + IF NOT XFERWD THEN 08373000 T 0302 + BEGIN 08374000 T 0302 + IF B.RBIT = 1 THEN 08375000 T 0303 + BEGIN 08376000 T 0304 + QF03 ← 1; 08377000 T 0304 + GO TO L3 08378000 T 0306 + END; 08379000 T 0307 + END; 08380000 T 0307 + L5: DBR ← B.ADDR; 08380500 T 0307 + DSZ ← IF B.SZ = 0 THEN 6 ELSE 2 × B.SZ; 08380600 T 0308 + DIB ← 0; 08381000 T 0312 + IF B.IBIT ≠ 0 THEN 08382000 T 0313 + BEGIN 08383000 T 0314 + IF B.SZ ≠ 0 THEN 08384000 T 0315 + BEGIN 08385000 T 0316 + DIB ← B.[8:4]; 08386000 T 0316 + DIR ← B.[12:16] 08387000 T 0318 + END ELSE 08388000 T 0318 + DIR ← B.INDEX 08389000 T 0319 + END ELSE 08390000 T 0319 + DIR ← 0; 08391000 T 0321 + BROF ← FALSE; 08392000 T 0322 + IF UPDATE THEN UPDF ← TRUE; 08393000 T 0323 + IF NOT TABLENTER THEN EXSF ← ESPF ← TRUE 08394000 T 0324 + ELSE 08395000 T 0326 + BEGIN 08396000 T 0327 + TEEF ← TRUE; PSR ← C.[38:3] 08397000 T 0327 + END; 08398000 T 0328 + OC: 08399000 T 0329 + END ENTEREDIT; 08400000 T 0330 + 74 IS 331 LONG, NEXT SEG 12 + PROCEDURE XFERWDS (UPDATE,OVERITE); 08400010 T 0579 +PRT(752) = XFERWDS + VALUE UPDATE, OVERITE; 08400020 T 0579 + BOOLEAN UPDATE, OVERITE; 08400030 T 0579 + BEGIN 08400040 T 0579 + LABEL OC, L1; 08400050 T 0579 + START OF SEGMENT ********** 75 + XFERWD ← OVERITE; 08400055 T 0000 + ENTEREDIT (0,UPDATE); 08400060 T 0000 + IF SIB ≠ 0 THEN STEPSP; 08400070 T 0001 + IF DIB ≠ 0 THEN STEPDP; 08400080 T 0005 + IF C.ADDR > 0 THEN 08400090 T 0008 + BEGIN 08400100 T 0009 + RPF ← C.ADDR; 08400110 T 0010 + WHILE (RPF ← RPF - 1) ≥ 0 DO 08400120 T 0011 + BEGIN 08400130 T 0013 + IF SOPF THEN ELSE 08400140 T 0013 + BEGIN 08400150 T 0014 + MM ← SBR ← SIR; 08400160 T 0014 + MOVE (M[MM], A); MEMCYCLE; 08400170 T 0016 + IF NOT OVERITE THEN 08400180 T 0021 + IF BOOLEAN (AX.TAG) THEN GO L1; 08400190 T 0021 + END; 08400200 T 0023 + MM ← DBR ← DIR; 08400210 T 0023 + MOVE (M[MM], C); 08400220 T 0025 + IF NOT OVERITE THEN 08400230 T 0029 + BEGIN 08400240 T 0029 + IF BOOLEAN (CX.TAG) THEN GO TO L1; 08400250 T 0030 + END; 08400260 T 0030 + MOVE (A, M[MM]); MEMCYCLE; 08400270 T 0031 + IF SOPF THEN 08400280 T 0036 + BEGIN 08400290 T 0037 + IF AX.TAG ≠ SINGL THEN 08400300 T 0037 + BEGIN 08400310 T 0038 + MOVE (A, JUNK); 08400320 T 0039 + MOVE (X, A); 08400330 T 0040 + MOVE (JUNK, A); 08400340 T 0041 + END 08400350 T 0042 + END ELSE 08400360 T 0042 + SIR ← SIR + 1; 08400370 T 0042 + DIR ← DIR + 1; 08400380 T 0044 + END; 08400390 T 0045 + END; 08400400 T 0045 + ENDE; GO TO OC; 08400500 T 0045 + L1: 08400600 T 0046 + UPDF ← TRUE; 08400700 T 0047 + ENDE; 08400750 T 0047 + QF04 ← 1; 08400800 T 0048 + JGIF; 08400850 T 0050 + 08400900 T 0115 + OC: 08400950 T 0115 + END XFERWDS; 08401000 T 0115 + 75 IS 116 LONG, NEXT SEG 12 + PROCEDURE XFERWHILE (UPDATE,RELATION); 08402000 T 0579 +PRT(753) = XFERWHILE + VALUE UPDATE, RELATION; 08403000 T 0579 + BOOLEAN UPDATE; 08404000 T 0579 + INTEGER RELATION; 08405000 T 0579 + BEGIN 08406000 T 0579 + REAL ACHAR, BCHAR; 08407000 T 0579 + START OF SEGMENT ********** 76 +STACK(F+2) = ACHAR +STACK(F+3) = BCHAR + LABEL OC, L1, L2, L3, L4; 08408000 T 0000 + ADJ (1,1); 08409000 T 0000 + IF AX.TAG ≠ SINGL THEN 08410000 T 0001 + BEGIN 08411000 T 0002 + QF01 ← 1; 08412000 T 0002 + JFIF; 08413000 T 0004 + GO TO OC 08414000 T 0052 + END; 08415000 T 0052 + MOVE (A, C); 08416000 T 0052 + AROF ← FALSE; SCANORXFER ← TRUE; XFERW ← TRUE; 08417000 T 0053 + ENTEREDIT (0, UPDATE); 08418000 T 0055 + CHARSZ; 08419000 T 0056 + DYAL (Y, BCHAR, SSZ-1, SSZ-1, SSZ); 08420000 T 0064 + TFFF ← TRUE; 08420500 T 0067 + RPF ← C.ADDR; 08421000 T 0067 + IF C.ADDR = 0 THEN 08422000 T 0069 + BEGIN 08423000 T 0070 + ENDE; GO TO OC; 08424000 T 0070 + END; 08425000 T 0071 + L1: FETCHSOURCE; 08426000 T 0071 + FETCHDESTINATION; 08427000 T 0151 + 08428000 T 0229 + DYAL (A, ACHAR, DYALSIB, SSZ-1, SSZ); 08429000 T 0229 + COMPARECHAR; 08430000 T 0232 + IF TFFF THEN 08431000 T 0245 + BEGIN 08432000 T 0245 + DYAL (A, B, DYALSIB, DYALDIB, SSZ); 08433000 T 0246 + RPF ← RPF - 1; 08434000 T 0249 + IF RPF = 0 THEN QH03 ← 1 ELSE 08435000 T 0251 + L2: BEGIN 08436000 T 0254 + BUMPSIB; 08437000 T 0255 + SWITCHSOURCE; 08438000 T 0257 + BUMPDIB; 08439000 T 0265 + IF DIB = 0 THEN 08440000 T 0268 + BEGIN 08440010 T 0268 + STOREB; DIR ← DIR + 1 08440020 T 0269 + END; 08440030 T 0276 + IF QH03 = 0 THEN GO TO L1; 08440040 T 0277 + IF UPDF THEN GO TO L3 ELSE GO TO L4; 08440050 T 0278 + END; 08440060 T 0280 + END; 08440070 T 0280 + STOREB; 08440080 T 0280 + IF TFFF THEN GO TO L2; 08440090 T 0286 + L3: ENDE; 08440100 T 0287 + ADJ (0,2); 08440110 T 0288 + A ← RPF; AX ← 0; 08440120 T 0289 + AROF ← TRUE; 08440130 T 0291 + GO TO OC; 08440140 T 0291 + L4: ENDE; 08440150 T 0292 + OC: SCANORXFER ← FALSE; XFERW ← FALSE; 08440160 T 0293 + END XFERWHILE; 08440170 T 0295 + 76 IS 298 LONG, NEXT SEG 12 + PROCEDURE TWSD; % TRANSFER WORDS, DESTRUCTIVE 08440180 T 0579 + BEGIN P2R3 ← 1; 08440190 T 0579 + XFERWDS (FALSE, FALSE); P2R3 ← 0; 08440200 T 0581 + END TWSD; 08440210 T 0584 + PROCEDURE TWSU; % TRANSFER WORDS, UPDATE 08440220 T 0584 + BEGIN P2R3 ← 1; 08440230 T 0584 + XFERWDS (TRUE, FALSE); P2R3 ← 0; 08440240 T 0586 + END TWSU; 08440250 T 0589 + PROCEDURE TWOD; % TRANSFER WORDS OVERWRITE, DESTRUCTIVE 08440260 T 0589 + BEGIN P2R3 ← 1; 08440270 T 0589 + XFERWDS (FALSE, TRUE); P2R3 ← 0; 08440280 T 0591 + END TWOD; 08440290 T 0594 + PROCEDURE TWOU; % TRANSFER WORDS OVERWRITE, UPDATE 08440300 T 0594 + BEGIN P2R3 ← 1; 08440310 T 0594 + XFERWDS (TRUE, TRUE); P2R3 ← 0; 08440320 T 0596 + END TWOU; 08440330 T 0599 + PROCEDURE TGTD; % TRANSFER WHILE GREATER, DESTRUCTIVE 08440340 T 0599 + BEGIN P2R4 ← 1; FWDT ← 1; 08440350 T 0599 + XFERWHILE (FALSE, 1); P2R4 ← 0; FWDT ← 0; 08440360 T 0603 + END TGTD; 08440370 T 0608 + PROCEDURE TGTU; % TRANSFER WHILE GREATER, UPDATE 08440380 T 0608 + BEGIN P2R4 ← 1; FWDT ← 1; 08440390 T 0608 + XFERWHILE (TRUE, 1); P2R4 ← 0; FWDT ← 0; 08440400 T 0612 + END TGTU; 08440500 T 0617 + PROCEDURE TGED; % TRANSFER WHILE GREATER OR EQUAL, DESTRUCTIVE 08440600 T 0617 + BEGIN P2R4 ← 1; FWDT ← 1; 08440700 T 0617 + XFERWHILE (FALSE, 5); P2R4 ← 0; FWDT ← 0; 08440800 T 0621 + END TGED; 08440900 T 0626 + PROCEDURE TGEU; % TRANSFER WHILE GREATER OR EQUAL, UPDATE 08441000 T 0626 + BEGIN P2R4 ← 1; FWDT ← 1; 08441100 T 0626 + XFERWHILE (TRUE, 5); P2R4 ← 0; FWDT ← 0; 08441200 T 0630 + END TGEU; 08441300 T 0635 + PROCEDURE TEQD; % TRANSFER WHILE EQUAL, DESTRUCTIVE 08441400 T 0635 + BEGIN P2R4 ← 1; FWDT ← 1; 08441500 T 0635 + XFERWHILE (FALSE, 4); P2R4 ← 0; FWDT ← 0; 08441600 T 0639 + END TEQD; 08441700 T 0644 + PROCEDURE TEQU; % TRANSFER WHILE EQUAL, UPDATE 08441800 T 0644 + BEGIN P2R4 ← 1; FWDT ← 1; 08441900 T 0644 + XFERWHILE (TRUE, 4); P2R4 ← 0; FWDT ← 0; 08442000 T 0648 + END TEQU; 08442100 T 0653 + PROCEDURE TLED; % TRANSFER WHILE LESS OR EQUAL, DESTRUCTIVE 08442200 T 0653 + BEGIN P2R4 ← 1; FWDT ← 1; 08442300 T 0653 + XFERWHILE (FALSE, 6); P2R4 ← 0; FWDT ← 0; 08442400 T 0657 + END TLED; 08442500 T 0662 + PROCEDURE TLEU; % TRANSFER WHILE LESS OR EQUAL, UPDATE 08442600 T 0662 + BEGIN P2R4 ← 1; FWDT ← 1; 08442700 T 0662 + XFERWHILE (TRUE, 6); P2R4 ← 0; FWDT ← 0; 08442800 T 0666 + END TLEU; 08442900 T 0671 + PROCEDURE TLSD; % TRANSFER WHILE LESS, DESTRUCTIVE 08443000 T 0671 + BEGIN P2R4 ← 1; FWDT ← 1; 08444000 T 0671 + XFERWHILE (FALSE, 3); P2R4 ← 0; FWDT ← 0; 08445000 T 0675 + END TLSD; 08446000 T 0680 + PROCEDURE TLSU; % TRANSFER WHILE LESS, UPDATE 08447000 T 0680 + BEGIN P2R4 ← 1; FWDT ← 1; 08448000 T 0680 + XFERWHILE (TRUE, 3); P2R4 ← 0; FWDT ← 0; 08448500 T 0684 + END TLSU; 08449000 T 0689 + PROCEDURE TNED; % TRANSFER WHILE NOT EQUAL, DESTRUCTIVE 08449500 T 0689 + BEGIN P2R4 ← 1; FWDT ← 1; 08450000 T 0689 + XFERWHILE (FALSE, 2); P2R4 ← 0; FWDT ← 0; 08451000 T 0693 + END TNED; 08452000 T 0698 + PROCEDURE TNEU; % TRANSFER WHILE NOT EQUAL, UPDATE 08453000 T 0698 + BEGIN P2R4 ← 1; FWDT ← 1; 08454000 T 0698 + XFERWHILE (TRUE, 2); P2R4 ← 0; FWDT ← 0; 08455000 T 0702 + END TNEU; 08456000 T 0707 + DEFINE MEMPROT = MEMPRO #; 08456500 T 0707 + PROCEDURE XFERWHILETF(TOGLE,UPDATE); 08457000 T 0707 +PRT(754) = XFERWHILETF + VALUE TOGLE,UPDATE; 08458000 T 0707 + BOOLEAN TOGLE,UPDATE; 08459000 T 0707 + BEGIN 08460000 T 0707 + LABEL OC,L12,L13,L14,L100,L1; 08461000 T 0707 + START OF SEGMENT ********** 77 + BOOLEAN LHFF; 08461100 T 0000 +STACK(F+2) = LHFF + ADJ (1,2); 08462000 T 0000 + IF AX.TAG ≠ DATADESC THEN 08463000 T 0001 + BEGIN 08464000 T 0002 + QF01 ← 1; 08465000 T 0002 + L1: JFIF; 08466000 T 0004 + GO OC; 08467000 T 0052 + END; 08468000 T 0052 + IF AX.PBIT = 0 THEN 08469000 T 0052 + BEGIN 08470000 T 0053 + QF02 ← 1; 08471000 T 0054 + 08472000 T 0056 + GO L1; 08473000 T 0056 + END; 08474000 T 0056 + IF A.IBIT ≠ 1 THEN TIR ← 0 ELSE 08475000 T 0056 + TIR ← IF A.SZ=0 THEN A.[12:16] ELSE A.INDEX; 08476000 T 0059 + TBR ← A.ADDR + TIR; 08477000 T 0063 + MOVE(A,C); 08478000 T 0065 + AROF ← FALSE; 08479000 T 0066 + IF UPDATE THEN EXSU ELSE EXSD; 08480000 T 0067 + CHARSZ; 08481000 T 0069 + IF RPF ← C.ADDR = 0 THEN BEGIN ENDE; GO OC END; 08482000 T 0077 + QH03 ← 1; 08483000 T 0080 + TFFF ← TRUE; 08484000 T 0082 + L12: 08484100 T 0082 + FETCHSOURCE; 08485000 T 0083 + IF QH03 = 1 THEN QH03 ← 0; 08486000 T 0162 + L13: FETCHDESTINATION; 08487000 T 0166 + L14: 08488000 T 0243 + MM ← DIS ← 0; 08489000 T 0244 + DYAL(A,MM,DYALSIB,2×REAL(SSZ=8),REAL(SSZ≠4)+2×REAL(SSZ=8)); 08490000 T 0245 + MM ← MM ← TBR; 08491000 T 0251 + DYAL(A,DIS,DYALSIB+1+2×REAL(SSZ=8),4-REAL(SSZ=4), 08492000 T 0252 + 5-REAL(SSZ=4)); 08493000 T 0257 + MOVE(M[MM],Y); MEMCYCLE; 08494000 T 0259 + IF BOOLEAN(YX.TAG) THEN MEMPROTECT; 08495000 T 0264 + DYAL(Y,AA,DIS,0,1); 08496000 T 0333 + Q03F ← REAL(TFFF← BOOLEAN(AA) EQV TOGLE); 08497000 T 0335 + IF Q03F=1 THEN DYAL(A,B,DYALSIB,DYALDIB,SSZ); 08498000 T 0338 + RPF ← RPF -1; 08499000 T 0343 + IF RPF = 0 THEN 08500000 T 0344 + BEGIN 08501000 T 0345 + LHFF ← TRUE; 08502000 T 0346 + STOREB; 08503000 T 0346 + IF TFFF THEN 08504000 T 0353 + BEGIN 08505000 T 0353 + L100: 08506000 T 0354 + ENDE; 08507000 T 0354 + ADJ(0,2); 08508000 T 0354 + A ← RPF; AX ← 0; 08509000 T 0355 + AROF ← TRUE; 08510000 T 0357 + GO OC; 08511000 T 0357 + END; 08512000 T 0358 + END; 08513000 T 0358 + BUMPSIB; 08514000 T 0358 + SWITCHSOURCE; 08514100 T 0360 + IF BUMPDIB=0 THEN 08514200 T 0369 + BEGIN 08514300 T 0371 + STOREB; 08514400 T 0372 + STEPDP; 08514500 T 0378 + END; 08514600 T 0380 + IF LHFF THEN IF UPDF THEN BEGIN ENDE; GO OC END ELSE GO L100; 08514700 T 0380 + IF SIB=0 THEN GO L12; 08514800 T 0383 + GO L13; 08514900 T 0384 + OC: 08515000 T 0385 + END OF TRANSFER ; 08516000 T 0385 + 77 IS 388 LONG, NEXT SEG 12 + PROCEDURE TWTD; % TRANSFER WHILE TRUE, DESTRUCTIVE 7.1.19 08517000 T 0707 + BEGIN 08518000 T 0707 + XFERWHILETF( TRUE , FALSE); % TRUE DESTRUCTIVE 08519000 T 0707 + END TWTD; 08520000 T 0709 + PROCEDURE TWTU ; % TRANSFER WHILE TRUE, UPDATE 7.1.20 08521000 T 0709 + BEGIN 08522000 T 0709 + XFERWHILETF( TRUE , TRUE ); % TRUE UPDATE 08523000 T 0709 + END TWTU; 08524000 T 0711 + PROCEDURE TWFD ; % TRANSFER WHILE FALSE, DESTRUCTIVE 7.1.21 08525000 T 0711 + BEGIN 08526000 T 0711 + XFERWHILETF( FALSE, FALSE); % FALSE DESTRUCTIVE 08527000 T 0711 + END TWFD; 08528000 T 0713 + PROCEDURE TWFU ; % TRANSFER WHILE FALSE, UPDATE 7.1.22 08529000 T 0713 + BEGIN 08530000 T 0713 + XFERWHILETF( FALSE, TRUE ); % FALSE UPDATE 08531000 T 0713 + END TWFU; 08532000 T 0715 + PROCEDURE TUND ; % TRANSFER UNCONDITIONAL , DESTRUCTIVE 7.1.23 08533000 T 0715 + BEGIN 08534000 T 0715 + ADJ(0,2); 08535000 T 0715 + A ← AX ← 0; 08536000 T 0717 + AROF ← TRUE; 08537000 T 0718 + XFERWHILE(FALSE,5); 08538000 T 0719 + END TUND; 08539000 T 0720 + PROCEDURE TUNU ; % TRANSFER UNCONDITIONAL , UPDATE 7.1.24 08540000 T 0720 + BEGIN 08541000 T 0720 + ADJ(0,2); 08542000 T 0720 + A←AX←0; 08543000 T 0722 + AROF←TRUE; 08544000 T 0723 + XFERWHILE(TRUE,5); 08545000 T 0724 + END TUNU; 08546000 T 0725 + PROCEDURE SCANWHILE(UPDATE,RELATION); 08547000 T 0725 +PRT(755) = SCANWHILE + VALUE UPDATE,RELATION; 08548000 T 0725 + BOOLEAN UPDATE; 08549000 T 0725 + INTEGER RELATION; 08550000 T 0725 + BEGIN 08551000 T 0725 + REAL ACHAR, BCHAR; 08552000 T 0725 + START OF SEGMENT ********** 78 +STACK(F+2) = ACHAR +STACK(F+3) = BCHAR + LABEL OC, L1, L2; 08553000 T 0000 + ADJ(1,1); 08553500 T 0000 + IF AX.TAG ≠ SINGL THEN 08554000 T 0001 + BEGIN 08554500 T 0002 + QF01 ← 1; 08555000 T 0002 + JFIF; 08555500 T 0004 + GO TO OC; 08556000 T 0052 + END; 08556500 T 0052 + MOVE(A,C); 08557000 T 0052 + AROF ← FALSE; SCANORXFER ← TRUE; SCANWH ← TRUE; 08557500 T 0053 + ENTEREDIT(1,UPDATE); 08558000 T 0055 + IF SSZ = 0 THEN SSZ ← 6; 08558500 T 0056 + DYAL(Y,BCHAR, SSZ - 1, SSZ - 1, SSZ); 08559000 T 0058 + TFFF ← TRUE; 08559500 T 0061 + IF C.ADDR = 0 THEN GO TO L2; 08560000 T 0062 + L1: FETCHSOURCE; 08561000 T 0064 + 08562000 T 0143 + DYAL (A, ACHAR,DYALSIB, SSZ - 1, SSZ); 08563000 T 0143 + COMPARECHAR; 08564000 T 0146 + IF NOT TFFF THEN ELSE 08565000 T 0159 + BEGIN 08566000 T 0160 + RPF ← RPF - 1; 08567000 T 0160 + IF RPF = 0 THEN LHFF ← 1; 08568000 T 0162 + BUMPSIB; 08569000 T 0165 + SWITCHSOURCE; 08570000 T 0167 + IF LHFF ≠ 1 THEN GO TO L1; 08571000 T 0175 + L2: IF NOT UPDF THEN 08572000 T 0177 + BEGIN 08572100 T 0178 + ENDE; 08573000 T 0179 + GO TO OC; 08574000 T 0179 + END; 08574100 T 0180 + END; 08575000 T 0180 + ENDE; 08576000 T 0180 + ADJ(0,2); 08577000 T 0180 + A ← RPF; AX ← 0; 08578000 T 0181 + AROF ← TRUE; 08579000 T 0183 + OC: SCANORXFER← SCANWH ← FALSE; 08580000 T 0183 + END OF SCANWHILE; 08581000 T 0185 + 78 IS 188 LONG, NEXT SEG 12 + PROCEDURE SGTD ; % SCAN WHILE GREATER, DESTRUCTIVE 7.2.1 08582000 T 0725 + BEGIN P2R3 ← 1; FWDT ← 1; 08583000 T 0725 + SCANWHILE ( FALSE , 1 ); 08584000 T 0729 + END SGTD; 08585000 T 0730 + PROCEDURE SGTU ; % SCAN WHILE GREATER, UPDATE 7.2.2 08586000 T 0730 + BEGIN P2R3 ← 1; FWDT ← 1; 08587000 T 0730 + SCANWHILE ( TRUE , 1 ); 08588000 T 0734 + END SGTU; 08589000 T 0735 + PROCEDURE SGED ; % SCAN WHILE GREATER OR EQUAL, DESTRUCTIVE7.2.3 08590000 T 0735 + BEGIN P2R3 ← 1; FWDT ← 1; 08591000 T 0735 + SCANWHILE ( FALSE , 5 ); 08592000 T 0739 + END SGED; 08593000 T 0740 + PROCEDURE SGEU ; % SCAN WHILE GREATER OR EQUAL, UPDATE 7.2.4 08594000 T 0740 + BEGIN P2R3 ← 1; FWDT ← 1; 08595000 T 0740 + SCANWHILE ( TRUE , 5 ); 08596000 T 0744 + END SGEU; 08597000 T 0745 + PROCEDURE SEQD ; % SCAN WHILE EQUAL, DESTRUCTIVE 7.2.5 08598000 T 0745 + BEGIN P2R3 ← 1; FWDT ← 1; 08599000 T 0745 + SCANWHILE ( FALSE , 4 ); 08600000 T 0749 + END SEQD; 08601000 T 0750 + PROCEDURE SEQU ; % SCAN WHILE EQUAL, UPDATE 7.2.6 08602000 T 0750 + BEGIN P2R3 ← 1; FWDT ← 1; 08603000 T 0750 + SCANWHILE ( TRUE , 4 ); 08604000 T 0754 + END SEQU; 08605000 T 0755 + PROCEDURE SLED ; % SCAN WHILE LESS OR EQUAL, DESTRUCTIVE 7.2.7 08606000 T 0755 + BEGIN P2R3 ← 1; FWDT ← 1; 08607000 T 0755 + SCANWHILE ( FALSE , 6 ); 08608000 T 0759 + END SLED; 08609000 T 0760 + PROCEDURE SLEU ; % SCAN WHILE LESS OR EQUAL, UPDATE 7.2.8 08610000 T 0760 + BEGIN P2R3 ← 1; FWDT ← 1; 08611000 T 0760 + SCANWHILE ( TRUE , 6 ); 08612000 T 0764 + END SLEU; 08613000 T 0765 + PROCEDURE SLSD ; % SCAN WHILE LESS, DESTRUCTIVE 7.2.9 08614000 T 0765 + BEGIN P2R3 ← 1; FWDT ← 1; 08615000 T 0765 + SCANWHILE ( FALSE , 3 ); 08616000 T 0769 + END SLSD; 08617000 T 0770 + PROCEDURE SLSU ; % SCAN WHILE LESS, UPDATE 7.2.10 08618000 T 0770 + BEGIN P2R3 ← 1; FWDT ← 1; 08619000 T 0770 + SCANWHILE ( TRUE , 3 ); 08620000 T 0774 + END SLSU; 08621000 T 0775 + PROCEDURE SNED ; % SCAN WHILE NOT EQUAL, DESTRUCTIVE 7.2.11 08622000 T 0775 + BEGIN P2R3 ← 1; FWDT ← 1; 08623000 T 0775 + SCANWHILE ( FALSE , 2 ); 08624000 T 0779 + END SNED; 08625000 T 0780 + PROCEDURE SNEU ; % SCAN WHILE NOT EQUAL, UPDATE 7.2.12 08626000 T 0780 + BEGIN P2R3 ← 1; FWDT ← 1; 08627000 T 0780 + SCANWHILE ( TRUE , 2 ); 08628000 T 0784 + END SNEU; 08629000 T 0785 + PROCEDURE SCANWHILETF(TOGLE,UPDATE); 08630000 T 0785 +PRT(756) = SCANWHILETF + VALUE TOGLE,UPDATE; 08631000 T 0785 + BOOLEAN TOGLE,UPDATE; 08632000 T 0785 + BEGIN 08633000 T 0785 + LABEL OC,L8 ,L100,L21; 08634000 T 0785 + START OF SEGMENT ********** 79 + BOOLEAN LHFF; 08634100 T 0000 +STACK(F+2) = LHFF + ADJ(1,2); 08635000 T 0000 + IF AX.TAG≠ DATADESC THEN 08636000 T 0001 + BEGIN 08637000 T 0002 + QF01 ← 1; 08638000 T 0002 + L21: 08639000 T 0004 + JFIF; 08640000 T 0005 + GO OC; 08641000 T 0052 + END; 08642000 T 0052 + IF AX.PBIT=0 THEN 08643000 T 0052 + BEGIN 08644000 T 0053 + QF02←1; 08644100 T 0054 + GO L21; 08644200 T 0056 + END; 08644300 T 0056 + AROF ← FALSE; 08645000 T 0056 + IF NOT(BOOLEAN(A.IBIT)) THEN TIR←0 ELSE 08646000 T 0057 + TIR ← IF A.CHRSZ = 0 THEN A.INDEX ELSE A.TIRF; 08647000 T 0059 + TIR←A.ADDR+TIR; 08648000 T 0064 + ENTEREDIT(1,UPDATE); 08649000 T 0066 + IF SSZ = 0 THEN SSZ ← 6; 08650000 T 0067 + RPF ← C.ADDR; 08651000 T 0069 + IF RPF =0 THEN 08652000 T 0070 + BEGIN 08653000 T 0071 + L100: 08654000 T 0071 + ENDE; 08655000 T 0072 + ADJ(0,2); 08656000 T 0072 + A ←RPF; AX ← 0; 08657000 T 0073 + AROF ← TRUE; 08658000 T 0075 + GO OC; 08659000 T 0075 + END; 08660000 T 0076 + TFFF ← TRUE; 08661000 T 0076 + L8: 08662000 T 0077 + FETCHSOURCE; 08663000 T 0077 + MM ← DIS ← 0; 08664000 T 0156 + DYAL(A,MM,DYALSIB,2×REAL(SSZ=8),REAL(SSZ≠4)+2×REAL(SSZ=4)); 08665000 T 0157 + MOVE(M[MM],Y); MEMCYCLE; 08666000 T 0163 + IF BOOLEAN(YX.TAG) THEN MEMPROTECT; 08667000 T 0168 + DYAL(Y,AA,DIS,0,1); 08668000 T 0238 + Q03F ← REAL(TFFF←BOOLEAN(AA) EQV TOGLE); 08669000 T 0240 + IF Q03F=0 THEN BEGIN TFFF←FALSE; GO L100 END; 08670000 T 0243 + RPF ← RPF -1; 08671000 T 0246 + IF RPF = 0 THEN LHFF ← TRUE; 08672000 T 0247 + BUMPSIB; SWITCHSOURCE; 08673000 T 0249 + IF LHFF THEN IF UPDF THEN GO L100 ELSE BEGIN ENDE; GO OC END; 08674000 T 0260 + GO TO L8; 08675000 T 0262 + 08676000 T 0263 + OC: 08677000 T 0263 + END OF SCAN ; 08678000 T 0264 + 79 IS 267 LONG, NEXT SEG 12 + PROCEDURE SWTD ; % SCAN WHILE TRUE, DESTRUCTIVE 7.2.13 08679000 T 0785 + BEGIN 08680000 T 0785 + SCANWHILETF( TRUE , FALSE); % TRUE DESTRUCTIVE 08681000 T 0785 + END SWTD; 08682000 T 0787 + PROCEDURE SWTU ; % SCAN WHILE TRUE, UPDATE 7.2.14 08683000 T 0787 + BEGIN 08684000 T 0787 + SCANWHILETF( TRUE , TRUE ); % TRUE UPDATE 08685000 T 0787 + END SWTU; 08686000 T 0789 + PROCEDURE SWFD ; % SCAN WHILE FALSE, DESTRUCTIVE 7.2.15 08687000 T 0789 + BEGIN 08688000 T 0789 + SCANWHILETF( FALSE, FALSE); % FALSE DESTRUCTIVE 08689000 T 0789 + END SWFD; 08690000 T 0791 + PROCEDURE SWFU ; % SCAN WHILE FALSE, UPDATE 7.2.16 08691000 T 0791 + BEGIN 08692000 T 0791 + SCANWHILETF( FALSE, TRUE ); % FALSE UPDATE 08693000 T 0791 + END SWFU; 08694000 T 0793 + PROCEDURE COMPARECHRS(UPDATE,RELATION); 08695000 T 0793 +PRT(757) = COMPARECHRS + VALUE UPDATE,RELATION; 08696000 T 0793 + BOOLEAN UPDATE; 08697000 T 0793 + INTEGER RELATION; 08698000 T 0793 + BEGIN 08699000 T 0793 + INTEGER ACHAR, BCHAR; 08700000 T 0793 + START OF SEGMENT ********** 80 +STACK(F+2) = ACHAR +STACK(F+3) = BCHAR + LABEL OC, L1; 08701000 T 0000 + ENTEREDIT(0,UPDATE); 08702000 T 0000 + CHARSZ; 08703000 T 0001 + RPF ← C.ADDR; 08704000 T 0008 + IF RPF = 0 THEN 08705000 T 0009 + BEGIN 08706000 T 0010 + ENDE; 08707000 T 0011 + GO TO OC; 08708000 T 0011 + END; 08709000 T 0012 + L1: TFFF ← TRUE; 08710000 T 0012 + FETCHSOURCE; 08711000 T 0012 + FETCHDESTINATION; 08712000 T 0091 + DYAL(A,BCHAR,DYALSIB, SSZ - 1, SSZ); 08713000 T 0169 + DYAL(B, ACHAR, DYALDIB, SSZ - 1, SSZ); 08714000 T 0172 + COMPARECHAR; 08715000 T 0176 + RPF ← RPF - 1; 08716000 T 0188 + BUMPSIB; 08717000 T 0189 + SWITCHSOURCE; 08718000 T 0192 + IF BUMPDIB = 0 THEN 08719000 T 0200 + BEGIN 08720000 T 0203 + STEPDP; 08721000 T 0203 + BROF ← FALSE; 08722000 T 0205 + END; 08723000 T 0206 + IF RPF = 0 THEN 08724000 T 0206 + BEGIN 08725000 T 0207 + BROF ← FALSE; 08726000 T 0207 + ENDE; 08727000 T 0208 + GO TO OC; 08728000 T 0209 + END; 08729000 T 0209 + GO TO L1; 08730000 T 0209 + OC: 08730500 T 0210 + END OF COMPARE CHARACTERS; 08731000 T 0210 + 80 IS 213 LONG, NEXT SEG 12 + PROCEDURE CGTD ; % COMPARE CHARACTERS GREATER, DESTRUCTIVE 7.3.1 08732000 T 0793 + BEGIN P2R3 ← 1; 08733000 T 0793 + COMPARECHRS( FALSE , 1 ); % DESTRUCTIVE GREATER 08734000 T 0795 + END CGTD; 08735000 T 0796 + PROCEDURE CGTU ; % COMPARE CHARACTERS GREATER, UPDATE 7.3.2 08736000 T 0797 + BEGIN P2R3 ← 1; 08737000 T 0797 + COMPARECHRS( TRUE , 1 ); % UPDATE GREATER 08738000 T 0798 + END CGTU; 08739000 T 0799 + PROCEDURE CGED ; % COMPARE CHARACTERS GREATER OR EQUAL, DST7.3.3 08740000 T 0800 + BEGIN P2R3 ← 1; 08741000 T 0800 + COMPARECHRS( FALSE , 5 ); % DESTRUCTIVE GREATER EQUAL 08742000 T 0801 + END CGED; 08743000 T 0802 + PROCEDURE CGEU ; % COMPARE CHARACTERS GREATER OR EQUAL, UPD7.3.4 08744000 T 0803 + BEGIN P2R3 ← 1; 08745000 T 0803 + COMPARECHRS( TRUE , 5 ); % UPDATE GREATER EQUAL 08746000 T 0804 + END CGEU; 08747000 T 0805 + PROCEDURE CEQD ; % COMPARE CHARACTERS EQUAL, DESTRUCTIVE 7.3.5 08748000 T 0806 + BEGIN P2R3 ← 1; 08749000 T 0806 + COMPARECHRS( FALSE , 4 ); % DESTRUCTIVE EQUAL 08750000 T 0807 + END CEQD; 08751000 T 0808 + PROCEDURE CEQU ; % COMPARE CHARACTERS EQUAL, UPDATE 7.3.6 08752000 T 0809 + BEGIN P2R3 ← 1; 08753000 T 0809 + COMPARECHRS( TRUE , 4 ); % UPDATE EQUAL 08754000 T 0810 + END CEQU; 08755000 T 0811 + PROCEDURE CLED ; % COMPARE CHARACTERS LESS OR EQUAL, DST 7.3.7 08756000 T 0812 + BEGIN P2R3 ← 1; 08757000 T 0812 + COMPARECHRS( FALSE , 6 ); % DESTRUCTIVE LESS EQUAL 08758000 T 0813 + END CLED; 08759000 T 0814 + PROCEDURE CLEU ; % COMPARE CHARACTERS LESS OR EQUAL, UPD 7.3.8 08760000 T 0815 + BEGIN P2R3 ← 1; 08761000 T 0815 + COMPARECHRS( TRUE , 6 ); % UPDATE LESS EQUAL 08762000 T 0816 + END CLEU; 08763000 T 0817 + PROCEDURE CLSD ; % COMPARE CHARACTERS LESS, DESTRUCTIVE 7.3.9 08764000 T 0818 + BEGIN P2R3 ← 1; 08765000 T 0818 + COMPARECHRS( FALSE , 3 ); % DESTRUCTIVE LESS 08766000 T 0819 + END CLSD; 08767000 T 0820 + PROCEDURE CLSU ; % COMPARE CHARACTERS LESS, UPDATE 7.3.10 08768000 T 0821 + BEGIN P2R3 ← 1; 08769000 T 0821 + COMPARECHRS( TRUE , 3 ); % UPDATE LESS 08770000 T 0822 + END CLSU; 08771000 T 0823 + PROCEDURE CNED ; % COMPARE CHARACTERS NOT EQUAL, DESTRUCTVE7.3.11 08772000 T 0824 + BEGIN P2R3 ← 1; 08773000 T 0824 + COMPARECHRS( FALSE , 2 ); % DESTRUCTIVE NOT EQUAL 08774000 T 0825 + END CNED; 08775000 T 0826 + PROCEDURE CNEU ; % COMPARE CHARACTERS NOT EQUAL, UPDATE 7.3.12 08776000 T 0827 + BEGIN P2R3 ← 1; 08777000 T 0827 + COMPARECHRS( TRUE , 2 ); % UPDATE NOT EQUAL 08778000 T 0828 + END CNEU; 08779000 T 0829 + DEFINE RPZF = BKIP#; 08779500 T 0830 + PROCEDURE UNPACKS(SIGNED,UPDATE); 08780000 T 0830 +PRT(760) = UNPACKS + VALUE SIGNED,UPDATE; 08781000 T 0830 + BOOLEAN SIGNED,UPDATE; 08782000 T 0830 + BEGIN 08783000 T 0830 + LABEL OC, L1, L2, L3, L4, L5, L6, L7, L8; 08784000 T 0830 + START OF SEGMENT ********** 81 + INTEGER RITEJUSTIFY; 08784500 T 0000 +STACK(F+2) = RITEJUSTIFY + ADJ (1,1); 08785000 T 0000 + IF BX.TAG = SINGL OR BX.TAG = DOUBL THEN ELSE 08785500 T 0001 + BEGIN 08786000 T 0004 + QF01 ← 1; 08786500 T 0004 + JFIF; 08787000 T 0006 + GO TO OC; 08787500 T 0054 + END; 08788000 T 0054 + ENTEREDIT (0, UPDATE); 08788500 T 0054 + RPF ← C.ADDR; 08789000 T 0055 + IF C.ADDR > 24 THEN 08789500 T 0056 + BEGIN 08790000 T 0058 + BROF ← TRUE; 08790500 T 0058 + QF01 ← 1; 08791000 T 0059 + JFIF; 08791500 T 0061 + GO TO OC; 08792000 T 0108 + END; 08792500 T 0108 + SSZ ← 4; 08793000 T 0108 + IF DSZ = 0 THEN DSZ ← 6; 08793500 T 0109 + IF RPF = 0 THEN 08794000 T 0111 + BEGIN 08794500 T 0112 + ENDE; GO TO OC; 08795000 T 0112 + END; 08795500 T 0113 + IF RPF = 1 THEN LHFF ← 1; 08796000 T 0113 + IF DSZ = 4 THEN RPZF ← 1; 08796500 T 0116 + L4: FETCHDESTINATION; 08797000 T 0119 + L7: IF DSZ = 4 THEN GO TO L1; 08797500 T 0197 + IF DSZ = 6 THEN GO TO L2; 08798000 T 0199 + IF NOT SIGNED THEN ELSE 08798500 T 0200 + IF LHFF ≠ 1 THEN ELSE 08799000 T 0201 + IF EXTF THEN 08799500 T 0203 + BEGIN 08800000 T 0204 + RITEJUSTIFY.[40:4] ← 32; 08800500 T 0205 + GO TO L3; 08801000 T 0206 + END; 08801500 T 0207 + RITEJUSTIFY.[40:4] ← 36; 08802000 T 0207 + L3: DYAL (RITEJUSTIFY, B, 40, DYALDIB, 4); 08802500 T 0209 + DYAL (A, B, DYALSIB, (DYALDIB - 4), 4); 08803000 T 0211 + GO TO L8; 08803500 T 0216 + L2: IF NOT SIGNED THEN ELSE 08804000 T 0216 + IF LHFF ≠ 1 THEN ELSE 08804500 T 0218 + IF EXTF THEN 08805000 T 0220 + BEGIN 08805500 T 0221 + RITEJUSTIFY.[42:2] ← 2; 08806000 T 0221 + GO TO L6; 08806500 T 0223 + END; 08807000 T 0223 + RITEJUSTIFY.[42:2] ← 0; 08807500 T 0223 + L6: DYAL (RITEJUSTIFY, B, 42, DYALDIB, 2); 08808000 T 0225 + DYAL (A, B, DYALSIB, (DYALDIB - 2), 4); 08808500 T 0228 + GO TO L8; 08809000 T 0233 + L1: IF SIGNED THEN 08809500 T 0233 + BEGIN 08810000 T 0234 + IF RPZF = 1 THEN 08810500 T 0234 + BEGIN 08811000 T 0236 + IF EXTF THEN RITEJUSTIFY ← 14 ELSE 08811500 T 0236 + RITEJUSTIFY ← 15; 08812000 T 0238 + DYAL(RITEJUSTIFY,B,3,DYALDIB,4); 08812500 T 0239 + GO TO L5; 08813000 T 0242 + END; 08813500 T 0242 + END; 08814000 T 0242 + DYAL (A, B, DYALSIB, DYALDIB, 4); 08815000 T 0242 + L8: BUMPSIB; 08816000 T 0246 + L5: IF BUMPDIB = 0 THEN 08817000 T 0249 + BEGIN 08818000 T 0252 + STOREB; 08819000 T 0253 + STEPDP; 08820000 T 0259 + END; 08821000 T 0261 + BEGIN 08822000 T 0261 + IF AX.TAG = DOUBL THEN 08822500 T 0261 + BEGIN 08823000 T 0263 + MOVE (A, JUNK); 08823500 T 0263 + MOVE (X, A); 08823800 T 0264 + MOVE (JUNK, X); 08824000 T 0265 + END; 08824400 T 0266 + END; 08824800 T 0266 + IF RPZF = 1 THEN RPZF ← 0 ELSE 08825000 T 0266 + RPF ← RPF - 1; 08825500 T 0270 + IF RPF = 0 THEN 08826000 T 0271 + BEGIN 08827000 T 0272 + IF DIB ≠ 0 THEN BROF ← TRUE; 08828000 T 0273 + ENDE; 08828500 T 0275 + GO TO OC; 08829000 T 0275 + END; 08830000 T 0276 + IF RPF = 1 THEN LHFF ← 1; 08831000 T 0276 + IF DIB = 0 THEN GO TO L4; 08832000 T 0279 + GO TO L7; 08833000 T 0280 + OC: 08834000 T 0280 + END OF UNPACKS; 08835000 T 0281 + 81 IS 284 LONG, NEXT SEG 12 + PROCEDURE PACKS (UPDATE); 08835100 T 0830 +PRT(761) = PACKS + VALUE UPDATE; 08835200 T 0830 + BOOLEAN UPDATE; 08835300 T 0830 + BEGIN 08835400 T 0830 + LABEL OC, L1, L2, L3; 08835500 T 0830 + START OF SEGMENT ********** 82 + ENTEREDIT (1, UPDATE); 08835600 T 0000 + RPF ← C.ADDR; 08835700 T 0001 + IF C.ADDR > 24 THEN 08835800 T 0002 + BEGIN 08835900 T 0003 + AROF ← TRUE; 08836000 T 0004 + QF01 ← 1; 08836100 T 0004 + JFIF; 08836200 T 0006 + GO TO OC; 08836300 T 0054 + END; 08836400 T 0054 + IF C.ADDR = 0 THEN 08836500 T 0054 + BEGIN 08836600 T 0055 + ENDE; 08836700 T 0056 + GO TO OC; 08836800 T 0056 + END; 08836900 T 0057 + TFFF←BOOLEAN(B←BX←0); 08836910 T 0057 + IF RPF > 12 THEN 08837000 T 0059 + BEGIN 08837100 T 0059 + BX.TAG ← DOUBL; 08837200 T 0060 + QH02 ← 1; 08837300 T 0062 + DIB ← 24 -RPF; 08837400 T 0063 + END ELSE 08837500 T 0065 + DIB ← 12 -RPF; 08837600 T 0065 + DSZ ← 4; 08837700 T 0066 + IF SSZ = 0 THEN 08837800 T 0067 + BEGIN 08837900 T 0068 + SSZ ← 6; 08838000 T 0068 + MOVE (A, Y); 08838100 T 0069 + END; 08838200 T 0070 + QH03 ← 1; 08838300 T 0070 + IF NOT SOPF THEN 08838400 T 0072 + BEGIN 08838500 T 0072 + L1: MM ← SBR + SIR; 08838600 T 0073 + MOVE (M[MM], A); 08838700 T 0075 + IF BOOLEAN (AX.TAG) THEN 08838800 T 0079 + BEGIN 08838900 T 0080 + MOVE (Y, A); 08839000 T 0080 + MOVE (C, B); 08839100 T 0081 + AROF ← BROF ← TRUE; 08839200 T 0082 + QF04 ← 1; 08839300 T 0083 + JFIF; 08839400 T 0085 + GO TO OC; 08839500 T 0133 + END; 08839600 T 0133 + END; 08839700 T 0133 + L3: IF SSZ ≠ 4 THEN 08839800 T 0133 + BEGIN 08839900 T 0134 + IF SSZ = 6 THEN 08840000 T 0135 + BEGIN DYAL(A,B,DYALSIB-2,DYALDIB,4); 08840100 T 0136 + DYAL(A,INTG,DYALSIB,0,1); TFFF←BOOLEAN(INTG); 08840110 T 0140 + 08840120 T 0144 + END ELSE 08840130 T 0144 + BEGIN DYAL(A,B,DYALSIB-4,DYALDIB,4); 08840200 T 0144 + DYAL(A,INTG,DYALSIB-2,0,1); 08840210 T 0149 + TFFF ← INTG = 0; 08840220 T 0152 + END; 08840230 T 0153 + END ELSE 08840300 T 0153 + IF QH03 = 1 THEN 08840400 T 0153 + BEGIN 08840500 T 0155 + QH03 ← 0; 08840600 T 0155 + DYAL (A, JUNK, DYALSIB, 44, 4); 08840700 T 0157 + IF JUNK.[44:4] > 9 THEN TFFF←JUNK.[44:4]=13 08840800 T 0160 + ELSE DYAL(A,B,DYALSIB,DYALDIB,4); 08840900 T 0162 + END ELSE 08841000 T 0168 + GO TO L2; 08841100 T 0168 + BUMPDIB; 08841200 T 0168 + L2: IF BUMPSIB = 0 THEN 08841300 T 0170 + BEGIN 08841400 T 0173 + IF SOPF THEN 08841500 T 0174 + BEGIN 08841600 T 0174 + MOVE (A, JUNK); 08841700 T 0175 + MOVE (X, A); 08841800 T 0176 + MOVE (JUNK, X); 08841900 T 0177 + END ELSE 08842000 T 0178 + SIR ← SIR + 1; 08842100 T 0178 + IF DIB ≠ 0 THEN GO TO L1; 08842200 T 0179 + IF QH02 = 1 THEN 08842300 T 0181 + BEGIN 08842400 T 0182 + QH02 ← 0; 08842500 T 0182 + GO TO L1; 08842600 T 0184 + END ELSE 08842700 T 0185 + BEGIN 08842800 T 0185 + BROF ← TRUE; 08842900 T 0185 + ADJ (2, 0); 08843000 T 0186 + ENDE; 08843100 T 0187 + GO TO OC; 08843200 T 0187 + END; 08843300 T 0188 + END ELSE 08843400 T 0188 + IF DIB ≠ 0 THEN GO TO L3; 08843500 T 0188 + BROF ← TRUE; 08843600 T 0190 + IF AROF THEN ADJ(1,0) ELSE ADJ(0,0); 08843700 T 0190 + IF QH02 = 1 THEN 08844000 T 0194 + BEGIN 08844500 T 0195 + QH02 ← 0; 08845000 T 0195 + GO TO L3; 08845500 T 0197 + END; 08846000 T 0198 + TFFF←DSZ=6 AND B.[42:1]=1 OR DSZ =8 AND B.[42:1]=0; 08847000 T 0198 + ENDE; 08847500 T 0203 + OC: 08848000 T 0203 + END OF PACKS; 08848500 T 0204 + 82 IS 205 LONG, NEXT SEG 12 + 08849000 T 0830 + PROCEDURE UABD; % UNPACK ABSOLUTE, DESTRUCTIVE 08849500 T 0830 + BEGIN P2R3 ← 1; 08850000 T 0830 + UNPACKS (FALSE, FALSE); 08850500 T 0831 + END UABD; 08851000 T 0832 + PROCEDURE UABU; % UNPACK ABSOLUTE, UPDATE 08851500 T 0833 + BEGIN P2R3 ← 1; 08852000 T 0833 + UNPACKS (FALSE, TRUE); 08852500 T 0834 + END UABU; 08853000 T 0835 + PROCEDURE USND; % UNPACK SIGNED, DESTRUCTIVE 08853500 T 0836 + BEGIN P2R3 ← 1; 08854000 T 0836 + UNPACKS (TRUE, FALSE); 08854500 T 0837 + END USND; 08855000 T 0838 + PROCEDURE USNU; % UNPACK SIGNED, UPDATE 08855500 T 0839 + BEGIN P2R3 ← 1; 08856000 T 0839 + UNPACKS (TRUE, TRUE); 08856500 T 0840 + END USNU; 08857000 T 0841 + PROCEDURE PACD; % PACK DESTRUCTIVE 08857500 T 0842 + BEGIN SWPS ← 1; P2R2 ← 1; 08858000 T 0842 + PACKS (FALSE); 08858500 T 0845 + END PACD; 08859000 T 0846 + PROCEDURE PACU; % PACK UPDATE 08859100 T 0846 + BEGIN SWPS ← 1; P2R2 ← 1; 08859200 T 0846 + PACKS (TRUE); 08859300 T 0850 + END PACU; 08859400 T 0851 + PROCEDURE TRNS ; % TRANSLATE 7.5 08860000 T 0851 + BEGIN 08861000 T 0851 + LABEL OC; 08862000 T 0851 + START OF SEGMENT ********** 83 + ADJ(1,2); 08863000 T 0000 + IF AX.TAG ≠ DATADESC THEN INVOPI; 08864000 T 0001 + IF BOOLEAN(AX) THEN ELSE 08865000 T 0005 + BEGIN 08866000 T 0005 + ADJ(0,0); 08867000 T 0006 + AX ← BX ← 0; 08868000 T 0007 + AROF ← BROF ← TRUE; 08869000 T 0008 + A ← S; 08870000 T 0009 + SETINTERRUPT(B←PRESBIT); 08871000 T 0010 + END; 08872000 T 0011 + AROF ← FALSE; 08873000 T 0011 + IF A.IBIT=0 THEN TIR ← 0 ELSE 08874000 T 0012 + TIR ← IF A.CHRSZ = 0 THEN A.INDEX ELSE A.TIRF; 08875000 T 0015 + TBR ← TIR + A.ADDR; 08876000 T 0021 + ENTEREDIT( 0,FALSE); 08877000 T 0023 + CHARSZ; 08878000 T 0024 + DIS ← 7; 08879000 T 0031 + RPF ← C.ADDR - 1; 08880000 T 0032 + WHILE RPF ≥ 0 DO 08881000 T 0034 + BEGIN 08882000 T 0035 + FETCHSOURCE; 08883000 T 0035 + FETCHDESTINATION; 08884000 T 0114 + MM ← 0; 08885000 T 0192 + DYAL(A,JUNK,DYALSIB,5,SSZ-2); 08886000 T 0193 + IF SSZ=4 THEN MM←JUNK.[42:2] ELSE 08887000 T 0196 + IF SSZ=6 THEN MM←JUNK.[42:4] ELSE MM←JUNK.[42:6]; 08888000 T 0199 + MM ← TBR + MM; 08889000 T 0203 + DYAL(A,JUNK,DYALSIB-SSZ+2,4,2); 08890000 T 0205 + DIS.[43:2] ← REAL(NOT BOOLEAN(JUNK)).[43:2]; 08891000 T 0208 + MOVE(M[MM],C); MEMCYCLE; 08892000 T 0211 + DYAL(C,8,DIS,DYALDIB,DSZ); 08893000 T 0216 + RPF ← RPF - 1; 08894000 T 0219 + BUMPSIB; 08895000 T 0220 + SWITCHSOURCE; 08896000 T 0222 + IF BUMPSIB = 0 THEN 08897000 T 0231 + BEGIN 08898000 T 0234 + STOREB; 08899000 T 0234 + STEPDP; 08900000 T 0241 + DIR ← DIR + 1; 08901000 T 0243 + END; 08902000 T 0244 + END; 08903000 T 0244 + ENDE; 08904000 T 0244 + OC: 08905000 T 0245 + END TRNS; 08906000 T 0246 + 83 IS 247 LONG, NEXT SEG 12 + PROCEDURE SCALE(TOG); VALUE TOG; BOOLEAN TOG; 08906010 T 0851 +PRT(762) = SCALE + BEGIN 08906020 T 0851 + DEFINE DYNAMIC = TOG #, %1 08906030 T 0851 + START OF SEGMENT ********** 84 + SAVER = TOG.[46:1]#, % 2 08906040 T 0000 + RIGHT = TOG.[45:1]#, % 4 08906050 T 0000 + FINAL = TOG.[44:1]#, % 6 08906060 T 0000 + ROUND = TOG.[43:1]#; % 16 08906070 T 0000 + REAL DIGR, TA, TX; 08906080 T 0000 +STACK(F+2) = DIGR +STACK(F+3) = TA +STACK(F+4) = TX + LABEL OC; 08906090 T 0000 + INTEGER SIGNQ,SIGNQH; 08906100 T 0000 +STACK(F+5) = SIGNQ +STACK(F+6) = SIGNQH + DEFINE SETINT = BEGIN 08906110 T 0000 + SETINTERRUPT(INVOP ); 08906120 T 0000 + ADJ(0,0); AROF ← BROF ← TRUE; 08906130 T 0000 + GO OC; 08906140 T 0000 + END#; 08906150 T 0000 + ADJ(0,1); 08906160 T 0000 + IF DYNAMIC THEN 08906170 T 0001 + BEGIN 08906180 T 0001 + NTGR; 08906190 T 0001 + IF SDIS=1 THEN 08906200 T 0002 + BEGIN 08906210 T 0003 + SETINTERRUPT(INTOVFI); 08906220 T 0004 + GO OC; 08906230 T 0004 + END; 08906240 T 0007 + END ELSE 08906250 T 0007 + BEGIN 08906260 T 0007 + C ← SYLLABLE; CX ← 0; 08906270 T 0007 + STEPPSR(1); 08906280 T 0011 + MOVE(C,A); 08906290 T 0011 + END; 08906300 T 0012 + DIGR ← A.[44:4]; 08906310 T 0012 + AROF ← FALSE; 08906320 T 0014 + IF INTEGERIZE(FALSE,B) THEN 08906330 T 0014 + BEGIN 08906340 T 0015 + SETINTERRUPT(INTOVFI); 08906350 T 0016 + GO OC; 08906360 T 0017 + END; 08906370 T 0019 + ADJ(1,0); 08906380 T 0019 + IF DIGR < 13 THEN ELSE 08906390 T 0020 + IF RIGHT THEN SETINT ELSE 08906400 T 0021 + BEGIN 08906410 T 0028 + OFFF ← TRUE; 08906420 T 0028 + GO OC; 08906430 T 0029 + END; 08906440 T 0029 + IF RIGHT THEN 08906450 T 0029 + BEGIN 08906460 T 0030 + MOVE(A,TA); 08906470 T 0031 + DOUBLE(A,X,10*DIGR,0,/,←,A,X); 08906480 T 0032 + SIGNQ ← SIGN(A); B.SOBIT ← 0; 08906490 T 0036 + MOVE(A,SSZ); 08906500 T 0040 + IF INTEGERIZE(FALSE,SSZ) THEN 08906510 T 0041 + BEGIN 08906520 T 0042 + SETINTERRUPT(INTOVFI); 08906530 T 0043 + GO OC; 08906540 T 0044 + END; 08906550 T 0046 + DSZ ← 0; 08906560 T 0046 + DOUBLE(TA,TX,10*DIGR,0,SIGNQ,SIGNQH,SSZ,DSZ, 08906570 T 0046 + ×,×,-,←,TA,TX); 08906580 T 0051 + FOR JUNK←0 STEP 1 UNTIL DIGR-1 DO 08906590 T 0052 + DYAL(TA,B,36-6×JUNK,4×JUNK,4); 08906600 T 0057 + END ELSE 08906610 T 0060 + DOUBLE(A,X,10*DIGR,0,×,←,A,X); 08906620 T 0060 + IF ROUND THEN ELSE GO OC; 08906630 T 0065 + IF FINAL THEN 08906640 T 0067 + BEGIN 08906650 T 0067 + BROF ← TRUE; 08906660 T 0068 + AROF ← FALSE; EXTF ← BOOLEAN(SIGN(A)); 08906670 T 0069 + IF A≠0 THEN OFFF ← TRUE; 08906680 T 0072 + END ELSE 08906690 T 0074 + IF SAVER THEN BROF ← TRUE ELSE 08906700 T 0074 + IF ROUND THEN 08906710 T 0076 + IF BX.PBIT=1 OR B.[1:3]>4 THEN X ← X + 1; 08906720 T 0078 + OC: 08906730 T 0083 + END SCALE; 08906740 T 0083 + 84 IS 87 LONG, NEXT SEG 12 + PROCEDURE SCLF ; % SCALE LEFT 7.6.1 08907000 T 0851 + BEGIN 08908000 T 0851 + SCALE(BOOLEAN( 0)); 08909000 T 0851 + END SCLF; 08910000 T 0852 + PROCEDURE DSLF ; % DYNAMIC SCALE LEFT 7.6.2 08911000 T 0853 + BEGIN 08912000 T 0853 + SCALE(BOOLEAN( 1)); 08913000 T 0853 + END DSLF; 08914000 T 0853 + PROCEDURE SCRS ; % SCALE RIGHT SAVE 7.6.3 08915000 T 0854 + BEGIN 08916000 T 0854 + SCALE(BOOLEAN( 6)); 08917000 T 0854 + END SCRS; 08918000 T 0854 + PROCEDURE DSRS ; % DYNAMIC SCALE RIGHT SAVE 7.6.4 08919000 T 0855 + BEGIN 08920000 T 0855 + SCALE(BOOLEAN( 7)); 08921000 T 0855 + END DSRS; 08922000 T 0855 + PROCEDURE SCRT ; % SCALE RIGHT TRUNCATE 7.6.5 08923000 T 0856 + BEGIN 08924000 T 0856 + SCALE(BOOLEAN(20)); 08925000 T 0856 + END SCRT; 08926000 T 0856 + PROCEDURE DSRT ; % DYNAMIC SCALE RIGHT TRUNCATE 7.6.6 08927000 T 0857 + BEGIN 08928000 T 0857 + SCALE(BOOLEAN(21)); 08929000 T 0857 + END DSRT; 08930000 T 0857 + PROCEDURE SCRR ; % SCALE RIGHT ROUND 7.6.7 08931000 T 0858 + BEGIN 08932000 T 0858 + SCALE(BOOLEAN( 4)); 08933000 T 0858 + END SCRR; 08934000 T 0858 + PROCEDURE DSRR ; % DYNAMIC SCALE RIGHT ROUND 7.6.8 08935000 T 0859 + BEGIN 08936000 T 0859 + SCALE(BOOLEAN( 5)); 08937000 T 0859 + END DSRR; 08938000 T 0859 + PROCEDURE SCRF ; % SCALE RIGHT FINAL 7.6.9 08939000 T 0860 + BEGIN 08940000 T 0860 + SCALE(BOOLEAN(12)); 08941000 T 0860 + END SCRF; 08942000 T 0860 + PROCEDURE DSRF ; % DYNAMIC SCALE RIGHT FINAL 7.6.10 08943000 T 0861 + BEGIN 08944000 T 0861 + SCALE(BOOLEAN(13)); 08945000 T 0861 + END DSRF; 08946000 T 0861 + PROCEDURE OCRX ; % OCCURS INDEX 7.7 08947000 T 0862 + BEGIN 08948000 T 0862 + LABEL OC; 08949000 T 0862 + START OF SEGMENT ********** 85 + ADJ(1,1); 08950000 T 0000 + IF AX.TAG=SINGL AND BX.TAG=SINGL OR BX.TAG=DOUBL THEN ELSE 08951000 T 0001 + BEGIN INTFAMA(-1); GO OC END; 08952000 T 0005 + MOVE(A,C); A←AX ←X ← XX ← 0; 08953000 T 0007 + A.[32:1] ← C.[16:16]; 08954000 T 0011 + X.[32:16] ← 0&CX [32:47:1]&C[33:1:15]; 08955000 T 0013 + AROF ← FALSE; 08956000 T 0017 + IF INTEGERIZE(FALSE,B) THEN BEGIN INTFAMA(INTOVFI);GO OC END; 08957000 T 0017 + IF B < 0 AND B > A THEN BEGIN INTFAMA(INVINXI); GO OC END; 08958000 T 0022 + MOVE(X,A); XX ← 0; 08959000 T 0027 + X ← C.[32:16]; 08960000 T 0028 + AROF ← TRUE; 08961000 T 0030 + B ← X + A × (B-1); 08962000 T 0030 + OC: 08966000 T 0033 + END OCRX; 08967000 T 0033 + 85 IS 34 LONG, NEXT SEG 12 + PROCEDURE SISO; % STRING ISOLATE 08968000 T 0862 + BEGIN 08968100 T 0862 + LABEL OC, L1, L2, L3; 08968200 T 0862 + START OF SEGMENT ********** 86 + ENTEREDIT (1, FALSE); 08968300 T 0000 + IF SSZ = 0 THEN SSZ ← 6; 08968400 T 0001 + IF C.ADDR > (96 DIV SSZ) THEN 08968500 T 0003 + BEGIN 08968600 T 0004 + MOVE (C, A); 08968700 T 0005 + AROF ← BROF ← TRUE; 08968800 T 0006 + QF01 ← 1; 08968900 T 0007 + JFIF; 08969000 T 0009 + GO TO OC; 08969100 T 0057 + END; 08969200 T 0057 + RPF ← C.ADDR; 08969300 T 0057 + BX ← B ← YX ← Y ← 0; 08969400 T 0058 + IF C.ADDR > (48 DIV SSZ) THEN 08969500 T 0061 + BEGIN 08969600 T 0062 + C.ADDR ← (C.ADDR - 48 DIV SSZ); 08969700 T 0063 + QH02 ← 1; 08969800 T 0066 + END; 08969900 T 0068 + DIB ← (48 DIV SSZ - C.ADDR); 08970000 T 0068 + IF SOPF THEN 08970100 T 0070 + BEGIN 08970200 T 0070 + MOVE (A, X); 08970300 T 0071 + L3: MM ← SBR + SIR; 08970400 T 0072 + MOVE (M[MM],A); 08970500 T 0074 + AROF ← TRUE; 08970600 T 0078 + IF BOOLEAN (AX.TAG) THEN 08970700 T 0079 + BEGIN 08970800 T 0079 + IF SOPF THEN 08970900 T 0080 + BEGIN 08971000 T 0080 + MOVE (X, A); 08971100 T 0081 + AROF ← TRUE; 08971200 T 0082 + END ELSE 08971300 T 0082 + BEGIN 08971400 T 0082 + IF QH01 = 1 THEN 08971500 T 0083 + BEGIN 08971600 T 0084 + MOVE (A, JUNK); 08971700 T 0085 + MOVE (X, A); 08971800 T 0086 + MOVE (JUNK, X); 08971900 T 0087 + END; 08972000 T 0088 + END; 08972100 T 0088 + QF04 ← 1; 08972200 T 0088 + JGIF; 08972300 T 0089 + GO TO OC; 08972400 T 0155 + END; 08972500 T 0155 + END; 08972600 T 0155 + L1: IF LHFF = 1 THEN 08972700 T 0155 + BEGIN 08972800 T 0157 + BX.TAG ← DOUBL; 08972900 T 0157 + DYAL (A, Y, DYALSIB, DYALDIB, SSZ); 08973000 T 0159 + END ELSE 08974000 T 0163 + DYAL (A, B, DYALSIB, DYALDIB, SSZ); 08975000 T 0163 + IF BUMPDIB = 0 THEN 08976000 T 0167 + BEGIN 08977000 T 0170 + IF LHFF ≠ 0 THEN GO TO L2; 08978000 T 0170 + IF QH02 ≠ 1 THEN GO TO L2; 08979000 T 0172 + LHFF ← 1; 08980000 T 0174 + END; 08981000 T 0176 + IF BUMPSIB = 0 THEN 08982000 T 0176 + BEGIN 08983000 T 0178 + QH01 ← 1; 08984000 T 0179 + IF NOT SOPF THEN GO TO L3 ELSE 08985000 T 0181 + BEGIN 08986000 T 0181 + MOVE (A, JUNK); 08987000 T 0181 + MOVE (X, A); 08988000 T 0182 + MOVE (JUNK, X); 08989000 T 0183 + END; 08990000 T 0184 + END; 08991000 T 0184 + GO TO L1; 08992000 T 0184 + L2: AROF ← EXSF ← SOPF ← FALSE; 08993000 T 0185 + BROF ← TRUE; 08994000 T 0187 + OC: 08995000 T 0188 + END OF STRING ISOLATE; 08996000 T 0189 + 86 IS 190 LONG, NEXT SEG 12 + PROCEDURE SXSN ; % SET EXTERNAL SIGN 7.9 08997000 T 0862 + BEGIN 08998000 T 0862 + ADJ(1,2); 08999000 T 0862 + 09000000 T 0863 + EXTF ← BOOLEAN(A.SOBIT); 09001000 T 0863 + END SXSN; 09002000 T 0864 + PROCEDURE RTFF ; % READ TRUE/FALSE FLIP-FLOP 7.10 09003000 T 0864 + BEGIN 09004000 T 0864 + ADJ(0,2); 09005000 T 0864 + AX ← A ← 0; 09006000 T 0866 + AROF ← TRUE; 09006500 T 0867 + A ← REAL(TFFF); 09007000 T 0868 + END RTFF; 09008000 T 0868 + PROCEDURE ROFF ; % READ AND CLEAR OVERFLOW FLIP-FLOP 7.11 09009000 T 0869 + BEGIN 09010000 T 0869 + ADJ(0,2); 09011000 T 0869 + AX ← A ← 0; 09012000 T 0870 + AROF ← TRUE; 09012500 T 0871 + A ← REAL(OFFF); 09013000 T 0872 + OFFF ← FALSE; 09014000 T 0872 + END ROFF; 09015000 T 0873 + PROCEDURE INPCONV( UPDATE); VALUE UPDATE; BOOLEAN UPDATE; 09015010 T 0873 +PRT(763) = INPCONV + BEGIN 09015020 T 0873 + REAL DIGR ; 09015030 T 0873 + START OF SEGMENT ********** 87 +STACK(F+2) = DIGR + LABEL OC; 09015040 T 0000 + ADJ(0,1); 09015050 T 0000 + IF INTEGERIZE(FALSE,B) THEN 09015060 T 0001 + BEGIN 09015070 T 0002 + SETINTERRUPT(INTOVFI); 09015080 T 0002 + ADJ(0,0); AROF ← BROF ← TRUE; 09015090 T 0003 + GO OC; 09015100 T 0005 + END; 09015110 T 0007 + ADJ(1,1); 09015120 T 0007 + IF A.[43:5] > 23 THEN 09015130 T 0008 + BEGIN 09015140 T 0009 + SETINTERRUPT(INVOP); 09015150 T 0009 + ADJ(0,0); AROF ← BROF ← TRUE; 09015160 T 0010 + GO OC; 09015170 T 0012 + END; 09015180 T 0015 + IF UPDATE THEN 09015190 T 0015 + BEGIN 09015200 T 0015 + PACU; ADJ(1,1); 09015210 T 0015 + END ELSE 09015220 T 0017 + BEGIN 09015230 T 0017 + PACU; ADJ(0,1); 09015240 T 0017 + END; 09015250 T 0019 + MOVE(A,C); 09015260 T 0019 + JUNK ← DIGR ← 09015270 T 0020 + A ← AX ← X ← XX ← 0; 09015280 T 0020 + DO BEGIN 09015290 T 0023 + DOUBLE(A,X,10,0,×,←,A,X); 09015300 T 0023 + IF DIGR < 12 THEN 09015310 T 0026 + BEGIN 09015320 T 0026 + DYAL(B,JUNK,47-4×DIGR,3,4); 09015330 T 0027 + X ← X + JUNK.[44:4]; 09015340 T 0030 + END ELSE 09015350 T 0031 + BEGIN 09015360 T 0031 + DYAL(Y,JUNK,48-4×DIGR,3,4); 09015370 T 0032 + X ← X + JUNK.[44:4]; 09015380 T 0035 + END; 09015390 T 0036 + END UNTIL DIGR ← DIGR + 1 = 24; 09015400 T 0036 + MOVE(A,B); MOVE(X,Y); MOVE(C,A); 09015410 T 0039 + IF B ≠ 0 THEN 09015420 T 0042 + BEGIN 09015430 T 0042 + B.SOBIT ← 1; 09015440 T 0043 + TFFF ← FALSE; 09015450 T 0045 + BX.TAG ← DOUBL; 09015460 T 0045 + 09015470 T 0047 + END ELSE 09015480 T 0047 + BEGIN 09015490 T 0047 + MOVE(Y,B); 09015500 T 0048 + B.SOBIT ← REAL(TFFF); 09015510 T 0049 + TFFF ← TRUE; 09015520 T 0050 + BX.TAG ← SINGL; 09015530 T 0051 + END; 09015540 T 0053 + OC: 09015545 T 0053 + END OF INPCONV; 09015550 T 0054 + 87 IS 57 LONG, NEXT SEG 12 + PROCEDURE ICVD ; % INPUT CONVERT, DESTRUCTIVE 7.12.1 09016000 T 0873 + BEGIN 09017000 T 0873 + INPCONV(FALSE); 09018000 T 0873 + END ICVD; 09019000 T 0874 + PROCEDURE ICVU ; % INPUT CONVERT, UPDATE 7.12.2 09020000 T 0875 + BEGIN 09021000 T 0875 + INPCONV(TRUE ); 09022000 T 0875 + END ICVU; 09023000 T 0875 + PROCEDURE TEED ; % TABLE ENTER EDIT, DESTRUCTIVE 7.13.1 09024000 T 0876 + BEGIN 09025000 T 0876 + ENTEREDIT(3,FALSE); 09026000 T 0876 + END TEED; 09027000 T 0877 + PROCEDURE TEEU ; % TABLE ENTER EDIT, UPDATE 7.13.2 09028000 T 0877 + BEGIN 09029000 T 0877 + ENTEREDIT(3, TRUE); 09030000 T 0877 + END TEEU; 09031000 T 0879 + PROCEDURE ILED ; % IN LINE ENTER EDIT, DESTRUCTIVE 7.13.3 09032000 T 0879 +PRT(764) = ILED + BEGIN 09033000 T 0879 + ENTEREDIT(2,FALSE); 09034000 T 0879 + END ILED; 09035000 T 0881 + PROCEDURE ILEU ; % IN LINE ENTER EDIT, UPDATE 7.13.4 09036000 T 0881 +PRT(765) = ILEU + BEGIN 09037000 T 0881 + ENTEREDIT(2, TRUE); 09038000 T 0881 + END ILEU; 09039000 T 0883 + PROCEDURE EXPU ; % SINGLE PINTER ENTER EDIT 09040000 T 0883 + BEGIN 09041000 T 0883 + ENTEREDIT(1,TRUE); 09042000 T 0883 + END OF SPEE; 09043000 T 0885 + PROCEDURE EXSD ; % EXECUTE SINGLE MICRO, DESTRUCTIVE 7.13.5 09044000 T 0885 + BEGIN 09045000 T 0885 + ENTEREDIT(0,FALSE); 09046000 T 0885 + END EXSD; 09047000 T 0887 + PROCEDURE EXSU ; % EXECUTE SINGLE MICRO, UPDATE 7.13.6 09048000 T 0887 + BEGIN 09049000 T 0887 + ENTEREDIT(0, TRUE); 09050000 T 0887 + END EXSU; 09051000 T 0889 + PROCEDURE MOVES (NUMRIC); 09052000 T 0889 +PRT(766) = MOVES + VALUE NUMRIC; 09053000 T 0889 + BOOLEAN NUMRIC; 09054000 T 0889 + BEGIN 09055000 T 0889 + INTEGER PLUG; 09055500 T 0889 + START OF SEGMENT ********** 88 +STACK(F+2) = PLUG + LABEL OC, L1, L2, L3, L4, L5; 09056000 T 0000 + EDITF ← TRUE; 09057000 T 0000 + SETUPEXSF; 09058000 T 0000 + CHARSZ; 09059000 T 0007 + IF C.ADDR = 0 THEN GO TO L1; 09060000 T 0015 + RPF ← C.ADDR; 09061000 T 0017 + QH03 ← 1; 09062000 T 0018 + L2: IF NOT SOPF THEN 09063000 T 0020 + BEGIN 09064000 T 0020 + MM ← SBR + SIR; 09065000 T 0021 + MOVE (M[MM], A); MEMCYCLE; 09066000 T 0022 + IF BOOLEAN (AX.TAG) THEN 09067000 T 0027 + BEGIN 09068000 T 0028 + L4: BKIP ← 1; 09069000 T 0028 + MEMPROTECT; 09070000 T 0030 + END; 09071000 T 0099 + END; 09072000 T 0099 + IF QH03 = 1 THEN QH03 ← 0 ELSE 09073000 T 0099 + L5: IF DIB ≠ 0 THEN GO TO L3; 09074000 T 0103 + IF BROF THEN BROF ← FALSE ELSE 09075000 T 0105 + BEGIN 09076000 T 0106 + MM ← DBR + DIR; 09077000 T 0107 + MOVE (M[MM], B); MEMCYCLE; 09078000 T 0108 + IF BOOLEAN (BX.TAG) THEN GO TO L4; 09079000 T 0113 + END; 09080000 T 0115 + L3: IF NUMRIC THEN 09081000 T 0115 + BEGIN 09082000 T 0116 + IF SSZ = 4 THEN 09083000 T 0116 + BEGIN 09084000 T 0117 + DYAL (A, B, DYALSIB, DYALDIB, 4); 09085000 T 0118 + END ELSE 09086000 T 0121 + IF SSZ = 6 THEN 09087000 T 0121 + BEGIN 09088000 T 0123 + PLUG ← 0; 09089000 T 0123 + DYAL (PLUG, B, 46, DYALDIB,2); 09089500 T 0124 + DYAL (A, B,(DYALSIB - 2), (DYALDIB -2),4); 09090000 T 0127 + END ELSE 09091000 T 0131 + BEGIN 09092000 T 0131 + PLUG ← 17; 09093000 T 0132 + DYAL (PLUG, B, 44, DYALDIB, 4); 09093050 T 0133 + DYAL (A, B,(DYALSIB -4),(DYALDIB -4), 4); 09094000 T 0135 + END; 09095000 T 0140 + END ELSE 09096000 T 0140 + DYAL (A, B, DYALSIB, DYALDIB, SSZ); 09097000 T 0140 + BUMPSIB; 09098000 T 0144 + SWITCHSOURCE; 09099000 T 0147 + RPF ← RPF - 1; 09100000 T 0155 + IF RPF = 0 THEN 09101000 T 0156 + BEGIN 09102000 T 0157 + MOVE (B, M[DBR + DIR]); MEMCYCLE; 09103000 T 0158 + LHFF ← 1; 09104000 T 0163 + END; 09105000 T 0165 + IF BUMPDIB = 0 THEN 09106000 T 0165 + BEGIN 09107000 T 0168 + MOVE (B, M[DBR + DIR]); MEMCYCLE; 09108000 T 0168 + END; 09109000 T 0174 + STEPDP; 09110000 T 0174 + IF LHFF = 0 THEN 09111000 T 0176 + BEGIN 09112000 T 0177 + IF SIB = 0 THEN GO TO L2; 09113000 T 0178 + GO TO L5; 09114000 T 0179 + END; 09115000 T 0180 + L1: IF EXSF THEN ENDE ELSE BROF ← TRUE; 09116000 T 0180 + OC: 09117000 T 0182 + END OF MOVES FOR MOVE CHARAS AND NUMERIC UNCOND; 09118000 T 0183 + 88 IS 186 LONG, NEXT SEG 12 + PROCEDURE MCHR; % MOVE CHARACTERS 09119000 T 0889 + BEGIN 09120000 T 0889 + P2R3 ← 1; 09121000 T 0889 + MOVES (FALSE); 09122000 T 0891 + END; 09123000 T 0892 + PROCEDURE MVNU; % MOVE NUMERIC UNCONDITIONAL 09124000 T 0892 + BEGIN 09125000 T 0892 + P2R3 ← 1; 09126000 T 0892 + MOVES (TRUE); 09127000 T 0894 + END; 09128000 T 0895 + PROCEDURE SKIPS (FORWAD, SOURCE); 09130000 T 0895 +PRT(767) = SKIPS + VALUE FORWAD, SOURCE; 09130500 T 0895 + BOOLEAN FORWAD, SOURCE; 09131000 T 0895 + BEGIN 09131500 T 0895 + LABEL OC, L1, L2, L3, MPERR, L4; 09132000 T 0895 + START OF SEGMENT ********** 89 + EDITF ← TRUE; 09132500 T 0000 + SETUPEXSF; 09133000 T 0000 + RPF ← BUF ← C.ADDR; 09133500 T 0007 + IF C.ADDR ≤ 0 THEN GO TO L3; 09134000 T 0009 + QH03 ← 1; 09134500 T 0011 + IF SOURCE THEN 09135000 T 0013 + BEGIN 09135500 T 0013 + IF SSZ = 0 THEN SSZ ← 6; 09136000 T 0013 + IF NOT SOPF THEN 09136500 T 0015 + BEGIN 09137000 T 0016 + L1: MM ← SBR + SIR; 09137500 T 0016 + MOVE (M[MM], A); 09138000 T 0018 + IF BOOLEAN (AX.TAG) THEN GO TO MPERR; 09138500 T 0022 + IF QH03 = 0 THEN 09139000 T 0023 + L2: IF FORWAD THEN 09139500 T 0025 + BEGIN 09140000 T 0026 + BUF ← RPF - 1; 09140500 T 0026 + RPF ← RPF - 1; 09141000 T 0028 + IF RPF = 0 THEN GO TO L3; 09141500 T 0029 + END ELSE 09142000 T 0030 + BEGIN 09143000 T 0030 + SIB ←(48 DIV SSZ); 09144000 T 0031 + END ELSE 09145000 T 0032 + QH03 ← 0; 09146000 T 0032 + END; 09147000 T 0034 + IF FORWAD THEN RPF ← RPF -(48 DIV SSZ -(SIB+1)) 09148000 T 0034 + ELSE 09149000 T 0037 + BEGIN 09150000 T 0038 + RPF ← RPF - SIB; 09151000 T 0038 + BUF ← RPF; 09152000 T 0039 + END; 09153000 T 0040 + IF RPF < 0 THEN RPZF ← 1; 09154000 T 0040 + IF RPF = 0 THEN LHFF ← 1; 09155000 T 0043 + IF FORWAD THEN 09156000 T 0046 + BEGIN 09157000 T 0046 + IF LHFF = 1 OR RPZF = 1 THEN 09158000 T 0047 + BEGIN 09159000 T 0050 + SIB ← SIB + BUF; 09160000 T 0050 + GO TO L3; 09161000 T 0051 + END; 09162000 T 0052 + SIB ← 0; 09163000 T 0052 + IF NOT SOPF THEN 09164000 T 0053 + BEGIN 09165000 T 0053 + SIR ← SIR + 1; 09166000 T 0054 + GO TO L1 09167000 T 0055 + END ELSE 09168000 T 0055 + BEGIN 09169000 T 0055 + MOVE (A, JUNK); 09170000 T 0056 + MOVE (X, A); 09171000 T 0057 + MOVE (JUNK, X); 09172000 T 0058 + GO TO L2; 09173000 T 0059 + END; 09174000 T 0059 + END ELSE 09175000 T 0059 + BEGIN 09176000 T 0059 + SIB ← 0; 09177000 T 0060 + IF LHFF = 1 OR RPZF = 1 THEN 09178000 T 0061 + BEGIN 09179000 T 0063 + SIB ← ABS (BUF + 0); 09180000 T 0064 + GO TO L3; 09181000 T 0065 + END; 09182000 T 0066 + IF NOT SOPF THEN 09183000 T 0066 + BEGIN 09184000 T 0066 + SIR ← SIR - 1; 09185000 T 0067 + GO TO L1; 09186000 T 0068 + END ELSE 09187000 T 0069 + BEGIN 09188000 T 0069 + MOVE (A, JUNK); 09189000 T 0069 + MOVE (X, A); 09190000 T 0070 + MOVE (JUNK, X); 09191000 T 0071 + GO TO L2; 09192000 T 0072 + END; 09193000 T 0073 + END; 09194000 T 0073 + END ELSE 09195000 T 0073 + BEGIN 09196000 T 0073 + IF DSZ = 0 THEN DSZ ← 6; 09197000 T 0073 + IF NOT BROF THEN 09198000 T 0075 + BEGIN 09199000 T 0076 + L4: MM ← DBR + DIR; 09200000 T 0076 + MOVE (M[MM], B); 09201000 T 0078 + IF BOOLEAN (BX.TAG) THEN GO TO MPERR; 09202000 T 0082 + END; 09203000 T 0083 + IF FORWAD THEN 09204000 T 0083 + BEGIN 09205000 T 0084 + IF QH03 = 0 THEN 09206000 T 0084 + BEGIN 09207000 T 0085 + BUF ← RPF - 1; 09208000 T 0086 + RPF ← BUF; 09209000 T 0087 + IF RPF = 0 THEN GO TO L3; 09210000 T 0088 + END ELSE 09211000 T 0089 + QH03 ← 0; 09212000 T 0089 + RPF ← RPF - (48 DIV SSZ - (DIB + 1)); 09213000 T 0091 + END ELSE 09214000 T 0094 + BEGIN 09215000 T 0094 + IF QH03 = 0 THEN DIB ← (48 DIV SSZ) ELSE 09216000 T 0095 + QH03 ← 0; 09217000 T 0098 + RPF ← RPF - DIB; 09218000 T 0100 + BUF ← RPF; 09218500 T 0101 + END; 09219000 T 0102 + IF RPF < 0 THEN RPZF ← 1; 09220000 T 0102 + IF RPF = 0 THEN LHFF ← 1; 09221000 T 0105 + IF FORWAD THEN 09222000 T 0108 + BEGIN 09223000 T 0108 + IF LHFF = 1 OR RPZF = 1 THEN 09224000 T 0109 + BEGIN 09225000 T 0111 + DIB ← DIB + BUF; 09226000 T 0112 + GO TO L3; 09227000 T 0113 + END ELSE 09228000 T 0114 + BEGIN 09229000 T 0114 + DIB ← 0; 09230000 T 0114 + BROF ← FALSE; 09231000 T 0115 + DIR ← DIR + 1; 09232000 T 0116 + GO TO L4; 09233000 T 0117 + END; 09234000 T 0117 + END ELSE 09235000 T 0117 + BEGIN 09235500 T 0117 + DIB ← 0; 09236000 T 0118 + IF LHFF = 1 OR RPZF = 1 THEN 09237000 T 0119 + BEGIN 09238000 T 0121 + DIB ← ABS (RPF + 0); 09239000 T 0122 + GO TO L3; 09240000 T 0123 + END ELSE 09241000 T 0124 + BEGIN 09242000 T 0124 + BROF ← FALSE; 09243000 T 0124 + DIR ← DIR - 1; 09244000 T 0125 + GO TO L4; 09245000 T 0126 + END; 09245500 T 0127 + END; 09246000 T 0127 + END; 09246500 T 0127 + MPERR: 09247000 T 0127 + UPDF ← TRUE; 09248000 T 0128 + ENDE; 09249000 T 0128 + BKIP ← 1; QF04 ← 1; 09250000 T 0129 + JGIF; 09251000 T 0132 + GO TO OC; 09252000 T 0198 + L3: IF EXSF THEN ENDE; 09253000 T 0198 + OC: 09254000 T 0200 + END OF SKIPS; 09255000 T 0201 + 89 IS 202 LONG, NEXT SEG 12 + PROCEDURE SFSC; % SKIP FORWARD SOURCE CHARACTERS 09255500 T 0895 + BEGIN P2R3 ← 1; 09256000 T 0895 + SKIPS (TRUE, TRUE); 09257000 T 0897 + END SFSC; 09258000 T 0898 + PROCEDURE SRSC; % SKIP REVERSE SOURCE CHARACTERS 09259000 T 0899 + BEGIN P2R3 ← 1; 09260000 T 0899 + SKIPS (FALSE, TRUE); 09261000 T 0900 + END SRSC; 09262000 T 0901 + PROCEDURE SFDC; % SKIP FORWARD DESTINATION CHARACTERS 09263000 T 0902 + BEGIN P2R3 ← 1; 09264000 T 0902 + SKIPS (TRUE, FALSE); 09265000 T 0903 + END SFDC; 09265500 T 0904 + PROCEDURE SRDC; % SKIP REVERSE DESTINATION CHARACTERS 09266000 T 0905 + BEGIN P2R3 ← 1; 09267000 T 0905 + SKIPS (FALSE, FALSE); 09268000 T 0906 + END SRDC; 09269000 T 0907 + PROCEDURE INSERTS(CONDITIONAL); 09270000 T 0908 +PRT(770) = INSERTS + VALUE CONDITIONAL; 09271000 T 0908 + BOOLEAN CONDITIONAL; 09272000 T 0908 + BEGIN 09273000 T 0908 + LABEL OC; 09274000 T 0908 + START OF SEGMENT ********** 90 + EDITF ← TRUE; 09274100 T 0000 + SETUPEXSF; 09275000 T 0000 + RPF←C; 09276000 T 0007 + Y←SYLLABLE; 09277000 T 0008 + STEPPSR(1); 09278000 T 0011 + IF CONDITIONAL THEN 09279000 T 0012 + IF NOT FLTF THEN STEPPSR(1) ELSE 09280000 T 0012 + BEGIN 09281000 T 0014 + Y ← SYLLABLE; YX ← 0; 09282000 T 0015 + STEPPSR(1); 09283000 T 0018 + END; 09284000 T 0019 + WHILE RPF > 0 DO 09285000 T 0019 + BEGIN 09286000 T 0020 + FETCHDESTINATION; 09287000 T 0020 + DYAL(Y,B,DSZ-1,DYALDIB,DSZ); 09288000 T 0098 + IF BUMPDIB = 0 THEN 09289000 T 0101 + BEGIN 09290000 T 0104 + STOREB; 09291000 T 0105 + STEPDP; 09292000 T 0111 + END; 09293000 T 0113 + RPF ← RPF - 1; 09294000 T 0113 + END; 09295000 T 0114 + IF EXSF THEN ENDE; 09296000 T 0115 + OC: 09297000 T 0116 + END OF INSERTS; 09298000 T 0117 + 90 IS 118 LONG, NEXT SEG 12 + PROCEDURE INSU ; % INSERT UNCONDITIONAL 8.4.1 09299000 T 0908 + BEGIN 09300000 T 0908 + INSERTS(FALSE); 09301000 T 0908 + END INSU; 09302000 T 0908 + PROCEDURE INSC ; % INSERT CONDITIONAL 8.4.2 09303000 T 0909 + BEGIN 09304000 T 0909 + INSERTS(TRUE ); 09305000 T 0909 + END INSC; 09306000 T 0909 + PROCEDURE INSG ; % INSERT DISPLAY SIGN 8.4.3 09307000 T 0910 + BEGIN 09308000 T 0910 + LABEL OC; 09309000 T 0910 + START OF SEGMENT ********** 91 + EDITF ← TRUE; 09309100 T 0000 + IF DSZ = 0 THEN DSZ ← 6 ELSE 09310000 T 0000 + IF DSZ = 4 THEN 09311000 T 0002 + BEGIN 09311100 T 0004 + UPDF ← TRUE; 09311200 T 0004 + ENDE; 09311300 T 0005 + QF01 ← 1; 09311400 T 0005 + BKIP ← 1; 09311500 T 0007 + JGIF; 09311600 T 0009 + GO OC; 09311700 T 0074 + END; 09311800 T 0074 + IF EXTF THEN ELSE STEPPSR(1); 09312000 T 0074 + Y← SYLLABLE; YX←0; 09313000 T 0076 + IF EXTF THEN STEPPSR(2) ELSE STEPPSR(1); 09314000 T 0080 + FETCHDESTINATION; 09315000 T 0082 + DYAL(Y,B,DSZ-1,DYALDIB,DSZ); 09316000 T 0160 + BUMPDIB; 09317000 T 0163 + IF DIB = 0 THEN 09318000 T 0166 + BEGIN 09320000 T 0166 + STOREB; 09321000 T 0167 + STEPDP; 09322000 T 0173 + END; 09323000 T 0175 + IF EXSF THEN ENDE; 09324000 T 0175 + OC: 09325000 T 0177 + END INSG; 09326000 T 0177 + 91 IS 178 LONG, NEXT SEG 12 + PROCEDURE INOP ; % INSERT OVERPUNCH 8.4.4 09327000 T 0910 + BEGIN 09328000 T 0910 + LABEL OC; 09329000 T 0910 + START OF SEGMENT ********** 92 + EDITF ← TRUE; 09330000 T 0000 + IF DSZ=0 THEN DSZ←6 ELSE 09331000 T 0000 + IF DSZ=4 THEN 09332000 T 0002 + BEGIN 09333000 T 0004 + UPDF ← TRUE; ENDE; 09334000 T 0004 + QF01← 1; 09335000 T 0005 + BKIP ← 1; 09336000 T 0007 + JGIF; 09337000 T 0009 + GO OC; 09338000 T 0074 + END; 09339000 T 0074 + FETCHDESTINATION; 09340000 T 0074 + IF EXTF THEN 09341000 T 0152 + IF (DIB←DIB-DSZ) < 0 THEN 09342000 T 0152 + IF DSZ=6 THEN DYAL(INTG←2,B,1,DYALDIB,2) 09343000 T 0155 +PRT(771) = *LIST, LABEL, OR SEGMENT DESCRIPTOR* + ELSE DYAL(INTG←13,B,3,DYALDIB,4); 09344000 T 0162 +PRT(772) = *LIST, LABEL, OR SEGMENT DESCRIPTOR* + BUMPDIB; 09345000 T 0170 + IF DIB=0 THEN 09346000 T 0172 + BEGIN 09347000 T 0173 + STOREB; 09347100 T 0173 + STEPDP; 09347200 T 0180 + END; 09347300 T 0182 + IF EXSF THEN ENDE; 09347400 T 0182 + OC: 09348000 T 0183 + END INOP; 09349000 T 0184 + 92 IS 185 LONG, NEXT SEG 12 + PROCEDURE RSTF ; % RESET FLOAT 09350000 T 0910 + BEGIN 09351000 T 0910 + FLTF ← FALSE; 09352000 T 0910 + END RFLT; 09353000 T 0910 + PROCEDURE ENDF ; % END FLOAT 8.9 09354000 T 0911 + BEGIN 09355000 T 0911 + LABEL OC; 09356000 T 0911 + START OF SEGMENT ********** 93 + EDITF ← TRUE; 09356100 T 0000 + IF FLTF THEN 09357000 T 0000 + BEGIN 09358000 T 0001 + STEPPSR(2); 09359000 T 0001 + FLTF ← FALSE; 09360000 T 0002 + GO OC; 09361000 T 0003 + END; 09362000 T 0003 + IF DSZ=0 THEN DSZ←6; 09363000 T 0003 + FETCHDESTINATION; 09364000 T 0005 + Y ← SYLLABLE; YX ← 0; 09365000 T 0083 + STEPPSR(1); 09366000 T 0087 + IF EXTF THEN Y ← SYLLABLE; 09367000 T 0087 + STEPPSR(1); 09368000 T 0091 + DYAL(Y,B,DSZ-1,DIB,DSZ); 09369000 T 0092 + BUMPDIB; 09370000 T 0094 + IF DIB = 0 THEN 09371000 T 0096 + BEGIN 09372000 T 0097 + STOREB; 09373000 T 0097 + STEPDP; 09374000 T 0104 + END; 09375000 T 0106 + IF EXSF THEN ENDE; 09376000 T 0106 + OC: 09377000 T 0107 + END ENDF; 09378000 T 0108 + 93 IS 109 LONG, NEXT SEG 12 + PROCEDURE MINS ; % MOVE WITH INSERT 8.10 09379000 T 0911 + BEGIN 09380000 T 0911 + BOOLEAN LHFF; 09381000 T 0911 + START OF SEGMENT ********** 94 +STACK(F+2) = LHFF + LABEL L12,L8,L10,L14,L20,L11,OC; 09382000 T 0000 + EDITF ← TRUE; 09383000 T 0000 + SETUPEXSF; 09384000 T 0000 + Y ← SYLLABLE; YX ← 0; STEPPSR(1); 09385000 T 0007 + CHARSZ; 09386000 T 0012 + IF C = 0 THEN GO TO L11; 09387000 T 0019 + RPF ← C.ADDR; 09388000 T 0020 + QH03 ← 1; 09389000 T 0022 + L12: 09390000 T 0023 + FETCHSOURCE; 09391000 T 0024 + L8: 09392000 T 0103 + IF QH03 = 1 THEN QH03←0 ELSE IF DIB≠0 THEN GO L14; 09393000 T 0104 + IF BROF THEN BROF ← FALSE ELSE 09394000 T 0109 + L10: 09395000 T 0110 + FETCHDESTINATION; 09396000 T 0112 + L14: 09397000 T 0189 + IF FLTF THEN 09398000 T 0190 + BEGIN 09399000 T 0190 + INTG ← 15×REAL(SSZ=8); 09400000 T 0190 + IF SSZ≠4 THEN DYAL(INTG,B,SSZ-5,DYALDIB,SSZ-4); 09401000 T 0192 + DYAL(A,8,DYALSIB-SIBLNG,DYALDIB-DIBLNG,4); GO L20; 09402000 T 0197 + END; 09403000 T 0207 + 09404000 T 0207 + DYAL(A,INTG,DYALSIB-SIBLNG,3,4); 09405000 T 0207 + IF INTG.[44:4] ≠ 0 THEN BEGIN FLTF←TRUE;GO L14 END; 09406000 T 0213 + 09407000 T 0216 + DYAL(Y,B,DSZ-1,DYALDIB,DSZ); 09408000 T 0216 + L20: BUMPSIB; 09409000 T 0219 + SWITCHSOURCE; 09410000 T 0222 + BUMPDIB; 09411000 T 0230 + RPF ← RPF - 1; 09412000 T 0233 + IF RPF = 0 THEN 09413000 T 0234 + BEGIN 09414000 T 0235 + STOREB; 09415000 T 0235 + LHFF ← TRUE; 09416000 T 0242 + END; 09417000 T 0242 + IF DIB = 0 THEN 09418000 T 0242 + BEGIN 09418100 T 0243 + STOREB; 09418200 T 0244 + STEPDP; 09418300 T 0250 + END; 09418400 T 0252 + IF NOT LHFF THEN IF SIB=0 THEN GO L12 ELSE 09418500 T 0252 + GO L10; 09418600 T 0254 + L11: IF EXSF THEN ENDE ELSE BROF ← TRUE; 09418700 T 0255 + OC: 09418800 T 0258 + END MINS; 09418900 T 0259 + 94 IS 262 LONG, NEXT SEG 12 + PROCEDURE MFLT ; % MOVE WITH FLOAT 8.11 09419000 T 0911 + BEGIN 09420000 T 0911 + LABEL L11,L9,L14,L15,L22,L10,L12,OC; 09421000 T 0911 + START OF SEGMENT ********** 95 + BOOLEAN LHFF; 09421100 T 0000 +STACK(F+2) = LHFF + EDITF ← TRUE; 09422000 T 0000 + SETUPEXSF; 09423000 T 0000 + Y ← SYLLABLE; YX ← 0; STEPPSR(1); 09424000 T 0007 + CHARSZ; 09425000 T 0012 + IF C = 0 THEN GO TO L10; 09426000 T 0019 + RPF ← C.ADDR; 09427000 T 0020 + QH03 ← 1; 09428000 T 0022 + L11: 09429000 T 0023 + FETCHSOURCE; 09430000 T 0024 + L9: 09431000 T 0103 + IF QH03 = 1 THEN QH03 ← 0 ELSE IF DIB ≠ 0 THEN GO TO L15; 09432000 T 0104 + IF BROF THEN BROF ← FALSE ELSE 09433000 T 0109 + L14: FETCHDESTINATION; 09434000 T 0110 + L15: 09435000 T 0189 + IF FLTF THEN 09436000 T 0190 + BEGIN 09437000 T 0190 + INTG ← 15×REAL(SSZ=8); 09438000 T 0190 + IF SSZ ≠ 4 THEN DYAL(INTG,B,SSZ-5,DYALDIB,SSZ-4); 09439000 T 0192 + DYAL(A,B,DYALSIB-SIBLNG,DYALDIB-DIBLNG,4); 09440000 T 0197 + END ELSE 09441000 T 0207 + BEGIN 09442000 T 0207 + DYAL(A,INTG,DYALSIB-SIBLNG,3,4); 09443000 T 0207 + IF INTG.[44:4] = 0 THEN 09444000 T 0213 + DYAL(Y,B,DSZ-1,DYALDIB,DSZ) ELSE 09445000 T 0214 + BEGIN 09446000 T 0218 + FLTF ← TRUE; 09447000 T 0219 + Y ← SYLLABLE; YX ← 0; STEPPSR(1); 09448000 T 0219 + IF EXTF THEN Y ← SYLLABLE; STEPPSR(1); 09449000 T 0224 + DYAL(Y,B,DSZ-1,DYALDIB,DSZ); 09450000 T 0228 + QH01 ← 1; 09451000 T 0231 + GO TO L22; 09452000 T 0233 + END; 09453000 T 0233 + END; 09454000 T 0233 + BUMPSIB; 09455000 T 0233 + IF SIB=0 AND NOT SOPF THEN SIR ← SIR + 1; 09456000 T 0236 + L22: 09457000 T 0239 + BUMPDIB; 09458000 T 0240 + IF QH01 = 0 THEN 09459000 T 0242 + BEGIN 09460000 T 0243 + RPF ← RPF - 1; 09461000 T 0244 + IF RPF = 0 THEN BEGIN STOREB; LHFF←TRUE END; 09462000 T 0245 + END ELSE QH01 ← 0; 09463000 T 0253 + IF DIB = 0 THEN 09464000 T 0256 + BEGIN 09465000 T 0256 + STOREB; 09466000 T 0257 + STEPDP; 09467000 T 0263 + END; 09468000 T 0265 + IF LHFF THEN GO L12; 09469000 T 0265 + IF SIB = 0 THEN GO L11; 09470000 T 0266 + GO L14; 09471000 T 0268 + L10: 09472000 T 0268 + IF QH03 = 0 THEN STEPPSR(2); 09473000 T 0269 + L12: 09474000 T 0271 + IF EXSF THEN ENDE ELSE BROF ← TRUE; 09474100 T 0272 + OC: 09474200 T 0274 + END MFLT; 09474300 T 0275 + 95 IS 278 LONG, NEXT SEG 12 + PROCEDURE ENDE; % END EDIT 09475000 T 0911 + BEGIN 09476000 T 0911 + LABEL OC, L1; 09477000 T 0911 + START OF SEGMENT ********** 96 + IF BROF THEN 09478000 T 0000 + BEGIN 09479000 T 0000 + MM ← DBR + DIR; 09480000 T 0000 + MOVE (B, M[MM]); MEMCYCLE; 09481000 T 0002 + BROF ← FALSE 09482000 T 0007 + END; 09483000 T 0007 + IF NOT UPDF THEN 09484000 T 0008 + BEGIN 09485000 T 0008 + FLTF ← FALSE; 09486000 T 0009 + AROF ← FALSE; 09487000 T 0009 + GO TO L1 09488000 T 0010 + END; 09489000 T 0011 + BROF ← TRUE; 09490000 T 0011 + B ← BX ← 0; 09490500 T 0011 + B ← DBR; 09491000 T 0013 + B.DIRF ← DIR; 09492000 T 0013 + B.CHARF ← DIB; 09493000 T 0015 + B.SZ ← DSZ DIV 2; 09494000 T 0017 + BX.TAG ← DATADESC; 09495000 T 0019 + B.IBIT ← 1; 09496000 T 0021 + BX.PBIT ← 1; 09497000 T 0023 + B.CBIT ← 1; 09498000 T 0024 + B.SBIT ← DPSF; 09499000 T 0026 + 09500000 T 0028 + IF SOPF THEN 09501000 T 0028 + BEGIN 09502000 T 0029 + IF AX.TAG = SINGL THEN 09503000 T 0029 + BEGIN 09504000 T 0030 + IF SIB ≠ 47 THEN 09505000 T 0031 + BEGIN 09506000 T 0032 + DYAL (A,C,DYALSIB,47,DYALSIZ); 09507000 T 0032 + DYAL (A,C,47,DYALSET,DYALSZ); 09508000 T 0036 + MOVE (C, A); 09509000 T 0039 + END; 09510000 T 0040 + AROF ← TRUE; 09511000 T 0040 + XROF ← 0; 09512000 T 0041 + END ELSE 09513000 T 0043 + IF SIB ≠ 47 THEN 09514000 T 0043 + BEGIN 09515000 T 0044 + DYAL (A,C,DYALSIB,47,DYALSIZ); 09516000 T 0044 + DYAL (X,C,47,DYALSET,DYALSZ); 09517000 T 0048 + DYAL (X,X,DYALSIB,47,DYALSIZ); 09518000 T 0051 + DYAL (A,X,47,DYALSET,DYALSZ); 09519000 T 0055 + MOVE (C, A); 09520000 T 0058 + END; 09521000 T 0059 + AROF ← TRUE; 09522000 T 0059 + XROF ← 1; GO TO L1; 09523000 T 0060 + END ELSE 09524000 T 0062 + AROF ← TRUE; 09525000 T 0062 + A ← AX ← 0; 09525500 T 0064 + A ← SBR; 09526000 T 0065 + A.SIRF ← SIR; 09527000 T 0066 + A.CHARF ← SIB; 09528000 T 0067 + A.SZ ← SSZ DIV 2; 09529000 T 0069 + AX.TAG ← DATADESC; 09530000 T 0071 + A.IBIT ← 1; 09531000 T 0073 + AX.PBIT ← 1; 09532000 T 0075 + A.CBIT ← 1; 09533000 T 0077 + A.SBIT ← SPSF; 09534000 T 0078 + A.RBIT ← SPRF; 09535000 T 0081 + L1: IF NOT EDITF THEN 09536000 T 0083 + BEGIN 09537000 T 0084 + IF SWPS = 1 THEN BROF ← FALSE 09538000 T 0085 + END ELSE 09539000 T 0087 + IF ESPF THEN AROF ← FALSE; 09540000 T 0087 + ESPF ← EXSF ← UPDF ← SOPF ← EDITF ← FALSE; 09541000 T 0089 + OC: 09542000 T 0092 + END ENDEDIT; 09543000 T 0093 + 96 IS 94 LONG, NEXT SEG 12 + PROCEDURE ERVSFLOW(OP); VALUE OP; INTEGER OP; 50000000 T 0911 + BEGIN 50001000 T 0911 + LABEL STARTVALC,STARTEVAL,STARTENTR,STARTEXIT,STARTRETN, 50002000 T 0911 + START OF SEGMENT ********** 97 + STARTINDX,STARTNXLN,STARTNXLV,STARTSTBR,STARTMKST, 50003000 T 0000 + STARTMVST,STARTDBTR,STARTDBFL,STARTDBUN,STARTBRTR, 50004000 T 0000 + STARTBRFL,STARTBRUN,STARTSTFF,STARTIRWL,STARTPCWL; 50005000 T 0000 + SWITCH START ← 50006000 T 0000 + STARTVALC,STARTEVAL,STARTENTR,STARTEXIT,STARTRETN, 50007000 T 0002 + STARTINDX,STARTNXLN,STARTNXLV,STARTSTBR, 50008000 T 0002 + STARTMKST,STARTMVST,STARTDBTR,STARTDBFL, 50009000 T 0002 + STARTDBUN,STARTBRTR,STARTBRFL,STARTBRUN, 50010000 T 0002 + STARTSTFF,STARTIRWL,STARTPCWL; 50011000 T 0002 + DEFINE VALC=OP=1#,EVAL=OP=2#,ENTR=OP=3#,EXIT=OP=4#,RETN=OP=5#, 50012000 T 0013 + INDX=OP=6#,NXLN=OP=7#,NXLV=OP=8#,STBR=OP=9#, 50013000 T 0013 + MKST=OP=10#,MVST=OP=11#,DBTR=OP=12#, 50014000 T 0013 + DBFL=OP=13#,DBUN=OP=14,BRTR=OP=15#,BRFL=OP=16#, 50015000 T 0013 + BRUN=OP=17#,STFF =OP=18#,IRWL = OP=19#, 50016000 T 0013 + PCWL= OP=20#; 50017000 T 0013 + LABEL LABELA,LABELB,LABELC,LABELD,LABELE,LABELF,LABELG, 50018000 T 0013 + LABELH,LABELP,LABELQ,LABELS,LABELT,LABELW,LABELX, 50019000 T 0013 + LABELZ, L1,L2,L3,L4,L5,L6,L7,L8,L9,L10,L11,L12,L13, 50020000 T 0013 + L14,L15,L16,L17,L18,DESCPAGE6,INDEXINDESC,NXLNPAGE9, 50021000 T 0013 + NORMALINDEX,SPECIALINDEX,OPERAND,INDEXWORD,STUFFEDIRW, 50022000 T 0013 + NORMALIRW,PCWPAGE22,DISPLAYUPDATE,BYPASUPDATE, 50023000 T 0013 + SEGMENTDESC,PCW2,INVOPLBL,INVINDLBL,STKUNFLBL,BOSLBL, 50024000 T 0013 + SEQERLBL,INTLBL,PRES10LBL,PRES11LBL,PRES12LBL, 50025000 T 0013 + PRES13LBL,OC,LABELOPND; 50026000 T 0013 + 50027000 T 0013 + REAL TS,T1,T2; 50028000 T 0013 +STACK(F+2) = TS +STACK(F+3) = T1 +STACK(F+4) = T2 + DEFINE I1INVALIDOPERATOR = GO TO INVOPLBL#, % ON PAGE 44 50029000 T 0013 + I2INTEGERIZE = BEGIN B ← BX ← 0; 50030000 T 0013 + GO TO INTLBL END#, % ON PAGE 45 50030500 T 0013 + I2MULT = I2INTEGERIZE#, 50031000 T 0013 + I2INTEGERDIV = I2INTEGERIZE#, 50032000 T 0013 + I3INVALIDINDEX = BEGIN LL ← X.LLF; 50033000 T 0013 + GO TO INVINDLBL END#, % PAGE 44 50033500 T 0013 + I4INVALIDINDEX = GO TO INVINDLBL#, % ON PAGE 44 50034000 T 0013 + I5BOSERROR = GO TO STKUNFLBL#, % ON PAGE 44 50035000 T 0013 + I6BOSNORMAL = GO TO BOSLBL#, % ON PAGE 45 50036000 T 0013 + I7SEQUENCEERROR = BEGIN LL ← X.LLF; 50037000 T 0013 + GO TO SEQERLBL END#, % PAGE 45 50037500 T 0013 + I8SEQUENCEERROR = GO TO SEQERLBL#, % ON PAGE 45 50038000 T 0013 + I9INVALIDINDEX = BEGIN MOVE (A,C); AROF ← FALSE; 50039000 T 0013 + GO TO INVINDLBL END#, % PAGE 44 50040000 T 0013 + I10PRESENCEBIT = GO TO PRES10LBL#, % ON PAGE 46 50041000 T 0013 + I11PRESENCEBIT = GO TO PRES11LBL#, % ON PAGE 46 50042000 T 0013 + I12PRESENCEBIT = GO TO PRES12LBL#, % ON PAGE 46 50043000 T 0013 + I13PRESENCEBIT = GO TO PRES13LBL#; % ON PAGE 46 50044000 T 0013 + %%% 50045000 T 0013 + DEFINE INTFL = SDIS=1#; %TO OVERCOME NOMENCLATURE DIFFICULTY 50046000 T 0013 + %%% 50047000 T 0013 + GO TO START[OP]; ERROR(10); MEMDUMP; GO TO EOJ; 50048000 T 0013 + % PAGE 2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50049000 T 0019 + STARTEVAL: 50050000 T 0019 + STARTSTBR: 50051000 T 0020 + LABELE: 50052000 T 0020 + ADJ(1,2); 50053000 T 0020 + GO TO L1; 50054000 T 0021 + STARTNXLV: 50055000 T 0021 + STARTNXLN: 50056000 T 0022 + STARTINDX: 50057000 T 0022 + ADJ(1,1); 50058000 T 0022 + IF AX.TAG = SINGL OR AX.TAG = DOUBL THEN EXCH; 50059000 T 0023 + L1: MOVE(A,C); AROF ← FALSE; 50060000 T 0026 + IF AX.TAG = IRW THEN GO TO LABELA ELSE GO TO DESCPAGE6; 50061000 T 0028 + % PAGE 3 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50062000 T 0031 + STARTENTR: 50063000 T 0031 + ADJ(0,0); 50064000 T 0031 + MOVE(M[F + 1], C); MEMCYCLE; 50065000 T 0032 + IF CX.TAG ≠ IRW THEN I1INVALIDOPERATOR; % ON PAGE 44 50066000 T 0037 + STARTIRWL: 50067000 T 0039 + LABELA: 50068000 T 0040 + MOVE (C,A); 50069000 T 0040 + IF C.EBIT = 1 THEN GO TO STUFFEDIRW ELSE GO TO NORMALIRW; 50070000 T 0041 + % PAGE 4 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50071000 T 0043 + STARTVALC: 50072000 T 0043 + T1 ← T1&DRS[34:42:6] & SYLLABLE[40:40:8]; STEPPSR(1); 50073000 T 0044 + BUF2 ← D[LEVEL(T1)] + DELTA(T1); 50074000 T 0049 + MOVE(M[D[LEVEL(T1)]+DELTA(T1)],C); MEMCYCLE; 50075000 T 0052 + QC1F ← 1; 50076000 T 0059 + IF AROF THEN ADJ(0,2); 50077000 T 0060 + IF CX.TAG = SINGL OR CX.TAG = DOUBL THEN 50078000 T 0062 + BEGIN 50079000 T 0065 + IF CX.TAG = DOUBL THEN MOVE (M[BUF2 + 1],X); 50080000 T 0065 + MOVE (C,A); AROF ← TRUE; 50081000 T 0072 + GO TO OC; 50082000 T 0073 + END; 50083000 T 0074 + IF CX.TAG = IRW THEN GO TO LABELA; % ON PAGE 3 50084000 T 0074 + % PAGE 6 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50085000 T 0076 + DESCPAGE6: 50086000 T 0076 + IF CX.TAG ≠ DATADESC THEN I1INVALIDOPERATOR; 50087000 T 0076 + IF C.CHRSZ = 0 THEN 50088000 T 0077 + BEGIN 50089000 T 0079 + QC6F ← 1; QC7F ← C.DBIT 50090000 T 0079 + END; 50091000 T 0081 + IF C.IBIT = 1 THEN GO TO L2; % ON PAGE 7 50092000 T 0083 + IF EVAL THEN GO TO LABELZ; % ON PAGE 9 50093000 T 0085 + IF NOT (NXLV OR NXLN OR INDX) THEN I1INVALIDOPERATOR; 50094000 T 0086 + LABELT: 50095000 T 0089 + IF C.CHRSZ = 0 OR INDX THEN GO TO NORMALINDEX % ON PAGE 10 50096000 T 0090 + ELSE I1INVALIDOPERATOR; 50097000 T 0092 + % PAGE 7 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50098000 T 0093 + L2: 50099000 T 0093 + IF INDX THEN I1INVALIDOPERATOR; 50100000 T 0094 + IF EVAL THEN GO TO LABELZ; % ON PAGE 9 50101000 T 0095 + INDEXINDESC: 50102000 T 0096 + IF C.SBIT ≠ 1 AND C.CHRSZ ≠ 0 THEN I1INVALIDOPERATOR; 50103000 T 0097 + IF CX.PBIT ≠ 1 THEN I11PRESENCEBIT; 50104000 T 0100 + T1 ← C.SBIT; 50105000 T 0102 + MOVE(M[BUF2 ← C.INDEX + C.ADDR],C); MEMCYCLE; 50106000 T 0103 + IF T1 = 1 THEN GO TO DESCPAGE6; 50107000 T 0110 + % PAGE 8 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50108000 T 0112 + IF NXLN THEN GO TO NXLNPAGE9; 50109000 T 0112 + LABELC: 50110000 T 0113 + IF CX.TAG=SINGL OR CX.TAG=DOUBL THEN GO TO OPERAND; % ON PAGE15 50111000 T 0114 + IF CX.TAG = SIW THEN GO TO INDEXWORD; % ON PAGE 17 50112000 T 0117 + IF NXLV THEN I1INVALIDOPERATOR; 50113000 T 0119 + GO TO DESCPAGE6; 50114000 T 0120 + % PAGE 9 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50115000 T 0121 + NXLNPAGE9: 50116000 T 0121 + IF CX.TAG ≠ DATADESC THEN I1INVALIDOPERATOR; 50117000 T 0121 + IF C.IBIT = 1 THEN I1INVALIDOPERATOR; 50118000 T 0122 + LABELZ: 50118100 T 0124 + IF CX.PBIT ≠ 1 THEN BEGIN 50119000 T 0125 + IF C.CBIT ≠ 1 THEN C.ADDR ← BUF2 50120000 T 0126 + END; 50121000 T 0128 + 50122000 T 0130 + C.CBIT ← 1; 50123000 T 0130 + MOVE(C,A); AROF ← TRUE; 50124000 T 0132 + GO TO OC; 50125000 T 0133 + % PAGE 10 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50126000 T 0134 + NORMALINDEX: 50127000 T 0134 + NTGR; IF INTFL THEN I2INTEGERIZE; 50128000 T 0135 + IF B.MANF < 0 OR B.MANF ≥ C.INDEX THEN I4INVALIDINDEX; 50129000 T 0139 + IF C.SBIT = 1 THEN GO TO LABELP; % ON PAGE 12 50130000 T 0143 + IF C.CHRSZ ≠ 0 THEN GO TO LABELQ; % ON PAGE 14 50131000 T 0144 + IF C.DBIT = 1 THEN B ← B × 2; 50131555 T 0146 + C.INDEX ← B.ADDR; 50132000 T 0149 + % PAGE 11 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50133000 T 0151 + SPECIALINDEX: 50134000 T 0151 + C.IBIT ← 1; BROF ← FALSE; 50135000 T 0152 + IF NOT INDX THEN GO TO INDEXINDESC; % ON PAGE 7 50136000 T 0154 + GO LABELZ; 50136600 T 0155 + MOVE (C,A); AROF ← TRUE; 50137000 T 0156 + GO TO OC; 50138000 T 0158 + % PAGE 12 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50139000 T 0158 + LABELP: 50140000 T 0158 + CASE C.SZ OF 50141000 T 0159 + BEGIN 50142000 T 0159 +PRT(773) = *CASE STATEMENT DESCRIPTOR* + % SZ = 000 (DATA DESCRIPTOR) SINGLE PRECISION 50143000 T 0160 + BEGIN A ← 256; GO TO L4 END; 50144000 T 0160 + % SZ = 001 (DATA DESCRIPTOR) DOUBLE PRECISION 50145000 T 0162 + BEGIN A ← 128; GO TO L4 END; 50146000 T 0162 + % SZ = 010 4-BIT CHARACTERS (STRING DESCRIPTOR) 50147000 T 0163 + BEGIN A ← 3072; GO TO L4 END; 50148000 T 0163 + % SZ = 011 6-BIT CHARACTERS (STRING DESCRIPTOR) 50149000 T 0166 + BEGIN A ← 2048; GO TO L4 END; 50150000 T 0166 + % SZ = 100 8-BIT CHARACTERS (STRING DESCRIPTOR) 50151000 T 0169 + BEGIN A ← 1536; GO TO L4 END; 50152000 T 0169 + END; 50153000 T 0172 + START OF SEGMENT ********** 98 + 98 IS 5 LONG, NEXT SEG 97 + % PAGE 13 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50154000 T 0172 + L4: 50155000 T 0172 + AROF ← TRUE; 50156000 T 0173 + IDIV; IF INTFL THEN I2INTEGERDIV; 50157000 T 0173 + C.INDEX ← B.ADDR; MOVE (A,B); C.IBIT ← 1; 50158000 T 0177 + GO TO INDEXINDESC; % ON PAGE 7 50159000 T 0182 + % PAGE 14 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50160000 T 0183 + LABELQ: 50161000 T 0183 + CASE C.SZ OF 50162000 T 0184 + BEGIN 50163000 T 0184 +PRT(774) = *CASE STATEMENT DESCRIPTOR* + % SZ = 000 NOT POSSIBLE AT THIS POINT 50164000 T 0185 + ; 50165000 T 0185 + % SZ = 001 NOT POSSIBLE AT THIS POINT 50166000 T 0185 + ; 50167000 T 0185 + % SZ = 010 4-BIT CHARACTERS 50168000 T 0185 + BEGIN T1 ← 12; T2 ← 4 END; 50169000 T 0185 + % SZ = 011 6-BIT CHARACTERS 50170000 T 0187 + BEGIN T1 ← 8; T2 ← 6 END; 50171000 T 0187 + % SZ = 100 8-BIT CHARACTERS 50172000 T 0189 + BEGIN T1 ← 6; T2 ← 8 END; 50173000 T 0189 + END; 50174000 T 0191 + START OF SEGMENT ********** 99 + 99 IS 5 LONG, NEXT SEG 97 + MOVE (A,B); BROF ← TRUE; A ← T1; 50175000 T 0191 + IDIV; IF INTFL THEN I2INTEGERDIV; 50176000 T 0193 + C.[13:15] ← B.[33:15]; AROF ← TRUE; AX.TAG ← SINGL; B ← T2; 50177000 T 0197 + MULT; IF INTFL THEN I2MULT; 50178000 T 0203 + MOVE (B,A); B ← 47; BROF ← FALSE; 50179000 T 0207 + B ← B - A; 50180000 T 0209 + C.[7:6] ← B.[42:6]; 50181000 T 0211 + GO TO SPECIALINDEX; % ON PAGE 11 50182000 T 0213 + % PAGE 15 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50183000 T 0213 + OPERAND: 50184000 T 0213 + IF EVAL THEN GO TO L7; % ON PAGE 16 50185000 T 0214 + IF QC6F = 1 THEN 50186000 T 0215 + BEGIN 50187000 T 0216 + IF QC7F = 1 THEN BEGIN CX.TAG ← DOUBL; 50188000 T 0217 + GO TO L5 END ELSE 50189000 T 0220 + BEGIN CX.TAG ← SINGL; 50190000 T 0221 + GO TO L6 END; 50191000 T 0223 + END; 50192000 T 0223 + IF CX.TAG ≠ DOUBL THEN GO TO L6; 50193000 T 0223 + L5: 50194000 T 0225 + MOVE (M[BUF2 + 1], X); MEMCYCLE; 50195000 T 0226 + L6: 50196000 T 0231 + MOVE (C,A); 50197000 T 0232 + % PAGE 16 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50198000 T 0233 + L7: 50199000 T 0233 + AROF ← TRUE; 50200000 T 0233 + IF NOT STBR THEN GO TO OC; 50201000 T 0233 + ADJ (0,1); 50202000 T 0235 + A ← AX ← 0; AROF ← TRUE; STEPPSR (2); 50203000 T 0236 + GO TO OC; 50204000 T 0238 + % PAGE 17 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50205000 T 0239 + INDEXWORD: 50206000 T 0239 + C.CVF ← C.CVF + C.INCRF; 50207000 T 0240 + MOVE (C, M[BUF2]); MEMCYCLE; 50208000 T 0243 + IF C.CVF ≤ C.FVF THEN 50209000 T 0248 + BEGIN 50210000 T 0250 + A ← AX ← 1; STEPPSR (2); AROF ← TRUE; 50211000 T 0250 + GO TO OC 50212000 T 0253 + END; 50213000 T 0254 + GO TO STARTBRUN; 50214000 T 0254 + 50215000 T 0254 + % PAGE 18 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50216000 T 0254 + STUFFEDIRW: 50217000 T 0254 + QC6F ← 0; Q04F ← 1; 50218000 T 0255 + LABELX: 50219000 T 0258 + IF SNR = C.STKNR THEN 50220000 T 0259 + BEGIN QC7F ← 0; TEMP ← BOSR END 50221000 T 0260 + ELSE 50222000 T 0263 + BEGIN 50223000 T 0263 + MOVE(M[STACKVECTOR],C); MEMCYCLE; QC7F ← 1; 50224000 T 0263 + IF CX.PBIT ≠1 THEN I10PRESENCEBIT; 50225000 T 0271 + IF C.LENGTH ≤ A.STKNR THEN I4INVALIDINDEX; 50226000 T 0273 + MOVE (M[C.ADDR + A.STKNR], C); MEMCYCLE; 50227000 T 0275 + IF CX.PBIT ≠1 THEN I10PRESENCEBIT; 50228000 T 0282 + TEMP ← C.ADDR; 50229000 T 0284 + END; 50230000 T 0285 + % PAGE 19 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50231000 T 0285 + IF Q04F ≠ 1 THEN 50232000 T 0285 + IF STFF THEN 50233000 T 0286 + GO TO LABELW % ON PAGE 42 50234000 T 0287 + ELSE GO TO LABELD; % ON PAGE 22 50235000 T 0287 + BUF ← TEMP + A.DISP; 50236000 T 0288 + BUF2 ← BUF + A.ADRCPLSIR; 50237000 T 0290 + IF IRWL THEN GO TO OC; 50238000 T 0292 + Q04F ← 0; MOVE(M[BUF + A.ADRCPLSIR] ,C); MEMCYCLE; 50239000 T 0293 + IF CX.TAG = IRW AND C.EBIT = 0 THEN I1INVALIDOPERATOR 50240000 T 0301 + ELSE GO TO LABELH; % ON PAGE 20 50241000 T 0304 + % PAGE 20 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50242000 T 0305 + NORMALIRW: 50243000 T 0305 + BUF ← D [LEVEL(C)]; BUF2 ← BUF + DELTA(C); 50244000 T 0306 + IF IRWL THEN GO TO OC; 50245000 T 0309 + MOVE (M[BUF + DELTA(C)],C); MEMCYCLE; 50246000 T 0310 + LABELH: 50247000 T 0316 + IF CX.TAG = IRW THEN GO TO LABELA; % ON PAGE 3 50248000 T 0317 + IF CX.TAG = PCW THEN GO TO PCWPAGE22; 50249000 T 0318 + IF ENTR THEN I1INVALIDOPERATOR; 50250000 T 0320 + IF NOT (NXLN OR NXLV OR INDX) THEN 50251000 T 0321 + BEGIN 50252000 T 0324 + QC6F ← 0; 50253000 T 0325 + GO TO LABELC % ON PAGE 8 50254000 T 0327 + END; 50255000 T 0327 + % PAGE 21 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50256000 T 0327 + IF CX.TAG ≠ DATADESC OR C.IBIT ≠ 0 THEN I1INVALIDOPERATOR; 50257000 T 0327 + GO TO DESCPAGE6; % ON PAGE 6 50258000 T 0331 + % PAGE 22 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50259000 T 0331 + STARTPCWL: 50260000 T 0331 + PCWPAGE22: 50261000 T 0332 + IF NOT (ENTR OR BOOLEAN (QC1F)) THEN 50262000 T 0332 + BEGIN 50263000 T 0334 + PIR ← PIR - PICR; 50264000 T 0334 + PSR ← OPSR; 50265000 T 0335 + END; 50266000 T 0336 + MOVE (C,X); 50267000 T 0336 + IF A.EBIT ≠ 0 THEN GO TO L8; 50268000 T 0337 + 50269000 T 0339 + A.STKNR ← C.STKNR; 50270000 T 0339 + GO TO LABELX; 50271000 T 0341 + LABELD: 50272000 T 0342 + TS ← D[LEVEL(A)]; 50273000 T 0342 + A.DISP ← TS - TEMP; 50274000 T 0343 + L8: 50275000 T 0345 + C ← CX ← 0; 50276000 T 0346 + C.NBIT ← REAL(NCSF); IIHF ← BOOLEAN(X.NBIT); 50277000 T 0347 + NCSF ← BOOLEAN(X.NBIT); 50278000 T 0350 + C.SDIF ← PDR; PDR ← X.SDIF; 50279000 T 0351 + % PAGE 23 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50280000 T 0354 + C.PSRF ← PDR; PDR ← X.PSRF; 50281000 T 0354 + C.PIRF ← PIR; PIR ← X.PIRF; 50282000 T 0357 + C.FLTFF ← REAL (FLTF); 50283000 T 0360 + C.TFFFF ← REAL (TFFF); 50284000 T 0362 + C.OFFFF ← REAL (OFFF); 50285000 T 0364 + CX.SGNFF ← SGNF; 50286000 T 0365 + C.LLF ← LL; 50287000 T 0367 + TS ← LL; LL ← X.LLF; X.[10:5] ← TS; 50288000 T 0369 + CX.TAG ← RCW; 50289000 T 0373 + IF ENTR THEN 50290000 T 0374 + BEGIN % EXPECTED PROCEDURE ENTRY 50291000 T 0375 + MOVE (C,M[F + 1]); MEMCYCLE; 50292000 T 0376 + MOVE (M[F],C); MEMCYCLE; 50293000 T 0381 + C.STKNR ← A.STKNR; 50294000 T 0387 + C.DISP ← A.DISP; 50295000 T 0389 + CX.DSBIT ← QC7F; 50296000 T 0391 + C.LLF ← LL; 50297000 T 0393 + C.EBIT ← 1; 50298000 T 0395 + MOVE (C,M[F]); MEMCYCLE; 50299000 T 0397 + GO TO DISPLAYUPDATE; % ON PAGE 25 50300000 T 0402 + END; 50300500 T 0403 + % PAGE 24 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50301000 T 0403 + % ACCIDENTAL PROCEDURE ENTRY 50302000 T 0403 + ADJ (0,0); 50303000 T 0403 + MOVE (A,B); 50304000 T 0404 + MOVE (C,A); 50305000 T 0405 + B.DSBIT ← QC7F; 50306000 T 0406 + B.DF ← S + 1 - F; 50307000 T 0408 + F ← S + 1; 50308000 T 0411 + B.VBIT ← QC1F; 50309000 T 0412 + BX.TAG ← MSCW; 50310000 T 0414 + B.LLF ← LL; 50311000 T 0416 + B.EBIT ← 1; 50312000 T 0418 + AROF ← BROF ← TRUE; 50313000 T 0419 + ADJ (0,0); 50314000 T 0421 + % PAGE 25 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50315000 T 0422 + DISPLAYUPDATE: 50316000 T 0422 + D [LL] ← F; 50317000 T 0422 + X.LLF ← LL; 50318000 T 0423 + L9: 50319000 T 0425 + IF LL = 0 OR QC6F = 1 THEN 50320000 T 0425 + BEGIN 50321000 T 0427 + BYPASUPDATE: 50322000 T 0427 + LL ← X.LLF; 50323000 T 0428 + IF MVST THEN GO TO OC 50324000 T 0429 + ELSE GO TO SEGMENTDESC; % ON PAGE 28 50325000 T 0430 + END; 50326000 T 0431 + LL ← LL - 1; 50327000 T 0431 + IF D[LL] = BUF AND LL ≤ X.[10:5] THEN GO TO BYPASUPDATE; 50328000 T 0432 + D[LL] ← BUF; MOVE (M[BUF], C); MEMCYCLE; 50329000 T 0435 + % PAGE 26 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50330000 T 0442 + IF CX.TAG ≠ MSCW OR LL ≠ C.LLF THEN 50331000 T 0442 + BEGIN 50332000 T 0444 + QC2F ← 1; I7SEQUENCEERROR; 50333000 T 0445 + END; 50334000 T 0448 + LABELF: 50335000 T 0448 + IF CX.DSBIT = 0 THEN 50336000 T 0449 + BEGIN 50337000 T 0450 + BUF ← TEMP + C.DISP; 50338000 T 0450 + GO TO L9 50339000 T 0452 + END; 50340000 T 0453 + MOVE (C,A); 50341000 T 0453 + BUF2 ← D0 + 2; 50342000 T 0454 + MOVE (M[STACKVECTOR], C); MEMCYCLE; 50343000 T 0455 + IF CX.PBIT ≠ 1 THEN I12PRESENCEBIT; 50344000 T 0461 + IF C.LENGTH ≤ A.STKNR THEN 50345000 T 0463 + BEGIN 50346000 T 0465 + QC2F ← 1; 50347000 T 0465 + I3INVALIDINDEX; 50348000 T 0467 + END; 50349000 T 0469 + % PAGE 27 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50350000 T 0469 + BUF2 ← C.ADDR + A.STKNR; 50351000 T 0469 + MOVE (M[BUF2], C); MEMCYCLE; 50352000 T 0471 + IF CX.PBIT ≠ 1 THEN I12PRESENCEBIT; 50353000 T 0476 + TEMP ← C.ADDR; 50354000 T 0478 + BUF ← TEMP + A.DISP; 50355000 T 0479 + GO TO L9; 50356000 T 0481 + % PAGE 28 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50357000 T 0481 + SEGMENTDESC: 50358000 T 0481 + C.SDIF ← PDR; 50359000 T 0482 + BUF2 ← D[C.LEVELPCW] + C.DELTAPCW; 50360000 T 0483 + MOVE (M[D[C.LEVELPCW] + C.DELTAPCW], C); MEMCYCLE; 50361000 T 0486 + IF CX.TAG ≠ SEGDESC THEN 50362000 T 0493 + BEGIN 50363000 T 0494 + QC2F ← 1; 50364000 T 0495 + I8SEQUENCEERROR; 50365000 T 0496 + END; 50366000 T 0497 + IF CX.PBIT ≠ 1 THEN I12PRESENCEBIT; 50367000 T 0497 + PBR ← C.ADDR; PROF ← FALSE; 50368000 T 0499 + IF NOT RETN THEN GO TO OC; 50369000 T 0501 + % PAGE 29 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50370000 T 0502 + IF QC1F ≠ 1 THEN GO TO OC; 50371000 T 0502 + OP ← 1; % FORCE A VALC INTO THE T REGISTER AND CONTINUE THE 50372000 T 0504 + % PROCESSING AS A VALUE CALL OPERATOR 50373000 T 0504 + GO TO LABELE; % ON PAGE 2 50374000 T 0504 + % PAGE 30 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50375000 T 0505 + STARTRETN: 50376000 T 0505 + ADJ (0,1); 50377000 T 0506 + L10: 50378000 T 0507 + F ← D[LL]; 50379000 T 0507 + MOVE (M[F + 1], C); MEMCYCLE; 50380000 T 0508 + IIHF ←BOOLEAN(C.NBIT); PDR ← C.SDIF; PIR ← C.PIRF; 50381000 T 0513 + PSR ← C.PSRF; NCSF ←BOOLEAN(C.NBIT); X.[10:5] ← LL; 50382000 T 0517 + FLTF ←BOOLEAN(C.FLTFF); TFFF ←BOOLEAN(C.TFFFF); OFFF ← BOOLEAN 50383000 T 0521 + (C.OFFFF); SGNF ← CX.SGNFF; LL ← C.LLF; 50384000 T 0524 + S ← F - 1; 50385000 T 0528 + TEMP ← BOSR; X.LLF ← LL; 50386000 T 0529 + IF F = BOSR + 1 THEN 50387000 T 0531 + BEGIN 50388000 T 0533 + QC2F ← 1; 50389000 T 0533 + I6BOSNORMAL; 50390000 T 0535 + END; 50391000 T 0535 + GO TO LABELG; % ON PAGE 31 50392000 T 0535 + % PAGE 31 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50393000 T 0536 + STARTEXIT: 50394000 T 0536 + ADJ (0,0); 50395000 T 0537 + GO TO L10; % ON PAGE 30 50396000 T 0538 + LABELG: 50397000 T 0538 + MOVE (M[F], C); MEMCYCLE; 50398000 T 0539 + IF CX.TAG ≠ MSCW THEN 50399000 T 0544 + BEGIN 50400000 T 0545 + QC2F ← 1; 50401000 T 0546 + I8SEQUENCEERROR; 50402000 T 0547 + END; 50403000 T 0548 + F ← F - C.DF; 50404000 T 0548 + BUF ← F; QC1F ← C.VBIT; 50405000 T 0550 + LABELS: 50406000 T 0553 + IF BOSR > BUF THEN 50407000 T 0553 + BEGIN 50408000 T 0553 + SUFL ← TRUE; 50409000 T 0554 + I5BOSERROR; 50410000 T 0555 + END; 50411000 T 0555 + D[LL] ← BUF; MOVE (M[BUF], C); MEMCYCLE; 50412000 T 0555 + % PAGE 32 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50413000 T 0562 + IF CX.TAG ≠ MSCW THEN 50414000 T 0562 + BEGIN 50415000 T 0563 + QC2F ← 1; I8SEQUENCEERROR; 50416000 T 0563 + END; 50417000 T 0566 + IF LL = C.LLF AND C.EBIT = 1 THEN GO TO LABELF; % ON PAGE 26 50418000 T 0566 + BUF ← D[LL] - C.DF; 50419000 T 0569 + GO TO LABELS; % ON PAGE 31 50420000 T 0571 + % PAGE 33 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50421000 T 0572 + STARTMVST: 50422000 T 0572 + ADJ (0,1); 50423000 T 0572 + C.DF ← S - F; C.LLF ← LL; C.NBIT ← REAL (NCSF); 50424000 T 0573 + C.DS ← S - BOSR; 50425000 T 0578 + C.FLTFF ←REAL(FLTF); C.TFFFF ←REAL(TFFF); C.OFFFF ←REAL(OFFF); 50426000 T 0581 + CX.SGNFF ← SGNF; CX.TAG ← TOS; 50427000 T 0586 + MOVE (M[BOSR], T1); 50428000 T 0589 + IF T2.ROBIT ≠ 1 THEN 50429000 T 0593 + BEGIN MOVE (C,M[BOSR]); MEMCYCLE END; 50430000 T 0595 + COMMENT THE LAST TWO STATEMENTS USE PSEUDO REGISTER T1,T2 TO 50431000 T 0600 + SIMULATE PROTECT LOGIC IN MEMORY MODULES; 50432000 T 0600 + BUF2 ← D0 + 2; 50433000 T 0600 + MOVE (M[STACKVECTOR], C); MEMCYCLE; 50434000 T 0602 + IF CX.PBIT ≠ 1 THEN I13PRESENCEBIT; 50435000 T 0608 + NTGR; IF INTFL THEN I2INTEGERIZE; 50436000 T 0610 + IF B.MANF < 0 OR B.MANF ≥ C.LENGTH THEN I4INVALIDINDEX; 50437000 T 0614 + BUF2 ← C.ADDR + B.ADDR; 50438000 T 0618 + MOVE (M[C.ADDR + B.ADDR], A); MEMCYCLE; 50439000 T 0620 + % PAGE 34 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50440000 T 0627 + IF AX.PBIT ≠ 1 THEN 50441000 T 0627 + BEGIN MOVE (A,C); I13PRESENCEBIT; END; 50442000 T 0628 + SNR ← B.ADDR;BROF ← FALSE; 50443000 T 0630 + BOSR ← A.ADDR; TEMP ← A.ADDR; LOSR ← A.ADDR + A.LENGTH; 50444000 T 0632 + C ← PID; CX.TAG ← SINGL; 50445000 T 0637 + MOVE (M[BOSR], T1); MOVE (C, M[BOSR]); MOVE (T1, C); MEMCYCLE; 50446000 T 0639 + S ← C.DS + BOSR; F ← S - C.DF; BUF ← S - C.DF; LL ← C.LLF; 50447000 T 0649 + X.[10:5] ← LL; NCSF ← BOOLEAN (C.NBIT); IIHF ← BOOLEAN(C.NBIT); 50448000 T 0656 + FLTF ← BOOLEAN (C.FLTFF); TFFF ← BOOLEAN (C.TFFFF); 50449000 T 0660 + OFFF ← BOOLEAN (C.OFFFF); SGNF ← C.SGNFF; 50450000 T 0663 + X.LLF ← LL; 50451000 T 0665 + GO TO LABELS; % ON PAGE 31 50452000 T 0667 + % PAGE 35 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50453000 T 0667 + STARTDBTR: 50454000 T 0667 + ADJ (1,1); 50455000 T 0668 + IF B.LOBIT ≠ 1 THEN GO TO L11 50456000 T 0669 + ELSE GO TO L12; 50457000 T 0670 + STARTDBFL: 50458000 T 0671 + ADJ (1,1); 50459000 T 0672 + IF B.LOBIT = 1 THEN 50460000 T 0673 + L11: BEGIN AROF ← FALSE; BROF ← FALSE; GO TO OC END; 50461000 T 0674 + L12: BROF ← FALSE; 50462000 T 0677 + GO TO LABELB; % ON PA6E 36 50463000 T 0677 + % PAGE 36 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50464000 T 0678 + STARTDBUN: 50465000 T 0678 + ADJ (1,2); 50466000 T 0679 + LABELB: 50467000 T 0680 + IF AX.TAG = SINGL OR AX.TAG = DOUBL THEN 50468000 T 0680 + GO TO LABELOPND; % ON PAGE 36 50469000 T 0682 + MOVE (A,C); 50470000 T 0683 + L13: IF CX.TAG = IRW THEN 50471000 T 0684 + BEGIN 50472000 T 0686 + IF C.EBIT ≠ 0 THEN 50473000 T 0686 + BEGIN AROF ← FALSE; I8SEQUENCEERROR END; 50474000 T 0688 + MOVE (M[D[LEVEL(C) ] + DELTA(C) ], C);MEMCYCLE; 50475000 T 0689 + GO TO L13; 50476000 T 0696 + END; 50477000 T 0697 + % PAGE 37 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50478000 T 0697 + IF CX.TAG = PCW THEN GO TO PCW2; % ON PAGE 39 50479000 T 0697 + AROF ← FALSE; 50480000 T 0699 + I1INVALIDOPERATOR; 50481000 T 0699 + % PAGE 38 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50482000 T 0700 + LABELOPND: 50483000 T 0700 + NTGR; IF INTFL THEN I2INTEGERIZE; 50484000 T 0701 + IF B.MANF < 0 THEN I9INVALIDINDEX; 50485000 T 0705 + IF B.MANF ≥ 2097152 THEN I9INVALIDINDEX; 50486000 T 0709 + IF B.LOBIT = 0 THEN PSR ← 0 50487000 T 0714 + ELSE PSR ← 3; 50488000 T 0715 + PIR ← B.[27:20]; PROF ← FALSE; BROF ← FALSE; 50489000 T 0717 + GO TO OC; 50490000 T 0720 + % PAGE 39 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50491000 T 0721 + PCW2: 50492000 T 0721 + IF LL ≠ C.LLF THEN 50493000 T 0721 + BEGIN AROF ← FALSE; I8SEQUENCEERROR END; 50494000 T 0722 + PDR ← C.SDIF; PSR ← C.PSRF; PIR ← C.PIRF; 50495000 T 0724 + BUF2 ← D[C.LEVELPCW] + C.DELTAPCW; 50496000 T 0727 + MOVE (M[D[C.LEVELPCW] + C.DELTAPCW], C); 50497000 T 0730 + AROF ← FALSE; 50498000 T 0736 + IF CX.TAG ≠ SEGDESC THEN 50499000 T 0736 + BEGIN QC2F ← 1; I8SEQUENCEERROR END; 50500000 T 0738 + IF CX.PBIT ≠ 1 THEN I12PRESENCEBIT; 50501000 T 0740 + PBR ← C.ADDR; PROF ← FALSE; 50502000 T 0742 + GO TO OC; 50503000 T 0744 + % PAGE 40 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50504000 T 0745 + STARTBRTR: 50505000 T 0745 + ADJ (1,2); 50506000 T 0745 + IF A.LOBIT ≠ 1 THEN 50507000 T 0746 + L14: BEGIN STEPPSR (2); AROF ← FALSE; GO TO OC END; 50508000 T 0747 + L15: 50509000 T 0750 + AROF ← FALSE; 50510000 T 0750 + STARTBRUN: 50511000 T 0750 + C.[32:8] ← SYLLABLE; STEPPSR(1); C.[40:8] ← SYLLABLE; 50512000 T 0751 + PSR ← C.[32:3]; PIR ← C.[35:13]; PROF ← FALSE; 50513000 T 0759 + GO TO OC; 50514000 T 0762 + STARTBRFL: 50515000 T 0763 + ADJ (1,2); 50516000 T 0763 + IF A.LOBIT = 0 THEN GO TO L15 ELSE GO TO L14; 50517000 T 0764 + % PAGE 41 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50518000 T 0766 + STARTSTFF: 50519000 T 0766 + ADJ (1,2); 50520000 T 0767 + IF AX.TAG ≠ IRW THEN 50521000 T 0768 + BEGIN MOVE (A, C); I1INVALIDOPERATOR END; 50522000 T 0769 + BUF ← BUF2 ← D[LEVEL(A)]; 50523000 T 0771 + L16: 50524000 T 0773 + MOVE (M[BUF2], C); 50525000 T 0774 + IF CX.TAG ≠ MSCW THEN I8SEQUENCEERROR; 50526000 T 0778 + IF CX.DSBIT ≠ 0 THEN 50527000 T 0779 + BEGIN BUF2 ← BUF2 - C.DF; GO TO L16 END; 50528000 T 0781 + A.STKNR ← C.STKNR; 50529000 T 0783 + GO TO LABELX; % ON PAGE 18 50530000 T 0786 + % PAGE 42 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50531000 T 0786 + LABELW: 50532000 T 0786 + A.DISP ← BUF - TEMP; A.ADRCPL ← DELTA(A); A.EBIT ← 1; 50533000 T 0787 + GO TO OC; 50534000 T 0793 + % PAGE 43 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50535000 T 0793 + STARTMKST: 50536000 T 0793 + ADJ (0,0); 50537000 T 0794 + B ← BX ← 0; 50538000 T 0795 + B.DF ← S + 1 - F; F ← S + 1; BX.TAG ← MSCW; BROF ← TRUE; 50539000 T 0796 + ADJ (0,0); 50540000 T 0802 + GO TO OC; 50541000 T 0803 + % PAGE 44 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% SET INTERRUPTS FOR ALL ERVSFLOW 50542000 T 0804 + % SYLLABLE DEPENDENT INTERRUPTS 50543000 T 0804 + % (NON-PRESENCE BIT) 50544000 T 0804 + INVOPLBL: 50545000 T 0804 + ADJ (0,0); 50546000 T 0805 + B ← BX ← 0; 50547000 T 0806 + B ← INVOP; 50548000 T 0807 + GO TO L17; 50549000 T 0808 + INVINDLBL: 50550000 T 0810 + ADJ (0,0); 50551000 T 0810 + B ← BX ← 0; 50552000 T 0811 + B ← INVINXI; 50553000 T 0812 + GO TO L17; 50554000 T 0813 + STKUNFLBL: 50555000 T 0815 + ADJ (0,0); 50556000 T 0815 + B ← BX ← 0; 50557000 T 0816 + B ← STKUNFI; 50558000 T 0817 + BROF ← TRUE; 50559000 T 0818 + GO TO OC; 50560000 T 0818 + % PAGE 45 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50561000 T 0821 + BOSLBL: 50562000 T 0821 + ADJ (0,0); 50563000 T 0821 + B ← BX ← 0; 50564000 T 0822 + B ← BOSINT; 50565000 T 0823 + GO TO L17; 50566000 T 0824 + SEQERLBL: 50567000 T 0826 + ADJ (0,0); 50568000 T 0826 + B ← BX ← 0; 50569000 T 0827 + B ← SEQERRI; 50570000 T 0828 + L17: PIR ← PIR - PICR; PSR ← OPSR; 50571000 T 0829 + INTLBL: % SET INTERRUPT FOR INTERRUPT CONDITION RECOGNISED WHEN 50572000 T 0831 + % INTEGERIZE USED AS SUB-OPERATOR IN ERVSFLOW. NOTE THAT 50573000 T 0831 + % SETTING OF B WITH INTERRUPT ID AND OTHER NECESSARY OPER- 50574000 T 0831 + % ATIONS TOOK PLACE AT TIME INTERRUPT WAS RECOGNISED IN 50575000 T 0831 + % INTEGERIZE. 50576000 T 0831 + BROF ← TRUE; 50577000 T 0831 + SDIS ← 1; MOVE (C,A); AROF ← TRUE; 50578000 T 0831 + GO TO OC; 50579000 T 0835 + % PAGE 46 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50580000 T 0837 + PRES13LBL: 50581000 T 0837 + ADJ (0,0); 50582000 T 0837 + PRES11LBL: 50583000 T 0838 + IF C.CBIT ≠ 1 THEN 50584000 T 0838 + BEGIN C.CBIT ← 1; C.ADDR ← BUF2 END; 50585000 T 0839 + MOVE (C,A); 50586000 T 0843 + PRES10LBL: 50587000 T 0844 + ADJ (0,0); 50588000 T 0845 + IF NOT (VALC OR ENTR OR MVST) THEN T1 ← 1; % CHECK ** 50589000 T 0846 + PIR ← PIR - PICR; PSR ← OPSR; 50590000 T 0850 + L18: 50591000 T 0852 + B ← BX ← 0; 50592000 T 0853 + SDIS ← 1; AROF ← BROF ← TRUE; B.SOBIT ← T1; 50593000 T 0854 + B.[18:30] ← PRESBIT; 50594000 T 0859 + GO TO OC; 50595000 T 0860 + PRES12LBL: 50596000 T 0863 + % PAGE 47 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 50597000 T 0863 + IF C.CBIT ≠ 1 THEN 50598000 T 0863 + BEGIN C.CBIT ← 1; C.ADDR ← BUF2 END; 50599000 T 0864 + MOVE (C,A); 50600000 T 0868 + ADJ (0,0); 50601000 T 0869 + GO TO L18; % ON PAGE 46 50602000 T 0870 + OC: 50603000 T 0870 + END ERVSFLOW; 50604000 T 0871 + 97 IS 874 LONG, NEXT SEG 12 + PROCEDURE STORE(OP); VALUE OP; REAL OP; 51000000 T 0911 + COMMENT OP=0: STORE DESTRUCTIVE 51001000 T 0911 + OP=1: STORE NON-DESTRUCTIVE 51002000 T 0911 + OP=2: OVERWRITE DESTRUCTIVE 51003000 T 0911 + OP=3: OVERWRITE NON-DESTRUCTIVE 51004000 T 0911 + OP=7: READ-WITH-LOCK; 51005000 T 0911 + BEGIN 51006000 T 0911 + LABEL EVALDESC,EVALIRW,TRYWRITE,MIXEDTYPECHECK,FIXROFS, 51007000 T 0911 + START OF SEGMENT ********** 100 + LABELF,ACCIDENTALENTRY, 51008000 T 0000 + OC; 51009000 T 0000 + DEFINE INVALIDOP = BEGIN INTFAMD(2); GO OC; END#, 51010000 T 0000 + PRESENCEBIT = BEGIN INTFAMD(8); GO OC END#, 51011000 T 0000 + INVALIDINDEX= BEGIN INTFAMD(7); GO OC END#, 51012000 T 0000 + MEMORYPROTECT=BEGIN INTFAMD(6); GO OC END#; 51013000 T 0000 + DEFINE OVERWRITE = (OP=2 OR OP=3)#, 51014000 T 0000 + NONDESTRUCTIVE = BOOLEAN(OP)#, 51015000 T 0000 + DESTRUCTIVE = NOT NONDESTRUCTIVE#, 51016000 T 0000 + READWITHLOCK = (OP=7)#; 51017000 T 0000 + %%%%% PAGE 1 %%%%%%%%%%%%%%% 51018000 T 0000 + ADJ(1,1); 51026000 T 0000 + IF AX.TAG=SINGL OR AX.TAG=DOUBL THEN EXCH; 51027000 T 0001 + MOVE(A,C); 51029000 T 0004 + IF CX.TAG=IRW THEN GO TO EVALIRW; 51030000 T 0005 + IF CX.TAG≠DATADESC OR C.IBIT≠1 THEN INVALIDOP; 51031000 T 0007 + EVALDESC: 51032000 T 0012 + IF C.RBIT≠0 THEN MEMORYPROTECT; 51033000 T 0012 + IF CX.PBIT≠1 THEN PRESENCEBIT; 51034000 T 0015 + MM←C.INDEX+C.ADDR; 51035000 T 0018 + TRYWRITE: 51036000 T 0020 + IF MM + MM > MEMMODS % INVALID ADDRESS CHECK FOR STORES 51036100 T 0021 + THEN BEGIN 51036200 T 0021 + SETINTERRUPT (INVADRI); 51036300 T 0022 + GO OC 51036400 T 0023 + END; 51036500 T 0024 + MOVE(M[MM],C); MEMCYCLE; 51037000 T 0025 + IF OVERWRITE OR READWITHLOCK OR NOT BOOLEAN(CX.TAG) 51038000 T 0030 + THEN MOVE(B,M[MM]); 51039000 T 0033 + IF OVERWRITE OR READWITHLOCK THEN GO TO LABELF; 51040000 T 0038 + %%%%% PAGE 2 %%%%%%%%%%%%%%% 51041000 T 0042 + CASE CX.TAG OF 51042000 T 0042 + BEGIN % CASE TYPE 51043000 T 0043 +PRT(775) = *CASE STATEMENT DESCRIPTOR* + ; % 0 SINGL 51044000 T 0043 + GO TO EVALIRW; % 1 IRW 51045000 T 0043 + ; % 2 DOUBL 51046000 T 0044 + MEMORYPROTECT; % 3 LINKS,CODE,MSCW,RCW,L 51047000 T 0044 + ; % 4 STEP INDEX WORD 51048000 T 0045 + IF C.IBIT=1 THEN GO EVALDESC ELSE MEMORYPROTECT; % 5 51049000 T 0045 + ; % 6 UNINITIALIZED 51050000 T 0049 + GO TO ACCIDENTALENTRY; % 7 PCW 51051000 T 0049 + END; 51052000 T 0049 + START OF SEGMENT ********** 101 + 101 IS 8 LONG, NEXT SEG 100 + MIXEDTYPECHECK: 51053000 T 0049 + CASE REAL(CX.TAG=DOUBL)×2 + REAL(BX.TAG=DOUBL) OF 51054000 T 0050 + BEGIN % C B 51055000 T 0053 +PRT(776) = *CASE STATEMENT DESCRIPTOR* + ; % S S 51056000 T 0053 + BEGIN IF Y.[9:1]=1 THEN B←(B+1)&B[1:1:8]; % S D 51057000 T 0053 + BX.TAG←0; MOVE(B,M[MM]); MEMCYCLE; % 51058000 T 0057 + END; % 51059000 T 0064 + BEGIN BX.TAG←DOUBL; Y←YX←0; YX.TAG←DOUBL; % D S 51060000 T 0065 + MOVE(B,M[MM ]); MEMCYCLE; % 51061000 T 0070 + MOVE(Y,M[MM+1]); MEMCYCLE; % 51062000 T 0075 + END; % 51063000 T 0081 + BEGIN MOVE(Y,M[MM+1]); MEMCYCLE; % D D 51064000 T 0081 + END; % 51065000 T 0087 + END; 51066000 T 0087 + START OF SEGMENT ********** 102 + 102 IS 4 LONG, NEXT SEG 100 + FIXROFS: 51067000 T 0087 + AROF←FALSE; 51068000 T 0088 + BROF←NONDESTRUCTIVE; 51069000 T 0088 + GO TO OC; 51070000 T 0089 + LABELF: 51071000 T 0090 + IF NOT READWITHLOCK THEN GO TO FIXROFS; 51072000 T 0090 + MOVE(C,A); 51073000 T 0091 + BROF ← FALSE; 51073100 T 0092 + GO TO OC; 51074000 T 0093 + %%%%% PAGE 3 %%%%%%%%%%%%%%% 51075000 T 0093 + EVALIRW: 51076000 T 0093 + IF C.EBIT=0 THEN 51077000 T 0094 + BEGIN %%%%% NORMAL IRW %%%%% 51078000 T 0095 + Q02F←1; 51079000 T 0095 + A.DISP←D[LEVEL(C)] - BOSR; 51080000 T 0097 + A.STKNR←SNR; 51081000 T 0100 + TEMP←BOSR; 51082000 T 0102 + BUF←D[LEVEL(C)]; 51083000 T 0103 + MM←BUF+DELTA(C); 51084000 T 0104 + END 51085000 T 0106 + ELSE 51086000 T 0106 + BEGIN %%%%% STUFFED IRW %%%%% 51087000 T 0106 + Q02F←0; 51088000 T 0106 + MOVE(C,A); 51089000 T 0108 + IF SNR = C.STKNR THEN TEMP←BOSR 51090000 T 0109 + ELSE BEGIN 51091000 T 0111 + MOVE(M[STACKVECTOR],C); MEMCYCLE; 51092000 T 0112 + IF CX.PBIT=0 THEN PRESENCEBIT; 51093000 T 0118 + IF C.LENGTH≤A.STKNR THEN INVALIDINDEX; 51094000 T 0121 + MOVE(M[C.ADDR+A.STKNR],C); MEMCYCLE; 51095000 T 0125 + IF CX.PBIT=0 THEN PRESENCEBIT; 51096000 T 0131 + TEMP←C.ADDR; 51097000 T 0134 + END; 51098000 T 0136 + BUF←TEMP+A.DISP; 51099000 T 0136 + MM←BUF+A.[35:13]; 51100000 T 0137 + END; 51101000 T 0139 + GO TO TRYWRITE; 51102000 T 0139 + ACCIDENTALENTRY: 51103000 T 0140 + Q01F←1; 51104000 T 0140 + NOTYETCODED; 51105000 T 0141 + OC: 51106000 T 0142 + END STORE; 51107000 T 0143 + 100 IS 144 LONG, NEXT SEG 12 + PROCEDURE ADJ(NEWAROF,NEWBROF); VALUE NEWAROF,NEWBROF; 60000000 T 0911 + INTEGER NEWAROF,NEWBROF; 60001000 T 0911 + BEGIN DEFINE 60002000 T 0911 + START OF SEGMENT ********** 103 + PUSHA = 60003000 T 0000 + BEGIN 60003150 T 0000 + STKOVFF ← S ← S + 1 =LOSR; 60003300 T 0000 + MOVE(A, M[S]); MEMCYCLE; AROF ← FALSE; 60004000 T 0000 + IF AX.TAG = DOUBL 60004300 T 0000 + THEN BEGIN 60004600 T 0000 + STKOVFF ← S ← S + 1 = LOSR; 60005000 T 0000 + XX.TAG ← DOUBL; MOVE(X, M[S]); MEMCYCLE; 60006000 T 0000 + END 60006300 T 0000 + END#, 60006600 T 0000 + PUSHB = 60007000 T 0000 + BEGIN 60007150 T 0000 + STKOVFF ← S ← S + 1 =LOSR; 60007300 T 0000 + MOVE(B, M[S]); MEMCYCLE; BROF ← FALSE; 60008000 T 0000 + IF BX.TAG = DOUBL 60008300 T 0000 + THEN BEGIN 60008600 T 0000 + STKOVFF ← S ← S + 1 = LOSR; 60009000 T 0000 + YX.TAG ← DOUBL; MOVE(Y, M[S]); MEMCYCLE; 60010000 T 0000 + END 60010300 T 0000 + END#, 60010600 T 0000 + POPA = BEGIN MOVE(M[S],A); S←S-1; MEMCYCLE; AROF←TRUE; 60011000 T 0000 + IF AX.TAG=DOUBL THEN 60012000 T 0000 + BEGIN X←A; XX←AX; 60013000 T 0000 + MOVE(M[S],A); S←S-1; MEMCYCLE; 60014000 T 0000 + END; 60015000 T 0000 + END#, 60016000 T 0000 + POPB = BEGIN MOVE(M[S],B); S←S-1; MEMCYCLE; BROF←TRUE; 60017000 T 0000 + IF BX.TAG=DOUBL THEN 60018000 T 0000 + BEGIN Y←B; YX←BX; 60019000 T 0000 + MOVE(M[S],B); S←S-1; MEMCYCLE; 60020000 T 0000 + END; 60021000 T 0000 + END#, 60022000 T 0000 + ATOB = BEGIN B←A; BX←AX; AROF←FALSE; BROF←TRUE; 60023000 T 0000 + IF AX.TAG=DOUBL THEN BEGIN Y←X; YX←XX; END; 60024000 T 0000 + END#, 60025000 T 0000 + BTOA = BEGIN A←B; AX←BX; AROF←TRUE; BROF←FALSE; 60026000 T 0000 + IF BX.TAG=DOUBL THEN BEGIN X←Y; XX←YX; END; 60027000 T 0000 + END#; 60028000 T 0000 + IF NEWAROF<0 OR NEWAROF>1 OR NEWBROF<0 OR NEWBROF>2 60029000 T 0000 + THEN BEGIN ERROR(98); GO TO EOJ; END; 60030000 T 0003 + AROF←AROF AND TRUE; BROF←BROF AND TRUE; 60031000 T 0007 + CASE (0&NEWAROF[45:47:1]&NEWBROF[43:46:2] 60032000 T 0009 + &REAL(AROF)[46:47:1]&REAL(BROF)[47:47:1]) OF 60033000 T 0012 + BEGIN % NEWA NEWB AROF BROF CASE 60034000 T 0014 +PRT(777) = *CASE STATEMENT DESCRIPTOR* + ; % 0 0 0 0 0 60035000 T 0014 + PUSHB; % 0 0 0 1 1 60036000 T 0014 + PUSHA; % 0 0 1 0 2 60037000 T 0034 + BEGIN PUSHB; PUSHA; END; % 0 0 1 1 3 60038000 T 0054 + POPA; % 1 0 0 0 4 60039000 T 0093 + BTOA; % 1 0 0 1 5 60040000 T 0110 + ; % 1 0 1 0 6 60041000 T 0117 + PUSHB; % 1 0 1 1 7 60042000 T 0117 + POPB; % 0 1 0 0 8 60043000 T 0137 + ; % 0 1 0 1 9 60044000 T 0154 + ATOB; % 0 1 1 0 10 60045000 T 0154 + BEGIN PUSHB; ATOB; END; % 0 1 1 1 11 60046000 T 0161 + BEGIN POPA; POPB; END; % 1 1 0 0 12 60047000 T 0187 + BEGIN BTOA; POPB; END; % 1 1 0 1 13 60048000 T 0221 + POPB; % 1 1 1 0 14 60049000 T 0245 + ; % 1 1 1 1 15 60050000 T 0263 + ; % 0 2 0 0 16 60051000 T 0263 + ; % 0 2 0 1 17 60052000 T 0263 + ATOB; % 0 2 1 0 18 60053000 T 0263 + BEGIN PUSHB; ATOB; END; % 0 2 1 1 19 60054000 T 0269 + POPA; % 1 2 0 0 20 60055000 T 0295 + BTOA; % 1 2 0 1 21 60056000 T 0313 + ; % 1 2 1 0 22 60057000 T 0320 + ; % 1 2 1 1 23 60058000 T 0320 + END; 60059000 T 0320 + START OF SEGMENT ********** 104 + 104 IS 24 LONG, NEXT SEG 103 + IF NOT (NEWAROF=REAL(AROF) AND (NEWBROF=2 OR 60060000 T 0320 + NEWBROF=REAL(BROF))) 60061000 T 0321 + THEN BEGIN ERROR(99); MEMDUMP; GO EOJ END; 60062000 T 0322 + END ADJ; 60063000 T 0327 + 103 IS 328 LONG, NEXT SEG 12 + INTEGER PROCEDURE LEVEL(WORD); VALUE WORD; REAL WORD; 60064000 T 0911 + BEGIN 60065000 T 0911 + LEVEL ← REFLECTION[REAL( 60066000 T 0911 + BOOLEAN(WORD) AND NOT BOOLEAN(DELTAMASK[LL]) 60067000 T 0911 + ).[34:5]]; 60068000 T 0911 + END LEVEL; 60069000 T 0913 + INTEGER PROCEDURE DELTA(WORD); VALUE WORD; REAL WORD; 60070000 T 0915 + BEGIN 60071000 T 0915 + DELTA ← REAL(BOOLEAN(WORD) AND BOOLEAN(DELTAMASK[LL])); 60072000 T 0915 + END DELTA; 60073000 T 0917 + BOOLEAN PROCEDURE INTEGERIZE(ROUND,REG); VALUE ROUND; 60074000 T 0919 + BOOLEAN ROUND; REAL REG; 60075000 T 0919 + BEGIN 60076000 T 0919 + STREAM PROCEDURE M0VE4(S,D); 60077000 T 0919 + START OF SEGMENT ********** 105 +PRT(1000) = M0VE4 + BEGIN SI←S; DI←D; DS←4 WDS; 60078000 T 0000 + END M0VE4; 60079000 T 0000 + REAL OWNA,OWNAX,OWNX,OWNXX; 60080000 T 0001 +STACK(F+3) = OWNA +STACK(F+4) = OWNAX +STACK(F+5) = OWNX +STACK(F+6) = OWNXX + INTEGER I; 60081000 T 0001 +STACK(F+7) = I + LABEL FINIS; 60082000 T 0001 + DEFINE MAXNTGR = 549755813887#; 60083000 T 0001 + M0VE4(REG,OWNA); 60084000 T 0001 + IF OWNAX.TAG≠SINGL AND OWNAX.TAG≠DOUBL THEN 60085000 T 0002 + INTEGERIZE ← TRUE; 60086000 T 0005 + IF (INTEGERIZE←ABS(OWNA)>MAXNTGR) THEN GO TO FINIS; 60087000 T 0006 + IF NOT ROUND THEN 60088000 T 0008 + I ← OWNA DIV 1 60089000 T 0009 + ELSE IF OWNAX.TAG =SINGL THEN 60090000 T 0009 + I ← OWNA 60091000 T 0014 + ELSE % DOUBLE PRECISION ROUNDED CASE 60092000 T 0014 + BEGIN 60093000 T 0015 + DOUBLE(OWNA,OWNX,(I←OWNA DIV 1),0,-, 60094000 T 0016 + ←,OWNAX,OWNXX); 60095000 T 0018 + IF I≥0 AND OWNAX≥(0.5) THEN 60096000 T 0019 + BEGIN 60097000 T 0021 + IF (INTEGERIZE←(I+1)>+(MAXNTGR)) THEN 60098000 T 0021 + GO TO FINIS; 60099000 T 0023 + I←I+1; 60100000 T 0024 + END 60101000 T 0025 + ELSE IF I<0 AND OWNAX<-(0.5) THEN 60102000 T 0025 + BEGIN 60103000 T 0030 + IF (INTEGERIZE←(I-1)<-(MAXNTGR)) THEN 60104000 T 0030 + GO TO FINIS; 60105000 T 0032 + I←I-1; 60106000 T 0033 + END; 60107000 T 0034 + END; 60108000 T 0034 + OWNA←1; OWNAX←SINGL+SINGL; MOVE(OWNA,REG); 60109000 T 0034 + FINIS: 60110000 T 0037 + END INTEGERIZE; 60111000 T 0038 + 105 IS 44 LONG, NEXT SEG 12 + PROCEDURE INITIALIZE; 71000000 T 0919 +PRT(1001) = INITIALIZE + BEGIN 71001000 T 0919 + FILE CODE DISK SERIAL (2,30); 71002000 T 0919 + START OF SEGMENT ********** 106 +STACK(F+2) = CODE + FORMAT ERROR ("EQUATED FILE IS NOT ON DISK. ", 32("X"), //); 71003000 T 0003 + START OF SEGMENT ********** 107 +PRT(1002) = ERROR + 107 IS 13 LONG, NEXT SEG 106 + LABEL EOF; 71004000 T 0003 + ARRAY JUNK[0:59],JUNK1[0:29]; 71005000 T 0003 +STACK(F+3) = JUNK +STACK(F+4) = JUNK1 + ARRAY MEMS[0:89]; 71005100 T 0007 +STACK(F+5) = MEMS + LABEL EOF1; 71006000 T 0008 + INTEGER MSTART; 71007000 T 0008 +STACK(F+6) = MSTART + STREAM PROCEDURE MOVEN(S,D,N); VALUE N; 71008000 T 0008 +PRT(1003) = MOVEN + BEGIN SI←S; DI←D; DS←N WDS END; 71009000 T 0008 + STREAM PROCEDURE STRIP(J,M); 71010000 T 0011 +PRT(1004) = STRIP + BEGIN LOCAL S,SS; 71011000 T 0011 + SI←J; DI←M; 71012000 T 0012 + 45(48 BITS; SKIP 31 DB; 16 BITS; SKIP 1 DB); 71013000 T 0012 + END; 71014000 T 0017 + STREAM PROCEDURE NFLAG(M); 71015000 T 0017 +PRT(1005) = NFLAG + BEGIN SI←M; DI←M; DI←DI+8; DI←DI+7; SKIP 5 DB; 71016000 T 0017 + 1 BITS; DI←DI+4; DI←M; DS←1 RESET; END; 71017000 T 0019 + SEARCH(CODE,TBUF[*]); 71018000 T 0022 + IF TBUF[0] > 0 THEN 71019000 T 0025 + BEGIN 71020000 T 0026 + MULFILID ← TBUF[1]; 71020100 T 0026 + FILID ← TBUF [2]; 71020200 T 0027 + MSTART←0; 71021000 T 0028 + DO BEGIN 71022000 T 0029 + READ(CODE,30,JUNK[*])[EOF]; 71023000 T 0029 +PRT(1006) = EOF + READ(CODE,30,JUNK1[*])[EOF1]; 71024000 T 0034 +PRT(1007) = EOF1 + MOVEN(JUNK1,JUNK[30],30); 71025000 T 0039 + EOF1: 71026000 T 0041 + STRIP(JUNK,MEMS); 71027000 T 0042 + FOR INTG←0 STEP 2 UNTIL 89 DO 71028000 T 0044 + BEGIN 71028100 T 0045 + IF MSTART+INTG/2 > 8191 THEN GO EOF; 71028110 T 0045 + NFLAG(MEMS[INTG]); 71028200 T 0047 + MOVE(MEMS[INTG],M[MSTART+INTG/2]); 71028300 T 0048 + END; 71029000 T 0053 + MSTART←MSTART+45; 71030000 T 0056 + END UNTIL FALSE; 71031000 T 0057 + EOF: 71032000 T 0058 + END ELSE BEGIN WRITE (LP, ERROR); GO EOF END; 71033000 T 0058 + 71034000 T 0063 + 71035000 T 0063 + 71036000 T 0063 + 71037000 T 0063 + 71038000 T 0063 + S←8192; PDR←2; SNR←2; 71039000 T 0063 + SNR ←0; 71040000 T 0066 + SETINTERRUPT (EXTINTI + 15); 71045000 T 0066 + P←0&32768[8:28:20]; 71046000 T 0068 + PX←11; 71047000 T 0069 + MOVE(P,M[4]); 71048000 T 0070 + END OF INITIALIZE; 71049000 T 0074 + 106 IS 83 LONG, NEXT SEG 12 + PROCEDURE COBOLSIM; % SPECIAL INITIALIZATION FOR COBOL SIMULATION; 71050000 T 0919 +PRT(1010) = COBOLSIM + BEGIN 71051000 T 0919 + FILE DK DISK SERIAL "SIM" "INPUT" (2,30,150); 71052000 T 0919 + START OF SEGMENT ********** 108 +STACK(F+2) = DK + ARRAY J[0:29]; 71053000 T 0003 +STACK(F+3) = J + REAL SZ; 71054000 T 0005 +STACK(F+4) = SZ + INTEGER I,K; 71055000 T 0005 +STACK(F+5) = I +STACK(F+6) = K + STREAM PROCEDURE MV(F,T); 71056000 T 0005 +PRT(1011) = MV + BEGIN 71057000 T 0005 + SI ← F; DI ← T; DS ←2 WDS; 71058000 T 0006 + END MV; 71059000 T 0006 + READ(DK,30,J[*]); 71060000 T 0007 + D0 ← J[0]; 71061000 T 0011 + D1 ← J[2]; 71062000 T 0012 + D2 ← J[4]; 71063000 T 0014 + S ← (D3 ←F ← J[6]) + 2; 71064000 T 0015 + LOSR ← J[8]; 71065000 T 0018 + BOSR ← 0; 71066000 T 0019 + PBR ← J[10].[28:20]; 71067000 T 0020 + LL ← 3; 71068000 T 0022 + SZ ← J[10].[8:20]; 71069000 T 0022 + I ← -1; WHILE I ←1 +1 ≤ SZ DO 71070000 T 0024 + BEGIN 71071000 T 0027 + K ←-2; WHILE K <30 DO 71072000 T 0027 + MV(J[K ← K + 2],M[I]); 71073000 T 0029 + READ(DK,30,J[*]); 71074000 T 0035 + END; 71075000 T 0040 + END COBOLSIM; 71076000 T 0040 + 108 IS 46 LONG, NEXT SEG 12 + INTEGER PROCEDURE PROTECT (IOAREA, IOCW, RESULT); 71077000 T 0919 +PRT(1012) = PROTECT + VALUE IOAREA, IOCW; 71078000 T 0919 + REAL IOAREA, IOCW, RESULT; 71079000 T 0919 + BEGIN COMMENT CHECK AN INPUT AREA FOR THE PRESENCE 0F PROTECTED 71080000 T 0919 + WORDS AND RETURN THE MAXIMUM NUMBER OF WORDS THAT CAN BE 71081000 T 0919 + WRITTEN T0 MEMORY. PLACE THE ENDING ADDRESS IN THE RESULT 71082000 T 0919 + DESCRIPTOR.; 71083000 T 0919 + INTEGER WORDS; 71084000 T 0919 + START OF SEGMENT ********** 109 +STACK(F+3) = WORDS + REAL R, S; 71085000 T 0000 +STACK(F+4) = R +STACK(F+5) = S + LABEL FINISH; 71086000 T 0000 + IF BOOLEAN (IOCW.IOPBIT) AND BOOLEAN (IOCW.IOWBIT) 71087000 T 0000 + THEN BEGIN 71088000 T 0000 + S ← IOAREA.ADDR +IOAREA.LENGTH; 71089000 T 0002 + FOR R ← IOAREA.ADDR + 1.5 STEP 1 UNTIL S DO 71090000 T 0004 + IF BOOLEAN (M [R].TAG) 71091000 T 0009 + THEN BEGIN 71092000 T 0009 + WORDS ← R - 1.5 -IOAREA.ADDR; 71093000 T 0013 + RESULT.RSLTPRO ← 1; 71094000 T 0015 + GO FINISH; 71095000 T 0018 + END; 71096000 T 0020 + END 71097000 T 0020 + ELSE WORDS ← IOAREA.LENGTH - 1; 71098000 T 0020 + FINISH: 71099000 T 0022 + RESULT.RSLTADRS ← IOAREA.ADDR + WORDS + 1; 71100000 T 0023 + PROTECT ← WORDS; 71101000 T 0026 + END PROTECT AND ENDING ADDRESS PROCESSING; 71102000 T 0027 + 109 IS 30 LONG, NEXT SEG 12 + REAL PROCEDURE GETRESULT (MPXAB); 71103000 T 0919 + VALUE MPXAB; 71104000 T 0919 + REAL MPXAB; 71105000 T 0919 + BEGIN COMMENT GET THE NEXT RESULT DESCRIPTOR FOR MPXAB AND UPDATE 71106000 T 0919 + FIRSTEVENT, FIRSTEVENTI, CURRENT TIME AND MPX. THE 71107000 T 0919 + RESULT DESCRIPTOR THAT IS GOTTEN, IS FORGOTTEN.; 71108000 T 0919 + REAL R; 71109000 T 0919 + START OF SEGMENT ********** 110 +STACK(F+3) = R + REAL E, L; 71109100 T 0000 +STACK(F+4) = E +STACK(F+5) = L + INTEGER I, J, F; 71110000 T 0000 +STACK(F+6) = I +STACK(F+7) = J +STACK(F+10) = F + R ← MPX [I ← MPXAB + DELTAMPX, J ← FIRSTEVENTI [MPXAB]]; 71111000 T 0000 + IF R.RSLTERR ≠ 0 THEN R.RSLTEXC ← 1; 71112000 T 0003 + F ← FIRSTEVENTI [MPXAB] ← EVENTS [J].EVLINK; 71113000 T 0007 + L ← J; 71113100 T 0009 + DO L ← (E ← EVENTS[L]).EVLINK UNTIL E =0 OR E.EVMPX =MPXAB; 71113200 T 0010 + IF E ≠0 AND MPX[MPXAB, L].MPXINT =0 71113300 T 0015 + THEN MPX[MPXAB, L].MPXINT ← MPX[MPXAB, J].MPXINT; 71113400 T 0017 + MPX [I, J] ← EVENTS [J] ← 0; 71114000 T 0023 + FIRSTEVENT [MPXAB] ← EVENTS [F].EVTIME; 71115000 T 0026 + CURRENTT ← FIRSTEVENT [CURRENTMPX ← IF J ← FIRSTEVENT [2] = 0 71116000 T 0028 + OR (I ← FIRSTEVENT [1] ≤ J AND I ≠ 0) THEN 1 ELSE 2]; 71117000 T 0029 + IF CURRENTT ≠ 0 AND(CURRENTT < IDLETIME OR IDLETIME = 0) 71118000 T 0034 + THEN IDLETIME ← CURRENTT ELSE IDLETIME ← INTTIMER; 71119000 T 0037 + MPXOPS [MPXAB] ← MPXOPS [MPXAB] + 1; 71120000 T 0040 + IF CURRENTT = 0 THEN LASTEVENT [MPXAB] ← 0; 71121000 T 0042 + GETRESULT ← R; 71122000 T 0045 + END GETTING RESULT DESCRIPTOR; 71123000 T 0046 + 110 IS 50 LONG, NEXT SEG 12 + PROCEDURE PUTRESULT (LUNIT, MPXAB, IOTIME, RESULT); 71124000 T 0919 +PRT(1013) = PUTRESULT + VALUE LUNIT, MPXAB, IOTIME; 71125000 T 0919 + REAL RESULT; 71126000 T 0919 + INTEGER LUNIT, MPXAB, IOTIME; 71127000 T 0919 + BEGIN COMMENT DO THE LINKED LIST UPDATING BASED ON IOTIME (THE TIME 71128000 T 0919 + INCREMENT FOR AN I/O) AND UPDATE CURRENTT AND 71129000 T 0919 + CURRENTMPX AS REQUIRED. PUT THE RESULT DESCRIPTOR IN 71130000 T 0919 + MPX BASED ON LUNIT AND MPXAB.; 71131000 T 0919 + INTEGER T, I, J, K; 71132000 T 0919 + START OF SEGMENT ********** 111 +STACK(F+2) = T +STACK(F+3) = I +STACK(F+4) = J +STACK(F+5) = K + DEFINE EVERYTHING =MPXAB [1:46:2] 71133000 T 0000 + &1 [6:47:1] % BUSY 71134000 T 0000 + &I [7:43:5] % EVENT LINK 71135000 T 0000 + #; 71136000 T 0000 + IF T←IOTIME≥LASTEVENT [MPXAB] % COMMON CASE 71137000 T 0000 + THEN BEGIN 71138000 T 0001 + EVENTS [LASTEVENTI[MPXAB]].EVLINK ← LUNIT; 71139000 T 0002 + LASTEVENT [MPXAB] ← T; 71140000 T 0004 + LASTEVENTI[MPXAB] ← LUNIT; 71141000 T 0006 + IF FIRSTEVENT [MPXAB] = 0 71142000 T 0007 + THEN BEGIN 71143000 T 0007 + FIRSTEVENT [MPXAB] ← T; 71144000 T 0008 + FIRSTEVENTI[MPXAB] ← LUNIT; 71145000 T 0010 + END; 71146000 T 0011 + END 71147000 T 0011 + ELSE BEGIN 71148000 T 0011 + I ← K ← FIRSTEVENTI [MPXAB]; 71149000 T 0011 + WHILE EVENTS [I].EVTIME ≤ T 71150000 T 0013 + DO I ← EVENTS [J ← I].EVLINK; 71151000 T 0014 + IF I = K % T IS EARLIER THAN EARLIEST 71152000 T 0017 + THEN BEGIN 71153000 T 0018 + FIRSTEVENTI [MPXAB] ← LUNIT; 71154000 T 0019 + FIRSTEVENT [MPXAB] ← T; 71155000 T 0020 + J ← I; 71156000 T 0021 + END; 71157000 T 0022 + EVENTS [J].EVLINK ← LUNIT 71158000 T 0022 + END; 71159000 T 0023 + EVENTS [LUNIT] ← T & EVERYTHING; 71160000 T 0024 + RESULT.RSLTUNIT ← LUNIT; 71161000 T 0029 + MPX [MPXAB + DELTAMPX, LUNIT] ← RESULT; 71162000 T 0031 + MPX[MPXAB, LUNIT].MPXINT ← MPXAB ← 240; % INTERRUPT LITERAL 71163000 T 0033 + IF T < CURRENTT OR CURRENTT = 0 71164000 T 0037 + THEN BEGIN CURRENTT ← T; CURRENTMPX ← MPXAB END; 71165000 T 0038 + IF T < IDLETIME OR IDLETIME =0 THEN IDLETIME ← T; 71166000 T 0041 + MPXOPS [MPXAB] ← MPXOPS [MPXAB] - 1; 71167000 T 0044 + END SORTING TIME AND RESULT DESCRIPTOR FOR AN IO; 71168000 T 0046 + 111 IS 49 LONG, NEXT SEG 12 + PROCEDURE FLAGHANDLE (MESS, MINDEX, WORDS, IOCW); 71169000 T 0919 +PRT(1014) = FLAGHANDLE + VALUE MINDEX, WORDS, IOCW; 71170000 T 0919 + INTEGER MINDEX, WORDS; 71171000 T 0919 + ARRAY MESS [0]; 71172000 T 0919 + REAL IOCW; 71173000 T 0919 + BEGIN COMMENT MOVE INPUT FROM WORK AREA (MESS) TO M ARRAY START- 71174000 T 0919 + ING AT MINDEX + 1 AND MOVE THE FLAG BIT TO THE EXTENSION 71175000 T 0919 + WORD.; 71176000 T 0919 + INTEGER I, J, K, MI, R, W; 71177000 T 0919 + START OF SEGMENT ********** 112 +STACK(F+2) = I +STACK(F+3) = J +STACK(F+4) = K +STACK(F+5) = MI +STACK(F+6) = R +STACK(F+7) = W + INTEGER JDIV, JMOD, TAG, BCD; 71178000 T 0000 +STACK(F+10) = JDIV +STACK(F+11) = JMOD +STACK(F+12) = TAG +STACK(F+13) = BCD + DEFINE FLAGGER = 71179000 T 0000 + DI ← B; DI ← DI + 15; SKIP 2 DB; 71180000 T 0000 + SI ← LOC TAG; SKIP 45 SB; 71181000 T 0000 + 3 BITS; SI ← A; 71182000 T 0000 + IF SB THEN DS ← 1 SET ELSE DS ← 1 RESET; 71183000 T 0000 + DI ← A; DS ← 1 RESET; SI ← A; DI ← B; 71184000 T 0000 + DS ← WDS; A ← SI; DI ← DI + 8; B ← DI; #; 71185000 T 0000 + STREAM PROCEDURE FLAGIN (S, D, JDIV, JMOD, TAG); 71186000 T 0000 +PRT(1015) = FLAGIN + VALUE JDIV, JMOD, TAG; 71187000 T 0000 + BEGIN 71188000 T 0000 + LOCAL A, B; 71189000 T 0000 + SI ← S; A ← SI; DI ← D; B ← DI; 71190000 T 0000 + JMOD (FLAGGER); 71191000 T 0001 + JDIV (32(FLAGGER)); 71192000 T 0009 + END; 71193000 T 0017 + DEFINE TAGGERIN = 71194000 T 0017 + SKIP BCD SB; 71195000 T 0017 + DI ← B; DI ← DI + 15; SKIP 2 DB; 71196000 T 0017 + 4 BITS; DI ← B; SKIP DB; 47 BITS; %>RETRO 71197000 T 0017 + DI ← DI + 8; B ← DI; #; %>RETRO 71198000 T 0017 + STREAM PROCEDURE TAGIN (M, MESS, JDIV, JMOD, BCD); %>RETRO 71199000 T 0017 +PRT(1016) = TAGIN + VALUE JDIV, JMOD, BCD; %>RETRO 71200000 T 0017 + BEGIN 71201000 T 0017 + LOCAL B; 71202000 T 0018 + SI ← MESS; DI ← M; B ← DI; 71203000 T 0018 + JMOD (TAGGERIN); 71204000 T 0018 + JDIV (32(TAGGERIN)); 71205000 T 0026 + END; 71206000 T 0034 + DEFINE FLAGGEROUT = 71207000 T 0034 + SI ← A; SI ← SI + 15; SKIP 5 SB; 71208000 T 0034 + DI ← A; IF SB THEN DS ← 1 SET ELSE DS ← 1 RESET; 71209000 T 0034 + DI ← B; SI ← A; DS ← WDS; B ← DI; 71210000 T 0034 + DI ← A; DS ← 1 RESET; 71211000 T 0034 + SI ← A; SI ← SI + 16; A ← SI;#; 71212000 T 0034 + STREAM PROCEDURE FLAGOUT (S, D, JDIV, JMOD); 71213000 T 0034 +PRT(1017) = FLAGOUT + VALUE JDIV, JMOD; 71214000 T 0034 + BEGIN 71215000 T 0034 + LOCAL A, B; 71216000 T 0035 + SI ← S; A ← SI; DI ← D; B ← DI; 71217000 T 0035 + JMOD (FLAGGEROUT); 71218000 T 0036 + JDIV (32(FLAGGEROUT)); 71219000 T 0041 + END; 71220000 T 0048 + DEFINE TAGGER = 71221000 T 0048 + SI ← A; SI ← SI + 15; SKIP 2 SB; 71222000 T 0048 + DI ← B; DS ← 3 LIT "0"; DI ← B; SKIP BCD DB;4 BITS; 71223000 T 0048 + SI ← A; SKIP SB; 47 BITS; SI ← SI + 8; 71224000 T 0048 + A ← SI; B ← DI;#; 71225000 T 0048 + STREAM PROCEDURE TAGOUT (M, MESS, JDIV, JMOD, BCD); 71226000 T 0048 +PRT(1020) = TAGOUT + VALUE JDIV, JMOD, BCD; 71227000 T 0048 + BEGIN 71228000 T 0048 + LOCAL A, B; 71229000 T 0049 + SI ← M; A ← SI; DI ← MESS; B ← DI; 71230000 T 0049 + JMOD (TAGGER); 71231000 T 0050 + JDIV (32(TAGGER)); 71232000 T 0059 + END; 71233000 T 0068 + MI ← MINDEX + 1; 71234000 T 0068 + W ← WORDS; 71235000 T 0070 + TAG ← IF I ← IOCW.IOTAGS = 0 THEN SINGL ELSE 71236000 T 0071 + IF I = 1 THEN CODE ELSE IF I = 3 THEN DOUBL ELSE 4; 71237000 T 0074 + BCD ← IF IOCW.IOSBIT = 1 THEN 13 ELSE 9; 71238000 T 0078 + DO BEGIN 71239000 T 0082 + I ← MI MOD ROWLENGTH; 71240000 T 0082 + J ← IF (R ← ROWLENGTH- I) > W THEN W ELSE R; 71241000 T 0083 + JDIV ← J DIV 32; 71242000 T 0087 + JMOD ← J MOD 32; 71243000 T 0088 + IF IOCW.IOWBIT = 1 71244000 T 0089 + THEN BEGIN 71245000 T 0090 + IF TAG < 4 71246000 T 0091 + THEN FLAGIN (MESS[K],M[MI],JDIV,JMOD,TAG) 71247000 T 0091 + ELSE TAGIN (MESS[K],M[MI],JDIV,JMOD,BCD); 71248000 T 0097 + END 71249000 T 0104 + ELSE BEGIN 71250000 T 0104 + IF TAG < 4 71251000 T 0104 + THEN FLAGOUT (M[MI], MESS[K], JDIV, JMOD) 71252000 T 0105 + ELSE TAGOUT (M[MI],MESS[K],JDIV,JMOD, BCD); 71253000 T 0110 + END; 71254000 T 0117 + K ← K + J; 71255000 T 0117 + MI ← MI + J; 71256000 T 0119 + END UNTIL W ← W - J ≤ 0; 71257000 T 0120 + END INPUT FLAG BIT MANIPULATI0NS; 71258000 T 0122 + 112 IS 127 LONG, NEXT SEG 12 + INTEGER PROCEDURE MPXTIME(ELTIME,METIME,LUNIT); 71259000 T 0919 +PRT(1021) = MPXTIME + VALUE ELTIME,METIME,LUNIT; 71260000 T 0919 + INTEGER ELTIME,METIME,LUNIT; 71261000 T 0919 + BEGIN 71262000 T 0919 + IF(EVENTS[LUNIT].EVTIME)REALTIME 71264000 T 0921 + THEN MPXTIME←UNITAVAILTIME[LUNIT]+ELTIME 71265000 T 0922 + ELSE MPXTIME←REALTIME+ELTIME; 71266000 T 0924 + IF (EVENTS[LUNIT].EVTIME)=0 71267000 T 0926 + THEN UNITAVAILTIME[LUNIT]←REALTIME+METIME 71268000 T 0927 + ELSE UNITAVAILTIME[LUNIT]←EVENTS[LUNIT].EVTIME+METIME; 71269000 T 0929 + END EVALUATION OF MPXTIME FOR AN IO; 71270000 T 0933 + PROCEDURE CARDLOAD; 71271000 T 0935 +PRT(1022) = CARDLOAD + BEGIN 71272000 T 0935 + FILE EDOC DISK SERIAL (2,3,30); 71273000 T 0935 + START OF SEGMENT ********** 113 +STACK(F+2) = EDOC + DEFINE CODE = EDOC#; 71273100 T 0003 + FORMAT ERROR ("EQUATED FILE IS NOT ON DISK. ", 32("X"),//); 71274000 T 0003 + START OF SEGMENT ********** 114 +PRT(1023) = ERROR + 114 IS 13 LONG, NEXT SEG 113 + LABEL EOF; 71275000 T 0003 + SEARCH (CODE, TBUF[*]); 71276000 T 0003 + IF TBUF[0] > 0 THEN 71277000 T 0005 + BEGIN 71278000 T 0006 + READ (CODE, *, PBR, S, D[0]); 71279000 T 0007 +PRT(1024) = *LIST, LABEL, OR SEGMENT DESCRIPTOR* + DO BEGIN 71280000 T 0018 + READ (CODE, *, MM, A, AX) [EOF]; 71281000 T 0018 +PRT(1025) = *LIST, LABEL, OR SEGMENT DESCRIPTOR* +PRT(1026) = EOF + MOVE (A, M[MM]); 71282000 T 0030 + END 71283000 T 0034 + UNTIL FALSE; 71284000 T 0034 + EOF: 71285000 T 0034 + END 71286000 T 0035 + ELSE 71287000 T 0035 + BEGIN 71288000 T 0035 + WRITE (LP, ERROR); GO EOF END 71289000 T 0035 + END; 71290000 T 0039 + 113 IS 43 LONG, NEXT SEG 12 + PROCEDURE MULTIPLEXOR; 72000000 T 0935 +PRT(1027) = MULTIPLEXOR + BEGIN COMMENT MULTIPLEXOR IS CALLED WHEN THE PROCESSOR HAS INITIATED 72001000 T 0935 + AN I/O. A SWITCH BASED ON HARDWARE UNIT TYPE IS INVOKED 72002000 T 0935 + AND THE SIMULATED I/O IS PERFORMED. TIMING CALCULATIONS 72003000 T 0935 + ARE COMPLETED AND EXCEPTION CONDITIONS ARE NOTED AND THE 72004000 T 0935 + RESULT DESCRIPTOR IS LINKED INTO THE EVENTS AND MPX ARRAYS 72005000 T 0935 + BASED ON MPX AND TIME. THE A & B REGISTERS ARE ASSUMED T0 72006000 T 0935 + BE FULL.; 72007000 T 0935 + REAL MPXINFO, RESULT, WORDS, EVENTIME; 72008000 T 0935 + START OF SEGMENT ********** 115 +STACK(F+2) = MPXINFO +STACK(F+3) = RESULT +STACK(F+4) = WORDS +STACK(F+5) = EVENTIME + INTEGER LDIV,LMOD,DESC,SKIP,SWFI, ELTIME,METIME; 72009000 T 0000 +STACK(F+6) = LDIV +STACK(F+7) = LMOD +STACK(F+10) = DESC +STACK(F+11) = SKIP +STACK(F+12) = SWFI +STACK(F+13) = ELTIME +STACK(F+14) = METIME + BOOLEAN SPACLP; 72010000 T 0000 +STACK(F+15) = SPACLP + REAL FUNCD, FUNCDX, IOAD , IOAREAX, IOCW, IOCWX; 72011000 T 0000 +STACK(F+16) = FUNCD +STACK(F+17) = FUNCDX +STACK(F+20) = IOAD +STACK(F+21) = IOAREAX +STACK(F+22) = IOCW +STACK(F+23) = IOCWX + LABEL AROUND, PUT, CEOF, OC; 72012000 T 0000 + DEFINE EBCDIC = 6(DI ← LOC J; SKIP 43 DB; 5 BITS ; 72013000 T 0000 + DI ← LOC K; SKIP 45 DB; 3 BITS ; 72014000 T 0000 + A ← SI; 72015000 T 0000 + SI ← TABLE; 72016000 T 0000 + J (SI ← SI + 8); SI ← SI + K; 72017000 T 0000 + DI ← B; DS ← CHR; B ← DI; 72018000 T 0000 + SI ← A;)#, 72019000 T 0000 + WORDIV = WORDS.[38:5], WORDS.[43:5]#; 72020000 T 0000 + STREAM PROCEDURE EBCOUT (MESS, TABLE, WMOD, WDIV); 72021000 T 0000 +PRT(1030) = EBCOUT + VALUE WMOD, WDIV; 72022000 T 0000 + BEGIN 72023000 T 0000 + LOCAL A, B, J, K; 72024000 T 0000 + SI ← MESS; A ← SI; 72025000 T 0000 + WMOD (EBCDIC); 72026000 T 0000 + WDIV (32(EBCDIC)); 72027000 T 0010 + END CONVERSION OF EBCDIC INTERNAL TO BCL GRAPHIC; 72028000 T 0021 + DEFINE ERROR201 = 72029000 T 0021 + IF IOAD.LENGTH - 1 > MPXINFO.MPXBUFF 72030000 T 0021 + THEN BEGIN ERROR (201); GO EOJ END;#, 72031000 T 0021 + BADUNIT = 72032000 T 0021 + BEGIN ERROR (200); MEMDUMP; GO EOJ END#; 72033000 T 0021 + STREAM PROCEDURE BLANK (M, LMOD, LDIV); VALUE LMOD, LDIV; 72034000 T 0021 +PRT(1031) = BLANK + BEGIN DI ← M; DS ← 8 LIT " "; SI ← M; DS←LMOD WDS; 72035000 T 0021 + LDIV (DS ← 32 WDS) END; 72036000 T 0024 + REAL STREAM PROCEDURE NFLAG(WORD); 72037000 T 0026 +PRT(1032) = NFLAG + BEGIN SI ← WORD; DI← LOC NFLAG; DS ← 1 WDS; 72038000 T 0026 + DI ← DI - 8; DS ← 1 RESET; 72039000 T 0026 + END; 72040000 T 0027 + DEFINE 72041000 T 0028 + T=PERIPHERALT#, 72042000 T 0028 + TSKIP=5×MPXINFO.MPXHDWE#; 72043000 T 0028 + LABEL EOF,PAR; 72044000 T 0028 + DEFINE READS = IF BOOLEAN(IOCW.IOBBIT) THEN 72045000 T 0028 + BEGIN 72046000 T 0028 + READ REVERSE(TAPES[SWFI], 72047000 T 0028 + MPXINFO.MPXBUFF,MESS[*]) 72048000 T 0028 + [EOF:PAR]; 72049000 T 0028 + IF NFLAG(MESS)=TMK THEN GO EOF; 72050000 T 0028 + MPX[0,FUNCD.LUNIT] ← 72051000 T 0028 + MPX[0,FUNCD.LUNIT] - 1; 72052000 T 0028 + END ELSE 72053000 T 0028 + BEGIN 72054000 T 0028 + READ(TAPES[SWFI],MPXINFO. 72055000 T 0028 + MPXBUFF,MESS[*])[EOF:PAR]; 72056000 T 0028 + IF NFLAG(MESS)=TMK THEN GO EOF; 72057000 T 0028 + BUMPIT; 72058000 T 0028 + END#, 72059000 T 0028 + TRANSLATE = IF BOOLEAN(IOCW.IOXBIT) THEN 72060000 T 0028 + BEGIN 72061000 T 0028 + FLAGHANDLE(MESS,IOAD.ADDR, 72062000 T 0028 + WORDS,IOCW); 72063000 T 0028 + IF BOOLEAN(IOCW.IOSBIT)THEN 72064000 T 0028 + BEGIN 72065000 T 0028 + EBCOUT(MESS, 72066000 T 0028 + EBCTOBCL,WORDIV); 72067000 T 0028 + WORDS ← ENTIER 72068000 T 0028 + (WORDS/.75); 72069000 T 0028 + END; 72070000 T 0028 + END #, 72071000 T 0028 + TIMEIT = ELTIME ← ELTIME + T[TSKIP]; 72072000 T 0028 + METIME ← METIME + T[TSKIP + 1] #, 72073000 T 0028 + BUMPIT = MPX[0,FUNCD.LUNIT] ← 72074000 T 0028 + MPX[0,FUNCD.LUNIT] + 1 #, 72075000 T 0028 + TMK = "≥≥≥≥≥≥≥"&"≥"[1:43:5] # , 72076000 T 0028 + TM = [13:1] #; 72077000 T 0028 + ALPHA STREAM PROCEDURE EXAMIN (NCR); VALUE NCR; 72078000 T 0028 +PRT(1033) = EXAMIN + BEGIN SI←NCR; DI←LOC EXAMIN; DI←DI+7; DS←CHR; END EXAMIN; 72079000 T 0028 + INTEGER STREAM PROCEDURE OUTPCVT(ADDR); VALUE ADDR; 72080000 T 0031 +PRT(1034) = OUTPCVT + BEGIN 72081000 T 0031 + SI ← LOC ADDR; DI ← LOC OUTPCVT; DS ← 8 OCT; 72082000 T 0031 + END; 72083000 T 0031 + REAL SAVIOAD, RECNT; 72084000 T 0032 +STACK(F+24) = SAVIOAD +STACK(F+25) = RECNT + LABEL PRINTERS; 72084100 T 0032 + MOVE (SCANBUSA, FUNCD); 72085000 T 0032 + MOVE (DATABUSA, IOAD); 72086000 T 0034 + MOVE (M[IOAD .ADDR ], IOCW); 72087000 T 0035 + MEMCYCLE; 72087100 T 0039 + RESULT.RSLTATT ← IOCW.IOABIT; 72088000 T 0040 + MPXINFO ← MPX [FUNCD.MPXFC, FUNCD.LUNIT]; 72089000 T 0043 + MULTIPLEX ← FALSE; 72090000 T 0045 + IF BOOLEAN (IOCW.IOTBIT) % TEST 72091000 T 0046 + THEN BEGIN 72092000 T 0047 + A ← MPX [FUNCD.MPXFC + DELTAMPX, FUNCD.LUNIT]; 72093000 T 0047 + A.RSLTBSY ← EVENTS [FUNCD.LUNIT].EVBUSY; 72094000 T 0051 + AX ← 0; 72095000 T 0054 + AROF ← TRUE; 72096000 T 0054 + GO OC; 72097000 T 0055 + END; 72098000 T 0056 + CASE MPXINFO.MPXHDWE OF 72099000 T 0056 + BEGIN % INTERNAL NAME CASE 72100000 T 0056 +PRT(1035) = *CASE STATEMENT DESCRIPTOR* + BADUNIT;% NONE 0 72101000 T 0057 + BEGIN% DISK 1 72102000 T 0061 + IF(JUNK←OUTPCVT(IOCW.[20:28])) < 9999 AND JUNK ≥ 0 THEN 72103000 T 0061 + BEGIN 72104000 T 0065 + SAVIOAD ← IOAD; 72105000 T 0066 + IOAD.LENGTH ← 60; 72106000 T 0066 + RECNT ← 0 ; 72107000 T 0068 + ERROR201; 72108000 T 0069 + IF BOOLEAN (IOCW.IOWBIT) 72109000 T 0075 + THEN DO BEGIN 72110000 T 0075 + READ (DISKA[JUNK], 60, MESS[*]); 72111000 T 0076 + WORDS ← PROTECT (IOAD, IOCW, RESULT); 72112000 T 0081 + FLAGHANDLE (MESS, IOAD.ADDR, WORDS, 72113000 T 0083 + IOCW); 72114000 T 0085 + RECNT ← RECNT + 1; 72115000 T 0086 + JUNK ← JUNK + WORDS; 72116000 T 0087 + TIMEIT; 72117000 T 0089 + END UNTIL SAVIOAD.LENGTH ≤ RECNT 72118000 T 0094 + OR RESULT.[31:17] ≠ 0 72119000 T 0095 + ELSE DO BEGIN 72120000 T 0096 + FLAGHANDLE (MESS, IOAD.ADDR, 60, 72121000 T 0100 + IOCW); 72122000 T 0102 + WRITE (DISKA[JUNK], 60, MESS[*]); 72123000 T 0102 + RECNT ← RECNT + 1; 72124000 T 0107 + JUNK ← JUNK + WORDS; 72125000 T 0109 + TIMEIT; 72126000 T 0110 + END UNTIL SAVIOAD.LENGTH ≤ RECNT 72127000 T 0115 + OR RESULT.[31:17] ≠ 0 72128000 T 0116 + END ELSE 72129000 T 0117 + BEGIN 72130000 T 0119 + RESULT.RSLTNRY ← 1; 72131000 T 0119 + TIMEIT; 72132000 T 0121 + END; 72133000 T 0126 + EVENTIME ← MPXTIME (ELTIME, METIME, FUNCD.LUNIT); 72134000 T 0126 + END; 72135000 T 0129 + BEGIN% SPO 2 72136000 T 0129 + IF TUBA.[9:9]= 0 THEN RESULT.RSLTNRY ← 1 ELSE 72137000 T 0129 + BEGIN 72138000 T 0133 + ERROR201; 72139000 T 0133 + WORDS ← PROTECT(IOAD,IOCW,RESULT); 72140000 T 0139 + IF BOOLEAN(IOCW.IOWBIT) THEN 72141000 T 0141 + BEGIN % READ 72142000 T 0142 + IF SPOED THEN 72143000 T 0142 + BEGIN 72144000 T 0143 + FLAGHANDLE(CUP,IOAD. 72145000 T 0143 + ADDR,WORDS,IOCW); 72146000 T 0144 + SPOED ← FALSE; 72147000 T 0146 + END ELSE 72148000 T 0147 + BEGIN 72149000 T 0147 + READ(SPO(TUBA) 72150000 T 0147 + ,10,MESS[*]); 72151000 T 0148 + FLAGHANDLE(MESS,IOAD. 72152000 T 0153 + ADDR,WORDS,IOCW); 72153000 T 0154 + END 72154000 T 0156 + END ELSE 72155000 T 0156 + BEGIN % WRITE 72156000 T 0156 + FLAGHANDLE(MESS,IOAD.ADDR, 72157000 T 0156 + WORDS,IOCW); 72158000 T 0158 + EBCOUT(MESS,EBCTOBCL,WORDIV); 72159000 T 0159 + WORDS ← ENTIER(WORDS / .75); 72160000 T 0163 + WRITE(SPO(TUBA), 72161000 T 0165 + 10,MESS[*]); 72162000 T 0168 + END; 72163000 T 0171 + ELTIME ← T[TSKIP]; 72164000 T 0171 + METIME ← T[TSKIP + 1]; 72165000 T 0173 + END; 72166000 T 0175 + END; 72167000 T 0175 + BEGIN% BIDS 3 72168000 T 0176 + END; 72169000 T 0176 + BADUNIT;% 4 72170000 T 0176 + BADUNIT;% 5 72171000 T 0180 + BEGIN% LP OR PRINT 6 72172000 T 0184 + PRINTERS: 72172100 T 0184 + ERROR201; 72173000 T 0185 + WORDS ← PROTECT (IOAD , IOCW, RESULT); 72174000 T 0190 + IF BOOLEAN (IOCW.IOXBIT) % TRANSLATE 72175000 T 0192 + THEN BEGIN 72176000 T 0193 + FLAGHANDLE (MESS, IOAD.ADDR, WORDS, 72177000 T 0194 + IOCW); 72178000 T 0196 + IF BOOLEAN (IOCW.IOSBIT) % 8 BIT 72179000 T 0196 + THEN BEGIN 72180000 T 0197 + EBCOUT (MESS, EBCTOBCL, WORDIV); 72181000 T 0198 + WORDS ← ENTIER (WORDS/.75); 72182000 T 0202 + END; 72183000 T 0204 + END 72184000 T 0204 + ELSE IF NOT BOOLEAN (IOCW.IOIBIT) %MEMORY INHIBIT 72185000 T 0204 + THEN BEGIN 72186000 T 0207 + RESULT.RSLTDSC ← DESC ← 1; 72187000 T 0208 + ELTIME←200; METIME←0; GO AROUND; 72188000 T 0210 + END 72189000 T 0212 + ELSE BEGIN 72190000 T 0212 + LDIV ← (LMOD ← WORDS ) DIV 32; 72191000 T 0213 + LMOD ← LMOD MOD 32 - 1; 72192000 T 0215 + BLANK (MESS, LMOD, LDIV); 72193000 T 0216 + END; 72194000 T 0218 + SWFI ← MPXINFO.MPXSWFI; 72195000 T 0218 + IF SKIP ← IOCW.IOSKIP = 0 72196000 T 0219 + THEN BEGIN 72197000 T 0221 + WRITE (LINES[SWFI][NO], WORDS 72198000 T 0222 + , MESS [*]); 72199000 T 0224 + SKIP ← IOCW.IOSPAC; SPACLP ← TRUE; 72200000 T 0226 + METIME←METIME+(T[TSKIP+2]+T[TSKIP+3]× 72201000 T 0228 + (SKIP-1)); 72202000 T 0232 + WHILE SKIP > 0 72203000 T 0234 + DO BEGIN 72204000 T 0235 + WRITE (LINES [SWFI]); 72205000 T 0236 + SKIP ← SKIP - 1; 72206000 T 0240 + END; 72207000 T 0241 + END 72208000 T 0242 + ELSE BEGIN 72209000 T 0242 + WRITE (LINES[SWFI][SKIP], WORDS, 72210000 T 0242 + MESS [*]); 72211000 T 0245 + METIME←METIME+T[TSKIP+4]; 72212000 T 0247 + END; 72213000 T 0250 + ELTIME←T[TSKIP]; 72214000 T 0250 + METIME←METIME+T[TSKIP+1]; 72215000 T 0252 + AROUND: EVENTIME←MPXTIME(ELTIME,METIME,FUNCD.LUNIT); 72216000 T 0255 + END; 72217000 T 0258 + BEGIN% LP 7 72218000 T 0259 + GO PRINTERS; 72218100 T 0259 + END; 72219000 T 0259 + BADUNIT;% 8 72220000 T 0260 + BEGIN% CR 9 72221000 T 0264 + ERROR201; 72222000 T 0264 + IF IOCW.IOWBIT = 1 AND (IOCW.IOXBIT = 1 OR 72223000 T 0269 + IOCW.IOSBIT = 1) 72224000 T 0272 + THEN BEGIN 72225000 T 0273 + READ (CARD, MPXINFO.MPXBUFF,MESS[*])[CEOF]; 72226000 T 0274 +PRT(1036) = CEOF + RESULT.RSLTVY ← REAL (EXAMIN(NCR)= "←"); 72227000 T 0279 + RESULT.RSLTCC ← RESULT.RSLTVY; 72228000 T 0283 + WORDS ← PROTECT (IOAD , IOCW, RESULT); 72229000 T 0286 + FLAGHANDLE (MESS, IOAD.ADDR, WORDS, IOCW); 72230000 T 0288 + ELTIME←T[TSKIP]; 72231000 T 0290 + METIME←T[TSKIP+1]; 72232000 T 0292 + GO PUT; 72233000 T 0295 + END 72234000 T 0295 + ELSE BEGIN 72235000 T 0295 + RESULT.RSLTDSC ← 1; 72236000 T 0296 + ELTIME←200; METIME←0; 72237000 T 0298 + GO PUT; 72238000 T 0299 + END; 72239000 T 0300 + CEOF:RESULT.RSLTNRY ← 1; 72240000 T 0300 + ELTIME←200; METIME←0; 72241000 T 0301 + PUT: EVENTIME←MPXTIME(ELTIME,METIME,FUNCD.LUNIT); 72242000 T 0303 + END; 72243000 T 0306 + BEGIN% CP 10 72244000 T 0307 + END; 72245000 T 0307 + BADUNIT;% 11 72246000 T 0307 + BADUNIT;% 12 72247000 T 0311 + BEGIN% MT 13 72248000 T 0315 + ELTIME ← METIME ← 0; 72249000 T 0315 + SWFI ← MPXINFO.MPXSWFI; 72250000 T 0316 + CASE 0&IOCW[46:3:2] OF 72251000 T 0318 + BEGIN 72252000 T 0319 +PRT(1037) = *CASE STATEMENT DESCRIPTOR* + % % % % WRITES % % % % 72253000 T 0320 + IF BOOLEAN(IOCW.TM) THEN 72254000 T 0320 + BEGIN 72255000 T 0320 + WRITE(TAPES[SWFI],*,TMK); 72256000 T 0321 +PRT(1040) = *LIST, LABEL, OR SEGMENT DESCRIPTOR* + TIMEIT; 72257000 T 0333 + BUMPIT; 72258000 T 0339 + END ELSE 72259000 T 0343 + BEGIN 72260000 T 0343 + ERROR201; 72261000 T 0344 + WORDS ← PROTECT(IOAD,IOCW,RESULT) 72262000 T 0349 + ;TRANSLATE; 72263000 T 0350 + WRITE(TAPES[SWFI],WORDS,MESS[*]); 72264000 T 0363 + TIMEIT; 72265000 T 0366 + BUMPIT; 72266000 T 0373 + END; 72267000 T 0378 + % % REWIND OR ERASE % % 72268000 T 0378 + IF BOOLEAN(IOCW.IOBBIT) THEN 72269000 T 0378 + BEGIN 72270000 T 0379 + INTG ← MPX[0,FUNCD.LUNIT]; 72271000 T 0379 + ELTIME ← T[TSKIP]; 72272000 T 0382 + FOR JUNK←1 STEP 1 UNTIL INTG DO 72273000 T 0384 + BEGIN 72274000 T 0387 + READ REVERSE(TAPES 72275000 T 0387 + [SWFI],1,MESS[*]) 72276000 T 0387 + [EOF:PAR]; 72277000 T 0390 +PRT(1041) = EOF +PRT(1042) = PAR + IF NFLAG(MESS)=TMK THEN GO EOF; 72278000 T 0393 + GO TO EOF; 72279000 T 0397 + MPX[0,FUNCD.LUNIT] ← 72280000 T 0399 + MPX[0,FUNCD.LUNIT] -1; 72281000 T 0400 + METIME ← METIME + 72282000 T 0403 + T[TSKIP + 1]; 72283000 T 0403 + END; 72284000 T 0406 + RESULT.RSLTRW ← 1; 72285000 T 0408 + END ELSE 72286000 T 0410 + BEGIN TIMEIT END; 72287000 T 0410 + % % % % READS % % % % 72288000 T 0417 + BEGIN 72289000 T 0417 + ERROR201; 72290000 T 0417 + READS; 72291000 T 0422 + IF FALSE THEN 72292000 T 0456 + PAR: 72293000 T 0456 + BEGIN 72294000 T 0457 + RESULT.RSLTMA ← 1; 72295000 T 0457 + RESULT.RSLTCC ← 1; 72296000 T 0458 + RESULT.RSLTOF ← 1; 72297000 T 0460 + END; 72298000 T 0462 + WORDS ← PROTECT(IOAD,IOCW,RESULT); 72299000 T 0462 + FLAGHANDLE(MESS,IOAD.ADDR,WORDS,IOCW); 72300000 T 0464 + TIMEIT; 72301000 T 0466 + END; 72302000 T 0472 + % % % % SPACE % % % % 72303000 T 0473 + BEGIN 72304000 T 0473 + IF (INTG←IOCW.RECS) =0 THEN INTG←100; 72305000 T 0473 + FOR JUNK←1 STEP 1 UNTIL INTG DO 72306000 T 0476 + BEGIN 72307000 T 0478 + READS; 72308000 T 0478 + TIMEIT; 72309000 T 0512 + END; 72310000 T 0517 + END; 72311000 T 0520 + END; 72312000 T 0520 + START OF SEGMENT ********** 116 + 116 IS 4 LONG, NEXT SEG 115 + IF FALSE THEN 72313000 T 0520 + EOF: BEGIN 72314000 T 0520 + RESULT.RSLTVY ← 1; 72315000 T 0522 + RESULT.RSLTNRY← 1; 72316000 T 0523 + TIMEIT; 72317000 T 0525 + END; 72318000 T 0531 + EVENTIME ← MPXTIME(ELTIME,METIME,FUNCD.LUNIT); 72319000 T 0531 + END; 72320000 T 0533 + END; 72321000 T 0534 + START OF SEGMENT ********** 117 + 117 IS 14 LONG, NEXT SEG 115 + PUTRESULT (FUNCD.LUNIT, FUNCD.MPXFC, EVENTIME , RESULT); 72322000 T 0534 + OC: 72323000 T 0536 + END MULTIPLEXOR; 72324000 T 0537 + 115 IS 547 LONG, NEXT SEG 12 + PROCEDURE NEXTEVENT; 72325000 T 0935 +PRT(1043) = NEXTEVENT + BEGIN COMMENT NEXTEVENT WORRIES ABOUT INTERRUPT PRIORITIES AND SETS 72326000 T 0935 + APPROPRIATE INTERRUPTS. PRIORITY (HIGH TO LOW) IS 72327000 T 0935 + ALARM, SYLLABLE-DEPENDENT, CONTROL AND EXTERNAL. 72328000 T 0935 + SOME FUNCTIONS OF INTERRUPT CONTROL ARE HANDLED. 72329000 T 0935 + ; 72330000 T 0935 + IF ABORTTIME ≤ REALTIME 72331000 T 0935 + THEN BEGIN 72332000 T 0936 + END 72333000 T 0937 + ELSE IF IDLETIME ≤ REALTIME AND SDIS + GCIF = 0 72334000 T 0937 + 72335000 T 0940 + THEN BEGIN 72336000 T 0940 + IF INTTIMER ≤ REALTIME 72337000 T 0941 + THEN BEGIN 72338000 T 0941 + SETINTERRUPT (INTTIMI); 72338500 T 0942 + INTTIMER ← 2*36; 72339000 T 0943 + IDLETIME ← CURRENTT; 72339050 T 0947 + END 72339500 T 0948 + ELSE IF NOT IIHF 72340000 T 0948 + AND CURRENTT ≤ REALTIME 72340100 T 0950 + AND CURRENTT ≠ 0 72340200 T 0950 + THEN BEGIN 72341000 T 0951 + SETINTERRUPT (EXTINTI + CURRENTMPX); 72342000 T 0953 + CURRENTT ← 0; 72342500 T 0954 + IDLETIME ← INTTIMER; 72342600 T 0955 + END; 72343000 T 0955 + END; 72344000 T 0955 + END OF NEXT EVENT; 72345000 T 0955 + PROCEDURE SIMULATOR; 73000000 T 0957 +PRT(1044) = SIMULATOR + BEGIN COMMENT THIS IS THE PRINCIPAL DRIVER FOR THE SIMULATOR. ; 73001000 T 0957 + LABEL NDIN; 73002000 T 0957 + START OF SEGMENT ********** 118 + CASE DISKLOAD OF 73003000 T 0000 + BEGIN 73004000 T 0000 +PRT(1045) = *CASE STATEMENT DESCRIPTOR* + INITIALIZE; % ESPOL 73005000 T 0001 + CARDLOAD; % ALGOL 73006000 T 0002 + COBOLSIM; % COBOL 73007000 T 0003 + END; 73008000 T 0004 + START OF SEGMENT ********** 119 + 119 IS 3 LONG, NEXT SEG 118 + 73009000 T 0004 + 73010000 T 0004 + TBUF[16]:=MKABS(TBUF); 73010100 T 0004 + ABORTTIME ← INTTIMER ← 2*36; 73010200 T 0007 + IF DISKLOAD = 0 THEN INTTIMER ← 2*36 73010300 T 0011 + ELSE IDLETIME ← 2*36; 73010400 T 0013 + NCR ← MKABS (MESS); 73010500 T 0020 + D31 ← MONITORVALUE & MONITORMASK[28:38:10]; 73010600 T 0022 + DO BEGIN 73011000 T 0025 + IF INT ≠ 0 73012000 T 0025 + THEN INTERRUPTCONTROLLER 73013000 T 0025 + ELSE BEGIN 73014000 T 0026 + CONTROLSECTION; 73015000 T 0027 + TRACE; 73016000 T 0027 + END; 73017000 T 0028 + IF MONITORVALUE≠ MONITORMASKOLD 73017100 T 0028 + THEN D31 ← MONITORMASKOLD ← MONITORVALUE; 73017200 T 0028 + IF MULTIPLEX THEN MULTIPLEXOR; 73018000 T 0031 + NEXTEVENT; 73019000 T 0032 + IF TUBA.[9:9]=0 THEN ELSE 73020000 T 0033 + IF SPOED THEN ELSE 73021000 T 0035 + BEGIN 73022000 T 0036 + READ(SPO(TUBA,1),10,CUP[*])[NDIN]; 73023000 T 0037 +PRT(1046) = NDIN + SPOED ← TRUE; 73024000 T 0044 + NDIN: 73025000 T 0044 + END; 73026000 T 0045 + END UNTIL FALSE; 73027000 T 0045 + END SIMULATOR CONTROL; 73028000 T 0045 + 118 IS 50 LONG, NEXT SEG 12 + PROCEDURE TRACE; 74000000 T 0957 + BEGIN 74001000 T 0957 + LABEL EXIT; 74002000 T 0957 + START OF SEGMENT ********** 120 + STREAM PROCEDURE PBIS(SYLL,PBR,PIR,PSR,TANK); 74003000 T 0000 +PRT(1047) = PBIS + VALUE SYLL,PBR,PIR,PSR,TANK; 74004000 T 0000 + BEGIN 74005000 T 0000 + DI:=TANK; SI:=LOC SYLL;SI:=SI+4; DS:=4 CHR; DS:=4 LIT" "; 74006000 T 0000 + DS:=12 LIT ""PBR:PIR:PSR"; DS:=3 LIT ""= "; 74007000 T 0001 + 2(SI:=SI+4; 8(DS:=3 RESET; 3 BITS); DS:= LIT ":"); 74008000 T 0004 + SI:=SI+7; DS:=CHR; 2(DS:=39 LIT " "); 74009000 T 0008 + END OF PBIS; 74010000 T 0014 + REAL STREAM PROCEDURE OCTIZE(TAG1,WD1,TAG2,WD2,DBLE,TANK); 74011000 T 0014 +PRT(1050) = OCTIZE + VALUE TAG1,WD1,TAG2,WD2,DBLE,TANK; 74012000 T 0014 + BEGIN 74013000 T 0014 + DI:=TANK; SI:=LOC TAG1; 74014000 T 0015 + DBLE(SKIP 44 SB; DS:=3 RESET; 3 BITS; DS:=LIT " "; 74015000 T 0015 + DS:=3 RESET; 1 BITS; SKIP SB; 2 BITS; 74016000 T 0019 + 7(DS:=3 RESET; 3 BITS); DS:=LIT " "; 74017000 T 0024 + 8(DS:=3 RESET; 3 BITS); DS:=2 LIT " "); 74018000 T 0027 + OCTIZE:= DI; 74019000 T 0030 + END OF OCTIZE; 74020000 T 0031 + STREAM PROCEDURE BLANK(TANK); 74021000 T 0032 +PRT(1051) = BLANK + VALUE TANK; 74022000 T 0032 + BEGIN LOCAL T; 74023000 T 0032 + DI:=TANK; T:=DI; DS:=8 LIT " "; SI:=T; DS:=14 WDS; 74024000 T 0032 + END OF BLANK; 74025000 T 0034 + PROCEDURE TOS; 74026000 T 0034 +PRT(1052) = TOS + BEGIN 74027000 T 0034 + FORMAT TOSREG(X8,"AREG",X17,"XREG",X17,"BREG",X17,"YRE6"); 74028000 T 0034 + START OF SEGMENT ********** 121 + START OF SEGMENT ********** 122 +PRT(1053) = TOSREG + 122 IS 11 LONG, NEXT SEG 121 + BLANK(TANK); 74029000 T 0000 + WRITE(LP,TOSREG); 74030000 T 0001 + IF AROF THEN 74031000 T 0004 + TANK:=OCTIZE(AX,A,XX,X,2,TANK); 74032000 T 0004 + IF BROF THEN 74033000 T 0008 + TANK:=OCTIZE(BX,B,YX,Y,2,TANK+65541×(REAL(NOT AROF)).[47:1]); 74034000 T 0008 + PRINT; 74035000 T 0014 + END OF TOS; 74036000 T 0018 + 121 IS 20 LONG, NEXT SEG 120 + PROCEDURE REGISTER(TAGE,WORDE,FMTE); 74037000 T 0034 +PRT(1054) = REGISTER + VALUE TAGE,WORDE,FMTE; 74038000 T 0034 + REAL TAGE,WORDE,FMTE; 74039000 T 0034 + BEGIN 74040000 T 0034 + SWITCH FORMAT REGS:= 74041000 T 0034 + START OF SEGMENT ********** 123 + START OF SEGMENT ********** 124 +PRT(1055) = REGS + ("C = "), 74042000 T 0000 + ("P = "); 74043000 T 0000 + 124 IS 12 LONG, NEXT SEG 123 + REAL STREAM PROCEDURE SYLLABLIZE(PX,P,TANK); VALUE PX,P,TANK; 74044000 T 0000 +PRT(1056) = SYLLABLIZE + BEGIN 74045000 T 0000 + DI← TANK; SI← LOC PX; 74046000 T 0000 + SKIP 44 SB; DS← 3 RESET; 3 BITS; DS← LIT " "; 74047000 T 0000 + DS← 4 RESET; 1 BITS; SKIP SB; 1 BITS; 74048000 T 0003 + 2(DS← 3 RESET; 3 BITS); DS← LIT " "; 74049000 T 0008 + 5(DS←4 RESET; 2 BITS; 2(DS←3RESET; 3 BITS);DS←LIT" "); 74050000 T 0011 + END; 74051000 T 0017 + TANK:=TBUF[16]; 74052000 T 0018 + WRITE(LP[NO],REGS[FMTE]); 74053000 T 0020 + BLANK(TANK); 74054000 T 0024 + IF FMTE=0 THEN TANK←OCTIZE(TAGE,WORDE,0,0,1,TANK+1) ELSE 74055000 T 0025 + IF FMTE=1 AND PROF THEN TANK←SYLLABLIZE(TAGE,WORDE,TANK+1); 74056000 T 0030 + PRINT; 74057000 T 0036 + END OF REGISTER; 74058000 T 0040 + 123 IS 41 LONG, NEXT SEG 120 + STREAM PROCEDURE OCTAL(TANK,DPLAY,WRDS); 74059000 T 0034 +PRT(1057) = OCTAL + VALUE TANK,WRDS; 74060000 T 0034 + BEGIN 74061000 T 0034 + DI←TANK; SI←DPLAY; 74062000 T 0035 + WRDS(SI:=SI+5; 6(DS:= 3 RESET; 3 BITS); DS:=2 LIT " "; ); 74063000 T 0035 + END OF OCTAL; 74064000 T 0040 + PROCEDURE DISPLAY; 74065000 T 0040 +PRT(1060) = DISPLAY + BEGIN 74066000 T 0040 + FORMAT DREGS("DISPLAY REGISTERS 0 THROUGH ",I2," LL= ",I2); 74067000 T 0040 + START OF SEGMENT ********** 125 + START OF SEGMENT ********** 126 +PRT(1061) = DREGS + 126 IS 11 LONG, NEXT SEG 125 + DEFINE N=NDISPLAY#; 74068000 T 0000 + INTEGER I,LINES,NMOD15; 74069000 T 0000 +STACK(F+2) = I +STACK(F+3) = LINES +STACK(F+4) = NMOD15 + INTEGER DPLAID; 74070000 T 0000 +STACK(F+5) = DPLAID + TANK:=TBUF[16]; 74071000 T 0000 + IF N=0 THEN N:=DPLAID:=31; 74072000 T 0001 + WRITE(LP,DREGS,N-1,LL); 74073000 T 0003 +PRT(1062) = *LIST, LABEL, OR SEGMENT DESCRIPTOR* + LINES:= N DIV 15; 74074000 T 0014 + FOR I:=1 STEP 1 UNTIL LINES DO 74075000 T 0015 + BEGIN 74076000 T 0017 + BLANK(TANK); 74077000 T 0017 + OCTAL(TANK,D[(I-1)×15],15); 74078000 T 0018 + PRINT; 74079000 T 0021 + END; 74080000 T 0025 + IF (NMOD15:=N MOD 15)≠0 THEN 74081000 T 0027 + BEGIN 74082000 T 0029 + BLANK(TANK); 74083000 T 0029 + OCTAL(TANK,D[LINES×15], NMOD15 ); 74084000 T 0031 + PRINT; 74085000 T 0033 + END; 74086000 T 0037 + IF DPLAID≠0 THEN N:=0; 74087000 T 0037 + END OF DISPLAY; 74088000 T 0039 + 125 IS 42 LONG, NEXT SEG 120 + OWN BOOLEAN ASTERICKS; 74089000 T 0040 +PRT(1063) = ASTERICKS + PROCEDURE STACK; 74090000 T 0040 +PRT(1064) = STACK + BEGIN 74091000 T 0040 + BOOLEAN STREAM PROCEDURE NOTZERO(ADDR); VALUE ADDR; 74092000 T 0040 + START OF SEGMENT ********** 127 +PRT(1065) = NOTZERO + BEGIN LOCAL L1,L2,L3; 74093000 T 0000 + DI:=LOC L3; DS:=21 LIT"0 OOOOOOOO 00000000 "; SI:=ADDR; 74094000 T 0000 + 4(DI:=LOC L3;SI:=SI+1; DI:=DI+1; 74095000 T 0003 + IF 20 SC≠DC THEN BEGIN TALLY:=1; JUMP OUT END); 74095100 T 0004 + NOTZERO:=TALLY; 74096000 T 0007 + END OF NOTZERO; 74097000 T 0007 + STREAM PROCEDURE STARS(ADDR); VALUE ADDR; 74098000 T 0008 +PRT(1066) = STARS + BEGIN LOCAL T; 74099000 T 0008 + DI:=ADDR; DS:=21 LIT "* ******** ******** "; 74100000 T 0009 + SI:=ADDR; 3(DS:=21 CHR); 74101000 T 0012 + END OF STARS; 74102000 T 0013 + FORMAT STACKS("STACK CONTENTS WORD F TO F+",I6,X4,"S= ",O, 74103000 T 0013 + START OF SEGMENT ********** 128 +PRT(1067) = STACKS + " F= ",O," BOSR= ",O," LOSR= ",O); 74104000 T 0013 + 128 IS 20 LONG, NEXT SEG 127 + DEFINE N=NSTACK#; 74105000 T 0013 + REAL T,T1; INTEGER I,LINES,J; 74106000 T 0013 +STACK(F+2) = T +STACK(F+3) = T1 +STACK(F+4) = I +STACK(F+5) = LINES +STACK(F+6) = J + INTEGER ISTACK; 74107000 T 0013 +STACK(F+7) = ISTACK + STREAM PROCEDURE OCTL(A,B,C,D,E); VALUE A,B,C,D,E; 74108000 T 0013 +PRT(1070) = OCTL + BEGIN DI←A; SI←LOC B; 4(SI←SI+4; 8(DS←3RESET; 3 BITS))END; 74109000 T 0013 + TANK:=TBUF[16]; 74110000 T 0018 + IF N=0 THEN N:=ISTACK:= S-F+1; 74111000 T 0020 + OCTL(TANK,S,F,BOSR,LOSR); 74112000 T 0023 + WRITE(LP,STACKS,N-1,TBUF[0],TBUF[1],TBUF[2],TBUF[3]); 74113000 T 0025 +PRT(1071) = *LIST, LABEL, OR SEGMENT DESCRIPTOR* + LINES:=N DIV 4; 74114000 T 0041 + FOR I:=1 STEP 1 UNTIL LINES DO 74115000 T 0042 + BEGIN 74116000 T 0044 + TANK:= TBUF[16]; 74117000 T 0044 + BLANK(TANK); 74118000 T 0045 + FOR J:=0 STEP 1 UNTIL 3 DO 74119000 T 0046 + BEGIN 74120000 T 0047 + MOVE(M[(F+J)+(I-1)×4],T); 74121000 T 0047 + TANK:=OCTIZE(T1,T,0,0,1,TANK); 74122000 T 0053 + END; 74123000 T 0056 + IF NOTZERO(TBUF[16]) THEN 74124000 T 0058 + BEGIN ASTERICKS:=FALSE; PRINT END ELSE 74125000 T 0061 + IF NOT ASTERICKS THEN 74126000 T 0066 + BEGIN STARS(TBUF[16]); PRINT; 74127000 T 0068 + ASTERICKS:=TRUE; WRITE(LP); 74128000 T 0074 + END; 74129000 T 0079 + END; 74130000 T 0079 + IF (I:=N MOD 4)≠0 THEN 74131000 T 0081 + BEGIN 74132000 T 0083 + TANK:= TBUF[16]; 74133000 T 0083 + BLANK(TANK); 74134000 T 0084 + FOR J:=1 STEP 1 UNTIL I DO 74135000 T 0086 + BEGIN 74136000 T 0087 + MOVE(M[(F+(J-1))+ LINES×4],T); 74137000 T 0087 + TANK:=OCTIZE(T1,T,0,0,1,TANK); 74138000 T 0093 + END; 74139000 T 0096 + PRINT; 74140000 T 0098 + END; 74141000 T 0102 + IF ISTACK≠0 THEN N:=0; 74142000 T 0102 + END OF STACK; 74143000 T 0104 + 127 IS 108 LONG, NEXT SEG 120 + LABEL NONE; 74144000 T 0040 + FORMAT TOGS ( X43,"VARF = ",I1," , LEEF = ",I1," , TEEF = ",I1, 74145000 T 0040 + START OF SEGMENT ********** 129 +PRT(1072) = TOGS + " , SEEE = ",I1," , NCSE = ",I1," UPDF S ",I1 74146000 T 0040 + ); 74147000 T 0040 + 129 IS 22 LONG, NEXT SEG 120 + INTEGER REALTI; 74148000 T 0040 +STACK(F+2) = REALTI + MONITOR LP (REALTI); 74149000 T 0040 + NONE: 74150000 T 0040 + ASTERICKS:=FALSE; 74151000 T 0041 + TANK:=TBUF[16]; 74152000 T 0042 + IF TRACEWORD = 0 OR ( TRACEWORD > 100 AND TRACTER=0) THEN 74153000 T 0043 + GO TO EXIT; 74154000 T 0045 + HEADING; 74155000 T 0046 + IF TS1=0 THEN JUNK:=MNEMONIC[0,T] 74156000 T 0051 + ELSE IF VARF THEN JUNK:=MNEMONIC[1,T] 74157000 T 0053 + ELSE JUNK← MNEMONIC[2,T]; 74158000 T 0056 + WRITE(LP[NO],TOGS,REAL(VARF),REAL(LEEF),REAL(TEEF),REAL(SEEF), 74159000 T 0059 +PRT(1073) = *LIST, LABEL, OR SEGMENT DESCRIPTOR* + REAL(NCSF),REAL(UPDF)); 74160000 T 0071 + PBIS(JUNK,PBR,PIR,PSR,TANK); 74161000 T 0078 + PRINT; 74162000 T 0080 + REALTI ← REALTIME; 74163000 T 0084 +PRT(1074) = DUMP + TANK:= TBUF[16]; 74164000 T 0091 + IF (JUNK←TRACEWORD) ≥ 100 THEN 74165000 T 0092 + JUNK ← TRACTER; 74166000 T 0093 + CASE JUNK OF 74167000 T 0094 + BEGIN 74168000 T 0095 +PRT(1075) = *CASE STATEMENT DESCRIPTOR* + ; 74169000 T 0095 + TOS; % TRACE OF A,X,B,Y REGISTERS 74170000 T 0095 + REGISTER(CX,C,0); % TRACE OF C REGISTER 74171000 T 0097 + REGISTER(PX,P,1); % TRACE OF P REGISTER 74172000 T 0099 + DISPLAY; % TRACE 0F N DISPLAY REGISTERS 74173000 T 0101 + STACK; % TRACE 0F N WORDS IN THE STACK 74174000 T 0102 + BEGIN TOS; REGISTER(CX,C,0) END; % 6 74175000 T 0103 + BEGIN TOS; REGISTER(PX,P,1) END; % 7 74176000 T 0106 + BEGIN TOS; DISPLAY END; % 8 74177000 T 0109 + BEGIN TOS; STACK END; % 9 74178000 T 0111 + BEGIN TOS; REGISTER(CX,C,0); REGISTER(PX,P,1) END; % 10 74179000 T 0113 + BEGIN TOS; REGISTER(CX,C,0); DISPLAY END; % 11 74180000 T 0117 + BEGIN TOS; REGISTER(CX,C,0); STACK END; % 12 74181000 T 0120 + BEGIN TOS; REGISTER(PX,P,1); DISPLAY END; % 13 74182000 T 0124 + BEGIN TOS; REGISTER(PX,P,1); STACK END; % 14 74183000 T 0127 + BEGIN TOS; DISPLAY; STACK END; % 15 74184000 T 0131 + BEGIN TOS; REGISTER(CX,C,0); REGISTER(PX,P,1); DISPLAY END;%16 74185000 T 0134 + BEGIN TOS; REGISTER(CX,C,0); REGISTER(PX,P,1); STACK END; % 17 74186000 T 0139 + BEGIN TOS; REGISTER(CX,C,0); REGISTER(PX,P,1); 74187000 T 0144 + DISPLAY;STACK; 74188000 T 0147 + END; % 18 74189000 T 0149 + MEMDUMP; % 19 74190000 T 0149 + BEGIN LABEL DUMPER; %%%%%%%%%%%%%%% 74191000 T 0150 +PRT(1076) = *SEGMENT DESCRIPTOR* + START OF SEGMENT ********** 130 + DUMP LP (MPX, FIRSTEVENT, LASTEVENT, FIRSTEVENTI, LASTEVENTI, 74192000 T 0000 +PRT(1077) = *LIST, LABEL, OR SEGMENT DESCRIPTOR* + CURRENTT,UNITAVAILTIME,EVENTS,CURRENTMPX,MPXOPS, 74193000 T 0031 + BUFRMAX)DUMPER:1; 74194000 T 0059 +STACK(F+3) = *LABEL DESCRIPTOR* + DUMPER: END; 74195000 T 0065 +PRT(1100) = *SEGMENT DESCRIPTOR* + 130 IS 70 LONG, NEXT SEG 120 + END; 74196000 T 0152 + START OF SEGMENT ********** 131 + 131 IS 21 LONG, NEXT SEG 120 + WRITE(LP); 74197000 T 0152 + EXIT: 74198000 T 0156 + END OF TRACE; 74199000 T 0157 + 120 IS 160 LONG, NEXT SEG 12 + PROCEDURE MEMDUMP; 75000000 T 0957 + BEGIN 75001000 T 0957 + INTEGER ADDRESS,I,ROW,J,WRDS,TANK; 75002000 T 0957 + START OF SEGMENT ********** 132 +STACK(F+2) = ADDRESS +STACK(F+3) = I +STACK(F+4) = ROW +STACK(F+5) = J +STACK(F+6) = WRDS +STACK(F+7) = TANK + INTEGER SAVETRACEWORD,SAVEN,SAVENN; 75003000 T 0000 +STACK(F+10) = SAVETRACEWORD +STACK(F+11) = SAVEN +STACK(F+12) = SAVENN + BOOLEAN ASTERICKS; 75004000 T 0000 +STACK(F+13) = ASTERICKS + ARRAY MD[0:9]; 75005000 T 0000 +STACK(F+14) = MD + ARRAY XMD[0:9]; 75005100 T 0001 +STACK(F+15) = XMD + DEFINE N= NDISPLAY#, NN=NSTACK#; 75006000 T 0003 + STREAM PROCEDURE OCTIZE(LOCM,ADDR,WRDS,BLK,TANK); 75007000 T 0003 +PRT(1101) = OCTIZE + VALUE LOCM,WRDS,BLK,TANK; 75008000 T 0003 + BEGIN 75009000 T 0003 + DI:=TANK; DS:=4 LIT " "; SI:=LOC LOCM; SI:=SI+4; 75010000 T 0004 + 8(DS:=3 RESET; 3 BITS); DS:=3 LIT " "; 75011000 T 0005 + SI:=ADDR; 75012000 T 0009 + WRDS(SKIP 44 SB; DS:=3 RESET; 3 BITS; DS:=LIT " "; 75013000 T 0009 + DS:=3 RESET; 1 BITS; SKIP SB; 2 BITS; 75014000 T 0013 + 7(DS:=3 RESET; 3 BITS); DS:=LIT " "; 75015000 T 0017 + 8(DS:=3 RESET; 3 BITS); DS:=2 LIT " "); 75016000 T 0021 + BLK(2(DS:=42 LIT " " )); 75017000 T 0024 + END OF OCTIZE; 75018000 T 0031 + BOOLEAN STREAM PROCEDURE NOTSAME(XMD,MD,WRDS); 75019000 T 0032 +PRT(1102) = NOTSAME + VALUE WRDS; 75020000 T 0032 + BEGIN LOCAL RPF; 75021000 T 0032 + SI ← XMD; DI ← MD; 75022000 T 0032 + WRDS(IF 8 SC≠DC THEN BEGIN TALLY←1; JUMP OUT END); 75022100 T 0032 + NOTSAME← TALLY; RPF ← TALLY; 75023000 T 0036 + RPF(SI←MD; DI←XMD; DS←WRDS WDS); 75024000 T 0036 + END; 75027000 T 0038 + STREAM PROCEDURE STARS(LOCM,TANK); 75028000 T 0039 +PRT(1103) = STARS + VALUE LOCM,TANK; 75029000 T 0039 + BEGIN 75030000 T 0039 + LOCAL T; 75031000 T 0040 + DI:=TANK; DS:=4 LIT " "; SI:=LOC LOCM; SI:=SI+4; 75032000 T 0040 + 8(DS:=3 RESET; 3 BITS); DS:=3 LIT " "; 75033000 T 0041 + T:=DI; DS:=21 LIT "* ******** ******** "; 75034000 T 0045 + SI:=T; 4(DS:=21 CHR); 75035000 T 0048 + END OF STARS; 75036000 T 0049 + STREAM PROCEDURE MOVIT(HERE,THERE,WORDS); 75037000 T 0049 +PRT(1104) = MOVIT + VALUE WORDS; 75038000 T 0049 + BEGIN 75039000 T 0049 + SI:=HERE; DI:=THERE; SI:=SI+8; 75040000 T 0050 + WORDS(DS:=WDS; SI:=SI+8; DI:=DI+8); 75041000 T 0050 + SI:=HERE; DI:=THERE; DI:=DI+8; 75042000 T 0052 + WORDS(DS:=WDS; SI:=SI+8; DI:=DI+8;); 75043000 T 0053 + END OF MOVIT; 75044000 T 0055 + SAVETRACEWORD:=TRACEWORD; SAVEN:=N; SAVENN:=NN; 75045000 T 0055 + TRACEWORD:=18; N:=32; NN:=99; 75046000 T 0058 + TRACE; 75047000 T 0060 + ADDRESS:=0; ASTERICKS:=FALSE; 75048000 T 0061 + TANK:=TBUF[16]; 75049000 T 0062 + FOR I ← 0 STEP 256 UNTIL (MEMMODS + 1) DIV 2 - 1 DO 75050000 T 0063 + BEGIN 75051000 T 0068 + FOR J:=0 STEP 5 UNTIL 255 DO 75052000 T 0068 + BEGIN 75053000 T 0070 + WRDS:= IF J=255 THEN 1 ELSE 5; 75054000 T 0070 + MOVIT(M[I+J],MD, WRDS); 75055000 T 0072 + IF NOTSAME(XMD,MD,2×WRDS)THEN 75056000 T 0078 + BEGIN 75057000 T 0081 + OCTIZE(ADDRESS, MD ,WRDS,WRDS≠5,TANK); 75058000 T 0081 + PRINT; 75059000 T 0084 + ASTERICKS:=FALSE; 75060000 T 0088 + END ELSE 75061000 T 0089 + IF NOT ASTERICKS THEN 75062000 T 0089 + BEGIN 75063000 T 0090 + STARS(ADDRESS,TANK); 75064000 T 0091 + PRINT; 75065000 T 0092 + ASTERICKS:=TRUE; 75066000 T 0096 + WRITE(LP); 75067000 T 0097 + END; 75068000 T 0101 + ADDRESS:=ADDRESS+WRDS; 75069000 T 0101 + END; 75070000 T 0102 + IF NOT ASTERICKS THEN 75071000 T 0105 + WRITE(LP); 75072000 T 0105 + END; 75073000 T 0110 + TRACEWORD:=SAVETRACEWORD; N:=SAVEN; NN:=SAVENN; 75074000 T 0110 + END OF MEMDUMP; 75075000 T 0112 + 132 IS 119 LONG, NEXT SEG 12 + PROCEDURE ERROR(ERRNUM); VALUE ERRNUM; REAL ERRNUM; 76000000 T 0957 + BEGIN 76001000 T 0957 + FORMAT ERR("ERROR # ",I3,X2,107("X")); 76002000 T 0957 + START OF SEGMENT ********** 133 + START OF SEGMENT ********** 134 +PRT(1105) = ERR + 134 IS 10 LONG, NEXT SEG 133 + TRACE; 76003000 T 0000 + WRITE(LP,ERR,ERRNUM); 76004000 T 0000 +PRT(1106) = *LIST, LABEL, OR SEGMENT DESCRIPTOR* + END ERROR; 76005000 T 0008 + 133 IS 9 LONG, NEXT SEG 12 + PROCEDURE HEADINGLINE (LP); FILE LP; 77000000 T 0957 + BEGIN 77001000 T 0957 + ARRAY DAYS[0:6], MONTHS[0:23]; 77002000 T 0957 + START OF SEGMENT ********** 135 +STACK(F+2) = DAYS +STACK(F+3) = MONTHS + INTEGER I,Q,P,DAY,MONTH,DATE,YEAR,HOURS,MINUTES; 77003000 T 0003 +STACK(F+4) = I +STACK(F+5) = Q +STACK(F+6) = P +STACK(F+7) = DAY +STACK(F+10) = MONTH +STACK(F+11) = DATE +STACK(F+12) = YEAR +STACK(F+13) = HOURS +STACK(F+14) = MINUTES + FORMAT CONF (X14, 77004000 T 0003 + START OF SEGMENT ********** 136 +PRT(1107) = CONF + " CLOCK RATE NUMBER OF OPERATIONS/MPX ", 77005000 T 0003 + " MEMORY SPEED MEMORY SIZE",/, X14, 77006000 T 0003 + " (MEGACYCLES) MULTIPLEXORS A B ", 77007000 T 0003 + "(MICROSECONDS) (16K MODULES)", 77008000 T 0003 + /, X14, I9, X3, I10, I11, I7, X11, 77009000 T 0003 + F3.1, X9 , I3,/), 77010000 T 0003 + CABH (X14, 77011000 T 0003 + " LOGICAL UNIT HARDWARE TYPE MULTIPLEXOR", 77012000 T 0003 + " BUFFER LENGTH WRITE LOCK-OUT INTERNAL NAME", /), 77013000 T 0003 + CABF (X14, I9, I11," = ", A4, X7, A6, X3, 77014000 T 0003 + I10, X10, A5, X12, A6), 77015000 T 0003 + FILF (/, X14, "SOURCE FILE IS: ", A1, A6, "/", A1, A6, "."), 77015100 T 0003 + CABT (//////); 77016000 T 0003 + 136 IS 104 LONG, NEXT SEG 135 + LIST CONL 77017000 T 0003 + (PROCCLOCK, MPXQUAN, MPXAOPS, IF MPXQUAN=1 THEN 0 ELSE MPXBOPS, 77018000 T 0003 +PRT(1110) = *LIST, LABEL, OR SEGMENT DESCRIPTOR* + MEMTIME/10,(MEMMODS+1)DIV 2*15 ); 77019000 T 0011 +STACK(F+15) = CONL + LIST FILEL (MULFILID.[6:6], MULFILID.[12:36], FILID.[6:6], 77019100 T 0023 +PRT(1111) = *LIST, LABEL, OR SEGMENT DESCRIPTOR* + FILID.[12:36]); 77019200 T 0033 +STACK(F+16) = FILEL + ARRAY HT [0:133], NAMES [0:3, 0:13]; 77020000 T 0038 +STACK(F+17) = HT +STACK(F+20) = NAMES + ALPHA ALF; 77021000 T 0042 +STACK(F+21) = ALF + REAL MPXI; 77022000 T 0042 +STACK(F+22) = MPXI + LABEL OWT; 77023000 T 0042 + FORMAT HEADFMT(X25,"BURROUGHS B-6500 SIMULATOR " 77024000 T 0042 + START OF SEGMENT ********** 137 +PRT(1112) = HEADFMT + X05,A6,"DAY, ",A3,A6,I3,", ",I4, 77025000 T 0042 + ", ",I2,":",I2,X1,"M."//); 77026000 T 0042 + 137 IS 25 LONG, NEXT SEG 135 + PRINTERNOTYETOPENED←FALSE; 77027000 T 0042 + FILL DAYS[*] WITH 77028000 T 0043 + " SUN"," MON"," TUES","WEDNES"," THURS"," FRI", 77029000 T 0043 + START OF SEGMENT ********** 138 + " SATUR"; 77030000 T 0045 + 138 IS 7 LONG, NEXT SEG 135 + FILL MONTHS[*] WITH 77031000 T 0045 + " J","ANUARY"," FE","BRUARY"," "," MARCH", 77032000 T 0045 + START OF SEGMENT ********** 139 + " "," APRIL"," "," MAY"," "," JUNE", 77033000 T 0046 + " "," JULY"," ","AUGUST"," SEP","TEMBER", 77034000 T 0046 + " O","CTOBER"," NO","VEMBER"," DE","CEMBER"; 77035000 T 0046 + 139 IS 24 LONG, NEXT SEG 135 + I←STARTDATE; 77036000 T 0046 + DATE←I.[30:6]×100+I.[36:6]×10+I.[42:6]; 77037000 T 0047 + YEAR←1900+I.[18:6]×10+I.[24:6]; 77038000 T 0051 + FOR I←31,IF YEAR MOD 4 = 0 THEN 29 ELSE 28,31,30,31,30, 77039000 T 0055 + 31,31,30,31,30 DO 77040000 T 0069 + IF DATE≤I THEN GO OWT 77041000 T 0080 +STACK(F+23) = *TEMPORARY STORAGE* + ELSE BEGIN DATE←DATE-I; MONTH←MONTH+1; END; 77042000 T 0080 + OWT: I←ETIME; 77043000 T 0086 + HOURS←I DIV (60×60×60); 77044000 T 0086 + MINUTES←(I DIV (60×60)) MOD 60; 77045000 T 0089 + IF MONTH<2 THEN BEGIN Q←MONTH+11; P←YEAR-1900-1; END 77046000 T 0091 + ELSE BEGIN Q←MONTH- 1; P←YEAR-1900 ; END; 77047000 T 0095 + DAY←((Q×26-2) DIV 10+DATE+P+P.[36:10]+1) MOD 7; 77048000 T 0099 + WRITE(LP,HEADFMT,DAYS[DAY], 77049000 T 0104 +PRT(1113) = *LIST, LABEL, OR SEGMENT DESCRIPTOR* + MONTHS[MONTH×2],MONTHS[MONTH×2+1],DATE,YEAR, 77050000 T 0111 + I←HOURS MOD 12, MINUTES, 77051000 T 0118 + IF HOURS>12 THEN "P" ELSE "A"); 77052000 T 0122 + FILL HT [*] WITH "NONE", "DISK", "SPO ", "AIDS", "NONE","NONE", 77053000 T 0129 + START OF SEGMENT ********** 140 + "LP ","LP ", "NONE", "CR ", "CP ", 0,0,"TAPE"; 77054000 T 0131 + 140 IS 14 LONG, NEXT SEG 135 + WRITE (LP, CONF, CONL); 77055000 T 0131 + WRITE (LP, CABH); 77056000 T 0134 + FILL NAMES [0, *] WITH 77057000 T 0137 + "NONE ","DISKA ","SPO ","AIDS ","NONE ","NONE " , 77058000 T 0138 + START OF SEGMENT ********** 141 + "LP ","LP ","NONE ","CARD ","PUNCH ",0,0,"TAPEA "; 77059000 T 0139 + FILL NAMES [1, *] WITH 77060000 T 0139 + 141 IS 14 LONG, NEXT SEG 135 + 0,"DISKB ",0,0,0,0,"SIMLP ","SIMLP ",0,0,0,0,0,"TAPEB "; 77061000 T 0140 + START OF SEGMENT ********** 142 + 142 IS 14 LONG, NEXT SEG 135 + FILL NAMES [2, *] WITH 0,"DISKC ",0,0,0,0,0,0,0,0,0, 77062000 T 0141 + START OF SEGMENT ********** 143 + 0,0,"TAPEC "; 77063000 T 0143 + 143 IS 14 LONG, NEXT SEG 135 + FILL NAMES [3, *] WITH 0,"DISKD ",0,0,0,0,0,0,0,0,0, 77064000 T 0143 + START OF SEGMENT ********** 144 + 0,0,"TAPED "; 77065000 T 0145 + 144 IS 14 LONG, NEXT SEG 135 + FOR I ← 1, 2 77066000 T 0145 + DO BEGIN 77067000 T 0147 +STACK(F+24) = *TEMPORARY STORAGE* + ALF ← IF I = 1 THEN "1 = A" ELSE "2 = B"; 77068000 T 0150 + FOR Q ← 0 STEP 1 UNTIL 31 77069000 T 0152 + DO IF MPXI ← MPX [I, Q] ≠ 0 77070000 T 0152 + THEN BEGIN 77071000 T 0157 + P ← MPXI.MPXHDWE; 77072000 T 0158 + WRITE (LP, CABF, Q, P, HT [P], ALF, 77073000 T 0160 +PRT(1114) = *LIST, LABEL, OR SEGMENT DESCRIPTOR* + MPXI.MPXBUFF, 77074000 T 0168 + IF P ≠ 13 THEN " N/A " 77075000 T 0171 + ELSE IF MPXI.MPXWLO = 1 77076000 T 0173 + THEN "TRUE " ELSE "FALSE", 77077000 T 0174 + NAMES [MPXI.MPXSWFI, P]); 77078000 T 0181 + END; 77079000 T 0186 + END; 77080000 T 0188 + WRITE (LP, FILF, FILEL); 77080100 T 0189 + WRITE (LP, CABT); 77081000 T 0192 + END HEADINGLINE; 77082000 T 0195 + 135 IS 204 LONG, NEXT SEG 12 + FILL MNEMONIC[0,*] WITH 78000000 T 0957 + "VALC","VALC","VALC","VALC","VALC","VALC","VALC","VALC", 78001000 T 0957 + START OF SEGMENT ********** 145 + "VALC","VALC","VALC","VALC","VALC","VALC","VALC","VALC", 78002000 T 0959 + "VALC","VALC","VALC","VALC","VALC","VALC","VALC","VALC", 78003000 T 0959 + "VALC","VALC","VALC","VALC","VALC","VALC","VALC","VALC", 78004000 T 0959 + "VALC","VALC","VALC","VALC","VALC","VALC","VALC","VALC", 78005000 T 0959 + "VALC","VALC","VALC","VALC","VALC","VALC","VALC","VALC", 78006000 T 0959 + "VALC","VALC","VALC","VALC","VALC","VALC","VALC","VALC", 78007000 T 0959 + "VALC","VALC","VALC","VALC","VALC","VALC","VALC","VALC", 78008000 T 0959 + "NAMC","NAMC","NAMC","NAMC","NAMC","NAMC","NAMC","NAMC", 78009000 T 0959 + "NAMC","NAMC","NAMC","NAMC","NAMC","NAMC","NAMC","NAMC", 78010000 T 0959 + "NAMC","NAMC","NAMC","NAMC","NAMC","NAMC","NAMC","NAMC", 78011000 T 0959 + "NAMC","NAMC","NAMC","NAMC","NAMC","NAMC","NAMC","NAMC", 78012000 T 0959 + "NAMC","NAMC","NAMC","NAMC","NAMC","NAMC","NAMC","NAMC", 78013000 T 0959 + "NAMC","NAMC","NAMC","NAMC","NAMC","NAMC","NAMC","NAMC", 78014000 T 0959 + "NAMC","NAMC","NAMC","NAMC","NAMC","NAMC","NAMC","NAMC", 78015000 T 0959 + "NAMC","NAMC","NAMC","NAMC","NAMC","NAMC","NAMC","NAMC", 78016000 T 0959 + "ADD ","SUBT","MULT","DIVD","IDIV","RDIV","NTIA","NTGR", 78017000 T 0959 + "LESS","GREQ","GRTR","LSEQ","EQUL","NEQL","CHSN","MULX", 78018000 T 0959 + "LAND","LOR ","LNOT","LEQV","SAME","VARI","BSET","DBST", 78019000 T 0959 + "FLTR","DFTR","ISOL","DISO","INSR","DINS","BRST","DBRS", 78020000 T 0959 + "BRFL","BRTR","BRUN","EXIT","STBR","NXLN","INDX","RETN", 78021000 T 0959 + "DBFL","DBTR","DBUN","ENTR","EVAL","NXLV","MKST","STFF", 78022000 T 0959 + "ZERO","ONE ","LT8 ","LT16","PUSH","DLET","EXCH","DUPL", 78023000 T 0959 + "STOD","STON","OVRD","OVRN","XXXX","LOAD","LT48","MPCW", 78024000 T 0959 + "SCLF","DSLF","SCRT","DSRT","SCRS","DSRS","SCRF","DSRF", 78025000 T 0959 + "SCRR","DSRR","ICVD","ICVU","SNGT","SNGL","XTND","IMKS", 78026000 T 0959 + "TEED","PACD","EXSD","TWSD","TWOD","SISO","SXSN","ROFF", 78027000 T 0959 + "TEEU","PACU","EXSU","TWSU","TWOU","EXPU","RTFF","HALT", 78028000 T 0959 + "TLSD","TGED","TGTD","TLED","TEQD","TNED","TUND","XXXX", 78029000 T 0959 + "TLSU","TGEU","TGTU","TLEU","TEQU","TNEU","TUNU","XXXX", 78030000 T 0959 + "CLSD","CGED","CGTD","CLED","CEQD","CNED","XXXX","XXXX", 78031000 T 0959 + "CLSU","CGEU","CGTU","CLEU","CEQU","CNEU","NOOP","NVLD"; 78032000 T 0959 + 145 IS 256 LONG, NEXT SEG 12 + FILL MNEMONIC[1,*] WITH 78033000 T 0959 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78034000 T 0959 + START OF SEGMENT ********** 146 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78035000 T 0961 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78036000 T 0961 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78037000 T 0961 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78038000 T 0961 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78039000 T 0961 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78040000 T 0961 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78041000 T 0961 + "XXXX","XXXX","JOIN","SPLT","IDLE","SINT","EEXI","DEXI", 78042000 T 0961 + "XXXX","XXXX","SCNI","SCNO","XXXX","XXXX","WHOI","HEYU", 78043000 T 0961 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78044000 T 0961 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78045000 T 0961 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78046000 T 0961 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78047000 T 0961 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78048000 T 0961 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78049000 T 0961 + "XXXX","XXXX","XXXX","XXXX","XXXX","OCRX","XXXX","XXXX", 78050000 T 0961 + "XXXX","XXXX","XXXX","LOG2","XXXX","XXXX","XXXX","XXXX", 78051000 T 0961 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78052000 T 0961 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78053000 T 0961 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78054000 T 0961 + "XXXX","XXXX","XXXX","XXXX","XXXX","IRWL","PCWL","MVST", 78055000 T 0961 + "XXXX","XXXX","XXXX","XXXX","STAG","RTAG","RSUP","RSON", 78056000 T 0961 + "RPRR","SPRR","RDLK","CBON","LODT","LLLU","SRCH","XXXX", 78057000 T 0961 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78058000 T 0961 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78059000 T 0961 + "USND","UABD","TWFD","TWTD","SWFD","SWTD","XXXX","TRNS", 78060000 T 0961 + "USNU","UABU","TWFU","TWTU","SWFU","SWTU","XXXX","HALT", 78061000 T 0961 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78062000 T 0961 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78063000 T 0961 + "SLSD","SGED","SGTD","SLED","SEQD","SNED","XXXX","XXXX", 78064000 T 0961 + "SLSU","SGEU","SGTU","SLEU","SEQU","SNEU","NOOP","NVLD"; 78065000 T 0961 + 146 IS 256 LONG, NEXT SEG 12 + FILL MNEMONIC[2,*] WITH 78066000 T 0961 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78067000 T 0961 + START OF SEGMENT ********** 147 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78068000 T 0963 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78069000 T 0963 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78070000 T 0963 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78071000 T 0963 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78072000 T 0963 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78073000 T 0963 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78074000 T 0963 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78075000 T 0963 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78076000 T 0963 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78077000 T 0963 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78078000 T 0963 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78079000 T 0963 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78080000 T 0963 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78081000 T 0963 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78082000 T 0963 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78083000 T 0963 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78084000 T 0963 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78085000 T 0963 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78086000 T 0963 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78087000 T 0963 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78088000 T 0963 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78089000 T 0963 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78090000 T 0963 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78091000 T 0963 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78092000 T 0963 + "MINS","MFLT","SFSC","SRSC","RSTF","ENDF","MVNU","MCHR", 78093000 T 0963 + "INOP","INSG","SFDC","SRDC","INSU","INSC","ENDE","HALT", 78094000 T 0963 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78095000 T 0963 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78096000 T 0963 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","XXXX", 78097000 T 0963 + "XXXX","XXXX","XXXX","XXXX","XXXX","XXXX","NOOP","NVLD"; 78098000 T 0963 + 147 IS 256 LONG, NEXT SEG 12 + FILL DELTAMASK[*] WITH 78099000 T 0963 + 8191,8191, % 0 AND 1 78100000 T 0963 + START OF SEGMENT ********** 148 + 4095,4095, % 2 AND 3 78101000 T 0964 + 2047,2047,2047,2047, % 4 THRU 7 78102000 T 0964 + 1023,1023,1023,1023,1023,1023,1023,1023, % 8 THRU 15 78103000 T 0964 + 511, 511, 511, 511, 511, 511, 511, 511, % 16 THRU 31 78104000 T 0964 + 511, 511, 511, 511, 511, 511, 511, 511; 78105000 T 0964 + 148 IS 32 LONG, NEXT SEG 12 + FILL REFLECTION[*] WITH 78106000 T 0964 + 0, 16, 8, 24, 4, 20, 12, 28, 78107000 T 0965 + START OF SEGMENT ********** 149 + 2, 18, 10, 26, 6, 22, 14, 30, 78108000 T 0966 + 1, 17, 9, 25, 5, 21, 13, 29, 78109000 T 0966 + 3, 19, 11, 27, 7, 23, 15, 31; 78110000 T 0966 + 149 IS 32 LONG, NEXT SEG 12 + F:=D[2];%%%%%%%%%%%%%%%%%%%%% 78111000 T 0966 + PDR ← 8; 78112000 T 0967 + SIMULATOR; 78113000 T 0968 + EOJ:END; 78114000 T 0969 +PRT(1115) = *SEGMENT DESCRIPTOR* + 12 IS 973 LONG, NEXT SEG 2 + END. 78115000 T 0031 + 2 IS 34 LONG, NEXT SEG 1 +PRT(722) = EXP INTRINSIC, SEGMENT NUMBER = 150. +PRT(721) = LN INTRINSIC, SEGMENT NUMBER = 151. +PRT(700) = OUTPUT(W) INTRINSIC, SEGMENT NUMBER = 152. +PRT(5) = BLOCK CONTROL INTRINSIC, SEGMENT NUMBER = 153. +PRT(107) = INPUT(W) INTRINSIC, SEGMENT NUMBER = 154. +PRT(1074) = DUMP INTRINSIC, SEGMENT NUMBER = 155. +PRT(723) = X TO THE I INTRINSIC, SEGMENT NUMBER = 156. +PRT(115) = GO TO SOLVER INTRINSIC, SEGMENT NUMBER = 157. +PRT(14) = ALGOL WRITE INTRINSIC, SEGMENT NUMBER = 158. +PRT(15) = ALGOL READ INTRINSIC, SEGMENT NUMBER = 159. +PRT(16) = ALGOL SELECT INTRINSIC, SEGMENT NUMBER = 160. +PRT(326) = FILE ATTRBUTS INTRINSIC, SEGMENT NUMBER = 161. + 1 IS 2 LONG, NEXT SEG 0 + 162 IS 69 LONG, NEXT SEG 0 +NUMBER OF ERRORS DETECTED = 0. COMPILATION TIME = 286 SECONDS. + +PRT SIZE = 590; TOTAL SEGMENT SIZE = 13917 WORDS; DISK SIZE = 720 SEGS; NO. PGM. SEGS = 162 + +ESTIMATED CORE STORAGE REQUIRED = 14388 WORDS. + +ESTIMATED AUXILIARY MEMORY REQUIRED = 0 WORDS. + + + + + + + + LABEL 000000000LINE 00187158?COMPILE B65SIM/DISK WITH LONGALG LIBRARY LONGALG/B65SIM diff --git a/B6500-Simulator/B65SIM-COMPILE.card b/B6500-Simulator/B65SIM-COMPILE.card new file mode 100644 index 0000000..fec772b --- /dev/null +++ b/B6500-Simulator/B65SIM-COMPILE.card @@ -0,0 +1,8 @@ +?REMOVE B65SIM/DISK +?COMPILE B65SIM/DISK WITH LONGALG LIBRARY +?ALGOL FILE TAPE=SYMBOL/B65SIM SERIAL +?ALGOL FILE NEWTAPE=NEWSYM/B65SIM SERIAL +?DATA CARD +$TAPE LIST SINGLE PRT +$ 99999990 +?END diff --git a/B6500-Simulator/LONGALG-DELTA.pdf b/B6500-Simulator/LONGALG-DELTA.pdf new file mode 100644 index 0000000000000000000000000000000000000000..3aa422c3d162e748eea47ca1d8e0a8340b47290f GIT binary patch literal 58699 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 literal 0 HcmV?d00001 diff --git a/B6500-Simulator/LONGALG-PATCH.alg_m b/B6500-Simulator/LONGALG-PATCH.alg_m new file mode 100644 index 0000000..fcde6ac --- /dev/null +++ b/B6500-Simulator/LONGALG-PATCH.alg_m @@ -0,0 +1,127 @@ +?REMOVE LONGALG/DISK, LONGALG/NEW, NEWSYM/LONGALG 00000100 +?COMPILE LONGALG/NEW ALGOL LIBRARY 00000200 +?ALGOL STACK=1000 00000300 +?ALGOL FILE TAPE=SYMBOL/ALGOL SERIAL 00000400 +?ALGOL FILE NEWTAPE=NEWSYM/LONGALG SERIAL 00000450 +?FILE LINE = LINE BACK UP DISK 00000500 +?FILE NEWTAPE = "0CRDIMG" TAPE 00000600 +?FILE PNCH = PNCH PUNCH 00000700 +?DATA CARD 00000800 +$ TAPE CHECK NEW 00000900 +% THE SECOND COMING OF THE B-5500 LONGALG COMPILER 00001020 +% 3 JUNE 2017 00001040 + 506 BLOCK: LONG APPEARS IMMEDIATELY BEFORE IDENTIFIER(NO TYPE). 00305070 + [22:1] =IF 1, THIS IS THE FINAL ROW OF A LONG ARRAY, WHICH 01106700 + WILL REQUIRE DOUBLING OF THE RAW INDEX VALUE AND 01106800 + AN EXTRA LEVEL OF INDEXING FOR LONGROWSZ-WORD ROWS. 01106900 + DEFINEV =19#, COMMENT 23; 01298000 + LONGV =20#; COMMENT 24; 01298100 +DEFINE LONGROWSZ=256#; % SIZE OF LONG-ARRAY SEGMENTED ROWS 01299300 + LASTSEQUENCE =156#, 01575000 + SORTA =666# ; 01580000 + P5, COMMENT TELLS WHETHER LONG WAS SEEN; 01589600 + 1023 THEN FLAG(59); 13530000 + EMITL(T); 13530100 + END 13530200 + ELSE 13530300 + BEGIN 13530400 + % FOR A LONG ARRAY, DOUBLE THE SIZE OF 13530500 + % THE LAST DIMENSION AND SPLIT IT INTO 13530600 + % LONGROWSZ-WORD ROWS. 13530700 + T~(2|T+LONGROWSZ-1) DIV LONGROWSZ; 13530800 + EMITL(T); % # ROWS 13530900 + EMITL(LONGROWSZ); % FINAL ROW SIZE 13531000 + IF T>1023 THEN FLAG(59); 13531100 + IF T, 01832000 TIME(6),DATER(TIME(5)),12|REAL(Q:=H MOD 12=0)+Q, 01833000 @@ -6921,12 +6927,13 @@ FILL INFO[2,*] WITH OCT0030000120000000, "2LB000", % THESE ENTRIES ARE 09214105 OCT0130000000040000, "5LNGAM", OCT0000000012700000,%657 09214420 OCT0130000000040000, "3TAN00", OCT0000000011100000,%660 09214425 OCT2000000000004050, COMMENT POWERS OF TEN ; %663 09214430 - 0, COMMENT SORTA ; %664 09214435 - " " ; COMMENT LASTSEQUENCE,LASTSEQROW ; %665 09214440 + OCT0430000240000000, "4LONG0", %664 09214432 + 0, COMMENT SORTA ; %666 09214435 + " " ; COMMENT LASTSEQUENCE,LASTSEQROW ; %667 09214440 COMMENT NOW LINK THESE ENTRIES INTO STACKHEAD; 09214500 FOR NEXTINFO~512 STEP 2 UNTIL 534,537 STEP 3 UNTIL 546 09214510 ,567STEP 3UNTIL 603,607STEP 4UNTIL 615,618,621STEP 4UNTIL 629,632,635, 09214515 -639STEP 3UNTIL 660 09214516 +639STEP 3UNTIL 660,664 09214516 DO PUT(TAKE(NEXTINFO)&STACKHEAD[GT2~TAKE(NEXTINFO+1)MOD 125][35:35:13], 09214520 LASTINFO~STACKHEAD[GT2]~NEXTINFO); 09214530 NEXTINFO ~ LASTINFO ~ LASTSEQROW | 256 + LASTSEQUENCE + 1; 09214980 @@ -8590,7 +8597,7 @@ END DEFINEPARAM; 12166000 DO 13078000 BEGIN 13079000 STOPDEFINE := TRUE ; 13079500 - STEPIT; J~K;P2~P3~FALSE;GTA1[0]~0; GET7(ACCUM[1],FILID); 13080000 + STEPIT; J~K;P2~P3~P5~FALSE;GTA1[0]~0; GET7(ACCUM[1],FILID); 13080000 MULFID~0;TYPE~2; ENTER(FILEID); 13081000 SAVADDRSF~ADDRSF ; 13081500 IF SPECTOG THEN GO TO START; 13082000 @@ -9018,7 +9025,7 @@ COMMENT 13377000 DESC XITR ; 13447000 BEGIN 13448000 REAL T1,T2,T3,K,LBJ,ARPROGS,SAVEDIM,T,T4,SAVEINFO,SAVEINFO2; 13449000 - BOOLEAN LLITOG,ULITOG; 13450000 + BOOLEAN LLITOG,ULITOG,LONGDIM; 13450000 REAL ADDCON; 13451000 LABEL CSZ,BETA1,TWO,START,SLB,BETA2; 13452000 ARRAYFLAG ~ TRUE; 13452100 @@ -9037,6 +9044,10 @@ REAL ADDCON; 13451000 IF SPECTOG THEN 13465000 FLAG(014) 13466000 END 13467000 + ELSE IF T1=LONGV THEN 13467100 + BEGIN 13467200 + P5~TRUE; 13467300 + END 13467400 ELSE 13468000 TYPEV ~REALID+T1; 13469000 IF NOT SPECTOG THEN EMITO(MKS); SAVEINFO~NEXTINFO; 13470000 @@ -9096,12 +9107,31 @@ TWO:IF STEPI=ADOP THEN 13474000 AEXP; 13524000 EMITL(JUNK); 13525000 EMITO(ISN); 13526000 -CSZ: IF LLITOG AND ULITOG THEN 13527000 +CSZ: 13527000 + LONGDIM:= P5 AND TABLE(I)=RTBRKET; % LAST DIM OF LONG ARRAY 13527100 + IF LLITOG AND ULITOG THEN 13527200 BEGIN 13528000 L~ARPROGS; 13529000 - IF(T~IF ADDCON=ADDC THEN T4+T3+1 ELSE 13530000 - T4-T3+1){0 OR T>1023 THEN FLAG(59); 13531000 - EMITL(T); 13531100 + T~IF ADDCON=ADDC THEN 13529500 + T4+T3+1 ELSE T4-T3+1; 13529600 + IF T{0 THEN FLAG(59); 13529700 + IF NOT LONGDIM THEN 13529800 + BEGIN 13529900 + IF T>1023 THEN FLAG(59); 13530000 + EMITL(T); 13530100 + END 13530200 + ELSE 13530300 + BEGIN 13530400 + % FOR A LONG ARRAY, DOUBLE THE SIZE OF 13530500 + % THE LAST DIMENSION AND SPLIT IT INTO 13530600 + % LONGROWSZ-WORD ROWS. 13530700 + T~(2|T+LONGROWSZ-1) DIV LONGROWSZ; 13530800 + EMITL(T); % # ROWS 13530900 + EMITL(LONGROWSZ); % FINAL ROW SIZE 13531000 + IF T>1023 THEN FLAG(59); 13531100 + IF TMAXSAVE 13533000 THEN MAXSAVE~SAVEDIM 13534000 @@ -9115,16 +9145,28 @@ CSZ: IF LLITOG AND ULITOG THEN 13527000 THEN 13542000 BEGIN 13543000 EMITO(XCH);EMITO(SUB) 13544000 - END;EMITL(1);EMITO(ADD) 13545000 + END;EMITL(1);EMITO(ADD); 13545000 + IF LONGDIM THEN 13545100 + BEGIN 13545200 + EMITO(DUP); 13545300 + EMITO(ADD); % DOUBLE THE SIZE 13545400 + EMITL(LONGROWSZ-1); 13545500 + EMITO(ADD); % ROUND UP TO LONGROWSZ 13545550 + EMITL(LONGROWSZ); 13545600 + EMITO(IDV); % # ROWS 13545650 + EMITL(LONGROWSZ); % FINAL ROW SIZE 13545700 + END; 13545800 END; 13546000 -SLB:PUTNBUMP(T2);LBJ~LBJ+1;IF T~TABLE(I)=COMMA THEN GO TO TWO 13547000 +SLB: % IF LAST DIM OF LONG ARRAY, SET BIT 22 IN INFO DIMENSION WORD 13547000 + PUTNBUMP(T2 & REAL(LONGDIM)[22:47:1]); 13547100 + LBJ~LBJ+1;IF T~TABLE(I)=COMMA THEN GO TO TWO 13547200 ELSE 13548000 IF T!RTBRKET THEN FLAG(018); 13549000 IF NOT SPECTOG THEN 13550000 BEGIN 13551000 COMMENT KEEP COUNT OF NO. OF ARRAYS DECLARED; 13551400 NOOFARRAYS~NOOFARRAYS + GTA1[0]; 13551500 - EMITL(LBJ);EMITL(GTA1[0]); 13552000 + EMITL(LBJ+REAL(LONGDIM));EMITL(GTA1[0]); 13552000 EMITL(REAL(P3) +2|REAL(P2)); 13553000 EMITV(5) 13554000 END; 13555000 @@ -9285,6 +9327,9 @@ CNTR~0; 13689000 THEN G~GTA1[J~J-1]; 13724000 IF NOT P3 13725000 THEN IF P3~(G=SAVEV) 13726000 + THEN G~GTA1[J~J-1]; 13726100 + IF NOT P5 13726200 + THEN IF P5~(G=LONGV) 13726300 THEN G~GTA1[J~J-1] 13727000 END; 13728000 IF G!0 THEN FLAG(25) ELSE ENTRY(TYPE) 13729000 @@ -9443,11 +9488,11 @@ BEGIN 14012000 LABELDEC,DUMPDEC,LISTDEC,OUTDEC,INDEC,MONITORDEC, 14014000 SWITCHDEC,PROCEDUREDEC,ARRAYDEC,FORMATDEC,FILEDEC, 14015000 GOTSCHK, 14016000 - STREAMERR,DEFINEDEC,CALLSTATEMENT,HF,START; 14017000 + STREAMERR,DEFINEDEC,LONGERR,CALLSTATEMENT,HF,START; 14017000 SWITCH DECLSW~ OWNERR,SAVERR,BOOLEANDEC,REALDEC,ALPHADEC,INTEGERDEC, 14018000 LABELDEC,DUMPDEC,LISTDEC,OUTDEC,INDEC,MONITORDEC, 14019000 SWITCHDEC,PROCEDUREDEC,ARRAYDEC,FORMATDEC,FILEDEC, 14020000 - STREAMERR,DEFINEDEC; 14021000 + STREAMERR,DEFINEDEC,LONGERR; 14021000 DEFINE NLOCS=10#,LOCBEGIN=PRTI#; 14022000 DEFINE LBP=[36:12]#; 14023000 ARRAY TEDOC[0:7,0:127],LOCALS[0:NLOCS]; 14024000 @@ -9579,10 +9624,11 @@ START: IF TABLE(I)!SEMICOLON 14063000 GTA1[J]!DUMPV;ERRORTOG~TRUE; 14130000 END; 14131000 IF J =0 THEN GO TO CALLSTATEMENT; 14132000 - P2~P3~FALSE; 14133000 + P2~P3~P5~FALSE; 14133000 GO TO DECLSW[GTA1[J]]; 14134000 OWNERR:FLAG(20);J~J+1;GO TO REALDEC; 14135000 SAVERR:FLAG(21);J~J+1;GO TO REALDEC; 14136000 +LONGERR:FLAG(506);J~J+1;GO TO REALDEC; 14136200 STREAMERR:FLAG(22);J~J+1;GO TO PROCEDUREDEC; 14137000 REALDEC:P3~TRUE;ENTER(REALID);GO TO START; 14138000 ALPHADEC:P3~TRUE;ENTER(ALFAID);GO TO START; 14139000 @@ -10351,6 +10397,47 @@ COMMENT 201 VARIABLE- A PARTIAL WORD DESIGNATOR IS NOT THE * 15122000 IS SET TRUE IF THE VARIABLE IN 15212000 TALL IS SPECIAL MONITORED. 15213000 ; 15214000 +PROCEDURE INDEXER(TALL,J,BYNAME); 15214020 + VALUE TALL,J,BYNAME; 15214040 + REAL TALL,J; 15214060 + BOOLEAN BYNAME; 15214080 + BEGIN COMMENT 15214100 + INDEXER HANDLES THE COMPLEXITIES OF INITIAL AND FINAL 15214120 + INDEXING OF ARRAY DIMENSIONS WHERE DOUBLE-INDEXING OF THE 15214140 + LAST DIMENSION OF A LONG ARRAY MAY BE INVOLVED. ON ENTRY, 15214160 + ASSUMES THE RAW INDEX VALUE IS AT TOP OF STACK; 15214180 + 15214200 + IF BOOLEAN(TAKE(GIT(TALL)+J).[22:1]) THEN 15214220 + BEGIN % THIS IS THE LONG DIMENSION FOR A LONG ARRAY. 15214240 + EMITO(DUP); 15214260 + EMITO(ADD); % DOUBLE THE INDEX 15214280 + EMITPAIR(JUNK,ISN); % SAVE A COPY FOR THE COL INDEX 15214300 + EMITL(LONGROWSZ); 15214320 + EMITO(IDV); % COMPUTE THE SPLIT-ROW INDEX 15214340 + IF J=1 THEN 15214360 + EMITN(TALL.ADDRESS) 15214380 + ELSE 15214400 + EMITO(CDC); 15214420 + EMITO(LOD); % LOAD THE DESTINATION DESCRIPTOR15214440 + EMITV(JUNK); % RETRIEVE THE SAVED INDEX VALUE 15214460 + EMITL(LONGROWSZ); 15214480 + EMITO(RDV); % COMPUTE THE SPLIT-COL INDEX 15214500 + IF BYNAME THEN 15214520 + EMITO(CDC) 15214540 + ELSE 15214560 + EMITO(COC); 15214580 + END 15214600 + ELSE IF J=1 THEN 15214620 + IF BYNAME THEN 15214640 + EMITN(TALL.ADDRESS) 15214660 + ELSE 15214680 + EMITV(TALL.ADDRESS) 15214700 + ELSE 15214720 + IF BYNAME THEN 15214740 + EMITO(CDC) 15214760 + ELSE 15214780 + EMITO(COC); 15214800 + END INDEXER; 15214820 PROCEDURE M4(TALL,J); 15215000 VALUE TALL,J ; 15216000 REAL TALL,J ; 15217000 @@ -10361,10 +10448,10 @@ PROCEDURE M4(TALL,J); 15215000 THEN BEGIN COMMENT TALL IS MONITORED; 15221000 EMITV(JUNK); EMITO(XCH); 15222000 END; 15223000 - EMITN(TALL.ADDRESS ) 15224000 + INDEXER(TALL,J,TRUE); 15224000 END 15225000 ELSE BEGIN COMMENT NOT THE FIRST TIME AROUND; 15226000 - EMITO(CDC); 15227000 + INDEXER(TALL,J,TRUE); 15227000 IF TALL < 0 15228000 THEN BEGIN COMMENT CALL SUBSCRIPT; 15229000 EMITV(JUNK); EMITO(XCH); 15230000 @@ -10502,19 +10589,13 @@ COMMENT ***** MONITOR FUNCTION M6 GOES BEFORE EMITO(XCH); 15310000 IF DOTSYNTAX(T1,T2) THEN GO TO EXIT; 15341000 IF STEPI = ASSIGNOP THEN IF P1=FS THEN GO TO LAST 15342000 ELSE BEGIN ERR(209); GO EXIT END; 15343000 - IF J=1 THEN EMITV(TALL.ADDRESS)ELSE EMITO(COC); 15344000 + INDEXER(TALL,J,FALSE); 15344000 END 15345000 ELSE 15346000 COMMENT ***** MONITOR FUNCTION M10 GOES HERE ; 15347000 BEGIN COMMENT MONITOR FUNCTION M10; 15348000 SPCLMON~P1 = FP OR ELCLASS } AMPERSAND; 15349000 - IF J = 1 15350000 - THEN IF SPCLMON 15351000 - THEN EMITV(TALL.ADDRESS) 15352000 - ELSE EMITN(TALL.ADDRESS) 15353000 - ELSE EMITO(IF SPCLMON 15354000 - THEN COC 15355000 - ELSE CDC); 15356000 + INDEXER(TALL,J,NOT SPCLMON); 15350000 IF TALL < 0 15357000 THEN BEGIN COMMENT DO NOT MONITOR AFTER ALL; 15358000 EMITL(5); 15359000 @@ -11052,4 +11133,4 @@ PROCEDURE JUMPS; 16431000 TIME1 ~ TIME(1); PROGRAM; 17000000 ENDOFITALL:END MAIN BLOCK 17000100 END. 17001000 -END;END. LAST CARD ON 0CRDING TAPE 99999999 +END;END. LAST CARD ON 0CRDIMG TAPE 99999990 diff --git a/B6500-Simulator/README.txt b/B6500-Simulator/README.txt index 1f6c133..f0acd57 100644 --- a/B6500-Simulator/README.txt +++ b/B6500-Simulator/README.txt @@ -2,22 +2,63 @@ Burroughs B6500 Simulator and Early MCP for the B5500 These files were transcribed by James Fehlinger of New Jersey, US in mid-2014, from scans of listings provided by Al Kossow of bitsavers.org. +Paul Kimpel assisted in proofing and debugging of the transcribed files. B65SIM.alg_m - A simulator for the Burroughs B6500 written in a variant of B5500 - Extended Algol, termed LONGALG. This variant implement a "Long - Array" type, which appeared to the programmer to be a single- - dimensional array, but was implemented as a two-dimensional array. - The compiler generated code to partition the array index into column - and row portions, and index the row and column accordingly. + An engineering simulator for the Burroughs B6500, written in a + variant of B5500 Extended Algol, termed LONGALG, described below. + This simulator appears to have been built to model the "flows" + (schematic logic and state diagrams) for the B6500 processor. It + runs as a normal user task under the B5500 MCP. + +B65SIM-COMPILE.card + A card deck to compile B65SIM using the LONGALG compiler described + below. Note that since LONGALG is not a standard compiler name, the + compile card must specify "WITH LONGALG". + +B65SIM-COMPILE-PRT.lst + The listing of the B6500 Simulator (with $PRT set) produced by the + card deck above. B65ESPOL.alg_m An early implementation of an ESPOL cross-compiler for the B6500, written to run on the B5500. We believe that Don Lyle was the - principle implementor of this compiler. + principal implementer of this compiler. B65MCP-MARK00.esp_m A very preliminary version of the B6500 MCP. It is notable for its use of ESPOL Queue structures, which eventually proved to be too expensive at run time, and were removed in the Mark II.0 release. +LONGALG.alg_m + LONGALG is a specially modified version of the Mark XIII Algol + compiler that supports the LONG ARRAY type required by B65SIM. We do + not have the source for the original LONGALG, which was written no + later than 1968, and would have been based on an earlier release + than XIII (which is from late 1971). Support for LONG ARRAYS was + reverse-engineered from comments in the B65SIM listing and + implemented for XIII Algol by Paul Kimpel in June 2017. + + LONGALG automatically doubles the declared size of the last + dimension of a LONG ARRAY, and automatically doubles any index + values for that last dimension when accessing elements of the array + (thus addressing only the even-numbered words). This was done to + implement a simulated memory array that allowed B6500 tag values to + be stored in the odd words. In addition, a LONG ARRAY physically has + one more dimension than is declared in the program. The last (or + only) declared dimension is split into rows of 256 words (128 + emulated words). As many of these rows are allocated in the next-to- + last physical dimension to accommodate the required number of rows + for the (doubled) size of the last declared dimension. + +LONGALG-PATCH.alg_m + Kimpel's patch to Mark XIII Algol to produce the LONGALG compiler. + This deck compiles LONGALG/NEW, which then must be marked as a + compiler by the SPO command "MC LONGALG/NEW", which will also change + the name of the file to the standard convention for compilers, + LONGALG/DISK. + +LONGALG-DELTA.pdf + A PDF document showing a side-by-side comparison of LONGALG to the + base Mark XIII source. +