Implement unbound varibility for struct types.

Now, if a struct member has an explicit 'uniform' or 'varying'
qualifier, then that member has that variability, regardless of
the variability of the struct's variability.  Members without
'uniform' or 'varying' have unbound variability, and in turn
inherit the variability of the struct.

As a result of this, now structs can properly be 'varying' by default,
just like all the other types, while still having sensible semantics.

tests/cfor-struct-gather-2.ispc

@@ -7,13 +7,13 @@ struct Foo {
     float f;
 };
 
-float func(uniform Foo foo[], int offset) {
+float func(Foo foo[], int offset) {
     return foo[offset].f;
 }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex];
-    uniform Foo foo[17];
+    Foo foo[17];
     uniform int i;
     cfor (i = 0; i < 17; ++i)
         foo[i].f = i*a;

tests/cfor-struct-gather-3.ispc

@@ -7,13 +7,13 @@ struct Foo {
     float f;
 };
 
-float func(uniform Foo foo[], int offset) {
+float func(Foo foo[], int offset) {
     return foo[offset].f;
 }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex];
-    uniform Foo foo[17];
+    Foo foo[17];
     uniform int i;
     cfor (i = 0; i < 17; ++i)
         foo[i].f = i*a;

tests/cfor-struct-gather.ispc

@@ -9,7 +9,7 @@ struct Foo {
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex];
-    uniform Foo foo[17];
+    Foo foo[17];
     uniform int i;
     cfor (i = 0; i < 17; ++i)
         foo[i].f = i*a;

tests/gather-struct-vector.ispc

@@ -14,7 +14,7 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
         r[i].v.z = 300*i + 3*programIndex;
     }
 
-    Ray *rp = &r[programIndex/2];
+    varying Ray *rp = &r[programIndex/2];
     RET[programIndex] = rp->v.z; 
 }
 

tests/masked-scatter-struct.ispc

@@ -1,13 +1,15 @@
 
 export uniform int width() { return programCount; }
 
-struct Foo { uniform float x; float y; };
+struct Foo { float x; float y; };
 
 export void f_fu(uniform float ret[], uniform float aa[], uniform float b) {
     float a = aa[programIndex];
-    Foo foo[32];
-    for (uniform int i = 0; i < 32; ++i)
+    uniform Foo foo[32];
+    for (uniform int i = 0; i < 32; ++i) {
         foo[i].x = i;
+        foo[i].y = -1234 + i;
+    }
     varying Foo fv = foo[a];
     fv.x += 1000;
 //CO    print("fv.x = %\n", fv.x);

tests/new-delete-5.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 struct Point {
-    uniform float x, y, z;
+    float x, y, z;
 };
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {

tests/new-delete-6.ispc

@@ -7,7 +7,7 @@ struct Point {
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex]; 
-    uniform Point * buf = new Point(0., b, a);
+    varying Point * buf = new varying Point(0., b, a);
     RET[programIndex] = buf->z;
     delete buf;
 }

tests/ptr-22.ispc

@@ -6,14 +6,14 @@ struct Foo {
     uniform float b;
 };
 
-void update(uniform Foo * varying fp) {
+void update(varying Foo * varying fp) {
     ++fp;
     fp->a -= 1;
     fp->b = 1;
 }
 
 export void f_f(uniform float RET[], uniform float aFOO[]) {
-    uniform Foo f[2] = { { 1234, 4321 }, { aFOO[programIndex], 5 } };
+    Foo f[2] = { { 1234, 4321 }, { aFOO[programIndex], 5 } };
     update(f);
     RET[programIndex] = f[1].a;
 }

tests/struct-gather-2.ispc

@@ -7,13 +7,13 @@ struct Foo {
     float f;
 };
 
-float func(uniform Foo foo[], int offset) {
+float func(Foo foo[], int offset) {
     return foo[offset].f;
 }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex];
-    uniform Foo foo[17];
+    Foo foo[17];
     uniform int i;
     for (i = 0; i < 17; ++i)
         foo[i].f = i*a;

tests/struct-gather-3.ispc

@@ -7,13 +7,13 @@ struct Foo {
     float f;
 };
 
-float func(uniform Foo foo[], int offset) {
+float func(Foo foo[], int offset) {
     return foo[offset].f;
 }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex];
-    uniform Foo foo[17];
+    Foo foo[17];
     uniform int i;
     for (i = 0; i < 17; ++i)
         foo[i].f = i*a;

tests/struct-gather.ispc

@@ -9,7 +9,7 @@ struct Foo {
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex];
-    uniform Foo foo[17];
+    Foo foo[17];
     uniform int i;
     for (i = 0; i < 17; ++i)
         foo[i].f = i*a;

tests/struct-nested-1.ispc

@@ -0,0 +1,34 @@
+
+struct Vector { float x, y, z; };
+
+struct Ray { Vector o; float t; Vector d; };
+
+export uniform int width() { return programCount; }
+
+void init(varying Ray rays[], uniform int count, float v) {
+    for (uniform int i = 0; i < count; ++i) {
+        rays[i].o.x = programIndex;
+        rays[i].o.y = v;
+        rays[i].o.z = -1234;
+        rays[i].t = 42;
+        rays[i].d.x = 2*v;
+        rays[i].d.y = 3*v;
+        rays[i].d.z = 4*v;
+    }
+}
+
+void zero_dx(Ray &r) {
+    r.d.x = 0;
+}
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float v = aFOO[programIndex];
+    Ray rays[10];
+    init(rays, 10, v);
+    zero_dx(rays[b]);
+    RET[programIndex] = rays[5].d.x + rays[5].d.y; 
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 3 + 3*programIndex;
+}

tests/struct-nested-2.ispc

@@ -0,0 +1,34 @@
+
+struct Vector { float x, y, z; };
+
+struct Ray { Vector o; float t; Vector d; };
+
+export uniform int width() { return programCount; }
+
+void init(uniform Ray rays[], uniform int count, float v) {
+    for (uniform int i = 0; i < count; ++i) {
+        rays[i].o.x = i;
+        rays[i].o.y = 2*i;
+        rays[i].o.z = 3*i;
+        rays[i].t = 4*i;
+        rays[i].d.x = 5*i;
+        rays[i].d.y = 6*i;
+        rays[i].d.z = 7*i;
+    }
+}
+
+void zero_dx(Ray &r) {
+    r.d.x = 0;
+}
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float v = aFOO[programIndex];
+    uniform Ray rays[programCount+1];
+    init(rays, programCount+1, v);
+    Ray rg = rays[v];
+    RET[programIndex] = rg.o.z;
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 3 + 3*programIndex;
+}

tests/struct-nested-3.ispc

@@ -0,0 +1,35 @@
+
+struct Vector { float x, y, z; };
+
+struct Ray { Vector o; float t; Vector d; };
+
+export uniform int width() { return programCount; }
+
+void init(uniform Ray rays[], uniform int count, float v) {
+    for (uniform int i = 0; i < count; ++i) {
+        rays[i].o.x = i;
+        rays[i].o.y = 2*i;
+        rays[i].o.z = 3*i;
+        rays[i].t = 4*i;
+        rays[i].d.x = 5*i;
+        rays[i].d.y = 6*i;
+        rays[i].d.z = 7*i;
+    }
+}
+
+void zero_dx(Ray &r) {
+    r.d.x = 0;
+}
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float v = aFOO[programIndex];
+    uniform Ray rays[programCount+1];
+    init(rays, programCount+1, v);
+    Ray rg = rays[v];
+    zero_dx(rg);
+    RET[programIndex] = rg.o.z + rg.d.x;
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 3 + 3*programIndex;
+}

tests/struct-nested-4.ispc

@@ -0,0 +1,35 @@
+
+struct Vector { float x, y, z; };
+
+struct Ray { Vector o; float t; Vector d; };
+
+export uniform int width() { return programCount; }
+
+void init(uniform Ray rays[], uniform int count, float v) {
+    for (uniform int i = 0; i < count; ++i) {
+        rays[i].o.x = i;
+        rays[i].o.y = 2*i;
+        rays[i].o.z = 3*i;
+        rays[i].t = 4*i;
+        rays[i].d.x = 5*i;
+        rays[i].d.y = 6*i;
+        rays[i].d.z = 7*i;
+    }
+}
+
+void zero_dx(Ray * uniform r) {
+    r->d.x = 0;
+}
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float v = aFOO[programIndex];
+    uniform Ray rays[programCount+1];
+    init(rays, programCount+1, v);
+    Ray rg = rays[v];
+    zero_dx(&rg);
+    RET[programIndex] = rg.o.z + rg.d.x;
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 3 + 3*programIndex;
+}

tests/struct-nested-5.ispc

@@ -0,0 +1,35 @@
+
+struct Vector { float x, y, z; };
+
+struct Ray { Vector o; float t; Vector d; };
+
+export uniform int width() { return programCount; }
+
+void init(uniform Ray rays[], uniform int count, float v) {
+    for (uniform int i = 0; i < count; ++i) {
+        rays[i].o.x = i;
+        rays[i].o.y = 2*i;
+        rays[i].o.z = 3*i;
+        rays[i].t = 4*i;
+        rays[i].d.x = 5*i;
+        rays[i].d.y = 6*i;
+        rays[i].d.z = 7*i;
+    }
+}
+
+void zero_dx(uniform Ray * r) {
+    r->d.x = 0;
+}
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float v = aFOO[programIndex];
+    uniform Ray rays[programCount+1];
+    init(rays, programCount+1, v);
+    zero_dx(&rays[v]);
+    Ray rg = rays[v];
+    RET[programIndex] = rg.o.z + rg.d.x;
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 3 + 3*programIndex;
+}

tests/struct-ref-lvalue.ispc

@@ -5,13 +5,13 @@ export uniform int width() { return programCount; }
 
 struct Foo { float f; };
 
-void f(uniform Foo foo[], float a) {
+void f(Foo foo[], float a) {
     ++foo[a].f;
 }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex];
-    uniform Foo foo[17];
+    Foo foo[17];
     for (uniform int i = 0; i < 17; ++i)
         foo[i].f = a;
     f(foo, a);

tests/struct-test-115.ispc

@@ -3,7 +3,7 @@ export uniform int width() { return programCount; }
 
 
 struct Foo {
-    uniform float x;
+    varying float x;
     uniform float f;
 };
 

tests/struct-test-116.ispc

@@ -3,8 +3,8 @@ export uniform int width() { return programCount; }
 
 
 struct Foo {
-    uniform float x;
-    uniform float f;
+    float x;
+    float f;
 };
 
 export void f_fi(uniform float RET[], uniform float aFOO[], uniform int bFOO[]) {

tests/struct-test-118.ispc

@@ -9,9 +9,9 @@ struct Foo {
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex];
-    uniform Foo myFoo[3] = { { -1, -2 }, {a, -3}, {-4, -5} };
+    Foo myFoo[3] = { { -1, -2 }, {a, -3}, {-4, -5} };
     int i = aFOO[0];
-    varying Foo barFoo = myFoo[i];
+    Foo barFoo = myFoo[i];
 //CO    print("% %\n", myFoo[i].x, barFoo.x);
     RET[programIndex] = barFoo.x;
 }

tests/struct-test-119.ispc

@@ -13,7 +13,7 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     varying Foo myFoo[3] = { { b, b, {b, b, b} }, 
                              { b, b, {b, b, b} }, 
                              { b, b, {b, b, b} } };
-    uniform Foo barFoo;
+    Foo barFoo;
     barFoo = myFoo[0];
     RET[programIndex] = barFoo.x + myFoo[1].i[2];
 }

tests/struct-vary-index-expr.ispc

@@ -7,10 +7,11 @@ struct Foo { float f; };
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex];
-    uniform Foo foo[17];
+    Foo foo[17];
     for (uniform int i = 0; i < 17; ++i)
         foo[i].f = a;
     ++foo[a].f;
+    assert(programCount <= 16);
     uniform int i[16] = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16 };
     RET[programIndex] = foo[i[programIndex]].f;
 }

tests/unif-struct-test-113.ispc

@@ -3,8 +3,8 @@ export uniform int width() { return programCount; }
 
 
 struct Foo {
-    int i;
-    float f;
+    varying int i;
+    varying float f;
 };
 export void f_f(uniform float RET[], uniform float aFOO[]) {
     float a = aFOO[programIndex];

tests/unif-struct-test-117.ispc

@@ -6,9 +6,10 @@ struct Foo {
     float x;
     float f;
 };
+
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex];
-    uniform struct Foo myFoo = {a,a};
+    struct Foo myFoo = {a,a};
     RET[programIndex] = myFoo.x;
 }
 

tests/unif-struct-test-118.ispc

@@ -8,8 +8,8 @@ struct Foo {
 };
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex];
-    uniform struct Foo myFoo[3] = { { a,a}, {a,a}, {a,a} };
-    uniform struct Foo barFoo;
+    struct Foo myFoo[3] = { { a,a}, {a,a}, {a,a} };
+    struct Foo barFoo;
     barFoo = myFoo[1];
     RET[programIndex] = barFoo.x;
 }

tests/unif-struct-test-120.ispc

@@ -7,12 +7,13 @@ struct Foo {
     float f;
     int i[3];
 };
-float bar(uniform struct Foo f) { return f.f; }
+
+float bar(struct Foo f) { return f.f; }
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex];
-    uniform struct Foo myFoo[3] = { { a, a, {a, a, a} }, 
-                                    { a, a, {a, a, a} }, 
-                                    { a, a, {a, a, a} } };
+    struct Foo myFoo[3] = { { a, a, {a, a, a} }, 
+                            { a, a, {a, a, a} }, 
+                            { a, a, {a, a, a} } };
     RET[programIndex] = bar(myFoo[1]);
 }
 

tests/unif-struct-test-121.ispc

@@ -3,8 +3,9 @@ export uniform int width() { return programCount; }
 
 
 struct Foo {
-    float x;
+    varying float x;
 };
+
 float bar(uniform struct Foo f) { ++f.x; return f.x; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {

tests/unif-struct-test-122.ispc

@@ -3,7 +3,7 @@ export uniform int width() { return programCount; }
 
 
 struct Foo {
-    float x;
+    varying float x;
 };
 float bar(uniform struct Foo * uniform f) { ++((*f).x); return (*f).x; }
 

tests/unif-struct-test-123.ispc

@@ -3,7 +3,7 @@ export uniform int width() { return programCount; }
 
 
 struct Foo {
-    float x;
+    varying float x;
 };
 void bar(uniform struct Foo * uniform f) { ++((*f).x); }
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {

tests/varying-struct-2.ispc

@@ -2,19 +2,19 @@
 export uniform int width() { return programCount; }
 
 
-
-struct Foo {
-    uniform float x, y;
-};
-
+
+struct Foo {
+    float x, y;
+};
+
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    float a = aFOO[programIndex];
-    Foo f[3] = { { b, b }, { 2*b, 2*b }, { 3*b, 3*b } };
-    int index = (a <= 2) ? 1 : 2;
-    varying Foo g = f[index];
-    RET[programIndex] = g.x;
-}
-
+    float a = aFOO[programIndex];
+    uniform Foo f[3] = { { b, b }, { 2*b, 2*b }, { 3*b, 3*b } };
+    int index = (a <= 2) ? 1 : 2;
+    varying Foo g = f[index];
+    RET[programIndex] = g.x;
+}
+
 export void result(uniform float RET[]) { 
     RET[programIndex] = 15;
     RET[0] = RET[1] = 10;

tests/varying-struct-3.ispc

@@ -2,19 +2,19 @@
 export uniform int width() { return programCount; }
 
 
-
-struct Foo {
-    uniform float x, y;
-};
-
+
+struct Foo {
+    float x, y;
+};
+
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    float a = aFOO[programIndex];
-    Foo f[3] = { { b, b }, { 2*b, 2*b }, { 3*b, 3*b } };
-    int index = (a <= 2) ? 1 : 2;
-    varying Foo g = f[index];
-    RET[programIndex] = g.x;
-}
-
+    float a = aFOO[programIndex];
+    uniform Foo f[3] = { { b, b }, { 2*b, 2*b }, { 3*b, 3*b } };
+    int index = (a <= 2) ? 1 : 2;
+    varying Foo g = f[index];
+    RET[programIndex] = g.x;
+}
+
 export void result(uniform float RET[4]) { 
     RET[programIndex] = 15;
     RET[0] = RET[1] = 10;

tests/varying-struct-4.ispc

@@ -2,19 +2,19 @@
 export uniform int width() { return programCount; }
 
 
-
-struct Foo {
-    uniform float x, y;
-};
-
+
+struct Foo {
+    float x, y;
+};
+
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    float a = aFOO[programIndex];
-    Foo f[3] = { { b, 2*b }, { 3*b, 4*b }, { 5*b, 6*b } };
-    int index = (a <= 2) ? 1 : 2;
-    varying Foo g = f[index];
-    RET[programIndex] = g.x;
-}
-
+    float a = aFOO[programIndex];
+    uniform Foo f[3] = { { b, 2*b }, { 3*b, 4*b }, { 5*b, 6*b } };
+    int index = (a <= 2) ? 1 : 2;
+    varying Foo g = f[index];
+    RET[programIndex] = g.x;
+}
+
 export void result(uniform float RET[]) { 
     RET[programIndex] = 25;
     RET[0] = RET[1] = 15;

tests/varying-struct-5.ispc

@@ -2,23 +2,23 @@
 export uniform int width() { return programCount; }
 
 
-
-struct Foo {
-    uniform float x, y;
-};
-
-struct Bar {
-    uniform Foo uf;
-    varying Foo vf;
-};
-
+
+struct Foo {
+    float x, y;
+};
+
+struct Bar {
+    uniform Foo uf;
+    varying Foo vf;
+};
+
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    float a = aFOO[programIndex];
-    //    Bar bar = { { b, b }, { a, a } };
-    Bar bar;
-    bar.uf.x = b;
-    bar.vf.y = a;
-    RET[programIndex] = bar.uf.x + bar.vf.y;
-}
-
-export void result(uniform float RET[]) { RET[programIndex] = 6+programIndex; }
+    float a = aFOO[programIndex];
+    //    Bar bar = { { b, b }, { a, a } };
+    Bar bar;
+    bar.uf.x = b;
+    bar.vf.y = a;
+    RET[programIndex] = bar.uf.x + bar.vf.y;
+}
+
+export void result(uniform float RET[]) { RET[programIndex] = 6+programIndex; }

tests/varying-struct-6.ispc

@@ -2,20 +2,20 @@
 export uniform int width() { return programCount; }
 
 
-
-struct Foo {
-    uniform float x, y;
-};
-
-struct Bar {
-    uniform Foo uf;
-    varying Foo vf;
-};
-
+
+struct Foo {
+    float x, y;
+};
+
+struct Bar {
+    uniform Foo uf;
+    varying Foo vf;
+};
+
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    float a = aFOO[programIndex];
-    Bar bar = { { b, b }, { a, a } };
-    RET[programIndex] = bar.uf.x + bar.vf.y;
-}
-
-export void result(uniform float RET[4]) { RET[programIndex] = 6+programIndex; }
+    float a = aFOO[programIndex];
+    Bar bar = { { b, b }, { a, a } };
+    RET[programIndex] = bar.uf.x + bar.vf.y;
+}
+
+export void result(uniform float RET[4]) { RET[programIndex] = 6+programIndex; }

tests/varying-struct.ispc

@@ -2,16 +2,16 @@
 export uniform int width() { return programCount; }
 
 
-
-struct Foo {
-    uniform float x, y;
-};
-
+
+struct Foo {
+    float x, y;
+};
+
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    float a = aFOO[programIndex];
-    varying Foo g;
-    g.x = a;
-    RET[programIndex] = g.x;
-}
-
-export void result(uniform float RET[]) { RET[programIndex] = 1+programIndex; }
+    float a = aFOO[programIndex];
+    varying Foo g;
+    g.x = a;
+    RET[programIndex] = g.x;
+}
+
+export void result(uniform float RET[]) { RET[programIndex] = 1+programIndex; }