Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/libcfa/stdlib.c

    rf3ddc21 r02d241f  
    1010// Created On       : Thu Jan 28 17:10:29 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue May  9 08:43:00 2017
    13 // Update Count     : 191
     12// Last Modified On : Sun Apr 16 10:41:05 2017
     13// Update Count     : 189
    1414//
    1515
    … …  
    2727} // extern "C"
    2828
    29 forall( dtype T | sized(T) ) T * malloc( void ) {               // type-safe
    30     return (T *)(void *)malloc( (size_t)sizeof(T) );
    31 } // malloc
    32 
    33 forall( dtype T | sized(T) ) T * malloc( char fill ) {  // initial with fill value (like calloc)
    34         T * ptr = (T *)(void *)malloc( (size_t)sizeof(T) );
     29forall( dtype T | sized(T) ) T * malloc( void ) {
     30        //printf( "malloc1\n" );
     31    return (T *)(void*)malloc( (size_t)sizeof(T) );
     32} // malloc
     33forall( dtype T | sized(T) ) T * malloc( char fill ) {
     34        //printf( "malloc3\n" );
     35        T * ptr = (T *)(void*)malloc( (size_t)sizeof(T) );
    3536    return memset( ptr, (int)fill, sizeof(T) );
    3637} // malloc
    3738
    38 forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size ) { // alternative realloc
    39     return (T *)realloc( ptr, size );
    40 } // malloc
    41 
    42 forall( 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 
    47 forall( dtype T | sized(T) ) T * calloc( size_t nmemb ) { // type-safe array initialization with fill 0
     39forall( dtype T | sized(T) ) T * calloc( size_t nmemb ) {
     40        //printf( "calloc\n" );
    4841    return (T *)calloc( nmemb, sizeof(T) );
    4942} // calloc
    5043
    51 
    52 forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size ) { // type-safe
     44forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size ) {
     45        //printf( "realloc1\n" );
    5346    return (T *)(void *)realloc( (void *)ptr, size );
    5447} // realloc
    55 
    56 forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, unsigned char fill ) { // alternative realloc with fill value
     48forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, unsigned char fill ) {
     49        //printf( "realloc2\n" );
    5750    char * nptr = (T *)(void *)realloc( (void *)ptr, size );
    5851    size_t unused = malloc_usable_size( nptr );
    … …  
    6154} // realloc
    6255
    63 
    64 forall( dtype T | sized(T) ) T * aligned_alloc( size_t alignment ) { // aligned allocation
     56forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size ) {
     57        //printf( "malloc4\n" );
     58    return (T *)realloc( ptr, size );
     59} // malloc
     60forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size, unsigned char fill ) {
     61        //printf( "malloc5\n" );
     62    return (T *)realloc( ptr, size, fill );
     63} // malloc
     64
     65forall( dtype T | sized(T) ) T * aligned_alloc( size_t alignment ) {
     66        //printf( "aligned_alloc\n" );
    6567    return (T *)memalign( alignment, sizeof(T) );
    6668} // aligned_alloc
    6769
    6870forall( dtype T | sized(T) ) T * memalign( size_t alignment ) {
     71        //printf( "memalign\n" );
    6972    return (T *)memalign( alignment, sizeof(T) );
    7073} // memalign
    7174
    7275forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t alignment ) {
     76        //printf( "posix_memalign\n" );
    7377    return posix_memalign( (void **)ptr, alignment, sizeof(T) );
    7478} // posix_memalign
    7579
    76 
    77 forall( dtype T, ttype Params | sized(T) | { void ?{}( T *, Params ); } ) //  new
     80forall( dtype T, ttype Params | sized(T) | { void ?{}( T *, Params ); } )
    7881T * new( Params p ) {
    7982        return ((T *)malloc()){ p };
    80 } // new
    81 
    82 forall( dtype T | { void ^?{}(T *); } )                                 // delete
     83}
     84
     85forall( dtype T | { void ^?{}(T *); } )
    8386void delete( T * ptr ) {
    84         if ( ptr ) {
    85                 ^ptr{};
    86                 free( ptr );
    87         }
    88 } // delete
     87  if ( ptr ) {
     88    ^ptr{};
     89    free( ptr );
     90  }
     91}
    8992
    9093forall( dtype T, ttype Params | { void ^?{}(T *); void delete(Params); } )
    … …  
    9598        }
    9699        delete( rest );
    97 } // delete
     100}
    98101
    99102//---------------------------------------
    … …  
    103106        if ( sscanf( ptr, "%d", &i ) == EOF ) {}
    104107        return i;
    105 } // ato
    106 
     108}
    107109unsigned int ato( const char * ptr ) {
    108110        unsigned int ui;
    109111        if ( sscanf( ptr, "%u", &ui ) == EOF ) {}
    110112        return ui;
    111 } // ato
    112 
     113}
    113114long int ato( const char * ptr ) {
    114115        long int li;
    115116        if ( sscanf( ptr, "%ld", &li ) == EOF ) {}
    116117        return li;
    117 } // ato
    118 
     118}
    119119unsigned long int ato( const char * ptr ) {
    120120        unsigned long int uli;
    121121        if ( sscanf( ptr, "%lu", &uli ) == EOF ) {}
    122122        return uli;
    123 } // ato
    124 
     123}
    125124long long int ato( const char * ptr ) {
    126125        long long int lli;
    127126        if ( sscanf( ptr, "%lld", &lli ) == EOF ) {}
    128127        return lli;
    129 } // ato
    130 
     128}
    131129unsigned long long int ato( const char * ptr ) {
    132130        unsigned long long int ulli;
    133131        if ( sscanf( ptr, "%llu", &ulli ) == EOF ) {}
    134132        return ulli;
    135 } // ato
    136 
     133}
    137134
    138135float ato( const char * ptr ) {
    … …  
    140137        if ( sscanf( ptr, "%f", &f ) == EOF ) {}
    141138        return f;
    142 } // ato
    143 
     139}
    144140double ato( const char * ptr ) {
    145141        double d;
    146142        if ( sscanf( ptr, "%lf", &d ) == EOF ) {}
    147143        return d;
    148 } // ato
    149 
     144}
    150145long double ato( const char * ptr ) {
    151146        long double ld;
    152147        if ( sscanf( ptr, "%Lf", &ld ) == EOF ) {}
    153148        return ld;
    154 } // ato
    155 
     149}
    156150
    157151float _Complex ato( const char * ptr ) {
    … …  
    159153        if ( sscanf( ptr, "%g%gi", &re, &im ) == EOF ) {}
    160154        return re + im * _Complex_I;
    161 } // ato
    162 
     155}
    163156double _Complex ato( const char * ptr ) {
    164157        double re, im;
    165158        if ( sscanf( ptr, "%lf%lfi", &re, &im ) == EOF ) {}
    166159        return re + im * _Complex_I;
    167 } // ato
    168 
     160}
    169161long double _Complex ato( const char * ptr ) {
    170162        long double re, im;
    171163        if ( sscanf( ptr, "%Lf%Lfi", &re, &im ) == EOF ) {}
    172164        return re + im * _Complex_I;
    173 } // ato
    174 
     165}
    175166
    176167int strto( const char * sptr, char ** eptr, int base ) {
    177168        return (int)strtol( sptr, eptr, base );
    178 } // strto
    179 
     169}
    180170unsigned int strto( const char * sptr, char ** eptr, int base ) {
    181171        return (unsigned int)strtoul( sptr, eptr, base );
    182 } // strto
    183 
     172}
    184173long int strto( const char * sptr, char ** eptr, int base ) {
    185174        return strtol( sptr, eptr, base );
    186 } // strto
    187 
     175}
    188176unsigned long int strto( const char * sptr, char ** eptr, int base ) {
    189177        return strtoul( sptr, eptr, base );
    190 } // strto
    191 
     178}
    192179long long int strto( const char * sptr, char ** eptr, int base ) {
    193180        return strtoll( sptr, eptr, base );
    194 } // strto
    195 
     181}
    196182unsigned long long int strto( const char * sptr, char ** eptr, int base ) {
    197183        return strtoull( sptr, eptr, base );
    198 } // strto
    199 
     184}
    200185
    201186float strto( const char * sptr, char ** eptr ) {
    202187        return strtof( sptr, eptr );
    203 } // strto
    204 
     188}
    205189double strto( const char * sptr, char ** eptr ) {
    206190        return strtod( sptr, eptr );
    207 } // strto
    208 
     191}
    209192long double strto( const char * sptr, char ** eptr ) {
    210193        return strtold( sptr, eptr );
    211 } // strto
    212 
     194}
    213195
    214196float _Complex strto( const char * sptr, char ** eptr ) {
    … …  
    219201        if ( sptr == *eptr ) return 0.0;
    220202        return re + im * _Complex_I;
    221 } // strto
    222 
     203}
    223204double _Complex strto( const char * sptr, char ** eptr ) {
    224205        double re, im;
    … …  
    228209        if ( sptr == *eptr ) return 0.0;
    229210        return re + im * _Complex_I;
    230 } // strto
    231 
     211}
    232212long double _Complex strto( const char * sptr, char ** eptr ) {
    233213        long double re, im;
    … …  
    237217        if ( sptr == *eptr ) return 0.0;
    238218        return re + im * _Complex_I;
    239 } // strto
     219}
    240220
    241221//---------------------------------------
Note: See TracChangeset for help on using the changeset viewer.