Index: libcfa/src/collections/array.hfa
===================================================================
--- libcfa/src/collections/array.hfa	(revision cfbc56ecba6583d7520c7a7a6bf7f4194e8016a0)
+++ libcfa/src/collections/array.hfa	(revision 1bb017077f97c1ee52b5e23882e2b6f50fa44ba9)
@@ -8,4 +8,8 @@
 #define ztag(n) ttag(n)
 
+#define subcheck( arr, sub, lb, ub ) \
+	if ( (sub) < (lb) || (sub) >= (ub) ) \
+		abort( "subscript %ld exceeds dimension range [%d,%zd) for array %p\n", \
+			   (sub), (lb), (ub), (arr) );
 
 // 
@@ -36,123 +40,132 @@
 //
 forall( [N], S & | sized(S), Timmed &, Tbase & ) {
-
-    //
-    // Single-dim array sruct (with explicit packing and atom)
-    //
-    struct arpk {
-        S strides[N];
-    };
-
-    // About the choice of integral types offered as subscript overloads:
-    // Intent is to cover these use cases:
-    //    a[0]                                                // i : zero_t
-    //    a[1]                                                // i : one_t
-    //    a[2]                                                // i : int
-    //    float foo( ptrdiff_t i ) { return a[i]; }           // i : ptrdiff_t
-    //    float foo( size_t i ) { return a[i]; }              // i : size_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 (and cfa)
-    // 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
-    //
-    // So the solution must support types {zero_t, one_t, int, unsigned int, long int, unsigned long int}
-    //
-    // The solution cannot rely on implicit conversions (e.g. just have one overload for ptrdiff_t)
-    // because assertion satisfaction requires types to match exacly.  Both higher-dimensional
-    // subscripting and operations on slices use asserted subscript operators.  The test case
-    // array-container/array-sbscr-cases covers the combinations.  Mike beleives that commenting out
-    // any of the current overloads leads to one of those cases failing, either on 64- or 32-bit.
-    // Mike is open to being shown a smaller set of overloads that still passes the test.
-
-    static inline Timmed & ?[?]( arpk(N, S, Timmed, Tbase) & a, zero_t ) {
-        assert( 0 < N );
-        return (Timmed &) a.strides[0];
-    }
-
-    static inline Timmed & ?[?]( arpk(N, S, Timmed, Tbase) & a, one_t ) {
-        assert( 1 < N );
-        return (Timmed &) a.strides[1];
-    }
-
-    static inline Timmed & ?[?]( arpk(N, S, Timmed, Tbase) & a, int i ) {
-        assert( i < N );
-        return (Timmed &) a.strides[i];
-    }
-
-    static inline const Timmed & ?[?]( const arpk(N, S, Timmed, Tbase) & a, int i ) {
-        assert( i < N );
-        return (Timmed &) a.strides[i];
-    }
-
-    static inline Timmed & ?[?]( arpk(N, S, Timmed, Tbase) & a, unsigned int i ) {
-        assert( i < N );
-        return (Timmed &) a.strides[i];
-    }
-
-    static inline const Timmed & ?[?]( const arpk(N, S, Timmed, Tbase) & a, unsigned int i ) {
-        assert( i < N );
-        return (Timmed &) a.strides[i];
-    }
-
-    static inline Timmed & ?[?]( arpk(N, S, Timmed, Tbase) & a, long int i ) {
-        assert( i < N );
-        return (Timmed &) a.strides[i];
-    }
-
-    static inline const Timmed & ?[?]( const arpk(N, S, Timmed, Tbase) & a, long int i ) {
-        assert( i < N );
-        return (Timmed &) a.strides[i];
-    }
-
-    static inline Timmed & ?[?]( arpk(N, S, Timmed, Tbase) & a, unsigned long int i ) {
-        assert( i < N );
-        return (Timmed &) a.strides[i];
-    }
-
-    static inline const Timmed & ?[?]( const arpk(N, S, Timmed, Tbase) & a, unsigned long int i ) {
-        assert( i < N );
-        return (Timmed &) a.strides[i];
-    }
-
-    static inline size_t ?`len( arpk(N, S, Timmed, Tbase) & a ) {
-        return N;
-    }
-
-    static inline void __taglen( tag(arpk(N, S, Timmed, Tbase)), tag(N) ) {}
+	//
+	// Single-dim array sruct (with explicit packing and atom)
+	//
+	struct arpk {
+		S strides[N];
+	};
+
+	// About the choice of integral types offered as subscript overloads:
+	// Intent is to cover these use cases:
+	//    a[0]                                                // i : zero_t
+	//    a[1]                                                // i : one_t
+	//    a[2]                                                // i : int
+	//    float foo( ptrdiff_t i ) { return a[i]; }           // i : ptrdiff_t
+	//    float foo( size_t i ) { return a[i]; }              // i : size_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 (and cfa)
+	// 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
+	//
+	// So the solution must support types {zero_t, one_t, int, unsigned int, long int, unsigned long int}
+	//
+	// The solution cannot rely on implicit conversions (e.g. just have one overload for ptrdiff_t)
+	// because assertion satisfaction requires types to match exacly.  Both higher-dimensional
+	// subscripting and operations on slices use asserted subscript operators.  The test case
+	// array-container/array-sbscr-cases covers the combinations.  Mike beleives that commenting out
+	// any of the current overloads leads to one of those cases failing, either on 64- or 32-bit.
+	// Mike is open to being shown a smaller set of overloads that still passes the test.
+
+	static inline Timmed & ?[?]( arpk(N, S, Timmed, Tbase ) & a, zero_t ) {
+		//assert( 0 < N );
+		subcheck( a, 0L, 0, N );
+		return (Timmed &) a.strides[0];
+	}
+
+	static inline Timmed & ?[?]( arpk(N, S, Timmed, Tbase ) & a, one_t ) {
+		//assert( 1 < N );
+		subcheck( a, 1L, 0, N );
+		return (Timmed &) a.strides[1];
+	}
+
+	static inline Timmed & ?[?]( arpk(N, S, Timmed, Tbase ) & a, int i ) {
+		//assert( i < N );
+		subcheck( a, (long int)i, 0, N );
+		return (Timmed &) a.strides[i];
+	}
+
+	static inline const Timmed & ?[?]( const arpk(N, S, Timmed, Tbase ) & a, int i ) {
+		//assert( i < N );
+		subcheck( a, (long int)i, 0, N );
+		return (Timmed &) a.strides[i];
+	}
+
+	static inline Timmed & ?[?]( arpk(N, S, Timmed, Tbase ) & a, unsigned int i ) {
+		//assert( i < N );
+		subcheck( a, (long int)i, 0, N );
+		return (Timmed &) a.strides[i];
+	}
+
+	static inline const Timmed & ?[?]( const arpk(N, S, Timmed, Tbase ) & a, unsigned int i ) {
+		//assert( i < N );
+		subcheck( a, (unsigned long int)i, 0, N );
+		return (Timmed &) a.strides[i];
+	}
+
+	static inline Timmed & ?[?]( arpk(N, S, Timmed, Tbase ) & a, long int i ) {
+		//assert( i < N );
+		subcheck( a, i, 0, N );
+		return (Timmed &) a.strides[i];
+	}
+
+	static inline const Timmed & ?[?]( const arpk(N, S, Timmed, Tbase ) & a, long int i ) {
+		//assert( i < N );
+		subcheck( a, i, 0, N );
+		return (Timmed &) a.strides[i];
+	}
+
+	static inline Timmed & ?[?]( arpk(N, S, Timmed, Tbase ) & a, unsigned long int i ) {
+		//assert( i < N );
+		subcheck( a, i, 0, N );
+		return (Timmed &) a.strides[i];
+	}
+
+	static inline const Timmed & ?[?]( const arpk(N, S, Timmed, Tbase ) & a, unsigned long int i ) {
+		//assert( i < N );
+		subcheck( a, i, 0, N );
+		return (Timmed &) a.strides[i];
+	}
+
+	static inline size_t ?`len( arpk(N, S, Timmed, Tbase ) & a ) {
+		return N;
+	}
+
+	static inline void __taglen( tag(arpk(N, S, Timmed, Tbase )), tag(N) ) {}
 }
 
 // RAII pattern has workarounds for
 //  - Trac 226:  Simplest handling would be, require immediate element to be otype, let autogen
-//    raii happen.  Performance on even a couple dimensions is unacceptable because of exponential
-//    thunk creation: ?{}() needs all four otype funcs from next level, so does ^?{}(), so do the
-//    other two.  This solution offers ?{}() that needs only ?{}(), and similar for ^?{}.
+//	raii happen.  Performance on even a couple dimensions is unacceptable because of exponential
+//	thunk creation: ?{}() needs all four otype funcs from next level, so does ^?{}(), so do the
+//	other two.  This solution offers ?{}() that needs only ?{}(), and similar for ^?{}.
 
 forall( [N], S & | sized(S), Timmed &, Tbase & | { void ?{}( Timmed & ); } )
-static inline void ?{}( arpk(N, S, Timmed, Tbase) & this ) {    
-    void ?{}( S (&)[N] ) {}
-    ?{}(this.strides);
-
-    for (i; N) ?{}( (Timmed &) this.strides[i] );
+static inline void ?{}( arpk(N, S, Timmed, Tbase ) & this ) {	
+	void ?{}( S (&)[N] ) {}
+	?{}(this.strides);
+
+	for (i; N) ?{}( (Timmed &) this.strides[i] );
 }
 
 forall( [N], S & | sized(S), Timmed &, Tbase & | { void ^?{}( Timmed & ); } )
-static inline void ^?{}( arpk(N, S, Timmed, Tbase) & this ) {
-    void ^?{}( S (&)[N] ) {}
-    ^?{}(this.strides);
-
-    for (i; N ) {
-        ^?{}( (Timmed &) this.strides[N-i-1] );
-    }
+static inline void ^?{}( arpk(N, S, Timmed, Tbase ) & this ) {
+	void ^?{}( S (&)[N] ) {}
+	^?{}(this.strides);
+
+	for (i; N ) {
+		^?{}( (Timmed &) this.strides[N-i-1] );
+	}
 }
 
@@ -169,16 +182,16 @@
 // based on https://stackoverflow.com/questions/1872220/is-it-possible-to-iterate-over-arguments-in-variadic-macros
 
-    // Make a FOREACH macro
-    #define FE_0(WHAT)
-    #define FE_1(WHAT, X) WHAT(X)
-    #define FE_2(WHAT, X, ...) WHAT(X)FE_1(WHAT, __VA_ARGS__)
-    #define FE_3(WHAT, X, ...) WHAT(X)FE_2(WHAT, __VA_ARGS__)
-    #define FE_4(WHAT, X, ...) WHAT(X)FE_3(WHAT, __VA_ARGS__)
-    #define FE_5(WHAT, X, ...) WHAT(X)FE_4(WHAT, __VA_ARGS__)
-    //... repeat as needed
-
-    #define GET_MACRO(_0,_1,_2,_3,_4,_5,NAME,...) NAME
-    #define FOR_EACH(action,...) \
-    GET_MACRO(_0,__VA_ARGS__,FE_5,FE_4,FE_3,FE_2,FE_1,FE_0)(action,__VA_ARGS__)
+	// Make a FOREACH macro
+	#define FE_0(WHAT)
+	#define FE_1(WHAT, X) WHAT(X)
+	#define FE_2(WHAT, X, ...) WHAT(X)FE_1(WHAT, __VA_ARGS__)
+	#define FE_3(WHAT, X, ...) WHAT(X)FE_2(WHAT, __VA_ARGS__)
+	#define FE_4(WHAT, X, ...) WHAT(X)FE_3(WHAT, __VA_ARGS__)
+	#define FE_5(WHAT, X, ...) WHAT(X)FE_4(WHAT, __VA_ARGS__)
+	//... repeat as needed
+
+	#define GET_MACRO(_0,_1,_2,_3,_4,_5,NAME,...) NAME
+	#define FOR_EACH(action,...) \
+	GET_MACRO(_0,__VA_ARGS__,FE_5,FE_4,FE_3,FE_2,FE_1,FE_0)(action,__VA_ARGS__)
 
 #define COMMA_ttag(X) , ttag(X)
@@ -200,5 +213,5 @@
 forall( TA &, TB &, TC &, IxAB, IxBC ... | { TB & ?[?]( TA &, IxAB ); TC & ?[?]( TB &, IxBC ); } )
 static inline TC & ?[?]( TA & this, IxAB ab, IxBC bc ) {
-    return this[ab][bc];
+	return this[ab][bc];
 }
 
@@ -209,15 +222,15 @@
 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];
+	return this[ab][bc];
 }
 
 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];
+	return this[[ab0,ab1]][bc];
 }
 
 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];
+	return this[[ab0,ab1,ab2]][bc];
 }
 
@@ -237,21 +250,21 @@
 // Base
 forall( [Nq], Sq & | sized(Sq), Tbase & )
-static inline tag(arpk(Nq, Sq, Tbase, Tbase)) enq_( tag(Tbase), tag(Nq), tag(Sq), tag(Tbase) ) {
-    tag(arpk(Nq, Sq, Tbase, Tbase)) ret;
-    return ret;
+static inline tag(arpk(Nq, Sq, Tbase, Tbase )) enq_( tag(Tbase ), tag(Nq), tag(Sq), tag(Tbase ) ) {
+	tag(arpk(Nq, Sq, Tbase, Tbase )) ret;
+	return ret;
 }
 
 // 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)) ) {
-    tag(arpk(N, S, recr, Tbase)) ret;
-    return ret;
+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 )) ) {
+	tag(arpk(N, S, recr, Tbase )) ret;
+	return ret;
 }
 
 // Wrapper
 extern 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 ) {
-    return (result&) this;
+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 ) {
+	return (result&) this;
 }
 
@@ -263,22 +276,22 @@
 // forall(A &, Tv &, [N])
 // trait ar {
-//     Tv& ?[?]( A&, zero_t );
-//     Tv& ?[?]( A&, one_t  );
-//     Tv& ?[?]( A&, int    );
-//                   ...
-//     size_t ?`len( A& );
-//     void __taglen( tag(C), tag(N) );
+//	 Tv& ?[?]( A&, zero_t );
+//	 Tv& ?[?]( A&, one_t  );
+//	 Tv& ?[?]( A&, int	);
+//				   ...
+//	 size_t ?`len( A& );
+//	 void __taglen( tag(C), tag(N) );
 // };
 
 // working around N's not being accepted as arguments to traits
 
-#define ar(A, Tv, N) {                 \
-    Tv& ?[?]( A&, zero_t );            \
-    Tv& ?[?]( A&, one_t );             \
-    Tv& ?[?]( A&, int );               \
-    Tv& ?[?]( A&, unsigned int );      \
-    Tv& ?[?]( A&, long int );          \
-    Tv& ?[?]( A&, unsigned long int ); \
-    size_t ?`len( A& );                \
-    void __taglen( tag(A), tag(N) );   \
-}
+#define ar( A, Tv, N ) {				\
+	Tv& ?[?]( A&, zero_t );				\
+	Tv& ?[?]( A&, one_t );				\
+	Tv& ?[?]( A&, int );				\
+	Tv& ?[?]( A&, unsigned int );		\
+	Tv& ?[?]( A&, long int );			\
+	Tv& ?[?]( A&, unsigned long int );	\
+	size_t ?`len( A& );					\
+	void __taglen( tag(A), tag(N) );	\
+}
