Changes in libcfa/src/stdlib.hfa [aabb846:d8d8f20]

File:

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

libcfa/src/stdlib.hfa

@@ -9 +9 @@
 // Author           : Peter A. Buhr
 // Created On       : Thu Jan 28 17:12:35 2016
-// Last Modified By : Andrew Beach
-// Last Modified On : Tue Jun  2 16:47:00 2020
-// Update Count     : 451
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue Jul 21 07:58:05 2020
+// Update Count     : 475
 //
 
@@ -39 +39 @@
 //---------------------------------------
 
+// Macro because of returns
+#define $VAR_ALLOC( allocation, alignment ) \
+        if ( _Alignof(T) <= libAlign() ) return (T *)(void *)allocation( (size_t)sizeof(T) ); /* C allocation */ \
+        else return (T *)alignment( _Alignof(T), sizeof(T) )
+
+#define $ARRAY_ALLOC( allocation, alignment, dim ) \
+        if ( _Alignof(T) <= libAlign() ) return (T *)(void *)allocation( dim, (size_t)sizeof(T) ); /* C allocation */ \
+        else return (T *)alignment( _Alignof(T), dim, sizeof(T) )
+
+#define $RE_SPECIALS( ptr, size, allocation, alignment ) \
+        if ( unlikely( size == 0 ) || unlikely( ptr == 0p ) ) { \
+                if ( unlikely( size == 0 ) ) free( ptr ); \
+                $VAR_ALLOC( malloc, memalign ); \
+        } /* if */
+
 static inline forall( dtype T | sized(T) ) {
         // Cforall safe equivalents, i.e., implicit size specification
 
         T * malloc( void ) {
-                if ( _Alignof(T) <= libAlign() ) return (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
-                else return (T *)memalign( _Alignof(T), sizeof(T) );
+                $VAR_ALLOC( malloc, memalign );
         } // malloc
 
         T * aalloc( size_t dim ) {
-                if ( _Alignof(T) <= libAlign() ) return (T *)(void *)aalloc( dim, (size_t)sizeof(T) ); // CFA aalloc
-                else return (T *)amemalign( _Alignof(T), dim, sizeof(T) );
+                $ARRAY_ALLOC( aalloc, amemalign, dim );
         } // aalloc
 
         T * calloc( size_t dim ) {
-                if ( _Alignof(T) <= libAlign() )return (T *)(void *)calloc( dim, sizeof(T) ); // C calloc
-                else return (T *)cmemalign( _Alignof(T), dim, sizeof(T) );
+                $ARRAY_ALLOC( calloc, cmemalign, dim );
         } // calloc
 
-        T * resize( T * ptr, size_t size ) {                            // CFA realloc, eliminate return-type cast
-                return (T *)(void *)resize( (void *)ptr, size ); // C realloc
+        T * resize( T * ptr, size_t size ) {                            // CFA resize, eliminate return-type cast
+                $RE_SPECIALS( ptr, size, malloc, memalign );
+                return (T *)(void *)resize( (void *)ptr, size ); // CFA resize
         } // resize
 
         T * realloc( T * ptr, size_t size ) {                           // CFA realloc, eliminate return-type cast
+                $RE_SPECIALS( ptr, size, malloc, memalign );
                 return (T *)(void *)realloc( (void *)ptr, size ); // C realloc
         } // realloc
@@ -118 +132 @@
 
         T * alloc( T ptr[], size_t dim, bool copy = true ) {
-                if ( copy ) {                                                                   // realloc
-                        return (T *)(void *)realloc( (void *)ptr, dim * sizeof(T) ); // C realloc
+                if ( copy ) {
+                        return realloc( ptr, dim * sizeof(T) );         // CFA realloc
                 } else {
-                        return resize( ptr, dim * sizeof(T) );          // resize
+                        return resize( ptr, dim * sizeof(T) );          // CFA resize
                 } // if
         } // alloc
@@ -146 +160 @@
                 return (T *)memcpy( (T *)alloc( dim ), fill, dim * sizeof(T) ); // initialize with fill value
         } // alloc
-} // distribution
-
-forall( dtype T | sized(T) ) {
-        T * alloc_set( T ptr[], size_t dim, char fill );        // realloc array with fill
-        T * alloc_set( T ptr[], size_t dim, T fill );           // realloc array with fill
+
+        T * alloc_set( T ptr[], size_t dim, char fill ) {       // realloc array with fill
+                size_t osize = malloc_size( ptr );                              // current allocation
+                size_t nsize = dim * sizeof(T);                                 // new allocation
+                T * nptr = realloc( ptr, nsize );                               // CFA realloc
+                if ( nsize > osize ) {                                                  // larger ?
+                        memset( (char *)nptr + osize, (int)fill, nsize - osize ); // initialize added storage
+                } // if
+                return (T *)nptr;
+        } // alloc_set
+
+        T * alloc_set( T ptr[], size_t dim, T & fill ) {        // realloc array with fill
+                size_t odim = malloc_size( ptr ) / sizeof(T);   // current dimension
+                size_t nsize = dim * sizeof(T);                                 // new allocation
+                size_t ndim = nsize / sizeof(T);                                // new dimension
+                T * nptr = realloc( ptr, nsize );                               // CFA realloc
+                if ( ndim > odim ) {                                                    // larger ?
+                        for ( i; odim ~ ndim ) {
+                                memcpy( &nptr[i], &fill, sizeof(T) );   // initialize with fill value
+                        } // for
+                } // if
+                return (T *)nptr;
+        } // alloc_align_set
 } // distribution
 
@@ -196 +228 @@
                 return (T *)memcpy( (T *)alloc_align( align, dim ), fill, dim * sizeof(T) );
         } // alloc_align
-} // distribution
-
-forall( dtype T | sized(T) ) {
-        T * alloc_align_set( T ptr[], size_t align, char fill ); // aligned realloc with fill
-        T * alloc_align_set( T ptr[], size_t align, T fill ); // aligned realloc with fill
-        T * alloc_align_set( T ptr[], size_t align, size_t dim, char fill ); // aligned realloc array with fill
-        T * alloc_align_set( T ptr[], size_t align, size_t dim, T fill ); // aligned realloc array with fill
+
+        T * alloc_align_set( T ptr[], size_t align, size_t dim, char fill ) {
+                size_t osize = malloc_size( ptr );                              // current allocation
+                size_t nsize = dim * sizeof(T);                                 // new allocation
+                T * nptr = realloc( ptr, align, nsize );                // CFA realloc
+                if ( nsize > osize ) {                                                  // larger ?
+                        memset( (char *)nptr + osize, (int)fill, nsize - osize ); // initialize added storage
+                } // if
+                return (T *)nptr;
+        } // alloc_align_set
+
+        T * alloc_align_set( T ptr[], size_t align, size_t dim, T & fill ) {
+                size_t odim = malloc_size( ptr ) / sizeof(T);   // current dimension
+                size_t nsize = dim * sizeof(T);                                 // new allocation
+                size_t ndim = nsize / sizeof(T);                                // new dimension
+                T * nptr = realloc( ptr, align, nsize );                // CFA realloc
+                if ( ndim > odim ) {                                                    // larger ?
+                        for ( i; odim ~ ndim ) {
+                                memcpy( &nptr[i], &fill, sizeof(T) );   // initialize with fill value
+                        } // for
+                } // if
+                return (T *)nptr;
+        } // alloc_align_set
 } // distribution