Changeset 2fa5bd2 for libcfa/src/stdlib.hfa

Timestamp:

Dec 12, 2019, 10:04:15 AM (4 years ago)

Author:

Dmitry Kobets <dkobets@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

e752e4e

Parents:

aca6a54c (diff), 2cd949b (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 vector-generic

File:

• libcfa/src/stdlib.hfa (modified) (8 diffs)

libcfa/src/stdlib.hfa

@@ -10 +10 @@
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Oct 20 22:57:33 2019
-// Update Count     : 390
+// Last Modified On : Fri Nov 29 23:08:02 2019
+// Update Count     : 400
 //
 
@@ -28 +28 @@
 } // extern "C"
 
+void * realloc( void * oaddr, size_t nalign, size_t size ); // CFA heap
+
 //---------------------------------------
 
@@ -50 +52 @@
         } // calloc
 
-        T * realloc( T * ptr, size_t size ) {
-                if ( unlikely( ptr == 0 ) ) return malloc();
+        T * realloc( T * ptr, size_t size ) {                           // CFA realloc, eliminate return-type cast
                 return (T *)(void *)realloc( (void *)ptr, size ); // C realloc
         } // realloc
@@ -59 +60 @@
         } // memalign
 
+        T * cmemalign( size_t align, size_t dim  ) {
+                return (T *)cmemalign( align, dim, sizeof(T) ); // CFA cmemalign
+        } // cmemalign
+
         T * aligned_alloc( size_t align ) {
                 return (T *)aligned_alloc( align, sizeof(T) );  // C aligned_alloc
@@ -79 +84 @@
 
         T * alloc( T ptr[], size_t dim ) {                                      // realloc
-                return realloc( ptr, dim * sizeof(T) );
+                return (T *)(void *)realloc( (void *)ptr, dim * sizeof(T) ); // C realloc
         } // alloc
 
@@ -118 +123 @@
         } // alloc_align
 
+        T * alloc_align( T ptr[], size_t align ) {                      // aligned realloc array
+                return (T *)(void *)realloc( (void *)ptr, align, sizeof(T) ); // CFA realloc
+        } // alloc_align
+
+        T * alloc_align( T ptr[], size_t align, size_t dim ) { // aligned realloc array
+                return (T *)(void *)realloc( (void *)ptr, align, dim * sizeof(T) ); // CFA realloc
+        } // alloc_align
+
         T * alloc_align_set( size_t align, char fill ) {
                 return (T *)memset( (T *)alloc_align( align ), (int)fill, sizeof(T) ); // initialize with fill value
@@ -142 +155 @@
 
 forall( dtype T | sized(T) ) {
-        T * alloc_align( T ptr[], size_t align );                       // realign
-        T * alloc_align( T ptr[], size_t align, size_t dim ); // aligned realloc array
         T * alloc_align_set( T ptr[], size_t align, size_t dim, char fill ); // aligned realloc array with fill
 } // distribution
@@ -199 +210 @@
 
 static inline {
-        int ato( const char * sptr ) { return (int)strtol( sptr, 0, 10 ); }
-        unsigned int ato( const char * sptr ) { return (unsigned int)strtoul( sptr, 0, 10 ); }
-        long int ato( const char * sptr ) { return strtol( sptr, 0, 10 ); }
-        unsigned long int ato( const char * sptr ) { return strtoul( sptr, 0, 10 ); }
-        long long int ato( const char * sptr ) { return strtoll( sptr, 0, 10 ); }
-        unsigned long long int ato( const char * sptr ) { return strtoull( sptr, 0, 10 ); }
-
-        float ato( const char * sptr ) { return strtof( sptr, 0 ); }
-        double ato( const char * sptr ) { return strtod( sptr, 0 ); }
-        long double ato( const char * sptr ) { return strtold( sptr, 0 ); }
-
-        float _Complex ato( const char * sptr ) { return strto( sptr, NULL ); }
-        double _Complex ato( const char * sptr ) { return strto( sptr, NULL ); }
-        long double _Complex ato( const char * sptr ) { return strto( sptr, NULL ); }
+        int ato( const char * sptr ) { return (int)strtol( sptr, 0p, 10 ); }
+        unsigned int ato( const char * sptr ) { return (unsigned int)strtoul( sptr, 0p, 10 ); }
+        long int ato( const char * sptr ) { return strtol( sptr, 0p, 10 ); }
+        unsigned long int ato( const char * sptr ) { return strtoul( sptr, 0p, 10 ); }
+        long long int ato( const char * sptr ) { return strtoll( sptr, 0p, 10 ); }
+        unsigned long long int ato( const char * sptr ) { return strtoull( sptr, 0p, 10 ); }
+
+        float ato( const char * sptr ) { return strtof( sptr, 0p ); }
+        double ato( const char * sptr ) { return strtod( sptr, 0p ); }
+        long double ato( const char * sptr ) { return strtold( sptr, 0p ); }
+
+        float _Complex ato( const char * sptr ) { return strto( sptr, 0p ); }
+        double _Complex ato( const char * sptr ) { return strto( sptr, 0p ); }
+        long double _Complex ato( const char * sptr ) { return strto( sptr, 0p ); }
 } // distribution