shithub: mc

Download patch

ref: c8962ecdaa334c37668228b43db27c283ca15e03
parent: d932e34a30c72f31632d9b057334cd84b86c1646
parent: 949eb0559d34c181134b810d16d845f7609c2222
author: Ori Bernstein <[email protected]>
date: Wed Aug 15 17:15:50 EDT 2012

Merge branch 'master' of git+ssh://mimir.eigenstate.org/git/ori/mc2

Conflicts:
	parse/infer.c

--- a/6/isel.c
+++ b/6/isel.c
@@ -542,12 +542,6 @@
             g(s, Imov, b, a, NULL);
             r = b;
             break;
-        case Oload: /* mem -> reg */
-            a = memloc(s, args[0], mode(n));
-            r = locreg(mode(n));
-            /* FIXME: we should be moving the correct 'coreg' */
-            g(s, Imov, a, r, NULL);
-            break;
         case Ocall:
             r = gencall(s, n);
             break;
--- a/6/simp.c
+++ b/6/simp.c
@@ -114,7 +114,6 @@
 {
     Node *n;
 
-    assert(exprop(a) != Oload);
     n = mkexpr(a->line, Oaddr, a, NULL);
     if (!bt)
         n->expr.type = mktyptr(a->line, a->expr.type);
@@ -128,7 +127,7 @@
     Node *n;
 
     assert(a->expr.type->type == Typtr);
-    n = mkexpr(a->line, Oload, a, NULL);
+    n = mkexpr(a->line, Oderef, a, NULL);
     n->expr.type = base(a->expr.type);
     return n;
 }
@@ -428,7 +427,7 @@
     Ucon *uc;
 
     if (exprop(n) != Ocons)
-        return load(addk(addr(n, mkty(n->line, Tyuint)), off));
+        return load(addk(addr(n, mktype(n->line, Tyuint)), off));
 
     uc = finducon(n);
     return word(uc->line, uc->id);
@@ -595,9 +594,9 @@
     args = n->expr.args;
     ty = tybase(exprtype(args[0]));
     if (ty->type == Typtr) {
-        t = args[0];
+        t = lval(s, args[0]);
     } else {
-        t = addr(args[0], exprtype(n));
+        t = addr(lval(s, args[0]), exprtype(n));
     }
     u = disp(n->line, offset(args[0], args[1]));
     r = add(t, u);
@@ -919,9 +918,9 @@
         tmp = temp(s, n);
 
     /* Set the tag on the ucon */
-    u = addr(tmp, mkty(n->line, Tyuint));
+    u = addr(tmp, mktype(n->line, Tyuint));
     tag = mkintlit(n->line, uc->id);
-    tag->expr.type = mkty(n->line, Tyuint);
+    tag->expr.type = mktype(n->line, Tyuint);
     append(s, set(deref(u), tag));
 
 
@@ -967,7 +966,7 @@
     /* if true */
     append(s, ltrue);
     u = mkexpr(n->line, Olit, mkbool(n->line, 1), NULL);
-    u->expr.type = mkty(n->line, Tybool);
+    u->expr.type = mktype(n->line, Tybool);
     t = set(r, u);
     append(s, t);
     jmp(s, ldone);
@@ -975,7 +974,7 @@
     /* if false */
     append(s, lfalse);
     u = mkexpr(n->line, Olit, mkbool(n->line, 0), NULL);
-    u->expr.type = mkty(n->line, Tybool);
+    u->expr.type = mktype(n->line, Tybool);
     t = set(r, u);
     append(s, t);
     jmp(s, ldone);
@@ -1353,9 +1352,9 @@
     FILE *fd;
 
     /* declare useful constants */
-    tyintptr = mkty(-1, Tyuint64);
-    tyword = mkty(-1, Tyuint);
-    tyvoid = mkty(-1, Tyvoid);
+    tyintptr = mktype(-1, Tyuint64);
+    tyword = mktype(-1, Tyuint);
+    tyvoid = mktype(-1, Tyvoid);
 
     fn = NULL;
     nfn = 0;
--- a/parse/gram.y
+++ b/parse/gram.y
@@ -271,7 +271,7 @@
         | uniondef
         | compoundtype
         | generictype
-        | Tellipsis {$$ = mkty($1->line, Tyvalist);}
+        | Tellipsis {$$ = mktype($1->line, Tyvalist);}
         ;
 
 generictype
@@ -289,7 +289,7 @@
 
 compoundtype
         : functype   {$$ = $1;}
-        | type Tosqbrac Tcomma Tcsqbrac {$$ = mktyslice($2->line, $1);}
+        | type Tosqbrac Tcolon Tcsqbrac {$$ = mktyslice($2->line, $1);}
         | type Tosqbrac expr Tcsqbrac {$$ = mktyarray($2->line, $1, $3);}
         | type Tstar {$$ = mktyptr($2->line, $1);}
         | name       {$$ = mktynamed($1->line, $1);}
@@ -502,7 +502,7 @@
             {$$ = mkexpr($1->line, Opostdec, $1, NULL);}
         | postfixexpr Tosqbrac expr Tcsqbrac
             {$$ = mkexpr($1->line, Oidx, $1, $3, NULL);}
-        | postfixexpr Tosqbrac optexpr Tcomma optexpr Tcsqbrac
+        | postfixexpr Tosqbrac optexpr Tcolon optexpr Tcsqbrac
             {$$ = mksliceexpr($1->line, $1, $3, $5);}
         | postfixexpr Toparen arglist Tcparen
             {$$ = mkcall($1->line, $1, $3.nl, $3.nn);}
--- a/parse/infer.c
+++ b/parse/infer.c
@@ -195,12 +195,17 @@
 static Type *tf(Inferstate *st, Type *t)
 {
     Type *lu;
+    Stab *ns;
 
     assert(t != NULL);
     lu = NULL;
     while (1) {
         if (!tytab[t->tid] && t->type == Tyunres) {
-            if (!(lu = gettype(curstab(), t->name)))
+            ns = curstab();
+            if (t->name->name.ns) {
+                ns = getns_str(ns, t->name->name.ns);
+            }
+            if (!(lu = gettype(ns, t->name)))
                 fatal(t->name->line, "Could not resolve type %s", namestr(t->name));
             tytab[t->tid] = lu;
         }
@@ -234,11 +239,11 @@
     if (n->lit.type)
         return n->lit.type;
     switch (n->lit.littype) {
-        case Lchr:      return mkty(n->line, Tychar);                           break;
-        case Lbool:     return mkty(n->line, Tybool);                           break;
+        case Lchr:      return mktype(n->line, Tychar);                         break;
+        case Lbool:     return mktype(n->line, Tybool);                         break;
         case Lint:      return mktylike(n->line, Tyint);                        break;
         case Lflt:      return mktylike(n->line, Tyfloat32);                    break;
-        case Lstr:      return mktyslice(n->line, mkty(n->line, Tybyte));       break;
+        case Lstr:      return mktyslice(n->line, mktype(n->line, Tybyte));     break;
         case Lfunc:     return n->lit.fnval->func.type;                         break;
         case Lseq:      return NULL; break;
     };
@@ -712,7 +717,7 @@
             t = type(st, args[0]);
             for (i = 1; i < nargs; i++)
                 unify(st, n, t, type(st, args[i]));
-            settype(st, n, mkty(-1, Tybool));
+            settype(st, n, mktype(-1, Tybool));
             break;
 
         /* reach into a type and pull out subtypes */
@@ -759,11 +764,11 @@
             if (nargs)
                 t = unify(st, n, ret, type(st, args[0]));
             else
-                t =  unify(st, n, mkty(-1, Tyvoid), ret);
+                t =  unify(st, n, mktype(-1, Tyvoid), ret);
             settype(st, n, t);
             break;
         case Ojmp:     /* goto void* -> void */
-            settype(st, n, mkty(-1, Tyvoid));
+            settype(st, n, mktype(-1, Tyvoid));
             break;
         case Ovar:      /* a:@a -> @a */
             /* if we created this from a namespaced var, the type should be
@@ -819,9 +824,8 @@
             settype(st, n, type(st, args[0]));
             break;
         case Olbl:      /* :lbl -> void* */
-            settype(st, n, mktyptr(n->line, mkty(-1, Tyvoid)));
-        case Obad: case Ocjmp:
-        case Oload: case Oset:
+            settype(st, n, mktyptr(n->line, mktype(-1, Tyvoid)));
+        case Obad: case Ocjmp: case Oset:
         case Oslbase: case Osllen:
         case Oblit: case Numops:
         case Otrunc: case Oswiden: case Ozwiden:
@@ -841,7 +845,7 @@
     infernode(st, n->func.body, n->func.type->sub[0], &sawret);
     /* if there's no return stmt in the function, assume void ret */
     if (!sawret)
-        unify(st, n, type(st, n)->sub[0], mkty(-1, Tyvoid));
+        unify(st, n, type(st, n)->sub[0], mktype(-1, Tyvoid));
 }
 
 static void inferdecl(Inferstate *st, Node *n)
@@ -983,9 +987,9 @@
     char buf[1024];
 
     if (!tyint)
-        tyint = mkty(-1, Tyint);
+        tyint = mktype(-1, Tyint);
     if (!tyflt)
-        tyflt = mkty(-1, Tyfloat64);
+        tyflt = mktype(-1, Tyfloat64);
 
     t = tf(st, t);
     if (t->type == Tyvar) {
--- a/parse/ops.def
+++ b/parse/ops.def
@@ -53,7 +53,6 @@
 O(Oarr, 1)
 /* backend-only */
 O(Ocjmp, 1)        /* conditional jump */
-O(Oload, 1)        /* load from memory */
 O(Oset, 1)         /* store to var */
 O(Osllen, 1)       /* size of slice */
 O(Oslbase, 1)      /* base of sice */
--- a/parse/parse.h
+++ b/parse/parse.h
@@ -179,7 +179,6 @@
                 int      boolval;
                 Node    *fnval;
                 Node    **seqval;
-                Node    **tupval;
             };
         } lit;
 
@@ -198,8 +197,8 @@
 
         struct {
             Node *val;
-            Node **matches;
             size_t nmatches;
+            Node **matches;
         } matchstmt;
 
         struct {
@@ -220,7 +219,7 @@
         struct {
             size_t did;
             char  isglobl;
-	    char  isexport;
+            char  isexport;
             char  isconst;
             char  isgeneric;
             char  isextern;
@@ -319,6 +318,7 @@
 void putucon(Stab *st, Ucon *uc);
 
 Stab *getns(Stab *st, Node *n);
+Stab *getns_str(Stab *st, char *n);
 Node *getdcl(Stab *st, Node *n);
 Type *gettype(Stab *st, Node *n);
 Cstr *getcstr(Stab *st, Node *n);
@@ -331,7 +331,7 @@
 /* type creation */
 void tyinit(Stab *st); /* sets up built in types */
 
-Type *mkty(int line, Ty ty);
+Type *mktype(int line, Ty ty);
 Type *tydup(Type *t); /* shallow duplicate; all subtypes/members/... kept */
 Type *mktyvar(int line);
 Type *mktyparam(int line, char *name);
--- a/parse/pickle.c
+++ b/parse/pickle.c
@@ -229,7 +229,7 @@
     size_t i;
 
     t = rdbyte(fd);
-    ty = mkty(-1, t);
+    ty = mktype(-1, t);
     /* tid is generated; don't write */
     /* cstrs are left out for now: FIXME */
     ty->nsub = rdint(fd);
--- a/parse/stab.c
+++ b/parse/stab.c
@@ -64,7 +64,7 @@
     Stab *st;
 
     st = zalloc(sizeof(Stab));
-    st->ns = mkht(namehash, nameeq);
+    st->ns = mkht(strhash, streq);
     st->dcl = mkht(namehash, nameeq);
     st->ty = mkht(namehash, nameeq);
     st->uc = mkht(namehash, nameeq);
@@ -104,7 +104,7 @@
 Type *gettype(Stab *st, Node *n)
 {
     Tydefn *t;
-    
+
     do {
         if ((t = htget(st->ty, n)))
             return t->type;
@@ -116,7 +116,7 @@
 Ucon *getucon(Stab *st, Node *n)
 {
     Ucon *uc;
-    
+
     do {
         if ((uc = htget(st->uc, n)))
             return uc;
@@ -128,7 +128,7 @@
 Cstr *getcstr(Stab *st, Node *n)
 {
     Cstrdefn *c;
-    
+
     do {
         if ((c = htget(st->ty, n)))
             return c->cstr;
@@ -137,11 +137,14 @@
     return NULL;
 }
 
-Stab *getns(Stab *st, Node *n)
+Stab *getns_str(Stab *st, char *name)
 {
     Stab *s;
+
+    if (!strcmp(namestr(st->name), name))
+        return st;
     do {
-        if ((s = htget(st->ns, n)))
+        if ((s = htget(st->ns, name)))
             return s;
         st = st->super;
     } while (st);
@@ -148,6 +151,11 @@
     return NULL;
 }
 
+Stab *getns(Stab *st, Node *n)
+{
+    return getns_str(st, namestr(n));
+}
+
 void putdcl(Stab *st, Node *s)
 {
     Node *d;
@@ -210,7 +218,7 @@
     s = getns(st, scope->name);
     if (s)
         fatal(scope->name->line, "Ns %s already defined", namestr(s->name));
-    htput(st->ns, scope->name, scope);
+    htput(st->ns, namestr(scope->name), scope);
 }
 
 /*
--- a/parse/type.c
+++ b/parse/type.c
@@ -25,7 +25,7 @@
 /* Built in type constraints */
 static Cstr *tycstrs[Ntypes + 1][4];
 
-Type *mkty(int line, Ty ty)
+Type *mktype(int line, Ty ty)
 {
     Type *t;
     int i;
@@ -51,7 +51,7 @@
 {
     Type *r;
 
-    r = mkty(t->line, t->type);
+    r = mktype(t->line, t->type);
     r->resolved = 0; /* re-resolving doesn't hurt */
     r->cstrs = bsdup(t->cstrs);
     r->nsub = t->nsub;
@@ -105,7 +105,7 @@
 {
     Type *t;
 
-    t = mkty(line, Tyvar);
+    t = mktype(line, Tyvar);
     return t;
 }
 
@@ -113,7 +113,7 @@
 {
     Type *t;
 
-    t = mkty(line, Typaram);
+    t = mktype(line, Typaram);
     t->pname = strdup(name);
     return t;
 }
@@ -123,7 +123,7 @@
     Type *t;
 
     /* resolve it in the type inference stage */
-    t = mkty(line, Tyunres);
+    t = mktype(line, Tyunres);
     t->name = name;
     return t;
 }
@@ -132,7 +132,7 @@
 {
     Type *t;
 
-    t = mkty(line, Tyname);
+    t = mktype(line, Tyname);
     t->name = name;
     t->nsub = 1;
     t->cstrs = bsdup(base->cstrs);
@@ -145,7 +145,7 @@
 {
     Type *t;
 
-    t = mkty(line, Tyarray);
+    t = mktype(line, Tyarray);
     t->nsub = 1;
     t->nmemb = 1; /* the size is a "member" */
     t->sub = xalloc(sizeof(Type*));
@@ -159,7 +159,7 @@
 {
     Type *t;
 
-    t = mkty(line, Tyslice);
+    t = mktype(line, Tyslice);
     t->nsub = 1;
     t->sub = xalloc(sizeof(Type*));
     t->sub[0] = base;
@@ -170,7 +170,7 @@
 {
     Type *t;
 
-    t = mkty(line, Tyvar);
+    t = mktype(line, Tyvar);
     t->nsub = 1;
     t->sub = xalloc(sizeof(Type*));
     t->sub[0] = base;
@@ -181,7 +181,7 @@
 {
     Type *t;
 
-    t = mkty(line, Typtr);
+    t = mktype(line, Typtr);
     t->nsub = 1;
     t->sub = xalloc(sizeof(Type*));
     t->sub[0] = base;
@@ -193,7 +193,7 @@
     Type *t;
     size_t i;
 
-    t = mkty(line, Tytuple);
+    t = mktype(line, Tytuple);
     t->nsub = nsub;
     t->sub = xalloc(nsub*sizeof(Type));
     for (i = 0; i < nsub; i++)
@@ -206,7 +206,7 @@
     Type *t;
     size_t i;
 
-    t = mkty(line, Tyfunc);
+    t = mktype(line, Tyfunc);
     t->nsub = nargs + 1;
     t->sub = xalloc((1 + nargs)*sizeof(Type));
     t->sub[0] = ret;
@@ -219,7 +219,7 @@
 {
     Type *t;
 
-    t = mkty(line, Tystruct);
+    t = mktype(line, Tystruct);
     t->nsub = 0;
     t->nmemb = ndecls;
     t->sdecls = memdup(decls, ndecls*sizeof(Node *));
@@ -230,7 +230,7 @@
 {
     Type *t;
 
-    t = mkty(line, Tyunion);
+    t = mktype(line, Tyunion);
     t->nmemb = ndecls;
     t->udecls = decls;
     return t;
@@ -526,7 +526,7 @@
  * constraints, otherwise they will have no constraints set on them. */
 #define Ty(t, n) \
     if (t != Ntypes) {\
-      ty = mkty(-1, t); \
+      ty = mktype(-1, t); \
       if (n) { \
           puttype(st, mkname(-1, n), ty); \
       } \
--- /dev/null
+++ b/test/neststruct.myr
@@ -1,0 +1,19 @@
+type s1 = struct
+	x : s2
+;;
+
+type s2 = struct
+	a : int
+	b : int
+;;
+
+const main = {
+	var s1 : s1
+	var s2 : s2
+
+	s1.x.a = 1
+	s1.x.b = 2
+	s2 = s1.x
+
+	-> s2.a + s2.b
+}
--- a/test/outparam-sl.myr
+++ b/test/outparam-sl.myr
@@ -1,6 +1,6 @@
 const arr = [1,2,3,4]
 const f = {out
-	*out = arr[1,3]
+	*out = arr[1:3]
 }
 
 const main = {
--- a/test/slice.myr
+++ b/test/slice.myr
@@ -2,7 +2,7 @@
 	var a : int[3]
 	var s
 
-	s = a[,]
+	s = a[:]
 	s[0] = 3
 	s[1] = 4
 	s[2] = s[0] + s[1] + s.len
--- a/test/slicelen.myr
+++ b/test/slicelen.myr
@@ -2,6 +2,6 @@
 	var a : int[8]
 	var s
 
-	s = a[1,6]
+	s = a[1:6]
 	-> s.len
 }
--- a/test/structarray.myr
+++ b/test/structarray.myr
@@ -5,7 +5,7 @@
 const main = {
 	var v : t
 
-	v.a[0] = 12
+	v.a[0] = 11
 	v.a[1] = 20
 
 	-> 2*v.a[0] + v.a[1]
--- a/test/tests
+++ b/test/tests
@@ -32,6 +32,7 @@
 B structasn	E	42
 B structarray	E	42
 B structret	E	42
+B neststruct	E	3
 B array		E	7
 B arrayaddr	E	42
 B global-arrayvar	E	7