Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/libcfa/stdlib.c

    r8bc4ef8 r3cfe27f  
    1010// Created On       : Thu Jan 28 17:10:29 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Apr 28 07:54:21 2016
    13 // Update Count     : 166
     12// Last Modified On : Wed Mar 23 13:26:42 2016
     13// Update Count     : 146
    1414//
    1515
    … …  
    2424#include <malloc.h>                                                                             // malloc_usable_size
    2525#include <math.h>                                                                               // fabsf, fabs, fabsl
    26 #include <complex.h>                                                                    // _Complex_I
     26#include <complex.h>                                                                    // _Complex_I, cabsf, cabs, cabsl
    2727} // extern "C"
    2828
    2929forall( otype T ) T * malloc( void ) {
    30         //printf( "malloc1\n" );
     30        printf( "malloc1\n" );
    3131    return (T *)malloc( sizeof(T) );
    3232} // malloc
     33forall( otype T ) T * malloc( size_t size ) {
     34        printf( "malloc2\n" );
     35    return (T *)(void *)malloc( size );
     36} // malloc
    3337forall( otype T ) T * malloc( char fill ) {
    34         //printf( "malloc3\n" );
     38        printf( "malloc3\n" );
    3539        T * ptr = (T *)malloc( sizeof(T) );
    36     return memset( ptr, (int)fill, sizeof(T) );
    37 } // malloc
    38 
    39 forall( otype T ) T * calloc( size_t nmemb ) {
    40         //printf( "calloc\n" );
    41     return (T *)calloc( nmemb, sizeof(T) );
     40    return memset( ptr );
     41} // malloc
     42
     43forall( otype T ) T * calloc( size_t size ) {
     44        printf( "calloc\n" );
     45    return (T *)calloc( size, sizeof(T) );
    4246} // calloc
    4347
    4448forall( otype T ) T * realloc( T * ptr, size_t size ) {
    45         //printf( "realloc1\n" );
     49        printf( "realloc1\n" );
    4650    return (T *)(void *)realloc( (void *)ptr, size );
    4751} // realloc
    4852forall( otype T ) T * realloc( T * ptr, size_t size, unsigned char fill ) {
    49         //printf( "realloc2\n" );
     53        printf( "realloc2\n" );
    5054    char * nptr = (T *)(void *)realloc( (void *)ptr, size );
    5155    size_t unused = malloc_usable_size( nptr );
    … …  
    5559
    5660forall( otype T ) T * malloc( T * ptr, size_t size ) {
    57         //printf( "malloc4\n" );
     61        printf( "malloc4\n" );
    5862    return (T *)realloc( ptr, size );
    5963} // malloc
    6064forall( otype T ) T * malloc( T * ptr, size_t size, unsigned char fill ) {
    61         //printf( "malloc5\n" );
     65        printf( "malloc5\n" );
    6266    return (T *)realloc( ptr, size, fill );
    6367} // malloc
    6468
    6569forall( otype T ) T * aligned_alloc( size_t alignment ) {
    66         //printf( "aligned_alloc\n" );
     70        printf( "aligned_alloc\n" );
    6771    return (T *)memalign( alignment, sizeof(T) );
    6872} // aligned_alloc
    6973
    7074forall( otype T ) T * memalign( size_t alignment ) {
    71         //printf( "memalign\n" );
     75        printf( "memalign\n" );
    7276    return (T *)memalign( alignment, sizeof(T) );
    7377} // memalign
    7478
    7579forall( otype T ) int posix_memalign( T ** ptr, size_t alignment ) {
    76         //printf( "posix_memalign\n" );
     80        printf( "posix_memalign\n" );
    7781    return posix_memalign( (void **)ptr, alignment, sizeof(T) );
    7882} // posix_memalign
    7983
     84forall( otype T ) T * memset( T * ptr, unsigned char fill ) { // use default value '\0' for fill
     85        printf( "memset1\n" );
     86    return (T *)memset( ptr, (int)fill, malloc_usable_size( ptr ) );
     87} // memset
     88forall( otype T ) T * memset( T * ptr ) {                               // remove when default value available
     89        printf( "memset2\n" );
     90    return (T *)memset( ptr, 0, malloc_usable_size( ptr ) );
     91} // memset
     92
    8093//---------------------------------------
    8194
    8295int ato( const char * ptr ) {
    8396        int i;
    84         if ( sscanf( ptr, "%d", &i ) == EOF ) {}
     97        if ( sscanf( ptr, "%d", &i ) == EOF ) {}                        // check return code
    8598        return i;
    8699}
    87100unsigned int ato( const char * ptr ) {
    88101        unsigned int ui;
    89         if ( sscanf( ptr, "%u", &ui ) == EOF ) {}
     102        if ( sscanf( ptr, "%u", &ui ) == EOF ) {}                       // check return code
    90103        return ui;
    91104}
    92105long int ato( const char * ptr ) {
    93106        long int li;
    94         if ( sscanf( ptr, "%ld", &li ) == EOF ) {}
     107        if ( sscanf( ptr, "%ld", &li ) == EOF ) {}                      // check return code
    95108        return li;
    96109}
    97110unsigned long int ato( const char * ptr ) {
    98111        unsigned long int uli;
    99         if ( sscanf( ptr, "%lu", &uli ) == EOF ) {}
     112        if ( sscanf( ptr, "%lu", &uli ) == EOF ) {}                     // check return code
    100113        return uli;
    101114}
    102115long long int ato( const char * ptr ) {
    103116        long long int lli;
    104         if ( sscanf( ptr, "%lld", &lli ) == EOF ) {}
     117        if ( sscanf( ptr, "%lld", &lli ) == EOF ) {}            // check return code
    105118        return lli;
    106119}
    107120unsigned long long int ato( const char * ptr ) {
    108121        unsigned long long int ulli;
    109         if ( sscanf( ptr, "%llu", &ulli ) == EOF ) {}
     122        if ( sscanf( ptr, "%llu", &ulli ) == EOF ) {}           // check return code
    110123        return ulli;
    111124}
    … …  
    113126float ato( const char * ptr ) {
    114127        float f;
    115         if ( sscanf( ptr, "%f", &f ) == EOF ) {}
     128        if ( sscanf( ptr, "%f", &f ) == EOF ) {}                        // check return code
    116129        return f;
    117130}
    118131double ato( const char * ptr ) {
    119132        double d;
    120         if ( sscanf( ptr, "%lf", &d ) == EOF ) {}
     133        if ( sscanf( ptr, "%lf", &d ) == EOF ) {}                       // check return code
    121134        return d;
    122135}
    123136long double ato( const char * ptr ) {
    124137        long double ld;
    125         if ( sscanf( ptr, "%Lf", &ld ) == EOF ) {}
     138        if ( sscanf( ptr, "%Lf", &ld ) == EOF ) {}                      // check return code
    126139        return ld;
    127140}
    … …  
    129142float _Complex ato( const char * ptr ) {
    130143        float re, im;
    131         if ( sscanf( ptr, "%g%gi", &re, &im ) == EOF ) {}
     144        if ( sscanf( ptr, "%g%gi", &re, &im ) == EOF ) {}       // check return code
    132145        return re + im * _Complex_I;
    133146}
    134147double _Complex ato( const char * ptr ) {
    135148        double re, im;
    136         if ( sscanf( ptr, "%lf%lfi", &re, &im ) == EOF ) {}
     149        if ( sscanf( ptr, "%lf%lfi", &re, &im ) == EOF ) {} // check return code
    137150        return re + im * _Complex_I;
    138151}
    139152long double _Complex ato( const char * ptr ) {
    140153        long double re, im;
    141         if ( sscanf( ptr, "%Lf%Lfi", &re, &im ) == EOF ) {}
     154        if ( sscanf( ptr, "%Lf%Lfi", &re, &im ) == EOF ) {}     // check return code
    142155        return re + im * _Complex_I;
    143156}       
    … …  
    213226//---------------------------------------
    214227
    215 // forall( otype T | { T ?/?( T, T ); T ?%?( T, T ); } )
    216 // [ T, T ] div( T t1, T t2 ) { return [ t1 / t2, t1 % t2 ]; }
     228forall( otype T | { T ?/?( T, T ); T ?%?( T, T ); } )
     229[ T, T ] div( T t1, T t2 ) { /* return [ t1 / t2, t1 % t2 ]; */ }
    217230
    218231//---------------------------------------
    … …  
    221234long int abs( long int v ) { return labs( v ); }
    222235long long int abs( long long int v ) { return llabs( v ); }
    223 float abs( float x ) { return fabsf( x ); }
    224 double abs( double x ) { return fabs( x ); }
    225 long double abs( long double x ) { return fabsl( x ); }
    226 float abs( float _Complex x ) { return cabsf( x ); }
    227 double abs( double _Complex x ) { return cabs( x ); }
    228 long double abs( long double _Complex x ) { return cabsl( x ); }
     236float abs( float v ) { return fabsf( v ); }
     237double abs( double v ) { return fabs( v ); }
     238long double abs( long double v ) { return fabsl( v ); }
     239float _Complex abs( float _Complex v ) { return cabsf( v ); }
     240double _Complex abs( double _Complex v ) { return cabs( v ); }
     241long double _Complex abs( long double _Complex v ) { return cabsl( v ); }
    229242
    230243//---------------------------------------
Note: See TracChangeset for help on using the changeset viewer.