Changeset ded61bf2 for libcfa/src/stdlib.hfa

Timestamp:

Aug 12, 2020, 5:59:46 PM (5 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:

51230f1b

Parents:

fb0ae06

Message:

formatting, replace "T fill" with "const T & fill"

File:

• libcfa/src/stdlib.hfa (modified) (6 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 : Thu Jul 30 16:14:58 2020
-// Update Count     : 490
+// Last Modified On : Tue Aug 11 21:11:46 2020
+// Update Count     : 495
 //
 
@@ -136 +136 @@
         T * alloc_set( char fill ) {
                 return (T *)memset( (T *)alloc(), (int)fill, sizeof(T) ); // initialize with fill value
-        } // alloc
-
-        T * alloc_set( T fill ) {
+        } // alloc_set
+
+        T * alloc_set( const T & fill ) {
                 return (T *)memcpy( (T *)alloc(), &fill, sizeof(T) ); // initialize with fill value
-        } // alloc
+        } // alloc_set
 
         T * alloc_set( size_t dim, char fill ) {
                 return (T *)memset( (T *)alloc( dim ), (int)fill, dim * sizeof(T) ); // initialize with fill value
-        } // alloc
-
-        T * alloc_set( size_t dim, T fill ) {
+        } // alloc_set
+
+        T * alloc_set( size_t dim, const T & fill ) {
                 T * r = (T *)alloc( dim );
                 for ( i; dim ) { memcpy( &r[i], &fill, sizeof(T) ); } // initialize with fill value
                 return r;
-        } // alloc
+        } // alloc_set
 
         T * alloc_set( size_t dim, const T fill[] ) {
                 return (T *)memcpy( (T *)alloc( dim ), fill, dim * sizeof(T) ); // initialize with fill value
-        } // alloc
+        } // alloc_set
 
         T * alloc_set( T ptr[], size_t dim, char fill ) {       // realloc array with fill
@@ -166 +166 @@
         } // alloc_set
 
-        T * alloc_set( T ptr[], size_t dim, T & fill ) {        // realloc array with fill
+        T * alloc_set( T ptr[], size_t dim, const T & fill ) {  // realloc array with fill
                 size_t odim = malloc_size( ptr ) / sizeof(T);   // current dimension
                 size_t nsize = dim * sizeof(T);                                 // new allocation
@@ -177 +177 @@
                 } // if
                 return nptr;
-        } // alloc_align_set
+        } // alloc_set
 } // distribution
 
@@ -204 +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
-
-        T * alloc_align_set( size_t align, T fill ) {
+        } // alloc_align_set
+
+        T * alloc_align_set( size_t align, const T & fill ) {
                 return (T *)memcpy( (T *)alloc_align( align ), &fill, sizeof(T) ); // initialize with fill value
-        } // alloc_align
+        } // alloc_align_set
 
         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
-
-        T * alloc_align_set( size_t align, size_t dim, T fill ) {
+        } // alloc_align_set
+
+        T * alloc_align_set( size_t align, size_t dim, const 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
+        } // alloc_align_set
 
         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
+        } // alloc_align_set
 
         T * alloc_align_set( T ptr[], size_t align, size_t dim, char fill ) {
@@ -234 +234 @@
         } // alloc_align_set
 
-        T * alloc_align_set( T ptr[], size_t align, size_t dim, T & fill ) {
+        T * alloc_align_set( T ptr[], size_t align, size_t dim, const T & fill ) {
                 size_t odim = malloc_size( ptr ) / sizeof(T);   // current dimension
                 size_t nsize = dim * sizeof(T);                                 // new allocation