ref: 4bc20df7142ce5e02c7fb49a33eefdc7715ff726
dir: /limbo/decls.c/
#include "limbo.h"
char *storename[Dend]=
{
/* 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",
};
char *storeart[Dend] =
{
/* Dtype */ "a ",
/* Dfn */ "a ",
/* Dglobal */ "a ",
/* Darg */ "an ",
/* Dlocal */ "a ",
/* Dconst */ "a ",
/* Dfield */ "a ",
/* Dtag */ "a",
/* Dimport */ "an ",
/* Dunbound */ "",
/* Dundef */ "",
/* Dwundef */ "",
};
int storespace[Dend] =
{
/* Dtype */ 0,
/* Dfn */ 0,
/* Dglobal */ 1,
/* Darg */ 1,
/* Dlocal */ 1,
/* Dconst */ 0,
/* Dfield */ 1,
/* Dtag */ 0,
/* Dimport */ 0,
/* Dunbound */ 0,
/* Dundef */ 0,
/* Dwundef */ 0,
};
static Decl *scopes[MaxScope];
static Decl *tails[MaxScope];
static Node *scopenode[MaxScope];
static uchar scopekind[MaxScope];
static void freeloc(Decl*);
void
popscopes(void)
{
Decl *d;
Dlist *id;
/*
* 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;
}
void
declstart(void)
{
Decl *d;
iota = mkids(&nosrc, enter("iota", 0), tint, nil);
iota->init = mkconst(&nosrc, 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 = enter("", 0);
installids(Dglobal, d);
scope = ScopeGlobal;
scopes[ScopeGlobal] = nil;
tails[ScopeGlobal] = nil;
}
void
redecl(Decl *d)
{
Decl *old;
old = d->sym->decl;
if(old->store == Dwundef)
return;
error(d->src.start, "redeclaration of %K, previously declared as %k on line %L",
d, old, old->src.start);
}
void
checkrefs(Decl *d)
{
Decl *id, *m;
long refs;
for(; d != nil; d = d->next){
if(d->das)
d->refs--;
switch(d->store){
case 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 %s.%s not defined", d->sym->name, id->sym->name);
if(superwarn && !id->refs && d->importid == nil)
warn(d->src.start, "function %s.%s not referenced", d->sym->name, id->sym->name);
}
}
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, "%K not referenced", d);
break;
case Dglobal:
if(!superwarn)
break;
case Dlocal:
case Darg:
if(!d->refs && d->sym != nil
&& d->sym->name != nil && d->sym->name[0] != '.')
warn(d->src.start, "%K not referenced", d);
break;
case Dconst:
if(superwarn && !d->refs && d->sym != nil)
warn(d->src.start, "%K not referenced", d);
if(d->ty == tstring && d->init != nil)
d->init->decl->refs += d->refs;
break;
case Dfn:
if(d->init == nil && d->importid == nil)
error(d->src.start, "%K not defined", d);
if(superwarn && !d->refs)
warn(d->src.start, "%K not referenced", d);
break;
case Dimport:
if(superwarn && !d->refs)
warn(d->src.start, "%K not referenced", d);
break;
}
if(d->das)
d->refs++;
}
}
Node*
vardecl(Decl *ids, Type *t)
{
Node *n;
n = mkn(Ovardecl, mkn(Oseq, nil, nil), nil);
n->decl = ids;
n->ty = t;
return n;
}
void
vardecled(Node *n)
{
Decl *ids, *last;
Type *t;
int store;
store = Dlocal;
if(scope == ScopeGlobal)
store = Dglobal;
if(n->ty->kind == Texception && n->ty->cons){
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;
}
Node*
condecl(Decl *ids, Node *init)
{
Node *n;
n = mkn(Ocondecl, mkn(Oseq, nil, nil), init);
n->decl = ids;
return n;
}
void
condecled(Node *n)
{
Decl *ids, *last;
ids = n->decl;
installids(Dconst, ids);
for(last = ids; ids != nil; ids = ids->next){
ids->ty = tunknown;
last = ids;
}
n->left->decl = last;
}
Node*
exdecl(Decl *ids, Decl *tids)
{
Node *n;
Type *t;
t = mktype(&ids->src.start, &ids->src.stop, Texception, nil, tids);
t->cons = 1;
n = mkn(Oexdecl, mkn(Oseq, nil, nil), nil);
n->decl = ids;
n->ty = t;
return n;
}
void
exdecled(Node *n)
{
Decl *ids, *last;
Type *t;
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;
}
Node*
importdecl(Node *m, Decl *ids)
{
Node *n;
n = mkn(Oimport, mkn(Oseq, nil, nil), m);
n->decl = ids;
return n;
}
void
importdecled(Node *n)
{
Decl *ids, *last;
ids = n->decl;
installids(Dimport, ids);
for(last = ids; ids != nil; ids = ids->next){
ids->ty = tunknown;
last = ids;
}
n->left->decl = last;
}
Node*
mkscope(Node *body)
{
Node *n;
n = mkn(Oscope, nil, body);
if(body != nil)
n->src = body->src;
return n;
}
Node*
fndecl(Node *n, Type *t, Node *body)
{
n = mkbin(Ofunc, n, body);
n->ty = t;
return n;
}
void
fndecled(Node *n)
{
Decl *d;
Node *left;
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
*/
Decl *
fnchk(Node *n)
{
int bad;
Decl *d, *inadt, *adtp;
Type *t;
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 %D, previously declared as %k on line %L",
d, d, 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 %D ty %T newty %T\n", d, d->ty, 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: %D defined as %T declared as %T on line %L",
d, t, d->ty, d->src.start);
else if(!raisescompat(d->ty->u.eraises, t->u.eraises))
nerror(n, "raises mismatch: %D", d);
if(t->varargs != 0)
nerror(n, "cannot define functions with a '*' argument, such as %D", d);
t->u.eraises = d->ty->u.eraises;
d->ty = t;
d->offset = idoffsets(t->ids, MaxTemp, IBY2WD);
d->src = n->src;
d->locals = nil;
n->ty = t;
return bad ? nil: d;
}
Node*
globalas(Node *dst, Node *v, int valok)
{
Node *tv;
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;
switch(dst->op){
case Oname:
if(dst->decl->init != nil)
nerror(dst, "duplicate assignment to %V, previously assigned on line %L",
dst, dst->decl->init->src.start);
if(valok)
dst->decl->init = v;
return v;
case Otuple:
if(valok && v->op != Otuple)
fatal("can't deal with %n in tuple case of globalas", v);
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 %n in globalas", dst);
return nil;
}
int
needsstore(Decl *d)
{
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
*/
Decl*
vars(Decl *d)
{
Decl *v, *n;
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
*/
static int
recdasdecl(Node *n, int store, int *nid)
{
Decl *d, *old;
int ok;
switch(n->op){
case Otuple:
ok = 1;
for(n = n->left; n != nil; n = n->right)
ok &= recdasdecl(n->left, store, nid);
return ok;
case Oname:
if(n->decl == nildecl){
*nid = -1;
return 1;
}
d = mkids(&n->src, n->decl->sym, nil, nil);
installids(store, d);
old = d->old;
if(old != nil
&& old->store != Dfn
&& old->store != Dwundef
&& old->store != Dundef)
warn(d->src.start, "redeclaration of %K, previously declared as %k on line %L",
d, old, old->src.start);
n->decl = d;
d->refs++;
d->das = 1;
if(*nid >= 0)
(*nid)++;
return 1;
}
return 0;
}
static int
recmark(Node *n, int nid)
{
switch(n->op){
case Otuple:
for(n = n->left; n != nil; n = n->right)
nid = recmark(n->left, nid);
break;
case Oname:
n->decl->nid = nid;
nid = 0;
break;
}
return nid;
}
int
dasdecl(Node *n)
{
int store, ok, nid;
nid = 0;
if(scope == ScopeGlobal)
store = Dglobal;
else
store = Dlocal;
ok = recdasdecl(n, store, &nid);
if(!ok)
nerror(n, "illegal declaration expression %V", n);
if(ok && store == Dlocal && nid > 1)
recmark(n, nid);
return ok;
}
/*
* declare global variables in nested := expressions
*/
void
gdasdecl(Node *n)
{
if(n == nil)
return;
if(n->op == Odas){
gdasdecl(n->right);
dasdecl(n->left);
}else{
gdasdecl(n->left);
gdasdecl(n->right);
}
}
Decl*
undefed(Src *src, Sym *s)
{
Decl *d;
d = mkids(src, s, tnone, nil);
error(src->start, "%s is not declared", s->name);
installids(Dwundef, d);
return d;
}
/*
int
inloop()
{
int i;
for (i = scope; i > 0; i--)
if (scopekind[i] == Sloop)
return 1;
return 0;
}
*/
int
nested()
{
int i;
for (i = scope; i > 0; i--)
if (scopekind[i] == Sscope || scopekind[i] == Sloop)
return 1;
return 0;
}
void
decltozero(Node *n)
{
Node *scp;
if ((scp = scopenode[scope]) != nil) {
/* can happen if we do
* x[i] := ......
* which is an error
*/
if (n->right != nil && errors == 0)
fatal("Ovardecl/Oname/Otuple has right field\n");
n->right = scp->left;
scp->left = n;
}
}
void
pushscope(Node *scp, int kind)
{
if(scope >= MaxScope)
fatal("scope too deep");
scope++;
scopes[scope] = nil;
tails[scope] = nil;
scopenode[scope] = scp;
scopekind[scope] = kind;
}
Decl*
curscope(void)
{
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.
*/
Decl*
popscope(void)
{
Decl *id;
Type *t;
if (debug['X'])
print("popscope\n");
for(id = scopes[scope]; id != nil; id = id->next){
if(id->sym != nil){
if (debug['X'])
print("%s : %s %d\n", id->sym->name, kindname[id->ty->kind], id->init != nil ? id->init->op : 0);
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
*/
void
repushids(Decl *ids)
{
Sym *s;
if(scope >= MaxScope)
fatal("scope too deep");
scope++;
scopes[scope] = nil;
tails[scope] = nil;
scopenode[scope] = nil;
scopekind[scope] = 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
*/
Decl*
popids(Decl *ids)
{
for(; ids != nil; ids = ids->next){
if(ids->sym != nil && ids->store != Dtag){
ids->sym->decl = ids->old;
ids->old = nil;
}
}
return popscope();
}
void
installids(int store, Decl *ids)
{
Decl *d, *last;
Sym *s;
last = 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;
}
}
Decl*
lookup(Sym *sym)
{
int s;
Decl *d;
for(s = scope; s >= ScopeBuiltin; s--){
for(d = scopes[s]; d != nil; d = d->next){
if(d->sym == sym)
return d;
}
}
return nil;
}
Decl*
mkids(Src *src, Sym *s, Type *t, Decl *next)
{
Decl *d;
d = mkdecl(src, Dundef, t);
d->next = next;
d->sym = s;
return d;
}
Decl*
mkdecl(Src *src, int store, Type *t)
{
Decl *d;
static Decl z;
d = allocmem(sizeof *d);
*d = z;
d->src = *src;
d->store = store;
d->ty = t;
d->nid = 1;
return d;
}
Decl*
dupdecl(Decl *old)
{
Decl *d;
d = allocmem(sizeof *d);
*d = *old;
d->next = nil;
return d;
}
Decl*
dupdecls(Decl *old)
{
Decl *d, *nd, *first, *last;
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;
}
Decl*
appdecls(Decl *d, Decl *dd)
{
Decl *t;
if(d == nil)
return dd;
for(t = d; t->next != nil; t = t->next)
;
t->next = dd;
return d;
}
Decl*
revids(Decl *id)
{
Decl *d, *next;
d = nil;
for(; id != nil; id = next){
next = id->next;
id->next = d;
d = id;
}
return d;
}
long
idoffsets(Decl *id, long offset, int al)
{
int a, algn;
Decl *d;
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 > 1){
for(d = id->next; d != nil && d->nid == 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 == 0 && (id->next == nil || id->next->nid != 0))
offset = align(offset, algn);
}
}
return align(offset, al);
}
long
idindices(Decl *id)
{
int i;
i = 0;
for(; id != nil; id = id->next){
if(storespace[id->store]){
usedty(id->ty);
id->offset = i++;
}
}
return i;
}
int
declconv(Fmt *f)
{
Decl *d;
char buf[4096], *s;
d = va_arg(f->args, Decl*);
if(d->sym == nil)
s = "<nil>";
else
s = d->sym->name;
seprint(buf, buf+sizeof(buf), "%s %s", storename[d->store], s);
return fmtstrcpy(f, buf);
}
int
storeconv(Fmt *f)
{
Decl *d;
char buf[4096];
d = va_arg(f->args, Decl*);
seprint(buf, buf+sizeof(buf), "%s%s", storeart[d->store], storename[d->store]);
return fmtstrcpy(f, buf);
}
int
dotconv(Fmt *f)
{
Decl *d;
char buf[4096], *p, *s;
d = va_arg(f->args, Decl*);
buf[0] = 0;
p = buf;
if(d->dot != nil && !isimpmod(d->dot->sym)){
s = ".";
if(d->dot->ty != nil && d->dot->ty->kind == Tmodule)
s = "->";
p = seprint(buf, buf+sizeof(buf), "%D%s", d->dot, s);
}
seprint(p, buf+sizeof(buf), "%s", d->sym->name);
return fmtstrcpy(f, buf);
}
/*
* merge together two sorted lists, yielding a sorted list
*/
static Decl*
namemerge(Decl *e, Decl *f)
{
Decl rock, *d;
d = &rock;
while(e != nil && f != nil){
if(strcmp(e->sym->name, f->sym->name) <= 0){
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
*/
static Decl*
recnamesort(Decl *d, int n)
{
Decl *r, *dd;
int i, m;
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
*/
Decl*
namesort(Decl *d)
{
Decl *dd;
int n;
n = 0;
for(dd = d; dd != nil; dd = dd->next)
n++;
return recnamesort(d, n);
}
void
printdecls(Decl *d)
{
for(; d != nil; d = d->next)
print("%ld: %K %T ref %d\n", d->offset, d, d->ty, d->refs);
}
void
mergepolydecs(Type *t)
{
Node *n, *nn;
Decl *id, *ids, *ids1;
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, "%K is not a type", id);
break;
}
if(id->ty->kind != Tpoly){
error(ids->src.start, "%K is not a polymorphic type", id);
break;
}
if(id->ty->ids != nil)
error(ids->src.start, "%K redefined", id);
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;
}
static void
adjfnptrs(Decl *d, Decl *polys1, Decl *polys2)
{
int n;
Decl *id, *idt, *idf, *arg;
if(debug['U'])
print("adjnptrs %s\n", d->sym->name);
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;
}
}
}
static void
addptrs(Decl *polys, Decl** fps, Decl **last, int link, Src *src)
{
Decl *idt, *idf, *fp;
if(debug['U'])
print("addptrs\n");
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;
}
}
}
void
addfnptrs(Decl *d, int link)
{
Decl *fps, *last, *polys;
if(debug['U'])
print("addfnptrs %s %d\n", d->sym->name, link);
polys = encpolys(d);
if(d->ty->flags&FULLARGS){
if(link)
adjfnptrs(d, d->ty->polys, polys);
if(0 && debug['U']){
for(d = d->ty->ids; d != nil; d = d->next)
print("%s=%ld(%d) ", d->sym->name, d->offset, tattr[d->ty->kind].isptr);
print("\n");
}
return;
}
d->ty->flags |= FULLARGS;
fps = last = nil;
addptrs(d->ty->polys, &fps, &last, link, &d->src);
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);
if(0 && debug['U']){
for(d = d->ty->ids; d != nil; d = d->next)
print("%s=%ld(%d) ", d->sym->name, d->offset, tattr[d->ty->kind].isptr);
print("\n");
}
}
void
rmfnptrs(Decl *d)
{
int n;
Decl *id, *idt, *idf;
if(debug['U'])
print("rmfnptrs %s\n", d->sym->name);
if(!(d->ty->flags&FULLARGS))
return;
d->ty->flags &= ~FULLARGS;
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);
}
int
local(Decl *d)
{
for(d = d->dot; d != nil; d = d->dot)
if(d->store == Dtype && d->ty->kind == Tmodule)
return 0;
return 1;
}
Decl*
module(Decl *d)
{
for(d = d->dot; d != nil; d = d->dot)
if(d->store == Dtype && d->ty->kind == Tmodule)
return d;
return nil;
}
Decl*
outerpolys(Node *n)
{
Decl *d;
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;
}
Decl*
encpolys(Decl *d)
{
if((d = d->dot) == nil)
return nil;
return d->ty->polys;
}
Decl*
fnlookup(Sym *s, Type *t, Node **m)
{
Decl *id;
Node *mod;
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;
}
if(m != nil)
*m = mod;
return id;
}
int
isimpmod(Sym *s)
{
Decl *d;
for(d = impmods; d != nil; d = d->next)
if(d->sym == s)
return 1;
return 0;
}
int
dequal(Decl *d1, Decl *d2, int full)
{
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));
}
static int
tzero(Type *t)
{
return t->kind == Texception || tmustzero(t);
}
static int
isptr(Type *t)
{
return t->kind == Texception || tattr[t->kind].isptr;
}
/* can d share the same stack location as another local ? */
void
shareloc(Decl *d)
{
int z;
Type *t, *tt;
Decl *dd, *res;
if(d->store != Dlocal || d->nid != 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 != 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){
/* print("%L %K share %L %K\n", d->src.start, d, res->src.start, res); */
d->link = res;
res->tref = 1;
return;
}
}
return;
}
static void
freeloc(Decl *d)
{
if(d->link != nil)
d->link->tref = 0;
}