PDP16S,NEWSIMS,PDPDUMPS,WOMBLES,SIMPS,REDUCES,GRAPH16S,ARTHPS %CONSTSHORTINTEGERARRAY MAIN(1: 172) = %C 1, 0, 4, 9, 15, 19, 23, 28, 33, 37, 43, 48, 53, 58, 63, 67, 71, 82, 86, 90, 94, 97, 105, 109, 113, 114, 116, 0, 118, 122, 0, 124, 127, 0, 131, 134, 135, 138, 0, 141, 144, 147, 150, 153, 156, 0, 162, 162, 167, 171, 0, 174, 178, 182, 189, 0, 191, 196, 0, 199, 203, 207, 210, 0, 213, 216, 219, 0, 222, 225, 228, 231, 0, 235, 238, 241, 244, 247, 0, 250, 253, 0, 256, 259, 262, 0, 265, 0, 268, 272, 0, 274, 277, 280, 283, 286, 0, 292, 296, 299, 302, 305, 308, 0, 310, 315, 0, 317, 320, 323, 0, 326, 330, 334, 0, 338, 341, 0, 343, 346, 0, 349, 355, 0, 357, 0, 362, 365, 368, 0, 370, 376, 0, 378, 0, 382, 390, 398, 402, 0, 406, 409, 412, 0, 417, 420, 0, 422, 427, 0, 429, 0, 432, 437, 0, 439, 442, 0, 444, 450, 0, 452, 457, 0, 459, 462, 465, 468, 471, 474, 477, 0 %CONSTSHORTINTEGERARRAY SUB(2: 480) = %C 4098,-32768, 0, 8207, 4246, 1, 4098, 0, 8194, 4143, 4121, 4152, 4217, 0, 8193, 16385, 4254, 0, 8195, 4207, 4211, 0, 3, 8196, 4175, 4193, 0, 8197, 4203, 20481, 4217, 0, 8198, 4135, 20480, 0, 8199, 4132, 20480, 4220, 4226, 0, 8, 8216, 16384, 4124, 0, 13, 8200, 16384, 4124, 0, 18, 8201, 16384, 24576, 0, 22, 8202, 4229, 4243, 0, 29, 8203, 16384, 0, 37, 8204, 4251, 0, 41, 8206, 16384, 48, 4178, 50, 4178, 50, 4178, 52, 0, 54, 8208, 16384, 0, 65, 8210, 12288, 0, 73, 79, 8213, 0, 83, 8214, 0, 87, 8215, 16384, 48, 12288, 4130, 52, 0, 97, 8217, 12288, 0, 103, 8218, 16385, 4217, 0, 110, 0, 113, 0, 48, 4127, 52, 0, 8192, 0, 8193, 16384, 0, 8194, 12288, 4130, 0, 50, 12288, 4130, 0, 115, 8195, 0, 122, 8205, 0, 126, 8194, 0, 131, 8201, 0, 137, 8202, 0, 143, 8203, 0, 150, 8204, 0, 155, 8193, 0, 79, 8217, 0, 159, 8192, 16385, 161, 0, 8193, 16385, 4147, 0, 8194, 163, 0, 167, 8193, 4260, 0, 169, 8194, 12288, 0, 171, 8195, 12288, 1, 12288, 173, 0, 8192, 0, 48, 8208, 4155, 175, 0, 8192, 4155, 0, 8193, 4160, 4182, 0, 8194, 4182, 4164, 0, 8195, 12288, 0, 8196, 4143, 0, 179, 8195, 0, 181, 8197, 0, 184, 8198, 0, 187, 8197, 0, 190, 8198, 0, 193, 8199, 0, 8192, 4169, 4182, 0, 196, 8200, 0, 198, 8201, 0, 200, 8202, 0, 202, 8203, 0, 205, 8204, 0, 207, 8193, 0, 213, 8194, 0, 8192, 4193, 0, 219, 8194, 0, 224, 8193, 0, 16385, 4184, 0, 167, 8193, 4260, 0, 8192, 0, 228, 8201, 0, 232, 8202, 0, 235, 8204, 0, 238, 8203, 0, 163, 8193, 171, 12288, 173, 0, 8192, 4182, 4200, 0, 241, 8202, 0, 246, 8204, 0, 255, 8203, 0, 264, 8201, 0, 4187, 0, 171, 8193, 12288, 173, 0, 8192, 0, 273, 8195, 0, 73, 8196, 0, 277, 8197, 0, 288, 8192, 16384, 0, 291, 8193, 8192, 0, 298, 8194, 8192, 0, 4214, 4193, 0, 8192, 0, 303, 8193, 0, 306, 8194, 0, 313, 8193, 4203, 20481, 4217, 0, 8192, 0, 48, 12288, 4222, 52, 0, 317, 9216, 0, 319, 8193, 0, 8193, 0, 50, 8193, 20480, 4220, 4226, 0, 8192, 0, 16384, 113, 4231, 0, 321, 8194, 4236, 171, 12288, 4240, 173, 0, 8193, 8192, 4182, 171, 8193, 12288, 173, 0, 8192, 16385, 4147, 0, 163, 8195, 4200, 0, 8220, 323, 0, 8221, 330, 0, 8222, 335, 12288, 52, 0, 1, 12288, 0, 8192, 0, 50, 8193, 4229, 4243, 0, 8192, 0, 16384, 4248, 0, 48, 8200, 12288, 52, 0, 8206, 0, 342, 8193, 0, 8192, 0, 48, 8193, 28672, 4257, 52, 0, 8192, 0, 50, 8193, 28672, 4257, 0, 8192, 0, 349, 8210, 0, 319, 8211, 0, 351, 8213, 0, 354, 8214, 0, 357, 8218, 0, 360, 8219, 0, 364, 8223, 0 %CONSTBYTEINTEGERARRAY LITERAL(1: 370) = %C 1, 58, 4, 119, 97, 105, 116, 4, 98, 114, 101, 103, 4, 116, 114, 101, 103, 3, 115, 112, 109, 6, 100, 101, 102, 105, 110, 101, 7, 114, 111, 117, 116, 105, 110, 101, 3, 101, 110, 100, 6, 98, 114, 97, 110, 99, 104, 1, 40, 1, 44, 1, 41, 10, 98, 114, 101, 97, 107, 112, 111, 105, 110, 116, 7, 99, 111, 110, 116, 114, 111, 108, 5, 99, 108, 101, 97, 114, 3, 98, 117, 115, 3, 110, 111, 112, 9, 114, 101, 103, 102, 111, 114, 109, 97, 116, 5, 114, 97, 100, 105, 120, 6, 101, 110, 97, 98, 108, 101, 2, 60, 45, 1, 61, 6, 109, 101, 109, 111, 114, 121, 3, 114, 111, 109, 4, 102, 108, 97, 103, 5, 103, 112, 105, 110, 116, 5, 105, 110, 105, 110, 116, 6, 111, 117, 116, 105, 110, 116, 4, 115, 105, 110, 116, 3, 103, 112, 97, 1, 91, 1, 93, 3, 66, 85, 83, 1, 95, 1, 35, 1, 60, 1, 62, 3, 41, 47, 50, 1, 92, 2, 50, 42, 2, 49, 43, 2, 42, 50, 2, 43, 49, 2, 45, 49, 1, 43, 1, 45, 1, 38, 2, 33, 33, 1, 33, 5, 119, 104, 105, 108, 101, 5, 117, 110, 116, 105, 108, 4, 104, 105, 103, 104, 3, 108, 111, 119, 3, 79, 86, 70, 2, 68, 90, 2, 68, 80, 2, 68, 78, 4, 90, 69, 82, 79, 8, 80, 79, 83, 73, 84, 73, 86, 69, 8, 78, 69, 71, 65, 84, 73, 86, 69, 8, 79, 86, 69, 82, 70, 76, 79, 87, 3, 115, 101, 116, 10, 99, 111, 109, 112, 108, 101, 109, 101, 110, 116, 2, 45, 62, 6, 114, 101, 116, 117, 114, 110, 4, 115, 116, 111, 112, 2, 105, 102, 6, 117, 110, 108, 101, 115, 115, 3, 97, 110, 100, 1, 75, 1, 66, 1, 42, 6, 83, 87, 73, 84, 67, 72, 4, 68, 65, 84, 65, 6, 76, 73, 71, 72, 84, 40, 6, 111, 102, 102, 105, 108, 101, 1, 65, 2, 75, 70, 2, 80, 70, 2, 73, 78, 3, 79, 85, 84, 6, 79, 86, 69, 82, 85, 78 %CONSTSTRING (31) VERSION = ' ARTHUR : VERSION 3.0' ! ! EXTERNAL SPECS ! %SYSTEMROUTINESPEC FDP(%INTEGER X, %STRING (17) X, %C %INTEGER X, X, %INTEGERNAME X) %EXTERNALROUTINESPEC PROMPT(%STRING (15) S) %EXTERNALSTRINGFNSPEC DATE %EXTERNALSTRINGFNSPEC TIME %EXTERNALROUTINESPEC DEFINE(%STRING (63) X) ! ! TABLES FOR PARSER ! ! ! TABLE OF FAULT MESSAGES ! %CONSTBYTEINTEGERARRAY FAULT TEXT(0 : 476) = %C 4, 'N', 'A', 'M', 'E', 9, 'D', 'U', 'P', 'L', 'I', 'C', 'A', 'T', 'E', 16, 'D', 'U', 'P', 'L', 'I', 'C', 'A', 'T', 'E', ' ', 'B', 'R', 'A', 'N', 'C', 'H', 11, 'L', 'A', 'B', 'E', 'L', ' ', 'E', 'R', 'R', 'O', 'R', 7, 'C', 'O', 'N', 'T', 'E', 'X', 'T', 11, 'I', 'N', 'V', 'A', 'L', 'I', 'D', ' ', 'B', 'I', 'T', 15, 'I', 'L', 'L', 'E', 'G', 'A', 'L', ' ', 'S', 'U', 'B', 'N', 'A', 'M', 'E', 13, 'I', 'L', 'L', 'E', 'G', 'A', 'L', ' ', 'I', 'N', 'D', 'E', 'X', 18, 'I', 'L', 'L', 'E', 'G', 'A', 'L', ' ', 'E', 'X', 'T', 'R', 'A', 'C', 'T', 'I', 'O', 'N', 12, 'S', 'P', 'U', 'R', 'I', 'O', 'U', 'S', ' ', 'E', 'N', 'D', 19, 'N', 'O', 'T', ' ', 'A', ' ', 'R', 'O', 'U', 'T', 'I', 'N', 'E', '/', 'M', 'A', 'C', 'R', 'O', 22, 'I', 'N', 'C', 'O', 'M', 'P', 'A', 'T', 'A', 'B', 'L', 'E', ' ', 'R', 'E', 'G', 'I', 'S', 'T', 'E', 'R', 'S', 19, 'N', 'O', 'T', ' ', 'A', 'N', ' ','''', 'A','''', ' ', 'R', 'E', 'G', 'I', 'S', 'T', 'E', 'R', 18, 'N', 'O', 'T', ' ', 'A', ' ', '''', 'B','''', ' ', 'R', 'E', 'G', 'I', 'S', 'T', 'E', 'R', 14, 'N', 'O', 'T', ' ', 'A', ' ', 'R', 'E', 'G', 'I', 'S', 'T', 'E', 'R', 14, 'N', 'O', 'T', ' ', 'A', 'N', ' ', 'A', 'D', 'D', 'R', 'E', 'S', 'S', 10, 'N', 'O', 'T', ' ', 'A', ' ', 'F', 'L', 'A', 'G', 17, 'R', 'E', 'C', 'U', 'R', 'S', 'I', 'V', 'E', ' ', 'C', 'A', 'L', 'L', ' ', 'O', 'N', 11, 'E', 'N', 'D', ' ', 'M', 'I', 'S', 'S', 'I', 'N', 'G', 10, 'I', 'N', 'V', 'A', 'L', 'I', 'D', ' ', '/', '2', 6, 'A', 'C', 'C', 'E', 'S', 'S', 13, 'L', 'A', 'B', 'E', 'L', ' ', 'M', 'I', 'S', 'S', 'I', 'N', 'G', 22, 'I', 'N', 'V', 'A', 'L', 'I', 'D', ' ', 'F', 'L', 'A', 'G', ' ', 'O', 'P', 'E', 'R', 'A', 'T', 'I', 'O', 'N', 21, 'D', 'E', 'C', 'L', 'A', 'R', 'A', 'T', 'I', 'O', 'N', ' ', 'M', 'I', 'S', 'P', 'L', 'A', 'C', 'E', 'D', 17, 'N', 'O', 'T', ' ', 'A', ' ', 'D', 'E', 'S', 'T', 'I', 'N', 'A', 'T', 'I', 'O', 'N', 12, 'N', 'O', 'T', ' ', 'A', ' ', 'S', 'O', 'U', 'R', 'C', 'E', 11, 'N', 'O', 'T', ' ', 'A', ' ', 'L', 'I', 'G', 'H', 'T', 17, 'T', 'O', 'O', ' ', 'M', 'A', 'N', 'Y', ' ', 'S', 'P', ' ', 'N', 'A', 'M', 'E', 'S', 15, 'N', 'O', 'T', ' ', 'E', 'N', 'O', 'U', 'G', 'H', ' ', 'P', 'I', 'N', 'S', 15, 'N', 'O', 'T', ' ', 'A', ' ', 'R', 'E', 'G', 'F', 'O', 'R', 'M', 'A', 'T', 13, 'N', 'O', 'T', ' ', 'A', ' ', 'R', 'E', 'G', ' ', 'P', 'I', 'N', 13, 'T', 'O', 'O', ' ', 'M', 'A', 'N', 'Y', ' ', 'P', 'I', 'N', 'S' %CONSTBYTEINTEGERARRAY FAULT ACTION(1 : 32) = %C %C 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 2, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 %CONSTSHORTINTEGERARRAY FAULT NO(1 : 32) = %C 0, 5, 15, 32, 44, 52, 64, 80, 94, 113, 126, 146, 169, 189, 208, 223, 238, 249, 267, 279, 290, 297, 311,334, 356, 374, 387, 399, 417, 433, 449, 463 %CONSTBYTEINTEGERARRAY OPUSE(0 : 11) = %C 15,16,0,17,20,19,0,0,0,18,0,21 %CONSTSTRING (5) %ARRAY MNAMES(0 : 21) = %C 'NULL ', 'GPA ', 'BSENS', 'GPI ', 'OI ', 'II ', 'SI ', 'CGEN ', 'CGEN*', 'ROM ', 'TREG ', 'BREG ', 'SPM ', 'MEM ', 'FLAG ', 'NOP ', 'EVOKE', '2-BR ', '8-BR ', 'S-RET', 'MERGE','BREAK' %CONSTSHORTINTEGERARRAY MTYPE(0 : 40) = %C 0, 1, 14, 13, 12, 7, 11, 10, 0, 3, 5, 4, 6, 9, 0(10), 12, 2, 0(15) %CONSTBYTEINTEGERARRAY ACC(0 : 23) = %C 0,1,1,1,1,1,0(8),1,0,1,0,0,0,0,1,1,1 %CONSTBYTEINTEGERARRAY DEST(0 : 40) = %C 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0(10) %CONSTBYTEINTEGERARRAY SNAME(0 : 40) = %C 1, 0(17), 1, 1, 0, 12, 12, 0(3), 9, 9, 0(3), 12, 0(9) %CONSTBYTEINTEGERARRAY BITS(0 : 40) = %C 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0(3), 0(10) ! %OWNINTEGER RADIX = 10; ! DEFAULT RADIX FOR CONSTANTS %OWNINTEGER EXTERNAL LENGTH = 100 %CONSTSHORTINTEGER HEADER LENGTH = 64 %CONSTINTEGER PERCC = 99; ! 'C'+32 %OWNINTEGER MAX NAMES = 200 %CONSTINTEGER MAX TEXT = 1500 %CONSTINTEGER LINE SIZE = 200 %CONSTINTEGER TABLE SIZE = 50 %CONSTINTEGER LIST SIZE = 100 %CONSTINTEGER AREC SIZE = 100 %CONSTINTEGER CODE LIMIT = 2000 %CONSTINTEGER CONST SIZE = 50 ! ! OPERATION CODES ! %CONSTINTEGER NOP CODE = 0 %CONSTINTEGER EVOKE CODE = 1 %CONSTINTEGER BUS CODE = 2 %CONSTINTEGER COND CODE = 3 %CONSTINTEGER MERGE CODE = 4 %CONSTINTEGER CALL CODE = 5 %CONSTINTEGER RETURN CODE = 6 %CONSTINTEGER JUMP CODE = 7 %CONSTINTEGER STOP CODE = 8 %CONSTINTEGER BRANCH CODE = 9 %CONSTINTEGER TEST CODE = 10 %CONSTINTEGER BREAK CODE = 11 %CONSTINTEGER C EVOKE CODE = 12 %CONSTINTEGER C MERGE CODE = 13 %CONSTINTEGER FLAG CODE = 14 %CONSTINTEGER EXTRA EVOKE CODE = 15 ! %CONSTINTEGER REG FORMAT = 32 ! ! %CONSTINTEGER INSTREAM = 40; ! INPUT STREAM NUMBER %CONSTINTEGER OUTSTREAM = 41; ! OUTPUT STREAM NUMBER ! ! ! %OWNSTRING (4) SAFETY FILE = '+.TT'; ! TO PREVENT INPUT FILE ENDED %CONSTSTRING (8) DEFAULT LIST = 'SS#LIST'; ! LISTING FILE %CONSTSTRING (8) DEFAULT IN = '.TT'; ! SOURCE FILE %CONSTSTRING (8) DEFAULT OBJECT = 'SS#ARTH'; ! OBJECT FILE ! ! ! ! %EXTERNALROUTINE ARTHUR(%STRING (63) FILES) ! ! RECORD FORMATS ! %RECORDFORMAT HEADERFM( %C %INTEGER IDEN, USEAGE, NNAMES, NAMES, TEXT, CODE, %C CONSTANTS, OLD FILE, TXTLNG, STARTAD, EXTERNS, TABS) ! %RECORDFORMAT EXTERNFM(%BYTEINTEGER FROM, FBITS, TO, TOBITS) ! %RECORDFORMAT SYSHEADFM(%INTEGER SIZE, HEADSIZE, MAX, LD) ! %RECORDFORMAT CODEFM(%BYTEINTEGER CODE, NAME, OPRN, MODULE, %C %SHORTINTEGER ADDR, STAT) ! %RECORDFORMAT TAGFM(%INTEGER MASTER, %SHORTINTEGER TYPE, %C %BYTEINTEGER USED, BITS, %INTEGER USE, DEFN, SIZE, WHERE) ! %RECORDFORMAT NAMEFM(%STRINGNAME TEXT,%RECORD TAGS(TAGFM)) ! %RECORDFORMAT TABFM(%SHORTINTEGERARRAY W(0 : 7)) ! ! %BYTEINTEGERARRAY SYMS, LINE(0 : LINE SIZE); ! BUFFERS FOR INPUT LINE %SHORTINTEGERARRAY CONSTS(1 : CONST SIZE); ! TABLE OF CONSTANTS %RECORDARRAY TABLES(1 : TABLE SIZE)(TABFM) ! TABLES FOR BRANCH & REGFORMAT %INTEGERARRAY INFO, LINK(1 : LIST SIZE);! LABEL LISTS %SHORTINTEGERARRAY REC(0 : AREC SIZE); ! ANALYSIS RECORD ARRAY ! ! %SHORTINTEGERARRAYNAME MODUSEAGE; ! TABLE OF MODULE USEAGES %BYTEINTEGERARRAYNAME TEXT; ! BUFFER FOR DICTIONARY ! ! %INTEGERNAME LAB LIST; ! CURRENT LAB LIST HEAD %INTEGERNAME NNAMES; ! NUMBER OF DECLARED NAMES %INTEGERNAME TEXTPT; ! CURRENT FREE SPACE IN DICT ! ! %INTEGER WHERE, FILE END %BYTEINTEGER LIST FLAG, OUT FLAG, ACCESS, DECLARATIONS, ROUTINES %INTEGER NAMEFAULT, NAME FLAG %INTEGER ASL, RT PENDING %BYTEINTEGER CONTROL, START FLAG, LAB ACTIVE %INTEGER CODEIN, FLAG, TP, MARKER, FSTART, LINE MAX %INTEGER LP, RP, J, K, SM, PP, CONS %INTEGER FAULTS, CONNECT, LINES, TABCOUNT, STATS ! ! ARRAY FORMATS ! %RECORDARRAYFORMAT EXTARFM(1 : EXTERNAL LENGTH)(EXTERNFM) %RECORDARRAYFORMAT CFM(0 : CODE LIMIT)(CODEFM) %RECORDARRAYFORMAT NAFM(1 : MAX NAMES)(NAMEFM) %BYTEINTEGERARRAYFORMAT TXT1(0 : MAX TEXT) %SHORTINTEGERARRAYFORMAT MUFM(0 : 21) ! ! RECORD NAMES ! ! ! %RECORDNAME HEADER(HEADERFM); ! ARTHUR FILE HEADER %RECORDNAME SYS HEADER(SYSHEADFM); ! SYSTEM FILE HEADER %RECORDNAME V, RTDEFN(NAMEFM) ! ! %RECORDARRAYNAME EXTERNALS(EXTERNFM) %RECORDARRAYNAME OBJECT(CODEFM) %RECORDARRAYNAME NAME(NAMEFM) ! ! %RECORD FLAG INFO(NAMEFM) %RECORD DESTN, TEMPLATE(TAGFM) ! ! %STRINGNAME CURRENT %STRING (63) IN FILE, OBJECT FILE, LIST FILE ! ! %ROUTINESPEC RECONSTRUCT(%BYTEINTEGER MODE) %ROUTINESPEC ABORT(%INTEGER B) %ROUTINESPEC NOP %ROUTINESPEC DUMP(%BYTEINTEGER A, B, C, D, %SHORTINTEGER Z) %ROUTINESPEC COMPILE BLOCK %ROUTINESPEC FAULT(%INTEGER NUMBER) ! ! %ROUTINE PINDEF %SHORTROUTINE ! ! CREATE THE TABLE FOR TRANSFER REGS ETC ! %INTEGER L, J L = ADDR(TABLES(TABCOUNT)_W(0)); ! ADDRESS OF TABLE ENTRY %CYCLE J = L, 1, L+15 RP = RP+1 FAULT(29) %AND %RETURN %IF REC(RP) < 0 BYTEINTEGER(J) <- REC(RP); ! FILL IN ENTRY FAULT(31) %UNLESS 0 <= REC(RP) <= 15 %REPEAT FAULT(32) %IF REC(RP+1) >= 0 %END %ROUTINE SHOW LISTS %ROUTINESPEC SHOW(%RECORDNAME V) %INTEGER J %RECORDNAME V(NAMEFM) %RETURN %IF NNAMES = 0 %CYCLE J = 1, 1, NNAMES V == NAME(J) SHOW(V) %IF V_TAGS_TYPE = 14 %OR V_TAGS_TYPE = 8 %REPEAT NEWLINE %ROUTINE SHOW(%RECORDNAME V) %RECORDSPEC V(NAMEFM) %INTEGER LIST LIST = V_TAGS_SIZE; %RETURN %IF LIST = 0 PRINTSTRING(V_TEXT.':') %UNTIL LIST = 0 %CYCLE V == NAME(INFO(LIST)) PRINTSTRING(' '.V_TEXT) LIST = LINK(LIST) %REPEAT NEWLINE %END %END %ROUTINE DISPLAY ! OUTPUT NAME INFO (TESTING ONLY) %INTEGER J %RECORDNAME V(NAMEFM) %STRING (8) TEXT J = NNAMES %WHILE J > 0 %CYCLE V == NAME(J) TEXT <- V_TEXT PRINTSTRING(TEXT) SPACES(10-LENGTH(TEXT)) WRITE(V_TAGS_MASTER, 5) WRITE(V_TAGS_TYPE, 3) WRITE(V_TAGS_USE, 3) WRITE(V_TAGS_DEFN, 3) WRITE(V_TAGS_SIZE, 3) WRITE(V_TAGS_WHERE, 3) NEWLINE J = J-1 %REPEAT %END %ROUTINE STOP %SHORTROUTINE ! ! COMPLETE THE COMPILATION BY TIDYING UP ANY LOOSE ENDS ! AND OUTPUTING ALL TABLES ETC. ! %STRING (7) ITEM %INTEGER J, K, N %RECORDNAME ON(CODEFM) %RECORDNAME NN(NAMEFM) %RECORDNAME TWORK(TABFM) DUMP(STOPCODE, 0, 0, 0, 0); ! GIVE A STOP AT THE END ROUTINES = ROUTINES-1 %AND FAULT(19) %WHILE ROUTINES > 0 ! ! TIDY UP NAMES ! J = NNAMES; ! NUMBER OF NAMES DECLARED %WHILE J > 0 %CYCLE NN == NAME(J); ! LOOK AT TAGS ! ! CHECK UNUSED NAMES ! %IF (NN_TAGS_TYPE = 14 %AND NN_TAGS_DEFN = 0) %C %OR (NN_TAGS_TYPE = 8 %AND NN_TAGS_USE = 0 %C %AND NN_TAGS_DEFN = 1) %START CURRENT == NN_TEXT; FAULT(22); ! LABEL MISSING %FINISH %IF NN_TAGS_USED = 0 %AND NN_TAGS_TYPE # 0 %START %IF NN_TAGS_TYPE = 14 %THEN ITEM = 'LABEL' %C %ELSE ITEM = 'NAME ' PRINTSTRING('? UNUSED '.ITEM.' '.NN_TEXT.' ') %FINISH %ELSE %START ! ! FILL IN MERGE INPUT COUNT FOR !LABELS ! %UNLESS 14 # NN_TAGS_TYPE # 15 %C %THEN OBJECT(NN_TAGS_WHERE)_OPRN = NN_TAGS_USE %FINISH J = J-1; ! BACK FOR NEXT NAME %REPEAT ! ! WORK OUT NUMBER OF MODULES ! %CYCLE J = 1, 1, CODEIN-1; ! SCAN THROUGH CODE ON == OBJECT(J) K = ON_CODE; ! LOOK AT OP-CODE %IF 0 <= K <= 11 %C %THEN K = OPUSE(K) %AND MODUSEAGE(K) = MODUSEAGE(K)+1 %REPEAT K = MODUSEAGE(15); ! ACTUAL NUMBER OF NOPS MODUSEAGE(16) = MODUSEAGE(16)+K; ! ADD EVOKES FOR NOPS MODUSEAGE(15) = K; ! NUMBER OF NOPS ! ! FILL IN CONSTANT TABLE ! K = CONS; MODUSEAGE(7) = K; ! NUMBER OF CONSTANTS J = ADDR(OBJECT(CODEIN+1)); ! FREE SPACE HEADER_CONSTANTS = J-ADDR(HEADER) SHORTINTEGER(J) <- K; ! NUMBER OF CONSTANTS ABORT(8) %IF J+K*2 > FILE END %WHILE K > 0 %CYCLE SHORTINTEGER(K<<1+J) <- CONSTS(K) K = K-1 %REPEAT J = J+CONS<<1+2 ! ! DUMP BRANCH & REGFORMAT TABLES ! HEADER_TABS = J-ADDR(HEADER) %UNLESS TABCOUNT = 0 %START ABORT(8) %IF J+TABCOUNT*16 > FILE END %CYCLE N = 1, 1, TABCOUNT TWORK == RECORD(J); J = J+16 TWORK = TABLES(N); ! COPY TABLES INTO OBJECT FILE %REPEAT %FINISH CODEIN = J; ! ADDRESS OF END OF OBJECT FILE ! ! OUTPUT MODULE USEAGE ! MODUSEAGE(20) = 0; ! IGNORE MERGES N = 5; ! COUNTER FOR NEWLINES %CYCLE J = 1, 1, 21 K = MODUSEAGE(J) %IF K # 0 %START PRINTSTRING(' '.MNAMES(J)); WRITE(K, 3) N = N-1; N = 5 %AND NEWLINE %IF N <= 0 %FINISH %REPEAT ! ! COMPLETE HEADER INFO AS NOTHING CATASTROPHIC CAN HAPPEN NOW ! SYS HEADER_HEADSIZE = HEADER LENGTH SYS HEADER_SIZE = CODEIN-ADDR(SYS HEADER)+16 %IF FAULTS = 0 HEADER_IDEN = M'ARTH'; ! SHOW AN 'ARTHUR OBJECT FILE' NEWLINES(2) ! ! OUTPUT THE TERMINATION MESSAGE FOR USER INFO ! THIS IS DONE TO THE LISTING FILE FIRST AND THEN IF ! IT IS NOT THE CONSOLE THE MESSAGE IS THERE REPEATED ! %CYCLE %IF FAULTS = 0 %START %PRINTTEXT'NO PROGRAM ENTRY POINT ' %IF START FLAG = 0 WRITE(STATS-1, 8) %PRINTTEXT ' STATEMENTS COMPILED' %FINISH %ELSE %START %PRINTTEXT ' PROGRAM CONTAINS' WRITE(FAULTS, 1) %PRINTTEXT ' FAULT' %PRINTTEXT 'S' %UNLESS FAULTS = 1 %FINISH NEWLINE %EXIT %IF OUT FLAG = 0 OUTFLAG = 0 SELECTOUTPUT(0) %REPEAT %END %ROUTINE WARNING(%STRING (7) TYPE) PRINTSTRING('* WARNING: '.TYPE.' INSERTED ') NOP RT PENDING = 0; LAB ACTIVE = 0 %END %ROUTINE ABORT(%INTEGER N) %SHORTROUTINE ! ! SOME TABLE OR OTHER HAS BEEN FILLED ! SHOW WHAT HAS FAILED AND THEN GET OUT ! %SWITCH BOOB(1 : 9) ! SELECTOUTPUT(0) %PRINTTEXT '*' WRITE(LINES&X'7FFF', 5) %PRINTTEXT ' TOO MANY ' -> BOOB(N) BOOB(1): %PRINTTEXT 'BRANCHES/REGFORMATS' %MONITORSTOP BOOB(2): %PRINTTEXT 'CONSTANTS' %MONITORSTOP BOOB(3): %PRINTTEXT 'INSTRUCTIONS' %MONITORSTOP BOOB(5): %PRINTTEXT 'LARGE ' BOOB(4): %PRINTTEXT 'NAMES' %MONITORSTOP BOOB(6): %PRINTTEXT 'SYMBOLS ON LINE' %MONITORSTOP BOOB(7): %PRINTTEXT 'CONJUNCTS IN STATEMENT' %MONITORSTOP BOOB(8): %PRINTTEXT 'STATEMENTS: OBJECT FILE FULL' %MONITORSTOP BOOB(9): %PRINTTEXT 'LABEL REFERENCES'; %MONITORSTOP %END %ROUTINE FAULT(%INTEGER NUMBER) %SHORTROUTINE %STRING (15) MESS %ROUTINESPEC LINE OUT(%INTEGER SYM) %SWITCH ACTION(0 : 2) %INTEGER J, K, SPCOUNT %BYTEINTEGER TIME TIME = 1 ! ! GIVE THE FAULT MESSAGE ON THE CONSOLE AS WELL IF THAT IS ! NOT THE LISTING FILE ! K = LINE MAX; MARKER = 0 %CYCLE ! ! OUTPUT SOURCE LINE ONTO THE CONSOLE UNLESS IT CAME ! FROM THERE IN THE FIRST PLACE ! %IF TIME = 1 %AND LINES < X'8000' %START %IF NUMBER # 0 %THEN SM = 1000 %ELSE %START %IF SM = NAME FLAG %C %THEN MESS = 'NAME ' %AND SM = NAME FAULT %C %ELSE MESS = 'SYNTAX ' %FINISH TP = 0 LP = 0 FSTART = 1 RECONSTRUCT(1) %FINISH %IF K # LP %OR TIME = 2 %START LINE OUT(' ') %CYCLE J = FSTART, 1, TP PRINTSYMBOL(SYMS(J)) %REPEAT NEWLINE %IF SYMS(TP) # NL SPCOUNT = 0 %FINISH %ELSE SPCOUNT = ROUTINES<<2+2 %IF NUMBER = 0 %START PRINTSTRING('* '.MESS) SPACES(SPCOUNT+MARKER-FSTART) %PRINTTEXT '!'; -> OUT %FINISH LINE OUT('*') PRINTSTRING(STRING(ADDR(FAULT TEXT(FAULT NO(NUMBER))))) -> ACTION(FAULT ACTION(NUMBER)) ACTION(1): PRINTSTRING(' '.CURRENT); -> OUT ACTION(2): ACCESS = 1; -> DONE ACTION(0): OUT: FAULTS = FAULTS+1 %IF TIME = 1 DONE: NEWLINE %EXIT %IF TIME = 2 %OR OUTFLAG = 0 SELECTOUTPUT(0); TIME = 2; ! OUT TO CONSOLE %REPEAT SELECTOUTPUT(OUTSTREAM) %IF TIME = 2; ! BACK TO LISTING FILE LINES = LINES!X'8000'; ! SHOW THE LINE IS FAULTY %ROUTINE LINE OUT(%INTEGER SYM) PRINTSYMBOL(SYM) WRITE(LINES&X'5FFF', 5) %PRINTTEXT ' ' %END %END %INTEGERFN NEWCELL(%INTEGER VAL) %INTEGER R ABORT(9) %IF ASL <= 0; ! NO SPACE LEFT R = ASL; ASL = LINK(R) INFO(R) = VAL; LINK(R) = 0 %RESULT = R %END %ROUTINE PUSH RT(%INTEGERNAME LIST, %INTEGER RT) LIST == LINK(LIST) %WHILE LIST # 0; ! FIND THE END LIST = NEWCELL(RT); ! ADD A NEW CELL %END %INTEGERFN FIND RT(%INTEGERNAME LIST, %INTEGER RT) %INTEGER J J = LIST %WHILE J # 0 %CYCLE; ! LOOK FOR 'RT' %RESULT = 1 %IF INFO(J) = RT; ! FOUND J = LINK(J) %REPEAT %RESULT = 0; ! NOT FOUND %END %INTEGERFN COPY LIST(%INTEGER HEAD) %INTEGER NEW, J NEW = 0 %WHILE HEAD # 0 %CYCLE J = NEWCELL(INFO(HEAD)) HEAD = LINK(HEAD) LINK(J) = NEW NEW = J %REPEAT %RESULT = NEW %END %ROUTINE UPDATE(%INTEGERNAME LIST, %INTEGER VALUE) %INTEGER J %INTEGERNAME PT PT == LIST PT == LINK(PT) %WHILE PT # 0 PT = ASL ASL = LIST J = 0 J = NEWCELL(VALUE) %UNLESS VALUE = 0 LIST = J %END ! ! I WISH THERE WERE PREDICATES IN THE IMPS COMPILERS ! %INTEGERFN LETTER(%INTEGER N) %RESULT = 1 %IF 'A' <= N <= 'Z' %RESULT = 0 %END %ROUTINE RECONSTRUCT(%BYTEINTEGER MODE) %SHORTROUTINE ! ! READ IN A SOURCE LINE AND PERFORM UNDERLINING (%) AND ! SPACE DELETION, AND CONTINUATION CHECKING. ! %INTEGER S %ROUTINESPEC TEST %ROUTINE SYMBOL(%INTEGERNAME N) ! ! INPUTS A SYMBOL AND OUTPUTS IT TO THE LISTING FILE ! IF NESC. ! %IF MODE = 0 %START READSYMBOL(N) TP = TP+1; SYMS(TP) = N PRINTSYMBOL(N) %UNLESS N = NL %OR LIST FLAG = 0 %FINISH %ELSE %START TP = TP+1; N = SYMS(TP) %FINISH %END -> CONT1 %IF MODE # 0 GO: LINES = (LINES)&X'7FFF'+1; ! LOOSE TOP BIT (SET BY FAULT) %IF LIST FLAG # 0 %START; ! NOT GOING TO THE CONSOLE WRITE(LINES, 6); ! GIVE LINE NUMBER SPACES(ROUTINES<<2+4); ! ROUTINE MARGINS %FINISH LP = 0; TP = 0; ! START OF LINE BUFFER PROMPT(' :'); ! DATA PROMPT FOR CONSOLE INPUT CONT1: %CYCLE SYMBOL(S); ! GET A SYMBOL 2: -> CONT1 %IF S = ' '; ! IGNORE SPACES %IF S = '%' %START; ! UNDERLINE MARKER %CYCLE SYMBOL(S); ! NEXT SYMBOL IN -> 2 %IF LETTER(S) = 0; ! NOT A LETTER LP = LP+1 LINE(LP) = S+32; ! CONVERT TO LOWER CASE TEST %IF MODE # 0 %REPEAT %FINISH %IF S = NL %START; ! END OF THIS LINE NEWL: %IF LINE(LP) = PERCC %START; ! CONTINUATION MARKER %PRINTTEXT ' C' %AND SPACES(ROUTINES<<2+4) %C %IF LIST FLAG # 0 %AND MODE = 0 LP = LP-1; ! BACK TO DELETE '%C' ABORT(6) %IF LP >= LINE SIZE;! LINE TOO LONG PROMPT('C:'); ! CONTINUATION PROMPT %RETURN %IF MODE # 0 %AND LP >= SM FSTART = TP+1 %IF MODE # 0 -> CONT1; ! LEAVE LINE NUMBER %FINISH -> CONT1 %IF LP = 0; ! BLANK LINE LP = LP+1 LINE(LP) = NL; ! FILL IN TERMINATOR TEST %IF MODE # 0 LINE MAX = LP NEWLINE %IF LIST FLAG # 0 %AND MODE = 0 ! TIDY THE LISTING %RETURN; ! ALL DONE %FINISH %IF S = '$' %START; ! COMMENT MARKER SYMBOL(S) %UNTIL S = NL; ! DRAIN THE LINE %IF LP = 0 %START; ! BLANK LINE (EFFECTIVELY) NEWLINE %IF LIST FLAG # 0 %AND MODE = 0 -> GO %FINISH -> NEWL %FINISH LP = LP+1 LINE(LP) = S; ! SAVE THE SYMBOL TEST %IF MODE # 0 %REPEAT; ! AROUND FOR MORE %ROUTINE TEST MARKER = TP %IF LP = SM %END %END %INTEGERFN DIGIT(%INTEGER N) %RESULT = 1 %IF '0' <= N <= '9' %RESULT = 0 %END %INTEGERFN NAME FOUND(%BYTEINTEGER OLD) %SHORTROUTINE %INTEGER P, R, L SAVE %RESULT = 0 %UNLESS LETTER(LINE(LP)) # 0 ! MUST START WITH A LETTER L SAVE = LP; ! REMEMBER NAME START FOR ERRORS P = TEXTPT; ! SPACE FOR LENGTH OF TEXT %UNTIL (LETTER(LINE(LP)) = 0 %AND DIGIT(LINE(LP)) = 0) %CYCLE P = P+1 TEXT(P) = LINE(LP); ! PUT NAME IN DICT PER TEM LP = LP+1 %REPEAT ABORT(5) %IF P > MAX TEXT TEXT(TEXTPT) = P-TEXTPT; ! FILL IN LENGTH R = NNAMES CURRENT == STRING(ADDR(TEXT(TEXTPT)));! POINT TO THE NAME ! ! SEE IF THE NAME'S ALREADY IN ! %WHILE R > 0 %CYCLE %EXIT %IF NAME(R)_TEXT = CURRENT; ! FOUND IT R = R-1 %REPEAT %IF R = 0 %START ! ! IT'S A NEW NAME ! %IF OLD # 0 %START; ! OLD NAME WANTED 1: NAMEFLAG = LP NAMEFAULT = L SAVE %RESULT = 0; ! FAILURE %FINISH ! ! INSERT THE NEW NAME ! R = NNAMES+1 ABORT(4) %IF R > MAX NAMES; ! TOO MANY NAMES NNAMES = R NAME(NNAMES)_TEXT == CURRENT TEXTPT = P+1; ! ON TO FREE DICTIONARY SPACE %FINISH %ELSE %START -> 1 %IF OLD # 0 %AND NAME(R)_TAGS_TYPE = 0 %FINISH RP = RP+1 REC(RP) <- R; ! DUMP NAME INDEX IN AREC NAME(R)_TAGS_USED = 1 %IF OLD # 0 %RESULT = 1; ! SUCCESS %END %INTEGERFN CONSTANT FOUND %SHORTROUTINE %INTEGER F, S, BASE, N %BYTEINTEGER PERMIT PERMIT = 0 S = LINE(LP); ! FIRST CHAR OF CONSTANT F = 0; ! FLAG TO DISALLOW '_123' !WITHOUT ANY BASE BASE = RADIX; ! DEFAULT (ALSO BASE BASE !) N = 0; ! FINAL VALUE IN HERE %CYCLE %IF DIGIT(S) # 0 %THEN S = S-'0' %ELSE %START -> 3 %UNLESS LETTER(S) # 0 S = S+10-'A'; ! CONVERT EXTRA DIGITS %FINISH %IF S < BASE %START; ! VALID DIGIT PERMIT = 1 N = N*BASE+S; ! ADD IT IN LP = LP+1 %FINISH %ELSE %START 3: %EXIT %IF S # '_'; ! N CONTAINS THE NEW BASE %RESULT = 0 %IF F = LP; ! '__' FOUND %EXIT %IF F # 0; ! NO BASE GIVEN LP = LP+1 BASE = N; ! RESET BASE N = 0; ! RESET NUMBER F = LP; ! REMEMBER '_' FOUND %FINISH S = LINE(LP) %REPEAT %RESULT = 0 %IF PERMIT = 0 RP = RP+1 REC(RP) <- N; ! DUMP CONSTANT INTO ANALYSIS !RECORD %RESULT = 1; ! SUCCESS %END %INTEGERFN PARSE(%INTEGER ENTRY) %SHORTROUTINE ! ! ENTRY IS A POINTER INTO 'MAIN' WHICH ITSELF POINTS TO ! THE LIST OF COMPONENTS OF THIS PHRASE IN 'SUB'. ! IF THE POINTER IN 'MAIN' IS ZERO THERE ARE NO ALTERNATIVES ! LEFT, SO THE PARSE HAS FAILED (%RESULT=0). ! THE LIST OF ENTRIES IN 'SUB' IS OF THE FORM ! BIP<<12 ! INDEX ! IF THE ENTRY IS ZERO THE END OF THE LIST HAS BEEN FOUND ! AND HENCE THE PARSE IS SUCCESSFUL (%RESULT = 1) ! FOR BIP = 0, INDEX POINTS INTO 'LITERAL' WHERE A LITERAL ! IS STORED IN STRING FORMAT (LENGTH, CHAR1,CHAR2,.....) ! %SWITCH BIP(0 : 15) %INTEGER SP, S, TRP, TLP, P, N, ON TRP = RP; ! SAVE INITIAL VALUE OF RP TLP = LP; ! SAVE INITIAL VALUE OF LP ! UNUSED BIPS: ALL GIVE FAILURE BIP(9): BIP(10): BIP(11): BIP(12): BIP(13): BIP(14): BIP(15): FAILURE: SM = LP %IF LP > SM; ! UPDATE SYNTAX MARKER RP = TRP; ! RESET ANALYSIS RECORD POINTER LP = TLP; ! RESET LINE POINTER ENTRY = ENTRY+1; ! NEXT ALTERNATIVE SP = MAIN(ENTRY); ! PICK IT UP %RESULT = 0 %IF SP = 0; ! NO MORE ALTERNATIVES SUCCESS: ! ALL OK SO FAR SP = SP+1; ! NEXT COMPONENT S = SUB(SP); ! BIP<<12!INDEX %RESULT = 1 %IF S = 0; ! END OF LIST -> BIP(S>>12&15); ! GO TO BUILT-IN PHRASE BIP(1): ! SUB-PHRASE -> SUCCESS %IF PARSE(S&X'FFF') # 0 -> FAILURE BIP(0): ! LITERAL P = LITERAL(S); ! HOLDS TEXT IN STRING FORMAT %CYCLE P = S+1, 1, S+P; ! CYCLE THROUGH SYMBOLS -> FAILURE %IF LINE(LP) # LITERAL(P) LP = LP+1; ! ONTO NEXT SYMBOL IN LINE %REPEAT -> SUCCESS; ! ALL FOUND BIP(4): ! [NAME] -> SUCCESS %IF NAME FOUND(S&7) # 0 -> FAILURE BIP(3): ! [CONSTANT] -> SUCCESS %IF CONSTANT FOUND # 0 -> FAILURE BIP(6): ! [SPDEFN'] -> SUCCESS %IF LINE(LP) = NL; ! NO SUB NAMES -> FAILURE %IF LINE(LP) # '='; ! THIS IS WANTED LP = LP+1 %CYCLE %IF LINE(LP) = '?' %START; ! DON'T CARE LP = LP+1 -> FAILURE %IF LINE(LP) # '('; ! MISSING COUNT LP = LP+1 RP = RP+1 REC(RP) = 1 -> FAILURE %IF CONSTANT FOUND = 0 -> FAILURE %IF LINE(LP) # ')' LP = LP+1 %FINISH %ELSE %START RP = RP+1 REC(RP) = 0 -> FAILURE %IF NAME FOUND(0) = 0 %FINISH %EXIT %IF LINE(LP) = NL; ! END OF LIST -> FAILURE %IF LINE(LP) # ',';! LIST SEPARATOR IS A COMMA LP = LP+1 ! ! BRING IN ANOTHER LINE IF NESC ! RECONSTRUCT(0) %AND LP = 1 %IF LINE(LP) = NL %REPEAT -> SUCCESS BIP(7): ![TEXT] ! ! THIS WILL BE USED FOR MACROS !IN FUTURE ! -> FAILURE BIP(5): ! [NAMELIST] RP = RP+1; ! LEAVE A P = RP; ! HOLE FOR NUMBER OF NAMES ON = S&7; ! OLD/NEW NAME WANTED N = 0; ! COUNTER FOR NUMBER OF NAMES -> FAILURE %UNLESS NAME FOUND(ON) = 1 %CYCLE N = N+1; ! ANOTHER NAME FOUND %EXIT %IF LINE(LP) # ','; ! END OF LIST LP = LP+1; ! PAST COMMA LP = LP-1 %AND %EXIT %UNLESS NAME FOUND(ON) = 1 %REPEAT REC(P) = N; ! FILL IN NUMBER OF NAMES -> SUCCESS BIP(8): ! [SEPARATOR] -> FAILURE %UNLESS LINE(LP) = NL ABORT(7) %IF RP > AREC SIZE; ! LONG ANALYSIS RECORD RP = RP+1; ! NEXT ANALYSIS RECORD SLOT REC(RP) = -1; ! ANALYSIS RECORD TERMINATOR -> SUCCESS BIP(2): ! <> RP = RP+1 REC(RP) = S&X'FFF'; ! FILL IN INDEX -> SUCCESS %END %ROUTINE DUMP(%BYTEINTEGER C, N, OP, D, %SHORTINTEGER AD) %RECORDNAME WORK(CODEFM) ! ! OUTPUT AN INSTRUCTION, PREFIXED BY THE STATEMENT NUMBER ! RT PENDING = 0 %IF C = 1; ! EVOKE WORK == RECORD(ADDR(C)); ! QUICK AND DIRTY TO COPY INFO WORK_STAT <- LINES; ! PLUG IN STATEMENTS LINE NUMBER DUMMY: ! TO STOP THE COMPILER ABORTING OBJECT(CODEIN) = WORK; ! COPY INTO THE OBJECT FILE CODEIN = CODEIN+1; ! ONTO NEXT FREE SLOT ! ! TESTING FOR TOO MANY INSTRUCTIONS IS NOT DONE HERE ! TO SAVE TIME IT IS DONE AT 'NEXT:' IN COMPILE BLOCK ! AT THE START OF EACH NEW STATEMENT. ! ANY OVERWRITING DONE HERE WILL BE NEGLIGIBLE ! %END %ROUTINE DECLARE(%INTEGER NAMES) %SHORTROUTINE ! ! DECLARE 'NAMES' NAMES AS DEFINED BY 'TEMPLATE' ! %RECORDNAME NAMEP(NAMEFM) %INTEGER J, N, T T = MTYPE(TEMPLATE_TYPE) MODUSEAGE(T) = MODUSEAGE(T)+NAMES %UNLESS T = 0 %CYCLE J = 1, 1, NAMES; ! CYCLE THROUGH THE NAMES RP = RP+1 N = REC(RP); ! NAME INDEX NAMEP == NAME(N); ! POINTER TO NAME SLOT TEMPLATE_MASTER = N; ! SHOW WHERE MASTER DEFN IS %IF NAMEP_TAGS_TYPE # 0 %START; ! DEFINED TWICE CURRENT == NAMEP_TEXT; ! POINTER TO TEXT FOR FAULT FAULT(2); ! FAULT 2 => DUPLICATE %FINISH %ELSE NAMEP_TAGS = TEMPLATE %REPEAT %END %ROUTINE FQUAL(%RECORDNAME V) %SHORTROUTINE %RECORDSPEC V(NAMEFM) %CONSTBYTEINTEGERARRAY REG PERMIT(0 : 4) = %C 1, 3, 1, 3, 2 ! ! 2**0 = BREG ALLOWED ! 2**1 = TREG ALLOWED ! %INTEGER N, M %SWITCH FQ(0 : 3) RP = RP+1; -> FQ(REC(RP)) FQ(1): !'_' RP = RP+1; N = REC(RP); ! PREDEFINED NAME INDEX %IF V_TAGS_TYPE # SNAME(N) %START; ! WRONG SUBNAME FAULT(7); ! NO SUBNAME PERMITTED %RETURN %FINISH V_TAGS_BITS = N-17 %IF 18 <= N <= 19; ! _A & _B V_TAGS_TYPE = N; ! UPDATE TYPE %RETURN FQ(2): ! '#' RP = RP+1; N = REC(RP); ! REGISTER WANTED FAULT(8) %UNLESS V_TAGS_TYPE = 4 %AND 0 <= N <= 15 V_TAGS_BITS = N; ! SHOW WHICH ONE V_TAGS_TYPE = 24; ! SHOW A REGISTER %RETURN FQ(3): ! ! FIELD EXTRACTION ! ONLY VALID FIELDS (+ CODE) ARE :- ! 0 : 3 4 BREG ONLY ! 0 : 7 5 ! 0 : 11 6 BREG ONLY ! 0 : 16 7 ! 8 : 16 8 TREG ONLY ! N = REC(RP+1); M = REC(RP+2); ! RP = RP+2 M = 0 %UNLESS 6 <= V_TAGS_TYPE <= 7; ! MUST BE T/B REG %IF N = 0 %START; ! 0 - ?? N = M>>2; ! EXAMINE UPPER M = 0 %UNLESS M&3 = 3 %AND 0 <= N <= 3 %FINISH %ELSE %START; ! ONLY CAN BE 8-15 M = 0 %UNLESS N = 8 %AND M = 15 N = 4 %FINISH FAULT(9) %IF M = 0 %OR REG PERMIT(N)&(V_TAGS_TYPE-1) = 0 V_TAGS_BITS = N+4; ! SAVE FIELD CODE IN 'BITS' FQ(0): ! NULL %END %ROUTINE GPA(%RECORDNAME V) %RECORDSPEC V(NAMEFM) %INTEGER N RP = RP+1; V = NAME(REC(RP)); ! REGISTER NAME RP = RP+1 %IF REC(RP) # 0 %START; ! SUBNAME GIVEN RP = RP+1; N = REC(RP); ! SUBNAME INDEX FAULT(7) %IF SNAME(N) = 0 %OR V_TAGS_TYPE # SNAME(N) V_TAGS_TYPE = N; ! UPDATE TYPE V_TAGS_BITS <- N-17 %FINISH %END %ROUTINE LOCATION(%RECORDNAME V) %SHORTROUTINE %RECORDSPEC V(NAMEFM) %INTEGER N RP = RP+1; N = REC(RP); ! TYPE OF LOCATION %IF N = 2 %START; ! 'BUS' V_TAGS = 0; ! CLEAR IT JUST IN CASE V_TAGS_TYPE = 25; ! SHOW THE BUS %RETURN %FINISH RP = RP+1; V = NAME(REC(RP)); ! PICK UP THE NAME NAME(V_TAGS_MASTER)_TAGS_USED = 1 %IF V_TAGS_TYPE = 24 %IF N = 0 %START; ! [MEMORY] CURRENT == V_TEXT %AND FAULT(16) %IF 13 # V_TAGS_TYPE # 3 V_TAGS_BITS = 9; ! SHOW MEMORY ACCESS %FINISH %ELSE %START FQUAL(V); ! GET QUALIFIERS CURRENT == V_TEXT %AND FAULT(16) %IF DEST(V_TAGS_TYPE) = 0 %FINISH %END %ROUTINE AND FLAGS %SHORTROUTINE %RECORDNAME V(NAMEFM) %INTEGER J, N, OP ! ! OPERATIONS 4 - %CLEAR ! 5 - %SET ! 6 - %COMPLEMENT ! LAB ACTIVE = 0; RT PENDING = 0 %WHILE REC(RP+1) # 0 %CYCLE RP = RP+2; OP = REC(RP); ! CLEAR, SET, COMP RP = RP+1; N = REC(RP); ! NUMBER OF NAMES %CYCLE J = 1, 1, N; ! CYCLE THROUGH NAMES RP = RP+1; V == NAME(REC(RP)); ! GET THE NAME CURRENT == V_TEXT %AND FAULT(17) %IF V_TAGS_TYPE # 2 DUMP(FLAG CODE, V_TAGS_MASTER, OP, 2, 0) %REPEAT %REPEAT %END %INTEGERFN CGEN(%INTEGER N) ! ! PUTS NEW CONSTANTS INTO 'CONSTS' AND RETURNS THEIR POSITION ! %INTEGER P P = CONS; ! NUMBER OF CONSTANTS DEFINED %WHILE P > 0 %CYCLE %RESULT = P %IF CONSTS(P) = N;! ALREADY IN P = P-1; ! BACK TO NECT %REPEAT ! ! NOT IN SO INSERT IT ! CONS = CONS+1; ! ON TO NEXT SLOT ABORT(2) %IF CONS > CONST SIZE; ! TOO MANY CONSTANTS CONSTS(CONS) <- N; ! SAVE IT %RESULT = CONS; ! RETURN INDEX %END %ROUTINE EXPRN %SHORTROUTINE %SWITCH XT(1 : 4) %RECORD LHS, RHS, TEMP(NAMEFM) %INTEGER OP, XTYPE, T, DIV, SOP, OPR, TO OPR = C EVOKE CODE; ! CONTINUE EVOKE SOP = 37; ! STORE BY DEFAULT TO = 3; ! BUS BY DEFAULT RP = RP+1; DIV = REC(RP); ! =20 IF (??)/2 RP = RP+1; XTYPE = REC(RP); -> XT(X TYPE) XT(1): ! 'UNARY' OPERATION RP = RP+1; OP = REC(RP); ! TYPE OF OP GPA(LHS); ! GET REGISTER %IF LHS_TAGS_TYPE # 18 %START; ! NOT AN 'A' REG CURRENT == LHS_TEXT %AND FAULT(13) %UNLESS OP = 3 OP = 4; ! CHANGE B VERSION %FINISH DD: OP = OP+DIV; ! SHOW IF RESULT TO BE HALVED %IF LHS_TAGS_MASTER = DESTN_MASTER %C %AND 18 <= DESTN_TYPE <= 19 %THEN TO = DESTN_TYPE-17 DUMP(EVOKE CODE, LHS_TAGS_MASTER, OP, LHS_TAGS_TYPE, TO) -> STORE XT(2): ! A+B, A&B ETC GPA(LHS); ! GET LEFT OPERAND RP = RP+1; OP = REC(RP); ! OPERATOR %IF OP = 0 %START; ! NON-PSEUDO UNARY RP = RP+1; OP = REC(RP); ! 'REAL' OPERATION GPA(RHS); ! RIGHT OPERAND %IF LHS_TAGS_TYPE = 19 %AND RHS_TAGS_TYPE = 18 %C %AND OP # 15 %START TEMP = LHS; LHS = RHS; RHS = TEMP; ! COMMUTATIVE %FINISH %IF RHS_TAGS_TYPE # 19 %START;! RIGHT MUST BE 'B' REG CURRENT == RHS_TEXT; FAULT(14) %FINISH %ELSE %START CURRENT == LHS_TEXT %AND FAULT(13) %IF LHS_TAGS_TYPE # 18 ! ! BOTH OPERANDS MUST BE FROM THE SAME GPA ! FAULT(12) %IF LHS_TAGS_MASTER # RHS_TAGS_MASTER %FINISH %FINISH %ELSE %START CURRENT == LHS_TEXT %AND FAULT(13) %IF LHS_TAGS_TYPE # 18 %FINISH -> DD XT(3): ! CONSTANT RP = RP+1; T = REC(RP); ! PICK UP CONSTANT %IF T # 0 %THEN DUMP(EVOKE CODE, CGEN(T), 36, 5, 3) %C %ELSE OPR = C EVOKE CODE %C %AND DUMP(EVOKE CODE, 0, 13, 25, 0) ! CLEAR BUS FIRST -> NOD XT(4): ! MEMORY ETC. OP = 0 LOCATION(LHS); T = LHS_TAGS_TYPE OPR = EXTRA EVOKE CODE %AND -> STORE %IF T = 25 ! FROM 'BUS' FAULT(26) %C %IF ((T = 3 %OR T = 13) %AND LHS_TAGS_BITS # 9) %OR T = 27 %C %OR T = 11 OP = T-17 %AND -> DD %UNLESS 18 # T # 19 T = 26 %IF T = 9; ! GPI_IN DUMP(EVOKE CODE, LHS_TAGS_MASTER, 36, T, LHS_TAGS_BITS) %IF T = 24 %AND DESTN_MASTER = LHS_TAGS_MASTER %START ! ! SPR#1 = SPR#2 MUST BE SPLIT INTO TWO EVOKES ! ! DUMP(C EVOKE CODE, 0, 37, 25, 0) SOP = 37 OPR = EXTRA EVOKE CODE WARNING('EVOKE'); CODEIN = CODEIN-1 %FINISH NOD: ! NO DIVISION ALLOWED FAULT(20) %IF DIV # 0 STORE: ! COMPLETE ANY TWO STAGE EXPRESSIONS T = DESTN_TYPE T = 27 %IF T = 9; ! GPI_OUT %IF TO = 3 %THEN DUMP(OPR, DESTN_MASTER, SOP, T, DESTN_BITS) %END %INTEGERFN FLAG NAME(%RECORDNAME V) %SHORTROUTINE %INTEGER R, B, T %RECORDSPEC V(NAMEFM) RP = RP+1; R = REC(RP); ! TYPE OF FLAG %IF R = 0 %START; ! %FLAG OR A BIT GPA(V); ! DEAL WITH NAME RP = RP+1; B = 0 T = 2 T = 4 %IF SNAME(V_TAGS_TYPE) = 12 %IF 30 > V_TAGS_TYPE > 27 %START T = V_TAGS_TYPE-23 %UNLESS V_TAGS_DEFN&X'FF' # 0 %FINISH %IF REC(RP) # 0 %START; ! BIT EXTRACTION GIVEN RP = RP+1; B = REC(RP); ! GIVE BIT FAULT(6) %UNLESS 0 <= B <= 15 %AND BITS(V_TAGS_TYPE) # 0 FAULT(6) %IF V_TAGS_TYPE = 19 %AND B # 0 %AND B # 15 T = 3; T = 1 %IF V_TAGS_TYPE = 25; ! %BUS %FINISH CURRENT == V_TEXT %AND FAULT(17) %IF T = 2 # V_TAGS_TYPE %IF V_TAGS_WHERE = 0 %OR 6 <= V_TAGS_TYPE <= 7 %C %THEN R = (((V_TAGS_MASTER)<<8+V_TAGS_TYPE)<<8+T)<<8+B %C %ELSE R = V_TAGS_WHERE ! FROM 'DEFINE' %FINISH %ELSE %START %IF R = 1 %START ! ! BUS BIT REFERENCE ! RP = RP+1; B = REC(RP) FAULT(6) %UNLESS 0 <= B <= 15 R = X'190300'+B %FINISH %ELSE R = R<<8 %FINISH %RESULT = R %END %ROUTINE COND(%INTEGER FLAG, MASK) ! ! MASK : 1 - IF ! 2 - UNLESS ! 3 - WHILE ! 4 - UNTIL ! DUMP(COND CODE, FLAG>>24, MASK, FLAG>>16&255, FLAG&X'FFFF') %END %ROUTINE NOP %RECORDNAME CC(CODEFM) CC == OBJECT(CODEIN); ! WHERE IT'S GOING CC = 0; CC_STAT <- LINES; ! CLEAR BUT FOR LINES CODEIN = CODEIN+1; ! ALWAYS ONTO FREE SPACE %END %ROUTINE SET BRANCH(%RECORDNAME V) %SHORTROUTINE %RECORDSPEC V(NAMEFM) %IF V_TAGS_USED = 0 %START; ! TABLE NOT YET OUTPUT V_TAGS_USED = 1; ! SHOW TABLE OUTPUT TABCOUNT = TABCOUNT+1; ! GET A NEW TABLE ENTRY V_TAGS_WHERE = TABCOUNT; ! POINT TO IT TABLES(TABCOUNT) = 0; ! CLEAR THE TABLE %FINISH %END %ROUTINE DUMP MERGE(%INTEGER MASTER, USE, ACCESS) %OWNINTEGER LAST MERGE %INTEGER CODE ! ! DUMP A 'C MERGE' IF THE LAST INSTRUCTION ! WAS ANY FORM OF MERGE (FOR THE BENEFIT OF WOMBLE) ! %IF LAST MERGE = CODEIN %THEN CODE = C MERGE CODE %C %ELSE CODE = MERGE CODE DUMP(CODE, MASTER, USE, ACCESS, 0) LAST MERGE = CODEIN; ! REMEMBER WHERE THIS IS %END %ROUTINE COMPILE BLOCK %ROUTINESPEC GET PINS %RECORDNAME TC(CODEFM) %RECORD DV(NAMEFM) %INTEGERNAME NN %SHORTINTEGERNAME SN %INTEGER EN %INTEGER LCOD %INTEGER T, B, N, J, MI, RTLINK %SWITCH PHRASE(-1 : 26) ! ! TOP OF LOOP. TEST HERE FOR TOO MUCH CODE ! NEXT: ABORT(3) %IF CODEIN > CODE LIMIT ! PHRASE(-1): ! RECONSTRUCT(0); ! READ IN THE NEXT LINE LP = 1; ! THE LINE STARTS AT 'LINE(1)' SM = 0; ! ZERO SYNTAX MARKER RP = 0; ! ONTO START OF ANALYSIS RECORD REC(1) = -1; ! IN CASE OF COMMENTS NAME FAULT = 0; NAME FLAG = 0; ! FOR 'NAME NOT DECLARED' FAULT(0) %AND -> NEXT %IF PARSE(0) = 0; ! SYNTAX REC(0) = RP -> NEXT %IF RP = 0; ! NULL ANALYSIS RECORD ! ! OUTPUT THE ANALYSIS RECORD IF WANTED ! %UNLESS CONTROL = 0 %START K = 12; ! COUNTER FOR ITEMS OUTPUT %CYCLE J = 1, 1, RP K = 0 %AND NEWLINE %IF K >= 12 WRITE(REC(J), 5) K = K+1 %REPEAT NEWLINE %UNLESS K = 0 %FINISH RP = 1; ! ANALYSIS RECORD STARTS AT !'REC(1)' PP = REC(1); ! ALTERNATIVE OF SS FOUND STATS = STATS+1 %UNLESS PP = -1; ! IGNORE COMMENTS ETC FAULT(21) %IF ACCESS = 0 %AND ACC(PP) = 1 LCOD = CODEIN; ! REMEMBER CURRENT CODE POINTER -> PHRASE(PP); ! COMPILE THE STATEMENT ! PHRASE(1): ! [NAME] (ACTP') ! DECLARATIONS = 0 RP = RP+1; V == NAME(REC(RP)); ! GET THE NAME TAGS ! NOT A ROUTINE ? %IF 15 # V_TAGS_TYPE # 16 %C %THEN CURRENT == V_TEXT %AND FAULT(11) %AND -> NEXT V_TAGS_USE = V_TAGS_USE+1; ! ONE MORE INPUT TO MERGE CURRENT == V_TEXT %AND FAULT(18) %C %IF ROUTINES > 0 %AND ADDR(V) = ADDR(RTDEFN) ! ! THE SAME ROUTINE MAY NOT BE CALLED TWICE WITHOUT (AT LEAST) ! A NOP INBETWEEN THE CALLS, SO PUT A NOP IN IF NESC. ! AND INFORM THE USER ! %IF LAB ACTIVE # 0 %START %IF LABACTIVE # 8 %C %AND FIND RT(LAB LIST, V_TAGS_MASTER) # 0 %C %THEN WARNING('%NOP') UPDATE(LAB LIST, V_TAGS_MASTER) LAB ACTIVE = 0 %FINISH WARNING('%NOP') %IF RT PENDING = V_TAGS_MASTER RT PENDING = V_TAGS_MASTER T = V_TAGS_DEFN; ! ROUTINE ENTRY POINT DUMP(CALL CODE, RT PENDING, T>>8, T&255, V_TAGS_WHERE) -> DEC ! PHRASE(2): ! (LOCATION) <- (EXPRN) (AND') ! DECLARATIONS = 0 LOCATION(DV); DESTN = DV_TAGS; ! GET DESTINATION FAULT(25) %C %IF DEST N_TYPE = 26 %OR DEST N_TYPE = 10 %OR (DEST N_ %C TYPE = 13 %AND DEST N_BITS = 9) EXPRN; ! GET EXPRESSION AND FLAGS; ! DEAL WITH AND FLAG OPS -> DEC ! PHRASE(3): ! (CONTROL TRANSFER) ! (OPTIONAL CONDITION) ! N = 0; ! SHOW NO COND YET DECLARATIONS = 0 %IF REC(RP+3) # 0 %START T = RP; RP = RP+3; ! SKIP THE TRANSFER N = REC(RP); ! IF - UNLESS EN = FLAG NAME(FLAG INFO); ! GET THE FLAG RP = T; ! RESET RP FOR THE TRANSFER COND(EN, N); ! DUMP THE CONDITION %FINISH %ELSE ACCESS = 0; ! MUST JUMP AWAY RP = RP+1 %IF REC(RP) = 0 %START; ! -> LABEL RP = RP+1; J = REC(RP) V == NAME(J); ! NAME TAGS V_TAGS_USED = 1; ! SHOW USED V_TAGS_TYPE = 14 %IF V_TAGS_TYPE = 0; ! SHOW A LABEL %IF V_TAGS_TYPE # 14 %THEN FAULT(4) %ELSE %START %IF RT PENDING # 0 %START %IF V_TAGS_DEFN = 0 %START PUSH RT(V_TAGS_SIZE, RT PENDING) %FINISH %ELSE %START %IF FIND RT(V_TAGS_SIZE, RT PENDING) # 0 %START %IF N # 0 %START CODEIN = CODEIN-1 OBJECT(CODEIN+1) = OBJECT(CODEIN) WARNING('%NOP') CODEIN = CODEIN+1 %FINISH %ELSE WARNING('%NOP') %FINISH %FINISH %FINISH CURRENT == V_TEXT; ! ONTO NAME FOR FAULTS %IF V_TAGS_DEFN = 0 %START;! UNDEFINED LABEL V_TAGS_MASTER = J %IF V_TAGS_WHERE = 0 WARNING('%NOP') %C %IF N # 0 %AND V_TAGS_WHERE = CODEIN-1 DUMP(JUMP CODE, V_TAGS_MASTER, 0, 0, V_TAGS_WHERE) V_TAGS_WHERE = CODEIN-1;! CHAIN ONTO LABEL LIST %FINISH %ELSE DUMP(JUMP CODE, V_TAGS_MASTER, 0, 0, V_ %C TAGS_WHERE) %FINISH RT PENDING = 0 %IF ACCESS = 0 V_TAGS_USE = V_TAGS_USE+1; ! ANOTHER USE %FINISH %ELSE %START RT PENDING = 0; LAB ACTIVE = 0 %IF REC(RP) = 1 %START; ! %RETURN FAULT(5) %AND -> NEXT %IF ROUTINES = 0 J = CODEIN; ! REMEMBER FOR CHAINING DUMP(JUMP CODE, RTDEFN_TAGS_MASTER, 0, 0, RTLINK) RTLINK = J; ! NEW TOP OF RETURN CHAIN -> NEXT %FINISH DUMP(STOP CODE, 0, 1, 0, 0); ! %STOP %FINISH -> DEC ! PHRASE(4): ! %WAIT (WHILE-UNTIL) (FLAGNAME) ! DECLARATIONS = 0 RP = RP+1; N = REC(RP)+2; ! WHILE/UNTIL EN = FLAG NAME(FLAG INFO); ! GET TEST FLAG T = CODEIN; ! REMEMBER FOR THE JUMP DUMP MERGE(0, 2, ACCESS); ! INTERNAL 'LABEL' NOP; ! WAIT LOOPS MUST HAVE AN EVOKE COND(EN, N); ! SET THE CONDITION DUMP(JUMP CODE, 0, 0, 0, T); ! JUMP BACK -> DEC ! PHRASE(5): ! (FLAG OPERATION) [NAMELIST] ! DECLARATIONS = 0 NOP; ! ALL FLAGS MUST BE EVOKED RP = RP-1; AND FLAGS; ! DEAL WITH THE FLAGS -> DEC ! PHRASE(6): ! (TYPE) [NAMELIST] ! TEMPLATE = 0 RP = RP+1 TEMPLATE_TYPE = REC(RP); ! DEFINE TYPE RP = RP+1 DECLARE(REC(RP)); ! DECLARE THE NAMES -> NEXT ! PHRASE(7): ! (ROM-MEMORY) [NAMELIST] (SIZE) ! ! TEMPLATE = 0 %UNTIL REC(RP) = 0 %CYCLE RP = RP+1; TEMPLATE_TYPE = REC(RP); ! ROM-MEMORY RP = RP+1; N = REC(RP); ! SIZE OF MEMORY TEMPLATE_SIZE = REC(RP+N+1)*REC(RP+N+2) DECLARE(N) RP = RP+3; ! ONTO NEXT NAME %REPEAT -> NEXT ! PHRASE(8): ! %TREG [NAME] (PIN DEFINITION) ! TEMPLATE = 0; TEMPLATE_TYPE = 7; DECLARE(1) GETPINS; -> NEXT ! PHRASE(9): ! %SPR [NAME] [SPDEFN'] ! TEMPLATE = 0; TEMPLATE_TYPE = 4; DECLARE(1) MI = 0; ! NAMES DEFINED %CYCLE RP = RP+1 %IF REC(RP) < 0 %START; ! END OF LIST FAULT(28) %IF MI > 16; ! TOO MANY NAMES -> NEXT %FINISH %IF REC(RP) # 0 %START; ! A DON'T CARE RP = RP+1 MI = MI+REC(RP); ! INCREASE BY (N) %FINISH %ELSE %START; ! NAME GIVEN RP = RP+1 V == NAME(REC(RP)); ! GET THE NAME %IF V_TAGS_TYPE # 0 %START;! ALREADY EXISTS CURRENT == V_TEXT; ! ONTO NAME TEXT FAULT(2); ! DUPLICATE %FINISH %ELSE %START; ! A VALID NEW NAME V_TAGS_MASTER = TEMPLATE_MASTER; ! COPY INFO V_TAGS_TYPE = 24; ! SHOW A REGISTER V_TAGS_BITS <- MI&X'F'; ! SHOW ITS ADDRESS FAULT(28) %IF MI > 16; ! TOO MANY NAMES MI = MI+1; ! ONE MORE FOUND %FINISH %FINISH %REPEAT ! PHRASE(10): ! %DEFINE (EQITEM) (RDEFINE') ! FAULT(24) %IF ROUTINES > 0 %BEGIN %SHORTROUTINE %SWITCH EQ(0 : 3) %UNTIL REC(RP) = 0 %CYCLE; ! CYCLE THROUGH DEFINITION LIST RP = RP+1; V == NAME(REC(RP)); ! GET NEW NAME CURRENT == V_TEXT %AND FAULT(2) %IF V_TAGS_TYPE # 0 RP = RP+1; MI = REC(RP); ! TYPE OF EQITEM -> EQ(MI) EQ(0): ! [OLD NAME](FQUAL') RP = RP+1 EN = REC(RP); ! OLD NAME DV = NAME(EN); ! OLD NAME INFO CURRENT == DV_TEXT %AND FAULT(1) %IF DV_TAGS_TYPE = 0 FQUAL(DV); ! GET ANY EXTRAS V_TAGS = DV_TAGS; ! COPY TAGS FAULT(4) %IF DV_TAGS_TYPE = 8 %OR 14 <= DV_TAGS_TYPE <= 15 -> CONT EQ(1): ! FLAG MI = FLAG NAME(DV); ! FLAG DEFN FOR 'AND FLAGS' DV_TAGS_WHERE = MI DV_TAGS_TYPE = 2; ! TYPE = FLAG V_TAGS = DV_TAGS; ! COPY INFO -> CONT EQ(2): ! '*' SOMETHING RP = RP+1; MI = REC(RP) V_TAGS_TYPE = MI RP = RP+1 %IF MI = 30 %START V_TAGS_WHERE = REC(RP) FAULT(27) %UNLESS 0 <= REC(RP) <= 7 %OR REC(RP) = 9 RP = RP+1 %FINISH FAULT(6) %UNLESS 0 <= REC(RP) <= 15 ! INVALID BIT V_TAGS_DEFN = REC(RP)<<8 RP = RP+1 FAULT(6) %UNLESS 0 <= REC(RP) <= 15 ! INVALID BIT FAULT(6) %IF REC(RP) # 0 %AND REC(RP) <= V_TAGS_DEFN>>8 V_TAGS_DEFN = V_TAGS_DEFN+REC(RP) -> CONT EQ(3): ! BUS DV_TAGS = 0; ! CLEAR IT FIRST DV_TAGS_TYPE = 25; ! SHOW IT'S A BUS RP = RP+1 %IF REC(RP) # 0 %START; ! BIT DEFINED RP = RP+1; MI = REC(RP); ! GET THE BIT MI = 0 %AND FAULT(6) %UNLESS 0 <= MI <= 15 DV_TAGS_TYPE = 2; ! IT'S A FLAG NOW DV_TAGS_WHERE = X'190300'+MI %FINISH V_TAGS = DV_TAGS CONT: RP = RP+1 V_TAGS_USED = 0; ! MAKE SURE UNUSED %REPEAT %END -> NEXT ! PHRASE(11): ! %ROUTINE [NAME] ! RTLINK = 0; ! LINK TO CHAIN RETURN CALL !TOGETHER ACCESS = 1; ! CALL MUST GIVE ACCESS ROUTINES = ROUTINES+1; ! INCREASE ROUTINE LEVEL (ONLY !ONE ALLOWED) FAULT(24) %IF DECLARATIONS = 0 %AND ROUTINES = 1 FAULT(5) %IF ROUTINES > 1 TEMPLATE = 0 TEMPLATE_TYPE = 15 TEMPLATE_WHERE = CODEIN; ! ENTRY ADDRESS DECLARE(1) RTDEFN == NAME(REC(RP)) RTDEFN_TAGS_DEFN = 0 DUMP MERGE(RTDEFN_TAGS_MASTER, 0, 0) -> NEXT ! PHRASE(12): ! %END (FILE') ! NEWLINE RT PENDING = 0; LAB ACTIVE = 0 DECLARATIONS = 1; ! ALLOW DECLARATIONS AFTER !ROUTINES %IF REC(RP+1) # 0 %THEN STOP %AND %RETURN; ! ENDOFFILE %IF ROUTINES = 0 %THEN FAULT(10) %AND -> NEXT ROUTINES = ROUTINES-1; ! DOWN A LEVEL RTDEFN_TAGS_SIZE = RTDEFN_TAGS_SIZE+1 J = ACCESS; ! IMMEDIATE WAYS HERE (FOR !MERGE) %WHILE RTLINK # 0 %CYCLE J = J+1; ! INCREASE MERGE COUNT TC == OBJECT(RTLINK); ! POINTER TO '%RETURN' RTLINK = TC_ADDR; ! DOWN THE CHAIN TC_ADDR = CODEIN; ! FILL IN ADDRESS OF HERE %REPEAT DUMP MERGE(0, J, ACCESS) %IF J > 1 ! MERGE THE JUMPS NN == RTDEFN_TAGS_DEFN; ! POINTER TO CALL LIST DUMP(RETURN CODE, 0, NN>>8, NN&255, RTDEFN_TAGS_MASTER) NN = CODEIN-1; ! LINK ONTO CALL LIST ACCESS = 1; ! YOU CAN'T GET HERE !!! -> NEXT ! PHRASE(13): ! %MACRO [NAME] (MACRO !PARAMETERS') %PRINTTEXT '**IGNORED** ' FAULT(24) %IF DECLARATIONS = 0 %AND ROUTINES = 1 -> NEXT ! PHRASE(14): ! %BRANCH [NAME] ( (LEVEL) , ! !(LEVEL),(LEVEL) ) DECLARATIONS = 0; ! ALLOW NO MORE DECS ACCESS = 0; ! IT CAN'T FALL THROUGH RP = RP+1; V == NAME(REC(RP)); ! GET BRANCH NAME V_TAGS_MASTER = REC(RP) %IF V_TAGS_TYPE = 0 %THEN V_TAGS_TYPE = 8 CURRENT == V_TEXT %AND FAULT(2) %IF V_TAGS_TYPE # 8 %IF RT PENDING # 0 %START %IF FIND RT(V_TAGS_SIZE, RT PENDING) # 0 %C %THEN WARNING('%NOP') %C %ELSE PUSH RT(V_TAGS_SIZE, RT PENDING) RT PENDING = 0; LAB ACTIVE = 0 %FINISH SET BRANCH(V); ! DEFINE BRANCH TABLE %IF V_TAGS_DEFN # 0 %START CURRENT == V_TEXT FAULT(3) %FINISH V_TAGS_DEFN = 1 DUMP(BRANCH CODE, V_TAGS_MASTER, 0, 0, V_TAGS_WHERE) %CYCLE J = 1, 1, 3; ! PICK UP LEVELS RP = RP+1; B = REC(RP)<<8; ! LEVEL TYPE B = FLAG NAME(FLAG INFO) %IF B = 0 ! FLAG, NOT '%HIGH' OR '%LOW' DUMP(TEST CODE, B>>24, 0, B>>16&255, B&X'FFFF') %REPEAT -> NEXT ! PHRASE(15): ! (LABEL) : (SS) ! DECLARATIONS = 0 RP = RP+1; J = REC(RP); ! LABEL NAME V == NAME(J); ! POINTER TO LABEL INFO RP = RP+1; T = REC(RP); ! LABEL - BRANCH V_TAGS_TYPE = T %IF V_TAGS_TYPE = 0 K = V_TAGS_WHERE %IF V_TAGS_TYPE # T %START DUPL: CURRENT == V_TEXT; FAULT(2); -> NEXT %FINISH V_TAGS_MASTER = J; ! DEFINE MASTER TAGS %IF T = 8 %START; ! BRANCH LABEL RP = RP+1; N = REC(RP); ! INDEX B = 1< NEXT %C %UNLESS 0 <= N <= 7 %AND V_TAGS_BITS&B = 0 V_TAGS_BITS = V_TAGS_BITS!B; ! SHOW THIS INDEX USED SET BRANCH(V); ! OUTPUT TABLE (IF NESC.) TABLES(V_TAGS_WHERE)_W(N) = CODEIN;! SET ADDRESS %FINISH %ELSE %START; ! ORDINARY LABEL -> DUPL %IF V_TAGS_DEFN # 0 V_TAGS_DEFN = 1; ! SHOW DEFINED J = V_TAGS_WHERE; ! GET PREV USE LIST %WHILE J # 0 %CYCLE; ! FILL IN ADDRESSES SN == OBJECT(J)_ADDR; ! POINTER TO JUMP J = SN; ! DOWN CHAIN SN = CODEIN; ! SET ADDRESS OF HERE %REPEAT V_TAGS_WHERE = CODEIN; ! DEFINE ADDRESS MI = V_TAGS_USE+ACCESS; ! WAYS TO GET HERE %FINISH DUMP MERGE(V_TAGS_MASTER, MI, ACCESS) V_TAGS_USE = MI; ! SHOW HOW MANY ENTRIES %IF K = 0 %START %IF LAB ACTIVE # 0 %C %THEN V_TAGS_SIZE = COPY LIST(LAB LIST) %C %ELSE V_TAGS_SIZE = 0 %FINISH LAB LIST == V_TAGS_SIZE LAB ACTIVE = T ACCESS = 1; ! YOU CAN GET HERE RP = RP+1 -> PHRASE(REC(RP)); ! ON TO REST OF STATEMENT ! PHRASE(16): ! %BREAKPOINT [NAME] ! DECLARATIONS = 0 TEMPLATE = 0 TEMPLATE_TYPE = 17 TEMPLATE_USED = 1 DECLARE(1) DUMP(BREAK CODE, REC(RP), 0, 0, 0) -> DEC ! PHRASE(17): ! EXTERNAL ! -> NEXT ! PHRASE(18): ! CONTROL ! RP = RP+1; N <- REC(RP) DISPLAY %AND -> NEXT %IF N = 7 SHOW LISTS %AND -> NEXT %IF N = 100 CONTROL <- N -> NEXT ! PHRASE(19): ! CGEN ! ! PHRASE(20): ! MODULE ! -> NEXT ! PHRASE(21): ! %CLEAR BUS ! DECLARATIONS = 0 DUMP(EVOKE CODE, 0, 13, 25, 0) DUMP(C EVOKE CODE, 0, 37, 25, 0) RT PENDING = 0; LAB ACTIVE = 0 -> DEC ! PHRASE(22): ! %NOP ! DECLARATIONS = 0 NOP RT PENDING = 0; LAB ACTIVE = 0 -> DEC ! PHRASE(23): !%REGFORMAT [NAME] ( [CONSTANT] ! !(PINLIST') ) TEMPLATE = 0 TABCOUNT = TABCOUNT+1 ABORT(1) %IF TABCOUNT > TABLE SIZE TEMPLATE_WHERE = TABCOUNT TEMPLATE_TYPE = REG FORMAT DECLARE(1) PINDEF -> NEXT ! PHRASE(24): !%BREG [NAME] (PINDEFINITION) ! TEMPLATE = 0 TEMPLATE_TYPE = 6 DECLARE(1) GET PINS; -> NEXT ! PHRASE(25): ! %RADIX [CONSTANT] ! RP = RP+1; N <- REC(RP) %IF N > 0 %THEN RADIX = N %ELSE FAULT(8) -> NEXT ! PHRASE(26): ! %ENABLE ! RP = RP+1; V == NAME(REC(RP)) CURRENT == V_TEXT %AND FAULT(17) %UNLESS V_TAGS_TYPE = 12 ! SI DUMP(EVOKE CODE, V_TAGS_MASTER, 35, 12, 0) AND FLAGS -> NEXT DEC: %IF ROUTINES = 0 %START DECLARATIONS = 0 STARTFLAG = 1 %AND HEADER_STARTAD = LCOD %IF STARTFLAG = 0 %FINISH -> NEXT %ROUTINE GET PINS %SHORTROUTINE RP = RP+1 %UNLESS REC(RP) = 0 %START %IF REC(RP) = 1 %START RP = RP+1 V == NAME(REC(RP)) CURRENT == V_TEXT %AND FAULT(30) %C %UNLESS V_TAGS_TYPE = REG FORMAT TEMPLATE_WHERE = V_TAGS_WHERE V_TAGS_USED = 1 %FINISH %ELSE %START TABCOUNT = TABCOUNT+1 PINDEF TEMPLATE_WHERE = TABCOUNT %FINISH %FINISH NAME(TEMPLATE_MASTER)_TAGS_WHERE = TEMPLATE_WHERE %END %END ! !******************* START HERE BY INITIALIZING ********************* ! LIST FLAG = 0; OUT FLAG = 0 ! ! UNTANGLE PARAMETERS ! LIST FILE = '' OBJECT FILE = '' INFILE = '' %IF FILES # '' %START INFILE = FILES %IF FILES -> INFILE.('/').OBJECT FILE %START LIST FILE = '' %C %UNLESS OBJECT FILE -> OBJECT FILE.(',').LIST FILE %FINISH %FINISH INFILE = DEFAULT IN %IF INFILE = '' OBJECT FILE = DEFAULT OBJECT %IF OBJECT FILE = '' LIST FILE = DEFAULT LIST %IF LIST FILE = '' OUT FLAG = 1 %IF LIST FILE # '.TT' LIST FLAG = 1 %IF IN FILE # '.TT' PRINTSTRING('PARAMS:'.FILES.' ? ') %AND %RETURN %C %IF IN FILE = LIST FILE %OR IN FILE = OBJECT FILE %C %OR OBJECT FILE = LIST FILE ! ! SET UP THE RELEVANT STREAMS ! SAFETY FILE = '' %IF INFILE = '.TT' DEFINE('STREAM40,'.INFILE.SAFETY FILE) DEFINE('STREAM41,'.LISTFILE) ! ! CREATE THE OBJECT FILE & CONNECT IT ! CONNECT = 0 FDP(3, OBJECT FILE, 0, 0, FLAG); ! DESTROY IT IN CASE TOO SMALL FDP(4, OBJECT FILE, 3, ADDR(CONNECT), FLAG) %IF FLAG # 0 %START; ! FDP HAS FAILED PRINTSTRING('CANNOT CREATE '.OBJECT FILE) WRITE(FLAG, 1) NEWLINE %RETURN %FINISH SELECTINPUT(INSTREAM); ! SOURCE FILE SELECTOUTPUT(OUT STREAM); ! LISTING FILE %IF OUTFLAG = 1 %START PRINTSTRING(' SOURCE FILE: '.INFILE.' COMPILED: '. %C DATE.' '.TIME) PRINTSTRING(' OBJECT FILE: '.OBJECT FILE.' ') %FINISH PRINTSTRING(VERSION.' ') ! ! NOW SET UP THE MAPPING TO THE SYSTEM STANDARD OBJECT FILE ! THIS CODE IS DUPLICATED IN ALL PROGRAMS WORKING ON ! ARTHUR FILES IN ORDER TO SIMPLIFY MODIFYING ! THE FORMAT OF THE OBJECT FILE, AS THEN ALL THAT ! NEEDS TO BE ALTERED IS THE FORMAT 'HEADERFM' ! FILE END = CONNECT+4095*16; ! 1 SEGMENT FILE SYS HEADER == RECORD(CONNECT); ! SYSTEM FILE HEADER HEADER == RECORD(CONNECT+16); ! ARTHUR FILE HEADER HEADER = 0; ! CLEAR IT TO REMOVE RUBBISH SYSHEADER_SIZE = 0; ! FAULTY MARKER SYSHEADER_LD = -1; ! SHOW IT'S A WIERD FILE ! MAX NAMES = (MAX NAMES+3)&(\3); ! MUST BE MULTIPLE OF 4 NNAMES == HEADER_NNAMES; ! POINTER FOR NUMBER OF NAMES HEADER_OLD FILE = CONNECT; ! OLD FILE HEAD FOR 'TRANS' CONNECT = CONNECT+HEADER LENGTH; ! PAST ARTHUR FILE HEADER MODUSEAGE == ARRAY(CONNECT, MUFM); ! MODULE USEAGE COUNTERS HEADER_USEAGE = CONNECT-ADDR(HEADER) CONNECT = CONNECT+64; ! SPACE FOR MODUSEAGE NAME == ARRAY(CONNECT, NAFM); ! NAME TAGS ARRAY HEADER_NAMES = CONNECT-ADDR(HEADER); ! START OF NAMES J = CONNECT+24*MAX NAMES; ! PAST NAME TABLE TEXT == ARRAY(J, TXT1); ! DICTIONARY FOR NAMES HEADER_TEXT = J-ADDR(HEADER); ! POINTER TO DICTIONARY WHERE = (MAX TEXT+3)&(\3)+J; ! PAST DICTIONARY EXTERNALS == ARRAY(WHERE, EXTARFM); ! EXTERNAL EVENT INFO HEADER_EXTERNS = WHERE-ADDR(HEADER); ! START OF EXTERNALS EXTERNAL LENGTH = (EXTERNAL LENGTH+3)&(\3) WHERE = WHERE+4*EXTERNAL LENGTH OBJECT == ARRAY(WHERE, CFM); ! START OF OBJECT CODE HEADER_CODE = WHERE-ADDR(HEADER) ! ! INITIALIZE NAME TABLE ! %CYCLE J = 1, 1, MAX NAMES NAME(J) = 0 %REPEAT OBJECT(0) = 0; ! SPECIAL FOR LABELS CONS = 0; ! COUTER FOR NUMBER OF CONSTANTS HEADER_STARTAD = 0; ! PROGRAM ENTRY POINT TABCOUNT = 0; ! NUMBER OF TABLES CODEIN = 1; ! WHERE TO START DUMPING CODE LINES = 0; ! LINES COMPILED STATS = 0; ! STATEMENTS COMPILED FAULTS = 0; ! FAULTY STATEMENT COUNTER HEADER_TXTLNG = 0; ! DICTIONARY SIZE TEXTPT == HEADER_TXTLNG; ! FREE DICTIONARY SPACE NNAMES = 0; ! NUMBER OF NAMES DECLARED FLAG = 0; ! FUNNY FLAG STARTFLAG = 0; ! SHOWS IF AN ENTRY POINT HAS !BEEN DEFINED CONTROL = 0; ! DYNAMIC COMPILER OPTIONS DECLARATIONS = 1; ! FLAG FOR DECLARATIONS !MISPLACED ROUTINES = 0; ! ROUTINE LEVEL COUNTER ACCESS = 1; ! FLAG FOR ACCESS INDICATION RT PENDING = 0; LAB ACTIVE = 0 %CYCLE J = 0, 1, 20; MODUSEAGE(J) = 0 %REPEAT %CYCLE ASL = 1, 1, LIST SIZE LINK(ASL) = ASL-1 %REPEAT COMPILE BLOCK; ! OFF TO THE WARS %END %ENDOFFILE @@@@@@@@@@@@@@@ %CONSTSHORTINTEGERARRAY SMAIN(1: 141) = %C 1, 0, 4, 8, 12, 15, 19, 25, 30, 35, 39, 43, 47, 50, 54, 58, 63, 69, 74, 79, 84, 88, 92, 96, 100, 104, 108, 112, 115, 116, 120, 0, 122, 125, 0, 128, 131, 0, 135, 137, 0, 139, 141, 0, 143, 147, 0, 149, 154, 0, 156, 0, 159, 164, 0, 166, 169, 0, 171, 174, 177, 180, 183, 186, 0, 189, 194, 0, 196, 198, 0, 200, 202, 0, 204, 207, 210, 0, 213, 215, 0, 217, 221, 222, 225, 226, 230, 0, 232, 238, 242, 0, 245, 249, 253, 260, 0, 262, 0, 265, 268, 0, 270, 273, 276, 279, 0, 282, 286, 289, 292, 295, 298, 0, 300, 305, 0, 307, 310, 313, 0, 316, 322, 0, 324, 0, 330, 335, 0, 337, 340, 343, 346, 349, 352, 355, 0, 358, 360, 363, 0 %CONSTSHORTINTEGERARRAY SSUB(2: 365) = %C 4098,-32768, 0, 1, 8193, 4164, 0, 10, 8193, 4164, 0, 12, 8195, 0, 15, 8196, 4131, 0, 21, 8198, 4184, 4161, 4167, 0, 25, 8199, 4146, 4148, 0, 27, 8201, 4128, 4161, 0, 29, 8203, 4167, 0, 34, 8204, 4134, 0, 41, 8205, 4134, 0, 49, 8206, 0, 58, 8207, 4125, 0, 65, 8208, 4140, 0, 71, 8209, 4137, 4143, 0, 8194, 4128, 4174, 4233, 12288, 0, 8197, 4213, 20481, 4217, 0, 76, 8200, 16385, 4177, 0, 81, 8202, 4220, 4222, 0, 88, 8210, 12288, 0, 96, 8210, 8192, 0, 101, 8210, 8198, 0, 107, 8210, 8199, 0, 113, 8210, 8196, 0, 119, 125, 8213, 0, 129, 8215, 12288, 0, 135, 8216, 16385, 0, 8193, 4128, 4161, 0, 8192, 0, 8192, 4184, 0, 8193, 138, 0, 142, 8192, 0, 146, 8193, 4167, 0, 20481, 0, 8192, 0, 12288, 0, 8192, 0, 8193, 12288, 4143, 0, 8192, 0, 149, 8193, 12288, 4143, 0, 8192, 0, 4128, 4151, 0, 149, 8193, 4146, 4148, 0, 8192, 0, 4154, 12288, 0, 8192, 0, 151, 8193, 0, 27, 8194, 0, 153, 8195, 0, 156, 8196, 0, 159, 8197, 0, 161, 8198, 0, 149, 8193, 4128, 4161, 0, 8192, 0, 12288, 0, 8192, 0, 4170, 0, 8192, 0, 163, 8193, 0, 167, 8194, 0, 8195, 16384, 0, 171, 0, 151, 0, 174, 12288, 4179, 176, 0, 149, 12288, 4179, 0, 10, 8193, 12288, 0, 8192, 0, 178, 8192, 16385, 4181, 180, 0, 8193, 16385, 4188, 0, 8194, 4203, 0, 182, 8193, 4225, 0, 27, 8194, 12288, 0, 159, 8195, 12288, 10, 12288, 161, 0, 8192, 0, 16385, 4195, 0, 182, 4225, 0, 8192, 0, 184, 8201, 0, 188, 8202, 0, 191, 8203, 0, 194, 8204, 0, 8192, 4193, 4210, 0, 197, 8202, 0, 202, 8203, 0, 211, 8204, 0, 220, 8201, 0, 4198, 0, 159, 8193, 12288, 161, 0, 8192, 0, 229, 8195, 0, 119, 8196, 0, 233, 8197, 0, 244, 8193, 4213, 20480, 4217, 0, 8192, 0, 16384, 151, 16385, 4188, 4210, 0, 149, 8193, 4220, 4222, 0, 8192, 0, 248, 8210, 0, 250, 8211, 0, 252, 8213, 0, 255, 8214, 0, 258, 8218, 0, 261, 8219, 0, 265, 8223, 0, 272, 0, 274, 8193, 0, 8192, 0 %CONSTBYTEINTEGERARRAY SLITERAL(1: 275) = %C 8, 99, 111, 110, 116, 105, 110, 117, 101, 1, 58, 2, 103, 111, 5, 116, 114, 97, 99, 101, 3, 109, 97, 112, 1, 63, 1, 35, 4, 100, 117, 109, 112, 6, 105, 103, 110, 111, 114, 101, 7, 114, 101, 112, 108, 97, 99, 101, 8, 101, 110, 100, 111, 102, 115, 105, 109, 6, 99, 97, 110, 99, 101, 108, 5, 98, 114, 101, 97, 107, 4, 102, 114, 101, 101, 4, 116, 114, 101, 103, 6, 100, 101, 102, 105, 110, 101, 7, 99, 111, 110, 116, 114, 111, 108, 4, 102, 117, 108, 108, 5, 113, 117, 105, 101, 116, 5, 110, 97, 109, 101, 115, 5, 116, 114, 97, 112, 115, 5, 99, 108, 101, 97, 114, 3, 98, 117, 115, 5, 114, 97, 100, 105, 120, 2, 45, 62, 3, 66, 85, 83, 3, 111, 102, 102, 2, 111, 110, 1, 44, 1, 61, 2, 62, 61, 2, 60, 61, 1, 60, 1, 62, 3, 46, 84, 84, 3, 46, 76, 80, 2, 60, 45, 1, 40, 1, 41, 1, 91, 1, 93, 1, 95, 3, 79, 86, 70, 2, 68, 90, 2, 68, 80, 2, 68, 78, 4, 90, 69, 82, 79, 8, 80, 79, 83, 73, 84, 73, 86, 69, 8, 78, 69, 71, 65, 84, 73, 86, 69, 8, 79, 86, 69, 82, 70, 76, 79, 87, 3, 115, 101, 116, 10, 99, 111, 109, 112, 108, 101, 109, 101, 110, 116, 3, 97, 110, 100, 1, 65, 1, 66, 2, 75, 70, 2, 80, 70, 2, 73, 78, 3, 79, 85, 84, 6, 79, 86, 69, 82, 85, 78, 1, 43, 1, 45 %CONSTSTRING (31) VERSION = ' SAM : VERSION 3.8' ! ! EXTERNAL SPECS ! %EXTERNALROUTINESPEC PROMPT(%STRING (15) S) %EXTERNALROUTINESPEC DEFINE(%STRING (63) X) %EXTERNALINTEGERFNSPEC TESTINT(%INTEGER C, %STRING (15) X) %EXTERNALROUTINESPEC MOVE(%INTEGER LENGTH, FROM, TO) %SYSTEMROUTINESPEC FDP(%INTEGER X, %STRING (17) S, %C %INTEGER A, N, %INTEGERNAME F) ! ! RECORDFORMATS ! %RECORDFORMAT HEADERFM( %C %INTEGER IDEN, USEAGE, NNAMES, NAMES, TEXT, CODE, %C CONSTANTS, OLD FILE, TXTLNG, STARTAD, EXTERNS, TABS) %RECORDFORMAT TABFM(%SHORTINTEGERARRAY W(0 : 7)) %RECORDFORMAT EXTERNFM(%BYTEINTEGER FROM, FBITS, TO, TOBITS) %RECORDFORMAT SYSHEADFM(%INTEGER SIZE, HEADSIZE, MAX, LD) %RECORDFORMAT CODEFM(%BYTEINTEGER CODE, NAME, OPRN, MODULE, %C %SHORTINTEGER ADDR, STAT) %RECORDFORMAT TAGFM(%INTEGER MASTER, %SHORTINTEGER TYPE, %C %BYTEINTEGER USED, BITS, %INTEGER USE, DEFN, SIZE, WHERE) %RECORDFORMAT NAMEFM(%STRINGNAME TEXT,%RECORD TAGS(TAGFM)) %RECORDFORMAT BRKFM(%INTEGER COUNT, IGNORE) %RECORDFORMAT IOBUFFM(%BYTEINTEGER OWNER, TYPE, %C %SHORTINTEGER PT, SYMS, %BYTEINTEGERARRAY TEXT(1 : 64)) %RECORDFORMAT MODFM(%SHORTINTEGER A, B, F1, F2, F3, F4, FLAG) %RECORDFORMAT MEMODFM(%SHORTINTEGER MEMADDR, LIMIT, %C %SHORTINTEGERARRAYNAME STORE) %RECORDFORMAT RTFM(%INTEGER RA, LASTRT) %RECORDFORMAT CONDFM(%SHORTINTEGERNAME W, %C %SHORTINTEGER TEST,COUNT, %BYTEINTEGER COND, FLAG, FIRED%C ,%RECORD DESC(NAMEFM)) %RECORDFORMAT BUSFM(%SHORTINTEGER BUSREG, OVF, DZ, DN, DP) %RECORDFORMAT TREG LIST FM(%BYTEINTEGERARRAY BIT(0 : 15)) ! ! EXTERNAL ARRAYS CONTAINING PHRASE STRUCTURE ! ! ! CONSTS ! %CONSTBYTEINTEGERARRAY Q(0 : 40) = %C 0,0,1,1,1,0,1,1,0,0,1,1,1,0(5),1,1,0,1,1,1,1,1,1,1,1,1, 1,1,0(9) %CONSTSHORTINTEGERARRAY MTYPE(0 : 40) = %C %C 0,1,14,13,12,7,11,10,0,3,5,4, 6,9,0(10),12,2,0(15) %CONSTBYTEINTEGERARRAY DEST(0 : 40) = %C 0,0,0,1,0,0,1,1,0,1, 1,1,1,1,0,0,0,0,1,1, 0,1,1,1,1,1,1,1,0(13) %CONSTBYTEINTEGERARRAY MODTY(0 : 40) = %C 0,1,1,2,2,2,1,1,0,1,1,1,1,2,0(11),1,0,0,0(13) %CONSTINTEGER MAX NAMES = 100; ! MAX NUMBER OF NAMES %CONSTINTEGER MAX TEXT = 600; ! MAX LENGTH OF TEXT ARRAY %CONSTINTEGER EXTERNAL LENGTH = 100; ! MAX LENGTH FOR EXTERNAL EVENT ARRAY %CONSTSTRING (7) WORK FILE = 'SS#WORK' %CONSTSTRING (8) DATA BUS = 'DATA BUS' %CONSTSTRING(31) %ARRAY MODNAMES(0:40)=%C '','%GPA','%FLAG','%MEMORY','%SPM','%CGEN','%BREG', '%TREG','8-WAY BRANCH','%GPINT','%ININT','%OUTINT', '%SINT','%ROM','PROGRAM LABEL','%ROUTINE','%MACRO', '%BREAKPOINT','%GPA ''A'' REG','%GPA ''B'' REG', '%MODULE','%SINT KB FLAG','%SINT PUNCH FLAG', 'REGISTER','%SPM REG','%BUS','%GPINT INPUT REG', '%GPINT OUTPUT REG','SWITCH','DATA SWITCH','LIGHT', '%SINT OVERUN FLAG','%REGFORMAT',''(8) %CONSTSTRING (3) %ARRAY BUSFLNM(9 : 12) = %C 'OVF','DZ','DP','DN'; ! BUS FLAG NAMES %CONSTSTRING (6) %ARRAY WHUN(3 : 4) = %C 'WHILE ','UNTIL '; ! %WAIT MESSAGES %CONSTSTRING (4) %ARRAY EXTENSION(0 : 40) = %C ''(18),'_A','_B','','_KF','_PF',''(3), '_IN','_OUT',''(3),'_OVR',''(9); ! NAME EXTENSION %CONSTSTRING (2) %ARRAY OP(1 : 6) = %C '=','#','>=','<=','<','>'; ! COMPARATORS ! ! OWNS ! %OWNRECORD DUMMY NAME(NAMEFM) %OWNINTEGER RADIX = 10 %OWNSTRING (63) OBJECT FILE = 'SS#ARTH' ! ! SAM STARTS HERE ! %EXTERNALROUTINE SAM(%STRING (63) FILES) ! %INTEGER NNAMES, N, FLAG, TEXTPT, NAMEFAULT, NAME FLAG, BUFFERS, %C BLIST %INTEGER RC, BC, LP, RP, J, SM, PP, CONS, FAULTS, CONNECT %SHORTINTEGER NMT, MT, MQ %BYTEINTEGER CONTROL ! %INTEGERARRAY REC(0 : 100); ! ANALYSIS RECORD ARRAY %BYTEINTEGERARRAY LINE(0 : 200); ! SOURCE LINE (MAPPED AS STRING 'SOURCE') ! %SHORTINTEGERARRAYFORMAT MEMODAFM(0 : 4095) %SHORTINTEGERARRAYFORMAT MUFM(0 : 21) %SHORTINTEGERARRAYFORMAT CONFM(0 : 50) %BYTEINTEGERARRAYFORMAT TXT1(0 : MAX TEXT) %RECORDARRAYFORMAT NAFM(1 : MAX NAMES)(NAMEFM) %RECORDARRAYFORMAT EXTARFM(1 : EXTERNAL LENGTH)(EXTERNFM) %RECORDARRAYFORMAT CFM(0 : 2000)(CODEFM) %RECORDARRAYFORMAT TBAFM(1 : 50)(TABFM) ! %RECORDNAME HEADER(HEADERFM) %RECORDNAME SYS HEADER(SYS HEAD FM) %STRINGNAME CURRENT, SOURCE %RECORDNAME V1, V2(TAGFM) %RECORDNAME V(NAMEFM) ! %SHORTINTEGERARRAYNAME CONSTANTS %SHORTINTEGERARRAYNAME MODUSEAGE %BYTEINTEGERARRAYNAME TEXT %RECORDARRAYNAME NAME(NAMEFM) %RECORDARRAYNAME OBJECT(CODEFM) %RECORDARRAYNAME TABLES(TABFM) %RECORDARRAYNAME EXTERNALS(EXTERNFM) %ROUTINE PSYM(%INTEGER N) ! PRINTS OUT NUMBERS AS SYMBOLS %SHORTROUTINE %IF N > 9 %THEN N = N+'A'-10 %ELSE N = N+'0' PRINTSYMBOL(N) %END %ROUTINE NUMBER(%INTEGER N, PLACES) ! 'WRITE' ROUTINE FOR CURRENT BASE %SHORTROUTINE %ROUTINESPEC PUT(%INTEGER N) %INTEGER SIGN %IF N < 0 %AND RADIX = 10 %THEN SIGN = '-' %AND N = -N %C %ELSE %START ! HANDLE NEGATIVE NUMBERS SIGN = ' ' N = N&X'FFFF' %FINISH PUT(N) %ROUTINE PUT(%INTEGER N) ! OUTPUT NUMBER IN BASE 'RADIX' WITH 'PLACES' PLACES %SHORTROUTINE PLACES = PLACES-1 %AND PUT(N//RADIX) %IF N >= RADIX SPACES(PLACES) %IF PLACES > 0 PLACES = 0 PRINTSYMBOL(SIGN) %IF SIGN # 0; SIGN = 0 PSYM(N-N//RADIX*RADIX) %END %END %ROUTINE DISPLAY %INTEGER I %RECORDNAME V(NAMEFM) %STRING(8) TEXT I=NNAMES %WHILE I#0%CYCLE V==NAME(I) TEXT<-V_TEXT;! TRUNCATE NAME NEWLINE PRINTSTRING(TEXT) SPACES(10-LENGTH(TEXT)) PRINTSTRING(MODNAMES(V_TAGS_TYPE)) I=I-1 %REPEAT NEWLINE %END %ROUTINE SDISPLAY ! PRINTS OUT ALL THE TAGS STORED FOR EACH NAMED ELEMENT ! IN THE SYSTEM. %NAMES OR %CONTROL 7 INITIATES THIS FACILITY %SHORTROUTINE %INTEGER J %RECORDNAME V(NAMEFM) %STRING (8) TEXT J = NNAMES %WHILE J > 0 %CYCLE V == NAME(J) TEXT <- V_TEXT; ! TRUNCATE NAME TO 8 CHARACTERS PRINTSTRING(TEXT) SPACES(10-LENGTH(TEXT)) NUMBER(V_TAGS_MASTER, 5) NUMBER(V_TAGS_TYPE, 3) NUMBER(V_TAGS_USED, 3) NUMBER(V_TAGS_BITS, 3) NUMBER(V_TAGS_USE, 3) NUMBER(V_TAGS_DEFN, 3) NUMBER(V_TAGS_SIZE, 3) NUMBER(V_TAGS_WHERE, 3) NEWLINE J = J-1 %REPEAT %END %ROUTINE FAULT(%INTEGER NUMBER) ! PRINT OUT FAULT MESSAGES %SHORTROUTINE %SWITCH FT(0 : 6) %PRINTTEXT '? ' -> FT(NUMBER) FT(0): -> OUT %IF NAMEFLAG # SM; ! SYNTAX FAULT OR COMMAND ERROR %PRINTTEXT ' NAME '; ! NAME FAULT SM = NAMEFAULT PRINTSTRING(SOURCE) SPACES(SM+10) %PRINTTEXT '!' -> OUT FT(1): %PRINTTEXT 'ILLEGAL SUBNAME'; -> OUT FT(2): %PRINTTEXT 'ILLEGAL INDEX'; -> OUT FT(3): %PRINTTEXT 'ILLEGAL EXTRACTION'; -> OUT FT(4): %PRINTTEXT 'INVALID ADDRESS'; -> OUT FT(5): %PRINTTEXT 'NOT A BREAKPOINT'; -> BODY FT(6): %PRINTTEXT 'NOT AN ADDRESS'; -> BODY BODY: %PRINTTEXT ' ' PRINTSTRING(CURRENT) OUT: NEWLINE FAULTS = FAULTS+1 %END ! ! !*********************************************************************** ! ! THE FOLLOWING ROUTINES ARE DEALT WITH IN PDP16S,THE SOURCE TEXT ! FOR ARTHUR. ! ! %INTEGERFN LETTER(%INTEGER N) %SHORTROUTINE %RESULT = 1 %IF 'A' <= N <= 'Z' %RESULT = 0 %END %ROUTINE RECONSTRUCT(%INTEGER PP) %SHORTROUTINE %INTEGER S LP = 0 PROMPT(' :') %IF PP = 0 CONT1: %CYCLE READSYMBOL(S) 2: -> CONT1 %IF S = ' ' %IF S = '%' %START %CYCLE READSYMBOL(S) -> 2 %UNLESS LETTER(S) = 1 LP = LP+1 LINE(LP) = S+32 %REPEAT %FINISH %IF S = NL %START NEWL: -> CONT1 %IF LP = 0 LP = LP+1 LINE(LP) = NL LINE(0) = LP %EXIT %FINISH %IF S = '$' %START; ! COMMENT MARKER READSYMBOL(S) %UNTIL S = NL -> NEWL %FINISH %ELSE %START LP = LP+1 LINE(LP) = S %FINISH %REPEAT %END %INTEGERFN DIGIT(%INTEGER N) %SHORTROUTINE %RESULT = 1 %IF '0' <= N <= '9' %RESULT = 0 %END %INTEGERFN NAME FOUND(%BYTEINTEGER OLD) %SHORTROUTINE %INTEGER P, R, L SAVE %RESULT = 0 %UNLESS LETTER(LINE(LP)) = 1 L SAVE = LP P = TEXTPT %UNTIL (LETTER(LINE(LP)) = 0 %AND DIGIT(LINE(LP)) = 0) %CYCLE P = P+1 TEXT(P) = LINE(LP) LP = LP+1 %REPEAT TEXT(TEXTPT) = P-TEXTPT R = NNAMES CURRENT == STRING(ADDR(TEXT(TEXTPT))) %WHILE R > 0 %CYCLE %EXIT %IF NAME(R)_TEXT = CURRENT R = R-1 %REPEAT %IF R = 0 %START %IF OLD # 0 %START 1: NAMEFLAG = LP NAMEFAULT = L SAVE %RESULT = 0 %FINISH R = NNAMES+1 NNAMES = R NAME(NNAMES)_TEXT == CURRENT TEXTPT = P+1 %FINISH %ELSE %START -> 1 %IF OLD # 0 %AND NAME(R)_TAGS_TYPE = 0 %FINISH RP = RP+1 REC(RP) = R %RESULT = 1 %END %INTEGERFN NEXT LINE %RESULT = LINE(LP) %END %INTEGERFN CONSTANT FOUND(%INTEGERFNNAME NEXT) %SHORTROUTINE %BYTEINTEGER PERMIT %SPEC NEXT %BYTEINTEGER SIGN %INTEGER F, S, BASE, N SIGN <- LP S = NEXT %UNTIL LP # 0 %OR (' ' # S # NL) %IF (S = '+' %OR S = '-') %AND SIGN = 0 %START SIGN = S; S = NEXT %FINISH %ELSE SIGN = 0 F = 0 PERMIT = 0; ! NO CONSTANT FOUND YET BASE = RADIX N = 0 %CYCLE %IF DIGIT(S) = 1 %THEN S = S-'0' %ELSE %START -> 3 %UNLESS LETTER(S) = 1 S = S-'A'+10 %FINISH %IF S < BASE %START PERMIT = 1; ! NUMBER FOUND N = N*BASE+S LP = LP+1 %FINISH %ELSE %START 3: %EXIT %IF S # '_' %RESULT = 0 %IF F = LP %EXIT %IF F # 0 LP = LP+1 BASE = N N = 0 F = LP %FINISH S = NEXT %REPEAT %RESULT = 0 %IF PERMIT = 0 SIGN = 0 %IF 0 # N>>16 # X'FFFF' N = -N %IF SIGN = '-' RP = RP+1 REC(RP) = N %RESULT = 1 %END %INTEGERFN PARSE(%INTEGER ENTRY) %SHORTROUTINE %INTEGER SP, S, TRP, TLP, P, N, ON %SWITCH BIP(0 : 15) TRP = RP TLP = LP FAILURE: SM = LP %IF LP > SM RP = TRP LP = TLP ENTRY = ENTRY+1 SP = SMAIN(ENTRY) %RESULT = 0 %IF SP = 0 SUCCESS: SP = SP+1 S = SSUB(SP) %RESULT = 1 %IF S = 0 -> BIP(S>>12&15) BIP(1): ! SUB-PHRASE -> SUCCESS %IF PARSE(S&X'FFF') = 1 -> FAILURE BIP(0): ! LITERAL P = SLITERAL(S) %CYCLE P = S+1, 1, S+P -> FAILURE %IF LINE(LP) # SLITERAL(P) LP = LP+1 %REPEAT -> SUCCESS BIP(4): ! [NAME] -> SUCCESS %IF NAME FOUND(S&7) = 1 -> FAILURE BIP(3): ! [CONSTANT] -> SUCCESS %IF CONSTANT FOUND(NEXT LINE) = 1 -> FAILURE BIP(5): ! [NAMELIST] RP = RP+1 P = RP ON = S&7 N = 0 -> FAILURE %UNLESS NAME FOUND(ON) = 1 %CYCLE N = N+1 %EXIT %IF LINE(LP) # ',' LP = LP+1 LP = LP-1 %AND %EXIT %UNLESS NAME FOUND(ON) = 1 %REPEAT REC(P) = N -> SUCCESS BIP(8): ! [SEPARATOR] -> FAILURE %UNLESS LINE(LP) = NL RP = RP+1 REC(RP) = -1 -> SUCCESS BIP(2): ! <> RP = RP+1 REC(RP) = S&X'FFF' -> SUCCESS %END ! !*********************************************************************** ! ! !******** START OF SIMULATION ******* ! OBJECT FILE = FILES %UNLESS FILES = '' CONNECT = 0 FDP(7, OBJECTFILE, 0, ADDR(CONNECT), FLAG);! CONNECT FOR READING %IF FLAG # 0 %START; ! CONNECT ERROR . ABORT RUN. PRINTSTRING('CANNOT CONNECT '.OBJECT FILE) NUMBER(FLAG, 4) NEWLINES(2) %RETURN %FINISH SYS HEADER == RECORD(CONNECT); ! SYSTEM HEADER OF FILE HEADER == RECORD(CONNECT+16); ! ARTHUR HEADER OF FILE %IF HEADER_IDEN # M'ARTH' %START;! FILE NOT AN ARTHUR OBJECT FILE. ABORT. PRINTSTRING(OBJECT FILE.' IS NOT AN ARTHUR OBJECT FILE ! ') %RETURN %FINISH PP = SYS HEADER_SIZE %IF PP = 0 %START; ! FILE IS FAULTY !!!! PRINTSTRING(OBJECT FILE.' FAULTY ') PROMPT('CONTINUE? '); ! ALLOW USER TO PROCEED AT HIS PERIL!!!!! READSYMBOL(J); ! GET USER'S ANSWER %RETURN %IF J # 'Y'; ! RETURN IF NOT YES READSYMBOL(J) %WHILE J # NL; ! SKIP REST OF LINE PP = 4096*16; ! MAX SIZE %FINISH DUMMY NAME = 0; ! SET UP FAKE TAGS FOR BUS DUMMY NAME_TEXT == DATA BUS; ! NAME DUMMY NAME_TAGS_TYPE = 25; ! TYPE ! ! NOW COPY ARTHUR OBJECT FILE SO AS TO BE ABLE TO MODIFY IT ! %BEGIN %INTEGER WORK AD WORK AD = 0; ! TO ANY CONVENIENT SPACE FDP(4, WORKFILE, 3, ADDR(WORK AD), FLAG); ! CREATE WORK FILE %IF FLAG # 0 %START PRINTSTRING('CREATE '.WORK FILE.' FAILS ') %MONITORSTOP %FINISH MOVE(PP, CONNECT, WORKAD); ! PERFORM COPY CONNECT = WORK AD; ! ADJUST CONNECT ADDRESS TO POINT TO NEW FILE. SYSHEADER == RECORD(CONNECT); ! REDIRECT HEADER POINTERS TO NEW FILE HEADER == RECORD(CONNECT+16) FDP(2, OBJECT FILE, 0, 0, WORKAD); ! DISCONNECT FILE %END SOURCE == STRING(ADDR(LINE(0))); ! MAP 'SOURCE' ONTO ARRAY 'LINE' NNAMES = HEADER_NNAMES; ! GET NU,BER OF NAMES DECLARED NAME == ARRAY(HEADER_NAMES+ADDR(HEADER), NAFM) ! NAME TAGS %CYCLE J = 1, 1, NNAMES ! ADJUST STRINGNAMES SO THAT THEY POINT TO CORRECT ADDRESSES NAME(J)_TEXT == STRING(ADDR(NAME(J)_TEXT)-HEADER_OLDFILE+ %C CONNECT) %REPEAT MODUSEAGE == ARRAY(HEADER_USEAGE+ADDR(HEADER), MUFM) ! MODULE USEAGE TEXT == ARRAY(HEADER_TEXT+ADDR(HEADER), TXT1) ! NAME TEXTS EXTERNALS == ARRAY(HEADER_EXTERNS+ADDR(HEADER), EXTARFM) ! EXTERNAL EVENTS TABLES == ARRAY(HEADER_TABS+ADDR(HEADER), TBAFM) ! 8-WAY BRANCHES & REGFORMATS OBJECT == ARRAY(HEADER_CODE+ADDR(HEADER), CFM) ! OBJECT CODE CONSTANTS == ARRAY(HEADER_CONSTANTS+ADDR(HEADER), CONFM) ! CONSTANTS PRINTSTRING(' '.VERSION.' '); ! IDENTIFY PROGRAM CONS = 0; ! CLEAR SYSTEM VARIABLES FAULTS = 0 TEXTPT = HEADER_TXTLNG; ! GET ADDRESSS OF NEXT FREE CELL IN TEXT ARRAY FLAG = 0 CONTROL = 0 ! SET UP MODULE COUNTS J = NNAMES NMT = 0; ! 'NON-MEMORY' MODULE TOTAL MT = 0; ! %MEMORY,%ROM,%SPM TOTALS MQ = 0; ! ACCUMULATE MEMORY SPACE NEEDED FOR MEMORIES ETC. RC = 0; ! ROUTINE COUNT BC = 0; ! BREAKPOINT COUNT BLIST = 0; BUFFERS = 0; ! BUFFER COUNT ! ! EVALUATE BOUNDS FOR DYNAMIC DECLARATIONS OF INNER BLOCK ! %WHILE J # 0 %CYCLE; ! ROUND ALL NAMES ! ! NO SPACE ASSIGNED FOR UNUSED NAMES (TASG_USED=0),NAMES DECLARED !IN %DEFINE STATEMENTS(TAGS_MASTER # INDEX OF NAME), OR !FOR NAMES NOT ASSOCIATED WITH MODULES (MODTY(TAGS_TYPE)=0) ! IF SPACE IS ASSIGNED THE INDEX TO IT IS ENTERED INTO ! TAGS_USED ! V1 == NAME(J)_TAGS %IF V1_USED # 0 %AND 9 <= V1_TYPE <= 12 %START ! ! NEEDS AN I/O BUFFER ASSIGNED : SINT ININT,OUTINT,GPINT ! BUFFERS = BUFFERS+1; ! INCR BUFFER COUNT BUFFERS = BUFFERS+1 %UNLESS 10 <= V1_TYPE <= 11 ! GPINT AND SINT NEED TWO BUFFERS V1_WHERE = BLIST; BLIST = J; ! CHAIN NAMES %FINISH RC = RC+1 %AND V1_USED = RC %AND -> CONT1 %IF V1_TYPE = 15 ! COUNT ROUTINES BC = BC+1 %AND V1_USED = BC %AND -> CONT1 %IF V1_TYPE = 17 ! COUNT BREAKPOINTS -> CONT1 %IF V1_USED = 0 %OR MODTY(V1_TYPE) = 0 %C %OR V1_MASTER # J ! DONT ALLOCATE SPACE(SEE ABOVE) %IF MODTY(V1_TYPE) = 1 %START;! 'NON-MEMORY' MODULE NMT = NMT+1; ! INCR COUNT V1_USED = NMT; ! STROE INDEX %FINISH %ELSE %START; ! %MEMORY %ROM %SPM MT = MT+1; ! INCR COUNT V1_USED = MT; ! STORE INDEX ! ACCUMULATE MEMORY SPACE (INCLUDES SPM) %IF V1_TYPE = 4 %THEN MQ = MQ+16 %ELSE %START ! NOT AN SPM SO MUST BE A MEMORY OR ROM V1_SIZE = 1024 %IF V1_SIZE = 0; ! IF SIZE NOT SPECIFIED MAKE IT 1K MQ = MQ+V1_SIZE; ! TOTAL MEMORY SPACE NEEDED %FINISH %FINISH CONT1: J = J-1; ! DECR INDEX %REPEAT BUFFERS = 1 %IF BUFFERS = 0; ! DECLARE AT LEAST ONE OF ALL TYPES OF SPACE TO MT = 1 %AND MQ = 1 %IF MT = 0; ! PREVENT PROGRAM ERRORS BC = 1 %IF BC = 0 RC = 1 %IF RC = 0 NMT = 1 %IF NMT = 0 %BEGIN %INTEGER NK, PC, LSBR, L %SHORTINTEGER BCOUNT, CCOUNT %BYTEINTEGER STBR, STPFLAG, SINGLE SHOT %RECORD DUMMY BREAK (BRKFM) %RECORD BUS1(BUSFM) %SHORTINTEGERARRAY STR(1 : MQ) %RECORDNAME WORD, KWORD(CODEFM) %RECORDNAME CURBREAK(BRKFM) %RECORDARRAY BSTATS(1 : 48)(BRKFM); ! STATEMENT BREAKS %RECORDARRAY BREAKPOINT(1 : BC)(BRKFM); ! PROGRAM BREAKS %RECORDARRAY CONPT(1 : 48)(CONDFM); ! CONDITIONAL BREAKS %RECORDARRAY MODS(0 : NMT)(MODFM); ! NON-MEMORY MODULES %RECORDARRAY MMODS(1 : MT)(MEMODFM); ! %MEMORY %ROM %SPM %RECORDARRAY RETAD(1 : RC)(RTFM); ! ROUTINES %RECORDARRAY BUFFER(1 : BUFFERS)(IOBUFFM); ! IO BUFFERS %ROUTINE PRINTNAME(%RECORDNAME V) ! THIS ROUTINE PRINTS OUT THE NAME OF A MODULE ! EXTENDED AS THE TYPE REQUIRES FOLLOWED BY SPACES %SHORTROUTINE %RECORDSPEC V(NAMEFM) %STRING (8) TEXT %INTEGER I TEXT <- V_TEXT; ! TRUNCATE NAME PRINTSTRING(TEXT) I = LENGTH(TEXT) %IF V_TAGS_TYPE = 25 %START; ! DATA BUS %IF V_TAGS_DEFN # 0 %START; ! BUS FLAG WANTED PRINTSTRING(' '.BUSFLNM(V_TAGS_DEFN)) I = I+3 %FINISH %FINISH %ELSE %START %IF NAME(V_TAGS_MASTER)_TEXT = V_TEXT %START ! DONT PRINT AN EXTENSION IF NAME DECLARED IN A %DEFINE PRINTSTRING(EXTENSION(V_TAGS_TYPE)) I = I+LENGTH(EXTENSION(V_TAGS_TYPE)) %FINISH %FINISH SPACES(14-I); ! GET SPACING RIGHT %END %ROUTINE CDISP !THIS ROUTINE DISPLAYS THE STATUS OF CONDITIONAL BREAKPOINTS %SHORTROUTINE %RECORDNAME C(CONDFM) %INTEGER I NEWLINE %IF CCOUNT = 0 %THEN %PRINTTEXT 'NO CONDITIONAL BREAKS ' %C %ELSE %START %CYCLE I = 1, 1, CCOUNT C == CONPT(I) PRINTNAME(C_DESC); ! PRINT NAME TRAP IS ON %IF C_COND = 0 %THEN %PRINTTEXT 'ON VALUE CHANGE' %C %ELSE %START ! VALUE CHANGE OR CONSTANT COMPARISON ? PRINTSTRING(OP(C_COND));! PRINT COMPARITOR WRITE(C_TEST, 1) %FINISH %PRINTTEXT ' HELD FOR' %AND WRITE(C_COUNT, 1) %C %IF C_COUNT # 0 ! PRINT OUT HOLD COUNT IF ANY NEWLINE %REPEAT %FINISH %END %ROUTINE BDISP ! THIS ROUTINE DISPLAYS THE STATUS OF BREAKPOINTS ! IN RESPONSE TO %TRAPS OR %CONTROL 4 %SHORTROUTINE %INTEGER J NEWLINE %IF SINGLE SHOT # 0 %THEN %PRINTTEXT 'SINGLE SHOT MODE ' %C %ELSE %START %IF BCOUNT = 0 %C %THEN %PRINTTEXT 'NO STATEMENT BREAKS ' %ELSE %START %CYCLE J = 1, 1, BCOUNT %PRINTTEXT 'LINE' WRITE(BSTATS(J)_IGNORE, 1); ! WRITE LINE NUMBER %IF BSTATS(J)_COUNT # 0 %START; ! WRITE HOLD COUNT IF ANY %PRINTTEXT ' HELD FOR' WRITE(BSTATS(J)_COUNT, 1) %FINISH NEWLINE %REPEAT %FINISH %FINISH CDISP; ! SHOW COND TRAPS %END %ROUTINE FQUAL(%RECORDNAME V) ! THIS ROUTINE HANDLES NAME EXTENSIONS FOR LOCATION %SHORTROUTINE %RECORDSPEC V(NAMEFM) %INTEGER N, M %SWITCH FQ(0 : 3) RP = RP+1; -> FQ(REC(RP)) FQ(1): !'_' RP = RP+1; N = REC(RP) %IF (N < 20 %AND V_TAGS_TYPE # 1) %OR (23 > N > 20 %C %AND V_TAGS_TYPE # 12) %OR (N > 25 %C %AND V_TAGS_TYPE # 9) %START ! FAULT IF _A OR _B NOT ON A GPA NAME,_IN OR _OUT NOTON ! GPINT, _KF,_PF,_OVRUN NOT ON SINT FAULT(1); ! ILLEGAL SUBNAME %RETURN %FINISH V_TAGS_TYPE = N; ! INSERT TYPE %RETURN FQ(2): ! '#' RP = RP+1; N = REC(RP) FAULT(2) %UNLESS V_TAGS_TYPE = 4 %AND 0 <= N <= 15 ! ILLEGAL INDEX, IF NOT SPM OR INDEX <0OR >15 V_TAGS_BITS = N; ! INSERT INDEX VALUE V_TAGS_TYPE = 24; ! SPM REG TYPE %RETURN FQ(3): ! N = REC(RP+1); M = REC(RP+2) RP = RP+2 N = 5 %UNLESS 6 <= V_TAGS_TYPE <= 7; ! FORCE ERROR IF NOT BREG OR TREG %IF N = 0 %START N = M>>2 FAULT(3) %UNLESS M&3 = 3 %AND 0 <= N <= 3 ! ILLEGAL EXTRACTION IF M# 3,7,11,15 %FINISH %ELSE %START FAULT(3) %UNLESS N = 8 %AND M = 15 ! ILLEGAL EXTRACTION IF NOT <8:15> N = 4 %FINISH V_TAGS_BITS = N+4; ! SET UP FLAG FOR EXTRACT THATS WANTED FQ(0): %END %ROUTINE FLAG NAME(%RECORDNAME V) %RECORDSPEC V(NAMEFM) ! THIS ROUTINE SET UPS PSEUDO TAGS FOR BUS FLAGS V = DUMMY NAME RP = RP+1 V_TAGS_DEFN = REC(RP); ! WHICH FLAG %END %ROUTINE LOCATION(%RECORDNAME V) %RECORDSPEC V(NAMEFM) RP = RP+1; NK = REC(RP) FLAGNAME(V) %AND %RETURN %IF NK = 2; ! BUS FLAG WANTED RP = RP+1; V = NAME(REC(RP)) %IF NK = 0 %START; ! CONTENTS OF %MEMORY %ROM WANTED V_TAGS_BITS = 9; ! FLAG FOR 'CONTENTS' CURRENT == V_TEXT %AND FAULT(6) %IF 13 # V_TAGS_TYPE # 3 ! GIVE 'NOT AN ADDRESS' IF NAME IS NOT A %MEMORY OR %ROM RP = RP+1 %IF REC(RP) # 0 %START; ! [(NAME):(CONSTANT)] RP = RP+1 ! NOT CONSTNAT SO THAT LOC 0 CAN BE ADDRESSED ! AS TAGS_WHERE=0 MEANS NOT A DIRECT ADDRESS V_TAGS_WHERE = \REC(RP); ! GET CONSTANT %FINISH %ELSE V_TAGS_WHERE = 0 %FINISH %ELSE %START FQUAL(V); ! GET EXTENSION, IF ANY %FINISH %END %SHORTINTEGERMAP BUS FLAG(%INTEGER I) ! THIS MAPS THE BUS FLAGS %SHORTROUTINE %SWITCH FL(9 : 12) -> FL(I) FL(9): !OVERFLOW %RESULT == BUS1_OVF FL(10):! DZ %RESULT == BUS1_DZ FL(11):! DP %RESULT == BUS1_DP FL(12):! DN %RESULT == BUS1_DN %END %SHORTINTEGERMAP SET FLAG(%RECORDNAME FLAG, V) !THID MAP RETURNS THE ADDRESS OF A LOCATION ! CONTAINING THE VALUE OF THE FLAG REQUESTED ! THIS _F1 IF THE VARIABLE IS A FLAG MODULE , BUT IF THE !FLAG REQUESTED IS A BIT EXTRACT THE _FLAG FIELD HAS !THE VALUE PLACED IN IT AND THE MAP POINTS TO IT !THIS PRESERVES THE READ ONLY NATURE OF BIT EXTRACTS ! IN THE FACE OF ERRORS %SHORTROUTINE %RECORDSPEC V(NAMEFM) %RECORDSPEC FLAG(MODFM) %INTEGER X %RESULT == BUS FLAG(V_TAGS_DEFN) %C %IF V_TAGS_TYPE = 25 %AND V_TAGS_DEFN # 0 ! DZ,DN,DP,OVF WANTED %RESULT == FLAG_F1 %IF V_TAGS_BITS = 0; ! MODULE FLAG %IF V_TAGS_BITS = 1 %THEN X = FLAG_A %ELSE X = FLAG_B ! 'A' REG OR 'B' REG X = (X>>(15-V_TAGS_WHERE&15))&1; ! EXTRACT REQUIRED BIT FLAG_FLAG = X; ! STORE IN SPECIAL LOCATION %RESULT == FLAG_FLAG; ! MAP RESULT ONTO SPECIAL %END %INTEGERFN BREAKHERE ! THIS FUNCTION LOOKS FOR BREAKPOINTS ! RESULT =0 IF NO BREAK ! RESULT=1 IF STATEMENT BREAK ! RESULT=2 IF CONDITIONAL BREAK %SHORTROUTINE %OWNRECORD SINGLE STEPS(BRKFM) %INTEGER J, R %RECORDNAME C(CONDFM) %SWITCH CND(0 : 6) %RESULT = 0 %IF LSBR = WORD_STAT;! THIS STATEMENT ALREADY CHECKED %IF SINGLE SHOT # 0 %START; ! SINGLE SHOT ENABLED CURBREAK == SINGLE STEPS; ! SET UP BREAK POINTER %RESULT = 1 %IF SINGLE STEPS_COUNT <= 0 ! BREAK IF SINGLE SHOT NOT HELD BY REPEAT COUNT SINGLE STEPS_COUNT = SINGLE STEPS_COUNT-1 ! DECR HOLD COUNT %FINISH %IF CCOUNT # 0 %START; ! ANY CONDITIONALS? R = 0; ! CLEAR FLAG %CYCLE J = 1, 1, CCOUNT C == CONPT(J) C_COUNT = C_COUNT-1 %AND -> CONT %IF C_COUNT # 0 ! DECR REPEAT COUNT IF ANY -> CND(C_COND) CND(0): ! HAS VARIABLE CHANGED? C_W = SET FLAG(MODS(C_DESC_TAGS_USED), C_DESC) %C %IF C_FLAG # 0 ! GET VALUE IF BIT EXTRACT -> CONT %IF C_W = C_TEST; ! VALUE HAS NOT CHANGED C_TEST = C_W; !TO KEEP UP TO DATE! PRINTNAME(C_DESC); ! WRITE OUT VARIABLE NAME %PRINTTEXT 'HAS CHANGED VALUE TO ' %IF C_DESC_TAGS_TYPE = 2 %C %OR (C_DESC_TAGS_TYPE = 25 %C %AND C_DESC_TAGS_DEFN # 0) %START ! SET OR CLEAR FOR A FLAG OR BUS FLAG %IF C_W # 0 %THEN %PRINTTEXT 'SET' %C %ELSE %PRINTTEXT 'CLEAR' %FINISH %ELSE NUMBER(C_W, 1); ! ELSE WRITE OUT VALUE TO CURRENT BASE NEWLINE -> INC CND(1): ! = -> BRK %IF C_W = C_TEST -> CONT CND(2): ! # -> BRK %IF C_W # C_TEST -> CONT CND(3): ! >= -> BRK %IF C_W >= C_TEST -> CONT CND(4): ! <= -> BRK %IF C_W <= C_TEST -> CONT CND(5): ! < -> BRK %IF C_W < C_TEST -> CONT CND(6): ! > -> CONT %IF C_W <= C_TEST BRK: PRINTNAME(C_DESC); ! WRITE OUT VARIABLE NAME PRINTSTRING(OP(C_COND)); ! CONDITION SATISFIED NUMBER(C_TEST, 1); ! WRITE VALUE TEST WAS AGAINST NEWLINE INC: R = 1; ! INDICATE TRAP HAS OCCURED C_FIRED = 1; ! FLAG CONDTION THAT CAME TRUE CONT: %REPEAT %RESULT = 2 %IF R = 1; ! CONDITIONAL BREAK %RESULT = 0 %IF BCOUNT = 0 %OR SINGLE SHOT # 0 %FINISH LSBR = 0 %RESULT = 0 %IF BCOUNT = 0 %OR SINGLE SHOT # 0 ! NO STATEMENT BREAKS %CYCLE J = 1, 1, BCOUNT %IF BSTATS(J)_IGNORE = WORD_STAT %START;! BREAK SET ON THIS LINE CURBREAK == BSTATS(J) %IF CURBREAK_COUNT <= 0 %THEN %RESULT = 1 ! NO HOLD COUNT! BREAK CURBREAK_COUNT = CURBREAK_COUNT-1; ! DECR REPEAT COUNT %RESULT = 0; ! ! NO BREAK %FINISH %REPEAT %RESULT = 0 %END %ROUTINE COMPILE BLOCK %RECORDNAME TEMP NAME(NAMEFM) %ROUTINESPEC MONITOR %OWNBYTEINTEGER SINT MODE = 0 %OWNSTRING (14) INDEV = 'INPUT' %OWNSTRING (16) %ARRAY OUT(1 : 3) = %C '.TT','.LP','' %INTEGER T, N, J, MI, TL, FLG, SELECT %INTEGER K, LAST, RESULT, CRRNT, LAST RT %BYTEINTEGER FLAGDV2, EN, TRACE %RECORD STORE WORD(CODEFM) %RECORD DV(NAMEFM) %RECORDNAME NP(NAMEFM) %RECORDNAME RT(RTFM) %RECORDNAME C(CONDFM) %RECORDNAME BUF(IOBUFFM) %SHORTINTEGERARRAYNAME DUM1 %INTEGERFNSPEC SYMBOL(%INTEGER BUFNO) %ROUTINESPEC PRINT(%INTEGER BUFNO, SYM) %INTEGERFNSPEC GET TREG(%INTEGER TABLE ADDR, VALUE) %SHORTINTEGERMAPSPEC SMAP(%RECORDNAME X) %SWITCH PHRASE(-1 : 24) ! ! %SHORTINTEGERMAP FMAP(%INTEGER N) ! THIS MAPS FLAGS AND BIT EXTRACTS ! FOR USE IN CONDITIONS %SHORTROUTINE %SHORTINTEGERNAME PP %SWITCH TY(1 : 12) -> TY(N) TY(3): !%BUS %RESULT == BUS1_BUSREG TY(2): !%FLAG OR BIT EXTRACT %RESULT == SET FLAG(MODS(NAME(WORD_NAME)_TAGS_USED), NAME( %C WORD_NAME)) TY(4): ! _KF TY(5): ! _PF TY(6): ! _OVERUN PP == MODS(NAME(WORD_NAME)_TAGS_USED)_F1; ! GET APPROPRIATE FLAG %RESULT = ADDR(PP)+(N-4)<<1 TY(9): !OVF %RESULT == BUS1_OVF TY(10): !DZ %RESULT == BUS1_DZ TY(12): !DP %RESULT == BUS1_DP TY(11): !DN %RESULT == BUS1_DN %END %INTEGERFN EXTRACT ! THIS GETS BITS AND SWITCHES %SHORTROUTINE %INTEGER MODE, RES %RECORDNAME DV(NAMEFM) MODE = WORD_ADDR>>8&X'FF' %IF MODE = 3 %START !BIT EXTRACT %IF WORD_NAME = 0 %THEN RES = BUS1_BUSREG %ELSE %START ! BUS WANTED DV == NAME(WORD_NAME) RES = SMAP(DV); ! GET REGISTER VALUE !!! RES = GET TREG(DV_TAGS_WHERE, RES) %C !!! %IF WORD_MODULE = 7 %OR WORD_MODULE = 6 ! FIDDLE BITS IF TREG OR BREG %FINISH %RESULT = RES>>(15-WORD_ADDR&X'FF')&1;! PICK OFF BIT %FINISH %ELSE %START %IF 5 <= MODE <= 6 %START; ! SWITCHES !************************ ! ! NOT YET IMPLEMENTED ! !************************** MONITOR %FINISH %ELSE %RESULT = FMAP(MODE);! OTHERWISE USE FMAP %FINISH %END %ROUTINE TEST ADDRESS(%INTEGER LIMIT, %INTEGERNAME ADDR, %C %STRINGNAME NAME) ! THIS ROUTINE CHECKS FOR INVALID ADDRESSING OF %MEMORY %ROM %SHORTROUTINE %UNLESS 0 <= ADDR <= LIMIT %START; ! CHECK ADDRESS ADDR = 0 PRINTSTRING('* ADDRESS ERROR IN '.NAME.' ') MONITOR; ! GIVE TRACE BACK %FINISH %END %SHORTINTEGERMAP SMAP(%RECORDNAME V) ! THIS ROUTINE RETURNS POINTERS TO REGISTERS AND NAMED FLAGS ! LIKE KF,PF OVR ETC. %SHORTROUTINE %RECORDSPEC V(NAMEFM) %OWNSHORTINTEGER DUMP %INTEGER J, K %SHORTINTEGERARRAYNAME Z %SWITCH TYPE(0 : 40) J = V_TAGS_USED -> TYPE(WORD_MODULE) TYPE(3): !%MEMORY %RESULT == MMODS(J)_MEMADDR %IF V_TAGS_BITS # 9 ! ADDRESS REG WANTED Z == MMODS(J)_STORE %IF V_TAGS_WHERE < 0 %THEN K = \V_TAGS_WHERE %C %ELSE K = MMODS(J)_MEMADDR ! DIRECT ADDRESS SPECIFIED? TEST ADDRESS(MMODS(J)_LIMIT, K, V_TEXT) %RESULT == Z(K); ! RETURN LOCATION TYPE(2): !%FLAG %RESULT == SET FLAG(MODS(J), V) TYPE(6): !BREG TYPE(7): ! TREG TYPE(10): ! %IPINT TYPE(11): ! %IPINT TYPE(18): ! _A TYPE(26): !_IN %RESULT == MODS(J)_A TYPE(19): ! _B TYPE(27): !_OUT %RESULT == MODS(J)_B TYPE(21): ! _KF %RESULT == MODS(J)_F1 TYPE(22): ! _PF %RESULT == MODS(J)_F2 TYPE(31): ! _OVRUN %RESULT == MODS(J)_F3 TYPE(24): ! SPM REGISTER Z == MMODS(J)_STORE %RESULT == Z(V_TAGS_BITS); ! INDEX IN TAGS_BITS TYPE(25): ! THE BUS %RESULT == BUS FLAG(V_TAGS_DEFN) %IF V_TAGS_DEFN # 0 ! DZ DP DN OVF WANTED %RESULT == BUS1_BUSREG; ! BUS WANTED TYPE(0): ! NOT USED PRINTSTRING('REFERENCE TO UNUSED NAME '.V_TEXT) MONITOR; ! PRINT TRACE BACK %RESULT == DUMP %END !THIS CONVERTS SYMBOLS AND VALYES TO STRINGS !%SHORTROUTINE %STRINGFN CHAR(%INTEGER S) %RESULT = TOSTRING(S) %IF 32 < S <= 127; ! ALPHANUMERIC %RESULT = 'SP' %IF S = ' '; ! SPACE %RESULT = 'NL' %IF S = NL; ! NEWLINE %RESULT = TOSTRING(S//10+'0').TOSTRING(S-S//10*10+'0') ! CONTROL CHAR %END %ROUTINE SHOW(%RECORDNAME V) ! THIS ROUTINE PRINTS OUT THE VALUES OF THE CONTENTS OF ! REGISTERS AND FLAGS WITH THEIR NAMES %SHORTROUTINE %RECORDSPEC V(NAMEFM) %ROUTINESPEC CS(%INTEGER FLAG) %INTEGER ADDR, J, K %SHORTINTEGERARRAYNAME Z %CONSTBYTEINTEGERARRAY PERMIT(0 : 36) = %C 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0; ! IS TYPE VALID? %STRING(7) FIDDLE %SWITCH TYPE(0 : 36) J = V_TAGS_USED; K = V_TAGS_TYPE %RETURN %IF (J = 0 %AND K # 25) %OR PERMIT(K) = 0 ! RETURN IF TYPE IS INVALID OR NAME UNUSED(EXCEPT WHEN THE BUS ! IS REQUIRED) PRINTNAME(V); ! OUTPUT NAME -> TYPE(K) TYPE(25): ! SPECIAL FOR THE BUS CS(BUSFLAG(V_TAGS_DEFN)) %AND -> OUT %IF V_TAGS_DEFN # 0 ! BUS FLAG WANTED NUMBER(BUS1_BUSREG, 4) NEWLINE %PRINTTEXT ' OVF:'; CS(BUS1_OVF) %PRINTTEXT ' DZ:'; CS(BUS1_DZ) %PRINTTEXT ' DN:'; CS(BUS1_DN) %PRINTTEXT ' DP:'; CS(BUS1_DP) -> OUT TYPE(9): TYPE(1): !%GPINT & %GPA FIDDLE=EXTENSION(17+K).':' FIDDLE=FROMSTRING(FIDDLE,2,LENGTH(FIDDLE)) SPACES(3-LENGTH(FIDDLE)) PRINTSTRING(FIDDLE) NUMBER(MODS(J)_A, 4); ! WRITE OUT A OR IN SPACES(3) FIDDLE=EXTENSION(18+K).':' FIDDLE=FROMSTRING(FIDDLE,2,LENGTH(FIDDLE)) SPACES(4-LENGTH(FIDDLE)) PRINTSTRING(FIDDLE) NUMBER(MODS(J)_B, 4); ! WRITE OUT B OR OUT -> OUT TYPE(2): !%FLAG K = SET FLAG(MODS(J), V); ! GET FLAG VALUE SC: CS(K) -> OUT TYPE(3): !%MEMORY %IF V_TAGS_WHERE < 0 %THEN ADDR = \V_TAGS_WHERE %C %ELSE ADDR = MMODS(J)_MEMADDR ! DIRECT ADDRESS? Z == MMODS(J)_STORE NUMBER(ADDR, 4); ! WRITE OUT ADDRESS %IF 0 <= ADDR <= MMODS(J)_LIMIT %START; ! CHECK ADDRESS %PRINTTEXT ' ['; NUMBER(Z(ADDR), 0); %PRINTTEXT ' ]' ! WRITE OUT CONTENTS %FINISH %ELSE %PRINTTEXT ' INVALID ADDRESS' V_TAGS_WHERE = 0; ! REMOVE DIRECT ADDRESS -> OUT TYPE(4): !%SPM Z == MMODS(J)_STORE %CYCLE K = 0, 1, 15 NEWLINE %IF K&3 = 0; ! NEWLINE IF LINE FILLED NUMBER(K, 4); ! WRITE SPM INDEX NUMBER(Z(K), 4); ! WRITE SPM VALUE %REPEAT -> OUT TYPE(6): !%BREG TYPE(7): !%TREG %PRINTTEXT 'IN:'; NUMBER(MODS(J)_A, 4); ! CONTENTS STORED %PRINTTEXT ' OUT:' NUMBER(GET TREG(V_TAGS_WHERE, MODS(J)_A), 4) ! TRANSFORMED CONTENTS -> OUT TYPE(10): TYPE(11): !%IPINT,%OPINT TYPE(18): ! _A TYPE(26): ! _IN NUMBER(MODS(J)_A, 4) -> OUT TYPE(19): !_B TYPE(27): !_OUT NUMBER(MODS(J)_B, 4) -> OUT TYPE(21): !_KF CS(MODS(J)_F1) -> OUT TYPE(22): !_PF CS(MODS(J)_F2) -> OUT TYPE(31): !_OVERUN CS(MODS(J)_F3) -> OUT TYPE(12): !%SINT PRINTSTRING(''''.CHAR(MODS(J)_A).''' : '''.CHAR(MODS(J)_B). %C ''' KF:') CS(MODS(J)_F1); ! KF %PRINTTEXT ' PF:'; CS(MODS(J)_F2); !PF %PRINTTEXT ' OVR:'; CS(MODS(J)_F3); ! OVR %PRINTTEXT ' ENABLED' %IF MODS(J)_F4 # 0; ! ENABLED? -> OUT TYPE(24): !SPM REG Z == MMODS(J)_STORE NUMBER(Z(V_TAGS_BITS), 4); ! BITS CONTAINS INDEX -> OUT OUT: NEWLINE %ROUTINE CS(%INTEGER FLAG) !THIS WRITES OUT THE VALUE OF FLAGS %SHORTROUTINE %IF FLAG = 0 %THEN %PRINTTEXT ' CLEAR' %C %ELSE %PRINTTEXT ' SET ' %END %END %ROUTINE MYREAD(%INTEGER BUFNO, %INTEGERNAME N) ! THIS ROUTINE TAKES INPUT FROM THE INPUT BUFFER !ALLOCATED TO THE INPUTTING MODULE AND READS INTEGER VALUES ! FROM IT %SHORTROUTINE %INTEGERFNSPEC NEXT SYM INDEV <- NAME(WORD_NAME)_TEXT; ! NAME FOR PROMPT %CYCLE RP = 0; LP = 0 %EXIT %IF CONSTANT FOUND(NEXT SYM) # 0; ! READ CONSTANT, 0 IF ERROR BUFFER(BUFNO)_SYMS = 0; ! SCRAP ALL INPUT SO FAR FAULT(0); ! QUERY %REPEAT N = REC(1); ! GET VALUE THAT WAS READ IN BUFFER(BUFNO)_SYMS = BUFFER(BUFNO)_SYMS+1; ! ADJUST BUFFER POINTERS BUFFER(BUFNO)_PT = BUFFER(BUFNO)_PT-1 %RETURN %INTEGERFN NEXT SYM %RESULT = SYMBOL(BUFNO) %END %END %ROUTINE PSTRING(%INTEGER BUFNO, %STRINGNAME S) !THIS ROUTINE OUTPUTS A STRING TO THE OUTPUT BUFFER !ADDRESSES BY BUFNO %SHORTROUTINE %INTEGER J, L L = LENGTH(S); %RETURN %IF L = 0 %CYCLE J = 1, 1, L PRINT(BUFNO, CHARNO(S, J)); ! OUTPUT CHARACTER TO BUFFER %REPEAT %END %ROUTINE SEND !THIS ROUTINE OUTPUTS TO A BUFFERTHE VALUE OF THE ! VARIABLE 'RESULT', WHICH HOLDS THE VALUE COMPUTED DURING ! BUS OPERATIONS %SHORTROUTINE %INTEGER BUF, N, RES %STRING(8) TEXT NEWLINE TEXT<-NAME(WORD_NAME)_TEXT PRINTSTRING(TEXT.':') SPACES(9-LENGTH(TEXT)) NUMBER(RESULT,1) NEWLINE %END %ROUTINE FLAG OP(%INTEGER TYPE) ! ! TYPE : 3 - %SET ! 4 - %CLEAR ! 5 - %COMPLEMENT ! %SHORTROUTINE %IF TYPE = 3 %THEN MODS(CRRNT)_F1 = 1 %IF TYPE = 4 %THEN MODS(CRRNT)_F1 = 0 %IF TYPE = 5 %THEN MODS(CRRNT)_F1 = MODS(CRRNT)_F1!!1 %END %INTEGERFN GET TREG(%INTEGER TABLE ADDR, VALUE) ! THIS FUNCTION PERFORMS THE OUTPUT TRANSFORMATION REQUIRED ! BY TREGS AND BREGS (SEE PDP-16 HANDBOOK) %SHORTROUTINE %RECORDNAME LIST(TREG LIST FM) %SHORTINTEGER SHORT %INTEGER B, N, J %IF TABLE ADDR > 0 %START;! NOT DEFAULT LIST == TABLES(TABLE ADDR) N = 0; ! CLEAR RESULT VARIABLE %CYCLE J = 0, 1, 15; ! PERFORM BIT SWOPPING B = VALUE>>(15-J)&1; ! BIT FROM SOURCE N = N!(B<<(15-LIST_BIT(J))) %REPEAT %FINISHELSE N=VALUE SHORT=N;! TO SET THE SIGN CORRECTLY DUMMY:! TO FORCE A LOAD(I.E. FORGET SHORT) %RESULT = SHORT %END %INTEGERFN SYMBOL(%INTEGER BUFNO) ! THIS FUNCTION RETURNS THE VALUE OF THE NEXT CHARACTER ! IN THE ADDRESSED INPUT BUFFER, IF IT IS EMPTY THE USER IS ! PROMPTED FOR MORE INPUT %SHORTROUTINE %RECORDNAME BB(IOBUFFM) %BYTEINTEGER S %IF BUFNO = 0 %START; ! NOT A BUFFER PRINTSTRING('SPURIOUS BUFFER FOR '.V_TEXT) %RESULT = NL %FINISH BB == BUFFER(BUFNO) %IF BB_TYPE # 0 %START; ! TYPE ERROR PRINTSTRING('OUTPUT USED AS INPUT ON '.V_TEXT) MONITOR %RESULT = NL %FINISH %IF BB_SYMS <= 0 %START; ! BUFFER EMPTY PROMPT(INDEV.':'); ! PROMPT WITH NAME %UNTIL S = NL %CYCLE; ! READ IN INPUT LINE READSYMBOL(S) BB_SYMS = BB_SYMS+1; ! INCR BUFFER POINTER BB_TEXT(BB_SYMS) = S; ! STORE CHAR %REPEAT PROMPT(' :'); ! RESET SYSTEM PROMPT BB_PT = 0; ! POINT OT FIRST CHAR %FINISH BB_SYMS = BB_SYMS-1; BB_PT = BB_PT+1;! ADJUST POINTERS %RESULT = BB_TEXT(BB_PT); ! EXTRACT CHAR %END %ROUTINE PRINT(%INTEGER BUFNO, SYM) ! THIS ROUTINE OUTPUTS TO THE ADDRESSED BUFFER, IF IT FILLS !THE CONTENTS ARE WRITTEN ONTO THE CONSOLE TO EMPTY !THE BUFFER %SHORTROUTINE %RECORDNAME BB(IOBUFFM) %STRING (8) VNAME %INTEGER J %IF BUFNO <= 0 %START; ! ERROR PRINTSTRING('SPURIOUS BUFFER FOR '.V_TEXT) MONITOR %RETURN %FINISH BB == BUFFER(BUFNO) %IF BB_TYPE # 1 %START; ! TYPE ERROR PRINTSTRING('INPUT USED AS OUTPUT ON '.V_TEXT) MONITOR %RETURN %FINISH %IF SYM = NL %OR BB_SYMS <= 0 %START; ! CLEAR BUFFER VNAME <- NAME(BB_OWNER)_TEXT; ! TRUNCATE NAME PRINTSTRING(VNAME.':'); ! IDENTIFY BUFFER K = BB_PT %IF K > 0 %START %CYCLE J = 1, 1, K; ! OUTPUT BUFFER CONTENTS PRINTCH(BB_TEXT(J)) %REPEAT %FINISH NEWLINE BB_PT = 0; BB_SYMS = 64; ! ADJUST POINTERS %RETURN %IF SYM = NL %FINISH BB_SYMS = BB_SYMS-1; BB_PT = BB_PT+1 BB_TEXT(BB_PT) = SYM; ! INSERT CHARACTER %END %ROUTINE FORCE OUTPUT ! THIS ROUTINE EMPTIES ALL BUFFERS WHEN THE PROGRAM IS ! HALTED %SHORTROUTINE %INTEGER J %RETURN %IF BUFFERS = 0; ! NO BUFFERS %CYCLE J = 1, 1, BUFFERS; ! ROUND ALL BUFFERS PRINT(J, NL) %IF BUFFER(J)_TYPE = 1 %AND BUFFER(J)_PT # 0 ! OUTPUT ONLY %REPEAT %END %ROUTINE MONITOR ! THIS ROUTINE GIVES A TRACE BACK OF THE PATH ! TAKEN TO REACH THE CUURENT POINT , THE ONLY THING ! TRACED IS ROUTINE ENTRY %SHORTROUTINE %INTEGER J, K %RECORDNAME CODE(CODEFM) %RECORDNAME RT(RTFM) %PRINTTEXT ' ** MONITOR ** ' J = LAST RT K = PC-1; ! BACK TO FAILING STATEMENT %WHILE J # 0 %CYCLE; ! ROUND EVERY ROUTINE CALLED RT == RETAD(J); %EXIT %IF RT_RA < 2; ! RETURN ERROR CODE == OBJECT(RT_RA-1) %PRINTTEXT 'LINE'; WRITE(OBJECT(K)_STAT, 1) %PRINTTEXT ' OF ' PRINTSTRING(NAME(CODE_NAME)_TEXT) NEWLINE K = RT_RA-1 J = RT_LAST RT; ! GET NEXT ROUTINE IN CHAIN %REPEAT %PRINTTEXT 'MAIN PROGRAM LINE'; WRITE(OBJECT(K)_STAT, 1) NEWLINE %END %INTEGERFN FIELD(%INTEGER VALUE, KEY) ! THIS FUNCTION PERFORMS FIELD EXTRACTIONS FOR TREGS AND BREGS ! SEE PDP16 HANDBOOK AND ARTHUR DOCUMENTATION FOR VALID FIELDS %SHORTROUTINE %RESULT = VALUE %UNLESS 4 <= KEY <= 8 %SWITCH KV(4 : 8) -> KV(KEY) KV(4): ! <0:3> %RESULT = VALUE&X'F' KV(5): ! <0:7> %RESULT = VALUE&X'FF' KV(6): ! <0:11> %RESULT = VALUE&X'FFF' KV(7): ! <0:15> %RESULT = VALUE KV(8): ! <8:15> %RESULT = VALUE>>8&X'FF' %END %INTEGERFN EVOKE ARITH OP(%INTEGER OP) ! THIS PERFORMS THE ARITHMETIC OPERATIONS FOR EVOKE ! INSTRUCTIONS %SHORTROUTINE %SWITCH EVOKEOP(1 : 50) %INTEGER RESULT,A ! -> EVOKEOP(OP) ! EVOKEOP(1): ! LOAD A REG ONTO BUS %RESULT = MODS(CRRNT)_A EVOKEOP(2): ! LOAD B REG ONTO BUS %RESULT = MODS(CRRNT)_B EVOKEOP(3): ! NOT %RESULT = \MODS(CRRNT)_A EVOKEOP(4): ! NOT B %RESULT = \MODS(CRRNT)_B EVOKEOP(5):!*2 AND OR IN RSI %RESULT = MODS(CRRNT)_A<<1!MODS(CRRNT)_F2 EVOKEOP(6): ! A+1 %RESULT = MODS(CRRNT)_A+1 EVOKEOP(7): ! A-1 %RESULT = MODS(CRRNT)_A-1 EVOKEOP(8): ! A+B %RESULT = MODS(CRRNT)_A+MODS(CRRNT)_B EVOKEOP(9): ! A-B %RESULT = MODS(CRRNT)_A-MODS(CRRNT)_B EVOKEOP(10): ! A&B %RESULT = MODS(CRRNT)_A&MODS(CRRNT)_B EVOKEOP(11): ! A XOR B %RESULT = MODS(CRRNT)_A!!MODS(CRRNT)_B EVOKEOP(12): ! A OR B %RESULT = MODS(CRRNT)_A!MODS(CRRNT)_B EVOKEOP(13): ! SET TO ZERO %RESULT = 0 EVOKEOP(36): ! LOAD %IF WORD_MODULE = 12 %START; ! SI INDEV <- NAME(WORD_NAME)_TEXT;! SET UP NAME FOR PROMPT %RESULT = SYMBOL(NAME(WORD_NAME)_TAGS_WHERE&X'00FF') %C %IF SINT MODE = 0 MY READ(NAME(WORD_NAME)_TAGS_WHERE&X'00FF',A) %RESULT=A ! READ A SYMBOL %FINISH %IF 9 <= WORD_MODULE <= 10 %OR WORD_MODULE = 26 %START ! GPI,ININT,GPI_IN MYREAD(V_TAGS_WHERE&X'00FF', RESULT); ! READ A VALUE MODS(CRRNT)_A <- RESULT; ! STORE VALUE IN INPUT SIDE %RESULT = RESULT %FINISH %IF WORD_MODULE = 5 %START; ! C GEN %RESULT = CONSTANTS(WORD_NAME) %FINISH %IF WORD_MODULE = 7 %OR WORD_MODULE = 6 %START ! TREG OR BREG RESULT = GET TREG(V_TAGS_WHERE, MODS(CRRNT)_A) ! TRANSFORM OUTPUT %RESULT = FIELD(RESULT, WORD_ADDR);! EXTRACT FIELD %FINISH %IF WORD_MODULE = 24 %START; ! SPM REG DUM1 == MMODS(CRRNT)_STORE %RESULT = DUM1(WORD_ADDR); ! INDEX IN ADDR %FINISH EVOKEOP(35): EVOKEOP(37): %RESULT = BUS1_BUSREG; !LOAD BUS REG %END %ROUTINE SET BUS BUS1 = 0 BUS1_BUSREG=RESULT BUS1_DZ=1 %IF BUS1_BUSREG = 0 BUS1_DP=1 %IF BUS1_BUSREG>0 BUS1_DN=1 %IF BUS1_BUSREG<0 BUS1_OVF=1 %UNLESS -32768 <= RESULT <= 32767 %END %ROUTINE DEPOSIT IN(%INTEGER INDEX) ! THIS ROUTINE STORES THE VALUE COMPUTED (HELD IN 'RESULT') ! INTO THE LOCATION REQUIRED. ! THIS ROUTINE FUNCTIONS FOR SINGLE EVOKE OPERATIONS ONLY ! THAT IS OPS OF THE FORM A<-A+B ! THAT IS SOURCE AND DESTINATION IN SAME MODULE %SHORTROUTINE %SWITCH EVKDEST(0 : 10) %INTEGER ADDR -> EVKDEST(INDEX) EVKDEST(1): ! STORE IN 'A' REG MODS(CRRNT)_A <- RESULT %RETURN EVKDEST(2): ! STORE IN 'B' REG MODS(CRRNT)_B <- RESULT %RETURN EVKDEST(3): ! STORE IN BUS REG BUS1_BUSREG <- RESULT %RETURN EVKDEST(9): ! MEMORY CONTENTS TO BUS ADDR = MMODS(CRRNT)_MEMADDR DUM1 == MMODS(CRRNT)_STORE RESULT<- DUM1(ADDR) SET BUS %RETURN EVKDEST(10): ! ERROR TO REACH HERE %PRINTTEXT ' SPURIOUS DESTINATION' NUMBER(INDEX, 1); NEWLINE MONITOR EVKDEST(4): EVKDEST(5): EVKDEST(6): EVKDEST(7): EVKDEST(8): %END %ROUTINE STORE(%INTEGER OP) ! THIS ROUTINE PERFORMS STORE FOR CONTINUATION EVOKE STORES %SHORTROUTINE %INTEGER ADR %SHORTINTEGERNAME MM %SWITCH EVOKEDEST(0 : 10) -> EVOKE DEST(OP) EVOKEDEST(0): ! VARIOUS DESTINATIONS %IF WORD_MODULE = 9 %OR WORD_MODULE = 11 %C %OR WORD_MODULE = 27 %START ! GPINT, OUTINT , GPINT _OUT SEND; ! TRANSMIT VALUE %IF WORD_MODULE = 11 %THEN MODS(CRRNT)_A <- RESULT %C %ELSE MODS(CRRNT)_B <- RESULT ! PUT VALUE IN 'A' IF OUTINT, ELSE PUT IT IN 'B' %RETURN %FINISH %IF WORD_MODULE = 3 %START; ! MEMORY ADDRESS REG MMODS(CRRNT)_MEMADDR <- RESULT %RETURN %FINISH %IF 6 <= WORD_MODULE <= 7 %START;! TREG BREG MODS(CRRNT)_A <- RESULT %FINISH %RETURN EVOKEDEST(1): ! STORE IN 'A' TYPE REG MODS(CRRNT)_A <- RESULT %RETURN EVOKEDEST(2): ! STORE IN 'B' TYPE REG MODS(CRRNT)_B <- RESULT %RETURN EVOKEDEST(3): ! ERROR TO REACH HERE EVOKEDEST(10): %PRINTTEXT ' SPURIOUS DESTINATION ' NUMBER(OP, 1) MONITOR %RETURN EVOKEDEST(4): ! <0:3> MM == MODS(CRRNT)_A MM <- MM&X'FFF0'!RESULT&X'000F' %RETURN EVOKEDEST(5): ! <0:7> MM == MODS(CRRNT)_A MM <- MM&X'FF00'!RESULT&X'00FF' %RETURN EVOKEDEST(6): ! <8:15> MM == MODS(CRRNT)_A MM <- MM&X'F000'!RESULT&X'0FFF' %RETURN EVOKEDEST(7): ! 'A' TYPE REG MODS(CRRNT)_A <- RESULT %RETURN EVOKEDEST(8): ! BYTE OPERATION MM == MODS(CRRNT)_A MM <- MM&X'00FF'!(RESULT&X'00FF')<<8 %RETURN EVOKEDEST(9): ! STORE RESULT IN CONTENTS OF MEMORY ADDRESSED BY !MEMADDR ADR = MMODS(CRRNT)_MEMADDR TEST ADDRESS(MMODS(CRRNT)_LIMIT, ADR, V_TEXT) ! CHECK ADDRESS DUM1 == MMODS(CRRNT)_STORE DUM1(ADR) <- RESULT %END %ROUTINE SIMULATE(%INTEGER MODE) ! THIS ROUTINE SIMULATES THE OBJECT CODE IN THE ARTHUR FILE %INTEGER STATEMENT,INDEX %SWITCH INSTR(0 : 15) %IF MODE = 0 %START; ! %GO OR %CONTINUE? ROUND: WORD == OBJECT(PC); PC = PC+1; ! POINT TO CURRENT INSTR AND INCR PCOUNT STATEMENT = WORD_STAT; ! GET STATEMENT NUMBER %IF STATEMENT#LAST%START ->BRK%IF TESTINT(0,'WAIT')#0;! USER HAS INTERUPTED %IF TRACE # 0 %START ! WRITE LINE NUMBER IF TRACE ON AND NEW STATEMENT SELECTOUTPUT(77); ! SELECT TRACE OUTPUT NUMBER(STATEMENT, 1); ! PRINT LINE NUMBER SELECTOUTPUT(0); ! RESELECT CONSOLE %FINISH EN = BREAKHERE; ! SAVE BREAK TYPE %IF EN # 0 %START; ! BREAKPOINT REACHED LSBR = STATEMENT; ! SAVE STATEMENT NUMBER BRK: STBR = 1; ! SET FLAG FORCE OUTPUT; ! CLEAR BUFFERS %PRINTTEXT 'BREAKPOINT LINE';! OUTPUT MESSAGE WRITE(STATEMENT, 1) NEWLINE %RETURN %FINISH %FINISH %FINISH %ELSE WORD == OBJECT(PC-1); ! RESTORE IT LAST=STATEMENT;! SAVE STATEMENT NUMBER %IF 0 < WORD_NAME <= NNAMES %START; ! POINT TO NAME IF VALID V == NAME(WORD_NAME); CRRNT = V_TAGS_USED %FINISH -> INSTR(WORD_CODE) INSTR(0): ! NOP -> ROUND INSTR(1): ! EVOKE J = WORD_OPRN; ! GET OPERATION %IF 17 <= J <= 28 %THEN J = J&15 %AND FLAGDV2 = 1 %C %ELSE FLAGDV2 = 0 ! /2 SPECIFIED, SET FLAG AND ADJUST OPERATION CODE RESULT = EVOKE ARITH OP(J); ! PERFORM OP %IF FLAGDV2 = 1 %THEN RESULT = RESULT>>1!MODS(CRRNT)_F1<<15 ! PERFORM /2 IF WANTED, AND OR IN LSI SET BUS %IF WORD_MODULE = 24 %AND J = 13 %START; ! SET SPM REG TO 0 DUM1 == MMODS(CRRNT)_STORE DUM1(WORD_ADDR) = 0 -> ROUND %FINISH %IF WORD_ADDR = 0 %START %IF WORD_MODULE = 12 %START; ! SI %IF J = 35 %START; ! ENABLE MODS(CRRNT)_F4 = 1; -> ROUND %FINISH MODS(CRRNT)_F4 = 0; ! REMOVE ENABLE MODS(CRRNT)_A = RESULT; ! STORE VALUE %FINISH -> ROUND %FINISH DEPOSIT IN(WORD_ADDR) %IF WORD_MODULE # 24 ! PERFORM STORE UNLESS SPM -> ROUND INSTR(2): ! BUS -> ROUND INSTR(3): ! CONDITION %IF 3 <= WORD_OPRN <= 4 %START; ! WAITUNTIL CONDITION %IF CONTROL&2 = 0 %START; ! PRINT MESSAGE IF NOT INHIBITED %PRINTTEXT ' WAITING ' PRINTSTRING(WHUN(WORD_OPRN).V_TEXT.EXTENSION(WORD_ %C MODULE)) NEWLINE %FINISH FMAP(WORD_ADDR>>8&X'FF') = WORD_OPRN-3; ! SET FLAG TO APPROPRIATE VALUE PC = PC+1; ! SKIP JUMP -> ROUND %FINISH ! IF-UNLESS CONDITION J = EXTRACT; ! GET FLAG VALUE PC = PC+1 %IF J = WORD_OPRN-1; ! SKIP IF COND SATISFIED -> ROUND INSTR(4): !MERGE -> ROUND INSTR(5): ! ROUTINE CALL DV = NAME(WORD_NAME); ! ROUTINE NAME TAGS J = DV_TAGS_USED RT == RETAD(J); ! POINT AT ROUTINE'S DATA AREA RT_RA = PC; ! SAVE RETURN ADDRESS RT_LAST RT = LAST RT ! SAVE NAME OF CURRENT ROUTINE(IF ANY) FOR TRACE BACK LAST RT = J; ! MAKE THIS THE CURRENT ROUTINE PC = WORD_ADDR; ! ADJUST PCOUNT -> ROUND INSTR(6): ! ROUTINE RETURN DV = NAME(WORD_ADDR) J = DV_TAGS_USED RT == RETAD(J) %IF RT_RA = 0 %START; ! NO RETURN ADDRESS!!!!!!!! %PRINTTEXT ' RETURN ERROR IN ROUTINE ' MONITOR -> STOP %FINISH PC = RT_RA; RT_RA = 0; ! RETURN PC AND CLEAR RET ADDR LAST RT = RT_LAST RT; ! RESET LAST ROUTINE NAME -> ROUND INSTR(7): ! JUMP PC = WORD_ADDR; ! ADJUST PCOUNT -> ROUND INSTR(9): ! 8 WAY BRANCH TL = 0; ! CLEAR 8-WAY BRANCH CONTROL VARIABLES SELECT = 0 KWORD == WORD; ! POINT TO THIS INSTRUCTION -> ROUND INSTR(10): ! TEST LINE FOR 8 WAY BRANCH %IF WORD_NAME = 0 = WORD_MODULE %C %THEN FLG = WORD_ADDR>>8-1 %ELSE FLG = EXTRACT ! GET TEST LINE VALUE !%HIGH,%LOW OR FLAG FLG = 1 %IF FLG # 0; ! ADJUST FLAG VALUE SELECT = SELECT<<1!FLG; ! BUILD UP ADDRESS %IF TL = 2 %START; ! ALL TEST LINES EXTRACTED DV = NAME(KWORD_NAME); ! GET BRANCH TAGS INDEX=TABLES(DV_TAGS_WHERE)_W(SELECT); !GET BRANCH ADDRESS %IF INDEX = 0 %START; ! LABEL NOT SET!!!!! PRINTSTRING(' LABEL '.DV_TEXT.'(') PRINTSYMBOL('0'+SELECT) %PRINTTEXT ') NOT DEFINED ' MONITOR -> STOP %FINISH PC=INDEX %FINISH TL = TL+1 -> ROUND INSTR(11): ! BREAKPOINT CURBREAK == BREAKPOINT(CRRNT); ! SAVE WHICH BREAKPOINT CURBREAK_COUNT = CURBREAK_COUNT-1 %UNLESS CURBREAK_COUNT = 0 ! DECR COUNT IF ANY -> ROUND %IF CURBREAK_IGNORE # 0 %OR CURBREAK_COUNT # 0 ! NO EFFECT IF IGNORED OR HELD FORCE OUTPUT; ! CLEAR BUFFERS PRINTSTRING('BREAKPOINT '.V_TEXT.' ');! PRINT MESSAGE PC=PC+1;! TO SKIP BREAKPOINT INSTRUCTION %RETURN INSTR(15): ! EXTRA EVOKE FOR WOMBLE INSTR(12): ! CONTINUATION FOR EVOKE %IF WORD_MODULE = 12 %START; ! SINT MODS(CRRNT)_B = RESULT; ! STORE RESULT PRINT(V_TAGS_WHERE>>8, RESULT); ! OUTPUT VALUE -> ROUND %FINISH %IF WORD_MODULE = 24 %START; ! SPM REG STORE DUM1 == MMODS(CRRNT)_STORE DUM1(WORD_ADDR) <- RESULT -> ROUND %FINISH STORE(WORD_ADDR); ! OTHERWISE DO STORE INSTR(13): ! CONTINUATION MERGE -> ROUND INSTR(14): ! FLAG OPERATION FLAG OP(WORD_OPRN); ! DO FLAG OPERATION -> ROUND STOP: INSTR(8): ! STOP STPFLAG = 1; ! SET FLAG TO PREVENT %CONTINUE %PRINTTEXT ' STOPPED AT LINE' WRITE(WORD_STAT, 1); ! LINE NUMBER NEWLINE %END ! N = BUFFERS %WHILE BLIST # 0 %CYCLE; ! GO ROUND BUFFER CHAIN NP == NAME(BLIST); L = NP_TAGS_WHERE; ! GET NEXT BUFFER NAME NP_TAGS_WHERE = 0 J = 0 J = 1 %UNLESS 10 <= NP_TAGS_TYPE <= 11; ! NEED 2 BUFFERS FOR SINT GPINT %CYCLE K = 0, 1, J; ! ROUND NO. OF BUFFERS NEEDED TIMES BUF == BUFFER(BUFFERS) BUF = 0; ! CLEAR NEXT FREE BUFFER BUF_OWNER = BLIST; ! SET UP OWNER NAME %IF J = 0 %THEN BUF_TYPE = NP_TAGS_TYPE&1 %C %ELSE BUF_TYPE = K ! SET UP TYPE (IN=0,OUT=1) NP_TAGS_WHERE = NP_TAGS_WHERE!(BUFFERS<<(BUF_TYPE<<3)) ! PACK BUFFER ADDRESSES BUF_SYMS = 80 %IF BUF_TYPE = 1; ! INITIALIZE OUTPUT BUFFERS = BUFFERS-1; ! DECR NO. OF BUFFERS %REPEAT BLIST = L; ! NEXT IN CHAIN %REPEAT %IF BUFFERS > 1 %START; ! ERROR %PRINTTEXT ' BUFFER ALLOCATION FAILS ' %MONITORSTOP %FINISH BUFFERS = N-BUFFERS; ! RESTORE NUMBER OF BUFFERS STPFLAG = 1; ! SET FLAG TO PREVENT %CONTINUE TRACE = 0; ! TRACE OFF LAST = -2 1: PHRASE(-1): RESULT = 0 RECONSTRUCT(0); ! GET NEXT COMMAND LP = 1; ! SET UP VARIABLES FOR PARSE SM = 0 RP = 0 REC(1) = -1 NAME FAULT = 0; NAME FLAG = 0 FAULT(0) %AND -> 1 %UNLESS PARSE(0) = 1; ! NAME OR SYNTAX FAULT K = 0 REC(0) = RP -> 1 %IF RP = 0 %IF CONTROL&1 # 0 %START; ! PRINT ANALYSIS RECORD IF ENABLED %CYCLE J = 1, 1, RP WRITE(REC(J), 5) K = K+1 K = 0 %AND NEWLINE %IF K >= 12 %REPEAT NEWLINE %FINISH RP = 1 PP = REC(1) -> PHRASE(PP) PHRASE(1): !%CONTINUE (REPEAT COUNT') FAULT(0) %AND -> 1 %IF STPFLAG = 1 ! CANNOT CONTINUE AFTER A STOP RP = RP+1 %IF EN # 0 %START %IF EN = 1 %THEN CURBREAK_COUNT = REC(RP) %ELSE %START ! FOR STAT OR PROG BREAK USE CURBREAK , FOR COND SEARCH LIST %IF CCOUNT # 0 %START; ! ALL BREAKPOINTS MAY HAVE BEEN CANCELED! %CYCLE J = 1, 1, CCOUNT C == CONPT(J) C_FIRED = 0 %AND C_COUNT = REC(RP) %IF C_FIRED = 1 ! COND BREAK THAT HAS CAUSED THE HALT (MAY BE MORE THAN ONE) %REPEAT %FINISH %FINISH %FINISH STBR = 0; ! CLEAR FLAG SIMULATE(1); ! CONTINUE SIMULATING -> 1 PHRASE(2): ! (LOCATION) <- (PLUS') !(CONSTANT) RP=RP+1 %IF REC(RP) = 0 %THEN LOCATION(DV) %ELSE DV=DUMMYNAME RP = RP+1; N = REC(RP+1); ! GET CONSTANT N = -N %IF REC(RP) # 0; ! NEGATIVE? FAULTS = 0 WORD == STORE WORD; ! FAKE INSTR FOR SMAP WORD_MODULE = DV_TAGS_TYPE SMAP(DV) <- N; ! STORE VALUE IN LOCATION ADDRESSED RESULT=N; SET BUS -> 1 PHRASE(3): !%GO ! ! FIRST CLEAR ROUTINE RETURN LISTS AND MODULES ! LAST RT = 0; ! SET BASIC LEVEL %CYCLE J = 1, 1, RC RETAD(J) = 0 %REPEAT %CYCLE L = 1, 1, NMT MODS(L) = 0 %REPEAT ! LSBR = 0; STBR = 0 STPFLAG = 0 PC = HEADER_STARTAD; ! GET START ADDRESS SIMULATE(0); ! SIMULATE -> 1 ! PHRASE(4): !%TRACE (ON-OFF) RP = RP+1 %IF REC(RP) = 0 %THEN TRACE = 0 %ELSE %START ! %TRACE %OFF !%TRACE %ON RP = RP+1; TRACE = REC(RP) TRACE = 1 %IF TRACE = 0; ! IF NO DESTINATION MAKE IT .TT %IF TRACE = 3 %THEN OUT(3) = NAME(REC(RP+1))_TEXT ! SET UP FILE NAME LAST = -2; ! INIT TRACE DEFINE('ST77,'.OUT(TRACE)); ! DEFINE TRACE STREAM %FINISH -> 1 PHRASE(5): ! (FLAG OPERATION) [NAMELIST] RP = RP+1 J = REC(RP) RP = RP+1 N = REC(RP) %CYCLE N = 1, 1, N RP = RP+1 CRRNT = NAME(REC(RP))_TAGS_USED; ! GET ADDRESS OF FLAG FLAGOP(J); ! PERFORM OPERATION %REPEAT -> 1 PHRASE(6): !%MAP (LOCATION) (RLOCLIST') !(WHERE') -> 1 PHRASE(7): ! ? (COND) (RCONDLIST') %UNTIL REC(RP) = 0 %CYCLE; ! ROUND TILL END OF COND LIST CCOUNT = CCOUNT+1; ! INCREMENT COND TRAP COUNT C == CONPT(CCOUNT); C = 0 ! SET UP POINTER TO NEXT COND RECORD AND ZERO IT RP = RP+1 %IF REC(RP) # 0 %THEN DV = DUMMY NAME %ELSE LOCATION(DV) ! EITHER SET UP TAGS FOR BUS OR GET LOCATION INFO MI = DV_TAGS_TYPE C_DESC = DV; ! PUT TAGS IN COND RECORD %IF Q(MI) = 0 %START; ! ERROR. LOCATION NOT CONDABLE PRINTSTRING(C_DESC_TEXT) %PRINTTEXT ' NOT VALID ' C_W == NMT; ! POINT C_W TO ANYWHERE TO PREVENT ADDRESS ERRORS CCOUNT = CCOUNT-1; !DECREMENT COND COUNT %FINISH %ELSE %START WORD == OBJECT(0); WORD_MODULE = MI ! SET UP PSEUDO INSTRUCTION FOR MAPPING ROUTINE C_W == SMAP(C_DESC); ! SET UP POINTER TO TRAPPED LOCATION %FINISH RP = RP+1 C_FLAG = 1 %C %IF (DV_TAGS_TYPE = 2 %AND DV_TAGS_BITS # 0) %OR NK = 2 ! TRAPPED VARIABLE IS A NON-MODULE FLAG I.E. BIT EXTRACTS, ETC. C_COND = REC(RP); ! ENTER CONDITION TYPE INTO COND RECORD %IF REC(RP) = 0 %THEN C_TEST = C_W %ELSE %START ! IF TEST IS NOT ON VARIABLE CHANGE (I.E. NO CONDITION IS !SPECIFIED ) STORE TEST VALUE IN C_TEST RP = RP+1 C_TEST = REC(RP); ! STORE TEST VALUE %FINISH RP = RP+1 %REPEAT; ! UNTIL END OF LIST -> 1 PHRASE(8): ! %TREG [NAME] (PIN DEFINITION) -> 1 PHRASE(9): ! # (LOCATION) (RLOCLIST') %UNTIL REC(RP) = 0 %CYCLE RP = RP+1 %IF REC(RP) = 0 %THEN LOCATION(DV) %ELSE DV = DUMMY NAME ! GET LOCATION TAGS OR ELSE GENERATE BUS TAGS SHOW(DV); ! DISPLAY NAME AND VALUE RP = RP+1 %REPEAT -> 1 PHRASE(10): ! %DEFINE (EQITEM) (RDEFINE') -> 1 PHRASE(11): ! %DUMP (WHERE') RP = RP+1 REC(RP) = 1 %IF REC(RP) = 0; ! .TT IF NO DEST GIVEN %IF REC(RP) = 3 %THEN OUT(3) = NAME(REC(RP+1))_TEXT ! GET FILE NAME DEFINE('ST76,'.OUT(REC(RP))); ! DEFINE DUMP STREAM SELECTOUTPUT(76) SHOW(DUMMY NAME); ! DISPLAY THE BUS CONTENTS %IF NNAMES > 0 %START; ! ANY NAMES? %CYCLE J = 1, 1, NNAMES; ! ROUND FOR EVERY NAME SHOW(NAME(J)); ! WRITE OUT VALUE AND NAME %REPEAT %FINISH SELECTOUTPUT(0); ! SELECT CONSOLE AGAIN -> 1 PHRASE(12): ! %IGNORE [OLD NAME LIST] ! ! THIS FUNCTION CAUSES A FLAG TO BE SET(_IGNORE) IN THE ! DATA ELEMENT ASSOCIATED WITH THE BREAKPOINTS NAMED WHICH !CAUSES THEM TO BE IGNORED WHEN ENCOUNTERED IN THE INSTRUCTION ! FLOW,THAT IS THEY WILL NOT CAUSE A BREAKPOINT TO BE GENERATED. ! RP = RP+1 %IF REC(RP) = 0 %START; ! IGNORE ALL %CYCLE J = 1, 1, BC; ! ROUND ALL BREAKPOINTS BREAKPOINT(J)_IGNORE = 1; ! SET FLAG %REPEAT -> 1 %FINISH ! LIST OF NAMES TO FOLLOW %CYCLE J = 1, 1, REC(RP); ! REC(RP) HAS LENGTH OF LIST RP = RP+1 DV = NAME(REC(RP)) %IF DV_TAGS_TYPE # 17 %START; ! NAME NOT A BREAKPOINT NAME CURRENT == DV_TEXT FAULT(5); ! NOT A BREAKPOINT (NAME) %FINISH %ELSE BREAKPOINT(DV_TAGS_USED)_IGNORE = 1 ! SET FLAG %REPEAT -> 1 PHRASE(13): ! %REPLACE [OLDNAME LIST] ! ! THIS FUNCTION REINSTATES A PROGRAMMED BREAKPOINT THAT HAS ! BEEN 'IGNORED' , THAT IS IT WILL NOW CAUSE THE ! SIMULATOR TO GO DOWN IN A BREAK. ! THIS IS SIGNALED BY SETTING _IGNORE TO 0 ! RP = RP+1 %IF REC(RP) = 0 %START; ! REPLACE ALL %CYCLE J = 1, 1, BC; ! ROUND ALL BREAKPOINTS BREAKPOINT(J) = 0; ! CLEAR FLAG %REPEAT -> 1 %FINISH %CYCLE J = 1, 1, REC(RP) RP = RP+1 DV = NAME(REC(RP)) %IF DV_TAGS_TYPE # 17 %START; ! NOT A BREAKPOINT NAME CURRENT == DV_TEXT FAULT(5) %FINISH %ELSE BREAKPOINT(DV_TAGS_USED) = 0 ! CLEAR FLAG %REPEAT -> 1 PHRASE(14): ! %ENDOFSIM %PRINTTEXT '#CLOSE ' %RETURN; ! TERMINATE SIMULATOR RUN PHRASE(15): ! %CANCEL ! THIS ALLOWS ONE TO DELETE SELECTED CONDITIONAL BREALPOINTS ! BY GIVING THE NAME ON WHICH THE TRAP WAS SET ! (ALL TRAPS FOR THAT LOCATION WILL BE REMOVED) ! IF NO LOCATION IS GIVEN ALL TRAPS WILL BE REMOVED FAULT(0) %AND -> 1 %IF CCOUNT = 0; ! NO CONDITIONAL BREAKPOINTS RP = RP+1 CCOUNT = 0 %AND -> 1 %IF REC(RP) = 0; ! REMOVE ALL BREAKPOINTS %UNTIL REC(RP) = 0 %CYCLE; ! ROUND UNTIL END OF LIST RP = RP+1 %IF REC(RP) = 0 %THEN LOCATION(DV) %ELSE DV = DUMMY NAME ! GET TAGS FOR LOCATION OR GENERATE BUS TAGS %CYCLE J = 1, 1, CCOUNT; !ROUND FOR NUMBER OF BREAKS C == CONPT(J); ! POINTER TO CURRENT BREAK INFO C_FIRED = 2 %C %IF C_DESC_TEXT = DV_TEXT %AND C_DESC_TAGS_ %C TYPE = DV_TAGS_TYPE ! SET FIRED TO 2 IF LOCATION MATCHES TRAPPED LOCATION %REPEAT RP = RP+1 %REPEAT; ! UNTIL END OF LIST T = 0; ! NO BREAKS AS YET REMOVED %CYCLE J = 1, 1, CCOUNT; ! ROUND FOR NUMBER OF TRAPS C == CONPT(J); ! POINT TO CURRENT BUGLAB: %IF C_FIRED = 2 %THEN T = T+1 %ELSE CONPT(J-T) = C ! IF BREAK IS TO BE REMOVED(FIRED=2) THEN INCREMENT T !ELSE COPY THIS RECORD 'T' RECORDS DOWN ARRAY TO COMPACT STORAGE %REPEAT CCOUNT = CCOUNT-T; ! ADJUST NUMBER OF BREAKS -> 1 PHRASE(16): ! %BREAK RP = RP+1; SINGLE SHOT = 1 %AND -> 1 %IF REC(RP) = 0 ! SET SINGLE SHOT MODE IF NO LINE NUMBER LIST %UNTIL REC(RP) = 0 %CYCLE RP = RP+1; N = REC(RP) BCOUNT = BCOUNT+1; ! INCR BREAK COUNT BSTATS(BCOUNT)_COUNT = 0; ! CLEAR HOLD COUNT BSTATS(BCOUNT)_IGNORE = N; ! STORE LINE NUMBER RP = RP+1 %REPEAT SINGLE SHOT = 0; ! DISABLE SS -> 1 PHRASE(17): ! %FREE %IF BCOUNT = 0 %START %IF SINGLE SHOT # 0 %THEN SINGLE SHOT = 0 %ELSE FAULT(0) ! CLEAR SS ,OR ESLE GIVE FAULT -> 1 %FINISH SINGLE SHOT = 0 BCOUNT = 0 %AND -> 1 %IF REC(RP+1) = 0 !REMOVE ALL STATEMENT BREAKS %UNTIL REC(RP) = 0 %CYCLE RP = RP+1 %CYCLE J = 1, 1, BCOUNT; ! COMPARE WITH ALL BREAKS BSTATS(J)_IGNORE = -1 %IF BSTATS(J)_IGNORE = REC(RP) ! SET SIGNAL THAT THIS BREAK FREED %REPEAT RP = RP+1 %REPEAT T = 0 CURBREAK==DUMMY BREAK%IF CURBREAK_IGNORE=-1 %CYCLE J = 1, 1, BCOUNT; ! COMPACT ARRAY BUGLAB2: %IF BSTATS(J)_IGNORE = -1 %THEN T = T+1 %C %ELSE BSTATS(J-T) = BSTATS(J) ! INCR FREED COUNT OR MOVE VALUE DOWN %REPEAT BCOUNT = BCOUNT-T; ! ADJUST BREAK COUNT -> 1 PHRASE(18): ! CONTROL ! %CONTROL 1 ENABLES PRINTING OF ANALYSIS RECORDS ! %CONTROL 2 ENABLES INHIBIT OF MESSAGES !%CONTROL 4 (%TRAPS) PRINTS OUT BREAKPOINT !%CONTROL 7(%NAMES) PRINTS OUT TAGS FOR NAMES RP = RP+1; N <- REC(RP) SINT MODE = N&1 %AND ->1 %IF N&16 # 0 BDISP %AND -> 1 %IF N = 4 DISPLAY %AND -> 1 %IF N = 7 SDISPLAY%AND ->1 %IF N=15;! DISPLAY NAME TAGS FOR SYSTEM CONTROL <- N -> 1 PHRASE(21): ! %CLEAR %BUS BUS1 = 0; BUS1_DZ = 1; -> 1; ! ZERO BUS AND SET DZ PHRASE(23): ! %RADIX %IF REC(RP+1) <= 0 %THEN FAULT(0) %ELSE RADIX = REC(RP+1) ! SET RADIX IF VALID -> 1 PHRASE(24):! -> (OLD NAME) RP = RP+1; TEMP NAME == NAME(REC(RP)) FAULT(6) %AND ->1 %IF TEMP NAME_TAGS_TYPE # 14;! NOT A LABEL PC = TEMP NAME_TAGS_WHERE+1 PRINTSTRING('CONTINUING FROM '.TEMP NAME_TEXT) NEWLINE ->PHRASE(1) %END; ! OF COMPILE BLOCK ! CLEAR OUT MEMORY SPACE, ROUTINE SPACE AND BREAKPOINT SPACE %CYCLE PC = 1, 1, MQ STR(PC) = 0 %REPEAT %CYCLE PC = 1, 1, RC RETAD(PC) = 0 %REPEAT %CYCLE PC = 1, 1, BC BREAKPOINT(PC) = 0 %REPEAT ! CLEAR SYSTEM VARIABLES STBR = 0; SINGLE SHOT = 0 CCOUNT = 0; ! COND BREAK COUNT BCOUNT = 0; ! STAT BREAK COUNT STPFLAG = 1; ! SET STOP FLAG NK = 1 N = NNAMES %WHILE N # 0 %CYCLE; ! ROUND FOR ALL NAMES V1 == NAME(N)_TAGS %IF V1_USED # 0 %START; ! USED NAME %IF V1_MASTER # N %START; ! EQUIVALENCED NAME V2 == NAME(V1_MASTER)_TAGS V1_USED = V2_USED %IF MODTY(V2_TYPE) # 0 ! IF NAME REFERS TO A MODULE REG THEN POINT IT AT ITS MASTERS ! STORAGE SPACE %FINISH %ELSE %START PC = MODTY(V1_TYPE) %IF PC # 0 %START; ! MODULE TYPE %IF PC = 1 %START; ! NOT MEMORY TYPE MODS(V1_USED) = 0;! CLEAR LOCATION %FINISH %ELSE %START MMODS(V1_USED)_MEMADDR = 0; ! SET MEMADDR REG TO 0 %IF V1_SIZE # 0 %THEN PC = V1_SIZE %ELSE %START %IF V1_TYPE = 4 %THEN PC = 16 %ELSE PC = 1024 %FINISH; ! FIND AMOUNT OF SPACE NEEDED FOR MEMORY MMODS(V1_USED)_STORE == ARRAY(ADDR(STR(NK)), %C MEMODAFM) ! MAP ONTO NEXT SPACE IN 'STORE' MMODS(V1_USED)_LIMIT = PC; ! STORE MAX SIZE NK = NK+PC; ! MOVE FREE STORE POINTER %FINISH %FINISH %FINISH %FINISH N = N-1 %REPEAT BUS1 = 0; ! CLEAR BUS BUS1_DZ = 1; ! SET DZ DUMMY BREAK =0;! CLEAR DUMMY BREAKPOINT CURBREAK == DUMMY BREAK;! TO PREVENT ERRORS COMPILE BLOCK; ! RUN %END %END; ! OF SAM %ENDOFFILE @@@@@@@@@@@@@@@ %OWNSTRING (15) OUTPUT = '.TT' %OWNSTRING (15) SOURCE = 'SS#ARTH' %CONSTSTRING (6) %ARRAY OPCODES(0 : 15) = %C 'NOP ', 'EVOKE ', 'BUS ', 'COND ', 'MERGE ', 'RTCALL', 'RETURN', 'JUMP ', 'STOP ', 'BRANCH', 'T-LINE', 'BREAK', ' CONT',' CMRGE','+FLAG ', 'UNDEF ' %CONSTINTEGER NMAX = 100 %RECORDFORMAT EXTERNFM(%BYTEINTEGER FROM, FBITS, TO, TOBITS) %CONSTINTEGER EXTLNG = 100 %RECORDFORMAT CODEFM(%BYTEINTEGER CODE, NAME, OPRN, MODULE, %C %SHORTINTEGER DEST, STAT) %RECORDFORMAT HEADFM( %C %INTEGER IDEN, USEAGE, NNAMES, NAMES, TEXT, CODE, %C CONSTANTS, OLD FILE, TXTLNG, STARTAD, EXTERNS, TABS) %RECORDFORMAT TAGFM(%INTEGER MASTER, %SHORTINTEGER TYPE, %C %BYTEINTEGER USED, BITS, %INTEGER USE, DEFN, SIZE, WHERE) %RECORDFORMAT NAMEFM(%INTEGER NAME,%RECORD TAGS(TAGFM)) %EXTERNALROUTINESPEC DEFINE(%STRING(63) S) %ROUTINE CONNEKT(%STRING(17) FILE, %INTEGERNAME AD,FLAG) %SYSTEMROUTINESPEC FDP(%INTEGER E,%STRING(17) S,%INTEGER A,B,%C %INTEGERNAME F) FDP(7,FILE,0,ADDR(AD),FLAG);! CONNECT FILE FLAG=0 %IF FLAG=5 %END %ROUTINE HSYM(%INTEGER N) %CONSTBYTEINTEGERARRAY SS(0 : 15) = %C '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F' PRINTSYMBOL(SS(N)) %END %ROUTINE HB(%INTEGER N) HSYM(N>>4); HSYM(N&15) %END %ROUTINE HS(%INTEGER N) HB(N>>8&255); HB(N&255) %END %EXTERNALROUTINE PDPDUMP(%STRING (63) S) %INTEGER I %RECORDARRAYFORMAT EXTARFM(1 : EXTLNG)(EXTERNFM) %RECORDARRAYNAME EXTERNALS(EXTERNFM) %RECORDFORMAT TABFM(%SHORTINTEGERARRAY W(0 : 7)) %RECORDARRAYFORMAT TBAFM(1 : 50)(TABFM) %RECORDARRAYNAME TABLES(TABFM) %RECORDARRAYFORMAT OBJFM(0 : 2000)(CODEFM) %RECORDARRAYFORMAT TEXTFM(1 : NMAX)(NAMEFM) %SHORTINTEGERARRAYFORMAT USEFM(0 : 20) %SHORTINTEGERARRAYFORMAT CONFM(0 : 60) %RECORDARRAYNAME OBJECT(CODEFM) %RECORDARRAYNAME NAME(NAMEFM) %RECORDNAME NP(NAMEFM) %RECORDNAME CP(CODEFM) %SHORTINTEGERARRAYNAME USE %SHORTINTEGERARRAYNAME CONSTANTS %RECORDNAME HEADER(HEADFM) %RECORDNAME TAGS(TAGFM) %EXTERNALROUTINESPEC HEX(%INTEGER N) %INTEGER OP, AD, FLAG, J, K, L, LIMIT, DISP SOURCE = S %UNLESS S = '' %IF SOURCE -> SOURCE.('/').OUTPUT %START SOURCE = 'SS#ARTH' %IF SOURCE = '' %FINISH DEFINE('ST11,'.OUTPUT) AD = 7; ! READ ONLY CONNEKT(SOURCE, AD, FLAG) %IF FLAG # 0 %START PRINTSTRING('CANNOT CONNECT '.SOURCE.', FLAG =') WRITE(FLAG, 1) NEWLINE %RETURN %FINISH %ROUTINE PS(%INTEGER AD) %STRING (8) S S <- STRING(AD+DISP) PRINTSTRING(S) SPACES(10-LENGTH(S)) %END AD = AD+16 HEADER == RECORD(AD) %IF HEADER_IDEN # M'ARTH' %START PRINTSTRING(SOURCE.' IS NOT AN ARTHUR OBJECT FILE ') %RETURN %FINISH SELECTOUTPUT(11) DISP = AD-HEADER_OLD FILE-16 NAME == ARRAY(AD+HEADER_NAMES, TEXTFM) EXTERNALS == ARRAY(AD+HEADER_EXTERNS, EXTARFM) TABLES == ARRAY(AD+HEADER_TABS, TBAFM) OBJECT == ARRAY(AD+HEADER_CODE, OBJFM) USE == ARRAY(AD+HEADER_USEAGE, USEFM) CONSTANTS == ARRAY(AD+HEADER_CONSTANTS, CONFM) PRINTSTRING(' DUMP OF ARTHUR OBJECT FILE: '.SOURCE) %PRINTTEXT ' CODE LOCN STAT CD NM OP MD ADDR ' K = HEADER_NNAMES J = 0 LIMIT = HEADER_CONSTANTS+AD %UNTIL (CP_CODE = 8 %AND CP_OPRN = 0) %C %OR ADDR(CP) >= LIMIT %CYCLE J = J+1; CP == OBJECT(J) ! HS(J); SPACES(2); WRITE(CP_STAT&X'7FFF', 2); SPACES(4) HB(CP_CODE); SPACE HB(CP_NAME); SPACES(2) HB(CP_OPRN); SPACE HB(CP_MODULE); SPACES(2) HS(CP_DEST) SPACES(4) %IF CP_MODULE = 5 %C %THEN HS(CONSTANTS(CP_NAME)) %AND SPACES(6) %ELSE %START %IF 0 < CP_NAME <= K %THEN PS(NAME(CP_NAME)_NAME) %C %ELSE SPACES(10) %FINISH %IF CP_STAT < 0 %THEN %PRINTTEXT '*' %ELSE %START SPACE L = CP_CODE L = 15 %IF L > 14 PRINTSTRING(OPCODES(L)) %FINISH NEWLINE %REPEAT %PRINTTEXT ' NAMES NAME MAST TY US BT USE DEFN SIZE WHERE ' %WHILE K > 0 %CYCLE NP == NAME(K); TAGS == NP_TAGS PS(NP_NAME); HS(TAGS_MASTER); SPACES(2) HB(TAGS_TYPE); SPACE HB(TAGS_USED); SPACE HB(TAGS_BITS) SPACES(2) HEX(TAGS_USE); SPACE HEX(TAGS_DEFN) WRITE(TAGS_SIZE, 4); SPACES(2) HEX(TAGS_WHERE) NEWLINE %IF 6 <= TAGS_TYPE <= 7 %START SPACES(6) %IF TAGS_WHERE = 0 %C %THEN %PRINTTEXT ' STANDARD SETTING ' %ELSE %START L = ADDR(TABLES(TAGS_WHERE)) %CYCLE I = 0, 1, 15 SPACE HB(BYTEINTEGER(L)) L = L+1 %REPEAT NEWLINE %FINISH %FINISH %IF TAGS_TYPE = 8 %START SPACES(5) %CYCLE L = 0, 1, 7 SPACES(2) HS(TABLES(TAGS_WHERE)_W(L)) %REPEAT NEWLINE %FINISH K = K-1 %REPEAT NEWLINES(2) %PRINTTEXT ' =========== END OF DUMP ========== ' %END %ENDOFFILE @@@@@@@@@@@@@@@ !***************************************************************** !***************************************************************** !** ** !** WIRING OF MODULES BY LINKED EVOKES ** !** ** !** CS4 PDP-16 GROUP PROJECT 1974 ** !** ** !***************************************************************** !***************************************************************** %CONSTSTRING (100) TITLE = 'WOMBLE : VERSION 2.0 ====== = ======= === ' %CONSTINTEGERARRAY MODPIN(1 : 544) = %C M'BR1',M'BS1',M'BN2',M'BP2',M'BR2',M'BS2',M'BU1',M'BV1', M'AH2',M'AJ2',M'AL2',M'AE2',M'AD2',M'AM2',M'AK2',M'AF2', M'AN2',M'AV1',M'AV2',M'AP2',M'AU2',M'AR2',M'AS2',M'AT2', M'BH2',M'BJ2',M'BL2',M'BK2',M'BL1',M'BM1',M'BN1',M'BP1', M'BV2',M'BT2',M'BM2',M'BU2',M'BB2',M'BJ1',M'BF2',M'BD2', M'BE2',M'BF1',M'BH1', M'AV2',M'BU2',M'BT2',M'BV2',M'BR2',M'BP2',M'BS2',M'BK2', M'BN1',M'BM2',M'BL2',M'BN2',M'BH2',M'BJ2',M'BH1',M'BF1', M'BM1',M'BL1',M'BK1',M'BJ1',M'BF2',M'BE2',M'BD2',M'BB2', M'AU2',M'AT2',M'AS2',M'AR2',M'AP2',M'AN2',M'AM2',M'AL2', M'AK2',M'AJ2',M'AH2',M'AF2',M'BP1',M'BR1',M'BS1',M'BU1', M'BV1',M'AV1', M'BR1',M'BS1',M'BN2',M'BP2',M'BR2',M'BS2',M'BP1',M'BN1', M'AD2',M'AE2',M'AF2',M'AH2',M'AJ2',M'AK2',M'AL2',M'AM2', M'AN2',M'AP2',M'AR2',M'AS2',M'AT2',M'AU2',M'BD2',M'BE2', M'BL1',M'BM1',M'BJ2',M'BK2',M'BL2',M'BM2',M'BK1',M'BJ1', M'AB2',M'BF2', M'BF1',M'BH1',M'BJ1',M'BK1',M'AB2',M'AD2',M'AE2',M'AF2', M'AH2',M'AJ2',M'AK2',M'AL2',M'AM2',M'AN2',M'AP2',M'AR2', M'AS2',M'AT2',M'AU2',M'AV2',M'BE2',M'BF2',M'BH2',M'BJ2', M'BR1',M'BS1',M'BN1',M'BP1',M'BL1',M'BM1',M'BU2',M'BV2', M'BS2',M'BT2',M'BP2',M'BR2',M'BM2',M'BN2',M'BK2',M'BL2', M'BE2',M'BF2',M'BH2',M'BJ2',M'BR1',M'BS1',M'BN1',M'BP1', M'BL1',M'BM1',M'BU2',M'BV2',M'BS2',M'BT2',M'BP2',M'BR2', M'BM2',M'BN2',M'BK2',M'BL2', M'BF1',M'BH1',M'BJ1',M'BK1',M'AB2',M'AD2',M'AE2',M'AF2', M'AH2',M'AJ2',M'AK2',M'AL2',M'AM2',M'AN2',M'AP2',M'AR2', M'AS2',M'AT2',M'AU2',M'AV2', M'BM2',M'BL2',M'BN2',M'BP2',M'BU2',M'BT2',M'BR2',M'BS2', M'BH1',M'BF1',M'BK1',M'BJ1',M'AL2',M'AN2',M'BM1',M'BL1', M'AK2',M'AM2', M'BR2',M'BS2',M'BP2',M'BN2',M'BR1',M'BS1',M'BT2',M'BU2', M'BJ1',M'BK1',M'BL2',M'BM2',M'BL1',M'BM1',M'BN1',M'BP1', M'BU1',M'BV1',M'BT2',M'BS2',M'BL2',M'BK2',M'BJ2',M'BF1', M'AH2',M'AF2',M'AE2',M'AD2',M'AM2',M'AL2',M'AK2',M'AJ2', M'AS2',M'AR2',M'AP2',M'AN2',M'BH2',M'BF2',M'BE2',M'BD2', M'BS1',M'BN2',M'BP2', M'BD2',M'BE2',M'BF2',M'BH2',M'BU1',M'BV1',M'BR1',M'BS1', M'BN1',M'BP1',M'BL1',M'BM1',M'AD2',M'AE2',M'AH2',M'AF2', M'AJ2',M'AK2',M'AM2',M'AL2',M'AN2',M'AP2',M'AS2',M'AR2', M'AT2',M'AU2',M'AV1',M'AV2', M'AJ2',M'AH2',M'AF2',M'AE2',M'AR2',M'AN2',M'AL2',M'AK2', M'AT2',M'AS2',M'BK2',M'BJ2',M'BB2',M'AU2',M'BM2',M'BL2', M'BH1',M'BH2',M'BK1',M'BJ1',M'BE2',M'BD2',M'BF1',M'BF2', M'BS2',M'BR2',M'BP2',M'BN2',M'BV1',M'BU1',M'BM1',M'BL1', M'BR1',M'BS1',M'BP1',M'BN1',M'BU2',M'BV2', M'BD2',M'BE2',M'BF2',M'BH2',M'BL1',M'BM1',M'BN1',M'BP1', M'BF1',M'BH1',M'BJ1',M'BK1', M'J1',M'F1',M'J2',M'L1',M'H1',M'K1',M'F2',M'E2', M'T2',M'R2',M'P2',M'U2',M'S2',M'V1',M'U1',M'D2', M'N1',M'R1',M'M2',M'L2',M'P1',M'M1',M'N2',M'S1', M'F1',M'H1',M'J1',M'K1',M'L1',M'M1',M'N1',M'P1', M'R1',M'S1',M'U1',M'V1',M'D2',M'E2',M'F2',M'H2', M'J2',M'L2',M'M2',M'N2',M'P2',M'R2',M'S2',M'T2', M'U2',M'V2',M'S2',M'T2',M'E2',M'F2',M'H2',M'J2',M'K2',M'L2', M'V1',M'U1',M'P1',M'R1',M'S1',M'M1',M'L1',M'K1',M'J1',M'N1', M'N2',M'P2',M'R2',M'D2',M'V2', M'A1',M'B1',M'C1',M'D1',M'E1',M'F1', M'H1',M'J1',M'K1',M'L1',M'M1',M'N1', M'P1',M'R1',M'S1',M'D2',M'E2',M'F2', M'H2',M'J2',M'K2',M'L2',M'M2',M'N2', M'P2',M'R2',M'S2',M'T2',M'U2',M'V2', M'A1',M'B1',M'C1',M'D1',M'E1',M'F1',M'H1',M'J1',M'K1',M'L1', M'M1',M'N1',M'P1',M'R1',M'S1',M'D2',M'E2',M'F2',M'H2',M'J2', M'K2',M'L2',M'M2',M'N2',M'P2',M'R2',M'S2',M'T2',M'U2',M'V2', M'H1',M'E2',M'D2',M'F1',M'K1',M'H2',M'F2',M'J1', M'M1',M'K2',M'J2',M'L1',M'P1',M'M2',M'L2',M'N1', M'S1',M'P2',M'N2',M'R1',M'V1',M'S2',M'R2',M'U1',M'V2', M'H1',M'D2',M'E2',M'F1',M'K1',M'F2',M'H2',M'J1', M'M1',M'J2',M'K2',M'L1',M'P1',M'L2',M'M2',M'N1', M'S1',M'N2',M'P2',M'R1',M'V1',M'R2',M'S2',M'U1', M'F1',M'H1',M'J1',M'K1', M'V1',M'U1',M'S1',M'R1',M'P1',M'N1',M'M1',M'L1', M'F2',M'H2',M'J2',M'K2', M'V2',M'U2',M'S2',M'R2',M'P2',M'N2',M'M2',M'L2' %CONSTBYTEINTEGERARRAY NUMPIN(1 : 544) = %C 4,0(3),4,0(3),1(16),8,0(7),1(11), 1(4),4,0(3),4,0(3),4,0(3), 4,0(3),4,0(3),4,0(3), 4,0(3),4,0(3),4,0(3),1,1, 8,0(7),1(16),8,0(7),1,1, 4,0(3),1(16),4,0(3),1(16), 4,0(3),1(16), 4,0(3),1(16), 4,0(3),4,0(3),4,0(3),1(6), 4,0(3),4,0(3),4,0(3),4,0(3), 2,0,2,0,2,0,2,0,1(19), 4,0(3),2,0,2,0,2,0,2,0,1(16), 4,0(3),4,0(3),2,0,2,0,2,0,2,0,2,0, 2,0,2,0,2,0,2,0,2,0, 2,0,2,0,2,0,2,0,2,0, 4,0(3),4,0(3),4,0(3), 1(206) %CONSTBYTEINTEGERARRAY GPAMAP(1 : 12) = %C 25, 21, 17, 13, 33, 29, 9, 5, 4, 3, 1, 2 %CONSTBYTEINTEGERARRAY MODSLOT(0 : 32) = %C 0,1,2,1(5),2,1(5),0(11),1,0(7) %CONSTSHORTINTEGER ABSENS = 0 %CONSTSHORTINTEGER AGPAU = 43 %CONSTSHORTINTEGER AGPAR = 85 %CONSTSHORTINTEGER AGPINT = 119 %CONSTSHORTINTEGER AOPINT = 159 %CONSTSHORTINTEGER AIPINT = 179 %CONSTSHORTINTEGER ASINT = 199 %CONSTSHORTINTEGER ACGEN = 217 %CONSTSHORTINTEGER ATREG = 233 %CONSTSHORTINTEGER ABREG = 260 %CONSTSHORTINTEGER ASPR = 288 %CONSTSHORTINTEGER AMEMORY = 326 %CONSTSHORTINTEGER AFLAG = 338 %CONSTSHORTINTEGER ANOP = 362 %CONSTSHORTINTEGER AEVOKE = 386 %CONSTSHORTINTEGER AFMERGE4 = 396 %CONSTSHORTINTEGER AFRTCALL = 406 %CONSTSHORTINTEGER AMERGE2 = 411 %CONSTSHORTINTEGER AMERGE4 = 441 %CONSTSHORTINTEGER ARTCALL = 471 %CONSTSHORTINTEGER ABRANCH2 = 496 %CONSTSHORTINTEGER ABRANCH8 = 520 %OWNINTEGERARRAY NOBUSSLOTS(0 : 15) = %C M'0C',M'1C',M'2C',M'3C', M'0D',M'1D',M'2D',M'3D', M'CC',M'DC',M'EC',M'FC', M'CD',M'DD',M'ED',M'FD' %OWNINTEGERARRAY CONTRLSLOTS(0 : 45) = %C M'4C',M'5C',M'6C',M'7C', M'8C',M'9C',M'AC',M'BC', M'4D',M'5D',M'6D',M'7D', M'8D',M'9D',M'AD',M'BD', M'DB',M'CB',M'BB',M'AB', M'9B',M'8B',M'7B',M'6B', M'5B',M'4B',M'3B',M'2B', M'1B',M'0B',0(16) %OWNINTEGERARRAY DATASLOTS(0 : 15) = %C M'1',M'2',M'3', M'4',M'5',M'6',M'7', M'8',M'9',M'A',M'B', M'C',M'D',M'E',M'0',M'F' %OWNINTEGERARRAY OPAT(0 : 16) %OWNINTEGERARRAY OPUSE(0 : 16) %OWNINTEGERARRAY OPNUM(0 : 16) %OWNINTEGERARRAY NULLWIRE(0 : 1024) %OWNINTEGERARRAY INSTRWIRE(0 : 1024) %OWNINTEGERARRAY INSTR(0 : 1024) %OWNINTEGERARRAY NAMESLOT(1 : 256) = -1(256) %OWNINTEGERARRAY DATASLOT(0 : 15) %OWNINTEGERARRAY CONTRLSLOT(0 : 45) %OWNINTEGERARRAY NOBUSSLOT(0 : 16) %OWNINTEGERARRAY ITEM(0 : 2048) %OWNSHORTINTEGERARRAY NEXT(0 : 2048) %OWNSHORTINTEGERARRAY WIREINSTR(0 : 1024) %OWNINTEGERARRAY WIRE(0 : 1024) %OWNINTEGERARRAY CHOICE(1 : 2) %OWNSHORTINTEGERARRAY SLOTADDR(1 : 32) %OWNINTEGER ASL = 2048 %OWNSHORTINTEGER HEAD %OWNINTEGER TYPE, FULL, WHAT, CURRENT, PREVIOUS, CHANGED, LOST, %C TLINENO %OWNINTEGER DATALOC=-1 %OWNINTEGER CONTRLOC=-1 %OWNINTEGER NOBUSLOC=-1 %OWNINTEGER FLAGAT, FLAGNUM %OWNINTEGER CGENUM, CGENAT %OWNINTEGER BRANCHAT, BRANCHNUM %OWNINTEGER MERGE2AT, MERGE2NUM %OWNINTEGER FMERGE4LEFT, FMERGE4NUM %OWNINTEGER MERGE4AT, MERGE4NUM %OWNINTEGER FRTCALLAT, FRTCALLNUM, DISPLACED %OWNINTEGER WIRENO, INSTRNO, START !***************************************************************** !*** DECLARATIONS AS PER PDPDUMPS %ENDOFLIST %OWNSTRING (15) OUTPUT = '.TT' %OWNSTRING (15) SOURCE = 'SS#ARTH' %CONSTSTRING (6) %ARRAY MODTYPE(1 : 12) = %C 'GPAUC ','FLAG ','MEMORY','SPREG ', 'CGEN ','BREG ','TREG ','BRANCH', 'GPINT ','IPINT ','OPINT ','SINT ' %CONSTSTRING (6) %ARRAY OPCODES(0 : 14) = %C 'NOP ', 'EVOKE ', 'BUS ', 'COND ', 'MERGE ', 'RTCALL', 'RETURN', 'JUMP ', 'STOP ', 'BRANCH', 'T-LINE', 'BREAK ', 'CONT ','CMERGE','UNDEF ' %CONSTINTEGER NMAX = 100 %RECORDFORMAT EXTERNFM(%BYTEINTEGER FROM, FBITS, TO, TOBITS) %CONSTINTEGER EXTLNG = 100 %RECORDFORMAT CODEFM(%BYTEINTEGER CODE, NAME, OPRN, MODULE, %C %SHORTINTEGER DEST, STAT) %RECORDFORMAT HEADFM( %C %INTEGER IDEN, USEAGE, NNAMES, NAMES, TEXT, CODE, %C CONSTANTS, OLD FILE, TXTLNG, STARTAD, EXTERNS, TABS) %RECORDFORMAT TAGFM(%INTEGER MASTER, %SHORTINTEGER TYPE, %C %BYTEINTEGER USED, BITS, %INTEGER USE, DEFN, SIZE, WHERE) %RECORDFORMAT NAMEFM(%INTEGER NAME,%RECORD TAGS(TAGFM)) %ROUTINE CONNEKT(%STRING(17) FILE, %INTEGERNAME AD,FLAG) %SYSTEMROUTINESPEC FDP(%INTEGER N,%STRING(17) S,%INTEGER J,K,%C %INTEGERNAME FLAG) AD=0 FDP(7, FILE,0, ADDR(AD), FLAG) FLAG=0 %IF FLAG=5 %END %LIST !***************************************************************** %ROUTINE INCRCONTRL %OWNINTEGER FLAG = 0 %INTEGER L CONTRLOC = CONTRLOC+1 %IF FLAG = 0 %AND CONTRLOC+DATALOC >= 29 %THEN %START !*** GET EXTRA CONTROLSLOTS FROM NOBUSSSLOTS %CYCLE L = 0, 1, 15 CONTRLSLOTS(CONTRLOC+L) = NOBUSSLOTS(15-L) %REPEAT FLAG = 1 %FINISH %IF CONTRLOC+DATALOC >= 45 %C %THEN %PRINTTEXT ' *** CONTROL BUS FULL *** ' %C %AND FULL = 1 %AND %RETURN %END !***************************************************************** %ROUTINE AUTOALLOC(%INTEGER OP, N) !*** ALLOCATE SLOTS ON CONTROL BUS %RETURN %IF OPUSE(OP) <= 0 OPAT(OP) = CONTRLOC+1 OPNUM(OP) = (OPUSE(OP)+N-1)//N %CYCLE N = 1, 1, OPNUM(OP) INCRCONTRL %IF FULL = 1 %THEN %RETURN CONTRLSLOT(CONTRLOC) = OP %REPEAT %END !***************************************************************** %ROUTINE AUTOINCR(%INTEGER OP, N) !*** GET NEXT CONTROL ELEMENT - NEW CARD IF NECESSARY %IF OPNUM(OP) = N %C %THEN OPNUM(OP) = 0 %AND OPAT(OP) = OPAT(OP)+1 OPNUM(OP) = OPNUM(OP)+1 %END !***************************************************************** %ROUTINE CON(%INTEGER WHAT, %INTEGERNAME POINTER) !*** CONNECT WIRE OR PIN TO LIST %INTEGER TEMP %RETURN %IF WHAT = 0 TEMP = NEXT(ASL) NEXT(ASL) = POINTER POINTER = ASL ASL = TEMP ITEM(POINTER) = WHAT %IF ASL = 0 %THEN %STOP %END !***************************************************************** %INTEGERFN ACTUAL(%INTEGER SLOT, PIN) !*** ACTUAL PIN FROM SLOT NUMBER AND DISPLACEMENT %RESULT = CONTRLSLOTS(SLOT)<<16+MODPIN(PIN) %END !***************************************************************** %ROUTINE PRINTMC(%INTEGER N) !*** PRINT MULTICONSTANT ROUTINE PRINTSYMBOL(N>>24) PRINTSYMBOL(N>>16&255) PRINTSYMBOL(N>>8&255) PRINTSYMBOL(N&255) %END !***************************************************************** %ROUTINE MERGE(%INTEGER PTR, P, DISP, SLOT) !*** ALLOCATE MERGES FOR FAN-IN %OWNBYTEINTEGERARRAY FLAGMAP(4 : 12) = %C 3,4,5,11,12,13,19,20,21 %INTEGERARRAY TPIN(1:2,1:3) %INTEGERARRAY FPIN(1:10,1:5) %INTEGERARRAY ARRAY(1 : 40) %INTEGER F, T, J, FLAG, IN, N, SHORT !* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * !*** FLAG: 1=MODULE,0=PROGRAM,-1=FLAG CONTROL FLAG = 1 %IF P = 0 %THEN %START P = 1; FLAG = 0 %FINISH %IF P = -1 %THEN %START P = 1; FLAG = -1 %FINISH !* * * * * * * * * * * * * * * * * * * * * * !*** GET ACTUAL INPUT WIRES N = 0 %WHILE PTR # 0 %THEN %CYCLE N = N+1 ARRAY(N) = ITEM(PTR) PTR = NEXT(PTR) %REPEAT !* * * * * * * * * * * * * * * * * * * * * * !*** WILL REQUIRE POST PROCESSING NOT A MERGE1 %IF FLAG = 0 %AND N = 1 %THEN %START NULLWIRE(-ARRAY(1)) = INSTRWIRE(INSTRNO)+1 PREVIOUS = 0 %RETURN %FINISH !* * * * * * * * * * * * * * * * * * * * * * !*** CALCULATE NUMBER OF MERGES REQUIRED F = (N-P)//3 T = (N-P)-F*3 %IF F < 0 %THEN F = 0 %IF T < 0 %THEN T = 0 !* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * !*** GET MERGE2S %IF T > 0 %THEN %START %CYCLE T = 1, 1, T MERGE2NUM = MERGE2NUM-MERGE2NUM//10*10+1 %IF MERGE2NUM = 1 %THEN %START NOBUSLOC = NOBUSLOC+1 MERGE2AT = NOBUSLOC NOBUSSLOT(NOBUSLOC) = 2 %FINISH %CYCLE J = 1, 1, 3 SHORT = MODPIN(AMERGE2+J+3*(MERGE2NUM-1)) TPIN(T, J) = NOBUSSLOTS(MERGE2AT)<<16+SHORT %REPEAT !*** OUTPUTS TEMPORARILY ON INPUT LIST ARRAY(N+T) = TPIN(T, 3) %REPEAT %FINISH !* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * !*** GET MERGE4S FROM EVOKE CARDS IF POSSIBLE %IF F > 0 %THEN %START %CYCLE F = 1, 1, F %IF FMERGE4LEFT > 0 %THEN %START FMERGE4NUM = FMERGE4NUM&1+1 DISPLACED = AFMERGE4+5*(FMERGE4NUM-1) %IF FMERGE4NUM = 1 %THEN MERGE4AT = MERGE4AT+1 %CYCLE J = 1, 1, 5 SHORT = MODPIN(DISPLACED+J) FPIN(F, J) = CONTRLSLOTS(MERGE4AT)<<16+SHORT %REPEAT %FINISH %ELSE %START !* * * * * * * * * * * * * * * * * * * * * * !*** GET MERGE4S FROM MERGE4 CARDS MERGE4NUM = MERGE4NUM-MERGE4NUM//6*6+1 %IF MERGE4NUM = 1 %THEN %START NOBUSLOC = NOBUSLOC+1 MERGE4AT = NOBUSLOC NOBUSSLOT(NOBUSLOC) = 4 %FINISH DISPLACED = AMERGE4+5*(MERGE4NUM-1) %CYCLE J = 1, 1, 5 SHORT = MODPIN(DISPLACED+J) FPIN(F, J) = NOBUSSLOTS(MERGE4AT)<<16+SHORT %REPEAT %FINISH !*** OUTPUTS TEMPORARILY ON INPUT LIST ARRAY(N+T+F) = FPIN(F, 5) FMERGE4LEFT = FMERGE4LEFT-1 %REPEAT %FINISH !* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * !*** ALLOCATE WIRES TO MERGE OUTPUTS IN = N+T+F %IF FLAG = 0 %THEN IN = IN-1 %IF IN > N %THEN %START %CYCLE N = N+1, 1, IN WIRENO = WIRENO+1 CON(ARRAY(N), WIRE(WIRENO)) ARRAY(N) = -WIRENO %REPEAT %FINISH !* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * !*** CONNECT WIRES TO PINS EXCEPT FOR CONTROL %IF FLAG = 0 %THEN PREVIOUS = ARRAY(IN+1) %ELSE %START %IF FLAG = -1 %THEN %START DISP = FLAGMAP(DISP) SHORT = CONTRLSLOTS(SLOT)<<16+MODPIN(AFLAG+DISP) CON(SHORT, WIRE(-ARRAY(IN))) IN = IN-1 %FINISH %ELSE %START %WHILE P > 0 %AND IN > 0 %THEN %CYCLE CON(MODPIN(DISP+P)+DATASLOTS(SLOT)<<24, WIRE(-ARRAY( %C IN))) P = P-1; IN = IN-1 %REPEAT %FINISH %FINISH !* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * !*** CONNECT INPUTS TO MERGE4S %WHILE F > 0 %THEN %CYCLE %CYCLE J = 1, 1, 4 CON(FPIN(F, J), WIRE(-ARRAY(IN))) IN = IN-1 %REPEAT F = F-1 %REPEAT !* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * !*** CONNECT INPUTS TO MERGE2S %WHILE T > 0 %THEN %CYCLE %CYCLE J = 1, 1, 2 CON(TPIN(T, J), WIRE(-ARRAY(IN))) IN = IN-1 %REPEAT T = T-1 %REPEAT %END !***************************************************************** %ROUTINE SORT LIST(%SHORTINTEGERNAME TOP) %SHORTINTEGERNAME N %SHORTINTEGER HEAD %INTEGER J, V, P HEAD = 0 J = TOP %WHILE J # 0 %THEN %CYCLE P = J; J = NEXT(J) V = ITEM(P) N == HEAD N == NEXT(N) %WHILE N # 0 %AND ITEM(N) < V NEXT(P) = N; N = P %REPEAT TOP = HEAD %END !***************************************************************** %EXTERNALROUTINE WOMBLE(%STRING (63) S) %SWITCH OPCODE(0 : 16) %SWITCH EVOMOD(0 : 32) %INTEGERARRAY PINS(0:14,0:43) %INTEGERARRAY FLAGPOLE(0:45,0:12) %INTEGERARRAY TLINES(1 : 3) !***************************************************************** !*** DECLARATIONS AS PER PDPDUMPS %ENDOFLIST %RECORDARRAYFORMAT EXTARFM(1 : EXTLNG)(EXTERNFM) %RECORDARRAYNAME EXTERNALS(EXTERNFM) %RECORDFORMAT TABFM(%SHORTINTEGERARRAY W(0 : 7)) %RECORDARRAYFORMAT TBAFM(1 : 50)(TABFM) %RECORDARRAYNAME TABLES(TABFM) %RECORDARRAYFORMAT OBJFM(0 : 2000)(CODEFM) %RECORDARRAYFORMAT TEXTFM(1 : NMAX)(NAMEFM) %SHORTINTEGERARRAYFORMAT USEFM(0 : 20) %SHORTINTEGERARRAYFORMAT CONFM(0 : 60) %RECORDARRAYNAME OBJECT(CODEFM) %RECORDARRAYNAME NAME(NAMEFM) %RECORDNAME NP(NAMEFM) %RECORDNAME CP(CODEFM) %SHORTINTEGERARRAYNAME USE %SHORTINTEGERARRAYNAME CONSTANTS %SHORTINTEGERARRAYNAME BADDRS %RECORDNAME HEADER(HEADFM) %RECORDNAME TAGS(TAGFM) %EXTERNALROUTINESPEC DEFINE(%STRING (63) S) %INTEGER AD, FLAG, J, K, L, LIMIT, DISP %ROUTINE PS(%INTEGER AD) %STRING (8) S S <- STRING(AD+DISP) PRINTSTRING(S) SPACES(10-LENGTH(S)) %END %LIST !***************************************************************** %ROUTINE CONPIN(%INTEGER PIN) CON(-WIRENO, PINS(NAMESLOT(CP_NAME), PIN)) %END !***************************************************************** %ROUTINE CONTLINE(%INTEGER MC, NAME, MODULE, ADDR) !* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * %ROUTINE CONCHAIN(%INTEGER PIN) CON(MC, PINS(NAMESLOT(NAME), PIN)) %END !* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * %INTEGER LEVEL %SWITCH MD(0 : 32) -> MD(MODULE) %RETURN !* * * * * * * * * * * * * * * * * * * * !*** HI,LO,OVF,DZ,DP,DN MD(0): ADDR = ADDR>>8 %IF ADDR = 1 %OR ADDR = 2 %THEN %START %IF ADDR = 2 %THEN LEVEL = M'*HI*' %ELSE LEVEL = M'*LO*' WIRENO = WIRENO+1 WIREINSTR(WIRENO) = INSTRNO CON(LEVEL, WIRE(WIRENO)) CON(MC, WIRE(WIRENO)) %RETURN %FINISH CON(MC, PINS(14, ADDR+24)) %RETURN !* * * * * * * * * * * * * * * * * * * * !*** FLAG MD(2): NAME = NAMESLOT(NAME) CON(MC, FLAGPOLE(NAME&63, NAME>>8)) %RETURN !* * * * * * * * * * * * * * * * * * * * !*** BREG BITS MD(6): CONCHAIN(13+ADDR&15) %RETURN !* * * * * * * * * * * * * * * * * * * * !*** TREG BITS MD(7): CONCHAIN(9+ADDR&15) %RETURN !* * * * * * * * * * * * * * * * * * * * !*** OPINT BITS MD(10): CONCHAIN(5+ADDR&15) %RETURN !* * * * * * * * * * * * * * * * * * * * !*** IPINT BITS MD(11): CONCHAIN(5+ADDR&15) %RETURN !* * * * * * * * * * * * * * * * * * * * !*** GPAUR_A BITS MD(18): CON(MC, PINS(NAMESLOT(NAME)+1, 9+ADDR&15)) %RETURN !* * * * * * * * * * * * * * * * * * * * !*** GPAUR_B BITS MD(19): CON(MC, PINS(NAMESLOT(NAME)+1, 33+ADDR&1)) %RETURN !* * * * * * * * * * * * * * * * * * * * !*** SINT_KF MD(21): CONCHAIN(13) %RETURN !* * * * * * * * * * * * * * * * * * * * !*** SINT_PF MD(22): CONCHAIN(14) %RETURN !* * * * * * * * * * * * * * * * * * * * !*** BUS BITS MD(25): CON(MC, PINS(14, 9+ADDR&15)) %RETURN !* * * * * * * * * * * * * * * * * * * * !*** GPINT_IN BITS MD(26): CONCHAIN(5+ADDR&15) %RETURN !* * * * * * * * * * * * * * * * * * * * !*** GPINT_OUT BITS MD(27): CONCHAIN(25+ADDR&15) %RETURN !* * * * * * * * * * * * * * * * * * * * !*** SINT_OVERUN MD(31): CONCHAIN(18) %END !***************************************************************** !*** INPUT/OUTPUT FILE ALLOCATION AND CHECK %IF LENGTH(S) > 31 %START PRINTSTRING('PARAMETER '.S.' ? ') %RETURN %FINISH S = SOURCE %IF S = '' %IF S -> S.('/').OUTPUT %THEN %START S = SOURCE %IF S = '' OUTPUT = '.TT' %IF OUTPUT = '' %FINISH DEFINE('ST01,'.OUTPUT) AD = 7; ! READ ONLY CONNEKT(S, AD, FLAG) %IF FLAG # 0 %START PRINTSTRING('CANNOT CONNECT '.S.', FLAG =') WRITE(FLAG, 1) NEWLINE %RETURN %FINISH HEADER == RECORD(AD+16) %IF HEADER_IDEN # M'ARTH' %OR INTEGER(AD) = 0 %C %THEN PRINTSTRING(S.' CANNOT BE WOMBLED ') %AND %RETURN AD = AD+16 SELECTOUTPUT(1) !***************************************************************** !*** INITIALISE ARRAYS AND LIST NEXT(0) = 0 %CYCLE ASL = 1, 1, ASL NEXT(ASL) = ASL-1 %REPEAT %CYCLE J = 0, 1, 14 %CYCLE K = 0, 1, 43 PINS(J, K) = 0 %REPEAT %REPEAT %CYCLE J = 0, 1, 45 %CYCLE K = 0, 1, 12 FLAGPOLE(J, K) = 0 %REPEAT %REPEAT !***************************************************************** !*** ADDRESSES OF PIN MULTICONSTANTS IN MODPIN PINS(0, 0) = ABSENS SLOTADDR(1) = AGPAU SLOTADDR(3) = AMEMORY SLOTADDR(4) = ASPR SLOTADDR(5) = ACGEN SLOTADDR(6) = ABREG SLOTADDR(7) = ATREG SLOTADDR(9) = AGPINT SLOTADDR(10) = AIPINT SLOTADDR(11) = AOPINT SLOTADDR(12) = ASINT !***************************************************************** !*** SET UP RECORDS FRON OBJECT FILE DISP = AD-HEADER_OLD FILE-16 NAME == ARRAY(AD+HEADER_NAMES, TEXTFM) EXTERNALS == ARRAY(AD+HEADER_EXTERNS, EXTARFM) TABLES == ARRAY(AD+HEADER_TABS, TBAFM) OBJECT == ARRAY(AD+HEADER_CODE, OBJFM) USE == ARRAY(AD+HEADER_USEAGE, USEFM) CONSTANTS == ARRAY(AD+HEADER_CONSTANTS, CONFM) K = HEADER_NNAMES J = 0 LIMIT = HEADER_CONSTANTS+AD !***************************************************************** !*** EXAMINE CODE FOR CONTROL MODULE ALLOCATION %UNTIL (CP_CODE = 8 %AND CP_OPRN = 0) %C %OR ADDR(CP) >= LIMIT %CYCLE J = J+1; CP == OBJECT(J) %IF CP_CODE = 6 %THEN START = J OPUSE(CP_CODE) = OPUSE(CP_CODE)+1 %REPEAT START = START+1 INSTRNO = J NEWLINES(5) PRINTSTRING(TITLE) !***************************************************************** !*** EXAMINE NAME TABLE FOR DATA MODULE ALLOCATION %PRINTTEXT ' DECLARED ======== NAME MODULE SLOT ---- ------ ---- BSENSE 0B ' %IF K > 0 %THEN %START %CYCLE K = 1, 1, K NP == NAME(K); TAGS == NP_TAGS %IF TAGS_MASTER # 0 %C %AND NAMESLOT(TAGS_MASTER) = -1 %THEN %START !*** ACTUAL DECLARATION !* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * %IF MODSLOT(TAGS_TYPE) = 1 %THEN %START !*** DATA MODULE PS(NP_NAME) DATALOC = DATALOC+1 DATASLOT(DATALOC) = TAGS_TYPE NAMESLOT(TAGS_MASTER) = DATALOC PINS(DATALOC, 0) = SLOTADDR(TAGS_TYPE) PRINTSTRING(MODTYPE(TAGS_TYPE)); SPACES(6) PRINTMC(DATASLOTS(NAMESLOT(TAGS_MASTER))<<8+'B') NEWLINE %IF TAGS_TYPE = 1 %THEN %START DATALOC = DATALOC+1 PINS(DATALOC, 0) = AGPAR %PRINTTEXT ' GPAUR ' PRINTMC(DATASLOTS(NAMESLOT(TAGS_MASTER)+1)<<8+ %C 'B') NEWLINE %FINISH %FINISH !* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * %IF MODSLOT(TAGS_TYPE) = 2 %THEN %START !*** CONTROL MODULE PS(NP_NAME) !* * * * * * * * * * * * * * * * * * * * * * %IF TAGS_TYPE = 2 %THEN %START !*** FLAG FLAGNUM = FLAGNUM-FLAGNUM//3*3+1 %IF FLAGNUM = 1 %THEN %START !*** NEW CARD INCRCONTRL %IF FULL = 1 %THEN %RETURN FLAGAT = CONTRLOC CONTRLSLOT(CONTRLOC) = 2 FLAGPOLE(FLAGAT, 0) = 1 %FINISH NAMESLOT(TAGS_MASTER) = FLAGNUM<<8+FLAGAT %FINISH !* * * * * * * * * * * * * * * * * * * * * * %IF TAGS_TYPE = 8 %THEN %START !*** BRANCH BRANCHNUM = BRANCHNUM&1+1 %IF BRANCHNUM = 1 %THEN %START !*** NEW CARD INCRCONTRL %IF FULL = 1 %THEN %RETURN BRANCHAT = CONTRLOC CONTRLSLOT(CONTRLOC) = 8 %FINISH NAMESLOT(TAGS_MASTER) = BRANCHNUM<<8+BRANCHAT %FINISH !* * * * * * * * * * * * * * * * * * * * * * PRINTSTRING(MODTYPE(TAGS_TYPE)); SPACES(6) PRINTMC(CONTRLSLOTS(NAMESLOT(TAGS_MASTER)&63)) NEWLINE %FINISH !* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * %IF DATALOC >= 14 %C %THEN %PRINTTEXT ' *** DATA BUS FULL *** ' %C %AND %RETURN %FINISH %REPEAT %FINISH !* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * CGENUM = CONSTANTS(0) CGENAT = DATALOC+1 %WHILE CGENUM > 0 %THEN %CYCLE DATALOC = DATALOC+1 %IF DATALOC = 14 %C %THEN %PRINTTEXT ' *** DATA BUS FULL *** ' %C %AND %RETURN PINS(DATALOC, 0) = ACGEN %PRINTTEXT ' CGEN ' PRINTMC(DATASLOTS(DATALOC)<<8+'B') CGENUM = CGENUM-4 NEWLINE %REPEAT %PRINTTEXT ' BTRMTR FB # ' !***************************************************************** !*** ALLOCATE REMAINING CONTROL MODULES !*** NOP AUTOALLOC(0, 24) !*** EACH NOP REQUIRES AN EVOKE OPUSE(1) = OPUSE(1)+OPUSE(0)+OPUSE(15) !*** EVOKE AUTOALLOC(1, 5) MERGE4AT = OPAT(1)-1 FMERGE4LEFT = 2*OPNUM(1) FRTCALLAT = OPAT(1) FRTCALLNUM = OPNUM(1) !*** COND AUTOALLOC(3, 6) OPUSE(5) = OPUSE(5)-OPNUM(1) !*** FREE RTCALLS ON EVOKE CARDS AUTOALLOC(5, 6) OPUSE(5) = OPUSE(5)+OPNUM(1) %IF FULL = 1 %THEN %RETURN NEWLINES(2) !***************************************************************** !*** OUTPUT ALLOCATION OF CONTROL SLOTS %PRINTTEXT ' CONTROL ======= CARD SLOT ---- ---- ' %CYCLE L = 0, 1, 5 J = 0 %IF L # 2 %AND L # 4 %AND OPNUM(L) # 0 %THEN %START PRINTSTRING(OPCODES(L)) SPACES(6) %CYCLE K = 0, 1, OPNUM(L)-1 %IF J = 8 %THEN %START NEWLINE; SPACES(12); J = 1 %FINISH %ELSE J = J+1 PRINTMC(CONTRLSLOTS(OPAT(L)+K)); SPACES(2) %REPEAT OPNUM(L) = 0 NEWLINE %FINISH %REPEAT !***************************************************************** !*** EXAMINE CODE AND GENERATE LISTS %CYCLE INSTRNO = 1, 1, INSTRNO CP == OBJECT(INSTRNO) WIRENO = WIRENO+1 WIREINSTR(WIRENO) = INSTRNO PREVIOUS = M'0BB2' %IF INSTRNO = START CON(PREVIOUS, WIRE(WIRENO)) PREVIOUS = 0 -> OPCODE(CP_CODE) !* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * !*** NOP OPCODE(0): AUTOINCR(0, 24) CURRENT = ACTUAL(OPAT(0), ANOP+OPNUM(0)) CON(CURRENT, WIRE(WIRENO)) !* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * !*** EVOKE OPCODE(1): OPCODE(15): AUTOINCR(1, 5) CURRENT = ACTUAL(OPAT(1), AEVOKE+2*OPNUM(1)-1) CON(CURRENT, WIRE(WIRENO)) PREVIOUS = ACTUAL(OPAT(1), AEVOKE+2*OPNUM(1)) -> EVOMOD(CP_MODULE) !* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * !*** CONTINUE OPCODE(12): WIRENO = WIRENO-1 -> EVOMOD(CP_MODULE) !* * * * * * * * * * * * * * * * * * * * * * !*** NOP EVOMOD(0): -> CONTINUE !* * * * * * * * * * * * * * * * * * * * * * !*** MEMORY EVOMOD(3): %IF CP_DEST = 9 %THEN %START %IF CP_OPRN = 36 %THEN CONPIN(5) %IF CP_OPRN = 37 %THEN CONPIN(9) %FINISH %ELSE %START %IF CP_OPRN = 37 %THEN CONPIN(1) %FINISH -> CONTINUE !* * * * * * * * * * * * * * * * * * * * * * !*** CGEN EVOMOD(5): CON(-WIRENO, PINS(CGENAT+(CP_NAME-1)//4, 1+(CP_NAME-1)&3*4)) -> CONTINUE !* * * * * * * * * * * * * * * * * * * * * * !*** BREG EVOMOD(6): %IF CP_OPRN = 36 %THEN CONPIN(2*CP_DEST-3) %IF CP_OPRN = 37 %THEN CONPIN(1) -> CONTINUE !* * * * * * * * * * * * * * * * * * * * * * !*** TREG EVOMOD(7): %IF CP_OPRN = 36 %THEN CONPIN(5-CP_DEST//2) %IF CP_OPRN = 37 %THEN CONPIN(9-CP_DEST//2) -> CONTINUE !* * * * * * * * * * * * * * * * * * * * * * !*** IPINT EVOMOD(10): CONPIN(1) -> CONTINUE !* * * * * * * * * * * * * * * * * * * * * * !*** OPINT EVOMOD(11): CONPIN(1) -> CONTINUE !* * * * * * * * * * * * * * * * * * * * * !*** SINT EVOMOD(12): %IF CP_OPRN = 35 %THEN CONPIN(9) %IF CP_OPRN = 36 %THEN CONPIN(5) %IF CP_OPRN = 37 %THEN CONPIN(1) -> CONTINUE !* * * * * * * * * * * * * * * * * * * * * * !*** ROM? EVOMOD(13): -> CONTINUE !* * * * * * * * * * * * * * * * * * * * * * !*** GPA_A EVOMOD(18): !*** GPA_B EVOMOD(19): %IF CP_OPRN&16 = 16 %THEN CONPIN(37) %IF CP_OPRN < 32 %THEN CONPIN(GPAMAP(CP_OPRN&15)) %IF CP_DEST = 1 %C %THEN CON(-WIRENO, PINS(NAMESLOT(CP_NAME)+1, 1)) %IF CP_DEST = 2 %C %THEN CON(-WIRENO, PINS(NAMESLOT(CP_NAME)+1, 25)) -> CONTINUE !* * * * * * * * * * * * * * * * * * * * * * !*** SP REG EVOMOD(24): %IF CP_OPRN = 36 %THEN CONPIN(1) %IF CP_OPRN = 37 %THEN CONPIN(5) %IF CP_DEST < 15 %THEN CONPIN(2*CP_DEST+9) -> CONTINUE !* * * * * * * * * * * * * * * * * * * * * * !*** BUS EVOMOD(25): %IF CP_OPRN = 13 %THEN CON(-WIRENO, PINS(14, 5)) %IF CP_OPRN = 37 %THEN CON(-WIRENO, PINS(14, 1)) -> CONTINUE !* * * * * * * * * * * * * * * * * * * * * * !*** GPINT_IN EVOMOD(26): CONPIN(1) -> CONTINUE !* * * * * * * * * * * * * * * * * * * * * * !*** GPINT_OUT EVOMOD(27): CONPIN(21) -> CONTINUE !* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * !*** CONDITION OPCODE(3): AUTOINCR(3, 6) DISPLACED = ABRANCH2+(OPNUM(3)-1)*4 TYPE = CP_OPRN %IF TYPE > 2 %THEN TYPE = TYPE-2 CURRENT = ACTUAL(OPAT(3), DISPLACED+1) CHOICE(1) = ACTUAL(OPAT(3), DISPLACED+2) CHOICE(2) = ACTUAL(OPAT(3), DISPLACED+3) CON(CURRENT, WIRE(WIRENO)) CON(CHOICE(TYPE), WIRE(WIRENO+1)) CON(CHOICE(3-TYPE), WIRE(WIRENO+2)) CURRENT = ACTUAL(OPAT(3), DISPLACED+4) CONTLINE(CURRENT, CP_NAME, CP_MODULE, CP_DEST) -> CONTINUE !* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * !*** MERGE OPCODE(4): %IF CP_MODULE = 0 %THEN WIRENO = WIRENO-1 %C %ELSE CON(-WIRENO, INSTR(INSTRNO)) -> CONTINUE !* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * !*** RTCALL OPCODE(5): %IF FRTCALLNUM # 0 %THEN %START FRTCALLNUM = FRTCALLNUM-1 DISPLACED = AFRTCALL %FINISH %ELSE %START AUTOINCR(5, 6) FRTCALLAT = OPAT(5) DISPLACED = ARTCALL+(OPNUM(5)-1)*4 %FINISH CURRENT = ACTUAL(FRTCALLAT, DISPLACED+1) CON(CURRENT, WIRE(WIRENO)) CON(-WIRENO, INSTR(CP_DEST)) CURRENT = ACTUAL(FRTCALLAT, DISPLACED+2) CON(CURRENT, WIRE(INSTRWIRE(CP_MODULE))) PREVIOUS = ACTUAL(FRTCALLAT, DISPLACED+3) FRTCALLAT = FRTCALLAT+1 -> CONTINUE !* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * !*** RETURN OPCODE(6): -> CONTINUE !* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * !*** JUMP OPCODE(7): J = CP_DEST %WHILE OBJECT(J)_CODE = 13 %THEN J = J-1 CON(-WIRENO, INSTR(J)) -> CONTINUE !* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * !*** STOP OPCODE(8): CON(M'****', WIRE(WIRENO)) -> CONTINUE !* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * !*** BRANCH OPCODE(9): BADDRS == TABLES(CP_DEST)_W BRANCHAT = NAMESLOT(CP_NAME)&63 BRANCHNUM = NAMESLOT(CP_NAME)>>8 DISPLACED = ABRANCH8+12*(BRANCHNUM-1)+1 CURRENT = ACTUAL(BRANCHAT, DISPLACED) CON(CURRENT, WIRE(WIRENO)) %CYCLE L = 0, 1, 7 %IF BADDRS(L) # 0 %THEN %START WIRENO = WIRENO+1 WIREINSTR(WIRENO) = INSTRNO CURRENT = ACTUAL(BRANCHAT, DISPLACED+4+L) CON(CURRENT, WIRE(WIRENO)) J = BADDRS(L) %WHILE OBJECT(J)_CODE = 13 %THEN J = J-1 CON(-WIRENO, INSTR(J)) %FINISH %REPEAT %CYCLE L = 1, 1, 3 TLINES(L) = ACTUAL(BRANCHAT, DISPLACED+L) %REPEAT TLINENO = 0 -> CONTINUE !* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * !*** T-LINE OPCODE(10): WIRENO = WIRENO-1 TLINENO = TLINENO+1 CONTLINE(TLINES(TLINENO), CP_NAME, CP_MODULE, CP_DEST) -> CONTINUE !* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * !*** BREAK OPCODE(11): WIRENO = WIRENO-1 -> CONTINUE !* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * !*** CMERGE OPCODE(13): WIRENO = WIRENO-1 -> CONTINUE !* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * !*** FLAG OPCODE(14): WIRENO = WIRENO-1 FLAGAT = NAMESLOT(CP_NAME)&63 FLAGNUM = NAMESLOT(CP_NAME)>>8 CON(-WIRENO, FLAGPOLE(FLAGAT, 3*FLAGNUM+CP_OPRN-2)) CONTINUE: INSTRWIRE(INSTRNO) = WIRENO %IF INSTRWIRE(INSTRNO) = 0 %REPEAT !***************************************************************** !*** ALLOCATE PROGRAM CONTROL MERGES %CYCLE INSTRNO = 1, 1, INSTRNO %IF INSTR(INSTRNO) # 0 %THEN %START MERGE(INSTR(INSTRNO), 0, 0, 0) CON(PREVIOUS, WIRE(INSTRWIRE(INSTRNO)+1)) %FINISH %REPEAT !***************************************************************** !*** ALLOCATE MODULE CONTROL MERGES %CYCLE DATALOC = 0, 1, 14 %CYCLE J = 1, 1, 43 CURRENT = PINS(DATALOC, J) %IF CURRENT # 0 %THEN %START %IF ITEM(CURRENT) < 0 %THEN %START DISPLACED = PINS(DATALOC, 0)+J MERGE(CURRENT, NUMPIN(DISPLACED), DISPLACED-1, %C DATALOC) %FINISH %ELSE %START !* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * !*** LINK TEST LINE CHAINS TO MODULES WIRENO = WIRENO+1 WIRE(WIRENO) = CURRENT CURRENT = DATASLOTS(DATALOC)<<24+MODPIN(PINS( %C DATALOC, 0)+J) CON(CURRENT, WIRE(WIRENO)) %FINISH %FINISH %REPEAT %REPEAT !***************************************************************** !*** LINK TEST LINE CHAINS TO FLAGS %CYCLE J = 0, 1, 45 %IF FLAGPOLE(J, 0) # 0 %THEN %START %CYCLE K = 1, 1, 3 %IF FLAGPOLE(J, K) # 0 %THEN %START WIRENO = WIRENO+1 WIRE(WIRENO) = FLAGPOLE(J, K) CURRENT = CONTRLSLOTS(J)<<16+MODPIN(AFLAG+(K-1)*8+ %C 6) CON(CURRENT, WIRE(WIRENO)) %FINISH %REPEAT !* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * !*** ALLOCATE FLAG CONTROL MERGES %CYCLE K = 4, 1, 12 %IF FLAGPOLE(J, K) # 0 %C %THEN MERGE(FLAGPOLE(J, K), -1, K, J) %REPEAT %FINISH %REPEAT !***************************************************************** !*** OUTPUT USE OF MERGE4 CARDS %IF FMERGE4LEFT < 0 %THEN %START %PRINTTEXT 'MERGE4 ' J = 0 %CYCLE NOBUSLOC = 0, 1, NOBUSLOC %IF NOBUSSLOT(NOBUSLOC) = 4 %THEN %START %IF J = 8 %THEN %START NEWLINE; SPACES(10); J = 1 %FINISH %ELSE J = J+1 SPACES(2); PRINTMC(NOBUSSLOTS(NOBUSLOC)) %FINISH %REPEAT NEWLINE %FINISH !* !* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * !*** OUTPUT USE OF MERGE2 CARDS %IF MERGE2NUM > 0 %THEN %START %PRINTTEXT 'MERGE2 ' J = 0 %CYCLE NOBUSLOC = 0, 1, NOBUSLOC %IF NOBUSSLOT(NOBUSLOC) = 2 %THEN %START %IF J = 8 %THEN %START NEWLINE; SPACES(10); J = 1 %FINISH %ELSE J = J+1 SPACES(2); PRINTMC(NOBUSSLOTS(NOBUSLOC)) %FINISH %REPEAT NEWLINE %FINISH PRINTSYMBOL('#') !***************************************************************** !*** POSTPROCESS WIRES TO ELIMINATE NULL WIRES %CYCLE CHANGED = 0 %CYCLE WIRENO = 1, 1, WIRENO %IF NULLWIRE(WIRENO) # 0 %THEN %START %WHILE WIRE(WIRENO) # 0 %THEN %CYCLE CURRENT = ITEM(WIRE(WIRENO)) WIRE(WIRENO) = NEXT(WIRE(WIRENO)) CON(CURRENT, WIRE(NULLWIRE(WIRENO))) CHANGED = 1 %REPEAT %FINISH %REPEAT %EXIT %IF CHANGED = 0 %REPEAT !***************************************************************** !*** SORT WIRES %CYCLE WIRENO = 1, 1, WIRENO HEAD = WIRE(WIRENO) SORT LIST(HEAD) WIRE(WIRENO) = HEAD %REPEAT !***************************************************************** !*** OUTPUT ACTUAL WIRING %PRINTTEXT ' WIRING ====== STAT WIRE FROM TO ---- ---- ---- -- ' L = -1 LOST = 0 %CYCLE WIRENO = 1, 1, WIRENO J = WIRE(WIRENO) %IF J # 0 %THEN %START K = 0 %IF L = OBJECT(WIREINSTR(WIRENO))_STAT %C %THEN SPACES(4) %ELSE %START L = OBJECT(WIREINSTR(WIRENO))_STAT %IF L = 0 %THEN SPACES(4) %ELSE WRITE(L, 3) %FINISH WRITE(WIRENO-LOST, 5) SPACES(4) !* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * !*** ACTUAL WIRE PRINTMC(ITEM(J)) J = NEXT(J) %WHILE J # 0 %THEN %CYCLE %PRINTTEXT ' <=> ' %IF K = 5 %THEN %START NEWLINES(2); SPACES(14); K = 0 %FINISH %ELSE K = K+1 PRINTMC(ITEM(J)) J = NEXT(J) %REPEAT NEWLINES(2) %FINISH %ELSE LOST = LOST+1 %REPEAT PRINTSYMBOL('#') !***************************************************************** !*** END MESSAGE TO FILE AND TELETYPE %CYCLE NEWLINES(3) %PRINTTEXT ' =========== END OF WOMBLE ========== ' NEWLINES(3) SELECTOUTPUT(0) %EXIT %IF OUTPUT = '.TT' OUTPUT = '.TT' %REPEAT %END !***************************************************************** !***************************************************************** %ENDOFFILE @@@@@@@@@@@@@@@ B[CONSTANT]=3 B[NAME]=4 B[NAMELIST]=5 B[SEPERATOR]=8 L = 0 L = 1 L = 0 D[OLD NAME]=[NAME=1] D[OLD NAME LIST] = [NAMELIST=1] P(STAT) (SS) [SEPERATOR]; P(SS) '%CONTINUE' <1> (REPEAT COUNT'): ':' <1> (REPEAT COUNT'): '%GO' <3>: '%TRACE' <4>(ON/OFF): '%MAP' <6> (LOCATION) (RLOCLIST') (WHERE'): '?' <7> (COND) (RCONDLIST'): '#' <9> (LOC/BUS) (RLOCLIST'): '%DUMP' <11> (WHERE'): '%IGNORE' <12> (NAMES'): '%REPLACE' <13> (NAMES'): '%ENDOFSIM' <14>: '%CANCEL'<15> (LOC LIST'): '%BREAK' <16> (CONST LIST): '%FREE' <17> (NONE) (RCONST LIST'): <2> (LOC/BUS) (ASSOP)(PLUS')[CONSTANT]: <5> (FLAG OPERATION) [OLD NAMELIST] (AND'): '%TREG' <8> [OLD NAME] (PIN DEFINITION'): '%DEFINE' <10> (EQITEM) (RDEFINE'): '%CONTROL' <18> [CONSTANT]: '%FULL' <18> <0>: '%QUIET' <18> <6> : '%NAMES' <18> <7>: '%TRAPS' <18> <4>: '%CLEAR' '%BUS'<21>: '%RADIX'<23>[CONSTANT]: '->'<24> [OLD NAME]: ; P(LOC LIST') (LOC/BUS)(RLOC LIST'): ; P(LOC/BUS) <0>(LOCATION): <1>'BUS'; P(ON/OFF) '%OFF'<0>: '%ON'<1>(WHERE'); P(NAMES') [OLD NAME LIST]: ; P(NONE) [CONSTANT]: ; P(CONST LIST) <1>[CONSTANT](R CONST LIST'):<0>; P(RCONST LIST') ','[CONSTANT] (RCONST LIST'): ; P(COND) (LOC/BUS) (RCOND'); P(RCONDLIST') ',' (COND) (RCONDLIST'): ; P(RCOND') (CONDOP) [CONSTANT]: ; P(CONDOP) '='<1>: '#'<2>: '>='<3>: '<='<4>: '<'<5>: '>'<6>; P(RLOCLIST') ',' (LOC/BUS) (RLOCLIST'): ; P(REPEAT COUNT') [CONSTANT]: ; P(WHERE') (LOC): ; P(LOC) '.TT'<1>: '.LP' <2>: <3> [NAME]; P(ASSOP) '<-': '='; P(PIN DEFINITION') '(' [CONSTANT] (PINLIST') ')': ; P(PINLIST') ',' [CONSTANT] (PINLIST'): ; P(ADDRESS') ':'<1> [CONSTANT]: <0>; P(LOCATION) '[' <0> [OLD NAME] (ADDRESS') ']': <1> [OLD NAME] (FQUAL'): <2> (FLAGNAME); P(FQUAL') '_' <1> (PREDECLARED NAME): '#' <2> [CONSTANT]: '<' <3> [CONSTANT] ':' [CONSTANT] '>': <0>; P(GPAREG NAME) [OLD NAME] (ENAME'); P(ENAME') '_' (PREDECLARED NAME): <0>; P(M FLAGS) 'OVF'<9>: 'DZ'<10>: 'DP'<11>: 'DN'<12>; P(FLAGNAME) <0>(GPAREG NAME) (BITDEF'): 'ZERO'<10>: 'POSITIVE'<11>: 'NEGATIVE'<12>: 'OVERFLOW'<9>: (M FLAGS); P(BITDEF') '<' <1> [CONSTANT] '>': <0>; P(FLAG OPERATION) '%SET' <3>: '%CLEAR' <4>: '%COMPLEMENT' <5>; P(AND') '%AND' <1> (FLAG OPERATION) [NAMELIST] (AND'): <0> ; P(EQITEM) [NAME] '=' [OLDNAME] (FQUAL') (BITDEF'); P(RDEFINE') ',' (EQITEM) (RDEFINE'): ; P(PREDECLARED NAME) 'A' <18>: 'B' <19>: 'KF' <21>: 'PF' <22>: 'IN' <26>: 'OUT' <27>: 'OVERUN'<31>; P(PLUS') '+': '-'<1>: <0>; @ @@@@@@@@@@@@@@@ ! ! NEW PHRASE STRUCTURE REDUCTION PROGRAM ! %EXTERNALROUTINESPEC SET STREAMS(%STRING (63) S) %CONSTINTEGER DATA IN = 1 %CONSTINTEGER DATA OUT = 2 %CONSTINTEGER ERROR OUT = 3 %EXTERNALROUTINE REDUCE(%STRING (63) FILES) %STRING (63) INPUT, OUTPUT, REPORT %OWNBYTEINTEGERARRAY BIPD(3 : 15) %BYTEINTEGERARRAY PHRASE USE(1 : 1000) %STRING (31) %ARRAY PHRASE(1 : 1000) %SHORTINTEGERARRAY MAIN, SUB, SMOD(1 : 3000) %SHORTINTEGERARRAY PVAL(1 : 1000), LITP(1 : 500) %BYTEINTEGERARRAY LITERAL(0 : 2000), PDEFN(1 : 1000) %OWNINTEGER PHS = 1, BPS = 501 %RECORDFORMAT EXTFM(%STRINGNAME NAME, %INTEGER EP) %RECORDARRAY EXT EP(1 : 100)(EXTFM) %INTEGER J, K, L, S, PN, BN, MP, SP, LP, LITN, N, MOD %INTEGER FAULTY, EXTPT %STRING (63) NAME, NUMBER %INTEGERFN NEXTS %INTEGER S READSYMBOL(S) %UNTIL S # ' ' %AND S # NL %RESULT = S %END %ROUTINE FAULT(%INTEGER N) FAULTY = FAULTY+1 %SWITCH FN(1 : 6) -> FN(N) FN(1): %PRINTTEXT '? ' PRINTSYMBOL(S); S = '^' PRINTSYMBOL(S) %AND READSYMBOL(S) %UNTIL S = NL NEWLINE %RETURN FN(2): PRINTSTRING('DUPLICATE '''.NAME.''' '); %RETURN FN(3): PRINTSTRING('VALUE '''.NAME.'''? '); %RETURN FN(4): PRINTSTRING(''''.NAME.''' UNDEFINED '); %RETURN %END %ROUTINE GET NAME(%INTEGER DELIM) %INTEGER S NAME = '' %CYCLE S = NEXTS; %EXIT %IF S = DELIM NAME = NAME.TOSTRING(S) %REPEAT %END %INTEGERFN STOI(%STRINGNAME S) %INTEGER J, K, N N = 0; %RESULT = 0 %IF LENGTH(S) = 0 %CYCLE J = ADDR(S)+1, 1, ADDR(S)+LENGTH(S) K = BYTEINTEGER(J)-'0' %RESULT = -1 %UNLESS 0 <= K <= 9 N = 10*N+K %REPEAT %RESULT = N %END %INTEGERFN FIND(%INTEGER S, %INTEGERNAME P) %WHILE S <= P %CYCLE %RESULT = S %IF PHRASE(S) = NAME S = S+1 %REPEAT P = P+1; PHRASE(P) = NAME PVAL(P) = 0; PDEFN(P) = 0 %RESULT = P %END PN = 0; BN = 500 PVAL(500) = 2; PHRASE(500) = ''; PDEFN(500) = 2 MP = 0; SP = 1; LP = 1 %CYCLE J = 1, 1, 3000; SMOD(J) = 0 %REPEAT %UNLESS FILES -> INPUT.('/').OUTPUT %START PRINTSTRING(FILES.'? ') %RETURN %FINISH REPORT = '.TT' %UNLESS OUTPUT -> OUTPUT.(',').REPORT SET STREAMS(INPUT.','.OUTPUT.','.REPORT) SELECTINPUT(DATA IN) SELECTOUTPUT(ERROR OUT) %CYCLE J = 1, 1, 1000; PHRASE USE(J) = 0 %REPEAT %CYCLE J = 1, 1, 100 EXTEP(J) = 0 %REPEAT ! FAULTY = 0 LITN = 0 EXTPT = 0 TOP: S = NEXTS TOPM: %IF S = 'B' %START; ! BUILT-IN PHRASE DEFN FAULT(1) %AND -> TOP %IF NEXTS # '[' GET NAME(']'); L = 3 BL: J = FIND(BPS, BN) FAULT(2) %AND -> TOP %IF PDEFN(J) # 0 PDEFN(J) = L FAULT(1) %AND -> TOP %IF NEXTS # '=' READ(N); ! VALUE %IF L = 1 %START FAULT(3) %AND -> TOP %UNLESS 2 < N <= 15 %AND BIPD(N) = 0 BIPD(N) = 1 %FINISH PVAL(J) = N -> TOP %FINISH %IF S = 'L' %START; ! LITERAL DEFN FAULT(1) %AND -> TOP %UNLESS NEXTS = '<' GET NAME('>'); L = 2; -> BL %FINISH %IF S = 'D' %START; ! DEFINE COMPLEX PHRASE FAULT(1) %AND -> TOP %IF NEXTS # '[' GET NAME(']') FAULT(1) %AND -> TOP %IF NEXTS # '=' %OR NEXTS # '[' J = FIND(BPS, BN) FAULT(2) %AND -> TOP %IF PDEFN(J) # 0 GET NAME(']') K = 0; K = STOI(NUMBER) %IF NAME -> NAME.('=').NUMBER NAME = NAME.NUMBER %IF K < 0 L = FIND(BPS, BN) PHRASE USE(L) = 1 FAULT(4) %AND -> TOP %UNLESS PDEFN(L) = 3 PDEFN(J) = 4 PVAL(J) <- PVAL(L)<<12!K -> TOP %FINISH %IF S = 'P' %START; ! PHRASE DEFN FAULT(1) %AND -> TOP %UNLESS NEXTS = '(' GET NAME(')') J = FIND(PHS, PN) FAULT(2) %AND -> TOP %UNLESS PDEFN(J) = 0 PDEFN(J) = 1 MP = MP+1; MAIN(MP) = SP PVAL(J) = MP-1 -> TOP %FINISH %IF S = '<' %START; ! LITERAL VALUE GET NAME('>') K = STOI(NAME) %IF K < 0 %START K = FIND(BPS, BN) FAULT(4) %AND -> TOP %IF PDEFN(K) # 2 PHRASE USE(K) = 1 K = PVAL(K) %FINISH SP = SP+1; SUB(SP) <- 500; SMOD(SP) <- K -> TOP %FINISH %IF S = '(' %START; ! PHRASE REF GET NAME(')') J = FIND(PHS, PN) PHRASE USE(J) = 1 SP = SP+1; SUB(SP) <- J SMOD(SP) = X'1000' -> TOP %FINISH %IF S = '[' %START; ! BIP REF GET NAME(']') K = 0 K = STOI(NUMBER) %IF NAME -> NAME.('=').NUMBER NAME = NAME.NUMBER %IF K < 0 J = FIND(BPS, BN) FAULT(3) %UNLESS PDEFN(J) = 3 %OR (PDEFN(J) = 4 %AND K = 0) PHRASE USE(J) = 1 SP = SP+1; SUB(SP) <- J; SMOD(SP) <- K -> TOP %FINISH %IF S = '''' %START MOD = 0; J = LP PC1: S = NEXTS -> PC2 %IF S = '''' MOD = 32 %AND -> PC1 %IF S = '%' MOD = 0 %UNLESS 'A' <= S <= 'Z' J = J+1; LITERAL(J) = S+MOD -> PC1 PC2: LITERAL(LP) = J-LP K = LITN %WHILE K > 0 %CYCLE -> PC3 %IF STRING(ADDR(LITERAL(LITP(K)))) = STRING( %C ADDR(LITERAL(LP))) K = K-1 %REPEAT K = LITN+1; LITN = K; LITP(K) = LP; LP = J+1 PC3: SP = SP+1; SUB(SP) <- 0; SMOD(SP) <- LITP(K) -> TOP %FINISH %IF S = ':' %START; ! END OF ALTERNATIVE SP = SP+1; SUB(SP) <- 0 S = NEXTS %IF S = ';' %THEN %START MP = MP+1; MAIN(MP) = SP-1 -> TOP %FINISH MP = MP+1; MAIN(MP) = SP; -> TOPM %FINISH %IF S = ';' %START SP = SP+1; SUB(SP) <- 0 MP = MP+1; MAIN(MP) = 0 -> TOP %FINISH %IF S = '*' %START READSYMBOL(S) %UNTIL S = NL -> TOP %FINISH %IF S = 'E' %START; ! EXTERNAL ENTRY POINT FAULT(1) %AND -> TOP %IF NEXTS # '[' GET NAME(']') FAULT(1) %AND -> TOP %IF NEXTS # '=' %OR NEXTS # '(' J = FIND(BPS, BN) FAULT(2) %AND -> TOP %IF PDEFN(J) # 0 EXTPT = EXTPT+1 EXTEP(EXTPT)_NAME == PHRASE(J) GET NAME(')') L = FIND(PHS, PN) PHRASE USE(L) = 1 FAULT(4) %AND -> TOP %IF PDEFN(L) > 1 PDEFN(J) = 5; ! EXTERNAL EXTEP(EXTPT)_EP = L -> TOP %FINISH FAULT(1) %AND -> TOP %IF S # '@' ! ! SECOND PHASE ! LP = LP-1 %CYCLE J = 2, 1, SP K = SUB(J) %IF K # 0 %START %IF PDEFN(K) = 0 %THEN %START NAME = PHRASE(K); FAULT(4) PDEFN(K) = 1 %FINISH %ELSE %START L = PVAL(K) L = L<<12 %IF 1 # PDEFN(K) # 4 SUB(J) <- L+SMOD(J) %FINISH %FINISH %ELSE SUB(J) = SMOD(J) %REPEAT %IF EXTPT # 0 %START %CYCLE J = 1, 1, EXTPT K = EXTEP(J)_EP %IF PDEFN(K) = 0 %START NAME = PHRASE(K); FAULT(4) PDEFN(K) = 1 %FINISH %ELSE EXTEP(J)_EP = PVAL(K) %REPEAT %FINISH ! %IF FAULTY # 0 %START SELECTOUTPUT(0) PRINTSTRING(INPUT.' CONTAINS') WRITE(FAULTY, 1) %PRINTTEXT' FAULT'; %PRINTTEXT'S' %IF FAULTY # 1 NEWLINE %RETURN %FINISH %CYCLE J = BPS, 1, BN PRINTSTRING('? ['.PHRASE(J).'] UNUSED ') %C %IF PHRASE USE(J) = 0 %AND PDEFN(J) # 5 %REPEAT %CYCLE J = PHS, 1, PN PRINTSTRING('? ('.PHRASE(J).') UNUSED ') %C %IF PHRASE USE(J) = 0 %REPEAT SELECTOUTPUT(DATA OUT) %IF EXTPT # 0 %START %CYCLE J = 1, 1, EXTPT PRINTSTRING('%CONSTSHORTINTEGER '.EXTEP(J)_NAME.' =') WRITE(EXTEP(J)_EP, 4); NEWLINE %REPEAT %FINISH %PRINTTEXT ' %CONSTSHORTINTEGERARRAY MAIN(1:' WRITE(MP, 1); %PRINTTEXT ') = %C ' L = 12 %CYCLE J = 1, 1, MP-1 WRITE(MAIN(J), 4); %PRINTTEXT ',' L = L-1; L = 12 %AND NEWLINE %IF L <= 0 %REPEAT WRITE(MAIN(MP), 4) %PRINTTEXT ' %CONSTSHORTINTEGERARRAY SUB(2:' WRITE(SP, 1); %PRINTTEXT ') = %C ' L = 9 %CYCLE J = 2, 1, SP-1 WRITE(SUB(J), 5); %PRINTTEXT ',' L = L-1; L = 9 %AND NEWLINE %IF L <= 0 %REPEAT WRITE(SUB(SP), 4) %PRINTTEXT ' %CONSTBYTEINTEGERARRAY LITERAL(1:' WRITE(LP, 1); %PRINTTEXT ') = %C ' L = 12 %CYCLE J = 1, 1, LP-1 WRITE(LITERAL(J), 4); %PRINTTEXT ',' L = L-1; L = 12 %AND NEWLINE %IF L <= 0 %REPEAT WRITE(LITERAL(LP), 4) NEWLINE SELECTOUTPUT(ERROR OUT) %PRINTTEXT 'REDUCTION SUCCESSFUL MAIN' WRITE(MP*2, 1) %PRINTTEXT ' BYTES SUB' WRITE(SP*2-2, 1) %PRINTTEXT ' BYTES LITERAL' WRITE(LP+1, 1) %PRINTTEXT ' BYTES TOTAL' WRITE(MP*2+SP*2+LP-1, 1) %PRINTTEXT ' BYTES ' %END %ENDOFFILE @@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@ %EXTERNALROUTINE FLO(%STRING (63) S) %STRING (63) INFILE, OUTFILE %EXTERNALROUTINESPEC DEFINE(%STRING (63) S) ! ! FRONT PANEL USEAGE INFO. ! %SHORTINTEGERARRAY PINS(0:63,1:38) ! ! PIN PARAMS. TO DRAWING ROUTINES ! %INTEGERARRAY PICT(1 : 11) %INTEGERARRAY POSITION(16 : 63) %INTEGERARRAY LINK, DATA(1 : 1024) %INTEGER STARTS, ASL, WIRES %CONSTSTRING (1) SNL = ' ' ! ! PIN USEAGE TEXT ! %CONSTSTRING (11) %ARRAY TXT(-64 : 15) = %C 'START','FFCOMP','FFSET0','FFSET1','FFRDDATA','FFDATA', 'NOP','TT<=PRINT','ENABLE',' //2','A<=A*2', 'A<=A+1','A<=\A','B<=\B','A<=A-1', 'A<=A+B','A<=A-B','A<=A&B','A<=AORB', 'A<=AXORB','<=MEM','<=SP15','<=BYTEREG','<=BREG 0:11', '<=BREG 0:7','<=BREG 0:3','<=LO TR','<=HI TR','<=CONST4', '<=CONST3','<=CONST2','<=CONST1','<=SINT','<=IPINT', '<=GPINT','<=A','<=B','<=0','MEM<=','LADR<=','SP15<=','SP14<=', 'SP13<=','SP12<=','SP11<=','SP10<=','SP9<=','SP8<=','SP7<=','SP6<=', 'SP5<=','SP4<=','SP3<=','SP2<=','SP1<=','SP0<=','BYTE REG<=', 'LO TR<=','HI TR<=','OPINT<=','GPINT<=', 'B<=','A<=','BUS SNS<=','UNUSED','EVOKE IN','EVOKE OUT', '2OR IN','2OR OUT','4OR IN','4OR OUT','2BR IN', '2BR OUT','8BR IN','8BR OUT','SRET IN', 'SRET OUT','ENDSUB','2BR CND','8BR CND' ! ! MODULE PIN USEAGE INFO. ! %CONSTSHORTINTEGERARRAY PINSPEC(1 : 798) = %C %C 0(9),1,0,2,0(3),1,5,2,5,1,5, 2,5,0,6,11,5,13,5,12,6,1,0,2,5,1,5,2, 3,0,3,0,4,0,3(4),4,4,0,0, 3(4),4,4,3(4),4,4,3(4),4,4,0,3,0,3, 0,4, 0(7),-58,0,-58(3),0(2),-58(5),0,-58(12), 0,-58(2),0,-58,0, 0(7),12,0,13,0,12,0(2),11,13,0,12,11,13, 0,12,11,13,0,12,11,13,0,12,11,13,0(4),11,0, 5,0,5,0,5,0,5,5,6,5(3),0,0,5(3),6,5,5,6, 5(6),6,5,5,6,5,0,5,0,5,0,6, 0(3),-64,0(21),-1,0,-1,-1,-27,-1,-27,0,0,-27,0,-27,0, 0(16),-3(8),-2(8),0(6), 0(9),-4,-30,-4,0,0,-30,-4,-30,-4,-30,0(19), 0(9),-5,0,-5,0(3),-5,0,-5,0(20), 0(10),-31,0(3),-31,0,-31,0,-31,0(19), 0(10),-57,0(3),-57,0,-57,0,-57,0,0,-56,0,-56,0,-56, 0,-56,0,-32,0,-32,0,-32,0,-32,0,0, 0(16),-34,0,-34,0,-36,-34,-36,-34,-36,-33,-36,-33, 0,-33,-35,-33,0,-35,0,-35,0,0, 0(10),-7,0(6),-7,0,-6,0,-6,0(9),-38,0,-38,-37,0,-37,0, 0(7),-8,0,-8,0,-8,0(3),-8,0(4),-42,0,-42,0,-41,0,-41, 0,-40,0,-40,0(3),-39,0,-39,0, 0(10),9(2),0(2),15(6),10(12),0,0,10(4), 0(7),8,0,8,14,8,0,0,7,8,14,8,7,8, 14,8,7,8,14,8,7,8,14,8,7,8,0,0, 14,0,7,0, 0(10),-60,0(3),-63,0,-59,-61,0,0,-62, -62,0,-61,-59,0,-63,-61,-60(2),0,-63,0, -59,0,-62,0,0, 0(3),-29,0(3),-29,0,-29,-51,-29,0,0,-51, -51,-52,-51,-52,-49,-52,-50,-52,-50(3), -55,-49,-55,-49,-55,-49,0, -47,-55,-46,0,-48, 0(11),-54,0(3),-54,0,-54,0,-54,0,-53,0,-53,0,-53, 0,-53,0,-28,0,-28,0,-28,0,-28,0,-45, 0(3),-11,0(3),-15,0,-15,-16(2),0,0,-13(2), -14,-10,-14,-10,-20,-12,-20,-12,-22,-18,-22,-18,-21, -17,-21,-17,0,0,-19,0,-19,0, 0(9),-24,0,-24,0(3),-24,0,-24,0,-43, 0,-43,0(3),-43,0(3),-43,0,-9,0,-9,0,-11,0,0 ! ! MAPS PIN NOS. TO CORRESP. LETTER ! %CONSTBYTEINTEGERARRAY VAL(1 : 19) = %C 'A','B','C','D','E','F','G','H','J', 'K','L','M','N','P','R','S','T', 'U','V' ! ! PINS USED BY DRAWING ROUTINES ! %CONSTSHORTINTEGERARRAY P(1 : 116) = %C 1,3,5,7,9,11,8,10,12, 15,17,19,16,18,20,21,23,25, 22,24,26,27,29,31, 1,7,9,3,5,8,16,18,10,12, 11,19,21,15,17,20,26,28,22,24, 23,29,31,25,27,30,36,38,32,34, 37,29,31,35,27,23,17,25,21,19, 15,10,11,8, 19,16,17,12, 23,20,21,18, 26,28,8,30, 27,24,25,22,31,28,29,26, 37,32,35,30, 15,11,10,8, 19,17,16,12, 23,21,20,18, 27,25,24,22, 31,29,28,26, 37,35,32,30 ! ! LIST PROCESSING ROUTINES FOLLOW. ! %ROUTINE PUSH(%INTEGER D, %INTEGERNAME P) DATA(ASL) = D D = ASL ASL = LINK(ASL) LINK(D) = P P = D %END %INTEGERFN POP(%INTEGERNAME P) %INTEGER D D = P P = LINK(P) LINK(D) = ASL ASL = D %RESULT = DATA(ASL) %END %ROUTINE CONCAT(%INTEGERNAME P1, P2) %INTEGER D %IF P1 = 0 %THEN %START P1 = P2 P2 = 0 %RETURN %FINISH D = P1 %WHILE LINK(D) # 0 %THEN D = LINK(D) LINK(D) = P2 P2 = 0 %END %ROUTINE BACKWARD PUSH(%INTEGER N, %INTEGERNAME P1) %INTEGER P2 P2 = 0 PUSH(N, P2) CONCAT(P1, P2) %END %ROUTINE ALLOCATE ! ! GIVEN MODULE ALLOCATION, IT ! FILLS IN PIN USEAGE INFO. ! %INTEGER P, ISPEC, TYPE, C, C1, C2 %CONSTSHORTINTEGERARRAY BASE(1 : 19) = %C 0,38,76,114,152,190,228,266,304,342, 380,418,456,494,532,570,608,646,722 %ROUTINE FILL %INTEGER C %CYCLE C = 1, 1, 38 PINS(P, C) = PINSPEC(ISPEC+C) %REPEAT %END %CYCLE C1 = 0, 1, 63 %CYCLE C2 = 1, 1, 38 PINS(C1, C2) = 0 %REPEAT %REPEAT %CYCLE C = 16, 1, 63 TYPE = POSITION(C) %IF TYPE # 0 %THEN %START ISPEC = BASE(TYPE) P = C FILL %IF TYPE > 17 %THEN %START ! DOUBLE HEIGHT MODULE ISPEC = ISPEC+38 P = P-16 FILL %FINISH %FINISH %REPEAT %END %ROUTINE PRINT PIN(%INTEGER THIS, FIRST, LAST) %INTEGER C1, C2, S1, S2 C2 = THIS&X'FF' %IF FIRST = 1 %THEN %START C1 = THIS>>16 S2 = C1//16+'A' S1 = C1-(C1//16)*16 %IF S1 < 10 %THEN S1 = S1+'0' %ELSE S1 = S1-10+'A' PRINTSYMBOL(S1) PRINTSYMBOL(S2) %FINISH %IF LAST = 1 %THEN %START PRINTSYMBOL(VAL((C2+1)//2)) PRINTSYMBOL('1'+(\C2&1)) %FINISH %END %INTEGERFN NEXT PIN START(%INTEGER THIS, FLAG) %CONSTBYTEINTEGERARRAY MAP(0 : 20) = %C 0,1,2,0,3,4,0(9),5,6,0(4) %OWNINTEGER NOPRINTED = 1 %CONSTBYTEINTEGERARRAY OUTPT OF(1 : 152) = %C 0(9),12,0(5),18,25,0,25,22,25,0,25, 0,0,30,31,30,31,0(2),34,0,0,31, 38,31,0,5,0,5,0(3),11,12,11,12,0(4),19, 20,19,20,0(2),25,26,25,26,0(2), 31,32,31,32,0(3),38,0,38,0,0, 0(9),8,0(4),8,12,0(2),12,18,0(2),18,22, 0(2),22,0(3),26,30,0(4),30,26, 9,0,9,0,9,0,9,18,0,18, 21,18,0(2),21,18,21,0,21,28, 0,28,31,28,31,28,31,0,31,38, 0,38,0,38,0,38,0,0 %OWNINTEGERARRAY PRINTED(0 : 400) %INTEGER TYPE, I, J, NEXT, C I = THIS>>16 J = THIS&X'FF' PRINTED(0) = 0 TYPE = MAP(POSITION(I)) I = I<<16 %IF TYPE < 5 %THEN %START %IF TYPE < 1 %THEN %START %PRINTTEXT 'FAULT PIN' PRINT PIN(THIS, 1, 1) %PRINTTEXT ' NOT AN INPUT' NEWLINE %RESULT = 0 %FINISH NEXT = OUTPT OF((TYPE-1)*38+J)+I %IF FLAG = '?' %THEN %RESULT = NEXT %CYCLE C = 0, 1, NOPRINTED-1 %IF PRINTED(C) = NEXT %THEN %RESULT = 0 %REPEAT PRINTED(NOPRINTED) = NEXT NOPRINTED = NOPRINTED+1 %RESULT = NEXT %FINISH %ELSE %START %IF TYPE = 5 %THEN %START %IF J = 11 %THEN %START PUSH(I+37, STARTS) PUSH(I+35, STARTS) PUSH(I+31, STARTS) PUSH(I+29, STARTS) PUSH(I+27, STARTS) PUSH(I+25, STARTS) PUSH(I+23, STARTS) NEXT = 21 %FINISH %ELSE %START PUSH(I+38, STARTS) PUSH(I+36, STARTS) PUSH(I+32, STARTS) PUSH(I+30, STARTS) PUSH(I+28, STARTS) PUSH(I+26, STARTS) PUSH(I+24, STARTS) NEXT = 22 %FINISH %FINISH %ELSE %START ! TYPE 6, 'COND' %IF J = 15 %THEN NEXT = 8 %AND PUSH(I+10, STARTS) %IF J = 19 %THEN NEXT = 12 %AND PUSH(I+16, STARTS) %IF J = 23 %THEN NEXT = 18 %AND PUSH(I+20, STARTS) %IF J = 27 %THEN NEXT = 22 %AND PUSH(I+24, STARTS) %IF J = 31 %THEN NEXT = 26 %AND PUSH(I+28, STARTS) %IF J = 37 %THEN NEXT = 30 %AND PUSH(I+32, STARTS) %FINISH %FINISH %RESULT = I+NEXT %END %INTEGERFN LIST WITH(%INTEGER THIS) %INTEGER P, D, W, LAST ! ! FINDS THE LIST CONTAINING THIS PIN ! DETACHES IT FROM THE LIST OF WIRES ! RESULT IS THE LIST POINTER ! W = WIRES LAST = 0 %WHILE W # 0 %CYCLE D = DATA(DATA(W)) %IF D = THIS %THEN %START P = DATA(W) %IF LAST = 0 %THEN D = POP(WIRES) %C %ELSE D = POP(LINK(LAST)) %RESULT = P %FINISH LAST = W W = LINK(W) %REPEAT %RESULT = 0 ! NOT FOUND %END %ROUTINE READ MODULE POSNS ! ! READS MODULE USEAGE AND ! ALLOCATIONS FROM INPUT FILE. ! %CONSTSTRING (9) %ARRAY TYPE(0 : 20) = %C 'UNUSED', 'EVOKE','MERGE2','NOP','RTCALL','MERGE4','BSENSE', 'GPAUR','GPINT','OPINT','IPINT','SINT','CGEN','TREG', 'BREG','BRANCH','COND','FLAG','GPAUC','SPREG','ETC' %INTEGER C, S, BUS SENSE %STRING (20) ST %ROUTINE SKIP LINES(%INTEGER N) %INTEGER C, S ! SKIPS EXACTLY N NEWLINE SYMBOLS. %CYCLE C = 1, 1, N READ SYMBOL(S) %UNTIL S = NL %REPEAT %END %ROUTINE READ STRING %STRING (1) S ST = '' READ ITEM(S) %UNTIL S # ' ' %AND S # SNL %CYCLE ST = ST.S %EXIT %IF NEXTSYMBOL = NL READ ITEM(S) %EXIT %IF S = ' ' %REPEAT %END %ROUTINE ALLOCATE LIST %INTEGER S, N, MTYPE %CYCLE MTYPE = 20, -1, 0 %IF TYPE(MTYPE) = ST %THEN %EXIT %REPEAT %IF MTYPE = 0 %AND ST # 'BTRMTR' %THEN %START PRINTSTRING('UNDEFINED MODULE '.ST.SNL) SKIP LINES(1) %RETURN %FINISH %CYCLE READ SYMBOL(S) %UNTIL S # ' ' %EXIT %IF S = NL %IF '0' <= S <= '9' %THEN N = S-'0' %ELSE N = S-'A'+10 READ SYMBOL(S) POSITION(N+(S-'A')*16) = MTYPE %REPEAT %END %CYCLE C = 16, 1, 63 POSITION(C) = 0 %REPEAT %CYCLE READ STRING %IF ST = 'NAME' %THEN %EXIT SKIP LINES(1) %REPEAT SKIP LINES(3) %CYCLE !SKIP NAME FIELD. %CYCLE C = 1, 1, 8 READ SYMBOL(S) %IF S = '#' %THEN -> CONTROL MODS %REPEAT ! READ MODULE TYPE. READ STRING ALLOCATE LIST %REPEAT CONTROL MODS: %CYCLE READ STRING %IF ST = 'CARD' %THEN %EXIT SKIP LINES(1) %REPEAT SKIP LINES(3) %CYCLE READ STRING ALLOCATE LIST S = NEXTSYMBOL %IF S = ' ' %THEN ALLOCATE LIST %IF S = '#' %THEN %EXIT %REPEAT SKIPLINES(8) %END %ROUTINE READ WIRING ! ! READS WIREING LIST ONTO A LIST OF LISTS. ! WIRING LISTS ARE FORMED INTO A ! STANDARD FORMAT:- ! LAST OUTPUT PIN,NEXT MAIN INPUT PIN,SECONDARY ! INPUT PINS, OTHER PINS ! %INTEGER D, S %INTEGERFN NEXT LIST %INTEGER C, N, S, I, J, TYPE %SWITCH SW(1 : 13) %INTEGER OUTS, MINS, INS, OTHERS %INTEGERFN NEXTPIN %CONSTBYTEINTEGERARRAY VAL('A' : 'V') = %C %C 0,2,4,6,8,10,12,14,100,16,18, 20,22,24,100,26,100,28,30,32,34,36 S = ' ' READ SYMBOL(S) %C %WHILE S = ' ' %OR S = '=' %OR S = '>' %OR S = '<' %C %OR S = '*' %RESULT = 0 %IF S = NL %IF 'A' <= S <= 'F' %THEN I = S-'A'+10 %ELSE I = S-'0' READSYMBOL(S) I = I+16*(S-'A') READ SYMBOL(J) READ SYMBOL(S) J = VAL(J)+S-'0' %RESULT = I<<16+J %END OUTS = 0 MINS = 0 INS = 0 OTHERS = 0 %IF NEXTSYMBOL = '#' %THEN %RESULT = -1 %CYCLE C = 1, 1, 12 READ SYMBOL(S) %RESULT = 0 %IF S = NL %REPEAT %CYCLE N = NEXTPIN %IF N = 0 %THEN %EXIT TYPE = PINS(I, J) %IF TYPE = -64 %THEN %START PUSH(N, OUTS) PUSH(N, STARTS) -> REPT %FINISH %IF 0 < TYPE < 14 %THEN %START -> SW(TYPE) SW(2): SW(4): SW(6): SW(8): SW(10): SW(12): PUSH(N, OUTS) -> END SW(1): SW(7): SW(9): SW(13): BACKWARDPUSH(N, MINS) -> END SW(11): PUSH(N, MINS) -> END SW(3): SW(5): BACKWARDPUSH(N, INS) END: %FINISH %ELSE BACKWARDPUSH(N, OTHERS) REPT: %REPEAT CONCAT(OUTS, MINS) CONCAT(OUTS, INS) CONCAT(OUTS, OTHERS) %RESULT = OUTS %END WIRES = 0 D = 1 %CYCLE D = NEXTLIST %IF D = -1 %THEN %EXIT %IF D # 0 %THEN BACKWARD PUSH(D, WIRES) ! SKIP BLANK LINE %EXIT %IF NEXTSYMBOL = '#' READ SYMBOL(S) %UNTIL S = NL %REPEAT %END %ROUTINE PRINT LIST(%INTEGER P1, NSPACES) %INTEGER P2, C1, C2 P2 = P1 SPACES(NSPACES) %WHILE P1 # 0 %CYCLE PRINT PIN(DATA(P1), 1, 1) SPACES(2) P1 = LINK(P1) %REPEAT NEWLINE SPACES(NSPACES) %WHILE P2 # 0 %CYCLE C1 = DATA(P2)>>16 C2 = DATA(P2)&X'FF' PRINTSTRING(TXT(PINS(C1, C2)).' ') P2 = LINK(P2) %REPEAT NEWLINE %END %ROUTINE PRINT WIRING %INTEGER P, L L = WIRES %UNTIL L = 0 %CYCLE P = DATA(L) PRINT LIST(P, 0) L = LINK(L) NEWLINE %REPEAT %END %ROUTINE DRAW EVOKE(%INTEGER STPIN) SPACES(13) PRINT PIN(STPIN, 0, 1) PRINT STRING(' *********O********* * ') PRINT PIN(STPIN, 1, 0) PRINT STRING(' * * *') PRINT STRING(' * * *********O********* ') PRINT PIN(NEXT PIN START(STPIN, '?'), 0, 1) NEWLINE %END %ROUTINE DRAW 2 BRANCH(%INTEGER STPIN) SPACES(12) PRINT STRING('0 ') PRINT PIN(PICT(1), 0, 1) PRINT STRING(' * * * * ') PRINT PIN(PICT(2), 0, 1) PRINT STRING(' * ') PRINT PIN(STPIN, 1, 0) PRINT STRING(' * ') PRINT PIN(PICT(3), 0, 1) PRINT STRING(' * <0>*O * * * * *<1>*') PRINTSTRING(' O ') PRINT PIN(PICT(4), 0, 1) NEWLINE %END %ROUTINE DRAW SUBROUTINE(%INTEGER STPIN) SPACES(14) PRINT PIN(PICT(1), 0, 1) PRINT STRING(' ******O****** * * * ') PRINT PIN(STPIN, 1, 0) PRINT STRING(' * ') PRINT PIN(PICT(2), 0, 1) PRINT STRING(' * O ') PRINT PIN(PICT(3), 0, 1) PRINT STRING(' * * O * ******O****** ') SPACES(14) PRINT PIN(PICT(4), 0, 1) NEWLINE %END %ROUTINE DRAW 8 BRANCH(%INTEGER STPIN) %STRING (40) S %INTEGER S2 S = '2 * ' S2 = STPIN&X'FF' %IF S2 = 11 %THEN S = '1 * ' SPACES(18) PRINT PIN(STPIN, 0, 1) PRINTSTRING(' *********O**************** ') PRINTSTRING(' *(4) H') SPACES(15) PRINT PIN(STPIN, 1, 0) PRINT STRING(' * ') PRINTSTRING(' *(2) J'.S) PRINT STRING(' *(0) K'.S) S = ' *V2 U2 S2 R2 P2 N2 M2 L2 * ' %IF S2 = 11 %THEN S = ' *V1 U1 S1 R1 P1 N1 M1 L1 * ' PRINTSTRING(S.' **O**O**O**O**O**O**O**O** ') NEWLINE %END %ROUTINE DRAW MERGE(%INTEGER TYPE, STPIN) %IF TYPE = 2 %THEN %START SPACES(4) PRINT PIN(PICT(1), 0, 1) PRINT STRING(' * * ') PRINT PIN(PICT(2), 0, 1) PRINT STRING(' **O O** * ***** * ') %FINISH %ELSE %START SPACES(3) PRINT PIN(PICT(1), 0, 1) PRINT STRING(' * * ') PRINT PIN(PICT(2), 0, 1) PRINT STRING(' ') PRINT PIN(PICT(4), 0, 1) PRINT STRING(' **O O** ') PRINT PIN(PICT(5), 0, 1) PRINT STRING(' * *O*O* * ') %FINISH PRINT STRING(' * * * ') PRINT PIN(STPIN, 1, 0) PRINT STRING(' * * * ') PRINT STRING(' * * * * O ') PRINT PIN(PICT(3), 0, 1) NEWLINE %END %ROUTINE DRAW MODULE(%INTEGER STPIN) %CONSTBYTEINTEGERARRAY BR2MAP(1 : 38) = %C 0(14),93,0(3),97,0(3),101,0(3),105, 0(3),109,0(5),113,0 %CONSTBYTEINTEGERARRAY SRMAP(1 : 38) = %C 0(14),65,0(3),69,0(3),73,0(2),77,81, 0(3),85,0(5),89,0 %CONSTBYTEINTEGERARRAY M2MAP(1 : 38) = %C 0(4),1,0(5),4,7,0(6),10,13, 0(4),16,19,0(4),22,25,0(5),28 %CONSTBYTEINTEGERARRAY M4MAP(1 : 38) = %C 0(8),25,0(8),30,0(2),35, 0(6),40,0(2),45,0(6),50 %INTEGER C, C1, S1, S2, OUT, TYPE S1 = STPIN>>16&X'FF' S2 = STPIN&X'FF' TYPE = PINS(S1, S2) %IF TYPE = 3 %OR TYPE = 5 %THEN %START OUT = NEXT PIN START(STPIN, '?') OUT = OUT&X'FF' %IF TYPE = 3 %THEN %START ! 2 MERGE C = M2 MAP(OUT) %CYCLE C1 = 0, 1, 2 PICT(C1+1) = P(C+C1) %REPEAT DRAW MERGE(2, STPIN) %RETURN %FINISH ! FOUR MERGE, TYPE=5 ! EVOKE MODULE 4 MERGES GET ! SPECIAL TREATMENT. %IF S1 = 32 %OR S1 = 33 %OR 46 <= S1 <= 49 %OR S1 = 62 %C %OR S1 = 63 %THEN C = M4MAP(OUT) %ELSE %START C = 60 %IF OUT = 31 %THEN C = 55 %FINISH %CYCLE C1 = 0, 1, 4 PICT(C1+1) = P(C+C1) %REPEAT DRAW MERGE(4, STPIN) %RETURN %FINISH %IF TYPE = 9 %THEN DRAW 8 BRANCH(STPIN) %AND %RETURN %IF TYPE = 11 %THEN %START C = SRMAP(S2) %CYCLE C1 = 0, 1, 3 PICT(C1+1) = P(C+C1) %REPEAT DRAW SUBROUTINE(STPIN) %RETURN %FINISH %IF TYPE = 7 %THEN %START ! 2 BRANCH IN C = BR2MAP(S2) %CYCLE C1 = 0, 1, 3 PICT(C1+1) = P(C+C1) %REPEAT DRAW 2 BRANCH(STPIN) %RETURN %FINISH %IF TYPE = 1 %THEN DRAW EVOKE(STPIN) %END %ROUTINE THREAD LIST %INTEGER START, OUT, N, L, NLS, IN, SUB STARTS, SFLAG SFLAG = 0 SUB STARTS = 0 PRINT STRING(' ') 1: %WHILE STARTS # 0 %CYCLE START = POP(STARTS) N = LIST WITH(START) %IF N = 0 %THEN -> REPT NLS = 1 %IF SFLAG = 0 %THEN %START ! PRINT START PIN IF NOT IN SUBROUTINE. PRINT STRING(' (') PRINT PIN(START, 1, 1) PRINTSYMBOL(')') NEWLINE %FINISH PRINT LIST(N, 30) NEWLINE %CYCLE L = LINK(N) %IF L = 0 %THEN %START PRINT PIN(DATA(N), 1, 1) %PRINTTEXT ' LIST LNGTH 1.' NEWLINE %EXIT %FINISH IN = DATA(L) OUT = NEXT PIN START(IN, 1) %IF OUT = 0 %THEN %START PRINT STRING(' (') PRINT PIN(IN, 1, 1) PRINT STRING(') ') %EXIT %FINISH ! SUBROUTINE START PIN? %IF PINS(IN>>16, IN&X'FF') = 11 %C %THEN PUSH(DATA(LINK(L)), SUB STARTS) DRAW MODULE(DATA(L)) N = LIST WITH(OUT) %IF N = 0 %THEN %START %PRINTTEXT 'NO LIST CONTAINS ' PRINT PIN(OUT, 1, 1) %EXIT %FINISH PRINT LIST(N, 30) %REPEAT REPT: NEWLINES(6) %REPEAT SFLAG = 1 %WHILE SUB STARTS # 0 %CYCLE IN = POP(SUB STARTS) OUT = NEXT PIN START(IN, 1) %IF OUT # 0 %THEN %START PRINT STRING('SUBROUTINE ENTRY POINT. ') DRAW MODULE(IN) PUSH(OUT, STARTS) -> 1 %FINISH %REPEAT %END INFILE = S OUT FILE = '' %UNLESS S -> INFILE.('/').OUTFILE INFILE=S OUTFILE='' %UNLESS ->INFILE.('/').OUTFILE PRINTSTRING('PARAM:'.S.' ') %AND %STOP %IF INFILE = '' OUTFILE='.TT' %IF OUTFILE = '' DEFINE('STREAM03,'.INFILE) DEFINE('STREAM04,'.OUTFILE) SELECT INPUT(3) SELECT OUTPUT(4) STARTS = 0 %CYCLE ASL = 1, 1, 1024 LINK(ASL) = ASL-1 DATA(ASL) = 0 %REPEAT READ MODULE POSNS ALLOCATE READ WIRING THREAD LIST PRINT WIRING %END %ENDOFFILE @@@@@@@@@@@@@@@ * * PHRASE STRUCTURE DEFINITOIN OF ARTHUR * * DEFINE BUILT-IN PHRASES * B[CONSTANT]=3 B[NAME]=4 B[NAMELIST]=5 B[SPDEFN']=6 B[TEXT]=7 B[SEPERATOR]=8 B[CONSTANT LIST]=9 * * DEFINE NAMED LITERAL VALUES * L = 0 L = 1 L = 0 * * DEFINE COMPOUND BUILT-IN PHRASES * D[OLD NAME]=[NAME=1] D[OLD NAME LIST] = [NAMELIST=1] * * THE FIRST PHRASE IS THE DEFAULT ENTRY POINT * P(STAT) (SS) [SEPERATOR]; P(SS) <15>(LABEL)':'(SS): <2> (LOCATION) (ASSOP) (EXPRN) (AND'): <1> [OLD NAME] (ACTP'): <3> (CONTROL TRANSFER) (OPTIONAL CONDITION'): '%WAIT' <4> (WHILE-UNTIL) (FLAGNAME): <5> (FLAG OPERATION) [OLD NAMELIST] (AND'): <6> (TYPE) [NAMELIST]: <7> (ROM-MEMORY) [NAMELIST] (SIZE) (RMEM'): '%BREG' <24> [NAME] (PIN DEFINITION'): '%TREG' <8> [NAME] (PIN DEFINITION'): '%SPM' <9> [NAME] [SPDEFN']: * '%CGEN' <19> [NAME] '=' [CONSTANT LIST]: '%DEFINE' <10> (EQITEM) (RDEFINE'): '%ROUTINE' <11> [NAME]: '%END' <12> (FILE'): * '%MACRO' <13> [NAME] (MACRO PARAMETERS'): '%BRANCH' <14> [NAME] '(' (LEVEL) ',' (LEVEL) ',' (LEVEL) ')': '%BREAKPOINT' <16> [NAME]: * '%EXTERNAL' [NAME LIST]: '%CONTROL' <18> [CONSTANT]: * '%MODULE' <20> [NAME]: '%CLEAR' '%BUS'<21>: '%NOP'<22>: '%REGFORMAT' <23> [NAME] '(' [CONSTANT] (PINLIST') ')': '%RADIX'<25>[CONSTANT]: '%ENABLE' <26> [OLD NAME](AND'): ; P(ASSOP) '<-': '='; P(PIN DEFINITION') '(' (DEF OR FORM) ')': ; P(DEF OR FORM) <1> [NAME]: <2> [CONSTANT] (PINLIST'); P(PINLIST') ',' [CONSTANT] (PINLIST'): ; P(ROM-MEMORY) '%MEMORY' <3>: '%ROM' <13>; P(TYPE) '%FLAG' <2>: '%GPINT' <9>: '%ININT' <10>: '%OUTINT' <11>: '%SINT' <12>: '%GPA' <1>; '%BUS'<25>: P(LOCATION) '[' <0> [OLD NAME] ']': <1> [OLD NAME] (FQUAL'): <2>'BUS'; P(FQUAL') '_' <1> (PREDECLARED NAME): '#' <2> [CONSTANT]: '<' <3> [CONSTANT] ':' [CONSTANT] '>': <0>; P(EXPRN) '('<16>(B-EXP) ')/2': <0>(B-EXP); P(B-EXP) <1> (PLUS) (GPAREG NAME) : <2> (GPAREG NAME) (OPERATION) : <3> [CONSTANT]: <4>(LOCATION); P(PLUS) '\' <3> : '2*' <5> : '1+' <6>; P(OPERATION) '*2' <5> : '+1' <6> : '-1' <7> : <0> (OPERATOR) (GPAREG NAME); P(OPERATOR) '+' <8> : '-' <9> : '&' <10> : '!!' <11> : '!' <12>; P(WHILE-UNTIL) '%WHILE' <1>: '%UNTIL' <2>; P(LEVEL) <0> (FLAGNAME): '%HIGH' <2>: '%LOW' <1>; P(GPAREG NAME) [OLD NAME] (ENAME'); P(ENAME') '_' <1> (PREDECLARED NAME): <0>; P(M FLAGS) 'OVF'<9>: 'DZ'<10>: 'DP'<12>: 'DN'<11>: 'BUS'<1>'<'[CONSTANT]'>'; P(FLAGNAME) <0>(GPAREG NAME) (BITDEF'): 'ZERO'<10>: 'POSITIVE'<12>: 'NEGATIVE'<11>: 'OVERFLOW'<9>: (M FLAGS); P(BITDEF') '<' <1> [CONSTANT] '>': <0>; P(FLAG OPERATION) '%SET' <3>: '%CLEAR' <4>: '%COMPLEMENT' <5>; P(CONTROL TRANSFER) '->' <0> [NAME]: '%RETURN' <1>: '%STOP' <2> ; P(OPTIONAL CONDITION') (IF-UNLESS) (FLAGNAME): <0>; P(IF-UNLESS) '%IF' <1>: '%UNLESS' <2>; P(AND') '%AND' <1> (FLAG OPERATION) [OLD NAMELIST] (AND'): <0> ; P(SIZE) '(' [CONSTANT] (KB') ')'; P(KB') 'K' <1024> : 'B' <1> : <1>; P(RMEM') ',' [NAMELIST] (SIZE) (RMEM'): ; P(EQITEM) [NAME] '=' (DTYPE); P(DTYPE) '*'<2> (HWNAME) '<' [CONSTANT] (RBIT) '>': <1><0>(GPA REG NAME)'<' <1> [CONSTANT] '>': <0>[OLD NAME](FQUAL'): 'BUS'<3>(BIT DEF'); P(HWNAME) <28> 'SWITCH': <29> 'DATA': <30> 'LIGHT(' [CONSTANT] ')' ; P(RBIT) ':' [CONSTANT]: ; P(RDEFINE') ',' (EQITEM) (RDEFINE'): ; P(LABEL) [NAME](QUAL'); P(QUAL') '('<8>[CONSTANT]')': <14>; P(FILE') '%OFFILE' : ; P(ACTP') '(' [TEXT] (RTEXTLST') ')': ; P(RTEXTLST') ',' [TEXT] (RTEXTLST'): ; *P(MACRO PARAMETERS') * '(' [NAMELIST] ')': * ; P(PREDECLARED NAME) 'A' <18>: 'B' <19>: 'KF' <21>: 'PF' <22>: 'IN' <26>: 'OUT' <27>: 'OVERUN' <31>; @ @@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@