Changes in libcfa/src/stdlib.hfa [c354108:60062be]

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 : Fri Aug 14 23:38:50 2020
-// Update Count     : 504
+// Last Modified On : Thu Jul 30 16:14:58 2020
+// Update Count     : 490
 //
 
@@ -39 +39 @@
 //---------------------------------------
 
-#include "common.hfa"
-
-//---------------------------------------
-
 // Macro because of returns
 #define $VAR_ALLOC( allocation, alignment ) \
@@ -140 +136 @@
         T * alloc_set( char fill ) {
                 return (T *)memset( (T *)alloc(), (int)fill, sizeof(T) ); // initialize with fill value
-        } // alloc_set
-
-        T * alloc_set( const T & fill ) {
+        } // alloc
+
+        T * alloc_set( T fill ) {
                 return (T *)memcpy( (T *)alloc(), &fill, sizeof(T) ); // initialize with fill value
-        } // alloc_set
+        } // alloc
 
         T * alloc_set( size_t dim, char fill ) {
                 return (T *)memset( (T *)alloc( dim ), (int)fill, dim * sizeof(T) ); // initialize with fill value
-        } // alloc_set
-
-        T * alloc_set( size_t dim, const T & fill ) {
+        } // alloc
+
+        T * alloc_set( size_t dim, T fill ) {
                 T * r = (T *)alloc( dim );
                 for ( i; dim ) { memcpy( &r[i], &fill, sizeof(T) ); } // initialize with fill value
                 return r;
-        } // alloc_set
-
-        T * alloc_set( size_t dimNew, const T fill[], size_t dimOld ) {
-                return (T *)memcpy( (T *)alloc( dimNew ), fill, min( dimNew, dimOld ) * sizeof(T) ); // initialize with fill value
-        } // alloc_set
+        } // alloc
+
+        T * alloc_set( size_t dim, const T fill[] ) {
+                return (T *)memcpy( (T *)alloc( dim ), fill, dim * sizeof(T) ); // initialize with fill value
+        } // alloc
 
         T * alloc_set( T ptr[], size_t dim, char fill ) {       // realloc array with fill
@@ -170 +166 @@
         } // alloc_set
 
-        T * alloc_set( T ptr[], size_t dim, const T & fill ) {  // realloc array with fill
+        T * alloc_set( T ptr[], size_t dim, T & fill ) {        // realloc array with fill
                 size_t odim = malloc_size( ptr ) / sizeof(T);   // current dimension
                 size_t nsize = dim * sizeof(T);                                 // new allocation
@@ -181 +177 @@
                 } // if
                 return nptr;
-        } // alloc_set
+        } // alloc_align_set
 } // distribution
 
@@ -208 +204 @@
         T * alloc_align_set( size_t align, char fill ) {
                 return (T *)memset( (T *)alloc_align( align ), (int)fill, sizeof(T) ); // initialize with fill value
-        } // alloc_align_set
-
-        T * alloc_align_set( size_t align, const T & fill ) {
+        } // alloc_align
+
+        T * alloc_align_set( size_t align, T fill ) {
                 return (T *)memcpy( (T *)alloc_align( align ), &fill, sizeof(T) ); // initialize with fill value
-        } // alloc_align_set
+        } // alloc_align
 
         T * alloc_align_set( size_t align, size_t dim, char fill ) {
                 return (T *)memset( (T *)alloc_align( align, dim ), (int)fill, dim * sizeof(T) ); // initialize with fill value
-        } // alloc_align_set
-
-        T * alloc_align_set( size_t align, size_t dim, const T & fill ) {
+        } // alloc_align
+
+        T * alloc_align_set( size_t align, size_t dim, T fill ) {
                 T * r = (T *)alloc_align( align, dim );
                 for ( i; dim ) { memcpy( &r[i], &fill, sizeof(T) ); } // initialize with fill value
                 return r;
-        } // alloc_align_set
-
-        T * alloc_align_set( size_t align, size_t dimNew, const T fill[], size_t dimOld ) {
-                return (T *)memcpy( (T *)alloc_align( align, dimNew ), fill, min( dimNew, dimOld ) * sizeof(T) );
-        } // alloc_align_set
+        } // alloc_align
+
+        T * alloc_align_set( size_t align, size_t dim, const T fill[] ) {
+                return (T *)memcpy( (T *)alloc_align( align, dim ), fill, dim * sizeof(T) );
+        } // alloc_align
 
         T * alloc_align_set( T ptr[], size_t align, size_t dim, char fill ) {
@@ -238 +234 @@
         } // alloc_align_set
 
-        T * alloc_align_set( T ptr[], size_t align, size_t dim, const T & fill ) {
+        T * alloc_align_set( T ptr[], size_t align, size_t dim, T & fill ) {
                 size_t odim = malloc_size( ptr ) / sizeof(T);   // current dimension
                 size_t nsize = dim * sizeof(T);                                 // new allocation
@@ -378 +374 @@
 //---------------------------------------
 
+#include "common.hfa"
+
+//---------------------------------------
+
 extern bool threading_enabled(void) OPTIONAL_THREAD;