shithub: mc

Info  •  Files  •  Log  •  Branches

Add indexed initializer tree support.

    Needed to support indexed initialization of sequence literals.

--- a/parse/dump.c

+++ b/parse/dump.c

@@ -222,6 +222,11 @@

             fprintf(stderr, "Nnone not a real node type!");

             fprintf(fd, "Nnone\n");

             break;

+        case Nidxinit:

+            fprintf(fd, "\n");

+            outnode(n->idxinit.idx, fd, depth + 1);

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

+            break;

     }

 }

--- a/parse/gram.y

+++ b/parse/gram.y

@@ -638,7 +638,8 @@

              {lappend(&$$.nl, &$$.nn, $3);}

         ;

-structelt: endlns Tdot Tident Tasn expr endlns {$$ = $5;}

+structelt: endlns Tdot Tident Tasn expr endlns 

+            {$$ = mkidxinit($2->line, mkname($3->line, $3->str), $5);}

          ;

 endlns  : /* none */

--- a/parse/infer.c

+++ b/parse/infer.c

@@ -1143,6 +1143,10 @@

             inferfunc(st, n);

             popstab();

             break;

+        case Nidxinit:

+            infernode(st, n->idxinit.idx, NULL, NULL);

+            infernode(st, n->idxinit.init, NULL, NULL);

+            break;

         case Nname:

         case Nlit:

         case Nuse:

@@ -1350,6 +1354,10 @@

                     break;

                 default:        break;

             }

+            break;

+        case Nidxinit:

+            typesub(st, n->idxinit.idx);

+            typesub(st, n->idxinit.init);

             break;

         case Nname:

         case Nuse:

--- a/parse/node.c

+++ b/parse/node.c

@@ -256,6 +256,17 @@

     return n;

 }

+Node *mkidxinit(int line, Node *idx, Node *init)

+{

+    Node *n;

+

+    n = mknode(line, Nidxinit);

+    n->idxinit.idx = idx;

+    n->idxinit.init = init;

+

+    return n;

+}

+

 Node *mkname(int line, char *name)

 {

     Node *n;

--- a/parse/nodes.def

+++ b/parse/nodes.def

@@ -11,3 +11,4 @@

 N(Nname)

 N(Ndecl)

 N(Nfunc)

+N(Nidxinit)

--- a/parse/parse.h

+++ b/parse/parse.h

@@ -222,6 +222,11 @@

         } match;

         struct {

+            Node *idx;

+            Node *init;

+        } idxinit;

+

+        struct {

             Stab *scope;

             size_t nstmts;

             Node **stmts;

@@ -387,6 +392,7 @@

 Node *mkmatch(int line, Node *pat, Node *body);

 Node *mkblock(int line, Stab *scope);

 Node *mkintlit(int line, uvlong val);

+Node *mkidxinit(int line, Node *idx, Node *init);

 Node *mkbool(int line, int val);

 Node *mkint(int line, uint64_t val);

--- a/parse/specialize.c

+++ b/parse/specialize.c

@@ -192,6 +192,9 @@

             fixup(n->func.body);

             popstab();

             break;

+        case Nidxinit:

+            fixup(n->idxinit.idx);

+            fixup(n->idxinit.init);

         case Nnone: case Nname:

             break;

     }

@@ -311,6 +314,10 @@

                 r->func.args[i] = specializenode(n->func.args[i], tsmap);

             r->func.body = specializenode(n->func.body, tsmap);

             popstab();

+            break;

+        case Nidxinit:

+            r->idxinit.idx = specializenode(n->idxinit.idx, tsmap);

+            r->idxinit.init = specializenode(n->idxinit.init, tsmap);

             break;

         case Nnone:

             die("Nnone should not be seen as node type!");

--- a/parse/use.c

+++ b/parse/use.c

@@ -413,6 +413,10 @@

                 pickle(n->func.args[i], fd);

             pickle(n->func.body, fd);

             break;

+        case Nidxinit:

+            pickle(n->idxinit.idx, fd);

+            pickle(n->idxinit.init, fd);

+            break;

         case Nnone:

             die("Nnone should not be seen as node type!");

             break;

@@ -546,6 +550,10 @@

             n->func.body = unpickle(fd);

             popstab();

             break;

+        case Nidxinit:

+            n->idxinit.idx = unpickle(fd);

+            n->idxinit.init = unpickle(fd);

+            break;

         case Nnone:

             die("Nnone should not be seen as node type!");

             break;

@@ -768,6 +776,11 @@

             for (i = 0; i < n->func.nargs; i++)

                 nodetag(n->func.args[i]);

             nodetag(n->func.body);

+            break;

+        case Nidxinit:

+            nodetag(n->idxinit.idx);

+            nodetag(n->idxinit.init);

+            break;

         case Nuse: case Nname:

             break;