Changes in libcfa/src/stdlib.hfa [4a3eb1c:fbe3f03]

File:

• libcfa/src/stdlib.hfa (modified) (13 diffs)

libcfa/src/stdlib.hfa

@@ -10 +10 @@
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Apr 23 14:05:21 2024
-// Update Count     : 963
+// Last Modified On : Mon Apr 15 22:11:51 2024
+// Update Count     : 817
 //
 
@@ -47 +47 @@
 
 static inline forall( T & | sized(T) ) {
-        // CFA safe equivalents, i.e., implicit size specification, eliminate return-type cast
+        // CFA safe equivalents, i.e., implicit size specification
 
         T * malloc( void ) {
@@ -64 +64 @@
         } // calloc
 
-        T * resize( T * ptr, size_t size ) {
-                if ( _Alignof(T) <= libAlign() ) return (T *)resize( (void *)ptr, size ); // C resize
+        T * resize( T * ptr, size_t size ) {                            // CFA resize
+                if ( _Alignof(T) <= libAlign() ) return (T *)resize( (void *)ptr, size ); // CFA resize
                 else return (T *)resize( (void *)ptr, _Alignof(T), size ); // CFA resize
-        } // resize
-
-        T * resize( T * ptr, size_t alignment, size_t size ) {
-                return (T *)resize( (void *)ptr, alignment, size ); // CFA resize
         } // resize
 
@@ -78 +74 @@
         } // realloc
 
-        T * realloc( T * ptr, size_t alignment, size_t size ) {
-                return (T *)realloc( (void *)ptr, alignment, size ); // CFA realloc
-        } // realloc
-
         T * reallocarray( T * ptr, size_t dim ) {                       // CFA reallocarray
                 if ( _Alignof(T) <= libAlign() ) return (T *)reallocarray( (void *)ptr, dim, sizeof(T) ); // C reallocarray
@@ -87 +79 @@
         } // realloc
 
-        T * reallocarray( T * ptr, size_t alignment, size_t dim ) {
-                return (T *)reallocarray( (void *)ptr, alignment, dim ); // CFA reallocarray
-        } // realloc
-
         T * memalign( size_t align ) {
                 return (T *)memalign( align, sizeof(T) );               // C memalign
@@ -99 +87 @@
         } // amemalign
 
-        T * cmemalign( size_t align, size_t dim ) {
+        T * cmemalign( size_t align, size_t dim  ) {
                 return (T *)cmemalign( align, dim, sizeof(T) ); // CFA cmemalign
         } // cmemalign
@@ -121 +109 @@
 
 /*
-        FIX ME : fix alloc interface after Ticker Number 214 is resolved, define and add union to S_fill. Then, modify
-        postfix-fill functions to support T * with nmemb, char, and T object of any size. Finally, change alloc_internal.
+        FIX ME : fix alloc interface after Ticker Number 214 is resolved, define and add union to S_fill. Then, modify postfix-fill functions to support T * with nmemb, char, and T object of any size. Finally, change alloc_internal.
         Or, just follow the instructions below for that.
 
@@ -166 +153 @@
 */
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
-#pragma GCC diagnostic ignored "-Wuninitialized"
-
-struct T_align { size_t align; };
-struct T_resize { void * addr; };
-struct T_realloc { void * addr; };
-forall( T & ) struct T_fill {
-        // 'N' => no fill, 'c' => fill with character c, 'a' => fill first N array elements from another array,
-        // 'A' => fill all array elements from another array, 'T' => fill using a T value.
-        char tag;
-        size_t nelem;   // number of elements copied from "at" (used with tag 'a')
-//      union {
-                char c;
-                T * at;
-                char t[64]; // T t;
-//      };
-};
-
-#pragma GCC diagnostic pop
-
-static inline {
-        T_align ?`align( size_t a ) { return (T_align){ a }; }
-        T_resize ?`resize( void * a ) { return (T_resize){ a }; }
-        T_realloc ?`realloc( void * a ) { return (T_realloc){ a }; }
+typedef struct S_align { inline size_t;  } T_align;
+typedef struct S_resize { inline void *;  }     T_resize;
+
+forall( T & ) {
+        struct S_fill { char tag; char c; size_t size; T * at; char t[50]; };
+        struct S_realloc { inline T *; };
 }
 
+static inline T_align ?`align( size_t a ) { return (T_align){a}; }
+static inline T_resize ?`resize( void * a )     { return (T_resize){a}; }
+
+extern "C" ssize_t write(int fd, const void *buf, size_t count);
 static inline forall( T & | sized(T) ) {
-        T_fill(T) ?`fill( char c ) { return (T_fill(T)){ 'c', 0, c }; }
-        T_fill(T) ?`fill( T t ) {
-                T_fill(T) ret = { 'T' };
+        S_fill(T) ?`fill ( T t ) {
+                S_fill(T) ret = { 't' };
                 size_t size = sizeof(T);
                 if ( size > sizeof(ret.t) ) {
@@ -204 +175 @@
                 return ret;
         }
-        T_fill(T) ?`fill( T a[] ) { return (T_fill(T)){ 'A', 0, '\0', a }; } // FIX ME: remove this once ticket 214 is resolved
-        T_fill(T) ?`fill( T a[], size_t nelem ) { return (T_fill(T)){ 'a', nelem * sizeof(T), '\0', a }; }
-
-        // private interface
-        T * alloc_internal$( size_t Dim, T_resize Resize, T_realloc Realloc, size_t Align, T_fill(T) Fill ) {
-                T * ptr;
-                size_t tsize = sizeof(T);
+        S_fill(T) ?`fill ( zero_t ) = void; // FIX ME: remove this once ticket 214 is resolved
+        S_fill(T) ?`fill ( T * a ) { return (S_fill(T)){ 'T', '0', 0, a }; } // FIX ME: remove this once ticket 214 is resolved
+        S_fill(T) ?`fill ( char c ) { return (S_fill(T)){ 'c', c };     }
+        S_fill(T) ?`fill ( T a[], size_t nmemb ) { return (S_fill(T)){ 'a', '0', nmemb * sizeof(T), a }; }
+
+        S_realloc(T) ?`realloc ( T * a ) { return (S_realloc(T)){a}; }
+
+        T * alloc_internal$( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill ) {
+                T * ptr = NULL;
+                size_t size = sizeof(T);
                 size_t copy_end = 0;
 
-                if ( Resize.addr ) {
-                        ptr = (T *)(void *)resize( Resize.addr, Align, Dim * tsize );
-                } else if ( Realloc.addr ) {
-                        if ( Fill.tag != 'N' ) copy_end = min(malloc_size( Realloc.addr ), Dim * tsize );
-                        ptr = (T *)(void *)realloc( Realloc.addr, Align, Dim * tsize );
+                if ( Resize ) {
+                        ptr = (T*)(void *)resize( (void *)Resize, Align, Dim * size );
+                } else if ( Realloc ) {
+                        if ( Fill.tag != '0' ) copy_end = min(malloc_size( Realloc ), Dim * size );
+                        ptr = (T *)(void *)realloc( (void *)Realloc, Align, Dim * size );
                 } else {
-                        ptr = (T *)(void *)memalign( Align, Dim * tsize );
-                } // if
+                        ptr = (T *)(void *) memalign( Align, Dim * size );
+                }
 
                 if ( Fill.tag == 'c' ) {
-                        memset( (char *)ptr + copy_end, (int)Fill.c, Dim * tsize - copy_end );
+                        memset( (char *)ptr + copy_end, (int)Fill.c, Dim * size - copy_end );
+                } else if ( Fill.tag == 't' ) {
+                        for ( i; copy_end ~ Dim * size ~ size ) {
+                                #pragma GCC diagnostic push
+                                #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+                                assert( size <= sizeof(Fill.t) );
+                                memcpy( (char *)ptr + i, &Fill.t, size );
+                                #pragma GCC diagnostic pop
+                        }
+                } else if ( Fill.tag == 'a' ) {
+                        memcpy( (char *)ptr + copy_end, Fill.at, min(Dim * size - copy_end, Fill.size) );
                 } else if ( Fill.tag == 'T' ) {
-                        for ( i; copy_end ~ Dim * tsize ~ tsize ) {
-                                assert( tsize <= sizeof(Fill.t) );
-                                memcpy( (char *)ptr + i, &Fill.t, tsize );
-                        } // for
-                } else if ( Fill.tag == 'a' ) {
-                        memcpy( (char *)ptr + copy_end, Fill.at, min( Dim * tsize - copy_end, Fill.nelem ) );
-                } else if ( Fill.tag == 'A' ) {
-                        memcpy( (char *)ptr + copy_end, Fill.at, Dim * tsize );
-                } // if
+                        memcpy( (char *)ptr + copy_end, Fill.at, Dim * size );
+                }
+
                 return ptr;
         } // alloc_internal$
 
-        // Dim is a fixed (optional first) parameter, and hence is not set using a postfix function. A dummy parameter is
-        // being overwritten by the postfix argument in the ttype.
-        forall( List ... | { T * alloc_internal$( size_t Dim, T_resize Resize, T_realloc Realloc, size_t Align, T_fill(T) Fill, List ); } ) {
-                // middle interface
-                T * alloc_internal$( size_t Dim, T_resize dummy, T_realloc Realloc, size_t Align, T_fill(T) Fill, T_resize Resize, List rest ) {
-                return alloc_internal$( Dim, Resize, (T_realloc){0p}, Align, Fill, rest );
-                }
-                T * alloc_internal$( size_t Dim, T_resize Resize, T_realloc dummy, size_t Align, T_fill(T) Fill, T_realloc Realloc, List rest ) {
-                return alloc_internal$( Dim, (T_resize){0p}, Realloc, Align, Fill, rest );
-                }
-                T * alloc_internal$( size_t Dim, T_resize Resize, T_realloc Realloc, size_t dummy, T_fill(T) Fill, T_align Align, List rest ) {
-                return alloc_internal$( Dim, Resize, Realloc, Align.align, Fill, rest );
-                }
-                T * alloc_internal$( size_t Dim, T_resize Resize, T_realloc Realloc, size_t Align, T_fill(T) dummy, T_fill(T) Fill, List rest ) {
-                return alloc_internal$( Dim, Resize, Realloc, Align, Fill, rest );
-                }
-                // public interface
-            T * alloc( List rest ) {
-                return alloc_internal$( (size_t)1, (T_resize){0p}, (T_realloc){0p}, (_Alignof(T) > libAlign() ? _Alignof(T) : libAlign()), (T_fill(T)){'N'}, rest );
+        forall( TT ... | { T * alloc_internal$( void *, T *, size_t, size_t, S_fill(T), TT ); } ) {
+                T * alloc_internal$( void *, T *, size_t Align, size_t Dim, S_fill(T) Fill, T_resize Resize, TT rest ) {
+                return alloc_internal$( Resize, (T*)0p, Align, Dim, Fill, rest);
+                }
+
+                T * alloc_internal$( void *, T *, size_t Align, size_t Dim, S_fill(T) Fill, S_realloc(T) Realloc, TT rest ) {
+                return alloc_internal$( (void*)0p, Realloc, Align, Dim, Fill, rest);
+                }
+
+                T * alloc_internal$( void * Resize, T * Realloc, size_t, size_t Dim, S_fill(T) Fill, T_align Align, TT rest ) {
+                return alloc_internal$( Resize, Realloc, Align, Dim, Fill, rest);
+                }
+
+                T * alloc_internal$( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T), S_fill(T) Fill, TT rest ) {
+                return alloc_internal$( Resize, Realloc, Align, Dim, Fill, rest );
+                }
+
+            T * alloc( TT all ) {
+                return alloc_internal$( (void*)0p, (T*)0p, (_Alignof(T) > libAlign() ? _Alignof(T) : libAlign()), (size_t)1, (S_fill(T)){'0'}, all );
             }
-            T * alloc( size_t Dim, List rest ) {
-                return alloc_internal$( Dim, (T_resize){0p}, (T_realloc){0p}, (_Alignof(T) > libAlign() ? _Alignof(T) : libAlign()), (T_fill(T)){'N'}, rest );
+
+            T * alloc( size_t dim, TT all ) {
+                return alloc_internal$( (void*)0p, (T*)0p, (_Alignof(T) > libAlign() ? _Alignof(T) : libAlign()), dim, (S_fill(T)){'0'}, all );
             }
-        } // distribution List
+        } // distribution TT
 } // distribution T
 
 static inline forall( T & | sized(T) ) {
         // CFA safe initialization/copy, i.e., implicit size specification, non-array types
-        T * memset( T * dest, char fill ) {                                     // all combinations of pointer/reference
-                return (T *)memset( dest, fill, sizeof(T) );    // C memset
+        T * memset( T * dest, char fill ) {
+                return (T *)memset( dest, fill, sizeof(T) );
         } // memset
-        T * memset( T & dest, char fill ) {
-                return (T *)memset( &dest, fill, sizeof(T) );   // C memset
-        } // memset
-
-        T * memcpy( T * dest, const T * src ) {                         // all combinations of pointer/reference
-                return (T *)memcpy( dest, src, sizeof(T) );             // C memcpy
-        } // memcpy
-        T * memcpy( T & dest, const T & src ) {
-                return (T *)memcpy( &dest, &src, sizeof(T) );   // C memcpy
-        } // memcpy
-        T * memcpy( T * dest, const T & src ) {
-                return (T *)memcpy( dest, &src, sizeof(T) );    // C memcpy
-        } // memcpy
-        T * memcpy( T & dest, const T * src ) {
-                return (T *)memcpy( &dest, src, sizeof(T) );    // C memcpy
+
+        T * memcpy( T * dest, const T * src ) {
+                return (T *)memcpy( dest, src, sizeof(T) );
         } // memcpy
 
@@ -296 +263 @@
 
 // CFA deallocation for multiple objects
-static inline forall( T & )
+static inline forall( T & )                                                     // FIX ME, problems with 0p in list
 void free( T * ptr ) {
         free( (void *)ptr );                                                            // C free
 } // free
-static inline forall( T &, List ... | { void free( List ); } )
-void free( T * ptr, List rest ) {
+static inline forall( T &, TT ... | { void free( TT ); } )
+void free( T * ptr, TT rest ) {
         free( ptr );
         free( rest );
@@ -307 +274 @@
 
 // CFA allocation/deallocation and constructor/destructor, non-array types
-static inline forall( T & | sized(T), Parms ... | { void ?{}( T &, Parms ); } )
-T * new( Parms p ) {
+static inline forall( T & | sized(T), TT ... | { void ?{}( T &, TT ); } )
+T * new( TT p ) {
         return &(*(T *)malloc()){ p };                                          // run constructor
 } // new
@@ -320 +287 @@
         free( ptr );                                                                            // always call free
 } // delete
-static inline forall( T &, List ... | { void ^?{}( T & ); void delete( List ); } )
-void delete( T * ptr, List rest ) {
+static inline forall( T &, TT ... | { void ^?{}( T & ); void delete( TT ); } )
+void delete( T * ptr, TT rest ) {
         delete( ptr );
         delete( rest );
@@ -327 +294 @@
 
 // CFA allocation/deallocation and constructor/destructor, array types
-forall( T & | sized(T), Parms ... | { void ?{}( T &, Parms ); } ) T * anew( size_t dim, Parms p );
+forall( T & | sized(T), TT ... | { void ?{}( T &, TT ); } ) T * anew( size_t dim, TT p );
 forall( T & | sized(T) | { void ^?{}( T & ); } ) void adelete( T arr[] );
-forall( T & | sized(T) | { void ^?{}( T & ); }, List ... | { void adelete( List ); } ) void adelete( T arr[], List rest );
-
+forall( T & | sized(T) | { void ^?{}( T & ); }, TT ... | { void adelete( TT ); } ) void adelete( T arr[], TT rest );
 //---------------------------------------