Changeset f3fc631f for src/libcfa
- Timestamp:
- May 30, 2017, 9:13:53 AM (7 years ago)
- 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
- Location:
- src/libcfa
- Files:
-
- 2 edited
Legend:
- Unmodified
- Added
- Removed
-
src/libcfa/stdlib
r2ab67b9 rf3fc631f 10 10 // Created On : Thu Jan 28 17:12:35 2016 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Wed May 24 18:06:27201713 // Update Count : 1 1512 // Last Modified On : Tue May 30 09:07:35 2017 13 // Update Count : 164 14 14 // 15 15 … … 28 28 //--------------------------------------- 29 29 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 ); 30 extern "C" { void * memset( void * dest, int c, size_t size ); } // use default C routine for void * 31 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 42 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 36 60 extern "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 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 44 139 forall( 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 );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 ); 47 142 48 143 //--------------------------------------- … … 77 172 78 173 forall( otype T | { int ?<?( T, T ); } ) 79 T * bsearch( T key, const T * arr, size_t dim ension);80 81 forall( otype T | { int ?<?( T, T ); } ) 82 unsigned int bsearch( T key, const T * arr, size_t dim ension);83 84 85 forall( otype T | { int ?<?( T, T ); } ) 86 void qsort( const T * arr, size_t dim ension);174 T * bsearch( T key, const T * arr, size_t dim ); 175 176 forall( otype T | { int ?<?( T, T ); } ) 177 unsigned int bsearch( T key, const T * arr, size_t dim ); 178 179 180 forall( otype T | { int ?<?( T, T ); } ) 181 void qsort( const T * arr, size_t dim ); 87 182 88 183 //--------------------------------------- -
src/libcfa/stdlib.c
r2ab67b9 rf3fc631f 10 10 // Created On : Thu Jan 28 17:10:29 2016 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Wed May 24 18:13:15201713 // Update Count : 19812 // Last Modified On : Tue May 30 09:07:56 2017 13 // Update Count : 237 14 14 // 15 15 … … 21 21 #define _XOPEN_SOURCE 600 // posix_memalign, *rand48 22 22 #include <stdlib.h> // malloc, free, calloc, realloc, memalign, posix_memalign, bsearch 23 #include <string.h> // mem set23 #include <string.h> // memcpy, memset 24 24 #include <malloc.h> // malloc_usable_size 25 25 #include <math.h> // fabsf, fabs, fabsl … … 27 27 } // extern "C" 28 28 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 30 forall( 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; 54 39 } // realloc 55 40 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 42 forall( dtype T, ttype Params | sized(T) | { void ?{}( T *, Params ); } ) 78 43 T * new( Params p ) { 79 44 return ((T *)malloc()){ p }; 80 45 } // new 81 46 82 forall( dtype T | { void ^?{}( T *); } ) // delete47 forall( dtype T | { void ^?{}( T * ); } ) 83 48 void delete( T * ptr ) { 84 49 if ( ptr ) { 85 ^ptr{}; 50 ^ptr{}; // run destructor 86 51 free( ptr ); 87 } 52 } // if 88 53 } // delete 89 54 90 forall( dtype T, ttype Params | { void ^?{}( T *); void delete(Params); } )55 forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } ) 91 56 void delete( T * ptr, Params rest ) { 92 57 if ( ptr ) { 93 ^ptr{}; 58 ^ptr{}; // run destructor 94 59 free( ptr ); 95 } 60 } // if 96 61 delete( rest ); 97 62 } // delete … … 242 207 243 208 forall( otype T | { int ?<?( T, T ); } ) 244 T * bsearch( T key, const T * arr, size_t dim ension) {209 T * bsearch( T key, const T * arr, size_t dim ) { 245 210 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, dim ension, sizeof(T), comp );211 return (T *)bsearch( &key, arr, dim, sizeof(T), comp ); 247 212 } // bsearch 248 213 249 214 forall( otype T | { int ?<?( T, T ); } ) 250 unsigned int bsearch( T key, const T * arr, size_t dim ension) {251 T *result = bsearch( key, arr, dim ension);252 return result ? result - arr : dim ension;// pointer subtraction includes sizeof(T)215 unsigned 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) 253 218 } // bsearch 254 219 255 220 forall( otype T | { int ?<?( T, T ); } ) 256 void qsort( const T * arr, size_t dim ension) {221 void qsort( const T * arr, size_t dim ) { 257 222 int comp( const void * t1, const void * t2 ) { return *(T *)t1 < *(T *)t2 ? -1 : *(T *)t2 < *(T *)t1 ? 1 : 0; } 258 qsort( arr, dim ension, sizeof(T), comp );223 qsort( arr, dim, sizeof(T), comp ); 259 224 } // qsort 260 225
Note: See TracChangeset
for help on using the changeset viewer.