Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • libcfa/src/stdlib.hfa

    rd4264e8 rb6a71bc  
    1010// Created On       : Thu Jan 28 17:12:35 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Apr 19 09:47:55 2024
    13 // Update Count     : 826
     12// Last Modified On : Fri Apr 12 07:39:15 2024
     13// Update Count     : 812
    1414//
    1515
    … …  
    4747
    4848static inline forall( T & | sized(T) ) {
    49         // CFA safe equivalents, i.e., implicit size specification, eliminate return-type cast
     49        // CFA safe equivalents, i.e., implicit size specification
    5050
    5151        T * malloc( void ) {
    … …  
    6464        } // calloc
    6565
    66         T * resize( T * ptr, size_t size ) {
    67                 if ( _Alignof(T) <= libAlign() ) return (T *)resize( (void *)ptr, size ); // C resize
     66        T * resize( T * ptr, size_t size ) {                            // CFA resize, eliminate return-type cast
     67                if ( _Alignof(T) <= libAlign() ) return (T *)resize( (void *)ptr, size ); // CFA resize
    6868                else return (T *)resize( (void *)ptr, _Alignof(T), size ); // CFA resize
    6969        } // resize
    7070
    71         T * resize( T * ptr, size_t alignment, size_t size ) {
    72                 return (T *)resize( (void *)ptr, alignment, size ); // CFA resize
    73         } // resize
    74 
    75         T * realloc( T * ptr, size_t size ) {                           // CFA realloc
     71        T * realloc( T * ptr, size_t size ) {                           // CFA realloc, eliminate return-type cast
    7672                if ( _Alignof(T) <= libAlign() ) return (T *)realloc( (void *)ptr, size ); // C realloc
    7773                else return (T *)realloc( (void *)ptr, _Alignof(T), size ); // CFA realloc
    7874        } // realloc
    7975
    80         T * realloc( T * ptr, size_t alignment, size_t size ) {
    81                 return (T *)realloc( (void *)ptr, alignment, size ); // CFA realloc
    82         } // realloc
    83 
    84         T * reallocarray( T * ptr, size_t dim ) {                       // CFA reallocarray
    85                 if ( _Alignof(T) <= libAlign() ) return (T *)reallocarray( (void *)ptr, dim, sizeof(T) ); // C reallocarray
    86                 else return (T *)reallocarray( (void *)ptr, _Alignof(T), dim ); // CFA reallocarray
    87         } // realloc
    88 
    89         T * reallocarray( T * ptr, size_t alignment, size_t dim ) {
    90                 return (T *)reallocarray( (void *)ptr, alignment, dim ); // CFA reallocarray
    91         } // realloc
    92 
    9376        T * memalign( size_t align ) {
    9477                return (T *)memalign( align, sizeof(T) );               // C memalign
    … …  
    9982        } // amemalign
    10083
    101         T * cmemalign( size_t align, size_t dim ) {
     84        T * cmemalign( size_t align, size_t dim  ) {
    10285                return (T *)cmemalign( align, dim, sizeof(T) ); // CFA cmemalign
    10386        } // cmemalign
    … …  
    176159static inline T_resize ?`resize( void * a )     { return (T_resize){a}; }
    177160
     161extern "C" ssize_t write(int fd, const void *buf, size_t count);
    178162static inline forall( T & | sized(T) ) {
    179         S_fill(T) ?`fill( T t ) {
     163        S_fill(T) ?`fill ( T t ) {
    180164                S_fill(T) ret = { 't' };
    181165                size_t size = sizeof(T);
    … …  
    186170                return ret;
    187171        }
    188         S_fill(T) ?`fill( zero_t ) = void; // FIX ME: remove this once ticket 214 is resolved
    189         S_fill(T) ?`fill( T * a ) { return (S_fill(T)){ 'T', '0', 0, a }; } // FIX ME: remove this once ticket 214 is resolved
    190         S_fill(T) ?`fill( char c ) { return (S_fill(T)){ 'c', c };      }
    191         S_fill(T) ?`fill( T a[], size_t nmemb ) { return (S_fill(T)){ 'a', '0', nmemb * sizeof(T), a }; }
     172        S_fill(T) ?`fill ( zero_t ) = void; // FIX ME: remove this once ticket 214 is resolved
     173        S_fill(T) ?`fill ( T * a ) { return (S_fill(T)){ 'T', '0', 0, a }; } // FIX ME: remove this once ticket 214 is resolved
     174        S_fill(T) ?`fill ( char c ) { return (S_fill(T)){ 'c', c };     }
     175        S_fill(T) ?`fill ( T a[], size_t nmemb ) { return (S_fill(T)){ 'a', '0', nmemb * sizeof(T), a }; }
    192176
    193177        S_realloc(T) ?`realloc ( T * a ) { return (S_realloc(T)){a}; }
    … …  
    226210        } // alloc_internal$
    227211
    228         forall( List ... | { T * alloc_internal$( void *, T *, size_t, size_t, S_fill(T), List ); } ) {
    229                 T * alloc_internal$( void *, T *, size_t Align, size_t Dim, S_fill(T) Fill, T_resize Resize, List rest ) {
     212        forall( TT... | { T * alloc_internal$( void *, T *, size_t, size_t, S_fill(T), TT ); } ) {
     213                T * alloc_internal$( void *, T *, size_t Align, size_t Dim, S_fill(T) Fill, T_resize Resize, TT rest ) {
    230214                return alloc_internal$( Resize, (T*)0p, Align, Dim, Fill, rest);
    231215                }
    232216
    233                 T * alloc_internal$( void *, T *, size_t Align, size_t Dim, S_fill(T) Fill, S_realloc(T) Realloc, List rest ) {
     217                T * alloc_internal$( void *, T *, size_t Align, size_t Dim, S_fill(T) Fill, S_realloc(T) Realloc, TT rest ) {
    234218                return alloc_internal$( (void*)0p, Realloc, Align, Dim, Fill, rest);
    235219                }
    236220
    237                 T * alloc_internal$( void * Resize, T * Realloc, size_t, size_t Dim, S_fill(T) Fill, T_align Align, List rest ) {
     221                T * alloc_internal$( void * Resize, T * Realloc, size_t, size_t Dim, S_fill(T) Fill, T_align Align, TT rest ) {
    238222                return alloc_internal$( Resize, Realloc, Align, Dim, Fill, rest);
    239223                }
    240224
    241                 T * alloc_internal$( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T), S_fill(T) Fill, List rest ) {
     225                T * alloc_internal$( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T), S_fill(T) Fill, TT rest ) {
    242226                return alloc_internal$( Resize, Realloc, Align, Dim, Fill, rest );
    243227                }
    244228
    245             T * alloc( List all ) {
     229            T * alloc( TT all ) {
    246230                return alloc_internal$( (void*)0p, (T*)0p, (_Alignof(T) > libAlign() ? _Alignof(T) : libAlign()), (size_t)1, (S_fill(T)){'0'}, all );
    247231            }
    248232
    249             T * alloc( size_t dim, List all ) {
     233            T * alloc( size_t dim, TT all ) {
    250234                return alloc_internal$( (void*)0p, (T*)0p, (_Alignof(T) > libAlign() ? _Alignof(T) : libAlign()), dim, (S_fill(T)){'0'}, all );
    251235            }
    252         } // distribution List
     236        } // distribution TT
    253237} // distribution T
    254238
    … …  
    274258
    275259// CFA deallocation for multiple objects
    276 static inline forall( T & )
     260static inline forall( T & )                                                     // FIX ME, problems with 0p in list
    277261void free( T * ptr ) {
    278262        free( (void *)ptr );                                                            // C free
    279263} // free
    280 static inline forall( T &, List ... | { void free( List ); } )
    281 void free( T * ptr, List rest ) {
     264static inline forall( T &, TT... | { void free( TT ); } )
     265void free( T * ptr, TT rest ) {
    282266        free( ptr );
    283267        free( rest );
    … …  
    285269
    286270// CFA allocation/deallocation and constructor/destructor, non-array types
    287 static inline forall( T & | sized(T), Parms ... | { void ?{}( T &, Parms ); } )
    288 T * new( Parms p ) {
     271static inline forall( T & | sized(T), TT... | { void ?{}( T &, TT ); } )
     272T * new( TT p ) {
    289273        return &(*(T *)malloc()){ p };                                          // run constructor
    290274} // new
    … …  
    298282        free( ptr );                                                                            // always call free
    299283} // delete
    300 static inline forall( T &, List ... | { void ^?{}( T & ); void delete( List ); } )
    301 void delete( T * ptr, List rest ) {
     284static inline forall( T &, TT... | { void ^?{}( T & ); void delete( TT ); } )
     285void delete( T * ptr, TT rest ) {
    302286        delete( ptr );
    303287        delete( rest );
    … …  
    305289
    306290// CFA allocation/deallocation and constructor/destructor, array types
    307 forall( T & | sized(T), Parms ... | { void ?{}( T &, Parms ); } ) T * anew( size_t dim, Parms p );
     291forall( T & | sized(T), TT... | { void ?{}( T &, TT ); } ) T * anew( size_t dim, TT p );
    308292forall( T & | sized(T) | { void ^?{}( T & ); } ) void adelete( T arr[] );
    309 forall( T & | sized(T) | { void ^?{}( T & ); }, List ... | { void adelete( List ); } ) void adelete( T arr[], List rest );
    310 
     293forall( T & | sized(T) | { void ^?{}( T & ); }, TT... | { void adelete( TT ); } ) void adelete( T arr[], TT rest );
    311294//---------------------------------------
    312295
Note: See TracChangeset for help on using the changeset viewer.