#include <perms.h>
// Edinburgh IMP77 Compiler - Version 8.4
//
// 1 !!! %option stack=40
// 2 !! 17/1/78
// 3 {Modified 25-Feb-82 to run on new subsystem}
// 4
// 5 !!!! %CONTROL 1; ! CHECK SWITCHES ONLY
// 6
// 7 ! PASS 3 OF 7/32 IMP COMPILER - VERSION FOR MOUSES AND OS-32MT SUBSYSTEM
// 8
// 9 %CONSTINTEGER MAX PERM = 54
// 10 %CONSTINTEGERARRAY PERMS(1: 733) = %C
const int PERMS[733] = {
55, 398, 410, 420, 440, 587, 494, 507, 463, 0, 132, 163, 198, 70, 219, 0,
0, 708, 693, 678, 670, 664, 658, 642, 528, 60, 94, 89, 536, 321, 388, 80,
75, 119, 112, 105, 99, 127, 65, 361, 544, 549, 554, 559, 590, 85, 87, 565,
570, 575, 581, 366, 378, 623, 4, 9280, 22589, 4, 771, 4, 9281, 22589, 4, 771,
4, 9285, 22589, 4, 771, 4, 9282, 22589, 4, 771, 4, 9283, 22589, 4, 771, 4,
9284, 22589, 4, 771, 1, 0, 1, 0, 4, 9289, 22589, 4, 771, 4, 9290, 22589,
4, 771, 5, 9322, 9285, 22589, 4, 771, 6, 2134, 9322, 9287, 22589, 4, 771, 6,
51296, 32, 9285, 22589, 4, 771, 7, 2134, 51296, 32, 9287, 22589, 4, 771, 4, 9286,
22589, 4, 771, 30, 18433, 0, 50432, 32896, 8501, 9217, 9232, 34952, 1, 37888, 37680, 4097,
8584, 54017, 17152, 0, 53762, 17152, 0, 8968, 10033, 18433, 17152, 0, 16386, 17152, 0, 10034,
8727, 776, 34, 18433, 0, 50432, 32896, 8501, 9217, 9232, 34952, 1, 37888, 37632, 54098, 0,
2149, 2658, 2640, 50512, 255, 8997, 9221, 9244, 34952, 1, 53842, 0, 9985, 536, 9825, 9745,
54065, 0, 53814, 0, 8712, 20, 2146, 54017, 0, 54098, 0, 2896, 8984, 2565, 8966, 54070,
0, 54321, 0, 568, 9745, 9825, 9985, 8728, 2133, 776, 93, 53431, 256, 2226, 18641, 0,
50640, 32896, 9016, 38109, 37853, 18434, 0, 50432, 32896, 8501, 9217, 9232, 34952, 1, 37888, 37632,
2829, 16912, 32802, 2251, 2273, 2301, 10225, 16912, 32798, 9921, 9953, 54076, 0, 54334, 0, 8761,
9905, 9985, 17152, 65498, 53687, 256, 2049, 776, 2150, 8501, 1458, 8247, 17152, 32796, 2107, 2866,
53814, 0, 2252, 1468, 9016, 9825, 9921, 54070, 0, 53820, 0, 8712, 2133, 8502, 2048, 16944,
65478, 17152, 32802, 2749, 54018, 0, 2562, 2096, 2875, 53813, 0, 1456, 9016, 9905, 9809, 54069,
0, 53819, 0, 8712, 53687, 0, 1501, 776, 7, 2087, 51216, 256, 37473, 16402, 0, 776,
39, 18486, 0, 50480, 32896, 8501, 9217, 9232, 34952, 1, 37939, 37683, 2133, 9000, 22535, 44,
1283, 8484, 2821, 9729, 8981, 9221, 9241, 34952, 1, 51255, 44, 2067, 53763, 0, 2661, 9985,
536, 9777, 54054, 0, 53795, 0, 9825, 8712, 4, 9288, 22589, 4, 771, 11, 26663, 44,
22631, 48, 22615, 52, 51264, 22, 22589, 4, 771, 9, 26663, 44, 22631, 48, 51264, 23,
22589, 4, 771, 9, 22631, 44, 22615, 48, 51264, 21, 22589, 4, 771, 11, 2096, 2611,
10036, 536, 22529, 17152, 0, 20482, 17152, 0, 8712, 9, 2096, 2611, 9216, 10036, 536, 20482,
17152, 0, 8709, 19, 2097, 18738, 2, 8491, 19250, 0, 8472, 2611, 29491, 16896, 4, 9011,
2622, 563, 2081, 9221, 9236, 34952, 1, 22, 20502, 8, 20534, 4, 20566, 0, 52021, 65535,
8485, 9221, 9238, 34952, 1, 7201, 7173, 9216, 2817, 51219, 3, 50192, 65532, 776, 30, 20595,
0, 20739, 0, 20579, 4, 2087, 2673, 22589, 0, 51571, 65024, 8999, 2929, 2081, 9218, 9232,
34952, 1, 22622, 16, 62800, 32896, 32896, 568, 20561, 17151, 65532, 10004, 8245, 12, 2099, 8982,
2083, 9221, 9242, 34952, 1, 9233, 10033, 536, 7170, 8707, 13, 9217, 12032, 2049, 8982, 11522,
10272, 9216, 51969, 1, 824, 11266, 9985, 8707, 2, 2070, 776, 3, 2070, 2581, 776, 7,
51223, 44, 51264, 17, 22589, 4, 771, 7, 51223, 44, 51264, 18, 22589, 4, 771, 4,
9293, 22589, 4, 771, 4, 9294, 22589, 4, 771, 4, 9295, 22589, 4, 771, 5, 51264,
16, 22589, 4, 771, 4, 9291, 22589, 4, 771, 4, 9292, 22589, 4, 771, 5, 51264,
19, 22589, 4, 771, 5, 51264, 20, 22589, 4, 771, 2, 12033, 776, 8, 22557, 0,
2839, 792, 9218, 9232, 34952, 1, 11, 26631, 44, 63504, 16512, 0, 20503, 44, 27143, 44,
11792, 776, 4, 26631, 44, 11792, 776, 6, 26631, 44, 11792, 12065, 11010, 776, 18, 22551,
44, 50272, 15, 4452, 50784, 57601, 16487, 0, 9312, 16487, 2, 51296, 776, 16487, 4, 17159,
0, 15, 2082, 9018, 2832, 2049, 60928, 31, 7426, 9745, 8467, 2048, 824, 9221, 9233, 34952,
1, 5, 824, 9222, 9233, 34952, 1, 5, 840, 9222, 9233, 34952, 1, 7, 54273, 0,
904, 9222, 9233, 34952, 1, 14, 22802, 0, 8471, 22802, 4, 8484, 23554, 8, 776, 2081,
9222, 9234, 34952, 1, 14, 19064, 0, 22541, 0, 50439, 512, 17288, 2, 19320, 0, 9218,
9232, 34952, 1, 25, 2119, 19016, 0, 19064, 2, 22541, 0, 50439, 512, 9095, 19320, 2,
9218, 9232, 34952, 1, 22542, 16, 20484, 0, 9796, 1351, 8740, 17160, 4};
struct _imp_dv PERMS_dv = {PERMS, sizeof(int) /*, dims, <bounds> */};
// 11+ X'0037',X'018E',X'019A',X'01A4',X'01B8',X'024B',X'01EE',X'01FB',X'01CF',
// 12+ X'0000',X'0084',X'00A3',X'00C6',X'0046',X'00DB',X'0000',X'0000',X'02C4',
// 13+ X'02B5',X'02A6',X'029E',X'0298',X'0292',X'0282',X'0210',X'003C',X'005E',
// 14+ X'0059',X'0218',X'0141',X'0184',X'0050',X'004B',X'0077',X'0070',X'0069',
// 15+ X'0063',X'007F',X'0041',X'0169',X'0220',X'0225',X'022A',X'022F',X'024E',
// 16+ X'0055',X'0057',X'0235',X'023A',X'023F',X'0245',X'016E',X'017A',X'026F',
// 17+ X'0004',X'2440',X'583D',X'0004',X'0303',X'0004',X'2441',X'583D',X'0004',
// 18+ X'0303',X'0004',X'2445',X'583D',X'0004',X'0303',X'0004',X'2442',X'583D',
// 19+ X'0004',X'0303',X'0004',X'2443',X'583D',X'0004',X'0303',X'0004',X'2444',
// 20+ X'583D',X'0004',X'0303',X'0001',X'0000',X'0001',X'0000',X'0004',X'2449',
// 21+ X'583D',X'0004',X'0303',X'0004',X'244A',X'583D',X'0004',X'0303',X'0005',
// 22+ X'246A',X'2445',X'583D',X'0004',X'0303',X'0006',X'0856',X'246A',X'2447',
// 23+ X'583D',X'0004',X'0303',X'0006',X'C860',X'0020',X'2445',X'583D',X'0004',
// 24+ X'0303',X'0007',X'0856',X'C860',X'0020',X'2447',X'583D',X'0004',X'0303',
// 25+ X'0004',X'2446',X'583D',X'0004',X'0303',X'001E',X'4801',X'0000',X'C500',
// 26+ X'8080',X'2135',X'2401',X'2410',X'8888',X'0001',X'9400',X'9330',X'1001',
// 27+ X'2188',X'D301',X'4300',X'0000',X'D202',X'4300',X'0000',X'2308',X'2731',
// 28+ X'4801',X'4300',X'0000',X'4002',X'4300',X'0000',X'2732',X'2217',X'0308',
// 29+ X'0022',X'4801',X'0000',X'C500',X'8080',X'2135',X'2401',X'2410',X'8888',
// 30+ X'0001',X'9400',X'9300',X'D352',X'0000',X'0865',X'0A62',X'0A50',X'C550',
// 31+ X'00FF',X'2325',X'2405',X'241C',X'8888',X'0001',X'D252',X'0000',X'2701',
// 32+ X'0218',X'2661',X'2611',X'D331',X'0000',X'D236',X'0000',X'2208',X'0014',
// 33+ X'0862',X'D301',X'0000',X'D352',X'0000',X'0B50',X'2318',X'0A05',X'2306',
// 34+ X'D336',X'0000',X'D431',X'0000',X'0238',X'2611',X'2661',X'2701',X'2218',
// 35+ X'0855',X'0308',X'005D',X'D0B7',X'0100',X'08B2',X'48D1',X'0000',X'C5D0',
// 36+ X'8080',X'2338',X'94DD',X'93DD',X'4802',X'0000',X'C500',X'8080',X'2135',
// 37+ X'2401',X'2410',X'8888',X'0001',X'9400',X'9300',X'0B0D',X'4210',X'8022',
// 38+ X'08CB',X'08E1',X'08FD',X'27F1',X'4210',X'801E',X'26C1',X'26E1',X'D33C',
// 39+ X'0000',X'D43E',X'0000',X'2239',X'26B1',X'2701',X'4300',X'FFDA',X'D1B7',
// 40+ X'0100',X'0801',X'0308',X'0866',X'2135',X'05B2',X'2037',X'4300',X'801C',
// 41+ X'083B',X'0B32',X'D236',X'0000',X'08CC',X'05BC',X'2338',X'2661',X'26C1',
// 42+ X'D336',X'0000',X'D23C',X'0000',X'2208',X'0855',X'2136',X'0800',X'4230',
// 43+ X'FFC6',X'4300',X'8022',X'0ABD',X'D302',X'0000',X'0A02',X'0830',X'0B3B',
// 44+ X'D235',X'0000',X'05B0',X'2338',X'26B1',X'2651',X'D335',X'0000',X'D23B',
// 45+ X'0000',X'2208',X'D1B7',X'0000',X'05DD',X'0308',X'0007',X'0827',X'C810',
// 46+ X'0100',X'9261',X'4012',X'0000',X'0308',X'0027',X'4836',X'0000',X'C530',
// 47+ X'8080',X'2135',X'2401',X'2410',X'8888',X'0001',X'9433',X'9333',X'0855',
// 48+ X'2328',X'5807',X'002C',X'0503',X'2124',X'0B05',X'2601',X'2315',X'2405',
// 49+ X'2419',X'8888',X'0001',X'C837',X'002C',X'0813',X'D203',X'0000',X'0A65',
// 50+ X'2701',X'0218',X'2631',X'D326',X'0000',X'D223',X'0000',X'2661',X'2208',
// 51+ X'0004',X'2448',X'583D',X'0004',X'0303',X'000B',X'6827',X'002C',X'5867',
// 52+ X'0030',X'5857',X'0034',X'C840',X'0016',X'583D',X'0004',X'0303',X'0009',
// 53+ X'6827',X'002C',X'5867',X'0030',X'C840',X'0017',X'583D',X'0004',X'0303',
// 54+ X'0009',X'5867',X'002C',X'5857',X'0030',X'C840',X'0015',X'583D',X'0004',
// 55+ X'0303',X'000B',X'0830',X'0A33',X'2734',X'0218',X'5801',X'4300',X'0000',
// 56+ X'5002',X'4300',X'0000',X'2208',X'0009',X'0830',X'0A33',X'2400',X'2734',
// 57+ X'0218',X'5002',X'4300',X'0000',X'2205',X'0013',X'0831',X'4932',X'0002',
// 58+ X'212B',X'4B32',X'0000',X'2118',X'0A33',X'7333',X'4200',X'0004',X'2333',
// 59+ X'0A3E',X'0233',X'0821',X'2405',X'2414',X'8888',X'0001',X'0016',X'5016',
// 60+ X'0008',X'5036',X'0004',X'5056',X'0000',X'CB35',X'FFFF',X'2125',X'2405',
// 61+ X'2416',X'8888',X'0001',X'1C21',X'1C05',X'2400',X'0B01',X'C813',X'0003',
// 62+ X'C410',X'FFFC',X'0308',X'001E',X'5073',X'0000',X'5103',X'0000',X'5063',
// 63+ X'0004',X'0827',X'0A71',X'583D',X'0000',X'C973',X'FE00',X'2327',X'0B71',
// 64+ X'0821',X'2402',X'2410',X'8888',X'0001',X'585E',X'0010',X'F550',X'8080',
// 65+ X'8080',X'0238',X'5051',X'42FF',X'FFFC',X'2714',X'2035',X'000C',X'0833',
// 66+ X'2316',X'0823',X'2405',X'241A',X'8888',X'0001',X'2411',X'2731',X'0218',
// 67+ X'1C02',X'2203',X'000D',X'2401',X'2F00',X'0801',X'2316',X'2D02',X'2820',
// 68+ X'2400',X'CB01',X'0001',X'0338',X'2C02',X'2701',X'2203',X'0002',X'0816',
// 69+ X'0308',X'0003',X'0816',X'0A15',X'0308',X'0007',X'C817',X'002C',X'C840',
// 70+ X'0011',X'583D',X'0004',X'0303',X'0007',X'C817',X'002C',X'C840',X'0012',
// 71+ X'583D',X'0004',X'0303',X'0004',X'244D',X'583D',X'0004',X'0303',X'0004',
// 72+ X'244E',X'583D',X'0004',X'0303',X'0004',X'244F',X'583D',X'0004',X'0303',
// 73+ X'0005',X'C840',X'0010',X'583D',X'0004',X'0303',X'0004',X'244B',X'583D',
// 74+ X'0004',X'0303',X'0004',X'244C',X'583D',X'0004',X'0303',X'0005',X'C840',
// 75+ X'0013',X'583D',X'0004',X'0303',X'0005',X'C840',X'0014',X'583D',X'0004',
// 76+ X'0303',X'0002',X'2F01',X'0308',X'0008',X'581D',X'0000',X'0B17',X'0318',
// 77+ X'2402',X'2410',X'8888',X'0001',X'000B',X'6807',X'002C',X'F810',X'4080',
// 78+ X'0000',X'5017',X'002C',X'6A07',X'002C',X'2E10',X'0308',X'0004',X'6807',
// 79+ X'002C',X'2E10',X'0308',X'0006',X'6807',X'002C',X'2E10',X'2F21',X'2B02',
// 80+ X'0308',X'0012',X'5817',X'002C',X'C460',X'000F',X'1164',X'C660',X'E101',
// 81+ X'4067',X'0000',X'2460',X'4067',X'0002',X'C860',X'0308',X'4067',X'0004',
// 82+ X'4307',X'0000',X'000F',X'0822',X'233A',X'0B10',X'0801',X'EE00',X'001F',
// 83+ X'1D02',X'2611',X'2113',X'0800',X'0338',X'2405',X'2411',X'8888',X'0001',
// 84+ X'0005',X'0338',X'2406',X'2411',X'8888',X'0001',X'0005',X'0348',X'2406',
// 85+ X'2411',X'8888',X'0001',X'0007',X'D401',X'0000',X'0388',X'2406',X'2411',
// 86+ X'8888',X'0001',X'000E',X'5912',X'0000',X'2117',X'5912',X'0004',X'2124',
// 87+ X'5C02',X'0008',X'0308',X'0821',X'2406',X'2412',X'8888',X'0001',X'000E',
// 88+ X'4A78',X'0000',X'580D',X'0000',X'C507',X'0200',X'4388',X'0002',X'4B78',
// 89+ X'0000',X'2402',X'2410',X'8888',X'0001',X'0019',X'0847',X'4A48',X'0000',
// 90+ X'4A78',X'0002',X'580D',X'0000',X'C507',X'0200',X'2387',X'4B78',X'0002',
// 91+ X'2402',X'2410',X'8888',X'0001',X'580E',X'0010',X'5004',X'0000',X'2644',
// 92+ X'0547',X'2224',X'4308',X'0004'
// 93 !
// 94 ! FAULT MESSAGES
// 95 ! 1 - NO CODE REFS LEFT
// 96 ! 2 - TOO MANY LABELS
// 97 ! 3 - SPURIOUS PERM CALL
// 98 ! 4 - TOO MANY PATCHES
// 99 ! 5 - CORRUPT JUMP
// 100 ! 6 - CORRUPT PERM ROUTINE
// 101 ! 7 - PHASE ERROR
// 102 ! 8 - CORRUPT PERM ADDRESS
// 103 ! 9 - CODE INCOMPLETE
// 104 ! 10 - GLAP INCOMPLETE
// 105 !
// 106 %CONSTINTEGER PSEUDO OBJ = 2, DIRECT = 3;! INPUT STREAMS
// 107 %CONSTINTEGER REPORT = 0, OBJECT = 2; ! OUTPUT
// 108
// 109 %CONSTINTEGERARRAY NOT(0:12) = 1,0,5,4,3,2,7,6,11,10,9,8,12
const int NOT[13] = {1, 0, 5, 4, 3, 2, 7, 6, 11, 10, 9, 8, 12};
struct _imp_dv NOT_dv = {NOT, sizeof(int) /*, dims, <bounds> */};
// 110 %CONSTINTEGERARRAY SB(0:12) =
const int SB[13] = {8752, 8240, 8208, 8224, 8736, 8720, 8752, 8240, 8224, 8208, 8720, 8736, 8704};
struct _imp_dv SB_dv = {SB, sizeof(int) /*, dims, <bounds> */};
// 111+ X'2230', X'2030', X'2010', X'2020', X'2220', X'2210',
// 112+ X'2230', X'2030', X'2020', X'2010', X'2210', X'2220', X'2200'
// 113 %CONSTINTEGERARRAY SF(0:12) =
const int SF[13] = {9008, 8496, 8464, 8480, 8992, 8976, 9008, 8496, 8480, 8464, 8976, 8992, 8960};
struct _imp_dv SF_dv = {SF, sizeof(int) /*, dims, <bounds> */};
// 114+ X'2330', X'2130', X'2110', X'2120', X'2320', X'2310',
// 115+ X'2330', X'2130', X'2120', X'2110', X'2310', X'2320', X'2300'
// 116 %CONSTINTEGERARRAY LJ(0:12) =
const int LJ[13] = {17214, 16958, 16926, 16942, 17198, 17182, 17214, 16958, 16942, 16926, 17182, 17198, 17166};
struct _imp_dv LJ_dv = {LJ, sizeof(int) /*, dims, <bounds> */};
// 117+ X'433E', X'423E', X'421E', X'422E', X'432E', X'431E',
// 118+ X'433E', X'423E', X'422E', X'421E', X'431E', X'432E', X'430E'
// 119 %CONSTINTEGER MAX PATCH = 450
// 120 %CONSTINTEGER MAX JUMPS = 3000
// 121 %CONSTINTEGER MAX LABELS= 2000
// 122 %BEGIN
int main(int argc, char **argv) { /*%begin*/
_imp_initialise(argc, argv);
// 123
// 124 %RECORDFORMAT PFM(%INTEGER WHAT, WHERE)
struct PFM {
union {
struct {
int WHAT;
int WHERE;
};
};
};
// 125 %RECORDFORMAT LFM(%INTEGER LAB, CA)
struct LFM {
union {
struct {
int LAB;
int CA;
};
};
};
// 126 ! LAB = MODE(3)+LABEL(12)
// 127 ! MODE= LONG+CONDITIONAL+PERM+RT
// 128 %RECORD(LFM)%ARRAY JUMP(1 : MAXJUMPS+1)
struct LFM JUMP[3000 + 1 - 1 + 1];
struct _imp_dv JUMP_dv = {JUMP, sizeof(struct LFM) /*, dims, <bounds> */};
// 129 %RECORD(PFM)%ARRAY PATCH(1 : MAX PATCH)
struct PFM PATCH[450];
struct _imp_dv PATCH_dv = {PATCH, sizeof(struct PFM) /*, dims, <bounds> */};
// 130 %INTEGERARRAY LAB(0 : MAXLABELS)
int LAB[2001];
struct _imp_dv LAB_dv = {LAB, sizeof(int) /*, dims, <bounds> */};
// 131 %INTEGERARRAY LTEMP(0:9)
int LTEMP[10];
struct _imp_dv LTEMP_dv = {LTEMP, sizeof(int) /*, dims, <bounds> */};
// 132 %INTEGERARRAY PEP, PADDR(1:MAX PERM)
int PEP[54];
struct _imp_dv PEP_dv = {PEP, sizeof(int) /*, dims, <bounds> */};
int PADDR[54];
struct _imp_dv PADDR_dv = {PADDR, sizeof(int) /*, dims, <bounds> */};
// 133 %INTEGER CA, GA, LA, DA
int CA;
int GA;
int LA;
int DA;
// 134 %INTEGER LINE SIZE
int LINESIZE;
// 135 %INTEGER CODE SIZE, GLA SIZE, LOAD SIZE, PERM SIZE, DIAG SIZE
int CODESIZE;
int GLASIZE;
int LOADSIZE;
int PERMSIZE;
int DIAGSIZE;
// 136 %CONSTINTEGER EMARK = X'8888'
// 137 %CONSTINTEGER NEVER = X'7FFF'
// 138 %CONSTINTEGER LONG = X'800000'
// 139 %CONSTINTEGER COND = X'400000'
// 140 %CONSTINTEGER PERM = X'200000'
// 141 %CONSTINTEGER RT = X'100000'
// 142 %CONSTINTEGER VERY = X'080000'
// 143 %CONSTINTEGER LABEL= X'FFFF'
// 144 %OWNINTEGER MAX LABEL = 1
static int MAXLABEL = 1;
// 145 %OWNINTEGER INIT GLA = 0
static int INITGLA = 0;
// 146 %INTEGER REF EXTRA, IGNORE, FLAG
int REFEXTRA;
int IGNORE;
int FLAG;
// 147 %INTEGER REFS, CURRENT LINE
int REFS;
int CURRENTLINE;
// 148 %INTEGER J,K,L,z
int J;
int K;
int L;
int Z;
// 149 %INTEGER CP, GP, CODE, TAG, EXTRA
int CP;
int GP;
int CODE;
int TAG;
int EXTRA;
// 150 %RECORD(PFM)%NAME PAT
struct PFM *PAT;
// 151 %INTEGER CTAG, CCA, UCA, DEFMOD, LAST
int CTAG;
int CCA;
int UCA;
int DEFMOD;
int LAST;
// 152 %INTEGER MODE, CADDR, CVAL, GADDR, GVAL
int MODE;
int CADDR;
int CVAL;
int GADDR;
int GVAL;
// 153 %SWITCH D(1:8), C(2:11)
int D_index;
int D_line;
char *D_file;
static const void *D[8] = {&&case_D_1, &&case_D_2, &&case_D_3, &&case_D_4,
&&case_D_5, &&case_D_6, &&case_D_7, &&case_D_8};
int C_index;
int C_line;
char *C_file;
static const void *C[10] = {&&case_C_2, &&case_C_3, &&case_C_4, &&case_C_5, &&case_C_6,
&&case_C_7, &&case_C_8, &&case_C_9, &&case_C_10, &&case_C_11};
// 154 %RECORD(LFM)%NAME UREF, CREF
struct LFM *UREF;
struct LFM *CREF;
// 155 %RECORD(LFM)%NAME R,B
struct LFM *R;
struct LFM *B;
// 156 %INTEGERNAME V
int *V;
// 157 %INTEGER PHASE
int PHASE;
// 158 %INTEGER RX1,RX2,RX3,SJ; RX1=0; RX2=0; RX3=0; SJ=0
int RX1;
int RX2;
int RX3;
int SJ;
RX1 = 0;
RX2 = 0;
RX3 = 0;
SJ = 0;
// 159 %INTEGER RTNCALLS, PERMCALLS; RTNCALLS=0; PERMCALLS=0
int RTNCALLS;
int PERMCALLS;
RTNCALLS = 0;
PERMCALLS = 0;
// 160 !
// 161 !
// 162 !
// 163 %SHORTINTEGER CBP, GBP, LBP, DBP, TBP
short int CBP;
short int GBP;
short int LBP;
short int DBP;
short int TBP;
// 164
// 165 ! N.B. 'GLABUFFSIZE' MUST BE A POWER OF 2 -- SEE LINE 562 ISH
// 166 %CONSTINTEGER CODEBUFFSIZE=200, GLABUFFSIZE=256, LD BUFF SIZE=200
// 167 %CONSTINTEGER DIAG BUFF SIZE = 256
// 168 %SHORTINTEGERARRAY TBUFF,DBUFF(1:DIAG BUFF SIZE)
short int TBUFF[256];
struct _imp_dv TBUFF_dv = {TBUFF, sizeof(short int) /*, dims, <bounds> */};
short int DBUFF[256];
struct _imp_dv DBUFF_dv = {DBUFF, sizeof(short int) /*, dims, <bounds> */};
// 169 %SHORTINTEGERARRAY CBUFF(1:CODE BUFFSIZE), GBUFF(1:GLA BUFFSIZE)
short int CBUFF[200];
struct _imp_dv CBUFF_dv = {CBUFF, sizeof(short int) /*, dims, <bounds> */};
short int GBUFF[256];
struct _imp_dv GBUFF_dv = {GBUFF, sizeof(short int) /*, dims, <bounds> */};
// 170 %SHORTINTEGERARRAY LBUFF(1:LD BUFFSIZE); ! ... LD = 'LOADER DATA'
short int LBUFF[200];
struct _imp_dv LBUFF_dv = {LBUFF, sizeof(short int) /*, dims, <bounds> */};
// 171 !
// 172 ! -------OBJECT BLOCK TYPE CODES-------
// 173 %CONSTINTEGER END OF FILE BLOCK = 0
// 174 %CONSTINTEGER NONDIAG CODE BLOCK = 1
// 175 %CONSTINTEGER DIAG CODE BLOCK = 2
// 176 %CONSTINTEGER STATIC DATA BLOCK = 3; ! ...'GLA' IN IMP CONTEXT
// 177 %CONSTINTEGER DIAGS DATA BLOCK = 4
// 178 %CONSTINTEGER DIAG TABLE = 5
// 179 %CONSTINTEGER ENTRY POINT BLOCK = 6
// 180 %CONSTINTEGER EXTERNAL REF BLOCK = 7
// 181 %CONSTINTEGER SEGMENT SIZE BLOCK = 15
// 182 !
// 183 %ROUTINE GET(%INTEGERNAME N)
void GET(int *N) {
// 184 %INTEGER S
int S;
// 185 READSYMBOL(N); READSYMBOL(S)
_imp_READSYMBOL(N);
_imp_READSYMBOL(/*?*/ &S);
// 186 N = N<<8!S
*N = *N << 8 | S;
// 187 %END
return;
} /* end of GET */
// 188 !
// 189 %ROUTINE PUT HALF(%SHORTINTEGER N)
void PUTHALF(short int N) {
// 190 PRINT SYMBOL((N>>8)&255)
_imp_PRINTSYMBOL((unsigned int)N >> 8 & 255);
// 191 PRINT SYMBOL(N&255)
_imp_PRINTSYMBOL(N & 255);
// 192 %END
return;
} /* end of PUTHALF */
// 193 !
// 194 %ROUTINE PUT BLOCK(%SHORTINTEGER HEADER, %SHORTINTEGERARRAYNAME BLOCK)
void PUTBLOCK(short int HEADER, short int *BLOCK) {
// 195 %SHORTINTEGER I,J
short int I;
short int J;
// 196 PUT HALF(HEADER)
PUTHALF(HEADER);
// 197 %CYCLE I = 1,1,(HEADER>>4)&X'0FFF'; ! ...EXTRACT LENGTH
// %for I = 1, 1, (unsigned int)HEADER >> 4 & 4095 %cycle
{
int _final = (unsigned int)HEADER >> 4 & 4095;
if (invalid_for_loop(1, 1, _final))
_imp_signal(5, 1, 0, "Illegal cycle I = 1, 1, (unsigned int)HEADER >> 4 & 4095");
I = 0;
L_0001:
if (I == _final) goto L_0002;
I += 1;
// 198 J = BLOCK(I)
J = BLOCK[/*BUG*/ I];
// 199 HEADER = HEADER+J; ! ...ACCUMULATE CHECKSUM
HEADER = HEADER + J;
// 200 PUT HALF(J)
PUTHALF(J);
// 201 %REPEAT
goto L_0001;
}
L_0002:;
// 202 PUT HALF(-HEADER-1); ! ...CHECKSUM
PUTHALF(-HEADER - 1);
// 203 %END
return;
} /* end of PUTBLOCK */
// 204 !
// 205 %ROUTINE COPY BLOCK(%SHORTINTEGER HEADER)
void COPYBLOCK(short int HEADER) {
// 206 %SHORTINTEGER I; %INTEGER N
short int I;
int N;
// 207 PUT HALF(HEADER)
PUTHALF(HEADER);
// 208 %CYCLE I = 1,1,(HEADER>>4)&X'0FFF'
// %for I = 1, 1, (unsigned int)HEADER >> 4 & 4095 %cycle
{
int _final = (unsigned int)HEADER >> 4 & 4095;
if (invalid_for_loop(1, 1, _final))
_imp_signal(5, 1, 0, "Illegal cycle I = 1, 1, (unsigned int)HEADER >> 4 & 4095");
I = 0;
L_0004:
if (I == _final) goto L_0005;
I += 1;
// 209 GET(N); HEADER = HEADER+N
GET(/*?*/ &N);
HEADER = HEADER + N;
// 210 PUT HALF(N)
PUTHALF(N);
// 211 %REPEAT
goto L_0004;
}
L_0005:;
// 212 PUT HALF(-HEADER-1)
PUTHALF(-HEADER - 1);
// 213 %END
return;
} /* end of COPYBLOCK */
// 214 %ROUTINE CFLUSH
void CFLUSH(void) {
// 215 ! OUTPUT BUFFER IF THERE IS ANYTHING IN IT -- OTHERWISE JUST
// 216 ! INITIALISE. BUFFER IS EMPTY IF CBP=1
// 217 PUT BLOCK( (CBP<<4)!DIAG CODE BLOCK, CBUFF ) %IF CBP # 1
if (CBP == 1) goto L_0006;
PUTBLOCK(CBP << 4 | 2, CBUFF);
L_0006:;
// 218 CBP = 1; CBUFF(1) = CURRENT LINE
CBP = 1;
CBUFF[0] = CURRENTLINE;
// 219 %END
return;
} /* end of CFLUSH */
// 220 !
// 221 %ROUTINE GFLUSH
void GFLUSH(void) {
// 222 PUT BLOCK( (GBP<<4)!STATIC DATA BLOCK, GBUFF) %UNLESS GBP = 0
if (GBP == 0) goto L_0007;
PUTBLOCK(GBP << 4 | 3, GBUFF);
L_0007:;
// 223 GBP = 0
GBP = 0;
// 224 %END
return;
} /* end of GFLUSH */
// 225 !
// 226 %ROUTINE LFLUSH
void LFLUSH(void) {
// 227 PUT BLOCK( (LBP<<4)!EXTERNAL REF BLOCK, LBUFF) %IF LBP # 0
if (LBP == 0) goto L_0008;
PUTBLOCK(LBP << 4 | 7, LBUFF);
L_0008:;
// 228 LBP = 0
LBP = 0;
// 229 %END
return;
} /* end of LFLUSH */
// 230 !
// 231 %ROUTINE DFLUSH
void DFLUSH(void) {
// 232 %RETURN %IF DBP = 0
if (DBP != 0) goto L_0009;
return;
L_0009:;
// 233 PUT BLOCK(DBP<<4+DIAGS DATA BLOCK, DBUFF)
PUTBLOCK((DBP << 4) + 4, DBUFF);
// 234 DBP = 0
DBP = 0;
// 235 %END
return;
} /* end of DFLUSH */
// 236 %ROUTINE T FLUSH
void TFLUSH(void) {
// 237 PUT BLOCK((TBP<<4)!DIAG TABLE, T BUFF) %UNLESS TBP = 0
if (TBP == 0) goto L_000A;
PUTBLOCK(TBP << 4 | 5, TBUFF);
L_000A:;
// 238 TBP = 0
TBP = 0;
// 239 %END
return;
} /* end of TFLUSH */
// 240 %ROUTINE CPUT(%SHORTINTEGER N)
void CPUT(short int N) {
// 241 CBP = CBP+1; CBUFF(CBP) = N
CBP = CBP + 1;
CBUFF[CBP - 1] = N;
// 242 CA = CA+2
CA = CA + 2;
// 243 %END
return;
} /* end of CPUT */
// 244 !
// 245 %ROUTINE GPUT(%SHORTINTEGER N)
void GPUT(short int N) {
// 246 GFLUSH %IF GBP = GLA BUFF SIZE
if (GBP != 256) goto L_000B;
GFLUSH();
L_000B:;
// 247 GBP = GBP+1; GBUFF(GBP) = N
GBP = GBP + 1;
GBUFF[GBP - 1] = N;
// 248 GA = GA+2
GA = GA + 2;
// 249 %END
return;
} /* end of GPUT */
// 250 !
// 251 %ROUTINE LPUT(%SHORTINTEGER N)
void LPUT(short int N) {
// 252 LFLUSH %IF LBP = LD BUFFSIZE
if (LBP != 200) goto L_000C;
LFLUSH();
L_000C:;
// 253 LBP = LBP+1; LBUFF(LBP) = N
LBP = LBP + 1;
LBUFF[LBP - 1] = N;
// 254 LA = LA+2
LA = LA + 2;
// 255 %END
return;
} /* end of LPUT */
// 256 !
// 257 %ROUTINE LSYM(%SHORTINTEGER N)
void LSYM(short int N) {
// 258 %OWNINTEGER FLAG,V
static int FLAG;
static int V;
// 259 FLAG = \FLAG
FLAG = (~FLAG);
// 260 %IF FLAG = 0 %START
if (FLAG != 0) goto L_000D;
// 261 LPUT(N<<8+V)
LPUT((N << 8) + V);
// 262 %ELSE
goto L_000E;
L_000D:;
// 263 V = N
V = N;
// 264 %FINISH
L_000E:;
// 265 %END
return;
} /* end of LSYM */
// 266 !
// 267 %ROUTINE DPUT(%SHORTINTEGER N)
void DPUT(short int N) {
// 268 DBP = DBP+1; DBUFF(DBP) = N
DBP = DBP + 1;
DBUFF[DBP - 1] = N;
// 269 DFLUSH %IF DBP = DIAG BUFF SIZE
if (DBP != 256) goto L_000F;
DFLUSH();
L_000F:;
// 270 DA = DA+2
DA = DA + 2;
// 271 %END
return;
} /* end of DPUT */
// 272 %ROUTINE DIAG LINE
void DIAGLINE(void) {
// 273 %OWNINTEGER HERE = 0
static int HERE = 0;
// 274 %RETURN %IF HERE = CURRENT LINE
if (HERE != CURRENTLINE) goto L_0010;
return;
L_0010:;
// 275 HERE = CURRENT LINE
HERE = CURRENTLINE;
// 276 DPUT(CURRENT LINE); DPUT(CA)
DPUT(CURRENTLINE);
DPUT(CA);
// 277 %END
return;
} /* end of DIAGLINE */
// 278 %ROUTINE T PUT(%SHORTINTEGER V)
void TPUT(short int V) {
// 279 TBP = TBP+1; TBUFF(TBP) = V
TBP = TBP + 1;
TBUFF[TBP - 1] = V;
// 280 T FLUSH %IF TBP = DIAG BUFF SIZE
if (TBP != 256) goto L_0011;
TFLUSH();
L_0011:;
// 281 %END
return;
} /* end of TPUT */
// 282 %ROUTINE CLOSE OBJECT FILE
void CLOSEOBJECTFILE(void) {
// 283 CFLUSH; GFLUSH; LFLUSH
CFLUSH();
GFLUSH();
LFLUSH();
// 284 DPUT(0); DPUT(0); D FLUSH ; ! ... MARK END OF TABLE THEN FLUSH
DPUT(0);
DPUT(0);
DFLUSH();
// 285 TPUT(X'8800'); TPUT(CA+2)
TPUT(34816);
TPUT(CA + 2);
// 286 TPUT(0); TPUT(0)
TPUT(0);
TPUT(0);
// 287 TPUT(0); TPUT(0)
TPUT(0);
TPUT(0);
// 288 TPUT(0); TPUT(0); T FLUSH; ! .... DITTO ....
TPUT(0);
TPUT(0);
TFLUSH();
// 289 PUT HALF( (0<<4)!END OF FILE BLOCK ); ! ...ZERO DATA CONTENT
PUTHALF(0 << 4 | 0);
// 290 PUT HALF(-END OF FILE BLOCK-1); ! ...CHECK SUM
PUTHALF(0 - 1);
// 291 %END
return;
} /* end of CLOSEOBJECTFILE */
// 292 !
// 293 !
// 294 !
// 295 !
// 296 !
// 297 %ROUTINE MONITOR(%INTEGER N)
void MONITOR(int N) {
// 298 SELECTOUTPUT(REPORT)
_imp_SELECTOUTPUT(0);
// 299 PRINTSTRING("FAULT"); WRITE(N, 1)
_imp_PRINTSTRING(_imp_str_literal("FAULT"));
_imp_WRITE(N, 1);
// 300 PRINTSTRING(" PHASE"); WRITE(PHASE, 1); NEWLINE
_imp_PRINTSTRING(_imp_str_literal(" PHASE"));
_imp_WRITE(PHASE, 1);
_imp_NEWLINE();
// 301 WRITE(REFS, 1); PRINTSTRING(" REFS"); NEWLINE
_imp_WRITE(REFS, 1);
_imp_PRINTSTRING(_imp_str_literal(" REFS"));
_imp_NEWLINE();
// 302 PRINTSTRING("MAX LABEL"); WRITE(MAX LABEL, 1); NEWLINE
_imp_PRINTSTRING(_imp_str_literal("MAX LABEL"));
_imp_WRITE(MAXLABEL, 1);
_imp_NEWLINE();
// 303 %SIGNAL 15,15
_imp_signal(15, 15, 0, "");
// 304 %END
return;
} /* end of MONITOR */
// 305 !
// 306 %ROUTINE SORT(%INTEGER FROM, TO)
void SORT(int FROM, int TO) {
// 307 %INTEGER FLAG, J, T
int FLAG;
int J;
int T;
// 308 %RECORD(PFM)%NAME A, B
struct PFM *A;
struct PFM *B;
// 309 %WHILE TO > FROM %CYCLE
L_0012:;
if (TO <= FROM) goto L_0013;
// 310 FLAG = 0
FLAG = 0;
// 311 A == PATCH(FROM)
A = (struct PFM *)/*?*/ &PATCH[FROM - 1];
// 312 %CYCLE J = FROM+1, 1, TO
// %for J = FROM + 1, 1, TO %cycle
{
int _initial = FROM + 1, _final = TO;
if (invalid_for_loop(_initial, 1, _final)) _imp_signal(5, 1, 0, "Illegal cycle J = FROM + 1, 1, TO");
J = _initial - (1);
L_0014:
if (J == _final) goto L_0015;
J += 1;
// 313 B == PATCH(J)
B = (struct PFM *)/*?*/ &PATCH[J - 1];
// 314 %IF A_WHERE > B_WHERE %START
if (A->WHERE <= B->WHERE) goto L_0017;
// 315 T = A_WHERE; A_WHERE = B_WHERE; B_WHERE = T
T = A->WHERE;
A->WHERE = B->WHERE;
B->WHERE = T;
// 316 T = B_WHAT; B_WHAT = A_WHAT; A_WHAT = T
T = B->WHAT;
B->WHAT = A->WHAT;
A->WHAT = T;
// 317 FLAG = 1
FLAG = 1;
// 318 %ELSE %IF A_WHERE = B_WHERE
goto L_0018;
L_0017:;
if (A->WHERE != B->WHERE) goto L_0019;
// 319 FLAG = 1
FLAG = 1;
// 320 A_WHERE = -10
A->WHERE = -10;
// 321 %FINISH
L_0019:;
L_0018:;
// 322 A == B
A = (struct PFM *)B;
// 323 %REPEAT
goto L_0014;
}
L_0015:;
// 324 %EXIT %IF FLAG = 0
if (FLAG != 0) goto L_001A;
goto L_0013;
L_001A:;
// 325 TO = TO-1
TO = TO - 1;
// 326 %REPEAT
goto L_0012;
L_0013:;
// 327 %END
return;
} /* end of SORT */
// 328 %ROUTINE NEXT CODE
void NEXTCODE(void) {
// 329 %OWNINTEGER P = 1, J = 1
static int P = 1;
static int J = 1;
// 330 %INTEGER C, BV
int C;
int BV;
// 331 %RECORD(PFM)%NAME PP
struct PFM *PP;
// 332 C = NEVER; BV = NEVER; MODE = NEVER
C = 32767;
BV = 32767;
MODE = 32767;
// 333 %IF P <= CP %START;! CODE PATCHES LEFT
if (P > CP) goto L_001B;
// 334 %CYCLE
L_001C:;
// 335 PP == PATCH(P)
PP = (struct PFM *)/*?*/ &PATCH[P - 1];
// 336 %EXIT %IF PP_WHERE # -10
if (PP->WHERE == -10) goto L_001D;
goto L_001E;
L_001D:;
// 337 P = P+1
P = P + 1;
// 338 %REPEAT
goto L_001C;
L_001E:;
// 339 C = PP_WHERE>>1
C = (unsigned int)PP->WHERE >> 1;
// 340 %FINISH
L_001B:;
// 341 %IF J < REFS %START;! JUMPS LEFT
if (J >= REFS) goto L_001F;
// 342 B == JUMP(J)
B = (struct LFM *)/*?*/ &JUMP[J - 1];
// 343 BV = B_CA>>1
BV = (unsigned int)B->CA >> 1;
// 344 %FINISH
L_001F:;
// 345 CADDR = NEVER
CADDR = 32767;
// 346 %RETURN %IF BV = NEVER = C
{
// Double-sided test on 32767 (Part I)
int tmp;
if (BV != (tmp = 32767)) goto L_0020;
// Double-sided test on 32767 (Part II)
if (tmp != C) goto L_0020;
}
return;
L_0020:;
// 347 %IF BV > C %START
if (BV <= C) goto L_0021;
// 348 P = P+1
P = P + 1;
// 349 CADDR = PP_WHERE; CVAL = PP_WHAT
CADDR = PP->WHERE;
CVAL = PP->WHAT;
// 350 %RETURN
return;
// 351 %FINISH
L_0021:;
// 352 %IF C > BV %START
if (C <= BV) goto L_0022;
// 353 J = J+1
J = J + 1;
// 354 MODE = 0; CADDR = B_CA
MODE = 0;
CADDR = B->CA;
// 355 %RETURN
return;
// 356 %FINISH
L_0022:;
// 357 MONITOR(1)
MONITOR(1);
// 358 %END
return;
} /* end of NEXTCODE */
// 359 %ROUTINE NEXT GLA
void NEXTGLA(void) {
// 360 GADDR = NEVER %AND %RETURN %IF GP > MAX PATCH
if (GP <= 450) goto L_0023;
GADDR = 32767;
return;
L_0023:;
// 361 PAT == PATCH(GP) %AND GP = GP+1 %UNTIL PAT_WHERE >= 0
L_0024:;
PAT = (struct PFM *)/*?*/ &PATCH[GP - 1];
GP = GP + 1;
if (PAT->WHERE >= 0) goto L_0025;
goto L_0024;
L_0025:;
// 362 GADDR = PAT_WHERE; GVAL = PAT_WHAT
GADDR = PAT->WHERE;
GVAL = PAT->WHAT;
// 363 %END
return;
} /* end of NEXTGLA */
// 364 %ROUTINE SET PERM(%INTEGER N)
void SETPERM(int N) {
// 365 %INTEGER J,K
int J;
int K;
// 366 %RETURN %UNLESS PEP(N) = 1
if (PEP[N - 1] == 1) goto L_0026;
return;
L_0026:;
// 367 PEP(N) = 2
PEP[N - 1] = 2;
// 368 K = PERMS(N)
K = PERMS[N - 1];
// 369 %IF K = 0 %START
if (K != 0) goto L_0027;
// 370 SELECTOUTPUT(REPORT)
_imp_SELECTOUTPUT(0);
// 371 PRINTSTRING("NO ENTRY FOR PERM"); WRITE(N, 1); NEWLINE
_imp_PRINTSTRING(_imp_str_literal("NO ENTRY FOR PERM"));
_imp_WRITE(N, 1);
_imp_NEWLINE();
// 372 PEP(N) = 0
PEP[N - 1] = 0;
// 373 SELECTOUTPUT(OBJECT)
_imp_SELECTOUTPUT(2);
// 374 %RETURN
return;
// 375 %FINISH
L_0027:;
// 376 %CYCLE J = 1, 1, PERMS(K)
// %for J = 1, 1, PERMS[K - 1] %cycle
{
int _final = PERMS[K - 1];
if (invalid_for_loop(1, 1, _final)) _imp_signal(5, 1, 0, "Illegal cycle J = 1, 1, PERMS[K - 1]");
J = 0;
L_0028:
if (J == _final) goto L_0029;
J += 1;
// 377 K = K+1
K = K + 1;
// 378 %IF PERMS(K) = EMARK %START
if (PERMS[K - 1] != 34952) goto L_002A;
// 379 N = PERMS(K+1)
N = PERMS[K + 1 - 1];
// 380 %IF PEP(N) # 2 %START
if (PEP[N - 1] == 2) goto L_002B;
// 381 PEP(N) = 1; SET PERM(N)
PEP[N - 1] = 1;
SETPERM(N);
// 382 %FINISH
L_002B:;
// 383 %FINISH
L_002A:;
// 384 %REPEAT
goto L_0028;
}
L_0029:;
// 385 %END
return;
} /* end of SETPERM */
// 386
// 387 %ROUTINE PLANT LONG JUMP
void PLANTLONGJUMP(void) {
// 388 %INTEGER N
int N;
// 389 ! PLANT A BRANCH OR BAL INSTRUCTION WHICH IS ASSUMED TO BE DESCRIBED
// 390 ! BY 'L'(OP CODE + BASE REG), 'TAG'(DESTINATION ADDRESS),
// 391 ! 'B'(NAME OF RECORD CONTAINING FLAG BITS) AND 'CA'(CURRENT CODE
// 392 ! ADDRESS).
// 393 %IF B_LAB&VERY = 0 %START; ! ...CAN USE A 32 BIT FORM
if (B->LAB & 524288 != 0) goto L_002C;
// 394 N = TAG-(CA+4)
N = TAG - (CA + 4);
// 395 %IF -16*1024 <= N < 16*1024 %START; ! USE PC RELATIVE
{
// Double-sided test on N (Part I)
int tmp;
if (-(16 * 1024) > (tmp = N)) goto L_002D;
// Double-sided test on N (Part II)
if (tmp >= 16 * 1024) goto L_002D;
}
// 396 L = L&X'FFF0'; ! STRIP OFF BASE REGISTER
L = L & 65520;
// 397 CPUT(L); CPUT(N!X'8000' )
CPUT(L);
CPUT(N | 32768);
// 398 RX2 = RX2+1
RX2 = RX2 + 1;
// 399 %ELSE; !USE BASE+DISP
goto L_002E;
L_002D:;
// 400 CPUT(L); CPUT(TAG)
CPUT(L);
CPUT(TAG);
// 401 RX1 = RX1+1
RX1 = RX1 + 1;
// 402 %FINISH
L_002E:;
// 403 %ELSE; ! ...48 BIT ADDRESS REQ'D
goto L_002F;
L_002C:;
// 404 CPUT(L)
CPUT(L);
// 405 CPUT((TAG>>16&X'FF')+X'4000')
CPUT(((unsigned int)TAG >> 16 & 255) + 16384);
// 406 CPUT(TAG); ! ...N.B. 'CPUT' ONLY PUTS 16 BITS
CPUT(TAG);
// 407 RX3 = RX3+1
RX3 = RX3 + 1;
// 408 %FINISH
L_002F:;
// 409 %END
return;
} /* end of PLANTLONGJUMP */
// 410
// 411
// 412
// 413 !
// 414 ! PHASE 1 - INPUT PROGRAM & GENERATE JUMP TABLES + PATCH TABLES
// 415 !
// 416 PHASE = 1
PHASE = 1;
// 417 PEP(J) = 0 %AND PADDR(J) = 0 %FOR J = 1, 1, MAX PERM
// %for J = 1, 1, 54 %cycle
{
J = 0;
L_0030:
if (J == 54) goto L_0031;
J += 1;
PEP[J - 1] = 0;
PADDR[J - 1] = 0;
goto L_0030;
}
L_0031:;
// 418 CP = 0; GP = MAX PATCH+1
CP = 0;
GP = 450 + 1;
// 419 REFS = 0; DEFMOD = 0; UCA = 0; CCA = 0; CTAG = 0
REFS = 0;
DEFMOD = 0;
UCA = 0;
CCA = 0;
CTAG = 0;
// 420 LAB(J) = 0 %FOR J = 1,1,MAX LABELS
// %for J = 1, 1, 2000 %cycle
{
J = 0;
L_0032:
if (J == 2000) goto L_0033;
J += 1;
LAB[J] = 0;
goto L_0032;
}
L_0033:;
// 421 SELECTINPUT(DIRECT)
_imp_SELECTINPUT(3);
// 422 READ SYMBOL(INIT GLA); ! MINIMUM POSSIBLE SIZE OF GLA - FROM PASS 2
_imp_READSYMBOL(/*?*/ &INITGLA);
// 423 %CYCLE
L_0034:;
// 424 READSYMBOL(CODE); ->D(CODE)
_imp_READSYMBOL(/*?*/ &CODE);
D_line = __LINE__;
D_file = __FILE__;
D_index = CODE;
goto case_D_dispatch;
// 425 D(1):! TAG DEF <REF>, <CA>
case_D_1:;
// 426 GET(TAG); GET(CA)
GET(/*?*/ &TAG);
GET(/*?*/ &CA);
// 427 MONITOR(2) %IF TAG > MAX LABELS
if (TAG <= 2000) goto L_0036;
MONITOR(2);
L_0036:;
// 428 MAX LABEL = TAG %IF TAG > MAX LABEL
if (TAG <= MAXLABEL) goto L_0037;
MAXLABEL = TAG;
L_0037:;
// 429 %IF TAG = CTAG %AND CCA = CA %AND UCA = CA %START
if (TAG != CTAG) goto L_0038;
if (CCA != CA) goto L_0038;
if (UCA != CA) goto L_0038;
// 430 DEFMOD = DEFMOD+2
DEFMOD = DEFMOD + 2;
// 431 UREF_LAB = UREF_LAB!PERM!COND
UREF->LAB = UREF->LAB | 2097152 | 4194304;
// 432 CREF_LAB = CREF_LAB!VERY!RT
CREF->LAB = CREF->LAB | 524288 | 1048576;
// 433 CTAG = UREF_LAB&LABEL
CTAG = UREF->LAB & 65535;
// 434 CREF == UREF
CREF = (struct LFM *)UREF;
// 435 CCA = CA+2
CCA = CA + 2;
// 436 %ELSE
goto L_0039;
L_0038:;
// 437 CTAG = 0
CTAG = 0;
// 438 %FINISH
L_0039:;
// 439 LAB(TAG) = CA
LAB[TAG] = CA;
// 440 %CONTINUE
goto L_0003;
// 441 D(2):! CREF <REF>, <CA>
case_D_2:;
// 442 FLAG = COND; ->CURP
FLAG = 4194304;
goto U_1000;
// 443 D(3):! UREF <REF>, <CA>
case_D_3:;
// 444 FLAG = 0; ->CURP
FLAG = 0;
goto U_1000;
// 445 D(4):! RREF <REF>, <CA>
case_D_4:;
// 446 FLAG = RT+LONG
FLAG = 1048576 + 8388608;
// 447 RTNCALLS = RTNCALLS+1
RTNCALLS = RTNCALLS + 1;
// 448 -> CURP
goto U_1000;
// 449
// 450 D(5):! PREF <REF>, <CA>
case_D_5:;
// 451 FLAG = PERM+LONG
FLAG = 2097152 + 8388608;
// 452 PERMCALLS = PERMCALLS+1
PERMCALLS = PERMCALLS + 1;
// 453
// 454 CURP: GET(TAG); GET(CA)
U_1000:;
GET(/*?*/ &TAG);
GET(/*?*/ &CA);
// 455 REFS = REFS+1; R == JUMP(REFS)
REFS = REFS + 1;
R = (struct LFM *)/*?*/ &JUMP[REFS - 1];
// 456 MONITOR(1) %IF REFS > MAX JUMPS
if (REFS <= 3000) goto L_003A;
MONITOR(1);
L_003A:;
// 457 R_LAB = TAG+FLAG
R->LAB = TAG + FLAG;
// 458 R_CA = CA
R->CA = CA;
// 459 %IF FLAG = 0 %START; ! UNCONDITIONAL
if (FLAG != 0) goto L_003B;
// 460 UCA = CA+2; UREF == R
UCA = CA + 2;
UREF = (struct LFM *)R;
// 461 %ELSE %IF FLAG = COND; ! CONDITIONAL
goto L_003C;
L_003B:;
if (FLAG != 4194304) goto L_003D;
// 462 CCA = CA+4; CTAG = TAG; CREF == R
CCA = CA + 4;
CTAG = TAG;
CREF = (struct LFM *)R;
// 463 %FINISH
L_003D:;
L_003C:;
// 464 %IF FLAG&PERM # 0 %START
if (FLAG & 2097152 == 0) goto L_003E;
// 465 %IF TAG > MAX PERM %OR PERMS(TAG) = 0 %START
if (TAG > 54) goto L_003F;
if (PERMS[TAG - 1] != 0) goto L_0040;
L_003F:;
// 466 SELECTOUTPUT(REPORT)
_imp_SELECTOUTPUT(0);
// 467 PRINTSTRING("NO PERM"); WRITE(TAG, 1); NEWLINE
_imp_PRINTSTRING(_imp_str_literal("NO PERM"));
_imp_WRITE(TAG, 1);
_imp_NEWLINE();
// 468 SELECTOUTPUT(OBJECT)
_imp_SELECTOUTPUT(2);
// 469 %ELSE
goto L_0041;
L_0040:;
// 470 PEP(TAG) = 1
PEP[TAG - 1] = 1;
// 471 %FINISH
L_0041:;
// 472 %FINISH
L_003E:;
// 473 %CONTINUE
goto L_0003;
// 474 D(6):! GPATCH <WHAT>, <WHERE>
case_D_6:;
// 475 GP = GP-1; PAT == PATCH(GP); ->PWW
GP = GP - 1;
PAT = (struct PFM *)/*?*/ &PATCH[GP - 1];
goto U_1001;
// 476 D(7):! CPATCH <WHAT>, <WHERE>
case_D_7:;
// 477 CP = CP+1; PAT == PATCH(CP)
CP = CP + 1;
PAT = (struct PFM *)/*?*/ &PATCH[CP - 1];
// 478 PWW: GET(TAG); GET(CA)
U_1001:;
GET(/*?*/ &TAG);
GET(/*?*/ &CA);
// 479 PAT_WHAT = TAG; PAT_WHERE = CA
PAT->WHAT = TAG;
PAT->WHERE = CA;
// 480 MONITOR(4) %IF CP = GP
if (CP != GP) goto L_0042;
MONITOR(4);
L_0042:;
// 481 %REPEAT
L_0003:;
goto L_0034;
// 482 D(8):! END MARKER
case_D_8:;
// 483 GET(CODE SIZE); GET(GLA SIZE); GET(LINE SIZE); GET(DIAG SIZE)
GET(/*?*/ &CODESIZE);
GET(/*?*/ &GLASIZE);
GET(/*?*/ &LINESIZE);
GET(/*?*/ &DIAGSIZE);
// 484 CODE SIZE = CODE SIZE-DEF MOD
CODESIZE = CODESIZE - DEFMOD;
// 485 REFS = REFS+1; JUMP(REFS) = 0
REFS = REFS + 1;
JUMP[REFS - 1] = (struct LFM){0};
// 486 %IF DEF MOD # 0 %START
if (DEFMOD == 0) goto L_0043;
// 487 REF EXTRA = 0
REFEXTRA = 0;
// 488 %CYCLE L = 1, 1, REFS-1
// %for L = 1, 1, REFS - 1 %cycle
{
int _final = REFS - 1;
if (invalid_for_loop(1, 1, _final)) _imp_signal(5, 1, 0, "Illegal cycle L = 1, 1, REFS - 1");
L = 0;
L_0044:
if (L == _final) goto L_0045;
L += 1;
// 489 R == JUMP (L)
R = (struct LFM *)/*?*/ &JUMP[L - 1];
// 490 R_CA = R_CA-REF EXTRA
R->CA = R->CA - REFEXTRA;
// 491 %IF R_LAB&COND # 0 %AND R_LAB&RT # 0 %START
if (R->LAB & 4194304 == 0) goto L_0046;
if (R->LAB & 1048576 == 0) goto L_0046;
// 492 REF EXTRA = REF EXTRA+2
REFEXTRA = REFEXTRA + 2;
// 493 %CYCLE K = 1, 1, CP
// %for K = 1, 1, CP %cycle
{
int _final = CP;
if (invalid_for_loop(1, 1, _final)) _imp_signal(5, 1, 0, "Illegal cycle K = 1, 1, CP");
K = 0;
L_0047:
if (K == _final) goto L_0048;
K += 1;
// 494 PAT == PATCH(K)
PAT = (struct PFM *)/*?*/ &PATCH[K - 1];
// 495 PAT_WHERE = PAT_WHERE-2 %IF PAT_WHERE > R_CA
if (PAT->WHERE <= R->CA) goto L_004A;
PAT->WHERE = PAT->WHERE - 2;
L_004A:;
// 496 %REPEAT
goto L_0047;
}
L_0048:;
// 497 %IF GP <= MAX PATCH %START
if (GP > 450) goto L_004B;
// 498 %CYCLE K = GP, 1, MAX PATCH
// %for K = GP, 1, 450 %cycle
{
int _initial = GP;
if (invalid_for_loop(_initial, 1, 450)) _imp_signal(5, 1, 0, "Illegal cycle K = GP, 1, 450");
K = _initial - (1);
L_004C:
if (K == 450) goto L_004D;
K += 1;
// 499 PAT == PATCH(K)
PAT = (struct PFM *)/*?*/ &PATCH[K - 1];
// 500 PAT_WHAT = PAT_WHAT-2 %IF PAT_WHAT > R_CA
if (PAT->WHAT <= R->CA) goto L_004F;
PAT->WHAT = PAT->WHAT - 2;
L_004F:;
// 501 PAT_WHERE = PAT_WHERE-2 %IF PAT_WHERE&1 # 0 %AND %C
if (PAT->WHERE & 1 == 0) goto L_0050;
if (PAT->WHERE <= R->CA) goto L_0050;
PAT->WHERE = PAT->WHERE - 2;
L_0050:;
// 502+ PAT_WHERE > R_CA
// 503 %REPEAT
goto L_004C;
}
L_004D:;
// 504 %FINISH
L_004B:;
// 505 %CYCLE K = 1, 1, MAX LABEL
// %for K = 1, 1, MAXLABEL %cycle
{
int _final = MAXLABEL;
if (invalid_for_loop(1, 1, _final)) _imp_signal(5, 1, 0, "Illegal cycle K = 1, 1, MAXLABEL");
K = 0;
L_0051:
if (K == _final) goto L_0052;
K += 1;
// 506 LAB(K) = LAB(K)-2 %IF LAB(K) > R_CA
if (LAB[K] <= R->CA) goto L_0053;
LAB[K] = LAB[K] - 2;
L_0053:;
// 507 %REPEAT
goto L_0051;
}
L_0052:;
// 508 DEFMOD = DEFMOD-2
DEFMOD = DEFMOD - 2;
// 509 %FINISH
L_0046:;
// 510 %REPEAT
goto L_0044;
}
L_0045:;
// 511 MONITOR(5) %IF DEFMOD # 0
if (DEFMOD == 0) goto L_0054;
MONITOR(5);
L_0054:;
// 512 %FINISH
L_0043:;
// 513
// 514
// 515 ! IDENTIFY THOSE PERM ROUTINES WHICH ARE REQUIRED.
// 516 PERM SIZE = 0
PERMSIZE = 0;
// 517 SET PERM(J) %FOR J = 1,1,MAX PERM
// %for J = 1, 1, 54 %cycle
{
J = 0;
L_0055:
if (J == 54) goto L_0056;
J += 1;
SETPERM(J);
goto L_0055;
}
L_0056:;
// 518 %CYCLE J = 1,1,MAX PERM
// %for J = 1, 1, 54 %cycle
{
J = 0;
L_0058:
if (J == 54) goto L_0059;
J += 1;
// 519 %IF PEP(J) # 0 %START
if (PEP[J - 1] == 0) goto L_005A;
// 520 PADDR(J) = CODE SIZE
PADDR[J - 1] = CODESIZE;
// 521 L = PERMS(PERMS(J))*2
L = PERMS[PERMS[J - 1] - 1] * 2;
// 522 CODE SIZE = CODE SIZE + L
CODESIZE = CODESIZE + L;
// 523 PERM SIZE = PERM SIZE + L
PERMSIZE = PERMSIZE + L;
// 524 %FINISH
L_005A:;
// 525 %REPEAT
goto L_0058;
}
L_0059:;
// 526
// 527
// 528 ! PHASE 2 - IDENTIFY LONG JUMPS
// 529 !
// 530 PHASE = 2
PHASE = 2;
// 531 %IF REFS > 1 %START
if (REFS <= 1) goto L_005B;
// 532 %CYCLE
L_005C:;
// 533 FLAG = 0; REF EXTRA = 0
FLAG = 0;
REFEXTRA = 0;
// 534 %CYCLE L = 1, 1, REFS-1
// %for L = 1, 1, REFS - 1 %cycle
{
int _final = REFS - 1;
if (invalid_for_loop(1, 1, _final)) _imp_signal(5, 1, 0, "Illegal cycle L = 1, 1, REFS - 1");
L = 0;
L_005D:
if (L == _final) goto L_005E;
L += 1;
// 535 R == JUMP(L);! JUMP REFERENCE
R = (struct LFM *)/*?*/ &JUMP[L - 1];
// 536 R_CA = R_CA+REF EXTRA
R->CA = R->CA + REFEXTRA;
// 537 %CONTINUE %IF R_LAB&VERY # 0;! ALREADY VERY LONG
if (R->LAB & 524288 == 0) goto L_0060;
goto L_005F;
L_0060:;
// 538 EXTRA = 0
EXTRA = 0;
// 539 J = R_LAB&LABEL
J = R->LAB & 65535;
// 540 %IF R_LAB&PERM = 0 %OR R_LAB&COND # 0 %C
if (R->LAB & 2097152 == 0) goto L_0049;
if (R->LAB & 4194304 == 0) goto L_0061;
L_0049:;
K = LAB[J];
goto L_0062;
L_0061:;
K = PADDR[J - 1];
L_0062:;
// 541+ %THEN K = LAB(J) %ELSE K = PADDR(J)
// 542 %UNLESS -30 <= K-R_CA <= 30 %START; ! ...CAN'T BE SHORT
{
// Double-sided test on K - R->CA (Part I)
int tmp;
if (-30 > (tmp = K - R->CA)) goto L_0063;
// Double-sided test on K - R->CA (Part II)
if (tmp <= 30) goto L_0064;
}
L_0063:;
// 543 %IF R_LAB&LONG=0 %START; ! ...BUT IT IS...
if (R->LAB & 8388608 != 0) goto L_0065;
// 544 %IF K < 16*1024 %OR -16*1024<=K-(R_CA+4)<16*1024 %START
if (K < 16 * 1024) goto L_0066;
{
// Double-sided test on K - (R->CA + 4) (Part I)
int tmp;
if (-(16 * 1024) > (tmp = K - (R->CA + 4))) goto L_0067;
// Double-sided test on K - (R->CA + 4) (Part II)
if (tmp >= 16 * 1024) goto L_0067;
}
L_0066:;
// 545 ! 32 BIT FORM: BASE+DISPLACEMENT OR PC RELATIVE
// 546 EXTRA = 2; R_LAB = R_LAB!LONG; ! SHORT -> LONG
EXTRA = 2;
R->LAB = R->LAB | 8388608;
// 547 %ELSE
goto L_0068;
L_0067:;
// 548 ! 48 BIT FORM REQ'D: BASE+DISP
// 549 EXTRA = 4; R_LAB = R_LAB!VERY; ! SHORT -> VERY
EXTRA = 4;
R->LAB = R->LAB | 524288;
// 550 %FINISH
L_0068:;
// 551 %ELSE
goto L_0069;
L_0065:;
// 552 %UNLESS K<16*1024 %OR -16*1024<=K-(R_CA+4)<16*1024 %START
if (K < 16 * 1024) goto L_006A;
{
// Double-sided test on K - (R->CA + 4) (Part I)
int tmp;
if (-(16 * 1024) > (tmp = K - (R->CA + 4))) goto L_006B;
// Double-sided test on K - (R->CA + 4) (Part II)
if (tmp < 16 * 1024) goto L_006A;
}
L_006B:;
// 553 EXTRA = 2; R_LAB = R_LAB!!(LONG!VERY); ! LONG -> VERY
EXTRA = 2;
R->LAB = R->LAB ^ (8388608 | 524288);
// 554 %FINISH
L_006A:;
// 555 %FINISH
L_0069:;
// 556 %CONTINUE %IF EXTRA = 0; ! ...NO CHANGES REQ'D
if (EXTRA != 0) goto L_006C;
goto L_005F;
L_006C:;
// 557 FLAG = 1
FLAG = 1;
// 558 ! ADJUST PATCHES
// 559 %IF CP > 0 %START
if (CP <= 0) goto L_006D;
// 560 %CYCLE K = 1, 1, CP
// %for K = 1, 1, CP %cycle
{
int _final = CP;
if (invalid_for_loop(1, 1, _final)) _imp_signal(5, 1, 0, "Illegal cycle K = 1, 1, CP");
K = 0;
L_006E:
if (K == _final) goto L_006F;
K += 1;
// 561 PAT == PATCH(K)
PAT = (struct PFM *)/*?*/ &PATCH[K - 1];
// 562 PAT_WHERE = PAT_WHERE+EXTRA %IF PAT_WHERE > R_CA
if (PAT->WHERE <= R->CA) goto L_0071;
PAT->WHERE = PAT->WHERE + EXTRA;
L_0071:;
// 563 %REPEAT
goto L_006E;
}
L_006F:;
// 564 %FINISH
L_006D:;
// 565 %IF GP <= MAX PATCH %START
if (GP > 450) goto L_0072;
// 566 %CYCLE K = GP, 1, MAX PATCH
// %for K = GP, 1, 450 %cycle
{
int _initial = GP;
if (invalid_for_loop(_initial, 1, 450)) _imp_signal(5, 1, 0, "Illegal cycle K = GP, 1, 450");
K = _initial - (1);
L_0073:
if (K == 450) goto L_0074;
K += 1;
// 567 PAT == PATCH(K)
PAT = (struct PFM *)/*?*/ &PATCH[K - 1];
// 568 PAT_WHAT = PAT_WHAT+EXTRA %IF PAT_WHAT > R_CA
if (PAT->WHAT <= R->CA) goto L_0075;
PAT->WHAT = PAT->WHAT + EXTRA;
L_0075:;
// 569 %REPEAT
goto L_0073;
}
L_0074:;
// 570 %FINISH
L_0072:;
// 571 ! ADJUST REMAINING REFS
// 572 %CYCLE K = 1, 1, MAX LABEL
// %for K = 1, 1, MAXLABEL %cycle
{
int _final = MAXLABEL;
if (invalid_for_loop(1, 1, _final)) _imp_signal(5, 1, 0, "Illegal cycle K = 1, 1, MAXLABEL");
K = 0;
L_0076:
if (K == _final) goto L_0077;
K += 1;
// 573 V == LAB(K)
V = (int *)/*?*/ &LAB[K];
// 574 V = V+EXTRA %IF V > R_CA
if (*V <= R->CA) goto L_0078;
*V = *V + EXTRA;
L_0078:;
// 575 %REPEAT
goto L_0076;
}
L_0077:;
// 576 %CYCLE K = 1, 1, MAX PERM
// %for K = 1, 1, 54 %cycle
{
K = 0;
L_0079:
if (K == 54) goto L_007A;
K += 1;
// 577 PADDR(K) = PADDR(K)+EXTRA %IF PADDR(K) # 0
if (PADDR[K - 1] == 0) goto L_007B;
PADDR[K - 1] = PADDR[K - 1] + EXTRA;
L_007B:;
// 578 %REPEAT
goto L_0079;
}
L_007A:;
// 579 REF EXTRA = REF EXTRA+EXTRA
REFEXTRA = REFEXTRA + EXTRA;
// 580 CODE SIZE = CODE SIZE+EXTRA
CODESIZE = CODESIZE + EXTRA;
// 581 %FINISH
L_0064:;
// 582 %REPEAT
L_005F:;
goto L_005D;
}
L_005E:;
// 583 %REPEAT %until flag = 0
if (FLAG == 0) goto L_007C;
goto L_005C;
L_007C:;
// 584 %FINISH
L_005B:;
// 585 !
// 586 ! PHASE 3 - GENERATE OBJECT FILE
// 587 !
// 588 PHASE = 3
PHASE = 3;
// 589 J = MAX PATCH+1; K = J
J = 450 + 1;
K = J;
// 590 %WHILE J > GP %CYCLE
L_007D:;
if (J <= GP) goto L_007E;
// 591 J = J-1
J = J - 1;
// 592 PAT == PATCH(J)
PAT = (struct PFM *)/*?*/ &PATCH[J - 1];
// 593 %IF PAT_WHERE&1 # 0 %START
if (PAT->WHERE & 1 == 0) goto L_007F;
// 594 PAT_WHERE = PAT_WHERE&(\1)
PAT->WHERE = PAT->WHERE & (~1);
// 595 CP = CP+1; PATCH(CP) = PAT
CP = CP + 1;
PATCH[CP - 1] = *PAT;
// 596 %ELSE
goto L_0080;
L_007F:;
// 597 K = K-1; PATCH(K) = PAT
K = K - 1;
PATCH[K - 1] = *PAT;
// 598 %FINISH
L_0080:;
// 599 %REPEAT
goto L_007D;
L_007E:;
// 600 GP = K
GP = K;
// 601 SORT(1, CP)
SORT(1, CP);
// 602 SORT(GP, MAX PATCH)
SORT(GP, 450);
// 603 !
// 604 !
// 605 SELECT OUTPUT(OBJECT); PUT HALF(X'8282')
_imp_SELECTOUTPUT(2);
PUTHALF(33410);
// 606 !
// 607 ! OUTPUT A CONTROL BLOCK GIVING CODE AND GLA SEGMENT SIZES(IN
// 608 ! HALF-WORDS). OTHER PARAMETERS MAY BE ADDED AS REQ'D.
// 609 ! USES 'GBUFF' AS WORKSPACE.
// 610 GBUFF(1) = (CODE SIZE + 1)>>1
GBUFF[0] = (unsigned int)CODESIZE + 1 >> 1;
// 611 GBUFF(2) = (GLA SIZE + 1)>>1
GBUFF[1] = (unsigned int)GLASIZE + 1 >> 1;
// 612 GBUFF(3) = (DIAG SIZE+16)>>1; ! ... +16 FOR EXTRA WORD AS TERMINATOR
GBUFF[2] = (unsigned int)DIAGSIZE + 16 >> 1;
// 613 GBUFF(4) = (LINE SIZE+16)>>1
GBUFF[3] = (unsigned int)LINESIZE + 16 >> 1;
// 614 ! -------REQUIRES LOADER DATA SIZE-----------
// 615 PUT BLOCK((4<<4)!SEGMENT SIZE BLOCK,GBUFF)
PUTBLOCK(4 << 4 | 15, GBUFF);
// 616 !
// 617 SELECT INPUT(PSEUDO OBJ)
_imp_SELECTINPUT(2);
// 618 CA = 0; GA = INITGLA; LA = 0; DA = 0
CA = 0;
GA = INITGLA;
LA = 0;
DA = 0;
// 619 CURRENT LINE = 0; CBP = 1; CFLUSH
CURRENTLINE = 0;
CBP = 1;
CFLUSH();
// 620 GBP = INIT GLA>>1; LBP = 0; DBP = 0; TBP = 0
GBP = (unsigned int)INITGLA >> 1;
LBP = 0;
DBP = 0;
TBP = 0;
// 621 NEXT CODE; NEXT GLA
NEXTCODE();
NEXTGLA();
// 622
// 623 READSYMBOL(CODE);! = 1
_imp_READSYMBOL(/*?*/ &CODE);
// 624 IGNORE = 0; LAST = 0
IGNORE = 0;
LAST = 0;
// 625 %CYCLE
L_0081:;
// 626 READ SYMBOL(CODE); -> C(CODE+IGNORE)
_imp_READSYMBOL(/*?*/ &CODE);
C_line = __LINE__;
C_file = __FILE__;
C_index = CODE + IGNORE;
goto case_C_dispatch;
// 627 C(2):! CODE <VAL>
case_C_2:;
// 628 GET(L)
GET(/*?*/ &L);
// 629 %IF CA = CADDR %START
if (CA != CADDR) goto L_0083;
// 630 %IF MODE # 0 %START;! CODE PATCH
if (MODE == 0) goto L_0084;
// 631 CPUT(CVAL)
CPUT(CVAL);
// 632 %ELSE;! JUMP+PERM+RT
goto L_0085;
L_0084:;
// 633 TAG = LAB(B_LAB&LABEL)
TAG = LAB[B->LAB & 65535];
// 634 %IF B_LAB&(PERM!RT) = 0 %OR B_LAB&COND # 0 %START;! JUMP
if (B->LAB & (2097152 | 1048576) == 0) goto L_0086;
if (B->LAB & 4194304 == 0) goto L_0087;
L_0086:;
// 635 %IF B_LAB&(PERM!RT) # 0 %START
if (B->LAB & (2097152 | 1048576) == 0) goto L_0088;
// 636 %IF B_LAB&RT # 0 %START
if (B->LAB & 1048576 == 0) goto L_0089;
// 637 LAST = L %IF LAST = 0
if (LAST != 0) goto L_008A;
LAST = L;
L_008A:;
// 638 LAST = NOT(LAST&15)!X'8000'
LAST = NOT[LAST & 15] | 32768;
// 639 NEXT CODE
NEXTCODE();
// 640 %CONTINUE
goto L_0057;
// 641 %FINISH
L_0089:;
// 642 L = LAST; LAST = 0
L = LAST;
LAST = 0;
// 643 %FINISH
L_0088:;
// 644 L = L&15
L = L & 15;
// 645 %IF B_LAB&(LONG!VERY) = 0 %START;! LEAVE IT SHORT
if (B->LAB & (8388608 | 524288) != 0) goto L_008B;
// 646 J = (TAG-CA)//2
J = ((long)(TAG - CA) / (long)2);
// 647 MONITOR(5) %UNLESS -15 <= J <= 15
{
// Double-sided test on J (Part I)
int tmp;
if (-15 > (tmp = J)) goto L_0070;
// Double-sided test on J (Part II)
if (tmp <= 15) goto L_008C;
}
L_0070:;
MONITOR(5);
L_008C:;
// 648 %IF J < 0 %THEN CPUT(SB(L)-J) %C
if (J >= 0) goto L_008D;
CPUT(SB[L] - J);
goto L_008E;
L_008D:;
CPUT(SF[L] + J);
L_008E:;
// 649+ %ELSE CPUT(SF(L)+J)
// 650 SJ = SJ+1
SJ = SJ + 1;
// 651 %ELSE; ! MAKE IT LONG
goto L_008F;
L_008B:;
// 652 L = LJ(L); PLANT LONG JUMP
L = LJ[L];
PLANTLONGJUMP();
// 653 %FINISH
L_008F:;
// 654 %ELSE;! PERM OR ROUTINE
goto L_0090;
L_0087:;
// 655 DIAG LINE
DIAGLINE();
// 656 IGNORE = 5
IGNORE = 5;
// 657 TAG = PADDR(B_LAB&LABEL) %IF B_LAB&PERM # 0
if (B->LAB & 2097152 == 0) goto L_0091;
TAG = PADDR[(B->LAB & 65535) - 1];
L_0091:;
// 658 PLANT LONG JUMP
PLANTLONGJUMP();
// 659 %FINISH
L_0090:;
// 660 %FINISH
L_0085:;
// 661 NEXT CODE
NEXTCODE();
// 662 %FINISH %ELSE CPUT(L)
goto L_0092;
L_0083:;
CPUT(L);
L_0092:;
// 663 %CONTINUE
goto L_0057;
// 664 C(11):GET(J)
case_C_11:;
GET(/*?*/ &J);
// 665 %IF J = X'FFFF' %START
if (J != 65535) goto L_0093;
// 666 GET(J)
GET(/*?*/ &J);
// 667 TPUT(X'4000'); TPUT(CA)
TPUT(16384);
TPUT(CA);
// 668 %CONTINUE
goto L_0057;
// 669 %FINISH
L_0093:;
// 670 TPUT(J)
TPUT(J);
// 671 GET(K)
GET(/*?*/ &K);
// 672 K = CA %IF J&X'8000' # 0
if (J & 32768 == 0) goto L_0094;
K = CA;
L_0094:;
// 673 TPUT(K)
TPUT(K);
// 674 GET(K); TPUT(K)
GET(/*?*/ &K);
TPUT(K);
// 675 GET(K); TPUT(K)
GET(/*?*/ &K);
TPUT(K);
// 676 GET(K); TPUT(K)
GET(/*?*/ &K);
TPUT(K);
// 677 GET(K); TPUT(K)
GET(/*?*/ &K);
TPUT(K);
// 678 %CONTINUE
goto L_0057;
// 679 C(10): DIAG LINE; %CONTINUE
case_C_10:;
DIAGLINE();
goto L_0057;
// 680 C(4):
case_C_4:;
// 681 C(9):CURRENT LINE = CURRENT LINE+1; CFLUSH
case_C_9:;
CURRENTLINE = CURRENTLINE + 1;
CFLUSH();
// 682 %CONTINUE;! LINE FLAG
goto L_0057;
// 683 C(7):IGNORE = 0; GET(L); %CONTINUE
case_C_7:;
IGNORE = 0;
GET(/*?*/ &L);
goto L_0057;
// 684 C(6):L = NL
case_C_6:;
L = 10;
// 685 J = 0
J = 0;
// 686 %CYCLE K = 1, 1, 9
// %for K = 1, 1, 9 %cycle
{
K = 0;
L_0095:
if (K == 9) goto L_0096;
K += 1;
// 687 %IF L # 0 %START
if (L == 0) goto L_0097;
// 688 READSYMBOL(L)
_imp_READSYMBOL(/*?*/ &L);
// 689 J = J+1; LTEMP(J) = L
J = J + 1;
LTEMP[J] = L;
// 690 %FINISH
L_0097:;
// 691 %REPEAT
goto L_0095;
}
L_0096:;
// 692 READSYMBOL(L) %WHILE L # 0
L_0098:;
if (L == 0) goto L_0099;
_imp_READSYMBOL(/*?*/ &L);
goto L_0098;
L_0099:;
// 693 J = J-1; LTEMP(0) = J
J = J - 1;
LTEMP[0] = J;
// 694 LSYM(LTEMP(J)) %FOR J = 0, 1, 8
// %for J = 0, 1, 8 %cycle
{
J = -1;
L_009A:
if (J == 8) goto L_009B;
J += 1;
LSYM(LTEMP[J]);
goto L_009A;
}
L_009B:;
// 695 GET(K); READSYMBOL(L)
GET(/*?*/ &K);
_imp_READSYMBOL(/*?*/ &L);
// 696 LSYM(L); LPUT(K)
LSYM(L);
LPUT(K);
// 697 %CONTINUE
goto L_0057;
// 698 C(8):
case_C_8:;
// 699 C(3):! GLA <VAL> -- SWITCH VECTOR ELEMENT
case_C_3:;
// 700 GET(L)
GET(/*?*/ &L);
// 701 %IF GA = GADDR %START
if (GA != GADDR) goto L_009C;
// 702 L = GVAL
L = GVAL;
// 703 NEXT GLA
NEXTGLA();
// 704 %FINISH
L_009C:;
// 705 GPUT(L)
GPUT(L);
// 706 %REPEAT
L_0057:;
goto L_0081;
// 707 C(5):! END
case_C_5:;
// 708 %CYCLE J = 1, 1, MAX PERM
// %for J = 1, 1, 54 %cycle
{
J = 0;
L_009D:
if (J == 54) goto L_009E;
J += 1;
// 709 %IF PEP(J) # 0 %START
if (PEP[J - 1] == 0) goto L_00A0;
// 710 K = PERMS(J); MONITOR(6) %IF K = 0
K = PERMS[J - 1];
if (K != 0) goto L_00A1;
MONITOR(6);
L_00A1:;
// 711 L = PADDR(J)
L = PADDR[J - 1];
// 712 MONITOR(7) %IF CA # L
if (CA == L) goto L_00A2;
MONITOR(7);
L_00A2:;
// 713 CFLUSH %IF CBP+PERMS(K) > CODE BUFF SIZE
if (CBP + PERMS[K - 1] <= 200) goto L_00A3;
CFLUSH();
L_00A3:;
// 714 { %CYCLE L = K+1, 1, K+PERMS(K) L is corrupted below!! }
// 715 l = k; z = k + perms(k)
L = K;
Z = K + PERMS[K - 1];
// 716 %while l # z %cycle
L_00A4:;
if (L == Z) goto L_00A5;
// 717 l = l+1
L = L + 1;
// 718 TAG = PERMS(L)
TAG = PERMS[L - 1];
// 719 %IF TAG = EMARK %START
if (TAG != 34952) goto L_00A6;
// 720 ! USE PC RELATIVE UNCONDITIONAL BRANCH FOR INTERNAL
// 721 ! LINKING BETWEEN PERM ROUTINES.
// 722 CPUT(X'4300')
CPUT(17152);
// 723 L = L+1; CPUT((PADDR(PERMS(L))-CA-2)!X'8000')
L = L + 1;
CPUT(PADDR[PERMS[L - 1] - 1] - CA - 2 | 32768);
// 724 %ELSE
goto L_00A7;
L_00A6:;
// 725 CPUT(TAG)
CPUT(TAG);
// 726 %FINISH
L_00A7:;
// 727 %REPEAT
goto L_00A4;
L_00A5:;
// 728 %FINISH
L_00A0:;
// 729 %REPEAT
goto L_009D;
}
L_009E:;
// 730 !
// 731 CLOSE OBJECT FILE
CLOSEOBJECTFILE();
// 732 !
// 733 MONITOR(9) %UNLESS CADDR = NEVER
if (CADDR == 32767) goto L_00A8;
MONITOR(9);
L_00A8:;
// 734 MONITOR(10) %UNLESS GADDR = NEVER
if (GADDR == 32767) goto L_00A9;
MONITOR(10);
L_00A9:;
// 735 SELECTOUTPUT(REPORT)
_imp_SELECTOUTPUT(0);
// 736 DA = DA+DIAG SIZE
DA = DA + DIAGSIZE;
// 737 PRINTSTRING("CODE"); WRITE(CODE SIZE-PERM SIZE, 1)
_imp_PRINTSTRING(_imp_str_literal("CODE"));
_imp_WRITE(CODESIZE - PERMSIZE, 1);
// 738 PRINTSTRING(" + GLA"); WRITE(GLA SIZE, 1)
_imp_PRINTSTRING(_imp_str_literal(" + GLA"));
_imp_WRITE(GLASIZE, 1);
// 739 PRINTSTRING(" + PERM"); WRITE(PERM SIZE, 1)
_imp_PRINTSTRING(_imp_str_literal(" + PERM"));
_imp_WRITE(PERMSIZE, 1);
// 740 PRINTSTRING(" + DIAGS"); WRITE(DA, 1)
_imp_PRINTSTRING(_imp_str_literal(" + DIAGS"));
_imp_WRITE(DA, 1);
// 741 PRINTSTRING(" =")
_imp_PRINTSTRING(_imp_str_literal(" ="));
// 742 WRITE(CODE SIZE+GLA SIZE+DA, 1)
_imp_WRITE(CODESIZE + GLASIZE + DA, 1);
// 743 PRINTSTRING(" BYTES")
_imp_PRINTSTRING(_imp_str_literal(" BYTES"));
// 744 NEWLINE
_imp_NEWLINE();
// 745
// 746
// 747 !%ENDOFPROGRAM; !**REMOVE FOR EXTRA MONITORING**
// 748
// 749 ! ------TEMPORARY EXTRA MONITORING-------
// 750 NEWLINE
_imp_NEWLINE();
// 751 PRINT STRING("JUMPS:")
_imp_PRINTSTRING(_imp_str_literal("JUMPS:"));
// 752 WRITE(SJ,1); PRINT STRING(" SHORT,")
_imp_WRITE(SJ, 1);
_imp_PRINTSTRING(_imp_str_literal(" SHORT,"));
// 753 WRITE(RX1,1); PRINT STRING(" RX1,")
_imp_WRITE(RX1, 1);
_imp_PRINTSTRING(_imp_str_literal(" RX1,"));
// 754 WRITE(RX2,1); PRINT STRING(" RX2,")
_imp_WRITE(RX2, 1);
_imp_PRINTSTRING(_imp_str_literal(" RX2,"));
// 755 WRITE(RX3,1); PRINT STRING(" RX3")
_imp_WRITE(RX3, 1);
_imp_PRINTSTRING(_imp_str_literal(" RX3"));
// 756 NEWLINE
_imp_NEWLINE();
// 757 PRINT STRING("...INCLUDING")
_imp_PRINTSTRING(_imp_str_literal("...INCLUDING"));
// 758 WRITE(PERMCALLS,1); PRINT STRING(" PERMCALLS AND")
_imp_WRITE(PERMCALLS, 1);
_imp_PRINTSTRING(_imp_str_literal(" PERMCALLS AND"));
// 759 WRITE(RTNCALLS,1); PRINT STRING(" CALLS ON USER-DEFINED ROUTINES")
_imp_WRITE(RTNCALLS, 1);
_imp_PRINTSTRING(_imp_str_literal(" CALLS ON USER-DEFINED ROUTINES"));
// 760 NEWLINES(2)
_imp_NEWLINES(2);
// 761 %ENDOFPROGRAM
_imp_stop(0);
return 0;
case_D_dispatch:
if (D_index < 1 || D_index > 8)
_imp_signalf(6, 3, D_index, "->D(%d) out of bounds at %s line %d", D_index, D_file, D_line);
goto *D[D_index - 1];
case_C_dispatch:
if (C_index < 2 || C_index > 11)
_imp_signalf(6, 3, C_index, "->C(%d) out of bounds at %s line %d", C_index, C_file, C_line);
goto *C[C_index - 2];
end_0:;
}