Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/libcfa/stdlib.c

    r6065b3aa rf3ddc21  
    1010// Created On       : Thu Jan 28 17:10:29 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Jun  1 21:52:57 2017
    13 // Update Count     : 280
     12// Last Modified On : Tue May  9 08:43:00 2017
     13// Update Count     : 191
    1414//
    1515
    … …  
    2121#define _XOPEN_SOURCE 600                                                               // posix_memalign, *rand48
    2222#include <stdlib.h>                                                                             // malloc, free, calloc, realloc, memalign, posix_memalign, bsearch
    23 #include <string.h>                                                                             // memcpy, memset
     23#include <string.h>                                                                             // memset
    2424#include <malloc.h>                                                                             // malloc_usable_size
    2525#include <math.h>                                                                               // fabsf, fabs, fabsl
    … …  
    2727} // extern "C"
    2828
    29 // resize, non-array types
    30 forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill ) {
    31         size_t olen = malloc_usable_size( ptr );                        // current allocation
    32     char * nptr = (void *)realloc( (void *)ptr, dim * (size_t)sizeof(T) ); // C realloc
    33         size_t nlen = malloc_usable_size( nptr );                       // new allocation
    34         if ( nlen > olen ) {                                                            // larger ?
    35                 memset( nptr + olen, (int)fill, nlen - olen );  // initialize added storage
    36         } //
    37     return (T *)nptr;
    38 } // alloc
    39 
    40 // allocation/deallocation and constructor/destructor, non-array types
    41 forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } )
     29forall( dtype T | sized(T) ) T * malloc( void ) {               // type-safe
     30    return (T *)(void *)malloc( (size_t)sizeof(T) );
     31} // malloc
     32
     33forall( dtype T | sized(T) ) T * malloc( char fill ) {  // initial with fill value (like calloc)
     34        T * ptr = (T *)(void *)malloc( (size_t)sizeof(T) );
     35    return memset( ptr, (int)fill, sizeof(T) );
     36} // malloc
     37
     38forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size ) { // alternative realloc
     39    return (T *)realloc( ptr, size );
     40} // malloc
     41
     42forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size, unsigned char fill ) { // alternative realloc with fill value
     43    return (T *)realloc( ptr, size, fill );
     44} // malloc
     45
     46
     47forall( dtype T | sized(T) ) T * calloc( size_t nmemb ) { // type-safe array initialization with fill 0
     48    return (T *)calloc( nmemb, sizeof(T) );
     49} // calloc
     50
     51
     52forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size ) { // type-safe
     53    return (T *)(void *)realloc( (void *)ptr, size );
     54} // realloc
     55
     56forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, unsigned char fill ) { // alternative realloc with fill value
     57    char * nptr = (T *)(void *)realloc( (void *)ptr, size );
     58    size_t unused = malloc_usable_size( nptr );
     59    memset( nptr + size - unused, (int)fill, unused );  // initialize any new storage
     60    return nptr;
     61} // realloc
     62
     63
     64forall( dtype T | sized(T) ) T * aligned_alloc( size_t alignment ) { // aligned allocation
     65    return (T *)memalign( alignment, sizeof(T) );
     66} // aligned_alloc
     67
     68forall( dtype T | sized(T) ) T * memalign( size_t alignment ) {
     69    return (T *)memalign( alignment, sizeof(T) );
     70} // memalign
     71
     72forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t alignment ) {
     73    return posix_memalign( (void **)ptr, alignment, sizeof(T) );
     74} // posix_memalign
     75
     76
     77forall( dtype T, ttype Params | sized(T) | { void ?{}( T *, Params ); } ) //  new
    4278T * new( Params p ) {
    43         return (malloc()){ p };                                                         // run constructor
     79        return ((T *)malloc()){ p };
    4480} // new
    4581
    46 forall( dtype T | { void ^?{}( T * ); } )
     82forall( dtype T | { void ^?{}(T *); } )                                 // delete
    4783void delete( T * ptr ) {
    48         if ( ptr ) {                                                                            // ignore null
    49                 ^ptr{};                                                                                 // run destructor
     84        if ( ptr ) {
     85                ^ptr{};
    5086                free( ptr );
    51         } // if
     87        }
    5288} // delete
    5389
    54 forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } )
     90forall( dtype T, ttype Params | { void ^?{}(T *); void delete(Params); } )
    5591void delete( T * ptr, Params rest ) {
    56         if ( ptr ) {                                                                            // ignore null
    57                 ^ptr{};                                                                                 // run destructor
     92        if ( ptr ) {
     93                ^ptr{};
    5894                free( ptr );
    59         } // if
     95        }
    6096        delete( rest );
    6197} // delete
    62 
    63 
    64 // allocation/deallocation and constructor/destructor, array types
    65 forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } )
    66 T * anew( size_t dim, Params p ) {
    67         T *arr = alloc( dim );
    68         for ( unsigned int i = 0; i < dim; i += 1 ) {
    69                 (&arr[i]){ p };                                                                 // run constructor
    70         } // for
    71         return arr;
    72 } // anew
    73 
    74 forall( dtype T | sized(T) | { void ^?{}( T * ); } )
    75 void adelete( size_t dim, T arr[] ) {
    76         if ( arr ) {                                                                            // ignore null
    77                 for ( int i = dim - 1; i >= 0; i -= 1 ) {               // reverse allocation order, must be unsigned
    78                         ^(&arr[i]){};                                                           // run destructor
    79                 } // for
    80                 free( arr );
    81         } // if
    82 } // adelete
    83 
    84 forall( dtype T | sized(T) | { void ^?{}( T * ); }, ttype Params | { void adelete( Params ); } )
    85 void adelete( size_t dim, T arr[], Params rest ) {
    86         if ( arr ) {                                                                            // ignore null
    87                 for ( int i = dim - 1; i >= 0; i -= 1 ) {               // reverse allocation order, must be unsigned
    88                         ^(&arr[i]){};                                                           // run destructor
    89                 } // for
    90                 free( arr );
    91         } // if
    92         adelete( rest );
    93 } // adelete
    9498
    9599//---------------------------------------
    … …  
    238242
    239243forall( otype T | { int ?<?( T, T ); } )
    240 T * bsearch( T key, const T * arr, size_t dim ) {
     244T * bsearch( T key, const T * arr, size_t dimension ) {
    241245        int comp( const void * t1, const void * t2 ) { return *(T *)t1 < *(T *)t2 ? -1 : *(T *)t2 < *(T *)t1 ? 1 : 0; }
    242         return (T *)bsearch( &key, arr, dim, sizeof(T), comp );
     246        return (T *)bsearch( &key, arr, dimension, sizeof(T), comp );
    243247} // bsearch
    244248
    245249forall( otype T | { int ?<?( T, T ); } )
    246 unsigned int bsearch( T key, const T * arr, size_t dim ) {
    247         T *result = bsearch( key, arr, dim );
    248         return result ? result - arr : dim;                                     // pointer subtraction includes sizeof(T)
     250unsigned int bsearch( T key, const T * arr, size_t dimension ) {
     251        T *result = bsearch( key, arr, dimension );
     252        return result ? result - arr : dimension;                       // pointer subtraction includes sizeof(T)
    249253} // bsearch
    250254
    251255forall( otype T | { int ?<?( T, T ); } )
    252 void qsort( const T * arr, size_t dim ) {
     256void qsort( const T * arr, size_t dimension ) {
    253257        int comp( const void * t1, const void * t2 ) { return *(T *)t1 < *(T *)t2 ? -1 : *(T *)t2 < *(T *)t1 ? 1 : 0; }
    254         qsort( arr, dim, sizeof(T), comp );
     258        qsort( arr, dimension, sizeof(T), comp );
    255259} // qsort
    256260
    … …  
    275279
    276280void rand48seed( long int s ) { srand48( s ); }
    277 char rand48( void ) { return mrand48(); }
    278 int rand48( void ) { return mrand48(); }
    279 unsigned int rand48( void ) { return lrand48(); }
    280 long int rand48( void ) { return mrand48(); }
    281 unsigned long int rand48( void ) { return lrand48(); }
    282 float rand48( void ) { return (float)drand48(); }               // otherwise float uses lrand48
    283 double rand48( void ) { return drand48(); }
    284 float _Complex rand48( void ) { return (float)drand48() + (float _Complex)(drand48() * _Complex_I); }
    285 double _Complex rand48( void ) { return drand48() + (double _Complex)(drand48() * _Complex_I); }
    286 long double _Complex rand48( void) { return (long double)drand48() + (long double _Complex)(drand48() * _Complex_I); }
     281char rand48() { return mrand48(); }
     282int rand48() { return mrand48(); }
     283unsigned int rand48() { return lrand48(); }
     284long int rand48() { return mrand48(); }
     285unsigned long int rand48() { return lrand48(); }
     286float rand48() { return (float)drand48(); }                             // otherwise float uses lrand48
     287double rand48() { return drand48(); }
     288float _Complex rand48() { return (float)drand48() + (float _Complex)(drand48() * _Complex_I); }
     289double _Complex rand48() { return drand48() + (double _Complex)(drand48() * _Complex_I); }
     290long double _Complex rand48() { return (long double)drand48() + (long double _Complex)(drand48() * _Complex_I); }
    287291
    288292//---------------------------------------
Note: See TracChangeset for help on using the changeset viewer.