Changeset b0a0ee4

Timestamp:

Jul 20, 2020, 8:20:21 PM (4 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

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

Children:

2b23d78

Parents:

92850ef

Message:

refactor duplicate code into cpp macros

File:

• libcfa/src/stdlib.hfa (modified) (2 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 : Mon Jul 20 14:29:21 2020
-// Update Count     : 464
+// Last Modified On : Mon Jul 20 19:04:33 2020
+// Update Count     : 472
 //
 
@@ -39 +39 @@
 //---------------------------------------
 
+// Macro because of returns
+#define $VAR_ALLOC( allocation, alignment ) \
+        if ( _Alignof(T) <= libAlign() ) return (T *)(void *)allocation( (size_t)sizeof(T) ); /* C allocation */ \
+        else return (T *)alignment( _Alignof(T), sizeof(T) )
+
+#define $ARRAY_ALLOC( allocation, alignment, dim ) \
+        if ( _Alignof(T) <= libAlign() ) return (T *)(void *)allocation( dim, (size_t)sizeof(T) ); /* C allocation */ \
+        else return (T *)alignment( _Alignof(T), dim, sizeof(T) )
+
+#define $RE_SPECIALS( ptr, size, allocation, alignment ) \
+        if ( unlikely( size == 0 ) || unlikely( ptr == 0p ) ) { \
+                if ( unlikely( size == 0 ) ) free( ptr ); \
+                $VAR_ALLOC( malloc, memalign ); \
+        } /* if */
+
 static inline forall( dtype T | sized(T) ) {
         // Cforall safe equivalents, i.e., implicit size specification
 
         T * malloc( void ) {
-                if ( _Alignof(T) <= libAlign() ) return (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
-                else return (T *)memalign( _Alignof(T), sizeof(T) );
+                $VAR_ALLOC( malloc, memalign );
         } // malloc
 
         T * aalloc( size_t dim ) {
-                if ( _Alignof(T) <= libAlign() ) return (T *)(void *)aalloc( dim, (size_t)sizeof(T) ); // CFA aalloc
-                else return (T *)amemalign( _Alignof(T), dim, sizeof(T) );
+                $ARRAY_ALLOC( aalloc, amemalign, dim );
         } // aalloc
 
         T * calloc( size_t dim ) {
-                if ( _Alignof(T) <= libAlign() )return (T *)(void *)calloc( dim, sizeof(T) ); // C calloc
-                else return (T *)cmemalign( _Alignof(T), dim, sizeof(T) );
+                $ARRAY_ALLOC( calloc, cmemalign, dim );
         } // calloc
 
         T * resize( T * ptr, size_t size ) {                            // CFA resize, eliminate return-type cast
-                if ( unlikely( size == 0 ) || unlikely( ptr == 0p ) ) { // special cases
-                        if ( unlikely( size == 0 ) ) free( ptr );
-                        if ( _Alignof(T) <= libAlign() ) return (T *)(void *)malloc( size ); // C malloc
-                        else return (T *)memalign( _Alignof(T), size ); // C memalign
-                } // if
+                $RE_SPECIALS( ptr, size, malloc, memalign );
                 return (T *)(void *)resize( (void *)ptr, size ); // CFA resize
         } // resize
 
         T * realloc( T * ptr, size_t size ) {                           // CFA realloc, eliminate return-type cast
-                if ( unlikely( size == 0 ) || unlikely( ptr == 0p ) ) { // special cases
-                        if ( unlikely( size == 0 ) ) free( ptr );
-                        if ( _Alignof(T) <= libAlign() ) return (T *)(void *)malloc( size ); // C malloc
-                        else return (T *)memalign( _Alignof(T), size ); // C memalign
-                } // if
+                $RE_SPECIALS( ptr, size, malloc, memalign );
                 return (T *)(void *)realloc( (void *)ptr, size ); // C realloc
         } // realloc