get rid of static/dynamic array distinction

R=r
OCL=14634
CL=14634

diff --git a/src/cmd/6g/align.c b/src/cmd/6g/align.c
index 8c837dd885e2abc2c9a1e90c58c67d5dcd107087..cab2a93c11da5e3bbe2493a00488f3854db18a99 100644 (file)
--- a/src/cmd/6g/align.c
+++ b/src/cmd/6g/align.c
@@ -157,14 +157,13 @@ dowidth(Type *t)
        case TSTRING:           // implemented as pointer
                w = wptr;
                break;
-       case TDARRAY:
-               fatal("width of a dynamic array");
        case TARRAY:
+               if(t->bound < 0)
+                       fatal("width of a dynamic array");
                if(t->type == T)
                        break;
                dowidth(t->type);
-               w = t->bound * t->type->width
-;//                    + offsetof(Array, b[0]);
+               w = t->bound * t->type->width;
                break;
 
        case TSTRUCT:

diff --git a/src/cmd/6g/cgen.c b/src/cmd/6g/cgen.c
index 7870a8f7e6d0c253f795202a0181847a1a0c6e50..f85b8e4e1a1477dd16d733e2fe88f9da0a56ef7a 100644 (file)
--- a/src/cmd/6g/cgen.c
+++ b/src/cmd/6g/cgen.c
@@ -136,7 +136,7 @@ cgen(Node *n, Node *res)
                }
                regalloc(&n1, nl->type, res);
                cgen(nl, &n1);
-               if(isptrto(n->type, TARRAY) && isptrto(nl->type, TDARRAY)) {
+               if(isptrarray(n->type) && isptrdarray(nl->type)) {
                        // convert dynamic array to static array
                        n2 = n1;
                        n2.op = OINDREG;
@@ -144,7 +144,7 @@ cgen(Node *n, Node *res)
                        n2.type = types[tptr];
                        gins(AMOVQ, &n2, &n1);
                }
-               if(isptrto(n->type, TDARRAY) && isptrto(nl->type, TARRAY)) {
+               if(isptrdarray(n->type) && isptrarray(nl->type)) {
                        // conver static array to dynamic array
                        // it is assumed that the dope is just before the array
                        nodconst(&n2, types[tptr], offsetof(Array,b));
@@ -187,7 +187,7 @@ cgen(Node *n, Node *res)
                        regfree(&n1);
                        break;
                }
-               if(isptrto(nl->type, TDARRAY)) {
+               if(isptrdarray(nl->type)) {
                        regalloc(&n1, types[tptr], res);
                        cgen(nl, &n1);
                        n1.op = OINDREG;
@@ -201,7 +201,7 @@ cgen(Node *n, Node *res)
                break;
 
        case OCAP:
-               if(isptrto(nl->type, TDARRAY)) {
+               if(isptrdarray(nl->type)) {
                        regalloc(&n1, types[tptr], res);
                        cgen(nl, &n1);
                        n1.op = OINDREG;
@@ -387,7 +387,7 @@ agen(Node *n, Node *res)
                // i is in &n1
                // w is width
 
-               if(isptrto(nl->type, TDARRAY)) {
+               if(isptrdarray(nl->type)) {
                        regalloc(&n2, types[tptr], res);
                        gmove(res, &n2);
 
@@ -418,7 +418,7 @@ agen(Node *n, Node *res)
                        if(!debug['B']) {
                                // check bounds
                                nodconst(&n3, types[TUINT32], nl->type->bound);
-                               if(isptrto(nl->type, TARRAY))
+                               if(isptrarray(nl->type))
                                        nodconst(&n3, types[TUINT32], nl->type->type->bound);
                                gins(optoas(OCMP, types[TUINT32]), &n1, &n3);
 

diff --git a/src/cmd/6g/gsubr.c b/src/cmd/6g/gsubr.c
index d6dff2c0b807c5f505826c05d9b3ef6d7d4e38d4..20654fa9d89b72084abf3eb4ef2e3599f8d38d74 100644 (file)
--- a/src/cmd/6g/gsubr.c
+++ b/src/cmd/6g/gsubr.c
@@ -1604,7 +1604,6 @@ isfat(Type *t)
        switch(t->etype) {
        case TSTRUCT:
        case TARRAY:
-       case TDARRAY:
        case TINTER:    // maybe remove later
                return 1;
        }

diff --git a/src/cmd/gc/dcl.c b/src/cmd/gc/dcl.c
index 2db8c325c45b09fe82327c25dc45bc7e27d4001d..54c437d3cd2bf4c138e2e913b49bb5d2f7f38bf8 100644 (file)
--- a/src/cmd/gc/dcl.c
+++ b/src/cmd/gc/dcl.c
@@ -481,7 +481,7 @@ loop:
        if(n->op != ODCLFIELD || n->type == T)
                fatal("stotype: oops %N\n", n);
 
-       if(n->type->etype == TDARRAY)
+       if(n->type->etype == TARRAY && n->type->bound < 0)
                yyerror("type of a structure field cannot be an open array");
 
        f = typ(TFIELD);

diff --git a/src/cmd/gc/export.c b/src/cmd/gc/export.c
index 57f823d6f2f6dcb39a21d227c2045d317a99dc3f..226952fcc879650500e20f6d1f0d11281ec216a3 100644 (file)
--- a/src/cmd/gc/export.c
+++ b/src/cmd/gc/export.c
@@ -147,18 +147,16 @@ dumpexporttype(Sym *s)
                break;
 
        case TARRAY:
-       case TDARRAY:
                reexport(t->type);
 
                /* type 2 */
                Bprint(bout, "\ttype ");
                if(s->export != 0)
                        Bprint(bout, "!");
-               if(et == TDARRAY) {
+               if(t->bound >= 0)
+                       Bprint(bout, "%lS [%lud] %lS\n", s, t->bound, t->type->sym);
+               else
                        Bprint(bout, "%lS [] %lS\n", s, t->type->sym);
-                       break;
-               }
-               Bprint(bout, "%lS [%lud] %lS\n", s, t->bound, t->type->sym);
                break;
 
        case TPTR32:
@@ -522,13 +520,10 @@ doimport2(Node *ss, Val *b, Node *st)
        Type *t;
        Sym *s;
 
-       if(b == nil) {
-               t = typ(TDARRAY);
-               t->dbound = N;
-       } else {
-               t = typ(TARRAY);
+       t = typ(TARRAY);
+       t->bound = -1;
+       if(b != nil)
                t->bound = mpgetfix(b->u.xval);
-       }
        s = pkglookup(st->sym->name, st->psym->name);
        t->type = s->otype;
 

diff --git a/src/cmd/gc/go.h b/src/cmd/gc/go.h
index 02e15810b603c578d8b124aa259defb8d70681eb..4237278f92d5ab5e1cf3398757e69f94ef807daa 100644 (file)
--- a/src/cmd/gc/go.h
+++ b/src/cmd/gc/go.h
@@ -140,8 +140,7 @@ struct      Type
        vlong   argwid;
 
        // TARRAY
-       int32   bound;
-       Node*   dbound;
+       int32   bound;          // negative is dynamic array
 };
 #define        T       ((Type*)0)
 
@@ -303,7 +302,7 @@ enum
 
        TFUNC,
        TARRAY,
-       TDARRAY,
+       T_old_DARRAY,
        TSTRUCT,
        TCHAN,
        TMAP,
@@ -558,6 +557,8 @@ void        dump(char*, Node*);
 Type*  aindex(Node*, Type*);
 int    isnil(Node*);
 int    isptrto(Type*, int);
+int    isptrarray(Type*);
+int    isptrdarray(Type*);
 int    isinter(Type*);
 int    isbytearray(Type*);
 int    eqtype(Type*, Type*, int);

diff --git a/src/cmd/gc/subr.c b/src/cmd/gc/subr.c
index 66e20b863d6384f74ade3d0719a4a3c047dd5c26..b925e5061e1a9dff4033d75058d2bd022a62db89 100644 (file)
--- a/src/cmd/gc/subr.c
+++ b/src/cmd/gc/subr.c
@@ -376,38 +376,28 @@ aindex(Node *b, Type *t)
        Type *r;
        int bound;
 
+       bound = -1;     // open bound
        walktype(b, Erv);
        switch(whatis(b)) {
        default:        // variable bound
-               walktype(b, Erv);
-               if(b->type != T && isint[b->type->etype])
-                       goto dyn;
                yyerror("array bound must be an integer expression");
-               bound = 0;
                break;
 
        case Wnil:      // open bound
-               goto dyn;
+               break;
 
        case Wlitint:   // fixed bound
                bound = mpgetfix(b->val.u.xval);
+               if(bound < 0)
+                       yyerror("array bound must be non negative");
                break;
        }
 
        // fixed array
        r = typ(TARRAY);
        r->type = t;
-       r->dbound = b;
        r->bound = bound;
        return r;
-
-dyn:
-       // dynamic array
-       r = typ(TDARRAY);
-       r->type = t;
-       r->dbound = b;
-       r->bound = 0;
-       return r;
 }
 
 void
@@ -806,7 +796,7 @@ etnames[] =
        [TPTR64]        = "PTR64",
        [TFUNC]         = "FUNC",
        [TARRAY]        = "ARRAY",
-       [TDARRAY]       = "DARRAY",
+//     [TDARRAY]       = "DARRAY",
        [TSTRUCT]       = "STRUCT",
        [TCHAN]         = "CHAN",
        [TMAP]          = "MAP",
@@ -1008,14 +998,10 @@ Tconv(Fmt *fp)
                break;
 
        case TARRAY:
-               snprint(buf1, sizeof(buf1), "[%ld]%T", t->bound, t->type);
-               strncat(buf, buf1, sizeof(buf));
-               break;
-
-       case TDARRAY:
-               snprint(buf1, sizeof(buf1), "[]%T", t->type);
-               if(t->dbound != N)
-                       snprint(buf1, sizeof(buf1), "[<expr>]%T", t->type);
+               if(t->bound >= 0)
+                       snprint(buf1, sizeof(buf1), "[%ld]%T", t->bound, t->type);
+               else
+                       snprint(buf1, sizeof(buf1), "[]%T", t->type);
                strncat(buf, buf1, sizeof(buf));
                break;
 
@@ -1216,6 +1202,24 @@ isptrto(Type *t, int et)
        return 1;
 }
 
+int
+isptrarray(Type *t)
+{
+       if(isptrto(t, TARRAY))
+               if(t->type->bound >= 0)
+                       return 1;
+       return 0;
+}
+
+int
+isptrdarray(Type *t)
+{
+       if(isptrto(t, TARRAY))
+               if(t->type->bound < 0)
+                       return 1;
+       return 0;
+}
+
 int
 isinter(Type *t)
 {
@@ -1324,7 +1328,6 @@ loop:
        case TPTR64:
        case TCHAN:
        case TARRAY:
-       case TDARRAY:
                stp = &st->type;
                goto loop;
 
@@ -1395,7 +1398,6 @@ deep(Type *t)
        case TPTR64:
        case TCHAN:
        case TARRAY:
-       case TDARRAY:
                nt = shallow(t);
                nt->type = deep(t->type);
                break;

diff --git a/src/cmd/gc/walk.c b/src/cmd/gc/walk.c
index 5b2fc97539505c67932abec0e0ba29118a655243..23ec5dbc3b84ae4f5bf6fb86c26bcb6c277198b0 100644 (file)
--- a/src/cmd/gc/walk.c
+++ b/src/cmd/gc/walk.c
@@ -430,7 +430,7 @@ loop:
                }
 
                // convert dynamic to static generated by ONEW
-               if(isptrto(t, TARRAY) && isptrto(l->type, TDARRAY))
+               if(isptrarray(t) && isptrdarray(l->type))
                        goto ret;
 
 //             if(t->etype == TARRAY) {
@@ -560,10 +560,10 @@ loop:
                        goto badt;
                case TSTRING:
                case TMAP:
-               case TDARRAY:
                        break;
                case TARRAY:
-                       nodconst(n, types[TINT32], t->bound);
+                       if(t->bound >= 0)
+                               nodconst(n, types[TINT32], t->bound);
                        break;
                }
                n->type = types[TINT32];
@@ -582,10 +582,9 @@ loop:
                switch(t->etype) {
                default:
                        goto badt;
-               case TDARRAY:
-                       break;
                case TARRAY:
-                       nodconst(n, types[TINT32], t->bound);
+                       if(t->bound >= 0)
+                               nodconst(n, types[TINT32], t->bound);
                        break;
                }
                n->type = types[TINT32];
@@ -652,7 +651,6 @@ loop:
                                *n = *mapop(n, top);
                        break;
 
-               case TDARRAY:
                case TARRAY:
                        // right side must be an int
                        if(n->right->type == T) {
@@ -704,7 +702,7 @@ loop:
                        *n = *stringop(n, top);
                        goto ret;
                }
-               if(t->etype == TDARRAY || t->etype == TARRAY) {
+               if(t->etype == TARRAY) {
                        *n = *arrayop(n, top);
                        goto ret;
                }
@@ -1435,8 +1433,8 @@ ascompat(Type *t1, Type *t2)
                if(isptrto(t1, TSTRUCT))
                        return 1;
 
-       if(isptrto(t1, TDARRAY))
-               if(isptrto(t2, TARRAY))
+       if(isptrdarray(t1))
+               if(isptrarray(t2))
                        return 1;
        return 0;
 }
@@ -1542,7 +1540,6 @@ newcompat(Node *n)
                r = chanop(n, Erv);
                return r;
 
-       case TDARRAY:
        case TARRAY:
                r = arrayop(n, Erv);
                return r;
@@ -2134,7 +2131,7 @@ fixarray(Type *tm)
                return T;
        }
 
-       if(t->etype != TDARRAY && t->etype != TARRAY) {
+       if(t->etype != TARRAY) {
                fatal("fixarray: %lT not array", tm);
                return T;
        }
@@ -2172,15 +2169,19 @@ arrayop(Node *n, int top)
                r = a;
 
                a = listfirst(&save, &n->left);         // max
+               a = listnext(&save);
                if(a == N)
                        a = nodintconst(0);
                a = nod(OCONV, a, N);
                a->type = types[TUINT32];
                r = list(a, r);
 
-               a = t->dbound;                          // nel
-               if(a == N)
+               a = listfirst(&save, &n->left);         // nel
+               if(a == N) {
+                       if(t->bound < 0)
+                               yyerror("new open array must have size");
                        a = nodintconst(t->bound);
+               }
                a = nod(OCONV, a, N);
                a->type = types[TUINT32];
                r = list(a, r);
@@ -2221,7 +2222,7 @@ arrayop(Node *n, int top)
                return n;
 
        case OSLICE:
-               if(isptrto(n->left->type, TARRAY))
+               if(isptrarray(n->left->type))
                        goto slicestatic;
 
                // arrayslices(old *[]any, lb uint32, hb uint32, width uint32) (ary *[]any)
@@ -2381,7 +2382,7 @@ convas(Node *n)
                return n;
        }
 
-       if(isptrto(lt, TDARRAY) && isptrto(rt, TARRAY)) {
+       if(isptrdarray(lt) && isptrarray(rt)) {
                if(!eqtype(lt->type->type, rt->type->type, 0))
                        goto bad;
                *n = *arrayop(n, Etop);