#include <perms.h>
_imp_string7 P2VERSION = _imp_str_literal("004");
static int DIAG = 0;
static int DEBUG = 0;
static int CURRENTLINE = 0;
const unsigned char INTERNALTYPE[14] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 4, 13};
const _imp_string7 TYPEID[14] = {_imp_str_literal("Unknown"), _imp_str_literal("Integer"), _imp_str_literal("Short "),
_imp_str_literal("Half "), _imp_str_literal("Byte "), _imp_str_literal("Addr "),
_imp_str_literal("Real "), _imp_str_literal("Lreal "), _imp_str_literal("String "),
_imp_str_literal("Record "), _imp_str_literal("General"), _imp_str_literal("Label "),
_imp_str_literal("Boolean"), _imp_str_literal("Set ")};
const unsigned char TYPEFMT[14] = {0, 4, 2, 2, 1, 4, 4, 8, 0, 0, 0, 0, 1, 32};
const unsigned char TYPECODE[14] = {0, 1, 6, 6, 5, 1, 2, 8, 3, 4, 0, 10, 0, 0};
const unsigned char TYPESIZE[14] = {0, 4, 2, 2, 1, 4, 4, 8, 0, 0, 12, 0, 2, 32};
const unsigned char UCHECK[14] = {0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0};
struct COMMFM {
union {
struct {
int LANGUAGE;
int OPTIONS;
int SPECIALS;
int PRIM;
int STATEMENTS;
int FAULTS;
int REFCOUNT;
int PRIMREFCOUNT;
int DEFCOUNT;
int PRIMDEFCOUNT;
int BLOCKCOUNT;
int PRIMBLOCKCOUNT;
int EXTERNALCOUNT;
int PRIMEXTERNALCOUNT;
int GLOBALSIZE;
int PRIMGLOBALSIZE;
int FORMATS;
int PRIMFORMATS;
int CONSTANTSIZE;
int PRIMCONSTANTSIZE;
int GLOBALARRAYSIZE;
int TOTALITEMS;
int TOTALBLOCKS;
int TOTALFORMATS;
int TOTALEXTERNALS;
_imp_string255 SOURCEFILE;
_imp_string255 MODULE;
};
};
};
void PASS2(struct COMMFM *INTERFACE) {
extern void D68000(int OP, int CA);
extern void DUMPENCODED(int N);
extern void PRINTHEX(int N, int P) __asm__("3L_IMP_PRINT_HEX");
const unsigned char ACTUAL[27] = {0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
13, 14, 15, 0, 0, 1, 2, 3, 4, 5, 6, 7, 0};
const _imp_string3 REGID[27] = {
_imp_str_literal(""), _imp_str_literal("R0 "), _imp_str_literal("R1 "), _imp_str_literal("R2 "),
_imp_str_literal("R3 "), _imp_str_literal("R4 "), _imp_str_literal("R5 "), _imp_str_literal("R6 "),
_imp_str_literal("R7 "), _imp_str_literal("R8 "), _imp_str_literal("R9 "), _imp_str_literal("R10"),
_imp_str_literal("R11"), _imp_str_literal("R12"), _imp_str_literal("R13"), _imp_str_literal("R14"),
_imp_str_literal("R15"), _imp_str_literal("R? "), _imp_str_literal("F0 "), _imp_str_literal("F1 "),
_imp_str_literal("F2 "), _imp_str_literal("F3 "), _imp_str_literal("F4 "), _imp_str_literal("F5 "),
_imp_str_literal("F6 "), _imp_str_literal("F7 "), _imp_str_literal("F? ")};
const unsigned char RTYPE[27] = {0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 7, 7, 7, 7, 7, 7, 7, 7, 7};
struct BOUNDFM {
union {
struct {
int LOWER;
int UPPER;
int MULT;
};
};
};
struct AFM {
union {
struct {
int DIMENSION;
int TOTALSIZE;
int ZERODISPLACEMENT;
int DV;
int LOCALFRAME;
int BASE;
struct BOUNDFM BOUND[7];
};
};
};
const struct AFM *ATYPE = 0;
struct VARFM {
union {
struct {
int FLAGS;
unsigned char BASE;
unsigned char PRIM;
unsigned char TYPE;
unsigned char FORM;
union {
struct {
double RVAR;
};
struct {
int DISP;
union {
struct {
int EXTRA;
};
struct {
struct AFM *ADATA;
};
};
};
};
union {
struct {
int FORMAT;
};
struct {
int SCALE;
};
};
int AREA;
};
};
};
struct OLFM {
union {
struct {
int OPER;
struct STACKFM *LINK;
};
};
};
struct XFM {
union {
struct {
int XSIZE;
struct STACKFM *INDEX;
};
};
};
struct DATAFM {
union {
struct {
struct VARFM V;
int VARNO;
struct VARFM *FV;
union {
struct {
int BIAS;
};
struct {
unsigned char REG;
unsigned char LABEL;
};
};
struct STACKFM *PARAMS;
struct STACKFM *RECORD;
union {
struct {
int OPER;
struct STACKFM *LINK;
};
struct {
struct OLFM OPLINK;
};
};
union {
struct {
int XSIZE;
struct STACKFM *INDEX;
};
struct {
struct XFM X;
};
};
};
};
};
struct MEMBERFM {
union {
struct {
int CONST;
int ITEMS;
struct STACKFM *A;
struct STACKFM *B;
struct MEMBERFM *LINK;
};
};
};
const struct MEMBERFM *MEMBERFMTYPE = 0;
struct STACKFM {
union {
struct {
struct VARFM V;
};
struct {
struct DATAFM DATA;
};
struct {
int FLAGS;
unsigned char BASE;
unsigned char PRIM;
unsigned char TYPE;
unsigned char FORM;
union {
struct {
double RVAL;
};
struct {
int RHIGH;
int RLOW;
};
struct {
union {
struct {
int DISP;
union {
struct {
int EXTRA;
};
struct {
struct AFM *ADATA;
};
};
};
};
union {
struct {
int FORMAT;
};
struct {
int SCALE;
};
};
int AREA;
int VARNO;
union {
struct {
struct VARFM *FV;
};
struct {
struct MEMBERFM *MEMBERS;
};
};
union {
struct {
int BIAS;
};
struct {
unsigned char REG;
unsigned char LABEL;
};
};
struct STACKFM *PARAMS;
struct STACKFM *RECORD;
union {
struct {
int OPER;
struct STACKFM *LINK;
};
struct {
struct OLFM OPLINK;
};
};
union {
struct {
int XSIZE;
struct STACKFM *INDEX;
};
struct {
struct XFM X;
};
};
};
};
struct STACKFM *USING;
struct STACKFM *STACK;
};
};
};
const struct STACKFM *STACKFMTYPE = 0;
struct WITHFM {
union {
struct {
int KEY;
struct DATAFM DATA;
struct WITHFM *LINK;
};
};
};
const struct WITHFM *WITHFMTYPE = 0;
struct WORKFM {
union {
struct {
int SIZE;
int DISPLACEMENT;
int VALIDITY;
};
};
};
struct WORKVFM {
union {
struct {
struct WORKVFM *LINK;
struct WORKFM W[31];
};
};
};
const struct WORKVFM *WORKVFMTYPE = 0;
struct WORKVFM WORKLIST;
WORKLIST = 0;
int WORKVALIDITY;
WORKVALIDITY = 1;
int LASTWORK;
LASTWORK = -1;
struct FORFM {
union {
struct {
unsigned char LABEL;
unsigned char ENTRY;
unsigned char REG;
unsigned char CC;
int TYPE;
int AS;
struct DATAFM CONTROL;
struct DATAFM FINAL;
struct FORFM *LINK;
};
};
};
const struct FORFM *FORFMTYPE = 0;
static struct FORFM *FORS = 0;
static struct STACKFM *STACK = 0;
static struct STACKFM *USING = 0;
static struct STACKFM *DASL = 0;
struct VALUEFM {
union {
struct {
double REAL;
};
struct {
int INTEGER;
};
struct {
_imp_string255 STRING;
};
struct {
unsigned char FILL[256];
};
};
};
static struct VALUEFM VALUE = 0;
static struct VALUEFM DEFAULTVALUE = 0;
const _imp_string4 OPERID[29] = {
_imp_str_literal("not "), _imp_str_literal("neg "), _imp_str_literal("abs "), _imp_str_literal("add "),
_imp_str_literal("sub "), _imp_str_literal("mul "), _imp_str_literal("div "), _imp_str_literal("exp "),
_imp_str_literal("and "), _imp_str_literal("or "), _imp_str_literal("xor "), _imp_str_literal("bic "),
_imp_str_literal("rot "), _imp_str_literal("lsh "), _imp_str_literal("rsh "), _imp_str_literal("rem "),
_imp_str_literal("mod "), _imp_str_literal("ext "), _imp_str_literal("mulh"), _imp_str_literal("udiv"),
_imp_str_literal("urem"), _imp_str_literal("conc"), _imp_str_literal("negr"), _imp_str_literal("absr"),
_imp_str_literal("addr"), _imp_str_literal("subr"), _imp_str_literal("mulr"), _imp_str_literal("divr"),
_imp_str_literal("expr")};
const short int OPERFLAGS[29] = {40, 40, 32, 589, 588, 769, 640, 642, 781, 781, 781, 780, 640, 648, 648,
128, 128, 128, 128, 128, 128, 128, 168, 160, 129, 128, 129, 128, 130};
const int EASYOP[9] = {8388608, 4194304, 0, 0, 0, 0, 25165824, 2097152, 29360128};
const int NULLVALUE[12] = {0, 0, 1, 1, 1, -1, 0, 0, 0, 0, 0, 0};
const unsigned char REVERSE[10] = {0, 1, 4, 5, 2, 3, 6, 7, 8, 9};
const unsigned char NEGATED[10] = {7, 6, 5, 4, 3, 2, 1, 0, 9, 8};
int J;
int NN;
static int CODE = 0;
static int PENDING = 0;
static int PENDINGTAG = 0;
static int PENDINGLIT = 0;
static int PENDINGAUTON = 0;
static int PENDINGAUTO = 0;
static int PENDINGAUTOCA = 0;
static int LANGUAGEFLAGS = 0;
static int STACKCHECK = 0;
static int FALIGN = 0;
static int INVERT = 0;
static int UNSIGNED = 0;
static int FREELABEL;
struct KNOWFM {
union {
struct {
unsigned char FTYPE;
unsigned char REG;
unsigned char BASE;
unsigned char OPER;
int DISP;
int AREA;
int OPND;
int EXTRA;
struct KNOWFM *LINK;
};
};
};
const struct KNOWFM *KNOWFMTYPE = 0;
struct LABELFM {
union {
struct {
int LAB;
struct KNOWFM *ENV;
};
};
};
struct ILABELFM {
union {
struct {
struct ILABELFM *LINK;
struct LABELFM LAB[256];
};
};
};
const struct ILABELFM *ILABELFMTYPE = 0;
struct ILABELFM *ILABELLIST;
ILABELLIST = NIL;
struct ILABELPFM {
union {
struct {
struct ILABELFM *LABEL;
};
};
};
struct ILABELPFM ILABELS[((unsigned int)8191 >> 8) + 1];
static struct KNOWFM *KNOWING = 0;
static struct KNOWFM *KASL = 0;
static int KTIMES[27] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
static int USEDTIME = 0;
static int USED[27] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
static int ACTIVITY[27] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
static int ACTIVEREGISTERS = 0;
int PENDINGKNOWNREGISTER;
PENDINGKNOWNREGISTER = 0;
struct STACKFM PENDINGKNOWN;
static _imp_string127 ALIAS = _imp_str_literal("");
static _imp_string127 INTERNALID = _imp_str_literal("");
static _imp_string127 EXTERNALID = _imp_str_literal("");
static _imp_string127 SECTIONID = _imp_str_literal("");
static int DECLSIZE;
static int VLB;
static int VUB;
static int OSTATE;
static int OWNTYPE;
static int OWNFORM;
static int OWNEXTRA;
static int CONSTANTTYPE;
static int INITFLAG = 0;
struct VARFM *DEFV;
struct VARFM ALTV;
static int PARMS;
static int SECTION = 0;
static int CONTROL = 0;
static int UNASSIGNED = 0;
static int COMPILINGPRIM = 0;
const _imp_string6 FORMID[6] = {_imp_str_literal("addr"), _imp_str_literal("value"), _imp_str_literal("()+"),
_imp_str_literal("-()"), _imp_str_literal("proc"), _imp_str_literal("label")};
static int ENTERPROC = 0;
const int CORRUPTS[56] = {0, 1, 4607, 0, 47, 393217, 4095, 60, 126, 15, 9, 0, 7, 15,
0, 0, 2287, 135, 0, 25, 0, 0, 4095, 77, 25, 0, 0, 58,
2559, 2559, 2559, 2559, 0, 0, 58, 0, 3, 63, 0, 31, 262145, 62,
511, 255, 8189, 56, 1023, 1023, 15, 510, 2559, 393217, 131073, 0, 0, 6160};
const int PRIMPARAMETER[56] = {0, 6, 7966, 2, 6, 131073, 0, 12, 6, 7, 6, 0, 7, 7,
0, 14, 2054, 4230, 0, 258, 0, 0, 0, 4172, 258, 0, 2, 259,
2304, 2304, 2304, 2304, 10, 0, 259, 10, 3, 6, 0, 7, 3, 6,
56, 472, 2, 7, 0, 0, 6, 1, 3, 131073, 131072, 0, 0, 16};
static int LASTDIR = 0;
static int REFS = 0;
static int BLOCKS = 0;
static int OWNBASE = 0;
static int MINSB = 0;
static int OWNARRAYBASE = 0;
static int CONSTANTBASE = 0;
static int CURRENTAREA = 0;
static int LASTAREA = 0;
static int EXTERNALNO = 0;
static int FRAMEUSE[18] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
static int FMARK = 0;
struct STACKFM UAPAT;
struct STACKFM ZERO;
struct STACKFM ONE;
struct STACKFM SPV;
struct STACKFM REGV[27];
struct VARFM *FORRANGE;
FORRANGE = NIL;
struct STACKFM C255;
C255 = 0;
C255.DISP = 255;
C255.TYPE = 1;
static int JAMIT = 0;
static int ENTRYPOINT = -1;
static int DANGERLEVEL = 32767;
_imp_string127 INCLUDEFILE;
INCLUDEFILE = _imp_str_literal("");
int DTYPE;
struct QFM {
union {
struct {
int TYPE;
int SIZE;
int ROUND;
int BIAS;
int DIM;
int FORMAT;
int DIAGS;
int DTYPE;
int DFORM;
int IND;
struct QFM *POINTED;
};
};
};
struct DIAGFM {
union {
struct {
struct DIAGFM *LINK;
struct VARFM *VAR;
int X;
int XTYPE;
int FORMAT;
int EXT;
_imp_string127 ID;
};
};
};
const struct DIAGFM *DIAGFMTYPE = 0;
struct DIAGFM *DIAGLIST;
DIAGLIST = NIL;
static short int DISPLAYVECTOR[18] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
static int CP = 0;
unsigned char CODEBUFFER[256];
struct VVFM {
union {
struct {
struct VVFM *LINK;
struct VARFM V[64];
};
};
};
const struct VVFM *VVFMTYPE = 0;
struct VVFM *VARLIST;
VARLIST = NIL;
struct PVFM {
union {
struct {
struct VVFM *P;
};
};
};
struct PVFM PVAR[32];
struct VARFM *VAR(int A) {
struct VVFM *V;
struct PVFM *X;
X = /*%A*/ /*addressof*/ &PVAR[(unsigned int)A >> 6];
if (/*%A*/ /*addressof*/ &X->P != NIL) goto L_0001;
V = _imp_NEW(VVFMTYPE);
V->LINK = VARLIST;
VARLIST = V;
X->P = V;
L_0001:
return /*%A*/ /*addressof*/ &X->P[A & 63];
} /* VAR */
void FLUSHCODE(void) {
int J;
if (CP != 0) goto L_0002;
return;
L_0002:
_imp_PRINTSYMBOL(31);
DUMPENCODED(CP);
J = 0; /*%for J = 1, 1, CP %cycle*/
L_0003:
if (J == CP) goto L_0004;
J += 1;
_imp_PRINTSYMBOL(CODEBUFFER[J]);
goto L_0003;
L_0004:
CP = 0;
} /* FLUSHCODE */
void ASSEMBLE(struct VARFM * AVAR, int AMODE, int VARS, int LOCAL, int PARAMETERLIST, int *GLOBALATTRIBUTES) {
auto void NOTINYET(void);
auto void FAIL(_imp_string63 WHY);
auto void WARN(int FAULT, _imp_string63 WHAT);
auto void DISPLAY(struct STACKFM * V, int BIAS);
auto void MONITOR(struct STACKFM * V, _imp_string127 TEXT);
auto int ICONST(struct STACKFM * V);
auto int ICONSTITEM(struct STACKFM * V);
auto int CONST(struct STACKFM * V);
auto int SAME(struct STACKFM * A, struct STACKFM * B);
auto int INREG(struct STACKFM * V);
auto int FLOATING(struct STACKFM * V);
auto int POWER(int N);
auto int ITEMSIZE(int F);
auto struct STACKFM *REGISTER(int REG);
auto void CLAIM(int REGISTER);
auto void RELEASE(int REGISTER);
auto void RELEASEANDDROP(struct STACKFM * V);
auto void ZAPINDEXANDRECORD(struct STACKFM * V);
auto void RELEASEANDDROPPAIR(struct STACKFM * A, struct STACKFM * B);
auto void HAZARD(int REG);
auto void PESSIMISE(struct STACKFM * V);
auto void FORGET(int REGISTER);
auto void FORGETDESTINATION(struct STACKFM * V);
auto void FORGETEVERYTHING(void);
auto void REMEMBER(int REGISTER, struct STACKFM *V);
auto void REMEMBERZERO(int REGISTER);
auto void OPTIMISE(struct STACKFM * V, int SWANTED);
auto void SIMPLIFY(struct STACKFM * V);
auto void AMAP(struct STACKFM * V);
auto void VMAP(struct STACKFM * V, int NEWTYPE);
auto void MAKEAUTOI(struct STACKFM * V, int TYPE);
auto void ADVANCE(struct STACKFM * V, int TYPE, int BY);
auto void LOAD(struct STACKFM * V, int R);
auto void LOADUP(struct STACKFM * FROM);
auto void LOADADDRESS(struct STACKFM * V, int R);
auto void LOADUPADDRESS(struct STACKFM * V);
auto void LOADPAIR(struct STACKFM * A, int AR, struct STACKFM *B, int BR);
auto void LOADTRIO(struct STACKFM * A, int AR, struct STACKFM *B, int BR, struct STACKFM *C, int CR);
auto void POPSTACK(int BYTES);
auto void LOADPROTECTED(struct STACKFM * V);
auto void MOVE(struct STACKFM * FROM, struct STACKFM * TO);
auto void MOVELITERAL(int VALUE, struct STACKFM *TO);
auto void STORE(struct STACKFM * R, struct STACKFM * L);
auto void STOREADDRESS(struct STACKFM * R, struct STACKFM * L, int *EXTRA);
auto void OPERATE(int NEWOPER, struct STACKFM *LHS, struct STACKFM *RHS);
auto void COMPARE(struct STACKFM * LEFT, struct STACKFM * RIGHT);
auto int NEWLABEL(void);
auto void JUMPTO(int INTERNALLABEL, int CONDCODE);
auto void DEFINELABEL(int INTERNALLABEL);
auto void TESTZERO(struct STACKFM * V);
auto void TESTRANGE(struct STACKFM * S, struct VARFM * V);
auto void CLEARVARS(int LIMIT);
auto void DIRSTRING(int OP, _imp_string *S);
auto void FLOAT(struct STACKFM * V, int R);
auto void DUMPEXTERNAL(int CODE, struct VARFM *V);
auto void DO(_imp_string31 IDENT, int *EP, int RESULT);
auto int GPR(void);
auto int FPR(void);
auto int SELECTBEST(struct STACKFM * FROM, struct STACKFM * TO, int DEFAULT);
auto struct STACKFM *DESCRIPTOR(void);
auto struct STACKFM *TEMPORARY(void);
auto void DROP(struct STACKFM * V);
auto struct STACKFM *LOCALINTEGER(int DISP);
auto struct STACKFM *LITERAL(int N);
auto struct STACKFM *COPY(struct STACKFM * V);
auto int TAG(void);
auto int FOURBYTES(void);
auto void PRIM(int N);
auto void DUMPTEXT(int MAX);
auto void PASSPARAMETERS(struct STACKFM * V, int *EXTRA, int BASEREG);
auto void ASSIGN(int HOW);
auto void STRINGASSIGN(struct STACKFM * R, struct STACKFM * L);
auto void SETASSIGN(struct STACKFM * FROM, struct STACKFM * DEST);
auto void EVALUATESTRINGEXPRESSION(struct STACKFM * V);
auto void RECORDASSIGN(struct STACKFM * FROM, struct STACKFM * TO);
auto struct STACKFM *CLAIMWORKAREA(int BYTES, int TYPE);
auto void FLUSHDIAGS(void);
auto void CONVERTFORMAT(struct STACKFM * V, int TYPE);
auto void TOSHORTREAL(struct STACKFM * V);
auto void STOREREALCONSTANT(struct STACKFM * W);
auto void BUILDSET(struct STACKFM * S);
auto void DROPMEMBERS(struct STACKFM * S);
static int FRAME = 0;
static int ROUND = 0;
int AFRAME;
AFRAME = 0;
int PARAMETERFRAME;
PARAMETERFRAME = 0;
int PARAMETERREGS;
PARAMETERREGS = 0;
int STRINGRESULT;
STRINGRESULT = 0;
int BLOCKTYPE;
BLOCKTYPE = 0;
int CODEBASE;
CODEBASE = 0;
int UNCONDJUMP;
UNCONDJUMP = -1;
int D;
int N;
int PARAMETERMODE;
int VARBASE;
VARBASE = /*indirectthrough*/ *VARS;
int FIRSTALT;
FIRSTALT = PARMS - 1;
int FRAMEBASE;
int OLDFRAME;
int ALTALIGN;
int FRAMEEXTRA;
int MAXFRAME;
int ASSIGNLOCK;
ASSIGNLOCK = 1;
int ATTRIBUTES;
ATTRIBUTES = 0;
int AT;
AT = 0;
int ENTRYMASK;
ENTRYMASK = 0;
int MYMARK;
int OPEN;
OPEN = 2048;
int EVENTLABEL;
EVENTLABEL = 0;
int EVENTBODY;
EVENTBODY = 0;
int EVENTBITS;
EVENTBITS = 0;
int WSPSAVE;
WSPSAVE = 0;
int DANGERMARKER;
DANGERMARKER = 0;
int LOCALDISPLAY;
LOCALDISPLAY = 0;
int JLAB;
int ARRAYBASE;
ARRAYBASE = 0;
int WORKBASE;
WORKBASE = LASTWORK;
int *CA;
CA = /*%A*/ /*addressof*/ &CODEBASE;
_imp_string127 PROCID;
PROCID = INTERNALID;
struct WITHFM *WITHS;
WITHS = NIL;
const _imp_string255 MONITORID = _imp_str_literal("3L___monitor");
static int MONITOREP = 0;
void DECODE(int WORD, int AT) {
extern void D(int W, int A) __asm__("DECODE_ARM");
_imp_SELECTOUTPUT(0);
D(/*indirectthrough*/ *WORD, AT);
_imp_SELECTOUTPUT(2);
} /* DECODE */
struct STACKFM *DISPLAYINFO(int BASE) {
int N;
struct STACKFM *T;
if (BASE >= DANGERLEVEL) goto L_0006;
FRAMEUSE[BASE] = 0;
N = DISPLAYVECTOR[BASE];
if (N != 0) goto L_0007;
MINSB = MINSB - 4;
N = MINSB;
DISPLAYVECTOR[BASE] = N;
L_0007:
T = LITERAL(N);
T->FORM = 1;
T->BASE = 10;
goto L_0008;
L_0006:
T = LOCALINTEGER(LOCALDISPLAY + 4 * (BASE - DANGERLEVEL));
L_0008:
ATTRIBUTES = ATTRIBUTES | 1 | 4;
T->FLAGS = T->FLAGS | 128;
return T;
} /* DISPLAYINFO */
void BD(int BASE, int DISP) {
_imp_WRITE(/*indirectthrough*/ *DISP, 1);
_imp_PRINTSYMBOL(40);
if (0 > BASE) goto L_0009;
if (BASE > 26) goto L_0009;
_imp_PRINTSTRING(REGID[BASE]);
goto L_000A;
L_0009:
if (BASE < 128) goto L_000B;
if (BASE != /*indirectthrough*/ *LOCAL) goto L_000C;
_imp_PRINTSTRING(_imp_str_literal("Fp"));
goto L_000D;
L_000C:
_imp_PRINTSYMBOL(76);
BASE = BASE - 128 - 1;
_imp_WRITE(BASE, 0);
L_000D:
goto L_000E;
L_000B:
_imp_WRITE(BASE, 0);
L_000E:
L_000A:
_imp_PRINTSYMBOL(41);
} /* BD */
void SHOW(int N, _imp_string15 TEXT) {
if (/*indirectthrough*/ *N == 0) goto L_000F;
_imp_SPACE();
_imp_PRINTSTRING(TEXT);
_imp_WRITE(/*indirectthrough*/ *N, 1);
L_000F:
} /* SHOW */
void SHOWDATA(struct STACKFM * V, int LEFT) {
_imp_SPACES(LEFT);
_imp_PRINTSTRING(TYPEID[V]);
_imp_SPACE();
_imp_PRINTSTRING(FORMID[V]);
BD(V, V);
SHOW(V, _imp_str_literal("Fm:"));
SHOW(V, _imp_str_literal("A:"));
SHOW(V, _imp_str_literal("Fl:"));
if (V & 1 == 0) goto L_0010;
_imp_PRINTSYMBOL(82);
L_0010:
if (V & 2 == 0) goto L_0011;
_imp_PRINTSYMBOL(65);
L_0011:
if (V & 64 == 0) goto L_0012;
_imp_PRINTSYMBOL(78);
L_0012:
if (V & 4 == 0) goto L_0013;
_imp_PRINTSYMBOL(80);
L_0013:
if (V & 8 == 0) goto L_0014;
_imp_PRINTSYMBOL(68);
L_0014:
if (V & 131072 == 0) goto L_0015;
_imp_PRINTSYMBOL(87);
L_0015:
if (V & 32 == 0) goto L_0016;
_imp_PRINTSYMBOL(83);
L_0016:
if (V & 128 == 0) goto L_0017;
_imp_PRINTSYMBOL(61);
L_0017:
if (V & 16 == 0) goto L_0018;
_imp_PRINTSYMBOL(72);
L_0018:
if (V & 1024 == 0) goto L_0019;
_imp_PRINTSYMBOL(88);
L_0019:
if (V & 65536 == 0) goto L_001A;
_imp_PRINTSYMBOL(110);
L_001A:
if (V & 1048576 == 0) goto L_001B;
_imp_PRINTSYMBOL(67);
L_001B:
if (V == 0) goto L_001C;
_imp_PRINTSYMBOL(35);
_imp_WRITE(V, 0);
L_001C:
if (/*%A*/ /*addressof*/ &V == NIL) goto L_001D;
_imp_NEWLINE();
_imp_SPACES(LEFT);
_imp_PRINTSTRING(_imp_str_literal(" _:"));
DISPLAY(/*%A*/ /*addressof*/ &V, LEFT + 4);
L_001D:
if (/*%A*/ /*addressof*/ &V == NIL) goto L_001E;
_imp_NEWLINE();
_imp_WRITE(V, LEFT + 2);
_imp_PRINTSTRING(_imp_str_literal("i:"));
DISPLAY(/*%A*/ /*addressof*/ &V, LEFT + 4);
L_001E:
} /* SHOWDATA */
void DISPLAY(struct STACKFM * V, int BIAS) {
if (/*%A*/ /*addressof*/ &V != NIL) goto L_001F;
_imp_PRINTSTRING(_imp_str_literal(" Nil"));
_imp_NEWLINE();
return;
L_001F:
SHOWDATA(/*%A*/ /*addressof*/ &V, BIAS);
_imp_NEWLINE();
if (V == 0) goto L_0020;
_imp_SPACES(BIAS - 4);
_imp_PRINTSTRING(OPERID[V]);
DISPLAY(/*%A*/ /*addressof*/ &V, BIAS + 4);
L_0020:
} /* DISPLAY */
void SHOWREG(int R) {
int A;
A = ACTIVITY[R];
_imp_PRINTSTRING(REGID[R]);
if (A != 0) goto L_0021;
_imp_PRINTSTRING(_imp_str_literal(" unused"));
goto L_0022;
L_0021:
if (A >= 0) goto L_0023;
if (A != -1) goto L_0024;
_imp_PRINTSTRING(_imp_str_literal(" locked"));
goto L_0025;
L_0024:
_imp_PRINTSTRING(_imp_str_literal(" ="));
_imp_PRINTSTRING(REGID[-A]);
_imp_SPACES(2);
L_0025:
goto L_0022;
L_0023:
_imp_PRINTSTRING(_imp_str_literal(" used*"));
_imp_WRITE(A, -1);
L_0022:
_imp_PRINTSTRING(_imp_str_literal(" u:"));
PRINTHEX(USED[R], 5);
_imp_PRINTSTRING(_imp_str_literal(" k:"));
_imp_WRITE(KTIMES[R], 0);
_imp_NEWLINE();
} /* SHOWREG */
void MONITORN(int N, _imp_string255 TEXT) {
_imp_SELECTOUTPUT(0);
_imp_PRINTSTRING(TEXT);
_imp_WRITE(N, 8);
_imp_NEWLINE();
_imp_SELECTOUTPUT(2);
} /* MONITORN */
void MONITORREGISTER(int R, _imp_string127 TEXT) {
_imp_SELECTOUTPUT(0);
_imp_PRINTSTRING(TEXT);
_imp_SPACES(9 - /*indirectthrough*/ *_imp_LENGTH(/*%A*/ /*addressof*/ &TEXT));
_imp_SPACE();
SHOWREG(R);
_imp_SELECTOUTPUT(2);
} /* MONITORREGISTER */
void MONITOR(struct STACKFM * V, _imp_string127 TEXT) {
_imp_SELECTOUTPUT(0);
_imp_PRINTSTRING(TEXT);
_imp_SPACES(9 - /*indirectthrough*/ *_imp_LENGTH(/*%A*/ /*addressof*/ &TEXT));
_imp_SPACE();
DISPLAY(/*%A*/ /*addressof*/ &V, 6);
_imp_SELECTOUTPUT(2);
} /* MONITOR */
void MONREGID(int R, _imp_string127 TEXT) {
_imp_SELECTOUTPUT(0);
_imp_PRINTSTRING(REGID[R]);
_imp_SPACE();
_imp_PRINTSTRING(TEXT);
_imp_NEWLINE();
_imp_SELECTOUTPUT(2);
} /* MONREGID */
void DISPLAYKNOWLEDGE(void) {
struct KNOWFM *K;
_imp_SELECTOUTPUT(0);
K = KNOWING;
L_0026:
if (K == NIL) goto L_0027;
_imp_PRINTSTRING(REGID[K->REG]);
_imp_PRINTSTRING(_imp_str_literal(" = "));
_imp_PRINTSTRING(TYPEID[(unsigned int)K->FTYPE >> 4]);
_imp_SPACE();
_imp_PRINTSTRING(FORMID[K->FTYPE & 15]);
_imp_SPACE();
BD(K->BASE, K->DISP);
if (K->EXTRA == 0) goto L_0028;
_imp_PRINTSTRING(_imp_str_literal(" X:"));
_imp_WRITE(K->EXTRA, 1);
L_0028:
if (K->AREA == 0) goto L_0029;
_imp_PRINTSTRING(_imp_str_literal(" A:"));
_imp_WRITE(K->AREA, 1);
L_0029:
if (K->OPER == 0) goto L_002A;
_imp_SPACE();
_imp_PRINTSTRING(OPERID[K->OPER]);
_imp_WRITE(K->OPND, 1);
L_002A:
_imp_NEWLINE();
K = /*%A*/ /*addressof*/ &K->LINK;
goto L_0026;
L_0027:
_imp_SELECTOUTPUT(2);
} /* DISPLAYKNOWLEDGE */
void SHOWWHERE(void) {
_imp_SELECTOUTPUT(0);
_imp_PRINTSTRING(_imp_str_literal(" at line "));
_imp_WRITE(CURRENTLINE, 0);
if (INCLUDEFILE == _imp_str_literal("")) goto L_002B;
_imp_PRINTSTRING(_imp_join((_imp_string)(_imp_str_literal(" in file ")), (_imp_string)(INCLUDEFILE)));
L_002B:
_imp_NEWLINE();
} /* SHOWWHERE */
void FAIL(_imp_string63 WHY) {
void PCODE(int S) {
if (S < 128) goto L_002C;
_imp_PRINTSTRING(_imp_str_literal("128+"));
S = S - 128;
L_002C:
if (32 > S) goto L_002D;
if (S > 126) goto L_002D;
_imp_PRINTSYMBOL(39);
_imp_PRINTSYMBOL(S);
_imp_PRINTSYMBOL(39);
L_002D:
_imp_WRITE(S, 3);
} /* PCODE */
void ERR(int STREAM) {
int R;
struct STACKFM *U;
struct STACKFM *S;
_imp_SELECTOUTPUT(STREAM);
_imp_NEWLINE();
_imp_PRINTSTRING(_imp_str_literal("====> Pass 2 fails -- "));
_imp_PRINTSTRING(WHY);
SHOWWHERE();
_imp_PRINTSTRING(_imp_str_literal("Code "));
PCODE(CODE);
_imp_PRINTSTRING(_imp_str_literal(" Pending "));
PCODE(PENDING);
_imp_NEWLINE();
R = 0; /*%for R = 1, 1, 16 %cycle*/
L_002E:
if (R == 16) goto L_002F;
R += 1;
if (ACTIVITY[R] <= 0) goto L_0030;
SHOWREG(R);
L_0030:
goto L_002E;
L_002F:
S = STACK;
L_0031:
if (S == NIL) goto L_0032;
_imp_PRINTSTRING(_imp_str_literal("S:"));
DISPLAY(S, 5);
S = /*%A*/ /*addressof*/ &S->STACK;
goto L_0031;
L_0032:
U = USING;
L_0033:
if (U == NIL) goto L_0034;
_imp_PRINTSTRING(_imp_str_literal("U:"));
DISPLAY(U, 5);
U = /*%A*/ /*addressof*/ &U->USING;
goto L_0033;
L_0034:
_imp_NEWLINE();
/*_imp_monitor(__LINE__, __FILE__, PRETTY_FUNCTION);*/
} /* ERR */
ERR(0);
ERR(7);
_imp_stop(0);
} /* FAIL */
void WARN(int FAULT, _imp_string63 WHAT) {
_imp_SELECTOUTPUT(0);
INTERFACE->FAULTS = INTERFACE->FAULTS + FAULT;
if (FAULT != 0) goto L_0035;
_imp_PRINTSTRING(_imp_str_literal("Warning: "));
goto L_0036;
L_0035:
_imp_PRINTSTRING(_imp_str_literal("*Error: "));
L_0036:
_imp_PRINTSTRING(WHAT);
SHOWWHERE();
_imp_SELECTOUTPUT(2);
} /* WARN */
void NOTINYET(void) { FAIL(_imp_str_literal("***Not implemented yet***")); } /* NOTINYET */
void DIR1(int CODE) {
FLUSHCODE();
_imp_PRINTSYMBOL(CODE);
PENDINGAUTO = 0;
} /* DIR1 */
void DIR2(int CODE, int ARG1) {
FLUSHCODE();
_imp_PRINTSYMBOL(CODE);
DUMPENCODED(ARG1);
if (CODE == 3) goto L_0037;
PENDINGAUTO = 0;
L_0037:
} /* DIR2 */
void DIR3(int CODE, int ARG1, int ARG2) {
FLUSHCODE();
_imp_PRINTSYMBOL(CODE);
DUMPENCODED(ARG1);
DUMPENCODED(/*indirectthrough*/ *ARG2);
PENDINGAUTO = 0;
} /* DIR3 */
void DIR4(int CODE, int ARG1, int ARG2, int ARG3) {
FLUSHCODE();
_imp_PRINTSYMBOL(CODE);
DUMPENCODED(/*indirectthrough*/ *ARG1);
DUMPENCODED(/*indirectthrough*/ *ARG2);
DUMPENCODED(ARG3);
PENDINGAUTO = 0;
} /* DIR4 */
struct WORKFM *WORKAREA(int N) {
struct WORKVFM *W;
int E;
int S;
int X;
if (!_imp_on_event(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)) goto L_0038;
E = _imp_EVENT().EVENT;
S = _imp_EVENT().SUB;
X = 0;
FAIL(_imp_join((_imp_string)(_imp_str_literal("too many work areas:")), (_imp_string)(_imp_ITOS(E, 0))));
L_0038:
if (DIAG & 8 == 0) goto L_0039;
MONITORN(/*indirectthrough*/ *N, _imp_str_literal("work area"));
L_0039:
W = /*%A*/ /*addressof*/ &WORKLIST;
L_003A:
if (/*indirectthrough*/ *N <= 30) goto L_003B;
/*indirectthrough*/ *N = /*indirectthrough*/ */*indirectthrough*/ *N - 30;
if (/*%A*/ /*addressof*/ &W->LINK != NIL) goto L_003C;
W->LINK = _imp_NEW(WORKVFMTYPE);
W->LINK = 0;
L_003C:
W = /*%A*/ /*addressof*/ &W->LINK;
goto L_003A;
L_003B:
return /*%A*/ /*addressof*/ &W->W[/*indirectthrough*/ *N];
} /* WORKAREA */
struct LABELFM *ILABEL(int N) {
int X;
int J;
struct ILABELFM *I;
struct LABELFM *L;
if (/*indirectthrough*/ *N <= 8191) goto L_003D;
FAIL(_imp_str_literal("internal label/1"));
L_003D:
X = /*indirectthrough*/ *(unsigned int)/*indirectthrough*/ *N >> 8;
I = /*%A*/ /*addressof*/ &ILABELS[X].LABEL;
if (I != NIL) goto L_003E;
I = _imp_NEW(ILABELFMTYPE);
ILABELS[X].LABEL = I;
I->LINK = ILABELLIST;
ILABELLIST = I;
J = -1; /*%for J = 0, 1, 255 %cycle*/
L_003F:
if (J == 255) goto L_0040;
J += 1;
L = /*%A*/ /*addressof*/ &I->LAB[J];
L->LAB = -2147483648;
L->ENV = NIL;
goto L_003F;
L_0040:
L_003E:
return /*%A*/ /*addressof*/ &I->LAB[/*indirectthrough*/ *N & 255];
} /* ILABEL */
void SELECTAREA(int AREAID, int *BASE) {
DIR3(27, (unsigned int)AREAID >> 8, BASE);
CURRENTAREA = AREAID;
CA = /*%A*/ /*addressof*/ &BASE;
} /* SELECTAREA */
void SELECTCODEAREA(void) { SELECTAREA(0, /*%A*/ /*addressof*/ &CODEBASE); } /* SELECTCODEAREA */
void SELECTCONSTANTAREA(void) { SELECTAREA(512, /*%A*/ /*addressof*/ &CONSTANTBASE); } /* SELECTCONSTANTAREA */
void SELECTOWNAREA(void) { SELECTAREA(256, /*%A*/ /*addressof*/ &OWNBASE); } /* SELECTOWNAREA */
void SELECTOWNARRAYAREA(void) { SELECTAREA(768, /*%A*/ /*addressof*/ &OWNARRAYBASE); } /* SELECTOWNARRAYAREA */
void DUMPBYTE(int B) {
_imp_PRINTSYMBOL(31);
_imp_PRINTSYMBOL(1);
_imp_PRINTSYMBOL(B & 255);
/*indirectthrough*/ *CA = /*indirectthrough*/ */*indirectthrough*/ *CA + 1;
} /* DUMPBYTE */
void DUMPHALF(int H) {
_imp_PRINTSYMBOL(31);
_imp_PRINTSYMBOL(2);
_imp_PRINTSYMBOL(H & 255);
_imp_PRINTSYMBOL((unsigned int)H >> 8 & 255);
/*indirectthrough*/ *CA = /*indirectthrough*/ */*indirectthrough*/ *CA + 2;
} /* DUMPHALF */
void DUMPWORD(int N) {
_imp_PRINTSYMBOL(31);
_imp_PRINTSYMBOL(4);
_imp_PRINTSYMBOL(N & 255);
_imp_PRINTSYMBOL((unsigned int)N >> 8 & 255);
_imp_PRINTSYMBOL((unsigned int)N >> 16 & 255);
_imp_PRINTSYMBOL((unsigned int)N >> 24);
if (DIAG & 1 == 0) goto L_0042;
if (CURRENTAREA != 0) goto L_0042;
DECODE(/*indirectthrough*/ *CA, N);
L_0042:
/*indirectthrough*/ *CA = /*indirectthrough*/ */*indirectthrough*/ *CA + 4;
} /* DUMPWORD */
int ACTUALREGISTER(int BASE) {
struct STACKFM *T;
if (BASE < 128) goto L_0043;
if (BASE != /*indirectthrough*/ *LOCAL) goto L_0044;
BASE = 11;
goto L_0045;
L_0044:
if (BASE <= 128) goto L_0046;
T = DISPLAYINFO(BASE);
LOADUP(T);
BASE = T->BASE;
RELEASEANDDROP(T);
L_0046:
L_0045:
L_0043:
return ACTUAL[BASE];
} /* ACTUALREGISTER */
int JUST(int R) { return ACTUALREGISTER(/*indirectthrough*/ *R); } /* JUST */
int NOTHING(void) { return 33554432; } /* NOTHING */
int IMMEDIATE(int N) {
int ROT;
ROT = 16;
if (N == 0) goto L_0047;
L_0048:
if (N & 3 != 0) goto L_0049;
ROT = ROT - 1;
N = (unsigned int)N >> 2;
goto L_0048;
L_0049:
if ((unsigned int)N >> 8 == 0) goto L_004A;
return -1;
L_004A:
L_0047:
return (ROT & 15) << 8 | N | 33554432;
} /* IMMEDIATE */
int ISHIFT(int RM, int BY, int HOW) {
if (HOW & 128 == 0) goto L_004B;
FAIL(_imp_str_literal("Bad immediate shift"));
L_004B:
return ACTUALREGISTER(RM) | (BY & 31) << 3 + 4 | HOW;
} /* ISHIFT */
int RSHIFT(int RM, int RS, int HOW) {
if (HOW & 128 != 0) goto L_004C;
FAIL(_imp_str_literal("Bad register shift"));
L_004C:
return ACTUALREGISTER(RM) | ACTUALREGISTER(RS) << 4 + 4 | HOW & 112;
} /* RSHIFT */
int ROT(int N, int BY) { return N & 255 | BY << 8 | 33554432; } /* ROT */
static int PENDINGPOP = 0;
void PLANT1(int FN, int RN, int RD, int X) {
DUMPWORD(FN ^ -536870912 | ACTUALREGISTER(RN) << 16 | ACTUALREGISTER(RD) << 12 | X);
if ((unsigned int)FN >> 23 & 3 == 2) goto L_004D;
FORGET(RD);
L_004D:
} /* PLANT1 */
void PLANT2(int FN, int RD, struct STACKFM *V) {
int N;
int SHIFT;
int SIGN;
int D;
int P;
int BASE;
int VBASE;
int EXTRA;
EXTRA = 0;
struct STACKFM *W;
if (V != 4) goto L_004E;
FN = FN | 4194304;
L_004E:
SIMPLIFY(/*%A*/ /*addressof*/ &V);
D = V;
if (V != 2) goto L_004F;
D = TYPESIZE[V];
FN = FN | 16777216;
goto L_0050;
L_004F:
if (V != 3) goto L_0051;
D = -TYPESIZE[V];
FN = FN | 2097152;
goto L_0050;
L_0051:
if (V == 1) goto L_0052;
FAIL(_imp_str_literal("illegal load/store"));
L_0052:
L_0050:
if (/*%A*/ /*addressof*/ &V != NIL) goto L_0053;
if (-4095 > D) goto L_0041;
if (D <= 4095) goto L_0054;
L_0041:
FAIL(_imp_str_literal("Bad displacement"));
L_0054:
if (D < 0) goto L_0055;
FN = FN | 8388608;
goto L_0056;
L_0055:
D = -D;
L_0056:
FN = FN | D;
if (D != 0) goto L_0057;
PENDINGAUTON = 0;
PENDINGAUTO = V;
PENDINGAUTOCA = /*indirectthrough*/ *CA;
L_0057:
goto L_0058;
L_0053:
if (D == 0) goto L_0059;
FAIL(_imp_str_literal("Bad index displacement"));
L_0059:
N = V;
if (N != 0) goto L_005A;
FAIL(_imp_str_literal("Zero Xsize"));
L_005A:
P = POWER(N);
if (P < 0) goto L_005B;
LOADUP(/*%A*/ /*addressof*/ &V);
goto L_005C;
L_005B:
P = 0;
SIGN = N & -2147483648;
L_005D:
if (N & 1 != 0) goto L_005E;
P = P + 1;
N = (unsigned int)N >> 1 | SIGN;
goto L_005D;
L_005E:
OPERATE(6, /*%A*/ /*addressof*/ &V, LITERAL(N));
V = 1;
LOADUP(/*%A*/ /*addressof*/ &V);
L_005C:
FN = FN | 8388608 | 33554432 | ISHIFT(V, P, 0);
L_0058:
if (V != 0) goto L_005F;
if (/*%A*/ /*addressof*/ &V != NIL) goto L_0060;
if (V >= 0) goto L_0061;
LOADUP(/*%A*/ /*addressof*/ &V);
FN = FN | ACTUALREGISTER(V) << 16;
goto L_0062;
L_0061:
FAIL(_imp_str_literal("No absolute yet"));
L_0062:
goto L_0063;
L_0060:
LOADUP(/*%A*/ /*addressof*/ &V);
V = V;
DROP(/*%A*/ /*addressof*/ &V);
V = NIL;
FN = FN | ACTUALREGISTER(V) << 16;
L_0063:
goto L_0064;
L_005F:
FN = FN | ACTUALREGISTER(V) << 16;
L_0064:
if (FN & (16777216 | 2097152) == 0) goto L_0065;
FORGET(V);
L_0065:
FN = FN ^ 16777216 | ACTUALREGISTER(RD) << 12;
DUMPWORD(FN ^ -536870912);
if (EXTRA == 0) goto L_0066;
RELEASE(EXTRA);
L_0066:
if (FN & 1048576 == 0) goto L_0067;
FORGET(RD);
goto L_0068;
L_0067:
FORGETDESTINATION(/*%A*/ /*addressof*/ &V);
REMEMBER(RD, /*%A*/ /*addressof*/ &V);
L_0068:
} /* PLANT2 */
void PLANT3(int FN, int N) { DUMPWORD(FN ^ -536870912 | N & 16777215); } /* PLANT3 */
void PLANT4(int FN, int RN, int OPERAND) {
DUMPWORD(FN ^ -536870912 | ACTUALREGISTER(RN) << 16 | OPERAND & 65535);
if (FN & 2097152 == 0) goto L_0069;
FORGET(RN);
L_0069:
} /* PLANT4 */
void PLANT5(int FN, int OFFSET) { DUMPWORD(FN ^ -536870912 | OFFSET & 16777215); } /* PLANT5 */
void PLANT6(int OP, int FD, struct STACKFM *V) {
int N;
int SHIFT;
int SIGN;
int D;
int P;
int BASE;
int VBASE;
struct STACKFM *W;
SIMPLIFY(/*%A*/ /*addressof*/ &V);
D = V;
if (D & 3 == 0) goto L_006A;
FAIL(_imp_str_literal("Floating-point alignment"));
L_006A:
D = ((long)D / (long)4);
if (V != 2) goto L_006B;
D = (unsigned int)TYPESIZE[V] >> 2;
OP = OP | 16777216;
goto L_006C;
L_006B:
if (V != 3) goto L_006D;
D = -((unsigned int)TYPESIZE[V] >> 2);
OP = OP | 2097152;
goto L_006C;
L_006D:
if (V == 1) goto L_006E;
FAIL(_imp_str_literal("illegal load/store"));
L_006E:
L_006C:
if (/*%A*/ /*addressof*/ &V == NIL) goto L_006F;
if (-255 > D) goto L_0070;
if (D <= 255) goto L_0071;
L_0070:
FAIL(_imp_str_literal("Fp Disp?"));
L_0071:
W = COPY(/*%A*/ /*addressof*/ &V);
LOADUPADDRESS(W);
W->TYPE = V;
W->FORM = 1;
PLANT6(OP, FD, W);
RELEASEANDDROP(W);
return;
L_006F:
if (D < 0) goto L_0072;
OP = OP | 8388608;
goto L_0073;
L_0072:
D = -D;
L_0073:
OP = OP | D;
if (V != 0) goto L_0074;
if (/*%A*/ /*addressof*/ &V != NIL) goto L_0075;
if (V >= 0) goto L_0076;
if (V == 1) goto L_0077;
FAIL(_imp_str_literal("Bad external"));
L_0077:
LOADUP(/*%A*/ /*addressof*/ &V);
OP = OP | ACTUALREGISTER(V) << 16;
goto L_0078;
L_0076:
FAIL(_imp_str_literal("No absolute yet"));
L_0078:
goto L_0079;
L_0075:
LOADUP(/*%A*/ /*addressof*/ &V);
V = V;
DROP(/*%A*/ /*addressof*/ &V);
V = NIL;
OP = OP | ACTUALREGISTER(V) << 16;
L_0079:
goto L_007A;
L_0074:
OP = OP | ACTUALREGISTER(V) << 16;
L_007A:
if (OP & (16777216 | 2097152) == 0) goto L_007B;
FORGET(V);
L_007B:
OP = OP ^ 16777216 | ACTUALREGISTER(FD) << 12;
DUMPWORD(OP ^ -536870912);
if (OP & 1048576 == 0) goto L_007C;
FORGET(FD);
goto L_007D;
L_007C:
FORGETDESTINATION(/*%A*/ /*addressof*/ &V);
REMEMBER(FD, /*%A*/ /*addressof*/ &V);
L_007D:
} /* PLANT6 */
void PLANT7(int OP, int FN, int RD, int FM) {
if (OP & 8 != 0) goto L_007E;
FM = ACTUAL[FM];
L_007E:
DUMPWORD(OP ^ -536870912 | ACTUAL[FN] << 16 | ACTUAL[RD] << 12 | FM);
if (OP & 1048576 != 0) goto L_007F;
FORGET(FN);
goto L_0080;
L_007F:
FORGET(RD);
L_0080:
} /* PLANT7 */
void PLANT8(int OP, int FN, int FM) {
if (OP & 8 != 0) goto L_0081;
FM = ACTUAL[FM];
L_0081:
DUMPWORD(OP ^ -536870912 | ACTUAL[FN] << 16 | FM);
} /* PLANT8 */
void PLANT9(int OP, int FN, int FD, int FM) {
if (OP & 8 != 0) goto L_0082;
FM = ACTUAL[FM];
L_0082:
DUMPWORD(OP ^ -536870912 | ACTUAL[FN] << 16 | ACTUAL[FD] << 12 | FM);
FORGET(FD);
} /* PLANT9 */
struct CONSTFM {
union {
struct {
int N;
int STORE;
int TYPE;
int V1;
int R1;
int V2;
int R2;
};
};
};
void TESTASSIGNED(void) {
DIR1(24);
/*indirectthrough*/ *CA = /*indirectthrough*/ */*indirectthrough*/ *CA + 4;
REFS = REFS + 1;
} /* TESTASSIGNED */
void FLOAT(struct STACKFM * V, int R) {
int N;
double LONG;
if (R != 26) goto L_0083;
R = FPR();
L_0083:
if (!(ICONST(/*%A*/ /*addressof*/ &V))) goto L_0084;
if (0 > V) goto L_0085;
if (V <= 5) goto L_0086;
L_0085:
if (V != 10) goto L_0087;
L_0086:
N = V;
if (V != 10) goto L_0088;
N = 7;
L_0088:
PLANT9(234914176 | 8, 0, R, N);
goto L_0089;
L_0087:
if (-5 > V) goto L_008A;
if (V <= 0) goto L_008B;
L_008A:
if (V != -10) goto L_008C;
L_008B:
N = -V;
if (N != 10) goto L_008D;
N = 7;
L_008D:
PLANT9(235962752 | 8, 0, R, N);
goto L_0089;
L_008C:
LONG = V;
V = LONG;
CONVERTFORMAT(/*%A*/ /*addressof*/ &V, 7);
STOREREALCONSTANT(/*%A*/ /*addressof*/ &V);
DIR4(12, ACTUAL[R], V, 1);
FORGET(R);
REFS = REFS + 1;
/*indirectthrough*/ *CA = /*indirectthrough*/ */*indirectthrough*/ *CA + 4;
L_0089:
goto L_008E;
L_0084:
LOADUP(/*%A*/ /*addressof*/ &V);
PLANT7(235405584, R, V, 0);
RELEASE(V);
L_008E:
V = 7;
V = 0;
V = R;
V = 0;
V = 0;
CLAIM(R);
} /* FLOAT */
void LOADSAFELY(struct STACKFM * V, int R) {
if (R != 17) goto L_008F;
LOADPROTECTED(/*%A*/ /*addressof*/ &V);
goto L_0090;
L_008F:
if (R != 26) goto L_0091;
if (FLOATING(/*%A*/ /*addressof*/ &V)) goto L_0092;
FLOAT(/*%A*/ /*addressof*/ &V, 26);
L_0092:
LOADPROTECTED(/*%A*/ /*addressof*/ &V);
goto L_0090;
L_0091:
if (ACTIVITY[R] != 1) goto L_0093;
if (V == R) goto L_0094;
L_0093:
HAZARD(R);
L_0094:
LOAD(/*%A*/ /*addressof*/ &V, R);
L_0090:
} /* LOADSAFELY */
void CHARACTERISECONSTANT(int N, struct CONSTFM *C) {
int SH;
int V;
int S;
int X;
const unsigned char BITS[16] = {0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
C = N;
V = N;
if (V != 0) goto L_0095;
C = 1;
return;
L_0095:
if (V != -1) goto L_0096;
C = 2;
return;
L_0096:
X = V;
S = 0;
L_0097:
S = S + BITS[X & 15];
X = (unsigned int)X >> 4;
if (X == 0) goto L_0098;
goto L_0097;
L_0098:
C = 3;
if (S <= 16) goto L_0099;
C = 4;
V = (~V);
L_0099:
if (V == 0) goto L_009A;
SH = 16;
L_009B:
if (V & 3 != 0) goto L_009C;
SH = SH - 1;
V = (unsigned int)V >> 2;
goto L_009B;
L_009C:
C = SH & 15;
C = V & 255;
V = (unsigned int)V >> 8;
C = 0;
C = 0;
if (V == 0) goto L_009D;
SH = SH - 4;
L_009E:
if (V & 3 != 0) goto L_009F;
SH = SH - 1;
V = (unsigned int)V >> 2;
goto L_009E;
L_009F:
C = SH & 15;
C = V & 255;
V = (unsigned int)V >> 8;
L_009D:
L_009A:
if (V == 0) goto L_00A0;
C = 5;
L_00A0:
} /* CHARACTERISECONSTANT */
void NOWINREGISTER(struct STACKFM * V, int R, int INHERIT) {
if (INHERIT == 0) goto L_00A1;
REMEMBER(R, /*%A*/ /*addressof*/ &V);
L_00A1:
if (/*%A*/ /*addressof*/ &V == NIL) goto L_00A2;
RELEASEANDDROP(/*%A*/ /*addressof*/ &V);
V = NIL;
L_00A2:
if (/*%A*/ /*addressof*/ &V == NIL) goto L_00A3;
RELEASEANDDROP(/*%A*/ /*addressof*/ &V);
V = NIL;
L_00A3:
RELEASE(V);
V = 0;
V = R;
V = 0;
V = RTYPE[R];
CLAIM(R);
} /* NOWINREGISTER */
void SIMPLELOAD(struct STACKFM * V, int R) {
struct STACKFM *W;
struct STACKFM *B1;
struct STACKFM *B2;
struct CONSTFM C;
int P;
int N;
int X;
int T;
int CHECK;
OPTIMISE(/*%A*/ /*addressof*/ &V, 1);
if (!(INREG(/*%A*/ /*addressof*/ &V))) goto L_00A4;
if (V == R) goto L_00A5;
if (R != 17) goto L_00A6;
if (V <= 17) goto L_00A5;
L_00A6:
if (R != 26) goto L_00A7;
if (V < 18) goto L_00A7;
L_00A5:
return;
L_00A7:
L_00A4:
if (R != 17) goto L_00A8;
R = GPR();
goto L_00A9;
L_00A8:
if (R != 26) goto L_00AA;
R = FPR();
L_00AA:
L_00A9:
if (V != R) goto L_0005;
if (ACTIVITY[R] == 1) goto L_00AB;
L_0005:
HAZARD(R);
L_00AB:
SIMPLIFY(/*%A*/ /*addressof*/ &V);
if (R < 18) goto L_00AC;
if (FLOATING(/*%A*/ /*addressof*/ &V)) goto L_00AC;
FLOAT(/*%A*/ /*addressof*/ &V, R);
return;
L_00AC:
if (!(ICONST(/*%A*/ /*addressof*/ &V))) goto L_00AD;
CHARACTERISECONSTANT(V, /*%A*/ /*addressof*/ &C);
if (C.TYPE != 1) goto L_00AE;
PLANT1(27262976, 0, R, ROT(0, 0));
goto L_00AF;
L_00AE:
if (C.TYPE != 2) goto L_00B0;
PLANT1(31457280, 0, R, ROT(0, 0));
goto L_00AF;
L_00B0:
if (C.TYPE != 3) goto L_00B1;
PLANT1(27262976, 0, R, ROT(C.V1, C.R1));
if (C.V2 == 0) goto L_00B2;
PLANT1(25165824, R, R, ROT(C.V2, C.R2));
L_00B2:
goto L_00AF;
L_00B1:
if (C.TYPE != 4) goto L_00B3;
PLANT1(31457280, 0, R, ROT(C.V1, C.R1));
if (C.V2 == 0) goto L_00B4;
PLANT1(2097152, R, R, ROT(C.V2, C.R2));
L_00B4:
goto L_00AF;
L_00B3:
CONSTANTBASE = CONSTANTBASE + 3 & (~3);
W = LITERAL(CONSTANTBASE);
W->FORM = 1;
W->AREA = 512;
SELECTCONSTANTAREA();
DUMPWORD(C.N);
SELECTCODEAREA();
DIR3(11, ACTUAL[R], CONSTANTBASE - 4);
FORGET(R);
REFS = REFS + 1;
/*indirectthrough*/ *CA = /*indirectthrough*/ */*indirectthrough*/ *CA + 4;
RELEASEANDDROP(W);
L_00AF:
NOWINREGISTER(/*%A*/ /*addressof*/ &V, R, 1);
goto L_00B5;
L_00AD:
if (V != 0) goto L_00B6;
if (!(INREG(/*%A*/ /*addressof*/ &V))) goto L_00B7;
if (V < 6) goto L_00B8;
PLANT9(234914176, 0, R, V);
goto L_00B9;
L_00B8:
PLANT1(27262976, 0, R, JUST(V));
L_00B9:
NOWINREGISTER(/*%A*/ /*addressof*/ &V, R, 1);
return;
L_00B7:
if (V < 6) goto L_00BA;
STOREREALCONSTANT(/*%A*/ /*addressof*/ &V);
DIR4(12, ACTUAL[R], V, 1);
FORGET(R);
REFS = REFS + 1;
/*indirectthrough*/ *CA = /*indirectthrough*/ */*indirectthrough*/ *CA + 4;
REMEMBER(R, /*%A*/ /*addressof*/ &V);
NOWINREGISTER(/*%A*/ /*addressof*/ &V, R, 1);
return;
L_00BA:
if (V != 512) goto L_00BB;
DIR3(10, ACTUAL[R], V);
FORGET(R);
REFS = REFS + 1;
/*indirectthrough*/ *CA = /*indirectthrough*/ */*indirectthrough*/ *CA + 4;
NOWINREGISTER(/*%A*/ /*addressof*/ &V, R, 1);
return;
L_00BB:
if (/*%A*/ /*addressof*/ &V == NIL) goto L_00BC;
if (/*%A*/ /*addressof*/ &V == NIL) goto L_00BD;
if (V != 0) goto L_00BD;
LOADUP(/*%A*/ /*addressof*/ &V);
V = V;
DROP(/*%A*/ /*addressof*/ &V);
V = NIL;
L_00BD:
if (V != 0) goto L_00BE;
NOTINYET();
L_00BE:
P = POWER(V);
if (P < 0) goto L_00BF;
LOADUP(/*%A*/ /*addressof*/ &V);
PLANT1(8388608, V, R, ISHIFT(V, P, 0));
goto L_00C0;
L_00BF:
OPERATE(6, /*%A*/ /*addressof*/ &V, LITERAL(V));
LOADUP(/*%A*/ /*addressof*/ &V);
V = 1;
PLANT1(8388608, V, R, JUST(V));
L_00C0:
if (V <= 0) goto L_00C1;
CHARACTERISECONSTANT(V, /*%A*/ /*addressof*/ &C);
if (C.TYPE != 3) goto L_00C2;
PLANT1(8388608, R, R, ROT(C.V1, C.R1));
if (C.V2 == 0) goto L_00C3;
PLANT1(8388608, R, R, ROT(C.V2, C.R2));
L_00C3:
goto L_00C4;
L_00C2:
if (C.TYPE != 5) goto L_00C5;
U_1000:
CONSTANTBASE = CONSTANTBASE + 3 & (~3);
SELECTCONSTANTAREA();
DUMPWORD(V);
SELECTCODEAREA();
X = GPR();
DIR3(11, ACTUAL[X], CONSTANTBASE - 4);
FORGET(X);
REFS = REFS + 1;
/*indirectthrough*/ *CA = /*indirectthrough*/ */*indirectthrough*/ *CA + 4;
PLANT1(8388608, V, R, JUST(X));
goto L_00C4;
L_00C5:
FAIL(_imp_str_literal("Bad displacement"));
L_00C4:
goto L_00C6;
L_00C1:
if (V >= 0) goto L_00C7;
CHARACTERISECONSTANT(-V, /*%A*/ /*addressof*/ &C);
if (C.TYPE != 3) goto L_00C8;
PLANT1(4194304, R, R, ROT(C.V1, C.R1));
if (C.V2 == 0) goto L_00C9;
PLANT1(4194304, R, R, ROT(C.V2, C.R2));
L_00C9:
goto L_00CA;
L_00C8:
if (C.TYPE != 5) goto L_00CB;
W = LITERAL(V);
W->FORM = 1;
W->BASE = 16;
LOADUP(W);
PLANT1(4194304, R, R, JUST(W->BASE));
RELEASEANDDROP(W);
goto L_00CA;
L_00CB:
goto U_1000;
L_00CA:
L_00C7:
L_00C6:
goto L_00CC;
L_00BC:
N = V;
P = 8388608;
if (N >= 0) goto L_00CD;
N = -N;
P = 4194304;
L_00CD:
CHARACTERISECONSTANT(N, /*%A*/ /*addressof*/ &C);
if (C.TYPE != 1) goto L_00CE;
PLANT1(27262976, 0, R, JUST(V));
goto L_00CF;
L_00CE:
if (C.TYPE != 3) goto L_00D0;
PLANT1(P, V, R, ROT(C.V1, C.R1));
if (C.V2 == 0) goto L_00D1;
PLANT1(P, R, R, ROT(C.V2, C.R2));
L_00D1:
goto L_00CF;
L_00D0:
if (C.TYPE != 5) goto L_00D2;
W = LITERAL(C.N);
LOADUP(W);
PLANT1(P, V, R, JUST(W->BASE));
RELEASEANDDROP(W);
goto L_00CF;
L_00D2:
FAIL(_imp_str_literal("negate error"));
L_00CF:
L_00CC:
NOWINREGISTER(/*%A*/ /*addressof*/ &V, R, 1);
goto L_00B5;
L_00B6:
if (V != 1) goto L_00D3;
CHECK = V & 1048576;
if (UNASSIGNED == 0) goto L_00D4;
if (V & 128 == 0) goto L_00D5;
L_00D4:
CHECK = 0;
L_00D5:
if (V == 0) goto L_00D6;
if (V != 512) goto L_00D7;
if (V != 1) goto L_00D8;
DIR3(11, ACTUAL[R], V);
goto L_00D9;
L_00D8:
if (V != 7) goto L_00DA;
DIR4(12, ACTUAL[R], V, 1);
goto L_00D9;
L_00DA:
if (V != 6) goto L_00DB;
DIR4(12, ACTUAL[R], V, 0);
goto L_00D9;
L_00DB:
if (V == 4) goto L_00DC;
if (V != 2) goto L_00DD;
L_00DC:
T = V;
AMAP(/*%A*/ /*addressof*/ &V);
LOAD(/*%A*/ /*addressof*/ &V, R);
V = T;
V = 1;
LOAD(/*%A*/ /*addressof*/ &V, R);
return;
L_00DD:
FAIL(_imp_str_literal("Bad constant type"));
L_00D9:
REFS = REFS + 1;
/*indirectthrough*/ *CA = /*indirectthrough*/ */*indirectthrough*/ *CA + 4;
FORGET(R);
NOWINREGISTER(/*%A*/ /*addressof*/ &V, R, 1);
return;
L_00D7:
if (V >= 0) goto L_00DE;
if (V == 1) goto L_00DF;
FAIL(_imp_str_literal("Bad external spec type"));
L_00DF:
DIR3(13, ACTUAL[R], -V);
FORGET(R);
REFS = REFS + 1;
/*indirectthrough*/ *CA = /*indirectthrough*/ */*indirectthrough*/ *CA + 4;
NOWINREGISTER(/*%A*/ /*addressof*/ &V, R, 1);
return;
L_00DE:
L_00D6:
if (V != 4) goto L_00E0;
PLANT2(68157440, R, /*%A*/ /*addressof*/ &V);
NOWINREGISTER(/*%A*/ /*addressof*/ &V, R, 1);
if (CHECK == 0) goto L_00E1;
PLANT1(22020096 | 1048576, R, 0, IMMEDIATE(128));
TESTASSIGNED();
L_00E1:
goto L_00E2;
L_00E0:
if (V != 2) goto L_00E3;
SIMPLIFY(/*%A*/ /*addressof*/ &V);
if (/*%A*/ /*addressof*/ &V != NIL) goto L_00E4;
if (/*%A*/ /*addressof*/ &V == NIL) goto L_00E5;
L_00E4:
LOADUPADDRESS(/*%A*/ /*addressof*/ &V);
V = 2;
V = 1;
L_00E5:
B1 = COPY(/*%A*/ /*addressof*/ &V);
ADVANCE(B1, 4, 0);
B2 = COPY(/*%A*/ /*addressof*/ &V);
ADVANCE(B2, 4, 1);
B1->FLAGS = B1->FLAGS | 128;
B2->FLAGS = B2->FLAGS | 128;
LOAD(B2, 15);
LOAD(B1, R);
LOADUP(B2);
if (CHECK == 0) goto L_00E6;
PLANT1(22020096 | 1048576, B1->BASE, 0, IMMEDIATE(128));
PLANT1(22020096 | 1048576 | -536870912, B2->BASE, 0, IMMEDIATE(128));
TESTASSIGNED();
L_00E6:
PLANT1(27262976, 0, B2->BASE, ISHIFT(B2->BASE, 24, 0));
PLANT1(25165824, B1->BASE, R, ISHIFT(B2->BASE, 16, 64));
RELEASEANDDROPPAIR(B1, B2);
NOWINREGISTER(/*%A*/ /*addressof*/ &V, R, 1);
goto L_00E2;
L_00E3:
if (V != 6) goto L_00E7;
PLANT6(202375424, R, /*%A*/ /*addressof*/ &V);
NOWINREGISTER(/*%A*/ /*addressof*/ &V, R, 1);
if (CHECK == 0) goto L_00E8;
B1 = LITERAL(0);
B1->TYPE = 7;
B1->FORM = 1;
B1->BASE = 10;
LOADUP(B1);
RELEASEANDDROP(B1);
PLANT8(244379920, B1->BASE, R);
TESTASSIGNED();
L_00E8:
goto L_00E2;
L_00E7:
if (V != 7) goto L_00E9;
PLANT6(202408192, R, /*%A*/ /*addressof*/ &V);
NOWINREGISTER(/*%A*/ /*addressof*/ &V, R, 1);
if (CHECK == 0) goto L_00EA;
B1 = LITERAL(0);
B1->TYPE = 7;
B1->FORM = 1;
B1->BASE = 10;
LOADUP(B1);
RELEASEANDDROP(B1);
PLANT8(244379920, B1->BASE, R);
TESTASSIGNED();
L_00EA:
goto L_00E2;
L_00E9:
PLANT2(68157440, R, /*%A*/ /*addressof*/ &V);
NOWINREGISTER(/*%A*/ /*addressof*/ &V, R, 1);
if (CHECK == 0) goto L_00EB;
B1 = LITERAL(0);
B1->FORM = 1;
B1->BASE = 10;
LOADUP(B1);
RELEASEANDDROP(B1);
PLANT1(22020096 | 1048576, B1->BASE, 0, JUST(R));
TESTASSIGNED();
L_00EB:
L_00E2:
goto L_00B5;
L_00D3:
if (V != 3) goto L_00EC;
PLANT2(68157440, R, /*%A*/ /*addressof*/ &V);
FORGET(V);
NOWINREGISTER(/*%A*/ /*addressof*/ &V, R, 1);
goto L_00B5;
L_00EC:
if (V != 2) goto L_00ED;
PLANT2(68157440, R, /*%A*/ /*addressof*/ &V);
FORGET(V);
NOWINREGISTER(/*%A*/ /*addressof*/ &V, R, 1);
goto L_00B5;
L_00ED:
FAIL(_imp_str_literal("Unknown type for LOAD"));
L_00B5:
} /* SIMPLELOAD */
void MULTIPLY(struct STACKFM * V, struct STACKFM * W, int R) {
void CMUL(int FROM, int TO, int BY) {
int X;
int OP;
int WITH;
int T;
if (BY & 1 != 0) goto L_00EE;
OP = 27262976;
WITH = 0;
goto L_00EF;
L_00EE:
if (BY & 3 != 1) goto L_00F0;
OP = 8388608;
WITH = FROM;
goto L_00EF;
L_00F0:
BY = BY + 1;
OP = 6291456;
WITH = FROM;
L_00EF:
X = 0;
L_00F1:
X = X + 1;
BY = (unsigned int)BY >> 1;
if (BY & 1 != 0) goto L_00F2;
goto L_00F1;
L_00F2:
if (BY != 1) goto L_00F3;
T = FROM;
goto L_00F4;
L_00F3:
T = GPR();
CMUL(FROM, T, BY);
L_00F4:
PLANT1(OP, WITH, TO, ISHIFT(T, X, 0));
} /* CMUL */
int L;
int INV;
struct STACKFM *Z;
if (!(ICONST(W))) goto L_00F5;
LOADSAFELY(/*%A*/ /*addressof*/ &V, /*indirectthrough*/ *R);
if (W->DISP != 0) goto L_00F6;
FAIL(_imp_str_literal("Zero multiply"));
L_00F6:
CMUL(V, V, W->DISP);
goto L_00F7;
L_00F5:
OPTIMISE(/*%A*/ /*addressof*/ &V, 1);
OPTIMISE(W, 1);
Z = LITERAL(0);
if (/*indirectthrough*/ *R == 17) goto L_00F8;
if (/*indirectthrough*/ *R == 26) goto L_00F8;
if (ACTIVITY[/*indirectthrough*/ *R] == 0) goto L_00F9;
L_00F8:
LOADPROTECTED(Z);
goto L_00FA;
L_00F9:
LOAD(Z, /*indirectthrough*/ *R);
L_00FA:
LOADPROTECTED(/*%A*/ /*addressof*/ &V);
LOADPROTECTED(W);
INV = INVERT;
INVERT = 0;
L = NEWLABEL();
DEFINELABEL(L);
PLANT1(27262976 | 1048576, 0, W->BASE, ISHIFT(W->BASE, 1, 32));
PLANT1(8388608 | -1073741824, Z->BASE, Z->BASE, JUST(V));
PLANT1(27262976, 0, V, ISHIFT(V, 1, 0));
JUMPTO(L, 6);
RELEASE(V);
V = Z->BASE;
DROP(Z);
LOAD(/*%A*/ /*addressof*/ &V, /*indirectthrough*/ *R);
INVERT = INV;
L_00F7:
RELEASEANDDROP(W);
} /* MULTIPLY */
void DIVIDE(struct STACKFM * V, struct STACKFM * W, int R, int Q, int U) {
int P;
int L;
int OP;
if (Q == 0) goto L_00FB;
if (U != 0) goto L_00FC;
L_00FB:
if (!(ICONST(W))) goto L_00FC;
P = POWER(W->DISP);
if (P <= 0) goto L_00FD;
if (U != 0) goto L_00FE;
if (Q != 0) goto L_00FF;
W->DISP = P;
OP = 15;
goto L_0100;
L_00FF:
W->DISP = ~(-1 << P);
OP = 9;
L_0100:
OPERATE(OP, V, W);
LOAD(V, R);
return;
L_00FE:
if (P > 8) goto L_0101;
LOADSAFELY(V, R);
PLANT1(22020096 | 1048576, V->BASE, 0, NOTHING());
L = NEWLABEL();
JUMPTO(L, 5);
PLANT1(8388608, V->BASE, V->BASE, ROT(W->DISP - 1, 0));
DEFINELABEL(L);
PLANT1(27262976, 0, V->BASE, ISHIFT(V->BASE, P, 64));
DROP(W);
return;
L_0101:
L_00FD:
L_00FC:
if (U != 0) goto L_0102;
OP = 49;
goto L_0103;
L_0102:
OP = 38;
L_0103:
LOADSAFELY(V, 2);
LOADPAIR(V, 2, W, 3);
PRIM(OP);
if (Q != 0) goto L_0104;
RELEASE(2);
CLAIM(1);
V->BASE = 1;
L_0104:
LOAD(V, R);
RELEASEANDDROP(W);
} /* DIVIDE */
void COMPLEXLOAD(struct STACKFM * V, int R) {
static const void *C[29] = {NULL};
static const void *C2 = {NULL};
const int REALOP[7] = {235962752, 237011328, 234881408, 236978560, 235929984, 239075712, 241172864};
struct STACKFM *W;
struct STACKFM *B;
struct CONSTFM CX;
int OPER;
int OP;
int REG2;
int N;
int PA;
W = /*%A*/ /*addressof*/ &V->LINK;
V->LINK = NIL;
OPER = V->OPER;
V->OPER = 0;
if (OPER >= 23) goto L_0105;
if (R < 18) goto L_0106;
L_0105:
if (R > 17) goto L_0107;
FAIL(_imp_str_literal("real load?"));
L_0107:
if (OPER != 29) goto L_0108;
LOADSAFELY(V, 18);
LOADPAIR(V, 18, W, 1);
PRIM(6);
RELEASEANDDROP(W);
LOAD(V, R);
return;
L_0108:
if (OPER >= 23) goto L_0109;
V->LINK = W;
V->OPER = OPER;
LOAD(V, 17);
LOAD(V, R);
return;
L_0109:
LOADSAFELY(V, R);
OP = REALOP[OPER];
if (W != NIL) goto L_010A;
PLANT9(OP, 0, V->BASE, V->BASE);
goto L_010B;
L_010A:
if (!(ICONST(W))) goto L_010C;
if (0 > W->DISP) goto L_010D;
if (W->DISP <= 5) goto L_010E;
L_010D:
if (W->DISP != 10) goto L_010C;
L_010E:
REG2 = W->DISP;
if (REG2 != 10) goto L_010F;
REG2 = 7;
L_010F:
OP = OP | 8;
goto L_0110;
L_010C:
LOAD(W, 26);
REG2 = W->BASE;
L_0110:
PLANT9(OP, V->BASE, V->BASE, REG2);
L_010B:
goto U_1001;
L_0106:
if (OPER != 8) goto L_0111;
LOADSAFELY(V, 2);
LOADPAIR(V, 2, W, 3);
PRIM(5);
RELEASEANDDROP(W);
LOAD(V, R);
return;
L_0111:
if (OPER != 17) goto L_0112;
LOADSAFELY(V, 2);
LOADPAIR(V, 2, W, 3);
PRIM(42);
RELEASEANDDROP(W);
return;
L_0112:
if (OPER != 6) goto L_0113;
MULTIPLY(V, W, R);
return;
L_0113:
if (OPER != 7) goto L_0114;
DIVIDE(V, W, R, 0, 1);
return;
L_0114:
if (OPER != 16) goto L_0115;
DIVIDE(V, W, R, 1, 1);
return;
L_0115:
if (OPER != 19) goto L_0116;
DIVIDE(V, W, R, 0, 0);
return;
L_0116:
if (OPER != 20) goto L_0117;
DIVIDE(V, W, R, 1, 0);
return;
L_0117:
if (OPER != 5) goto L_0118;
if (!(ICONST(V))) goto L_0118;
CHARACTERISECONSTANT(V->DISP, /*%A*/ /*addressof*/ &CX);
if (CX.TYPE != 3) goto L_0119;
LOAD(W, R);
R = W->BASE;
PLANT1(6291456, W->BASE, R, ROT(CX.V1, CX.R1));
if (CX.V2 == 0) goto L_011A;
PLANT1(8388608, R, R, ROT(CX.V2, CX.R2));
L_011A:
goto U_1002;
L_0119:
if (CX.TYPE != 2) goto L_011B;
LOADSAFELY(W, R);
R = W->BASE;
PLANT1(31457280, 0, R, JUST(W->BASE));
U_1002:
V->BASE = R;
V->DISP = 0;
W->BASE = 0;
goto U_1001;
L_011B:
L_0118:
if (PENDINGAUTO == 0) goto L_011C;
if (OPER != 4) goto L_011C;
if (!(ICONST(W))) goto L_011C;
if (-4095 > W->DISP) goto L_011C;
if (W->DISP > 4095) goto L_011C;
PA = PENDINGAUTO;
OPTIMISE(V, 1);
if (!(INREG(V))) goto L_011D;
if (V->BASE != PA) goto L_011D;
if (PENDINGAUTON == 0) goto L_011E;
if (_imp_MOD((unsigned int)W->DISP >> 2) > 255) goto L_011D;
L_011E:
DIR3(16, /*indirectthrough*/ */*indirectthrough*/ *CA - PENDINGAUTOCA, (unsigned int)W->DISP >> PENDINGAUTON);
FORGET(PA);
DROP(W);
LOADSAFELY(V, R);
return;
L_011D:
L_011C:
if (V->TYPE != 2) goto L_011F;
if (OPER == 9) goto L_0120;
if (OPER != 12) goto L_011F;
L_0120:
if (!(ICONST(W))) goto L_011F;
N = W->DISP;
if (OPER != 12) goto L_0121;
N = (~N);
L_0121:
if ((unsigned int)N >> 16 != 0) goto L_0122;
RELEASEANDDROP(W);
if (N > 255) goto L_0123;
ADVANCE(V, 4, 0);
if (N == 255) goto L_0124;
OPERATE(9, V, LITERAL(N));
L_0124:
LOAD(V, R);
goto L_0125;
L_0123:
if (N & 255 != 0) goto L_0126;
V->OPER = 0;
V->LINK = 0;
ADVANCE(V, 4, 1);
if ((unsigned int)N >> 8 == 255) goto L_0127;
OPERATE(9, V, LITERAL((unsigned int)N >> 8));
L_0127:
OPERATE(14, V, LITERAL(8));
LOAD(V, R);
goto L_0125;
L_0126:
B = COPY(V);
ADVANCE(B, 4, 1);
if ((unsigned int)N >> 8 == 255) goto L_0128;
OPERATE(9, B, LITERAL((unsigned int)N >> 8));
L_0128:
ADVANCE(V, 4, 0);
if (N & 255 == 255) goto L_0129;
OPERATE(9, V, LITERAL(N & 255));
L_0129:
LOADUP(B);
LOADSAFELY(V, R);
LOADUP(B);
LOADSAFELY(V, R);
PLANT1(25165824, V->BASE, V->BASE, ISHIFT(B->BASE, 8, 0));
RELEASEANDDROP(B);
L_0125:
return;
L_0122:
L_011F:
LOADSAFELY(V, R);
R = V->BASE;
if (W == NIL) goto L_012A;
if (!(ICONST(W))) goto L_012B;
if (OPER != 21) goto L_012C;
PLANT1(27262976, 0, R, ISHIFT(V->BASE, W->DISP & 65535, 32));
N = -1 << ((unsigned int)W->DISP >> 16);
PLANT1(0, R, R, IMMEDIATE((~N)));
goto U_1001;
L_012C:
if (OPER != 9) goto L_012D;
if (IMMEDIATE(W->DISP) >= 0) goto L_012D;
OPER = 12;
W->DISP = (~W->DISP);
L_012D:
CHARACTERISECONSTANT(W->DISP, /*%A*/ /*addressof*/ &CX);
if (CX.TYPE != 2) goto L_012E;
if (OPER != 4) goto L_012F;
PLANT1(4194304, V->BASE, R, ROT(1, 0));
goto U_1001;
L_012F:
if (OPER != 5) goto L_0130;
PLANT1(8388608, V->BASE, R, ROT(1, 0));
goto U_1001;
L_0130:
if (OPER != 11) goto L_0131;
PLANT1(31457280, 0, R, JUST(V->BASE));
goto U_1001;
L_0131:
goto L_0132;
L_012E:
if (CX.TYPE != 3) goto L_0133;
goto *C2[OPER]; /*TO DO*/
case_C2_4:;
OP = 8388608;
goto U_1003;
case_C2_5:;
OP = 4194304;
goto U_1003;
case_C2_12:;
OP = 29360128;
goto U_1003;
case_C2_10:;
OP = 25165824;
goto U_1003;
case_C2_11:;
OP = 2097152;
goto U_1003;
case_C2_9:;
if (CX.V2 != 0) goto L_0135;
OP = 0;
goto U_1003;
L_0135:
goto U_1004;
U_1003:
PLANT1(OP, V->BASE, R, ROT(CX.V1, CX.R1));
if (CX.V2 == 0) goto L_0136;
PLANT1(OP, R, R, ROT(CX.V2, CX.R2));
L_0136:
goto U_1001;
case_C2_14:;
if ((unsigned int)W->DISP >> 5 == 0) goto L_0137;
WARN(1, _imp_str_literal("Dubious shift"));
L_0137:
PLANT1(27262976, 0, R, ISHIFT(V->BASE, W->DISP & 31, 0));
goto U_1001;
case_C2_15:;
if ((unsigned int)W->DISP >> 5 == 0) goto L_0138;
WARN(1, _imp_str_literal("Dubious shift"));
L_0138:
PLANT1(27262976, 0, R, ISHIFT(V->BASE, W->DISP & 31, 32));
goto U_1001;
L_0133:
if (CX.TYPE != 4) goto L_0139;
CHARACTERISECONSTANT(-W->DISP, /*%A*/ /*addressof*/ &CX);
if (CX.TYPE == 3) goto L_013A;
goto U_1004;
L_013A:
if (OPER != 4) goto L_013B;
OP = 4194304;
goto U_1003;
L_013B:
if (OPER != 5) goto L_013C;
OP = 8388608;
goto U_1003;
L_013C:
if (OPER == 15) goto L_013D;
if (OPER != 14) goto L_013E;
L_013D:
WARN(1, _imp_str_literal("Dubious shift"));
L_013E:
L_0139:
L_0132:
L_012B:
L_012A:
U_1004:
C2_default:;
if (W == NIL) goto L_013F;
LOADUP(W);
L_013F:
goto *C[OPER]; /*TO DO*/
case_C_1:;
PLANT1(31457280, 0, R, JUST(V->BASE));
goto U_1005;
case_C_2:;
PLANT1(6291456, V->BASE, R, NOTHING());
goto U_1005;
case_C_3:;
PLANT1(8388608 | 1048576, R, R, NOTHING());
{ /*%begin*/
int LABEL;
LABEL = NEWLABEL();
JUMPTO(LABEL, 5);
PLANT1(6291456, R, R, NOTHING());
DEFINELABEL(LABEL);
}
goto U_1005;
case_C_4:;
PLANT1(8388608, V->BASE, R, JUST(W->BASE));
goto U_1001;
case_C_5:;
PLANT1(4194304, V->BASE, R, JUST(W->BASE));
goto U_1001;
case_C_12:;
PLANT1(29360128, V->BASE, R, JUST(W->BASE));
goto U_1001;
case_C_9:;
PLANT1(0, V->BASE, R, JUST(W->BASE));
goto U_1001;
case_C_10:;
PLANT1(25165824, V->BASE, R, JUST(W->BASE));
goto U_1001;
case_C_11:;
PLANT1(2097152, V->BASE, R, JUST(W->BASE));
goto U_1001;
case_C_14:;
PLANT1(27262976, 0, R, RSHIFT(V->BASE, W->BASE, 144));
goto U_1001;
case_C_15:;
PLANT1(27262976, 0, R, RSHIFT(V->BASE, W->BASE, 176));
goto U_1001;
C_default:;
NOTINYET();
U_1001:
if (W == NIL) goto L_0141;
RELEASEANDDROP(W);
L_0141:
U_1005:
} /* COMPLEXLOAD */
void LOAD(struct STACKFM * V, int R) {
if (V->OPER != 0) goto L_0142;
SIMPLELOAD(V, R);
goto L_0143;
L_0142:
COMPLEXLOAD(V, R);
L_0143:
if (DIAG & 32 == 0) goto L_0144;
MONITOR(V, _imp_str_literal("<-Load"));
L_0144:
} /* LOAD */
void LOADPAIR(struct STACKFM * A, int AR, struct STACKFM *B, int BR) {
if (B != 0) goto L_0145;
if (/*%A*/ /*addressof*/ &B != NIL) goto L_0145;
if (/*%A*/ /*addressof*/ &B == NIL) goto L_0146;
L_0145:
LOAD(/*%A*/ /*addressof*/ &B, BR);
LOAD(A, AR);
LOAD(/*%A*/ /*addressof*/ &B, BR);
goto L_0147;
L_0146:
LOAD(A, AR);
LOAD(/*%A*/ /*addressof*/ &B, BR);
LOAD(A, AR);
L_0147:
} /* LOADPAIR */
void LOADTRIO(struct STACKFM * A, int AR, struct STACKFM *B, int BR, struct STACKFM *C, int CR) {
if (B != 0) goto L_0148;
if (/*%A*/ /*addressof*/ &B != NIL) goto L_0148;
if (/*%A*/ /*addressof*/ &B == NIL) goto L_0149;
L_0148:
LOAD(/*%A*/ /*addressof*/ &B, BR);
LOADPAIR(A, AR, /*%A*/ /*addressof*/ &C, /*indirectthrough*/ *CR);
goto L_014A;
L_0149:
if (C != 0) goto L_014B;
if (/*%A*/ /*addressof*/ &C != NIL) goto L_014B;
if (/*%A*/ /*addressof*/ &C == NIL) goto L_014C;
L_014B:
LOAD(/*%A*/ /*addressof*/ &C, BR);
LOADPAIR(A, AR, /*%A*/ /*addressof*/ &B, BR);
goto L_014A;
L_014C:
LOAD(A, AR);
LOADPAIR(/*%A*/ /*addressof*/ &B, BR, /*%A*/ /*addressof*/ &C, /*indirectthrough*/ *CR);
L_014A:
LOAD(A, AR);
LOAD(/*%A*/ /*addressof*/ &B, BR);
LOAD(/*%A*/ /*addressof*/ &C, /*indirectthrough*/ *CR);
} /* LOADTRIO */
void REPEAT(void BODY(void), struct STACKFM *TIMES, int INC, int HOW) {
int LABEL;
if (!(ICONST(/*%A*/ /*addressof*/ &TIMES))) goto L_014D;
if (TIMES > 0) goto L_014D;
return;
L_014D:
LOADUP(/*%A*/ /*addressof*/ &TIMES);
LABEL = NEWLABEL();
DEFINELABEL(LABEL);
BODY();
PLANT1(4194304 | 1048576, TIMES, TIMES, IMMEDIATE(INC));
JUMPTO(LABEL, HOW);
if (HOW != 6) goto L_014E;
REMEMBERZERO(TIMES);
L_014E:
RELEASEANDDROP(/*%A*/ /*addressof*/ &TIMES);
} /* REPEAT */
int CHEAPEST(int LOW, int HIGH) {
int R;
int A;
int U;
int MINACTIVITY;
int MINKNOWN;
int MINREG;
int OLDEST;
MINACTIVITY = 1000;
MINKNOWN = 1000;
MINREG = 0;
USEDTIME = USEDTIME + 1;
OLDEST = USEDTIME;
R = LOW - 1; /*%for R = LOW, 1, HIGH %cycle*/
L_014F:
if (R == HIGH) goto L_0150;
R += 1;
A = ACTIVITY[R];
if (A >= 0) goto L_0152;
goto L_0151;
L_0152:
U = USED[R];
if (A != MINACTIVITY) goto L_0153;
if (MINKNOWN <= KTIMES[R]) goto L_0154;
MINREG = R;
MINKNOWN = KTIMES[R];
OLDEST = U;
goto L_0155;
L_0154:
if (MINKNOWN != KTIMES[R]) goto L_0156;
if (OLDEST <= U) goto L_0157;
MINREG = R;
OLDEST = U;
L_0157:
L_0156:
L_0155:
goto L_0158;
L_0153:
if (A >= MINACTIVITY) goto L_0159;
MINACTIVITY = A;
MINREG = R;
MINKNOWN = KTIMES[R];
OLDEST = U;
L_0159:
L_0158:
L_0151:
goto L_014F;
L_0150:
if (MINREG != 0) goto L_015A;
FAIL(_imp_str_literal("all registers lost"));
L_015A:
USED[MINREG] = USEDTIME;
if (MINACTIVITY == 0) goto L_015B;
HAZARD(MINREG);
L_015B:
return MINREG;
} /* CHEAPEST */
int GPR(void) { return CHEAPEST(1, 9); } /* GPR */
int FPR(void) { return CHEAPEST(18, 25); } /* FPR */
struct STACKFM *REGISTER(int REG) {
struct STACKFM *R;
R = DESCRIPTOR();
if (REG != 17) goto L_015C;
R->TYPE = 1;
REG = CHEAPEST(1, 9);
goto L_015D;
L_015C:
if (REG != 26) goto L_015E;
R->TYPE = 7;
REG = CHEAPEST(18, 25);
goto L_015D;
L_015E:
R->TYPE = 1;
if (REG < 18) goto L_015F;
R->TYPE = 7;
L_015F:
L_015D:
R->BASE = REG;
CLAIM(REG);
return R;
} /* REGISTER */
int LOCKED(int R) {
if (/*indirectthrough*/ *R >= 128) goto L_0160;
if (/*indirectthrough*/ *R == 0) goto L_0160;
if (ACTIVITY[/*indirectthrough*/ *R] >= 0) goto L_0161;
L_0160:
return 1 /*TRUE*/;
L_0161:
return 0 /*FALSE*/;
} /* LOCKED */
int PROPERLYALIGNED(struct STACKFM * V, int MASK) {
if (V != 13) goto L_0162;
return 1 /*TRUE*/;
L_0162:
if (V != 9) goto L_0163;
if (V < 0) goto L_0164;
return 0 /*FALSE*/;
L_0164:
if (VAR(-V)->DISP != 3) goto L_0165;
return 1 /*TRUE*/;
L_0165:
L_0163:
if (LOCKED(V)) goto L_0166;
return 0 /*FALSE*/;
L_0166:
if (V != 1) goto L_0167;
if (/*%A*/ /*addressof*/ &V != NIL) goto L_0167;
if (/*%A*/ /*addressof*/ &V != NIL) goto L_0167;
if (V & MASK != 0) goto L_0167;
return 1 /*TRUE*/;
L_0167:
return 0 /*FALSE*/;
} /* PROPERLYALIGNED */
void SIMPLIFY(struct STACKFM * V) {
int N;
int D;
struct STACKFM *R;
struct STACKFM *X;
if (DIAG & 16 == 0) goto L_0168;
MONITOR(/*%A*/ /*addressof*/ &V, _imp_str_literal("->Simplify"));
L_0168:
if (V == 0) goto L_0169;
LOADUP(/*%A*/ /*addressof*/ &V);
goto U_1006;
L_0169:
if (/*%A*/ /*addressof*/ &V == NIL) goto L_016A;
if (V != 0) goto L_016B;
if (V != 0) goto L_016B;
if (V != 0) goto L_016B;
if (/*%A*/ /*addressof*/ &V != NIL) goto L_016B;
R = /*%A*/ /*addressof*/ &V;
V = R->DATA;
R->INDEX = NIL;
R->RECORD = NIL;
DROP(R);
SIMPLIFY(/*%A*/ /*addressof*/ &V);
goto U_1006;
L_016B:
SIMPLIFY(/*%A*/ /*addressof*/ &V);
if (/*%A*/ /*addressof*/ &V != NIL) goto L_016C;
if (V != 0) goto L_016C;
if (V == 0) goto L_016D;
L_016C:
LOADUP(/*%A*/ /*addressof*/ &V);
L_016D:
V = V + V;
V = 0;
if (V != 0) goto L_016E;
DROP(/*%A*/ /*addressof*/ &V);
V = NIL;
goto L_016F;
L_016E:
if (V != 0) goto L_0170;
V = V;
DROP(/*%A*/ /*addressof*/ &V);
V = NIL;
goto L_016F;
L_0170:
if (/*%A*/ /*addressof*/ &V != NIL) goto L_0171;
V = /*%A*/ /*addressof*/ &V;
V = 1;
V = NIL;
goto L_016F;
L_0171:
OPERATE(4, /*%A*/ /*addressof*/ &V, /*%A*/ /*addressof*/ &V);
V = NIL;
L_016F:
L_016A:
if (/*%A*/ /*addressof*/ &V == NIL) goto L_0172;
SIMPLIFY(/*%A*/ /*addressof*/ &V);
if (V != 512) goto L_0173;
X = LITERAL(V);
V = 0;
X->AREA = 512;
V = 0;
LOADUP(X);
if (V != 0) goto L_0174;
V = X->BASE;
DROP(X);
goto L_0175;
L_0174:
OPERATE(6, /*%A*/ /*addressof*/ &V, LITERAL(V));
V = 1;
OPERATE(4, /*%A*/ /*addressof*/ &V, X);
L_0175:
goto L_0176;
L_0173:
N = POWER(V);
if (N >= 0) goto L_0177;
OPERATE(6, /*%A*/ /*addressof*/ &V, LITERAL(V));
V = 1;
LOADUP(/*%A*/ /*addressof*/ &V);
L_0177:
L_0176:
if (V == 0) goto L_0178;
if (V == 1) goto L_0179;
OPERATE(6, /*%A*/ /*addressof*/ &V, LITERAL(V));
V = 1;
L_0179:
OPERATE(4, /*%A*/ /*addressof*/ &V, LITERAL(V));
V = 0;
LOADUP(/*%A*/ /*addressof*/ &V);
L_0178:
L_0172:
void ENSUREDISPLACEMENT(int D, int TYPE) {
struct STACKFM *W;
if (TYPE != 1) goto L_017A;
if (-4095 > D) goto L_017B;
if (D > 4095) goto L_017B;
return;
L_017B:
goto L_017C;
L_017A:
if (D & 3 == 0) goto L_017D;
FAIL(_imp_str_literal("real address error"));
L_017D:
if (-255 > ((long)D / (long)4)) goto L_017E;
if (((long)D / (long)4) > 255) goto L_017E;
return;
L_017E:
L_017C:
V = 0;
W = LITERAL(D);
LOADUP(W);
if (/*%A*/ /*addressof*/ &V != NIL) goto L_017F;
V = W;
V = 1;
goto L_0180;
L_017F:
if (V == 1) goto L_0181;
OPERATE(6, /*%A*/ /*addressof*/ &V, LITERAL(V));
V = 1;
L_0181:
OPERATE(4, /*%A*/ /*addressof*/ &V, W);
L_0180:
SIMPLIFY(/*%A*/ /*addressof*/ &V);
} /* ENSUREDISPLACEMENT */
D = V;
if (!(ICONST(/*%A*/ /*addressof*/ &V))) goto L_0182;
if (0 > D) goto L_0183;
if (D > 255) goto L_0183;
V = 4;
goto L_0184;
L_0183:
if (-32768 > D) goto L_0185;
if (D > 32767) goto L_0185;
V = 2;
L_0185:
L_0184:
goto L_0186;
L_0182:
if (V == 0) goto L_0187;
if (V == 7) goto L_0188;
if (V != 6) goto L_0189;
L_0188:
ENSUREDISPLACEMENT(D, 6);
goto L_018A;
L_0189:
if (V > 5) goto L_018B;
ENSUREDISPLACEMENT(D, 1);
L_018B:
L_018A:
L_0187:
L_0186:
U_1006:
if (DIAG & 16 == 0) goto L_018C;
MONITOR(/*%A*/ /*addressof*/ &V, _imp_str_literal("<-Simplify"));
L_018C:
} /* SIMPLIFY */
void APPLYINDEX(struct STACKFM * V, struct STACKFM * X, int XSIZE) {
int N;
int MULOP;
if (!(ICONST(/*%A*/ /*addressof*/ &X))) goto L_018D;
if (V != 1) goto L_018D;
N = V + X * /*indirectthrough*/ *XSIZE;
V = N;
DROP(/*%A*/ /*addressof*/ &X);
return;
L_018D:
if (/*%A*/ /*addressof*/ &V != NIL) goto L_018E;
V = /*%A*/ /*addressof*/ &X;
V = /*indirectthrough*/ *XSIZE;
goto L_018F;
L_018E:
if (V != /*indirectthrough*/ *XSIZE) goto L_0190;
OPERATE(4, /*%A*/ /*addressof*/ &V, /*%A*/ /*addressof*/ &X);
goto L_018F;
L_0190:
MULOP = 6;
if (V == 1) goto L_0191;
OPERATE(MULOP, /*%A*/ /*addressof*/ &V, LITERAL(V));
L_0191:
if (/*indirectthrough*/ *XSIZE == 1) goto L_0192;
OPERATE(MULOP, /*%A*/ /*addressof*/ &X, LITERAL(/*indirectthrough*/ *XSIZE));
L_0192:
OPERATE(4, /*%A*/ /*addressof*/ &V, /*%A*/ /*addressof*/ &X);
V = 1;
L_018F:
} /* APPLYINDEX */
void FIXUNITARYSTRING(struct STACKFM * V) {
int LEN;
int VAL;
int AT;
static int NULLADDRESS = -1;
int LOCATE(int LEN, int CHAR) {
int HERE;
CONSTANTBASE = CONSTANTBASE + 3 & (~3);
HERE = CONSTANTBASE;
SELECTCONSTANTAREA();
DUMPBYTE(LEN);
if (LEN == 0) goto L_0193;
DUMPBYTE(/*indirectthrough*/ *CHAR);
L_0193:
SELECTCODEAREA();
return HERE;
} /* LOCATE */
if (V != 8) goto L_0194;
if (V != 1) goto L_0194;
if (NULLADDRESS >= 0) goto L_0195;
NULLADDRESS = LOCATE(0, 0);
L_0195:
AT = NULLADDRESS;
LEN = 1;
goto L_0196;
L_0194:
if (V != 13) goto L_0197;
BUILDSET(/*%A*/ /*addressof*/ &V);
return;
L_0197:
if (V > 5) goto L_0198;
VAL = V & 255;
if (VAL == V) goto L_0199;
WARN(1, _imp_str_literal("string character out of range"));
L_0199:
AT = LOCATE(1, VAL);
LEN = 2;
goto L_0196;
L_0198:
FAIL(_imp_str_literal("bad tostring type"));
L_0196:
V = AT;
V = 8;
V = 1;
V = 512;
V = LEN;
V = LEN;
} /* FIXUNITARYSTRING */
void AMAP(struct STACKFM * V) {
struct STACKFM *W;
if (V != 0) goto L_019A;
FIXUNITARYSTRING(/*%A*/ /*addressof*/ &V);
goto L_019B;
L_019A:
if (V == 0) goto L_019C;
FAIL(_imp_str_literal("Amap:oper"));
L_019C:
L_019B:
V = 1;
if (V != 3) goto L_019D;
return;
L_019D:
if (V != 4) goto L_019E;
if (V & 1024 == 0) goto L_019F;
HAZARD(14);
FORGET(14);
DIR2(19, V);
REFS = REFS + 1;
/*indirectthrough*/ *CA = /*indirectthrough*/ */*indirectthrough*/ *CA + 4;
V = 1;
V = 0;
V = 14;
V = 0;
V = 0;
CLAIM(14);
goto L_01A0;
L_019F:
if (V & 4 == 0) goto L_01A1;
V = 1;
V = 1;
V = 0;
goto L_01A0;
L_01A1:
if (V & 16777216 == 0) goto L_01A2;
HAZARD(14);
FORGET(14);
DIR2(18, V);
REFS = REFS + 1;
/*indirectthrough*/ *CA = /*indirectthrough*/ */*indirectthrough*/ *CA + 4;
V = 1;
V = 0;
V = 14;
V = 0;
V = 0;
CLAIM(14);
goto L_01A0;
L_01A2:
FAIL(_imp_str_literal("cannot address local procedures"));
L_01A0:
goto L_01A3;
L_019E:
if (V == 1) goto L_01A4;
FAIL(_imp_str_literal("Amap:form"));
L_01A4:
V = 0;
if (/*%A*/ /*addressof*/ &V == NIL) goto L_01A5;
if (!(ICONST(/*%A*/ /*addressof*/ &V))) goto L_01A5;
V = V + V * V;
DROP(/*%A*/ /*addressof*/ &V);
V = NIL;
L_01A5:
if (V != 0) goto L_01A6;
if (/*%A*/ /*addressof*/ &V != NIL) goto L_01A6;
if (/*%A*/ /*addressof*/ &V == NIL) goto L_01A6;
W = /*%A*/ /*addressof*/ &V;
V = W->DATA;
W->INDEX = NIL;
W->RECORD = NIL;
DROP(W);
L_01A6:
L_01A3:
if (DIAG & 16 == 0) goto L_01A7;
MONITOR(/*%A*/ /*addressof*/ &V, _imp_str_literal("Amap<-"));
L_01A7:
} /* AMAP */
void MAKEAUTOI(struct STACKFM * V, int TYPE) {
AMAP(/*%A*/ /*addressof*/ &V);
LOADPROTECTED(/*%A*/ /*addressof*/ &V);
V = /*indirectthrough*/ *TYPE;
V = 2;
} /* MAKEAUTOI */
void VMAP(struct STACKFM * V, int NEWTYPE) {
struct STACKFM *W;
struct STACKFM *C;
int D;
D = 0;
if (1 > V) goto L_01A8;
if (V <= 5) goto L_01A9;
L_01A8:
FAIL(_imp_str_literal("Vmap:type"));
L_01A9:
if (V != 4) goto L_01AA;
C = /*%A*/ /*addressof*/ &V;
if (!(ICONST(C))) goto L_01AB;
D = C->DISP;
DROP(C);
V = NIL;
V = 0;
L_01AB:
L_01AA:
if (V == 0) goto L_01AC;
LOADUP(/*%A*/ /*addressof*/ &V);
L_01AC:
if (V == 0) goto L_01AD;
W = DESCRIPTOR();
W->DATA = V;
V = 0;
V = W;
V = D;
L_01AD:
V = INTERNALTYPE[/*indirectthrough*/ *NEWTYPE];
V = 1;
V = TYPEFMT[/*indirectthrough*/ *NEWTYPE];
if (DIAG & 16 == 0) goto L_01AE;
MONITOR(/*%A*/ /*addressof*/ &V, _imp_str_literal("Vmap<-"));
L_01AE:
} /* VMAP */
void FMAP(int NEWTYPE) {
if (!(INREG(STACK))) goto L_01AF;
HAZARD(STACK->BASE);
L_01AF:
if (STACK->TYPE != 1) goto L_01B0;
if (STACK->FORM != 0) goto L_01B1;
L_01B0:
FAIL(_imp_str_literal("Bad type for Fmap"));
L_01B1:
STACK->FORM = 4;
STACK->TYPE = /*indirectthrough*/ *NEWTYPE;
STACK->FLAGS = STACK->FLAGS | 524288 | 4;
} /* FMAP */
void ADVANCE(struct STACKFM * V, int TYPE, int BY) {
int CHECKFLAG;
if (V->FORM == 3) goto L_01B2;
CHECKFLAG = V->FLAGS & 1048576;
AMAP(V);
OPERATE(4, V, LITERAL(/*indirectthrough*/ *BY));
VMAP(V, /*indirectthrough*/ *TYPE);
V->FLAGS = V->FLAGS | CHECKFLAG;
goto L_01B3;
L_01B2:
V->TYPE = /*indirectthrough*/ *TYPE;
L_01B3:
} /* ADVANCE */
void MACHINECODE(void) {
const _imp_string4 OPCODE[95] = {
_imp_str_literal("ABS"), _imp_str_literal("ACS"), _imp_str_literal("ADC"), _imp_str_literal("ADD"),
_imp_str_literal("ADF"), _imp_str_literal("AND"), _imp_str_literal("ASN"), _imp_str_literal("ATN"),
_imp_str_literal("B"), _imp_str_literal("BAL"), _imp_str_literal("BCC"), _imp_str_literal("BCS"),
_imp_str_literal("BEQ"), _imp_str_literal("BGE"), _imp_str_literal("BGT"), _imp_str_literal("BHI"),
_imp_str_literal("BIC"), _imp_str_literal("BL"), _imp_str_literal("BLAL"), _imp_str_literal("BLCC"),
_imp_str_literal("BLCS"), _imp_str_literal("BLE"), _imp_str_literal("BLEQ"), _imp_str_literal("BLGE"),
_imp_str_literal("BLGT"), _imp_str_literal("BLHI"), _imp_str_literal("BLLE"), _imp_str_literal("BLLS"),
_imp_str_literal("BLLT"), _imp_str_literal("BLMI"), _imp_str_literal("BLNE"), _imp_str_literal("BLNV"),
_imp_str_literal("BLPL"), _imp_str_literal("BLS"), _imp_str_literal("BLT"), _imp_str_literal("BLVC"),
_imp_str_literal("BLVS"), _imp_str_literal("BMI"), _imp_str_literal("BNE"), _imp_str_literal("BNV"),
_imp_str_literal("BPL"), _imp_str_literal("BR"), _imp_str_literal("BVC"), _imp_str_literal("BVS"),
_imp_str_literal("CMF"), _imp_str_literal("CMFE"), _imp_str_literal("CMN"), _imp_str_literal("CMP"),
_imp_str_literal("CNF"), _imp_str_literal("CNFE"), _imp_str_literal("COS"), _imp_str_literal("DVF"),
_imp_str_literal("EOR"), _imp_str_literal("EXP"), _imp_str_literal("FDV"), _imp_str_literal("FIX"),
_imp_str_literal("FLT"), _imp_str_literal("FML"), _imp_str_literal("FRD"), _imp_str_literal("LDF"),
_imp_str_literal("LDM"), _imp_str_literal("LDR"), _imp_str_literal("LGN"), _imp_str_literal("LOG"),
_imp_str_literal("MNF"), _imp_str_literal("MOV"), _imp_str_literal("MUF"), _imp_str_literal("MVF"),
_imp_str_literal("MVN"), _imp_str_literal("ORR"), _imp_str_literal("POL"), _imp_str_literal("POW"),
_imp_str_literal("RDF"), _imp_str_literal("RFC"), _imp_str_literal("RFS"), _imp_str_literal("RMF"),
_imp_str_literal("RND"), _imp_str_literal("RPW"), _imp_str_literal("RSB"), _imp_str_literal("RSC"),
_imp_str_literal("RSF"), _imp_str_literal("SBC"), _imp_str_literal("SIN"), _imp_str_literal("SQT"),
_imp_str_literal("STF"), _imp_str_literal("STM"), _imp_str_literal("STR"), _imp_str_literal("SUB"),
_imp_str_literal("SUF"), _imp_str_literal("SWI"), _imp_str_literal("TAN"), _imp_str_literal("TEQ"),
_imp_str_literal("TST"), _imp_str_literal("WFC"), _imp_str_literal("WFS")};
const unsigned char TYPE[95] = {10, 10, 1, 1, 10, 1, 10, 10, 5, 5, 5, 5, 5, 5, 5, 5, 1, 5, 5,
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 5, 9, 9, 1, 1, 9, 9, 10, 10, 1, 10, 10, 7, 7,
10, 10, 6, 4, 2, 10, 10, 10, 1, 10, 10, 1, 1, 10, 10, 10, 7, 7, 10,
10, 10, 1, 1, 10, 1, 10, 10, 6, 4, 2, 1, 10, 3, 10, 1, 1, 7, 7};
const int VALUE[95] = {
237011200, 247496960, 10485760, 8388608, 234881280, 0, 246448384, 248545536,
-369098752, -369098752, 973078528, 704643072, 167772160, -1442840576, -905969664, -1979711488,
29360128, -352321536, -352321536, 989855744, 721420288, -637534208, 184549376, -1426063360,
-889192448, -1962934272, -620756992, -1694498816, -1157627904, 1258291200, 452984832, -83886080,
1526726656, -1711276032, -1174405120, 2063597568, 1795162112, 1241513984, 436207616, -100663296,
1509949440, -369098752, 2046820352, 1778384896, 244379920, 248574224, 23068672, 20971520,
246477072, 250671376, 244351232, 239075584, 2097152, 242254080, 245367040, 235929872,
234881296, 244318464, 246415616, 202375424, 135266304, 68157440, 241205504, 240156928,
235962624, 27262976, 235929856, 234914048, 31457280, 25165824, 247464192, 241172736,
240124160, 240124176, 238027024, 243269888, 238059776, 242221312, 6291456, 14680064,
238027008, 12582912, 243302656, 239108352, 201326848, 134217728, 67108864, 4194304,
236978432, 251658240, 245399808, 18874368, 16777216, 239075600, 236978448};
int OPNUM;
int OPTYPE;
int OPVALUE;
OPVALUE = 0;
int OPLENGTH;
int OPERANDS;
int N;
int J;
int KEY;
int P;
int X;
X = 0;
int SYMP;
int DISP;
int RN;
int RD;
int RS;
int RM;
int SH;
int ROT;
int UD;
int REG1;
int REG2;
int FDST;
int FS1;
int FS2;
_imp_string7 OPSTRING;
struct VARFM *W;
static const void *OT[12] = {NULL};
void MCERROR(_imp_string127 TEXT) {
void ERR(int STREAM) {
_imp_SELECTOUTPUT(STREAM);
_imp_PRINTSTRING(_imp_str_literal("*"));
_imp_WRITE(CURRENTLINE, 4);
_imp_PRINTSTRING(
_imp_join((_imp_string)(_imp_join(
(_imp_string)(_imp_join((_imp_string)(_imp_str_literal(" ")), (_imp_string)(OPSTRING))),
(_imp_string)(_imp_str_literal(": ")))),
(_imp_string)(TEXT)));
_imp_NEWLINE();
} /* ERR */
ERR(7);
ERR(0);
if (DIAG & 512 == 0) goto L_01B4;
FAIL(_imp_str_literal("Bang"));
L_01B4:
INTERFACE->FAULTS = INTERFACE->FAULTS + 1;
_imp_SELECTOUTPUT(2);
_imp_SIGNAL(14, 0, 0);
} /* MCERROR */
void FINDOPCODE(void) {
int MIN;
int MAX;
int P;
_imp_string4 KEY;
KEY = _imp_str_literal("0");
OPLENGTH = /*indirectthrough*/ *_imp_LENGTH(/*%A*/ /*addressof*/ &OPSTRING);
if (OPLENGTH > 3) goto L_01B5;
SYMP = OPLENGTH;
KEY = OPSTRING;
goto L_01B6;
L_01B5:
SYMP = 3;
KEY = _imp_join(
(_imp_string)(_imp_join(
(_imp_string)(_imp_TOSTRING(/*indirectthrough*/ *_imp_CHARNO(/*%A*/ /*addressof*/ &OPSTRING, 1))),
(_imp_string)(_imp_TOSTRING(/*indirectthrough*/ *_imp_CHARNO(/*%A*/ /*addressof*/ &OPSTRING, 2))))),
(_imp_string)(_imp_TOSTRING(/*indirectthrough*/ *_imp_CHARNO(/*%A*/ /*addressof*/ &OPSTRING, 3))));
if (/*indirectthrough*/ *_imp_CHARNO(/*%A*/ /*addressof*/ &OPSTRING, 1) != 66) goto L_01B7;
if (/*indirectthrough*/ *_imp_CHARNO(/*%A*/ /*addressof*/ &OPSTRING, 2) != 76) goto L_01B7;
if (OPLENGTH < 4) goto L_01B7;
KEY = _imp_join(
(_imp_string)(KEY),
(_imp_string)(_imp_TOSTRING(/*indirectthrough*/ *_imp_CHARNO(/*%A*/ /*addressof*/ &OPSTRING, 4))));
SYMP = 4;
L_01B7:
L_01B6:
MIN = 1;
MAX = 95;
L_01B8:
if (MIN > MAX) goto L_01B9;
P = (unsigned int)MIN + MAX >> 1;
if (OPCODE[P] != KEY) goto L_01BA;
OPNUM = P;
OPTYPE = TYPE[OPNUM];
OPVALUE = VALUE[OPNUM];
return;
L_01BA:
if (KEY <= OPCODE[P]) goto L_01BB;
MIN = P + 1;
goto L_01BC;
L_01BB:
MAX = P - 1;
L_01BC:
goto L_01B8;
L_01B9:
if (OPSTRING == _imp_str_literal("BYTE")) goto L_01BD;
if (OPSTRING != _imp_str_literal("BYTE1")) goto L_01BE;
L_01BD:
OPNUM = -1;
OPTYPE = -1;
SYMP = OPLENGTH;
goto L_01BF;
L_01BE:
if (OPSTRING != _imp_str_literal("BYTE2")) goto L_01C0;
OPNUM = -2;
OPTYPE = -1;
SYMP = OPLENGTH;
goto L_01BF;
L_01C0:
if (OPSTRING != _imp_str_literal("BYTE4")) goto L_01C1;
OPNUM = -3;
OPTYPE = -1;
SYMP = OPLENGTH;
goto L_01BF;
L_01C1:
MCERROR(_imp_str_literal("unknown opcode"));
L_01BF:
} /* FINDOPCODE */
int MATCH(int WANTED) {
if (PENDING == WANTED) goto L_01C2;
return 0 /*FALSE*/;
L_01C2:
_imp_READSYMBOL(/*%A*/ /*addressof*/ &PENDING);
return 1 /*TRUE*/;
} /* MATCH */
int PMATCH(int WANTED) {
if (PENDING == WANTED | 128) goto L_01C3;
return 0 /*FALSE*/;
L_01C3:
_imp_READSYMBOL(/*%A*/ /*addressof*/ &PENDING);
return 1 /*TRUE*/;
} /* PMATCH */
int LITERAL(int *N) {
if (!(MATCH(78))) goto L_01C4;
N = FOURBYTES();
return 1 /*TRUE*/;
L_01C4:
if (!(MATCH(128 + 98))) goto L_01C5;
N = PENDING;
_imp_READSYMBOL(/*%A*/ /*addressof*/ &PENDING);
return 1 /*TRUE*/;
L_01C5:
if (MATCH(45)) goto L_01C6;
return 0 /*FALSE*/;
L_01C6:
if (LITERAL(/*%A*/ /*addressof*/ &N)) goto L_01C7;
MCERROR(_imp_str_literal("constant expected"));
L_01C7:
N = -N;
return 1 /*TRUE*/;
} /* LITERAL */
void WANT(int SYM) {
if (MATCH(SYM)) goto L_01C8;
MCERROR(_imp_join((_imp_string)(_imp_TOSTRING(SYM)), (_imp_string)(_imp_str_literal(" expected"))));
L_01C8:
} /* WANT */
void WANTLITERAL(int *N) {
if (LITERAL(/*%A*/ /*addressof*/ &N)) goto L_01C9;
MCERROR(_imp_str_literal("constant expected"));
L_01C9:
} /* WANTLITERAL */
void REGISTER(int *R) {
if (!(LITERAL(/*%A*/ /*addressof*/ &R))) goto L_01CA;
if (0 > R) goto L_01CA;
if (R <= 15) goto L_01CB;
L_01CA:
MCERROR(_imp_str_literal("Register expected"));
L_01CB:
} /* REGISTER */
void FREGISTER(int *R) {
if (!(LITERAL(/*%A*/ /*addressof*/ &R))) goto L_01CC;
if (16 + 0 > R) goto L_01CC;
if (R <= 16 + 7) goto L_01CD;
L_01CC:
MCERROR(_imp_str_literal("Floating register expected"));
L_01CD:
} /* FREGISTER */
void SETCC(void) {
const int CC[16] = {17745, 20037, 17235, 17219, 19785, 20556, 22099, 22083,
18505, 19539, 18245, 19540, 18260, 19525, 16716, 20054};
int SYM;
int C;
if (SYMP + 1 >= OPLENGTH) goto L_01CE;
SYM = /*indirectthrough*/ */*indirectthrough*/ */*indirectthrough*/ *_imp_CHARNO(/*%A*/ /*addressof*/ &OPSTRING,
SYMP + 1)
<< 8 |
/*indirectthrough*/ *_imp_CHARNO(/*%A*/ /*addressof*/ &OPSTRING, SYMP + 2);
C = -1; /*%for C = 0, 1, 15 %cycle*/
L_01CF:
if (C == 15) goto L_01D0;
C += 1;
if (CC[C] != SYM) goto L_01D2;
OPVALUE = OPVALUE | C << 28;
SYMP = SYMP + 2;
return;
L_01D2:
goto L_01CF;
L_01D0:
L_01CE:
OPVALUE = OPVALUE | -536870912;
} /* SETCC */
void COMMA(void) {
if (MATCH(44)) goto L_01D3;
MCERROR(_imp_str_literal("comma missing"));
L_01D3:
} /* COMMA */
int OMATCH(int SYM) {
if (SYMP >= OPLENGTH) goto L_01D4;
if (/*indirectthrough*/ *_imp_CHARNO(/*%A*/ /*addressof*/ &OPSTRING, SYMP + 1) == SYM) goto L_01D5;
L_01D4:
return 0 /*FALSE*/;
L_01D5:
SYMP = SYMP + 1;
return 1 /*TRUE*/;
} /* OMATCH */
if (!_imp_on_event(14)) goto L_01D6;
L_01D7:
if (PENDING == 59) goto L_01D8;
_imp_READSYMBOL(/*%A*/ /*addressof*/ &PENDING);
goto L_01D7;
L_01D8:
goto L_01D9;
L_01D6:
OPSTRING = _imp_str_literal("");
L_01DA:
if (PENDING == 95) goto L_01DB;
if (/*indirectthrough*/ *_imp_LENGTH(/*%A*/ /*addressof*/ &OPSTRING) == 7) goto L_01DC;
OPSTRING = _imp_join((_imp_string)(OPSTRING), (_imp_string)(_imp_TOSTRING(PENDING)));
L_01DC:
_imp_READSYMBOL(/*%A*/ /*addressof*/ &PENDING);
goto L_01DA;
L_01DB:
_imp_READSYMBOL(/*%A*/ /*addressof*/ &PENDING);
FINDOPCODE();
if (OPTYPE <= 0) goto L_01DD;
if (OPTYPE == 5) goto L_01DD;
SETCC();
L_01DD:
goto *OT[OPTYPE]; /*TO DO*/
const unsigned char LITSH[4] = {64, 0, 32, 96};
const unsigned char REGSH[4] = {80, 16, 48, 112};
void BADSHIFT(void) { MCERROR(_imp_str_literal("unknown type of shift")); } /* BADSHIFT */
void GETSHIFT(void) {
int SH;
if (!(PMATCH(65))) goto L_01DF;
if (!(PMATCH(83))) goto L_01E0;
if (!(PMATCH(82))) goto L_01E0;
SH = 1;
goto L_01E1;
L_01E0:
BADSHIFT();
L_01E1:
goto L_01D9;
L_01DF:
if (!(PMATCH(76))) goto L_01E2;
if (!(PMATCH(83))) goto L_01E3;
if (!(PMATCH(76))) goto L_01E4;
SH = 2;
goto L_01E5;
L_01E4:
if (!(PMATCH(82))) goto L_01E6;
SH = 3;
goto L_01E5;
L_01E6:
BADSHIFT();
L_01E5:
goto L_01E7;
L_01E3:
BADSHIFT();
L_01E7:
goto L_01D9;
L_01E2:
if (!(PMATCH(82))) goto L_01E8;
if (!(PMATCH(82))) goto L_01E9;
if (PMATCH(88)) goto L_01EA;
BADSHIFT();
L_01EA:
SH = 0;
goto L_01EB;
L_01E9:
if (!(PMATCH(79))) goto L_01EC;
if (!(PMATCH(82))) goto L_01EC;
SH = 4;
goto L_01EB;
L_01EC:
BADSHIFT();
L_01EB:
goto L_01D9;
L_01E8:
BADSHIFT();
L_01D9:
if (SH != 0) goto L_01ED;
OPVALUE = OPVALUE | 6 << 4;
goto L_01EE;
L_01ED:
if (!(MATCH(35))) goto L_01EF;
WANTLITERAL(/*%A*/ /*addressof*/ &N);
if (0 > N) goto L_01D1;
if (N <= 32) goto L_01F0;
L_01D1:
MCERROR(_imp_str_literal("shift out of range"));
L_01F0:
OPVALUE = OPVALUE | (N & 31) << 7 | LITSH[SH];
goto L_01EE;
L_01EF:
REGISTER(/*%A*/ /*addressof*/ &RS);
OPVALUE = OPVALUE | RS << 8 | REGSH[SH];
L_01EE:
} /* GETSHIFT */
case_OT_1:;
KEY = (unsigned int)OPVALUE >> 23 & 3;
N = (unsigned int)OPVALUE >> 21 & 15;
RN = 0;
RD = 0;
RM = 0;
RS = 0;
if (!(OMATCH(83))) goto L_01F1;
OPVALUE = OPVALUE | 1 << 20;
L_01F1:
if (!(OMATCH(80))) goto L_01F2;
if (KEY == 2) goto L_01F3;
WARN(1, _imp_str_literal("spurious P qualifier"));
L_01F3:
RD = 15;
L_01F2:
REGISTER(/*%A*/ /*addressof*/ &RN);
if (KEY == 2) goto L_01F4;
RD = RN;
RN = 0;
if (N == 13) goto L_01F5;
if (N == 15) goto L_01F5;
COMMA();
REGISTER(/*%A*/ /*addressof*/ &RN);
L_01F5:
L_01F4:
OPVALUE = OPVALUE | RD << 12 | RN << 16;
COMMA();
if (!(MATCH(35))) goto L_01F6;
WANTLITERAL(/*%A*/ /*addressof*/ &N);
ROT = 16;
if (N == 0) goto L_01F7;
L_01F8:
if (N & 3 != 0) goto L_01F9;
ROT = ROT - 1;
N = (unsigned int)N >> 2;
goto L_01F8;
L_01F9:
L_01F7:
if ((unsigned int)N >> 8 == 0) goto L_01FA;
MCERROR(_imp_str_literal("cannot generate constant"));
L_01FA:
OPVALUE = OPVALUE | (ROT & 15) << 8 | N | 33554432;
goto L_01FB;
L_01F6:
REGISTER(/*%A*/ /*addressof*/ &RM);
if (!(MATCH(44))) goto L_01FC;
GETSHIFT();
L_01FC:
OPVALUE = OPVALUE | RM;
L_01FB:
goto U_1007;
void GETDISPLACEMENT(int MODE) {
int RM;
UD = 1;
if (!(MATCH(35))) goto L_01FD;
WANTLITERAL(/*%A*/ /*addressof*/ &DISP);
if (DISP >= 0) goto L_01FE;
UD = 0;
DISP = -DISP;
L_01FE:
goto L_01FF;
L_01FD:
DISP = 0;
if (!(MATCH(45))) goto L_0200;
UD = 0;
goto L_0201;
L_0200:
if (!(MATCH(43))) goto L_0202;
L_0202:
L_0201:
REGISTER(/*%A*/ /*addressof*/ &RM);
OPVALUE = OPVALUE | RM | 33554432;
if (!(MATCH(44))) goto L_0203;
GETSHIFT();
L_0203:
L_01FF:
OPVALUE = OPVALUE | MODE;
} /* GETDISPLACEMENT */
void MODIFYDISP(void) {
int SIGN;
int MOD;
SIGN = PENDING;
if (MATCH(43)) goto L_0204;
if (MATCH(45)) goto L_0204;
return;
L_0204:
if (LITERAL(/*%A*/ /*addressof*/ &MOD)) goto L_0205;
MCERROR(_imp_str_literal("constant expected"));
L_0205:
if (SIGN != 45) goto L_0206;
MOD = -MOD;
L_0206:
N = N + MOD;
} /* MODIFYDISP */
case_OT_2:;
if (!(OMATCH(66))) goto L_0207;
OPVALUE = OPVALUE | 1 << 22;
L_0207:
if (!(OMATCH(84))) goto L_0208;
OPVALUE = OPVALUE | 1 << 21;
L_0208:
REGISTER(/*%A*/ /*addressof*/ &RD);
OPVALUE = OPVALUE | RD << 12;
COMMA();
UD = 1;
if (!(MATCH(32))) goto L_0209;
W = VAR(TAG());
DISP = W->DISP;
MODIFYDISP();
if (W->BASE != /*indirectthrough*/ *LOCAL) goto L_020A;
RN = ACTUAL[11];
goto L_020B;
L_020A:
if (W->BASE != 10) goto L_020C;
RN = ACTUAL[10];
goto L_020B;
L_020C:
if (W->BASE != 0) goto L_020D;
if (W->AREA >= 0) goto L_020D;
DIR3(13, RD, -W->AREA);
REFS = REFS + 1;
/*indirectthrough*/ *CA = /*indirectthrough*/ */*indirectthrough*/ *CA + 4;
RN = RD;
DISP = 0;
goto L_020B;
L_020D:
MCERROR(_imp_str_literal("cannot address non-locals"));
L_020B:
if (DISP >= 0) goto L_020E;
DISP = -DISP;
UD = 0;
L_020E:
OPVALUE = OPVALUE | 83886080 | RN << 16;
goto L_020F;
L_0209:
WANT(91);
REGISTER(/*%A*/ /*addressof*/ &RN);
OPVALUE = OPVALUE | RN << 16;
if (!(MATCH(44))) goto L_0210;
if (OPVALUE & 1 << 21 == 0) goto L_0211;
WARN(1, _imp_str_literal("spurious translate option"));
L_0211:
GETDISPLACEMENT(83886080);
WANT(93);
if (!(MATCH(33))) goto L_0212;
OPVALUE = OPVALUE | 1 << 21;
L_0212:
goto L_0213;
L_0210:
WANT(93);
if (!(MATCH(44))) goto L_0214;
GETDISPLACEMENT(67108864);
goto L_0215;
L_0214:
DISP = 0;
OPVALUE = OPVALUE | 67108864;
L_0215:
L_0213:
L_020F:
if (DISP <= 4095) goto L_0216;
MCERROR(_imp_str_literal("displacement too large"));
L_0216:
OPVALUE = OPVALUE | UD << 23 | DISP;
goto U_1007;
case_OT_3:;
WANTLITERAL(/*%A*/ /*addressof*/ &N);
OPVALUE = OPVALUE | N & 16777215;
goto U_1007;
void RLIST(void) {
WANT(60);
if (PENDING == 62) goto L_0217;
L_0218:
REGISTER(/*%A*/ /*addressof*/ &N);
OPVALUE = OPVALUE | 1 << N;
if (!(MATCH(44))) goto L_0219;
goto L_0218;
L_0219:
L_0217:
WANT(62);
} /* RLIST */
case_OT_4:;
if (!(OMATCH(73))) goto L_021A;
if (!(OMATCH(65))) goto L_021B;
OPVALUE = OPVALUE | 1 << 23;
goto L_021C;
L_021B:
if (!(OMATCH(66))) goto L_021D;
OPVALUE = OPVALUE | 3 << 23;
goto L_021C;
L_021D:
MCERROR(_imp_str_literal("IA or IB expected"));
L_021C:
goto L_021E;
L_021A:
if (!(OMATCH(68))) goto L_021F;
if (!(OMATCH(65))) goto L_0220;
OPVALUE = OPVALUE | 0 << 23;
goto L_0221;
L_0220:
if (!(OMATCH(66))) goto L_0222;
OPVALUE = OPVALUE | 2 << 23;
goto L_0221;
L_0222:
MCERROR(_imp_str_literal("DA or DB expected"));
L_0221:
goto L_021E;
L_021F:
if (!(OMATCH(70))) goto L_0223;
OPVALUE = OPVALUE | 2 << 23;
goto L_0224;
L_0223:
if (!(OMATCH(69))) goto L_0225;
OPVALUE = OPVALUE | 0 << 23;
L_0225:
L_0224:
if (!(OMATCH(65))) goto L_0226;
OPVALUE = OPVALUE | 1 << 23;
goto L_0227;
L_0226:
if (!(OMATCH(68))) goto L_0228;
OPVALUE = OPVALUE | 0 << 23;
L_0228:
L_0227:
L_021E:
REGISTER(/*%A*/ /*addressof*/ &RN);
OPVALUE = OPVALUE | RN << 16;
if (!(MATCH(33))) goto L_0229;
OPVALUE = OPVALUE | 1 << 21;
L_0229:
COMMA();
RLIST();
if (!(MATCH(94))) goto L_022A;
OPVALUE = OPVALUE | 1 << 22;
L_022A:
goto U_1007;
case_OT_5:;
if (!(MATCH(32))) goto L_022B;
W = VAR(TAG());
if (W->TYPE != 11) goto L_022C;
DIR3(15, W->DISP, OPVALUE);
/*indirectthrough*/ *CA = /*indirectthrough*/ */*indirectthrough*/ *CA + 4;
goto U_1008;
L_022C:
L_022B:
MCERROR(_imp_str_literal("Unimplemented form of branch"));
void SETDS(int LETP) {
if (!(OMATCH(68))) goto L_022D;
OPVALUE = OPVALUE | 128;
goto L_022E;
L_022D:
if (!(OMATCH(69))) goto L_022F;
OPVALUE = OPVALUE | 524288;
goto L_022E;
L_022F:
if (LETP == 0) goto L_0230;
if (!(OMATCH(80))) goto L_0230;
OPVALUE = OPVALUE | 524416;
goto L_022E;
L_0230:
if (OMATCH(83)) goto L_0231;
MCERROR(_imp_str_literal("D, S, E or P wanted"));
L_0231:
L_022E:
} /* SETDS */
void LITREG(int *R) {
if (!(MATCH(35))) goto L_0232;
WANTLITERAL(/*%A*/ /*addressof*/ &R);
if (R != 1) goto L_0233;
if (!(MATCH(47))) goto L_0233;
WANTLITERAL(/*%A*/ /*addressof*/ &R);
if (R == 2) goto L_0234;
MCERROR(_imp_str_literal("only 1/2 permitted"));
L_0234:
R = 6;
goto L_0235;
L_0233:
if (0 > R) goto L_0236;
if (R <= 5) goto L_0237;
L_0236:
if (R == 10) goto L_0237;
MCERROR(_imp_str_literal("bad range"));
L_0237:
if (R != 10) goto L_0238;
R = 7;
L_0238:
L_0235:
R = R | 8;
goto L_0239;
L_0232:
FREGISTER(/*%A*/ /*addressof*/ &R);
R = R & 7;
L_0239:
} /* LITREG */
case_OT_6:;
if (!(OMATCH(83))) goto L_023A;
goto L_023B;
L_023A:
if (!(OMATCH(68))) goto L_023C;
OPVALUE = OPVALUE | 32768;
goto L_023B;
L_023C:
if (!(OMATCH(69))) goto L_023D;
OPVALUE = OPVALUE | 4194304;
goto L_023B;
L_023D:
if (!(OMATCH(80))) goto L_023E;
OPVALUE = OPVALUE | 4227072;
L_023E:
L_023B:
FREGISTER(/*%A*/ /*addressof*/ &FDST);
COMMA();
UD = 1;
if (!(MATCH(32))) goto L_023F;
W = VAR(TAG());
DISP = W->DISP;
MODIFYDISP();
if (W->BASE != /*indirectthrough*/ *LOCAL) goto L_0240;
RN = ACTUAL[11];
goto L_0241;
L_0240:
if (W->BASE != 10) goto L_0242;
RN = ACTUAL[10];
goto L_0241;
L_0242:
if (W->BASE != 0) goto L_0243;
if (W->AREA >= 0) goto L_0243;
DIR3(13, RD, -W->AREA);
REFS = REFS + 1;
/*indirectthrough*/ *CA = /*indirectthrough*/ */*indirectthrough*/ *CA + 4;
RN = RD;
DISP = 0;
goto L_0241;
L_0243:
MCERROR(_imp_str_literal("cannot address non-locals"));
L_0241:
goto L_0244;
L_023F:
WANT(91);
REGISTER(/*%A*/ /*addressof*/ &RN);
if (!(MATCH(44))) goto L_0245;
if (OPVALUE & 1 << 21 == 0) goto L_0246;
WARN(1, _imp_str_literal("spurious translate option"));
L_0246:
GETDISPLACEMENT(83886080);
WANT(93);
if (!(MATCH(33))) goto L_0247;
OPVALUE = OPVALUE | 1 << 21;
L_0247:
goto L_0248;
L_0245:
WANT(93);
if (!(MATCH(44))) goto L_0249;
GETDISPLACEMENT(67108864);
goto L_024A;
L_0249:
OPVALUE = OPVALUE | 67108864;
L_024A:
L_0248:
L_0244:
if (DISP >= 0) goto L_024B;
DISP = -DISP;
UD = 0;
L_024B:
if (DISP & 3 == 0) goto L_024C;
MCERROR(_imp_str_literal("Alignment error"));
L_024C:
DISP = (unsigned int)DISP >> 2;
if (DISP <= 255) goto L_024D;
MCERROR(_imp_str_literal("displacement too large"));
L_024D:
OPVALUE = OPVALUE | DISP | 83886080 | RN << 16 | (FDST & 7) << 12 | UD << 23;
goto U_1007;
void SETROUND(void) {
if (!(OMATCH(80))) goto L_024E;
OPVALUE = OPVALUE | 32;
goto L_024F;
L_024E:
if (!(OMATCH(77))) goto L_0250;
OPVALUE = OPVALUE | 64;
goto L_024F;
L_0250:
if (!(OMATCH(90))) goto L_0251;
OPVALUE = OPVALUE | 96;
L_0251:
L_024F:
} /* SETROUND */
case_OT_7:;
SETDS(0);
SETROUND();
N = (unsigned int)OPVALUE >> 20 & 15;
if (N != 0) goto L_0252;
FREGISTER(/*%A*/ /*addressof*/ ®1);
COMMA();
REGISTER(/*%A*/ /*addressof*/ ®2);
OPVALUE = OPVALUE | (REG1 & 7) << 16 | REG2 << 12;
goto L_0253;
L_0252:
if (N != 1) goto L_0254;
REGISTER(/*%A*/ /*addressof*/ ®1);
COMMA();
FREGISTER(/*%A*/ /*addressof*/ ®2);
OPVALUE = OPVALUE | REG1 << 12 | REG2 & 7;
goto L_0253;
L_0254:
REGISTER(/*%A*/ /*addressof*/ ®1);
OPVALUE = OPVALUE | REG1 << 12;
L_0253:
goto U_1007;
case_OT_9:;
FREGISTER(/*%A*/ /*addressof*/ &FS1);
COMMA();
LITREG(/*%A*/ /*addressof*/ &FS2);
OPVALUE = OPVALUE | (FS1 & 7) << 16 | FS2;
goto U_1007;
case_OT_10:;
SETDS(1);
SETROUND();
FREGISTER(/*%A*/ /*addressof*/ &FDST);
COMMA();
if (OPVALUE & 32768 != 0) goto L_0255;
FREGISTER(/*%A*/ /*addressof*/ &FS1);
COMMA();
goto L_0256;
L_0255:
FS1 = 0;
L_0256:
LITREG(/*%A*/ /*addressof*/ &FS2);
OPVALUE = OPVALUE | (FDST & 7) << 12 | (FS1 & 7) << 16 | FS2;
goto U_1007;
case_OT_ - 1:;
L_0257:
if (LITERAL(/*%A*/ /*addressof*/ &N)) goto L_0258;
MCERROR(_imp_str_literal("constant expected"));
L_0258:
if (OPNUM != -1) goto L_0259;
DUMPBYTE(N & 255);
goto L_025A;
L_0259:
if (OPNUM != -2) goto L_025B;
DUMPBYTE(N & 255);
DUMPBYTE((unsigned int)N >> 8 & 255);
goto L_025A;
L_025B:
DUMPWORD(N);
L_025A:
if (!(MATCH(44))) goto L_025C;
goto L_0257;
L_025C:
if (/*indirectthrough*/ *CA & 3 == 0) goto L_025D;
L_025E:
DUMPBYTE(0);
if (/*indirectthrough*/ *CA & 3 == 0) goto L_025F;
goto L_025E;
L_025F:
WARN(0, _imp_str_literal("zero padding bytes added to ensure word alignment"));
L_025D:
goto U_1008;
U_1007:
DUMPWORD(OPVALUE);
U_1008:
if (MATCH(59)) goto L_0260;
MCERROR(_imp_str_literal("Too many operands"));
L_0260:
if (SYMP == OPLENGTH) goto L_0261;
MCERROR(_imp_str_literal("spurious operation qualifiers"));
L_0261:
L_0262:
} /* MACHINECODE */
int USES(int R, struct STACKFM *V) {
int N;
N = 0;
L_0262:
if (/*%A*/ /*addressof*/ &V == NIL) goto L_0263;
if (V != R) goto L_0264;
N = N + 1;
L_0264:
if (/*%A*/ /*addressof*/ &V == NIL) goto L_0265;
N = N + USES(R, /*%A*/ /*addressof*/ &V);
L_0265:
if (/*%A*/ /*addressof*/ &V == NIL) goto L_0266;
N = N + USES(R, /*%A*/ /*addressof*/ &V);
L_0266:
V = /*%A*/ /*addressof*/ &V;
goto L_0000;
L_0263:
return N;
} /* USES */
void STOREREALCONSTANT(struct STACKFM * W) {
int N;
if (W != 0) goto L_0267;
if (W != 0) goto L_0267;
if (/*%A*/ /*addressof*/ &W != NIL) goto L_0267;
if (/*%A*/ /*addressof*/ &W != NIL) goto L_0267;
CONSTANTBASE = CONSTANTBASE + 3 & (~3);
SELECTCONSTANTAREA();
N = /*indirectthrough*/ *CA;
DUMPWORD(W);
DUMPWORD(W);
SELECTCODEAREA();
W = N;
W = 512;
W = 1;
L_0267:
} /* STOREREALCONSTANT */
int POTENTIALLYUNASSIGNED(struct STACKFM * V) {
if (UNASSIGNED != 0) goto L_0268;
return 0 /*FALSE*/;
L_0268:
if (V & 128 == 0) goto L_0269;
return 0 /*FALSE*/;
L_0269:
if (V != 1) goto L_026A;
if (V & 1048576 != 0) goto L_026B;
L_026A:
return 0 /*FALSE*/;
L_026B:
return 1 /*TRUE*/;
} /* POTENTIALLYUNASSIGNED */
void SIMPLE(struct STACKFM * FROM, struct STACKFM * TO) {
struct STACKFM *W;
W = COPY(/*%A*/ /*addressof*/ &FROM);
MOVE(W, /*%A*/ /*addressof*/ &TO);
RELEASEANDDROP(W);
} /* SIMPLE */
void LOADADDRESS(struct STACKFM * V, int R) {
AMAP(/*%A*/ /*addressof*/ &V);
LOAD(/*%A*/ /*addressof*/ &V, R);
} /* LOADADDRESS */
void PUSH(struct STACKFM * V) {
struct STACKFM S;
S = 0;
S.TYPE = 1;
S.FORM = 3;
S.BASE = 13;
STORE(/*%A*/ /*addressof*/ &V, /*%A*/ /*addressof*/ &S);
} /* PUSH */
void PUSHLITERAL(int LIT) {
struct STACKFM *L;
L = LITERAL(LIT);
PUSH(L);
RELEASEANDDROP(L);
} /* PUSHLITERAL */
void PUSHADDRESS(struct STACKFM * V) {
AMAP(V);
PUSH(V);
} /* PUSHADDRESS */
void POPSTACK(int BYTES) {
if (/*indirectthrough*/ *BYTES != 0) goto L_026C;
return;
L_026C:
if (/*indirectthrough*/ *BYTES & 3 == 0) goto L_026D;
FAIL(_imp_str_literal("stack alignment"));
L_026D:
PLANT1(8388608, 13, 13, ROT(/*indirectthrough*/ *(unsigned int)/*indirectthrough*/ *BYTES >> 2, 16 - 1));
} /* POPSTACK */
void LOADUPADDRESS(struct STACKFM * V) {
AMAP(V);
LOAD(V, 17);
} /* LOADUPADDRESS */
void LOADUP(struct STACKFM * FROM) {
int OPER;
struct STACKFM *W;
struct STACKFM *LHS;
if (FROM->TYPE != 13) goto L_026E;
if (FROM->OPER != 0) goto L_026F;
FAIL(_imp_str_literal("Bad set"));
L_026F:
OPER = FROM->OPER;
W = /*%A*/ /*addressof*/ &FROM->LINK;
FROM->OPER = 0;
FROM->LINK = NIL;
if (FROM->FLAGS & 262144 != 0) goto L_0270;
LHS = CLAIMWORKAREA(32, 13);
LHS->FLAGS = LHS->FLAGS | 262144;
SETASSIGN(FROM, LHS);
RELEASE(FROM->BASE);
ZAPINDEXANDRECORD(FROM);
FROM->DATA = LHS->DATA;
DROP(LHS);
L_0270:
LHS = COPY(FROM);
FROM->OPER = OPER;
FROM->LINK = W;
SETASSIGN(FROM, LHS);
RELEASEANDDROP(LHS);
goto L_0271;
L_026E:
if (!(FLOATING(FROM))) goto L_0272;
LOAD(FROM, 26);
goto L_0271;
L_0272:
LOAD(FROM, 17);
L_0271:
} /* LOADUP */
void LOADPROTECTED(struct STACKFM * V) {
if (DIAG & 8 == 0) goto L_0273;
MONITOR(V, _imp_str_literal("->Load protected"));
L_0273:
LOADUP(V);
if (ACTIVITY[V->BASE] == 1) goto L_0274;
if (V->TYPE < 6) goto L_0275;
LOAD(V, FPR());
goto L_0276;
L_0275:
LOAD(V, GPR());
L_0276:
L_0274:
if (DIAG & 8 == 0) goto L_0277;
MONITOR(V, _imp_str_literal("<-Load protected"));
L_0277:
} /* LOADPROTECTED */
void CONSTANTOPERATION(int OP, int *L, struct STACKFM *R) {
static const void *COP[29] = {NULL};
int N;
N = R->DISP;
DROP(R);
goto *COP[OP]; /*TO DO*/
case_COP_4:;
/*indirectthrough*/ *L = /*indirectthrough*/ */*indirectthrough*/ *L + N;
goto U_1009;
case_COP_5:;
/*indirectthrough*/ *L = /*indirectthrough*/ */*indirectthrough*/ *L - N;
goto U_1009;
case_COP_18:;
case_COP_6:;
/*indirectthrough*/ *L = /*indirectthrough*/ */*indirectthrough*/ *L * N;
goto U_1009;
case_COP_9:;
/*indirectthrough*/ *L = /*indirectthrough*/ *L & N;
goto U_1009;
case_COP_12:;
/*indirectthrough*/ *L = /*indirectthrough*/ *L & (~N);
goto U_1009;
case_COP_10:;
/*indirectthrough*/ *L = /*indirectthrough*/ */*indirectthrough*/ *L | N;
goto U_1009;
case_COP_11:;
/*indirectthrough*/ *L = /*indirectthrough*/ */*indirectthrough*/ *L ^ N;
goto U_1009;
case_COP_14:;
/*indirectthrough*/ *L = /*indirectthrough*/ */*indirectthrough*/ *L << N;
goto U_1009;
case_COP_15:;
/*indirectthrough*/ *L = /*indirectthrough*/ *(unsigned int)/*indirectthrough*/ *L >> N;
goto U_1009;
case_COP_8:;
if (N >= 0) goto L_0279;
FAIL(_imp_str_literal("Exp"));
L_0279:
/*indirectthrough*/ *L = /*indirectthrough*/ *_imp_IEXP(/*indirectthrough*/ *L, N);
goto U_1009;
case_COP_17:;
if (N > 0) goto L_027A;
FAIL(_imp_str_literal("Illegal MOD"));
L_027A:
if (/*indirectthrough*/ *L >= 0) goto L_027B;
/*indirectthrough*/ *L = N - _imp_REM(/*indirectthrough*/ *-/*indirectthrough*/ *L, N);
if (/*indirectthrough*/ *L != N) goto L_027C;
/*indirectthrough*/ *L = 0;
L_027C:
goto U_1009;
L_027B:
case_COP_16:;
if (N != 0) goto L_027D;
FAIL(_imp_str_literal("Zero divide"));
L_027D:
/*indirectthrough*/ *L = _imp_REM(/*indirectthrough*/ *L, N);
goto U_1009;
case_COP_7:;
if (N != 0) goto L_027E;
FAIL(_imp_str_literal("Zero divide"));
L_027E:
/*indirectthrough*/ *L = /*indirectthrough*/ *((long)/*indirectthrough*/ *L / (long)N);
goto U_1009;
COP_default:;
FAIL(_imp_str_literal("C-op"));
U_1009:
} /* CONSTANTOPERATION */
void OPERATE(int NEWOPER, struct STACKFM *LHS, struct STACKFM *RHS) {
int OP;
int RCONST;
int KEY;
int LFLAGS;
int RFLAGS;
int N;
int FN;
struct STACKFM *W;
void SWOP(void) {
struct STACKFM TEMP;
TEMP.DATA = LHS->DATA;
LHS->DATA = RHS->DATA;
RHS->DATA = TEMP.DATA;
} /* SWOP */
void ZAP(void) {
DROP(W);
DROP(RHS);
LHS->LINK = NIL;
LHS->OPER = 0;
RHS = LITERAL(0);
SWOP();
RELEASEANDDROP(RHS);
} /* ZAP */
void REDUCECONSTANT(void) {
int OP;
int N;
int F;
void FIX(int OP) {
LHS->OPER = OP;
DROP(/*%A*/ /*addressof*/ &LHS->LINK);
LHS->LINK = NIL;
} /* FIX */
OP = LHS->OPER;
F = OPERFLAGS[OP];
N = LHS->LINK;
if (F & 512 == 0) goto L_027F;
if (NULLVALUE[OP] != N) goto L_027F;
FIX(0);
goto L_0280;
L_027F:
if (OP != 6) goto L_0281;
if (N != 0) goto L_0282;
FIX(0);
RELEASE(LHS->BASE);
LHS->FORM = 0;
LHS->BASE = 0;
LHS->DISP = 0;
LHS->AREA = 0;
if (/*%A*/ /*addressof*/ &LHS->INDEX == NIL) goto L_0283;
RELEASEANDDROP(/*%A*/ /*addressof*/ &LHS->INDEX);
L_0283:
if (/*%A*/ /*addressof*/ &LHS->RECORD == NIL) goto L_0284;
RELEASEANDDROP(/*%A*/ /*addressof*/ &LHS->RECORD);
L_0284:
LHS->RECORD = NIL;
LHS->INDEX = NIL;
goto L_0285;
L_0282:
if (N != -1) goto L_0286;
FIX(2);
L_0286:
L_0285:
goto L_0280;
L_0281:
if (OP != 4) goto L_0287;
if (LHS->FORM != 0) goto L_0288;
FIX(0);
LHS->DISP = LHS->DISP + N;
L_0288:
goto L_0280;
L_0287:
if (OP != 9) goto L_0289;
if (LHS->FORM != 1) goto L_0289;
if (LHS->AREA != 0) goto L_0289;
if (LHS->TYPE != 4) goto L_028A;
N = N & 255;
L_028A:
if (UNASSIGNED == 0) goto L_028B;
if (LHS->FLAGS & 1048576 == 0) goto L_028B;
if (LHS->FLAGS & 128 == 0) goto L_028C;
L_028B:
if (N & -256 != 0) goto L_028D;
LHS->TYPE = 4;
if (N != 255) goto L_028E;
FIX(0);
L_028E:
goto L_028F;
L_028D:
if (N & -65281 != 0) goto L_0290;
if (LHS->TYPE != 2) goto L_0290;
LHS->TYPE = 4;
LHS->DISP = LHS->DISP + 1;
N = (unsigned int)N >> 8;
LHS->LINK = N;
if (N != 255) goto L_0291;
FIX(0);
L_0291:
OPERATE(14, LHS, LITERAL(8));
L_0290:
L_028F:
L_028C:
goto L_0280;
L_0289:
if (OP != 11) goto L_0292;
if (N != -1) goto L_0292;
FIX(1);
L_0292:
L_0280:
} /* REDUCECONSTANT */
int FIELD(int AND, int SHIFT, int ANDFIRST) {
int R;
R = 0;
if (ANDFIRST == 0) goto L_0293;
AND = (unsigned int)AND >> SHIFT << SHIFT;
if (AND != 0) goto L_0294;
return -1;
L_0294:
L_0295:
if (AND & 1 != 0) goto L_0296;
AND = (unsigned int)AND >> 1;
R = R + 1;
goto L_0295;
L_0296:
if (SHIFT >= R) goto L_0297;
return 0;
L_0297:
goto L_0298;
L_0293:
AND = (unsigned int)AND << SHIFT >> SHIFT;
if (AND != 0) goto L_0299;
return -1;
L_0299:
L_0298:
N = POWER(AND + 1);
if (N < 0) goto L_029A;
if (N <= 8) goto L_029B;
L_029A:
return 0;
L_029B:
return (N << 16) + SHIFT;
} /* FIELD */
if (DIAG & 16 == 0) goto L_029C;
MONITOR(LHS, _imp_str_literal("O-Lhs"));
MONITOR(RHS, _imp_str_literal("O-Rhs"));
L_029C:
RFLAGS = OPERFLAGS[NEWOPER];
if (RFLAGS & 32 == 0) goto L_029D;
if (!(ICONST(LHS))) goto L_029E;
if (NEWOPER != 2) goto L_029F;
LHS->DISP = -LHS->DISP;
goto L_02A0;
L_029F:
if (NEWOPER != 1) goto L_02A1;
LHS->DISP = (~LHS->DISP);
goto L_02A0;
L_02A1:
if (NEWOPER != 3) goto L_02A2;
LHS->DISP = _imp_MOD(LHS->DISP);
goto L_02A0;
L_02A2:
FAIL(_imp_str_literal("Operator"));
L_02A0:
goto L_02A3;
L_029E:
if (!(FLOATING(LHS))) goto L_02A4;
NEWOPER = NEWOPER + 21;
L_02A4:
if (LHS->OPER == 0) goto L_02A5;
if (LHS->OPER != NEWOPER) goto L_02A6;
if (NEWOPER == 3) goto L_02A7;
if (NEWOPER == 24) goto L_02A7;
LHS->OPER = 0;
L_02A7:
goto U_100A;
L_02A6:
if (NEWOPER == 2) goto L_02A8;
if (NEWOPER != 1) goto L_02A9;
L_02A8:
if (LHS->OPER == 2) goto L_02AA;
if (LHS->OPER != 1) goto L_02AB;
L_02AA:
LHS->OPER = 0;
if (NEWOPER != 2) goto L_02AC;
NEWOPER = 4;
goto L_02AD;
L_02AC:
NEWOPER = 5;
L_02AD:
OPERATE(NEWOPER, LHS, LITERAL(1));
goto U_100A;
L_02AB:
L_02A9:
if (NEWOPER != 2) goto L_02AE;
if (LHS->OPER != 6) goto L_02AE;
if (!(ICONST(/*%A*/ /*addressof*/ &LHS->LINK))) goto L_02AE;
if (LHS->LINK == -2147483648) goto L_02AF;
LHS->LINK = -LHS->LINK;
goto U_100A;
L_02AF:
L_02AE:
LOADUP(LHS);
L_02A5:
LHS->OPER = NEWOPER;
LHS->LINK = NIL;
L_02A3:
goto U_100A;
L_029D:
if (NEWOPER != 22) goto L_02B0;
if (RHS->BIAS != 1) goto L_02B1;
DROP(RHS);
return;
L_02B1:
if (LHS->BIAS != 1) goto L_02B2;
if (/*%A*/ /*addressof*/ &LHS->LINK == NIL) goto L_02B3;
FAIL(_imp_str_literal("inconsistent concatenation"));
L_02B3:
LHS->DATA = RHS->DATA;
DROP(RHS);
return;
L_02B2:
if (LHS->OPER == 0) goto L_02B4;
if (LHS->OPER == 22) goto L_02B4;
LOADUP(LHS);
L_02B4:
if (RHS->OPER == 0) goto L_02B5;
LOADUP(RHS);
L_02B5:
L_02B6:
if (LHS->OPER == 0) goto L_02B7;
LHS = /*%A*/ /*addressof*/ &LHS->LINK;
goto L_02B6;
L_02B7:
LHS->OPER = 22;
LHS->LINK = RHS;
goto U_100A;
L_02B0:
if (RFLAGS & 1 == 0) goto L_02B8;
if (!(ICONST(LHS))) goto L_02B8;
SWOP();
L_02B8:
if (RHS->OPER == 0) goto L_02B9;
OP = RHS->OPER;
if (OP != 2) goto L_02BA;
if (NEWOPER == 4) goto L_02BB;
if (NEWOPER != 5) goto L_02BA;
L_02BB:
NEWOPER = 4 + 5 - NEWOPER;
RFLAGS = OPERFLAGS[NEWOPER];
RHS->OPER = 0;
goto L_02BC;
L_02BA:
if (OP != 1) goto L_02BD;
if (NEWOPER != 9) goto L_02BD;
RHS->OPER = 0;
NEWOPER = 12;
goto L_02BC;
L_02BD:
if (OP == 14) goto L_02BE;
if (OP != 15) goto L_02BF;
L_02BE:
if (OPERFLAGS[NEWOPER] & 4 == 0) goto L_02BF;
if (LHS->TYPE >= 6) goto L_02BF;
if (LHS->OPER >= 23) goto L_02BF;
W = /*%A*/ /*addressof*/ &RHS->LINK;
RHS->LINK = NIL;
RHS->OPER = 0;
LOADUP(LHS);
LOADUP(RHS);
if (!(ICONST(W))) goto L_02C0;
if (OP != 14) goto L_02C1;
N = ISHIFT(RHS->BASE, W->DISP, 0);
goto L_02C2;
L_02C1:
N = ISHIFT(RHS->BASE, W->DISP, 32);
L_02C2:
goto L_02C3;
L_02C0:
LOADUP(W);
if (OP != 14) goto L_02C4;
N = RSHIFT(RHS->BASE, W->BASE, 144);
goto L_02C5;
L_02C4:
N = RSHIFT(RHS->BASE, W->BASE, 176);
L_02C5:
L_02C3:
PLANT1(EASYOP[NEWOPER], LHS->BASE, LHS->BASE, N);
RELEASEANDDROPPAIR(RHS, W);
return;
L_02BF:
LOADUP(RHS);
L_02BC:
L_02B9:
if (!(ICONST(RHS))) goto L_02C6;
RCONST = 1;
if (NEWOPER != 5) goto L_02C7;
if (RHS->DISP == -2147483648) goto L_02C8;
RHS->DISP = -RHS->DISP;
NEWOPER = 4;
RFLAGS = OPERFLAGS[4];
L_02C8:
L_02C7:
if (OPERFLAGS[NEWOPER] & 512 == 0) goto L_02C9;
if (NULLVALUE[NEWOPER] != RHS->DISP) goto L_02C9;
DROP(RHS);
return;
L_02C9:
goto L_02CA;
L_02C6:
RCONST = 0;
L_02CA:
if (LHS->OPER == 0) goto L_02CB;
OP = LHS->OPER;
LFLAGS = OPERFLAGS[OP];
W = /*%A*/ /*addressof*/ &LHS->LINK;
if (OP != 2) goto L_02CC;
if (NEWOPER != 6) goto L_02CC;
LHS->OPER = 0;
OPERATE(6, LHS, RHS);
OPERATE(2, LHS, NIL);
return;
L_02CC:
if (LFLAGS & 32 != 0) goto L_02CD;
if (!(ICONST(W))) goto L_02CD;
if (RCONST == 0) goto L_02CE;
if (NEWOPER >= 23) goto L_02CE;
KEY = (LFLAGS | RFLAGS) & 384;
if (KEY == 0) goto L_02CF;
if (KEY != 256) goto L_02D0;
if (NEWOPER != OP) goto L_02D0;
L_02CF:
if (RHS->BASE == 0) goto L_02D1;
if (NEWOPER != 4) goto L_02D2;
L_02D1:
CONSTANTOPERATION(NEWOPER, /*%A*/ /*addressof*/ &W->DISP, RHS);
if (RHS->BASE != 0) goto L_02D3;
REDUCECONSTANT();
L_02D3:
goto U_100A;
L_02D2:
L_02D0:
if (OP != 14) goto L_02D4;
if (NEWOPER != 9) goto L_02D4;
if (-31 > W->DISP) goto L_02D4;
if (W->DISP > 0) goto L_02D4;
N = FIELD(RHS->DISP, -W->DISP, 0);
if (N == 0) goto L_02D5;
if (N != -1) goto L_02D6;
ZAP();
goto U_100A;
L_02D6:
W->DISP = N;
LHS->OPER = 21;
DROP(RHS);
goto U_100A;
L_02D5:
L_02D4:
if (OP != 9) goto L_02D7;
if (NEWOPER != 15) goto L_02D7;
if (0 > RHS->DISP) goto L_02D7;
if (RHS->DISP > 31) goto L_02D7;
N = FIELD(W->DISP, RHS->DISP, 1);
if (N == 0) goto L_02D8;
if (N != -1) goto L_02D9;
ZAP();
goto U_100A;
L_02D9:
W->DISP = N;
LHS->OPER = 21;
DROP(RHS);
goto U_100A;
L_02D8:
L_02D7:
L_02CE:
L_02CD:
if (OP == 14) goto L_02DA;
if (OP != 15) goto L_02DB;
L_02DA:
if (OPERFLAGS[NEWOPER] & 4 == 0) goto L_02DB;
if (NEWOPER == 12) goto L_02DB;
if (RHS->TYPE >= 6) goto L_02DB;
LHS->LINK = NIL;
LHS->OPER = 0;
LOADUP(LHS);
LOADUP(RHS);
if (!(ICONST(W))) goto L_02DC;
if (OP != 14) goto L_02DD;
N = ISHIFT(LHS->BASE, W->DISP, 0);
goto L_02DE;
L_02DD:
N = ISHIFT(LHS->BASE, W->DISP, 32);
L_02DE:
goto L_02DF;
L_02DC:
LOADUP(W);
if (OP != 14) goto L_02E0;
N = RSHIFT(LHS->BASE, W->BASE, 144);
goto L_02E1;
L_02E0:
N = RSHIFT(LHS->BASE, W->BASE, 176);
L_02E1:
L_02DF:
FN = EASYOP[NEWOPER];
if (NEWOPER != 5) goto L_02E2;
FN = 6291456;
L_02E2:
PLANT1(FN, RHS->BASE, LHS->BASE, N);
RELEASEANDDROPPAIR(RHS, W);
return;
L_02DB:
LOADUP(LHS);
L_02CB:
if (!(ICONST(LHS))) goto L_02E3;
if (RCONST == 0) goto L_02E3;
if (NEWOPER >= 23) goto L_02E3;
CONSTANTOPERATION(NEWOPER, /*%A*/ /*addressof*/ &LHS->DISP, RHS);
goto U_100A;
L_02E3:
if (LHS->TYPE >= 6) goto L_02E4;
if (RHS->TYPE < 6) goto L_02E5;
L_02E4:
if (NEWOPER >= 23) goto L_02E6;
NEWOPER = NEWOPER + 21;
L_02E6:
if (LHS->TYPE != 13) goto L_02E7;
if (LHS->FLAGS != 16384) goto L_02E8;
if (NEWOPER != 25) goto L_02E9;
SWOP();
L_02E9:
RHS->TYPE = 0;
goto L_02EA;
L_02E8:
if (RHS->FLAGS != 16384) goto L_02EB;
if (NEWOPER != 27) goto L_02EC;
SWOP();
L_02EC:
RHS->TYPE = 0;
L_02EB:
L_02EA:
LHS->OPER = NEWOPER;
LHS->LINK = RHS;
if (RHS->TYPE != 0) goto L_02ED;
LHS->OPER = 0;
LHS->LINK = NIL;
DROPMEMBERS(RHS);
RELEASEANDDROP(RHS);
L_02ED:
goto U_100A;
L_02E7:
L_02E5:
if (RFLAGS & 1 == 0) goto L_02EE;
if (!(INREG(RHS))) goto L_02EE;
SWOP();
RCONST = 0;
if (!(ICONST(RHS))) goto L_02EF;
RCONST = 1;
L_02EF:
L_02EE:
if (NEWOPER != 5) goto L_02F0;
if (LHS->FORM != 0) goto L_02F0;
if (0 != RHS->FORM) goto L_02F0;
if (LHS->BASE != RHS->BASE) goto L_02F1;
if (LHS->AREA != RHS->AREA) goto L_02F1;
if (!(SAME(/*%A*/ /*addressof*/ &LHS->INDEX, /*%A*/ /*addressof*/ &RHS->INDEX))) goto L_02F2;
if (!(SAME(/*%A*/ /*addressof*/ &LHS->RECORD, /*%A*/ /*addressof*/ &RHS->RECORD))) goto L_02F2;
if (LHS->XSIZE != RHS->XSIZE) goto L_02F2;
LHS->DISP = LHS->DISP - RHS->DISP;
RELEASEANDDROP(RHS);
if (/*%A*/ /*addressof*/ &LHS->INDEX == NIL) goto L_02F3;
RELEASEANDDROP(/*%A*/ /*addressof*/ &LHS->INDEX);
L_02F3:
if (/*%A*/ /*addressof*/ &LHS->RECORD == NIL) goto L_02F4;
RELEASEANDDROP(/*%A*/ /*addressof*/ &LHS->RECORD);
L_02F4:
LHS->BASE = 0;
LHS->XSIZE = 0;
goto U_100A;
L_02F2:
L_02F1:
L_02F0:
LHS->OPER = NEWOPER;
LHS->LINK = RHS;
if (RCONST == 0) goto L_02F5;
REDUCECONSTANT();
L_02F5:
U_100A:
if (DIAG & 16 == 0) goto L_02F6;
MONITOR(LHS, _imp_str_literal("<-Operate"));
L_02F6:
} /* OPERATE */
void AOP(void) {
int TYPE;
int FORMAT;
int SIZE;
struct STACKFM *X;
X = STACK;
STACK = /*%A*/ /*addressof*/ &X->STACK;
SIZE = ITEMSIZE(STACK->FORMAT);
if (/*%A*/ /*addressof*/ &STACK->INDEX != NIL) goto L_02F7;
STACK->INDEX = X;
STACK->XSIZE = SIZE;
goto L_02F8;
L_02F7:
if (STACK->XSIZE != SIZE) goto L_02F9;
OPERATE(4, /*%A*/ /*addressof*/ &STACK->INDEX, X);
goto L_02F8;
L_02F9:
TYPE = STACK->TYPE;
FORMAT = STACK->FORMAT;
AMAP(STACK);
OPERATE(6, X, LITERAL(SIZE));
OPERATE(4, STACK, X);
VMAP(STACK, TYPE);
STACK->FORMAT = FORMAT;
L_02F8:
} /* AOP */
void OPERATION(int OPER) {
struct STACKFM *V;
V = STACK;
STACK = /*%A*/ /*addressof*/ &STACK->STACK;
OPERATE(OPER, STACK, V);
} /* OPERATION */
void REPLACE(struct STACKFM * OLD, struct STACKFM * NEW) {
ZAPINDEXANDRECORD(OLD);
RELEASE(OLD->BASE);
OLD->BASE = NEW->BASE;
OLD->DISP = NEW->DISP;
OLD->EXTRA = NEW->EXTRA;
OLD->TYPE = NEW->TYPE;
OLD->FORM = NEW->FORM;
OLD->FORMAT = NEW->FORMAT;
OLD->AREA = NEW->AREA;
OLD->OPER = 0;
OLD->LINK = NIL;
DROP(NEW);
} /* REPLACE */
int MEMORABLE(struct STACKFM * V, struct KNOWFM * K) {
int OP;
OP = 0;
int SCALE;
SCALE = 0;
if (V->OPER == 0) goto L_02FA;
if (/*%A*/ /*addressof*/ &V->LINK == NIL) goto L_02FB;
if (ICONST(/*%A*/ /*addressof*/ &V->LINK)) goto L_02FC;
L_02FB:
return 0 /*FALSE*/;
L_02FC:
OP = V->OPER;
SCALE = V->LINK;
L_02FA:
if (/*%A*/ /*addressof*/ &V->INDEX != NIL) goto L_02FD;
if (/*%A*/ /*addressof*/ &V->RECORD != NIL) goto L_02FD;
if (V->FORM < 2) goto L_02FE;
L_02FD:
return 0 /*FALSE*/;
L_02FE:
K = (V->TYPE << 4) + V->FORM;
K = V->BASE;
K = V->DISP;
K = V->EXTRA;
K = V->AREA;
K = SCALE;
K = OP;
if (!(ICONST(V))) goto L_02FF;
K = (1 << 4) + 0;
L_02FF:
return 1 /*TRUE*/;
} /* MEMORABLE */
void OPTIMISE(struct STACKFM * V, int SWANTED) {
struct KNOWFM *P;
struct KNOWFM M;
struct STACKFM *W;
int OP;
P = KNOWING;
if (P != NIL) goto L_0300;
return;
L_0300:
if (V->OPER == 0) goto L_0301;
OP = V->OPER;
V->OPER = 0;
W = /*%A*/ /*addressof*/ &V->LINK;
V->LINK = NIL;
OPTIMISE(V, 1);
if (W == NIL) goto L_0302;
OPTIMISE(W, 1);
L_0302:
V->OPER = OP;
V->LINK = W;
L_0301:
if (/*%A*/ /*addressof*/ &V->RECORD == NIL) goto L_0303;
OPTIMISE(/*%A*/ /*addressof*/ &V->RECORD, 1);
if (V->RECORD != 0) goto L_0304;
SIMPLIFY(V);
P = KNOWING;
if (P != NIL) goto L_0305;
return;
L_0305:
L_0304:
L_0303:
if (MEMORABLE(V, /*%A*/ /*addressof*/ &M)) goto L_0306;
return;
L_0306:
if (DIAG & 128 == 0) goto L_0307;
MONITOR(V, _imp_str_literal("Opt"));
L_0307:
void SET(int FORM) {
if (V->OPER == 0) goto L_0308;
RELEASEANDDROP(/*%A*/ /*addressof*/ &V->LINK);
V->OPER = 0;
V->LINK = NIL;
L_0308:
if (FORM != 0) goto L_0309;
if (V->TYPE > 5) goto L_0309;
V->TYPE = 1;
L_0309:
V->FORM = FORM;
RELEASE(V->BASE);
V->AREA = 0;
V->DISP = 0;
V->BASE = P->REG;
if (P->REG != PENDINGAUTO) goto L_030A;
PENDINGAUTO = 0;
L_030A:
CLAIM(V->BASE);
if (DIAG & 128 == 0) goto L_030B;
MONITOR(V, _imp_str_literal("Opt->"));
L_030B:
} /* SET */
L_030C:
if (P->DISP != M.DISP) goto L_030D;
if (P->AREA != M.AREA) goto L_030D;
if (P->EXTRA != M.EXTRA) goto L_030D;
if (P->OPER != M.OPER) goto L_030D;
if (P->BASE != M.BASE) goto L_030D;
if (P->OPND != M.OPND) goto L_030D;
if (P->FTYPE != M.FTYPE) goto L_030E;
if (SWANTED == 0) goto L_030E;
SET(0);
return;
L_030E:
if (M.OPER != 0) goto L_030F;
if (M.FTYPE & 15 == 0) goto L_030F;
if (P->FTYPE != (1 << 4) + 0) goto L_0310;
SET(V->FORM);
if (SWANTED == 0) goto L_0311;
OPTIMISE(V, 1);
L_0311:
return;
L_0310:
L_030F:
L_030D:
P = /*%A*/ /*addressof*/ &P->LINK;
if (P == NIL) goto L_0312;
goto L_030C;
L_0312:
} /* OPTIMISE */
struct KNOWFM *NEWK(void) {
struct KNOWFM *P;
P = KASL;
if (P != NIL) goto L_0313;
P = _imp_NEW(KNOWFMTYPE);
/*indirectthrough*/ *P = 0;
goto L_0314;
L_0313:
KASL = /*%A*/ /*addressof*/ &P->LINK;
L_0314:
return P;
} /* NEWK */
void KINC(struct KNOWFM * K) {
KTIMES[K->REG] = KTIMES[K->REG] + 1;
if (K->BASE & 128 != 0) goto L_0315;
KTIMES[K->BASE] = KTIMES[K->BASE] + 1;
L_0315:
} /* KINC */
void KDEC(struct KNOWFM * K) {
KTIMES[K.REG] = KTIMES[K.REG] - 1;
if (K.BASE & 128 != 0) goto L_0316;
KTIMES[K.BASE] = KTIMES[K.BASE] - 1;
L_0316:
} /* KDEC */
void FORGET(int REGISTER) {
int *N;
struct KNOWFM *K;
struct KNOWFM *R;
if (1 > REGISTER) goto L_0317;
if (REGISTER <= 25) goto L_0318;
L_0317:
return;
L_0318:
if (PENDINGAUTO != REGISTER) goto L_0319;
PENDINGAUTO = 0;
L_0319:
N = /*%A*/ /*addressof*/ &KTIMES[REGISTER];
USED[REGISTER] = 0;
if (/*indirectthrough*/ *N != 0) goto L_031A;
return;
L_031A:
K = KNOWING;
KNOWING = NIL;
L_031B:
if (K == NIL) goto L_031C;
R = K;
K = /*%A*/ /*addressof*/ &K->LINK;
if (R->REG == REGISTER) goto L_031D;
if (R->BASE != REGISTER) goto L_031E;
L_031D:
R->LINK = KASL;
KASL = R;
KDEC(R);
if (DIAG & 128 == 0) goto L_031F;
MONREGID(R->REG, _imp_str_literal("Forgotten"));
L_031F:
goto L_0320;
L_031E:
R->LINK = KNOWING;
KNOWING = R;
L_0320:
goto L_031B;
L_031C:
if (/*indirectthrough*/ *N == 0) goto L_0321;
FAIL(_imp_str_literal("Register still known"));
L_0321:
} /* FORGET */
void FORGETEVERYTHING(void) {
struct KNOWFM *K;
PENDINGAUTO = 0;
K = KNOWING;
if (K == NIL) goto L_0322;
L_0323:
USED[K->REG] = 0;
if (K->BASE & 128 != 0) goto L_0324;
USED[K->BASE] = 0;
L_0324:
KDEC(K);
if (/*%A*/ /*addressof*/ &K->LINK != NIL) goto L_0325;
goto L_0326;
L_0325:
K = /*%A*/ /*addressof*/ &K->LINK;
goto L_0323;
L_0326:
K->LINK = KASL;
KASL = KNOWING;
KNOWING = NIL;
L_0322:
} /* FORGETEVERYTHING */
void INHERIT(int NEW, int OLD) {
struct KNOWFM *P;
struct KNOWFM *K;
struct KNOWFM *X;
if (/*indirectthrough*/ *NEW != /*indirectthrough*/ *OLD) goto L_0327;
return;
L_0327:
USED[/*indirectthrough*/ *NEW] = USEDTIME;
P = KNOWING;
L_0328:
if (P == NIL) goto L_0329;
K = P;
P = /*%A*/ /*addressof*/ &K->LINK;
if (K->REG != /*indirectthrough*/ *OLD) goto L_032A;
if (DIAG & 128 == 0) goto L_032B;
MONREGID(/*indirectthrough*/ *OLD, _imp_str_literal("inherited"));
L_032B:
X = NEWK();
if (X != NIL) goto L_032C;
return;
L_032C:
/*indirectthrough*/ *X = /*indirectthrough*/ *K;
X->REG = /*indirectthrough*/ *NEW;
X->LINK = KNOWING;
KNOWING = X;
KINC(X);
L_032A:
goto L_0328;
L_0329:
} /* INHERIT */
void REMEMBER(int REGISTER, struct STACKFM *V) {
struct KNOWFM *K;
struct KNOWFM M;
if (1 > /*indirectthrough*/ *REGISTER) goto L_032D;
if (/*indirectthrough*/ *REGISTER > 25) goto L_032D;
if (/*indirectthrough*/ *REGISTER != 17) goto L_032E;
L_032D:
return;
L_032E:
USED[/*indirectthrough*/ *REGISTER] = USEDTIME;
if (!(INREG(V))) goto L_032F;
INHERIT(/*indirectthrough*/ *REGISTER, V->OPER);
return;
L_032F:
if (/*indirectthrough*/ *REGISTER != V->OPER) goto L_0330;
return;
L_0330:
if (!(MEMORABLE(V, /*%A*/ /*addressof*/ &M))) goto L_0331;
K = NEWK();
if (K != NIL) goto L_0332;
return;
L_0332:
/*indirectthrough*/ *K = M;
K->REG = /*indirectthrough*/ *REGISTER;
K->LINK = KNOWING;
KNOWING = K;
KINC(K);
if (DIAG & 128 == 0) goto L_0333;
MONITOR(V, _imp_join((_imp_string)(_imp_str_literal("Remember ")),
(_imp_string)(REGID[/*indirectthrough*/ *REGISTER])));
L_0333:
L_0331:
} /* REMEMBER */
void REMEMBERZERO(int REGISTER) {
struct STACKFM *ZERO;
ZERO = LITERAL(0);
FORGET(/*indirectthrough*/ *REGISTER);
REMEMBER(/*indirectthrough*/ *REGISTER, ZERO);
DROP(ZERO);
} /* REMEMBERZERO */
void FORGETDESTINATION(struct STACKFM * V) {
int LOW;
int HIGH;
int BASE;
BASE = V;
int UNSAFE;
UNSAFE = 0;
int ALTER;
struct KNOWFM *P;
struct KNOWFM *K;
if (DIAG & 128 == 0) goto L_0334;
MONITOR(V, _imp_str_literal("Forget Dest"));
L_0334:
if (!(INREG(V))) goto L_0335;
FORGET(V);
return;
L_0335:
LOW = V;
HIGH = LOW + ITEMSIZE(V) - 1;
if (HIGH >= LOW) goto L_0336;
HIGH = LOW + 3;
L_0336:
P = KNOWING;
KNOWING = NIL;
if (INTERFACE->OPTIONS & 1 != 0) goto L_0337;
if (V >= 128) goto L_0338;
if (ACTIVITY[V] < 0) goto L_0338;
UNSAFE = 1;
goto L_0339;
L_0338:
if (/*%A*/ /*addressof*/ &V == NIL) goto L_033A;
UNSAFE = 1;
L_033A:
L_0339:
if (DIAG & 128 == 0) goto L_033B;
MONITORN(UNSAFE, _imp_str_literal("Unsafe"));
L_033B:
L_0337:
L_033C:
if (P == NIL) goto L_033D;
K = P;
P = /*%A*/ /*addressof*/ &P->LINK;
ALTER = 0;
if (K->BASE >= 128) goto L_033E;
if (ACTIVITY[K->BASE] < 0) goto L_033E;
ALTER = UNSAFE;
L_033E:
if (K->FTYPE & 15 == 0) goto L_033F;
if (K->BASE != BASE) goto L_0340;
if (LOW > K->DISP) goto L_0340;
if (K->DISP > HIGH) goto L_0340;
ALTER = 1;
L_0340:
L_033F:
if (ALTER == 0) goto L_0341;
KDEC(K);
K->LINK = KASL;
KASL = K;
if (DIAG & 128 == 0) goto L_0342;
MONREGID(K->REG, _imp_str_literal("Altered"));
L_0342:
goto L_0343;
L_0341:
K->LINK = KNOWING;
KNOWING = K;
L_0343:
goto L_033C;
L_033D:
} /* FORGETDESTINATION */
void FORGETENVIRONMENT(int LABEL) {
struct LABELFM *L;
struct KNOWFM *P;
struct KNOWFM *E;
L = ILABEL(LABEL);
P = /*%A*/ /*addressof*/ &L->ENV;
L->ENV = NIL;
if (P == NIL) goto L_0344;
E = P;
L_0345:
if (/*%A*/ /*addressof*/ &P->LINK == NIL) goto L_0346;
P = /*%A*/ /*addressof*/ &P->LINK;
goto L_0345;
L_0346:
P->LINK = KASL;
KASL = E;
L_0344:
} /* FORGETENVIRONMENT */
void REMEMBERENVIRONMENT(int LABEL) {
struct KNOWFM *K;
struct KNOWFM *TOP;
TOP = NIL;
struct KNOWFM *P;
FORGETENVIRONMENT(/*indirectthrough*/ *LABEL);
K = KNOWING;
L_0347:
if (K == NIL) goto L_0348;
P = NEWK();
/*indirectthrough*/ *P = /*indirectthrough*/ *K;
P->LINK = TOP;
TOP = P;
if (DIAG & 128 == 0) goto L_0349;
MONREGID(P->REG, _imp_str_literal("in env"));
L_0349:
K = /*%A*/ /*addressof*/ &K->LINK;
goto L_0347;
L_0348:
ILABEL(/*indirectthrough*/ *LABEL)->ENV = TOP;
} /* REMEMBERENVIRONMENT */
void MERGEENVIRONMENT(int LABEL) {
struct LABELFM *L;
struct KNOWFM *P;
struct KNOWFM *K;
struct KNOWFM *NEXT;
struct KNOWFM *TOP;
if (DIAG & 128 == 0) goto L_034A;
MONITOR(NIL, _imp_str_literal("merge"));
L_034A:
if (KNOWING != NIL) goto L_034B;
FORGETENVIRONMENT(/*indirectthrough*/ *LABEL);
goto L_034C;
L_034B:
L = ILABEL(/*indirectthrough*/ *LABEL);
TOP = NIL;
NEXT = /*%A*/ /*addressof*/ &L->ENV;
L_034D:
P = NEXT;
if (P != NIL) goto L_034E;
goto L_034F;
L_034E:
NEXT = /*%A*/ /*addressof*/ &P->LINK;
K = KNOWING;
L_0350:
if (K->REG != P->REG) goto L_0351;
if (K->DISP != P->DISP) goto L_0351;
if (K->BASE != P->BASE) goto L_0351;
if (K->FTYPE != P->FTYPE) goto L_0351;
if (K->AREA != P->AREA) goto L_0351;
if (K->OPND != P->OPND) goto L_0351;
if (K->OPER != P->OPER) goto L_0351;
P->LINK = TOP;
TOP = P;
if (DIAG & 128 == 0) goto L_0352;
MONREGID(P->REG, _imp_str_literal("Merged"));
L_0352:
goto U_100B;
L_0351:
K = /*%A*/ /*addressof*/ &K->LINK;
if (K == NIL) goto L_0353;
goto L_0350;
L_0353:
P->LINK = KASL;
KASL = P;
U_100B:
goto L_034D;
L_034F:
L->ENV = TOP;
L_034C:
} /* MERGEENVIRONMENT */
void RESTOREENVIRONMENT(int LABEL) {
struct KNOWFM *P;
struct KNOWFM *K;
struct KNOWFM *NEXT;
FORGETEVERYTHING();
NEXT = /*%A*/ /*addressof*/ &ILABEL(/*indirectthrough*/ *LABEL)->ENV;
L_0354:
P = NEXT;
if (P != NIL) goto L_0355;
return;
L_0355:
NEXT = /*%A*/ /*addressof*/ &P->LINK;
K = NEWK();
/*indirectthrough*/ *K = /*indirectthrough*/ *P;
K->LINK = KNOWING;
KNOWING = K;
KINC(K);
if (DIAG & 128 == 0) goto L_0356;
MONREGID(P->REG, _imp_str_literal("back"));
L_0356:
goto L_0354;
} /* RESTOREENVIRONMENT */
void CLAIM(int REGISTER) {
if (1 > /*indirectthrough*/ *REGISTER) goto L_0357;
if (/*indirectthrough*/ *REGISTER > 26) goto L_0357;
if (ACTIVITY[/*indirectthrough*/ *REGISTER] >= 0) goto L_0358;
L_0357:
return;
L_0358:
ACTIVITY[/*indirectthrough*/ *REGISTER] = ACTIVITY[/*indirectthrough*/ *REGISTER] + 1;
ACTIVEREGISTERS = ACTIVEREGISTERS + 1;
USEDTIME = USEDTIME + 1;
USED[/*indirectthrough*/ *REGISTER] = USEDTIME;
if (DIAG & 4 == 0) goto L_0359;
MONITORREGISTER(/*indirectthrough*/ *REGISTER, _imp_str_literal("Claimed"));
L_0359:
} /* CLAIM */
void RELEASE(int REGISTER) {
if (1 > /*indirectthrough*/ *REGISTER) goto L_035A;
if (/*indirectthrough*/ *REGISTER > 26) goto L_035A;
if (ACTIVITY[/*indirectthrough*/ *REGISTER] >= 0) goto L_035B;
L_035A:
return;
L_035B:
ACTIVITY[/*indirectthrough*/ *REGISTER] = ACTIVITY[/*indirectthrough*/ *REGISTER] - 1;
if (ACTIVITY[/*indirectthrough*/ *REGISTER] >= 0) goto L_035C;
FAIL(_imp_str_literal("Register not claimed"));
L_035C:
if (DIAG & 4 == 0) goto L_035D;
MONITORREGISTER(/*indirectthrough*/ *REGISTER, _imp_str_literal("Released"));
L_035D:
ACTIVEREGISTERS = ACTIVEREGISTERS - 1;
if (ACTIVEREGISTERS >= 0) goto L_035E;
FAIL(_imp_str_literal("Register unclaimed"));
L_035E:
} /* RELEASE */
void TOSTORE(int CODE) {
if (/*indirectthrough*/ *CODE == 0) goto L_035F;
if (/*indirectthrough*/ *CODE != 3) goto L_0360;
if (STACK->TYPE != 4) goto L_0361;
LOADUP(STACK);
L_0361:
goto L_0362;
L_0360:
if (/*indirectthrough*/ *CODE != 1) goto L_0363;
if (STACK->TYPE == 4) goto L_0364;
if (STACK->TYPE != 2) goto L_0365;
L_0364:
LOADUP(STACK);
L_0365:
L_0363:
L_0362:
L_035F:
if (STACK->FORM == 0) goto L_0366;
if (STACK->OPER != 0) goto L_0366;
if (/*%A*/ /*addressof*/ &STACK->INDEX == NIL) goto L_0367;
L_0366:
if (STACK->TYPE == 8) goto L_0368;
if (STACK->TYPE != 9) goto L_0369;
L_0368:
EVALUATESTRINGEXPRESSION(STACK);
goto L_036A;
L_0369:
LOADUP(STACK);
HAZARD(STACK->BASE);
L_036A:
L_0367:
} /* TOSTORE */
void PESSIMISE(struct STACKFM * V) {
int REG;
int N;
int DISP;
struct KNOWFM *K;
struct STACKFM *T;
if (DIAG & 8 == 0) goto L_036B;
MONITOR(V, _imp_str_literal("Pessimise->"));
L_036B:
if (INREG(V)) goto L_036C;
FAIL(_imp_str_literal("Not loaded"));
L_036C:
REG = V->OPER;
N = KTIMES[REG];
K = KNOWING;
if (N != 0) goto L_036D;
K = NIL;
L_036D:
L_036E:
if (K != NIL) goto L_036F;
if (N == 0) goto L_0370;
FAIL(_imp_str_literal("corrupt knowing"));
L_0370:
REG = V->OPER;
if (1 > REG) goto L_0371;
if (REG > 16) goto L_0371;
T = CLAIMWORKAREA(4, 1);
goto L_0372;
L_0371:
T = CLAIMWORKAREA(2 * 4, 7);
L_0372:
DISP = T->DISP;
SIMPLE(V, T);
RELEASE(REG);
V->OPER = /*indirectthrough*/ *LOCAL;
V = DISP;
V->OPND = 1;
DROP(T);
goto L_0373;
L_036F:
if (K->REG != REG) goto L_0374;
N = N - 1;
if (K->OPER != 0) goto L_0375;
if (0 != K->OPND) goto L_0375;
if (K->FTYPE != (V->AREA << 4) + 1) goto L_0376;
if (K->AREA != V) goto L_0376;
if (!(LOCKED(K->BASE))) goto L_0376;
RELEASE(REG);
V->OPER = K->BASE;
V = K->DISP;
V = K->EXTRA;
V->OPND = 1;
V->BASE = 128;
CLAIM(V->OPER);
goto L_0373;
L_0376:
if (K->FTYPE != (1 << 4) + 0) goto L_0377;
if (K->BASE != 0) goto L_0377;
if (K->AREA != 0) goto L_0377;
RELEASE(REG);
V->OPER = 0;
V = K->DISP;
V->OPND = 0;
V = 0;
V->BASE = 128;
goto L_0373;
L_0377:
L_0375:
goto L_0378;
L_0374:
if (K->BASE != REG) goto L_0379;
N = N - 1;
L_0379:
L_0378:
K = /*%A*/ /*addressof*/ &K->LINK;
goto L_036E;
L_0373:
if (DIAG & 8 == 0) goto L_037A;
MONITOR(V, _imp_str_literal("Pessimise<-"));
L_037A:
} /* PESSIMISE */
void HAZARD(int REG) {
int REGISTER;
REGISTER = /*indirectthrough*/ *_imp_MOD(/*indirectthrough*/ *REG);
struct STACKFM *U;
struct STACKFM *R;
int *N;
int DISP;
int STORED;
STORED = 0;
void STORE(void) {
struct STACKFM *T;
if (STORED == 0) goto L_037B;
return;
L_037B:
STORED = 1;
if (1 > REGISTER) goto L_037C;
if (REGISTER > 16) goto L_037C;
T = CLAIMWORKAREA(4, 1);
goto L_037D;
L_037C:
T = CLAIMWORKAREA(2 * 4, 7);
L_037D:
DISP = T->DISP;
SIMPLE(/*%A*/ /*addressof*/ ®V[REGISTER], T);
RELEASEANDDROP(T);
} /* STORE */
if (DIAG & 4 == 0) goto L_037E;
MONITORREGISTER(REGISTER, _imp_str_literal("Hazard"));
L_037E:
N = /*%A*/ /*addressof*/ &ACTIVITY[REGISTER];
if (/*indirectthrough*/ *N > 0) goto L_037F;
return;
L_037F:
U = USING;
L_0380:
if (U == NIL) goto L_0381;
if (U->BASE != REGISTER) goto L_0382;
if (DIAG & 4 == 0) goto L_0383;
MONITOR(U, _imp_str_literal("Hazarding"));
L_0383:
if (/*indirectthrough*/ *N != 1) goto L_0384;
if (STORED != 0) goto L_0384;
if (!(INREG(U))) goto L_0384;
PESSIMISE(U);
return;
L_0384:
STORE();
if (U->FORM != 0) goto L_0385;
if (U->DISP != 0) goto L_0385;
if (/*%A*/ /*addressof*/ &U->INDEX != NIL) goto L_0385;
U->FORM = 1;
U->BASE = /*indirectthrough*/ *LOCAL;
U->DISP = DISP;
goto L_0386;
L_0385:
if (/*%A*/ /*addressof*/ &U->RECORD == NIL) goto L_0387;
FAIL(_imp_str_literal("Corrupt record"));
L_0387:
R = LOCALINTEGER(DISP);
R->FLAGS = 16;
U->BASE = 0;
U->RECORD = R;
L_0386:
RELEASE(REGISTER);
L_0382:
U = /*%A*/ /*addressof*/ &U->USING;
goto L_0380;
L_0381:
if (/*indirectthrough*/ *N == 0) goto L_0388;
if (/*indirectthrough*/ *N == 0) goto L_0389;
FAIL(_imp_str_literal("Use lost"));
L_0389:
L_0388:
} /* HAZARD */
void HAZARDALL(void) {
HAZARD(1);
HAZARD(2);
HAZARD(3);
HAZARD(4);
if (ACTIVEREGISTERS != 0) goto L_038A;
return;
L_038A:
HAZARD(5);
HAZARD(6);
HAZARD(7);
HAZARD(8);
if (ACTIVEREGISTERS != 0) goto L_038B;
return;
L_038B:
HAZARD(9);
HAZARD(12);
HAZARD(15);
if (ACTIVEREGISTERS != 0) goto L_038C;
return;
L_038C:
HAZARD(18);
HAZARD(19);
HAZARD(20);
HAZARD(21);
if (ACTIVEREGISTERS != 0) goto L_038D;
return;
L_038D:
HAZARD(22);
HAZARD(23);
HAZARD(24);
HAZARD(25);
} /* HAZARDALL */
struct STACKFM *DESCRIPTOR(void) {
struct STACKFM *V;
if (DASL != NIL) goto L_038E;
DASL = _imp_NEW(STACKFMTYPE);
DASL->USING = NIL;
L_038E:
V = DASL;
DASL = /*%A*/ /*addressof*/ &V->USING;
/*indirectthrough*/ *V = 0;
V->USING = USING;
USING = V;
return V;
} /* DESCRIPTOR */
void DROPALL(struct STACKFM * V) {
if (/*%A*/ /*addressof*/ &V->INDEX == NIL) goto L_038F;
DROPALL(/*%A*/ /*addressof*/ &V->INDEX);
V->INDEX = NIL;
L_038F:
if (/*%A*/ /*addressof*/ &V->RECORD == NIL) goto L_0390;
DROPALL(/*%A*/ /*addressof*/ &V->RECORD);
V->RECORD = NIL;
L_0390:
DROP(V);
} /* DROPALL */
void DROP(struct STACKFM * V) {
struct STACKFM *P;
struct STACKFM *E;
if (DIAG & 2 == 0) goto L_0391;
MONITOR(V, _imp_str_literal("Drop"));
L_0391:
ZAPINDEXANDRECORD(V);
if (USING != V) goto L_0392;
USING = /*%A*/ /*addressof*/ &V->USING;
goto L_0393;
L_0392:
P = USING;
L_0394:
if (P != NIL) goto L_0395;
FAIL(_imp_str_literal("Not in use"));
L_0395:
E = P;
P = /*%A*/ /*addressof*/ &P->USING;
if (P == V) goto L_0396;
goto L_0394;
L_0396:
E->USING = /*%A*/ /*addressof*/ &P->USING;
L_0393:
V->USING = DASL;
DASL = V;
} /* DROP */
void RELEASEANDDROP(struct STACKFM * V) {
if (/*%A*/ /*addressof*/ &V->LINK == NIL) goto L_0397;
RELEASEANDDROP(/*%A*/ /*addressof*/ &V->LINK);
L_0397:
RELEASE(V->BASE);
DROP(V);
} /* RELEASEANDDROP */
void ZAPINDEXANDRECORD(struct STACKFM * V) {
if (/*%A*/ /*addressof*/ &V->INDEX == NIL) goto L_0398;
RELEASEANDDROP(/*%A*/ /*addressof*/ &V->INDEX);
V->INDEX = NIL;
L_0398:
if (/*%A*/ /*addressof*/ &V->RECORD == NIL) goto L_0399;
RELEASEANDDROP(/*%A*/ /*addressof*/ &V->RECORD);
V->RECORD = NIL;
L_0399:
} /* ZAPINDEXANDRECORD */
void RELEASEANDDROPPAIR(struct STACKFM * A, struct STACKFM * B) {
RELEASEANDDROP(A);
RELEASEANDDROP(B);
} /* RELEASEANDDROPPAIR */
void POPRELEASEANDDROP(void) {
struct STACKFM *S;
S = STACK;
STACK = /*%A*/ /*addressof*/ &S->STACK;
RELEASEANDDROP(S);
} /* POPRELEASEANDDROP */
void DROPMEMBERS(struct STACKFM * S) {
struct MEMBERFM *M;
struct MEMBERFM *X;
M = /*%A*/ /*addressof*/ &S->MEMBERS;
S->MEMBERS = NIL;
L_039A:
if (M == NIL) goto L_039B;
X = M;
M = /*%A*/ /*addressof*/ &M->LINK;
if (X->CONST == 0) goto L_039C;
DROP(/*%A*/ /*addressof*/ &X->A);
if (/*%A*/ /*addressof*/ &X->B == NIL) goto L_039D;
DROP(/*%A*/ /*addressof*/ &X->B);
L_039D:
goto L_039E;
L_039C:
RELEASEANDDROP(/*%A*/ /*addressof*/ &X->A);
if (/*%A*/ /*addressof*/ &X->B == NIL) goto L_039F;
RELEASEANDDROP(/*%A*/ /*addressof*/ &X->B);
L_039F:
L_039E:
_imp_DISPOSE(X);
goto L_039A;
L_039B:
} /* DROPMEMBERS */
void APPLYINDIRECTION(void) {
struct STACKFM *W;
W = STACK;
STACK = DESCRIPTOR();
STACK->STACK = /*%A*/ /*addressof*/ &W->STACK;
STACK->TYPE = W->TYPE;
STACK->FORM = 1;
STACK->RECORD = W;
STACK->FORMAT = W->FORMAT;
W->TYPE = 1;
W->FORM = 1;
W->FORMAT = 0;
} /* APPLYINDIRECTION */
void STACKTRUEORFALSE(int CC) {
int OTHER;
int R;
int LAB;
struct STACKFM *V;
V = LITERAL(0);
OPTIMISE(V, 1);
if (!(INREG(V))) goto L_03A0;
/*indirectthrough*/ *CC = NEGATED[/*indirectthrough*/ *CC];
OTHER = 1;
goto L_03A1;
L_03A0:
V->DISP = 1;
OTHER = 0;
L_03A1:
LOADPROTECTED(V);
R = V->BASE;
RELEASEANDDROP(V);
if (ACTIVITY[R] == 0) goto L_03A2;
FAIL(_imp_str_literal("register active"));
L_03A2:
LAB = NEWLABEL();
JUMPTO(LAB, /*indirectthrough*/ *CC);
V = LITERAL(OTHER);
LOAD(V, R);
DEFINELABEL(LAB);
FORGET(R);
V->STACK = STACK;
STACK = V;
} /* STACKTRUEORFALSE */
void STACKVAR(int VARNO) {
int FORM;
int FLAGS;
struct STACKFM *V;
V = DESCRIPTOR();
V->V = /*indirectthrough*/ *VAR(VARNO);
V->VARNO = VARNO;
V->STACK = STACK;
STACK = V;
if (STACK->BASE != 10) goto L_03A3;
ATTRIBUTES = ATTRIBUTES | 4;
L_03A3:
FORM = V->FORM;
if (V->FLAGS & 8388608 == 0) goto L_03A4;
FLAGS = V->FLAGS;
V->FLAGS = 0;
APPLYINDIRECTION();
STACK->FLAGS = FLAGS & (~8388608);
L_03A4:
if (FORM != 15) goto L_03A5;
APPLYINDIRECTION();
L_03A5:
if (DIAG & 2 == 0) goto L_03A6;
MONITOR(STACK, _imp_str_literal("Stack Var"));
L_03A6:
} /* STACKVAR */
struct STACKFM *LOCALINTEGER(int DISP) {
struct STACKFM *V;
V = DESCRIPTOR();
V->TYPE = 1;
V->FORM = 1;
V->BASE = /*indirectthrough*/ *LOCAL;
V->DISP = DISP;
V->FLAGS = 128;
return V;
} /* LOCALINTEGER */
struct STACKFM *LITERAL(int N) {
struct STACKFM *V;
V = DESCRIPTOR();
V->DISP = N;
V->TYPE = 1;
V->FLAGS = 128;
return V;
} /* LITERAL */
void STACKINTEGER(int N) {
struct STACKFM *V;
V = LITERAL(/*indirectthrough*/ *N);
V->STACK = STACK;
STACK = V;
} /* STACKINTEGER */
int POPPEDVALUE(void) {
struct STACKFM *V;
V = STACK;
STACK = /*%A*/ /*addressof*/ &V->STACK;
DROP(V);
return V->DISP;
} /* POPPEDVALUE */
struct STACKFM *TEMPORARY(void) {
struct STACKFM *V;
FRAME = (FRAME & -4) - 4;
V = LOCALINTEGER(FRAME);
return V;
} /* TEMPORARY */
struct STACKFM *COPY(struct STACKFM * V) {
struct STACKFM *C;
if (V != NIL) goto L_03A7;
return NIL;
L_03A7:
C = DESCRIPTOR();
C->DATA = V->DATA;
CLAIM(C->BASE);
C->OPER = V->OPER;
if (/*%A*/ /*addressof*/ &V->INDEX == NIL) goto L_03A8;
C->INDEX = COPY(/*%A*/ /*addressof*/ &V->INDEX);
L_03A8:
if (/*%A*/ /*addressof*/ &V->RECORD == NIL) goto L_03A9;
C->RECORD = COPY(/*%A*/ /*addressof*/ &V->RECORD);
L_03A9:
if (/*%A*/ /*addressof*/ &V->LINK == NIL) goto L_03AA;
C->LINK = COPY(/*%A*/ /*addressof*/ &V->LINK);
L_03AA:
return C;
} /* COPY */
void SELECT(int ITEM) {
struct STACKFM *V;
struct STACKFM *X;
struct VARFM *FIELD;
V = STACK;
FIELD = VAR(VAR(-V->FORMAT)->EXTRA - /*indirectthrough*/ *ITEM);
if (V->FORM != 0) goto L_03AB;
FAIL(_imp_str_literal("Select"));
L_03AB:
STACK->VARNO = 0;
if (V->FORM != 1) goto L_03AC;
if (/*%A*/ /*addressof*/ &V->INDEX != NIL) goto L_03AC;
V->DISP = V->DISP + FIELD->DISP;
V->TYPE = FIELD->TYPE;
V->FORM = FIELD->FORM;
V->FORMAT = FIELD->FORMAT;
V->FLAGS = FIELD->FLAGS;
V->ADATA = /*%A*/ /*addressof*/ &FIELD->ADATA;
goto L_03AD;
L_03AC:
AMAP(V);
X = DESCRIPTOR();
X->V = /*indirectthrough*/ *FIELD;
X->BASE = 0;
X->RECORD = V;
STACK = X;
X->STACK = /*%A*/ /*addressof*/ &V->STACK;
L_03AD:
if (STACK->FORM != 15) goto L_03AE;
APPLYINDIRECTION();
L_03AE:
if (DIAG & 2 == 0) goto L_03AF;
MONITOR(STACK, _imp_str_literal("Select"));
L_03AF:
} /* SELECT */
void XCALL(int EP, int STACKIT, int HAZARD) {
struct STACKFM *V;
if (/*indirectthrough*/ *HAZARD <= 0) goto L_03B0;
if (ACTIVEREGISTERS == 0) goto L_03B0;
HAZARDALL();
L_03B0:
DIR2(23, /*indirectthrough*/ *EP);
REFS = REFS + 1;
/*indirectthrough*/ *CA = /*indirectthrough*/ */*indirectthrough*/ *CA + 4;
if (/*indirectthrough*/ *HAZARD < 0) goto L_03B1;
FORGETEVERYTHING();
L_03B1:
ATTRIBUTES = ATTRIBUTES | 4;
if (/*indirectthrough*/ *STACKIT == 0) goto L_03B2;
ATTRIBUTES = ATTRIBUTES | 64;
V = REGISTER(/*indirectthrough*/ *STACKIT);
V->STACK = STACK;
STACK = V;
L_03B2:
} /* XCALL */
void CHECKCOMPILERLABEL(int LABEL) {
if (/*indirectthrough*/ *LABEL <= 8191) goto L_03B3;
FAIL(_imp_str_literal("compiler labels/1"));
L_03B3:
} /* CHECKCOMPILERLABEL */
int NEWLABEL(void) {
FREELABEL = FREELABEL + 1;
if (FREELABEL & 32768 == 0) goto L_03B4;
FAIL(_imp_str_literal("too many internal labels"));
L_03B4:
return FREELABEL;
} /* NEWLABEL */
void JUMPTO(int INTERNALLABEL, int CONDCODE) {
JLAB = /*indirectthrough*/ *INTERNALLABEL;
if (INVERT == 0) goto L_03B5;
/*indirectthrough*/ *CONDCODE = REVERSE[/*indirectthrough*/ *CONDCODE];
INVERT = 0;
L_03B5:
DIR3(14, /*indirectthrough*/ *INTERNALLABEL, /*indirectthrough*/ */*indirectthrough*/ *CONDCODE + UNSIGNED);
UNSIGNED = 0;
REFS = REFS + 1;
/*indirectthrough*/ *CA = /*indirectthrough*/ */*indirectthrough*/ *CA + 4;
if (/*indirectthrough*/ *CONDCODE != 7) goto L_03B6;
UNCONDJUMP = /*indirectthrough*/ *CA;
L_03B6:
ASSIGNLOCK = 0;
} /* JUMPTO */
void DEFINELABEL(int INTERNALLABEL) {
DIR2(8, /*indirectthrough*/ *INTERNALLABEL);
UNCONDJUMP = -1;
ASSIGNLOCK = 0;
} /* DEFINELABEL */
void DEFINECOMPILERLABEL(int LABEL) {
struct LABELFM *L;
CHECKCOMPILERLABEL(/*indirectthrough*/ *LABEL);
L = ILABEL(/*indirectthrough*/ *LABEL);
if (L->LAB & -2147483648 == 0) goto L_03B7;
FORGETENVIRONMENT(/*indirectthrough*/ *LABEL);
L->LAB = NEWLABEL();
L_03B7:
L->LAB = L->LAB | -2147483648;
if (UNCONDJUMP == /*indirectthrough*/ *CA) goto L_03B8;
MERGEENVIRONMENT(/*indirectthrough*/ *LABEL);
L_03B8:
DEFINELABEL(L->LAB & 2147483647);
RESTOREENVIRONMENT(/*indirectthrough*/ *LABEL);
} /* DEFINECOMPILERLABEL */
int FORWARDLABEL(int LABEL) {
struct LABELFM *L;
L = ILABEL(/*indirectthrough*/ *LABEL);
if (L->LAB & -2147483648 == 0) goto L_03B9;
L->LAB = NEWLABEL();
REMEMBERENVIRONMENT(/*indirectthrough*/ *LABEL);
goto L_03BA;
L_03B9:
MERGEENVIRONMENT(/*indirectthrough*/ *LABEL);
L_03BA:
return L->LAB;
} /* FORWARDLABEL */
void JUMPFORWARD(int LABEL, int CONDCODE) {
CHECKCOMPILERLABEL(/*indirectthrough*/ *LABEL);
JUMPTO(FORWARDLABEL(/*indirectthrough*/ *LABEL), CONDCODE);
if (CONDCODE != 6) goto L_03BB;
if (PENDINGKNOWNREGISTER == 0) goto L_03BB;
REMEMBER(PENDINGKNOWNREGISTER, /*%A*/ /*addressof*/ &PENDINGKNOWN);
L_03BB:
PENDINGKNOWNREGISTER = 0;
} /* JUMPFORWARD */
void JUMPBACKWARD(int LABEL) {
struct STACKFM C;
struct STACKFM F;
struct STACKFM *U;
struct STACKFM *CC;
struct FORFM *FOR;
FOR = NIL;
struct VARFM *VR;
struct LABELFM *L;
int HOW;
CHECKCOMPILERLABEL(LABEL);
L = ILABEL(LABEL);
HOW = 7;
if (L->LAB & -2147483648 != 0) goto L_03BC;
FAIL(_imp_str_literal("Label missing"));
L_03BC:
if (FORS == NIL) goto L_03BD;
if (LABEL != FORS->LABEL) goto L_03BD;
FOR = FORS;
FORS = /*%A*/ /*addressof*/ &FORS->LINK;
C.DATA = FOR->CONTROL;
VMAP(/*%A*/ /*addressof*/ &C, FOR->TYPE);
LOAD(/*%A*/ /*addressof*/ &C, FOR->REG);
if (FOR->ENTRY == 0) goto L_03BE;
DEFINECOMPILERLABEL(FOR->ENTRY);
L_03BE:
F.DATA = FOR->FINAL;
COMPARE(/*%A*/ /*addressof*/ &C, /*%A*/ /*addressof*/ &F);
RELEASE(C.BASE);
RELEASE(F.BASE);
HOW = FOR->CC;
L_03BD:
JUMPTO(L->LAB & 2147483647, HOW);
if (FOR == NIL) goto L_03BF;
if (HOW == 7) goto L_03C0;
if (LANGUAGEFLAGS & 4 == 0) goto L_03C0;
if (UNASSIGNED == 0) goto L_03C0;
CC = LITERAL(0);
CC->DATA = FOR->CONTROL;
VMAP(CC, FOR->TYPE);
U = COPY(/*%A*/ /*addressof*/ &UAPAT);
U->TYPE = FOR->TYPE;
SIMPLE(U, CC);
FORGETDESTINATION(CC);
FORGET(U->BASE);
RELEASEANDDROP(U);
RELEASEANDDROP(CC);
if (FOR->CONTROL == 0) goto L_03C1;
VR = VAR(FOR->CONTROL);
VR->FLAGS = VR->FLAGS & (~128);
L_03C1:
L_03C0:
_imp_DISPOSE(FOR);
L_03BF:
} /* JUMPBACKWARD */
void SETUSERLABEL(int LABEL) {
struct VARFM *V;
V = VAR(LABEL);
CLEARVARS(LABEL);
V->TYPE = 11;
V->BASE = /*indirectthrough*/ *LOCAL;
V->DISP = NEWLABEL();
} /* SETUSERLABEL */
void USERJUMP(int LABEL) {
static int JOUT = 0;
int B;
struct STACKFM *BASE;
struct VARFM *V;
struct VARFM C;
V = VAR(/*indirectthrough*/ *LABEL);
if (/*indirectthrough*/ *LABEL > /*indirectthrough*/ *VARS) goto L_03C2;
if (V->DISP != 0) goto L_03C3;
L_03C2:
SETUSERLABEL(/*indirectthrough*/ *LABEL);
L_03C3:
B = V->BASE;
if (B == /*indirectthrough*/ *LOCAL) goto L_03C4;
BASE = DISPLAYINFO(B);
RELEASEANDDROP(BASE);
BASE = LITERAL(0);
BASE->BASE = B;
BASE->FLAGS = 128;
LOAD(BASE, 11);
BASE->DISP = V->EXTRA;
BASE->FORM = 1;
BASE->FLAGS = 128;
LOAD(BASE, 4);
RELEASEANDDROP(BASE);
DO(_imp_str_literal("3L_pascal___jump_out"), /*%A*/ /*addressof*/ &JOUT, 0);
L_03C4:
JUMPTO(V->DISP, 7);
} /* USERJUMP */
void MARKUSERLABEL(void) { DIR1(9); } /* MARKUSERLABEL */
void DEFINEUSERLABEL(int LABEL) {
struct VARFM *V;
V = VAR(LABEL);
if (LABEL > /*indirectthrough*/ *VARS) goto L_03C5;
if (V->DISP != 0) goto L_03C6;
L_03C5:
SETUSERLABEL(LABEL);
L_03C6:
DEFINELABEL(V->DISP);
MARKUSERLABEL();
FORGETEVERYTHING();
} /* DEFINEUSERLABEL */
void RETURN(int HOW) {
int RESULTREG;
int TYPE;
struct STACKFM *V;
struct STACKFM *W;
if (UNCONDJUMP != /*indirectthrough*/ *CA) goto L_03C7;
if (/*indirectthrough*/ *HOW >= 0) goto L_03C8;
POPRELEASEANDDROP();
L_03C8:
return;
L_03C7:
V = NIL;
RESULTREG = 1;
TYPE = AVAR;
if (/*indirectthrough*/ *HOW != 1) goto L_03C9;
V = LITERAL(1);
goto L_03CA;
L_03C9:
if (/*indirectthrough*/ *HOW != 2) goto L_03CB;
V = LITERAL(0);
goto L_03CA;
L_03CB:
if (/*indirectthrough*/ *HOW == 0) goto L_03CC;
V = STACK;
STACK = /*%A*/ /*addressof*/ &STACK->STACK;
if (/*indirectthrough*/ *HOW != -2) goto L_03CD;
AMAP(V);
TYPE = 5;
goto L_03CE;
L_03CD:
if (TYPE == 8) goto L_03CF;
if (TYPE != 9) goto L_03D0;
L_03CF:
W = LITERAL(0);
W->TYPE = TYPE;
W->FORM = 1;
W->RECORD = LOCALINTEGER(STRINGRESULT);
W->RECORD = AVAR;
if (W->TYPE != 8) goto L_03D1;
STRINGASSIGN(V, W);
goto L_03D2;
L_03D1:
RECORDASSIGN(V, W);
L_03D2:
RELEASEANDDROPPAIR(W, V);
V = NIL;
L_03D0:
L_03CE:
L_03CC:
L_03CA:
if (V == NIL) goto L_03D3;
if (TYPE == 6) goto L_03D4;
if (TYPE != 7) goto L_03D5;
L_03D4:
LOAD(V, 18);
goto L_03D6;
L_03D5:
LOAD(V, RESULTREG);
L_03D6:
RELEASEANDDROP(V);
L_03D3:
DIR2(26, PARAMETERFRAME);
REFS = REFS + 1;
/*indirectthrough*/ *CA = /*indirectthrough*/ */*indirectthrough*/ *CA + 4;
UNCONDJUMP = /*indirectthrough*/ *CA;
OPEN = 0;
} /* RETURN */
void STAB(struct STACKFM * V) {
struct STACKFM *T;
struct STACKFM *TT;
if (!(ICONST(/*%A*/ /*addressof*/ &V))) goto L_03D7;
return;
L_03D7:
T = TEMPORARY();
TT = COPY(T);
STORE(/*%A*/ /*addressof*/ &V, T);
RELEASEANDDROP(T);
REPLACE(/*%A*/ /*addressof*/ &V, TT);
V = V | 128;
} /* STAB */
void COMPILEFOR(int REPEATLABEL) {
int TYPE;
int N;
struct STACKFM *INITIAL;
struct STACKFM *FINAL;
struct STACKFM *INC;
struct STACKFM *CONTROL;
struct STACKFM *INCREMENT;
struct STACKFM *C;
struct FORFM *FOR;
struct VARFM *V;
int LOOPTYPE(void) {
int I;
int N;
if (!(ICONST(INITIAL))) goto L_03D8;
if (!(ICONST(INC))) goto L_03D8;
if (ICONST(FINAL)) goto L_03D9;
L_03D8:
return 1;
L_03D9:
I = INC->DISP;
N = FINAL->DISP - INITIAL->DISP + I;
if (I == 0) goto L_03DA;
if (N != 0) goto L_03DB;
return 1;
L_03DB:
if (N ^ I < 0) goto L_03DC;
if (_imp_REM(N, I) != 0) goto L_03DC;
if (FORRANGE == NIL) goto L_03DD;
if (FORRANGE->DISP > INITIAL->DISP) goto L_03DE;
if (INITIAL->DISP > FORRANGE->EXTRA) goto L_03DE;
if (FORRANGE->DISP > FINAL->DISP) goto L_03DE;
if (FINAL->DISP <= FORRANGE->EXTRA) goto L_03DF;
L_03DE:
return 1;
L_03DF:
FORRANGE = NIL;
L_03DD:
return 0;
L_03DC:
goto L_03E0;
L_03DA:
I = 1;
L_03E0:
if (LANGUAGEFLAGS & 2 != 0) goto L_03E1;
WARN(1, _imp_str_literal("Non-integral %for loop"));
FINAL->DISP = INITIAL->DISP + ((long)N / (long)I) * I;
L_03E1:
return 1;
} /* LOOPTYPE */
FINAL = STACK;
INC = /*%A*/ /*addressof*/ &FINAL->STACK;
INITIAL = /*%A*/ /*addressof*/ &INC->STACK;
CONTROL = /*%A*/ /*addressof*/ &INITIAL->STACK;
STACK = /*%A*/ /*addressof*/ &CONTROL->STACK;
STAB(INC);
TYPE = CONTROL->TYPE;
if (CONTROL->FORM != 1) goto L_03E2;
if (/*%A*/ /*addressof*/ &CONTROL->INDEX != NIL) goto L_03E2;
if (/*%A*/ /*addressof*/ &CONTROL->RECORD != NIL) goto L_03E2;
if (CONTROL->BASE == 0) goto L_03E3;
if (CONTROL->BASE == /*indirectthrough*/ *LOCAL) goto L_03E3;
if (CONTROL->BASE == 10) goto L_03E3;
L_03E2:
AMAP(CONTROL);
STAB(CONTROL);
goto L_03E4;
L_03E3:
AMAP(CONTROL);
L_03E4:
SIMPLIFY(CONTROL);
FOR = _imp_NEW(FORFMTYPE);
FOR->LINK = FORS;
FORS = FOR;
FOR->LABEL = /*indirectthrough*/ *REPEATLABEL;
FOR->CONTROL = CONTROL->DATA;
VMAP(CONTROL, TYPE);
FOR->TYPE = TYPE;
FOR->ENTRY = LOOPTYPE();
FOR->AS = 0;
N = INC->DISP;
FOR->CC = 6;
if (LANGUAGEFLAGS & 2 == 0) goto L_03E5;
if (FOR->ENTRY == 0) goto L_03E5;
if (N != 1) goto L_03E6;
FOR->CC = 2;
goto L_03E7;
L_03E6:
if (N != -1) goto L_03E8;
FOR->CC = 4;
goto L_03E7;
L_03E8:
FAIL(_imp_str_literal("corrupt increment"));
L_03E7:
L_03E5:
INCREMENT = COPY(INC);
OPERATE(5, INITIAL, INC);
LOADUP(INITIAL);
FOR->REG = INITIAL->BASE;
STAB(FINAL);
FOR->FINAL = FINAL->DATA;
LOAD(INITIAL, FOR->REG);
if (FOR->ENTRY == 0) goto L_03E9;
if (LANGUAGEFLAGS & 4 != 0) goto L_03EA;
C = COPY(CONTROL);
STORE(INITIAL, C);
RELEASEANDDROP(C);
L_03EA:
FOR->ENTRY = /*indirectthrough*/ */*indirectthrough*/ *REPEATLABEL + 2;
JUMPFORWARD(FOR->ENTRY, 7);
L_03E9:
DEFINECOMPILERLABEL(/*indirectthrough*/ *REPEATLABEL);
if (FOR->AS != 0) goto L_03EB;
OPERATE(4, INITIAL, INCREMENT);
LOAD(INITIAL, FOR->REG);
L_03EB:
if (FORRANGE == NIL) goto L_03EC;
TESTRANGE(INITIAL, FORRANGE);
FORRANGE = NIL;
L_03EC:
STORE(INITIAL, CONTROL);
FOR->CONTROL = FOR->CONTROL | 128;
if (CONTROL->VARNO == 0) goto L_03ED;
V = VAR(CONTROL->VARNO);
V->FLAGS = V->FLAGS | 128;
L_03ED:
RELEASEANDDROPPAIR(CONTROL, INITIAL);
RELEASEANDDROP(FINAL);
} /* COMPILEFOR */
struct STACKFM *CONSTSTRING(void) {
struct STACKFM *W;
CONSTANTBASE = CONSTANTBASE + 3 & (~3);
SELECTCONSTANTAREA();
W = LITERAL(/*indirectthrough*/ *CA);
W->TYPE = 8;
W->FORM = 1;
W->AREA = 512;
W->FORMAT = /*indirectthrough*/ */*indirectthrough*/ *_imp_LENGTH(/*%A*/ /*addressof*/ &VALUE.STRING) + 1;
W->BIAS = W->FORMAT;
if (VALUE.STRING == _imp_str_literal("")) goto L_03EE;
DUMPTEXT(0);
L_03EE:
SELECTCODEAREA();
return W;
} /* CONSTSTRING */
void FIXTOSTRING(struct STACKFM * C) {
struct STACKFM *W;
VALUE.STRING = _imp_TOSTRING(C);
W = CONSTSTRING();
C = W->DATA;
DROP(W);
} /* FIXTOSTRING */
void SETSIZEORTYPE(int ST, struct STACKFM *V) {
int N;
if (V->TYPE != 10) goto L_03EF;
AMAP(V);
V->DISP = V->DISP + /*indirectthrough*/ */*indirectthrough*/ *ST * 4;
goto L_03F0;
L_03EF:
if (/*indirectthrough*/ *ST != 1) goto L_03F1;
N = ITEMSIZE(V->FORMAT);
if (N != 1) goto L_03F2;
if (V->TYPE != 8) goto L_03F2;
AMAP(V);
ADVANCE(V, 1, 4);
return;
L_03F2:
goto L_03F3;
L_03F1:
N = TYPECODE[V->TYPE];
L_03F3:
RELEASE(V->BASE);
ZAPINDEXANDRECORD(V);
V->DATA = 0;
V->DISP = N;
V->TYPE = 1;
V->FORM = 0;
L_03F0:
} /* SETSIZEORTYPE */
void APPLYTRUNC(struct STACKFM * V) {
int R;
if (FLOATING(V)) goto L_03F4;
return;
L_03F4:
LOAD(V, 26);
RELEASE(V->BASE);
R = GPR();
PLANT7(236454160 | 3 << 5, 0, R, V->BASE);
V->TYPE = 1;
V->BASE = R;
CLAIM(R);
} /* APPLYTRUNC */
void CONVERTFUNCTION(int OP, struct STACKFM *V) {
if (FLOATING(V)) goto L_03F5;
return;
L_03F5:
LOAD(V, 18);
RELEASE(18);
PRIM(OP);
V->TYPE = 1;
V->BASE = 1;
CLAIM(1);
} /* CONVERTFUNCTION */
void APPLYROUND(struct STACKFM * V) { CONVERTFUNCTION(53, V); } /* APPLYROUND */
void APPLYINTPT(struct STACKFM * V) {
int R;
if (FLOATING(V)) goto L_03F6;
return;
L_03F6:
LOAD(V, 26);
RELEASE(V->BASE);
R = GPR();
PLANT7(236454160 | 2 << 5, 0, R, V->BASE);
V->TYPE = 1;
V->BASE = R;
CLAIM(R);
} /* APPLYINTPT */
void APPLYINT(struct STACKFM * V) {
int R;
if (FLOATING(/*%A*/ /*addressof*/ &V)) goto L_03F7;
return;
L_03F7:
LOAD(/*%A*/ /*addressof*/ &V, 26);
RELEASE(V);
PLANT9(234881408 | 8, V, V, 6);
R = GPR();
PLANT7(236454160 | 2 << 5, 0, R, V);
V = 1;
V = R;
CLAIM(R);
} /* APPLYINT */
void XDEFINE(int *EP, _imp_string63 TEXT, int P) {
struct VARFM C;
C = 0;
if (EP != 0) goto L_03F8;
EXTERNALID = /*indirectthrough*/ *TEXT;
if (P != 0) goto L_03F9;
DUMPEXTERNAL(0, /*%A*/ /*addressof*/ &C);
EP = C.AREA;
goto L_03FA;
L_03F9:
C.FORM = 4;
DUMPEXTERNAL(2, /*%A*/ /*addressof*/ &C);
EP = C.DISP;
L_03FA:
L_03F8:
} /* XDEFINE */
void STACKREGISTER(int R) {
struct STACKFM *X;
X = LITERAL(0);
X->BASE = /*indirectthrough*/ *R;
CLAIM(/*indirectthrough*/ *R);
X->STACK = STACK;
STACK = X;
} /* STACKREGISTER */
void DO(_imp_string31 IDENT, int *EP, int RESULT) {
XDEFINE(EP, /*indirectthrough*/ *IDENT, 1);
XCALL(/*indirectthrough*/ *EP, RESULT, 1);
} /* DO */
void DOCONDITIONALEXTERNAL(int CC, _imp_string31 IDENT, int *EP) {
int LABEL;
XDEFINE(/*%A*/ /*addressof*/ &EP, IDENT, 1);
if (ACTIVEREGISTERS == 0) goto L_03FB;
HAZARDALL();
L_03FB:
if (/*indirectthrough*/ *CC == 7) goto L_03FC;
LABEL = NEWLABEL();
JUMPTO(LABEL, NEGATED[/*indirectthrough*/ *CC]);
L_03FC:
XCALL(EP, 0, 0);
if (/*indirectthrough*/ *CC == 7) goto L_03FD;
DEFINELABEL(LABEL);
L_03FD:
} /* DOCONDITIONALEXTERNAL */
void SPECIALCALL(int N) {
struct STACKFM *V;
V = STACK;
struct STACKFM *X;
struct STACKFM *Y;
struct STACKFM *Z;
static int READCHEP = 0;
static int IREAD = 0;
static int RREAD = 0;
static int SREAD = 0;
static int NEXTCHEP = 0;
int TYPE;
static const void *SP[59] = {NULL};
const unsigned char TYPEMAP[7] = {8, 1, 2, 4, 6, 7, 9};
const unsigned char LENMAP[7] = {0, 4, 2, 1, 4, 8, 0};
if (0 >= N) goto L_03FE;
if (N > 59) goto L_03FE;
goto *SP[N]; /*TO DO*/
L_03FE:
SP_default:;
FAIL(_imp_str_literal("Bad primitive"));
void PSYM(struct STACKFM * CHAR) {
static int PRINTSYMBOLEP = 0;
LOAD(/*%A*/ /*addressof*/ &CHAR, 1);
RELEASEANDDROP(/*%A*/ /*addressof*/ &CHAR);
PRIM(45);
FORGETEVERYTHING();
} /* PSYM */
void DOPRINTSTRING(void) {
static int PRINTSTRINGEP = 0;
struct STACKFM *S;
struct STACKFM *V;
V = STACK;
STACK = /*%A*/ /*addressof*/ &STACK->STACK;
L_0400:
S = V;
V = /*%A*/ /*addressof*/ &S->LINK;
S->OPER = 0;
S->LINK = NIL;
if (S->TYPE > 5) goto L_0401;
PSYM(S);
goto L_0402;
L_0401:
if (S->BIAS != 1) goto L_0403;
RELEASEANDDROP(S);
goto L_0402;
L_0403:
AMAP(S);
LOAD(S, 1);
RELEASEANDDROP(S);
DO(_imp_str_literal("3L_IMP_PRINT_STRING"), /*%A*/ /*addressof*/ &PRINTSTRINGEP, 0);
L_0402:
if (V == NIL) goto L_0404;
goto L_0400;
L_0404:
} /* DOPRINTSTRING */
void LOADEXTERNALVARIABLE(_imp_string63 ID, int *EP) {
struct STACKFM *V;
struct VARFM X;
if (/*indirectthrough*/ *EP != 0) goto L_0405;
X.FORM = 0;
EXTERNALID = /*indirectthrough*/ *ID;
DUMPEXTERNAL(0, /*%A*/ /*addressof*/ &X);
/*indirectthrough*/ *EP = -X.AREA;
L_0405:
HAZARD(2);
DIR3(13, ACTUAL[2], /*indirectthrough*/ *EP);
REFS = REFS + 1;
/*indirectthrough*/ *CA = /*indirectthrough*/ */*indirectthrough*/ *CA + 4;
ATTRIBUTES = ATTRIBUTES | 4;
} /* LOADEXTERNALVARIABLE */
void DOINPUT(int FN) {
struct STACKFM *R;
static int INSCB = 0;
HAZARDALL();
LOADEXTERNALVARIABLE(_imp_str_literal("3L___cur_in"), /*%A*/ /*addressof*/ &INSCB);
FORGETEVERYTHING();
DUMPWORD(-460255232);
DUMPWORD(-393150436);
DUMPWORD(-514719741);
PRIM(55);
if (/*indirectthrough*/ *FN != 0) goto L_0406;
DUMPWORD(-455983104);
goto L_0407;
L_0406:
DUMPWORD(-455983103);
DUMPWORD(-469688320);
L_0407:
if (/*indirectthrough*/ *FN < 0) goto L_0408;
R = REGISTER(5);
R->STACK = STACK;
STACK = R;
if (/*indirectthrough*/ *FN != 1) goto L_0409;
ASSIGN(0);
L_0409:
L_0408:
} /* DOINPUT */
case_SP_1:;
DOINPUT(1);
return;
case_SP_2:;
DOINPUT(0);
return;
case_SP_26:;
DOINPUT(-1);
return;
case_SP_25:;
STACK = /*%A*/ /*addressof*/ &V->STACK;
PSYM(V);
return;
case_SP_27:;
X = LITERAL(10);
PSYM(X);
return;
case_SP_28:;
X = LITERAL(32);
PSYM(X);
return;
case_SP_24:;
DOPRINTSTRING();
return;
case_SP_23:;
if (V->TYPE != 8) goto L_040A;
TYPE = 8;
X = LITERAL(ITEMSIZE(STACK->FORMAT) - 1);
AMAP(STACK);
LOAD(STACK, 1);
LOAD(X, 2);
RELEASEANDDROP(X);
POPRELEASEANDDROP();
DO(_imp_str_literal("3L_IMP___read_s"), /*%A*/ /*addressof*/ &SREAD, 0);
goto L_040B;
L_040A:
if (1 > V->TYPE) goto L_040C;
if (V->TYPE > 5) goto L_040C;
TYPE = 1;
DO(_imp_str_literal("3L_IMP___read_i"), /*%A*/ /*addressof*/ &IREAD, 1);
goto L_040D;
L_040C:
if (V->TYPE == 6) goto L_040E;
if (V->TYPE != 7) goto L_040F;
L_040E:
TYPE = 7;
DO(_imp_str_literal("3L_IMP___read_r"), /*%A*/ /*addressof*/ &RREAD, 18);
goto L_040D;
L_040F:
WARN(1, _imp_str_literal("Bad type of parameter for READ"));
TYPE = 1;
L_040D:
STACK->TYPE = TYPE;
if (TYPE != 8) goto L_0410;
STACK->FORM = 1;
L_0410:
ASSIGN(0);
L_040B:
return;
case_SP_20:;
AMAP(V);
return;
case_SP_3:;
case_SP_4:;
case_SP_5:;
case_SP_6:;
case_SP_7:;
case_SP_8:;
case_SP_9:;
VMAP(V, TYPEMAP[N]);
V->FORMAT = LENMAP[N];
return;
case_SP_10:;
FLOAT(STACK, FPR());
return;
case_SP_11:;
X = /*%A*/ /*addressof*/ &V->STACK;
STACK = /*%A*/ /*addressof*/ &X->STACK;
OPERATE(16, V, X);
V->STACK = STACK;
STACK = V;
return;
case_SP_12:;
ADVANCE(V, 4, 0);
return;
case_SP_13:;
X = /*%A*/ /*addressof*/ &V->STACK;
STACK = /*%A*/ /*addressof*/ &X->STACK;
if (/*%A*/ /*addressof*/ &V->INDEX == NIL) goto L_0411;
SIMPLIFY(V);
L_0411:
V->TYPE = 4;
APPLYINDEX(V, X, 1);
V->STACK = STACK;
STACK = V;
return;
case_SP_14:;
STACKINTEGER(10);
case_SP_15:;
SIMPLIFY(STACK);
return;
case_SP_16:;
SETSIZEORTYPE(1, V);
return;
case_SP_17:;
SETSIZEORTYPE(2, V);
return;
case_SP_19:;
APPLYINT(V);
return;
case_SP_18:;
APPLYINTPT(V);
return;
case_SP_22:;
APPLYROUND(V);
return;
case_SP_21:;
APPLYTRUNC(V);
return;
const _imp_string255 FILLID = _imp_str_literal("3L_pascal___fill");
static int FILLEP = 0;
const _imp_string255 FTXTID = _imp_str_literal("3L_pascal___fill_text");
static int FTXTEP = 0;
const _imp_string255 SAFEID = _imp_str_literal("3L_pascal___safe");
static int SAFEEP = 0;
const _imp_string255 EMPTYID = _imp_str_literal("3L_pascal___empty");
static int EMPTYEP = 0;
const _imp_string255 EOLNID = _imp_str_literal("3L_pascal___eoln_error");
static int EOLNEP = 0;
const _imp_string255 READLNID = _imp_str_literal("3L_pascal___read_ln");
static int READLNEP = 0;
const _imp_string255 WRITELNID = _imp_str_literal("3L_pascal___write_ln");
static int WRITELNEP = 0;
const _imp_string255 WRITECID = _imp_str_literal("3L_pascal___write_char");
static int WRITECEP = 0;
void MAKESAFE(struct STACKFM * F, int EOF) {
struct STACKFM *P;
struct STACKFM *B;
struct STACKFM *V2;
struct STACKFM *V3;
SIMPLIFY(/*%A*/ /*addressof*/ &F);
ADVANCE(/*%A*/ /*addressof*/ &F, 1, 0);
P = COPY(/*%A*/ /*addressof*/ &F);
B = COPY(/*%A*/ /*addressof*/ &F);
ADVANCE(B, 1, 4);
if (B->BASE >= 128) goto L_0412;
if (ACTIVITY[B->BASE] >= 0) goto L_0413;
L_0412:
V2 = COPY(B);
V3 = COPY(P);
goto L_0414;
L_0413:
V2 = NIL;
V3 = NIL;
L_0414:
LOAD(B, 3);
P->FLAGS = P->FLAGS | 128;
LOAD(P, 4);
VMAP(B, 1);
ADVANCE(B, 1, 0);
B->FLAGS = B->FLAGS | 128;
LOAD(B, 5);
COMPARE(P, B);
RELEASEANDDROPPAIR(P, B);
if (EOF != 0) goto L_0415;
DOCONDITIONALEXTERNAL(4, FTXTID, /*%A*/ /*addressof*/ &FTXTEP);
goto L_0416;
L_0415:
DOCONDITIONALEXTERNAL(4, SAFEID, /*%A*/ /*addressof*/ &SAFEEP);
L_0416:
F = F | 128;
if (V2 == NIL) goto L_0417;
REMEMBER(3, V2);
REMEMBER(4, V3);
RELEASEANDDROPPAIR(V2, V3);
V2 = REGISTER(3);
V2->FORM = 1;
REMEMBER(5, V2);
RELEASEANDDROP(V2);
L_0417:
} /* MAKESAFE */
void ONTOBOOLEAN(struct STACKFM * F, int DISP, int KNOWN) {
ADVANCE(/*%A*/ /*addressof*/ &F, 1, 4);
F = F | /*indirectthrough*/ *KNOWN;
LOAD(/*%A*/ /*addressof*/ &F, 3);
VMAP(/*%A*/ /*addressof*/ &F, 4);
ADVANCE(/*%A*/ /*addressof*/ &F, 4, /*indirectthrough*/ *DISP);
F = F | 128;
} /* ONTOBOOLEAN */
void EOF(struct STACKFM * F, int TEXT) {
if (/*indirectthrough*/ *TEXT == 0) goto L_0418;
MAKESAFE(F, 0);
L_0418:
ONTOBOOLEAN(F, 12, 0);
} /* EOF */
void EOLN(struct STACKFM * F) {
MAKESAFE(F, 1);
ONTOBOOLEAN(F, 13, 128);
} /* EOLN */
case_SP_41:;
STACK = /*%A*/ /*addressof*/ &STACK->STACK;
SIMPLIFY(V);
ADVANCE(V, 1, 0);
X = COPY(V);
Y = COPY(V);
LOAD(Y, 4);
ADVANCE(V, 1, 4);
V->FLAGS = V->FLAGS | 128;
LOAD(V, 3);
V->FORM = 1;
Z = COPY(V);
ADVANCE(V, 1, 8);
V->FLAGS = V->FLAGS | 128;
OPERATE(4, Y, V);
ADVANCE(Z, 1, 0);
Z->FLAGS = Z->FLAGS | 128;
COMPARE(Y, Z);
RELEASEANDDROPPAIR(Z, Y);
DOCONDITIONALEXTERNAL(4, FILLID, /*%A*/ /*addressof*/ &FILLEP);
Y = REGISTER(4);
SIMPLE(Y, X);
RELEASEANDDROPPAIR(X, Y);
return;
case_SP_42:;
STACK = /*%A*/ /*addressof*/ &STACK->STACK;
MAKESAFE(V, 1);
ADVANCE(V, 1, 0);
Y = REGISTER(4);
OPERATE(4, Y, LITERAL(1));
SIMPLE(Y, V);
RELEASEANDDROPPAIR(V, Y);
return;
case_SP_43:;
STACK = /*%A*/ /*addressof*/ &STACK->STACK;
MAKESAFE(V, 1);
RELEASEANDDROP(V);
V = REGISTER(4);
V->STACK = STACK;
STACK = V;
return;
case_SP_44:;
STACK = /*%A*/ /*addressof*/ &STACK->STACK;
MAKESAFE(V, 1);
Y = REGISTER(4);
X = REGISTER(2);
PLANT1(68157440 | 4194304 | 8388608, 4, 2, 1);
SIMPLE(Y, V);
RELEASEANDDROPPAIR(V, Y);
X->STACK = STACK;
STACK = X;
return;
case_SP_45:;
STACK = /*%A*/ /*addressof*/ &STACK->STACK;
ADVANCE(V, 1, 4);
LOAD(V, 3);
RELEASEANDDROP(V);
DO(READLNID, /*%A*/ /*addressof*/ &READLNEP, 0);
return;
case_SP_46:;
EOLN(V);
return;
case_SP_47:;
EOF(V, 0);
return;
case_SP_48:;
EOF(V, 1);
return;
case_SP_49:;
STACK = /*%A*/ /*addressof*/ &STACK->STACK;
SIMPLIFY(V);
ADVANCE(V, 1, 0);
X = COPY(V);
Y = COPY(V);
ADVANCE(Y, 1, 4);
Y->FLAGS = Y->FLAGS | 128;
LOAD(X, 4);
LOAD(Y, 3);
Y->FORM = 1;
Y->DISP = 4;
Y->FLAGS = Y->FLAGS | 128;
Z = COPY(Y);
Z->DISP = 8;
OPERATE(4, X, Z);
LOAD(X, 4);
COMPARE(X, Y);
RELEASEANDDROPPAIR(Y, X);
DOCONDITIONALEXTERNAL(5, EMPTYID, /*%A*/ /*addressof*/ &EMPTYEP);
X = REGISTER(4);
SIMPLE(X, V);
RELEASEANDDROPPAIR(X, V);
return;
case_SP_50:;
STACK = /*%A*/ /*addressof*/ &STACK->STACK;
SIMPLIFY(V);
ADVANCE(V, 1, 0);
X = COPY(V);
Y = COPY(V);
ADVANCE(Y, 1, 4);
Y->FLAGS = Y->FLAGS | 128;
LOAD(X, 4);
LOAD(Y, 3);
OPERATE(4, X, LITERAL(1));
LOAD(X, 4);
Y->FORM = 1;
Y->DISP = 4;
Y->FLAGS = Y->FLAGS | 128;
COMPARE(X, Y);
RELEASEANDDROPPAIR(Y, X);
DOCONDITIONALEXTERNAL(5, EMPTYID, /*%A*/ /*addressof*/ &EMPTYEP);
X = REGISTER(4);
SIMPLE(X, V);
RELEASEANDDROPPAIR(X, V);
return;
case_SP_51:;
STACK = /*%A*/ /*addressof*/ &STACK->STACK;
ADVANCE(V, 1, 4);
LOAD(V, 3);
RELEASEANDDROP(V);
DOCONDITIONALEXTERNAL(7, WRITELNID, /*%A*/ /*addressof*/ &WRITELNEP);
return;
case_SP_52:;
{ /*%begin*/
struct STACKFM *C;
struct STACKFM *W;
struct STACKFM *BP;
struct STACKFM *FCB;
struct STACKFM *Z;
SIMPLIFY(V);
C = /*%A*/ /*addressof*/ &V->STACK;
W = /*%A*/ /*addressof*/ &C->STACK;
STACK = /*%A*/ /*addressof*/ &W->STACK;
if (!(ICONST(W))) goto L_0419;
if (W->DISP != 1) goto L_0419;
RELEASEANDDROP(W);
ADVANCE(V, 1, 0);
BP = COPY(V);
FCB = COPY(V);
ADVANCE(FCB, 1, 4);
LOAD(BP, 4);
FCB->FLAGS = FCB->FLAGS | 128;
LOAD(FCB, 3);
LOADUP(C);
PLANT1(67108864 | 4194304 | 8388608, 4, C->BASE, 1);
RELEASEANDDROP(C);
FCB->FORM = 1;
FCB->DISP = 4;
FCB->FLAGS = FCB->FLAGS | 128;
COMPARE(BP, FCB);
RELEASEANDDROPPAIR(FCB, BP);
DOCONDITIONALEXTERNAL(4, EMPTYID, /*%A*/ /*addressof*/ &EMPTYEP);
BP = REGISTER(4);
SIMPLE(BP, V);
RELEASEANDDROPPAIR(BP, V);
goto L_041A;
L_0419:
LOAD(W, 2);
LOAD(C, 3);
AMAP(V);
LOAD(V, 4);
RELEASEANDDROPPAIR(W, C);
RELEASEANDDROP(V);
DO(WRITECID, /*%A*/ /*addressof*/ &WRITECEP, 0);
L_041A:
}
return;
case_SP_53:;
return;
void DOREALFN(int FN) {
int REG;
LOAD(V, 26);
REG = FPR();
CLAIM(REG);
PLANT9(/*indirectthrough*/ *FN, 0, REG, V->BASE);
RELEASE(V->BASE);
V->BASE = REG;
} /* DOREALFN */
case_SP_54:;
DOREALFN(239108480);
return;
case_SP_55:;
DOREALFN(243302784);
return;
case_SP_56:;
DOREALFN(244351360);
return;
case_SP_57:;
DOREALFN(241205632);
return;
case_SP_58:;
DOREALFN(242254208);
return;
case_SP_59:;
DOREALFN(248545664);
return;
} /* SPECIALCALL */
void CALL(int TIDY) {
struct STACKFM *V;
struct STACKFM *TEMP;
struct STACKFM *X;
struct STACKFM *W;
struct STACKFM WORK;
int EP;
int FLAGS;
int EXTRA;
int OP;
int BASEREG;
V = STACK;
STACK = /*%A*/ /*addressof*/ &STACK->STACK;
FLAGS = V->FLAGS;
if (FLAGS & 512 == 0) goto L_041B;
L_041C:
if (/*%A*/ /*addressof*/ &V->PARAMS == NIL) goto L_041D;
V->PARAMS = STACK;
STACK = /*%A*/ /*addressof*/ &V->PARAMS;
V->PARAMS = /*%A*/ /*addressof*/ &V->PARAMS;
goto L_041C;
L_041D:
SPECIALCALL(V->PRIM);
DROP(V);
return;
L_041B:
BASEREG = 1;
if (FLAGS & 524288 == 0) goto L_041E;
if (V->FLAGS & 8 != 0) goto L_041E;
if (V->TYPE == 8) goto L_041F;
if (V->TYPE != 9) goto L_041E;
L_041F:
BASEREG = 2;
L_041E:
PASSPARAMETERS(V, /*%A*/ /*addressof*/ &EXTRA, BASEREG);
if (ACTIVEREGISTERS == 0) goto L_0420;
HAZARDALL();
L_0420:
ASSIGNLOCK = 0;
ATTRIBUTES = ATTRIBUTES | 64;
TEMP = NIL;
if (BASEREG != 2) goto L_0421;
TEMP = CLAIMWORKAREA(ITEMSIZE(V->FORMAT), V->TYPE);
TEMP->FORMAT = V->FORMAT;
W = COPY(TEMP);
AMAP(W);
LOAD(W, 1);
RELEASEANDDROP(W);
L_0421:
EP = V->DISP;
if (FLAGS & 1024 == 0) goto L_0422;
if (FLAGS & 256 == 0) goto L_0423;
FAIL(_imp_str_literal("XP-call"));
L_0423:
XCALL(EP, 0, 1);
goto L_0424;
L_0422:
if (FLAGS & 4 != 0) goto L_0425;
if (V->BASE != 0) goto L_0425;
if (/*%A*/ /*addressof*/ &V->RECORD == NIL) goto L_0426;
L_0425:
W = COPY(V);
W->TYPE = 1;
W->FORM = 1;
W->AREA = 0;
AMAP(W);
LOAD(W, 5);
RELEASEANDDROP(W);
PRIM(54);
goto L_0424;
L_0426:
if (FLAGS & 256 == 0) goto L_0427;
FAIL(_imp_str_literal("P-call"));
L_0427:
if (FLAGS & 65536 == 0) goto L_0428;
if (LOCALDISPLAY != 0) goto L_0429;
FAIL(_imp_str_literal("No local display"));
L_0429:
X = LOCALINTEGER(LOCALDISPLAY);
LOADADDRESS(X, 9);
RELEASEANDDROP(X);
L_0428:
DIR2(20, EP);
/*indirectthrough*/ *CA = /*indirectthrough*/ */*indirectthrough*/ *CA + 4;
REFS = REFS + 1;
L_0424:
if (EXTRA == 0) goto L_042A;
POPSTACK(EXTRA);
L_042A:
FORGETEVERYTHING();
if (FLAGS & 524288 == 0) goto L_042B;
if (TEMP != NIL) goto L_042C;
TEMP = LITERAL(0);
TEMP->TYPE = V->TYPE;
TEMP->FORMAT = V->FORMAT;
TEMP->BASE = 1;
if (FLAGS & 8 == 0) goto L_042D;
TEMP->FORM = 1;
TEMP->BASE = 1;
goto L_042E;
L_042D:
if (6 > TEMP->TYPE) goto L_042F;
if (TEMP->TYPE > 7) goto L_042F;
TEMP->BASE = 18;
TEMP->TYPE = 7;
L_042F:
L_042E:
CLAIM(TEMP->BASE);
L_042C:
TEMP->STACK = STACK;
STACK = TEMP;
goto L_0430;
L_042B:
if (FLAGS & 2097152 == 0) goto L_0431;
PLANT1(19922944, 1, 0, NOTHING());
L_0431:
L_0430:
if (FLAGS & 2048 == 0) goto L_0432;
UNCONDJUMP = /*indirectthrough*/ *CA;
L_0432:
DROP(V);
} /* CALL */
void PRIM(int N) {
int FOR;
int REG;
int PAR;
if (1 > /*indirectthrough*/ *N) goto L_0433;
if (/*indirectthrough*/ *N <= 56) goto L_0434;
L_0433:
FAIL(_imp_str_literal("Prim "));
L_0434:
if (DIAG & 16 == 0) goto L_0435;
MONITOR(NIL,
_imp_join((_imp_string)(_imp_str_literal("Prim ")), (_imp_string)(_imp_ITOS(/*indirectthrough*/ *N, 0))));
L_0435:
FOR = CORRUPTS[/*indirectthrough*/ *N];
PAR = PRIMPARAMETER[/*indirectthrough*/ *N];
REG = 1;
L_0436:
if (FOR == 0) goto L_0437;
if (FOR & 1 == 0) goto L_0438;
if (PAR & 1 != 0) goto L_0439;
HAZARD(REG);
goto L_043A;
L_0439:
if (ACTIVITY[REG] <= 1) goto L_043B;
HAZARD(REG);
L_043B:
L_043A:
FORGET(REG);
L_0438:
REG = REG + 1;
FOR = (unsigned int)FOR >> 1;
PAR = (unsigned int)PAR >> 1;
goto L_0436;
L_0437:
DIR2(25, /*indirectthrough*/ *N);
/*indirectthrough*/ *CA = /*indirectthrough*/ */*indirectthrough*/ *CA + 4;
REFS = REFS + 1;
} /* PRIM */
void SWITCHLABEL(int TAG) {
DIR2(7, VAR(TAG)->AREA + POPPEDVALUE());
UNCONDJUMP = -1;
ASSIGNLOCK = 0;
MARKUSERLABEL();
FORGETEVERYTHING();
} /* SWITCHLABEL */
void SWITCHJUMP(int TAG) {
struct STACKFM *X;
X = STACK;
STACK = /*%A*/ /*addressof*/ &STACK->STACK;
LOAD(X, 2);
RELEASEANDDROP(X);
PRIM(4);
DUMPWORD(-409800443);
DIR2(29, VAR(TAG)->FORMAT);
/*indirectthrough*/ *CA = /*indirectthrough*/ */*indirectthrough*/ *CA + 4;
UNCONDJUMP = /*indirectthrough*/ *CA;
} /* SWITCHJUMP */
void SAVEWSP(void) {
struct STACKFM *D;
if (WSPSAVE != 0) goto L_043C;
FRAME = (FRAME & (~3)) - 4;
WSPSAVE = FRAME;
L_043C:
D = LOCALINTEGER(WSPSAVE);
PLANT2(67108864, 13, D);
RELEASEANDDROP(D);
} /* SAVEWSP */
void EVENTTRAP(int BITS) {
int LAB;
struct STACKFM *D;
LAB = TAG();
SAVEWSP();
JUMPFORWARD(LAB, 7);
EVENTBITS = /*indirectthrough*/ *BITS;
EVENTBODY = JLAB;
EVENTLABEL = NEWLABEL();
DEFINELABEL(EVENTLABEL);
MARKUSERLABEL();
FORGETEVERYTHING();
D = LOCALINTEGER(WSPSAVE);
PLANT2(68157440, 13, D);
RELEASEANDDROP(D);
ATTRIBUTES = ATTRIBUTES | 64;
} /* EVENTTRAP */
void SIGNALEVENT(int EVENT) {
struct STACKFM *E;
struct STACKFM *SUBEVENT;
struct STACKFM *EXTRA;
EXTRA = STACK;
SUBEVENT = /*%A*/ /*addressof*/ &EXTRA->STACK;
STACK = /*%A*/ /*addressof*/ &SUBEVENT->STACK;
E = LITERAL(EVENT);
LOADTRIO(E, 2, SUBEVENT, 3, EXTRA, 4);
RELEASEANDDROPPAIR(E, SUBEVENT);
RELEASEANDDROP(EXTRA);
PRIM(1);
UNCONDJUMP = /*indirectthrough*/ *CA;
ATTRIBUTES = ATTRIBUTES | 64;
} /* SIGNALEVENT */
void SETPENDINGFOR(int V) {
int MASK;
MASK = 0;
if (PENDING != 61) goto L_043D;
MASK = 2;
goto L_043E;
L_043D:
if (PENDING != 35) goto L_043F;
MASK = 5;
goto L_043E;
L_043F:
if (PENDING != 60) goto L_0440;
MASK = 4;
goto L_043E;
L_0440:
if (PENDING != 62) goto L_0441;
MASK = 1;
goto L_043E;
L_0441:
if (PENDING != 40) goto L_0442;
MASK = 6;
goto L_043E;
L_0442:
if (PENDING != 41) goto L_0443;
MASK = 3;
goto L_043E;
L_0443:
if (PENDING != 116) goto L_0444;
MASK = 5;
goto L_043E;
L_0444:
if (PENDING != 107) goto L_0445;
MASK = 2;
goto L_043E;
L_0445:
FAIL(_imp_str_literal("Bad cc"));
L_043E:
if (INVERT == 0) goto L_0446;
/*indirectthrough*/ *V = /*indirectthrough*/ *-/*indirectthrough*/ *V;
INVERT = 0;
L_0446:
PENDING = 35;
if (/*indirectthrough*/ *V != 0) goto L_0447;
if (MASK & 2 != 0) goto L_0448;
L_0447:
if (/*indirectthrough*/ *V <= 0) goto L_0449;
if (MASK & 1 != 0) goto L_0448;
L_0449:
if (/*indirectthrough*/ *V >= 0) goto L_044A;
if (MASK & 4 == 0) goto L_044A;
L_0448:
PENDING = 61;
L_044A:
PLANT1(22020096 | 1048576, 0, 1, JUST(1));
} /* SETPENDINGFOR */
void TESTZERO(struct STACKFM * V) {
struct STACKFM *W;
int OP;
int X;
void TESTSHORTBITS(struct STACKFM * V, int MASK) {
int OP;
OP = 17825792;
struct STACKFM *W;
MASK = MASK & 65535;
V = COPY(/*%A*/ /*addressof*/ &V);
if (MASK & 255 != 0) goto L_044B;
ADVANCE(/*%A*/ /*addressof*/ &V, 4, 1);
LOADUP(/*%A*/ /*addressof*/ &V);
PLANT1(17825792, V, 0, IMMEDIATE((unsigned int)MASK >> 8));
goto L_044C;
L_044B:
if (MASK > 255) goto L_044D;
ADVANCE(/*%A*/ /*addressof*/ &V, 4, 0);
LOADUP(/*%A*/ /*addressof*/ &V);
PLANT1(17825792, V, 0, IMMEDIATE(MASK));
goto L_044C;
L_044D:
W = COPY(/*%A*/ /*addressof*/ &V);
ADVANCE(/*%A*/ /*addressof*/ &V, 4, 0);
ADVANCE(W, 4, 1);
LOADUP(/*%A*/ /*addressof*/ &V);
LOADUP(W);
PLANT1(17825792, V, 0, IMMEDIATE(MASK & 255));
PLANT1(17825792 | -536870912, W->BASE, 0, IMMEDIATE((unsigned int)MASK >> 8));
RELEASEANDDROP(W);
L_044C:
RELEASEANDDROP(/*%A*/ /*addressof*/ &V);
} /* TESTSHORTBITS */
void TESTINTEGERBITS(struct STACKFM * V, int MASK) {
int X;
int OP;
LOADUP(/*%A*/ /*addressof*/ &V);
OP = 17825792;
X = 16;
L_044E:
if (MASK == 0) goto L_044F;
L_0450:
if (MASK & 3 != 0) goto L_0451;
MASK = (unsigned int)MASK >> 2;
X = X - 1;
goto L_0450;
L_0451:
PLANT1(OP, V, 0, ROT(MASK & 255, X & 15));
MASK = (unsigned int)MASK >> 8;
X = X - 4;
OP = OP | -536870912;
goto L_044E;
L_044F:
if (X != 16) goto L_0452;
PLANT1(OP, V, 0, IMMEDIATE(0));
L_0452:
} /* TESTINTEGERBITS */
if (DIAG & 256 == 0) goto L_0453;
MONITOR(V, _imp_str_literal("Tzero"));
L_0453:
OPTIMISE(V, 1);
if (V->OPER == 0) goto L_0454;
W = /*%A*/ /*addressof*/ &V->LINK;
if (PENDING == 61) goto L_0455;
if (PENDING == 35) goto L_0455;
if (PENDING == 116) goto L_0455;
if (PENDING != 107) goto L_0456;
L_0455:
if (V->OPER != 9) goto L_0456;
if (!(ICONST(W))) goto L_0456;
V->OPER = 0;
V->LINK = NIL;
if (V->TYPE != 2) goto L_0457;
TESTSHORTBITS(V, W->DISP);
goto L_0458;
L_0457:
if (V->TYPE != 4) goto L_0459;
LOADUP(V);
PLANT1(17825792, V->BASE, 0, IMMEDIATE(W->DISP & 255));
goto L_0458;
L_0459:
TESTINTEGERBITS(V, W->DISP);
L_0458:
RELEASEANDDROP(W);
return;
L_0456:
LOADUP(V);
L_0454:
if (V->TYPE < 6) goto L_045A;
LOADUP(V);
PLANT8(244379920 | 8, V->BASE, 0);
goto L_045B;
L_045A:
if (!(ICONST(V))) goto L_045C;
SETPENDINGFOR(V->DISP);
goto L_045B;
L_045C:
LOADUP(V);
PLANT1(22020096, V->BASE, 0, NOTHING());
if (PENDING != 35) goto L_045D;
PENDINGKNOWNREGISTER = V->BASE;
PENDINGKNOWN = 0;
L_045D:
L_045B:
} /* TESTZERO */
void COMPTOSTRING(struct STACKFM * S, struct STACKFM * X) {
AMAP(S);
LOADPAIR(S, 3, /*%A*/ /*addressof*/ &X, 2);
PRIM(2);
} /* COMPTOSTRING */
void COMPARESTRINGS(struct STACKFM * LEFT, struct STACKFM * RIGHT) {
struct STACKFM *W;
if (LEFT == 0) goto L_045E;
EVALUATESTRINGEXPRESSION(/*%A*/ /*addressof*/ &LEFT);
L_045E:
if (RIGHT == 0) goto L_045F;
EVALUATESTRINGEXPRESSION(/*%A*/ /*addressof*/ &RIGHT);
L_045F:
SIMPLIFY(/*%A*/ /*addressof*/ &LEFT);
SIMPLIFY(/*%A*/ /*addressof*/ &RIGHT);
RIGHT = COPY(/*%A*/ /*addressof*/ &RIGHT);
LEFT = COPY(/*%A*/ /*addressof*/ &LEFT);
if (RIGHT != 1) goto L_0460;
if (LEFT == 8) goto L_0461;
LOADUP(/*%A*/ /*addressof*/ &LEFT);
PLANT1(24117248, 0, LEFT, IMMEDIATE(1));
goto L_0462;
L_0461:
if (LEFT != 1) goto L_0463;
PLANT1(22020096 | 1048576, 0, 1, JUST(1));
goto L_0462;
L_0463:
LEFT = 4;
TESTZERO(/*%A*/ /*addressof*/ &LEFT);
L_0462:
goto L_0464;
L_0460:
if (LEFT != 1) goto L_0465;
if (RIGHT == 8) goto L_0466;
LOADUP(/*%A*/ /*addressof*/ &RIGHT);
PLANT1(24117248, 0, RIGHT, IMMEDIATE(1));
goto L_0467;
L_0466:
RIGHT = 4;
TESTZERO(/*%A*/ /*addressof*/ &RIGHT);
L_0467:
INVERT = INVERT ^ 1;
goto L_0464;
L_0465:
if (RIGHT == 8) goto L_0468;
COMPTOSTRING(/*%A*/ /*addressof*/ &LEFT, /*%A*/ /*addressof*/ &RIGHT);
goto L_0464;
L_0468:
if (LEFT == 8) goto L_0469;
COMPTOSTRING(/*%A*/ /*addressof*/ &RIGHT, /*%A*/ /*addressof*/ &LEFT);
INVERT = INVERT ^ 1;
goto L_0464;
L_0469:
AMAP(/*%A*/ /*addressof*/ &LEFT);
AMAP(/*%A*/ /*addressof*/ &RIGHT);
LOADPAIR(/*%A*/ /*addressof*/ &LEFT, 2, /*%A*/ /*addressof*/ &RIGHT, 3);
PRIM(9);
L_0464:
RELEASEANDDROPPAIR(/*%A*/ /*addressof*/ &LEFT, /*%A*/ /*addressof*/ &RIGHT);
} /* COMPARESTRINGS */
void COMPARERECORDS(struct STACKFM * L, struct STACKFM * R) {
struct STACKFM *SIZE;
int N;
int OP;
void FIXSET(struct STACKFM * L) {
SIMPLIFY(/*%A*/ /*addressof*/ &L);
if (/*%A*/ /*addressof*/ &L == NIL) goto L_046A;
BUILDSET(/*%A*/ /*addressof*/ &L);
goto L_046B;
L_046A:
if (L & 16384 == 0) goto L_046C;
L = 1;
L_046C:
L_046B:
L = ((long)256 / (long)8);
} /* FIXSET */
void COMPARESET(struct STACKFM * L, struct STACKFM * R, int CC) {
PENDING = CC;
AMAP(/*%A*/ /*addressof*/ &L);
AMAP(/*%A*/ /*addressof*/ &R);
LOADPAIR(/*%A*/ /*addressof*/ &L, 9, /*%A*/ /*addressof*/ &R, 12);
PRIM(32);
} /* COMPARESET */
if (L != 13) goto L_046D;
FIXSET(/*%A*/ /*addressof*/ &L);
L_046D:
if (R->TYPE != 13) goto L_046E;
FIXSET(R);
L_046E:
if (L != 1) goto L_046F;
if (R->TYPE != 1) goto L_0470;
PLANT1(22020096 | 1048576, 0, 1, JUST(1));
goto L_0471;
L_0470:
INVERT = INVERT ^ 1;
COMPARERECORDS(R, /*%A*/ /*addressof*/ &L);
L_0471:
return;
L_046F:
N = ITEMSIZE(L);
if (N > 0) goto L_0472;
FAIL(_imp_str_literal("Null area?"));
L_0472:
if (R->TYPE != 1) goto L_0473;
if (N == 32) goto L_0474;
FAIL(_imp_str_literal("Bad set size"));
L_0474:
void DOSET(int CODE) {
PENDING = CODE;
LOADADDRESS(/*%A*/ /*addressof*/ &L, 1);
PRIM(50);
} /* DOSET */
if (PENDING == 61) goto L_0475;
if (PENDING != 35) goto L_0476;
L_0475:
DOSET(PENDING);
goto L_0477;
L_0476:
if (INVERT != 0) goto L_0478;
if (PENDING != 62) goto L_0479;
DOSET(35);
goto L_047A;
L_0479:
if (PENDING != 60) goto L_047B;
PENDING = 128 + 48;
goto L_047A;
L_047B:
if (PENDING != 41) goto L_047C;
PENDING = 70;
goto L_047A;
L_047C:
if (PENDING != 40) goto L_047D;
DOSET(61);
goto L_047A;
L_047D:
FAIL(_imp_str_literal("Null/1"));
L_047A:
goto L_0477;
L_0478:
if (PENDING != 62) goto L_047E;
PENDING = 128 + 48;
goto L_047F;
L_047E:
if (PENDING != 60) goto L_0480;
DOSET(35);
goto L_047F;
L_0480:
if (PENDING != 41) goto L_0481;
DOSET(61);
goto L_047F;
L_0481:
if (PENDING != 40) goto L_0482;
PENDING = 70;
goto L_047F;
L_0482:
FAIL(_imp_str_literal("Null/2"));
L_047F:
L_0477:
INVERT = 0;
goto L_0483;
L_0473:
if (L != 13) goto L_0484;
if (13 != R->TYPE) goto L_0484;
if (N == 32) goto L_0485;
FAIL(_imp_str_literal("Bad set size"));
L_0485:
if (PENDING == 61) goto L_0486;
if (PENDING != 35) goto L_0487;
L_0486:
AMAP(/*%A*/ /*addressof*/ &L);
AMAP(R);
LOADPAIR(/*%A*/ /*addressof*/ &L, 1, R, 2);
PRIM(51);
goto L_0488;
L_0487:
if (PENDING != 60) goto L_0489;
COMPARESET(/*%A*/ /*addressof*/ &L, R, 35);
goto L_048A;
L_0489:
if (PENDING != 62) goto L_048B;
COMPARESET(R, /*%A*/ /*addressof*/ &L, 35);
goto L_048A;
L_048B:
if (PENDING != 40) goto L_048C;
COMPARESET(R, /*%A*/ /*addressof*/ &L, 61);
goto L_048A;
L_048C:
if (PENDING != 41) goto L_048D;
COMPARESET(/*%A*/ /*addressof*/ &L, R, 61);
goto L_048A;
L_048D:
FAIL(_imp_str_literal("bad set comparison"));
L_048A:
L_0488:
goto L_0483;
L_0484:
AMAP(/*%A*/ /*addressof*/ &L);
AMAP(R);
SIZE = LITERAL(N);
LOADTRIO(/*%A*/ /*addressof*/ &L, 2, R, 3, SIZE, 1);
RELEASEANDDROP(SIZE);
PRIM(40);
L_0483:
} /* COMPARERECORDS */
void TRYFORZERO(struct STACKFM * V, int MOD) {
int OLD;
OLD = PENDING;
if (V->DISP != /*indirectthrough*/ *MOD) goto L_048E;
if (PENDING != 60) goto L_048F;
PENDING = 40;
goto L_0490;
L_048F:
if (PENDING != 41) goto L_0491;
PENDING = 62;
L_0491:
L_0490:
goto L_0492;
L_048E:
if (V->DISP != /*indirectthrough*/ *-/*indirectthrough*/ *MOD) goto L_0493;
if (PENDING != 62) goto L_0494;
PENDING = 41;
goto L_0495;
L_0494:
if (PENDING != 40) goto L_0496;
PENDING = 60;
L_0496:
L_0495:
L_0493:
L_0492:
if (PENDING == OLD) goto L_0497;
V->DISP = 0;
L_0497:
} /* TRYFORZERO */
void COMPAREFLOATING(struct STACKFM * LEFT, struct STACKFM * RIGHT) {
int SUITABLECONST(struct STACKFM * L, struct STACKFM * R) {
int OP;
int N;
if (ICONST(/*%A*/ /*addressof*/ &R)) goto L_0498;
return 0 /*FALSE*/;
L_0498:
if (0 > R) goto L_0499;
if (R > 5) goto L_0499;
OP = 244379920;
N = R;
goto L_049A;
L_0499:
if (-5 > R) goto L_049B;
if (R > 0) goto L_049B;
OP = 246477072;
N = -R;
goto L_049A;
L_049B:
if (R != 10) goto L_049C;
OP = 244379920;
N = 7;
goto L_049A;
L_049C:
if (R != -10) goto L_049D;
OP = 246477072;
N = 7;
goto L_049A;
L_049D:
return 0 /*FALSE*/;
L_049A:
LOAD(/*%A*/ /*addressof*/ &L, 26);
PLANT8(OP | 8, L, N);
return 1 /*TRUE*/;
} /* SUITABLECONST */
if (!(SUITABLECONST(LEFT, /*%A*/ /*addressof*/ &RIGHT))) goto L_049E;
return;
L_049E:
if (!(SUITABLECONST(/*%A*/ /*addressof*/ &RIGHT, LEFT))) goto L_049F;
INVERT = INVERT ^ 1;
return;
L_049F:
LOAD(LEFT, 26);
LOAD(/*%A*/ /*addressof*/ &RIGHT, 26);
PLANT8(244379920, LEFT->BASE, RIGHT);
} /* COMPAREFLOATING */
void COMPARE(struct STACKFM * LEFT, struct STACKFM * RIGHT) {
int LAB;
struct STACKFM *W;
void DOCONST(struct STACKFM * A, struct STACKFM * B) {
int N;
int OP;
int V;
LOADUP(/*%A*/ /*addressof*/ &A);
V = B;
if (V < 0) goto L_04A0;
N = IMMEDIATE(V);
OP = 22020096;
goto L_04A1;
L_04A0:
N = IMMEDIATE(-V);
OP = 24117248;
L_04A1:
if (N >= 0) goto L_04A2;
LOADUP(/*%A*/ /*addressof*/ &B);
N = JUST(B);
OP = 22020096;
L_04A2:
PLANT1(OP, A, 0, N);
if (PENDING != 35) goto L_04A3;
PENDINGKNOWNREGISTER = A;
PENDINGKNOWN = 0;
PENDINGKNOWN.DISP = V;
PENDINGKNOWN.TYPE = 1;
L_04A3:
} /* DOCONST */
PENDINGKNOWNREGISTER = 0;
if (CODE == 128 + 63) goto L_04A4;
if (CODE == 128 + 34) goto L_04A4;
UNSIGNED = 0;
L_04A4:
if (PENDINGTAG == 0) goto L_04A5;
LAB = PENDINGTAG;
PENDINGTAG = 0;
W = LITERAL(PENDINGLIT);
if (PENDING == 62) goto L_04A6;
if (PENDING != 41) goto L_04A7;
L_04A6:
if (RIGHT < PENDINGLIT) goto L_04A7;
if (ICONST(/*%A*/ /*addressof*/ &RIGHT)) goto L_04A8;
L_04A7:
LOADUP(LEFT);
COMPARE(LEFT, W);
RELEASEANDDROP(W);
JUMPFORWARD(LAB, 2);
goto L_04A9;
L_04A8:
UNSIGNED = 10;
OPERATE(5, LEFT, W);
RIGHT = RIGHT - PENDINGLIT;
L_04A9:
L_04A5:
if (LEFT->TYPE == 8) goto L_04AA;
if (RIGHT == 8) goto L_04AA;
if (LEFT->OPER == 22) goto L_04AA;
if (RIGHT != 22) goto L_04AB;
L_04AA:
COMPARESTRINGS(LEFT, /*%A*/ /*addressof*/ &RIGHT);
return;
L_04AB:
if (LEFT->TYPE == 9) goto L_04AC;
if (LEFT->TYPE == 13) goto L_04AC;
if (RIGHT == 9) goto L_04AC;
if (RIGHT != 13) goto L_04AD;
L_04AC:
COMPARERECORDS(LEFT, /*%A*/ /*addressof*/ &RIGHT);
return;
L_04AD:
if (!(ICONST(/*%A*/ /*addressof*/ &RIGHT))) goto L_04AE;
if (FLOATING(LEFT)) goto L_04AF;
TRYFORZERO(/*%A*/ /*addressof*/ &RIGHT, 1);
L_04AF:
if (!(ICONST(LEFT))) goto L_04B0;
SETPENDINGFOR(LEFT->DISP - RIGHT);
return;
L_04B0:
if (RIGHT != 0) goto L_04B1;
TESTZERO(LEFT);
return;
L_04B1:
goto L_04B2;
L_04AE:
if (!(ICONST(LEFT))) goto L_04B3;
if (FLOATING(/*%A*/ /*addressof*/ &RIGHT)) goto L_04B4;
TRYFORZERO(LEFT, -1);
L_04B4:
if (LEFT->DISP != 0) goto L_04B5;
TESTZERO(/*%A*/ /*addressof*/ &RIGHT);
INVERT = INVERT ^ 1;
return;
L_04B5:
L_04B3:
L_04B2:
if (FLOATING(LEFT)) goto L_04B6;
if (!(FLOATING(/*%A*/ /*addressof*/ &RIGHT))) goto L_04B7;
L_04B6:
COMPAREFLOATING(LEFT, /*%A*/ /*addressof*/ &RIGHT);
goto L_04B8;
L_04B7:
if (!(ICONST(/*%A*/ /*addressof*/ &RIGHT))) goto L_04B9;
DOCONST(LEFT, /*%A*/ /*addressof*/ &RIGHT);
goto L_04BA;
L_04B9:
if (!(ICONST(LEFT))) goto L_04BB;
DOCONST(/*%A*/ /*addressof*/ &RIGHT, LEFT);
INVERT = INVERT ^ 1;
goto L_04BA;
L_04BB:
LOADUP(LEFT);
LOADUP(/*%A*/ /*addressof*/ &RIGHT);
LOADUP(LEFT);
PLANT1(22020096, LEFT->BASE, 0, JUST(RIGHT));
L_04BA:
L_04B8:
} /* COMPARE */
void COMPAREVALUES(void) {
struct STACKFM *L;
struct STACKFM *R;
R = STACK;
L = /*%A*/ /*addressof*/ &R->STACK;
STACK = /*%A*/ /*addressof*/ &L->STACK;
COMPARE(L, R);
RELEASEANDDROPPAIR(L, R);
} /* COMPAREVALUES */
void COMPAREDOUBLE(void) {
struct STACKFM *L;
struct STACKFM *R;
R = STACK;
L = /*%A*/ /*addressof*/ &R->STACK;
R->STACK = /*%A*/ /*addressof*/ &L->STACK;
if (R->OPER == 0) goto L_04BC;
if (R->OPER != 22) goto L_04BD;
EVALUATESTRINGEXPRESSION(R);
goto L_04BE;
L_04BD:
LOADUP(R);
L_04BE:
L_04BC:
if (PENDING != 62) goto L_04BF;
if (L->DISP < 0) goto L_04BF;
if (!(ICONST(L))) goto L_04BF;
if (R->TYPE > 5) goto L_04BF;
_imp_READSYMBOL(/*%A*/ /*addressof*/ &PENDING);
PENDINGLIT = L->DISP;
PENDINGTAG = TAG();
goto L_04C0;
L_04BF:
COMPARE(L, R);
L_04C0:
RELEASEANDDROP(L);
} /* COMPAREDOUBLE */
void COMPAREADDRESSES(void) {
struct STACKFM *L;
struct STACKFM *R;
R = STACK;
L = /*%A*/ /*addressof*/ &R->STACK;
STACK = /*%A*/ /*addressof*/ &L->STACK;
AMAP(L);
AMAP(R);
COMPARE(L, R);
RELEASEANDDROPPAIR(L, R);
} /* COMPAREADDRESSES */
void STACKCONDITION(void) {
int CC;
struct STACKFM *L;
struct STACKFM *R;
R = STACK;
L = /*%A*/ /*addressof*/ &R->STACK;
STACK = /*%A*/ /*addressof*/ &L->STACK;
COMPARE(L, R);
RELEASEANDDROPPAIR(L, R);
if (PENDING != 61) goto L_04C1;
CC = 1;
goto L_04C2;
L_04C1:
if (PENDING != 60) goto L_04C3;
CC = 2;
goto L_04C2;
L_04C3:
if (PENDING != 40) goto L_04C4;
CC = 3;
goto L_04C2;
L_04C4:
if (PENDING != 62) goto L_04C5;
CC = 4;
goto L_04C2;
L_04C5:
if (PENDING != 41) goto L_04C6;
CC = 5;
goto L_04C2;
L_04C6:
if (PENDING != 35) goto L_04C7;
CC = 6;
goto L_04C2;
L_04C7:
if (PENDING != 116) goto L_04C8;
CC = 8;
goto L_04C2;
L_04C8:
if (PENDING != 102) goto L_04C9;
CC = 9;
goto L_04C2;
L_04C9:
if (PENDING != 70) goto L_04CA;
CC = 7;
goto L_04C2;
L_04CA:
if (PENDING != 128 + 48) goto L_04CB;
CC = 0;
goto L_04C2;
L_04CB:
FAIL(_imp_str_literal("Bad CC"));
L_04C2:
_imp_READSYMBOL(/*%A*/ /*addressof*/ &PENDING);
if (INVERT == 0) goto L_04CC;
CC = REVERSE[CC];
INVERT = 0;
L_04CC:
STACKTRUEORFALSE(CC);
} /* STACKCONDITION */
void GENERALCOMPARE(void) {
int OP;
struct STACKFM *RIGHT;
struct STACKFM *LEFT;
struct STACKFM *RLEN;
struct STACKFM *LLEN;
RLEN = STACK;
LLEN = /*%A*/ /*addressof*/ &RLEN->STACK;
RIGHT = /*%A*/ /*addressof*/ &LLEN->STACK;
LEFT = /*%A*/ /*addressof*/ &RIGHT->STACK;
STACK = /*%A*/ /*addressof*/ &LEFT->STACK;
if (!(ICONST(RLEN))) goto L_04CD;
if (ICONST(LLEN)) goto L_04CE;
L_04CD:
FAIL(_imp_str_literal("variable compare"));
L_04CE:
if (RLEN->DISP != LLEN->DISP) goto L_04CF;
AMAP(LEFT);
AMAP(RIGHT);
LOADTRIO(LEFT, 2, RIGHT, 3, RLEN, 1);
PRIM(40);
goto L_04D0;
L_04CF:
NOTINYET();
L_04D0:
RELEASEANDDROPPAIR(RLEN, LLEN);
RELEASEANDDROPPAIR(RIGHT, LEFT);
} /* GENERALCOMPARE */
void GENERALMOVE(void) {
struct STACKFM *F;
struct STACKFM *T;
struct STACKFM *FLEN;
struct STACKFM *TLEN;
FLEN = STACK;
TLEN = /*%A*/ /*addressof*/ &FLEN->STACK;
F = /*%A*/ /*addressof*/ &TLEN->STACK;
T = /*%A*/ /*addressof*/ &F->STACK;
STACK = /*%A*/ /*addressof*/ &T->STACK;
LOADPAIR(TLEN, 4, FLEN, 5);
LOADPAIR(T, 2, F, 3);
LOADPAIR(TLEN, 4, FLEN, 5);
LOADPAIR(T, 2, F, 3);
RELEASEANDDROPPAIR(FLEN, TLEN);
RELEASEANDDROPPAIR(F, T);
PRIM(7);
FORGETEVERYTHING();
} /* GENERALMOVE */
void RECORDASSIGN(struct STACKFM * FROM, struct STACKFM * TO) {
int LENL;
int LENR;
int INC;
int MOD;
int LOAD;
int R;
int ALIGNED;
ALIGNED = 1;
int ZERO;
void RECORDOP(void) {
if (R >= 0) goto L_04D1;
R = GPR();
L_04D1:
if (LOAD == 0) goto L_04D2;
PLANT2(68157440 | MOD, R, FROM);
L_04D2:
PLANT2(67108864 | MOD, R, TO);
} /* RECORDOP */
LENL = ITEMSIZE(TO->FORMAT);
LENR = ITEMSIZE(FROM->FORMAT);
if (LENL == 0) goto L_04D3;
if (LENR == 0) goto L_04D4;
if (LENR >= LENL) goto L_04D4;
L_04D3:
LENL = LENR;
L_04D4:
if (LENL > 0) goto L_04D5;
return;
L_04D5:
if (LENL & 3 != 0) goto L_04D6;
if (PROPERLYALIGNED(TO, 3)) goto L_04D7;
L_04D6:
ALIGNED = 0;
L_04D7:
ZERO = 0;
if (!(ICONST(FROM))) goto L_04D8;
ZERO = 1;
goto L_04D9;
L_04D8:
if (PROPERLYALIGNED(FROM, 3)) goto L_04DA;
ALIGNED = 0;
L_04DA:
L_04D9:
FORGETDESTINATION(TO);
MAKEAUTOI(TO, 1);
LOAD = 1;
INC = 4;
MOD = 0;
if (ALIGNED != 0) goto L_04DB;
INC = 1;
MOD = 4194304;
TO->TYPE = 4;
L_04DB:
if (ZERO == 0) goto L_04DC;
LOAD = 0;
LOADUP(FROM);
R = FROM->BASE;
goto L_04DD;
L_04DC:
MAKEAUTOI(FROM, TO->TYPE);
R = -1;
L_04DD:
REPEAT(RECORDOP, LITERAL(LENL), INC, 6);
} /* RECORDASSIGN */
void SETASSIGN(struct STACKFM * FROM, struct STACKFM * DEST) {
struct MEMBERFM *M;
struct MEMBERFM *X;
int OP;
OP = FROM->OPER;
int FN;
struct STACKFM *W;
struct STACKFM *INDEX;
struct STACKFM *TO;
TO = COPY(DEST);
if (/*%A*/ /*addressof*/ &FROM->MEMBERS == NIL) goto L_04DE;
BUILDSET(FROM);
L_04DE:
W = /*%A*/ /*addressof*/ &FROM->LINK;
if (W == NIL) goto L_04DF;
FROM->LINK = NIL;
FROM->OPER = 0;
if (FROM->FLAGS & 16384 == 0) goto L_04E0;
FROM = W;
goto L_04E1;
L_04E0:
if (OP == 25) goto L_04E2;
if (OP == 26) goto L_04E2;
if (OP == 27) goto L_04E2;
FAIL(_imp_str_literal("Bad set operator"));
L_04E2:
if (W->FLAGS & 16384 != 0) goto L_04E3;
if (SAME(FROM, TO)) goto L_04E4;
FROM->OPER = OP;
FROM->LINK = W;
LOADUP(FROM);
SETASSIGN(FROM, TO);
RELEASEANDDROP(TO);
return;
L_04E4:
if (/*%A*/ /*addressof*/ &W->MEMBERS == NIL) goto L_04E5;
if (W->MEMBERS > 2) goto L_04E6;
if (OP != 27) goto L_04E5;
L_04E6:
BUILDSET(W);
L_04E5:
LOADADDRESS(TO, 9);
if (OP == 27) goto L_04E7;
if (/*%A*/ /*addressof*/ &W->MEMBERS == NIL) goto L_04E7;
M = /*%A*/ /*addressof*/ &W->MEMBERS;
W->MEMBERS = NIL;
L_04E8:
if (M == NIL) goto L_04E9;
X = M;
M = /*%A*/ /*addressof*/ &M->LINK;
LOADPAIR(TO, 9, /*%A*/ /*addressof*/ &X->A, 2);
if (/*%A*/ /*addressof*/ &X->B == NIL) goto L_04EA;
LOAD(/*%A*/ /*addressof*/ &X->B, 1);
LOADPAIR(TO, 9, /*%A*/ /*addressof*/ &X->A, 2);
RELEASEANDDROP(/*%A*/ /*addressof*/ &X->B);
if (OP != 25) goto L_04EB;
FN = 28;
goto L_04EC;
L_04EB:
FN = 35;
L_04EC:
goto L_04ED;
L_04EA:
if (OP != 25) goto L_04EE;
FN = 20;
goto L_04ED;
L_04EE:
FN = 25;
L_04ED:
RELEASEANDDROP(/*%A*/ /*addressof*/ &X->A);
_imp_DISPOSE(X);
PRIM(FN);
goto L_04E8;
L_04E9:
RELEASEANDDROPPAIR(W, TO);
goto L_04EF;
L_04E7:
AMAP(W);
LOADPAIR(TO, 9, W, 12);
RELEASEANDDROP(W);
if (OP != 25) goto L_04F0;
FN = 29;
goto L_04F1;
L_04F0:
if (OP != 26) goto L_04F2;
FN = 30;
goto L_04F1;
L_04F2:
FN = 31;
L_04F1:
PRIM(FN);
RELEASEANDDROP(TO);
L_04EF:
return;
L_04E3:
L_04E1:
L_04DF:
if (W == NIL) goto L_04F3;
RELEASEANDDROP(W);
L_04F3:
FORGETDESTINATION(TO);
if (FROM->FLAGS & 16384 == 0) goto L_04F4;
void ZERO(int R) {
struct STACKFM *W;
W = LITERAL(0);
LOAD(W, R);
RELEASEANDDROP(W);
} /* ZERO */
LOADADDRESS(TO, 9);
ZERO(1);
ZERO(2);
ZERO(3);
ZERO(4);
PLANT4(134217728 | 8388608 | 2097152, TO->BASE, 15);
PLANT4(134217728 | 8388608, TO->BASE, 15);
goto L_04F5;
L_04F4:
LOADADDRESS(FROM, 12);
LOADADDRESS(TO, 9);
HAZARD(1);
HAZARD(2);
HAZARD(3);
HAZARD(4);
HAZARD(5);
HAZARD(6);
HAZARD(7);
HAZARD(8);
PLANT4(135266304 | 8388608, FROM->BASE, 255);
PLANT4(134217728 | 8388608, TO->BASE, 255);
FORGET(1);
FORGET(2);
FORGET(3);
FORGET(4);
FORGET(5);
FORGET(6);
FORGET(7);
FORGET(8);
L_04F5:
RELEASEANDDROP(TO);
} /* SETASSIGN */
void RESOLVE(int FLAG) {
int LAB;
int INLAB;
INLAB = 0;
int PEND;
int N;
struct STACKFM *S;
struct STACKFM *A;
struct STACKFM *B;
struct STACKFM *C;
N = 0;
if (/*indirectthrough*/ *FLAG & 1 == 0) goto L_04F6;
C = STACK;
STACK = /*%A*/ /*addressof*/ &STACK->STACK;
goto L_04F7;
L_04F6:
N = N | 1;
C = NIL;
L_04F7:
B = STACK;
STACK = /*%A*/ /*addressof*/ &STACK->STACK;
if (/*indirectthrough*/ *FLAG & 2 == 0) goto L_04F8;
A = STACK;
STACK = /*%A*/ /*addressof*/ &STACK->STACK;
goto L_04F9;
L_04F8:
N = N | 2;
A = NIL;
L_04F9:
S = STACK;
STACK = /*%A*/ /*addressof*/ &STACK->STACK;
if (B->OPER == 0) goto L_04FA;
EVALUATESTRINGEXPRESSION(B);
L_04FA:
if (B->TYPE > 5) goto L_04FB;
FIXTOSTRING(B);
L_04FB:
AMAP(S);
AMAP(B);
LOADPAIR(S, 2, B, 3);
RELEASEANDDROPPAIR(S, B);
PRIM(3);
if (/*indirectthrough*/ *FLAG & 4 != 0) goto L_04FC;
PRIM(12);
goto L_04FD;
L_04FC:
if (PENDING == 116) goto L_04FE;
if (PENDING == 107) goto L_04FE;
FAIL(_imp_str_literal("corrupt resolution"));
L_04FE:
PEND = PENDING;
_imp_READSYMBOL(/*%A*/ /*addressof*/ &PENDING);
INLAB = TAG();
if (PEND != 116) goto L_04FF;
LAB = NEWLABEL();
JUMPTO(LAB, 6);
goto L_0500;
L_04FF:
JUMPFORWARD(INLAB, 6);
INLAB = 0;
L_0500:
L_04FD:
CLAIM(2);
CLAIM(8);
CLAIM(4);
CLAIM(7);
if (A == NIL) goto L_0501;
LOADADDRESS(A, 3);
PRIM(18);
RELEASEANDDROP(A);
L_0501:
if (C == NIL) goto L_0502;
LOADADDRESS(C, 3);
PRIM(24);
RELEASEANDDROP(C);
L_0502:
RELEASE(2);
RELEASE(8);
RELEASE(4);
RELEASE(7);
if (INLAB == 0) goto L_0503;
JUMPFORWARD(INLAB, 7);
DEFINELABEL(LAB);
L_0503:
} /* RESOLVE */
void EVALUATESTRINGEXPRESSION(struct STACKFM * V) {
struct STACKFM *W;
W = CLAIMWORKAREA(256, 8);
STRINGASSIGN(V, W);
REPLACE(V, W);
} /* EVALUATESTRINGEXPRESSION */
void STRINGASSIGN(struct STACKFM * R, struct STACKFM * L) {
struct STACKFM *W;
struct STACKFM *LL;
struct STACKFM *DELAYV;
struct STACKFM *Z;
int CONCLENGTH;
CONCLENGTH = 1;
int ALLCONST;
ALLCONST = 1;
int REG;
int DELAY;
DELAY = 0;
int LEN;
LEN = 0;
int HERE;
int LAB;
int N;
_imp_string255 VAL;
VAL = _imp_str_literal("");
int SAFE(struct STACKFM * TARGET, struct STACKFM * CHAIN) {
L_0504:
CONCLENGTH = CONCLENGTH + 1;
if (CHAIN <= 5) goto L_0505;
CONCLENGTH = -1000;
L_0505:
if (ICONSTITEM(/*%A*/ /*addressof*/ &CHAIN)) goto L_0506;
ALLCONST = 0;
L_0506:
if (ALLCONST == 0) goto L_0507;
VAL = _imp_join((_imp_string)(VAL), (_imp_string)(_imp_TOSTRING(CHAIN & 255)));
L_0507:
if (SAME(/*%A*/ /*addressof*/ &TARGET, /*%A*/ /*addressof*/ &CHAIN)) goto L_0508;
if (/*%A*/ /*addressof*/ &TARGET == NIL) goto L_0509;
if (/*%A*/ /*addressof*/ &CHAIN == NIL) goto L_0509;
L_0508:
return 0 /*FALSE*/;
L_0509:
CHAIN = /*%A*/ /*addressof*/ &CHAIN;
if (/*%A*/ /*addressof*/ &CHAIN == NIL) goto L_050A;
goto L_0504;
L_050A:
return 1 /*TRUE*/;
} /* SAFE */
void MOVE1(void) {
FORGET(L->BASE);
FORGET(R->BASE);
SIMPLE(R, L);
} /* MOVE1 */
FORGETDESTINATION(L);
if (R->OPER != 0) goto L_050B;
N = R->BIAS;
if (N == 0) goto L_050C;
if (N != 1) goto L_050D;
L = COPY(L);
L->TYPE = 4;
R = LITERAL(0);
SIMPLE(R, L);
goto L_050E;
L_050D:
if (N >= 0) goto L_050F;
U_100C:
L = COPY(L);
ADVANCE(L, 4, 1);
SIMPLE(R, L);
R = LITERAL(1);
ADVANCE(L, 4, -1);
SIMPLE(R, L);
goto L_050E;
L_050F:
L = COPY(L);
MAKEAUTOI(L, 4);
R = COPY(R);
MAKEAUTOI(R, 4);
REPEAT(MOVE1, LITERAL(N), 1, 6);
L_050E:
RELEASEANDDROPPAIR(L, R);
goto L_0510;
L_050C:
if (R->TYPE > 5) goto L_0511;
if (!(ICONSTITEM(R))) goto L_0512;
goto U_100C;
L_0512:
W = COPY(L);
ADVANCE(W, 4, 1);
SIMPLE(R, W);
RELEASEANDDROP(W);
L = COPY(L);
L->TYPE = 4;
MOVELITERAL(1, L);
RELEASEANDDROP(L);
goto L_0510;
L_0511:
L = COPY(L);
MAKEAUTOI(L, 4);
R = COPY(R);
MAKEAUTOI(R, 4);
W = COPY(R);
W->FORM = 1;
REPEAT(MOVE1, W, 1, 5);
RELEASEANDDROPPAIR(L, R);
L_0510:
return;
L_050B:
void ASSIGNVIAWORK(void) {
struct STACKFM *W;
W = CLAIMWORKAREA(255, 8);
STRINGASSIGN(R, W);
STRINGASSIGN(W, L);
RELEASEANDDROP(W);
} /* ASSIGNVIAWORK */
W = /*%A*/ /*addressof*/ &R->LINK;
if (SAFE(L, W)) goto L_0513;
ASSIGNVIAWORK();
return;
L_0513:
R->OPLINK = 0;
if (CONCLENGTH <= 0) goto L_0514;
if (R->TYPE > 5) goto L_0514;
L = COPY(L);
if (ICONSTITEM(R)) goto L_0515;
ALLCONST = 0;
L_0515:
if (ALLCONST == 0) goto L_0516;
VALUE.STRING = _imp_join((_imp_string)(_imp_TOSTRING(R->DISP & 255)), (_imp_string)(VAL));
Z = CONSTSTRING();
STRINGASSIGN(Z, L);
RELEASEANDDROP(Z);
goto L_0517;
L_0516:
MAKEAUTOI(L, 4);
MOVELITERAL(CONCLENGTH, L);
L_0517:
void ASSIGNPART(void) {
R->OPLINK = 0;
if (ALLCONST != 0) goto L_0514;
SIMPLE(R, L);
L_0514:
} /* ASSIGNPART */
ASSIGNPART();
L_0518:
R = W;
W = /*%A*/ /*addressof*/ &R->LINK;
ASSIGNPART();
RELEASEANDDROP(R);
if (W == NIL) goto L_0519;
goto L_0518;
L_0519:
RELEASEANDDROP(L);
return;
L_051A:
void CONCAT(struct STACKFM * SOURCE) {
struct STACKFM *DEST;
SOURCE = 0;
if (SOURCE > 5) goto L_051A;
DEST = REGISTER(3);
DEST->TYPE = 4;
DEST->FORM = 2;
SIMPLE(/*%A*/ /*addressof*/ &SOURCE, DEST);
RELEASEANDDROP(DEST);
return;
L_051A:
LOADADDRESS(/*%A*/ /*addressof*/ &SOURCE, 4);
PRIM(8);
} /* CONCAT */
LL = COPY(L);
AMAP(LL);
if (!(SAME(L, R))) goto L_051B;
if (/*%A*/ /*addressof*/ &W->LINK != NIL) goto L_051C;
if (W->TYPE > 5) goto L_051C;
LOADUP(LL);
LL->TYPE = 4;
LL->FORM = 1;
R = COPY(LL);
Z = COPY(LL);
OPERATE(4, Z, LITERAL(1));
LOADUP(Z);
LL->INDEX = COPY(Z);
LL->XSIZE = 1;
SIMPLE(W, LL);
SIMPLE(Z, R);
RELEASEANDDROPPAIR(W, Z);
RELEASEANDDROPPAIR(LL, R);
return;
L_051C:
LOAD(LL, 3);
Z = COPY(LL);
Z->TYPE = 4;
Z->FORM = 2;
LOAD(Z, 2);
R = COPY(LL);
LOAD(R, 1);
DROP(R);
LL->INDEX = Z;
LL->XSIZE = 1;
LOAD(LL, 3);
RELEASE(3);
FORGET(3);
ACTIVITY[3] = -1;
LL->BASE = 1;
goto L_051D;
L_051B:
DELAYV = NIL;
L_051E:
if (R->TYPE > 5) goto L_051F;
DELAY = DELAY + 1;
R->OPER = 0;
R->LINK = DELAYV;
DELAYV = R;
R = W;
W = /*%A*/ /*addressof*/ &W->LINK;
goto L_051E;
L_051F:
OPERATE(4, LL, LITERAL(DELAY + 1));
LOAD(LL, 3);
LOAD(LL, 1);
FORGET(3);
ACTIVITY[3] = -1;
if (R == NIL) goto L_0520;
CONCAT(R);
RELEASE(R->BASE);
R->BASE = 0;
if (DELAY == 0) goto L_0521;
DROP(R);
L_0521:
goto L_0522;
L_0520:
LEN = DELAY;
L_0522:
L_051D:
L_0523:
if (W == NIL) goto L_0524;
R = W;
W = /*%A*/ /*addressof*/ &R->LINK;
CONCAT(R);
RELEASEANDDROP(R);
goto L_0523;
L_0524:
LL->TYPE = 4;
LL->FORM = 3;
L_0525:
if (DELAY == 0) goto L_0526;
DELAY = DELAY - 1;
R = DELAYV;
DELAYV = /*%A*/ /*addressof*/ &R->LINK;
R->LINK = NIL;
SIMPLE(R, LL);
if (DELAY == 0) goto L_0527;
RELEASEANDDROP(R);
L_0527:
goto L_0525;
L_0526:
if (LEN != 0) goto L_0528;
PLANT1(4194304, 3, 3, JUST(1));
PLANT2(67108864, 3, LL);
RELEASEANDDROP(LL);
LL = COPY(L);
LL->TYPE = 4;
REMEMBER(3, LL);
goto L_0529;
L_0528:
MOVELITERAL(LEN, LL);
L_0529:
RELEASEANDDROP(LL);
ACTIVITY[3] = 0;
} /* STRINGASSIGN */
void STORE(struct STACKFM * R, struct STACKFM * L) {
if (R->OPER != 0) goto L_052A;
if (SAME(L, R)) goto L_052B;
L_052A:
if (L->TYPE != 9) goto L_052C;
RECORDASSIGN(R, L);
goto L_052D;
L_052C:
if (L->TYPE != 8) goto L_052E;
STRINGASSIGN(R, L);
goto L_052D;
L_052E:
if (L->TYPE != 13) goto L_052F;
SETASSIGN(R, L);
goto L_052D;
L_052F:
MOVE(R, L);
L_052D:
L_052B:
} /* STORE */
void ASSIGNPROCEDURE(struct STACKFM * R, struct STACKFM * L) {
int MASK;
struct STACKFM *W;
struct STACKFM *V;
if (R->FLAGS & 1024 == 0) goto L_0530;
HAZARD(3);
DIR2(19, R->DISP);
REFS = REFS + 1;
/*indirectthrough*/ *CA = /*indirectthrough*/ */*indirectthrough*/ *CA + 4;
R = REGISTER(14);
goto L_0531;
L_0530:
if (R->FLAGS & 4 == 0) goto L_0532;
R->TYPE = 1;
R->FORM = 1;
R->AREA = 0;
R = COPY(R);
goto L_0531;
L_0532:
if (R->FLAGS & 16777216 == 0) goto L_0533;
HAZARD(14);
DIR2(18, R->DISP);
REFS = REFS + 1;
/*indirectthrough*/ *CA = /*indirectthrough*/ */*indirectthrough*/ *CA + 4;
R = REGISTER(14);
goto L_0531;
L_0533:
HAZARD(14);
DIR2(18, R->DISP);
/*indirectthrough*/ *CA = /*indirectthrough*/ */*indirectthrough*/ *CA + 4;
REFS = REFS + 1;
CLAIM(14);
MASK = 9216;
W = NIL;
if (R->FLAGS & 65536 == 0) goto L_0534;
FRAME = FRAME - 4;
W = LITERAL(LOCALDISPLAY);
W->BASE = /*indirectthrough*/ *LOCAL;
LOAD(W, 15);
MASK = 25600;
L_0534:
FRAME = (FRAME & (~3)) - 8;
R = LOCALINTEGER(FRAME);
LOADUPADDRESS(R);
PLANT4(134217728 | 8388608, R->BASE, MASK);
RELEASE(14);
if (W == NIL) goto L_0535;
RELEASEANDDROP(W);
L_0535:
L_0531:
L->TYPE = 1;
SIMPLE(R, L);
RELEASEANDDROP(R);
} /* ASSIGNPROCEDURE */
void ASSIGNARRAYNAME(struct STACKFM * ARRAY, struct STACKFM * TO) {
struct STACKFM *DOPEVECTOR;
ARRAY->TYPE = 1;
TO = 1;
if (ARRAY->FLAGS & (64 | 32) != 0) goto L_0536;
if (/*%A*/ /*addressof*/ &ARRAY->ADATA != NIL) goto L_0537;
DOPEVECTOR = LITERAL(0);
goto L_0538;
L_0537:
DOPEVECTOR = LITERAL(ARRAY->ADATA);
DOPEVECTOR->AREA = 512;
L_0538:
AMAP(ARRAY);
goto L_0539;
L_0536:
DOPEVECTOR = COPY(ARRAY);
ADVANCE(DOPEVECTOR, 1, 4);
L_0539:
SIMPLIFY(/*%A*/ /*addressof*/ &TO);
ADVANCE(/*%A*/ /*addressof*/ &TO, 1, 4);
SIMPLE(DOPEVECTOR, /*%A*/ /*addressof*/ &TO);
RELEASEANDDROP(DOPEVECTOR);
ADVANCE(/*%A*/ /*addressof*/ &TO, 1, -4);
SIMPLE(ARRAY, /*%A*/ /*addressof*/ &TO);
} /* ASSIGNARRAYNAME */
int SELECTBEST(struct STACKFM * FROM, struct STACKFM * TO, int DEFAULT) {
struct STACKFM *W;
int REG;
if (!(INREG(FROM))) goto L_053A;
return /*indirectthrough*/ *DEFAULT;
L_053A:
W = COPY(/*%A*/ /*addressof*/ &TO);
OPTIMISE(W, 1);
if (!(INREG(W))) goto L_053B;
if (ACTIVITY[W->BASE] != 1) goto L_053B;
REG = W->BASE;
goto L_053C;
L_053B:
REG = /*indirectthrough*/ *DEFAULT;
L_053C:
RELEASEANDDROP(W);
return REG;
} /* SELECTBEST */
void MOVE(struct STACKFM * FROM, struct STACKFM * TO) {
struct STACKFM *BF1;
struct STACKFM *BF2;
struct STACKFM *BT1;
struct STACKFM *BT2;
struct STACKFM *W;
int R;
int PA;
int N;
int BEST;
int OP;
if (FROM->OPER != 4) goto L_053D;
if (PENDINGAUTO == 0) goto L_053D;
W = /*%A*/ /*addressof*/ &FROM->LINK;
if (!(ICONST(W))) goto L_053E;
if (-4095 > W->DISP) goto L_053E;
if (W->DISP > 4095) goto L_053E;
FROM->OPER = 0;
FROM->LINK = NIL;
PA = PENDINGAUTO;
OPTIMISE(FROM, 1);
if (!(INREG(FROM))) goto L_053F;
if (FROM->BASE != PA) goto L_053F;
if (PENDINGAUTON == 0) goto L_0540;
if (_imp_MOD((unsigned int)W->DISP >> 2) > 255) goto L_053F;
L_0540:
DIR3(16, /*indirectthrough*/ */*indirectthrough*/ *CA - PENDINGAUTOCA, (unsigned int)W->DISP >> PENDINGAUTON);
FORGET(PA);
DROP(W);
goto L_0541;
L_053F:
FROM->OPER = 4;
FROM->LINK = W;
L_0541:
L_053E:
L_053D:
if (FROM->TYPE != 2) goto L_0542;
if (FROM->OPER == 9) goto L_0543;
if (FROM->OPER != 12) goto L_0542;
L_0543:
if (TO != 1) goto L_0542;
if (!(ICONST(/*%A*/ /*addressof*/ &FROM->LINK))) goto L_0542;
N = FROM->LINK;
if (FROM->OPER != 12) goto L_0544;
N = (~N);
L_0544:
if (N & -65536 != 0) goto L_0545;
RELEASEANDDROP(/*%A*/ /*addressof*/ &FROM->LINK);
FROM->OPER = 0;
FROM->LINK = NIL;
if (N > 255) goto L_0546;
ADVANCE(FROM, 4, 0);
if (N == 255) goto L_0547;
OPERATE(9, FROM, LITERAL(N));
L_0547:
goto L_0548;
L_0546:
if (N & 255 != 0) goto L_0549;
RELEASEANDDROP(/*%A*/ /*addressof*/ &FROM->LINK);
FROM->OPER = 0;
FROM->LINK = 0;
ADVANCE(FROM, 4, 1);
if ((unsigned int)N >> 8 == 255) goto L_054A;
OPERATE(9, FROM, LITERAL((unsigned int)N >> 8));
L_054A:
OPERATE(14, FROM, LITERAL(8));
goto L_0548;
L_0549:
BEST = SELECTBEST(FROM, /*%A*/ /*addressof*/ &TO, 17);
BF2 = COPY(FROM);
ADVANCE(BF2, 4, 1);
if ((unsigned int)N >> 8 == 255) goto L_054B;
OPERATE(9, BF2, LITERAL((unsigned int)N >> 8));
L_054B:
ADVANCE(FROM, 4, 0);
if (N & 255 == 255) goto L_054C;
OPERATE(9, FROM, LITERAL(N & 255));
L_054C:
LOADUP(BF2);
LOADSAFELY(FROM, BEST);
LOADUP(BF2);
LOADSAFELY(FROM, BEST);
PLANT1(25165824, FROM->BASE, FROM->BASE, ISHIFT(BF2->BASE, 8, 0));
RELEASEANDDROP(BF2);
L_0548:
L_0545:
L_0542:
if (TO != 2) goto L_054D;
if (!(ICONST(FROM))) goto L_054E;
BF1 = LITERAL(FROM->DISP & 255);
BF2 = LITERAL((unsigned int)FROM->DISP >> 8 & 255);
goto L_054F;
L_054E:
if (FROM->TYPE != 2) goto L_0550;
if (FROM->OPER != 0) goto L_0550;
if (/*%A*/ /*addressof*/ &FROM->INDEX != NIL) goto L_0551;
if (/*%A*/ /*addressof*/ &FROM->RECORD == NIL) goto L_0552;
L_0551:
LOADUPADDRESS(FROM);
FROM->TYPE = 2;
FROM->FORM = 1;
L_0552:
BF1 = COPY(FROM);
ADVANCE(BF1, 4, 0);
BF2 = COPY(FROM);
ADVANCE(BF2, 4, 1);
goto L_054F;
L_0550:
if (FROM->TYPE != 4) goto L_0553;
if (FROM->OPER != 0) goto L_0553;
BF1 = COPY(FROM);
ADVANCE(BF1, 4, 0);
BF2 = LITERAL(0);
goto L_054F;
L_0553:
LOADUP(FROM);
BF1 = COPY(FROM);
BF2 = COPY(FROM);
OPERATE(15, BF2, LITERAL(8));
L_054F:
BT1 = COPY(/*%A*/ /*addressof*/ &TO);
ADVANCE(BT1, 4, 0);
BT2 = COPY(/*%A*/ /*addressof*/ &TO);
ADVANCE(BT2, 4, 1);
MOVE(BF2, BT2);
MOVE(BF1, BT1);
RELEASEANDDROPPAIR(BF1, BT1);
RELEASEANDDROPPAIR(BF2, BT2);
goto L_0554;
L_054D:
if (TO != 4) goto L_0555;
if (FROM->OPER != 0) goto L_0556;
if (FROM->TYPE != 2) goto L_0556;
FROM->TYPE = 4;
L_0556:
SIMPLIFY(/*%A*/ /*addressof*/ &TO);
LOADUP(FROM);
PLANT2(67108864 | 4194304, FROM->BASE, /*%A*/ /*addressof*/ &TO);
goto L_0554;
L_0555:
if (TO != 7) goto L_0557;
BEST = SELECTBEST(FROM, /*%A*/ /*addressof*/ &TO, 26);
SIMPLIFY(/*%A*/ /*addressof*/ &TO);
LOAD(FROM, BEST);
PLANT6(201359616, FROM->BASE, /*%A*/ /*addressof*/ &TO);
goto L_0554;
L_0557:
if (TO != 6) goto L_0558;
if (!(ICONST(FROM))) goto L_0559;
if (-5 > FROM->DISP) goto L_055A;
if (FROM->DISP <= 5) goto L_055B;
L_055A:
if (FROM->DISP == 10) goto L_055B;
if (FROM->DISP != -10) goto L_0559;
L_055B:
OP = 234914176;
N = FROM->DISP;
if (N >= 0) goto L_055C;
OP = 235962752;
N = -N;
L_055C:
if (N != 10) goto L_055D;
N = 7;
L_055D:
R = FPR();
PLANT9(OP | 8, 0, R, N);
PLANT6(201326848, R, /*%A*/ /*addressof*/ &TO);
goto L_055E;
L_0559:
if (FROM->FORM != 1) goto L_055F;
if (FROM->OPER != 0) goto L_055F;
if (FROM->TYPE != 6) goto L_055F;
TO = COPY(/*%A*/ /*addressof*/ &TO);
TO = 1;
FROM = COPY(FROM);
FROM->TYPE = 1;
MOVE(FROM, /*%A*/ /*addressof*/ &TO);
FORGET(FROM->BASE);
RELEASEANDDROPPAIR(FROM, /*%A*/ /*addressof*/ &TO);
goto L_055E;
L_055F:
SIMPLIFY(/*%A*/ /*addressof*/ &TO);
LOAD(FROM, 26);
PLANT6(201326848, FROM->BASE, /*%A*/ /*addressof*/ &TO);
L_055E:
goto L_0554;
L_0558:
BEST = SELECTBEST(FROM, /*%A*/ /*addressof*/ &TO, 17);
SIMPLIFY(/*%A*/ /*addressof*/ &TO);
LOAD(FROM, BEST);
PLANT2(67108864, FROM->BASE, /*%A*/ /*addressof*/ &TO);
L_0554:
} /* MOVE */
void MOVELITERAL(int VALUE, struct STACKFM *TO) {
struct STACKFM *W;
W = LITERAL(/*indirectthrough*/ *VALUE);
SIMPLE(W, /*%A*/ /*addressof*/ &TO);
RELEASEANDDROP(W);
} /* MOVELITERAL */
void MOVEBIASED(struct STACKFM * FROM, struct STACKFM * TO, int BIAS) {
FROM = COPY(/*%A*/ /*addressof*/ &FROM);
TO = COPY(TO);
if (FROM != 1) goto L_0560;
ADVANCE(/*%A*/ /*addressof*/ &FROM, 1, /*indirectthrough*/ *BIAS);
L_0560:
ADVANCE(TO, 1, /*indirectthrough*/ *BIAS);
MOVE(/*%A*/ /*addressof*/ &FROM, TO);
RELEASEANDDROPPAIR(/*%A*/ /*addressof*/ &FROM, TO);
} /* MOVEBIASED */
void STOREADDRESS(struct STACKFM * R, struct STACKFM * L, int *EXTRA) {
struct STACKFM *W;
int RT;
int FORMAT;
if (L->TYPE != 10) goto L_0561;
L->TYPE = 1;
if (L->FORM == 3) goto L_0562;
AMAP(L);
L_0562:
FORMAT = R;
RT = R;
AMAP(/*%A*/ /*addressof*/ &R);
if (RT != 10) goto L_0563;
MOVEBIASED(/*%A*/ /*addressof*/ &R, L, 4 * 2);
MOVEBIASED(/*%A*/ /*addressof*/ &R, L, 4 * 1);
MOVE(/*%A*/ /*addressof*/ &R, L);
goto L_0564;
L_0563:
W = LITERAL(TYPECODE[RT]);
MOVEBIASED(W, L, 4 * 2);
RELEASEANDDROP(W);
if (RT != 8) goto L_0565;
if (R != 1) goto L_0565;
if (FORMAT != 1) goto L_0565;
MOVEBIASED(/*%A*/ /*addressof*/ &R, L, 4);
MOVE(/*%A*/ /*addressof*/ &R, L);
goto L_0566;
L_0565:
W = LITERAL(ITEMSIZE(FORMAT));
MOVEBIASED(W, L, 4);
RELEASEANDDROP(W);
MOVE(/*%A*/ /*addressof*/ &R, L);
L_0566:
L_0564:
/*indirectthrough*/ *EXTRA = /*indirectthrough*/ */*indirectthrough*/ *EXTRA + 12;
goto L_0567;
L_0561:
if (L->FORM != 4) goto L_0568;
ASSIGNPROCEDURE(/*%A*/ /*addressof*/ &R, L);
/*indirectthrough*/ *EXTRA = /*indirectthrough*/ */*indirectthrough*/ *EXTRA + 4;
goto L_0567;
L_0568:
if (L->FLAGS & 64 == 0) goto L_0569;
ASSIGNARRAYNAME(/*%A*/ /*addressof*/ &R, L);
/*indirectthrough*/ *EXTRA = /*indirectthrough*/ */*indirectthrough*/ *EXTRA + 8;
goto L_0567;
L_0569:
if (L->TYPE != 8) goto L_056A;
if (L->FORMAT != 1) goto L_056A;
N = R;
AMAP(L);
AMAP(/*%A*/ /*addressof*/ &R);
if (N != 1) goto L_056B;
if (R == 0) goto L_056B;
MOVEBIASED(/*%A*/ /*addressof*/ &R, L, 4);
MOVE(/*%A*/ /*addressof*/ &R, L);
goto L_056C;
L_056B:
W = LITERAL(N);
MOVEBIASED(W, L, 4);
RELEASEANDDROP(W);
MOVE(/*%A*/ /*addressof*/ &R, L);
L_056C:
/*indirectthrough*/ *EXTRA = /*indirectthrough*/ */*indirectthrough*/ *EXTRA + 8;
goto L_0567;
L_056A:
if (L->FORM != 3) goto L_056D;
L->TYPE = 1;
goto L_056E;
L_056D:
AMAP(L);
L_056E:
AMAP(/*%A*/ /*addressof*/ &R);
STORE(/*%A*/ /*addressof*/ &R, L);
/*indirectthrough*/ *EXTRA = /*indirectthrough*/ */*indirectthrough*/ *EXTRA + 4;
L_0567:
} /* STOREADDRESS */
void JAMTRANSFER(struct STACKFM * L, struct STACKFM * R) {
int N;
int TYPE;
struct STACKFM *M;
TYPE = L->TYPE;
if (TYPE == 8) goto L_056F;
JAMIT = 1;
STORE(R, L);
JAMIT = 0;
FORGETDESTINATION(L);
goto L_0570;
L_056F:
N = L->FORMAT - 1;
if (R->OPER == 0) goto L_0571;
EVALUATESTRINGEXPRESSION(R);
L_0571:
AMAP(L);
AMAP(R);
if (N > 0) goto L_0572;
M = COPY(L);
M->DISP = M->DISP + 4;
M->TYPE = 1;
goto L_0573;
L_0572:
M = LITERAL(N + 1);
L_0573:
LOADTRIO(L, 3, R, 2, M, 1);
PRIM(10);
RELEASEANDDROP(M);
L_0570:
} /* JAMTRANSFER */
void ASSIGN(int HOW) {
int X;
X = 0;
struct VARFM *V;
struct STACKFM *L;
struct STACKFM *R;
R = STACK;
L = /*%A*/ /*addressof*/ &R->STACK;
STACK = /*%A*/ /*addressof*/ &L->STACK;
if (DIAG & 32 == 0) goto L_0574;
MONITOR(L, _imp_str_literal("A-L"));
MONITOR(R, _imp_str_literal("A-R"));
L_0574:
if (/*indirectthrough*/ *HOW != 0) goto L_0575;
STORE(R, L);
goto L_0576;
L_0575:
if (/*indirectthrough*/ *HOW != 1) goto L_0577;
STOREADDRESS(R, L, /*%A*/ /*addressof*/ &X);
goto L_0576;
L_0577:
JAMTRANSFER(L, R);
L_0576:
if (ASSIGNLOCK == 0) goto L_0578;
if (L->VARNO == 0) goto L_0578;
V = VAR(L->VARNO);
V->FLAGS = V->FLAGS | 128;
L_0578:
RELEASEANDDROPPAIR(R, L);
} /* ASSIGN */
void ASSIGNPARAMETER(void) {
struct STACKFM *PAR;
PAR = STACK;
STACK = /*%A*/ /*addressof*/ &PAR->STACK;
PAR->PARAMS = /*%A*/ /*addressof*/ &STACK->PARAMS;
STACK->PARAMS = PAR;
if (STACK->EXTRA == 0) goto L_0579;
STACK->EXTRA = STACK->EXTRA - 1;
L_0579:
PAR->VARNO = STACK->EXTRA;
} /* ASSIGNPARAMETER */
struct STACKFM *TOTEMP(struct STACKFM * V, int SIZE) {
struct STACKFM *W;
W = CLAIMWORKAREA(/*indirectthrough*/ *SIZE, 8);
STRINGASSIGN(V, W);
RELEASEANDDROP(V);
return W;
} /* TOTEMP */
struct STACKFM *PROCEDUREITEMS(struct STACKFM * R) {
int MASK;
struct STACKFM *EP;
struct STACKFM *ENV;
ENV = NIL;
if (R->FLAGS & 1024 == 0) goto L_057A;
MINSB = MINSB - 4;
EP = LOCALINTEGER(MINSB);
EP->BASE = 10;
DIR3(19, R->DISP, EP->DISP);
goto L_057B;
L_057A:
if (R->FLAGS & 4 == 0) goto L_057C;
R->TYPE = 1;
R->FORM = 1;
R->AREA = 0;
ENV = COPY(R);
EP = COPY(ENV);
ADVANCE(EP, 1, 4);
goto L_057B;
L_057C:
if (R->FLAGS & 16777216 != 0) goto L_057D;
if (R->FLAGS & 65536 == 0) goto L_057D;
ENV = LOCALINTEGER(LOCALDISPLAY);
AMAP(ENV);
L_057D:
MINSB = MINSB - 4;
EP = LOCALINTEGER(MINSB);
EP->BASE = 10;
DIR3(18, R->DISP, EP->DISP);
REFS = REFS + 1;
L_057B:
if (ENV != NIL) goto L_057E;
ENV = LITERAL(0);
L_057E:
ENV->PRIM = 1;
EP->PRIM = 1;
ENV->PARAMS = EP;
EP->PARAMS = NIL;
return ENV;
} /* PROCEDUREITEMS */
struct STACKFM *ARRAYNAMEITEMS(struct STACKFM * ARRAY) {
struct STACKFM *DOPEVECTOR;
ARRAY = COPY(/*%A*/ /*addressof*/ &ARRAY);
ARRAY = 1;
if (ARRAY & (64 | 32) != 0) goto L_057F;
if (/*%A*/ /*addressof*/ &ARRAY != NIL) goto L_0580;
DOPEVECTOR = LITERAL(0);
goto L_0581;
L_0580:
DOPEVECTOR = LITERAL(ARRAY);
DOPEVECTOR->AREA = 512;
L_0581:
AMAP(/*%A*/ /*addressof*/ &ARRAY);
goto L_0582;
L_057F:
DOPEVECTOR = COPY(/*%A*/ /*addressof*/ &ARRAY);
ADVANCE(DOPEVECTOR, 1, 4);
L_0582:
ARRAY = 1;
DOPEVECTOR->PRIM = 1;
ARRAY = DOPEVECTOR;
DOPEVECTOR->PARAMS = NIL;
return /*%A*/ /*addressof*/ &ARRAY;
} /* ARRAYNAMEITEMS */
struct STACKFM *ADDRESSITEMS(struct STACKFM * PAR, struct STACKFM * FORMAL) {
struct STACKFM *W;
struct STACKFM *X;
struct STACKFM *Y;
struct STACKFM *Z;
int RT;
int FORMAT;
if (FORMAL->FORM != 4) goto L_0583;
return PROCEDUREITEMS(PAR);
L_0583:
if (FORMAL->FLAGS & 64 == 0) goto L_0584;
return ARRAYNAMEITEMS(PAR);
L_0584:
X = COPY(PAR);
AMAP(X);
X->PRIM = 1;
X->PARAMS = NIL;
FORMAT = PAR->FORMAT;
if (FORMAL->TYPE != 10) goto L_0585;
RT = PAR->TYPE;
if (RT != 10) goto L_0586;
ADVANCE(X, 1, 0);
Y = COPY(X);
ADVANCE(Y, 1, 4);
Z = COPY(X);
ADVANCE(Z, 1, 4 * 2);
goto L_0587;
L_0586:
Z = LITERAL(TYPECODE[RT]);
if (RT != 8) goto L_0588;
if (X->FORM != 1) goto L_0588;
if (FORMAT != 1) goto L_0588;
Y = COPY(X);
ADVANCE(Y, 1, 4);
goto L_0589;
L_0588:
Y = LITERAL(ITEMSIZE(FORMAT));
L_0589:
L_0587:
Y->PRIM = 1;
Z->PRIM = 1;
X->PARAMS = Y;
Y->PARAMS = Z;
Z->PARAMS = NIL;
goto L_058A;
L_0585:
if (FORMAL->TYPE != 8) goto L_058B;
if (FORMAL->FORMAT != 1) goto L_058B;
if (FORMAT != 1) goto L_058C;
if (X->FORM == 0) goto L_058C;
Y = COPY(X);
ADVANCE(Y, 1, 4);
goto L_058D;
L_058C:
Y = LITERAL(FORMAT);
L_058D:
Y->PRIM = 1;
X->PARAMS = Y;
Y->PARAMS = NIL;
L_058B:
L_058A:
return X;
} /* ADDRESSITEMS */
void PASSPARAMETERS(struct STACKFM * V, int *EXTRA, int BASEREG) {
int COMPLETED;
struct STACKFM *PAR;
struct STACKFM *FORMAL;
struct STACKFM *HEAD;
struct STACKFM *L;
struct STACKFM *ITEMS;
struct STACKFM *REST;
struct STACKFM *X;
struct STACKFM *Y;
struct RPFM {
union {
struct {
struct STACKFM *P;
};
};
};
struct RPFM REGINFO[4];
static struct STACKFM SPMARK;
/*indirectthrough*/ *EXTRA = 0;
HEAD = /*%A*/ /*addressof*/ &V->PARAMS;
if (HEAD != NIL) goto L_058E;
return;
L_058E:
ITEMS = NIL;
L_058F:
if (HEAD == NIL) goto L_0590;
PAR = HEAD;
HEAD = /*%A*/ /*addressof*/ &HEAD->PARAMS;
STACKVAR(PAR->VARNO);
FORMAL = STACK;
STACK = /*%A*/ /*addressof*/ &FORMAL->STACK;
if (FORMAL->FLAGS & 4 == 0) goto L_0591;
X = PROCEDUREITEMS(PAR);
goto L_0592;
L_0591:
if (FORMAL->FLAGS & 64 == 0) goto L_0593;
X = ARRAYNAMEITEMS(PAR);
goto L_0592;
L_0593:
if (FORMAL->FLAGS & 131072 == 0) goto L_0594;
if (PAR->OPER != 22) goto L_0595;
PAR = TOTEMP(PAR, 256);
goto L_0596;
L_0595:
if (FORMAL->TYPE != 8) goto L_0597;
if (PAR->TYPE == 8) goto L_0597;
if (!(ICONST(PAR))) goto L_0598;
FIXUNITARYSTRING(PAR);
goto L_0599;
L_0598:
PAR = TOTEMP(PAR, 2);
L_0599:
goto L_0596;
L_0597:
if (PAR->TYPE != 8) goto L_059A;
if (PAR->BIAS != 1) goto L_059A;
FIXUNITARYSTRING(PAR);
goto L_0596;
L_059A:
if (PAR->TYPE != 13) goto L_059B;
if (PAR->OPER == 0) goto L_059C;
LOADUP(PAR);
goto L_059D;
L_059C:
if (/*%A*/ /*addressof*/ &PAR->MEMBERS == NIL) goto L_059E;
BUILDSET(PAR);
L_059E:
L_059D:
L_059B:
L_0596:
X = ADDRESSITEMS(PAR, FORMAL);
goto L_0592;
L_0594:
X = COPY(PAR);
X->PRIM = FORMAL->TYPE;
X->PARAMS = NIL;
L_0592:
RELEASEANDDROPPAIR(PAR, FORMAL);
Y = X;
L_059F:
if (/*%A*/ /*addressof*/ &Y->PARAMS == NIL) goto L_05A0;
Y = /*%A*/ /*addressof*/ &Y->PARAMS;
goto L_059F;
L_05A0:
Y->PARAMS = ITEMS;
ITEMS = X;
goto L_058F;
L_0590:
void COMPLETEREGISTERPROCESSING(void) {
int R;
int N;
int MASK;
struct STACKFM *V;
if (COMPLETED == 0) goto L_05A1;
return;
L_05A1:
COMPLETED = 1;
if (DIAG & 8 == 0) goto L_05A2;
MONITORN(0, _imp_str_literal("+complete"));
L_05A2:
R = 0; /*%for R = 1, 1, 4 %cycle*/
L_05A3:
if (R == 4) goto L_05A4;
R += 1;
V = /*%A*/ /*addressof*/ ®INFO[R].P;
if (V == NIL) goto L_05A6;
if (V != /*%A*/ /*addressof*/ &SPMARK) goto L_05A7;
L_05A6:
goto L_05A5;
L_05A7:
if (V->OPER == 0) goto L_05A8;
LOAD(V, R);
goto L_05A9;
L_05A8:
SIMPLIFY(V);
L_05A9:
L_05A5:
goto L_05A3;
L_05A4:
R = 0; /*%for R = 1, 1, 4 %cycle*/
L_05AA:
if (R == 4) goto L_05AB;
R += 1;
V = /*%A*/ /*addressof*/ ®INFO[R].P;
if (V == NIL) goto L_05AD;
if (V != /*%A*/ /*addressof*/ &SPMARK) goto L_05AE;
L_05AD:
goto L_05AC;
L_05AE:
if (ACTIVITY[R] != 0) goto L_05AF;
if (KTIMES[R] != 0) goto L_05AF;
LOAD(V, R);
L_05AF:
L_05AC:
goto L_05AA;
L_05AB:
R = 0; /*%for R = 1, 1, 4 %cycle*/
L_05B0:
if (R == 4) goto L_05B1;
R += 1;
V = /*%A*/ /*addressof*/ ®INFO[R].P;
if (V == NIL) goto L_05B3;
if (V != /*%A*/ /*addressof*/ &SPMARK) goto L_05B4;
L_05B3:
goto L_05B2;
L_05B4:
if (ACTIVITY[R] != 0) goto L_05B5;
LOAD(V, R);
L_05B5:
L_05B2:
goto L_05B0;
L_05B1:
N = 0;
R = 0; /*%for R = 1, 1, 4 %cycle*/
L_05B6:
if (R == 4) goto L_05B7;
R += 1;
V = /*%A*/ /*addressof*/ ®INFO[R].P;
if (V == NIL) goto L_05B9;
if (V != /*%A*/ /*addressof*/ &SPMARK) goto L_05BA;
L_05B9:
goto L_05B8;
L_05BA:
LOAD(V, R);
N = N + 1;
L_05B8:
goto L_05B6;
L_05B7:
if (ACTIVEREGISTERS == N) goto L_05BB;
R = 0; /*%for R = 1, 1, 4 %cycle*/
L_05BC:
if (R == 4) goto L_05BD;
R += 1;
V = /*%A*/ /*addressof*/ ®INFO[R].P;
if (V == NIL) goto L_05BF;
if (V != /*%A*/ /*addressof*/ &SPMARK) goto L_05C0;
L_05BF:
HAZARD(R);
L_05C0:
goto L_05BC;
L_05BD:
HAZARD(5);
HAZARD(6);
HAZARD(7);
HAZARD(8);
if (ACTIVEREGISTERS == N) goto L_05C1;
HAZARD(9);
HAZARD(12);
HAZARD(15);
if (ACTIVEREGISTERS == N) goto L_05C2;
HAZARD(18);
HAZARD(19);
HAZARD(20);
HAZARD(21);
if (ACTIVEREGISTERS == N) goto L_05C3;
HAZARD(22);
HAZARD(23);
HAZARD(24);
HAZARD(25);
L_05C3:
L_05C2:
L_05C1:
L_05BB:
MASK = 0;
N = 1;
R = 0; /*%for R = 1, 1, 4 %cycle*/
L_05C4:
if (R == 4) goto L_05C5;
R += 1;
if (/*%A*/ /*addressof*/ ®INFO[R].P != /*%A*/ /*addressof*/ &SPMARK) goto L_05C7;
/*indirectthrough*/ *EXTRA = /*indirectthrough*/ */*indirectthrough*/ *EXTRA - 4;
MASK = MASK | N;
L_05C7:
N = N << 1;
goto L_05C4;
L_05C5:
if (MASK == 0) goto L_05C8;
PLANT4(135266304 | 8388608 | 2097152, 13, MASK);
L_05C8:
R = 0; /*%for R = 1, 1, 4 %cycle*/
L_05C9:
if (R == 4) goto L_05CA;
R += 1;
V = /*%A*/ /*addressof*/ ®INFO[R].P;
if (V == NIL) goto L_05BE;
if (V != /*%A*/ /*addressof*/ &SPMARK) goto L_05CB;
L_05BE:
goto L_05C6;
L_05CB:
RELEASEANDDROP(V);
L_05C6:
goto L_05C9;
L_05CA:
if (DIAG & 8 == 0) goto L_05CC;
MONITORN(0, _imp_str_literal("+complete"));
L_05CC:
} /* COMPLETEREGISTERPROCESSING */
void PUSH(struct STACKFM * V, int TYPE) {
struct STACKFM SPV;
SPV = 0;
SPV.TYPE = TYPE;
SPV.FORM = 3;
SPV.BASE = 13;
if (TYPE != 1) goto L_05CD;
LOAD(/*%A*/ /*addressof*/ &V, 17);
PLANT2(67108864, V, /*%A*/ /*addressof*/ &SPV);
goto L_05CE;
L_05CD:
if (TYPE != 7) goto L_05CF;
LOAD(/*%A*/ /*addressof*/ &V, 26);
PLANT6(201359616, V, /*%A*/ /*addressof*/ &SPV);
/*indirectthrough*/ *EXTRA = /*indirectthrough*/ */*indirectthrough*/ *EXTRA + 4;
goto L_05CE;
L_05CF:
if (TYPE != 6) goto L_05D0;
LOAD(/*%A*/ /*addressof*/ &V, 26);
PLANT6(201326848, V, /*%A*/ /*addressof*/ &SPV);
goto L_05CE;
L_05D0:
FAIL(_imp_str_literal("Bad push type"));
L_05CE:
/*indirectthrough*/ *EXTRA = /*indirectthrough*/ */*indirectthrough*/ *EXTRA + 4;
RELEASEANDDROP(/*%A*/ /*addressof*/ &V);
} /* PUSH */
void PROCESS(struct STACKFM * V, int RN) {
struct STACKFM *NEXT;
if (/*%A*/ /*addressof*/ &V != NIL) goto L_05D1;
return;
L_05D1:
NEXT = /*%A*/ /*addressof*/ &V;
if (RN <= 4) goto L_05D2;
PROCESS(NEXT, 5);
PUSH(/*%A*/ /*addressof*/ &V, V);
goto L_05D3;
L_05D2:
if (V != 1) goto L_05D4;
REGINFO[RN].P = /*%A*/ /*addressof*/ &V;
PROCESS(NEXT, RN + 1);
goto L_05D3;
L_05D4:
if (V != 6) goto L_05D5;
SIMPLIFY(/*%A*/ /*addressof*/ &V);
if (V == 6) goto L_05D6;
if (V == 7) goto L_05D6;
LOAD(/*%A*/ /*addressof*/ &V, 26);
L_05D6:
if (V != 1) goto L_05D7;
V = 1;
REGINFO[RN].P = /*%A*/ /*addressof*/ &V;
PROCESS(NEXT, RN + 1);
goto L_05D8;
L_05D7:
PROCESS(NEXT, RN + 1);
PUSH(/*%A*/ /*addressof*/ &V, 6);
REGINFO[RN].P = /*%A*/ /*addressof*/ &SPMARK;
L_05D8:
goto L_05D3;
L_05D5:
if (V != 7) goto L_05D9;
SIMPLIFY(/*%A*/ /*addressof*/ &V);
if (V == 7) goto L_05DA;
LOAD(/*%A*/ /*addressof*/ &V, 26);
L_05DA:
if (V != 1) goto L_05DB;
if (RN != 4) goto L_05DC;
PROCESS(NEXT, RN + 2);
PUSH(/*%A*/ /*addressof*/ &V, 7);
REGINFO[RN].P = /*%A*/ /*addressof*/ &SPMARK;
goto L_05DD;
L_05DC:
V = 1;
X = COPY(/*%A*/ /*addressof*/ &V);
ADVANCE(X, 1, 4);
REGINFO[RN + 0].P = /*%A*/ /*addressof*/ &V;
REGINFO[RN + 1].P = X;
PROCESS(NEXT, RN + 2);
L_05DD:
goto L_05DE;
L_05DB:
PROCESS(NEXT, RN + 2);
PUSH(/*%A*/ /*addressof*/ &V, 7);
if (RN != 4) goto L_05DF;
REGINFO[RN + 0].P = /*%A*/ /*addressof*/ &SPMARK;
goto L_05E0;
L_05DF:
REGINFO[RN + 0].P = /*%A*/ /*addressof*/ &SPMARK;
REGINFO[RN + 1].P = /*%A*/ /*addressof*/ &SPMARK;
L_05E0:
L_05DE:
goto L_05D3;
L_05D9:
FAIL(_imp_str_literal("Bad process type"));
L_05D3:
} /* PROCESS */
REGINFO[1].P = NIL;
REGINFO[2].P = NIL;
REGINFO[3].P = NIL;
REGINFO[4].P = NIL;
COMPLETED = 0;
PROCESS(ITEMS, /*indirectthrough*/ *BASEREG);
COMPLETEREGISTERPROCESSING();
} /* PASSPARAMETERS */
void ARRAYINDEX(void) {
struct STACKFM *X;
struct STACKFM *END;
X = STACK;
STACK = /*%A*/ /*addressof*/ &STACK->STACK;
END = STACK;
L_05E1:
if (/*%A*/ /*addressof*/ &END->PARAMS == NIL) goto L_05E2;
END = /*%A*/ /*addressof*/ &END->PARAMS;
goto L_05E1;
L_05E2:
END->PARAMS = X;
X->PARAMS = NIL;
STACK->OPER = STACK->OPER + 1;
} /* ARRAYINDEX */
void ARRAYACCESS(void) {
int N;
int LIM;
int FLAG;
int TYPE;
int FORMAT;
int XSIZE;
int SCALENEEDED;
SCALENEEDED = 0;
int MULOP;
struct STACKFM *X;
struct STACKFM *ALL;
struct STACKFM *NEXT;
struct STACKFM *MULT;
struct STACKFM *SCALE;
void SETUPMULT(void) {
MULT = COPY(/*%A*/ /*addressof*/ &X->STACK);
ADVANCE(MULT, 1, 4);
LOADUP(MULT);
MULT->DISP = 20;
MULT->FORM = 1;
} /* SETUPMULT */
SCALE = NIL;
X = STACK;
FLAG = X->STACK;
MULOP = 6;
if (FLAG & 8 != 0) goto L_05E3;
if (X->STACK != 8) goto L_05E4;
if (X->STACK == 1) goto L_05E5;
L_05E4:
if (X->STACK != 9) goto L_05E6;
if (X->STACK != 0) goto L_05E6;
L_05E5:
SCALENEEDED = 1;
L_05E6:
L_05E3:
LIM = 1;
if (X->STACK == 0) goto L_05E7;
ARRAYINDEX();
NEXT = /*%A*/ /*addressof*/ &STACK->PARAMS;
ALL = LITERAL(0);
LIM = STACK->OPER;
STACK->OPER = 0;
if (FLAG & 64 == 0) goto L_05E8;
SETUPMULT();
L_05E8:
N = 0; /*%for N = 1, 1, LIM %cycle*/
L_05E9:
if (N == LIM) goto L_05EA;
N += 1;
X = NEXT;
NEXT = /*%A*/ /*addressof*/ &X->PARAMS;
X->PARAMS = NIL;
if (N == 1) goto L_05EC;
if (FLAG & 64 == 0) goto L_05ED;
OPERATE(MULOP, ALL, COPY(MULT));
MULT->DISP = MULT->DISP + 12;
goto L_05EE;
L_05ED:
OPERATE(MULOP, ALL, LITERAL(STACK->ADATA[N - 1]));
L_05EE:
L_05EC:
OPERATE(4, ALL, X);
goto L_05E9;
L_05EA:
if (NEXT == NIL) goto L_05EF;
FAIL(_imp_str_literal("Corrupt array index"));
L_05EF:
X = ALL;
if (FLAG & 2 != 0) goto L_05F0;
if (SCALENEEDED == 0) goto L_05F1;
SCALE = MULT;
goto L_05F2;
L_05F1:
RELEASEANDDROP(MULT);
L_05F2:
L_05F0:
goto L_05F3;
L_05E7:
if (SCALENEEDED == 0) goto L_05F4;
SETUPMULT();
SCALE = MULT;
L_05F4:
STACK = /*%A*/ /*addressof*/ &X->STACK;
L_05F3:
TYPE = STACK->TYPE;
STACK->TYPE = 1;
FORMAT = STACK->FORMAT;
if (FLAG & 64 == 0) goto L_05F5;
VMAP(STACK, 1);
L_05F5:
if (FLAG & 8 == 0) goto L_05F6;
XSIZE = 4;
if (TYPE != 8) goto L_05F7;
if (FORMAT != 1) goto L_05F7;
XSIZE = 2 * 4;
L_05F7:
goto L_05F8;
L_05F6:
if (SCALE == NIL) goto L_05F9;
OPERATE(MULOP, X, SCALE);
XSIZE = 1;
goto L_05F8;
L_05F9:
XSIZE = ITEMSIZE(FORMAT);
L_05F8:
STACK->FLAGS = STACK->FLAGS | FLAG;
APPLYINDEX(STACK, X, XSIZE);
if (FLAG & 8 == 0) goto L_05FA;
VMAP(STACK, TYPE);
goto L_05FB;
L_05FA:
STACK->TYPE = TYPE;
L_05FB:
STACK->FORMAT = FORMAT;
STACK->FLAGS = STACK->FLAGS & ~(32 | 2 | 64);
if (DIAG & 8 == 0) goto L_05FC;
MONITOR(STACK, _imp_str_literal("Array"));
L_05FC:
} /* ARRAYACCESS */
void UPDATELINE(int THISLINE) {
if (STACK == NIL) goto L_05FD;
FAIL(_imp_str_literal("Stack"));
L_05FD:
if (ACTIVEREGISTERS == 0) goto L_05FE;
FAIL(_imp_str_literal("Registers"));
L_05FE:
if (USING == NIL) goto L_05FF;
FAIL(_imp_str_literal("Descriptors"));
L_05FF:
if (REGV[17].BASE != 17) goto L_0600;
if (REGV[26].BASE == 26) goto L_0601;
L_0600:
FAIL(_imp_str_literal("Corrupt"));
L_0601:
if (THISLINE == CURRENTLINE) goto L_0602;
CURRENTLINE = THISLINE;
if (COMPILINGPRIM != 0) goto L_0603;
DIR2(3, CURRENTLINE);
L_0603:
L_0602:
if (DIAG & 64 == 0) goto L_0604;
_imp_SELECTOUTPUT(0);
_imp_PRINTSTRING(_imp_str_literal("Line:"));
_imp_WRITE(THISLINE, 1);
_imp_NEWLINE();
_imp_SELECTOUTPUT(2);
L_0604:
if (DIAG & 128 == 0) goto L_0605;
DISPLAYKNOWLEDGE();
L_0605:
WORKVALIDITY = WORKVALIDITY + 1;
VALUE = DEFAULTVALUE;
} /* UPDATELINE */
void TERMINATEBLOCK(void) {
int J;
int N;
int M;
struct VARFM *V;
if (AMODE >= 0) goto L_0606;
if (AMODE == -16) goto L_0606;
FALIGN = ALTALIGN;
N = 0;
if (FALIGN != (~0)) goto L_0607;
N = FRAMEEXTRA;
goto L_0608;
L_0607:
if (FALIGN != (~1)) goto L_0609;
N = FRAMEEXTRA & 2;
L_0609:
L_0608:
M = N;
if (N == 0) goto L_060A;
J = PARMS - 1; /*%for J = PARMS, 1, FIRSTALT %cycle*/
L_060B:
if (J == FIRSTALT) goto L_060C;
J += 1;
V = VAR(J);
V->DISP = V->DISP - N;
goto L_060B;
L_060C:
MAXFRAME = MAXFRAME - N;
FRAME = FRAME - N;
L_060A:
if (MAXFRAME <= FRAME) goto L_060E;
FRAME = MAXFRAME;
L_060E:
if (AMODE != -2) goto L_060F;
OLDFRAME = FRAME;
goto L_0610;
L_060F:
AVAR = (~FALIGN);
FRAME = FRAME + (~FALIGN) & FALIGN;
AVAR = FRAME;
DIR1(6);
L_0610:
L_0606:
FRAME = OLDFRAME;
} /* TERMINATEBLOCK */
void COPYOLDDISPLAY(void) {
int T;
int J;
void COPY(int FLAG, int TO) {
struct STACKFM *F;
struct STACKFM *T;
F = LITERAL(0);
if (FLAG >= 0) goto L_0611;
F->BASE = /*indirectthrough*/ *LOCAL;
goto L_0612;
L_0611:
F->BASE = 9;
F->FORM = 2;
CLAIM(F->BASE);
LOADUP(F);
L_0612:
T = LOCALINTEGER(TO);
PLANT2(67108864, F->BASE, T);
RELEASEANDDROPPAIR(F, T);
} /* COPY */
T = LOCALDISPLAY;
J = DANGERLEVEL - 1; /*%for J = DANGERLEVEL, 1, /*indirectthrough*/
*/*indirectthrough*/ *LOCAL -
1 % cycle * / L_0613 : if (J == /*indirectthrough*/ */*indirectthrough*/ *LOCAL - 1) goto L_0614;
J += 1;
COPY(0, T);
T = T + 4;
goto L_0613;
L_0614:
COPY(-1, T);
} /* COPYOLDDISPLAY */
int FINISHPARAMS(void) {
int J;
int MOD;
MOD = 0;
int TYPE;
int A;
int N;
struct VARFM *AP;
struct VARFM *FP;
struct VARFM *V;
struct STACKFM *S;
PARAMETERREGS = 0;
/*indirectthrough*/ *PARAMETERLIST = 0;
if (AMODE >= 0) goto L_0616;
FLUSHDIAGS();
return 1 /*TRUE*/;
L_0616:
PARAMETERFRAME = FRAME;
if (AVAR->P & 524288 == 0) goto L_0617;
if (AVAR->P & 8 != 0) goto L_0617;
if (AVAR == 8) goto L_0615;
if (AVAR != 9) goto L_0617;
L_0615:
PARAMETERFRAME = PARAMETERFRAME + 4;
STRINGRESULT = 4;
MOD = MOD + 4;
L_0617:
if (AMODE != 0) goto L_0618;
N = 1;
A = 4;
L_0619:
if (A >= PARAMETERFRAME) goto L_061A;
S = LOCALINTEGER(A);
REMEMBER(N, S);
DROP(S);
PARAMETERREGS = PARAMETERREGS + 1;
A = A + 4;
if (N != 4) goto L_061B;
goto L_061A;
L_061B:
N = N + 1;
goto L_0619;
L_061A:
L_0618:
FRAME = -20;
if (VARBASE == /*indirectthrough*/ *VARS) goto L_061C;
AVAR = PARMS;
AVAR = PARAMETERFRAME;
J = VARBASE + 1 - 1; /*%for J = VARBASE + 1, 1, /*indirectthrough*/
*VARS % cycle * / L_061D : if (J == /*indirectthrough*/ *VARS) goto L_061E;
J += 1;
AP = VAR(J);
PARMS = PARMS - 1;
FP = VAR(PARMS);
AP->BASE = /*indirectthrough*/ *LOCAL;
/*indirectthrough*/ *FP = /*indirectthrough*/ *AP;
FP->BASE = 13;
FP->FORM = 3;
FP->DISP = 0;
AP->DISP = AP->DISP + MOD;
FP->FLAGS = FP->FLAGS | 128;
if (AP->FORM == 1) goto L_061F;
FP->FLAGS = FP->FLAGS | 131072;
L_061F:
if (FP->TYPE == 4) goto L_060D;
if (FP->TYPE != 2) goto L_0620;
L_060D:
FP->TYPE = 1;
L_0620:
if (AP->FLAGS & 131072 == 0) goto L_0621;
if (AMODE != 0) goto L_0621;
if (AP->FORM == 4) goto L_0621;
AP->FLAGS = AP->FLAGS - 131072;
V = VAR(2000);
/*indirectthrough*/ *V = /*indirectthrough*/ *AP;
FRAME = FRAME - ITEMSIZE(AP->FORMAT);
V->BASE = /*indirectthrough*/ *LOCAL;
V->DISP = FRAME;
STACKVAR(2000);
STACKVAR(J);
TYPE = STACK->TYPE;
STACK->TYPE = 1;
VMAP(STACK, TYPE);
ASSIGN(0);
/*indirectthrough*/ *AP = /*indirectthrough*/ *V;
L_0621:
if (AP->FLAGS & 4 != 0) goto L_0622;
AP->FLAGS = AP->FLAGS | 128;
L_0622:
goto L_061D;
L_061E:
FLUSHDIAGS();
L_061C:
if (AMODE == 0) goto L_0623;
return 1 /*TRUE*/;
L_0623:
if (DANGERMARKER == 0) goto L_0624;
if (DANGERLEVEL != 32767) goto L_0625;
DANGERLEVEL = /*indirectthrough*/ *LOCAL;
L_0625:
L_0624:
if (DANGERLEVEL == 32767) goto L_0626;
FRAME =
(FRAME & (~3)) - 4 * (/*indirectthrough*/ */*indirectthrough*/ */*indirectthrough*/ *LOCAL - DANGERLEVEL + 1);
LOCALDISPLAY = FRAME;
ATTRIBUTES = ATTRIBUTES | 128 | 256;
L_0626:
if (LOCALDISPLAY == 0) goto L_0627;
COPYOLDDISPLAY();
L_0627:
return 0 /*FALSE*/;
} /* FINISHPARAMS */
int TAG(void) {
int N;
_imp_READSYMBOL(/*%A*/ /*addressof*/ &N);
N = (PENDING << 8) + N;
_imp_READSYMBOL(/*%A*/ /*addressof*/ &PENDING);
return N;
} /* TAG */
void GETSTRING(_imp_string * TEXT) {
int J;
int SYM;
int LIMIT;
LIMIT = _imp_SIZEOF(/*%A*/ /*addressof*/ &TEXT) - 1;
TEXT = _imp_str_literal("");
J = PENDING - -1; /*%for J = PENDING, -1, 1 %cycle*/
L_0628:
if (J == 1) goto L_0629;
J += -1;
_imp_READSYMBOL(/*%A*/ /*addressof*/ &SYM);
if (/*indirectthrough*/ *_imp_LENGTH(/*%A*/ /*addressof*/ &TEXT) >= LIMIT) goto L_062B;
TEXT = _imp_join((_imp_string)(TEXT), (_imp_string)(_imp_TOSTRING(SYM)));
L_062B:
goto L_0628;
L_0629:
_imp_READSYMBOL(/*%A*/ /*addressof*/ &PENDING);
} /* GETSTRING */
int ONIEEE(void) {
int MONE;
MONE = -1;
double M;
M = MONE;
unsigned char B;
B = /*indirectthrough*/ *_imp_BYTEINTEGER(_imp_ADDR(/*%A*/ /*addressof*/ &M));
if (B == 0) goto L_062A;
if (B != 191) goto L_062C;
L_062A:
return 1 /*TRUE*/;
L_062C:
return 0 /*FALSE*/;
} /* ONIEEE */
void CONVERTFORMAT(struct STACKFM * V, int TYPE) {
float SINGLE;
int A;
A = V;
int B;
B = V;
int FH;
int FL;
int S;
int X;
if (A != 0) goto L_062D;
if (0 == B) goto L_062E;
L_062D:
if (ONIEEE()) goto L_062E;
FH = (A & 127) << 16 | (unsigned int)A >> 16;
FL = (B & 65535) << 16 | (unsigned int)B >> 16;
X = (unsigned int)A >> 7;
X = (X & 255) - 128;
S = (unsigned int)A >> 15 & 1;
if (TYPE != 7) goto L_062F;
X = X + 1023 - 1 & 2047;
B = (FH & 7) << 29 | (unsigned int)FL >> 3;
A = (S << 31) + (X << 20) + ((unsigned int)FH >> 3 & 1048575);
goto L_0630;
L_062F:
X = X + 127 - 1 & 255;
A = (S << 31) + (X << 23) + FH;
B = 0;
L_0630:
goto L_0631;
L_062E:
if (TYPE != 6) goto L_0632;
SINGLE = V;
A = /*indirectthrough*/ *_imp_INTEGER(_imp_ADDR(/*%A*/ /*addressof*/ &SINGLE));
B = 0;
L_0632:
L_0631:
V = A;
V = B;
} /* CONVERTFORMAT */
void TOSHORTREAL(struct STACKFM * V) {
int X;
int Y;
int EXP;
int S;
if (V != 0) goto L_0633;
if (0 != V) goto L_0633;
return;
L_0633:
if (!(ONIEEE())) goto L_0634;
/*indirectthrough*/ *_imp_REAL(_imp_ADDR(/*%A*/ /*addressof*/ &V)) = V;
goto L_0635;
L_0634:
X = V;
S = X;
Y = V;
EXP = ((unsigned int)X >> 20 & 2047) - 1023 + 1;
EXP = EXP + 127 - 1;
X = (X & 1048575) << 3;
X = X | (unsigned int)Y >> 32 - 3;
if (Y & 268435456 == 0) goto L_0636;
X = X + 1;
L_0636:
if (X & 8388608 == 0) goto L_0637;
X = (unsigned int)X >> 1;
EXP = EXP + 1;
L_0637:
X = X | (EXP & 255) << 23;
if (S >= 0) goto L_0638;
X = X | -2147483648;
L_0638:
V = X;
V = 0;
L_0635:
} /* TOSHORTREAL */
double REALCONSTANT(void) {
extern double TEXTTOFLOATING(_imp_string255 S, int EXP) __asm__("3L___text_to_float");
int EXP;
int J;
double VALUE;
_imp_string255 S;
if (!_imp_on_event(1, 4)) goto L_0639;
if (_imp_EVENT().EVENT != 1) goto L_063A;
FAIL(_imp_str_literal("overflow while processing real constant"));
L_063A:
if (_imp_EVENT().EVENT != 4) goto L_063B;
FAIL(_imp_str_literal("error in real constant"));
L_063B:
FAIL(_imp_str_literal("Bad signal"));
L_0639:
S = _imp_str_literal("");
EXP = 0;
J = 0; /*%for J = 1, 1, TAG() %cycle*/
L_063C:
if (J == TAG()) goto L_063D;
J += 1;
if (PENDING != 64) goto L_063F;
_imp_READSYMBOL(/*%A*/ /*addressof*/ &PENDING);
EXP = TAG();
if (EXP & -32768 == 0) goto L_0640;
EXP = EXP | -32768;
L_0640:
goto L_063D;
L_063F:
S = _imp_join((_imp_string)(S), (_imp_string)(_imp_TOSTRING(PENDING)));
_imp_READSYMBOL(/*%A*/ /*addressof*/ &PENDING);
goto L_063C;
L_063D:
VALUE = TEXTTOFLOATING(S, EXP);
if (PENDING != 85) goto L_0641;
VALUE = -VALUE;
_imp_READSYMBOL(/*%A*/ /*addressof*/ &PENDING);
L_0641:
return VALUE;
} /* REALCONSTANT */
int FOURBYTES(void) {
int A;
int B;
int C;
int D;
A = PENDING;
_imp_READSYMBOL(/*%A*/ /*addressof*/ &B);
_imp_READSYMBOL(/*%A*/ /*addressof*/ &C);
_imp_READSYMBOL(/*%A*/ /*addressof*/ &D);
_imp_READSYMBOL(/*%A*/ /*addressof*/ &PENDING);
return (((A << 8) + B << 8) + C << 8) + D;
} /* FOURBYTES */
void INPUTINTEGERVALUE(int BYTE) {
CONSTANTTYPE = 1;
if (BYTE != 0) goto L_0642;
VALUE.INTEGER = FOURBYTES();
goto L_0643;
L_0642:
VALUE.INTEGER = PENDING;
_imp_READSYMBOL(/*%A*/ /*addressof*/ &PENDING);
L_0643:
if (PENDING != 85) goto L_0644;
VALUE.INTEGER = -VALUE.INTEGER;
_imp_READSYMBOL(/*%A*/ /*addressof*/ &PENDING);
goto L_0645;
L_0644:
if (PENDING != 92) goto L_0646;
VALUE.INTEGER = (~VALUE.INTEGER);
_imp_READSYMBOL(/*%A*/ /*addressof*/ &PENDING);
L_0646:
L_0645:
if (PENDING == 65) goto L_0647;
STACKINTEGER(VALUE.INTEGER);
L_0647:
} /* INPUTINTEGERVALUE */
void INPUTREALVALUE(void) {
CONSTANTTYPE = 6;
VALUE.REAL = REALCONSTANT();
if (PENDING == 65) goto L_0648;
if (PENDING == 36) goto L_0648;
STACKINTEGER(0);
if (VALUE.REAL != 0) goto L_05EB;
if (PENDING == 83) goto L_0649;
if (PENDING == 63) goto L_0649;
L_05EB:
STACK->TYPE = 7;
STACK->RVAL = VALUE.REAL;
CONVERTFORMAT(STACK, 7);
L_0649:
L_0648:
} /* INPUTREALVALUE */
void INPUTSTRINGVALUE(void) {
struct STACKFM *W;
CONSTANTTYPE = 8;
GETSTRING(/*%A*/ /*addressof*/ &VALUE.STRING);
if (PENDING == 36) goto L_063E;
if (PENDING != 65) goto L_064A;
L_063E:
return;
L_064A:
if (/*indirectthrough*/ *_imp_LENGTH(/*%A*/ /*addressof*/ &VALUE.STRING) != 1) goto L_064B;
STACKINTEGER(/*indirectthrough*/ *_imp_CHARNO(/*%A*/ /*addressof*/ &VALUE.STRING, 1));
STACK->BIAS = -1;
goto L_064C;
L_064B:
W = CONSTSTRING();
W->STACK = STACK;
STACK = W;
L_064C:
} /* INPUTSTRINGVALUE */
int INREG(struct STACKFM * V) {
if (V == NIL) goto L_064D;
if (V->FORM != 0) goto L_064D;
if (V->DISP != 0) goto L_064D;
if (V->BASE == 0) goto L_064D;
if (V->AREA != 0) goto L_064D;
if (V->OPER != 0) goto L_064D;
if (/*%A*/ /*addressof*/ &V->INDEX != NIL) goto L_064D;
if (/*%A*/ /*addressof*/ &V->RECORD == NIL) goto L_064E;
L_064D:
return 0 /*FALSE*/;
L_064E:
return 1 /*TRUE*/;
} /* INREG */
int FLOATING(struct STACKFM * V) {
if (6 > V->TYPE) goto L_064F;
if (V->TYPE <= 7) goto L_0650;
L_064F:
if (V->OPER < 23) goto L_0651;
L_0650:
return 1 /*TRUE*/;
L_0651:
return 0 /*FALSE*/;
} /* FLOATING */
int SAME(struct STACKFM * A, struct STACKFM * B) {
if (A != /*%A*/ /*addressof*/ &B) goto L_0652;
return 1 /*TRUE*/;
L_0652:
if (A == NIL) goto L_0653;
if (/*%A*/ /*addressof*/ &B != NIL) goto L_0654;
L_0653:
return 0 /*FALSE*/;
L_0654:
if (A->DISP != B) goto L_0655;
if (A->BASE != B) goto L_0655;
if (A->TYPE != B) goto L_0655;
if (A->FORM != B) goto L_0655;
if (A->EXTRA != B) goto L_0655;
if (A->AREA == B) goto L_0656;
L_0655:
return 0 /*FALSE*/;
L_0656:
if (/*%A*/ /*addressof*/ &A->INDEX == NIL) goto L_0657;
if (/*%A*/ /*addressof*/ &B == NIL) goto L_0658;
if (A->XSIZE != B) goto L_0658;
if (!(SAME(/*%A*/ /*addressof*/ &A->INDEX, /*%A*/ /*addressof*/ &B))) goto L_0658;
if (A->INDEX != B) goto L_0658;
if (SAME(/*%A*/ /*addressof*/ &A->INDEX, /*%A*/ /*addressof*/ &B)) goto L_0659;
L_0658:
return 0 /*FALSE*/;
L_0659:
goto L_065A;
L_0657:
if (/*%A*/ /*addressof*/ &B == NIL) goto L_065B;
return 0 /*FALSE*/;
L_065B:
L_065A:
if (/*%A*/ /*addressof*/ &A->RECORD == NIL) goto L_065C;
if (/*%A*/ /*addressof*/ &B == NIL) goto L_065D;
if (!(SAME(/*%A*/ /*addressof*/ &A->RECORD, /*%A*/ /*addressof*/ &B))) goto L_065D;
if (A->RECORD != B) goto L_065D;
if (SAME(/*%A*/ /*addressof*/ &A->RECORD, /*%A*/ /*addressof*/ &B)) goto L_065E;
L_065D:
return 0 /*FALSE*/;
L_065E:
goto L_065F;
L_065C:
if (/*%A*/ /*addressof*/ &B == NIL) goto L_0660;
return 0 /*FALSE*/;
L_0660:
L_065F:
return 1 /*TRUE*/;
} /* SAME */
int CONST(struct STACKFM * V) {
if (V->FORM != 0) goto L_0661;
if (V->BASE != 0) goto L_0661;
if (V->OPER != 0) goto L_0661;
if (/*%A*/ /*addressof*/ &V->INDEX != NIL) goto L_0661;
if (/*%A*/ /*addressof*/ &V->RECORD != NIL) goto L_0661;
if (V->AREA == 0) goto L_0662;
L_0661:
return 0 /*FALSE*/;
L_0662:
return 1 /*TRUE*/;
} /* CONST */
int ICONST(struct STACKFM * V) {
if (V == NIL) goto L_0663;
if (V->FORM != 0) goto L_0663;
if (V->BASE != 0) goto L_0663;
if (V->OPER != 0) goto L_0663;
if (/*%A*/ /*addressof*/ &V->INDEX != NIL) goto L_0663;
if (/*%A*/ /*addressof*/ &V->RECORD != NIL) goto L_0663;
if (V->TYPE > 5) goto L_0663;
if (V->AREA == 0) goto L_0664;
L_0663:
return 0 /*FALSE*/;
L_0664:
return 1 /*TRUE*/;
} /* ICONST */
int ICONSTITEM(struct STACKFM * V) {
if (V == NIL) goto L_0665;
if (V->FORM != 0) goto L_0665;
if (V->BASE != 0) goto L_0665;
if (/*%A*/ /*addressof*/ &V->INDEX != NIL) goto L_0665;
if (/*%A*/ /*addressof*/ &V->RECORD != NIL) goto L_0665;
if (V->TYPE > 5) goto L_0665;
if (V->AREA == 0) goto L_0666;
L_0665:
return 0 /*FALSE*/;
L_0666:
return 1 /*TRUE*/;
} /* ICONSTITEM */
int POWER(int N) {
int P;
int MASK;
if (/*indirectthrough*/ *N <= (unsigned int)~((unsigned int)-1 >> 1) >> 1) goto L_0667;
return -1;
L_0667:
MASK = 1;
P = 0;
L_0668:
if (MASK != /*indirectthrough*/ *N) goto L_0669;
return P;
L_0669:
if (MASK <= /*indirectthrough*/ *N) goto L_066A;
return -1;
L_066A:
MASK = MASK << 1;
P = P + 1;
goto L_0668;
} /* POWER */
int ITEMSIZE(int F) {
if (/*indirectthrough*/ *F < 0) goto L_066B;
return /*indirectthrough*/ *F;
L_066B:
return VAR(/*indirectthrough*/ *-/*indirectthrough*/ *F)->FORMAT;
} /* ITEMSIZE */
struct STACKFM *CLAIMWORKAREA(int BYTES, int TYPE) {
struct STACKFM *T;
struct WORKFM *W;
struct WORKFM *BEST;
BEST = NIL;
int P;
if (/*indirectthrough*/ *BYTES > 0) goto L_066C;
FAIL(_imp_str_literal("claim work area/1"));
L_066C:
P = WORKBASE;
L_066D:
if (P != LASTWORK) goto L_066E;
if (BEST != NIL) goto L_066F;
LASTWORK = LASTWORK + 1;
BEST = WORKAREA(LASTWORK);
FRAME = FRAME - /*indirectthrough*/ *BYTES & (~3);
BEST->SIZE = /*indirectthrough*/ *BYTES;
BEST->DISPLACEMENT = FRAME;
L_066F:
W = BEST;
goto L_0670;
L_066E:
P = P + 1;
W = WORKAREA(P);
if (DIAG & 2 == 0) goto L_0671;
MONITORN(P, _imp_str_literal("try work"));
L_0671:
if (W->VALIDITY >= WORKVALIDITY) goto L_0672;
if (W->SIZE < /*indirectthrough*/ *BYTES) goto L_0672;
if (W->SIZE != /*indirectthrough*/ *BYTES) goto L_0673;
goto L_0670;
L_0673:
if (BEST == NIL) goto L_0674;
if (BEST->SIZE <= W->SIZE) goto L_0675;
L_0674:
BEST = W;
L_0675:
L_0672:
goto L_066D;
L_0670:
W->VALIDITY = WORKVALIDITY;
if (DIAG & 2 == 0) goto L_0676;
MONITORN(W->DISPLACEMENT, _imp_str_literal("temporary"));
L_0676:
T = LITERAL(W->DISPLACEMENT);
T->BASE = /*indirectthrough*/ *LOCAL;
T->TYPE = TYPE;
T->FORM = 1;
T->FORMAT = /*indirectthrough*/ *BYTES;
return T;
} /* CLAIMWORKAREA */
void CONSTANTBOUNDS(void) {
VUB = POPPEDVALUE();
VLB = POPPEDVALUE();
} /* CONSTANTBOUNDS */
void SETCD(int VALUE, int *CD) {
if (/*indirectthrough*/ *VALUE & 49152 != 2 << 14) goto L_0677;
/*indirectthrough*/ *CD = /*indirectthrough*/ *VALUE & 16383;
L_0677:
} /* SETCD */
int ALTERNATEFORMAT(int CODE) {
int ATTR;
ATTR = 0;
struct VARFM DUMMY;
if (/*indirectthrough*/ *CODE != 65) goto L_0678;
ASSEMBLE(/*%A*/ /*addressof*/ &DUMMY, -2, /*indirectthrough*/ *VARS, /*indirectthrough*/ *LOCAL, -1,
/*%A*/ /*addressof*/ &ATTR);
ALTALIGN = ALTALIGN & FALIGN;
goto L_0679;
L_0678:
if (/*indirectthrough*/ *CODE != 67) goto L_067A;
if (FRAME <= MAXFRAME) goto L_067B;
MAXFRAME = FRAME;
L_067B:
FRAME = FRAMEBASE;
goto L_0679;
L_067A:
if (/*indirectthrough*/ *CODE != 66) goto L_067C;
if (MAXFRAME <= FRAME) goto L_067D;
FRAME = MAXFRAME;
L_067D:
FALIGN = ALTALIGN;
return 1 /*TRUE*/;
L_067C:
FAIL(_imp_join((_imp_string)(_imp_str_literal("Format ")),
(_imp_string)(_imp_ITOS(/*indirectthrough*/ *CODE, 0))));
L_0679:
return 0 /*FALSE*/;
} /* ALTERNATEFORMAT */
void COMPILEBEGIN(void) {
int MAINEP;
MAINEP = 0;
struct VARFM B;
B = 0;
B.TYPE = 10;
B.DISP = NEWLABEL();
B.BASE = 0;
if (/*indirectthrough*/ *LOCAL == 128) goto L_067E;
STACKINTEGER(B.DISP);
if (/*indirectthrough*/ *LOCAL < DANGERLEVEL) goto L_067F;
STACK->FLAGS = STACK->FLAGS | 65536;
L_067F:
CALL(0);
OSTATE = 0;
goto L_0680;
L_067E:
OSTATE = 3;
EXTERNALID = _imp_str_literal("3L___main_program");
ENTRYPOINT = EXTERNALNO + 1;
MAINEP = 1;
L_0680:
INTERNALID = _imp_str_literal("block");
if (ALIAS == _imp_str_literal("")) goto L_0681;
INTERNALID = ALIAS;
ALIAS = _imp_str_literal("");
L_0681:
ASSEMBLE(/*%A*/ /*addressof*/ &B, 0, /*indirectthrough*/ *VARS,
/*indirectthrough*/ */*indirectthrough*/ *LOCAL + 1, 0, /*%A*/ /*addressof*/ &ATTRIBUTES);
} /* COMPILEBEGIN */
void CLEARVARS(int LIMIT) {
if (LIMIT < PARMS) goto L_0682;
FAIL(_imp_str_literal("Too many objects"));
L_0682:
L_0683:
if (/*indirectthrough*/ *VARS >= LIMIT) goto L_0684;
/*indirectthrough*/ *VARS = /*indirectthrough*/ */*indirectthrough*/ *VARS + 1;
/*indirectthrough*/ *VAR(/*indirectthrough*/ *VARS) = 0;
goto L_0683;
L_0684:
} /* CLEARVARS */
void DIRSTRING(int OP, _imp_string *S) {
int L;
L = /*indirectthrough*/ *_imp_LENGTH(/*%A*/ /*addressof*/ &S);
int J;
if (OP < 0) goto L_0685;
DIR1(OP);
L_0685:
DIR1(L);
J = 0; /*%for J = 1, 1, L %cycle*/
L_0686:
if (J == L) goto L_0687;
J += 1;
DIR1(/*indirectthrough*/ *_imp_CHARNO(/*%A*/ /*addressof*/ &S, J));
goto L_0686;
L_0687:
} /* DIRSTRING */
void DUMPEXTERNAL(int CODE, struct VARFM *V) {
EXTERNALNO = EXTERNALNO + 1;
if (CODE & 1 != 0) goto L_0689;
if (V.FORM != 4) goto L_068A;
V.AREA = 23;
V.DISP = EXTERNALNO;
goto L_068B;
L_068A:
V.AREA = -EXTERNALNO;
V.DISP = 0;
L_068B:
L_0689:
if (CODE & 2 == 0) goto L_068C;
if (V.FLAGS & 256 == 0) goto L_068C;
CODE = CODE | 4;
L_068C:
DIRSTRING(21, /*%A*/ /*addressof*/ &EXTERNALID);
DIR2(CODE, V.DISP);
} /* DUMPEXTERNAL */
void PLANTDIAG(struct DIAGFM * D) {
int DISP;
int TYPE;
int IND;
int BASE;
int BTYPE;
int PTYPE;
struct AFM *DV;
if (D.PRIM & 64 == 0) goto L_068D;
if (D.FORM & 65535 != 0) goto L_068D;
return;
L_068D:
DISP = D.BASE;
if (D.RVAR == 0) goto L_068E;
DISP = D.RVAR;
L_068E:
TYPE = (unsigned int)D.PRIM >> 2 & 15;
if (INTERFACE->OPTIONS & 4 == 0) goto L_068F;
if (TYPE == 14) goto L_068F;
DIRSTRING(2, /*%A*/ /*addressof*/ &D.DISP);
DUMPENCODED(D.PRIM);
DUMPENCODED(D.TYPE);
DUMPENCODED(D.BASE);
if (D.PRIM & 64 == 0) goto L_0690;
DUMPENCODED(D.FORM & 65535);
L_0690:
L_068F:
if (DEBUG == 0) goto L_0691;
BASE = D.PRIM & 3;
IND = (unsigned int)D.PRIM >> 7;
BTYPE = D.TYPE & 15;
PTYPE = (unsigned int)D.TYPE >> 4 & 15;
if (TYPE != 14) goto L_0692;
DIRSTRING(33, /*%A*/ /*addressof*/ &D.DISP);
DV = /*%A*/ /*addressof*/ &D.BASE;
DUMPENCODED(DV->BOUND[1]);
DUMPENCODED(DV->BOUND[1]);
DUMPENCODED(DV->TOTALSIZE);
DUMPENCODED(BTYPE);
DUMPENCODED(D.FORM & 65535);
goto L_0693;
L_0692:
if (BASE == 1) goto L_0694;
if (BASE == 2) goto L_0694;
return;
L_0694:
DIRSTRING(34, /*%A*/ /*addressof*/ &D.DISP);
DUMPENCODED(TYPE);
DUMPENCODED(IND);
DUMPENCODED(BASE);
DUMPENCODED(BTYPE);
DUMPENCODED(PTYPE);
DUMPENCODED(D.BASE);
DUMPENCODED(D.FORM & 65535);
DUMPENCODED(ITEMSIZE(D.BASE));
L_0693:
L_0691:
} /* PLANTDIAG */
void DUMPDIAG(int BASE, struct QFM *Q) {
struct DIAGFM D;
struct DIAGFM *ND;
if (COMPILINGPRIM == 0) goto L_0695;
return;
L_0695:
D.LINK = DIAGLIST;
D.ID = INTERNALID;
D.XTYPE = 0;
D.EXT = 0;
if (BASE != 17) goto L_0696;
if (/*indirectthrough*/ *PARAMETERLIST != 0) goto L_0697;
return;
L_0697:
BASE = 0;
D.XTYPE = (unsigned int)Q >> 2 & 15;
Q = 14 << 2;
goto L_0698;
L_0696:
if (BASE != /*indirectthrough*/ *LOCAL) goto L_0699;
BASE = 1;
goto L_0698;
L_0699:
if (BASE != 10) goto L_069A;
BASE = 2;
goto L_0698;
L_069A:
if (BASE >= 0) goto L_069B;
D.EXT = -BASE;
BASE = 3;
goto L_0698;
L_069B:
BASE = 0;
L_0698:
if (/*%A*/ /*addressof*/ &Q != NIL) goto L_069C;
D.X = 0;
D.FORMAT = 0;
goto L_069D;
L_069C:
D.FORMAT = Q;
if (/*%A*/ /*addressof*/ &Q == NIL) goto L_069E;
D.XTYPE = (unsigned int)Q >> 2 | ((unsigned int)Q >> 2 & 15) << 4;
Q = Q | 15 << 2 | Q & 64;
D.FORMAT = Q;
L_069E:
D.X = Q << 7 | Q | BASE;
L_069D:
D.VAR = DEFV;
if (D.FORMAT != 0) goto L_069F;
if (D.X & 64 == 0) goto L_069F;
return;
L_069F:
if (/*indirectthrough*/ *PARAMETERLIST != 0) goto L_06A0;
PLANTDIAG(/*%A*/ /*addressof*/ &D);
goto L_06A1;
L_06A0:
ND = _imp_NEW(DIAGFMTYPE);
U_100D:
/*indirectthrough*/ *ND = D;
DIAGLIST = ND;
L_06A1:
} /* DUMPDIAG */
void FLUSHDIAGS(void) {
void FLUSH(struct DIAGFM * D) {
if (/*%A*/ /*addressof*/ &D != NIL) goto L_06A2;
return;
L_06A2:
FLUSH(/*%A*/ /*addressof*/ &D);
PLANTDIAG(/*%A*/ /*addressof*/ &D);
_imp_DISPOSE(/*%A*/ /*addressof*/ &D);
} /* FLUSH */
FLUSH(DIAGLIST);
DIAGLIST = NIL;
} /* FLUSHDIAGS */
void DEFINEVAR(void) {
int DECL;
int TF;
int NEWV;
int AREA;
int EXTERNALMODE;
int *AT;
int SPEC;
int OFLAGS;
int N;
int TYPE;
int FORM;
int FORMAT;
struct VARFM *FV;
struct QFM Q;
struct QFM PQ;
struct STACKFM *VV;
const unsigned char FORMMAP[16] = {0, 1, 15, 0, 0, 0, 0, 4, 4, 4, 4, 1, 1, 1, 1, 0};
void ENCODETYPE(int TYPE, int FORMAT, struct QFM *Q) {
static const void *T[14] = {NULL};
const short int DIAGMAP[14] = {20, 12, 8, 0, 4, 16, 24, 92, 32, 52, 104, 108, 48, 36};
const unsigned char TYPEMAP[14] = {7, 4, 2, 10, 1, 6, 8, 9, 4, 13, 4, 2, 1, 4};
const unsigned char SIZEMAP[14] = {8, 1, 2, 12, 4, 4, 0, 0, 1, 32, 1, 2, 4, 1};
const unsigned char ALGNMAP[14] = {3, 0, 1, 3, 3, 3, 0, 0, 0, 3, 0, 1, 3, 0};
if (TYPE != 1) goto L_06A3;
if (FORMAT != 2) goto L_06A4;
TYPE = -2;
goto L_06A5;
L_06A4:
if (FORMAT != 3) goto L_06A6;
TYPE = -1;
L_06A6:
L_06A5:
goto L_06A7;
L_06A3:
if (TYPE != 2) goto L_06A8;
if (FORMAT != 4) goto L_06A9;
TYPE = -3;
L_06A9:
L_06A8:
L_06A7:
if (-3 > TYPE) goto L_0688;
if (TYPE <= 10) goto L_06AA;
L_0688:
FAIL(_imp_str_literal("Unknown type"));
L_06AA:
Q = TYPEMAP[TYPE];
Q = SIZEMAP[TYPE];
DEFV->FORMAT = Q;
Q = ALGNMAP[TYPE];
Q = 0;
Q = DIAGMAP[TYPE];
Q = 0;
Q = FORMAT;
Q = 1;
Q = 0;
Q = NIL;
goto *T[TYPE]; /*TO DO*/
case_T_0:;
Q = 0;
return;
case_T_ - 3:;
case_T_1:;
case_T_2:;
case_T_5:;
DEFV->FLAGS = DEFV->FLAGS | 1048576;
case_T_ - 1:;
case_T_ - 2:;
case_T_10:;
return;
case_T_3:;
Q = FORMAT + 1;
DEFV->FORMAT = Q;
return;
case_T_4:;
FV = VAR(FORMAT);
if (FORMAT <= /*indirectthrough*/ *VARS) goto L_06AC;
CLEARVARS(FORMAT);
INTERFACE->FORMATS = INTERFACE->FORMATS + 1;
FV->AREA = INTERFACE->FORMATS;
goto L_06AD;
L_06AC:
Q = FV->FORMAT;
L_06AD:
DEFV->FORMAT = -FORMAT;
Q = FV->DISP;
Q = FV->AREA;
case_T_7:;
Q = VAR(FORMAT)->AREA;
return;
case_T_8:;
Q = VAR(FORMAT)->AREA;
return;
case_T_9:;
DEFV->FLAGS = DEFV->FLAGS | 1048576;
case_T_6:;
if (/*%A*/ /*addressof*/ &Q == /*%A*/ /*addressof*/ &PQ) goto L_06AE;
ENCODETYPE(Q, FORMAT, /*%A*/ /*addressof*/ &PQ);
DEFV->FORMAT = SIZEMAP[TYPE];
Q = /*%A*/ /*addressof*/ &PQ;
goto L_06AF;
L_06AE:
Q = 0;
L_06AF:
if (TYPE != 6) goto L_06B0;
DEFV->FLAGS = DEFV->FLAGS & (~1048576);
L_06B0:
return;
} /* ENCODETYPE */
NEWV = 1;
DECL = TAG();
if (DECL == 0) goto L_06B1;
if (DECL > /*indirectthrough*/ *VARS) goto L_06B2;
NEWV = 0;
L_06B2:
DEFV = VAR(DECL);
CLEARVARS(DECL);
goto L_06B3;
L_06B1:
PARMS = PARMS - 1;
DEFV = VAR(PARMS);
/*indirectthrough*/ *DEFV = 0;
L_06B3:
if (PARMS > /*indirectthrough*/ *VARS) goto L_06B4;
FAIL(_imp_str_literal("Too many objects"));
L_06B4:
INTERNALID = _imp_str_literal("");
L_06B5:
if (PENDING == 44) goto L_06B6;
if (/*indirectthrough*/ *_imp_LENGTH(/*%A*/ /*addressof*/ &INTERNALID) == 127) goto L_06B7;
INTERNALID = _imp_join((_imp_string)(INTERNALID), (_imp_string)(_imp_TOSTRING(PENDING)));
L_06B7:
_imp_READSYMBOL(/*%A*/ /*addressof*/ &PENDING);
goto L_06B5;
L_06B6:
_imp_READSYMBOL(/*%A*/ /*addressof*/ &PENDING);
TF = TAG();
FORMAT = TAG();
OSTATE = TAG();
Q.DIM = (unsigned int)OSTATE >> 8;
SPEC = OSTATE & 8;
OFLAGS = OSTATE & 240;
OSTATE = OSTATE & 7;
if (OSTATE != 5) goto L_06B8;
OSTATE = 3;
L_06B8:
TYPE = (unsigned int)TF >> 4 & 15;
FORM = TF & 15;
if (ALIAS == _imp_str_literal("")) goto L_06B9;
if (OSTATE != 4) goto L_06BA;
OSTATE = 3;
L_06BA:
EXTERNALID = ALIAS;
ALIAS = _imp_str_literal("");
goto L_06BB;
L_06B9:
if (OSTATE != 4) goto L_06BC;
OSTATE = 3;
EXTERNALID = _imp_join((_imp_string)(_imp_str_literal("$")), (_imp_string)(INTERNALID));
goto L_06BB;
L_06BC:
EXTERNALID = INTERNALID;
L_06BB:
EXTERNALMODE = OSTATE;
if (FORM != 0) goto L_06BD;
if (DECL != 0) goto L_06BD;
PARMS = PARMS + 1;
DUMPDIAG(0, NIL);
return;
L_06BD:
ENCODETYPE(TYPE, FORMAT, /*%A*/ /*addressof*/ &Q);
if (INTERNALID != _imp_str_literal("")) goto L_06BE;
Q.DIAGS = 0;
L_06BE:
DEFV->TYPE = Q.TYPE;
if (OFLAGS & 16 == 0) goto L_06BF;
DEFV->TYPE = 1;
DEFV->FORMAT = 4;
Q.IND = 1;
Q.SIZE = 4;
Q.ROUND = 3;
Q.BIAS = 0;
FORM = 1;
L_06BF:
if (FORM == 1) goto L_06C0;
Q.BIAS = 0;
L_06C0:
if (OFLAGS & 32 == 0) goto L_06C1;
DEFV->FLAGS = DEFV->FLAGS | 1048576;
L_06C1:
DECLSIZE = Q.SIZE;
DEFV->FORM = FORMMAP[FORM];
if (FORM != 4) goto L_06C2;
DEFV->EXTRA = PARMS;
PARAMETERMODE = -1;
BLOCKTYPE = -1;
if (DEFV->AREA != 0) goto L_06C3;
INTERFACE->FORMATS = INTERFACE->FORMATS + 1;
DEFV->AREA = INTERFACE->FORMATS;
L_06C3:
return;
L_06C2:
if (FORM != 3) goto L_06C4;
SETUSERLABEL(DECL);
if (LANGUAGEFLAGS & 1 == 0) goto L_06C5;
if (WSPSAVE != 0) goto L_06C6;
SAVEWSP();
L_06C6:
DEFV->EXTRA = WSPSAVE;
L_06C5:
goto L_06C7;
L_06C4:
if (FORM != 6) goto L_06C8;
DEFV->AREA = FREELABEL - VLB + 1;
DEFV->DISP = VLB;
DEFV->EXTRA = VUB;
N = FREELABEL + 1;
FREELABEL = N + VUB - VLB;
CONSTANTBASE = CONSTANTBASE + 3 & (~3);
SELECTCONSTANTAREA();
DEFV->FORMAT = /*indirectthrough*/ *CA;
DUMPWORD(VUB);
DUMPWORD(VLB);
DIR3(28, N, FREELABEL);
CONSTANTBASE = CONSTANTBASE + 4 * (VUB - VLB + 1);
SELECTCODEAREA();
goto L_06C7;
L_06C8:
if (7 > FORM) goto L_06C9;
if (FORM > 10) goto L_06C9;
PARAMETERMODE = 1;
BLOCKTYPE = SPEC;
if (8 > FORM) goto L_06CA;
if (FORM > 9) goto L_06CA;
DEFV->FLAGS = DEFV->FLAGS | 524288;
if (FORM != 9) goto L_06CB;
DEFV->FLAGS = DEFV->FLAGS | 8;
goto L_06CC;
L_06CB:
if (DEFV->TYPE > 5) goto L_06CD;
DEFV->TYPE = 1;
L_06CD:
L_06CC:
goto L_06CE;
L_06CA:
if (FORM != 10) goto L_06CF;
DEFV->FLAGS = DEFV->FLAGS | 2097152;
L_06CF:
L_06CE:
if (EXTERNALMODE != 1) goto L_06D0;
EXTERNALMODE = 3;
OSTATE = 3;
DEFV->FLAGS = DEFV->FLAGS | 32768;
goto L_06D1;
L_06D0:
if (EXTERNALMODE < 6) goto L_06D2;
if (EXTERNALMODE != 6) goto L_06D3;
DEFV->FLAGS = DEFV->FLAGS | 512;
DEFV->PRIM = Q.DIM;
goto L_06D4;
L_06D3:
DEFV->FLAGS = DEFV->FLAGS | 256;
L_06D4:
EXTERNALMODE = 3;
OSTATE = 3;
L_06D2:
L_06D1:
if (/*indirectthrough*/ *PARAMETERLIST <= 0) goto L_06D5;
DANGERMARKER = 1;
FRAME = FRAME + 3 & (~3);
DEFV->DISP = FRAME;
DEFV->BASE = /*indirectthrough*/ *LOCAL;
DEFV->FLAGS = DEFV->FLAGS | 4;
FRAME = FRAME + 4 * 2;
goto L_06D6;
L_06D5:
if (/*indirectthrough*/ *LOCAL < DANGERLEVEL) goto L_06D7;
DEFV->FLAGS = DEFV->FLAGS | 65536;
L_06D7:
L_06D6:
goto L_06C7;
L_06C9:
if (FORM == 11) goto L_06D8;
if (FORM != 13) goto L_06D9;
L_06D8:
Q.DIAGS = 0;
if (FORM != 13) goto L_06DA;
DECLSIZE = 4;
if (Q.TYPE != 8) goto L_06DB;
if (Q.SIZE != 1) goto L_06DB;
DECLSIZE = 4 * 2;
L_06DB:
DEFV->FLAGS = 8;
Q.ROUND = 3;
L_06DA:
Q.SIZE = 0;
goto L_06DC;
L_06D9:
if (FORM != 2) goto L_06DD;
Q.IND = 1;
Q.ROUND = 3;
if (Q.TYPE == 10) goto L_06DE;
DECLSIZE = 4;
if (Q.TYPE != 8) goto L_06DF;
if (Q.SIZE != 1) goto L_06DF;
DECLSIZE = 4 * 2;
L_06DF:
Q.SIZE = DECLSIZE;
L_06DE:
goto L_06DC;
L_06DD:
if (FORM != 1) goto L_06E0;
if (/*indirectthrough*/ *PARAMETERLIST <= 0) goto L_06E1;
if (Q.TYPE == 8) goto L_06E2;
if (Q.TYPE == 9) goto L_06E2;
if (Q.TYPE != 13) goto L_06E1;
L_06E2:
Q.SIZE = 4;
if (OFLAGS & 16 != 0) goto L_06E3;
DEFV->FLAGS = DEFV->FLAGS | 131072;
L_06E3:
L_06E1:
goto L_06DC;
L_06E0:
Q.DIAGS = 0;
Q.ROUND = 3;
Q.SIZE = 4 * 2;
if (FORM != 14) goto L_06E4;
DEFV->FLAGS = 8;
L_06E4:
DEFV->FLAGS = DEFV->FLAGS | 64;
L_06DC:
if (EXTERNALMODE != 0) goto L_06E5;
DEFV->BASE = /*indirectthrough*/ *LOCAL;
if (DECL != 0) goto L_06E6;
FRAME = FRAME + Q.ROUND & (~Q.ROUND);
DEFV->DISP = FRAME;
FRAME = FRAME + Q.SIZE;
goto L_06E7;
L_06E6:
if (/*indirectthrough*/ *PARAMETERLIST <= 0) goto L_06E8;
if (Q.ROUND >= 3) goto L_06E9;
Q.ROUND = 3;
L_06E9:
if (Q.SIZE >= 4) goto L_06EA;
Q.SIZE = 4;
L_06EA:
FRAME = FRAME + 3 & (~3);
DEFV->DISP = FRAME;
FRAME = FRAME + Q.SIZE;
goto L_06E7;
L_06E8:
if (Q.SIZE <= 256) goto L_06EB;
Q.IND = 1;
FRAME = (FRAME & (~3)) - 4;
DEFV->DISP = FRAME;
DEFV->FORM = 15;
DEFV->FLAGS = DEFV->FLAGS & (~1048576);
N = Q.SIZE + 3 & (~3);
ATTRIBUTES = ATTRIBUTES | 32;
if (UNASSIGNED == 0) goto L_06EC;
ATTRIBUTES = ATTRIBUTES | 4;
VV = LITERAL(N);
LOAD(VV, 5);
RELEASEANDDROP(VV);
PRIM(56);
goto L_06ED;
L_06EC:
VV = LOCALINTEGER(-N);
VV->BASE = 13;
VV->FORM = 0;
LOAD(VV, 13);
DROP(VV);
L_06ED:
VV = LOCALINTEGER(FRAME);
PLANT2(67108864, 13, VV);
RELEASEANDDROP(VV);
if (WSPSAVE == 0) goto L_06EE;
SAVEWSP();
L_06EE:
goto L_06EF;
L_06EB:
FRAME = (FRAME & (~Q.ROUND)) - Q.SIZE;
DEFV->DISP = FRAME;
L_06EF:
L_06E7:
if (TF & 256 == 0) goto L_06F0;
DEFV->FLAGS = DEFV->FLAGS | 128;
L_06F0:
if (Q.DIAGS == 0) goto L_06F1;
if (AMODE > 0) goto L_06F1;
DUMPDIAG(/*indirectthrough*/ *LOCAL, /*%A*/ /*addressof*/ &Q);
L_06F1:
goto L_06F2;
L_06E5:
OWNEXTRA = 0;
if (SPEC != 0) goto L_06F3;
INITFLAG = 0;
OWNTYPE = Q.TYPE;
OWNFORM = FORM;
if (EXTERNALMODE != 2) goto L_06F4;
if (FORM == 2) goto L_06F5;
if (FORM == 12) goto L_06F5;
if (FORM != 14) goto L_06F6;
L_06F5:
DEFV->FORM = 1;
INITFLAG = -1;
return;
L_06F6:
CONSTANTBASE = CONSTANTBASE + 3 & (~3);
AREA = 512;
AT = /*%A*/ /*addressof*/ &CONSTANTBASE;
DEFV->AREA = 512;
Q.DIAGS = 0;
goto L_06F7;
L_06F4:
AREA = 256;
AT = /*%A*/ /*addressof*/ &OWNBASE;
DEFV->BASE = 10;
if (FORM == 11) goto L_06F8;
if (FORM != 13) goto L_06F9;
L_06F8:
OWNARRAYBASE = OWNARRAYBASE + 3 & (~3);
AREA = 768;
AT = /*%A*/ /*addressof*/ &OWNARRAYBASE;
OSTATE = 255;
L_06F9:
L_06F7:
if (OWNFORM == 12) goto L_06FA;
if (OWNFORM != 14) goto L_06FB;
L_06FA:
OWNEXTRA = 1;
L_06FB:
if (OWNTYPE != 8) goto L_06FC;
if (DEFV->FORMAT != 1) goto L_06FC;
if (OWNFORM == 2) goto L_06FD;
if (OWNFORM != 13) goto L_06FC;
L_06FD:
OWNEXTRA = 1;
L_06FC:
if (OWNFORM == 1) goto L_06FE;
if (OWNFORM == 11) goto L_06FE;
OWNTYPE = 1;
Q.ROUND = 3;
L_06FE:
/*indirectthrough*/ *AT = /*indirectthrough*/ */*indirectthrough*/ *AT + Q.ROUND & (~Q.ROUND);
DEFV->DISP = /*indirectthrough*/ *AT;
if (FORM == 11) goto L_06FF;
if (FORM != 13) goto L_0700;
L_06FF:
DEFV->FLAGS = DEFV->FLAGS | 64;
N = DEFV->DISP - VLB * DECLSIZE;
OWNBASE = OWNBASE + 3 & (~3);
DEFV->BASE = 10;
DEFV->DISP = OWNBASE;
DEFV->AREA = 0;
SELECTOWNAREA();
DIR4(17, (unsigned int)AREA >> 8, N, 0);
/*indirectthrough*/ *CA = /*indirectthrough*/ */*indirectthrough*/ *CA + 8;
SELECTCODEAREA();
VALUE = DEFAULTVALUE;
INITFLAG = 1;
DEFV->ADATA = _imp_NEW(ATYPE);
U_100E:
DEFV->ADATA = 0;
L_0700:
if (EXTERNALMODE != 3) goto L_0701;
DUMPEXTERNAL(1, DEFV);
DEFV->AREA = 0;
DEFV->FLAGS = DEFV->FLAGS & (~8388608);
L_0701:
if (Q.DIAGS == 0) goto L_0702;
DUMPDIAG(DEFV->BASE, /*%A*/ /*addressof*/ &Q);
L_0702:
goto L_0703;
L_06F3:
DEFV->FLAGS = DEFV->FLAGS | 8388608;
if (FORM == 11) goto L_0704;
if (FORM != 13) goto L_0705;
L_0704:
DEFV->FLAGS = DEFV->FLAGS | 64;
L_0705:
DUMPEXTERNAL(0, DEFV);
L_0703:
L_06F2:
L_06C7:
ALTALIGN = ALTALIGN & (~Q.ROUND);
ROUND = Q.ROUND;
DTYPE = Q.DTYPE;
} /* DEFINEVAR */
void DUMPTEXT(int MAX) {
int J;
int LEN;
LEN = /*indirectthrough*/ *_imp_LENGTH(/*%A*/ /*addressof*/ &VALUE.STRING);
if (MAX != 0) goto L_0706;
MAX = LEN;
goto L_0707;
L_0706:
if (LEN <= MAX) goto L_0708;
LEN = MAX;
WARN(0, _imp_str_literal("String truncated"));
L_0708:
L_0707:
DUMPBYTE(LEN);
J = 0; /*%for J = 1, 1, MAX %cycle*/
L_0709:
if (J == MAX) goto L_070A;
J += 1;
if (J <= LEN) goto L_070C;
DUMPBYTE(0);
goto L_070D;
L_070C:
DUMPBYTE(/*indirectthrough*/ *_imp_CHARNO(/*%A*/ /*addressof*/ &VALUE.STRING, J));
L_070D:
goto L_0709;
L_070A:
} /* DUMPTEXT */
void ADUMP(void) {
struct STACKFM RV;
int J;
int DISP;
int KEY;
if (OWNTYPE == 1) goto L_070B;
if (OWNTYPE != 5) goto L_070E;
L_070B:
if (STACK != NIL) goto L_070F;
DUMPWORD(VALUE.INTEGER);
goto L_0710;
L_070F:
if (/*%A*/ /*addressof*/ &STACK->RECORD == NIL) goto L_0711;
FAIL(_imp_str_literal("Adump/0"));
L_0711:
SIMPLIFY(STACK);
DISP = STACK->DISP;
if (/*%A*/ /*addressof*/ &STACK->RECORD != NIL) goto L_0712;
if (/*%A*/ /*addressof*/ &STACK->INDEX == NIL) goto L_0713;
L_0712:
FAIL(_imp_str_literal("Adump/1"));
L_0713:
if (STACK->FORM != 0) goto L_0714;
if (STACK->BASE != 10) goto L_0715;
KEY = 0;
goto L_0716;
L_0715:
if (STACK->BASE != 0) goto L_0717;
if (STACK->AREA != 512) goto L_0718;
KEY = -1;
goto L_0719;
L_0718:
KEY = -STACK->AREA;
if (KEY > 0) goto L_071A;
FAIL(_imp_str_literal("Adump/4"));
L_071A:
L_0719:
goto L_0716;
L_0717:
FAIL(_imp_str_literal("Adump/2"));
L_0716:
DIR3(30, KEY, DISP);
goto L_071B;
L_0714:
FAIL(_imp_str_literal("Adump/3"));
L_071B:
/*indirectthrough*/ *CA = /*indirectthrough*/ */*indirectthrough*/ *CA + 4;
POPRELEASEANDDROP();
L_0710:
goto L_071C;
L_070E:
if (OWNTYPE == 4) goto L_071D;
if (OWNTYPE != 12) goto L_071E;
L_071D:
if (0 > VALUE.INTEGER) goto L_071F;
if (VALUE.INTEGER <= 255) goto L_0720;
L_071F:
WARN(0, _imp_str_literal("value truncated to 8 bits unsigned"));
L_0720:
DUMPBYTE(VALUE.INTEGER);
goto L_071C;
L_071E:
if (OWNTYPE != 2) goto L_0721;
if (-32768 > VALUE.INTEGER) goto L_0722;
if (VALUE.INTEGER <= 32767) goto L_0723;
L_0722:
WARN(0, _imp_str_literal("value truncated to 16 bits signed"));
L_0723:
DUMPHALF(VALUE.INTEGER);
goto L_071C;
L_0721:
if (OWNTYPE == 6) goto L_0724;
if (OWNTYPE != 7) goto L_0725;
L_0724:
RV.RVAL = VALUE.REAL;
CONVERTFORMAT(/*%A*/ /*addressof*/ &RV, OWNTYPE);
DUMPWORD(RV.RHIGH);
if (OWNTYPE != 7) goto L_0726;
DUMPWORD(RV.RLOW);
L_0726:
goto L_071C;
L_0725:
if (OWNTYPE != 8) goto L_0727;
DUMPTEXT(DECLSIZE - 1);
goto L_071C;
L_0727:
if (OWNTYPE == 9) goto L_0728;
if (OWNTYPE != 13) goto L_0729;
L_0728:
J = 0; /*%for J = 1, 1, DECLSIZE %cycle*/
L_072A:
if (J == DECLSIZE) goto L_072B;
J += 1;
DUMPBYTE(0);
goto L_072A;
L_072B:
goto L_071C;
L_0729:
FAIL(_imp_str_literal("Init"));
L_071C:
L_072D:
if (OWNEXTRA <= 0) goto L_072E;
DUMPWORD(0);
OWNEXTRA = OWNEXTRA - 1;
goto L_072D;
L_072E:
} /* ADUMP */
void INIT(int N) {
if (STACK == NIL) goto L_072F;
if (!(ICONST(STACK))) goto L_072F;
VALUE.INTEGER = STACK->DISP;
CONSTANTTYPE = 1;
POPRELEASEANDDROP();
L_072F:
if (6 > OWNTYPE) goto L_0730;
if (OWNTYPE > 7) goto L_0730;
if (CONSTANTTYPE != 1) goto L_0731;
VALUE.REAL = VALUE.INTEGER;
L_0731:
L_0730:
if (INITFLAG >= 0) goto L_0732;
DEFV->DISP = VALUE.INTEGER;
goto L_0733;
L_0732:
if (OSTATE != 2) goto L_0734;
SELECTCONSTANTAREA();
goto L_0735;
L_0734:
if (OSTATE != 255) goto L_0736;
SELECTOWNARRAYAREA();
goto L_0735;
L_0736:
SELECTOWNAREA();
L_0735:
L_0737:
if (N <= 0) goto L_0738;
N = N - 1;
ADUMP();
goto L_0737;
L_0738:
SELECTCODEAREA();
L_0733:
VALUE = DEFAULTVALUE;
DEFV->FLAGS = DEFV->FLAGS | 128;
} /* INIT */
void DIMENSION(int DIM, int N) {
int X;
int STATICARRAY;
STATICARRAY = 0;
int J;
struct VARFM *V;
struct AFM DOPE;
struct STACKFM *B;
struct STACKFM *TOTAL;
struct STACKFM *DOPEVECTOR;
struct STACKFM *ZERO;
struct STACKFM *HEADER;
struct STACKFM *L1;
struct STACKFM *L2;
struct STACKFM *U1;
struct STACKFM *U2;
struct STACKFM *M1;
struct STACKFM *M2;
struct QFM Q;
int ALLCONST(void) {
struct STACKFM *P;
struct BOUNDFM *B;
int J;
int N;
P = STACK;
N = DECLSIZE;
J = DIM - -1; /*%for J = DIM, -1, 1 %cycle*/
L_0739:
if (J == 1) goto L_073A;
J += -1;
B = /*%A*/ /*addressof*/ &DOPE.BOUND[J];
if (ICONST(P)) goto L_073C;
return 0 /*FALSE*/;
L_073C:
B->UPPER = P->DISP;
P = /*%A*/ /*addressof*/ &P->STACK;
if (ICONST(P)) goto L_073D;
return 0 /*FALSE*/;
L_073D:
B->LOWER = P->DISP;
P = /*%A*/ /*addressof*/ &P->STACK;
B->MULT = N;
N = B->UPPER - B->LOWER + 1;
if (N >= 0) goto L_073E;
FAIL(_imp_str_literal("Array inside-out"));
L_073E:
goto L_0739;
L_073A:
DOPE.TOTALSIZE = N;
DOPE.BASE = /*indirectthrough*/ *LOCAL;
DOPE.DIMENSION = DIM;
DOPE.ZERODISPLACEMENT = 0;
N = 0;
J = 0; /*%for J = 1, 1, DIM %cycle*/
L_073F:
if (J == DIM) goto L_0740;
J += 1;
B = /*%A*/ /*addressof*/ &DOPE.BOUND[J];
DOPE.ZERODISPLACEMENT = DOPE.ZERODISPLACEMENT * N - B->LOWER;
N = B->MULT;
DOPE.TOTALSIZE = DOPE.TOTALSIZE * N;
goto L_073F;
L_0740:
DOPE.ZERODISPLACEMENT = DOPE.ZERODISPLACEMENT * N;
J = 0; /*%for J = 1, 1, DIM * 2 %cycle*/
L_0741:
if (J == DIM * 2) goto L_0742;
J += 1;
POPRELEASEANDDROP();
goto L_0741;
L_0742:
STATICARRAY = 1;
CONSTANTBASE = CONSTANTBASE + 3 & -4;
DOPE.DV = CONSTANTBASE;
if (/*indirectthrough*/ *PARAMETERLIST != 0) goto L_0743;
DOPE.TOTALSIZE = DOPE.TOTALSIZE + 3 & (~3);
L_0743:
SELECTCONSTANTAREA();
DUMPWORD(DIM);
DUMPWORD(DOPE.TOTALSIZE);
DUMPWORD(DOPE.ZERODISPLACEMENT);
J = 0; /*%for J = 1, 1, DIM %cycle*/
L_0744:
if (J == DIM) goto L_0745;
J += 1;
B = /*%A*/ /*addressof*/ &DOPE.BOUND[J];
DUMPWORD(B->LOWER);
DUMPWORD(B->UPPER);
DUMPWORD(B->MULT);
goto L_0744;
L_0745:
SELECTCODEAREA();
return 1 /*TRUE*/;
} /* ALLCONST */
ATTRIBUTES = ATTRIBUTES | 32;
if (!(ALLCONST())) goto L_0746;
if (N != 0) goto L_0747;
return;
L_0747:
if (/*indirectthrough*/ *PARAMETERLIST == 0) goto L_0748;
X = PARMS + N;
FRAME = FRAME + ROUND & (~ROUND);
L_0749:
if (N <= 0) goto L_074A;
N = N - 1;
X = X - 1;
V = VAR(X);
V->DISP = FRAME + DOPE.ZERODISPLACEMENT;
FRAME = FRAME + DOPE.TOTALSIZE;
V->FORM = 1;
V->FLAGS = V->FLAGS | 2;
V->ADATA = _imp_NEW(ATYPE);
U_100F:
V->ADATA = DOPE;
if (DEBUG == 0) goto L_074B;
Q.DFORM = 0;
if (V->FORMAT >= 0) goto L_074C;
Q.DFORM = VAR(-V->FORMAT)->AREA;
L_074C:
Q.POINTED = NIL;
Q.IND = 0;
Q.DTYPE = DTYPE;
DEFV = V;
DUMPDIAG(17, /*%A*/ /*addressof*/ &Q);
L_074B:
goto L_0749;
L_074A:
return;
L_0748:
ZERO = NIL;
if (DOPE.ZERODISPLACEMENT == 0) goto L_074D;
ZERO = LITERAL(DOPE.ZERODISPLACEMENT);
L_074D:
TOTAL = LITERAL(DOPE.TOTALSIZE);
DOPEVECTOR = LITERAL(DOPE.DV);
DOPEVECTOR->FORM = 0;
DOPEVECTOR->AREA = 512;
LOAD(DOPEVECTOR, 4);
if (ZERO == NIL) goto L_074E;
LOAD(ZERO, 3);
L_074E:
LOAD(TOTAL, 2);
goto L_074F;
L_0746:
if (DIM != 1) goto L_0750;
U1 = STACK;
STACK = /*%A*/ /*addressof*/ &U1->STACK;
L1 = STACK;
STACK = /*%A*/ /*addressof*/ &L1->STACK;
M1 = LITERAL(DECLSIZE);
LOADTRIO(U1, 5, L1, 4, M1, 6);
RELEASEANDDROPPAIR(L1, U1);
RELEASEANDDROP(M1);
PRIM(43);
goto L_0751;
L_0750:
if (DIM != 2) goto L_0752;
U2 = STACK;
STACK = /*%A*/ /*addressof*/ &U2->STACK;
L2 = STACK;
STACK = /*%A*/ /*addressof*/ &L2->STACK;
M2 = LITERAL(DECLSIZE);
U1 = STACK;
STACK = /*%A*/ /*addressof*/ &U1->STACK;
L1 = STACK;
STACK = /*%A*/ /*addressof*/ &L1->STACK;
LOADPAIR(U1, 5, L1, 4);
LOADTRIO(U2, 8, L2, 7, M2, 9);
LOADPAIR(U1, 5, L1, 4);
LOADTRIO(U2, 8, L2, 7, M2, 9);
RELEASEANDDROPPAIR(L1, U1);
RELEASEANDDROPPAIR(L2, U2);
RELEASEANDDROP(M2);
PRIM(44);
goto L_0751;
L_0752:
X = DECLSIZE;
J = 0; /*%for J = 1, 1, DIM %cycle*/
L_0753:
if (J == DIM) goto L_0754;
J += 1;
PUSHLITERAL(X);
X = 0;
B = STACK;
STACK = /*%A*/ /*addressof*/ &B->STACK;
PUSH(B);
RELEASEANDDROP(B);
B = STACK;
STACK = /*%A*/ /*addressof*/ &B->STACK;
PUSH(B);
RELEASEANDDROP(B);
goto L_0753;
L_0754:
PUSHLITERAL(0);
PUSHLITERAL(0);
PUSHLITERAL(DIM);
PRIM(17);
L_0751:
TOTAL = REGISTER(2);
ZERO = REGISTER(3);
DOPEVECTOR = REGISTER(4);
L_074F:
FRAME = FRAME & (~3);
HEADER = LOCALINTEGER(FRAME - 4);
LOADADDRESS(HEADER, 5);
X = /*indirectthrough*/ */*indirectthrough*/ *VARS - N;
L_0756:
if (N <= 0) goto L_0757;
N = N - 1;
X = X + 1;
V = VAR(X);
FRAME = FRAME - 2 * 4;
V->DISP = FRAME;
V->FLAGS = V->FLAGS | 128 | 64;
V->FORM = 1;
PLANT1(4194304, 13, 13, JUST(2));
if (ZERO != NIL) goto L_0758;
PLANT1(27262976, 0, 1, JUST(13));
goto L_0759;
L_0758:
PLANT1(8388608, 13, 1, JUST(3));
L_0759:
PLANT4(134217728 | 2097152, 5, 9);
goto L_0756;
L_0757:
RELEASEANDDROP(TOTAL);
if (ZERO == NIL) goto L_075A;
RELEASEANDDROP(ZERO);
L_075A:
RELEASEANDDROP(DOPEVECTOR);
RELEASEANDDROP(HEADER);
} /* DIMENSION */
void SWOP(void) {
struct STACKFM *T;
T = STACK;
STACK = /*%A*/ /*addressof*/ &T->STACK;
T->STACK = /*%A*/ /*addressof*/ &STACK->STACK;
STACK->STACK = T;
} /* SWOP */
void DEFINERANGE(void) {
int T;
struct VARFM *V;
T = TAG();
V = VAR(T);
CLEARVARS(T);
CONSTANTBOUNDS();
V->DISP = VLB;
V->EXTRA = VUB;
V->FORMAT = -1;
} /* DEFINERANGE */
void TESTRANGE(struct STACKFM * S, struct VARFM * V) {
struct STACKFM *R;
struct STACKFM *L;
struct STACKFM *U;
struct STACKFM *LOW;
struct STACKFM *HIGH;
if (INTERFACE->OPTIONS & 128 != 0) goto L_075B;
return;
L_075B:
if (S != 13) goto L_075C;
LOW = LITERAL(V->DISP);
HIGH = LITERAL(V->EXTRA);
if (S == 0) goto L_075D;
LOADUP(/*%A*/ /*addressof*/ &S);
L_075D:
if (/*%A*/ /*addressof*/ &S == NIL) goto L_075E;
BUILDSET(/*%A*/ /*addressof*/ &S);
L_075E:
R = COPY(/*%A*/ /*addressof*/ &S);
AMAP(R);
LOADTRIO(LOW, 2, HIGH, 3, R, 1);
PRIM(46);
RELEASEANDDROPPAIR(LOW, HIGH);
RELEASEANDDROP(R);
return;
L_075C:
if (!(ICONST(/*%A*/ /*addressof*/ &S))) goto L_075F;
if (V->DISP > S) goto L_0760;
if (S > V->EXTRA) goto L_0760;
return;
L_0760:
WARN(1, _imp_str_literal("Range violation"));
L_075F:
LOADUP(/*%A*/ /*addressof*/ &S);
R = COPY(/*%A*/ /*addressof*/ &S);
U = LITERAL(V->EXTRA);
if (V->DISP == 0) goto L_0761;
L = LITERAL(V->DISP);
LOADTRIO(R, 2, L, 3, U, 4);
PRIM(16);
RELEASEANDDROP(L);
goto L_0762;
L_0761:
LOADPAIR(R, 2, U, 4);
PRIM(33);
L_0762:
RELEASEANDDROPPAIR(R, U);
} /* TESTRANGE */
void DUPLICATE(void) {
struct STACKFM *V;
V = COPY(STACK);
V->STACK = STACK;
STACK = V;
} /* DUPLICATE */
void STACKWORKVARIABLE(void) {
int T;
struct VARFM *V;
T = TAG();
V = VAR(T);
CLEARVARS(T);
if (V->BASE != 0) goto L_0763;
FRAME = (FRAME & -4) - 4;
V->TYPE = 1;
V->FORM = 1;
V->BASE = /*indirectthrough*/ *LOCAL;
V->DISP = FRAME;
V->FLAGS = 128;
L_0763:
STACKVAR(T);
} /* STACKWORKVARIABLE */
void CLAIMWITH(int N) {
int FORMAT;
struct WITHFM *W;
W = _imp_NEW(WITHFMTYPE);
W->LINK = WITHS;
WITHS = W;
W->KEY = /*indirectthrough*/ *N;
if (/*%A*/ /*addressof*/ &STACK->INDEX != NIL) goto L_073B;
if (/*%A*/ /*addressof*/ &STACK->RECORD != NIL) goto L_073B;
if (STACK->FORM != 1) goto L_073B;
if (LOCKED(STACK->BASE)) goto L_0764;
L_073B:
FORMAT = STACK->FORMAT;
AMAP(STACK);
STAB(STACK);
STACK->FORMAT = FORMAT;
STACK->FLAGS = STACK->FLAGS | 4194304;
L_0764:
W->DATA = STACK->DATA;
POPRELEASEANDDROP();
} /* CLAIMWITH */
void RELEASEWITH(int N) {
struct WITHFM BASE;
struct WITHFM *W;
W = /*%A*/ /*addressof*/ &BASE;
struct WITHFM *X;
BASE.LINK = WITHS;
L_0765:
if (/*%A*/ /*addressof*/ &W->LINK == NIL) goto L_0766;
if (W->LINK != N) goto L_0767;
X = /*%A*/ /*addressof*/ &W->LINK;
W->LINK = /*%A*/ /*addressof*/ &X->LINK;
WITHS = /*%A*/ /*addressof*/ &BASE.LINK;
_imp_DISPOSE(X);
return;
L_0767:
W = /*%A*/ /*addressof*/ &W->LINK;
goto L_0765;
L_0766:
FAIL(_imp_str_literal("No use"));
} /* RELEASEWITH */
void USEWITH(int N) {
int FORMAT;
struct WITHFM *W;
W = WITHS;
L_0768:
if (W == NIL) goto L_0769;
if (W->KEY != N) goto L_076A;
STACKINTEGER(0);
STACK->DATA = W->DATA;
if (STACK->FLAGS & 4194304 == 0) goto L_076B;
FORMAT = STACK->FORMAT;
VMAP(STACK, 1);
STACK->FORMAT = FORMAT;
L_076B:
return;
L_076A:
W = /*%A*/ /*addressof*/ &W->LINK;
goto L_0768;
L_0769:
FAIL(_imp_str_literal("No use"));
} /* USEWITH */
void BUILDSET(struct STACKFM * S) {
struct STACKFM *W;
struct STACKFM *Z;
struct STACKFM *OLDLINK;
struct MEMBERFM *M;
struct MEMBERFM *X;
struct CSETFM {
union {
struct {
unsigned char SET[32];
};
};
};
struct CSETFM C;
int DUMPED;
DUMPED = 0;
int MARKED;
MARKED = 0;
int INWORK;
INWORK = 0;
int LOW;
int HIGH;
int OP;
int OLDOPER;
void DUMPSET(void) {
int J;
DUMPED = 1;
CONSTANTBASE = CONSTANTBASE + 3 & (~3);
S = 13;
S = CONSTANTBASE;
S = 1;
S = 512;
SELECTCONSTANTAREA();
J = -1; /*%for J = 0, 1, 31 %cycle*/
L_076C:
if (J == 31) goto L_076D;
J += 1;
DUMPBYTE(C.SET[J]);
goto L_076C;
L_076D:
SELECTCODEAREA();
} /* DUMPSET */
void MARK(int N) {
int W;
if (0 > N) goto L_076E;
if (N <= 255) goto L_076F;
L_076E:
WARN(1,
_imp_join((_imp_string)(_imp_str_literal("Set element out of range ")), (_imp_string)(_imp_ITOS(N, 0))));
return;
L_076F:
W = (unsigned int)N >> 3;
C.SET[W] = C.SET[W] | 1 << (N & 7);
MARKED = 1;
} /* MARK */
if (DIAG & 8 == 0) goto L_0770;
MONITOR(/*%A*/ /*addressof*/ &S, _imp_str_literal("Bset->"));
L_0770:
OLDLINK = /*%A*/ /*addressof*/ &S;
S = NIL;
OLDOPER = S;
S = 0;
C = 0;
M = /*%A*/ /*addressof*/ &S;
S = NIL;
S.LINK = S.LINK & (~16384);
L_0771:
if (M == NIL) goto L_0772;
X = M;
M = /*%A*/ /*addressof*/ &M->LINK;
if (X->CONST == 0) goto L_0773;
HIGH = X->A;
DROP(/*%A*/ /*addressof*/ &X->A);
if (/*%A*/ /*addressof*/ &X->B != NIL) goto L_0774;
MARK(HIGH);
goto L_0775;
L_0774:
LOW = X->B;
DROP(/*%A*/ /*addressof*/ &X->B);
L_0776:
if (LOW > HIGH) goto L_0777;
MARK(LOW);
LOW = LOW + 1;
goto L_0776;
L_0777:
L_0775:
goto L_0778;
L_0773:
if (INWORK != 0) goto L_0779;
W = CLAIMWORKAREA(32, 13);
if (MARKED == 0) goto L_077A;
if (DUMPED != 0) goto L_077B;
DUMPSET();
L_077B:
SETASSIGN(/*%A*/ /*addressof*/ &S, W);
RELEASE(S);
MARKED = 0;
goto L_077C;
L_077A:
Z = LITERAL(0);
Z->FLAGS = 16384;
SETASSIGN(Z, W);
RELEASEANDDROP(Z);
L_077C:
S.DATA = W->DATA;
DROP(W);
DUMPED = 1;
INWORK = 1;
L_0779:
AMAP(/*%A*/ /*addressof*/ &S);
LOADPAIR(/*%A*/ /*addressof*/ &S, 9, /*%A*/ /*addressof*/ &X->A, 2);
if (/*%A*/ /*addressof*/ &X->B != NIL) goto L_077D;
OP = 20;
goto L_077E;
L_077D:
LOADTRIO(/*%A*/ /*addressof*/ &X->B, 1, /*%A*/ /*addressof*/ &S, 9, /*%A*/ /*addressof*/ &X->A, 2);
RELEASEANDDROP(/*%A*/ /*addressof*/ &X->B);
OP = 28;
L_077E:
PRIM(OP);
VMAP(/*%A*/ /*addressof*/ &S, 13);
S.LINK = S.LINK | 262144;
RELEASEANDDROP(/*%A*/ /*addressof*/ &X->A);
L_0778:
_imp_DISPOSE(X);
goto L_0771;
L_0772:
if (DUMPED != 0) goto L_077F;
DUMPSET();
L_077F:
S = OLDLINK;
S = OLDOPER;
if (DIAG & 8 == 0) goto L_0780;
MONITOR(/*%A*/ /*addressof*/ &S, _imp_str_literal("Bset<-"));
L_0780:
} /* BUILDSET */
void COMPILEIN(int STACKIT) {
int N;
struct STACKFM *V;
struct STACKFM *SET;
struct STACKFM *C;
SET = STACK;
V = /*%A*/ /*addressof*/ &SET->STACK;
STACK = /*%A*/ /*addressof*/ &V->STACK;
if (/*%A*/ /*addressof*/ &SET->MEMBERS == NIL) goto L_0781;
BUILDSET(SET);
L_0781:
if (SET->OPER == 0) goto L_0782;
LOADUP(SET);
L_0782:
if (SET->FLAGS & 16384 == 0) goto L_0783;
if (/*indirectthrough*/ *STACKIT == 0) goto L_0784;
C = LITERAL(0);
C->STACK = STACK;
STACK = C;
goto L_0785;
L_0784:
DUMPWORD(-514850816);
L_0785:
RELEASEANDDROP(SET);
RELEASEANDDROP(V);
return;
L_0783:
if (!(ICONST(V))) goto L_0786;
if (0 > V->DISP) goto L_0786;
if (V->DISP > 255) goto L_0786;
ADVANCE(SET, 1, (unsigned int)V->DISP >> 5 << 2);
OPERATE(9, SET, LITERAL(1 << (V->DISP & 31)));
TESTZERO(SET);
goto L_0787;
L_0786:
AMAP(SET);
LOADPAIR(V, 2, SET, 3);
PRIM(11);
L_0787:
RELEASEANDDROPPAIR(SET, V);
if (/*indirectthrough*/ *STACKIT == 0) goto L_0788;
STACKTRUEORFALSE(6);
L_0788:
} /* COMPILEIN */
void ADDMEMBER(int N) {
struct MEMBERFM BASE;
struct MEMBERFM *M;
struct MEMBERFM *P;
struct STACKFM *A;
struct STACKFM *B;
B = NIL;
int ITEMS;
ITEMS = 0;
A = STACK;
STACK = /*%A*/ /*addressof*/ &A->STACK;
if (N == 0) goto L_0789;
B = STACK;
STACK = /*%A*/ /*addressof*/ &B->STACK;
if (!(ICONST(A))) goto L_078A;
if (!(ICONST(B))) goto L_078A;
if (A->DISP >= B->DISP) goto L_078A;
DROP(A);
DROP(B);
return;
L_078A:
L_0789:
M = _imp_NEW(MEMBERFMTYPE);
M->A = A;
M->B = B;
if (/*%A*/ /*addressof*/ &STACK->MEMBERS == NIL) goto L_078B;
ITEMS = STACK->MEMBERS;
L_078B:
if (!(ICONST(A))) goto L_078C;
if (B == NIL) goto L_078D;
if (!(ICONST(B))) goto L_078C;
L_078D:
M->CONST = 1;
M->LINK = /*%A*/ /*addressof*/ &STACK->MEMBERS;
STACK->MEMBERS = M;
goto L_078E;
L_078C:
M->CONST = 0;
BASE.LINK = /*%A*/ /*addressof*/ &STACK->MEMBERS;
P = /*%A*/ /*addressof*/ &BASE;
L_078F:
if (/*%A*/ /*addressof*/ &P->LINK == NIL) goto L_0790;
if (P->LINK == 0) goto L_0790;
P = /*%A*/ /*addressof*/ &P->LINK;
goto L_078F;
L_0790:
M->LINK = /*%A*/ /*addressof*/ &P->LINK;
P->LINK = M;
STACK->MEMBERS = /*%A*/ /*addressof*/ &BASE.LINK;
L_078E:
STACK->MEMBERS = ITEMS + 1;
STACK->FLAGS = STACK->FLAGS & (~16384);
} /* ADDMEMBER */
void STACKDATASIZE(void) {
int T;
int N;
T = PENDING;
_imp_READSYMBOL(/*%A*/ /*addressof*/ &PENDING);
if (T != 0) goto L_0791;
T = TAG();
N = VAR(T)->FORMAT;
if (N >= 0) goto L_0792;
N = VAR(-N)->FORMAT;
L_0792:
goto L_0793;
L_0791:
if (0 > T) goto L_0794;
if (T > 13) goto L_0794;
N = TYPESIZE[T];
goto L_0795;
L_0794:
N = 0;
L_0795:
if (N != 0) goto L_0796;
FAIL(_imp_str_literal("Unknown type"));
L_0796:
L_0793:
STACKINTEGER(N);
} /* STACKDATASIZE */
void TESTFORNIL(void) {
if (UNASSIGNED == 0) goto L_0797;
STACK->FLAGS = STACK->FLAGS | 128;
LOAD(STACK, 2);
PRIM(13);
L_0797:
} /* TESTFORNIL */
void SETVARIANTCOUNT(int N) {
struct STACKFM *V;
V = COPY(STACK);
struct STACKFM *COUNT;
VMAP(V, 2);
COUNT = LITERAL(/*indirectthrough*/ *N);
SIMPLE(COUNT, V);
RELEASEANDDROPPAIR(COUNT, V);
} /* SETVARIANTCOUNT */
void TESTVARIANTCOUNT(int N) {
struct STACKFM *V;
V = COPY(STACK);
struct STACKFM *COUNT;
COUNT = LITERAL(/*indirectthrough*/ *N);
VMAP(V, 2);
LOADPAIR(V, 4, COUNT, 1);
PRIM(36);
RELEASEANDDROPPAIR(V, COUNT);
} /* TESTVARIANTCOUNT */
void CHECKNOTLONGNEW(void) {
struct STACKFM *V;
V = COPY(STACK);
AMAP(V);
VMAP(V, 2);
TESTZERO(V);
INVERT = 0;
PRIM(26);
RELEASEANDDROP(V);
} /* CHECKNOTLONGNEW */
void CHECKDYNAMICBOUNDS(void) {
struct STACKFM *LOWER;
struct STACKFM *UPPER;
UPPER = STACK;
LOWER = /*%A*/ /*addressof*/ &UPPER->STACK;
STACK = /*%A*/ /*addressof*/ &LOWER->STACK;
LOADTRIO(STACK, 2, LOWER, 3, UPPER, 4);
PRIM(16);
RELEASEANDDROPPAIR(LOWER, UPPER);
} /* CHECKDYNAMICBOUNDS */
void LOCALISE(void) {
struct STACKFM *LOC;
struct STACKFM *SIZE;
struct STACKFM *ZERO;
ZERO = STACK;
SIZE = /*%A*/ /*addressof*/ &ZERO->STACK;
LOC = /*%A*/ /*addressof*/ &SIZE->STACK;
STACK = /*%A*/ /*addressof*/ &LOC->STACK;
FORGETDESTINATION(LOC);
AMAP(LOC);
LOADTRIO(SIZE, 1, ZERO, 2, LOC, 3);
PRIM(14);
ATTRIBUTES = ATTRIBUTES | 32;
RELEASEANDDROPPAIR(SIZE, ZERO);
RELEASEANDDROP(LOC);
} /* LOCALISE */
void ENDOFBLOCK(void) {
if (/*indirectthrough*/ *LOCAL == 128) goto L_0798;
if (UNCONDJUMP == /*indirectthrough*/ *CA) goto L_0799;
if (AVAR != 10) goto L_0799;
if (AVAR->P & 256 != 0) goto L_0799;
RETURN(0);
L_0799:
L_0798:
} /* ENDOFBLOCK */
void PROCESSINCLUDEFILE(void) {
GETSTRING(/*%A*/ /*addressof*/ &INCLUDEFILE);
DIRSTRING(4, /*%A*/ /*addressof*/ &INCLUDEFILE);
} /* PROCESSINCLUDEFILE */
static const void *C[256] = {NULL};
AT = 0;
PENDINGAUTO = 0;
OLDFRAME = FRAME;
if (AMODE < -1) goto L_079A;
FRAME = 0;
if (AMODE < 0) goto L_079B;
FRAME = 4;
if (AVAR->P & 1024 == 0) goto L_079C;
AVAR->P = AVAR->P - 1024;
AVAR = 0;
L_079C:
if (AVAR != 0) goto L_079D;
if (7 == OSTATE) goto L_079E;
if (OSTATE != 3) goto L_0755;
L_079E:
if (AMODE != 0) goto L_079D;
L_0755:
AVAR = NEWLABEL();
L_079D:
if (AMODE != 0) goto L_079F;
if (/*indirectthrough*/ *LOCAL <= 128 + 17) goto L_07A0;
FAIL(_imp_str_literal("Subroutines nested too deeply"));
L_07A0:
UNCONDJUMP = -1;
FORGETEVERYTHING();
DIR2(1, AVAR);
BLOCKS = BLOCKS + 1;
DIRSTRING(-1, /*%A*/ /*addressof*/ &INTERNALID);
FMARK = FMARK + 1;
FRAMEUSE[/*indirectthrough*/ *LOCAL] = FMARK;
if (DEBUG == 0) goto L_07A1;
DIR3(35, 0, CURRENTLINE);
L_07A1:
L_079F:
if (OSTATE != 3) goto L_07A2;
if (AMODE == 0) goto L_07A3;
AVAR->P = AVAR->P | 1024;
DUMPEXTERNAL(2, AVAR);
goto L_07A4;
L_07A3:
AVAR->P = AVAR->P | 16777216;
N = 3;
if (AVAR->P & 32768 == 0) goto L_07A5;
N = 3 | 1 << 4;
L_07A5:
DUMPEXTERNAL(N, AVAR);
ATTRIBUTES = ATTRIBUTES | 16;
if (AVAR->P & 256 == 0) goto L_07A6;
ATTRIBUTES = ATTRIBUTES | 8;
L_07A6:
L_07A4:
L_07A2:
goto L_07A7;
L_079B:
DIR2(5, AVAR);
L_07A7:
L_079A:
FRAMEEXTRA = FRAME;
FRAME = FRAME + 3 & -4;
FRAMEEXTRA = FRAME - FRAMEEXTRA;
FRAMEBASE = FRAME;
MYMARK = FMARK;
MAXFRAME = 0;
ALTALIGN = (~0);
PENDINGKNOWNREGISTER = 0;
PENDINGAUTO = 0;
if (CODE != 72) goto L_07A8;
goto *C[125]; /*TO DO*/
L_07A8:
L_07A9:
CODE = PENDING;
_imp_READSYMBOL(/*%A*/ /*addressof*/ &PENDING);
goto *C[CODE]; /*TO DO*/
case_C_33:;
OPERATION(10);
goto L_07AA;
case_C_34:;
COMPAREDOUBLE();
goto L_07AA;
case_C_35:;
JUMPFORWARD(TAG(), 6);
goto L_07AA;
case_C_36:;
DEFINEVAR();
goto L_07AA;
case_C_37:;
OPERATION(11);
goto L_07AA;
case_C_38:;
OPERATION(9);
goto L_07AA;
case_C_39:;
INPUTSTRINGVALUE();
goto L_07AA;
case_C_40:;
JUMPFORWARD(TAG(), 3);
goto L_07AA;
case_C_41:;
JUMPFORWARD(TAG(), 5);
goto L_07AA;
case_C_42:;
OPERATION(6);
goto L_07AA;
case_C_43:;
OPERATION(4);
goto L_07AA;
case_C_45:;
OPERATION(5);
goto L_07AA;
case_C_46:;
OPERATION(22);
goto L_07AA;
case_C_47:;
OPERATION(7);
goto L_07AA;
case_C_58:;
DEFINECOMPILERLABEL(TAG());
goto L_07AA;
case_C_59:;
ENDOFBLOCK();
goto L_07AB;
case_C_60:;
JUMPFORWARD(TAG(), 2);
goto L_07AA;
case_C_61:;
JUMPFORWARD(TAG(), 1);
goto L_07AA;
case_C_62:;
JUMPFORWARD(TAG(), 4);
goto L_07AA;
case_C_63:;
COMPAREVALUES();
goto L_07AA;
case_C_64:;
STACKVAR(TAG());
goto L_07AA;
case_C_65:;
INIT(TAG());
goto L_07AA;
case_C_66:;
JUMPBACKWARD(TAG());
goto L_07AA;
case_C_67:;
COMPAREADDRESSES();
goto L_07AA;
case_C_68:;
INPUTREALVALUE();
goto L_07AA;
case_C_69:;
CALL(0);
goto L_07AA;
case_C_70:;
JUMPFORWARD(TAG(), 7);
goto L_07AA;
case_C_71:;
GETSTRING(/*%A*/ /*addressof*/ &ALIAS);
goto L_07AA;
case_C_72:;
COMPILEBEGIN();
goto L_07AA;
case_C_73:;
_imp_SELECTINPUT(2);
_imp_READSYMBOL(/*%A*/ /*addressof*/ &PENDING);
goto L_07AA;
case_C_74:;
USERJUMP(TAG());
goto L_07AA;
case_C_75:;
RETURN(2);
goto L_07AA;
case_C_76:;
DEFINEUSERLABEL(TAG());
goto L_07AA;
case_C_77:;
RETURN(-2);
goto L_07AA;
case_C_78:;
INPUTINTEGERVALUE(0);
goto L_07AA;
case_C_79:;
UPDATELINE(TAG());
goto L_07AA;
case_C_80:;
DUMPBYTE(POPPEDVALUE() & 255);
goto L_07AA;
case_C_81:;
OPERATION(28);
goto L_07AA;
case_C_82:;
RETURN(0);
goto L_07AA;
case_C_83:;
ASSIGN(0);
goto L_07AA;
case_C_84:;
RETURN(1);
goto L_07AA;
case_C_85:;
OPERATE(2, STACK, NIL);
goto L_07AA;
case_C_86:;
RETURN(-1);
goto L_07AA;
case_C_87:;
SWITCHJUMP(TAG());
goto L_07AA;
case_C_88:;
OPERATION(8);
goto L_07AA;
case_C_90:;
ASSIGN(1);
goto L_07AA;
case_C_91:;
OPERATION(14);
goto L_07AA;
case_C_92:;
OPERATE(1, STACK, NIL);
goto L_07AA;
case_C_93:;
OPERATION(15);
goto L_07AA;
case_C_94:;
STACK->FORMAT = -TAG();
goto L_07AA;
case_C_95:;
SWITCHLABEL(TAG());
goto L_07AA;
case_C_97:;
ARRAYACCESS();
goto L_07AA;
case_C_98:;
CONSTANTBOUNDS();
goto L_07AA;
case_C_99:;
SECTION = 1;
GETSTRING(/*%A*/ /*addressof*/ &SECTIONID);
goto L_07AB;
case_C_100:;
D = TAG();
N = TAG();
DIMENSION(D, N);
goto L_07AA;
case_C_101:;
SIGNALEVENT(TAG());
goto L_07AA;
case_C_102:;
COMPILEFOR(TAG());
goto L_07AA;
case_C_103:;
TESTFORNIL();
goto L_07AA;
case_C_104:;
SPECIALCALL(TAG());
goto L_07AA;
case_C_105:;
ARRAYINDEX();
goto L_07AA;
case_C_106:;
ASSIGN(-1);
goto L_07AA;
case_C_107:;
JUMPFORWARD(TAG(), 9);
goto L_07AA;
case_C_108:;
LANGUAGEFLAGS = TAG();
goto L_07AA;
case_C_109:;
DO(MONITORID, /*%A*/ /*addressof*/ &MONITOREP, 0);
goto L_07AA;
case_C_110:;
SELECT(TAG());
goto L_07AA;
case_C_111:;
EVENTTRAP(TAG());
goto L_07AA;
case_C_112:;
ASSIGNPARAMETER();
goto L_07AA;
case_C_113:;
PROCESSINCLUDEFILE();
goto L_07AA;
case_C_114:;
RESOLVE(TAG());
goto L_07AA;
case_C_115:;
TOSTORE(TAG());
goto L_07AA;
case_C_116:;
JUMPFORWARD(TAG(), 8);
goto L_07AA;
case_C_117:;
AOP();
goto L_07AA;
case_C_118:;
OPERATE(3, STACK, NIL);
goto L_07AA;
case_C_119:;
MACHINECODE();
FORGETEVERYTHING();
goto L_07AA;
case_C_120:;
OPERATION(29);
goto L_07AA;
case_C_121:;
SETCD(TAG(), /*%A*/ /*addressof*/ &DIAG);
goto L_07AA;
case_C_122:;
SETCD(TAG(), /*%A*/ /*addressof*/ &CONTROL);
goto L_07AA;
case_C_123:;
ASSEMBLE(DEFV, BLOCKTYPE, /*indirectthrough*/ *VARS, /*indirectthrough*/ */*indirectthrough*/ *LOCAL + 1,
PARAMETERMODE, /*%A*/ /*addressof*/ &ATTRIBUTES);
goto L_07AA;
case_C_125:;
if (!(FINISHPARAMS())) goto L_07AC;
goto L_07AB;
L_07AC:
if (INTERFACE->OPTIONS & 1048576 == 0) goto L_07AD;
DO(_imp_str_literal("3L___stack_check"), /*%A*/ /*addressof*/ &STACKCHECK, 0);
L_07AD:
goto L_07AA;
case_C_126:;
N = PENDING;
_imp_READSYMBOL(/*%A*/ /*addressof*/ &PENDING);
if (!(ALTERNATEFORMAT(N))) goto L_07AE;
goto L_07AB;
L_07AE:
goto L_07AA;
case_C_162:;
UNSIGNED = 10;
STACKCONDITION();
goto L_07AA;
case_C_191:;
UNSIGNED = 10;
COMPAREVALUES();
goto L_07AA;
case_C_172:;
if (FRAME <= MAXFRAME) goto L_07AF;
MAXFRAME = FRAME;
L_07AF:
FRAME = FRAMEBASE;
goto L_07AA;
case_C_176:;
N = TAG();
goto L_07AA;
case_C_177:;
ADDMEMBER(0);
goto L_07AA;
case_C_178:;
ADDMEMBER(1);
goto L_07AA;
case_C_179:;
SETVARIANTCOUNT(TAG());
goto L_07AA;
case_C_180:;
TESTVARIANTCOUNT(TAG());
goto L_07AA;
case_C_181:;
CHECKNOTLONGNEW();
goto L_07AA;
case_C_182:;
CHECKDYNAMICBOUNDS();
goto L_07AA;
case_C_175:;
OPERATION(19);
goto L_07AA;
case_C_252:;
OPERATION(20);
goto L_07AA;
case_C_192:;
if (DIAG & 1 == 0) goto L_07B0;
DECODE(0, -1);
L_07B0:
CURRENTLINE = TAG();
goto L_07AA;
case_C_193:;
AMAP(STACK);
goto L_07AA;
case_C_194:;
if (PENDING != 116) goto L_07B1;
PENDING = 35;
goto L_07B2;
L_07B1:
PENDING = 61;
L_07B2:
TESTZERO(STACK);
POPRELEASEANDDROP();
goto L_07AA;
case_C_195:;
UNSIGNED = 0;
STACKCONDITION();
goto L_07AA;
case_C_196:;
DUPLICATE();
goto L_07AA;
case_C_197:;
if (STACK->FORM != 0) goto L_072C;
if (!(LOCKED(STACK->BASE))) goto L_072C;
if (/*%A*/ /*addressof*/ &STACK->RECORD != NIL) goto L_072C;
if (/*%A*/ /*addressof*/ &STACK->INDEX == NIL) goto L_07B3;
L_072C:
LOADUP(STACK);
L_07B3:
goto L_07AA;
case_C_198:;
STACK->FORMAT = -TAG();
goto L_07AA;
case_C_201:;
COMPILEIN(1);
goto L_07AA;
case_C_204:;
LOCALISE();
goto L_07AA;
case_C_205:;
OPERATION(17);
goto L_07AA;
case_C_206:;
OPERATION(16);
goto L_07AA;
case_C_207:;
APPLYROUND(STACK);
goto L_07AA;
case_C_208:;
POPRELEASEANDDROP();
goto L_07AA;
case_C_210:;
DEFINERANGE();
goto L_07AA;
case_C_211:;
SWOP();
goto L_07AA;
case_C_212:;
APPLYTRUNC(STACK);
goto L_07AA;
case_C_213:;
USEWITH(TAG());
goto L_07AA;
case_C_214:;
VMAP(STACK, TAG());
goto L_07AA;
case_C_215:;
STACKWORKVARIABLE();
goto L_07AA;
case_C_216:;
if (STACK->TYPE == 7) goto L_07B4;
LOADUP(STACK);
L_07B4:
goto L_07AA;
case_C_218:;
STACKINTEGER(0);
STACK->TYPE = 13;
STACK->FLAGS = 16384;
goto L_07AA;
case_C_219:;
CLAIMWITH(TAG());
goto L_07AA;
case_C_221:;
RELEASEWITH(TAG());
goto L_07AA;
case_C_226:;
INPUTINTEGERVALUE(1);
goto L_07AA;
case_C_227:;
GENERALCOMPARE();
goto L_07AA;
case_C_229:;
N = STACK->TYPE;
AMAP(STACK);
if (STACK->FORM != 0) goto L_07B5;
if (!(LOCKED(STACK->BASE))) goto L_07B5;
if (/*%A*/ /*addressof*/ &STACK->INDEX != NIL) goto L_07B5;
if (/*%A*/ /*addressof*/ &STACK->RECORD == NIL) goto L_07B6;
L_07B5:
LOADUP(STACK);
L_07B6:
VMAP(STACK, N);
goto L_07AA;
case_C_230:;
FORRANGE = VAR(TAG());
goto L_07AA;
case_C_231:;
CALL(1);
goto L_07AA;
case_C_233:;
COMPILEIN(0);
goto L_07AA;
case_C_238:;
APPLYINT(STACK);
goto L_07AA;
case_C_237:;
GENERALMOVE();
goto L_07AA;
case_C_239:;
OWNTYPE = TAG();
goto L_07AA;
case_C_240:;
FMAP(TAG());
goto L_07AA;
case_C_242:;
TESTRANGE(STACK, VAR(TAG()));
goto L_07AA;
case_C_243:;
SETSIZEORTYPE(1, STACK);
goto L_07AA;
case_C_244:;
SETSIZEORTYPE(2, STACK);
goto L_07AA;
case_C_246:;
COMPAREVALUES();
PRIM(36);
goto L_07AA;
case_C_247:;
APPLYINTPT(STACK);
goto L_07AA;
case_C_250:;
STACKDATASIZE();
goto L_07AA;
case_C_251:;
NN = 0;
ASSEMBLE(/*%A*/ /*addressof*/ &ALTV, -2, /*indirectthrough*/ *VARS, /*indirectthrough*/ *LOCAL, -1,
/*%A*/ /*addressof*/ &NN);
ALTALIGN = ALTALIGN & FALIGN;
goto L_07AA;
case_C_253:;
if (MAXFRAME <= FRAME) goto L_07B7;
FRAME = MAXFRAME;
L_07B7:
FALIGN = ALTALIGN;
goto L_07AB;
L_07AA:
goto L_07A9;
L_07AB:
/*indirectthrough*/ *GLOBALATTRIBUTES =
/*indirectthrough*/ */*indirectthrough*/ *GLOBALATTRIBUTES | ATTRIBUTES & 512;
if (AMODE & 8 != 0) goto L_07B8;
if (FRAMEUSE[/*indirectthrough*/ *LOCAL] == MYMARK) goto L_07B9;
ATTRIBUTES = ATTRIBUTES | 2;
L_07B9:
if (DEBUG == 0) goto L_07BA;
DIR2(36, CURRENTLINE);
L_07BA:
DIR1(32);
DUMPENCODED((FRAME & -4) - AFRAME);
DUMPENCODED(CODEBASE);
DUMPENCODED(PARAMETERFRAME);
DUMPENCODED(PARAMETERREGS);
DUMPENCODED(DISPLAYVECTOR[/*indirectthrough*/ *LOCAL]);
DUMPENCODED(LOCALDISPLAY);
DUMPENCODED(ARRAYBASE);
DUMPENCODED(ATTRIBUTES);
DUMPENCODED(ENTRYMASK);
DUMPENCODED(EVENTBITS & 65535);
DUMPENCODED(EVENTLABEL);
DUMPENCODED(EVENTBODY);
FORGETEVERYTHING();
AVAR->P = AVAR->P | OPEN;
L_07B8:
TERMINATEBLOCK();
if (/*indirectthrough*/ *LOCAL == 145) goto L_07BB;
DISPLAYVECTOR[/*indirectthrough*/ */*indirectthrough*/ *LOCAL + 1] = 0;
L_07BB:
if (DANGERLEVEL != /*indirectthrough*/ *LOCAL) goto L_07BC;
DANGERLEVEL = 32767;
L_07BC:
PENDINGKNOWNREGISTER = 0;
PENDINGAUTO = 0;
LASTWORK = WORKBASE;
return;
C_default:;
FAIL(_imp_join((_imp_string)(_imp_str_literal("Code ")), (_imp_string)(_imp_ITOS(CODE, 0))));
} /* ASSEMBLE */
ACTIVITY[13] = -1;
ACTIVITY[11] = -1;
ACTIVITY[10] = -1;
COMPILINGPRIM = INTERFACE->PRIM;
UNASSIGNED = INTERFACE->OPTIONS & 32;
DEBUG = INTERFACE->OPTIONS & 8388608;
if (UNASSIGNED == 0) goto L_07BD;
OWNBASE = 16;
L_07BD:
J = -1; /*%for J = 0, 1, 31 %cycle*/
L_07BE:
if (J == 31) goto L_07BF;
J += 1;
PVAR[J].P = NIL;
goto L_07BE;
L_07BF:
J = -1; /*%for J = 0, 1, (unsigned int)8191 >> 8 %cycle*/
L_07C1:
if (J == (unsigned int)8191 >> 8) goto L_07C2;
J += 1;
ILABELS[J].LABEL = NIL;
goto L_07C1;
L_07C2:
_imp_SELECTINPUT(1);
_imp_READSYMBOL(/*%A*/ /*addressof*/ &PENDING);
/*indirectthrough*/ *VAR(0) = 0;
DEFAULTVALUE = 0;
VALUE = DEFAULTVALUE;
void INITIALISE(struct STACKFM * V, int BASE, int FORM) {
V = 0;
V = /*indirectthrough*/ *BASE;
V = 1;
V = /*indirectthrough*/ *FORM;
V = 128;
} /* INITIALISE */
INITIALISE(/*%A*/ /*addressof*/ &UAPAT, 10, 1);
INITIALISE(/*%A*/ /*addressof*/ &ZERO, 0, 0);
INITIALISE(/*%A*/ /*addressof*/ &ONE, 0, 0);
ONE.DISP = 1;
INITIALISE(/*%A*/ /*addressof*/ &SPV, 13, 0);
{ /*%begin*/
int J;
struct STACKFM *R;
J = 0; /*%for J = 1, 1, 26 %cycle*/
L_07C3:
if (J == 26) goto L_07C4;
J += 1;
R = /*%A*/ /*addressof*/ ®V[J];
/*indirectthrough*/ *R = 0;
R->BASE = J;
R->TYPE = 1;
R->FORM = 0;
R->FORMAT = 4;
if (J < 18) goto L_07C5;
R->TYPE = 7;
R->FORMAT = 4 * 2;
L_07C5:
goto L_07C3;
L_07C4:
}
KNOWING = NIL;
KASL = NIL;
_imp_SELECTOUTPUT(2);
PARMS = 2000;
CONSTANTBASE = 0;
FREELABEL = 0;
SECTION = 0;
ASSEMBLE(VAR(0), -16, 0, 128, 0, /*%A*/ /*addressof*/ &J);
DUMPENCODED(ENTRYPOINT);
DUMPENCODED(CONTROL);
DUMPENCODED(MINSB);
INTERFACE->REFCOUNT = REFS;
INTERFACE->DEFCOUNT = FREELABEL;
INTERFACE->BLOCKCOUNT = BLOCKS;
INTERFACE->EXTERNALCOUNT = EXTERNALNO;
INTERFACE->GLOBALSIZE = OWNBASE;
INTERFACE->GLOBALARRAYSIZE = OWNARRAYBASE;
INTERFACE->CONSTANTSIZE = CONSTANTBASE;
{ /*%begin*/
void MONITOR(_imp_string255 TEXT) {
_imp_SELECTOUTPUT(0);
_imp_PRINTSTRING(/*indirectthrough*/ *TEXT);
_imp_NEWLINE();
} /* MONITOR */
struct VVFM *V;
if (DIAG & 64 == 0) goto L_07C6;
MONITOR(_imp_str_literal("Dispose Vars"));
L_07C6:
L_07C7:
if (VARLIST == NIL) goto L_07C8;
V = VARLIST;
VARLIST = /*%A*/ /*addressof*/ &VARLIST->LINK;
_imp_DISPOSE(V);
goto L_07C7;
L_07C8:
struct KNOWFM *K;
if (DIAG & 64 == 0) goto L_07C9;
MONITOR(_imp_str_literal("Dispose Kasl"));
L_07C9:
L_07CA:
if (KASL == NIL) goto L_07CB;
K = KASL;
KASL = /*%A*/ /*addressof*/ &KASL->LINK;
_imp_DISPOSE(K);
goto L_07CA;
L_07CB:
struct ILABELFM *I;
if (DIAG & 64 == 0) goto L_07CC;
MONITOR(_imp_str_literal("Dispose Labels"));
L_07CC:
L_07CD:
if (ILABELLIST == NIL) goto L_07CE;
I = ILABELLIST;
ILABELLIST = /*%A*/ /*addressof*/ &I->LINK;
_imp_DISPOSE(I);
goto L_07CD;
L_07CE:
struct WORKVFM *W1;
struct WORKVFM *W2;
W2 = /*%A*/ /*addressof*/ &WORKLIST.LINK;
if (DIAG & 64 == 0) goto L_07CF;
MONITOR(_imp_str_literal("Dispose Work"));
L_07CF:
L_07D0:
if (W2 == NIL) goto L_07D1;
W1 = W2;
W2 = /*%A*/ /*addressof*/ &W2->LINK;
_imp_DISPOSE(W1);
goto L_07D0;
L_07D1:
if (DIAG & 64 == 0) goto L_07D2;
MONITOR(_imp_str_literal("Disposed"));
L_07D2:
}
return;
}
/* %endoffile */