Add support for pointers to the language.

Pointers can be either uniform or varying, and behave correspondingly.
e.g.: "uniform float * varying" is a varying pointer to uniform float
data in memory, and "float * uniform" is a uniform pointer to varying
data in memory.  Like other types, pointers are varying by default.

Pointer-based expressions, & and *, sizeof, ->, pointer arithmetic,
and the array/pointer duality all bahave as in C.  Array arguments
to functions are converted to pointers, also like C.

There is a built-in NULL for a null pointer value; conversion from
compile-time constant 0 values to NULL still needs to be implemented.

Other changes:
- Syntax for references has been updated to be C++ style; a useful
  warning is now issued if the "reference" keyword is used.
- It is now illegal to pass a varying lvalue as a reference parameter
  to a function; references are essentially uniform pointers.
  This case had previously been handled via special case call by value
  return code.  That path has been removed, now that varying pointers
  are available to handle this use case (and much more).
- Some stdlib routines have been updated to take pointers as
  arguments where appropriate (e.g. prefetch and the atomics).
  A number of others still need attention.
- All of the examples have been updated
- Many new tests

TODO: documentation

tests/aossoa-1.ispc

@@ -11,7 +11,7 @@ export void f_v(uniform float RET[]) {
         a[i] = i;
 
     float x=-1, y=-1, z=-1;
-    aos_to_soa3(a, 0, x, y, z);
+    aos_to_soa3(a, 0, &x, &y, &z);
 
     int errs = 0;
     if (x != width * programIndex) ++errs;

tests/aossoa-2.ispc

@@ -11,7 +11,7 @@ export void f_v(uniform float RET[]) {
         a[i] = i;
 
     float x=-1, y=-1, z=-1, w=-1;
-    aos_to_soa4(a, 0, x, y, z, w);
+    aos_to_soa4(a, 0, &x, &y, &z, &w);
 
     int errs = 0;
     if (x != width * programIndex) ++errs;

tests/aossoa-5.ispc

@@ -11,7 +11,7 @@ export void f_v(uniform float RET[]) {
         a[i] = i;
 
     int x=-1, y=-1, z=-1;
-    aos_to_soa3(a, 0, x, y, z);
+    aos_to_soa3(a, 0, &x, &y, &z);
 
     int errs = 0;
     if (x != width * programIndex) ++errs;

tests/aossoa-6.ispc

@@ -11,7 +11,7 @@ export void f_v(uniform float RET[]) {
         a[i] = i;
 
     int x=-1, y=-1, z=-1, w=-1;
-    aos_to_soa4(a, 0, x, y, z, w);
+    aos_to_soa4(a, 0, &x, &y, &z, &w);
 
     int errs = 0;
     if (x != width * programIndex) ++errs;

tests/array-assignment-varying-control.ispc

@@ -5,7 +5,7 @@ export uniform int width() { return programCount; }
 
 struct Foo { float f; };
 
-void f(reference uniform Foo foo[], float a) {
+void f(uniform Foo foo[], float a) {
     ++foo[a].f;
 }
 

tests/atomics-1.ispc

@@ -6,7 +6,7 @@ uniform unsigned int32 s = 0;
 export void f_f(uniform float RET[], uniform float aFOO[]) {
     float a = aFOO[programIndex]; 
     float delta = 1;
-    float b = atomic_add_global(s, delta);
+    float b = atomic_add_global(&s, delta);
     RET[programIndex] = reduce_add(b);
 }
 

tests/atomics-10.ispc

@@ -8,7 +8,7 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
     float b = 0;
     float delta = 1;
     if (programIndex < 2)
-        b = atomic_add_global(s, delta);
+        b = atomic_add_global(&s, delta);
     RET[programIndex] = s;
 }
 

tests/atomics-11.ispc

@@ -7,7 +7,7 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
     float a = aFOO[programIndex]; 
     float b = 0;
     if (programIndex & 1)
-        b = atomic_add_global(s, programIndex);
+        b = atomic_add_global(&s, programIndex);
     RET[programIndex] = s;
 }
 

tests/atomics-12.ispc

@@ -7,7 +7,7 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
     float a = aFOO[programIndex]; 
     float b = 0;
     if (programIndex & 1)
-        b = atomic_or_global(s, (1 << programIndex));
+        b = atomic_or_global(&s, (1 << programIndex));
     RET[programIndex] = s;
 }
 

tests/atomics-13.ispc

@@ -7,7 +7,7 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
     float a = aFOO[programIndex]; 
     float b = 0;
     if (programIndex & 1)
-        b = atomic_or_global(s, (1 << programIndex));
+        b = atomic_or_global(&s, (1 << programIndex));
     RET[programIndex] = popcnt(reduce_max((int32)b));
 }
 

tests/atomics-14.ispc

@@ -7,7 +7,7 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
     float a = aFOO[programIndex]; 
     float b = 0;
     if (programIndex & 1)
-        b = atomic_or_global(s, (1 << programIndex));
+        b = atomic_or_global(&s, (1 << programIndex));
     RET[programIndex] = (s>>20);
 }
 

tests/atomics-2.ispc

@@ -6,7 +6,7 @@ uniform int64 s = 0;
 export void f_f(uniform float RET[], uniform float aFOO[]) {
     float a = aFOO[programIndex]; 
     float delta = 1;
-    float b = atomic_add_global(s, delta);
+    float b = atomic_add_global(&s, delta);
     RET[programIndex] = reduce_add(b);
 }
 

tests/atomics-3.ispc

@@ -6,7 +6,7 @@ uniform int32 s = 0xff;
 export void f_f(uniform float RET[], uniform float aFOO[]) {
     float a = aFOO[programIndex]; 
     int32 bits = 0xfffffff0;
-    float b = atomic_xor_global(s, bits);
+    float b = atomic_xor_global(&s, bits);
     RET[programIndex] = s;
 }
 

tests/atomics-4.ispc

@@ -5,7 +5,7 @@ uniform int32 s = 0;
 
 export void f_f(uniform float RET[], uniform float aFOO[]) {
     float a = aFOO[programIndex]; 
-    float b = atomic_or_global(s, (1<<programIndex));
+    float b = atomic_or_global(&s, (1<<programIndex));
     RET[programIndex] = s;
 }
 

tests/atomics-5.ispc

@@ -5,7 +5,7 @@ uniform int32 s = 0xbeef;
 
 export void f_f(uniform float RET[], uniform float aFOO[]) {
     float a = aFOO[programIndex]; 
-    float b = atomic_swap_global(s, programIndex);
+    float b = atomic_swap_global(&s, programIndex);
     RET[programIndex] = reduce_max(b);
 }
 

tests/atomics-6.ispc

@@ -5,7 +5,7 @@ uniform int32 s = 2;
 
 export void f_f(uniform float RET[], uniform float aFOO[]) {
     float a = aFOO[programIndex]; 
-    float b = atomic_compare_exchange_global(s, programIndex, a*1000);
+    float b = atomic_compare_exchange_global(&s, programIndex, a*1000);
     RET[programIndex] = s;
 }
 

tests/atomics-7.ispc

@@ -5,7 +5,7 @@ uniform int32 s = 0;
 
 export void f_f(uniform float RET[], uniform float aFOO[]) {
     int32 a = aFOO[programIndex]; 
-    float b = atomic_min_global(s, a);
+    float b = atomic_min_global(&s, a);
     RET[programIndex] = reduce_min(b);
 }
 

tests/atomics-8.ispc

@@ -7,7 +7,7 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
     int32 a = aFOO[programIndex]; 
     int32 b = 0;
     if (programIndex & 1)
-        b = atomic_max_global(s, a);
+        b = atomic_max_global(&s, a);
     RET[programIndex] = s;
 }
 

tests/atomics-9.ispc

@@ -8,7 +8,7 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
     float b = 0;
     int32 delta = 1;
     if (programIndex < 2)
-        b = atomic_add_global(s, delta);
+        b = atomic_add_global(&s, delta);
     RET[programIndex] = reduce_add(b);
 }
 

tests/atomics-uniform-1.ispc

@@ -5,7 +5,7 @@ uniform unsigned int32 s = 10;
 
 export void f_f(uniform float RET[], uniform float aFOO[]) {
     float a = aFOO[programIndex]; 
-    uniform unsigned int32 b = atomic_add_global(s, 1);
+    uniform unsigned int32 b = atomic_add_global(&s, 1);
     RET[programIndex] = s;
 }
 

tests/atomics-uniform-2.ispc

@@ -5,7 +5,7 @@ uniform unsigned int32 s = 0b1010;
 
 export void f_f(uniform float RET[], uniform float aFOO[]) {
     float a = aFOO[programIndex]; 
-    uniform unsigned int32 b = atomic_or_global(s, 1);
+    uniform unsigned int32 b = atomic_or_global(&s, 1);
     RET[programIndex] = s;
 }
 

tests/atomics-uniform-3.ispc

@@ -5,7 +5,7 @@ uniform unsigned int32 s = 0b1010;
 
 export void f_f(uniform float RET[], uniform float aFOO[]) {
     float a = aFOO[programIndex]; 
-    uniform unsigned int32 b = atomic_or_global(s, 1);
+    uniform unsigned int32 b = atomic_or_global(&s, 1);
     RET[programIndex] = b;
 }
 

tests/atomics-uniform-4.ispc

@@ -5,7 +5,7 @@ uniform unsigned int32 s = 0xffff;
 
 export void f_f(uniform float RET[], uniform float aFOO[]) {
     float a = aFOO[programIndex]; 
-    uniform unsigned int32 b = atomic_min_global(s, 1);
+    uniform unsigned int32 b = atomic_min_global(&s, 1);
     RET[programIndex] = b;
 }
 

tests/atomics-uniform-5.ispc

@@ -5,7 +5,7 @@ uniform unsigned int32 s = 0xffff;
 
 export void f_f(uniform float RET[], uniform float aFOO[]) {
     float a = aFOO[programIndex]; 
-    uniform unsigned int32 b = atomic_min_global(s, 1);
+    uniform unsigned int32 b = atomic_min_global(&s, 1);
     RET[programIndex] = s;
 }
 

tests/atomics-uniform-6.ispc

@@ -5,7 +5,7 @@ uniform float s = 100.;
 
 export void f_f(uniform float RET[], uniform float aFOO[]) {
     float a = aFOO[programIndex]; 
-    uniform float b = atomic_swap_global(s, 1.);
+    uniform float b = atomic_swap_global(&s, 1.);
     RET[programIndex] = s;
 }
 

tests/atomics-uniform-7.ispc

@@ -5,7 +5,7 @@ uniform float s = 100.;
 
 export void f_f(uniform float RET[], uniform float aFOO[]) {
     float a = aFOO[programIndex]; 
-    uniform float b = atomic_swap_global(s, 1.);
+    uniform float b = atomic_swap_global(&s, 1.);
     RET[programIndex] = b;
 }
 

tests/atomics-uniform-8.ispc

@@ -5,7 +5,7 @@ uniform float s = 100.;
 
 export void f_f(uniform float RET[], uniform float aFOO[]) {
     float a = aFOO[programIndex]; 
-    uniform float b = atomic_compare_exchange_global(s, 1., -100.);
+    uniform float b = atomic_compare_exchange_global(&s, 1., -100.);
     RET[programIndex] = b;
 }
 

tests/atomics-uniform-9.ispc

@@ -5,7 +5,7 @@ uniform int64 s = 100.;
 
 export void f_f(uniform float RET[], uniform float aFOO[]) {
     float a = aFOO[programIndex]; 
-    uniform int64 b = atomic_compare_exchange_global(s, 100, -100);
+    uniform int64 b = atomic_compare_exchange_global(&s, 100, -100);
     RET[programIndex] = s;
 }
 

tests/cfor-ref-5.ispc

@@ -3,8 +3,8 @@ export uniform int width() { return programCount; }
 
 
 
-void foo(reference float a) {
-    a = 0;
+void foo(float * uniform a) {
+    *a = 0;
 }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
@@ -13,7 +13,7 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     uniform int i;
     cfor (i = 0; i < 10; ++i)
         x[i] = a*b;
-    foo(x[b]);
+    foo(&x[b]);
     RET[programIndex] = x[5] + x[9];
 }
 

tests/cfor-ref-6.ispc

@@ -3,7 +3,7 @@ export uniform int width() { return programCount; }
 
 
 
-void foo(reference float a[10]) {
+void foo(float a[10]) {
     a[5] = 0;
 }
 

tests/cfor-ref-7.ispc

@@ -3,7 +3,7 @@ export uniform int width() { return programCount; }
 
 
 
-void foo(reference float a[10]) {
+void foo(float a[10]) {
     a[5] = 0;
 }
 

tests/frexp-double-1.ispc

@@ -7,7 +7,7 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
     if (programIndex & 1)
         a = -a;
     int exponent;
-    frexp(a, exponent);
+    frexp(a, &exponent);
     RET[programIndex] = exponent;
 }
 

tests/frexp-double.ispc

@@ -7,7 +7,7 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
     if (programIndex & 1)
         a = -a;
     int exponent;
-    RET[programIndex] = frexp(a, exponent);
+    RET[programIndex] = frexp(a, &exponent);
 }
 
 export void result(uniform float RET[]) {

tests/frexp-float-1.ispc

@@ -7,7 +7,7 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
     if (programIndex & 1)
         a = -a;
     int exponent;
-    frexp(a, exponent);
+    frexp(a, &exponent);
     RET[programIndex] = exponent;
 }
 

tests/frexp-float.ispc

@@ -7,7 +7,7 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
     if (programIndex & 1)
         a = -a;
     int exponent;
-    RET[programIndex] = frexp(a, exponent);
+    RET[programIndex] = frexp(a, &exponent);
 }
 
 export void result(uniform float RET[]) {

tests/funcptr-null-3.ispc

@@ -8,7 +8,7 @@ float foo(float a, float b) {
 }
 
 static float bar(float a, float b) {
-    return min(a, b);
+    return a < b ? a : b;
 }
 
 export void f_f(uniform float RET[], uniform float aFOO[]) {

tests/masked-scatter-vector.ispc

@@ -0,0 +1,23 @@
+
+export uniform int width() { return programCount; }
+
+typedef int<3> int3;
+
+export void f_fu(uniform float ret[], uniform float aa[], uniform float b) {
+    float a = aa[programIndex];
+    uniform int3 array[32];
+    for (uniform int i = 0; i < 6*b + 2; ++i) {
+        for (uniform int j = 0; j < 3; ++j)
+            array[i][j] = i+100*j;
+    }
+
+    varying int3 vv = array[a];
+    ++vv.y;
+    array[a] = vv;
+    ret[programIndex] = array[programIndex].y;
+}
+
+export void result(uniform float ret[]) {
+    ret[programIndex] = 101+programIndex;
+    ret[0] = 100;
+}

tests/packed-load-1.ispc

@@ -5,7 +5,7 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
     uniform unsigned int a[programCount];
     a[programIndex] = aFOO[programIndex];
     unsigned int aa;
-    packed_load_active(a, 0, aa);
+    packed_load_active(a, 0, &aa);
     RET[programIndex] = aa;
 }
 

tests/packed-load-2.ispc

@@ -7,7 +7,7 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
     int aa = 15;
     uniform int count = 0;
     if (programIndex < 2)
-        count += packed_load_active(a, 0, aa);
+        count += packed_load_active(a, 0, &aa);
     RET[programIndex] = aa;
 }
 

tests/packed-load-3.ispc

@@ -7,7 +7,7 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
     int aa;
     uniform int count = 0;
     if (programIndex < 2)
-        count += packed_load_active(a, 0, aa);
+        count += packed_load_active(a, 0, &aa);
     RET[programIndex] = count;
 }
 

tests/packed-load-4.ispc

@@ -8,7 +8,7 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
     int aa = 32;
     uniform int count = 0;
     if (programIndex < 2)
-        count += packed_load_active(a, 5, aa);
+        count += packed_load_active(a, 5, &aa);
     RET[programIndex] = aa;
 }
 

tests/packed-load-5.ispc

@@ -8,9 +8,9 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
     int aa = 32;
     uniform int count = 0;
     if (programIndex & 1)
-        count += packed_load_active(a, 10, aa);
+        count += packed_load_active(a, 10, &aa);
     if (!(programIndex & 1))
-        count += packed_load_active(a, 10+count, aa);
+        count += packed_load_active(a, 10+count, &aa);
     RET[programIndex] = aa;
 }
 

tests/pass-varying-lvalue-to-ref.ispc

@@ -1,14 +1,14 @@
 
 export uniform int width() { return programCount; }
 
-void inc(reference float v) { ++v; }
+void inc(uniform float * varying v) { ++(*v); }
 
 export void f_fu(uniform float ret[], uniform float aa[], uniform float b) {
     uniform float foo[32];
     for (uniform int i = 0; i < 32; ++i)
         foo[i] = 10+i;
     int a = (int)aa[programIndex];
-    inc(foo[a]);
+    inc(&foo[a]);
     ret[programIndex] = foo[programIndex]-programIndex;
 }
 

tests/prefetch.ispc

@@ -0,0 +1,17 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    prefetch_l1(aFOO);
+    prefetch_l2(aFOO);
+    prefetch_l3(aFOO);
+    prefetch_nt(aFOO);
+    float a = aFOO[programIndex]; 
+    float b = 0.; b = a; 
+    RET[programIndex] = a+b; 
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 2 + 2*programIndex;
+}

tests/ptr-1.ispc

@@ -0,0 +1,13 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    uniform int a = 1;
+    uniform int * uniform b = &a;
+    RET[programIndex] = *b;
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 1;
+}

tests/ptr-10.ispc

@@ -0,0 +1,11 @@
+
+export uniform int width() { return programCount; }
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    uniform float * uniform b = aFOO;
+    RET[programIndex] = *b;
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 1;
+}

tests/ptr-11.ispc

@@ -0,0 +1,16 @@
+
+export uniform int width() { return programCount; }
+
+void inc(int * uniform v) {
+    ++*v;
+}
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    uniform float * uniform b = &aFOO[0];
+    b = b + 3;
+    RET[programIndex] = *b;
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 4;
+}

tests/ptr-12.ispc

@@ -0,0 +1,17 @@
+
+export uniform int width() { return programCount; }
+
+void inc(int * uniform v) {
+    ++*v;
+}
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    uniform float * uniform b = &aFOO[0];
+    ++b;
+    b++;
+    RET[programIndex] = *b;
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 3;
+}

tests/ptr-13.ispc

@@ -0,0 +1,17 @@
+
+export uniform int width() { return programCount; }
+
+void inc(int * uniform v) {
+    ++*v;
+}
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    uniform float * uniform b = &aFOO[0];
+    b += 3;
+    b -= 1;
+    RET[programIndex] = *b;
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 3;
+}

tests/ptr-14.ispc

@@ -0,0 +1,15 @@
+
+export uniform int width() { return programCount; }
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    float a = aFOO[programIndex];
+    float * uniform pa = &a;
+    int * uniform pb = (int *)pa;
+    float *uniform pc = (float *)pb;
+    *pc = programIndex;
+    RET[programIndex] = *pc;
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = programIndex;
+}

tests/ptr-15.ispc

@@ -0,0 +1,18 @@
+
+export uniform int width() { return programCount; }
+
+void foo(uniform float * uniform * ret) {
+    uniform float *px = *ret;
+    ++px;
+    *ret = px;
+}
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    uniform float * uniform ptr = &aFOO[0];
+    foo(&ptr);
+    RET[programIndex] = *ptr;
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 2;
+}

tests/ptr-16.ispc

@@ -0,0 +1,11 @@
+
+export uniform int width() { return programCount; }
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    uniform float * uniform b = aFOO;
+    RET[programIndex] = b[programIndex];
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 1+programIndex;
+}

tests/ptr-17.ispc

@@ -0,0 +1,16 @@
+
+export uniform int width() { return programCount; }
+
+void inc(int * uniform v) {
+    ++*v;
+}
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    uniform float * uniform b = aFOO;
+    b[programIndex] = programCount - programIndex;
+    RET[programIndex] = aFOO[programIndex];
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = programCount - programIndex;
+}

tests/ptr-18.ispc

@@ -0,0 +1,12 @@
+
+export uniform int width() { return programCount; }
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    uniform float * uniform b = aFOO;
+    b += 10;
+    RET[programIndex] = b[-5];
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 6;
+}

tests/ptr-19.ispc

@@ -0,0 +1,13 @@
+
+export uniform int width() { return programCount; }
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    uniform float * uniform b = aFOO;
+    b += 10;
+    int8 index = -5;
+    RET[programIndex] = b[index];
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 6;
+}

tests/ptr-2.ispc

@@ -0,0 +1,13 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    int a = aFOO[programIndex];
+    int * uniform b = &a;
+    RET[programIndex] = *b;
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 1+programIndex;
+}

tests/ptr-20.ispc

@@ -0,0 +1,13 @@
+
+export uniform int width() { return programCount; }
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    uniform float * uniform b = aFOO;
+    b += 10;
+    uniform int8 index = -5;
+    RET[programIndex] = b[index];
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 6;
+}

tests/ptr-21.ispc

@@ -0,0 +1,22 @@
+
+export uniform int width() { return programCount; }
+
+struct Foo {
+    int a;
+    uniform float b;
+};
+
+void update(Foo * uniform fp) {
+    fp->a += 1;
+    fp->b = 1;
+}
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    Foo f = { aFOO[programIndex], 5 };
+    update(&f);
+    RET[programIndex] = f.b;
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 1;
+}

tests/ptr-22.ispc

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

tests/ptr-23.ispc

@@ -0,0 +1,21 @@
+
+export uniform int width() { return programCount; }
+
+struct Foo {
+    int a;
+    uniform float b;
+};
+
+void update(float<3> * uniform vp) {
+    vp->x = 0;
+}
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    float<3> v = { 1, 2, 3 };
+    update(&v);
+    RET[programIndex] = v.x;
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 0;
+}

tests/ptr-24.ispc

@@ -0,0 +1,24 @@
+
+export uniform int width() { return programCount; }
+
+void update(uniform float<2> * varying vp) {
+    vp->y = 0;
+}
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    uniform float<2> v[programCount];
+    for (uniform int i = 0; i < programCount; ++i) {
+        v[i].x = 2*i;
+        v[i].y = 2*i+1;
+    }
+    
+    int index = aFOO[programIndex] - 1;
+    update(&v[programIndex]);
+//CO    for (uniform int i = 0; i < programCount; ++i) 
+//CO        print("%: % %\n", i, v[i].x, v[i].y);
+    RET[programIndex] = v[programIndex].x + v[programIndex].y;
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 2*programIndex;
+}

tests/ptr-25.ispc

@@ -0,0 +1,24 @@
+
+export uniform int width() { return programCount; }
+
+void update(float<2> * varying vp) {
+    vp->y = 0;
+}
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    float<2> v[programCount];
+    for (uniform int i = 0; i < programCount; ++i) {
+        v[i].x = 2*i;
+        v[i].y = 2*i+1;
+    }
+    
+    int index = aFOO[programIndex] - 1;
+    update(&v[programIndex]);
+//CO    for (uniform int i = 0; i < programCount; ++i) 
+//CO        print("%: % %\n", i, v[i].x, v[i].y);
+    RET[programIndex] = v[programIndex].x;
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 2*programIndex;
+}

tests/ptr-3.ispc

@@ -0,0 +1,14 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    int a = aFOO[programIndex];
+    int * uniform b = &a;
+    *b = 2;
+    RET[programIndex] = *b;
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 2;
+}

tests/ptr-4.ispc

@@ -0,0 +1,14 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    int a = aFOO[programIndex];
+    int * uniform b = &a;
+    ++*b;
+    RET[programIndex] = *b;
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 2+programIndex;
+}

tests/ptr-5.ispc

@@ -0,0 +1,14 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    int a = aFOO[programIndex];
+    int * uniform b = &a;
+    (*b)++;
+    RET[programIndex] = *b;
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 2+programIndex;
+}

tests/ptr-6.ispc

@@ -0,0 +1,12 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    uniform float * uniform ap = &aFOO[0];
+    RET[programIndex] = ap[programIndex];
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 1+programIndex;
+}

tests/ptr-7.ispc

@@ -0,0 +1,12 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    uniform float * varying ap = &aFOO[programIndex];
+    RET[programIndex] = *ap;
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 1+programIndex;
+}

tests/ptr-8.ispc

@@ -0,0 +1,20 @@
+
+export uniform int width() { return programCount; }
+
+void inc(int * uniform v) {
+    ++*v;
+}
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    int a = aFOO[programIndex];
+    int * uniform b = &a;
+    if (a <= 2)
+        inc(b);
+    RET[programIndex] = a;
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 1+programIndex;
+    RET[0] = 2;
+    RET[1] = 3;
+}

tests/ptr-9.ispc

@@ -0,0 +1,18 @@
+
+export uniform int width() { return programCount; }
+
+void inc(int * uniform v) {
+    ++*v;
+}
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    int a = aFOO[programIndex];
+    int * uniform b = &a;
+    void * uniform vp = b;
+    int * uniform c = (int * uniform)vp;
+    RET[programIndex] = *c;
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 1+programIndex;
+}

tests/ptr-diff-1.ispc

@@ -0,0 +1,12 @@
+
+export uniform int width() { return programCount; }
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    uniform float * uniform b = aFOO;
+    b += 5;
+    RET[programIndex] = b - aFOO;
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 5;
+}

tests/ptr-diff-2.ispc

@@ -0,0 +1,12 @@
+
+export uniform int width() { return programCount; }
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    uniform float * varying b = aFOO;
+    b += 5;
+    RET[programIndex] = b - aFOO;
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 5;
+}

tests/ptr-diff-3.ispc

@@ -0,0 +1,12 @@
+
+export uniform int width() { return programCount; }
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    uniform int8 * varying pa = (uniform int8 *)aFOO;
+    uniform int8 * varying pb = (uniform int8 *)(&aFOO[10]);
+    RET[programIndex] = pb - pa;
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 40;
+}

tests/ptr-r--0.ispc

@@ -0,0 +1,16 @@
+
+export uniform int width() { return programCount; }
+
+
+
+float foo(float * uniform a) {
+    *a = 0;
+}
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex];
+    foo(&a);
+    RET[programIndex] = a;
+}
+
+export void result(uniform float RET[]) { RET[programIndex] = 0; }

tests/ptr-r--1.ispc

@@ -0,0 +1,16 @@
+
+export uniform int width() { return programCount; }
+
+
+
+float foo(uniform float * uniform a) {
+    *a = 0;
+}
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex];
+    foo(&b);
+    RET[programIndex] = b;
+}
+
+export void result(uniform float RET[]) { RET[programIndex] = 0; }

tests/ptr-r--2.ispc

@@ -0,0 +1,17 @@
+
+export uniform int width() { return programCount; }
+
+
+
+float foo(float * uniform a) {
+    *a = 0;
+}
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex];
+    if (b > 6)
+        foo(&a);
+    RET[programIndex] = a;
+}
+
+export void result(uniform float RET[]) { RET[programIndex] = 1+programIndex; }

tests/ptr-r--3.ispc

@@ -0,0 +1,21 @@
+
+export uniform int width() { return programCount; }
+
+
+
+void foo(float * uniform a) {
+    *a = 0;
+}
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex];
+    if (a >= 3)
+        foo(&a);
+    RET[programIndex] = a;
+}
+
+export void result(uniform float RET[4]) { 
+    RET[programIndex] = 0;
+    RET[0] = 1;
+    RET[1] = 2;
+}

tests/ptr-r--4.ispc

@@ -0,0 +1,21 @@
+
+export uniform int width() { return programCount; }
+
+
+
+void foo(float * uniform a) {
+    *a = 0;
+}
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex];
+    if (a >= 3)
+        foo(&a);
+    RET[programIndex] = a;
+}
+
+export void result(uniform float RET[]) { 
+    RET[programIndex] = 0;
+    RET[0] = 1;
+    RET[1] = 2;
+}

tests/ptr-r--5.ispc

@@ -0,0 +1,20 @@
+
+export uniform int width() { return programCount; }
+
+
+
+void foo(float * uniform a) {
+    *a = 0;
+}
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex];
+    float x[10];
+    uniform int i;
+    for (i = 0; i < 10; ++i)
+        x[i] = a*b;
+    foo(&x[b]);
+    RET[programIndex] = x[5] + x[9];
+}
+
+export void result(uniform float RET[]) { RET[programIndex] = 5 * (programIndex+1); }

tests/ptr-r--6.ispc

@@ -0,0 +1,26 @@
+
+export uniform int width() { return programCount; }
+
+
+
+void foo(float a[10]) {
+    a[5] = 0;
+}
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex];
+    float x[10];
+    uniform int i;
+    for (i = 0; i < 10; ++i)
+        x[i] = a*b;
+    if (a >= 2)
+        foo(x);
+    RET[programIndex] = x[b] + x[9];
+}
+
+export void result(uniform float RET[]) { 
+    RET[programIndex] = 5 * (programIndex+1);
+    RET[0] = 10;
+    RET[1] = 10;
+}
+

tests/ptr-r--7.ispc

@@ -0,0 +1,25 @@
+
+export uniform int width() { return programCount; }
+
+
+
+void foo(float a[10]) {
+    a[5] = 0;
+}
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float a = aFOO[programIndex];
+    float x[10];
+    uniform int i;
+    for (i = 0; i < 10; ++i)
+        x[i] = a*b;
+    if (a > 2)
+        foo(x);
+    RET[programIndex] = x[b] + x[9];
+}
+
+export void result(uniform float RET[]) { 
+    RET[programIndex] = 5 * (programIndex+1);
+    RET[0] = 10;
+    RET[1] = 20;
+}

tests/ptr-r-erence-assignment-typeconv.ispc

@@ -0,0 +1,19 @@
+
+export uniform int width() { return programCount; }
+
+
+
+void foo(float * uniform x, int y) {
+    *x = y;
+}
+
+export void f_fu(uniform float ret[], uniform float a[], uniform float b) {
+    float aa = a[programIndex];
+    int bb = (int)b;
+    foo(&aa, bb);
+    ret[programIndex] = aa;
+}
+
+export void result(uniform float r[]) {
+    r[programIndex] = 5;
+}

tests/ptr-r-erence-assignment.ispc

@@ -3,14 +3,14 @@ export uniform int width() { return programCount; }
 
 
 
-struct Foo {
-    uniform float array[];
-};
+void foo(float * uniform x, float y) {
+    *x = y;
+}
 
 export void f_fu(uniform float ret[], uniform float a[], uniform float b) {
-    Foo f;
-    f.array = ret;
-    f.array[programIndex] = b;
+    float aa = a[programIndex], bb = b;
+    foo(&aa, bb);
+    ret[programIndex] = aa;
 }
 
 export void result(uniform float r[]) {

tests/ptr-r-erence-prepost-increment.ispc

@@ -0,0 +1,21 @@
+
+export uniform int width() { return programCount; }
+
+
+
+void foo(float * uniform x) {
+    if ((*x) <= 2)
+        ++(*x);
+}
+
+export void f_fu(uniform float ret[], uniform float a[], uniform float b) {
+    float aa = a[programIndex];
+    foo(&aa);
+    ret[programIndex] = aa;
+}
+
+export void result(uniform float r[]) {
+    r[programIndex] = 1+programIndex;
+    r[0] = 2;
+    r[1] = 3;
+}

tests/rand-distrib-1.ispc

@@ -3,13 +3,13 @@ export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     RNGState state;
-    seed_rng(state, 1);
+    seed_rng(&state, 1);
     int count[32];
     for (uniform int i = 0; i < 32; ++i)
         count[i] = (b == 5.) ? 0 : 1;
     uniform int iters = 10000;
     for (uniform int i = 0; i < iters; ++i) {
-        unsigned int val = random(state);
+        unsigned int val = random(&state);
         for (uniform int j = 0; j < 32; ++j) {
             if (val & (1<<j))
                 ++count[j];

tests/rand-distrib.ispc

@@ -3,11 +3,11 @@ export uniform int width() { return programCount; }
 
 export void f_f(uniform float RET[], uniform float aFOO[]) {
     RNGState state;
-    seed_rng(state, 1);
+    seed_rng(&state, 1);
     float sum = 0;
     uniform int iters = 40000;
     for (unsigned int i = 0; i < iters; ++i)
-        sum += frandom(state);
+        sum += frandom(&state);
     float avg = sum / iters;
     RET[programIndex] = (avg > 0.495 && avg < 0.505) ? 1 : 0;
 }

tests/reduce-equal-12.ispc

@@ -7,7 +7,7 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     uniform int sameVal;
     uniform bool re;
     if (a <= 11) {
-        re = reduce_equal(a, sameVal);
+        re = reduce_equal(a, &sameVal);
 //CO        print("% % %\n", re, sameVal, a);
     }
     RET[programIndex] = ((int)re << 8) + sameVal;

tests/reduce-equal-13.ispc

@@ -7,7 +7,7 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     uniform bool re;
     uniform int val;
     if (programIndex & 1) {
-        re = reduce_equal(a, val);
+        re = reduce_equal(a, &val);
     }
     RET[programIndex] = ((int)re << 8) + val;
 }

tests/ref-0.ispc

@@ -3,13 +3,13 @@ export uniform int width() { return programCount; }
 
 
 
-float foo(reference float a) {
-    a = 0;
+float foo(float * uniform a) {
+    *a = 0;
 }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex];
-    foo(a);
+    foo(&a);
     RET[programIndex] = a;
 }
 

tests/ref-1.ispc

@@ -3,7 +3,7 @@ export uniform int width() { return programCount; }
 
 
 
-float foo(reference uniform float a) {
+float foo(uniform float &a) {
     a = 0;
 }
 

tests/ref-2.ispc

@@ -3,7 +3,7 @@ export uniform int width() { return programCount; }
 
 
 
-float foo(reference float a) {
+float foo(float & a) {
     a = 0;
 }
 

tests/ref-3.ispc

@@ -3,7 +3,7 @@ export uniform int width() { return programCount; }
 
 
 
-void foo(reference float a) {
+void foo(float & a) {
     a = 0;
 }
 

tests/ref-4.ispc

@@ -3,7 +3,7 @@ export uniform int width() { return programCount; }
 
 
 
-void foo(reference float a) {
+void foo(float & a) {
     a = 0;
 }
 

tests/ref-5.ispc

@@ -3,7 +3,7 @@ export uniform int width() { return programCount; }
 
 
 
-void foo(reference float a) {
+void foo(float & a) {
     a = 0;
 }
 

tests/ref-6.ispc

@@ -3,24 +3,22 @@ export uniform int width() { return programCount; }
 
 
 
-void foo(reference float a[10]) {
-    a[5] = 0;
+void foo(float<3> &a) {
+    a.x = 0;
+    a.y *= 2;
+    a.z = 1;
 }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex];
-    float x[10];
-    uniform int i;
-    for (i = 0; i < 10; ++i)
-        x[i] = a*b;
+    float<3> v = { a, b, 10 };
     if (a >= 2)
-        foo(x);
-    RET[programIndex] = x[b] + x[9];
+        foo(v);
+    RET[programIndex] = v.x + v.y + v.z;
 }
 
 export void result(uniform float RET[]) { 
-    RET[programIndex] = 5 * (programIndex+1);
-    RET[0] = 10;
-    RET[1] = 10;
+    RET[programIndex] = 11;
+    RET[0] = 16;
 }
 

tests/ref-7.ispc

@@ -2,24 +2,23 @@
 export uniform int width() { return programCount; }
 
 
-
-void foo(reference float a[10]) {
-    a[5] = 0;
+void foo(float &a) {
+    a += a;
 }
 
+struct Foo {
+    float a, b, c;
+};
+
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    float a = aFOO[programIndex];
-    float x[10];
-    uniform int i;
-    for (i = 0; i < 10; ++i)
-        x[i] = a*b;
-    if (a > 2)
-        foo(x);
-    RET[programIndex] = x[b] + x[9];
+    Foo f = { b, aFOO[programIndex], 1 };
+    if (programIndex < 2)
+        foo(f.b);
+    RET[programIndex] = f.b;
 }
 
 export void result(uniform float RET[]) { 
-    RET[programIndex] = 5 * (programIndex+1);
-    RET[0] = 10;
-    RET[1] = 20;
+    RET[programIndex] = 1+programIndex;
+    RET[0] = 2;
+    RET[1] = 4;
 }

tests/ref-8.ispc

@@ -0,0 +1,24 @@
+
+export uniform int width() { return programCount; }
+
+
+struct Foo {
+    float a, b, c;
+};
+
+void foo(Foo &f) {
+    f.a += f.a;
+}
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    Foo f = { b, aFOO[programIndex], 1 };
+    if (programIndex < 2)
+        foo(f);
+    RET[programIndex] = f.a + f.b + f.c;
+}
+
+export void result(uniform float RET[]) { 
+    RET[programIndex] = 7+programIndex;
+    RET[0] = 12;
+    RET[1] = 13;
+}

tests/ref-9.ispc

@@ -0,0 +1,18 @@
+
+export uniform int width() { return programCount; }
+
+
+int &foo(int &a, int &b) {
+    return b;
+}
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    int a = aFOO[programIndex];
+    int three = 3;
+    int &val = foo(a, three);
+    RET[programIndex] = val;
+}
+
+export void result(uniform float RET[]) { 
+    RET[programIndex] = 3;
+}

tests/reference-assignment-typeconv.ispc

@@ -3,7 +3,7 @@ export uniform int width() { return programCount; }
 
 
 
-void foo(reference float x, reference int y) {
+void foo(float &x, int y) {
     x = y;
 }
 

tests/reference-assignment.ispc

@@ -3,7 +3,7 @@ export uniform int width() { return programCount; }
 
 
 
-void foo(reference float x, reference float y) {
+void foo(float & x, float y) {
     x = y;
 }
 

tests/reference-prepost-increment.ispc

@@ -3,9 +3,11 @@ export uniform int width() { return programCount; }
 
 
 
-void foo(reference float x) {
-    if (x <= 2)
-        ++x;
+void foo(float & x) {
+    if ((x) <= 2) {
+        ++(x);
+        x += 1;
+    }
 }
 
 export void f_fu(uniform float ret[], uniform float a[], uniform float b) {
@@ -16,6 +18,6 @@ export void f_fu(uniform float ret[], uniform float a[], uniform float b) {
 
 export void result(uniform float r[]) {
     r[programIndex] = 1+programIndex;
-    r[0] = 2;
-    r[1] = 3;
+    r[0] = 3;
+    r[1] = 4;
 }