shithub: mc

Info  •  Files  •  Log  •  Branches

Make type names proper types.

--- a/8/reduce.c

+++ b/8/reduce.c

@@ -223,6 +223,8 @@

         case Tyslice:

             return 8; /* len; ptr */

+        case Tyalias:

+            return tysize(t->sub[0]);

         case Tyarray:

             assert(exprop(t->asize) == Olit);

             return t->asize->expr.args[0]->lit.intval * tysize(t->sub[0]);

@@ -377,6 +379,7 @@

     if (aggr->expr.type->type == Typtr)

         aggr = aggr->expr.args[0];

     ty = aggr->expr.type;

+    ty = tybase(ty);

     assert(ty->type == Tystruct);

     nl = aggrmemb(ty, &nn);

--- a/parse/gram.y

+++ b/parse/gram.y

@@ -241,7 +241,7 @@

 tydef   : Ttype Tident Tasn type Tendln

             {$$.line = $1->line;

              $$.name = $2->str;

-             $$.type = $4;}

+             $$.type = mktyalias($2->line, mkname($2->line, $2->str), $4);}

         | Ttype Tident Tendln

             {$$.line = $1->line;

              $$.name = $2->str;

--- a/parse/infer.c

+++ b/parse/infer.c

@@ -92,12 +92,12 @@

     if (t->resolved)

         return;

+    t->resolved = 1;

     n = aggrmemb(t, &nn);

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

         infernode(n[i], NULL, NULL);

     for (i = 0; i < t->nsub; i++)

         t->sub[i] = tf(t->sub[i]);

-    t->resolved = 1;

 }

 /* fixd the most accurate type mapping we have */

--- a/parse/node.c

+++ b/parse/node.c

@@ -272,17 +272,6 @@

     return e->expr.op;

 }

-Node **aggrmemb(Type *t, size_t *n)

-{

-    *n = t->nmemb;

-    switch (t->type) {

-        case Tystruct: return t->sdecls; break;

-        case Tyunion: return t->udecls; break;

-        case Tyarray: return &t->asize; break;

-        default: return NULL;

-    }

-}

-

 char *namestr(Node *name)

 {

     if (!name)

--- a/parse/parse.h

+++ b/parse/parse.h

@@ -97,6 +97,7 @@

     size_t nmemb;     /* for aggregate types (struct, union) */

     Type **sub;       /* sub-types; shared by all composite types */

     union {

+        Node *aname;   /* Tyalias: alias name */

         Node *name;    /* Tyname: unresolved name */

         Node *asize;   /* array size */

         char *pname;   /* Typaram: name of type parameter */

@@ -290,6 +291,7 @@

 Type *tydup(Type *t); /* shallow duplicate; all subtypes/members/... kept */

 Type *mktyvar(int line);

 Type *mktyparam(int line, char *name);

+Type *mktyalias(int line, Node *name, Type *base);

 Type *mktynamed(int line, Node *name);

 Type *mktyarray(int line, Type *base, Node *sz);

 Type *mktyslice(int line, Type *base);

@@ -303,6 +305,7 @@

 int   istysigned(Type *t);

 /* type manipulation */

+Type *tybase(Type *t);

 int hascstr(Type *t, Cstr *c);

 int cstreq(Type *t, Cstr **cstrs, size_t len);

 int setcstr(Type *t, Cstr *c);

--- a/parse/type.c

+++ b/parse/type.c

@@ -117,6 +117,19 @@

     return t;

 }

+Type *mktyalias(int line, Node *name, Type *base)

+{

+    Type *t;

+

+    t = mkty(line, Tyalias);

+    t->name = name;

+    t->nsub = 1;

+    t->cstrs = bsdup(base->cstrs);

+    t->sub = xalloc(sizeof(Type*));

+    t->sub[0] = base;

+    return t;

+}

+

 Type *mktyarray(int line, Type *base, Node *sz)

 {

     Type *t;

@@ -210,6 +223,25 @@

     }

 }

+Type *tybase(Type *t)

+{

+    while (t->type == Tyalias)

+        t = t->sub[0];

+    return t;

+}

+

+Node **aggrmemb(Type *t, size_t *n)

+{

+    t = tybase(t);

+    *n = t->nmemb;

+    switch (t->type) {

+        case Tystruct:  return t->sdecls;               break;

+        case Tyunion:   return t->udecls;               break;

+        case Tyarray:   return &t->asize;               break;

+        default: return NULL;

+    }

+}

+

 static int namefmt(char *buf, size_t len, Node *n)

 {

     char *p;

@@ -374,6 +406,9 @@

         case Tyname:

             p += snprintf(p, end - p, "?"); /* indicate unresolved name. should not be seen by user. */

             p += namefmt(p, end - p, t->name);

+            break;

+        case Tyalias:  

+            p += snprintf(p, end - p, "%s", namestr(t->aname));

             break;

         case Tystruct:  p += fmtstruct(p, end - p, t);  break;

         case Tyunion:   p += fmtunion(p, end - p, t);   break;

--- a/parse/types.def

+++ b/parse/types.def

@@ -38,4 +38,5 @@

 Ty(Tyname, NULL)

 Ty(Tystruct, NULL)

 Ty(Tyunion, NULL)

+Ty(Tyalias, NULL)

 Ty(Ntypes, NULL)