Ignore:
Timestamp:
May 30, 2017, 9:53:15 AM (7 years ago)
Author:
Thierry Delisle <tdelisle@…>
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:
d6fb3c7
Parents:
a029714 (diff), bff607e (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' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/libcfa/stdlib.c

    ra029714 r5e8d732  
    1010// Created On       : Thu Jan 28 17:10:29 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed May 24 18:13:15 2017
    13 // Update Count     : 198
     12// Last Modified On : Tue May 30 09:07:56 2017
     13// Update Count     : 237
    1414//
    1515
    … …  
    2121#define _XOPEN_SOURCE 600                                                               // posix_memalign, *rand48
    2222#include <stdlib.h>                                                                             // malloc, free, calloc, realloc, memalign, posix_memalign, bsearch
    23 #include <string.h>                                                                             // memset
     23#include <string.h>                                                                             // memcpy, memset
    2424#include <malloc.h>                                                                             // malloc_usable_size
    2525#include <math.h>                                                                               // fabsf, fabs, fabsl
    … …  
    2727} // extern "C"
    2828
    29 forall( dtype T | sized(T) ) T * malloc( void ) {               // type-safe
    30     return (T *)(void *)malloc( (size_t)sizeof(T) );
    31 } // malloc
    32 
    33 forall( dtype T | sized(T) ) T * malloc( char fill ) {  // initial with fill value (like calloc)
    34         T * ptr = (T *)(void *)malloc( (size_t)sizeof(T) );
    35     return memset( ptr, (int)fill, sizeof(T) );
    36 } // malloc
    37 
    38 forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size ) { // alternative realloc
    39     return (T *)realloc( ptr, size );
    40 } // malloc
    41 
    42 forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size, unsigned char fill ) { // alternative realloc with fill value
    43     return (T *)realloc( ptr, size, fill );
    44 } // malloc
    45 
    46 
    47 forall( dtype T | sized(T) ) T * calloc( size_t nmemb ) { // type-safe array initialization with fill 0
    48     return (T *)calloc( nmemb, sizeof(T) );
    49 } // calloc
    50 
    51 
    52 forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size ) { // type-safe
    53     return (T *)(void *)realloc( (void *)ptr, size );
     29// resize, non-array types
     30forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, char fill ) { // alternative realloc with fill value
     31        //printf( "X6\n" );
     32        size_t olen = malloc_usable_size( ptr );                        // current allocation
     33    char * nptr = (void *)realloc( (void *)ptr, size ); // C realloc
     34        size_t nlen = malloc_usable_size( nptr );                       // new allocation
     35        if ( nlen > olen ) {                                                            // larger ?
     36                memset( nptr + olen, (int)fill, nlen - olen );  // initialize added storage
     37        } //
     38    return (T *)nptr;
    5439} // realloc
    5540
    56 forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, unsigned char fill ) { // alternative realloc with fill value
    57     char * nptr = (T *)(void *)realloc( (void *)ptr, size );
    58     size_t unused = malloc_usable_size( nptr );
    59     memset( nptr + size - unused, (int)fill, unused );  // initialize any new storage
    60     return nptr;
    61 } // realloc
    62 
    63 
    64 forall( dtype T | sized(T) ) T * aligned_alloc( size_t alignment ) { // aligned allocation
    65     return (T *)memalign( alignment, sizeof(T) );
    66 } // aligned_alloc
    67 
    68 forall( dtype T | sized(T) ) T * memalign( size_t alignment ) {
    69     return (T *)memalign( alignment, sizeof(T) );
    70 } // memalign
    71 
    72 forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t alignment ) {
    73     return posix_memalign( (void **)ptr, alignment, sizeof(T) );
    74 } // posix_memalign
    75 
    76 
    77 forall( dtype T, ttype Params | sized(T) | { void ?{}( T *, Params ); } ) //  new
     41// allocation/deallocation and constructor/destructor
     42forall( dtype T, ttype Params | sized(T) | { void ?{}( T *, Params ); } )
    7843T * new( Params p ) {
    7944        return ((T *)malloc()){ p };
    8045} // new
    8146
    82 forall( dtype T | { void ^?{}(T *); } )                                 // delete
     47forall( dtype T | { void ^?{}( T * ); } )
    8348void delete( T * ptr ) {
    8449        if ( ptr ) {
    85                 ^ptr{};
     50                ^ptr{};                                                                                 // run destructor
    8651                free( ptr );
    87         }
     52        } // if
    8853} // delete
    8954
    90 forall( dtype T, ttype Params | { void ^?{}(T *); void delete(Params); } )
     55forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } )
    9156void delete( T * ptr, Params rest ) {
    9257        if ( ptr ) {
    93                 ^ptr{};
     58                ^ptr{};                                                                                 // run destructor
    9459                free( ptr );
    95         }
     60        } // if
    9661        delete( rest );
    9762} // delete
    … …  
    242207
    243208forall( otype T | { int ?<?( T, T ); } )
    244 T * bsearch( T key, const T * arr, size_t dimension ) {
     209T * bsearch( T key, const T * arr, size_t dim ) {
    245210        int comp( const void * t1, const void * t2 ) { return *(T *)t1 < *(T *)t2 ? -1 : *(T *)t2 < *(T *)t1 ? 1 : 0; }
    246         return (T *)bsearch( &key, arr, dimension, sizeof(T), comp );
     211        return (T *)bsearch( &key, arr, dim, sizeof(T), comp );
    247212} // bsearch
    248213
    249214forall( otype T | { int ?<?( T, T ); } )
    250 unsigned int bsearch( T key, const T * arr, size_t dimension ) {
    251         T *result = bsearch( key, arr, dimension );
    252         return result ? result - arr : dimension;                       // pointer subtraction includes sizeof(T)
     215unsigned int bsearch( T key, const T * arr, size_t dim ) {
     216        T *result = bsearch( key, arr, dim );
     217        return result ? result - arr : dim;                                     // pointer subtraction includes sizeof(T)
    253218} // bsearch
    254219
    255220forall( otype T | { int ?<?( T, T ); } )
    256 void qsort( const T * arr, size_t dimension ) {
     221void qsort( const T * arr, size_t dim ) {
    257222        int comp( const void * t1, const void * t2 ) { return *(T *)t1 < *(T *)t2 ? -1 : *(T *)t2 < *(T *)t1 ? 1 : 0; }
    258         qsort( arr, dimension, sizeof(T), comp );
     223        qsort( arr, dim, sizeof(T), comp );
    259224} // qsort
    260225
Note: See TracChangeset for help on using the changeset viewer.