Diff [f845e8037246bd5e7cd820b02574b6b12a8fa7c0:98b4b120d533ef4cef3eb4d2a31814b29043a42a] for / – Cforall

benchmark/Makefile.am

-                      rf845e80
+                      r98b4b12
 include $(top_srcdir)/src/cfa.make
 AM_CFLAGS = -O2 -Wall -I$(srcdir) -lrt -pthread
 AM_CFAFLAGS = -quiet -in-tree -nodebug
 AM_UPPFLAGS = -quiet -nodebug -multi
+AM_CFLAGS = -O2 -Wall -Wextra -Werror -I$(srcdir) -lrt -pthread
+AM_CFAFLAGS = -quiet -nodebug -in-tree
+AM_UPPFLAGS = -quiet -nodebug -multi -std=c++14
 BENCH_V_CC = $(__bench_v_CC_$(__quiet))
 …
         $(BENCH_V_CC)$(COMPILE) -DBENCH_N=500000000  $(srcdir)/fetch_add.c
+tls-fetch_add$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) -DBENCH_N=500000000  $(srcdir)/tls-fetch_add.c
 ## =========================================================================================================
 CTXSWITCH_DEPEND  =                 \
 …
         function.run                    \
         fetch_add.run                   \
+        tls-fetch_add.run                       \
         ctxswitch-pthread.run           \
         ctxswitch-cfa_coroutine.run     \

benchmark/Makefile.in

-                      rf845e80
+                      r98b4b12
 # applies to both programs
 AM_CFLAGS = -O2 -Wall -I$(srcdir) -lrt -pthread
 AM_CFAFLAGS = -quiet -in-tree -nodebug
 AM_UPPFLAGS = -quiet -nodebug -multi
+AM_CFLAGS = -O2 -Wall -Wextra -Werror -I$(srcdir) -lrt -pthread
+AM_CFAFLAGS = -quiet -nodebug -in-tree
+AM_UPPFLAGS = -quiet -nodebug -multi -std=c++14
 BENCH_V_CC = $(__bench_v_CC_$(__quiet))
 BENCH_V_CFA = $(__bench_v_CFA_$(__quiet))
 …
 dummy_SOURCES = dummyC.c dummyCXX.cpp
 CTXSWITCH_DEPEND = loop.run function.run fetch_add.run \
         ctxswitch-pthread.run ctxswitch-cfa_coroutine.run \
         ctxswitch-cfa_thread.run ctxswitch-cfa_thread2.run \
         ctxswitch-upp_coroutine.run ctxswitch-upp_thread.run \
         ctxswitch-goroutine.run ctxswitch-java_thread.run \
         $(am__append_1)
+        tls-fetch_add.run ctxswitch-pthread.run \
+        ctxswitch-cfa_coroutine.run ctxswitch-cfa_thread.run \
+        ctxswitch-cfa_thread2.run ctxswitch-upp_coroutine.run \
+        ctxswitch-upp_thread.run ctxswitch-goroutine.run \
+        ctxswitch-java_thread.run $(am__append_1)
 testdir = $(top_srcdir)/tests
 all: all-am
 …
         $(BENCH_V_CC)$(COMPILE) -DBENCH_N=500000000  $(srcdir)/fetch_add.c
+tls-fetch_add$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) -DBENCH_N=500000000  $(srcdir)/tls-fetch_add.c
 @WITH_LIBFIBRE_TRUE@ctxswitch-kos_fibre$(EXEEXT):
 @WITH_LIBFIBRE_TRUE@    $(BENCH_V_CXX)$(CXXCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/kos_fibre.cpp  -I$(LIBFIBRE_DIR) -lfibre

configure

-                      rf845e80
+                      r98b4b12
 #==============================================================================
 ac_config_files="$ac_config_files Makefile driver/Makefile src/Makefile benchmark/Makefile tests/Makefile tests/preempt_longrun/Makefile tools/Makefile tools/prettyprinter/Makefile"
+ac_config_files="$ac_config_files Makefile driver/Makefile src/Makefile benchmark/Makefile tests/Makefile longrun_tests/Makefile tools/Makefile tools/prettyprinter/Makefile"
 …
     "benchmark/Makefile") CONFIG_FILES="$CONFIG_FILES benchmark/Makefile" ;;
     "tests/Makefile") CONFIG_FILES="$CONFIG_FILES tests/Makefile" ;;
     "tests/preempt_longrun/Makefile") CONFIG_FILES="$CONFIG_FILES tests/preempt_longrun/Makefile" ;;
+    "longrun_tests/Makefile") CONFIG_FILES="$CONFIG_FILES longrun_tests/Makefile" ;;
     "tools/Makefile") CONFIG_FILES="$CONFIG_FILES tools/Makefile" ;;
     "tools/prettyprinter/Makefile") CONFIG_FILES="$CONFIG_FILES tools/prettyprinter/Makefile" ;;

configure.ac

rf845e80	r98b4b12
211	211	benchmark/Makefile
212	212	tests/Makefile
213		~~tests/preempt_longrun~~/Makefile
	213	longrun_tests/Makefile
214	214	tools/Makefile
215	215	tools/prettyprinter/Makefile

doc/bibliography/pl.bib

-                      rf845e80
+                      r98b4b12
     title       = {Checked C: Making C Safe by Extension},
     booktitle   = {2018 IEEE Cybersecurity Development (SecDev)},
     year = {2018},
     month = {September},
     pages = {53-60},
     publisher = {IEEE},
     url = {https://www.microsoft.com/en-us/research/publication/checkedc-making-c-safe-by-extension/},
+    year        = {2018},
+    month       = {September},
+    pages       = {53-60},
+    publisher   = {IEEE},
+    url         = {https://www.microsoft.com/en-us/research/publication/checkedc-making-c-safe-by-extension/},
+}
 @misc{Clang,
     keywords = {clang},
     contributer = {a3moss@uwaterloo.ca},
     title = {Clang: a {C} language family frontend for {LLVM}},
     howpublished = {\href{https://clang.llvm.org/}{https://\-clang.llvm.org/}}
+    keywords    = {clang},
+    contributer = {a3moss@uwaterloo.ca},
+    title       = {Clang: a {C} language family frontend for {LLVM}},
+    howpublished= {\href{https://clang.llvm.org/}{https://\-clang.llvm.org/}}
+}
 …
+}
+@article{Ritchie93,
+    keywords    = {C, history},
+    contributer = {pabuhr@plg},
+    author      = {Ritchie, Dennis M.},
+    title       = {The Development of the {C} Language},
+    journal     = sigplan,
+    volume      = 28,
+    number      = 3,
+    month       = mar,
+    year        = 1993,
+    pages       = {201--208},
+    url         = {http://doi.acm.org/10.1145/155360.155580},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+}
 @article{design,
     keywords    = {Smalltalk, designing classes},
 …
     journal     = joop,
     year        = 1988,
+    volume      = 1, number = 2, pages = {22-35},
+    volume      = 1,
+    number      = 2,
+    pages       = {22-35},
     comment     = {
         Abstract classes represent standard protocols.  ``It is better to
 …
     optaddress  = {Waterloo, Ontario, Canada, N2L 3G1},
     note        = {\href{https://uwspace.uwaterloo.ca/handle/10012/13935}{https://\-uwspace.uwaterloo.ca/\-handle/\-10012/\-13935}},
+}
+@article{Swift05,
+   contributer  = {pabuhr@plg},
+   author       = {Michael M. Swift and Brian N. Bershad and Henry M. Levy},
+   title        = {Improving the Reliability of Commodity Operating Systems},
+   journal      = tocs,
+   volume       = 23,
+   number       = 1,
+   month        = feb,
+   year         = 2005,
+   pages        = {77-110},
+}

doc/papers/concurrency/Paper.tex

-                      rf845e80
+                      r98b4b12
 {}
 \lstnewenvironment{Go}[1][]
+{\lstset{#1}}
+{\lstset{language=go,moredelim=**[is][\protect\color{red}]{`}{`},#1}\lstset{#1}}
+{}
+\lstnewenvironment{python}[1][]
+{\lstset{language=python,moredelim=**[is][\protect\color{red}]{`}{`},#1}\lstset{#1}}
 {}
 …
+}
 \title{\texorpdfstring{Advanced Control-flow in \protect\CFA}{Advanced Control-flow in Cforall}}
+\title{\texorpdfstring{Advanced Control-flow and Concurrency in \protect\CFA}{Advanced Control-flow in Cforall}}
 \author[1]{Thierry Delisle}
 …
 \abstract[Summary]{
 \CFA is a modern, polymorphic, non-object-oriented, backwards-compatible extension of the C programming language.
 This paper discusses the advanced control-flow features in \CFA, which include concurrency and parallelism, and its supporting runtime system.
 These features are created from scratch as ISO C's concurrency is low-level and unimplemented, so C programmers continue to rely on the C pthreads library.
 \CFA provides high-level control-flow mechanisms, like coroutines and user-level threads, and monitors for mutual exclusion and synchronization.
 A unique contribution of this work is allowing multiple monitors to be safely acquired \emph{simultaneously} (deadlock free), while integrating this capability with all monitor synchronization mechanisms.
 All features respect the expectations of C programmers, while being fully integrate with the \CFA polymorphic type-system and other language features.
+This paper discusses some advanced control-flow and concurrency/parallelism features in \CFA, along with the supporting runtime.
+These features are created from scratch because they do not exist in ISO C, or are low-level and/or unimplemented, so C programmers continue to rely on library features, like C pthreads.
+\CFA introduces language-level control-flow mechanisms, like coroutines, user-level threading, and monitors for mutual exclusion and synchronization.
+A unique contribution of this work is allowing multiple monitors to be safely acquired \emph{simultaneously} (deadlock free), while integrating this capability with monitor synchronization mechanisms.
+These features also integrate with the \CFA polymorphic type-system and exception handling, while respecting the expectations and style of C programmers.
 Experimental results show comparable performance of the new features with similar mechanisms in other concurrent programming-languages.
 }%
 …
 \section{Introduction}
 This paper discusses the design of advanced, high-level control-flow extensions (especially concurrency and parallelism) in \CFA and its runtime.
+This paper discusses the design of language-level control-flow and concurrency/parallelism extensions in \CFA and its runtime.
 \CFA is a modern, polymorphic, non-object-oriented\footnote{
 \CFA has features often associated with object-oriented programming languages, such as constructors, destructors, virtuals and simple inheritance.
 However, functions \emph{cannot} be nested in structures, so there is no lexical binding between a structure and set of functions (member/method) implemented by an implicit \lstinline@this@ (receiver) parameter.},
 backwards-compatible extension of the C programming language~\cite{Moss18}.
+Within the \CFA framework, new control-flow features were created from scratch.
+ISO \Celeven defines only a subset of the \CFA extensions, and with respect to concurrency~\cite[\S~7.26]{C11}, the features are largely wrappers for a subset of the pthreads library~\cite{Butenhof97,Pthreads}.
+Furthermore, \Celeven and pthreads concurrency is basic, based on thread fork/join in a function and a few locks, which is low-level and error prone;
+no high-level language concurrency features exist.
+Interestingly, almost a decade after publication of the \Celeven standard, neither gcc-8, clang-8 nor msvc-19 (most recent versions) support the \Celeven include @threads.h@, indicating little interest in the C concurrency approach.
+Finally, while the \Celeven standard does not state a concurrent threading-model, the historical association with pthreads suggests the threading model is kernel-level threading (1:1)~\cite{ThreadModel}.
+Within the \CFA framework, new control-flow features are created from scratch.
+ISO \Celeven defines only a subset of the \CFA extensions, where the overlapping features are concurrency~\cite[\S~7.26]{C11}.
+However, \Celeven concurrency is largely wrappers for a subset of the pthreads library~\cite{Butenhof97,Pthreads}.
+Furthermore, \Celeven and pthreads concurrency is simple, based on thread fork/join in a function and a few locks, which is low-level and error prone;
+no high-level language concurrency features are defined.
+Interestingly, almost a decade after publication of the \Celeven standard, neither gcc-8, clang-8 nor msvc-19 (most recent versions) support the \Celeven include @threads.h@, indicating little interest in the C11 concurrency approach.
+Finally, while the \Celeven standard does not state a concurrent threading-model, the historical association with pthreads suggests implementations would adopt kernel-level threading (1:1)~\cite{ThreadModel}.
 In contrast, there has been a renewed interest during the past decade in user-level (M:N, green) threading in old and new programming languages.
 …
 A further effort over the past decade is the development of language memory-models to deal with the conflict between certain language features and compiler/hardware optimizations.
 This issue can be rephrased as some features are pervasive (language and runtime) and cannot be safely added via a library to prevent invalidation by sequential optimizations~\cite{Buhr95a,Boehm05}.
+This issue can be rephrased as: some language features are pervasive (language and runtime) and cannot be safely added via a library to prevent invalidation by sequential optimizations~\cite{Buhr95a,Boehm05}.
 The consequence is that a language must be cognizant of these features and provide sufficient tools to program around any safety issues.
 For example, C created the @volatile@ qualifier to provide correct execution for @setjmp@/@logjmp@ (concurrency came later).
 The simplest solution is to provide a handful of complex qualifiers and functions (e.g., @volatile@ and atomics) allowing programmers to write consistent/race-free programs, often in the sequentially-consistent memory-model~\cite{Boehm12}.
+The common solution is to provide a handful of complex qualifiers and functions (e.g., @volatile@ and atomics) allowing programmers to write consistent/race-free programs, often in the sequentially-consistent memory-model~\cite{Boehm12}.
 While having a sufficient memory-model allows sound libraries to be constructed, writing these libraries can quickly become awkward and error prone, and using these low-level libraries has the same issues.
 Essentially, using low-level explicit locks is the concurrent equivalent of assembler programming.
 Just as most assembler programming is replaced with programming in a high-level language, explicit locks can be replaced with high-level concurrency constructs in a programming language.
 The goal is to get the compiler to check for correct usage and follow any complex coding conventions implicitly.
+Just as most assembler programming is replaced with high-level programming, explicit locks can be replaced with high-level concurrency in a programming language.
+Then the goal is for the compiler to check for correct usage and follow any complex coding conventions implicitly.
 The drawback is that language constructs may preclude certain specialized techniques, therefore introducing inefficiency or inhibiting concurrency.
 For most concurrent programs, these drawbacks are insignificant in comparison to the speed of composition, and subsequent reliability and maintainability of the high-level concurrent program.
 …
 As stated, this observation applies to non-concurrent forms of complex control-flow, like exception handling and coroutines.
 Adapting the programming language allows matching the control-flow model with the programming-language style, versus adapting to one general (sound) library/paradigm.
+Adapting the programming language to these features also allows matching the control-flow model with the programming-language style, versus adopting one general (sound) library/paradigm.
 For example, it is possible to provide exceptions, coroutines, monitors, and tasks as specialized types in an object-oriented language, integrating these constructs to allow leveraging the type-system (static type-checking) and all other object-oriented capabilities~\cite{uC++}.
 It is also possible to leverage call/return for blocking communication via new control structures, versus switching to alternative communication paradigms, like channels or message passing.
 …
 however, the reverse is seldom true, i.e., given implicit concurrency, e.g., actors, it is virtually impossible to create explicit concurrency, e.g., blocking thread objects.}
 Finally, with extended language features and user-level threading it is possible to discretely fold locking and non-blocking I/O multiplexing into the language's I/O libraries, so threading implicitly dovetails with the I/O subsystem.
+\CFA embraces language extensions and user-level threading to provide advanced control-flow and concurrency.
+We attempt to show the \CFA extensions and runtime are demonstrably better than those proposed for \CC and other concurrent, imperative programming languages.
+The contributions of this work are:
+\CFA embraces language extensions and user-level threading to provide advanced control-flow (exception handling\footnote{
+\CFA exception handling will be presented in a separate paper.
+The key feature that dovetails with this paper is non-local exceptions allowing exceptions to be raised across stacks, with synchronous exceptions raised among coroutines and asynchronous exceptions raised among threads, similar to that in \uC~\cite[\S~5]{uC++}
+} and coroutines) and concurrency.
+Most augmented traditional (Fortran 18~\cite{Fortran18}, Cobol 14~\cite{Cobol14}, Ada 12~\cite{Ada12}, Java 11~\cite{Java11}) and new languages (Go~\cite{Go}, Rust~\cite{Rust}, and D~\cite{D}), except \CC, diverge from C with different syntax and semantics, only interoperate indirectly with C, and are not systems languages, for those with managed memory.
+As a result, there is a significant learning curve to move to these languages, and C legacy-code must be rewritten.
+While \CC, like \CFA, takes an evolutionary approach to extend C, \CC's constantly growing complex and interdependent features-set (e.g., objects, inheritance, templates, etc.) mean idiomatic \CC code is difficult to use from C, and C programmers must expend significant effort learning \CC.
+Hence, rewriting and retraining costs for these languages, even \CC, are prohibitive for companies with a large C software-base.
+\CFA with its orthogonal feature-set, its high-performance runtime, and direct access to all existing C libraries circumvents these problems.
+We present comparative examples so the reader can judge if the \CFA control-flow extensions are equivalent or better than those in or proposed for \Celeven, \CC and other concurrent, imperative programming languages, and perform experiments to show the \CFA runtime is competitive with other similar mechanisms.
+The detailed contributions of this work are:
 \begin{itemize}
 \item
 …
 \section{Coroutines: A Stepping Stone}\label{coroutine}
+Advanced controlWhile the focus of this discussion is concurrency and parallelism, it is important to address coroutines, which are a significant building block of a concurrency system (but not concurrent among themselves).
+\section{Coroutines: Stepping Stone}
+\label{coroutine}
 Coroutines are generalized routines allowing execution to be temporarily suspended and later resumed.
 Hence, unlike a normal routine, a coroutine may not terminate when it returns to its caller, allowing it to be restarted with the values and execution location present at the point of suspension.
 …
 \centering
 \newbox\myboxA
+% \begin{lrbox}{\myboxA}
+% \begin{cfa}[aboveskip=0pt,belowskip=0pt]
+% `int fn1, fn2, state = 1;`   // single global variables
+% int fib() {
+%       int fn;
+%       `switch ( state )` {  // explicit execution state
+%         case 1: fn = 0;  fn1 = fn;  state = 2;  break;
+%         case 2: fn = 1;  fn2 = fn1;  fn1 = fn;  state = 3;  break;
+%         case 3: fn = fn1 + fn2;  fn2 = fn1;  fn1 = fn;  break;
+%       }
+%       return fn;
+% }
+% int main() {
+%
+%       for ( int i = 0; i < 10; i += 1 ) {
+%               printf( "%d\n", fib() );
+%       }
+% }
+% \end{cfa}
+% \end{lrbox}
 \begin{lrbox}{\myboxA}
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
+`int f1, f2, state = 1;`   // single global variables
+int fib() {
+        int fn;
+        `switch ( state )` {  // explicit execution state
+          case 1: fn = 0;  f1 = fn;  state = 2;  break;
+          case 2: fn = 1;  f2 = f1;  f1 = fn;  state = 3;  break;
+          case 3: fn = f1 + f2;  f2 = f1;  f1 = fn;  break;
+        }
+        return fn;
+}
+#define FIB_INIT { 0, 1 }
+typedef struct { int fn1, fn; } Fib;
+int fib( Fib * f ) {
+        int ret = f->fn1;
+        f->fn1 = f->fn;
+        f->fn = ret + f->fn;
+        return ret;
+}
 int main() {
+        Fib f1 = FIB_INIT, f2 = FIB_INIT;
         for ( int i = 0; i < 10; i += 1 ) {
+                printf( "%d\n", fib() );
+                printf( "%d %d\n",
+                                fib( &f1 ), fib( &f2 ) );
+        }
+}
 …
 \begin{lrbox}{\myboxB}
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
+#define FIB_INIT `{ 0, 1 }`
+typedef struct { int f2, f1; } Fib;
+int fib( Fib * f ) {
+        int ret = f->f2;
+        int fn = f->f1 + f->f2;
+        f->f2 = f->f1; f->f1 = fn;
+        return ret;
+}
+int main() {
+        Fib f1 = FIB_INIT, f2 = FIB_INIT;
+        for ( int i = 0; i < 10; i += 1 ) {
+                printf( "%d %d\n", fib( &f1 ), fib( &f2 ) );
+`coroutine` Fib { int fn1; };
+void main( Fib & fib ) with( fib ) {
+        int fn;
+        [fn1, fn] = [0, 1];
+        for () {
+                `suspend();`
+                [fn1, fn] = [fn, fn1 + fn];
+        }
+}
+\end{cfa}
+\end{lrbox}
+\subfloat[3 States: global variables]{\label{f:GlobalVariables}\usebox\myboxA}
+\qquad
+\subfloat[1 State: external variables]{\label{f:ExternalState}\usebox\myboxB}
+\caption{C Fibonacci Implementations}
+\label{f:C-fibonacci}
+\bigskip
+\newbox\myboxA
+\begin{lrbox}{\myboxA}
+\begin{cfa}[aboveskip=0pt,belowskip=0pt]
+`coroutine` Fib { int fn; };
+void main( Fib & fib ) with( fib ) {
+        int f1, f2;
+        fn = 0;  f1 = fn;  `suspend()`;
+        fn = 1;  f2 = f1;  f1 = fn;  `suspend()`;
+        for ( ;; ) {
+                fn = f1 + f2;  f2 = f1;  f1 = fn;  `suspend()`;
+        }
+}
+int next( Fib & fib ) with( fib ) {
+        `resume( fib );`
+        return fn;
+int ?()( Fib & fib ) with( fib ) {
+        `resume( fib );`  return fn1;
+}
 int main() {
         Fib f1, f2;
+        for ( int i = 1; i <= 10; i += 1 ) {
+                sout | next( f1 ) | next( f2 );
+        }
+}
+        for ( 10 ) {
+                sout | f1() | f2();
+}
 \end{cfa}
 \end{lrbox}
+\newbox\myboxB
+\begin{lrbox}{\myboxB}
+\begin{cfa}[aboveskip=0pt,belowskip=0pt]
+`coroutine` Fib { int ret; };
+void main( Fib & f ) with( fib ) {
+        int fn, f1 = 1, f2 = 0;
+        for ( ;; ) {
+                ret = f2;
+                fn = f1 + f2;  f2 = f1;  f1 = fn; `suspend();`
+        }
+}
+int next( Fib & fib ) with( fib ) {
+        `resume( fib );`
+        return ret;
+}
+\end{cfa}
+\newbox\myboxC
+\begin{lrbox}{\myboxC}
+\begin{python}[aboveskip=0pt,belowskip=0pt]
+def Fib():
+    fn1, fn = 0, 1
+    while True:
+        `yield fn1`
+        fn1, fn = fn, fn1 + fn
+// next prewritten
+f1 = Fib()
+f2 = Fib()
+for i in range( 10 ):
+        print( next( f1 ), next( f2 ) )
+\end{python}
 \end{lrbox}
+\subfloat[3 States, internal variables]{\label{f:Coroutine3States}\usebox\myboxA}
+\qquad\qquad
+\subfloat[1 State, internal variables]{\label{f:Coroutine1State}\usebox\myboxB}
+\caption{\CFA Coroutine Fibonacci Implementations}
+\label{f:cfa-fibonacci}
+\subfloat[C]{\label{f:GlobalVariables}\usebox\myboxA}
+\hspace{3pt}
+\vrule
+\hspace{3pt}
+\subfloat[\CFA]{\label{f:ExternalState}\usebox\myboxB}
+\hspace{3pt}
+\vrule
+\hspace{3pt}
+\subfloat[Python]{\label{f:ExternalState}\usebox\myboxC}
+\caption{Fibonacci Generator}
+\label{f:C-fibonacci}
+% \bigskip
+%
+% \newbox\myboxA
+% \begin{lrbox}{\myboxA}
+% \begin{cfa}[aboveskip=0pt,belowskip=0pt]
+% `coroutine` Fib { int fn; };
+% void main( Fib & fib ) with( fib ) {
+%       fn = 0;  int fn1 = fn; `suspend()`;
+%       fn = 1;  int fn2 = fn1;  fn1 = fn; `suspend()`;
+%       for () {
+%               fn = fn1 + fn2; fn2 = fn1; fn1 = fn; `suspend()`; }
+% }
+% int next( Fib & fib ) with( fib ) { `resume( fib );` return fn; }
+% int main() {
+%       Fib f1, f2;
+%       for ( 10 )
+%               sout | next( f1 ) | next( f2 );
+% }
+% \end{cfa}
+% \end{lrbox}
+% \newbox\myboxB
+% \begin{lrbox}{\myboxB}
+% \begin{python}[aboveskip=0pt,belowskip=0pt]
+%
+% def Fibonacci():
+%       fn = 0; fn1 = fn; `yield fn`  # suspend
+%       fn = 1; fn2 = fn1; fn1 = fn; `yield fn`
+%       while True:
+%               fn = fn1 + fn2; fn2 = fn1; fn1 = fn; `yield fn`
+%
+%
+% f1 = Fibonacci()
+% f2 = Fibonacci()
+% for i in range( 10 ):
+%       print( `next( f1 )`, `next( f2 )` ) # resume
+%
+% \end{python}
+% \end{lrbox}
+% \subfloat[\CFA]{\label{f:Coroutine3States}\usebox\myboxA}
+% \qquad
+% \subfloat[Python]{\label{f:Coroutine1State}\usebox\myboxB}
+% \caption{Fibonacci input coroutine, 3 states, internal variables}
+% \label{f:cfa-fibonacci}
 \end{figure}
 …
 \begin{lrbox}{\myboxA}
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
 `coroutine` Format {
         char ch;   // used for communication
         int g, b;  // global because used in destructor
+`coroutine` Fmt {
+        char ch;   // communication variables
+        int g, b;   // needed in destructor
 };
 void main( Format & fmt ) with( fmt ) {
         for ( ;; ) {
                 for ( g = 0; g < 5; g += 1 ) {      // group
                         for ( b = 0; b < 4; b += 1 ) { // block
+void main( Fmt & fmt ) with( fmt ) {
+        for () {
+                for ( g = 0; g < 5; g += 1 ) { // groups
+                        for ( b = 0; b < 4; b += 1 ) { // blocks
                                 `suspend();`
+                                sout | ch;              // separator
+                        }
+                        sout | "  ";               // separator
+                }
+                sout | nl;
+        }
+}
+void ?{}( Format & fmt ) { `resume( fmt );` }
+void ^?{}( Format & fmt ) with( fmt ) {
+        if ( g != 0 || b != 0 ) sout | nl;
+}
+void format( Format & fmt ) {
+        `resume( fmt );`
+}
+                                sout | ch; } // print character
+                        sout | "  "; } // block separator
+                sout | nl; }  // group separator
+}
+void ?{}( Fmt & fmt ) { `resume( fmt );` } // prime
+void ^?{}( Fmt & fmt ) with( fmt ) { // destructor
+        if ( g != 0 || b != 0 ) // special case
+                sout | nl; }
+void send( Fmt & fmt, char c ) { fmt.ch = c; `resume( fmt )`; }
 int main() {
+        Format fmt;
+        eof: for ( ;; ) {
+                sin | fmt.ch;
+          if ( eof( sin ) ) break eof;
+                format( fmt );
+        }
+        Fmt fmt;
+        sout | nlOff;   // turn off auto newline
+        for ( 41 )
+                send( fmt, 'a' );
+}
 \end{cfa}
 …
 \newbox\myboxB
 \begin{lrbox}{\myboxB}
+\begin{cfa}[aboveskip=0pt,belowskip=0pt]
+struct Format {
+        char ch;
+        int g, b;
+};
+void format( struct Format * fmt ) {
+        if ( fmt->ch != -1 ) {      // not EOF ?
+                printf( "%c", fmt->ch );
+                fmt->b += 1;
+                if ( fmt->b == 4 ) {  // block
+                        printf( "  " );      // separator
+                        fmt->b = 0;
+                        fmt->g += 1;
+                }
+                if ( fmt->g == 5 ) {  // group
+                        printf( "\n" );     // separator
+                        fmt->g = 0;
+                }
+        } else {
+                if ( fmt->g != 0 || fmt->b != 0 ) printf( "\n" );
+        }
+}
+int main() {
+        struct Format fmt = { 0, 0, 0 };
+        for ( ;; ) {
+                scanf( "%c", &fmt.ch );
+          if ( feof( stdin ) ) break;
+                format( &fmt );
+        }
+        fmt.ch = -1;
+        format( &fmt );
+}
+\end{cfa}
+\begin{python}[aboveskip=0pt,belowskip=0pt]
+def Fmt():
+        try:
+                while True:
+                        for g in range( 5 ):
+                                for b in range( 4 ):
+                                        print( `(yield)`, end='' )
+                                print( '  ', end='' )
+                        print()
+        except GeneratorExit:
+                if g != 0 | b != 0:
+                        print()
+fmt = Fmt()
+`next( fmt )`                    # prime
+for i in range( 41 ):
+        `fmt.send( 'a' );`      # send to yield
+\end{python}
 \end{lrbox}
 \subfloat[\CFA Coroutine]{\label{f:CFAFmt}\usebox\myboxA}
+\subfloat[\CFA]{\label{f:CFAFmt}\usebox\myboxA}
 \qquad
 \subfloat[C Linearized]{\label{f:CFmt}\usebox\myboxB}
 \caption{Formatting text into lines of 5 blocks of 4 characters.}
+\subfloat[Python]{\label{f:CFmt}\usebox\myboxB}
+\caption{Output formatting text}
 \label{f:fmt-line}
 \end{figure}
 …
 void main( Prod & prod ) with( prod ) {
         // 1st resume starts here
         for ( int i = 0; i < N; i += 1 ) {
+        for ( i; N ) {
                 int p1 = random( 100 ), p2 = random( 100 );
                 sout | p1 | " " | p2;
 …
+}
 void start( Prod & prod, int N, Cons &c ) {
         &prod.c = &c;
+        &prod.c = &c; // reassignable reference
         prod.[N, receipt] = [N, 0];
         `resume( prod );`
 …
         Prod & p;
         int p1, p2, status;
         _Bool done;
+        bool done;
 };
 void ?{}( Cons & cons, Prod & p ) {
         &cons.p = &p;
+        &cons.p = &p; // reassignable reference
         cons.[status, done ] = [0, false];
+}
 …
 The program main restarts after the resume in @start@.
 @start@ returns and the program main terminates.
+One \emph{killer} application for a coroutine is device drivers, which at one time caused 70\%-85\% of failures in Windows/Linux~\cite{Swift05}.
+Many device drivers are a finite state-machine parsing a protocol, e.g.:
+\begin{tabbing}
+\ldots STX \= \ldots message \ldots \= ESC \= ETX \= \ldots message \ldots  \= ETX \= 2-byte crc \= \ldots      \kill
+\ldots STX \> \ldots message \ldots \> ESC \> ETX \> \ldots message \ldots  \> ETX \> 2-byte crc \> \ldots
+\end{tabbing}
+where a network message begins with the control character STX and ends with an ETX, followed by a 2-byte cyclic-redundancy check.
+Control characters may appear in a message if preceded by an ESC.
+Because FSMs can be complex and occur frequently in important domains, direct support of the coroutine is crucial in a systems programminglanguage.
+\begin{figure}
+\begin{cfa}
+enum Status { CONT, MSG, ESTX, ELNTH, ECRC };
+`coroutine` Driver {
+        Status status;
+        char * msg, byte;
+};
+void ?{}( Driver & d, char * m ) { d.msg = m; }         $\C[3.0in]{// constructor}$
+Status next( Driver & d, char b ) with( d ) {           $\C{// 'with' opens scope}$
+        byte = b; `resume( d );` return status;
+}
+void main( Driver & d ) with( d ) {
+        enum { STX = '\002', ESC = '\033', ETX = '\003', MaxMsg = 64 };
+        unsigned short int crc;                                                 $\C{// error checking}$
+  msg: for () {                                                                         $\C{// parse message}$
+                status = CONT;
+                unsigned int lnth = 0, sum = 0;
+                while ( byte != STX ) `suspend();`
+          emsg: for () {
+                        `suspend();`                                                    $\C{// process byte}$
+                        choose ( byte ) {                                               $\C{// switch with default break}$
+                          case STX:
+                                status = ESTX; `suspend();` continue msg;
+                          case ETX:
+                                break emsg;
+                          case ESC:
+                                suspend();
+                        } // choose
+                        if ( lnth >= MaxMsg ) {                                 $\C{// buffer full ?}$
+                                status = ELNTH; `suspend();` continue msg; }
+                        msg[lnth++] = byte;
+                        sum += byte;
+                } // for
+                msg[lnth] = '\0';                                                       $\C{// terminate string}\CRT$
+                `suspend();`
+                crc = (unsigned char)byte << 8; // prevent sign extension for signed char
+                `suspend();`
+                status = (crc | (unsigned char)byte) == sum ? MSG : ECRC;
+                `suspend();`
+        } // for
+}
+\end{cfa}
+\caption{Device driver for simple communication protocol}
+\end{figure}

doc/proposals/vtable.md

-                      rf845e80
+                      r98b4b12
 should be able to store anything that goes into a trait.
+I also include notes on a sample implementation, which primarly exists to show
+there is a resonable implementation. The code samples for that are in a slight
+psudo-code to help avoid name mangling and keeps some CFA features while they
+would actually be writen in C.
 Trait Instances
 ---------------
 …
 before.
+Internally a trait object is a pair of pointers. One to an underlying object
+and the other to the vtable. All calls on an trait are implemented by looking
+up the matching function pointer and passing the underlying object and the
+remaining arguments to it.
+Trait objects can be moved by moving the pointers. Almost all other operations
+require some functions to be implemented on the underlying type. Depending on
+what is in the virtual table a trait type could be a dtype or otype.
+For traits to be used this way they should meet two requirements. First they
+should only have a single polymorphic type and each assertion should use that
+type once as a parameter. Extentions may later loosen these requirements.
+If a trait object is used it should generate a series of implicate functions
+each of which implements one of the functions required by the trait. So for
+combiner there is an implicate:
+    void combine(trait combiner & this, int);
+This function is the one actually called at the end
+The main use case for trait objects is that they can be stored. They can be
+passed into functions, but using the trait directly is prefred in this case.
+    trait drawable(otype T) {
+        void draw(Surface & to, T & draw);
+        Rect(int) drawArea(T & draw);
+    };
+    struct UpdatingSurface {
+        Surface * surface;
+        vector(trait drawable) drawables;
+    };
+    void updateSurface(UpdatingSurface & us) {
+        for (size_t i = 0 ; i < us.drawables.size ; ++i) {
+            draw(us.surface, us.drawables[i]);
+        }
+    }
+Currently these traits are limited to 1 trait parameter and functions should
+have exactly 1 parameter. We cannot abstract away pairs of types and still
+pass them into normal functions, which take them seperately.
+The second is required the because we need to get the vtable from somewhere.
+If there are 0 trait objects than no vtable is avalible, if we have more than
+than the vtables give conflicting answers on what underlying function to
+call. And even then the underlying type assumes a concrete type.
+This loop can sort of be broken by using the trait object directly in the
+signature. This has well defined meaning, but might not be useful.
+    trait example(otype T) {
+        bool test(T & this, trait example & that);
+    }
+#### Sample Implementation
+A simple way to implement trait objects is by a pair of pointers. One to the
+underlying object and one to the vtable.
+    struct vtable_drawable {
+        void (*draw)(Surface &, void *);
+        Rect(int) (*drawArea)(void *);
+    };
+    struct drawable {
+        void * object;
+        vtable_drawable * vtable;
+    };
+The functions that run on the trait object would generally be generated using
+the following pattern:
+    void draw(Surface & surface, drawable & traitObj) {
+        return traitObj.vtable->draw(surface, traitObj.object);
+    }
+There may have to be special cases for things like copy construction, that
+might require a more sigificant wrapper. On the other hand moving could be
+implemented by moving the pointers without any need to refer to the base
+object.
+### Extention: Multiple Trait Parameters
+Currently, this gives traits two independent uses. They use the same syntax,
+except for limits boxable traits have, and yet don't really mix. The most
+natural way to do this is to allow trait instances to pick one parameter
+that they are generic over, the others they choose types to implement.
+The two ways to do the selection, the first is do it at the trait definition.
+Each trait picks out a single parameter which it can box (here the `virtual`
+qualifier). When you create an instance of a trait object you provide
+arguments like for a generic structure, but skip over the marked parameter.
+    trait combiner(virtual otype T, otype Combined) {
+        void combine(T &, Combined &);
+    }
+    trait combiner(int) int_combiner;
+The second is to do it at the instaniation point. A placeholder (here the
+keyword `virtual`) is used to explicately skip over the parameter that will be
+abstracted away, with the same rules as above if it was the marked parameter.
+    trait combiner(otype T, otype Combined) {
+        void combine(T &, Combined &);
+    };
+    trait combiner(virtual, int) int_combiner;
+Using both (first to set the default, second as a local override) would also
+work, although might be exessively complicated.
+This is useful in cases where you want to use a generic type, but leave part
+of it open and store partially generic result. As a simple example
+    trait folder(otype T, otype In, otype Out) {
+        void fold(T & this, In);
+        Out fold_result(T & this);
+    }
+Which allows you to fold values without putting them in a container. If they
+are already in a container this is exessive, but if they are generated over
+time this gives you a simple interface. This could for instance be used in
+a profile, where T changes for each profiling statistic and you can plug in
+multiple profilers for any run by adding them to an array.
 Hierarchy
 …
 the pointer to it.
+Exception Example:
+(Also I'm not sure where I got these casing rules.)
+    trait exception(otype T) virtual() {
+        char const * what(T & this);
+    }
+    trait io_error(otype T) virtual(exception) {
+        FILE * which_file(T & this);
+    }
+    struct eof_error(otype T) virtual(io_error) {
+        FILE * file;
+    }
+    char const * what(eof_error &) {
+        return "Tried to read from an empty file.";
+    }
+    FILE * which_file(eof_error & this) {
+        return eof_error.file;
+    }
+Ast Example:
+    trait ast_node(otype T) virtual() {
+        void print(T & this, ostream & out);
+        void visit(T & this, Visitor & visitor);
+        CodeLocation const & get_code_location(T & this);
+    }
+    trait expression_node(otype T) virtual(ast_node) {
+        Type eval_type(T const & this);
+    }
+    struct operator_expression virtual(expression_node) {
+        enum operator_kind kind;
+        trait expression_node rands[2];
+    }
+    trait statement_node(otype T) virtual(ast_node) {
+        vector(Label) & get_labels(T & this);
+    }
+    struct goto_statement virtual(statement_node) {
+        vector(Label) labels;
+        Label target;
+    }
+    trait declaration_node(otype T) virtual(ast_node) {
+        string name_of(T const & this);
+        Type type_of(T const & this);
+    }
+    struct using_declaration virtual(declaration_node) {
+        string new_type;
+        Type old_type;
+    }
+    struct variable_declaration virtual(declaration_node) {
+        string name;
+        Type type;
+    }
+#### Sample Implementation
+The type id may be as little as:
+    struct typeid {
+        struct typeid const * const parent;
+    };
+Some linker magic would have to be used to ensure exactly one copy of each
+structure for each type exists in memory. There seem to be spectial once
+sections that support this and it should be easier than generating unique
+ids across compilation units.
+The structure could be extended to contain any additional type information.
+There are two general designs for vtables with type ids. The first is to put
+the type id at the top of the vtable, this is the most compact and efficient
+solution but only works if we have exactly 1 vtable for each type. The second
+is to put a pointer to the type id in each vtable. This has more overhead but
+allows multiple vtables.
+    struct <trait>_vtable {
+        struct typeid const id;
+        // Trait dependent list of vtable members.
+    };
+    struct <trait>_vtable {
+        struct typeid const * const id;
+        // Trait dependent list of vtable members.
+    };
+### Virtual Casts
+To convert from a pointer to a type higher on the hierarchy to one lower on
+the hierarchy a check is used to make sure that the underlying type is also
+of that lower type.
+The proposed syntax for this is:
+    trait SubType * new_value = (virtual trait SubType *)super_type;
+It will return the same pointer if it does point to the subtype and null if
+it does not, doing the check and conversion in one operation.
 ### Inline vtables
 Since the structures here are usually made to be turned into trait objects
 it might be worth it to have fields on them to store the virtual table
+pointer. This would have to be declared on the trait as an assertion, but if
+it is the trait object could be a single pointer.
+It is trivial to do if the field with the virtual table pointer is fixed.
+Otherwise some trickery with pointing to the field and storing the offset in
+the virtual table to recover the main object would have to be used.
+pointer. This would have to be declared on the trait as an assertion (example:
+`vtable;` or `T.vtable;`), but if it is the trait object could be a single
+pointer.
+There are also three options for where the pointer to the vtable. It could be
+anywhere, a fixed location for each trait or always at the front. For the per-
+trait solution an extention to specify what it is (example `vtable[0];`) which
+could also be used to combine it with others. So these options can be combined
+to allow access to all three options.
 ### Virtual Tables as Types
 Here we consider encoding plus the implementation of functions on it. Which
+is to say in the type hierarchy structures aren't concrete types anymore,
+instead they are parent types to vtables, which combine the encoding and
 implementation.
+Here we consider encoding plus the implementation of functions on it to be a
+type. Which is to say in the type hierarchy structures aren't concrete types
+anymore, instead they are parent types to vtables, which combine the encoding
+and implementation.
 Resolution Scope
 …
 other.
+Some syntax would have to be added. All resolutions can be found at compile
+time and a single vtable created for each type at compilation time.
+Some syntax would have to be added to specify the resolution point. To ensure
+a single instance there may have to be two variants, one forward declaration
+and one to create the instance. With some compiler magic the forward
+declaration maybe enough.
+    extern trait combiner(struct summation) vtable;
+    trait combiner(struct summation) vtable;
+Or (with the same variants):
+    vtable combiner(struct summation);
+The extern variant promises that the vtable will exist while the normal one
+is where the resolution actually happens.
 ### Explicit Resolution Points:
 …
 vtable.
+    extern trait combiner(struct summation) vtable sum;
+    trait combiner(struct summation) vtable sum;
+    extern trait combiner(struct summation) vtable sum default;
+    trait combiner(struct summation) vtable sum default;
+The extern difference is the same before. The name (sum in the samples) is
+used at the binding site to say which one is picked. The default keyword can
+be used in only some of the declarations.
+    trait combiner fee = (summation_instance, sum);
+    trait combiner foe = summation_instance;
+(I am not really happy about this syntax, but it kind of works.)
+The object being bound is required. The name of the vtable is optional if
+there is exactly one vtable name marked with default.
+These could also be placed inside functions. In which case both the name and
+the default keyword might be optional. If the name is ommited in an assignment
+the closest vtable is choosen (returning to the global default rule if no
+approprate local vtable is in scope).
 ### Site Based Resolution:
 Every place in code where the binding of a vtable to an object occurs has

doc/user/user.tex

-                      rf845e80
+                      r98b4b12
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Tue Dec 11 23:19:26 2018
 %% Update Count     : 3400
+%% Last Modified On : Sun Apr 14 11:02:34 2019
+%% Update Count     : 3443
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 As for \Index{division}, there are exponentiation operators for integral and floating types, including the builtin \Index{complex} types.
+Unsigned integral exponentiation\index{exponentiation!unsigned integral} is performed with repeated multiplication\footnote{The multiplication computation is $O(\log y)$.} (or shifting if the base is 2).
+Signed integral exponentiation\index{exponentiation!signed integral} is performed with repeated multiplication (or shifting if the base is 2), but yields a floating result because $x^{-y}=1/x^y$.
+Hence, it is important to designate exponent integral-constants as unsigned or signed: ©3 \ 3u© return an integral result, while ©3 \ 3© returns a floating result.
+Floating exponentiation\index{exponentiation!floating} is performed using \Index{logarithm}s\index{exponentiation!logarithm}, so the base cannot be negative.
+\begin{cfa}
+sout | 2 ®\® 8u | 4 ®\® 3u | -4 ®\® 3u | 4 ®\® -3 | -4 ®\® -3 | 4.0 ®\® 2.1 | (1.0f+2.0fi) ®\® (3.0f+2.0fi);
+64 -64 0.015625 -0.015625 18.3791736799526 0.264715-1.1922i
+\end{cfa}
+Integral exponentiation\index{exponentiation!unsigned integral} is performed with repeated multiplication\footnote{The multiplication computation is $O(\log y)$.} (or shifting if the exponent is 2).
+Overflow from large exponents or negative exponents return zero.
+Floating exponentiation\index{exponentiation!floating} is performed using \Index{logarithm}s\index{exponentiation!logarithm}, so the exponent cannot be negative.
+\begin{cfa}
+sout | 1 ®\® 0 | 1 ®\® 1 | 2 ®\® 8 | -4 ®\® 3 | 5 ®\® 3 | 5 ®\® 32 | 5L ®\® 32 | 5L ®\® 64 | -4 ®\® -3 | -4.0 ®\® -3 | 4.0 ®\® 2.1
+           | (1.0f+2.0fi) ®\® (3.0f+2.0fi);
+1 256 -64 125 ®0® 3273344365508751233 ®0® ®0® -0.015625 18.3791736799526 0.264715-1.1922i
+\end{cfa}
+Note, ©5 ®\® 32© and ©5L ®\® 64© overflow, and ©-4 ®\® -3© is a fraction but stored in an integer so all three computations generate an integral zero.
 Parenthesis are necessary for complex constants or the expression is parsed as ©1.0f+®(®2.0fi \ 3.0f®)®+2.0fi©.
+The exponentiation operator is available for all the basic types, but for user-defined types, only the integral-computation versions are available.
+For returning an integral value, the user type ©T© must define multiplication, ©*©, and one, ©1©;
+for returning a floating value, an additional divide of type ©T© into a ©double© returning a ©double© (©double ?/?( double, T )©) is necessary for negative exponents.
+The exponentiation operator is available for all the basic types, but for user-defined types, only the integral-computation version is available.
+\begin{cfa}
+forall( otype OT | { void ?{}( OT & this, one_t ); OT ?*?( OT, OT ); } )
+OT ?®\®?( OT ep, unsigned int y );
+forall( otype OT | { void ?{}( OT & this, one_t ); OT ?*?( OT, OT ); } )
+OT ?®\®?( OT ep, unsigned long int y );
+\end{cfa}
+The user type ©T© must define multiplication, one, ©1©, and, ©*©.
 …
 \subsection{Loop Control}
+The ©for©/©while©/©do-while© loop-control allows empty or simplified ranges.
+The ©for©/©while©/©do-while© loop-control allows empty or simplified ranges (see Figure~\ref{f:LoopControlExamples}).
+\begin{itemize}
+\item
 An empty conditional implies ©1©.
+The up-to range ©~©\index{~@©~©} means exclusive range [M,N);
+the up-to range ©~=©\index{~=@©~=©} means inclusive range [M,N].
+The down-to range ©-~©\index{-~@©-~©} means exclusive range [N,M);
+the down-to range ©-~=©\index{-~=@©-~=©} means inclusive range [N,M].
+\item
+The up-to range ©~©\index{~@©~©} means exclusive range [M,N).
+\item
+The up-to range ©~=©\index{~=@©~=©} means inclusive range [M,N].
+\item
+The down-to range ©-~©\index{-~@©-~©} means exclusive range [N,M).
+\item
+The down-to range ©-~=©\index{-~=@©-~=©} means inclusive range [N,M].
+\item
+©@© means put nothing in this field.
+\item
 ©0© is the implicit start value;
+\item
 ©1© is the implicit increment value.
+\item
 The up-to range uses ©+=© for increment;
+the down-to range uses ©-=© for decrement.
+\item
+The down-to range uses ©-=© for decrement.
+\item
 The loop index is polymorphic in the type of the start value or comparison value when start is implicitly ©0©.
+\end{itemize}
+\begin{figure}
 \begin{cquote}
 \begin{tabular}{@{}ll|l@{}}
 \multicolumn{2}{c|}{loop control} & \multicolumn{1}{c}{output} \\
+\begin{tabular}{@{}l|l@{}}
+\multicolumn{1}{c|}{loop control} & \multicolumn{1}{c}{output} \\
 \hline
 \begin{cfa}
+while ®()® { sout | "empty"; break; }
+do { sout | "empty"; break; } while ®()®;
+for ®()® { sout | "empty"; break; }
+for ( ®0® ) { sout | "A"; }
+for ( ®1® ) { sout | "A"; }
+for ( ®10® ) { sout | "A"; }
+for ( ®1 ~= 10 ~ 2® ) { sout | "B"; }
+for ( ®10 -~= 1 ~ 2® ) { sout | "C"; }
+for ( ®0.5 ~ 5.5® ) { sout | "D"; }
+for ( ®5.5 -~ 0.5® ) { sout | "E"; }
+for ( ®i; 10® ) { sout | i; }
+for ( ®i; 1 ~= 10 ~ 2® ) { sout | i; }
+for ( ®i; 10 -~= 1 ~ 2® ) { sout | i; }
+for ( ®i; 0.5 ~ 5.5® ) { sout | i; }
+for ( ®i; 5.5 -~ 0.5® ) { sout | i; }
+for ( ®ui; 2u ~= 10u ~ 2u® ) { sout | ui; }
+for ( ®ui; 10u -~= 2u ~ 2u® ) { sout | ui; }
+sout | nlOff;
+while ®()® { sout | "empty"; break; } sout | nl;
+do { sout | "empty"; break; } while ®()®; sout | nl;
+for ®()® { sout | "empty"; break; } sout | nl;
+for ( ®0® ) { sout | "A"; } sout | "zero" | nl;
+for ( ®1® ) { sout | "A"; } sout | nl;
+for ( ®10® ) { sout | "A"; } sout | nl;
+for ( ®1 ~= 10 ~ 2® ) { sout | "B"; } sout | nl;
+for ( ®10 -~= 1 ~ 2® ) { sout | "C"; } sout | nl;
+for ( ®0.5 ~ 5.5® ) { sout | "D"; } sout | nl;
+for ( ®5.5 -~ 0.5® ) { sout | "E"; } sout | nl;
+for ( ®i; 10® ) { sout | i; } sout | nl;
+for ( ®i; 1 ~= 10 ~ 2® ) { sout | i; } sout | nl;
+for ( ®i; 10 -~= 1 ~ 2® ) { sout | i; } sout | nl;
+for ( ®i; 0.5 ~ 5.5® ) { sout | i; } sout | nl;
+for ( ®i; 5.5 -~ 0.5® ) { sout | i; } sout | nl;
+for ( ®ui; 2u ~= 10u ~ 2u® ) { sout | ui; } sout | nl;
+for ( ®ui; 10u -~= 2u ~ 2u® ) { sout | ui; } sout | nl;
 enum { N = 10 };
 for ( ®N® ) { sout | "N"; }
 for ( ®i; N® ) { sout | i; }
 for ( ®i; N -~ 0® ) { sout | i; }
+for ( ®N® ) { sout | "N"; } sout | nl;
+for ( ®i; N® ) { sout | i; } sout | nl;
+for ( ®i; N -~ 0® ) { sout | i; } sout | nl;
 const int start = 3, comp = 10, inc = 2;
+for ( ®i; start ~ comp ~ inc + 1® ) { sout | i; }
+for ( ®i; start ~ comp ~ inc + 1® ) { sout | i; } sout | nl;
+for ( ®i; 1 ~ @® ) { if ( i > 10 ) break;
+        sout | i; } sout | nl;
+for ( ®i; 10 -~ @® ) { if ( i < 0 ) break;
+        sout | i; } sout | nl;
+for ( ®i; 2 ~ @ ~ 2® ) { if ( i > 10 ) break;
+        sout | i; } sout | nl;
+for ( ®i; 2.1 ~ @ ~ @® ) { if ( i > 10.5 ) break;
+        sout | i; i += 1.7; } sout | nl;
+for ( ®i; 10 -~ @ ~ 2® ) { if ( i < 0 ) break;
+        sout | i; } sout | nl;
+for ( ®i; 12.1 ~ @ ~ @® ) { if ( i < 2.5 ) break;
+        sout | i; i -= 1.7; } sout | nl;
+for ( ®i; 5 : j; -5 ~ @® ) { sout | i | j; } sout | nl;
+for ( ®i; 5 : j; -5 -~ @® ) { sout | i | j; } sout | nl;
+for ( ®i; 5 : j; -5 ~ @ ~ 2® ) { sout | i | j; } sout | nl;
+for ( ®i; 5 : j; -5 -~ @ ~ 2® ) { sout | i | j; } sout | nl;
+for ( ®j; -5 ~ @ : i; 5® ) { sout | i | j; } sout | nl;
+for ( ®j; -5 -~ @ : i; 5® ) { sout | i | j; } sout | nl;
+for ( ®j; -5 ~ @ ~ 2 : i; 5® ) { sout | i | j; } sout | nl;
+for ( ®j; -5 -~ @ ~ 2 : i; 5® ) { sout | i | j; } sout | nl;
+for ( ®j; -5 -~ @ ~ 2 : i; 5 : k; 1.5 ~ @® ) {
+        sout | i | j | k; } sout | nl;
+for ( ®j; -5 -~ @ ~ 2 : k; 1.5 ~ @ : i; 5® ) {
+        sout | i | j | k; } sout | nl;
+for ( ®k; 1.5 ~ @ : j; -5 -~ @ ~ 2 : i; 5® ) {
+        sout | i | j | k; } sout | nl;
 \end{cfa}
+&
 \begin{cfa}
+sout | nl;
+sout | nl;
+sout | nl;
+sout | "zero" | nl;
+sout | nl;
+sout | nl;
+sout | nl;
+sout | nl;
+sout | nl;
+sout | nl;
+sout | nl;
+sout | nl;
+sout | nl;
+sout | nl;
+sout | nl;
+sout | nl;
+sout | nl | nl;
+sout | nl;
+sout | nl;
+sout | nl | nl;
+sout | nl;
+\end{cfa}
+&
+\begin{cfa}
 empty
 empty
 …
 6 9
+2 3 4 5 6 7 8 9 10
+9 8 7 6 5 4 3 2 1 0
+4 6 8 10
+.1 3.8 5.5 7.2 8.9
+8 6 4 2 0
+.1 10.4 8.7 7 5.3 3.6
+-5 1 -4 2 -3 3 -2 4 -1
+-5 1 -6 2 -7 3 -8 4 -9
+-5 1 -3 2 -1 3 1 4 3
+-5 1 -7 2 -9 3 -11 4 -13
+-5 1 -4 2 -3 3 -2 4 -1
+-5 1 -6 2 -7 3 -8 4 -9
+-5 1 -3 2 -1 3 1 4 3
+-5 1 -7 2 -9 3 -11 4 -13
+-5 1.5 1 -7 2.5 2 -9 3.5 3 -11 4.5 4 -13 5.5
+-5 1.5 1 -7 2.5 2 -9 3.5 3 -11 4.5 4 -13 5.5
+-5 1.5 1 -7 2.5 2 -9 3.5 3 -11 4.5 4 -13 5.5
 \end{cfa}
 \end{tabular}
 \end{cquote}
+\caption{Loop Control Examples}
+\label{f:LoopControlExamples}
+\end{figure}
 …
 \end{cfa}
 Essentially, the return type is wrapped around the routine name in successive layers (like an \Index{onion}).
+While attempting to make the two contexts consistent is a laudable goal, it has not worked out in practice.
+While attempting to make the two contexts consistent is a laudable goal, it has not worked out in practice, even though Dennis Richie believed otherwise:
+\begin{quote}
+In spite of its difficulties, I believe that the C's approach to declarations remains plausible, and am comfortable with it; it is a useful unifying principle.~\cite[p.~12]{Ritchie93}
+\end{quote}
 \CFA provides its own type, variable and routine declarations, using a different syntax.

libcfa/configure

rf845e80	r98b4b12
2977	2977	;;
2978	2978	esac
	2979
	2980	CONFIG_CFAFLAGS="${CONFIG_CFAFLAGS} ${CFAFLAGS}"
2979	2981
2980	2982

libcfa/configure.ac

rf845e80	r98b4b12
64	64	esac
65	65
	66	CONFIG_CFAFLAGS="${CONFIG_CFAFLAGS} ${CFAFLAGS}"
	67
66	68	AC_SUBST(CONFIG_CFLAGS)
67	69	AC_SUBST(CONFIG_CFAFLAGS)

libcfa/prelude/builtins.c

-                      rf845e80
+                      r98b4b12
 // Created On       : Fri Jul 21 16:21:03 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Mar 10 10:52:50 2019
 // Update Count     : 31
+// Last Modified On : Tue Mar 26 23:10:36 2019
+// Update Count     : 95
 //
 …
 typedef unsigned long long __cfaabi_abi_exception_type_t;
+#include <limits.h>                                                                             // CHAR_BIT
 #include "../src/virtual.h"
 #include "../src/exception.h"
 …
 // increment/decrement unification
+static inline forall( dtype T | { T & ?+=?( T &, one_t ); } )
+T & ++? ( T & x ) { return x += 1; }
+static inline {
+        forall( dtype DT | { DT & ?+=?( DT &, one_t ); } )
+        DT & ++?( DT & x ) { return x += 1; }
 static inline forall( dtype T | sized(T) | { void ?{}( T &, T ); void ^?{}( T & ); T & ?+=?( T &, one_t ); } )
 T & ?++ ( T & x ) { T tmp = x; x += 1; return tmp; }
+        forall( dtype DT | sized(DT) | { void ?{}( DT &, DT ); void ^?{}( DT & ); DT & ?+=?( DT &, one_t ); } )
+        DT & ?++( DT & x ) { DT tmp = x; x += 1; return tmp; }
 static inline forall( dtype T | { T & ?-=?( T &, one_t ); } )
 T & --? ( T & x ) { return x -= 1; }
+        forall( dtype DT | { DT & ?-=?( DT &, one_t ); } )
+        DT & --?( DT & x ) { return x -= 1; }
+static inline forall( dtype T | sized(T) | { void ?{}( T &, T ); void ^?{}( T & ); T & ?-=?( T &, one_t ); } )
+T & ?-- ( T & x ) { T tmp = x; x -= 1; return tmp; }
+        forall( dtype DT | sized(DT) | { void ?{}( DT &, DT ); void ^?{}( DT & ); DT & ?-=?( DT &, one_t ); } )
+        DT & ?--( DT & x ) { DT tmp = x; x -= 1; return tmp; }
+} // distribution
 // universal typed pointer constant
 static inline forall( dtype T ) T * intptr( uintptr_t addr ) { return (T *)addr; }
+// Compiler issue: there is a problem with anonymous types that do not have a size.
+static inline forall( dtype DT | sized(DT) ) DT * intptr( uintptr_t addr ) { return (DT *)addr; }
 // exponentiation operator implementation
 …
 } // extern "C"
+static inline float ?\?( float x, float y ) { return powf( x, y ); }
+static inline double ?\?( double x, double y ) { return pow( x, y ); }
+static inline long double ?\?( long double x, long double y ) { return powl( x, y ); }
+static inline float _Complex ?\?( float _Complex x, _Complex float y ) { return cpowf(x, y ); }
+static inline double _Complex ?\?( double _Complex x, _Complex double y ) { return cpow( x, y ); }
+static inline long double _Complex ?\?( long double _Complex x, _Complex long double y ) { return cpowl( x, y ); }
+static inline {
+        float ?\?( float x, float y ) { return powf( x, y ); }
+        double ?\?( double x, double y ) { return pow( x, y ); }
+        long double ?\?( long double x, long double y ) { return powl( x, y ); }
+        float _Complex ?\?( float _Complex x, _Complex float y ) { return cpowf(x, y ); }
+        double _Complex ?\?( double _Complex x, _Complex double y ) { return cpow( x, y ); }
+        long double _Complex ?\?( long double _Complex x, _Complex long double y ) { return cpowl( x, y ); }
+} // distribution
+static inline long int ?\?( long int ep, unsigned long int y ) { // disallow negative exponent
+        if ( y == 0 ) return 1;                                                         // base case
+        if ( ep == 2 ) return ep << (y - 1);                            // special case, positive shifting only
+        typeof( ep ) op = 1;                                                            // accumulate odd product
+        for ( ; y > 1; y >>= 1 ) {                                                      // squaring exponentiation, O(log2 y)
+                if ( (y & 1) == 1 ) op *= ep;                                   // odd ?
+                ep *= ep;
+        } // for
+        return ep * op;
+} // ?\?
+#define __CFA_BASE_COMP_1__() if ( ep == 1 ) return 1
+#define __CFA_BASE_COMP_2__() if ( ep == 2 ) return ep << (y - 1)
+#define __CFA_EXP_OVERFLOW__() if ( y >= sizeof(y) * CHAR_BIT ) return 0
+static inline forall( otype T | { void ?{}( T & this, one_t ); T ?*?( T, T ); } )
+T ?\?( T ep, unsigned long int y ) {
+        if ( y == 0 ) return 1;
+        T op = 1;
+        for ( ; y > 1; y >>= 1 ) {                                                      // squaring exponentiation, O(log2 y)
+                if ( (y & 1) == 1 ) op = op * ep;                               // odd ?
+                ep = ep * ep;
+        } // for
+        return ep * op;
+} // ?\?
+#define __CFA_EXP__() \
+        if ( y == 0 ) return 1;                                                         /* convention */ \
+        __CFA_BASE_COMP_1__();                                                          /* base case */ \
+        __CFA_BASE_COMP_2__();                                                          /* special case, positive shifting for integral types */ \
+        __CFA_EXP_OVERFLOW__();                                                         /* immediate overflow, negative exponent > 2^size-1 */ \
+        typeof(ep) op = 1;                                                                      /* accumulate odd product */ \
+        for ( ; y > 1; y >>= 1 ) {                                                      /* squaring exponentiation, O(log2 y) */ \
+                if ( (y & 1) == 1 ) op = op * ep;                               /* odd ? */ \
+                ep = ep * ep; \
+        } \
+        return ep * op
+// unsigned computation may be faster and larger
+static inline unsigned long int ?\?( unsigned long int ep, unsigned long int y ) { // disallow negative exponent
+        if ( y == 0 ) return 1;                                                         // base case
+        if ( ep == 2 ) return ep << (y - 1);                            // special case, positive shifting only
+        typeof( ep ) op = 1;                                                            // accumulate odd product
+        for ( ; y > 1; y >>= 1 ) {                                                      // squaring exponentiation, O(log2 y)
+                if ( (y & 1) == 1 ) op *= ep;                                   // odd ?
+                ep *= ep;
+        } // for
+        return ep * op;
+} // ?\?
+static inline {
+        long int ?\?( int ep, unsigned int y ) { __CFA_EXP__(); }
+        long int ?\?( long int ep, unsigned long int y ) { __CFA_EXP__(); }
+        // unsigned computation may be faster and larger
+        unsigned long int ?\?( unsigned int ep, unsigned int y ) { __CFA_EXP__(); }
+        unsigned long int ?\?( unsigned long int ep, unsigned long int y ) { __CFA_EXP__(); }
+} // distribution
+static inline double ?\?( long int x, signed long int y ) {     // allow negative exponent
+        if ( y >=  0 ) return (double)(x \ (unsigned long int)y);
+        else return 1.0 / x \ (unsigned int)(-y);
+} // ?\?
+#undef __CFA_BASE_COMP_1__
+#undef __CFA_BASE_COMP_2__
+#undef __CFA_EXP_OVERFLOW__
+#define __CFA_BASE_COMP_1__()
+#define __CFA_BASE_COMP_2__()
+#define __CFA_EXP_OVERFLOW__()
+// FIXME (x \ (unsigned long int)y) relies on X ?\?(T, unsigned long) a function that is neither
+// defined, nor passed as an assertion parameter. Without user-defined conversions, cannot specify
+// X as a type that casts to double, yet it doesn't make sense to write functions with that type
+// signature where X is double.
+static inline forall( otype OT | { void ?{}( OT & this, one_t ); OT ?*?( OT, OT ); } ) {
+        OT ?\?( OT ep, unsigned int y ) { __CFA_EXP__(); }
+        OT ?\?( OT ep, unsigned long int y ) { __CFA_EXP__(); }
+} // distribution
+// static inline forall( otype T | { void ?{}( T & this, one_t ); T ?*?( T, T ); double ?/?( double, T ); } )
+// double ?\?( T x, signed long int y ) {
+//     if ( y >=  0 ) return (double)(x \ (unsigned long int)y);
+//     else return 1.0 / x \ (unsigned long int)(-y);
+// } // ?\?
+#undef __CFA_BASE_COMP_1__
+#undef __CFA_BASE_COMP_2__
+#undef __CFA_EXP_OVERFLOW__
+static inline long int ?\=?( long int & x, unsigned long int y ) { x = x \ y; return x; }
+static inline unsigned long int ?\=?( unsigned long int & x, unsigned long int y ) { x = x \ y; return x; }
+static inline int ?\=?( int & x, unsigned long int y ) { x = x \ y; return x; }
+static inline unsigned int ?\=?( unsigned int & x, unsigned long int y ) { x = x \ y; return x; }
+static inline {
+        long int ?\=?( long int & x, unsigned long int y ) { x = x \ y; return x; }
+        unsigned long int ?\=?( unsigned long int & x, unsigned long int y ) { x = x \ y; return x; }
+        int ?\=?( int & x, unsigned long int y ) { x = x \ y; return x; }
+        unsigned int ?\=?( unsigned int & x, unsigned long int y ) { x = x \ y; return x; }
+} // distribution
 // Local Variables: //

libcfa/prelude/prelude-gen.cc

-                      rf845e80
+                      r98b4b12
 // Created On       : Sat Feb 16 08:44:58 2019
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Mar  8 16:00:22 2019
 // Update Count     : 26
+// Last Modified On : Tue Apr  2 17:18:24 2019
+// Update Count     : 37
 //
 …
         { "?!=?", false, "signed int", Normal, "" },
         { "?=?", true, "", Normal, "" }, // void * LHS, zero_t RHS ???
+        { "*?", false, "&", Normal, " | sized(DT)" }, // & ???
+//      { "*?", false, "&", Normal, " | sized(DT)" }, // & ???
+        { "*?", false, "&", Normal, "" }, // & ???
         { "?-?", false, "ptrdiff_t", Normal, " | sized(DT)" },
 …
                 cout << "void ?{} (" << type << " &);" << endl;
                 cout << "void ?{} (" << type << " &, " << type << ");" << endl;
                 cout << type << "  ?=? (" << type << " &, " << type << ")";
+                cout << type << " ?=? (" << type << " &, " << type << ")";
                 if ( do_volatile ) {
                         cout << ",  ?=?(volatile " << type << " &, " << type << ")";
+                        cout << ", ?=?(volatile " << type << " &, " << type << ")";
+                }
                 cout << ";" << endl;
 …
         otype("zero_t");
+        cout << endl;
         otype("one_t");
+        cout << endl;
         otype("_Bool", true);
         cout << endl;
 …
                 cout << "void ?{}(" << type.name << " &, " << type.name << ");" << endl;
                 cout << "void ?{}(" << type.name << " &, zero_t);" << endl;
+                cout << "void ?{}(" << type.name << " &, one_t);" << endl;
                 cout << "void ^?{}(" << type.name << " &);" << endl;
                 cout << endl;

libcfa/src/Makefile.am

-                      rf845e80
+                      r98b4b12
 prelude.o : prelude.cfa extras.cf gcc-builtins.cf builtins.cf @CFACC@ @CFACPP@
         ${AM_V_GEN}@CFACC@ ${AM_CFLAGS} ${CFLAGS} -quiet -in-tree @CONFIG_CFAFLAGS@ -XCFA -l ${<} -c -o ${@}
+        ${AM_V_GEN}$(CFACOMPILE) -quiet -in-tree -XCFA -l ${<} -c -o ${@}
 prelude.lo: prelude.cfa extras.cf gcc-builtins.cf builtins.cf @CFACC@ @CFACPP@
         ${AM_V_GEN}$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile \
         @CFACC@ ${AM_CFLAGS} ${CFLAGS} -quiet -in-tree @CONFIG_CFAFLAGS@ -XCFA -l ${<} -c -o ${@}
+        $(CFACOMPILE) -quiet -in-tree -XCFA -l ${<} -c -o ${@}

libcfa/src/Makefile.in

-                      rf845e80
+                      r98b4b12
 prelude.o : prelude.cfa extras.cf gcc-builtins.cf builtins.cf @CFACC@ @CFACPP@
         ${AM_V_GEN}@CFACC@ ${AM_CFLAGS} ${CFLAGS} -quiet -in-tree @CONFIG_CFAFLAGS@ -XCFA -l ${<} -c -o ${@}
+        ${AM_V_GEN}$(CFACOMPILE) -quiet -in-tree -XCFA -l ${<} -c -o ${@}
 prelude.lo: prelude.cfa extras.cf gcc-builtins.cf builtins.cf @CFACC@ @CFACPP@
         ${AM_V_GEN}$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile \
         @CFACC@ ${AM_CFLAGS} ${CFLAGS} -quiet -in-tree @CONFIG_CFAFLAGS@ -XCFA -l ${<} -c -o ${@}
+        $(CFACOMPILE) -quiet -in-tree -XCFA -l ${<} -c -o ${@}
 #----------------------------------------------------------------------------------------------------------------

libcfa/src/concurrency/CtxSwitch-x86_64.S

-                      rf845e80
+                      r98b4b12
         ret
+//.text
+//      .align 2
+//.globl        CtxStore
+//CtxStore:
+//      // Save floating & SSE control words on the stack.
+//
+//      subq   $8,%rsp
+//      stmxcsr 0(%rsp)         // 4 bytes
+//      fnstcw  4(%rsp)         // 2 bytes
+//
+//      // Save volatile registers on the stack.
+//
+//      pushq %r15
+//      pushq %r14
+//      pushq %r13
+//      pushq %r12
+//      pushq %rbx
+//
+//      // Save old context in the "from" area.
+//
+//      movq %rsp,SP_OFFSET(%rdi)
+//      movq %rbp,FP_OFFSET(%rdi)
+//
+//      // Return to thread
+//
+//      ret
+//
+//.text
+//      .align 2
+//.globl        CtxRet
+//CtxRet:
+//      // Load new context from the "to" area.
+//
+//      movq SP_OFFSET(%rdi),%rsp
+//      movq FP_OFFSET(%rdi),%rbp
+//
+//      // Load volatile registers from the stack.
+//
+//      popq %rbx
+//      popq %r12
+//      popq %r13
+//      popq %r14
+//      popq %r15
+//
+//      // Load floating & SSE control words from the stack.
+//
+//      fldcw   4(%rsp)
+//      ldmxcsr 0(%rsp)
+//      addq   $8,%rsp
+//
+//      // Return to thread.
+//
+//      ret
 .text
         .align 2

libcfa/src/concurrency/coroutine.cfa

-                      rf845e80
+                      r98b4b12
 extern "C" {
       void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage) __attribute__ ((__noreturn__));
+      void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct coroutine_desc *) __attribute__ ((__noreturn__));
       static void _CtxCoroutine_UnwindCleanup(_Unwind_Reason_Code, struct _Unwind_Exception *) __attribute__ ((__noreturn__));
       static void _CtxCoroutine_UnwindCleanup(_Unwind_Reason_Code, struct _Unwind_Exception *) {
 …
 void ^?{}(coroutine_desc& this) {
       if(this.state != Halted && this.state != Start) {
             coroutine_desc * src = TL_GET( this_coroutine );
+            coroutine_desc * src = TL_GET( this_thread )->curr_cor;
             coroutine_desc * dst = &this;
 …
 // Wrapper for co
 void CoroutineCtxSwitch(coroutine_desc* src, coroutine_desc* dst) {
+      // Safety note : This could cause some false positives due to preemption
+      // Safety note : Preemption must be disabled since there is a race condition
+      // kernelTLS.this_thread->curr_cor and $rsp/$rbp must agree at all times
       verify( TL_GET( preemption_state.enabled ) || TL_GET( this_processor )->do_terminate );
       disable_interrupts();
 …
       // set new coroutine that task is executing
       kernelTLS.this_coroutine = dst;
+      TL_GET( this_thread )->curr_cor = dst;
       // context switch to specified coroutine
 …
       enable_interrupts( __cfaabi_dbg_ctx );
-      // Safety note : This could cause some false positives due to preemption
       verify( TL_GET( preemption_state.enabled ) || TL_GET( this_processor )->do_terminate );
       if( unlikely(src->cancellation != NULL) ) {
             _CtxCoroutine_Unwind(src->cancellation);
+            _CtxCoroutine_Unwind(src->cancellation, src);
+      }
 } //ctxSwitchDirect
 …
+      }
+      void __leave_coroutine() {
+            coroutine_desc * src = TL_GET( this_coroutine ); // optimization
+      void __leave_coroutine( coroutine_desc * src ) {
             coroutine_desc * starter = src->cancellation != 0 ? src->last : src->starter;

libcfa/src/concurrency/coroutine.hfa

-                      rf845e80
+                      r98b4b12
 //-----------------------------------------------------------------------------
 // Public coroutine API
 static inline void suspend();
+static inline void suspend(void);
 forall(dtype T | is_coroutine(T))
 …
 // Suspend implementation inlined for performance
 static inline void suspend() {
+static inline void suspend(void) {
         // optimization : read TLS once and reuse it
         // Safety note: this is preemption safe since if
 …
         // will also migrate which means this value will
         // stay in syn with the TLS
         coroutine_desc * src = TL_GET( this_coroutine );
+        coroutine_desc * src = TL_GET( this_thread )->curr_cor;
         assertf( src->last != 0,
 …
         // will also migrate which means this value will
         // stay in syn with the TLS
         coroutine_desc * src = TL_GET( this_coroutine );
+        coroutine_desc * src = TL_GET( this_thread )->curr_cor;
         coroutine_desc * dst = get_coroutine(cor);
 …
         // will also migrate which means this value will
         // stay in syn with the TLS
         coroutine_desc * src = TL_GET( this_coroutine );
+        coroutine_desc * src = TL_GET( this_thread )->curr_cor;
         // not resuming self ?
 …
+}
+// static inline bool suspend_checkpoint(void) {
+//      // optimization : read TLS once and reuse it
+//      // Safety note: this is preemption safe since if
+//      // preemption occurs after this line, the pointer
+//      // will also migrate which means this value will
+//      // stay in syn with the TLS
+//      // set state of current coroutine to inactive
+//       this->state = Checkpoint;
+//       // context switch to specified coroutine
+//       assert( src->stack.context );
+//       CtxStore(src->stack.context);
+//      bool ret = this->state == Checkpoint;
+//       // set state of new coroutine to active
+//       src->state = Active;
+//       enable_interrupts( __cfaabi_dbg_ctx );
+//       // Safety note : This could cause some false positives due to preemption
+//       verify( TL_GET( preemption_state.enabled ) || TL_GET( this_processor )->do_terminate );
+//       if( unlikely(src->cancellation != NULL) ) {
+//             _CtxCoroutine_Unwind(src->cancellation);
+//       }
+//      return ret;
+// }
+// static inline void suspend_return(void) {
+//      // optimization : read TLS once and reuse it
+//      // Safety note: this is preemption safe since if
+//      // preemption occurs after this line, the pointer
+//      // will also migrate which means this value will
+//      // stay in syn with the TLS
+//      coroutine_desc * src = TL_GET( this_thread )->curr_cor;
+//      assertf( src->last != 0,
+//              "Attempt to suspend coroutine \"%.256s\" (%p) that has never been resumed.\n"
+//              "Possible cause is a suspend executed in a member called by a coroutine user rather than by the coroutine main.",
+//              src->name, src );
+//      assertf( src->last->state != Halted,
+//              "Attempt by coroutine \"%.256s\" (%p) to suspend back to terminated coroutine \"%.256s\" (%p).\n"
+//              "Possible cause is terminated coroutine's main routine has already returned.",
+//              src->name, src, src->last->name, src->last );
+//      // Safety note : Preemption must be disabled here since kernelTLS.this_coroutine must always be up to date
+//       verify( TL_GET( preemption_state.enabled ) || TL_GET( this_processor )->do_terminate );
+//       disable_interrupts();
+//       // set state of current coroutine to inactive
+//       src->state = src->state == Halted ? Halted : Inactive;
+//       // set new coroutine that task is executing
+//       kernelTLS.this_coroutine = dst;
+//       // context switch to specified coroutine
+//       assert( src->stack.context );
+//      CtxRet( src->stack.context );
+//      abort();
+// }
 // Local Variables: //
 // mode: c //

libcfa/src/concurrency/invoke.c

-                      rf845e80
+                      r98b4b12
 extern void __suspend_internal(void);
 extern void __leave_coroutine(void);
 extern void __finish_creation(void);
+extern void __leave_coroutine( struct coroutine_desc * );
+extern void __finish_creation( struct coroutine_desc * );
 extern void __leave_thread_monitor( struct thread_desc * this );
 extern void disable_interrupts();
 …
         //Final suspend, should never return
         __leave_coroutine();
+        __leave_coroutine( cor );
         __cabi_abort( "Resumed dead coroutine" );
+}
 …
         __attribute((__unused__)) struct _Unwind_Exception * unwind_exception,
         __attribute((__unused__)) struct _Unwind_Context * context,
         __attribute((__unused__)) void * param
+        void * param
 ) {
         if( actions & _UA_END_OF_STACK  ) {
                 // We finished unwinding the coroutine,
                 // leave it
                 __leave_coroutine();
+                __leave_coroutine( param );
                 __cabi_abort( "Resumed dead coroutine" );
+        }
 …
+}
 void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage) __attribute__ ((__noreturn__));
 void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage) {
         _Unwind_Reason_Code ret = _Unwind_ForcedUnwind( storage, _CtxCoroutine_UnwindStop, NULL );
+void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct coroutine_desc * cor) __attribute__ ((__noreturn__));
+void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct coroutine_desc * cor) {
+        _Unwind_Reason_Code ret = _Unwind_ForcedUnwind( storage, _CtxCoroutine_UnwindStop, cor );
         printf("UNWIND ERROR %d after force unwind\n", ret);
         abort();
 …
         void *this
 ) {
+        // Fetch the thread handle from the user defined thread structure
+        struct thread_desc* thrd = get_thread( this );
         // First suspend, once the thread arrives here,
         // the function pointer to main can be invalidated without risk
         __finish_creation();
+        __finish_creation(&thrd->self_cor);
+        // Fetch the thread handle from the user defined thread structure
+        struct thread_desc* thrd = get_thread( this );
+        // Restore the last to NULL, we clobbered because of the thunk problem
         thrd->self_cor.last = NULL;

libcfa/src/concurrency/invoke.h

-                      rf845e80
+                      r98b4b12
                 extern thread_local struct KernelThreadData {
-                        struct coroutine_desc * volatile this_coroutine;
                         struct thread_desc    * volatile this_thread;
                         struct processor      * volatile this_processor;
 …
                 } kernelTLS __attribute__ ((tls_model ( "initial-exec" )));
+        }
-        static inline struct coroutine_desc * volatile active_coroutine() { return TL_GET( this_coroutine ); }
-        static inline struct thread_desc    * volatile active_thread   () { return TL_GET( this_thread    ); }
-        static inline struct processor      * volatile active_processor() { return TL_GET( this_processor ); } // UNSAFE
         #endif
 …
                         struct thread_desc * prev;
                 } node;
+     };
+     #ifdef __cforall
+     extern "Cforall" {
+        };
+        #ifdef __cforall
+        extern "Cforall" {
+                static inline struct coroutine_desc * volatile active_coroutine() { return TL_GET( this_thread )->curr_cor; }
+                static inline struct thread_desc    * volatile active_thread   () { return TL_GET( this_thread    ); }
+                static inline struct processor      * volatile active_processor() { return TL_GET( this_processor ); } // UNSAFE
                 static inline thread_desc * & get_next( thread_desc & this ) {
                         return this.next;
 …
         extern void CtxInvokeStub( void );
         void CtxSwitch( void * from, void * to ) asm ("CtxSwitch");
+        // void CtxStore ( void * this ) asm ("CtxStore");
+        // void CtxRet   ( void * dst  ) asm ("CtxRet");
         #if   defined( __i386 )

libcfa/src/concurrency/kernel.cfa

-                      rf845e80
+                      r98b4b12
         NULL,
         NULL,
-        NULL,
         { 1, false, false }
 };
 …
 static void returnToKernel() {
         coroutine_desc * proc_cor = get_coroutine(kernelTLS.this_processor->runner);
         coroutine_desc * thrd_cor = kernelTLS.this_thread->curr_cor = kernelTLS.this_coroutine;
+        coroutine_desc * thrd_cor = kernelTLS.this_thread->curr_cor;
         ThreadCtxSwitch(thrd_cor, proc_cor);
+}
 …
         processor * proc = (processor *) arg;
         kernelTLS.this_processor = proc;
-        kernelTLS.this_coroutine = NULL;
         kernelTLS.this_thread    = NULL;
         kernelTLS.preemption_state.[enabled, disable_count] = [false, 1];
 …
         //Set global state
-        kernelTLS.this_coroutine = get_coroutine(proc->runner);
         kernelTLS.this_thread    = NULL;
 …
 // KERNEL_ONLY
 void kernel_first_resume(processor * this) {
         coroutine_desc * src = kernelTLS.this_coroutine;
+        coroutine_desc * src = mainThread->curr_cor;
         coroutine_desc * dst = get_coroutine(this->runner);
 …
         // set state of current coroutine to inactive
         src->state = src->state == Halted ? Halted : Inactive;
-        // set new coroutine that task is executing
-        kernelTLS.this_coroutine = dst;
         // SKULLDUGGERY normally interrupts are enable before leaving a coroutine ctxswitch.
 …
         kernelTLS.this_processor = mainProcessor;
         kernelTLS.this_thread    = mainThread;
-        kernelTLS.this_coroutine = &mainThread->self_cor;
         // Enable preemption
 …
                 __cfaabi_dbg_bits_write( abort_text, len );
                 if ( get_coroutine(thrd) != kernelTLS.this_coroutine ) {
                         len = snprintf( abort_text, abort_text_size, " in coroutine %.256s (%p).\n", kernelTLS.this_coroutine->name, kernelTLS.this_coroutine );
+                if ( &thrd->self_cor != thrd->curr_cor ) {
+                        len = snprintf( abort_text, abort_text_size, " in coroutine %.256s (%p).\n", thrd->curr_cor->name, thrd->curr_cor );
                         __cfaabi_dbg_bits_write( abort_text, len );
+                }

libcfa/src/concurrency/thread.cfa

-                      rf845e80
+                      r98b4b12
         coroutine_desc* thrd_c = get_coroutine(this);
         thread_desc   * thrd_h = get_thread   (this);
         thrd_c->last = TL_GET( this_coroutine );
+        thrd_c->last = TL_GET( this_thread )->curr_cor;
         // __cfaabi_dbg_print_safe("Thread start : %p (t %p, c %p)\n", this, thrd_c, thrd_h);
 …
         disable_interrupts();
         create_stack(&thrd_c->stack, thrd_c->stack.size);
-        kernelTLS.this_coroutine = thrd_c;
         CtxStart(&this, CtxInvokeThread);
         assert( thrd_c->last->stack.context );
 …
 extern "C" {
         // KERNEL ONLY
+        void __finish_creation(void) {
+                coroutine_desc* thrd_c = kernelTLS.this_coroutine;
+        void __finish_creation(coroutine_desc * thrd_c) {
                 ThreadCtxSwitch( thrd_c, thrd_c->last );
+        }
 …
         // set new coroutine that the processor is executing
         // and context switch to it
-        kernelTLS.this_coroutine = dst;
         assert( src->stack.context );
         CtxSwitch( src->stack.context, dst->stack.context );
-        kernelTLS.this_coroutine = src;
         // set state of new coroutine to active

libcfa/src/fstream.cfa

-                      rf845e80
+                      r98b4b12
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Dec 24 18:33:38 2018
 // Update Count     : 304
+// Last Modified On : Sat Apr 20 12:03:43 2019
+// Update Count     : 311
 //
 …
 #include <complex.h>                                                                    // creal, cimag
 #include <assert.h>
+#include <errno.h>                                                                              // errno
 #define IO_MSG "I/O error: "
 …
         os.nlOnOff = nlOnOff;
         os.prt = prt;
+        os.sawNL = false;
         sepSet( os, separator );
         sepSetCur( os, sepGet( os ) );
 …
         #ifdef __CFA_DEBUG__
         if ( file == 0 ) {
+                fprintf( stderr, IO_MSG "open output file \"%s\", ", name );
+                perror( 0 );
+                exit( EXIT_FAILURE );
+                abort( IO_MSG "open output file \"%s\", %s", name, strerror( errno ) );
         } // if
         #endif // __CFA_DEBUG__
 …
         if ( fclose( (FILE *)(os.file) ) == EOF ) {
                 perror( IO_MSG "close output" );
+                abort( IO_MSG "close output %s", strerror( errno ) );
         } // if
 } // close
 …
 ofstream & write( ofstream & os, const char * data, size_t size ) {
         if ( fail( os ) ) {
+                fprintf( stderr, "attempt write I/O on failed stream\n" );
+                exit( EXIT_FAILURE );
+                abort( "attempt write I/O on failed stream\n" );
         } // if
         if ( fwrite( data, 1, size, (FILE *)(os.file) ) != size ) {
+                perror( IO_MSG "write" );
+                exit( EXIT_FAILURE );
+                abort( IO_MSG "write %s", strerror( errno ) );
         } // if
         return os;
 …
         if ( len == EOF ) {
                 if ( ferror( (FILE *)(os.file) ) ) {
+                        fprintf( stderr, "invalid write\n" );
+                        exit( EXIT_FAILURE );
+                        abort( "invalid write\n" );
                 } // if
         } // if
 …
 void ?{}( ifstream & is, void * file ) {
         is.file = file;
+        is.nlOnOff = false;
+}
 …
         open( is, name, "r" );
+}
+void nlOn( ifstream & os ) { os.nlOnOff = true; }
+void nlOff( ifstream & os ) { os.nlOnOff = false; }
+bool getANL( ifstream & os ) { return os.nlOnOff; }
 int fail( ifstream & is ) {
 …
 void open( ifstream & is, const char * name, const char * mode ) {
         FILE *file = fopen( name, mode );
+        FILE * file = fopen( name, mode );
         #ifdef __CFA_DEBUG__
         if ( file == 0 ) {
+                fprintf( stderr, IO_MSG "open input file \"%s\", ", name );
+                perror( 0 );
+                exit( EXIT_FAILURE );
+                abort( IO_MSG "open input file \"%s\", %s\n", name, strerror( errno ) );
         } // if
         #endif // __CFA_DEBUG__
 …
         if ( fclose( (FILE *)(is.file) ) == EOF ) {
                 perror( IO_MSG "close input" );
+                abort( IO_MSG "close input %s", strerror( errno ) );
         } // if
 } // close
 …
 ifstream & read( ifstream & is, char * data, size_t size ) {
         if ( fail( is ) ) {
+                fprintf( stderr, "attempt read I/O on failed stream\n" );
+                exit( EXIT_FAILURE );
+                abort( "attempt read I/O on failed stream\n" );
         } // if
         if ( fread( data, size, 1, (FILE *)(is.file) ) == 0 ) {
+                perror( IO_MSG "read" );
+                exit( EXIT_FAILURE );
+                abort( IO_MSG "read %s", strerror( errno ) );
         } // if
         return is;
 …
 ifstream &ungetc( ifstream & is, char c ) {
         if ( fail( is ) ) {
+                fprintf( stderr, "attempt ungetc I/O on failed stream\n" );
+                exit( EXIT_FAILURE );
+                abort( "attempt ungetc I/O on failed stream\n" );
         } // if
         if ( ungetc( c, (FILE *)(is.file) ) == EOF ) {
+                perror( IO_MSG "ungetc" );
+                exit( EXIT_FAILURE );
+                abort( IO_MSG "ungetc %s", strerror( errno ) );
         } // if
         return is;
 …
         if ( len == EOF ) {
                 if ( ferror( (FILE *)(is.file) ) ) {
+                        fprintf( stderr, "invalid read\n" );
+                        exit( EXIT_FAILURE );
+                        abort( "invalid read\n" );
                 } // if
         } // if

libcfa/src/fstream.hfa

-                      rf845e80
+                      r98b4b12
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Dec 24 18:33:41 2018
 // Update Count     : 149
+// Last Modified On : Sat Apr 20 12:03:58 2019
+// Update Count     : 151
 //
 …
 struct ifstream {
         void * file;
+        bool nlOnOff;
 }; // ifstream
 // public
+void nlOn( ifstream & );
+void nlOff( ifstream & );
+bool getANL( ifstream & );
 int fail( ifstream & is );
 int eof( ifstream & is );

libcfa/src/gmp.hfa

-                      rf845e80
+                      r98b4b12
 // Created On       : Tue Apr 19 08:43:43 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Dec  4 23:25:51 2018
 // Update Count     : 22
+// Last Modified On : Sat Apr 20 09:01:52 2019
+// Update Count     : 24
 //
 …
         void ?|?( ostype & os, Int mp ) {
                 (ostype)(os | mp); if ( getANL( os ) ) nl( os );
+                (ostype)(os | mp); nl( os );
         } // ?|?
 } // distribution

libcfa/src/heap.cfa

-                      rf845e80
+                      r98b4b12
 // Created On       : Tue Dec 19 21:58:35 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Sep  6 09:01:30 2018
 // Update Count     : 513
+// Last Modified On : Fri Mar 22 13:43:10 2019
+// Update Count     : 514
 //
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa -nodebug -O2 heap.c" //
+// compile-command: "cfa -nodebug -O2 heap.cfa" //
 // End: //

libcfa/src/iostream.cfa

-                      rf845e80
+                      r98b4b12
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Mar  4 20:57:24 2019
 // Update Count     : 593
+// Last Modified On : Sat Apr 20 14:02:43 2019
+// Update Count     : 617
 //
 …
         istype & ?|?( istype & is, char & c ) {
+                fmt( is, "%c", &c );                                                    // must pass pointer through varg to fmt
+                char temp;
+                for () {
+                        fmt( is, "%c", &temp );                                                 // must pass pointer through varg to fmt
+                        // do not overwrite parameter with newline unless appropriate
+                        if ( temp != '\n' || getANL( is ) ) { c = temp; break; }
+                        if ( eof( is ) ) break;
+                } // for
                 return is;
         } // ?|?
 …
                 return is;
         } // nl
+        istype & nlOn( istype & is ) {
+                nlOn( is );                                                                             // call void returning
+                return is;
+        } // nlOn
+        istype & nlOff( istype & is ) {
+                nlOff( is );                                                                    // call void returning
+                return is;
+        } // nlOff
 } // distribution

libcfa/src/iostream.hfa

-                      rf845e80
+                      r98b4b12
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Feb 26 16:57:22 2019
 // Update Count     : 221
+// Last Modified On : Sat Apr 20 12:04:07 2019
+// Update Count     : 226
 //
 …
 trait istream( dtype istype ) {
+        void nlOn( istype & );                                                          // read newline
+        void nlOff( istype & );                                                         // scan newline
+        bool getANL( istype & );                                                        // get scan newline (on/off)
         int fail( istype & );
         int eof( istype & );
 …
         // manipulators
+        istype & nlOn( istype & );
+        istype & nlOff( istype & );
         istype & ?|?( istype &, istype & (*)( istype & ) );
         istype & nl( istype & is );

libcfa/src/rational.cfa

-                      rf845e80
+                      r98b4b12
 // Created On       : Wed Apr  6 17:54:28 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Dec 23 22:56:49 2018
 // Update Count     : 170
+// Last Modified On : Thu Mar 28 17:33:03 2019
+// Update Count     : 181
 //
 …
         static RationalImpl simplify( RationalImpl & n, RationalImpl & d ) {
                 if ( d == (RationalImpl){0} ) {
+                        serr | "Invalid rational number construction: denominator cannot be equal to 0.";
+                        exit( EXIT_FAILURE );
+                        abort( "Invalid rational number construction: denominator cannot be equal to 0.\n" );
                 } // exit
                 if ( d < (RationalImpl){0} ) { d = -d; n = -n; } // move sign to numerator
 …
         void ?{}( Rational(RationalImpl) & r, RationalImpl n, RationalImpl d ) {
                 RationalImpl t = simplify( n, d );                              // simplify
+                r.numerator = n / t;
+                r.denominator = d / t;
+                r.[numerator, denominator] = [n / t, d / t];
         } // rational
 …
                 RationalImpl prev = r.numerator;
                 RationalImpl t = gcd( abs( n ), r.denominator ); // simplify
+                r.numerator = n / t;
+                r.denominator = r.denominator / t;
+                r.[numerator, denominator] = [n / t, r.denominator / t];
                 return prev;
         } // numerator
 …
                 RationalImpl prev = r.denominator;
                 RationalImpl t = simplify( r.numerator, d );    // simplify
+                r.numerator = r.numerator / t;
+                r.denominator = d / t;
+                r.[numerator, denominator] = [r.numerator / t, d / t];
                 return prev;
         } // denominator
 …
         Rational(RationalImpl) +?( Rational(RationalImpl) r ) {
+                Rational(RationalImpl) t = { r.numerator, r.denominator };
+                return t;
+                return (Rational(RationalImpl)){ r.numerator, r.denominator };
         } // +?
         Rational(RationalImpl) -?( Rational(RationalImpl) r ) {
+                Rational(RationalImpl) t = { -r.numerator, r.denominator };
+                return t;
+                return (Rational(RationalImpl)){ -r.numerator, r.denominator };
         } // -?
         Rational(RationalImpl) ?+?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
                 if ( l.denominator == r.denominator ) {                 // special case
+                        Rational(RationalImpl) t = { l.numerator + r.numerator, l.denominator };
+                        return t;
+                        return (Rational(RationalImpl)){ l.numerator + r.numerator, l.denominator };
                 } else {
+                        Rational(RationalImpl) t = { l.numerator * r.denominator + l.denominator * r.numerator, l.denominator * r.denominator };
+                        return t;
+                        return (Rational(RationalImpl)){ l.numerator * r.denominator + l.denominator * r.numerator, l.denominator * r.denominator };
                 } // if
         } // ?+?
 …
         Rational(RationalImpl) ?-?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
                 if ( l.denominator == r.denominator ) {                 // special case
+                        Rational(RationalImpl) t = { l.numerator - r.numerator, l.denominator };
+                        return t;
+                        return (Rational(RationalImpl)){ l.numerator - r.numerator, l.denominator };
                 } else {
+                        Rational(RationalImpl) t = { l.numerator * r.denominator - l.denominator * r.numerator, l.denominator * r.denominator };
+                        return t;
+                        return (Rational(RationalImpl)){ l.numerator * r.denominator - l.denominator * r.numerator, l.denominator * r.denominator };
                 } // if
         } // ?-?
         Rational(RationalImpl) ?*?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
+                Rational(RationalImpl) t = { l.numerator * r.numerator, l.denominator * r.denominator };
+                return t;
+                return (Rational(RationalImpl)){ l.numerator * r.numerator, l.denominator * r.denominator };
         } // ?*?
         Rational(RationalImpl) ?/?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
                 if ( r.numerator < (RationalImpl){0} ) {
+                        r.numerator = -r.numerator;
+                        r.denominator = -r.denominator;
+                        r.[numerator, denominator] = [-r.numerator, -r.denominator];
                 } // if
+                Rational(RationalImpl) t = { l.numerator * r.denominator, l.denominator * r.numerator };
+                return t;
+                return (Rational(RationalImpl)){ l.numerator * r.denominator, l.denominator * r.numerator };
         } // ?/?
 …
         forall( dtype istype | istream( istype ) | { istype & ?|?( istype &, RationalImpl & ); } )
         istype & ?|?( istype & is, Rational(RationalImpl) & r ) {
-                RationalImpl t;
                 is | r.numerator | r.denominator;
                 t = simplify( r.numerator, r.denominator );
+                RationalImpl t = simplify( r.numerator, r.denominator );
                 r.numerator /= t;
                 r.denominator /= t;
 …
         } // distribution
 } // distribution
+forall( otype RationalImpl | arithmetic( RationalImpl ) | { RationalImpl ?\?( RationalImpl, unsigned long ); } )
+Rational(RationalImpl) ?\?( Rational(RationalImpl) x, long int y ) {
+        if ( y < 0 ) {
+                return (Rational(RationalImpl)){ x.denominator \ -y, x.numerator \ -y };
+        } else {
+                return (Rational(RationalImpl)){ x.numerator \ y, x.denominator \ y };
+        } // if
+}
 // conversion

libcfa/src/rational.hfa

-                      rf845e80
+                      r98b4b12
 // Created On       : Wed Apr  6 17:56:25 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Dec  4 23:07:46 2018
 // Update Count     : 106
+// Last Modified On : Tue Mar 26 23:16:10 2019
+// Update Count     : 109
 //
 …
 } // distribution
+forall( otype RationalImpl | arithmetic( RationalImpl ) |{RationalImpl ?\?( RationalImpl, unsigned long );} )
+Rational(RationalImpl) ?\?( Rational(RationalImpl) x, long int y );
 // conversion
 forall( otype RationalImpl | arithmetic( RationalImpl ) | { double convert( RationalImpl ); } )

libcfa/src/stdhdr/stdbool.h

-                      rf845e80
+                      r98b4b12
 // Created On       : Mon Jul  4 23:25:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Jul  5 20:39:51 2016
 // Update Count     : 12
+// Last Modified On : Mon Mar 25 08:00:08 2019
+// Update Count     : 15
 //
 extern "C" {
 #include_next <stdbool.h>                                                               // has internal check for multiple expansion
+// allows printing as true/false
+#if defined( true )
+#undef true
+#define true ((_Bool)1)
+#endif // true
+#if defined( false )
+#undef false
+#define false ((_Bool)0)
+#endif // false
 } // extern "C"

libcfa/src/stdlib.hfa

-                      rf845e80
+                      r98b4b12
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Dec 17 15:37:45 2018
 // Update Count     : 346
+// Last Modified On : Wed Apr 24 17:35:43 2019
+// Update Count     : 352
 //
 …
         } // malloc
-        // T & malloc( void ) {
-        //      int & p = *(T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
-        //      printf( "& malloc %p\n", &p );
-        //      return p;
-        //      //      return (T &)*(T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
-        // } // malloc
         T * calloc( size_t dim ) {
                 return (T *)(void *)calloc( dim, sizeof(T) );   // C calloc
 …
         T * alloc( char fill ) {
                 T * ptr = (T *)(void *)malloc( (size_t)sizeof(T) );     // C malloc
                 return (T *)memset( ptr, (int)fill, sizeof(T) );        // initial with fill value
+                return (T *)memset( ptr, (int)fill, sizeof(T) ); // initialize with fill value
         } // alloc
 …
         T * alloc( size_t dim, char fill ) {
                 T * ptr = (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc
                 return (T *)memset( ptr, (int)fill, dim * sizeof(T) );    // initial with fill value
+                T * ptr = (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C calloc
+                return (T *)memset( ptr, (int)fill, dim * sizeof(T) ); // initialize with fill value
         } // alloc

src/Common/PassVisitor.cc

rf845e80	r98b4b12
17	17
18	18	PassVisitorStats pass_visitor_stats;
	19	Stats::Counters::SimpleCounter* BaseSyntaxNode::new_nodes = nullptr;

src/Common/Stats/Counter.h

-                      rf845e80
+                      r98b4b12
                         class SimpleCounter {
                         public:
+                                inline void operator++() {}
                                 inline void operator++(int) {}
                                 inline void operator+=(size_t) {}
 …
                                 virtual void print(std::ostream & os) override { os << count; }
+                                inline void operator++()             { if(!enabled) return; count++;        }
                                 inline void operator++(int)          { if(!enabled) return; count++;        }
                                 inline void operator+=(size_t value) { if(!enabled) return; count += value; }

src/ControlStruct/ForExprMutator.cc

-                      rf845e80
+                      r98b4b12
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Fri Aug 18 10:22:00 2017
 // Update Count     : 12
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Mar 11 22:26:52 2019
+// Update Count     : 14
 //
 …
 namespace ControlStruct {
         Statement *hoist( Statement *originalStmt, std::list<Statement *> &init ) {
+        Statement * hoist( Statement * originalStmt, std::list<Statement *> & init ) {
                 // If no hoisting is needed, skip:
                 if ( 0 == init.size() ) {
 …
                 // Create compound statement, move initializers outside,
                 // the resut of the original stays as is.
                 CompoundStmt *block = new CompoundStmt();
                 std::list<Statement *> &stmts = block->get_kids();
+                CompoundStmt * block = new CompoundStmt();
+                std::list<Statement *> & stmts = block->get_kids();
                 stmts.splice( stmts.end(), init );
 …
+        }
         Statement *ForExprMutator::postmutate( IfStmt *ifStmt ) {
+        Statement * ForExprMutator::postmutate( IfStmt * ifStmt ) {
                 return hoist( ifStmt, ifStmt->initialization );
+        }
         Statement *ForExprMutator::postmutate( ForStmt *forStmt ) {
+        Statement * ForExprMutator::postmutate( ForStmt * forStmt ) {
                 // hoist any initializer declarations to make them C89 (rather than C99)
                 return hoist( forStmt, forStmt->initialization );
+        }
         Statement *ForExprMutator::postmutate( WhileStmt *whileStmt ) {
+        Statement * ForExprMutator::postmutate( WhileStmt * whileStmt ) {
                 return hoist( whileStmt, whileStmt->initialization );
+        }

src/ControlStruct/LabelFixer.cc

-                      rf845e80
+                      r98b4b12
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Rob Schluntz
 // Last Modified On : Tue Jul 28 13:32:43 2015
 // Update Count     : 156
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Mar 11 22:26:02 2019
+// Update Count     : 159
 //
 …
+        }
         LabelFixer::LabelFixer( LabelGenerator *gen ) : generator ( gen ) {
+        LabelFixer::LabelFixer( LabelGenerator * gen ) : generator ( gen ) {
                 if ( generator == 0 )
                         generator = LabelGenerator::getGenerator();
 …
         // prune to at most one label definition for each statement
         void LabelFixer::previsit( Statement *stmt ) {
+        void LabelFixer::previsit( Statement * stmt ) {
                 std::list< Label > &labels = stmt->get_labels();
 …
+        }
         void LabelFixer::previsit( BranchStmt *branchStmt ) {
+        void LabelFixer::previsit( BranchStmt * branchStmt ) {
                 previsit( ( Statement *)branchStmt );
 …
         // sets the definition of the labelTable entry to be the provided
         // statement for every label in the list parameter. Happens for every kind of statement
         Label LabelFixer::setLabelsDef( std::list< Label > &llabel, Statement *definition ) {
+        // sets the definition of the labelTable entry to be the provided statement for every label in the list
+        // parameter. Happens for every kind of statement
+        Label LabelFixer::setLabelsDef( std::list< Label > & llabel, Statement * definition ) {
                 assert( definition != 0 );
                 assert( llabel.size() > 0 );
 …
                 } // for
+                // produce one of the labels attached to this statement to be
+                // temporarily used as the canonical label
+                // produce one of the labels attached to this statement to be temporarily used as the canonical label
                 return labelTable[ llabel.front() ]->get_label();
+        }
 …
         // Builds a table that maps a label to its defining statement.
         std::map<Label, Statement * > *LabelFixer::resolveJumps() throw ( SemanticErrorException ) {
+        std::map<Label, Statement * > * LabelFixer::resolveJumps() throw ( SemanticErrorException ) {
                 std::map< Label, Statement * > *ret = new std::map< Label, Statement * >();
                 for ( std::map< Label, Entry * >::iterator i = labelTable.begin(); i != labelTable.end(); ++i ) {

src/ControlStruct/LabelGenerator.cc

-                      rf845e80
+                      r98b4b12
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Thr Aug 14 14:14:00 2015
 // Update Count     : 14
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Mar 11 22:23:20 2019
+// Update Count     : 15
 //
 …
 namespace ControlStruct {
         LabelGenerator *LabelGenerator::labelGenerator = 0;
+        LabelGenerator * LabelGenerator::labelGenerator = 0;
         LabelGenerator *LabelGenerator::getGenerator() {
+        LabelGenerator * LabelGenerator::getGenerator() {
                 if ( LabelGenerator::labelGenerator == 0 )
                         LabelGenerator::labelGenerator = new LabelGenerator();
                 return labelGenerator;
+        }
 …
                 if ( stmt && ! stmt->get_labels().empty() ) {
                         os << "_" << stmt->get_labels().front() << "__";
+                }
+                } // if
                 std::string ret = os.str();
                 Label l( ret );

src/Parser/ParseNode.h

-                      rf845e80
+                      r98b4b12
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Feb 13 17:36:49 2019
 // Update Count     : 867
+// Last Modified On : Mon Apr 15 14:22:39 2019
+// Update Count     : 874
 //
 …
         void printOneLine( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const {}
-        Expression *get_expr() const { return expr.get(); }
         template<typename T>
         bool isExpressionType() const { return nullptr != dynamic_cast<T>(expr.get()); }
         Expression * build() const { return const_cast<ExpressionNode *>(this)->expr.release(); }
+        std::unique_ptr<Expression> expr;                                       // public because of lifetime implications
   private:
         bool extension = false;
-        std::unique_ptr<Expression> expr;
 }; // ExpressionNode

src/Parser/lex.ll

-                      rf845e80
+                      r98b4b12
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
  * Last Modified On : Sun Mar 10 09:13:09 2019
  * Update Count     : 706
+ * Last Modified On : Wed Mar 13 14:54:30 2019
+ * Update Count     : 707
  */
 …
 char                    { KEYWORD_RETURN(CHAR); }
 choose                  { KEYWORD_RETURN(CHOOSE); }                             // CFA
+coerce                  { KEYWORD_RETURN(COERCE); }                             // CFA
 _Complex                { KEYWORD_RETURN(COMPLEX); }                    // C99
 __complex               { KEYWORD_RETURN(COMPLEX); }                    // GCC

src/Parser/parser.yy

-                      rf845e80
+                      r98b4b12
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Feb 21 08:45:07 2019
 // Update Count     : 4232
+// Last Modified On : Mon Apr 15 15:02:56 2019
+// Update Count     : 4290
 //
 …
 ForCtrl * forCtrl( ExpressionNode * type, string * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
         ConstantExpr * constant = dynamic_cast<ConstantExpr *>(type->get_expr());
+        ConstantExpr * constant = dynamic_cast<ConstantExpr *>(type->expr.get());
         if ( constant && (constant->get_constant()->get_value() == "0" || constant->get_constant()->get_value() == "1") ) {
         type = new ExpressionNode( new CastExpr( maybeMoveBuild< Expression >(type), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) ) );
 …
 ForCtrl * forCtrl( ExpressionNode * type, ExpressionNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
         if ( NameExpr * identifier = dynamic_cast<NameExpr *>(index->get_expr()) ) {
+        if ( NameExpr * identifier = dynamic_cast<NameExpr *>(index->expr.get()) ) {
                 return forCtrl( type, new string( identifier->name ), start, compop, comp, inc );
         } else if ( CommaExpr * commaExpr = dynamic_cast<CommaExpr *>(index->get_expr()) ) {
+        } else if ( CommaExpr * commaExpr = dynamic_cast<CommaExpr *>(index->expr.get()) ) {
                 if ( NameExpr * identifier = dynamic_cast<NameExpr *>(commaExpr->arg1 ) ) {
                         return forCtrl( type, new string( identifier->name ), start, compop, comp, inc );
 …
 %token RESTRICT                                                                                 // C99
 %token ATOMIC                                                                                   // C11
 %token FORALL MUTEX VIRTUAL                                                             // CFA
+%token FORALL MUTEX VIRTUAL COERCE                                              // CFA
 %token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED
 %token BOOL COMPLEX IMAGINARY                                                   // C99
 …
 %type<en> subrange
 %type<decl> asm_name_opt
 %type<en> asm_operands_opt asm_operands_list asm_operand
+%type<en> asm_operands_opt                              asm_operands_list                       asm_operand
 %type<label> label_list
 %type<en> asm_clobbers_list_opt
 %type<flag> asm_volatile_opt
 %type<en> handler_predicate_opt
 %type<genexpr> generic_association generic_assoc_list
+%type<genexpr> generic_association              generic_assoc_list
 // statements
 …
         | '(' type_no_function ')' cast_expression
                 { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
+                // keyword cast cannot be grouped because of reduction in aggregate_key
         | '(' COROUTINE '&' ')' cast_expression                         // CFA
                 { $$ = new ExpressionNode( build_keyword_cast( KeywordCastExpr::Coroutine, $5 ) ); }
 …
         | '(' VIRTUAL type_no_function ')' cast_expression      // CFA
                 { $$ = new ExpressionNode( new VirtualCastExpr( maybeMoveBuild< Expression >( $5 ), maybeMoveBuildType( $3 ) ) ); }
+        | '(' RETURN type_no_function ')' cast_expression       // CFA
+                { SemanticError( yylloc, "Return cast is currently unimplemented." ); $$ = nullptr; }
+        | '(' COERCE type_no_function ')' cast_expression       // CFA
+                { SemanticError( yylloc, "Coerce cast is currently unimplemented." ); $$ = nullptr; }
+        | '(' qualifier_cast_list ')' cast_expression           // CFA
+                { SemanticError( yylloc, "Qualifier cast is currently unimplemented." ); $$ = nullptr; }
 //      | '(' type_no_function ')' tuple
 //              { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
+        ;
+qualifier_cast_list:
+        cast_modifier type_qualifier_name
+        | cast_modifier MUTEX
+        | qualifier_cast_list cast_modifier type_qualifier_name
+        | qualifier_cast_list cast_modifier MUTEX
+        ;
+cast_modifier:
+        '-'
+        | '+'
+        ;
 …
         for_control_expression
         | for_control_expression_list ':' for_control_expression
+                { $$ = $3; }
+                // ForCtrl + ForCtrl:
+                //    init + init => multiple declaration statements that are hoisted
+                //    condition + condition => (expression) && (expression)
+                //    change + change => (expression), (expression)
+                {
+                        $1->init->set_last( $3->init );
+                        if ( $1->condition ) {
+                                if ( $3->condition ) {
+                                        $1->condition->expr.reset( new LogicalExpr( $1->condition->expr.release(), $3->condition->expr.release(), true ) );
+                                } // if
+                        } else $1->condition = $3->condition;
+                        if ( $1->change ) {
+                                if ( $3->change ) {
+                                        $1->change->expr.reset( new CommaExpr( $1->change->expr.release(), $3->change->expr.release() ) );
+                                } // if
+                        } else $1->change = $3->change;
+                        $$ = $1;
+                }
+        ;
 …
         | declaration comma_expression_opt ';' comma_expression_opt // C99, declaration has ';'
                 { $$ = new ForCtrl( $1, $2, $4 ); }
         | comma_expression                                                                      // CFA
                 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
 …
         | comma_expression ';' comma_expression inclexcl comma_expression '~' comma_expression // CFA
                 { $$ = forCtrl( $3, $1, $3->clone(), $4, $5, $7 ); }
+                // There is a S/R conflicit if ~ and -~ are factored out.
+        | comma_expression ';' comma_expression '~' '@'         // CFA
+                { $$ = forCtrl( $3, $1, $3->clone(), OperKinds::LThan, nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
+        | comma_expression ';' comma_expression ErangeDown '@' // CFA
+                { $$ = forCtrl( $3, $1, $3->clone(), OperKinds::GThan, nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
         | comma_expression ';' comma_expression '~' '@' '~' comma_expression // CFA
                 { $$ = forCtrl( $3, $1, $3->clone(), OperKinds::LThan, nullptr, $7 ); }

src/ResolvExpr/AlternativeFinder.cc

-                      rf845e80
+                      r98b4b12
                         // - necessary pre-requisite to pruning
                         AltList candidates;
+                        std::list<std::string> errors;
                         for ( unsigned i = 0; i < alternatives.size(); ++i ) {
                                 resolveAssertions( alternatives[i], indexer, candidates );
+                                resolveAssertions( alternatives[i], indexer, candidates, errors );
+                        }
                         // fail early if none such
                         if ( mode.failFast && candidates.empty() ) {
                                 std::ostringstream stream;
+                                stream << "No resolvable alternatives for expression " << expr << "\n"
+                                       << "Alternatives with failing assertions are:\n";
+                                printAlts( alternatives, stream, 1 );
+                                stream << "No alternatives with satisfiable assertions for " << expr << "\n";
+                                //        << "Alternatives with failing assertions are:\n";
+                                // printAlts( alternatives, stream, 1 );
+                                for ( const auto& err : errors ) {
+                                        stream << err;
+                                }
                                 SemanticError( expr->location, stream.str() );
+                        }

src/ResolvExpr/ResolveAssertions.cc

-                      rf845e80
+                      r98b4b12
 #include <list>                     // for list
 #include <memory>                   // for unique_ptr
+#include <string>
+#include <sstream>                  // for ostringstream
+#include <string>                   // for string
 #include <unordered_map>            // for unordered_map, unordered_multimap
 #include <utility>                  // for move
 …
 #include "Alternative.h"            // for Alternative, AssertionItem, AssertionList
 #include "Common/FilterCombos.h"    // for filterCombos
+#include "Common/Indenter.h"        // for Indenter
 #include "Common/utility.h"         // for sort_mins
 #include "ResolvExpr/RenameVars.h"  // for renameTyVars
 …
                         return { item, item.matches[i] };
+                }
+                const DeclarationWithType* get_decl() const { return cache->at(key).deferIds[0].decl; }
                 // sortable by key
 …
         static const int recursionLimit = /* 10 */ 4;
         void resolveAssertions( Alternative& alt, const SymTab::Indexer& indexer, AltList& out ) {
+        void resolveAssertions( Alternative& alt, const SymTab::Indexer& indexer, AltList& out, std::list<std::string>& errors ) {
                 // finish early if no assertions to resolve
                 if ( alt.need.empty() ) {
 …
                                 for ( auto& assn : resn.need ) {
                                         // fail early if any assertion is not resolvable
+                                        if ( ! resolveAssertion( assn, resn, assnCache ) ) goto nextResn;
+                                        if ( ! resolveAssertion( assn, resn, assnCache ) ) {
+                                                Indenter tabs{ Indenter::tabsize, 3 };
+                                                std::ostringstream ss;
+                                                ss << tabs << "Unsatisfiable alternative:\n";
+                                                resn.alt.print( ss, ++tabs );
+                                                ss << --tabs << "Could not satisfy assertion:\n";
+                                                assn.decl->print( ss, ++tabs );
+                                                errors.emplace_back( ss.str() );
+                                                goto nextResn;
+                                        }
+                                }
 …
                                                 resn.deferred,
                                                 CandidateEnvMerger{ resn.alt.env, resn.alt.openVars, resn.indexer } );
+                                        // fail early if no mutually-compatible assertion satisfaction
+                                        if ( compatible.empty() ) {
+                                                Indenter tabs{ Indenter::tabsize, 3 };
+                                                std::ostringstream ss;
+                                                ss << tabs << "Unsatisfiable alternative:\n";
+                                                resn.alt.print( ss, ++tabs );
+                                                ss << --tabs << "No mutually-compatible satisfaction for assertions:\n";
+                                                ++tabs;
+                                                for ( const auto& d : resn.deferred ) {
+                                                        d.get_decl()->print( ss, tabs );
+                                                }
+                                                errors.emplace_back( ss.str() );
+                                                goto nextResn;
+                                        }
                                         // sort by cost
                                         CandidateCost coster{ resn.indexer };

src/ResolvExpr/ResolveAssertions.h

rf845e80	r98b4b12
24	24	namespace ResolvExpr {
25	25	/// Recursively resolves all assertions provided in an alternative; returns true iff succeeds
26		void resolveAssertions( Alternative& alt, const SymTab::Indexer& indexer, AltList& out );
	26	void resolveAssertions( Alternative& alt, const SymTab::Indexer& indexer, AltList& out, std::list<std::string>& errors );
27	27	} // namespace ResolvExpr
28	28

src/ResolvExpr/TypeEnvironment.cc

-                      rf845e80
+                      r98b4b12
+        }
+        bool TypeEnvironment::bindVarToVar( TypeInstType *var1, TypeInstType *var2, const TypeDecl::Data & data, AssertionSet &need, AssertionSet &have, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
+        bool TypeEnvironment::bindVarToVar( TypeInstType *var1, TypeInstType *var2,
+                        TypeDecl::Data && data, AssertionSet &need, AssertionSet &have,
+                        const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
                 auto class1 = internal_lookup( var1->get_name() );
 …
                                         class1->set_type( common );
+                                }
+                                class1->data.isComplete |= data.isComplete;
                                 env.erase( class2 );
                         } else return false;
 …
                                 class1->vars.insert( class2->vars.begin(), class2->vars.end() );
                                 class1->allowWidening = widen1;
+                                class1->data.isComplete |= data.isComplete;
                                 env.erase( class2 );
                         } else {
                                 class2->vars.insert( class1->vars.begin(), class1->vars.end() );
                                 class2->allowWidening = widen2;
+                                class2->data.isComplete |= data.isComplete;
                                 env.erase( class1 );
                         } // if
 …
                         class1->vars.insert( var2->get_name() );
                         class1->allowWidening = widen1;
+                        class1->data.isComplete |= data.isComplete;
                 } else if ( class2 != env.end() ) {
                         // var1 unbound, add to class2
                         class2->vars.insert( var1->get_name() );
                         class2->allowWidening = widen2;
+                        class2->data.isComplete |= data.isComplete;
                 } else {
                         // neither var bound, create new class

src/ResolvExpr/TypeEnvironment.h

rf845e80	r98b4b12
139	139	/// Binds the type classes represented by `var1` and `var2` together; will add
140	140	/// one or both classes if needed. Returns false on failure.
141		bool bindVarToVar( TypeInstType var1, TypeInstType var2, ~~const TypeDecl::Data~~ & data, AssertionSet &need, AssertionSet &have, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer );
	141	bool bindVarToVar( TypeInstType var1, TypeInstType var2, TypeDecl::Data && data, AssertionSet &need, AssertionSet &have, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer );
142	142
143	143	/// Disallows widening for all bindings in the environment

src/ResolvExpr/Unify.cc

-                      rf845e80
+                      r98b4b12
                 bool isopen2 = var2 && ( entry2 != openVars.end() );
+                if ( isopen1 && isopen2 && entry1->second == entry2->second ) {
+                        result = env.bindVarToVar( var1, var2, entry1->second, needAssertions, haveAssertions, openVars, widenMode, indexer );
+                if ( isopen1 && isopen2 ) {
+                        if ( entry1->second.kind != entry2->second.kind ) {
+                                result = false;
+                        } else {
+                                result = env.bindVarToVar(
+                                        var1, var2, TypeDecl::Data{ entry1->second, entry2->second }, needAssertions,
+                                        haveAssertions, openVars, widenMode, indexer );
+                        }
                 } else if ( isopen1 ) {
                         result = env.bindVar( var1, type2, entry1->second, needAssertions, haveAssertions, openVars, widenMode, indexer );

src/SymTab/Indexer.cc

-                      rf845e80
+                      r98b4b12
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:37:33 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Aug 17 16:08:40 2017
 // Update Count     : 20
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Fri Mar  8 13:55:00 2019
+// Update Count     : 21
 //
 …
 #include <cassert>                 // for assert, strict_dynamic_cast
-#include <iostream>                // for operator<<, basic_ostream, ostream
 #include <string>                  // for string, operator<<, operator!=
+#include <memory>                  // for shared_ptr, make_shared
 #include <unordered_map>           // for operator!=, unordered_map<>::const...
 #include <unordered_set>           // for unordered_set
 #include <utility>                 // for pair, make_pair, move
+#include <vector>                  // for vector
 #include "CodeGen/OperatorTable.h" // for isCtorDtor, isCtorDtorAssign
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/utility.h"        // for cloneAll
 #include "Common/Stats/Counter.h" // for counters
 #include "GenPoly/GenPoly.h"
+#include "Common/Stats/Counter.h"  // for counters
+#include "GenPoly/GenPoly.h"       // for getFunctionType
 #include "InitTweak/InitTweak.h"   // for isConstructor, isCopyFunction, isC...
 #include "Mangler.h"               // for Mangler
 …
 #include "SynTree/Type.h"          // for Type, StructInstType, UnionInstType
-#define debugPrint(x) if ( doDebug ) { std::cerr << x; }
 namespace SymTab {
         // Statistics block
         namespace {
+                static inline auto stats_idtable() {
+                        using namespace Stats::Counters;
+                        static auto group = build<CounterGroup>("IdTable");
+                        static struct {
+                                SimpleCounter * find;
+                                AverageCounter<double> * size;
+                                AverageCounter<double> * key;
+                        } ret = {
+                                .find = build<SimpleCounter>("Find calls", group),
+                                .size = build<AverageCounter<double>>("Average Size", group),
+                                .key  = build<AverageCounter<double>>("Average Key Size", group),
+                        };
+                        return ret;
+                }
+                static inline auto stats_indexers() {
+                static inline auto stats() {
                         using namespace Stats::Counters;
                         static auto group   = build<CounterGroup>("Indexers");
 …
                                 SimpleCounter * count;
                                 AverageCounter<double> * size;
+                                AverageCounter<double> * depth_a;
+                                MaxCounter<size_t> * depth_m;
+                                SimpleCounter * new_scopes;
+                                SimpleCounter * lazy_scopes;
+                                AverageCounter<double> * avg_scope_depth;
+                                MaxCounter<size_t> * max_scope_depth;
+                                SimpleCounter * add_calls;
+                                SimpleCounter * lookup_calls;
+                                SimpleCounter * map_lookups;
+                                SimpleCounter * map_mutations;
                         } ret = {
                                 .count   = build<SimpleCounter>("Count", group),
                                 .size    = build<AverageCounter<double>>("Average Size", group),
+                                .depth_a = build<AverageCounter<double>>("Average Depth", group),
+                                .depth_m = build<MaxCounter<size_t>>("Max Depth", group),
+                                .new_scopes = build<SimpleCounter>("Scopes", group),
+                                .lazy_scopes = build<SimpleCounter>("Lazy Scopes", group),
+                                .avg_scope_depth = build<AverageCounter<double>>("Average Scope", group),
+                                .max_scope_depth = build<MaxCounter<size_t>>("Max Scope", group),
+                                .add_calls = build<SimpleCounter>("Add Calls", group),
+                                .lookup_calls = build<SimpleCounter>("Lookup Calls", group),
+                                .map_lookups = build<SimpleCounter>("Map Lookups", group),
+                                .map_mutations = build<SimpleCounter>("Map Mutations", group)
                         };
                         return ret;
 …
+        }
+        std::ostream & operator<<( std::ostream & out, const Indexer::IdData & data ) {
+                return out << "(" << data.id << "," << data.baseExpr << ")";
+        }
+        typedef std::unordered_map< std::string, Indexer::IdData > MangleTable;
+        typedef std::unordered_map< std::string, MangleTable > IdTable;
+        typedef std::unordered_map< std::string, NamedTypeDecl* > TypeTable;
+        typedef std::unordered_map< std::string, StructDecl* > StructTable;
+        typedef std::unordered_map< std::string, EnumDecl* > EnumTable;
+        typedef std::unordered_map< std::string, UnionDecl* > UnionTable;
+        typedef std::unordered_map< std::string, TraitDecl* > TraitTable;
+        void dump( const IdTable &table, std::ostream &os ) {
+                for ( IdTable::const_iterator id = table.begin(); id != table.end(); ++id ) {
+                        for ( MangleTable::const_iterator mangle = id->second.begin(); mangle != id->second.end(); ++mangle ) {
+                                os << mangle->second << std::endl;
+                        }
+                }
+        }
+        template< typename Decl >
+        void dump( const std::unordered_map< std::string, Decl* > &table, std::ostream &os ) {
+                for ( typename std::unordered_map< std::string, Decl* >::const_iterator it = table.begin(); it != table.end(); ++it ) {
+                        os << it->second << std::endl;
+                } // for
+        }
+        struct Indexer::Impl {
+                Impl( unsigned long _scope ) : refCount(1), scope( _scope ), size( 0 ), base(),
+                                idTable(), typeTable(), structTable(), enumTable(), unionTable(), traitTable() {}
+                Impl( unsigned long _scope, Indexer &&_base ) : refCount(1), scope( _scope ), size( 0 ), base( _base ),
+                                idTable(), typeTable(), structTable(), enumTable(), unionTable(), traitTable() {}
+                unsigned long refCount;   ///< Number of references to these tables
+                unsigned long scope;      ///< Scope these tables are associated with
+                unsigned long size;       ///< Number of elements stored in this table
+                const Indexer base;       ///< Base indexer this extends
+                IdTable idTable;          ///< Identifier namespace
+                TypeTable typeTable;      ///< Type namespace
+                StructTable structTable;  ///< Struct namespace
+                EnumTable enumTable;      ///< Enum namespace
+                UnionTable unionTable;    ///< Union namespace
+                TraitTable traitTable;    ///< Trait namespace
+        };
+        Indexer::Impl *Indexer::newRef( Indexer::Impl *toClone ) {
+                if ( ! toClone ) return 0;
+                // shorten the search chain by skipping empty links
+                Indexer::Impl *ret = toClone->size == 0 ? toClone->base.tables : toClone;
+                if ( ret ) { ++ret->refCount; }
+                return ret;
+        }
+        void Indexer::deleteRef( Indexer::Impl *toFree ) {
+                if ( ! toFree ) return;
+                if ( --toFree->refCount == 0 ) delete toFree;
+        }
+        void Indexer::removeSpecialOverrides( const std::string &id, std::list< IdData > & out ) const {
+                // only need to perform this step for constructors, destructors, and assignment functions
+                if ( ! CodeGen::isCtorDtorAssign( id ) ) return;
+                // helpful data structure to organize properties for a type
+                struct ValueType {
+                        struct DeclBall { // properties for this particular decl
+                                IdData decl;
+                                bool isUserDefinedFunc;
+                                bool isCopyFunc;
+                        };
+                        // properties for this type
+                        bool existsUserDefinedCopyFunc = false;    // user-defined copy ctor found
+                        BaseSyntaxNode * deleteStmt = nullptr;     // non-null if a user-defined function is found
+                        std::list< DeclBall > decls;
+                        // another FunctionDecl for the current type was found - determine
+                        // if it has special properties and update data structure accordingly
+                        ValueType & operator+=( IdData data ) {
+                                DeclarationWithType * function = data.id;
+                                bool isUserDefinedFunc = ! LinkageSpec::isOverridable( function->linkage );
+                                bool isCopyFunc = InitTweak::isCopyFunction( function, function->name );
+                                decls.push_back( DeclBall{ data, isUserDefinedFunc, isCopyFunc } );
+                                existsUserDefinedCopyFunc = existsUserDefinedCopyFunc || (isUserDefinedFunc && isCopyFunc);
+                                if ( isUserDefinedFunc && ! deleteStmt ) {
+                                        // any user-defined function can act as an implicit delete statement for generated constructors.
+                                        // a delete stmt should not act as an implicit delete statement.
+                                        deleteStmt = data.id;
+                                }
+                                return *this;
+                        }
+                }; // ValueType
+                std::list< IdData > copy;
+                copy.splice( copy.end(), out );
+                // organize discovered declarations by type
+                std::unordered_map< std::string, ValueType > funcMap;
+                for ( auto decl : copy ) {
+                        if ( FunctionDecl * function = dynamic_cast< FunctionDecl * >( decl.id ) ) {
+                                std::list< DeclarationWithType * > & params = function->type->parameters;
+                                assert( ! params.empty() );
+                                // use base type of pointer, so that qualifiers on the pointer type aren't considered.
+                                Type * base = InitTweak::getPointerBase( params.front()->get_type() );
+                                assert( base );
+                                funcMap[ Mangler::mangle( base ) ] += decl;
+                        } else {
+                                out.push_back( decl );
+                        }
+                }
+                // if a type contains user defined ctor/dtor/assign, then special rules trigger, which determine
+                // the set of ctor/dtor/assign that can be used  by the requester. In particular, if the user defines
+                // a default ctor, then the generated default ctor is unavailable, likewise for copy ctor
+                // and dtor. If the user defines any ctor/dtor, then no generated field ctors are available.
+                // If the user defines any ctor then the generated default ctor is unavailable (intrinsic default
+                // ctor must be overridden exactly). If the user defines anything that looks like a copy constructor,
+                // then the generated copy constructor is unavailable, and likewise for the assignment operator.
+                for ( std::pair< const std::string, ValueType > & pair : funcMap ) {
+                        ValueType & val = pair.second;
+                        for ( ValueType::DeclBall ball : val.decls ) {
+                                bool isNotUserDefinedFunc = ! ball.isUserDefinedFunc && ball.decl.id->linkage != LinkageSpec::Intrinsic;
+                                bool isCopyFunc = ball.isCopyFunc;
+                                bool existsUserDefinedCopyFunc = val.existsUserDefinedCopyFunc;
+                                // only implicitly delete non-user defined functions that are not intrinsic, and are
+                                // not copy functions (assignment or copy constructor). If a  user-defined copy function exists,
+                                // do not pass along the non-user-defined copy functions since signatures do not have to match,
+                                // and the generated functions will often be cheaper.
+                                if ( isNotUserDefinedFunc ) {
+                                        if ( isCopyFunc ) {
+                                                // Skip over non-user-defined copy functions when there is a user-defined copy function.
+                                                // Since their signatures do not have to be exact, deleting them is the wrong choice.
+                                                if ( existsUserDefinedCopyFunc ) continue;
+                                        } else {
+                                                // delete non-user-defined non-copy functions if applicable.
+                                                // deleteStmt will be non-null only if a user-defined function is found.
+                                                ball.decl.deleteStmt = val.deleteStmt;
+                                        }
+                                }
+                                out.push_back( ball.decl );
+                        }
+                }
+        }
+        void Indexer::makeWritable() {
+                if ( ! tables ) {
+                        // create indexer if not yet set
+                        tables = new Indexer::Impl( scope );
+                } else if ( tables->refCount > 1 || tables->scope != scope ) {
+                        // make this indexer the base of a fresh indexer at the current scope
+                        tables = new Indexer::Impl( scope, std::move( *this ) );
+                }
+        }
+        Indexer::Indexer() : tables( 0 ), scope( 0 ) {
+                (*stats_indexers().count)++;
+        }
+        Indexer::Indexer( const Indexer &that ) : doDebug( that.doDebug ), tables( newRef( that.tables ) ), scope( that.scope ) {
+                (*stats_indexers().count)++;
+        }
+        Indexer::Indexer( Indexer &&that ) : doDebug( that.doDebug ), tables( that.tables ), scope( that.scope ) {
+                that.tables = 0;
+        }
+        Indexer::Indexer()
+        : idTable(), typeTable(), structTable(), enumTable(), unionTable(), traitTable(),
+          prevScope(), scope( 0 ), repScope( 0 ) { ++*stats().count; }
         Indexer::~Indexer() {
+                if(tables) {
+                        stats_indexers().size->push( tables->idTable.size() );
+                        size_t depth = 1;
+                        for( auto crnt = tables->base.tables; crnt; crnt = crnt->base.tables ) {
+                                ++depth;
+                        }
+                        stats_indexers().depth_a->push( depth );
+                        stats_indexers().depth_m->push( depth );
+                }
+                deleteRef( tables );
+        }
+        Indexer& Indexer::operator= ( const Indexer &that ) {
+                deleteRef( tables );
+                tables = newRef( that.tables );
+                scope = that.scope;
+                doDebug = that.doDebug;
+                return *this;
+        }
+        Indexer& Indexer::operator= ( Indexer &&that ) {
+                deleteRef( tables );
+                tables = that.tables;
+                scope = that.scope;
+                doDebug = that.doDebug;
+                that.tables = 0;
+                return *this;
+                stats().size->push( idTable ? idTable->size() : 0 );
+        }
+        void Indexer::lazyInitScope() {
+                if ( repScope < scope ) {
+                        ++*stats().lazy_scopes;
+                        // create rollback
+                        prevScope = std::make_shared<Indexer>( *this );
+                        // update repScope
+                        repScope = scope;
+                }
+        }
+        void Indexer::enterScope() {
+                ++scope;
+                ++*stats().new_scopes;
+                stats().avg_scope_depth->push( scope );
+                stats().max_scope_depth->push( scope );
+        }
+        void Indexer::leaveScope() {
+                if ( repScope == scope ) {
+                        Ptr prev = prevScope;           // make sure prevScope stays live
+                        *this = std::move(*prevScope);  // replace with previous scope
+                }
+                --scope;
+        }
         void Indexer::lookupId( const std::string &id, std::list< IdData > &out ) const {
+                std::unordered_set< std::string > foundMangleNames;
+                Indexer::Impl *searchTables = tables;
+                while ( searchTables ) {
+                        (*stats_idtable().find)++;
+                        stats_idtable().key->push( id.size() );
+                        stats_idtable().size->push( searchTables->idTable.size() );
+                        IdTable::const_iterator decls = searchTables->idTable.find( id );
+                        if ( decls != searchTables->idTable.end() ) {
+                                const MangleTable &mangleTable = decls->second;
+                                for ( MangleTable::const_iterator decl = mangleTable.begin(); decl != mangleTable.end(); ++decl ) {
+                                        // mark the mangled name as found, skipping this insertion if a declaration for that name has already been found
+                                        if ( foundMangleNames.insert( decl->first ).second == false ) continue;
+                                        out.push_back( decl->second );
+                                }
+                        }
+                        // get declarations from base indexers
+                        searchTables = searchTables->base.tables;
+                }
+                // some special functions, e.g. constructors and destructors
+                // remove autogenerated functions when they are defined so that
+                // they can never be matched
+                removeSpecialOverrides( id, out );
+                ++*stats().lookup_calls;
+                if ( ! idTable ) return;
+                ++*stats().map_lookups;
+                auto decls = idTable->find( id );
+                if ( decls == idTable->end() ) return;
+                for ( auto decl : *(decls->second) ) {
+                        out.push_back( decl.second );
+                }
+        }
         NamedTypeDecl *Indexer::lookupType( const std::string &id ) const {
+                if ( ! tables ) return 0;
+                TypeTable::const_iterator ret = tables->typeTable.find( id );
+                return ret != tables->typeTable.end() ? ret->second : tables->base.lookupType( id );
+                ++*stats().lookup_calls;
+                if ( ! typeTable ) return nullptr;
+                ++*stats().map_lookups;
+                auto it = typeTable->find( id );
+                return it == typeTable->end() ? nullptr : it->second.decl;
+        }
         StructDecl *Indexer::lookupStruct( const std::string &id ) const {
+                if ( ! tables ) return 0;
+                StructTable::const_iterator ret = tables->structTable.find( id );
+                return ret != tables->structTable.end() ? ret->second : tables->base.lookupStruct( id );
+                ++*stats().lookup_calls;
+                if ( ! structTable ) return nullptr;
+                ++*stats().map_lookups;
+                auto it = structTable->find( id );
+                return it == structTable->end() ? nullptr : it->second.decl;
+        }
+        EnumDecl *Indexer::lookupEnum( const std::string &id ) const {
+                ++*stats().lookup_calls;
+                if ( ! enumTable ) return nullptr;
+                ++*stats().map_lookups;
+                auto it = enumTable->find( id );
+                return it == enumTable->end() ? nullptr : it->second.decl;
+        }
+        UnionDecl *Indexer::lookupUnion( const std::string &id ) const {
+                ++*stats().lookup_calls;
+                if ( ! unionTable ) return nullptr;
+                ++*stats().map_lookups;
+                auto it = unionTable->find( id );
+                return it == unionTable->end() ? nullptr : it->second.decl;
+        }
+        TraitDecl *Indexer::lookupTrait( const std::string &id ) const {
+                ++*stats().lookup_calls;
+                if ( ! traitTable ) return nullptr;
+                ++*stats().map_lookups;
+                auto it = traitTable->find( id );
+                return it == traitTable->end() ? nullptr : it->second.decl;
+        }
+        const Indexer* Indexer::atScope( unsigned long target ) const {
+                // by lazy construction, final indexer in list has repScope 0, cannot be > target
+                // otherwise, will find first scope representing the target
+                const Indexer* indexer = this;
+                while ( indexer->repScope > target ) {
+                        indexer = indexer->prevScope.get();
+                }
+                return indexer;
+        }
         NamedTypeDecl *Indexer::globalLookupType( const std::string &id ) const {
                 return lookupTypeAtScope( id, 0 );
+                return atScope( 0 )->lookupType( id );
+        }
         StructDecl *Indexer::globalLookupStruct( const std::string &id ) const {
                 return lookupStructAtScope( id, 0 );
+                return atScope( 0 )->lookupStruct( id );
+        }
         UnionDecl *Indexer::globalLookupUnion( const std::string &id ) const {
                 return lookupUnionAtScope( id, 0 );
+                return atScope( 0 )->lookupUnion( id );
+        }
         EnumDecl *Indexer::globalLookupEnum( const std::string &id ) const {
+                return lookupEnumAtScope( id, 0 );
+        }
+        EnumDecl *Indexer::lookupEnum( const std::string &id ) const {
+                if ( ! tables ) return 0;
+                EnumTable::const_iterator ret = tables->enumTable.find( id );
+                return ret != tables->enumTable.end() ? ret->second : tables->base.lookupEnum( id );
+        }
+        UnionDecl *Indexer::lookupUnion( const std::string &id ) const {
+                if ( ! tables ) return 0;
+                UnionTable::const_iterator ret = tables->unionTable.find( id );
+                return ret != tables->unionTable.end() ? ret->second : tables->base.lookupUnion( id );
+        }
+        TraitDecl *Indexer::lookupTrait( const std::string &id ) const {
+                if ( ! tables ) return 0;
+                TraitTable::const_iterator ret = tables->traitTable.find( id );
+                return ret != tables->traitTable.end() ? ret->second : tables->base.lookupTrait( id );
+        }
+        const Indexer::IdData * Indexer::lookupIdAtScope( const std::string &id, const std::string &mangleName, unsigned long scope ) const {
+                if ( ! tables ) return nullptr;
+                if ( tables->scope < scope ) return nullptr;
+                (*stats_idtable().find)++;
+                stats_idtable().key->push( id.size() );
+                stats_idtable().size->push( tables->idTable.size() );
+                IdTable::const_iterator decls = tables->idTable.find( id );
+                if ( decls != tables->idTable.end() ) {
+                        const MangleTable &mangleTable = decls->second;
+                        MangleTable::const_iterator decl = mangleTable.find( mangleName );
+                        if ( decl != mangleTable.end() ) return &decl->second;
+                }
+                return tables->base.lookupIdAtScope( id, mangleName, scope );
+        }
+        Indexer::IdData * Indexer::lookupIdAtScope( const std::string &id, const std::string &mangleName, unsigned long scope ) {
+                return const_cast<IdData *>(const_cast<const Indexer *>(this)->lookupIdAtScope( id, mangleName, scope ));
+        }
+        bool Indexer::hasIncompatibleCDecl( const std::string &id, const std::string &mangleName, unsigned long scope ) const {
+                if ( ! tables ) return false;
+                if ( tables->scope < scope ) return false;
+                (*stats_idtable().find)++;
+                stats_idtable().key->push( id.size() );
+                stats_idtable().size->push( tables->idTable.size() );
+                IdTable::const_iterator decls = tables->idTable.find( id );
+                if ( decls != tables->idTable.end() ) {
+                        const MangleTable &mangleTable = decls->second;
+                        for ( MangleTable::const_iterator decl = mangleTable.begin(); decl != mangleTable.end(); ++decl ) {
+                                // check for C decls with the same name, skipping those with a compatible type (by mangleName)
+                                if ( ! LinkageSpec::isMangled( decl->second.id->get_linkage() ) && decl->first != mangleName ) return true;
+                        }
+                }
+                return tables->base.hasIncompatibleCDecl( id, mangleName, scope );
+        }
+        bool Indexer::hasCompatibleCDecl( const std::string &id, const std::string &mangleName, unsigned long scope ) const {
+                if ( ! tables ) return false;
+                if ( tables->scope < scope ) return false;
+                (*stats_idtable().find)++;
+                stats_idtable().key->push( id.size() );
+                stats_idtable().size->push( tables->idTable.size() );
+                IdTable::const_iterator decls = tables->idTable.find( id );
+                if ( decls != tables->idTable.end() ) {
+                        const MangleTable &mangleTable = decls->second;
+                        for ( MangleTable::const_iterator decl = mangleTable.begin(); decl != mangleTable.end(); ++decl ) {
+                                // check for C decls with the same name, skipping
+                                // those with an incompatible type (by mangleName)
+                                if ( ! LinkageSpec::isMangled( decl->second.id->get_linkage() ) && decl->first == mangleName ) return true;
+                        }
+                }
+                return tables->base.hasCompatibleCDecl( id, mangleName, scope );
+        }
+        NamedTypeDecl *Indexer::lookupTypeAtScope( const std::string &id, unsigned long scope ) const {
+                if ( ! tables ) return 0;
+                if ( tables->scope < scope ) return 0;
+                if ( tables->scope > scope ) return tables->base.lookupTypeAtScope( id, scope );
+                TypeTable::const_iterator ret = tables->typeTable.find( id );
+                return ret != tables->typeTable.end() ? ret->second : tables->base.lookupTypeAtScope( id, scope );
+        }
+        StructDecl *Indexer::lookupStructAtScope( const std::string &id, unsigned long scope ) const {
+                if ( ! tables ) return 0;
+                if ( tables->scope < scope ) return 0;
+                if ( tables->scope > scope ) return tables->base.lookupStructAtScope( id, scope );
+                StructTable::const_iterator ret = tables->structTable.find( id );
+                return ret != tables->structTable.end() ? ret->second : tables->base.lookupStructAtScope( id, scope );
+        }
+        EnumDecl *Indexer::lookupEnumAtScope( const std::string &id, unsigned long scope ) const {
+                if ( ! tables ) return 0;
+                if ( tables->scope < scope ) return 0;
+                if ( tables->scope > scope ) return tables->base.lookupEnumAtScope( id, scope );
+                EnumTable::const_iterator ret = tables->enumTable.find( id );
+                return ret != tables->enumTable.end() ? ret->second : tables->base.lookupEnumAtScope( id, scope );
+        }
+        UnionDecl *Indexer::lookupUnionAtScope( const std::string &id, unsigned long scope ) const {
+                if ( ! tables ) return 0;
+                if ( tables->scope < scope ) return 0;
+                if ( tables->scope > scope ) return tables->base.lookupUnionAtScope( id, scope );
+                UnionTable::const_iterator ret = tables->unionTable.find( id );
+                return ret != tables->unionTable.end() ? ret->second : tables->base.lookupUnionAtScope( id, scope );
+        }
+        TraitDecl *Indexer::lookupTraitAtScope( const std::string &id, unsigned long scope ) const {
+                if ( ! tables ) return 0;
+                if ( tables->scope < scope ) return 0;
+                if ( tables->scope > scope ) return tables->base.lookupTraitAtScope( id, scope );
+                TraitTable::const_iterator ret = tables->traitTable.find( id );
+                return ret != tables->traitTable.end() ? ret->second : tables->base.lookupTraitAtScope( id, scope );
+                return atScope( 0 )->lookupEnum( id );
+        }
 …
+        }
+        bool addedIdConflicts( Indexer::IdData & existing, DeclarationWithType *added, BaseSyntaxNode * deleteStmt, Indexer::ConflictFunction handleConflicts ) {
+                // if we're giving the same name mangling to things of different types then there is something wrong
+        bool Indexer::addedIdConflicts(
+                        const Indexer::IdData & existing, DeclarationWithType *added,
+                        Indexer::OnConflict handleConflicts, BaseSyntaxNode * deleteStmt ) {
+                // if we're giving the same name mangling to things of different types then there is
+                // something wrong
                 assert( (isObject( added ) && isObject( existing.id ) )
                         || ( isFunction( added ) && isFunction( existing.id ) ) );
                 if ( LinkageSpec::isOverridable( existing.id->get_linkage() ) ) {
+                if ( LinkageSpec::isOverridable( existing.id->linkage ) ) {
                         // new definition shadows the autogenerated one, even at the same scope
                         return false;
+                } else if ( LinkageSpec::isMangled( added->get_linkage() ) || ResolvExpr::typesCompatible( added->get_type(), existing.id->get_type(), Indexer() ) ) {
+                } else if ( LinkageSpec::isMangled( added->linkage )
+                                || ResolvExpr::typesCompatible(
+                                        added->get_type(), existing.id->get_type(), Indexer() ) ) {
                         // it is a conflict if one declaration is deleted and the other is not
                         if ( deleteStmt && ! existing.deleteStmt ) {
+                                return handleConflicts( existing, "deletion of defined identifier " );
+                                if ( handleConflicts.mode == OnConflict::Error ) {
+                                        SemanticError( added, "deletion of defined identifier " );
+                                }
+                                return true;
                         } else if ( ! deleteStmt && existing.deleteStmt ) {
+                                return handleConflicts( existing, "definition of deleted identifier " );
+                                if ( handleConflicts.mode == OnConflict::Error ) {
+                                        SemanticError( added, "definition of deleted identifier " );
+                                }
+                                return true;
+                        }
                         if ( isDefinition( added ) && isDefinition( existing.id ) ) {
+                                if ( isFunction( added ) ) {
+                                        return handleConflicts( existing, "duplicate function definition for " );
+                                if ( handleConflicts.mode == OnConflict::Error ) {
+                                        SemanticError( added,
+                                                isFunction( added ) ?
+                                                        "duplicate function definition for " :
+                                                        "duplicate object definition for " );
+                                }
+                                return true;
+                        } // if
+                } else {
+                        if ( handleConflicts.mode == OnConflict::Error ) {
+                                SemanticError( added, "duplicate definition for " );
+                        }
+                        return true;
+                } // if
+                return true;
+        }
+        bool Indexer::hasCompatibleCDecl( const std::string &id, const std::string &mangleName ) const {
+                if ( ! idTable ) return false;
+                ++*stats().map_lookups;
+                auto decls = idTable->find( id );
+                if ( decls == idTable->end() ) return false;
+                for ( auto decl : *(decls->second) ) {
+                        // skip other scopes (hidden by this decl)
+                        if ( decl.second.scope != scope ) continue;
+                        // check for C decl with compatible type (by mangleName)
+                        if ( ! LinkageSpec::isMangled( decl.second.id->linkage ) && decl.first == mangleName ) {
+                                return true;
+                        }
+                }
+                return false;
+        }
+        bool Indexer::hasIncompatibleCDecl(
+                        const std::string &id, const std::string &mangleName ) const {
+                if ( ! idTable ) return false;
+                ++*stats().map_lookups;
+                auto decls = idTable->find( id );
+                if ( decls == idTable->end() ) return false;
+                for ( auto decl : *(decls->second) ) {
+                        // skip other scopes (hidden by this decl)
+                        if ( decl.second.scope != scope ) continue;
+                        // check for C decl with incompatible type (by manglename)
+                        if ( ! LinkageSpec::isMangled( decl.second.id->linkage ) && decl.first != mangleName ) {
+                                return true;
+                        }
+                }
+                return false;
+        }
+        /// gets the base type of the first parameter; decl must be a ctor/dtor/assignment function
+        std::string getOtypeKey( FunctionDecl* function ) {
+                auto& params = function->type->parameters;
+                assert( ! params.empty() );
+                // use base type of pointer, so that qualifiers on the pointer type aren't considered.
+                Type* base = InitTweak::getPointerBase( params.front()->get_type() );
+                assert( base );
+                return Mangler::mangle( base );
+        }
+        /// gets the declaration for the function acting on a type specified by otype key,
+        /// nullptr if none such
+        FunctionDecl * getFunctionForOtype( DeclarationWithType * decl, const std::string& otypeKey ) {
+                FunctionDecl * func = dynamic_cast< FunctionDecl * >( decl );
+                if ( ! func || otypeKey != getOtypeKey( func ) ) return nullptr;
+                return func;
+        }
+        bool Indexer::removeSpecialOverrides(
+                        Indexer::IdData& data, Indexer::MangleTable::Ptr& mangleTable ) {
+                // if a type contains user defined ctor/dtor/assign, then special rules trigger, which
+                // determinethe set of ctor/dtor/assign that can be used  by the requester. In particular,
+                // if the user defines a default ctor, then the generated default ctor is unavailable,
+                // likewise for copy ctor and dtor. If the user defines any ctor/dtor, then no generated
+                // field ctors are available. If the user defines any ctor then the generated default ctor
+                // is unavailable (intrinsic default ctor must be overridden exactly). If the user defines
+                // anything that looks like a copy constructor, then the generated copy constructor is
+                // unavailable, and likewise for the assignment operator.
+                // only relevant on function declarations
+                FunctionDecl * function = dynamic_cast< FunctionDecl * >( data.id );
+                if ( ! function ) return true;
+                // only need to perform this check for constructors, destructors, and assignment functions
+                if ( ! CodeGen::isCtorDtorAssign( data.id->name ) ) return true;
+                // set up information for this type
+                bool dataIsUserDefinedFunc = ! LinkageSpec::isOverridable( function->linkage );
+                bool dataIsCopyFunc = InitTweak::isCopyFunction( function, function->name );
+                std::string dataOtypeKey = getOtypeKey( function );
+                if ( dataIsUserDefinedFunc && dataIsCopyFunc ) {
+                        // this is a user-defined copy function
+                        // if this is the first such, delete/remove non-user-defined overloads as needed
+                        std::vector< std::string > removed;
+                        std::vector< MangleTable::value_type > deleted;
+                        bool alreadyUserDefinedFunc = false;
+                        for ( const auto& entry : *mangleTable ) {
+                                // skip decls that aren't functions or are for the wrong type
+                                FunctionDecl * decl = getFunctionForOtype( entry.second.id, dataOtypeKey );
+                                if ( ! decl ) continue;
+                                bool isCopyFunc = InitTweak::isCopyFunction( decl, decl->name );
+                                if ( ! LinkageSpec::isOverridable( decl->linkage ) ) {
+                                        // matching user-defined function
+                                        if ( isCopyFunc ) {
+                                                // mutation already performed, return early
+                                                return true;
+                                        } else {
+                                                // note that non-copy deletions already performed
+                                                alreadyUserDefinedFunc = true;
+                                        }
                                 } else {
+                                        return handleConflicts( existing, "duplicate object definition for " );
+                                } // if
+                        } // if
+                } else {
+                        return handleConflicts( existing, "duplicate definition for " );
+                } // if
+                                        // non-user-defined function; mark for deletion/removal as appropriate
+                                        if ( isCopyFunc ) {
+                                                removed.push_back( entry.first );
+                                        } else if ( ! alreadyUserDefinedFunc ) {
+                                                deleted.push_back( entry );
+                                        }
+                                }
+                        }
+                        // perform removals from mangle table, and deletions if necessary
+                        for ( const auto& key : removed ) {
+                                ++*stats().map_mutations;
+                                mangleTable = mangleTable->erase( key );
+                        }
+                        if ( ! alreadyUserDefinedFunc ) for ( const auto& entry : deleted ) {
+                                ++*stats().map_mutations;
+                                mangleTable = mangleTable->set( entry.first, IdData{ entry.second, function } );
+                        }
+                } else if ( dataIsUserDefinedFunc ) {
+                        // this is a user-defined non-copy function
+                        // if this is the first user-defined function, delete non-user-defined overloads
+                        std::vector< MangleTable::value_type > deleted;
+                        for ( const auto& entry : *mangleTable ) {
+                                // skip decls that aren't functions or are for the wrong type
+                                FunctionDecl * decl = getFunctionForOtype( entry.second.id, dataOtypeKey );
+                                if ( ! decl ) continue;
+                                // exit early if already a matching user-defined function;
+                                // earlier function will have mutated table
+                                if ( ! LinkageSpec::isOverridable( decl->linkage ) ) return true;
+                                // skip mutating intrinsic functions
+                                if ( decl->linkage == LinkageSpec::Intrinsic ) continue;
+                                // user-defined non-copy functions do not override copy functions
+                                if ( InitTweak::isCopyFunction( decl, decl->name ) ) continue;
+                                // this function to be deleted after mangleTable iteration is complete
+                                deleted.push_back( entry );
+                        }
+                        // mark deletions to update mangle table
+                        // this needs to be a separate loop because of iterator invalidation
+                        for ( const auto& entry : deleted ) {
+                                ++*stats().map_mutations;
+                                mangleTable = mangleTable->set( entry.first, IdData{ entry.second, function } );
+                        }
+                } else if ( function->linkage != LinkageSpec::Intrinsic ) {
+                        // this is an overridable generated function
+                        // if there already exists a matching user-defined function, delete this appropriately
+                        for ( const auto& entry : *mangleTable ) {
+                                // skip decls that aren't functions or are for the wrong type
+                                FunctionDecl * decl = getFunctionForOtype( entry.second.id, dataOtypeKey );
+                                if ( ! decl ) continue;
+                                // skip non-user-defined functions
+                                if ( LinkageSpec::isOverridable( decl->linkage ) ) continue;
+                                if ( dataIsCopyFunc ) {
+                                        // remove current function if exists a user-defined copy function
+                                        // since the signatures for copy functions don't need to match exactly, using
+                                        // a delete statement is the wrong approach
+                                        if ( InitTweak::isCopyFunction( decl, decl->name ) ) return false;
+                                } else {
+                                        // mark current function deleted by first user-defined function found
+                                        data.deleteStmt = decl;
+                                        return true;
+                                }
+                        }
+                }
+                // nothing (more) to fix, return true
                 return true;
+        }
+        void Indexer::addId( DeclarationWithType *decl, ConflictFunction handleConflicts, Expression * baseExpr, BaseSyntaxNode * deleteStmt ) {
+                if ( decl->name == "" ) return;
+                debugPrint( "Adding Id " << decl->name << std::endl );
+                makeWritable();
+        void Indexer::addId(
+                        DeclarationWithType *decl, OnConflict handleConflicts, Expression * baseExpr,
+                        BaseSyntaxNode * deleteStmt ) {
+                ++*stats().add_calls;
                 const std::string &name = decl->name;
+                if ( name == "" ) return;
                 std::string mangleName;
                 if ( LinkageSpec::isOverridable( decl->linkage ) ) {
                         // mangle the name without including the appropriate suffix, so overridable routines are placed into the
                         // same "bucket" as their user defined versions.
+                        // mangle the name without including the appropriate suffix, so overridable routines
+                        // are placed into the same "bucket" as their user defined versions.
                         mangleName = Mangler::mangle( decl, false );
                 } else {
 …
                 } // if
+                // this ensures that no two declarations with the same unmangled name at the same scope both have C linkage
+                if ( ! LinkageSpec::isMangled( decl->linkage ) ) {
+                        // NOTE this is broken in Richard's original code in such a way that it never triggers (it
+                        // doesn't check decls that have the same manglename, and all C-linkage decls are defined to
+                        // have their name as their manglename, hence the error can never trigger).
+                        // The code here is closer to correct, but name mangling would have to be completely
+                        // isomorphic to C type-compatibility, which it may not be.
+                        if ( hasIncompatibleCDecl( name, mangleName, scope ) ) {
+                // this ensures that no two declarations with the same unmangled name at the same scope
+                // both have C linkage
+                if ( LinkageSpec::isMangled( decl->linkage ) ) {
+                        // Check that a Cforall declaration doesn't override any C declaration
+                        if ( hasCompatibleCDecl( name, mangleName ) ) {
+                                SemanticError( decl, "Cforall declaration hides C function " );
+                        }
+                } else {
+                        // NOTE: only correct if name mangling is completely isomorphic to C
+                        // type-compatibility, which it may not be.
+                        if ( hasIncompatibleCDecl( name, mangleName ) ) {
                                 SemanticError( decl, "conflicting overload of C function " );
+                        }
+                } else {
+                        // Check that a Cforall declaration doesn't override any C declaration
+                        if ( hasCompatibleCDecl( name, mangleName, scope ) ) {
+                                SemanticError( decl, "Cforall declaration hides C function " );
+                        }
+                }
+                // Skip repeat declarations of the same identifier
+                IdData * existing = lookupIdAtScope( name, mangleName, scope );
+                if ( existing && existing->id && addedIdConflicts( *existing, decl, deleteStmt, handleConflicts ) ) return;
+                // add to indexer
+                tables->idTable[ name ][ mangleName ] = IdData{ decl, baseExpr, deleteStmt };
+                ++tables->size;
+                }
+                // ensure tables exist and add identifier
+                MangleTable::Ptr mangleTable;
+                if ( ! idTable ) {
+                        idTable = IdTable::new_ptr();
+                        mangleTable = MangleTable::new_ptr();
+                } else {
+                        ++*stats().map_lookups;
+                        auto decls = idTable->find( name );
+                        if ( decls == idTable->end() ) {
+                                mangleTable = MangleTable::new_ptr();
+                        } else {
+                                mangleTable = decls->second;
+                                // skip in-scope repeat declarations of same identifier
+                                ++*stats().map_lookups;
+                                auto existing = mangleTable->find( mangleName );
+                                if ( existing != mangleTable->end()
+                                                && existing->second.scope == scope
+                                                && existing->second.id ) {
+                                        if ( addedIdConflicts( existing->second, decl, handleConflicts, deleteStmt ) ) {
+                                                if ( handleConflicts.mode == OnConflict::Delete ) {
+                                                        // set delete expression for conflicting identifier
+                                                        lazyInitScope();
+                                                        *stats().map_mutations += 2;
+                                                        idTable = idTable->set(
+                                                                name,
+                                                                mangleTable->set(
+                                                                        mangleName,
+                                                                        IdData{ existing->second, handleConflicts.deleteStmt } ) );
+                                                }
+                                                return;
+                                        }
+                                }
+                        }
+                }
+                // add/overwrite with new identifier
+                lazyInitScope();
+                IdData data{ decl, baseExpr, deleteStmt, scope };
+                // Ensure that auto-generated ctor/dtor/assignment are deleted if necessary
+                if ( ! removeSpecialOverrides( data, mangleTable ) ) return;
+                *stats().map_mutations += 2;
+                idTable = idTable->set( name, mangleTable->set( mangleName, std::move(data) ) );
+        }
         void Indexer::addId( DeclarationWithType * decl, Expression * baseExpr ) {
                 // default handling of conflicts is to raise an error
                 addId( decl, [decl](IdData &, const std::string & msg) { SemanticError( decl, msg ); return true; }, baseExpr, decl->isDeleted ? decl : nullptr );
+                addId( decl, OnConflict::error(), baseExpr, decl->isDeleted ? decl : nullptr );
+        }
         void Indexer::addDeletedId( DeclarationWithType * decl, BaseSyntaxNode * deleteStmt ) {
                 // default handling of conflicts is to raise an error
                 addId( decl, [decl](IdData &, const std::string & msg) { SemanticError( decl, msg ); return true; }, nullptr, deleteStmt );
+                addId( decl, OnConflict::error(), nullptr, deleteStmt );
+        }
 …
+                        }
+                }
+                // does not need to be added to the table if both existing and added have a base that are the same
+                // does not need to be added to the table if both existing and added have a base that are
+                // the same
                 return true;
+        }
         void Indexer::addType( NamedTypeDecl *decl ) {
+                debugPrint( "Adding type " << decl->name << std::endl );
+                makeWritable();
+                ++*stats().add_calls;
                 const std::string &id = decl->name;
+                TypeTable::iterator existing = tables->typeTable.find( id );
+                if ( existing == tables->typeTable.end() ) {
+                        NamedTypeDecl *parent = tables->base.lookupTypeAtScope( id, scope );
+                        if ( ! parent || ! addedTypeConflicts( parent, decl ) ) {
+                                tables->typeTable.insert( existing, std::make_pair( id, decl ) );
+                                ++tables->size;
+                        }
+                } else {
+                        if ( ! addedTypeConflicts( existing->second, decl ) ) {
+                                existing->second = decl;
+                        }
+                }
+                if ( ! typeTable ) {
+                        typeTable = TypeTable::new_ptr();
+                } else {
+                        ++*stats().map_lookups;
+                        auto existing = typeTable->find( id );
+                        if ( existing != typeTable->end()
+                                && existing->second.scope == scope
+                                && addedTypeConflicts( existing->second.decl, decl ) ) return;
+                }
+                lazyInitScope();
+                ++*stats().map_mutations;
+                typeTable = typeTable->set( id, Scoped<NamedTypeDecl>{ decl, scope } );
+        }
 …
         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();
+                ++*stats().add_calls;
                 const std::string &id = decl->name;
+                StructTable::iterator existing = tables->structTable.find( id );
+                if ( existing == tables->structTable.end() ) {
+                        StructDecl *parent = tables->base.lookupStructAtScope( id, scope );
+                        if ( ! parent || ! addedDeclConflicts( parent, decl ) ) {
+                                tables->structTable.insert( existing, std::make_pair( id, decl ) );
+                                ++tables->size;
+                        }
+                } else {
+                        if ( ! addedDeclConflicts( existing->second, decl ) ) {
+                                existing->second = decl;
+                        }
+                }
+                if ( ! structTable ) {
+                        structTable = StructTable::new_ptr();
+                } else {
+                        ++*stats().map_lookups;
+                        auto existing = structTable->find( id );
+                        if ( existing != structTable->end()
+                                && existing->second.scope == scope
+                                && addedDeclConflicts( existing->second.decl, decl ) ) return;
+                }
+                lazyInitScope();
+                ++*stats().map_mutations;
+                structTable = structTable->set( id, Scoped<StructDecl>{ decl, scope } );
+        }
         void Indexer::addEnum( EnumDecl *decl ) {
+                debugPrint( "Adding enum " << decl->name << std::endl );
+                makeWritable();
+                ++*stats().add_calls;
                 const std::string &id = decl->name;
+                EnumTable::iterator existing = tables->enumTable.find( id );
+                if ( existing == tables->enumTable.end() ) {
+                        EnumDecl *parent = tables->base.lookupEnumAtScope( id, scope );
+                        if ( ! parent || ! addedDeclConflicts( parent, decl ) ) {
+                                tables->enumTable.insert( existing, std::make_pair( id, decl ) );
+                                ++tables->size;
+                        }
+                } else {
+                        if ( ! addedDeclConflicts( existing->second, decl ) ) {
+                                existing->second = decl;
+                        }
+                }
+                if ( ! enumTable ) {
+                        enumTable = EnumTable::new_ptr();
+                } else {
+                        ++*stats().map_lookups;
+                        auto existing = enumTable->find( id );
+                        if ( existing != enumTable->end()
+                                && existing->second.scope == scope
+                                && addedDeclConflicts( existing->second.decl, decl ) ) return;
+                }
+                lazyInitScope();
+                ++*stats().map_mutations;
+                enumTable = enumTable->set( id, Scoped<EnumDecl>{ decl, scope } );
+        }
         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();
+                ++*stats().add_calls;
                 const std::string &id = decl->name;
+                UnionTable::iterator existing = tables->unionTable.find( id );
+                if ( existing == tables->unionTable.end() ) {
+                        UnionDecl *parent = tables->base.lookupUnionAtScope( id, scope );
+                        if ( ! parent || ! addedDeclConflicts( parent, decl ) ) {
+                                tables->unionTable.insert( existing, std::make_pair( id, decl ) );
+                                ++tables->size;
+                        }
+                } else {
+                        if ( ! addedDeclConflicts( existing->second, decl ) ) {
+                                existing->second = decl;
+                        }
+                }
+                if ( ! unionTable ) {
+                        unionTable = UnionTable::new_ptr();
+                } else {
+                        ++*stats().map_lookups;
+                        auto existing = unionTable->find( id );
+                        if ( existing != unionTable->end()
+                                && existing->second.scope == scope
+                                && addedDeclConflicts( existing->second.decl, decl ) ) return;
+                }
+                lazyInitScope();
+                ++*stats().map_mutations;
+                unionTable = unionTable->set( id, Scoped<UnionDecl>{ decl, scope } );
+        }
         void Indexer::addTrait( TraitDecl *decl ) {
+                debugPrint( "Adding trait " << decl->name << std::endl );
+                makeWritable();
+                ++*stats().add_calls;
                 const std::string &id = decl->name;
+                TraitTable::iterator existing = tables->traitTable.find( id );
+                if ( existing == tables->traitTable.end() ) {
+                        TraitDecl *parent = tables->base.lookupTraitAtScope( id, scope );
+                        if ( ! parent || ! addedDeclConflicts( parent, decl ) ) {
+                                tables->traitTable.insert( existing, std::make_pair( id, decl ) );
+                                ++tables->size;
+                        }
+                } else {
+                        if ( ! addedDeclConflicts( existing->second, decl ) ) {
+                                existing->second = decl;
+                        }
+                }
+        }
+        void Indexer::addMembers( AggregateDecl * aggr, Expression * expr, ConflictFunction handleConflicts ) {
+                if ( ! traitTable ) {
+                        traitTable = TraitTable::new_ptr();
+                } else {
+                        ++*stats().map_lookups;
+                        auto existing = traitTable->find( id );
+                        if ( existing != traitTable->end()
+                                && existing->second.scope == scope
+                                && addedDeclConflicts( existing->second.decl, decl ) ) return;
+                }
+                lazyInitScope();
+                ++*stats().map_mutations;
+                traitTable = traitTable->set( id, Scoped<TraitDecl>{ decl, scope } );
+        }
+        void Indexer::addMembers( AggregateDecl * aggr, Expression * expr,
+                        OnConflict handleConflicts ) {
                 for ( Declaration * decl : aggr->members ) {
                         if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
 …
                                 if ( dwt->name == "" ) {
                                         Type * t = dwt->get_type()->stripReferences();
                                         if ( dynamic_cast< StructInstType * >( t ) || dynamic_cast< UnionInstType * >( t ) ) {
+                                        if ( dynamic_cast<StructInstType*>( t ) || dynamic_cast<UnionInstType*>( t ) ) {
                                                 Expression * base = expr->clone();
                                                 ResolvExpr::Cost cost = ResolvExpr::Cost::zero; // xxx - carry this cost into the indexer as a base cost?
 …
                                 assertf( aggr, "WithStmt expr has non-aggregate type: %s", toString( expr->result ).c_str() );
+                                addMembers( aggr, expr, [withStmt](IdData & existing, const std::string &) {
+                                        // on conflict, delete the identifier
+                                        existing.deleteStmt = withStmt;
+                                        return true;
+                                });
+                                addMembers( aggr, expr, OnConflict::deleteWith( withStmt ) );
+                        }
+                }
 …
                 addIds( ftype->returnVals );
                 addIds( ftype->parameters );
+        }
-        void Indexer::enterScope() {
-                ++scope;
-                if ( doDebug ) {
-                        std::cerr << "--- Entering scope " << scope << std::endl;
+                }
+        }
-        void Indexer::leaveScope() {
-                using std::cerr;
-                assert( scope > 0 && "cannot leave initial scope" );
-                if ( doDebug ) {
-                        cerr << "--- Leaving scope " << scope << " containing" << std::endl;
+                }
-                --scope;
-                while ( tables && tables->scope > scope ) {
-                        if ( doDebug ) {
-                                dump( tables->idTable, cerr );
-                                dump( tables->typeTable, cerr );
-                                dump( tables->structTable, cerr );
-                                dump( tables->enumTable, cerr );
-                                dump( tables->unionTable, cerr );
-                                dump( tables->traitTable, cerr );
+                        }
-                        // swap tables for base table until we find one at an appropriate scope
-                        Indexer::Impl *base = newRef( tables->base.tables );
-                        deleteRef( tables );
-                        tables = base;
+                }
+        }
-        void Indexer::print( std::ostream &os, int indent ) const {
-                using std::cerr;
-                if ( tables ) {
-                        os << "--- scope " << tables->scope << " ---" << std::endl;
-                        os << "===idTable===" << std::endl;
-                        dump( tables->idTable, os );
-                        os << "===typeTable===" << std::endl;
-                        dump( tables->typeTable, os );
-                        os << "===structTable===" << std::endl;
-                        dump( tables->structTable, os );
-                        os << "===enumTable===" << std::endl;
-                        dump( tables->enumTable, os );
-                        os << "===unionTable===" << std::endl;
-                        dump( tables->unionTable, os );
-                        os << "===contextTable===" << std::endl;
-                        dump( tables->traitTable, os );
-                        tables->base.print( os, indent );
-                } else {
-                        os << "--- end ---" << std::endl;
+                }
+        }

src/SymTab/Indexer.h

-                      rf845e80
+                      r98b4b12
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:38:55 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Aug 17 16:09:12 2017
 // Update Count     : 8
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Fri Mar  8 13:55:00 2019
+// Update Count     : 9
 //
 #pragma once
 #include <iosfwd>             // for ostream
 #include <list>               // for list
 #include <string>             // for string
 #include <functional>         // for function
+#include <functional>              // for function
+#include <list>                    // for list
+#include <memory>                  // for shared_ptr, enable_shared_from_this
+#include <string>                  // for string
 #include "SynTree/Visitor.h"  // for Visitor
 #include "SynTree/SynTree.h"  // for AST nodes
+#include "Common/PersistentMap.h"  // for PersistentMap
+#include "SynTree/SynTree.h"       // for AST nodes
 namespace ResolvExpr {
 class Cost;
+        class Cost;
+}
 namespace SymTab {
         class Indexer {
           public:
+        class Indexer : public std::enable_shared_from_this<SymTab::Indexer> {
+        public:
                 explicit Indexer();
+                virtual ~Indexer();
+                Indexer( const Indexer &that );
+                Indexer( Indexer &&that );
+                virtual ~Indexer();
+                Indexer& operator= ( const Indexer &that );
+                Indexer& operator= ( Indexer &&that );
+                // when using an indexer manually (e.g., within a mutator traversal), it is necessary to tell the indexer
+                // explicitly when scopes begin and end
+                // when using an indexer manually (e.g., within a mutator traversal), it is necessary to
+                // tell the indexer explicitly when scopes begin and end
                 void enterScope();
                 void leaveScope();
 …
                         /// non-null if this declaration is deleted
                         BaseSyntaxNode * deleteStmt = nullptr;
+                        /// scope of identifier
+                        unsigned long scope = 0;
                         // NOTE: shouldn't need either of these constructors, but gcc-4 does not properly support initializer lists with default members.
                         IdData() = default;
+                        IdData( DeclarationWithType * id, Expression * baseExpr, BaseSyntaxNode * deleteStmt ) : id( id ), baseExpr( baseExpr ), deleteStmt( deleteStmt ) {}
+                        IdData(
+                                DeclarationWithType * id, Expression * baseExpr, BaseSyntaxNode * deleteStmt,
+                                unsigned long scope )
+                                : id( id ), baseExpr( baseExpr ), deleteStmt( deleteStmt ), scope( scope ) {}
+                        IdData( const IdData& o, BaseSyntaxNode * deleteStmt )
+                                : id( o.id ), baseExpr( o.baseExpr ), deleteStmt( deleteStmt ), scope( o.scope ) {}
                         Expression * combine( ResolvExpr::Cost & cost ) const;
 …
                 EnumDecl *globalLookupEnum( const std::string &id ) const;
-                void print( std::ostream &os, int indent = 0 ) const;
-                /// looks up a specific mangled ID at the given scope
-                IdData * lookupIdAtScope( const std::string &id, const std::string &mangleName, unsigned long scope );
-                const IdData * lookupIdAtScope( const std::string &id, const std::string &mangleName, unsigned long scope ) const;
-                /// returns true if there exists a declaration with C linkage and the given name with a different mangled name
-                bool hasIncompatibleCDecl( const std::string &id, const std::string &mangleName, unsigned long scope ) const;
-                /// returns true if there exists a declaration with C linkage and the given name with the same mangled name
-                bool hasCompatibleCDecl( const std::string &id, const std::string &mangleName, unsigned long scope ) const;
-                // equivalents to lookup functions that only look at tables at scope `scope` (which should be >= tables->scope)
-                NamedTypeDecl *lookupTypeAtScope( const std::string &id, unsigned long scope ) const;
-                StructDecl *lookupStructAtScope( const std::string &id, unsigned long scope ) const;
-                EnumDecl *lookupEnumAtScope( const std::string &id, unsigned long scope ) const;
-                UnionDecl *lookupUnionAtScope( const std::string &id, unsigned long scope ) const;
-                TraitDecl *lookupTraitAtScope( const std::string &id, unsigned long scope ) const;
-                typedef std::function<bool(IdData &, const std::string &)> ConflictFunction;
                 void addId( DeclarationWithType * decl, Expression * baseExpr = nullptr );
                 void addDeletedId( DeclarationWithType * decl, BaseSyntaxNode * deleteStmt );
 …
                 void addWith( std::list< Expression * > & withExprs, BaseSyntaxNode * withStmt );
-                /// adds all of the members of the Aggregate (addWith helper)
-                void addMembers( AggregateDecl * aggr, Expression * expr, ConflictFunction );
                 /// convenience function for adding a list of Ids to the indexer
                 void addIds( const std::list< DeclarationWithType * > & decls );
 …
                 void addFunctionType( FunctionType * ftype );
-                bool doDebug = false; ///< Display debugging trace?
           private:
+                struct Impl;
+                /// Wraps a Decl* with a scope
+                template<typename Decl>
+                struct Scoped {
+                        Decl* decl;           ///< declaration
+                        unsigned long scope;  ///< scope of this declaration
                 Impl *tables;         ///< Copy-on-write instance of table data structure
                 unsigned long scope;  ///< Scope index of this pointer
+                        Scoped(Decl* d, unsigned long s) : decl(d), scope(s) {}
+                };
+                /// Takes a new ref to a table (returns null if null)
+                static Impl *newRef( Impl *toClone );
+                /// Clears a ref to a table (does nothing if null)
+                static void deleteRef( Impl *toFree );
+                using Ptr = std::shared_ptr<const Indexer>;
+                // Removes matching autogenerated constructors and destructors
+                // so that they will not be selected
+                // void removeSpecialOverrides( FunctionDecl *decl );
+                void removeSpecialOverrides( const std::string &id, std::list< IdData > & out ) const;
+                using MangleTable = PersistentMap< std::string, IdData >;
+                using IdTable = PersistentMap< std::string, MangleTable::Ptr >;
+                using TypeTable = PersistentMap< std::string, Scoped<NamedTypeDecl> >;
+                using StructTable = PersistentMap< std::string, Scoped<StructDecl> >;
+                using EnumTable = PersistentMap< std::string, Scoped<EnumDecl> >;
+                using UnionTable = PersistentMap< std::string, Scoped<UnionDecl> >;
+                using TraitTable = PersistentMap< std::string, Scoped<TraitDecl> >;
+                /// Ensures that tables variable is writable (i.e. allocated, uniquely owned by this Indexer, and at the current scope)
+                void makeWritable();
+                IdTable::Ptr idTable;          ///< identifier namespace
+                TypeTable::Ptr typeTable;      ///< type namespace
+                StructTable::Ptr structTable;  ///< struct namespace
+                EnumTable::Ptr enumTable;      ///< enum namespace
+                UnionTable::Ptr unionTable;    ///< union namespace
+                TraitTable::Ptr traitTable;    ///< trait namespace
+                Ptr prevScope;                 ///< reference to indexer for parent scope
+                unsigned long scope;           ///< Scope index of this indexer
+                unsigned long repScope;        ///< Scope index of currently represented scope
+                /// Ensures that a proper backtracking scope exists before a mutation
+                void lazyInitScope();
+                /// Gets the indexer at the given scope
+                const Indexer* atScope( unsigned long scope ) const;
+                /// Removes matching autogenerated constructors and destructors so that they will not be
+                /// selected. If returns false, passed decl should not be added.
+                bool removeSpecialOverrides( IdData& decl, MangleTable::Ptr& mangleTable );
+                /// Options for handling identifier conflicts
+                struct OnConflict {
+                        enum {
+                                Error,  ///< Throw a semantic error
+                                Delete  ///< Delete the earlier version with the delete statement
+                        } mode;
+                        BaseSyntaxNode * deleteStmt;  ///< Statement that deletes this expression
+                private:
+                        OnConflict() : mode(Error), deleteStmt(nullptr) {}
+                        OnConflict( BaseSyntaxNode * d ) : mode(Delete), deleteStmt(d) {}
+                public:
+                        OnConflict( const OnConflict& ) = default;
+                        static OnConflict error() { return {}; }
+                        static OnConflict deleteWith( BaseSyntaxNode * d ) { return { d }; }
+                };
+                /// true if the existing identifier conflicts with the added identifier
+                bool addedIdConflicts(
+                        const IdData& existing, DeclarationWithType * added, OnConflict handleConflicts,
+                        BaseSyntaxNode * deleteStmt );
                 /// common code for addId, addDeletedId, etc.
+                void addId( DeclarationWithType * decl, ConflictFunction, Expression * baseExpr = nullptr, BaseSyntaxNode * deleteStmt = nullptr );
+                void addId(
+                        DeclarationWithType * decl, OnConflict handleConflicts,
+                        Expression * baseExpr = nullptr, BaseSyntaxNode * deleteStmt = nullptr );
+                /// adds all of the members of the Aggregate (addWith helper)
+                void addMembers( AggregateDecl * aggr, Expression * expr, OnConflict handleConflicts );
+                /// returns true if there exists a declaration with C linkage and the given name with the same mangled name
+                bool hasCompatibleCDecl( const std::string &id, const std::string &mangleName ) const;
+                /// returns true if there exists a declaration with C linkage and the given name with a different mangled name
+                bool hasIncompatibleCDecl( const std::string &id, const std::string &mangleName ) const;
         };
 } // namespace SymTab

src/SynTree/Attribute.cc

rf845e80	r98b4b12
21	21	#include "Expression.h" // for Expression
22	22
23		Attribute::Attribute( const Attribute &other ) : name( other.name ) {
	23	Attribute::Attribute( const Attribute &other ) : BaseSyntaxNode( other ), name( other.name ) {
24	24	cloneAll( other.parameters, parameters );
25	25	}

src/SynTree/BaseSyntaxNode.h

-                      rf845e80
+                      r98b4b12
 #include "Common/CodeLocation.h"
 #include "Common/Indenter.h"
+#include "Common/Stats.h"
 class Visitor;
 class Mutator;
 …
 class BaseSyntaxNode {
   public:
+  static Stats::Counters::SimpleCounter* new_nodes;
         CodeLocation location;
+  BaseSyntaxNode() { ++*new_nodes; }
+  BaseSyntaxNode( const BaseSyntaxNode& o ) : location(o.location) { ++*new_nodes; }
         virtual ~BaseSyntaxNode() {}

src/SynTree/Constant.cc

rf845e80	r98b4b12
25	25	Constant::Constant( Type * type, std::string rep, double val ) : type( type ), rep( rep ), val( val ) {}
26	26
27		Constant::Constant( const Constant &other ) : rep( other.rep ), val( other.val ) {
	27	Constant::Constant( const Constant &other ) : BaseSyntaxNode( other ), rep( other.rep ), val( other.val ) {
28	28	type = other.type->clone();
29	29	}

src/SynTree/Declaration.h

-                      rf845e80
+                      r98b4b12
                 TypeDecl::Kind kind;
                 bool isComplete;
                 Data() : kind( (TypeDecl::Kind)-1 ), isComplete( false ) {}
                 Data( TypeDecl * typeDecl ) : Data( typeDecl->get_kind(), typeDecl->isComplete() ) {}
                 Data( Kind kind, bool isComplete ) : kind( kind ), isComplete( isComplete ) {}
+                Data( const Data& d1, const Data& d2 )
+                : kind( d1.kind ), isComplete ( d1.isComplete || d2.isComplete ) {}
                 bool operator==(const Data & other) const { return kind == other.kind && isComplete == other.isComplete; }
                 bool operator!=(const Data & other) const { return !(*this == other);}

src/SynTree/Statement.h

-                      rf845e80
+                      r98b4b12
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Mar  8 14:53:02 2018
 // Update Count     : 78
+// Last Modified On : Tue Mar 12 09:01:53 2019
+// Update Count     : 83
 //
 …
 #include <list>                    // for list
 #include <memory>                  // for allocator
 #include <vector>                        // for vector
+#include <vector>                                  // for vector
 #include "BaseSyntaxNode.h"        // for BaseSyntaxNode
 …
         const std::list<Label> & get_labels() const { return labels; }
         virtual Statement *clone() const override = 0;
         virtual void accept( Visitor &v ) override = 0;
         virtual Statement *acceptMutator( Mutator &m ) override = 0;
         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual Statement * clone() const override = 0;
+        virtual void accept( Visitor & v ) override = 0;
+        virtual Statement * acceptMutator( Mutator & m ) override = 0;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         CompoundStmt();
         CompoundStmt( std::list<Statement *> stmts );
         CompoundStmt( const CompoundStmt &other );
+        CompoundStmt( const CompoundStmt & other );
         virtual ~CompoundStmt();
 …
         void push_front( Statement * stmt ) { kids.push_front( stmt ); }
         virtual CompoundStmt *clone() const override { return new CompoundStmt( *this ); }
         virtual void accept( Visitor &v ) override { v.visit( this ); }
         virtual CompoundStmt *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual CompoundStmt * clone() const override { return new CompoundStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual CompoundStmt * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         NullStmt( const std::list<Label> & labels = {} );
         virtual NullStmt *clone() const override { return new NullStmt( *this ); }
         virtual void accept( Visitor &v ) override { v.visit( this ); }
         virtual NullStmt *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual NullStmt * clone() const override { return new NullStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual NullStmt * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 class ExprStmt : public Statement {
   public:
         Expression *expr;
         ExprStmt( Expression *expr );
         ExprStmt( const ExprStmt &other );
+        Expression * expr;
+        ExprStmt( Expression * expr );
+        ExprStmt( const ExprStmt & other );
         virtual ~ExprStmt();
         Expression *get_expr() { return expr; }
         void set_expr( Expression *newValue ) { expr = newValue; }
         virtual ExprStmt *clone() const override { return new ExprStmt( *this ); }
         virtual void accept( Visitor &v ) override { v.visit( this ); }
         virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        Expression * get_expr() { return expr; }
+        void set_expr( Expression * newValue ) { expr = newValue; }
+        virtual ExprStmt * clone() const override { return new ExprStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
   public:
         bool voltile;
         Expression *instruction;
+        Expression * instruction;
         std::list<Expression *> output, input;
         std::list<ConstantExpr *> clobber;
         std::list<Label> gotolabels;
         AsmStmt( bool voltile, Expression *instruction, std::list<Expression *> output, std::list<Expression *> input, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels );
         AsmStmt( const AsmStmt &other );
+        AsmStmt( bool voltile, Expression * instruction, std::list<Expression *> output, std::list<Expression *> input, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels );
+        AsmStmt( const AsmStmt & other );
         virtual ~AsmStmt();
 …
         void set_output( const std::list<Expression *> & newValue ) { output = newValue; }
         std::list<Expression *> & get_input() { return input; }
         void set_input( const std::list<Expression *> &newValue ) { input = newValue; }
+        void set_input( const std::list<Expression *> & newValue ) { input = newValue; }
         std::list<ConstantExpr *> & get_clobber() { return clobber; }
         void set_clobber( const std::list<ConstantExpr *> &newValue ) { clobber = newValue; }
+        void set_clobber( const std::list<ConstantExpr *> & newValue ) { clobber = newValue; }
         std::list<Label> & get_gotolabels() { return gotolabels; }
         void set_gotolabels( const std::list<Label> &newValue ) { gotolabels = newValue; }
+        void set_gotolabels( const std::list<Label> & newValue ) { gotolabels = newValue; }
         virtual AsmStmt * clone() const { return new AsmStmt( *this ); }
 …
 class IfStmt : public Statement {
   public:
         Expression *condition;
         Statement *thenPart;
         Statement *elsePart;
+        Expression * condition;
+        Statement * thenPart;
+      &n

Context Navigation

Changes in / [f845e80:98b4b12]

Legend: