Index: libcfa/prelude/builtins.c
===================================================================
--- libcfa/prelude/builtins.c	(revision ae6b6cf796a0f3fdf820aab4c5ad66768ec6d9cb)
+++ libcfa/prelude/builtins.c	(revision 8dbfb7e85838167c7235e53538d79e9a3f90a70c)
@@ -10,6 +10,6 @@
 // Created On       : Fri Jul 21 16:21:03 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Mar 10 10:52:50 2019
-// Update Count     : 31
+// Last Modified On : Tue Mar 26 14:05:49 2019
+// Update Count     : 84
 //
 
@@ -26,19 +26,20 @@
 // increment/decrement unification
 
-static inline forall( dtype T | { T & ?+=?( T &, one_t ); } )
-T & ++? ( T & x ) { return x += 1; }
+static inline forall( dtype DT | { DT & ?+=?( DT &, one_t ); } )
+DT & ++?( DT & x ) { return x += 1; }
 
-static inline forall( dtype T | sized(T) | { void ?{}( T &, T ); void ^?{}( T & ); T & ?+=?( T &, one_t ); } )
-T & ?++ ( T & x ) { T tmp = x; x += 1; return tmp; }
+static inline forall( dtype DT | sized(DT) | { void ?{}( DT &, DT ); void ^?{}( DT & ); DT & ?+=?( DT &, one_t ); } )
+DT & ?++( DT & x ) { DT tmp = x; x += 1; return tmp; }
 
-static inline forall( dtype T | { T & ?-=?( T &, one_t ); } )
-T & --? ( T & x ) { return x -= 1; }
+static inline forall( dtype DT | { DT & ?-=?( DT &, one_t ); } )
+DT & --?( DT & x ) { return x -= 1; }
 
-static inline forall( dtype T | sized(T) | { void ?{}( T &, T ); void ^?{}( T & ); T & ?-=?( T &, one_t ); } )
-T & ?-- ( T & x ) { T tmp = x; x -= 1; return tmp; }
+static inline forall( dtype DT | sized(DT) | { void ?{}( DT &, DT ); void ^?{}( DT & ); DT & ?-=?( DT &, one_t ); } )
+DT & ?--( DT & x ) { DT tmp = x; x -= 1; return tmp; }
 
 // universal typed pointer constant
 
-static inline forall( dtype T ) T * intptr( uintptr_t addr ) { return (T *)addr; }
+// Compiler issue: there is a problem with anonymous types that do not have  a size.
+static inline forall( dtype DT | sized(DT) ) DT * intptr( uintptr_t addr ) { return (DT *)addr; }
 
 // exponentiation operator implementation
@@ -60,53 +61,57 @@
 static inline long double _Complex ?\?( long double _Complex x, _Complex long double y ) { return cpowl( x, y ); }
 
-static inline long int ?\?( long int ep, unsigned long int y ) { // disallow negative exponent
-	if ( y == 0 ) return 1;								// base case
-	if ( ep == 2 ) return ep << (y - 1);				// special case, positive shifting only
-	typeof( ep ) op = 1;								// accumulate odd product
-	for ( ; y > 1; y >>= 1 ) {							// squaring exponentiation, O(log2 y)
-		if ( (y & 1) == 1 ) op *= ep;					// odd ?
-		ep *= ep;
-	} // for
-	return ep * op;
+#define __CFA_EXP__() \
+	if ( y == 0 ) return 1;								/* base case */ \
+	__CFA_BASE_COMP_1__()								/* base case */ \
+	__CFA_BASE_COMP_2__()								/* special case, positive shifting for integral types */ \
+	__CFA_EXP_OVERFLOW__()								/* immediate overflow, negative exponent > 2^size-1 */ \
+	typeof(ep) op = 1;									/* accumulate odd product */ \
+	for ( ; y > 1; y >>= 1 ) {							/* squaring exponentiation, O(log2 y) */ \
+		if ( (y & 1) == 1 ) op = op * ep;				/* odd ? */ \
+		ep = ep * ep; \
+	} \
+	return ep * op
+
+#define __CFA_BASE_COMP_1__() if ( ep == 1 ) return 1;
+#define __CFA_BASE_COMP_2__() if ( ep == 2 ) return ep << (y - 1);
+#define __CFA_EXP_OVERFLOW__() if ( y >= sizeof(y) * 8 ) return 0;
+
+static inline long int ?\?( int ep, unsigned int y ) {
+	__CFA_EXP__();
 } // ?\?
 
-static inline forall( otype T | { void ?{}( T & this, one_t ); T ?*?( T, T ); } )
-T ?\?( T ep, unsigned long int y ) {
-	if ( y == 0 ) return 1;
-	T op = 1;
-	for ( ; y > 1; y >>= 1 ) {							// squaring exponentiation, O(log2 y)
-		if ( (y & 1) == 1 ) op = op * ep;				// odd ?
-		ep = ep * ep;
-	} // for
-	return ep * op;
+static inline long int ?\?( long int ep, unsigned long int y ) {
+	__CFA_EXP__();
 } // ?\?
 
 // unsigned computation may be faster and larger
-static inline unsigned long int ?\?( unsigned long int ep, unsigned long int y ) { // disallow negative exponent
-	if ( y == 0 ) return 1;								// base case
-	if ( ep == 2 ) return ep << (y - 1);				// special case, positive shifting only
-	typeof( ep ) op = 1;								// accumulate odd product
-	for ( ; y > 1; y >>= 1 ) {							// squaring exponentiation, O(log2 y)
-		if ( (y & 1) == 1 ) op *= ep;					// odd ?
-		ep *= ep;
-	} // for
-	return ep * op;
+static inline unsigned long int ?\?( unsigned int ep, unsigned int y ) {
+	__CFA_EXP__();
 } // ?\?
 
-static inline double ?\?( long int x, signed long int y ) {	// allow negative exponent
-	if ( y >=  0 ) return (double)(x \ (unsigned long int)y);
-	else return 1.0 / x \ (unsigned int)(-y);
+static inline unsigned long int ?\?( unsigned long int ep, unsigned long int y ) {
+	__CFA_EXP__();
 } // ?\?
 
-// FIXME (x \ (unsigned long int)y) relies on X ?\?(T, unsigned long) a function that is neither
-// defined, nor passed as an assertion parameter. Without user-defined conversions, cannot specify
-// X as a type that casts to double, yet it doesn't make sense to write functions with that type
-// signature where X is double.
+#undef __CFA_BASE_COMP_1__
+#undef __CFA_BASE_COMP_2__
+#undef __CFA_EXP_OVERFLOW__
+#define __CFA_BASE_COMP_1__()
+#define __CFA_BASE_COMP_2__()
+#define __CFA_EXP_OVERFLOW__()
 
-// static inline forall( otype T | { void ?{}( T & this, one_t ); T ?*?( T, T ); double ?/?( double, T ); } )
-// double ?\?( T x, signed long int y ) {
-//     if ( y >=  0 ) return (double)(x \ (unsigned long int)y);
-//     else return 1.0 / x \ (unsigned long int)(-y);
-// } // ?\?
+static inline forall( otype OT | { void ?{}( OT & this, one_t ); OT ?*?( OT, OT ); } )
+OT ?\?( OT ep, unsigned int y ) {
+	__CFA_EXP__();
+} // ?\?
+
+static inline forall( otype OT | { void ?{}( OT & this, zero_t ); void ?{}( OT & this, one_t ); int ?==?( OT, OT ); OT ?*?( OT, OT ); } )
+OT ?\?( OT ep, unsigned long int y ) {
+	__CFA_EXP__();
+} // ?\?
+
+#undef __CFA_BASE_COMP_1__
+#undef __CFA_BASE_COMP_2__
+#undef __CFA_EXP_OVERFLOW__
 
 static inline long int ?\=?( long int & x, unsigned long int y ) { x = x \ y; return x; }