Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • libcfa/src/stdlib.hfa

    rd1b70d4 r09da82d  
    1010// Created On       : Thu Jan 28 17:12:35 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Jan 21 22:02:13 2021
    13 // Update Count     : 574
     12// Last Modified On : Sat Dec 12 13:52:34 2020
     13// Update Count     : 536
    1414//
    1515
    … …  
    4848        else return (T *)alignment( _Alignof(T), dim, sizeof(T) )
    4949
    50 static inline forall( T & | sized(T) ) {
     50static inline forall( dtype T | sized(T) ) {
    5151        // CFA safe equivalents, i.e., implicit size specification
    5252
    … …  
    108108
    109109        1. Replace the current forall-block that contains defintions of S_fill and S_realloc with following:
    110                 forall( T & | sized(T) ) {
     110                forall( dtype T | sized(T) ) {
    111111                        union  U_fill           { char c; T * a; T t; };
    112112                        struct S_fill           { char tag; U_fill(T) fill; };
    … …  
    151151typedef struct S_resize                 { inline void *;  }     T_resize;
    152152
    153 forall( T & ) {
     153forall( dtype T ) {
    154154        struct S_fill           { char tag; char c; size_t size; T * at; char t[50]; };
    155155        struct S_realloc        { inline T *; };
    … …  
    159159static inline T_resize  ?`resize  ( void * a )  { return (T_resize){a}; }
    160160
    161 static inline forall( T & | sized(T) ) {
     161static inline forall( dtype T | sized(T) ) {
    162162        S_fill(T) ?`fill ( T t ) {
    163163                S_fill(T) ret = { 't' };
    164164                size_t size = sizeof(T);
    165                 if ( size > sizeof(ret.t) ) {
    166                         abort( "ERROR: const object of size greater than 50 bytes given for dynamic memory fill\n" );
    167                 } // if
     165                if(size > sizeof(ret.t)) { printf("ERROR: const object of size greater than 50 bytes given for dynamic memory fill\n"); exit(1); }
    168166                memcpy( &ret.t, &t, size );
    169167                return ret;
    … …  
    175173        S_realloc(T)    ?`realloc ( T * a )                             { return (S_realloc(T)){a}; }
    176174
    177         T * $alloc_internal( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill ) {
     175        T * $alloc_internal( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill) {
    178176                T * ptr = NULL;
    179177                size_t size = sizeof(T);
    … …  
    183181                        ptr = (T*) (void *) resize( (void *)Resize, Align, Dim * size );
    184182                } else if ( Realloc ) {
    185                         if ( Fill.tag != '0' ) copy_end = min(malloc_size( Realloc ), Dim * size );
    186                         ptr = (T *) (void *) realloc( (void *)Realloc, Align, Dim * size );
     183                        if (Fill.tag != '0') copy_end = min(malloc_size( Realloc ), Dim * size);
     184                        ptr = (T*) (void *) realloc( (void *)Realloc, Align, Dim * size );
    187185                } else {
    188                         ptr = (T *) (void *) memalign( Align, Dim * size );
    189                 }
    190 
    191                 if ( Fill.tag == 'c' ) {
     186                        ptr = (T*) (void *) memalign( Align, Dim * size );
     187                }
     188
     189                if(Fill.tag == 'c') {
    192190                        memset( (char *)ptr + copy_end, (int)Fill.c, Dim * size - copy_end );
    193                 } else if ( Fill.tag == 't' ) {
     191                } else if(Fill.tag == 't') {
    194192                        for ( int i = copy_end; i < Dim * size; i += size ) {
    195                                 #pragma GCC diagnostic push
    196                                 #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
    197                                 assert( size <= sizeof(Fill.t) );
    198193                                memcpy( (char *)ptr + i, &Fill.t, size );
    199                                 #pragma GCC diagnostic pop
    200194                        }
    201                 } else if ( Fill.tag == 'a' ) {
     195                } else if(Fill.tag == 'a') {
    202196                        memcpy( (char *)ptr + copy_end, Fill.at, min(Dim * size - copy_end, Fill.size) );
    203                 } else if ( Fill.tag == 'T' ) {
    204                         memcpy( (char *)ptr + copy_end, Fill.at, Dim * size );
     197                } else if(Fill.tag == 'T') {
     198                        for ( int i = copy_end; i < Dim * size; i += size ) {
     199                                memcpy( (char *)ptr + i, Fill.at, size );
     200                        }
    205201                }
    206202
    … …  
    208204        } // $alloc_internal
    209205
    210         forall( TT... | { T * $alloc_internal( void *, T *, size_t, size_t, S_fill(T), TT ); } ) {
     206        forall( ttype TT | { T * $alloc_internal( void *, T *, size_t, size_t, S_fill(T), TT ); } ) {
    211207
    212208                T * $alloc_internal( void *       , T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill, T_resize Resize, TT rest) {
    … …  
    237233} // distribution T
    238234
    239 static inline forall( T & | sized(T) ) {
     235static inline forall( dtype T | sized(T) ) {
    240236        // CFA safe initialization/copy, i.e., implicit size specification, non-array types
    241237        T * memset( T * dest, char fill ) {
    … …  
    258254
    259255// CFA deallocation for multiple objects
    260 static inline forall( T & )                                                     // FIX ME, problems with 0p in list
     256static inline forall( dtype T )                                                 // FIX ME, problems with 0p in list
    261257void free( T * ptr ) {
    262258        free( (void *)ptr );                                                            // C free
    263259} // free
    264 static inline forall( T &, TT... | { void free( TT ); } )
     260static inline forall( dtype T, ttype TT | { void free( TT ); } )
    265261void free( T * ptr, TT rest ) {
    266262        free( ptr );
    … …  
    269265
    270266// CFA allocation/deallocation and constructor/destructor, non-array types
    271 static inline forall( T & | sized(T), TT... | { void ?{}( T &, TT ); } )
     267static inline forall( dtype T | sized(T), ttype TT | { void ?{}( T &, TT ); } )
    272268T * new( TT p ) {
    273         return &(*(T *)malloc()){ p };                                          // run constructor
     269        return &(*(T *)malloc()){ p };                                                  // run constructor
    274270} // new
    275271
    276 static inline forall( T & | { void ^?{}( T & ); } )
     272static inline forall( dtype T | { void ^?{}( T & ); } )
    277273void delete( T * ptr ) {
    278274        // special case for 0-sized object => always call destructor
    … …  
    282278        free( ptr );                                                                            // always call free
    283279} // delete
    284 static inline forall( T &, TT... | { void ^?{}( T & ); void delete( TT ); } )
     280static inline forall( dtype T, ttype TT | { void ^?{}( T & ); void delete( TT ); } )
    285281void delete( T * ptr, TT rest ) {
    286282        delete( ptr );
    … …  
    289285
    290286// CFA allocation/deallocation and constructor/destructor, array types
    291 forall( T & | sized(T), TT... | { void ?{}( T &, TT ); } ) T * anew( size_t dim, TT p );
    292 forall( T & | sized(T) | { void ^?{}( T & ); } ) void adelete( T arr[] );
    293 forall( T & | sized(T) | { void ^?{}( T & ); }, TT... | { void adelete( TT ); } ) void adelete( T arr[], TT rest );
     287forall( dtype T | sized(T), ttype TT | { void ?{}( T &, TT ); } ) T * anew( size_t dim, TT p );
     288forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void adelete( T arr[] );
     289forall( dtype T | sized(T) | { void ^?{}( T & ); }, ttype TT | { void adelete( TT ); } ) void adelete( T arr[], TT rest );
    294290
    295291//---------------------------------------
    … …  
    331327//---------------------------------------
    332328
    333 forall( E | { int ?<?( E, E ); } ) {
     329forall( otype E | { int ?<?( E, E ); } ) {
    334330        E * bsearch( E key, const E * vals, size_t dim );
    335331        size_t bsearch( E key, const E * vals, size_t dim );
    … …  
    340336} // distribution
    341337
    342 forall( K, E | { int ?<?( K, K ); K getKey( const E & ); } ) {
     338forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } ) {
    343339        E * bsearch( K key, const E * vals, size_t dim );
    344340        size_t bsearch( K key, const E * vals, size_t dim );
    … …  
    349345} // distribution
    350346
    351 forall( E | { int ?<?( E, E ); } ) {
     347forall( otype E | { int ?<?( E, E ); } ) {
    352348        void qsort( E * vals, size_t dim );
    353349} // distribution
Note: See TracChangeset for help on using the changeset viewer.