Index: libcfa/prelude/builtins.c
===================================================================
--- libcfa/prelude/builtins.c	(revision 6503ef4f201545a960c07a4385e562f244961952)
+++ libcfa/prelude/builtins.c	(revision 9f7285e5547fb00a14b8c717d94e50278e13e78f)
@@ -10,30 +10,31 @@
 // Created On       : Fri Jul 21 16:21:03 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Nov  8 17:07:15 2024
-// Update Count     : 144
+// Last Modified On : Sun Dec  8 09:01:23 2024
+// Update Count     : 149
 //
 
 #define __cforall_builtins__
 
-// type that wraps a pointer and a destructor-like function - used in generating implicit destructor calls for struct members in user-defined functions
-// Note: needs to occur early, because it is used to generate destructor calls during code generation
-forall(T &)
+// Type that wraps a pointer and a destructor-like function - used in generating implicit destructor calls for struct
+// members in user-defined functions. Note: needs to occur early, because it is used to generate destructor calls during
+// code generation
+forall( T &)
 struct __Destructor {
 	T * object;
-	void (*dtor)(T *);
-};
-
-// defined destructor in the case that non-generated code wants to use __Destructor
-forall(T &)
-static inline void ^?{}(__Destructor(T) & x) {
-	if (x.object && x.dtor) {
-		x.dtor(x.object);
-	}
-}
-
-// easy interface into __Destructor's destructor for easy codegen purposes
+	void (*dtor)( T * );
+};
+
+// Defined destructor in the case that non-generated code wants to use __Destructor.
+forall( T &)
+static inline void ^?{}( __Destructor(T) & x ) {
+	if ( x.object && x.dtor ) {
+		x.dtor( x.object );
+	}
+}
+
+// Easy interface into __Destructor's destructor for easy codegen purposes.
 extern "C" {
-	forall(T &)
-	static inline void __destroy_Destructor(__Destructor(T) * dtor) {
+	forall( T &)
+	static inline void __destroy_Destructor( __Destructor(T) * dtor ) {
 		^(*dtor){};
 	}
@@ -47,9 +48,9 @@
 #include "../src/exception.h"
 
-void exit( int status, const char fmt[], ... ) __attribute__ (( format(printf, 2, 3), __nothrow__, __leaf__, __noreturn__ ));
-void abort( const char fmt[], ... ) __attribute__ (( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ ));
-
-forall(T &)
-static inline T & identity(T & i) {
+void exit( int status, const char fmt[], ... ) __attribute__ (( format( printf, 2, 3 ), __nothrow__, __leaf__, __noreturn__ ));
+void abort( const char fmt[], ... ) __attribute__ (( format( printf, 1, 2 ), __nothrow__, __leaf__, __noreturn__ ));
+
+forall( T &)
+static inline T & identity( T & i ) {
 	return i;
 }
@@ -60,16 +61,16 @@
 };
 
-static inline void  ?{}(generator$ & this) { ((int&)this) = 0; }
-static inline void ^?{}(generator$ &) {}
+static inline void  ?{}( generator$ & this ) { ((int&)this) = 0; }
+static inline void ^?{}( generator$ &) {}
 
 forall( T & )
 trait is_generator {
-      void main(T & this);
-      generator$ * get_generator(T & this);
-};
-
-forall(T & | is_generator(T))
-static inline T & resume(T & gen) {
-	main(gen);
+      void main( T & this );
+      generator$ * get_generator( T & this );
+};
+
+forall( T & | is_generator( T ) )
+static inline T & resume( T & gen ) {
+	main( gen );
 	return gen;
 }
@@ -77,5 +78,5 @@
 // implicit increment, decrement if += defined, and implicit not if != defined
 
-// C11 reference manual Section 6.5.16 (page101): "An assignment expression has the value of the left operand after the
+// C11 reference manual Section 6.5.16 (page 101): "An assignment expression has the value of the left operand after the
 // assignment, but is not an lvalue." Hence, return a value not a reference.
 static inline {
@@ -110,4 +111,5 @@
 // forall( T | { void ?{}( T &, zero_t ); void ?{}( T &, one_t ); T ?+=?( T &, T ); T ?-=?( T &, T ); int ?<?( T, T ); } )
 // static inline T __for_control_index_constraints__( T t ) { return t; }
+
 
 // exponentiation operator implementation
@@ -122,9 +124,9 @@
 } // extern "C"
 
-static inline {
+static inline {											// wrappers
 	float ?\?( float x, float y ) { return powf( x, y ); }
 	double ?\?( double x, double y ) { return pow( x, y ); }
 	long double ?\?( long double x, long double y ) { return powl( x, y ); }
-	float _Complex ?\?( float _Complex x, _Complex float y ) { return cpowf(x, y ); }
+	float _Complex ?\?( float _Complex x, _Complex float y ) { return cpowf( x, y ); }
 	double _Complex ?\?( double _Complex x, _Complex double y ) { return cpow( x, y ); }
 	long double _Complex ?\?( long double _Complex x, _Complex long double y ) { return cpowl( x, y ); }
@@ -154,13 +156,16 @@
 } // distribution
 
-struct quasi_void {};
-static inline void ?{}(quasi_void &) {}
-static inline void ?{}(quasi_void &, quasi_void) {}
-static inline void ^?{}(quasi_void &) {}
-static inline quasi_void ?=?(quasi_void &, quasi_void & _src) { return _src; }
+// struct quasi_void {};
+// static inline void ?{}( quasi_void &) {}
+// static inline void ?{}( quasi_void &, quasi_void ) {}
+// static inline void ^?{}( quasi_void &) {}
+// static inline quasi_void ?=?( quasi_void &, quasi_void & _src ) { return _src; }
+
+
+// enumeration implementation
 
 forall( E ) trait Bounded {
-	E lowerBound(void);
-	E upperBound(void);
+	E lowerBound( void );
+	E upperBound( void );
 };
 
@@ -204,10 +209,10 @@
 		if ( fromInstance( e ) >= fromInstance( upper ) )
 			abort( "call to succ() exceeds enumeration upper bound of %d.", fromInstance( upper ) );
-		return succ_unsafe(e);
+		return succ_unsafe( e );
 	}
 
 	E pred( E e ) {
 		E lower = lowerBound();
-		if ( fromInstance( e ) <= fromInstance(lower ) )
+		if ( fromInstance( e ) <= fromInstance( lower ) )
 			abort( "call to pred() exceeds enumeration lower bound of %d.", fromInstance( lower ) );
 		return pred_unsafe( e );
@@ -223,5 +228,5 @@
 
 static inline
-forall( E | CfaEnum(E) | Serial(E) ) {
+forall( E | CfaEnum( E ) | Serial( E ) ) {
 	int ?==?( E l, E r ) { return posn( l ) == posn( r ); }	// relational operators
 	int ?!=?( E l, E r ) { return posn( l ) != posn( r ); }
@@ -232,49 +237,49 @@
 
 	E ++?( E & l ) { 									// increment operators
-		int pos = posn(l);
-		l = fromInt_unsafe(pos+1);
+		int pos = posn( l );
+		l = fromInt_unsafe( pos + 1 );
 		return l;
 	}
 
 	E --?( E & l ) {
-		int pos = posn(l);
-		l = fromInt_unsafe(pos-1);
+		int pos = posn( l );
+		l = fromInt_unsafe( pos - 1 );
 		return l;
 	}
 
 	E ?+=? ( E & l, one_t ) {
-		int pos = posn(l);
-		l = fromInt_unsafe(pos+1);
+		int pos = posn( l );
+		l = fromInt_unsafe( pos + 1 );
 		return l;
 	}
 
 	E ?-=? ( E & l, one_t ) {
-		int pos = posn(l);
-		l = fromInt_unsafe(pos-1);
+		int pos = posn( l );
+		l = fromInt_unsafe( pos - 1 );
 		return l;
 	}
 
 	E ?+=? ( E & l, int i ) {
-		int pos = posn(l);
-		l = fromInt_unsafe(pos+i);
+		int pos = posn( l );
+		l = fromInt_unsafe( pos + i );
 		return l;
 	}
 
 	E ?-=? ( E & l, int i ) {
-		int pos = posn(l);
-		l = fromInt_unsafe(pos-i);
+		int pos = posn( l );
+		l = fromInt_unsafe( pos - i );
 		return l;
 	}
 
 	E ?++( E & l ) {
-		int pos = posn(l);
-		l = fromInt_unsafe(pos+1);
-		return fromInt_unsafe(pos);
+		int pos = posn( l );
+		l = fromInt_unsafe( pos + 1 );
+		return fromInt_unsafe( pos );
 	}
 
 	E ?--( E & l ) {
-		int pos = posn(l);
-		l = fromInt_unsafe(pos-1);
-		return fromInt_unsafe(pos);
+		int pos = posn( l );
+		l = fromInt_unsafe( pos - 1 );
+		return fromInt_unsafe( pos );
 	}
 }