ref: f8935b5778397074d41a48205e5c7f87d7b531fe
dir: /appl/cmd/asm/asm.b/
implement Asm;
#line 2 "asm.y"
include "sys.m";
sys: Sys;
include "draw.m";
include "bufio.m";
bufio: Bufio;
Iobuf: import bufio;
include "math.m";
math: Math;
export_real: import math;
include "string.m";
str: String;
include "arg.m";
include "../limbo/isa.m";
YYSTYPE: adt {
inst: ref Inst;
addr: ref Addr;
op: int;
ival: big;
fval: real;
str: string;
sym: ref Sym;
listv: ref List;
};
YYLEX: adt {
lval: YYSTYPE;
EOF: con -1;
lex: fn(l: self ref YYLEX): int;
error: fn(l: self ref YYLEX, msg: string);
numsym: fn(l: self ref YYLEX, first: int): int;
eatstring: fn(l: self ref YYLEX);
};
Eof: con -1;
False: con 0;
True: con 1;
Strsize: con 1024;
Hashsize: con 128;
Addr: adt
{
mode: int;
off: int;
val: int;
sym: ref Sym;
text: fn(a: self ref Addr): string;
};
List: adt
{
link: cyclic ref List;
addr: int;
typ: int;
pick{
Int => ival: big; # DEFB, DEFW, DEFL
Bytes => b: array of byte; # DEFF, DEFS
Array => a: ref Array; # DEFA
}
};
Inst: adt
{
op: int;
typ: int;
size: int;
reg: ref Addr;
src: ref Addr;
dst: ref Addr;
pc: int;
sym: ref Sym;
link: cyclic ref Inst;
text: fn(i: self ref Inst): string;
};
Sym: adt
{
name: string;
lexval: int;
value: int;
ds: int;
};
Desc: adt
{
id: int;
size: int;
np: int;
map: array of byte;
link: cyclic ref Desc;
};
Array: adt
{
i: int;
size: int;
};
Link: adt
{
desc: int;
addr: int;
typ: int;
name: string;
link: cyclic ref Link;
};
Keywd: adt
{
name: string;
op: int;
terminal: int;
};
Ldts: adt
{
n: int;
ldt: list of ref Ldt;
};
Ldt: adt
{
sign: int;
name: string;
};
Exc: adt
{
n1, n2, n3, n4, n5, n6: int;
etab: list of ref Etab;
};
Etab: adt
{
n: int;
name: string;
};
Asm: module {
init: fn(nil: ref Draw->Context, nil: list of string);
TOKI0: con 57346;
TOKI1: con 57347;
TOKI2: con 57348;
TOKI3: con 57349;
TCONST: con 57350;
TOKSB: con 57351;
TOKFP: con 57352;
TOKHEAP: con 57353;
TOKDB: con 57354;
TOKDW: con 57355;
TOKDL: con 57356;
TOKDF: con 57357;
TOKDS: con 57358;
TOKVAR: con 57359;
TOKEXT: con 57360;
TOKMOD: con 57361;
TOKLINK: con 57362;
TOKENTRY: con 57363;
TOKARRAY: con 57364;
TOKINDIR: con 57365;
TOKAPOP: con 57366;
TOKLDTS: con 57367;
TOKEXCS: con 57368;
TOKEXC: con 57369;
TOKETAB: con 57370;
TOKSRC: con 57371;
TID: con 57372;
TFCONST: con 57373;
TSTRING: con 57374;
};
YYEOFCODE: con 1;
YYERRCODE: con 2;
YYMAXDEPTH: con 200;
#line 527 "asm.y"
kinit()
{
for(i := 0; keywds[i].name != nil; i++) {
s := enter(keywds[i].name, keywds[i].terminal);
s.value = keywds[i].op;
}
enter("desc", TOKHEAP);
enter("mp", TOKSB);
enter("fp", TOKFP);
enter("byte", TOKDB);
enter("word", TOKDW);
enter("long", TOKDL);
enter("real", TOKDF);
enter("string", TOKDS);
enter("var", TOKVAR);
enter("ext", TOKEXT);
enter("module", TOKMOD);
enter("link", TOKLINK);
enter("entry", TOKENTRY);
enter("array", TOKARRAY);
enter("indir", TOKINDIR);
enter("apop", TOKAPOP);
enter("ldts", TOKLDTS);
enter("exceptions", TOKEXCS);
enter("exception", TOKEXC);
enter("exctab", TOKETAB);
enter("source", TOKSRC);
cmap['0'] = '\0'+1;
cmap['z'] = '\0'+1;
cmap['n'] = '\n'+1;
cmap['r'] = '\r'+1;
cmap['t'] = '\t'+1;
cmap['b'] = '\b'+1;
cmap['f'] = '\f'+1;
cmap['a'] = '\a'+1;
cmap['v'] = '\v'+1;
cmap['\\'] = '\\'+1;
cmap['"'] = '"'+1;
}
Bgetc(b: ref Iobuf): int
{
return b.getb();
}
Bungetc(b: ref Iobuf)
{
b.ungetb();
}
Bgetrune(b: ref Iobuf): int
{
return b.getc();
}
Bputc(b: ref Iobuf, c: int)
{
b.putb(byte c);
}
strchr(s: string, c: int): string
{
for(i := 0; i < len s; i++)
if(s[i] == c)
return s[i:];
return nil;
}
escchar(c: int): int
{
buf := array[32] of byte;
if(c >= '0' && c <= '9') {
n := 1;
buf[0] = byte c;
for(;;) {
c = Bgetc(bin);
if(c == Eof)
fatal(sys->sprint("%d: <eof> in escape sequence", line));
if(strchr("0123456789xX", c) == nil) {
Bungetc(bin);
break;
}
buf[n++] = byte c;
}
return int string buf[0:n];
}
n := cmap[c];
if(n == 0)
return c;
return n-1;
}
strbuf := array[Strsize] of byte;
resizebuf()
{
t := array[len strbuf+Strsize] of byte;
t[0:] = strbuf;
strbuf = t;
}
YYLEX.eatstring(l: self ref YYLEX)
{
esc := 0;
Scan:
for(cnt := 0;;) {
c := Bgetc(bin);
case c {
Eof =>
fatal(sys->sprint("%d: <eof> in string constant", line));
'\n' =>
line++;
diag("newline in string constant");
break Scan;
'\\' =>
if(esc) {
if(cnt >= len strbuf)
resizebuf();
strbuf[cnt++] = byte c;
esc = 0;
break;
}
esc = 1;
'"' =>
if(esc == 0)
break Scan;
c = escchar(c);
esc = 0;
if(cnt >= len strbuf)
resizebuf();
strbuf[cnt++] = byte c;
* =>
if(esc) {
c = escchar(c);
esc = 0;
}
if(cnt >= len strbuf)
resizebuf();
strbuf[cnt++] = byte c;
}
}
l.lval.str = string strbuf[0: cnt];
}
eatnl()
{
line++;
for(;;) {
c := Bgetc(bin);
if(c == Eof)
diag("eof in comment");
if(c == '\n')
return;
}
}
YYLEX.lex(l: self ref YYLEX): int
{
for(;;){
c := Bgetc(bin);
case c {
Eof =>
return Eof;
'"' =>
l.eatstring();
return TSTRING;
' ' or
'\t' or
'\r' =>
continue;
'\n' =>
line++;
'.' =>
c = Bgetc(bin);
Bungetc(bin);
if(isdigit(c))
return l.numsym('.');
return '.';
'#' =>
eatnl();
'(' or
')' or
';' or
',' or
'~' or
'$' or
'+' or
'/' or
'%' or
'^' or
'*' or
'&' or
'=' or
'|' or
'<' or
'>' or
'-' or
':' =>
return c;
'\'' =>
c = Bgetrune(bin);
if(c == '\\')
l.lval.ival = big escchar(Bgetc(bin));
else
l.lval.ival = big c;
c = Bgetc(bin);
if(c != '\'') {
diag("missing '");
Bungetc(bin);
}
return TCONST;
* =>
return l.numsym(c);
}
}
}
isdigit(c: int): int
{
return c >= '0' && c <= '9';
}
isxdigit(c: int): int
{
return c >= '0' && c <= '9' || c >= 'a' && c <= 'f' || c >= 'A' && c <= 'F';
}
isalnum(c: int): int
{
return c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || isdigit(c);
}
YYLEX.numsym(l: self ref YYLEX, first: int): int
{
Int, Hex, Frac, Expsign, Exp: con iota;
state: int;
symbol[0] = byte first;
p := 0;
if(first == '.')
state = Frac;
else
state = Int;
c: int;
if(isdigit(int symbol[p++]) || state == Frac) {
Collect:
for(;;) {
c = Bgetc(bin);
if(c < 0)
fatal(sys->sprint("%d: <eof> eating numeric", line));
case state {
Int =>
if(isdigit(c))
break;
case c {
'x' or
'X' =>
c = 'x';
state = Hex;
'.' =>
state = Frac;
'e' or
'E' =>
c = 'e';
state = Expsign;
* =>
break Collect;
}
Hex =>
if(!isxdigit(c))
break Collect;
Frac =>
if(isdigit(c))
break;
if(c != 'e' && c != 'E')
break Collect;
c = 'e';
state = Expsign;
Expsign =>
state = Exp;
if(c == '-' || c == '+')
break;
if(!isdigit(c))
break Collect;
Exp =>
if(!isdigit(c))
break Collect;
}
symbol[p++] = byte c;
}
# break Collect
lastsym = string symbol[0:p];
Bungetc(bin);
case state {
Frac or
Expsign or
Exp =>
l.lval.fval = real lastsym;
return TFCONST;
* =>
if(len lastsym >= 3 && lastsym[0:2] == "0x")
(l.lval.ival, nil) = str->tobig(lastsym[2:], 16);
else
(l.lval.ival, nil) = str->tobig(lastsym, 10);
return TCONST;
}
}
for(;;) {
c = Bgetc(bin);
if(c < 0)
fatal(sys->sprint("%d <eof> eating symbols", line));
# '$' and '/' can occur in fully-qualified Java class names
if(c != '_' && c != '.' && c != '/' && c != '$' && !isalnum(c)) {
Bungetc(bin);
break;
}
symbol[p++] = byte c;
}
lastsym = string symbol[0:p];
s := enter(lastsym,TID);
case s.lexval {
TOKI0 or
TOKI1 or
TOKI2 or
TOKI3 =>
l.lval.op = s.value;
* =>
l.lval.sym = s;
}
return s.lexval;
}
hash := array[Hashsize] of list of ref Sym;
enter(name: string, stype: int): ref Sym
{
s := lookup(name);
if(s != nil)
return s;
h := 0;
for(p := 0; p < len name; p++)
h = h*3 + name[p];
if(h < 0)
h = ~h;
h %= Hashsize;
s = ref Sym(name, stype, 0, 0);
hash[h] = s :: hash[h];
return s;
}
lookup(name: string): ref Sym
{
h := 0;
for(p := 0; p < len name; p++)
h = h*3 + name[p];
if(h < 0)
h = ~h;
h %= Hashsize;
for(l := hash[h]; l != nil; l = tl l)
if((s := hd l).name == name)
return s;
return nil;
}
YYLEX.error(l: self ref YYLEX, s: string)
{
if(s == "syntax error") {
l.error(sys->sprint("syntax error, near symbol '%s'", lastsym));
return;
}
sys->print("%s %d: %s\n", file, line, s);
if(nerr++ > 10) {
sys->fprint(sys->fildes(2), "%s:%d: too many errors, giving up\n", file, line);
sys->remove(ofile);
raise "fail: yyerror";
}
}
fatal(s: string)
{
sys->fprint(sys->fildes(2), "asm: %d (fatal compiler problem) %s\n", line, s);
raise "fail:"+s;
}
diag(s: string)
{
srcline := line;
sys->fprint(sys->fildes(2), "%s:%d: %s\n", file, srcline, s);
if(nerr++ > 10) {
sys->fprint(sys->fildes(2), "%s:%d: too many errors, giving up\n", file, line);
sys->remove(ofile);
raise "fail: error";
}
}
zinst: Inst;
ai(op: int): ref Inst
{
i := ref zinst;
i.op = op;
return i;
}
aa(val: big): ref Addr
{
if(val <= big -1073741824 && val > big 1073741823)
diag("offset out of range");
return ref Addr(0, 0, int val, nil);
}
isoff2big(o: int): int
{
return o < 0 || o > 16rFFFF;
}
inldt := 0;
nldts := 0;
aldts: list of ref Ldts;
curl: ref Ldts;
nexcs := 0;
aexcs: list of ref Exc;
cure: ref Exc;
srcpath: string;
bin: ref Iobuf;
bout: ref Iobuf;
line := 0;
heapid := 0;
symbol := array[1024] of byte;
lastsym: string;
nerr := 0;
cmap := array[256] of int;
file: string;
dlist: ref Desc;
dcout := 0;
dseg := 0;
dcount := 0;
mdata: ref List;
amodule: ref Sym;
links: ref Link;
linkt: ref Link;
nlink := 0;
listing := 0;
mustcompile := 0;
dontcompile := 0;
ofile: string;
dentry := 0;
pcentry := 0;
init(nil: ref Draw->Context, args: list of string)
{
sys = load Sys Sys->PATH;
math = load Math Math->PATH;
bufio = load Bufio Bufio->PATH;
str = load String String->PATH;
arg := load Arg Arg->PATH;
arg->setusage("asm [-l] file.s");
arg->init(args);
while((c := arg->opt()) != 0){
case c {
'C' => dontcompile++;
'c' => mustcompile++;
'l' => listing++;
* => arg->usage();
}
}
args = arg->argv();
if(len args != 1)
arg->usage();
arg = nil;
kinit();
pcentry = -1;
dentry = -1;
file = hd args;
bin = bufio->open(file, Bufio->OREAD);
if(bin == nil) {
sys->fprint(sys->fildes(2), "asm: can't open %s: %r\n", file);
raise "fail: errors";
}
p := strrchr(file, '/');
if(p == nil)
p = file;
else
p = p[1:];
ofile = mkfile(p, ".s", ".dis");
bout = bufio->create(ofile, Bufio->OWRITE, 8r666);
if(bout == nil){
sys->fprint(sys->fildes(2), "asm: can't create: %s: %r\n", ofile);
raise "fail: errors";
}
line = 1;
yyparse(ref YYLEX);
bout.close();
if(nerr != 0){
sys->remove(ofile);
raise "fail: errors";
}
}
strrchr(s: string, c: int): string
{
for(i := len s; --i >= 0;)
if(s[i] == c)
return s[i:];
return nil;
}
mkfile(file: string, oldext: string, ext: string): string
{
n := len file;
n2 := len oldext;
if(n >= n2 && file[n-n2:] == oldext)
n -= n2;
return file[0:n] + ext;
}
opcode(i: ref Inst): int
{
if(i.op < 0 || i.op >= len keywds)
fatal(sys->sprint("internal error: invalid op %d (%#x)", i.op, i.op));
return keywds[i.op].op;
}
Inst.text(i: self ref Inst): string
{
if(i == nil)
return "IZ";
case keywds[i.op].terminal {
TOKI0 =>
return sys->sprint("%s", keywds[i.op].name);
TOKI1 =>
return sys->sprint("%s\t%s", keywds[i.op].name, i.dst.text());
TOKI3 =>
if(i.reg != nil) {
pre := "";
post := "";
case i.reg.mode {
AXIMM =>
pre = "$";
break;
AXINF =>
post = "(fp)";
break;
AXINM =>
post = "(mp)";
break;
}
return sys->sprint("%s\t%s, %s%d%s, %s", keywds[i.op].name, i.src.text(), pre, i.reg.val, post, i.dst.text());
}
return sys->sprint("%s\t%s, %s", keywds[i.op].name, i.src.text(), i.dst.text());
TOKI2 =>
return sys->sprint("%s\t%s, %s", keywds[i.op].name, i.src.text(), i.dst.text());
* =>
return "IGOK";
}
}
Addr.text(a: self ref Addr): string
{
if(a == nil)
return "AZ";
if(a.mode & AIND) {
case a.mode & ~AIND {
AFP =>
return sys->sprint("%d(%d(fp))", a.val, a.off);
AMP =>
return sys->sprint("%d(%d(mp))", a.val, a.off);
}
}
else {
case a.mode {
AFP =>
return sys->sprint("%d(fp)", a.val);
AMP =>
return sys->sprint("%d(mp)", a.val);
AIMM =>
return sys->sprint("$%d", a.val);
}
}
return "AGOK";
}
append[T](l: list of T, v: T): list of T
{
if(l == nil)
return v :: nil;
return hd l :: append(tl l, v);
}
newa(i: int, size: int): ref List
{
a := ref Array(i, size);
l := ref List.Array(nil, -1, 0, a);
return l;
}
# does order matter?
newi(v: big, l: ref List): ref List
{
n := ref List.Int(nil, -1, 0, v);
if(l == nil)
return n;
for(t := l; t.link != nil; t = t.link)
;
t.link = n;
return l;
}
news(s: string, l: ref List): ref List
{
return ref List.Bytes(l, -1, 0, array of byte s);
}
newb(a: array of byte, l: ref List): ref List
{
return ref List.Bytes(l, -1, 0, a);
}
digit(x: int): int
{
if(x >= 'A' && x <= 'F')
return x - 'A' + 10;
if(x >= 'a' && x <= 'f')
return x - 'a' + 10;
if(x >= '0' && x <= '9')
return x - '0';
diag("bad hex value in pointers");
return 0;
}
heap(id: int, size: int, ptr: string)
{
d := ref Desc;
d.id = id;
d.size = size;
size /= IBY2WD;
d.map = array[size] of {* => byte 0};
d.np = 0;
if(dlist == nil)
dlist = d;
else {
f: ref Desc;
for(f = dlist; f.link != nil; f = f.link)
;
f.link = d;
}
d.link = nil;
dcount++;
if(ptr == nil)
return;
if(len ptr & 1) {
diag("pointer descriptor has odd length");
return;
}
k := 0;
l := len ptr;
for(i := 0; i < l; i += 2) {
d.map[k++] = byte ((digit(ptr[i])<<4)|digit(ptr[i+1]));
if(k > size) {
diag("pointer descriptor too long");
break;
}
}
d.np = k;
}
conout(val: int)
{
if(val >= -64 && val <= 63) {
Bputc(bout, val & ~16r80);
return;
}
if(val >= -8192 && val <= 8191) {
Bputc(bout, ((val>>8) & ~16rC0) | 16r80);
Bputc(bout, val);
return;
}
if(val < 0 && ((val >> 29) & 7) != 7
|| val > 0 && (val >> 29) != 0)
diag(sys->sprint("overflow in constant 0x%ux\n", val));
Bputc(bout, (val>>24) | 16rC0);
Bputc(bout, val>>16);
Bputc(bout, val>>8);
Bputc(bout, val);
}
aout(a: ref Addr)
{
if(a == nil)
return;
if(a.mode & AIND)
conout(a.off);
conout(a.val);
}
Bputs(b: ref Iobuf, s: string)
{
for(i := 0; i < len s; i++)
Bputc(b, s[i]);
Bputc(b, '\0');
}
lout()
{
if(amodule == nil)
amodule = enter("main", 0);
Bputs(bout, amodule.name);
for(l := links; l != nil; l = l.link) {
conout(l.addr);
conout(l.desc);
Bputc(bout, l.typ>>24);
Bputc(bout, l.typ>>16);
Bputc(bout, l.typ>>8);
Bputc(bout, l.typ);
Bputs(bout, l.name);
}
}
ldtout()
{
conout(nldts);
for(la := aldts; la != nil; la = tl la){
ls := hd la;
conout(ls.n);
for(l := ls.ldt; l != nil; l = tl l){
t := hd l;
Bputc(bout, t.sign>>24);
Bputc(bout, t.sign>>16);
Bputc(bout, t.sign>>8);
Bputc(bout, t.sign);
Bputs(bout, t.name);
}
}
conout(0);
}
excout()
{
if(nexcs == 0)
return;
conout(nexcs);
for(es := aexcs; es != nil; es = tl es){
e := hd es;
conout(e.n3);
conout(e.n1);
conout(e.n2);
conout(e.n4);
conout(e.n5|(e.n6<<16));
for(ets := e.etab; ets != nil; ets = tl ets){
et := hd ets;
if(et.name != nil)
Bputs(bout, et.name);
conout(et.n);
}
}
conout(0);
}
srcout()
{
if(srcpath == nil)
return;
Bputs(bout, srcpath);
}
assem(i: ref Inst)
{
f: ref Inst;
while(i != nil){
link := i.link;
i.link = f;
f = i;
i = link;
}
i = f;
pc := 0;
for(f = i; f != nil; f = f.link) {
f.pc = pc++;
if(f.sym != nil)
f.sym.value = f.pc;
}
if(pcentry >= pc)
diag("entry pc out of range");
if(dentry >= dcount)
diag("entry descriptor out of range");
conout(XMAGIC);
hints := 0;
if(mustcompile)
hints |= MUSTCOMPILE;
if(dontcompile)
hints |= DONTCOMPILE;
hints |= HASLDT;
if(nexcs > 0)
hints |= HASEXCEPT;
conout(hints); # Runtime flags
conout(1024); # default stack size
conout(pc);
conout(dseg);
conout(dcount);
conout(nlink);
conout(pcentry);
conout(dentry);
for(f = i; f != nil; f = f.link) {
if(f.dst != nil && f.dst.sym != nil) {
f.dst.mode = AIMM;
f.dst.val = f.dst.sym.value;
}
o := opcode(f);
if(o == IRAISE){
f.src = f.dst;
f.dst = nil;
}
Bputc(bout, o);
n := 0;
if(f.src != nil)
n |= src(f.src.mode);
else
n |= src(AXXX);
if(f.dst != nil)
n |= dst(f.dst.mode);
else
n |= dst(AXXX);
if(f.reg != nil)
n |= f.reg.mode;
else
n |= AXNON;
Bputc(bout, n);
aout(f.reg);
aout(f.src);
aout(f.dst);
if(listing)
sys->print("%4d %s\n", f.pc, f.text());
}
for(d := dlist; d != nil; d = d.link) {
conout(d.id);
conout(d.size);
conout(d.np);
for(n := 0; n < d.np; n++)
Bputc(bout, int d.map[n]);
}
dout();
lout();
ldtout();
excout();
srcout();
}
data(typ: int, addr: big, l: ref List)
{
if(inldt){
ldtw(int intof(l));
return;
}
l.typ = typ;
l.addr = int addr;
if(mdata == nil)
mdata = l;
else {
for(f := mdata; f.link != nil; f = f.link)
;
f.link = l;
}
}
ext(addr: int, typ: int, s: string)
{
if(inldt){
ldte(typ, s);
return;
}
data(DEFW, big addr, newi(big typ, nil));
n: ref List;
for(i := 0; i < len s; i++)
n = newi(big s[i], n);
data(DEFB, big(addr+IBY2WD), n);
if(addr+len s > dseg)
diag("ext beyond mp");
}
mklink(desc: int, addr: int, typ: int, s: string)
{
for(ls := links; ls != nil; ls = ls.link)
if(ls.name == s)
diag(sys->sprint("%s already defined", s));
nlink++;
l := ref Link;
l.desc = desc;
l.addr = addr;
l.typ = typ;
l.name = s;
l.link = nil;
if(links == nil)
links = l;
else
linkt.link = l;
linkt = l;
}
intof(l: ref List): big
{
pick rl := l {
Int =>
return rl.ival;
* =>
raise "list botch";
}
}
arrayof(l: ref List): ref Array
{
pick rl := l {
Array =>
return rl.a;
* =>
raise "list botch";
}
}
bytesof(l: ref List): array of byte
{
pick rl := l {
Bytes =>
return rl.b;
* =>
raise "list botch";
}
}
nel(l: ref List): (int, ref List)
{
n := 1;
for(e := l.link; e != nil && e.addr == -1; e = e.link)
n++;
return (n, e);
}
dout()
{
e: ref List;
n: int;
for(l := mdata; l != nil; l = e) {
case l.typ {
DEFB =>
(n, e) = nel(l);
if(n < DMAX)
Bputc(bout, dbyte(DEFB, n));
else {
Bputc(bout, dbyte(DEFB, 0));
conout(n);
}
conout(l.addr);
while(l != e) {
Bputc(bout, int intof(l));
l = l.link;
}
break;
DEFW =>
(n, e) = nel(l);
if(n < DMAX)
Bputc(bout, dbyte(DEFW, n));
else {
Bputc(bout, dbyte(DEFW, 0));
conout(n);
}
conout(l.addr);
while(l != e) {
n = int intof(l);
Bputc(bout, n>>24);
Bputc(bout, n>>16);
Bputc(bout, n>>8);
Bputc(bout, n);
l = l.link;
}
break;
DEFL =>
(n, e) = nel(l);
if(n < DMAX)
Bputc(bout, dbyte(DEFL, n));
else {
Bputc(bout, dbyte(DEFL, 0));
conout(n);
}
conout(l.addr);
while(l != e) {
b := intof(l);
Bputc(bout, int (b>>56));
Bputc(bout, int (b>>48));
Bputc(bout, int (b>>40));
Bputc(bout, int (b>>32));
Bputc(bout, int (b>>24));
Bputc(bout, int (b>>16));
Bputc(bout, int (b>>8));
Bputc(bout, int b);
l = l.link;
}
break;
DEFF =>
(n, e) = nel(l);
if(n < DMAX)
Bputc(bout, dbyte(DEFF, n));
else {
Bputc(bout, dbyte(DEFF, 0));
conout(n);
}
conout(l.addr);
while(l != e) {
b := bytesof(l);
Bputc(bout, int b[0]);
Bputc(bout, int b[1]);
Bputc(bout, int b[2]);
Bputc(bout, int b[3]);
Bputc(bout, int b[4]);
Bputc(bout, int b[5]);
Bputc(bout, int b[6]);
Bputc(bout, int b[7]);
l = l.link;
}
break;
DEFS =>
a := bytesof(l);
n = len a;
if(n < DMAX && n != 0)
Bputc(bout, dbyte(DEFS, n));
else {
Bputc(bout, dbyte(DEFS, 0));
conout(n);
}
conout(l.addr);
for(i := 0; i < n; i++)
Bputc(bout, int a[i]);
e = l.link;
break;
DEFA =>
Bputc(bout, dbyte(DEFA, 1));
conout(l.addr);
ar := arrayof(l);
Bputc(bout, ar.i>>24);
Bputc(bout, ar.i>>16);
Bputc(bout, ar.i>>8);
Bputc(bout, ar.i);
Bputc(bout, ar.size>>24);
Bputc(bout, ar.size>>16);
Bputc(bout, ar.size>>8);
Bputc(bout, ar.size);
e = l.link;
break;
DIND =>
Bputc(bout, dbyte(DIND, 1));
conout(l.addr);
Bputc(bout, 0);
Bputc(bout, 0);
Bputc(bout, 0);
Bputc(bout, 0);
e = l.link;
break;
DAPOP =>
Bputc(bout, dbyte(DAPOP, 1));
conout(0);
e = l.link;
break;
}
}
Bputc(bout, dbyte(DEFZ, 0));
}
ldts(n: int)
{
nldts = n;
inldt = 1;
}
ldtw(n: int)
{
ls := ref Ldts(n, nil);
aldts = append(aldts, ls);
curl = ls;
}
ldte(n: int, s: string)
{
l := ref Ldt(n, s);
curl.ldt = append(curl.ldt, l);
}
excs(n: int)
{
nexcs = n;
}
exc(n1: int, n2: int, n3: int, n4: int, n5: int, n6: int)
{
e := ref Exc;
e.n1 = n1;
e.n2 = n2;
e.n3 = n3;
e.n4 = n4;
e.n5 = n5;
e.n6 = n6;
e.etab = nil;
aexcs = append(aexcs, e);
cure = e;
}
etab(s: string, n: int)
{
et := ref Etab;
et.n = n;
et.name = s;
cure.etab = append(cure.etab, et);
}
source(s: string)
{
srcpath = s;
}
dtype(x: int): int
{
return (x>>4)&16rF;
}
dbyte(x: int, l: int): int
{
return (x<<4) | l;
}
dlen(x: int): int
{
return x & (DMAX-1);
}
src(x: int): int
{
return x<<3;
}
dst(x: int): int
{
return x<<0;
}
dtocanon(d: real): array of byte
{
b := array[8] of byte;
export_real(b, array[] of {d});
return b;
}
keywds: array of Keywd = array[] of
{
("nop", INOP, TOKI0),
("alt", IALT, TOKI3),
("nbalt", INBALT, TOKI3),
("goto", IGOTO, TOKI2),
("call", ICALL, TOKI2),
("frame", IFRAME, TOKI2),
("spawn", ISPAWN, TOKI2),
("runt", IRUNT, TOKI2),
("load", ILOAD, TOKI3),
("mcall", IMCALL, TOKI3),
("mspawn", IMSPAWN, TOKI3),
("mframe", IMFRAME, TOKI3),
("ret", IRET, TOKI0),
("jmp", IJMP, TOKI1),
("case", ICASE, TOKI2),
("exit", IEXIT, TOKI0),
("new", INEW, TOKI2),
("newa", INEWA, TOKI3),
("newcb", INEWCB, TOKI1),
("newcw", INEWCW, TOKI1),
("newcf", INEWCF, TOKI1),
("newcp", INEWCP, TOKI1),
("newcm", INEWCM, TOKI2),
("newcmp", INEWCMP, TOKI2),
("send", ISEND, TOKI2),
("recv", IRECV, TOKI2),
("consb", ICONSB, TOKI2),
("consw", ICONSW, TOKI2),
("consp", ICONSP, TOKI2),
("consf", ICONSF, TOKI2),
("consm", ICONSM, TOKI3),
("consmp", ICONSMP, TOKI3),
("headb", IHEADB, TOKI2),
("headw", IHEADW, TOKI2),
("headp", IHEADP, TOKI2),
("headf", IHEADF, TOKI2),
("headm", IHEADM, TOKI3),
("headmp", IHEADMP, TOKI3),
("tail", ITAIL, TOKI2),
("lea", ILEA, TOKI2),
("indx", IINDX, TOKI3),
("movp", IMOVP, TOKI2),
("movm", IMOVM, TOKI3),
("movmp", IMOVMP, TOKI3),
("movb", IMOVB, TOKI2),
("movw", IMOVW, TOKI2),
("movf", IMOVF, TOKI2),
("cvtbw", ICVTBW, TOKI2),
("cvtwb", ICVTWB, TOKI2),
("cvtfw", ICVTFW, TOKI2),
("cvtwf", ICVTWF, TOKI2),
("cvtca", ICVTCA, TOKI2),
("cvtac", ICVTAC, TOKI2),
("cvtwc", ICVTWC, TOKI2),
("cvtcw", ICVTCW, TOKI2),
("cvtfc", ICVTFC, TOKI2),
("cvtcf", ICVTCF, TOKI2),
("addb", IADDB, TOKI3),
("addw", IADDW, TOKI3),
("addf", IADDF, TOKI3),
("subb", ISUBB, TOKI3),
("subw", ISUBW, TOKI3),
("subf", ISUBF, TOKI3),
("mulb", IMULB, TOKI3),
("mulw", IMULW, TOKI3),
("mulf", IMULF, TOKI3),
("divb", IDIVB, TOKI3),
("divw", IDIVW, TOKI3),
("divf", IDIVF, TOKI3),
("modw", IMODW, TOKI3),
("modb", IMODB, TOKI3),
("andb", IANDB, TOKI3),
("andw", IANDW, TOKI3),
("orb", IORB, TOKI3),
("orw", IORW, TOKI3),
("xorb", IXORB, TOKI3),
("xorw", IXORW, TOKI3),
("shlb", ISHLB, TOKI3),
("shlw", ISHLW, TOKI3),
("shrb", ISHRB, TOKI3),
("shrw", ISHRW, TOKI3),
("insc", IINSC, TOKI3),
("indc", IINDC, TOKI3),
("addc", IADDC, TOKI3),
("lenc", ILENC, TOKI2),
("lena", ILENA, TOKI2),
("lenl", ILENL, TOKI2),
("beqb", IBEQB, TOKI3),
("bneb", IBNEB, TOKI3),
("bltb", IBLTB, TOKI3),
("bleb", IBLEB, TOKI3),
("bgtb", IBGTB, TOKI3),
("bgeb", IBGEB, TOKI3),
("beqw", IBEQW, TOKI3),
("bnew", IBNEW, TOKI3),
("bltw", IBLTW, TOKI3),
("blew", IBLEW, TOKI3),
("bgtw", IBGTW, TOKI3),
("bgew", IBGEW, TOKI3),
("beqf", IBEQF, TOKI3),
("bnef", IBNEF, TOKI3),
("bltf", IBLTF, TOKI3),
("blef", IBLEF, TOKI3),
("bgtf", IBGTF, TOKI3),
("bgef", IBGEF, TOKI3),
("beqc", IBEQC, TOKI3),
("bnec", IBNEC, TOKI3),
("bltc", IBLTC, TOKI3),
("blec", IBLEC, TOKI3),
("bgtc", IBGTC, TOKI3),
("bgec", IBGEC, TOKI3),
("slicea", ISLICEA, TOKI3),
("slicela", ISLICELA, TOKI3),
("slicec", ISLICEC, TOKI3),
("indw", IINDW, TOKI3),
("indf", IINDF, TOKI3),
("indb", IINDB, TOKI3),
("negf", INEGF, TOKI2),
("movl", IMOVL, TOKI2),
("addl", IADDL, TOKI3),
("subl", ISUBL, TOKI3),
("divl", IDIVL, TOKI3),
("modl", IMODL, TOKI3),
("mull", IMULL, TOKI3),
("andl", IANDL, TOKI3),
("orl", IORL, TOKI3),
("xorl", IXORL, TOKI3),
("shll", ISHLL, TOKI3),
("shrl", ISHRL, TOKI3),
("bnel", IBNEL, TOKI3),
("bltl", IBLTL, TOKI3),
("blel", IBLEL, TOKI3),
("bgtl", IBGTL, TOKI3),
("bgel", IBGEL, TOKI3),
("beql", IBEQL, TOKI3),
("cvtlf", ICVTLF, TOKI2),
("cvtfl", ICVTFL, TOKI2),
("cvtlw", ICVTLW, TOKI2),
("cvtwl", ICVTWL, TOKI2),
("cvtlc", ICVTLC, TOKI2),
("cvtcl", ICVTCL, TOKI2),
("headl", IHEADL, TOKI2),
("consl", ICONSL, TOKI2),
("newcl", INEWCL, TOKI1),
("casec", ICASEC, TOKI2),
("indl", IINDL, TOKI3),
("movpc", IMOVPC, TOKI2),
("tcmp", ITCMP, TOKI2),
("mnewz", IMNEWZ, TOKI3),
("cvtrf", ICVTRF, TOKI2),
("cvtfr", ICVTFR, TOKI2),
("cvtws", ICVTWS, TOKI2),
("cvtsw", ICVTSW, TOKI2),
("lsrw", ILSRW, TOKI3),
("lsrl", ILSRL, TOKI3),
("eclr", IECLR, TOKI0),
("newz", INEWZ, TOKI2),
("newaz", INEWAZ, TOKI3),
("raise", IRAISE, TOKI1),
("casel", ICASEL, TOKI2),
("mulx", IMULX, TOKI3),
("divx", IDIVX, TOKI3),
("cvtxx", ICVTXX, TOKI3),
("mulx0", IMULX0, TOKI3),
("divx0", IDIVX0, TOKI3),
("cvtxx0", ICVTXX0, TOKI3),
("mulx1", IMULX1, TOKI3),
("divx1", IDIVX1, TOKI3),
("cvtxx1", ICVTXX1, TOKI3),
("cvtfx", ICVTFX, TOKI3),
("cvtxf", ICVTXF, TOKI3),
("expw", IEXPW, TOKI3),
("expl", IEXPL, TOKI3),
("expf", IEXPF, TOKI3),
("self", ISELF, TOKI1),
(nil, 0, 0),
};
yyexca := array[] of {-1, 1,
1, -1,
-2, 0,
-1, 61,
4, 54,
5, 54,
6, 54,
7, 54,
8, 54,
9, 54,
10, 54,
11, 54,
12, 54,
13, 54,
46, 54,
-2, 46,
-1, 140,
44, 44,
-2, 50,
-1, 159,
44, 43,
-2, 45,
};
YYNPROD: con 70;
YYPRIVATE: con 57344;
yytoknames: array of string;
yystates: array of string;
include "y.debug";
yydebug: con 1;
YYLAST: con 561;
yyact := array[] of {
64, 59, 107, 65, 162, 161, 31, 160, 158, 34,
42, 43, 44, 45, 156, 47, 48, 33, 50, 51,
52, 30, 32, 54, 55, 148, 39, 38, 63, 66,
67, 105, 100, 70, 99, 36, 98, 96, 90, 69,
57, 172, 85, 81, 80, 79, 77, 78, 72, 73,
74, 75, 76, 165, 163, 126, 151, 61, 58, 53,
49, 101, 60, 41, 103, 40, 46, 102, 143, 144,
106, 56, 108, 109, 110, 111, 112, 113, 153, 152,
116, 117, 118, 7, 115, 114, 119, 108, 108, 120,
121, 127, 128, 129, 130, 6, 132, 133, 134, 135,
136, 131, 137, 1, 140, 103, 35, 145, 142, 146,
29, 28, 27, 26, 68, 149, 150, 5, 8, 9,
10, 11, 12, 13, 14, 16, 15, 17, 18, 19,
20, 21, 22, 23, 24, 25, 4, 74, 75, 76,
159, 62, 138, 125, 2, 82, 83, 84, 3, 164,
0, 122, 29, 28, 27, 26, 166, 167, 168, 0,
169, 81, 80, 79, 77, 78, 72, 73, 74, 75,
76, 0, 173, 124, 123, 175, 0, 177, 81, 80,
79, 77, 78, 72, 73, 74, 75, 76, 39, 38,
0, 0, 39, 38, 63, 0, 0, 36, 143, 144,
0, 36, 0, 141, 81, 80, 79, 77, 78, 72,
73, 74, 75, 76, 72, 73, 74, 75, 76, 37,
104, 0, 0, 61, 0, 41, 0, 40, 139, 41,
0, 40, 81, 80, 79, 77, 78, 72, 73, 74,
75, 76, 0, 0, 176, 81, 80, 79, 77, 78,
72, 73, 74, 75, 76, 81, 80, 79, 77, 78,
72, 73, 74, 75, 76, 77, 78, 72, 73, 74,
75, 76, 174, 81, 80, 79, 77, 78, 72, 73,
74, 75, 76, 0, 0, 171, 80, 79, 77, 78,
72, 73, 74, 75, 76, 170, 81, 80, 79, 77,
78, 72, 73, 74, 75, 76, 0, 0, 0, 0,
0, 0, 0, 157, 81, 80, 79, 77, 78, 72,
73, 74, 75, 76, 81, 80, 79, 77, 78, 72,
73, 74, 75, 76, 0, 0, 155, 81, 80, 79,
77, 78, 72, 73, 74, 75, 76, 0, 0, 0,
0, 0, 0, 0, 154, 79, 77, 78, 72, 73,
74, 75, 76, 0, 147, 81, 80, 79, 77, 78,
72, 73, 74, 75, 76, 0, 0, 97, 81, 80,
79, 77, 78, 72, 73, 74, 75, 76, 81, 80,
79, 77, 78, 72, 73, 74, 75, 76, 0, 0,
0, 0, 0, 0, 0, 95, 81, 80, 79, 77,
78, 72, 73, 74, 75, 76, 0, 0, 94, 0,
0, 0, 0, 0, 0, 0, 0, 0, 93, 81,
80, 79, 77, 78, 72, 73, 74, 75, 76, 0,
0, 0, 0, 0, 0, 0, 92, 81, 80, 79,
77, 78, 72, 73, 74, 75, 76, 81, 80, 79,
77, 78, 72, 73, 74, 75, 76, 0, 0, 91,
81, 80, 79, 77, 78, 72, 73, 74, 75, 76,
0, 0, 0, 0, 0, 0, 0, 89, 0, 0,
0, 0, 0, 0, 0, 0, 0, 88, 81, 80,
79, 77, 78, 72, 73, 74, 75, 76, 0, 0,
87, 81, 80, 79, 77, 78, 72, 73, 74, 75,
76, 39, 38, 0, 0, 0, 0, 0, 0, 0,
36, 0, 0, 0, 0, 0, 0, 0, 86, 81,
80, 79, 77, 78, 72, 73, 74, 75, 76, 0,
0, 71, 37, 0, 0, 0, 0, 0, 41, 0,
40,
};
yypact := array[] of {
-1000,-1000, 96,-1000, -22, -23,-1000,-1000, 512, 512,
512, 512, 512, 26, 512, 512, 20, 512, 512, 512,
-1000, 19, 512, 512, 29, 16, 17, 17, 17,-1000,
138, -5, 512,-1000, 507,-1000,-1000,-1000, 512, 512,
512, 512, 494, 466, 453, 443, -6, 425, 402,-1000,
384, 374, 361, -7, 535, 333, -8, -10,-1000, -12,
512,-1000,-1000, 512, 174,-1000, -13,-1000,-1000, 512,
535, 512, 512, 512, 512, 512, 512, 78, 76, 512,
512, 512,-1000,-1000,-1000, 39, 512, 512, 133, 13,
512, 512, 512, 512, -23, 512, 512, 512, 512, 512,
183, 535,-1000, 157, 179, 17, 320, -19, 535, 126,
126,-1000,-1000,-1000, 512, 512, 258, 349, 281,-1000,
-19, -19,-1000,-1000,-1000, 38,-1000, 535, 310, 292,
535, -30, 535, 535, 269, 535, 535,-1000, -36, 512,
-1000, 49, -40, -42, -43,-1000,-1000, 12, 512, 205,
205,-1000,-1000,-1000, 11, 512, 512, 512, 17, 535,
-1000,-1000,-1000,-1000, 535,-1000, 251, 535, 241,-1000,
-1, 512,-1000, 228, 512, 200, 512, 535,
};
yypgo := array[] of {
0, 148, 144, 83, 106, 0, 6, 1, 142, 141,
3, 2, 109, 103, 95,
};
yyr1 := array[] of {
0, 13, 2, 2, 1, 1, 1, 1, 6, 6,
12, 12, 11, 11, 3, 3, 3, 3, 3, 14,
14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
14, 14, 14, 8, 8, 7, 7, 7, 9, 9,
9, 10, 10, 4, 4, 4, 4, 4, 4, 5,
5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
};
yyr2 := array[] of {
0, 1, 0, 2, 3, 5, 1, 1, 2, 1,
0, 2, 1, 3, 4, 6, 4, 2, 1, 4,
4, 4, 4, 4, 4, 5, 5, 5, 4, 4,
6, 8, 2, 4, 6, 4, 1, 4, 2, 12,
4, 4, 2, 2, 1, 2, 1, 1, 2, 4,
1, 4, 4, 1, 1, 2, 2, 2, 3, 1,
3, 3, 3, 3, 3, 4, 4, 3, 3, 3,
};
yychk := array[] of {
-1000, -13, -2, -1, 40, 21, -14, -3, 22, 23,
24, 25, 26, 27, 28, 30, 29, 31, 32, 33,
34, 35, 36, 37, 38, 39, 17, 16, 15, 14,
43, -6, 45, 40, -5, -4, 18, 40, 10, 9,
48, 46, -5, -5, -5, -5, 40, -5, -5, 40,
-5, -5, -5, 40, -5, -5, 42, 11, 42, -7,
45, 40, -9, 11, -5, -10, -7, -7, -3, 44,
-5, 44, 9, 10, 11, 12, 13, 7, 8, 6,
5, 4, -4, -4, -4, -5, 44, 44, 44, 44,
44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
44, -5, -10, -5, 46, 44, -5, -11, -5, -5,
-5, -5, -5, -5, 7, 8, -5, -5, -5, 47,
-11, -11, 18, 41, 40, 10, 42, -5, -5, -5,
-5, -6, -5, -5, -5, -5, -5, -7, -8, 45,
-10, 46, -10, 19, 20, -7, -12, 44, 44, -5,
-5, 18, 41, 40, 44, 44, 44, 44, 44, -5,
47, 47, 47, 42, -5, 42, -5, -5, -5, -7,
44, 44, 42, -5, 44, -5, 44, -5,
};
yydef := array[] of {
2, -2, 1, 3, 0, 0, 6, 7, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
36, 0, 0, 0, 0, 0, 0, 0, 0, 18,
0, 0, 0, 9, 0, 59, 53, 54, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 32,
0, 0, 0, 0, 38, 0, 0, 0, 42, 0,
0, -2, 47, 0, 0, 50, 0, 17, 4, 0,
8, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 55, 56, 57, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 45, 48, 0, 0, 0, 10, 19, 12, 60,
61, 62, 63, 64, 0, 0, 67, 68, 69, 58,
20, 21, 22, 23, 24, 0, 28, 29, 0, 0,
33, 0, 35, 37, 0, 40, 41, 14, 0, 0,
-2, 0, 0, 0, 0, 16, 5, 0, 0, 65,
66, 25, 26, 27, 0, 0, 0, 0, 0, -2,
49, 51, 52, 11, 13, 30, 0, 34, 0, 15,
0, 0, 31, 0, 0, 0, 0, 39,
};
yytok1 := array[] of {
1, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 45, 13, 6, 3,
46, 47, 11, 9, 44, 10, 3, 12, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 43, 3,
7, 3, 8, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 5, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 4, 3, 48,
};
yytok2 := array[] of {
2, 3, 14, 15, 16, 17, 18, 19, 20, 21,
22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
42,
};
yytok3 := array[] of {
0
};
YYSys: module
{
FD: adt
{
fd: int;
};
fildes: fn(fd: int): ref FD;
fprint: fn(fd: ref FD, s: string, *): int;
};
yysys: YYSys;
yystderr: ref YYSys->FD;
YYFLAG: con -1000;
# parser for yacc output
yytokname(yyc: int): string
{
if(yyc > 0 && yyc <= len yytoknames && yytoknames[yyc-1] != nil)
return yytoknames[yyc-1];
return "<"+string yyc+">";
}
yystatname(yys: int): string
{
if(yys >= 0 && yys < len yystates && yystates[yys] != nil)
return yystates[yys];
return "<"+string yys+">\n";
}
yylex1(yylex: ref YYLEX): int
{
c : int;
yychar := yylex.lex();
if(yychar <= 0)
c = yytok1[0];
else if(yychar < len yytok1)
c = yytok1[yychar];
else if(yychar >= YYPRIVATE && yychar < YYPRIVATE+len yytok2)
c = yytok2[yychar-YYPRIVATE];
else{
n := len yytok3;
c = 0;
for(i := 0; i < n; i+=2) {
if(yytok3[i+0] == yychar) {
c = yytok3[i+1];
break;
}
}
if(c == 0)
c = yytok2[1]; # unknown char
}
if(yydebug >= 3)
yysys->fprint(yystderr, "lex %.4ux %s\n", yychar, yytokname(c));
return c;
}
YYS: adt
{
yyv: YYSTYPE;
yys: int;
};
yyparse(yylex: ref YYLEX): int
{
if(yydebug >= 1 && yysys == nil) {
yysys = load YYSys "$Sys";
yystderr = yysys->fildes(2);
}
yys := array[YYMAXDEPTH] of YYS;
yyval: YYSTYPE;
yystate := 0;
yychar := -1;
yynerrs := 0; # number of errors
yyerrflag := 0; # error recovery flag
yyp := -1;
yyn := 0;
yystack:
for(;;){
# put a state and value onto the stack
if(yydebug >= 4)
yysys->fprint(yystderr, "char %s in %s", yytokname(yychar), yystatname(yystate));
yyp++;
if(yyp >= len yys)
yys = (array[len yys * 2] of YYS)[0:] = yys;
yys[yyp].yys = yystate;
yys[yyp].yyv = yyval;
for(;;){
yyn = yypact[yystate];
if(yyn > YYFLAG) { # simple state
if(yychar < 0)
yychar = yylex1(yylex);
yyn += yychar;
if(yyn >= 0 && yyn < YYLAST) {
yyn = yyact[yyn];
if(yychk[yyn] == yychar) { # valid shift
yychar = -1;
yyp++;
if(yyp >= len yys)
yys = (array[len yys * 2] of YYS)[0:] = yys;
yystate = yyn;
yys[yyp].yys = yystate;
yys[yyp].yyv = yylex.lval;
if(yyerrflag > 0)
yyerrflag--;
if(yydebug >= 4)
yysys->fprint(yystderr, "char %s in %s", yytokname(yychar), yystatname(yystate));
continue;
}
}
}
# default state action
yyn = yydef[yystate];
if(yyn == -2) {
if(yychar < 0)
yychar = yylex1(yylex);
# look through exception table
for(yyxi:=0;; yyxi+=2)
if(yyexca[yyxi] == -1 && yyexca[yyxi+1] == yystate)
break;
for(yyxi += 2;; yyxi += 2) {
yyn = yyexca[yyxi];
if(yyn < 0 || yyn == yychar)
break;
}
yyn = yyexca[yyxi+1];
if(yyn < 0){
yyn = 0;
break yystack;
}
}
if(yyn != 0)
break;
# error ... attempt to resume parsing
if(yyerrflag == 0) { # brand new error
yylex.error("syntax error");
yynerrs++;
if(yydebug >= 1) {
yysys->fprint(yystderr, "%s", yystatname(yystate));
yysys->fprint(yystderr, "saw %s\n", yytokname(yychar));
}
}
if(yyerrflag != 3) { # incompletely recovered error ... try again
yyerrflag = 3;
# find a state where "error" is a legal shift action
while(yyp >= 0) {
yyn = yypact[yys[yyp].yys] + YYERRCODE;
if(yyn >= 0 && yyn < YYLAST) {
yystate = yyact[yyn]; # simulate a shift of "error"
if(yychk[yystate] == YYERRCODE)
continue yystack;
}
# the current yyp has no shift onn "error", pop stack
if(yydebug >= 2)
yysys->fprint(yystderr, "error recovery pops state %d, uncovers %d\n",
yys[yyp].yys, yys[yyp-1].yys );
yyp--;
}
# there is no state on the stack with an error shift ... abort
yyn = 1;
break yystack;
}
# no shift yet; clobber input char
if(yydebug >= 2)
yysys->fprint(yystderr, "error recovery discards %s\n", yytokname(yychar));
if(yychar == YYEOFCODE) {
yyn = 1;
break yystack;
}
yychar = -1;
# try again in the same state
}
# reduction by production yyn
if(yydebug >= 2)
yysys->fprint(yystderr, "reduce %d in:\n\t%s", yyn, yystatname(yystate));
yypt := yyp;
yyp -= yyr2[yyn];
# yyval = yys[yyp+1].yyv;
yym := yyn;
# consult goto table to find next state
yyn = yyr1[yyn];
yyg := yypgo[yyn];
yyj := yyg + yys[yyp].yys + 1;
if(yyj >= YYLAST || yychk[yystate=yyact[yyj]] != -yyn)
yystate = yyact[yyg];
case yym {
1=>
#line 178 "asm.y"
{
assem(yys[yypt-0].yyv.inst);
}
2=>
#line 184 "asm.y"
{ yyval.inst = nil; }
3=>
#line 186 "asm.y"
{
if(yys[yypt-0].yyv.inst != nil) {
yys[yypt-0].yyv.inst.link = yys[yypt-1].yyv.inst;
yyval.inst = yys[yypt-0].yyv.inst;
}
else
yyval.inst = yys[yypt-1].yyv.inst;
}
4=>
#line 197 "asm.y"
{
yys[yypt-0].yyv.inst.sym = yys[yypt-2].yyv.sym;
yyval.inst = yys[yypt-0].yyv.inst;
}
5=>
#line 202 "asm.y"
{
heap(int yys[yypt-3].yyv.ival, int yys[yypt-1].yyv.ival, yys[yypt-0].yyv.str);
yyval.inst = nil;
}
6=>
#line 207 "asm.y"
{
yyval.inst = nil;
}
7=>
yyval.inst = yys[yyp+1].yyv.inst;
8=>
#line 214 "asm.y"
{
yyval.ival = yys[yypt-0].yyv.ival;
}
9=>
#line 218 "asm.y"
{
yys[yypt-0].yyv.sym.value = heapid++;
yyval.ival = big yys[yypt-0].yyv.sym.value;
}
10=>
#line 225 "asm.y"
{ yyval.str = nil; }
11=>
#line 227 "asm.y"
{
yyval.str = yys[yypt-0].yyv.str;
}
12=>
#line 233 "asm.y"
{
yyval.listv = newi(yys[yypt-0].yyv.ival, nil);
}
13=>
#line 237 "asm.y"
{
yyval.listv = newi(yys[yypt-0].yyv.ival, yys[yypt-2].yyv.listv);
}
14=>
#line 243 "asm.y"
{
yyval.inst = ai(yys[yypt-3].yyv.op);
yyval.inst.src = yys[yypt-2].yyv.addr;
yyval.inst.dst = yys[yypt-0].yyv.addr;
}
15=>
#line 249 "asm.y"
{
yyval.inst = ai(yys[yypt-5].yyv.op);
yyval.inst.src = yys[yypt-4].yyv.addr;
yyval.inst.reg = yys[yypt-2].yyv.addr;
yyval.inst.dst = yys[yypt-0].yyv.addr;
}
16=>
#line 256 "asm.y"
{
yyval.inst = ai(yys[yypt-3].yyv.op);
yyval.inst.src = yys[yypt-2].yyv.addr;
yyval.inst.dst = yys[yypt-0].yyv.addr;
}
17=>
#line 262 "asm.y"
{
yyval.inst = ai(yys[yypt-1].yyv.op);
yyval.inst.dst = yys[yypt-0].yyv.addr;
}
18=>
#line 267 "asm.y"
{
yyval.inst = ai(yys[yypt-0].yyv.op);
}
19=>
#line 273 "asm.y"
{
data(DEFB, yys[yypt-2].yyv.ival, yys[yypt-0].yyv.listv);
}
20=>
#line 277 "asm.y"
{
data(DEFW, yys[yypt-2].yyv.ival, yys[yypt-0].yyv.listv);
}
21=>
#line 281 "asm.y"
{
data(DEFL, yys[yypt-2].yyv.ival, yys[yypt-0].yyv.listv);
}
22=>
#line 285 "asm.y"
{
data(DEFF, yys[yypt-2].yyv.ival, newb(dtocanon(real yys[yypt-0].yyv.ival), nil));
}
23=>
#line 289 "asm.y"
{
data(DEFF, yys[yypt-2].yyv.ival, newb(dtocanon(yys[yypt-0].yyv.fval), nil));
}
24=>
#line 293 "asm.y"
{
case yys[yypt-0].yyv.sym.name {
"Inf" or "Infinity" =>
b := array[] of {byte 16r7F, byte 16rF0, byte 0, byte 0, byte 0, byte 0, byte 0, byte 0};
data(DEFF, yys[yypt-2].yyv.ival, newb(b, nil));
"NaN" =>
b := array[] of {byte 16r7F, byte 16rFF, byte 16rFF, byte 16rFF, byte 16rFF, byte 16rFF, byte 16rFF, byte 16rFF};
data(DEFF, yys[yypt-2].yyv.ival, newb(b, nil));
* =>
diag(sys->sprint("bad value for real: %s", yys[yypt-0].yyv.sym.name));
}
}
25=>
#line 306 "asm.y"
{
data(DEFF, yys[yypt-3].yyv.ival, newb(dtocanon(-real yys[yypt-0].yyv.ival), nil));
}
26=>
#line 310 "asm.y"
{
data(DEFF, yys[yypt-3].yyv.ival, newb(dtocanon(-yys[yypt-0].yyv.fval), nil));
}
27=>
#line 314 "asm.y"
{
case yys[yypt-0].yyv.sym.name {
"Inf" or "Infinity" =>
b := array[] of {byte 16rFF, byte 16rF0, byte 0, byte 0, byte 0, byte 0, byte 0, byte 0};
data(DEFF, yys[yypt-3].yyv.ival, newb(b, nil));
* =>
diag(sys->sprint("bad value for real: %s", yys[yypt-0].yyv.sym.name));
}
}
28=>
#line 324 "asm.y"
{
data(DEFS, yys[yypt-2].yyv.ival, news(yys[yypt-0].yyv.str, nil));
}
29=>
#line 328 "asm.y"
{
if(yys[yypt-2].yyv.sym.ds != 0)
diag(sys->sprint("%s declared twice", yys[yypt-2].yyv.sym.name));
yys[yypt-2].yyv.sym.ds = int yys[yypt-0].yyv.ival;
yys[yypt-2].yyv.sym.value = dseg;
dseg += int yys[yypt-0].yyv.ival;
}
30=>
#line 336 "asm.y"
{
ext(int yys[yypt-4].yyv.ival, int yys[yypt-2].yyv.ival, yys[yypt-0].yyv.str);
}
31=>
#line 340 "asm.y"
{
mklink(int yys[yypt-6].yyv.ival, int yys[yypt-4].yyv.ival, int yys[yypt-2].yyv.ival, yys[yypt-0].yyv.str);
}
32=>
#line 344 "asm.y"
{
if(amodule != nil)
diag(sys->sprint("this module already defined as %s", yys[yypt-0].yyv.sym.name));
else
amodule = yys[yypt-0].yyv.sym;
}
33=>
#line 351 "asm.y"
{
if(pcentry >= 0)
diag(sys->sprint("this module already has entry point %d, %d" , pcentry, dentry));
pcentry = int yys[yypt-2].yyv.ival;
dentry = int yys[yypt-0].yyv.ival;
}
34=>
#line 358 "asm.y"
{
data(DEFA, yys[yypt-4].yyv.ival, newa(int yys[yypt-2].yyv.ival, int yys[yypt-0].yyv.ival));
}
35=>
#line 362 "asm.y"
{
data(DIND, yys[yypt-2].yyv.ival, newa(int yys[yypt-0].yyv.ival, 0));
}
36=>
#line 366 "asm.y"
{
data(DAPOP, big 0, newa(0, 0));
}
37=>
#line 370 "asm.y"
{
ldts(int yys[yypt-0].yyv.ival);
}
38=>
#line 374 "asm.y"
{
excs(int yys[yypt-0].yyv.ival);
}
39=>
#line 378 "asm.y"
{
exc(int yys[yypt-10].yyv.ival, int yys[yypt-8].yyv.ival, int yys[yypt-6].yyv.ival, int yys[yypt-4].yyv.ival, int yys[yypt-2].yyv.ival, int yys[yypt-0].yyv.ival);
}
40=>
#line 382 "asm.y"
{
etab(yys[yypt-2].yyv.str, int yys[yypt-0].yyv.ival);
}
41=>
#line 386 "asm.y"
{
etab(nil, int yys[yypt-0].yyv.ival);
}
42=>
#line 390 "asm.y"
{
source(yys[yypt-0].yyv.str);
}
43=>
#line 396 "asm.y"
{
yyval.addr = aa(yys[yypt-0].yyv.ival);
yyval.addr.mode = AXIMM;
if(yyval.addr.val > 16r7FFF || yyval.addr.val < -16r8000)
diag(sys->sprint("immediate %d too large for middle operand", yyval.addr.val));
}
44=>
#line 403 "asm.y"
{
if(yys[yypt-0].yyv.addr.mode == AMP)
yys[yypt-0].yyv.addr.mode = AXINM;
else
yys[yypt-0].yyv.addr.mode = AXINF;
if(yys[yypt-0].yyv.addr.mode == AXINM && isoff2big(yys[yypt-0].yyv.addr.val))
diag(sys->sprint("register offset %d(mp) too large", yys[yypt-0].yyv.addr.val));
if(yys[yypt-0].yyv.addr.mode == AXINF && isoff2big(yys[yypt-0].yyv.addr.val))
diag(sys->sprint("register offset %d(fp) too large", yys[yypt-0].yyv.addr.val));
yyval.addr = yys[yypt-0].yyv.addr;
}
45=>
#line 417 "asm.y"
{
yyval.addr = aa(yys[yypt-0].yyv.ival);
yyval.addr.mode = AIMM;
}
46=>
#line 422 "asm.y"
{
yyval.addr = aa(big 0);
yyval.addr.sym = yys[yypt-0].yyv.sym;
}
47=>
yyval.addr = yys[yyp+1].yyv.addr;
48=>
#line 430 "asm.y"
{
yys[yypt-0].yyv.addr.mode |= AIND;
yyval.addr = yys[yypt-0].yyv.addr;
}
49=>
#line 435 "asm.y"
{
yys[yypt-1].yyv.addr.mode |= AIND;
if(yys[yypt-1].yyv.addr.val & 3)
diag("indirect offset must be word size");
if(yys[yypt-1].yyv.addr.mode == (AMP|AIND) && (isoff2big(yys[yypt-1].yyv.addr.val) || isoff2big(int yys[yypt-3].yyv.ival)))
diag(sys->sprint("indirect offset %bd(%d(mp)) too large", yys[yypt-3].yyv.ival, yys[yypt-1].yyv.addr.val));
if(yys[yypt-1].yyv.addr.mode == (AFP|AIND) && (isoff2big(yys[yypt-1].yyv.addr.val) || isoff2big(int yys[yypt-3].yyv.ival)))
diag(sys->sprint("indirect offset %bd(%d(fp)) too large", yys[yypt-3].yyv.ival, yys[yypt-1].yyv.addr.val));
yys[yypt-1].yyv.addr.off = yys[yypt-1].yyv.addr.val;
yys[yypt-1].yyv.addr.val = int yys[yypt-3].yyv.ival;
yyval.addr = yys[yypt-1].yyv.addr;
}
50=>
yyval.addr = yys[yyp+1].yyv.addr;
51=>
#line 451 "asm.y"
{
yyval.addr = aa(yys[yypt-3].yyv.ival);
yyval.addr.mode = AMP;
}
52=>
#line 456 "asm.y"
{
yyval.addr = aa(yys[yypt-3].yyv.ival);
yyval.addr.mode = AFP;
}
53=>
yyval.ival = yys[yyp+1].yyv.ival;
54=>
#line 464 "asm.y"
{
yyval.ival = big yys[yypt-0].yyv.sym.value;
}
55=>
#line 468 "asm.y"
{
yyval.ival = -yys[yypt-0].yyv.ival;
}
56=>
#line 472 "asm.y"
{
yyval.ival = yys[yypt-0].yyv.ival;
}
57=>
#line 476 "asm.y"
{
yyval.ival = ~yys[yypt-0].yyv.ival;
}
58=>
#line 480 "asm.y"
{
yyval.ival = yys[yypt-1].yyv.ival;
}
59=>
yyval.ival = yys[yyp+1].yyv.ival;
60=>
#line 487 "asm.y"
{
yyval.ival = yys[yypt-2].yyv.ival + yys[yypt-0].yyv.ival;
}
61=>
#line 491 "asm.y"
{
yyval.ival = yys[yypt-2].yyv.ival - yys[yypt-0].yyv.ival;
}
62=>
#line 495 "asm.y"
{
yyval.ival = yys[yypt-2].yyv.ival * yys[yypt-0].yyv.ival;
}
63=>
#line 499 "asm.y"
{
yyval.ival = yys[yypt-2].yyv.ival / yys[yypt-0].yyv.ival;
}
64=>
#line 503 "asm.y"
{
yyval.ival = yys[yypt-2].yyv.ival % yys[yypt-0].yyv.ival;
}
65=>
#line 507 "asm.y"
{
yyval.ival = yys[yypt-3].yyv.ival << int yys[yypt-0].yyv.ival;
}
66=>
#line 511 "asm.y"
{
yyval.ival = yys[yypt-3].yyv.ival >> int yys[yypt-0].yyv.ival;
}
67=>
#line 515 "asm.y"
{
yyval.ival = yys[yypt-2].yyv.ival & yys[yypt-0].yyv.ival;
}
68=>
#line 519 "asm.y"
{
yyval.ival = yys[yypt-2].yyv.ival ^ yys[yypt-0].yyv.ival;
}
69=>
#line 523 "asm.y"
{
yyval.ival = yys[yypt-2].yyv.ival | yys[yypt-0].yyv.ival;
}
}
}
return yyn;
}