Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/libcfa/stdlib

    rf3fc631f r8dc51c8  
    1010// Created On       : Thu Jan 28 17:12:35 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue May 30 09:07:35 2017
    13 // Update Count     : 164
     12// Last Modified On : Wed May 24 18:06:27 2017
     13// Update Count     : 115
    1414//
    1515
    … …  
    2828//---------------------------------------
    2929
    30 extern "C" { void * memset( void * dest, int c, size_t size ); } // use default C routine for void *
     30forall( dtype T | sized(T) ) T * malloc( void );
     31forall( dtype T | sized(T) ) T * malloc( char fill );
     32forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size );
     33forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size, unsigned char fill );
     34extern "C" { void * calloc( size_t nmemb, size_t size ); } // use default C routine for void *
     35forall( dtype T | sized(T) ) T * calloc( size_t nmemb );
     36extern "C" { void * realloc( void * ptr, size_t size ); } // use default C routine for void *
     37forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size );
     38forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, unsigned char fill );
    3139
    32 // allocation, non-array types
    33 static inline forall( dtype T | sized(T) ) T * malloc( void ) {
    34         //printf( "X1\n" );
    35         return (T *)(void *)malloc( (size_t)sizeof(T) );        // C malloc
    36 } // malloc
    37 static inline forall( dtype T | sized(T) ) T * malloc( char fill ) {
    38         //printf( "X2\n" );
    39         T * ptr = (T *)(void *)malloc( (size_t)sizeof(T) );     // C malloc
    40     return memset( ptr, (int)fill, sizeof(T) );                 // initial with fill value
    41 } // malloc
     40forall( dtype T | sized(T) ) T * aligned_alloc( size_t alignment );
     41forall( dtype T | sized(T) ) T * memalign( size_t alignment );          // deprecated
     42forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t alignment );
    4243
    43 // allocation, array types
    44 extern "C" { void * calloc( size_t dim, size_t size ); } // use default C routine for void *
    45 static inline forall( dtype T | sized(T) ) T * calloc( size_t dim ) {
    46         //printf( "X3\n" );
    47         return (T *)(void *)calloc( dim, sizeof(T) );           // C cmalloc
    48 }
    49 static inline forall( dtype T | sized(T) ) T * amalloc( size_t dim ) { // alternative name
    50         //printf( "X4\n" );
    51         return (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc
    52 } // amalloc
    53 static inline forall( dtype T | sized(T) ) T * amalloc( size_t dim, char fill ) { // alternative name
    54         //printf( "X5\n" );
    55         T * ptr = (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc
    56     return memset( ptr, (int)fill, dim * sizeof(T) );
    57 } // amalloc
    58 
    59 // resize, non-array types
    60 extern "C" { void * realloc( void * ptr, size_t size ); } // use default C routine for void *
    61 static inline forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size ) {
    62         //printf( "X5.5\n" );
    63         return (T *)(void *)realloc( (void *)ptr, size );
    64 }
    65 forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, char fill );
    66 static inline forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size ) { // alternative name
    67         //printf( "X7\n" );
    68         return realloc( ptr, size );
    69 } // malloc
    70 static inline forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size, char fill ) { // alternative name
    71         //printf( "X8\n" );
    72         return realloc( ptr, size, fill );
    73 } // malloc
    74 
    75 // resize, array types
    76 static inline forall( dtype T | sized(T) ) T * amalloc( T * ptr, size_t dim ) {
    77         //printf( "X9\n" );
    78         return malloc( ptr, dim * (size_t)sizeof(T) );
    79 } // amalloc
    80 static inline forall( dtype T | sized(T) ) T * amalloc( T * ptr, size_t dim, char fill ) {
    81         //printf( "X10\n" );
    82         return malloc( ptr, dim * (size_t)sizeof(T), fill );
    83 } // amalloc
    84 
    85 // alignment, non-array types
    86 extern "C" { void * memalign( size_t alignment, size_t size ); } // use default C routine for void *
    87 static inline forall( dtype T | sized(T) ) T * memalign( size_t alignment ) {
    88         //printf( "X11\n" );
    89         return (T *)memalign( alignment, sizeof(T) );
    90 } // memalign
    91 static inline forall( dtype T | sized(T) ) T * memalign( size_t alignment, char fill ) {
    92         //printf( "X12\n" );
    93     T * ptr = (T *)memalign( alignment, sizeof(T) );
    94     return memset( ptr, (int)fill, sizeof(T) );
    95 } // memalign
    96 static inline forall( dtype T | sized(T) ) T * aligned_alloc( size_t alignment ) {
    97         //printf( "X13\n" );
    98         return (T *)memalign( alignment, sizeof(T) );
    99 } // aligned_alloc
    100 extern "C" { int posix_memalign( void ** ptr, size_t alignment, size_t size ); } // use default C routine for void *
    101 static inline forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t alignment ) {
    102         //printf( "X14\n" );
    103         return posix_memalign( (void **)ptr, alignment, sizeof(T) );
    104 } // posix_memalign
    105 
    106 // alignment, array types
    107 static inline forall( dtype T | sized(T) ) T * amemalign( size_t alignment, size_t dim ) {
    108         //printf( "X15\n" );
    109         return (T *)memalign( alignment, dim * sizeof(T) );
    110 } // amemalign
    111 static inline forall( dtype T | sized(T) ) T * amemalign( size_t alignment, size_t dim, char fill ) {
    112         //printf( "X16\n" );
    113     T * ptr = (T *)memalign( alignment, dim * sizeof(T) );
    114     return memset( ptr, (int)fill, dim * sizeof(T) );
    115 } // amemalign
    116 
    117 // data, non-array types
    118 static inline forall( dtype T | sized(T) ) T * memset( T * dest, char c ) {
    119         //printf( "X17\n" );
    120         return memset( dest, c, sizeof(T) );
    121 } // memset
    122 extern "C" { void * memcpy( void * dest, const void * src, size_t size ); } // use default C routine for void *
    123 static inline forall( dtype T | sized(T) ) T * memcpy( T * dest, const T * src ) {
    124         //printf( "X18\n" );
    125         return memcpy( dest, src, sizeof(T) );
    126 } // memcpy
    127 
    128 // data, array types
    129 static inline forall( dtype T | sized(T) ) T * amemset( T * dest, size_t dim, char c ) {
    130         //printf( "X19\n" );
    131         return memset( dest, c, dim * sizeof(T) );
    132 } // amemset
    133 static inline forall( dtype T | sized(T) ) T * amemcpy( T * dest, const T * src, size_t dim ) {
    134         //printf( "X20\n" );
    135         return memcpy( dest, src, dim * sizeof(T) );
    136 } // amemcpy
    137 
    138 // allocation/deallocation and constructor/destructor
    13944forall( dtype T, ttype Params | sized(T) | { void ?{}(T *, Params); } ) T * new( Params p );
    140 forall( dtype T | { void ^?{}( T * ); } ) void delete( T * ptr );
    141 forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } ) void delete( T * ptr, Params rest );
     45forall( dtype T | { void ^?{}(T *); } ) void delete( T * ptr );
     46forall( dtype T, ttype Params | { void ^?{}(T *); void delete(Params); } ) void delete( T * ptr, Params rest );
    14247
    14348//---------------------------------------
    … …  
    17277
    17378forall( otype T | { int ?<?( T, T ); } )
    174 T * bsearch( T key, const T * arr, size_t dim );
     79T * bsearch( T key, const T * arr, size_t dimension );
    17580
    17681forall( otype T | { int ?<?( T, T ); } )
    177 unsigned int bsearch( T key, const T * arr, size_t dim );
     82unsigned int bsearch( T key, const T * arr, size_t dimension );
    17883
    17984
    18085forall( otype T | { int ?<?( T, T ); } )
    181 void qsort( const T * arr, size_t dim );
     86void qsort( const T * arr, size_t dimension );
    18287
    18388//---------------------------------------
Note: See TracChangeset for help on using the changeset viewer.