summaryrefslogtreecommitdiff
path: root/limbo/typecheck.c
diff options
context:
space:
mode:
Diffstat (limited to 'limbo/typecheck.c')
-rw-r--r--limbo/typecheck.c3635
1 files changed, 3635 insertions, 0 deletions
diff --git a/limbo/typecheck.c b/limbo/typecheck.c
new file mode 100644
index 00000000..827aa1e1
--- /dev/null
+++ b/limbo/typecheck.c
@@ -0,0 +1,3635 @@
+#include "limbo.h"
+#include "y.tab.h"
+
+Node **labstack;
+int labdep;
+static Node* inexcept;
+static Decl* fndec;
+
+void checkraises(Node *n);
+
+static void
+increfs(Decl *id)
+{
+ for( ; id != nil; id = id->link)
+ id->refs++;
+}
+
+static int
+fninline(Decl *d)
+{
+ Node *n, *left, *right;
+
+ left = right = nil;
+ n = d->init;
+ if(dontinline || d->caninline < 0 || d->locals != nil || ispoly(d) || n->ty->tof->kind == Tnone || nodes(n) >= 100)
+ return 0;
+ n = n->right;
+ if(n->op == Oseq && n->right == nil)
+ n = n->left;
+ /*
+ * inline
+ * (a) return e;
+ * (b) if(c) return e1; else return e2;
+ * (c) if(c) return e1; return e2;
+ */
+ switch(n->op){
+ case Oret:
+ break;
+ case Oif:
+ right = n->right;
+ if(right->right == nil || right->left->op != Oret || right->right->op != Oret || !tequal(right->left->left->ty, right->right->left->ty))
+ return 0;
+ break;
+ case Oseq:
+ left = n->left;
+ right = n->right;
+ if(left->op != Oif || left->right->right != nil || left->right->left->op != Oret || right->op != Oseq || right->right != nil || right->left->op != Oret || !tequal(left->right->left->left->ty, right->left->left->ty))
+ return 0;
+ break;
+ default:
+ return 0;
+ }
+ if(occurs(d, n) || hasasgns(n))
+ return 0;
+ if(n->op == Oseq){
+ left->right->right = right->left;
+ n = left;
+ right = n->right;
+ d->init->right->right = nil;
+ }
+ if(n->op == Oif){
+ n->ty = right->ty = right->left->left->ty;
+ right->left = right->left->left;
+ right->right = right->right->left;
+ d->init->right->left = mkunary(Oret, n);
+ }
+ return 1;
+}
+
+static int
+isfnrefty(Type *t)
+{
+ return t->kind == Tref && t->tof->kind == Tfn;
+}
+
+static int
+isfnref(Decl *d)
+{
+ switch(d->store){
+ case Dglobal:
+ case Darg:
+ case Dlocal:
+ case Dfield:
+ case Dimport:
+ return isfnrefty(d->ty);
+ }
+ return 0;
+}
+
+int
+argncompat(Node *n, Decl *f, Node *a)
+{
+ for(; a != nil; a = a->right){
+ if(f == nil){
+ nerror(n, "%V: too many function arguments", n->left);
+ return 0;
+ }
+ f = f->next;
+ }
+ if(f != nil){
+ nerror(n, "%V: too few function arguments", n->left);
+ return 0;
+ }
+ return 1;
+}
+
+static void
+rewind(Node *n)
+{
+ Node *r, *nn;
+
+ r = n;
+ nn = n->left;
+ for(n = n->right; n != nil; n = n->right){
+ if(n->right == nil){
+ r->left = nn;
+ r->right = n->left;
+ }
+ else
+ nn = mkbin(Oindex, nn, n->left);
+ }
+}
+
+static void
+ckmod(Node *n, Decl *id)
+{
+ Type *t;
+ Decl *d, *idc;
+ Node *mod;
+
+ if(id == nil)
+ fatal("can't find function: %n", n);
+ idc = nil;
+ mod = nil;
+ if(n->op == Oname){
+ idc = id;
+ mod = id->eimport;
+ }
+ else if(n->op == Omdot)
+ mod = n->left;
+ else if(n->op == Odot){
+ idc = id->dot;
+ t = n->left->ty;
+ if(t->kind == Tref)
+ t = t->tof;
+ if(t->kind == Tadtpick)
+ t = t->decl->dot->ty;
+ d = t->decl;
+ while(d != nil && d->link != nil)
+ d = d->link;
+ if(d != nil && d->timport != nil)
+ mod = d->timport->eimport;
+ n->right->left = mod;
+ }
+ if(mod != nil && mod->ty->kind != Tmodule){
+ nerror(n, "cannot use %V as a function reference", n);
+ return;
+ }
+ if(mod != nil){
+ if(valistype(mod)){
+ nerror(n, "cannot use %V as a function reference because %V is a module interface", n, mod);
+ return;
+ }
+ }else if(idc != nil && idc->dot != nil && !isimpmod(idc->dot->sym)){
+ nerror(n, "cannot use %V without importing %s from a variable", n, idc->sym->name);
+ return;
+ }
+ if(mod != nil)
+ modrefable(n->ty);
+}
+
+static void
+addref(Node *n)
+{
+ Node *nn;
+
+ nn = mkn(0, nil, nil);
+ *nn = *n;
+ n->op = Oref;
+ n->left = nn;
+ n->right = nil;
+ n->decl = nil;
+ n->ty = usetype(mktype(&n->src.start, &n->src.stop, Tref, nn->ty, nil));
+}
+
+static void
+fnref(Node *n, Decl *id)
+{
+ id->caninline = -1;
+ ckmod(n, id);
+ addref(n);
+ while(id->link != nil)
+ id = id->link;
+ if(ispoly(id) && encpolys(id) != nil)
+ nerror(n, "cannot have a polymorphic adt function reference %s", id->sym->name);
+}
+
+Decl*
+typecheck(int checkimp)
+{
+ Decl *entry, *m, *d;
+ Sym *s;
+ int i;
+
+ if(errors)
+ return nil;
+
+ /*
+ * generate the set of all functions
+ * compile one function at a time
+ */
+ gdecl(tree);
+ gbind(tree);
+ fns = allocmem(nfns * sizeof(Decl));
+ i = gcheck(tree, fns, 0);
+ if(i != nfns)
+ fatal("wrong number of functions found in gcheck");
+
+ maxlabdep = 0;
+ for(i = 0; i < nfns; i++){
+ d = fns[i];
+ if(d != nil)
+ fndec = d;
+ if(d != nil)
+ fncheck(d);
+ fndec = nil;
+ }
+
+ if(errors)
+ return nil;
+
+ entry = nil;
+ if(checkimp){
+ Decl *im;
+ Dlist *dm;
+
+ if(impmods == nil){
+ yyerror("no implementation module");
+ return nil;
+ }
+ for(im = impmods; im != nil; im = im->next){
+ for(dm = impdecls; dm != nil; dm = dm->next)
+ if(dm->d->sym == im->sym)
+ break;
+ if(dm == nil || dm->d->ty == nil){
+ yyerror("no definition for implementation module %s", im->sym->name);
+ return nil;
+ }
+ }
+
+ /*
+ * can't check the module spec until all types and imports are determined,
+ * which happens in scheck
+ */
+ for(dm = impdecls; dm != nil; dm = dm->next){
+ im = dm->d;
+ im->refs++;
+ im->ty = usetype(im->ty);
+ if(im->store != Dtype || im->ty->kind != Tmodule){
+ error(im->src.start, "cannot implement %K", im);
+ return nil;
+ }
+ }
+
+ /* now check any multiple implementations */
+ impdecl = modimp(impdecls, impmods);
+
+ s = enter("init", 0);
+ entry = nil;
+ for(dm = impdecls; dm != nil; dm = dm->next){
+ im = dm->d;
+ for(m = im->ty->ids; m != nil; m = m->next){
+ m->ty = usetype(m->ty);
+ m->refs++;
+
+ if(m->sym == s && m->ty->kind == Tfn && entry == nil)
+ entry = m;
+
+ if(m->store == Dglobal || m->store == Dfn)
+ modrefable(m->ty);
+
+ if(m->store == Dtype && m->ty->kind == Tadt){
+ for(d = m->ty->ids; d != nil; d = d->next){
+ d->ty = usetype(d->ty);
+ modrefable(d->ty);
+ d->refs++;
+ }
+ }
+ }
+ checkrefs(im->ty->ids);
+ }
+ }
+
+ if(errors)
+ return nil;
+ gsort(tree);
+ tree = nil;
+ return entry;
+}
+
+/*
+ * introduce all global declarations
+ * also adds all fields to adts and modules
+ * note the complications due to nested Odas expressions
+ */
+void
+gdecl(Node *n)
+{
+ for(;;){
+ if(n == nil)
+ return;
+ if(n->op != Oseq)
+ break;
+ gdecl(n->left);
+ n = n->right;
+ }
+ switch(n->op){
+ case Oimport:
+ importdecled(n);
+ gdasdecl(n->right);
+ break;
+ case Oadtdecl:
+ adtdecled(n);
+ break;
+ case Ocondecl:
+ condecled(n);
+ gdasdecl(n->right);
+ break;
+ case Oexdecl:
+ exdecled(n);
+ break;
+ case Omoddecl:
+ moddecled(n);
+ break;
+ case Otypedecl:
+ typedecled(n);
+ break;
+ case Ovardecl:
+ vardecled(n);
+ break;
+ case Ovardecli:
+ vardecled(n->left);
+ gdasdecl(n->right);
+ break;
+ case Ofunc:
+ fndecled(n);
+ break;
+ case Oas:
+ case Odas:
+ case Onothing:
+ gdasdecl(n);
+ break;
+ default:
+ fatal("can't deal with %O in gdecl", n->op);
+ }
+}
+
+/*
+ * bind all global type ids,
+ * including those nested inside modules
+ * this needs to be done, since we may use such
+ * a type later in a nested scope, so if we bound
+ * the type ids then, the type could get bound
+ * to a nested declaration
+ */
+void
+gbind(Node *n)
+{
+ Decl *d, *ids;
+
+ for(;;){
+ if(n == nil)
+ return;
+ if(n->op != Oseq)
+ break;
+ gbind(n->left);
+ n = n->right;
+ }
+ switch(n->op){
+ case Oas:
+ case Ocondecl:
+ case Odas:
+ case Oexdecl:
+ case Ofunc:
+ case Oimport:
+ case Onothing:
+ case Ovardecl:
+ case Ovardecli:
+ break;
+ case Ofielddecl:
+ bindtypes(n->decl->ty);
+ break;
+ case Otypedecl:
+ bindtypes(n->decl->ty);
+ if(n->left != nil)
+ gbind(n->left);
+ break;
+ case Opickdecl:
+ gbind(n->left);
+ d = n->right->left->decl;
+ bindtypes(d->ty);
+ repushids(d->ty->ids);
+ gbind(n->right->right);
+ /* get new ids for undefined types; propagate outwards */
+ ids = popids(d->ty->ids);
+ if(ids != nil)
+ installids(Dundef, ids);
+ break;
+ case Oadtdecl:
+ case Omoddecl:
+ bindtypes(n->ty);
+ if(n->ty->polys != nil)
+ repushids(n->ty->polys);
+ repushids(n->ty->ids);
+ gbind(n->left);
+ /* get new ids for undefined types; propagate outwards */
+ ids = popids(n->ty->ids);
+ if(ids != nil)
+ installids(Dundef, ids);
+ if(n->ty->polys != nil)
+ popids(n->ty->polys);
+ break;
+ default:
+ fatal("can't deal with %O in gbind", n->op);
+ }
+}
+
+/*
+ * check all of the > declarations
+ * bind all type ids referred to within types at the global level
+ * record decls for defined functions
+ */
+int
+gcheck(Node *n, Decl **fns, int nfns)
+{
+ Ok rok;
+ Decl *d;
+
+ for(;;){
+ if(n == nil)
+ return nfns;
+ if(n->op != Oseq)
+ break;
+ nfns = gcheck(n->left, fns, nfns);
+ n = n->right;
+ }
+
+ switch(n->op){
+ case Ofielddecl:
+ if(n->decl->ty->u.eraises)
+ raisescheck(n->decl->ty);
+ break;
+ case Onothing:
+ case Opickdecl:
+ break;
+ case Otypedecl:
+ tcycle(n->ty);
+ break;
+ case Oadtdecl:
+ case Omoddecl:
+ if(n->ty->polys != nil)
+ repushids(n->ty->polys);
+ repushids(n->ty->ids);
+ if(gcheck(n->left, nil, 0))
+ fatal("gcheck fn decls nested in modules or adts");
+ if(popids(n->ty->ids) != nil)
+ fatal("gcheck installs new ids in a module or adt");
+ if(n->ty->polys != nil)
+ popids(n->ty->polys);
+ break;
+ case Ovardecl:
+ varcheck(n, 1);
+ break;
+ case Ocondecl:
+ concheck(n, 1);
+ break;
+ case Oexdecl:
+ excheck(n, 1);
+ break;
+ case Oimport:
+ importcheck(n, 1);
+ break;
+ case Ovardecli:
+ varcheck(n->left, 1);
+ rok = echeck(n->right, 0, 1, nil);
+ if(rok.ok){
+ if(rok.allok)
+ n->right = fold(n->right);
+ globalas(n->right->left, n->right->right, rok.allok);
+ }
+ break;
+ case Oas:
+ case Odas:
+ rok = echeck(n, 0, 1, nil);
+ if(rok.ok){
+ if(rok.allok)
+ n = fold(n);
+ globalas(n->left, n->right, rok.allok);
+ }
+ break;
+ case Ofunc:
+ rok = echeck(n->left, 0, 1, n);
+ if(rok.ok && n->ty->u.eraises)
+ raisescheck(n->ty);
+ d = nil;
+ if(rok.ok)
+ d = fnchk(n);
+ fns[nfns++] = d;
+ break;
+ default:
+ fatal("can't deal with %O in gcheck", n->op);
+ }
+ return nfns;
+}
+
+/*
+ * check for unused expression results
+ * make sure the any calculated expression has
+ * a destination
+ */
+Node*
+checkused(Node *n)
+{
+ Type *t;
+ Node *nn;
+
+ /*
+ * only nil; and nil = nil; should have type tany
+ */
+ if(n->ty == tany){
+ if(n->op == Oname)
+ return n;
+ if(n->op == Oas)
+ return checkused(n->right);
+ fatal("line %L checkused %n", n->src.start, n);
+ }
+
+ if(n->op == Ocall && n->left->ty->kind == Tfn && n->left->ty->tof != tnone){
+ n = mkunary(Oused, n);
+ n->ty = n->left->ty;
+ return n;
+ }
+ if(n->op == Ocall && isfnrefty(n->left->ty)){
+ if(n->left->ty->tof->tof != tnone){
+ n = mkunary(Oused, n);
+ n->ty = n->left->ty;
+ }
+ return n;
+ }
+ if(isused[n->op] && (n->op != Ocall || n->left->ty->kind == Tfn))
+ return n;
+ t = n->ty;
+ if(t->kind == Tfn)
+ nerror(n, "function %V not called", n);
+ else if(t->kind == Tadt && t->tags != nil || t->kind == Tadtpick)
+ nerror(n, "expressions cannot have type %T", t);
+ else if(n->op == Otuple){
+ for(nn = n->left; nn != nil; nn = nn->right)
+ checkused(nn->left);
+ }
+ else
+ nwarn(n, "result of expression %V not used", n);
+ n = mkunary(Oused, n);
+ n->ty = n->left->ty;
+ return n;
+}
+
+void
+fncheck(Decl *d)
+{
+ Node *n;
+ Decl *adtp;
+
+ n = d->init;
+ if(debug['t'])
+ print("typecheck tree: %n\n", n);
+
+ fndecls = nil;
+ adtp = outerpolys(n->left);
+ if(n->left->op == Odot)
+ repushids(adtp);
+ if(d->ty->polys != nil)
+ repushids(d->ty->polys);
+ repushids(d->ty->ids);
+
+ labdep = 0;
+ labstack = allocmem(maxlabdep * sizeof *labstack);
+ n->right = scheck(n->right, d->ty->tof, Sother);
+ if(labdep != 0)
+ fatal("unbalanced label stack in fncheck");
+ free(labstack);
+
+ d->locals = appdecls(popids(d->ty->ids), fndecls);
+ if(d->ty->polys != nil)
+ popids(d->ty->polys);
+ if(n->left->op == Odot)
+ popids(adtp);
+ fndecls = nil;
+
+ checkrefs(d->ty->ids);
+ checkrefs(d->ty->polys);
+ checkrefs(d->locals);
+
+ checkraises(n);
+
+ d->caninline = fninline(d);
+}
+
+Node*
+scheck(Node *n, Type *ret, int kind)
+{
+ Node *left, *right, *last, *top;
+ Decl *d;
+ Sym *s;
+ Ok rok;
+ int i;
+
+ top = n;
+ last = nil;
+ for(; n != nil; n = n->right){
+ left = n->left;
+ right = n->right;
+ switch(n->op){
+ case Ovardecl:
+ vardecled(n);
+ varcheck(n, 0);
+ if (nested() && tmustzero(n->decl->ty))
+ decltozero(n);
+/*
+ else if (inloop() && tmustzero(n->decl->ty))
+ decltozero(n);
+*/
+ return top;
+ case Ovardecli:
+ vardecled(left);
+ varcheck(left, 0);
+ echeck(right, 0, 0, nil);
+ if (nested() && tmustzero(left->decl->ty))
+ decltozero(left);
+ return top;
+ case Otypedecl:
+ typedecled(n);
+ bindtypes(n->ty);
+ tcycle(n->ty);
+ return top;
+ case Ocondecl:
+ condecled(n);
+ concheck(n, 0);
+ return top;
+ case Oexdecl:
+ exdecled(n);
+ excheck(n, 0);
+ return top;
+ case Oimport:
+ importdecled(n);
+ importcheck(n, 0);
+ return top;
+ case Ofunc:
+ fatal("scheck func");
+ case Oscope:
+ pushscope(n, kind == Sother ? Sscope : kind);
+ if (left != nil)
+ fatal("Oscope has left field");
+ echeck(left, 0, 0, nil);
+ n->right = scheck(right, ret, Sother);
+ d = popscope();
+ fndecls = appdecls(fndecls, d);
+ return top;
+ case Olabel:
+ echeck(left, 0, 0, nil);
+ n->right = scheck(right, ret, Sother);
+ return top;
+ case Oseq:
+ n->left = scheck(left, ret, Sother);
+ /* next time will check n->right */
+ break;
+ case Oif:
+ rok = echeck(left, 0, 0, nil);
+ if(rok.ok && left->op != Onothing && left->ty != tint)
+ nerror(n, "if conditional must be an int, not %Q", left);
+ right->left = scheck(right->left, ret, Sother);
+ /* next time will check n->right->right */
+ n = right;
+ break;
+ case Ofor:
+ rok = echeck(left, 0, 0, nil);
+ if(rok.ok && left->op != Onothing && left->ty != tint)
+ nerror(n, "for conditional must be an int, not %Q", left);
+ /*
+ * do the continue clause before the body
+ * this reflects the ordering of declarations
+ */
+ pushlabel(n);
+ right->right = scheck(right->right, ret, Sother);
+ right->left = scheck(right->left, ret, Sloop);
+ labdep--;
+ if(n->decl != nil && !n->decl->refs)
+ nwarn(n, "label %s never referenced", n->decl->sym->name);
+ return top;
+ case Odo:
+ rok = echeck(left, 0, 0, nil);
+ if(rok.ok && left->op != Onothing && left->ty != tint)
+ nerror(n, "do conditional must be an int, not %Q", left);
+ pushlabel(n);
+ n->right = scheck(n->right, ret, Sloop);
+ labdep--;
+ if(n->decl != nil && !n->decl->refs)
+ nwarn(n, "label %s never referenced", n->decl->sym->name);
+ return top;
+ case Oalt:
+ case Ocase:
+ case Opick:
+ case Oexcept:
+ pushlabel(n);
+ switch(n->op){
+ case Oalt:
+ altcheck(n, ret);
+ break;
+ case Ocase:
+ casecheck(n, ret);
+ break;
+ case Opick:
+ pickcheck(n, ret);
+ break;
+ case Oexcept:
+ exccheck(n, ret);
+ break;
+ }
+ labdep--;
+ if(n->decl != nil && !n->decl->refs)
+ nwarn(n, "label %s never referenced", n->decl->sym->name);
+ return top;
+ case Oret:
+ rok = echeck(left, 0, 0, nil);
+ if(!rok.ok)
+ return top;
+ if(left == nil){
+ if(ret != tnone)
+ nerror(n, "return of nothing from a fn of %T", ret);
+ }else if(ret == tnone){
+ if(left->ty != tnone)
+ nerror(n, "return %Q from a fn with no return type", left);
+ }else if(!tcompat(ret, left->ty, 0))
+ nerror(n, "return %Q from a fn of %T", left, ret);
+ return top;
+ case Obreak:
+ case Ocont:
+ s = nil;
+ if(n->decl != nil)
+ s = n->decl->sym;
+ for(i = 0; i < labdep; i++){
+ if(s == nil || labstack[i]->decl != nil && labstack[i]->decl->sym == s){
+ if(n->op == Ocont
+ && labstack[i]->op != Ofor && labstack[i]->op != Odo)
+ continue;
+ if(s != nil)
+ labstack[i]->decl->refs++;
+ return top;
+ }
+ }
+ nerror(n, "no appropriate target for %V", n);
+ return top;
+ case Oexit:
+ case Onothing:
+ return top;
+ case Oexstmt:
+ fndec->handler = 1;
+ n->left = scheck(left, ret, Sother);
+ n->right = scheck(right, ret, Sother);
+ return top;
+ default:
+ rok = echeck(n, 0, 0, nil);
+ if(rok.allok)
+ n = checkused(n);
+ if(last == nil)
+ return n;
+ last->right = n;
+ return top;
+ }
+ last = n;
+ }
+ return top;
+}
+
+void
+pushlabel(Node *n)
+{
+ Sym *s;
+ int i;
+
+ if(labdep >= maxlabdep){
+ maxlabdep += MaxScope;
+ labstack = reallocmem(labstack, maxlabdep * sizeof *labstack);
+ }
+ if(n->decl != nil){
+ s = n->decl->sym;
+ n->decl->refs = 0;
+ for(i = 0; i < labdep; i++)
+ if(labstack[i]->decl != nil && labstack[i]->decl->sym == s)
+ nerror(n, "label %s duplicated on line %L", s->name, labstack[i]->decl->src.start);
+ }
+ labstack[labdep++] = n;
+}
+
+void
+varcheck(Node *n, int isglobal)
+{
+ Type *t;
+ Decl *ids, *last;
+
+ t = validtype(n->ty, nil);
+ t = topvartype(t, n->decl, isglobal, 0);
+ last = n->left->decl;
+ for(ids = n->decl; ids != last->next; ids = ids->next){
+ ids->ty = t;
+ shareloc(ids);
+ }
+ if(t->u.eraises)
+ raisescheck(t);
+}
+
+void
+concheck(Node *n, int isglobal)
+{
+ Decl *ids, *last;
+ Type *t;
+ Node *init;
+ Ok rok;
+ int i;
+
+ pushscope(nil, Sother);
+ installids(Dconst, iota);
+ rok = echeck(n->right, 0, isglobal, nil);
+ popscope();
+
+ init = n->right;
+ if(!rok.ok){
+ t = terror;
+ }else{
+ t = init->ty;
+ if(!tattr[t->kind].conable){
+ nerror(init, "cannot have a %T constant", t);
+ rok.allok = 0;
+ }
+ }
+
+ last = n->left->decl;
+ for(ids = n->decl; ids != last->next; ids = ids->next)
+ ids->ty = t;
+
+ if(!rok.allok)
+ return;
+
+ i = 0;
+ for(ids = n->decl; ids != last->next; ids = ids->next){
+ if(rok.ok){
+ iota->init->val = i;
+ ids->init = dupn(0, &nosrc, init);
+ if(!varcom(ids))
+ rok.ok = 0;
+ }
+ i++;
+ }
+}
+
+static char*
+exname(Decl *d)
+{
+ int n;
+ Sym *m;
+ char *s;
+ char buf[16];
+
+ n = 0;
+ sprint(buf, "%d", scope-ScopeGlobal);
+ m = impmods->sym;
+ if(d->dot)
+ m = d->dot->sym;
+ if(m)
+ n += strlen(m->name)+1;
+ if(fndec)
+ n += strlen(fndec->sym->name)+1;
+ n += strlen(buf)+1+strlen(d->sym->name)+1;
+ s = malloc(n);
+ strcpy(s, "");
+ if(m){
+ strcat(s, m->name);
+ strcat(s, ".");
+ }
+ if(fndec){
+ strcat(s, fndec->sym->name);
+ strcat(s, ".");
+ }
+ strcat(s, buf);
+ strcat(s, ".");
+ strcat(s, d->sym->name);
+ return s;
+}
+
+void
+excheck(Node *n, int isglobal)
+{
+ char *nm;
+ Type *t;
+ Decl *ids, *last;
+
+ t = validtype(n->ty, nil);
+ t = topvartype(t, n->decl, isglobal, 0);
+ last = n->left->decl;
+ for(ids = n->decl; ids != last->next; ids = ids->next){
+ ids->ty = t;
+ nm = exname(ids);
+ ids->init = mksconst(&n->src, enterstring(nm, strlen(nm)));
+ /* ids->init = mksconst(&n->src, enterstring(strdup(ids->sym->name), strlen(ids->sym->name))); */
+ }
+}
+
+void
+importcheck(Node *n, int isglobal)
+{
+ Node *m;
+ Decl *id, *last, *v;
+ Type *t;
+ Ok rok;
+
+ rok = echeck(n->right, 1, isglobal, nil);
+ if(!rok.ok)
+ return;
+
+ m = n->right;
+ if(m->ty->kind != Tmodule || m->op != Oname){
+ nerror(n, "cannot import from %Q", m);
+ return;
+ }
+
+ last = n->left->decl;
+ for(id = n->decl; id != last->next; id = id->next){
+ v = namedot(m->ty->ids, id->sym);
+ if(v == nil){
+ error(id->src.start, "%s is not a member of %V", id->sym->name, m);
+ id->store = Dwundef;
+ continue;
+ }
+ id->store = v->store;
+ v->ty = validtype(v->ty, nil);
+ id->ty = t = v->ty;
+ if(id->store == Dtype && t->decl != nil){
+ id->timport = t->decl->timport;
+ t->decl->timport = id;
+ }
+ id->init = v->init;
+ id->importid = v;
+ id->eimport = m;
+ }
+}
+
+static Decl*
+rewcall(Node *n, Decl *d)
+{
+ /* put original function back now we're type checked */
+ while(d->link != nil)
+ d = d->link;
+ if(n->op == Odot)
+ n->right->decl = d;
+ else if(n->op == Omdot){
+ n->right->right->decl = d;
+ n->right->right->ty = d->ty;
+ }
+ else
+ fatal("bad op in Ocall rewcall");
+ n->ty = n->right->ty = d->ty;
+ d->refs++;
+ usetype(d->ty);
+ return d;
+}
+
+/*
+ * annotate the expression with types
+ */
+Ok
+echeck(Node *n, int typeok, int isglobal, Node *par)
+{
+ Type *t, *tt;
+ Node *left, *right, *mod, *nn;
+ Decl *tg, *id, *callee;
+ Sym *s;
+ int max, nocheck;
+ Ok ok, rok, kidsok;
+ static int tagopt;
+
+ ok.ok = ok.allok = 1;
+ if(n == nil)
+ return ok;
+
+ /* avoid deep recursions */
+ if(n->op == Oseq){
+ for( ; n != nil && n->op == Oseq; n = n->right){
+ rok = echeck(n->left, typeok == 2, isglobal, n);
+ ok.ok &= rok.ok;
+ ok.allok &= rok.allok;
+ n->ty = tnone;
+ }
+ if(n == nil)
+ return ok;
+ }
+
+ left = n->left;
+ right = n->right;
+
+ nocheck = 0;
+ if(n->op == Odot || n->op == Omdot || n->op == Ocall || n->op == Oref || n->op == Otagof || n->op == Oindex)
+ nocheck = 1;
+ if(n->op != Odas /* special case */
+ && n->op != Oload) /* can have better error recovery */
+ ok = echeck(left, nocheck, isglobal, n);
+ if(n->op != Odas /* special case */
+ && n->op != Odot /* special check */
+ && n->op != Omdot /* special check */
+ && n->op != Ocall /* can have better error recovery */
+ && n->op != Oindex){
+ rok = echeck(right, 0, isglobal, n);
+ ok.ok &= rok.ok;
+ ok.allok &= rok.allok;
+ }
+ if(!ok.ok){
+ n->ty = terror;
+ ok.allok = 0;
+ return ok;
+ }
+
+ switch(n->op){
+ case Odas:
+ kidsok = echeck(right, 0, isglobal, n);
+ if(!kidsok.ok)
+ right->ty = terror;
+ if(!isglobal && !dasdecl(left)){
+ kidsok.ok = 0;
+ }else if(!specific(right->ty) || !declasinfer(left, right->ty)){
+ nerror(n, "cannot declare %V from %Q", left, right);
+ declaserr(left);
+ kidsok.ok = 0;
+ }
+ if(right->ty->kind == Texception)
+ left->ty = n->ty = mkextuptype(right->ty);
+ else{
+ left->ty = n->ty = right->ty;
+ usedty(n->ty);
+ }
+ kidsok.allok &= kidsok.ok;
+ if (nested() && tmustzero(left->ty))
+ decltozero(left);
+ return kidsok;
+ case Oseq:
+ case Onothing:
+ n->ty = tnone;
+ break;
+ case Owild:
+ n->ty = tint;
+ break;
+ case Ocast:
+ t = usetype(n->ty);
+ n->ty = t;
+ tt = left->ty;
+ if(tcompat(t, tt, 0)){
+ left->ty = t;
+ break;
+ }
+ if(tt->kind == Tarray){
+ if(tt->tof == tbyte && t == tstring)
+ break;
+ }else if(t->kind == Tarray){
+ if(t->tof == tbyte && tt == tstring)
+ break;
+ }else if(casttab[tt->kind][t->kind]){
+ break;
+ }
+ nerror(n, "cannot make a %T from %Q", n->ty, left);
+ ok.ok = ok.allok = 0;
+ return ok;
+ case Ochan:
+ n->ty = usetype(n->ty);
+ if(left && left->ty->kind != Tint){
+ nerror(n, "channel size %Q is not an int", left);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ break;
+ case Oload:
+ n->ty = usetype(n->ty);
+ kidsok = echeck(left, 0, isglobal, n);
+ if(n->ty->kind != Tmodule){
+ nerror(n, "cannot load a %T, ", n->ty);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ if(!kidsok.allok){
+ ok.allok = 0;
+ break;
+ }
+ if(left->ty != tstring){
+ nerror(n, "cannot load a module from %Q", left);
+ ok.allok = 0;
+ break;
+ }
+if(n->ty->tof->decl->refs != 0)
+n->ty->tof->decl->refs++;
+n->ty->decl->refs++;
+ usetype(n->ty->tof);
+ break;
+ case Oref:
+ t = left->ty;
+ if(t->kind != Tadt && t->kind != Tadtpick && t->kind != Tfn && t->kind != Ttuple){
+ nerror(n, "cannot make a ref from %Q", left);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ if(!tagopt && t->kind == Tadt && t->tags != nil && valistype(left)){
+ nerror(n, "instances of ref %V must be qualified with a pick tag", left);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ if(t->kind == Tadtpick)
+ t->tof = usetype(t->tof);
+ n->ty = usetype(mktype(&n->src.start, &n->src.stop, Tref, t, nil));
+ break;
+ case Oarray:
+ max = 0;
+ if(right != nil){
+ max = assignindices(n);
+ if(max < 0){
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ if(!specific(right->left->ty)){
+ nerror(n, "type for array not specific");
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ n->ty = mktype(&n->src.start, &n->src.stop, Tarray, right->left->ty, nil);
+ }
+ n->ty = usetype(n->ty);
+
+ if(left->op == Onothing)
+ n->left = left = mkconst(&n->left->src, max);
+
+ if(left->ty->kind != Tint){
+ nerror(n, "array size %Q is not an int", left);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ break;
+ case Oelem:
+ n->ty = right->ty;
+ break;
+ case Orange:
+ if(left->ty != right->ty
+ || left->ty != tint && left->ty != tstring){
+ nerror(left, "range %Q to %Q is not an int or string range", left, right);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ n->ty = left->ty;
+ break;
+ case Oname:
+ id = n->decl;
+ if(id == nil){
+ nerror(n, "name with no declaration");
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ if(id->store == Dunbound){
+ s = id->sym;
+ id = s->decl;
+ if(id == nil)
+ id = undefed(&n->src, s);
+ /* save a little space */
+ s->unbound = nil;
+ n->decl = id;
+ id->refs++;
+ }
+ n->ty = id->ty = usetype(id->ty);
+ switch(id->store){
+ case Dfn:
+ case Dglobal:
+ case Darg:
+ case Dlocal:
+ case Dimport:
+ case Dfield:
+ case Dtag:
+ break;
+ case Dundef:
+ nerror(n, "%s is not declared", id->sym->name);
+ id->store = Dwundef;
+ ok.ok = ok.allok = 0;
+ return ok;
+ case Dwundef:
+ ok.ok = ok.allok = 0;
+ return ok;
+ case Dconst:
+ if(id->init == nil){
+ nerror(n, "%s's value cannot be determined", id->sym->name);
+ id->store = Dwundef;
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ break;
+ case Dtype:
+ if(typeok)
+ break;
+ nerror(n, "%K is not a variable", id);
+ ok.ok = ok.allok = 0;
+ return ok;
+ default:
+ fatal("echeck: unknown symbol storage");
+ }
+
+ if(n->ty == nil){
+ nerror(n, "%K's type is not fully defined", id);
+ id->store = Dwundef;
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ if(id->importid != nil && valistype(id->eimport)
+ && id->store != Dconst && id->store != Dtype && id->store != Dfn){
+ nerror(n, "cannot use %V because %V is a module interface", n, id->eimport);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ if(n->ty->kind == Texception && !n->ty->cons && par != nil && par->op != Oraise && par->op != Odot){
+ nn = mkn(0, nil, nil);
+ *nn = *n;
+ n->op = Ocast;
+ n->left = nn;
+ n->decl = nil;
+ n->ty = usetype(mkextuptype(n->ty));
+ }
+ /* function name as function reference */
+ if(id->store == Dfn && (par == nil || (par->op != Odot && par->op != Omdot && par->op != Ocall && par->op != Ofunc)))
+ fnref(n, id);
+ break;
+ case Oconst:
+ if(n->ty == nil){
+ nerror(n, "no type in %V", n);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ break;
+ case Oas:
+ t = right->ty;
+ if(t->kind == Texception)
+ t = mkextuptype(t);
+ if(!tcompat(left->ty, t, 1)){
+ nerror(n, "type clash in %Q = %Q", left, right);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ if(t == tany)
+ t = left->ty;
+ n->ty = t;
+ left->ty = t;
+ if(t->kind == Tadt && t->tags != nil || t->kind == Tadtpick)
+ if(left->ty->kind != Tadtpick || right->ty->kind != Tadtpick)
+ nerror(n, "expressions cannot have type %T", t);
+ if(left->ty->kind == Texception){
+ nerror(n, "cannot assign to an exception");
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ if(islval(left))
+ break;
+ ok.ok = ok.allok = 0;
+ return ok;
+ case Osnd:
+ if(left->ty->kind != Tchan){
+ nerror(n, "cannot send on %Q", left);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ if(!tcompat(left->ty->tof, right->ty, 0)){
+ nerror(n, "type clash in %Q <-= %Q", left, right);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ t = right->ty;
+ if(t == tany)
+ t = left->ty->tof;
+ n->ty = t;
+ break;
+ case Orcv:
+ t = left->ty;
+ if(t->kind == Tarray)
+ t = t->tof;
+ if(t->kind != Tchan){
+ nerror(n, "cannot receive on %Q", left);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ if(left->ty->kind == Tarray)
+ n->ty = usetype(mktype(&n->src.start, &n->src.stop, Ttuple, nil,
+ mkids(&n->src, nil, tint, mkids(&n->src, nil, t->tof, nil))));
+ else
+ n->ty = t->tof;
+ break;
+ case Ocons:
+ if(right->ty->kind != Tlist && right->ty != tany){
+ nerror(n, "cannot :: to %Q", right);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ n->ty = right->ty;
+ if(right->ty == tany)
+ n->ty = usetype(mktype(&n->src.start, &n->src.stop, Tlist, left->ty, nil));
+ else if(!tcompat(right->ty->tof, left->ty, 0)){
+ t = tparent(right->ty->tof, left->ty);
+ if(!tcompat(t, left->ty, 0)){
+ nerror(n, "type clash in %Q :: %Q", left, right);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ else
+ n->ty = usetype(mktype(&n->src.start, &n->src.stop, Tlist, t, nil));
+ }
+ break;
+ case Ohd:
+ case Otl:
+ if(left->ty->kind != Tlist || left->ty->tof == nil){
+ nerror(n, "cannot %O %Q", n->op, left);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ if(n->op == Ohd)
+ n->ty = left->ty->tof;
+ else
+ n->ty = left->ty;
+ break;
+ case Otuple:
+ n->ty = usetype(mktype(&n->src.start, &n->src.stop, Ttuple, nil, tuplefields(left)));
+ break;
+ case Ospawn:
+ if(left->op != Ocall || left->left->ty->kind != Tfn && !isfnrefty(left->left->ty)){
+ nerror(left, "cannot spawn %V", left);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ if(left->ty != tnone){
+ nerror(left, "cannot spawn functions which return values, such as %Q", left);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ break;
+ case Oraise:
+ if(left->op == Onothing){
+ if(inexcept == nil){
+ nerror(n, "%V: empty raise not in exception handler", n);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ n->left = dupn(1, &n->src, inexcept);
+ break;
+ }
+ if(left->ty != tstring && left->ty->kind != Texception){
+ nerror(n, "%V: raise argument %Q is not a string or exception", n, left);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ if((left->op != Ocall || left->left->ty->kind == Tfn) && left->ty->ids != nil && left->ty->cons){
+ nerror(n, "too few exception arguments");
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ break;
+ case Ocall:{
+ int pure;
+
+ kidsok = echeck(right, 0, isglobal, nil);
+ t = left->ty;
+ usedty(t);
+ pure = 1;
+ if(t->kind == Tref){
+ pure = 0;
+ t = t->tof;
+ }
+ if(t->kind != Tfn)
+ return callcast(n, kidsok.allok, ok.allok);
+ n->ty = t->tof;
+ if(!kidsok.allok){
+ ok.allok = 0;
+ break;
+ }
+
+ /*
+ * get the name to call and any associated module
+ */
+ mod = nil;
+ callee = nil;
+ id = nil;
+ tt = nil;
+ if(left->op == Odot){
+ Decl *dd;
+ Type *ttt;
+
+ callee = left->right->decl;
+ id = callee->dot;
+ right = passimplicit(left, right);
+ n->right = right;
+ tt = left->left->ty;
+ if(tt->kind == Tref)
+ tt = tt->tof;
+ ttt = tt;
+ if(tt->kind == Tadtpick)
+ ttt = tt->decl->dot->ty;
+ dd = ttt->decl;
+ while(dd != nil && dd->link != nil)
+ dd = dd->link;
+ if(dd != nil && dd->timport != nil)
+ mod = dd->timport->eimport;
+ /*
+ * stash the import module under a rock,
+ * because we won't be able to get it later
+ * after scopes are popped
+ */
+ left->right->left = mod;
+ }else if(left->op == Omdot){
+ if(left->right->op == Odot){
+ callee = left->right->right->decl;
+ right = passimplicit(left->right, right);
+ n->right = right;
+ tt = left->right->left->ty;
+ if(tt->kind == Tref)
+ tt = tt->tof;
+ }else
+ callee = left->right->decl;
+ mod = left->left;
+ }else if(left->op == Oname){
+ callee = left->decl;
+ id = callee;
+ mod = id->eimport;
+ }else if(pure){
+ nerror(left, "%V is not a function name", left);
+ ok.allok = 0;
+ break;
+ }
+ if(pure && callee == nil)
+ fatal("can't find called function: %n", left);
+ if(callee != nil && callee->store != Dfn && !isfnref(callee)){
+ nerror(left, "%V is not a function or function reference", left);
+ ok.allok = 0;
+ break;
+ }
+ if(mod != nil && mod->ty->kind != Tmodule){
+ nerror(left, "cannot call %V", left);
+ ok.allok = 0;
+ break;
+ }
+ if(mod != nil){
+ if(valistype(mod)){
+ nerror(left, "cannot call %V because %V is a module interface", left, mod);
+ ok.allok = 0;
+ break;
+ }
+ }else if(id != nil && id->dot != nil && !isimpmod(id->dot->sym)){
+ nerror(left, "cannot call %V without importing %s from a variable", left, id->sym->name);
+ ok.allok = 0;
+ break;
+ }
+ if(mod != nil)
+ modrefable(left->ty);
+ if(callee != nil && callee->store != Dfn)
+ callee = nil;
+ if(t->varargs != 0){
+ t = mkvarargs(left, right);
+ if(left->ty->kind == Tref)
+ left->ty = usetype(mktype(&t->src.start, &t->src.stop, Tref, t, nil));
+ else
+ left->ty = t;
+ }
+ else if(ispoly(callee) || isfnrefty(left->ty) && left->ty->tof->polys != nil){
+ Tpair *tp;
+
+ unifysrc = n->src;
+ if(!argncompat(n, t->ids, right))
+ ok.allok = 0;
+ else if(!tunify(left->ty, calltype(left->ty, right, n->ty), &tp)){
+ nerror(n, "function call type mismatch");
+ ok.allok = 0;
+ }
+ else{
+ n->ty = usetype(expandtype(n->ty, nil, nil, &tp));
+ if(ispoly(callee) && tt != nil && (tt->kind == Tadt || tt->kind == Tadtpick) && (tt->flags&INST))
+ callee = rewcall(left, callee);
+ n->right = passfns(&n->src, callee, left, right, tt, tp);
+ }
+ }
+ else if(!argcompat(n, t->ids, right))
+ ok.allok = 0;
+ break;
+ }
+ case Odot:
+ t = left->ty;
+ if(t->kind == Tref)
+ t = t->tof;
+ switch(t->kind){
+ case Tadt:
+ case Tadtpick:
+ case Ttuple:
+ case Texception:
+ case Tpoly:
+ id = namedot(t->ids, right->decl->sym);
+ if(id == nil){
+ id = namedot(t->tags, right->decl->sym);
+ if(id != nil && !valistype(left)){
+ nerror(n, "%V is not a type", left);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ }
+ if(id == nil){
+ id = namedot(t->polys, right->decl->sym);
+ if(id != nil && !valistype(left)){
+ nerror(n, "%V is not a type", left);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ }
+ if(id == nil && t->kind == Tadtpick)
+ id = namedot(t->decl->dot->ty->ids, right->decl->sym);
+ if(id == nil){
+ for(tg = t->tags; tg != nil; tg = tg->next){
+ id = namedot(tg->ty->ids, right->decl->sym);
+ if(id != nil)
+ break;
+ }
+ if(id != nil){
+ nerror(n, "cannot yet index field %s of %Q", right->decl->sym->name, left);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ }
+ if(id == nil)
+ break;
+ if(id->store == Dfield && valistype(left)){
+ nerror(n, "%V is not a value", left);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ id->ty = validtype(id->ty, t->decl);
+ id->ty = usetype(id->ty);
+ break;
+ default:
+ nerror(left, "%Q cannot be qualified with .", left);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ if(id == nil){
+ nerror(n, "%V is not a member of %Q", right, left);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ if(id->ty == tunknown){
+ nerror(n, "illegal forward reference to %V", n);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+
+ increfs(id);
+ right->decl = id;
+ n->ty = id->ty;
+ if((id->store == Dconst || id->store == Dtag) && hasside(left, 1))
+ nwarn(left, "result of expression %Q ignored", left);
+ /* function name as function reference */
+ if(id->store == Dfn && (par == nil || (par->op != Omdot && par->op != Ocall && par->op != Ofunc)))
+ fnref(n, id);
+ break;
+ case Omdot:
+ t = left->ty;
+ if(t->kind != Tmodule){
+ nerror(left, "%Q cannot be qualified with ->", left);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ id = nil;
+ if(right->op == Oname){
+ id = namedot(t->ids, right->decl->sym);
+ }else if(right->op == Odot){
+ kidsok = echeck(right, 0, isglobal, n);
+ ok.ok = kidsok.ok;
+ ok.allok &= kidsok.allok;
+ if(!ok.ok){
+ ok.allok = 0;
+ return ok;
+ }
+ tt = right->left->ty;
+ if(tt->kind == Tref)
+ tt = tt->tof;
+ if(right->ty->kind == Tfn
+ && tt->kind == Tadt
+ && tt->decl->dot == t->decl)
+ id = right->right->decl;
+ }
+ if(id == nil){
+ nerror(n, "%V is not a member of %Q", right, left);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ if(id->store != Dconst && id->store != Dtype && id->store != Dtag){
+ if(valistype(left)){
+ nerror(n, "%V is not a value", left);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ }else if(hasside(left, 1))
+ nwarn(left, "result of expression %Q ignored", left);
+ if(!typeok && id->store == Dtype){
+ nerror(n, "%V is a type, not a value", n);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ if(id->ty == tunknown){
+ nerror(n, "illegal forward reference to %V", n);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ id->refs++;
+ right->decl = id;
+ n->ty = id->ty = usetype(id->ty);
+ if(id->store == Dglobal)
+ modrefable(id->ty);
+ /* function name as function reference */
+ if(id->store == Dfn && (par == nil || (par->op != Ocall && par->op != Ofunc)))
+ fnref(n, id);
+ break;
+ case Otagof:
+ n->ty = tint;
+ t = left->ty;
+ if(t->kind == Tref)
+ t = t->tof;
+ id = nil;
+ switch(left->op){
+ case Oname:
+ id = left->decl;
+ break;
+ case Odot:
+ id = left->right->decl;
+ break;
+ case Omdot:
+ if(left->right->op == Odot)
+ id = left->right->right->decl;
+ break;
+ }
+ if(id != nil && id->store == Dtag
+ || id != nil && id->store == Dtype && t->kind == Tadt && t->tags != nil)
+ n->decl = id;
+ else if(t->kind == Tadt && t->tags != nil || t->kind == Tadtpick)
+ n->decl = nil;
+ else{
+ nerror(n, "cannot get the tag value for %Q", left);
+ ok.ok = 1;
+ ok.allok = 0;
+ return ok;
+ }
+ break;
+ case Oind:
+ t = left->ty;
+ if(t->kind != Tref || (t->tof->kind != Tadt && t->tof->kind != Tadtpick && t->tof->kind != Ttuple)){
+ nerror(n, "cannot * %Q", left);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ n->ty = t->tof;
+ for(tg = t->tof->tags; tg != nil; tg = tg->next)
+ tg->ty->tof = usetype(tg->ty->tof);
+ break;
+ case Oindex:
+ if(valistype(left)){
+ tagopt = 1;
+ kidsok = echeck(right, 2, isglobal, n);
+ tagopt = 0;
+ if(!kidsok.allok){
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ if((t = exptotype(n)) == nil){
+ nerror(n, "%V is not a type list", right);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ if(!typeok){
+ nerror(n, "%Q is not a variable", left);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ *n = *(n->left);
+ n->ty = usetype(t);
+ break;
+ }
+ if(0 && right->op == Oseq){ /* a[e1, e2, ...] */
+ /* array creation to do before we allow this */
+ rewind(n);
+ return echeck(n, typeok, isglobal, par);
+ }
+ t = left->ty;
+ kidsok = echeck(right, 0, isglobal, n);
+ if(t->kind != Tarray && t != tstring){
+ nerror(n, "cannot index %Q", left);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ if(t == tstring){
+ n->op = Oinds;
+ n->ty = tint;
+ }else{
+ n->ty = t->tof;
+ }
+ if(!kidsok.allok){
+ ok.allok = 0;
+ break;
+ }
+ if(right->ty != tint){
+ nerror(n, "cannot index %Q with %Q", left, right);
+ ok.allok = 0;
+ break;
+ }
+ break;
+ case Oslice:
+ t = n->ty = left->ty;
+ if(t->kind != Tarray && t != tstring){
+ nerror(n, "cannot slice %Q with '%v:%v'", left, right->left, right->right);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ if(right->left->ty != tint && right->left->op != Onothing
+ || right->right->ty != tint && right->right->op != Onothing){
+ nerror(n, "cannot slice %Q with '%v:%v'", left, right->left, right->right);
+ ok.allok = 0;
+ return ok;
+ }
+ break;
+ case Olen:
+ t = left->ty;
+ n->ty = tint;
+ if(t->kind != Tarray && t->kind != Tlist && t != tstring){
+ nerror(n, "len requires an array, string or list in %Q", left);
+ ok.allok = 0;
+ return ok;
+ }
+ break;
+ case Ocomp:
+ case Onot:
+ case Oneg:
+ n->ty = left->ty;
+ usedty(n->ty);
+ switch(left->ty->kind){
+ case Tint:
+ return ok;
+ case Treal:
+ case Tfix:
+ if(n->op == Oneg)
+ return ok;
+ break;
+ case Tbig:
+ case Tbyte:
+ if(n->op == Oneg || n->op == Ocomp)
+ return ok;
+ break;
+ }
+ nerror(n, "cannot apply %O to %Q", n->op, left);
+ ok.ok = ok.allok = 0;
+ return ok;
+ case Oinc:
+ case Odec:
+ case Opreinc:
+ case Opredec:
+ n->ty = left->ty;
+ switch(left->ty->kind){
+ case Tint:
+ case Tbig:
+ case Tbyte:
+ case Treal:
+ break;
+ default:
+ nerror(n, "cannot apply %O to %Q", n->op, left);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ if(islval(left))
+ break;
+ ok.ok = ok.allok = 0;
+ return ok;
+ case Oadd:
+ case Odiv:
+ case Omul:
+ case Osub:
+ if(mathchk(n, 1))
+ break;
+ ok.ok = ok.allok = 0;
+ return ok;
+ case Oexp:
+ case Oexpas:
+ n->ty = left->ty;
+ if(n->ty != tint && n->ty != tbig && n->ty != treal){
+ nerror(n, "exponend %Q is not int, big or real", left);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ if(right->ty != tint){
+ nerror(n, "exponent %Q is not int", right);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ if(n->op == Oexpas && !islval(left)){
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ break;
+/*
+ if(mathchk(n, 0)){
+ if(n->ty != tint){
+ nerror(n, "exponentiation operands not int");
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ break;
+ }
+ ok.ok = ok.allok = 0;
+ return ok;
+*/
+ case Olsh:
+ case Orsh:
+ if(shiftchk(n))
+ break;
+ ok.ok = ok.allok = 0;
+ return ok;
+ case Oandand:
+ case Ooror:
+ if(left->ty != tint){
+ nerror(n, "%O's left operand is not an int: %Q", n->op, left);
+ ok.allok = 0;
+ }
+ if(right->ty != tint){
+ nerror(n, "%O's right operand is not an int: %Q", n->op, right);
+ ok.allok = 0;
+ }
+ n->ty = tint;
+ break;
+ case Oand:
+ case Omod:
+ case Oor:
+ case Oxor:
+ if(mathchk(n, 0))
+ break;
+ ok.ok = ok.allok = 0;
+ return ok;
+ case Oaddas:
+ case Odivas:
+ case Omulas:
+ case Osubas:
+ if(mathchk(n, 1) && islval(left))
+ break;
+ ok.ok = ok.allok = 0;
+ return ok;
+ case Olshas:
+ case Orshas:
+ if(shiftchk(n) && islval(left))
+ break;
+ ok.ok = ok.allok = 0;
+ return ok;
+ case Oandas:
+ case Omodas:
+ case Oxoras:
+ case Ooras:
+ if(mathchk(n, 0) && islval(left))
+ break;
+ ok.ok = ok.allok = 0;
+ return ok;
+ case Olt:
+ case Oleq:
+ case Ogt:
+ case Ogeq:
+ if(!mathchk(n, 1)){
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ n->ty = tint;
+ break;
+ case Oeq:
+ case Oneq:
+ switch(left->ty->kind){
+ case Tint:
+ case Tbig:
+ case Tbyte:
+ case Treal:
+ case Tstring:
+ case Tref:
+ case Tlist:
+ case Tarray:
+ case Tchan:
+ case Tany:
+ case Tmodule:
+ case Tfix:
+ case Tpoly:
+ if(!tcompat(left->ty, right->ty, 0) && !tcompat(right->ty, left->ty, 0))
+ break;
+ t = left->ty;
+ if(t == tany)
+ t = right->ty;
+ if(t == tany)
+ t = tint;
+ if(left->ty == tany)
+ left->ty = t;
+ if(right->ty == tany)
+ right->ty = t;
+ n->ty = tint;
+ return ok;
+ }
+ nerror(n, "cannot compare %Q to %Q", left, right);
+ usedty(n->ty);
+ ok.ok = ok.allok = 0;
+ return ok;
+ case Otype:
+ if(!typeok){
+ nerror(n, "%Q is not a variable", n);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ n->ty = usetype(n->ty);
+ break;
+ default:
+ fatal("unknown op in typecheck: %O", n->op);
+ }
+ usedty(n->ty);
+ return ok;
+}
+
+/*
+ * n is syntactically a call, but n->left is not a fn
+ * check if it's the contructor for an adt
+ */
+Ok
+callcast(Node *n, int kidsok, int allok)
+{
+ Node *left, *right;
+ Decl *id;
+ Type *t, *tt;
+ Ok ok;
+
+ left = n->left;
+ right = n->right;
+ id = nil;
+ switch(left->op){
+ case Oname:
+ id = left->decl;
+ break;
+ case Omdot:
+ if(left->right->op == Odot)
+ id = left->right->right->decl;
+ else
+ id = left->right->decl;
+ break;
+ case Odot:
+ id = left->right->decl;
+ break;
+ }
+/*
+ (chan of int)(nil) looks awkward since both sets of brackets needed
+ if(id == nil && right != nil && right->right == nil && (t = exptotype(left)) != nil){
+ n->op = Ocast;
+ n->left = right->left;
+ n->right = nil;
+ n->ty = t;
+ return echeck(n, 0, 0, nil);
+ }
+*/
+ if(id == nil || (id->store != Dtype && id->store != Dtag && id->ty->kind != Texception)){
+ nerror(left, "%V is not a function or type name", left);
+ ok.ok = ok.allok = 0;
+ return ok;
+ }
+ if(id->store == Dtag)
+ return tagcast(n, left, right, id, kidsok, allok);
+ t = left->ty;
+ n->ty = t;
+ if(!kidsok){
+ ok.ok = 1;
+ ok.allok = 0;
+ return ok;
+ }
+
+ if(t->kind == Tref)
+ t = t->tof;
+ tt = mktype(&n->src.start, &n->src.stop, Ttuple, nil, tuplefields(right));
+ if(t->kind == Tadt && tcompat(t, tt, 1)){
+ if(right == nil)
+ *n = *n->left;
+ ok.ok = 1;
+ ok.allok = allok;
+ return ok;
+ }
+
+ /* try an exception with args */
+ tt = mktype(&n->src.start, &n->src.stop, Texception, nil, tuplefields(right));
+ tt->cons = 1;
+ if(t->kind == Texception && t->cons && tcompat(t, tt, 1)){
+ if(right == nil)
+ *n = *n->left;
+ ok.ok = 1;
+ ok.allok = allok;
+ return ok;
+ }
+
+ /* try a cast */
+ if(t->kind != Texception && right != nil && right->right == nil){ /* Oseq but single expression */
+ right = right->left;
+ n->op = Ocast;
+ n->left = right;
+ n->right = nil;
+ n->ty = mkidtype(&n->src, id->sym);
+ return echeck(n, 0, 0, nil);
+ }
+
+ nerror(left, "cannot make a %V from '(%v)'", left, right);
+ ok.ok = ok.allok = 0;
+ return ok;
+}
+
+Ok
+tagcast(Node *n, Node *left, Node *right, Decl *id, int kidsok, int allok)
+{
+ Type *tt;
+ Ok ok;
+
+ left->ty = id->ty;
+ if(left->op == Omdot)
+ left->right->ty = id->ty;
+ n->ty = id->ty;
+ if(!kidsok){
+ ok.ok = 1;
+ ok.allok = 0;
+ return ok;
+ }
+ id->ty->tof = usetype(id->ty->tof);
+ if(right != nil)
+ right->ty = id->ty->tof;
+ tt = mktype(&n->src.start, &n->src.stop, Ttuple, nil, mkids(&nosrc, nil, tint, tuplefields(right)));
+ tt->ids->store = Dfield;
+ if(tcompat(id->ty->tof, tt, 1)){
+ ok.ok = 1;
+ ok.allok = allok;
+ return ok;
+ }
+
+ nerror(left, "cannot make a %V from '(%v)'", left, right);
+ ok.ok = ok.allok = 0;
+ return ok;
+}
+
+int
+valistype(Node *n)
+{
+ switch(n->op){
+ case Oname:
+ if(n->decl->store == Dtype)
+ return 1;
+ break;
+ case Omdot:
+ return valistype(n->right);
+ }
+ return 0;
+}
+
+int
+islval(Node *n)
+{
+ int s;
+
+ s = marklval(n);
+ if(s == 1)
+ return 1;
+ if(s == 0)
+ nerror(n, "cannot assign to %V", n);
+ else
+ circlval(n, n);
+ return 0;
+}
+
+/*
+ * check to see if n is an lval
+ * mark the lval name as set
+ */
+int
+marklval(Node *n)
+{
+ Decl *id;
+ Node *nn;
+ int s;
+
+ if(n == nil)
+ return 0;
+ switch(n->op){
+ case Oname:
+ return storespace[n->decl->store] && n->ty->kind != Texception; /*ZZZZ && n->decl->tagged == nil;*/
+ case Odot:
+ if(n->right->decl->store != Dfield)
+ return 0;
+ if(n->right->decl->cycle && !n->right->decl->cyc)
+ return -1;
+ if(n->left->ty->kind != Tref && marklval(n->left) == 0)
+ nwarn(n, "assignment to %Q ignored", n);
+ return 1;
+ case Omdot:
+ if(n->right->decl->store == Dglobal)
+ return 1;
+ return 0;
+ case Oind:
+ for(id = n->ty->ids; id != nil; id = id->next)
+ if(id->cycle && !id->cyc)
+ return -1;
+ return 1;
+ case Oslice:
+ if(n->right->right->op != Onothing || n->ty == tstring)
+ return 0;
+ return 1;
+ case Oinds:
+ /*
+ * make sure we don't change a string constant
+ */
+ switch(n->left->op){
+ case Oconst:
+ return 0;
+ case Oname:
+ return storespace[n->left->decl->store];
+ case Odot:
+ case Omdot:
+ if(n->left->right->decl != nil)
+ return storespace[n->left->right->decl->store];
+ break;
+ }
+ return 1;
+ case Oindex:
+ case Oindx:
+ return 1;
+ case Otuple:
+ for(nn = n->left; nn != nil; nn = nn->right){
+ s = marklval(nn->left);
+ if(s != 1)
+ return s;
+ }
+ return 1;
+ default:
+ return 0;
+ }
+ return 0;
+}
+
+/*
+ * n has a circular field assignment.
+ * find it and print an error message.
+ */
+int
+circlval(Node *n, Node *lval)
+{
+ Decl *id;
+ Node *nn;
+ int s;
+
+ if(n == nil)
+ return 0;
+ switch(n->op){
+ case Oname:
+ break;
+ case Odot:
+ if(n->right->decl->cycle && !n->right->decl->cyc){
+ nerror(lval, "cannot assign to %V because field '%s' of %V could complete a cycle to %V",
+ lval, n->right->decl->sym->name, n->left, n->left);
+ return -1;
+ }
+ return 1;
+ case Oind:
+ for(id = n->ty->ids; id != nil; id = id->next){
+ if(id->cycle && !id->cyc){
+ nerror(lval, "cannot assign to %V because field '%s' of %V could complete a cycle to %V",
+ lval, id->sym->name, n, n);
+ return -1;
+ }
+ }
+ return 1;
+ case Oslice:
+ if(n->right->right->op != Onothing || n->ty == tstring)
+ return 0;
+ return 1;
+ case Oindex:
+ case Oinds:
+ case Oindx:
+ return 1;
+ case Otuple:
+ for(nn = n->left; nn != nil; nn = nn->right){
+ s = circlval(nn->left, lval);
+ if(s != 1)
+ return s;
+ }
+ return 1;
+ default:
+ return 0;
+ }
+ return 0;
+}
+
+int
+mathchk(Node *n, int realok)
+{
+ Type *tr, *tl;
+
+ tl = n->left->ty;
+ tr = n->right->ty;
+ if(tr != tl && !tequal(tl, tr)){
+ nerror(n, "type clash in %Q %O %Q", n->left, n->op, n->right);
+ return 0;
+ }
+ n->ty = tr;
+ switch(tr->kind){
+ case Tint:
+ case Tbig:
+ case Tbyte:
+ return 1;
+ case Tstring:
+ switch(n->op){
+ case Oadd:
+ case Oaddas:
+ case Ogt:
+ case Ogeq:
+ case Olt:
+ case Oleq:
+ return 1;
+ }
+ break;
+ case Treal:
+ case Tfix:
+ if(realok)
+ return 1;
+ break;
+ }
+ nerror(n, "cannot %O %Q and %Q", n->op, n->left, n->right);
+ return 0;
+}
+
+int
+shiftchk(Node *n)
+{
+ Node *left, *right;
+
+ right = n->right;
+ left = n->left;
+ n->ty = left->ty;
+ switch(n->ty->kind){
+ case Tint:
+ case Tbyte:
+ case Tbig:
+ if(right->ty->kind != Tint){
+ nerror(n, "shift %Q is not an int", right);
+ return 0;
+ }
+ return 1;
+ }
+ nerror(n, "cannot %Q %O %Q", left, n->op, right);
+ return 0;
+}
+
+/*
+ * check for any tany's in t
+ */
+int
+specific(Type *t)
+{
+ Decl *d;
+
+ if(t == nil)
+ return 0;
+ switch(t->kind){
+ case Terror:
+ case Tnone:
+ case Tint:
+ case Tbig:
+ case Tstring:
+ case Tbyte:
+ case Treal:
+ case Tfn:
+ case Tadt:
+ case Tadtpick:
+ case Tmodule:
+ case Tfix:
+ return 1;
+ case Tany:
+ return 0;
+ case Tpoly:
+ return 1;
+ case Tref:
+ case Tlist:
+ case Tarray:
+ case Tchan:
+ return specific(t->tof);
+ case Ttuple:
+ case Texception:
+ for(d = t->ids; d != nil; d = d->next)
+ if(!specific(d->ty))
+ return 0;
+ return 1;
+ }
+ fatal("unknown type %T in specific", t);
+ return 0;
+}
+
+/*
+ * infer the type of all variable in n from t
+ * n is the left-hand exp of a := exp
+ */
+int
+declasinfer(Node *n, Type *t)
+{
+ Decl *ids;
+ int ok;
+
+ if(t->kind == Texception){
+ if(t->cons)
+ return 0;
+ t = mkextuptype(t);
+ }
+ switch(n->op){
+ case Otuple:
+ if(t->kind != Ttuple && t->kind != Tadt && t->kind != Tadtpick)
+ return 0;
+ ok = 1;
+ n->ty = t;
+ n = n->left;
+ ids = t->ids;
+ if(t->kind == Tadtpick)
+ ids = t->tof->ids->next;
+ for(; n != nil && ids != nil; ids = ids->next){
+ if(ids->store != Dfield)
+ continue;
+ ok &= declasinfer(n->left, ids->ty);
+ n = n->right;
+ }
+ for(; ids != nil; ids = ids->next)
+ if(ids->store == Dfield)
+ break;
+ if(n != nil || ids != nil)
+ return 0;
+ return ok;
+ case Oname:
+ topvartype(t, n->decl, 0, 0);
+ if(n->decl == nildecl)
+ return 1;
+ n->decl->ty = t;
+ n->ty = t;
+ shareloc(n->decl);
+ return 1;
+ }
+ fatal("unknown op %n in declasinfer", n);
+ return 0;
+}
+
+/*
+ * an error occured in declaring n;
+ * set all decl identifiers to Dwundef
+ * so further errors are squashed.
+ */
+void
+declaserr(Node *n)
+{
+ switch(n->op){
+ case Otuple:
+ for(n = n->left; n != nil; n = n->right)
+ declaserr(n->left);
+ return;
+ case Oname:
+ if(n->decl != nildecl)
+ n->decl->store = Dwundef;
+ return;
+ }
+ fatal("unknown op %n in declaserr", n);
+}
+
+int
+argcompat(Node *n, Decl *f, Node *a)
+{
+ for(; a != nil; a = a->right){
+ if(f == nil){
+ nerror(n, "%V: too many function arguments", n->left);
+ return 0;
+ }
+ if(!tcompat(f->ty, a->left->ty, 0)){
+ nerror(n, "%V: argument type mismatch: expected %T saw %Q",
+ n->left, f->ty, a->left);
+ return 0;
+ }
+ if(a->left->ty == tany)
+ a->left->ty = f->ty;
+ f = f->next;
+ }
+ if(f != nil){
+ nerror(n, "%V: too few function arguments", n->left);
+ return 0;
+ }
+ return 1;
+}
+
+/*
+ * fn is Odot(adt, methid)
+ * pass adt implicitly if needed
+ * if not, any side effect of adt will be ingored
+ */
+Node*
+passimplicit(Node *fn, Node *args)
+{
+ Node *n;
+ Type *t;
+
+ t = fn->ty;
+ if(t->ids == nil || !t->ids->implicit){
+ if(hasside(fn->left, 1))
+ nwarn(fn, "result of expression %V ignored", fn->left);
+ return args;
+ }
+ n = fn->left;
+ if(n->op == Oname && n->decl->store == Dtype){
+ nerror(n, "%V is a type and cannot be a self argument", n);
+ n = mkn(Onothing, nil, nil);
+ n->src = fn->src;
+ n->ty = t->ids->ty;
+ }
+ args = mkn(Oseq, n, args);
+ args->src = n->src;
+ return args;
+}
+
+static int
+mem(Type *t, Decl *d)
+{
+ for( ; d != nil; d = d->next)
+ if(d->ty == t) /* was if(d->ty == t || tequal(d->ty, t)) */
+ return 1;
+ return 0;
+}
+
+static int
+memp(Type *t, Decl *f)
+{
+ return mem(t, f->ty->polys) || mem(t, encpolys(f));
+}
+
+static void
+passfns0(Src *src, Decl *fn, Node *args0, Node **args, Node **a, Tpair *tp, Decl *polys)
+{
+ Decl *id, *idt, *idf, *dot;
+ Type *tt;
+ Sym *sym;
+ Node *n, *na, *mod;
+ Tpair *p;
+
+if(debug['w']){
+ print("polys: ");
+ for(id=polys; id!=nil; id=id->next) print("%s ", id->sym->name);
+ print("\nmap: ");
+ for(p=tp; p!=nil; p=p->nxt) print("%T -> %T ", p->t1, p->t2);
+ print("\n");
+}
+ for(idt = polys; idt != nil; idt = idt->next){
+ tt = valtmap(idt->ty, tp);
+ if(tt->kind == Tpoly && fndec != nil && !memp(tt, fndec))
+ error(src->start, "cannot determine the instantiated type of %T", tt);
+ for(idf = idt->ty->ids; idf != nil; idf = idf->next){
+ sym = idf->sym;
+ id = fnlookup(sym, tt, &mod);
+ while(id != nil && id->link != nil)
+ id = id->link;
+if(debug['v']) print("fnlookup: %p\n", id);
+ if(id == nil) /* error flagged already */
+ continue;
+ id->refs++;
+ id->caninline = -1;
+ if(tt->kind == Tmodule){ /* mod an actual parameter */
+ for(;;){
+ if(args0 != nil && tequal(tt, args0->left->ty)){
+ mod = args0->left;
+ break;
+ }
+ if(args0 != nil)
+ args0 = args0->right;
+ }
+ }
+ if(mod == nil && (dot = module(id)) != nil && !isimpmod(dot->sym))
+ error(src->start, "cannot use %s without importing %s from a variable", id->sym->name, id->dot->sym->name);
+
+if(debug['U']) print("fp: %s %s %s\n", fn->sym->name, mod ? mod->decl->sym->name : "nil", id->sym->name);
+ n = mkn(Ofnptr, mod, mkdeclname(src, id));
+ n->src = *src;
+ n->decl = fn;
+ if(tt->kind == Tpoly)
+ n->flags = FNPTRA;
+ else
+ n->flags = 0;
+ na = mkn(Oseq, n, nil);
+ if(*a == nil)
+ *args = na;
+ else
+ (*a)->right = na;
+
+ n = mkn(Ofnptr, mod, mkdeclname(src, id));
+ n->src = *src;
+ n->decl = fn;
+ if(tt->kind == Tpoly)
+ n->flags = FNPTRA|FNPTR2;
+ else
+ n->flags = FNPTR2;
+ *a = na->right = mkn(Oseq, n, nil);
+ }
+ if(args0 != nil)
+ args0 = args0->right;
+ }
+}
+
+Node*
+passfns(Src *src, Decl *fn, Node *left, Node *args, Type *adt, Tpair *tp)
+{
+ Node *a, *args0;
+
+ a = nil;
+ args0 = args;
+ if(args != nil)
+ for(a = args; a->right != nil; a = a->right)
+ ;
+ passfns0(src, fn, args0, &args, &a, tp, ispoly(fn) ? fn->ty->polys : left->ty->tof->polys);
+ if(adt != nil)
+ passfns0(src, fn, args0, &args, &a, adt->u.tmap, ispoly(fn) ? encpolys(fn) : nil);
+ return args;
+}
+
+/*
+ * check the types for a function with a variable number of arguments
+ * last typed argument must be a constant string, and must use the
+ * print format for describing arguments.
+ */
+Type*
+mkvarargs(Node *n, Node *args)
+{
+ Node *s, *a;
+ Decl *f, *last, *va;
+ Type *nt;
+
+ nt = copytypeids(n->ty);
+ n->ty = nt;
+ f = n->ty->ids;
+ last = nil;
+ if(f == nil){
+ nerror(n, "%V's type is illegal", n);
+ return nt;
+ }
+ s = args;
+ for(a = args; a != nil; a = a->right){
+ if(f == nil)
+ break;
+ if(!tcompat(f->ty, a->left->ty, 0)){
+ nerror(n, "%V: argument type mismatch: expected %T saw %Q",
+ n, f->ty, a->left);
+ return nt;
+ }
+ if(a->left->ty == tany)
+ a->left->ty = f->ty;
+ last = f;
+ f = f->next;
+ s = a;
+ }
+ if(f != nil){
+ nerror(n, "%V: too few function arguments", n);
+ return nt;
+ }
+
+ s->left = fold(s->left);
+ s = s->left;
+ if(s->ty != tstring || s->op != Oconst){
+ nerror(args, "%V: format argument %Q is not a string constant", n, s);
+ return nt;
+ }
+ fmtcheck(n, s, a);
+ va = tuplefields(a);
+ if(last == nil)
+ nt->ids = va;
+ else
+ last->next = va;
+ return nt;
+}
+
+/*
+ * check that a print style format string matches it's arguments
+ */
+void
+fmtcheck(Node *f, Node *fmtarg, Node *va)
+{
+ Sym *fmt;
+ Rune r;
+ char *s, flags[10];
+ int i, c, n1, n2, dot, verb, flag, ns, lens, fmtstart;
+ Type *ty;
+
+ fmt = fmtarg->decl->sym;
+ s = fmt->name;
+ lens = fmt->len;
+ ns = 0;
+ while(ns < lens){
+ c = s[ns++];
+ if(c != '%')
+ continue;
+
+ verb = -1;
+ n1 = 0;
+ n2 = 0;
+ dot = 0;
+ flag = 0;
+ fmtstart = ns - 1;
+ while(ns < lens && verb < 0){
+ c = s[ns++];
+ switch(c){
+ default:
+ chartorune(&r, &s[ns-1]);
+ nerror(f, "%V: invalid character %C in format '%.*s'", f, r, ns-fmtstart, &s[fmtstart]);
+ return;
+ case '.':
+ if(dot){
+ nerror(f, "%V: invalid format '%.*s'", f, ns-fmtstart, &s[fmtstart]);
+ return;
+ }
+ n1 = 1;
+ dot = 1;
+ continue;
+ case '*':
+ if(!n1)
+ n1 = 1;
+ else if(!n2 && dot)
+ n2 = 1;
+ else{
+ nerror(f, "%V: invalid format '%.*s'", f, ns-fmtstart, &s[fmtstart]);
+ return;
+ }
+ if(va == nil){
+ nerror(f, "%V: too few arguments for format '%.*s'",
+ f, ns-fmtstart, &s[fmtstart]);
+ return;
+ }
+ if(va->left->ty->kind != Tint){
+ nerror(f, "%V: format '%.*s' incompatible with argument %Q",
+ f, ns-fmtstart, &s[fmtstart], va->left);
+ return;
+ }
+ va = va->right;
+ break;
+ case '0': case '1': case '2': case '3': case '4':
+ case '5': case '6': case '7': case '8': case '9':
+ while(ns < lens && s[ns] >= '0' && s[ns] <= '9')
+ ns++;
+ if(!n1)
+ n1 = 1;
+ else if(!n2 && dot)
+ n2 = 1;
+ else{
+ nerror(f, "%V: invalid format '%.*s'", f, ns-fmtstart, &s[fmtstart]);
+ return;
+ }
+ break;
+ case '+':
+ case '-':
+ case '#':
+ case ',':
+ case 'b':
+ case 'u':
+ for(i = 0; i < flag; i++){
+ if(flags[i] == c){
+ nerror(f, "%V: duplicate flag %c in format '%.*s'",
+ f, c, ns-fmtstart, &s[fmtstart]);
+ return;
+ }
+ }
+ flags[flag++] = c;
+ if(flag >= sizeof flags){
+ nerror(f, "too many flags in format '%.*s'", ns-fmtstart, &s[fmtstart]);
+ return;
+ }
+ break;
+ case '%':
+ case 'r':
+ verb = Tnone;
+ break;
+ case 'H':
+ verb = Tany;
+ break;
+ case 'c':
+ verb = Tint;
+ break;
+ case 'd':
+ case 'o':
+ case 'x':
+ case 'X':
+ verb = Tint;
+ for(i = 0; i < flag; i++){
+ if(flags[i] == 'b'){
+ verb = Tbig;
+ break;
+ }
+ }
+ break;
+ case 'e':
+ case 'f':
+ case 'g':
+ case 'E':
+ case 'G':
+ verb = Treal;
+ break;
+ case 's':
+ case 'q':
+ verb = Tstring;
+ break;
+ }
+ }
+ if(verb != Tnone){
+ if(verb < 0){
+ nerror(f, "%V: incomplete format '%.*s'", f, ns-fmtstart, &s[fmtstart]);
+ return;
+ }
+ if(va == nil){
+ nerror(f, "%V: too few arguments for format '%.*s'", f, ns-fmtstart, &s[fmtstart]);
+ return;
+ }
+ ty = va->left->ty;
+ if(ty->kind == Texception)
+ ty = mkextuptype(ty);
+ switch(verb){
+ case Tint:
+ switch(ty->kind){
+ case Tstring:
+ case Tarray:
+ case Tref:
+ case Tchan:
+ case Tlist:
+ case Tmodule:
+ if(c == 'x' || c == 'X')
+ verb = ty->kind;
+ break;
+ }
+ break;
+ case Tany:
+ if(tattr[ty->kind].isptr)
+ verb = ty->kind;
+ break;
+ }
+ if(verb != ty->kind){
+ nerror(f, "%V: format '%.*s' incompatible with argument %Q", f, ns-fmtstart, &s[fmtstart], va->left);
+ return;
+ }
+ va = va->right;
+ }
+ }
+ if(va != nil)
+ nerror(f, "%V: more arguments than formats", f);
+}
+
+Decl*
+tuplefields(Node *n)
+{
+ Decl *d, *h, **last;
+
+ h = nil;
+ last = &h;
+ for(; n != nil; n = n->right){
+ d = mkdecl(&n->left->src, Dfield, n->left->ty);
+ *last = d;
+ last = &d->next;
+ }
+ return h;
+}
+
+/*
+ * make explicit indices for every element in an array initializer
+ * return the maximum index
+ * sort the indices and check for duplicates
+ */
+int
+assignindices(Node *ar)
+{
+ Node *wild, *off, *size, *inits, *n, *q;
+ Type *t;
+ Case *c;
+ int amax, max, last, nlab, ok;
+
+ amax = 0x7fffffff;
+ size = dupn(0, &nosrc, ar->left);
+ if(size->ty == tint){
+ size = fold(size);
+ if(size->op == Oconst)
+ amax = size->val;
+ }
+
+ inits = ar->right;
+ max = -1;
+ last = -1;
+ t = inits->left->ty;
+ wild = nil;
+ nlab = 0;
+ ok = 1;
+ for(n = inits; n != nil; n = n->right){
+ if(!tcompat(t, n->left->ty, 0)){
+ t = tparent(t, n->left->ty);
+ if(!tcompat(t, n->left->ty, 0)){
+ nerror(n->left, "inconsistent types %T and %T and in array initializer", t, n->left->ty);
+ return -1;
+ }
+ else
+ inits->left->ty = t;
+ }
+ if(t == tany)
+ t = n->left->ty;
+
+ /*
+ * make up an index if there isn't one
+ */
+ if(n->left->left == nil)
+ n->left->left = mkn(Oseq, mkconst(&n->left->right->src, last + 1), nil);
+
+ for(q = n->left->left; q != nil; q = q->right){
+ off = q->left;
+ if(off->ty != tint){
+ nerror(off, "array index %Q is not an int", off);
+ ok = 0;
+ continue;
+ }
+ off = fold(off);
+ switch(off->op){
+ case Owild:
+ if(wild != nil)
+ nerror(off, "array index * duplicated on line %L", wild->src.start);
+ wild = off;
+ continue;
+ case Orange:
+ if(off->left->op != Oconst || off->right->op != Oconst){
+ nerror(off, "range %V is not constant", off);
+ off = nil;
+ }else if(off->left->val < 0 || off->right->val >= amax){
+ nerror(off, "array index %V out of bounds", off);
+ off = nil;
+ }else
+ last = off->right->val;
+ break;
+ case Oconst:
+ last = off->val;
+ if(off->val < 0 || off->val >= amax){
+ nerror(off, "array index %V out of bounds", off);
+ off = nil;
+ }
+ break;
+ case Onothing:
+ /* get here from a syntax error */
+ off = nil;
+ break;
+ default:
+ nerror(off, "array index %V is not constant", off);
+ off = nil;
+ break;
+ }
+
+ nlab++;
+ if(off == nil){
+ off = mkconst(&n->left->right->src, last);
+ ok = 0;
+ }
+ if(last > max)
+ max = last;
+ q->left = off;
+ }
+ }
+
+ /*
+ * fix up types of nil elements
+ */
+ for(n = inits; n != nil; n = n->right)
+ if(n->left->ty == tany)
+ n->left->ty = t;
+
+ if(!ok)
+ return -1;
+
+
+ c = checklabels(inits, tint, nlab, "array index");
+ t = mktype(&inits->src.start, &inits->src.stop, Tainit, nil, nil);
+ inits->ty = t;
+ t->cse = c;
+
+ return max + 1;
+}
+
+/*
+ * check the labels of a case statment
+ */
+void
+casecheck(Node *cn, Type *ret)
+{
+ Node *n, *q, *wild, *left, *arg;
+ Type *t;
+ Case *c;
+ Ok rok;
+ int nlab, ok, op;
+
+ rok = echeck(cn->left, 0, 0, nil);
+ cn->right = scheck(cn->right, ret, Sother);
+ if(!rok.ok)
+ return;
+ arg = cn->left;
+
+ t = arg->ty;
+ if(t != tint && t != tbig && t != tstring){
+ nerror(cn, "case argument %Q is not an int or big or string", arg);
+ return;
+ }
+
+ wild = nil;
+ nlab= 0;
+ ok = 1;
+ for(n = cn->right; n != nil; n = n->right){
+ q = n->left->left;
+ if(n->left->right->right == nil)
+ nwarn(q, "no body for case qualifier %V", q);
+ for(; q != nil; q = q->right){
+ left = fold(q->left);
+ q->left = left;
+ switch(left->op){
+ case Owild:
+ if(wild != nil)
+ nerror(left, "case qualifier * duplicated on line %L", wild->src.start);
+ wild = left;
+ break;
+ case Orange:
+ if(left->ty != t)
+ nerror(left, "case qualifier %Q clashes with %Q", left, arg);
+ else if(left->left->op != Oconst || left->right->op != Oconst){
+ nerror(left, "case range %V is not constant", left);
+ ok = 0;
+ }
+ nlab++;
+ break;
+ default:
+ if(left->ty != t){
+ nerror(left, "case qualifier %Q clashes with %Q", left, arg);
+ ok = 0;
+ }else if(left->op != Oconst){
+ nerror(left, "case qualifier %V is not constant", left);
+ ok = 0;
+ }
+ nlab++;
+ break;
+ }
+ }
+ }
+
+ if(!ok)
+ return;
+
+ c = checklabels(cn->right, t, nlab, "case qualifier");
+ op = Tcase;
+ if(t == tbig)
+ op = Tcasel;
+ else if(t == tstring)
+ op = Tcasec;
+ t = mktype(&cn->src.start, &cn->src.stop, op, nil, nil);
+ cn->ty = t;
+ t->cse = c;
+}
+
+/*
+ * check the labels and bodies of a pick statment
+ */
+void
+pickcheck(Node *n, Type *ret)
+{
+ Node *w, *arg, *qs, *q, *qt, *left, **tags;
+ Decl *id, *d;
+ Type *t, *argty;
+ Case *c;
+ Ok rok;
+ int ok, nlab;
+
+ arg = n->left->right;
+ rok = echeck(arg, 0, 0, nil);
+ if(!rok.allok)
+ return;
+ t = arg->ty;
+ if(t->kind == Tref)
+ t = t->tof;
+ if(arg->ty->kind != Tref || t->kind != Tadt || t->tags == nil){
+ nerror(arg, "pick argument %Q is not a ref adt with pick tags", arg);
+ return;
+ }
+ argty = usetype(mktype(&arg->ty->src.start, &arg->ty->src.stop, Tref, t, nil));
+
+ arg = n->left->left;
+ pushscope(nil, Sother);
+ dasdecl(arg);
+ arg->decl->ty = argty;
+ arg->ty = argty;
+
+ tags = allocmem(t->decl->tag * sizeof *tags);
+ memset(tags, 0, t->decl->tag * sizeof *tags);
+ w = nil;
+ ok = 1;
+ nlab = 0;
+ for(qs = n->right; qs != nil; qs = qs->right){
+ qt = nil;
+ for(q = qs->left->left; q != nil; q = q->right){
+ left = q->left;
+ switch(left->op){
+ case Owild:
+ /* left->ty = tnone; */
+ left->ty = t;
+ if(w != nil)
+ nerror(left, "pick qualifier * duplicated on line %L", w->src.start);
+ w = left;
+ break;
+ case Oname:
+ id = namedot(t->tags, left->decl->sym);
+ if(id == nil){
+ nerror(left, "pick qualifier %V is not a member of %Q", left, arg);
+ ok = 0;
+ continue;
+ }
+
+ left->decl = id;
+ left->ty = id->ty;
+
+ if(tags[id->tag] != nil){
+ nerror(left, "pick qualifier %V duplicated on line %L",
+ left, tags[id->tag]->src.start);
+ ok = 0;
+ }
+ tags[id->tag] = left;
+ nlab++;
+ break;
+ default:
+ fatal("pickcheck can't handle %n", q);
+ break;
+ }
+
+ if(qt == nil)
+ qt = left;
+ else if(!tequal(qt->ty, left->ty))
+ nerror(left, "type clash in pick qualifiers %Q and %Q", qt, left);
+ }
+
+ argty->tof = t;
+ if(qt != nil)
+ argty->tof = qt->ty;
+ qs->left->right = scheck(qs->left->right, ret, Sother);
+ if(qs->left->right == nil)
+ nwarn(qs->left->left, "no body for pick qualifier %V", qs->left->left);
+ }
+ argty->tof = t;
+ for(qs = n->right; qs != nil; qs = qs->right)
+ for(q = qs->left->left; q != nil; q = q->right)
+ q->left = fold(q->left);
+
+ d = popscope();
+ d->refs++;
+ if(d->next != nil)
+ fatal("pickcheck: installing more than one id");
+ fndecls = appdecls(fndecls, d);
+
+ if(!ok)
+ return;
+
+ c = checklabels(n->right, tint, nlab, "pick qualifier");
+ t = mktype(&n->src.start, &n->src.stop, Tcase, nil, nil);
+ n->ty = t;
+ t->cse = c;
+}
+
+void
+exccheck(Node *en, Type *ret)
+{
+ Decl *ed;
+ Node *n, *q, *wild, *left, *oinexcept;
+ Type *t, *qt;
+ Case *c;
+ int nlab, ok;
+ Ok rok;
+ char buf[32];
+ static int nexc;
+
+ pushscope(nil, Sother);
+ if(en->left == nil){
+ seprint(buf, buf+sizeof(buf), ".ex%d", nexc++);
+ en->left = mkdeclname(&en->src, mkids(&en->src, enter(buf, 0), texception, nil));
+ }
+ oinexcept = inexcept;
+ inexcept = en->left;
+ dasdecl(en->left);
+ en->left->ty = en->left->decl->ty = texception;
+ ed = en->left->decl;
+ /* en->right = scheck(en->right, ret, Sother); */
+ t = tstring;
+ wild = nil;
+ nlab = 0;
+ ok = 1;
+ for(n = en->right; n != nil; n = n->right){
+ qt = nil;
+ for(q = n->left->left; q != nil; q = q->right){
+ left = q->left;
+ switch(left->op){
+ case Owild:
+ left->ty = texception;
+ if(wild != nil)
+ nerror(left, "exception qualifier * duplicated on line %L", wild->src.start);
+ wild = left;
+ break;
+ case Orange:
+ left->ty = tnone;
+ nerror(left, "exception qualifier %V is illegal", left);
+ ok = 0;
+ break;
+ default:
+ rok = echeck(left, 0, 0, nil);
+ if(!rok.ok){
+ ok = 0;
+ break;
+ }
+ left = q->left = fold(left);
+ if(left->ty != t && left->ty->kind != Texception){
+ nerror(left, "exception qualifier %Q is not a string or exception", left);
+ ok = 0;
+ }else if(left->op != Oconst){
+ nerror(left, "exception qualifier %V is not constant", left);
+ ok = 0;
+ }
+ else if(left->ty != t)
+ left->ty = mkextype(left->ty);
+ nlab++;
+ break;
+ }
+
+ if(qt == nil)
+ qt = left->ty;
+ else if(!tequal(qt, left->ty))
+ qt = texception;
+ }
+
+ if(qt != nil)
+ ed->ty = qt;
+ n->left->right = scheck(n->left->right, ret, Sother);
+ if(n->left->right->right == nil)
+ nwarn(n->left->left, "no body for exception qualifier %V", n->left->left);
+ }
+ ed->ty = texception;
+ inexcept = oinexcept;
+ if(!ok)
+ return;
+ c = checklabels(en->right, texception, nlab, "exception qualifier");
+ t = mktype(&en->src.start, &en->src.stop, Texcept, nil, nil);
+ en->ty = t;
+ t->cse = c;
+ ed = popscope();
+ fndecls = appdecls(fndecls, ed);
+}
+
+/*
+ * check array and case labels for validity
+ */
+Case *
+checklabels(Node *inits, Type *ctype, int nlab, char *title)
+{
+ Node *n, *p, *q, *wild;
+ Label *labs, *aux;
+ Case *c;
+ char buf[256], buf1[256];
+ int i, e;
+
+ labs = allocmem(nlab * sizeof *labs);
+ i = 0;
+ wild = nil;
+ for(n = inits; n != nil; n = n->right){
+ for(q = n->left->left; q != nil; q = q->right){
+ switch(q->left->op){
+ case Oconst:
+ labs[i].start = q->left;
+ labs[i].stop = q->left;
+ labs[i++].node = n->left;
+ break;
+ case Orange:
+ labs[i].start = q->left->left;
+ labs[i].stop = q->left->right;
+ labs[i++].node = n->left;
+ break;
+ case Owild:
+ wild = n->left;
+ break;
+ default:
+ fatal("bogus index in checklabels");
+ break;
+ }
+ }
+ }
+
+ if(i != nlab)
+ fatal("bad label count: %d then %d", nlab, i);
+
+ aux = allocmem(nlab * sizeof *aux);
+ casesort(ctype, aux, labs, 0, nlab);
+ for(i = 0; i < nlab; i++){
+ p = labs[i].stop;
+ if(casecmp(ctype, labs[i].start, p) > 0)
+ nerror(labs[i].start, "unmatchable %s %V", title, labs[i].node);
+ for(e = i + 1; e < nlab; e++){
+ if(casecmp(ctype, labs[e].start, p) <= 0){
+ eprintlist(buf, buf+sizeof(buf), labs[e].node->left, " or ");
+ eprintlist(buf1, buf1+sizeof(buf1), labs[e-1].node->left, " or ");
+ nerror(labs[e].start,"%s '%s' overlaps with '%s' on line %L",
+ title, buf, buf1, p->src.start);
+ }
+
+ /*
+ * check for merging case labels
+ */
+ if(ctype != tint
+ || labs[e].start->val != p->val+1
+ || labs[e].node != labs[i].node)
+ break;
+ p = labs[e].stop;
+ }
+ if(e != i + 1){
+ labs[i].stop = p;
+ memmove(&labs[i+1], &labs[e], (nlab-e) * sizeof *labs);
+ nlab -= e - (i + 1);
+ }
+ }
+ free(aux);
+
+ c = allocmem(sizeof *c);
+ c->nlab = nlab;
+ c->nsnd = 0;
+ c->labs = labs;
+ c->wild = wild;
+
+ return c;
+}
+
+static int
+matchcmp(Node *na, Node *nb)
+{
+ Sym *a, *b;
+ int sa, sb;
+
+ a = na->decl->sym;
+ b = nb->decl->sym;
+ sa = a->len > 0 && a->name[a->len-1] == '*';
+ sb = b->len > 0 && b->name[b->len-1] == '*';
+ if(sa){
+ if(sb){
+ if(a->len == b->len)
+ return symcmp(a, b);
+ return b->len-a->len;
+ }
+ else
+ return 1;
+ }
+ else{
+ if(sb)
+ return -1;
+ else{
+ if(na->ty == tstring){
+ if(nb->ty == tstring)
+ return symcmp(a, b);
+ else
+ return 1;
+ }
+ else{
+ if(nb->ty == tstring)
+ return -1;
+ else
+ return symcmp(a, b);
+ }
+ }
+ }
+}
+
+int
+casecmp(Type *ty, Node *a, Node *b)
+{
+ if(ty == tint || ty == tbig){
+ if(a->val < b->val)
+ return -1;
+ if(a->val > b->val)
+ return 1;
+ return 0;
+ }
+ if(ty == texception)
+ return matchcmp(a, b);
+ return symcmp(a->decl->sym, b->decl->sym);
+}
+
+void
+casesort(Type *t, Label *aux, Label *labs, int start, int stop)
+{
+ int n, top, mid, base;
+
+ n = stop - start;
+ if(n <= 1)
+ return;
+ top = mid = start + n / 2;
+
+ casesort(t, aux, labs, start, top);
+ casesort(t, aux, labs, mid, stop);
+
+ /*
+ * merge together two sorted label arrays, yielding a sorted array
+ */
+ n = 0;
+ base = start;
+ while(base < top && mid < stop){
+ if(casecmp(t, labs[base].start, labs[mid].start) <= 0)
+ aux[n++] = labs[base++];
+ else
+ aux[n++] = labs[mid++];
+ }
+ if(base < top)
+ memmove(&aux[n], &labs[base], (top-base) * sizeof *aux);
+ else if(mid < stop)
+ memmove(&aux[n], &labs[mid], (stop-mid) * sizeof *aux);
+ memmove(&labs[start], &aux[0], (stop-start) * sizeof *labs);
+}
+
+/*
+ * binary search for the label corresponding to a given value
+ */
+int
+findlab(Type *ty, Node *v, Label *labs, int nlab)
+{
+ int l, r, m;
+
+ if(nlab <= 1)
+ return 0;
+ l = 1;
+ r = nlab - 1;
+ while(l <= r){
+ m = (r + l) / 2;
+ if(casecmp(ty, labs[m].start, v) <= 0)
+ l = m + 1;
+ else
+ r = m - 1;
+ }
+ m = l - 1;
+ if(casecmp(ty, labs[m].start, v) > 0
+ || casecmp(ty, labs[m].stop, v) < 0)
+ fatal("findlab out of range");
+ return m;
+}
+
+void
+altcheck(Node *an, Type *ret)
+{
+ Node *n, *q, *left, *op, *wild;
+ Case *c;
+ int ok, nsnd, nrcv;
+
+ an->left = scheck(an->left, ret, Sother);
+
+ ok = 1;
+ nsnd = 0;
+ nrcv = 0;
+ wild = nil;
+ for(n = an->left; n != nil; n = n->right){
+ q = n->left->right->left;
+ if(n->left->right->right == nil)
+ nwarn(q, "no body for alt guard %V", q);
+ for(; q != nil; q = q->right){
+ left = q->left;
+ switch(left->op){
+ case Owild:
+ if(wild != nil)
+ nerror(left, "alt guard * duplicated on line %L", wild->src.start);
+ wild = left;
+ break;
+ case Orange:
+ nerror(left, "alt guard %V is illegal", left);
+ ok = 0;
+ break;
+ default:
+ op = hascomm(left);
+ if(op == nil){
+ nerror(left, "alt guard %V has no communication", left);
+ ok = 0;
+ break;
+ }
+ if(op->op == Osnd)
+ nsnd++;
+ else
+ nrcv++;
+ break;
+ }
+ }
+ }
+
+ if(!ok)
+ return;
+
+ c = allocmem(sizeof *c);
+ c->nlab = nsnd + nrcv;
+ c->nsnd = nsnd;
+ c->wild = wild;
+
+ an->ty = mktalt(c);
+}
+
+Node*
+hascomm(Node *n)
+{
+ Node *r;
+
+ if(n == nil)
+ return nil;
+ if(n->op == Osnd || n->op == Orcv)
+ return n;
+ r = hascomm(n->left);
+ if(r != nil)
+ return r;
+ return hascomm(n->right);
+}
+
+void
+raisescheck(Type *t)
+{
+ Node *n, *nn;
+ Ok ok;
+
+ if(t->kind != Tfn)
+ return;
+ n = t->u.eraises;
+ for(nn = n->left; nn != nil; nn = nn->right){
+ ok = echeck(nn->left, 0, 0, nil);
+ if(ok.ok && nn->left->ty->kind != Texception)
+ nerror(n, "%V: illegal raises expression", nn->left);
+ }
+}
+
+typedef struct Elist Elist;
+
+struct Elist{
+ Decl *d;
+ Elist *nxt;
+};
+
+static Elist*
+emerge(Elist *el1, Elist *el2)
+{
+ int f;
+ Elist *el, *nxt;
+
+ for( ; el1 != nil; el1 = nxt){
+ f = 0;
+ for(el = el2; el != nil; el = el->nxt){
+ if(el1->d == el->d){
+ f = 1;
+ break;
+ }
+ }
+ nxt = el1->nxt;
+ if(!f){
+ el1->nxt = el2;
+ el2 = el1;
+ }
+ }
+ return el2;
+}
+
+static Elist*
+equals(Node *n)
+{
+ Node *q, *nn;
+ Elist *e, *el;
+
+ el = nil;
+ for(q = n->left->left; q != nil; q = q->right){
+ nn = q->left;
+ if(nn->op == Owild)
+ return nil;
+ if(nn->ty->kind != Texception)
+ continue;
+ e = (Elist*)malloc(sizeof(Elist));
+ e->d = nn->decl;
+ e->nxt = el;
+ el = e;
+ }
+ return el;
+}
+
+static int
+caught(Decl *d, Node *n)
+{
+ Node *q, *nn;
+
+ for(n = n->right; n != nil; n = n->right){
+ for(q = n->left->left; q != nil; q = q->right){
+ nn = q->left;
+ if(nn->op == Owild)
+ return 1;
+ if(nn->ty->kind != Texception)
+ continue;
+ if(d == nn->decl)
+ return 1;
+ }
+ }
+ return 0;
+}
+
+static Elist*
+raisecheck(Node *n, Elist *ql)
+{
+ int exc;
+ Node *e;
+ Elist *el, *nel, *nxt;
+
+ if(n == nil)
+ return nil;
+ el = nil;
+ for(; n != nil; n = n->right){
+ switch(n->op){
+ case Oscope:
+ return raisecheck(n->right, ql);
+ case Olabel:
+ case Odo:
+ return raisecheck(n->right, ql);
+ case Oif:
+ case Ofor:
+ return emerge(raisecheck(n->right->left, ql),
+ raisecheck(n->right->right, ql));
+ case Oalt:
+ case Ocase:
+ case Opick:
+ case Oexcept:
+ exc = n->op == Oexcept;
+ for(n = n->right; n != nil; n = n->right){
+ ql = nil;
+ if(exc)
+ ql = equals(n);
+ el = emerge(raisecheck(n->left->right, ql), el);
+ }
+ return el;
+ case Oseq:
+ el = emerge(raisecheck(n->left, ql), el);
+ break;
+ case Oexstmt:
+ el = raisecheck(n->left, ql);
+ nel = nil;
+ for( ; el != nil; el = nxt){
+ nxt = el->nxt;
+ if(!caught(el->d, n->right)){
+ el->nxt = nel;
+ nel = el;
+ }
+ }
+ return emerge(nel, raisecheck(n->right, ql));
+ case Oraise:
+ e = n->left;
+ if(e->ty && e->ty->kind == Texception){
+ if(!e->ty->cons)
+ return ql;
+ if(e->op == Ocall)
+ e = e->left;
+ if(e->op == Omdot)
+ e = e->right;
+ if(e->op != Oname)
+ fatal("exception %n not a name", e);
+ el = (Elist*)malloc(sizeof(Elist));
+ el->d = e->decl;
+ el->nxt = nil;
+ return el;
+ }
+ return nil;
+ default:
+ return nil;
+ }
+ }
+ return el;
+}
+
+void
+checkraises(Node *n)
+{
+ int f;
+ Decl *d;
+ Elist *e, *el;
+ Node *es, *nn;
+
+ el = raisecheck(n->right, nil);
+ es = n->ty->u.eraises;
+ if(es != nil){
+ for(nn = es->left; nn != nil; nn = nn->right){
+ d = nn->left->decl;
+ f = 0;
+ for(e = el; e != nil; e = e->nxt){
+ if(d == e->d){
+ f = 1;
+ e->d = nil;
+ break;
+ }
+ }
+ if(!f)
+ nwarn(n, "function %V does not raise %s but declared", n->left, d->sym->name);
+ }
+ }
+ for(e = el; e != nil; e = e->nxt)
+ if(e->d != nil)
+ nwarn(n, "function %V raises %s but not declared", n->left, e->d->sym->name);
+}
+
+/* sort all globals in modules now that we've finished with 'last' pointers
+ * and before any code generation
+ */
+void
+gsort(Node *n)
+{
+ for(;;){
+ if(n == nil)
+ return;
+ if(n->op != Oseq)
+ break;
+ gsort(n->left);
+ n = n->right;
+ }
+ if(n->op == Omoddecl && n->ty->ok & OKverify){
+ n->ty->ids = namesort(n->ty->ids);
+ sizeids(n->ty->ids, 0);
+ }
+}
generated by cgit v1.2.3 (git 2.46.0) at 2025-12-10 07:36:30 +0000