#include int _imp_mainep(int _imp_argc, char **_imp_argv) { static const int True = 1; static const int False = 0; _imp_string Cliparam; Cliparam = _imp_str_literal("adec"); static const _imp_string Title = _imp_str_literal(" EUCSD IMP Compiler for M68000. APM Version 2.2g"); static const int Which = '.imp'; static const int Maxname = 127; _imp_string Mainfile; _imp_string Objfile; typedef struct Edfile { int Start1; int Lim1; int Start2; int Lim2; int Lim; int Lbeg; int Fp; int Change; int Flag; int Line; int Diff; unsigned char Top; unsigned char Win; unsigned char Bot; unsigned char Min; unsigned char Row; unsigned char Col; _imp_string Name; } Edfile; static const int Newgroup = 1; static const int Nodefault = 2; _imp_string Date; Date = _imp_str_literal("02/02/02"); _imp_string Time; Time = _imp_str_literal("02:02"); int Cputime; Cputime = 123; static int Item = 0; static int Listout = 0; static const int Arrbit = 0x80000000; static const int Loopbit = 0x40000000; static const int Capbit = 0x20000000; static const int Overbit = 0x10000000; static const int Assbit = 0x08000000; static const int Strassbit = 0x04000000; static const int Sassbit = 0x02000000; static const int Bassbit = 0x01000000; static const int Assmask = Assbit | Strassbit | Sassbit | Bassbit; static const int Linebit = 0x00800000; static const int Diagbit = 0x00400000; static const int Tracebit = 0x00200000; static const int Stackbit = 0x00100000; static const int Checkbit = 0x00080000; static const int Sysbit = 0x00040000; static const int Strictbit = 0x00020000; static const int Volbit = 0x00010000; static const int Halfbit = 0x00008000; static const int Lowbit = 0x00004000; static const int Editbit = 0x00002000; static const int Runbit = 0x00001000; static const int Forcebit = 0x00000800; static const int Logbit = 0x00000400; static const int Warnbit = 0x00000200; static const int Nonsbit = 0x00000100; static const int Permbit = 0x00000080; static const int Newbit = 0x00000040; static const int Codelist = 0x00000020; static const int Dictlist = 0x00000010; static const int Explist = 0x00000008; static const int Maplist = 0x00000004; static const int Ttlist = 0x00000002; static const int List = 0x00000001; static const int Listbits = Codelist + Dictlist + Explist + Maplist + Ttlist + List; static int Control = Warnbit + Checkbit + Linebit + Diagbit + Editbit + Volbit + Strassbit + Assbit + Arrbit + Loopbit + Capbit + Stackbit; int Initcon; int Time1; int Time2; static const int Oflow = 1; static const int Fail = 11; static const int Done = 12; static const int Redo = 13; static const int Abandon = 14; static const int Maxint = 0x7FFFFFFF; static const int Minint = ~Maxint; static const int Sign16 = ~0x7FFF; static const int Sign = ~0x7FFFFFFF; static const int Smallmin = -1024; static const int Smallmax = 1023; static const int Litmax = Smallmin - (Smallmax + 1); static const int Litmin = Litmax - 199; static const int Litmite = -255; static const int Litquick = -16; static const int One = -(1 << 1); static const int D0 = 1; static const int D1 = D0 + 1; static const int D2 = D0 + 2; static const int D7 = D0 + 7; static const int A0 = D0 + 8; static const int A1 = A0 + 1; static const int A6 = A0 + 6; static const int A7 = A0 + 7; static const int Inda0 = A0 + 8; static const int Inda7 = Inda0 + 7; static const int Posta0 = Inda0 + 8; static const int Posta7 = Posta0 + 7; static const int Prea0 = Posta0 + 8; static const int Prea7 = Prea0 + 7; static const int Undef = A7; static int Dictlim = 1000; static int Finalbound = 64; int Lablim; int Np0; int Explim; int Charbound; static const int Labels = 42; static const int Triples = 200; static const int Ad = 16384; static const int Breg = D0 + 4; static const int Lineloc = D0 + 5; static const int F1 = A0 + 6; static const int Gb = A0 + 5; static const int Mb = A0 + 4; static const int Maxdreg = D0 + 3; static const int Maxareg = A0 + 3; static const int D0b = 1; static const int D1b = 2; static const int D2b = 4; static const int Bregb = 16; static const int A0b = 0x100; static const int A1b = 0x200; static const int A2b = 0x400; static const int Anydreg = 0x00FF - Bregb; static const int Anyareg = 0xFF00; static const int Anyreg = 0xFFFF; static const int Defaultfree = (2 << (Maxdreg - D0)) - 1 + (((2 << (Maxareg - A0)) - 1) << 8) + Bregb; int Maxcalldreg; int Maxcallareg; int Free; int Litpos; int Litstore[200 /*-2247:-2048*/]; typedef struct Objinfo { short Flags; short Type; unsigned char Reg; unsigned char Mode; int Val; } Objinfo; typedef struct Identinfo { } Identinfo; static const int Aregmode = 0b001000; static const int Dispmode = 0b101000; static const int Indexmode = 0b110000; static const int Absmode = 0b111000; static const int Pcmode = 0b111010; static const int Litmode = 0b111100; static const int Indir = 8; static const int Post = 16; static const int Pre = 24; static const int Labmode = 0b10000000 + Pcmode; static const int Procmode = 0b11000000 + Pcmode; static const int Globalmode = Dispmode + (Gb - A0); static const int Ownmode = 0b01000000 + Dispmode + (Mb - A0); static const int Constmode = 0b01000000 + Pcmode; static const int Framemode = 0b10000000 + Dispmode; static const int Cat = 0x000F; static const int Writable = 0x0001; static const int Readable = 0x0002; static const int Volatile = 0x0004; static const int Arrflag = 0x0008; static const int Alt = 0x0008; static const int Wflag = 0x0010; static const int Rflag = 0x0020; static const int Okflag = 0x0040; static const int Noret = 0x0040; static const int Mflag = 0x0080; static const int Spec = 0x0100; static const int Typeid = 0x0200; static const int Packed = 0x0400; static const int Indirect = 0x0800; static const int Proc = 0x3000; static const int Proc1 = 0x1000; static const int Proc2 = 0x2000; static const int Ext = 0x4000; static const int Name = Sign16; static const int Heritable = Writable + Readable + Volatile + Wflag + Rflag + Okflag + Arrflag; static const int Inty = 0; static const int Chary = 1; static const int Booly = 2; static const int Enumy = 3; static const int Pointy = 4; static const int Realy = 5; static const int Stringy = 8; static const int Arry = 9; static const int Sety = 10; static const int Recy = 12; static const int Filey = 13; static const int Nonord = 12; static Objinfo Definedlabel = 0; static Objinfo Forwardlabel = 0; static Objinfo Beginblock = 0; static Objinfo Typeident = 0; static const int Main = 1; Edfile File[3 /*1:3*/]; Edfile *Cur; int Fcontrol[3 /*1:3*/]; int Curfile; int Lastfile; int Curstart; int Curlim; void Setoptions(_imp_string Parm) { static int Removewarning; static const int Checks = Assmask + Arrbit + Loopbit + Capbit + Overbit; Removewarning = Addr(Parm); if (!(Control & Checkbit)) Control = Control & (~Checks); if (Control & Listbits) Control = Control & (~Editbit); } void Setextension(_imp_string * F, _imp_string Ext) { int Strip; int Last4(_imp_string * S) { int I; int E; I = 0; E = 0; while (I < *Length(*S)) { I++; E = (E << 8) + *Charno(*S, I); } return (E); } Strip = Last4(Ext); if (_imp_strcmp(*F, _imp_str_literal("")) == 0) { *F = Mainfile; Strip = Which; } if ((Last4(*F) | 0x202020) == Strip) *Length(*F) = *Length(*F) - 4; *F = _imp_join(*F, Ext); } void Openfiles(void) { _imp_string Listfile; Listfile = _imp_str_literal(""); Objfile = _imp_str_literal(""); File[Main] = 0; Setoptions(Cliparam); if (!(Control & Diagbit)) Control = Control & (~Linebit); File[Main].Name = Mainfile; File[Main].Flag = 32768; Time1 -= Cputime; Time1 += Cputime; if (File[Main].Flag) exit(0); if (_imp_strcmp(Listfile, _imp_str_literal("")) != 0 || (Control & (List + Ttlist)) != 0) { if (!(Control & Ttlist)) { Setextension(Listfile, _imp_str_literal(".lis")); Listout = 2; Openoutput(Listout, Listfile); } Control = Control & (~(Editbit + Ttlist)); if (!(Control & Listbits)) Control = Control | List; } Selectoutput(Listout); if (Control & Listbits) { if ((Control & Listbits) != Maplist) Control = Control | List; Newlines(2); Printstring(Title); Newlines(2); Printstring(_imp_str_literal(" ")); Printstring(File[Main].Name); Printstring(_imp_str_literal(" compiled on ")); Printstring(Date); Printstring(_imp_str_literal(" at ")); Printstring(Time); Newlines(2); } Initcon = Control; } Time1 = 0; Openfiles(); Dictlim += 300; Charbound = Dictlim * 8; Finalbound = (Finalbound << 10) + 4095; Lablim = Dictlim + Labels; Explim = Lablim + Triples; Np0 = Lablim + 4; File[Main].Change = 0x7FFFFFFF; Forwardlabel.Flags = Spec; Forwardlabel.Mode = Labmode; Definedlabel.Mode = Labmode; Beginblock.Mode = Procmode; Typeident.Flags = Typeid + Recy; Identinfo Dict[(Explim - 1) + 1]; int Dlim; int Dlim0; int Dmin; int Dmin0; int Dictshown; int Inclim; Identinfo *Dlink; Identinfo *Dformat; Identinfo *Dtemp; Identinfo *Dtemp2; Identinfo *Dtsprel; Identinfo *Dint; int Subbed; int Ranges; unsigned char Char[Charbound + 1]; int Char0; int Charlim; int Charmin; int Newlen; short Hashindex[256 /*0:255*/]; short *Head; static const int Null = 41; static const int Procstar = 42; static const int Inttype = 43; static const int Shorttype = 46; static const int Halftype = 49; static const int Bytetype = 52; static const int Mitetype = 55; static const int Booltype = 58; static const int Chartype = 61; static const int Stringstar = 62; static const int String1 = 63; static const int Stringtype = 64; static const int Arrstar = 65; static const int Nullsettype = 66; static const int Recstar = 67; static const int Realtype = 69; static const int Signal = 73; static const int Daddr = 74; static const int Dsizeof = 77; static const int Index = 78; static const int Lenref = 79; static const int Sindex = 82; static const int Imul = 86; static const int Idiv = 87; static const int Ipow = 88; static const int Fneg = 89; static const int Fadd = 90; static const int Fsub = 91; static const int Fmul = 92; static const int Fdiv = 93; static const int Fpow = 94; static const int Float = 95; static const int Drem = 98; static const int Unass = 102; static const int Adok = 103; static const int Stackok = 104; static const int Asize = 105; static const int Concat = 106; static const int Dtostring = 107; static const int Aget = 109; static const int Forok = 110; static const int Check = 111; static const int Scomp = 112; static const int Strcopy = 113; static const int Strtostk = 114; static const int Dnew = 115; static const int Resolves = 117; static const int Deventf = 128; static const int Devent = 134; static const int Dnil = 137; static const int Dprintstr = 155; static const int Dwrite = 183; static const int Opmax = Resolves; void Sethashhead(_imp_string * S) { int H; int I; H = 0; for (I = 1; I <= *Length(*S); I++) H = H << 1 ^ *Charno(*S, I); Head = &Hashindex[H & 255]; } void Preset(void) { static const int Cmax = 775; static unsigned char Charinit[776 /*0:775*/] = { 0, 2, 'd', '0', 2, 'd', '1', 2, 'd', '2', 2, 'd', '3', 2, 'd', '4', 2, 'd', '5', 2, 'd', '6', 2, 'd', '7', 2, 'a', '0', 2, 'a', '1', 2, 'a', '2', 2, 'a', '3', 2, 'a', '4', 2, 'a', '5', 2, 'a', '6', 2, 'a', '7', 7, 'i', 'n', 't', 'e', 'g', 'e', 'r', 6, 'M', 'A', 'X', 'I', 'N', 'T', 12, 's', 'h', 'o', 'r', 't', 'i', 'n', 't', 'e', 'g', 'e', 'r', 11, 'h', 'a', 'l', 'f', 'i', 'n', 't', 'e', 'g', 'e', 'r', 11, 'b', 'y', 't', 'e', 'i', 'n', 't', 'e', 'g', 'e', 'r', 11, 'm', 'i', 't', 'e', 'i', 'n', 't', 'e', 'g', 'e', 'r', 7, 'B', 'O', 'O', 'L', 'E', 'A', 'N', 5, 'F', 'A', 'L', 'S', 'E', 4, 'T', 'R', 'U', 'E', 4, 'c', 'h', 'a', 'r', 6, 's', 't', 'r', 'i', 'n', 'g', 5, 'a', 'r', 'r', 'a', 'y', 6, 'r', 'e', 'c', 'o', 'r', 'd', 4, 'T', 'E', 'X', 'T', 4, 'r', 'e', 'a', 'l', 8, 'l', 'o', 'n', 'g', 'r', 'e', 'a', 'l', 6, 'S', 'I', 'G', 'N', 'A', 'L', 4, 'a', 'd', 'd', 'r', 6, 's', 'i', 'z', 'e', 'o', 'f', 5, 'I', 'N', 'D', 'E', 'X', 6, 'l', 'e', 'n', 'g', 't', 'h', 6, 'c', 'h', 'a', 'r', 'n', 'o', 4, 'I', 'M', 'U', 'L', 4, 'I', 'D', 'I', 'V', 4, 'I', 'P', 'O', 'W', 4, 'F', 'N', 'E', 'G', 4, 'F', 'A', 'D', 'D', 4, 'F', 'S', 'U', 'B', 4, 'F', 'M', 'U', 'L', 4, 'F', 'D', 'I', 'V', 4, 'F', 'P', 'O', 'W', 5, 'f', 'l', 'o', 'a', 't', 3, 'r', 'e', 'm', 5, 'U', 'N', 'A', 'S', 'S', 4, 'A', 'D', 'O', 'K', 7, 'S', 'T', 'A', 'C', 'K', 'O', 'K', 5, 'A', 'S', 'I', 'Z', 'E', 6, 'C', 'O', 'N', 'C', 'A', 'T', 8, 't', 'o', 's', 't', 'r', 'i', 'n', 'g', 4, 'A', 'G', 'E', 'T', 5, 'F', 'O', 'R', 'O', 'K', 5, 'C', 'H', 'E', 'C', 'K', 5, 'S', 'C', 'O', 'M', 'P', 7, 'S', 'T', 'R', 'C', 'O', 'P', 'Y', 8, 'S', 'T', 'R', 'T', 'O', 'S', 'T', 'K', 3, 'n', 'e', 'w', 8, 'r', 'e', 's', 'o', 'l', 'v', 'e', 's', 9, 's', 'u', 'b', 's', 't', 'r', 'i', 'n', 'g', 7, 'e', 'v', 'e', 'n', 't', 'f', 'm', 5, 'e', 'v', 'e', 'n', 't', 3, 's', 'u', 'b', 4, 'l', 'i', 'n', 'e', 5, 'e', 'x', 't', 'r', 'a', 7, 'm', 'e', 's', 's', 'a', 'g', 'e', 5, 'e', 'v', 'e', 'n', 't', 2, 'n', 'l', 3, 's', 'n', 'l', 3, 'n', 'i', 'l', 7, 'd', 'i', 's', 'p', 'o', 's', 'e', 5, 'r', 'o', 'u', 'n', 'd', 5, 't', 'r', 'u', 'n', 'c', 8, 'f', 'r', 'a', 'c', 't', 'i', 'o', 'n', 3, 'i', 'n', 't', 5, 'i', 'n', 't', 'p', 't', 6, 'f', 'r', 'a', 'c', 'p', 't', 4, 's', 'q', 'r', 't', 10, 'n', 'e', 'x', 't', 's', 'y', 'm', 'b', 'o', 'l', 10, 'r', 'e', 'a', 'd', 's', 'y', 'm', 'b', 'o', 'l', 10, 's', 'k', 'i', 'p', 's', 'y', 'm', 'b', 'o', 'l', 11, 'p', 'r', 'i', 'n', 't', 's', 'y', 'm', 'b', 'o', 'l', 11, 'p', 'r', 'i', 'n', 't', 's', 't', 'r', 'i', 'n', 'g', 9, 'o', 'p', 'e', 'n', 'i', 'n', 'p', 'u', 't', 10, 'o', 'p', 'e', 'n', 'o', 'u', 't', 'p', 'u', 't', 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', 8, 's', 'e', 't', 'i', 'n', 'p', 'u', 't', 9, 's', 'e', 't', 'o', 'u', 't', 'p', 'u', 't', 10, 'r', 'e', 's', 'e', 't', 'i', 'n', 'p', 'u', 't', 11, 'r', 'e', 's', 'e', 't', 'o', 'u', 't', 'p', 'u', 't', 10, 'c', 'l', 'o', 's', 'e', 'i', 'n', 'p', 'u', 't', 11, 'c', 'l', 'o', 's', 'e', 'o', 'u', 't', 'p', 'u', 't', 6, 'p', 'r', 'o', 'm', 'p', 't', 7, 'n', 'e', 'w', 'l', 'i', 'n', 'e', 5, 's', 'p', 'a', 'c', 'e', 6, 's', 'p', 'a', 'c', 'e', 's', 8, 'n', 'e', 'w', 'l', 'i', 'n', 'e', 's', 4, 'r', 'e', 'a', 'd', 138, 'r', 'e', 'a', 'd', 's', 't', 'r', 'i', 'n', 'g', 4, 'r', 'e', 'a', 'd', 136, 'r', 'e', 'a', 'd', 'r', 'e', 'a', 'l', 4, 'r', 'e', 'a', 'd', 5, 'w', 'r', 'i', 't', 'e', 7, 'c', 'p', 'u', 't', 'i', 'm', 'e', 5, 'p', 'r', 'i', 'n', 't', 7, 'p', 'r', 'i', 'n', 't', 'f', 'l', 8, 'i', 'n', 's', 't', 'r', 'e', 'a', 'm', 9, 'o', 'u', 't', 's', 't', 'r', 'e', 'a', 'm', 8, 'c', 'l', 'i', 'p', 'a', 'r', 'a', 'm', 0}; static const int Premax = 196; static short Dictinit[936 /*246:1181*/] = { 516, -1, 0, 0, 0, 0, 527, -1, 0, 0, 0, 4, 512, 43, 4, 56, -32768, 0, 0, -44, 4, 60, -32768, 0, 0, 43, 4, 60, 32767, -1, 512, 43, 2, 56, -32768, 0, 0, -44, 2, 60, -1, -32768, 0, -44, 2, 60, 0, 32767, 512, 43, 2, 56, -32768, 0, 0, -44, 2, 60, 0, 0, 0, -44, 2, 60, 0, -1, 512, 43, 1, 56, -32768, 0, 0, -44, 1, 60, 0, 0, 0, -44, 1, 60, 0, 255, 512, 43, 1, 56, -32768, 0, 0, -44, 1, 60, -1, -128, 0, -44, 1, 60, 0, 127, 514, 58, 1, 0, 0, 0, 0, 58, 1, 60, 0, 0, 0, 58, 1, 60, 0, 1, 513, 61, 255, 0, 0, 0, 520, 61, 0, 0, 0, 0, 520, -62, -2, 0, 0, 0, 520, -62, -256, 0, 0, 0, 521, 0, 0, 0, 0, 0, 522, -1, 0, 0, 0, 0, 524, 0, 0, 0, 0, 0, 525, 61, 4, 0, 0, 0, 517, 0, 4, 0, 0, 0, 517, 0, 4, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 4256, 42, 0, 56, 0, 16122, 4098, 75, 0, 56, 0, 0, 0, -44, 76, 0, 0, 4, -32701, -1, 0, 6313, -1, -4, 4098, 75, 0, 56, 0, 0, 4096, 42, 0, 56, -32767, 2861, 4099, 80, 0, 56, 0, 0, 0, -53, 81, 6144, 0, 4, -32701, -63, 0, 6313, -1, -4, 4099, 83, 0, 56, 0, 0, 0, -53, 84, 6144, 0, 4, -32701, -63, 85, 6313, -1, -4, 67, -44, 0, 169, -1, -8, 4256, 42, 0, 56, 0, 16116, 4256, 42, 0, 56, 0, 16110, 4096, 42, 0, 56, 0, 16098, 4096, 42, 0, 56, 0, 16092, 4096, 42, 0, 56, 0, 16086, 4096, 42, 0, 56, 0, 16080, 4096, 42, 0, 56, 0, 16074, 4096, 42, 0, 56, 0, 16068, 4096, 42, 0, 56, 0, 16062, 4098, 96, 0, 56, 0, 16056, 0, -70, 97, 0, 0, 4, 67, -44, 0, 169, -1, -4, 4098, 99, 0, 56, 0, 0, 0, -44, 100, 0, 0, 4, 67, -44, 101, 169, -1, -4, 67, -44, 0, 425, -1, -8, 4096, 42, 0, 56, -32722, 2578, 4096, 42, 0, 56, -32704, 2064, 4096, 42, 0, 56, -32688, 2839, 4096, 42, 0, 56, -32665, 3097, 4096, 42, 0, 56, -32640, 2077, 4098, 108, 0, 56, -32611, 6, 0, -64, 97, 6144, 0, 4, 4096, 42, 0, 56, -32605, 2597, 4096, 42, 0, 56, -32568, 2334, 4096, 42, 0, 56, -32538, 1806, 4096, 42, 0, 56, -32524, 2626, 4096, 42, 0, 56, -32458, 2070, 4096, 42, 0, 56, -32436, 2090, 4103, 116, 0, 56, 0, 16008, 0, -68, 76, 6144, 0, 4, 22786, 118, 0, 108, 0, 0, 0, -59, 119, 0, 0, 0, -32701, -63, 120, 6313, -1, -4, 67, -65, 121, 6569, -1, -260, -32701, -63, 122, 6825, -1, -264, -32701, -63, 0, 7081, -1, -268, 4098, 124, 0, 56, -32394, 15, 0, -65, 125, 6144, 0, 4, -32701, -63, 126, 6313, -1, -4, 67, -44, 127, 169, -1, -8, 67, -44, 0, 425, -1, -12, 524, 0, 129, 0, -1, -264, 3, 52, 0, 0, 0, 0, 3, 52, 0, 0, 0, 1, 3, 46, 0, 0, 0, 2, 3, 43, 0, 0, 0, 4, 3, 64, 0, 0, 0, 8, 67, 128, 0, 45, 0, 32, 66, 43, 0, 60, 0, 10, 66, 61, 0, 60, 0, 10, 67, 67, 0, 56, 0, 0, 4096, 139, 0, 56, 0, 16002, 0, -1, 76, 0, 0, 4, 4098, 141, 0, 56, 0, 16050, 0, -44, 142, 0, 0, 4, 67, -70, 0, 169, -1, -4, 4098, 141, 0, 56, 0, 16044, 4098, 145, 0, 56, 0, 16038, 0, -70, 142, 0, 0, 4, 4098, 141, 0, 56, 0, 16032, 4098, 141, 0, 56, 0, 16026, 4098, 145, 0, 56, 0, 16020, 4098, 145, 0, 56, 0, 16014, 4098, 132, 0, 56, 0, 15996, 4098, 132, 0, 56, 0, 15990, 4096, 42, 0, 56, 0, 15990, 4256, 154, 0, 56, 0, 15984, 0, -1, 97, 0, 0, 4, 4096, 156, 0, 56, 0, 15978, 0, -1, 157, 0, 0, 4, 67, -65, 0, 6313, -1, -256, 26880, 159, 0, 108, 0, 0, 0, -1, 160, 0, 0, 0, 67, -44, 161, 169, -1, -4, 67, -65, 0, 6313, -1, -260, 26880, 159, 0, 108, 0, 0, 4096, 154, 0, 56, 0, 15960, 4096, 154, 0, 56, 0, 15954, 26880, 166, 0, 108, 0, 0, 0, -1, 97, 0, 0, 0, 26880, 166, 0, 108, 0, 0, 26880, 0, 0, 108, 0, 0, 26880, 0, 0, 108, 0, 0, 4096, 42, 0, 56, 0, 15936, 4096, 42, 0, 56, 0, 15930, 26880, 173, 0, 108, 0, 0, 0, -1, 157, 0, 0, 0, 4096, 42, 0, 56, -32379, 4, 4096, 42, 0, 56, -32375, 4, 22784, 166, 0, 108, 0, 0, 22784, 166, 0, 108, 0, 0, 22790, 179, 0, 108, 0, 0, 0, -65, 0, 6144, 0, 0, 22798, 181, 0, 108, 0, 0, 0, -70, 0, 0, 0, 0, 22798, 1, 0, 108, 0, 0, 22784, 184, 0, 108, 0, 0, 0, -1, 100, 0, 0, 0, 26886, 1, 0, 108, 0, 0, 22784, 187, 0, 108, 0, 0, 0, -1, 188, 0, 0, 0, 67, -70, 189, 169, -1, -4, 67, -44, 190, 425, -1, -8, 67, -44, 0, 681, -1, -12, 22784, 192, 0, 108, 0, 0, 0, -1, 193, 0, 0, 0, 67, -70, 101, 169, -1, -4, 67, 43, 0, 45, 0, 392, 67, 43, 0, 45, 0, 396, 67, 64, 0, 45, 0, 464}; int I; int Ci; int Anons; Identinfo *Dp; void Putchar(void) { *Byteinteger(Charlim) = Charinit[Ci]; Charlim++; Ci++; } void Textset(Identinfo * Dp) { int Len; Dp.Hlink = 0; if (Dp.Type < 0) { Dp.Type = ~Dp.Type; Dp.Text = 0; Anons--; if (Anons == 0 && Dlim <= Mitetype + 2) { Dp.Hlink = Ranges; Ranges = Dlim; } } else { Dp.Text = Ci; if (Charinit[Ci + 1] & 32) if (Deventf < Dlim && Dlim < Devent) { *Head = Dlim; Head = &Dp.Hlink; } else { Sethashhead(*String(Addr(Charinit[Ci]))); Dp.Hlink = *Head; *Head = Dlim; if (Dlim == Deventf) Head = &Dp.Link; } Len = Charinit[Ci]; do { Putchar(); Len--; } while (Len >= 0); Len = Charinit[Ci] - 128; while (Len >= 0) { Putchar(); Len--; } Anons = 2; } } for (I = 0; I <= 255; I++) Hashindex[I] = 0; *Byteinteger(Char0) = 0; Charlim = Char0 + 1; Charmin = Charlim + Charbound; Ranges = 0; Ci = 1; Anons = 100; Dict[0] = 0; Dlim = D0; do { Dp = &Dict[Dlim]; if (Dlim <= Prea7) { *Dp = 0; Dp->Flags = Okflag + Writable + Readable; Dp->Mode = Dlim - D0; Dp->Type = Inttype; if (Dlim <= A7) Textset(*Dp); } else { Dp->Details = *Record(Addr(Dictinit[Dlim * 6])); Textset(*Dp); } Dlim++; if ((Control & Permbit) != 0 && Dlim >= Signal) break; } while (Dlim <= Premax); Dictshown = Dlim; I = Dictlim; do { Dp = &Dict[I]; *Dp = 0; Dp->Mode = Labmode; I++; } while (I != Np0); } int Explo; int Oldexplo; int Np; int Startnp; static const int Move = 1; static const int Add = 2; static const int Sub = 3; static const int Cmp = 4; static const int And = 5; static const int Or = 6; static const int Eor = 7; static const int Not = 8; static const int Neg = 9; static const int Lsl = 10; static const int Lsr = 11; static const int Muls = 12; static const int Divs = 13; static const int Mulu = 14; static const int Divu = 15; static const int Bra = 16; static const int Bsr = 17; static const int Bcc = 20; static const int Bcs = 21; static const int Bne = 22; static const int Beq = 23; static const int Bvc = 24; static const int Bvs = 25; static const int Bge = 28; static const int Blt = 29; static const int Bgt = 30; static const int Ble = 31; static const int Compare = Cmp; static const int Goto = Bra; static const int Jamass = 32; static const int Okass = 33; static const int Assign = 34; static const int Incass = 35; static const int Forass = 36; static const int Stop = 37; static const int Return = 38; static const int Repeat = 39; static const int Else = 40; static const int Jumpout = 41; static const int Settrap = 42; static const int Swgoto = 43; static const int Label = 44; static const int Recref = 45; static const int Prel = 46; static const int Storemap = 47; static const int Iabs = 48; static const int Fabs = 49; static const int End = 50; int Starts; int Cycles; int Curlab; int Pendout; int Pendcond; int Pendin; int Polarity; int Condop; static short Extspecs = 0; static short Externs = 0; typedef struct Contentinfo { short Ccx; short Ccy; short Line; short Content[16 /*1:16*/]; } Contentinfo; typedef struct Blockinf { int Sp; int Stack; int Extra; int Totstack; int Free; int Status; int Type; int Localdpos; int Parlim; int Localtext; int Localad; int Vintage; int Localpc; int Localswpc; int Pid; int Access; int Forward; int Lab1; int Looplab; int Eventsp; int Faults; int Return; int Shorts; int Temps; int Dynarray; int Oldcontrol; int Mode; int Val; Identinfo *Dpid; Contentinfo Reg; } Blockinf; static const int Unknown = 0x0002; static const int Wrongcc = 0x0004; static const int Onstack = 0x0008; static const int Globbed = 0x0010; static const int Labglobbed = 0x0020; static const int Hadspec = 0x0040; static const int Hadswitch = 0x0080; static const int Hadon = 0x1000; static const int Hadordererr = 0x2000; static const int Hadinst = 0x4000; static const int Outerlevel = 0; static const int Maxlevel = 7; int Level; int Vintage; Blockinf C; Blockinf Hold[7 /*0:6*/]; Contentinfo Lreg[43 /*0:42*/]; static const int Progbound = 16383; short Prog[16384 /*0:16383*/]; unsigned char Pflag[16384 /*0:16383*/]; static const int Shortjump = 1; static const int Jump = 2; static const int Longjump = 3; static const int Global = 4; static const int Indglobal = 7; static const int Zeroshorts = 8; int Pc; int Swpc; unsigned char Final[Finalbound + 1]; int Cad; int Ownad; int Jokerad; int Ownbase; int Final0; int Accounted; int Firstentry; int Firstpos; static int Type = 0; static int Value = 0; Identinfo *Ditem; int Speccing; int Dump; static int Atom = 0; int Matched; int Sym; int Line; static int Codeflag = ' '; int Listflag; int Linestart; int Fp; int Atomp; int Expp; int Isshort(int V) { if (-32768 <= V && V <= 32767) return (True); return (False); } int Ismite(int V) { if (-128 <= V && V <= 127) return (True); return (False); } int Mite(int V) { V = V & 255; if (V & 128) V -= 256; return (V); } Identinfo *Typecell(int T) { return (&Dict[T]); } int Category(int T) { return (Dict[T].Flags & (Packed + Cat)); } int Litval(int V) { if (!V) return (V); if (V > Litmax) { if (!(V & 1)) return ((unsigned)(-V) >> 1); return (~((unsigned)(-V) >> 1)); } return (Litstore[V]); } int Faults; int Others; int Faultnum; int Faultp; int Statements; int Comments; int Atoms; int Identatoms; int Litatoms; int Zaps; int Steps; int Jumps; int Shorts; _imp_string Rep; void Printline(void) { Printstring(Rep); Printsymbol(Nl); Rep = _imp_str_literal(""); } void Putsym(int K) { Rep = _imp_join(Rep, Tostring(K)); } void Putstring(_imp_string S) { Rep = _imp_join(Rep, S); } void Putnum(int Val) { void Pd(int V) { if (V <= -10) { Pd(V / 10); V -= V / 10 * 10; } Putsym('0' - V); } if (Val < 0) { Putsym('-'); Pd(Val); } else Pd(-Val); } void Putident(int P, int Mode) { Identinfo *Dp; do { if (*Length(Rep) > 50) Printline(); if (_imp_strcmp(Rep, _imp_str_literal("")) == 0) Spaces(6); Dp = &Dict[P]; if (Mode) { Putsym(' '); Putsym('"'); } if (Dp->Text > 0) Putstring(*String(Char0 + Dp->Text)); else if (Dp->Text < 0) Putnum(~Dp->Text); else Putnum(P); if (Mode) Putsym('"'); if (Mode <= 0) return; P = Dp->Hlink; } while (P); } void Spaces(int N) { while (N > 0) { Putsym(' '); N--; } } void Putspnum(int Val) { if (Val >= 0) Putsym(' '); Putnum(Val); } static const unsigned char Hexsym[16 /*0:15*/] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'}; void Puthex(int Val) { int I; for (I = 12; I >= 0; I -= 4) Putsym(Hexsym[(unsigned)Val >> I & 15]); } void Putoperand(int V) { int I; void Interpret(int Mode) { static int S_sw; static void *S[8 /*0:7*/] = { &&S_0, &&S_1, &&S_2, &&S_3, &&S_4, &&S_5, &&S_6, &&S_7, }; goto *S[S_sw = (unsigned)Mode >> 3 & 7]; S_0:; Putsym('D'); Putrno:; Putsym((Mode & 7) + '0'); return; S_1:; if (Mode >= Framemode - Dispmode) Putsym('F'); else Putsym('A'); goto Putrno; S_4:; Putsym('-'); S_2:; Ind:; Putsym('('); Interpret((Mode & 0b11000111) + Aregmode); Putsym(')'); return; S_3:; Interpret(Mode - 8); Putsym('+'); return; S_5:; Putnum(I); goto Ind; S_6:; Putnum(Mite(I)); Putsym('('); Interpret(Mode + (Aregmode - Indexmode)); Putsym(','); Interpret((unsigned)I >> 12 & 15); Putsym('.'); if (!(I & 0x800)) Putsym('W'); else Putsym('L'); Putsym(')'); return; S_7:; if ((Mode & 63) == Pcmode) { if (Mode == Pcmode) Putnum(I); Putstring(_imp_str_literal("(PC)")); return; } if (Mode <= Absmode + 1) { Putsym('$'); if (Mode == Absmode + 1 || Isshort(I) != True) Puthex((unsigned)I >> 16); } else { Putsym(Hexsym[(unsigned)Mode >> 4 & 3]); Putsym(Hexsym[Mode & 15]); Putsym('_'); } Puthex(I); } if (V <= 0) { V = Litval(V); Putsym('#'); if (Ismite(V) == True) Putnum(V); else { Putsym('$'); if ((unsigned)V >> 16) Puthex((unsigned)V >> 16); Puthex(V & 0xFFFF); } } else if (V <= Prea7) Interpret(V - D0); else if (V < Dictlim) Putident(V, 0); else if (V < Lablim) { Putsym('L'); Putnum(V - Dictlim); } else { I = Dict[V].Val; Interpret(Dict[V].Mode); } } void Markat(int Col) { while (*Length(Rep) < Col) Putsym(' '); Putsym('|'); } void Showdict(int From) { int I; Identinfo D; static const unsigned char Flagsym[16 /*0:15*/] = {'W', 'R', 'V', 'A', 'w', 'r', 'o', 'm', 'S', 'T', 'K', '?', 'P', 'p', 'E', '*'}; static const unsigned char Catsym[16 /*0:15*/] = {'I', 'C', 'B', 'E', '@', 'X', '?', '?', 'S', 'A', 'Z', '?', 'R', 'F', '?', '?'}; if (From >= Dlim) return; if (_imp_strcmp(Rep, _imp_str_literal("")) != 0) Printline(); *Byteinteger(Charlim) = 0; Spaces(6); Putstring(_imp_str_literal("___identifier____flags___type__link__par_mode___value____")); Printline(); do { Putspnum(From); Markat(6); D = Dict[From]; Putsym(' '); Putident(From, 0); if (D.Text > 0) { I = Char0 + D.Text; I = I + *Byteinteger(I) + 1; if (*Byteinteger(I) & 128) { *Byteinteger(I) = *Byteinteger(I) - 128; Putsym(':'); Putstring(*String(I)); *Byteinteger(I) = *Byteinteger(I) + 128; } } Markat(22); if (D.Flags & Typeid) { Putsym(Catsym[D.Flags & Cat]); I = 4; } else { Putsym(' '); I = 0; } do { if ((unsigned)D.Flags >> I & 1) Putsym(Flagsym[I]); I++; } while (I <= 15); Markat(30); Putspnum(D.Type); Markat(35); Putspnum(D.Link); Markat(42); Putspnum(D.Reg); Markat(46); Putspnum(D.Mode); Markat(51); Putspnum(D.Val); Markat(63); Printline(); From++; } while (From != Dlim); Spaces(6); Putstring(_imp_str_literal("+-------------------------------------------------------+")); Printline(); } void Putmnemonic(int M) { M = M << 2; do { Putsym(((unsigned)M >> 27) + 'A' - 1); M = M << 5; } while (M); } auto void Putopcode(int Op); void Showexp(int Startp) { int P; int Q; Identinfo *Dp; static const int Bopmax = 51; static const int Extra[20 /*32:51*/] = {-736721293, -558838176, -1019632402, -756971917, -856095117, -414728192, -463841714, -463989708, -892759040, -880488448, -383729664, -411844977, -669969024, -464402266, -517820416, -414632912, -770618368, -871281664, -891158528, -655110494}; void Putoprand(int V) { if (V >= Explim) { Putsym('#'); V -= Ad; } if (V < Np0) Putoperand(V); else Putnum(V); } if (_imp_strcmp(Rep, _imp_str_literal("")) != 0) Printline(); if (Np <= Np0) return; Putstring(_imp_str_literal(" ______action_______first_______second____")); Printline(); P = Np0; do { if (P == Np) { P = Explo; if (P >= Oldexplo) break; Putstring(_imp_str_literal(" |---------------------------------------|")); Printline(); } if (P == Startp) Putsym('>'); else Putsym(' '); Putnum(P); Markat(6); Dp = &Dict[P]; Putsym(' '); Q = Dp->Act; if (Q <= 31) Putopcode(Q); else if (Q <= Bopmax) Putmnemonic(Extra[Q]); else Putident(Q, 0); Markat(22); Putsym(' '); Putoprand(Dp->X); Markat(34); Putsym(' '); Putoprand(Dp->Y); Markat(46); if (P >= Explo) { Putspnum(Dp->Type); if (Dp->Flags < 0) Putsym('*'); } Printline(); P++; } while (P < Oldexplo); Oldexplo = Explo; Putstring(_imp_str_literal(" +---------------------------------------+")); Printline(); } void Croak(_imp_string S) { Selectoutput(0); Putstring(_imp_str_literal("** ")); Putstring(S); Putstring(_imp_str_literal(". Compilation abandoned at line ")); Putnum(Line); Printline(); _imp_signal(14, 0, 0, _imp_str_literal("")); } static const int Internerr = 1; static const int Plexerr = 2; static const int Creacherr = 3; static const int Reacherr = 4; static const int Noresult = 5; static const int Dreacherr = 6; static const int Formerr = 7; static const int Atomerr = 8; static const int Namerr = 9; static const int Classerr = 10; static const int Sizerr = 11; static const int Typerr = 12; static const int Boundserr = 13; static const int Unending = 14; static const int Lowlevel = 15; static const int Accesserr = 16; static const int Notinloop = 17; static const int Notinrout = 18; static const int Notinfun = 19; static const int Notinpred = 20; static const int Duperr = 21; static const int Ordererr = 22; static const int Matcherr = 23; static const int Rangerr = 24; static const int Nonliteral = 25; static const int Moperr = 26; static const int Nocycle = 27; static const int Nostart = 28; static const int Noif = 29; static const int Illstarred = 30; static const int Nonstarter = 31; static const int Nonvar = 32; static const int Nonref = 33; static const int Toofew = 34; static const int Toomany = 35; static const int Nobegin = 36; static const int Dubious = 37; static const int Notinblock = 38; static const int Nonstand = 39; static const int Notin = 40; static const int Asserr = 41; static const int Noend = 42; static const int Nofinish = 43; static const int Norepeat = 44; static const int Counterr = 45; static const int Slabmissing = 46; static const int Idmissing = 47; static const int Point = 64; static const int Warn = -128; static const int Now = 128; void Report(int N, int Id, int Num) { static int Lastchange = 0; int Mark; int Start; int Errline; void Printtext(int Stream) { static const int Esc = 27; int K; int P; static const _imp_string Message[44 /*1:44*/] = { _imp_str_literal("Internal error "), _imp_str_literal("Reg not free"), _imp_str_literal("Out of reach "), _imp_str_literal(" out of reach!"), _imp_str_literal("RESULT missing"), _imp_str_literal("Out of reach"), _imp_str_literal("Faulty form"), _imp_str_literal("Unknown atom"), _imp_str_literal("Unknown name"), _imp_str_literal("Wrong class"), _imp_str_literal("Wrong size"), _imp_str_literal("Wrong type"), _imp_str_literal("Inside out"), _imp_str_literal("Endless loop"), _imp_str_literal("Low level"), _imp_str_literal("Not accessible"), _imp_str_literal("Not in loop"), _imp_str_literal("Not in routine"), _imp_str_literal("Not in fn/map"), _imp_str_literal("Not in pred"), _imp_str_literal("Duplicate"), _imp_str_literal("Out of order"), _imp_str_literal("Mismatch"), _imp_str_literal("Out of range"), _imp_str_literal("Not literal"), _imp_str_literal("Faulty operand"), _imp_str_literal("%CYCLE missing"), _imp_str_literal("%START missing"), _imp_str_literal("Extra %ELSE"), _imp_str_literal("Ill-starred"), _imp_str_literal("Non-starter"), _imp_str_literal("Not variable"), _imp_str_literal("Not reference"), _imp_str_literal("Too few args"), _imp_str_literal("Too many args"), _imp_str_literal("%BEGIN missing"), _imp_str_literal("Dubious usage"), _imp_str_literal("Not in block"), _imp_str_literal("Nonstandard "), _imp_str_literal("Not supported"), _imp_str_literal(" void"), _imp_str_literal("%END missing"), _imp_str_literal("%FINISH missing"), _imp_str_literal("%REPEAT missing")}; Putsym(Mark); if (Errline < 1000) Putsym(' '); if (Errline < 100) Putsym(' '); if (Errline < 10) Putsym(' '); Putnum(Errline); Putsym(Listflag); Putsym(' '); K = N & 63; if (K >= Counterr) { if (K == Counterr) { if (Num < 0) { Putnum(-Num); Putstring(_imp_str_literal(" extra")); } else { if (Num) Putnum(Num); Putstring(_imp_str_literal(" missing")); } Putstring(_imp_str_literal(" value(s) for ")); Putident(Id, 0); return; } if (K != Slabmissing) Putident(Id, 1); else { Putident(Id, 0); Putsym('('); Putnum(Num); Putsym(')'); } Putstring(_imp_str_literal(" missing")); Mend:; if (C.Dpid) { Putstring(_imp_str_literal(" in ")); Putident(C.Pid, -1); } return; } if (Id > 0) Putident(Id, 0); Putstring(Message[K]); if (Num > 0) Putnum(Num); if (Creacherr <= K && K <= Noresult) goto Mend; Spaces(22 - *Length(Rep)); P = Start; while (*Byteinteger(P) == ' ') P++; if (P < Faultp - 50) { P = Faultp - 47; Putstring(_imp_str_literal("...")); } else Putsym(' '); for (;;) { K = *Byteinteger(P); P++; if (P == Faultp) Putsym('|'); if (K == Nl) break; Putsym(K); } return; } Mark = '?'; if (N > 0) { Mark = '*'; C.Faults = C.Faults + 1; Faults++; } Faultnum = 0; C.Access = -1; if (File[Main].Start1 <= Fp && Fp < Lastchange) return; Start = Linestart; Errline = Line; if (!(N & Point)) { Faultp = 0; } else { while (Start >= Faultp) { Start--; if (*Byteinteger(Start) == Nl) Errline--; } while (Start != Curstart && *Byteinteger(Start - 1) != Nl) Start--; } Time1 -= Cputime; if (Listout) { Printtext(Listout); Printline(); } Selectoutput(0); if (Curfile != Lastfile) { Lastfile = Curfile; Putstring(Cur->Name); Printline(); } Printtext(0); if (N > Reacherr && Curfile == Main && (Control & Editbit) != 0) { if (Faultp > Start) Start = Faultp - 1; Cur->Fp = Start; Cur->Line = Line; if (Lastchange) Cur->Change = 0x7FFFFFFE; Selectinput(0); File[Main + 1] = 0; Rep = _imp_str_literal(""); Selectoutput(Listout); Time1 += Cputime; if (Cur->Flag < 0) _imp_signal(14, 0, 0, _imp_str_literal("")); if (Cur->Flag == 'I') Control = Control & (~Editbit); if (Cur->Change < 0x7FFFFFFE) { Lastchange = Cur->Change; _imp_signal(13, 0, 0, _imp_str_literal("")); } } else { Printline(); Selectoutput(Listout); Time1 += Cputime; } } void Fault(int N) { if (Faultnum == 0 || (N > 0 && Faultnum < 0)) { Faultnum = N; Faultp = Atomp; if (Faultnum >= Now) Report(Faultnum & 127, 0, 0); } } void Intern(int N) { Report(Internerr, 0, N); } int Litref(int V) { int I; if (!V) return (V); if (V > 0) { if (V <= Smallmax) return (-(V << 1)); } else if (V >= Smallmin) return ((V << 1) + 1); Litstore[Litpos] = V; I = Litmin - 1; do I++; while (Litstore[I] != V); if (I == Litpos) { Litpos++; if (Litpos >= Litmax) Croak(_imp_str_literal("Too many literals")); } return (I); } void Putexp(int Act, int X, int Y, int T) { Type = T; Item = Explim; if (Explo <= X && X < Item) Item = X; if (Explo <= Y && Y < Item) Item = Y; do { Item--; Ditem = &Dict[Item]; if (Item < Explo) { Explo = Item; Ditem->Act = Act; Ditem->X = X; Ditem->Y = Y; Ditem->Flags = 0; Ditem->Type = T; Ditem->Mode = 0; break; } } while (Ditem->Act != Act || Ditem->X != X || Ditem->Y != Y); } void Putexp2(int Op, int First, int T) { if (!Item) Item = Litref(Value); Putexp(Op, First, Item, T); } int Normitem(void) { if (Item) return (Item); return (Litref(Value)); } void Toreal(void) { if (Item) Putexp(Float, Item, 0, Realtype); else { *Real(Addr(Value)) = Value; Type = Realtype; } } int Temp(int M, int V) { Dtemp->Mode = M; Dtemp->Val = V; return (Lablim); } int Tempx(int R1, int R2) { Dtemp->Mode = R1 + (Indexmode - A0); Dtemp->Val = ((R2 - D0) << 12) + 0x0800; return (Lablim); } int Tempd(int A, int Disp) { Dtemp->Mode = A + (Dispmode - A0); Dtemp->Val = Disp; return (Lablim); } int Tempx2(int R1, int R2) { Dtemp2->Mode = R1 + (Indexmode - A0); Dtemp2->Val = ((R2 - D0) << 12) + 0x0800; return (Lablim + 1); } static const int Lea = 78; static const int Pea = 55; static const int Clr = 52; static const int Dbra = 81; static const int Jsr = 56; static const int Link = 72; static const int Unlk = 73; static const int Rts = 68; static const int Movem = 100; static const int Trapi = 101; static const int Dc = 102; static const int Shift = 32; static const int Reg = 1; static const int Areg = 2; static const int Ireg = 3; static const int Quick = 4; static const int Mquick = 5; static const int Ea = 6; static const int Rwea = 7; static const int Wea = 8; static const int Imm = 9; static const int Tquick = 10; static const int Rel = 11; static const int Longrel = 12; static const int Qreg = 13; static const int Postareg = 14; static const int Qea = 15; static const int Revea = 16; static const int Ximm = 17; static const int Data = 18; static const int Preareg = 19; static const int Qpre = 20; static const int Exreg = 21 + Shift; static const int Reg9 = Reg + Shift; static const int Qreg9 = Qreg + Shift; static const int Ireg9 = Ireg + Shift; static const int Postareg9 = Postareg + Shift; static const int Quick9 = Quick + Shift; static const int Areg9 = Areg + Shift; static const int Sized = 1 << 15; static const int Asized = 1 << 14; static const int Reversible = (Revea << 6) + Reg9 + Sized; static const int Multiple = (Ximm << 6) + Ea + Asized; static const int Defmax = 129; static const int Def[259 /*0:258*/] = { 0, 33192, -621079552, -805272543, -1035862016, -1879014367, -414121984, -1342144095, -958922752, -1073707999, -1025376256, -2147449823, -551550976, -1325365177, -889651200, 1174437895, -587595776, 1140883463, -598507520, -519533759, -650772480, -536310975, -650575872, -1044381279, -615101440, -2118123103, -929346560, -1061158495, -615099392, -2134900319, -929344512, 1610612747, -987725824, 1627389963, -986120192, 1644167179, -997949440, 1660944395, -993427456, 1677721611, -1003388928, 1694498827, -1002864640, 1711276043, -991789056, 1728053259, -1000833024, 1744830475, -983465984, 1761607691, -982941696, 1778384907, -989462528, 1795162123, -992706560, 1811939339, -999129088, 1828716555, -993394688, 1845493771, -998637568, 1862270987, -993886208, -520058047, -1019871232, -536835263, -1019674624, -518485183, -453640192, -535262399, -453443584, 1879048545, -621079008, 1342212359, -1035844608, 1358989575, -414104576, 809517474, -621079520, -792706654, -1035860992, -1866448478, -414120960, -1329577566, -958921728, -1324874834, -958909440, 100696647, -1035852800, 67142215, -414112768, 201359942, -958913536, 33587783, -1025367040, 33351, -551256064, 167805511, -889641984, -519009471, -453234688, -535786687, -453228544, 1107329032, -959905792, 1073774599, -598482944, 1207959559, -601780224, 1212153862, -531595264, 1317011462, -717684736, 1321205766, -724041728, 1254096903, -400982016, 1241546758, -382074880, -1056963295, -1037987840, -2130705119, -434008064, -788495071, -1035837440, -1862236895, -414097408, 1316028416, -587726848, 1315962880, -463890816, 1316159488, -448626688, 1316421632, -448200704, 1316290560, -448167936, 1316093961, -414728192, 1316356096, -383728960, 1312817162, -383729664, 1313866306, -661181440, 1314390018, -354014208, 1212153857, -412041216, 1216348161, -880124928, 1220542465, -880136192, -1052766911, -880574464, 1103102946, -665812992, 1098908065, -964329472, 1355284556, -936615936, 1372061772, -936836096, 1388838988, -937155584, 1405616204, -937014272, 1422393420, -937325568, 1439170636, -937309184, 1455947852, -936963072, 1472725068, -937245696, 1489502284, -936702976, 1506279500, -936686592, 1523056716, -936890368, 1539833932, -936991744, 1556611148, -937192448, 1573388364, -937013248, 1590165580, -937177088, 1606942796, -937028608, 20973767, -1003217920, 25168072, -1003075584, 29362376, -986525696, 16779462, -985018368, 1216365638, -621079136, 1312817738, -383729376, 18, -936378368, 1354760200, -415236096, 1371537416, -429916160, 1388314632, -427524096, 1405091848, -423002112, 1421869064, -432963584, 1438646280, -432439296, 1455423496, -421363712, 1472200712, -430407680, 1488977928, -413040640, 1505755144, -412516352, 1522532360, -419037184, 1539309576, -422281216, 1556086792, -428703744, 1572864008, -422969344, 1589641224, -428212224, 1606418440, -423460864, 1153433984, -616460736, 1186988416, -615921664, 1086324744, -630601728, 1314914306, -615854592, 1315438594, -630534656, 37486601, -1019113920, 41680905, -1018574848, 171704329, -884896192, 175898633, -884357120, 3932169, -549351872, 8126473, -548812800}; void Putopcode(int Op) { Putmnemonic(Def[Op + Op]); } void Store(int V, int F) { Prog[Pc] = V; Pflag[Pc] = F; Pc++; } void Makeroom(int Size) { int Newbase; int Newlim; Size = (Size + 127) & (~127); Ownbase -= Size; if (Ownbase <= Cad) Croak(_imp_str_literal("Program too big")); Newbase = Ownbase; Newlim = Newbase + Ownad; do { Final[Newbase] = Final[Newbase + Size]; Newbase++; } while (Newbase < Newlim); } void Fillcode(int N) { int I; I = Cad; Cad += N; while (N > 0) { Final[I] = 0x80; I++; N--; } } void Fillown(int N) { int I; Makeroom(N); I = Ownbase + Ownad; Ownad += N; while (N > 0) { Final[I] = 0x80; I++; N--; } } void Setcodeword(int V) { Shortinteger = V; Cad += 2; } int Codeword(int Cad) { return (Shortinteger); } void Setcodelongword(int V) { Setcodeword((unsigned)V >> 16); Setcodeword(V); } void Setownword(int V) { if (Ownbase + Ownad > Finalbound) Makeroom(2); Shortinteger = V; Ownad += 2; } void Extendstack(int Delta) { C.Sp = C.Sp - Delta; if (C.Sp < C.Stack) { C.Stack = C.Sp; if (C.Stack < C.Totstack) C.Totstack = C.Stack; } } void Plant(int Op, int Y, int X) { int Opcode; int Pc1; int I; int F; int Extword; int Info; int Kind; int Mode; int Modex; int Size; Identinfo *Dx; Identinfo *Dy; static int S_sw; static void *S[22 /*0:21*/] = { &&S_0, &&S_1, &&S_2, &&S_3, &&S_4, &&S_5, &&S_6, &&S_7, &&S_8, &&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, }; static const unsigned char Sizesym[4 /*0:3*/] = {'L', 'B', 'W', '?'}; int Nonlocal(int L) { int R; if (!L) return (Mb); if (L != Level) Hold[L].Status = Hold[L].Status | Globbed; if (L == Outerlevel + 1) return (F1); R = Maxareg; do { if (C.Reg.Content == D7 + L) return (R); R--; } while (R >= A0); R = Maxareg; while (!(A0b << (R - A0) & Free)) { if (R == A0) { Fault(Plexerr); break; } R--; } C.Reg.Content = D7 + L; Dtsprel->Mode = Globalmode; Dtsprel->Val = L << 2; Plant(Move, Lablim + 2, R); return (R); } static const int Moveq = 36; static const int Addq = 37; static const int Movea = 39; static const int Adda = 40; static const int Addi = 44; if (X > 0) { if (X >= Explim) { Intern(1); return; } Dx = &Dict[X]; Modex = Dx->Mode; if (Modex >= Framemode && Modex != C.Mode && (Modex & 0b111000) != 0b111000) Modex = Nonlocal(Modex & 7) - A0 + (Modex & (7 << 3)); } else { Modex = Litmode; Dx = Dint; } if (Y > 0) { if (Y >= Explim) { Intern(1); return; } Dy = &Dict[Y]; Mode = Dy->Mode; if (Mode >= Framemode && Mode != C.Mode && (Mode & 0b111000) != 0b111000) Mode = Nonlocal(Mode & 7) - A0 + (Mode & (7 << 3)); } else { Mode = Litmode; Dy = Dint; } Size = (unsigned)Op >> 8; Op = Op & 255; if (Op == Move) if (!(Modex & 0b111000)) { if (Y <= 0 && Y >= Litmite && (Size & 3) == 0) Op = Moveq; } else if (!(Modex & 0b110000)) Op = Movea; else if (Op <= Cmp) if (Op < Cmp && Y < 0 && Y >= Litquick && (Y & 1) == 0) Op += Addq - Add; else if ((Modex & 0b111000) == Aregmode) Op += Adda - Add; else if (Y <= 0) Op += Addi - Add; else if (Op <= Eor) if (Y <= 0) Op += Addi - Add; Info = Def[Op + Op - 1]; Opcode = (unsigned)Info >> 16; if (Info & Sized) { if (!Size) Size = 4; if (Op == Move) if (Size == 4) Opcode += 0x2000; else if (Size == 2) Opcode += 0x3000; else Opcode += 0x1000; else if (Size == 4) Opcode += 0x80; else if (Size == 2) Opcode += 0x40; } else if (Info & Asized) { if (Size == 1) Fault(Sizerr); if (Op != Movem) { if (!Size) if (Y > 0 || Isshort(Litval(Y)) != True) Size = 4; if (Size == 4) if (Op == Movea) Opcode = Opcode ^ 0x1000; else Opcode += 0x0100; } else { if (!Size) Size = 4; if (Size == 4) Opcode += 0x0040; } } if ((Control & Codelist) != 0 && (Control & List) != 0) { if (*Length(Rep) >= 4) Printline(); Putsym(Codeflag); Spaces(4 - *Length(Rep)); Putopcode(Op); if (Size) { Putsym('.'); Putsym(Sizesym[Size & 3]); } Spaces(12 - *Length(Rep)); if (Info & (63 << 6)) { Putoperand(Y); if (Info & 63) Putsym(','); } if (Info & 63) Putoperand(X); Spaces(33 - *Length(Rep)); Putsym(':'); } Pc1 = Pc; Pflag[Pc1] = C.Shorts; Pc++; if (Pc >= Swpc - 8) Croak(_imp_str_literal("Code space exhausted")); Kind = (unsigned)Info >> 6; Again:; goto *S[S_sw = Kind & 31]; S_0:; Next:; Kind = Info; if (Kind) { Dy = Dx; Y = X; Mode = Modex; Info = 0; goto Again; } Prog[Pc1] = Opcode; if ((Control & Codelist) != 0 && (Control & List) != 0) { do { Putsym(' '); Puthex(Prog[Pc1]); Pc1++; } while (Pc1 < Pc); Printline(); } return; void Pcrel(int Shorten) { if (Dy->Mode == Labmode) { F = Jump; if (!Shorten) F = Longjump; if (Extword > 0) { if (Shorten != 0 && (Extword - Pflag[Extword] - Pc + C.Shorts) << 1 >= -128) if (C.Shorts == 255) Zaps += 100; else { Shorts++; C.Shorts = C.Shorts + 1; F = Shortjump; } } else { Extword = -Extword; Dy->Val = -Pc; } } else if (Dy->Mode == Procmode) { F = Indglobal; Extword = Y; } else if (Dy->Mode == Constmode) { F = Global; if (Extword < 0) F++; if (Extword > 65535) F += 2; } else if (Dy->Mode != Pcmode) Fault(Moperr); } S_15:; if ((Mode & 63) != X - (A0 - Indexmode) || (Dy->Val & 255) != 0) goto Ea0; Opcode = 0xD1C0 + ((unsigned)Dy->Val >> 12 & 15); goto Next; S_8:; Dy->Flags = Dy->Flags | (Mflag | Wflag); goto Wea1; S_7:; Dy->Flags = Dy->Flags | Mflag; Wea1:; if (Y <= 0 || (Mode & 63) >= Pcmode) goto Err; goto Ea1; S_16:; if (Modex & 0b111000) { Kind = Shift; Info = Rwea; Opcode = Opcode ^ 0x0100; goto Sreg; } S_6: Ea0:; if (Y <= 0) { Opcode += Litmode; goto Simm; } if ((Dy->Flags & (Ext + Spec + Rflag + Wflag)) == Ext + Spec && (Dy->Flags & Proc) != 0) { if (Ownad & 1) Fillown(1); Dy->Val = Ownad; Setownword(0x207C + ((Mb - A0) << 9)); Setownword(0); Setownword(0); Setownword(0x4EF9); Setownword(0); Setownword(0); } if ((Op == Lea || Op == Pea) && (Mode & 63) != Pcmode) { Dy->Flags = Dy->Flags | (Mflag + Rflag + Wflag); if ((Mode & 0b111000) < Aregmode + Indir) goto Err; } else Dy->Flags = Dy->Flags | (Mflag + Rflag); Ea1:; Extword = Dy->Val; if (Mode == C.Mode) { Mode = Dispmode + 7; Extword -= C.Sp; if (Extword < 0) { if (Extword < -4) Intern(4); Mode = Aregmode + Pre + 7; Extendstack(-Extword); Extword = 0; } } Mode = Mode & 63; if (Mode >= Dispmode) { F = 0; if (Mode == Pcmode) Pcrel(0); if (Mode <= Dispmode + 7) if (!Extword) { if (Mode >= Dispmode) Mode += Aregmode + Indir - Dispmode; } else { if (-32768 > Extword || Extword > 32767) Fault(Dreacherr); Store(Extword, F); } else { if (Mode == Absmode && Isshort(Extword) != True) Mode = Absmode + 1; if (Mode == Absmode + 1) Store((unsigned)Extword >> 16, 0); Store(Extword, F); } } if (Kind & Shift) Mode = (((Mode & 7) << 3) + ((unsigned)Mode >> 3)) << 6; Opcode += Mode; goto Next; S_21:; if (!(Mode & 0b111000)) { if (Modex & 0b111000) { Opcode = Opcode ^ 0xC8; Info = Areg; } goto Sreg; } Opcode += 8; Info = Areg; goto Sareg; S_20:; if (!(Mode & 0b111000)) goto Sreg; Opcode += 8; Info = Preareg + Shift; S_19:; Mode += Post - Pre; S_14:; Mode -= Post; S_2: Sareg:; Mode -= 8; S_1: Sreg:; if (Mode & 0b111000) goto Err; Mode = Mode & 7; if (Kind & Shift) Mode = Mode << 9; Opcode += Mode; goto Next; S_13:; if (Y > 0) { Opcode += 0x20; goto Sreg; } if (Y == One && Size == 2 && (Modex & 0b111000) != 0) { Opcode = Opcode ^ 0x290; goto Next; } S_4:; if (Y >= 0) goto Err; Y = Litval(Y); if (Y > 8) goto Err; Opcode += (Y & 7) << 9; goto Next; S_10:; if (-30 > Y || (Y & 1) != 0) goto Err; S_5:; if (Y > 0 || Y < Litmite) goto Err; Y = Litval(Y); Opcode += Y & 255; goto Next; S_11:; if (Y <= 0 && Y >= Litmite) goto *S[S_sw = Mquick]; S_12:; if (Y <= 0) goto Simm; Dy->Flags = Dy->Flags | Rflag; Extword = Dy->Val; F = 0; Pcrel(Longrel - (Kind & 31)); Store(Extword, F); goto Next; S_3:; if (Y > 0) goto Sreg; Opcode = Opcode ^ 0x900; S_9:; if (Y > 0) goto Err; Simm:; Y = Litval(Y); if (Size == 4) Store((unsigned)Y >> 16, 0); Put:; Store(Y, 0); goto Next; S_17:; if (Y > 0) { Opcode = Opcode ^ 0x0400; I = X; X = Y; Y = I; Dx = Dy; Modex = Mode; } Y = Litval(Y); if (Prea0 <= X && X <= Prea7) { I = 0; for (Extword = 1; Extword <= 16; Extword++) { I = (I << 1) + (Y & 1); Y = (unsigned)Y >> 1; } Y = I; } goto Put; S_18:; if (Y <= 0) goto Err; if (Mode != Absmode) goto Err; Opcode = Dy->Val; goto Next; Err:; Fault(Moperr); goto Next; } void Plantlit(int Op, int V, int X) { if (V >= 0) if (V > Smallmax) { Litstore[Litmax] = V; V = Litmax; } else V = -(V << 1); else if (V < Smallmin) { Litstore[Litmax] = V; V = Litmax; } else V = (V << 1) + 1; Plant(Op, V, X); } void Plantlit2(int Op, int Y, int V) { if (V >= 0) if (V > Smallmax) { Litstore[Litmax] = V; V = Litmax; } else V = -(V << 1); else if (V < Smallmin) { Litstore[Litmax] = V; V = Litmax; } else V = (V << 1) + 1; Plant(Op, Y, V); } void Align(int *Ad, int Size) { if (Size != 1 && (*Ad & 1) != 0) *Ad = *Ad + 1; } void Addimm(int Bytes, int Dest) { if (Bytes <= 0) { if (!Bytes) return; if (Bytes >= -8) { Plantlit(Sub, -Bytes, Dest); return; } } else if (Bytes <= 8) { Plantlit(Add, Bytes, Dest); return; } if (A0 <= Dest && Dest <= A7 && Isshort(Bytes) == True) { Plant(Lea, Tempd(Dest, Bytes), Dest); return; } Plantlit(Add, Bytes, Dest); } int Freereg(int Rset) { int R; int R1; R = D0; Rset = Rset & Free; if (!Rset) Fault(Plexerr); else { while (!(Rset & 1)) { R++; Rset = (unsigned)Rset >> 1; } R1 = R; while (C.Reg.Content != Undef) { R++; Rset = (unsigned)Rset >> 1; if (!Rset) { R = R1; break; } while (!(Rset & 1)) { R++; Rset = (unsigned)Rset >> 1; } } Free -= D0b << (R - D0); } return (R); } void Moveblock(int Source, int Dest, int Bytes) { int Op; int F; int R; int Pc1; Op = Move; if (!Source) Op = Clr; if (Bytes <= 16 && (Bytes & 1) == 0) { while (Bytes >= 4) { Plant(Op, Source, Dest); Bytes -= 4; } if (Bytes >= 2) Plant(Op + (2 << 8), Source, Dest); } else { Op += 1 << 8; if (!(Bytes & 1)) { Bytes = (unsigned)Bytes >> 1; Op += 1 << 8; if (!(Bytes & 1)) { Bytes = (unsigned)Bytes >> 1; Op += 2 << 8; } } F = Free; if (Bytes <= 32768 && (Free & Anydreg) != 0) { R = Freereg(Anydreg); Plantlit(Move, Bytes - 1, R); Pc1 = Pc; Plant(Op, Source, Dest); Plantlit2(Dbra, R, (Pc1 - Pc - 1) << 1); Bytes = Undef; } else { R = Freereg(Anydreg | Bregb); Plantlit(Move, Bytes, R); Pc1 = Pc; Plant(Op, Source, Dest); Plant(Sub, One, R); Plantlit2(Bne, 0, (Pc1 - Pc - 1) << 1); Bytes = 0; } C.Reg.Content = Bytes; Free = F; } } void Updatesp(void) { if (!C.Val) return; if (C.Val < 0) { Addimm(-C.Val, A7); C.Sp = C.Sp - C.Val; } else { if (!(Control & Assmask)) Addimm(-C.Val, A7); else Moveblock(D7, Prea7, C.Val); Extendstack(C.Val); } C.Val = 0; } void Getbounds(int T, int *Lo, int *Hi) { if (Dict[T].Type == T && T != Inttype) { *Lo = 0; *Hi = Dict[T].Size; } else { if (Dict[T + 1].Mode != Litmode) *Lo = Minint; else *Lo = Dict[T + 1].Val; if (Dict[T + 2].Mode != Litmode) *Hi = Maxint; else *Hi = Dict[T + 2].Val; } } int Size(int T) { int S; int Ss; int Lo; int Hi; Identinfo *Tp; Tp = &Dict[T]; if (!(Tp->Flags & Nonord)) { if (Tp->Type != T) return (Tp->Size()); if (Tp->Type == Inttype) return (4); if (Tp->Size() <= 255) return (1); return (2); } if ((Tp->Flags & Cat) == Recy) return (Tp->Val); if ((Tp->Flags & Cat) != Arry) return (Tp->Size()); if (Tp->Mode >= Framemode) return (0); S = 4; if (Tp->Flags >= 0) S = Size(Tp->Type); Getbounds(Tp->Xtype, Lo, Hi); if (Lo == Minint || Hi == Maxint) return (0); Ss = (Hi - Lo + 1) * S; if (Ss <= 0) return (Ss); if (S == 1) { if (Ss == 1) return (Ss); } else if (Ss <= 4) return (Ss); return (-Ss); } int Nsize(Identinfo * Dp) { if (Dp.Flags & (Name + Indirect)) return (4); if (Dp.Flags & Proc) return (0); return (Size(Dp.Type)); } int Tsize(int T) { return (Size(Dict[T].Type)); } void Forget(int R) { C.Reg.Content = Undef; } void Forgetcc(void) { C.Reg.Ccy = Undef; } void Forgetregs(void) { short *Cc; int I; I = Maxareg; Cc = &C.Reg.Content; for (;;) { *Cc = Undef; if (Cc == &C.Reg.Content) break; I--; Cc = &C.Reg.Content; } C.Reg.Ccy = Undef; C.Reg.Line = -9; } void Forgettriples(void) { Litpos = Litmin; Explo = Explim; Oldexplo = Explim; } void Forgetall(void) { int I; int J; Contentinfo *Lr; Forgetregs(); J = Dictlim; for (;;) { J++; if (J >= Curlab) break; Lr = &Lreg[J - Dictlim]; for (I = D0; I <= Maxareg; I++) Lr->Content = Undef; Lr->Ccx = Undef; } Forgettriples(); } void Definejumps(int Chain) { int I; int J; int K; Chain = -Chain; if (Chain <= 0) return; C.Forward = C.Forward - 1; C.Access = 1; do { I = Prog[Chain]; if (Pflag[Chain] == Jump) { J = Chain - Pflag[Chain - 1]; K = (Pc - C.Shorts - J) << 1; if (K > 2 && K <= 127) if (C.Shorts == 255) Zaps += 100; else { C.Shorts = C.Shorts + 1; Shorts++; Pflag[Chain] = Shortjump; J = Chain; do { if (Pflag[J] >= Zeroshorts) Pflag[J] = Pflag[J] + 1; J++; } while (J != Pc); } } Prog[Chain] = Pc; Chain = I; } while (Chain > 0); } void Savecontext(int L) { int R; Contentinfo *Lr; if (L - Dictlim < 0) return; Lr = &Lreg[L - Dictlim]; if (Dict[L].Val >= 0) { Dict[L].Val = 0; *Lr = C.Reg; C.Forward = C.Forward + 1; } else { for (R = D0; R <= Maxareg; R++) if (Lr->Content != C.Reg.Content) Lr->Content = Undef; if (Lr->Ccx != C.Reg.Ccx || Lr->Ccy != C.Reg.Ccy) Lr->Ccy = Undef; if (Lr->Line != C.Reg.Line) Lr->Line = -9; } } void Srcall(int X) { void Putprim(Identinfo * Dx) { static short Primcode[396 /*1:396*/] = { 0x1541, 0x7272, 0x6179, 0x2062, 0x6F75, 0x6E64, 0x7320, 0x6578, 0x6365, 0x6564, 0x6564, 0xB098, 0x6E06, 0x9098, 0x6C10, 0xD0A0, 0x41FA, 0xFFDE, 0x2400, 0x7202, 0x7076, 0x4EF8, 0x3EFA, 0x4A58, 0x660C, 0x4840, 0x4A40, 0x6610, 0x4840, 0xC0D8, 0x4E75, 0x2F01, 0x2200, 0xC2E8, 0xFFFE, 0x6008, 0x2F01, 0x2200, 0x4840, 0xC2D0, 0x4841, 0xC0D8, 0xD081, 0x221F, 0x4E75, 0x1355, 0x6E61, 0x7373, 0x6967, 0x6E65, 0x6420, 0x7661, 0x7269, 0x6162, 0x6C65, 0x660C, 0x41FA, 0xFFE8, 0x7201, 0x7058, 0x4EF8, 0x3EFA, 0x4E75, 0x0F49, 0x6E76, 0x616C, 0x6964, 0x2061, 0x6464, 0x7265, 0x7373, 0x6E0C, 0x41FA, 0xFFEC, 0x7201, 0x7058, 0x4EF8, 0x3EFA, 0x4E75, 0x1553, 0x7461, 0x636B, 0x2073, 0x7061, 0x6365, 0x2065, 0x7868, 0x6175, 0x7374, 0x6564, 0xD88F, 0xB886, 0x6C0E, 0x4284, 0x41FA, 0xFFE0, 0x7203, 0x7055, 0x4EF8, 0x3EFA, 0x4284, 0x4E75, 0x1741, 0x7272, 0x6179, 0x2062, 0x6F75, 0x6E64, 0x7320, 0x696E, 0x7369, 0x6465, 0x206F, 0x7574, 0x9282, 0x6F0C, 0x41FA, 0xFFE2, 0x7203, 0x7055, 0x4EF8, 0x3EFA, 0x4481, 0x5281, 0x4EF8, 0x3EF4, 0x4E75, 0x0E53, 0x7472, 0x696E, 0x6720, 0x746F, 0x6F20, 0x6269, 0x6780, 0x1811, 0x9004, 0x6504, 0x9010, 0x640C, 0x41FA, 0xFFE4, 0x7203, 0x7051, 0x4EF8, 0x3EFA, 0x1018, 0x670C, 0xD111, 0x1398, 0x4801, 0x5204, 0x5300, 0x66F6, 0x2049, 0x4E75, 0x3F00, 0x7001, 0x1E80, 0x204F, 0x548F, 0x4E75, 0x124E, 0x6F20, 0x7370, 0x6163, 0x6520, 0x666F, 0x7220, 0x6172, 0x7261, 0x7980, 0x5680, 0xE480, 0xE588, 0x6D08, 0x204F, 0x91C0, 0xB1C6, 0x6C0E, 0x2400, 0x41FA, 0xFFD8, 0x7201, 0x7072, 0x4EF8, 0x3EFA, 0x205F, 0xE488, 0x6004, 0x4840, 0x2F07, 0x51C8, 0xFFFC, 0x4840, 0x51C8, 0xFFF4, 0x4ED0, 0x4E75, 0x1149, 0x6E76, 0x616C, 0x6964, 0x2025, 0x666F, 0x7220, 0x6C6F, 0x6F70, 0x2F00, 0x9082, 0x6720, 0x2F01, 0x6708, 0x4EB8, 0x3EEE, 0x4A80, 0x6D0E, 0x508F, 0x41FA, 0xFFD8, 0x7201, 0x7055, 0x4EF8, 0x3EFA, 0x4A81, 0x66EE, 0x221F, 0x201F, 0x4E75, 0x0C4F, 0x7574, 0x206F, 0x6620, 0x7261, 0x6E67, 0x6580, 0x41FA, 0xFFF0, 0x7201, 0x7056, 0x4EF8, 0x3EFA, 0x4E75, 0x1355, 0x6E61, 0x7373, 0x6967, 0x6E65, 0x6420, 0x7661, 0x7269, 0x6162, 0x6C65, 0xB0FC, 0x0000, 0x6F1A, 0xB2FC, 0x0000, 0x6F14, 0xBE10, 0x6606, 0xBE28, 0x0001, 0x670A, 0xBE11, 0x6612, 0xBE29, 0x0001, 0x660C, 0x41FA, 0xFFCA, 0x7202, 0x7054, 0x4EF8, 0x3EFA, 0x48E7, 0xC0C0, 0x4240, 0x1018, 0x6730, 0x4241, 0x1219, 0x6722, 0x5380, 0x5381, 0xB041, 0x6E12, 0x9240, 0xB109, 0x56C8, 0xFFFC, 0x6602, 0x4441, 0x4CDF, 0x0303, 0x4E75, 0xB109, 0x56C9, 0xFFFC, 0x66F2, 0x7201, 0x4CDF, 0x0303, 0x4E75, 0x1011, 0x4440, 0x4CDF, 0x0303, 0x4E75, 0x0E53, 0x7472, 0x696E, 0x6720, 0x746F, 0x6F20, 0x6269, 0x6780, 0xB010, 0x640C, 0x41FA, 0xFFEA, 0x7203, 0x7051, 0x4EF8, 0x3EFA, 0x4280, 0x1010, 0x12D8, 0x51C8, 0xFFFC, 0x4E75, 0x0E53, 0x7472, 0x696E, 0x6720, 0x746F, 0x6F20, 0x6269, 0x6780, 0xB010, 0x640C, 0x41FA, 0xFFEA, 0x7201, 0x7056, 0x4EF8, 0x3EFA, 0x0240, 0x00FE, 0x245F, 0x9EC0, 0x558F, 0x224F, 0xBFC8, 0x6E0E, 0x1010, 0x12D8, 0x51C8, 0xFFFC, 0x204F, 0x224F, 0x4ED2, 0x1018, 0x5289, 0xD0C0, 0xD2C0, 0x1320, 0x51C8, 0xFFFC, 0x204F, 0x224F, 0x4ED2, 0x4E75, 0x43EF, 0xFF00, 0x2448, 0xD5C0, 0x2049, 0x9280, 0x6C04, 0x4211, 0x4E75, 0x1281, 0x5219, 0x12DA, 0x51C9, 0xFFFC, 0x4E75, 0x700A, 0x4EF8, 0x3E70, 0x4E75, 0x7020, 0x4EF8, 0x3E70, 0x4E75}; int Start; int Limit; Identinfo *Ddx; if (Cad & 1) Fillcode(1); Start = (unsigned)Dx.Val >> 16 & 511; Limit = Start + (Dx.Val & 255); Dx.Val = Cad + ((unsigned)Dx.Val >> 7 & (255 << 1)); Dx.Mode = Procmode; if (Start == Limit) { Ddx = &Dict[Check]; if (Ddx->Mode == Absmode) { Putprim(*Ddx); Dx.Val = Cad; } Setcodeword(0x0C80); Setcodelongword(Dict[X + 1].Val); Setcodeword(0x6D00); Setcodeword(Ddx->Val - Cad); Setcodeword(0x0C80); Setcodelongword(Dict[X + 2].Val); Setcodeword(0x6E00); Setcodeword(Ddx->Val - Cad); Setcodeword(0x4E75); } else do { Setcodeword(Primcode[Start]); Start++; } while (Start < Limit); } Identinfo *Dx; Identinfo *Tp; Dx = &Dict[X]; Tp = Typecell(Dx->Type); if (Dx->Mode == Absmode && Dx->Val < 0) Putprim(*Dx); else { if (Tp->Val <= 0) C.Status = C.Status | Unknown; if (C.Sp - Imod(Tp->Val) < C.Totstack) C.Totstack = C.Sp - Imod(Tp->Val); } if ((Dx->Mode & 63) == Pcmode) { if ((Dx->Flags & Spec) != 0 && (Dx->Flags & Rflag) == 0) C.Forward = C.Forward + 1; Plant(Bsr, 0, X); } else if ((Dx->Flags & (Name + Indirect)) == 0 || (Dx->Flags & Ext) != 0) Plant(Jsr, 0, X); else if (Free & A0b << 3) { Plant(Move, X, A0 + 3); Plant(Jsr, 0, A0 + 3 + Indir); Forget(A0 + 3); } else { Plant(Move, X, Tempd(A7, -4)); Plantlit(Move, 0x4EF9, Tempd(A7, -6)); Plant(Jsr, 0, Lablim); } } void Definelabel(int Lab) { int R; int Chain; Contentinfo *Lr; Chain = Dict[Lab].Val; if (Chain >= 0) { Updatesp(); Forgetregs(); } else { Lr = &Lreg[Lab - Dictlim]; if (!C.Access) { C.Reg = *Lr; } else { for (R = D0; R <= Maxareg; R++) if (C.Reg.Content != Lr->Content) Forget(R); if (C.Reg.Ccx != Lr->Ccx || C.Reg.Ccy != Lr->Ccy) Forgetcc(); if (Lr->Line != C.Reg.Line) C.Reg.Line = -9; } } Definejumps(Chain); Dict[Lab].Val = Pc; if ((Control & Codelist) != 0 && (Control & List) != 0) Putoperand(Lab); } void Setuserlabel(int *Chain) { Updatesp(); if (C.Temps != 0 && C.Access != 0) Addimm(C.Temps, A7); Definejumps(*Chain); *Chain = Pc; C.Access = 1; if (C.Temps) Addimm(-C.Temps, A7); Forgetregs(); if (Curlab == C.Lab1) Forgettriples(); } void Flush(void) { if (Pendcond < 0) { Litstore[Litpos] = Line; if (Control & Tracebit) Plantlit2(Trapi, Litpos, 15); else if (Line - C.Reg.Line > 8) Plant(Move + (2 << 8), Litpos, Lineloc); else Plantlit(Add + (2 << 8), Line - C.Reg.Line, Lineloc); Forgetcc(); C.Reg.Line = Line; } else { if (Pendout) { Pendcond = Pendcond & 15; if (!Pendcond) C.Access = 0; if (Pendcond != 1) { Savecontext(Pendout); Plant(Bra + Pendcond, 0, Pendout); } } if (Pendin) Definelabel(Pendin); } Pendcond = 0; } static const int Inst = 1 << 30; void Eval(int *Pp, int Rset) { static const int Asl = 32; static const int Cmpm = 43; static const int Trapv = 70; static const int Swap = 74; static const int Extl = 76; static const int Jmp = 57; static const int Tst = 59; static const int Dbne = 86; static const int Movew = Move + (2 << 8); static const int Addw = Add + (2 << 8); static const int Moveb = Move + (1 << 8); static const int Addb = Add + (1 << 8); static const int Subb = Sub + (1 << 8); static const int Cmpb = Cmp + (1 << 8); static const int Cmpmb = Cmpm + (1 << 8); static const int Val = Sign + Anyreg; static const int Ref = Sign; static const int Sizeshift = 16; static const int Tobyte = 1 << 16; static const int Toshort = 1 << 17; static const int Tostack = 1 << 19; static const int Asad = 1 << 20; static int Do_sw; static void *Do[118 /*0:117*/] = { &&Do_0, &&Do_1, &&Do_2, &&Do_3, &&Do_4, &&Do_5, &&Do_6, &&Do_7, &&Do_8, &&Do_9, &&Do_10, &&Do_11, &&Do_12, &&Do_13, &&Do_14, &&Do_15, &&Do_16, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_32, &&Do_33, &&Do_34, &&Do_35, &&Do_36, &&Do_37, &&Do_38, &&Do_39, &&Do_40, &&Do_41, &&Do_42, &&Do_43, &&Do_44, &&Do_45, &&Do_46, &&Do_47, &&Do_48, &&Do_49, &&Do_50, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_73, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_78, &&Do_79, &&Do_default, &&Do_default, &&Do_82, &&Do_default, &&Do_default, &&Do_default, &&Do_86, &&Do_87, &&Do_88, &&Do_89, &&Do_90, &&Do_91, &&Do_92, &&Do_93, &&Do_94, &&Do_95, &&Do_default, &&Do_default, &&Do_98, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_103, &&Do_default, &&Do_105, &&Do_106, &&Do_107, &&Do_default, &&Do_109, &&Do_default, &&Do_111, &&Do_default, &&Do_default, &&Do_default, &&Do_115, &&Do_default, &&Do_117, }; static int Stsiz = 0; int I; int J; int P; int Act; int X; int Y; int Xx; int Yy; int Wx; int Wy; int Sx; int Sy; int R; int Oldfree; int Freed; int M; int V; int Sp; int Stsize; int Op; int Case; Identinfo *Dp; Identinfo *Dx; Identinfo *Dy; Identinfo *Tx; int Freedreg(void) { return (Freereg(Anydreg)); } int Freeareg(int Content) { int R; R = Freereg(Anyareg); C.Reg.Content = Content; return (R); } void Push(int X) { Plant(Move, X, Prea7); Extendstack(4); } void Pop(int X) { Plant(Move, Posta7, X); C.Sp = C.Sp + 4; } void Pushs(int X, int S) { Plant(Move + (S << 8), X, Prea7); if (S < 4) Extendstack(2); else Extendstack(4); } void Pushblock(int Areg, int Bytes) { if (Bytes <= 4) Moveblock(Areg + Indir, Prea7, Bytes); else { Addimm(Bytes, Areg); Moveblock(Areg + Pre, Prea7, Bytes); } Extendstack(Bytes); } void Compileuncondbranch(int L) { if (Pendcond) if (Pendcond < 0) { Pendcond = 0; } else if (Pendin) { Flush(); } else { Pendcond = Pendcond ^ 1; if (*Pp + 1 < Np && Dict[*Pp + 1].Act == Else) C.Access = -2; } Pendcond = Pendcond & 15; if (!Pendcond) C.Access = 0; if (Pendcond != 1) Plant(Bra + Pendcond, 0, L); Pendcond = 0; } int Cleanreg(void) { int R; if (Free & Bregb) { Free -= Bregb; return (Breg); } R = Freedreg(); Plant(Clr, 0, R); return (R); } int Weight(int P) { int A; int Wy; Identinfo *Dp; if (P >= Explim) P -= Ad; if (P < Np0) return (1); Dp = &Dict[P]; A = Dp->Act; if (A >= Imul) return (999); Wy = Weight(Dp->Y); if (Wy >= 999) return (Wy); if (A == Recref && Dict[Dp->X].Flags >= 0) Wy--; return (Wy + Weight(Dp->X)); } void Checkaddress(int V) { if (A0 <= V && V <= A7) Plant(Cmp + (2 << 8), 0, V); else Plant(Tst, 0, V); Srcall(Adok); Forgetcc(); } void Call(void) { int Sp; int Stage; int Maxq; int Awkward; void Evalparlist(int Arg, int Q) { Identinfo *Darg; Identinfo *Dv; int V; int W; int F; int R; int S; if (!Arg) return; Darg = &Dict[Arg]; Q++; if (Q > Maxq) Maxq = Q; if (!(Q & 1)) V = Dict[P + ((unsigned)Q >> 1)].X; else V = Dict[P + ((unsigned)Q >> 1)].Y; R = Darg->Reg & 15; S = Size(Darg->Type); if (Darg->Flags & Proc) { S = 0; if (Awkward) { F = V; if (F >= Explim) F -= Ad; Dv = &Dict[F]; if ((Dv->Flags & (Ext + Spec)) != Ext + Spec) { if (Stage) { Evalparlist(Darg->Link, Q); return; } if (Dv->Flags & (Name + Indirect)) Plant(Move, F, Prea7); else Plant(Pea, 0, F); Plantlit(Move + (2 << 8), 0x4EF9, Prea7); Plant(Move, Mb, Prea7); Plantlit(Move + (2 << 8), 0x287C, Prea7); Extendstack(12); S = C.Sp; Evalparlist(Darg->Link, Q); if (Darg->Val > 0) Plant(Pea, 0, Temp(C.Mode, S)); else { Plant(Lea, Temp(C.Mode, S), R + D0); Free = Free & (~(D0b << R)); } return; } } } if (Darg->Val > 0) { Evalparlist(Darg->Link, Q); if (Stage) return; if (Darg->Flags < 0) { F = Free; Eval(V, Anyareg); Push(V); Free = F; return; } if (S > 0) { F = Free; Eval(V, Val); Pushs(V, S); Free = F; } else { Stsiz = S; if (Category(Darg->Type) != Stringy) Stsiz = -Stsiz; Eval(V, Tostack); } return; } if (S <= 0 && Darg->Flags >= 0) { if (V >= Explim) V -= Ad; if (V >= Np0) { Dv = &Dict[V]; if (Dv->Act >= Concat && Dv->Mode == 0) { if (!Stage) { Stsiz = S; if (Category(Darg->Type) != Stringy) Stsiz = -Stsiz; R = V; Eval(R, Tostack); Free = Free | A0b; C.Reg.Content = V + Ad; Dv->Val = C.Sp; Evalparlist(Darg->Link, Q); } else { Evalparlist(Darg->Link, Q); if (C.Reg.Content != V + Ad) { Dv->Mode = C.Mode; Plant(Lea, V, R + D0); Dv->Mode = 0; } Free = Free & (~(D0b << R)); } return; } } V += Ad; } W = Weight(V); if (W >= 999) { Evalparlist(Darg->Link, Q); if (Stage) return; } else { if (W >= 2 && Stage != 0) { Eval(V, D0b << R); Evalparlist(Darg->Link, Q); return; } Evalparlist(Darg->Link, Q); if (!Stage) return; } Eval(V, D0b << R); } Awkward = 0; if ((Dx->Flags & Proc2) != 0 && ((Dx->Flags & Ext) == 0 || (Dx->Flags & Spec) != 0)) { Awkward = 1; Push(Mb); } Sp = C.Sp; Maxq = 0; Stage = 0; Evalparlist(Dict[Dx->Type].Link, -1); Stage = 1; Evalparlist(Dict[Dx->Type].Link, -1); Srcall(Act); if (C.Sp != Sp) { Addimm(Sp - C.Sp, A7); C.Sp = Sp; } if (Awkward) Pop(Mb); if (P < Np) *Pp = P + ((unsigned)Maxq >> 1); Forgetregs(); if ((Dx->Flags & (Ext + Proc)) == Ext + Proc1) C.Reg.Line = Line; } void Structcall(int Entry, int Size) { if (Size <= 0) { Size = Mite(-Size - 1); Forget(Breg); } Plantlit(Move, Size, D0); Srcall(Entry); Forget(D0); } void Pushstructure(void) { if (Stsize <= 0) { Structcall(Strtostk, Stsize); Forget(A0); Forget(A1); Forget(A0 + 2); Extendstack(256 - (Stsize & 254)); } else Pushblock(A0, (Stsize + 1) & (~1)); } void Okreg(int Got) { R = Got; if (!(D0b << (Got - D0) & Rset)) { C.Reg.Content = *Pp; if ((Rset & Free) == 0 && (Rset & Tostack) != 0) { Pushstructure(); R = A7; } else { R = Freereg(Rset & (~Bregb)); Plant(Move, Got, R); if (R < A0) { C.Reg.Ccx = *Pp; C.Reg.Ccy = 0; } } } } void Okareg(int Got, int Ok) { R = Got; if (!(A0b << (Got - A0) & Ok)) { R = Freereg(Ok); Plant(Move, Got, R); } } void Loadaddress(int P) { int I; int F; if (Rset & Anyareg & Free) { if ((Dp->Mode & 0b111000) == Indexmode && (Dp->Val & 255) == 0) { I = A0b << (Dp->Mode & 7); if (Rset & Free & I) Rset = I; } R = Freereg(Rset & Anyareg); Plant(Lea, P, R); } else { F = Free; I = Freeareg(P + Ad); Plant(Lea, P, I); Free = F; R = Freereg(Rset & (~Bregb)); Plant(Move, I, R); } } void Commandeer(int Regs) { int R; Freed = ~Free & Regs; if (Freed) { Regs = Freed; R = D0; while (Regs) { if (Regs & 1) { Push(R); Forgetcc(); } Regs = (unsigned)Regs >> 1; R++; } Free = Free | Freed; Rset = Rset & (~Freed); } } void Restore(int Regs) { int R; R = A7; while (Regs) { if (Regs & 0x8000) { Pop(R); Forget(R); Forgetcc(); } Regs = Regs << 1 & 0xFFFF; R--; } } void Partreg(void) { if (R == Breg || R >= A0) Sy = 4; while (Imod(Sy) < Sx) if (Sy > 0) { Plant(Extl - 2 + Sy, 0, R); Sy += Sy; } else { if (Sy == -1) Plantlit(And, 255, R); else Plantlit(And, 0xFFFF, R); Sy = 4; } } Stsize = Stsiz; if (Rset & Tobyte) Rset = Rset & (~Anyareg); P = *Pp; if (P >= Explim) P -= Ad; if (Rset & Asad) { Rset -= Asad; *Pp = P + Ad; } if (P <= 0) Dp = Dint; else Dp = &Dict[P]; Oldfree = Free; Freed = 0; if (Rset != Inst) { if ((Dp->Mode & 0b110000) != 0 || *Pp >= Np0) { J = *Pp; if (Rset & (Anydreg | Bregb)) { I = D0; do { if (C.Reg.Content == J) { J = I; break; } I++; if (I == Maxdreg + 1) I = A0; } while (I <= Maxareg); } else if (Rset & Anyareg) { I = Maxareg; do { if (C.Reg.Content == J) { J = I; break; } I--; if (I == A0 - 1) I = Maxdreg; } while (I >= D0); } else if (J < Explim && Rset != Tostack) { I = A0; do { if (C.Reg.Content == J + Ad) { Free = Free & (~(A0b << (I - A0))); Dp->Flags = Dp->Flags | (Rflag + Wflag); *Pp = I + Indir; return; } I++; } while (I <= Maxareg); } } else { J = Dp->Mode + D0; if (Rset < 0) { *Pp = J; return; } *Pp = C.Reg.Content; } if (0 < J && J <= A7) { Okreg(J); Dp->Flags = Dp->Flags | Rflag; goto Endload; } if (P <= 0) { if (Rset < 0) return; if (Rset == Tostack) { I = Constmode; if (!P) I = Pcmode; Plant(Lea, Temp(I, Litval(P)), A0); Forget(A0); Pushstructure(); return; } if (*Pp < Explim) { if (P < -(255 << 1) || (P & 1) != 0) Rset = Rset & (~Bregb); R = Freereg(Rset); if (R < A0 || P != 0) Plant(Move, P, R); else Plant(Sub, R, R); } else { I = Constmode; if (!P) I = Pcmode; Loadaddress(Temp(I, Litval(P))); } if (R < A0) { C.Reg.Ccx = *Pp; C.Reg.Ccy = 0; } goto Endload; } } if (P >= Np0) { More:; Act = Dp->Act; X = Dp->X; Y = Dp->Y; Xx = X; Yy = Y; if (Act > Opmax) goto Proccall; goto *Do[Do_sw = Act]; } Do_1:; Load:; I = 0; if (Dp->Flags & Indirect) I++; if (Dp->Flags < 0) I += 2; if (*Pp >= Explim) { if (!I) { Free = Oldfree; Loadaddress(P); } else { if (I == 3) { Free = Oldfree; R = Freeareg(Undef); Plant(Move, P, R); P = R + Indir; } if (Rset < 0) { *Pp = P; return; } Free = Oldfree; R = Freereg(Rset); Plant(Move, P, R); } if (R < A0) { C.Reg.Ccx = *Pp; C.Reg.Ccy = 0; } } else { if (I > 0) { Free = Oldfree; R = Maxareg + 1; do { R--; if (R < A0) { R = Freeareg(P + Ad); Plant(Move, P, R); if (I == 3) Plant(Move, R + Indir, R); if (I > 1 && (Control & Assbit) != 0) Checkaddress(R); } } while (C.Reg.Content != P + Ad); Free = Free & (~(A0b << (R - A0))); P = R + Indir; } if (Rset == Ref) { *Pp = P; return; } Sx = (unsigned)Rset >> Sizeshift & 3; if (!Sx) Sx = 4; I = Dp->Flags; Sy = Size(Dp->Type); if (C.Localdpos <= P && P < Dictlim && (I & Okflag) == 0 && C.Forward == 0) { if (!(I & Wflag)) if (!C.Faults) Report(Asserr + Warn, P, 0); if (Dp->Flags >= 0 && Sy > 0) Dp->Flags = Dp->Flags + Okflag; } if (Rset == Tostack) { Free = Oldfree; Plant(Lea, P, A0); Forget(A0); Pushstructure(); return; } if (Sy <= 0) { Intern(5); return; } if (!(Control & (unsigned)Bassbit >> 1 << Sy)) I = I | Okflag; if ((I & Okflag) != 0 && Rset < 0) if (Sy == Sx) { *Pp = P; return; } Free = Oldfree; if (I & Okflag) I = -1; else I = Sy; if (Sy != 4 && ((Dict[Dp->Type].Flags & Nonord) != 0 || Dict[Dp->Type + 1].Val == 0)) Sy = -Sy; if (Sy == -1) { if (Free & Bregb) if (Rset & Bregb) Rset = Bregb; else { Plant(Moveb, P, Breg); Forget(Breg); P = Breg; Sy = 4; } } else Rset = Rset & (~Bregb); if (Sy < 2 || Sx == 1) if (!(Rset & (Anydreg | Bregb))) { R = Freedreg(); Plant(Move + (Imod(Sy) << 8), P, R); Partreg(); P = R; Free = Oldfree; } else Rset = Rset & (~Anyareg); if (Sy == 2 && (Rset & Anyareg & Free) != 0) { Rset = Rset & (~Anydreg); } R = Freereg(Rset); Plant(Move + (Imod(Sy) << 8), P, R); if (R < A0) { C.Reg.Ccx = *Pp; C.Reg.Ccy = 0; } if (Sy != 4) Partreg(); if (I >= 0) { Plant(Cmp + (I << 8), R, D7); Srcall(Unass); Forgetcc(); } if (Sy != 4 && R != Breg) { Forget(R); goto Endload1; } } Endload:; C.Reg.Content = *Pp; Endload1:; Free = Free & (~(D0b << (R - D0))); if (Rset == Ref) R += Indir; *Pp = R; return; Dataload:; Eval(P, Anydreg); Okreg(P); goto Endload; int Freeishareg(int For) { int I; I = M & 7; if ((A0b << I & Oldfree) == 0 || M >= Framemode) return (Freeareg(For)); Free = Free & (~(A0b << I)); I += A0; C.Reg.Content = For; return (I); } void Adeval(int X, int Y, int Q) { int I; int J; if (X <= 0) { M = Constmode; V = Litval(X); } else { Eval(X, Ref); M = Dict[X].Mode; V = Dict[X].Val; if (M == C.Mode && V < 0) { M = Dispmode + 7; V -= C.Sp; } else if ((M & 0b111000) == Aregmode + Indir) M += Dispmode - (Aregmode + Indir); } if (Y) Eval(Y, Anyreg); if ((M & 0b111000) == Indexmode) { if (!Y) { J = Mite(V); I = J + Q; if (Ismite(I) == True) { V = V - J + (I & 255); return; } } I = Freeishareg(X + Ad); Plant(Lea, X, I); M = I + (Dispmode - A0); V = 0; } if (Y) if ((M & 63) == Pcmode) { I = Freeareg(Undef); Plant(Lea, Temp(M, V + Q), I); M = I + (Dispmode - A0); V = 0; Q = 0; } else if (Ismite(V + Q) != True) { if (Ismite(Q) != True) { I = Freeishareg(Undef); if (Isshort(V + Q) == True) Plant(Lea, Temp(M, V + Q), I); else { Plant(Lea, X, I); Addimm(Q, I); } Q = 0; } else { I = Freeishareg(X + Ad); Plant(Lea, X, I); } M = I + (Dispmode - A0); V = 0; } V += Q; if (Y) { M += Indexmode - Dispmode; V = ((Y - D0) << 12) + 0x0800 + (V & 255); } } Do_78:; Dx = &Dict[X]; I = Dx->Type; Tx = &Dict[I]; Getbounds(Tx->Xtype, Sx, Sy); M = Imod(Nsize(*Tx)); if ((Dx->Flags & Arrflag) != 0 && (Y > 0 || Sx == Minint || M == 0)) { Commandeer(D0b + D1b + A0b); Eval(Y, D0b); J = 0; while (!Tx->Mode) { J += 12; I++; Tx = &Dict[I]; } if (Tx->Flags & Indirect) { Plant(Move, I, A0); if (J) Addimm(J, A0); } else { if (Tx->Val == 0 && Tx->Mode == Constmode) { if (Cad & 1) Fillcode(1); Tx->Val = Cad; Setcodelongword(Sy); Setcodelongword(Sx); Setcodelongword(M); } Plant(Lea, I, A0); } Srcall(Index); Forget(D0); Forget(A0); Restore(Freed & (~D0b)); Free = Oldfree & (~D0b); Freed = Freed & D0b; I = X; Eval(I, (Anyareg & Free) + Asad); Plant(Add, D0, I); if (Dp->Flags < 0) Forget(I); else C.Reg.Content = P + Ad; if (!Freed) Free = Free | D0b; Restore(Freed); M = I + (Dispmode - A0); V = 0; goto Setflags; } Index1:; J = 0; if (Y <= 0) { J = Litval(Y); Y = 0; } if (Y >= Np0 && Dict[Y].Act == Add && Dict[Y].Y <= 0) { J = Litval(Dict[Y].Y); Y = Dict[Y].X; } if (M > 1) if (Y) { if ((M & (M - 1)) != 0 && M <= 32767 && Sy <= 32767 && Sx >= -32768) Putexp(Muls, Y, Litref(M), Inttype); else Putexp(Imul, Y, Litref(M), Inttype); Y = Item; } if ((Dx->Flags & (Name + Ext + Arrflag + Indirect)) == Indirect && Sx != 0) { Dx->Val = Dx->Val + 4; Adeval(X, Y, J * M); Dx->Val = Dx->Val - 4; } else { J -= Sx; if (M > 1) J = J * M; Adeval(X, Y, J); } Setflags:; Dx->Flags = Dx->Flags | (Mflag + Wflag + Rflag); Setmode:; if (Dispmode <= M && M < Indexmode) { if (Isshort(V) != True) { Okareg(M + (A0 - Dispmode), Oldfree & Anyareg); Addimm(V, R); Forget(R); M = R - (A0 - Dispmode); V = 0; } if (*Pp >= Explim && V == 0 && Rset != Ref && Dp->Flags >= 0) { Okreg(M + (A0 - Dispmode)); Free = Oldfree; goto Endload; } } Dp->Mode = M; Dp->Val = V; goto Load; Do_45:; Dx = &Dict[X]; Adeval(X, 0, Dict[Y].Val); goto Setflags; Do_47:; V = 0; if (Y >= Explim) { Y -= Ad; Eval(Y, Ref); M = Dict[Y].Mode; V = Dict[Y].Val; } else { if (Y >= Np0) { if (Dict[Y].Act == Add) { M = Dict[Y].Y; if (M <= 0) { Y = Dict[Y].X; V = Litval(M); } } } Eval(Y, Anyareg); if ((Control & Assbit) != 0 && *Pp < Explim) Checkaddress(Y); M = Y + (Dispmode - A0); } goto Setmode; Do_79:; Do_82:; if (X >= Explim) X -= Ad; Dx = &Dict[X]; if (Y <= 0) Adeval(X, 0, Litval(Y)); else { Eval(Y, Anydreg); Adeval(X, Y, 0); } goto Setflags; Do_115:; Commandeer(C.Free); Plant(Move, Y, D0); Srcall(Act); Forgetregs(); C.Reg.Line = Line; goto Endmap; Do_107:; Proccall:; Dx = &Dict[Act]; if (P < Np) goto Rcall; if (!(Dx->Flags & Writable)) goto Funcall; Commandeer(C.Free); Call(); Endmap:; Free = Oldfree; R = A0; if (Rset != Ref) Okareg(A0, ~Freed & Anyareg); Restore(Freed); Free = Free & (~(A0b << (R - A0))); C.Reg.Content = P + Ad; M = R + (Dispmode - A0); V = 0; goto Setmode; Funcall:; Commandeer(C.Free); Call(); R = (*Typecell(Dx->Type)(Dx->Type).Reg & 15) + D0; if (Dx->Flags & Okflag) { C.Reg.Ccx = *Pp; C.Reg.Ccy = 0; } Endloadr:; Free = Oldfree; if (Rset != Ref) Okreg(R); Restore(Freed); goto Endload; Rcall:; if (Pendcond) Flush(); Updatesp(); while (Act == Dprintstr && X >= Np0 && Dict[X].Act == Concat) { Dp->X = Dict[X].X; Call(); Free = C.Free; X = Dict[X].Y; Dp->X = X; } Call(); if (Dx->Flags & Noret) C.Access = 0; if (*Pp + 1 == Np && Curlab == C.Lab1 && Dict[Curlab].Val >= 0 && Dict[Curlab + 1].Val >= 0) Forgettriples(); return; void Evalxy(void) { Rset = Rset & (~Bregb); Commandeer(D0b + D1b); if (999 > Weight(X) && Weight(X) < Weight(Y)) { Eval(Y, D1b); Eval(X, D0b); } else { Eval(X, D0b); Eval(Y, D1b); } } void Stackop(int S) { Stsiz = S; Sp = C.Sp; Eval(X, Tostack); Free = Free | A0b; Eval(Y, A0b + Asad); Plant(Move, A7, A1); Structcall(Act, S); Forget(A0); Forget(A1); Forget(A0 + 2); } Do_46:; Dx = &Dict[X]; M = Imod(Size(Dx->Type)); Sx = 0; Sy = 999999; goto Index1; Do_111:; Commandeer(D0b); Eval(Y, D0b); Srcall(X); R = D0; goto Endloadr; Do_2:; if (Control & Overbit) { if (!(Rset & (~Anyareg))) goto Dataload; Rset = Rset & (~Anyareg); } if (!(Rset & (~Bregb))) goto Dataload; Rset = Rset & (~Bregb); if (Y < 0) { if (Y >= Litquick) { if (Y & 1) { Y--; Act = Sub; } Eval(X, Rset & Free); goto Fin1; } if (Y == -(128 << 1)) { Act = Sub; Y++; goto Op2; } } goto Op1; Do_7:; if (!(Rset & (~Bregb))) goto Dataload; Rset = Rset & (~Bregb); Do_6:; Do_5:; if (!(Rset & (~Anyareg))) goto Dataload; Rset = Rset & (~Anyareg); Op1:; Wx = Weight(X); if (Wx <= 1 && Y <= 0 && Y >= Litmite && (Rset & (~Anyareg)) != 0) { Rset = Rset & (~Anyareg); I = X; X = Y; Y = I; } else if (999 > Wx && Wx < Weight(Y)) { I = X; X = Y; Y = I; } goto Op2; Do_3:; if (Control & Overbit) { if (!(Rset & (~Anyareg))) goto Dataload; Rset = Rset & (~Anyareg); } Rset = Rset & (~Bregb); Op2:; Eval(X, Rset & Free); Op3:; Oldfree = Free; if (Y <= 0 && Y >= Litmite && (Free & (Anydreg | Bregb)) != 0) { Eval(Y, Anydreg | Bregb); } else if (Act == Eor && Y > 0) Eval(Y, Anydreg); else if (Act > Sub) if (X == Breg && Y > 0) { Sy = Tsize(Y); if (Sy == 1 || (Sy == 2 && Act == And)) { Eval(Y, (Val & (~Anyareg)) + (Sy << Sizeshift)); if (Y > D7) Act += Sy << 8; } else Eval(Y, Val & (~Anyareg)); } else Eval(Y, Val & (~Anyareg)); else Eval(Y, Val); Free = Oldfree; Fin1:; Plant(Act, Y, X); if (Act > Sub) goto Fin3; Fin2:; if (Control & Overbit) Plant(Trapv, 0, 0); Fin3:; *Pp = X; C.Reg.Content = P; if (Act <= Opmax) { C.Reg.Ccx = P; C.Reg.Ccy = 0; } else Forgetcc(); return; Do_12: Do_14:; if (!(Rset & (~(Anyareg | Bregb)))) goto Dataload; Rset = Rset & (~(Anyareg | Bregb)); Eval(X, Rset & Free); Oldfree = Free; if (Y > 0) Eval(Y, Anydreg); Free = Oldfree; Plant(Act, Y, X); goto Fin2; Do_10: Do_11:; if (!(Rset & (~(Anyareg | Bregb)))) goto Dataload; Rset = Rset & (~(Anyareg | Bregb)); Eval(X, Rset & Free); if (Y < 0 && Y >= Litquick) { if (Y & 1) { Act = Act ^ (Lsl ^ Lsr); Y--; } } else { Oldfree = Free; Eval(Y, Anydreg); Free = Oldfree; } goto Fin1; Do_9:; if (Y) { R = Y; Y = X; X = R; Act = Sub; goto *Do[Do_sw = Sub]; } Do_8:; if (!(Rset & (~(Anyareg | Bregb)))) goto Dataload; Rset = Rset & (~(Anyareg | Bregb)); Eval(X, Rset & Free); Plant(Act, 0, X); goto Fin3; Do_48:; if (!(Rset & (~(Anyareg | Bregb)))) goto Dataload; Rset = Rset & (~(Anyareg | Bregb)); X = Y; Eval(X, Rset & Free); if (C.Reg.Ccx != Y || C.Reg.Ccy != 0) Plant(Move, X, X); Plantlit2(Bge, 0, 2); Plant(Neg, 0, X); goto Fin2; Do_49:; if (!(Rset & (~(Anyareg | Bregb)))) goto Dataload; Rset = Rset & (~(Anyareg | Bregb)); X = Y; Eval(X, Rset & Free); Plantlit(And, 0x7FFFFFFF, X); goto Fin3; void Doshift(void) { int I; I = 0; do { I++; J = (unsigned)J >> 1; } while (!(J & 1)); if (I == 1) Plant(Add, X, X); else { I = Litref(I); if (I < Litquick) { Oldfree = Free; Eval(I, Anydreg); Free = Oldfree; } Plant(Asl, I, X); } } Do_86:; if (!(Rset & (~(Anyareg | Bregb)))) goto Dataload; Rset = Rset & (~(Anyareg | Bregb)); if (Y < 0) { J = Litval(Y); I = J & (J - 1); if (I == 0 || (I & (I - 1)) == 0) { Eval(X, Rset & Free); if (!(J & 1)) Doshift(); if (J != 1) { Plant(Move, X, Prea7); Doshift(); Plant(Add, Posta7, X); } goto Fin2; } } Do_91: Do_93:; Do_88: Do_94:; Do_90: Do_92:; Evalxy(); Srcall(Act); if (Act == Imul && (Control & Overbit) != 0) Plant(Trapv, 0, 0); Forget(D1); R = D0; Forgetcc(); goto Endloadr; Do_87: Do_98:; if (Control & Halfbit) { if (Act == Idiv) Act = Divs; Do_13: Do_15:; if (!(Rset & (~(Anyareg | Bregb)))) goto Dataload; Rset = Rset & (~(Anyareg | Bregb)); Eval(X, Rset & Free); Oldfree = Free; Eval(Y, Anydreg); Free = Oldfree; if (Act == Drem) { Plant(Divs, Y, X); Plant(Swap, 0, X); } else Plant(Act, Y, X); Plant(Extl, 0, X); goto Fin3; } Evalxy(); Srcall(Idiv); Putexp(Act ^ (Idiv ^ Drem), Xx, Yy, Inttype); if (Act == Idiv) { C.Reg.Content = Item; R = D0; } else { C.Reg.Content = Item; R = D1; } Forgetcc(); goto Endloadr; Do_95:; Do_89:; Commandeer(D0b); Eval(X, D0b); Srcall(Act); Forgetcc(); R = D0; goto Endloadr; Do_106:; if ((Free & (A0b + A1b + A2b + D0b + Bregb)) != A0b + A1b + A2b + D0b + Bregb) Fault(Plexerr); Stackop(-256); Endconc:; if (!(Rset & Tostack)) { if (C.Sp != Sp) { Addimm(Sp - C.Sp, A7); C.Sp = Sp; } } else Rset = A0b; R = A0; goto Endloadr; void Condswop(void) { int Temp; Temp = X; X = Y; Y = Temp; Temp = Xx; Xx = Yy; Yy = Temp; Temp = Sx; Sx = Sy; Sy = Temp; Temp = Wx; Wx = Wy; Wy = Temp; if (Case & 8) Case = Case ^ 3; } void Unsigned(void) { if (Case & 8) { Case = Case ^ 8; if (Case & 2) Case = Case ^ 4; } } Do_4:; if (Pendcond) Flush(); Updatesp(); Sp = C.Sp; *Pp = *Pp + 1; Dp = &Dict[*Pp]; Case = Dp->Act; if (X <= 0) { if (!X) Case = Case ^ 1; Pendcond = (Case & 1) + Bra; goto Endcomp; } if (X >= Explim) { Dx = &Dict[X - Ad]; Sx = 4; } else { Dx = &Dict[X]; Tx = &Dict[Dx->Type]; Sx = Size(Dx->Type); } Dx->Flags = Dx->Flags | Rflag; if (Y >= Explim || Y <= 0) Sy = 4; else Sy = Tsize(Y); if (C.Reg.Ccx == Y && C.Reg.Ccy == X) { Wx = 0; Wy = 0; Condswop(); } if (C.Reg.Ccx != X || C.Reg.Ccy != Y) if (Y) { Wx = Weight(X); Wy = Weight(Y); if (Wx < 999 && Wy > Wx + 1) Condswop(); if (X >= Explim || Y >= Explim) { if (0 <= Y - Ad && Y - Ad < Dictlim && Dict[Y - Ad].Flags >= 0) Condswop(); Eval(X, Anyareg); Eval(Y, Sign + Anyareg); Plant(Cmp, Y, X); C.Reg.Ccx = Xx; C.Reg.Ccy = Yy; } else if (Sx > 0) if ((Tx->Flags & Cat) == Realy) { Eval(X, D0b); Eval(Y, D1b); Srcall(Fsub); Forget(X); C.Reg.Ccx = Xx; C.Reg.Ccy = Yy; } else if (Y < 0) { if (Y >= Litmite) { Eval(X, Val + (Sx << Sizeshift)); if ((Sx == 4 && (Free & Anydreg) != 0) || (X > A7 && (Dict[X].Mode & 63) == Pcmode)) { Eval(Y, Anydreg); if (X > D7) { Condswop(); Sx = Sy; } } } else { if (Sx == 1) Sx = 0; Eval(X, Val + (Sx << Sizeshift)); if (A0 <= X && X <= A7 && Isshort(Litval(Y)) == True) Sx = 2; } Plant(Cmp + (Sx << 8), Y, X); if (Sx == 1) Unsigned(); C.Reg.Ccx = Xx; C.Reg.Ccy = Yy; } else { if (Sy < Sx) Condswop(); Eval(X, Anyreg); if (Sy <= 2 && Sy == Sx && (Sy == 1 || X < A0)) { Eval(Y, Val + (Sy << Sizeshift)); Plant(Cmp + (Sy << 8), Y, X); if (Sy == 1) Unsigned(); Forgetcc(); } else { Eval(Y, Val); Plant(Cmp, Y, X); C.Reg.Ccx = Xx; C.Reg.Ccy = Yy; } } else { Stsiz = Sx; if ((Tx->Flags & Cat) != Stringy) Stsiz = -Stsiz; if (((Case & 8) == 0 && (Control & Strassbit) == 0) || Stringy != (Tx->Flags & Cat) && (Tx->Flags & Cat) != Sety) { if (Wy >= 999) { Eval(X, Tostack); Free = Free | A0b; Eval(Y, (Anyareg & Free) + Asad); X = Freeareg(Undef); Plant(Move, A7, X); } else { Eval(X, (Anyareg & Free) + Asad); Forget(X); Eval(Y, (Anyareg & Free) + Asad); } I = Freedreg(); if ((Tx->Flags & Cat) == Stringy) { Plant(Clr, 0, I); Plant(Moveb, X + Indir, I); } else Plantlit(Move, -Sx - 1, I); Plant(Cmpmb, X + Post, Y + Post); Plantlit2(Dbne, I, -4); Forget(I); Forget(Y); } else { if (Wx >= 999) { Eval(X, Tostack); Free = Free | A0b; if (Wy >= 999) { Stsiz = Sy; if ((Tx->Flags & Cat) != Stringy) Stsiz = -Stsiz; Eval(Y, Tostack); Y = A1; Plant(Move, A7, Y); Sy = (Imod(Sy) + 1) & (~1); if (!Sy) Sy = 256; X = A0; Plant(Lea, Tempd(A7, Sy), X); } else { Eval(Y, A1b + Asad); X = A0; Plant(Move, A7, X); } } else { Eval(X, A0b + Asad); Eval(Y, A1b + Asad); } Srcall(Scomp); Unsigned(); } Forgetcc(); } } else if (Sx <= 0 || (Sx == 1 && Dx->Mode >= Dispmode)) if ((Tx->Flags & Cat) == Stringy || Sx == 1) { Eval(X, Ref); Plant(Tst + (1 << 8), 0, X); Forgetcc(); Unsigned(); } else { Eval(X, (Anyareg & Free) + Asad); I = Freedreg(); Plantlit(Move, -Sx - 1, I); Plant(Tst + (1 << 8), 0, X + Post); Plantlit2(Dbne, I, -4); Forget(I); Forget(X); } else { Eval(X, Anydreg); if (C.Reg.Ccx != Xx || C.Reg.Ccy != 0) { Plant(Move, X, X); C.Reg.Ccx = Xx; C.Reg.Ccy = 0; } } Pendcond = Case; Endcomp:; Pendin = Dp->X; Pendout = Dp->Y; Checksp:; if (C.Sp != Sp) { Addimm(Sp - C.Sp, A7); C.Sp = Sp; } return; Do_117:; if (Pendcond) Flush(); Updatesp(); Sp = C.Sp; Dx = &Dict[Act]; Call(); *Pp = *Pp + 2; Dp = &Dict[*Pp]; Pendcond = Dp->Act; goto Endcomp; int Easy(int Y) { int R1; int F; Identinfo *Dy; static int S = 0; if (Y < Np0) return (False); Dy = &Dict[Y]; if (Dy->Act > Concat || Dy->Act == Prel) return (False); F = Free; if (Dy->X == X) { S = Tsize(X); if (Dy->Act != Concat) S = -S; Eval(X, A1b + Asad); } else if (Dy->Y >= Np0 || Dy->Y == X || Easy(Dy->X) != True) return (False); Y = Dy->Y; if (Y >= Np0 && Dict[Y].Act == Dtostring) { Y = Dict[Y].X; Eval(Y, Tobyte + Val); R1 = Cleanreg(); Plant(Addb, One, X + Indir); Plant(Moveb, X + Indir, R1); Plant(Moveb, Y, Tempx(X, R1)); Forget(R1); } else { Eval(Y, A0b + Asad); Structcall(Dy->Act, S); Forget(A0); Forget(A1); Forget(D1); Forget(D2); } Free = F & (~A1b); return (True); } void Beware(int Dest) { int R; int D; int Unsafe(int P) { for (;;) { if (P <= Undef) return (False); if (P == Dest || P == D) return (True); if (P >= Explim) P -= Ad; if (P < Np0) return (False); if (Dict[P].Act > Opmax) return (True); if (Dest == Dict[P].Y || Dict[P].Y >= Np0) return (True); P = Dict[P].X; } } if (Dest <= A7) { Forget(Dest); return; } D = Dest; if (D >= Explim) D -= Ad; for (R = D0; R <= Maxareg; R++) if (Unsafe(C.Reg.Content) == True) Forget(R); if (Unsafe(C.Reg.Ccx) == True || Unsafe(C.Reg.Ccy) == True) Forgetcc(); } int Xfree(int V, int Strong) { Identinfo *Dp; for (;;) { if (V >= Explim) V -= Ad; if (V < Dictlim) break; Dp = &Dict[V]; if (Xfree(Dp->Y, 1) != True) return (False); if (Dp->Y >= Dictlim) Strong = 1; V = Dp->X; } if (V != X || Strong == 0) return (True); return (False); } Do_36:; Eval(Y, D0b); *Pp = *Pp + 1; Dp = &Dict[*Pp]; I = Dp->X; Eval(I, D1b); I = Dp->Y; Eval(I, D2b); Srcall(Forok); Do_32:; Do_34:; Do_33:; if (Pendcond) Flush(); if (Xx >= Explim) { Wx = Weight(Xx - Ad); Dx = &Dict[Xx - Ad]; Sx = 4; } else { Wx = Weight(Xx); Dx = &Dict[Xx]; Sx = Size(Dx->Type); } Tx = &Dict[Dx->Type]; Sp = C.Sp - C.Val; if (Sx <= 0) { Updatesp(); if ((Tx->Flags & Cat) == Stringy) { if (!Sx) Sx = -256; Op = -1; if (Y >= Np0) Op = Dict[Y].Act; if (!Y) { Eval(X, Ref); Plant(Clr + (1 << 8), 0, X); } else if (Op == Dtostring) { Y = Dict[Y].X; Eval(Y, Tobyte + Val); Eval(X, (Anyareg & Free) + Asad); Plant(Moveb, One, X + Post); Plant(Moveb, Y, X + Indir); Forget(X); Forgetcc(); } else if (Act == Jamass || Easy(Y) != True) { if (Op >= Concat && Wx > 1) { Stsiz = Sx; Eval(Y, Tostack); Free = Free | A0b; Eval(X, A1b + Asad); Plant(Move, A7, A0); Y = A0; Structcall(Strcopy, Sx); } else if (Act != Assign || Sx == -256 || (Control & Capbit) == 0) { if (Wx > 1) { Eval(X, (Anyareg & Free) + Asad); Eval(Y, (Anyareg & Free) + Asad); } else { Eval(Y, (Anyareg & Free) + Asad); Eval(X, (Anyareg & Free) + Asad); } I = Freereg(Anydreg | Bregb); if (Act == Jamass) { Plantlit(Move, Mite(-Sx - 1), I); Plant(Moveb, I, X + Post); Plant(Cmpb, Y + Post, I); Plantlit2(Bcs, 0, 6); Plant(Sub, One, X); Plant(Moveb, Y + Pre, I); } else { Plant(Moveb, Y + Indir, I); } Plant(Moveb, Y + Post, X + Post); Plant(Subb, One, I); Plantlit2(Bcc, 0, -6); Forget(I); } else { if (Wx > 1) { Eval(X, A1b + Asad); Eval(Y, A0b + Asad); } else { Eval(Y, A0b + Asad); Eval(X, A1b + Asad); } Structcall(Strcopy, Sx); } Forget(X); Forget(Y); Forgetcc(); } } else if (Easy(Y) != True) { if (Y == 0 || Wx > 1) Eval(X, (Anyareg & Free) + Asad); if (Y) { if (!Sx) Sx = Tsize(Y); Eval(Y, (Anyareg & Free) + Asad); Forget(Y); Y += Post; if (Wx <= 1) Eval(X, (Anyareg & Free) + Asad); } Forget(X); if (!Sx) Fault(Sizerr); else Moveblock(Y, X + Post, -Sx); } Beware(Xx); goto Checksp; } if (C.Val) { if (Dx->Val == Sp && Dx->Mode == C.Mode) if (Sx == 4 || X >= Explim) C.Val = C.Val - 4; else C.Val = C.Val - 2; Updatesp(); } Op = Move; Case = Val; if (Sx != 4) Case += Sx << Sizeshift; if (X <= A7) if (Xfree(Y, 0) == True) { Case = 1 << (X - D0); Free = Free | Case; } else Free = Free & (~(1 << (X - D0))); if (Sx != 4 && Act == Assign && (Control & Capbit) != 0) { Eval(Y, D0b); Srcall(Dx->Type); } I = Y; if (I >= Explim) I -= Ad; if (I >= Np0) { if ((Dx->Flags & Okflag) != 0 || (Control & (unsigned)Bassbit >> 1 << Sx) == 0) { Dy = &Dict[I]; if (Y >= Explim) { if (Dy->Act == Prel && Dy->X == X - Ad && (Dy->Y < 0 || Dy->Type == Bytetype)) { Y = Dy->Y; if (Dy->Type != Bytetype) Y = Litref(Litval(Y) * Imod(Size(Dy->Type))); Act = Add; goto Tostore; } } else if (Dy->X == X && (Dy->Act < Neg || (Dy->Act == Neg && Dy->Y == 0))) { Act = Dy->Act; Y = Dy->Y; goto Tostore; } } if (Wx < 999) { Eval(Y, Case); Eval(X, Ref); } else { Eval(X, Ref); Eval(Y, Case); } } else { Eval(X, Ref); if (Y <= 0) if (Y == 0 && (Dx->Flags & Readable) != 0) Op = Clr; else if (Y >= Litmite && Sx == 4) Eval(Y, Anydreg); else if (Y > A7) Eval(Y, Case); } if (Y != X) { if (0 < Y && Y <= Maxareg && 0 < Yy && Yy == C.Reg.Content) { Beware(Xx); C.Reg.Content = Xx; } else Beware(Xx); Plant(Op + ((Sx & 3) << 8), Y, X); C.Reg.Ccx = Xx; C.Reg.Ccy = 0; } else Beware(Xx); Endass:; if (C.Localdpos <= Xx && Xx < Dictlim && C.Forward == 0) Dx->Flags = Dx->Flags | Okflag; return; Do_35:; if (Pendcond) Flush(); Dx = &Dict[Xx]; Sx = Size(Dx->Type); Wx = Weight(X); Act = Add; Tostore:; if (!Y) Eval(X, Ref); else if (Y < 0) { if (Act == Add) { if (Y >= Litquick) { if (Y & 1) { Act = Sub; Y--; } Eval(X, Ref); goto Past; } if (Y == -(128 << 1)) { Act = Sub; Y++; } } Eval(X, Ref); if (Y >= Litmite && (Anydreg & Free) != 0) Eval(Y, Anydreg); } else if (X <= A7) Eval(Y, Val); else if (999 > Wx && Wx < Weight(Y)) { Eval(Y, Anydreg); Eval(X, Ref); } else { Eval(X, Ref); Eval(Y, Anydreg); } Past:; Plant(Act + (Sx << 8), Y, X); if ((Control & Overbit) != 0 && Act <= Sub) Plant(Trapv, 0, 0); Beware(Xx); C.Reg.Ccx = Xx; C.Reg.Ccy = 0; goto Endass; Do_38:; Updatesp(); if (C.Type) { R = *Typecell(C.Dpid)(C.Dpid).Reg & 15; if (C.Type > 0 && Size(C.Type) > 0) { if (Pendcond != 0 && Pendin != 0) Flush(); I = Y; if (C.Reg.Content != Y) { if (Pendcond) Flush(); Eval(Y, D0b << R); } if (C.Reg.Ccx != I || C.Reg.Ccy != 0) C.Status = C.Status | Wrongcc; } else { C.Status = C.Status | Wrongcc; if (Pendcond) Flush(); if (C.Type > 0) Y += Ad; Sp = C.Sp; Eval(Y, D0b << R); if (C.Sp != Sp) { Addimm(Sp - C.Sp, A7); C.Sp = Sp; } } } if (C.Temps) { if (Pendcond) Flush(); Addimm(C.Temps, A7); } Dict[Dictlim].Val = C.Return; Compileuncondbranch(Dictlim); C.Return = -(Pc - 1); return; Do_41:; Updatesp(); if (Pendcond > 0 && Pendin != 0) Flush(); if (Y != X) Savecontext(Y); Compileuncondbranch(Y); return; Do_39:; Updatesp(); Compileuncondbranch(X); if (Dict[X + 1].Val < 0) Definelabel(X + 1); if (Y < 0) { C.Val = Y; C.Temps = C.Temps + Y; Updatesp(); } return; Do_40:; if (C.Access != 0 && C.Access != -2) { Savecontext(Y); Compileuncondbranch(Y); } if (X != 0 && Dict[X].Val < 0) Definelabel(X); return; Do_16:; Updatesp(); if (!Dict[Y].Val) C.Forward = C.Forward + 1; if (C.Temps) Addimm(C.Temps, A7); I = Pendcond; Compileuncondbranch(Y); if (I != 0 && C.Temps != 0) Addimm(-C.Temps, A7); return; Do_44:; Updatesp(); Definelabel(X); return; Do_37:; Updatesp(); if (Pendcond) Flush(); Plant(Clr, 0, D0); Srcall(Signal); C.Access = 0; return; Do_73:; Updatesp(); if (Pendcond) Flush(); Sp = C.Sp; *Pp = *Pp + 1; Dp = &Dict[*Pp]; Xx = Dp->X; Yy = Dp->Y; X = Litval(X); if (Yy != Undef) { Eval(Yy, A0b + Asad); X += 64; } if (Xx != Undef) { Eval(Xx, D2b); X += 32; } if (Y != Undef) { Eval(Y, D1b); X += 16; } X = Litref(X); Eval(X, D0b); if (Control & Sysbit) Plant(Jmp, 0, Signal); else Plant(Jsr, 0, Signal); if (C.Sp != Sp) { Addimm(Sp - C.Sp, A7); C.Sp = Sp; } C.Access = 0; return; Do_42:; Updatesp(); Push(D0 + 6); Push(Mb); Plant(Pea, 0, Temp(Pcmode, 10)); C.Sp = C.Sp - 4; Push(Gb + Indir); Plant(Move, A7, Gb + Indir); C.Eventsp = C.Sp; C.Forward = C.Forward + 1; Lreg[C.Lab1 - Dictlim] = C.Reg; Plant(Bra, 0, C.Lab1); Pflag[Pc - 1] = Longjump; Forgetregs(); Plant(Dc, 0, Temp(Absmode, Litval(Y))); return; Do_43:; if (Pendcond) Flush(); Updatesp(); Dx = &Dict[X]; Dx->Flags = Dx->Flags | Rflag; I = Dx->Val; Dy = Typecell(Dx->Type); Getbounds(Dy->Xtype, Sx, Sy); if (Y <= 0) { Y = Litval(Y); I = I + Y - Sx; if (C.Temps) Addimm(C.Temps, A7); Plant(Bra, 0, Temp(Labmode, Prog[I])); Prog[I] = Dtemp->Val; } else { Eval(Y, D0b); if (I > Pc) { C.Forward = C.Forward + (Sy - Sx + 1); if (!(Dx->Flags & Arrflag)) { if (C.Temps) Addimm(C.Temps, A7); Plant(Lea, Temp(Pcmode, 10 - Sx - Sx), A0); Plant(Add, D0, D0); } else { Wx = 12; if (C.Temps) { Wx += 2; if (C.Temps > 8) Wx += 2; } Plant(Lea, Temp(Pcmode, Wx), A0); Srcall(Index); if (C.Temps) Addimm(C.Temps, A7); } Plant(Add + (2 << 8), Tempx(A0, D0), A0); Plant(Jmp, 0, A0 + Indir); if (Dx->Flags & Arrflag) { Store((unsigned)Sy >> 16, 0); Store(Sy, 0); Store((unsigned)Sx >> 16, 0); Store(Sx, 0); Store(0, 0); Store(2, 0); } Dx->Val = Pc; do { Store(Prog[I], 0); if (I == Swpc) Swpc++; I++; Sx++; } while (Sx <= Sy); } else { if (Dx->Flags & Arrflag) I -= 7; Plant(Bra, 0, Temp(Labmode, I - 6)); } } C.Access = 0; return; Do_105:; if (Y) { Updatesp(); Eval(Y, D0b); } else Srcall(Asize); *Pp = *Pp + 1; Dp = &Dict[*Pp]; Xx = Dp->X; Yy = Dp->Y; Free = C.Free - D0b; Eval(Xx, D1b); Eval(Yy, D2b); Push(D0); Push(D1); Push(D2); Forgetregs(); Free = Free | (D1b + D2b); Dict[X].Val = C.Sp; return; Do_103:; Updatesp(); if (X) if (X != D0) Eval(X, D0b); else Srcall(Asize); if (Y) Push(Y); Push(D0); return; Do_109:; Plant(Move, X, D0); Srcall(Aget); Plant(Move, A7, X); if (Y) { Dx = &Dict[X]; Dx->Val = Dx->Val + 4; Plant(Move, A7, D0); Plant(Add, D0, X); Dx->Val = Dx->Val - 4; } Forget(D0); Forget(A0); return; void Compileentry(int Linked, int Arg) { int I; int R; int Vsp; int Lastvsp; int Holdsp; Identinfo *Darg; Identinfo *Tp; Holdsp = C.Sp; C.Sp = 0; Lastvsp = 0; if (Linked > 0) C.Stack = C.Stack - 4; if (Linked == 0 && (C.Status & Onstack) != 0) { C.Sp = 4; Holdsp -= 4; C.Stack = C.Stack - 4; } C.Stack = C.Stack - 4; if (C.Stack < C.Totstack) C.Totstack = C.Stack; if ((Control & Stackbit) != 0 && ((C.Status & Unknown) != 0 || C.Totstack < -128)) { Plantlit(Move, C.Stack, Breg); Srcall(Stackok); } if (Level > Outerlevel && Linked > 0) if (Level > 1) { Plant(Move, Tempd(Gb, Level << 2), Prea7); Plant(Move, A7, Tempd(Gb, Level << 2)); } else { Plant(Link, 0, F1); } Darg = &Dict[Arg]; for (;;) { Arg = Darg->Link; if (!Arg) break; Darg = &Dict[Arg]; if (Darg->Val <= 0) { Vsp = Darg->Val; R = (Darg->Reg & 15) + D0; if ((Darg->Flags & Mflag) != 0 || Linked > 0) { Addimm(Lastvsp - C.Sp, A7); C.Sp = Lastvsp; I = Nsize(*Darg); if (I > 0) Plant(Move + (I << 8), R, Prea7); else if (Darg->Flags & Proc) { Plant(Move, R, Prea7); Plantlit(Movew, 0x4EF9, Prea7); } else { Tp = Typecell(Darg->Type); if ((Tp->Flags & Cat) == Stringy) { if ((Control & Capbit) != 0 && Tp->Size() > -256) { Plantlit(Cmp + (1 << 8), -Tp->Size(), R + Indir); Plantlit2(Bcs, 0, 4); Srcall(Check); } I = C.Sp - Vsp; Addimm(-I, A7); Extendstack(I); Plant(Moveb, R + Indir, Breg); Plant(Moveb, Tempx(R, Breg), Tempx2(A7, Breg)); Plant(Subb, One, Breg); Plantlit2(Bcc, 0, -10); } else { Free = Bregb; Pushblock(R, C.Sp - Vsp); } } C.Sp = Vsp; } Lastvsp = Vsp; } } if (C.Sp) { Addimm(Lastvsp - C.Sp, A7); C.Sp = Holdsp; } else C.Sp = Holdsp - Lastvsp; } Do_50:; Compileentry(C.Status & Globbed, C.Dpid); return; Do_default: Intern(8); Do_0:; } void Compile(int Startp) { int P; if ((Control & Explist) != 0 && (Control & List) != 0) Showexp(Startp); if (Faultnum > 0) { Np = Np0; return; } Pendcond = 0; P = Startp - 1; for (;;) { Free = C.Free; P++; if (P >= Np) { if (Startp == Np0) { Np = Np0; if (Pendcond > 0) Flush(); return; } Np = Startp; Startp = Np0; P = Startp; } if (C.Reg.Line != Line && (Control & (Tracebit | Diagbit | Linebit)) != 0) { if (Pendcond > 0) Flush(); Pendcond = -1; } Eval(P, Inst); } } void Setfirstentry(void) { int J; int K; int P; Identinfo *Dp; Firstpos = Dictlim; Firstentry = Finalbound; P = 0; for (;;) { P++; if (P >= Dlim) break; Dp = &Dict[P]; if (Dp->Mode != Procmode) continue; if (Dp->Val >= Firstentry) continue; J = Dp->Val; if (J <= 0) { if (!J) continue; K = -J; do { J = K << 1; K = Codeword(J) & 0xFFFF; } while (K); if (J >= Firstentry) continue; } Firstentry = J; Firstpos = P; } } void Defineentry(int Chain, int Entry, int Pid) { int J; do { Chain = Chain << 1; if (Isshort(Entry - Chain) != True) Report(Reacherr, Pid, 0); J = Codeword(Chain) & 0xFFFF; Shortinteger = Entry - Chain; Chain = J; } while (Chain); } void Checkreach(int Blocksize) { int I; for (;;) { I = Blocksize + Cad; if (I >= Ownbase) Croak(_imp_str_literal("Program too big")); if (I - Firstentry < 31000) return; if (Blocksize >= 32000 || Cad - Firstentry >= 32760) return; if (Dict[Firstpos].Val < 0) { Defineentry(-Dict[Firstpos].Val, Cad, Firstpos); Setcodeword(0x6000); Dict[Firstpos].Val = (unsigned)-Cad >> 1; Setcodeword(0); } else { Dict[Firstpos].Val = Cad; Setcodeword(0x6000); Setcodeword(Firstentry - Cad); } Steps += 2; Setfirstentry(); } } void Putword(int V) { Printsymbol((unsigned)V >> 8 & 255); Printsymbol(V & 255); } void Doexternals(int Chain, int Specs) { int K; int A; int B; Identinfo *Dp; Identinfo *Tp; *Byteinteger(Charlim) = 0; Value = 2; do { Dp = &Dict[Chain]; A = Dp->Text + Char0; B = *Byteinteger(A); if (*Byteinteger(A + B + 1) & 128) { A = A + B + 1; B = *Byteinteger(A) - 128; } Value += (B + 14) & (~1); if (Specs >= 0) { Putword(Dp->Flags & (Ext + Proc) | Sign16); Putword(Dp->Mode); K = 0; if (Dp->Flags & Proc) { Tp = &Dict[Dp->Type]; K = 4; if (Tp->Type) K = 6; for (;;) { if (Tp->Reg & 8) K++; if (Tp->Link <= 0) break; Tp = &Dict[Tp->Link]; K = K << 1; } if (K == 9 && Tp->Type == Stringtype && Tp->Flags >= 0) K += 2; } Putword((unsigned)K >> 16); Putword(K); Putword((unsigned)Dp->Val >> 16); Putword(Dp->Val); Putword((B << 8) + *Byteinteger(A + 1)); for (;;) { A += 2; B -= 2; if (B < 0) break; K = *Byteinteger(A) << 8; if (B > 0) K += *Byteinteger(A + 1); Putword(K); } } Chain = Dp->Link; } while (Chain); if (Specs >= 0) { Putword(0); if (Value & 3) Putword(0); } Value = (Value + 3) & (~3); } void Putact(int Act, int X, int Y) { Dict[Np].Act = Act; Dict[Np].X = X; Dict[Np].Y = Y; Np++; } void Compileend(void) { int I; int J; int X; int Y; int Entry; int Lim; if (C.Reg.Line != Line && (Control & (Diagbit | Linebit | Tracebit)) != 0 && Level > Outerlevel && C.Access != 0) { Pendcond = -1; Flush(); } if (C.Eventsp) { Plant(Move, Temp(C.Mode, C.Eventsp), Gb + Indir); Forgetcc(); } Codeflag = '^'; X = Pc; Putact(End, 0, 0); Compile(Np0); if (Cad & 1) Fillcode(1); Checkreach((Pc - C.Localpc) << 1); Entry = Cad; Y = X; while (Y < Pc) { if (Pflag[Y] == Indglobal) Setcodeword(Dict[Prog[Y]].Val - Cad); else Setcodeword(Prog[Y]); Y++; } Codeflag = ' '; Pc = X; if (C.Access) { if (Level > Outerlevel && (C.Status & Globbed) != 0) if (Level > 1) { Plant(Move, Tempd(Gb, Level << 2), A7); Plant(Move, Posta7, Tempd(Gb, Level << 2)); Forgetcc(); } else Plant(Unlk, 0, F1); else if (C.Sp < 0) Addimm(-C.Sp, A7); if (Level > Outerlevel) { if (C.Type > 0 && (C.Status & Wrongcc | C.Reg.Ccx | C.Reg.Ccy) == 0) C.Dpid = C.Dpid | Okflag; Plant(Rts, 0, 0); } else { Plant(Move, 0, D0); Srcall(Signal); } } else C.Dpid = C.Dpid | Noret; X = C.Dpid; if (X < 0) Defineentry(-X, Entry, C.Pid); C.Dpid = Entry; Lim = Cad + ((Pc - C.Localpc - C.Shorts + Zeroshorts) << 1); X = C.Localpc; C.Shorts = Zeroshorts; while (X < Pc) { Y = Prog[X]; J = Pflag[X]; if (J) if (J < Zeroshorts) if (J <= Longjump) { Jumps++; Y = (Y - Pflag[Y] - X + C.Shorts) << 1; if (J == Shortjump) { Cad -= 2; Y = Prog[X - 1] + (Y & 255); C.Shorts = C.Shorts + 1; } } else if (J == Indglobal) { I = Dict[Y].Val; if (I <= 0) { Dict[Y].Val = -((unsigned)Cad >> 1); Y = -I; } else { I -= Cad; if (Isshort(I) != True) Report(Reacherr, Y, 0); Y = I; } } else { if (J != Global + 1) { Y = Y & 0xFFFF; if (J != Global) Y += 65536; } Y -= Cad; if (Isshort(Y) != True) if ((Prog[X - 1] & 0xF1FF) != 0x41FA) Report(Creacherr, 0, Cad); else { I = Cad; Cad = Lim; Setcodeword(Prog[X - 1] ^ (0x41FA ^ 0x207C)); Setcodelongword(Y - 2); Setcodeword(Prog[X - 1] ^ (0x41FA ^ 0xD1D7)); Setcodeword(0x4E75); Lim = Cad; Cad = I - 2; Setcodeword(0x6100); Y = Lim - 10 - Cad; Steps += 5; } } Shortinteger = Y; Cad += 2; X++; } Cad = Lim; Forgetall(); } void Topred(void) { if (!Item) Item = Litref(Value); Putact(Compare, Item, 0); Condop = Bne ^ Polarity; Item = Np - 1; } void Resetcontext(int Pid, int Free) { Starts = 0; Cycles = 0; C = 0; Forgetall(); C.Localdpos = Dlim; C.Parlim = Dlim; C.Localtext = Charlim; C.Localpc = Pc; C.Localswpc = Swpc; C.Lab1 = Curlab; C.Shorts = Zeroshorts; C.Free = Free; C.Mode = Framemode + Level; C.Vintage = Vintage; C.Pid = Pid; C.Dpid = &Dict[C.Pid]; } void Openblock(int Pid) { Forgetregs(); if (Level == Maxlevel) Croak(_imp_str_literal("Too many levels")); C.Oldcontrol = Control; Hold[Level] = C; Level++; Vintage++; Resetcontext(Pid, C.Free); C.Access = 1; C.Localad = Cad - Accounted; } int Parmatch(int Apos, int Bpos) { Identinfo *Ap; Identinfo *Bp; Identinfo *Atp; Identinfo *Btp; for (;;) { Ap = &Dict[Apos]; Bp = &Dict[Bpos]; if ((Ap->Flags ^ Bp->Flags) < 0) return (False); if (Ap->Type != Bp->Type) { Atp = Typecell(Ap->Type); Btp = Typecell(Bp->Type); if ((Atp->Flags & Cat) != Arry || Arry != (Btp->Flags & Cat)) return (False); } Apos = Ap->Link; Bpos = Bp->Link; if (!Apos) { if (Bpos) return (False); return (True); } else if (!Bpos) return (False); } } int Crunched(int P) { Identinfo *Dq; Identinfo *Dp; static int Q = 0; static int L = 0; Dp = &Dict[P]; Dp->Text = 0; Q = 0; L = Dp->Link; if (L) { if (Dp->Type < P) L = Crunched(L); if (P <= L) return (P); Dp->Link = L; Q = L - 1; } Dq = &Dict[Q]; while (Q < P) { if (Dq->Type == Dp->Type && Dq->Link == L && Dq->Reg == Dp->Reg && Dq->Val == Dp->Val) { Dlim = P; return (Q); } Q++; Dq = &Dict[Q]; } return (P); } void Popcontext(void) { Pc = C.Localpc; Swpc = C.Localswpc; Curlab = C.Lab1; Dlim = C.Parlim; if (Level > Outerlevel) { Charlim = C.Localtext; while (Ranges >= C.Parlim) Ranges = Dict[Ranges].Hlink; C.Dpid = Crunched(C.Dpid); Level--; C = Hold[Level]; Control = Control & Editbit | C.Oldcontrol & (~Editbit); } if (Dictshown > Dlim) Dictshown = Dlim; Starts = 0; Cycles = 0; } void Fixupswitchvector(int Pos, Identinfo *Dp) { int X; int Y; int J; int Default; int Temp; int Lo; int Hi; Identinfo *Tp; Tp = Typecell(Dp.Type); X = Dp.Val; Default = Dp.Link; if (!Default) Default = Pc; Getbounds(Tp->Xtype, Lo, Hi); if (!(Dp.Flags & Arrflag)) J = Pflag[X - 1] + Lo; else J = Pflag[X - 7]; J -= X; while (Lo <= Hi) { Y = Prog[X]; if (Y <= 0) { if (!Dp.Link) { Report(Slabmissing + Warn, Pos, Lo); C.Access = 1; } if (Y < 0) { Y = -Y; do { Temp = Y; Y = Prog[Temp]; Prog[Temp] = Default; } while (Y); } Y = Default; } Prog[X] = (Y - Pflag[Y] - J) << 1; X++; Lo++; } } void Closeblock(void) { int Miss; int Under; int Pos; int Base; Identinfo *Dp; if (C.Type > 0 && (C.Status & Wrongcc) == 0) { C.Reg.Ccx = 0; C.Reg.Ccy = 0; } if (C.Return) { if (C.Return == -(Pc - 1) && C.Access == 0) { C.Return = -Prog[Pc - 1]; Pc -= 2; } Definejumps(C.Return); C.Access = -1; } Pflag[Pc] = C.Shorts; if (C.Status & Hadswitch) { Pos = C.Localdpos; while (Pos < Dlim) { Dp = &Dict[Pos]; if (Dp->Mode == Labmode && Dp->Type != 0) Fixupswitchvector(Pos, *Dp); Pos++; } } Compileend(); C.Totstack = C.Totstack - C.Extra; if (!(C.Status & Unknown)) C.Totstack = -C.Totstack; *Typecell(C.Dpid)(C.Dpid).Val = C.Totstack; if (Control & Maplist) { Putident(C.Pid, 0); Markat(20); Putstring(_imp_str_literal(" code:")); Putnum(Cad - C.Localad - Accounted); Putstring(_imp_str_literal(" entry:")); Putnum(C.Dpid - C.Localad - Accounted); Putstring(_imp_str_literal(" stack:")); Putnum(-C.Stack); Putsym('/'); Putnum(Imod(C.Totstack)); if (C.Totstack < 0) Putsym('+'); Accounted = Cad - C.Localad; Printline(); } Miss = 0; Under = 0; Base = C.Localdpos; if (!Level) Base = 0; Pos = Dlim; Dp = &Dict[Pos]; while (Pos > Base) { Pos--; Dp = &Dict[Pos]; if (!(Dp->Flags & Ext)) { if (Dp->Text > 0) { Sethashhead(*String(Dp->Text + Char0)); if (*Head == Pos) { *Head = Dp->Hlink; Check: if (Dp->Flags & Spec) { Dp->Hlink = Miss; Miss = Pos; } else if ((((Dp->Flags & (Readable + Rflag)) == Readable && Dp->Mode != Litmode) || ((Dp->Flags & (Writable + Okflag + Wflag + Spec)) == Writable)) && Pos >= C.Localdpos && Dp->Mode != 0 && (Dp->Flags & Typeid) == 0 && (Control & (List | Maplist)) != 0) { Dp->Hlink = Under; Under = Pos; } } } } else if (!Level) if (!(Dp->Flags & Spec)) { Dp->Link = Externs; Externs = Pos; } else if (Dp->Flags & (Rflag + Wflag)) { Dp->Link = Extspecs; Extspecs = Pos; } } if (Miss) Report(Idmissing, Miss, 0); if (Under != 0 && C.Faults == 0) { Putident(Under, 1); Putstring(_imp_str_literal(" underused")); Printline(); } Popcontext(); if (Firstpos >= Dlim) Setfirstentry(); } void Error(int Case) { Faultp = Atomp; Report(Case, 0, 0); _imp_signal(11, 0, 0, _imp_str_literal("")); } static const int Dud = 63; void Syntaxerror(void) { if (Atom == Dud) Error(Atomerr + Point); else Error(Formerr + Point); } void Expfault(int Case) { if (Faultnum == 0 || Expp < Faultp) { Faultnum = Case | Point; Faultp = Expp; } } void Nonstandard(int Case) { int B; static int Hadit = 0; B = 1 << Case; if ((B & Hadit) == 0 && (Control & Nonsbit) == 0 && Faultnum == 0) { Hadit += B; Faultp = Atomp; if (Control & Strictbit) Report(Nonstand + Point, 0, Case); else Report(Nonstand + Point + Warn, 0, Case); } } void Nameerror(void) { if (Item >= 0) { Fault(Namerr + Point + Now); if (Charmin - Newlen - 80 >= Charlim) { Dmin--; Dmin0 = Dmin; Charmin = Charmin - Newlen - 1; *String(Charmin) = *String(Charlim); Dict[Dmin].Text = Charmin - Char0; while (*Head > 0) Head = &Dict[*Head].Hlink; Dict[Dmin].Hlink = *Head; *Head = -Dmin; } } else Others++; _imp_signal(11, 0, 0, _imp_str_literal("")); } void Findop(int Mnemonic, int *Op, int *Types) { int I; I = 0; do { I += 2; if (I > Defmax + Defmax) Error(Namerr); } while (Def[I] != Mnemonic); *Types = Def[I - 1]; *Op = (unsigned)I >> 1; } void Readline(int Flag) { if (Faultnum) Report(Faultnum, 0, 0); while (Sym > Nl) { Sym = *Byteinteger(Fp); Fp++; } Line++; while (Fp == Curlim) { if (Curlim != Cur->Lim2) Fp = Cur->Start2; else if (Curfile == Main) _imp_signal(12, 0, 0, _imp_str_literal("")); else { Cur->Flag = -1; Curfile--; Cur = &File[Curfile]; Fp = Cur->Fp; Line = Cur->Line; Control = Fcontrol[Curfile]; if (Level == Outerlevel && C.Status < Hadon) Inclim = Dlim; } Curstart = Cur->Start2; Curlim = Cur->Lim2; if (Fp < Curstart || Fp > Curlim) { Curstart = Cur->Start1; Curlim = Cur->Lim1; } } Linestart = Fp; if (!Flag) { Flag = ' '; if (Curfile != Main) Flag = '&'; } Listflag = Flag; if (Control & List) { Time1 -= Cputime; if (_imp_strcmp(Rep, _imp_str_literal("")) != 0) Printline(); if (Control & Dictlist) Showdict(Dictshown); Dictshown = Dlim; Write(Line, 4); Printsymbol(Listflag); Printsymbol(' '); do { Sym = *Byteinteger(Fp); Fp++; Printsymbol(Sym); } while (Sym > Nl); Fp = Linestart; Time1 += Cputime; } Sym = 0; } static const int Casebit = 32; static int Percent = 0; static int Subatom = 0; static const int Keyend = 1; static const int Keyrepeat = 2; static const int Keyfinish = 3; static const int Keyelse = 4; static const int Keybegin = 5; static const int Exit = 6; static const int Keyreturn = 7; static const int Tf = 8; static const int Keyresult = 9; static const int Keystop = 10; static const int Keygoto = 11; static const int Keysignal = 12; static const int Keymonitor = 13; static const int Keyon = 14; static const int Iu = 15; static const int Keywhile = 16; static const int Keyuntil = 17; static const int Keyfor = 18; static const int Keythen = 19; static const int Keystart = 20; static const int Keycycle = 21; static const int Keylabel = 22; static const int Keyconst = 23; static const int Keyown = 24; static const int Keyext = 25; static const int Kattrib = 26; static const int Ktype = 27; static const int Keyinteger = 28; static const int Keylong = 29; static const int Keyreal = 30; static const int Keystring = 31; static const int Keyrecord = 32; static const int Keyname = 33; static const int Keyformat = 34; static const int Fnmap = 35; static const int Rpred = 36; static const int Keyspec = 37; static const int Keyarray = 38; static const int Keyswitch = 39; static const int Keyof = 40; static const int Keyfile = 41; static const int Keyprogram = 42; static const int Keylist = 43; static const int Keycontrol = 44; static const int Keycomment = 45; static const int Keyevent = 46; static const int Keyinclude = 47; static const int Keyoption = 48; static const int Keyalias = 49; static const int Keynot = 50; static const int Keyand = 72; static const int Keyor = 73; static const int Terminator = 51; static const int Const = 52; static const int Ident = 53; static const int Modsign = 54; static const int Colon = 59; static const int Comma = 60; static const int Right = 61; static const int Rightb = 62; static const int Left = 55; static const int Leftb = 56; static const int Atsign = 57; static const int Underline = 58; static const int Arrow = 74; static const int Eqeq = 75; static const int Noteqeq = 76; static const int Equals = 77; static const int Noteq = 78; static const int Lesseq = 79; static const int Less = 80; static const int Greateq = 81; static const int Greater = 82; static const int Plus = 83; static const int Minus = 84; static const int Exclam = 85; static const int Exclam2 = 86; static const int Dot = 87; static const int Star = 88; static const int Slash2 = 89; static const int Slash = 90; static const int Ampersand = 91; static const int Star2 = 92; static const int Backslash = 93; static const int Uparrow = 94; static const int Backslash2 = 95; static const int Uparrow2 = 96; static const int Tilde = 97; static const int Lshift = 98; static const int Rshift = 99; static const int Atommax = 99; static const int Aleft = Left; static const int Aright = Right; static const int Recsub = Underline; static const int Over = Slash2; static const int Sconc = Dot; static const int Simple = Atommax + 1; static const int Vsimple = Simple + 1; static const int Major = Plus; static const int Scond = Arrow; static const int Cond = Keyand; static const int Condq = 71; int Nextatom(void) { static int S_sw; static void *S[256 /*0:255*/] = { &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_9, &&S_10, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_33, &&S_34, &&S_35, &&S_default, &&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, &&S_50, &&S_51, &&S_52, &&S_53, &&S_54, &&S_55, &&S_56, &&S_57, &&S_58, &&S_59, &&S_60, &&S_61, &&S_62, &&S_default, &&S_64, &&S_65, &&S_66, &&S_67, &&S_68, &&S_69, &&S_70, &&S_71, &&S_72, &&S_73, &&S_74, &&S_75, &&S_76, &&S_77, &&S_78, &&S_79, &&S_80, &&S_81, &&S_82, &&S_83, &&S_84, &&S_85, &&S_86, &&S_87, &&S_88, &&S_89, &&S_90, &&S_91, &&S_92, &&S_93, &&S_94, &&S_95, &&S_default, &&S_97, &&S_98, &&S_99, &&S_100, &&S_101, &&S_102, &&S_103, &&S_104, &&S_105, &&S_106, &&S_107, &&S_108, &&S_109, &&S_110, &&S_111, &&S_112, &&S_113, &&S_114, &&S_115, &&S_116, &&S_117, &&S_118, &&S_119, &&S_120, &&S_121, &&S_122, &&S_123, &&S_124, &&S_default, &&S_126, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, }; static const int Tab = 9; static const int Max10 = Maxint / 10; static const int Maxdig = Maxint - Max10 * 10; int I; int J; int P; int Radix; int Hash; float Rval; static const unsigned char Map[128 /*0:127*/] = {[0 ... 47] = 0, '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 0, 0, 0, 0, 0, 0, 0, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 0, 0, 0, 0, 0, 0, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 0, 0, 0, 0, 0}; static const short Syminit[26 /*97:122*/] = {2, 15, 31, 72, 79, 102, 133, 137, 141, 1, 1, 156, 169, 183, 190, 205, 1, 220, 257, 297, 309, 319, 327, 1, 1, 1}; static const unsigned char Symbol[340 /*1:340*/] = { 128, 114, 114, 97, 121, 166, 108, 105, 97, 115, 177, 110, 100, 200, 101, 103, 105, 110, 133, 121, 116, 101, 155, 111, 111, 108, 101, 97, 110, 155, 111, 110, 116, 105, 110, 117, 101, 134, 121, 99, 108, 101, 149, 104, 97, 114, 155, 115, 116, 114, 105, 110, 103, 159, 109, 109, 101, 110, 116, 173, 115, 116, 97, 110, 116, 151, 151, 114, 111, 108, 172, 121, 110, 97, 109, 105, 99, 153, 110, 100, 129, 108, 115, 101, 132, 120, 105, 116, 134, 118, 101, 110, 116, 174, 116, 101, 114, 110, 97, 108, 153, 105, 110, 105, 115, 104, 131, 97, 108, 115, 101, 136, 111, 114, 109, 97, 116, 162, 110, 163, 117, 110, 99, 116, 105, 111, 110, 163, 146, 108, 101, 169, 111, 116, 111, 139, 97, 108, 102, 155, 102, 143, 110, 116, 101, 103, 101, 114, 156, 99, 108, 117, 100, 101, 175, 97, 98, 101, 108, 150, 111, 110, 103, 157, 105, 115, 116, 171, 111, 110, 105, 116, 111, 114, 141, 105, 116, 101, 155, 97, 112, 163, 97, 109, 101, 161, 111, 116, 178, 110, 142, 119, 110, 152, 102, 168, 112, 116, 105, 111, 110, 176, 114, 201, 114, 101, 100, 105, 99, 97, 116, 101, 164, 111, 103, 114, 97, 109, 170, 101, 112, 101, 97, 116, 130, 111, 117, 116, 105, 110, 101, 164, 116, 117, 114, 110, 135, 115, 117, 108, 116, 137, 97, 100, 111, 110, 108, 121, 154, 99, 111, 114, 100, 160, 108, 158, 116, 111, 112, 138, 105, 103, 110, 97, 108, 140, 121, 115, 116, 101, 109, 153, 104, 111, 114, 116, 155, 112, 101, 99, 165, 119, 105, 116, 99, 104, 167, 97, 114, 116, 148, 114, 105, 110, 103, 159, 114, 117, 101, 136, 104, 101, 110, 147, 101, 120, 116, 155, 110, 108, 101, 115, 115, 143, 116, 105, 108, 145, 111, 108, 97, 116, 105, 108, 101, 154, 104, 105, 108, 101, 144, 114, 105, 116, 101, 111, 110, 108, 121, 154}; static const unsigned char Altdisp[340 /*1:340*/] = { 0, 5, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 4, 0, 0, 9, 0, 0, 0, 0, 0, 0, 15, 8, 23, 28, 34, 0, 0, 0, 0, 5, 0, 0, 0, 0, 4, 0, 0, 18, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 0, 0, 4, 0, 0, 0, 4, 8, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 27, 0, 0, 0, 0, 5, 0, 0, 0, 0, 6, 0, 14, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 2, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 4, 0, 0, 12, 0, 0, 1, 4, 0, 0, 0, 0, 0, 0, 2, 0, 3, 0, 0, 2, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 6, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 5, 0, 0, 0, 0, 7, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 30, 0, 0, 6, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 5, 5, 0, 0, 0, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 4, 0, 0, 0, 0, 0, 0, 25, 0, 5, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}; void Getsym(void) { do { Sym = *Byteinteger(Fp); Fp++; } while (Sym == ' '); I = Sym - '0'; if (I >= 10) { I = (Sym | Casebit) - 'a'; if (I >= 0) I += 10; } } Matched = 0; Again: S_9:; if (Sym == Nl) Readline(0); Again1:; do { Sym = *Byteinteger(Fp); Fp++; } while (Sym == ' '); Atomp = Fp; Atoms++; goto *S[S_sw = Sym]; Linebreak: S_10:; if (Atom != Comma) return (Terminator); Continuation:; Readline('+'); goto Again1; S_123:; Comments++; do { Sym = *Byteinteger(Fp); Fp++; if (Sym == Nl) goto Linebreak; } while (Sym != '}'); goto Again; S_43: return (Plus); S_45: if (*Byteinteger(Fp) == '>') { Fp++; return (Arrow); } if (*Byteinteger(Fp) == Nl) goto Continuation; return (Minus); S_42: return (Star); S_47: if (*Byteinteger(Fp) == '/') { Fp++; return (Slash2); } return (Slash); S_92: if (*Byteinteger(Fp) == '\\') { Fp++; return (Backslash2); } if (*Byteinteger(Fp) == '=') { Fp++; return (Noteq); } return (Backslash); S_94: if (*Byteinteger(Fp) == '^') { Fp++; return (Uparrow2); } return (Uparrow); S_126: return (Tilde); S_33: if (*Byteinteger(Fp) == '!') { Fp++; return (Exclam2); } return (Exclam); S_38: return (Ampersand); S_46: if ('0' <= *Byteinteger(Fp) && *Byteinteger(Fp) <= '9') { Rval = 0; goto Fraction; } return (Dot); S_61: if (*Byteinteger(Fp) == '=') { Fp++; return (Eqeq); } return (Equals); S_35: if (*Byteinteger(Fp) == '#') { Fp++; return (Noteqeq); } return (Noteq); S_60: if (*Byteinteger(Fp) == '=') { Fp++; return (Lesseq); } if (*Byteinteger(Fp) == '>') { Fp++; return (Noteq); } if (*Byteinteger(Fp) == '<') { Fp++; return (Lshift); } return (Less); S_62: if (*Byteinteger(Fp) == '=') { Fp++; return (Greateq); } if (*Byteinteger(Fp) == '>') { Fp++; return (Rshift); } return (Greater); S_95: return (Underline); S_58: return (Colon); S_44: return (Comma); S_59: return (Terminator); S_40: return (Left); S_91: return (Leftb); S_41: return (Right); S_93: return (Rightb); S_124: return (Modsign); S_64: return (Atsign); S_77: S_109:; if (*Byteinteger(Fp) == '\'') { Fp++; goto Charconst; } S_65: S_66: S_67: S_68: S_69: S_70: S_71: S_72:; S_73: S_74: S_75: S_76: S_78: S_79: S_80:; S_81: S_82: S_83: S_84: S_85: S_86: S_87: S_88:; S_89: S_90: S_97: S_98: S_99: S_100: S_101: S_102:; S_103: S_104: S_105: S_106: S_107: S_108: S_110:; S_111: S_112: S_113: S_114: S_115: S_116: S_117: S_118:; S_119: S_120: S_121: S_122:; if (Percent) goto Keyword; Newlen = Charlim + 1; Hash = Sym | Casebit; *Byteinteger(Newlen) = Hash; do { Sym = *Byteinteger(Fp); Fp++; } while (Sym == ' '); if (Sym == '\'') { if (Hash == 'x') { Radix = 16; goto Ibm; } if (Hash == 'k') { Radix = 8; goto Ibm; } if (Hash == 'b') { Radix = 2; goto Ibm; } } Sym = Map[Sym]; if (Sym) do { Newlen++; *Byteinteger(Newlen) = Sym; Hash = Hash << 1 ^ Sym; do { Sym = *Byteinteger(Fp); Fp++; } while (Sym == ' '); Sym = Map[Sym]; } while (Sym); Fp--; Newlen -= Charlim; *Byteinteger(Charlim) = Newlen; if (Subbed) Head = &Dformat->Link; else Head = &Hashindex[Hash & 255]; Item = *Head; if (Item) do { Ditem = &Dict[Imod(Item)]; if (*String(Ditem->Text + Char0) == *String(Charlim) && (Item > A7 || Item < 0 || (Control & Lowbit) != 0)) break; Item = Ditem->Hlink; } while (Item); Identatoms++; return (Ident); S_37:; Sym = *Byteinteger(Fp); if ('a' > (Sym | Casebit) || (Sym | Casebit) > 'z') goto Again; Fp++; Keyword:; Percent = 0; P = Syminit[Sym | Casebit]; for (;;) { while (Symbol[P] == (*Byteinteger(Fp) | Casebit)) { P++; Fp++; } if (Symbol[P] > 127) break; Atom = Altdisp[P]; if (!Atom) { if ((Sym | Casebit) != 'c' || *Byteinteger(Fp) != Nl) return (Dud); goto Continuation; } P += Atom; } if ('a' <= (*Byteinteger(Fp) | Casebit) && (*Byteinteger(Fp) | Casebit) <= 'z') Percent = 1; Subatom = Altdisp[P]; Atom = Symbol[P] - 128; if (!Atom) return (Dud); return (Atom); Ibm:; Nonstandard(20); Item = -1; Value = 0; goto Ibm1; S_48: S_49: S_50: S_51: S_52: S_53: S_54: S_55: S_56: S_57:; Item = 0; Type = Inttype; Radix = 10; Value = Sym - '0'; Ibm1:; for (;;) { for (;;) { do { Sym = *Byteinteger(Fp); Fp++; } while (Sym == ' '); I = Sym - '0'; if (Radix == 10) { if (I < 0 || I >= 10) break; if (Value > Max10 || (Value == Max10 && I > Maxdig)) Fault(Rangerr + Point + Warn); Value = (((Value << 2) + Value) << 1) + I; } else { if (I >= 10) I = (Sym | Casebit) - 'a' + 10; if (I < 0 || I >= Radix) break; J = Radix; do { if (J & 1) I += Value; Value = Value << 1; J = (unsigned)J >> 1; } while (J); Value = I; } } if (Sym != '_') break; Radix = Value; if (!Radix) return (Dud); Value = 0; } if (Item < 0) { if (Sym != '\'') return (Dud); Item = 0; } else { J = 0; if (Sym == '.') { if (Type == Inttype) Rval = Value; Fraction:; J = 0; Type = Realtype; for (;;) { Getsym(); if (0 > I || I >= Radix) break; Rval = Rval * Radix + I; J--; } if (!J) return (Dud); } if (Sym == '@') { if (Type == Inttype) { Type = Realtype; Rval = Value; } Getsym(); Value = 0; if (Sym == '+') Getsym(); else if (Sym == '-') { Value = 1; Getsym(); } if (0 > I || I >= Radix) return (Dud); P = 0; do { P = P * Radix + I; Getsym(); } while (0 <= I && I < Radix); if (Value) P = -P; J += P; } if (Type == Realtype) { if (J) Rval = Rval * IEXP(Radix, J); if (Type == Realtype) Value = *Integer(Addr(Rval)); } Fp--; Sym = 0; } Litatoms++; return (Const); S_39:; Charconst:; Item = 0; Type = Inttype; Value = 0; for (;;) { Sym = *Byteinteger(Fp); Fp++; if (Sym == Nl) return (Dud); if (Sym == '\'') { if (*Byteinteger(Fp) != '\'') break; Fp++; } Value = (Value << 8) + Sym; } if (Value) return (Const); return (Dud); S_34:; Item = 0; Value = Cad; Type = Stringtype; I = Line; J = Linestart; P = 0; for (;;) { Sym = *Byteinteger(Fp); Fp++; if (Sym == '"') { if (*Byteinteger(Fp) != '"') break; Fp++; } P++; if (P > 255) { Sym = 0; Fp = Atomp; Linestart = J; return (Dud); } Final[Value + P] = Sym; if (Sym == Nl) Readline('"'); } if (P) { Final[Value] = P; Cad += P + 1; } else Value = 0; Litatoms++; return (Const); S_default:; return (Dud); } int A(int K) { if (Matched) Atom = Nextatom(); if (K != Atom) return (False); Matched = 1; return (True); } void Get(int K) { if (Matched) Atom = Nextatom(); Matched = 1; if (Atom == K) return; Syntaxerror(); } void Allow(int K) { if (A(K) == True) ; } void Getlitstring(void) { int Holditem; Holditem = Item; Get(Const); if (Type != Stringtype) Error(Typerr + Point); Cad = Value; Item = Holditem; } int Idtext(int F) { int K; if (Item > 0 && (F & Ext) == 0) return (Ditem->Text); Charlim = Charlim + Newlen + 1; if (Charlim + 80 >= Charmin) Croak(_imp_str_literal("Identifier space exhausted")); K = Charlim - Newlen - 1 - Char0; if ((F & Ext) != 0 && A(Keyalias) == True) { Getlitstring(); *String(Charlim) = *String(Final0 + Value); *Byteinteger(Charlim) = *Byteinteger(Charlim) + 128; Charlim = Charlim + *Byteinteger(Charlim) - 127; } return (K); } Objinfo *Details(int F, int T, int M, int V) { static Objinfo D = 0; D.Flags = F; D.Type = T; D.Mode = M; D.Val = V; return (&D); } void Declare(Objinfo * D) { int I; Identinfo *Dp; Dp = &Dict[Dlim]; if (!Speccing) { if (Item >= C.Localdpos) { if ((D.Flags & Spec) == 0 && (Ditem->Flags & Spec) != 0) { if ((D.Flags & (Ext + Proc + Typeid)) == (Ditem->Flags & (Ext + Proc + Typeid))) { I = Item; if (D.Flags & Ext) { if (Ditem->Flags & Rflag) goto Ok; Ditem->Mode = D.Mode; Ditem->Val = D.Val; if (A(Keyalias) == True) { Getlitstring(); Item = I; } } if (!(D.Flags & Proc)) Ditem->Flags = Ditem->Flags & (~(Spec + Indirect)); return; } if ((Ditem->Flags & (Ext + Proc)) == Proc1 && (D.Flags & Ext) != 0 && (D.Flags & Proc) != 0) { Ditem->Flags = Ditem->Flags - Proc1 + (D.Flags & (Ext + Proc)); Ditem->Text = Idtext(Ext); return; } } if (Item < Inclim && (Ditem->Flags & (Rflag + Wflag)) == 0) Fault(Duperr + Warn + Point); else Fault(Duperr + Point); } Ok: Dp->Hlink = *Head; *Head = Dlim; Dp->Text = Idtext(D.Flags); } else { Dp->Hlink = 0; Dp->Text = 0; } Item = Dlim; Ditem = Dp; Ditem->*Details() = *D; Dlim++; if (Dlim >= Dmin) { if (Control & Logbit) Showdict(0); Croak(_imp_str_literal("Too many identifiers")); } } void Declareanon(Objinfo * D) { Speccing++; Item = 0; Declare(*D); Speccing--; } void Declaretemp(int T) { C.Val = C.Val + 4; C.Temps = C.Temps + 4; Declareanon(*Details(Okflag + Writable + Readable, T, C.Mode, C.Sp - C.Val)); } void Declarerange(int Type, int Lower, int Upper) { int S; int Ok(int L, int U) { if ((L <= Lower && Upper <= U) || (0 <= Lower && Upper <= U - L)) return (True); return (False); } S = 4; if (Ok(-32768, 32767) == True) { S = 2; if (Ok(-128, 127) == True) S = 1; } Ditem->*Details() = *Details(Typeid, Type, Absmode, Sign); Ditem->Size() = S; Declareanon(*Details(Okflag, Type, Litmode, Lower)); Declareanon(*Details(Okflag, Type, Litmode, Upper)); Ditem->Hlink = Ranges; Ranges = Item; Item -= 2; } static int Literal = 0; static int Jammy = 0; auto void Getexpression(int Rank, int Etype); int Valok(int Wanted, int T) { int Lo; int Hi; int L; int H; int Wc; int Tc; Identinfo *Wp; Identinfo *Tp; if (Wanted == T && T != Recstar) return (True); Wp = Typecell(Wanted); Tp = Typecell(T); Wc = Wp->Flags & (Packed + Cat); Tc = Tp->Flags & (Packed + Cat); if (Wc == Tc) if (!(Wc & Nonord)) { if (Wp->Type == Tp->Type) { if (Wp->Type == Wanted) return (True); if (Dict[Wanted + 1].Mode != Litmode) Getbounds(Dict[Wanted + 1].Type, Lo, Hi); else Lo = Dict[Wanted + 1].Val; if (Dict[Wanted + 2].Mode != Litmode) Getbounds(Dict[Wanted + 2].Type, Hi, Hi); else Hi = Dict[Wanted + 2].Val; if (!Item) { if (Lo <= Value && Value <= Hi) return (True); Jammy = Jammy ^ 1; } else { if (Tp->Type == T) { Jammy = Jammy ^ 1; return (True); } if (Dict[T + 1].Mode != Litmode) Getbounds(Dict[T + 1].Type, L, H); else L = Dict[T + 1].Val; if (Dict[T + 2].Mode != Litmode) Getbounds(Dict[T + 2].Type, H, H); else H = Dict[T + 2].Val; if (L >= Lo) { if (H <= Hi) return (True); Jammy = Jammy ^ 1; if (L <= Hi) return (True); } else { Jammy = Jammy ^ 1; if (H >= Lo) return (True); } } if (Jammy) Expfault(Rangerr); return (True); } } else if (Wc == Realy) return (True); else if (Wc == Stringy) { if (Wanted == Stringstar) return (True); if (!Item) { if (!Value) return (True); L = Final[Value] + 1; } else { L = Imod(Tp->Size()); if (!L) L = 256; } if (L > Imod(Wp->Size()) && Imod(Wp->Size()) != 0) { Jammy = Jammy ^ 1; if (Item == 0 && Jammy != 0) Expfault(Rangerr); } return (True); } else if ((Wc & Cat) == Arry) { if (Wp->Type == Tp->Type && Valok(Wp->Xtype, Tp->Xtype) == True) return (True); } else if (Wanted == Recstar) { if (T != Recstar) return (True); } else if (T == Recstar || (Item | Value) == 0) return (True); else if (!Tc) { if (Wc == Recy && (Item | Value) == 0) return (True); if (Wc == Realy) { Toreal(); return (True); } } else if (Wc == Stringy && T == Chartype) { if (!Item) { Final[Cad] = 1; Final[Cad + 1] = Value; Value = Cad; Cad += 2; Type = Stringtype; } else Putexp(Dtostring, Normitem(), 0, String1); return (True); } return (False); } void Getvalue(int Valtype) { Getexpression(Major, Valtype); } void Getliteral(int T) { Literal++; Getexpression(Major, T); Literal--; } void Getmident(int Min, int Max) { Get(Ident); if (Item <= 0) { if (_imp_strcmp(*String(Charlim), _imp_str_literal("sp")) != 0) Nameerror(); Item = A7; Ditem = &Dict[Item]; } if (Ditem->Mode == Litmode) { Value = Ditem->Val; Item = 0; } if (Min > Item || Item > Max) Syntaxerror(); } void Getregset(void) { int Hold; int Set; Set = 0; do { Getmident(D0, A7); Hold = Item; if (A(Minus) == True) Getmident(Hold, A7); do { Set = Set | 1 << (Hold - D0); Hold++; } while (Hold <= Item); } while (A(Slash) == True); Item = 0; Value = Set; } void Getmcode(void) { int Op; int X; int Y; int Types; int Opsize(int Okbyte) { if (A(Dot) != True) return (0); Sym = *Byteinteger(Fp) & (~Casebit); Fp++; if (Sym == 'L') return (4); if (Sym == 'W') return (2); if (Sym == Okbyte) return (1); Syntaxerror(); } void Getmop(int T, int Dummy, Identinfo *Dp) { static const int Hashsign = Noteq; int Sign; int Hold; int Holdval; int M; if (A(Hashsign) == True) { Getliteral(Inttype); return; } Sign = 0; Hold = -1; Holdval = 0; if (A(Minus) == True) Sign = 1; if (A(Ident) == True) { Matched = 0; Getmident(0, Dlim); Hold = Item; if (Hold) { if (Sign) Syntaxerror(); if (Item > A7) { Dp.Flags = Ditem->Flags; Dp.Mode = Ditem->Mode; Dp.Val = Ditem->Val; while (A(Recsub) == True) { Dformat = Typecell(Ditem->Type); if ((Dformat->Flags & Cat) != Recy || (Ditem->Flags & (Name + Indirect)) != 0) Syntaxerror(); Subbed = 1; Get(Ident); Subbed = 0; if (Item <= 0) Error(Namerr + Point); Dp.Flags = Ditem->Flags; Dp.Type = Ditem->Type; Dp.Val = Dp.Val + Ditem->Val; Item = Dummy; Ditem = Dp; } return; } if ((Op & 255) == Movem && Item > 0) { Matched = 0; Getregset(); } return; } Holdval = Value; } else if (A(Const) == True) { Hold = 0; Holdval = Value; } if (Sign) Holdval = -Holdval; if (A(Left) == True) { Getmident(A0, A7); if (Hold < 0) { Get(Right); if (Sign) Item += Pre; else if (A(Plus) != True) Item += Indir; else Item += Post; return; } M = Item + (Dispmode - A0); if (A(Comma) == True) { Getmident(D0, A7); if (Ismite(Holdval) != True) Fault(Rangerr); M += Indexmode - Dispmode; Holdval = ((Item - D0) << 12) + (Holdval & 255); if (Opsize(0) != 2) Holdval += 0x0800; } Get(Right); } else { if (Hold < 0) Syntaxerror(); M = Absmode; } Dp.Mode = M; Dp.Val = Holdval; Item = Dummy; } static const int Temp = (((((('t' & 31) << 5) + ('e' & 31)) << 5) + ('m' & 31)) << 5) + ('p' & 31); Updatesp(); Atomp = Fp + 1; X = 0; for (;;) { Sym = *Byteinteger(Fp); Fp++; if ('A' > (Sym & (~Casebit)) || (Sym & (~Casebit)) > 'Z') break; Sym = Sym & 31; X = (X << 5) + Sym; } Fp--; Sym = 0; if (!X) Syntaxerror(); if (X == Temp) { Value = 0; if (A(Ident) == True) { Matched = 0; Getregset(); } C.Free = Value; return; } do X = X << 5; while (!(X & (31 << 25))); X = X | 0xC0000000; Findop(X, Op, Types); if (Types & (Sized | Asized)) Op += Opsize('B') << 8; X = 0; Y = 0; if ((unsigned)Types >> 6 & 63) { Getmop((unsigned)Types >> 6 & 63, Lablim, *Dtemp); X = Normitem(); if (Types & 63) Get(Comma); } if (Types & 63) { Getmop(Types & 63, Lablim + 1, *Dtemp2); Y = Normitem(); } Plant(Op, X, Y); Forgetregs(); C.Access = -1; } int Refok(int Wanted, int T) { Identinfo *Wp; Identinfo *Tp; if (T == Wanted || Wanted == 0 || T == 0 || (Item | Value) == 0) return (True); Wp = Typecell(Wanted); Tp = Typecell(T); if (!((Wp->Flags ^ Tp->Flags) & (Name + Packed + Cat))) if ((Wp->Flags & Cat) == Arry) { if (Refok(Wp->Type, Tp->Type) == True) return (True); } else if ((Wp->Flags & Cat) == Stringy) { if (Tp->Size() == 0 || Wp->Size() == 0) return (True); } else if (T == Recstar || Wanted == Recstar) return (True); return (False); } void Toref(void) { if (Item <= 0 || Ditem->Mode < Dispmode) { Atomp = Expp; Error(Nonref + Point); } if (Item >= Dictlim) ; else if (Ditem->Mode == Absmode && Ditem->Flags >= 0) { Item = 0; Value = Ditem->Val; return; } Item += Ad; } void Copydown(int Np1) { while (Np > Np1) { Np--; Explo--; Dict[Explo] = Dict[Np]; } } void Getreference(int Reftype) { Getexpression(Simple, Reftype | Sign16); } void Getparlist(int Special) { int Procnp; int Pact; int Hold; int Count; int Headitem; int Arg; int P; int Q; int Restype; Identinfo *Hp; Identinfo *Tp; Identinfo *Darg; void Putactual(void) { if (!Item) Item = Litref(Value); if (!(Count & 1)) Hold = Item; else { Putact(Pact, Hold, Item); Pact = 0; } Count++; } int Noalt(void) { if (!(Hp->Flags & Alt)) { Expfault(Typerr); return (True); } Item = Hp->Hlink; for (;;) { if (Item <= 0) { Report(Internerr, 0, 6); _imp_signal(11, 0, 0, _imp_str_literal("")); } Ditem = &Dict[Item]; if (*String(Ditem->Text + Char0) == *String(Hp->Text + Char0)) break; Item = Ditem->Hlink; } Headitem = Item; Pact = Headitem; Hp = Ditem; Arg = Hp->Type; Darg = &Dict[Arg]; Restype = Darg->Type; return (False); } void Putbounds(int Ft, int At) { int Maxarg; Identinfo *Ftp; Identinfo *Atp; Identinfo *Fxp; Identinfo *Axp; Maxarg = Arg; do { Ftp = Typecell(Ft); Atp = Typecell(At); if ((Ftp->Flags & Cat) == Stringy) { if (Ftp->Size()) break; if (Atp->Size()) Item = Litref(Imod(Atp->Size())); else Item = At - 1; Putactual(); if (Ft - 1 > Maxarg) Maxarg = Ft - 1; break; } if (Ftp->Xtype >= Arg) { Fxp = Typecell(Ftp->Xtype); Axp = Typecell(Atp->Xtype); if (Dict[Ftp->Xtype + 1].Mode != Litmode) { Item = Atp->Xtype + 1; if (Dict[Atp->Xtype + 1].Mode == Litmode) { Item = 0; Value = Dict[Atp->Xtype + 1].Val; } Putactual(); if (Ftp->Xtype >= Maxarg) Maxarg = Ftp->Xtype + 1; } if (Dict[Ftp->Xtype + 2].Mode != Litmode) { Item = Atp->Xtype + 2; if (Dict[Atp->Xtype + 2].Mode == Litmode) { Item = 0; Value = Dict[Atp->Xtype + 2].Val; } Putactual(); if (Ftp->Xtype + 1 >= Maxarg) Maxarg = Ftp->Xtype + 2; } } Ft = Ftp->Type; At = Atp->Type; } while (Ft > Arg); Arg = Maxarg; Darg = &Dict[Arg]; } Count = 0; Hold = 0; Procnp = Np; Headitem = Item; Pact = Headitem; Hp = Ditem; Arg = Hp->Type; Darg = &Dict[Arg]; Restype = Darg->Type; if (A(Left) == True) { do { Arg = Darg->Link; if (!Arg) { if (!Special) Error(Toomany + Point); Getreference(0); Value = Item - Ad; do if (Type == Realtype) { if (Restype == Realtype) break; } else if (Valok(Type, Restype) == True) break; while (Noalt() != True); Special = 0; } else { Darg = &Dict[Arg]; if (Darg->Flags & Proc) { Get(Ident); if (Item <= 0) Nameerror(); if ((Ditem->Flags & Proc) == 0 || Parmatch(Darg->Type, Ditem->Type) != True) Fault(Typerr + Point); if (Item > Headitem && Ditem->Mode == Procmode) Fault(Classerr + Point); Item += Ad; Putactual(); } else if (Darg->Flags >= 0) { Jammy = 0; Getexpression(Major, 0); do if (Valok(Darg->Type, Type) == True) break; while (Noalt() != True); if (Jammy != 0 && (Control & Capbit) != 0 && Category(Darg->Type) < Realy) Putexp(Check, Darg->Type, Item, Darg->Type); Putactual(); } else { Getreference(0); do if (Refok(Darg->Type, Type) == True) break; while (Noalt() != True); Putactual(); Tp = Typecell(Darg->Type); if ((Tp->Flags & Cat) == Arry && Dict[Arg + 1].Type != Darg->Type && Tp->Mode >= Framemode) Putbounds(Darg->Type, Type); } } } while (A(Comma) == True); if (Darg->Link != 0 || Special != 0) Error(Toofew + Point); Get(Right); } else if (Darg->Link) Error(Toofew + Point); if ((Count & 1) != 0 || Count == 0) Putact(Pact, Hold, 0); Type = Restype; if (Type) { if (!(Hp->Flags & Volatile)) { P = Explo; while (P < Explim) { if (Dict[P].Act == Headitem) { Item = P; Q = Procnp; for (;;) { if (Dict[P].X != Dict[Q].X || Dict[P].Y != Dict[Q].Y) break; P++; Q++; if (Q >= Np) goto Okf; } } P++; } } Copydown(Procnp); Item = Explo; Okf: Ditem = &Dict[Item]; Ditem->Flags = Hp->Flags & Heritable; Ditem->Mode = 0; if (Hp->Flags & Writable) Ditem->Mode = Dispmode; Ditem->Type = Type; Np = Procnp; } } void Getresolution(int T, int Item1) { int Fore; int Ftype; int S; S = Size(T); if (!S) S = -256; Fore = 0; if (A(Left) != True) { Getreference(Stringstar); Fore = Item; Ftype = Type; Get(Dot); Get(Left); } Getvalue(Stringtype); Get(Right); if (!Item) { Item = Litref(Value); S += Final[Value]; } if (Fore != 0 && S < Size(Ftype) && Size(Ftype) != 0) Fault(Rangerr + Warn); Putact(Resolves, Item1 + Ad, Item + Ad); Item = 0; if (A(Dot) == True) { Getreference(Stringstar); if (S < Size(Type) && Size(Type) != 0) Fault(Rangerr + Warn); } Putact(0, Fore, Item); Putact(0, 0, 0); } int Anon(Objinfo * D) { Dict[Lablim + 3].*Details() = *D; return (Lablim + 3); } int Aassop(int T) { if (T <= 0) { if (A(Eqeq) != True) return (False); } else { if (Matched) Atom = Nextatom(); if (Atom != Equals) { if (Atom != Less || *Byteinteger(Fp) != '-') return (False); Jammy = 1; Fp++; } else Jammy = 0; Matched = 1; } return (True); } void Getexpression(int Rank, int Etype) { int Atomp0; int Item1; int Type1; int Cat1; int Val1; int Double; int Op; Identinfo *Ditem1; Identinfo *Tp; static const int Nop = 0; void Getrecord(void) { int Fid; int Ad; int Arg; int Hold; int Count; int Max; int S; Identinfo *Darg; Identinfo *Fidp; Literal++; if (Cad & 1) Fillcode(1); Ad = Cad; Fid = Item; Fidp = Ditem; Arg = Fidp->Link; Count = 0; Max = -1; Get(Left); for (;;) { for (;;) { if (Arg <= 0) Error(Toomany + Point); Darg = &Dict[Arg]; if (Ad + Darg->Val - Cad >= 0) break; Arg = Darg->Hlink; } Fillcode(Ad + Darg->Val - Cad); if (A(Recsub) == True) { Subbed = 1; Dformat = Fidp; Get(Ident); Subbed = 0; if (Item < Arg) Nameerror(); Fillcode(Ditem->Val - Darg->Val); Arg = Item; Darg = Ditem; if (Aassop((Darg->Flags & Name) + Darg->Type) != True) Syntaxerror(); } S = Nsize(*Darg); if (A(Comma) != True) { Getvalue((Darg->Flags & Name) + Darg->Type); if (S > 0) if (S == 4) Setcodelongword(Value); else if (S == 2) Setcodeword(Value); else { Final[Cad] = Value; Cad++; } if (A(Right) == True) break; Get(Comma); } else if (S > 0) Fillcode(S); Arg = Darg->Hlink; } Fillcode(Ad + Imod(Fidp->Val) - Cad); Item = 0; Value = Ad; Literal--; } void Swop(void) { int Temp; Temp = Item1; Item1 = Item; Item = Temp; Temp = Val1; Val1 = Value; Value = Temp; Temp = Type1; Type1 = Type; Type = Temp; } static const int Intok = 1 << Inty; static const int Charok = 1 << Chary; static const int Boolok = 1 << Booly; static const int Enumok = 1 << Enumy; static const int Realok = 1 << Realy; static const int Stringok = 1 << Stringy; static const int Arrok = 1 << Arry; static const int Setok = 1 << Sety; static const int Recok = 1 << Recy; static const int Pointok = 1 << Pointy; static const int Numok = Intok | Realok; static const int Ordok = Intok | Charok | Boolok | Enumok; static const int Relok = Ordok | Realok | Stringok; void Check1(int Ok) { Cat1 = Category(Type); if (!((unsigned)Ok >> (Cat1 & Cat) & 1)) if (Cat1 == Inty && (Ok & Realok) != 0) { Toreal(); Cat1 = Realy; } else if ((Ok & Stringok) != 0 && Valok(Stringtype, Type) == True) Cat1 = Stringy; else Fault(Typerr + Point); Type1 = Type; Item1 = Item; Val1 = Value; } int Frozenlit(int T, int V) { int Hold; int Res; Hold = Item; Putexp(Move, 0, Litref(V), T); Ditem->Flags = Okflag + Wflag; Ditem->Mode = Constmode; Ditem->Val = V; Res = Item; Item = Hold; return (Res); } void Coerce(int C) { if (C == Inty && Cat1 == Realy) Toreal(); else if (Cat1 == Inty && C == Realy) { if (Item1) { Val1 = Item; Item = Item1; Toreal(); Item1 = Item; Item = Val1; } else *Real(Addr(Val1)) = Val1; Type1 = Realtype; Cat1 = Realy; } else Expfault(Typerr); } void Getarith(int Rank) { Getexpression(Rank, 0); Rank = Category(Type); if (Rank != Cat1) Coerce(Rank); } int Rcond(int Op) { static const int Equal = 0b1001000010; static const int Less = 0b1010000001; static const int Greater = 0b0101000001; int Which; int C; Check1(Relok); Getexpression(Major, 0); C = Category(Type); if (C != Cat1) Coerce(C); if (Equals <= Atom && Atom <= Greater) { if (Double >= 0) Syntaxerror(); Double = Item; } else if (Double < 0) Double = -2; if (!Item1) if (!Item) { if (Size(Type1) > 0 || (Item1 | Val1) == 0 || (Item | Value) == 0) { if (Val1 < Value) Which = Less; else if (Val1 == Value) Which = Equal; else Which = Greater; return ((unsigned)Which >> (Op - Bne) & 1); } Item1 = Frozenlit(Type1, Val1); } else { Swop(); if (Op & 8) Op = Op ^ 3; } return (Op); } int Opval(void) { static int Op_sw; static void *Op[28 /*72:99*/] = { &&Op_72, &&Op_73, &&Op_74, &&Op_75, &&Op_76, &&Op_77, &&Op_78, &&Op_79, &&Op_80, &&Op_81, &&Op_82, &&Op_83, &&Op_84, &&Op_85, &&Op_86, &&Op_87, &&Op_88, &&Op_89, &&Op_90, &&Op_91, &&Op_92, &&Op_93, &&Op_94, &&Op_95, &&Op_96, &&Op_97, &&Op_98, &&Op_99, }; goto *Op[Op_sw = (Atom)-72]; Op_83:; Check1(Numok + Setok); Getarith(Star); if (!Cat1) { if (!Item1) { if (!Item) return (Val1 + Value); Swop(); } if (!(Item | Value)) return (Nop); Type = Inttype; return (Add); } else { if (!Item1) { if (!Item) { *Real(Addr(Val1)) = *Real(Addr(Val1)) + *Real(Addr(Value)); return (Val1); } Swop(); } if (!(Item | Value)) return (Nop); return (Fadd); } Op_84:; Check1(Numok + Setok); Getarith(Star); if (!Cat1) { if (!Item1) { if (!Item) return (Val1 - Value); if (!Val1) { Swop(); return (Neg); } } Type = Inttype; if (!Item) { if (!Value) return (Nop); if (Value != Minint) Value = -Value; return (Add); } return (Sub); } else { if (!Item) { if (!Item1) { *Real(Addr(Val1)) = *Real(Addr(Val1)) - *Real(Addr(Value)); return (Val1); } if (!Value) return (Nop); } return (Fsub); } Op_85:; Check1(Intok); Getexpression(Star, Inttype); if (!Item1) { if (!Item) return (Val1 | Value); Swop(); } if (!(Item | Value)) return (Nop); Type = Inttype; return (Or); Op_86:; Check1(Intok); Getexpression(Star, Inttype); if (!Item1) { if (!Item) return (Val1 ^ Value); Swop(); } if (!(Item | Value)) return (Nop); Type = Inttype; return (Eor); Op_91:; Check1(Intok); Getexpression(Star2, Inttype); if (!Item1) { if (!Item) return (Val1 & Value); Swop(); } if (!(Item | Value)) { Item1 = 0; return (0); } Type = Inttype; return (And); Op_88:; Check1(Numok + Setok); Getarith(Star2); if (!(Item | Value)) { Item1 = 0; return (0); } if (!Cat1) { if (!Item1) { if (!Item) return (Val1 * Value); Swop(); } Type = Inttype; if (!(Control & Halfbit)) return (Imul); return (Muls); } else { if (!Item1) { if (!Item) { *Real(Addr(Val1)) = *Real(Addr(Val1)) * *Real(Addr(Value)); return (Val1); } Swop(); } return (Fmul); } Op_89:; Check1(Intok); Getexpression(Star2, Inttype); if (!Item) { if (!Value) { Fault(Rangerr); return (Nop); } if (!Item1) return (Val1 / Value); } Type = Inttype; return (Idiv); Op_90:; Check1(Realok); Getexpression(Star2, Realtype); if (!Item) { if (!Value) { Fault(Rangerr); return (Nop); } if (!Item1) { *Real(Addr(Val1)) = *Real(Addr(Val1)) / *Real(Addr(Value)); return (Val1); } } return (Fdiv); Op_95: Op_96:; Check1(Intok); Getexpression(Simple, Inttype); if (!Item) { if (!Item1) return (IEXP(Val1, Value)); if (!Value) { Item1 = 0; return (1); } if (Value == 1) return (Nop); if (Value == 2) { Item = Item1; return (Imul); } } Type = Inttype; return (Ipow); Op_93: Op_94: Op_92:; Check1(Realok); Getexpression(Simple, Inttype); Type = Realtype; if (!(Item | Item1)) { *Real(Addr(Val1)) = REXP(*Real(Addr(Val1)), Value); return (Val1); } return (Fpow); Op_98:; Check1(Intok); Getexpression(Simple, Inttype); if (!Item) { if (!Item1) return (Val1 << Value); if (!Value) return (Nop); } Type = Inttype; return (Lsl); Op_99:; Check1(Intok); Getexpression(Simple, Inttype); if (!Item) { if (!Item1) return ((unsigned)Val1 >> Value); if (!Value) return (Nop); } Type = Inttype; return (Lsr); Op_97:; Check1(Intok); Getexpression(Simple, Inttype); if (!Item) return (~Value); Swop(); Type = Inttype; return (Not); Op_87:; Check1(Stringok); Getexpression(Dot + 1, Stringtype); if (!Item) { if (!Item1) { if (!Value) return (Val1); if (!Val1) return (Value); if (Final[Val1] + Final[Value] <= 255) { *String(Final0 + Val1) = _imp_join(*String(Final0 + Val1), *String(Final0 + Value)); Cad--; } else Fault(Rangerr); return (Val1); } if (!Value) return (Nop); } else if (!(Item1 | Val1)) { Item1 = Item; Val1 = Value; Type1 = Type; return (Nop); } Type = Stringtype; return (Concat); Op_77:; return (Rcond(Beq)); Op_78:; return (Rcond(Bne)); Op_79:; return (Rcond(Ble)); Op_80:; return (Rcond(Blt)); Op_81:; return (Rcond(Bge)); Op_82:; return (Rcond(Bgt)); int Racond(int Op) { Toref(); Item1 = Normitem(); Type1 = Type; Getreference(Type1); if (!Item1) { Val1 = 0; Swop(); } if (Arrow <= Atom && Atom <= Greater) Syntaxerror(); Double = -2; return (Op); } Op_75:; return (Racond(Beq)); Op_76:; return (Racond(Bne)); Op_74:; Check1(Stringok); if (!Item1) Item1 = Litref(Val1); Getresolution(Type, Item1); Item1 = Np - 3; Condop = Bne ^ Polarity; Type1 = Booltype; return (Nop); Op_72:; if (!Condop) Topred(); Item1 = Np; Type1 = Booltype; Putact((Condop ^ Polarity ^ 1) + (Polarity << 7), Item, 0); Condop = 0; Getexpression(Scond, Booltype); Dict[Item1].Y = Item; if (A(Keyor) == True) Syntaxerror(); return (Nop); Op_73:; if (!Condop) Topred(); Item1 = Np; Type1 = Booltype; Putact((Condop ^ Polarity) + ((Polarity ^ 1) << 7), Item, 0); Condop = 0; Getexpression(Scond, Booltype); Dict[Item1].Y = Item; if (A(Keyand) == True) Syntaxerror(); return (Nop); } if (Matched) Atom = Nextatom(); Atomp0 = Atomp; Jammy = Jammy << 1; if (Atom == Ident) { Matched = 1; if (Item <= 0 || (Ditem->Mode == Labmode && Item < C.Localdpos)) Nameerror(); if (Item >= Dlim0) Fault(Namerr + Point); Type = Ditem->Type; if (Ditem->Flags & Typeid) if ((Ditem->Flags & Cat) == Recy && Item > Dnil) { Getrecord(); return; } else { Item1 = Item; Ditem1 = Ditem; if (A(Less) == True) { Getvalue(0); Get(Greater); Type = Item1; } else { Get(Left); Getvalue(Inttype); Get(Right); Putexp2(Storemap, Item1, Item1); Ditem->Flags = Writable | Readable; Ditem->Mode = Dispmode; } } else if (Ditem->Mode == Litmode) { Item = 0; Value = Ditem->Val; } else for (;;) if (Ditem->Flags & Proc) if (Item == Daddr || Item == Dsizeof || Item == Dnew) { Get(Left); if (Item == Daddr) { Getreference(0); Type = Inttype; } else { Item1 = Item; Getreference(0); Value = Imod(Size(Type)); if (!Value) Expfault(Sizerr); if (Item1 == Dsizeof) { Item = 0; Type = Inttype; } else { Putexp(Dnew, 0, Litref(Value), 0); Ditem->Mode = Dispmode; } } Get(Right); } else { Getparlist(0); if (!Type) { Atomp = Atomp0; Error(Classerr + Point); } } else { if (Matched) Atom = Nextatom(); if (Aleft > Atom || Atom > Recsub || Rank > Simple) break; if (Atom == Aleft) { do { Item1 = Item; Ditem1 = Ditem; Tp = Typecell(Type); if ((Tp->Flags & Cat) == Stringy) { Matched = 1; Nonstandard(2); Getvalue(Bytetype); Putexp2(Sindex, Item1, Chartype); } else { if ((Tp->Flags & Cat) != Arry) goto Out; Matched = 1; Getvalue(Tp->Xtype); Putexp2(Index, Item1, Tp->Type); } Ditem->Flags = Ditem1->Flags & Heritable; Ditem->Mode = Ditem1->Mode; } while (A(Comma) == True); Ditem->Flags = Ditem->Flags + (Tp->Flags & Name); Get(Right); } else if (Atom == Recsub) { Item1 = Item; Ditem1 = Ditem; Dformat = Typecell(Ditem->Type); if ((Dformat->Flags & Cat) != Recy) Syntaxerror(); Matched = 1; Subbed = 1; Get(Ident); Subbed = 0; if (Item <= 0) Error(Namerr + Point); Val1 = Ditem1->Flags & Heritable | Ditem->Flags; Putexp2(Recref, Item1, Ditem->Type); Ditem->Flags = Val1; Ditem->Mode = Ditem1->Mode; } else if (Atom == Atsign) { Nonstandard(4); if (!(Ditem->Flags & Typeid)) Syntaxerror(); Matched = 1; Ditem1 = Ditem; Item1 = Item; Getexpression(Vsimple, Inttype); Putexp2(Storemap, Item1, Item1); Ditem->Flags = Writable | Readable; Ditem->Mode = Dispmode; } else { if (Ditem->Mode < Dispmode) Error(Nonref + Point); if (!Size(Ditem->Type)) Fault(Sizerr); Matched = 1; Ditem1 = Ditem; Item1 = Item; Getvalue(Inttype); Get(Rightb); Putexp2(Prel, Item1, Ditem1->Type); Ditem->Flags = Writable | Readable; Ditem->Mode = Ditem1->Mode; } } } else if (Atom == Const) Matched = 1; else if (Atom == Minus) { Item = 0; Value = 0; Type = Inttype; } else if (Atom == Left) { Matched = 1; if (Rank < Major) Getexpression(Condq, 0); else Getexpression(Major, 0); Get(Right); } else if (A(Keynot) == True) { if (Rank >= Major) Syntaxerror(); Polarity = Polarity ^ 1; Getexpression(Scond, Booltype); if (!Item) Value = Value ^ 1; Polarity = Polarity ^ 1; } else if (Atom == Backslash) { Item = 0; Value = 0; Type = Inttype; Atom = Tilde; } else if (A(Modsign) == True) { Getexpression(Major, 0); if (Valok(Inttype, Type) == True) if (!Item) { if (Value < 0) if (Value != Minint) Value = -Value; else Expfault(Rangerr); } else Putexp2(Iabs, 0, Inttype); else if (Valok(Realtype, Type) == True) Putexp2(Fabs, 0, Realtype); else Error(Typerr + Point); Get(Modsign); } else Syntaxerror(); Out:; if (Matched) Atom = Nextatom(); if (Etype < 0) { Expp = Atomp0; Jammy = (unsigned)Jammy >> 1; if (Item | Value) { Toref(); if (Refok(Etype - Sign16, Type) != True) Expfault(Typerr); } else { Atomp = Atomp0; Nonstandard(21); } } else { while (Atom >= Rank) { Matched = 1; Double = -1; Op = Opval(); if (!(Item1 | Item)) { if (Double != -1) { if (Double >= 0) { Literal++; Op = Op & Opval(); Literal--; } Type = Booltype; } Value = Op; } else if (Double == -1) if (Op) { if (!Item1) Item1 = Litref(Val1); Putexp(Op, Item1, Normitem(), Type); } else { Item = Item1; Type = Type1; } else { Condop = Op ^ Polarity; Putact(Compare, Item1, Normitem()); Item = Np - 1; if (Double >= 0) { Putact((Condop ^ Polarity ^ 1) + (Polarity << 7), Np - 1, Np + 1); Item = Double; Matched = 1; Op = Opval(); if (!(Item1 | Item)) Error(Nonliteral); Condop = Op ^ Polarity; Putact(Compare, Item1, Normitem()); Item = Np - 2; } Type = Booltype; } } Expp = Atomp0; Jammy = (unsigned)Jammy >> 1; if (Etype) { if (Type == Booltype) if ((Rank == Cond || Rank == Scond) && Condop == 0) Topred(); if (Valok(Etype, Type) != True) Expfault(Typerr); } } if (Literal != 0 && Item != 0) { Atomp = Expp; Error(Nonliteral + Point); } } void Getcondition(void) { int Maxlab; int Condnp; void Assignlabels(int P, int Lab, int Pol) { int Base; Identinfo *Dp; Base = Maxlab; while ((P - Condnp) & 1) { Dp = &Dict[P]; P = Dp->Y; if ((Dp->Act & 1 << 7) == Pol) Assignlabels(Dp->X, Lab, Pol); else { Maxlab = Base + 1; Assignlabels(Dp->X, Maxlab, Pol ^ 1 << 7); } } Dp = &Dict[P + 1]; if (!Dp->Act) Dp = &Dict[P + 3]; if (Maxlab > Base) { Dp->X = Maxlab; Maxlab = Base; } else Dp->X = 0; Dp->Y = Lab; Dp->Act = Dp->Act & 127; } Condnp = Np; Polarity = Subatom; Condop = 0; Getexpression(Cond, Booltype); Putact(Condop ^ 1, Item, 0); if (Faultnum > 0) return; Maxlab = Curlab + 1; Assignlabels(Item, Maxlab, 0); } void Dodynamicarrays(void) { Updatesp(); C.Mode = C.Mode | 0b01000000; C.Status = C.Status | Globbed; while (C.Dynarray) { if (C.Dynarray < 0) Putact(Aget, -C.Dynarray, One); else Putact(Aget, C.Dynarray, 0); C.Dynarray = Dict[Imod(C.Dynarray)].Link; } Compile(Np0); } void Getstatements(int Stopper) { static int Initial_sw; static void *Initial[100 /*0:99*/] = { &&Initial_default, &&Initial_1, &&Initial_2, &&Initial_3, &&Initial_4, &&Initial_5, &&Initial_6, &&Initial_7, &&Initial_8, &&Initial_9, &&Initial_10, &&Initial_11, &&Initial_12, &&Initial_13, &&Initial_14, &&Initial_15, &&Initial_16, &&Initial_default, &&Initial_18, &&Initial_default, &&Initial_default, &&Initial_21, &&Initial_22, &&Initial_23, &&Initial_24, &&Initial_25, &&Initial_26, &&Initial_27, &&Initial_28, &&Initial_29, &&Initial_30, &&Initial_31, &&Initial_32, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_36, &&Initial_default, &&Initial_default, &&Initial_39, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_43, &&Initial_44, &&Initial_45, &&Initial_default, &&Initial_47, &&Initial_48, &&Initial_default, &&Initial_default, &&Initial_51, &&Initial_default, &&Initial_53, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_57, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_63, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_74, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_85, &&Initial_86, &&Initial_default, &&Initial_88, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, }; int Forinf; int Endval; int Loopstart; void Thisisinst(void) { if (C.Status < Hadinst) { C.Status = C.Status + Hadinst; if (!Stopper) Fault(Ordererr); } if (C.Access == 0 && Np == Np0) Fault(Accesserr + Warn); if (C.Dynarray) Dodynamicarrays(); } void Putact2(int Act, int Item1) { Putact(Act, Item1, Normitem()); } void Getresult(void) { Getvalue(C.Type); } void Getinstruction(void) { int Item1; Identinfo *Tp; Thisisinst(); do if (A(Ident) == True) { if (Item <= 0) Nameerror(); if (Ditem->Flags & (Writable | Typeid)) { Matched = 0; Getexpression(Simple, 0); Item1 = Item; if (A(Equals) == True) { Jammy = 0; Getvalue(Type); Putact2(Okass + Jammy, Item1); } else if (A(Eqeq) == True) { if (Ditem->Flags >= 0) Syntaxerror(); Getreference(Type); Putact2(Assign, Item1 + Ad); } else if (Atom == Less && *Byteinteger(Fp) == '-') { Fp++; Matched = 1; Jammy = 1; Getvalue(Type); Putact2(Jamass + Jammy, Item1); } else { if (A(Arrow) != True) Syntaxerror(); Getresolution(Type, Item1); Putact(Bne, 0, Curlab); Putact(Signal, Litref(7), Undef); Putact(0, Undef, Undef); } } else { if (!(Ditem->Flags & Proc)) Error(Classerr + Point); Tp = Typecell(Ditem->Type); if (Tp->Type) { Getparlist(Tp->Type); Putact2(Assign, Value); } else Getparlist(0); } } else { if (Np == Np0) C.Access = 0; if (A(Keymonitor) == True) { C.Access = 1; } else if (A(Exit) == True) { if (!C.Looplab) Fault(Notinloop + Point); else Putact(Jumpout, C.Looplab, C.Looplab + Subatom); break; } else if (A(Keyreturn) == True) { Item = 0; Value = 0; if (C.Type) Getresult(); Putact2(Return, 0); break; } else if (A(Keyresult) == True) { if (!C.Type) Error(Notinfun + Point); if (Aassop(C.Type) != True) Syntaxerror(); Getresult(); Putact2(Return, 0); break; } else if (A(Tf) == True) { if (C.Type != Booltype) Fault(Notinpred + Point); else Putact(Return, 0, Litref(Subatom)); break; } else if (A(Arrow) == True || A(Keygoto) == True) { if (Atom == Keygoto) Nonstandard(5); Get(Ident); if (*Byteinteger(Fp) != '(') { if (Item < C.Localdpos || Ditem->Type != 0) Declare(Forwardlabel); Putact2(Goto, 0); } else { if (Item < C.Localdpos) Nameerror(); if (Ditem->Mode != Labmode || Ditem->Type == 0) Error(Classerr + Point); Item1 = Item; Get(Left); Getvalue(*Typecell(Ditem->Type)(Ditem->Type).Xtype); Get(Right); Putact2(Swgoto, Item1); } break; } else if (A(Keystop) == True) { Putact(Stop, 0, 0); break; } else if (A(Keysignal) == True) { C.Access = 1; Allow(Keyevent); Getliteral(Inttype); if (0 > Value || Value > 15) Expfault(Rangerr); Item1 = Litref(Value); Item = Undef; if (A(Comma) == True) { L1: if (A(Comma) == True) Matched = 0; else Getvalue(Bytetype); } Putact2(Signal, Item1); Item = Undef; if (A(Comma) == True) { L2: if (A(Comma) == True) Matched = 0; else Getvalue(Inttype); } Item1 = Normitem(); Item = Undef; if (A(Comma) == True) Getvalue(Stringtype); Putact2(0, Item1); break; } else Syntaxerror(); } while (A(Keyand) == True); } void Getforclause(void) { int Loopvar; int Lvtype; int K; int S; int Start; int Sval; int I; int Inc; int Ival; int E; int N; int End; Identinfo *Tp; Forinf = 0; Get(Ident); if (Item <= 0) Nameerror(); Lvtype = Ditem->Type; Tp = Typecell(Lvtype); if (Tp->Flags & Nonord) Fault(Typerr + Point); Loopvar = Item; Get(Equals); Getvalue(Lvtype); Start = Item; Sval = Value; Get(Comma); Getvalue(Lvtype); Inc = Item; Ival = Value; if (Inc == 0 && 0 == Ival) { Expfault(Rangerr); Ival = 1; } K = Undef; if (Start >= Np0 && Dict[Start].Act == Add) K = Dict[Start].Y; if (!Inc) { I = Litref(Ival); if (!Start) { Sval -= Ival; Item = Litref(Sval); } else if (K <= 0) { K = Litval(K) - Ival; Item = Dict[Start].X; if (K) Putexp(Add, Item, Litref(K), Inttype); } else Putexp(Add, Start, Litref(-Ival), Inttype); } else { I = Inc; if (Control & Volbit) { Declaretemp(Inttype); I = Item; Putact(Assign, I, Inc); Forinf -= 4; } if (Start == Inc) { Item = 0; Sval = 0; } else if (K == Inc) Item = Dict[Start].X; else { Item = Start; if (!Item) Item = Litref(Sval); Putexp(Sub, Item, I, Inttype); } } S = Item; Get(Comma); Getvalue(Lvtype); End = Item; if (!End) { E = Litref(Value); Endval = Value; } else { E = Item; if (Control & Volbit) { Declaretemp(Inttype); E = Item; Putact(Assign, E, End); Forinf -= 4; } } if ((Start | Inc | End) != 0 && (Control & Loopbit) != 0) { Putact(Forass, Loopvar, S); Putact(Forass, I, E); } else Putact(Assign, Loopvar, S); Putact(Label, Curlab, 0); if (!(Start | Inc | End)) { K = Endval - Sval; N = K / Ival; if (!N) { Fault(Dubious + Warn); Putact(Else, 0, Curlab + 1); return; } if (N < 0) Fault(Boundserr); if (N * Ival != K) Fault(Unending); Forinf = Loopvar; } else { Putact(Compare, Loopvar, E); Putact(Beq, 0, Curlab + 1); } Putact(Incass, Loopvar, I); } void Getloopbody(void) { int Hold; Hold = C.Looplab; C.Looplab = Curlab; Curlab += 2; Getstatements(Keyrepeat); Curlab -= 2; C.Looplab = Hold; } void Getswitchindex(void) { int I; int Lo; int Hi; Identinfo *Dp; Identinfo *Tp; void Setlabel(short *P) { Value = *P; if (Value > 0) Expfault(Duperr); Setuserlabel(Value); *P = Value; } Dp = Ditem; Tp = Typecell(Ditem->Type); Get(Left); if (A(Star) == True) Setlabel(Dp->Link); else { Getvalue(Tp->Xtype); if (Tp->Xtype > Inttype && Faultnum == 0) { Getbounds(Tp->Xtype, Lo, Hi); I = Value - Lo + Dp->Val; if (I < Pc) C.Forward = C.Forward - 1; Setlabel(Prog[I]); } } Get(Right); } if (_imp_on_event(1, 11, 12)) { if (!Event.Event()) { if (Event.Sub) exit(0); _imp_signal(14, 0, 0, _imp_str_literal("")); } if (Event.Event() == Done) { if (Stopper) Croak(_imp_str_literal("Premature end of input")); Closeblock(); C.Dpid = 0; return; } if (Event.Event() == Oflow) Fault(Rangerr + Now); goto Ignore; } Next:; Statements++; if (Np > Np0) Compile(Startnp); if (Dict[Curlab].Val < 0) Definelabel(Curlab); if (Dict[Curlab + 1].Val < 0) Definelabel(Curlab + 1); Next1:; if (Faultnum) Report(Faultnum, 0, 0); Dlim0 = Dlim; Speccing = 0; Subbed = 0; Literal = 0; Jammy = 0; Condop = 0; Dict[Curlab].Val = 0; Dict[Curlab + 1].Val = 0; Np = Np0; Startnp = Np0; Maxcalldreg = Maxdreg; Maxcallareg = Maxareg; if (Explo < Np0 + 50) { Zaps++; Forgetall(); } if (Litpos > Litmax - 40) { Zaps += 1000; Forgetall(); } Value = 0; Initial_51:; Atom = Nextatom(); Matched = 1; goto *Initial[Initial_sw = Atom]; Initial_45: Initial_85: Initial_86:; Comments++; Readline(0); goto Next1; Term:; Get(Terminator); goto Next; Ignore:; C.Access = -1; if (Atom != Terminator) { do { Subatom = Atom; Atom = Nextatom(); } while (Atom != Terminator); if (Subatom == Keystart) Starts++; if (Subatom == Keycycle) Cycles++; } goto Next1; Initial_63:; Syntaxerror(); Initial_default:; Error(Nonstarter + Point); Initial_53:; if (*Byteinteger(Fp) == ':') { Fp++; Declare(Definedlabel); Setuserlabel(Ditem->Val); goto Next; } if (Item <= 0) Nameerror(); if (Ditem->Mode == Labmode && Ditem->Type != 0) { Literal = 1; Getswitchindex(); Get(Colon); goto Next; } Initial_7: Initial_9: Initial_8:; Initial_10: Initial_12: Initial_13:; Initial_6: Initial_11: Initial_74:; Matched = 0; Getinstruction(); if (A(Terminator) == True) goto Next; C.Access = 1; if (A(Iu) == True) { Startnp = Np; Getcondition(); } else if (A(Keywhile) == True) { Putact(Repeat, Curlab, 0); Startnp = Np; Definelabel(Curlab); Getcondition(); } else if (A(Keyfor) == True) { Putact(0, 0, 0); Putact(0, 0, 0); Putact(Repeat, Curlab, 0); Startnp = Np; Getforclause(); Value = Np; Np = Startnp - 3; if (Forinf > 0) { Putact(Compare, Forinf, Litref(Endval)); Putact(Beq, 0, Curlab); } else Np += 2; Putact(Repeat, Curlab, Forinf); Np = Value; } else { if (A(Keyuntil) != True) Syntaxerror(); Getcondition(); Putact(Repeat, Curlab, 0); Definelabel(Curlab); } goto Term; Initial_15:; Thisisinst(); do { Getcondition(); if (A(Keythen) == True && A(Keystart) != True) Getinstruction(); else { Matched = 0; Get(Keystart); for (;;) { Get(Terminator); Curlab += 2; Getstatements(Keyelse); Curlab -= 2; if (Atom != Keyelse) break; Putact(Else, Curlab + 1, Curlab); if (A(Iu) != True) goto Exit2; Getcondition(); } if (Atom == Keyend) goto *Initial[Initial_sw = Keyend]; } if (A(Keyelse) != True) goto Term; Putact(Else, Curlab + 1, Curlab); } while (A(Iu) == True); if (A(Keystart) != True) Getinstruction(); else { Exit2:; Get(Terminator); Curlab += 2; Getstatements(Keyfinish); Curlab -= 2; if (Atom == Keyend) goto *Initial[Initial_sw = Keyend]; } goto Term; Initial_21:; Thisisinst(); if (A(Terminator) == True) { Definelabel(Curlab); Getloopbody(); if (Atom == Keyend) goto *Initial[Initial_sw = Keyend]; if (A(Keyuntil) == True) Getcondition(); Putact(Repeat, Curlab, 0); goto Term; } Nonstandard(22); Getforclause(); goto For1; Initial_16:; Thisisinst(); Definelabel(Curlab); Getcondition(); Get(Keycycle); Get(Terminator); Compile(Np0); Getloopbody(); if (Atom == Keyend) goto *Initial[Initial_sw = Keyend]; if (A(Keyuntil) == True) { Nonstandard(6); Getcondition(); } Putact(Repeat, Curlab, 0); goto Term; Initial_18:; Thisisinst(); Getforclause(); Get(Keycycle); For1:; Get(Terminator); Compile(Np0); if (Forinf > 0) { Loopstart = Dict[Curlab].Val; Dict[Curlab].Val = 0; } Getloopbody(); if (Atom == Keyend) goto *Initial[Initial_sw = Keyend]; if (Forinf > 0) { Definelabel(Curlab); Dict[Curlab].Val = Loopstart; Putact(Compare, Forinf, Litref(Endval)); Putact(Beq, 0, Curlab); } Putact(Repeat, Curlab, Forinf); goto Term; Initial_14:; if (C.Status >= Hadon || Stopper == 0) Fault(Ordererr + Point); if (C.Dynarray) Dodynamicarrays(); C.Status = C.Status | Hadon; Matched = 1; Allow(Keyevent); Dump = 0; do { Getliteral(Inttype); if (0 > Value || Value > 15) Expfault(Rangerr); Dump = Dump | 1 << Value; } while (A(Comma) == True); Get(Keystart); Putact(Settrap, 0, Litref(Dump)); Curlab += 2; Getstatements(Keyfinish); Curlab -= 2; if (Atom == Keyend) goto *Initial[Initial_sw = Keyend]; goto Term; Initial_4:; if (Starts) goto Ignore; if (Stopper == Keyelse) return; if (Stopper == Keyfinish) Error(Noif); Initial_3:; if (Starts) { Starts--; goto Ignore; } if (Stopper == Keyfinish || Stopper == Keyelse) return; Error(Nostart); Initial_2:; if (Cycles) { Cycles--; goto Ignore; } if (Stopper == Keyrepeat) return; Error(Nocycle); Initial_88:; if (!(Control & Lowbit)) { Fault(Lowlevel + Warn + Point); Control = Control | Lowbit; } Matched = 1; if (*Byteinteger(Fp) == '=') { Fp++; Getliteral(Inttype); Plant(Dc, 0, Temp(Absmode, Value)); } else Getmcode(); goto Term; void Declarelitrange(int Basetype, int Lo, int Hi) { static Objinfo D = 0; if (Lo > Hi) { Fault(Boundserr); Hi = Lo; } Item = Ranges; do { Ditem = &Dict[Item]; if (Ditem->Val == Hi && Ditem->Type == Basetype && Dict[Item - 1].Val == Lo) { Item -= 2; return; } Item = Ditem->Hlink; } while (Item); Declareanon(D); Declarerange(Basetype, Lo, Hi); } void Declarestringtype(int Size) { if (Size == -256) { Item = Stringtype; return; } if (Size == -2) { Item = String1; return; } Item = Ranges; do { Ditem = &Dict[Item]; if (Ditem->Size == Size && Ditem->Type == Chartype) return; Item = Ditem->Hlink; } while (Item); Declareanon(*Details(Typeid + Stringy, Chartype, 0, 0)); Ditem->Size = Size; Ditem->Hlink = Ranges; Ranges = Item; } void Getlitrange(int Basetype) { int Holdval; Getliteral(Basetype); Holdval = Value; Get(Colon); Getliteral(Basetype); Declarelitrange(Basetype, Holdval, Value); } void Getidentlist(Objinfo * D) { Dlim0 = Dlim; do { Get(Ident); Declare(*D); } while (A(Comma) == True); } void Recalign(int *Val) { Align(*Val, 2); if (*Val > 4) *Val = -*Val; } void Getdeclaration(int Flags, int Mode, int *Disp, int Depth) { Objinfo Decl; Identinfo *Dfhold; static int Itemtype = 0; static int Itemsize = 0; static int Adim = 0; int Base; int Hold; int Max; int Stmax; int Dreg; int Areg; auto void Getvarbound(void); void Getdatatype(void) { static int S_sw; static void *S[7 /*27:33*/] = { &&S_27, &&S_28, &&S_29, &&S_30, &&S_31, &&S_32, &&S_33, }; if (Matched) Atom = Nextatom(); if (Kattrib > Atom || Atom > Keyname) Syntaxerror(); Matched = 1; goto *S[S_sw = (Atom)-27]; S_27:; Itemtype = Inttype + Subatom; Itemsize = Size(Itemtype); if (Itemtype >= Mitetype) Nonstandard(7); Allow(Keyinteger); return; S_28:; Itemtype = Inttype; Itemsize = 4; if (A(Left) == True) { Nonstandard(8); Getlitrange(Inttype); Get(Right); Itemtype = Item; Itemsize = *Typecell(Itemtype)(Itemtype).Size(); } return; S_29:; Itemtype = Inttype; Itemsize = 4; if (A(Keyinteger) == True) Fault(Notin + Point + Warn); else { Itemtype = Realtype; Get(Keyreal); } return; S_30:; Itemtype = Realtype; Itemsize = 4; return; S_31:; Itemsize = 0; if (A(Left) == True) { Atom = Nextatom(); if (A(Star) == True) Itemtype = Stringstar; else { Getliteral(Bytetype); Itemsize = -(Value + 1); Declarestringtype(Itemsize); Itemtype = Item; } Get(Right); } else { if (Mode != Constmode) Syntaxerror(); Itemtype = Stringtype; } return; S_32:; Get(Left); if (A(Star) != True) { if (A(Ident) != True) { Declareanon(Typeident); Hold = Item; Dfhold = Dformat; Dformat = Ditem; Getdeclaration(Writable + Readable, 0, Dformat->Val, 0); Recalign(Dformat->Val); Ditem = Dformat; Dformat = Dfhold; Item = Hold; } if (Item <= 0) Nameerror(); if ((Ditem->Flags & (~Spec)) != Typeid + Recy) Error(Classerr + Point); Itemtype = Item; Itemsize = Ditem->Val; } else { Itemtype = Recstar; Itemsize = 0; } Get(Right); return; S_33:; Itemtype = 0; Matched = 0; } void Assignaddress(int Size) { void Assignstackaddress(void) { Align(Stmax, 2); Ditem->Val = Stmax; Stmax += Imod(Size); if (Depth == 1 && Speccing == 0) C.Status = C.Status | Onstack; } if (Ditem->Flags & (Name + Indirect)) Size = -4; if (Depth) { Dlink->Link = Item; Dlink = Ditem; if (Size > 0) { if (Dreg > Maxcalldreg) { Assignstackaddress(); return; } if (!Speccing) C.Reg.Content = Item; Ditem->Reg = Dreg - D0; Dreg++; } else { if (Areg > Maxcallareg) { Assignstackaddress(); Ditem->Reg = 8; return; } if (Speccing == 0 && Ditem->Flags < 0) C.Reg.Content = Item + Ad; Ditem->Reg = Areg - D0; Areg++; } } Size = Imod(Size); Align(*Disp, Size); Ditem->Val = *Disp; if (Constmode != Ditem->Mode && Ditem->Mode != Ownmode) { *Disp = *Disp + Size; if (Ditem->Mode >= Framemode) { Align(*Disp, 2); Ditem->Val = C.Sp - *Disp; } } } void Getqident(void) { Get(Ident); if (!Mode) { Head = &Dformat->Link; Item = *Head; if (Item > 0) do { Ditem = &Dict[Item]; if (*String(Ditem->Text + Char0) == *String(Charlim)) Fault(Duperr + Point); Head = &Ditem->Hlink; Item = *Head; } while (Item > 0); } Declare(Decl); } void Dumpconst(int V, int N) { int I; int J; int K; int Kk; int Vv; K = Itemsize; if (K <= 0) { K = -K; if (!K) K = Final[V] + 1; if (V) Cad = V; } Kk = K; if (N < 1) return; if (N > 1) Kk = Kk * N; if (Mode == Constmode) { I = Cad; Cad += Kk; if (Cad >= Ownbase) Croak(_imp_str_literal("Program too big")); } else { if (Ownbase + Ownad + Kk - Finalbound > 0) Makeroom(Ownbase + Ownad + Kk - Finalbound); I = Ownbase + Ownad; Ownad += Kk; } if (Itemsize <= 0) while (N > 0) { N--; J = I + K; if (V) { Vv = V; do { Final[I] = Final[Vv]; I++; Vv++; } while (I != J); } else while (I < J) { Final[I] = 0; I++; } } else while (N > 0) { N--; if (Itemsize >= 2) { if (Itemsize > 2) { Final[I] = (unsigned)V >> 24; Final[I + 1] = (unsigned)V >> 16; I += 2; } Final[I] = (unsigned)V >> 8; I++; } Final[I] = V; I++; } } void Getvarbound(void) { int F; F = Decl.Flags; Getdatatype(); Decl.Flags = Okflag + Mflag; Decl.Type = Itemtype; Get(Ident); Declare(Decl); Decl.Flags = F; Assignaddress(Itemsize); } void Declarebound(int Mode, int Val) { Declareanon(*Details(Okflag, Inttype, Mode, Val)); if (Depth != 0 && Mode >= Framemode) { Ditem->Flags = Ditem->Flags | Mflag; Assignaddress(4); } } void Getarraydeclaration(int Dim) { int Pos; int Dlim1; int Holdval; int Holdz; int Jam; int Elements; int Tot; int Totsize; int Lo1; int Size1; Identinfo *Dp; static Objinfo Atype = 0; int Xtype(void) { Declareanon(*Details(Typeid, Inttype, 0, 0)); return (Item); } void Stringstararray(void) { if (!Depth) Fault(Notin + Point); Declareanon(*Details(Okflag + Mflag + Inty, Inttype, Mode, 0)); Tot = Item; Assignaddress(4); Declareanon(*Details(Typeid + Stringy, Inttype, 0, 0)); Atype.Type = Item; Elements = Maxint; } void Getrest(void) { int E; int R; int Lo; int Loval; int Hi; int Hival; R = 0; if (Matched) Atom = Nextatom(); if (Decl.Flags < 0) if (Depth > 0 && Ktype <= Atom && Atom <= Keyinteger) { R = Xtype(); Getvarbound(); } else Getliteral(Inttype); else Getvalue(Inttype); Loval = Value; Lo = Item; if (Lo) Loval = Minint; Get(Colon); if (Matched) Atom = Nextatom(); if (Decl.Flags < 0) if (Depth > 0 && Ktype <= Atom && Atom <= Keyinteger) { if (!R) { R = Xtype(); Declarebound(Litmode, Loval); } Getvarbound(); } else if ((Dim | R) == 0 && A(Star) == True) { Item = 0; Value = Maxint; } else { Getliteral(Inttype); if (R) Declarebound(Litmode, Value); } else Getvalue(Inttype); Hival = Value; Hi = Item; if (Hi) Hival = Maxint; E = Maxint; if (!R) { if (!(Lo | Hi)) { if ((Hival ^ Loval) >= 0 || Minint + Hival - Loval < 0) E = Hival - Loval; if (E != Maxint) E++; if (Hival == Maxint) E = 0; Declarelitrange(Inttype, Loval, Hival); } else { Declareanon(Typeident); Declarerange(Inttype, Loval, Hival); } R = Item; } Elements = E; if (A(Comma) == True) { Dim++; Getrest(); if (Elements != Maxint && E != Maxint) Elements = Elements * E; else Elements = Maxint; } Atype.Xtype() = R; Size1 = Totsize; Lo1 = Loval; if (Atype.Type == Stringstar) Stringstararray(); if (Elements == Maxint) { Atype.Mode = Mode; Declareanon(Atype); Atype.Type = Item; if (Decl.Flags >= 0 || (Depth == 1 && Speccing == 0)) { if (!Lo) Lo = Litref(Loval); if (!Hi) Hi = Litref(Hival); if (!Tot) Tot = Litref(Totsize); Putact(Asize, Item, Tot); Putact(0, Lo, Hi); if (Decl.Flags >= 0) { Compile(Np0); if (Lo > 0) { Dict[R + 1].Mode = C.Mode; Dict[R + 1].Val = C.Sp + 4; } if (Hi > 0) { Dict[R + 2].Mode = C.Mode; Dict[R + 2].Val = C.Sp; } } } Tot = 0; Totsize = 0; } else { Item = 0; for (;;) { Ditem = &Dict[Item]; if (Ditem->Type == Atype.Type && Ditem->Xtype() == Atype.Xtype() && Ditem->Flags == Atype.Flags) break; Item++; if (Item == Dlim) { Declareanon(Atype); break; } } Atype.Type = Item; Totsize = Totsize * E; } } void Putbounds(void) { int I; I = Xtype(); Declarebound(Mode, 0); Declarebound(Mode, 0); Dim--; if (Dim > 0) Putbounds(); if (Atype.Type == Stringstar) Stringstararray(); Atype.Xtype() = I; Declareanon(Atype); if (!Speccing) { if (!Tot) Tot = Litref(Totsize); Putact(Asize, Item, Tot); Putact(0, I + 1, I + 2); } Tot = 0; Totsize = 0; Lo1 = Minint; Atype.Type = Item; } Pos = Dlim0; Dlim1 = Dlim; Dp = Ditem; Atype.Flags = Typeid + Arry + Okflag; Atype.Type = Itemtype; if (Atype.Type < 0) { Atype.Flags = Atype.Flags + Name; Atype.Type = Atype.Type - Name; } Atype.Mode = Constmode; Tot = 0; Totsize = Imod(Itemsize); if (Dim > 0) { Atype.Mode = Mode; Putbounds(); Elements = Maxint; } else { Getrest(); Get(Right); } Dp->Type = Atype.Type; if (Mode != Constmode && Mode != Ownmode) { Holdval = D0; while (Pos != Dlim1) { Dp = &Dict[Pos]; Dp->Type = Atype.Type; if (Mode >= Framemode) { if (Lo1 == Minint || Size1 == 0) Dp->Flags = Dp->Flags | Arrflag; if (Decl.Flags >= 0) { if (Totsize != 0 && (Totsize << 1) - C.Sp + *Disp <= 32000) { *Disp = *Disp + Totsize; Align(*Disp, 2); } else { if (C.Mode & 0b01000000) Fault(Ordererr); if (Totsize) { C.Extra = C.Extra + Totsize; Holdval = Litref(Totsize); } Holdz = 0; if (!(Dp->Flags & Arrflag)) Holdz = Litref(-Lo1 * Size1); Putact(Adok, Holdval, Holdz); Compile(Np0); Dp->Flags = Dp->Flags + Indirect; Dp->Link = C.Dynarray; C.Dynarray = Pos; if (Holdz) C.Dynarray = -C.Dynarray; C.Status = C.Status | Unknown; Holdval = 0; } Dp->Val = C.Sp - *Disp; } } else { Dp->Val = *Disp; if (Decl.Flags < 0) *Disp = *Disp + 4; else *Disp = *Disp + Totsize; } Pos++; } } else if (Decl.Flags & (Name + Indirect)) if (Mode == Constmode) Fillcode(4); else Fillown(4); else { if (Aassop(Itemtype) == True) { Jam = Jammy; Dp->Flags = Dp->Flags | Okflag; Allow(Terminator); do { Jammy = Jam; Getvalue(Itemtype); if (Faultnum == Rangerr + Point) Faultnum = Rangerr + Point + Warn; Holdval = Value; Value = 1; if (A(Left) == True) { Value = Elements; if (A(Star) != True) Getliteral(Halftype); Get(Right); } Elements -= Value; if (Elements < 0) Value += Elements; Dumpconst(Holdval, Value); } while (A(Comma) == True); if (Faultnum == 0 && Elements != 0) if (Elements < 0) Report(Counterr, Pos, Elements); else Report(Counterr + Warn, Pos, Elements); } if (Elements > 0) Dumpconst(0, Elements); } } void Getproceduredeclaration(void) { int Pos; int Dlim1; int Argmode; int Argad; int Restype; int Stack; Identinfo *Headditem; Identinfo *Dhold; int Dupok(void) { Identinfo *Tp; if (!(Ditem->Flags & Proc)) return (False); Tp = Typecell(Ditem->Type); if (!Restype) { if (Tp->Type != 0 || Tp->Link == 0) return (False); } else { if (Restype == Tp->Type) return (False); } return (True); } Restype = Itemtype; Stack = 0; Decl.Flags = Decl.Flags & (~Okflag); Decl.Type = Procstar; if (Depth) { Decl.Flags = Decl.Flags | Proc2; } else if (Mode >= Framemode) { Decl.Mode = Procmode; Decl.Val = 0; Decl.Flags = Decl.Flags | Proc1; if (A(Keyspec) == True) Decl.Flags = Decl.Flags | Spec; } else if (Mode == Ownmode) { Decl.Mode = Procmode; Decl.Val = 0; if (A(Keyspec) == True) { Decl.Mode = Ownmode; Decl.Flags = Decl.Flags | Spec; } } else { Decl.Flags = Decl.Flags | Proc1; Decl.Val = *Disp; Stack = 4; } if ((Decl.Flags & Ext) != 0 && A(Keyalias) == True) { Nonstandard(9); Get(Ident); if (Item <= 0) Fault(Namerr + Point); else if (Dupok() == True) { Item = 0; Decl.Flags = Decl.Flags | Alt; } } else Get(Ident); Declare(Decl); Headditem = Ditem; if (Depth) Assignaddress(-6); Argmode = (C.Mode & (~0b01000000)) + 1; if ((Decl.Flags & Spec) != 0 || Decl.Mode != Procmode) Speccing++; else { if (Ditem->Flags & Rflag) C.Forward = C.Forward - 1; Openblock(Item); C.Type = Restype; if (Decl.Flags & Writable) C.Type = C.Type | Sign16; } Dlim1 = Dlim; Declareanon(*Details(0, Restype, 0, Stack)); if ((Decl.Flags & Writable) != 0 || Size(Restype) <= 0) Ditem->Reg = 8; Argad = C.Sp; if (A(Left) == True) { Dhold = Dlink; Dlink = Ditem; Getdeclaration(Okflag + Writable + Readable, Argmode, Argad, 1); Dlink = Dhold; Get(Right); } if (Speccing) { Speccing--; Pos = Crunched(Dlim1); if (Pos < Dlim1 || Speccing == 0) Headditem->Type = Pos; else { Fault(Classerr); Dlim = Dlim1; } } else { if (C.Dpid & Spec) { C.Dpid = C.Dpid - Spec; if (Parmatch(C.Dpid, Dlim1) != True) if (C.Pid == Dlim1 - 2) Fault(Matcherr + Warn); else Fault(Matcherr); } Headditem->Type = Dlim1; C.Parlim = Dlim; C.Sp = -Argad; Compile(Np0); Get(Terminator); Getstatements(Keyend); } } void Getinitialvalue(Identinfo * Dp) { int Present; Present = 0; Jammy = 0; if (Aassop(Itemtype) == True) { Getvalue(Itemtype); Dp.Flags = Dp.Flags | Okflag; Present = 1; } if (Mode >= Framemode) { if (Present) { if (Item) { Atomp = Expp; Nonstandard(1); } if (Itemtype < 0) Putact(Okass, Dlim0 + Ad, Normitem()); else Putact(Okass + Jammy, Dlim0, Normitem()); Compile(Np0); } } else if (Mode == Constmode) { if (!Present) Syntaxerror(); if (Itemtype < 0) { Dp.Flags = Writable + Readable; Dp.Mode = Absmode; Dp.Val = Value; } else { if (Faultnum == Rangerr + Point) Faultnum = Rangerr + Point + Warn; if (Itemsize <= 0) Dumpconst(Value, 1); else { Dp.Mode = Litmode; Dp.Val = Value; } } } else if (Present) { if (Faultnum == Rangerr + Point) Faultnum = Rangerr + Point + Warn; Dumpconst(Value, 1); } else if (Itemtype < 0) Fillown(4); else Fillown(Imod(Itemsize)); } Dreg = D0; Areg = A0; Stmax = 8; Max = 0; Base = *Disp; do { *Disp = Base; for (;;) { Decl = 0; Decl.Flags = Flags; Decl.Mode = Mode; Adim = -1; while (A(Kattrib) == True) Decl.Flags = Decl.Flags ^ (1 << Subatom); if (Depth == 0 && A(Left) == True) { Align(*Disp, 2); Getdeclaration(Flags, Mode, *Disp, 0); Get(Right); } else if (A(Rpred) == True) { if (Subatom) { Decl.Flags = Decl.Flags & (~(Writable)); if (Control & Volbit) Decl.Flags = Decl.Flags | Volatile; Itemtype = Booltype; } else { Decl.Flags = Decl.Flags & (~(Writable + Readable)); Itemtype = 0; } Getproceduredeclaration(); if (!Depth) return; } else { Getdatatype(); if (A(Fnmap) == True) { if (Control & Volbit) Decl.Flags = Decl.Flags | Volatile; if (!Subatom) { Decl.Flags = Decl.Flags & (~Writable); if (!Itemsize) Fault(Illstarred); } Getproceduredeclaration(); if (!Depth) return; } else { Decl.Flags = Decl.Flags & (~Proc); Decl.Type = Itemtype; if (A(Keyname) == True) { Decl.Flags = Decl.Flags + Name; Itemtype += Name; Itemsize = 4; } if (A(Keyarray) == True) { if (Itemtype == Recstar) Fault(Illstarred); Adim = 0; Decl.Flags = Decl.Flags & (~Name); Decl.Type = Arrstar; if (Control & Arrbit) Decl.Flags = Decl.Flags | Arrflag; if (A(Left) == True) { if (!Depth) Fault(Notin + Point); Getliteral(Inttype); if (Value & (~7)) Expfault(Rangerr); else Adim = Value; Get(Right); Get(Keyname); Matched = 0; } if (A(Keyname) == True) Decl.Flags = Decl.Flags + Name; } if (Itemsize == 0 && Decl.Flags >= 0 && Disp != &Jokerad && Decl.Type != Stringtype) Fault(Illstarred); if (Disp == &C.Val) { if (!Stopper) Fault(Notinblock); if (C.Status >= Hadon) if ((C.Forward | C.Return) != 0 || Curlab != C.Lab1) Fault(Ordererr); else if (!(C.Status & Hadordererr)) { Fault(Ordererr + Warn); C.Status = C.Status + Hadordererr; } } else if ((Decl.Flags & Ext) != 0 && A(Keyspec) == True) Decl.Flags = Decl.Flags | (Spec + Indirect); do { Dlim0 = Dlim; if (Decl.Type != Arrstar) { Getqident(); Assignaddress(Itemsize); if (Mode >= Ownmode && Depth == 0) if (!(Decl.Flags & Spec)) Getinitialvalue(*Ditem); else { Setownword(0); Setownword(0); } } else { for (;;) { Getqident(); Assignaddress(0); if (A(Comma) != True) break; Atom = Nextatom(); if (Atom != Ident) { if (!Adim) { if (Decl.Flags >= 0) Syntaxerror(); Adim = 1; } Getarraydeclaration(Adim); goto Exit22; } } if (Adim != 0 || A(Left) != True) { if (!Adim) { if (Decl.Flags >= 0) Syntaxerror(); Adim = 1; } Getarraydeclaration(Adim); goto Exit2; } Getarraydeclaration(Adim); } if (A(Comma) != True) goto Exit2; Atom = Nextatom(); } while (Atom == Ident); Exit22:; continue; } } if (A(Comma) != True) break; } Exit2:; if (*Disp > Max) Max = *Disp; } while (A(Keyor) == True); *Disp = Max; } Initial_23:; Literal = 1; Getdeclaration(Okflag + Readable, Constmode, Cad, 0); goto Term; Initial_57:; Dump = 0; Atted:; if (!(Control & Lowbit)) { Fault(Lowlevel + Warn + Point); Control = Control | Lowbit; } Getliteral(Inttype); Jokerad = Value; if (A(Left) == True) { Getmident(A0, A7); Get(Right); Value = Item + (Dispmode - A0); } else Value = Absmode; Literal = 1; Getdeclaration(Dump | (Okflag + Writable + Readable), Value, Jokerad, 0); goto Term; Initial_24:; Literal = 1; Getdeclaration(Writable + Readable, Ownmode, Ownad, 0); goto Term; Initial_25:; if (Level) Fault(Ordererr); Literal = 1; Dump = Subatom << 12; if (A(Atsign) == True) goto Atted; if (A(Left) == True) { Getliteral(Inttype); Get(Right); Maxcalldreg = (D0 - 1) + (Value & 15); Maxcallareg = (A0 - 1) + ((unsigned)Value >> 4 & 15); Dump = Dump ^ (Value & (~255)); } Getdeclaration(Dump | (Writable + Readable), Ownmode, Ownad, 0); goto Term; Initial_32:; if (A(Left) != True) { Get(Keyformat); if (A(Keyspec) == True) { Typeident.Flags = Typeid + Spec + Recy; Get(Ident); Declare(Typeident); } else { Typeident.Flags = Typeid + Recy; Get(Ident); Declare(Typeident); Get(Left); Dformat = Ditem; Getdeclaration(Writable + Readable, 0, Dformat->Val, 0); Recalign(Dformat->Val); Get(Right); } goto Term; } Fp--; Atom = Keyrecord; Initial_27: Initial_29:; Initial_28: Initial_30:; Initial_26: Initial_31:; Initial_36:; Matched = 0; Getdeclaration(Writable + Readable, C.Mode, C.Val, 0); goto Term; Initial_22:; Getidentlist(Forwardlabel); goto Term; void Getswitchdeclaration(void) { int I; int Lo; int Hi; int Dlim1; static Objinfo D = 0; Matched = 1; do { D.Type = Arrstar; if (Control & Arrbit) D.Flags = D.Flags + Arrflag; D.Mode = Labmode; Getidentlist(D); Dlim1 = Dlim; Declareanon(*Details(Typeid + Arry, 0, 0, 0)); Get(Left); Getlitrange(Inttype); Get(Right); Dict[Dlim1].Xtype = Item; Getbounds(Item, Lo, Hi); do { for (I = Lo; I <= Hi; I++) { Swpc--; Prog[Swpc] = 0; if (Swpc <= Pc) Croak(_imp_str_literal("Code space exhausted")); } Dict[Dlim0].Val = Swpc; Dict[Dlim0].Type = Dlim1; Dlim0++; } while (Dlim0 != Dlim1); } while (A(Comma) == True); } Initial_39:; Literal = 1; Getswitchdeclaration(); C.Status = C.Status | Hadswitch; goto Term; void Opt(void) { int C; C = Control; Setoptions(*String(Final0 + Value)); Selectoutput(Listout); if (!(Initcon & List)) Control = Control & (~List); if (Control & (~C) & (Ttlist + Codelist + Explist + Dictlist)) Control = Control | List; } Initial_48:; Getlitstring(); Get(Terminator); if (!Faultnum) Opt(); goto Next; Initial_47:; Getlitstring(); Get(Terminator); if (!Faultnum) { if (Curfile == 3) Croak(_imp_str_literal("Too many nested includes")); if (Sym == Nl) Line++; Cur->Fp = Fp; Cur->Line = Line; Fcontrol[Curfile] = Control; if (!(Control & (Codelist + Explist + Dictlist))) Control = Control & (~List); Curfile++; if (Curfile == Lastfile) Lastfile = -1; Cur = &File[Curfile]; *Cur = 0; Time1 -= Cputime; Opt(); Time1 += Cputime; if (Cur->Flag) _imp_signal(14, 0, 0, _imp_str_literal("")); Line = 0; Sym = Nl; Curstart = Cur->Start2; Curlim = Cur->Lim2; Fp = Cur->Start2; } goto Next; Initial_44:; Getliteral(Inttype); if (!Value) Control = 0; Control = Control ^ Value; if (Control & Dictlist) Showdict(0); goto Term; Initial_43:; Control = Control | List; goto Term; Initial_5:; Get(Terminator); if (!Stopper) { C.Localdpos = Dlim; C.Parlim = Dlim; C.Access = 1; Getstatements(Keyend); return; } Declareanon(Beginblock); Openblock(Dlim0); Getstatements(Keyend); Updatesp(); Thisisinst(); Srcall(Dlim - 1); goto Term; Initial_1:; if (Stopper > Keyend) if (Stopper == Keyrepeat) Fault(Norepeat + Now); else Fault(Nofinish + Now); else { if (A(Keyof) == True) { if (A(Keylist) == True) { Control = Control & (~List); goto Term; } if (A(Keyfile) == True) { Fp = Curlim; Sym = Nl; goto Next; } Get(Keyprogram); if (Level) Fault(Noend + Now); } if (!Stopper) Fault(Nobegin + Now); if (C.Access > 0) { if (C.Type) Fault(Noresult + Now); } Closeblock(); } } void Announce(int Value, _imp_string Message) { Write(Value, 1); Space(); Printstring(Message); if (Value != 1) Printsymbol('s'); } void Outputobjectfile(void) { static const int Objout = 1; static const int Initsize = 18; int I; int Reset; int Totsize; int Ownsize; Reset = 0; Totsize = Cad; Ownsize = Ownad; if (Ownsize) { if (Ownad & 3) Fillown(4 - (Ownad & 3)); Ownsize = Ownad; Reset = Cad; Totsize += Initsize + Ownad; } Setextension(Objfile, _imp_str_literal(".mob")); Time1 -= Cputime; Openoutput(Objout, Objfile); Selectoutput(Objout); Putword(0xFE02); Putword((unsigned)Control >> 20 << 4); Value = 0; if (Externs) Doexternals(Externs, -1); Putword(Value); Value = 0; if (Extspecs) Doexternals(Extspecs, -1); Putword(Value); Putword((unsigned)Totsize >> 16); Putword(Totsize); Putword((unsigned)Reset >> 1); Putword((unsigned)C.Dpid >> 1); Putword((unsigned)Ownsize >> 16); Putword(Ownsize); Putword((unsigned)C.Totstack >> 16); Putword(C.Totstack); Putword(0); Putword(0); Putword(0); Putword(0); if (Externs) Doexternals(Externs, 0); if (Extspecs) Doexternals(Extspecs, 1); Final[0] = 0x4E; Final[1] = 0x75; I = 0; do { Printsymbol(Final[I]); I++; } while (I != Cad); if (Ownsize) { Putword(0x2248 + Mb - A0); Putword(0x41FA); Putword(0x000E); Putword(0x303C); Putword(((unsigned)Ownad >> 1) - 1); Putword(0x32D8); Putword(0x51C8); Putword(-4); Putword(0x4E75); I = 0; do { Printsymbol(Final[I + Ownbase]); I++; } while (I != Ownad); } Time1 += Cputime; } void Closeedit(void) { if (File[Main].Flag >= 0 && 0 < File[Main].Change && File[Main].Change != 0x7FFFFFFF) { File[Main].Name = Mainfile; Time1 -= Cputime; Printstring(_imp_join(File[Main].Name, _imp_str_literal(" updated"))); Newline(); Time1 += Cputime; } } { if (_imp_on_event(13, 14)) if (Event.Event() == Abandon) { Closeedit(); exit(0); } Time2 = Cputime - Time1; Statements = 1; Comments = 0; Atoms = 0; Identatoms = 0; Litatoms = 0; Faults = 0; Others = 0; Faultnum = 0; Zaps = 0; Steps = 0; Jumps = 0; Shorts = 0; Rep = _imp_str_literal(""); Forgettriples(); Char0 = Addr(Char[0]); Final0 = Addr(Final[0]); Preset(); Dint = &Dict[Inttype]; Dtemp = &Dict[Lablim]; Dtemp2 = &Dict[Lablim + 1]; Dtsprel = &Dict[Lablim + 2]; Dmin = Dictlim; Dmin0 = Dmin; Inclim = 0; Accounted = 0; Firstentry = Finalbound; Firstpos = Dictlim; Pc = 1; Swpc = Progbound + 1; Cad = 2; Final[0] = 0; Ownbase = Finalbound - 4095; Ownad = 0; Level = Outerlevel; Vintage = 1; Pendout = 0; Pendin = 0; Polarity = 0; Curlab = Dictlim + 1; Resetcontext(Procstar, Defaultfree); C.Sp = -4; Control = Initcon; Lastfile = Main; Curfile = Main; Cur = &File[Main]; Curstart = File[Main].Start1; Curlim = File[Main].Lim1; Fp = File[Main].Start1; Line = 0; Sym = Nl; Np = Np0; Getstatements(0); } Time2 = Cputime - Time2 - Time1; Closeedit(); if (Faults == 0 || (Control & Forcebit) != 0) Outputobjectfile(); for (;;) { Selectoutput(Listout); Printstring(File[Main].Name); if (Faults == 0 || (Control & Forcebit) != 0) { Printstring(_imp_str_literal(" compiled:")); Announce(Statements, _imp_str_literal("statement")); Printstring(_imp_str_literal(" (+")); Announce(Comments, _imp_str_literal("comment")); Printstring(_imp_str_literal(") to")); Announce(Cad, _imp_str_literal("byte")); Printstring(_imp_str_literal(" (+")); Write(Ownad, 1); Printsymbol(')'); Newline(); } if (Faults) { Printsymbol(':'); Announce(Faults, _imp_str_literal("fault")); Printstring(_imp_str_literal(" reported")); if (Others) { Printstring(_imp_str_literal(" (+")); Announce(Others, _imp_str_literal("other")); Printsymbol(')'); } Newline(); } if (Control & Logbit) { Printstring(_imp_str_literal(" CODE OWNS JUMPS SHORT STEPS ZAPS | ATOMS LITS IDS TIME")); Newline(); Write(Cad, 5); Write(Ownad, 5); Write(Jumps, 6); Write(Shorts, 5); Write(Steps, 5); Write(Zaps, 5); Print(Atoms / Statements, 5, 1); Print(Litatoms / Statements, 2, 1); Print(Identatoms / Statements, 1, 1); Print(Time2 / Statements, 2, 3); Printsymbol('+'); Print(Time1 / Statements, 0, 3); Newline(); } if (!Listout) break; Listout = 0; } exit(0); return (1); }