Ignore:
Timestamp:
May 2, 2016, 3:28:16 PM (9 years ago)
Author:
Rob Schluntz <rschlunt@…>
Branches:
ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc
Children:
1b7ea43
Parents:
1f6e009 (diff), e945826 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' into global-init

File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/libcfa/stdlib.c

    r1f6e009 r1048b31  
    1010// Created On       : Thu Jan 28 17:10:29 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Mar 23 13:26:42 2016
    13 // Update Count     : 146
     12// Last Modified On : Thu Apr 28 07:54:21 2016
     13// Update Count     : 166
    1414//
    1515
    … …  
    2424#include <malloc.h>                                                                             // malloc_usable_size
    2525#include <math.h>                                                                               // fabsf, fabs, fabsl
    26 #include <complex.h>                                                                    // _Complex_I, cabsf, cabs, cabsl
     26#include <complex.h>                                                                    // _Complex_I
    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
    33 forall( otype T ) T * malloc( size_t size ) {
    34         printf( "malloc2\n" );
    35     return (T *)(void *)malloc( size );
    36 } // malloc
    3733forall( otype T ) T * malloc( char fill ) {
    38         printf( "malloc3\n" );
     34        //printf( "malloc3\n" );
    3935        T * ptr = (T *)malloc( sizeof(T) );
    40     return memset( ptr );
    41 } // malloc
    42 
    43 forall( otype T ) T * calloc( size_t size ) {
    44         printf( "calloc\n" );
    45     return (T *)calloc( size, sizeof(T) );
     36    return memset( ptr, (int)fill, sizeof(T) );
     37} // malloc
     38
     39forall( otype T ) T * calloc( size_t nmemb ) {
     40        //printf( "calloc\n" );
     41    return (T *)calloc( nmemb, sizeof(T) );
    4642} // calloc
    4743
    4844forall( otype T ) T * realloc( T * ptr, size_t size ) {
    49         printf( "realloc1\n" );
     45        //printf( "realloc1\n" );
    5046    return (T *)(void *)realloc( (void *)ptr, size );
    5147} // realloc
    5248forall( otype T ) T * realloc( T * ptr, size_t size, unsigned char fill ) {
    53         printf( "realloc2\n" );
     49        //printf( "realloc2\n" );
    5450    char * nptr = (T *)(void *)realloc( (void *)ptr, size );
    5551    size_t unused = malloc_usable_size( nptr );
    … …  
    5955
    6056forall( otype T ) T * malloc( T * ptr, size_t size ) {
    61         printf( "malloc4\n" );
     57        //printf( "malloc4\n" );
    6258    return (T *)realloc( ptr, size );
    6359} // malloc
    6460forall( otype T ) T * malloc( T * ptr, size_t size, unsigned char fill ) {
    65         printf( "malloc5\n" );
     61        //printf( "malloc5\n" );
    6662    return (T *)realloc( ptr, size, fill );
    6763} // malloc
    6864
    6965forall( otype T ) T * aligned_alloc( size_t alignment ) {
    70         printf( "aligned_alloc\n" );
     66        //printf( "aligned_alloc\n" );
    7167    return (T *)memalign( alignment, sizeof(T) );
    7268} // aligned_alloc
    7369
    7470forall( otype T ) T * memalign( size_t alignment ) {
    75         printf( "memalign\n" );
     71        //printf( "memalign\n" );
    7672    return (T *)memalign( alignment, sizeof(T) );
    7773} // memalign
    7874
    7975forall( otype T ) int posix_memalign( T ** ptr, size_t alignment ) {
    80         printf( "posix_memalign\n" );
     76        //printf( "posix_memalign\n" );
    8177    return posix_memalign( (void **)ptr, alignment, sizeof(T) );
    8278} // posix_memalign
    8379
    84 forall( 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
    88 forall( 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 
    9380//---------------------------------------
    9481
    9582int ato( const char * ptr ) {
    9683        int i;
    97         if ( sscanf( ptr, "%d", &i ) == EOF ) {}                        // check return code
     84        if ( sscanf( ptr, "%d", &i ) == EOF ) {}
    9885        return i;
    9986}
    10087unsigned int ato( const char * ptr ) {
    10188        unsigned int ui;
    102         if ( sscanf( ptr, "%u", &ui ) == EOF ) {}                       // check return code
     89        if ( sscanf( ptr, "%u", &ui ) == EOF ) {}
    10390        return ui;
    10491}
    10592long int ato( const char * ptr ) {
    10693        long int li;
    107         if ( sscanf( ptr, "%ld", &li ) == EOF ) {}                      // check return code
     94        if ( sscanf( ptr, "%ld", &li ) == EOF ) {}
    10895        return li;
    10996}
    11097unsigned long int ato( const char * ptr ) {
    11198        unsigned long int uli;
    112         if ( sscanf( ptr, "%lu", &uli ) == EOF ) {}                     // check return code
     99        if ( sscanf( ptr, "%lu", &uli ) == EOF ) {}
    113100        return uli;
    114101}
    115102long long int ato( const char * ptr ) {
    116103        long long int lli;
    117         if ( sscanf( ptr, "%lld", &lli ) == EOF ) {}            // check return code
     104        if ( sscanf( ptr, "%lld", &lli ) == EOF ) {}
    118105        return lli;
    119106}
    120107unsigned long long int ato( const char * ptr ) {
    121108        unsigned long long int ulli;
    122         if ( sscanf( ptr, "%llu", &ulli ) == EOF ) {}           // check return code
     109        if ( sscanf( ptr, "%llu", &ulli ) == EOF ) {}
    123110        return ulli;
    124111}
    … …  
    126113float ato( const char * ptr ) {
    127114        float f;
    128         if ( sscanf( ptr, "%f", &f ) == EOF ) {}                        // check return code
     115        if ( sscanf( ptr, "%f", &f ) == EOF ) {}
    129116        return f;
    130117}
    131118double ato( const char * ptr ) {
    132119        double d;
    133         if ( sscanf( ptr, "%lf", &d ) == EOF ) {}                       // check return code
     120        if ( sscanf( ptr, "%lf", &d ) == EOF ) {}
    134121        return d;
    135122}
    136123long double ato( const char * ptr ) {
    137124        long double ld;
    138         if ( sscanf( ptr, "%Lf", &ld ) == EOF ) {}                      // check return code
     125        if ( sscanf( ptr, "%Lf", &ld ) == EOF ) {}
    139126        return ld;
    140127}
    … …  
    142129float _Complex ato( const char * ptr ) {
    143130        float re, im;
    144         if ( sscanf( ptr, "%g%gi", &re, &im ) == EOF ) {}       // check return code
     131        if ( sscanf( ptr, "%g%gi", &re, &im ) == EOF ) {}
    145132        return re + im * _Complex_I;
    146133}
    147134double _Complex ato( const char * ptr ) {
    148135        double re, im;
    149         if ( sscanf( ptr, "%lf%lfi", &re, &im ) == EOF ) {} // check return code
     136        if ( sscanf( ptr, "%lf%lfi", &re, &im ) == EOF ) {}
    150137        return re + im * _Complex_I;
    151138}
    152139long double _Complex ato( const char * ptr ) {
    153140        long double re, im;
    154         if ( sscanf( ptr, "%Lf%Lfi", &re, &im ) == EOF ) {}     // check return code
     141        if ( sscanf( ptr, "%Lf%Lfi", &re, &im ) == EOF ) {}
    155142        return re + im * _Complex_I;
    156143}       
    … …  
    226213//---------------------------------------
    227214
    228 forall( otype T | { T ?/?( T, T ); T ?%?( T, T ); } )
    229 [ T, T ] div( T t1, T t2 ) { /* return [ t1 / t2, t1 % t2 ]; */ }
     215// forall( otype T | { T ?/?( T, T ); T ?%?( T, T ); } )
     216// [ T, T ] div( T t1, T t2 ) { return [ t1 / t2, t1 % t2 ]; }
    230217
    231218//---------------------------------------
    … …  
    234221long int abs( long int v ) { return labs( v ); }
    235222long long int abs( long long int v ) { return llabs( v ); }
    236 float abs( float v ) { return fabsf( v ); }
    237 double abs( double v ) { return fabs( v ); }
    238 long double abs( long double v ) { return fabsl( v ); }
    239 float _Complex abs( float _Complex v ) { return cabsf( v ); }
    240 double _Complex abs( double _Complex v ) { return cabs( v ); }
    241 long double _Complex abs( long double _Complex v ) { return cabsl( v ); }
     223float abs( float x ) { return fabsf( x ); }
     224double abs( double x ) { return fabs( x ); }
     225long double abs( long double x ) { return fabsl( x ); }
     226float abs( float _Complex x ) { return cabsf( x ); }
     227double abs( double _Complex x ) { return cabs( x ); }
     228long double abs( long double _Complex x ) { return cabsl( x ); }
    242229
    243230//---------------------------------------
Note: See TracChangeset for help on using the changeset viewer.