Changeset 87d13cd for src/tests

Timestamp:

Mar 21, 2017, 10:07:52 PM (9 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:

cb91437

Parents:

829c907 (diff), a53e10a (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:

fix conflicit in iostream.c

Location:

src/tests

Files:

• avltree/avl.h (modified) (1 diff)
• avltree/avl1.c (modified) (1 diff)
• avltree/avl_test.c (modified) (2 diffs)
• completeTypeError.c (modified) (1 diff)
• coroutine.c (modified) (3 diffs)
• dtor-early-exit.c (modified) (1 diff)
• monitor.c (modified) (1 diff)
• multi-monitor.c (modified) (2 diffs)
• thread.c (modified) (2 diffs)

src/tests/avltree/avl.h

@@ -61 +61 @@
 void ?{}(tree(K, V) *t, K key, V value);
 
-forall(otype K | Comparable(K), otype V)
+forall(otype K, otype V)
 void ^?{}(tree(K, V) * t);
 

src/tests/avltree/avl1.c

@@ -12 +12 @@
 }
 
-forall(otype K | Comparable(K), otype V)
+forall(otype K, otype V)
 void ^?{}(tree(K, V) * t){
   delete(t->left);

src/tests/avltree/avl_test.c

@@ -25 +25 @@
 
   // int -> char *
-  tree(int, char *) * smap = create(-1, "baz");
+  tree(int, const char *) * smap = create(-1, "baz");
   insert(&smap, 12, "bar");
   insert(&smap, 2, "foo");
@@ -35 +35 @@
   delete(smap);
 
-  // char* -> char*
-  struct c_str { char *str; };  // wraps a C string
-  int ?<?(c_str a, c_str b) {
-    return strcmp(a.str,b.str) < 0;
+  // const char* -> const char*
+  int ?<?(const char * a, const char * b) {
+    return strcmp(a, b) < 0;
   }
-  tree(c_str, char *) * ssmap = create((c_str){"queso"}, "cheese");
-  insert(&ssmap, (c_str){"foo"}, "bar");
-  insert(&ssmap, (c_str){"hello"}, "world");
+
+  tree(const char *, const char *) * ssmap = create("queso", "cheese");
+  insert(&ssmap, "foo", "bar");
+  insert(&ssmap, "hello", "world");
   assert( height(ssmap) == 2 );
 
-  printf("%s %s %s\n", *find(ssmap, (c_str){"hello"}), *find(ssmap, (c_str){"foo"}), *find(ssmap, (c_str){"queso"}));
+  printf("%s %s %s\n", *find(ssmap, "hello"), *find(ssmap, "foo"), *find(ssmap, "queso"));
 
-  remove(&ssmap, (c_str){"foo"});
+  remove(&ssmap, "foo");
   delete(ssmap);
 }

src/tests/completeTypeError.c

@@ -62 +62 @@
 
 forall(dtype T | sized(T))
-void qux(T * z) {
+void quux(T * z) {
         // okay
         bar(z);

src/tests/coroutine.c

@@ -2 +2 @@
 #include <coroutine>
 
-struct Fibonacci {
+coroutine Fibonacci {
       int fn; // used for communication
-      coroutine_desc c;
 };
 
@@ -11 +10 @@
 }
 
-coroutine_desc* get_coroutine(Fibonacci* this) {
-      return &this->c;
-}
-
 void main(Fibonacci* this) {
-#ifdef MORE_DEBUG
-      sout | "Starting main of coroutine " | this | endl;
-      sout | "Started from " | this->c.last | endl;
-#endif
       int fn1, fn2;             // retained between resumes
       this->fn = 0;
@@ -45 +36 @@
 int main() {
       Fibonacci f1, f2;
-#ifdef MORE_DEBUG      
-      Fibonacci *pf1 = &f1, *pf2 = &f2;
-      coroutine_desc *cf1 = &f1.c, *cf2 = &f2.c;
-      covptr_t  *vf1 = vtable(pf1), *vf2 = vtable(pf2);
-      coroutine_desc *cv1 = get_coroutine(vf1), *cv2 = get_coroutine(vf2);
-      Fibonacci *ov1 = (Fibonacci *)get_object(vf1), *ov2 = (Fibonacci *)get_object(vf2);
-
-      sout | "User coroutines : " | pf1 | ' ' | pf2 | endl;
-      sout | "Coroutine data  : " | cf1 | ' ' | cf2 | endl;
-      sout | "Vptr address    : " | vf1 | ' ' | vf2 | endl;
-      sout | "Vptr obj data   : " | ov1 | ' ' | ov2 | endl;
-      sout | "Vptr cor data   : " | cv1 | ' ' | cv2 | endl;
-#endif
       for ( int i = 1; i <= 10; i += 1 ) {
             sout | next(&f1) | ' ' | next(&f2) | endl;

src/tests/dtor-early-exit.c

@@ -28 +28 @@
 // don't want these called
 void ?{}(A * a) { assert( false ); }
-void ?{}(A * a, char * name) { a->name = name; sout | "construct " | name | endl; a->x = (int*)malloc(); }
-void ?{}(A * a, char * name, int * ptr) { assert( false ); }
+void ?{}(A * a, const char * name) { a->name = name; sout | "construct " | name | endl; a->x = (int*)malloc(); }
+void ?{}(A * a, const char * name, int * ptr) { assert( false ); }
 
 A ?=?(A * a, A a) {  sout | "assign " | a->name | " " | a.name; return a; }

src/tests/monitor.c

@@ -13 +13 @@
 }
 
+monitor_desc * get_monitor( global_t * this ) {
+        return &this->m;
+}
+
 static global_t global;
 
-void increment( /*mutex*/ global_t * this ) {
-        monitor_desc * mon = &this->m;
-        monitor_guard_t g1 = { &mon };
-        {
-                monitor_guard_t g2 = { &mon };
-                {
-                        monitor_guard_t g3 = { &mon };
-                        this->value += 1;
-                }
-        }
+void increment3( global_t * mutex this ) {
+        this->value += 1;
 }
 
-struct MyThread { thread_desc t; };
+void increment2( global_t * mutex this ) {
+        increment3( this );
+}
+
+void increment( global_t * mutex this ) {
+        increment2( this );
+}
+
+struct MyThread { thread_desc __thrd; };
 
 DECL_THREAD(MyThread);
 
 void ?{}( MyThread * this ) {}
+void ^?{}( MyThread * mutex this ) {}
 
 void main( MyThread* this ) {
-        for(int i = 0; i < 1000000; i++) {
+        for(int i = 0; i < 1_000_000; i++) {
                 increment( &global );
         }

src/tests/multi-monitor.c

@@ -6 +6 @@
 static int global12, global23, global13;
 
-static monitor_desc m1, m2, m3;
+struct monitor_t {
+        monitor_desc m;
+};
 
-void increment( /*mutex*/ monitor_desc * p1, /*mutex*/ monitor_desc * p2, int * value ) {
-        monitor_desc * mons[] = { p1, p2 };
-        monitor_guard_t g = { mons, 2 };
+monitor_desc * get_monitor( monitor_t * this ) {
+        return &this->m;
+}
+
+static monitor_t m1, m2, m3;
+
+void increment( monitor_t * mutex p1, monitor_t * mutex p2, int * value ) {
         *value += 1;
 }
 
 struct MyThread { 
-        thread_desc t; 
+        thread_desc __thrd; 
         int target;
 };
@@ -24 +30 @@
         this->target = target;
 }
+
+void ^?{}( MyThread * mutex this ) {}
 
 void main( MyThread* this ) {

src/tests/thread.c

@@ -4 +4 @@
 #include <thread>
 
-struct First { thread_desc t; signal_once* lock; };
-struct Second { thread_desc t; signal_once* lock; };
+struct First { thread_desc __thrd; signal_once* lock; };
+struct Second { thread_desc __thrd; signal_once* lock; };
 
 DECL_THREAD(First);
@@ -12 +12 @@
 void ?{}( First * this, signal_once* lock ) { this->lock = lock; }
 void ?{}( Second * this, signal_once* lock ) { this->lock = lock; }
+
+void ^?{}( First  * mutex this ) {}
+void ^?{}( Second * mutex this ) {}
 
 void main(First* this) {