Changeset 506d4f0 for tests/zombies/constructors.c

Timestamp:

Oct 1, 2020, 8:17:34 AM (2 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

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

Children:

17b6fc9, ebec8ed

Parents:

e96e439

Message:

updated zombie programs but still not ready for prime time

File:

• tests/zombies/constructors.c (modified) (2 diffs)

tests/zombies/constructors.c

@@ -1 @@
-int fred() {
+#include <fstream.hfa>
+#include <stdlib.hfa>
+
+int main() {
     // initialize basic structure
     struct S {
         int i, j, k;
     };
-    void ?{}( S *s ) { s->i = 1, s->k = 2; }            // default constructor
-    void ?{}( S *s, int i, int k ) { s->i = i, s->k = k; } // 2 parameter constructor
-    void ?{}( S *s, S c ) { *s = c; }                   // copy constructor
-    void ^?{}( S *s ) { s->i = 0, s->k = 0; }           // default destructor
-    void ^?{}( S *s, int i ) { s->i = i, s->k = i; }    // 1 parameter destructor
+    void ?{}( S & s ) { s.i = 1, s.k = 2; }             // default constructor
+    void ?{}( S & s, int i, int k ) { s.i = i, s.k = k; } // 2 parameter constructor
+    void ?{}( S & s, S c ) { /* s @= c */ s.[i,j,k] = c.[i,j,k]; } // copy constructor
+    void ^?{}( S & s ) { s.i = 0, s.k = 0; }            // default destructor
+    void ^?{}( S & s, int i ) { s.i = i, s.k = i; }     // 1 parameter destructor
     {
-        S s1;                   // default constructor
-        S s2 = { 3, 7 };        // 2 parameter constructor
-        S s3 @= { .k:3, .i:7 }; // 2 parameter C initialization
-        ?{}( &s3, 2, 5 );       // explicit 2 parameter constructor
-        ^?{}( &s1 );            // explicit call to default destructor
+        S s1;                                           // default constructor
+        S s2 = { 3, 7 };                                // 2 parameter constructor
+        S s3 @= { .k:3, .i:7 };                         // 2 parameter C initialization
+        ?{}( s3, 2, 5 );                                // explicit 2 parameter constructor
+        ^?{}( s1 );                                     // explicit call to default destructor
     } // implicit call to default destructor for s2, explicit call s1, no call for s3
-    S s4 @= {};                 // no default construction
-    (&s4){ 2, 5 };              // explicit 2 parameter constructor
-    ^s4{ 3 };                   // explicit call to 1 parameter destructor
+    S s4 @= {};                                         // no default construction
+    (s4){ 2, 5 };                                       // explicit 2 parameter constructor
+    ^s4{ 3 };                                           // explicit call to 1 parameter destructor
 
     // initialize pointer to a basic structure
 
-    void ?{}( S **s ) { *s = malloc(); (*s)->i = 1, (*s)->k = 2; } // default constructor
-    void ?{}( S **s, int i, int k ) { *s = malloc(); (*s)->i = i, (*s)->k = k; } // 2 parameter constructor
-    void ^?{}( S **s ) { (*s)->i = 0, (*s)->k = 0; free( *s ); *s = 0; } // default destructor
+    void ?{}( S *& s ) { s = malloc(); s->i = 1, (*s).k = 2; } // default constructor
+    void ?{}( S *& s, int i, int k ) { s = malloc(); (*s).i = i, (*s).k = k; } // 2 parameter constructor
+    void ^?{}( S *& s ) { (*s).i = 0, (*s).k = 0; free( s ); &s = 0p; } // default destructor
     {
-        S *ps1;                 // default constructor
-        S *ps2 = { 3, 7 };      // 2 parameter constructor
-        S *ps3 @= 0;            // C initialization
-        S *ps4 @= {};           // no default construction
+        S * ps1;                                        // default constructor
+        S * ps2 = { 3, 7 };                             // 2 parameter constructor
+        sout | ps1 | ps2;
+
+        S * ps3 @= 0p;                                  // C initialization
+        S * ps4 @= { 3 };                               // no default construction
+        sout | ps3 | ps4;
+
+        ?{}( ps3, 2, 5 );                               // explicit 2 parameter constructor
+        (ps4){ 2, 5 };                                  // explicit 2 parameter constructor
+        sout | ps3 | ps4;
+
+        ^?{}( ps3 );                                    // explicit call to default destructor
+        ^ps4{};                                         // explicit call to default destructor
+        sout | ps3 | ps4;
     } // implicit call to default destructor for ps2 and ps1, checks ordering of explicit destructor calls
-
-    ?{}( &ps3, 2, 5 );          // explicit 2 parameter constructor
-    (&ps4){ 2, 5 };             // explicit 2 parameter constructor
-    
-    ^?{}( &ps3 );               // explicit call to default destructor
-    ^ps4{};                     // explicit call to default destructor
 
     // initialize complex structure
@@ -44 +52 @@
     };
 
-    void ?{}( T *t ) {}                                 // default constructor => implicitly call constructor for field s
-    void ?{}( T *t, int i, int k ) { (&t->s){ i, k }; } // 2 parameter constructor => explicitly call constructor for field s
-    void ?{}( T *t, S c ) { (&t->s){ c }; }             // 1 parameter constructor => explicitly call copy constructor for field s
-    void ^?{}( T *s, int i ) {}                         // destructor => implicitly call destructor for field s
+    void ?{}( T & t ) {}        // default constructor => implicitly call constructor for field s
+    void ?{}( T & t, int i, int k ) { (t.s){ i, k }; } // 2 parameter constructor => explicitly call constructor for field s
+    void ?{}( T & t, S c ) { (t.s){ c }; }// 1 parameter constructor => explicitly call copy constructor for field s
+    void ^?{}( T & s ) {}       // destructor => implicitly call destructor for field s
+    void ^?{}( T & s, int i ) {}// destructor => implicitly call destructor for field s
     {
-        S s;                    // default constructor
-        T t1;                   // default constructor
-        T t2 = { s };           // 1 parameter constructor
-        ^?{}( &t1 );            // explicit call to default destructor => implicit call to t1.s's destructor
+        S s;                                            // default constructor
+        T t1;                                           // default constructor
+        T t2 = { s };                                   // 1 parameter constructor
+        ^?{}( t1, 3 );                                  // explicit call to default destructor => implicit call to t1.s's destructor
+        T t3;                                           // default constructor
+        T t4 @= { { 1, 3 } };                           // C initialization
+        (t4){ 2, 5 };                                   // explicit 2 parameter constructor
     } // implicit call to default destructor for t2 and implicit call for s;
-    T t3;                       // default constructor
-    T t4 @= { { 1, 3 } };       // C initialization
-    (&t4){ 2, 5 };              // explicit 2 parameter constructor
 
     T *pt = malloc(){ 3, 4 };   // common usage