Renamed carray<123>_<tag> to carray<123><tag>.

3 files changed, 64 insertions, 65 deletions

diff --git a/examples/complex.c b/examples/complex.c
index a52bd175..40dc9722 100644
--- a/examples/complex.c
+++ b/examples/complex.c
@@ -6,7 +6,7 @@
 void check_destroy(float* v) {printf("destroy %g\n", *v);}

 

 declare_CArray(f, float, check_destroy); // normally omit the last argument - float type need no destroy.

-declare_CList(t2, CArray2_f, carray2_f_destroy, c_noCompare);

+declare_CList(t2, CArray2f, carray2f_destroy, c_noCompare);

 declare_CMap(il, int, CList_t2, clist_t2_destroy);

 declare_CMap_str(sm, CMap_il, cmap_il_destroy);

 

@@ -17,20 +17,20 @@ int main() {
     CMap_sm theMap = cmap_init;

 

     { // Construct.

-        CArray2_f table = carray2_f_make(ydim, xdim, 0.f);

+        CArray2f table = carray2f_make(ydim, xdim, 0.f);

         printf("table: (%zu, %zu)\n", carray2_ydim(table), carray2_xdim(table));

         CList_t2 tableList = clist_init;

         CMap_il listMap = cmap_init;

         

         // Put in some data.

-        carray2_f_data(table, y)[x] = 3.1415927; // table[y][x]

+        carray2f_data(table, y)[x] = 3.1415927; // table[y][x]

         clist_t2_pushBack(&tableList, table);

         cmap_il_put(&listMap, tableKey, tableList);

         cmap_sm_put(&theMap, strKey, listMap);

     }

     { // Access the data entry

-        CArray2_f table = clist_back(cmap_il_find(&cmap_sm_find(&theMap, strKey)->value, tableKey)->value);

-        printf("value (%d, %d) is: %f\n", y, x, carray2_f_value(table, y, x));

+        CArray2f table = clist_back(cmap_il_find(&cmap_sm_find(&theMap, strKey)->value, tableKey)->value);

+        printf("value (%d, %d) is: %f\n", y, x, carray2f_value(table, y, x));

     }

 

     cmap_sm_destroy(&theMap); // free up the whole shebang!

diff --git a/examples/demos.c b/examples/demos.c
index e6e76d7a..03d8a21d 100644
--- a/examples/demos.c
+++ b/examples/demos.c
@@ -173,29 +173,28 @@ void mapdemo3()
 }

 

 

-

 declare_CArray(f, float);

 

 void arraydemo1()

 {

     printf("\nARRAYDEMO1\n");

-    CArray3_f a3 = carray3_f_make(30, 20, 10, 0.f);

-    carray3_f_data(a3, 5, 4)[3] = 10.2f;  // a3[5][4][3]

-    CArray2_f a2 = carray3_f_at(a3, 5);     // sub-array reference (no data copy).

+    CArray3f a3 = carray3f_make(30, 20, 10, 0.f);

+    carray3f_data(a3, 5, 4)[3] = 10.2f;  // a3[5][4][3]

+    CArray2f a2 = carray3f_at(a3, 5);     // sub-array reference (no data copy).

 

     printf("a3: %zu: (%zu, %zu, %zu) = %zu\n", sizeof(a3), carray3_xdim(a3), carray3_ydim(a3), carray3_zdim(a3), carray3_size(a3));

     printf("a2: %zu: (%zu, %zu) = %zu\n", sizeof(a2), carray2_xdim(a2), carray2_ydim(a2), carray2_size(a2));

 

-    printf("%f\n", carray2_f_value(a2, 4, 3));   // readonly lookup a2[4][3] (=10.2f)

-    printf("%f\n", carray2_f_data(a2, 4)[3]);    // same, but this is writable.

-    printf("%f\n", carray2_f_at(a2, 4).data[3]); // same, via sub-array access.

+    printf("%f\n", carray2f_value(a2, 4, 3));   // readonly lookup a2[4][3] (=10.2f)

+    printf("%f\n", carray2f_data(a2, 4)[3]);    // same, but this is writable.

+    printf("%f\n", carray2f_at(a2, 4).data[3]); // same, via sub-array access.

     

-    printf("%f\n", carray3_f_value(a3, 5, 4, 3)); // same data location, via a3 array.

-    printf("%f\n", carray3_f_data(a3, 5, 4)[3]);

-    printf("%f\n", carray3_f_at2(a3, 5, 4).data[3]);

+    printf("%f\n", carray3f_value(a3, 5, 4, 3)); // same data location, via a3 array.

+    printf("%f\n", carray3f_data(a3, 5, 4)[3]);

+    printf("%f\n", carray3f_at2(a3, 5, 4).data[3]);

 

-    carray2_f_destroy(&a2); // does nothing, since it is a sub-array.

-    carray3_f_destroy(&a3); // also invalidates a2.

+    carray2f_destroy(&a2); // does nothing, since it is a sub-array.

+    carray3f_destroy(&a3); // also invalidates a2.

 }

 

 

diff --git a/stc/carray.h b/stc/carray.h
index 5bacbe4c..6157b7f3 100644
--- a/stc/carray.h
+++ b/stc/carray.h
@@ -34,20 +34,20 @@ declare_CArray(f, float);
 

 int main()

 {

-    CArray3_f a3 = carray3_f_make(30, 20, 10, 0.f);

-    carray3_f_data(a3, 5, 4)[3] = 10.2f;  // a3[5][4][3]

-    CArray2_f a2 = carray3_f_at(a3, 5);   // sub-array reference (no data copy).

+    CArray3_f a3 = carray3f_make(30, 20, 10, 0.f);

+    carray3f_data(a3, 5, 4)[3] = 10.2f;  // a3[5][4][3]

+    CArray2_f a2 = carray3f_at(a3, 5);   // sub-array reference (no data copy).

 

-    printf("%f\n", carray2_f_value(a2, 4, 3));   // readonly lookup a2[4][3] (=10.2f)

-    printf("%f\n", carray2_f_data(a2, 4)[3]);    // same, but this is writable.

-    printf("%f\n", carray2_f_at(a2, 4).data[3]); // same, via sub-array access.

+    printf("%f\n", carray2f_value(a2, 4, 3));   // readonly lookup a2[4][3] (=10.2f)

+    printf("%f\n", carray2f_data(a2, 4)[3]);    // same, but this is writable.

+    printf("%f\n", carray2f_at(a2, 4).data[3]); // same, via sub-array access.

     

-    printf("%f\n", carray3_f_value(a3, 5, 4, 3)); // same data location, via a3 array.

-    printf("%f\n", carray3_f_data(a3, 5, 4)[3]);

-    printf("%f\n", carray3_f_at2(a3, 5, 4).data[3]);

+    printf("%f\n", carray3f_value(a3, 5, 4, 3)); // same data location, via a3 array.

+    printf("%f\n", carray3f_data(a3, 5, 4)[3]);

+    printf("%f\n", carray3f_at2(a3, 5, 4).data[3]);

     

-    carray2_f_destroy(&a2); // does nothing, since it is a sub-array.

-    carray3_f_destroy(&a3); // also invalidates a2.

+    carray2f_destroy(&a2); // does nothing, since it is a sub-array.

+    carray3f_destroy(&a3); // also invalidates a2.

 }

 */

 

@@ -84,110 +84,110 @@ static inline size_t _carray3_size(const size_t* zdim) {
     typedef struct { \

         Value *data; \

         size_t _xdim; \

-    } CArray1_##tag; \

+    } CArray1##tag; \

  \

     typedef struct { \

         Value *data; \

         size_t _xdim, _yxdim; \

-    } CArray2_##tag; \

+    } CArray2##tag; \

  \

     typedef struct { \

         Value *data; \

         size_t _xdim, _yxdim, _zdim; \

-    } CArray3_##tag; \

+    } CArray3##tag; \

  \

-    static inline CArray1_##tag \

-    carray1_##tag##_make(size_t xdim, Value val) { \

+    static inline CArray1##tag \

+    carray1##tag##_make(size_t xdim, Value val) { \

         Value* m = c_new_N(Value, xdim); \

         for (size_t i=0; i<xdim; ++i) m[i] = val; \

-        CArray1_##tag a = {m, xdim | _carray_OWN}; \

+        CArray1##tag a = {m, xdim | _carray_OWN}; \

         return a; \

     } \

-    static inline CArray2_##tag \

-    carray2_##tag##_make(size_t ydim, size_t xdim, Value val) { \

+    static inline CArray2##tag \

+    carray2##tag##_make(size_t ydim, size_t xdim, Value val) { \

         const size_t n = ydim * xdim; \

         Value* m = c_new_N(Value, n); \

         for (size_t i=0; i<n; ++i) m[i] = val; \

-        CArray2_##tag a = {m, xdim | _carray_OWN, ydim * xdim}; \

+        CArray2##tag a = {m, xdim | _carray_OWN, ydim * xdim}; \

         return a; \

     } \

-    static inline CArray3_##tag \

-    carray3_##tag##_make(size_t zdim, size_t ydim, size_t xdim, Value val) { \

+    static inline CArray3##tag \

+    carray3##tag##_make(size_t zdim, size_t ydim, size_t xdim, Value val) { \

         const size_t n = zdim * ydim * xdim; \

         Value* m = c_new_N(Value, n); \

         for (size_t i=0; i<n; ++i) m[i] = val; \

-        CArray3_##tag a = {m, xdim | _carray_OWN, ydim * xdim, zdim}; \

+        CArray3##tag a = {m, xdim | _carray_OWN, ydim * xdim, zdim}; \

         return a; \

     } \

  \

-    static inline CArray1_##tag \

-    carray1_##tag##_from(size_t xdim, Value* array, bool own) { \

-        CArray1_##tag a = {array, xdim | (own ? _carray_OWN : 0)}; \

+    static inline CArray1##tag \

+    carray1##tag##_from(size_t xdim, Value* array, bool own) { \

+        CArray1##tag a = {array, xdim | (own ? _carray_OWN : 0)}; \

         return a; \

     } \

-    static inline CArray2_##tag \

-    carray2_##tag##_from(size_t ydim, size_t xdim, Value* array, bool own) { \

-        CArray2_##tag a = {array, xdim | (own ? _carray_OWN : 0), ydim * xdim}; \

+    static inline CArray2##tag \

+    carray2##tag##_from(size_t ydim, size_t xdim, Value* array, bool own) { \

+        CArray2##tag a = {array, xdim | (own ? _carray_OWN : 0), ydim * xdim}; \

         return a; \

     } \

-    static inline CArray3_##tag \

-    carray3_##tag##_from(size_t zdim, size_t ydim, size_t xdim, Value* array, bool own) { \

-        CArray3_##tag a = {array, xdim | (own ? _carray_OWN : 0), ydim * xdim, zdim}; \

+    static inline CArray3##tag \

+    carray3##tag##_from(size_t zdim, size_t ydim, size_t xdim, Value* array, bool own) { \

+        CArray3##tag a = {array, xdim | (own ? _carray_OWN : 0), ydim * xdim, zdim}; \

         return a; \

     } \

  \

     static inline void \

-    carray1_##tag##_destroy(CArray1_##tag* self) { \

+    carray1##tag##_destroy(CArray1##tag* self) { \

         if (self->_xdim & _carray_OWN) { \

             size_t n = carray1_size(*self); Value* a = self->data; \

             while (n--) valueDestroy(&a[n]); free(a); \

         } \

     } \

     static inline void \

-    carray2_##tag##_destroy(CArray2_##tag* self) { \

+    carray2##tag##_destroy(CArray2##tag* self) { \

         if (self->_xdim & _carray_OWN) { \

             size_t n = carray2_size(*self); Value* a = self->data; \

             while (n--) valueDestroy(&a[n]); free(a); \

         } \

     } \

     static inline void \

-    carray3_##tag##_destroy(CArray3_##tag* self) { \

+    carray3##tag##_destroy(CArray3##tag* self) { \

         if (self->_xdim & _carray_OWN) { \

             size_t n = carray3_size(*self); Value* a = self->data; \

             while (n--) valueDestroy(&a[n]); free(a); \

         } \

     } \

  \

-    static inline CArray1_##tag \

-    carray2_##tag##_at(CArray2_##tag a, size_t y) { \

-        CArray1_##tag sub = {a.data + y*carray2_xdim(a), carray2_xdim(a)}; \

+    static inline CArray1##tag \

+    carray2##tag##_at(CArray2##tag a, size_t y) { \

+        CArray1##tag sub = {a.data + y*carray2_xdim(a), carray2_xdim(a)}; \

         return sub; \

     } \

     static inline Value* \

-    carray2_##tag##_data(CArray2_##tag a, size_t y) { \

+    carray2##tag##_data(CArray2##tag a, size_t y) { \

         return a.data + y*carray2_xdim(a); \

     } \

     static inline Value \

-    carray2_##tag##_value(CArray2_##tag a, size_t y, size_t x) { \

+    carray2##tag##_value(CArray2##tag a, size_t y, size_t x) { \

         return a.data[ y*carray2_xdim(a) + x ]; \

     } \

  \

-    static inline CArray2_##tag \

-    carray3_##tag##_at(CArray3_##tag a, size_t z) { \

-        CArray2_##tag sub = {a.data + z*a._yxdim, carray3_xdim(a), a._yxdim}; \

+    static inline CArray2##tag \

+    carray3##tag##_at(CArray3##tag a, size_t z) { \

+        CArray2##tag sub = {a.data + z*a._yxdim, carray3_xdim(a), a._yxdim}; \

         return sub; \

     } \

-    static inline CArray1_##tag \

-    carray3_##tag##_at2(CArray3_##tag a, size_t z, size_t y) { \

-        CArray1_##tag sub = {a.data + z*a._yxdim + y*carray3_xdim(a), carray3_xdim(a)}; \

+    static inline CArray1##tag \

+    carray3##tag##_at2(CArray3##tag a, size_t z, size_t y) { \

+        CArray1##tag sub = {a.data + z*a._yxdim + y*carray3_xdim(a), carray3_xdim(a)}; \

         return sub; \

     } \

     static inline Value* \

-    carray3_##tag##_data(CArray3_##tag a, size_t z, size_t y) { \

+    carray3##tag##_data(CArray3##tag a, size_t z, size_t y) { \

         return a.data + z*a._yxdim + y*carray3_xdim(a); \

     } \

     static inline Value \

-    carray3_##tag##_value(CArray3_##tag a, size_t z, size_t y, size_t x) { \

+    carray3##tag##_value(CArray3##tag a, size_t z, size_t y, size_t x) { \

         return a.data[ z*a._yxdim + y*carray3_xdim(a) + x ]; \

     } \

     typedef Value CArrayValue_##tag