ref: 53aac62a54ebbcc1781c0000d3e2384ed038c7bb
dir: /appl/cmd/limbo/decls.b/
storename := array[Dend] of
{
Dtype => "type",
Dfn => "function",
Dglobal => "global",
Darg => "argument",
Dlocal => "local",
Dconst => "con",
Dfield => "field",
Dtag => "pick tag",
Dimport => "import",
Dunbound => "unbound",
Dundef => "undefined",
Dwundef => "undefined",
};
storeart := array[Dend] of
{
Dtype => "a ",
Dfn => "a ",
Dglobal => "a ",
Darg => "an ",
Dlocal => "a ",
Dconst => "a ",
Dfield => "a ",
Dtag => "a ",
Dimport => "an ",
Dunbound => "",
Dundef => "",
Dwundef => "",
};
storespace := array[Dend] of
{
Dtype => 0,
Dfn => 0,
Dglobal => 1,
Darg => 1,
Dlocal => 1,
Dconst => 0,
Dfield => 1,
Dtag => 0,
Dimport => 0,
Dunbound => 0,
Dundef => 0,
Dwundef => 0,
};
impdecl: ref Decl;
impdecls: ref Dlist;
scopes := array[MaxScope] of ref Decl;
tails := array[MaxScope] of ref Decl;
scopekind := array[MaxScope] of byte;
scopenode := array[MaxScope] of ref Node;
iota: ref Decl;
zdecl: Decl;
popscopes()
{
d: ref Decl;
#
# clear out any decls left in syms
#
while(scope >= ScopeBuiltin){
for(d = scopes[scope--]; d != nil; d = d.next){
if(d.sym != nil){
d.sym.decl = d.old;
d.old = nil;
}
}
}
for(id := impdecls; id != nil; id = id.next){
for(d = id.d.ty.ids; d != nil; d = d.next){
d.sym.decl = nil;
d.old = nil;
}
}
impdecls = nil;
scope = ScopeBuiltin;
scopes[ScopeBuiltin] = nil;
tails[ScopeBuiltin] = nil;
}
declstart()
{
iota = mkids(nosrc, enter("iota", 0), tint, nil);
iota.init = mkconst(nosrc, big 0);
scope = ScopeNils;
scopes[ScopeNils] = nil;
tails[ScopeNils] = nil;
nildecl = mkdecl(nosrc, Dglobal, tany);
nildecl.sym = enter("nil", 0);
installids(Dglobal, nildecl);
d := mkdecl(nosrc, Dglobal, tstring);
d.sym = enterstring("");
installids(Dglobal, d);
scope = ScopeGlobal;
scopes[ScopeGlobal] = nil;
tails[ScopeGlobal] = nil;
}
redecl(d: ref Decl)
{
old := d.sym.decl;
if(old.store == Dwundef)
return;
error(d.src.start, "redeclaration of "+declconv(d)+", previously declared as "+storeconv(old)+" on line "+
lineconv(old.src.start));
}
checkrefs(d: ref Decl)
{
id, m: ref Decl;
refs: int;
for(; d != nil; d = d.next){
if(d.das != byte 0)
d.refs--;
case d.store{
Dtype =>
refs = d.refs;
if(d.ty.kind == Tadt){
for(id = d.ty.ids; id != nil; id = id.next){
d.refs += id.refs;
if(id.store != Dfn)
continue;
if(id.init == nil && id.link == nil && d.importid == nil)
error(d.src.start, "function "+d.sym.name+"."+id.sym.name+" not defined");
if(superwarn && !id.refs && d.importid == nil)
warn(d.src.start, "function "+d.sym.name+"."+id.sym.name+" not referenced");
}
}
if(d.ty.kind == Tmodule){
for(id = d.ty.ids; id != nil; id = id.next){
refs += id.refs;
if(id.iface != nil)
id.iface.refs += id.refs;
if(id.store == Dtype){
for(m = id.ty.ids; m != nil; m = m.next){
refs += m.refs;
if(m.iface != nil)
m.iface.refs += m.refs;
}
}
}
d.refs = refs;
}
if(superwarn && !refs && d.importid == nil)
warn(d.src.start, declconv(d)+" not referenced");
Dglobal =>
if(superwarn && !d.refs && d.sym != nil && d.sym.name[0] != '.')
warn(d.src.start, declconv(d)+" not referenced");
Dlocal or
Darg =>
if(!d.refs && d.sym != nil && d.sym.name != nil && d.sym.name[0] != '.')
warn(d.src.start, declconv(d)+" not referenced");
Dconst =>
if(superwarn && !d.refs && d.sym != nil)
warn(d.src.start, declconv(d)+" not referenced");
Dfn =>
if(d.init == nil && d.importid == nil)
error(d.src.start, declconv(d)+" not defined");
if(superwarn && !d.refs)
warn(d.src.start, declconv(d)+" not referenced");
Dimport =>
if(superwarn && !d.refs)
warn(d.src.start, declconv(d)+" not referenced");
}
if(d.das != byte 0)
d.refs++;
}
}
vardecl(ids: ref Decl, t: ref Type): ref Node
{
n := mkn(Ovardecl, mkn(Oseq, nil, nil), nil);
n.decl = ids;
n.ty = t;
return n;
}
vardecled(n: ref Node)
{
store := Dlocal;
if(scope == ScopeGlobal)
store = Dglobal;
if(n.ty.kind == Texception && n.ty.cons == byte 1){
store = Dconst;
fatal("Texception in vardecled");
}
ids := n.decl;
installids(store, ids);
t := n.ty;
for(last := ids; ids != nil; ids = ids.next){
ids.ty = t;
last = ids;
}
n.left.decl = last;
}
condecl(ids: ref Decl, init: ref Node): ref Node
{
n := mkn(Ocondecl, mkn(Oseq, nil, nil), init);
n.decl = ids;
return n;
}
condecled(n: ref Node)
{
ids := n.decl;
installids(Dconst, ids);
for(last := ids; ids != nil; ids = ids.next){
ids.ty = tunknown;
last = ids;
}
n.left.decl = last;
}
exdecl(ids: ref Decl, tids: ref Decl): ref Node
{
n: ref Node;
t: ref Type;
t = mktype(ids.src.start, ids.src.stop, Texception, nil, tids);
t.cons = byte 1;
n = mkn(Oexdecl, mkn(Oseq, nil, nil), nil);
n.decl = ids;
n.ty = t;
return n;
}
exdecled(n: ref Node)
{
ids, last: ref Decl;
t: ref Type;
ids = n.decl;
installids(Dconst, ids);
t = n.ty;
for(last = ids; ids != nil; ids = ids.next){
ids.ty = t;
last = ids;
}
n.left.decl = last;
}
importdecl(m: ref Node, ids: ref Decl): ref Node
{
n := mkn(Oimport, mkn(Oseq, nil, nil), m);
n.decl = ids;
return n;
}
importdecled(n: ref Node)
{
ids := n.decl;
installids(Dimport, ids);
for(last := ids; ids != nil; ids = ids.next){
ids.ty = tunknown;
last = ids;
}
n.left.decl = last;
}
mkscope(body: ref Node): ref Node
{
n := mkn(Oscope, nil, body);
if(body != nil)
n.src = body.src;
return n;
}
fndecl(n: ref Node, t: ref Type, body: ref Node): ref Node
{
n = mkbin(Ofunc, n, body);
n.ty = t;
return n;
}
fndecled(n: ref Node)
{
left := n.left;
if(left.op == Oname){
d := left.decl.sym.decl;
if(d == nil || d.store == Dimport){
d = mkids(left.src, left.decl.sym, n.ty, nil);
installids(Dfn, d);
}
left.decl = d;
d.refs++;
}
if(left.op == Odot)
pushscope(nil, Sother);
if(n.ty.polys != nil){
pushscope(nil, Sother);
installids(Dtype, n.ty.polys);
}
pushscope(nil, Sother);
installids(Darg, n.ty.ids);
n.ty.ids = popscope();
if(n.ty.val != nil)
mergepolydecs(n.ty);
if(n.ty.polys != nil)
n.ty.polys = popscope();
if(left.op == Odot)
popscope();
}
#
# check the function declaration only
# the body will be type checked later by fncheck
#
fnchk(n: ref Node): ref Decl
{
bad := 0;
d := n.left.decl;
if(n.left.op == Odot)
d = n.left.right.decl;
if(d == nil)
fatal("decl() fnchk nil");
n.left.decl = d;
if(d.store == Dglobal || d.store == Dfield)
d.store = Dfn;
if(d.store != Dfn || d.init != nil){
nerror(n, "redeclaration of function "+dotconv(d)+", previously declared as "
+storeconv(d)+" on line "+lineconv(d.src.start));
if(d.store == Dfn && d.init != nil)
bad = 1;
}
d.init = n;
t := n.ty;
inadt := d.dot;
if(inadt != nil && (inadt.store != Dtype || inadt.ty.kind != Tadt))
inadt = nil;
if(n.left.op == Odot){
pushscope(nil, Sother);
adtp := outerpolys(n.left);
if(adtp != nil)
installids(Dtype, adtp);
if(!polyequal(adtp, n.decl))
nerror(n, "adt polymorphic type mismatch");
n.decl = nil;
}
t = validtype(t, inadt);
if(n.left.op == Odot)
popscope();
if(debug['d'])
print("declare function %s ty %s newty %s\n", dotconv(d), typeconv(d.ty), typeconv(t));
t = usetype(t);
if(!polyequal(d.ty.polys, t.polys))
nerror(n, "function polymorphic type mismatch");
if(!tcompat(d.ty, t, 0))
nerror(n, "type mismatch: "+dotconv(d)+" defined as "
+typeconv(t)+" declared as "+typeconv(d.ty)+" on line "+lineconv(d.src.start));
else if(!raisescompat(d.ty.eraises, t.eraises))
nerror(n, "raises mismatch: " + dotconv(d));
if(t.varargs != byte 0)
nerror(n, "cannot define functions with a '*' argument, such as "+dotconv(d));
t.eraises = d.ty.eraises;
d.ty = t;
d.offset = idoffsets(t.ids, MaxTemp, IBY2WD);
d.src = n.src;
d.locals = nil;
n.ty = t;
if(bad)
return nil;
return d;
}
globalas(dst: ref Node, v: ref Node, valok: int): ref Node
{
if(v == nil)
return nil;
if(v.op == Oas || v.op == Odas){
v = globalas(v.left, v.right, valok);
if(v == nil)
return nil;
}else if(valok && !initable(dst, v, 0))
return nil;
case dst.op{
Oname =>
if(dst.decl.init != nil)
nerror(dst, "duplicate assignment to "+expconv(dst)+", previously assigned on line "
+lineconv(dst.decl.init.src.start));
if(valok)
dst.decl.init = v;
return v;
Otuple =>
if(valok && v.op != Otuple)
fatal("can't deal with "+nodeconv(v)+" in tuple case of globalas");
tv := v.left;
for(dst = dst.left; dst != nil; dst = dst.right){
globalas(dst.left, tv.left, valok);
if(valok)
tv = tv.right;
}
return v;
}
fatal("can't deal with "+nodeconv(dst)+" in globalas");
return nil;
}
needsstore(d: ref Decl): int
{
if(!d.refs)
return 0;
if(d.importid != nil)
return 0;
if(storespace[d.store])
return 1;
return 0;
}
#
# return the list of all referenced storage variables
#
vars(d: ref Decl): ref Decl
{
while(d != nil && !needsstore(d))
d = d.next;
for(v := d; v != nil; v = v.next){
while(v.next != nil){
n := v.next;
if(needsstore(n))
break;
v.next = n.next;
}
}
return d;
}
#
# declare variables from the left side of a := statement
#
recdasdecl(n: ref Node, store: int, nid: int): (int, int)
{
r: int;
case n.op{
Otuple =>
ok := 1;
for(n = n.left; n != nil; n = n.right){
(r, nid) = recdasdecl(n.left, store, nid);
ok &= r;
}
return (ok, nid);
Oname =>
if(n.decl == nildecl)
return (1, -1);
d := mkids(n.src, n.decl.sym, nil, nil);
installids(store, d);
n.decl = d;
old := d.old;
if(old != nil
&& old.store != Dfn
&& old.store != Dwundef
&& old.store != Dundef)
warn(d.src.start, "redeclaration of "+declconv(d)+", previously declared as "
+storeconv(old)+" on line "+lineconv(old.src.start));
d.refs++;
d.das = byte 1;
if(nid >= 0)
nid++;
return (1, nid);
}
return (0, nid);
}
recmark(n: ref Node, nid: int): int
{
case(n.op){
Otuple =>
for(n = n.left; n != nil; n = n.right)
nid = recmark(n.left, nid);
Oname =>
n.decl.nid = byte nid;
nid = 0;
}
return nid;
}
dasdecl(n: ref Node): int
{
ok: int;
nid := 0;
store := Dlocal;
if(scope == ScopeGlobal)
store = Dglobal;
(ok, nid) = recdasdecl(n, store, nid);
if(!ok)
nerror(n, "illegal declaration expression "+expconv(n));
if(ok && store == Dlocal && nid > 1)
recmark(n, nid);
return ok;
}
#
# declare global variables in nested := expressions
#
gdasdecl(n: ref Node)
{
if(n == nil)
return;
if(n.op == Odas){
gdasdecl(n.right);
dasdecl(n.left);
}else{
gdasdecl(n.left);
gdasdecl(n.right);
}
}
undefed(src: Src, s: ref Sym): ref Decl
{
d := mkids(src, s, tnone, nil);
error(src.start, s.name+" is not declared");
installids(Dwundef, d);
return d;
}
# inloop() : int
# {
# for (i := scope; i > 0; i--)
# if (int scopekind[i] == Sloop)
# return 1;
# return 0;
# }
nested() : int
{
for (i := scope; i > 0; i--)
if (int scopekind[i] == Sscope || int scopekind[i] == Sloop)
return 1;
return 0;
}
decltozero(n : ref Node)
{
if ((scop := scopenode[scope]) != nil) {
if (n.right != nil && errors == 0)
fatal("Ovardecl/Oname/Otuple has right field\n");
n.right = scop.left;
scop.left = n;
}
}
pushscope(scp : ref Node, kind : int)
{
if(scope >= MaxScope)
fatal("scope too deep");
scope++;
scopes[scope] = nil;
tails[scope] = nil;
scopenode[scope] = scp;
scopekind[scope] = byte kind;
}
curscope(): ref Decl
{
return scopes[scope];
}
#
# revert to old declarations for each symbol in the currect scope.
# remove the effects of any imported adt types
# whenever the adt is imported from a module,
# we record in the type's decl the module to use
# when calling members. the process is reversed here.
#
popscope(): ref Decl
{
for(id := scopes[scope]; id != nil; id = id.next){
if(id.sym != nil){
id.sym.decl = id.old;
id.old = nil;
}
if(id.importid != nil)
id.importid.refs += id.refs;
t := id.ty;
if(id.store == Dtype
&& t.decl != nil
&& t.decl.timport == id)
t.decl.timport = id.timport;
if(id.store == Dlocal)
freeloc(id);
}
return scopes[scope--];
}
#
# make a new scope,
# preinstalled with some previously installed identifiers
# don't add the identifiers to the scope chain,
# so they remain separate from any newly installed ids
#
# these routines assume no ids are imports
#
repushids(ids: ref Decl)
{
if(scope >= MaxScope)
fatal("scope too deep");
scope++;
scopes[scope] = nil;
tails[scope] = nil;
scopenode[scope] = nil;
scopekind[scope] = byte Sother;
for(; ids != nil; ids = ids.next){
if(ids.scope != scope
&& (ids.dot == nil || !isimpmod(ids.dot.sym)
|| ids.scope != ScopeGlobal || scope != ScopeGlobal + 1))
fatal("repushids scope mismatch");
s := ids.sym;
if(s != nil && ids.store != Dtag){
if(s.decl != nil && s.decl.scope >= scope)
ids.old = s.decl.old;
else
ids.old = s.decl;
s.decl = ids;
}
}
}
#
# pop a scope which was started with repushids
# return any newly installed ids
#
popids(ids: ref Decl): ref Decl
{
for(; ids != nil; ids = ids.next){
if(ids.sym != nil && ids.store != Dtag){
ids.sym.decl = ids.old;
ids.old = nil;
}
}
return popscope();
}
installids(store: int, ids: ref Decl)
{
last : ref Decl = nil;
for(d := ids; d != nil; d = d.next){
d.scope = scope;
if(d.store == Dundef)
d.store = store;
s := d.sym;
if(s != nil){
if(s.decl != nil && s.decl.scope >= scope){
redecl(d);
d.old = s.decl.old;
}else
d.old = s.decl;
s.decl = d;
}
last = d;
}
if(ids != nil){
d = tails[scope];
if(d == nil)
scopes[scope] = ids;
else
d.next = ids;
tails[scope] = last;
}
}
lookup(sym: ref Sym): ref Decl
{
s: int;
d: ref Decl;
for(s = scope; s >= ScopeBuiltin; s--){
for(d = scopes[s]; d != nil; d = d.next){
if(d.sym == sym)
return d;
}
}
return nil;
}
mkids(src: Src, s: ref Sym, t: ref Type, next: ref Decl): ref Decl
{
d := ref zdecl;
d.src = src;
d.store = Dundef;
d.ty = t;
d.next = next;
d.sym = s;
d.nid = byte 1;
return d;
}
mkdecl(src: Src, store: int, t: ref Type): ref Decl
{
d := ref zdecl;
d.src = src;
d.store = store;
d.ty = t;
d.nid = byte 1;
return d;
}
dupdecl(old: ref Decl): ref Decl
{
d := ref *old;
d.next = nil;
return d;
}
dupdecls(old: ref Decl): ref Decl
{
d, nd, first, last: ref Decl;
first = last = nil;
for(d = old; d != nil; d = d.next){
nd = dupdecl(d);
if(first == nil)
first = nd;
else
last.next = nd;
last = nd;
}
return first;
}
appdecls(d: ref Decl, dd: ref Decl): ref Decl
{
if(d == nil)
return dd;
for(t := d; t.next != nil; t = t.next)
;
t.next = dd;
return d;
}
revids(id: ref Decl): ref Decl
{
next : ref Decl;
d : ref Decl = nil;
for(; id != nil; id = next){
next = id.next;
id.next = d;
d = id;
}
return d;
}
idoffsets(id: ref Decl, offset: int, al: int): int
{
algn := 1;
for(; id != nil; id = id.next){
if(storespace[id.store]){
usedty(id.ty);
if(id.store == Dlocal && id.link != nil){
# id.nid always 1
id.offset = id.link.offset;
continue;
}
a := id.ty.align;
if(id.nid > byte 1){
for(d := id.next; d != nil && d.nid == byte 0; d = d.next)
if(d.ty.align > a)
a = d.ty.align;
algn = a;
}
offset = align(offset, a);
id.offset = offset;
offset += id.ty.size;
if(id.nid == byte 0 && (id.next == nil || id.next.nid != byte 0))
offset = align(offset, algn);
}
}
return align(offset, al);
}
idindices(id: ref Decl): int
{
i := 0;
for(; id != nil; id = id.next){
if(storespace[id.store]){
usedty(id.ty);
id.offset = i++;
}
}
return i;
}
declconv(d: ref Decl): string
{
if(d.sym == nil)
return storename[d.store] + " " + "<???>";
return storename[d.store] + " " + d.sym.name;
}
storeconv(d: ref Decl): string
{
return storeart[d.store] + storename[d.store];
}
dotconv(d: ref Decl): string
{
s: string;
if(d.dot != nil && !isimpmod(d.dot.sym)){
s = dotconv(d.dot);
if(d.dot.ty != nil && d.dot.ty.kind == Tmodule)
s += ".";
else
s += ".";
}
s += d.sym.name;
return s;
}
#
# merge together two sorted lists, yielding a sorted list
#
namemerge(e, f: ref Decl): ref Decl
{
d := rock := ref Decl;
while(e != nil && f != nil){
if(e.sym.name <= f.sym.name){
d.next = e;
e = e.next;
}else{
d.next = f;
f = f.next;
}
d = d.next;
}
if(e != nil)
d.next = e;
else
d.next = f;
return rock.next;
}
#
# recursively split lists and remerge them after they are sorted
#
recnamesort(d: ref Decl, n: int): ref Decl
{
if(n <= 1)
return d;
m := n / 2 - 1;
dd := d;
for(i := 0; i < m; i++)
dd = dd.next;
r := dd.next;
dd.next = nil;
return namemerge(recnamesort(d, n / 2),
recnamesort(r, (n + 1) / 2));
}
#
# sort the ids by name
#
namesort(d: ref Decl): ref Decl
{
n := 0;
for(dd := d; dd != nil; dd = dd.next)
n++;
return recnamesort(d, n);
}
printdecls(d: ref Decl)
{
for(; d != nil; d = d.next)
print("%d: %s %s ref %d\n", d.offset, declconv(d), typeconv(d.ty), d.refs);
}
mergepolydecs(t: ref Type)
{
n, nn: ref Node;
id, ids, ids1: ref Decl;
for(n = t.val; n != nil; n = n.right){
nn = n.left;
for(ids = nn.decl; ids != nil; ids = ids.next){
id = ids.sym.decl;
if(id == nil){
undefed(ids.src, ids.sym);
break;
}
if(id.store != Dtype){
error(ids.src.start, declconv(id) + " is not a type");
break;
}
if(id.ty.kind != Tpoly){
error(ids.src.start, declconv(id) + " is not a polymorphic type");
break;
}
if(id.ty.ids != nil)
error(ids.src.start, declconv(id) + " redefined");
pushscope(nil, Sother);
fielddecled(nn.left);
id.ty.ids = popscope();
for(ids1 = id.ty.ids; ids1 != nil; ids1 = ids1.next){
ids1.dot = id;
bindtypes(ids1.ty);
if(ids1.ty.kind != Tfn){
error(ids1.src.start, "only function types expected");
id.ty.ids = nil;
}
}
}
}
t.val = nil;
}
adjfnptrs(d: ref Decl, polys1: ref Decl, polys2: ref Decl)
{
n: int;
id, idt, idf, arg: ref Decl;
n = 0;
for(id = d.ty.ids; id != nil; id = id.next)
n++;
for(idt = polys1; idt != nil; idt = idt.next)
for(idf = idt.ty.ids; idf != nil; idf = idf.next)
n -= 2;
for(idt = polys2; idt != nil; idt = idt.next)
for(idf = idt.ty.ids; idf != nil; idf = idf.next)
n -= 2;
for(arg = d.ty.ids; --n >= 0; arg = arg.next)
;
for(idt = polys1; idt != nil; idt = idt.next){
for(idf = idt.ty.ids; idf != nil; idf = idf.next){
idf.link = arg;
arg = arg.next.next;
}
}
for(idt = polys2; idt != nil; idt = idt.next){
for(idf = idt.ty.ids; idf != nil; idf = idf.next){
idf.link = arg;
arg = arg.next.next;
}
}
}
addptrs(polys: ref Decl, fps: ref Decl, last: ref Decl, link: int, src: Src): (ref Decl, ref Decl)
{
for(idt := polys; idt != nil; idt = idt.next){
for(idf := idt.ty.ids; idf != nil; idf = idf.next){
fp := mkdecl(src, Darg, tany);
fp.sym = idf.sym;
if(link)
idf.link = fp;
if(fps == nil)
fps = fp;
else
last.next = fp;
last = fp;
fp = mkdecl(src, Darg, tint);
fp.sym = idf.sym;
last.next = fp;
last = fp;
}
}
return (fps, last);
}
addfnptrs(d: ref Decl, link: int)
{
fps, last, polys: ref Decl;
polys = encpolys(d);
if(int(d.ty.flags&FULLARGS)){
if(link)
adjfnptrs(d, d.ty.polys, polys);
return;
}
d.ty.flags |= FULLARGS;
fps = last = nil;
(fps, last) = addptrs(d.ty.polys, fps, last, link, d.src);
(fps, last) = addptrs(polys, fps, last, link, d.src);
for(last = d.ty.ids; last != nil && last.next != nil; last = last.next)
;
if(last != nil)
last.next = fps;
else
d.ty.ids = fps;
d.offset = idoffsets(d.ty.ids, MaxTemp, IBY2WD);
}
rmfnptrs(d: ref Decl)
{
n: int;
id, idt, idf: ref Decl;
if(int(d.ty.flags&FULLARGS))
d.ty.flags &= ~FULLARGS;
else
return;
n = 0;
for(id = d.ty.ids; id != nil; id = id.next)
n++;
for(idt = d.ty.polys; idt != nil; idt = idt.next)
for(idf = idt.ty.ids; idf != nil; idf = idf.next)
n -= 2;
for(idt = encpolys(d); idt != nil; idt = idt.next)
for(idf = idt.ty.ids; idf != nil; idf = idf.next)
n -= 2;
if(n == 0){
d.ty.ids = nil;
return;
}
for(id = d.ty.ids; --n > 0; id = id.next)
;
id.next = nil;
d.offset = idoffsets(d.ty.ids, MaxTemp, IBY2WD);
}
local(d: ref Decl): int
{
for(d = d.dot; d != nil; d = d.dot)
if(d.store == Dtype && d.ty.kind == Tmodule)
return 0;
return 1;
}
lmodule(d: ref Decl): ref Decl
{
for(d = d.dot; d != nil; d = d.dot)
if(d.store == Dtype && d.ty.kind == Tmodule)
return d;
return nil;
}
outerpolys(n: ref Node): ref Decl
{
d: ref Decl;
if(n.op == Odot){
d = n.right.decl;
if(d == nil)
fatal("decl() outeradt nil");
d = d.dot;
if(d != nil && d.store == Dtype && d.ty.kind == Tadt)
return d.ty.polys;
}
return nil;
}
encpolys(d: ref Decl): ref Decl
{
if((d = d.dot) == nil)
return nil;
return d.ty.polys;
}
fnlookup(s: ref Sym, t: ref Type): (ref Decl, ref Node)
{
id: ref Decl;
mod: ref Node;
id = nil;
mod = nil;
if(t.kind == Tpoly || t.kind == Tmodule)
id = namedot(t.ids, s);
else if(t.kind == Tref){
t = t.tof;
if(t.kind == Tadt){
id = namedot(t.ids, s);
if(t.decl != nil && t.decl.timport != nil)
mod = t.decl.timport.eimport;
}
else if(t.kind == Tadtpick){
id = namedot(t.ids, s);
if(t.decl != nil && t.decl.timport != nil)
mod = t.decl.timport.eimport;
t = t.decl.dot.ty;
if(id == nil)
id = namedot(t.ids, s);
if(t.decl != nil && t.decl.timport != nil)
mod = t.decl.timport.eimport;
}
}
if(id == nil){
id = lookup(s);
if(id != nil)
mod = id.eimport;
}
return (id, mod);
}
isimpmod(s: ref Sym): int
{
d: ref Decl;
for(d = impmods; d != nil; d = d.next)
if(d.sym == s)
return 1;
return 0;
}
dequal(d1: ref Decl, d2: ref Decl, full: int): int
{
return d1.sym == d2.sym &&
d1.store == d2.store &&
d1.implicit == d2.implicit &&
d1.cyc == d2.cyc &&
(!full || tequal(d1.ty, d2.ty)) &&
(!full || d1.store == Dfn || sametree(d1.init, d2.init));
}
tzero(t: ref Type): int
{
return t.kind == Texception || tmustzero(t);
}
isptr(t: ref Type): int
{
return t.kind == Texception || tattr[t.kind].isptr;
}
# can d share the same stack location as another local ?
shareloc(d: ref Decl)
{
z: int;
t, tt: ref Type;
dd, res: ref Decl;
if(d.store != Dlocal || d.nid != byte 1)
return;
t = d.ty;
res = nil;
for(dd = fndecls; dd != nil; dd = dd.next){
if(d == dd)
fatal("d==dd in shareloc");
if(dd.store != Dlocal || dd.nid != byte 1 || dd.link != nil || dd.tref != 0)
continue;
tt = dd.ty;
if(t.size != tt.size || t.align != tt.align)
continue;
z = tzero(t)+tzero(tt);
if(z > 0)
continue; # for now
if(t == tt || tequal(t, tt))
res = dd;
else{
if(z == 1)
continue;
if(z == 0 || isptr(t) || isptr(tt) || mktdesc(t) == mktdesc(tt))
res = dd;
}
if(res != nil){
d.link = res;
res.tref = 1;
return;
}
}
return;
}
freeloc(d: ref Decl)
{
if(d.link != nil)
d.link.tref = 0;
}