Changeset 0f9e4403 for src/libcfa/stdlib.c

Timestamp:

Apr 15, 2016, 12:03:11 PM (9 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

29ad0ac

Parents:

c5833e8 (diff), 37f0da8 (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' into gc_noraii

File:

• src/libcfa/stdlib.c (modified) (11 diffs)

src/libcfa/stdlib.c

@@ -10 +10 @@
 // Created On       : Thu Jan 28 17:10:29 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb 10 15:45:56 2016
-// Update Count     : 140
+// Last Modified On : Wed Apr 13 14:49:58 2016
+// Update Count     : 155
 //
 
@@ -27 +27 @@
 } // extern "C"
 
-forall( type T ) T * memset( T * ptr, unsigned char fill ) { // use default value '\0' for fill
-        printf( "memset1\n" );
-    return (T *)memset( ptr, (int)fill, malloc_usable_size( ptr ) );
-} // memset
-forall( type T ) T * memset( T * ptr ) {                                // remove when default value available
-        printf( "memset2\n" );
-    return (T *)memset( ptr, 0, malloc_usable_size( ptr ) );
-} // memset
-
-forall( type T ) T * malloc( void ) {
-        printf( "malloc1\n" );
+forall( otype T ) T * malloc( void ) {
+        //printf( "malloc1\n" );
     return (T *)malloc( sizeof(T) );
 } // malloc
-forall( type T ) T * malloc( size_t size ) {
-        printf( "malloc2\n" );
-    return (T *)(void *)malloc( size );
-} // malloc
-forall( type T ) T * malloc( char fill ) {
-        printf( "malloc3\n" );
+forall( otype T ) T * malloc( char fill ) {
+        //printf( "malloc3\n" );
         T * ptr = (T *)malloc( sizeof(T) );
     return memset( ptr );
 } // malloc
 
-forall( type T ) T * calloc( size_t size ) {
-        printf( "calloc\n" );
-    return (T *)calloc( size, sizeof(T) );
+forall( otype T ) T * calloc( size_t nmemb ) {
+        //printf( "calloc\n" );
+    return (T *)calloc( nmemb, sizeof(T) );
 } // calloc
 
-forall( type T ) T * realloc( T * ptr, size_t size ) {
-        printf( "realloc1\n" );
+forall( otype T ) T * realloc( T * ptr, size_t size ) {
+        //printf( "realloc1\n" );
     return (T *)(void *)realloc( (void *)ptr, size );
 } // realloc
-forall( type T ) T * realloc( T * ptr, size_t size, unsigned char fill ) {
-        printf( "realloc2\n" );
+forall( otype T ) T * realloc( T * ptr, size_t size, unsigned char fill ) {
+        //printf( "realloc2\n" );
     char * nptr = (T *)(void *)realloc( (void *)ptr, size );
     size_t unused = malloc_usable_size( nptr );
@@ -67 +54 @@
 } // realloc
 
-forall( type T ) T * malloc( T * ptr, size_t size ) {
-        printf( "malloc4\n" );
+forall( otype T ) T * malloc( T * ptr, size_t size ) {
+        //printf( "malloc4\n" );
     return (T *)realloc( ptr, size );
 } // malloc
-forall( type T ) T * malloc( T * ptr, size_t size, unsigned char fill ) {
-        printf( "malloc5\n" );
+forall( otype T ) T * malloc( T * ptr, size_t size, unsigned char fill ) {
+        //printf( "malloc5\n" );
     return (T *)realloc( ptr, size, fill );
 } // malloc
 
-forall( type T ) T * aligned_alloc( size_t alignment ) {
-        printf( "aligned_alloc\n" );
+forall( otype T ) T * aligned_alloc( size_t alignment ) {
+        //printf( "aligned_alloc\n" );
     return (T *)memalign( alignment, sizeof(T) );
 } // aligned_alloc
 
-forall( type T ) T * memalign( size_t alignment ) {
-        printf( "memalign\n" );
+forall( otype T ) T * memalign( size_t alignment ) {
+        //printf( "memalign\n" );
     return (T *)memalign( alignment, sizeof(T) );
 } // memalign
 
-forall( type T ) int posix_memalign( T ** ptr, size_t alignment ) {
-        printf( "posix_memalign\n" );
+forall( otype T ) int posix_memalign( T ** ptr, size_t alignment ) {
+        //printf( "posix_memalign\n" );
     return posix_memalign( (void **)ptr, alignment, sizeof(T) );
 } // posix_memalign
+
+forall( otype T ) T * memset( T * ptr, unsigned char fill ) { // use default value '\0' for fill
+        //printf( "memset1\n" );
+    return (T *)memset( ptr, (int)fill, malloc_usable_size( ptr ) );
+} // memset
+forall( otype T ) T * memset( T * ptr ) {                               // remove when default value available
+        //printf( "memset2\n" );
+    return (T *)memset( ptr, 0, malloc_usable_size( ptr ) );
+} // memset
 
 //---------------------------------------
@@ -123 +119 @@
         return ulli;
 }
+
 float ato( const char * ptr ) {
         float f;
@@ -138 +135 @@
         return ld;
 }
+
 float _Complex ato( const char * ptr ) {
         float re, im;
@@ -172 +170 @@
         return strtoull( sptr, eptr, base );
 }
+
 float strto( const char * sptr, char ** eptr ) {
         return strtof( sptr, eptr );
@@ -181 +180 @@
         return strtold( sptr, eptr );
 }
+
 float _Complex strto( const char * sptr, char ** eptr ) {
         float re, im;
@@ -208 +208 @@
 //---------------------------------------
 
-forall( type T | { int ?<?( T, T ); } )
+forall( otype T | { int ?<?( T, T ); } )
 T * bsearch( const T key, const T * arr, size_t dimension ) {
         int comp( const void * t1, const void * t2 ) { return *(T *)t1 < *(T *)t2 ? -1 : *(T *)t2 < *(T *)t1 ? 1 : 0; }
@@ -214 +214 @@
 } // bsearch
 
-forall( type T | { int ?<?( T, T ); } )
+forall( otype T | { int ?<?( T, T ); } )
 void qsort( const T * arr, size_t dimension ) {
         int comp( const void * t1, const void * t2 ) { return *(T *)t1 < *(T *)t2 ? -1 : *(T *)t2 < *(T *)t1 ? 1 : 0; }
@@ -222 +222 @@
 //---------------------------------------
 
-forall( type T | { T ?/?( T, T ); T ?%?( T, T ); } )
+forall( otype T | { T ?/?( T, T ); T ?%?( T, T ); } )
 [ T, T ] div( T t1, T t2 ) { /* return [ t1 / t2, t1 % t2 ]; */ }
 
@@ -239 +239 @@
 //---------------------------------------
 
-void randseed( long int s ) { srand48( s ); }
-char random() { return lrand48(); }
-int random() { return mrand48(); }
-unsigned int random() { return lrand48(); }
-long int random() { return mrand48(); }
-unsigned long int random() { return lrand48(); }
-float random() { return (float)drand48(); }                             // otherwise float uses lrand48
-double random() { return drand48(); }
-float _Complex random() { return (float)drand48() + (float _Complex)(drand48() * _Complex_I); }
-double _Complex random() { return drand48() + (double _Complex)(drand48() * _Complex_I); }
-long double _Complex random() { return (long double)drand48() + (long double _Complex)(drand48() * _Complex_I); }
-
-//---------------------------------------
-
-forall( type T | { int ?<?( T, T ); } )
+float floor( float v ) { return floorf( v ); }
+long double floor( long double v ) { return floorl( v ); }
+
+float ceil( float v ) { return ceilf( v ); }
+long double ceil( long double v ) { return ceill( v ); }
+
+//---------------------------------------
+
+void rand48seed( long int s ) { srand48( s ); }
+char rand48() { return mrand48(); }
+int rand48() { return mrand48(); }
+unsigned int rand48() { return lrand48(); }
+long int rand48() { return mrand48(); }
+unsigned long int rand48() { return lrand48(); }
+float rand48() { return (float)drand48(); }                             // otherwise float uses lrand48
+double rand48() { return drand48(); }
+float _Complex rand48() { return (float)drand48() + (float _Complex)(drand48() * _Complex_I); }
+double _Complex rand48() { return drand48() + (double _Complex)(drand48() * _Complex_I); }
+long double _Complex rand48() { return (long double)drand48() + (long double _Complex)(drand48() * _Complex_I); }
+
+//---------------------------------------
+
+forall( otype T | { int ?<?( T, T ); } )
 T min( const T t1, const T t2 ) {
         return t1 < t2 ? t1 : t2;
 } // min
 
-forall( type T | { int ?>?( T, T ); } )
+forall( otype T | { int ?>?( T, T ); } )
 T max( const T t1, const T t2 ) {
         return t1 > t2 ? t1 : t2;
 } // max
 
-forall( type T )
+forall( otype T )
 void swap( T * t1, T * t2 ) {
         T temp = *t1;