Changeset 8ca26d5

Timestamp:

Nov 12, 2020, 1:26:38 PM (4 years ago)

Author:

Fangren Yu <f37yu@…>

Branches:

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

Children:

0989e79, 9d264e18, f2ccbfd

Parents:

3746f777 (diff), 0b996a1 (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 plg.uwaterloo.ca:software/cfa/cfa-cc

Files:

• benchmark/rmit.py (modified) (3 diffs)
• doc/theses/andrew_beach_MMath/features.tex (added)
• libcfa/src/Makefile.am (modified) (1 diff)
• libcfa/src/concurrency/locks.cfa (modified) (19 diffs)
• libcfa/src/concurrency/locks.hfa (modified) (5 diffs)
• libcfa/src/stdlib.cfa (modified) (3 diffs)
• libcfa/src/stdlib.hfa (modified) (7 diffs)
• src/AST/Convert.cpp (modified) (3 diffs)
• tests/.expect/alloc-ERROR.txt (modified) (3 diffs)
• tests/alloc.cfa (modified) (2 diffs)
• tests/malloc.cfa (modified) (2 diffs)
• tests/manipulatorsOutput3.cfa (modified) (3 diffs)

benchmark/rmit.py

@@ -12 +12 @@
 import datetime
 import itertools
+import json
 import os
 import random
@@ -117 +118 @@
         # ================================================================================
         # parse command line arguments
-        formats = ['raw', 'csv']
+        formats = ['raw', 'csv', 'json']
         parser = argparse.ArgumentParser(description='Python Script to implement R.M.I.T. testing : Randomized Multiple Interleaved Trials')
         parser.add_argument('--list', help='List all the commands that would be run', action='store_true')
-        parser.add_argument('--format', help='How to print the result', choices=formats, default='csv')
+        parser.add_argument('--format', help='How to print the result', choices=formats, default='json')
         parser.add_argument('--file', nargs='?', type=argparse.FileType('w'), default=sys.stdout)
         parser.add_argument('-t', '--trials', help='Number of trials to run per combinaison', type=int, default=3)
@@ -203 +204 @@
 
         # ================================================================================
-        # Print csv
+        # Print raw
         if options.format == 'raw':
                 for r in result:
                         print(r, file=options.file)
+                sys.exit(0)
+
+        # ================================================================================
+        # Print json
+        if options.format == 'json':
+                json.dump(result, options.file)
                 sys.exit(0)
 

libcfa/src/Makefile.am

@@ -96 +96 @@
         concurrency/exception.hfa \
         concurrency/kernel.hfa \
+        concurrency/locks.hfa \
         concurrency/monitor.hfa \
         concurrency/mutex.hfa \

libcfa/src/concurrency/locks.cfa

@@ -51 +51 @@
 }
 
-void ?{}( mutex_lock & this ) {
+void ?{}( single_acquisition_lock & this ) {
         ((blocking_lock &)this){ false, false };
 }
 
-void ^?{}( mutex_lock & this ) {
+void ^?{}( single_acquisition_lock & this ) {
         // default
 }
@@ -67 +67 @@
 }
 
-void ?{}( recursive_mutex_lock & this ) {
+void ?{}( multiple_acquisition_lock & this ) {
         ((blocking_lock &)this){ true, false };
 }
 
-void ^?{}( recursive_mutex_lock & this ) {
+void ^?{}( multiple_acquisition_lock & this ) {
         // default
 }
 
 void lock( blocking_lock & this ) with( this ) {
-        $thread * thrd = active_thread();
         lock( lock __cfaabi_dbg_ctx2 );
-        if ( owner == thrd && !multi_acquisition) {
+        if ( owner == active_thread() && !multi_acquisition) {
                 fprintf(stderr, "A single acquisition lock holder attempted to reacquire the lock resulting in a deadlock."); // Possibly throw instead
         exit(EXIT_FAILURE);
-        } else if ( owner != 0p && owner != thrd ) {
-                append( blocked_threads, thrd );
+        } else if ( owner != 0p && owner != active_thread() ) {
+                append( blocked_threads, active_thread() );
                 wait_count++;
                 unlock( lock );
                 park( );
-        } else if ( owner == thrd && multi_acquisition ) {
+        } else if ( owner == active_thread() && multi_acquisition ) {
                 recursion_count++;
                 unlock( lock );
         } else {
-                owner = thrd;
+                owner = active_thread();
                 recursion_count = 1;
                 unlock( lock );
@@ -97 +96 @@
 
 bool try_lock( blocking_lock & this ) with( this ) {
-        $thread * thrd = active_thread();
         bool ret = false;
         lock( lock __cfaabi_dbg_ctx2 );
         if ( owner == 0p ) {
-                owner = thrd;
-                if ( multi_acquisition ) recursion_count = 1;
+                owner = active_thread();
+                recursion_count = 1;
                 ret = true;
-        } else if ( owner == thrd && multi_acquisition ) {
+        } else if ( owner == active_thread() && multi_acquisition ) {
                 recursion_count++;
                 ret = true;
@@ -115 +113 @@
         lock( lock __cfaabi_dbg_ctx2 );
         if ( owner == 0p ){ // no owner implies lock isn't held
-                fprintf( stderr, "There was an attempt to release a lock that isn't held" );
+                fprintf( stderr, "There was an attempt to release a lock that isn't held" ); 
                 return;
-        } else if ( strict_owner && active_thread() ) {
-                fprintf( stderr, "A thread other than the owner attempted to release an owner lock" );
+        } else if ( strict_owner && owner != active_thread() ) {
+                fprintf( stderr, "A thread other than the owner attempted to release an owner lock" ); 
                 return;
         }
@@ -125 +123 @@
                 $thread * thrd = pop_head( blocked_threads );
                 owner = thrd;
-                recursion_count = ( thrd && multi_acquisition ? 1 : 0 );
+                recursion_count = ( thrd ? 1 : 0 );
                 wait_count--;
                 unpark( thrd );
@@ -153 +151 @@
         } else {
                 owner = t;
-                if ( multi_acquisition ) recursion_count = 1;
+                recursion_count = 1;
                 #if !defined( __CFA_NO_STATISTICS__ )
-                        kernelTLS.this_stats = t->curr_cluster->stats;
+                        //kernelTLS.this_stats = t->curr_cluster->stats;
                 #endif
                 unpark( t );
@@ -165 +163 @@
     lock( lock __cfaabi_dbg_ctx2 );
         if ( owner == 0p ){ // no owner implies lock isn't held
-                fprintf( stderr, "A lock that is not held was passed to a synchronization lock" );
-        } else if ( strict_owner && active_thread() ) {
-                fprintf( stderr, "A thread other than the owner of a lock passed it to a synchronization lock" );
+                fprintf( stderr, "A lock that is not held was passed to a synchronization lock" ); 
+        } else if ( strict_owner && owner != active_thread() ) {
+                fprintf( stderr, "A thread other than the owner of a lock passed it to a synchronization lock" ); 
         } else {
                 $thread * thrd = pop_head( blocked_threads );
                 owner = thrd;
-                recursion_count = ( thrd && multi_acquisition ? 1 : 0 );
+                recursion_count = ( thrd ? 1 : 0 );
                 wait_count--;
                 unpark( thrd );
@@ -184 +182 @@
 // This is temporary until an inheritance bug is fixed
 
-void lock( mutex_lock & this ){
+void lock( single_acquisition_lock & this ){
         lock( (blocking_lock &)this );
 }
 
-void unlock( mutex_lock & this ){
+void unlock( single_acquisition_lock & this ){
         unlock( (blocking_lock &)this );
 }
 
-void add_( mutex_lock & this, struct $thread * t ){
+void add_( single_acquisition_lock & this, struct $thread * t ){
         add_( (blocking_lock &)this, t );
 }
 
-void remove_( mutex_lock & this ){
+void remove_( single_acquisition_lock & this ){
         remove_( (blocking_lock &)this );
 }
 
-void set_recursion_count( mutex_lock & this, size_t recursion ){
+void set_recursion_count( single_acquisition_lock & this, size_t recursion ){
         set_recursion_count( (blocking_lock &)this, recursion );
 }
 
-size_t get_recursion_count( mutex_lock & this ){
-        get_recursion_count( (blocking_lock &)this );
-}
-
-void lock( recursive_mutex_lock & this ){
+size_t get_recursion_count( single_acquisition_lock & this ){
+        return get_recursion_count( (blocking_lock &)this );
+}
+
+void lock( owner_lock & this ){
         lock( (blocking_lock &)this );
 }
 
-void unlock( recursive_mutex_lock & this ){
+void unlock( owner_lock & this ){
         unlock( (blocking_lock &)this );
 }
 
-void add_( recursive_mutex_lock & this, struct $thread * t ){
+void add_( owner_lock & this, struct $thread * t ){
         add_( (blocking_lock &)this, t );
 }
 
-void remove_( recursive_mutex_lock & this ){
+void remove_( owner_lock & this ){
         remove_( (blocking_lock &)this );
 }
 
-void set_recursion_count( recursive_mutex_lock & this, size_t recursion ){
+void set_recursion_count( owner_lock & this, size_t recursion ){
         set_recursion_count( (blocking_lock &)this, recursion );
 }
 
-size_t get_recursion_count( recursive_mutex_lock & this ){
-        get_recursion_count( (blocking_lock &)this );
+size_t get_recursion_count( owner_lock & this ){
+        return get_recursion_count( (blocking_lock &)this );
+}
+
+void lock( multiple_acquisition_lock & this ){
+        lock( (blocking_lock &)this );
+}
+
+void unlock( multiple_acquisition_lock & this ){
+        unlock( (blocking_lock &)this );
+}
+
+void add_( multiple_acquisition_lock & this, struct $thread * t ){
+        add_( (blocking_lock &)this, t );
+}
+
+void remove_( multiple_acquisition_lock & this ){
+        remove_( (blocking_lock &)this );
+}
+
+void set_recursion_count( multiple_acquisition_lock & this, size_t recursion ){
+        set_recursion_count( (blocking_lock &)this, recursion );
+}
+
+size_t get_recursion_count( multiple_acquisition_lock & this ){
+        return get_recursion_count( (blocking_lock &)this );
 }
 
@@ -244 +266 @@
                 info_thread(L) * copy = *i;
                         remove( cond->blocked_threads, i );              //remove this thread O(1)
-                        cond->wait_count--;
+                        cond->count--;
                         if( !copy->lock ) {
-                                unlock( cond->lock );
                                 #if !defined( __CFA_NO_STATISTICS__ )
-                                        #warning unprotected access to tls TODO discuss this
-                                        kernelTLS.this_stats = copy->t->curr_cluster->stats;
+                                        //kernelTLS.this_stats = copy->t->curr_cluster->stats;
                                 #endif
                                 unpark( copy->t );
@@ -285 +305 @@
                 bool ret = !!blocked_threads;
                 info_thread(L) * popped = pop_head( blocked_threads );
-                popped->listed = false;
                 if(popped != 0p) {
+                        popped->listed = false;
                         count--;
                         if (popped->lock) {
@@ -303 +323 @@
                 while( blocked_threads ) {
                         info_thread(L) * popped = pop_head( blocked_threads );
-                        popped->listed = false;
                         if(popped != 0p){
+                                popped->listed = false;
                                 count--;
                                 if (popped->lock) {
@@ -341 +361 @@
                         remove_( *i.lock );
                 }
-
+                
                 unlock( lock );
                 park( ); // blocks here
@@ -385 +405 @@
                 queue_info_thread( this, i );
         }
-
+        
         void wait( condition_variable(L) & this, Duration duration ) with(this) {
                 info_thread( L ) i = { active_thread() };
@@ -391 +411 @@
         }
 
-        void wait( condition_variable(L) & this, uintptr_t info, Duration duration ) with(this) {
+        void wait( condition_variable(L) & this, uintptr_t info, Duration duration ) with(this) { 
                 info_thread( L ) i = { active_thread(), info };
                 queue_info_thread_timeout(this, i, __kernel_get_time() + duration );
@@ -417 +437 @@
                 queue_info_thread( this, i );
         }
-
+        
         void wait( condition_variable(L) & this, L & l, Duration duration ) with(this) {
                 info_thread(L) i = { active_thread() };
@@ -423 +443 @@
                 queue_info_thread_timeout(this, i, __kernel_get_time() + duration );
         }
-
+        
         void wait( condition_variable(L) & this, L & l, uintptr_t info, Duration duration ) with(this) {
                 info_thread(L) i = { active_thread(), info };
@@ -429 +449 @@
                 queue_info_thread_timeout(this, i, __kernel_get_time() + duration );
         }
-
+        
         void wait( condition_variable(L) & this, L & l, Time time ) with(this) {
                 info_thread(L) i = { active_thread() };
@@ -435 +455 @@
                 queue_info_thread_timeout(this, i, time );
         }
-
+        
         void wait( condition_variable(L) & this, L & l, uintptr_t info, Time time ) with(this) {
                 info_thread(L) i = { active_thread(), info };
@@ -442 +462 @@
         }
 }
+
+// thread T1 {};
+// thread T2 {};
+
+// multiple_acquisition_lock m;
+// condition_variable( multiple_acquisition_lock ) c;
+
+// void main( T1 & this ) {
+//      printf("T1 start\n");
+//      lock(m);
+//      printf("%d\n", counter(c));
+//      if(empty(c)) {
+//              printf("T1 wait\n");
+//              wait(c,m,12);
+//      }else{
+//              printf("%d\n", front(c));
+//              notify_one(c);
+//      }
+//      unlock(m);
+//      printf("curr thd in main %p \n", active_thread());
+//      printf("T1 waits for 2s\n");
+//      lock(m);
+//      wait( c, m, 2`s );
+//      unlock(m);
+//      printf("T1 wakes\n");
+//      printf("T1 done\n");
+// }
+
+// void main( T2 & this ) {
+//      printf("T2 start\n");
+//      lock(m);
+//      printf("%d\n", counter(c));
+//      if(empty(c)) {
+//              printf("T2 wait\n");
+//              wait(c,m,12);
+//      }else{
+//              printf("%d\n", front(c));
+//              notify_one(c);
+//      }
+//      unlock(m);
+//      printf("T2 done\n");
+// }
+
+// int main() {
+//      printf("start\n");
+//      processor p[2];
+//      {
+//              T1 t1;
+//              T2 t2;
+//      }
+//      printf("done\n");
+// }

libcfa/src/concurrency/locks.hfa

@@ -49 +49 @@
 //// Blocking Locks
 ///////////////////////////////////////////////////////////////////
+
 struct blocking_lock {
         // Spin lock used for mutual exclusion
@@ -72 +73 @@
 };
 
-struct mutex_lock {
+struct single_acquisition_lock {
         inline blocking_lock;
 };
@@ -80 +81 @@
 };
 
-struct recursive_mutex_lock {
+struct multiple_acquisition_lock {
         inline blocking_lock;
 };
@@ -87 +88 @@
 void ^?{}( blocking_lock & this );
 
-void ?{}( mutex_lock & this );
-void ^?{}( mutex_lock & this );
+void ?{}( single_acquisition_lock & this );
+void ^?{}( single_acquisition_lock & this );
 
 void ?{}( owner_lock & this );
 void ^?{}( owner_lock & this );
 
-void ?{}( recursive_mutex_lock & this );
-void ^?{}( recursive_mutex_lock & this );
+void ?{}( multiple_acquisition_lock & this );
+void ^?{}( multiple_acquisition_lock & this );
 
 void lock( blocking_lock & this );
@@ -105 +106 @@
 size_t get_recursion_count( blocking_lock & this );
 
-void lock( mutex_lock & this );
-void unlock( mutex_lock & this );
-void add_( mutex_lock & this, struct $thread * t );
-void remove_( mutex_lock & this );
-void set_recursion_count( mutex_lock & this, size_t recursion );
-size_t get_recursion_count( mutex_lock & this );
+void lock( single_acquisition_lock & this );
+void unlock( single_acquisition_lock & this );
+void add_( single_acquisition_lock & this, struct $thread * t );
+void remove_( single_acquisition_lock & this );
+void set_recursion_count( single_acquisition_lock & this, size_t recursion );
+size_t get_recursion_count( single_acquisition_lock & this );
 
-void lock( recursive_mutex_lock & this );
-void unlock( recursive_mutex_lock & this );
-void add_( recursive_mutex_lock & this, struct $thread * t );
-void remove_( recursive_mutex_lock & this );
-void set_recursion_count( recursive_mutex_lock & this, size_t recursion );
-size_t get_recursion_count( recursive_mutex_lock & this );
+void lock( owner_lock & this );
+void unlock( owner_lock & this );
+void add_( owner_lock & this, struct $thread * t );
+void remove_( owner_lock & this );
+void set_recursion_count( owner_lock & this, size_t recursion );
+size_t get_recursion_count( owner_lock & this );
+
+void lock( multiple_acquisition_lock & this );
+void unlock( multiple_acquisition_lock & this );
+void add_( multiple_acquisition_lock & this, struct $thread * t );
+void remove_( multiple_acquisition_lock & this );
+void set_recursion_count( multiple_acquisition_lock & this, size_t recursion );
+size_t get_recursion_count( multiple_acquisition_lock & this );
 
 ///////////////////////////////////////////////////////////////////

libcfa/src/stdlib.cfa

@@ -10 +10 @@
 // Created On       : Thu Jan 28 17:10:29 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Jul 19 15:05:28 2020
-// Update Count     : 501
+// Last Modified On : Thu Nov 12 07:46:09 2020
+// Update Count     : 503
 //
 
@@ -26 +26 @@
 //---------------------------------------
 
-// allocation/deallocation and constructor/destructor, non-array types
-forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } )
-T * new( Params p ) {
-        return &(*malloc()){ p };                                                       // run constructor
-} // new
-
-forall( dtype T | { void ^?{}( T & ); } )
-void delete( T * ptr ) {
-        if ( ptr ) {                                                                            // ignore null
-                ^(*ptr){};                                                                              // run destructor
-                free( ptr );
-        } // if
-} // delete
-
-forall( dtype T, ttype Params | { void ^?{}( T & ); void delete( Params ); } )
-void delete( T * ptr, Params rest ) {
-        delete( ptr );
-        delete( rest );
-} // delete
-
-
-// allocation/deallocation and constructor/destructor, array types
-forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } )
-T * anew( size_t dim, Params p ) {
+// Cforall allocation/deallocation and constructor/destructor, array types
+
+forall( dtype T | sized(T), ttype TT | { void ?{}( T &, TT ); } )
+T * anew( size_t dim, TT p ) {
         T * arr = alloc( dim );
         for ( unsigned int i = 0; i < dim; i += 1 ) {
@@ -68 +48 @@
 } // adelete
 
-forall( dtype T | sized(T) | { void ^?{}( T & ); }, ttype Params | { void adelete( Params ); } )
-void adelete( T arr[], Params rest ) {
+forall( dtype T | sized(T) | { void ^?{}( T & ); }, ttype TT | { void adelete( TT ); } )
+void adelete( T arr[], TT rest ) {
         if ( arr ) {                                                                            // ignore null
                 size_t dim = malloc_size( arr ) / sizeof( T );

libcfa/src/stdlib.hfa

@@ -10 +10 @@
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Sep  1 20:32:34 2020
-// Update Count     : 505
+// Last Modified On : Thu Nov 12 08:12:08 2020
+// Update Count     : 515
 //
 
 #pragma once
 
-#include "bits/defs.hfa"
-#include "bits/align.hfa"
+#include "bits/defs.hfa"                                                                // OPTIONAL_THREAD
+#include "bits/align.hfa"                                                               // libAlign
 
 #include <stdlib.h>                                                                             // *alloc, strto*, ato*
@@ -104 +104 @@
         void free( T * addr ) {
                 free( (void *) addr );                                                  // C free
-        } // free
-} // distribution
-
-static inline forall( ttype TT | { void free( TT ); } ) {
-        // T* does not take void* and vice-versa
-
-        void free( void * addr, TT rest ) {
-                free( addr );
-                free( rest );
-        } // free
-
-        forall( dtype T | sized(T) )
-        void free( T * addr, TT rest ) {
-                free( addr );
-                free( rest );
         } // free
 } // distribution
@@ -177 +162 @@
 static inline T_align   ?`align   ( size_t a )  { return (T_align){a}; }
 static inline T_resize  ?`resize  ( void * a )  { return (T_resize){a}; }
+
 static inline forall( dtype T | sized(T) ) {
-
         S_fill(T) ?`fill ( T t ) {
                 S_fill(T) ret = { 't' };
@@ -250 +235 @@
 
         } // distribution TT
-
 } // distribution T
 
@@ -262 +246 @@
                 return (T *)memcpy( dest, src, sizeof(T) );
         } // memcpy
-} // distribution
-
-static inline forall( dtype T | sized(T) ) {
+
         // Cforall safe initialization/copy, i.e., implicit size specification, array types
         T * amemset( T dest[], char fill, size_t dim ) {
@@ -275 +257 @@
 } // distribution
 
+// Cforall deallocation for multiple objects
+static inline forall( dtype T, ttype TT | { void free( TT ); } )
+void free( T * addr, TT rest ) {
+        free( addr );
+        free( rest );
+} // free
+
 // Cforall allocation/deallocation and constructor/destructor, non-array types
-forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * new( Params p );
-forall( dtype T | { void ^?{}( T & ); } ) void delete( T * ptr );
-forall( dtype T, ttype Params | { void ^?{}( T & ); void delete( Params ); } ) void delete( T * ptr, Params rest );
+static inline forall( dtype T | sized(T), ttype TT | { void ?{}( T &, TT ); } )
+T * new( TT p ) {
+        return &(*malloc()){ p };                                                       // run constructor
+} // new
+
+static inline forall( dtype T | { void ^?{}( T & ); } )
+void delete( T * ptr ) {
+        if ( ptr ) {                                                                            // ignore null
+                ^(*ptr){};                                                                              // run destructor
+                free( ptr );
+        } // if
+} // delete
+
+static inline forall( dtype T, ttype TT | { void ^?{}( T & ); void delete( TT ); } )
+void delete( T * ptr, TT rest ) {
+        delete( ptr );
+        delete( rest );
+} // delete
 
 // Cforall allocation/deallocation and constructor/destructor, array types
-forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * anew( size_t dim, Params p );
+forall( dtype T | sized(T), ttype TT | { void ?{}( T &, TT ); } ) T * anew( size_t dim, TT p );
 forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void adelete( T arr[] );
-forall( dtype T | sized(T) | { void ^?{}( T & ); }, ttype Params | { void adelete( Params ); } ) void adelete( T arr[], Params rest );
+forall( dtype T | sized(T) | { void ^?{}( T & ); }, ttype TT | { void adelete( TT ); } ) void adelete( T arr[], TT rest );
 
 //---------------------------------------
@@ -379 +383 @@
 //---------------------------------------
 
-extern bool threading_enabled(void) OPTIONAL_THREAD;
+extern bool threading_enabled( void ) OPTIONAL_THREAD;
 
 // Local Variables: //

src/AST/Convert.cpp

@@ -9 +9 @@
 // Author           : Thierry Delisle
 // Created On       : Thu May 09 15::37::05 2019
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Dec 11 21:39:32 2019
-// Update Count     : 33
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr Nov 12 10:07:00 2020
+// Update Count     : 34
 //
 
@@ -187 +187 @@
                 auto init = get<Initializer>().accept1( node->init );
                 decl->init = init;
-                
+
                 this->node = decl;
                 return nullptr;
@@ -2812 +2812 @@
         }
         deleteAll(translationUnit);
+
+        // Load the local static varables into the global store.
+        unit.global.sizeType = ast::sizeType;
+        unit.global.dereference = ast::dereferenceOperator;
+        unit.global.dtorStruct = ast::dtorStruct;
+        unit.global.dtorDestroy = ast::dtorStructDestroy;
+
         return unit;
 }

tests/.expect/alloc-ERROR.txt

@@ -1 @@
-alloc.cfa:361:1 error: No reasonable alternatives for expression Applying untyped:
+alloc.cfa:382:1 error: No reasonable alternatives for expression Applying untyped:
   Name: ?=?
 ...to:
@@ -19 +19 @@
 
 
-alloc.cfa:362:1 error: No reasonable alternatives for expression Applying untyped:
+alloc.cfa:383:1 error: No reasonable alternatives for expression Applying untyped:
   Name: ?=?
 ...to:
@@ -30 +30 @@
 
 
-alloc.cfa:363:1 error: No reasonable alternatives for expression Applying untyped:
+alloc.cfa:384:1 error: No reasonable alternatives for expression Applying untyped:
   Name: ?=?
 ...to:

tests/alloc.cfa

@@ -10 +10 @@
 // Created On       : Wed Feb  3 07:56:22 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Oct  9 23:03:11 2020
-// Update Count     : 431
+// Last Modified On : Thu Nov 12 10:02:18 2020
+// Update Count     : 432
 //
 
@@ -375 +375 @@
         dp = alloc(5.0`fill); // just for testing multiple free
         assert(*dp == 5.0);
-        free( ip, dp );
+        free( ip, dp, 0p );
 
 #ifdef ERR1

tests/malloc.cfa

@@ -319 +319 @@
         free(ip);
 
-        free( (void*) 0p ); // sanity check
+        free( (void *) 0p ); // sanity check
         free( NULL ); // sanity check
 
@@ -605 +605 @@
         return 0;
 }
+
+// Local Variables: //
+// tab-width: 4 //
+// compile-command: "cfa malloc.cfa" //
+// End: //

tests/manipulatorsOutput3.cfa

@@ -156 +156 @@
         sout | nl;
 
-        ui128 = 0x7fffffffffffffff;
-        ui128 <<= 64;
-        ui128 += 0xffffffffffffffff;
         sout | left( wd( 160, i128 ) );
         sout | left( sign( wd( 0, i128 ) ) );
@@ -177 +174 @@
         sout | left( wd( 160, bin( i128 ) ) );
         sout | left( sign( wd( 160, i128 ) ) );
-        sout | left( wd( 160, upcase(hex( i128 )) ) );
-        sout | left( wd( 160, upcase(oct( i128 ) )) );
-        sout | left( wd( 160, upcase(bin( i128 )) ) );
+        sout | left( wd( 160, upcase( hex( i128 ) ) ) );
+        sout | left( wd( 160, upcase( oct( i128 ) ) ) );
+        sout | left( wd( 160, upcase( bin( i128 ) ) ) );
 
         x = 1234;
@@ -316 +313 @@
         }
 
-
         // int128 constants (and printing)
         int128 v = 0xffff_ffffffff_ffffffff_L128 + 0xffffffff_ffffffff_ffffffff_ffffffff_L128;