Changeset 9f7285e for libcfa/prelude/builtins.c

Timestamp:

Dec 8, 2024, 9:02:49 AM (10 days ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

bc999b7

Parents:

6503ef4

Message:

formatting, temporarily remove quasi_void

File:

• libcfa/prelude/builtins.c (modified) (10 diffs)

libcfa/prelude/builtins.c

@@ -10 +10 @@
 // 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 +48 @@
 #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 +61 @@
 };
 
-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 +78 @@
 // 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 +111 @@
 // 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 +124 @@
 } // 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 +156 @@
 } // 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 +209 @@
                 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 +228 @@
 
 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 +237 @@
 
         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 );
         }
 }