Changeset d3e4d6c for src/libcfa/stdlib.c

Timestamp:

Aug 23, 2017, 6:22:07 PM (8 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

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

Children:

87e08e24, cb811ac

Parents:

9f07232 (diff), bd37119 (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' of plg2:software/cfa/cfa-cc

File:

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

src/libcfa/stdlib.c

@@ -32 +32 @@
         if ( nlen > olen ) {                                                            // larger ?
                 memset( nptr + olen, (int)fill, nlen - olen );  // initialize added storage
-        } // 
+        } //
     return (T *)nptr;
 } // alloc
 
 // allocation/deallocation and constructor/destructor, non-array types
-forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } )
+forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } )
 T * new( Params p ) {
-        return (malloc()){ p };                                                         // run constructor
+        return &(*malloc()){ p };                                                               // run constructor
 } // new
 
-forall( dtype T | { void ^?{}( T * ); } )
+forall( dtype T | sized(T) | { void ^?{}( T & ); } )
 void delete( T * ptr ) {
         if ( ptr ) {                                                                            // ignore null
-                ^ptr{};                                                                                 // run destructor
+                ^(*ptr){};                                                                                      // run destructor
                 free( ptr );
         } // if
 } // delete
 
-forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } )
+forall( dtype T, ttype Params | sized(T) | { void ^?{}( T & ); void delete( Params ); } )
 void delete( T * ptr, Params rest ) {
         if ( ptr ) {                                                                            // ignore null
-                ^ptr{};                                                                                 // run destructor
+                ^(*ptr){};                                                                                      // run destructor
                 free( ptr );
         } // if
@@ -61 +61 @@
 
 // allocation/deallocation and constructor/destructor, array types
-forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } )
+forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } )
 T * anew( size_t dim, Params p ) {
         T *arr = alloc( dim );
         for ( unsigned int i = 0; i < dim; i += 1 ) {
-                (&arr[i]){ p };                                                                 // run constructor
+                (arr[i]){ p };                                                                  // run constructor
         } // for
         return arr;
 } // anew
 
-forall( dtype T | sized(T) | { void ^?{}( T * ); } )
+forall( dtype T | sized(T) | { void ^?{}( T & ); } )
 void adelete( size_t dim, T arr[] ) {
         if ( arr ) {                                                                            // ignore null
                 for ( int i = dim - 1; i >= 0; i -= 1 ) {               // reverse allocation order, must be unsigned
-                        ^(&arr[i]){};                                                           // run destructor
+                        ^(arr[i]){};                                                            // run destructor
                 } // for
                 free( arr );
@@ -80 +80 @@
 } // adelete
 
-forall( dtype T | sized(T) | { void ^?{}( T * ); }, ttype Params | { void adelete( Params ); } )
+forall( dtype T | sized(T) | { void ^?{}( T & ); }, ttype Params | { void adelete( Params ); } )
 void adelete( size_t dim, T arr[], Params rest ) {
         if ( arr ) {                                                                            // ignore null
                 for ( int i = dim - 1; i >= 0; i -= 1 ) {               // reverse allocation order, must be unsigned
-                        ^(&arr[i]){};                                                           // run destructor
+                        ^(arr[i]){};                                                            // run destructor
                 } // for
                 free( arr );