|
@@ -0,0 +1,757 @@
|
|
|
+/*
|
|
|
+ * (c) copyright 1983 by the Vrije Universiteit, Amsterdam, The Netherlands.
|
|
|
+ *
|
|
|
+ * This product is part of the Amsterdam Compiler Kit.
|
|
|
+ *
|
|
|
+ * Permission to use, sell, duplicate or disclose this software must be
|
|
|
+ * obtained in writing. Requests for such permissions may be sent to
|
|
|
+ *
|
|
|
+ * Dr. Andrew S. Tanenbaum
|
|
|
+ * Wiskundig Seminarium
|
|
|
+ * Vrije Universiteit
|
|
|
+ * Postbox 7161
|
|
|
+ * 1007 MC Amsterdam
|
|
|
+ * The Netherlands
|
|
|
+ *
|
|
|
+ */
|
|
|
+
|
|
|
+/*
|
|
|
+ * Encode to compact EM assembly language
|
|
|
+ *
|
|
|
+ * Author: Johan Stevenson, Vrije Universiteit, Amsterdam
|
|
|
+ */
|
|
|
+
|
|
|
+#include <stdio.h>
|
|
|
+#include <ctype.h>
|
|
|
+#include <assert.h>
|
|
|
+#include <setjmp.h>
|
|
|
+#include <em_spec.h>
|
|
|
+#include <em_pseu.h>
|
|
|
+#include <em_flag.h>
|
|
|
+#include <em_ptyp.h>
|
|
|
+#include <em_mes.h>
|
|
|
+
|
|
|
+#define put8(x) putchar(x)
|
|
|
+
|
|
|
+#define check(x) if (!(x)) fail_check()
|
|
|
+
|
|
|
+#define fit16i(x) ((x) >= 0xFFFF8000 && (x) <= 0x00007FFF)
|
|
|
+#define fit8u(x) ((x) >= 0 && (x) <= 0xFF)
|
|
|
+
|
|
|
+#define MAXSTR 256
|
|
|
+#define HSIZE 256
|
|
|
+#define EMPTY (EOF-1)
|
|
|
+
|
|
|
+/*
|
|
|
+ * global variables
|
|
|
+ */
|
|
|
+
|
|
|
+int opcode;
|
|
|
+int offtyp;
|
|
|
+long argval;
|
|
|
+int dlbval;
|
|
|
+char string[MAXSTR];
|
|
|
+int strsiz;
|
|
|
+
|
|
|
+int wsize;
|
|
|
+int psize;
|
|
|
+int lineno;
|
|
|
+int argnum;
|
|
|
+int errors;
|
|
|
+char *progname;
|
|
|
+char *filename = "INPUT";
|
|
|
+
|
|
|
+long wordmask[] = { /* allowed bits in a word */
|
|
|
+ 0x00000000,
|
|
|
+ 0x000000FF,
|
|
|
+ 0x0000FFFF,
|
|
|
+ 0x00000000,
|
|
|
+ 0xFFFFFFFF
|
|
|
+};
|
|
|
+
|
|
|
+long sizemask[] = { /* allowed bits in multiples of 'wsize' */
|
|
|
+ 0x00000000,
|
|
|
+ 0x7FFFFFFF,
|
|
|
+ 0x7FFFFFFE,
|
|
|
+ 0x00000000,
|
|
|
+ 0x7FFFFFFC
|
|
|
+};
|
|
|
+
|
|
|
+int peekc = EMPTY;
|
|
|
+int hashtab[HSIZE];
|
|
|
+jmp_buf recover;
|
|
|
+
|
|
|
+/*
|
|
|
+ * external tables
|
|
|
+ */
|
|
|
+
|
|
|
+extern char em_flag[];
|
|
|
+extern short em_ptyp[];
|
|
|
+extern char em_mnem[][4];
|
|
|
+extern char em_pseu[][4];
|
|
|
+
|
|
|
+int main(argc,argv) char **argv; {
|
|
|
+
|
|
|
+ progname = argv[0];
|
|
|
+ if (argc >= 2) {
|
|
|
+ filename = argv[1];
|
|
|
+ if (freopen(filename,"r",stdin) == NULL)
|
|
|
+ fatal("can't open %s",filename);
|
|
|
+ }
|
|
|
+ if (argc >= 3)
|
|
|
+ if (freopen(argv[2],"w",stdout) == NULL)
|
|
|
+ fatal("can't create %s",argv[2]);
|
|
|
+ init();
|
|
|
+ put16(sp_magic);
|
|
|
+ setjmp(recover);
|
|
|
+ while (nextline())
|
|
|
+ ;
|
|
|
+ return(errors ? -1 : 0);
|
|
|
+}
|
|
|
+
|
|
|
+/* ----- copy ----- */
|
|
|
+
|
|
|
+int nextline() {
|
|
|
+ register c,i;
|
|
|
+
|
|
|
+ lineno++;
|
|
|
+ argnum = 1;
|
|
|
+ c = nextchar();
|
|
|
+ if (c == EOF)
|
|
|
+ return(0);
|
|
|
+ if (isspace(c) && c != '\n') {
|
|
|
+ c = nospace();
|
|
|
+ if (isalpha(c)) {
|
|
|
+ inmnem(c);
|
|
|
+ if (opcode <= sp_lmnem)
|
|
|
+ instr();
|
|
|
+ else
|
|
|
+ pseudo();
|
|
|
+ } else
|
|
|
+ peekc = c;
|
|
|
+ } else if (c == '#') {
|
|
|
+ line_line();
|
|
|
+ } else {
|
|
|
+ peekc = c;
|
|
|
+ i = gettyp(sym_ptyp | ptyp(sp_cst2) | ptyp(sp_cend));
|
|
|
+ switch (i) {
|
|
|
+ case sp_cst2:
|
|
|
+ i = (int) argval;
|
|
|
+ if (i >= 0 && i < sp_nilb0)
|
|
|
+ put8(i + sp_filb0);
|
|
|
+ else
|
|
|
+ putarg(sp_ilb2);
|
|
|
+ break;
|
|
|
+ case sp_dlb2:
|
|
|
+ case sp_dnam:
|
|
|
+ putarg(i);
|
|
|
+ break;
|
|
|
+ case sp_cend:
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (nospace() != '\n')
|
|
|
+ syntax("end of line expected");
|
|
|
+ return(1);
|
|
|
+}
|
|
|
+
|
|
|
+instr() {
|
|
|
+ register i,j,t;
|
|
|
+ register long l;
|
|
|
+
|
|
|
+ i = opcode;
|
|
|
+ put8(i);
|
|
|
+ i -= sp_fmnem;
|
|
|
+ j = em_flag[i] & EM_PAR;
|
|
|
+ if (j == PAR_NO)
|
|
|
+ return;
|
|
|
+ t = em_ptyp[j];
|
|
|
+ if (j == PAR_B)
|
|
|
+ t = ptyp(sp_ilb2);
|
|
|
+ t = getarg(t);
|
|
|
+ /*
|
|
|
+ * range checking
|
|
|
+ */
|
|
|
+ switch (j) {
|
|
|
+ case PAR_N:
|
|
|
+ check(argval >= 0);
|
|
|
+ break;
|
|
|
+ case PAR_G:
|
|
|
+ if (t != sp_cst2 && t != sp_cst4)
|
|
|
+ break;
|
|
|
+ check(argval >= 0);
|
|
|
+ /* fall through */
|
|
|
+ case PAR_L:
|
|
|
+ l = argval >= 0 ? argval : -argval;
|
|
|
+ check((l & ~wordmask[psize]) == 0);
|
|
|
+ break;
|
|
|
+ case PAR_W:
|
|
|
+ if (t == sp_cend)
|
|
|
+ break;
|
|
|
+ check((argval & ~wordmask[wsize]) == 0);
|
|
|
+ /* fall through */
|
|
|
+ case PAR_S:
|
|
|
+ check(argval != 0);
|
|
|
+ /* fall through */
|
|
|
+ case PAR_Z:
|
|
|
+ check((argval & ~sizemask[wsize]) == 0);
|
|
|
+ break;
|
|
|
+ case PAR_O:
|
|
|
+ check(argval != 0);
|
|
|
+ check((argval & ~sizemask[wsize])==0 || (wsize % argval)==0);
|
|
|
+ break;
|
|
|
+ case PAR_B:
|
|
|
+ t = sp_cst2;
|
|
|
+ break;
|
|
|
+ case PAR_R:
|
|
|
+ check(argval >= 0 && argval <= 2);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ putarg(t);
|
|
|
+}
|
|
|
+
|
|
|
+pseudo() {
|
|
|
+ register i,t;
|
|
|
+
|
|
|
+ i = opcode;
|
|
|
+ put8(i);
|
|
|
+ switch (i) {
|
|
|
+ case ps_bss:
|
|
|
+ case ps_hol:
|
|
|
+ putarg(getarg(cst_ptyp));
|
|
|
+ putarg(getarg(val_ptyp));
|
|
|
+ putarg(getarg(ptyp(sp_cst2)));
|
|
|
+ check(argval==0 || argval==1);
|
|
|
+ break;
|
|
|
+ case ps_rom:
|
|
|
+ case ps_con:
|
|
|
+ putarg(getarg(val_ptyp));
|
|
|
+ do
|
|
|
+ putarg(t = getarg(any_ptyp));
|
|
|
+ while (t != sp_cend);
|
|
|
+ break;
|
|
|
+ case ps_mes:
|
|
|
+ putarg(getarg(ptyp(sp_cst2)));
|
|
|
+ if (argval == ms_emx) {
|
|
|
+ putarg(getarg(ptyp(sp_cst2)));
|
|
|
+ check(argval > 0 && argval <= 4);
|
|
|
+ wsize = (int) argval;
|
|
|
+ putarg(getarg(ptyp(sp_cst2)));
|
|
|
+ check(argval > 0 && argval <= 4);
|
|
|
+ psize = (int) argval;
|
|
|
+ }
|
|
|
+ do
|
|
|
+ putarg(t = getarg(any_ptyp));
|
|
|
+ while (t != sp_cend);
|
|
|
+ break;
|
|
|
+ case ps_exa:
|
|
|
+ case ps_ina:
|
|
|
+ putarg(getarg(sym_ptyp));
|
|
|
+ break;
|
|
|
+ case ps_exp:
|
|
|
+ case ps_inp:
|
|
|
+ putarg(getarg(ptyp(sp_pnam)));
|
|
|
+ break;
|
|
|
+ case ps_exc:
|
|
|
+ putarg(getarg(ptyp(sp_cst2)));
|
|
|
+ putarg(getarg(ptyp(sp_cst2)));
|
|
|
+ break;
|
|
|
+ case ps_pro:
|
|
|
+ putarg(getarg(ptyp(sp_pnam)));
|
|
|
+ putarg(getarg(cst_ptyp|ptyp(sp_cend)));
|
|
|
+ break;
|
|
|
+ case ps_end:
|
|
|
+ putarg(getarg(cst_ptyp|ptyp(sp_cend)));
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ syntax("bad pseudo %d",i);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/* ----- input ----- */
|
|
|
+
|
|
|
+int getarg(typset) {
|
|
|
+ register c;
|
|
|
+
|
|
|
+ if (argnum != 1) {
|
|
|
+ c = nospace();
|
|
|
+ if (c != ',') {
|
|
|
+ if (c != '\n')
|
|
|
+ syntax("comma expected");
|
|
|
+ peekc = c;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ argnum++;
|
|
|
+ return(gettyp(typset));
|
|
|
+}
|
|
|
+
|
|
|
+int gettyp(typset) {
|
|
|
+ register c,t,sp;
|
|
|
+
|
|
|
+ c = nospace();
|
|
|
+ if (c == '\n') {
|
|
|
+ peekc = c;
|
|
|
+ sp = sp_cend;
|
|
|
+ } else if (isdigit(c) || c == '+' || c == '-' || c == '(') {
|
|
|
+ sp = inexpr1(c);
|
|
|
+ if (sp == sp_cst4 && fit16i(argval))
|
|
|
+ sp = sp_cst2;
|
|
|
+ } else if (isalpha(c)) {
|
|
|
+ inname(c);
|
|
|
+ sp = offsetted(sp_dnam);
|
|
|
+ } else if (c == '.') {
|
|
|
+ in15u();
|
|
|
+ dlbval = (int) argval;
|
|
|
+ sp = offsetted(sp_dlb2);
|
|
|
+ } else if (c == '*') {
|
|
|
+ in15u();
|
|
|
+ sp = sp_ilb2;
|
|
|
+ } else if (c == '$') {
|
|
|
+ inname(nextchar());
|
|
|
+ sp = sp_pnam;
|
|
|
+ } else if (c == '"' || c == '\'') {
|
|
|
+ sp = instring(c);
|
|
|
+ } else if (c == '?') {
|
|
|
+ sp = sp_cend;
|
|
|
+ } else
|
|
|
+ syntax("operand expected");
|
|
|
+ t = sp - sp_fspec;
|
|
|
+ assert(t >= 0 && t < 16);
|
|
|
+ t = 1 << t;
|
|
|
+ if ((typset & t) == 0)
|
|
|
+ error("bad argument type %d",sp);
|
|
|
+ return(sp);
|
|
|
+}
|
|
|
+
|
|
|
+int offsetted(sp) {
|
|
|
+ register c;
|
|
|
+
|
|
|
+ c = nospace();
|
|
|
+ if (c == '+' || c == '-') {
|
|
|
+ gettyp(cst_ptyp);
|
|
|
+ if (c == '-')
|
|
|
+ argval = -argval;
|
|
|
+ offtyp = sp;
|
|
|
+ return(sp_doff);
|
|
|
+ }
|
|
|
+ peekc = c;
|
|
|
+ return(sp);
|
|
|
+}
|
|
|
+
|
|
|
+inname(c) register c; {
|
|
|
+ register char *p;
|
|
|
+
|
|
|
+ if (isalpha(c) == 0)
|
|
|
+ syntax("letter expected");
|
|
|
+ p = string;
|
|
|
+ do {
|
|
|
+ if (p < &string[MAXSTR-1])
|
|
|
+ *p++ = c;
|
|
|
+ c = nextchar();
|
|
|
+ } while (isalnum(c));
|
|
|
+ peekc = c;
|
|
|
+ *p = '\0';
|
|
|
+ strsiz = p - string;
|
|
|
+}
|
|
|
+
|
|
|
+int inmnem(c) register c; {
|
|
|
+ register unsigned h;
|
|
|
+ register i;
|
|
|
+
|
|
|
+ inname(c);
|
|
|
+ h = hash(string);
|
|
|
+ for (;;) {
|
|
|
+ h++;
|
|
|
+ h %= HSIZE;
|
|
|
+ i = hashtab[h];
|
|
|
+ if (i == 0)
|
|
|
+ syntax("bad mnemonic");
|
|
|
+ if (i <= sp_lmnem) {
|
|
|
+ assert(i >= sp_fmnem);
|
|
|
+ if (strcmp(string,em_mnem[i - sp_fmnem]) != 0)
|
|
|
+ continue;
|
|
|
+ return(opcode = i);
|
|
|
+ }
|
|
|
+ assert(i <= sp_lpseu && i >= sp_fpseu);
|
|
|
+ if (strcmp(string,em_pseu[i - sp_fpseu]) != 0)
|
|
|
+ continue;
|
|
|
+ return(opcode = i);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+int inexpr1(c) register c; {
|
|
|
+ long left;
|
|
|
+
|
|
|
+ if ((c = inexpr2(c)) != sp_cst4)
|
|
|
+ return(c);
|
|
|
+ for (;;) {
|
|
|
+ c = nospace();
|
|
|
+ if (c != '+' && c != '-') {
|
|
|
+ peekc = c;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ left = argval;
|
|
|
+ if (inexpr2(nospace()) != sp_cst4)
|
|
|
+ syntax("term expected");
|
|
|
+ if (c == '+')
|
|
|
+ argval += left;
|
|
|
+ else
|
|
|
+ argval = left - argval;
|
|
|
+ }
|
|
|
+ return(sp_cst4);
|
|
|
+}
|
|
|
+
|
|
|
+int inexpr2(c) register c; {
|
|
|
+ long left;
|
|
|
+
|
|
|
+ if ((c = inexpr3(c)) != sp_cst4)
|
|
|
+ return(c);
|
|
|
+ for (;;) {
|
|
|
+ c = nospace();
|
|
|
+ if (c != '*' && c != '/' && c != '%') {
|
|
|
+ peekc = c;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ left = argval;
|
|
|
+ if (inexpr3(nospace()) != sp_cst4)
|
|
|
+ syntax("factor expected");
|
|
|
+ if (c == '*')
|
|
|
+ argval *= left;
|
|
|
+ else if (c == '/')
|
|
|
+ argval = left / argval;
|
|
|
+ else
|
|
|
+ argval = left % argval;
|
|
|
+ }
|
|
|
+ return(sp_cst4);
|
|
|
+}
|
|
|
+
|
|
|
+inexpr3(c) register c; {
|
|
|
+
|
|
|
+ if (c == '(') {
|
|
|
+ if (inexpr1(nospace()) != sp_cst4)
|
|
|
+ syntax("expression expected");
|
|
|
+ if (nospace() != ')')
|
|
|
+ syntax("')' expected");
|
|
|
+ return(sp_cst4);
|
|
|
+ }
|
|
|
+ return(innumber(c));
|
|
|
+}
|
|
|
+
|
|
|
+int innumber(c) register c; {
|
|
|
+ register char *p;
|
|
|
+ register n;
|
|
|
+ int expsign;
|
|
|
+ static char numstr[MAXSTR];
|
|
|
+ long atol();
|
|
|
+
|
|
|
+ p = numstr;
|
|
|
+ expsign = 0;
|
|
|
+ if (c == '+' || c == '-') {
|
|
|
+ if (c == '-')
|
|
|
+ *p++ = c;
|
|
|
+ c = nextchar();
|
|
|
+ }
|
|
|
+ if (isdigit(c) == 0)
|
|
|
+ syntax("digit expected");
|
|
|
+ n = sp_cst4;
|
|
|
+ for (;;) {
|
|
|
+ if (p >= &numstr[MAXSTR-1])
|
|
|
+ fatal("number too long");
|
|
|
+ *p++ = c;
|
|
|
+ c = nextchar();
|
|
|
+ if (c == '.' || c == 'e' || c == 'E') {
|
|
|
+ expsign = c != '.';
|
|
|
+ n = sp_fcon;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ if (expsign) {
|
|
|
+ expsign = 0;
|
|
|
+ if (c == '+' || c == '-')
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ if (isdigit(c) == 0)
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ peekc = c;
|
|
|
+ *p = '\0';
|
|
|
+ c = nospace();
|
|
|
+ if (n == sp_fcon && c != 'F')
|
|
|
+ syntax("'F' expected");
|
|
|
+ if (c == 'I' || c == 'U' || c == 'F')
|
|
|
+ return(incon(numstr,c));
|
|
|
+ peekc = c;
|
|
|
+ argval = atol(numstr);
|
|
|
+ return(sp_cst4);
|
|
|
+}
|
|
|
+
|
|
|
+in15u() {
|
|
|
+
|
|
|
+ if (innumber(nextchar()) != sp_cst4)
|
|
|
+ syntax("integer expected");
|
|
|
+ check((argval & ~077777) == 0);
|
|
|
+}
|
|
|
+
|
|
|
+int incon(p,c) register char *p; {
|
|
|
+ register char *q;
|
|
|
+
|
|
|
+ q = string;
|
|
|
+ while (*q++ = *p++)
|
|
|
+ ;
|
|
|
+ strsiz = q - string - 1;
|
|
|
+ gettyp(cst_ptyp);
|
|
|
+ return(c == 'I' ? sp_icon : (c == 'U' ? sp_ucon : sp_fcon));
|
|
|
+}
|
|
|
+
|
|
|
+int instring(termc) {
|
|
|
+ register char *p;
|
|
|
+ register c;
|
|
|
+
|
|
|
+ p = string;
|
|
|
+ for (;;) {
|
|
|
+ c = nextchar();
|
|
|
+ if (c == '\n' || c == EOF) {
|
|
|
+ peekc = c;
|
|
|
+ syntax("non-terminated string");
|
|
|
+ }
|
|
|
+ if (c == termc) {
|
|
|
+ if (termc == '"')
|
|
|
+ *p++ = '\0';
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ if (c == '\\')
|
|
|
+ c = inescape();
|
|
|
+ if (p >= &string[MAXSTR-1])
|
|
|
+ fatal("string too long");
|
|
|
+ *p++ = c;
|
|
|
+ }
|
|
|
+ strsiz = p - string;
|
|
|
+ return(sp_scon);
|
|
|
+}
|
|
|
+
|
|
|
+int inescape() {
|
|
|
+ register c,j,r;
|
|
|
+
|
|
|
+ c = nextchar();
|
|
|
+ if (c >= '0' && c <= '7') {
|
|
|
+ r = c - '0';
|
|
|
+ for (j = 0; j < 2; j++) {
|
|
|
+ c = nextchar();
|
|
|
+ if (c < '0' || c > '7') {
|
|
|
+ peekc = c;
|
|
|
+ return(r);
|
|
|
+ }
|
|
|
+ r <<= 3;
|
|
|
+ r += (c - '0');
|
|
|
+ }
|
|
|
+ return(r);
|
|
|
+ }
|
|
|
+ switch (c) {
|
|
|
+ case 'b': return('\b');
|
|
|
+ case 'f': return('\f');
|
|
|
+ case 'n': return('\n');
|
|
|
+ case 'r': return('\r');
|
|
|
+ case 't': return('\t');
|
|
|
+ }
|
|
|
+ return(c);
|
|
|
+}
|
|
|
+
|
|
|
+int nospace() {
|
|
|
+ register c;
|
|
|
+
|
|
|
+ do
|
|
|
+ c = nextchar();
|
|
|
+ while (isspace(c) && c != '\n');
|
|
|
+ if (c == ';')
|
|
|
+ do
|
|
|
+ c = nextchar();
|
|
|
+ while (c != '\n' && c != EOF);
|
|
|
+ return(c);
|
|
|
+}
|
|
|
+
|
|
|
+int nextchar() {
|
|
|
+ register c;
|
|
|
+
|
|
|
+ if (peekc != EMPTY) {
|
|
|
+ c = peekc;
|
|
|
+ peekc = EMPTY;
|
|
|
+ return(c);
|
|
|
+ }
|
|
|
+ c = getchar();
|
|
|
+ if (isascii(c) == 0 && c != EOF)
|
|
|
+ fatal("non-ascii char");
|
|
|
+ return(c);
|
|
|
+}
|
|
|
+
|
|
|
+line_line() {
|
|
|
+ register char *p,*q;
|
|
|
+ static char filebuff[MAXSTR+1];
|
|
|
+
|
|
|
+ gettyp(ptyp(sp_cst2));
|
|
|
+ lineno = (int) (argval-1);
|
|
|
+ gettyp(ptyp(sp_scon));
|
|
|
+ p = string;
|
|
|
+ q = filebuff;
|
|
|
+ while (--strsiz >= 0)
|
|
|
+ *q++ = *p++;
|
|
|
+ *q = '\0';
|
|
|
+ filename = filebuff;
|
|
|
+}
|
|
|
+
|
|
|
+init() {
|
|
|
+ register i;
|
|
|
+
|
|
|
+ for (i = sp_fmnem; i <= sp_lmnem; i++)
|
|
|
+ pre_hash(i,em_mnem[i - sp_fmnem]);
|
|
|
+ for (i = sp_fpseu; i <= sp_lpseu; i++)
|
|
|
+ pre_hash(i,em_pseu[i - sp_fpseu]);
|
|
|
+ /* treat '_' as letter */
|
|
|
+ /* In System III the array is called _ctype[] without the trailing '_' */
|
|
|
+ (_ctype_+1)['_'] = (_ctype_+1)['a'];
|
|
|
+}
|
|
|
+
|
|
|
+pre_hash(i,s) char *s; {
|
|
|
+ register unsigned h;
|
|
|
+
|
|
|
+ assert(i != 0);
|
|
|
+ h = hash(s);
|
|
|
+ for (;;) {
|
|
|
+ h++;
|
|
|
+ h %= HSIZE;
|
|
|
+ if (hashtab[h] == 0) {
|
|
|
+ hashtab[h] = i;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+int hash(s) register char *s; {
|
|
|
+ register h;
|
|
|
+
|
|
|
+ h = 0;
|
|
|
+ while (*s) {
|
|
|
+ h <<= 1;
|
|
|
+ h += *s++;
|
|
|
+ }
|
|
|
+ return(h);
|
|
|
+}
|
|
|
+
|
|
|
+/* ----- output ----- */
|
|
|
+
|
|
|
+putarg(sp) register sp; {
|
|
|
+ register i;
|
|
|
+
|
|
|
+ switch (sp) {
|
|
|
+ case sp_ilb2:
|
|
|
+ i = (int) argval;
|
|
|
+ if (fit8u(i)) {
|
|
|
+ put8(sp_ilb1);
|
|
|
+ put8(i);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ put8(sp);
|
|
|
+ put16(i);
|
|
|
+ break;
|
|
|
+ case sp_dlb2:
|
|
|
+ i = dlbval;
|
|
|
+ if (fit8u(i)) {
|
|
|
+ put8(sp_dlb1);
|
|
|
+ put8(i);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ put8(sp);
|
|
|
+ put16(i);
|
|
|
+ break;
|
|
|
+ case sp_cst2:
|
|
|
+ case sp_cst4:
|
|
|
+ if (fit16i(argval) == 0) {
|
|
|
+ put8(sp_cst4);
|
|
|
+ put32(argval);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ i = (int) argval;
|
|
|
+ if (i >= -sp_zcst0 && i < sp_ncst0 - sp_zcst0) {
|
|
|
+ put8(i + sp_zcst0 + sp_fcst0);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ put8(sp_cst2);
|
|
|
+ put16(i);
|
|
|
+ break;
|
|
|
+ case sp_doff:
|
|
|
+ put8(sp);
|
|
|
+ putarg(offtyp);
|
|
|
+ putarg(sp_cst4);
|
|
|
+ break;
|
|
|
+ case sp_dnam:
|
|
|
+ case sp_pnam:
|
|
|
+ case sp_scon:
|
|
|
+ put8(sp);
|
|
|
+ putstr();
|
|
|
+ break;
|
|
|
+ case sp_icon:
|
|
|
+ case sp_ucon:
|
|
|
+ case sp_fcon:
|
|
|
+ put8(sp);
|
|
|
+ putarg(sp_cst4);
|
|
|
+ putstr();
|
|
|
+ break;
|
|
|
+ case sp_cend:
|
|
|
+ put8(sp);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+putstr() {
|
|
|
+ register char *p;
|
|
|
+ long consiz;
|
|
|
+
|
|
|
+ consiz = argval;
|
|
|
+ argval = strsiz;
|
|
|
+ putarg(sp_cst4);
|
|
|
+ argval = consiz;
|
|
|
+ p = string;
|
|
|
+ while (--strsiz >= 0)
|
|
|
+ put8(*p++);
|
|
|
+}
|
|
|
+
|
|
|
+put16(w) int w; {
|
|
|
+
|
|
|
+ put8(w);
|
|
|
+ put8(w >> 8);
|
|
|
+}
|
|
|
+
|
|
|
+put32(f) long f; {
|
|
|
+
|
|
|
+ put16((int) f);
|
|
|
+ put16((int)(f >> 16));
|
|
|
+}
|
|
|
+
|
|
|
+/* ----- error handling ----- */
|
|
|
+
|
|
|
+fail_check() {
|
|
|
+ error("argument range error");
|
|
|
+}
|
|
|
+
|
|
|
+/* VARARGS */
|
|
|
+error(s,a1,a2,a3,a4) char *s; {
|
|
|
+ fprintf(stderr,"%s: line %d: ", filename, lineno);
|
|
|
+ fprintf(stderr,s,a1,a2,a3,a4);
|
|
|
+ fprintf(stderr,"\n");
|
|
|
+ errors++;
|
|
|
+}
|
|
|
+
|
|
|
+/* VARARGS */
|
|
|
+fatal(s,a1,a2,a3,a4) char *s; {
|
|
|
+ error(s,a1,a2,a3,a4);
|
|
|
+ exit(-1);
|
|
|
+}
|
|
|
+
|
|
|
+/* VARARGS */
|
|
|
+syntax(s,a1,a2,a3,a4) char *s; {
|
|
|
+ register c;
|
|
|
+
|
|
|
+ error(s,a1,a2,a3,a4);
|
|
|
+ do
|
|
|
+ c = nextchar();
|
|
|
+ while (c != '\n' && c != EOF);
|
|
|
+ longjmp(recover);
|
|
|
+}
|