Changes in / [9d264e18:d6ad99e]

Files:

• benchmark/rmit.py (modified) (3 diffs)
• doc/theses/andrew_beach_MMath/features.tex (deleted)
• 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) (8 diffs)
• src/AST/Convert.cpp (modified) (3 diffs)
• src/AST/Pass.impl.hpp (modified) (1 diff)
• src/AST/Pass.proto.hpp (modified) (1 diff)
• src/InitTweak/GenInit.cc (modified) (1 diff)
• src/ResolvExpr/Resolver.cc (modified) (2 diffs)
• src/main.cc (modified) (1 diff)
• 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
@@ -118 +117 @@
         # ================================================================================
         # parse command line arguments
-        formats = ['raw', 'csv', 'json']
+        formats = ['raw', 'csv']
         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='json')
+        parser.add_argument('--format', help='How to print the result', choices=formats, default='csv')
         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)
@@ -204 +203 @@
 
         # ================================================================================
-        # Print raw
+        # Print csv
         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 ?{}( single_acquisition_lock & this ) {
+void ?{}( mutex_lock & this ) {
         ((blocking_lock &)this){ false, false };
 }
 
-void ^?{}( single_acquisition_lock & this ) {
+void ^?{}( mutex_lock & this ) {
         // default
 }
@@ -67 +67 @@
 }
 
-void ?{}( multiple_acquisition_lock & this ) {
+void ?{}( recursive_mutex_lock & this ) {
         ((blocking_lock &)this){ true, false };
 }
 
-void ^?{}( multiple_acquisition_lock & this ) {
+void ^?{}( recursive_mutex_lock & this ) {
         // default
 }
 
 void lock( blocking_lock & this ) with( this ) {
+        $thread * thrd = active_thread();
         lock( lock __cfaabi_dbg_ctx2 );
-        if ( owner == active_thread() && !multi_acquisition) {
+        if ( owner == thrd && !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 != active_thread() ) {
-                append( blocked_threads, active_thread() );
+        } else if ( owner != 0p && owner != thrd ) {
+                append( blocked_threads, thrd );
                 wait_count++;
                 unlock( lock );
                 park( );
-        } else if ( owner == active_thread() && multi_acquisition ) {
+        } else if ( owner == thrd && multi_acquisition ) {
                 recursion_count++;
                 unlock( lock );
         } else {
-                owner = active_thread();
+                owner = thrd;
                 recursion_count = 1;
                 unlock( lock );
@@ -96 +97 @@
 
 bool try_lock( blocking_lock & this ) with( this ) {
+        $thread * thrd = active_thread();
         bool ret = false;
         lock( lock __cfaabi_dbg_ctx2 );
         if ( owner == 0p ) {
-                owner = active_thread();
-                recursion_count = 1;
+                owner = thrd;
+                if ( multi_acquisition ) recursion_count = 1;
                 ret = true;
-        } else if ( owner == active_thread() && multi_acquisition ) {
+        } else if ( owner == thrd && multi_acquisition ) {
                 recursion_count++;
                 ret = true;
@@ -113 +115 @@
         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 && owner != active_thread() ) {
-                fprintf( stderr, "A thread other than the owner attempted to release an owner lock" ); 
+        } else if ( strict_owner && active_thread() ) {
+                fprintf( stderr, "A thread other than the owner attempted to release an owner lock" );
                 return;
         }
@@ -123 +125 @@
                 $thread * thrd = pop_head( blocked_threads );
                 owner = thrd;
-                recursion_count = ( thrd ? 1 : 0 );
+                recursion_count = ( thrd && multi_acquisition ? 1 : 0 );
                 wait_count--;
                 unpark( thrd );
@@ -151 +153 @@
         } else {
                 owner = t;
-                recursion_count = 1;
+                if ( multi_acquisition ) 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 );
@@ -163 +165 @@
     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 && 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 && 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 ? 1 : 0 );
+                recursion_count = ( thrd && multi_acquisition ? 1 : 0 );
                 wait_count--;
                 unpark( thrd );
@@ -182 +184 @@
 // This is temporary until an inheritance bug is fixed
 
-void lock( single_acquisition_lock & this ){
+void lock( mutex_lock & this ){
         lock( (blocking_lock &)this );
 }
 
-void unlock( single_acquisition_lock & this ){
+void unlock( mutex_lock & this ){
         unlock( (blocking_lock &)this );
 }
 
-void add_( single_acquisition_lock & this, struct $thread * t ){
+void add_( mutex_lock & this, struct $thread * t ){
         add_( (blocking_lock &)this, t );
 }
 
-void remove_( single_acquisition_lock & this ){
+void remove_( mutex_lock & this ){
         remove_( (blocking_lock &)this );
 }
 
-void set_recursion_count( single_acquisition_lock & this, size_t recursion ){
+void set_recursion_count( mutex_lock & this, size_t recursion ){
         set_recursion_count( (blocking_lock &)this, recursion );
 }
 
-size_t get_recursion_count( single_acquisition_lock & this ){
-        return get_recursion_count( (blocking_lock &)this );
-}
-
-void lock( owner_lock & this ){
+size_t get_recursion_count( mutex_lock & this ){
+        get_recursion_count( (blocking_lock &)this );
+}
+
+void lock( recursive_mutex_lock & this ){
         lock( (blocking_lock &)this );
 }
 
-void unlock( owner_lock & this ){
+void unlock( recursive_mutex_lock & this ){
         unlock( (blocking_lock &)this );
 }
 
-void add_( owner_lock & this, struct $thread * t ){
+void add_( recursive_mutex_lock & this, struct $thread * t ){
         add_( (blocking_lock &)this, t );
 }
 
-void remove_( owner_lock & this ){
+void remove_( recursive_mutex_lock & this ){
         remove_( (blocking_lock &)this );
 }
 
-void set_recursion_count( owner_lock & this, size_t recursion ){
+void set_recursion_count( recursive_mutex_lock & this, size_t recursion ){
         set_recursion_count( (blocking_lock &)this, recursion );
 }
 
-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 );
+size_t get_recursion_count( recursive_mutex_lock & this ){
+        get_recursion_count( (blocking_lock &)this );
 }
 
@@ -266 +244 @@
                 info_thread(L) * copy = *i;
                         remove( cond->blocked_threads, i );              //remove this thread O(1)
-                        cond->count--;
+                        cond->wait_count--;
                         if( !copy->lock ) {
+                                unlock( cond->lock );
                                 #if !defined( __CFA_NO_STATISTICS__ )
-                                        //kernelTLS.this_stats = copy->t->curr_cluster->stats;
+                                        #warning unprotected access to tls TODO discuss this
+                                        kernelTLS.this_stats = copy->t->curr_cluster->stats;
                                 #endif
                                 unpark( copy->t );
@@ -305 +285 @@
                 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) {
@@ -323 +303 @@
                 while( blocked_threads ) {
                         info_thread(L) * popped = pop_head( blocked_threads );
+                        popped->listed = false;
                         if(popped != 0p){
-                                popped->listed = false;
                                 count--;
                                 if (popped->lock) {
@@ -361 +341 @@
                         remove_( *i.lock );
                 }
-                
+
                 unlock( lock );
                 park( ); // blocks here
@@ -405 +385 @@
                 queue_info_thread( this, i );
         }
-        
+
         void wait( condition_variable(L) & this, Duration duration ) with(this) {
                 info_thread( L ) i = { active_thread() };
@@ -411 +391 @@
         }
 
-        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 );
@@ -437 +417 @@
                 queue_info_thread( this, i );
         }
-        
+
         void wait( condition_variable(L) & this, L & l, Duration duration ) with(this) {
                 info_thread(L) i = { active_thread() };
@@ -443 +423 @@
                 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 };
@@ -449 +429 @@
                 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() };
@@ -455 +435 @@
                 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 };
@@ -462 +442 @@
         }
 }
-
-// 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
@@ -73 +72 @@
 };
 
-struct single_acquisition_lock {
+struct mutex_lock {
         inline blocking_lock;
 };
@@ -81 +80 @@
 };
 
-struct multiple_acquisition_lock {
+struct recursive_mutex_lock {
         inline blocking_lock;
 };
@@ -88 +87 @@
 void ^?{}( blocking_lock & this );
 
-void ?{}( single_acquisition_lock & this );
-void ^?{}( single_acquisition_lock & this );
+void ?{}( mutex_lock & this );
+void ^?{}( mutex_lock & this );
 
 void ?{}( owner_lock & this );
 void ^?{}( owner_lock & this );
 
-void ?{}( multiple_acquisition_lock & this );
-void ^?{}( multiple_acquisition_lock & this );
+void ?{}( recursive_mutex_lock & this );
+void ^?{}( recursive_mutex_lock & this );
 
 void lock( blocking_lock & this );
@@ -106 +105 @@
 size_t get_recursion_count( blocking_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( 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( 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 );
+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 );
 
 ///////////////////////////////////////////////////////////////////

libcfa/src/stdlib.cfa

@@ -10 +10 @@
 // Created On       : Thu Jan 28 17:10:29 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Nov 12 07:46:09 2020
-// Update Count     : 503
+// Last Modified On : Sun Jul 19 15:05:28 2020
+// Update Count     : 501
 //
 
@@ -26 +26 @@
 //---------------------------------------
 
-// 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 ) {
+// 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 ) {
         T * arr = alloc( dim );
         for ( unsigned int i = 0; i < dim; i += 1 ) {
@@ -48 +68 @@
 } // adelete
 
-forall( dtype T | sized(T) | { void ^?{}( T & ); }, ttype TT | { void adelete( TT ); } )
-void adelete( T arr[], TT rest ) {
+forall( dtype T | sized(T) | { void ^?{}( T & ); }, ttype Params | { void adelete( Params ); } )
+void adelete( T arr[], Params 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 : Thu Nov 12 08:12:08 2020
-// Update Count     : 515
+// Last Modified On : Tue Sep  1 20:32:34 2020
+// Update Count     : 505
 //
 
 #pragma once
 
-#include "bits/defs.hfa"                                                                // OPTIONAL_THREAD
-#include "bits/align.hfa"                                                               // libAlign
+#include "bits/defs.hfa"
+#include "bits/align.hfa"
 
 #include <stdlib.h>                                                                             // *alloc, strto*, ato*
@@ -107 +107 @@
 } // 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
+
 /*
         FIX ME : fix alloc interface after Ticker Number 214 is resolved, define and add union to S_fill. Then, modify postfix-fill functions to support T * with nmemb, char, and T object of any size. Finally, change alloc_internal.
@@ -114 +129 @@
                 forall( dtype T | sized(T) ) {
                         union  U_fill           { char c; T * a; T t; };
-                        struct S_fill           { char tag; U_fill(T) fill; };
+                        struct S_fill           { char tag; char c; size_t size; T * at; char t[50]; };
                         struct S_realloc        { inline T *; };
                 }
@@ -162 +177 @@
 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' };
@@ -235 +250 @@
 
         } // distribution TT
+
 } // distribution T
 
@@ -246 +262 @@
                 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 ) {
@@ -257 +275 @@
 } // 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
-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
+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 );
 
 // 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 );
+forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * anew( size_t dim, Params p );
 forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void adelete( T arr[] );
-forall( dtype T | sized(T) | { void ^?{}( T & ); }, ttype TT | { void adelete( TT ); } ) void adelete( T arr[], TT rest );
+forall( dtype T | sized(T) | { void ^?{}( T & ); }, ttype Params | { void adelete( Params ); } ) void adelete( T arr[], Params rest );
 
 //---------------------------------------
@@ -383 +379 @@
 //---------------------------------------
 
-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 : Andrew Beach
-// Last Modified On : Thr Nov 12 10:07:00 2020
-// Update Count     : 34
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Wed Dec 11 21:39:32 2019
+// Update Count     : 33
 //
 
@@ -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;
 }

src/AST/Pass.impl.hpp

@@ -423 +423 @@
                 }
                 catch( SemanticErrorException &e ) {
-                        if (__pass::on_error (visitor.core, *i, 0))
+                        if (__pass::onError (visitor.core, *i, 0))
                                 errors.append( e );
                 }

src/AST/Pass.proto.hpp

@@ -270 +270 @@
 
         template< typename core_t >
-        static bool on_error (core_t &, ptr<Decl> &, long) { return true; }
-
-        template< typename core_t >
-        static auto on_error (core_t & core, ptr<Decl> & decl, int) -> decltype(core.on_error(decl)) {
-                return core.on_error(decl); 
+        static bool onError (core_t &, ptr<Decl> &, long) { return true; }
+
+        template< typename core_t >
+        static auto onError (core_t & core, ptr<Decl> & decl, int) -> decltype(core.onError(decl)) {
+                return core.onError(decl); 
         }
 

src/InitTweak/GenInit.cc

@@ -202 +202 @@
                         }
                         // don't need to hoist dimension if it's definitely pure - only need to if there's potential for side effects.
-                        // xxx - hoisting has no side effects anyways, so don't skip since we delay resolve
-                        // still try to detect constant expressions
-                        if ( ! Tuples::maybeImpure( arrayType->dimension ) ) return;
+                        // xxx - hoisting has no side effects anyways, so don't skip since we delay resolve     
+                        // only skip in the most trivial case, which does not require resolve
+                        if (dynamic_cast<ConstantExpr *>(arrayType->dimension)) return;
+                        // if ( ! Tuples::maybeImpure( arrayType->dimension ) ) return;
 
                         ObjectDecl * arrayDimension = new ObjectDecl( dimensionName.newName(), storageClasses, LinkageSpec::C, 0, Validate::SizeType->clone(), new SingleInit( arrayType->get_dimension() ) );

src/ResolvExpr/Resolver.cc

@@ -1289 +1289 @@
                 void beginScope() { managedTypes.beginScope(); }
                 void endScope() { managedTypes.endScope(); }
-                bool on_error(ast::ptr<ast::Decl> & decl);
+                bool onError(ast::ptr<ast::Decl> & decl);
         };
         // size_t Resolver_new::traceId = Stats::Heap::new_stacktrace_id("Resolver");
@@ -2068 +2068 @@
 
         // suppress error on autogen functions and mark invalid autogen as deleted.
-        bool Resolver_new::on_error(ast::ptr<ast::Decl> & decl) {
+        bool Resolver_new::onError(ast::ptr<ast::Decl> & decl) {
                 if (auto functionDecl = decl.as<ast::FunctionDecl>()) {
                         // xxx - can intrinsic gen ever fail?

src/main.cc

@@ -341 +341 @@
 
                 if( useNewAST) {
-                        if (Stats::Counters::enabled) {
-                                ast::pass_visitor_stats.avg = Stats::Counters::build<Stats::Counters::AverageCounter<double>>("Average Depth - New");
-                                ast::pass_visitor_stats.max = Stats::Counters::build<Stats::Counters::MaxCounter<double>>("Max depth - New");
-                        }
                         auto transUnit = convert( move( translationUnit ) );
                         PASS( "Resolve", ResolvExpr::resolve( transUnit ) );

tests/.expect/alloc-ERROR.txt

@@ -1 @@
-alloc.cfa:382:1 error: No reasonable alternatives for expression Applying untyped:
+alloc.cfa:361:1 error: No reasonable alternatives for expression Applying untyped:
   Name: ?=?
 ...to:
@@ -19 +19 @@
 
 
-alloc.cfa:383:1 error: No reasonable alternatives for expression Applying untyped:
+alloc.cfa:362:1 error: No reasonable alternatives for expression Applying untyped:
   Name: ?=?
 ...to:
@@ -30 +30 @@
 
 
-alloc.cfa:384:1 error: No reasonable alternatives for expression Applying untyped:
+alloc.cfa:363: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 : Thu Nov 12 10:02:18 2020
-// Update Count     : 432
+// Last Modified On : Fri Oct  9 23:03:11 2020
+// Update Count     : 431
 //
 
@@ -375 +375 @@
         dp = alloc(5.0`fill); // just for testing multiple free
         assert(*dp == 5.0);
-        free( ip, dp, 0p );
+        free( ip, dp );
 
 #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 ) ) );
@@ -174 +177 @@
         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;
@@ -313 +316 @@
         }
 
+
         // int128 constants (and printing)
         int128 v = 0xffff_ffffffff_ffffffff_L128 + 0xffffffff_ffffffff_ffffffff_ffffffff_L128;