// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-
#undef EXTERN
#define EXTERN
#include "gg.h"
pl = newplist();
pl->name = curfn->nname;
- pl->locals = autodcl;
nodconst(&nod1, types[TINT32], 0);
ptxt = gins(ATEXT, curfn->nname, &nod1);
pl = newplist();
pl->name = curfn->nname;
- pl->locals = autodcl;
nodconst(&nod1, types[TINT32], 0);
ptxt = gins(ATEXT, curfn->nname, &nod1);
regfree(&ax);
regfree(&dx);
-
+
if(oldax.op != 0) {
gmove(&oldax, &ax);
regfree(&oldax);
gmove(&olddx, &dx);
regfree(&olddx);
}
-
+
}
/*
pl = newplist();
pl->name = curfn->nname;
- pl->locals = autodcl;
nodconst(&nod1, types[TINT32], 0);
ptxt = gins(ATEXT, curfn->nname, &nod1);
*a = ao;
// only generate data the first time.
- if(ao.sym->uniq)
+ if(ao.sym->flags & SymUniq)
return;
- ao.sym->uniq = 1;
+ ao.sym->flags |= SymUniq;
data();
for(w=0; w<len; w+=8) {
}
*a = ao;
- if(ao.sym->uniq)
+ if(ao.sym->flags & SymUniq)
return;
- ao.sym->uniq = 1;
+ ao.sym->flags |= SymUniq;
data();
// DATA gostring, wp, $cstring
void
dcopy(Sym *a, Sym *b)
{
+ a->package = b->package;
a->name = b->name;
a->def = b->def;
- a->package = b->package;
- a->undef = b->undef;
- a->vargen = b->vargen;
a->block = b->block;
a->lastlineno = b->lastlineno;
- a->offset = b->offset;
}
Sym*
/*
* declare individual names - var, typ, const
*/
-static void
-redeclare(char *str, Sym *s)
-{
- if(s->block == block) {
- yyerror("%s %S redeclared in this block", str, s);
- print(" previous declaration at %L\n", s->lastlineno);
- }
- s->block = block;
- s->lastlineno = lineno;
-}
-
void
-addvar(Node *n, Type *t, int ctxt)
+declare(Node *n, int ctxt)
{
- Dcl *r, *d;
Sym *s;
+ char *what;
int gen;
-
- if(n==N || n->sym == S || (n->op != ONAME && n->op != ONONAME) || t == T)
- fatal("addvar: n=%N t=%T nil", n, t);
+ static int typegen, vargen;
s = n->sym;
-
- if(ctxt == PEXTERN || ctxt == PFUNC) {
- r = externdcl;
- gen = 0;
+ gen = 0;
+ if(ctxt == PEXTERN) {
+ externdcl = list(externdcl, n);
} else {
- r = autodcl;
- vargen++;
- gen = vargen;
+ if(autodcl != nil)
+ autodcl = list(autodcl, n);
+ if(n->op == OTYPE)
+ gen = ++typegen;
+ else if(n->op == ONAME)
+ gen = ++vargen;
pushdcl(s);
}
- redeclare("variable", s);
- n->op = ONAME;
- s->vargen = gen;
- s->def = n;
- s->offset = 0;
+ if(s->block == block) {
+ what = "???";
+ switch(n->op) {
+ case ONAME:
+ what = "variable";
+ break;
+ case OLITERAL:
+ what = "constant";
+ break;
+ case OTYPE:
+ what = "type";
+ break;
+ }
- n->funcdepth = funcdepth;
- n->type = t;
+ yyerror("%s %S redeclared in this block", what, s);
+ print("\tprevious declaration at %L\n", s->lastlineno);
+ }
+ s->block = block;
+ s->lastlineno = lineno;
+ s->def = n;
n->vargen = gen;
+ n->funcdepth = funcdepth;
n->class = ctxt;
- d = dcl();
- d->dsym = s;
- d->dnode = n;
- d->op = ONAME;
-
- r->back->forw = d;
- r->back = d;
-
- if(dflag()) {
- if(ctxt == PEXTERN)
- print("extern var-dcl %S G%ld %T\n", s, s->vargen, t);
- else if(ctxt == PFUNC)
- print("extern func-dcl %S G%ld %T\n", s, s->vargen, t);
- else
- print("auto var-dcl %S G%ld %T\n", s, s->vargen, t);
- }
+ autoexport(n, ctxt);
}
void
-addtyp(Type *n, int ctxt)
+addvar(Node *n, Type *t, int ctxt)
{
- Dcl *r, *d;
- Sym *s;
- static int typgen;
-
- if(n==T || n->sym == S)
- fatal("addtyp: n=%T t=%T nil", n);
-
- s = n->sym;
-
- if(ctxt == PEXTERN)
- r = externdcl;
- else {
- r = autodcl;
- pushdcl(s);
- n->vargen = ++typgen;
- }
-
- redeclare("type", s);
- s->def = typenod(n);
-
- d = dcl();
- d->dsym = s;
- d->dtype = n;
- d->op = OTYPE;
-
- d->back = r->back;
- r->back->forw = d;
- r->back = d;
-
- d = dcl();
- d->dtype = n;
- d->op = OTYPE;
-
- r = typelist;
- d->back = r->back;
- r->back->forw = d;
- r->back = d;
+ if(n==N || n->sym == S || (n->op != ONAME && n->op != ONONAME) || t == T)
+ fatal("addvar: n=%N t=%T nil", n, t);
- if(dflag()) {
- if(ctxt == PEXTERN)
- print("extern typ-dcl %S G%ld %T\n", s, s->vargen, n);
- else
- print("auto typ-dcl %S G%ld %T\n", s, s->vargen, n);
- }
+ n->op = ONAME;
+ declare(n, ctxt);
+ n->type = t;
}
-// TODO(rsc): cut
void
-addconst(Node *n, Node *e, int ctxt)
+addtyp(Type *n, int ctxt)
{
- Sym *s;
- Dcl *r, *d;
-
- if(n->op != ONAME && n->op != ONONAME)
- fatal("addconst: not a name");
-
- if(e->op != OLITERAL) {
- yyerror("expression must be a constant");
- return;
- }
-
- s = n->sym;
+ Node *def;
- if(ctxt == PEXTERN)
- r = externdcl;
- else {
- r = autodcl;
- pushdcl(s);
- }
-
- redeclare("constant", s);
- s->def = e;
- e->sym = s;
+ if(n==T || n->sym == S)
+ fatal("addtyp: n=%T t=%T nil", n);
- d = dcl();
- d->dsym = s;
- d->dnode = e;
- d->op = OLITERAL;
- d->back = r->back;
- r->back->forw = d;
- r->back = d;
+ def = typenod(n);
+ declare(def, ctxt);
+ n->vargen = def->vargen;
- if(dflag())
- print("const-dcl %S %N\n", n->sym, n->sym->def);
+ typelist = list(typelist, def);
}
/*
t = typ(TFORW);
addvar(n, t, dclcontext);
- autoexport(n->sym);
if(funcdepth > 0)
*init = list(*init, nod(ODCL, n, N));
}
-// TODO(rsc): cut
-void
-dodclconst(Node *n, Node *e)
-{
- if(n == N)
- return;
- addconst(n, e, dclcontext);
- autoexport(n->sym);
-}
-
/*
* introduce a type named n
* but it is an unknown type for now
n = s->def->type;
if(s->block != block) {
// completing forward struct from other file
- Dcl *d, *r;
- d = dcl();
- d->dsym = s;
- d->dtype = n;
- d->op = OTYPE;
- r = externdcl;
- d->back = r->back;
- r->back->forw = d;
- r->back = d;
+ externdcl = list(externdcl, typenod(n));
}
goto found;
}
found:
n->local = 1;
- autoexport(n->sym);
+ autoexport(typenod(n), dclcontext);
return n;
}
NodeList*
variter(NodeList *vl, Node *t, NodeList *el)
{
- int doexpr, gen;
+ int doexpr;
Node *v, *e;
NodeList *init;
Sym *s;
- Dcl *r, *d;
init = nil;
doexpr = el != nil;
} else
e = N;
- v = vl->n;
+ v = vl->n;
s = v->sym;
- if(dclcontext == PEXTERN || dclcontext == PFUNC) {
- r = externdcl;
- gen = 0;
- } else {
- r = autodcl;
- gen = ++vargen;
- pushdcl(s);
- }
-
- redeclare("variable", s);
- s->def = v;
- // TODO: vargen
- s->offset = 0;
- s->block = block;
v->op = ONAME;
- v->class = dclcontext;
+ declare(v, dclcontext);
v->ntype = t;
- v->funcdepth = funcdepth;
- v->vargen = gen;
+
if(e != N || funcdepth > 0) {
if(funcdepth > 0)
init = list(init, nod(ODCL, v, N));
if(e->right != N)
v->defn = e;
}
-
- d = dcl();
- d->dsym = s;
- d->dnode = v;
- d->op = ONAME;
- r->back->forw = d;
- r->back = d;
-
- autoexport(s);
}
if(el != nil)
yyerror("extra expr in var dcl");
{
Node *v, *c;
NodeList *vv;
- Sym *s;
vv = vl;
if(cl == nil) {
cl = cl->next;
v = vl->n;
- s = v->sym;
- if(dclcontext != PEXTERN)
- pushdcl(s);
- redeclare("constant", s);
- s->def = v;
-
v->op = OLITERAL;
+ declare(v, dclcontext);
+
v->ntype = t;
v->defn = c;
- autoexport(s);
}
if(cl != nil)
yyerror("extra expr in const dcl");
}
/*
- * this generates a new name that is
- * pushed down on the declaration list.
- * no diagnostics are produced as this
- * name will soon be declared.
+ * this generates a new name node,
+ * typically for labels or other one-off names.
*/
Node*
newname(Sym *s)
return n;
}
+/*
+ * this generates a new name node for a name
+ * being declared. if at the top level, it might return
+ * an ONONAME node created by an earlier reference.
+ */
Node*
dclname(Sym *s)
{
return t;
}
-Type*
-oldtype(Sym *s)
-{
- Type *t;
-
- if(s == S)
- return T;
- if(s->def == N || s->def->op != OTYPE) {
- if(!s->undef)
- yyerror("%S is not a type", s);
- return T;
- }
- t = s->def->type;
-
- /*
- * If t is lowercase and not in our package
- * and this isn't a reference during the parsing
- * of import data, complain.
- */
- if(pkgimportname == S && !exportname(s->name) && strcmp(s->package, package) != 0)
- yyerror("cannot use type %T", t);
- return t;
-}
-
/*
* type check top level declarations
*/
void
dclchecks(void)
{
- Dcl *d;
-
- for(d=externdcl; d!=D; d=d->forw) {
- if(d->op != ONAME)
+ NodeList *l;
+
+ for(l=externdcl; l; l=l->next) {
+ if(l->n->op != ONAME)
continue;
- typecheck(&d->dnode, Erv);
+ typecheck(&l->n, Erv);
}
}
}
// change the declaration context from extern to auto
- autodcl = dcl();
- autodcl->back = autodcl;
+ autodcl = list1(nod(OXXX, N, N));
if(funcdepth == 0 && dclcontext != PEXTERN)
fatal("funchdr: dclcontext");
funclit = n;
// new declaration context
- autodcl = dcl();
- autodcl->back = autodcl;
+ autodcl = list1(nod(OEMPTY, N, N));
typecheck(&t, Etype);
funcargs(t->type);
Iter save;
int narg, shift;
NodeList *args, *l, *in, *out;
+ static int closgen;
type = ntype->type;
popdcl();
ft->outnamed = type->outnamed;
// declare function.
- vargen++;
- snprint(namebuf, sizeof(namebuf), "_f%.3ld·%s", vargen, filename);
+ snprint(namebuf, sizeof(namebuf), "_f%.3ld·%s", ++closgen, filename);
f = newname(lookup(namebuf));
addvar(f, ft, PFUNC);
f->funcdepth = 0;
void dumpsym(Sym*);
void
-addexportsym(Sym *s)
+addexportsym(Node *n)
{
- Dcl *d, *r;
-
- d = mal(sizeof(*d));
- d->dsym = s;
- d->dnode = N;
- d->lineno = lineno;
-
- r = exportlist;
- d->back = r->back;
- r->back->forw = d;
- r->back = d;
+ exportlist = list(exportlist, n);
}
void
-exportsym(Sym *s)
+exportsym(Node *n)
{
- if(s == S)
+ if(n == N || n->sym == S)
return;
- if(s->export != 0) {
- if(s->export != 1)
- yyerror("export/package mismatch: %S", s);
+ if(n->sym->flags & (SymExport|SymPackage)) {
+ if(n->sym->flags & SymPackage)
+ yyerror("export/package mismatch: %S", n->sym);
return;
}
- s->export = 1;
+ n->sym->flags |= SymExport;
- addexportsym(s);
+ addexportsym(n);
}
void
-packagesym(Sym *s)
+packagesym(Node *n)
{
- if(s == S)
+ if(n == N || n->sym == S)
return;
- if(s->export != 0) {
- if(s->export != 2)
- yyerror("export/package mismatch: %S", s);
+ if(n->sym->flags & (SymExport|SymPackage)) {
+ if(n->sym->flags & SymExport)
+ yyerror("export/package mismatch: %S", n->sym);
return;
}
- s->export = 2;
+ n->sym->flags |= SymPackage;
- addexportsym(s);
+ addexportsym(n);
}
int
}
void
-autoexport(Sym *s)
+autoexport(Node *n, int ctxt)
{
- if(s == S)
+ if(n == N || n->sym == S)
return;
- if(dclcontext != PEXTERN)
+ if((ctxt != PEXTERN && ctxt != PFUNC) || dclcontext != PEXTERN)
return;
- if(exportname(s->name)) {
- exportsym(s);
- } else {
- packagesym(s);
- }
+ if(exportname(n->sym->name) || strcmp(n->sym->name, "init") == 0)
+ exportsym(n);
+ else
+ packagesym(n);
}
void
{
Type *f, *t;
- if(s->exported != 0)
+ if(s->flags & SymExported)
return;
- s->exported = 1;
+ s->flags |= SymExported;
if(s->def == N) {
yyerror("unknown export symbol: %S", s);
void
dumpexport(void)
{
- Dcl *d;
+ NodeList *l;
int32 lno;
lno = lineno;
Bprint(bout, " package %s\n", package);
- for(d=exportlist->forw; d!=D; d=d->forw) {
- lineno = d->lineno;
- dumpsym(d->dsym);
+ for(l=exportlist; l; l=l->next) {
+ lineno = l->n->lineno;
+ dumpsym(l->n->sym);
}
Bprint(bout, "\n$$ // local types\n");
- for(d=typelist->forw; d!=D; d=d->forw) {
- lineno = d->lineno;
- dumptype(d->dtype);
+ for(l=typelist; l; l=l->next) {
+ lineno = l->n->lineno;
+ dumptype(l->n->type);
}
Bprint(bout, "\n$$\n");
// mark the symbol so it is not reexported
if(s->def == N) {
if(exportname(s->name))
- s->export = 1;
+ s->flags |= SymExport;
else
- s->export = 2; // package scope
- s->imported = 1;
+ s->flags |= SymPackage; // package scope
+ s->flags |= SymImported;
}
return s;
}
return;
}
- dodclconst(newname(s), n);
+ if(n->op != OLITERAL) {
+ yyerror("expression must be a constant");
+ return;
+ }
+ n->sym = s;
+ declare(n, PEXTERN);
if(debug['E'])
print("import const %S\n", s);
void
importvar(Sym *s, Type *t, int ctxt)
{
+ Node *n;
+
if(!exportname(s->name) && !mypackage(s))
return;
s, s->def->type, t);
}
checkwidth(t);
- addvar(newname(s), t, ctxt);
+ n = newname(s);
+ n->type = t;
+ declare(n, ctxt);
if(debug['E'])
print("import var %S %lT\n", s, t);
case TFORWINTER:
case TFORWSTRUCT:
// allow re-export in case it gets defined
- s->export = 0;
- s->imported = 0;
+ s->flags &= ~(SymExport|SymPackage);
+ s->flags &= ~SymImported;
break;
default:
checkwidth(n->type);
void
allocparams(void)
{
- Dcl *d;
+ NodeList *l;
Node *n;
uint32 w;
* slots for all automatics.
* allocated starting at -w down.
*/
- for(d=autodcl; d!=D; d=d->forw) {
- if(d->op != ONAME)
+ for(l=autodcl; l; l=l->next) {
+ n = l->n;
+ if(n->op != ONAME || n->class != PAUTO)
continue;
-
- n = d->dnode;
- if(n->class != PAUTO)
- continue;
-
typecheck(&n, Erv);
dowidth(n->type);
w = n->type->width;
typedef struct Node Node;
typedef struct NodeList NodeList;
typedef struct Type Type;
-typedef struct Dcl Dcl;
struct Type
{
NodeList* enter;
NodeList* exit;
NodeList* cvars; // closure params
- Dcl* dcl; // outer autodcl
+ NodeList* dcl; // outer autodcl
// OLITERAL/OREGISTER
Val val;
NodeList* end;
};
-struct Sym
+enum
{
- ushort block; // blocknumber to catch redeclaration
+ SymExport = 1<<0,
+ SymPackage = 1<<1,
+ SymExported = 1<<2,
+ SymImported = 1<<3,
+ SymUniq = 1<<4,
+ SymSiggen = 1<<5,
+};
- uchar undef; // a diagnostic has been generated
- uchar export; // marked as export
- uchar exported; // exported
- uchar imported; // imported
+struct Sym
+{
+ ushort lexical;
+ uchar flags;
uchar sym; // huffman encoding in object file
- uchar uniq; // imbedded field name first found
- uchar siggen; // signature generated
+ Sym* link;
+ // saved and restored by dcopy
char* package; // package name
char* name; // variable name
Node* def; // definition: ONAME OTYPE OPACK or OLITERAL
- vlong offset; // stack location if automatic
- int32 lexical;
- int32 vargen; // unique variable number
+ int32 block; // blocknumber to catch redeclaration
int32 lastlineno; // last declaration for diagnostic
- Sym* link;
};
#define S ((Sym*)0)
-struct Dcl
-{
- uchar op;
- ushort block;
- int32 lineno;
-
- Sym* dsym; // for printing only
- Node* dnode; // oname
- Type* dtype; // otype
-
- Dcl* forw;
- Dcl* back; // sentinel has pointer to last
-};
-#define D ((Dcl*)0)
-
typedef struct Iter Iter;
struct Iter
{
EXTERN Mpflt* minfltval[NTYPE];
EXTERN Mpflt* maxfltval[NTYPE];
-EXTERN Dcl* autodcl;
-EXTERN Dcl* paramdcl;
-EXTERN Dcl* externdcl;
-EXTERN Dcl* exportlist;
-EXTERN Dcl* signatlist;
-EXTERN Dcl* typelist;
+EXTERN NodeList* autodcl;
+EXTERN NodeList* externdcl;
+EXTERN NodeList* exportlist;
+EXTERN NodeList* typelist;
EXTERN int dclcontext; // PEXTERN/PAUTO
-EXTERN int importflag;
EXTERN int inimportsys;
EXTERN int initflag; // compiling the init fn
EXTERN int statuniqgen; // name generator for static temps
EXTERN uint32 iota;
EXTERN NodeList* lastconst;
EXTERN Node* lasttype;
-EXTERN int32 vargen;
-EXTERN int32 exportgen;
EXTERN int32 maxarg;
EXTERN int32 stksize; // stack size for current frame
EXTERN int32 initstksize; // stack size for init function
-EXTERN ushort blockgen; // max block number
-EXTERN ushort block; // current block number
+EXTERN int32 blockgen; // max block number
+EXTERN int32 block; // current block number
EXTERN int hasdefer; // flag that curfn has defer statetment
EXTERN Node* curfn;
EXTERN int maxround;
EXTERN int widthptr;
-EXTERN Node* retnil;
-
EXTERN Node* typeswvar;
EXTERN char* structpkg;
Node* nod(int, Node*, Node*);
Node* nodlit(Val);
Type* typ(int);
-Dcl* dcl(void);
int algtype(Type*);
void dodump(Node*, int);
void dump(char*, Node*);
/*
* dcl.c
*/
+void declare(Node*, int);
void dodclvar(Node*, Type*, NodeList**);
Type* dodcltype(Type*);
void updatetype(Type*, Type*);
-void dodclconst(Node*, Node*);
void defaultlit(Node**, Type*);
void defaultlit2(Node**, Node**, int);
int structcount(Type*);
* export.c
*/
void renameimports(void);
-void autoexport(Sym*);
+void autoexport(Node*, int);
int exportname(char*);
-void exportsym(Sym*);
-void packagesym(Sym*);
+void exportsym(Node*);
+void packagesym(Node*);
void dumpe(Sym*);
void dumpexport(void);
void dumpexporttype(Sym*);
struct Plist
{
Node* name;
- Dcl* locals;
Prog* firstpc;
int recur;
Plist* link;
| xfndcl
{
if($1 != N && $1->nname != N && $1->type->thistuple == 0)
- autoexport($1->nname->sym);
+ autoexport($1->nname, dclcontext);
$$ = nil;
}
| ';'
}
| LNAME
{
- $$ = oldtype($1);
+ // predefined name like uint8
+ if($1->def == N || $1->def->op != OTYPE) {
+ yyerror("%S is not a type", $1);
+ $$ = T;
+ } else
+ $$ = $1->def->type;
}
| '[' ']' hidden_type
{
a = nod(ORETURN, N, N);
r = list(r, a);
- exportsym(fn->nname->sym);
+ exportsym(fn->nname);
fn->nbody = r;
//dump("b", fn);
curio.peekc = 0;
curio.peekc1 = 0;
- externdcl = mal(sizeof(*externdcl));
- externdcl->back = externdcl;
dclcontext = PEXTERN;
- exportlist = mal(sizeof(*exportlist));
- exportlist->back = exportlist;
-
- typelist = mal(sizeof(*typelist));
- typelist->back = typelist;
-
nerrors = 0;
yyparse();
runifacechecks();
void
dumpglobls(void)
{
- Dcl *d;
- Sym *s;
Node *n;
+ NodeList *l;
// add globals
- for(d=externdcl; d!=D; d=d->forw) {
- if(d->op != ONAME)
+ for(l=externdcl; l; l=l->next) {
+ n = l->n;
+ if(n->op != ONAME)
continue;
- s = d->dsym;
- if(s == S)
- fatal("external nil");
- n = d->dnode;
- if(n == N || n->type == T)
- fatal("external %S nil\n", s);
-
+ if(n->type == T)
+ fatal("external %#N nil type\n", n);
if(n->class == PFUNC)
continue;
-
dowidth(n->type);
- ggloblnod(s->def, n->type->width);
+
+ // TODO(rsc): why is this not s/n->sym->def/n/ ?
+ ggloblnod(n->sym->def, n->type->width);
}
}
* runtime interface and reflection data structures
*/
-static Sym* dtypesym(Type*);
+static NodeList* signatlist;
+static Sym* dtypesym(Type*);
static int
sigcmp(Sig *a, Sig *b)
a->tsym = methodsym(method, t);
a->type = methodfunc(f);
- if(!a->isym->siggen) {
- a->isym->siggen = 1;
+ if(!(a->isym->flags & SymSiggen)) {
+ a->isym->flags |= SymSiggen;
if(!eqtype(this, it)) {
if(oldlist == nil)
oldlist = pc;
}
}
- if(!a->tsym->siggen) {
- a->tsym->siggen = 1;
+ if(!(a->tsym->flags & SymSiggen)) {
+ a->tsym->flags |= SymSiggen;
if(!eqtype(this, t)) {
if(oldlist == nil)
oldlist = pc;
{
Sym *s;
Node *n;
- Dcl *d;
s = typesym(t);
if(s->def == N) {
n->xoffset = 0;
s->def = n;
- // copy to signatlist
- d = dcl();
- d->dsym = s;
- d->dtype = t;
- d->op = OTYPE;
- d->forw = signatlist;
- signatlist = d;
+ signatlist = list(signatlist, typenod(t));
}
n = nod(OADDR, s->def, N);
Type *t1;
s = typesym(t);
- if(s->siggen)
+ if(s->flags & SymSiggen)
return s;
- s->siggen = 1;
+ s->flags |= SymSiggen;
// special case (look for runtime below):
// when compiling package runtime,
dumptypestructs(void)
{
int i;
- Dcl *d, *x;
+ NodeList *l;
+ Node *n;
Type *t;
// copy types from externdcl list to signatlist
- for(d=externdcl; d!=D; d=d->forw) {
- if(d->op != OTYPE)
+ for(l=externdcl; l; l=l->next) {
+ n = l->n;
+ if(n->op != OTYPE)
continue;
- t = d->dtype;
- x = mal(sizeof(*x));
- x->op = OTYPE;
- x->dtype = t;
- x->forw = signatlist;
- x->block = 0;
- signatlist = x;
+ signatlist = list(signatlist, n);
}
// process signatlist
- for(d=signatlist; d!=D; d=d->forw) {
- if(d->op != OTYPE)
+ for(l=signatlist; l; l=l->next) {
+ n = l->n;
+ if(n->op != OTYPE)
continue;
- t = d->dtype;
+ t = n->type;
dtypesym(t);
if(t->sym && !isptr[t->etype])
dtypesym(ptrto(t));
return p;
}
-Dcl*
-dcl(void)
-{
- Dcl *d;
-
- d = mal(sizeof(*d));
- d->lineno = lineno;
- return d;
-}
-
extern int yychar;
Node*
nod(int op, Node *nleft, Node *nright)
fmtprint(fp, "%lS", s);
if(strcmp(s->package, package) != 0)
return 0;
- if(s->imported)
+ if(s->flags & SymImported)
return 0;
- if(t->vargen || !s->export) {
+ if(t->vargen || !(s->flags & (SymExport|SymPackage))) {
fmtprint(fp, "·%s", filename);
if(t->vargen)
fmtprint(fp, "·%d", t->vargen);
break;
}
fmtprint(fp, "%O-%S G%ld%J", n->op,
- n->sym, n->sym->vargen, n);
+ n->sym, n->vargen, n);
goto ptyp;
case OREGISTER:
break;
}
if(n->sym != S)
- fmtprint(fp, " %S G%ld", n->sym, n->sym->vargen);
+ fmtprint(fp, " %S G%ld", n->sym, n->vargen);
ptyp:
if(n->type != T)
frame(int context)
{
char *p;
- Dcl *d;
+ NodeList *l;
+ Node *n;
int flag;
p = "stack";
- d = autodcl;
+ l = autodcl;
if(context) {
p = "external";
- d = externdcl;
+ l = externdcl;
}
flag = 1;
- for(; d!=D; d=d->forw) {
- switch(d->op) {
+ for(; l; l=l->next) {
+ n = l->n;
+ switch(n->op) {
case ONAME:
if(flag)
print("--- %s frame ---\n", p);
- print("%O %S G%ld T\n", d->op, d->dsym, d->dnode->vargen, d->dnode->type);
+ print("%O %S G%ld T\n", n->op, n->sym, n->vargen, n->type);
flag = 0;
break;
case OTYPE:
if(flag)
print("--- %s frame ---\n", p);
- print("%O %T\n", d->op, d->dnode);
+ print("%O %T\n", n->op, n->type);
flag = 0;
break;
}
for(f=u->type; f!=T; f=f->down) {
if(!exportname(f->sym->name) && strcmp(f->sym->package, package) != 0)
continue;
- if(f->sym->uniq)
+ if(f->sym->flags & SymUniq)
continue;
- f->sym->uniq = 1;
+ f->sym->flags |= SymUniq;
sl = mal(sizeof(*sl));
sl->field = f;
sl->link = slist;
for(f=u->method; f!=T; f=f->down) {
if(!exportname(f->sym->name) && strcmp(f->sym->package, package) != 0)
continue;
- if(f->sym->uniq)
+ if(f->sym->flags & SymUniq)
continue;
- f->sym->uniq = 1;
+ f->sym->flags |= SymUniq;
sl = mal(sizeof(*sl));
sl->field = f;
sl->link = slist;
// check each method to be uniquely reachable
for(sl=slist; sl!=nil; sl=sl->link) {
- sl->field->sym->uniq = 0;
+ sl->field->sym->flags &= ~SymUniq;
for(d=0; d<nelem(dotlist); d++) {
c = adddot1(sl->field->sym, t, d, &f);
if(c == 0)