Changeset 695e00d

doc/proposals/concurrency/Makefile

re149f77	r695e00d
22	22	monitor \
23	23	ext_monitor \
	24	int_monitor \
24	25	}}
25	26

doc/proposals/concurrency/annex/local.bib

-                      re149f77
+                      r695e00d
         title   = {Intel Thread Building Blocks},
+}
+@manual{www-cfa,
+        keywords        = {Cforall},
+        title   = {Cforall Programmming Language},
+        address = {https://plg.uwaterloo.ca/~cforall/}
+}
+@article{rob-thesis,
+        keywords        = {Constructors, Destructors, Tuples},
+        author  = {Rob Schluntz},
+        title   = {Resource Management and Tuples in Cforall},
+        year            = 2017
+}

doc/proposals/concurrency/style/cfa-format.tex

re149f77	r695e00d
166	166	xleftmargin=\parindentlnth, % indent code to paragraph indentation
167	167	moredelim=[is][\color{red}\bfseries]{R}{R}, % red highlighting
168		morekeywords=[2]{accept, signal, signal_block, wait},
	168	morekeywords=[2]{accept, signal, signal_block, wait, waitfor},
169	169	}
170	170

doc/proposals/concurrency/text/basics.tex

-                      re149f77
+                      r695e00d
 % ======================================================================
 % ======================================================================
 \chapter{Basics}
+\chapter{Basics}\label{basics}
 % ======================================================================
 % ======================================================================
 …
 \section{Coroutines: A stepping stone}\label{coroutine}
 While the main focus of this proposal is concurrency and parallelism, as mentionned above it is important to adress coroutines, which are actually a significant underlying aspect of a concurrency system. Indeed, while having nothing todo with parallelism and arguably little to do with concurrency, coroutines need to deal with context-switchs and and other context-management operations. Therefore, this proposal includes coroutines both as an intermediate step for the implementation of threads, and a first class feature of \CFA. Furthermore, many design challenges of threads are at least partially present in designing coroutines, which makes the design effort that much more relevant. The core API of coroutines revolve around two features: independent call stacks and \code{suspend}/\code{resume}.
+While the main focus of this proposal is concurrency and parallelism, as mentionned above it is important to adress coroutines, which are actually a significant underlying aspect of a concurrency system. Indeed, while having nothing to do with parallelism and arguably little to do with concurrency, coroutines need to deal with context-switchs and other context-management operations. Therefore, this proposal includes coroutines both as an intermediate step for the implementation of threads, and a first class feature of \CFA. Furthermore, many design challenges of threads are at least partially present in designing coroutines, which makes the design effort that much more relevant. The core API of coroutines revolve around two features: independent call stacks and \code{suspend}/\code{resume}.
 Here is an example of a solution to the fibonnaci problem using \CFA coroutines:
 …
         };
         void ?{}(Fibonacci* this) { // constructor
               this->fn = 0;
+        void ?{}(Fibonacci & this) { // constructor
+              this.fn = 0;
+        }
         // main automacically called on first resume
         void main(Fibonacci* this) {
+        void main(Fibonacci & this) {
                 int fn1, fn2;           // retained between resumes
                 this->fn = 0;
                 fn1 = this->fn;
+                this.fn = 0;
+                fn1 = this.fn;
                 suspend(this);          // return to last resume
                 this->fn = 1;
+                this.fn = 1;
                 fn2 = fn1;
                 fn1 = this->fn;
+                fn1 = this.fn;
                 suspend(this);          // return to last resume
                 for ( ;; ) {
                         this->fn = fn1 + fn2;
+                        this.fn = fn1 + fn2;
                         fn2 = fn1;
                         fn1 = this->fn;
+                        fn1 = this.fn;
                         suspend(this);  // return to last resume
+                }
+        }
         int next(Fibonacci* this) {
+        int next(Fibonacci & this) {
                 resume(this); // transfer to last suspend
                 return this.fn;
 …
                 Fibonacci f1, f2;
                 for ( int i = 1; i <= 10; i += 1 ) {
                         sout | next(&f1) | next(&f2) | endl;
+                        sout | next( f1 ) | next( f2 ) | endl;
+                }
+        }
 …
         };
         void ?{}(Fibonacci* this) {
               this->fn = 0;
                 (&this->c){};
+        void ?{}(Fibonacci & this) {
+              this.fn = 0;
+                (this.c){};
+        }
 \end{cfacode}
 …
 \subsection{Alternative: Lamda Objects}
 For coroutines as for threads, many implementations are based on routine pointers or function objects\cit. For example, Boost implements coroutines in terms of four functor object types:
+For coroutines as for threads, many implementations are based on routine pointers or function objects\cit. For example, Boost implements coroutines in terms of four functor object types:
 \begin{cfacode}
 asymmetric_coroutine<>::pull_type
 …
 symmetric_coroutine<>::call_type
 symmetric_coroutine<>::yield_type
 \end{cfacode}
 Often, the canonical threading paradigm in languages is based on function pointers, pthread being one of the most well known examples. The main problem of this approach is that the thread usage is limited to a generic handle that must otherwise be wrapped in a custom type. Since the custom type is simple to write in \CFA and solves several issues, added support for routine/lambda based coroutines adds very little.
 A variation of this would be to use an simple function pointer in the same way pthread does for threads :
+\end{cfacode}
+Often, the canonical threading paradigm in languages is based on function pointers, pthread being one of the most well known examples. The main problem of this approach is that the thread usage is limited to a generic handle that must otherwise be wrapped in a custom type. Since the custom type is simple to write in \CFA and solves several issues, added support for routine/lambda based coroutines adds very little.
+A variation of this would be to use an simple function pointer in the same way pthread does for threads :
 \begin{cfacode}
 void foo( coroutine_t cid, void * arg ) {
 …
 \subsection{Alternative: Trait-based coroutines}
 Finally the underlying approach, which is the one closest to \CFA idioms, is to use trait-based lazy coroutines. This approach defines a coroutine as anything that satisfies the trait \code{is_coroutine} and is used as a coroutine is a coroutine.
+Finally the underlying approach, which is the one closest to \CFA idioms, is to use trait-based lazy coroutines. This approach defines a coroutine as anything that satisfies the trait \code{is_coroutine} and is used as a coroutine.
 \begin{cfacode}
 trait is_coroutine(dtype T) {
       void main(T * this);
       coroutine_desc * get_coroutine(T * this);
 };
 \end{cfacode}
 This ensures an object is not a coroutine until \code{resume} (or \code{prime}) is called on the object. Correspondingly, any object that is passed to \code{resume} is a coroutine since it must satisfy the \code{is_coroutine} trait to compile. The advantage of this approach is that users can easily create different types of coroutines, for example, changing the memory foot print of a coroutine is trivial when implementing the \code{get_coroutine} routine. The \CFA keyword \code{coroutine} only has the effect of implementing the getter and forward declarations required for users to only have to implement the main routine.
+      void main(T & this);
+      coroutine_desc * get_coroutine(T & this);
+};
+\end{cfacode}
+This ensures an object is not a coroutine until \code{resume} (or \code{prime}) is called on the object. Correspondingly, any object that is passed to \code{resume} is a coroutine since it must satisfy the \code{is_coroutine} trait to compile. The advantage of this approach is that users can easily create different types of coroutines, for example, changing the memory foot print of a coroutine is trivial when implementing the \code{get_coroutine} routine. The \CFA keyword \code{coroutine} only has the effect of implementing the getter and forward declarations required for users to only have to implement the main routine.
 \begin{center}
 …
 };
 static inline
 coroutine_desc * get_coroutine(
         struct MyCoroutine * this
+static inline
+coroutine_desc * get_coroutine(
+        struct MyCoroutine & this
 ) {
         return &this->__cor;
+        return &this.__cor;
+}
 …
 \end{center}
+The combination of these two approaches allows users new to concurrency to have a easy and concise method while more advanced users can expose themselves to otherwise hidden pitfalls at the benefit of tighter control on memory layout and initialization.
 \section{Thread Interface}\label{threads}
 The basic building blocks of multi-threading in \CFA are \glspl{cfathread}. Both use and kernel threads are supported, where user threads are the concurrency mechanism and kernel threads are the parallel mechanism. User threads offer a flexible and lightweight interface. A thread can be declared using a struct declaration \code{thread} as follows:
+The basic building blocks of multi-threading in \CFA are \glspl{cfathread}. Both user and kernel threads are supported, where user threads are the concurrency mechanism and kernel threads are the parallel mechanism. User threads offer a flexible and lightweight interface. A thread can be declared using a struct declaration \code{thread} as follows:
 \begin{cfacode}
 …
 \begin{cfacode}
 trait is_thread(dtype T) {
       void ^?{}(T* mutex this);
       void main(T* this);
       thread_desc* get_thread(T* this);
+      void ^?{}(T & mutex this);
+      void main(T & this);
+      thread_desc* get_thread(T & this);
 };
 \end{cfacode}
 …
         thread foo {};
         void main(foo* this) {
+        void main(foo & this) {
                 sout | "Hello World!" | endl;
+        }
 …
         //ctor
         void ?{}(FuncRunner* this, voidFunc inFunc) {
                 func = inFunc;
+        void ?{}(FuncRunner & this, voidFunc inFunc) {
+                this.func = inFunc;
+        }
         //main
         void main(FuncRunner* this) {
                 this->func();
+        void main(FuncRunner & this) {
+                this.func();
+        }
 \end{cfacode}
 …
 thread World;
 void main(thread World* this) {
+void main(World & this) {
         sout | "World!" | endl;
+}
 …
 \begin{cfacode}
+        thread MyThread {
+                //...
+        };
+        //main
+        void main(MyThread* this) {
+                //...
+        }
+        void foo() {
+                MyThread thrds[10];
+                //Start 10 threads at the beginning of the scope
+thread MyThread {
+        //...
+};
+//main
+void main(MyThread & this) {
+        //...
+}
+void foo() {
+        MyThread thrds[10];
+        //Start 10 threads at the beginning of the scope
+        DoStuff();
+        //Wait for the 10 threads to finish
+}
+\end{cfacode}
+However, one of the apparent drawbacks of this system is that threads now always form a lattice, that is they are always destroyed in opposite order of construction because of block structure. However, storage allocation is not limited to blocks; dynamic allocation can create threads that outlive the scope in which the thread is created much like dynamically allocating memory lets objects outlive the scope in which they are created
+\begin{cfacode}
+thread MyThread {
+        //...
+};
+//main
+void main(MyThread & this) {
+        //...
+}
+void foo() {
+        MyThread * long_lived;
+        {
+                MyThread short_lived;
+                //Start a thread at the beginning of the scope
                 DoStuff();
+                //Wait for the 10 threads to finish
+        }
+\end{cfacode}
+However, one of the apparent drawbacks of this system is that threads now always form a lattice, that is they are always destroyed in opposite order of construction because of block structure. However, storage allocation os not limited to blocks; dynamic allocation can create threads that outlive the scope in which the thread is created much like dynamically allocating memory lets objects outlive the scope in which they are created
+\begin{cfacode}
+        thread MyThread {
+                //...
+        };
+        //main
+        void main(MyThread* this) {
+                //...
+        }
+        void foo() {
+                MyThread* long_lived;
+                {
+                        MyThread short_lived;
+                        //Start a thread at the beginning of the scope
+                        DoStuff();
+                        //create another thread that will outlive the thread in this scope
+                        long_lived = new MyThread;
+                        //Wait for the thread short_lived to finish
+                }
+                DoMoreStuff();
+                //Now wait for the short_lived to finish
+                delete long_lived;
+        }
+\end{cfacode}
+                //create another thread that will outlive the thread in this scope
+                long_lived = new MyThread;
+                //Wait for the thread short_lived to finish
+        }
+        DoMoreStuff();
+        //Now wait for the short_lived to finish
+        delete long_lived;
+}
+\end{cfacode}

doc/proposals/concurrency/text/cforall.tex

-                      re149f77
+                      r695e00d
 % ======================================================================
 % ======================================================================
+As mentionned in the introduction, the document presents the design for the concurrency features in \CFA. Since it is a new language here is a quick review of the language specifically tailored to the features needed to support concurrency.
+\CFA is a extension of ISO C and therefore supports much of the same paradigms as C. It is a non-object oriented system level language, meaning it has very most of the major abstractions have either no runtime cost or can be opt-out easily. Like C, the basics of \CFA revolve around structures and routines, which are thin abstractions over assembly. The vast majority of the code produced by a \CFA compiler respects memory-layouts and calling-conventions laid out by C. However, while \CFA is not an object-oriented language according to a strict definition. It does have some notion of objects, most importantly construction and destruction of objects. Most of the following pieces of code can be found as is on the \CFA website : \cite{www-cfa}
+\section{References}
+Like \CC, \CFA introduces references as an alternative to pointers. In regards to concurrency, the semantics difference between pointers and references aren't particularly relevant but since this document uses mostly references here is a quick overview of the semantics :
+\begin{cfacode}
+int x, *p1 = &x, **p2 = &p1, ***p3 = &p2,
+&r1 = x,    &&r2 = r1,   &&&r3 = r2;
+***p3 = 3;                                      // change x
+r3 = 3;                                         // change x, ***r3
+**p3 = ...;                                     // change p1
+&r3 = ...;                                      // change r1, (&*)**r3
+*p3 = ...;                                      // change p2
+&&r3 = ...;                                     // change r2, (&(&*)*)*r3
+&&&r3 = p3;                                     // change r3 to p3, (&(&(&*)*)*)r3
+int y, z, & ar[3] = { x, y, z };                // initialize array of references
+&ar[1] = &z;                                    // change reference array element
+typeof( ar[1] ) p;                              // is int, i.e., the type of referenced object
+typeof( &ar[1] ) q;                             // is int &, i.e., the type of reference
+sizeof( ar[1] ) == sizeof( int );               // is true, i.e., the size of referenced object
+sizeof( &ar[1] ) == sizeof( int *);             // is true, i.e., the size of a reference
+\end{cfacode}
+The important thing to take away from this code snippet is that references offer a handle to an object much like pointers but which is automatically derefferenced when convinient.
+\section{Overloading}
+Another important feature \CFA has in common with \CC is function overloading :
+\begin{cfacode}
+// selection based on type and number of parameters
+void f( void );                                 // (1)
+void f( char );                                 // (2)
+void f( int, double );                          // (3)
+f();                                            // select (1)
+f( 'a' );                                       // select (2)
+f( 3, 5.2 );                                    // select (3)
+// selection based on  type and number of returns
+char f( int );                                  // (1)
+double f( int );                                // (2)
+[ int, double ] f( int );                       // (3)
+char c = f( 3 );                                // select (1)
+double d = f( 4 );                              // select (2)
+[ int, double ] t = f( 5 );                     // select (3)
+\end{cfacode}
+This feature is particularly important for concurrency since the runtime system relies on creating different types do represent concurrency objects. Therefore, overloading is necessary to prevent the need for long prefixes and other naming conventions that prevent clashes. As seen in chapter \ref{basics}, the main is an example of routine that benefits from overloading when concurrency in introduced.
+\section{Operators}
+Overloading also extends to operators. The syntax for denoting operator-overloading is to name a routine with the symbol of the operator and question marks where the arguments of the operation would be, like so :
+\begin{cfacode}
+int ++?( int op );                              // unary prefix increment
+int ?++( int op );                              // unary postfix increment
+int ?+?( int op1, int op2 );                    // binary plus
+int ?<=?( int op1, int op2 );                   // binary less than
+int ?=?( int & op1, int op2 );                  // binary assignment
+int ?+=?( int & op1, int op2 );                 // binary plus-assignment
+struct S { int i, j; };
+S ?+?( S op1, S op2 ) {                         // add two structures
+        return (S){ op1.i + op2.i, op1.j + op2.j };
+}
+S s1 = { 1, 2 }, s2 = { 2, 3 }, s3;
+s3 = s1 + s2;                                   // compute sum: s3 == { 2, 5 }
+\end{cfacode}
+Since concurrency does not use operator overloading, this feature is more important as an introduction for the syntax of constructors.
+\section{Constructors/Destructors}
+\CFA uses the following syntax for constructors and destructors :
+\begin{cfacode}
+struct S {
+        size_t size;
+        int * ia;
+};
+void ?{}( S & s, int asize ) with s {           // constructor operator
+        size = asize;                           // initialize fields
+        ia = calloc( size, sizeof( S ) );
+}
+void ^?{}( S & s ) with s {                     // destructor operator
+        free( ia );                             // de-initialization fields
+}
+int main() {
+        S x = { 10 }, y = { 100 };              // implict calls: ?{}( x, 10 ), ?{}( y, 100 )
+        ...                                     // use x and y
+        ^x{};  ^y{};                            // explicit calls to de-initialize
+        x{ 20 };  y{ 200 };                     // explicit calls to reinitialize
+        ...                                     // reuse x and y
+}                                               // implict calls: ^?{}( y ), ^?{}( x )
+\end{cfacode}
+The language guarantees that every object and all their fields are constructed. Like \CC construction is automatically done on declaration and destruction done when the declared variables reach the end of its scope.
+For more information see \cite{cforall-ug,rob-thesis,www-cfa}.

doc/proposals/concurrency/text/concurrency.tex

-                      re149f77
+                      r695e00d
 % ======================================================================
 % ======================================================================
 It easier to understand the problem of multi-monitor scheduling using a series of pseudo-code. Note that for simplicity in the following snippets of pseudo-code, waiting and signalling is done using an implicit condition variable, like Java built-in monitors.
+It is easier to understand the problem of multi-monitor scheduling using a series of pseudo-code. Note that for simplicity in the following snippets of pseudo-code, waiting and signalling is done using an implicit condition variable, like Java built-in monitors.
 \begin{multicols}{2}
 …
 \end{center}
 It is particularly important to pay attention to code sections 8 and 3, which are where the existing semantics of internal scheduling need to be extended for multiple monitors. The root of the problem is that \gls{group-acquire} is used in a context where one of the monitors is already acquired and is why it is important to define the behaviour of the previous pseudo-code. When the signaller thread reaches the location where it should "release A \& B" (line 16), it must actually transfer ownership of monitor B to the waiting thread. This ownership trasnfer is required in order to prevent barging. Since the signalling thread still needs the monitor A, simply waking up the waiting thread is not an option because it would violate mutual exclusion. There are three options:
+It is particularly important to pay attention to code sections 8 and 4, which are where the existing semantics of internal scheduling need to be extended for multiple monitors. The root of the problem is that \gls{group-acquire} is used in a context where one of the monitors is already acquired and is why it is important to define the behaviour of the previous pseudo-code. When the signaller thread reaches the location where it should "release A \& B" (line 16), it must actually transfer ownership of monitor B to the waiting thread. This ownership trasnfer is required in order to prevent barging. Since the signalling thread still needs the monitor A, simply waking up the waiting thread is not an option because it would violate mutual exclusion. There are three options:
 \subsubsection{Delaying signals}
 …
 Note that ordering is not determined by a race condition but by whether signalled threads are enqueued in FIFO or FILO order. However, regardless of the answer, users can move line 15 before line 11 and get the reverse effect.
 In both cases however, the threads need to be able to distinguish on a per monitor basis which ones need to be released and which ones need to be transferred. Which means monitors cannot be handled as a single homogenous group.
+In both cases, the threads need to be able to distinguish on a per monitor basis which ones need to be released and which ones need to be transferred. Which means monitors cannot be handled as a single homogenous group.
 \subsubsection{Dependency graphs}
 …
 Resolving dependency graph being a complex and expensive endeavour, this solution is not the preffered one.
 \subsubsection{Partial signalling}
+\subsubsection{Partial signalling} \label{partial-sig}
 Finally, the solution that is chosen for \CFA is to use partial signalling. Consider the following case:
 …
 % ======================================================================
 % ======================================================================
+\subsection{Internal scheduling: Implementation} \label{insched-impl}
+% ======================================================================
+% ======================================================================
+\TODO
+\subsection{Internal scheduling: Implementation} \label{inschedimpl}
+% ======================================================================
+% ======================================================================
+There are several challenges specific to \CFA when implementing internal scheduling. These challenges are direct results of \gls{group-acquire} and loose object definitions. These two constraints are to root cause of most design decisions in the implementation of internal scheduling. Furthermore, to avoid the head-aches of dynamically allocating memory in a concurrent environment, the internal-scheduling design is entirely free of mallocs and other dynamic memory allocation scheme. This is to avoid the chicken and egg problem of having a memory allocator that relies on the threading system and a threading system that relies on the runtime. This extra goal, means that memory management is a constant concern in the design of the system.
+The main memory concern for concurrency is queues. All blocking operations are made by parking threads onto queues. These queues need to be intrinsic\cit to avoid the need memory allocation. This entails that all the fields needed to keep track of all needed information. Since internal scheduling can use an unbound amount of memory (depending on \gls{group-acquire}) statically defining information information in the intrusive fields of threads is insufficient. The only variable sized container that does not require memory allocation is the callstack, which is heavily used in the implementation of internal scheduling. Particularly the GCC extension variable length arrays which is used extensively.
+Since stack allocation is based around scope, the first step of the implementation is to identify the scopes that are available to store the information, and which of these can have a variable length. In the case of external scheduling, the threads and the condition both allow a fixed amount of memory to be stored, while mutex-routines and the actual blocking call allow for an unbound amount (though adding too much to the mutex routine stack size can become expansive faster).
+The following figure is the traditionnal illustration of a monitor :
+\begin{center}
+{\resizebox{0.4\textwidth}{!}{\input{monitor}}}
+\end{center}
+For \CFA, the previous picture does not have support for blocking multiple monitors on a single condition. To support \gls{group-acquire} two changes to this picture are required. First, it doesn't make sense to tie the condition to a single monitor since blocking two monitors as one would require arbitrarily picking a monitor to hold the condition. Secondly, the object waiting on the conditions and AS-stack cannot simply contain the waiting thread since a single thread can potentially wait on multiple monitors. As mentionned in section \ref{inschedimpl}, the handling in multiple monitors is done by partially passing, which entails that each concerned monitor needs to have a node object. However, for waiting on the condition, since all threads need to wait together, a single object needs to be queued in the condition. Moving out the condition and updating the node types yields :
+\begin{center}
+{\resizebox{0.8\textwidth}{!}{\input{int_monitor}}}
+\end{center}
+\newpage
+This picture and the proper entry and leave algorithms is the fundamental implementation of internal scheduling.
+\begin{multicols}{2}
+Entry
+\begin{pseudo}[numbers=left]
+if monitor is free
+        enter
+elif I already own the monitor
+        continue
+else
+        block
+increment recursion
+\end{pseudo}
+\columnbreak
+Exit
+\begin{pseudo}[numbers=left, firstnumber=8]
+decrement recursion
+if recursion == 0
+        if signal_stack not empty
+                set_owner to thread
+                if all monitors ready
+                        wake-up thread
+        if entry queue not empty
+                wake-up thread
+\end{pseudo}
+\end{multicols}
+Some important things to notice about the exit routine. The solution discussed in \ref{inschedimpl} can be seen on line 11 of the previous pseudo code. Basically, the solution boils down to having a seperate data structure for the condition queue and the AS-stack, and unconditionally transferring ownership of the monitors but only unblocking the thread when the last monitor has trasnferred ownership. This solution is safe as well as preventing any potential barging.
 % ======================================================================
 …
                 inUse = true;
+        }
         void g() {
+        void V() {
                 inUse = false;
 …
 \end{tabular}
 \end{center}
 This method is more constrained and explicit, which may help users tone down the undeterministic nature of concurrency. Indeed, as the following examples demonstrates, external scheduling allows users to wait for events from other threads without the concern of unrelated events occuring. External scheduling can generally be done either in terms of control flow (e.g. \uC) or in terms of data (e.g. Go). Of course, both of these paradigms have their own strenghts and weaknesses but for this project control flow semantics where chosen to stay consistent with the rest of the languages semantics. Two challenges specific to \CFA arise when trying to add external scheduling with loose object definitions and multi-monitor routines. The following example shows a simple use \code{accept} versus \code{wait}/\code{signal} and its advantages.
 In the case of internal scheduling, the call to \code{wait} only guarantees that \code{g} is the last routine to access the monitor. This entails that the routine \code{f} may have acquired mutual exclusion several times while routine \code{h} was waiting. On the other hand, external scheduling guarantees that while routine \code{h} was waiting, no routine other than \code{g} could acquire the monitor.
+This method is more constrained and explicit, which may help users tone down the undeterministic nature of concurrency. Indeed, as the following examples demonstrates, external scheduling allows users to wait for events from other threads without the concern of unrelated events occuring. External scheduling can generally be done either in terms of control flow (e.g., \uC) or in terms of data (e.g. Go). Of course, both of these paradigms have their own strenghts and weaknesses but for this project control-flow semantics were chosen to stay consistent with the rest of the languages semantics. Two challenges specific to \CFA arise when trying to add external scheduling with loose object definitions and multi-monitor routines. The previous example shows a simple use \code{_Accept} versus \code{wait}/\code{signal} and its advantages. Note that while other languages often use \code{accept} as the core external scheduling keyword, \CFA uses \code{waitfor} to prevent name collisions with existing socket APIs.
+In the case of internal scheduling, the call to \code{wait} only guarantees that \code{V} is the last routine to access the monitor. This entails that the routine \code{V} may have acquired mutual exclusion several times while routine \code{P} was waiting. On the other hand, external scheduling guarantees that while routine \code{P} was waiting, no routine other than \code{V} could acquire the monitor.
 % ======================================================================
 …
         void f(A & mutex a);
+        void g(A & mutex a) { accept(f); }
+\end{cfacode}
+However, external scheduling is an example where implementation constraints become visible from the interface. Indeed, since there is no hard limit to the number of threads trying to acquire a monitor concurrently, performance is a significant concern. Here is the pseudo code for the entering phase of a monitor:
+        void f(int a, float b);
+        void g(A & mutex a) {
+                waitfor(f); // Less obvious which f() to wait for
+        }
+\end{cfacode}
+Furthermore, external scheduling is an example where implementation constraints become visible from the interface. Indeed, since there is no hard limit to the number of threads trying to acquire a monitor concurrently, performance is a significant concern. Here is the pseudo code for the entering phase of a monitor:
 \begin{center}
 …
         if monitor is free
                 enter
+        elif I already own the monitor
+                continue
         elif monitor accepts me
                 enter
 …
 \end{center}
 For the \pscode{monitor is free} condition it is easy to implement a check that can evaluate the condition in a few instruction. However, a fast check for \pscode{monitor accepts me} is much harder to implement depending on the constraints put on the monitors. Indeed, monitors are often expressed as an entry queue and some acceptor queue as in the following figure:
+For the fist two conditions, it is easy to implement a check that can evaluate the condition in a few instruction. However, a fast check for \pscode{monitor accepts me} is much harder to implement depending on the constraints put on the monitors. Indeed, monitors are often expressed as an entry queue and some acceptor queue as in the following figure:
 \begin{center}
 …
 \end{center}
 There are other alternatives to these pictures but in the case of this picture implementing a fast accept check is relatively easy. Indeed simply updating a bitmask when the acceptor queue changes is enough to have a check that executes in a single instruction, even with a fairly large number (e.g. 128) of mutex members. However, this relies on the fact that all the acceptable routines are declared with the monitor type. For OO languages this does not compromise much since monitors already have an exhaustive list of member routines. However, for \CFA this is not the case; routines can be added to a type anywhere after its declaration. Its important to note that the bitmask approach does not actually require an exhaustive list of routines, but it requires a dense unique ordering of routines with an upper-bound and that ordering must be consistent across translation units.
+There are other alternatives to these pictures but in the case of this picture implementing a fast accept check is relatively easy. Indeed simply updating a bitmask when the acceptor queue changes is enough to have a check that executes in a single instruction, even with a fairly large number (e.g. 128) of mutex members. This technique cannot be used in \CFA because it relies on the fact that the monitor type declares all the acceptable routines. For OO languages this does not compromise much since monitors already have an exhaustive list of member routines. However, for \CFA this is not the case; routines can be added to a type anywhere after its declaration. Its important to note that the bitmask approach does not actually require an exhaustive list of routines, but it requires a dense unique ordering of routines with an upper-bound and that ordering must be consistent across translation units.
 The alternative would be to have a picture more like this one:
 …
 \end{center}
+Not storing the queues inside the monitor means that the storage can vary between routines, allowing for more flexibility and extensions. Storing an array of function-pointers would solve the issue of uniquely identifying acceptable routines. However, the single instruction bitmask compare has been replaced by dereferencing a pointer followed by a linear search. Furthermore, supporting nested external scheduling may now require additionnal searches on calls to accept to check if a routine is already queued in.
+At this point we must make a decision between flexibility and performance. Many design decisions in \CFA achieve both flexibility and performance, for example polymorphic routines add significant flexibility but inlining them means the optimizer can easily remove any runtime cost. Here however, the cost of flexibility cannot be trivially removed.
+In either cases here are a few alternatives for the different syntaxes this syntax : \\
+\begin{center}
+{\renewcommand{\arraystretch}{1.5}
+\begin{tabular}[t]{l @{\hskip 0.35in} l}
+\hline
+\multicolumn{2}{ c }{\code{accept} on type}\\
+\hline
+Alternative 1 & Alternative 2 \\
+\begin{lstlisting}
+mutex struct A
+accept( void f(A & mutex a) )
+{};
+\end{lstlisting} &\begin{lstlisting}
+mutex struct A {}
+accept( void f(A & mutex a) );
+\end{lstlisting} \\
+Alternative 3 & Alternative 4 \\
+\begin{lstlisting}
+mutex struct A {
+        accept( void f(A & mutex a) )
+};
+\end{lstlisting} &\begin{lstlisting}
+mutex struct A {
+        accept :
+                void f(A & mutex a) );
+};
+\end{lstlisting}\\
+\hline
+\multicolumn{2}{ c }{\code{accept} on routine}\\
+\hline
+\begin{lstlisting}
+mutex struct A {};
+void f(A & mutex a)
+accept( void f(A & mutex a) )
+void g(A & mutex a) {
+        /*...*/
+}
+\end{lstlisting}&\\
+\end{tabular}
+}
+\end{center}
+Another aspect to consider is what happens if multiple overloads of the same routine are used. For the time being it is assumed that multiple overloads of the same routine should be scheduled regardless of the overload used. However, this could easily be extended in the future.
+Not storing the queues inside the monitor means that the storage can vary between routines, allowing for more flexibility and extensions. Storing an array of function-pointers would solve the issue of uniquely identifying acceptable routines. However, the single instruction bitmask compare has been replaced by dereferencing a pointer followed by a linear search. Furthermore, supporting nested external scheduling may now require additionnal searches on calls to waitfor to check if a routine is already queued in.
+At this point we must make a decision between flexibility and performance. Many design decisions in \CFA achieve both flexibility and performance, for example polymorphic routines add significant flexibility but inlining them means the optimizer can easily remove any runtime cost. Here however, the cost of flexibility cannot be trivially removed. In the end, the most flexible approach has been chosen since it allows users to write programs that would otherwise be prohibitively hard to write. This is based on the assumption that writing fast but inflexible locks is closer to a solved problems than writing locks that are as flexible as external scheduling in \CFA.
+Another aspect to consider is what happens if multiple overloads of the same routine are used. For the time being it is assumed that multiple overloads of the same routine are considered as distinct routines. However, this could easily be extended in the future.
 % ======================================================================
 …
 External scheduling, like internal scheduling, becomes orders of magnitude more complex when we start introducing multi-monitor syntax. Even in the simplest possible case some new semantics need to be established:
 \begin{cfacode}
-        accept( void f(mutex struct A & mutex this))
         mutex struct A {};
 …
         void g(A & mutex a, B & mutex b) {
                 accept(f); //ambiguous, which monitor
+                waitfor(f); //ambiguous, which monitor
+        }
 \end{cfacode}
 …
 \begin{cfacode}
-        accept( void f(mutex struct A & mutex this))
         mutex struct A {};
 …
         void g(A & mutex a, B & mutex b) {
+                accept( b, f );
+        }
+\end{cfacode}
+This is unambiguous. Both locks will be acquired and kept, when routine \code{f} is called the lock for monitor \code{a} will be temporarily transferred from \code{g} to \code{f} (while \code{g} still holds lock \code{b}). This behavior can be extended to multi-monitor accept statment as follows.
+\begin{cfacode}
+        accept( void f(mutex struct A & mutex, mutex struct A & mutex))
+                waitfor( f, b );
+        }
+\end{cfacode}
+This is unambiguous. Both locks will be acquired and kept, when routine \code{f} is called the lock for monitor \code{b} will be temporarily transferred from \code{g} to \code{f} (while \code{g} still holds lock \code{a}). This behavior can be extended to multi-monitor waitfor statment as follows.
+\begin{cfacode}
         mutex struct A {};
 …
         void g(A & mutex a, B & mutex b) {
+                accept( b, a, f);
+        }
+\end{cfacode}
+Note that the set of monitors passed to the \code{accept} statement must be entirely contained in the set of monitor already acquired in the routine. \code{accept} used in any other context is Undefined Behaviour.
+                waitfor( f, a, b);
+        }
+\end{cfacode}
+Note that the set of monitors passed to the \code{waitfor} statement must be entirely contained in the set of monitor already acquired in the routine. \code{waitfor} used in any other context is Undefined Behaviour.
+An important behavior to note is that what happens when set of monitors only match partially :
+\begin{cfacode}
+        mutex struct A {};
+        mutex struct B {};
+        void g(A & mutex a, B & mutex b) {
+                waitfor(f, a, b);
+        }
+        A a1, a2;
+        B b;
+        void foo() {
+                g(a1, b);
+        }
+        void bar() {
+                f(a2, b);
+        }
+\end{cfacode}
+While the equivalent can happen when using internal scheduling, the fact that conditions are branded on first use means that users have to use two different condition variables. In both cases, partially matching monitor sets will not wake-up the waiting thread. It is also important to note that in the case of external scheduling, as for routine calls, the order of parameters is important; \code{waitfor(f,a,b)} and \code{waitfor(f,b,a)} are to distinct waiting condition.
 % ======================================================================

doc/proposals/concurrency/version

re149f77	r695e00d
1		0.9.122
	1	0.9.180

src/Common/PassVisitor.impl.h

-                      re149f77
+                      r695e00d
                 } catch ( SemanticError &e ) {
+                        e.set_location( (*i)->location );
                         errors.append( e );
+                }
 …
 //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+// A NOTE ON THE ORDER OF TRAVERSAL
+//
+// Types and typedefs have their base types visited before they are added to the type table.  This is ok, since there is
+// no such thing as a recursive type or typedef.
+//
+//             typedef struct { T *x; } T; // never allowed
+//
+// for structs/unions, it is possible to have recursion, so the decl should be added as if it's incomplete to begin, the
+// members are traversed, and then the complete type should be added (assuming the type is completed by this particular
+// declaration).
+//
+//             struct T { struct T *x; }; // allowed
+//
+// It is important to add the complete type to the symbol table *after* the members/base has been traversed, since that
+// traversal may modify the definition of the type and these modifications should be visible when the symbol table is
+// queried later in this pass.
+//
+// TODO: figure out whether recursive contexts are sensible/possible/reasonable.
 //--------------------------------------------------------------------------
 …
         indexerAddEnum( node );
         // unlike structs, contexts, and unions, enums inject their members into the global scope
+        // unlike structs, traits, and unions, enums inject their members into the global scope
         maybeAccept( node->parameters, *this );
         maybeAccept( node->members   , *this );
 …
+        }
+        // see A NOTE ON THE ORDER OF TRAVERSAL, above
+        // note that assertions come after the type is added to the symtab, since they are not part of the type proper
+        // and may depend on the type itself
         indexerAddType( node );
 …
+        }
+        // see A NOTE ON THE ORDER OF TRAVERSAL, above
+        // note that assertions come after the type is added to the symtab, since they are not part of the type proper
+        // and may depend on the type itself
         indexerAddType( node );
 …
 void PassVisitor< pass_type >::visit( IfStmt * node ) {
         VISIT_START( node );
+        visitExpression( node->condition );
+        node->thenPart = visitStatement( node->thenPart );
+        node->elsePart = visitStatement( node->elsePart );
+        {
+                // if statements introduce a level of scope (for the initialization)
+                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                acceptAll( node->get_initialization(), *this );
+                visitExpression( node->condition );
+                node->thenPart = visitStatement( node->thenPart );
+                node->elsePart = visitStatement( node->elsePart );
+        }
         VISIT_END( node );
+}
 …
         MUTATE_START( node );
+        {
+                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                // if statements introduce a level of scope (for the initialization)
+                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                maybeMutateRef( node->get_initialization(), *this );
                 node->condition = mutateExpression( node->condition );
                 node->thenPart  = mutateStatement ( node->thenPart  );
 …
         VISIT_START( node );
+        {
+                // for statements introduce a level of scope (for the initialization)
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeAccept( node->initialization, *this );
 …
         MUTATE_START( node );
+        {
+                // for statements introduce a level of scope (for the initialization)
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeMutateRef( node->initialization, *this );
 …
         VISIT_START( node );
+        {
+                // catch statements introduce a level of scope (for the caught exception)
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeAccept( node->decl, *this );
 …
         MUTATE_START( node );
+        {
+                // catch statements introduce a level of scope (for the caught exception)
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeMutateRef( node->decl, *this );

src/GenPoly/Box.cc

-                      re149f77
+                      r695e00d
                                         } else {
                                                 // xxx - should this be an assertion?
+                                                std::string x = env ? toString( *env ) : "missing env";
+                                                throw SemanticError( x + "\n" + "unbound type variable: " + tyParm->first + " in application ", appExpr );
+                                                throw SemanticError( toString( *env, "\nunbound type variable: ", tyParm->first, " in application " ), appExpr );
                                         } // if
                                 } // if
 …
                                 if ( concrete == 0 ) {
                                         return typeInst;
-                                        // xxx - should this be an assertion?
-//                                      std::string x = env ? toString( *env ) : "missing env";
-//                                      throw SemanticError( x + "\n" + "Unbound type variable " + typeInst->get_name() + " in ", appExpr );
                                 } // if
                                 return concrete;

src/InitTweak/FixInit.cc

-                      re149f77
+                      r695e00d
 namespace InitTweak {
         namespace {
-                typedef std::unordered_map< Expression *, TypeSubstitution * > EnvMap;
                 typedef std::unordered_map< int, int > UnqCount;
+                class InsertImplicitCalls : public WithTypeSubstitution {
+                public:
+                struct InsertImplicitCalls : public WithTypeSubstitution {
                         /// wrap function application expressions as ImplicitCopyCtorExpr nodes so that it is easy to identify which
                         /// function calls need their parameters to be copy constructed
+                        static void insert( std::list< Declaration * > & translationUnit, EnvMap & envMap );
+                        InsertImplicitCalls( EnvMap & envMap ) : envMap( envMap ) {}
+                        static void insert( std::list< Declaration * > & translationUnit );
                         Expression * postmutate( ApplicationExpr * appExpr );
-                        void premutate( StmtExpr * stmtExpr );
-                        // collects environments for relevant nodes
-                        EnvMap & envMap;
                 };
+                class ResolveCopyCtors final : public SymTab::Indexer {
+                public:
+                struct ResolveCopyCtors final : public WithIndexer, public WithShortCircuiting, public WithTypeSubstitution {
                         /// generate temporary ObjectDecls for each argument and return value of each ImplicitCopyCtorExpr,
                         /// generate/resolve copy construction expressions for each, and generate/resolve destructors for both
                         /// arguments and return value temporaries
+                        static void resolveImplicitCalls( std::list< Declaration * > & translationUnit, const EnvMap & envMap, UnqCount & unqCount );
+                        typedef SymTab::Indexer Parent;
+                        using Parent::visit;
+                        ResolveCopyCtors( const EnvMap & envMap, UnqCount & unqCount ) : envMap( envMap ), unqCount( unqCount ) {}
+                        virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr ) override;
+                        virtual void visit( UniqueExpr * unqExpr ) override;
+                        virtual void visit( StmtExpr * stmtExpr ) override;
+                        static void resolveImplicitCalls( std::list< Declaration * > & translationUnit, UnqCount & unqCount );
+                        ResolveCopyCtors( UnqCount & unqCount ) : unqCount( unqCount ) {}
+                        void postvisit( ImplicitCopyCtorExpr * impCpCtorExpr );
+                        void postvisit( StmtExpr * stmtExpr );
+                        void previsit( UniqueExpr * unqExpr );
+                        void postvisit( UniqueExpr * unqExpr );
                         /// create and resolve ctor/dtor expression: fname(var, [cpArg])
 …
                         void destructRet( ObjectDecl * ret, ImplicitCopyCtorExpr * impCpCtorExpr );
-                        TypeSubstitution * env;
-                        const EnvMap & envMap;
                         UnqCount & unqCount; // count the number of times each unique expr ID appears
+                        std::unordered_set< int > vars;
                 };
 …
                 };
+                class GenStructMemberCalls final : public SymTab::Indexer {
+                  public:
+                        typedef Indexer Parent;
+                struct GenStructMemberCalls final : public WithGuards, public WithShortCircuiting, public WithIndexer {
                         /// generate default/copy ctor and dtor calls for user-defined struct ctor/dtors
                         /// for any member that is missing a corresponding ctor/dtor call.
 …
                         static void generate( std::list< Declaration * > & translationUnit );
+                        using Parent::visit;
+                        virtual void visit( FunctionDecl * funcDecl ) override;
+                        virtual void visit( MemberExpr * memberExpr ) override;
+                        virtual void visit( ApplicationExpr * appExpr ) override;
+                        void previsit( FunctionDecl * funcDecl );
+                        void postvisit( FunctionDecl * funcDecl );
+                        void previsit( MemberExpr * memberExpr );
+                        void previsit( ApplicationExpr * appExpr );
                         SemanticError errors;
 …
                 InitTweak::fixGlobalInit( translationUnit, filename, inLibrary );
-                EnvMap envMap;
                 UnqCount unqCount;
                 InsertImplicitCalls::insert( translationUnit, envMap );
                 ResolveCopyCtors::resolveImplicitCalls( translationUnit, envMap, unqCount );
+                InsertImplicitCalls::insert( translationUnit );
+                ResolveCopyCtors::resolveImplicitCalls( translationUnit, unqCount );
                 InsertDtors::insert( translationUnit );
                 FixInit::fixInitializers( translationUnit );
 …
         namespace {
                 void InsertImplicitCalls::insert( std::list< Declaration * > & translationUnit, EnvMap & envMap ) {
                         PassVisitor<InsertImplicitCalls> inserter( envMap );
+                void InsertImplicitCalls::insert( std::list< Declaration * > & translationUnit ) {
+                        PassVisitor<InsertImplicitCalls> inserter;
                         mutateAll( translationUnit, inserter );
+                }
                 void ResolveCopyCtors::resolveImplicitCalls( std::list< Declaration * > & translationUnit, const EnvMap & envMap, UnqCount & unqCount ) {
                         ResolveCopyCtors resolver( envMap, unqCount );
+                void ResolveCopyCtors::resolveImplicitCalls( std::list< Declaration * > & translationUnit, UnqCount & unqCount ) {
+                        PassVisitor<ResolveCopyCtors> resolver( unqCount );
                         acceptAll( translationUnit, resolver );
+                }
 …
                 void GenStructMemberCalls::generate( std::list< Declaration * > & translationUnit ) {
                         GenStructMemberCalls warner;
+                        PassVisitor<GenStructMemberCalls> warner;
                         acceptAll( translationUnit, warner );
+                }
 …
                         // wrap each function call so that it is easy to identify nodes that have to be copy constructed
                         ImplicitCopyCtorExpr * expr = new ImplicitCopyCtorExpr( appExpr );
                         // save the type substitution into the envMap so that it is easy to find.
+                        // Move the type substitution to the new top-level, if it is attached to the appExpr.
                         // Ensure it is not deleted with the ImplicitCopyCtorExpr by removing it before deletion.
                         // The substitution is needed to obtain the type of temporary variables so that copy constructor
+                        // calls can be resolved. Normally this is what PolyMutator is for, but the pass that resolves
+                        // copy constructor calls must be an Indexer. We could alternatively make a PolyIndexer which
+                        // saves the environment, or compute the types of temporaries here, but it's much simpler to
+                        // save the environment here, and more cohesive to compute temporary variables and resolve copy
+                        // constructor calls together.
+                        // calls can be resolved.
                         assert( env );
                         envMap[expr] = env;
+                        std::swap( expr->env, appExpr->env );
                         return expr;
+                }
-                void InsertImplicitCalls::premutate( StmtExpr * stmtExpr ) {
-                        assert( env );
-                        envMap[stmtExpr] = env;
+                }
 …
                         // (VariableExpr and already resolved expression)
                         CP_CTOR_PRINT( std::cerr << "ResolvingCtorDtor " << untyped << std::endl; )
                         Expression * resolved = ResolvExpr::findVoidExpression( untyped, *this );
+                        Expression * resolved = ResolvExpr::findVoidExpression( untyped, indexer );
                         assert( resolved );
                         if ( resolved->get_env() ) {
 …
+                }
                 void ResolveCopyCtors::visit( ImplicitCopyCtorExpr *impCpCtorExpr ) {
+                void ResolveCopyCtors::postvisit( ImplicitCopyCtorExpr *impCpCtorExpr ) {
                         CP_CTOR_PRINT( std::cerr << "ResolveCopyCtors: " << impCpCtorExpr << std::endl; )
-                        Parent::visit( impCpCtorExpr );
-                        env = envMap.at(impCpCtorExpr);
-                        assert( env );
                         ApplicationExpr * appExpr = impCpCtorExpr->get_callExpr();
 …
+                }
+                void ResolveCopyCtors::visit( StmtExpr * stmtExpr ) {
+                        Parent::visit( stmtExpr );
+                        env = envMap.at(stmtExpr);
+                void ResolveCopyCtors::postvisit( StmtExpr * stmtExpr ) {
+                        assert( env );
                         assert( stmtExpr->get_result() );
                         Type * result = stmtExpr->get_result();
 …
                                 stmtExpr->get_dtors().push_front( makeCtorDtor( "^?{}", ret ) );
                         } // if
+                }
+                void ResolveCopyCtors::visit( UniqueExpr * unqExpr ) {
+                        static std::unordered_set< int > vars;
+                }
+                void ResolveCopyCtors::previsit( UniqueExpr * unqExpr ) {
                         unqCount[ unqExpr->get_id() ]++;  // count the number of unique expressions for each ID
                         if ( vars.count( unqExpr->get_id() ) ) {
                                 // xxx - hack to prevent double-handling of unique exprs, otherwise too many temporary variables and destructors are generated
+                                visit_children = false;
+                        }
+                }
+                void ResolveCopyCtors::postvisit( UniqueExpr * unqExpr ) {
+                        if ( vars.count( unqExpr->get_id() ) ) {
+                                // xxx - hack to prevent double-handling of unique exprs, otherwise too many temporary variables and destructors are generated
                                 return;
+                        }
-                        Parent::visit( unqExpr );
                         // it should never be necessary to wrap a void-returning expression in a UniqueExpr - if this assumption changes, this needs to be rethought
                         assert( unqExpr->get_result() );
 …
                         // xxx - update to work with multiple return values
                         ObjectDecl * returnDecl = returnDecls.empty() ? NULL : returnDecls.front();
+                        ObjectDecl * returnDecl = returnDecls.empty() ? nullptr : returnDecls.front();
                         Expression * callExpr = impCpCtorExpr->get_callExpr();
 …
                         tempDecls.clear();
                         returnDecls.clear();
+                        impCpCtorExpr->set_callExpr( NULL );
+                        impCpCtorExpr->set_env( NULL );
+                        impCpCtorExpr->set_callExpr( nullptr );
+                        std::swap( impCpCtorExpr->env, callExpr->env );
+                        assert( impCpCtorExpr->env == nullptr );
                         delete impCpCtorExpr;
 …
+                }
                 void GenStructMemberCalls::visit( FunctionDecl * funcDecl ) {
                         ValueGuard< FunctionDecl * > oldFunction( funcDecl );
                         ValueGuard< std::set< DeclarationWithType * > > oldUnhandled( unhandled );
                         ValueGuard< std::map< DeclarationWithType *, CodeLocation > > oldUsedUninit( usedUninit );
                         ValueGuard< ObjectDecl * > oldThisParam( thisParam );
                         ValueGuard< bool > oldIsCtor( isCtor );
                         ValueGuard< StructDecl * > oldStructDecl( structDecl );
+                void GenStructMemberCalls::previsit( FunctionDecl * funcDecl ) {
+                        GuardValue( funcDecl );
+                        GuardValue( unhandled );
+                        GuardValue( usedUninit );
+                        GuardValue( thisParam );
+                        GuardValue( isCtor );
+                        GuardValue( structDecl );
                         errors = SemanticError();  // clear previous errors
 …
+                                }
+                        }
+                        Parent::visit( function );
+                }
+                void addIds( SymTab::Indexer & indexer, const std::list< DeclarationWithType * > & decls ) {
+                        for ( auto d : decls ) {
+                                indexer.addId( d );
+                        }
+                }
+                void addTypes( SymTab::Indexer & indexer, const std::list< TypeDecl * > & tds ) {
+                        for ( auto td : tds ) {
+                                indexer.addType( td );
+                                addIds( indexer, td->assertions );
+                        }
+                }
+                void GenStructMemberCalls::postvisit( FunctionDecl * funcDecl ) {
                         // remove the unhandled objects from usedUninit, because a call is inserted
                         // to handle them - only objects that are later constructed are used uninitialized.
 …
                         if ( ! unhandled.empty() ) {
                                 // need to explicitly re-add function parameters to the indexer in order to resolve copy constructors
+                                enterScope();
+                                maybeAccept( function->get_functionType(), *this );
+                                auto guard = makeFuncGuard( [this]() { indexer.enterScope(); }, [this]() { indexer.leaveScope(); } );
+                                addTypes( indexer, function->type->forall );
+                                addIds( indexer, function->type->returnVals );
+                                addIds( indexer, function->type->parameters );
                                 // need to iterate through members in reverse in order for
 …
                                                 Statement * callStmt = stmt.front();
                                                 MutatingResolver resolver( *this );
+                                                MutatingResolver resolver( indexer );
                                                 try {
                                                         callStmt->acceptMutator( resolver );
 …
+                                        }
+                                }
-                                leaveScope();
+                        }
                         if (! errors.isEmpty()) {
 …
+                }
+                void GenStructMemberCalls::visit( ApplicationExpr * appExpr ) {
+                        if ( ! checkWarnings( function ) ) return;
+                void GenStructMemberCalls::previsit( ApplicationExpr * appExpr ) {
+                        if ( ! checkWarnings( function ) ) {
+                                visit_children = false;
+                                return;
+                        }
                         std::string fname = getFunctionName( appExpr );
 …
+                                }
+                        }
+                        Parent::visit( appExpr );
+                }
+                void GenStructMemberCalls::visit( MemberExpr * memberExpr ) {
+                        if ( ! checkWarnings( function ) ) return;
+                        if ( ! isCtor ) return;
+                }
+                void GenStructMemberCalls::previsit( MemberExpr * memberExpr ) {
+                        if ( ! checkWarnings( function ) || ! isCtor ) {
+                                visit_children = false;
+                                return;
+                        }
                         if ( isThisExpression( memberExpr->get_aggregate(), thisParam ) ) {
 …
+                                }
+                        }
-                        Parent::visit( memberExpr );
+                }
 …
                         // in generated code. If this changes, add mutate methods for entities with
                         // scope and call {enter,leave}Scope explicitly.
                         objectDecl->accept( indexer );
+                        indexer.addId( objectDecl );
                         return objectDecl;
+                }

src/Parser/ExpressionNode.cc

-                      re149f77
+                      r695e00d
 // Created On       : Sat May 16 13:17:07 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Sep 13 14:54:19 2017
 // Update Count     : 683
+// Last Modified On : Thu Sep 14 23:09:34 2017
+// Update Count     : 690
 //
 …
 } // build_pfieldSel
-Expression * build_addressOf( ExpressionNode * expr_node ) {
-        return new AddressExpr( maybeMoveBuild< Expression >(expr_node) );
-} // build_addressOf
-Expression * build_sizeOfexpr( ExpressionNode * expr_node ) {
-        return new SizeofExpr( maybeMoveBuild< Expression >(expr_node) );
-} // build_sizeOfexpr
-Expression * build_sizeOftype( DeclarationNode * decl_node ) {
-        return new SizeofExpr( maybeMoveBuildType( decl_node ) );
-} // build_sizeOftype
-Expression * build_alignOfexpr( ExpressionNode * expr_node ) {
-        return new AlignofExpr( maybeMoveBuild< Expression >(expr_node) );
-} // build_alignOfexpr
-Expression * build_alignOftype( DeclarationNode * decl_node ) {
-        return new AlignofExpr( maybeMoveBuildType( decl_node) );
-} // build_alignOftype
 Expression * build_offsetOf( DeclarationNode * decl_node, NameExpr * member ) {
         Expression * ret = new UntypedOffsetofExpr( maybeMoveBuildType( decl_node ), member->get_name() );
 …
 } // build_cond
-Expression * build_attrexpr( NameExpr * var, ExpressionNode * expr_node ) {
-        return new AttrExpr( var, maybeMoveBuild< Expression >(expr_node) );
-} // build_attrexpr
-Expression * build_attrtype( NameExpr * var, DeclarationNode * decl_node ) {
-        return new AttrExpr( var, maybeMoveBuildType( decl_node ) );
-} // build_attrtype
 Expression * build_tuple( ExpressionNode * expr_node ) {
         list< Expression * > exprs;
 …
         return new UntypedExpr( maybeMoveBuild< Expression >(function), args, nullptr );
 } // build_func
-Expression * build_range( ExpressionNode * low, ExpressionNode * high ) {
-        return new RangeExpr( maybeMoveBuild< Expression >( low ), maybeMoveBuild< Expression >( high ) );
-} // build_range
 Expression * build_compoundLiteral( DeclarationNode * decl_node, InitializerNode * kids ) {

src/Parser/ParseNode.h

-                      re149f77
+                      r695e00d
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Sep 13 12:35:10 2017
 // Update Count     : 807
+// Last Modified On : Thu Sep 14 23:09:39 2017
+// Update Count     : 815
 //
 …
 Expression * build_fieldSel( ExpressionNode * expr_node, Expression * member );
 Expression * build_pfieldSel( ExpressionNode * expr_node, Expression * member );
-Expression * build_addressOf( ExpressionNode * expr_node );
-Expression * build_sizeOfexpr( ExpressionNode * expr_node );
-Expression * build_sizeOftype( DeclarationNode * decl_node );
-Expression * build_alignOfexpr( ExpressionNode * expr_node );
-Expression * build_alignOftype( DeclarationNode * decl_node );
 Expression * build_offsetOf( DeclarationNode * decl_node, NameExpr * member );
 Expression * build_and( ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
 …
 Expression * build_binary_ptr( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
 Expression * build_cond( ExpressionNode * expr_node1, ExpressionNode * expr_node2, ExpressionNode * expr_node3 );
-Expression * build_attrexpr( NameExpr * var, ExpressionNode * expr_node );
-Expression * build_attrtype( NameExpr * var, DeclarationNode * decl_node );
 Expression * build_tuple( ExpressionNode * expr_node = nullptr );
 Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node );
-Expression * build_range( ExpressionNode * low, ExpressionNode * high );
 Expression * build_compoundLiteral( DeclarationNode * decl_node, InitializerNode * kids );

src/Parser/parser.yy

-                      re149f77
+                      r695e00d
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Sep 13 11:01:20 2017
 // Update Count     : 2803
+// Last Modified On : Thu Sep 14 23:07:12 2017
+// Update Count     : 2815
 //
 …
                         switch ( $1 ) {
                           case OperKinds::AddressOf:
                                 $$ = new ExpressionNode( build_addressOf( $2 ) );
+                                $$ = new ExpressionNode( new AddressExpr( maybeMoveBuild< Expression >( $2 ) ) );
                                 break;
                           case OperKinds::PointTo:
 …
                                 break;
                           case OperKinds::And:
                                 $$ = new ExpressionNode( new AddressExpr( build_addressOf( $2 ) ) );
+                                $$ = new ExpressionNode( new AddressExpr( new AddressExpr( maybeMoveBuild< Expression >( $2 ) ) ) );
                                 break;
                           default:
 …
                 { $$ = new ExpressionNode( build_unary_ptr( OperKinds::Decr, $2 ) ); }
         | SIZEOF unary_expression
                 { $$ = new ExpressionNode( build_sizeOfexpr( $2 ) ); }
+                { $$ = new ExpressionNode( new SizeofExpr( maybeMoveBuild< Expression >( $2 ) ) ); }
         | SIZEOF '(' type_no_function ')'
                 { $$ = new ExpressionNode( build_sizeOftype( $3 ) ); }
+                { $$ = new ExpressionNode( new SizeofExpr( maybeMoveBuildType( $3 ) ) ); }
         | ALIGNOF unary_expression                                                      // GCC, variable alignment
                 { $$ = new ExpressionNode( build_alignOfexpr( $2 ) ); }
+                { $$ = new ExpressionNode( new AlignofExpr( maybeMoveBuild< Expression >( $2 ) ) ); }
         | ALIGNOF '(' type_no_function ')'                                      // GCC, type alignment
                 { $$ = new ExpressionNode( build_alignOftype( $3 ) ); }
+                { $$ = new ExpressionNode( new AlignofExpr( maybeMoveBuildType( $3 ) ) ); }
         | OFFSETOF '(' type_no_function ',' no_attr_identifier ')'
                 { $$ = new ExpressionNode( build_offsetOf( $3, build_varref( $5 ) ) ); }
         | ATTR_IDENTIFIER
                 { $$ = new ExpressionNode( build_attrexpr( build_varref( $1 ), nullptr ) ); }
+                { $$ = new ExpressionNode( new AttrExpr( build_varref( $1 ), maybeMoveBuild< Expression >( (ExpressionNode *)nullptr ) ) ); }
         | ATTR_IDENTIFIER '(' argument_expression ')'
                 { $$ = new ExpressionNode( build_attrexpr( build_varref( $1 ), $3 ) ); }
+                { $$ = new ExpressionNode( new AttrExpr( build_varref( $1 ), maybeMoveBuild< Expression >( $3 ) ) ); }
         | ATTR_IDENTIFIER '(' type ')'
                 { $$ = new ExpressionNode( build_attrtype( build_varref( $1 ), $3 ) ); }
+                { $$ = new ExpressionNode( new AttrExpr( build_varref( $1 ), maybeMoveBuildType( $3 ) ) ); }
+        ;
 …
         constant_expression                                                     { $$ = $1; }
         | constant_expression ELLIPSIS constant_expression      // GCC, subrange
                 { $$ = new ExpressionNode( build_range( $1, $3 ) ); }
+                { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild< Expression >( $1 ), maybeMoveBuild< Expression >( $3 ) ) ); }
         | subrange                                                                                      // CFA, subrange
+        ;
 …
                 { $$ = $3; }
         | '[' push constant_expression ELLIPSIS constant_expression pop ']' // GCC, multiple array elements
                 { $$ = new ExpressionNode( build_range( $3, $5 ) ); }
+                { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild< Expression >( $3 ), maybeMoveBuild< Expression >( $5 ) ) ); }
         | '.' '[' push field_list pop ']'                                       // CFA, tuple field selector
                 { $$ = $4; }
 …
 subrange:
         constant_expression '~' constant_expression                     // CFA, integer subrange
                 { $$ = new ExpressionNode( build_range( $1, $3 ) ); }
+                { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild< Expression >( $1 ), maybeMoveBuild< Expression >( $3 ) ) ); }
+        ;

src/ResolvExpr/AlternativeFinder.cc

re149f77	r695e00d
523	523	for ( AssertionSet::iterator i = assertSet.begin(); i != assertSet.end(); ++i ) {
524	524	if ( i->second.isUsed ) {
525		i~~->first->accept( indexer~~ );
	525	indexer.addId( i->first );
526	526	}
527	527	}

src/ResolvExpr/AlternativePrinter.cc

-                      re149f77
+                      r695e00d
 namespace ResolvExpr {
         AlternativePrinter::AlternativePrinter( std::ostream &os ) : SymTab::Indexer( false ), os( os ) {}
+        AlternativePrinter::AlternativePrinter( std::ostream &os ) : os( os ) {}
         void AlternativePrinter::visit( ExprStmt *exprStmt ) {
+        void AlternativePrinter::postvisit( ExprStmt *exprStmt ) {
                 TypeEnvironment env;
                 AlternativeFinder finder( *this, env );
+                AlternativeFinder finder( indexer, env );
                 finder.findWithAdjustment( exprStmt->get_expr() );
                 int count = 1;

src/ResolvExpr/AlternativePrinter.h

-                      re149f77
+                      r695e00d
 #include <iostream>          // for ostream
 #include "SymTab/Indexer.h"  // for Indexer
+#include "Common/PassVisitor.h"
 class ExprStmt;
 namespace ResolvExpr {
         class AlternativePrinter final : public SymTab::Indexer {
+        class AlternativePrinter final : public WithIndexer {
           public:
                 AlternativePrinter( std::ostream &os );
+                using SymTab::Indexer::visit;
+                virtual void visit( ExprStmt *exprStmt ) override;
+                void postvisit( ExprStmt *exprStmt );
           private:
                 std::ostream &os;

src/ResolvExpr/Resolver.cc

-                      re149f77
+                      r695e00d
 #include "Alternative.h"                 // for Alternative, AltList
 #include "AlternativeFinder.h"           // for AlternativeFinder, resolveIn...
+#include "Common/PassVisitor.h"          // for PassVisitor
 #include "Common/SemanticError.h"        // for SemanticError
 #include "Common/utility.h"              // for ValueGuard, group_iterate
 …
 namespace ResolvExpr {
+        class Resolver final : public SymTab::Indexer {
+          public:
+                Resolver() : SymTab::Indexer( false ) {}
+                Resolver( const SymTab:: Indexer & other ) : SymTab::Indexer( other ) {
+                        if ( const Resolver * res = dynamic_cast< const Resolver * >( &other ) ) {
+                                functionReturn = res->functionReturn;
+                                currentObject = res->currentObject;
+                                inEnumDecl = res->inEnumDecl;
+                        }
+                }
+                typedef SymTab::Indexer Parent;
+                using Parent::visit;
+                virtual void visit( FunctionDecl *functionDecl ) override;
+                virtual void visit( ObjectDecl *functionDecl ) override;
+                virtual void visit( TypeDecl *typeDecl ) override;
+                virtual void visit( EnumDecl * enumDecl ) override;
+                virtual void visit( ArrayType * at ) override;
+                virtual void visit( PointerType * at ) override;
+                virtual void visit( ExprStmt *exprStmt ) override;
+                virtual void visit( AsmExpr *asmExpr ) override;
+                virtual void visit( AsmStmt *asmStmt ) override;
+                virtual void visit( IfStmt *ifStmt ) override;
+                virtual void visit( WhileStmt *whileStmt ) override;
+                virtual void visit( ForStmt *forStmt ) override;
+                virtual void visit( SwitchStmt *switchStmt ) override;
+                virtual void visit( CaseStmt *caseStmt ) override;
+                virtual void visit( BranchStmt *branchStmt ) override;
+                virtual void visit( ReturnStmt *returnStmt ) override;
+                virtual void visit( ThrowStmt *throwStmt ) override;
+                virtual void visit( CatchStmt *catchStmt ) override;
+                virtual void visit( WaitForStmt *waitforStmt ) override;
+                virtual void visit( SingleInit *singleInit ) override;
+                virtual void visit( ListInit *listInit ) override;
+                virtual void visit( ConstructorInit *ctorInit ) override;
+        struct Resolver final : public WithIndexer, public WithGuards, public WithVisitorRef<Resolver>, public WithShortCircuiting {
+                Resolver() {}
+                Resolver( const SymTab::Indexer & other ) {
+                        indexer = other;
+                }
+                void previsit( FunctionDecl *functionDecl );
+                void postvisit( FunctionDecl *functionDecl );
+                void previsit( ObjectDecl *functionDecl );
+                void previsit( TypeDecl *typeDecl );
+                void previsit( EnumDecl * enumDecl );
+                void previsit( ArrayType * at );
+                void previsit( PointerType * at );
+                void previsit( ExprStmt *exprStmt );
+                void previsit( AsmExpr *asmExpr );
+                void previsit( AsmStmt *asmStmt );
+                void previsit( IfStmt *ifStmt );
+                void previsit( WhileStmt *whileStmt );
+                void previsit( ForStmt *forStmt );
+                void previsit( SwitchStmt *switchStmt );
+                void previsit( CaseStmt *caseStmt );
+                void previsit( BranchStmt *branchStmt );
+                void previsit( ReturnStmt *returnStmt );
+                void previsit( ThrowStmt *throwStmt );
+                void previsit( CatchStmt *catchStmt );
+                void previsit( WaitForStmt * stmt );
+                void previsit( SingleInit *singleInit );
+                void previsit( ListInit *listInit );
+                void previsit( ConstructorInit *ctorInit );
           private:
         typedef std::list< Initializer * >::iterator InitIterator;
 …
         void resolve( std::list< Declaration * > translationUnit ) {
                 Resolver resolver;
+                PassVisitor<Resolver> resolver;
                 acceptAll( translationUnit, resolver );
+        }
+        // used in resolveTypeof
         Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer ) {
                 TypeEnvironment env;
                 return resolveInVoidContext( expr, indexer, env );
+        }
         namespace {
 …
+        }
         void Resolver::visit( ObjectDecl *objectDecl ) {
                 Type *new_type = resolveTypeof( objectDecl->get_type(), *this );
+        void Resolver::previsit( ObjectDecl *objectDecl ) {
+                Type *new_type = resolveTypeof( objectDecl->get_type(), indexer );
                 objectDecl->set_type( new_type );
                 // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that class-variable
 …
                 // each value of initContext is retained, so the type on the first analysis is preserved and used for selecting
                 // the RHS.
                 ValueGuard<CurrentObject> temp( currentObject );
+                GuardValue( currentObject );
                 currentObject = CurrentObject( objectDecl->get_type() );
                 if ( inEnumDecl && dynamic_cast< EnumInstType * >( objectDecl->get_type() ) ) {
 …
                         currentObject = CurrentObject( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
+                }
-                Parent::visit( objectDecl );
-                if ( inEnumDecl && dynamic_cast< EnumInstType * >( objectDecl->get_type() ) ) {
-                        // delete newly created signed int type
-                        // delete currentObject.getType();
+                }
+        }
 …
                 if ( type->get_dimension() ) {
                         CastExpr *castExpr = new CastExpr( type->get_dimension(), SymTab::SizeType->clone() );
                         Expression *newExpr = findSingleExpression( castExpr, *this );
+                        Expression *newExpr = findSingleExpression( castExpr, indexer );
                         delete type->get_dimension();
                         type->set_dimension( newExpr );
 …
+        }
         void Resolver::visit( ArrayType * at ) {
+        void Resolver::previsit( ArrayType * at ) {
                 handlePtrType( at );
+                Parent::visit( at );
+        }
+        void Resolver::visit( PointerType * pt ) {
+        }
+        void Resolver::previsit( PointerType * pt ) {
                 handlePtrType( pt );
+                Parent::visit( pt );
+        }
+        void Resolver::visit( TypeDecl *typeDecl ) {
+        }
+        void Resolver::previsit( TypeDecl *typeDecl ) {
                 if ( typeDecl->get_base() ) {
                         Type *new_type = resolveTypeof( typeDecl->get_base(), *this );
+                        Type *new_type = resolveTypeof( typeDecl->get_base(), indexer );
                         typeDecl->set_base( new_type );
                 } // if
+                Parent::visit( typeDecl );
+        }
+        void Resolver::visit( FunctionDecl *functionDecl ) {
+        }
+        void Resolver::previsit( FunctionDecl *functionDecl ) {
 #if 0
                 std::cout << "resolver visiting functiondecl ";
                 functionDecl->print( std::cout );
                 std::cout << std::endl;
+                std::cerr << "resolver visiting functiondecl ";
+                functionDecl->print( std::cerr );
+                std::cerr << std::endl;
 #endif
                 Type *new_type = resolveTypeof( functionDecl->get_type(), *this );
+                Type *new_type = resolveTypeof( functionDecl->get_type(), indexer );
                 functionDecl->set_type( new_type );
                 ValueGuard< Type * > oldFunctionReturn( functionReturn );
+                GuardValue( functionReturn );
                 functionReturn = ResolvExpr::extractResultType( functionDecl->get_functionType() );
+                Parent::visit( functionDecl );
+        }
+        void Resolver::postvisit( FunctionDecl *functionDecl ) {
                 // default value expressions have an environment which shouldn't be there and trips up later passes.
                 // xxx - it might be necessary to somehow keep the information from this environment, but I can't currently
 …
+        }
         void Resolver::visit( EnumDecl * enumDecl ) {
+        void Resolver::previsit( EnumDecl * ) {
                 // in case we decide to allow nested enums
                 ValueGuard< bool > oldInEnumDecl( inEnumDecl );
+                GuardValue( inEnumDecl );
                 inEnumDecl = true;
                 Parent::visit( enumDecl );
+        }
         void Resolver::visit( ExprStmt *exprStmt ) {
+        }
+        void Resolver::previsit( ExprStmt *exprStmt ) {
+                visit_children = false;
                 assertf( exprStmt->get_expr(), "ExprStmt has null Expression in resolver" );
                 Expression *newExpr = findVoidExpression( exprStmt->get_expr(), *this );
+                Expression *newExpr = findVoidExpression( exprStmt->get_expr(), indexer );
                 delete exprStmt->get_expr();
                 exprStmt->set_expr( newExpr );
+        }
+        void Resolver::visit( AsmExpr *asmExpr ) {
+                Expression *newExpr = findVoidExpression( asmExpr->get_operand(), *this );
+        void Resolver::previsit( AsmExpr *asmExpr ) {
+                visit_children = false;
+                Expression *newExpr = findVoidExpression( asmExpr->get_operand(), indexer );
                 delete asmExpr->get_operand();
                 asmExpr->set_operand( newExpr );
                 if ( asmExpr->get_inout() ) {
                         newExpr = findVoidExpression( asmExpr->get_inout(), *this );
+                        newExpr = findVoidExpression( asmExpr->get_inout(), indexer );
                         delete asmExpr->get_inout();
                         asmExpr->set_inout( newExpr );
 …
+        }
+        void Resolver::visit( AsmStmt *asmStmt ) {
+                acceptAll( asmStmt->get_input(), *this);
+                acceptAll( asmStmt->get_output(), *this);
+        }
+        void Resolver::visit( IfStmt *ifStmt ) {
+                Expression *newExpr = findSingleExpression( ifStmt->get_condition(), *this );
+        void Resolver::previsit( AsmStmt *asmStmt ) {
+                visit_children = false;
+                acceptAll( asmStmt->get_input(), *visitor );
+                acceptAll( asmStmt->get_output(), *visitor );
+        }
+        void Resolver::previsit( IfStmt *ifStmt ) {
+                Expression *newExpr = findSingleExpression( ifStmt->get_condition(), indexer );
                 delete ifStmt->get_condition();
                 ifStmt->set_condition( newExpr );
+                Parent::visit( ifStmt );
+        }
+        void Resolver::visit( WhileStmt *whileStmt ) {
+                Expression *newExpr = findSingleExpression( whileStmt->get_condition(), *this );
+        }
+        void Resolver::previsit( WhileStmt *whileStmt ) {
+                Expression *newExpr = findSingleExpression( whileStmt->get_condition(), indexer );
                 delete whileStmt->get_condition();
                 whileStmt->set_condition( newExpr );
+                Parent::visit( whileStmt );
+        }
+        void Resolver::visit( ForStmt *forStmt ) {
+                Parent::visit( forStmt );
+        }
+        void Resolver::previsit( ForStmt *forStmt ) {
                 if ( forStmt->get_condition() ) {
                         Expression * newExpr = findSingleExpression( forStmt->get_condition(), *this );
+                        Expression * newExpr = findSingleExpression( forStmt->get_condition(), indexer );
                         delete forStmt->get_condition();
                         forStmt->set_condition( newExpr );
 …
                 if ( forStmt->get_increment() ) {
                         Expression * newExpr = findVoidExpression( forStmt->get_increment(), *this );
+                        Expression * newExpr = findVoidExpression( forStmt->get_increment(), indexer );
                         delete forStmt->get_increment();
                         forStmt->set_increment( newExpr );
 …
+        }
         void Resolver::visit( SwitchStmt *switchStmt ) {
                 ValueGuard< CurrentObject > oldCurrentObject( currentObject );
+        void Resolver::previsit( SwitchStmt *switchStmt ) {
+                GuardValue( currentObject );
                 Expression *newExpr;
                 newExpr = findIntegralExpression( switchStmt->get_condition(), *this );
+                newExpr = findIntegralExpression( switchStmt->get_condition(), indexer );
                 delete switchStmt->get_condition();
                 switchStmt->set_condition( newExpr );
                 currentObject = CurrentObject( newExpr->get_result() );
+                Parent::visit( switchStmt );
+        }
+        void Resolver::visit( CaseStmt *caseStmt ) {
+        }
+        void Resolver::previsit( CaseStmt *caseStmt ) {
                 if ( caseStmt->get_condition() ) {
                         std::list< InitAlternative > initAlts = currentObject.getOptions();
                         assertf( initAlts.size() == 1, "SwitchStmt did not correctly resolve an integral expression." );
                         CastExpr * castExpr = new CastExpr( caseStmt->get_condition(), initAlts.front().type->clone() );
                         Expression * newExpr = findSingleExpression( castExpr, *this );
+                        Expression * newExpr = findSingleExpression( castExpr, indexer );
                         castExpr = strict_dynamic_cast< CastExpr * >( newExpr );
                         caseStmt->set_condition( castExpr->get_arg() );
 …
                         delete castExpr;
+                }
                 Parent::visit( caseStmt );
+        }
         void Resolver::visit( BranchStmt *branchStmt ) {
+        }
+        void Resolver::previsit( BranchStmt *branchStmt ) {
+                visit_children = false;
                 // must resolve the argument for a computed goto
                 if ( branchStmt->get_type() == BranchStmt::Goto ) { // check for computed goto statement
 …
                                 PointerType pt( Type::Qualifiers(), v.clone() );
                                 CastExpr * castExpr = new CastExpr( arg, pt.clone() );
                                 Expression * newExpr = findSingleExpression( castExpr, *this ); // find best expression
+                                Expression * newExpr = findSingleExpression( castExpr, indexer ); // find best expression
                                 branchStmt->set_target( newExpr );
                         } // if
 …
+        }
+        void Resolver::visit( ReturnStmt *returnStmt ) {
+        void Resolver::previsit( ReturnStmt *returnStmt ) {
+                visit_children = false;
                 if ( returnStmt->get_expr() ) {
                         CastExpr *castExpr = new CastExpr( returnStmt->get_expr(), functionReturn->clone() );
                         Expression *newExpr = findSingleExpression( castExpr, *this );
+                        Expression *newExpr = findSingleExpression( castExpr, indexer );
                         delete castExpr;
                         returnStmt->set_expr( newExpr );
 …
+        }
+        void Resolver::visit( ThrowStmt *throwStmt ) {
+        void Resolver::previsit( ThrowStmt *throwStmt ) {
+                visit_children = false;
                 // TODO: Replace *exception type with &exception type.
                 if ( throwStmt->get_expr() ) {
                         StructDecl * exception_decl =
                                 lookupStruct( "__cfaehm__base_exception_t" );
+                                indexer.lookupStruct( "__cfaehm__base_exception_t" );
                         assert( exception_decl );
                         Expression * wrapped = new CastExpr(
 …
+                                        )
                                 );
                         Expression * newExpr = findSingleExpression( wrapped, *this );
+                        Expression * newExpr = findSingleExpression( wrapped, indexer );
                         throwStmt->set_expr( newExpr );
+                }
+        }
+        void Resolver::visit( CatchStmt *catchStmt ) {
+                // inline Indexer::visit so that the exception variable is still in-scope for
+                // findSingleExpression() below
+                Parent::enterScope();
+                Visitor::visit( catchStmt );
+        void Resolver::previsit( CatchStmt *catchStmt ) {
                 if ( catchStmt->get_cond() ) {
                         Expression * wrapped = new CastExpr(
 …
                                 new BasicType( noQualifiers, BasicType::Bool )
                                 );
+                        catchStmt->set_cond( findSingleExpression( wrapped, *this ) );
+                }
+                Parent::leaveScope();
+                        catchStmt->set_cond( findSingleExpression( wrapped, indexer ) );
+                }
+        }
 …
+        }
         void Resolver::visit( WaitForStmt * stmt ) {
+        void Resolver::previsit( WaitForStmt * stmt ) {
                 // Resolve all clauses first
 …
+        }
+        void Resolver::visit( SingleInit *singleInit ) {
+        void Resolver::previsit( SingleInit *singleInit ) {
+                visit_children = false;
                 // resolve initialization using the possibilities as determined by the currentObject cursor
                 UntypedInitExpr * untyped = new UntypedInitExpr( singleInit->get_value(), currentObject.getOptions() );
                 Expression * newExpr = findSingleExpression( untyped, *this );
+                Expression * newExpr = findSingleExpression( untyped, indexer );
                 InitExpr * initExpr = strict_dynamic_cast< InitExpr * >( newExpr );
 …
+        }
+        void Resolver::visit( ListInit * listInit ) {
+        void Resolver::previsit( ListInit * listInit ) {
+                visit_children = false;
                 // move cursor into brace-enclosed initializer-list
                 currentObject.enterListInit();
 …
                         Initializer * init = std::get<1>(p);
                         newDesignations.push_back( currentObject.findNext( des ) );
                         init->accept( *this );
+                        init->accept( *visitor );
+                }
                 // set the set of 'resolved' designations and leave the brace-enclosed initializer-list
 …
                 delete ctorInit->get_dtor();
                 ctorInit->set_dtor( NULL );
                 maybeAccept( ctorInit->get_init(), *this );
+                maybeAccept( ctorInit->get_init(), *visitor );
+        }
 …
         void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer ) {
                 assert( ctorInit );
                 Resolver resolver( indexer );
+                PassVisitor<Resolver> resolver( indexer );
                 ctorInit->accept( resolver );
+        }
 …
         void resolveStmtExpr( StmtExpr * stmtExpr, const SymTab::Indexer & indexer ) {
                 assert( stmtExpr );
                 Resolver resolver( indexer );
+                PassVisitor<Resolver> resolver( indexer );
                 stmtExpr->accept( resolver );
+        }
+        void Resolver::visit( ConstructorInit *ctorInit ) {
+        void Resolver::previsit( ConstructorInit *ctorInit ) {
+                visit_children = false;
                 // xxx - fallback init has been removed => remove fallbackInit function and remove complexity from FixInit and remove C-init from ConstructorInit
                 maybeAccept( ctorInit->get_ctor(), *this );
                 maybeAccept( ctorInit->get_dtor(), *this );
+                maybeAccept( ctorInit->get_ctor(), *visitor );
+                maybeAccept( ctorInit->get_dtor(), *visitor );
                 // found a constructor - can get rid of C-style initializer

src/SymTab/Indexer.cc

-                      re149f77
+                      r695e00d
                 return *this;
+        }
-        void Indexer::visit( ObjectDecl *objectDecl ) {
-                enterScope();
-                maybeAccept( objectDecl->get_type(), *this );
-                leaveScope();
-                maybeAccept( objectDecl->get_init(), *this );
-                maybeAccept( objectDecl->get_bitfieldWidth(), *this );
-                if ( objectDecl->get_name() != "" ) {
-                        debugPrint( "Adding object " << objectDecl->get_name() << std::endl );
-                        addId( objectDecl );
-                } // if
+        }
-        void Indexer::visit( FunctionDecl *functionDecl ) {
-                if ( functionDecl->get_name() == "" ) return;
-                debugPrint( "Adding function " << functionDecl->get_name() << std::endl );
-                addId( functionDecl );
-                enterScope();
-                maybeAccept( functionDecl->get_functionType(), *this );
-                maybeAccept( functionDecl->get_statements(), *this );
-                leaveScope();
+        }
-// A NOTE ON THE ORDER OF TRAVERSAL
-//
-// Types and typedefs have their base types visited before they are added to the type table.  This is ok, since there is
-// no such thing as a recursive type or typedef.
-//
-//             typedef struct { T *x; } T; // never allowed
-//
-// for structs/unions, it is possible to have recursion, so the decl should be added as if it's incomplete to begin, the
-// members are traversed, and then the complete type should be added (assuming the type is completed by this particular
-// declaration).
-//
-//             struct T { struct T *x; }; // allowed
-//
-// It is important to add the complete type to the symbol table *after* the members/base has been traversed, since that
-// traversal may modify the definition of the type and these modifications should be visible when the symbol table is
-// queried later in this pass.
-//
-// TODO: figure out whether recursive contexts are sensible/possible/reasonable.
-        void Indexer::visit( TypeDecl *typeDecl ) {
-                // see A NOTE ON THE ORDER OF TRAVERSAL, above
-                // note that assertions come after the type is added to the symtab, since they are not part of the type proper
-                // and may depend on the type itself
-                enterScope();
-                acceptAll( typeDecl->get_parameters(), *this );
-                maybeAccept( typeDecl->get_base(), *this );
-                leaveScope();
-                debugPrint( "Adding type " << typeDecl->get_name() << std::endl );
-                addType( typeDecl );
-                acceptAll( typeDecl->get_assertions(), *this );
-                acceptNewScope( typeDecl->get_init(), *this );
+        }
-        void Indexer::visit( TypedefDecl *typeDecl ) {
-                enterScope();
-                acceptAll( typeDecl->get_parameters(), *this );
-                maybeAccept( typeDecl->get_base(), *this );
-                leaveScope();
-                debugPrint( "Adding typedef " << typeDecl->get_name() << std::endl );
-                addType( typeDecl );
+        }
-        void Indexer::visit( StructDecl *aggregateDecl ) {
-                // make up a forward declaration and add it before processing the members
-                // needs to be on the heap because addStruct saves the pointer
-                StructDecl &fwdDecl = *new StructDecl( aggregateDecl->get_name() );
-                cloneAll( aggregateDecl->get_parameters(), fwdDecl.get_parameters() );
-                debugPrint( "Adding fwd decl for struct " << fwdDecl.get_name() << std::endl );
-                addStruct( &fwdDecl );
-                enterScope();
-                acceptAll( aggregateDecl->get_parameters(), *this );
-                acceptAll( aggregateDecl->get_members(), *this );
-                leaveScope();
-                debugPrint( "Adding struct " << aggregateDecl->get_name() << std::endl );
-                // this addition replaces the forward declaration
-                addStruct( aggregateDecl );
+        }
-        void Indexer::visit( UnionDecl *aggregateDecl ) {
-                // make up a forward declaration and add it before processing the members
-                UnionDecl fwdDecl( aggregateDecl->get_name() );
-                cloneAll( aggregateDecl->get_parameters(), fwdDecl.get_parameters() );
-                debugPrint( "Adding fwd decl for union " << fwdDecl.get_name() << std::endl );
-                addUnion( &fwdDecl );
-                enterScope();
-                acceptAll( aggregateDecl->get_parameters(), *this );
-                acceptAll( aggregateDecl->get_members(), *this );
-                leaveScope();
-                debugPrint( "Adding union " << aggregateDecl->get_name() << std::endl );
-                addUnion( aggregateDecl );
+        }
-        void Indexer::visit( EnumDecl *aggregateDecl ) {
-                debugPrint( "Adding enum " << aggregateDecl->get_name() << std::endl );
-                addEnum( aggregateDecl );
-                // unlike structs, contexts, and unions, enums inject their members into the global scope
-                acceptAll( aggregateDecl->get_members(), *this );
+        }
-        void Indexer::visit( TraitDecl *aggregateDecl ) {
-                enterScope();
-                acceptAll( aggregateDecl->get_parameters(), *this );
-                acceptAll( aggregateDecl->get_members(), *this );
-                leaveScope();
-                debugPrint( "Adding trait " << aggregateDecl->get_name() << std::endl );
-                addTrait( aggregateDecl );
+        }
-        void Indexer::visit( CompoundStmt *compoundStmt ) {
-                enterScope();
-                acceptAll( compoundStmt->get_kids(), *this );
-                leaveScope();
+        }
-        void Indexer::visit( IfStmt *ifStmt ) {
-            // for statements introduce a level of scope
-            enterScope();
-            Visitor::visit( ifStmt );
-            leaveScope();
+        }
-        void Indexer::visit( ForStmt *forStmt ) {
-            // for statements introduce a level of scope
-            enterScope();
-            Visitor::visit( forStmt );
-            leaveScope();
+        }
-        void Indexer::visit( CatchStmt *catchStmt ) {
-                // catch statements introduce a level of scope (for the caught exception)
-                enterScope();
-                Visitor::visit( catchStmt );
-                leaveScope();
+        }
-        void Indexer::visit( ApplicationExpr *applicationExpr ) {
-                acceptNewScope( applicationExpr->get_result(), *this );
-                maybeAccept( applicationExpr->get_function(), *this );
-                acceptAll( applicationExpr->get_args(), *this );
+        }
-        void Indexer::visit( UntypedExpr *untypedExpr ) {
-                acceptNewScope( untypedExpr->get_result(), *this );
-                acceptAll( untypedExpr->get_args(), *this );
+        }
-        void Indexer::visit( NameExpr *nameExpr ) {
-                acceptNewScope( nameExpr->get_result(), *this );
+        }
-        void Indexer::visit( AddressExpr *addressExpr ) {
-                acceptNewScope( addressExpr->get_result(), *this );
-                maybeAccept( addressExpr->get_arg(), *this );
+        }
-        void Indexer::visit( LabelAddressExpr *labAddressExpr ) {
-                acceptNewScope( labAddressExpr->get_result(), *this );
+        }
-        void Indexer::visit( CastExpr *castExpr ) {
-                acceptNewScope( castExpr->get_result(), *this );
-                maybeAccept( castExpr->get_arg(), *this );
+        }
-        void Indexer::visit( UntypedMemberExpr *memberExpr ) {
-                acceptNewScope( memberExpr->get_result(), *this );
-                maybeAccept( memberExpr->get_aggregate(), *this );
+        }
-        void Indexer::visit( MemberExpr *memberExpr ) {
-                acceptNewScope( memberExpr->get_result(), *this );
-                maybeAccept( memberExpr->get_aggregate(), *this );
+        }
-        void Indexer::visit( VariableExpr *variableExpr ) {
-                acceptNewScope( variableExpr->get_result(), *this );
+        }
-        void Indexer::visit( ConstantExpr *constantExpr ) {
-                acceptNewScope( constantExpr->get_result(), *this );
-                maybeAccept( constantExpr->get_constant(), *this );
+        }
-        void Indexer::visit( SizeofExpr *sizeofExpr ) {
-                acceptNewScope( sizeofExpr->get_result(), *this );
-                if ( sizeofExpr->get_isType() ) {
-                        maybeAccept( sizeofExpr->get_type(), *this );
-                } else {
-                        maybeAccept( sizeofExpr->get_expr(), *this );
+                }
+        }
-        void Indexer::visit( AlignofExpr *alignofExpr ) {
-                acceptNewScope( alignofExpr->get_result(), *this );
-                if ( alignofExpr->get_isType() ) {
-                        maybeAccept( alignofExpr->get_type(), *this );
-                } else {
-                        maybeAccept( alignofExpr->get_expr(), *this );
+                }
+        }
-        void Indexer::visit( UntypedOffsetofExpr *offsetofExpr ) {
-                acceptNewScope( offsetofExpr->get_result(), *this );
-                maybeAccept( offsetofExpr->get_type(), *this );
+        }
-        void Indexer::visit( OffsetofExpr *offsetofExpr ) {
-                acceptNewScope( offsetofExpr->get_result(), *this );
-                maybeAccept( offsetofExpr->get_type(), *this );
-                maybeAccept( offsetofExpr->get_member(), *this );
+        }
-        void Indexer::visit( OffsetPackExpr *offsetPackExpr ) {
-                acceptNewScope( offsetPackExpr->get_result(), *this );
-                maybeAccept( offsetPackExpr->get_type(), *this );
+        }
-        void Indexer::visit( AttrExpr *attrExpr ) {
-                acceptNewScope( attrExpr->get_result(), *this );
-                if ( attrExpr->get_isType() ) {
-                        maybeAccept( attrExpr->get_type(), *this );
-                } else {
-                        maybeAccept( attrExpr->get_expr(), *this );
+                }
+        }
-        void Indexer::visit( LogicalExpr *logicalExpr ) {
-                acceptNewScope( logicalExpr->get_result(), *this );
-                maybeAccept( logicalExpr->get_arg1(), *this );
-                maybeAccept( logicalExpr->get_arg2(), *this );
+        }
-        void Indexer::visit( ConditionalExpr *conditionalExpr ) {
-                acceptNewScope( conditionalExpr->get_result(), *this );
-                maybeAccept( conditionalExpr->get_arg1(), *this );
-                maybeAccept( conditionalExpr->get_arg2(), *this );
-                maybeAccept( conditionalExpr->get_arg3(), *this );
+        }
-        void Indexer::visit( CommaExpr *commaExpr ) {
-                acceptNewScope( commaExpr->get_result(), *this );
-                maybeAccept( commaExpr->get_arg1(), *this );
-                maybeAccept( commaExpr->get_arg2(), *this );
+        }
-        void Indexer::visit( TypeExpr *typeExpr ) {
-                acceptNewScope( typeExpr->get_result(), *this );
-                maybeAccept( typeExpr->get_type(), *this );
+        }
-        void Indexer::visit( AsmExpr *asmExpr ) {
-                maybeAccept( asmExpr->get_inout(), *this );
-                maybeAccept( asmExpr->get_constraint(), *this );
-                maybeAccept( asmExpr->get_operand(), *this );
+        }
-        void Indexer::visit( ImplicitCopyCtorExpr *impCpCtorExpr ) {
-                acceptNewScope( impCpCtorExpr->get_result(), *this );
-                maybeAccept( impCpCtorExpr->get_callExpr(), *this );
-                acceptAll( impCpCtorExpr->get_tempDecls(), *this );
-                acceptAll( impCpCtorExpr->get_returnDecls(), *this );
-                acceptAll( impCpCtorExpr->get_dtors(), *this );
+        }
-        void Indexer::visit( ConstructorExpr * ctorExpr ) {
-                acceptNewScope( ctorExpr->get_result(), *this );
-                maybeAccept( ctorExpr->get_callExpr(), *this );
+        }
-        void Indexer::visit( CompoundLiteralExpr *compLitExpr ) {
-                acceptNewScope( compLitExpr->get_result(), *this );
-                maybeAccept( compLitExpr->get_initializer(), *this );
+        }
-        void Indexer::visit( RangeExpr *rangeExpr ) {
-                maybeAccept( rangeExpr->get_low(), *this );
-                maybeAccept( rangeExpr->get_high(), *this );
+        }
-        void Indexer::visit( UntypedTupleExpr *tupleExpr ) {
-                acceptNewScope( tupleExpr->get_result(), *this );
-                acceptAll( tupleExpr->get_exprs(), *this );
+        }
-        void Indexer::visit( TupleExpr *tupleExpr ) {
-                acceptNewScope( tupleExpr->get_result(), *this );
-                acceptAll( tupleExpr->get_exprs(), *this );
+        }
-        void Indexer::visit( TupleIndexExpr *tupleExpr ) {
-                acceptNewScope( tupleExpr->get_result(), *this );
-                maybeAccept( tupleExpr->get_tuple(), *this );
+        }
-        void Indexer::visit( TupleAssignExpr *tupleExpr ) {
-                acceptNewScope( tupleExpr->get_result(), *this );
-                maybeAccept( tupleExpr->get_stmtExpr(), *this );
+        }
-        void Indexer::visit( StmtExpr *stmtExpr ) {
-                acceptNewScope( stmtExpr->get_result(), *this );
-                maybeAccept( stmtExpr->get_statements(), *this );
-                acceptAll( stmtExpr->get_returnDecls(), *this );
-                acceptAll( stmtExpr->get_dtors(), *this );
+        }
-        void Indexer::visit( UniqueExpr *uniqueExpr ) {
-                acceptNewScope( uniqueExpr->get_result(), *this );
-                maybeAccept( uniqueExpr->get_expr(), *this );
+        }
-        void Indexer::visit( TraitInstType *traitInst ) {
-                acceptAll( traitInst->get_parameters(), *this );
+        }
-        void Indexer::visit( StructInstType *structInst ) {
-                if ( ! lookupStruct( structInst->get_name() ) ) {
-                        debugPrint( "Adding struct " << structInst->get_name() << " from implicit forward declaration" << std::endl );
-                        addStruct( structInst->get_name() );
+                }
-                enterScope();
-                acceptAll( structInst->get_parameters(), *this );
-                leaveScope();
+        }
-        void Indexer::visit( UnionInstType *unionInst ) {
-                if ( ! lookupUnion( unionInst->get_name() ) ) {
-                        debugPrint( "Adding union " << unionInst->get_name() << " from implicit forward declaration" << std::endl );
-                        addUnion( unionInst->get_name() );
+                }
-                enterScope();
-                acceptAll( unionInst->get_parameters(), *this );
-                leaveScope();
+        }
 …
         void Indexer::addId( DeclarationWithType *decl ) {
+                debugPrint( "Adding Id " << decl->name << std::endl );
                 makeWritable();
 …
         void Indexer::addType( NamedTypeDecl *decl ) {
+                debugPrint( "Adding type " << decl->name << std::endl );
                 makeWritable();
 …
         void Indexer::addStruct( const std::string &id ) {
+                debugPrint( "Adding fwd decl for struct " << id << std::endl );
                 addStruct( new StructDecl( id ) );
+        }
         void Indexer::addStruct( StructDecl *decl ) {
+                debugPrint( "Adding struct " << decl->name << std::endl );
                 makeWritable();
 …
         void Indexer::addEnum( EnumDecl *decl ) {
+                debugPrint( "Adding enum " << decl->name << std::endl );
                 makeWritable();
 …
         void Indexer::addUnion( const std::string &id ) {
+                debugPrint( "Adding fwd decl for union " << id << std::endl );
                 addUnion( new UnionDecl( id ) );
+        }
         void Indexer::addUnion( UnionDecl *decl ) {
+                debugPrint( "Adding union " << decl->name << std::endl );
                 makeWritable();
 …
         void Indexer::addTrait( TraitDecl *decl ) {
+                debugPrint( "Adding trait " << decl->name << std::endl );
                 makeWritable();

src/SymTab/Indexer.h

-                      re149f77
+                      r695e00d
 namespace SymTab {
         class Indexer : public Visitor {
+        class Indexer {
           public:
                 explicit Indexer( bool useDebug = false );
 …
                 Indexer& operator= ( const Indexer &that );
                 Indexer& operator= ( Indexer &&that );
-                using Visitor::visit;
-                virtual void visit( ObjectDecl *objectDecl );
-                virtual void visit( FunctionDecl *functionDecl );
-                virtual void visit( TypeDecl *typeDecl );
-                virtual void visit( TypedefDecl *typeDecl );
-                virtual void visit( StructDecl *aggregateDecl );
-                virtual void visit( UnionDecl *aggregateDecl );
-                virtual void visit( EnumDecl *aggregateDecl );
-                virtual void visit( TraitDecl *aggregateDecl );
-                virtual void visit( CompoundStmt *compoundStmt );
-                virtual void visit( IfStmt *ifStmt );
-                virtual void visit( ForStmt *forStmt );
-                virtual void visit( CatchStmt *catchStmt );
-                virtual void visit( ApplicationExpr *applicationExpr );
-                virtual void visit( UntypedExpr *untypedExpr );
-                virtual void visit( NameExpr *nameExpr );
-                virtual void visit( CastExpr *castExpr );
-                virtual void visit( AddressExpr *addressExpr );
-                virtual void visit( LabelAddressExpr *labAddressExpr );
-                virtual void visit( UntypedMemberExpr *memberExpr );
-                virtual void visit( MemberExpr *memberExpr );
-                virtual void visit( VariableExpr *variableExpr );
-                virtual void visit( ConstantExpr *constantExpr );
-                virtual void visit( SizeofExpr *sizeofExpr );
-                virtual void visit( AlignofExpr *alignofExpr );
-                virtual void visit( UntypedOffsetofExpr *offsetofExpr );
-                virtual void visit( OffsetofExpr *offsetofExpr );
-                virtual void visit( OffsetPackExpr *offsetPackExpr );
-                virtual void visit( AttrExpr *attrExpr );
-                virtual void visit( LogicalExpr *logicalExpr );
-                virtual void visit( ConditionalExpr *conditionalExpr );
-                virtual void visit( CommaExpr *commaExpr );
-                virtual void visit( TypeExpr *typeExpr );
-                virtual void visit( AsmExpr *asmExpr );
-                virtual void visit( ImplicitCopyCtorExpr *impCpCtorExpr );
-                virtual void visit( ConstructorExpr * ctorExpr );
-                virtual void visit( CompoundLiteralExpr *compLitExpr );
-                virtual void visit( RangeExpr *rangeExpr );
-                virtual void visit( UntypedTupleExpr *tupleExpr );
-                virtual void visit( TupleExpr *tupleExpr );
-                virtual void visit( TupleIndexExpr *tupleExpr );
-                virtual void visit( TupleAssignExpr *tupleExpr );
-                virtual void visit( StmtExpr * stmtExpr );
-                virtual void visit( UniqueExpr * uniqueExpr );
-                virtual void visit( TraitInstType *contextInst );
-                virtual void visit( StructInstType *contextInst );
-                virtual void visit( UnionInstType *contextInst );
                 // when using an indexer manually (e.g., within a mutator traversal), it is necessary to tell the indexer

src/libcfa/concurrency/coroutine.c

-                      re149f77
+                      r695e00d
+}
 void ^?{}(coStack_t& this) {
         if ( ! this.userStack ) {
+void ^?{}(coStack_t & this) {
+        if ( ! this.userStack && this.storage ) {
                 LIB_DEBUG_DO(
                         if ( mprotect( this.storage, pageSize, PROT_READ | PROT_WRITE ) == -1 ) {
 …
         //TEMP HACK do this on proper kernel startup
         if(pageSize == 0ul) pageSize = sysconf( _SC_PAGESIZE );
+        LIB_DEBUG_PRINT_SAFE("FRED");
         size_t cxtSize = libCeiling( sizeof(machine_context_t), 8 ); // minimum alignment

src/libcfa/concurrency/preemption.c

re149f77	r695e00d
243	243
244	244	// Setup proper signal handlers
245		__kernel_sigaction( SIGUSR1, sigHandler_ctxSwitch, SA_SIGINFO ); // CtxSwitch handler
	245	__kernel_sigaction( SIGUSR1, sigHandler_ctxSwitch, SA_SIGINFO \| SA_RESTART ); // CtxSwitch handler
246	246	// __kernel_sigaction( SIGSEGV, sigHandler_segv , SA_SIGINFO ); // Failure handler
247	247	// __kernel_sigaction( SIGBUS , sigHandler_segv , SA_SIGINFO ); // Failure handler

src/libcfa/iostream.c

-                      re149f77
+                      r695e00d
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Sep 11 09:21:24 2017
 // Update Count     : 420
+// Last Modified On : Sun Sep 17 23:24:25 2017
+// Update Count     : 422
 //
 …
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype * os, signed char c ) {
+        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
         fmt( os, "%hhd", c );
-        sepOff( os );
         return os;
 } // ?|?
 …
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype * os, unsigned char c ) {
+        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
         fmt( os, "%hhu", c );
-        sepOff( os );
         return os;
 } // ?|?

src/main.cc

-                      re149f77
+                      r695e00d
 #include "CodeTools/DeclStats.h"            // for printDeclStats
 #include "CodeTools/TrackLoc.h"             // for fillLocations
+#include "Common/PassVisitor.h"
 #include "Common/CompilerError.h"           // for CompilerError
 #include "Common/SemanticError.h"           // for SemanticError
 …
                 if ( expraltp ) {
                         ResolvExpr::AlternativePrinter printer( cout );
+                        PassVisitor<ResolvExpr::AlternativePrinter> printer( cout );
                         acceptAll( translationUnit, printer );
                         return 0;

Context Navigation

Legend:

doc/proposals/concurrency/Makefile

doc/proposals/concurrency/annex/local.bib

doc/proposals/concurrency/style/cfa-format.tex

doc/proposals/concurrency/text/basics.tex

doc/proposals/concurrency/text/cforall.tex

doc/proposals/concurrency/text/concurrency.tex

doc/proposals/concurrency/version

src/Common/PassVisitor.impl.h

src/GenPoly/Box.cc

src/InitTweak/FixInit.cc

src/Parser/ExpressionNode.cc

src/Parser/ParseNode.h

src/Parser/parser.yy

src/ResolvExpr/AlternativeFinder.cc

src/ResolvExpr/AlternativePrinter.cc

src/ResolvExpr/AlternativePrinter.h

src/ResolvExpr/Resolver.cc

src/SymTab/Indexer.cc

src/SymTab/Indexer.h

src/libcfa/concurrency/coroutine.c

src/libcfa/concurrency/preemption.c

src/libcfa/iostream.c

src/main.cc

Download in other formats: