shithub: mc

Info  •  Files  •  Log  •  Branches

Get rid of the 'Sym' struct.

    It just got in the way, in the end, even though it seemed
    like a good idea when it was put in.

--- a/8/reduce.c

+++ b/8/reduce.c

@@ -62,9 +62,9 @@

     return ispureop[exprop(n)];

 }

-static int isconstfn(Sym *s)

+static int isconstfn(Node *s)

 {

-    return s->isconst && s->type->type == Tyfunc;

+    return s->decl.isconst && decltype(s)->type == Tyfunc;

 }

 static char *asmname(Node *n)

@@ -146,7 +146,7 @@

     if (n->type == Nexpr)

         t = n->expr.type;

     else

-        t = n->decl.sym->type;

+        t = n->decl.type;

     return tysize(t);

 }

@@ -165,16 +165,14 @@

     char buf[128];

     static int nexttmp;

     Node *t, *r, *n;

-    Sym *s;

     assert(e->type == Nexpr);

     snprintf(buf, 128, ".t%d", nexttmp++);

     n = mkname(e->line, buf);

-    s = mksym(e->line, n, e->expr.type);

-    t = mkdecl(e->line, s);

+    t = mkdecl(e->line, n, e->expr.type);

     declarelocal(simp, t);

     r = mkexpr(e->line, Ovar, t, NULL);

-    r->expr.did = s->id;

+    r->expr.did = t->decl.did;

     return r;

 }

@@ -540,8 +538,8 @@

     assert(n->type == Ndecl);

     s->stksz += size(n);

     if (debug)

-        printf("DECLARE %s(%ld) at %zd\n", declname(n), n->decl.sym->id, s->stksz);

-    htput(s->locs, (void*)n->decl.sym->id, (void*)s->stksz);

+        printf("DECLARE %s(%ld) at %zd\n", declname(n), n->decl.did, s->stksz);

+    htput(s->locs, (void*)n->decl.did, (void*)s->stksz);

 }

 static void declarearg(Simp *s, Node *n)

@@ -548,8 +546,8 @@

 {

     assert(n->type == Ndecl);

     if (debug)

-        printf("DECLARE %s(%ld) at %zd\n", declname(n), n->decl.sym->id, -(s->argsz + 8));

-    htput(s->locs, (void*)n->decl.sym->id, (void*)-(s->argsz + 8));

+        printf("DECLARE %s(%ld) at %zd\n", declname(n), n->decl.did, -(s->argsz + 8));

+    htput(s->locs, (void*)n->decl.did, (void*)-(s->argsz + 8));

     s->argsz += size(n);

 }

@@ -589,7 +587,7 @@

 	    if (n->decl.init) {

 		v = rval(s, n->decl.init);

 		r = mkexpr(n->line, Ovar, n, NULL);

-		r->expr.did = n->decl.sym->id;

+		r->expr.did = n->decl.did;

 		append(s, store(r, v));

 	    }

             break;

@@ -692,12 +690,12 @@

     void **k;

     size_t i, nk;

     Stab *stab;

-    Sym *s;

+    Node *s;

     k = htkeys(st->dcl, &nk);

     for (i = 0; i < nk; i++) {

         s = htget(st->dcl, k[i]);

-        htput(globls, (void*)s->id, asmname(s->name));

+        htput(globls, (void*)s->decl.did, asmname(s->decl.name));

     }

     free(k);

@@ -716,7 +714,6 @@

     char *name;

     FILE *fd;

     Node **n;

-    Sym *s;

     /* declrae useful constants */

     one = mkintlit(-1, 1);

@@ -737,9 +734,8 @@

             case Nuse: /* nothing to do */ 

                 break;

             case Ndecl:

-                s = n[i]->decl.sym;

-                name = asmname(s->name);

-                if (isconstfn(s)) {

+                name = asmname(n[i]->decl.name);

+                if (isconstfn(n[i])) {

                     lowerfn(name, n[i]->decl.init, globls, fd);

                     free(name);

                 } else {

--- a/parse/dump.c

+++ b/parse/dump.c

@@ -25,20 +25,20 @@

     fprintf(fd, "%s", n->name.name);

 }

-static void outsym(Sym *s, FILE *fd, int depth)

+static void outsym(Node *s, FILE *fd, int depth)

 {

     char buf[1024];

     indent(fd, depth);

-    if (s->isconst)

+    if (s->decl.isconst)

         fprintf(fd, "const ");

     else

         fprintf(fd, "var ");

-    outname(s->name, fd);

-    fprintf(fd, " : %s\n", tyfmt(buf, 1024, s->type));

+    outname(s->decl.name, fd);

+    fprintf(fd, " : %s\n", tyfmt(buf, 1024, s->decl.type));

 }

-void dumpsym(Sym *s, FILE *fd)

+void dumpsym(Node *s, FILE *fd)

 {

     outsym(s, fd, 0);

 }

@@ -117,7 +117,7 @@

             break;

         case Ndecl:

             fprintf(fd, "\n");

-            outsym(n->decl.sym, fd, depth + 1);

+            outsym(n, fd, depth + 1);

             outnode(n->decl.init, fd, depth + 1);

             break;

         case Nblock:

--- a/parse/gram.y

+++ b/parse/gram.y

@@ -163,7 +163,7 @@

 toplev

         : decl

             {lappend(&file->file.stmts, &file->file.nstmts, $1);

-             putdcl(file->file.globls, $1->decl.sym);}

+             putdcl(file->file.globls, $1);}

         | use

             {lappend(&file->file.uses, &file->file.nuses, $1);}

         | package

@@ -173,21 +173,19 @@

         ;

 decl    : Tvar declbody Tendln

-            {$2->decl.flags = 0;

-             $$ = $2;}

+            {$$ = $2;}

         | Tconst declbody Tendln

-            {$2->decl.sym->isconst = 1;

-             $2->decl.flags = 0;

+            {$2->decl.isconst = 1;

              $$ = $2;}

         | Tgeneric declbody Tendln

-            {$2->decl.sym->isconst = 1;

-             $2->decl.flags = 0;

+            {$2->decl.isconst = 1;

              $$ = $2;}

         | Textern Tvar declbody Tendln

-            {$3->decl.flags = Dclextern;

+            {$3->decl.isextern = 1;

              $$ = $3;}

         | Textern Tconst declbody Tendln

-            {$3->decl.flags = Dclconst | Dclextern;

+            {$3->decl.isconst = 1;

+             $3->decl.isextern = 1;

              $$ = $3;}

         ;

@@ -209,7 +207,7 @@

         | pkgbody pkgitem

         ;

-pkgitem : decl {putdcl(file->file.exports, $1->decl.sym);}

+pkgitem : decl {putdcl(file->file.exports, $1);}

         | tydef {puttype(file->file.exports, 

                          mkname($1.line, $1.name),

                          $1.type);}

@@ -227,9 +225,9 @@

         ;

 declcore: name

-            {$$ = mkdecl($1->line, mksym($1->line, $1, mktyvar($1->line)));}

+            {$$ = mkdecl($1->line, $1, mktyvar($1->line));}

         | name Tcolon type

-            {$$ = mkdecl($1->line, mksym($1->line, $1, $3));}

+            {$$ = mkdecl($1->line, $1, $3);}

         ;

 name    : Tident

@@ -558,12 +556,12 @@

              if ($1)

                 lappend(&$$->block.stmts, &$$->block.nstmts, $1);

              if ($1 && $1->type == Ndecl)

-                putdcl($$->block.scope, $1->decl.sym);}

+                putdcl($$->block.scope, $1);}

         | blockbody stmt

             {if ($2)

                 lappend(&$1->block.stmts, &$1->block.nstmts, $2);

              if ($2 && $2->type == Ndecl)

-                putdcl($1->block.scope, $2->decl.sym);

+                putdcl($1->block.scope, $2);

              $$ = $1;}

         ;

--- a/parse/infer.c

+++ b/parse/infer.c

@@ -95,7 +95,7 @@

     t = tf(t);

     switch (n->type) {

         case Nexpr:     n->expr.type = t;       break;

-        case Ndecl:     n->decl.sym->type = t;  break;

+        case Ndecl:     n->decl.type = t;       break;

         case Nlit:      n->lit.type = t;        break;

         case Nfunc:     n->func.type = t;       break;

         default:

@@ -247,7 +247,7 @@

     Node *var, *name, *nsname;

     Node **args;

     Stab *st;

-    Sym *s;

+    Node *s;

     if (n->type != Nexpr)

         return;

@@ -263,8 +263,8 @@

     if (!s)

         fatal(n->line, "Undeclared var %s.%s", nsname->name.ns, nsname->name.name);

     var = mkexpr(n->line, Ovar, nsname, NULL);

-    var->expr.did = s->id;

-    settype(var, s->type);

+    var->expr.did = s->decl.did;

+    settype(var, s->decl.type);

     *ret = var;

 }

@@ -272,8 +272,8 @@

 {

     Node **args;

     int nargs;

+    Node *s;

     Type *t;

-    Sym *s;

     int i;

     assert(n->type == Nexpr);

@@ -397,8 +397,8 @@

             if (!s)

                 fatal(n->line, "Undeclared var %s", ctxstr(args[0]));

             else

-                settype(n, s->type);

-            n->expr.did = s->id;

+                settype(n, s->decl.type);

+            n->expr.did = s->decl.did;

             break;

         case Olit:      /* <lit>:@a::tyclass -> @a */

             switch (args[0]->lit.littype) {

@@ -463,9 +463,9 @@

 {

     void **k;

     size_t i, nk;

-    Node *d;

     Type *ty;

-    Sym *s;

+    Node *d;

+    Node *s;

     if (!n)

         return;

@@ -488,9 +488,9 @@

 		d  = n->file.stmts[i];

 		infernode(d, NULL, sawret);

 		if (d->type == Ndecl)  {

-		    s = getdcl(file->file.exports, d->decl.sym->name);

+		    s = getdcl(file->file.exports, d->decl.name);

 		    if (s)

-			unify(d, type(d), s->type);

+			unify(d, type(d), s->decl.type);

 		}

 	    }

             popstab();

@@ -621,7 +621,7 @@

     void **k;

     size_t n, i;

     Type *t;

-    Sym *d;

+    Node *d;

     k = htkeys(s->ty, &n);

     for (i = 0; i < n; i++) {

@@ -633,7 +633,7 @@

     k = htkeys(s->dcl, &n);

     for (i = 0; i < n; i++) {

 	d = getdcl(s, k[i]);

-	d->type = tyfix(d->name, d->type);

+	d->decl.type = tyfix(d->decl.name, d->decl.type);

     }

     free(k);

 }

--- a/parse/node.c

+++ b/parse/node.c

@@ -111,7 +111,7 @@

     f->func.type = mktyfunc(line, args, nargs, ret);

     for (i = 0; i < nargs; i++)

-        putdcl(f->func.scope, args[i]->decl.sym);

+        putdcl(f->func.scope, args[i]);

     n = mknode(line, Nlit);

     n->lit.littype = Lfunc;

@@ -207,12 +207,15 @@

     return n;

 }

-Node *mkdecl(int line, Sym *sym)

+Node *mkdecl(int line, Node *name, Type *ty)

 {

+    static int nextdid;

     Node *n;

     n = mknode(line, Ndecl);

-    n->decl.sym = sym;

+    n->decl.did = nextdid++;

+    n->decl.name = name;

+    n->decl.type = ty;

     return n;

 }

@@ -231,7 +234,7 @@

 {

     Node *name;

     assert(n->type == Ndecl);

-    name = n->decl.sym->name;

+    name = n->decl.name;

     return name->name.name;

 }

@@ -250,7 +253,7 @@

 Type *nodetype(Node *n)

 {

     switch (n->type) {

-        case Ndecl:     return n->decl.sym->type;       break;

+        case Ndecl:     return n->decl.type;            break;

         case Nexpr:     return n->expr.type;            break;

         case Nlit:      return n->lit.type;             break;

         default:        die("Node %s has no type", nodestr(n->type)); break;

--- a/parse/parse.h

+++ b/parse/parse.h

@@ -11,7 +11,6 @@

 typedef struct Tok Tok;

 typedef struct Node Node;

 typedef struct Stab Stab;

-typedef struct Sym Sym;

 typedef struct Type Type;

 typedef struct Cstr Cstr;

@@ -86,12 +85,6 @@

 };

 struct Sym {

-    long  id;

-    int   line;

-    int   isconst;

-    int   isgeneric;

-    Node *name;

-    Type *type;

 };

 struct Type {

@@ -194,8 +187,12 @@

         } lbl;

         struct {

-            Sym *sym;

-            int flags;

+            long  did;

+            int   isconst;

+            int   isgeneric;

+            int   isextern;

+            Node *name;

+            Type *type;

             Node *init;

         } decl;

@@ -275,10 +272,10 @@

 void putns(Stab *st, Stab *scope);

 void puttype(Stab *st, Node *n, Type *ty);

 void updatetype(Stab *st, Node *n, Type *t);

-void putdcl(Stab *st, Sym *s);

+void putdcl(Stab *st, Node *s);

 Stab *getns(Stab *st, Node *n);

-Sym *getdcl(Stab *st, Node *n);

+Node *getdcl(Stab *st, Node *n);

 Type *gettype(Stab *st, Node *n);

 Stab *curstab(void);

@@ -285,7 +282,6 @@

 void pushstab(Stab *st);

 void popstab(void);

-Sym *mksym(int line, Node *name, Type *ty);

 /* type creation */

 void tyinit(Stab *st); /* sets up built in types */

@@ -333,7 +329,7 @@

 Node *mkarray(int line, Node **vals);

 Node *mkname(int line, char *name);

 Node *mknsname(int line, char *ns, char *name);

-Node *mkdecl(int line, Sym *sym);

+Node *mkdecl(int line, Node *name, Type *ty);

 Node *mklbl(int line, char *lbl);

 Node *mkslice(int line, Node *base, Node *off);

@@ -358,7 +354,7 @@

 /* debug */

 void dump(Node *t, FILE *fd);

-void dumpsym(Sym *s, FILE *fd);

+void dumpsym(Node *s, FILE *fd);

 void dumpstab(Stab *st, FILE *fd);

 char *opstr(Op o);

 char *nodestr(Ntype nt);

@@ -373,10 +369,10 @@

 /* serialization/usefiles */

 void typickle(Type *t, FILE *fd);

-void sympickle(Sym *s, FILE *fd);

+void sympickle(Node *s, FILE *fd);

 void pickle(Node *n, FILE *fd);

 Type *tyunpickle(FILE *fd);

-Sym  *symunpickle(FILE *fd);

+Node *symunpickle(FILE *fd);

 Node *unpickle(FILE *fd);

 /* serializing/unserializing */

--- a/parse/pickle.c

+++ b/parse/pickle.c

@@ -17,8 +17,8 @@

 static Type *rdtype(FILE *fd);

 static void wrstab(FILE *fd, Stab *val);

 static Stab *rdstab(FILE *fd);

-static void wrsym(FILE *fd, Sym *val);

-static Sym *rdsym(FILE *fd);

+static void wrsym(FILE *fd, Node *val);

+static Node *rdsym(FILE *fd);

 static void wrstab(FILE *fd, Stab *val)

 {

@@ -82,23 +82,35 @@

     return st;

 }

-static void wrsym(FILE *fd, Sym *val)

+static void wrsym(FILE *fd, Node *val)

 {

+    /* sym */

     wrint(fd, val->line);

-    pickle(val->name, fd);

-    wrtype(fd, val->type);

+    pickle(val->decl.name, fd);

+    wrtype(fd, val->decl.type);

+

+    /* symflags */

+    wrint(fd, val->decl.isconst);

+    wrint(fd, val->decl.isgeneric);

+    wrint(fd, val->decl.isextern);

 }

-static Sym *rdsym(FILE *fd)

+static Node *rdsym(FILE *fd)

 {

     int line;

     Node *name;

     Type *type;

+    Node *n;

     line = rdint(fd);

     name = unpickle(fd);

     type = rdtype(fd);

-    return mksym(line, name, type);

+    n = mkdecl(line, name, type);

+    

+    n->decl.isconst = rdint(fd);

+    n->decl.isgeneric = rdint(fd);

+    n->decl.isextern = rdint(fd);

+    return n;

 }

 Type *tyunpickle(FILE *fd)

@@ -106,7 +118,7 @@

     return rdtype(fd);

 }

-Sym *symunpickle(FILE *fd)

+Node *symunpickle(FILE *fd)

 {

     return rdsym(fd);

 }

@@ -220,7 +232,7 @@

     wrtype(fd, t);

 }

-void sympickle(Sym *s, FILE *fd)

+void sympickle(Node *s, FILE *fd)

 {

     wrsym(fd, s);

 }

@@ -307,8 +319,16 @@

             wrstr(fd, n->lbl.name);

             break;

         case Ndecl:

-            wrsym(fd, n->decl.sym);

-            wrint(fd, n->decl.flags);

+            /* sym */

+            pickle(n->decl.name, fd);

+            wrtype(fd, n->decl.type);

+

+            /* symflags */

+            wrint(fd, n->decl.isconst);

+            wrint(fd, n->decl.isgeneric);

+            wrint(fd, n->decl.isextern);

+

+            /* init */

             pickle(n->decl.init, fd);

             break;

         case Nfunc:

@@ -403,8 +423,16 @@

             n->lbl.name = rdstr(fd);

             break;

         case Ndecl:

-            n->decl.sym = rdsym(fd);

-            n->decl.flags = rdint(fd);

+            /* sym */

+            n->decl.name = unpickle(fd);

+            n->decl.type = rdtype(fd);

+

+            /* symflags */

+            n->decl.isconst = rdint(fd);

+            n->decl.isgeneric = rdint(fd);

+            n->decl.isextern = rdint(fd);

+

+            /* init */

             n->decl.init = unpickle(fd);

             break;

         case Nfunc:

--- a/parse/stab.c

+++ b/parse/stab.c

@@ -47,19 +47,6 @@

     return a == b || !strcmp(namestr(a), namestr(b));

 }

-Sym *mksym(int line, Node *name, Type *ty)

-{

-    static int nextid;

-    Sym *sym;

-

-    sym = zalloc(sizeof(Sym));

-    sym->id = nextid++;

-    sym->name = name;

-    sym->type = ty;

-    sym->line = line;

-    return sym;

-}

-

 Stab *mkstab()

 {

     Stab *st;

@@ -72,9 +59,9 @@

 }

 /* FIXME: do namespaces */

-Sym *getdcl(Stab *st, Node *n)

+Node *getdcl(Stab *st, Node *n)

 {

-    Sym *s;

+    Node *s;

     Stab *orig;

     orig = st;

@@ -84,7 +71,7 @@

             if (!st->closure)

                 st->closure = mkht(namehash, nameeq);

             if (st != orig)

-                htput(st->closure, s->name, s);

+                htput(st->closure, s->decl.name, s);

             return s;

         }

         st = st->super;

@@ -115,16 +102,16 @@

     return NULL;

 }

-void putdcl(Stab *st, Sym *s)

+void putdcl(Stab *st, Node *s)

 {

-    Sym *d;

+    Node *d;

-    d = getdcl(st, s->name);

+    d = getdcl(st, s->decl.name);

     if (d)

-        fatal(s->line, "%s already declared (line %d", namestr(s->name), d->line);

+        fatal(s->line, "%s already declared (line %d", namestr(s->decl.name), d->line);

     if (st->name)

-        setns(s->name, namestr(st->name));

-    htput(st->dcl, s->name, s);

+        setns(s->decl.name, namestr(st->name));

+    htput(st->dcl, s->decl.name, s);

 }

 void updatetype(Stab *st, Node *n, Type *t)

--- a/parse/use.c

+++ b/parse/use.c

@@ -15,7 +15,7 @@

 {

     char *pkg;

     Stab *s;

-    Sym *dcl;

+    Node *dcl;

     Type *t;

     Node *n;

     int c;

@@ -106,7 +106,7 @@

     Stab *st;

     void **k;

     Type *t;

-    Sym *s;

+    Node *s;

     size_t i, n;

     st = file->file.exports;

@@ -127,7 +127,7 @@

     k = htkeys(st->dcl, &n);

     for (i = 0; i < n; i++) {

 	s = getdcl(st, k[i]);

-	if (s->isgeneric)

+	if (s->decl.isgeneric)

 	    wrbyte(f, 'G');

 	else

 	    wrbyte(f, 'D');

--- a/test/test.sh

+++ b/test/test.sh

@@ -1,8 +1,15 @@

 #!/bin/bash

 export PATH=.:$PATH

 export MC=../8/8m

+export MU=../util/muse

 export ASOPT="-g"

+function use {

+    rm -f $1

+    echo $MU $1.myr -o $1.use && \

+    $MU $1.myr -o $1.use && \

+}

+

 function build {

     rm -f $1

     echo $MC $1.myr && \

@@ -34,6 +41,10 @@

 for i in `awk '/^B/{print $2}' tests`; do

     build $i

+done

+

+for i in `awk '/^U/{print $2}' tests`; do

+    use $i

 done

 for i in `awk '/^F/{print $2}' tests`; do