Changes in libcfa/src/containers/array.hfa [63f42a8:c7625e0]

File:

• libcfa/src/containers/array.hfa (modified) (5 diffs)

libcfa/src/containers/array.hfa

@@ -5 +5 @@
 
 // the inverse of Z(-)
-#define z(N) sizeof(N)
+#define z(Zn) sizeof(Zn)
+
+// if you're expecting a Z(n), say so, by asking for a ztype, instead of dtype or otype
+#define ztype(Zn) Zn & | sized(Zn)
 
 forall( T & ) struct tag {};
@@ -16 +19 @@
 //
 
-forall( [N], S & | sized(S), Timmed &, Tbase & ) {
+forall( ztype(Zn), ztype(S), Timmed &, Tbase & ) {
     struct arpk {
-        S strides[z(N)];
+        S strides[z(Zn)];
     };
 
-    // About the choice of integral types offered as subscript overloads:
-    // Intent is to cover these use cases:
-    //    float foo( ptrdiff_t i ) { return a[i]; }           // i : ptrdiff_t
-    //    forall( [N] ) ... for( i; N ) { total += a[i]; }    // i : typeof( sizeof(42) )
-    //    for( i; 5 ) { total += a[i]; }                      // i : int
-    // It gets complicated by:
-    // -  CFA does overloading on concrete types, like int and unsigned int, not on typedefed
-    //    types like size_t.  So trying to overload on ptrdiff_t vs int works in 64-bit mode
-    //    but not in 32-bit mode.
-    // -  Given bug of Trac #247, CFA gives sizeof expressions type unsigned long int, when it
-    //    should give them type size_t.
-    //    
-    //                          gcc -m32         cfa -m32 given bug         gcc -m64
-    // ptrdiff_t                int              int                        long int
-    // size_t                   unsigned int     unsigned int               unsigned long int
-    // typeof( sizeof(42) )     unsigned int     unsigned long int          unsigned long int
-    // int                      int              int                        int
-
-    static inline Timmed & ?[?]( arpk(N, S, Timmed, Tbase) & a, int i ) {
+    Timmed & ?[?]( arpk(Zn, S, Timmed, Tbase) & a, ptrdiff_t i ) {
         return (Timmed &) a.strides[i];
     }
 
-    static inline Timmed & ?[?]( arpk(N, S, Timmed, Tbase) & a, unsigned int i ) {
-        return (Timmed &) a.strides[i];
-    }
-
-    static inline Timmed & ?[?]( arpk(N, S, Timmed, Tbase) & a, long int i ) {
-        return (Timmed &) a.strides[i];
-    }
-
-    static inline Timmed & ?[?]( arpk(N, S, Timmed, Tbase) & a, unsigned long int i ) {
-        return (Timmed &) a.strides[i];
-    }
-
-    static inline size_t ?`len( arpk(N, S, Timmed, Tbase) & a ) {
-        return z(N);
+    size_t ?`len( arpk(Zn, S, Timmed, Tbase) & a ) {
+        return z(Zn);
     }
 
     // workaround #226 (and array relevance thereof demonstrated in mike102/otype-slow-ndims.cfa)
-    static inline void ?{}( arpk(N, S, Timmed, Tbase) & this ) {
-        void ?{}( S (&inner)[z(N)] ) {}
+    void ?{}( arpk(Zn, S, Timmed, Tbase) & this ) {
+        void ?{}( S (&inner)[z(Zn)] ) {}
         ?{}(this.strides);
     }
-    static inline void ^?{}( arpk(N, S, Timmed, Tbase) & this ) {
-        void ^?{}( S (&inner)[z(N)] ) {}
+    void ^?{}( arpk(Zn, S, Timmed, Tbase) & this ) {
+        void ^?{}( S (&inner)[z(Zn)] ) {}
         ^?{}(this.strides);
     }
@@ -75 +48 @@
 
 forall( Te )
-static inline Te mkar_( tag(Te) ) {}
+Te mkar_( tag(Te) ) {}
 
-forall( [N], ZTags ... , Trslt &, Tatom & | { Trslt mkar_( tag(Tatom), ZTags ); } )
-static inline arpk(N, Trslt, Trslt, Tatom) mkar_( tag(Tatom), tag(N), ZTags ) {}
+forall( ztype(Zn), ZTags ... , Trslt &, Tatom & | { Trslt mkar_( tag(Tatom), ZTags ); } )
+arpk(Zn, Trslt, Trslt, Tatom) mkar_( tag(Tatom), tag(Zn), ZTags ) {}
 
 // based on https://stackoverflow.com/questions/1872220/is-it-possible-to-iterate-over-arguments-in-variadic-macros
@@ -107 +80 @@
 // Core -[[-,-,-]] operator
 
-#ifdef TRY_BROKEN_DESIRED_MD_SUBSCRIPT
+// Desired form.  One definition with recursion on IxBC (worked until Jan 2021, see trac #__TODO__)
+// forall( TA &, TB &, TC &, IxAB, IxBC ... | { TB & ?[?]( TA &, IxAB ); TC & ?[?]( TB &, IxBC ); } )
+// TC & ?[?]( TA & this, IxAB ab, IxBC bc ) {
+//     return this[ab][bc];
+// }
 
-// Desired form.  One definition with recursion on IxBC (worked until Jan 2021, see trac #__TODO__)
-
-forall( TA &, TB &, TC &, IxAB, IxBC ... | { TB & ?[?]( TA &, IxAB ); TC & ?[?]( TB &, IxBC ); } )
-static inline TC & ?[?]( TA & this, IxAB ab, IxBC bc ) {
+// Workaround form.  Listing all possibilities up to 4 dims.
+forall( TA &, TB &, IxAB | { TB & ?[?]( TA &, IxAB ); }
+            , TC &, IxBC | { TC & ?[?]( TB &, IxBC ); } )
+TC & ?[?]( TA & this, IxAB ab, IxBC bc ) {
     return this[ab][bc];
 }
-
-#else 
-
-// Workaround form.  Listing all possibilities up to 4 dims.
-
-forall( TA &, TB &, TC &, IxAB_0, IxBC | { TB & ?[?]( TA &, IxAB_0 ); TC & ?[?]( TB &, IxBC ); } )
-static inline TC & ?[?]( TA & this, IxAB_0 ab, IxBC bc ) {
-    return this[ab][bc];
+forall( TA &, TB &, IxAB | { TB & ?[?]( TA &, IxAB ); }
+            , TC &, IxBC | { TC & ?[?]( TB &, IxBC ); }
+            , TD &, IxCD | { TD & ?[?]( TC &, IxCD ); } )
+TD & ?[?]( TA & this, IxAB ab, IxBC bc, IxCD cd ) {
+    return this[ab][bc][cd];
+}
+forall( TA &, TB &, IxAB | { TB & ?[?]( TA &, IxAB ); }
+            , TC &, IxBC | { TC & ?[?]( TB &, IxBC ); }
+            , TD &, IxCD | { TD & ?[?]( TC &, IxCD ); }
+            , TE &, IxDE | { TE & ?[?]( TD &, IxDE ); } )
+TE & ?[?]( TA & this, IxAB ab, IxBC bc, IxCD cd, IxDE de ) {
+    return this[ab][bc][cd][de];
 }
 
-forall( TA &, TB &, TC &, IxAB_0, IxAB_1, IxBC | { TB & ?[?]( TA &, IxAB_0, IxAB_1 ); TC & ?[?]( TB &, IxBC ); } )
-static inline TC & ?[?]( TA & this, IxAB_0 ab0, IxAB_1 ab1, IxBC bc ) {
-    return this[[ab0,ab1]][bc];
+// Adapters for "indexed by ptrdiff_t" implies "indexed by [this other integral type]"
+// Work around restriction that assertions underlying -[[-,-,-]] must match excatly
+forall( C &, E & | { E & ?[?]( C &, ptrdiff_t ); } ) {
+
+    // Targeted to support:  for( i; z(N) ) ... a[[ ..., i, ... ]]
+    E & ?[?]( C & this, size_t i ) {
+        return this[ (ptrdiff_t) i ];
+    }
+
+    // Targeted to support:  for( i; 5 ) ... a[[ ..., i, ... ]]
+    E & ?[?]( C & this, int i ) {
+        return this[ (ptrdiff_t) i ];
+    }
 }
-
-forall( TA &, TB &, TC &, IxAB_0, IxAB_1, IxAB_2, IxBC | { TB & ?[?]( TA &, IxAB_0, IxAB_1, IxAB_2 ); TC & ?[?]( TB &, IxBC ); } )
-static inline TC & ?[?]( TA & this, IxAB_0 ab0, IxAB_1 ab1, IxAB_2 ab2, IxBC bc ) {
-    return this[[ab0,ab1,ab2]][bc];
-}
-
-#endif
 
 //
@@ -142 +126 @@
 
 // Base
-forall( [Nq], Sq & | sized(Sq), Tbase & )
-static inline tag(arpk(Nq, Sq, Tbase, Tbase)) enq_( tag(Tbase), tag(Nq), tag(Sq), tag(Tbase) ) {}
+forall( ztype(Zq), ztype(Sq), Tbase & )
+tag(arpk(Zq, Sq, Tbase, Tbase)) enq_( tag(Tbase), tag(Zq), tag(Sq), tag(Tbase) ) {}
 
 // Rec
-forall( [Nq], Sq & | sized(Sq), [N], S & | sized(S), recq &, recr &, Tbase & | { tag(recr) enq_( tag(Tbase), tag(Nq), tag(Sq), tag(recq) ); } )
-static inline tag(arpk(N, S, recr, Tbase)) enq_( tag(Tbase), tag(Nq), tag(Sq), tag(arpk(N, S, recq, Tbase)) ) {}
+forall( ztype(Zq), ztype(Sq), ztype(Z), ztype(S), recq &, recr &, Tbase & | { tag(recr) enq_( tag(Tbase), tag(Zq), tag(Sq), tag(recq) ); } )
+tag(arpk(Z, S, recr, Tbase)) enq_( tag(Tbase), tag(Zq), tag(Sq), tag(arpk(Z, S, recq, Tbase)) ) {}
 
 // Wrapper
 struct all_t {} all;
-forall( [N], S & | sized(S), Te &, result &, Tbase & | { tag(result) enq_( tag(Tbase), tag(N), tag(S), tag(Te) ); } )
-static inline result & ?[?]( arpk(N, S, Te, Tbase) & this, all_t ) {
+forall( ztype(Z), ztype(S), Te &, result &, Tbase & | { tag(result) enq_( tag(Tbase), tag(Z), tag(S), tag(Te) ); } )
+result & ?[?]( arpk(Z, S, Te, Tbase) & this, all_t ) {
     return (result&) this;
 }