// cc -o nrimp10s -g -O0 nrimp10s-77.c -Wno-multichar -I../new-parser/imps ../new-parser/imps/perms.c -lm
#include <perms.h>
#undef Longinteger
#undef Newpage
#undef Readline
#undef Rexp
#undef Float
void Lput(int A, int B, int C, int D) {
}
int *Comreg(int N) {
static int Dummy = 0;
return &Dummy;
}
void Consource(_imp_string File, int *Ad) {
// I think this may be for %include files?
}
void Iocp(int A, int B) {
}
void Ncode(int Start, int Finish, int Ca) {
}
int _imp_mainep(int _imp_argc, char **_imp_argv) {
_imp_string Itos(int V, int P) {
int Vv;
int Q;
int Pos;
unsigned char Store[128 /*0:127*/];
Vv = V;
if (Vv > 0)
Vv = -Vv;
Pos = 127;
while (Vv <= -10) {
Q = Vv / 10;
Store[Pos] = Q * 10 - Vv + '0';
Pos--;
Vv = Q;
}
Store[Pos] = '0' - Vv;
if (P <= 0)
P += 128;
else {
P -= 128;
if (P > Pos)
P = Pos;
P--;
}
if (V < 0) {
Pos--;
Store[Pos] = '-';
}
while (Pos > P && Pos > 1) {
Pos--;
Store[Pos] = ' ';
}
Pos--;
Store[Pos] = 127 - Pos;
return (*String(Addr(Store[Pos])));
}
long long int *Longinteger(int Addr) { return ((long long int *)(Addr)); }
void Pprofile(void) {}
void Printch(int I) { Printsymbol(I); }
void Newpage(void) { Printch(12); }
int Imod(int I) { return (abs(I)); }
float Mod(float R) { return (abs(R)); }
float Fracpt(float R) { return (R - Intpt(R)); }
static const int Release = 10;
#define Yes 1
#define No 0
static const int Useimp = Yes;
static const int Vmeb = No;
static const _imp_string Ladate = _imp_str_literal("28 Jan 81");
int I;
int J;
int K;
static const unsigned char Clett[501 /*0:500*/] = {
1, 43, 1, 45, 1, 40, 1, 41, 1, 44, 2, 201, 198, 6, 213,
206, 204, 197, 211, 211, 5, 215, 200, 201, 204, 197, 5, 213, 206, 212,
201, 204, 3, 198, 207, 210, 1, 61, 4, 210, 197, 193, 204, 7, 201,
206, 212, 197, 199, 197, 210, 8, 204, 207, 206, 199, 210, 197, 193, 204,
4, 204, 207, 206, 199, 11, 194, 217, 212, 197, 201, 206, 212, 197, 199,
197, 210, 6, 211, 212, 210, 201, 206, 199, 11, 200, 193, 204, 198, 201,
206, 212, 197, 199, 197, 210, 7, 210, 207, 213, 212, 201, 206, 197, 2,
198, 206, 3, 205, 193, 208, 8, 198, 213, 206, 195, 212, 201, 207, 206,
6, 210, 197, 195, 207, 210, 196, 4, 206, 193, 205, 197, 5, 193, 210,
210, 193, 217, 9, 193, 210, 210, 193, 217, 206, 193, 205, 197, 9, 207,
198, 208, 210, 207, 199, 210, 193, 205, 6, 207, 198, 198, 201, 204, 197,
6, 207, 198, 204, 201, 211, 212, 6, 198, 207, 210, 205, 193, 212, 4,
211, 208, 197, 195, 3, 206, 207, 212, 3, 193, 206, 196, 2, 207, 210,
1, 58, 6, 206, 207, 210, 205, 193, 204, 3, 207, 215, 206, 8, 197,
216, 212, 197, 210, 206, 193, 204, 9, 197, 216, 212, 210, 201, 206, 211,
201, 195, 8, 195, 207, 206, 211, 212, 193, 206, 212, 5, 195, 207, 206,
211, 212, 5, 197, 214, 197, 206, 212, 5, 211, 212, 193, 210, 212, 9,
212, 200, 197, 206, 211, 212, 193, 210, 212, 4, 212, 200, 197, 206, 9,
197, 204, 211, 197, 211, 212, 193, 210, 212, 4, 197, 204, 211, 197, 1,
95, 6, 211, 217, 211, 212, 197, 205, 7, 196, 217, 206, 193, 205, 201,
195, 2, 42, 61, 1, 42, 4, 80, 85, 84, 95, 5, 67, 78, 79,
80, 95, 2, 204, 61, 1, 60, 1, 62, 4, 40, 196, 210, 43, 2,
196, 210, 1, 194, 3, 212, 207, 211, 3, 204, 206, 194, 3, 216, 206,
194, 2, 208, 195, 3, 195, 212, 194, 2, 45, 62, 6, 210, 197, 212,
213, 210, 206, 6, 210, 197, 211, 213, 204, 212, 7, 205, 207, 206, 201,
212, 207, 210, 4, 211, 212, 207, 208, 6, 211, 201, 199, 206, 193, 204,
4, 197, 216, 201, 212, 8, 195, 207, 206, 212, 201, 206, 213, 197, 6,
198, 201, 206, 201, 211, 200, 5, 195, 217, 195, 204, 197, 6, 210, 197,
208, 197, 193, 212, 3, 197, 206, 196, 5, 210, 197, 193, 204, 211, 5,
194, 197, 199, 201, 206, 2, 207, 206, 6, 211, 215, 201, 212, 195, 200,
4, 204, 201, 211, 212, 7, 211, 208, 197, 195, 201, 193, 204, 14, 212,
210, 213, 211, 212, 197, 196, 208, 210, 207, 199, 210, 193, 205, 6, 205,
193, 201, 206, 197, 208, 7, 195, 207, 206, 212, 210, 207, 204, 7, 201,
206, 195, 204, 213, 196, 197};
static int Symbol[1300+914 /*1300:2213*/] = { [ 0 ... 1299 ] = 0,
1307, 1303, 0, 1305, 2, 1307, 1000, 1319, 1312, 1001, 1357, 1824,
1315, 1003, 1020, 1319, 4, 1336, 6, 1329, 1323, 1001, 1014, 1325,
1003, 1329, 4, 1329, 6, 1336, 1336, 1010, 1028, 1319, 1011, 1350,
1343, 1343, 1010, 1028, 1307, 1011, 1343, 1350, 1348, 1026, 1307, 999,
1350, 1000, 1357, 1355, 1026, 1319, 999, 1357, 1000, 1365, 1363, 4,
1336, 1365, 6, 1365, 1000, 1372, 1370, 8, 1336, 999, 1372, 1000,
1377, 1375, 10, 1377, 13, 1401, 1384, 20, 1010, 1542, 1562, 1011,
1390, 26, 1010, 1542, 1562, 1011, 1401, 32, 1010, 1001, 36, 1336,
8, 1336, 8, 1336, 1011, 1408, 1406, 8, 1001, 999, 1408, 1000,
1415, 1411, 38, 1413, 43, 1415, 51, 1430, 1418, 43, 1420, 38,
1423, 60, 1408, 1425, 65, 1428, 77, 1925, 1430, 84, 1437, 1433,
96, 1437, 1031, 1415, 1437, 1444, 1440, 104, 1442, 107, 1444, 111,
1466, 1450, 1415, 1476, 1001, 1401, 1456, 120, 1466, 127, 1001, 1401,
1462, 1430, 1471, 1001, 1401, 1483, 1466, 127, 1001, 1401, 1471, 1469,
132, 1471, 1000, 1476, 1474, 127, 1476, 1000, 1483, 1479, 138, 1481,
127, 1483, 1000, 1493, 1491, 4, 1010, 1444, 1011, 1493, 6, 1493,
1000, 1502, 1500, 1030, 1010, 1444, 1011, 999, 1502, 1000, 1513, 1506,
148, 1016, 1508, 158, 1511, 165, 1018, 1513, 1016, 1518, 1516, 172,
1518, 1000, 1542, 1526, 172, 1001, 4, 1876, 1869, 6, 1535, 179,
1010, 1001, 1818, 1011, 4, 1001, 6, 1542, 1010, 1615, 1011, 4,
1001, 6, 1556, 1548, 1336, 1032, 1336, 1556, 1553, 4, 1542, 1562,
6, 1556, 184, 1542, 1562, 1560, 1037, 1336, 1562, 1000, 1573, 1567,
188, 1542, 1573, 1571, 192, 1542, 1580, 1573, 1000, 1580, 1578, 188,
1542, 999, 1580, 1000, 1587, 1585, 192, 1542, 999, 1587, 1000, 1595,
1591, 1033, 1336, 1593, 195, 1595, 1000, 1601, 1599, 179, 1008, 1601,
1015, 1606, 1604, 60, 1606, 197, 1615, 1613, 8, 1336, 195, 1336,
1606, 1615, 1000, 1624, 1620, 1476, 1001, 1401, 1624, 132, 1513, 1624,
1630, 1630, 1001, 1401, 1832, 1630, 1636, 1634, 8, 1624, 1636, 1000,
1652, 1646, 1476, 1010, 1001, 1401, 1840, 1011, 1652, 1006, 1652, 132,
1513, 1001, 1832, 1701, 1663, 1661, 8, 1010, 1001, 1401, 1840, 1011,
1652, 1663, 1000, 1674, 1666, 204, 1668, 208, 1670, 217, 1672, 227,
1674, 236, 1701, 1678, 1415, 1636, 1689, 120, 1476, 1010, 1001, 1401,
1011, 4, 1001, 6, 1006, 1701, 120, 132, 1513, 1010, 1001, 1832,
1011, 4, 1001, 6, 1006, 1711, 1709, 36, 1028, 1319, 1350, 1722,
1711, 1711, 1000, 1722, 1720, 8, 1012, 1028, 1319, 1350, 1722, 999,
1722, 1000, 1731, 1729, 4, 1028, 1319, 1350, 6, 1731, 1000, 1738,
1736, 8, 1009, 999, 1738, 1000, 1743, 1741, 242, 1743, 1000, 1749,
1747, 8, 1336, 1749, 1000, 1762, 1760, 8, 1001, 1401, 4, 1336,
195, 1336, 6, 999, 1762, 1000, 1769, 1767, 26, 1542, 1562, 1769,
1000, 1782, 1772, 1019, 1774, 1006, 1779, 1372, 1542, 1562, 1006, 1782,
1377, 1006, 1795, 1786, 248, 1034, 1789, 254, 1034, 1795, 264, 1010,
2060, 1011, 1801, 1801, 1799, 188, 2060, 1801, 1000, 1818, 1805, 269,
1034, 1813, 279, 1372, 1010, 1542, 1562, 1011, 1782, 1816, 279, 2060,
1818, 1000, 1824, 1822, 284, 1001, 1824, 1000, 1832, 1830, 284, 1001,
1357, 1824, 1832, 1000, 1840, 1840, 4, 1336, 195, 1336, 1606, 6,
1848, 1846, 36, 1028, 1319, 1350, 1848, 1000, 1858, 1852, 286, 1013,
1854, 208, 1856, 293, 1858, 1000, 1869, 1867, 1001, 36, 1336, 8,
1336, 8, 1336, 1869, 1000, 1876, 1874, 8, 1876, 999, 1876, 1000,
1916, 1882, 1415, 1476, 1001, 1401, 1889, 1415, 132, 1001, 1401, 1832,
1916, 1895, 120, 1466, 127, 1001, 1401, 1904, 120, 1010, 1001, 1401,
1011, 4, 1001, 6, 1916, 120, 132, 1010, 1001, 1401, 1832, 1916,
1011, 4, 1001, 6, 1925, 1923, 8, 1001, 1401, 1832, 999, 1925,
1000, 1932, 1930, 4, 1009, 6, 1932, 1000, 1950, 1936, 301, 1001,
1939, 304, 1001, 1942, 306, 1002, 1945, 1022, 1950, 1950, 311, 1009,
8, 1009, 1964, 1954, 1023, 1964, 1959, 1024, 317, 2003, 2008, 1964,
1025, 1005, 8, 1987, 1987, 1969, 320, 1001, 322, 1971, 2036, 1976,
4, 2036, 2025, 6, 1980, 324, 2036, 6, 1985, 4, 329, 2025,
6, 1987, 332, 2003, 1992, 320, 1001, 322, 1994, 2036, 1999, 4,
329, 2025, 6, 2003, 324, 1005, 6, 2008, 2006, 329, 2008, 1005,
2016, 2014, 8, 1005, 8, 1005, 2016, 1000, 2025, 2020, 0, 1005,
2023, 2, 1005, 2025, 1000, 2031, 2029, 0, 332, 2031, 1000, 2036,
2034, 36, 2036, 1000, 2051, 2041, 2031, 1300, 1003, 2044, 1001, 2016,
2049, 4, 2051, 2016, 6, 2051, 334, 2060, 2054, 338, 2056, 342,
2058, 346, 2060, 349, 2093, 2069, 1010, 1001, 1357, 1824, 1011, 1587,
1795, 2073, 353, 1001, 1357, 2075, 356, 2079, 363, 1033, 1336, 2082,
370, 1795, 2084, 378, 2089, 383, 1738, 1009, 1743, 2091, 390, 2093,
395, 2214, 2100, 1027, 1010, 2060, 1011, 1769, 2102, 1007, 2110, 1372,
1010, 1542, 1562, 1011, 1782, 1006, 2115, 404, 1035, 1801, 1006, 2120,
411, 1029, 1858, 1006, 2125, 417, 1036, 1762, 1006, 2130, 1377, 411,
1029, 1006, 2136, 1031, 1008, 1415, 1615, 1006, 2140, 424, 1502, 1006,
2144, 120, 1518, 1006, 2153, 1010, 1848, 1430, 1011, 1595, 1001, 1483,
1006, 2156, 1663, 1674, 2160, 428, 1601, 1006, 2164, 434, 1015, 1006,
2173, 440, 1021, 1738, 1009, 1731, 248, 1034, 1006, 2184, 443, 1001,
1401, 4, 1336, 195, 1336, 6, 1749, 1006, 2188, 450, 1006, 1017,
2193, 455, 127, 1001, 1006, 2197, 304, 1932, 1006, 2200, 463, 1006,
2204, 478, 1001, 1006, 2208, 485, 1003, 1006, 2212, 493, 1003, 1038,
2214, 1006};
static const int Ss = 2093;
static const unsigned char Itoetab[128 /*0:127*/] = {
0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x15, 0x40,
0x0C, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x4F, 0x7F, 0x7B,
0x5B, 0x6C, 0x50, 0x7D, 0x4D, 0x5D, 0x5C, 0x4E, 0x6B, 0x60, 0x4B, 0x61,
0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0x7A, 0x5E,
0x4C, 0x7E, 0x6E, 0x6F, 0x7C, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
0xC8, 0xC9, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xE2,
0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0x4A, 0x5F, 0x5A, 0x6A, 0x6D,
0x7C, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92,
0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6,
0xA7, 0xA8, 0xA9, 0xC0, 0x40, 0xD0, 0x40, 0x40};
static const int Opc[127 /*0:126*/] = {
0, ' JCC', ' JAT', ' JAF', [4 ... 7] = 0, ' VAL', ' CYD', 'INCA',
'MODD', 'PRCL', ' J', ' JLK', 'CALL', ' ADB', ' SBB', 'DEBJ',
' CPB', ' SIG', ' MYB', ' VMY', 'CPIB', ' LCT', 'MPSR', 'CPSR',
'STCT', 'EXIT', 'ESEX', ' OUT', ' ACT', ' SL', 'SLSS', 'SLSD',
'SLSQ', ' ST', 'STUH', 'STXN', 'IDLE', ' SLD', ' SLB', 'TDEC',
'INCT', ' STD', ' STB', 'STLN', 'STSF', ' L', ' LSS', ' LSD',
' LSQ', 'RRTC', ' LUH', 'RALN', ' ASF', 'LDRL', ' LDA', 'LDTB',
' LDB', ' LD', ' LB', ' LLN', ' LXN', ' TCH', 'ANDS', ' ORS',
'NEQS', 'EXPA', ' AND', ' OR', ' NEQ', ' PK', ' INS', 'SUPK',
' EXP', 'COMA', ' DDV', 'DRDV', 'DMDV', 'SWEQ', 'SWNE', ' CPS',
' TTR', ' FLT', ' IDV', 'IRDV', 'IMDV', ' MVL', ' MV', 'CHOV',
' COM', ' FIX', ' RDV', 'RRDV', 'RDVD', ' UAD', ' USB', 'URSB',
' UCP', ' USH', ' ROT', ' SHS', ' SHZ', ' DAD', ' DSB', 'DRSB',
' DCP', ' DSH', ' DMY', 'DMYD', 'CBIN', ' IAD', ' ISB', 'IRSB',
' ICP', ' ISH', ' IMY', 'IMYD', 'CDEC', ' RAD', ' RSB', 'RRSB',
' RCP', ' RSC', ' RMY', 'RMYD'};
static const unsigned char Onecase[128 /*0:127*/] = {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
96, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 123, 124, 125, 126, 127};
static const int Tsname[63 /*0:62*/] = {[0 ... 7] = 0x1000,
0x1001,
[9 ... 13] = 0x1000,
0x1001,
0x1062,
[16 ... 17] = 0x1001,
0x1062,
[19 ... 20] = 0x1000,
0x52,
0x51,
0x62,
[24 ... 30] = 0x1062,
0x1000,
0x31,
0x51,
[34 ... 35] = 0x1062,
0x31,
0x1000,
0x51,
0x62,
[40 ... 41] = 0x1000,
0x35,
0x1000,
0x1035,
0x31,
0x35,
0x1035,
0x33,
0,
0x1000,
0x31,
0x52,
0x51,
0x61,
0x72,
0x61,
0x72,
0x51,
0x62,
0x1051,
0x41,
0x1000};
static int Fixedgla[12 /*0:11*/] = {0, 0x50000000, [2 ... 3] = 0,
-1, 0, [6 ... 11] = 0};
static const unsigned char Bytes[8 /*0:7*/] = {[0 ... 2] = 0, 1, 2, 4, 8, 16};
static const unsigned char Trtab[256 /*0:255*/] = {
[0 ... 47] = 0, [48 ... 57] = 1, [58 ... 64] = 0, [65 ... 90] = 2,
[91 ... 96] = 0, [97 ... 122] = 2, [123 ... 127] = 0, [128 ... 255] = 0};
static const int Maxlevels = 31;
static const int Concop = 13;
static const int Fixedglalen = 48;
static const int Jobberbit = 0x40000000;
static const int Cebit = 1;
static const int Maxdict = 0x100;
static const int Lb = 0x7A;
static const int Slb = 0x52;
static const int Stb = 0x5A;
static const int Adb = 0x20;
static const int Cpb = 0x26;
static const int Myb = 0x2A;
static const int Sbb = 0x22;
static const int Cpib = 0x2E;
static const int Out = 0x3C;
static const int Cpsr = 0x34;
static const int Ld = 0x78;
static const int Lda = 0x72;
static const int Inca = 0x14;
static const int Std = 0x58;
static const int Ldb = 0x76;
static const int Ldtb = 0x74;
static const int Ldrl = 0x70;
static const int Cyd = 0x12;
static const int Modd = 0x16;
static const int Sld = 0x50;
static const int Stln = 0x5C;
static const int Asf = 0x6E;
static const int St = 0x48;
static const int Raln = 0x6C;
static const int Lxn = 0x7E;
static const int Lln = 0x7C;
static const int Lss = 0x62;
static const int Slss = 0x42;
static const int Mpsr = 0x32;
static const int Stsf = 0x5E;
static const int Luh = 0x6A;
static const int Stuh = 0x4A;
static const int Lsd = 0x64;
static const int Slsd = 0x44;
static const int Prcl = 0x18;
static const int Lsq = 0x66;
static const int Slsq = 0x46;
static const int Stxn = 0x4C;
static const int Lct = 0x30;
static const int Stct = 0x36;
static const int Junc = 0x1A;
static const int Jlk = 0x1C;
static const int Call = 0x1E;
static const int Exit = 0x38;
static const int Jcc = 2;
static const int Jat = 4;
static const int Jaf = 6;
static const int Debj = 0x24;
static const int Iad = 0xE0;
static const int Icp = 0xE6;
static const int Ush = 0xC8;
static const int Isb = 0xE2;
static const int Irsb = 0xE4;
static const int Or = 0x8C;
static const int Ucp = 0xC6;
static const int Imy = 0xEA;
static const int Imdv = 0xAe;
static const int And = 0x8A;
static const int Ish = 0xE8;
static const int Imyd = 0xEC;
static const int Idv = 0xAA;
static const int Rad = 0xF0;
static const int Rsb = 0xF2;
static const int Rrsb = 0xF4;
static const int Flt = 0xA8;
static const int Rrdv = 0xBC;
static const int Rsc = 0xF8;
static const int Fix = 0xB8;
static const int Rdv = 0xBA;
static const int Rddv = 0xBE;
static const int Rmyd = 0xFC;
static const int Rmy = 0xFA;
static const int Mvl = 0xB0;
static const int Mv = 0xB2;
static const int Sweq = 0xA0;
static const int Swne = 0xA2;
static const int Cps = 0xA4;
static const int Accr = 0;
static const int Dr = 1;
static const int Lnb = 2;
static const int Xnb = 3;
static const int Pc = 4;
static const int Ctb = 5;
static const int Tos = 6;
static const int Breg = 7;
static const unsigned char Ldcode[8 /*0:7*/] = {0, 0x78, 0x7C, 0x7E,
0, 48, 0, 0x7A};
static const _imp_string Mdep = _imp_str_literal("S#NDIAG");
static const _imp_string Iocpep = _imp_str_literal("S#IOCP");
static const _imp_string Auxstep = _imp_str_literal("ICL9CEAUXST");
static const int Snpt = 0x1006;
static const int Commalt = 2;
static const int Endalt = 9;
static const int Unasspat = 0x81818181;
static const int Decalt = 8;
int Dictbase;
int Constptr;
int Constbtm;
int Dfhead;
int Consthole;
int Wkfilead;
int Wkfilek;
int Dummyformat;
int P1size;
int Levelinf;
int Iocpdisp;
int Parmbits1;
int Parmbits2;
int Parmlet;
int Asl;
int Nnames;
int Arsize;
int Cabuf;
int Ppcurr;
int Constlimit;
int Oldline;
int Line;
int Length;
int Nextp;
int Snum;
int Rlevel;
int Nmax;
int Ustptr;
int Plabel;
int Level;
int Ca;
int Lastname;
int Cdcount;
int Aslcurbtm;
int Parmdynamic;
int Faulty;
int Hit;
int Inhcode;
int Imps;
int Ttoput;
int List;
int Parmdiag;
int Warnflag;
int Parmtrace;
int Parmline;
int Parmopt;
int Ctype;
int Dcomp;
int Cprmode;
int Parmchk;
int Parmarr;
int Alllong;
int Parmdbug;
int Compiler;
int Lastinst;
int Smap;
int Stack;
int Auxst;
int Parmy;
int Bfflag;
int Rbase;
int N;
int Freeformat;
int Parmprof;
int Exitlab;
int Contlab;
int Q;
int R;
int S;
int Nest;
int Fname;
int Ldptr;
int Glaca;
int Glacabuf;
int Glacurr;
int Crefhead;
int Sstl;
int Qmax;
int Stmts;
int Lastat;
int Fileaddr;
int Fileptr;
int Fileend;
int Filesize;
int Lastend;
int Bimstr;
int Stlimit;
int Strlink;
int Rectb;
int Aslwarn;
int Ihead;
int Maxulab;
int Sflabel;
double Cvalue;
double Imax;
double Ctime;
_imp_string Mainep;
typedef struct Listf {
int S1;
int S2;
int S3;
int Link;
} Listf;
int Logepdisp;
int Expepdisp;
//extern int *Comreg(int N);
{
Fileaddr = *Comreg(46);
Parmbits1 = *Comreg(27);
Parmbits2 = *Comreg(28);
Wkfilead = *Comreg(14);
Wkfilek = 128;
if (Fileaddr <= 0) {
Filesize = 64000;
Fileaddr = 0;
} else {
Fileptr = Fileaddr + *Integer(Fileaddr + 4);
Fileend = Fileaddr + *Integer(Fileaddr);
Filesize = *Integer(Fileaddr);
}
Nnames = 255;
if (Filesize > 10000)
Nnames = 511;
if (!(Parmbits1 & Jobberbit)) {
if (Filesize > 32000)
Nnames = 1023;
if (Filesize > 256 * 1024 || (Parmbits2 & Maxdict) != 0 || Wkfilek > 512)
Nnames = 2047;
}
Asl = 3 * Nnames;
if (Asl > 4095 && (Parmbits2 & Maxdict) == 0)
Asl = 4095;
Arsize = Wkfilek * 768 - 300;
unsigned char A[(Wkfilek * 1024) + 1];
Listf Aslist[Asl + 1];
int Word[Nnames + 1];
int Tags[Nnames + 1];
int Dvheads[13 /*0:12*/];
auto int Fromar4(int Ptr);
auto int Fromar2(int Ptr);
auto void Toar8(int Ptr, double Value);
auto void Toar4(int Ptr, int Value);
auto void Toar2(int Ptr, int Value);
auto void Warn(int N, int V);
auto void Fault2(int N, int Val, int Iden);
auto void Fault(int N, int Value);
auto _imp_string Printname(int N);
auto int Morespace(void);
auto void Insertatend(int *S, int A, int B, int C);
auto void From12(int Cell, int *S1, int *S2);
auto void From123(int Cell, int *S1, int *S2, int *S3);
auto void Pop(int *C, int *P, int *Q, int *R);
auto void Push(int *C, int S1, int S2, int S3);
auto int Find(int Lab, int List);
auto void Mlink(int *Cell);
auto void Replace1(int Cell, int S1);
auto void Replace2(int Cell, int S2);
auto void Replace3(int Cell, int S3);
auto void Replace123(int Cell, int A1, int A2, int S3);
auto int From2(int Cell);
auto int From1(int Cell);
auto int From3(int Cell);
auto void Binsert(int *T, int *B, int S1, int S2, int S3);
auto void Clearlist(int *Head);
auto _imp_string Message(int N);
//extern void Lput(int A, int B, int C, int D);
//extern double Cputime(void);
//extern void Ncode(int Start, int Finish, int Ca);
auto void Printlist(int Head);
auto void Prhex(int Value, int Places);
auto void Checkasl(void);
#if 1 /* !Vmeb */
//extern void Consource(_imp_string File, int *Ad);
#endif
{
__label__ Bend;
auto void Readline(int Mode, int Char);
auto int Compare(int P);
auto void Pname(int Mode);
auto void Const(int Mode);
auto void Texttext(int Ebcdic);
int Ccsize;
int Dsize;
int Next;
int Atline1;
int Starstart;
Ccsize = 1000;
Dsize = 7 * Nnames;
int Display[32 /*0:31*/];
int Sfs[32 /*0:31*/];
unsigned char *Tline = calloc(222,1)+60 ; // [222 /*-60:161*/];
unsigned char Cc[Ccsize + 1];
unsigned char Lett[(Dsize + 20) + 1];
long long int Atl0;
long long int Asym0;
static const unsigned char Ilett[501 /*0:500*/] = {
11, 'S', 'E', 'L', 'E', 'C', 'T', 'I', 'N', 'P', 'U', 'T', 12, 'S',
'E', 'L', 'E', 'C', 'T', 'O', 'U', 'T', 'P', 'U', 'T', 7, 'N', 'E',
'W', 'L', 'I', 'N', 'E', 5, 'S', 'P', 'A', 'C', 'E', 10, 'S', 'K',
'I', 'P', 'S', 'Y', 'M', 'B', 'O', 'L', 10, 'R', 'E', 'A', 'D', 'S',
'T', 'R', 'I', 'N', 'G', 8, 'N', 'E', 'W', 'L', 'I', 'N', 'E', 'S',
6, 'S', 'P', 'A', 'C', 'E', 'S', 10, 'N', 'E', 'X', 'T', 'S', 'Y',
'M', 'B', 'O', 'L', 11, 'P', 'R', 'I', 'N', 'T', 'S', 'Y', 'M', 'B',
'O', 'L', 10, 'R', 'E', 'A', 'D', 'S', 'Y', 'M', 'B', 'O', 'L', 4,
'R', 'E', 'A', 'D', 5, 'W', 'R', 'I', 'T', 'E', 7, 'N', 'E', 'W',
'P', 'A', 'G', 'E', 4, 'A', 'D', 'D', 'R', 6, 'A', 'R', 'C', 'S',
'I', 'N', 3, 'I', 'N', 'T', 5, 'I', 'N', 'T', 'P', 'T', 6, 'F',
'R', 'A', 'C', 'P', 'T', 5, 'P', 'R', 'I', 'N', 'T', 7, 'P', 'R',
'I', 'N', 'T', 'F', 'L', 4, 'R', 'E', 'A', 'L', 7, 'I', 'N', 'T',
'E', 'G', 'E', 'R', 3, 'M', 'O', 'D', 6, 'A', 'R', 'C', 'C', 'O',
'S', 4, 'S', 'Q', 'R', 'T', 3, 'L', 'O', 'G', 3, 'S', 'I', 'N',
3, 'C', 'O', 'S', 3, 'T', 'A', 'N', 3, 'E', 'X', 'P', 11, 'C',
'L', 'O', 'S', 'E', 'S', 'T', 'R', 'E', 'A', 'M', 11, 'B', 'Y', 'T',
'E', 'I', 'N', 'T', 'E', 'G', 'E', 'R', 8, 'E', 'V', 'E', 'N', 'T',
'I', 'N', 'F', 6, 'R', 'A', 'D', 'I', 'U', 'S', 6, 'A', 'R', 'C',
'T', 'A', 'N', 6, 'L', 'E', 'N', 'G', 'T', 'H', 11, 'P', 'R', 'I',
'N', 'T', 'S', 'T', 'R', 'I', 'N', 'G', 2, 'N', 'L', 8, 'L', 'O',
'N', 'G', 'R', 'E', 'A', 'L', 7, 'P', 'R', 'I', 'N', 'T', 'C', 'H',
6, 'R', 'E', 'A', 'D', 'C', 'H', 6, 'S', 'T', 'R', 'I', 'N', 'G',
8, 'R', 'E', 'A', 'D', 'I', 'T', 'E', 'M', 8, 'N', 'E', 'X', 'T',
'I', 'T', 'E', 'M', 6, 'C', 'H', 'A', 'R', 'N', 'O', 8, 'T', 'O',
'S', 'T', 'R', 'I', 'N', 'G', 10, 'F', 'R', 'O', 'M', 'S', 'T', 'R',
'I', 'N', 'G', 6, 'R', 'E', 'C', 'O', 'R', 'D', 5, 'A', 'R', 'R',
'A', 'Y', 10, 'S', 'E', 'T', 'M', 'A', 'R', 'G', 'I', 'N', 'S', 4,
'I', 'M', 'O', 'D', 2, 'P', 'I', 9, 'E', 'V', 'E', 'N', 'T', 'L',
'I', 'N', 'E', 11, 'L', 'O', 'N', 'G', 'I', 'N', 'T', 'E', 'G', 'E',
'R', 12, 'L', 'O', 'N', 'G', 'L', 'O', 'N', 'G', 'R', 'E', 'A', 'L',
9, 'L', 'E', 'N', 'G', 'T', 'H', 'E', 'N', 'I', 9, 'L', 'E', 'N',
'G', 'T', 'H', 'E', 'N', 'R', 8, 'S', 'H', 'O', 'R', 'T', 'E', 'N',
'I', 8, 'S', 'H', 'O', 'R', 'T', 'E', 'N', 'R', 6, 'N', 'E', 'X',
'T', 'C', 'H', 11, 'H', 'A', 'L', 'F', 'I', 'N', 'T', 'E', 'G', 'E',
'R', 8, 'P', 'P', 'R', 'O', 'F', 'I', 'L', 'E', 255};
Imax = (unsigned)(-1) >> 1;
Plabel = 24999;
Lett[0] = 0;
Atline1 = Addr(Tline[1]);
*Integer(Addr(Atl0) + 4) = Atline1 - 1;
*Integer(Addr(Atl0)) = 0x18000100;
*Integer(Addr(Asym0)) = 0x28000C00;
*Integer(Addr(Asym0) + 4) = Addr(Symbol[1300]) - 4 * 1300;
N = 12;
Maxulab = Nnames + 16384;
Glacurr = 0;
Glaca = Fixedglalen;
Glacabuf = Glaca;
Parmopt = 1;
Parmarr = 1;
Lastinst = 0;
Parmline = 1;
Parmtrace = 1;
Parmdiag = 1;
List = 1;
Sflabel = 20999;
Parmchk = 1;
Exitlab = 0;
Contlab = 0;
Cabuf = 0;
Ppcurr = 0;
Oldline = 0;
Compiler = 0;
Rlevel = 0;
Nmax = 0;
Ustptr = 0;
Level = 0;
Ca = 0;
Lastat = 0;
Faulty = 0;
Warnflag = 0;
Alllong = 0;
Inhcode = 0;
Dcomp = 0;
Bfflag = 0;
Cprmode = 0;
Next = 1;
Ldptr = 0;
Iocpdisp = 0;
Crefhead = 0;
Auxst = 0;
Rbase = 10;
Logepdisp = 0;
Expepdisp = 0;
Strlink = 0;
Rectb = 0;
Ihead = 0;
Sstl = 0;
Stmts = 1;
Snum = 0;
Levelinf = 0;
Cdcount = 0;
Bimstr = 0;
Logepdisp = 0;
Expepdisp = 0;
Mainep = _imp_str_literal("S#GO");
Dictbase = Addr(Lett[0]);
Lput(0, 0, 0, 0);
Ctime = Cputime();
I = *Comreg(27);
Stlimit = 0x1F000;
if ((unsigned)I >> 24 & 1)
Stlimit = *Comreg(48) - 4096;
if ((I & 2) == 2)
List = 0;
if ((I & 4) == 4)
Parmdiag = 0;
if (I & 0x800000)
Parmline = 0;
if ((I & 16) == 16)
Parmchk = 0;
if ((I & 32) == 32)
Parmarr = 0;
Parmprof = ((unsigned)I >> 15 & 1) | ((unsigned)I >> 7 & 1);
Parmdynamic = (unsigned)I >> 20 & 1;
Parmlet = (unsigned)I >> 13 & 1;
Dcomp = (unsigned)I >> 14 & 1;
Parmdbug = (unsigned)I >> 18 & 1;
if ((I & 64) == 64) {
Parmtrace = 0;
Parmdiag = 0;
}
Freeformat = I & 0x80000;
Stack = (unsigned)I >> 3 & 1;
Smap = (unsigned)I >> 26 & 1;
Ttoput = *Comreg(40);
if (I & (1 << 16)) {
Parmarr = 0;
Parmopt = 0;
Parmline = 0;
Parmchk = 0;
Parmdiag = 0;
}
Parmtrace = Parmtrace | Parmopt;
Imps = (unsigned)I >> 23 & 1;
Imps = 1;
Newlines(3);
Spaces(14);
Printstring(_imp_str_literal("ERCC. Imp"));
if (Imps)
Printsymbol('s');
Printstring(_imp_str_literal(" Compiler Release"));
Write(Release, 1);
Printstring(_imp_join(_imp_str_literal(" Version "), Ladate));
Newlines(3);
Write(Nnames, 5);
Write(Asl, 5);
Newline();
Aslwarn = 0;
Aslcurbtm = Asl - 240;
Constlimit = 4 * Aslcurbtm - 8;
for (I = Aslcurbtm; I <= Asl - 1; I++)
Aslist[I + 1].Link = I;
Aslist[Aslcurbtm].Link = 0;
Aslist[0].S1 = -1;
Aslist[0].S2 = -1;
Aslist[0].S3 = -1;
Aslist[0].Link = 0;
for (I = 0; I <= Nnames; I++) {
Word[I] = 0;
Tags[I] = 0;
}
for (I = 0; I <= 12; I++)
Dvheads[I] = 0;
K = 0;
Next = 1;
I = Ilett[0];
while (I < 255) {
for (J = I; J >= 1; J--)
Cc[J] = Ilett[K + J];
Cc[I + 1] = ';';
R = 2;
Q = 1;
Pname(1);
Push(&Tags[Lastname], Snpt << 16 | 0x8000, 0, Snum << 16);
Snum++;
K = K + I + 1;
I = Ilett[K];
}
*Comreg(24) = 16;
Dummyformat = 0;
Dfhead = 0;
Push(&Dfhead, 0, 0, 0);
Push(&Dummyformat, 0, 0, Dfhead);
Line = 0;
Length = 0;
Q = 1;
R = 1;
Level = 1;
for (;;) {
if (Q >= Length) {
Qmax = 1;
Readline(0, 0);
}
Warnflag = 0;
Starstart = R;
R += 3;
Oldline = Line;
A[R] = (unsigned)Line >> 8;
A[R + 1] = Line & 255;
R += 2;
if (!Compare(Ss)) {
Fault(100, Addr(Cc[0]));
R = Starstart;
} else {
if (R > Arsize)
Fault(102, 0);
if (A[Starstart + 5] == Commalt)
R = Starstart;
else {
I = R - Starstart;
A[Starstart] = (unsigned)I >> 16;
A[Starstart + 1] = (unsigned)I >> 8 & 255;
A[Starstart + 2] = I & 255;
if (A[Starstart + 5] == Decalt && Level > 1) {
if (!Sfs[Level]) {
Toar4(Display[Level], Starstart);
Display[Level] = Starstart + 6;
} else
A[Starstart + 6] = 128;
}
if (Smap) {
Newline();
Write(Line, 5);
Write(Starstart, 5);
Newline();
J = 0;
for (I = Starstart; I <= R - 1; I++) {
Write(A[I], 5);
J++;
if (J >= 20) {
Newline();
J = 0;
}
}
Newline();
}
if (A[Starstart + 5] == Endalt && 1 <= A[Starstart + 6] &&
A[Starstart + 6] <= 2)
break;
if (!Level) {
Fault(14, 0);
break;
}
}
}
}
Toar8(R, 0);
R += 8;
if (R + Next > Arsize)
Fault(102, 0);
P1size = R;
for (I = 0; I <= Next; I++)
A[R + I] = Lett[I];
Dictbase = Addr(A[R]);
R = R + Next + 1;
goto Bend;
void Readline(int Mode, int Char) {
auto void Getline(void);
int Del;
int Ll;
int Lp;
Ll = 0;
Lp = 0;
Q = 1;
Length = 0;
Del = 0;
Next:;
Lp++;
if (Lp > Ll) {
Getline();
Lp = 1;
}
I = Tline[Lp];
if (!Mode) {
if (I == '%') {
Del = 128;
goto Next;
}
I = Onecase[I];
if ('A' <= I && I <= 'Z')
I = I | Del;
else {
Del = 0;
if (I == ' ')
goto Next;
}
Length++;
Cc[Length] = I;
if (I == '\'' || I == 34) {
Mode = 1;
Char = I;
}
} else {
Length++;
Cc[Length] = I;
if (I == Char)
Mode = 0;
}
if (I != Nl)
goto Next;
if (Cc[Length - 1] == 'C' + 128) {
Length -= 2;
goto Next;
}
if (Length > Ccsize)
Fault(101, 0);
return;
void Getline(void) {
//extern void Iocp(int A, int B);
static const unsigned char Itoi[256 /*0:255*/] = {[0 ... 9] = 32,
10,
[11 ... 24] = 32,
25,
26,
[27 ... 31] = 32,
32,
33,
34,
35,
36,
37,
38,
39,
40,
41,
42,
43,
44,
45,
46,
47,
48,
49,
50,
51,
52,
53,
54,
55,
56,
57,
58,
59,
60,
61,
62,
63,
64,
65,
66,
67,
68,
69,
70,
71,
72,
73,
74,
75,
76,
77,
78,
79,
80,
81,
82,
83,
84,
85,
86,
87,
88,
89,
90,
91,
92,
93,
94,
95,
96,
97,
98,
99,
100,
101,
102,
103,
104,
105,
106,
107,
108,
109,
110,
111,
112,
113,
114,
115,
116,
117,
118,
119,
120,
121,
122,
123,
124,
125,
126,
32,
[128 ... 132] = 26,
10,
[134 ... 143] = 26,
[144 ... 159] = 26,
[160 ... 173] = 26,
92,
38,
[176 ... 186] = 26,
35,
[188 ... 191] = 26,
[192 ... 207] = 26,
[208 ... 216] = 26,
35,
[218 ... 222] = 26,
94,
[224 ... 255] = 26};
int K;
Ll = 0;
if (!Fileaddr)
do {
Readsymbol(&K);
Tline[Ll + 1] = Itoi[K];
Ll++;
} while (K != Nl);
else {
if (Fileptr >= Fileend) {
if (Ihead) {
Pop(&Ihead, &Fileaddr, &Fileptr, &Fileend);
Getline();
return;
}
_imp_signal(9, 1, 0, _imp_str_literal(""));
}
Imp:;
do {
K = *Byteinteger(Fileptr);
Fileptr++;
Tline[Ll + 1] = Itoi[K];
Ll++;
} while (K != Nl && K != 0);
Olist:;
}
Line++;
if (List) {
if (Mode == 0 && Length > 0)
Printstring(_imp_str_literal(" C"));
else
Write(Line, 5);
for (K = -7; K <= 0; K++)
Tline[K] = ' ';
if (Mode)
Tline[-7] = '"';
Tline[-8] = Ll + 8;
Iocp(15, Addr(Tline[-8]));
}
if (Freeformat == 0 && Ll > 73) {
Tline[73] = 10;
Ll = 73;
}
}
}
int Compare(int P) {
int I;
int J;
int Item;
int Ra;
int Rl;
int Rp;
int Rq;
int Rr;
int Rs;
int Marker;
int Ssl;
int Alt;
int Pp;
static int Savecomp;
static int Bip_sw;
static void *Bip[40 /*999:1038*/] = {
&&Bip_999, &&Bip_1000, &&Bip_1001, &&Bip_1002, &&Bip_1003,
&&Bip_1004, &&Bip_1005, &&Bip_1006, &&Bip_1007, &&Bip_1008,
&&Bip_1009, &&Bip_1010, &&Bip_1011, &&Bip_1012, &&Bip_1013,
&&Bip_1014, &&Bip_1015, &&Bip_1016, &&Bip_1017, &&Bip_1018,
&&Bip_1019, &&Bip_1020, &&Bip_1021, &&Bip_1022, &&Bip_1023,
&&Bip_1024, &&Bip_1025, &&Bip_1026, &&Bip_1027, &&Bip_1028,
&&Bip_1029, &&Bip_1030, &&Bip_1031, &&Bip_1032, &&Bip_1033,
&&Bip_1034, &&Bip_1035, &&Bip_1036, &&Bip_1037, &&Bip_1038,
};
Rp = Symbol[P];
Rl = Level;
P++;
Pp = P;
Comm:;
Rq = Q;
Rr = R;
Ssl = Strlink;
Alt = 1;
Ra = Symbol[P];
Rs = P;
Upr:
R++;
Succ:;
Rs++;
if (Rs == Ra)
goto Fini;
Item = Symbol[Rs];
if (Item < 999)
goto Lit;
if (Item < 1300)
goto *Bip[Bip_sw = (Item)-999];
if (!Compare(Item))
goto Fail;
goto Succ;
Lit:;
I = Cc[Q];
if (I != Clett[Item + 1])
goto Fail;
Q++;
K = Clett[Item] + Item;
Item += 2;
while (Item <= K) {
if (Cc[Q] != Clett[Item])
goto Fail;
Q++;
Item++;
}
goto Succ;
Fail:;
if (Ra == Rp)
goto Tfail;
if (Q > Qmax)
Qmax = Q;
Q = Rq;
R = Rr + 1;
Strlink = Ssl;
Alt++;
Rs = Ra;
Ra = Symbol[Ra];
goto Succ;
Tfail:;
Level = Rl;
return (0);
Bip_999:;
A[Rr] = Alt;
P = Pp;
goto Comm;
Bip_1000:
Fini:;
A[Rr] = Alt;
return (1);
Bip_1001:;
Bip_1004:;
I = Cc[Q];
if (Trtab[I] != 2)
goto Fail;
Pname(Item - 1004);
if (Hit == 1)
goto Succ;
goto Fail;
Bip_1002:;
Bip_1003:;
Const(Item - 1003);
if (!Hit)
goto Fail;
goto Succ;
Bip_1005:;
I = Cc[Q];
if ('0' > I || I > '9')
goto Fail;
S = 0;
while ('0' <= I && I <= '9') {
S = 10 * S + (I & 15);
Q++;
I = Cc[Q];
}
Toar2(R, S);
R += 2;
goto Succ;
Bip_1006:;
I = Cc[Q];
if (I == Nl)
goto Succ;
if (I != ';')
goto Fail;
Q++;
goto Succ;
Bip_1007:;
I = Cc[Q];
J = I;
if (I == ';' || I == Nl)
goto Tx;
if (I != '!' && I != '|' &&
(I != 'C' + 128 || Cc[Q + 1] != 'O' + 128 ||
Cc[Q + 2] != Cc[Q + 3] || Cc[Q + 3] != 'M' + 128 ||
Cc[Q + 4] != 'E' + 128 || Cc[Q + 5] != 'N' + 128 ||
Cc[Q + 6] != 'T' + 128))
goto Fail;
Q = Q + 1 + 6 * ((unsigned)I >> 7);
J = Cc[Q];
for (;;) {
if (J == Nl || J == ';')
break;
Q++;
J = Cc[Q];
}
Tx:
if (J == ';')
Q++;
goto Succ;
Bip_1008:;
Toar4(R, 0);
R += 4;
goto Succ;
Bip_1009:;
I = Cc[Q];
if ('0' > I || I > '9')
goto Fail;
S = 0;
while ('0' <= I && I <= '9') {
S = 10 * S + (I & 15);
Q++;
I = Cc[Q];
}
if (0 > S || S > 255)
goto Fail;
A[R] = S;
goto Upr;
Bip_1010:;
Marker = R;
R += 2;
goto Succ;
Bip_1011:;
I = R - Marker;
A[Marker + 1] = I;
A[Marker] = (unsigned)I >> 8;
goto Succ;
Bip_1012:;
I = Cc[Q];
while (I == Nl) {
Readline(0, 0);
Rq = 1;
I = Cc[Q];
}
if (R > Arsize)
Fault(102, 0);
goto Succ;
Bip_1013:;
if (Imps != 1)
goto Fail;
goto Succ;
Bip_1014:;
A[R] = 2;
A[R + 1] = 2;
R += 2;
goto Succ;
Bip_1015:;
Level++;
Toar4(R, 0);
Display[Level] = R;
Sfs[Level] = 0;
R += 4;
goto Succ;
Bip_1016:;
Display[Level] = 0;
while (Sfs[Level]) {
Pop(&Sfs[Level], &I, &J, &K);
if (I == 1)
Fault2(53, K, 0);
if (I == 2)
Fault2(13, K, 0);
}
Level--;
goto Succ;
Bip_1017:;
List = 1;
goto Succ;
Bip_1018:;
List = 0;
goto Succ;
Bip_1019:;
if (Cc[Q - 1] != ':')
goto Fail;
goto Succ;
Bip_1020:;
if (Ctype == 5) {
Toar4(S - 4, Strlink);
Strlink = S - 4;
}
goto Succ;
Bip_1021:;
Parmtrace = 1;
goto Succ;
Bip_1022:;
I = Cc[Q];
S = ' ';
while ('A' <= I && I <= 'Z') {
S = S << 8 | I;
Q++;
I = Cc[Q];
}
if (I != '_' || S == ' ')
goto Fail;
Q++;
goto Succ;
Bip_1023:;
for (I = 7; I <= 126; I++)
if (Opc[I] == S)
goto Pfnd;
goto Fail;
Pfnd:;
if (8 <= (unsigned)I >> 3 && (unsigned)I >> 3 <= 11 && (I & 7) <= 3)
goto Fail;
A[R] = 2 * I;
goto Upr;
Bip_1024:;
for (I = 64; I <= 88; I += 8)
for (J = 0; J <= 3; J++)
if (Opc[I + J] == S)
goto Sfnd;
goto Fail;
Sfnd:
A[R] = 2 * (I + J);
goto Upr;
Bip_1025:;
for (I = 3; I >= 1; I--)
if (Opc[I] == S) {
A[R] = 2 * I;
goto Upr;
}
goto Fail;
Bip_1026:;
I = Cc[Q];
if (32 >= I || I >= 127 ||
((unsigned)0x80000000 >> ((I - 32) & 31) & 0x4237000A) == 0)
goto Fail;
Q++;
if (I == '+') {
A[R] = 1;
goto Upr;
}
if (I == '-') {
A[R] = 2;
goto Upr;
}
if (I == '&') {
A[R] = 3;
goto Upr;
}
J = Cc[Q];
if (I == '*') {
if (J != I) {
A[R] = 6;
goto Upr;
}
if (Cc[Q + 1] == I && I == Cc[Q + 2]) {
A[R] = 4;
Q += 3;
goto Upr;
}
A[R] = 5;
Q++;
goto Upr;
}
if (I == '/') {
if (J != I) {
A[R] = 10;
goto Upr;
}
A[R] = 9;
Q++;
goto Upr;
}
if (I == '!') {
if (J != I) {
A[R] = 8;
goto Upr;
}
A[R] = 7;
Q++;
goto Upr;
}
if (I == '.') {
A[R] = 13;
goto Upr;
}
if (I == J && J == '<') {
A[R] = 12;
Q++;
goto Upr;
}
if (I == J && J == '>') {
A[R] = 11;
Q++;
goto Upr;
}
if (I == '\\') {
if (J != I) {
A[R] = 15;
goto Upr;
}
Q++;
A[R] = 14;
goto Upr;
}
goto Fail;
Bip_1027:;
I = Cc[Q];
if (Trtab[I] == 2 || I == '-')
goto Succ;
if ((unsigned)0x80000000 >> (I & 31) & 0x14043000)
goto Succ;
goto Fail;
Bip_1028:;
I = Cc[Q];
if (I == '\\' || I == 0x7E) {
A[R] = 3;
Q++;
goto Upr;
}
if (I == '-') {
A[R] = 2;
Q++;
goto Upr;
}
if (I == '+') {
A[R] = 1;
Q++;
goto Upr;
}
A[R] = 4;
goto Upr;
Bip_1029:;
Toar4(R, 0);
Push(&Sfs[Level], 2, R, Line);
R += 4;
goto Succ;
Bip_1030:;
I = Cc[Q];
if (I == ')')
goto Fail;
if (I == ',')
Q++;
goto Succ;
Bip_1031:;
I = Cc[Q];
if (I <= 128 || ((unsigned)0x80000000 >> (I & 31) & 0x20C83000) == 0 ||
((unsigned)0x80000000 >> (Cc[Q + 2] & 31) & 0x400A2800) == 0)
goto Fail;
goto Succ;
Bip_1032:;
Bip_1037:;
I = Cc[Q];
if (32 >= I || I > 92 ||
((unsigned)0x80000000 >> (I & 31) & 0x1004000E) == 0)
goto Fail;
if (I == '=') {
if (Cc[Q + 1] == I) {
J = 9;
goto Join1;
}
J = 1;
goto Join;
}
if (I == '#') {
if (Cc[Q + 1] == I) {
J = 10;
goto Join1;
}
J = 4;
goto Join;
}
if (I == '\\' && Cc[Q + 1] == '=') {
Q++;
if (Cc[Q + 1] == '=') {
J = 10;
goto Join1;
}
J = 4;
goto Join;
}
if (I == '>') {
if (Cc[Q + 1] == '=') {
J = 2;
goto Join1;
}
J = 3;
goto Join;
}
if (I == '<') {
if (Cc[Q + 1] == '=') {
J = 5;
goto Join1;
}
J = 6;
goto Join;
}
if (I == '-' && Cc[Q + 1] == '>') {
J = 8;
goto Join1;
}
goto Fail;
Join1:
Q++;
Join:
Q++;
A[R] = J;
if (Item == 1032) {
Savecomp = J;
goto Upr;
}
if (Savecomp > 6 || J > 6) {
Q--;
goto Fail;
}
goto Upr;
Bip_1033:;
I = Cc[Q];
if (I == '=') {
if (Cc[Q + 1] == '=') {
A[R] = 1;
Q += 2;
goto Upr;
}
A[R] = 2;
Q++;
goto Upr;
}
if (I == '<' && Cc[Q + 1] == '-') {
A[R] = 3;
Q += 2;
goto Upr;
}
if (I == '-' && Cc[Q + 1] == '>') {
A[R] = 4;
Q += 2;
goto Upr;
}
goto Fail;
Bip_1034:;
Toar4(R, 0);
Push(&Sfs[Level], 1, R, Line);
R += 4;
goto Succ;
Bip_1035:;
if (!Sfs[Level]) {
Fault2(51, 0, 0);
goto Succ;
}
Pop(&Sfs[Level], &I, &J, &K);
if (I == 2)
Fault2(59, K, 0);
Toar4(J, Starstart);
goto Succ;
Bip_1036:;
if (!Sfs[Level]) {
Fault2(1, 0, 0);
goto Succ;
}
Pop(&Sfs[Level], &I, &J, &K);
if (I == 1)
Fault2(52, K, 0);
Toar4(J, Starstart);
goto Succ;
Bip_1038:;
if (Vmeb == Yes)
goto Fail;
I = Cc[Q];
if (I != Nl && I != ';')
goto Fail;
if (I == ';')
Q++;
if (Ctype != 5)
goto Fail;
Push(&Ihead, Fileaddr, Fileptr, Fileend);
Consource(*String(Addr(A[S])), &Fileaddr);
Fileptr = Fileaddr + *Integer(Fileaddr + 4);
Fileend = Fileaddr + *Integer(Fileaddr);
goto Succ;
}
void Pname(int Mode) {
static const int Hash[8 /*0:7*/] = {71, 47, 97, 79, 29, 37, 53, 59};
int Jj;
int Kk;
int Ll;
int Fq;
int Fs;
int T;
int S;
int I;
long long int Drdes;
long long int Accdes;
Hit = 0;
Fq = Q;
Fs = Cc[Q];
if (Trtab[Fs] != 2 || '"' == Cc[Q + 1] || Cc[Q + 1] == '\'')
return;
T = 1;
Lett[Next + 1] = Fs;
Jj = 71 * Fs;
for (;;) {
Q++;
I = Cc[Q];
if (!Trtab[I])
break;
if (T <= 7)
Jj += Hash[T];
T++;
Lett[Next + T] = I;
}
Lett[Next] = T;
S = T + 1;
if (Next + S > Dsize)
Fault(103, 0);
Jj = (Jj + 113 * T) & Nnames;
for (Kk = Jj; Kk <= Nnames; Kk++) {
Ll = Word[Kk];
if (!Ll)
goto Hole;
if (_imp_strcmp(*String(Addr(Lett[Next])), *String(Addr(Lett[Ll]))) == 0)
goto Fnd;
}
for (Kk = 0; Kk <= Jj; Kk++) {
Ll = Word[Kk];
if (!Ll)
goto Hole;
if (_imp_strcmp(*String(Addr(Lett[Next])), *String(Addr(Lett[Ll]))) == 0)
goto Fnd;
}
Fault(104, 0);
Hole:
if (!Mode) {
Q = Fq;
return;
}
Word[Kk] = Next;
Next += S;
Fnd:
Lastat = Fq;
Hit = 1;
Lastname = Kk;
A[R + 1] = Lastname;
A[R] = (unsigned)Lastname >> 8;
R += 2;
Lastend = Q;
}
void Const(int Mode) {
int Z;
int Dotseen;
int Ebcdic;
int Fs;
int Cprec;
int Rr;
int S;
int T;
int Ss;
double X;
double Cvalue;
double Dummy;
static const double Ten = 10.0;
Cprec = 5;
Rr = R;
R++;
Dotseen = 0;
Hit = 0;
Cvalue = 0;
Dummy = 0;
Fs = Cc[Q];
S = 0;
if ('0' <= Fs && Fs <= '9')
goto N;
if (Fs == '.' && Mode == 0 && '0' <= Cc[Q + 1] && Cc[Q + 1] <= '9')
goto Dot;
Ctype = 1;
Ebcdic = 0;
if (Fs == '\'')
goto Quote;
if (Fs == 34)
goto Str2;
if (Cc[Q + 1] != '\'')
goto Notquote;
Q += 2;
if (Fs == 'X')
goto Hex;
if (Fs == 'M')
goto Mult;
if (Fs == 'B')
goto Bin;
if (Fs == 'R' && Mode == 0)
goto Rhex;
if (Fs == 'K')
goto Oct;
if (Fs == 'C') {
Ebcdic = 1;
goto Mult;
}
if (Fs == 'D' && Mode == 0) {
Cprec = 7;
if ('0' <= Cc[Q] && Cc[Q] <= '9')
goto N;
if (Cc[Q] == '.')
goto Dot;
}
Q -= 2;
return;
Quote:;
if (Cc[Q + 2] == '\'') {
S = Cc[Q + 1];
Q += 3;
if (S != '\'')
goto Iend;
if (Cc[Q] == '\'') {
Q++;
goto Iend;
}
}
return;
Notquote:;
if (Fs != 'E' || Cc[Q + 1] != '"')
return;
Ebcdic = 1;
Q++;
Str2:;
A[Rr] = 0x35;
Texttext(Ebcdic);
Ctype = 5;
return;
Hex:
T = 0;
for (;;) {
I = Cc[Q];
Q++;
if (I == '\'')
break;
T++;
if ((('0' > I || I > '9') && ('A' > I || I > 'F')) || T >= 17)
return;
if (T == 9) {
Ss = S;
S = 0;
}
S = (S << 4) + (I & 15) + 9 * ((unsigned)I >> 6);
}
if (T > 8) {
Z = 4 * (T - 8);
S = S | (Ss << Z);
Ss = (unsigned)Ss >> (32 - Z);
Cprec = 6;
}
Iend:
if (Cprec == 6) {
Toar4(R, Ss);
R += 4;
}
if (Cprec == 5 && 0 <= S && S <= 0x7FFF) {
Cprec = 4;
Toar2(R, S);
R += 2;
} else {
Toar4(R, S);
R += 4;
}
if (Mode == 0 || Cprec != 6)
Hit = 1;
A[Rr] = Cprec << 4 | Ctype;
return;
Rhex:;
T = 0;
for (;;) {
I = Cc[Q];
Q++;
if ((T & 7) == 0 && T != 0) {
Toar4(R, S);
R += 4;
S = 0;
}
if (I == '\'')
break;
T++;
if (('0' > I || I > '9') && ('A' > I || I > 'F'))
return;
S = (S << 4) + (I & 15) + 9 * ((unsigned)I >> 6);
}
if (T != 8 && T != 16 && T != 32)
return;
if (T == 32)
Cprec = 7;
else
Cprec = 4 + T / 8;
A[Rr] = Cprec << 4 | 2;
Hit = 1;
return;
Oct:;
T = 0;
for (;;) {
I = Cc[Q];
Q++;
T++;
if (I == '\'')
break;
if ('0' > I || I > '7' || T >= 12)
return;
S = S << 3 | (I & 7);
}
goto Iend;
Mult:
T = 0;
for (;;) {
I = Cc[Q];
Q++;
T++;
if (I == '\'')
if (Cc[Q] != '\'')
break;
else
Q++;
if (T >= 5)
return;
if (Ebcdic)
I = Itoetab[I];
S = S << 8 | I;
}
goto Iend;
Bin:
T = 0;
for (;;) {
I = Cc[Q];
Q++;
T++;
if (I == '\'')
break;
if ('0' > I || I > '1' || T >= 33)
return;
S = S << 1 | I & 1;
}
goto Iend;
N:;
I = Cc[Q];
do {
Cvalue = Ten * Cvalue + (I & 15);
Q++;
I = Cc[Q];
} while (I >= '0' && I <= '9');
if (Mode != 0 || I != '.')
goto Alpha;
Dot:
Q++;
X = Ten;
I = Cc[Q];
Dotseen = 1;
while ('0' <= I && I <= '9') {
Cvalue += (I & 15) / X;
X = Ten * X;
Q++;
I = Cc[Q];
}
Alpha:;
if (Mode == 0 && Cc[Q] == '@') {
Q++;
X = Cvalue;
Z = 1;
I = Cc[Q];
if (I == '-')
Z = -1;
if (I == '+' || I == '-')
Q++;
Const(2);
if (!Hit)
return;
Hit = 0;
R = Rr + 1;
if ((unsigned)A[R] >> 4 != 4)
return;
S = Fromar2(R + 1) * Z;
if (S == -99)
Cvalue = 0;
else {
while (S > 0) {
S--;
Cvalue = Cvalue * Ten;
}
while (S < 0 && Cvalue != 0) {
S++;
Cvalue = Cvalue / Ten;
}
}
}
if (Fs == 'D') {
I = Cc[Q];
if (I == '\'')
Q++;
else
return;
Dotseen = 1;
}
if (Dotseen == 1 || Cvalue > Imax || Fracpt(Cvalue) != 0)
Ctype = 2;
else {
Ctype = 1;
S = Int(Cvalue);
}
if (Ctype == 1)
goto Iend;
if (Cprec == 5)
Cprec = 6;
if (Cprec == 6)
;
Toar8(R, Cvalue);
R += 8;
if (Cprec == 7) {
Toar8(R, *Longreal(Addr(Cvalue) + 8));
R += 8;
}
A[Rr] = (Cprec << 4) + Ctype;
Hit = 1;
Fail:;
}
void Texttext(int Ebcdic) {
int J;
int Ii;
static const int Qu = '"';
I = Cc[Q];
S = R + 4;
R += 5;
Hit = 0;
if (I != Qu)
return;
Q++;
for (;;) {
I = Cc[Q];
if (Ebcdic)
Ii = Itoetab[I];
else
Ii = I;
A[R] = Ii;
R++;
if (I == Qu) {
Q++;
if (Cc[Q] != Qu)
break;
}
if (I == 10)
Readline(1, Qu);
else
Q++;
if (R - S > 256)
Fault(106, 0);
}
R--;
J = R - S - 1;
A[S] = J;
Hit = 1;
}
Bend:;
}
if (Level > 1)
Fault(15, 0);
I = 0;
Newline();
if (!Faulty) {
Write(Line, 5);
Printstring(_imp_str_literal(" LINES ANALYSED IN"));
Write(Int(1000 * (Cputime() - Ctime)), 5);
Printstring(_imp_str_literal(" MSECS - SIZE="));
Write(P1size, 5);
if (Line > 90 && List != 0)
Newpage();
else
Newline();
} else {
Printstring(_imp_str_literal("CODE GENERATION NOT ATTEMPTED\n"));
*Comreg(24) = 8;
*Comreg(47) = Faulty;
exit(0);
}
{
int Register[8 /*0:7*/];
int Gruse[8 /*0:7*/];
int Grat[8 /*0:7*/];
int Grinf1[8 /*0:7*/];
int Grinf2[8 /*0:7*/];
int Olink[8 /*0:7*/];
unsigned char Code[269 /*0:268*/];
unsigned char Glabuf[269 /*0:268*/];
int Plabs[32 /*0:31*/];
int Desads[32 /*0:31*/];
int Plink[32 /*0:31*/];
int Set[32 /*0:31*/];
int Stackbase[32 /*0:31*/];
int Ral[32 /*0:31*/];
int Flag[32 /*0:31*/];
int L[32 /*0:31*/];
int M[32 /*0:31*/];
int Nmdecs[32 /*0:31*/];
int Onword[32 /*0:31*/];
int Oninf[32 /*0:31*/];
int Jump[32 /*0:31*/];
int Label[32 /*0:31*/];
int Jround[32 /*0:31*/];
int Diaginf[32 /*0:31*/];
int Display[32 /*0:31*/];
int Auxsbase[32 /*0:31*/];
int Names[32 /*0:31*/];
int Avlwsp[5 /*0:4*/][32 /*0:31*/];
typedef struct Rcf {
int Val[24565 /*0:24564*/];
} Rcf;
Rcf *Ctable;
auto void Cnop(int I, int J);
auto void Pclod(int From, int To);
auto void Pconst(int X);
auto void Psf1(int Opcode, int K, int N);
auto void Pf1(int Opcode, int Kp, int Kpp, int N);
auto void Psorlf1(int Opcode, int Kp, int Kpp, int N);
auto void Pf2(int Opcode, int H, int Q, int N, int Mask, int Filler);
auto void Pf3(int Opcode, int Mask, int Kppp, int N);
auto void Notecref(int Ca, int Val);
auto int Paramdes(int Prec);
auto int Mapdes(int Prec);
auto int Specialconsts(int Which);
auto void Storeconst(int *D, int L, int Ad);
auto void Dumpconsts(void);
auto void Plant(int Value);
auto void Plug(int I, int J, int K, int Bytes);
auto void Codeout(void);
auto void Prologue(void);
auto void Epilogue(void);
auto void Compileastmnt(void);
auto void Css(int P);
auto void Loaddata(void);
auto void Abort(void);
auto void Printuse(void);
for (I = 0; I <= 7; I++) {
Register[I] = 0;
Gruse[I] = 0;
Grinf1[I] = 0;
Grat[I] = 0;
Grinf2[I] = 0;
}
for (I = 0; I <= Maxlevels; I++) {
Set[I] = 0;
Stackbase[I] = 0;
Ral[I] = 0;
Jump[I] = 0;
Jround[I] = 0;
Label[I] = 0;
Flag[I] = 0;
L[I] = 0;
M[I] = 0;
Diaginf[I] = 0;
Display[I] = 0;
Onword[I] = 0;
Oninf[I] = 0;
Names[I] = -1;
for (J = 0; J <= 4; J++)
Avlwsp[J][I] = 0;
}
Ctable = Record(Addr(Aslist[1]));
Consthole = 0;
Prologue();
Line = 0;
Nextp = 1;
Level = 1;
Stmts = 0;
Rlevel = 0;
Rbase = 0;
while (A[Nextp + 3] | A[Nextp + 4])
Compileastmnt();
Line = 99999;
Epilogue();
Loaddata();
exit(0);
void Compileastmnt(void) {
int I;
if (Dcomp != 0 && Ca > Cabuf) {
Codeout();
Printuse();
}
I = Nextp;
Nextp = Nextp + (A[Nextp] << 16) + (A[Nextp + 1] << 8) + A[Nextp + 2];
Line = (A[I + 3] << 8) + A[I + 4];
Stmts++;
Css(I + 5);
}
void Loaddata(void) {
int Langflag;
int Parms;
Glaca = (Glaca + 7) & (-8);
Ustptr = (Ustptr + 7) & (-8);
Codeout();
Cnop(0, 8);
Dumpconsts();
if (!Parmtrace)
Langflag = 6;
else
Langflag = 1;
Langflag = Langflag << 24;
Parms = (Parmdiag << 1 | Parmline) << 1 | Parmtrace;
Fixedgla[4] = Langflag | 1 << 16 | (Cprmode & 1) << 8 | Parms;
I = Glaca - Glacabuf;
if (!Inhcode) {
if (I)
Lput(2, I, Glacabuf, Addr(Glabuf[0]));
Lput(2, Fixedglalen, 0, Addr(Fixedgla[0]));
Lput(19, 2, 8, 5);
Lput(19, 2, 12, 4);
I = 0xE2E2E2E2;
Lput(4, 4, Sstl, Addr(I));
}
Sstl = (Sstl + 11) & (-8);
Printstring(_imp_str_literal("\nCODE"));
Write(Ca, 6);
Printstring(_imp_str_literal(" BYTES GLAP"));
Write(Glaca, 3);
Printstring(_imp_str_literal("+"));
Write(Ustptr, 1);
Printstring(_imp_str_literal(" BYTES DIAG TABLES"));
Write(Sstl, 3);
Printstring(_imp_str_literal(" BYTES\nTOTAL"));
Register[0] = Ca;
Register[1] = Glaca;
Register[2] = 0;
Register[3] = Sstl;
Register[4] = Ustptr;
K = Ca + Glaca + Sstl + Ustptr;
Register[5] = K;
Write(K, 5);
Printstring(_imp_str_literal(" BYTES"));
Newline();
Printch(13);
if (!Faulty) {
Write(Stmts, 7);
Printstring(_imp_str_literal(" STATEMENTS COMPILED IN"));
Write(Int(1000 * (Cputime() - Ctime)), 5);
Printstring(_imp_str_literal(" MSECS"));
*Comreg(47) = Stmts;
} else {
Printstring(_imp_str_literal("PROGRAM CONTAINS"));
Write(Faulty, 2);
Printstring(_imp_str_literal(" FAULT"));
if (Faulty > 1)
Printsymbol('S');
*Comreg(47) = Faulty;
}
Newlines(2);
Newline();
I = 0;
if (Faulty)
I = 8;
*Comreg(24) = I;
if (!Inhcode)
Lput(7, 24, 0, Addr(Register[0]));
Pprofile();
exit(0);
}
void Recode(int S, int F, int Ad) {
if (S != F) {
Printstring(_imp_str_literal("\nCODE FOR LINE"));
Write(Line, 5);
Ncode(S, F, Ad);
}
}
void Codeout(void) {
if (Ppcurr > 0) {
if (Dcomp)
Recode(Addr(Code[0]), Addr(Code[Ppcurr]), Cabuf);
if (!Inhcode)
Lput(1, Ppcurr, Cabuf, Addr(Code[0]));
Ppcurr = 0;
Cabuf = Ca;
}
}
void Plant(int Halfword) {
Code[Ppcurr] = (unsigned)Halfword >> 8;
Code[Ppcurr + 1] = Halfword;
Ppcurr += 2;
Ca += 2;
if (Ppcurr >= 256)
Codeout();
}
void Pconst(int Word) {
int I;
for (I = 24; I >= 0; I -= 8) {
Code[Ppcurr] = (unsigned)Word >> I & 255;
Ppcurr++;
}
Ca += 4;
if (Ppcurr >= 256)
Codeout();
}
void Psf1(int Opcode, int K, int N) {
int Kpp;
if ((K == 0 && -64 <= N && N <= 63) || (K != 0 && 0 <= N && N <= 511)) {
if (K)
N = N / 4;
Code[Ppcurr] = Opcode | (unsigned)K >> 1;
Code[Ppcurr + 1] = (K & 1) << 7 | N & 127;
Ppcurr += 2;
Ca += 2;
if (Ppcurr >= 256)
Codeout();
} else {
if (!K)
Kpp = 0;
else
Kpp = 2;
Pf1(Opcode, (unsigned)K >> 1 << 1, Kpp, N);
}
}
void Pf1(int Opcode, int Kp, int Kpp, int N) {
int Inc;
Inc = 2;
if (Kpp == Pc) {
if (N < 0) {
N = N & 0x7FFFFFFF;
Notecref(Ca, N);
}
N = (N - Ca) / 2;
}
if ((1 << Kpp) & 0b101100)
N = N / 4;
Code[Ppcurr] = Opcode | 1;
Code[Ppcurr + 1] = 0x80 | Kp << 5 | Kpp << 2 | ((unsigned)N >> 16 & 3);
Code[Ppcurr + 2] = (unsigned)N >> 8 & 255;
Code[Ppcurr + 3] = N & 255;
if (Kpp <= 5)
Inc = 4;
Ppcurr += Inc;
Ca += Inc;
if (Ppcurr >= 256)
Codeout();
}
void Psorlf1(int Opcode, int Kp, int Kpp, int N) {
int Inc;
Inc = 2;
if ((Kpp == 0 && 0 == Kp && -64 <= N && N <= 63) ||
(Kpp == Lnb && (Kp & 1) == 0 && 0 <= N && N <= 511)) {
if (Kpp == Lnb)
Kp = 1 + ((unsigned)Kp >> 1);
if (Kp)
N = N / 4;
Code[Ppcurr] = Opcode | (unsigned)Kp >> 1;
Code[Ppcurr + 1] = (Kp & 1) << 7 | (N & 127);
} else {
if (Kpp == Pc) {
if (N < 0) {
N = N & 0x7FFFFFFF;
Notecref(Ca, N);
}
N = (N - Ca) / 2;
}
if ((1 << Kpp) & 0b101100)
N = N / 4;
Code[Ppcurr] = Opcode | 1;
Code[Ppcurr + 1] =
((4 | Kp) << 3 | Kpp) << 2 | ((unsigned)N >> 16 & 3);
Code[Ppcurr + 2] = (unsigned)N >> 8 & 255;
Code[Ppcurr + 3] = N & 255;
if (Kpp <= 5)
Inc = 4;
}
Ca += Inc;
Ppcurr += Inc;
if (Ppcurr >= 256)
Codeout();
}
void Pf2(int Opcode, int H, int Q, int N, int Mask, int Filler) {
Plant(Opcode << 8 | H << 8 | Q << 7 | N);
if (Q)
Plant(Mask << 8 | Filler);
}
void Pf3(int Opcode, int Mask, int Kppp, int N) {
if (Kppp == Pc) {
if (N < 0) {
N = N & 0x7FFFFFFF;
Notecref(Ca, N);
}
N = (N - Ca) / 2;
}
Code[Ppcurr] = Opcode | (unsigned)Mask >> 3 & 1;
Code[Ppcurr + 1] =
(Mask & 7) << 5 | Kppp << 2 | ((unsigned)N >> 16 & 3);
Ppcurr += 2;
Ca += 2;
if (Kppp <= 5) {
Code[Ppcurr] = (unsigned)N >> 8 & 255;
Code[Ppcurr + 1] = N & 255;
Ppcurr += 2;
Ca += 2;
}
if (Ppcurr >= 256)
Codeout();
}
void Notecref(int Ca, int N) {
Listf *Cell;
Cell = &Aslist[Crefhead];
if (Crefhead == 0 || Cell->S3 != 0) {
Push(&Crefhead, Ca, 0, 0);
return;
}
if (!Cell->S2)
Cell->S2 = Ca;
else
Cell->S3 = Ca;
}
void Pclod(int From, int To) { int I; }
void Cnop(int I, int J) {
while ((Ca & (J - 1)) != I)
Psf1(Junc, 0, 1);
}
void Pgla(int Bdry, int L, int Infadr) {
int I;
int J;
J = Glaca;
Glaca = (J + Bdry - 1) & (-Bdry);
Glacurr = Glacurr + Glaca - J;
if (L + Glacurr > 256) {
if (!Inhcode)
Lput(2, Glacurr, Glacabuf, Addr(Glabuf[0]));
Glacurr = 0;
Glacabuf = Glaca;
}
for (I = 0; I <= L - 1; I++)
Glabuf[Glacurr + I] = *Byteinteger(I + Infadr);
Glaca += L;
Glacurr += L;
}
void Plug(int Area, int At, int Value, int Bytes) {
int *Wcabuf;
int I;
int Relad;
int Bufad;
Wcabuf = &Cabuf;
Bufad = Addr(Code[0]);
if (Area == 2) {
Wcabuf = &Glacabuf;
Bufad = Addr(Glabuf[0]);
}
Relad = At - *Wcabuf;
if (0 <= Relad && Relad <= 256 && Area <= 3)
for (I = 0; I <= Bytes - 1; I++)
*Byteinteger(Relad + Bufad + I) =
(unsigned)Value >> ((Bytes - 1 - I) << 3);
else {
if (Relad == -2)
Codeout();
if (!Inhcode)
Lput(Area, Bytes, At, Addr(Value) + 4 - Bytes);
if (Dcomp == 1 && 1 == Area)
Ncode(Addr(Value) + 4 - Bytes, Addr(Value) + 4, At);
}
}
int Paramdes(int Prec) {
int K;
int Des;
K = Desads[Prec];
if (K)
return (K);
if (Prec == 4)
Des = 0x58000002;
else
Des = Prec << 27 | 1;
Storeconst(&K, 4, Addr(Des));
Desads[Prec] = K;
return (K);
}
int Mapdes(int Prec) {
int K;
int Des0;
int Des1;
K = Desads[Prec + 8];
if (K)
return (K);
if (Prec == 4)
Des0 = 0x58000002;
else
Des0 = 0x03000000 | Prec << 27;
Des1 = 0;
Storeconst(&K, 8, Addr(Des0));
Desads[Prec + 8] = K;
return (K);
}
int Specialconsts(int Which) {
static int Scs[6 /*0:5*/] = {0x40800000, 0, 0x41100000, 0, 1, 0};
int K;
K = Desads[Which + 16];
if (K)
return (K);
Storeconst(&K, 8, Addr(Scs[2 * Which]));
Desads[Which + 16] = K;
return (K);
}
void Storeconst(int *D, int L, int Ad) {
int I;
int J;
int K;
int C1;
int C2;
int C3;
int C4;
int Lp;
Lp = L / 4;
C2 = 0;
C3 = 0;
C4 = 0;
for (I = 0; I <= L - 1; I++)
*Byteinteger(Addr(C1) + I) = *Byteinteger(Ad + I);
if (Parmopt)
goto Skip;
K = Constbtm;
if (L == 4) {
while (K < Constptr) {
// %IF CTABLE_val(K)=C1 %AND CONSTHOLE#K %THEN D=4*K!16_80000000 %AND %RETURN
if (Ctable->Val[K] == C1 && Consthole != K) {
*D = 4 * K | 0x80000000;
return;
}
K++;
}
} else {
J = Constptr - Lp;
while (K <= J) {
// %IF CTABLE_val(K)=C1 %AND CTABLE_val(K+1)=C2 %AND (CONSTHOLE<K %OR CONSTHOLE>=K+LP) %START
if (Ctable->Val[K] == C1 && Ctable->Val[K+1] == C2 &&
(Consthole < K || Consthole >= K + Lp))
// %IF L=8 %OR (CTABLE_val(K+2)=C3 %AND CTABLE_val(K+3)=C4) %THEN D=4*K!16_80000000 %AND %RETURN
if (L == 8 || (Ctable->Val[K+2] == C3 && Ctable->Val[K+3] == C4)) {
*D = 4 * K | 0x80000000;
return;
}
K += 2;
}
}
Skip:;
if (L == 4 && Consthole != 0) {
// CTABLE_val(CONSTHOLE)=C1
Ctable->Val[Consthole] = C1;
*D = 4 * Consthole | 0x80000000;
Consthole = 0;
return;
}
if (L > 4 && (Constptr & 1) != 0) {
Consthole = Constptr;
Constptr++;
}
*D = 4 * Constptr | 0x80000000;
// CTABLE_val(CONSTPTR)=C1
Ctable->Val[Constptr] = C1;
// CTABLE_val(CONSTPTR+1)=C2
Ctable->Val[Constptr] = C2;
if (L == 16) {
// %IF L=16 %THEN CTABLE_val(CONSTPTR+2)=C3 %AND CTABLE_val(CONSTPTR+3)=C4
Ctable->Val[Constptr+2] = C3;
Ctable->Val[Constptr+3] = C4;
}
Constptr += Lp;
if (Constptr > Constlimit)
Fault(107, 0);
}
void Getenv(int *Head) {
int I;
int Use;
for (I = 0; I <= 7; I++) {
Use = Gruse[I] & 0xFF;
if (Use)
Push(Head, Grinf1[I], Grat[I], I << 8 | Use);
}
}
void Restore(int Head) {
int I;
int R;
int Use;
int Inf;
int At;
for (I = 0; I <= 7; I++)
if (Register[I] >= 0) {
Gruse[I] = 0;
Grinf1[I] = 0;
}
while (Head) {
Pop(&Head, &Inf, &At, &I);
R = (unsigned)I >> 8;
Use = I & 255;
if (Register[R] >= 0) {
Gruse[R] = Use;
Grinf1[R] = Inf;
}
Grat[R] = At;
}
}
void Relocate(int Glarad, int Value, int Area) {
if (Glarad < 0) {
Pgla(4, 4, Addr(Value));
Glarad = Glaca - 4;
}
Lput(19, 2, Glarad, Area);
}
void Gxref(_imp_string Name, int Mode, int Xtra, int At) {
int Lputno;
if (Mode == 2)
Lputno = 15;
else
Lputno = Mode + 12;
Lput(Lputno, Xtra, At, Addr(Name));
}
void Cxref(_imp_string Name, int Mode, int Xtra, int *At) {
int Z1;
int Z2;
Z1 = 0;
Z2 = 0;
Pgla(8, 8, Addr(Z1));
*At = Glaca - 8;
Gxref(Name, Mode, Xtra, *At);
}
void Codedes(int *At) {
int Desc1;
int Desc2;
Desc1 = 0xE1000000;
Desc2 = 0;
if (!Cdcount) {
Fixedgla[0] = Desc1;
*At = 0;
} else {
Pgla(8, 8, Addr(Desc1));
*At = Glaca - 8;
}
Cdcount++;
}
void Defineep(_imp_string Name, int Adr, int At, int Main) {
if (!At)
Fixedgla[1] = Adr;
else
Plug(2, At + 4, Adr, 4);
Relocate(At + 4, Adr, 1);
if (_imp_strcmp(Name, _imp_str_literal("")) != 0)
Lput(11, Main << 31 | 2, At, Addr(Name));
}
void Prologue(void) {
auto int Stringin(int Pos);
auto void Errexit(int A, int B, int C);
int I;
int K;
int L;
int Stca;
I = 0xC2C2C2C2;
Lput(4, 4, 0, Addr(I));
Sstl = 4;
for (I = 0; I <= 31; I++) {
Plabs[I] = 0;
Plink[I] = 0;
Desads[I] = 0;
}
Plabs[1] = Ca;
for (I = 0; I <= 1; I++)
Pconst(Unasspat);
Plabs[2] = Ca;
Psf1(Prcl, 0, 4);
Psf1(Jlk, 0, 1);
Pf1(Stln, 0, Tos, 0);
Pf1(St, 0, Tos, 0);
Psf1(Lxn, 1, 16);
Psf1(Raln, 0, 9);
Pf1(Call, 2, Xnb, 40);
Pf1(Junc, 0, Tos, 0);
if (Parmdbug) {
Plabs[3] = Ca;
Cxref(_imp_str_literal("S#IMPMON"), Parmdynamic, 2, &K);
Psf1(Prcl, 0, 4);
Pf1(St, 0, Tos, 0);
Psf1(Lxn, 1, 16);
Psf1(Raln, 0, 6);
Pf1(Call, 2, Xnb, K);
Pf1(Junc, 0, Tos, 0);
}
if (Parmchk == 1) {
Cnop(0, 4);
K = Ca;
Pconst(0x58000000);
Plabs[4] = Ca;
Pf3(Jat, 12, 0, 13);
Pf1(Lss, 0, Tos, 0);
Pf1(Stsf, 0, Tos, 0);
Pf1(Ldtb, 0, Pc, K);
Pf1(Lda, 0, Tos, 0);
Pf1(Asf, 0, Breg, 0);
Psf1(Myb, 0, 4);
Pf1(Ldb, 0, Breg, 0);
Pf2(Mvl, 1, 1, 0, 0, Unasspat & 255);
Pf1(St, 0, Tos, 0);
Pf1(Junc, 0, Tos, 0);
}
if (Parmopt)
Errexit(5, 0x801, 0);
Errexit(6, 0x504, 0);
Errexit(7, 0x505, 1);
if (Parmopt)
Errexit(8, 0x201, 0);
Errexit(9, 0x601, 0);
Errexit(10, 21, 0);
if (Parmopt)
Errexit(11, 0x501, 0);
Errexit(12, 0x701, 0);
if (Parmopt)
Errexit(13, 36, 0);
// CTABLE_val(0)=16_18000001
Ctable->Val[0] = 0x18000001;
// CTABLE_val(1)=4
Ctable->Val[1] = 4;
// STCA=8; L=ADDR(CTABLE_val(0))
Stca = 8;
L = Addr(Ctable->Val[0]);
Constptr = 2;
while (Strlink) {
I = Strlink;
Strlink = Fromar4(I);
Toar4(I, Stringin(I + 4));
}
Strlink = 0x80000000;
Constbtm = Constptr;
if (Parmopt) {
// %IF PARMOPT#0 %THEN CTABLE_val(CONST PTR)=M'IDIA' %AND CONST PTR=CONST PTR+1
Ctable->Val[Constptr] = 'IDIA';
Constptr++;
}
Gxref(Mdep, Parmdynamic, 2, 40);
if (Parmprof) {
I = 0x38000001 + Line;
K = 8;
Parmprof = Glaca;
Pgla(4, 8, Addr(I));
K = 0;
for (I = 0; I <= Line; I++)
Pgla(4, 4, Addr(K));
Line = 0;
}
Level = 1;
for (I = 0; I <= 31; I++)
if (Plink[I])
Clearlist(&Plink[I]);
return;
int Stringin(int Pos) {
int J;
int K;
int Ind;
int Hd;
Listf *Cell;
K = A[Pos];
if (!K)
return (0);
Ind = K & 31;
Hd = Plink[Ind];
while (Hd) {
Cell = &Aslist[Hd];
if (Cell->S1 == K && _imp_strcmp(*String(L + Cell->S2), *String(Addr(A[Pos]))) == 0)
return (Cell->S2 - 4);
Hd = Cell->Link;
}
Hd = Stca;
*Byteinteger(L + Stca) = K;
Stca++;
for (J = Pos + 1; J <= Pos + K; J++) {
*Byteinteger(L + Stca) = A[J];
Stca++;
}
Constptr = (unsigned)((Stca + 7) & (-8)) >> 2;
Push(&Plink[Ind], K, Hd, 0);
return (Hd - 4);
}
void Errexit(int Lab, int Errno, int Mode) {
Plabs[Lab] = Ca;
if (!Mode)
Psf1(Lss, 0, 0);
else
Pf1(Lss, 0, Breg, 0);
Psf1(Luh, 0, Errno);
Psf1(Jlk, 0, (Plabs[2] - Ca) / 2);
}
}
void Css(int P) {
__label__ Bend;
auto void Mergeinfo(void);
auto void Reduceenv(int *Head);
auto void Enterjump(int Mask, int Stad, int Flag);
auto int Enterlab(int M, int Flag);
auto void Removelab(int Lab);
auto void Cend(int Kkk);
auto int Ccond(int Cto, int A, int B);
auto void Checkstof(void);
auto int Reverse(int Mask);
auto void Setline(void);
auto int Setxorynb(int Which, int Rlevel);
auto int Xorynb(int Use, int Inf);
auto void Getinacc(int Acc, int Size, int Ac, int Area, int Disp);
auto int Areacode(void);
auto int Areacode2(int Bs);
auto void Cui(int Code);
auto void Assign(int A, int B);
auto void Cstart(int Ccres, int Mode);
auto void Ccycbody(int Ua, int Elab, int Clab);
auto void Cloop(int Alt, int Markc, int Markui);
auto void Cifthen(int Markiu, int Markc, int Markui, int Marke,
int Markr, int Skip);
auto void Createah(int Mode);
auto void Torp(int *Head, int *Bot, int *Nops);
auto int Intexp(int *Value);
auto int Constexp(int Prectype);
auto void Csexp(int Reg, int Mode);
auto void Cstrexp(int A, int B);
auto void Cres(int Lab);
auto void Expop(int A, int B, int C, int D);
auto void Testapp(int *Num);
auto void Skipexp(void);
auto void Skipapp(void);
auto void Noapp(void);
auto int Dopevector(int A, int B, int Mode, int Id, int *C, int *D);
auto void Declarearrays(int A, int B);
auto void Declarescalars(int A, int B);
auto void Makedecs(int Q);
auto void Saveauxstack(void);
auto void Resetauxstack(void);
auto void Crspec(int M);
auto void Cfplist(int *A, int *B);
auto void Cfpdel(void);
auto void Clt(void);
auto void Cqn(int P);
auto void Getwsp(int *Place, int Size);
auto void Returnwsp(int Place, int Size);
auto int Tsexp(int *Value);
auto void Crcall(int Rtname);
auto void Nameop(int Z, int Reg, int Size, int Namep);
auto void Cname(int Z, int Reg);
auto void Caname(int Z, int Bs, int Dp);
auto void Csname(int Z, int Reg);
auto void Testass(int Reg, int Type, int Size);
auto void Copytag(int Kk);
auto void Reducetag(void);
auto void Replacetag(int Kk);
auto void Rtjump(int Code, int *L);
auto void Storetag(int Kk, int Slink);
auto void Unpack(void);
auto void Pack(int *Ptype);
auto void Diagpointer(int Level);
auto void Rdisplay(int Kk);
auto void Rhead(int Kk);
auto void Oddalign(void);
auto int Ptroffset(int Rlev);
auto void Ppj(int Mask, int N);
auto void Crformat(int *Ophead);
auto int Displacement(int Link);
auto int Copyrecordtag(int *Subs);
auto void Saveirs(void);
auto void Copydr(void);
auto void Bootout(int Reg);
auto void Changerd(int Reg);
auto void Forget(int Reg);
auto void Remember(void);
auto void Noteassment(int Reg, int Assop, int Var);
static int Sw_sw;
static void *Sw[24 /*1:24*/] = {
&&Sw_1, &&Sw_2, &&Sw_3, &&Sw_4, &&Sw_5, &&Sw_6,
&&Sw_7, &&Sw_8, &&Sw_9, &&Sw_10, &&Sw_11, &&Sw_12,
&&Sw_13, &&Sw_14, &&Sw_15, &&Sw_16, &&Sw_17, &&Sw_18,
&&Sw_19, &&Sw_20, &&Sw_21, &&Sw_22, &&Sw_23, &&Sw_24,
};
typedef struct Rd {
unsigned char Uptype;
unsigned char Ptype;
unsigned char Xb;
unsigned char Flag;
int D;
int Xtra;
} Rd;
int Sndisp;
int Acc;
int K;
int Kform;
int Stname;
int Midcell;
int Tcell;
int Nummod;
int Jj;
int Jjj;
int Kk;
int Qq;
int Marker;
int Reportui;
int Xdisp;
int Mask;
int Base;
int Area;
int Access;
int Disp;
int Extrn;
int Currinst;
int Value;
int Stringl;
int Ptype;
int I;
int J;
int Oldi;
int Usebits;
int Twsphead;
int Kkk;
int Strfnres;
int Markiu;
int Markui;
int Markc;
int Marke;
int Markr;
int Litl;
int Rout;
int Nam;
int Arr;
int Prec;
int Type;
Rd Expopnd;
Currinst = 0;
Twsphead = 0;
int Sgruse[8 /*0:7*/];
int Sgrinf[8 /*0:7*/];
goto *Sw[Sw_sw = (A[P]) - 1];
Sw_23:;
Sw_24:;
Sw_2:;
Cssexit:
Lastinst = Currinst;
while (Twsphead) {
Pop(&Twsphead, &Jj, &Kk, &Qq);
Returnwsp(Jj, Kk);
}
return;
Sw_1:;
if (Level < 2)
Fault(57, 0);
Marker = P + 1 + (A[P + 1] << 8) + A[P + 2];
P += 3;
if (A[Marker] == 1)
goto Labfnd;
if (A[Marker] == 2) {
Setline();
Cui(0);
goto Cssexit;
}
Marke = 0;
Markr = 0;
Markui = P;
Markiu = Marker + 1;
Markc = Markiu + 1;
if (A[Marker] == 3) {
Cifthen(Markiu, Markc, Markui, 0, 0, No);
goto Cssexit;
}
Cloop(A[Markiu], Markc + 2, Markui);
goto Cssexit;
Labfnd:
if (A[P] != 1 || A[P + 5] != 2)
goto Switch;
if (A[P + 6] != 2 || A[P + 7] != 2)
goto Switch;
Jj = Enterlab(Fromar2(P + 3), 0);
goto Cssexit;
Sw_5:;
if (Level < 2)
Fault(57, 0);
if (A[P + 5] == 2)
Cloop(0, P + 1, 0);
else
Cloop(6, P + 6, P + 1);
goto Cssexit;
Sw_6:;
goto Cssexit;
Sw_22:;
J = Fromar4(P + 2);
Codeout();
Dcomp = (unsigned)J >> 28;
goto Cssexit;
Sw_3:;
Markiu = P + 1;
Markc = Markiu + 3;
Markr = P + 2 + (A[P + 2] << 8) + A[P + 3];
Marke = 0;
if (A[Markr] == 3) {
Marke = Markr + 1 + Fromar2(Markr + 1);
Markui = Markr + 3;
}
Cifthen(Markiu, Markc, Markui, Marke, Markr, No);
goto Cssexit;
Sw_4:;
goto Cssexit;
Switch : {
int Head;
int Basept;
int Naps;
int Fname;
int Bits[3 /*0:2*/];
Forget(-1);
Fname = Fromar2(P + 3);
if (A[P] != 1 || A[P + 5] != 1) {
Fault2(5, 0, Fname);
goto Bend;
}
P += 3;
Testapp(&Naps);
P += 6;
if (Intexp(&Jj)) {
Fault2(41, 0, 0);
goto Bend;
}
if (Naps != 1) {
Fault2(21, Naps - 1, Fname);
goto Bend;
}
if (A[P + 1] != 2 || 2 != A[P + 2]) {
Fault2(5, 0, Fname);
goto Bend;
}
Copytag(Fname);
Head = K;
if (Oldi != Level || Type != 6) {
Fault(4, Fname);
goto Bend;
}
From123(Head, &Basept, &Kkk, &Kk);
Mlink(&Head);
if (Kkk <= Jj && Jj <= Kk)
goto Inbd;
Fault2(50, Jj, Fname);
goto Bend;
Inbd:
Q = Jj - Kkk;
while (Q >= 96) {
Mlink(&Head);
Q -= 96;
}
From123(Head, &Bits[0], &Bits[1], &Bits[2]);
Qq = (unsigned)Q >> 5;
Q = Q & 31;
Jjj = 1 << Q;
if (Bits[Qq] & Jjj)
Fault2(6, Jj, Fname);
Bits[Qq] = Bits[Qq] | Jjj;
Replace123(Head, Bits[0], Bits[1], Bits[2]);
if (Arr == 2)
Kkk = 0;
Qq = Basept + (Jj - Kkk) * 4;
Plug(2, Qq, Ca, 4);
Bend:;
}
goto Cssexit;
Sw_7:;
if (Level < 2)
Fault(57, 0);
Markiu = P + 1;
Markc = Markiu + 3;
Cloop(A[Markiu] + 3, Markc, Markiu + 1 + Fromar2(Markiu + 1));
goto Cssexit;
Sw_8:;
if (Level < 2)
Fault(57, 0);
if (Nmdecs[Level] & 1)
Fault(40, 0);
Qq = P;
P += 5;
Clt();
Rout = 0;
Litl = 0;
if (A[P] != 1) {
if (Type == 5 && Acc == 0)
Fault(70, 0);
Nam = 0;
Setline();
Qq = 2 - A[P + 1];
P += 2;
Declarearrays(Qq, 0);
} else if (A[Qq + 1] == 128) {
Cqn(P + 1);
P += 2;
Declarescalars(1, 0);
}
goto Cssexit;
Sw_9:;
{
__label__ Bend;
static int S_sw;
static void *S[5 /*1:5*/] = {
&&S_1, &&S_2, &&S_3, &&S_4, &&S_default,
};
goto *S[S_sw = (A[P + 1]) - 1];
S_1:;
S_2:;
if (!Cprmode)
Cprmode = 2;
if (Level + Cprmode != 3)
Fault(15, 0);
if (A[P + 1] != Cprmode)
Fault(56, 0);
Cend(Cprmode);
goto Bend;
S_3:;
List = 0;
goto Bend;
S_4:;
Cend(Flag[Level]);
Bend:;
goto S_skip;
S_default:
fprintf(stderr, "\nSwitch label 'S(%d):' not set in %s\n", S_sw + 1,
__PRETTY_FUNCTION__);
fflush(stderr);
abort();
S_skip:;
}
goto Cssexit;
Sw_11:;
{
__label__ Bend;
int Marker1;
int Kk;
int Kkk;
_imp_string Xname;
P++;
Marker1 = Fromar2(P) + P;
Agn:
Q = P;
Kk = Fromar2(Marker1 + 5);
Extrn = A[P + 2];
Litl = Extrn & 3;
if (A[Marker1] == 1) {
P += 3;
Crspec(1 - ((unsigned)Extrn >> 2));
goto Bend;
}
Copytag(Kk);
if (Oldi == Level) {
if (!Cprmode)
Cprmode = 2;
if (Cprmode == 2 && Level == 1) {
if (Extrn == 3)
Extrn = 2;
Xname = *String(Dictbase + Word[Kk]);
if (Extrn == 1)
Xname = _imp_join(_imp_str_literal("S#"), Xname);
if (Extrn == 4)
Xname = _imp_str_literal("");
Jj = Midcell;
if (Extrn != 4)
Usebits = 2;
Defineep(Xname, Ca, Jj, 0);
if (Jj)
Psf1(Inca, 0, -Jj);
} else {
if (Extrn != 4)
Fault(55, Kk);
Extrn = 4;
}
if (A[P + 3] == 1)
Kkk = Litl << 14 | 0x1000;
else {
Rout = 1;
P += 4;
Clt();
Arr = 0;
Nam = 0;
if (A[P] == 2)
Nam = 2;
Pack(&Kkk);
}
}
if (Oldi != Level || J != 15 || Ptype != Kkk) {
P = Q + 3;
Crspec(0);
P = Q;
goto Agn;
}
Ptype = Ptype | (Extrn & 3) << 14;
{
int Ptr;
int Ptypep;
int Cnt;
int Pp;
J = 0;
Replacetag(Kk);
Jj = K;
Plabel--;
if (Compiler != 1 && (Cprmode != 2 || Level != 1))
if (!Jround[Level + 1]) {
Jround[Level + 1] = Plabel;
Enterjump(15, Plabel, 0);
}
Ptypep = Ptype;
P = Marker1 + 7;
Rhead(Kk);
N = 20;
Cnt = 1;
while (A[P] == 1) {
Pp = P + 1 + Fromar2(P + 1);
P += 3;
Cfpdel();
Ptr = P;
do {
if (Jj) {
From12(Jj, &J, &Jjj);
if ((unsigned)J >> 16 != Ptype ||
(Ptype == 5 && (unsigned)Jjj >> 16 != Acc))
Fault2(9, Cnt, Kk);
} else
Fault2(8, 0, Kk);
Ptr += 3;
Cnt++;
Mlink(&Jj);
} while (A[Ptr - 1] != 2);
Declarescalars(0, 0);
P = Pp;
}
N = (N + 3) & (-4);
if (Jj)
Fault2(10, 0, Kk);
Ptype = Ptypep;
if ((Ptype & 0xF0F) == 5)
N += 8;
Rdisplay(Kk);
Makedecs(Marker1 + 1);
}
Bend:;
}
goto Cssexit;
Sw_13:;
if (Cprmode)
Fault(58, 0);
Alllong = A[P + 1] & 1;
goto Cssexit;
Sw_14:;
{
Ptype = 0;
if (Level == 1 && Rlevel == 0 && Cprmode == 0) {
Codedes(&Jj);
Defineep(Mainep, Ca, Jj, 1);
Rlevel = 1;
Rbase = 1;
L[1] = 0;
M[1] = 0;
Diaginf[1] = 0;
Auxsbase[1] = 0;
Cprmode = 1;
N = 24;
Nmax = N;
Forget(-1);
Diagpointer(Level + 1);
Psf1(Std, 1, 12);
Psf1(Lxn, 1, 16);
Pf1(Stln, 0, Xnb, 20);
Pf1(Stln, 0, Tos, 0);
Pf1(Lss, 0, Tos, 0);
Psf1(Iad, 0, 24);
Pf1(Stsf, 0, Tos, 0);
Pf1(Isb, 0, Tos, 0);
Psf1(Ish, 0, -2);
Pf1(St, 0, Breg, 0);
Pf1(Asf, 0, Breg, 0);
Pf1(Mpsr, 0, 0, 0x40C0);
Ptype = 1;
} else
Setline();
Rhead(-1);
Rdisplay(-1);
Makedecs(P + 1);
}
goto Cssexit;
Sw_15:;
if (Level < 2)
Fault(57, 0);
if (Nmdecs[Level] & 1)
Fault(40, 0);
Nmdecs[Level] = Nmdecs[Level] | 0x11;
if (!Stack) {
Saveauxstack();
Disp = Auxsbase[Level];
Psf1(Lss, 2, Disp);
Psf1(St, 1, Disp + 12);
}
Gruse[Accr] = 0;
Psf1(Cpsr, 1, N + 8);
Plabel--;
Jjj = Plabel;
Enterjump(15, Jjj, 0b10);
P += 2;
Jj = 0;
do {
Kk = A[P];
if (1 > Kk || Kk > 14)
Fault2(26, Kk, 0);
Jj = Jj | 1 << (Kk - 1);
P += 2;
} while (A[P - 1] != 2);
Kk = Ca;
Pgla(4, 4, Addr(Ca));
Relocate(Glaca - 4, Kk, 1);
Onword[Level] = Jj << 18 | (Glaca - 4);
Forget(-1);
Psf1(St, 1, N);
Psf1(Mpsr, 1, N + 8);
Oninf[Level] = N;
N += 12;
if (!Stack) {
Psf1(Lss, 1, Disp + 12);
Psf1(St, 2, Disp);
}
Cstart(0, 3);
Nmdecs[Level] = Nmdecs[Level] ^ 0x10;
Jj = Enterlab(Jjj, 0b111);
goto Cssexit;
Sw_16:;
if (Level < 2)
Fault(57, 0);
{
int Q;
int Range;
int Kkk;
int Kk;
int Lb;
int Pp;
int D0;
int D1;
int Ophead;
int V;
int Arrp;
int R;
Q = P;
Arrp = 1;
if (!Parmopt)
Arrp = 2;
do {
P += 3;
while (A[P] == 1)
P += 3;
P += 4;
Kkk = Intexp(&Lb);
P += 3;
Kkk = Kkk | Intexp(&Kk);
Range = (Kk - Lb + 1);
if (Range <= 0 || Kkk != 0) {
Fault2(38, 1 - Range, Fromar2(Q + 1));
Lb = 0;
Kk = 10;
Range = 11;
}
if (Glaca + 8 - 4 * Lb < 0)
Arrp = 1;
Ptype = 0x56 + (Arrp << 8);
Pp = P;
P = Q + 1;
do {
K = Fromar2(P);
P += 3;
Ophead = 0;
R = Lb;
do {
Push(&Ophead, 0, 0, 0);
R += 96;
} while (R <= Kk);
D1 = (Glaca + 15) & (-8);
D0 = 0x28000000 | Range;
if (Arrp == 2) {
if (Lb)
D0 = D0 | 0x01000000;
D1 -= 4 * Lb;
}
Pgla(8, 8, Addr(D0));
Sndisp = ((unsigned)Glaca >> 2) - 2;
Relocate(Glaca - 4, D1, 2);
Push(&Ophead, D1, Lb, Kk);
Kform = 0;
Acc = 4;
J = 1;
Storetag(K, Ophead);
V = Plabs[6];
for (Kkk = Lb; Kkk <= Kk; Kkk++) {
Relocate(-1, V, 1);
}
} while (A[P - 1] != 2);
Q = Pp;
P = Q;
} while (A[Q] != 2);
}
goto Cssexit;
Sw_17:
List = 1;
goto Cssexit;
Sw_12:;
{
__label__ Bend;
auto void Clear(int L);
auto void Stag(int J, int Datalen);
auto void Xtractconst(int Contype, int Conprec);
auto void Initspace(int A, int B);
int Length;
int Bp;
int Pp;
int Sign;
int Cbase;
int Mode;
int Uiconst;
int Iconst;
int Tagdisp;
int Eptype;
int Epdisp;
int Ah1;
int Ah2;
int Ah3;
int Ah4;
int Ad;
int Fnam;
int Finf;
int Spoint;
int Constsfound;
int Cprec;
int Extrn;
int Nnames;
int Mark;
int Lputp;
int Marker1;
int Lb;
int Ctype;
int Constp;
int Format;
int Ptsize;
int Dimen;
int Sacc;
int Typep;
double Rconst;
double Lrconst;
static double Zero = 0;
_imp_string Sconst;
_imp_string Namtxt;
int *Stptr;
Lputp = 5;
Stptr = &Ustptr;
Extrn = A[P + 1];
if (Extrn >= 4)
Extrn = 0;
Litl = Extrn;
if (Litl <= 1)
Litl = Litl ^ 1;
Kform = 0;
Sndisp = 0;
Constsfound = 0;
if (!Extrn) {
Lputp = 4;
Stptr = &Sstl;
}
P += 3;
Cbase = 0;
Mode = A[P - 1];
if (Mode > 1)
goto Record;
Clt();
if (A[P] == 1)
Cqn(P + 1);
else {
Arr = 1;
Nam = 0;
}
if (Type == 5 && Acc == 0 && 0 == Nam) {
Fault(70, 0);
Acc = 2;
}
Rout = 0;
Pack(&Ptype);
if (Arr != 0 && Nam == 0)
goto Nonscalar;
P++;
do {
Mark = P + 1 + Fromar2(P + 1);
Nnames = 1;
Pp = P + 3;
P = Pp + 2;
while (A[P] == 1) {
Nnames++;
P += 3;
}
P++;
Iconst = 0;
Uiconst = 0;
Rconst = 0;
Lrconst = 0;
Sconst = _imp_str_literal("");
Sign = 3;
Ctype = Type;
Constsfound = 0;
Cprec = Prec;
if (Nam) {
Ctype = 1;
Cprec = 5;
}
if (A[P] == 1) {
P++;
Xtractconst(Ctype, Cprec);
}
do {
J = 0;
K = Fromar2(Pp);
Namtxt = *String(Dictbase + Word[K]);
if (Nam) {
if (Extrn == 3)
Fault2(46, 0, K);
Uiconst = 0xFFFF | Prec << 27;
Pgla(8, Acc, Addr(Uiconst));
Tagdisp = Glaca - Acc;
Epdisp = Tagdisp;
} else if (Type == 5) {
Qq = *Stptr;
Ad = Addr(Sconst);
if (Extrn == 3) {
Ah3 = 0;
Ah2 = Prec << 27 | Acc;
} else {
if (!Inhcode)
Lput(Lputp, Acc, Qq, Ad);
*Stptr = (*Stptr + Acc + 3) & (-4);
Ah3 = Qq;
Ah2 = 3 << 27 | Acc;
}
Pgla(8, 8, Addr(Ah2));
Tagdisp = Glaca - 8;
if (Extrn == 3)
Gxref(Namtxt, 2, 2 << 24 | Acc, Tagdisp + 4);
else
Relocate(Tagdisp + 4, Ah3, Lputp);
Eptype = 5;
Epdisp = Qq;
} else if (Extrn == 3) {
Ptype = Ptype | 1 << 10;
Ah2 = Prec << 27;
Ah3 = 0;
Pgla(8, 8, Addr(Ah2));
Tagdisp = Glaca - 8;
Gxref(Namtxt, 2, 2 << 24 | Acc, Tagdisp + 4);
} else {
if (Type == 2)
Ad = Addr(Rconst);
else
Ad = Addr(Iconst) + 4 - Acc;
if (Extrn)
Pgla(Acc, Acc, Ad);
Tagdisp = Glaca - Acc;
Epdisp = Tagdisp;
Eptype = 2;
}
Stag(Tagdisp, Acc);
if (Extrn == 0 && 0 == Nam) {
Replace2(Tags[K], *Integer(Ad & (-4)));
if (Prec == 6)
Replace3(Tags[K], *Integer(Ad + 4));
if (Prec == 7)
Replace3(Tags[K], Constp);
}
Pp += 3;
Nnames--;
} while (Nnames);
P = Mark;
} while (A[Mark] != 2);
goto Bend;
Record:;
Marker1 = P + 1 + Fromar2(P + 1);
Fnam = Fromar2(Marker1);
Copytag(Fnam);
Finf = Tcell;
if (Ptype != 4) {
Fault(62, Fnam);
goto Bend;
}
Ptype = 0x133 | Litl << 14;
Kform = Finf;
Unpack();
if (Mode == 3) {
Format = 2 - A[P];
P += 2;
goto Recin;
}
P++;
Bp = Acc;
Ptype = 0x33;
J = 0;
if (A[P - 1] != 3) {
Cqn(P - 1);
Pack(&Ptype);
}
P++;
Ptsize = Acc;
do {
P++;
K = Fromar2(P);
Namtxt = *String(Dictbase + Word[K]);
if (Nam) {
if (Extrn == 3)
Fault2(46, 0, K);
Uiconst = 0xFFFF | Prec << 27;
Pgla(8, Ptsize, Addr(Uiconst));
Eptype = 2;
Tagdisp = Glaca - Ptsize;
Epdisp = Tagdisp;
} else if (Extrn == 3) {
Ptype = Ptype | 0x400;
Ah2 = 0x18000000 + Bp;
Ah3 = 0;
Pgla(8, 8, Addr(Ah2));
Tagdisp = Glaca - 8;
Gxref(Namtxt, 2, 2 << 24 | Bp, Tagdisp + 4);
} else {
Epdisp = (Glaca + 15) & (-8);
Ah3 = Epdisp;
Ah2 = 0x18000000 + Bp;
Pgla(8, 4, Addr(Ah2));
Relocate(-1, Ah3, 2);
Tagdisp = Epdisp;
Eptype = 2;
I = 0;
Iconst = 0;
while (I < Bp) {
Pgla(4, 4, Addr(Iconst));
I += 4;
}
}
Acc = Bp;
Stag(Tagdisp, Bp);
P += 2;
} while (A[P] != 2);
goto Bend;
Nonscalar:;
P++;
Format = 2 - A[P];
Recin:
Pp = P + 1;
P += 3;
Nnames = 1;
K = Fromar2(Pp);
Namtxt = *String(Dictbase + Word[K]);
if (Type >= 3)
Bp = Acc;
else
Bp = Bytes[Prec];
Sacc = Acc;
Typep = Ptype;
Ah4 = 12 + Dopevector(Type, Bp, 0, K, &Qq, &Lb);
Sndisp = Ah4 - 12;
if (Sndisp == -1)
Sndisp = 0;
Sndisp = (unsigned)(Sndisp & 0x3FFFF) >> 2;
Dimen = J;
Acc = Sacc;
Ptype = Typep;
Unpack();
if (Lb == 0 && J == 1 && Type <= 3) {
Arr = 2;
Pack(&Ptype);
}
Length = Qq / Bp;
Spoint = *Stptr;
if (Mode != 3 && Format == 0)
if (A[P] == 1) {
P++;
Initspace(Qq, Length);
}
if (!Constsfound) {
Constsfound = Length;
if (Length >= 1 && Extrn != 3 && Format == 0)
Clear(Qq);
} else if (Extrn == 3 || Format != 0)
Fault2(49, 0, K);
if (Extrn == 3)
Epdisp = 0;
else
Epdisp = Spoint;
J = Dimen;
if (Type <= 2)
Ah1 = Prec << 27 | Length;
else
Ah1 = 3 << 27 | 1 << 25 | Qq;
Ah1 = Ah1 | (1 - Parmarr) << 24;
if (Prec == 4)
Ah1 = 0x58000002;
Ah2 = Epdisp;
Ah3 = 5 << 27 | 3 * J;
if (Type <= 3 && Parmarr == 0 && 0 == Format && Parmchk == 0 &&
J == 1)
Ah2 -= Bp * Lb;
Pgla(8, 16, Addr(Ah1));
Tagdisp = Glaca - 16;
if (Extrn == 3) {
Gxref(Namtxt, 2, 2 << 24 | Qq, Tagdisp + 4);
} else {
Relocate(Tagdisp + 4, Ah2, Lputp);
}
Relocate(Tagdisp + 12, Ah4, 1);
Ah4 = ((unsigned)Ah4 << 1 >> 3) | 0x80000000;
Notecref(Ah4 | (unsigned)(Tagdisp + 12) >> 2 << 16, (Ah4 & 0xFFFF)
<< 2);
Eptype = 5;
Stag(Tagdisp, Qq);
goto Bend;
void Initspace(int Size, int Nels) {
int Rf;
int I;
int K;
int Elsize;
int Ad;
int Spp;
int Length;
int Saver;
int Wsize;
int Writ;
if (Size > 4096)
Wsize = 4096;
else
Wsize = Size;
Saver = R;
R = R + Wsize + 256;
if (R > Arsize)
Fault(102, 0);
unsigned char Sp[(Wsize + 256) + 1];
if (Type == 1)
Ad = Addr(Iconst) + 4 - Acc;
if (Type == 2)
Ad = Addr(Rconst);
if (Type == 5)
Ad = Addr(Sconst);
Spp = 0;
Writ = 0;
Elsize = Size / Nels;
do {
Xtractconst(Type, Prec);
if (A[P] == 1) {
P++;
if (Intexp(&Rf)) {
Fault(44, Constsfound);
Rf = 1;
}
P++;
} else {
Rf = 1;
P += 2;
}
if (Rf <= 0)
Fault(44, Constsfound);
for (I = Rf; I >= 1; I--) {
for (K = 0; K <= Elsize - 1; K++)
if (Constsfound <= Nels) {
Sp[Spp] = *Byteinteger(Ad + K);
Spp++;
}
Constsfound++;
if (Spp >= 4096) {
if (!Inhcode)
Lput(Lputp, Spp, *Stptr + Writ, Addr(Sp[0]));
Writ += Spp;
Spp = 0;
}
}
} while (A[P - 1] != 2);
if (Constsfound != Nels)
Fault(45, Constsfound);
*Stptr = (*Stptr + 3) & (-4);
Length = (Size + 3) & (-4);
if (!Inhcode)
Lput(Lputp, Length - Writ, *Stptr + Writ, Addr(Sp[0]));
*Stptr = *Stptr + Length;
R = Saver;
}
void Clear(int Length) {
*Stptr = (*Stptr + 3) & (-4);
Length = (Length + 3) & (-4);
if (!Inhcode)
Lput(Lputp, Length, *Stptr, 0);
*Stptr = *Stptr + Length;
}
void Stag(int J, int Datalen) {
if (Extrn == 2)
Lput(14, Eptype << 24 | Datalen, Epdisp, Addr(Namtxt));
Rbase = Cbase;
Storetag(K, J);
Rbase = Rlevel;
}
void Xtractconst(int Contype, int Conprec) {
int Length;
int Stype;
int Sprec;
int Sacc;
int Cprec;
int Mode;
int I;
Stype = Ptype;
Sacc = Acc;
if (Contype == 5) {
Ctype = 5;
if (A[P] == 4 && A[P + 1] == 2 && A[P + 2] == 0x35 &&
A[P + A[P + 7] + 8] == 2) {
Sconst = *String(Addr(A[P + 7]));
Length = A[P + 7];
P = P + A[P + 7] + 9;
} else {
Fault(44, Constsfound);
Sconst = _imp_str_literal("");
Length = 0;
P -= 3;
Skipexp();
}
} else {
Mode = Conprec << 4 | Contype;
if (Conprec < 5)
Mode = Contype | 0x50;
Constp = Constexp(Mode);
if (!Constp) {
Fault(41, 0);
Constp = Addr(Zero);
}
Ctype = Type;
Cprec = Prec;
if (Ctype == 1) {
Iconst = *Integer(Constp);
if (Conprec == 6) {
Uiconst = Iconst;
Iconst = *Integer(Constp + 4);
}
} else {
Rconst = *Longreal(Constp);
if (Conprec == 7)
for (I = 0; I <= 15; I++)
*Byteinteger(Addr(Rconst) + I) = *Byteinteger(Constp + I);
}
}
Ptype = Stype;
Unpack();
Acc = Sacc;
if (Extrn == 3 || (Ctype == 5 && Length >= Acc) ||
(Contype == 1 && ((Conprec == 3 && Iconst > 255) ||
(Conprec == 4 && Iconst > 0xFFFF))))
Fault(44, Constsfound);
}
Bend:;
}
goto Cssexit;
Sw_18:;
Abort();
Sw_10:;
{
__label__ Bend;
int Mode;
int Recl;
int Alloc;
int Fnam;
int Finf;
int Name;
int Ophead;
P++;
Mode = A[P];
Sndisp = 0;
if (Mode == 1) {
Name = Fromar2(P + 1);
P += 3;
Crformat(&Ophead);
K = Name;
Ptype = 4;
J = 0;
Kform = Ophead;
Storetag(K, Ophead);
goto Bend;
}
P++;
Marker = P + Fromar2(P);
Fnam = Fromar2(Marker);
Copytag(Fnam);
Finf = Tcell;
if (Type != 4) {
Finf = Dummyformat;
Acc = 4;
Fault(62, Fnam);
}
Recl = Acc;
if (Mode == 2) {
Copytag(Fromar2(P + 2));
if (A[P + 4] == 1 && Type == 4) {
P += 5;
Q = Displacement(Tcell);
Unpack();
}
if (Type == 3 && Nam == 1 && (From3(Tcell) & 0xFFFF) == 0) {
Replace3(Tcell, Finf | K << 16);
Replace2(Tcell, Sndisp << 16 | Recl);
} else
Fault(63, 0);
} else {
if (Level < 2)
Fault(57, 0);
if (Nmdecs[Level] & 1)
Fault(40, 0);
Type = 3;
Prec = 3;
Rout = 0;
if (A[P + 2] == 1) {
Alloc = Acc;
Cqn(P + 3);
Acc = Alloc;
P += 4;
Declarescalars(1, Finf);
} else {
Nam = 0;
Q = 2 - A[P + 3];
P += 4;
Setline();
Declarearrays(Q, Finf);
}
}
Bend:;
}
goto Cssexit;
Sw_19:;
if (Level < 2)
Fault(57, 0);
{
auto void Cind(void);
int Fname;
int Alt;
int Opcode;
int Form;
int H;
int Q;
int Mask;
int Filler;
static int Sw_sw;
static void *Sw[5 /*1:5*/] = {
&&Cind_Sw_1, &&Cind_Sw_2, &&Cind_Sw_3, &&Cind_Sw_4, &&Cind_Sw_5,
};
static int F_sw;
static void *F[3 /*1:3*/] = {
&&F_1,
&&F_2,
&&F_3,
};
static int Pop_sw;
static void *Pop[6 /*1:6*/] = {
&&Pop_1, &&Pop_2, &&Pop_3, &&Pop_4, &&Pop_5, &&Pop_6,
};
static int Top_sw;
static void *Top[4 /*1:4*/] = {
&&Top_1,
&&Top_2,
&&Top_3,
&&Top_4,
};
Alt = A[P + 1];
P += 2;
Opcode = Call;
goto *Sw[Sw_sw = (Alt)-1];
Cind_Sw_1:
Cind_Sw_2:;
Fname = Fromar2(P);
Copytag(Fname);
if (Rout != Nam || Nam != 0 || Arr != 0 || Prec <= 4 || I != Rbase ||
Type == 7)
Fault(33, Fname);
if (Alt == 1)
Psf1(St, 1, K);
else
Getinacc(Accr, (unsigned)Bytes[Prec] >> 2, 0, Lnb, K);
goto Exit;
Cind_Sw_3:;
Type = A[P];
Prec = (unsigned)Type >> 4;
Type = Type & 7;
if (Type != 1 || Prec >= 6)
Fault(32, 0);
if (Prec == 5)
P += 2;
Plant(Fromar2(P + 1));
goto Exit;
Cind_Sw_5:;
Cnop(A[P], A[P + 1]);
goto Exit;
Cind_Sw_4:;
Form = A[P];
Opcode = A[P + 1];
P += 2;
goto *F[F_sw = (Form)-1];
F_1:;
Alt = A[P];
P++;
goto *Pop[Pop_sw = (Alt)-1];
Pop_1:;
Fname = Fromar2(P);
P += 2;
Enterjump(Opcode << 24 | 3 << 23, Fname, 0);
goto Exit;
Pop_2:;
Cind();
Popi:
Psorlf1(Opcode, Access, Area, Disp);
goto Exit;
Pop_3:;
Cind();
Access = 4 - A[P];
P++;
goto Popi;
Pop_4:;
Cind();
Access = 1;
goto Popi;
Pop_5:;
Access = 4 - A[P];
Area = 7;
Disp = 0;
P++;
goto Popi;
Pop_6:;
Access = 0;
Area = 7;
Disp = 0;
goto Popi;
F_2:;
Mask = 0;
Filler = 0;
Q = 0;
Fname = 0;
H = 2 - A[P];
if (!H) {
Fname = Fromar2(P + 1) - 1;
P += 2;
}
if (0 > Fname || Fname > 127)
Fault(32, 0);
Alt = A[P + 1];
P += 2;
if (Alt == 1) {
Q = 1;
Mask = Fromar2(P);
Filler = Fromar2(P + 2);
P += 4;
if (0 > (Mask | Filler) || (Mask | Filler) > 255)
Fault(32, 0);
}
Pf2(Opcode, H, Q, Fname, Mask, Filler);
goto Exit;
F_3:;
Mask = Fromar2(P);
Alt = A[P + 2];
if (0 > Mask || Mask > 15)
Fault(32, 0);
P += 3;
goto *Top[Top_sw = (Alt)-1];
Top_1:;
Fname = Fromar2(P);
P += 2;
Enterjump(Opcode << 24 | Mask << 21, Fname, 0);
goto Exit;
Top_2:;
Cind();
if (Area >= 6)
Fault(32, 0);
if (Area == Lnb || Area == Xnb || Area == Ctb)
Disp = Disp / 4;
Topi:
Pf3(Opcode, Mask, Area, Disp);
goto Exit;
Top_3:;
Disp = 0;
Area = 8 - A[P];
P++;
goto Topi;
Top_4:;
Disp = Fromar2(P);
P += 2;
Area = 1;
goto Topi;
void Cind(void) {
int Alt;
int Afn;
int Fn0;
int Fn1;
int Fn2;
int Fn3;
int Jj;
int D;
int Ctype;
int Cprec;
static int Sw_sw;
static void *Sw[4 /*1:4*/] = {
&&Sw_1,
&&Sw_2,
&&Sw_3,
&&Sw_4,
};
Afn = Addr(Fn0);
Alt = A[P];
Access = 0;
P++;
goto *Sw[Sw_sw = (Alt)-1];
Sw_1:;
P++;
D = A[P];
Ctype = A[P + 1];
Cprec = (unsigned)Ctype >> 4;
Ctype = Ctype & 7;
if (Cprec == 4)
Fn0 = Fromar2(P + 2);
else
for (Jj = 0; Jj <= Bytes[Cprec] - 1; Jj++)
*Byteinteger(Afn + Jj) = A[P + Jj + 2];
P = P + 2 + Bytes[Cprec];
if (D == 2)
if (Ctype == 2)
Fn0 = Fn0 ^ 0x80000000;
else if (Cprec == 6)
*Longinteger(Afn) = -*Longinteger(Afn);
else
Fn0 = -Fn0;
Cnst:
if (Ctype != 1 || Cprec > 5 || 0xFFFE0000 > Fn0 || Fn0 > 0x1FFFF)
goto Lit;
Area = 0;
Disp = Fn0;
return;
Lit:
if (1 > Ctype || Ctype > 2 || 5 > Cprec || Cprec > 7)
Fault(32, 0);
Storeconst(&Disp, Bytes[Cprec], Afn);
Area = Pc;
Access = 0;
return;
Sw_2:;
Fn0 = Fromar2(P);
P += 2;
Copytag(Fn0);
if (Litl == 1 && Arr == 0) {
Ctype = Type;
Cprec = Prec;
Alt = Tags[Fn0];
From123(Alt, &D, &Fn0, &Fn1);
if (Cprec == 7)
Afn = Fn1;
goto Cnst;
}
if (Type >= 6 || Type == 4 || (Rout == 1 && Nam == 0)) {
Fault(33, Fn0);
return;
}
if (Rout == 1)
K = From1(K);
Area = Lnb;
if (I != Rbase)
Area = Setxorynb(Xnb, I);
Alt = A[P];
D = Fromar2(P + 1);
if (Alt == 1)
K += D;
if (Alt == 2)
K -= D;
P++;
if (Alt <= 2)
P += 2;
Disp = K;
return;
Sw_3:;
Area = A[P] + 1;
Alt = A[P + 1];
P += 2;
Disp = 0;
D = Fromar2(P);
if (Alt == 1)
Disp = D;
if (Alt == 2)
Fault(32, 0);
if (Area == Pc)
Disp = Ca + 2 * Disp;
else
Disp = 4 * Disp;
if (Alt != 3)
P += 2;
return;
Sw_4:;
Area = 6;
Disp = 0;
}
Exit:
Gruse[Accr] = 0;
Gruse[Dr] = 0;
Gruse[Breg] = 0;
if (Opcode == Call || Opcode == Lxn || Opcode == Jlk || Opcode == Out)
Gruse[Xnb] = 0;
if (Opcode == Call || Opcode == Lct || Opcode == Jlk || Opcode == Out)
Gruse[Ctb] = 0;
}
goto Cssexit;
Sw_20:;
if (Parmarr == 0 && Parmchk == 0)
Compiler = 1;
goto Cssexit;
Sw_21:;
Kk = Fromar2(P + 1);
if (Cprmode)
Fault(58, 0);
Mainep = *String(Dictbase + Word[Kk]);
goto Cssexit;
void Crformat(int *Ophead) {
int D1;
int D2;
int Nlist;
int Form;
int Rl;
int Mrl;
int Unscal;
int Sc;
int Desc;
int Fn;
int Inc;
int Q;
int R;
int A0;
int A1;
int A2;
int Dv;
int Rfd;
int Lb;
int Ob;
int Typep;
int Sacc;
static int Rfel_sw;
static void *Rfel[5 /*1:5*/] = {
&&Rfel_1, &&Rfel_2, &&Rfel_3, &&Rfel_4, &&Rfel_5,
};
auto void Sn(int Q);
auto void Round(void);
Nlist = 0;
Ophead = 0;
Form = 0;
Acc = 0;
Ob = 0;
Mrl = 0;
Inc = 0;
Next:
Rout = 0;
Litl = 0;
Nam = 0;
Rfd = A[P];
if (Rfd <= 2) {
P++;
Clt();
}
goto *Rfel[Rfel_sw = (Rfd)-1];
Rfel_1:;
Cqn(P);
P++;
Pack(&Ptype);
D2 = 0;
Rl = 3;
if (Nam == 0 && 3 <= Prec && Prec <= 4)
Rl = Prec - 3;
Agn:
Round();
J = 0;
do {
D1 = Inc;
Sn(P);
P += 3;
Inc += Acc;
} while (A[P - 1] != 2);
P += (unsigned)Rfd >> 2 << 1;
Tryend:
if (A[P] == 2)
goto End;
P++;
goto Next;
Rfel_2:
Rfel2:;
Q = P;
Arr = 1;
Pack(&Ptype);
if (Type <= 2) {
Unscal = 0;
Sc = Prec;
} else {
Unscal = 1;
Sc = 3;
}
if (Prec == 4)
Desc = 0x58000002;
else
Desc = Sc << 27 | Unscal << 25 | (1 - Parmarr) << 24;
do {
do
P += 3;
while (A[P - 1] != 2);
Typep = Ptype;
Sacc = Acc;
Dv = Dopevector(Type, Acc, 0, Fromar2(Q), &R, &Lb) + 12;
Acc = Sacc;
Ptype = Typep;
Unpack();
if (Type == 5 || (Type == 1 && Prec == 3))
Rl = 0;
else
Rl = 3;
Round();
do {
A0 = R;
if (!Unscal)
A0 = A0 / Acc;
if (Prec == 4)
A0 = 0;
A0 = A0 | Desc;
A1 = Inc;
if (Type <= 3 && Parmarr == 0 && 0 == Parmchk && J == 1)
A1 -= Lb * Acc;
A2 = 5 << 27 | 3 * J;
Pgla(4, 16, Addr(A0));
D1 = Glaca - 16;
Relocate(D1 + 12, Dv, 1);
Notecref(0x80000000 | ((unsigned)Dv << 1 >> 3) |
(unsigned)(D1 + 12) >> 2 << 16,
(Dv & 0xFFFF) << 2);
D2 = Inc;
Sn(Q);
Inc += R;
Q += 3;
} while (A[Q - 1] != 2);
P++;
Q = P;
} while (A[P - 1] != 2);
if (Rfd == 5)
P += 2;
goto Tryend;
Rfel_3:;
Type = 3;
Prec = 3;
Nam = 1;
Arr = 2 - A[P + 1];
P += 2;
Pack(&Ptype);
D2 = 0;
Rl = 3;
Acc = 8 + 8 * Arr;
Form = 0;
goto Agn;
Rfel_4:;
Rfel_5:;
Q = P + Fromar2(P + 1) + 1;
Fn = Fromar2(Q);
Copytag(Fn);
if (Ptype != 4)
Fault(62, Fn);
Type = 3;
Prec = 3;
Form = Tcell;
if (Rfd == 4) {
Ptype = 0x33;
P += 3;
D2 = 0;
Rl = 3;
goto Agn;
}
P += 3;
goto Rfel2;
End:;
Rl = Mrl;
Round();
Acc = Inc;
if (Inc > 0x7FFF)
Fault(98, 0);
Clearlist(&Nlist);
return;
void Sn(int Q) {
Fname = Fromar2(Q);
if (Find(Fname, Nlist) != -1)
Fault2(61, 0, Fname);
Binsert(Ophead, &Ob, Fname << 20 | Ptype << 4 | J, D2 << 16 | Acc,
D1 << 16 | Form);
Push(&Nlist, 0, Fname, 0);
}
void Round(void) {
if (Rl > Mrl)
Mrl = Rl;
while (Inc & Rl)
Inc++;
}
}
int Displacement(int Link) {
Listf *Fcell;
Listf *Pcell;
Listf *Lcell;
int Rr;
int Ii;
int Ename;
int Cell;
Ename = (A[P] << 8) + A[P + 1];
Cell = 0;
if (Link) {
Fcell = &Aslist[Link];
Link = Fcell->S3 & 0x7FFF;
Cell = Link;
Ii = -1;
Acc = -1;
while (Link > 0) {
Lcell = &Aslist[Link];
if ((unsigned)Lcell->S1 >> 20 == Ename) {
Tcell = Link;
Rr = Lcell->S1;
Sndisp = Lcell->S2;
K = Lcell->S3;
J = Rr & 15;
Ptype = (unsigned)Rr >> 4 & 0xFFFF;
Acc = Sndisp & 0xFFFF;
Sndisp = (Sndisp & 0xFFFF0000) / 0x10000;
Kform = K & 0xFFFF;
K = (unsigned)K >> 16;
if (Link != Cell) {
Pcell->Link = Lcell->Link;
Lcell->Link = Cell;
Fcell->S3 = Fcell->S3 & 0xFFFF0000 | Link;
}
return (K);
}
Pcell = Lcell;
Link = Lcell->Link;
}
}
Fault(65, Ename);
if (Cell > 0)
Push(&Aslist[Cell].Link, Ename << 20 | 7 << 4, 0, 0);
Ptype = 7;
Tcell = 0;
return (-1);
}
int Copyrecordtag(int *Subs) {
int Q;
int Fname;
Subs = 0;
do {
Fname = Kform;
P += 2;
Skipapp();
if (A[P] == 2 || Fname <= 0)
return (0);
Subs++;
P++;
Q = Displacement(Fname);
Unpack();
} while (Type == 3);
return (Q + 1);
}
void Crname(int Z, int Reg, int Mode, int Bs, int Ar, int Dp,
int *Namep) {
int Depth;
int Fname;
auto void Cename(int Mode, int Fname, int Bs, int Ar, int Dp, int Xd);
Depth = 0;
Fname = Kform;
if (Arr == 0 || (Z == 6 && A[P + 2] == 2)) {
if (A[P + 2] == 2)
P += 3;
else
Noapp();
Cename(Mode, Fname, Bs, Ar, Dp, 0);
} else {
Caname(Arr, Bs, Dp);
Cename(Access, Fname, Base, Area, Disp, 0);
}
return;
void Cename(int Mode, int Fname, int Bs, int Ar, int Dp, int Xd) {
auto void Fetchrad(void);
auto void Localise(int Size);
int Q;
int Qq;
int D;
int C;
int W;
Depth++;
if (A[P] == 2) {
Access = Mode;
Area = Ar;
Xdisp = Xd;
Base = Bs;
Disp = Dp;
if (Z < 14)
if ((3 > Z || Z > 4) && Z != 6) {
Fault(64, 0);
Base = Rbase;
Area = -1;
Disp = 0;
Access = 0;
Ptype = 1;
Unpack();
}
return;
}
P++;
Q = Displacement(Fname);
Unpack();
if (Q == -1 && -1 == Acc || Ptype == 7) {
P += 2;
Skipapp();
P -= 3;
Access = 0;
Base = Rbase;
Disp = 0;
Area = -1;
return;
}
*Namep = (A[P] << 8 | A[P + 1]) << 16 | *Namep;
if (Arr == 1)
goto Ae;
if (A[P + 2] == 2)
P += 3;
else
Noapp();
if (Type <= 2 || Type == 5 ||
(Type == 3 && A[P] == 2 && (3 <= Z && Z <= 4 || Z == 6))) {
Access = Mode + 4 + 4 * Nam;
Base = Bs;
Area = Ar;
Disp = Dp;
Xdisp = Xd + Q;
return;
}
Xd += Q;
*Namep = -1;
if (Nam == 1)
if (!Mode) {
Dp += Xd;
Xd = 0;
Mode = 2;
} else {
Localise(8);
Ar = Area;
Dp = Disp;
Bs = Base;
}
Cename(Mode, Kform, Bs, Ar, Dp, Xd);
return;
Ae:;
From123(Tcell, &Q, &Sndisp, &K);
Acc = Sndisp & 0xFFFF;
Sndisp = (Sndisp & 0xFFFF0000) / 0x10000;
Kform = K & 0xFFFF;
K = (unsigned)K >> 16;
C = Acc;
D = Sndisp;
Q = K;
Qq = Kform;
if ((Z == 6 || Z == 12) && A[P + 2] == 2) {
P += 3;
if (Nam == 1) {
Access = Mode + 8;
Base = Bs;
Area = Ar;
Disp = Dp;
Xdisp = Xd + Q;
return;
}
*Namep = -1;
Fetchrad();
Area = -1;
Disp = Q;
Base = 0;
Access = 0;
Createah(1);
} else {
*Namep = -1;
if (Nam == 1) {
Xd += Q;
Localise(16);
Caname(3, Base, Disp);
} else {
if (Mode == 0 || Mode == 2)
if (!Mode)
W = Dp - 4;
else
W = Dp + 4;
else {
Fetchrad();
Getwsp(&W, 1);
Psf1(St, 1, W);
Xd = 0;
Bs = Rbase;
}
Caname(3, 0, Q);
if (Parmarr == 0 && 0 == Parmchk && Access == 3 &&
(Prec == 3 || Type >= 3)) {
Psorlf1(Adb, 0, Areacode2(Bs), W);
if (Xd)
Psf1(Adb, 0, Xd);
Gruse[Breg] = 0;
} else {
Getinacc(Dr, 2, 0, Areacode(), Q);
Psorlf1(Inca, 0, Areacode2(Bs), W);
if (Access == 1) {
Access = 2;
Area = 7;
Xd += Nummod * Bytes[Prec];
}
if (Xd)
Psf1(Inca, 0, Xd);
Forget(Dr);
Area = 7;
Disp = 0;
if (Type == 3 && A[P] == 1) {
Getwsp(&Disp, 2);
Psf1(Std, 1, Disp);
Area = Lnb;
Base = Rbase;
}
}
}
if (Type == 3)
Cename(Access, Qq, Base, Area, Disp, 0);
}
return;
void Fetchrad(void) {
Access = Mode + 4;
Area = Ar;
Base = Bs;
Disp = Dp;
Xdisp = Xd;
Nameop(4, Accr, 4, -1);
}
void Localise(int Size) {
int Hole;
Access = Mode + 4;
Area = Ar;
Base = Bs;
Disp = Dp;
Xdisp = Xd;
Nameop(2, Accr, Size, -1);
Getwsp(&Hole, (unsigned)Size >> 2);
Psf1(St, 1, Hole);
Mode = 2;
Area = Lnb;
Base = Rbase;
Disp = Hole;
Xd = 0;
}
}
}
void Cstrexp(int Mode, int Reg) {
int Pp;
int Wkarea;
int Dots;
int Rexp;
int Err;
int Clen;
int Keepwa;
int Fnam;
auto int Strop(int Reg);
Keepwa = Mode & 16;
Mode = Mode & 15;
Pp = P;
Stringl = 0;
Fnam = 0;
Wkarea = 0;
Rexp = 2 - A[P + 1 + Fromar2(P + 1)];
if (A[P + 3] != 4 || Rexp != 0 || Mode != 0)
goto Normal;
if (A[P + 4] == 2)
goto Simple;
if (A[P + 4] != 1)
goto Normal;
Simple:
P += 4;
Err = Strop(Reg);
if (Err)
goto Error;
Value = Wkarea;
P++;
Strfnres = 0;
return;
Error:
Fault2(Err, 0, Fnam);
Base = Rbase;
Disp = 0;
Value = 0;
Access = 0;
P = Pp;
Skipexp();
return;
Normal:
Clen = 0;
P += 3;
Err = 72;
if (A[P] != 4)
goto Error;
P++;
Getwsp(&Wkarea, 268);
Dots = 0;
Next:
Stringl = 0;
Err = Strop(Dr);
if (Err)
goto Error;
if (Register[Accr])
Bootout(Accr);
Psf1(Lb, 0, Wkarea);
Ppj(0, 19 + Dots);
if (A[P] == 2)
goto Tidy;
Err = 72;
if (A[P + 1] != Concop)
goto Error;
Dots = Dots | 1;
P += 2;
goto Next;
Tidy:;
Value = Wkarea;
P++;
if (!Keepwa)
Returnwsp(Wkarea, 268);
Stringl = 0;
return;
int Strop(int Reg) {
int Ctype;
int Val;
int Mode;
Mode = A[P];
if (Mode > 2)
return (75);
if (Mode != 1) {
Ctype = A[P + 1];
if (Ctype == 0x35) {
Stringl = A[P + 6];
Disp = Fromar4(P + 2);
P = P + Stringl + 7;
} else
return (71);
Pf1(Ldrl, 0, Pc, Strlink);
if (Disp)
Psf1(Inca, 0, Disp);
if (Stringl != 1) {
if (Stringl <= 63)
Psf1(Ldb, 0, Stringl);
else
Pf1(Ldb, 2, 7, 0);
}
Gruse[Dr] = 0;
if (!Reg)
Copydr();
} else {
P++;
Reducetag();
if (5 != Type && Type != 7) {
Fnam = Fromar2(P);
return (71);
}
Cname(2, Reg);
Stringl = 0;
if (Rout != 0 && Nam <= 1)
if (Wkarea == 0 && Keepwa != 0)
Wkarea = Strfnres;
else
Returnwsp(Strfnres, 268);
}
return (0);
}
}
void Cres(int Lab) {
int P1;
int P2;
int Sexprn;
int W;
int Last;
int Err;
int Fnam;
Rd R;
Last = 0;
Fnam = 0;
Sexprn = 0;
Err = 74;
Psf1(Inca, 0, 1);
P1 = P;
P += 3;
if (A[P] == 4)
goto Res;
Err = 72;
Error:
Fault2(Err, 0, Fnam);
P = P1;
Skipexp();
return;
Res:
P++;
Psf1(Prcl, 0, 4);
if (!Sexprn)
W = Std;
else
W = St;
Pf1(W, 0, Tos, 0);
if (A[P] == 3) {
Psf1(Lsd, 0, 0);
Gruse[Accr] = 0;
} else {
if (A[P] != 1)
goto Error;
P++;
P2 = P;
Cname(3, Accr);
if (Type != 5) {
Err = 71;
Fnam = Fromar2(P2);
goto Error;
}
if (A[P + 1] != Concop) {
Err = 72;
goto Error;
}
P += 2;
}
Pf1(St, 0, Tos, 0);
if (A[P] != 3)
goto Error;
Sexprn++;
P++;
Cstrexp(0, Dr);
Pf1(Std, 0, Tos, 0);
Psf1(Raln, 0, 11);
Ppj(-1, 16);
if (Lab)
Enterjump(7, Lab, 0b11);
else
Ppj(7, 12);
if (A[P] == 2)
goto End;
if (A[P + 1] != Concop) {
Err = 72;
goto Error;
}
if (A[P + 2] != 1)
goto Error;
P2 = P + 1;
P = P2 + 1;
do {
P += 3;
Skipapp();
} while (A[P] != 2);
if (A[P + 1] == 1) {
P = P2;
goto Res;
}
P1 = P + 1;
Register[Accr] = 1;
Olink[Accr] = Addr(R);
R.Ptype = 1;
R.Xb = Accr;
R.Flag = 9;
P = P2 + 2;
Cname(1, Dr);
if (R.Flag != 9)
Pf1(Lsd, 0, Tos, 0);
Register[Accr] = 0;
Pf1(Stuh, 0, Breg, 0);
Pf1(Luh, 0, Breg, 0);
Pf2(Mvl, 0, 0, 0, 0, 0);
if (Rout != 0 || Nam != 0)
Ppj(0, 18);
Pf2(Mv, 1, 1, 0, 0, Unasspat & 255);
Gruse[Accr] = 0;
if (Parmarr == 1) {
Psf1(Ush, 0, 8);
Psf1(Ush, 0, -40);
Ppj(36, 9);
}
P = P1;
End:;
P++;
}
void Saveauxstack(void) {
int Xynb;
int Dr0;
int Dr1;
if (!Auxst) {
Dr0 = 0x30000001;
Dr1 = 0;
Pgla(8, 8, Addr(Dr0));
Auxst = Glaca - 8;
Gxref(Auxstep, 2, 0x02000008, Auxst + 4);
}
if (!Auxsbase[Level]) {
Xynb = Setxorynb(-1, -1);
Pf1(Ld, 2, Xynb, Auxst);
if (Parmopt) {
Pf1(Lss, 1, 0, 2);
Psf1(St, 1, N + 16);
}
Pf1(Lss, 2, 7, 0);
Psf1(Std, 1, N);
Psf1(St, 1, N + 8);
Auxsbase[Level] = N;
N += 16;
if (Parmopt)
N += 4;
Gruse[Dr] = 0;
Gruse[Accr] = 11;
Grinf1[Accr] = 0;
}
}
void Resetauxstack(void) {
if (Auxsbase[Level]) {
Psf1(Lb, 1, Auxsbase[Level] + 8);
Psf1(Stb, 2, Auxsbase[Level]);
Gruse[Breg] = 0;
}
}
void Rtexit(void) {
Resetauxstack();
Psf1(Exit, 0, -0x40);
}
void Claimstframe(int At, int Value) {
int Instr;
int Wk;
Wk = (unsigned)At >> 18;
At = At & 0x3FFFF;
Instr = (Asf + 12 * Parmchk) << 24 | 3 << 23 |
(unsigned)(Value - Wk + 3) >> 2;
Plug(1, At, Instr, 4);
}
void Cend(int Kkk) {
int Kp;
int Jj;
int Bit;
auto void Dtable(int Level);
if (Kkk != 2)
Setline();
Forget(-1);
Bit = 1 << Level;
if ((Kkk & 0x3FFF) > 0x1000 && Compiler == 0 && Lastinst == 0)
Ppj(15, 10);
if (N > Nmax)
Nmax = N;
while (Label[Level]) {
Pop(&Label[Level], &I, &J, &Kp);
I = (unsigned)I >> 24;
if (J & 0xFFFF) {
J = J & 0xFFFF;
if (0 < Kp && Kp <= Maxulab)
Fault2(11, From3(J), Kp);
Clearlist(&J);
} else if (I == 0 && Kp < Maxulab)
Warn(3, Kp);
}
for (Jj = 0; Jj <= 4; Jj++) {
Clearlist(&Avlwsp[Jj][Level]);
}
Dtable(Level);
Nmax = (Nmax + 7) & (-8);
if (Kkk == 2)
return;
if (Kkk >= 0x1000 || Kkk == 1)
Claimstframe(Set[Rlevel], Nmax);
if ((Kkk & 0x3FFF) == 0x1000 && Lastinst == 0)
Rtexit();
if (Kkk == 1 && Lastinst == 0)
Ppj(15, 21);
if (!Kkk) {
if (Parmtrace == 1) {
Psf1(Ld, 1, 12);
Diagpointer(Level - 1);
Psf1(Std, 1, 12);
}
if (Stack) {
Jj = (unsigned)Nmdecs[Level] >> 14;
if (Jj) {
Pf1(Stsf, 0, Tos, 0);
Pf1(Lss, 0, Tos, 0);
Psf1(Isb, 1, Jj);
Psf1(Ush, 0, -2);
Pf1(St, 0, Tos, 0);
Pf1(Asf, 0, Tos, 0);
Gruse[Accr] = 0;
}
} else
Resetauxstack();
}
if (Level <= 2 && (Level != 2 || Cprmode != 2))
if (Kkk == 1 && Level == 2)
Kkk = 2;
else {
Fault(14, 0);
exit(0);
}
Level--;
if (Kkk >= 0x1000) {
Rlevel--;
Rbase = Rlevel;
}
Pop(&Levelinf, &Kp, &N, &Kp);
if (Kkk >= 0x1000)
Nmax = (unsigned)N >> 16;
N = N & 0x7FFF;
if (Kkk == 2)
Cend(Kkk);
if (Aslwarn) {
Aslwarn = 0;
Epilogue();
}
if (Kkk >= 0x1000 && Compiler == 0 && (Rlevel > 0 || Cprmode != 2)) {
Jj = Nextp + 6;
if (A[Nextp + 5] != 11 || A[Jj + Fromar2(Jj)] != 2) {
Jj = Enterlab(Jround[Level + 1], 0);
Jround[Level + 1] = 0;
}
}
return;
void Dtable(int Level) {
_imp_string Rtname;
_imp_string Localname;
Listf *Lcell;
static const int Larrrout = 0xF300;
int Dptr;
int Lnum;
int Ml;
int Kk;
int Jj;
int Q;
int Dend;
int Bit;
int S1;
int S2;
int S3;
int S4;
int Langd;
int Ii;
int Dd[501 /*0:500*/];
Bit = 1 << Level;
Langd = (unsigned)Kkk >> 14 << 30 | Level << 18;
while (Ral[Level]) {
Pop(&Ral[Level], &Q, &Jj, &Kk);
Plug(Q, Jj, Kk | Sstl, 4);
}
if (Parmtrace)
Push(&Ral[Level - 1], 4, Sstl + 4, Langd);
Dd[0] = L[Level] << 16 | (Diaginf[Level]);
Dd[1] = Langd;
Dd[2] = Display[Rlevel] << 16 | Flag[Level] & 0x3FFF;
Ml = M[Level];
Lnum = *Byteinteger(Dictbase + Ml);
Dptr = 4;
Dend = 0;
if (!Lnum)
Dd[3] = 0;
else {
Q = Dictbase + Ml;
Rtname = *String(Q);
Lnum = *Byteinteger(Addr(Rtname));
*String(Addr(Dd[3])) = Rtname;
Dptr += (unsigned)Lnum >> 2;
}
Dd[Dptr] = Onword[Level];
Dptr++;
Jj = Names[Level];
while (0 <= Jj && Jj < 0x3FFF) {
Lcell = &Aslist[Tags[Jj]];
if (!(Lcell->S1 & 0xF000))
Warn(2, Jj);
S1 = Lcell->S1;
S2 = Lcell->S2;
S3 = Lcell->S3;
S4 = Lcell->Link;
Lcell->Link = Asl;
Asl = Tags[Jj];
Tags[Jj] = S4 & 0x3FFFF;
Ptype = (unsigned)S1 >> 16;
Type = Ptype & 15;
I = (unsigned)S1 >> 4 & 15;
J = S1 & 15;
K = (unsigned)S3 >> 16;
if (Parmdiag != 0 && (Ptype & 0x7300) <= 0x200 && Dptr < 497 &&
(Type == 1 || Type == 2 || Type == 5)) {
Q = Dictbase + Word[Jj];
if (!I)
Ii = 1;
else
Ii = 0;
Dd[Dptr] = Ptype << 20 | Ii << 18 | K;
Localname = *String(Q);
Lnum = *Byteinteger(Addr(Localname));
*String(Addr(Dd[Dptr]) + 4) = Localname;
Dptr += (unsigned)(Lnum + 8) >> 2;
}
if (J == 15 && S2 != 0)
Fault2(28, 0, Jj);
if ((Ptype & 0x3000) != 0 || Type == 4 || Type == 6)
Clearlist(&K);
else if (I != 0 && K > 511 && (Ptype & Larrrout) == 0 &&
Type != 7)
Warn(5, Jj);
Jj = (unsigned)S4 >> 18;
}
Dd[Dptr] = -1;
Dptr = (Dptr << 2) + 4;
if (Parmtrace == 1) {
Lput(4, Dptr, Sstl, Addr(Dd[0]));
Sstl += Dptr;
}
}
}
void Makedecs(int Q) {
int Qq;
int Head;
int Prio;
int Count;
int Sl;
int *Thead;
Listf *Cell;
Sl = Line;
Qq = Fromar4(Q);
Head = 0;
Count = 0;
while (Qq) {
Count++;
if (A[Qq + 5] != 8)
Abort();
P = Qq + 10;
Clt();
if (Prec == 3 || A[P] != 1 || A[P + 1] != 3) {
if (A[P] == 1)
Insertatend(&Head, 0xFFFF, Qq, 0);
} else {
Prio = Prec << 4 | Type;
Thead = &Head;
for (;;) {
Cell = &Aslist[*Thead];
if (*Thead == 0 || Prio < Cell->S1) {
Push(Thead, Prio, Qq, 0);
break;
}
Thead = &Cell->Link;
}
}
Qq = Fromar4(Qq + 6);
}
if (Count >= 7) {
Getwsp(&Qq, 2);
if (!Avlwsp[1][Level])
Getwsp(&Qq, 1);
}
while (Head) {
Pop(&Head, &Prio, &Qq, &Count);
Line = Fromar2(Qq + 3);
P = Qq + 10;
Clt();
Rout = 0;
Litl = 0;
Cqn(P + 1);
P += 2;
Declarescalars(1, 0);
}
Line = Sl;
}
void Declarescalars(int Permit, int Xtra) {
int Inc;
int Q;
int Schain;
int Dmade;
int Nparms;
int D0;
int Scalname;
int Typep;
Pack(&Ptype);
J = 0;
Inc = Acc;
Dmade = 0;
Sndisp = 0;
if (Ptype == 0x33)
Inc = (Inc + 3) & (-4);
if (Nam != 0 && Rout == 0 && Arr == 0)
Inc = 8;
if (Nam > 0 && Arr > 0)
Inc = 16;
if (Ptype == 0x35 && Acc == 0)
Fault(70, 0);
if (Permit != 0 && (Inc == 8 || Inc == 16))
Oddalign();
if (Ptype == 0x33 || (Ptype == 0x35 && Permit != 0)) {
D0 = 0x18000000 + Acc;
Storeconst(&Q, 4, Addr(D0));
Pf1(Ldtb, 0, Pc, Q);
Gruse[Dr] = 0;
}
if (Ptype == 0x35) {
Inc = 8;
if (Permit) {
Pf1(Stsf, 0, Tos, 0);
Pf1(Lda, 0, Tos, 0);
}
}
N = (N + 3) & (-4);
if (Ptype == 0x33) {
Psf1(Lda, 1, Ptroffset(Rbase));
Psf1(Inca, 0, N + 8);
}
do {
Dmade++;
Scalname = Fromar2(P);
if (Ptype == 0x31 && Permit == 0)
N += 3;
if (Ptype == 0x41 && Permit == 0)
N += 2;
Schain = N;
Kform = Xtra;
if (Rout == 1) {
Typep = Ptype;
Q = P;
do
P += 3;
while (A[P - 1] != 2);
Cfplist(&Schain, &Nparms);
P = Q;
J = 13;
Kform = Nparms;
Acc = N;
Ptype = Typep;
Unpack();
}
P += 3;
if (Ptype == 0x33) {
Psf1(Std, 1, N);
N += 8;
Schain = N;
if (A[P - 1] == 1)
Psf1(Inca, 0, Inc + 8);
}
if (Ptype == 0x35 && Permit != 0) {
Psf1(Std, 1, N);
if (A[P - 1] == 1)
Psf1(Inca, 0, (Acc + 3) & (-4));
else {
Q = ((unsigned)(Acc + 3) >> 2) * Dmade;
Psf1(Asf + 12 * Parmchk, 0, Q);
if (Parmchk)
Ppj(0, 4);
}
}
Storetag(Scalname, Schain);
N += Inc;
} while (A[P - 1] != 2);
if (Permit)
N = (N + 3) & (-4);
}
int Dopevector(int Typep, int Elsize, int Mode, int Iden, int *Asize,
int *Lb) {
int I;
int Jj;
int K;
int Nd;
int D;
int Unscal;
int M0;
int Head;
int Nops;
int Typepp;
int Pin;
int Ptr;
Listf *Lcell;
int Lbh[13 /*0:12*/];
int Lbb[13 /*0:12*/];
int Ubh[13 /*0:12*/];
int Ubb[13 /*0:12*/];
int Dv[40 /*0:39*/];
Nd = 0;
Nops = 0;
Typepp = 0;
Pin = P;
if (Typep > 2 || (Typep == 1 && Prec == 4)) {
Unscal = 1;
M0 = Elsize;
} else {
Unscal = 0;
M0 = 1;
}
do {
Nd++;
P += 4;
Lbh[Nd] = 0;
Lbb[Nd] = 0;
Ubb[Nd] = 0;
Ubh[Nd] = 0;
Torp(&Lbh[Nd], &Lbb[Nd], &Nops);
P += 3;
Typepp = Typepp | Type;
Torp(&Ubh[Nd], &Ubb[Nd], &Nops);
Typepp = Typepp | Type;
} while (A[P] != 2);
P++;
if (Typepp != 1 || (Nops & 0x40040000) != 0)
goto Nonconst;
Ptr = 1;
for (D = Nd; D >= 1; D--) {
K = 3 * D;
Expop(Lbh[Ptr], Accr, Nops, 0x251);
if (Expopnd.Flag > 1 || Expopnd.Ptype != 0x51) {
Expopnd.D = 0;
Fault(41, 0);
}
Dv[K] = Expopnd.D;
Dv[K + 1] = M0;
Expop(Ubh[Ptr], Accr, Nops, 0x251);
if (Expopnd.Flag > 1 || Expopnd.Ptype != 0x51) {
Expopnd.D = 10;
Fault(41, 0);
}
Jj = Expopnd.D;
M0 = M0 * (Jj - Dv[K] + 1);
if (Jj < Dv[K])
Fault2(38, 1 - M0, Iden);
Dv[K + 2] = M0;
Ptr++;
}
if (!Unscal)
M0 = M0 * Elsize;
if (Nd == 1)
*Lb = Dv[3];
*Asize = M0;
Dv[2] = *Asize;
Dv[1] = 12;
Dv[0] = 5 << 27 | 3 * Nd;
K = 3 * Nd + 2;
J = Nd;
Head = Dvheads[Nd];
while (Head) {
Lcell = &Aslist[Head];
if (Lcell->S2 == *Asize && Lcell->S3 == Dv[5]) {
// ->ON %UNLESS DV(D)=CTABLE_val(D+LCELL_S1)
for (D = 0; D <= K; D++)
if (Dv[D] != Ctable->Val[D+Lcell->S1])
goto On;
return (0x80000000 | 4 * Lcell->S1);
}
On:;
Head = Lcell->Link;
}
if (Constptr & 1) {
Consthole = Constptr;
Constptr++;
}
I = 4 * Constptr | 0x80000000;
Push(&Dvheads[Nd], Constptr, *Asize, Dv[5]);
for (D = 0; D <= K; D++) {
// CTABLE_val(CONST PTR)=DV(D)
Ctable->Val[Constptr] = Dv[D];
Constptr++;
}
if (Constptr > Constlimit)
Fault(107, 0);
Wayout:;
for (D = Nd; D >= 1; D--) {
Aslist[Lbb[D]].Link = Asl;
Asl = Lbh[D];
Aslist[Ubb[D]].Link = Asl;
Asl = Ubh[D];
}
return (I);
Nonconst:;
J = Nd;
I = -1;
*Lb = 0;
*Asize = Elsize;
if (!Mode)
Fault(41, 0);
else
P = Pin;
goto Wayout;
}
void Declarearrays(int Format, int Finf) {
auto void Claimas(void);
int Dvdisp;
int Pp;
int Dvf;
int Elsize;
int Totsize;
int D0;
int D1;
int Ptypep;
int Arrp;
int Nn;
int Nd;
int Ii;
int Jj;
int Qq;
int R;
int Cdv;
int Unscal;
int Desc;
int Sc;
int Lwb;
int Ptypepp;
int Jjj;
int Jjjj;
int Adj;
if (Stack != 0 && Flag[Level] == 0 &&
0 == (unsigned)Nmdecs[Level] >> 14) {
Psf1(Stsf, 1, N);
Nmdecs[Level] = Nmdecs[Level] | (N << 14);
N += 4;
}
if (!Stack)
Saveauxstack();
Arrp = 2 * Format + 1;
Arr = Arrp;
Pack(&Ptypep);
Elsize = Acc;
if (Type > 2 || (Type == 1 && Prec == 4)) {
Unscal = 1;
Sc = 3;
} else {
Unscal = 0;
Sc = Prec;
}
Desc = Sc << 27 | Unscal << 25 | (1 - Parmarr) << 24;
if (Prec == 4)
Desc = 0x58000002;
Start:
Nn = 1;
P++;
Pp = P;
Cdv = 0;
Ptypepp = Ptypep;
while (A[P + 2] == 1) {
P += 3;
Nn++;
}
P += 3;
Dvdisp = Dopevector(Type, Elsize, 1, Fromar2(Pp), &Totsize, &Lwb);
Nd = J;
if (Dvdisp != -1)
goto Constdv;
Dvf = 0;
Totsize = 0xFFFF;
Dvdisp = N;
N = N + 12 * Nd + 12;
if (Nd > 12)
Fault(37, 0);
D0 = 5 << 27 | 3 * Nd;
D1 = 12;
Storeconst(&Jj, 8, Addr(D0));
Pf1(Ld, 0, Pc, Jj);
Psf1(Std, 1, Dvdisp);
Gruse[Dr] = 0;
if (!Unscal)
Jj = 1;
else
Jj = Elsize;
Psf1(Lss, 0, Jj);
Gruse[Accr] = 0;
for (Ii = Nd; Ii >= 1; Ii--) {
P++;
Qq = Dvdisp + 12 * Ii;
Psf1(St, 1, Qq + 4);
Csexp(Accr, 0x51);
if (Nd == 1 && (Ptypep & 7) <= 3 && Format == 0 &&
Gruse[Accr] == 5 && Grinf1[Accr] == 0)
Ptypepp += 256;
Psf1(St, 1, Qq);
Csexp(Accr, 0x51);
Psf1(Isb, 1, Qq);
Gruse[Accr] = 0;
if (Compiler == 0 || Parmarr != 0) {
Pf3(Jaf, 6, 0, 3);
Psf1(Lss, 0, -1);
}
Psf1(Iad, 0, 1);
Psf1(Imy, 1, Qq + 4);
Psf1(St, 1, Qq + 8);
}
P++;
if (Unscal == 0 && Elsize != 1)
Psf1(Imy, 0, Elsize);
Psf1(St, 1, Dvdisp + 8);
Sndisp = 0;
goto Decl;
Constdv:;
Dvf = 1;
Cdv = 1;
if (Nd == 1 && Lwb == 0 && (Ptypep & 15) <= 3 && Format == 0)
Ptypepp = Ptypep + 256;
Sndisp = (unsigned)(Dvdisp & 0xFFFFFF) >> 2;
Decl:;
J = Nd;
Oddalign();
Ptype = Ptypepp;
Unpack();
if (Dvf) {
R = Totsize;
if (!Unscal)
R = R / Elsize;
D0 = Desc;
if (Prec != 4)
D0 = D0 | R;
Storeconst(&D1, 4, Addr(D0));
Pf1(Lb, 0, Pc, D1);
} else {
Storeconst(&D1, 4, Addr(Desc));
Pf1(Lb, 0, Pc, D1);
if (Prec != 4)
Psf1(Adb, 1, Dvdisp + 20);
}
if (Dvf)
Qq = Pc;
else
Qq = Lnb;
Psorlf1(Ldrl, 0, Qq, Dvdisp);
Gruse[Breg] = 0;
Gruse[Dr] = 0;
for (Jjj = 0; Jjj <= Nn - 1; Jjj++) {
Psf1(Stb, 1, N + 16 * Jjj);
Psf1(Std, 1, N + 8 + 16 * Jjj);
}
if (Parmarr == 0 && Parmchk == 0 && Nd == 1 && Type <= 3 &&
(Ptypepp & 0xF00) != 0x200)
Adj = 1;
else
Adj = 0;
for (Jjj = 0; Jjj <= Nn - 1; Jjj++) {
if (Adj)
if (Stack) {
Pf1(Stsf, 0, Breg, 0);
if (Dvf)
Psf1(Sbb, 0, Lwb * Elsize);
else if (Elsize == 1)
Psf1(Sbb, 1, Dvdisp + 12);
else {
Psf1(Slb, 1, Dvdisp + 12);
Psf1(Myb, 0, Elsize);
Pf1(Slb, 0, Tos, 0);
Pf1(Sbb, 0, Tos, 0);
}
Psf1(Stb, 1, N + 4);
Gruse[Breg] = 0;
} else {
if (Dvf) {
if (Gruse[Accr] != 11) {
Psf1(Lss, 2, Auxsbase[Level]);
Gruse[Accr] = 11;
Grinf1[Accr] = 0;
}
Jjjj = Lwb * Elsize - Grinf1[Accr];
if (Jjjj)
Psf1(Isb, 0, Jjjj);
Grinf1[Accr] = Lwb * Elsize;
} else {
if (Gruse[Accr] == 11 && Grinf1[Accr] == 0 && Elsize == 1)
Psf1(Isb, 1, Dvdisp + 12);
else {
Psf1(Lss, 1, Dvdisp + 12);
if (Elsize != 1)
Psf1(Imy, 0, Elsize);
Psf1(Irsb, 2, Auxsbase[Level]);
}
Gruse[Accr] = 0;
}
Psf1(St, 1, N + 4);
}
else if (Stack)
Psf1(Stsf, 1, N + 4);
else {
if (Gruse[Accr] != 11 || Grinf1[Accr] != 0)
Psf1(Lss, 2, Auxsbase[Level]);
Psf1(St, 1, N + 4);
Gruse[Accr] = 11;
Grinf1[Accr] = 0;
}
Acc = Elsize;
Kform = Finf;
K = Fromar2(Pp + 3 * Jjj);
Storetag(K, N);
if (!Format)
Claimas();
N += 16;
}
P++;
if (A[P - 1] == 1)
goto Start;
return;
void Claimas(void) {
int T;
int B;
int D;
int Adjment;
if (Stack == 1) {
if (Cdv == 1) {
T = (Totsize + 3) / 4;
Psf1(Asf + 12 * Parmchk, 0, T);
if (Parmchk)
Ppj(0, 4);
} else if (Parmchk == 0 && (Ptypep & 7) <= 2 &&
(Elsize == 4 || Elsize == 8)) {
Psf1(Asf, 1, Dvdisp + 20);
if (Elsize == 8)
Psf1(Asf, 1, Dvdisp + 20);
} else {
Psf1(Lss, 1, Dvdisp + 8);
if (Elsize & 3)
Psf1(Iad, 0, 3);
Psf1(Ush, 0, -2);
Pf1(St, 0, Breg, 0);
Forget(Breg);
if (Parmchk)
Ppj(0, 4);
else
Pf1(Asf, 0, Breg, 0);
}
Checkstof();
} else {
if (Gruse[Accr] != 11 || (Grinf1[Accr] != 0 && Cdv != 1)) {
Psf1(Lss, 2, Auxsbase[Level]);
Gruse[Accr] = 11;
Grinf1[Accr] = 0;
}
if (Cdv == 1) {
Adjment = ((Totsize + 7) & (-8)) + Grinf1[Accr];
if (Adjment < 0x1FFFF) {
B = 0;
D = Adjment;
} else {
Storeconst(&D, 4, Addr(Adjment));
B = Pc;
}
if (Adj == 1 && Jjj != Nn - 1 && Parmopt == 0)
Grinf1[Accr] = Adjment;
else {
Grinf1[Accr] = 0;
if (B != D || D != 0)
Psorlf1(Iad, 0, B, D);
}
} else {
B = Lnb;
D = Dvdisp + 8;
Psf1(Iad, 1, D);
if (Elsize & 7) {
Psf1(Iad, 0, 7);
Psf1(And, 0, -8);
}
Grinf1[Accr] = 0;
}
if (Jjj == Nn - 1 || (Adj == 1 && Cdv == 0))
Psf1(St, 2, Auxsbase[Level]);
if (Parmopt) {
Psf1(Icp, 1, Auxsbase[Level] + 16);
Ppj(2, 8);
}
if (Parmchk) {
Pf1(Ldtb, 0, Pc, Paramdes(3));
Psorlf1(Ldb, 0, B, D);
Psf1(Lda, 1, N + 4);
Pf2(Mvl, 1, 1, 0, 0, Unasspat & 255);
Gruse[Dr] = 0;
}
}
}
}
void Clt(void) {
static const unsigned char Typeflag[1+10 /*1:10*/] = {0,
0x51, 0x52, 0, 0x31, 0x35, 0x41, 0, 0x62, 0x61, 0x72};
int Alt;
Alt = A[P];
Type = Typeflag[Alt];
if (!Type) {
P++;
Type = Typeflag[A[P] + 7];
}
Prec = (unsigned)Type >> 4;
Type = Type & 7;
if (Type == 2 && Alllong != 0 && Prec <= 5)
Prec = 6;
Acc = Bytes[Prec];
if (Type == 5)
if (A[P + 1] == 1) {
P += 2;
Acc = A[P] + 1;
} else {
Acc = 0;
P++;
}
P++;
}
void Cqn(int P) {
int I;
I = A[P];
Nam = 0;
Arr = 0;
if (I == 1) {
Arr = 1;
Acc = 16;
}
if (I <= 2)
Nam = 1;
if (I == 2)
Acc = 8;
}
void Crspec(int M) {
int Kk;
int Jj;
int Typep;
int Ophead;
int Nparms;
_imp_string Xname;
Litl = Extrn & 3;
if (A[P] == 1) {
Typep = Litl << 14 | 0x1000;
P += 2;
} else {
Rout = 1;
Arr = 0;
P++;
Clt();
Nam = 0;
if (A[P] == 2)
Nam = 2;
Pack(&Typep);
P += 2;
}
P += 4;
Kk = Fromar2(P);
Jj = 0;
P += 2;
Cfplist(&Ophead, &Nparms);
if (M == 1) {
Xname = *String(Dictbase + Word[Kk]);
if (Extrn == 1)
Xname = _imp_join(_imp_str_literal("S#"), Xname);
Cxref(Xname, Parmdynamic | (Extrn / 3), 2, &Jj);
}
if (M == 0 && Rlevel == 0)
Codedes(&Jj);
J = 15 - M;
Ptype = Typep;
Kform = Nparms;
Sndisp = (unsigned)Jj >> 16;
Acc = Jj & 0xFFFF;
Storetag(Kk, Ophead);
}
void Cfplist(int *Ophead, int *Nparms) {
int Opbot;
int Pp;
Ophead = 0;
Opbot = 0;
Nparms = 0;
while (A[P] == 1) {
Pp = P + 1 + Fromar2(P + 1);
P += 3;
Cfpdel();
do {
Binsert(Ophead, &Opbot, Ptype << 16, Acc << 16, 0);
Nparms++;
P += 3;
} while (A[P - 1] != 2);
P = Pp;
}
P++;
}
void Cfpdel(void) {
static int Fp_sw;
static void *Fp[4 /*1:4*/] = {
&&Fp_1,
&&Fp_2,
&&Fp_3,
&&Fp_4,
};
int Fpalt;
Fpalt = A[P];
P++;
Kform = 0;
Litl = 0;
goto *Fp[Fp_sw = (Fpalt)-1];
Fp_1:;
Rout = 0;
Clt();
Cqn(P);
if (Type == 5 && Acc == 0)
Fault(70, 0);
P++;
goto Pk;
Fp_2:;
Arr = 2 - A[P];
Rout = 0;
Acc = 8 + 8 * Arr;
Type = 3;
Prec = 3;
Nam = 1;
P++;
goto Pk;
Fp_3:;
Rout = 1;
Nam = 1;
Arr = 0;
if (A[P] == 1) {
Type = 0;
Prec = 0;
P += 2;
} else {
P++;
Clt();
Nam = 1;
if (A[P] == 2)
Nam = 3;
P += 2;
}
Acc = 16;
goto Pk;
Fp_4:;
Acc = 8;
Nam = 1;
Rout = 0;
Type = 0;
Arr = 0;
Prec = 0;
Pk:
Pack(&Ptype);
}
void Diagpointer(int Level) {
if (Parmtrace) {
Push(&Ral[Level], 1, Ca, Ldb << 24 | 3 << 23);
Pf1(Ldb, 0, 0, 0);
Gruse[Dr] = 0;
}
}
void Rhead(int Kk) {
int W1;
int W3;
int Insrn;
int At;
Push(&Levelinf, 0, Nmax << 16 | N, 0);
Level++;
Nmdecs[Level] = 0;
Auxsbase[Level] = 0;
Names[Level] = -1;
Oninf[Level] = 0;
Onword[Level] = 0;
if (Kk >= 0) {
Rlevel++;
Rbase = Rlevel;
}
if (Level == Maxlevels)
Fault(34, 0);
if (Level > Maxlevels)
Fault(105, 0);
if (Kk >= 0 && Rlevel > 1) {
Copytag(Kk);
Jj = K;
J = Midcell;
if (J == 0 && Level > 2)
Replace1(Tags[Kk], From1(Tags[Kk]) & 0xFFFF3FFF);
while (J) {
Pop(&J, &Insrn, &At, &W1);
W3 = Ca - At;
if ((unsigned)Insrn >> 25 == (unsigned)Call >> 1)
W3 = W3 / 2;
Insrn += W3;
Plug(1, At, Insrn, 4);
}
Replace2(Tags[Kk], Ca);
}
if (Kk >= 0 && Rlevel == 1) {
Diagpointer(Level);
Psf1(Std, 1, 12);
}
if (Kk < 0)
W3 = 0;
else
W3 = Word[Kk];
L[Level] = Line;
M[Level] = W3;
Flag[Level] = Ptype;
}
void Rdisplay(int Kk) {
int W1;
int W2;
int Stack;
int Op;
int Inc;
if (Kk >= 0 || Level == 2) {
Stack = 0;
Display[Rlevel] = N;
Gruse[Xnb] = 0;
Gruse[Ctb] = 0;
Gruse[Breg] = 0;
if (Level != 2) {
Gruse[Xnb] = 4;
Grinf1[Xnb] = Rlevel - 1;
Grat[Xnb] = Ca;
Pf1(Ld, 0, Xnb, 12);
Diagpointer(Level);
Psf1(Std, 1, 12);
W1 = Rlevel - 1;
W2 = Display[W1];
if (W1 == 1) {
Pf1(Stxn, 0, Tos, 0);
N += 4;
} else
while (W1 > 0) {
Op = Lss;
Inc = 1;
if (W1 >= 2) {
Op = Lsd;
Inc = 2;
}
if (W1 >= 4) {
Op = Lsq;
Inc = 4;
}
Pf1(Op + Stack, 0, Xnb, W2);
Stack = -32;
N += 4 * Inc;
W2 += 4 * Inc;
W1 -= Inc;
}
}
if (Stack)
Pf1(St, 0, Tos, 0);
Pf1(Stln, 0, Tos, 0);
N += 4;
}
if (Parmtrace) {
if (Parmopt)
Pf1(Lss, 0, Pc, 4 * Constbtm | 0x80000000);
if (Kk >= 0 || Level == 2) {
if (Parmopt) {
Psf1(Slss, 0, Line);
N += 4;
} else
Psf1(Lss, 0, Line);
Pf1(St, 0, Tos, 0);
} else {
if (Parmopt) {
Psf1(St, 1, N);
N += 4;
}
Psf1(Lss, 0, Line);
Psf1(St, 1, N);
Psf1(Ld, 1, 12);
Diagpointer(Level);
Psf1(Std, 1, 12);
}
Diaginf[Level] = N;
N += 4;
Gruse[Accr] = 0;
}
if (Parmopt != 0 && Kk >= 0 && Level == 2) {
Pf1(Stsf, 0, Breg, 0);
Pf1(Stln, 0, Tos, 0);
Pf1(Sbb, 0, Tos, 0);
Psf1(Cpb, 0, N);
Ppj(7, 13);
}
if (Kk >= 0 || Level == 2) {
Set[Rlevel] = N << 18 | Ca;
Nmax = N;
Pf1(Asf + 12 * Parmchk, 0, 0, 0);
if (Parmchk)
Ppj(0, 4);
}
if (Kk >= 0 && Parmchk != 0) {
Checkstof();
}
if (Parmdbug)
Setline();
}
void Checkstof(void) {
if (Parmopt) {
Pf1(Stsf, 0, Tos, 0);
Pf1(Lss, 0, Tos, 0);
Psf1(Ush, 0, 14);
Psf1(Ush, 0, -15);
Pf1(Icp, 0, 0, (unsigned)Stlimit >> 1);
Ppj(2, 8);
}
}
void Ciocp(int N, int Reg) {
int Xynb;
int Op1;
int Op2;
if (!Iocpdisp)
Cxref(Iocpep, Parmdynamic, 2, &Iocpdisp);
if (Register[Breg])
Bootout(Breg);
if (!Reg) {
Op1 = Luh;
Op2 = St;
} else {
Op1 = Ldtb;
Op2 = Std;
}
Psf1(Op1, 0, N);
Psf1(Prcl, 0, 4);
Pf1(Op2, 0, Tos, 0);
Xynb = Setxorynb(-1, -1);
Psf1(Raln, 0, 7);
Pf1(Call, 2, Xynb, Iocpdisp);
Forget(-1);
}
void Cui(int Code) {
int Marker;
int J;
int Lname;
int Typep;
int Precp;
int Gwrdd;
int Lwb;
int Xynb;
int Arrp;
int Alt;
static int Sw_sw;
static void *Sw[9 /*1:9*/] = {
&&Sw_1, &&Sw_2, &&Sw_3, &&Sw_4, &&Sw_5,
&&Sw_6, &&Sw_7, &&Sw_8, &&Sw_9,
};
Reportui = 0;
Alt = A[P];
goto *Sw[Sw_sw = (Alt)-1];
Sw_1:;
P++;
Marker = P + Fromar2(P);
if (A[Marker] == 1) {
J = P + 2;
P = Marker + 2;
Assign(A[Marker + 1], J);
} else {
P += 2;
Cname(0, 0);
P++;
}
Aui:
J = A[P];
P++;
if (J == 1)
Cui(Code);
return;
Sw_2:;
Nmdecs[Level] = Nmdecs[Level] | 1;
if (!Code)
Currinst = 1;
Lname = Fromar2(P + 1);
J = A[P + 3];
P += 4;
if (J == 2) {
Enterjump(15, Lname, 0);
Reportui = 1;
} else {
Copytag(Lname);
Arrp = Arr;
Gwrdd = Sndisp << 2;
if (Oldi != Level || Type != 6) {
Fault(4, Lname);
P--;
Skipapp();
return;
}
Lwb = From2(K);
Csexp(Breg, 0x51);
if (Arrp == 1)
Psf1(Sbb, 0, Lwb);
Xynb = Setxorynb(-1, -1);
Pf1(Junc, 3, Xynb, Gwrdd);
Reportui = 1;
Forget(-1);
}
return;
Sw_3:;
if ((Flag[Level] & 0x3FFF) != 0x1000)
Fault(30, 0);
P++;
Ret:
Rtexit();
Reportui = 1;
if (!Code)
Currinst = 1;
return;
Sw_4:;
Ptype = Flag[Level] & 0x3FFF;
Unpack();
if (Ptype > 0x1000 && A[P + 1] != 3) {
if (A[P + 1] == 1 && Nam != 0 && A[P + 5] == 4 && A[P + 6] == 1) {
P += 7;
Typep = Type;
Precp = Prec;
Cname(4, Accr);
if (A[P] != 2)
Fault(81, 0);
P++;
if (Typep != Type || Precp != Prec)
Fault(83, 0);
goto Ret;
}
if (A[P + 1] == 2) {
P += 2;
if (Nam)
Type = 1;
if (Type == 5) {
Cstrexp(0, Accr);
Psf1(Ld, 1, Display[Rbase] - 8);
Pf1(Iad, 0, Pc, Specialconsts(2));
Pf2(Mv, 1, 1, 0, 0, Unasspat & 255);
Psf1(Ldb, 2, Display[Rbase] - 8);
Copydr();
} else {
if (Prec < 5)
Prec = 5;
if (!Nam)
Kk = Prec << 4 | Type;
else
Kk = 0x51;
Csexp(Accr, Kk);
}
goto Ret;
}
}
Fault(31, 0);
P += 2;
Skipexp();
return;
Sw_5:;
Psf1(Lsd, 0, 0);
Ppj(0, 2);
P++;
goto Aui;
Sw_6:;
Ppj(0, 21);
P++;
if (!Code)
Currinst = 1;
Reportui = 1;
return;
Sw_7:;
Psf1(Prcl, 0, 4);
Psf1(Jlk, 0, 1);
if (Nmdecs[Level] & 16)
if (Flag[Level] <= 2) {
Psf1(Ld, 1, 12);
Diagpointer(Level - 1);
Psf1(Std, 1, 12);
Pf1(Stln, 0, Tos, 0);
} else {
Psf1(Lss, 1, 0);
Pf1(St, 0, Tos, 0);
}
else
Pf1(Stln, 0, Tos, 0);
Gruse[Accr] = 0;
J = A[P + 2];
if (1 > J || J > 15)
Fault2(26, J, 0);
if (A[P + 3] == 1) {
P += 4;
Csexp(Accr, 0x51);
Pf1(And, 0, 0, 255);
Pf1(Or, 0, 0, 256 * J);
} else
Pf1(Lss, 0, 0, 256 * J);
Psf1(Slss, 0, 0);
Pf1(St, 0, Tos, 0);
Xynb = Setxorynb(-1, -1);
Psf1(Raln, 0, 9);
Pf1(Call, 2, Xynb, 40);
if (!Code)
Currinst = 1;
Reportui = 1;
return;
Sw_8:;
Sw_9:;
Alt = Alt & 7;
if (!Exitlab) {
Fault2(54 + Alt, 0, 0);
return;
}
Kk = *Integer(Addr(Exitlab) + 4 * Alt);
Enterjump(15, Kk, 0b10);
Reportui = 1;
if (!Code)
Currinst = 1;
}
void Cifthen(int Markiu, int Markc, int Markui, int Marke, int Markr,
int Skip) {
int Altui;
int Ccres;
int Elres;
int Thenlab;
int Elselab;
int Userlab;
int Report;
int Start;
int Elsealt;
int K;
static const int Nullelse = 4;
static int Esw_sw;
static void *Esw[4 /*1:4*/] = {
&&Esw_1,
&&Esw_2,
&&Esw_3,
&&Esw_4,
};
if (Skip != Yes)
Setline();
Markiu = A[Markiu];
Plabel--;
Thenlab = Plabel;
Start = 0;
Elselab = 0;
P = Markc;
if (Markr > 0 && A[Markr] <= 2)
Start = 1;
if (Marke != 0 && Level < 2 && Start == 0)
Fault(57, 0);
Userlab = -1;
if (Start)
Altui = 0;
else
Altui = A[Markui];
if (Altui == 2 && A[Markui + 3] == 2)
Userlab = Fromar2(Markui + 1);
if (8 <= Altui && Altui <= 9 && Exitlab != 0)
if (Altui == 8)
Userlab = Exitlab;
else
Userlab = Contlab;
if (Skip == Yes) {
if (Start) {
P = Markr + 1;
Cstart(2, 1);
Marke = P;
}
Ccres = 1;
goto Else;
}
if (Userlab >= 0) {
Nmdecs[Level] = Nmdecs[Level] | 1;
Ccres = Ccond(0, 3 - Markiu, Userlab);
if (Ccres)
Ccres = Ccres ^ 3;
Thenlab = 0;
Report = 1;
} else {
Ccres = Ccond(1, Markiu, Thenlab);
if (Start) {
if (!Ccres) {
if (Level < 2)
Fault(57, 0);
Nmdecs[Level] = Nmdecs[Level] | 1;
}
P = Markr + 1;
Cstart(Ccres, 1);
if (A[P] <= 2) {
Plabel--;
Elselab = Plabel;
}
Marke = P;
Report = Lastinst;
} else if (Ccres != 2) {
P = Markui;
Cui(1);
Report = Reportui;
} else
Report = 1;
}
Else:;
if (!Marke)
Elsealt = Nullelse;
else
Elsealt = A[Marke];
if (Elsealt < Nullelse) {
Plabel--;
Elselab = Plabel;
}
P = Marke + 1;
if (Report == 0 && 0 == Ccres && Elsealt < Nullelse) {
Report = 1;
Enterjump(15, Elselab, 0b10);
}
if (Thenlab > 0)
Elres = Enterlab(Thenlab, 0b11 | Report << 2);
goto *Esw[Esw_sw = (Elsealt)-1];
Esw_1:;
if (!Ccres)
Nmdecs[Level] = Nmdecs[Level] | 1;
Cstart(Ccres, 2);
Report = Lastinst;
goto Enterelselab;
Esw_2:;
Marke = 0;
Markui = 0;
Markr = P + 1 + Fromar2(P + 1);
if (A[Markr] == 3) {
Marke = Markr + 1 + Fromar2(Markr + 1);
Markui = Markr + 3;
}
if (Ccres == 1 || Skip == Yes)
K = Yes;
else
K = No;
Cifthen(P, P + 3, Markui, Marke, Markr, K);
goto Enterelselab;
Esw_3:;
if (Ccres != 1) {
if (Start)
Setline();
if (!Thenlab)
K = 0;
else
K = 2;
Cui(K);
Report = Reportui;
}
Enterelselab:;
if (Elselab > 0)
Elres = Enterlab(Elselab, 0b11 | Report << 2);
Esw_4:;
}
void Cstart(int Ccres, int Code) {
int Skipcode;
int Finishar;
int Oldnextp;
int Oldline;
Skipcode = No;
if (1 <= Code && Code <= 2 && (Ccres | Code) == 3)
Skipcode = Yes;
Finishar = Fromar4(P);
if (Finishar <= P)
Abort();
Oldline = Line;
do {
Oldnextp = Nextp;
if (!Skipcode)
Compileastmnt();
else {
Line = A[Nextp + 3] << 8 | A[Nextp + 4];
Nextp =
Nextp + (A[Nextp] << 16) + (A[Nextp + 1] << 8) + A[Nextp + 2];
}
} while (Oldnextp < Finishar);
P = Finishar + 6;
if (A[P] <= 2 && Code != 1)
Fault2(45 + Code, Oldline, 0);
if (Skipcode == Yes)
Lastinst = 1;
}
void Ccycbody(int Ua, int Elab, int Clab) {
int Finishar;
int Oldline;
int Savee;
int Savec;
Finishar = Fromar4(P);
if (Finishar <= P)
Abort();
Oldline = Line;
Savee = Exitlab;
Savec = Contlab;
Exitlab = Elab;
Contlab = Clab;
while (Nextp <= Finishar)
Compileastmnt();
Exitlab = Savee;
Contlab = Savec;
P = Finishar + 6;
if (A[P] == 1 && Ua == 0)
Fault2(12, Oldline, 0);
}
void Cloop(int Alt, int Markc, int Markui) {
int L1;
int L2;
int L3;
int Ccres;
int Elres;
int Forname;
int Inittype;
int Initval;
int Steptype;
int Stepval;
int Finaltype;
int Finalval;
int Facc;
int Fdisp;
int Fbase;
int Initp;
int Repmask;
int Usedebj;
int Debto;
auto void Forexp(int *Etype, int *Evalue, int Tt, int Reg);
auto void Validatefor(void);
static int Sw_sw;
static void *Sw[7 /*0:6*/] = {
&&Sw_0, &&Sw_1, &&Sw_2, &&Sw_3, &&Sw_4, &&Sw_5, &&Sw_6,
};
P = Markc;
Sflabel -= 2;
L1 = Sflabel;
L2 = L1 + 1;
L3 = 0;
if (0b1100001 & 1 << Alt) {
L3 = Sflabel - 1;
Sflabel = L3;
}
if (1 <= Alt && Alt <= 3)
Setline();
if (0b0110111 & 1 << Alt)
Elres = Enterlab(L1, 0);
goto *Sw[Sw_sw = Alt];
Sw_0:;
Ccycbody(1, L2, L3);
Elres = Enterlab(L3, 0b011);
if (A[P] == 1) {
P++;
Ccres = Ccond(0, 1, L1);
} else
Enterjump(15, L1, 0);
Elres = Enterlab(L2, 0b011);
Wayout:;
Removelab(L1);
Removelab(L2);
if (L3 > 0)
Removelab(L3);
return;
Sw_1:;
Ccres = Ccond(0, 1, L2);
P = Markui;
Cui(1);
Enterjump(15, L1, 0);
Elres = Enterlab(L2, 0b111);
goto Wayout;
Sw_2:;
P = Markui;
Cui(1);
P = Markc;
Ccres = Ccond(0, 1, L1);
goto Wayout;
Sw_3:;
Sw_6:;
Forname = Fromar2(P);
Initp = P + 2;
P = Initp;
Copytag(Forname);
Fdisp = K;
Fbase = I;
Facc = 2 * Nam;
if (Type != 1 || Prec != 5 || Rout != 0 || 0 != Arr)
Fault2(91, 0, Forname);
if (Fbase != Rbase)
Warn(4, Forname);
Skipexp();
Forexp(&Steptype, &Stepval, 1, Accr);
if (!Steptype) {
if (!Stepval)
Fault2(92, 0, 0);
} else {
if (Parmopt)
Ppj(26, 11);
}
Forexp(&Finaltype, &Finalval, 1, Accr);
P = Initp;
Forexp(&Inittype, &Initval, 0, Breg);
if (Parmopt)
Validatefor();
Usedebj = 0;
if (Stepval == -1 && (Finaltype | Steptype) == 0 && Finalval == 1) {
Usedebj = 1;
if (!Inittype)
Psf1(Lb, 0, Initval);
if (Inittype != 0 || Initval < 1)
Enterjump(32 + 13, L2, 0b10);
Debto = Ca;
} else {
if (!(Inittype | Steptype))
Psf1(Lb, 0, Initval - Stepval);
else {
if (!Inittype)
Psf1(Lb, 0, Initval);
Psf1(Sbb, Steptype, Stepval);
}
if (Steptype == 1) {
Pf1(Lss, 0, Breg, 0);
Psf1(Irsb, Finaltype, Finalval);
Psf1(Idv, 1, Stepval);
Gruse[Accr] = 0;
Enterjump(37, L2, 0b10);
Repmask = 7;
} else
Repmask = 8 | (2 << ((unsigned)Stepval >> 31));
Elres = Enterlab(L1, 0);
if (Steptype == 0 && Stepval == 1)
Psf1(Cpib, Finaltype, Finalval);
else {
Psf1(Cpb, Finaltype, Finalval);
Psf1(Adb, Steptype, Stepval);
}
Gruse[Breg] = 0;
Enterjump(Repmask, L2, 0b10);
}
Base = Fbase;
Area = -1;
Psorlf1(Stb, Facc, Areacode(), Fdisp);
Noteassment(Breg, 2, Forname);
P = Markui;
if (Alt == 3)
Cui(0);
else {
Ccycbody(0, L2, L3);
Elres = Enterlab(L3, 0b011);
}
Base = Fbase;
Access = Facc;
Area = -1;
Disp = Fdisp;
Nameop(2, Breg, 4, Forname);
if (!Usedebj)
Enterjump(15, L1, 0);
else {
Psf1(Debj, 0, (Debto - Ca) / 2);
Gruse[Breg] = 0;
}
Elres = Enterlab(L2, 0b111 ^ (Usedebj << 2));
goto Wayout;
Sw_4:;
Ccres = Ccond(0, 1, L2);
Ccycbody(0, L2, L1);
Enterjump(15, L1, 0);
Elres = Enterlab(L2, 0b111);
goto Wayout;
Sw_5:;
P = Markui;
Ccycbody(0, L2, L3);
P = Markc;
Elres = Enterlab(L3, 0b011);
Ccres = Ccond(0, 1, L1);
Elres = Enterlab(L2, 0b011);
goto Wayout;
void Forexp(int *Etype, int *Evalue, int Totemp, int Usereg) {
int Inp;
int Val;
int Op;
Inp = P;
P += 3;
if (Intexp(&Val) == 0 && Imod(Val) < 0x1FFFF) {
*Evalue = Val;
*Etype = 0;
return;
}
P = Inp;
Csexp(Usereg, 0x51);
*Etype = 1;
if (Totemp) {
Getwsp(&Val, 1);
if (!Usereg)
Op = St;
else
Op = Stb;
Psf1(Op, 1, Val);
*Evalue = Val;
}
}
void Validatefor(void) {
int I;
if (!(Inittype | Steptype | Finaltype)) {
J = Finalval - Initval;
if ((J / Stepval) * Stepval != J)
Fault2(93, 0, 0);
return;
}
if (Steptype == 0 && Imod(Stepval) == 1)
return;
if (!Inittype)
Psf1(Lss, 0, Initval);
else
Pf1(Lss, 0, Breg, 0);
Psf1(Irsb, Finaltype, Finalval);
Psf1(Imdv, Steptype, Stepval);
Pf1(Lss, 0, Tos, 0);
Gruse[Accr] = 0;
Ppj(36, 11);
}
}
void Assign(int Assop, int P1) {
int Q;
int Qq;
int Kk;
int Typep;
int Precp;
int Ptypep;
int Jjj;
int P2;
int Jj;
int Reg;
int Stcode;
int Rhtype;
int Accp;
int Ii;
int Head1;
int Nops;
int Tpcell;
int Lvl;
int Bot1;
int Lhname;
int Rhname;
Rd R;
static int Sw_sw;
static void *Sw[4 /*0:3*/] = {
&&Sw_0,
&&Sw_1,
&&Sw_2,
&&Sw_3,
};
P2 = P;
if (Assop > 4)
Rhtype = Type;
Lhname = A[P1] << 8 | A[P1 + 1];
P = P1;
Reducetag();
Ptypep = Ptype;
Jj = J;
Kk = K;
Ii = I;
Lvl = Oldi;
Tpcell = Tcell;
Accp = Acc;
P = P2;
Typep = Type;
Precp = Prec;
goto *Sw[Sw_sw = Assop & 3];
Sw_2:
Sw_3:;
if (Type == 3)
goto Recop;
if (Type != 2 && Type != 5)
Type = 1;
if (Type == 5)
goto String;
Back:
Head1 = 0;
if (Type != 2)
Type = 1;
Typep = Type;
Nops = (1 << 18) + 1;
P = P2 + 3;
Push(&Head1, (Assop & 3) + 33, Precp, 0);
Bot1 = Head1;
Push(&Head1, Ptypep << 16 | 2, P1, 0);
if (Assop > 4) {
if (Type != Rhtype)
Fault(24, 0);
Push(&Head1, Rhtype << 16 | 9, 0, 0);
Olink[Accr] = Head1;
} else
Torp(&Head1, &Bot1, &Nops);
Expop(Head1, -1, Nops, 256 + (Precp << 4) + Typep);
Aslist[Bot1].Link = Asl;
Asl = Head1;
return;
String:;
if (A[P + 3] == 4 && A[P + 4] == 2 && A[P + 5] == 0x35 &&
A[P + 10] == 0 && A[P + 11] == 2) {
Q = P + 12 - ((unsigned)A[P + 10] >> 1);
P = P1;
Cname(1, Dr);
Pf2(Mvl, 0, 1, 0, 0, 0);
P = Q;
return;
}
if (Assop <= 3)
Cstrexp(0, Accr);
Assop = Assop & 3;
Qq = Stringl;
Q = P;
Register[Accr] = 1;
Olink[Accr] = Addr(R);
R.Ptype = 0x51;
R.Flag = 9;
R.Uptype = 0;
R.Xb = Accr;
P = P1;
Cname(1, Dr);
if (R.Flag != 9)
Pf1(Lsd, 0, Tos, 0);
Pf1(Iad, 0, Pc, Specialconsts(2));
if (Assop != 3 && (Rout != 0 || Nam != 0 && 0 == Arr) && Qq == 0) {
if (Parmopt)
Ppj(0, 18);
else {
Pf1(Stuh, 0, Breg, 0);
Pf1(Luh, 0, Breg, 0);
Pf1(Ldb, 0, Breg, 0);
}
Gruse[Breg] = 0;
}
Gruse[Accr] = 0;
Register[Accr] = 0;
if (Qq > 0 && Assop != 3)
Pf2(Mv, 0, 0, Qq, 0, 0);
else {
if (Assop == 3)
Pf1(Std, 0, Tos, 0);
Pf2(Mv, 1, 1, 0, 0, Unasspat & 255);
if (Parmarr != 0 || Assop == 3) {
Psf1(Ush, 0, 8);
Psf1(Ush, 0, -40);
}
if (Parmarr != 0 && Assop == 2)
Ppj(36, 9);
if (Assop == 3) {
Pf1(Irsb, 2, Tos, 0);
Pf1(St, 2, 7, 0);
}
}
P = Q;
return;
Recop:;
Reg = Accr;
Q = Tsexp(&Jjj);
if (Q == 1 && Jjj == 0) {
P = P1;
Cname(3, Dr);
if (Acc <= 128) {
Jj = 0;
Kk = Acc - 1;
} else {
Jj = 1;
Kk = 0;
if (Nam != 0 || Arr != 0)
Psf1(Ldb, 0, Acc);
}
Pf2(Mvl, Jj, 1, Kk, 0, 0);
} else {
if (Type != 3 || A[P2 + 3] != 4 || A[P2 + 4] != 1)
goto Back;
P = P2 + 5;
Cname(3, Accr);
Accp = Acc;
if (A[P] != 2) {
Fault2(66, 0, Lhname);
goto F00;
}
R.Ptype = 0x61;
R.Flag = 9;
R.Xb = Accr << 5;
R.D = 0;
Olink[Accr] = Addr(R);
Register[Accr] = 1;
P = P1;
Cname(3, Dr);
Register[Accr] = 0;
if (R.Flag != 9)
Pf1(Lsd, 0, Tos, 0);
if (Assop == 2 && Accp != Acc) {
Fault2(67, Lhname, Fromar2(P2 + 5));
goto F00;
}
if (Accp > Acc)
Accp = Acc;
do {
if (Accp > 128)
Kk = 128;
else
Kk = Accp;
Pf2(Mv, 0, 0, Kk - 1, 0, 0);
Accp -= Kk;
} while (Accp);
Gruse[Accr] = 0;
}
P = P2;
Skipexp();
Gruse[Dr] = 0;
return;
Sw_0:;
P = P1;
Cname(2, Dr);
P = P2;
if (Type == 5)
Cres(0);
else {
Skipexp();
if (Type != 7)
Fault2(71, 0, Fromar2(P1));
}
return;
Sw_1:;
Reg = Accr;
Stcode = St;
if (A[P2 + 3] != 4 || A[P2 + 4] != 1)
goto F81;
if (Nam != 1) {
Fault2(82, 0, Lhname);
goto F00;
}
P = P2 + 5;
Rhname = A[P] << 8 | A[P + 1];
if (Arr == 1)
goto Arrname;
if (A[P1 + 2] == 2 && 2 == A[P1 + 3]) {
Copytag(Rhname);
if (Ptype != Snpt && Arr != 0) {
Reg = Dr;
Stcode = Std;
}
}
Cname(3, Reg);
R.Ptype = 0x61;
R.Flag = 9;
R.Xb = Reg;
Olink[Reg] = Addr(R);
Register[Reg] = 1;
if (A[P] != 2)
goto F81;
Q = P + 1;
P = P1;
if (Type != Typep || Prec != Precp)
goto F83;
if (Oldi > Lvl && Base != 0 && Nam == 0)
goto F86;
Cname(6, 0);
if (R.Flag != 9) {
if (Reg)
Abort();
Pf1(Lsd, 0, Tos, 0);
Gruse[Accr] = 0;
}
Register[Reg] = 0;
Com:
Psorlf1(Stcode, Access, Areacode(), Disp);
if (Reg == Dr && Access != 0)
Abort();
Noteassment(Reg, 1, A[P1] << 8 | A[P1 + 1]);
P = Q;
return;
Arrname:
Cname(12, Accr);
if (Access >= 8)
Access -= 4;
else
Access = 0;
if (Type != Typep || Prec != Precp || Arr <= 0)
goto F83;
if (Oldi > Lvl && Base != 0 && Nam == 0)
goto F86;
Type = 0;
Nameop(2, Accr, 16, -1);
R.Ptype = 0x72;
R.Uptype = 0;
R.Flag = 9;
R.Xb = Accr;
R.D = -1;
Register[Accr] = 1;
Olink[Accr] = Addr(R);
if (A[P] != 2)
goto F81;
Q = P + 1;
P = P1;
Cname(6, 0);
if (R.Flag != 9)
Pf1(Lsq, 0, Tos, 0);
Register[Accr] = 0;
goto Com;
F83:
Fault2(83, Lhname, Rhname);
goto F00;
F86:
Fault2(86, Lhname, Rhname);
goto F00;
F81:
Fault2(81, 0, Lhname);
F00:;
Register[Reg] = 0;
P = P2;
Skipexp();
}
void Csexp(int Reg, int Mode) {
int Exphead;
int Nops;
int Expbot;
Exphead = 0;
Expbot = 0;
Nops = 0;
P += 3;
Torp(&Exphead, &Expbot, &Nops);
Expop(Exphead, Reg, Nops, Mode);
Aslist[Expbot].Link = Asl;
Asl = Exphead;
}
int Constexp(int Prectype) {
int Exphead;
int Expbot;
int Nops;
int Res;
Exphead = 0;
Expbot = 0;
Nops = 0;
Res = 0;
Torp(&Exphead, &Expbot, &Nops);
if (Nops & 0x00040000)
goto Wayout;
Expop(Exphead, Accr, Nops, 0x200 + Prectype);
if (Expopnd.Flag == 3) {
Res = Expopnd.Xtra;
goto Wayout;
}
if (Expopnd.Flag > 1)
goto Wayout;
Res = Addr(Expopnd.D);
Wayout:;
if (Res == 0 && Dcomp != 0)
_imp_monitor(0);
Aslist[Expbot].Link = Asl;
Asl = Exphead;
return (Res);
}
int Intexp(int *Value) {
int Exphead;
int Expbot;
int Nops;
int Code;
int Sptype;
int Sacc;
Exphead = 0;
Expbot = 0;
Nops = 0;
Code = 0;
Sptype = Ptype;
Sacc = Acc;
Torp(&Exphead, &Expbot, &Nops);
if ((Nops & 0x00040000) == 0 && Type == 1) {
Expop(Exphead, Accr, Nops, 0x251);
if (Expopnd.Flag > 1 || Expopnd.Ptype != 0x51)
Code = 1;
*Value = Expopnd.D;
} else {
Code = 1;
*Value = 1;
}
Aslist[Expbot].Link = Asl;
Asl = Exphead;
Acc = Sacc;
Ptype = Sptype;
Unpack();
return (Code);
}
void Torp(int *Head, int *Bot, int *Nops) {
static int Operand_sw;
static void *Operand[3 /*1:3*/] = {
&&Operand_1,
&&Operand_2,
&&Operand_3,
};
static const unsigned char Precedence[1+15 /*1:15*/] = {0,
3, 3, 4, 5, 5, 4, 3, 3, 4, 4, 5, 5, 3, 5, 5};
static const unsigned char Opval[1+15 /*1:15*/] = {0,
20, 21, 27, 37, 30, 24, 22, 23, 25, 26, 28, 29, 20, 37, 30};
int Rphead;
int Passhead;
int Savehead;
int Real;
int Realop;
int Complex;
int Operator;
int Opprec;
int Opnd;
int C;
int D;
int E;
int Rptype;
int Rpinf;
int Bdisp;
int Opname;
int Opmask;
int Xtra;
int Rpbot;
int Opstk;
int Oppstk;
int Passbot;
Listf *Lcell;
Passhead = 0;
Rphead = 0;
Savehead = 0;
Real = 0;
Realop = 0;
Bdisp = 0;
Rpbot = 0;
Opstk = 0;
Oppstk = 0;
C = A[P];
if (2 <= C && C <= 3) {
Nops++;
Opstk = 4 - C;
Oppstk = (C << 1) - 1;
Opmask = 1 << (19 + C);
} else
Opmask = 0;
Nextopnd:
Opnd = A[P + 1];
P += 2;
Complex = 0;
Xtra = 0;
goto *Operand[Operand_sw = (Opnd)-1];
Operand_1:;
Opname = (A[P] << 8) + A[P + 1];
Lcell = &Aslist[Tags[Opname]];
Ptype = (unsigned)Lcell->S1 >> 16;
if (Ptype == 0xFFFF)
Ptype = 7;
Type = Ptype & 7;
Prec = (unsigned)Ptype >> 4 & 15;
if (Ptype == Snpt) {
D = (unsigned)Lcell->S3 >> 16;
if (D == 38 && A[P + 2] == 2) {
Rptype = 0;
Rpinf = 10;
Ptype = 0x51;
P += 2;
goto Sknam;
}
if (D == 52 && A[P + 2] == 2) {
Rptype = 1;
Ptype = 0x62;
Rpinf = 0x413243F6;
Xtra = 0xA8885A31;
P += 2;
Real = 1;
goto Sknam;
}
Complex = 1;
Ptype = Tsname[D];
Unpack();
}
if ((Ptype & 0xFF00) == 0x4000 && A[P + 2] == 2 && 2 == A[P + 3] &&
1 <= Type && Type <= 2) {
Lcell->S1 = Lcell->S1 | 0x8000;
Rpinf = Lcell->S2;
Xtra = Lcell->S3;
Rptype = 1;
Ptype = Ptype & 255;
if (Type == 1 && Prec <= 5 && 0xFFFE0000 <= Rpinf &&
Rpinf <= 0x1FFFF) {
Rptype = 0;
Ptype = 0x51;
}
if (Prec == 7)
Rptype = 3;
if (Type == 2)
Real = 1;
P += 2;
goto Sknam;
}
Xtra = Opname;
if ((Ptype & 0x3F00) != 0 || Parmchk == 1 || Prec < 5) {
Complex = 1;
Xtra = -1;
}
Opmask = Opmask | (Complex << 19);
if (A[P + 2] != 2 || A[P + 3] != 2)
Xtra = -1;
if (Type == 3) {
D = P;
Kform = Lcell->S3 & 0xFFFF;
C = Copyrecordtag(&E);
P = D;
if (E != 1 || 1 > Type || Type > 2 || Nam != Arr || Arr != 0 ||
Prec == 3)
Complex = 1;
}
if (Prec >= 6)
Opmask = Opmask | 1 << 17;
Rptype = 2;
Rpinf = P;
if (Ptype == 7)
Ptype = 0x51;
if (Type == 5) {
Fault2(76, 0, Opname);
Rptype = 0;
Ptype = 0x51;
}
if (Type == 2)
Real = 1;
P += 2;
Sknam:
if (A[P] == 2)
P++;
else
Skipapp();
if (A[P] == 1) {
P += 3;
goto Sknam;
}
P += 2;
Ins:
if (Rptype == 2)
Opmask = Opmask | 1 << 18;
Binsert(&Rphead, &Rpbot, Ptype << 16 | Complex << 8 | Rptype, Rpinf,
Xtra);
goto Op;
Operand_2:;
Ptype = A[P];
D = (unsigned)Ptype >> 4;
C = Ptype & 7;
if (D == 4) {
Rpinf = Fromar2(P + 1);
Ptype = 0x51;
} else
Rpinf = Fromar4(P + 1);
if (C == 2)
Real = 1;
Rptype = 1;
if (D == 6)
Xtra = Fromar4(P + 5);
if (C == 5) {
Fault2(77, 0, 0);
Rpinf = 1;
Rptype = 0;
P = P + A[P + 5] + 7;
Ptype = 0x51;
} else {
if (D == 7) {
Xtra = Addr(A[P + 1]);
Rptype = 3;
}
if (Ptype == 0x51 && 0xFFFE0000 <= Rpinf && Rpinf <= 0x1FFFF)
Rptype = 0;
P = P + 2 + Bytes[D];
}
goto Ins;
Operand_3:;
Passhead = 0;
Passbot = 0;
P += 3;
Torp(&Passhead, &Passbot, Nops);
if (Type == 2)
Real = 1;
if (!Rpbot)
Rphead = Passhead;
else
Aslist[Rpbot].Link = Passhead;
Rpbot = Passbot;
P++;
Op:;
if (A[P - 1] == 2)
goto Eoe;
Operator = A[P];
if (Operator == Concop)
Fault2(78, 0, 0);
Opprec = Precedence[Operator];
Operator = Opval[Operator];
if (Operator == 26 || Operator == 30)
Real = 1;
Nops++;
while (Opprec <= (Oppstk & 31)) {
Binsert(&Rphead, &Rpbot, (Opstk & 31) + 9, 0, 0);
Opstk = (unsigned)Opstk >> 5;
Oppstk = (unsigned)Oppstk >> 5;
}
Opstk = Opstk << 5 | (Operator - 9);
Oppstk = Oppstk << 5 | Opprec;
if (Operator >= 31)
Operator = 30;
Opmask = Opmask | (1 << Operator);
goto Nextopnd;
Eoe:;
while (Opstk) {
Binsert(&Rphead, &Rpbot, (Opstk & 31) + 9, 0, 0);
Opstk = (unsigned)Opstk >> 5;
}
Ptype = Real + 1;
Type = Ptype;
if (!Head)
*Bot = Rpbot;
else
Aslist[Rpbot].Link = *Head;
*Head = Rphead;
*Nops = *Nops | Opmask;
}
void Expop(int Inhead, int Reg, int Nops, int Mode) {
auto void Ctop(int *A);
auto void Vmy(void);
auto void Vmy1(void);
auto void Choose(int *I);
auto void Put(void);
auto void Starstar(void);
auto void Rexp(void);
auto void Load(Rd * Op, int Reg, int Mode);
auto void Float(Rd * Opnd, int Otherptype);
auto void Coercet(Rd * Op1, Rd * Op2, int Mode);
auto void Coercep(Rd * Op1, Rd * Op2);
auto void Lengthen(Rd * Op);
auto void Shorten(Rd * Op);
int Operand[1+2 /*1:2*/];
int Stk[100 /*0:99*/];
Listf *List;
Rd *Opnd1;
Rd *Opnd2;
Rd *Opnd;
int C;
int D;
int Kk;
int Jj;
int Opcode;
int Comm;
int Xtra;
int Pp;
int Pt;
int Jjj;
int Loadreg;
int Evalreg;
int Stptr;
int Constform;
int Condform;
int Savep;
static const int Mcinst[10+28 /*10:37*/] = { [ 0 ... 9 ] = 0,
0x8E8E, 0xF4F4E4E4,
0xA8A8, 0xF4F4E4E4,
[4 ... 9] = 0, 0xF0F0E0E0,
0xF2F4E2E4, 0x8E8E,
0x8C8C, 0xFAFAEAEA,
0xAAAC, 0xBABC0000,
0x8A8A, [18 ... 19] = 0xC800,
0xFA000000, 0xF6F6E6E6,
0x00F600E6, 0x2C002C00,
0x02000200, [25 ... 26] = 0x48004800,
0xEA00};
static const unsigned char Corules[20+18 /*20:37*/] = { [ 0 ... 19 ] 0,
[20 ... 21] = 0x1F,
[22 ... 23] = 0x11,
0x1F,
0x11,
0x12,
0x11,
1,
1,
0,
[31 ... 32] = 0x1F,
[33 ... 36] = 0,
1};
static const unsigned char Fcomp[1+28 /*1:28*/] = {0,
8, 10, 2, 7, 12, 4, 7, 8, 12, 4, 7, 10, 2, 7,
16, 34, 17, 32, 33, 18, 32, 16, 33, 18, 32, 34, 17, 32};
static int Sw_sw;
static void *Sw[28 /*10:37*/] = {
&&Sw_10, &&Sw_11, &&Sw_12, &&Sw_13,
&&Sw_14, &&Sw_default, &&Sw_default, &&Sw_default,
&&Sw_default, &&Sw_default, &&Sw_20, &&Sw_21,
&&Sw_22, &&Sw_23, &&Sw_24, &&Sw_25,
&&Sw_26, &&Sw_27, &&Sw_28, &&Sw_29,
&&Sw_30, &&Sw_31, &&Sw_32, &&Sw_33,
&&Sw_34, &&Sw_35, &&Sw_36, &&Sw_37,
};
Stptr = 0;
Constform = Mode & 512;
Condform = Mode & 256;
Savep = P;
Evalreg = Accr;
if (Reg == Breg && (Nops & 0x7EC20000) == 0)
Evalreg = Breg;
Next:
List = &Aslist[Inhead];
C = List->S1;
Xtra = List->S2;
Jj = C & 255;
D = Inhead;
Inhead = List->Link;
if (Jj >= 10)
goto Operator;
Operand[1] = Addr(Aslist[D]);
Opnd1 = Record(Addr(Aslist[D]));
if (Opnd1->Flag == 2 && Opnd1->Xb != 0)
Load(Opnd1, Evalreg, 0);
Stk[Stptr] = Operand[1];
Stptr++;
if (Stptr > 99)
Abort();
Anymore:;
if (Inhead != 0 && Mode != 100)
goto Next;
goto Finish;
Operator:;
if (Jj < 19)
Kk = 1;
else
Kk = 2;
for (Kk = Kk; Kk >= 1; Kk--) {
Stptr--;
C = Stk[Stptr];
Operand[Kk] = C;
}
Opcode = Mcinst[Jj];
Comm = 1;
Opnd1 = Record(Operand[1]);
Opnd2 = Opnd1;
if (Jj >= 19) {
Opnd2 = Record(Operand[2]);
C = Corules[Jj];
if (C & 15)
Coercet(Opnd1, Opnd2, C & 15);
if ((unsigned)C >> 4)
Coercep(Opnd1, Opnd2);
}
if (Jj > 19) {
Choose(&Comm);
Opnd1 = Record(Operand[Comm]);
Opnd2 = Record(Operand[3 - Comm]);
}
Ptype = Opnd1->Ptype;
Type = Ptype & 7;
if (Type == 1)
Opcode = Opcode & 0xFFFF;
else
Opcode = (unsigned)Opcode >> 16;
if (2 != Opnd1->Flag && Opnd1->Flag < 4 && 2 != Opnd2->Flag &&
Opnd2->Flag < 4)
Ctop(&Jj);
if (!Jj)
goto Stres;
goto *Sw[Sw_sw = (Jj)-10];
Sw_10:;
Load(Opnd1, Evalreg, 2);
if (Type != 1 && Type != 7)
Fault(24, 0);
Psf1(Opcode & 255, 0, -1);
Gruse[Evalreg] = 0;
Suse:
Olink[Evalreg] = Operand[Comm];
Stres:
Stk[Stptr] = Operand[Comm];
Stptr++;
goto Anymore;
Sw_11:;
Load(Opnd1, Evalreg, 2);
if (Evalreg == Breg) {
Psf1(Slb, 0, 0);
Pf1(Sbb, 0, Tos, 0);
} else
Psf1(Opcode & 255, 0, 0);
Gruse[Evalreg] = 0;
goto Suse;
Sw_12:;
Abort();
Sw_13:;
Load(Opnd1, Evalreg, 2);
if (Type == 2)
C = 2;
else
C = 6;
Pf3(Jaf, C, 0, 3);
Psf1(Opcode & 255, 0, 0);
Gruse[Evalreg] = 0;
goto Suse;
Sw_14:;
Abort();
Sw_20:;
if (Type == 1 && Gruse[Evalreg] == 10 && Opnd1->Flag == 2 &&
Opnd2->Flag == 0 && Register[Evalreg] == 0) {
P = Opnd1->D;
D = Grinf1[Evalreg];
if (Fromar2(P) == (D & 0xFFFF) && A[P + 2] == 2 && 2 == A[P + 3]) {
if (!Evalreg)
C = Iad;
else
C = Adb;
Psf1(C, 0, Opnd2->D - ((unsigned)D >> 16));
Grinf1[Evalreg] = D & 0xFFFF | Opnd2->D << 16;
Register[Evalreg] = 1;
Opnd1->Flag = 9;
Opnd1->Xb = Evalreg << 4;
Opnd1->D = 0;
goto Suse;
}
}
Binop:
Load(Opnd1, Evalreg, 2);
Load(Opnd2, Evalreg, 1);
Put();
goto Suse;
Sw_21:;
goto Binop;
Sw_22:;
Sw_23:;
Sw_27:;
if (Type == 1)
goto Binop;
F24:
if (Type != 7)
Fault(24, 0);
Jj = 20;
Opcode = Mcinst[20];
goto Binop;
Sw_28:;
if (!Opnd2->Flag)
Opnd2->D = -Opnd2->D;
else {
Load(Opnd2, Evalreg, 2);
Psf1(Irsb, 0, 0);
Gruse[Evalreg] = 0;
}
Sw_29:;
if ((unsigned)Opnd2->Ptype >> 4 == 6)
Shorten(Opnd2);
goto Binop;
Sw_24:;
goto Binop;
Sw_25:;
if (Type != 1)
goto F24;
goto Binop;
Sw_26:;
goto Binop;
Sw_30:;
if ((Opnd1->Ptype & 7) == 1)
Float(Opnd1, 0);
if ((Opnd2->Ptype & 7) == 1) {
Starstar();
goto Suse;
}
Rexp();
Comm = 2;
goto Suse;
Sw_37:;
Starstar();
goto Suse;
Sw_31:;
Sw_32:;
Ptype = Opnd1->Ptype;
if (Opnd1->Flag <= 1 && Opnd1->D == 0 && Jj == 31 &&
(Opnd1->Xtra == 0 || (unsigned)Ptype >> 4 == 5))
goto Z1;
if (Opnd2->Flag <= 1 && Opnd2->D == 0 &&
(Opnd2->Xtra == 0 || (unsigned)Opnd2->Ptype >> 4 == 5))
goto Z2;
Load(Opnd1, Evalreg, 2);
Load(Opnd2, Evalreg, 1);
Put();
Register[Evalreg] = 0;
Bfflag = Comm - 1;
Mask = Fcomp[Xtra + 7 * Bfflag];
Comm = 2;
goto Stres;
Z1:
Comm -= 3;
Z2:
Opnd = Record(Operand[Comm]);
C = Evalreg;
D = Evalreg ^ 7;
if (Opnd->Flag == 2 && Gruse[D] == 9 &&
((Grinf1[D] & 0xFFFF) == Opnd->Xtra ||
(unsigned)Grinf1[D] >> 16 == Opnd->Xtra))
C = D;
Load(Opnd, C, 2);
Register[C] = 0;
Mask = Fcomp[Xtra + 7 * Comm + 7];
if (Type == 1)
Mask += 4;
if (C == Breg)
Mask += 8;
Comm = 2;
goto Stres;
Sw_33:;
C = (unsigned)Opnd2->D >> 24;
D = (unsigned)Opnd2->D >> 16 & 31;
if (D == 1)
Vmy1();
else
Vmy();
if (Opnd1->Flag > 1)
Olink[Loadreg] = Operand[Comm];
if (C == 1)
goto Stres;
goto Anymore;
Sw_34:;
Abort();
Sw_35:;
Sw_36:;
Pt = Opnd2->Ptype;
Pp = Opnd2->D;
if ((Pt & 7) == 1 && (Opnd1->Ptype & 7) == 2)
Fault(24, 0);
if ((Pt & 7) == 2 && (Opnd1->Ptype & 7) == 1)
Float(Opnd1, Opnd2->Ptype);
Load(Opnd1, Evalreg, 2);
Register[Evalreg] = 2;
C = (unsigned)Pt >> 4;
D = (unsigned)Opnd1->Ptype >> 4;
if (C < 5)
C = 5;
if (D < 5)
D = 5;
while (D < C) {
Lengthen(Opnd1);
D = (unsigned)Opnd1->Ptype >> 4;
}
while ((C < D && Type == 1 && Jj != 36) || C < D - 1) {
Shorten(Opnd1);
D = (unsigned)Opnd1->Ptype >> 4;
}
P = Pp;
Cname(1, 0);
D = Disp;
C = Access;
Jjj = Area;
Kk = Prec;
Load(Opnd1, Evalreg, 2);
if (Jj == 36 && Type == 1) {
if (3 <= Xtra && Xtra <= 4) {
Pf1(And, 0, 0, (unsigned)(-1) >> (8 * (6 - Xtra)));
Gruse[Accr] = 0;
}
if (Kk <= 5 && Prec == 6) {
Psf1(Mpsr, 0, 17);
Gruse[Accr] = 0;
}
}
if (Type == 2 && Kk < Prec)
Kk = Stuh;
else
Kk = St;
if (Evalreg == Breg)
Kk = Stb;
Psorlf1(Kk, C, Jjj, D);
if (((C & 1) == 0 && Stname > 0) ||
(C == 3 && (unsigned)Stname >> 16 > 0))
Noteassment(Evalreg, Jj - 33, Stname);
if (C >= 2 && Jjj != 7)
if (Stname > 0) {
Gruse[Dr] = 7;
Grinf1[Dr] = Stname & 0xFFFF;
} else
Gruse[Dr] = 0;
if (Kk == Stuh)
Gruse[Accr] = 0;
Comm = 1;
goto Stres;
Finish:
C = Stk[Stptr - 1];
Operand[1] = C;
Opnd1 = Record(C);
if (((unsigned)Opnd1->Ptype >> 4 & 15) < 5)
Opnd1->Ptype = Opnd1->Ptype & 0xF | 0x50;
if (!Condform) {
D = (unsigned)Mode >> 4 & 7;
if (D < 5)
D = 5;
if ((Mode & 7) == 2 && (Opnd1->Ptype & 7) == 1)
Float(Opnd1, D << 4);
while (D<(unsigned)Opnd1->Ptype>> 4)
Shorten(Opnd1);
while (D > (unsigned)Opnd1->Ptype >> 4)
Lengthen(Opnd1);
if (Constform == 0 || 2 <= Opnd1->Flag && Opnd1->Flag != 3)
Load(Opnd1, Reg, 2);
}
Expopnd = *Opnd1;
Ptype = Opnd1->Ptype;
Type = Ptype & 7;
Prec = (unsigned)Ptype >> 4;
if (Type == 2 && (Mode & 7) == 1)
Fault(24, 0);
if (Opnd1->Flag == 9)
Register[(unsigned)Opnd1->Xb >> 4] = 0;
P = Savep;
return;
void Choose(int *Choice) {
Rd *Opnd1;
Rd *Opnd2;
Opnd1 = Record(Operand[1]);
Opnd2 = Record(Operand[2]);
*Choice = 1;
if (Jj == 21 && Evalreg == Breg)
return;
if ((Opcode & 0xFF00FF00) == 0 ||
((Opcode & 0xFF00FF) != 0 &&
(Opnd2->Flag == 9 ||
(Opnd2->Flag == 2 && Gruse[Evalreg] == 9 &&
Grinf1[Evalreg] == Opnd2->Xtra && Opnd2->Xtra > 0))))
*Choice = 2;
}
void Load(Rd * Opnd, int Reg, int Mode) {
int K;
int Kk;
static int Sw_sw;
static void *Sw[10 /*0:9*/] = {
&&Sw_0, &&Sw_1, &&Sw_2, &&Sw_3, &&Sw_4,
&&Sw_5, &&Sw_6, &&Sw_7, &&Sw_8, &&Sw_9,
};
K = Opnd->Flag;
if (Mode != 2 && K != 2 && (K > 3 || Mode != 1))
return;
Ptype = Opnd->Ptype;
Type = Ptype & 15;
Prec = (unsigned)Ptype >> 4;
if (K < 0 || K > 9)
Abort();
goto *Sw[Sw_sw = K];
Sw_0:
Litconst:;
Area = 0;
Access = 0;
if (Prec <= 5)
Disp = Opnd->D;
else {
Disp = Opnd->Xtra;
if ((Disp < 0 || Opnd->D != 0) && (Disp >= 0 || Opnd->D != -1))
Abort();
}
if (Mode == 2) {
if ((Gruse[Reg] & 255) == 5 && 5 == Prec && Grinf1[Reg] == Disp) {
if (Register[Reg])
Bootout(Reg);
} else
Getinacc(Reg, (unsigned)Bytes[Prec] >> 2, Access, Area, Disp);
if (Prec <= 5) {
Gruse[Reg] = 5;
Grinf1[Reg] = Disp;
}
goto Lded;
}
if (Prec == 3)
Opnd->Ptype = 0x51;
Opnd->Flag = 7;
Opnd->Xb = Area << 4 | Access;
Opnd->D = Disp;
return;
Sw_1:;
if (Opnd->D == 0 && 0 == Opnd->Xtra && Prec <= 6)
goto Litconst;
Sw_3:;
if (Prec == 7)
Kk = Opnd->Xtra;
else
Kk = Addr(Opnd->D);
Storeconst(&Disp, Bytes[Prec], Kk);
if (Mode != 2) {
Opnd->Flag = 7;
Opnd->Xb = Pc << 4;
Opnd->D = Disp;
return;
}
if ((Gruse[Reg] & 255) == 6 && Grinf1[Reg] == Disp) {
if (Register[Reg])
Bootout(Reg);
} else
Getinacc(Reg, (unsigned)Bytes[Prec] >> 2, 0, Pc, Disp);
Gruse[Reg] = 6;
Grinf1[Reg] = Disp;
goto Lded;
Sw_2:;
P = Opnd->D;
if (Mode == 2 || Opnd->Xb != 0)
goto Load;
Cname(5, Reg);
if (Nest >= 0)
goto Lded;
Area = -1;
Area = Areacode();
Opnd->Ptype = Ptype;
Opnd->Flag = 7;
Opnd->Xb = Area << 4 | Access;
Opnd->D = Disp;
return;
Load:
Cname(2, Reg);
Lded:
Register[Reg] = 1;
Olink[Reg] = Addr(Opnd);
if (Prec < 5)
Opnd->Ptype = Opnd->Ptype & 15 | 0x50;
Opnd->Flag = 9;
Opnd->D = 0;
Opnd->Xb = Reg << 4;
if (Reg == Breg && (Register[Accr] & 1) != 0)
Register[Breg] = 2;
return;
Sw_4:;
Sw_5:;
Sw_6:;
Abort();
Sw_7:;
Area = (unsigned)Opnd->Xb >> 4;
Access = Opnd->Xb & 15;
Disp = Opnd->D;
Pickup:
Getinacc(Reg, (unsigned)Bytes[Prec] >> 2, Access, Area, Disp);
goto Lded;
Sw_8:;
Area = Tos;
Access = 0;
Disp = 0;
goto Pickup;
Sw_9:;
if ((unsigned)Opnd->Xb >> 4 == Reg)
goto Lded;
if (Reg) {
if (Register[Breg])
Bootout(Breg);
Pf1(St, 0, Breg, 0);
} else
Getinacc(Accr, 1, 0, Breg, 0);
Register[(unsigned)Opnd->Xb >> 4] = 0;
Opnd->Xb = Reg << 4;
Gruse[Reg] = 0;
Register[Reg] = 1;
Olink[Reg] = Addr(Opnd);
}
void Put(void) {
int Code;
int Ocode;
Code = Opcode;
if (Comm == 1)
Code = (unsigned)Code >> 8;
Code = Code & 255;
Ocode = Code;
if (Evalreg == Breg)
Code -= 0xC0;
if (Opnd1->Flag != 9)
Abort();
Psorlf1(Code, Opnd2->Xb & 15, (unsigned)Opnd2->Xb >> 4, Opnd2->D);
if (Ocode == Iad && Gruse[Evalreg] == 9 && Opnd2->Xb == 0 &&
Opnd2->D < 4095 && (unsigned)Grinf1[Evalreg] >> 16 == 0) {
Gruse[Evalreg] = 10;
Grinf1[Evalreg] = Grinf1[Evalreg] & 0xFFFF | Opnd2->D << 16;
} else if (31 > Jj || Jj > 32)
Gruse[Evalreg] = 0;
Olink[Evalreg] = Operand[Comm];
}
void Float(Rd * Opnd, int Otherptype) {
if (Opnd->Flag <= 1) {
Cvalue = Opnd->D;
Opnd->D = *Integer(Addr(Cvalue));
Opnd->Xtra = *Integer(Addr(Cvalue) + 4);
Opnd->Flag = 1;
} else {
Load(Opnd, Accr, 2);
if ((Otherptype & 0xF0) == 0x70 && (Opnd->Ptype & 0xF0) <= 0x50) {
Psf1(Imyd, 0, 1);
Opnd->Ptype = Opnd->Ptype & 15 | 0x60;
}
Psf1(Flt, 0, 0);
Gruse[Accr] = 0;
}
Opnd->Ptype = Opnd->Ptype + 0x11;
Type = 2;
}
void Coercet(Rd * Opnd1, Rd * Opnd2, int Mode) {
int Pt1;
int Pt2;
Pt1 = Opnd1->Ptype & 7;
Pt2 = Opnd2->Ptype & 7;
if ((Mode == 1 || Mode == 15) && Pt1 == 1 && 1 == Pt2)
return;
if (Mode == 1) {
Fault(24, 0);
return;
}
if (Pt1 == 1)
Float(Opnd1, Opnd2->Ptype);
if (Pt2 == 1)
Float(Opnd2, Opnd1->Ptype);
}
void Coercep(Rd * Opnd1, Rd * Opnd2) {
int Prec1;
int Prec2;
Prec1 = (unsigned)Opnd1->Ptype >> 4;
Prec2 = (unsigned)Opnd2->Ptype >> 4;
while (Prec1 < Prec2) {
Lengthen(Opnd1);
Prec1 = (unsigned)Opnd1->Ptype >> 4;
}
while (Prec2 < Prec1) {
Lengthen(Opnd2);
Prec2 = (unsigned)Opnd2->Ptype >> 4;
}
}
void Lengthen(Rd * Opnd) {
int Tp;
int Pr;
Tp = Opnd->Ptype & 7;
Pr = (unsigned)Opnd->Ptype >> 4;
if (Opnd->Flag <= 1 && Pr <= 4 + Tp)
if (Tp == 1 && Opnd->Flag <= 1) {
Opnd->Xtra = Opnd->D;
if (Opnd->Xtra < 0)
Opnd->D = -1;
else
Opnd->D = 0;
} else if (Pr == 6) {
Toar8(R, *Longreal(Addr(Opnd->D)));
Toar8(R + 8, 0);
Opnd->Xtra = Addr(A[R]);
Opnd->Flag = 3;
R += 16;
} else
Opnd->Xtra = 0;
else {
Load(Opnd, Accr, 2);
if (Tp == 1)
Psf1(Imyd, 0, 1);
else
Pf1(Rmyd, 0, Pc, Specialconsts(1));
Gruse[Accr] = 0;
}
Opnd->Ptype = ((Pr + 1) << 4) + Tp;
}
void Shorten(Rd * Opnd) {
int Ty;
int Pr;
int F;
int I;
int J;
Ty = Opnd->Ptype & 7;
Pr = (unsigned)Opnd->Ptype >> 4;
F = Opnd->Flag;
if (F == 3) {
for (I = 0; I <= 3; I++)
*Byteinteger(Addr(J) + I) = *Byteinteger(Opnd->Xtra + 4 + I);
Opnd->Xtra = J;
Opnd->Flag = 1;
goto Wayout;
}
if (F <= 1) {
if (Ty == 2)
goto Wayout;
if ((Opnd->D == 0 && Opnd->Xtra >= 0) ||
(Opnd->D == -1 && Opnd->Xtra < 0)) {
Opnd->D = Opnd->Xtra;
goto Wayout;
}
}
Load(Opnd, Accr, 2);
if (Pr == 7)
Pf1(Rddv, 0, Pc, Specialconsts(1));
else {
if (Type == 1 && 1 == Parmarr)
Psf1(Ish, 0, 32);
if (Parmarr == 1 || Type != 1)
Psf1(Ush, 0, -32);
if (!Register[Breg]) {
Pf1(Stuh, 0, Breg, 0);
Gruse[Breg] = 0;
} else
Psf1(Mpsr, 0, 17);
}
Gruse[Accr] = 0;
Wayout:;
Opnd->Ptype = ((Pr - 1) << 4) + Ty;
}
void Extract(Rd * Opnd, long long int *Val, double *Rval) {
int Type;
int Prec;
int S;
int I;
int Ad;
Type = Opnd->Ptype;
Prec = (unsigned)Type >> 4;
Type = Type & 15;
if (Type == 1) {
if (Prec <= 5)
*Val = Opnd->D;
else {
*Integer(Addr(Val)) = Opnd->D;
*Integer(Addr(Val) + 4) = Opnd->Xtra;
}
*Rval = *Val;
} else {
Rval = 0;
if (Prec == 7) {
S = 15;
Ad = Opnd->Xtra;
} else {
S = 7;
Ad = Addr(Opnd->D);
}
for (I = 0; I <= S; I++)
*Byteinteger(Addr(Rval) + I) = *Byteinteger(Ad + I);
}
}
void Vmy1(void) {
int Opname;
int Vuse;
int Dvpos;
int Dvname;
int X;
int Y;
int Dtype;
int Dprec;
int Dacc;
int Dptype;
Dptype = (unsigned)Xtra >> 16;
Dvname = Xtra & 0xFFFF;
Dvpos = Opnd2->D & 0xFFFF;
if (Dvpos > 0 && Opnd1->Flag <= 1) {
X = Opnd1->D;
// X=X-CTABLE_val(DVPOS+3)
X -= Ctable->Val[Dvpos+3];
// X=X*CTABLE_val(DVPOS+4)
X = X * Ctable->Val[Dvpos+4];
// %IF X<0 %OR X>=CTABLE_val(DVPOS+5) %THEN FAULT2(50,X,DVNAME)
if (X < 0 || X >= Ctable->Val[Dvpos+5])
Fault2(50, X, Dvname);
// %IF PARMARR=0=PARMCHK %AND DPTYPE&16_C0F<=3 %THEN X=X+CTABLE_val(DVPOS+3)*CTABLE_val(DVPOS+4)
if (Parmarr == 0 && 0 == Parmchk && (Dptype & 0xC0F) <= 3)
X += Ctable->Val[Dvpos+3] * Ctable->Val[Dvpos+4];
Opnd1->D = X;
return;
}
Opname = -1;
if (Opnd1->Flag == 2)
Opname = Opnd1->Xtra;
Vuse = Dvname | Opname << 16;
if (Opname >= 0 && Gruse[Breg] == 14 && Grinf1[Breg] == Vuse)
goto Done;
if (Parmarr == 0 && 0 == Parmchk && Dvpos > 0) {
Load(Opnd1, Breg, 2);
// X=CTABLE_val(DVPOS+4)
X = Ctable->Val[Dvpos+4];
if (X != 1) {
Psf1(Myb, 0, X);
Gruse[Breg] = 0;
}
// Y=X*CTABLE_val(DVPOS+3)
Y = X * Ctable->Val[Dvpos+3];
if ((Dptype & 0xC0F) <= 3) {
if (X != 1)
goto Done;
goto Out;
}
if (Y) {
Psf1(Sbb, 0, Y);
Gruse[Breg] = 0;
}
goto Done;
}
if (Parmarr == 0 && 0 == Parmchk &&
((Dptype & 0x300) == 0x200 || (Dptype & 0xC0F) <= 3 ||
Compiler != 0)) {
Dtype = Dptype & 15;
Dprec = (unsigned)Dptype >> 4 & 7;
if (Opnd1->Flag > 1)
Load(Opnd1, Breg, 2);
if (Dtype >= 3 || Dprec == 4) {
Dacc = List->S3;
if (Opnd1->Flag <= 1) {
Opnd1->D = Opnd1->D * Dacc;
return;
}
if (Dacc != 1)
Psf1(Myb, 0, Dacc);
Gruse[Breg] = 0;
goto Done;
}
if (Opnd1->Flag <= 1)
return;
Loadreg = Breg;
goto Out;
}
if (Opnd1->Flag == 9 && (unsigned)Opnd1->Xb >> 4 == Accr) {
Pf1(St, 0, Tos, 0);
Changerd(Accr);
Register[Accr] = 0;
}
Base = (unsigned)Opnd2->Xtra >> 18;
Area = -1;
Getinacc(Dr, 2, 0, Areacode(), (Opnd2->Xtra & 0x1FFFF) + 8);
Load(Opnd1, Evalreg, 0);
if ((unsigned)Opnd1->Ptype >> 4 >= 6)
Fault(24, 0);
if (Register[Breg] >= 1 &&
(Opnd1->Flag != 9 || (unsigned)Opnd1->Xb >> 4 != Breg)) {
Opnd = Record(Olink[Breg]);
Opnd->D = 0;
Register[Breg] = 2;
Bootout(Breg);
}
Area = (unsigned)Opnd1->Xb >> 4;
Access = Opnd1->Xb & 15;
Psorlf1((unsigned)Opcode >> 8, Access, Area, Opnd1->D);
Gruse[Breg] = 0;
Done:;
if (Opname >= 0) {
Gruse[Breg] = 14;
Grinf1[Breg] = Vuse;
Grinf2[Breg] = 0;
}
Out:;
Loadreg = Breg;
Register[Loadreg] = 1;
Opnd1->Flag = 9;
Opnd1->Xb = Loadreg << 4;
}
void Vmy(void) {
if (Opnd1->Flag == 9 && (unsigned)Opnd1->Xb >> 4 == Accr) {
Pf1(St, 0, Tos, 0);
Changerd(Accr);
Register[Accr] = 0;
}
if (C == D) {
Base = (unsigned)Opnd2->Xtra >> 18;
Area = -1;
Getinacc(Dr, 2, 0, Areacode(), (Opnd2->Xtra & 0x1FFFF) + 8);
}
Load(Opnd1, Evalreg, 0);
if ((unsigned)Opnd1->Ptype >> 4 >= 6)
Fault(24, 0);
if (C == D && Register[Breg] >= 1 &&
(Opnd1->Flag != 9 || (unsigned)Opnd1->Xb >> 4 != Breg)) {
Opnd = Record(Olink[Breg]);
Opnd->D = 0;
Register[Breg] = 2;
Bootout(Breg);
}
Area = (unsigned)Opnd1->Xb >> 4;
Access = Opnd1->Xb & 15;
Psorlf1((unsigned)Opcode >> 8, Access, Area, Opnd1->D);
Gruse[Breg] = 0;
Loadreg = Accr;
if (C == D)
Getinacc(Accr, 1, 0, 7, 0);
else
Pf1(Iad, 0, Breg, 0);
if (C == 1) {
Pf1(St, 0, Breg, 0);
Register[Accr] = 0;
Loadreg = Breg;
}
Register[Loadreg] = 1;
Opnd1->Flag = 9;
Opnd1->Xb = Loadreg << 4;
}
void Ctop(int *Flag) {
static const int Truncmask = 0x01300800;
int K;
int Typep;
int Precp;
int Op;
int Typepp;
int Val;
int Sval1;
int Sval2;
long long int Val1;
long long int Val2;
double Rval1;
double Rval2;
static int Isw_sw;
static void *Isw[23 /*10:32*/] = {
&&Isw_10, &&Isw_11, &&Isw_12, &&Isw_13,
&&Isw_14, &&Isw_default, &&Isw_default, &&Isw_default,
&&Isw_default, &&Isw_default, &&Isw_20, &&Isw_21,
&&Isw_22, &&Isw_23, &&Isw_24, &&Isw_25,
&&Isw_26, &&Isw_27, &&Isw_28, &&Isw_29,
&&Isw_30, &&Isw_31, &&Isw_32,
};
static int Rsw_sw;
static void *Rsw[23 /*10:32*/] = {
&&Rsw_default, &&Rsw_11, &&Rsw_12, &&Rsw_13,
&&Rsw_14, &&Rsw_default, &&Rsw_default, &&Rsw_default,
&&Rsw_default, &&Rsw_default, &&Rsw_20, &&Rsw_21,
&&Rsw_22, &&Rsw_23, &&Rsw_24, &&Rsw_25,
&&Rsw_26, &&Rsw_27, &&Rsw_28, &&Rsw_29,
&&Rsw_default, &&Rsw_31, &&Rsw_32,
};
if (_imp_on_event(1, 2))
return;
Typep = Type;
Precp = (unsigned)Ptype >> 4 & 15;
Op = *Flag;
Extract(Opnd1, &Val1, &Rval1);
Extract(Opnd2, &Val2, &Rval2);
Sval1 = Val1;
Sval2 = Val2;
if (Typep == 1 && Op == 37)
goto Isw37;
if (Op > 32)
return;
if (Typep == 2)
goto *Rsw[Rsw_sw = (Op)-10];
else
goto *Isw[Isw_sw = (Op)-10];
Isw_10:;
Val1 = ~Val1;
Intend:;
if (Precp == 6) {
Opnd1->D = (unsigned long long)Val1 >> 32;
Opnd1->Xtra = Val1;
*Flag = 0;
} else {
Val = Val1;
if (Val == Val1 || (1 << Op & Truncmask) == 0) {
*Flag = 0;
Opnd1->D = Val;
}
}
if (!*Flag) {
Opnd1->Ptype = Precp << 4 | 1;
if (0xFFFE0000 <= Val1 && Val1 <= 0x1FFFF)
Opnd1->Flag = 0;
else
Opnd1->Flag = 1;
}
return;
Isw_11:;
Val1 = -Val1;
goto Intend;
Isw_13:;
Val1 = Imod(Val1);
goto Intend;
Isw_12:;
Rval1 = Val1;
Precp = 5 + Xtra;
goto Realend;
Rsw_14:;
Precp++;
Realend:
Opnd1->Flag = 1;
Opnd1->D = *Integer(Addr(Rval1));
Opnd1->Xtra = *Integer(Addr(Rval1) + 4);
if (Precp == 7) {
Opnd1->Flag = 3;
Opnd1->Xtra = Addr(A[R]);
for (K = 0; K <= 15; K++) {
A[R] = *Byteinteger(Addr(Rval1) + K);
R++;
}
}
*Flag = 0;
Opnd1->Ptype = 16 * Precp + 2;
return;
Isw_14:;
Rsw_12:;
Abort();
Isw_20:;
Val1 += Val2;
goto Intend;
Isw_21:;
Val1 -= Val2;
goto Intend;
Isw_22:;
Val1 = Val1 ^ Val2;
goto Intend;
Isw_23:;
Val1 = Val1 | Val2;
goto Intend;
Isw_24:;
Val1 = Val1 * Val2;
goto Intend;
Isw_26:
return;
Isw_25:
if (!Val2)
return;
Val1 = Val1 / Val2;
goto Intend;
Isw_27:;
Val1 = Val1 & Val2;
goto Intend;
Isw_29:;
if (Precp == 6)
Val1 = Val1 << Sval2;
else
Val1 = Sval1 << Sval2;
goto Intend;
Isw_28:;
if (Precp == 6)
Val1 = (unsigned)Val1 >> Sval2;
else
Val1 = (unsigned)Sval1 >> Sval2;
goto Intend;
Isw_31:
Isw_32:;
Rsw_31:
Rsw_32:;
Bfflag = Comm - 1;
Mask = Fcomp[Xtra + 7 * Bfflag];
Comm = 2;
*Flag = 0;
if (Type == 2)
goto Rcomp;
if (((Mask & 8) != 0 && Val1 == Val2) ||
((Mask & 4) != 0 && Val1 < Val2) ||
((Mask & 2) != 0 && Val1 > Val2))
Mask = 15;
else
Mask = 0;
return;
Rcomp:;
if (((Mask & 8) != 0 && Rval1 == Rval2) ||
((Mask & 4) != 0 && Rval1 < Rval2) ||
((Mask & 2) != 0 && Rval1 > Rval2))
Mask = 15;
else
Mask = 0;
return;
Rsw_11:;
Rval1 = -Rval1;
goto Realend;
Rsw_13:;
Rval1 = Mod(Rval1);
goto Realend;
Rsw_20:;
Rval1 += Rval2;
goto Realend;
Rsw_21:;
Rval1 -= Rval2;
goto Realend;
Rsw_24:;
Rval1 = Rval1 * Rval2;
goto Realend;
Rsw_26:;
if (!Rval2)
return;
Rval1 = Rval1 / Rval2;
goto Realend;
Isw_30:;
Isw37:;
if (0 > Val2 || Val2 > 63)
return;
Val2 = 1;
while (Sval2 > 0) {
Val2 = Val2 * Val1;
Sval2--;
if (Val2 != *Integer(Addr(Val2) + 4))
return;
}
Val1 = Val2;
goto Intend;
Rsw_22:
Rsw_23:;
Rsw_25:
Rsw_27:
Rsw_28:
Rsw_29:;
goto Rsw_skip;
Rsw_default:
fprintf(stderr, "\nSwitch label 'Rsw(%d):' not set in %s\n",
Rsw_sw + 10, __PRETTY_FUNCTION__);
fflush(stderr);
abort();
Rsw_skip:;
goto Isw_skip;
Isw_default:
fprintf(stderr, "\nSwitch label 'Isw(%d):' not set in %s\n",
Isw_sw + 10, __PRETTY_FUNCTION__);
fflush(stderr);
abort();
Isw_skip:;
}
void Rexp(void) {
int I;
int Pr;
Rd *Opnd;
if (Register[Breg] > 0)
Bootout(Breg);
for (I = 1; I <= 2; I++) {
Opnd = Record(Operand[I]);
if (I != 1 || Opnd->Flag != 8)
Load(Opnd, Accr, 2);
Pr = (unsigned)Opnd->Ptype >> 4;
if (Pr < 6)
Lengthen(Opnd);
if (Pr > 6)
Shorten(Opnd);
}
Ppj(0, 17);
}
void Starstar(void) {
int Typep;
int Precp;
int Work;
int C;
int Expwork;
int Value;
Ptype = Opnd1->Ptype;
Unpack();
Typep = Type;
Precp = Prec;
if (Typep == 2)
Opcode = 0xFA;
else
Opcode = 0xEA;
Value = 0;
if (Opnd2->Flag == 0 && 1 <= Opnd2->D && Opnd2->D <= 63 * Type)
Value = Opnd2->D;
Load(Opnd1, Accr, 2);
if (Typep == 2 && Precp == 5) {
Lengthen(Opnd1);
Precp = 6;
}
if (2 <= Value && Value <= 4) {
Pf1(St, 0, Tos, 0);
if (Value == 3)
Pf1(St, 0, Tos, 0);
Pf1(Opcode, 0, Tos, 0);
if (Value == 4)
Pf1(St, 0, Tos, 0);
if (Value > 2)
Pf1(Opcode, 0, Tos, 0);
Gruse[Accr] = 0;
return;
}
Getwsp(&Work, (unsigned)Bytes[Precp] >> 2);
if (Typep == 2)
Getwsp(&Expwork, 1);
Psf1(St, 1, Work);
Register[Accr] = 0;
Plabel--;
if ((unsigned)Opnd2->Ptype >> 4 == 6)
Shorten(Opnd2);
Load(Opnd2, Breg, 2);
if (Typep == 2)
Psf1(Stb, 1, Expwork);
Getinacc(Accr, (unsigned)Bytes[Precp + 1 - Typep] >> 2, 0, 0, 1);
if (Typep == 2)
Psf1(Flt, 0, 0);
if (!Value) {
Enterjump(28, Plabel, 0b11);
if (Typep == 2) {
Pf3(Jat, 13, 0, 4);
Psf1(Slb, 0, 0);
Pf1(Sbb, 0, Tos, 0);
}
if (Parmopt == 1) {
if (Typep == 1)
Ppj(30, 7);
Psf1(Cpb, 0, 64 * Typep * Typep - 1);
Ppj(2, 7);
}
}
C = Ca;
Psf1(Opcode, 1, Work);
Psf1(Debj, 0, (C - Ca) / 2);
if (Value == 0 && Typep == 2) {
Psf1(Lb, 1, Expwork);
Enterjump(46, Plabel, 0b11);
if (Precp < 7)
Pf1(Rrdv, 0, Pc, Specialconsts(1));
else {
Psf1(Slsd, 0, 1);
Psf1(Flt, 0, 0);
Pf1(Rdv, 0, Tos, 0);
}
}
Type = Typep;
Prec = Precp;
Register[Breg] = 0;
Gruse[Accr] = 0;
Gruse[Breg] = 0;
Register[Accr] = 1;
Opnd1->Ptype = 16 * Prec + Type;
Opnd1->Xb = 0;
Opnd1->D = Accr;
C = Enterlab(Plabel, 0b11);
}
goto Sw_skip;
Sw_default:
fprintf(stderr, "\nSwitch label 'Sw(%d):' not set in %s\n",
Sw_sw + 10, __PRETTY_FUNCTION__);
fflush(stderr);
abort();
Sw_skip:;
}
void Reduceenv(int *Head) {
int Newhead;
int I;
int J;
int K;
int Reg;
int Use;
Newhead = 0;
while (*Head) {
Pop(Head, &I, &J, &K);
Reg = (unsigned)K >> 8;
Use = K & 255;
if (Use == (Gruse[Reg] & 255) && I == Grinf1[Reg])
Push(&Newhead, I, J, K);
}
*Head = Newhead;
}
int Ccond(int Cto, int Iu, int Farlab) {
auto void Writecondlist(void);
auto void Skipsc(int Reversed);
auto void Skipcond(int Reversed);
auto int Ccomp(void);
auto void Jump(int Mask, int Lab, int Flags);
auto void Labunused(int Lab);
auto void Omitto(int Lab);
static const unsigned char Fcomp[1+21 /*1:21*/] = {0,
8, 13, 5, 7, 10, 2, 7, 8, 10, 2, 7,
13, 5, 7, 27, 0, 0, 43, 0, 0, 43};
int Pin;
int Pp;
int Ii;
int L;
int Cptr;
int Cmax;
int Ll;
int Bitmask;
int La;
typedef struct Cf {
unsigned char Tf;
unsigned char Cmp1;
unsigned char Cmp2;
unsigned char Labu;
unsigned char Lvl;
unsigned char Jmp;
unsigned char Rev;
unsigned char Sp;
int Labno;
int Sp1;
int Sp2;
} Cf;
Cf Clist[1+30 /*1:30*/];
Cf *C1;
Cf *C2;
Pin = P;
Cptr = 1;
L = 3;
C1 = &Clist[Cptr];
*C1 = (Cf){0};
Skipsc(0);
Skipcond(0);
C1->Lvl = 2;
C1->Tf = Iu;
Cmax = Cptr + 1;
C1 = &Clist[Cmax];
*C1 = (Cf){0};
C1->Lvl = 1;
C1->Tf = 3 - Iu;
C1->Labno = Farlab;
Pp = P;
if (Cmax > 29)
Fault(209, 0);
for (Cptr = 1; Cptr <= Cmax - 1; Cptr++) {
C1 = &Clist[Cptr];
L = C1->Lvl;
Ll = L;
for (Ii = Cptr + 1; Ii <= Cmax + 1; Ii++) {
C2 = &Clist[Ii];
if (C1->Tf != C2->Tf && C2->Lvl < Ll)
break;
if (C2->Lvl < Ll)
Ll = C2->Lvl;
}
C1->Jmp = Ii;
C2->Labu = C2->Labu + 1;
if (C1->Cmp2 != 0 || C1->Cmp1 == 8) {
C1->Labu = C1->Labu + 1;
}
if (C1->Labu != 0 && C1->Labno <= 0) {
Plabel--;
C1->Labno = Plabel;
}
}
if (Dcomp == 1)
Writecondlist();
Bitmask = 0;
Cptr = 1;
for (;;) {
C1 = &Clist[Cptr];
La = Ccomp();
if (La) {
Omitto(La);
if (Cptr >= Cmax) {
if (!Cto)
Enterjump(15, La, 0b11);
return (2);
}
C1 = &Clist[Cptr];
}
if (C1->Labno > 0)
Ii = Enterlab(C1->Labno, 0b11);
Cptr++;
if (Cptr >= Cmax)
break;
}
P = Pp;
if (!(Bitmask & 1))
return (1);
return (0);
void Labunused(int Lab) {
int I;
Cf *C1;
for (I = Cptr; I <= Cmax - 1; I++) {
C1 = &Clist[I];
if (C1->Labno == Lab) {
C1->Labu = C1->Labu - 1;
if (!C1->Labu)
C1->Labno = 0;
return;
}
}
}
void Omitto(int Lab) {
Cf *C1;
for (;;) {
C1 = &Clist[Cptr];
if (C1->Labno > 0) {
if (C1->Labno == Lab)
return;
Jump(15, Lab, 0b11);
return;
}
Cptr++;
if (Cptr >= Cmax)
break;
}
}
void Skipsc(int Reversed) {
static int Scalt_sw;
static void *Scalt[3 /*1:3*/] = {
&&Scalt_1,
&&Scalt_2,
&&Scalt_3,
};
int Alt;
Alt = A[P];
P++;
goto *Scalt[Scalt_sw = (Alt)-1];
Scalt_1:;
C1->Sp1 = P - Pin;
Skipexp();
C1->Cmp1 = A[P];
C1->Rev = 3 * Reversed;
P++;
C1->Sp2 = P - Pin;
Skipexp();
if (A[P] == 2)
P++;
else {
C1->Cmp2 = A[P + 1];
P += 2;
Skipexp();
}
return;
Scalt_2:;
L++;
Skipsc(Reversed);
Skipcond(Reversed);
L--;
return;
Scalt_3:;
Skipsc(Reversed ^ 1);
}
void Skipcond(int Reversed) {
int Alt;
int Altp;
Alt = A[P];
P++;
if (Alt != 3) {
do {
C1->Lvl = L;
C1->Tf = Alt;
C1->Tf = C1->Tf ^ (3 * Reversed);
Cptr++;
C1 = &Clist[Cptr];
*C1 = (Cf){0};
Skipsc(Reversed);
Altp = A[P];
P++;
} while (Altp != 2);
}
}
void Writecondlist(void) {
static const _imp_string Cm[11 /*0:10*/] = {
_imp_str_literal(" "), _imp_str_literal(" ="),
_imp_str_literal(" >="), _imp_str_literal(" >"),
_imp_str_literal(" #"), _imp_str_literal(" <="),
_imp_str_literal(" <"), _imp_str_literal(" \\="),
_imp_str_literal(" ->"), _imp_str_literal(" =="),
_imp_str_literal(" \\==")};
Printstring(_imp_str_literal(
"\n NO TF C1 C2 LABU LVL JMP REV LABNO\n"));
for (Cptr = 1; Cptr <= Cmax; Cptr++) {
C1 = &Clist[Cptr];
Write(Cptr, 2);
Write(C1->Tf, 4);
Printstring(Cm[C1->Cmp1]);
Printstring(Cm[C1->Cmp2]);
Write(C1->Labu, 6);
Write(C1->Lvl, 5);
Write(C1->Jmp, 4);
Write(C1->Rev, 4);
Write(C1->Labno, 7);
Newline();
}
}
int Ccomp(void) {
auto void Acomp(int Tf, int Ds);
auto void Adcomp(int Tf);
auto void Scomp(int Ds, int Tf, int Lab, int *Wa);
int Head1;
int Head2;
int Nops;
int Te1;
int Te2;
int Tex1;
int Tex2;
int P1;
int P2;
int Fexit;
int Iexit;
int Cmp;
int Wa1;
int Wa2;
int Wa3;
int Bot1;
int Bot2;
Head1 = 0;
Head2 = 0;
Nops = 0;
Bot1 = 0;
Bot2 = 0;
Fexit = Clist[C1->Jmp].Labno;
Iexit = Fexit;
if ((C1->Rev ^ C1->Tf) == 2 && (C1->Cmp1 == 8 || C1->Cmp2 != 0))
Iexit = C1->Labno;
P = Pin + C1->Sp2;
P2 = P;
P1 = Pin + C1->Sp1;
if (C1->Cmp1 == 8) {
P = P1;
if (A[P + 3] == 4 && A[P + 4] == 1) {
P += 5;
Cname(2, Dr);
if (A[P] == 2) {
if (Type != 5) {
Fault2(71, 0, Fromar2(P1 + 5));
return (0);
}
P = P2;
Cres(Iexit);
if (Iexit == Farlab)
Bitmask = Bitmask | 1;
else
Bitmask = Bitmask | 2;
if ((C1->Rev ^ C1->Tf) == 2)
Jump(15, Fexit, 0b11);
return (0);
}
}
Fault2(74, 0, 0);
return (0);
}
if (C1->Cmp1 > 8)
goto Adrcomp;
Mask = Fcomp[C1->Cmp1];
Te2 = Tsexp(&Tex2);
if (Type == 5)
goto Str;
if (Te2 != 1)
goto Arith;
P = P1;
Te1 = Tsexp(&Tex1);
if (Type == 5)
goto Str;
Arith:;
P = P1 + 3;
Torp(&Head1, &Bot1, &Nops);
Cmp = C1->Cmp1;
P = P2 + 3;
if (C1->Cmp2) {
Acomp(1, 1);
if (Mask == 15)
return (Iexit);
Jump(Mask, Iexit, 0b11);
P += 5;
Cmp = C1->Cmp2;
}
Acomp(C1->Rev ^ C1->Tf, 0);
if (Mask == 15)
return (Fexit);
Jump(Mask, Fexit, 0b11);
return (0);
Str:;
P = P1;
Wa1 = 0;
Wa2 = 0;
Wa3 = 0;
if (C1->Cmp2 == 0 && 7 <= Fcomp[C1->Cmp1] && Fcomp[C1->Cmp1] <= 8 &&
A[P2 + 3] == 4 && A[P2 + 4] == 2 && A[P2 + 5] == 0x35 &&
A[P2 + 10] == 0 && A[P2 + 11] == 2) {
Cstrexp(0, Dr);
Mask = Fcomp[C1->Cmp1 + 14];
if ((C1->Rev ^ C1->Tf) == 1)
Mask = Reverse(Mask);
Jump(Mask, Fexit, 0b11);
return (0);
}
Cstrexp(16, Accr);
Wa1 = Value;
Cmp = C1->Cmp1;
P = P2;
if (C1->Cmp2) {
Scomp(1, 1, Iexit, &Wa2);
P += 2;
Cmp = C1->Cmp2;
if (Wa1) {
Returnwsp(Wa1, 256);
Wa1 = 0;
}
}
Scomp(0, C1->Rev ^ C1->Tf, Fexit, &Wa3);
for (Cmp = Addr(Wa1); Cmp <= Addr(Wa3); Cmp += 4)
if (*Integer(Cmp))
Returnwsp(*Integer(Cmp), 256);
return (0);
Adrcomp:;
Adcomp(C1->Rev ^ C1->Tf);
Jump(Mask, Fexit, 0b11);
return (0);
void Adcomp(int Tf) {
int Typep;
int Precp;
int Lhname;
int Rhname;
int Fname;
Rd R;
Lhname = A[P1 + 5] << 8 | A[P1 + 6];
Fname = Rhname;
Rhname = A[P2 + 5] << 8 | A[P2 + 6];
if (A[P1 + 3] != 4 || A[P1 + 4] != 1)
goto Flt;
P = P1 + 5;
Cname(4, Accr);
if (A[P] != 2)
goto Flt;
Typep = Type;
Precp = Prec;
Register[Accr] = 1;
Olink[Accr] = Addr(R);
R.Ptype = 1;
R.Xb = Accr << 4;
R.Flag = 9;
Fname = Lhname;
if (A[P2 + 3] != 4 || A[P2 + 4] != 1)
goto Flt;
P = P2 + 5;
Cname(4, Accr);
if (A[P] != 2)
goto Flt;
if (Typep != Type || Precp != Prec)
Fault2(83, Lhname, Rhname);
Pf1(Icp, 0, Tos, 0);
if (C1->Cmp1 == 10)
Mask = 7;
else
Mask = 8;
if (Tf == 1)
Mask = Reverse(Mask);
return;
Flt:
Register[Accr] = 0;
Fault2(80, 0, Fname);
Mask = 7;
}
void Acomp(int Tf, int Ds) {
int Precp;
int Typep;
int Reg;
Precp = (unsigned)Ptype >> 4 & 15;
Typep = Type;
Push(&Head2, 31 + Ds, Cmp, 0);
Bot2 = Head2;
Nops = (Nops + 1) | 1 << 31;
Torp(&Head2, &Bot2, &Nops);
if (Typep > Type)
Type = Typep;
Aslist[Bot1].Link = Head2;
Bot1 = Bot2;
Bot2 = 0;
Head2 = 0;
Expop(Head1, -1, Nops, 256 + 16 * Precp + Type);
Aslist[Bot1].Link = Asl;
Asl = Head1;
Head1 = 0;
if (Ds) {
Push(&Head1, *Integer(Addr(Expopnd)), Expopnd.D, Expopnd.Xtra);
Bot1 = Head1;
if (Expopnd.Flag == 9) {
Reg = (unsigned)Expopnd.D >> 4;
Register[Reg] = 1;
Olink[Reg] = Addr(Aslist[Head1]);
}
}
if (Tf == 1)
Mask = Reverse(Mask);
}
void Scomp(int Ds, int Tf, int Lab, int *Wa) {
int Mask;
Rd R;
Register[Accr] = 1;
Olink[Accr] = Addr(R);
R.Ptype = 1;
R.Xb = Accr << 4;
R.Flag = 9;
Mask = Fcomp[Cmp];
if (Tf == 1)
Mask = Reverse(Mask);
Cstrexp(16, Dr);
*Wa = Value;
Register[Accr] = 0;
if (R.Flag != 9)
Pf1(Lsd, 0, Tos, 0);
if (Ds)
Pf1(Std, 0, Tos, 0);
Psf1(Inca, 0, 1);
Psf1(Iad, 0, 1);
Pf2(Cps, 1, 1, 0, 0, 0);
Gruse[Accr] = 0;
Gruse[Dr] = 0;
if (0 != (Mask & 0xC) && (Mask & 0xC) != 0xC) {
Pf3(Jcc, 7, 0, 4);
Psf1(Ush, 0, -32);
Psf1(Ish, 0, -24);
}
if (Ds)
Pf1(Lsd, 0, Tos, 0);
Jump(Mask, Lab, 0b11);
}
}
void Jump(int Mask, int Lab, int Flags) {
if (!Mask) {
Labunused(Lab);
return;
}
Enterjump(Mask, Lab, Flags);
if (Lab == Farlab)
Bitmask = Bitmask | 1;
else
Bitmask = Bitmask | 2;
}
}
int Reverse(int Mask) {
if (Mask > 15)
Mask = Mask ^ 0x30;
else
Mask = Mask ^ 15;
return (Mask);
}
int Enterlab(int Lab, int Flags) {
int Cell;
int At;
int Envhead;
int Jumphead;
int Instrn;
int Oldcell;
int Work;
Listf *Lcell;
int *Lhead;
Cell = Label[Level];
Oldcell = 0;
while (Cell > 0) {
Lcell = &Aslist[Cell];
if (Lcell->S3 == Lab)
break;
Oldcell = Cell;
Cell = Lcell->Link;
}
if (Cell <= 0) {
if (!(Flags & 1)) {
Push(&Label[Level], Ca, 0, Lab);
Forget(-1);
return (1);
}
return (0);
}
if (Lcell->S1 & 0xFFFFFF) {
Fault(2, Lab);
} else
Lcell->S1 = 0x1000000 | Ca;
Jumphead = Lcell->S2;
Envhead = (unsigned)Jumphead >> 16;
Jumphead = Jumphead & 0xFFFF;
if (!(Flags & 2)) {
Forget(-1);
Clearlist(&Envhead);
} else {
if (!(Flags & 4))
Remember();
Restore(Envhead);
Envhead = 0;
if (!(Flags & 4))
Mergeinfo();
}
while (Jumphead) {
Pop(&Jumphead, &At, &Instrn, &Work);
Plug(1, At, Instrn | (Ca - At) / 2, 4);
}
Lcell->S2 = 0;
if (Lab > Maxulab) {
if (!Oldcell)
Lhead = &Label[Level];
else
Lhead = &Aslist[Oldcell].Link;
Pop(&*Lhead, &At, &At, &At);
}
return (1);
}
void Enterjump(int Mask, int Lab, int Flags) {
int At;
int Cell;
int J;
int Jj;
int Labaddr;
int I;
int Envhead;
int Oldenv;
int Jcode;
int Instrn;
Listf *Lcell;
Envhead = 0;
At = Ca;
if (Lab < Maxulab)
Flags = Flags & 0xFD;
if (Lab < 21000)
Flags = Flags & 0xFE;
Cell = Label[Level];
while (Cell > 0) {
Lcell = &Aslist[Cell];
if (Lab == Lcell->S3)
break;
Cell = Lcell->Link;
}
Instrn = Mask;
if (!((unsigned)Instrn >> 8)) {
Jcode = Jcc;
if (Mask >= 16)
Jcode = Jat;
if (Mask >= 32)
Jcode = Jaf;
Instrn = Jcode << 24 | (Mask & 15) << 21;
if (Mask == 15)
Instrn = Junc << 24 | 3 << 23;
}
if (Cell <= 0)
goto Firstref;
Labaddr = Lcell->S1 & 0xFFFFFF;
if (!Labaddr)
goto Notyetset;
Lcell->S1 = Labaddr | 0x1000000;
I = (Labaddr - Ca) / 2;
if (Mask == 15)
Psf1(Junc, 0, I);
else
Pconst(Instrn | (I & 0x3FFFF));
return;
Firstref:;
if (Lab > Maxulab && (Flags & 2) != 0)
Getenv(&Envhead);
Push(&Label[Level], 0x1000000, Envhead << 16, Lab);
Cell = Label[Level];
Lcell = &Aslist[Cell];
goto Code;
Notyetset:;
if (Lab > Maxulab && (Flags & 2) != 0) {
I = Lcell->S2;
Oldenv = (unsigned)I >> 16;
Reduceenv(&Oldenv);
Lcell->S2 = Oldenv << 16 | I & 0xFFFF;
}
Code:;
J = Lcell->S2;
Jj = J & 0xFFFF;
Push(&Jj, Ca, Instrn, Line);
Lcell->S2 = J & 0xFFFF0000 | Jj;
Pconst(Instrn);
}
void Removelab(int Lab) {
Listf *Lcell;
int *Lhead;
int Cell;
int At;
Lhead = &Label[Level];
Cell = *Lhead;
while (Cell > 0) {
Lcell = &Aslist[Cell];
if (Lcell->S3 == Lab)
break;
Lhead = &Lcell->Link;
Cell = *Lhead;
}
if (Cell > 0)
Pop(&*Lhead, &At, &At, &At);
}
void Mergeinfo(void) {
int I;
for (I = 0; I <= 7; I++)
if (Sgruse[I] != (Gruse[I] & 255) || Sgrinf[I] != Grinf1[I])
Gruse[I] = 0;
}
void Remember(void) {
int I;
for (I = 0; I <= 7; I++) {
Sgruse[I] = Gruse[I] & 255;
Sgrinf[I] = Grinf1[I];
}
}
void Createah(int Mode) {
int Wk;
Getwsp(&Wk, 4);
Area = Areacode();
if (!Mode) {
if (Compiler == 1 && 1 == J && Type <= 2) {
Pf1(Slss, 2, Area, Disp + 8);
if (Prec != 3)
Psf1(Imy, 0, -Bytes[Prec]);
Pf1(Iad, 0, Tos, 0);
Gruse[Dr] = 0;
}
Psorlf1(Luh, Access, Area, Disp);
} else {
Psf1(Luh, 0, 0);
Psorlf1(Iad, Access, Area, Disp);
}
Psf1(St, 1, Wk);
Psorlf1(Lsd, Access, Area, Disp + 8);
Psf1(St, 1, Wk + 8);
Gruse[Accr] = 0;
Access = 0;
Area = Lnb;
Disp = Wk;
}
void Csname(int Z, int Reg) {
auto int Optmap(void);
static int Adhoc_sw;
static void *Adhoc[15 /*1:15*/] = {
&&Adhoc_1, &&Adhoc_2, &&Adhoc_3, &&Adhoc_4, &&Adhoc_5,
&&Adhoc_6, &&Adhoc_7, &&Adhoc_8, &&Adhoc_9, &&Adhoc_10,
&&Adhoc_11, &&Adhoc_12, &&Adhoc_13, &&Adhoc_14, &&Adhoc_15,
};
static const int Sninfo[63 /*0:62*/] = {0x41080001,
0x41090001,
0x408A0001,
0x40A00001,
0x40010001,
0x800D0000,
0x11010001,
0x11010001,
0x10020024,
0x41030001,
0x19030001,
0x80130001,
0x801B0014,
0x408C0001,
0x19050024,
0x80010002,
0x11040024,
0x11040024,
0x80010005,
0x80090006,
0x80060007,
0x2100003E,
0x2100003E,
0x11060024,
0x80010008,
0x80010009,
0x8001000A,
0x8001000B,
0x8001000C,
0x8001000D,
0x8001000E,
0x8015000F,
0x2100003E,
0x100D0024,
0x80030010,
0x80030011,
0x1907003E,
0x41070001,
0x10080024,
0x2100003E,
0x41050001,
0x19030001,
0x2100003E,
0x19030001,
0x10020024,
0x1A07003E,
0x11090024,
0x800F0012,
0x110A8018,
0x120B1000,
0x80170013,
0x11060024,
0x100C0024,
0x100D0024,
[54 ... 55] = 0x2100003E,
[56 ... 59] = 0x110E0024,
0x10020024,
0x2100003E,
0x100F0001};
static const _imp_string Snxrefs[21 /*0:20*/] = {
_imp_str_literal("READSTRING"), _imp_str_literal("S#READ"),
_imp_str_literal("S#IARCSIN"), _imp_str_literal("S#INT"),
_imp_str_literal("S#INTPT"), _imp_str_literal("S#FRACPT"),
_imp_str_literal("S#PRINT"), _imp_str_literal("S#PRINTFL"),
_imp_str_literal("S#IARCCOS"), _imp_str_literal("S#ISQRT"),
_imp_str_literal("S#ILOG"), _imp_str_literal("S#ISIN"),
_imp_str_literal("S#ICOS"), _imp_str_literal("S#ITAN"),
_imp_str_literal("S#IEXP"), _imp_str_literal("CLOSESTREAM"),
_imp_str_literal("S#IRADIUS"), _imp_str_literal("S#IARCTAN"),
_imp_str_literal("FROMSTRING"), _imp_str_literal("SETMARGINS"),
_imp_str_literal("S#WRITE")};
static const int Snparams[30 /*0:29*/] = {
0, 1, 0x62, 2, 0x62, 0x62, 2, 0x62, 0x51, 3,
0x62, 0x51, 0x51, 1, 0x435, 3, 0x35, 0x51, 0x51, 1,
0x400, 1, 0x51, 3, 0x51, 0x51, 0x51, 2, 0x51, 0x51};
auto void Rtos(int Reg);
Rd R;
int Errno;
int Flag;
int Pointer;
int Wreg;
int Pin;
int Snno;
int Snname;
int Naps;
int Snptype;
int Jj;
int Xtra;
int Iocpep;
int B;
int D;
int Sninf;
int P0;
int Ophead;
Snname = Fromar2(P);
Snno = K;
Testapp(&Naps);
Pin = P;
P += 2;
Snptype = Tsname[Snno];
Sninf = Sninfo[Snno];
Xtra = Sninf & 0xFFFF;
Pointer = ((unsigned)Sninf >> 16) & 255;
Flag = (unsigned)Sninf >> 24;
if (Flag & 0x80) {
Cxref(Snxrefs[Xtra], Parmdynamic, 2, &Jj);
if (Snno == 26)
Logepdisp = Jj;
if (Snno == 31)
Expepdisp = Jj;
Ophead = 0;
P0 = Snparams[Pointer];
K = Ophead;
D = 1;
while (D <= P0) {
Ptype = Snparams[Pointer + D];
Unpack();
if (!Nam)
Acc = Bytes[Prec];
else
Acc = 8;
if (Ptype == 0x35)
Acc = 256;
Insertatend(&Ophead, Ptype << 16, Acc << 16, 0);
D++;
}
I = 1;
J = 14;
Oldi = 0;
Ptype = Snptype;
K = Ophead;
Kform = P0;
Replacetag(Snname);
Replace2(Tags[Snname], Jj);
P = Pin;
Cname(Z, Reg);
Nest = Reg;
P--;
return;
}
if (Naps != (Flag & 3)) {
Errno = 19;
goto Errexit;
}
Jj = 1 << Z;
if (!(Jj & Xtra)) {
Errno = 23;
if (!Z)
Errno = 17;
if (Z == 1 || 3 <= Z && Z <= 4)
Errno = 29;
if (Xtra & 0xF000)
Errno = 84;
goto Errexit;
}
if (Flag & 0x40) {
Iocpep = Pointer;
B = Accr;
if (Flag & 3) {
P++;
if (Snno == 37) {
Cstrexp(0, Dr);
B = Dr;
} else
Csexp(Accr, 0x51);
}
if (Iocpep > 127) {
Psf1(Lss, 0, Iocpep & 127);
Iocpep = 5;
}
if (Snno == 4)
Psf1(Lss, 0, 0);
Ciocp(Iocpep, B);
P++;
goto Okexit;
}
if (Flag & 0x20) {
Snptype += 0x1C00;
if (Parmopt == 0 && Optmap() != 0)
goto Okexit;
if (Z == 1)
Bimstr = 1;
P++;
Csexp(Breg, 0x51);
P++;
if (Z == 1)
Bimstr = 0;
Jj = (unsigned)Snptype >> 4 & 15;
Disp = Mapdes(Jj);
Area = Pc;
Access = 3;
Oldi = 0;
goto Okexit;
}
P++;
if ((Flag & 8) != 0 && (A[P + 3] != 4 || A[P + 4] != 1 ||
A[P + Fromar2(P + 1) + 1] != 2)) {
Errno = 22;
goto Errexit;
}
goto *Adhoc[Adhoc_sw = (Pointer)-1];
Adhoc_1:;
Csexp(Accr, 0x51);
if (Snno == 6)
Jj = 10;
else
Jj = 32;
Psf1(Ush, 0, 8);
Psf1(Or, 0, Jj);
Ciocp(17, Accr);
P++;
goto Okexit;
Adhoc_2:;
Getinacc(Accr, 1, 0, 0, 0);
if (Snno == 60)
Jj = 18;
else
Jj = 2;
Ciocp(Jj, Accr);
if (Snno == 44) {
Rtos(Breg);
Snptype = 0x1435;
Area = Pc;
Access = 3;
Disp = Mapdes(3);
}
Nest = Accr;
goto Okexit;
Adhoc_3:;
if (Snno == 41)
Jj = 4;
else
Jj = 1;
Psf1(Lss, 0, 0);
Ciocp(Jj, Accr);
P += 5;
if (Snno == 43) {
Type = 5;
Rtos(Accr);
Pf1(Luh, 0, Pc, Paramdes(3));
} else {
Register[Accr] = 1;
Type = 1;
}
Jj = Type;
Assign(6, P);
P = Pin + 6 + Fromar2(Pin + 4);
goto Okexit;
Adhoc_4:;
Csexp(Accr, 0x62);
if (Snno == 16)
Pf1(Rad, 0, Pc, Specialconsts(0));
if (!Parmopt) {
Psf1(Rsc, 0, 55);
Psf1(Rsc, 0, -55);
}
if (Register[Breg])
Bootout(Breg);
Pf1(Fix, 0, Breg, 0);
Psf1(Myb, 0, 4);
Psf1(Cpb, 0, -64);
Pf3(Jcc, 10, 0, 3);
Psf1(Lb, 0, -64);
Pf1(Ish, 0, Breg, 0);
Pf1(Stuh, 0, Breg, 0);
Gruse[Accr] = 0;
Gruse[Breg] = 0;
Nest = Accr;
P++;
goto Okexit;
Adhoc_5:;
P += 5;
Cname(4, Reg);
Nest = Reg;
P += 2;
goto Okexit;
Adhoc_6:;
if (Snno == 51) {
Jj = 0x51;
B = 5;
D = Irsb;
Xtra = 3;
Wreg = Accr;
if (Reg == Breg) {
B = 13;
D = Slb;
Xtra = 4;
Wreg = Breg;
}
} else {
Jj = 0x62;
B = 1;
D = Rrsb;
Xtra = 3;
Wreg = Accr;
}
Csexp(Wreg, Jj);
Pf3(Jat, B, 0, Xtra);
Psf1(D, 0, 0);
if (Wreg == Breg)
Pf1(Sbb, 0, Tos, 0);
Gruse[Wreg] = 0;
Nest = Wreg;
P++;
goto Okexit;
Adhoc_7:;
P += 5;
if (Parmarr != 0 && Snno == 45)
Cname(Z, Dr);
else
Cname(4, Breg);
Errno = 22;
if (Type != 5 || Rout != 0)
goto Errexit;
P += 2;
if (Snno != 36) {
if (Parmarr == 0 && 0 == Parmchk) {
Pf1(Stb, 0, Tos, 0);
Csexp(Breg, 0x51);
Pf1(Adb, 0, Tos, 0);
} else {
Getwsp(&Jj, 2);
if (Z == 2 || Z == 5)
B = Inca;
else
B = Modd;
Psf1(B, 0, 1);
Psf1(Std, 1, Jj);
Csexp(Breg, 0x51);
Psf1(Ld, 1, Jj);
Psf1(Sbb, 0, 1);
Pf1(Modd, 0, Breg, 0);
Gruse[Dr] = 0;
Psf1(Adb, 1, Jj + 4);
}
P++;
Gruse[Breg] = 0;
}
Disp = Mapdes(3);
Area = Pc;
Access = 3;
if (Z == 1)
Stname = -1;
Snptype += 0x1C00;
goto Okexit;
Adhoc_12:;
Adhoc_8:;
Nest = 0;
P++;
goto Okexit;
Adhoc_9:;
Csexp(Accr, 0x51);
P++;
Rtos(Breg);
Disp = Mapdes(3);
Area = Pc;
Access = 3;
Snptype += 0x1C00;
goto Okexit;
Adhoc_10:;
if (!Rectb) {
Jj = 0x1800FFFF;
Storeconst(&Rectb, 4, Addr(Jj));
}
if (!Reg) {
Csexp(Accr, 0x51);
Pf1(Luh, 0, Pc, Rectb);
} else {
Csexp(Breg, 0x51);
Pf1(Ldtb, 0, Pc, Rectb);
Pf1(Lda, 0, Breg, 0);
}
P++;
Gruse[Reg] = 0;
Oldi = 0;
Acc = 0xFFFF;
Snptype += 0x1C00;
goto Okexit;
Adhoc_11:;
Csexp(Accr, 0x51);
Errno = 22;
if (A[P + 4] != 4 || A[P + 5] != 1)
goto Errexit;
Register[Accr] = 1;
Olink[Accr] = Addr(R);
R = (Rd){0};
R.Ptype = 0x51;
R.Flag = 9;
R.Xb = Accr;
P += 6;
Cname(12, 0);
if (R.Flag != 9)
Pf1(Lss, 0, Tos, 0);
Register[Accr] = 0;
if (A[P] != 2 || Arr <= 0)
goto Errexit;
P += 2;
Createah(0);
return;
Adhoc_13:;
D = Oninf[Level];
if (!D)
Fault(16, Snname);
if (Snno != 33)
D += 4;
Getinacc(Accr, 1, 0, Lnb, D);
Gruse[Accr] = 0;
Nest = Accr;
goto Okexit;
Adhoc_14:;
D = (Snno & 3) * 8;
Csexp(Accr, (unsigned)0x62517261 >> D & 255);
P++;
Nest = Accr;
goto Okexit;
Adhoc_15:;
if (Parmprof)
Ppj(0, 22);
Okexit:;
Ptype = Snptype;
Unpack();
return;
Errexit:;
Fault(Errno, Snname);
Base = 0;
Disp = 0;
Access = 0;
Area = 0;
P = Pin + 2;
Skipapp();
P--;
return;
int Optmap(void) {
int Varname;
int Rexp;
int Pp;
int Cval;
int Op;
int Xynb;
if (3 <= Z && Z <= 4 || Snno == 42 || Snno == 32 || Snno == 61)
return (0);
Pp = P + 2;
Rexp = Fromar2(Pp) + Pp;
Varname = Fromar2(Pp + 4);
if (A[Pp + 2] != 4 || A[Pp + 3] != 1)
return (0);
Copytag(Varname);
if (Ptype == Snpt && K == 14 && A[Pp + 6] == 1)
goto Wasadr;
if ((Ptype & 0xFBFF) == 0x51 && A[Pp + 6] == 2 && 2 == A[Pp + 7])
goto Wasloc;
return (0);
Wasadr:
Pp += 10;
if (A[Pp] != 4 || A[Pp + 1] != 1 || A[Pp + 4] != 2 ||
2 != A[Pp + 5] || A[Pp + 6] != 2 || 2 != A[Pp + 7] ||
A[Pp + 8] != 2)
return (0);
Varname = Fromar2(Pp + 2);
Copytag(Varname);
if (Ptype & 0xFF0C)
return (0);
if (A[Rexp] == 2)
P = Rexp + 2;
else {
Op = A[Rexp + 1];
if (1 > Op || Op > 2 || A[Rexp + 2] != 2 || A[Rexp + 3] != 0x41 ||
A[Rexp + 6] != 2)
return (0);
Cval = Fromar2(Rexp + 4);
if (Op == 1)
K += Cval;
else
K -= Cval;
if (K < 0)
return (0);
P = Rexp + 8;
}
Base = I;
Disp = K;
Area = -1;
Access = 0;
Area = Areacode();
return (1);
Wasloc:;
Cval = 0;
if (A[Rexp] == 2) {
Pp = Rexp + 2;
goto Fetch;
}
if (A[Rexp + 1] != 1 || A[Rexp + 2] != 2)
return (0);
if (A[Rexp + 3] == 0x41 && A[Rexp + 6] == 2) {
Cval = Fromar2(Rexp + 4);
Pp = Rexp + 8;
goto Fetch;
}
if (A[Rexp + 3] == 0x51 && A[Rexp + 8] == 2) {
Cval = Fromar4(Rexp + 4);
Pp = Rexp + 10;
goto Fetch;
}
return (0);
Fetch:
if ((Cval & 3) != 0 || (unsigned)Cval >> 20 != 0)
return (0);
Xynb = Xorynb(9, Varname);
if (Gruse[Xynb] != 9 || Grinf1[Xynb] != Varname) {
Area = -1;
Base = I;
Psorlf1(Ldcode[Xynb], 2 * Nam, Areacode(), K);
Gruse[Xynb] = 9;
Grinf1[Xynb] = Varname;
}
P = Pp;
Area = Xynb;
Access = 0;
Disp = Cval;
return (1);
}
void Rtos(int Reg) {
int Kk;
Getwsp(&Kk, 1);
Stringl = 1;
Disp = Kk + 2;
Pf1(Or, 0, 0, 256);
Psf1(St, 1, Kk);
Getinacc(Reg, 1, 0, Lnb, Ptroffset(Rbase));
if (Reg == Breg)
Kk = Adb;
else
Kk = Iad;
Psf1(Kk, 0, Disp);
Gruse[Breg] = 0;
}
}
void Caname(int Arrp, int Bs, int Dp) {
int Head1;
int Head2;
int Head3;
int Nops;
int Ptypep;
int Kk;
int Pp;
int Jj;
int Soldi;
int Typep;
int Arrname;
int Q;
int Precp;
int Elsize;
int Naminf;
int Bot1;
int Bot2;
int Bot3;
int Dvd;
int Vmyop;
Pp = P;
Typep = Type;
Jj = J;
Ptypep = Ptype;
Precp = Prec;
Soldi = Oldi;
if (Type <= 2)
Elsize = Bytes[Precp];
else
Elsize = Acc;
Dvd = Sndisp;
Arrname = Fromar2(P);
Naminf = Tags[Arrname];
if (Arr == 3)
Fault(29, Arrname);
if (Arrp > 2) {
Naminf = -2;
Dvd = 0;
}
Testapp(&Q);
if (!Jj) {
Replace1(Tcell, From1(Tcell) | Q);
Jj = Q;
}
if (Jj == Q && Q != 0) {
Nops = 0;
Head1 = 0;
Head2 = 0;
Head3 = 0;
Bot1 = 0;
Bot3 = 0;
P = Pp + 3;
for (Kk = 1; Kk <= Jj; Kk++) {
P += 3;
Bot2 = 0;
Torp(&Head2, &Bot2, &Nops);
P++;
Nops = (Nops + 1) | 1 << 24;
Push(&Head3, 33, Ptypep << 16 | Arrname, Elsize);
if (!Bot3)
Bot3 = Head3;
Vmyop = Kk << 24 | Jj << 16 | Dvd;
Push(&Head3, 1 << 16, Vmyop, Bs << 18 | Dp);
if (!Head1)
Head1 = Head2;
else
Aslist[Bot1].Link = Head2;
Bot1 = Bot2;
Head2 = 0;
}
Aslist[Bot1].Link = Head3;
Bot1 = Bot3;
Expop(Head1, Breg, Nops, 0x251);
Aslist[Bot1].Link = Asl;
Asl = Head1;
Base = Bs;
Disp = Dp;
Access = 3;
Area = -1;
if (Expopnd.Flag <= 1) {
Nummod = Expopnd.D;
if (Nummod < 0)
Getinacc(Breg, 1, 0, 0, Nummod);
else
Access = 1;
}
} else {
if (Jj > Q)
Fault2(20, Jj - Q, Arrname);
else
Fault2(21, Q - Jj, Arrname);
P += 2;
Skipapp();
Base = Bs;
Disp = 0;
Access = 3;
Area = -1;
}
Acc = Elsize;
Ptype = Ptypep;
Unpack();
J = Jj;
Oldi = Soldi;
}
void Cname(int Z, int Reg) {
int Jj;
int Jjj;
int Kk;
int Rr;
int Levelp;
int Dispp;
int Namep;
int Pp;
int Savesl;
int Fname;
static int S_sw;
static void *S[2 /*12:13*/] = {
&&S_12,
&&S_default,
};
static int Funny_sw;
static void *Funny[2 /*12:13*/] = {
&&Funny_12,
&&Funny_13,
};
static int Sw_sw;
static void *Sw[9 /*0:8*/] = {
&&Sw_0, &&Sw_1, &&Sw_2, &&Sw_3, &&Sw_4,
&&Sw_5, &&Sw_6, &&Sw_7, &&Sw_default,
};
static int Map_sw;
static void *Map[4 /*0:3*/] = {
&&Map_0,
&&Map_1,
&&Map_2,
&&Map_3,
};
Pp = P;
Fname = (A[P] << 8) + A[P + 1];
if (Z == 1 || Z == 6)
Stname = Fname;
Copytag(Fname);
if (I == -1) {
Fault(16, Fname);
I = Rlevel;
J = 0;
K = Fname;
Kform = 0;
Sndisp = 0;
Acc = 4;
Ptype = 7;
Storetag(K, N);
K = N;
N += 4;
Copytag(Fname);
}
Savesl = Acc;
Jj = J;
if (Jj == 15)
Jj = 0;
Namep = Fname;
Levelp = I;
Dispp = K;
if (Litl == 1 && Rout == 0 && 0 == Nam &&
(Z == 1 || Z == 3 || (Z == 4 && Type < 5 && Arr == 0)))
Fault(29, Fname);
if (Type == 7)
goto Notset;
if ((Z == 0 && (Rout != 1 || 0 != Type && Type != 6)) ||
(Z == 13 && Rout == 0)) {
Fault2(27, 0, Fname);
goto Notset;
}
if (Z >= 10)
goto *Funny[Funny_sw = (Z)-12];
if (Rout == 1)
goto Rtcall;
goto *Sw[Sw_sw = Type];
Sw_6:;
Sw_4:;
Fault2(5, 0, Fname);
Sw_7:;
Notset:;
Nest = 0;
Base = I;
Disp = K;
Access = 0;
Area = Lnb;
Ptype = 1;
Unpack();
P += 2;
Skipapp();
goto Chken;
Funny_12:;
if (Type == 3 && (Arr == 0 || A[P + 2] == 1))
goto *Sw[Sw_sw = 3];
if (Ptype == Snpt) {
Csname(12, Reg);
goto Chken;
}
if (A[P + 2] == 2)
P += 3;
else
Noapp();
Access = 0;
Base = I;
Disp = K;
Area = -1;
Adjusthead:;
if (Arr == 1 && 1 == J && Parmarr == 0 && 0 == Nam && Parmchk == 0 &&
Type <= 3) {
Getwsp(&Jj, 4);
Getinacc(Accr, 4, Access, Areacode(), Disp);
Psf1(St, 1, Jj);
Getinacc(Breg, 1, 2, Lnb, Jj + 8);
if (Type == 3)
Kk = Acc;
else
Kk = Bytes[Prec];
if (Kk != 1)
Psf1(Myb, 0, Kk);
Psf1(Ld, 1, Jj);
Pf1(Inca, 0, Breg, 0);
Psf1(Std, 1, Jj);
Gruse[Dr] = 0;
Gruse[Accr] = 0;
Gruse[Breg] = 0;
Area = Lnb;
Disp = Jj;
}
goto Chken;
S_12:;
Nameop(1, Accr, 16, Namep);
goto Adjusthead;
Funny_13:;
if (Ptype == Snpt) {
Csname(Z, Reg);
P++;
goto Chken;
}
Disp = Midcell;
Base = I;
if (Nam & 1) {
Area = -1;
Getinacc(Reg, 4, 0, Areacode(), Disp);
} else {
if (J == 14) {
Getinacc(Reg, 2, 0, 0, 0);
Getinacc(Dr, 2, 0, Setxorynb(-1, -1), Disp);
} else if (Base == 0 && Cprmode == 2) {
Psf1(Ld, 1, 12);
if (Disp)
Psf1(Inca, 0, Disp);
Getinacc(Accr, 2, 0, 0, 0);
} else {
Psf1(Jlk, 0, 1);
Rtjump(Lda, &Aslist[Tags[Fname]].S2);
Pf1(Inca, 0, Tos, 0);
Jj = 0xE0000001;
Storeconst(&Jjj, 4, Addr(Jj));
Pf1(Ldtb, 0, Pc, Jjj);
Getinacc(Accr, 1, 0, Lnb, Ptroffset(Base));
Jj = 'IMP';
Storeconst(&Jjj, 4, Addr(Jj));
Pf1(Luh, 0, Pc, Jjj);
}
Pf1(Std, 0, Tos, 0);
Pf1(Luh, 0, Tos, 0);
Gruse[Dr] = 0;
}
if (A[P + 2] == 2)
P += 3;
else
Noapp();
goto Chken;
Sw_3:;
Crname(Z, Reg, 2 * Nam, I, -1, K, &Namep);
if (Z >= 10)
goto *S[S_sw = (Z)-12];
if (Z == 1 || Z == 6)
Stname = Namep;
if (Type == 5 && Z != 6)
goto Strinrec;
if (Type == 7)
goto Notset;
Nameop(Z, Reg, Bytes[Prec], Namep);
goto Chken;
Sw_5:;
if (Z == 6)
goto *Sw[Sw_sw = 1];
if (Arr >= 1)
goto Strarr;
if (A[P + 2] == 2)
P += 3;
else
Noapp();
Base = I;
Access = 2;
Area = -1;
Disp = K;
Sninrec:
if (Z == 1)
Z = 3;
if (Z == 3 || Z == 4) {
Nameop(Z, Reg, 8, -1);
goto Chken;
}
if (Access == 2 && Parmchk == 0 && Register[Dr] == 0) {
Psorlf1(Ldb, 2, Areacode(), Disp);
Gruse[Dr] = 0;
if (!Reg)
Copydr();
goto Chken;
}
Nameop(3, Dr, 8, -1);
Mbnd:
if (Parmchk == 1)
Testass(Dr, 5, 8);
Pf1(Ldb, 2, 7, 0);
if (!Reg)
Copydr();
goto Chken;
Strarr:;
Caname(Arr, I, K);
Namep = -1;
if (Z == 1 || Z == 6)
Stname = Namep;
Sainrec:;
if (Z == 1 || Z == 3) {
if (Nam == 1) {
Getinacc(Dr, 2, 0, Areacode(), Disp + 8);
Pf1(Slb, 1, 0, 1 + 3 * (J - 1));
}
if (Area != 7)
Getinacc(Dr, 2, 0, Areacode(), Disp);
if (Nam == 1) {
Pf1(Modd, 0, Tos, 0);
Pf1(Ldb, 0, Breg, 0);
} else {
if (Access == 1) {
if (Nummod)
Psf1(Modd, 0, Nummod);
} else if (Access == 3)
Pf1(Modd, 0, Breg, 0);
Psf1(Ldb, 0, Acc);
}
if (!Reg)
Copydr();
goto Chken;
}
if (Z == 4) {
Nameop(Z, Reg, 4, -1);
goto Chken;
}
if (Area != 7)
Getinacc(Dr, 2, 0, Areacode(), Disp);
if (Access == 1) {
if (Nummod)
Psf1(Modd, 0, Nummod);
} else if (Access == 3)
Pf1(Modd, 0, Breg, 0);
goto Mbnd;
Strinrec:;
if (Arr)
goto Sainrec;
if (Nam != 0 || Z == 4)
goto Sninrec;
Nameop(4, Breg, 4, -1);
Pf1(Ldtb, 0, Pc, Paramdes(3));
Pf1(Lda, 0, Breg, 0);
if (Z != 2 || Parmchk != 0)
Psf1(Ldb, 0, Acc);
Gruse[Dr] = 0;
if (Z == 2)
goto Mbnd;
if (!Reg)
Copydr();
goto Chken;
Rtcall:;
if (Type == 0 && Z != 0) {
Fault(23, Fname);
goto Notset;
}
if (Ptype == Snpt) {
Csname(Z, Reg);
if (Rout == 1 && Nam >= 1 && Z != 0)
goto Bim;
if (Type != 0 && Nest == Accr)
goto Mvfnres;
goto Chken;
}
Crcall(Fname);
P++;
if (!(Ptype & 15))
goto Chken;
if (Nam > 1)
goto Udm;
if (Z != 2 && Z != 5) {
Fault(29, Fname);
Base = 0;
Access = 0;
Disp = 0;
}
Mvfnres:
if (Type == 5) {
if (Reg == Dr) {
Pf1(St, 0, Tos, 0);
Pf1(Ld, 0, Tos, 0);
}
} else if (Reg == Breg) {
if (Register[Breg])
Bootout(Breg);
Pf1(St, 0, Breg, 0);
}
Nest = Reg;
goto Chken;
Udm:;
Pf1(St, 0, Breg, 0);
Disp = Mapdes(Prec);
Access = 3;
Area = Pc;
Namep = -1;
Stname = -1;
Bim:;
if (Area != Pc || Access != 3) {
Namep = -1;
Stname = -1;
}
if (Type == 3)
goto Chken;
if (Z == 3 || (Type == 5 && Z != 4)) {
Pf1(Ldtb, 0, Pc, Disp);
if (Type == 5 && (Parmchk != 0 || Z != 2))
Psf1(Ldb, 0, 255);
Pf1(Lda, 0, Breg, 0);
Gruse[Dr] = 0;
} else {
if (Gruse[Dr] == 7 && Namep > 0 && Grinf1[Dr] == (Namep & 0xFFFF) &&
1 <= Z && Z <= 2)
Area = 7;
}
Kk = Z;
if (Z == 5)
Kk = 2;
goto *Map[Map_sw = Kk & 3];
Map_0:;
if (Reg != Breg)
Getinacc(Accr, 1, 0, Breg, 0);
goto Chken;
Map_1:;
if (Type != 5)
goto Chken;
goto *Map[Map_sw = 3];
Map_2:;
if (Type == 5)
goto Mbnd;
Getinacc(Reg, (unsigned)Bytes[Prec] >> 2, Access, Area, Disp);
if (Namep > 0) {
Gruse[Dr] = 7;
Grinf1[Dr] = Namep;
}
if (Parmchk == 1 && Prec >= 5)
Testass(Reg, 1, Bytes[Prec]);
goto Chken;
Map_3:;
if (Type == 5)
Pf1(Ldb, 0, 0, 256);
if (Reg != Dr)
Copydr();
goto Chken;
Sw_0:;
if (3 > Z || Z > 4) {
Fault2(90, 0, Fname);
Type = 1;
}
Sw_1:;
Sw_2:;
if (Arr == 0 || (Z == 6 && A[P + 2] == 2)) {
Base = I;
Access = 2 * Nam;
Disp = K;
Area = -1;
if (A[P + 2] == 2)
P += 3;
else
Noapp();
} else {
Caname(Arr, I, K);
Nam = 0;
}
Nameop(Z, Reg, Bytes[Prec], Namep);
goto Chken;
Chken:
while (A[P] == 1) {
Fault(69, Fname);
P += 3;
Skipapp();
}
P++;
goto Sw_skip;
Sw_default:
fprintf(stderr, "\nSwitch label 'Sw(%d):' not set in %s\n", Sw_sw,
__PRETTY_FUNCTION__);
fflush(stderr);
abort();
Sw_skip:;
goto S_skip;
S_default:
fprintf(stderr, "\nSwitch label 'S(%d):' not set in %s\n", S_sw + 12,
__PRETTY_FUNCTION__);
fflush(stderr);
abort();
S_skip:;
}
void Nameop(int Z, int Reg, int Size, int Namep) {
static int Mod_sw;
static void *Mod[48 /*0:47*/] = {
&&Mod_0, &&Mod_1, &&Mod_2, &&Mod_3, &&Mod_4, &&Mod_5,
&&Mod_6, &&Mod_7, &&Mod_8, &&Mod_9, &&Mod_10, &&Mod_11,
&&Mod_12, &&Mod_13, &&Mod_14, &&Mod_15, &&Mod_16, &&Mod_17,
&&Mod_18, &&Mod_19, &&Mod_20, &&Mod_21, &&Mod_22, &&Mod_23,
&&Mod_24, &&Mod_25, &&Mod_26, &&Mod_27, &&Mod_28, &&Mod_29,
&&Mod_30, &&Mod_31, &&Mod_32, &&Mod_33, &&Mod_34, &&Mod_35,
&&Mod_36, &&Mod_37, &&Mod_38, &&Mod_39, &&Mod_40, &&Mod_41,
&&Mod_42, &&Mod_43, &&Mod_44, &&Mod_45, &&Mod_46, &&Mod_47,
};
auto int Basereg(int Gruseval, int Grinfval);
int Kk;
int Jjj;
int Tother;
int Xynb;
int Jj;
int Op1;
int Op2;
Kk = Z;
if (Z == 5)
Kk = 2;
if (Z == 6) {
if (Nam != 1 || Rout != 0 || (Access < 8 && Access != 2))
Fault2(82, 0, Namep);
Kk = 1;
Size = 8;
if (Access >= 8)
Access -= 4;
else
Access = 0;
}
Kk = Kk & 3;
goto *Mod[Mod_sw = Access << 2 | Kk];
Mod_0:;
if (Type == 3) {
Getinacc(Reg, 1, 0, Areacode(), Disp - 4);
return;
}
Getinacc(Reg, 1, 0, Lnb, Ptroffset(Base));
if (Reg == Breg)
Jjj = Adb;
else
Jjj = Iad;
Psf1(Jjj, 0, Disp);
if (Bimstr == 1)
Noteassment(Reg, 3, Namep);
return;
Mod_1:;
if (1 <= Size && Size <= 2) {
if (Gruse[Dr] != Size + 11)
Pf1(Ldtb, 0, Pc, Mapdes(Size + 2));
if (12 > Gruse[Dr] || Gruse[Dr] > 13 || Grinf1[Dr] != Base)
Psf1(Lda, 1, Ptroffset(Base));
Gruse[Dr] = Size + 11;
Grinf1[Dr] = Base;
Access = 1;
Area = 0;
} else
Area = Areacode();
return;
Mod_2:;
if (Size > 2 && Z == 5 && Parmchk == 0) {
Nest = -1;
return;
}
Mod_10:;
if (Gruse[Reg] >= 9 && Namep > 0)
if ((Grinf1[Reg] == Namep && (Gruse[Reg] & 255) == 9) ||
(Grinf2[Reg] == Namep && (unsigned)Gruse[Reg] >> 16 == 9)) {
if (Register[Reg])
Bootout(Reg);
Nest = Reg;
return;
}
Tother = Reg ^ 7;
if (Gruse[Tother] >= 9 && Namep > 0) {
Kk = Grinf1[Tother];
if ((Kk == Namep && (Gruse[Tother] & 255) == 9) ||
(Grinf2[Tother] == Namep &&
(unsigned)Gruse[Tother] >> 16 == 9)) {
if (Reg == Breg && Register[Breg] == 0) {
Pf1(St, 0, Breg, 0);
Gruse[Reg] = Gruse[Tother];
Grinf1[Reg] = Grinf1[Tother];
Grinf2[Reg] = Grinf2[Tother];
Nest = Reg;
return;
}
if (Reg == Accr && Z == 2) {
Access = 0;
Area = 7;
Size = 4;
Disp = 0;
}
}
}
if (1 <= Size && Size <= 2 && Access == 0) {
if (Gruse[Dr] != Size + 11)
Pf1(Ldtb, 0, Pc, Mapdes(Size + 2));
if (12 > Gruse[Dr] || Gruse[Dr] > 13 || Grinf1[Dr] != Base)
Psf1(Lda, 1, Ptroffset(Base));
Gruse[Dr] = Size + 11;
Grinf1[Dr] = Base;
if (Z == 5 && Parmchk == 0) {
Access = 1;
Area = 0;
Nest = -1;
return;
}
Getinacc(Reg, 1, 1, 0, Disp);
if (Parmchk != 0 && Size == 2)
Testass(Reg, Type, Size);
Nest = Reg;
return;
}
Mod_14:;
if (Access >= 2 && (Area == 7 || (Gruse[Dr] == 7 && Namep > 0 &&
Grinf1[Dr] == (Namep & 0xFFFF)))) {
Area = 7;
Disp = 0;
} else
Area = Areacode();
Drfetch:;
Getinacc(Reg, (unsigned)Size >> 2, Access, Area, Disp);
if (Parmchk == 1 && Size != 1)
Testass(Reg, Type, Size);
if ((Access == 0 || Access == 2) && Namep > 0) {
Gruse[Reg] = 9;
Grinf1[Reg] = Namep;
}
if (Access >= 2 && Namep > 0) {
Gruse[Dr] = 7;
Grinf1[Dr] = Namep & 0xFFFF;
}
Nest = Reg;
return;
Mod_3:;
if (Reg != Accr && Reg != Dr)
Abort();
if (Type == 3) {
Getinacc(Reg, 2, 0, Areacode(), Disp - 8);
return;
} else
Jjj = Paramdes(Prec);
if (!Reg) {
Getinacc(Reg, 1, 0, Lnb, Ptroffset(Base));
Op1 = Iad;
Op2 = Luh;
} else {
Psf1(Lda, 1, Ptroffset(Base));
Op1 = Inca;
Op2 = Ldtb;
}
Psf1(Op1, 0, Disp);
Pf1(Op2, 0, Pc, Jjj);
Gruse[Reg] = 0;
return;
Mod_4:;
Jj = Nummod;
if (Prec > 4)
Jj = Jj * Bytes[Prec];
goto Md20;
Mod_20:;
Jj = Nummod + Xdisp;
Md20:
Getinacc(Reg, 1, 0, Areacode(), Disp + 4);
if (!Reg)
Op1 = Iad;
else
Op1 = Adb;
if (Jj)
Psf1(Op1, 0, Jj);
return;
Mod_7:;
Jj = Nummod;
if (Prec > 4)
Jj = Jj * Bytes[Prec];
Getinacc(Reg, 2, 0, Areacode(), Disp);
if (!Reg)
Op1 = Iad;
else
Op1 = Inca;
if (Jj)
Psf1(Op1, 0, Jj);
return;
Mod_5:;
Mod_6:;
if (!Nummod) {
Access = 2;
goto *Mod[Mod_sw = Kk + 8];
}
if (Gruse[Dr] != 7 || Namep <= 0 || Grinf1[Dr] != (Namep & 0xFFFF))
Getinacc(Dr, 2, 0, Areacode(), Disp);
if (Namep > 0) {
Gruse[Dr] = 7;
Grinf1[Dr] = Namep & 0xFFFF;
}
Area = 0;
Disp = Nummod;
if (Z == 2)
goto Drfetch;
return;
Mod_12:;
Jjj = Bytes[Prec];
if (Jjj != 1 && Prec != 4) {
Psf1(Myb, 0, Jjj);
Gruse[Breg] = 0;
}
Md12:
if (Reg == Breg) {
if (Area == 7) {
Pf1(Inca, 0, Breg, 0);
Gruse[Dr] = 0;
Pf1(Lb, 2, 0, 11);
} else
Pf1(Adb, 0, Areacode(), Disp + 4);
Gruse[Breg] = 0;
return;
}
Mod_8:;
if (Area == 7)
Getinacc(Reg, 1, 2, 0, 11);
else
Getinacc(Reg, 1, 0, Areacode(), Disp + 4);
if ((Access & 3) == 3)
Pf1(Iad, 0, Breg, 0);
return;
Mod_9:;
Mod_13:;
if (Area == 7) {
Disp = 0;
return;
}
if (Gruse[Dr] == 7 && Namep > 0 && Grinf1[Dr] == (Namep & 0xFFFF)) {
Area = 7;
Disp = 0;
} else
Area = Areacode();
return;
Mod_11:;
if (Area == 7) {
if (Reg != Dr)
Copydr();
return;
}
Getinacc(Reg, 2, 0, Areacode(), Disp);
return;
Mod_15:;
if (Area != 7)
Getinacc(Dr, 2, 0, Areacode(), Disp);
if (Prec == 4 || (Type == 3 && Parmarr == 0))
Jj = Inca;
else
Jj = Modd;
Pf1(Jj, 0, Breg, 0);
if (Reg != Dr)
Copydr();
Gruse[Dr] = 0;
return;
Mod_17:;
Mod_18:;
if (Size == 1) {
Disp -= 8;
goto Md2526;
}
Disp += Xdisp;
Access = 0;
goto *Mod[Mod_sw = Kk];
Mod_36:;
Mod_37:;
Mod_38:;
Mod_39:;
Xynb = Basereg(8, Namep & 0xFFFF);
Disp = Nummod + Xdisp;
Area = Xynb;
Access = 3;
Namep = 0;
goto *Mod[Mod_sw = Kk + 8];
Mod_16:;
Disp -= 8;
Mod_24:;
Getinacc(Reg, 1, 0, Areacode(), Disp + 4);
if (Reg == Breg)
Kk = Adb;
else
Kk = Iad;
if (Xdisp)
Psf1(Kk, 0, Xdisp);
return;
Md2526:;
Mod_25:;
Mod_26:;
if (Size > 2) {
Xynb = Basereg(8, Namep & 0xFFFF);
Area = Xynb;
Access = 0;
Disp = Xdisp;
goto *Mod[Mod_sw = Kk];
}
if (Size == 1) {
if (Gruse[Dr] != 7 || Namep <= 0 || Grinf1[Dr] != (Namep & 0xFFFF))
Psorlf1(Ld, 0, Areacode(), Disp);
} else {
if (Gruse[Dr] != 13 && Gruse[Dr] != 15)
Pf1(Ldtb, 0, Pc, Mapdes(4));
if (Namep <= 0 || Grinf1[Dr] != (Namep & 0xFFFF) ||
(Gruse[Dr] != 7 && Gruse[Dr] != 15))
Psorlf1(Lda, 0, Areacode(), Disp + 4);
}
Gruse[Dr] = 0;
if (Namep > 0) {
Gruse[Dr] = 8 * Size - 1;
Grinf1[Dr] = Namep & 0xFFFF;
}
Access = 1;
Area = 0;
Disp = Xdisp;
if (Disp == 0 && Access == 1) {
Area = 7;
Access = 2;
}
if (Z == 2)
goto Drfetch;
return;
Mod_23:;
Xdisp += Nummod;
goto Md31;
Mod_19:;
Disp -= 8;
Mod_27:;
Mod_31:;
Md31:
Getinacc(Dr, 2, 0, Areacode(), Disp);
if (Xdisp)
Psf1(Inca, 0, Xdisp);
if (Access == 7)
Pf1(Inca, 0, Breg, 0);
if (Type == 3 || Type == 5)
Psorlf1(Ldb, 0, 0, Acc);
else
Pf1(Ldtb, 0, Pc, Paramdes(Prec));
if (Reg != Dr)
Copydr();
return;
Mod_28:;
if (Xdisp) {
Psf1(Adb, 0, Xdisp);
Gruse[Breg] = 0;
}
Access = 3;
goto Md12;
Mod_29:;
Mod_30:;
Mod_21:;
Mod_22:;
if (1 <= Size && Size <= 2) {
if (Size == 1) {
if (Gruse[Dr] != 7 || Namep <= 0 ||
Grinf1[Dr] != (Namep & 0xFFFF))
Psorlf1(Ld, 0, Areacode(), Disp);
} else {
if (Namep < 0 || Grinf1[Dr] != (Namep & 0xFFFF) ||
(Gruse[Dr] != 7 && Gruse[Dr] != 15))
Psorlf1(Lda, 0, Areacode(), Disp + 4);
if (Gruse[Dr] != 13 && Gruse[Dr] != 15)
Pf1(Ldtb, 0, Pc, Mapdes(4));
}
Gruse[Dr] = 0;
if (Namep > 0) {
Gruse[Dr] = 8 * Size - 1;
Grinf1[Dr] = Namep & 0xFFFF;
}
if (Access == 7) {
if (Xdisp)
Psf1(Adb, 0, Xdisp);
Access = 3;
Area = 7;
Disp = 0;
Gruse[Breg] = 0;
} else {
Disp = Xdisp + Nummod;
Access = 1;
Area = 0;
}
Namep = 0;
if (Z == 2)
goto Drfetch;
return;
}
if (Access == 7) {
Psorlf1(Adb, 0, Areacode(), Disp + 4);
Gruse[Breg] = 0;
Xynb = Xorynb(0, 0);
Pf1(Ldcode[Xynb], 0, Breg, 0);
Gruse[Xynb] = 0;
Disp = Xdisp;
} else {
Xynb = Basereg(8, Namep & 0xFFFF);
Disp = Nummod + Xdisp;
}
Area = Xynb;
Access = 0;
Namep = 0;
goto *Mod[Mod_sw = Kk];
Mod_32:;
Mod_33:;
Mod_34:;
Mod_35:;
Disp += Xdisp;
Namep = 0;
Access = 2;
goto *Mod[Mod_sw = Kk + 8];
Mod_40:;
Mod_41:;
Mod_42:;
Mod_43:;
Xynb = Basereg(8, Namep & 0xFFFF);
Area = Xynb;
Access = 2;
Disp = Xdisp;
Namep = 0;
goto *Mod[Mod_sw = Kk + 8];
Mod_44:;
Mod_45:;
Mod_46:;
Mod_47:;
Psorlf1(Adb, 0, Areacode(), Disp + 4);
Gruse[Breg] = 0;
Xynb = Xorynb(0, 0);
Pf1(Ldcode[Xynb], 0, Breg, 0);
Gruse[Xynb] = 0;
Namep = 0;
Area = Xynb;
Access = 2;
Disp = Xdisp;
goto *Mod[Mod_sw = Kk + 8];
int Basereg(int Gruseval, int Grinfval) {
int Xynb;
if (Namep <= 0) {
Gruseval = 0;
Grinfval = 0;
}
Xynb = Xorynb(Gruseval, Grinfval);
if (Gruse[Xynb] != Gruseval || Gruseval <= 0 ||
Grinf1[Xynb] != Grinfval)
Psorlf1(Ldcode[Xynb], 0, Areacode(), Disp + 4);
Gruse[Xynb] = Gruseval;
Grinf1[Xynb] = Grinfval;
Grat[Xynb] = Ca;
return (Xynb);
}
}
void Crcall(int Rtname) {
static int Fpd_sw;
static void *Fpd[4 /*0:3*/] = {
&&Fpd_0,
&&Fpd_1,
&&Fpd_2,
&&Fpd_3,
};
int Ii;
int Iii;
int Qqq;
int Dlink;
int Jj;
int Jjj;
int Nparms;
int Pt;
int Lp;
int Psize;
int Twsp;
int Fptr;
int Typep;
int Precp;
int Namp;
int Tl;
int Moveptr;
int Clink;
int Rdisp;
Listf *Lcell;
Pt = Ptype;
Jjj = J;
Tl = Oldi;
Twsp = 0;
Lp = I;
Clink = K;
Typep = Type;
Precp = Prec;
Namp = Nam;
Rdisp = Midcell;
Testapp(&Nparms);
P += 2;
if (Kform != Nparms) {
Fault(19, Rtname);
Skipapp();
P--;
return;
}
Saveirs();
Psf1(Prcl, 0, 4);
Fptr = 20;
goto Firstparm;
Nextparm:
Clink = Lcell->Link;
Firstparm:
if (!Clink)
goto Entryseq;
Lcell = &Aslist[Clink];
Psize = (unsigned)Lcell->S2 >> 16;
P++;
Ptype = (unsigned)Lcell->S1 >> 16;
Unpack();
Ii = Type;
Iii = Prec;
Jj = (Nam << 1 | Arr) & 3;
if ((Jj != 0 || Rout != 0) && (A[P + 3] != 4 || A[P + 4] != 1 ||
A[P + Fromar2(P + 1) + 1] != 2)) {
Fault(22, 0);
Skipexp();
goto Nextparm;
}
if (Rout == 1) {
Ii = Ptype;
P += 5;
Cname(13, Accr);
if ((Ii & 255) != (Ptype & 255))
Fault(22, 0);
P++;
Moveptr = 16;
goto Stuff;
}
goto *Fpd[Fpd_sw = Jj];
Fpd_0:;
if (Type == 5) {
Cstrexp(17, Dr);
Psf1(Ldb, 0, Psize);
if (Register[Accr] == 3) {
Pf1(St, 0, Tos, 0);
Register[Accr] = 0;
}
Pf1(Std, 0, Tos, 0);
Push(&Twsp, Value, 268, 0);
Fptr += 8;
goto Nextparm;
} else {
if (Prec == 6)
Jj = 3;
else
Jj = Type;
Csexp(Accr, Iii << 4 | Ii);
Moveptr = ((Bytes[Iii] + 3) & (-4));
}
goto Stuff;
Fpd_2:;
P += 5;
Fname = Fromar2(P);
Copytag(Fname);
if (Ii != 0 || Type == 0) {
Cname(3, Accr);
if (Ii != Type || Iii != Prec)
Fault(22, Fname);
} else {
Cname(4, Accr);
if (Type <= 2)
Jj = Prec << 27 | Type;
else
Jj = (0x1A << 24) + Acc;
Storeconst(&Iii, 4, Addr(Jj));
Pf1(Luh, 0, Pc, Iii);
}
P++;
Moveptr = 8;
goto Stuff;
Fpd_1:
Fpd_3:;
P += 5;
Cname(12, Accr);
Getinacc(Accr, 4, 0, Areacode(), Disp);
P++;
Moveptr = 16;
if (1 > Arr || Arr > 2 || Ii != Type || Iii != Prec) {
Fault(22, 0);
goto Stuff;
}
Qqq = From1(Tcell) & 15;
Jj = Lcell->S1 & 15;
if (!Jj) {
Jj = Qqq;
Lcell->S1 = Lcell->S1 | Jj;
}
if (!Qqq) {
Qqq = Jj;
Replace1(Tcell, From1(Tcell) | Jj);
}
if (Jj != Qqq)
Fault(22, 0);
Stuff:
Register[Accr] = 3;
Fptr += Moveptr;
goto Nextparm;
Entryseq:;
if (Register[Accr] == 3) {
Pf1(St, 0, Tos, 0);
Register[Accr] = 0;
}
J = Jjj;
while (Twsp) {
Pop(&Twsp, &Qqq, &Jj, &Iii);
Returnwsp(Qqq, 268);
}
if (Typep == 5 && Namp <= 1) {
Getwsp(&Qqq, 268);
Strfnres = Qqq;
Iii = 0x18000100;
Qqq += 8;
Storeconst(&Jj, 8, Addr(Iii));
Pf1(Ld, 0, Pc, Jj);
Psf1(Inca, 1, Ptroffset(Rbase));
Pf1(Std, 0, Tos, 0);
Fptr += 8;
}
if (Jjj == 14) {
Nmdecs[Level] = Nmdecs[Level] | 2;
Ii = Setxorynb(-1, -1);
Psf1(Raln, 0, (unsigned)Fptr >> 2);
Pf1(Call, 2, Ii, Rdisp);
} else if (!(Namp & 1))
if (!Lp) {
Psf1(Ld, 1, 12);
if (Rdisp)
Psf1(Inca, 0, Rdisp);
Psf1(Raln, 0, (unsigned)Fptr >> 2);
Pf1(Call, 2, 7, 0);
} else {
Ii = Setxorynb(Xnb, Lp);
Psf1(Raln, 0, (unsigned)Fptr >> 2);
Rtjump(Call, &Aslist[Tags[Rtname]].S2);
}
else {
Area = -1;
Base = Lp;
Area = Areacode();
Getinacc(Dr, 2, 0, Area, Rdisp);
Psorlf1(Lxn, 0, Area, Rdisp + 12);
Psf1(Raln, 0, (unsigned)Fptr >> 2);
Pf1(Call, 2, 7, 0);
}
Forget(-1);
Rout = 1;
Type = Typep;
Nam = Namp;
Prec = Precp;
Ptype = Pt;
}
void Rtjump(int Code, int *Link) {
int Dp;
if (J == 15) {
Push(Link, Code << 24 | 3 << 23, Ca, 0);
Pf1(Code, 0, 0, 0);
} else {
Dp = *Link - Ca;
if (Code == Call)
Dp = Dp / 2;
Psf1(Code, 0, Dp);
}
}
int Tsexp(int *Value) {
static int Sw_sw;
static void *Sw[3 /*1:3*/] = {
&&Sw_1,
&&Sw_2,
&&Sw_3,
};
int Pp;
int Rexp;
int Kk;
int Sign;
int Ct;
Type = 1;
Pp = P;
Rexp = 2 - A[P + 1 + Fromar2(P + 1)];
P += 3;
Sign = A[P];
if (Sign != 4 && A[P + 1] != 2)
goto Typed;
goto *Sw[Sw_sw = (A[P + 1]) - 1];
Sw_1:;
P += 2;
Reducetag();
goto Typed;
Sw_2:;
Ct = A[P + 2];
Type = Ct & 7;
if (Ct != 0x41 || Sign == 3)
goto Typed;
Kk = Fromar2(P + 3);
if (Rexp != 0 && A[P + 6] == Concop) {
Type = 5;
goto Typed;
}
if (Rexp != 0 || 0 > Kk || Kk > 255)
goto Typed;
*Value = Kk;
P += 6;
if (Sign != 2)
return (1);
*Value = -*Value;
return (-1);
Sw_3:;
Typed:
P = Pp;
return (0);
}
void Skipexp(void) {
int Optype;
int Pin;
int J;
Pin = P;
P += 3;
for (;;) {
Optype = A[P + 1];
P += 2;
if (Optype == 0 || Optype > 3)
Abort();
if (Optype == 3)
Skipexp();
if (Optype == 2) {
J = A[P] & 7;
if (J == 5)
P = P + A[P + 5] + 6;
else
P = P + 1 + Bytes[(unsigned)A[P] >> 4];
}
if (Optype == 1) {
P--;
do {
P += 3;
Skipapp();
} while (A[P] != 2);
P++;
}
P++;
if (A[P - 1] == 2)
break;
}
}
void Skipapp(void) {
int Pin;
Pin = P;
while (A[P] == 1) {
P++;
Skipexp();
}
P++;
}
void Noapp(void) {
P += 2;
if (A[P] == 1) {
Fault2(17, 0, Fromar2(P - 2));
Skipapp();
} else
P++;
}
void Testapp(int *Num) {
int Pp;
int Q;
Q = 0;
Pp = P;
P += 2;
while (A[P] == 1) {
P++;
Q++;
Skipexp();
}
P = Pp;
*Num = Q;
}
void Testass(int Reg, int Type, int Size) {
int Opcode;
int A;
int D;
if (Type == 5) {
if (Reg != Dr)
return;
Pf1(Std, 0, Tos, 0);
Pf2(Sweq, 1, 1, 0, 0, Unasspat & 255);
} else {
if (Reg == Breg)
Opcode = Cpb;
else
Opcode = Ucp;
if (Size == 16)
Pf1(Stuh, 0, Tos, 0);
if (Size == 2) {
A = 0;
D = (unsigned)Unasspat >> 16;
} else {
A = Pc;
D = Plabs[1];
}
Pf1(Opcode, 0, A, D);
if (Size == 16)
Pf1(Luh, 0, Tos, 0);
}
Ppj(8, 5);
if (Type == 5)
Pf1(Ld, 0, Tos, 0);
}
void Getwsp(int *Place, int Size) {
int J;
int K;
int L;
if (Size > 4)
Size = 0;
Pop(&Avlwsp[Size][Level], &J, &K, &L);
if (K <= 0) {
if (Size > 1)
Oddalign();
K = N;
if (!Size)
N += 268;
else
N += Size << 2;
}
*Place = K;
if (Size)
Push(&Twsphead, K, Size, 0);
}
void Returnwsp(int Place, int Size) {
if (Size > 4)
Size = 0;
if (Place < 511)
Push(&Avlwsp[Size][Level], 0, Place, 0);
else
Insertatend(&Avlwsp[Size][Level], 0, Place, 0);
}
void Setline(void) {
int Xynb;
int I;
int Ldi;
int Sti;
int Reg;
Ldi = Lss;
Sti = St;
Reg = Accr;
if ((Parmdbug | Parmprof) == 0 && Gruse[Accr] != 0 &&
(Gruse[Breg] == 0 || Gruse[Breg] == 5)) {
Ldi = Lb;
Sti = Stb;
Reg = Breg;
}
if (Parmline | Parmdbug)
Psf1(Ldi, 0, Line);
if (Parmline == 1) {
Psf1(Sti, 1, Diaginf[Level]);
Gruse[Reg] = 5;
Grinf1[Reg] = Line;
}
if (Parmdbug)
Ppj(0, 3);
if (Parmprof) {
Xynb = Setxorynb(-1, 0);
Psf1(Lss, 0, 1);
I = Parmprof + 8 + 4 * Line;
Pf1(Iad, 0, Xynb, I);
Pf1(St, 0, Xynb, I);
Gruse[Accr] = 0;
}
}
void Forget(int Reg) {
int L;
int U;
L = Reg;
U = L;
if (L < 0) {
L = 0;
U = 7;
}
for (Reg = L; Reg <= U; Reg++)
if (Register[Reg] >= 0) {
Gruse[Reg] = 0;
Grinf1[Reg] = 0;
}
}
void Saveirs(void) {
if (Register[Accr] == 1 && 1 == Register[Breg])
Abort();
if (Register[Accr] >= 1)
Bootout(Accr);
if (Register[Breg] >= 1)
Bootout(Breg);
if (Register[Dr] >= 1)
Bootout(Dr);
}
void Bootout(int Reg) {
static const unsigned char Bootcode[8 /*0:7*/] = {
0x48, 0x58, 0x5C, [3 ... 6] = 0, 0x5A};
int Code;
Rd *R;
Code = Bootcode[Reg];
if (1 > Register[Reg] || Register[Reg] > 3 || Code == 0)
Abort();
R = Record(Olink[Reg]);
if (Register[Reg] == 2) {
if (!R->D)
Getwsp(&R->D, (unsigned)Bytes[(unsigned)R->Ptype >> 4] >> 2);
Psf1(Code, 1, R->D);
} else {
if (Reg != Accr && (Register[Accr] == 1 || Register[Accr] == 3))
Bootout(Accr);
Pf1(Code, 0, Tos, 0);
}
Changerd(Reg);
Register[Reg] = 0;
}
void Copydr(void) {
if (Register[Accr])
Bootout(Accr);
Psf1(Cyd, 0, 0);
Gruse[Accr] = 0;
}
void Changerd(int Reg) {
Rd *Opnd;
if (1 > Register[Reg] || Register[Reg] > 3)
Abort();
Opnd = Record(Olink[Reg]);
if (Register[Reg] == 1) {
if (Opnd->Flag != 9 || (unsigned)Opnd->Xb >> 4 != Reg)
Abort();
Opnd->Flag = 8;
Opnd->Xb = Tos << 4;
}
if (Register[Reg] == 2) {
Opnd->Flag = 7;
Opnd->Xb = Lnb << 4;
}
}
void Storetag(int Kk, int Slink) {
int Q;
int Qq;
int Qqq;
int I;
int Tcell;
Listf *Lcell;
Tcell = Tags[Kk];
Q = Ptype << 16 | Level << 8 | Rbase << 4 | J;
Qqq = Slink << 16 | Kform;
Qq = Sndisp << 16 | Acc;
if (((unsigned)From1(Tcell) >> 8 & 63) == Level) {
Fault(7, Kk);
Q = From1(Tcell) & 0xC000 | Q;
Replace123(Tcell, Q, Qq, Qqq);
} else {
I = Asl;
if (!I)
I = Morespace();
Lcell = &Aslist[I];
Asl = Lcell->Link;
Lcell->Link = Tags[Kk] | Names[Level] << 18;
Lcell->S1 = Q;
Lcell->S2 = Qq;
Lcell->S3 = Qqq;
Tags[Kk] = I;
Names[Level] = Kk;
}
}
void Copytag(int Kk) {
int Qqq;
Listf *Lcell;
Tcell = Tags[Kk];
if (!Tcell) {
Type = 7;
Ptype = 0x57;
Prec = 5;
Rout = 0;
Nam = 0;
Arr = 0;
Litl = 0;
Acc = 4;
I = -1;
J = -1;
K = -1;
Oldi = -1;
} else {
Lcell = &Aslist[Tcell];
Kk = Lcell->S1;
Lcell->S1 = Kk | 0x8000;
Midcell = Lcell->S2;
Qqq = Lcell->S3;
Ptype = (unsigned)Kk >> 16;
Usebits = (unsigned)Kk >> 14 & 3;
Oldi = (unsigned)Kk >> 8 & 63;
I = (unsigned)Kk >> 4 & 15;
J = Kk & 15;
Sndisp = (Midcell & 0xFFFF0000) / 0x10000;
Acc = Midcell & 0xFFFF;
K = (unsigned)Qqq >> 16;
Kform = Qqq & 0xFFFF;
Litl = (unsigned)Ptype >> 14;
Rout = (unsigned)Ptype >> 12 & 3;
Nam = (unsigned)Ptype >> 10 & 3;
Arr = (unsigned)Ptype >> 8 & 3;
Prec = (unsigned)Ptype >> 4 & 15;
Type = Ptype & 15;
}
}
void Reducetag(void) {
int Subs;
int Qq;
int Pp;
Copytag(Fromar2(P));
if (Ptype == Snpt) {
Ptype = Tsname[K];
Unpack();
Rout = 1;
}
if (Type == 3) {
Pp = P;
Qq = Copyrecordtag(&Subs);
P = Pp;
}
}
void Replacetag(int Kk) {
int P;
int Q;
P = Tags[Kk];
Q = Ptype << 16 | Usebits << 14 | Oldi << 8 | I << 4 | J;
Replace1(P, Q);
Replace3(P, K << 16 | Kform);
}
void Unpack(void) {
Litl = (unsigned)Ptype >> 14;
Rout = (unsigned)Ptype >> 12 & 3;
Nam = (unsigned)Ptype >> 10 & 3;
Arr = (unsigned)Ptype >> 8 & 3;
Prec = (unsigned)Ptype >> 4 & 15;
Type = Ptype & 15;
}
void Pack(int *Ptype) {
*Ptype = ((((Litl << 2 | Rout) << 2 | Nam) << 2 | Arr) << 4 | Prec) << 4 | Type;
}
void Ppj(int Mask, int N) {
int Val;
int Instrn;
int Code;
int J;
Listf *Lcell;
if (!Mask)
Code = Jlk;
else
Code = Call;
if (Mask > 0)
Code = Jcc;
if (Mask >= 16)
Code = Jat;
if (Mask >= 32)
Code = Jaf;
Val = Plabs[N];
if (Mask <= 0)
Instrn = Code << 24 | 3 << 23;
else
Instrn = Code << 24 | (Mask & 15) << 21;
if (Val > 0)
Instrn = Instrn | ((Val - Ca) / 2) & 0x3FFFF;
else {
Lcell = &Aslist[Plink[N]];
J = Instrn | Ca;
if (Lcell->S3)
Push(&Plink[N], J, 0, 0);
else if (!Lcell->S2)
Lcell->S2 = J;
else
Lcell->S3 = J;
}
Pconst(Instrn);
if (Mask <= 0)
Forget(-1);
}
int Setxorynb(int Which, int Rlev) {
int Use;
int Inf;
int Offset;
if (-1 > Rlev || Rlev > Rlevel)
Abort();
if (Rlev <= 0) {
Use = 3;
Inf = 0;
} else {
Use = 4;
Inf = Rlev;
}
if (Which <= 0)
Which = Xorynb(Use, Inf);
if (Gruse[Which] == Use && Grinf1[Which] == Inf) {
Grat[Which] = Ca;
return (Which);
}
Offset = Ptroffset(Rlev);
Psf1(Ldcode[Which], 1, Offset);
Gruse[Which] = Use;
Grinf1[Which] = Inf;
Grat[Which] = Ca;
return (Which);
}
int Xorynb(int Use, int Inf) {
if (Gruse[Xnb] == Use && Grinf1[Xnb] == Inf) {
Grat[Xnb] = Ca;
return (Xnb);
}
if (Gruse[Ctb] == Use && Grinf1[Ctb] == Inf) {
Grat[Ctb] = Ca;
return (Ctb);
}
if (!(Gruse[Xnb] | Gruse[Ctb])) {
if (Use == 3)
return (Ctb);
return (Xnb);
}
if (!Gruse[Xnb])
return (Xnb);
if (!Gruse[Ctb])
return (Ctb);
if (Grat[Xnb] < Grat[Ctb])
return (Xnb);
return (Ctb);
}
void Oddalign(void) {
if (!(N & 7)) {
Returnwsp(N, 1);
N += 4;
}
}
int Ptroffset(int Rlev) {
if (Rlev <= 0)
return (16);
return (Display[Rlevel] + ((Rlev - 1) << 2));
}
int Areacode(void) {
if (Area < 0) {
if (Base == Rbase) {
Area = Lnb;
return (Lnb);
}
Area = Setxorynb(-1, Base);
}
return (Area);
}
int Areacode2(int Bs) {
if (Bs == Rbase)
return (Lnb);
return (Setxorynb(-1, Bs));
}
void Getinacc(int Reg, int Size, int Access, int Area, int Disp) {
int Opcode;
if (!Size)
Size = 1;
if (Reg == Dr)
Opcode = Ld;
else if (Reg == Breg)
Opcode = Lb;
else
Opcode = Lss + (Size & 6);
if (Register[Reg] >= 1)
if (Register[Reg] == 2 || (Access == 2 && Area == 0))
Bootout(Reg);
else {
if (Reg != Accr && (Register[Accr] == 1 || Register[Accr] == 3))
Bootout(Accr);
Changerd(Reg);
Register[Reg] = 0;
if (!Reg)
Opcode -= 32;
else
Opcode -= 40;
}
Psorlf1(Opcode, Access, Area, Disp);
if (Access >= 2 && 0 != Area && Area != 7)
Gruse[Dr] = 0;
Gruse[Reg] = 0;
}
void Noteassment(int Reg, int Assop, int Var) {
static const int Eemask = 0b100011110000000;
static const int Emask = 0b100011000000000;
static const int Nregs = 5;
#define Regs (16 * 16 * 16 * 16 * Ctb + 16 * 16 * 16 * Xnb + 16 * 16 * Accr + 16 * Breg + Dr)
int I;
int Use1;
int Use2;
int Ii;
if (Var <= 0)
return;
if (Assop == 1) {
for (I = 0; I <= 7; I++) {
Use1 = Gruse[I];
Use2 = (unsigned)Use1 >> 16;
Use1 = Use1 & 255;
if ((Eemask & 1 << Use2) != 0 &&
((Grinf2[I] & 0xFFFF) == Var ||
(unsigned)Grinf2[I] >> 16 == Var)) {
Gruse[I] = Use1;
Use2 = 0;
}
if ((Eemask & 1 << Use1) != 0 &&
((Grinf1[I] & 0xFFFF) == Var ||
(unsigned)Grinf1[I] >> 16 == Var)) {
Gruse[I] = Use2;
Grinf1[I] = Grinf2[I];
}
}
Gruse[Reg] = 7;
Grinf1[Reg] = Var;
} else {
for (Ii = 0; Ii <= 4 * (Nregs - 1); Ii += 4) {
I = (unsigned)Regs >> Ii & 15;
Use1 = Gruse[I];
Use2 = (unsigned)Use1 >> 16;
Use1 = Use1 & 255;
if ((Emask & 1 << Use2) != 0 &&
((Grinf2[I] & 0xFFFF) == Var ||
(unsigned)Grinf2[I] >> 16 == Var || Grinf2[I] == Var)) {
Gruse[I] = Use1;
Use2 = 0;
}
if ((Emask & 1 << Use1) != 0 &&
((Grinf1[I] & 0xFFFF) == Var ||
(unsigned)Grinf1[I] >> 16 == Var || Grinf1[I] == Var)) {
Gruse[I] = Use2;
Grinf1[I] = Grinf2[I];
}
}
if (Assop == 2 && Var > 0) {
Use1 = Gruse[Reg];
if (5 <= (Use1 & 255) && (Use1 & 255) <= 6) {
Gruse[Reg] = Use1 & 255 | (9 << 16);
Grinf2[Reg] = Var;
} else {
Gruse[Reg] = Use1 << 16 | 9;
Grinf2[Reg] = Grinf1[Reg];
Grinf1[Reg] = Var;
}
}
}
}
#undef Regs
}
void Printuse(void) {
static const _imp_string Regs[8 /*0:7*/] = {
_imp_str_literal("ACC"), _imp_str_literal(" DR"),
_imp_str_literal("LNB"), _imp_str_literal("XNB"),
_imp_str_literal(" PC"), _imp_str_literal("CTB"),
_imp_str_literal("TOS"), _imp_str_literal(" B")};
static const _imp_string Uses[16 /*0:15*/] = {
_imp_str_literal(" NOT KNOWN "), _imp_str_literal(" I-RESULT "),
_imp_str_literal(" TEMPORARY "), _imp_str_literal(" PLTBASE "),
_imp_str_literal(" NAMEBASE "), _imp_str_literal(" LIT CONST "),
_imp_str_literal(" TAB CONST "), _imp_str_literal(" DESC FOR "),
_imp_str_literal(" RECD BASE "), _imp_str_literal(" LOCAL VAR "),
_imp_str_literal(" NAME+CNST "), _imp_str_literal(" AUXSTPTR- "),
_imp_str_literal(" BYTE DES "), _imp_str_literal(" HALF DES "),
_imp_str_literal(" VMY RES "), _imp_str_literal(" REC HDES ")};
static const _imp_string State_raw[5 /*-1:3*/] = {
_imp_str_literal(" LOCKED "), _imp_str_literal(" FREE "),
_imp_str_literal(" I-RESULT "), _imp_str_literal(" TEMPORARY "),
_imp_str_literal(" RT-PARAM ")};
static const _imp_string *State = &State_raw[1];
auto void Out(int Use, int Inf);
int I;
int Use;
int Inf;
for (I = 0; I <= 7; I++)
if (Register[I] | Gruse[I]) {
Use = Gruse[I];
Printstring(_imp_join(Regs[I], State[Register[I]]));
Out(Use & 255, Grinf1[I]);
if ((unsigned)Use >> 16) {
Printstring(_imp_str_literal(" ALSO "));
Out((unsigned)Use >> 16, Grinf2[I]);
}
Newline();
}
return;
void Out(int Use, int Inf) {
static const int Lnmask = 0b1100011110000000;
static const int Unmask = 0b0100001110000000;
Printstring(_imp_join(_imp_str_literal(" USE = "), Uses[Use]));
if (Lnmask & 1 << Use)
Printstring(Printname(Inf & 0xFFFF));
else
Write(Inf, 1);
if (Use == 10) {
Printsymbol('+');
Write((unsigned)Inf >> 16, 1);
}
if ((Unmask & 1 << Use) != 0 && (unsigned)Inf >> 16 != 0) {
Printstring(_imp_str_literal(" MODBY"));
Printstring(Printname((unsigned)Inf >> 16));
}
}
}
void Abort(void) {
Printstring(
_imp_str_literal("\n**************** "
"ABORT******************** ABORT *******"));
if (Ca != Cabuf)
Ncode(Addr(Code[0]), Addr(Code[Ppcurr]), Cabuf);
Printuse();
_imp_monitor(0);
exit(0);
}
void Epilogue(void) {
int D;
int J;
auto void Fill(int Lab);
if (!Plink[15])
goto P16;
Abort();
P16:;
if (!Plink[16])
goto P17;
Fill(16);
Psf1(Lxn, 1, 0);
Pf1(Ld, 0, Xnb, 12);
Psf1(Ldb, 0, 0);
Psf1(Std, 1, 12);
Psf1(Asf, 0, 4);
Psf1(Ld, 1, 20);
Psf1(Sld, 1, 36);
Psf1(Lb, 0, 0);
Pf3(Jat, 11, 0, 0x24);
Psf1(Inca, 0, 1);
Pf1(Lb, 2, 7, 0);
Psf1(Std, 1, 44);
Psf1(Lss, 1, 20);
Pf1(And, 0, 0, 0x1FF);
Pf3(Jat, 4, 0, 0x27);
Psf1(Ld, 1, 23);
Pf2(Swne, 1, 0, 0, 0, 0);
Pf3(Jcc, 8, 0, 0x23);
Psf1(Std, 1, 52);
Psf1(Cyd, 0, 0);
Psf1(Ld, 1, 44);
Pf2(Cps, 1, 1, 0, 0, 0xFF);
Pf3(Jcc, 8, 0, 5);
Psf1(Ld, 1, 52);
Pf2(Sweq, 0, 0, 0, 0, 0);
Psf1(Junc, 0, -12);
Psf1(Slss, 1, 20);
Psf1(Isb, 1, 52);
Pf1(St, 0, Breg, 0);
Psf1(Lss, 1, 28);
Pf3(Jaf, 4, 0, 3);
Psf1(Lss, 0, 1);
Pf1(And, 0, 0, 0x1FF);
Pf1(Icp, 0, Breg, 0);
Pf3(Jcc, 12, 0, 13);
Psf1(Ld, 1, 28);
Pf3(Jat, 11, 0, 7);
Psf1(Lsd, 1, 20);
Pf2(Mvl, 0, 0, 0, 0, 0);
Pf1(Ldb, 0, Breg, 0);
Pf2(Mv, 1, 1, 0, 0, Unasspat & 255);
Pf1(Ld, 0, Tos, 0);
Psf1(Cyd, 0, 0);
Psf1(Exit, 0, -0x40);
Psf1(Mpsr, 0, 0x24);
Psf1(Exit, 0, -0x40);
P17:;
if (!Plink[17])
goto P18;
Fill(17);
if (!Logepdisp)
Cxref(_imp_str_literal("S#ILOG"), Parmdynamic, 2, &Logepdisp);
if (!Expepdisp)
Cxref(_imp_str_literal("S#IEXP"), Parmdynamic, 2, &Expepdisp);
Pf1(Lb, 0, Tos, 0);
Pf1(Ld, 0, Tos, 0);
Pf1(Stb, 0, Tos, 0);
Pf1(Std, 0, Tos, 0);
Pf1(Slsd, 0, Tos, 0);
Pf3(Jat, 2, 0, 0x35);
Pf3(Jaf, 0, 0, 7);
Pf1(Slsd, 0, Tos, 0);
Pf3(Jaf, 1, 0, 0x30);
Pf1(Lsd, 0, Tos, 0);
Pf1(Junc, 0, Tos, 0);
Pf1(Slsd, 0, Tos, 0);
Pf1(St, 0, Tos, 0);
Pf3(Jat, 2, 0, 26);
Psf1(Rsc, 0, 55);
Psf1(Rsc, 0, -55);
Pf1(Fix, 0, Breg, 0);
Psf1(Myb, 0, 4);
Psf1(Cpb, 0, -64);
Pf3(Jcc, 10, 0, 3);
Psf1(Lb, 0, -64);
Pf1(Ish, 0, Breg, 0);
Pf1(Stuh, 0, Breg, 0);
Pf3(Jcc, 7, 0, 14);
Psf1(Asf, 0, -2);
Pf1(St, 0, Breg, 0);
Psf1(Lss, 0, 1);
Psf1(Flt, 0, 0);
Pf3(Jaf, 12, 0, 5);
Psf1(Asf, 0, -2);
Pf1(Junc, 0, Tos, 0);
Pf1(Std, 0, Tos, 0);
Pf1(Rmy, 0, Tos, 0);
Psf1(Debj, 0, -2);
Pf1(Junc, 0, Tos, 0);
Pf1(Lsd, 0, Tos, 0);
Pf1(Slsd, 0, Tos, 0);
Psf1(Prcl, 0, 4);
Pf1(St, 0, Tos, 0);
Psf1(Lxn, 1, 16);
Psf1(Raln, 0, 7);
Pf1(Call, 2, Xnb, Logepdisp);
Pf1(Rmy, 0, Tos, 0);
Psf1(Prcl, 0, 4);
Pf1(St, 0, Tos, 0);
Psf1(Lxn, 1, 16);
Psf1(Raln, 0, 7);
Pf1(Call, 2, Xnb, Expepdisp);
Pf1(Junc, 0, Tos, 0);
Pf1(Junc, 0, 0, (Plabs[7] - Ca) / 2);
P18:;
if (!Plink[18])
goto P19;
Cnop(0, 8);
D = Ca;
Pconst(511);
Pconst(0);
Fill(18);
Pf1(St, 0, Tos, 0);
Pf1(And, 0, Pc, D);
Pf1(Stuh, 0, Breg, 0);
Pf1(Lsd, 0, Tos, 0);
Pf1(Std, 0, Tos, 0);
Psf1(Sbb, 0, 1);
Pf3(Jaf, 13, 0, 3);
Pf1(Modd, 0, Breg, 0);
Psf1(Adb, 0, 1);
Pf1(Ld, 0, Tos, 0);
Pf1(Ldb, 0, Breg, 0);
Pf1(Junc, 0, Tos, 0);
P19:;
if (!(Plink[19] | Plink[20]))
goto P21;
Cnop(0, 8);
D = Ca;
Pconst(0x180000FF);
Pconst(12);
Fill(19);
Pf1(Stln, 0, Tos, 0);
Pf1(Adb, 0, Tos, 0);
Pf1(Lxn, 0, Breg, 0);
Pf1(Slb, 2, 7, 0);
Pf1(Stb, 0, Xnb, 8);
Psf1(Inca, 0, 1);
Psf1(Cyd, 0, 0);
Pf1(Ld, 0, Pc, D);
Pf1(Inca, 0, Tos, 0);
Pf1(Std, 0, Xnb, 0);
Pf1(Ldb, 0, Breg, 0);
Pf2(Mv, 1, 0, 0, 0, 0);
Pf1(Ld, 0, Xnb, 0);
Pf1(Ldb, 0, Breg, 0);
Psf1(Inca, 0, -1);
Psf1(Cyd, 0, 0);
Pf1(Junc, 0, Tos, 0);
if (!Plink[20])
goto P21;
Fill(20);
Pf1(Stln, 0, Tos, 0);
Pf1(Adb, 0, Tos, 0);
Pf1(Lxn, 0, Breg, 0);
Pf1(Lb, 2, 7, 0);
Pf1(Stb, 0, Tos, 0);
Pf1(Adb, 0, Xnb, 8);
Psf1(Inca, 0, 1);
Psf1(Cyd, 0, 0);
Pf1(Ld, 0, Xnb, 0);
Pf1(Modd, 0, Xnb, 8);
Pf1(Ldb, 0, Tos, 0);
Pf2(Mv, 1, 0, 0, 0, 0);
Pf1(Stb, 0, Xnb, 8);
Pf1(Cpb, 0, 0, 255);
Pf3(Jcc, 2, 0, (Plabs[9] - Ca) / 2);
Pf1(Ld, 0, Xnb, 0);
Pf1(Ldb, 0, Breg, 0);
Psf1(Inca, 0, -1);
Psf1(Cyd, 0, 0);
Pf1(Junc, 0, Tos, 0);
P21:;
if (!Plink[21])
goto P22;
Fill(21);
Cxref(_imp_str_literal("S#STOP"), Parmdynamic, 2, &J);
Psf1(Prcl, 0, 4);
Psf1(Lxn, 1, 16);
Psf1(Raln, 0, 5);
Pf1(Call, 2, Xnb, J);
Pf1(0x4E, 0, 0, 0xB00B);
P22:;
if (!Plink[22])
goto P23;
Fill(22);
Cxref(_imp_str_literal("S#PPROFILE"), Parmdynamic, 2, &J);
Psf1(Prcl, 0, 4);
Psf1(Lxn, 1, 16);
Pf1(Ldrl, 0, Xnb, Parmprof);
Pf1(Std, 0, Tos, 0);
Psf1(Raln, 0, 7);
Pf1(Call, 2, Xnb, J);
Pf1(Junc, 0, Tos, 0);
P23:;
return;
void Fill(int Lab) {
int At;
int Instrn;
int I;
int J;
int A[3 /*0:2*/];
while (Plink[Lab]) {
Pop(&Plink[Lab], &A[0], &A[1], &A[2]);
for (I = 0; I <= 2; I++) {
Instrn = A[I];
if (Instrn) {
At = Instrn & 0x3FFFF;
Instrn = Instrn & 0xFFC00000;
Instrn = Instrn | (unsigned)(Ca - At) >> 1;
Plug(1, At, Instrn, 4);
}
}
}
Plabs[Lab] = Ca;
}
}
void Dumpconsts(void) {
auto void Doit(int Val);
auto void Fill(int Crefhead);
int I;
int J;
int K;
int Disp;
int Size;
int Base;
Base = 0;
Size = Constptr - Base;
if (Size <= 0)
return;
if (Ca & 7)
Cnop(0, 8);
Codeout();
// LPUT(1,SIZE*4,CA,ADDR(CTABLE_val(BASE)))
Lput(1, Size * 4, Ca, Addr(Ctable->Val[Base]));
if (Dcomp) {
Printstring(_imp_str_literal("\nCONSTANT TABLE"));
I = Base;
for (;;) {
Newline();
Prhex(Ca + 4 * (I - Base), 5);
for (J = 0; J <= 7; J++) {
Spaces(2);
// PRHEX(CTABLE_val(I+J),8)
Prhex(Ctable->Val[I+J], 8);
}
Space();
for (J = 0; J <= 31; J++) {
// K=BYTEINTEGER(ADDR(CTABLE_val(I))+J)
K = *Byteinteger(Addr(Ctable->Val[I]) + J);
if (K < 31 || K > 95)
K = 32;
Printsymbol(K);
}
I += 8;
if (I >= Constptr)
break;
}
}
Fill(Crefhead);
Size = (Size + 1) & (-2);
Ca += 4 * Size;
Cabuf = Ca;
return;
void Fill(int Crefhead) {
Disp = (Ca - 4 * Base) / 2;
while (Crefhead) {
Pop(&Crefhead, &I, &J, &K);
Doit(I);
if (J)
Doit(J);
if (K)
Doit(K);
}
}
void Doit(int Val) {
int I;
int J;
if (Val > 0)
Lput(18, 0, Val, Disp);
else {
I = ((unsigned)Val >> 16 & 0x7FFF) << 2;
J = 4 * (Val & 0xFFFF) + Ca;
Plug(2, I, J, 4);
}
}
}
}
_imp_string Message(int N) {
static const unsigned char Outtt[64 /*0:63*/] = {
'?', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q',
'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
'&', '-', '/', '\'', '(', ')', 'a', 'b', 'c',
'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u',
'v', 'w', 'x', 'y', 'z', '.', '%', '#', [62 ... 63] = '?'};
static const int Wordmax = 584;
static const int Default = 580;
static int Word[585 /*0:584*/] = {
0, 1, 32769, 32771, 32772, 32773, 2, 32775, 32776, 32777,
32778, 32780, 32781, 32782, 32783, 32784, 4, 32785, 32776, 32777,
32772, 32780, 32787, 5, 32785, 32789, 32776, 32782, 32790, 32792,
32793, 6, 32785, 32795, 32796, 32781, 32797, 32798, 32800, 7,
32801, 32776, 32777, 32778, 32780, 32787, 8, 32802, 32792, 32804,
32776, 32777, 32805, 32806, 32808, 32809, 9, 32811, 32813, 32814,
32776, 32815, 32782, 32817, 32818, 32819, 10, 32802, 32792, 32804,
32776, 32777, 32822, 32806, 32808, 32809, 11, 32775, 32776, 32823,
32825, 32826, 32813, 32777, 32772, 32780, 32781, 12, 32827, 32825,
32826, 32813, 32777, 32829, 32830, 32832, 13, 32769, 32834, 32827,
32825, 32826, 32813, 32771, 32835, 14, 32837, 32838, 32839, 15,
32840, 32839, 16, 32801, 32776, 32777, 32772, 32780, 32787, 17,
32801, 32776, 32842, 32772, 32843, 32806, 32792, 32845, 19, 32847,
32848, 32849, 32850, 20, 32813, 32852, 32853, 32845, 32854, 32834,
32856, 32776, 21, 32813, 32852, 32857, 32845, 32854, 32834, 32856,
32776, 22, 32858, 32850, 32860, 32861, 32862, 23, 32863, 32865,
32866, 32867, 24, 32869, 32866, 32870, 32867, 26, 32813, 32771,
32772, 32797, 32872, 32873, 32875, 27, 32776, 32771, 32772, 32797,
32877, 32789, 28, 32802, 32792, 32804, 32776, 32777, 32819, 32879,
32880, 32881, 29, 32882, 32860, 32883, 30, 32885, 32887, 32877,
32881, 31, 32889, 32887, 32804, 32792, 32891, 32881, 32, 32892,
32894, 33, 32892, 32865, 32866, 32894, 34, 32837, 32838, 32896,
37, 32837, 32838, 32898, 38, 32900, 32776, 32777, 32901, 32902,
32813, 32903, 32808, 32904, 32902, 40, 32905, 32906, 41, 32908,
32910, 32912, 32913, 32825, 32915, 32800, 44, 32917, 32919, 45,
32847, 32848, 32849, 32919, 46, 32776, 32771, 32787, 32920, 32921,
32817, 32923, 32925, 47, 32926, 32778, 32927, 32825, 32826, 32813,
48, 32926, 32921, 32928, 32929, 32873, 49, 32930, 32932, 32933,
32923, 32792, 32935, 32776, 50, 32937, 32814, 32813, 32771, 32887,
32939, 32940, 32814, 32776, 51, 32942, 32771, 32772, 32773, 52,
32769, 32944, 32814, 32942, 32834, 32946, 32825, 32826, 32813, 53,
32942, 32834, 32946, 32825, 32826, 32813, 32771, 32835, 54, 32948,
32887, 32827, 32769, 32881, 55, 32949, 32887, 32827, 32769, 32881,
56, 32951, 32953, 32849, 32954, 57, 32956, 32840, 58, 32957,
32959, 32906, 59, 32942, 32944, 32814, 32769, 32834, 32827, 32825,
32826, 32813, 61, 32801, 32776, 32777, 32778, 32780, 32960, 32782,
32783, 32935, 62, 32860, 32961, 32865, 63, 32963, 32862, 32965,
64, 32966, 32840, 65, 32966, 32860, 32866, 32961, 66, 32968,
32970, 32932, 32972, 32776, 67, 32974, 32976, 32977, 32776, 32978,
32979, 32981, 69, 32966, 32953, 32849, 32954, 70, 32917, 32983,
32905, 71, 32776, 32771, 32772, 32797, 32985, 32987, 72, 32989,
32991, 32782, 32797, 32985, 32790, 73, 32989, 32993, 32782, 32797,
32985, 32790, 74, 32995, 32771, 32772, 32939, 32997, 32999, 75,
32985, 32790, 33001, 32797, 33003, 32790, 76, 32985, 33004, 32776,
32782, 33006, 32790, 77, 32985, 32993, 32782, 33006, 32790, 78,
32985, 32991, 33008, 32782, 33006, 32790, 80, 33009, 33004, 32776,
33011, 33013, 32790, 81, 33009, 33004, 32776, 33014, 32932, 32790,
82, 32776, 32771, 32772, 32797, 33017, 32789, 83, 32976, 32977,
32776, 33019, 32772, 33020, 32782, 32817, 84, 32963, 32953, 32849,
32954, 86, 33022, 33017, 32976, 33014, 32932, 33024, 32776, 91,
33025, 32830, 33004, 32776, 32772, 33026, 92, 33025, 33028, 32777,
33030, 33031, 93, 33025, 33028, 32777, 33032, 32875, 32814, 33034,
90, 33036, 32789, 32776, 32960, 32920, 33004, 8, 33038, 101,
33041, 33043, 32837, 33044, 102, 33045, 32837, 33047, 103, 33048,
32837, 33044, 104, 32837, 32838, 33048, 105, 32837, 32838, 32896,
106, 32983, 32919, 32837, 33044, 107, 33049, 33051, 33053, 202,
32801, 32776, 32772, 32960, 203, 32775, 32776, 32772, 32960, 204,
33022, 33025, 32830, 33004, 32776, 205, 32801, 32776, 32772, 33054,
255, 33057, 33058, 33059, 0};
static const int Lett[293 /*0:292*/] = {
0, 0x7890A80B, 0x02A00000, 0x53980000, 0x5D7E8000,
0x652E3AD3, 0x652C8000, 0x190C52D8, 0x36000000, 0x510E6000,
0x436652C3, 0x49C80000, 0x452CB700, 0x672E8000, 0x53700000,
0x69453980, 0x4565F1D6, 0x27BD3A47, 0x50000000, 0x492C7643,
0x652C8000, 0x5D0DB280, 0x4BC6194B, 0x679D37DC, 0x5F900000,
0x439E74CF, 0x5D6CB768, 0x590C52D8, 0x36FFB000, 0x42000000,
0x672C77DD, 0x48000000, 0x694DB280, 0x1D0DB280, 0x257EBA53,
0x5D280000, 0x4D700000, 0x5B7E5280, 0x610E50DB, 0x4BA4B966,
0x69443700, 0x6784B1D3, 0x4D4CB200, 0x210E50DB, 0x4BA4B900,
0x7A000000, 0x5F300000, 0x494CD34B, 0x65980000, 0x69CE1280,
0x4D95F680, 0x6784B1D3, 0x4D4C70E9, 0x537DC000, 0x4D2EF2E4,
0x652CD2E5, 0x4B7472C8, 0x43A00000, 0x594DD280, 0x781B2199,
0x0A000000, 0x69BDE000, 0x477DDA65, 0x5F600000, 0x47643AE7,
0x4B980000, 0x4D7E4000, 0x5B4E79D3, 0x5D380000, 0x2879E000,
0x1A09CC80, 0x0A708980, 0x1A4A6993, 0x1C380000, 0x497CB980,
0x652E3AD3, 0x65280000, 0x67AC59C7, 0x654E1A66, 0x2E91E70E,
0x1C780000, 0x1E300000, 0x200A409B, 0x0AA0A926, 0x697DE000,
0x4D2EE000, 0x6195FB53, 0x492C8000, 0x439650F2, 0x5B0DDC80,
0x021A8A83, 0x18000000, 0x1C7A8000, 0x02980000, 0x2680A180,
0x247AAA13, 0x1C280000, 0x1C09A280, 0x12700000, 0x0AC20927,
0x26700000, 0x24282600, 0x1272828F, 0x0A900000, 0x6D0D94C8,
0x782AC29D, 0x28000000, 0x5DADB14B, 0x64000000, 0x657EBA53,
0x5D280000, 0x45AE8000, 0x5D780000, 0x457C9C80, 0x18426000,
0x082A6A1D, 0x28700000, 0x7890AA2B, 0x24700000, 0x5FAE9BD3,
0x69400000, 0x7890A9AB, 0x18A00000, 0x5B0E0000, 0x1272C099,
0x12200000, 0x029A629B, 0x0460A900, 0x182AC299, 0x26000000,
0x0849A29D, 0x2649E726, 0x039650F2, 0x6B8612E4, 0x457EB748,
0x592E7980, 0x597EF2E4, 0x0828661C, 0x1A4A6819, 0x0218A200,
0x077DD9E9, 0x43768000, 0x470DD75F, 0x68000000, 0x45280000,
0x4BB4366B, 0x43A4B200, 0x477DB853, 0x59280000, 0x1261828F,
0x02600000, 0x0679C9A8, 0x43980000, 0x5376D0D9, 0x53200000,
0x782B0A25, 0x12726486, 0x7870268A, 0x7829898A, 0x4F4ED2DC,
0x433692E4, 0x7879C000, 0x03A692DB, 0x61A00000, 0x69780000,
0x53753A53, 0x436539CA, 0x7831E91B, 0x02A00000, 0x27AC59C7,
0x654E1A00, 0x6944A000, 0x457EB749, 0x66000000, 0x78312713,
0x26400000, 0x53767A4B, 0x43200000, 0x789A80A5, 0x28000000,
0x782B04A8, 0x7819E729, 0x1272A280, 0x0A70878D, 0x0C498280,
0x1EAA8000, 0x0679CA0B, 0x30A00000, 0x0428E49C, 0x0679CA25,
0x1E600000, 0x26A1A728, 0x6B9CB200, 0x0C7A4683, 0x28000000,
0x242867A5, 0x08000000, 0x0A9247A4, 0x26A84703, 0x1A280000,
0x0BC6194B, 0x679D37DC, 0x439E74CF, 0x5D2C8000, 0x652C77E5,
0x48000000, 0x252C77E5, 0x49980000, 0x36D80000, 0x43748000,
0x510ED280, 0x494CD34B, 0x652DDA00, 0x4D7E56C3, 0x69980000,
0x26A2449D, 0x0E000000, 0x27A654DD, 0x4E000000, 0x6D0E50D3,
0x4564A000, 0x03953A51, 0x5B2E94C6, 0x5F84B943, 0x697E4000,
0x477DD9E9, 0x43768000, 0x252E77D9, 0x6BA537DC, 0x477E594B,
0x47A00000, 0x4D7E56C3, 0x68000000, 0x477DDA43, 0x53766000,
0x67AC4000, 0x6D0E54C3, 0x4564A000, 0x43953A51, 0x5B2E94C6,
0x3DDBC000, 0x217D3769, 0x4B900000, 0x477DB843, 0x652C8000,
0x6F4E9400, 0x4B8EB4ED, 0x4364B747, 0x4B200000, 0x617D3769,
0x4B900000, 0x4394A000, 0x4B8EB4ED, 0x4364B768, 0x0F65F143,
0x58000000, 0x597C70D8, 0x7831E900, 0x537692CF, 0x4B900000,
0x47643AE7, 0x4A000000, 0x752E5780, 0x67A4B800, 0x5D7DD4DD,
0x692CF2E4, 0x69943B4B, 0x659CB980, 0x2B769CE1, 0x4B200000,
0x0220890B, 0x26982113, 0x184A8C80, 0x267AA907, 0x0A000000,
0x1849C280, 0x1879C380, 0x2E7A458D, 0x1260A000, 0x26682618,
0x1C09A2A6, 0x0679A813, 0x182A4000, 0x2808460B, 0x26000000,
0x0CA98600, 0x4324994B, 0x679C3159, 0x4A000000, 0x2628A000,
0x126A0000, 0x1A09CA83, 0x18000000};
int I;
int J;
int K;
int M;
int Q;
int S;
_imp_string Omess;
Omess = _imp_str_literal(" ");
for (I = 1; I <= Wordmax - 1; I++)
if (N == Word[I])
goto Found;
I = Default;
Found:;
J = 1;
for (;;) {
K = Word[I + J];
if (!(K & 0x8000))
break;
K = K ^ 0x8000;
if (J != 1)
Omess = _imp_join(Omess, _imp_str_literal(" "));
do {
M = Lett[K];
S = 25;
do {
Q = (unsigned)M >> S & 63;
if (Q)
Omess = _imp_join(Omess, Tostring(Outtt[Q]));
S -= 6;
} while (S >= 0);
K++;
} while (M & 1);
J++;
}
return (Omess);
}
_imp_string Swrite(int Value, int Places) { return (Itos(Value, Places)); }
void Fault2(int N, int Data, int Ident) {
int I;
int J;
int T;
_imp_string Mess1;
_imp_string Mess2;
_imp_string Wk1;
_imp_string Wk2;
if (Faulty <= 1 && (Smap != 0 || Dcomp != 0))
_imp_monitor(0);
Mess1 = _imp_str_literal("");
Mess2 = _imp_str_literal("");
Faulty++;
if (N == 100) {
Mess1 =
_imp_join(_imp_str_literal("\n* Failed to analyse line "),
_imp_join(Swrite(Line, 2), _imp_str_literal("\n ")));
if (Line != Oldline)
Mess1 = _imp_join(
Mess1,
_imp_str_literal(
"Text mode failure - erroneos source line not available\n"));
else {
J = 0;
S = 0;
T = 0;
do {
I = J;
J = *Byteinteger(Data + Q);
if (J > 128 && I < 128) {
Mess2 = _imp_join(Mess2, _imp_str_literal(" %"));
T += 2;
}
if (I > 128 && J < 128) {
Mess2 = _imp_join(Mess2, _imp_str_literal(" "));
T++;
}
Mess2 = _imp_join(Mess2, Tostring(J));
T++;
if (Q == Qmax)
S = T;
Q++;
if (T >= 250)
break;
} while ((J != ';' || Q <= Qmax) && Q != Length);
if (Q == Qmax)
S = T;
}
} else {
Mess1 = _imp_join(_imp_str_literal("\n*"),
_imp_join(Swrite(Line, 4), _imp_str_literal(" ")));
Parmopt = 1;
if (!Parmlet)
Inhcode = 1;
Mess1 = _imp_join(Mess1,
_imp_join(_imp_str_literal("FAULT"), Swrite(N, 2)));
Mess2 = Message(N);
if (_imp_resolve(Mess2, &Wk1, _imp_str_literal("##"), &Wk2))
Mess2 = _imp_join(Wk1, _imp_join(Swrite(Ident, 1), Wk2));
if (_imp_resolve(Mess2, &Wk1, _imp_str_literal("#"), &Wk2))
Mess2 = _imp_join(Wk1, _imp_join(Swrite(Data, 1), Wk2));
if (_imp_resolve(Mess2, &Wk1, _imp_str_literal("&&"), &Wk2))
Mess2 = _imp_join(Wk1, _imp_join(Printname(Data), Wk2));
if (_imp_resolve(Mess2, &Wk1, _imp_str_literal("&"), &Wk2))
Mess2 = _imp_join(Wk1, _imp_join(Printname(Ident), Wk2));
if (N > 100)
Mess2 = _imp_join(Mess2, _imp_str_literal(" Disaster"));
}
for (I = 2; I >= 1; I--) {
if (I == 1)
Selectoutput(Ttoput);
Printstring(Mess1);
if (_imp_strcmp(Mess2, _imp_str_literal("")) != 0)
Printstring(Mess2);
if (N == 100 && S < 115) {
Newline();
Spaces(S + 4);
Printsymbol('!');
}
Newline();
if (I == 1)
Selectoutput(82);
if (Ttoput <= 0)
break;
}
if (N > 100) {
_imp_monitor(0);
exit(0);
}
}
void Fault(int N, int Fname) { Fault2(N, Fname, Fname); }
void Warn(int N, int V) {
_imp_string T;
_imp_string S;
S = Message(N + 200);
if (_imp_resolve(S, &S, _imp_str_literal("&"), &T))
S = _imp_join(S, _imp_join(Printname(V), T));
Printstring(
_imp_join(_imp_str_literal("\n? Warning :- "),
_imp_join(S, _imp_join(_imp_str_literal(" at line No"),
Swrite(Line, 1)))));
Newline();
}
void Toar2(int Ptr, int Value) {
A[Ptr + 1] = Value;
A[Ptr] = (unsigned)Value >> 8;
}
void Toar4(int Ptr, int Value) {
int I;
for (I = 0; I <= 3; I++)
A[Ptr + I] = *Byteinteger(Addr(Value) + I);
}
void Toar8(int Ptr, double Value) {
int I;
for (I = 0; I <= 7; I++)
A[Ptr + I] = *Byteinteger(Addr(Value) + I);
}
int Fromar2(int Ptr) { return (A[Ptr] << 8 | A[Ptr + 1]); }
int Fromar4(int Ptr) {
return (A[Ptr] << 24 | A[Ptr + 1] << 16 | A[Ptr + 2] << 8 | A[Ptr + 3]);
}
_imp_string Printname(int N) {
int V;
int K;
_imp_string S;
V = Word[N];
K = *Byteinteger(Dictbase + V);
if (!K)
S = _imp_str_literal("???");
else
S = *String(Dictbase + V);
return (S);
}
void Prhex(int Value, int Places) {
static const unsigned char Hex[16 /*0:15*/] = {
'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
int I;
for (I = (Places << 2) - 4; I >= 0; I -= 4)
Printsymbol(Hex[(unsigned)Value >> I & 15]);
}
void Printlist(int Head) {
int I;
int J;
int K;
Printstring(_imp_str_literal("\nPRINT OF LIST "));
Write(Head, 2);
Newline();
while (Head) {
From123(Head, &I, &J, &K);
Write(Head, 3);
Spaces(3);
Prhex(I, 8);
Spaces(3);
Prhex(J, 8);
Spaces(3);
Prhex(K, 8);
Newline();
Mlink(&Head);
Head = Head & 0xFFFF;
}
}
void Checkasl(void) {
int N;
int Q;
Q = Asl;
N = 0;
while (Q) {
N++;
Q = Aslist[Q].Link;
}
Newline();
Printstring(_imp_str_literal("FREE CELLS AFTER LINE "));
Write(Line, 3);
Printsymbol('=');
Write(N, 3);
}
int Morespace(void) {
int I;
int N;
int Cl;
int Amount;
N = Aslcurbtm - 1;
Amount = (unsigned)(Nnames + 1) >> 3;
I = Aslcurbtm - ((unsigned)(Constptr + 8) >> 2);
if ((unsigned)I >> 1 < Amount) {
Amount = (unsigned)I >> 1;
Aslwarn = 1;
}
if (Amount < 20)
Amount = 0;
Aslcurbtm -= Amount;
if (Aslcurbtm <= 1)
Aslcurbtm = 1;
Cl = 4 * Aslcurbtm - 8;
if (Aslcurbtm >= N || Constptr > Cl) {
Aslcurbtm = N + 1;
for (I = 12; I >= 1; I--)
if (Dvheads[I])
Clearlist(&Dvheads[I]);
if (Asl)
return (Asl);
Fault(107, 0);
} else
Constlimit = Cl;
for (I = Aslcurbtm; I <= N - 1; I++)
Aslist[I + 1].Link = I;
Aslist[Aslcurbtm].Link = 0;
Asl = N;
return (N);
}
void Push(int *Cell, int S1, int S2, int S3) {
Listf *Lcell;
int I;
I = Asl;
if (!I)
I = Morespace();
Lcell = &Aslist[I];
Asl = Lcell->Link;
Lcell->Link = *Cell;
*Cell = I;
Lcell->S1 = S1;
Lcell->S2 = S2;
Lcell->S3 = S3;
}
void Pop(int *Cell, int *S1, int *S2, int *S3) {
Listf *Lcell;
int I;
I = *Cell;
Lcell = &Aslist[I];
*S1 = Lcell->S1;
*S2 = Lcell->S2;
*S3 = Lcell->S3;
if (I) {
*Cell = Lcell->Link;
Lcell->Link = Asl;
Asl = I;
}
}
void Replace1(int Cell, int S1) { Aslist[Cell].S1 = S1; }
void Replace2(int Cell, int S2) { Aslist[Cell].S2 = S2; }
void Replace3(int Cell, int S3) { Aslist[Cell].S3 = S3; }
void Binsert(int *Top, int *Bot, int S1, int S2, int S3) {
int I;
int J;
Listf *Lcell;
I = Asl;
if (!I)
I = Morespace();
Lcell = &Aslist[I];
Asl = Lcell->Link;
Lcell->S1 = S1;
Lcell->S2 = S2;
Lcell->S3 = S3;
Lcell->Link = 0;
J = *Bot;
if (!J) {
*Bot = I;
*Top = *Bot;
} else {
Aslist[J].Link = I;
*Bot = I;
}
}
void Insertatend(int *Cell, int S1, int S2, int S3) {
int I;
int J;
int N;
Listf *Lcell;
I = *Cell;
J = I;
while (I) {
J = I;
I = Aslist[J].Link;
}
N = Asl;
if (!N)
N = Morespace();
Lcell = &Aslist[N];
Asl = Lcell->Link;
if (!J)
*Cell = N;
else
Aslist[J].Link = N;
Lcell->S1 = S1;
Lcell->S2 = S2;
Lcell->S3 = S3;
Lcell->Link = 0;
}
void Replace123(int Cell, int S1, int S2, int S3) {
Aslist[Cell].S1 = S1;
Aslist[Cell].S2 = S2;
Aslist[Cell].S3 = S3;
}
void Mlink(int *Cell) { *Cell = Aslist[*Cell].Link; }
int Find(int Lab, int List) {
while (List) {
if (Lab == Aslist[List].S2)
return (List);
List = Aslist[List].Link;
}
return (-1);
}
void From123(int Cell, int *S1, int *S2, int *S3) {
Listf *Lcell;
Lcell = &Aslist[Cell];
*S1 = Lcell->S1;
*S2 = Lcell->S2;
*S3 = Lcell->S3;
}
void From12(int Cell, int *S1, int *S2) {
Listf *Lcell;
Lcell = &Aslist[Cell];
*S1 = Lcell->S1;
*S2 = Lcell->S2;
}
int From1(int Cell) { return (Aslist[Cell].S1); }
int From2(int Cell) { return (Aslist[Cell].S2); }
int From3(int Cell) { return (Aslist[Cell].S3); }
void Clearlist(int *Ophead) {
int I;
int J;
I = *Ophead;
J = I;
while (I) {
J = I;
I = Aslist[J].Link;
}
if (J) {
Aslist[J].Link = Asl;
Asl = *Ophead;
*Ophead = 0;
}
}
}
exit(0);
return (1);
}