// cc -o allimpc1 -g -Wno-multichar allimpc1.c -I ../new-parser/imps ../new-parser/imps/perms.c -lm
#include <perms.h>
#undef Unass
#undef Printsymbol
#define Printsymbol(C) printf("%c", (C)&128 ? (((C)&127)-'A'+'a') : (C))
void Recode(int Start, int Finish, int Ca) {
}
int Com(int N) {
if (N == 2) {
// address of free stack?
}
if (N == 24) {
//List = 2;
//Linenos = 4;
//Unass = 16;
//Checks = 32;
//Printmap = 0x8000;
//Diags1 = 64;
return 0x8000 | 2 | 4 | 16;// | 32; | 64;
}
return 0;
}
void Setcom(int I, int J) {
}
void Lput(int A, int B, int C, int D) {
if (Com(24)&64) fprintf(stderr, "LPUT(%d,%d,%d,%08x);\n", A,B,C,D);
}
//%SYSTEMINTEGERFNSPEC COM(%INTEGER N)
//%SYSTEMROUTINESPEC SET COM(%INTEGER I,J)
//%SYSTEMROUTINESPEC IOCP(%INTEGER A,B)
//%SYSTEMROUTINESPEC LPUT(%INTEGER A,B,C,D)
int _imp_mainep(int _imp_argc, char **_imp_argv) {
int I;
int J;
int K;
int Ss;
static unsigned char Clett[1+425 /*1:425*/] = {0,
1, 43, 1, 45, 1, 92, 1, 40, 1, 41, 1, 33, 1, 44, 2,
42, 42, 2, 33, 33, 1, 42, 2, 47, 47, 1, 47, 1, 38, 2,
62, 62, 2, 60, 60, 1, 46, 1, 63, 2, 201, 198, 6, 213, 206,
204, 197, 211, 211, 7, 201, 206, 212, 197, 199, 197, 210, 4, 210, 197,
193, 204, 4, 194, 217, 212, 197, 5, 211, 200, 207, 210, 212, 4, 204,
207, 206, 199, 6, 211, 212, 210, 201, 206, 199, 7, 210, 207, 213, 212,
201, 206, 197, 2, 198, 206, 3, 205, 193, 208, 4, 206, 193, 205, 197,
6, 210, 197, 195, 207, 210, 196, 4, 211, 212, 207, 208, 7, 195, 207,
205, 208, 201, 204, 197, 6, 201, 199, 206, 207, 210, 197, 2, 207, 206,
3, 207, 198, 198, 5, 193, 210, 210, 193, 217, 3, 193, 206, 196, 2,
207, 210, 2, 61, 61, 1, 61, 2, 60, 45, 2, 45, 62, 4, 211,
208, 197, 195, 6, 206, 207, 210, 205, 193, 204, 6, 214, 197, 195, 212,
207, 210, 1, 58, 2, 62, 61, 1, 62, 1, 35, 2, 60, 61, 1,
60, 2, 92, 61, 4, 197, 204, 211, 197, 1, 95, 6, 211, 217, 211,
212, 197, 205, 8, 197, 216, 212, 197, 210, 206, 193, 204, 5, 195, 204,
193, 201, 205, 7, 210, 197, 204, 197, 193, 211, 197, 1, 80, 3, 80,
85, 84, 1, 64, 9, 208, 210, 201, 206, 212, 212, 197, 216, 212, 6,
210, 197, 212, 213, 210, 206, 7, 210, 197, 211, 213, 204, 212, 61, 7,
205, 207, 206, 201, 212, 207, 210, 5, 211, 212, 193, 210, 212, 7, 209,
213, 197, 210, 201, 197, 211, 5, 195, 217, 195, 204, 197, 6, 210, 197,
208, 197, 193, 212, 4, 212, 200, 197, 206, 3, 197, 206, 196, 7, 195,
207, 205, 205, 197, 206, 212, 5, 210, 197, 193, 204, 211, 5, 194, 197,
199, 201, 206, 2, 207, 198, 7, 208, 210, 207, 199, 210, 193, 205, 6,
211, 215, 201, 212, 195, 200, 8, 210, 197, 199, 201, 211, 212, 197, 210,
3, 207, 215, 206, 5, 205, 195, 207, 196, 197, 5, 198, 193, 213, 204,
212, 4, 198, 201, 204, 197, 6, 196, 197, 198, 201, 206, 197, 1, 210,
7, 211, 208, 197, 195, 201, 193, 204, 4, 204, 201, 211, 212, 7, 195,
207, 206, 212, 210, 207, 204, 6, 198, 201, 206, 201, 211, 200, 6, 198,
207, 210, 205, 193, 212};
static short Symbol[1300+849 /*1300:2148*/] = {[ 0 ... 1299 ] = 0,
1309, 1303, 1, 1305, 3, 1307, 5, 1309, 1000, 1316, 1312, 1,
1314, 3, 1316, 1000, 1335, 1321, 1001, 1342, 1706, 1323, 1003, 1329,
7, 1300, 1316, 1335, 9, 1335, 11, 1300, 1316, 1335, 11, 1342,
1340, 1361, 1316, 1335, 1342, 1000, 1352, 1350, 7, 1300, 1316, 1335,
1352, 9, 1352, 1000, 1361, 1359, 13, 1300, 1316, 1335, 1352, 1361,
1000, 1388, 1364, 15, 1366, 1, 1368, 3, 1370, 18, 1372, 11,
1374, 21, 1376, 23, 1378, 26, 1380, 28, 1382, 30, 1384, 33,
1386, 36, 1388, 1000, 1393, 1391, 38, 1393, 1000, 1398, 1396, 13,
1398, 1000, 1403, 1401, 40, 1403, 43, 1420, 1406, 50, 1408, 58,
1411, 63, 50, 1414, 68, 50, 1417, 74, 58, 1420, 79, 1883,
1426, 1423, 86, 1426, 1403, 1426, 1431, 1429, 94, 1431, 97, 1445,
1435, 1420, 1467, 1438, 1403, 1472, 1441, 1462, 101, 1445, 106, 1462,
101, 1450, 1448, 1005, 1450, 1001, 1457, 1453, 113, 1455, 118, 1457,
126, 1462, 1460, 133, 1462, 136, 1467, 1465, 140, 1467, 1000, 1472,
1470, 101, 1472, 1000, 1484, 1477, 101, 140, 101, 1480, 140, 101,
1482, 101, 1484, 1000, 1493, 1491, 7, 1431, 1009, 1493, 9, 1493,
1000, 1501, 1499, 1393, 1431, 1009, 1493, 1501, 1000, 1520, 1513, 1010,
1300, 1316, 1335, 1669, 1300, 1316, 1335, 1520, 1011, 1520, 7, 1010,
1501, 1528, 1011, 9, 1528, 1526, 1669, 1300, 1316, 1335, 1528, 1000,
1539, 1533, 146, 1501, 1539, 1537, 150, 1501, 1546, 1539, 1000, 1546,
1544, 146, 1501, 1539, 1546, 1000, 1553, 1551, 150, 1501, 1546, 1553,
1000, 1562, 1560, 1562, 1300, 1316, 1335, 1388, 1562, 1000, 1571, 1565,
153, 1567, 156, 1569, 158, 1571, 161, 1576, 1574, 164, 1576, 1000,
1581, 1579, 74, 1581, 169, 1588, 1586, 13, 1714, 1581, 1588, 1000,
1599, 1592, 1472, 1009, 1596, 1467, 140, 1599, 1599, 176, 1613, 1607,
1607, 1009, 7, 1714, 1581, 9, 1607, 1613, 1611, 13, 1599, 1613,
1000, 1618, 1618, 1009, 1635, 1618, 1624, 1622, 13, 1613, 1624, 1000,
1635, 1629, 1001, 1723, 1006, 1635, 140, 1001, 1635, 1890, 1004, 1644,
1644, 7, 1309, 1003, 183, 1309, 1003, 9, 1651, 1649, 13, 1005,
1644, 1651, 1000, 1661, 1659, 13, 1005, 1644, 161, 1445, 1651, 1661,
1000, 1669, 1667, 13, 1009, 1635, 1661, 1669, 1000, 1686, 1672, 156,
1674, 185, 1676, 188, 1678, 190, 1680, 192, 1682, 195, 1684, 197,
1686, 161, 1694, 1689, 1006, 1694, 1398, 1501, 1528, 1006, 1700, 1698,
200, 1902, 1700, 1000, 1706, 1704, 205, 1001, 1706, 1000, 1714, 1712,
205, 1001, 1342, 1706, 1714, 1000, 1723, 1723, 1300, 1316, 1335, 183,
1300, 1316, 1335, 1730, 1728, 156, 1300, 1003, 1730, 1000, 1737, 1733,
207, 1735, 214, 1737, 1000, 1742, 1740, 223, 1742, 229, 1747, 1745,
140, 1747, 106, 1757, 1755, 1393, 1403, 1467, 140, 1599, 1747, 1757,
1000, 1764, 1762, 1431, 1009, 1493, 1764, 1000, 1772, 1768, 1001, 1857,
1772, 195, 1445, 188, 1785, 1780, 1005, 7, 1005, 13, 1005, 9,
1785, 1764, 7, 1005, 9, 1792, 1789, 1764, 1883, 1792, 1005, 1792,
1805, 1799, 7, 1005, 13, 1005, 9, 1803, 7, 1005, 9, 1805,
1000, 1811, 1809, 13, 1003, 1811, 1000, 1817, 1814, 1764, 1817, 1005,
1883, 1857, 1823, 1012, 1005, 13, 1005, 1828, 1013, 1005, 13, 1785,
1835, 1014, 1005, 13, 1005, 13, 1811, 1839, 1015, 1811, 1805, 1844,
1016, 1005, 13, 1811, 1849, 1017, 1772, 13, 1811, 1854, 1018, 1772,
13, 1772, 1857, 1019, 1005, 1863, 1861, 1, 1005, 1863, 1000, 1883,
1872, 21, 1005, 13, 1895, 1001, 1342, 1706, 1876, 161, 237, 1005,
1879, 1002, 1817, 1883, 239, 205, 1003, 1890, 1888, 7, 1005, 9,
1890, 1000, 1895, 1893, 156, 1895, 1000, 1902, 1898, 243, 1900, 156,
1902, 1000, 1943, 1910, 1010, 1001, 1342, 1706, 1011, 1553, 1918, 161,
1001, 7, 1300, 1316, 1335, 9, 1921, 161, 1445, 1924, 245, 1008,
1926, 255, 1931, 262, 1300, 1316, 1335, 1933, 113, 1936, 270, 113,
1938, 278, 1940, 270, 1943, 284, 1457, 2149, 1949, 1010, 1902, 1011,
1686, 1967, 292, 1001, 1342, 1706, 156, 1300, 1316, 1335, 13, 1300,
1316, 1335, 13, 1300, 1316, 1335, 1006, 1970, 298, 1006, 1973, 1445,
183, 1985, 1398, 1010, 1501, 1528, 305, 1011, 1010, 1902, 1011, 1694,
1006, 1988, 11, 1007, 1992, 1403, 1588, 1006, 1995, 310, 1006, 2004,
1010, 1730, 1420, 1011, 1571, 1001, 1484, 1006, 2007, 314, 1007, 2011,
322, 1576, 1006, 2014, 328, 1006, 2019, 310, 334, 337, 1006, 2026,
1001, 7, 1309, 1003, 9, 183, 2032, 345, 1009, 1635, 1661, 1006,
2036, 1450, 284, 1006, 2040, 352, 1001, 1006, 2044, 361, 1403, 1624,
2050, 1737, 1742, 352, 1001, 1006, 2053, 365, 1006, 2057, 68, 86,
1006, 2061, 21, 1863, 1006, 2069, 371, 1005, 1644, 161, 1445, 1651,
1006, 2074, 310, 334, 377, 1006, 2079, 310, 334, 365, 1006, 2084,
382, 118, 389, 1006, 2090, 164, 1001, 1706, 1484, 1006, 2095, 391,
101, 1001, 1006, 2098, 399, 1006, 2103, 310, 334, 399, 1006, 2107,
404, 1003, 1006, 2111, 412, 1694, 1006, 2120, 106, 419, 1001, 7,
1757, 1747, 9, 1006, 2129, 106, 1010, 1588, 1011, 7, 1001, 9,
1006, 2136, 1010, 1420, 101, 1011, 1009, 1006, 2147, 106, 164, 1010,
1001, 1700, 1011, 7, 1001, 9, 1006, 2149, 1006};
Ss = 1943;
static unsigned char Opc[121 /*0:120*/] = {
0, 8, 9, 0x10, 0x11, 0x12, 0x13, 0x20, 0x21, 0x22, 0x23,
0x30, 0x31, 0x32, 0x33, 0x24, 0x34, 0, 0x45, 0x46, 0x47, 0x54,
0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F,
0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x78, 0x79, 0x7A,
0x7B, 0x7C, 0x7D, 0x7E, 0x7F, 0, 0x70, 0x60, 0x50, 0x4E, 0x4F,
0x4C, 0x4B, 0x4A, 0x49, 0x48, 0x44, 0x43, 0x42, 0x41, 0x40, 0,
0x90, 0x98, 0x86, 0x87, 0, 0x91, 0x92, 0x94, 0x95, 0x96, 0x97,
0x9C, 0x9E, 0x9D, 0x9F, 0x82, 0x84, 0x85, 0, 0x88, 0x89, 0x8A,
0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0, 0xD0, 0xD1, 0xD2, 0xD4, 0xD5,
0xD6, 0xD7, 0xD8, 0xDC, 0xDd, 0xDE, 0xDF, 0xD3, 0, 0xF1, 0xF2,
0xF3, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0, 10, 4, 0x80};
static int Nem[121 /*0:120*/] = {
'CNOP', 'ISK', 'SSK', 'LP', 'LN', 'LT', 'LC', 'LPD', 'LND', 'LTD',
'LCD', 'LPE', 'LNE', 'LTE', 'LCE', 'HD', 'HE', 0, 'BAL', 'BCT',
'BC', 'N', 'CL', 'O', 'X', 'L', 'C', 'A', 'S', 'M',
'D', 'AL', 'SL', 'LD', 'CD', 'AD', 'SD', 'MD', 'DD', 'AW',
'SW', 'LE', 'CE', 'AE', 'SE', 'ME', 'DE', 'AU', 'SU', 0,
'STE', 'STD', 'ST', 'CVD', 'CVB', 'MH', 'SH', 'AH', 'CH', 'LH',
'EX', 'IC', 'STC', 'LA', 'STH', 0, 'STM', 'LM', 'BXH', 'BXLE',
0, 'TM', 'MVI', 'NI', 'CLI', 'OI', 'XI', 'SDV', 'HDV', 'TDV',
'CKC', 'PC', 'WRD', 'RDD', 0, 'SRL', 'SLL', 'SRA', 'SLA', 'SRDL',
'SLDL', 'SRDA', 'SLDA', 0, 'SSP', 'MVN', 'MVC', 'NC', 'CLC', 'OC',
'XC', 'LSP', 'TR', 'TRT', 'ED', 'EDMK', 'MVZ', 0, 'MVO', 'PACK',
'UNPK', 'ZAP', 'CP', 'AP', 'SP', 'MP', 'DP', 0, 'SVC', 'SPM',
'IDL'};
static short Clods[89 /*0:88*/] = {
4, 0x50CD, 0x001C, 0x58CD, 0x5C, 4, 0x50FB, 0x003C, 0x45FC,
0x4C, 6, 0x5820, 0x2000, 0x0620, 0x8920, 24, 0x1602, 0,
8, 0x50B0, 0, 0x4AB0, 0x4002, 0x41BB, 0x7, 0x54BD, 84,
4, 0x581D, 36, 0x9200, 0x1001, 11, 0x0510, 0x2826, 0x6E6D,
0x48, 0x6A6D, 0x28, 0x2B26, 0x47B0, 0x1014, 0x6A2D, 0x30, 4,
0x9003, 0xB000, 0x41BB, 0x10, 5, 0x4100, 0, 0x58EC, 186,
0x5FE, 5, 0x904E, 0xB010, 0x98CE, 0xD000, 0x5FE, 7, 0x904E,
0xB010, 0x98CF, 0, 0x9859, 0xF014, 0x5FE, 5, 0x4100, 255,
0x8900, 0x18, 0x1610, 6, 0x4100, 4, 0x59BD, 0x44, 0x4720,
0xC054, 6, 0x6000, 0xB040, 0x4100, 12, 0x5000, 0xB048};
static unsigned char Tsname[51 /*0:50*/] = {[0 ... 7] = 0,
1,
[9 ... 13] = 0,
1,
26,
1,
1,
26,
[19 ... 20] = 0,
2,
1,
[23 ... 30] = 26,
3,
9,
17,
[34 ... 35] = 26,
1,
0,
1,
26,
[40 ... 41] = 0,
5,
[43 ... 50] = 0};
Newlines(3);
Spaces(30);
printf("%s", "E.R.C.C. IMP(SYS1) COMPILER ");
printf("%s", " RELEASE 5 ALL-IMP VERSION");
printf("%s", " DATED 1/5/70");
Newlines(3);
static unsigned char Bytes[4 /*0:3*/] = {4, 1, 2, 8};
static unsigned char Precedence[1+12 /*1:12*/] = {0,
0, 3, 3, 3, 3, 4,
4, 4, 4, 5, 5, 5};
static unsigned char Typeflag[1+6 /*1:6*/] = {0,
1, 2, 0b1001,
0b10001, 0b11010, 5};
static int Mask1 = 0x0F0F0F0F;
static int Mask2 = 0x0F0F0F0F;
static short Maxlevels = 11;
static int Coder = 12;
static int Link = 15;
static int Wspr = 11;
static int Gla = 13;
short Ccsize;
short Arsize;
short Dsize;
short Nrouts;
auto void Sizes(void);
int Asl;
int Nnames;
int Cabuf;
int Ppcurr;
int Qpreal;
int Oldline;
int Line;
int Length;
int Lengthp;
int N0;
int Num;
int Snum;
int Rlevel;
int Nmax;
int Ownlink;
int Constptr;
int Plabel;
int Level;
int Ca;
int Marker1;
int Marker2;
int Labset;
int R13;
int Rp13;
int Sigfigs;
unsigned char Aflag;
unsigned char Fflag;
unsigned char Checks;
unsigned char Sbflag;
unsigned char Faulty;
unsigned char Mone;
unsigned char Hit;
unsigned char Qu;
unsigned char Perm;
unsigned char Mcswitch;
unsigned char List;
unsigned char Alllong;
unsigned char Linenos;
unsigned char Diags1;
unsigned char Diags2;
unsigned char Checksp;
unsigned char Ctype;
unsigned char Dcomp;
unsigned char Compiler;
unsigned char Cprmode;
unsigned char Unass;
unsigned char Printmap;
double Cvalue;
double Imax;
int Mask;
int Rbase;
int Sflabel;
int Next;
int N;
int Nr;
int Item;
int Strinst;
int P;
int Q;
int R;
int S;
int T;
int U;
int V;
int Nest;
int Fname;
int Xreflink;
int Ldptr;
short Neps;
short Eplink;
int Sstl;
int Qmax;
int Stmts;
int Register[16 /*0:15*/];
int St[1301 /*0:1300*/];
int Set[Maxlevels + 1];
int Codebase[Maxlevels + 1];
int Freg[Maxlevels + 1];
int Ral[Maxlevels + 1];
short Cycle[Maxlevels + 1];
short Jump[Maxlevels + 1];
short Name[Maxlevels + 1];
short Label[Maxlevels + 1];
short Flag[Maxlevels + 1];
short Sbr[Maxlevels + 1];
short Wsp[Maxlevels + 1];
short L[Maxlevels + 1];
short M[Maxlevels + 1];
short Lwsp[Maxlevels + 1];
short Mdarr[Maxlevels + 1];
short Rnext[Maxlevels + 1];
short Nmdecs[Maxlevels + 1];
short Strwsp[Maxlevels + 1];
short Code[193 /*0:192*/];
short Pagenos[51 /*0:50*/];
int Uvarreg[5+4 /*5:8*/];
Sizes();
unsigned char Cc[Ccsize + 1];
unsigned char Aslist[Asl + 1];
unsigned char Lett[(Dsize + 20) + 1];
short Ra[Nrouts + 1];
short A[Arsize - -2 + 1];
short Word[Nnames + 1];
short Tags[Nnames + 1];
//extern int Com(int N);
//extern void Setcom(int I, int J);
//extern void Iocp(int A, int B);
auto void Cnop(int I, int J);
auto void Pconst(int X);
auto void Psi(int Opcode, int J, int Base, int Disp);
auto void Pss(int Opcode, int N, int Base, int Disp, int P, int Q);
auto void Prx(int Opcode, int R1, int R2, int Base, int Disp);
auto void Paclod(int Ptr, int At, int Value);
auto void Pclod(int Ptr);
auto void Plant(int Value);
auto void Prr(int Opcode, int R1, int R2);
//extern void Lput(int A, int B, int C, int D);
auto void Plug(int J, int K);
auto void Prhex(int Value, int Places);
auto void Initialise(void);
auto void Psym(int X);
auto void Compare(void);
auto void Pname(void);
auto void Const(unsigned char Mode);
auto void Constlist(void);
auto void Texttext(void);
auto void XFromar8(int Ptr, double *Value);
#define Fromar8(Ptr, Value) XFromar8(Ptr, &Value)
auto void XFromar4(int Ptr, int *Value);
#define Fromar4(Ptr, Value) XFromar4(Ptr, &Value)
auto void Toar8(int Ptr, double Value);
auto void Toar4(int Ptr, int Value);
auto void Css(int P);
auto void Fault(unsigned char N);
auto void Finalise(void);
auto void Printname(int N);
//void Recode(int Start, int Finish, int Ca);
auto void Readline(unsigned char N);
if (_imp_on_event(9, 18)) {
if (_imp_caught_on_event(EVENT.EVENT, 9))
goto Inend;
if (_imp_caught_on_event(EVENT.EVENT, 18))
goto Subschar;
}
Initialise();
Lput(0, 1, 1, Addr(Lett[1]));
L__8:
Readline(0);
Q = 1;
L__5:
R = 1;
P = Ss;
Oldline = Line;
Compare();
if (R > Arsize)
Fault(102);
if (!Hit)
goto L__6;
Stmts++;
Css(1);
if (Dcomp != 0 && Ca > Cabuf) {
Recode(Addr(Code[0]), Addr(Code[Ppcurr]), Cabuf);
Newline();
Lput(1, Ca - Cabuf, Cabuf, Addr(Code[0]));
Ppcurr = 0;
Cabuf = Ca;
}
if (A[1] == 13)
goto L__7;
L__9:
if (Q >= Length)
goto L__8;
goto L__5;
L__6:
Fault(100);
goto L__9;
L__7:;
Finalise();
if (Compiler == 0 && Faulty == 0)
Setcom(24, 0);
exit(0);
Inend:
Fault(108);
Subschar:
Line++;
Fault(48);
Spaces(5);
L__15:
Readsymbol(&I);
if (I == 10)
goto L__8;
Printsymbol(I);
goto L__15;
void Finalise(void) {
if ((N0 & 1) != 1)
N0++;
Cnop(0, 8);
St[0] = 0x20000;
St[1] = 0x10100000;
St[4] = -1;
St[6] = 255;
St[8] = Ownlink;
St[12] = 0x41100000;
St[14] = 0x41200000;
St[18] = 0x4E000000;
St[20] = -4;
St[21] = -8;
St[22] = Xreflink;
Xreflink = 88;
St[26] = 0x80000000;
St[27] = 0x06492350;
St[28] = 'ERMA';
St[29] = 0x904EB010;
St[30] = 0x5A10D01C;
St[31] = 0x07F10700;
St[32] = 0x80808080;
St[33] = 0x80808080;
St[38] = 0x80000000;
St[39] = 0x06532349;
St[40] = 'OCP ';
K = Ca;
if (Ca != Cabuf)
Lput(1, Ca - Cabuf, Cabuf, Addr(Code[0]));
Lput(2, (N0 << 2) + 4, 0, Addr(St[0]));
if (N0 > 1023)
Fault(99);
I = 0xE2E2E2E2;
Lput(4, 4, Sstl, Addr(I));
if (Constptr & 1)
Psym(0);
if (Faulty)
goto L__129;
Newline();
Write(Stmts, 4);
printf("%s", " STATEMENTS COMPILED SUCCESSFULLY");
L__120:
printf("%s", "\nCODE OCCUPIES ");
Write(K, 3);
printf("%s", " BYTES GLAP ");
Write(N0 << 2, 3);
printf("%s", " +");
Write(Constptr << 2, 1);
printf("%s", " BYTES DIAG TABLES ");
Write(Sstl + 4, 4);
printf("%s", " BYTES Total ");
St[0] = Ca;
St[1] = (N0 << 2) + 4;
St[2] = ((Ldptr << 2) + 7) & (-8);
St[3] = (Sstl + 11) & (-8);
St[4] = Constptr << 2;
St[5] = Ca + St[1] + St[2] + St[3] + St[4];
Write(St[5], 5);
printf("%s", " Bytes");
Newline();
Newline();
Lput(7, 24, 0, Addr(St[0]));
return;
L__129:
printf("%s", "\nPROGRAM CONTAINS ");
Write(Faulty, 2);
printf("%s", " FAULTS");
goto L__120;
}
void Readline(unsigned char N) {
__label__ L__1;
int Del;
unsigned char Np; // ABOUT 30% CPU TIME OF COMPILATION IS SPENT IN THIS
// ROUTINE AS WRITTEN. A HAND CODED VERSION USING I
// ISO CARD NOT READ SYMBOL IS USED IN PRODUCTION VRSN
Q = 1;
Line++;
Length = 0;
Del = 0;
L__1:
if (N != 0 || Nextsymbol() != 10)
goto Start;
Skipsymbol();
goto L__1;
Start:
if (!List)
goto L__2;
Write(Line, 5);
if (N)
Printsymbol('\'');
Spaces(4 * Level - N);
L__2:
Readsymbol(&I);
if (List)
Printsymbol(I);
if (N)
goto L__4;
if (I != '%')
goto L__3;
Del = 128;
goto L__2;
L__3:
if ('A' > I || I > 'Z')
Del = 0;
if (I == ' ')
goto L__2;
L__4:
Length++;
Cc[Length] = I | Del;
if (I == '\'')
N--;
if (I != 10)
goto L__2;
if (Cc[Length - 1] != 'C' + 128)
return;
Length--;
if (!List)
goto L__2;
Spaces(5);
Printsymbol('C');
Spaces(4 * Level);
goto L__2;
}
void Fault(unsigned char N) {
__label__ L__99;
int I;
int J;
int Qp;
printf("%s", "\n*");
Write(Line, 4);
I = 3;
if (!List)
I = 3 * Level;
Spaces(I);
Faulty++;
if (N == 100)
goto L__9;
printf("%s", "Fault ");
Write(N, 2);
if (N < 100)
goto L__2;
printf("%s", " DISASTER ");
_imp_monitor(0);
exit(0);
L__2:
if (7 == N || N == 16)
Printname(Fname);
goto L__99;
L__9:
printf("%s", " SYNTAX ");
if (Line != Oldline)
goto L__11;
Qp = Q;
for (Q = Q; Q <= Length - 1; Q++) {
Printsymbol(Cc[Q]);
if (Cc[Q] == ';')
goto L__10;
}
L__10:
Q++;
if (I + 20 + Q - Qp > 120)
goto L__99;
Newline();
Spaces(I + Qmax - Qp + 17);
Printsymbol('!');
Newline();
goto L__99;
L__11:
printf("%s", "\n TEXT MODE FAILURE ");
Write(Line - Oldline, 1);
printf("%s", " LINES LOST ");
Newline();
Q = Qmax;
L__99:
Newline();
}
void Compare(void) {
int Ra;
int Rp;
int Rq;
int Rr;
int Rs;
int Marker;
static int Bip_sw;
static void *Bip[20 /*1000:1019*/] = {
&&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,
};
Rp = Symbol[P];
Rq = Q;
Rr = R;
A[R] = 1;
P++;
Ra = Symbol[P];
Rs = P; // ROUTINE REALLY STARTS HERE
L__1:
R++;
Bip_1000:
L__2:;
Rs++;
if (Rs == Ra)
goto L__8;
Item = Symbol[Rs];
if (Item >= 1300)
goto L__4;
if (Item >= 1000)
goto L__6;
for (J = 1; J <= Clett[Item]; J++) {
if (Cc[Q] != Clett[J + Item])
goto L__3;
Q++;
}
goto L__2;
L__4:;
P = Item;
Compare();
if (Hit)
goto L__2;
L__3:
if (Q > Qmax)
Qmax = Q;
Q = Rq;
R = Rr;
if (Ra == Rp)
goto L__7;
Rs = Ra;
A[R] = A[R] + 1;
Ra = Symbol[Ra];
goto L__1;
L__8:;
Hit = 1;
return;
L__7:;
Hit = 0;
return;
L__6:;
I = Cc[Q];
goto *Bip[Bip_sw = (Item)-1000];
Bip_1001:;
Pname();
if (Hit == 1)
goto L__1;
goto L__3;
Bip_1002:;
if ('A' > I || I > 'Z')
goto L__3;
S = I;
J = 1;
L__200:
Q++;
I = Cc[Q];
if ('A' > I || I > 'Z')
goto L__201;
S = S << 8 | I;
J++;
goto L__200;
L__201:
if (I != '_' || J > 4)
goto L__3;
Q++;
goto L__2;
Bip_1003:;
Const(0);
if (!Hit)
goto L__3;
if (Ctype == 5)
goto L__1;
if (Ctype == 2)
goto L__26;
if (!(S >> 12))
goto L__22;
A[R] = 1;
Toar4(R + 1, S);
R += 3;
goto L__2;
L__22:
A[R] = 9;
R++;
A[R] = S;
goto L__1;
L__26:
A[R] = 2;
Toar8(R + 1, Cvalue);
R += 5;
goto L__2;
Bip_1005:;
if ('0' > I || I > '9')
goto L__3;
Const(2);
A[R] = S;
goto L__1;
Bip_1004:;
Constlist();
goto L__1;
Bip_1006:;
if (I == 10)
goto L__2;
if (I != ';')
goto L__3;
Q++;
goto L__2;
Bip_1007:
L__30:;
if (10 == I || I == ';')
goto L__1;
Q++;
I = Cc[Q];
goto L__30;
Bip_1008:;
Texttext();
if (!Hit)
goto L__3;
goto L__1;
Bip_1009:;
U = R;
V = 1;
R++;
Pname();
if (!Hit)
goto L__3;
L__90:
if (Cc[Q] != ',')
goto L__91;
Q++;
R++;
I = Cc[Q];
Pname();
if (!Hit)
goto L__92;
V++;
goto L__90;
L__92:
R--;
Q--;
L__91:
A[U] = V;
goto L__1;
Bip_1010:;
Marker = R;
goto L__1;
Bip_1011:;
A[Marker] = R - Marker;
goto L__2;
Bip_1012:;
if ((S & 255) == 'R')
goto L__124;
for (I = 0; I <= 2; I++)
if (S == Nem[I])
goto L__120;
goto L__3;
L__120:
A[R] = Opc[I] & 63;
goto L__1;
L__124:
J = S >> 8;
for (I = 2; I <= 48; I++)
if (J == Nem[I])
goto L__120;
goto L__3;
Bip_1013:;
for (I = 18; I <= 64; I++)
if (S == Nem[I])
goto L__130;
goto L__3;
L__130:
A[R] = Opc[I];
goto L__1;
Bip_1014:;
for (I = 66; I <= 69; I++)
if (S == Nem[I])
goto L__130;
goto L__3;
Bip_1015:;
for (I = 71; I <= 83; I++)
if (S == Nem[I])
goto L__130;
goto L__3;
Bip_1016:;
for (I = 85; I <= 92; I++)
if (S == Nem[I])
goto L__130;
goto L__3;
Bip_1017:;
for (I = 94; I <= 106; I++)
if (S == Nem[I])
goto L__130;
goto L__3;
Bip_1018:;
for (I = 108; I <= 116; I++)
if (S == Nem[I])
goto L__130;
goto L__3;
Bip_1019:;
for (I = 118; I <= 120; I++)
if (S == Nem[I])
goto L__130;
goto L__3;
}
int Hash(int Addr) {
return (Nnames & (19 * *Byteinteger(Addr) + 31 * *Byteinteger(Addr + 1)));
}
void Pname(void) {
int Jj;
int Kk;
int Ll;
Hit = 0;
I = Cc[Q];
if ('A' > I || I > 'Z')
goto L__3;
if (Cc[Q + 1] == '\'' && (I == 'B' || I == 'X' || I == 'M'))
goto L__3;
S = 2;
T = 1;
goto L__10;
L__12:
Q++;
I = Cc[Q];
if (('A' > I || I > 'Z') && ('0' > I || I > '9'))
goto L__101;
T++;
S++;
L__10:
Lett[Next + T] = I;
goto L__12;
L__101:
Lett[Next] = T;
if (Next + S > Dsize)
Fault(108);
Jj = Hash(Addr(Lett[Next]));
for (Num = Jj; Num <= Jj + Nnames; Num++) {
Kk = Num & Nnames;
Ll = Word[Kk];
if (!Ll)
goto L__2;
for (Jj = 1; Jj <= Lett[Ll]; Jj++)
if (Lett[Next + Jj] != Lett[Ll + Jj])
goto Fail;
goto L__41;
Fail:;
}
Fault(104);
L__2:
Word[Kk] = Next;
Next += S;
L__41:
A[R] = Kk;
Hit = 1;
L__3:;
}
void Const(
unsigned char Mode) { // MODE=0 FOR NORMAL MODE=2 FOR EXPONENT ETC
__label__ L__99;
int Z;
double X;
Cvalue = 0;
I = Cc[Q];
S = 0;
if ('0' <= I && I <= '9')
goto N;
if (I == '.' && Mode == 0 && '0' <= Cc[Q + 1] && Cc[Q + 1] <= '9')
goto Dot;
if (I == '$' && Mode == 0)
goto Pi;
if (I == '\'')
goto L__101;
if (Cc[Q + 1] != '\'')
goto L__150;
Q += 2;
if (I == 'X')
goto L__102;
if (I == 'M')
goto Mult;
if (I == 'B')
goto L__104;
Q -= 2;
goto L__150;
Pi:;
Cvalue = 3.14159265358979323846;
Q++;
goto L__40;
L__101:
S = R;
A[R] = 5;
R++;
Texttext();
if (!A[S + 1])
goto L__24;
if (A[S + 1] == 1)
goto L__27;
Ctype = 5;
return;
L__24:
R = S;
S = 0;
goto L__99;
L__27:
R = S;
S = A[S + 2];
goto L__99;
L__102:
I = Cc[Q];
Q++;
if (I == '\'')
goto L__99;
if ('0' <= I && I <= '9')
goto L__5;
if ('A' > I || I > 'F')
goto L__150;
S = S << 4 | (I - 'A' + 10);
goto L__102;
L__5:
S = S << 4 | (I - '0');
goto L__102;
Mult:
T = 0;
L__28:
I = Cc[Q];
Q++;
if (I == '\'')
goto L__22;
L__29:
S = S << 8 | I;
T++;
if (T >= 5)
goto L__150;
goto L__28;
L__22:
if (Cc[Q] != '\'')
goto L__99;
Q++;
goto L__29;
L__104:
T = Q;
L__32:
I = Cc[Q];
Q++;
if ('1' != I && I != '0')
goto L__31;
S = S << 1 | (I - '0');
if (Q - T >= 33)
goto L__150;
goto L__32;
L__31:
if (I == '\'')
goto L__99;
goto L__150;
N:
I = I & 15;
Cvalue = 10 * Cvalue + I;
Q++;
I = Cc[Q];
if ('0' <= I && I <= '9')
goto N;
if (Mode != 0 || I != '.')
goto Alpha;
Dot:
Q++;
X = 10;
L__45:
I = Cc[Q];
if ('0' > I || I > '9')
goto Alpha;
I = I & 15;
Cvalue += I / X;
X = 10 * X;
Q++;
goto L__45;
Alpha: // TEST FOR EXPONENT
if (Mode != 0 || Cc[Q] != '@')
goto Fix;
Q++;
X = Cvalue;
Z = 1;
if ('+' != Cc[Q] && Cc[Q] != '-')
goto L__39;
if (Cc[Q] == '-')
Z = -1;
Q++;
L__39:
Const(2);
if (!Hit)
goto L__150;
S = S * Z;
if (S == -99)
Cvalue = 0;
else
Cvalue = X * REXP(10, S);
Fix: // SEE IF IT IS Integer
if (Cvalue > Imax)
goto L__40;
if (!Fracpt(Cvalue))
goto L__41;
L__40:
Ctype = 2;
Hit = 1;
return;
L__41:
S = Int(Cvalue);
L__99:
Ctype = 1;
Hit = 1;
return;
L__150:
Hit = 0;
}
void Constlist(void) {
__label__ L__99;
int Precp;
int Nconst;
int Rf;
int J;
int K;
int Cpw;
int Kk;
int Sign;
int Sp;
int Rq;
int Value;
int Typep;
int Acc;
int Rp;
int N;
int Jj;
double C;
Value = 0;
Nconst = 0;
if (Constptr & 1)
Psym(0);
A[R + 1] = Constptr;
Rp = R;
R += 2;
Acc = 0;
N = 24;
Typep = Typeflag[A[2]];
Precp = Typep >> 3;
Typep = Typep & 7;
if (Typep == 5)
Acc = A[4];
if (Typep == 2 && Alllong == 1)
Precp = 3;
Cpw = 4 / Bytes[Precp];
if (Typep == 5)
Cpw = 4;
L__6:
Rq = Q;
I = Cc[Q];
Sign = 1;
if (I == '-')
goto L__7;
if (I == '+')
goto L__8;
goto L__9;
L__7:
Sign = -1;
if (Cpw == 4)
goto L__99;
L__8:
Q++;
I = Cc[Q];
L__9:
Const(0);
Rf = 1;
if (!Hit)
goto L__98;
if (Cc[Q] != '(')
goto L__1;
J = S;
Q++;
C = Cvalue;
Const(2);
if (Hit != 1 || S <= 0 || Cc[Q] != ')')
goto L__98;
Q++;
Cvalue = C;
Rf = S;
S = J;
L__1:
if (Typep == 2)
goto L__21;
if (Typep == 5)
goto L__51;
if (Cpw == 4 && S > 255)
goto L__99;
if (Cpw == 2 && abs(S) >> 16 != 0)
goto L__99;
S = S * Sign;
if (Cpw == 2)
S = S & 0xFFFF;
for (Kk = 1; Kk <= Rf; Kk++) {
J = Nconst / Cpw;
K = Nconst - Cpw * J;
Sp = S << (32 * (Cpw - K - 1) / Cpw);
Value = Sp | Value;
Nconst++;
if ((Cpw - 1) & Nconst)
goto L__5;
Psym(Value);
Value = 0;
L__5:;
}
L__11:
if (Cc[Q] != ',')
goto L__99;
Q++;
if (Cc[Q] != 10)
goto L__6;
Readline(0);
Q = 1;
goto L__6;
L__21:
if (Ctype == 1)
Cvalue = S;
Cvalue = Sign * Cvalue;
J = *Integer(Addr(Cvalue));
K = *Integer(Addr(Cvalue) + 4);
for (Kk = 1; Kk <= Rf; Kk++) {
Nconst++;
Psym(J);
if (Precp == 3)
Psym(K);
}
goto L__11;
L__51:
if (Ctype == 5)
goto L__52;
if (Ctype != 1 || S > 127)
goto L__98;
A[Rp + 3] = 1;
A[Rp + 4] = S;
L__52:
if (Sign != 1 || Acc < A[Rp + 3])
goto L__98;
for (Kk = 1; Kk <= Rf; Kk++) {
for (Jj = 0; Jj <= Acc; Jj++) {
S = A[Rp + Jj + 3] & 127;
Sp = S << N;
Value = Sp | Value;
N -= 8;
if (N >= 0)
goto L__55;
Psym(Value);
N = 24;
Value = 0;
L__55:;
}
Nconst++;
}
R = Rp + 2;
goto L__11;
L__98:
Q = Rq;
L__99:
R = Rp;
A[R] = Nconst;
if ((Typep == 5 && N != 24) || (Typep != 5 && ((Cpw - 1) & Nconst) != 0))
Psym(Value);
}
void Texttext(void) {
__label__ L__99;
int S;
int J;
S = R;
R++;
if (I != '\'')
goto L__98;
Q++;
L__1:
I = Cc[Q];
A[R] = I;
R++;
if (I == '\'')
goto L__31;
if (I == 10)
goto L__32;
Q++;
if (R - S > 256)
Fault(106);
goto L__1;
L__32:
Readline(1);
Q = 1;
goto L__1;
L__31:
if (Cc[Q + 1] != '\'')
goto L__35;
Q += 2;
goto L__1;
L__35:
R -= 2;
J = R - S;
if (J & 1)
goto L__36;
R++;
A[R] = 0;
L__36:
A[S] = J;
Q++;
Hit = 1;
goto L__99;
L__98:
Hit = 0;
L__99:;
}
void Setuplist(void) {
int J;
int K;
for (J = 0; J <= Asl - 16; J += 8)
*Shortinteger(Addr(Aslist[J])+14) = J;
// SHORT INTEGER(ADDR(ASLIST(J))+14)=J
*Integer(Addr(Aslist[0])) = -1;
*Integer(Addr(Aslist[4])) = 0xFFFF0000;
Asl -= 8;
}
void Initialise(void) {
static unsigned char Ilett[1+320 /*1:320*/] = {0,
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', 6, 'R', 'U', 'N', 'O', 'U',
'T', 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', 9, 'M', 'A', 'P', 'R', 'E',
'C', 'O', 'R', 'D', 11, 'B', 'Y', 'T', 'E', 'I', 'N', 'T', 'E', 'G',
'E', 'R', 12, 'S', 'H', 'O', 'R', 'T', 'I', 'N', 'T', 'E', 'G', 'E',
'R', 6, 'R', 'A', 'D', 'I', 'U', 'S', 6, 'A', 'R', 'C', 'T', 'A',
'N', 6, 'P', 'A', 'R', 'I', 'T', 'Y', 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'};
static short Iword[43 /*0:42*/] = {
1, 13, 26, 34, 40, 51, 58, 67, 74, 85, 97,
108, 113, 119, 127, 132, 139, 143, 149, 156, 162, 170,
175, 183, 187, 194, 199, 203, 207, 211, 215, 219, 229,
241, 254, 261, 268, 275, 287, 290, 299, 307, 314};
int I;
Cabuf = 0;
Ppcurr = 0;
Qpreal = 0;
Oldline = 0;
Line = 0;
Rlevel = 0;
Nmax = 0;
Constptr = 0;
Level = 0;
Ca = 0;
Aflag = 0;
Fflag = 0;
Sbflag = 0;
Faulty = 0;
Perm = 0;
Mcswitch = 0;
Alllong = 0;
Dcomp = 0;
Compiler = 0;
Cprmode = 0;
Printmap = 0;
Next = 1;
Nr = 0;
Ldptr = 0;
Neps = 0;
Eplink = 0;
Rbase = 0;
Strinst = 0;
Imax = (-1) >> 1;
Plabel = 24999;
Sstl = 0;
Stmts = 0;
Snum = 0;
Labset = 3 << 30;
Lett[0] = 0;
N0 = 41;
N = 12;
Checksp = 1;
Checks = 1;
Linenos = 1;
Diags1 = 1;
Qu = 1;
Mone = 1;
List = 1;
Sflabel = 20999;
Unass = 1;
Ownlink = 0;
Xreflink = 136;
I = Com(24);
if (I & 2)
List = 0;
if (I & 4)
Linenos = 0;
if (I & 16)
Unass = 0;
if (I & 32)
Checks = 0;
if (I & 0x8000)
Printmap = 1;
if (I & 64)
Diags1 = 0;
for (I = 0; I <= Maxlevels; I++) {
Set[I] = 0;
Codebase[I] = 0;
Freg[I] = 0;
Ral[I] = 0;
Lwsp[I] = 0;
Mdarr[I] = 0;
Rnext[I] = 0;
Strwsp[I] = 0;
Cycle[I] = 0;
Jump[I] = 0;
Name[I] = 0;
Label[I] = 0;
Flag[I] = 0;
Sbr[I] = 0;
Wsp[I] = 0;
}
for (I = 0; I <= 50; I++) {
St[I] = 0;
Pagenos[I] = 0;
if (I < 16)
Register[I] = 0;
if (5 <= I && I <= 8)
Uvarreg[I] = 0;
}
Pagenos[1] = 10;
for (I = 0; I <= Nnames; I++) {
Word[I] = 0;
Tags[I] = 0;
}
Setuplist();
Pclod(0);
Pclod(5);
A[1] = 28;
for (I = 0; I <= 42; I++) {
J = Iword[I];
for (K = 1; K <= Ilett[J]; K++) {
Cc[K] = Ilett[J + K];
}
Cc[K + 1] = ';';
R = 2;
Q = 1;
Pname();
Css(1);
}
A[1] = 12;
Css(1);
}
// THE NEXT 4 ROUTINES CAN BE MACROISED USING MVC
void Toar4(int Ptr, int Value) {
int Ad;
Ad = Addr(Value);
A[Ptr] = *Shortinteger(Ad); //A(PTR)<-SHORT INTEGER(AD)
A[Ptr + 1] = *Shortinteger(Ad+2); //A(PTR+1)<-SHORT INTEGER (AD+2)
}
void Toar8(int Ptr, double Value) {
int Ad;
Ad = Addr(Value);
A[Ptr] = *Shortinteger(Ad); //A(PTR)<-SHORT INTEGER(AD)
A[Ptr + 1] = *Shortinteger(Ad+2); //A(PTR+1)<-SHORT INTEGER(AD+2)
A[Ptr + 2] = *Shortinteger(Ad+4); //A(PTR+2)<-SHORT INTEGER(AD+4)
A[Ptr + 3] = *Shortinteger(Ad+6); //A(PTR+3)<-SHORT INTEGER(AD+6)
}
void XFromar4(int Ptr, int *Value) {
int Ad;
Ad = Addr(Value);
*Shortinteger(Ad) = A[Ptr]; //SHORT INTEGER(AD)<- A(PTR)
*Shortinteger(Ad+2) = A[Ptr + 1]; //SHORT INTEGER(AD+2)<- A(PTR+1)
}
void XFromar8(int Ptr, double *Value) {
int Ad;
Ad = Addr(Value);
*Shortinteger(Ad) = A[Ptr]; //SHORT INTEGER(AD)<- A(PTR)
*Shortinteger(Ad+2) = A[Ptr + 1]; //SHORT INTEGER(AD+2)<- A(PTR+1)
*Shortinteger(Ad+4) = A[Ptr + 2]; //SHORT INTEGER(AD+4)<- A(PTR+2)
*Shortinteger(Ad+6) = A[Ptr + 3]; //SHORT INTEGER(AD+6)<- A(PTR+3)
}
void Printname(int N) {
int J;
int V;
if (N >= 0)
goto L__4;
N = -N;
if (16384 > N || N > 16384 + Nnames)
goto L__5;
N -= 16384;
goto L__4;
L__5:
Write(N, 1);
goto L__3;
L__4:
Space();
V = Word[N];
for (J = 1; J <= Lett[V]; J++)
Printsymbol(Lett[V + J]);
L__3:;
}
void Pclod(int Ptr) {
int I;
for (I = Ptr + 1; I <= Ptr + Clods[Ptr]; I++)
Plant(Clods[I]);
}
void Paclod(int Ptr, int At, int Value) {
int I;
int J;
int K;
J = Clods[Ptr];
At += Ptr;
for (I = Ptr + 1; I <= Ptr + J; I++) {
K = Clods[I];
if (I == At)
K = K | Value;
Plant(K);
}
}
void Plant(int Value) {
Code[Ppcurr] = Value;
Ppcurr++;
Ca += 2;
if (Ppcurr != 192)
return;
Lput(1, 384, Cabuf, Addr(Code[0]));
Ppcurr = 0;
Cabuf = Ca;
}
void Prr(int Opcode, int R1, int R2) { Plant(Opcode << 8 | R1 << 4 | R2); }
void Prx(int Opcode, int R1, int R2, int Base, int Disp) {
Plant(Opcode << 8 | R1 << 4 | R2);
Plant(Base << 12 | Disp);
}
void Psi(int Opcode, int J, int Base, int Disp) {
Plant(Opcode << 8 | J);
Plant(Base << 12 | Disp);
}
void Pss(int Opcode, int N, int Base, int Disp, int P, int Q) {
Plant(Opcode << 8 | (N - 1));
Plant(Base << 12 | Disp);
Plant(P << 12 | Q);
}
void Pconst(int X) {
Plant(X >> 16);
Plant(X & 0xFFFF);
}
void Cnop(int I, int J) {
J--;
L__1:
if ((Ca & J) == I)
goto L__9;
Plant(0x0700);
goto L__1;
L__9:;
}
void Psym(int X) {
Lput(5, 4, Constptr << 2, Addr(X));
Constptr++;
}
void Plug(int J, int K) {
__label__ L__99;
if (J >= Cabuf)
goto Inbuf;
Lput(1, 2, J, Addr(K) + 2);
goto L__99;
Inbuf:
Code[(J - Cabuf) >> 1] = K;
L__99:;
}
void Prhex(int Value, int Places) {
static 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[Value >> I & 15]);
}
void Sizes(void) {
auto void Sum(int I);
int I;
int J;
int Free;
int Total;
Sum(5);
return;
// system-dependent calculation of free memory...
I = Com(2);
Free = *Integer(I + 4);
Free = Free - Addr(Total) - 10000;
for (J = 0; J <= 5; J++) {
Sum(J);
if (Total > Free)
goto L__1;
}
return;
L__1:
if (J)
goto L__2;
printf("%s", "NOT ENOUGH CORE ALLOCATED FOR IMP");
_imp_monitor(0);
exit(0);
L__2:
Sum(J - 1);
return;
void Sum(int I) {
Nnames = 128 * REXP(2, I) - 1;
Ccsize = 200 + 40 * I;
Nrouts = Nnames / 2;
Asl = 24 * Nnames;
if (Asl > 32760)
Asl = 32760;
Arsize = 300 + 50 * I;
Dsize = 6 * Nnames;
Total = Ccsize + Asl + 2 * (Nrouts + Arsize + Dsize);
}
}
void Css(int P) {
__label__ Scalar;
auto void Redefineep(int Typep, int Params);
auto void Ciocp(int N);
auto void Defineep(int Mode, int Name, int Addr);
auto void Loaddata(void);
auto void Plocaljump(int Mask, int Lab);
auto void Filllocaljumps(void);
auto void XClearlist(short *Ophead);
#define Clearlist(Ophead) XClearlist(&Ophead)
auto void Storestring(int Z, int From, int To, int Bml, int Dml);
auto void Cend(int Kkk);
auto void XCbpair(int *Lb, int *Ub);
#define Cbpair(Lb, Ub) XCbpair(&Lb, &Ub)
auto void XUndcrf(short *Ophead);
#define Undcrf(Ophead) XUndcrf(&Ophead)
auto void Ccond(int Iu, int Reg, int Addr);
auto void Filljumps(int Level);
auto void Setline(void);
auto void Cui(unsigned char Code);
auto void Set80(int Where, int N);
auto void Cvdecln(void);
auto void Csexp(int Reg, unsigned char Mode);
auto void Cstrexp(int Reg);
auto void Checkrf(void);
auto void Assign(int P1, int P2);
auto int Copyrecordtag(void);
auto int Countaps(void);
auto int Displacement(int Link);
auto void Loadad(int Reg, int Base, int X, int Disp);
auto void Skipapp(void);
auto void Cquery(int Reg);
auto void Crformat(void);
auto void Cadcln(unsigned char Mode);
auto void Cqn(int P);
auto void Clt(void);
auto void Mover(int R, int N);
auto int Getarrwsp(void);
auto int Getdblewrd(void);
auto void Crcall(int Clink);
auto void Cname(int Z, int Reg);
auto void Crname(int Z, int Mode, int Clink, int Bs, int Dp);
auto void Caname(int Z, int Bs, int Dp, int Link, int Bsrf, int Dprf);
auto void Cename(int Z, int Mode, int Bs, int Dp);
auto void XInsertafter(short *Stad, int S1, int S2);
#define Insertafter(Stad, S1, S2) XInsertafter(&Stad, S1, S2)
auto void XFromlist(int Cell, int *S1, int *S2);
#define Fromlist(Cell, S1, S2) XFromlist(Cell, &S1, &S2)
auto void XPop(short *Cell, int *S1, int *S2);
#define Pop(Cell, S1, S2) XPop(&Cell, &S1, &S2)
auto void XPush(short *Cell, int S1, int S2);
#define Push(Cell, S1, S2) XPush(&Cell, S1, S2)
auto int Find(int Lab, int List);
auto void XMlink(int *Cell);
#define Mlink(Cell) XMlink(&Cell)
auto void Replace2(int Cell, int S2);
auto void Replace1(int Cell, int S1);
auto void Replaceboth(int Cell, int S1, int S2);
auto void XFrom2(int Cell, int *S2);
#define From2(Cell, S2) XFrom2(Cell, &S2)
auto void XFrom1(int Cell, int *S1);
#define From1(Cell, S1) XFrom1(Cell, &S1)
auto void Cres(int Mode, int Lab);
auto int Newcell(void);
auto void Copytag(int Kk);
auto void Csname(int Z, int Reg);
auto void Replacetag(int Kk);
auto int Park(int Reg);
auto int Parkf(int Reg, int Prec);
auto int Claimablereg(void);
auto int Findpp(void);
auto int Getstrwsp(void);
auto void Setex(void);
auto void Gxref(int Name, int Hash);
auto void Unpark(int Opcode, int Reg, int Q);
auto void Storetag(int Kk, int Slink);
auto int Pageno(int N);
auto void Testnst(void);
auto void Cuci(void);
auto void Skipexp(void);
auto void Unpack(void);
auto int Sortconst(int P, int Long, int Type);
auto void XPack(int *Ptype);
#define Pack(Ptype) XPack(&Ptype)
auto void Crspec(unsigned char M);
auto void Dump(int Code, int Reg, int Dis, int X, int Level);
auto void Rhead(int Kk);
auto void Testass(int Reg);
auto void Pj(int Mask, int Stad);
auto void Compileformalparameter(void);
auto void Ppj(unsigned char N);
auto void Plab(int M);
auto void Checkcapacity(int Reg, int Dis, int X, int Level);
auto int XTsexp(int *Code);
#define Tsexp(Code) XTsexp(&Code)
static int Sw_sw;
static void *Sw[45 /*1:45*/] = {
&&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, &&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, &&Sw_default, &&Sw_default, &&Sw_default,
&&Sw_default, &&Sw_default, &&Sw_default, &&Sw_default, &&Sw_default,
};
int Inc;
int Incp;
int Bxle;
int Acc;
short Ophead;
int Jj;
int Jjj;
int Kk;
int Kkk;
int Q;
int Qq;
int Extrn;
int Base;
int Disp;
int Value;
int Index;
int Localbase;
int Localaddr;
short Localjump;
short Locallabel;
unsigned char Rout;
unsigned char Nam;
unsigned char Arr;
unsigned char Prec;
unsigned char Type;
unsigned char Precp;
int Ptype;
int I;
int J;
int K;
int Oldi;
int Inreg;
int Ptypep;
int Save13;
int Chnge13;
Localjump = 0;
Locallabel = 0;
Localbase = 0;
Oldi = 0;
goto *Sw[Sw_sw = (A[P]) - 1];
Sw_1:
Marker2 = P + 1 + A[P + 1];
Setline();
P += 2;
if (A[Marker2] == 2)
goto L__101;
Mask = 15;
Cui(0);
goto L__1;
L__101:
Q = P;
if (A[P] == 9)
Fault(54);
Save13 = R13;
Chnge13 = 0;
if (A[P] == 3)
goto L__103;
Plabel -= 2;
Jjj = Plabel + 1;
Kkk = Plabel;
P = Marker2 + 2;
Ccond(A[P - 1] - 1, Jjj, Kkk);
Plocaljump(Mask, Kkk);
if (R13 != Save13 || Chnge13 != 0)
R13 = 0;
Push(Locallabel, Ca, Jjj);
P = Q;
Cui(1);
L__104:
Push(Locallabel, Ca, Kkk);
if (R13 != Save13 || Chnge13 != 0)
R13 = 0;
L__102:
if (Localbase != 10 && Localbase != 0)
Register[Localbase] = 0;
Filllocaljumps();
goto L__1;
L__103:
Plabel--;
Jjj = Plabel;
Nmdecs[Level] = 1;
Kkk = A[P + 2] + ((A[P + 1] - 1) << 14);
P = Marker2 + 2;
Ccond(2 - A[P - 1], Jjj, Kkk);
Plocaljump(Mask, Kkk);
if (R13 != Save13 || Chnge13 != 0)
R13 = 0;
Push(Locallabel, Ca, Jjj);
goto L__102;
Sw_2:
Setline();
P++;
Bxle = 0;
Cname(3, 4);
Inc = N;
N += 12;
if (Type != 1 || Prec != 0)
Fault(25);
Q = P;
Skipexp();
Register[4] = 1;
Jj = P;
if (3900 > Ca - Codebase[Level] && 1 <= Tsexp(Jjj) && Tsexp(Jjj) <= 2)
Bxle = 1;
P = Jj;
Csexp(2, 1);
Jjj = P;
Kkk = Tsexp(Qq);
P = Jjj;
if (!Kkk)
Dump(1, 2, Inc, 0, Rbase);
Csexp(3, 1);
if (!Kkk)
Prx(0x90, 3, 4, Rbase, Inc + 4);
else
Prx(0x90, 2, 4, Rbase, Inc);
P = Q;
Csexp(1, 1);
if (!Checksp)
goto L__202;
Dump(0, 2, Inc, 0, Rbase);
Ppj(17);
L__202:
Plab(-1);
Register[4] = 0;
Dump(1, 1, 0, 0, 4);
Push(Cycle[Level], K, Inc + 4096 * Bxle);
goto L__1;
Sw_3:;
Setline();
Pop(Cycle[Level], J, K);
if (J != -1)
goto L__302;
Fault(1);
goto L__1;
L__302:
Bxle = K >> 12;
K = K & 4095;
Prx(0x98, 2, 4, Rbase, K);
Dump(2, 1, 0, 0, 4);
if (Bxle == 1)
goto L__301;
Plant(0x1A12);
Pconst(0x59304000);
K = J;
Pj(7, K);
goto L__1;
L__301:
I = Find(J, Label[Level]);
Prx(0x87, 1, 2, 10, I - Codebase[Level]);
goto L__1;
Sw_4:;
K = A[P + 2] + ((A[P + 1] - 1) << 14);
if (Find(K, Label[Level]) == -1)
goto L__402;
Fault(2);
goto L__1;
L__402:
Plab(K);
goto L__1;
Sw_5:
Q = P + 1;
Marker2 = P + 3 + A[P + 2];
Setline();
P = Marker2;
Save13 = R13;
Chnge13 = 0;
if (A[P] == 3)
goto L__510;
if (A[P] == 9)
goto L__520;
Plabel -= 2;
Jjj = Plabel + 1;
Kkk = Plabel;
P = Q + 2;
Ccond(A[Q] - 1, Jjj, Kkk);
Plocaljump(Mask, Kkk);
if (R13 != Save13 || Chnge13 != 0)
R13 = 0;
Push(Locallabel, Ca, Jjj);
P = Marker2;
Cui(1);
if (A[P] != 1)
goto L__104;
P++;
if (A[P] == 9)
goto L__107;
Plabel--;
Jjj = Plabel;
Plocaljump(15, Jjj);
Push(Locallabel, Ca, Kkk);
if (R13 != Save13 || Chnge13 != 0)
R13 = 0;
Mask = 15;
Cui(2);
Kkk = Jjj;
goto L__104;
L__107:
Pj(15, Sflabel - 1);
Cui(2);
goto L__104;
L__510:
Plabel--;
Jjj = Plabel;
Nmdecs[Level] = 1;
Kkk = A[P + 2] + ((A[P + 1] - 1) << 14);
P = Q + 2;
Ccond(2 - A[Q], Jjj, Kkk);
Plocaljump(Mask, Kkk);
if (R13 != Save13 || Chnge13 != 0)
R13 = 0;
Push(Locallabel, Ca, Jjj);
P = Marker2 + 3;
if (A[P] != 1)
goto L__102;
P++;
Mask = 15;
Cui(0);
goto L__102;
L__520:
Plabel--;
Jjj = Plabel;
Kkk = Sflabel - 1;
P = Q + 2;
Ccond(A[Q] - 1, Jjj, Kkk);
Plocaljump(Mask, Kkk);
if (R13 != Save13 || Chnge13 != 0)
R13 = 0;
Push(Locallabel, Ca, Jjj);
P = Marker2;
Cui(1);
P++;
if (A[P] == 1)
Fault(53);
goto L__102;
Sw_6:
L__1:;
return;
Sw_7:;
if (Level < 2)
Fault(57);
if (Nmdecs[Level])
Fault(40);
P++;
Clt();
Rout = 0;
if (Type == 5 && Acc == 0)
Fault(70);
if (A[P] == 1)
goto Scalar;
if (A[P] == 3)
goto Vector;
Arr = 1;
Nam = (2 - A[P + 1]) << 1;
Pack(Ptype);
P += 2;
Setline();
if (Nam)
Acc = 4;
Cadcln(0);
goto L__1;
Vector:
Arr = 2;
Nam = 0;
Pack(Ptype);
P++;
Setline();
Cvdecln();
goto L__1;
Scalar:
J = 0;
Rout = 0;
Cqn(P + 1);
P += 2;
Inc = N;
Qq = Acc;
if (Type == 5)
Acc = 4;
Jj = 0;
if (Acc != 8 || (N & 7) == 0)
goto L__701;
Push(Wsp[Level], 0, N);
N += 4;
L__701:
if (Type == 5)
Setline();
Pack(Ptype);
for (Kk = 1; Kk <= A[P]; Kk++) {
K = A[P + Kk];
Testnst();
Storetag(K, N);
if (Type != 5)
goto L__705;
Jj += Qq;
if (Unass == 1)
Pss(0xD2, 2, Wspr, 0, Gla, 128);
Prx(0x50, Wspr, Rbase, 0, N);
Psi(0x92, Qq - 1, Rbase, N);
if (Kk == A[P])
Qq = Qq + ((Jj + 7) & (-8)) - Jj;
Prx(0x41, Wspr, Wspr, 0, Qq);
L__705:
N += Acc;
}
N += 3;
N = N & (-4);
if (Unass == 1 && Type != 5)
Set80(Inc, N - Inc);
goto L__1;
Sw_8:;
Cend(Flag[Level]);
goto L__1;
Sw_9:
P++;
Marker1 = A[P] + P;
L__900:
Q = P;
Kkk = A[Marker1 + 1];
Extrn = A[P + 1];
if (A[Marker1] == 2)
goto L__902;
P++;
Crspec(0);
if (Extrn == 3)
goto L__1;
N0--;
Kk = 'S' * (2 - Extrn);
Gxref(Kkk, Kk);
Jj = Tags[Kkk];
From1(Jj, Q);
Replace1(Jj, Q & (-2));
goto L__1;
L__902:
Filljumps(Level);
Kk = Kkk;
Copytag(Kkk);
if (Oldi != Level)
goto L__939;
if (Extrn != 3) {
if (!Cprmode)
Cprmode = 2;
if (Cprmode != 2 || Level != 1)
Fault(55);
Defineep(Extrn, Kkk, Ca);
Pclod(0);
}
if (A[P + 2] == 1)
goto L__908;
Rout = 1;
P += 3;
Clt();
Arr = 0;
Nam = (A[P] - 1) << 1;
Pack(Kkk);
goto L__909;
L__908:
Kkk = 10000;
L__909:
if (J == 15 && Ptype == Kkk)
goto L__940;
Fname = Kk;
if ((Ptype & 7) != 7)
Fault(7);
L__939:
P = Q + 1;
Crspec(0);
P = Q;
goto L__900;
L__940:
J = 0;
Replacetag(Kk);
Jj = K;
Plabel--;
if (Compiler != 1 && (Cprmode != 2 || Level != 1))
Pj(15, Plabel);
Ral[Level] = Nmax << 16 | Sbflag << 15 | N;
Rhead(Kk);
if (Extrn != 3)
Ppj(40);
Flag[Level] = Ptype;
P = Marker1 + 1;
if (A[P + 1] == 2)
goto L__942;
L__943:
P += 2;
Compileformalparameter();
for (Bxle = 1; Bxle <= A[P]; Bxle++) {
Mlink(Jj);
if (Jj)
goto L__945;
Fault(8);
goto L__946;
L__945:
Fromlist(Jj, J, Jjj);
if (J == Ptype && (Ptype != 5 || Jjj == Acc))
goto L__946;
Fault(9);
Printname(A[P + Bxle]);
L__946:
K = A[P + Bxle];
Testnst();
Ophead = 0;
Unpack();
if (Rout == 1)
goto L__947;
if (Ptype == 5)
goto L__9040;
J = Jjj;
if (Type == 3)
goto L__948;
R = N;
if (Arr == 1)
goto L__950;
if (Prec == 3 && Nam == 0)
goto L__949;
N = N + 4 - Acc;
R = N;
L__950:
Storetag(K, N);
N = R + Acc;
goto L__999;
L__947:
Push(Ophead, N, 1000);
J = 13;
L__951:
Kk = Ophead;
R = N;
N = Kk;
goto L__950;
L__9040:
Prx(0x41, 1, 0, Rbase, N + 4);
Prx(0x50, 1, 0, Rbase, N);
Psi(0x92, Jjj - 1, Rbase, N);
Storetag(K, N);
N += (Acc + 7) & (-4);
goto L__999;
L__948:
Push(Ophead, 0, N);
J = 0;
goto L__951;
L__949:
R = N;
if (!(N & 7))
goto L__950;
Push(Wsp[Level], 0, N);
N += 4;
R = N;
goto L__950;
L__999:;
}
P = P + 1 + Bxle;
if (A[P] == 1)
goto L__943;
L__942:
Mlink(Jj);
if (Jj)
Fault(10);
goto L__1202;
Sw_10:;
goto L__1;
Sw_11:;
Alllong = A[P + 1] & 1;
goto L__1;
Sw_12:;
Filljumps(Level);
Ral[Level] = Sbflag << 15 | N;
Ptype = 0;
Rhead(-1);
Flag[Level] = 0;
if (Level == 1 && 1 == Rlevel)
goto L__1;
if (Level != 2)
goto L__1202;
if (!Cprmode)
Cprmode = 1;
Defineep(0, 0, 0);
if (Cprmode != 1)
Fault(55);
L__1202:
Plant(0x05A0);
Codebase[Level] = Ca;
goto L__1;
Sw_13:;
if (Level != 2)
Fault(15);
if (Cprmode != 1)
Fault(56);
Perm = 0;
Cend(1);
Loaddata();
goto L__1;
Sw_14 :
{
__label__ L__1;
R13 = 0;
Mone = 1;
Copytag(A[P + 1]);
if (Oldi == Level && Type == 6)
goto L__1401;
Fault(4);
goto L__1;
L__1401:
Fromlist(K, Acc, Kkk);
Mlink(K);
Fromlist(K, Qq, Kk);
if ((A[P + 3] & 7) != 1)
goto L__1411;
if (A[P + 3] == 9)
Jj = A[P + 4];
else {
Fromar4(P + 4, Jj);
P++;
}
if (A[P + 2] == 2)
Jj = -Jj;
if (Kkk <= Jj && Jj <= Kk)
goto L__1402;
L__1411:
Fault(5);
goto L__1;
L__1402:
Q = Jj - Kkk;
L__1404:
if (31 >= Q)
goto L__1403;
Mlink(K);
Q -= 32;
Fromlist(K, Qq, Jjj);
goto L__1404;
L__1403:
Jjj = 1 << Q;
if (Jjj & Qq)
Fault(6);
Replace1(K, Qq | Jjj);
Q = Ca - Codebase[Level];
if (Prec)
goto L__1407;
Qq = Acc + 8 + ((Jj - Kkk) << 2);
if (Q >> 16)
Plug(Qq, Q >> 16);
L__1406:
Plug(Qq + 2, Q & 0xFFFF);
goto L__1;
L__1407:
Qq = Acc + 6 + ((Jj - Kkk) << 1);
if (Q > 0x7FFF)
Fault(99);
goto L__1406;
L__1:;
}
goto L__1;
Sw_15 :
{
__label__ L__1;
int Bp;
int Qqq;
Q = P;
Cnop(0, 4);
Pj(15, Plabel - 1);
if (Level < 2)
Fault(56);
L__1528:
P = Q + A[Q + 1] + 2;
Cbpair(Kkk, Kk);
if (abs(Kkk) >= 0x7FFF || 0x7FFF <= abs(Kk))
goto L__1501;
if (Kkk <= Kk)
goto L__1535;
Fault(27);
Kk = Kkk;
L__1535:
for (Qq = 1; Qq <= A[Q + 1]; Qq++) {
K = A[Q + Qq + 1];
Testnst();
Prec = 0;
if (Sbflag == 1 || Compiler == 1)
Prec = 2;
Type = 6;
Rout = 0;
Nam = 0;
Arr = 1;
Pack(Ptype);
Ophead = Newcell();
Jj = Ophead;
J = 0;
Storetag(K, Ophead);
R = Kkk;
Insertafter(Ophead, 0, Kk);
L__1503:
if (Kk - R < 32)
goto L__1504;
Insertafter(Ophead, 0, 0);
R += 32;
goto L__1503;
L__1504:
Replaceboth(Jj, Ca, Kkk);
Pconst(Kkk & 0xFFFFFF | Prec << 24);
Pconst(Kk);
Jjj = Kk - Kkk;
if (Prec == 2)
Jjj = (Jjj + 1) / 2;
for (I = 0; I <= Jjj; I++)
Pconst(0);
}
Q = P;
if (A[Q] != 2)
goto L__1528;
Plab(-1);
goto L__1;
L__1501:
Fault(18);
Kk = 0;
Kkk = 0;
goto L__1535;
L__1:;
}
goto L__1;
Sw_16:
Qu = ~A[P + 1] & 1;
P += 2;
goto L__1;
Sw_17:;
Kk = Claimablereg();
if (!Kk)
goto L__1999;
Register[Kk] = -Level;
Uvarreg[Kk] = Level;
Ptype = 8;
J = 0;
K = A[P + 1];
Testnst();
Storetag(K, Kk);
goto L__1;
Sw_18:;
{
__label__ L__1;
__label__ L__99;
int Wsp1;
int Length;
int Bp;
int Pp;
int Sign;
int *Var;
if (Nmdecs[Level])
Fault(40);
P++;
Clt();
if (Type == 5 && Acc == 0)
Fault(70);
Nam = 0;
Rout = 0;
Arr = A[P] - 1;
Pack(Ptype);
Pp = P + 1;
P += 2;
if (Arr)
goto Nonscalar;
if (A[P] != 2)
goto L__1801;
A[P + 1] = 4;
A[P + 2] = 9;
A[P + 3] = 0;
L__1801:
Sign = A[P + 1];
if (Type == 5)
goto L__1820;
Jj = Sortconst(P + 2, Prec & 1, Type);
if (Type == 2)
goto L__1810;
Var = &St[N0 - 1];
if ((Prec == 1 && *Var > 255) || (Prec == 2 && abs(*Var) >> 16 != 0))
Fault(44);
if ((A[P + 2] & 7) == 2)
Fault(44);
if (Sign == 2)
*Var = -*Var;
if (Sign == 3)
*Var = ~*Var;
L__1803:
K = A[Pp];
Testnst();
if (Prec != 3)
Jj = Jj + 4 - Bytes[Prec];
Push(Tags[K], Ptype << 16 | Level << 8 | Gla << 4, Jj);
Push(Name[Level], 0, K);
goto L__99;
L__1810:
if (Sign == 3)
Fault(44);
if (Sign != 2)
goto L__1803;
St[Jj >> 2] = St[Jj >> 2] | 0x80000000;
goto L__1803;
L__1820:;
if (A[P + 2] != 9 || A[P + 3] >= 127)
goto L__1822;
A[P + 2] = 5;
A[P + 4] = A[P + 3];
A[P + 3] = 1;
L__1822:
if (Sign != 4 || A[P + 2] != 5 || A[P + 3] >= Acc)
Fault(44);
Qq = Constptr << 2;
for (Jj = 0; Jj <= (Acc - 1) & (-4); Jj += 4) {
Wsp1 = A[P + Jj + 3] << 8 | A[P + Jj + 4] & 255;
Wsp1 = Wsp1 << 8 | A[P + Jj + 5] & 255;
Wsp1 = Wsp1 << 8 | A[P + Jj + 6] & 255;
Psym(Wsp1);
}
Prx(0x58, 2, 0, Gla, 8);
Loadad(1, 2, Gla, Qq);
Prx(0x50, 1, 0, Rbase, N);
Psi(0x92, Acc - 1, Rbase, N);
K = A[Pp];
Testnst();
J = 0;
Storetag(K, N);
N += 4;
goto L__99;
Nonscalar:
Cbpair(Kk, Kkk);
if (Type == 5)
Bp = Acc;
else
Bp = Bytes[Prec];
Length = Kkk - Kk + 1;
if (!A[P + 1])
goto L__3;
L__1:
if (Kkk < Kk || Length != A[P + 1])
Fault(45);
Qq = Constptr << 2;
Jj = A[P + 2] << 2; // OUTPUT AN ARRAYHEAD RELATIVE TO Qq
St[N0] = Jj - Kk * Bp;
St[N0 + 1] = Jj;
St[N0 + 2] = Qq;
St[N0 + 3] = Ownlink; // NOW OUTPUT DOPE Vector
Psym(1 << 16 | Bp);
Psym(Kk);
Psym(Kkk); // NOW PLANT Code
K = A[Pp];
J = 1;
Testnst();
Ownlink = N0 << 2;
Rbase = Gla;
Storetag(K, Ownlink);
Rbase = 10 - Rlevel;
N0 += 4;
goto L__99;
L__3:
A[P + 2] = Constptr;
A[P + 1] = Length;
if (Length < 1)
goto L__1;
for (Jj = 1; Jj <= (Length * Bp + 3) / 4; Jj++)
Psym(0);
goto L__1;
L__99:;
}
goto L__1;
Sw_19:;
Copytag(A[P + 3]);
if (A[P + 2] == 1)
goto L__1910;
if (Arr != 0 || Type != 3)
goto L__1999;
From2(K, K);
goto L__1920;
L__1910:
if (Arr != 1 || Type > 3 || J > 2)
goto L__1999;
L__1920:
if (A[P + 1] == 2)
goto L__1930;
Kk = Claimablereg();
if (!Kk)
goto L__1999;
Register[Kk] = A[P + 3] + 1;
Prx(0x58, Kk, 0, I, K);
Jj = Tags[A[P + 3]];
From1(Jj, Jjj);
Jjj = Jjj | Kk << 12;
L__1925:
Replace1(Jj, Jjj);
goto L__1;
L__1930:
if (Inreg == 0 || Register[Inreg] != A[P + 3] + 1)
goto L__1999;
Register[Inreg] = 0;
Jj = Tags[A[P + 3]];
From1(Jj, Jjj);
Jjj = Jjj & 0xFFFF0FFF;
goto L__1925;
L__1999:
Fault(58);
goto L__1;
Sw_26:
Compiler = 1;
Unass = 0;
goto L__1;
Sw_27:;
P++;
if (A[P + 1] == 1)
goto L__2701;
Crspec(2);
goto L__1;
L__2701:
Copytag(A[P]);
if (Ptype != 4 || A[P + 4] != 2 || 2 != A[P + 3])
goto L__3901;
P += 2;
K = Displacement(Tags[A[P - 2]]);
if (K == -1)
goto L__1;
Ophead = K;
P += 2;
Crspec(3);
goto L__1;
Sw_20:
Mcswitch = 1;
Perm = 1;
goto L__1;
Sw_21:
Sbflag = 1;
goto L__1;
Sw_22:
P = 2;
Cuci();
goto L__1;
Sw_23:;
if (Level != 2 || Cprmode == 2)
Fault(26);
P++;
Q = P + 1;
L__2302:
if (A[Q] == 2)
goto L__2303;
Q += 2;
goto L__2302;
L__2303:
K = A[Q + 2] + ((A[Q + 1] - 1) << 14);
Kkk = A[P];
Pconst(0x41100000 | Kkk);
if (Kkk > 32 || Kkk == 0 || Kkk == 29 || 12 <= Kkk && Kkk <= 13)
Fault(36);
Ppj(20);
Qq = Ca;
Pj(15, K);
if (Ca != Qq + 8)
Pconst(0x07000700);
P += 2;
if (A[P - 1] == 1)
goto L__2303;
if (A[P + 2] == 2)
goto L__1;
P += 3;
Q = P + 1;
goto L__2302;
Sw_24:
if (Cprmode != 2 || Rlevel != 1)
Fault(56);
Loaddata();
Finalise();
exit(0);
Sw_25:
Mcswitch = 0;
Perm = 0;
goto L__1;
Sw_28:;
J = 0;
Ptype = 10006;
Storetag(A[P + 1], Snum);
Snum++;
goto L__1;
Sw_29:
List = 1;
goto L__1;
Sw_30:
List = 0;
goto L__1;
Sw_31:;
if (A[P + 1] == 9)
J = A[P + 2];
else
Fromar4(P + 2, J);
K = J & 15;
if (K != 15)
Linenos = K;
K = J >> 4 & 15;
if (K != 15)
Diags1 = K;
K = J >> 8 & 15;
if (K != 15)
Checks = K;
if (K != 15)
Checksp = K & 14;
K = J >> 12 & 15;
if (K != 15)
Unass = K;
K = J >> 28;
if (K != 15)
Dcomp = K;
goto L__1;
Sw_32:
Pop(Sbr[Level], J, K);
if (J != -1)
goto L__321;
Fault(51);
goto L__1;
L__321:
Pop(Cycle[Level], Jj, Kk);
if (0 >= Jj)
goto L__322;
Fault(52);
goto L__321;
L__322:
if (A[2] != 1)
goto L__402;
if (J != 1)
Fault(47);
P += 2;
Kk = K;
Mone = 0;
R13 = 0;
Setline();
if (A[P] == 9)
Jj = Sflabel - 1;
else
Jj = Plabel - 1;
Pj(15, Jj);
Plab(Kk);
Cui(2);
Plab(-1);
goto L__1;
Sw_33:;
if (Level < 2)
Fault(56);
Setline();
Crformat();
goto L__1;
Sw_34:;
{
__label__ Scalar;
__label__ L__1;
auto void Testandset(void);
Setline();
P++;
Marker1 = P + A[P];
if (Level < 2)
Fault(57);
if (Nmdecs[Level])
Fault(40);
Checkrf();
if (K == -1)
goto L__1;
Type = 3;
Prec = 0;
Rout = 0;
if (A[P + 1] == 1)
goto Scalar;
if (A[P + 2] != 2)
Fault(41);
Nam = 0;
Arr = 1;
Pack(Ptype);
P += 3;
L__3401:
Qq = P + 1;
Pss(0xD2, 4, Wspr, 0, 4, 0);
Cadcln(2);
for (Q = 1; Q <= A[Qq]; Q++) {
K = A[Q + Qq];
Testandset();
Ppj(13);
Prx(0x90, 0, 3, Rbase, N);
N += 16;
}
if (A[P] == 2)
goto L__1;
P++;
Checkrf();
goto L__3401;
Scalar:
Cqn(P + 2);
P += 3;
J = 0;
Pack(Ptype);
for (Q = 1; Q <= A[P]; Q++) {
K = A[P + Q];
Testandset();
if (Nam == 1)
Pss(0xD2, 4, Rbase, N, Gla, 128);
else
Paclod(18, 2, Rbase << 12 | N); // = ST WSP,? - AH WSP,LENGTH - LA
// WSP,7(WSP) - N WSP,=F'-8'
N += 4;
}
goto L__1;
void Testandset(void) {
Testnst();
Jjj = Newcell();
Storetag(K, Jjj);
Replaceboth(Jjj, Tags[A[Marker1]], N);
}
L__1:;
}
goto L__1;
Sw_35:;
P++;
Marker1 = P + A[P];
if (A[P + 1] == 1)
goto L__3801;
Rout = 1;
P += 2;
Clt();
Arr = 2 - A[P + 1];
Nam = (A[P + 2] - 1) << 1;
Pack(Ptype);
goto L__3802;
L__3801:
Ptype = 11000;
L__3802:
J = 0;
for (Kk = 1; Kk <= A[Marker1]; Kk++) {
K = A[Marker1 + Kk];
Testnst();
Ophead = 0;
Push(Ophead, N, 1000);
Storetag(K, Ophead);
N += 40;
}
goto L__1;
Sw_36:;
P++;
Marker1 = P + A[P];
Checkrf();
if (K == -1)
goto L__1;
P++;
Copytag(A[P]);
if (A[P + 1] == 1)
goto L__3910;
if (Type == 3 && Nam == 1)
goto L__3902;
L__3901:
Fault(63);
goto L__1;
L__3902:
From1(K, Q);
if (Q)
Fault(63);
Replace1(K, Tags[A[Marker1]]);
goto L__1;
L__3910:;
P += 2;
K = Displacement(Tags[A[P - 2]]);
if (K == -1)
goto L__3901;
goto L__3902;
Sw_37:
goto L__1;
void Cend(int Kkk) {
__label__ L__99;
int Dptr;
int Lnum;
int W1;
int W2;
int Dd[301 /*0:300*/];
Setline();
R13 = 0;
Mone = 1;
L__1:
Fromlist(Sbr[Level], J, K);
if (J == -1)
goto L__2;
Fault(53);
A[2] = 32;
A[3] = 2;
Css(2);
goto L__1;
L__2:
Filljumps(Level);
if (N > Nmax)
Nmax = N;
Pop(Jump[Level], J, K);
if (J == -1)
goto L__3;
if (K >= Sflabel)
goto L__2;
Fault(11);
if (K < 16384)
Write(K, 4);
else
Printname(K - 16384);
goto L__2;
L__3:
Clearlist(Label[Level]);
Clearlist(Wsp[Level]);
Clearlist(Lwsp[Level]);
Clearlist(Mdarr[Level]);
Clearlist(
Strwsp[Level]); // CLEAR DECLARATIONS -PLANT DIAGNOSTICS IF REQUIRED
if (!Diags1)
goto L__10;
Lnum = Lett[M[Level]];
Dd[0] = 0xC2C2C2C2;
Dd[1] = L[Level] << 16 | Rbase << 8 | Lnum;
Dptr = 3;
if (Lnum)
goto L__9;
Dd[2] = L[Level - 1];
goto L__10;
L__9:
W1 = M[Level];
for (W2 = 1; W2 <= Lnum; W2++) {
*Byteinteger(Addr(Dd[0]) + 7 + W2) = Lett[W1 + W2];
}
Dptr += (Lnum - 1) >> 2;
L__10:
Pop(Name[Level], J, Jj);
if (J == -1)
goto L__20;
Copytag(Jj);
Pop(Tags[Jj], Kk, Kk);
if (Ptype == 8) {
Register[K] = 0;
Uvarreg[K] = 0;
}
if (Inreg)
Register[Inreg] = 0;
if (J != 15)
goto L__12;
Fault(28);
Printname(Jj);
L__12:
Ophead = K;
if (Type == 4)
goto L__13;
if (Rout != 1 && Type != 3 && Type != 6 && Arr != 2)
goto L__14;
Clearlist(Ophead);
goto L__10;
L__13:
Undcrf(Ophead);
goto L__10;
L__14:
if (Type != 1 && Type != 2 && Type != 5)
goto L__10;
if (Arr != 0 || Diags1 != 1 || Rout != 0)
goto L__10;
if (Dptr > 297)
goto L__10;
Q = Word[Jj];
Lnum = Lett[Q];
if (Lnum > 8)
Lnum = 8;
Ptype = Nam << 6 | Prec << 3 | Type;
Dd[Dptr] = Ptype << 24 | I << 20 | K << 8 | Lnum;
for (W1 = 1; W1 <= Lnum; W1++)
*Byteinteger(Addr(Dd[Dptr]) + W1 + 3) = Lett[W1 + Q];
Dptr = Dptr + 1 + ((Lnum + 3) >> 2);
goto L__10;
L__20:
if (!Diags1)
goto L__21;
Dd[Dptr] = -1;
Lput(4, (Dptr << 2) + 4, Sstl, Addr(Dd[0]));
Sstl = Sstl + (Dptr << 2) + 4; // CHECK CYCLE-REPEATS
L__21:
if (!Cycle[Level])
goto L__22;
From2(Cycle[Level], J);
if (!J)
goto L__22;
Pop(Cycle[Level], I, I);
Fault(13);
goto L__21;
L__22: // GARBAGE COLECT DICTIONARY
Next = Rnext[Level];
for (W1 = 0; W1 <= Nnames; W1++)
if (Word[W1] > Next)
Word[W1] = 0; // PLANT ANY NECESSARY Code
Nmax = (Nmax + 7) & (-8);
if (Nmax > 4092)
Fault(99);
if (Kkk >= 10000 || Kkk == 1)
Plug(Set[Rlevel], Nmax);
if (Kkk == 10000)
goto L__23;
if (!Kkk)
goto L__24;
if (Kkk > 10000 && Compiler == 0) {
Pconst(0x4100000B);
Ppj(21);
}
if (Kkk == 1)
Ppj(6);
goto L__30;
L__23:
P++;
A[P] = 5;
Cui(0);
goto L__30;
L__24:
Jj = 0xFFF & Ral[Level - 1];
Prx(0x98, 10, 11, Rbase, Jj);
if (Diags1 == 1)
Pss(0xD2, 4, Gla, 20, Rbase, Jj + 8);
L__30:
if (Kkk == 2)
goto L__99;
Newline();
if (Printmap == 1 && List == 1 && Kkk != 0) {
printf("%s", " LOCALS EXTEND TO ");
Write(Nmax, 2);
Newline();
}
if (List)
goto L__31;
Write(Line, 5);
Spaces(3 * Level - 3);
printf("%s", "END");
L__31:
if (Level > 2 || Perm == 1 || Cprmode == 2)
goto L__33;
if (Kkk == 1)
goto L__32;
Fault(14);
A[1] = 13;
goto L__99;
L__32:
Kkk = 2;
L__33:
Level--;
if (Kkk >= 10000)
Rlevel--;
Rbase = 10 - Rlevel;
Register[9 - Rlevel] = 0;
N = Ral[Level];
Sbflag = N >> 15 & 1;
if (Kkk >= 10000)
Nmax = N >> 16;
N = N & 4095;
if (Kkk == 2)
goto L__2;
if (Rlevel == 1 && Cprmode == 2)
goto L__99;
if (Kkk == 0 || Compiler == 1)
goto L__99;
From2(Jump[Level], J);
Plab(J);
L__99:;
}
void Crspec(unsigned char M) {
__label__ L__99;
int Pp;
int Kk;
int Jj;
int Jjj;
int Q;
int Typep;
if (M == 3)
goto L__12;
Pp = P;
if (M != 2)
goto L__2;
Kk = A[P];
P++;
Copytag(Kk);
if (Oldi == Level && 10006 != Ptype && Ptype >= 10000)
goto L__1;
Fault(3);
goto L__99;
L__1:
Fromlist(K, Jj, Q);
Ophead = K;
if (Q == 1000)
goto L__12;
goto L__10;
L__2:
if (A[Pp + 1] == 2)
goto L__3;
Typep = 10000;
P = Pp + 3;
goto L__4;
L__3:
Rout = 1;
Arr = 0;
P = Pp + 2;
Clt();
Nam = (A[P] - 1) * 2;
Pack(Typep);
P += 2;
L__4:
Kk = A[P];
Copytag(Kk);
if (Oldi != Level)
goto L__11;
if (Ptype == Typep || abs(Ptype - Typep) == 1000)
goto L__1;
L__10:
Fname = Kk;
if (Ptype != 7)
Fault(7);
if (M == 2)
goto L__99;
L__11:
Jj = Nr;
Nr++;
Ra[Jj] = 4 * N0;
N0++;
if (Nr > Nrouts)
Fault(109);
Ophead = Newcell();
J = 15;
Ptype = Typep;
Storetag(Kk, Ophead);
L__12:
Jjj = Ophead;
Q = 0;
if (A[P + 1] == 2)
goto L__24;
L__13:
P += 2;
Compileformalparameter();
for (Pp = 1; Pp <= A[P]; Pp++) {
Kk = 0;
if (Ptype == 5)
Kk = Acc;
Insertafter(Ophead, Ptype, Kk);
Q++;
}
P = P + Pp + 1;
if (A[P] == 1)
goto L__13;
L__24:
Replace2(Jjj, Q);
if (M == 3)
goto L__99;
Replace1(Jjj, Jj);
L__99:;
}
void Compileformalparameter(void) {
static int Fpd_sw;
static void *Fpd[5 /*1:5*/] = {
&&Fpd_1, &&Fpd_2, &&Fpd_3, &&Fpd_4, &&Fpd_default,
};
goto *Fpd[Fpd_sw = (A[P]) - 1];
Fpd_1:;
Acc = 16;
Rout = 1;
Nam = 1;
Arr = 0;
if (A[P + 1] != 1)
goto L__1;
Prec = 0;
Type = 0;
P += 3;
goto L__98;
L__1:
P += 2;
Clt();
Nam = 2 * (A[P] - 1) + 1;
P += 2;
Acc = 16;
goto L__98;
Fpd_2:;
P++;
Clt();
Cqn(P);
Rout = 0;
if (Type == 5 && Acc == 0)
Fault(70);
P++;
goto L__98;
Fpd_3:;
Type = 0;
L__31:
Nam = 1;
Arr = 2 - A[P + 1];
Rout = 0;
Acc = 4 + 12 * Arr;
Prec = 0;
P += 2;
goto L__98;
Fpd_4:
Type = 3;
goto L__31;
L__98:
Pack(Ptype);
goto Fpd_skip;
Fpd_default:
fprintf(stderr, "Switch label 'Fpd(%d):' not set in %s", Fpd_sw + 1,
__PRETTY_FUNCTION__);
exit(1) /* or %signal ... */;
Fpd_skip:;
}
void Assign(int P1, int P2) {
int Q;
int Assop;
int Kk;
int Reg;
int Precp;
int Z;
int Zp;
int Typep;
int Jjj;
static int Sw_sw;
static void *Sw[4 /*1:4*/] = {
&&Sw_1,
&&Sw_2,
&&Sw_3,
&&Sw_4,
};
static int S_sw;
static void *S[16 /*0:15*/] = {
&&S_0, &&S_1, &&S_2, &&S_3, &&S_4, &&S_5,
&&S_6, &&S_7, &&S_8, &&S_default, &&S_10, &&S_11,
&&S_12, &&S_default, &&S_14, &&S_default,
};
Assop = A[P2];
goto *Sw[Sw_sw = (Assop)-1];
Sw_2:
Sw_3:
Copytag(A[P1 + 1]);
P = P2 + 1;
if (Type == 8)
goto Regvar;
if (Rout == 1)
goto Maps;
if (Type == 2)
goto L__34;
if (Type == 5)
goto L__50;
if (Type == 3)
goto L__35;
if (Nam == 0 && Type == 1 && Arr == 0)
goto L__32;
L__33:
P = P2 + 1;
Kk = 0;
if (Arr != 0 || Rout != 0 || 1 < Type)
Kk = 4;
L__36:
if (Kk == 4 && Register[4] != 0)
Kk = 14;
Csexp(Kk, 1);
Reg = Nest;
Kk = P;
if (!Register[Reg])
Register[Reg] = 1;
P = P1 + 1;
Cname((Assop - 1) * (Assop - 1), Reg);
if (Register[Reg] > 0)
Register[Reg] = 0;
L__30:;
P = Kk;
if (A[P] == 1 && 1 == Qu)
Cquery(Reg);
P++;
goto L__1;
L__31:
printf("%s", " CRUNCH ");
_imp_monitor(0);
exit(0);
L__32:
if (Rout == 1 || A[P1 + 2] == 1 || A[P1 + 3] == 1)
goto L__33;
if (Unass == 1)
goto L__33;
Precp = Prec;
Typep = Ptype;
Kk = K;
Reg = I;
Q = Tsexp(Jjj);
Ptype = Typep;
Unpack();
if (Q == 0 || A[P] == 1 && 1 == Qu)
goto L__33;
if (10 <= Q && Q <= 12 && Q - 10 == Precp)
goto L__37;
if (Q != 1 || Precp != 1)
goto L__33;
Psi(0x92, Jjj, Reg, Kk);
P++;
goto L__1;
L__37:
Pss(0xD2, Bytes[Precp], Reg, Kk, I, K);
P++;
goto L__1;
L__34:
Q = 2;
if (Prec == 3)
Q = 3;
if (A[P1 + 2] == 1) {
P = P1 + 2;
Fflag = 0;
Skipapp();
if (Fflag)
goto L__55;
P = P2 + 1;
}
Csexp(0, Q);
Kk = P;
Freg[Nest] = 1;
Reg = Nest;
P = P1 + 1;
Cname(1, Nest);
Freg[Reg] = 0;
goto L__30;
L__35:
P = P1 + 1;
Q = Copyrecordtag();
P = P2 + 1;
if (Type != 2 && Type != 5)
Type = 1;
if (Type == 5)
goto L__50;
Kk = 4;
if (Type == 1)
goto L__36;
goto L__34;
L__50:
Cstrexp(4);
Kk = P;
Register[4] = 1;
P = P1 + 1;
Cname(REXP((Assop - 1), 2), 4);
Register[4] = 0;
Reg = 4;
goto L__30;
Maps:
if (Ptype == 10006) {
Type = Tsname[K];
Prec = Type >> 3;
Type = Type & 7;
}
if (Type == 1)
goto L__33;
if (Type == 5)
goto L__50;
L__55:
P = P2 + 1;
Precp = Prec;
Csexp(0, 2 + (Prec & 1));
Q = Parkf(Nest, 3);
Kk = P;
P = P1 + 1;
Cname(3, 1);
Dump(16, 0, Q, 0, Rbase);
Dump(9 + 2 * Prec, 0, 0, 0, 1);
Push(Lwsp[Level], 0, Q);
goto L__30;
Regvar:
if (A[P1 + 2] != 2 || 2 != A[P1 + 3])
Fault(59);
Kk = K;
Csexp(Kk, 1);
Register[Kk] = -1;
if (A[P] == 1 && 1 == Qu)
Cquery(Reg);
P++;
goto L__1;
Sw_4:;
P = P1 + 1;
Cname(2, 1);
P = P2 + 1;
Cres(0, 0);
P++;
goto L__1;
Sw_1:;
P = P1 + 1;
Copytag(A[P]);
if (I == -1)
goto L__9;
Q = 1;
if (Type == 3)
Q = Copyrecordtag();
if (!Q)
goto L__201;
if (A[P2 + 1] != 4 || A[P2 + 2] != 1)
Fault(81);
if (Rout == 1)
goto L__101;
Nest = 4;
goto *S[S_sw = ((Nam & 2) + Arr) << 2 | (Nam & 1) * 2 | (2 - A[P + 1])];
L__9:
Fname = A[P];
Fault(16);
S_0:
S_1:
S_3:
S_4:
S_5:;
S_7:
S_8:
S_10:
S_11:
S_12:;
L__10:
Fault(82);
P = P2 + 1;
Skipexp();
P++;
goto L__1;
S_2:;
Z = 3;
Zp = 6;
L__12:
P = P2 + 3;
Cname(Z, 4);
if (A[P] != 2)
goto L__10;
Precp = Prec;
Typep = Type;
Kk = P + 2;
P = P1 + 1;
Cname(Zp, 4);
L__14:;
P = Kk;
if (Prec == Precp && Type == Typep)
goto L__1;
Fault(83);
goto L__1;
S_6:;
S_14:;
Z = 12;
Zp = 11;
goto L__12;
L__201:;
if (Arr == 1 && Nam == 1 && A[P + 1] == 2)
goto *S[S_sw = 6];
Z = 15;
Zp = 14;
goto L__12;
L__101:
P = P1 + 1;
Cname(13, 1);
Precp = Prec;
Typep = Type;
Jjj = K;
if (J != 0 || Nam != 1)
goto L__10;
Reg = Findpp();
if (!Reg)
goto L__31;
Dump(0, Reg, Disp, Index, Base);
P = P2 + 3;
Cname(13, 1);
if (Base == Gla && J == 0)
goto L__102;
Pss(0xD2, 16, Reg, 0, Base, Disp);
if (J == 14)
goto L__103;
L__110:
Register[Reg] = 0;
Kk = P + 2;
From2(Jjj, Z);
From2(K, Zp);
if (Z != Zp)
Fault(83);
goto L__14;
L__102:
Dump(2, 2, Disp, Index, Base);
Prx(0x5A, 2, 0, Gla, 28);
Pconst(0x180C181D);
Prr(0x18, 3, Reg);
Prx(0x90, 0, 9, Reg, 0);
goto L__110;
L__103:
Prx(0x50, 9, 0, Reg, 12);
goto L__110;
L__1:;
goto S_skip;
S_default:
fprintf(stderr, "Switch label 'S(%d):' not set in %s", S_sw,
__PRETTY_FUNCTION__);
exit(1) /* or %signal ... */;
S_skip:;
}
void Cui(unsigned char Code) {
int Kk;
int Jj;
int Qq;
static int Sw_sw;
static void *Sw[11 /*1:11*/] = {
&&Sw_1, &&Sw_2, &&Sw_3, &&Sw_4, &&Sw_5, &&Sw_6,
&&Sw_7, &&Sw_8, &&Sw_9, &&Sw_10, &&Sw_11,
};
goto *Sw[Sw_sw = (A[P]) - 1];
Sw_1:
P++;
Marker1 = P + A[P];
if (A[Marker1] == 1)
goto L__3;
P++;
Cname(0, 0);
P++;
goto L__1;
L__3:
Assign(P, Marker1 + 1);
goto L__1;
Sw_2:;
Nmdecs[Level] = 1;
Copytag(A[P + 1]);
Ptypep = Ptype;
Kk = K;
P += 2;
if (Oldi == Level && Type == 6)
goto L__200;
Fault(4);
Skipexp();
goto L__1;
L__200:
Csexp(1, 1);
Ptype = Ptypep;
Unpack();
Fromlist(Kk, Qq, Jj);
Qq -= Codebase[Level];
if (!Checksp)
goto L__205;
L__201:
Loadad(2, 10, 0, Qq);
Ppj(7);
goto L__1;
L__205:
Jj = 8 + Qq - Jj * Bytes[Prec];
if (0 > Jj || Jj > 4095)
goto L__201;
if (!Prec)
goto L__210;
Plant(0x1A11);
Kk = 0x48;
L__207:
Prx(Kk, 1, 1, 10, Jj);
Pconst(0x47F1A000);
goto L__1;
L__210:
Pconst(0x89100002);
Kk = 0x58;
goto L__207;
Sw_3:;
Nmdecs[Level] = 1;
K = A[P + 2] + ((A[P + 1] - 1) << 14);
Pj(Mask, K);
P += 3;
goto L__1;
Sw_4:;
K = (A[P + 1] + 2) / 2;
P++;
Ppj(30);
for (Kk = 1; Kk <= K; Kk++) {
Plant(A[P] << 8 | A[P + 1]);
P += 2;
}
goto L__1;
Sw_5:;
if (Flag[Level] != 10000 && Perm != 1)
Fault(30);
P++;
L__6:
if (Diags1 == 1)
Pss(0xD2, 4, Gla, 20, Rbase,
0); // CHECK FOR REGISTER VARS & UPDATE CORE COPY
for (Kk = 5; Kk <= 8; Kk++)
if (0 != Uvarreg[Kk] && Uvarreg[Kk] < Level)
Prx(0x50, Kk, 0, Rbase, Kk << 2);
Prx(0x98, 4, 15, Rbase, 16);
R13 = 0;
Prr(7, 15, Link);
goto L__1;
Sw_6:;
P++;
Kk = Flag[Level];
if (Kk <= 10000)
Fault(31);
if (Kk == 10002)
goto L__61;
if (Kk == 10032)
goto L__62;
if (Kk == 10005)
goto L__63;
Csexp(1, 1);
goto L__6;
L__61:
Csexp(2, 2);
goto L__6;
L__62:
Csexp(2, 3);
goto L__6;
L__63:
Cstrexp(1);
goto L__6;
Sw_7:
Sw_8:;
Ppj(6 * (A[P] - 6));
P++;
goto L__1;
Sw_9:
Sflabel--;
Push(Sbr[Level], Code, Sflabel);
Push(Cycle[Level], 0, 0);
goto L__1;
Sw_11:;
Kk = 2 - A[P + 1];
P += 2;
Psi(0x92, Kk, Gla, 1);
goto L__1;
Sw_10:
Ppj(31);
P++;
L__1:;
}
void Crformat(void) {
int Lengthp;
int Qqq;
int Rep;
int Code;
K = A[P + 1];
Testnst();
J = 0;
Ptype = 4;
Ophead = Newcell();
Jjj = Ophead;
Storetag(K, Jjj);
P = 3;
Q = 0;
Inc = 4;
Incp = 0;
if (A[P] == 2)
goto L__101;
L__1:
P++;
Compileformalparameter();
Lengthp = Acc - 1;
if (Acc > 8)
Lengthp = 3;
L__2:
if (!(Incp & Lengthp))
goto L__3;
Incp++;
goto L__2;
L__3:
for (Rep = 1; Rep <= A[P]; Rep++) {
P++;
Code = 255;
Lengthp = Acc;
if (Rout == 1)
goto L__11;
if (Type == 3)
goto L__12;
Qqq = Incp;
if (Type != 5)
goto L__4;
Code = 250;
Lengthp = Acc - 1;
Qqq = Inc;
L__4:
Insertafter(Ophead, Ptype << 4 | A[P] << 20, Qqq);
Psi(0x92, Code, Rbase, N + Inc);
Psi(0x92, Lengthp, Rbase, N + Inc + 1);
Q++;
Inc += 4;
Incp += Acc;
goto L__15;
L__11:
Qqq = Newcell();
Replaceboth(Qqq, Incp, 100);
if (Ptype != 11000)
Fault(41);
Acc = 40;
Lengthp = Acc;
goto L__4;
L__12:
Qqq = Newcell();
Replaceboth(Qqq, 0, Incp);
goto L__4;
L__15:;
}
P++;
if (A[P] == 2)
goto L__101;
P++;
goto L__1;
L__101:
P++;
L__102:
if (A[P] == 2)
goto L__201;
P += 2;
Clt();
Nam = 2 * (2 - A[P]);
if (Nam)
Acc = 4;
P++;
Rout = 0;
Arr = 1;
Pack(Ptype);
L__103:;
Psi(0x92, 0, Rbase, N + Inc);
Dump(1, Wspr, N + Inc + 8, 0, Rbase);
Qq = P;
Cadcln(1);
Jj = P;
P = Qq + 2;
Rep = P + A[P - 1];
L__105:
Insertafter(Ophead, J | Ptype << 4 | A[P] << 20, Inc);
Inc += 16;
Q++;
P++;
if (P == Rep)
goto L__106;
Pss(0xD2, 16, Rbase, N + Inc, Rbase, N + Inc - 16);
goto L__105;
L__106:
P = Jj + 2;
if (A[P - 1] == 1)
goto L__103;
goto L__102;
L__201:
Replaceboth(Jjj, N, Q);
Prx(0x41, 1, 0, 0, Q);
Dump(5, 1, N, 0, Rbase);
Dump(0, 1, N, 0, Rbase);
Ppj(25);
N += Inc;
}
void Cadcln(unsigned char Mode) {
int Q;
int Qq;
int Kk;
int S;
int Jj;
int Jjj;
Q = P;
Ptypep = Ptype;
L__1:
P = A[Q + 1] + Q + 1;
Kk = 0;
if (Mode == 1)
goto L__4;
Prx(0x50, Wspr, 0, Gla, 36);
if (Unass == 1)
Psi(0x92, 1, Gla, 36);
L__4:
P += 2;
Jj = P;
Kk++;
Skipexp();
Qq = Tsexp(Jjj);
P = Jj;
if (!Qq)
Csexp(4, 1);
else
Csexp(1, 1);
Register[4] = 1;
Csexp(2, 1);
Register[4] = 0;
if (!Qq)
Prr(0x18, 1, 4);
if (Kk != 1)
goto L__41;
S = 1;
if (Mode != 2) {
S = 0;
Prx(0x41, 0, 0, 0, Acc);
}
Prx(0x90, S, 2, Wspr, 4 * S);
Psi(0x92, 3 - A[P], Wspr, 1);
Mover(Wspr, 16);
goto L__42;
L__41:
S = (Kk & 1) << 2;
if (!S)
Jjj = 8 * A[P];
else
Jjj = 16;
Prx(0x90, 1, 2, Wspr, S);
Mover(Wspr, Jjj);
L__42:
if (A[P] == 1)
goto L__4;
if (Kk <= 2)
goto L__5;
if (Kk > 6)
Fault(37);
Paclod(27, 3, Kk);
L__5:
Qq = Q + 1;
J = Kk;
Ptype = Ptypep;
if (Mode >= 1)
goto L__9;
for (Jjj = 1; Jjj <= A[Qq]; Jjj++) {
K = A[Qq + Jjj];
Testnst();
J = Kk;
Storetag(K, N);
Ppj(13);
Prx(0x90, 0, 3, Rbase, N);
N += 16;
}
Q = P + 2;
if (A[Q - 1] == 1)
goto L__1;
L__9:;
}
void Cvdecln(void) {
int Lb;
int Ub;
int Adv;
int Q;
int Qq;
int Range;
int Jjj;
int Kk;
int Disp0;
int Disp1;
Q = P;
P = A[Q + 1] + Q + 2;
Cbpair(Lb, Ub);
Adv = N0;
St[N0] = 1 << 16 | Acc;
St[N0 + 1] = Lb;
St[N0 + 2] = Ub;
Range = Ub - Lb + 1;
St[N0 + 3] = Range;
N0 += 4;
if (Lb > Ub)
Fault(44);
Prx(0x41, 2, 0, Gla, Adv << 2);
Prx(0x41, 3, 0, 0, Range);
Qq = Q + 1;
J = 1;
for (Jjj = 1; Jjj <= A[Qq]; Jjj++) {
N = (N + 7) & (-8);
Disp1 = N + 16;
Disp0 = Disp1 - Lb * Acc;
if (0 >= Disp0 || Disp0 >= 4095)
Fault(44);
Kk = Newcell();
Replaceboth(Kk, Disp0, N);
Prx(0x41, 0, 0, Rbase, Disp0);
Prx(0x41, 1, 0, Rbase, Disp1);
K = A[Qq + Jjj];
Testnst();
Storetag(K, Kk);
Prx(0x90, 0, 3, Rbase, N);
if (Unass == 1)
Set80(Disp1, Acc * Range);
N = Disp1 + Acc * Range;
}
P++;
if (A[P - 1] == 1)
Cvdecln();
N = (N + 3) & (-4);
}
void Csexp(int Reg, unsigned char Mode) { // MODE=1 FOR %INTEGER, =2REAL,
// =3LONG,=0INTEGER %IF PNS
__label__ L__99;
int C;
int D;
int Qp;
int Nop;
int X;
int Jj;
int Opcode;
int Evaluate;
int Opnd;
short Ophead;
unsigned char Real;
unsigned char Longreal;
unsigned char Realop;
int Operator;
int Nops;
int Lastop;
int Bs[1+2 /*1:2*/];
int Pt[1+2 /*1:2*/];
int Dp[1+2 /*1:2*/];
int Op[6 /*0:5*/];
int Opprec[6 /*0:5*/];
auto void Test(int N);
auto void Plant(int A, int B, int C);
auto int Findr(void);
auto void XLoad(int *N, int Reg, int Mode);
#define Load(N, Reg, Mode) XLoad(&N, Reg, Mode)
auto void Printorders(void);
static int N0 = 1024;
Qp = 0;
Ophead = 0;
Opcode = 0;
Real = 0;
Longreal = 0;
Realop = 0;
Nops = 0;
Lastop = 0;
{
__label__ L__99;
static int S_sw;
static void *S[4 /*1:4*/] = {
&&S_1,
&&S_2,
&&S_3,
&&S_4,
};
static int Sw_sw;
static void *Sw[4 /*1:4*/] = {
&&Sw_1,
&&Sw_2,
&&Sw_3,
&&Sw_4,
};
Aflag = 0;
Nop = N0;
Op[0] = 0;
Opprec[0] = 0;
goto *S[S_sw = (A[P]) - 1];
S_2:;
Op[1] = 11;
L__101:
Opprec[1] = 2 + Op[1] / 6;
Qp = 1;
goto L__1;
S_3:
Op[1] = 23;
goto L__101;
S_1:
S_4:
L__1:;
Opnd = A[P + 1];
P += 2;
Qp++;
goto *Sw[Sw_sw = (Opnd)-1];
Sw_1:;
Copytag(A[P]);
if (Type == 8)
goto Regvar;
if (Type == 3 && Arr == 0 && Inreg != 0)
goto L__19;
if (Arr == 2 && A[P + 1] == 1)
goto L__171;
if (1 <= Type && Type <= 2 && Arr == 0 && Rout == 0 && A[P + 1] == 2 &&
2 == A[P + 2])
goto L__17;
L__10:;
if (Type != 1 && (Rout != 1 || Type != 6 || (Tsname[K] & 7) != 1))
goto L__14;
C = P;
if (Qp > 1)
goto L__11;
P++;
Skipapp();
if (A[P] != A[P + 1] || A[P + 1] != 2)
goto L__11;
P = C;
C = Reg;
if (Reg <= 0) {
C = Findr();
Register[C] = 0;
}
Cname(2, C);
Nest = C;
goto L__80;
L__11:
P = C;
C = Findpp();
if (!C)
goto L__14;
Cname(2, C);
Nest = C;
if (Qp == 1 && A[P] == 2)
goto L__80;
P++;
L__12:
St[N0] = 9;
St[N0 + 1] = C;
N0 += 3;
Register[C] = 1;
goto L__50;
L__14: // OPERAND MUST BE FETCHED AND STORED
Cname(2, 2);
Nest = 2;
if (Type == 5) {
Fault(42);
Type = 1;
}
if (Type == 2)
Freg[2] = 1;
else
Register[2] = 1;
Nam = 0;
Arr = 0;
Rout = 0;
if (Prec == 3)
Longreal = 1;
if (Qp == 1 && A[P] == 2)
goto L__80;
L__16:
if (Type == 1)
goto L__15;
Real = 1;
if (Prec == 3)
Longreal = 1;
if (A[P] == 2)
goto L__161;
C = Parkf(Nest, Prec);
Freg[Nest] = 0;
L__13:
St[N0] = 10;
P++;
St[N0 + 1] = Rbase | (Type | Prec << 3 | Nam << 6) << 8;
St[N0 + 2] = C;
N0 += 3;
goto L__50;
L__161:
St[N0] = 8;
St[N0 + 1] = Nest + 512 + (Prec << 11);
Freg[Nest] = 1;
N0 += 3;
P++;
goto L__50;
L__15:
C = Nest;
C = Park(Nest);
if (Nest != C)
Register[Nest] = 0;
if (C > 0)
goto L__18;
C = abs(C);
Prec = 0;
goto L__13;
L__18:
P++;
goto L__12;
L__17: // OPND HAS BASE REGISTER COVER
St[N0] = 2;
St[N0 + 1] = I | (Type | Prec << 3 | Nam << 6) << 8;
St[N0 + 2] = K;
P += 4;
N0 += 3;
if (Type == 2)
Real = 1;
if (Prec == 3)
Longreal = 1;
if (Unass != 1 || (Prec != 0 && Prec != 3))
goto L__50;
if (Nam == 1)
goto L__50;
Pss(0xD5, Bytes[Prec], I, K, Gla, 128);
Prx(0x47, 8, 0, Coder, 40);
goto L__50;
L__171:
if (A[P + 2] != 4 || A[P + 3] != 2 || A[P + 4] != 9)
goto L__10;
if (A[P + 5] >= 256 || A[P + 6] != 2 || A[P + 7] != 2 || 2 != A[P + 8])
goto L__10;
From1(K, C);
C += Bytes[Prec] * A[P + 5];
if (0 >= C || C >= 4096)
goto L__10;
K = C;
P += 6;
goto L__17;
L__19:
if (A[P + 1] != 2 || A[P + 2] != 1)
goto L__14;
P += 3;
From1(K, Fname);
I = Inreg;
K = Displacement(Fname);
if (I == -1)
goto L__191;
Unpack();
if (Arr == 0 && Rout == 0 && 1 <= Type && Type <= 2 && A[P + 1] == 2 &&
2 == A[P + 2])
goto L__17;
L__191:
P -= 3;
goto L__14;
Regvar:
if (A[P + 1] != 2 || 2 != A[P + 2])
goto L__14;
P += 4;
St[N0] = 9;
St[N0 + 1] = K;
N0 += 3;
goto L__50;
Sw_2:;
C = A[P];
St[N0 + 1] = P;
St[N0 + 2] = A[P + 1];
if ((C & 7) == 2)
goto L__24;
if (C == 5) {
Fault(42);
P = P + (A[P + 1] & 0xFE) + 1;
C = 9;
}
if (C <= 8)
goto L__22;
St[N0] = 0;
L__21:
N0 += 3;
P += 3;
goto L__50;
L__22:
St[N0] = 1;
P++;
goto L__21;
L__24:
Real = 1;
P += 2;
goto L__22;
Sw_3:
Sw_4:;
D = 0;
if (Mode == 1 || Lastop == 12)
D = 1;
Csexp(0, D);
if (Opnd != 4)
goto L__32;
D = 16 * Type;
if (Type == 2 && Prec == 0)
D = 48;
Prr(D, Nest, Nest);
L__32:
if (Prec == 3)
Longreal = 1;
if (Qp == 1 && A[P] == 2)
goto L__80;
goto L__16;
L__50: // DEAL WITH Operator
if (A[P - 1] == 2)
goto L__60;
Operator = A[P];
if (Operator == 12) {
Fault(42);
Operator = 2;
}
if (Operator == 13)
Operator = 6;
if (Operator == 1 || Operator == 8)
Realop = 1;
if (Operator == 1)
Operator = 12;
Nops++;
Lastop = Operator;
C = Precedence[Operator];
L__51:
if (C > Opprec[Qp - 1])
goto L__52;
Qp--;
St[N0] = Op[Qp];
N0 += 3;
goto L__51;
L__52:
Op[Qp] = 10 + Operator;
Opprec[Qp] = C;
goto L__1;
L__60: // - END OF EXPRESSION
for (Jj = Qp - 1; Jj >= 0; Jj--) {
St[N0] = Op[Jj];
N0 += 3;
}
if (Mode != 1 && Realop == 1)
Real = 1;
if (Real == 1)
goto L__70;
// - CAN EVALUATE AS Integer
Printorders();
L__61:
if (Mode >= 2)
goto L__71;
L__72:
D = 1;
if (0 >= Reg)
Reg--;
if (Real != 0 || 0 <= Reg || Dp[1] >= 0 || Register[Bs[1]] >= 0)
Load(D, Reg, Real);
Nest = Bs[1];
if (Real == 1)
Freg[Nest] = 0;
else if (Register[Nest] > 0)
Register[Nest] = 0;
Ptype = 1 + 30 * Longreal + Real;
N0 = Nop;
Unpack();
goto L__99;
L__70: // EVALUATE AS Real
if (Mode == 1)
Fault(24);
if (Mode == 3)
Longreal = 1;
Evaluate = 16 * Longreal;
Printorders();
goto L__72;
L__71:
if (Mode == 3)
Longreal = 1;
Real = 1;
Evaluate = 16 * Longreal;
goto L__72;
L__80: // SINGLE OPERAND EXPRESSION
Bs[1] = Nest;
Dp[1] = -1;
Pt[1] = Prec << 3 | Type;
Aflag = 0;
P++;
if (Type == 2 && Mode == 1)
Fault(24);
if (Type == 1)
goto L__61;
goto L__71;
L__99:;
}
goto L__99;
int Findr(void) {
int I;
if (0 >= Reg)
goto L__2;
I = Reg;
if (!Register[I])
goto L__1;
L__2:
for (I = 1; I <= Rbase - 1; I++)
if (!Register[I])
goto L__1;
Fault(241);
L__1:
Register[I] = 1;
return (I);
}
int Findpr(void) {
int I;
for (I = 0; I <= 6; I += 2)
if (Register[I] == 0 && Register[I + 1] == 0)
goto Found;
Fault(242);
Found:
Register[I] = 1;
Register[I + 1] = 1;
return (I);
}
int Findfr(void) {
int I;
for (I = 6; I >= 0; I -= 2)
if (!Freg[I])
goto L__1;
Fault(242);
L__1:
Freg[I] = 1;
return (I);
}
void XLoad(int *N, int Reg, int Mode) {
__label__ L__99;
int I;
int X;
int *Bsi;
int *Dpi;
int *Pti;
I = *N;
if (I)
goto Nochoice;
I = 1;
if (Dp[1] < 0 && Register[Bs[1]] >= 0)
goto Chosen;
I = 2;
if (Dp[2] < 0 && Register[Bs[2]] >= 0)
goto Chosen;
if (Mode == 0 && (Pt[2] == 255 || (Pt[2] & 24) == 8))
goto Chosen;
if (Mode == 1 &&
((Pt[2] & 7) == 1 || (Evaluate > 0 && (Pt[2] & 24) == 0)))
goto Chosen;
I = 1;
Chosen:
*N = I;
Nochoice:
Bsi = &Bs[I];
Dpi = &Dp[I];
Pti = &Pt[I];
if (Mode == 0 && *Pti == 255)
goto Shortconst;
if (Mode == 1 || (*Pti & 64) != 0)
Test(I);
if (*Dpi < 0)
goto Inreg;
if (Reg >= 0)
goto Nofind;
if (!Mode)
Reg = Findr();
else
Reg = Findfr();
Nofind:
X = (Mode << 3 | (*Pti >> 2 & 6)) + 2;
Dump(X, Reg, *Dpi, 0, *Bsi);
goto L__98;
Inreg:
if (Mode == 1)
goto L__90;
if (*Bsi == Reg)
goto L__99;
if (Register[*Bsi] < 0)
goto Locked;
if (0 > Reg)
goto L__99;
Register[*Bsi] = 0;
Swop:
Prr(0x18, Reg, *Bsi);
goto L__98;
Locked:
if (0 > Reg)
Reg = Findr();
goto Swop;
L__90:
if (!*Bsi)
goto L__91;
if (*Bsi == Reg || 0 > Reg)
goto L__99;
L__91:;
if (0 > Reg)
Reg = Findfr();
Prr(0x38 - Evaluate, Reg, *Bsi);
Freg[*Bsi] = 0;
goto L__98;
Shortconst:
if (0 > Reg)
Reg = Findr();
Dump(0, Reg, *Dpi, 0, 0);
L__98:
*Bsi = Reg;
*Dpi = -2;
L__99:;
}
void Plant(int Opcode, int R1, int R2) {
__label__ L__99;
int Bsr2;
Bsr2 = Bs[R2];
R1 = Bs[R1];
if (Dp[R2] < 0)
goto Rrop;
if ((Pt[R2] & 24) == 16 && 0x5A <= Opcode && Opcode <= 0x5B)
Opcode -= 16;
Prx(Opcode, R1, 0, Bsr2, Dp[R2]);
goto L__99;
Rrop:
Prr(Opcode - 64, R1, Bsr2);
if (Real == 1)
Freg[Bsr2] = 0;
if (Real == 0 && Register[Bsr2] > 0)
Register[Bsr2] = 0;
L__99:;
}
void Test(int N) { // INSPECTS OPERAND - MAKES TYPE CONVERSIONS ETC.
int X;
int *Lbase;
int *Ldisp;
int *Lptype;
unsigned char Lprec;
Lptype = &Pt[N];
Ldisp = &Dp[N];
Lbase = &Bs[N];
Lprec = *Lptype >> 3 & 3;
if (*Lptype == 255)
goto Shortconst;
if (!(*Lptype & 64))
goto Start;
Rp13 = R13;
R13 = *Lbase << 12 | *Ldisp;
if (R13 != Rp13)
Prx(0x58, Link, 0, *Lbase, *Ldisp);
*Lptype = *Lptype & 31;
*Lbase = Link;
*Ldisp = 0;
Start:
if (Real)
goto Floating;
if (Lprec == 0 || (Lprec == 2 && 12 <= Opcode && Opcode <= 13))
goto Finish;
Pickup:
Load(N, -1, 0);
Lprec = 0;
goto Finish;
Shortconst:
Lprec = 0;
if (!Real)
goto Pickup;
if (0 <= *Ldisp && *Ldisp <= 2)
goto Ingla;
A[-2] = 9;
A[-1] = *Ldisp;
*Ldisp = Sortconst(-2, Longreal, 2);
L__1:
*Lbase = Gla;
goto Finish;
Ingla:
*Ldisp = 8 * *Ldisp + 40;
goto L__1;
Floating:
if ((*Lptype & 7) == 1)
goto Floatit;
if (Lprec == 3 || Evaluate == 0)
goto Finish;
// MUST STRETCH A 32 BIT Real
if (*Ldisp < 0)
Freg[*Lbase] = 1;
X = Findfr();
Prr(0x2B, X, X);
if (*Ldisp < 0) {
Prr(0x38, X, *Lbase);
Freg[*Lbase] = 0;
} else
Prx(0x78, X, 0, *Lbase, *Ldisp);
*Lbase = X;
*Ldisp = -2;
goto Finish;
Floatit:
Load(N, 1, 0);
Ppj(43);
Register[1] = 0;
*Lbase = 0;
*Ldisp = -2;
Finish:
*Lptype = (1 + Real) | Lprec << 3;
if (Longreal == 1 && Real == 1)
*Lptype = *Lptype | 24;
}
void XMult(int *Result) {
#define Mult(Result) XMult(&Result)
__label__ L__99;
int I;
int K;
for (I = 1; I <= 2; I++) {
if (Pt[I] == 255 && Dp[I] == 2)
goto L__30;
if (Dp[I] < 0 && Register[Bs[I]] >= 0)
goto L__1;
L__5:;
}
I = 1;
K = Findpr();
Load(I, K + 1, 0);
goto L__11;
L__1:
if ((Bs[I] & 1) == 1 && I > 0 && Register[Bs[I] - 1] == 0)
goto L__14;
if ((Bs[I] & 1) == 0 && Register[Bs[I] + 1] == 0)
goto L__12;
goto L__5;
L__12:
K = Bs[I];
Register[K + 1] = 1;
Prr(0x18, K + 1, K);
goto L__13;
L__14:
Register[Bs[I] - 1] = 1;
L__11:
Bs[I] = Bs[I] - 1;
L__13:
Test(3 - I);
Plant(0x5C, I, 3 - I);
if (!Checksp)
goto L__15;
Prx(0x8F, Bs[I], 0, 0, 32);
L__15:
*Result = 257 + Bs[I] - Checksp;
Register[Bs[I] + Checksp] = 0;
Aflag = Checks;
goto L__99;
L__30:
K = 3 - I;
Load(K, -1, 0);
Prr(0x1A, Bs[K], Bs[K]);
Aflag = 1;
*Result = 256 + Bs[K];
L__99:;
}
void XDiv(int *Result) {
#define Div(Result) XDiv(&Result)
int I;
int K;
if (Dp[1] < 0)
goto L__3;
L__1:
K = Findpr();
L__2:
I = 1;
Load(I, K, 0);
goto L__10;
L__3:
if ((Bs[1] & 1) == 0 && Register[Bs[1] + 1] == 0)
goto L__4;
K = Findpr();
goto L__2;
L__4:
if (Register[Bs[1]] < 0)
goto L__1;
Register[Bs[1] + 1] = 1;
K = Bs[1];
L__10:
Prx(0x8E, K, 0, 0, 32);
Test(2);
Plant(0x5D, 1, 2);
if (!Checksp)
goto L__20;
if (Opcode == 17)
goto L__20;
Prr(0x12, K, K);
Prx(0x47, 7, 0, Coder, 64);
L__20:
Register[K] = 0;
Aflag = 0;
*Result = K + 257;
}
void Printorders(void) {
static int S_sw;
static void *S[50 /*0:49*/] = {
&&S_0, &&S_1, &&S_2, &&S_default, &&S_default,
&&S_default, &&S_default, &&S_default, &&S_default, &&S_9,
&&S_10, &&S_11, &&S_12, &&S_13, &&S_14,
&&S_15, &&S_16, &&S_17, &&S_18, &&S_19,
&&S_20, &&S_21, &&S_22, &&S_23, &&S_24,
&&S_25, &&S_26, &&S_27, &&S_default, &&S_default,
&&S_default, &&S_default, &&S_default, &&S_33, &&S_34,
&&S_35, &&S_36, &&S_37, &&S_38, &&S_39,
&&S_40, &&S_41, &&S_42, &&S_43, &&S_44,
&&S_45, &&S_46, &&S_47, &&S_48, &&S_49,
};
int C;
int D;
int Last;
int Kk;
Last = N0 - 6;
for (Jj = Nop; Jj <= Last; Jj += 3) {
__label__ L__99;
Opcode = St[Jj];
if (10 >= Opcode || Opcode == 24)
goto Skip;
if (Opcode == 11 || Opcode == 23)
Kk = 1;
else
Kk = 2;
for (Kk = Kk; Kk >= 1; Kk--) {
Pop(Ophead, C, Dp[Kk]);
Pt[Kk] = C >> 8;
Bs[Kk] = C & 15;
}
Skip:
goto *S[S_sw = Opcode + 25 * Real];
S_0:;
S_25:;
D = 0xFF00;
C = St[Jj + 2];
goto L__99;
S_1:;
C = Sortconst(St[Jj + 1], 0, 1);
D = 256 + Gla;
goto L__99;
S_26:;
D = 512 + Gla;
if (Longreal == 1)
D += 3 << 11;
C = Sortconst(St[Jj + 1], Longreal, 2);
goto L__99;
S_2:
S_27:;
D = St[Jj + 1];
C = St[Jj + 2];
goto L__99;
S_33:;
D = St[Jj + 1];
C = -2;
goto L__99;
S_9:
S_34:;
D = 256 + St[Jj + 1];
C = -2;
goto L__99;
S_10:
S_35:;
C = St[Jj + 2];
D = St[Jj + 1];
if (Real == 1 && (D >> 8 & 24) == 24)
Push(Lwsp[Level], 0, C);
else
Push(Wsp[Level], 0, C);
goto L__99;
S_11:;
if (Pt[1] != 255 || Dp[1] != 1)
goto L__109;
Aflag = 0;
D = 256 + Gla;
C = 16;
goto L__99;
S_36:;
L__109:
C = 1;
D = 0x13 + Real * (32 - Evaluate);
Load(C, -1, Real);
Aflag = 1;
Prr(D, Bs[1], Bs[1]);
L__111:
D = (Real + 1 + 24 * Longreal) << 8 | Bs[C];
C = -2;
goto L__99;
S_23:;
C = 1;
Aflag = 2;
Load(C, -1, 0);
Prx(0x57, Bs[1], 0, Gla, 16);
goto L__111;
S_12:
S_37:;
Aflag = 1;
D = 0x5A;
L__125:
C = 0;
L__126:
Load(C, -1, Real);
Test(3 - C);
D += Real * (0x20 - Evaluate);
Plant(D, C, 3 - C);
goto L__111;
S_13:
S_38:;
Aflag = 1;
D = 0x5B;
C = 1;
if (Real != 0 || Pt[2] != 255 || 1 > Dp[2] || Dp[2] > 2)
goto L__126;
Aflag = 0;
Load(C, -1, 0);
if (Dp[2] == 2)
Prr(6, Bs[1], 0);
Prr(6, Bs[1], 0);
goto L__111;
S_14:
D = 0x57;
L__141:
Aflag = 2;
goto L__125;
S_15:
D = 0x56;
goto L__141;
S_16:
Mult(D);
C = -2;
goto L__99;
S_17:
S_18:
Div(D);
C = -2;
goto L__99;
S_19:
D = 0x54;
goto L__141;
S_20:
S_21:;
D = 0;
C = 1;
Load(C, -1, 0);
if (Pt[2] == 255)
D = 1;
C = 2;
if (!D)
Load(C, -1, 0);
Prx(0x89 + Opcode - 21, Bs[1], 0, Bs[2], D * Dp[2]);
if (!D)
Register[Bs[2]] = 0;
C = 1;
Aflag = 0;
goto L__111;
S_22:
for (C = 1; C <= 2; C++) {
Load(C, -1, 0);
Dump(1, Bs[C], 28 + 4 * C, 0, Gla);
Register[Bs[C]] = 0;
}
if (Register[0])
goto L__221;
C = 2;
Aflag = 0;
Register[0] = 1;
Ppj(15);
Bs[2] = 0;
goto L__111;
L__221:
C = Findr();
D = Findr();
Prr(0x18, C, 0);
Ppj(15);
Prr(0x18, D, 0);
Prr(0x18, 0, C);
Register[C] = 0;
C = 2;
Aflag = 0;
Bs[2] = D;
goto L__111;
S_39:
S_40:
S_42:
S_44:
S_45:
S_46:
S_48:;
Fault(24);
if (Opcode == 23)
Opcode = 36;
else
Opcode = 37;
goto *S[S_sw = Opcode];
S_41:;
D = 0x5C;
C = 0;
L__410:
Aflag = 0;
goto L__126;
S_43:;
D = 0x5D;
C = 1;
goto L__410;
S_47:;
C = 1;
Load(C, -1, 1);
if (Pt[2] == 255 && Dp[2] == 2)
goto L__222;
Prr(0x38 - Evaluate, 0, Bs[1]);
C = 2;
if (Pt[2] != 255 && (Pt[2] & 7) > 1)
Fault(39);
Load(C, 1, 0);
Ppj(36);
Register[1] = 0;
Prr(0x38 - Evaluate, Bs[1], 0);
C = 1;
goto L__111;
L__222:
Prr(0x3C - Evaluate, Bs[1], Bs[1]);
C = 1;
goto L__111;
L__99:
if (Jj != Last)
Push(Ophead, D, C);
S_24:
S_49:;
}
Dp[1] = C;
Pt[1] = D >> 8;
Bs[1] = D & 15;
goto S_skip;
S_default:
fprintf(stderr, "Switch label 'S(%d):' not set in %s", S_sw,
__PRETTY_FUNCTION__);
exit(1) /* or %signal ... */;
S_skip:;
}
L__99:;
}
int Sortconst(int P, int Long, int Type) {
double Cvalue;
int I;
int K;
if (Type == 2)
goto L__50;
if ((A[P] & 7) != 1)
Fault(24);
if (A[P] == 9)
I = A[P + 1];
else
Fromar4(P + 1, I);
L__40:
K = N0;
St[K] = I;
N0++;
return (K << 2);
L__50:
Cvalue = 0;
if ((A[P] & 7) != 1)
goto L__60;
if (A[P] == 9)
I = A[P + 1];
else
Fromar4(P + 1, I);
Cvalue = I;
goto L__70;
L__60:
Fromar8(P + 1, Cvalue);
L__70:
if (Long)
goto L__75;
I = *Integer(Addr(Cvalue));
goto L__40;
L__75:
K = (N0 + 1) & (-2);
St[K] = *Integer(Addr(Cvalue));
St[K + 1] = *Integer(Addr(Cvalue) + 4);
N0 = K + 2;
return (K << 2);
}
void Cstrexp(int Reg) { // EVALUATES STRING EXPR USING CURRENT
// WORKAREA AND 1 SUBROUTINES LEAVES ADDR IN
// REG -VE IF STRING MUST BE MOVED TO WK.ARREA
__label__ L__99;
int Jj;
int Qq;
int Kk;
int Wkarea;
int Pp;
if (!Strinst)
Setex();
Pp = P;
Jj = Tsexp(Qq);
if (Jj == 20 && Reg >= 0)
goto L__71;
P = Pp;
Reg = abs(Reg);
Wkarea = Getstrwsp();
Psi(0x92, 0, Rbase, Wkarea);
if (A[P] == 4)
goto L__2;
L__1:
Fault(71);
L__4:
P = Pp;
Skipexp();
goto L__99;
L__5:
Fault(72);
goto L__4;
L__2:
if (A[P + 1] == 2)
goto L__10;
if (A[P + 1] != 1)
goto L__1;
P += 2;
Cname(2, 1);
if (Type != 5)
goto L__1;
goto L__20;
L__10:
P += 2;
if (A[P] == 5)
goto L__14;
if (A[P] != 9 || A[P + 1] >= 127)
goto L__1;
if (!A[P + 1])
goto L__11;
Prx(0x41, 1, 0, 0, A[P + 1]);
P += 2;
goto L__20;
L__11:
P += 2;
goto L__21;
L__14: // STRING CONSTANT PUT IN CODE CF (TEXTTEXT)
Kk = (Ca + 6 + A[P + 1] - Codebase[Level]) & (-2);
Qq = 0;
if (Kk < 4095)
goto L__15;
Kk += 4;
Qq = 1;
Prx(0x58, 1, Gla, 0, Pageno(Kk) << 2);
L__15:
Prx(0x45, 1, 10, Qq, Kk & 4095);
P++;
for (Kk = 1; Kk <= (A[P] + 2) / 2; Kk++) {
Plant(A[P] << 8 | A[P + 1]);
P += 2;
}
L__20:
Prx(0x41, 2, Rbase, 0, Wkarea);
Ppj(26);
L__21:
if (A[P] == 2)
goto L__90;
if (A[P + 1] != 12)
goto L__5;
P++;
goto L__2;
L__71:
Dump(2, Reg, K, I, 0);
goto L__99;
L__90:
P++;
Push(Strwsp[Level], 0, Wkarea);
Prx(0x41, Reg, 0, Rbase, Wkarea);
L__99:
Ptype = 5;
Unpack();
}
void Cres(int Mode, int Lab) {
__label__ L__99;
auto void Skipname(void);
auto void Fail(int Mask);
int P1;
int P2;
int P3;
int W;
int Sexprn; // MODE=0 UNCONDITIONAL # 0 CONDITIONAL
// ENTER WITH ADDR OF LHS IN R1 AND P ON PLUS''
Sexprn = 0;
W = Getdblewrd();
P1 = P;
if (A[P] == 4)
goto L__1;
L__1000:
P = P1;
Skipexp();
Fault(74);
goto L__99;
L__1:
if (Type != 5)
goto L__1000;
Prr(0x1B, 2, 2);
Prx(0x90, 1, 2, Rbase, W);
P2 = -1;
P += 2;
if (A[P - 1] == 3)
goto L__10;
if (A[P - 1] != 1)
goto L__1000;
L__3:
P2 = P;
Skipname();
if (A[P] == 2)
goto L__50;
if (A[P + 1] != 12)
goto L__1000;
if (A[P + 2] != 3)
goto L__1000;
P += 3;
L__10:
Cstrexp(-4);
Sexprn++;
Prx(0x98, 1, 2, Rbase, W);
Ppj(27);
Fail(7);
Prx(0x90, 1, 2, Rbase, W);
if (P2 < 0)
goto L__15;
P3 = P;
P = P2;
Cname(1, 4);
if (Type != 5)
Fault(71);
P = P3;
L__12:
if (A[P] != 1 || A[P + 1] != 12 || A[P + 2] != 1)
goto L__1000;
P += 3;
goto L__3;
L__15:
Psi(0x95, 0, 4, 0);
Fail(7);
goto L__12;
L__50:
if (!Sexprn)
goto L__1000;
Prx(0x98, 1, 2, Rbase, W);
Ppj(37);
P3 = P;
P = P2;
Cname(1, 4);
if (Type != 5)
Fault(71);
P = P3 + 1;
L__99:
Push(Lwsp[Level], 0, W);
return;
void Skipname(void) {
L__1:
P++;
Skipapp();
P++;
if (A[P - 1] == 2)
return;
P++;
goto L__1;
}
void Fail(int Mask) {
if (!Mode)
Prx(0x47, Mask, 0, Coder, 152);
else
Plocaljump(Mask, Lab);
}
}
void Ccond(int Iu, int Nearlab, int Farlab) { // IU=0 FOR IF =1 FOR UNLESS
auto void Ccc(void);
auto void XCsc(int *Flab); // P ON ALT OF (SC)
#define Csc(Flab) XCsc(&Flab)
int T;
int C;
int Failpt;
int Base;
int Disp;
int Jnporfp;
int Tp;
int Clauses;
Clauses = 0;
T = A[P + 1 + A[P + 1]];
if (T == 3)
T = 0;
Tp = T;
if (!T)
Tp++;
if (!(Iu ^ (Tp - 1)))
Jnporfp = Farlab;
else
Jnporfp = Nearlab;
Failpt = 0;
Ccc();
goto L__99;
void Ccomp(int C) {
int M;
int L;
int Q;
int R;
int T;
static unsigned char Fcomp[1+7 /*1:7*/] = {0,
8, 10, 2, 7, 12, 4, 7};
static unsigned char Bcomp[1+7 /*1:7*/] = {0,
8, 12, 4, 7, 10, 2, 7};
static int Sw_sw;
static void *Sw[13 /*-10:2*/] = {
&&Sw_M10, &&Sw_M9, &&Sw_default, &&Sw_default, &&Sw_default,
&&Sw_M5, &&Sw_M4, &&Sw_M3, &&Sw_M2, &&Sw_M1,
&&Sw_0, &&Sw_1, &&Sw_2,
};
M = A[P];
P++;
if (M != 8)
goto *Sw[Sw_sw = (C) - -10];
Fault(73);
Skipexp();
goto L__1;
Sw_M10:;
Cstrexp(1);
Nest = 1;
Dump(2, 2, Disp, 0, Base);
goto L__161;
Sw_M9:
T = P;
R = Tsexp(Q);
if (R == 10 && A[P] == 2)
goto Reg1;
if (R == 11 && A[P] == 2)
goto Reg2;
P = T;
Csexp(0, 0);
if (Type == 2)
goto Reg3;
Prr(0x19, Disp, Nest);
goto L__20;
Reg1:
Q = 0x59;
goto Rcom;
Reg2:
Q = 0x49;
Rcom:
Prx(Q, Disp, 0, I, K);
goto L__20;
Reg3:
Prr(0x18, 1, Disp);
goto L__37;
Sw_M5:;
Csexp(0, 3);
Q = 0x69;
L__51:
Prx(Q, Nest, 0, Base, Disp);
goto L__21;
Sw_M4:;
Q = 0x79;
Csexp(0, 2);
L__40:
if (!Prec)
goto L__51;
Prr(0x2B, 0, 0);
Prx(0x78, 0, 0, Base, Disp);
Prr(0x29, 0, Nest);
goto L__20;
Sw_M3:;
Csexp(0, 0);
if (!Value)
goto L__30;
if (Type == 2)
goto L__36;
R = 2;
if (Nest == 2)
R = 1;
Dump(0, R, Value, 0, 0);
L__29:
Prr(0x19, R, Nest);
goto L__20;
L__30:;
if (Type == 5)
goto L__35;
if (Aflag == 1)
goto L__32;
if (Type == 2)
goto L__31;
if (Aflag == 2 && 7 <= Fcomp[M] && Fcomp[M] <= 8)
goto L__32;
L__31:
Prr((Type - 1) * (2 - (Prec & 1)) * 16 + 0x12, Nest, Nest);
L__32:
if (C == -3)
goto L__21;
goto L__20;
L__35:
Psi(0x95, 0, Nest, 0);
goto L__20;
L__36:
Dump(0, 1, Value, 0, 0);
L__37:
Ppj(43);
Prr((1 - (Prec & 1)) * 16 + 0x29, 0, Nest);
goto L__20;
Sw_M2:
Q = 0x49;
L__24:
Csexp(0, 0);
if (Type == 2)
goto L__25;
Prx(Q, Nest, 0, Base, Disp);
goto L__21;
L__25:
R = 2;
if (Q == 0x49)
R = 6;
L__26:
Dump(R, 1, Disp, 0, Base);
goto L__37;
Sw_M1:;
T = P;
R = Tsexp(Q);
L = 1;
if (R == 11 && A[P] == 2)
goto L__18;
if (R == 1 && A[P] == 2)
goto L__19;
P = T;
Csexp(0, 0);
if (Type == 2)
goto L__14;
R = 2;
if (Nest == 2)
R = 1;
Dump(4, R, Disp, 0, Base);
goto L__29;
L__14:
R = 4;
goto L__26;
L__18:
Pss(0xD5, L, Base, Disp, I, K);
goto L__20;
L__19:
Psi(0x95, Q, Base, Disp);
goto L__20;
Sw_0:;
T = P;
R = Tsexp(Q);
L = 4;
if (R != 10 || A[P] != 2)
goto Rstore;
if (7 <= Fcomp[M] && Fcomp[M] <= 8)
goto L__18;
Rstore:
P = T;
Q = 0x59;
goto L__24;
Sw_1:;
Sw_2:;
T = P;
Ptypep = Ptype;
R = Tsexp(Value);
Ptype = Ptypep;
Unpack();
if (R == 1 && Value == 0 && (A[P] == 2 || C == 2))
goto L__30;
if (Type == 5)
goto L__160;
if (Type == 2)
goto L__150;
if (R == 0 || 14 <= R && R <= 15 || (A[P] == 1 && C == 1))
goto L__120;
if (Unass == 1 || R == 100 || R == 11 || R <= 2)
goto L__130;
if (R == 50)
goto L__131;
Q = 0x59;
if (R == 12)
Q = 0x49;
Prx(Q, Nest, 0, I, K);
goto L__20;
L__130:;
R = Nest;
if (!Register[R])
Register[R] = 1;
P = T;
Csexp(0, 1);
if (Register[R] > 0)
Register[R] = 0;
goto L__29;
L__131:
Prr(0x19, Nest, K);
goto L__20;
L__120:;
Q = Park(Nest);
P = T;
Csexp(0, 0);
if (Type == 2)
goto L__122;
Unpark(0x59, Nest, Q);
goto L__21;
L__122:
Unpark(0x58, 1, Q);
goto L__37;
L__150:
P = T;
Q = Parkf(Nest, Prec);
if (!Prec)
goto L__155;
Csexp(0, 3);
Push(Lwsp[Level], 0, Q);
Base = Rbase;
Disp = Q;
Q = 0x69;
goto L__51;
L__155:
Csexp(0, 2);
Push(Wsp[Level], 0, Q);
Base = Rbase;
Disp = Q;
Q = 0x79;
goto L__40;
L__160: // 1ST OPERAND A STRING EXPRESSION PTR IN Nest
P = T;
Pop(Strwsp[Level], R, T);
R = Park(Nest);
Cstrexp(1);
Nest = 1;
Unpark(0x58, 2, R);
Push(Strwsp[Level], 0, T);
L__161:
if (7 > Fcomp[M] || Fcomp[M] > 8)
goto L__162;
Prx(0x43, 3, 0, 1, 0);
Prx(0x44, 3, 0, Gla, Strinst + 6);
goto L__20;
L__162:
Ppj(35);
L__20:
Mask = Fcomp[M];
goto L__1;
L__21:
Mask = Bcomp[M];
L__1:;
goto Sw_skip;
Sw_default:
fprintf(stderr, "Switch label 'Sw(%d):' not set in %s", Sw_sw + -10,
__PRETTY_FUNCTION__);
exit(1) /* or %signal ... */;
Sw_skip:;
}
void Ccc(void) {
int Line;
int Flab;
Csc(Flab);
C = A[P];
P++;
Clauses++;
if (T == 0 || (Clauses > 1 && C == 2))
goto L__10;
if (Failpt)
goto L__2;
Failpt = 1;
Line = 1;
goto L__3;
L__2:
Line = 0;
L__3:;
Plocaljump(Mask, Jnporfp);
if (Flab) {
Push(Locallabel, Ca, Flab);
if (R13 != Save13 || Chnge13 != 0)
R13 = 0;
}
Ccc();
if (!Line)
goto L__10;
if (Jnporfp == Nearlab)
Mask = Mask ^ 15;
L__10:;
}
void XCsc(int *Flab) {
int Line;
int Q;
int R;
int S;
int Tp;
int Near;
Flab = 0;
S = A[P + 1 + A[P + 1]];
Line = S;
Near = Nearlab;
if (T == 0 || (S == 2 && Clauses > 0))
goto Start;
Plabel--;
Near = Plabel;
Start:
if (A[P] == 1)
goto L__1;
P += 2;
if (!T)
goto Redund;
if (T == A[P + 1 + A[P + 1]])
goto Redund2;
if (Near != Nearlab)
*Flab = Near;
Tp = T - 1;
if (Near == Nearlab)
goto Last;
Ccond(Tp, Near, Farlab);
goto L__9;
Redund:
Ccond(Iu, Nearlab, Farlab);
goto L__9;
Redund2:
Ccond(Iu, Nearlab, Farlab);
if (Jnporfp == Nearlab)
Mask = Mask ^ 15;
goto L__9;
Last:
Ccond(Iu, Near, Farlab);
Nearlab = 0;
goto L__9;
L__1: // CLASSIFY SIMPLE CONDITION AND ACT ACCORDINGLY
P += 2;
S = P;
Skipexp();
if (A[P] == 8)
goto L__21;
P++;
Q = Tsexp(R);
if (Type == 3) {
P += 2;
R = Copyrecordtag();
}
if (Type == 5)
goto Str;
if (Q == 1 && R == 0 && A[P] == 2)
goto Zero;
P = S;
Q = Tsexp(R);
if (1 <= Q && Q <= 2)
goto Const;
if (Q == 20)
goto Simple;
if (Q == 50)
goto Regvar;
if (Type == 5)
goto Str;
if (Unass != 0 || 10 > Q || Q > 15)
goto Normal;
Simple:
Base = I;
Disp = K;
Ccomp(10 - Q);
goto L__8;
Regvar:
Disp = K;
Ccomp(-9);
goto L__8;
Str:
P = S;
Cstrexp(1);
Nest = 1;
Ccomp(1);
goto L__8;
Const:
Value = R;
Ccomp(-3);
goto L__8;
L__21:
P = S + 2;
if (A[S] != 4 || A[S + 1] != 1)
goto L__22;
Cname(2, 1);
if (A[P] == 2 && Type == 5)
goto L__23;
L__22:
P = S;
Skipexp();
L__28:
P++;
Skipexp();
Fault(73);
goto L__8;
L__23:
P += 2;
if (Near != Nearlab)
*Flab = Near;
if (T != 2)
R = Jnporfp;
else if (Jnporfp != Farlab && Line == 2 && Clauses > 0)
R = Farlab;
else
R = Near;
Cres(1, R);
if (A[P] != 2)
goto L__28;
P++;
Mask = 15;
goto L__10;
Zero:
P = S;
Q = Tsexp(R);
if (Q == 11)
goto Simple;
if (Type == 5)
goto Str;
Normal:
P = S;
Csexp(0, 0);
Ccomp(1);
L__8:
P++;
if (A[P - 1] == 2)
goto L__10;
if (Near != Nearlab)
*Flab = Near;
if (T == 2)
goto Orcond;
R = Jnporfp;
goto L__7;
Orcond:
if (Jnporfp != Farlab && Line == 2 && Clauses > 0)
R = Farlab;
else
R = Near; // LAST DOUBLESIDED IN OR CONDITION IS SPECIAL
L__7:;
Plocaljump(Mask ^ 15, R);
Ccomp(2);
L__10:
if (T == 1 || (T == 0 && Iu == 0))
Mask = Mask ^ 15;
L__9:;
}
L__99:;
}
void Filllocaljumps(void) {
int T;
int C;
int J;
L__1:
Pop(Localjump, T, C);
if (T == -1)
goto L__98;
J = Find(C, Locallabel);
if (J == -1)
Fault(233);
J -= Localaddr;
Plug(T + 2, J);
goto L__1;
L__98:
Clearlist(Locallabel);
}
void Plocaljump(int Mask, int Label) {
if (!Mask)
return;
if (Save13 != R13)
Chnge13 = 1;
if (Label > 21000)
goto L__1;
Pj(Mask, Label);
goto L__99;
L__1:
if (Localbase)
goto L__2;
Localbase = 10;
Localaddr = Codebase[Level];
if (Sbflag == 1 || 3000 + 800 * Compiler > Ca - Codebase[Level])
goto L__2;
Localbase = Findpp();
if (Localbase <= 0)
Fault(231);
Prr(5, Localbase, 0);
Localaddr = Ca;
L__2:
Push(Localjump, Ca, Label);
Prx(0x47, Mask, Localbase, 0, 0);
L__99:;
}
void Csname(int Z, int Reg) {
int B[6 /*0:5*/];
static unsigned char Plabel[46 /*0:45*/] = {9,
9,
3,
3,
1,
[5 ... 7] = 14,
2,
3,
1,
18,
4,
3,
[14 ... 15] = 12,
33,
42,
34,
35,
32,
[21 ... 36] = 12,
5,
[38 ... 45] = 12};
static unsigned char Mode[46 /*0:45*/] = {[0 ... 1] = 16,
[2 ... 4] = 0,
[5 ... 7] = 16,
2,
[9 ... 10] = 16,
31,
32,
0,
18,
31,
[16 ... 18] = 18,
63,
47,
[21 ... 22] = 23,
18,
[24 ... 30] = 31,
31,
[32 ... 33] = 23,
[34 ... 35] = 47,
18,
16,
2,
23,
[40 ... 41] = 16,
23,
[43 ... 45] = 0};
static int Sw_sw;
static void *Sw[46 /*0:45*/] = {
&&Sw_0, &&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_default, &&Sw_16, &&Sw_17, &&Sw_18, &&Sw_19,
&&Sw_20, &&Sw_21, &&Sw_22, &&Sw_23, &&Sw_default,
&&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, &&Sw_38, &&Sw_39,
&&Sw_40, &&Sw_41, &&Sw_42, &&Sw_default, &&Sw_default,
&&Sw_default,
};
int Pl;
int Kk;
int Pp;
int V;
int Jj;
Kk = K;
Jj = Countaps();
Pl = Plabel[Kk];
Pp = P + 1;
V = Mode[K];
P++;
if (V >> 4)
P++;
if ((V & 15) == 15)
goto L__1010;
if (V >> 4 != Jj)
goto L__1001;
V = V & 15;
if (V == 0 && Z != 0)
goto L__1002;
if (V == 2 && Z != 2)
goto L__1003;
if (Z == 0 && V != 0)
goto L__1005;
L__1010:
goto *Sw[Sw_sw = Kk];
L__1001:
Fault(19);
Printname(Fname);
L__1000:
P = Pp;
Skipapp();
P--;
goto L__99;
L__1002:
Fault(23);
goto L__1000;
L__1003:
Fault(29);
goto L__1000;
L__1004:
Fault(22);
goto L__1000;
L__1005:
Fault(17);
goto L__1000;
L__1:
Ppj(Pl);
goto L__99;
Sw_4:
Ciocp(1);
goto L__99;
Sw_2:
V = 10;
Prx(0x41, 1, 0, 0, V);
L__23:
Ciocp(3);
goto L__99;
L__21:
Prx(0x41, 1, 0, 0, V);
goto L__1;
Sw_3:
V = 32;
goto L__21;
Sw_5:
V = 0;
L__51:
Csexp(2, 1);
goto L__21;
Sw_6:
V = 10;
goto L__51;
Sw_7:
V = 32;
goto L__51;
Sw_0:
Sw_1:;
Csexp(1, 1);
Ciocp(Kk + 8);
goto L__99;
Sw_9:;
Csexp(1, 1);
goto L__23;
Sw_8:
Ciocp(2);
L__81:
if (Reg != 1)
Prr(0x18, Reg, 1);
L__82:
Ptype = 10001;
Unpack();
goto L__99;
Sw_10:
Ciocp(1);
L__106:
if (A[P] != 4 || A[P + 1] != 1)
goto L__1004;
P += 2;
Copytag(A[P]);
Unpack();
if (Type != 1 || Arr != 0 || Rout != 0)
goto L__104;
Cname(1, 1);
L__102:
if (A[P] != 2)
goto L__1004;
P++;
goto L__99;
L__104:
Plant(0x1841);
Register[4] = 1;
Cname(1, 4);
Register[4] = 0;
if (Type != 1)
goto L__1004;
goto L__102;
Sw_11:;
B[0] = 1;
B[1] = 1000;
L__110:
Jj = 10000;
if (0 != Z && Z != 13)
goto L__1004;
goto L__302;
Sw_12:;
Csexp(1, 1);
P++;
Jj = P;
V = Tsexp(Kk);
if (V)
goto L__121;
V = Park(1);
Csexp(2, 1);
Unpark(0x58, 1, V);
L__120:
Ppj(Pl);
goto L__99;
L__121:
P = Jj;
Register[1] = 1;
Csexp(2, 1);
Register[1] = 0;
goto L__120;
Sw_13:;
Prx(0x41, 1, 0, 0, 12);
Ciocp(5);
goto L__99;
Sw_14:
if (A[P] != 4 || A[P + 1] != 1)
goto L__1004;
P += 2;
Cname(3, Reg);
if (A[P] != 2)
goto L__1004;
P++;
goto L__82;
Sw_16:;
Sw_17:;
Csexp(0, 3);
if (Nest)
Prr(0x28, 0, Nest);
Ppj(Pl);
goto L__81;
Sw_18:
Csexp(6, 3);
Pclod(32);
if (Reg != 2)
Prr(0x28, Reg, 2);
Ptype = 10032;
Unpack();
goto L__99;
Sw_19:;
B[0] = 3;
B[3] = 1;
L__191:
B[1] = 32;
B[2] = 1;
goto L__110;
Sw_20:;
Qpreal = (N0 << 2) + 4;
B[0] = 2;
goto L__191;
Sw_39:
Jj = 11032;
goto L__210;
Sw_21:
Jj = 11002;
L__210:
Csexp(0, 1);
P++;
if (Nest)
goto L__212;
Plant(0x1810);
Nest = 1;
L__212:
Ptype = Jj;
Unpack();
goto L__99;
Sw_22:
Jj = 11001;
goto L__210;
Sw_23:
Csexp(Reg, 3);
Prr(0x20, Reg, Reg);
goto L__99;
Sw_25:
Sw_26:
Sw_27:;
Sw_28:
Sw_29:
Sw_30:;
B[0] = 1;
L__301:
B[1] = 32;
Jj = 10032;
if (2 != Z && Z != 13)
goto L__1004;
L__302:
Redefineep(Jj, B[0]); // 302: REDEFINE EP(JJ,B) - looks like original bug. B is an integer array, not an integer!
Cname(Z, Reg);
P -= 2;
goto L__99;
Sw_31:;
Csexp(Reg, 1);
if (Z != 15)
Fault(84);
Ptype = 3;
Unpack();
goto L__99;
Sw_32:
Jj = 11011;
goto L__210;
Sw_33: // SW(33): JJ=11021; ->210; ! SHORT INTEGER
Jj = 11021;
goto L__210;
Sw_34:
Sw_35:;
B[0] = 2;
B[2] = 32;
goto L__301;
Sw_36:;
Csexp(Reg, 1);
Prx(0x89, Reg, 0, 0, 31);
Prx(0x8A, Reg, 0, 0, 30);
Prx(0x5B, Reg, 0, Gla, 16);
goto L__99;
Sw_37:
Cstrexp(1);
Ciocp(7);
goto L__99;
Sw_38:
Prx(0x41, Reg, 0, 0, 10);
goto L__82;
Sw_40:;
Csexp(1, 1);
Ciocp(5);
goto L__99;
Sw_41:;
Ciocp(4);
goto L__106;
Sw_42:
Jj = 11005;
goto L__210;
L__99:;
goto Sw_skip;
Sw_default:
fprintf(stderr, "Switch label 'Sw(%d):' not set in %s", Sw_sw,
__PRETTY_FUNCTION__);
exit(1) /* or %signal ... */;
Sw_skip:;
}
void Ciocp(int N) {
Prx(0x41, 0, 0, 0, N);
Prx(0x90, 4, 1, 11, 16);
Prx(0x98, 12, 14, Gla, 140);
Prr(0x05, 15, 14);
R13 = 0;
}
void Caname(int Z, int Bs, int Dp, int Clink, int Bsrf, int Dprf) {
static int S_sw;
static void *S[4 /*0:3*/] = {
&&S_0,
&&S_1,
&&S_2,
&&S_3,
};
int Ptypep;
int Kk;
int Rr;
int Pp;
int Jj;
int Jjj;
int Kkk;
int Dis;
int Q;
int Precp;
int Checksp;
int Basereg;
int Arrp;
int Basicdisp;
Checksp = Checks;
if (!Type)
Checksp = 1;
Pp = P;
Basereg = Link;
if (Inreg) {
if (Type)
Checksp = 0;
Basereg = Inreg;
}
Jj = J;
Ptypep = Ptype;
Arrp = Arr;
Q = Countaps();
if (Jj)
goto L__1;
From1(Clink, Jj);
Replace1(Clink, Jj | Q);
Jj = Q;
L__1:
if (Jj == Q && Q != 0)
goto L__4;
Fault(19);
Printname(Fname);
P++;
Skipapp();
goto L__99;
L__4:;
if (Arrp == 2)
Fromlist(K, Basicdisp, Dp);
if (Checksp != 0 || Jj != 1 || Z == 3)
goto L__12;
if (2 < Type)
goto L__12;
Precp = Prec;
Kkk = 0;
P = Pp + 2;
Jjj = Tsexp(Kkk);
if (3 <= Jjj && Jjj <= 99)
Dis = 0;
else
Dis = Kkk * Bytes[Precp];
if (Dis > 4095 || (Arrp == 2 && Dis + Basicdisp > 4095))
goto L__12;
if (Jjj == 50 && Precp == 1)
goto Regvar;
if (Jjj == 101)
goto Rdisp;
if (1 <= Jjj && Jjj <= 2)
goto Const;
if (Jjj != 100)
goto L__12;
Dump(2 + 2 * Prec, 1, K, 0, I);
P++;
goto L__9;
Regvar:
Jjj = K;
P++;
goto L__8;
Rdisp:
if (Precp == 1)
goto Regvar;
Prr(0x18, 1, K);
P++;
goto L__9;
L__12:
P = Pp + 2;
Dis = 0;
if (Jj != 1)
goto L__21;
Csexp(1, 1);
P++;
if (Checksp == 1)
goto L__10;
L__9:
Jjj = 1;
L__8:
if (Basereg != Link)
goto L__5;
if (Arrp == 2)
goto Vector;
Rp13 = R13;
R13 = Bs << 12 | Dp;
if (R13 != Rp13)
Prx(0x58, Link, 0, Bs, Dp);
goto L__5;
Vector:
Dis += Basicdisp;
Basereg = Bs;
L__5:
Ptype = Ptypep;
Unpack();
if (!Jjj)
goto L__6;
if (Type == 5)
goto Str;
if (Type != 3)
goto *S[S_sw = Prec];
L__3:
Prx(0x4C, 1, 0, Bsrf, Dprf);
goto L__6;
Str:
Prx(0x58, 2, 0, Bs, Dp + 8);
Bsrf = 2;
Dprf = 2;
goto L__3;
S_3:;
S_0:;
Pconst(0x89100002 | Prec);
goto L__6;
S_2:;
Plant(0x1A11);
S_1:
L__6:
Disp = Dis;
Index = Jjj;
Base = Basereg;
goto L__99;
Const:
Jjj = 0;
P++;
goto L__8;
L__10:;
Dump(0, 3, Dp, 0, Bs);
Ppj(22 + Jj);
Jjj = 1;
L__11:
Ptype = Ptypep;
Unpack();
goto L__6;
L__21:;
if (Jj != 2 || Checksp != 0)
goto L__31;
Csexp(2, 1);
Jjj = 2;
P++;
Kk = P;
Q = Tsexp(Pp);
P = Kk;
if (Q)
goto L__22;
Jjj = Park(2);
L__22:
Csexp(1, 1);
P++;
Prx(0x4C, 1, 0, Bs, Dp + 14);
Unpark(0x5A, 1, Jjj);
goto L__9;
L__31:;
Rr = Getarrwsp();
for (Pp = 0; Pp <= Jj - 1; Pp++) {
Csexp(0, 1);
P++;
Dump(1, Nest, Rr + (Pp << 2), 0, Rbase);
}
Dump(0, 1, Rr + (Pp << 2), 0, Rbase);
Dump(0, 2, Dp, 0, Bs);
Ppj(24);
Jjj = 1;
Push(Mdarr[Level], 0, Rr);
goto L__11;
L__99:
J = Jj;
}
void Cename(int Z, int Mode, int Bs,
int Dp) { // MODE=0 POINTER TO RECORD IN CORE AT BS & Dp
// MODE=1 POINTER TO RECORD IN REGISTER BS DP RUBBISH
// MODE=2 RECORD REG CLAIMED
int Q;
int Qqq;
int Bsrf;
int Dprf;
if (A[P] == 1)
goto L__2;
if (Z >= 14)
goto L__1;
Fault(64);
P -= 2;
Ptype = 1;
Unpack();
goto L__99;
L__1:
Base = Bs;
Disp = Dp;
if (Mode)
Disp = -1;
Index = 0;
goto L__99;
L__2:
P++;
Q = Displacement(Fname);
Unpack();
if (Q == -1)
goto L__98;
if (Type == 3)
goto L__50;
if (Arr == 1)
goto L__20;
if (Type == 5)
goto L__30;
if (Mode)
goto L__11;
Rp13 = R13;
R13 = Bs << 12 | Dp;
if (R13 != Rp13)
Prx(0x58, Link, 0, Bs, Dp);
Base = Link;
L__7:
Index = 0;
Disp = Q;
if (Rout == 1)
From1(Q, Disp);
goto L__99;
L__11:
Base = Bs;
goto L__7;
L__20:;
Fromlist(Fname, Bsrf, Qqq);
Bsrf = Bsrf >> 4 & 15;
From1(Qqq, Dprf);
if (Z < 10 || A[P + 1] == 1)
goto L__21;
K = Dprf + Q;
I = Bsrf;
if (!Mode)
Dump(2, 1, Dp, 0, Bs);
goto L__99;
L__21:
if (Mode != 0 || Bs >= 4)
goto L__22;
Dump(2, 1, Dp, 0, Bs);
Mode = 1;
Bs = 1;
L__22:
if (Mode == 1)
Qqq = Park(1);
Caname(3, Bsrf, Dprf + Q, K, 0, 0);
R13 = 0;
if (!Mode)
Prx(0x5A, Index, Bs, 0, Dp);
if (Mode == 1)
Unpark(0x5A, Index, Qqq);
if (Mode == 2)
Prr(0x1A, Index, Bs);
I = Bsrf;
K = Dprf + Q;
goto L__99;
L__30:
Fromlist(Fname, Bsrf, Qqq);
From1(Qqq, Dprf);
Bsrf = Bsrf >> 4 & 15;
if (Mode != 0 && Bs != 1)
Prr(0x18, 1, Bs);
if (!Mode)
Prx(0x58, 1, Bs, 0, Dp);
Prx(0x5A, 1, Bsrf, 0, Dprf + Q);
Base = 1;
Index = 0;
Disp = 0;
I = Bsrf;
K = Dprf + Q;
goto L__99;
L__50:;
if (!Mode)
Dump(2, 1, Dp, 0, Bs);
if (Mode)
Prr(0x18, 1, Bs);
From2(Q, Qqq);
Crname(Z, 1, K, 1, Qqq);
goto L__99;
L__98:
P++;
Skipapp();
P -= 2;
L__99:;
}
void Crname(int Z, int Mode, int Clink, int Bs,
int Dp) { // DEALS WITH RECORD NAME CALLING CENAME TO COMPILE
// SUBFIELDS MODE=0 POINTER TO RECORD IN CORE AT BS &
// Dp MODE=1 POINTER TO RECORD IN REGISTER BS DP
// RUBBISH CLINK POINTS TO CELL CONTAING NAME DETAILS
int Kk;
int Jj;
int Q;
int Qq;
From2(Clink, Q);
From1(Q, Fname);
if (!Arr)
goto L__50;
I = Bs;
K = Dp;
if (11 <= Z && Z <= 12 && A[P + 1] == 2)
goto L__99;
Fromlist(Fname, Kk, Jj);
Kk = Kk >> 4 & 15;
From1(Jj, Jj);
if (Mode == 2)
Prr(0x1A, Index, Bs);
if (Mode != 0 || Bs >= 4)
goto L__3;
Dump(2, 1, Dp, 0, Bs);
Mode = 1;
Bs = 1;
L__3:;
Qq = Bs;
if (Mode == 1)
Qq = Park(Bs);
Caname(Z, Qq, Dp, Clink, Kk, Jj + 2);
From1(Q, Fname);
if (Mode == 1)
Register[Qq] = 0;
Prr(0x1A, 1, Link);
Cename(Z, 1, 1, 0);
goto L__99;
L__50:
P++;
if (A[P] == 2)
goto L__51;
Fault(19);
Skipapp();
L__51:
P++;
if (Inreg == 0 || Z == 14)
Cename(Z, 0, Bs, Dp);
else
Cename(Z, 2, Inreg, 0);
L__99:;
}
void Cname(int Z, int Reg) {
int Jj;
int Jjj;
int Kk;
int Rr;
int Ptypep;
int Levelp;
int Dispp; // Z=0-RTCALL,Z=1STORE(=), Z=2 FETCH,Z=3 FETCH ADDR,Z=4%C
// STORE N<-), Z=6 STORE PTR, Z=12 FETCH ARRAYHEAD, Z=11 STORE %C
// ARRAY Head
static int S_sw;
static void *S[6 /*10:15*/] = {
&&S_default, &&S_11, &&S_12, &&S_13, &&S_14, &&S_15,
};
static int Funny_sw;
static void *Funny[6 /*10:15*/] = {
&&Funny_default, &&Funny_11, &&Funny_12,
&&Funny_13, &&Funny_14, &&Funny_15,
};
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_8,
};
static int Mod_sw;
static void *Mod[32 /*0:31*/] = {
&&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,
};
Fname = A[P];
Copytag(Fname);
if (I != -1)
goto L__3;
Fault(16);
I = Level;
J = 0;
K = Fname;
Ptype = 7;
Storetag(K, N);
K = N;
N += 4;
Unpack();
L__3:
Jj = J;
if (Jj == 15)
Jj = 0;
Levelp = I;
Dispp = K;
if (Type == 7)
goto L__502;
if (Z == 0 && (Rout != 1 || 0 != Type && Type != 6))
goto L__500;
if (Z >= 10)
goto *Funny[Funny_sw = (Z)-10];
if (Rout == 1)
goto L__501;
goto *Sw[Sw_sw = Type];
L__500:
if (Type == 3)
goto *Sw[Sw_sw = 3];
if (Type != 7)
Fault(17);
goto L__502;
Sw_6:
if (Z != 3 || Arr != 1)
goto L__661;
K = K << 2;
Arr = 0;
I = 10;
goto L__600;
Sw_4:;
L__661:
Fault(20);
Sw_7:
L__502:
P++;
Ptype = 1;
Unpack();
if (A[P] == 2)
goto L__6;
goto L__102;
Funny_11:
if (Type == 3)
goto L__1011;
if (Arr != 1 || Nam != 1 || K >> 12 != 0)
Fault(17);
Prx(0x90, 0, 3, I, K);
goto L__91;
L__1011:
Pclod(44);
goto *Sw[Sw_sw = 3];
S_11:
Mover(Wspr, -16);
Pss(0xD2, 16, 1, 0, Wspr, 0);
goto L__91;
Funny_12:
if (Type == 3)
goto *Sw[Sw_sw = 3];
if (Arr == 2)
goto L__1202;
if (Arr != 1)
Fault(17);
L__1201:
Prx(0x98, 0, 3, I, K & 4095);
goto L__91;
L__1202:
From2(K, K);
goto L__1201;
S_12:
if (Type == 3 && Arr == 1)
goto L__1201;
Prr(0x18, 0, 1);
Prx(0x5A, 0, 0, I, K);
Prx(0x5A, 1, 0, I, K + 4);
Prx(0x98, 2, 3, I, K + 8);
goto L__91;
Funny_13:;
if (Type == 3)
goto *Sw[Sw_sw = 3];
if (Ptype == 10006)
goto L__1302;
if (Rout == 1 && (Nam & 1) == 1)
goto L__1301;
Base = Gla;
From1(K, Disp);
Index = 0;
Disp = Ra[Disp];
if (J == 14)
Disp += 4;
L__1300:
if (Rout != 1)
goto L__500;
goto L__91;
L__1301:
Base = I;
From1(K, Disp);
Index = 0;
goto L__91;
L__1302:
Csname(Z, Reg);
goto L__6;
S_13:
From2(K, K);
goto L__1300;
Funny_15:;
if (Ptype == 10006)
goto L__1501;
Funny_14:;
Rr = 0;
if (Arr == 0 && Inreg != 0 && A[P + 1] == 2 && 2 == A[P + 2])
Rr = Inreg;
if (Type == 3)
goto *Sw[Sw_sw = 3];
goto L__661;
S_14:
if (Type != 3 || Nam != 1)
Fault(20);
if (Reg != Rr && Rr != 0)
Prr(0x18, Rr, Reg);
if (Disp < 0)
Disp = 0;
if (R13 == (Base << 12 | Disp))
R13 = 0;
L__1401:
Dump(Z - 13, Reg, Disp, Index, Base);
P++;
goto L__9005;
S_15:
if (Type != 3)
goto L__661;
if (Disp >= 0)
goto L__1401;
Dump(0, Reg, 0, Index, Base);
P++;
goto L__9005;
L__1501:
Csname(Z, Reg);
if (A[P] != 2 || A[P + 1] != 2)
Fault(22);
P += 2;
goto L__9005;
Sw_3:;
From2(K, Jjj);
Crname(Z, 0, Tags[A[P]], I, Jjj);
if (Z >= 10)
goto *S[S_sw = (Z)-10];
if (Type == 5)
goto L__5020;
if (Z)
goto L__601;
if (Rout != 1 || Nam != 1)
goto L__500;
Levelp = Park(Base);
Rr = Disp;
Ptypep = Ptype;
From2(K, Jj);
From2(Jj, K);
goto L__22;
Sw_5:;
Base = I;
Index = 0;
Disp = K;
Jjj = 2;
if (Arr != 1)
goto L__5000;
Caname(Z, I, K, Tags[Fname], 0, 0);
L__4998:
Nam = Nam >> 1;
Jjj = 0;
if (Z != 3)
goto L__5000;
Dump(0, Reg, Disp, Index, Base);
if (Checks)
Prx(0x58, 2, 0, Levelp, Dispp + 8);
Paclod(10, 6, Reg << 4);
goto L__9;
// L 2,LMAX. BCTR 2,0. SLL 2,24. OR REG,2
L__5000:
if (2 <= Z && Z <= 3)
goto L__605;
if (Reg != 4)
Prr(0x18, 4, Reg);
Dump(Jjj, 1, Disp, Index, Base);
if (!Arr)
goto L__5001;
if (Z == 4 || Checks != 0)
Prx(0x58, 2, 0, Levelp, Dispp + 8);
I = 2;
K = 3;
L__5001:
Storestring(Z, 4, 1, I, K);
goto L__9;
L__5020:;
if (Arr == 1)
goto L__5025;
if (2 <= Z && Z <= 3)
goto L__9;
if (Reg != 4)
Prr(0x18, 4, Reg);
goto L__5001;
L__5025:;
Levelp = I;
Dispp = K;
goto L__4998;
Sw_8:;
if ((1 > Z || Z > 2) && Z != 4)
Fault(29);
if (K == Reg)
goto L__9;
if (Z == 2)
Prr(0x18, Reg, K);
else
Prr(0x18, K, Reg);
goto L__9;
Sw_0:
if (Z != 3 && Z <= 10) {
Fault(12);
Type = 1;
Ptype++;
}
Sw_2:;
Sw_1:
if (!Arr)
goto L__600;
Caname(Z, I, K, Tags[Fname], 0, 0);
if (!Type)
Type = 1;
Nam = Nam >> 1;
goto L__601;
L__501:
if (Z == 0 || Ptype != 10000)
goto L__503;
Fault(23);
Printname(A[P]);
goto L__503;
L__503:
Ptypep = Ptype;
if (Ptype != 10006)
goto L__20;
Csname(Z, Reg);
if (Rout == 1 && Nam >= 1 && Z != 0)
goto L__202;
goto L__6;
L__20:
Kk = K;
Fromlist(Kk, Rr, K);
L__22:
if (K != 1000)
goto L__21;
Fault(21);
goto L__502;
L__21:
Crcall(Kk);
Ptype = Ptypep;
Unpack();
if ((Nam & 1) == 1)
goto L__37;
if (Jj == 14)
goto L__36;
Dump(2, 1, Ra[Rr], 0, Gla);
Prx(0x45, Link, 0, Gla, 116);
L__371:
Mone = 1;
R13 = 0;
P++;
if (Ptype == 10000 || Ptype == 11000)
goto L__1;
if (Nam > 1)
goto L__201;
if (Z != 2)
Fault(29);
if (Type == 2)
goto L__43;
L__44:
if (Reg != 1)
Prr(0x18, Reg, 1);
goto L__1;
L__43:
if (Reg != 2)
Prr(0x28, Reg, 2);
goto L__1;
L__36:;
Paclod(55, 4, Ra[Rr] + 4);
goto L__371;
L__37:;
if (Levelp < Rbase)
Register[Levelp] = 0;
Paclod(61, 4,
Levelp << 12 |
Rr); // STM 4,14,?--LM 12,15 ? -- LM 5,9,20(15) -- BALR 15,14
goto L__371;
L__201: // - REAL MAPS AND INTEGER MAPS
Nest = 1;
L__202:;
if (Type == 5)
goto L__205;
if (Z == 3)
goto L__203;
Jjj = Z;
if (Z == 4)
Jjj = 1;
Jjj += (Type << 3) + (Prec << 1) - 8;
Dump(Jjj, Reg, 0, 0, Nest);
if (Z == 1 && Checks == 1)
Checkcapacity(Reg, 0, 0, Nest);
if (Z == 2 && Unass == 1)
Testass(Reg);
goto L__1;
L__203:
if (Reg != Nest)
Prr(0x18, Reg, Nest);
goto L__1;
L__205: // STRING MAPS
if (Nest != 1)
Prr(0x18, 1, Nest);
if (2 <= Z && Z <= 3)
goto L__206;
Storestring(Z, Reg, 1, 0, 255);
goto L__1;
L__206:
Pclod(69);
goto L__44;
L__600:
Base = I;
Index = 0;
Disp = K;
L__601:
if (Z == 6)
goto L__602;
goto *Mod[Mod_sw = Nam << 4 | Prec << 2 | Z & 3];
L__602:
if (!Nam)
Fault(17);
if (R13 == (Base << 12 | Disp))
R13 = 0;
Jjj = 1;
goto L__605;
Mod_1:;
Mod_0:;
Mod_5:;
Mod_4:;
Mod_9:;
Mod_8:;
Mod_12:;
Mod_13:;
Mod_2:;
Mod_14:;
Jjj = Z;
if (Z == 4)
Jjj = 1;
Jjj += (Type << 3) + (Prec << 1) - 8;
L__605:
Dump(Jjj, Reg, Disp, Index, Base);
if (Z == 1 && Checks == 1)
Checkcapacity(Reg, Disp, Index, Base);
if (Z == 2 && Unass == 1)
Testass(Reg);
goto L__9;
Mod_31:;
Mod_19:;
Mod_23:;
Mod_27:;
Jjj = 2;
goto L__605;
Mod_15:;
Mod_3:;
Mod_7:;
Mod_11:;
Jjj = 0;
goto L__605;
Mod_6:;
Mod_10:;
Jjj = (Prec << 1) + 2;
goto L__605;
Mod_16:;
Mod_20:;
Mod_24:;
Mod_17:;
Mod_21:;
Mod_25:;
Mod_28:;
Mod_29:;
Mod_18:;
Mod_22:;
Mod_26:;
Mod_30:;
Rp13 = R13;
R13 = Base << 12 | Disp;
if (R13 != Rp13 || Index != 0)
Prx(0x58, Link, Index, Base, Disp);
Jjj = Z;
if (Z == 4)
Jjj = 1;
Jjj += (Type << 3) + (Prec << 1) - 8;
Dump(Jjj, Reg, 0, 0, Link);
if (Z == 1 && Checks == 1)
Checkcapacity(Reg, 0, 0, Link);
if (Z == 2 && Unass == 1)
Testass(Reg);
L__9:
if (Arr)
goto L__1;
L__91:
P++;
if (A[P] == 2)
goto L__6;
Fault(19);
L__102:
Skipapp();
goto L__1;
L__6:
P++;
L__1:
P++;
if (A[P - 1] == 2)
goto L__9005;
Fault(69);
goto L__91;
L__9005:;
goto Funny_skip;
Funny_default:
fprintf(stderr, "Switch label 'Funny(%d):' not set in %s", Funny_sw + 10,
__PRETTY_FUNCTION__);
exit(1) /* or %signal ... */;
Funny_skip:;
goto S_skip;
S_default:
fprintf(stderr, "Switch label 'S(%d):' not set in %s", S_sw + 10,
__PRETTY_FUNCTION__);
exit(1) /* or %signal ... */;
S_skip:;
}
void Crcall(int Clink) {
static int Fpd_sw;
static void *Fpd[4 /*0:3*/] = {
&&Fpd_0,
&&Fpd_1,
&&Fpd_2,
&&Fpd_3,
};
int Kk;
int Ii;
int Iii;
int Q;
int Qq;
int Qqq;
int Pp;
int Rf;
auto void Moveback(void);
int Moved;
int Tomove;
int Typep;
short List;
List = 0;
Fflag = 0;
Kk = Countaps();
P++;
if (K == Kk)
goto L__2;
Fault(19);
Printname(Fname);
Skipapp();
P--;
goto L__99;
L__2:
if (!K)
goto L__99;
Q = 0;
Qq = 64;
Rf = 1 - Fflag;
Moved = 0;
if (Kk == 1)
Rf = 1;
L__7:
Mlink(Clink);
From1(Clink, Ptype);
P++;
Unpack();
Ii = Type;
Iii = Prec;
Qqq = P;
Pp = (Nam << 1 | Arr) & 3;
if ((Pp != 0 || Rout != 0) && (A[P] != 4 || A[P + 1] != 1))
goto L__10;
if (Rout == 1)
goto L__12;
goto *Fpd[Fpd_sw = Pp];
L__10:
P = Qqq;
Skipexp();
L__11:
Fault(22);
goto L__53;
// ROUTINE TYPE PARAMETERS
L__12:
Ii = Ptype;
P += 2;
Cname(13, 0);
if (1000 != abs(Ptype - Ii) && abs(Ptype - Ii) != 0)
goto L__10;
if (A[P] == 1)
goto L__10;
P++;
if (J == 14)
goto L__13;
if (Nam & 1)
goto L__15;
Dump(2, 2, Disp, Index, Base);
Prx(0x5A, 2, 0, Gla, 28);
Pconst(0x180C181D);
Push(List, Qq + 12, 0);
goto L__69;
L__13:
Prx(0x98, 0, 2, Base, Disp);
Prr(0x18, 3, 9);
goto L__69;
L__15:
Prx(0x98, 0, 3, Base, Disp);
goto L__69;
Fpd_0:
if (Prec == 3)
goto L__41;
if (Type == 5)
goto L__45;
if (Unass != 0 || Type != 1)
goto L__39;
Pp = P;
Typep = Prec;
Ii = Tsexp(Iii);
if (Ii == 10 && Typep == 0)
goto L__42;
if (Ii == 1 && Typep == 1)
goto L__43;
P = Pp;
Type = 1;
L__39:
Csexp(0, Type);
Moveback();
Dump(8 * Type - 7, Nest, Qq - Moved, 0, Wspr);
if (Checks == 1)
Checkcapacity(Nest, Qq - Moved, 0, Wspr);
Tomove = 4;
goto L__50;
L__42:
Moveback();
Pss(0xD2, 4, Wspr, Qq - Moved, I, K);
Tomove = 4;
goto L__50;
L__43:
Moveback();
Psi(0x92, Iii, Wspr, Qq - Moved + 3);
Tomove = 4;
goto L__50;
L__41:
Ii = 0;
if (Qq & 7)
Ii = 4;
Csexp(0, 3);
Dump(15, Nest, Qq - Moved + Ii, 0, Wspr);
Tomove = 8 + Ii;
goto L__50;
L__45:
Cstrexp(4);
From2(Clink, Iii);
Prx(0x41, 1, 0, Wspr, Qq - Moved + 4);
Storestring(1, 4, 1, 0, Iii - 1);
Tomove = (Iii + 7) & (-4);
goto L__50;
Fpd_2:;
P += 2;
if (Type == 3)
Cname(15, 1);
else
Cname(3, 1);
if (A[P] == 1)
goto L__10;
P++;
if ((Ii != Type || Iii != Prec) && Ii != 0)
goto L__11;
Moveback();
Dump(1, 1, Qq - Moved, 0, Wspr);
Tomove = 4;
if (Ii)
goto L__50;
if (2 < Type)
Fault(12);
Psi(0x92, Prec << 3 | Type, Wspr, Qq - Moved);
goto L__50;
Fpd_1:
Fpd_3:;
P += 2;
Cname(12, 0);
if (A[P] == 1)
goto L__10;
P++;
From2(Clink, Pp);
if (!Pp)
Replace2(Clink, J);
if (Arr <= 0 || (J != 0 && Pp != 0 && J != Pp))
Fault(22);
if (Ii != 0 && (Type != Ii || Iii != Prec))
Fault(22);
L__69:
Moveback();
Prx(0x90, 0, 3, Wspr, Qq - Moved);
Tomove = 16;
L__50:
Qq += Tomove;
if (Rf == 1 || Q == Kk - 1)
goto L__53;
Ii = ((Qq + 7) & (-8)) - Moved;
Mover(Wspr, Ii);
Moved += Ii;
L__53:
Q++;
if (Q != Kk)
goto L__7;
if (Rf != 1)
Mover(Wspr, -Moved);
L__55:
Pop(List, Q, Qq);
if (Q == -1)
goto L__99;
Prx(0x50, Wspr, 0, Wspr, Q);
goto L__55;
void Moveback(void) {
if (Qq >= Moved)
goto L__1;
Mover(Wspr, Qq - Moved);
Moved = Qq;
L__1:;
}
L__99:;
}
// Z=1 FOR= ,4 FOR <- AND MAX LENGTH IN BYTE DEFINED BY BML&Dml
void Storestring(int Z, int From, int To, int Bml,
int Dml) { // REGISTER 2 IS ASSUMED TO BE USABLE.
if (To != 1 || From != 4)
Fault(239);
if (Z == 4)
goto L__10;
if (!Checks)
goto L__2;
if (Bml > 0)
goto L__1;
Psi(0x95, Dml, From, 0);
goto L__3;
L__1:;
Pss(0xD5, 1, From, 0, Bml, Dml);
L__3:;
Prx(0x47, 2, 0, Coder, 88);
L__2:
Prx(0x43, 2, 0, From, 0);
Prx(0x44, 2, 0, Gla, Strinst);
goto L__99;
L__10:
Prx(0x43, 2, 0, Bml, Dml);
Ppj(39);
L__99:;
}
void Testnst(void) {
Fname = K;
if (Find(Fname, Name[Level]) != -1)
Fault(7);
}
void Cuci(void) {
auto void Dxb(void);
auto void Dlb(void);
auto void Db(void);
auto void Cucs(void);
int Z;
int Kk;
int X;
int Opcode;
int Reg;
static int Sw_sw;
static void *Sw[4 /*1:4*/] = {
&&Sw_1,
&&Sw_2,
&&Sw_3,
&&Sw_4,
};
static int S_sw;
static void *S[8 /*1:8*/] = {
&&S_1, &&S_2, &&S_3, &&S_4, &&S_5, &&S_6, &&S_7, &&S_8,
};
P = 2;
goto *Sw[Sw_sw = (A[P]) - 1];
Sw_1:;
Nest = A[3];
P = 5;
Z = A[4] - 1;
if (!Z)
Z = 3;
Cname(Z, Nest);
goto L__99;
Sw_2:
Ppj(A[P + 1]);
goto L__99;
Sw_4:;
if (A[P + 1] != 9)
goto L__401;
Plant(A[P + 2]);
P += 3;
goto L__99;
L__401:
if (A[P + 1] != 1)
Fault(32);
Plant(A[P + 3]);
P += 4;
goto L__99;
Sw_3:
Opcode = A[P + 2];
P += 3;
goto *S[S_sw = (A[P - 2]) - 1];
S_1:
if (!Opcode)
goto L__87;
Prr(Opcode, A[P], A[P + 1]);
P += 2;
goto L__99;
S_2:
Reg = A[P];
P++;
Dxb();
L__11:
Prx(Opcode, Reg, X, I, K);
goto L__99;
S_3:
Reg = A[P];
X = A[P + 1];
P += 2;
Db();
goto L__11;
S_4:
Db();
Z = 0;
if (A[P] == 2)
goto L__41;
Z = A[P + 2];
if (A[P + 1] != 9 || Z >= 256)
Fault(32);
P += 2;
L__41:
Psi(Opcode, Z, I, K);
P++;
goto L__99;
S_5:
Reg = A[P];
P++;
Db();
X = 0;
goto L__11;
S_6:
Dlb();
Kk = K;
Z = X;
Reg = I;
Db();
if (!Z)
Z = 1;
L__61:
Pss(Opcode, Z, Reg, Kk, I, K);
goto L__99;
S_7:
Dlb();
Kk = K;
Z = X;
Reg = I;
Dlb();
if (!Z)
Z = 1;
if (!X)
X = 1;
Z = (Z - 1) << 4 | X;
goto L__61;
S_8:
Reg = A[P];
P++;
if (Opcode == 0x80)
goto L__85;
if (Opcode == 10)
goto L__83;
Prr(Opcode, Reg, 0);
goto L__99;
L__83:
Plant(0xA00 | Reg);
goto L__99;
L__85:
Psi(Opcode, Reg, 0, 0);
goto L__99;
L__87:
Cnop(A[P], A[P + 1]);
goto L__99;
void Db(void) {
if (A[P] == 1)
goto L__2;
K = A[P + 1];
I = 0;
P += 3;
if (A[P - 1] == 2)
goto L__99;
I = A[P];
P++;
goto L__99;
L__2:
Cucs();
L__99:;
}
void Dxb(void) {
static int Sw_sw;
static void *Sw[3 /*1:3*/] = {
&&Sw_1,
&&Sw_2,
&&Sw_3,
};
if (A[P] == 2)
goto L__2;
Cucs();
X = 0;
P++;
if (A[P - 1] == 2)
goto L__99;
X = A[P];
P++;
goto L__99;
L__2:
K = A[P + 1];
P += 2;
I = 0;
X = 0;
goto *Sw[Sw_sw = (A[P]) - 1];
Sw_1:
X = A[P + 1];
P++;
Sw_2:
I = A[P + 1];
P++;
Sw_3:
P++;
L__99:;
}
void Dlb(void) {
if (A[P] == 2)
goto L__2;
K = A[P + 1];
X = A[P + 2];
I = A[P + 3];
P += 4;
goto L__99;
L__2:
Cucs();
X = A[P];
P++;
L__99:;
}
void Cucs(void) {
static int Utype_sw;
static void *Utype[9 /*0:8*/] = {
&&Utype_0, &&Utype_1, &&Utype_2, &&Utype_3, &&Utype_4,
&&Utype_5, &&Utype_6, &&Utype_7, &&Utype_8,
};
P++;
if (A[P] == 2)
goto L__10;
Fname = A[P + 1];
Copytag(Fname);
P += 3;
if (I != -1)
goto L__1;
Fault(16);
J = 0;
I = Level;
Ptype = 7;
Unpack();
Storetag(Fname, N);
K = N;
N += 4;
L__1:
if (Rout == 1)
Fault(33);
goto *Utype[Utype_sw = Type];
Utype_3:
From2(K, K);
goto L__9;
Utype_4:
From1(K, K);
goto L__9;
Utype_8:
Fault(33);
goto L__9;
Utype_6:
From1(K, K);
K -= Codebase[Oldi];
if (K > 4095)
Fault(99);
I = 10;
Utype_0:
Utype_1:
Utype_2:
Utype_5:
Utype_7:;
if (Arr != 2)
goto L__9;
From2(K, K);
L__9:
if (A[P - 1] == 2)
goto L__99;
K += A[P];
P++;
goto L__99;
L__10:
K = A[P + 2] + ((A[P + 1] - 1) << 14);
J = Find(K, Label[Level]);
if (J == -1)
goto L__25;
K = J - Codebase[Level];
I = 10;
if (K > 4095)
Fault(99);
P += 3;
goto L__99;
L__25:
Push(Jump[Level], Ca | Labset, K);
K = 0;
I = 0;
P += 3;
L__99:;
}
L__99:;
}
void Testass(int Reg) {
int J;
if (1 > Type || Type > 2)
return;
if (Type == 1)
goto L__5;
J = 0x79;
if (Prec == 3)
J = 0x69;
L__3:
Prx(J, Reg, 0, Gla, 128);
Prx(0x47, 8, 0, Coder, 40);
goto L__99;
L__5:
if (Prec)
goto L__99;
J = 0x59;
goto L__3;
L__99:;
}
void Gxref(int Name, int Hash) {
int I;
int J;
int K;
int N;
int Np;
I = N0;
N0 += 7;
J = Word[Name];
St[I + 1] = 0;
St[I + 2] = 0;
St[I + 3] = 0;
N = Lett[J];
Np = N;
if (Np > 8)
Np = 8;
K = Addr(St[I + 5]);
if (!Hash)
goto L__1;
St[I + 5] = Hash << 16 | '#' << 8;
K += 2;
N += 2;
if (Np > 6)
Np = 6;
L__1:
for (Np = 1; Np <= Np; Np++)
*Byteinteger(K + Np) = Lett[J + Np];
if (N > 8)
N = 8;
St[I + 4] = 0x80000000;
St[I] = Xreflink;
Xreflink = I << 2;
*Byteinteger(Addr(St[I + 5])) = N;
if (N == 8)
N0++;
}
void XUndcrf(short *Ophead) {
int I;
int J;
short Op; // UNSCRAMBLES RECORD FORMAT TAGS LIST & SIDECHAIN
Pop(*Ophead, I, J);
L__1:
Pop(*Ophead, I, J);
if (I == -1)
goto L__9;
Op = J;
Ptype = I >> 4 & 0xFFFF;
Unpack();
if (Rout == 1 || Type == 3)
Clearlist(Op);
goto L__1;
L__9:;
}
void Clt(void) { // P ON PHRASE TYPE AT ENTRY - TO NEXT PHRASE AT EXIT
Type = Typeflag[A[P]];
Prec = Type >> 3;
Type = Type & 7;
if (Type == 2 && Alllong != 0)
Prec = 3;
Acc = Bytes[Prec];
P++;
if (Type != 5)
goto L__99;
if (A[P] != 2)
goto L__2;
Acc = 0;
P++;
goto L__99;
L__1:
P++;
Fault(70);
goto L__99;
L__2:
P++;
Acc = A[P] + 1;
if (2 > Acc || Acc > 256)
goto L__1;
P++;
L__99:;
}
void Cqn(int P) {
unsigned char I;
I = A[P];
Nam = 0;
Arr = 0;
if (I == 1)
Nam = 2;
if (I <= 2)
Arr = 1;
if (I <= 3)
Nam = Nam | 1;
if (Arr == 1)
Acc = 16;
if (I == 3)
Acc = 4;
}
void Skipexp(void) {
static int Sw_sw;
static void *Sw[4 /*1:4*/] = {
&&Sw_1,
&&Sw_2,
&&Sw_3,
&&Sw_4,
};
int J;
static int Rt = 10000;
L__3:
P++;
goto *Sw[Sw_sw = (A[P]) - 1];
Sw_1:
P += 2;
J = Addr(Aslist[Tags[A[P - 1]]]);
if (*Shortinteger(J) < Rt)
goto L__5; // ->5 %IF SHORT INTEGER(J)<RT; FFLAG=1
Fflag = 1;
L__5:
Skipapp();
P++;
if (A[P - 1] == 2)
goto L__1;
P++;
goto L__5;
Sw_2:;
P++;
J = A[P];
if (J == 9) {
P += 2;
goto L__1;
}
if (J == 1) {
P += 3;
goto L__1;
}
if (J == 2) {
P += 5;
goto L__1;
}
P = P + (A[P + 1] & 0xFE) + 3;
goto L__1;
Sw_3:
Sw_4:
P++;
Skipexp();
L__1:
P++;
if (A[P - 1] == 1)
goto L__3;
}
void Skipapp(void) {
L__5:
P++;
if (A[P - 1] == 2)
goto L__1;
Skipexp();
goto L__5;
L__1:;
}
void Cquery(int Reg) {
Psi(0x95, 0, Gla, 1);
Pj(8, Plabel - 1);
if (Type == 2)
goto L__1;
if (Type == 5)
goto L__5;
if (Reg != 1)
Prr(0x18, 1, Reg);
Pconst(0x4120000B);
Ppj(4);
goto L__9;
L__1:
Pconst(0x41100020);
Ppj(3);
if (!Qpreal) {
Qpreal = (N0 << 2) + 4;
St[N0] = Xreflink;
Xreflink = Qpreal - 4;
St[N0 + 4] = 8;
St[N0 + 5] = 'I#PR';
St[N0 + 6] = 'INTF';
N0 += 7;
}
Paclod(
82, 1,
Reg << 4); // STD REG,64(11).LA 0,12.ST 0,68(11) %ABD SS ENTRYPRINTF
Paclod(55, 4, Qpreal);
goto L__9;
L__5:
Pconst(0x4110000A);
Ppj(3);
Prr(0x18, 1, Reg);
Ppj(5);
L__9:
Plab(-1);
}
void Loadad(int Reg, int Base, int X, int Disp) {
int I;
Prx(0x41, Reg, X, Base, Disp & 4095);
I = Pageno(Disp);
if (4095 < Disp)
Prx(0x5A, Reg, 0, Gla, 4 * I);
}
int XTsexp(int *Code) {
static int Sw_sw;
static void *Sw[4 /*1:4*/] = {
&&Sw_1,
&&Sw_2,
&&Sw_3,
&&Sw_4,
};
Type = 1;
if (1 != A[P] && A[P] != 4)
goto L__9;
goto *Sw[Sw_sw = (A[P + 1]) - 1];
Sw_1:
*Code = A[P + 2];
Copytag(*Code);
if (Ptype == 10006) {
Type = Tsname[K];
Prec = Type >> 3;
Type = Type & 7;
}
if (Type == 8)
goto L__40;
if (Type == 3 && Arr == 0 && Inreg != 0)
goto L__30;
if (Arr == 2 && Type == 1)
goto L__50;
if (A[P + 3] != 2 || 2 != A[P + 4])
goto L__9;
if (Rout != 0 || Arr != 0)
goto L__9;
if (Type == 5)
goto L__20;
if (Nam)
goto L__9;
if (Type == 2)
goto L__14;
if (Type != 1)
goto L__9;
if (A[P + 5] == 2)
goto L__11;
if (A[P + 6] != 2 || 2 != A[P + 7])
goto L__9;
if (A[P + 8] != 9 || A[P + 10] != 2)
goto L__9;
*Code = A[P + 9];
P += 11;
return (100);
L__11:
P += 6;
return (10 + Prec);
L__14:
if (A[P + 5] != 2)
goto L__9;
P += 6;
return (14 + (Prec & 1));
L__20:
if (A[P + 5] != 2)
goto L__9;
P += 6;
return (20);
L__30:
if (A[P + 3] != 2 || A[P + 4] != 1)
goto L__9;
P += 5;
From1(K, Fname);
I = Inreg;
K = Displacement(Fname);
Unpack();
if (I == -1 || Arr != 0 || Rout != 0)
goto L__9;
if (1 > Type || Type > 2 || A[P + 1] != 2 || 2 != A[P + 2])
goto L__9;
if (A[P + 3] != 2)
goto L__9;
P -= 2;
if (Type == 1)
goto L__11;
goto L__14;
L__40:
if (A[P + 5] == 2)
goto L__41;
if (A[P + 6] != 2 || 2 != A[P + 7])
goto L__9;
if (A[P + 8] != 9 || A[P + 10] != 2)
goto L__9;
*Code = A[P + 9];
P += 11;
return (101);
L__41:
P += 6;
return (50);
L__50:
if (A[P + 3] != 1 || A[P + 4] != 4 || A[P + 5] != 2)
goto L__9;
if (A[P + 6] != 9 || A[P + 7] >= 256 || A[P + 8] != 2)
goto L__9;
if (A[P + 9] != 2 || A[P + 10] != 2 || A[P + 11] != 2)
goto L__9;
From1(K, K);
K += A[P + 7] * Bytes[Prec];
if (0 > K || K >= 4096)
goto L__9;
P += 12;
return (10 + Prec);
Sw_2:
Type = A[P + 2] & 7;
if (A[P + 2] != 9)
goto L__9;
if (A[P + 4] == 1)
goto L__21;
*Code = A[P + 3];
P += 5;
if (256 > *Code)
return (1);
return (2);
L__21:
if (A[P + 5] == 12)
Type = 5;
Sw_3:
Sw_4:
L__9:
return (0);
}
void Mover(int R, int N) {
if (!N)
goto L__99;
if (0 > N)
goto L__2;
Dump(0, R, N, 0, R);
goto L__99;
L__2:
N = -N;
if (N != 4 && N != 8)
goto L__3;
Prx(0x5A, R, 0, Gla, 76 + N);
goto L__99;
L__3:
Pconst(0x41000000 | N);
Prr(0x1B, R, 0);
L__99:;
}
int Findpp(void) {
int I;
for (I = 9 - Rlevel; I >= 4; I--)
if (!Register[I])
goto L__1;
return (0);
L__1:
Register[I] = 1;
return (I);
}
void Unpark(int Opcode, int Reg, int Q) {
if (0 > Q)
goto L__1;
Prr(Opcode - 0x40, Reg, Q);
Register[Q] = 0;
goto L__9;
L__1:
Q = abs(Q);
Prx(Opcode, Reg, 0, Rbase, Q);
Push(Wsp[Level], 0, Q);
L__9:;
}
int Park(int Reg) {
int I;
int J;
int P;
P = Claimablereg();
if (!P)
goto L__1;
Register[P] = 1;
if (P == Reg)
goto L__2;
Prr(0x18, P, Reg);
L__2:
return (P);
L__1:
Pop(Wsp[Level], I, J);
if (J != -1)
goto L__3;
J = N;
N += 4;
L__3:
Dump(1, Reg, J, 0, Rbase);
return (-J);
}
int Claimablereg(void) {
int I;
if (Rbase <= 4)
goto L__1;
for (I = 5; I <= Rbase; I++)
if (!Register[I])
return (I);
L__1:
return (0);
}
int Parkf(int Reg, int Prec) {
int I;
int J;
if (Prec)
goto L__10;
Pop(Wsp[Level], I, J);
if (J != -1)
goto L__3;
J = N;
N += 4;
L__3:
Dump(9 + 2 * Prec, Reg, J, 0, Rbase);
return (J);
L__10:
J = Getdblewrd();
goto L__3;
}
int Getarrwsp(void) { // PRODUCES 6 CONTIGUOUS WORDS UNDER BASE
// REGISTER COVER FOR ARRAY ACCESS
int I;
int J;
Pop(Mdarr[Level], I, J);
if (J > 0)
goto L__1;
J = N;
N += 24;
L__1:
return (J);
}
void Rhead(int Kk) {
int Flag;
int W1;
int W2;
Flag = Kk;
if (!Rlevel)
Flag = 10000;
if (!Rlevel)
goto L__5;
if (List)
goto L__5;
Newline();
Write(Line, 5);
Spaces(3 * Level);
if (Kk < 0)
printf("%s", "BEGIN");
else {
printf("%s", "RT/FN/MAP ");
Printname(Kk);
}
Write(Ca, 6);
L__5:
Level++;
if (Flag < 0)
goto L__6;
Rlevel++;
Rbase = 10 - Rlevel;
R13 = 0;
if (Rbase == 4 || Register[Rbase] != 0)
Fault(35);
Register[Rbase] = 1;
L__6:
if (Level == 10)
Fault(34);
if (Level > Maxlevels)
Fault(105);
Nmdecs[Level] = 0;
if (Flag >= 0)
goto L__10;
Prx(0x90, 10, 11, Rbase, N);
N += 12;
W1 = Rbase;
W2 = N - 4;
goto L__20;
L__10:
if (Kk < 0)
goto L__25;
Fromlist(Jj, J, K);
St[Ra[J] >> 2] = Ca;
Prx(0x50, Link, 0, Wspr, 60);
W1 = Wspr;
W2 = 0;
L__20:
if (!Diags1)
goto L__21;
Pss(0xD2, 4, W1, W2, Gla, 20);
Loadad(0, 0, 0, Line);
Pconst(0x4000D014);
L__21:
Mone = 1;
Setline();
L__25:
if (Flag >= 0)
Prr(0x18, Rbase, Wspr);
if (Kk < 0)
W1 = 0;
else
W1 = Word[Kk];
L[Level] = Line;
M[Level] = W1;
Rnext[Level] = Next;
if (Flag < 0)
return;
Set[Rlevel] = Ca + 2;
Prx(0x41, Wspr, Wspr, 0, 0);
if (Checks)
Pclod(75);
N = 64;
Nmax = N;
}
void Set80(int Where, int N) {
if (N <= 2)
return;
int K;
Psi(0x92, 0x80, Rbase, Where);
N--;
K = Where;
L__1:
if (N <= 256)
goto L__2;
Pss(0xD2, 256, Rbase, K + 1, Rbase, K);
K += 256;
N -= 256;
goto L__1;
L__2:
Pss(0xD2, N, Rbase, K + 1, Rbase, K);
}
void XCbpair(int *Lb, int *Ub) {
int Kk;
int Kkk;
int Jj;
int Bp;
P++;
Kk = 0;
for (Jj = 1; Jj <= 2; Jj++) {
Kkk = Kk;
if (A[P] == 2)
Kk = -1;
else
Kk = 1;
if ((A[P + 1] & 7) == 2)
goto Real;
if ((A[P + 1] & 7) == 5)
goto String;
if (A[P + 1] == 9)
Bp = A[P + 2];
else {
Fromar4(P + 2, Bp);
P++;
}
Kk = Kk * Bp;
P += 3;
goto Again;
Real:
Fault(24);
P += 6;
Kk = 0;
goto Again;
String:
Fault(42);
P = (P * A[P + 2] & 0xFE) + 2;
Kk = 0;
Again:;
}
*Lb = Kkk;
*Ub = Kk;
}
void Loaddata(void) {
int Ldlink;
int Jj;
int Kk;
int Ptr;
int Jjj;
short Head;
Ldptr = 8 + 8 * Neps;
int Buffer[Ldptr + 1];
Buffer[0] = 7;
Buffer[2] = 88;
Buffer[3] = 0;
Buffer[4] = 0;
Buffer[5] = 0;
Buffer[6] = 64;
Ptr = 8;
Ldlink = 0;
L__1:
Pop(Eplink, Jj, Kk);
if (Jj < 0)
goto L__10;
Head = Kk;
Buffer[Ptr] = Ldlink;
Ldlink = Ptr << 2;
Buffer[Ptr + 1] = 0;
Buffer[Ptr + 2] = 0;
Buffer[Ptr + 3] = Jj;
Buffer[Ptr + 4] = 0x80000000;
Pop(Head, Buffer[Ptr + 5], Kk);
if (Kk > 3)
Pop(Head, Buffer[Ptr + 6], Jjj);
Ptr += 7;
if (Kk > 7) {
Pop(Head, Buffer[Ptr], Jjj);
Ptr++;
}
goto L__1;
L__10:
Buffer[1] = Ldlink;
Lput(3, Ptr << 2, 0, Addr(Buffer[0]));
Ldptr = Ptr;
}
void Defineep(int Mode, int Name, int Adr) {
short Head;
int Jj;
int Kk;
int Length;
int Id1;
int Id2;
int Id3;
static int Sw_sw;
static void *Sw[3 /*0:2*/] = {
&&Sw_0,
&&Sw_1,
&&Sw_2,
};
Kk = Word[Name];
Head = 0;
goto *Sw[Sw_sw = Mode];
Sw_0:
// DEFINE S#GO
Length = 4;
Id1 = 'S#G';
Id2 = 'O ';
goto L__10;
Sw_1:
// SYSTEM EP
Length = Lett[Kk] + 2;
Id1 = 'S#A';
for (Jj = 1; Jj <= 6; Jj++)
*Byteinteger(Addr(Id1) + Jj + 2) = Lett[Kk + Jj];
goto L__10;
Sw_2:
// ENTRY TO EXTERNAL ROUTINE
Length = Lett[Kk];
for (Jj = 1; Jj <= 8; Jj++)
*Byteinteger(Addr(Id1) + Jj) = Lett[Kk + Jj];
L__10:
if (Length > 8)
Length = 8;
*Byteinteger(Addr(Id1)) = Length;
if (Length > 7)
Push(Head, Id3, 0);
if (Length > 3)
Push(Head, Id2, 0);
Push(Head, Id1, Length);
Push(Eplink, Adr, Head);
Neps++;
}
void Redefineep(int Typep, int Params) {
int Jj;
int Kk;
short Ophead;
Jj = N0;
P -= 2;
Gxref(A[P], 'I');
K = Newcell();
Ophead = K;
if (!Params)
goto L__1;
for (Kk = 1; Kk <= Params; Kk++)
Insertafter(Ophead, Params, 0);
L__1:
I = 9;
J = 14;
Oldi = 0;
Ptype = Typep;
Replacetag(A[P]);
Replaceboth(K, Nr, Params);
Ra[Nr] = Jj << 2;
Nr++;
}
int Getdblewrd(void) { // PRODUCES A DOUBLE WORD OF TEMPORARY SPACE
// COVERED BY CURRENT BASE REGISTER (RBASE)
int I;
int J;
Pop(Lwsp[Level], I, J);
if (I != -1)
goto L__3;
if (!(N & 7))
goto L__2;
Push(Wsp[Level], 0, N);
N += 4;
L__2:
J = N;
N += 8;
L__3:
return (J);
}
int Getstrwsp(void) {
int I;
int J;
Pop(Strwsp[Level], I, J);
if (J != -1)
goto L__2;
J = N;
N += 256;
L__2:
return (J);
}
void Setex(void) {
if (Strinst)
return;
St[N0] = 0xD2001000;
St[N0 + 1] = 0x4000D500;
St[N0 + 2] = 0x20001000;
Strinst = N0 << 2;
N0 += 3;
}
void Setline(void) {
int K;
static int Value;
if (Linenos != 1)
return;
K = Line & 255;
if (!K)
Mone = 1;
if (K != Value || Mone != 0)
Psi(0x92, K, Gla, 23);
Value = K;
if (!Mone)
goto L__9;
Psi(0x92, Line >> 8, Gla, 22);
L__9:
Mone = 0;
}
void Checkcapacity(int Reg, int Dis, int X, int Level) {
int Mask;
if (Type != 1 || 1 > Prec || Prec > 2)
return;
if (Prec == 1)
goto L__3;
Mask = 7;
Prx(0x49, Reg, Level, X, Dis);
L__1:
Prx(0x47, Mask, 12, 0, 88);
goto L__99;
L__3:
Prx(0x55, Reg, 0, Gla, 24);
Mask = 2;
goto L__1;
L__99:;
}
// MACROISING THE FROMS,REPLACES & MLINK SAVES TIME & SPACE;
// MACROISING THE OTHERS SAVES TIME BUT INCREASES SIZE
void XFromlist(int Cell, int *S1, int *S2) {
int J;
J = Addr(Aslist[Cell]);
*S1 = *Integer(J);
*S2 = *Shortinteger(J+4); // S2= SHORT INTEGER(J+4)
}
int Newcell(void) {
int P;
P = Asl;
if (!P)
Fault(107);
Asl = *Shortinteger(Addr(Aslist[P+6])); // ASL= SHORT INTEGER(ADDR(ASLIST(P+6)));! NEXT FREE CELL
*Shortinteger(Addr(Aslist[P+6])) = 0; // SHORT INTEGER(ADDR(ASLIST(P+6)))=0; ! LINK OF NEWCELL TO 0
return (P);
}
void XPush(short *Cell, int S1, int S2) {
int P;
int Q;
P = Newcell();
Q = Addr(Aslist[P]);
*Integer(Q) = S1;
*Shortinteger(Q+4) = S2; // SHORT INTEGER(Q+4)=S2
*Shortinteger(Q+6) = *Cell; // SHORT INTEGER(Q+6)=CELL
*Cell = P;
}
void XPop(short *Cell, int *S1, int *S2) {
int P;
int Q;
Q = Addr(Aslist[*Cell]);
*S1 = *Integer(Q);
*S2 = *Shortinteger(Q+4); // S2=SHORT INTEGER(Q+4)
if (!*Cell)
goto L__1;
P = *Cell;
*Cell = *Shortinteger(Q+6); // P=CELL; CELL=SHORT INTEGER(Q+6);! CELL ONTO NEXT CELL
*Shortinteger(Q+6) = Asl; // SHORT INTEGER(Q+6)=ASL; ASL=P;! OLD CELL ONTO FREE LIST
Asl = P;
L__1:;
}
void Replace1(int Cell, int S1) { *Integer(Addr(Aslist[Cell])) = S1; }
void Replace2(int Cell, int S2) { *Shortinteger(Addr(Aslist[Cell+4])) = S2; } // SHORT INTEGER(ADDR(ASLIST(CELL+4)))=S2
void XMlink(int *Cell) { *Cell = *Shortinteger(Addr(Aslist[*Cell+6])); } // CELL=SHORT INTEGER(ADDR(ASLIST(CELL+6)))
void XInsertafter(short *Cell, int S1, int S2) {
if (!*Cell)
goto L__1;
Push(*Shortinteger(Addr(Aslist[*Cell+6])), S1, S2); // PUSH(SHORT INTEGER(ADDR(ASLIST(CELL+6))),S1,S2)
*Cell = *Shortinteger(Addr(Aslist[*Cell+6])); // CELL=SHORT INTEGER(ADDR(ASLIST(CELL+6)))
return;
L__1:
Push(*Cell, S1, S2);
}
int Find(int Lab, int List) {
L__3:
if (!List)
goto L__1;
if (*Shortinteger(Addr(Aslist[List+4])) == Lab)
goto L__4; // ->4 %IF SHORT INTEGER(ADDR(ASLIST(LIST+4)))=LAB
Mlink(List);
goto L__3;
L__4:
return (*Integer(Addr(Aslist[List])));
L__1:
return (-1);
}
void XFrom1(int Cell, int *S1) { *S1 = *Integer(Addr(Aslist[Cell])); }
void XFrom2(int Cell, int *S2) { *S2 = *Shortinteger(Addr(Aslist[Cell+4])); } // S2=SHORT INTEGER(ADDR(ASLIST(CELL+4)))
void Replaceboth(int Cell, int S1, int S2) {
int I;
I = Addr(Aslist[Cell]);
*Integer(I) = S1;
*Shortinteger(I+4) = S2; // SHORT INTEGER(I+4)=S2
}
void XClearlist(short *Ophead) {
int I;
int J;
L__1:
Pop(*Ophead, I, J);
if (I != -1)
goto L__1;
}
void Storetag(int Kk, int Slink) {
Push(Tags[Kk], Ptype << 16 | Level << 8 | Rbase << 4 | J, Slink);
if (Level > 1)
Push(Name[Level], 0, Kk);
}
int Countaps(void) {
int Pp;
int Q;
Q = 0;
Pp = P;
P++;
L__1:
if (A[P] == 2)
goto L__2;
P++;
Q++;
Skipexp();
goto L__1;
L__2:
P = Pp;
return (Q);
}
int Displacement(int Link) {
int Rr;
int Ii;
if (!Link)
goto L__2;
From2(Link, Link);
L__1:
Mlink(Link);
Fromlist(Link, Rr, Ii);
if (Ii == -1)
goto L__2;
J = Rr & 15;
Ptype = Rr >> 4 & 0xFFFF;
Rr = Rr >> 20;
K = Link;
Inreg = 0;
if (Rr == A[P])
goto L__99;
goto L__1;
L__2:
Fault(65);
Printname(A[P]);
Ptype = 1;
L__99:
return (Ii);
}
int Copyrecordtag(void) {
int Q;
int Fname;
L__1:
From1(K, Fname);
P++;
Skipapp();
if (A[P] == 2)
return (0);
P++;
Q = Displacement(Fname);
if (Q == -1)
Ptype = 7;
Unpack();
if (Type == 3) {
K = Q;
goto L__1;
}
if (Q == -1)
return (-1);
return (1);
}
void Copytag(int Kk) {
int Q;
Fromlist(Tags[Kk], Q, K);
if (Q == -1)
goto Notset;
Ptype = Q >> 16;
Inreg = Q >> 12 & 15;
Oldi = Q >> 8 & 15;
I = Q >> 4 & 15;
J = Q & 15;
L__1:
Unpack();
return;
Notset:
Ptype = 7;
I = -1;
J = I;
Oldi = J;
goto L__1;
}
void Replacetag(int Kk) {
int P;
int Q;
P = Tags[Kk];
Q = Ptype << 16 | Inreg << 12 | Oldi << 8 | I << 4 | J;
Replaceboth(P, Q, K);
}
void Unpack(void) {
int Q;
Rout = Ptype / 10000;
Q = Ptype - 10000 * Rout;
Nam = Q / 1000;
Q -= 1000 * Nam;
Arr = Q / 100;
Q -= 100 * Arr;
Prec = Q / 10;
Type = Q - 10 * Prec;
}
void XPack(int *Ptype) {
int Q;
Q = 10000 * Rout + 1000 * Nam + 100 * Arr;
*Ptype = Q + 10 * Prec + Type;
}
void Ppj(unsigned char N) {
R13 = 0;
Pconst(0x45F0C000 | N << 2);
}
int Pageno(int N) {
int I;
int J;
J = N >> 12;
I = Pagenos[J];
if (I)
return (I);
St[N0] = J << 12;
Pagenos[J] = N0;
N0++;
return (N0 - 1);
}
void Filljumps(int Level) {
int J;
int K;
int Q;
int Kk;
Ophead = 0;
L__1:
Pop(Jump[Level], J, K);
if (J == -1)
goto L__3;
Q = Find(K, Label[Level]);
if (Q != -1)
goto L__2;
Push(Ophead, J, K);
goto L__1;
L__2:
Kk = 0;
Q -= Codebase[Level];
K = Q >> 12;
if (J & Labset)
goto L__22;
if (Sbflag == 1)
goto L__23;
Plug(J, 0x58E0);
Plug(J + 2, Gla << 12 | 4 * Pageno(Q));
J += 4;
if (K)
Kk = 14;
L__21:
Plug(J + 2, Kk << 12 | Q & 0xFFF);
goto L__1;
L__22:
J = J & 0xFFFFFF;
Kk = 10;
L__23:
if (Q > 4095)
Fault(99);
goto L__21;
L__3:
Jump[Level] = Ophead;
}
void Pj(int Mask, int Lab) {
int I;
int J;
int Q;
J = Find(Lab, Label[Level]);
if (J == -1)
goto L__200;
I = J - Codebase[Level];
if (I >= 4096)
goto L__50;
Prx(0x47, Mask, 0, 10, I);
goto L__999;
L__50:
Q = 4 * Pageno(I);
Pconst(0x58E0D000 | Q);
Prx(0x47, Mask, 14, 10, I & 4095);
goto L__999;
L__200:
Push(Jump[Level], Ca, Lab);
if (Sbflag != 1)
Pconst(0);
Prx(0x47, Mask, 10, 0, 0);
L__999:;
}
void Plab(int M) {
Mone = 1;
if (M >= 0)
goto L__1;
Plabel--;
K = Plabel;
M = K;
L__1:
Push(Label[Level], Ca, M);
R13 = 0;
}
void Checkrf(void) {
Copytag(A[Marker1]);
if (Type != 4)
goto L__1;
Jj = K;
Fromlist(Jj, Q, Fname);
Dump(0, 4, Q, 0, I);
goto L__9;
L__1:
K = -1;
Fault(62);
L__9:;
}
void Dump(int Code, int Reg, int Dis, int X,
int Level) { // CODE=8*(TYPE-1)+2*PREC+Z
int J;
static unsigned char Opcode[17 /*0:16*/] = {
0x41, 0x50, 0x58, 0x42, 0x43, 0x40,
0x48, 0x59, 0x49, 0x70, 0x78, [11 ... 14] = 0,
0x60, 0x68};
J = Opcode[Code];
if (!J)
Fault(248);
if (Code == 4)
goto L__4;
if (Code != 0 || 0 != Dis)
goto L__1;
if (Level != 0 || 0 != X)
goto L__3;
Prr(0x1F, Reg, Reg);
goto L__99;
L__3:
if (Level != 0 && X != 0)
goto L__1;
if (Reg != X + Level)
Prr(0x18, Reg, X + Level);
goto L__99;
L__4:
if (X != Reg && Reg != Level)
Prr(0x1F, Reg, Reg);
L__1:
Prx(J, Reg, X, Level,
Dis); // AND WITH 255 FOR BYTE IF SLR NOT POSSIBLE AS ADDR IN R
if (Code == 4 && (X == Reg || Reg == Level))
Prx(0x54, Reg, 0, Gla, 24);
L__99:;
}
goto Sw_skip;
Sw_default:
fprintf(stderr, "Switch label 'Sw(%d):' not set in %s", Sw_sw + 1,
__PRETTY_FUNCTION__);
exit(1) /* or %signal ... */;
Sw_skip:;
}
exit(0);
return (1);
}
#ifdef NEVER
#endif