Changes in libcfa/src/stdlib.hfa [d1b70d4:09ee131]

File:

• libcfa/src/stdlib.hfa (modified) (15 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 : Thu Jan 21 22:02:13 2021
-// Update Count     : 574
+// Last Modified On : Mon Jan 18 21:51:13 2021
+// Update Count     : 569
 //
 
@@ -48 +48 @@
         else return (T *)alignment( _Alignof(T), dim, sizeof(T) )
 
-static inline forall( T & | sized(T) ) {
+static inline forall( dtype T | sized(T) ) {
         // CFA safe equivalents, i.e., implicit size specification
 
@@ -108 +108 @@
 
         1. Replace the current forall-block that contains defintions of S_fill and S_realloc with following:
-                forall( T & | sized(T) ) {
+                forall( dtype T | sized(T) ) {
                         union  U_fill           { char c; T * a; T t; };
                         struct S_fill           { char tag; U_fill(T) fill; };
@@ -151 +151 @@
 typedef struct S_resize                 { inline void *;  }     T_resize;
 
-forall( T & ) {
+forall( dtype T ) {
         struct S_fill           { char tag; char c; size_t size; T * at; char t[50]; };
         struct S_realloc        { inline T *; };
@@ -159 +159 @@
 static inline T_resize  ?`resize  ( void * a )  { return (T_resize){a}; }
 
-static inline forall( T & | sized(T) ) {
+static inline forall( dtype T | sized(T) ) {
         S_fill(T) ?`fill ( T t ) {
                 S_fill(T) ret = { 't' };
@@ -195 +195 @@
                                 #pragma GCC diagnostic push
                                 #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
-                                assert( size <= sizeof(Fill.t) );
-                                memcpy( (char *)ptr + i, &Fill.t, size );
+                                memcpy( (char *)ptr + i, &Fill.t, sizeof(Fill.t) );
                                 #pragma GCC diagnostic pop
                         }
@@ -208 +207 @@
         } // $alloc_internal
 
-        forall( TT... | { T * $alloc_internal( void *, T *, size_t, size_t, S_fill(T), TT ); } ) {
+        forall( ttype TT | { T * $alloc_internal( void *, T *, size_t, size_t, S_fill(T), TT ); } ) {
 
                 T * $alloc_internal( void *       , T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill, T_resize Resize, TT rest) {
@@ -237 +236 @@
 } // distribution T
 
-static inline forall( T & | sized(T) ) {
+static inline forall( dtype T | sized(T) ) {
         // CFA safe initialization/copy, i.e., implicit size specification, non-array types
         T * memset( T * dest, char fill ) {
@@ -258 +257 @@
 
 // CFA deallocation for multiple objects
-static inline forall( T & )                                                     // FIX ME, problems with 0p in list
+static inline forall( dtype T )                                                 // FIX ME, problems with 0p in list
 void free( T * ptr ) {
         free( (void *)ptr );                                                            // C free
 } // free
-static inline forall( T &, TT... | { void free( TT ); } )
+static inline forall( dtype T, ttype TT | { void free( TT ); } )
 void free( T * ptr, TT rest ) {
         free( ptr );
@@ -269 +268 @@
 
 // CFA allocation/deallocation and constructor/destructor, non-array types
-static inline forall( T & | sized(T), TT... | { void ?{}( T &, TT ); } )
+static inline forall( dtype T | sized(T), ttype TT | { void ?{}( T &, TT ); } )
 T * new( TT p ) {
         return &(*(T *)malloc()){ p };                                          // run constructor
 } // new
 
-static inline forall( T & | { void ^?{}( T & ); } )
+static inline forall( dtype T | { void ^?{}( T & ); } )
 void delete( T * ptr ) {
         // special case for 0-sized object => always call destructor
@@ -282 +281 @@
         free( ptr );                                                                            // always call free
 } // delete
-static inline forall( T &, TT... | { void ^?{}( T & ); void delete( TT ); } )
+static inline forall( dtype T, ttype TT | { void ^?{}( T & ); void delete( TT ); } )
 void delete( T * ptr, TT rest ) {
         delete( ptr );
@@ -289 +288 @@
 
 // CFA allocation/deallocation and constructor/destructor, array types
-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 & ); }, TT... | { void adelete( TT ); } ) void adelete( T arr[], TT rest );
+forall( dtype T | sized(T), ttype TT | { void ?{}( T &, TT ); } ) T * anew( size_t dim, TT p );
+forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void adelete( T arr[] );
+forall( dtype T | sized(T) | { void ^?{}( T & ); }, ttype TT | { void adelete( TT ); } ) void adelete( T arr[], TT rest );
 
 //---------------------------------------
@@ -331 +330 @@
 //---------------------------------------
 
-forall( E | { int ?<?( E, E ); } ) {
+forall( otype E | { int ?<?( E, E ); } ) {
         E * bsearch( E key, const E * vals, size_t dim );
         size_t bsearch( E key, const E * vals, size_t dim );
@@ -340 +339 @@
 } // distribution
 
-forall( K, E | { int ?<?( K, K ); K getKey( const E & ); } ) {
+forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } ) {
         E * bsearch( K key, const E * vals, size_t dim );
         size_t bsearch( K key, const E * vals, size_t dim );
@@ -349 +348 @@
 } // distribution
 
-forall( E | { int ?<?( E, E ); } ) {
+forall( otype E | { int ?<?( E, E ); } ) {
         void qsort( E * vals, size_t dim );
 } // distribution