shithub: mc

Download patch

ref: b9b381e6f0eb16b144127f1fbb7b4ce17da8e66c
parent: 4c863884833102c4d44d8d52104fd11e48200a55
author: Ori Bernstein <[email protected]>
date: Mon Jul 9 09:18:04 EDT 2012 

Parse and store unadorned literal sequences

    Now, the '[a,b,c]' syntax parses and gets nodes built. It also gets
    passed down to the type inference code.


--- a/parse/dump.c
+++ b/parse/dump.c
@@ -175,7 +175,8 @@
                     break;
                 case Lseq:
                     fprintf(fd, " Lseq\n");
-                    outnode(n->lit.arrval, fd, depth+1);
+                    for (i = 0; i < n->lit.nelt; i++)
+                        outnode(n->lit.seqval[i], fd, depth+1);
                     break;
                 default: die("Bad literal type"); break;
             }
--- a/parse/gram.y
+++ b/parse/gram.y
@@ -519,7 +519,7 @@
         ;
 
 seqlit  : Tosqbrac seqbody Tcsqbrac
-            {$$ = mkarray($1->line, $2.nl, $2.nn);}
+            {$$ = mkseq($1->line, $2.nl, $2.nn);}
         ;
 
 seqbody : seqelt
--- a/parse/infer.c
+++ b/parse/infer.c
@@ -529,7 +529,7 @@
         case Olit:      /* <lit>:@a::tyclass -> @a */
             switch (args[0]->lit.littype) {
                 case Lfunc: infernode(args[0]->lit.fnval, NULL, NULL); break;
-                case Lseq: die("array types not implemented yet"); break;
+                case Lseq: die("seq lits not implemented yet"); break;
                 default: break;
             }
             settype(n, type(args[0]));
@@ -897,7 +897,10 @@
             settype(n, tyfix(n, type(n)));
             switch (n->lit.littype) {
                 case Lfunc:     typesub(n->lit.fnval); break;
-                case Lseq:      typesub(n->lit.arrval); break;
+                case Lseq:
+                    for (i = 0; i < n->lit.nelt; i++)
+                        typesub(n->lit.seqval[i]);
+                    break;
                 default:        break;
             }
             break;
--- a/parse/node.c
+++ b/parse/node.c
@@ -208,12 +208,15 @@
     return n;
 }
 
-Node *mkarray(int line, Node **vals, size_t nvals)
+Node *mkseq(int line, Node **vals, size_t nvals)
 {
     Node *n;
 
-    n = NULL;
-    die("Yeah, I need an array repr...");
+    n = mknode(line, Nlit);
+    n->lit.littype = Lseq;
+    n->lit.nelt = nvals;
+    n->lit.seqval = vals;
+
     return n;
 }
 
--- a/parse/parse.h
+++ b/parse/parse.h
@@ -169,7 +169,7 @@
                 char    *strval;
                 int      boolval;
                 Node    *fnval;
-                Node    *arrval;
+                Node    **seqval;
             };
         } lit;
 
@@ -363,7 +363,7 @@
 Node *mkstr(int line, char *s);
 Node *mkfloat(int line, double flt);
 Node *mkfunc(int line, Node **args, size_t nargs, Type *ret, Node *body);
-Node *mkarray(int line, Node **vals, size_t nvals);
+Node *mkseq(int line, Node **vals, size_t nvals);
 Node *mkname(int line, char *name);
 Node *mknsname(int line, char *ns, char *name);
 Node *mkdecl(int line, Node *name, Type *ty);
--- a/parse/pickle.c
+++ b/parse/pickle.c
@@ -304,6 +304,7 @@
         case Nlit:
             wrbyte(fd, n->lit.littype);
             wrtype(fd, n->lit.type);
+            wrint(fd, n->lit.nelt);
             switch (n->lit.littype) {
                 case Lchr:      wrint(fd, n->lit.chrval);       break;
                 case Lint:      wrint(fd, n->lit.intval);       break;
@@ -311,7 +312,10 @@
                 case Lstr:      wrstr(fd, n->lit.strval);       break;
                 case Lbool:     wrbool(fd, n->lit.boolval);     break;
                 case Lfunc:     pickle(n->lit.fnval, fd);       break;
-                case Lseq:      pickle(n->lit.arrval, fd);      break;
+                case Lseq:
+                    for (i = 0; i < n->lit.nelt; i++)
+                        pickle(n->lit.seqval[i], fd);
+                    break;
             }
             break;
         case Nloopstmt:
@@ -417,6 +421,7 @@
         case Nlit:
             n->lit.littype = rdbyte(fd);
             n->lit.type = rdtype(fd);
+            n->lit.nelt = rdint(fd);
             switch (n->lit.littype) {
                 case Lchr:      n->lit.chrval = rdint(fd);       break;
                 case Lint:      n->lit.intval = rdint(fd);       break;
@@ -424,7 +429,10 @@
                 case Lstr:      n->lit.strval = rdstr(fd);       break;
                 case Lbool:     n->lit.boolval = rdbool(fd);     break;
                 case Lfunc:     n->lit.fnval = unpickle(fd);       break;
-                case Lseq:      n->lit.arrval = unpickle(fd);      break;
+                case Lseq:
+                    for (i = 0; i < n->lit.nelt; i++)
+                        n->lit.seqval[i] = unpickle(fd);
+                    break;
             }
             break;
         case Nloopstmt:
--- a/parse/specialize.c
+++ b/parse/specialize.c
@@ -102,7 +102,10 @@
         case Nlit:
             switch (n->lit.littype) {
                 case Lfunc:     fixup(n->lit.fnval);          break;
-                case Lseq:      fixup(n->lit.arrval);         break;
+                case Lseq:
+                    for (i = 0; i < n->lit.nelt; i++)
+                        fixup(n->lit.seqval[i]);
+                    break;
                 case Lchr: case Lint: case Lflt: case Lstr: case Lbool:
                     break;
             }
@@ -182,7 +185,10 @@
                 case Lstr:      r->lit.strval = n->lit.strval;       break;
                 case Lbool:     r->lit.boolval = n->lit.boolval;     break;
                 case Lfunc:     r->lit.fnval = specializenode(n->lit.fnval, tsmap);       break;
-                case Lseq:      r->lit.arrval = specializenode(n->lit.arrval, tsmap);     break;
+                case Lseq:
+                    for (i = 0; i < n->lit.nelt; i++)
+                        r->lit.seqval[i] = specializenode(n->lit.seqval[i], tsmap);
+                    break;
             }
             break;
         case Nifstmt: