#include static const int Maxname = 127; 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; int Shift; unsigned char Top; unsigned char Win; unsigned char Bot; unsigned char Min; unsigned char Row; unsigned char Col; _imp_string Name; } Edfile; void Edi(Edfile *Main, Edfile *Sec, _imp_string Message) {} void Connectedfile(Edfile *F) {} void Disconnectedfile(Edfile *F) {} static const _imp_string Permfile = _imp_str_literal("ECCE_PERM"); static const int Logbit = 0x00040000; static const int Warnbit = 0x00020000; static const int Nonsbit = 0x00010000; static const int Dictlist = 0x00001000; static const int Explist = 0x00000800; static int Control = Warnbit + Nonsbit; void Ecceci(Edfile *Main) { static _imp_string Extraname; static Edfile Extra = 0; static Edfile Null = 0; int Curstart; int Curlim; int Nonstop; static int Change = 0; static const int Formerr = 0; static const int Atomerr = 1; static const int Namerr = 2; static const int Caterr = 3; static const int Sizerr = 4; static const int Asserr = 5; static const int Typerr = 6; static const int Duperr = 7; static const int Nostart = 8; static const int Nocycle = 9; static const int Ordererr = 10; static const int Matcherr = 11; static const int Rangerr = 12; static const int Nonliteral = 13; static const int Boundserr = 14; static const int Accesserr = 15; static const int Notinloop = 16; static const int Notinrout = 17; static const int Notinfun = 18; static const int Notinpred = 19; static const int Plexerr = 20; static const int Noif = 21; static const int Nonstand = 22; static const int Notin = 23; static const int Indexerr = 24; static const int Moperr = 27; static const int Noterm = 28; static const int Nonstarter = 29; static const int Nonvar = 30; static const int Nonref = 31; static const int Toomany = 32; static const int Toofew = 33; static const int Unwanted = 34; static const int Noparm = 35; static const int Unending = 37; static const int Selfref = 38; static const int Noend = 40; static const int Nobegin = 41; static const int Idmissing = 42; static const int Nofinish = 43; static const int Norepeat = 44; static const int Counterr = 45; static const int Noresult = 46; static const int Errmax = 46; static const int Point = 64; static const int Warn = 128; static int Faultnum = 0; static int Faults = 0; static const int Maxint = 0x7FFFFFFF; static const int Minint = ~Maxint; static const int Max10 = Maxint / 10; static const int Maxdig = Maxint - Max10 * 10; static const int False = 0; static const int True = 1; int I; static int Statements = 0; static const int Smallmin = -1000; static const int Smallmax = 1000; static const int Litmin = Smallmax + 1; static const int Litmax = Smallmax + 1000; static const int D0 = Litmax + 1; static const int D1 = D0 + 1; static const int D2 = D0 + 2; static const int D6 = D0 + 6; 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 Posta0 = Inda0 + 8; static const int Posta7 = Posta0 + 7; static const int Prea0 = Posta0 + 8; static const int Prea7 = Prea0 + 7; static const int Dictmin = Prea0 + 8; static const int Dictmax = Prea0 + 1200; static const int Labmin = Dictmax + 1; static const int Lab1 = Labmin + 1; static const int Labmax = Labmin + 20; static const int Expmin = Labmax + 1; static const int Expmax = Labmax + 300; static const int Undef = Expmax + 1; static const int Ad = 0x4000; static const int Maxdreg = D0 + 4; static const int Maxareg = A0 + 3; static const int D0b = 1; static const int D1b = 2; static const int D2b = 4; static const int A0b = 0x100; static const int A1b = 0x200; static const int A2b = 0x400; static const int Allregs = 0b0000111100011111; static int Free = Allregs; static const int Nulltype = Dictmin; static const int Recy = Nulltype + 1; static const int Arry = Recy + 1; static const int Stringy = Arry + 1; static const int Realy = Stringy + 1; static const int Inty = Realy + 1; static const int Chartype = Inty + 1; static const int Booltype = Chartype + 1; static const int Falseconst = Booltype + 1; static const int Trueconst = Booltype + 2; static const int Inttype = Trueconst + 1; static const int Shorttype = Inttype + 1; static const int Halftype = Shorttype + 1; static const int Bytetype = Halftype + 1; static const int Mitetype = Bytetype + 1; static const int Bittype = Mitetype + 1; static const int Longinttype = Bittype + 1; static const int Realtype = Longinttype + 1; static const int Longrealtype = Realtype + 1; static const int Puretype = 8191; static const int Direct = 8192; static const int Indirect = 16384; static const int Anyint = Inty + Direct; static const int Anyintvar = Inty + Indirect; static const int Anystring = Stringy + Direct; static const int Anystringvar = Stringy + Indirect; static const int Anyname = Nulltype + Indirect; static int Dictshown = Dictmin; static int Litpos = Litmin; static int Slitpos = Litmax; int Litstore[1000 /*1001:2000*/]; static const int Bytesize = 1; static const int Wordsize = 2; static const int Longsize = 3; static const int Sizemask = 0xC0; static const int Sizeshift = 6; static const int Dmode = 0; static const int Amode = 0b001000; static const int Indmode = 0b010000; static const int Postmode = 0b011000; static const int Premode = 0b100000; 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 Ownmode = Dispmode + 6; typedef struct Objinfo { int Flags; int Type; int Val; } Objinfo; typedef struct Identinfo { int Text; int Link; } Identinfo; static const int Var = 0x0001; static const int Lab = 0x0002; static const int Proc = 0x0004; static const int Static = 0x0008; static const int Spec = 0x0010; static const int Ext = 0x0020; static const int Parm = 0x0040; static const int More = 0x0080; static const int Typeid = 0x0100; static const int Okflag = 0x0200; static const int Alt = 0x0800; static const int Rflag = 0x1000; static const int Wflag = 0x2000; Identinfo Dict[1254 /*2001:3254*/]; static int Dlim = Trueconst + 1; static int Dlim0; static int Permlim = Dictmin; static int Dmin = Dictmax - 1; static const int Charbound = 6000; unsigned char Char[6001 /*0:6000*/]; int Charbase; int Charlim; int Charmin; int Newlen; int Hashindex[256 /*0:255*/]; int *Head; static int Explo = Expmax + 1; static int Oldexplo = Expmax + 1; static const int Np0 = Expmin; static int Np; static int Condnp; static int Instnp; static const int End = 1; static const int Repeat = 2; static const int Finish = 3; static const int Else = 4; static const int Begin = 5; static const int Exit = 6; static const int Return = 7; static const int Tf = 8; static const int Result = 9; static const int Stop = 10; static const int Goto = 11; static const int Signal = 12; static const int Monitor = 13; static const int On = 15; static const int Iu = 16; static const int While = 17; static const int Until = 18; static const int For = 19; static const int Then = 20; static const int Start = 21; static const int Cycle = 22; static const int Keylabel = 23; static const int Prefix = 24; static const int Krange = 25; static const int Keylong = 26; static const int Keyinteger = 27; static const int Keyreal = 28; static const int Keystring = 29; static const int Keyrecord = 30; static const int Keyformat = 31; static const int Fnmap = 32; static const int Rpred = 33; static const int Keyspec = 34; static const int Keyarray = 35; static const int Keyname = 36; static const int Keyswitch = 37; static const int Of = 38; static const int Keyfile = 39; static const int Program = 40; static const int Keylist = 41; static const int Keycontrol = 42; static const int Comment = 43; static const int Keyevent = 44; static const int Include = 45; static const int Alias = 46; static const int Keynot = 47; static const int Keyand = 64; static const int Keyor = 65; static const int Syminit[26 /*97:122*/] = {2, 15, 27, 57, 64, 87, 118, 122, 126, 1, 1, 141, 154, 168, 175, 184, 1, 199, 230, 270, 278, 1, 288, 1, 1, 1}; static const unsigned char Symbol[292 /*1:292*/] = { 128, 114, 114, 97, 121, 163, 108, 105, 97, 115, 174, 110, 100, 192, 101, 103, 105, 110, 133, 121, 116, 101, 153, 105, 116, 153, 111, 110, 116, 105, 110, 117, 101, 134, 121, 99, 108, 101, 150, 109, 109, 101, 110, 116, 171, 115, 116, 97, 110, 116, 152, 152, 114, 111, 108, 170, 121, 110, 97, 109, 105, 99, 152, 110, 100, 129, 108, 115, 101, 132, 120, 105, 116, 134, 118, 101, 110, 116, 172, 116, 101, 114, 110, 97, 108, 152, 105, 110, 105, 115, 104, 131, 97, 108, 115, 101, 136, 111, 114, 109, 97, 116, 159, 110, 160, 117, 110, 99, 116, 105, 111, 110, 160, 147, 108, 101, 167, 111, 116, 111, 139, 97, 108, 102, 153, 102, 144, 110, 116, 101, 103, 101, 114, 155, 99, 108, 117, 100, 101, 173, 97, 98, 101, 108, 151, 111, 110, 103, 154, 105, 115, 116, 169, 111, 110, 105, 116, 111, 114, 141, 105, 116, 101, 153, 97, 112, 160, 97, 109, 101, 164, 111, 116, 175, 110, 143, 119, 110, 152, 102, 166, 114, 193, 114, 101, 100, 105, 99, 97, 116, 101, 161, 111, 103, 114, 97, 109, 168, 101, 112, 101, 97, 116, 130, 111, 117, 116, 105, 110, 101, 161, 116, 117, 114, 110, 135, 115, 117, 108, 116, 137, 97, 108, 156, 99, 111, 114, 100, 158, 116, 111, 112, 138, 105, 103, 110, 97, 108, 140, 121, 115, 116, 101, 109, 152, 104, 111, 114, 116, 153, 112, 101, 99, 162, 119, 105, 116, 99, 104, 165, 97, 114, 116, 149, 114, 105, 110, 103, 157, 114, 117, 101, 136, 104, 101, 110, 148, 110, 108, 101, 115, 115, 144, 116, 105, 108, 146, 104, 105, 108, 101, 145}; static const unsigned char Altdisp[292 /*1:292*/] = { 0, 5, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 4, 0, 0, 3, 0, 0, 5, 8, 12, 17, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 40, 3, 0, 0, 4, 0, 0, 0, 4, 8, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 40, 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, 2, 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, 4, 0, 0, 1, 4, 0, 0, 0, 0, 0, 0, 2, 0, 3, 0, 8, 2, 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, 3, 0, 0, 0, 0, 0, 0, 0, 4, 30, 0, 0, 6, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 40, 5, 0, 0, 0, 1, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 0, 0, 0, 5, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0}; static const int Terminator = 52; static const int Const = 53; static const int Ident = 54; static const int Aref = 55; static const int Recref = 56; static const int Modsign = 57; static const int Colon = 58; static const int Comma = 59; static const int Right = 60; static const int Rightbracket = 61; static const int Dud = 63; static const int Booland = 64; static const int Boolor = 65; static const int Boolnot = 66; static const int Float = 67; static const int Imod = 68; static const int Fmod = 69; static const int Equals = 70; static const int Noteq = 71; static const int Lesseq = 72; static const int Less = 73; static const int Greateq = 74; static const int Greater = 75; static const int Eqeq = 76; static const int Noteqeq = 77; static const int Resolve = 79; static const int Plus = 80; static const int Minus = 81; static const int Logor = 82; static const int Logxor = 83; static const int Concat = 84; static const int Mult = 88; static const int Fdiv = 89; static const int Idiv = 90; static const int Logand = 91; static const int Fpower = 96; static const int Ipower = 97; static const int Lshift = 100; static const int Rshift = 101; static const int Lognot = 102; static const int Fcall = 106; static const int Mcall = 107; static const int Atommax = 107; static const int Swgoto = 35; static const int Rcall = Mcall + 2; static const int Assign = 41; static const int Jamassign = 42; static const int Plusass = 43; static const int Compare = 44; static const int Jump = 45; static const int Label = 46; static const int Adecl = 47; static const int Actmax = 49; static const int Eq = 0b0111; static const int Ne = 0b0110; static const int Gt = 0b1110; static const int Le = 0b1111; static const int Lt = 0b1101; static const int Ge = 0b1100; static const int Cc = 0b0100; static const int Cs = 0b0101; static const int Double = 16; static const int Dshort = Dictmin + 6; static const int Dlength = Dshort + 1; static const int Dcharno = Dlength + 1; static const int Daddr = Dcharno + 1; static const int Dtostr = Daddr + 1; static const int Drem = Dtostr + 1; static const int Dnextsym = Drem + 1; static const int Dreadsym = Dnextsym + 1; static const int Dprintstr = Dreadsym + 3; static const int Dread = Dictmin + 27; static const int Dnewline = Dictmin + 41; static const int Sigentry = 0x1114; static const int Scompentry = 0x1128; static const int Boundentry = 0x1134; static const int Agetentry = 0x1138; static const int Indexentry = 0x113C; static const int Ireadentry = 0x1118; static int Starts = 0; static int Cycles = 0; static int Looplab = 0; static int Curlab = Lab1; typedef struct Blockinf { int Sp; int Delta; int Fortemps; int Flags; int Type; int Localdpos; int Parlim; int Localtext; int Localpc; int Localspc; int Pidpos; int Access; int Forward; int Events; int Eventpc; int Faults; int Return; int Shorts; } Blockinf; static const int Wrongcc = 2; static const int Nonlocalref = 4; static const int Dynarray = 8; static const int Hadon = 0x10; static const int Hadinst = 0x20; static const int Outerlevel = 0; static const int Maxlevel = 16; static int Level = Outerlevel; Blockinf C; Blockinf Hold[16 /*0:15*/]; static const int Purebound = 0; static const int Ownbase = Purebound + 1; static const int Finalbound = Ownbase + 8191; unsigned char Final[8193 /*0:8192*/]; static int Finalad = 2; static int Ownad = Ownbase; static int Pc = 0; static int Spc = Finalbound; static const int Casemask = 95; static const int Casebit = 32; static int Item = 0; Objinfo T; Identinfo *Ditem; static int Elements; static int Hash; static int Speccing = 0; static int Mcoding = 0; static int Declmode; static int Dsize; static Identinfo D; static int Atom = 0; static int Matched = 1; static int Sym = Nl; static int Line = 0; static int Mainline = 0; static int Diagline = -9999; static int Proline = 0; static int Modesym = '&'; static int Linestart = 0; static int Fp = 0; static int Chars = 0; static int Atomp = 0; static int Faultp = 0; static int Mainfp; static int Stringp; static int Expp; static int Listout = 0; static _imp_string Rep = _imp_str_literal(""); void Newline(void) { Printstring(Rep); Printsymbol(Nl); Rep = _imp_str_literal(""); } void Putsym(int K) { if (*Length(Rep) < 132) Rep = _imp_join(Rep, Tostring(K)); } void Printstring(_imp_string S) { if (*Length(Rep) < 132) Rep = _imp_join(Rep, S); } void Spaces(int N) { while (N > 0) { Rep = _imp_join(Rep, _imp_str_literal(" ")); N--; } } void Write(int Val, int P) { void Pd(int V) { P--; if (V <= -10) { Pd(V / 10); V -= V / 10 * 10; } if (P > 0) { Spaces(P); P = 0; } Putsym('0' - V); } if (Val < 0) { Putsym('-'); Pd(Val); } else Pd(-Val); } void Report(int N, int Joker) { int Mark; int Start; int Errline; int K; int Editfp; void Printident(int X) { Putsym('"'); Printstring(*String(Dict[X].Text + Charbase)); Putsym('"'); } void Printtext(int X, int Stream) { static const int Esc = 27; int K; int P; static int S_sw; static void *S[47 /*0:46*/] = { &&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, &&S_22, &&S_23, &&S_24, &&S_default, &&S_default, &&S_27, &&S_28, &&S_29, &&S_30, &&S_31, &&S_32, &&S_33, &&S_34, &&S_35, &&S_default, &&S_37, &&S_38, &&S_default, &&S_40, &&S_41, &&S_42, &&S_43, &&S_44, &&S_45, &&S_46, }; Putsym(Mark); Write(Line, 4); Putsym(Modesym); Putsym(' '); goto *S[S_sw = N & 63]; S_0: Printstring(_imp_str_literal("Faulty form")); goto Print; S_1: Printstring(_imp_str_literal("Unknown atom")); goto Print; S_2: Printstring(_imp_str_literal("Unknown name")); goto Print; S_3: Printstring(_imp_str_literal("Unsuitable")); goto Print; S_4: Printstring(_imp_str_literal("Size")); goto Print; S_6: Printstring(_imp_str_literal("Wrong type")); goto Print; S_14: Printstring(_imp_str_literal("Inside out")); goto Print; S_37: Printstring(_imp_str_literal("Endless loop")); goto Print; S_24: Printstring(_imp_str_literal("Index")); goto Print; S_15: Printstring(_imp_str_literal("Not accessible")); goto Print; S_16: Printstring(_imp_str_literal("Not in loop")); goto Print; S_17: Printstring(_imp_str_literal("Not in routine")); goto Print; S_18: Printstring(_imp_str_literal("Not in fn/map")); goto Print; S_19: Printstring(_imp_str_literal("Not in pred")); goto Print; S_20: Printstring(_imp_str_literal("Too complex!")); goto Print; S_7: Printstring(_imp_str_literal("Duplicate")); goto Print; S_10: Printstring(_imp_str_literal("Out of order")); goto Print; S_11: Printstring(_imp_str_literal("Mismatch")); goto Print; S_12: Printstring(_imp_str_literal("Out of range")); goto Print; S_13: Printstring(_imp_str_literal("Not literal")); goto Print; S_22: Printstring(_imp_str_literal("Nonstandard")); goto Print; S_23: Printstring(_imp_str_literal("Not in yet")); goto Print; S_27: Printstring(_imp_str_literal("Faulty operand")); goto Print; S_9: Printstring(_imp_str_literal("Missing %CYCLE")); goto Print; S_8: Printstring(_imp_str_literal("Missing %START")); goto Print; S_21: Printstring(_imp_str_literal("Missing %IF")); goto Print; S_28: Printstring(_imp_str_literal("';' missing")); goto Print; S_29: Printstring(_imp_str_literal("Non-starter")); goto Print; S_30: Printstring(_imp_str_literal("Not variable")); goto Print; S_31: Printstring(_imp_str_literal("Not reference")); goto Print; S_35: Printstring(_imp_str_literal("No parameters")); goto Print; S_33: Printstring(_imp_str_literal("Too few")); goto Print; S_34: Printstring(_imp_str_literal("Unwanted")); goto Print; S_32: Printstring(_imp_str_literal("Too many")); goto Print; S_38: Printstring(_imp_str_literal("Self-reference")); goto Print; S_41: Printstring(_imp_str_literal("Extra %END")); goto Print; Print:; Spaces(21 - *Length(Rep)); P = Start; if (P < Faultp - 50) { P = Faultp - 47; Printstring(_imp_str_literal("...")); } else Putsym(' '); for (;;) { K = *Byteinteger(P); P++; if (P == Faultp) { if (!Stream) { Putsym(Esc); Putsym('F'); } Putsym('~'); if (!Stream) { Putsym(Esc); Putsym('G'); } } if (K == Nl) break; if (' ' <= K && K <= '~') Putsym(K); else { Putsym('['); Write(K, -1); Putsym(']'); } } return; S_40: Printstring(_imp_str_literal("%END")); goto Mend; S_46: Printstring(_imp_str_literal("Result")); goto Mend; S_43: Printstring(_imp_str_literal("%FINISH")); goto Mend0; S_44: Printstring(_imp_str_literal("%REPEAT")); Mend0: if (Curlab > Lab1 + 2) Printstring(_imp_str_literal(" etc")); goto Mend; S_42:; do { Putsym(' '); Printident(X); if (!(Dict[X].Flags & Spec)) Printstring(_imp_str_literal("(?)")); X = Dict[X].Val; } while (X); Mend:; Printstring(_imp_str_literal(" missing")); if (C.Type) { Printstring(_imp_str_literal(" at END of ")); Printident(C.Pidpos); } else N = 0; return; S_45:; if (Elements < 0) { Write(-Elements, 0); Printstring(_imp_str_literal(" extra")); } else { Write(Elements, 0); Printstring(_imp_str_literal(" missing")); } Printstring(_imp_str_literal(" value(s) for ")); Printident(X); return; S_5:; Printident(X); Printstring(_imp_str_literal(" void")); goto S_skip; S_default: fprintf(stderr, "\nSwitch label 'S(%d):' not set in %s\n", S_sw, __PRETTY_FUNCTION__); fflush(stderr); abort(); S_skip:; } Mark = '?'; if (!(N & Warn)) { Mark = '*'; C.Faults = C.Faults + 1; Faults++; } Faultnum = 0; C.Access = -1; if (Main.Start1 <= Fp && Fp < Change) return; Start = Linestart; Errline = Line; if (!(N & Point)) Faultp = 0; else { if (Joker > 0) Faultp = Joker; while (Faultp <= Start) { Start--; if (*Byteinteger(Start) == Nl) Errline--; } while (Start != Curstart && *Byteinteger(Start - 1) != Nl) Start--; } Editfp = Start; if (Faultp > Start) Editfp = Faultp - 1; if (Curlim == Extra.Lim2) Editfp = Mainfp; while (*Byteinteger(Start) == ' ') Start++; Printtext(Joker, 0); if ((N & Warn) != 0 || Nonstop != 0) { Newline(); return; } Main.Fp = Editfp; Main.Line = Line; if (Change) Main.Change = 0x7FFFFFFE; Edi(*Main, Null, Rep); Rep = _imp_str_literal(""); if (Main.Flag == 'I') Nonstop = 1; if (Main.Flag < 0) exit(0); if (Main.Change < 0x7FFFFFFE) _imp_signal(12, 0, 0, _imp_str_literal("")); } void Croak(_imp_string S) { Printstring(_imp_join(_imp_str_literal("** "), _imp_join(S, _imp_str_literal(". Checking abandoned at line ")))); Write(Line, 0); Newline(); Nonstop = -999; _imp_signal(12, 0, 0, _imp_str_literal("")); } void Fault(int N) { if (!Faultnum) { Faultnum = N; Faultp = Atomp; } } void Expfault(int N) { if (Faultnum == 0 || Expp < Faultp) { Faultnum = N | Point; Faultp = Expp; } } static const int Pred = 1; static const int Uparr = 1 << 1; static const int Nocomma = 1 << 2; static const int Overload = 1 << 3; static const int Ranges = 1 << 4; static const int Nolength = 1 << 5; static const int Initass = 1 << 6; static const int Kgoto = 1 << 7; static const int Hyphen = 1 << 8; static const int Naming = 1 << 9; static const int Klabel = 1 << 10; static const int Ibmhex = 1 << 11; static const int Oldcycle = 1 << 12; static const int Loop2 = 1 << 13; void Nonstandard(int Case) { static int Hadit = 0; if ((Control & Nonsbit) != 0 && (Case & Hadit) == 0) { Hadit += Case; Fault(Nonstand + Point + Warn); } } void Error(int Case) { Report(Case, Atomp); _imp_signal(14, 0, 0, _imp_str_literal("")); } void Nameerror(void) { while (Item < 0 && *String(Dict[-Item].Text + Charbase) != *String(Charlim)) Item = Dict[-Item].Link; if (Item >= 0) { Report(Namerr + Point, Atomp); if (Charmin - Newlen - 80 >= Charlim) { Dmin--; Charmin = Charmin - Newlen - 1; *String(Charmin) = *String(Charlim); Dict[Dmin].Text = Charmin - Charbase; while (*Head > 0) Head = &Dict[*Head].Link; Dict[Dmin].Link = *Head; *Head = -Dmin; } } _imp_signal(14, 0, 0, _imp_str_literal("")); } void Syntaxerror(void) { int E; E = Formerr + Point; if (Atom == Dud) E = Atomerr + Point; Report(E, Atomp); _imp_signal(14, 0, 0, _imp_str_literal("")); } int Floated(int Item) { if (!Item) return (0); return (Explo); } void Forget(void) {} void Forgetall(void) { int I; int J; Litpos = Litmin; Explo = Expmax + 1; Oldexplo = Explo; } void Setlabel(int B) {} void Setuserlabel(int Dpos) {} void Compile(int From, int To) { Np = Np0; } void Compileentry(void) {} void Compileend(void) {} void Put3(int Act, int X, int Y) {} void Put2(int Act, int X) {} int Tempvar(void) { return (Dlim); } void Openblock(int Pidpos) { Forget(); if (Level == Maxlevel) Croak(_imp_str_literal("Too many levels")); Hold[Level] = C; Level++; C = 0; Starts = 0; Cycles = 0; Curlab = Lab1; Looplab = 0; Forgetall(); C.Flags = 0; C.Type = D.Type; C.Pidpos = Pidpos; C.Localdpos = Dlim; C.Parlim = Dlim; C.Localtext = Charlim; C.Localpc = Pc; C.Localspc = Spc; C.Access = 1; } void Closeblock(void) { int I; int Miss; int Dpos; int *P; Identinfo *Dp; Miss = 0; P = &Miss; Dpos = C.Localdpos; while (Dpos != Dlim) { Dp = &Dict[Dpos]; if ((Dp->Flags & (Proc + Lab)) != 0 && (Dp->Flags & (Ext + Spec)) == Spec) { *P = Dpos; P = &Dp->Val; *P = 0; } Dpos++; } if (Miss) Report(Idmissing, Miss); Compileend(); Pc = C.Localpc; Spc = C.Localspc; Dlim = C.Parlim; Charlim = C.Localtext; for (I = 0; I <= 255; I++) while (Hashindex[I] >= C.Localdpos) Hashindex[I] = Dict[Hashindex[I]].Link; Level--; C = Hold[Level]; Starts = 0; Cycles = 0; } void Switchinput(void) { if (Fp == Main.Lim2) _imp_signal(12, 0, 0, _imp_str_literal("")); if (Nonstop < 0) { Nonstop += 3; Permlim = Dlim; C.Localdpos = Dlim; C.Parlim = Dlim; Statements = 0; } if (Fp != Main.Lim1) { Nonstop--; Fp = Mainfp; Line = Mainline; Curstart = Main.Start1; Curlim = Main.Lim1; } else Fp = Main.Start2; if (Main.Start2 <= Fp && Fp <= Main.Lim2) { Curstart = Main.Start2; Curlim = Main.Lim2; } Modesym = ' '; Sym = Nl; } void Readline(void) { if (Faultnum) Report(Faultnum, Faultp); while (Sym != Nl) { Sym = *Byteinteger(Fp); Fp++; } while (Fp == Curlim) Switchinput(); Line++; Linestart = Fp; Sym = 0; } static int Percent = 0; static int Subatom = 0; static const int Arrow = Resolve; static const int Exclam = Logor; static const int Exclam2 = Logxor; static const int Dot = Concat; static const int Star = Mult; static const int Slash = Fdiv; static const int Slash2 = Idiv; static const int Ampersand = Logand; static const int Backslash = Fpower; static const int Backslash2 = Ipower; static const int Uparrow = Fpower; static const int Uparrow2 = Ipower; static const int Tilde = Lognot; static const int Left = Aref; static const int Underline = Recref; static const int Leftbracket = 106; static const int Simple = 104; static const int Major = Plus; static const int Scond = Equals; static const int Cond = Keyand; static const int Recok = 1 << 0; static const int Arrok = 1 << 1; static const int Stringok = 1 << 2; static const int Realok = 1 << 3; static const int Intok = 1 << 4; static const int Charok = 1 << 5; static const int Boolok = 1 << 6; static const int Enumok = 1 << 7; static const int Setok = 1 << 8; static const int Znop = 1 << 9; static const int Refonly = 1 << 10; static const int Varonly = 1 << 11; static const int Arithok = Intok + Realok; static const int Ordok = Intok + Charok + Boolok + Enumok; static const int Any = Realok + Ordok + Stringok + Arrok + Recok; static const int Opbits[44 /*64:107*/] = {64, 64, 0, 0, 0, 0, 255, 255, 508, 252, 508, 252, 255, 255, 0, 4, 792, 792, 528, 528, 4, 0, 0, 0, 24, 24, 16, 16, 0, 0, 0, 0, 24, 16, 0, 0, 528, 528, 16, 0, 2, 1, 0, 0}; 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_default, &&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_default, &&S_92, &&S_default, &&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_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, &&S_default, }; static const int Tab = 9; int I; int J; int P; int Radix; int Digits; 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}; void Assemblereal(void) { J = 0; for (;;) { do { Sym = *Byteinteger(Fp); Fp++; } while (Sym == ' '); I = Sym - '0'; if (0 > I || I >= Radix) return; Rval = Rval * Radix + I; J++; } } Matched = 0; Again: S_9:; if (Sym == Nl) Readline(); do { Sym = *Byteinteger(Fp); Fp++; } while (Sym == ' '); Atomp = Fp; goto *S[S_sw = Sym]; Linebreak: S_10:; if (Atom != Comma) return (Terminator); goto Again; S_123:; 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 Again; return (Minus); S_42: return (Star); S_47: if (*Byteinteger(Fp) == '/') { Fp++; return (Slash2); } return (Slash); S_92: if (*Byteinteger(Fp) == '\\') { Fp++; return (Backslash2); } return (Backslash); S_94: Nonstandard(Uparr); if (*Byteinteger(Fp) == '^') { Fp++; return (Uparrow2); } return (Uparrow); S_33: if (*Byteinteger(Fp) == '!') { Fp++; return (Exclam2); } return (Exclam); S_38: return (Ampersand); S_46: 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_41: return (Right); S_124: return (Modsign); S_69: S_101:; if (*Byteinteger(Fp) == '"') { Fp++; goto Stringconst; } S_77: S_109: S_67: S_99:; if (*Byteinteger(Fp) == '\'') { Fp++; goto Charconst; } S_65: S_66: S_68: 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_100: 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 == ' '); 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; Head = &Hashindex[Hash & 255]; Item = *Head; if (Item > 0) do { if (Item <= 0) return (Ident); Ditem = &Dict[Item]; if (*String(Ditem->Text + Charbase) == *String(Charlim)) break; Item = Ditem->Link; } while (Item > 0); 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] >= 128) break; Atom = Altdisp[P]; if (!Atom) { if ((Sym | Casebit) != 'c' || *Byteinteger(Fp) != Nl) return (Dud); Readline(); goto Again; } 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); S_48: S_49: S_50: S_51: S_52: S_53: S_54: S_55: S_56: S_57:; Item = 0; T.Type = Inty; Radix = 10; T.Val = 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 (T.Val > Max10 || (T.Val == Max10 && I > Maxdig)) { T.Type = Realy; Rval = T.Val; Assemblereal(); break; } T.Val = T.Val * 10 + I; } else { if (I >= 10) I = (Sym | Casebit) - 'a' + 10; if (I < 0 || I >= Radix) break; J = Radix; do { if (J & 1) I += T.Val; T.Val = T.Val << 1; J = (unsigned)J >> 1; } while (J); T.Val = I; } } if (Sym != '_') break; Radix = T.Val; if (!Radix) return (Dud); T.Val = 0; } if (Sym == '.') { if (T.Type == Inty) { T.Type = Realy; Rval = T.Val; } Assemblereal(); if (!J) return (Dud); Rval = Rval / REXP(Radix, J); } Fp--; Sym = 0; return (Const); S_39:; Charconst:; Item = 0; T.Type = Inty; T.Val = 0; for (;;) { Sym = *Byteinteger(Fp); Fp++; if (Sym == Nl) return (Dud); if (Sym == '\'') { if (*Byteinteger(Fp) != '\'') break; Fp++; } T.Val = (T.Val << 8) + Sym; } if (T.Val) return (Const); return (Dud); S_34:; Stringconst:; Item = 0; T.Type = Stringy; Stringp = Atomp; T.Val = 0; I = Line; J = Linestart; for (;;) { Sym = *Byteinteger(Fp); Fp++; if (Sym == '"') { if (*Byteinteger(Fp) != '"') break; Fp++; } T.Val = T.Val + 1; if (T.Val > 255) { Sym = 0; Fp = Atomp; Linestart = J; return (Dud); } if (Sym == Nl) Readline(); } return (Const); S_default:; return (Dud); } void Lookupfieldident(int List) { Item = List; if (!Item) return; for (;;) { Ditem = &Dict[Item]; if (!(Ditem->Flags & Typeid)) { if (*String(Ditem->Text + Charbase) == *String(Charlim)) return; if (!(Ditem->Flags & More)) break; } Item++; } Item = 0; } int /* boolean */ A(int K) { if (Matched) Atom = Nextatom(); if (K != Atom) return (0); Matched = 1; return (1); } void Get(int K) { if (Matched) Atom = Nextatom(); Matched = 1; if (Atom == K) return; if (Atom == Dud) Syntaxerror(); Faultp = Atomp; Report(Formerr + Point, -K); _imp_signal(14, 0, 0, _imp_str_literal("")); } void Allow(int K) { if (A(K)) ; } void Declare(void) { if (!Speccing) { if (Item >= C.Localdpos) { if ((D.Flags & Spec) == 0 && D.Flags + Spec == Ditem->Flags && Ditem->Type == D.Type) { Ditem->Flags = Ditem->Flags - Spec; return; } Fault(Duperr + Point); } D.Link = *Head; *Head = Dlim; if (Item > 0) D.Text = Ditem->Text; else { D.Text = Charlim - Charbase; Charlim = Charlim + Newlen + 1; if (Charlim + 80 >= Charmin) Croak(_imp_str_literal("Identifier space exhausted")); } } else D.Text = 0; Item = Dlim; Ditem = &Dict[Item]; *Ditem = D; Dlim++; if (Dlim >= Dmin) Croak(_imp_str_literal("Too many identifiers")); } void Declareanon(void) { D.Text = 0; D.Link = 0; Dict[Dlim] = D; Dlim++; if (Dlim >= Dmin) Croak(_imp_str_literal("Too many identifiers")); } static int Jammy; int /* boolean */ Aassop(void) { if (Matched) Atom = Nextatom(); if (Atom != Equals && Atom != Eqeq) { if (Atom != Less || *Byteinteger(Fp) != '-') return (0); Jammy = 2; Fp++; } else Jammy = 0; Matched = 1; return (1); } static int Literal = 0; auto void Getexpression(int Rank, int Control); int Compat(int Control) { if (T.Type == Inty) { if ((Control & Intok) == 0 && (Control & Realok) != 0) { Item = Floated(Item); T.Type = Realy; } return (Control & (Intok + Realok)); } if (T.Type <= Booltype) return (Control & ((unsigned)Boolok >> (Booltype - T.Type))); if (T.Type < Direct) return (Control & Enumok); return (Control & Arrok); } int Listmatch(int Alist, int Blist) { Identinfo *Ap; Identinfo *Bp; if (Alist == Blist) return (1); if (Alist < Dictmin || Blist < Dictmin) return (0); do { Ap = &Dict[Alist]; Bp = &Dict[Blist]; if (Ap->Type != Bp->Type) return (0); Alist++; Blist++; } while (Ap->Flags & Bp->Flags & More); if ((Ap->Flags & More) != 0 || (Bp->Flags & More) != 0) return (0); return (1); } void Getreference(int Reftype) { int Type; int Temp; Getexpression(Simple, Refonly + Any); Type = Ditem->Type & Puretype; Reftype = Reftype & Puretype; if (Reftype == Type) return; if (Type < Reftype) { Temp = Type; Type = Reftype; Reftype = Temp; } if (Reftype == Nulltype) return; Type = Dict[Type].Type; if (Type <= Inty && Type == Reftype) return; if (Type >= Direct && Type == Dict[Reftype].Type) return; Expfault(Typerr + Point); } void Getvalue(int Valtype) { Identinfo *Dp; Identinfo *P; Getexpression(Major, Any); Valtype = Valtype & Puretype; Dp = &Dict[Valtype]; if (T.Type != Dp->Type) { if (Item == 0 && 0 == T.Val) return; if (Dp->Type == Realy && T.Type == Inty) { T.Type = Realy; return; } } else if (T.Type >= Inty) { if (!Item) { if (Dp->Low <= T.Val && T.Val <= Dp->Val) return; if (Jammy >= 0) Jammy = Jammy | 1; } else if (T.Low >= Dp->Low) { if (T.Val <= Dp->Val) return; if (Jammy >= 0) Jammy = Jammy | 1; if (T.Low <= Dp->Val) return; } else { if (Jammy >= 0) Jammy = Jammy | 1; if (T.Val >= Dp->Low) return; } if (Jammy < 2) Expfault(Rangerr + Point); return; } else if (T.Type == Stringy) { if (T.Val > Dp->Val) { if (Jammy >= 0) Jammy = Jammy | 1; if (Item == 0 && Jammy < 2) Expfault(Rangerr + Point); } return; } else if (T.Type == Recy) { if (T.Extra == Dp->Extra) return; if (Jammy >= 2) { Jammy = Jammy | 1; return; } } else if (T.Type == Realy) return; Expfault(Typerr + Point); } void Getliteral(int Littype) { Literal++; Getvalue(Littype); Literal--; } void Getlitint(void) { Literal++; Getexpression(Major, Intok); Literal--; } void Getlitstring(void) { int Holditem; Holditem = Item; Get(Const); if (T.Type != Stringy) Error(Typerr + Point); Item = Holditem; } void Getparmlist(void) { Identinfo *Hp; Identinfo *Dp; int I; int J; int Headitem; int Headact; int Dpos; int Case; int Procnp; int First; Headitem = Item; Hp = Ditem; Headact = Rcall; I = 0; First = 1; Dpos = Headitem; Dp = Hp; do { if (!(Dp->Flags & More)) Error(Toomany + Point); do { Dpos++; Dp = &Dict[Dpos]; } while (!(Dp->Flags & Parm)); if (Dp->Flags & Proc) { Get(Ident); if (Item <= 0) Nameerror(); if (!(Ditem->Flags & Proc)) Fault(Typerr + Point); if (Item > Headitem) Fault(Caterr + Point); } else if (Dp->Type < Indirect) { Case = I & 7; I++; Getvalue(Dp->Type); } else { Case = ((unsigned)I >> 3) + 8; I += 8; Getreference(Dp->Type); } } while (A(Comma)); Item = Explo; } void Getresolution(void) { if (!A(Left)) { Getreference(Anystringvar); Get(Dot); Get(Left); } Getvalue(Anystring); Get(Right); if (A(Dot)) Getreference(Anystringvar); } void Getexpression(int Rank, int Control) { int Type; int F; int Opok; int C1; int Op; int Atomp1; int Item1; Objinfo T1; Identinfo *Dp; int Litval(void) { static int Lit_sw; static void *Lit[44 /*64:107*/] = { &&Lit_64, &&Lit_65, &&Lit_66, &&Lit_default, &&Lit_default, &&Lit_default, &&Lit_70, &&Lit_71, &&Lit_72, &&Lit_73, &&Lit_74, &&Lit_75, &&Lit_default, &&Lit_default, &&Lit_default, &&Lit_default, &&Lit_80, &&Lit_81, &&Lit_82, &&Lit_83, &&Lit_84, &&Lit_default, &&Lit_default, &&Lit_default, &&Lit_88, &&Lit_default, &&Lit_90, &&Lit_91, &&Lit_default, &&Lit_default, &&Lit_default, &&Lit_default, &&Lit_default, &&Lit_default, &&Lit_default, &&Lit_default, &&Lit_100, &&Lit_101, &&Lit_102, &&Lit_default, &&Lit_default, &&Lit_default, &&Lit_default, &&Lit_default, }; goto *Lit[Lit_sw = (Op)-64]; Lit_80: return (T1.Val + T.Val); Lit_81: return (T1.Val - T.Val); Lit_88: return (T1.Val * T.Val); Lit_90: if (T.Val) return (T1.Val / T.Val); Fault(Rangerr); return (0); Lit_91:; Lit_64: return (T1.Val & T.Val); Lit_82:; Lit_65: return (T1.Val | T.Val); Lit_83: return (T1.Val ^ T.Val); Lit_100: return (T1.Val << T.Val); Lit_101: return ((unsigned)T1.Val >> T.Val); Lit_66: return (T.Val ^ True); Lit_102: return (~T.Val); Lit_70: if (T1.Val == T.Val) return (True); return (False); Lit_71: if (T1.Val != T.Val) return (True); return (False); Lit_72: if (T1.Val <= T.Val) return (True); return (False); Lit_73: if (T1.Val < T.Val) return (True); return (False); Lit_74: if (T1.Val >= T.Val) return (True); return (False); Lit_75: if (T1.Val > T.Val) return (True); return (False); Lit_84: return (T1.Val + T.Val); Lit_default:; return (1); } if (Matched) Atom = Nextatom(); Atomp1 = Atomp; if (Atom == Ident) { Matched = 1; if (Item <= 0) Nameerror(); if (Item >= Dlim0) Fault(Selfref + Point); Type = Ditem->Type; if (Control & (Refonly + Varonly)) { if ((Control & Varonly) != 0 && (F & Var) == 0) Error(Nonvar + Point); if (Type < Direct) Error(Nonref + Point); } F = Ditem->Flags; if (Inty <= Type && Type <= Booltype && (F & Proc) == 0) { Item = 0; T = Ditem->Details; } else { if (Literal > 0) Fault(Nonliteral + Point); if (F & Proc) { if (F & Parm) { Ditem = &Dict[Type]; Type = Ditem->Type; } if (Type == Nulltype) Error(Caterr + Point); if (A(Left)) { Dp = Ditem; Getparmlist(); Get(Right); Ditem = Dp; } else { if (Ditem->Flags & More) Error(Toofew + Point); Item = Explo; } } for (;;) { Dp = &Dict[Type & Puretype]; T = Dp->Details; if (Matched) Atom = Nextatom(); if (Atom != Underline && Atom != Left) break; Matched = 1; Item1 = Item; if (Atom == Left) { for (;;) { if (T.Type < Direct) Syntaxerror(); Type = T.Type; Getvalue(T.Val); Item = Explo; Ditem = Dp; if (!A(Comma)) break; Dp = &Dict[Type & Puretype]; T = Dp->Details; Item1 = Item; } Get(Right); } else { if (T.Type != Recy) Syntaxerror(); Get(Ident); Lookupfieldident(T.Extra); if (Item <= 0) Error(Namerr + Point); Type = Ditem->Type; Item = Explo; } } if (Control & (Varonly + Refonly)) goto Final; } } else { if (Control & Varonly) Error(Nonvar + Point); if (Control & Refonly) Error(Nonref + Point); if (A(Const)) ; else if (Atom == Minus) { Item = 0; T = 0; T.Type = Inty; } else if (A(Left)) { if (Rank < Major) Getexpression(Cond, Any); else { Jammy -= 4; C1 = Control; if (C1 & Realok) C1 = C1 | Intok; Getexpression(Major, C1); Jammy += 4; } Get(Right); } else if (A(Keynot)) { if (Rank >= Major) Syntaxerror(); Getexpression(Scond, Any); if (!Item) T.Val = T.Val ^ True; else Item = Explo; } else if (Atom == Backslash) { Item = 0; T = 0; T.Type = Inty; Atom = Tilde; } else if (A(Modsign)) { if (!(Control & Arithok)) Fault(Typerr + Point); Getexpression(Major, Arithok); Get(Modsign); if (!Item) { if (T.Val < 0) if (T.Val != Minint) T.Val = -T.Val; else Expfault(Rangerr); } else if (T.Type == Inty) { Item = Explo; } else if (T.Type == Realy) { Item = Explo; } else Error(Typerr); } else Syntaxerror(); } if (Matched) Atom = Nextatom(); while (Atom >= Rank) { Op = Atom; Matched = 1; Opok = Opbits[Op]; C1 = Compat(Opok); if (!C1) Fault(Typerr + Point); Item1 = Item; T1 = T; if (Op >= Major) { if (Op == Dot) Getexpression(Dot, Stringok); else Getexpression((Op & (~7)) + 8, C1); if (T.Type == Realy && T1.Type == Inty) { Item1 = Floated(Item1); T1.Type = Realy; } } else { if (Op == Resolve) Getresolution(); else if (Op >= Eqeq) Getexpression(Simple, Any + Refonly); else if (Op >= Equals) { Getexpression(Major, C1); if (Equals <= Atom && Atom < Eqeq) { Op = Atom; Matched = 1; Getexpression(Major, C1); } if (T.Type == Realy && T1.Type == Inty) { Item1 = Floated(Item1); T1.Type = Realy; } } else { Getexpression(Scond, Any); if (Atom >= Cond) if (Atom != Op) Syntaxerror(); } T.Type = Booltype; if (Item) { T.Low = 0; T.Val = 1; } } if (!Item1) if (!Item) { T.Val = Litval(); if (!Item) continue; } if (!Item) { if (Op == Minus && T.Type == Inty) { if (T.Val != Minint) T.Val = -T.Val; Op = Plus; } if (T.Val == 0 && (Opok & Znop) != 0) { Item = Item1; continue; } } Item = Explo; T.Low = Minint; T.Val = Maxint; } Final:; Expp = Atomp1; if (!Compat(Control)) Expfault(Typerr); } void Getcondition(void) { int Polarity; Polarity = Subatom; Condnp = Np; Getexpression(Cond, Any); } void Getstatements(int Stopper) { int Holdnp; int Holdlooplab; static int Initial_sw; static void *Initial[108 /*0:107*/] = { &&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_default, &&Initial_15, &&Initial_16, &&Initial_17, &&Initial_default, &&Initial_19, &&Initial_default, &&Initial_default, &&Initial_22, &&Initial_23, &&Initial_24, &&Initial_25, &&Initial_26, &&Initial_27, &&Initial_28, &&Initial_29, &&Initial_30, &&Initial_default, &&Initial_default, &&Initial_33, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_37, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_41, &&Initial_42, &&Initial_default, &&Initial_default, &&Initial_45, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_52, &&Initial_default, &&Initial_54, &&Initial_default, &&Initial_default, &&Initial_default, &&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_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_79, &&Initial_default, &&Initial_default, &&Initial_82, &&Initial_83, &&Initial_default, &&Initial_default, &&Initial_default, &&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, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, }; void Getinstruction(void) { int Item1; int Hold; int Act; Identinfo *Ditem1; void Putact(void) {} if (C.Flags < Hadinst) { C.Flags = C.Flags + Hadinst; if (Level <= Outerlevel) Fault(Ordererr); } Instnp = Np; do if (A(Ident)) { if (Item <= 0) Nameerror(); if (Ditem->Flags & Var) { Matched = 0; Getexpression(Simple, Any); Item1 = Item; Ditem1 = Ditem; if (A(Equals)) { Getvalue(Ditem1->Type); } else if (A(Eqeq)) { if (Ditem1->Type < Indirect) Syntaxerror(); Getreference(Ditem1->Type); if (Item) Item += Ad; } else if (Atom == Less && *Byteinteger(Fp) == '-') { Fp++; Matched = 1; Jammy = 2; Getvalue(Ditem1->Type); } else { if (!A(Arrow)) Syntaxerror(); Getresolution(); } } else { if (!(Ditem->Flags & Proc)) Error(Caterr + Point); if (Ditem->Flags & Parm) Ditem = &Dict[Ditem->Type]; if (Ditem->Type != Nulltype) Error(Caterr + Point); if (A(Left)) { Getparmlist(); Get(Right); } else { if (Ditem->Flags & More) Error(Toofew + Point); } } } else { Act = Atom; Hold = Subatom; T.Val = 0; C.Access = 0; if (A(Monitor)) { C.Access = 1; } else if (A(Exit)) { if (!Looplab) Fault(Notinloop + Point); else { T.Val = Looplab; Putact(); } break; } else if (A(Return)) { if (C.Type != Nulltype) Fault(Notinrout + Point); else Putact(); break; } else if (A(Result)) { if (C.Type <= Nulltype) Error(Notinfun + Point); if (!Aassop()) Syntaxerror(); if (C.Type < Direct) { if (Atom == Eqeq) Fault(Caterr + Point); Getvalue(C.Type); } else { if (Atom != Eqeq) Fault(Caterr + Point); Getreference(C.Type + (Indirect - Direct)); } break; } else if (A(Tf)) { if (C.Type != Booltype) Fault(Notinpred + Point); else Putact(); break; } else if (A(Arrow) || A(Goto)) { if (Atom == Goto) Nonstandard(Kgoto); Get(Ident); if (*Byteinteger(Fp) != '(') { if (Item < C.Localdpos || (Ditem->Flags & Lab) == 0 || Ditem->Type != Nulltype) { D.Flags = Spec + Lab; D.Type = Nulltype; Declare(); } } else { if (Item < C.Localdpos) Nameerror(); if ((Ditem->Flags & Lab) == 0 || Ditem->Type == Nulltype) Syntaxerror(); Get(Left); Getvalue(Ditem->Type); Get(Right); } break; } else if (A(Stop)) { Putact(); break; } else if (A(Signal)) { C.Access = 1; Allow(Keyevent); Getlitint(); if (0 > T.Val || T.Val > 15) Expfault(Rangerr + Point); Hold = T.Val; T.Val = 0; if (A(Comma)) Getlitint(); Hold += T.Val << 4; Item = 0; T.Val = 0; if (A(Comma)) Getvalue(Anyint); break; } else Syntaxerror(); } while (A(Keyand)); } void Getforclause(void) { int Loopvar; int K; int S; int Start; int Sval; int I; int Inc; int Ival; int E; int N; int Temp; int Eval; Identinfo *Dp; Holdnp = Np; Temp = 0; Dict[Curlab].Val = 1; Condnp = Np; Get(Ident); if (Item <= 0) Nameerror(); if (Dict[Ditem->Type & Puretype].Type != Inty) Fault(Typerr + Point); if (Ditem->Type != Direct + Inttype) Fault(Caterr + Point + Warn); Loopvar = Item; Dp = Ditem; Get(Equals); Getvalue(Ditem->Type); Start = Item; Sval = T.Val; Get(Comma); Getvalue(Anyint); Inc = Item; Ival = T.Val; if (Inc == 0 && 0 == Ival) { Expfault(Rangerr + Point); Ival = 1; } Get(Comma); Getvalue(Ditem->Type); if (!Inc) { I = 1; if (!Start) { Sval -= Ival; S = 1; } else { S = Explo; } } else { S = Explo; } if (!(Start | Inc | Item)) { K = T.Val - Sval; N = K / Ival; if (N < 0) Fault(Boundserr); if (N * Ival != K) Fault(Unending); } } void Getswitchindex(void) { int Item1; Identinfo *Dp; Item1 = Item; Dp = Ditem; Get(Left); Item = 1; if (A(Star)) { if (Dp->Spare) Fault(Duperr + Point); Dp->Spare = 1; } else { Getliteral(Dp->Type); if (Dp->Type > Inttype && Faultnum == 0) { T.Val = T.Val - Dict[Dp->Type].Low + Dp->Val; if (Final[T.Val]) Expfault(Duperr + Point); Final[T.Val] = 1; } } Get(Right); C.Access = 1; } if (_imp_on_event(1, 14)) { if (Event.Event() == 1) Report(Rangerr, 0); goto Skip; } Next:; Statements++; Next1:; if (Faultnum) Report(Faultnum, Faultp); D = 0; Declmode = 0; Dsize = 0; Dlim0 = Dlim; Elements = 0; Speccing = 0; Mcoding = 0; Literal = 0; Jammy = 0; Dict[Curlab].Val = 0; Dict[Curlab + 1].Val = 0; Np = Np0; Instnp = Np0; Condnp = Np0; if (Explo < Expmin + 50 || Litpos > Litmax - 50) Forgetall(); T.Val = 0; Initial_52:; Atom = Nextatom(); Matched = 1; goto *Initial[Initial_sw = Atom]; Initial_88: Initial_82: Initial_83:; Readline(); goto Next1; Term:; Get(Terminator); goto Next; Skip:; C.Access = -1; if (Atom != Terminator) { do { Subatom = Atom; Atom = Nextatom(); } while (Atom != Terminator); if (Subatom == Start) Starts++; if (Subatom == Cycle) Cycles++; } goto Next; Initial_63:; Syntaxerror(); Initial_default:; Error(Nonstarter + Point); Initial_54:; if (*Byteinteger(Fp) == ':') { Fp++; D.Flags = Lab; D.Type = Nulltype; Declare(); Setuserlabel(Item); goto Next; } if (Item <= 0) Nameerror(); if (Ditem->Flags & Lab) { Getswitchindex(); Get(Colon); goto Next; } Initial_7: Initial_9: Initial_8:; Initial_10: Initial_12: Initial_13:; Initial_6: Initial_11: Initial_79:; Matched = 0; Getinstruction(); if (A(Terminator)) goto Next; C.Access = 1; if (A(Iu)) { Holdnp = Np; Getcondition(); } else if (A(While)) { Holdnp = Np; Getcondition(); } else if (A(For)) { Getforclause(); } else { if (!A(Until)) Syntaxerror(); Getcondition(); } goto Term; Initial_16:; for (;;) { Holdnp = Np; Getcondition(); if (A(Then)) { if (A(Start)) goto Fudge; Getinstruction(); } else { Get(Start); Fudge:; for (;;) { Get(Terminator); Curlab += 2; Getstatements(Else); Curlab -= 2; if (Atom != Else) break; if (A(Iu)) Getcondition(); } if (Atom != Finish) return; } if (!A(Else)) break; if (A(Start)) goto Fudge; if (!A(Iu)) { Getinstruction(); break; } } goto Term; Initial_22:; if (A(Terminator)) { Holdlooplab = Looplab; Looplab = Curlab; Curlab += 2; Getstatements(Repeat); Curlab -= 2; Looplab = Holdlooplab; if (Atom != Repeat) return; if (A(Until)) Getcondition(); goto Term; } Nonstandard(Oldcycle); Getforclause(); goto For1; Initial_17:; Holdnp = Np; Getcondition(); Get(Cycle); Get(Terminator); Holdlooplab = Looplab; Looplab = Curlab; Curlab += 2; Getstatements(Repeat); Curlab -= 2; Looplab = Holdlooplab; if (Atom != Repeat) return; if (A(Until)) { Nonstandard(Loop2); Getcondition(); } goto Term; Initial_19:; Getforclause(); Get(Cycle); For1:; Get(Terminator); Holdlooplab = Looplab; Looplab = Curlab; Curlab += 2; Getstatements(Repeat); Curlab -= 2; Looplab = Holdlooplab; if (Atom != Repeat) return; goto Term; Initial_15:; if (C.Flags >= Hadon || Level <= Outerlevel) Fault(Ordererr + Point); C.Flags = C.Flags | Hadon; Matched = 1; Allow(Keyevent); do { Getlitint(); if (0 > T.Val || T.Val > 15) Expfault(Rangerr + Point); C.Events = C.Events | 1 << T.Val; } while (A(Comma)); Get(Start); Curlab += 2; Getstatements(Finish); Curlab -= 2; if (Atom != Finish) return; goto Term; Initial_4:; if (Starts) goto Skip; if (Stopper == Else) return; if (Stopper == Finish) Error(Noif); Initial_3:; if (Starts) { Starts--; goto Skip; } if (Stopper == Finish || Stopper == Else) return; Error(Nostart); Initial_2:; if (Cycles) { Cycles--; goto Skip; } if (Stopper == Repeat) return; Error(Nocycle); int Newatype(int Eltype, int Xtype) { int Dpos; Identinfo *Dp; static Identinfo D = 0; Dpos = Dictmin; do { Dp = &Dict[Dpos]; if ((Dp->Flags & Typeid) != 0 && Dp->Type == Eltype && Dp->Val == Xtype) return (Dpos + Direct); Dpos++; } while (Dpos != Dlim); D.Flags = Typeid; D.Type = Eltype; D.Val = Xtype; Dict[Dpos] = D; Dlim++; if (Dlim >= Dmin) Croak(_imp_str_literal("Too many identifers")); return (Dpos + Direct); } int Newstype(int Max) { int Dpos; Identinfo *Dp; static Identinfo D = 0; Dpos = Dictmin; do { Dp = &Dict[Dpos]; if (Dp->Type == Stringy && Dp->Val == Max) return (Dpos); Dpos++; } while (Dpos != Dlim); D.Flags = Typeid; D.Type = Stringy; D.Val = Max; Dict[Dpos] = D; Dlim++; if (Dlim >= Dmin) Croak(_imp_str_literal("Too many identifers")); return (Dpos); } int Newrange(int Type, int Lower, int Upper) { int Dpos; Identinfo *Dp; static Identinfo D = 0; if (Lower > Upper) { Fault(Boundserr); Upper = Lower; } Elements = Maxint; if ((Upper ^ Lower) >= 0 || Minint + Upper - Lower < 0) Elements = Upper - Lower; if (Elements != Maxint) Elements++; Dpos = Dictmin; do { Dp = &Dict[Dpos]; if (Dp->Flags == Typeid && Dp->Type == Type && Dp->Low == Lower && Dp->Val == Upper) return (Dpos); Dpos++; } while (Dpos != Dlim); D.Flags = Typeid; D.Type = Type; D.Low = Lower; D.Val = Upper; Dict[Dpos] = D; Dlim++; if (Dlim >= Dmin) Croak(_imp_str_literal("Too many identifers")); return (Dpos); } void Getlitbounds(void) { int Lower; Get(Left); Getlitint(); Lower = T.Val; Get(Colon); Getlitint(); Get(Right); T.Low = Lower; Item = Newrange(Inty, T.Low, T.Val); } void Getident(void) { Dlim0 = Dlim; Get(Ident); Declare(); if ((D.Flags & Ext) != 0 && A(Alias)) Getlitstring(); } void Getidentlist(void) { Dlim0 = Dlim; do { Get(Ident); Declare(); if ((D.Flags & Ext) != 0 && A(Alias)) Getlitstring(); } while (A(Comma)); } void Gettype(int Flags) { static int Fbase; static Identinfo *Formp; static Identinfo *Fieldp; void Getformatdef(void) { int Disp; int Max; int Base; void Getfieldident(void) { Get(Ident); if (Item > 0) D.Text = Ditem->Text; else { D.Text = Charlim - Charbase; Charlim = Charlim + Newlen + 1; if (Charlim + 80 >= Charmin) Croak(_imp_str_literal("Identifier space exhausted")); } Ditem = &Dict[Dlim]; Fieldp = Ditem; *Ditem = D; if (!Formp->Extra) Formp->Extra = Dlim; Dlim++; if (Dlim >= Dmin) Croak(_imp_str_literal("Too many identifiers")); } void Getunit(void) { for (;;) if (A(Left)) { Getformatdef(); Get(Right); if (!A(Comma)) return; } else { Gettype(Static + More); if (!(D.Flags & Parm)) do { if ((Disp & 1) != 0 && Dsize != 1) Disp++; D.Val = Disp; Disp += Dsize; Getfieldident(); if (!A(Comma)) return; Atom = Nextatom(); } while (Atom == Ident); else { D.Flags = D.Flags - Parm; if (Disp & 1) Disp++; D.Val = Disp; Getfieldident(); Getlitbounds(); Fieldp->Type = Newatype(D.Type, Item); Disp += Dsize * Elements; if (!A(Comma)) return; } } } Max = 0; Base = 0; do { Disp = Base; Getunit(); if (Max < Disp) Max = Disp; } while (A(Keyor)); Base = Max; } Dsize = 0; D.Mode = 0; D.Val = 0; D.Type = Nulltype; if (A(Rpred)) { if (Flags & Ext) Flags = Flags & (~Static); if (Flags & Static) Syntaxerror(); if (Subatom) { Nonstandard(Pred); D.Type = Booltype; } D.Flags = Flags + Proc; Declmode += Pcmode; return; } if (A(Krange)) { D.Type = Inttype + Subatom; Dsize = 1; if (D.Type == Shorttype || D.Type == Halftype) Dsize = 2; if (D.Type >= Mitetype) Nonstandard(Ranges); Allow(Keyinteger); } else if (A(Keyinteger)) { D.Type = Inttype; Dsize = 4; Atom = Nextatom(); if (Atom == Left) { Getlitbounds(); D.Type = Item; if (Elements <= 65536 && T.Low >= -32768) Dsize = 2; if (Elements <= 256 && T.Low >= -128) Dsize = 1; } } else if (A(Keylong)) { D.Type = Longinttype; Dsize = 8; if (!A(Keyinteger)) { D.Type = Longrealtype; Get(Keyreal); } } else if (A(Keyreal)) { D.Type = Realtype; Dsize = 4; } else if (A(Keystring)) { D.Type = Stringy; T.Val = 255; Dsize = 256; if (A(Left)) { T.Val = 0; if (!A(Star)) { Getlitint(); if (0 >= T.Val || T.Val > 255) { Expfault(Rangerr + Point); T.Val = 255; } } Get(Right); } else Nonstandard(Nolength); if (T.Val) { D.Type = Newstype(T.Val); Dsize = (T.Val + 2) & (~1); } } else if (A(Keyrecord)) { D.Type = Recy; if (A(Keyformat)) { if (Flags & (Static + Ext)) Syntaxerror(); if (A(Keyspec)) { D.Flags = Typeid + Spec; Getident(); } else { D.Flags = Typeid; Getident(); Formp = Ditem; Get(Left); Fbase = 0; Getformatdef(); Fieldp->Flags = Fieldp->Flags - More; Get(Right); } D.Flags = Typeid; return; } Get(Left); if (!A(Star)) { if (!A(Ident)) { Getformatdef(); Fieldp->Flags = Fieldp->Flags - More; Get(Right); D.Flags = Typeid; Declareanon(); } if (Item <= 0) Nameerror(); if (Ditem->Type != Recy) Syntaxerror(); D.Type = Item; Dsize = Ditem->Val; } Get(Right); } else { if (Atom != Keyname) Syntaxerror(); } if (Dsize <= 4) if (Dsize <= 2) Declmode = Dsize << Sizeshift; else Declmode = Longsize << Sizeshift; if (A(Fnmap)) { if (Flags & Ext) Flags = Flags & (~Static); if (Flags & Static) Syntaxerror(); if (Subatom) { Flags++; D.Type = D.Type + Direct; } D.Flags = Flags + Proc; Declmode += Pcmode; return; } D.Type = D.Type + Direct; while (A(Keyarray) || A(Keyname)) { if (Atom == Keyarray) { if (D.Type >= Indirect) Nonstandard(Naming); if (!A(Keyname)) { if (Flags & Parm) Syntaxerror(); Flags += Parm; break; } D.Type = Newatype(D.Type, Inty); } if (D.Type >= Indirect) Syntaxerror(); D.Type = D.Type + (Indirect - Direct); Dsize = 4; } D.Flags = Flags ^ Var; } void Getownarraydeclaration(void) { int Holdval; int Dpos; Identinfo *Dp; Getident(); Dpos = Item; Dp = Ditem; Getlitbounds(); Dp->Type = Newatype(D.Type, Item); if (Aassop()) { Allow(Terminator); do { Getliteral(D.Type); if (Faultnum == Rangerr + Point) Faultnum = Rangerr + Point + Warn; Holdval = T.Val; T.Val = 1; if (A(Left)) { T.Val = Elements; if (!A(Star)) Getlitint(); Get(Right); } Elements -= T.Val; } while (A(Comma)); if (Elements != 0 && Faultnum == 0) Report(Counterr, Dpos); } } void Getarraydeclaration(void) { int I; int Dlim1; int Hold; int Holdval; int Type; void Getbounds(void) { int Range; Getvalue(Anyint); Hold = Item; if (Hold) T.Val = Minint; Holdval = T.Val; Get(Colon); Getvalue(Anyint); if (Item) T.Val = Maxint; Range = Newrange(Inty, Holdval, T.Val); if (A(Comma)) Getbounds(); Type = Newatype(Type, Range); } do { Type = D.Type; Getidentlist(); Dlim1 = Dlim; Get(Left); Getbounds(); Get(Right); while (Dlim0 != Dlim1) { Dict[Dlim0].Type = Type; Dlim0++; } } while (A(Comma)); } void Getparmdef(void) { int Headitem; int Dpos; int Dlim1; Identinfo *Headditem; Identinfo *Dp; int Parmmatch(int Apos) { int Bpos; Identinfo *Ap; Identinfo *Bp; Bpos = Dlim1; Ap = &Dict[Apos]; while (Bpos != Dlim) { if (!(Ap->Flags & More)) return (0); do { Apos++; Ap = &Dict[Apos]; } while (!(Ap->Flags & Parm)); Bp = &Dict[Bpos]; if (Ap->Type != Bp->Type) return (0); Bpos++; } if (!(Ap->Flags & More)) return (1); return (0); } Headitem = Item; Headditem = Ditem; Dlim1 = Dlim; if (A(Left)) { for (;;) { if (Atom != Ident) Gettype(Parm | More); if (!(D.Flags & Proc)) { Getident(); if (!A(Comma) && Atom == Right) break; if (Atom != Comma) Nonstandard(Nocomma); else Atom = Nextatom(); } else { Getident(); Speccing += 2; Getparmdef(); Speccing -= 2; if (!A(Comma)) break; } } Dict[Dlim - 1].Flags = Dict[Dlim - 1].Flags - More; Get(Right); } if (Speccing >= 2) { Dpos = Dictmin; do { Dp = &Dict[Dpos]; if ((Dp->Flags & Proc) != 0 && Dp->Type == Headditem->Type) if (Parmmatch(Dpos)) { Headditem->Type = Dpos; Dlim = Dlim1; return; } Dpos++; } while (Dpos < Headitem); Fault(Caterr); Dlim = Dlim1; return; } if (Speccing == 0 && (Headditem->Flags & Spec) != 0) { Headditem->Flags = Headditem->Flags - Spec; if (!Parmmatch(Headitem)) Fault(Matcherr); } else if (Dlim != Dlim1) Headditem->Flags = Headditem->Flags | More; } Initial_23: Nonstandard(Klabel); D.Flags = Lab + Spec; D.Type = Nulltype; Getidentlist(); goto Term; Initial_24:; D.Flags = Subatom; Atom = Nextatom(); Initial_25: Initial_26:; Initial_27: Initial_28:; Initial_29: Initial_30:; Initial_33:; Matched = 0; Gettype(D.Flags); if (A(Keyspec)) { if (A(Left)) { Getlitint(); Get(Right); Declmode = (Declmode & Sizemask) + Absmode; D.Val = T.Val; Getident(); if (D.Flags & Proc) { Speccing = 1; Getparmdef(); } goto Term; } D.Flags = D.Flags + Spec; if (!(D.Flags & Proc)) { Getidentlist(); goto Term; } } if (D.Flags & Proc) { Get(Ident); if (Item >= C.Localdpos && Ditem->Type == D.Type && (Ditem->Flags & Proc) != 0) { if ((Ditem->Flags & Spec) == 0 || (D.Flags & Spec) != 0) { Item = 0; D.Flags = D.Flags + Alt; Declare(); } } else Declare(); if ((D.Flags & Ext) != 0 && A(Alias)) Getlitstring(); if (D.Flags & Spec) { Speccing = 1; Getparmdef(); } else { Openblock(Item); Getparmdef(); C.Parlim = Dlim; Compileentry(); Get(Terminator); Getstatements(End); Closeblock(); } } else if (D.Flags == Typeid) ; else if (D.Flags & Parm) { D.Flags = D.Flags - Parm; if (D.Flags & Static) Getownarraydeclaration(); else { if ((D.Flags & Static) == 0 && C.Flags >= Hadon) { Fault(Ordererr); C.Flags = C.Flags & (~(Hadon + Hadinst)); } Getarraydeclaration(); } } else if (D.Flags == Static) { D.Type = Dict[D.Type & Puretype].Type; if (D.Type == Recy || D.Type == Stringy) D.Type = D.Type + Direct; do { Getident(); if (!Aassop()) Syntaxerror(); Getliteral(D.Type); if (Faultnum == Rangerr + Point) Faultnum = Rangerr + Point + Warn; Dict[Dlim - 1].Val = T.Val; } while (A(Comma)); } else if (D.Flags & Static) { Declmode += Ownmode; do { Getident(); T.Val = 0; if (Aassop()) { Getliteral(D.Type); if (Faultnum == Rangerr + Point) Faultnum = Rangerr + Point + Warn; } Elements = 1; } while (A(Comma)); } else { if ((D.Flags & Static) == 0 && C.Flags >= Hadon) { Fault(Ordererr); C.Flags = C.Flags & (~(Hadon + Hadinst)); } do { C.Delta = C.Delta - Dsize; if (C.Delta & 1) C.Delta = C.Delta - 1; T.Val = C.Sp + C.Delta; Getident(); if (Aassop()) { Nonstandard(Initass); if (D.Type >= Indirect) { if (Atom != Eqeq) Fault(Caterr + Point); Getreference(D.Type); if (Item) Item += Ad; } else { if (Atom == Eqeq) Fault(Caterr + Point); Getvalue(D.Type); } } } while (A(Comma)); } goto Term; void Getswitchdeclaration(void) { int I; int J; int Dlim1; Matched = 1; do { D.Flags = Lab; D.Type = Nulltype; Declmode = Pcmode + (Wordsize << Sizeshift); Getidentlist(); Dlim1 = Dlim; Getlitbounds(); do { if (Spc - Elements <= 0) break; for (I = 1; I <= Elements; I++) { Spc--; Final[Spc] = 0; } Dict[Dlim0].Val = Spc; Dict[Dlim0].Type = Item; Dlim0++; } while (Dlim0 != Dlim1); } while (A(Comma)); } Initial_37:; Getswitchdeclaration(); goto Term; Initial_42:; Getlitint(); if (!T.Val) Control = 0; Control = Control ^ T.Val; goto Term; Initial_45:; Getlitstring(); Extra.Name = _imp_str_literal(""); while (T.Val > 0) { Extra.Name = _imp_join(Extra.Name, Tostring(*Byteinteger(Atomp))); Atomp++; T.Val = T.Val - 1; } Get(Terminator); if (!Faultnum) { Connectedfile(Extra); if (Extra.Flag) { Nonstop = -999; _imp_signal(12, 0, 0, _imp_str_literal("")); } Mainfp = Fp; Mainline = Line; Line = 0; Sym = Nl; Fp = Extra.Start2; Curstart = Fp; Curlim = Extra.Lim2; Modesym = '&'; Nonstop++; } goto Next; Initial_41:; goto Term; Initial_5:; C.Sp = -8; Get(Terminator); Openblock(0); Getstatements(0); Closeblock(); if (Stopper >= 0) goto Term; return; Initial_1:; if (!A(Of)) { if (Stopper == Else || Stopper == Finish) Fault(Nofinish); if (Stopper == Repeat) Fault(Norepeat); if (Stopper >= 0) return; Fault(Nobegin); goto Term; } if (A(Keylist)) goto Term; if (A(Keyfile)) { if (Curlim == Extra.Lim2) { Switchinput(); goto Next; } } else Get(Program); } void Init(int T, int L, int H) { D.Flags = Typeid; D.Type = T; D.Low = L; D.Val = H; Dict[Dlim] = D; Dlim++; } if (_imp_on_event(12)) { if (Fp == Main.Lim2) goto Printout; if (Main.Flag < 0 || Nonstop == -999) goto Ended; Change = Main.Change; } Printstring(_imp_str_literal(" IMP Checker ")); Newline(); for (I = 0; I <= 255; I++) Hashindex[I] = 0; Charbase = Addr(Char[0]); *Byteinteger(Charbase) = 0; Charlim = Charbase + 1; Charmin = Charlim + Charbound; for (I = D0; I <= Labmax; I++) Dict[I].Val = 0; D.Flags = Typeid; D.Low = Minint; D.Val = Maxint; Dmin = Dictmax - 1; Dlim = Dictmin; do { D.Type = Dlim; Dict[Dlim] = D; Dlim++; } while (Dlim <= Booltype); D.Flags = 0; Init(Booltype, 0, 0); Init(Booltype, 0, 1); D.Flags = Typeid; Init(Inty, Minint, Maxint); Init(Inty, -32768, 32767); Init(Inty, 0, 65535); Init(Inty, 0, 255); Init(Inty, -128, 127); Init(Inty, 0, 1); Init(Inty, Minint, Maxint); Init(Realy, Minint, Maxint); Init(Realy, Minint, Maxint); C = 0; C.Localdpos = Dlim; C.Parlim = Dlim; Level = Outerlevel; Spc = Finalbound; Faults = 0; Line = 0; Mainline = 0; Mainfp = Main.Start1; Extra.Name = Permfile; Connectedfile(Extra); if (Extra.Flag) { Nonstop = -999; _imp_signal(12, 0, 0, _imp_str_literal("")); } Fp = Extra.Start2; Curstart = Fp; Curlim = Extra.Lim2; Nonstop = -2; if (Main.Flag == 'I') Nonstop = -1; Sym = Nl; Getstatements(-1); Printout:; if (!Faults) { Write(Statements, 1); Printstring(_imp_str_literal(" statements checked ")); } else { Write(Faults, 1); Printstring(_imp_str_literal(" fault")); if (Faults > 1) Putsym('s'); Printstring(_imp_str_literal(" reported ")); } Newline(); Ended:; Newline(); } int _imp_mainep(int _imp_argc, char **_imp_argv) { exit(0); return (1); }