Changeset f3fc631f for src/libcfa/stdlib


Ignore:
Timestamp:
May 30, 2017, 9:13:53 AM (7 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc
Children:
fab700b
Parents:
2ab67b9
Message:

first attempt new storage management routines

File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/libcfa/stdlib

    r2ab67b9 rf3fc631f  
    1010// Created On       : Thu Jan 28 17:12:35 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed May 24 18:06:27 2017
    13 // Update Count     : 115
     12// Last Modified On : Tue May 30 09:07:35 2017
     13// Update Count     : 164
    1414//
    1515
    … …  
    2828//---------------------------------------
    2929
    30 forall( dtype T | sized(T) ) T * malloc( void );
    31 forall( dtype T | sized(T) ) T * malloc( char fill );
    32 forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size );
    33 forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size, unsigned char fill );
    34 extern "C" { void * calloc( size_t nmemb, size_t size ); } // use default C routine for void *
    35 forall( dtype T | sized(T) ) T * calloc( size_t nmemb );
     30extern "C" { void * memset( void * dest, int c, size_t size ); } // use default C routine for void *
     31
     32// allocation, non-array types
     33static 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
     37static 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
     42
     43// allocation, array types
     44extern "C" { void * calloc( size_t dim, size_t size ); } // use default C routine for void *
     45static 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}
     49static 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
     53static 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
    3660extern "C" { void * realloc( void * ptr, size_t size ); } // use default C routine for void *
    37 forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size );
    38 forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, unsigned char fill );
    39 
    40 forall( dtype T | sized(T) ) T * aligned_alloc( size_t alignment );
    41 forall( dtype T | sized(T) ) T * memalign( size_t alignment );          // deprecated
    42 forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t alignment );
    43 
     61static 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}
     65forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, char fill );
     66static 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
     70static 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
     76static 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
     80static 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
     86extern "C" { void * memalign( size_t alignment, size_t size ); } // use default C routine for void *
     87static inline forall( dtype T | sized(T) ) T * memalign( size_t alignment ) {
     88        //printf( "X11\n" );
     89        return (T *)memalign( alignment, sizeof(T) );
     90} // memalign
     91static 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
     96static 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
     100extern "C" { int posix_memalign( void ** ptr, size_t alignment, size_t size ); } // use default C routine for void *
     101static 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
     107static 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
     111static 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
     118static 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
     122extern "C" { void * memcpy( void * dest, const void * src, size_t size ); } // use default C routine for void *
     123static 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
     129static 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
     133static 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
    44139forall( dtype T, ttype Params | sized(T) | { void ?{}(T *, Params); } ) T * new( Params p );
    45 forall( dtype T | { void ^?{}(T *); } ) void delete( T * ptr );
    46 forall( dtype T, ttype Params | { void ^?{}(T *); void delete(Params); } ) void delete( T * ptr, Params rest );
     140forall( dtype T | { void ^?{}( T * ); } ) void delete( T * ptr );
     141forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } ) void delete( T * ptr, Params rest );
    47142
    48143//---------------------------------------
    … …  
    77172
    78173forall( otype T | { int ?<?( T, T ); } )
    79 T * bsearch( T key, const T * arr, size_t dimension );
    80 
    81 forall( otype T | { int ?<?( T, T ); } )
    82 unsigned int bsearch( T key, const T * arr, size_t dimension );
    83 
    84 
    85 forall( otype T | { int ?<?( T, T ); } )
    86 void qsort( const T * arr, size_t dimension );
     174T * bsearch( T key, const T * arr, size_t dim );
     175
     176forall( otype T | { int ?<?( T, T ); } )
     177unsigned int bsearch( T key, const T * arr, size_t dim );
     178
     179
     180forall( otype T | { int ?<?( T, T ); } )
     181void qsort( const T * arr, size_t dim );
    87182
    88183//---------------------------------------
Note: See TracChangeset for help on using the changeset viewer.