Changes in src/libcfa/stdlib.c [f3fc631f:8dc51c8]

File:

• src/libcfa/stdlib.c (modified) (4 diffs)

src/libcfa/stdlib.c

@@ -10 +10 @@
 // Created On       : Thu Jan 28 17:10:29 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue May 30 09:07:56 2017
-// Update Count     : 237
+// Last Modified On : Wed May 24 18:13:15 2017
+// Update Count     : 198
 //
 
@@ -21 +21 @@
 #define _XOPEN_SOURCE 600                                                               // posix_memalign, *rand48
 #include <stdlib.h>                                                                             // malloc, free, calloc, realloc, memalign, posix_memalign, bsearch
-#include <string.h>                                                                             // memcpy, memset
+#include <string.h>                                                                             // memset
 #include <malloc.h>                                                                             // malloc_usable_size
 #include <math.h>                                                                               // fabsf, fabs, fabsl
@@ -27 +27 @@
 } // extern "C"
 
-// resize, non-array types
-forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, char fill ) { // alternative realloc with fill value
-        //printf( "X6\n" );
-        size_t olen = malloc_usable_size( ptr );                        // current allocation
-    char * nptr = (void *)realloc( (void *)ptr, size ); // C realloc
-        size_t nlen = malloc_usable_size( nptr );                       // new allocation
-        if ( nlen > olen ) {                                                            // larger ?
-                memset( nptr + olen, (int)fill, nlen - olen );  // initialize added storage
-        } // 
-    return (T *)nptr;
+forall( dtype T | sized(T) ) T * malloc( void ) {               // type-safe
+    return (T *)(void *)malloc( (size_t)sizeof(T) );
+} // malloc
+
+forall( dtype T | sized(T) ) T * malloc( char fill ) {  // initial with fill value (like calloc)
+        T * ptr = (T *)(void *)malloc( (size_t)sizeof(T) );
+    return memset( ptr, (int)fill, sizeof(T) );
+} // malloc
+
+forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size ) { // alternative realloc
+    return (T *)realloc( ptr, size );
+} // malloc
+
+forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size, unsigned char fill ) { // alternative realloc with fill value
+    return (T *)realloc( ptr, size, fill );
+} // malloc
+
+
+forall( dtype T | sized(T) ) T * calloc( size_t nmemb ) { // type-safe array initialization with fill 0
+    return (T *)calloc( nmemb, sizeof(T) );
+} // calloc
+
+
+forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size ) { // type-safe
+    return (T *)(void *)realloc( (void *)ptr, size );
 } // realloc
 
-// allocation/deallocation and constructor/destructor
-forall( dtype T, ttype Params | sized(T) | { void ?{}( T *, Params ); } )
+forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, unsigned char fill ) { // alternative realloc with fill value
+    char * nptr = (T *)(void *)realloc( (void *)ptr, size );
+    size_t unused = malloc_usable_size( nptr );
+    memset( nptr + size - unused, (int)fill, unused );  // initialize any new storage
+    return nptr;
+} // realloc
+
+
+forall( dtype T | sized(T) ) T * aligned_alloc( size_t alignment ) { // aligned allocation
+    return (T *)memalign( alignment, sizeof(T) );
+} // aligned_alloc
+
+forall( dtype T | sized(T) ) T * memalign( size_t alignment ) {
+    return (T *)memalign( alignment, sizeof(T) );
+} // memalign
+
+forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t alignment ) {
+    return posix_memalign( (void **)ptr, alignment, sizeof(T) );
+} // posix_memalign
+
+
+forall( dtype T, ttype Params | sized(T) | { void ?{}( T *, Params ); } ) //  new
 T * new( Params p ) {
         return ((T *)malloc()){ p };
 } // new
 
-forall( dtype T | { void ^?{}( T * ); } )
+forall( dtype T | { void ^?{}(T *); } )                                 // delete
 void delete( T * ptr ) {
         if ( ptr ) {
-                ^ptr{};                                                                                 // run destructor
+                ^ptr{};
                 free( ptr );
-        } // if
+        }
 } // delete
 
-forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } )
+forall( dtype T, ttype Params | { void ^?{}(T *); void delete(Params); } )
 void delete( T * ptr, Params rest ) {
         if ( ptr ) {
-                ^ptr{};                                                                                 // run destructor
+                ^ptr{};
                 free( ptr );
-        } // if
+        }
         delete( rest );
 } // delete
@@ -207 +242 @@
 
 forall( otype T | { int ?<?( T, T ); } )
-T * bsearch( T key, const T * arr, size_t dim ) {
+T * bsearch( T key, const T * arr, size_t dimension ) {
         int comp( const void * t1, const void * t2 ) { return *(T *)t1 < *(T *)t2 ? -1 : *(T *)t2 < *(T *)t1 ? 1 : 0; }
-        return (T *)bsearch( &key, arr, dim, sizeof(T), comp );
+        return (T *)bsearch( &key, arr, dimension, sizeof(T), comp );
 } // bsearch
 
 forall( otype T | { int ?<?( T, T ); } )
-unsigned int bsearch( T key, const T * arr, size_t dim ) {
-        T *result = bsearch( key, arr, dim );
-        return result ? result - arr : dim;                                     // pointer subtraction includes sizeof(T)
+unsigned int bsearch( T key, const T * arr, size_t dimension ) {
+        T *result = bsearch( key, arr, dimension );
+        return result ? result - arr : dimension;                       // pointer subtraction includes sizeof(T)
 } // bsearch
 
 forall( otype T | { int ?<?( T, T ); } )
-void qsort( const T * arr, size_t dim ) {
+void qsort( const T * arr, size_t dimension ) {
         int comp( const void * t1, const void * t2 ) { return *(T *)t1 < *(T *)t2 ? -1 : *(T *)t2 < *(T *)t1 ? 1 : 0; }
-        qsort( arr, dim, sizeof(T), comp );
+        qsort( arr, dimension, sizeof(T), comp );
 } // qsort