Changeset 515a037

benchmark/Makefile.am

-              rcdc02f2
+              r515a037
 ## Created On       : Sun May 31 09:08:15 2015
 ## Last Modified By : Peter A. Buhr
 ## Last Modified On : Mon Jan 25 22:31:42 2016
 ## Update Count     : 25
+## Last Modified On : Tue Nov  6 09:01:23 2018
+## Update Count     : 26
 ###############################################################################
 …
 compile-attributes$(EXEEXT):
         $(AM_V_CFA)$(CFACOMPILE) -fsyntax-only -w $(testdir)/attributes.c
+        $(AM_V_CFA)$(CFACOMPILE) -fsyntax-only -w $(testdir)/attributes.cfa
 compile-empty$(EXEEXT):

benchmark/Makefile.in

rcdc02f2	r515a037
879	879
880	880	compile-attributes$(EXEEXT):
881		$(AM_V_CFA)$(CFACOMPILE) -fsyntax-only -w $(testdir)/attributes.c
	881	$(AM_V_CFA)$(CFACOMPILE) -fsyntax-only -w $(testdir)/attributes.cfa
882	882
883	883	compile-empty$(EXEEXT):

benchmark/Monitor.c

rcdc02f2	r515a037
29	29	EndTime = Time();
30	30
31		sout \| ( EndTime - StartTime ) / N ~~\| endl~~;
	31	sout \| ( EndTime - StartTime ) / N;
32	32	}

doc/bibliography/pl.bib

-              rcdc02f2
+              r515a037
 %  toplas: ACM Trans. on Prog. Lang. & Sys.
 %  tcs: Theoretical Computer Science
+@string{ieeepds="IEEE Transactions on Parallel and Distributed Systems"}
+% @string{ieeepds="IEEE Trans. Parallel Distrib. Syst."}
+@string{ieeese="IEEE Transactions on Software Engineering"}
+% @string{ieeese="IEEE Trans. Softw. Eng."}
+@string{spe="Software---\-Practice and Experience"}
+% @string{spe="Softw. Pract. Exp."}
+@string{ccpe="Concurrency and Computation: Practice and Experience"}
+% @string{ccpe="Concurrency Comput: Pract Experience"}
+@string{sigplan="SIGPLAN Notices"}
+% @string{sigplan="SIGPLAN Not."}
+@string{joop="Journal of Object-Oriented Programming"}
+% @string{joop="J. of Object-Oriented Program."}
+string{ieeepds="IEEE Transactions on Parallel and Distributed Systems"}
+@string{ieeepds="IEEE Trans. Parallel Distrib. Syst."}
+string{ieeese="IEEE Transactions on Software Engineering"}
+@string{ieeese="IEEE Trans. Softw. Eng."}
+string{spe="Software---\-Practice and Experience"}
+@string{spe="Softw. Pract. Exper."}
+string{ccpe="Concurrency and Computation: Practice and Experience"}
+@string{ccpe="Concurrency Comput.: Pract. Exper."}
+string{sigplan="SIGPLAN Notices"}
+@string{sigplan="SIGPLAN Not."}
+string{joop="Journal of Object-Oriented Programming"}
+@string{joop="J. of Object-Oriented Program."}
 @string{popl="Conference Record of the ACM Symposium on Principles of Programming Languages"}
 @string{osr="Operating Systems Review"}
 @string{pldi="Programming Language Design and Implementation"}
 @string{toplas="Transactions on Programming Languages and Systems"}
 @string{mathann="Mathematische Annalen"}
 % @string{mathann="Math. Ann."}
+string{mathann="Mathematische Annalen"}
+@string{mathann="Math. Ann."}
 % A
 …
+}
+@inproceedings {Qin18,
+    author      = {Henry Qin and Qian Li and Jacqueline Speiser and Peter Kraft and John Ousterhout},
+    title       = {Arachne: Core-Aware Thread Management},
+    booktitle   = {13th {USENIX} Symp. on Oper. Sys. Design and Impl. ({OSDI} 18)},
+    year        = {2018},
+    address     = {Carlsbad, CA},
+    pages       = {145-160},
+    publisher   = {{USENIX} Association},
+    note        = {\href{https://www.usenix.org/conference/osdi18/presentation/qin}{https://\-www.usenix.org/\-conference/\-osdi18/\-presentation/\-qin}},
+}
 @article{Kessels82,
     keywords    = {concurrency, critical section},
 …
     author      = {Joung, Yuh-Jzer},
     title       = {Asynchronous group mutual exclusion},
+    journal     = {Distributed Computing},
+    journal     = {Dist. Comput.},
+    optjournal  = {Distributed Computing},
     year        = {2000},
     month       = {Nov},
 …
         time computable inheritance hierarchy.
     },
     comment = {
+    comment     = {
         Classes are predicates; if object {\tt o} is in class {\tt C}, then
         {\tt C} is true of {\tt o}.  Classes are combined with {\tt :AND},
 …
 @article{Moss18,
     keywords    = {type systems, tuples, Cforall},
+    keywords    = {type systems, polymorphism, tuples, Cforall},
     contributer = {pabuhr@plg},
     author      = {Aaron Moss and Robert Schluntz and Peter A. Buhr},
     title       = {\textsf{C}$\mathbf{\forall}$ : Adding Modern Programming Language Features to C},
+    journal     = spe,
+    volume      = 48,
+    number      = 12,
+    month       = dec,
     year        = 2018,
+    month       = aug,
+    journal     = spe,
+    pages       = {2111-2146},
     note        = {\href{http://dx.doi.org/10.1002/spe.2624}{http://\-dx.doi.org/\-10.1002/\-spe.2624}},
+}
 …
     journal     = {Dr. Dobb's Journal of Software Tools},
     year        = 1989,
+    month       = feb, volume = 14, number = 2, pages = {45-51},
+    month       = feb,
+    volume      = 14,
+    number      = 2,
+    pages       = {45-51},
     comment     = {
        A light-weight multitasking kernel for MS-DOS.  A task\_control
 …
+}
 @techreport{uC++,
+@manual{uC++,
     keywords    = {C++, concurrency, light-weight process, shared memory},
     contributer = {pabuhr@plg},
+    key         = {uC++},
     author      = {Peter A. Buhr},
     title       = {$\mu${C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}} Annotated Reference Manual, Version 7.0.0},
+    institution = {School of Computer Science, University of Waterloo},
+    address     = {Waterloo, Ontario, Canada, N2L 3G1},
+    month       = dec,
+    year        = 2017,
+    organization= {University of Waterloo},
+    month       = sep,
+    year        = 2018,
     note        = {\href{https://plg.uwaterloo.ca/~usystem/pub/uSystem/uC++.pdf}{https://\-plg.uwaterloo.ca/\-$\sim$usystem/\-pub/\-uSystem/uC++.pdf}},
+}
 …
     author      = {Sun, Xianda},
     title       = {Concurrent High-performance Persistent Hash Table In {J}ava},
     school      = {School of Computer Science, University of Waterloo},
+    school      = {School of Computer Sc., University of Waterloo},
     year        = 2015,
     optaddress  = {Waterloo, Ontario, Canada, N2L 3G1},
 …
     note        = {Svensk Standard SS 63 61 14},
     year        = 1987,
+    abstract    = {
+        Standard for the programming language SIMULA.  Written in English.
+    }
+    abstract    = {Standard for the programming language SIMULA. Written in English.}
+}
+@article{Galil91,
+    keywords    = {union-find},
+    contributer = {a3moss@uwaterloo.ca},
+    title       = {Data structures and algorithms for disjoint set union problems},
+    author      = {Galil, Zvi and Italiano, Giuseppe F},
+    journal     = {ACM Computing Surveys (CSUR)},
+    volume      = 23,
+    number      = 3,
+    pages       = {319--344},
+    year        = 1991,
+    publisher   = {ACM},
+}
 …
     year        = {1998},
     pages       = {393-407},
+}
+@book{Aho74,
+    keywords    = {algorithms, textbook, union-find},
+    contributer = {a3moss@uwaterloo.ca},
+    title       = {The Design and Analysis of Computer Algorithms},
+    author      = {Aho, Alfred V and Hopcroft, John E and Ullman, Jeffrey D},
+    year        = {1974},
+    publisher   = {Addison-Wesley},
+    address     = {Reading, MA, USA}
+}
 …
+}
+@inproceedings{Patwary10,
+    keywords    = {union-find},
+    contributer = {a3moss@uwaterloo.ca},
+    author      = {Patwary, Md. Mostofa Ali and Blair, Jean and Manne, Fredrik},
+    editor      = {Festa, Paola},
+    title       = {Experiments on Union-Find Algorithms for the Disjoint-Set Data Structure},
+    booktitle   = {Experimental Algorithms},
+    year        = 2010,
+    publisher   = {Springer Berlin Heidelberg},
+    address     = {Berlin, Heidelberg},
+    pages       = {411--423},
+    isbn        = {978-3-642-13193-6}
+}
 % F
 …
     keywords    = {Go programming language},
     contributer = {pabuhr@plg},
+    author      = {Robert Griesemer and Rob Pike and Ken Thompson},
     title       = {{Go} Programming Language},
-    author      = {Robert Griesemer and Rob Pike and Ken Thompson},
     organization= {Google},
     year        = 2009,
 …
     month       = sep,
     publisher   = {John Wiley \& Sons},
     note        = {\href{https://doi-org.proxy.lib.uwaterloo.ca/10.1002/cpe.4475}{https://\-doi-org.proxy.lib.uwaterloo.ca/\-10.1002/\-cpe.4475}},
+    note        = {\href{https://doi.org/10.1002/cpe.4475}{https://\-doi.org/\-10.1002/\-cpe.4475}},
+}
 …
     publisher   = {ACM Press},
     address     = {New York, NY, USA},
+}
+@article{Galler64,
+    keywords    = {union-find, original},
+    contributer = {a3moss@uwaterloo.ca},
+    title       = {An improved equivalence algorithm},
+    author      = {Galler, Bernard A and Fisher, Michael J},
+    journal     = {Communications of the ACM},
+    volume      = {7},
+    number      = {5},
+    pages       = {301--303},
+    year        = {1964},
+    publisher   = {ACM}
+}
 …
     author      = {Peter A. Buhr and Martin Karsten and Jun Shih},
     title       = {{\small\textsf{KDB}}: A Multi-threaded Debugger for Multi-threaded Applications},
     booktitle   = {Proceedings of SPDT'96: SIGMETRICS Symposium on Parallel and Distributed Tools},
+    booktitle   = {Proc. of SPDT'96: SIGMETRICS Symp. on Parallel and Distributed Tools},
     publisher   = {ACM Press},
     address     = {Philadelphia, Pennsylvania, U.S.A.},
 …
+}
+@inproceedings{Conchon07,
+    keywords    = {persistent array, union-find},
+    contributer = {a3moss@uwaterloo.ca},
+    title       = {A persistent union-find data structure},
+    author      = {Conchon, Sylvain and Filli{\^a}tre, Jean-Christophe},
+    booktitle   = {Proceedings of the 2007 workshop on Workshop on ML},
+    pages       = {37--46},
+    year        = {2007},
+    organization= {ACM}
+}
 @article{poly,
     keywords    = {Poly, Standard ML, Russell, persistence},
 …
     author      = {Peter A. Buhr and Robert Denda},
     title       = {{$\mu$Profiler} : Profiling User-Level Threads in a Shared-Memory Programming Environment},
     booktitle   = {Proceedings of the Second International Symposium on Computing in Object-Oriented Parallel Environments (ISCOPE'98)},
+    booktitle   = {Proc. of 2nd Inter. Symp. on Computing in Object-Oriented Parallel Environments},
     series      = {Lecture Notes in Computer Science},
     publisher   = {Springer-Verlag},
 …
     issn        = {0164-0925},
     pages       = {429-475},
     url         = {http://doi.acm.org.proxy.lib.uwaterloo.ca/10.1145/1133651.1133653},
+    url         = {http://doi.acm.org/10.1145/1133651.1133653},
     doi         = {10.1145/1133651.1133653},
     acmid       = {1133653},
 …
     contributer = {pabuhr@plg},
     key         = {Rust},
     title       = {The {R}ust Programming Language},
     address     = {The Rust Project Developers},
+    title       = {{R}ust Programming Language},
+    optaddress  = {Rust Project Developers},
     year        = 2015,
     note        = {\href{https://doc.rust-lang.org/reference.html}{https://\-doc.rust-lang\-.org/\-reference.html}},
 …
     publisher   = {Springer},
     note        = {Lecture Notes in Computer Science v. 173},
+}
+@article{Baker78,
+    keywords    = {Algol display, FUNARG's, Lisp 1.5, deep binding, environment trees, multiprogramming, shallow binding},
+    contributer = {a3moss@uwaterloo.ca},
+    author      = {Baker,Jr., Henry G.},
+    title       = {Shallow Binding in Lisp 1.5},
+    journal     = {Commun. ACM},
+    issue_date  = {July 1978},
+    volume      = 21,
+    number      = 7,
+    month       = jul,
+    year        = 1978,
+    issn        = {0001-0782},
+    pages       = {565--569},
+    numpages    = {5},
+    url         = {http://doi.acm.org/10.1145/359545.359566},
+    doi         = {10.1145/359545.359566},
+    acmid       = {359566},
+    publisher   = {ACM},
+    address     = {New York, NY, USA}
+}
+@article{Baker91,
+    keywords    = {shallow binding, functional arrays},
+    contributer = {a3moss@uwaterloo.ca},
+    author      = {Baker, Henry G.},
+    title       = {Shallow Binding Makes Functional Arrays Fast},
+    journal     = {SIGPLAN Not.},
+    issue_date  = {Aug. 1991},
+    volume      = 26,
+    number      = 8,
+    month       = aug,
+    year        = 1991,
+    issn        = {0362-1340},
+    pages       = {145--147},
+    numpages    = {3},
+    url         = {http://doi.acm.org/10.1145/122598.122614},
+    doi         = {10.1145/122598.122614},
+    acmid       = {122614},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+}
 …
+}
+@article{Tarjan84,
+    keywords    = {union-find},
+    contributer = {a3moss@uwaterloo.ca},
+    author      = {Tarjan, Robert E. and van Leeuwen, Jan},
+    title       = {Worst-case Analysis of Set Union Algorithms},
+    journal     = {J. ACM},
+    issue_date  = {April 1984},
+    volume      = 31,
+    number      = 2,
+    month       = mar,
+    year        = 1984,
+    issn        = {0004-5411},
+    pages       = {245--281},
+    numpages    = {37},
+    url         = {http://doi.acm.org/10.1145/62.2160},
+    doi         = {10.1145/62.2160},
+    acmid       = {2160},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+}
 % X

doc/papers/concurrency/Paper.tex

-              rcdc02f2
+              r515a037
         Fib f1, f2;
         for ( int i = 1; i <= 10; i += 1 ) {
                 sout | next( f1 ) | next( f2 ) | endl;
+                sout | next( f1 ) | next( f2 );
+        }
+}
 …
                         sout | "  ";               // separator
+                }
                 sout | endl;
+                sout | nl;
+        }
+}
 void ?{}( Format & fmt ) { `resume( fmt );` }
 void ^?{}( Format & fmt ) with( fmt ) {
         if ( g != 0 || b != 0 ) sout | endl;
+        if ( g != 0 || b != 0 ) sout | nl;
+}
 void format( Format & fmt ) {
 …
         for ( int i = 0; i < N; i += 1 ) {
                 int p1 = random( 100 ), p2 = random( 100 );
                 sout | p1 | " " | p2 | endl;
+                sout | p1 | " " | p2;
                 int status = delivery( c, p1, p2 );
                 sout | " $" | money | endl | status | endl;
+                sout | " $" | money | nl | status;
                 receipt += 1;
+        }
         stop( c );
         sout | "prod stops" | endl;
+        sout | "prod stops";
+}
 int payment( Prod & prod, int money ) {
 …
         int money = 1, receipt;
         for ( ; ! done; ) {
                 sout | p1 | " " | p2 | endl | " $" | money | endl;
+                sout | p1 | " " | p2 | nl | " $" | money;
                 status += 1;
                 receipt = payment( p, money );
                 sout | " #" | receipt | endl;
+                sout | " #" | receipt;
                 money += 1;
+        }
         sout | "cons stops" | endl;
+        sout | "cons stops";
+}
 int delivery( Cons & cons, int p1, int p2 ) {
 …
 void main(foo & this) {
         sout | "Hello World!" | endl;
+        sout | "Hello World!";
+}
 \end{cfa}
 …
 void hello(/*unused*/ int) {
         sout | "Hello World!" | endl;
+        sout | "Hello World!";
+}
 …
 thread World {};
 void main( World & this ) {
         sout | "World!" | endl;
+        sout | "World!";
+}
 int main() {
         World w`[10]`;                                                  $\C{// implicit forks after creation}$
         sout | "Hello " | endl;                                 $\C{// "Hello " and 10 "World!" printed concurrently}$
+        sout | "Hello ";                                        $\C{// "Hello " and 10 "World!" printed concurrently}$
 }                                                                                       $\C{// implicit joins before destruction}$
 \end{cfa}
 …
                 total += subtotals[r];                          $\C{// total subtotal}$
+    }
     sout | total | endl;
+    sout | total;
+}
 \end{cfa}
 …
         BENCH(
                 for ( size_t i = 0; i < N; i += 1 ) { @resume( c );@ } )
         sout | result`ns | endl;
+        sout | result`ns;
+}
 \end{cfa}
 …
         BENCH(
                 for ( size_t i = 0; i < N; i += 1 ) { @yield();@ } )
         sout | result`ns | endl;
+        sout | result`ns;
+}
 \end{cfa}
 …
 int main() {
         BENCH( for( size_t i = 0; i < N; i += 1 ) { @do_call( m1/*, m2, m3, m4*/ );@ } )
         sout | result`ns | endl;
+        sout | result`ns;
+}
 \end{cfa}
 …
         BENCH( for ( size_t i = 0; i < N; i += 1 ) { @wait( c );@ } );
         go = 0; // stop other thread
         sout | result`ns | endl;
+        sout | result`ns;
+}
 int main() {
 …
         BENCH( for ( size_t i = 0; i < N; i += 1 ) { @waitfor( do_call, m );@ } )
         go = 0; // stop other thread
         sout | result`ns | endl;
+        sout | result`ns;
+}
 int main() {
 …
 int main() {
         BENCH( for ( size_t i = 0; i < N; i += 1 ) { @MyThread m;@ } )
         sout | result`ns | endl;
+        sout | result`ns;
+}
 \end{cfa}

doc/proposals/flags.md

-              rcdc02f2
+              r515a037
         ```
         FunFlags f = some_val();
         if ( f ) { sout | "f has some flag(s) set" | endl; }
         if ( f & FOO ) { sout | "f has FOO set" | endl; }
+        if ( f ) { sout | "f has some flag(s) set"; }
+        if ( f & FOO ) { sout | "f has FOO set"; }
         f |= FOO; // set FOO
         f -= FOO; // unset FOO
 …
         ```
         FunFlags f = some_val();
         if ( f.FOO ) { sout | "f has FOO set" | endl; }
+        if ( f.FOO ) { sout | "f has FOO set"; }
         f.FOO = true;    // set FOO
         f.FOO = false;   // unset FOO

doc/theses/aaron_moss_PhD/phd/thesis.tex

-              rcdc02f2
+              r515a037
 % \usepackage[pdftex]{graphicx} % For including graphics N.B. pdftex graphics driver
 \usepackage{graphicx}
+\usepackage{amsthm} % for theorem environment
+\newtheorem{theorem}{Theorem}
 \usepackage{footmisc} % for double refs to the same footnote

doc/theses/aaron_moss_PhD/phd/type-environment.tex

-              rcdc02f2
+              r515a037
 As discussed in Chapter~\ref{resolution-chap}, being able to efficiently determine which type variables are bound to which concrete types or whether two type environments are compatible is a core requirement of the resolution algorithm.
 Furthermore, expression resolution involves a search through many related possible solutions, so being able to re-use shared subsets of type environment data and to switch between environments quickly is desirable for performance.
 In this chapter I discuss and empirically compare a number of type environment data structure variants, including some novel variations on the union-find\cit{} data structure introduced in this thesis.
 \section{Definitions}
+In this chapter I discuss and empirically compare a number of type environment data structure variants, including some novel variations on the union-find\cite{Galler64} data structure introduced in this thesis.
+\section{Definitions} \label{env-defn-sec}
 For purposes of this chapter, a \emph{type environment} $T$ is a set of \emph{type classes} $\myset{T_1, T_2, \cdots, T_{|T|}}$.
 …
         $add(T_i, v_{i,j})$ &                                                           & Add variable to class                 \\
         $bind(T_i, b_i)$ &                                                                      & Set or update class bound             \\
-        $remove(T, T_i)$ &                                                                      & Remove class from environment \\
         $unify(T, T_i, T_j)$ & $\rightarrow \top | \bot$        & Combine two type classes              \\
+        $split(T, T_i)$ & $\rightarrow T'$                                      & Revert the last $unify$ operation on $T_i$            \\
         $combine(T, T')$ & $\rightarrow \top | \bot$            & Merge two environments                \\
         $save(T)$ & $\rightarrow H$                                                     & Get handle for current state  \\
 …
 The $add(T_i, v_{i,j})$ operation adds a new type variable $v_{i,j}$ to class $T_i$; again, $v_{i,j}$ cannot exist elsewhere in $T$.
 $bind(T_i, b_i)$ mutates the bound for a type class, setting or updating the current bound.
-The final basic mutation operation is $remove(T, T_i)$, which removes a class $T_i$ and all its type variables from an environment $T$.
 The $unify$ operation is the fundamental non-trivial operation a type environment data structure must support.
 $unify(T, T_i, T_j)$ merges a type class $T_j$ into another $T_i$, producing a failure result and leaving $T$ in an invalid state if this merge fails.
 It is always possible to unify the type variables of both classes by simply taking the union of both sets; given the disjointness property, no checks for set containment are required, and the variable sets can simply be concatenated if supported by the underlying data structure.
 $unify$ depends on an internal $unify_bound$ operation which may fail.
 In \CFACC{}, $unify_bound(b_i, b_j) \rightarrow b'_i|\bot$ checks that the type classes contain the same sort of variable, takes the tighter of the two conversion permissions, and checks if the bound types can be unified.
 If the bound types cannot be unified (\eg{} !struct A! with !int*!), then $unify_bound$ fails, while other combinations of bound types may result in recursive calls.
 For instance, unifying !R*! with !S*! for type variables !R! and !S! will result in a call to $unify(T, find($!R!$), find($!S!$))$, while unifying !R*! with !int*! will result in a call to $unify_bound$ on !int! and the bound type of the class containing !R!.
+$unify$ depends on an internal $unifyBound$ operation which may fail.
+In \CFACC{}, $unifyBound(b_i, b_j) \rightarrow b'_i|\bot$ checks that the type classes contain the same sort of variable, takes the tighter of the two conversion permissions, and checks if the bound types can be unified.
+If the bound types cannot be unified (\eg{} !struct A! with !int*!), then $unifyBound$ fails, while other combinations of bound types may result in recursive calls.
+For instance, unifying !R*! with !S*! for type variables !R! and !S! will result in a call to $unify(T, find($!R!$), find($!S!$))$, while unifying !R*! with !int*! will result in a call to $unifyBound$ on !int! and the bound type of the class containing !R!.
 As such, a call to $unify(T, T_i, T_j)$ may touch every type class in $T$, not just $T_i$ and $T_j$, collapsing the entirety of $T$ into a single type class in extreme cases.
+For more information on \CFA{} unification, see \cite{Bilson03}.
+The inverse of $unify$ is $split(T, T_i)$, which produces a new environment $T'$ which is the same as $T$ except that $T_i$ has been replaced by two classes corresponding to the arguments to the previous call to $unify$ on $T_i$.
+If there has been no call to $unify$ on $T_i$ (\ie{} $T_i$ is a single-element class) $T_i$ is absent in $T'$.
 Given the nature of the expression resolution problem as backtracking search, caching and concurrency are both useful tools to decrease runtime.
 …
 The invalid state of $T$ on failure is not important, given that a combination failure will result in the resolution algorithm backtracking to a different environment.
 $combine$ proceeds by calls to $insert$, $add$, and $unify$ as needed, and can be roughly thought of as calling $unify$ on every pair of classes in $T$ that have variables $v'_{i,j}$ and $v'_{i,k}$ in the same class $T'_i$ in $T'$.
 Like for $unify$, $combine$ can always find a mutually-consistent division of type variables into classes (in the extreme case, all type variables from $T$ and $T'$ in a single type class), but may fail due to inconsistent bounds on merged type classes.
+Like $unify$, $combine$ can always find a mutually-consistent partition of type variables into classes (in the extreme case, all type variables from $T$ and $T'$ in a single type class), but may fail due to inconsistent bounds on merged type classes.
 Finally, the backtracking access patterns of the compiler can be exploited to reduce memory usage or runtime through use of an appropriately designed data structure.
 The set of mutations to a type environment across the execution of the resolution algorithm produce an implicit tree of related environments, and the backtracking search typically focuses only on one leaf of the tree at once, or at most a small number of closely-related nodes as arguments to $combine$.
 As such, the ability to save and restore particular type environment states is useful, and supported by the $save(T) \rightarrow H$ and $backtrack(T, H)$ operations, which produce a handle for the current environment state and mutate an environment back to a previous state, respectively.
+These operations can be naively implemented by a deep copy of $T$ into $H$ and vice versa, but have more efficient implementations in persistency-aware data structures.
+These operations can be naively implemented by a deep copy of $T$ into $H$ and vice versa, but have more efficient implementations in persistency-aware data structures.
+\section{Approaches}
+\subsection{Na\"{\i}ve}
+The type environment data structure used in Bilson's\cite{Bilson03} original implementation of \CFACC{} is a straightforward translation of the definitions in Section~\ref{env-defn-sec} to \CC{} code; a !TypeEnvironment! contains a list of !EqvClass! type equivalence classes, each of which contains the type bound information and a tree-based sorted set of type variables.
+This approach has the benefit of being easy to understand and not imposing life-cycle or inheritance constraints on its use, but, as can be seen in Table~\ref{env-bounds-table}, does not support many of the desired operations with any particular efficiency.
+Some variations on this structure may improve performance somewhat; for instance, replacing the !EqvClass! variable storage with a hash-based set would reduce search and update times from $O(\log n)$ to amortized $O(1)$, while adding an index for the type variables in the entire environment would remove the need to check each type class individually to maintain the disjointness property.
+These improvements do not change the fundamental issues with this data structure, however.
+\subsection{Incremental Inheritance}
+One more invasive modification to this data structure which I investigated is to support swifter combinations of closely-related environments in the backtracking tree by storing a reference to a \emph{parent} environment within each environment, and having that environment only store type classes which have been modified with respect to the parent.
+This approach provides constant-time copying of environments, as a new environment simply consists of an empty list of type classes and a reference to its (logically identical) parent; since many type environments are no different than their parent, this speeds backtracking in this common case.
+Since all mutations made to a child environment are by definition compatible with the parent environment, two descendants of a common ancestor environment can be combined by iteratively combining the changes made in one environment then that environment's parent until the common ancestor is reached, again re-using storage and reducing computation in many cases.
+For this environment I also employed a lazily-generated index of type variables to their containing class, which could be in either the current environment or an ancestor.
+Any mutation of a type class in an ancestor environment would cause that class to be copied into the current environment before mutation, as well as added to the index, ensuring that all local changes to the type environment are listed in its index.
+However, not adding type variables to the index until lookup or mutation preserves the constant-time environment copy operation in the common case in which the copy is not mutated from its parent during its life-cycle.
+This approach imposes some performance penalty on $combine$ if related environments are not properly linked together, as the entire environment needs to be combined rather than just the diff, but is correct as long as the ``null parent'' base case is properly handled.
+The life-cycle issues are somewhat more complex, as many environments may descend from a common parent, and all of these need their parent to stay alive for purposes of lookup.
+These issues can be solved by ``flattening'' parent nodes into their children before the parents leave scope, but given the tree structure of the inheritance graph it is more straightforward to store the parent nodes in reference-counted or otherwise automatically garbage-collected heap storage.
+\subsection{Union-Find} \label{env-union-find-approach}
+Given the nature of the classes of type variables as disjoint sets, another natural approach to implementing a type environment is the union-find disjoint set data structure\cite{Galler64}.
+Union-find efficiently implements two operations over a partition of a collection of elements into disjoint sets; $find(x)$ locates the \emph{representative} of $x$, the element which canonically names its set, while $union(r, s)$ merges two sets represented by $r$ and $s$, respectively.
+The union-find data structure is based on providing each element with a reference to its parent element, such that the root of a tree of elements is the representative of the set of elements contained in the tree.
+$find$ is then implemented by a search up to the parent, generally combined with a \emph{path compression} step that links nodes more directly to their ancestors to speed up subsequent searches.
+$union$ involves making the representative of one set a child of the representative of the other, generally employing a rank- or size-based heuristic to ensure that the tree remains somewhat balanced.
+If both path compression and a balancing heuristic are employed, both $union$ and $find$ run in amortized $O(\alpha(n))$ worst-case time; this bound by the inverse Ackermann function is a small constant for all practical values of $n$.
+The union-find $find$ and $union$ operations have obvious applicability to the $find$ and $unify$ type environment operations in Table~\ref{env-op-table}, but the union-find data structure must be augmented to fully implement the type environment operations.
+In particular, the type class bound cannot be easily included in the union-find data structure, as the requirement to make it the class representative breaks the balancing properties of $union$, and requires too-close integration of the type environment $unifyBound$ internal operation.
+This issue can be solved by including a side map from class representatives to the type class bound.
+If placeholder values are inserted in this map for type classes without bounds than this also has the useful property that the key set of the map provides an easily obtainable list of all the class representatives, a list which cannot be derived from the union-find data structure without a linear search for class representatives through all elements.
+\subsection{Union-Find with Classes} \label{env-union-find-classes-approach}
+Another type environment operation not supported directly by the union-find data structure is $report$, which lists the type variables in a given class, and similarly $split$, which reverts a $unify$ operation.
+Since the union-find data structure stores only links from children to parents and not vice-versa, there is no way to reconstruct a class from one of its elements without a linear search over the entire data structure, with $find$ called on each element to check its membership in the class.
+The situation is even worse for the $split$ operation, which would require extra information to maintain the order that each child was added to its parent node.
+Unfortunately, the literature\cite{Tarjan84,Galil91,Patwary10} on union-find does not present a way to keep references to children without breaking the asymptotic time bounds of the algorithm; I have discovered a method to do so which, despite its simplicity, seems to be novel.
+\TODO{port figure from slideshow}
+The core idea of this ``union-find with classes'' data structure and algorithm is to keep the members of each class stored in a circularly-linked list.
+Aho, Hopcroft, and Ullman also include a circularly-linked list in their 1974 textbook~\cite{Aho74}.
+However, the algorithm presented by Aho~\etal{} has an entirely flat class hierarchy, where all elements are direct children of the representative, giving constant-time $find$ at the cost of linear-time $union$ operations.
+In my version, the list data structure does not affect the layout of the union-find tree, maintaining the same asymptotic bounds as union-find.
+In more detail, each element is given a !next! pointer to another element in the same class; this !next! pointer initially points to the element itself.
+When two classes are unified, the !next! pointers of the representatives of those classes are swapped, splicing the two circularly-linked lists together.
+Importantly, though this approach requires an extra pointer per element, it does maintain the linear space bound of union-find, and because it only requires updating the two root nodes in $union$ it does not asymptotically increase runtime either.
+The basic approach is compatible with all path-compression techniques, and allows the members of any class to be retrieved in time linear in the size of the class simply by following the !next! pointers from any element.
+If the path-compression optimization is abandoned, union-find with classes also encodes a reversible history of all the $union$ operations applied to a given class.
+Theorem~\ref{env-reverse-thm} demonstrates that the !next! pointer of the representative of a class always points to a leaf from the last-added subtree.
+This property is sufficient to reverse the most-recent $union$ operation by finding the ancestor of that leaf that is an immediate child of the representative, breaking its parent link, and swapping the !next! pointers back\footnote{Union-by-size may be a more appropriate approach than union-by-rank in this instance, as adding two known sizes is a reversible operation, but the rank increment operation cannot be reliably reversed.}.
+Once the $union$ operation has been reversed, Theorem~\ref{env-reverse-thm} still holds for the reduced class, and the process can be repeated recursively until the entire set is split into its component elements.
+\begin{theorem} \label{env-reverse-thm}
+The !next! pointer of a class representative in the union-find with classes algorithm without path compression points to a leaf from the most-recently-added subtree.
+\end{theorem}
+\begin{proof}
+        By induction on the height of the tree. \\
+        \emph{Base case:} A height 1 tree by definition includes only a single item. In such a case, the representative's !next! pointer points to itself by construction, and the representative is the most-recently-added (and only) leaf in the tree. \\
+        \emph{Inductive case:} By construction, a tree $T$ of height greater than 1 has children of the root (representative) node that were representative nodes of classes merged by $union$. By definition, the most-recently-added subtree $T'$ has a smaller height than $T$, thus by the inductive hypothesis before the most-recent $union$ operation the !next! pointer of the root of $T'$ pointed to one of the leaf nodes of $T'$; by construction the !next! pointer of the root of $T$ points to this leaf after the $union$ operation.
+\end{proof}
+On its own, union-find, like the na\"{\i}ve approach, has no special constraints on life-cycle or inheritance, but it can be used as a building block in more sophisticated type environment data structures.
+\subsection{Persistent Union-Find}
+Given the backtracking nature of the resolution algorithm discussed in Section~\ref{env-defn-sec}, the abilities to quickly switch between related versions of a type environment and to de-duplicate shared data between environments are both assets to performance.
+Conchon and Filli\^{a}tre~\cite{Conchon07} present a persistent union-find data structure based on the persistent array of Baker~\cite{Baker78,Baker91}.
+\TODO{port figure from slideshow}
+In Baker's persistent array, an array reference contains either a pointer to the array or a pointer to an \emph{edit node}; these edit nodes contain an array index, the value in that index, and another array reference pointing either to the array or a different edit node.
+In this manner, a tree of edits is formed, rooted at the actual array.
+Read from the actual array at the root can be performed in constant time, as with a non-persistent array.
+The persistent array can be mutated in constant time by directly modifying the underlying array, then replacing its array reference with an edit node containing the mutated index, the previous value at that index, and a reference to the mutated array. If the current array reference is not the root, mutation consists simply of constructing a new edit node encoding the change and referring to the current array reference.
+The mutation algorithm at the root is in some sense a special case of the key operation on persistent arrays, $reroot$.
+A rerooting operation takes any array reference and makes it the root node of the array.
+This is accomplished by tracing the path from some edit node to the root node of the array (always the underlying array), recursively applying the edits to the underlying array and replacing each edit node's successor with the inverse edit.
+In this way, any previous state of the persistent array can be restored in time proportional to the number of edits to the current state of the array.
+While $reroot$ does maintain the same value mapping in every version of the persistent array, the internal mutations it performs means that it is not thread-safe, and must be used behind a lock in a concurrent context.
+Also, the root node with the actual array may in principle be anywhere in the tree, and does not provide information to report its leaf nodes, so some form of automatic garbage collection is generally required for the data structure.
+Since the graph of edit nodes is tree-structured, reference counting approaches suffice for garbage collection; Conchon and Filli\^{a}tre~\cite{Conchon07} also observe that if the only $reroot$ operations are for backtracking then the tail of inverse edit nodes may be elided, suggesting the possibility of stack-based memory management.
+While Conchon and Filli\^{a}tre~\cite{Conchon07} implement their persistent union-find data structure over a universe of integer elements in the fixed range $[1,N]$, the type environment problem needs more flexibility.
+In particular, an arbitrary number of type variables must be added to the environment.
+As such, a persistent hash table is a more suitable structure than a persistent array, providing the same expected asymptotic time bounds while allowing a dynamic number of elements.
+Besides replacing the underlying array with a hash table, the other major change in this approach is to replace the two types of array references, !Array! and !Edit!, with four node types, !Table!,  !Edit!, !Add!, and !Remove!, where !Add! adds a new key-value pair, !Remove! removes a key, and !Edit! mutates an existing key-value pair.
+In this variant of \CFACC{}, this persistent hash table is used as the side map discussed in Section~\ref{env-union-find-approach} for class bounds.
+The actual union-find data structure is slightly modified from this approach, with a !Base! node containing the root union-find data structure, !Add! nodes adding new elements, !AddTo! nodes defining the union of two type classes, and !Remove! and !RemoveFrom! nodes as inverses of the previous two elements, for purposes of maintaining the edit list.
+Making !AddTo! and !RemoveFrom! single nodes shortens the edit path for improved performance, while also providing semantic information missing from the raw array updates in Conchon and Filli\^{a}tre's data structure.
+The single-node approach, does, however, break under most path-compression algorithms; !RemoveFrom! can be applied to the underlying data structure using the ``leaf of last union'' approach discussed in in Section~\ref{env-union-find-classes-approach}; this was judged an acceptable trade-off for the added semantic information and shortened paths.
+Maintaining explicit information on $union$ operations in the persistent union-find edit tree in the form of !AddTo! and !RemoveFrom! nodes exposes a new option for combining type environments.
+If the type environments are part of the same edit tree, one environment $T'$ can be combined with another $T$ by only testing the edits on the path from $T'$ to $T$ in both the persistent union-find data structure describing the classes and the persistent hash table containing the class bounds.
+This is generally more efficient than testing the compatibility of all type classes in $T'$, as only those that are actually different than those in $T$ must be considered.
+The procedure for $combine(T, T')$ based on edit paths is as follows:
+The shared edit trees for classes and bindings are rerooted at $T$, and the path from $T'$ to $T$ is followed to create a list of actual edits.
+By tracking the state of each element, redundant changes such as an !Edit! followed by an !Edit! can be reduced to their form in $T'$ by dropping the later (more like $T$) !Edit! for the same key; !Add! and !Remove! cancel similarly.
+This procedure is repeated for both the class edit tree and the binding edit tree.
+When the list of net changes to the environment has been produced, the additive changes are applied to $T$.
+For example, if a type class exists in $T'$ but not $T$, the corresponding !Add! edit will be applied to $T$, but in the reverse situation the !Remove! edit will not be applied to $T$, as the intention is to produce a new environment representing the union of the two sets of type classes; similarly, !AddTo! edits are applied to unify type-classes in $T$ that are united in $T'$, but !RemoveFrom! edits that split type classes are not.
+The new environment, $T''$ can always be constructed with a consistent partitioning of type variables; in the extreme case, all variables from both $T$ and $T'$ will be united in a single type class in $T''$.
+Where $combine$ can fail is in unifying the bound types; if any class in $T'$ has a class bound which does not unify with the merged class in $T''$ than $combine$ fails.
+\section{Analysis}
+In this section I present asymptotic analyses of the various approaches to a type environment data structure discussed in the previous section.
+\begin{table}
+\caption[Type environment operation bounds]{Worst-case analysis of type environment operations. $n$ is the number of type classes, $m$ the maximum size of a type class, and $p$ the edit distance between two environments or a single environment and the empty environment; $u(n)$ captures the recursive cost of class unification.}
+\label{env-bounds-table}
+\centering
+\begin{tabular}{rllll}
+        \hline
+                                & \textbf{Na\"{\i}ve}   & \textbf{Incremental}  & \textbf{Union-Find}           & \textbf{U-F with Classes}             \\
+        \hline
+        $find$          & $O(n)$                                & $O(p)$                                & $O(\alpha(m))$                        & $O(\log m)$                                   \\
+        $report$        & $O(m)$                                & $O(m)$                                & $O(n \log m)$                         & $O(m)$                                                \\
+        $bound$         & $O(1)$                                & $O(1)$                                & $O(1)$                                        & $O(1)$                                                \\
+        $insert$        & $O(1)$                                & $O(1)$                                & $O(1)$                                        & $O(1)$                                                \\
+        $add$           & $O(1)$                                & $O(1)$                                & $O(1)$                                        & $O(1)$                                                \\
+        $bind$          & $O(1)$                                & $O(1)$                                & $O(1)$                                        & $O(1)$                                                \\
+        $unify$         & $O(m + u(n))$                 & $O(m + u(n))$                 & $O(\log m + u(n))$            & $O(\log m + u(n))$                    \\
+        $split$         & ---                                   & ---                                   & ---                                           & $O(\log m)$                                   \\
+        $combine$       & $O(nm \cdot u(n))$    & $O(pm \cdot u(n))$    & $O(n \log m \cdot u(n))$      & $O(p \log m \cdot u(n))$              \\
+        $save$          & $O(nm)$                               & $O(1)$                                & $O(nm)$                                       & $O(1)$                                                \\
+        $backtrack$     & $O(nm)$                               & $O(pm)$                               & $O(nm)$                                       & $O(p)$                                                \\
+        \hline
+\end{tabular}
+\end{table}
 % Future work: design multi-threaded version of C&F persistent map --- core idea is some sort of thread-boundary edit node

doc/user/user.tex

-              rcdc02f2
+              r515a037
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Fri Aug 31 07:54:50 2018
 %% Update Count     : 3396
+%% Last Modified On : Tue Dec 11 23:19:26 2018
+%% Update Count     : 3400
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 int main( void ) {
         int x = 0, y = 1, z = 2;
         ®sout | x | y | z | endl;®§\indexc{sout}§
+        ®sout | x | y | z;®§\indexc{sout}§
+}
 \end{cfa}
 …
 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) | endl;
+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}
 …
+%\subsection{\texorpdfstring{\protect\lstinline@for@ Statement}{for Statement}}
+\subsection{\texorpdfstring{\LstKeywordStyle{for} Statement}{for Statement}}
+\subsection{Loop Control}
 The ©for©/©while©/©do-while© loop-control allows empty or simplified ranges.
 …
 the down-to range ©-~=©\index{-~=@©-~=©} means inclusive range [N,M].
 ©0© is the implicit start value;
+©1© is the implicit increment value for an up-to range and ©-1© for an implicit down-to range.
+©1© is the implicit increment value.
+The up-to range uses ©+=© for increment;
+the down-to range uses ©-=© for decrement.
 The loop index is polymorphic in the type of the start value or comparison value when start is implicitly ©0©.
 \begin{cquote}
 \begin{tabular}{@{}ll|l@{}}
 \multicolumn{2}{c|}{for control} & \multicolumn{1}{c}{output} \\
+\multicolumn{2}{c|}{loop control} & \multicolumn{1}{c}{output} \\
 \hline
 \begin{cfa}
 …
 for ( ®10® ) { sout | "A"; }
 for ( ®1 ~= 10 ~ 2® ) { sout | "B"; }
 for ( ®10 -~= 1 ~ -2® ) { sout | "C"; }
+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; 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; }
+int start = 3, comp = 10, inc = 2;
+for ( ®ui; 10u -~= 2u ~ 2u® ) { sout | ui; }
+enum { N = 10 };
+for ( ®N® ) { sout | "N"; }
+for ( ®i; N® ) { sout | i; }
+for ( ®i; N -~ 0® ) { sout | i; }
+const int start = 3, comp = 10, inc = 2;
 for ( ®i; start ~ comp ~ inc + 1® ) { sout | i; }
 \end{cfa}
+&
 \begin{cfa}
+sout | endl;
+sout | endl;
+sout | endl;
+sout | endl;
+sout | endl;
+sout | endl;
+sout | endl;
+sout | endl;
+sout | endl;
+sout | endl;
+sout | endl;
+sout | endl;
+sout | endl;
+sout | endl;
+sout | endl;
+sout | endl;
+sout | endl;
+sout | endl;
+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}
+&
 …
 empty
 empty
+zero
+A
 A A A A A A A A A A
 …
 4 6 8 10
 8 6 4 2
+N N N N N N N N N N
+1 2 3 4 5 6 7 8 9
+9 8 7 6 5 4 3 2 1
 6 9
 …
         int bar( int p ) {
                 ®i® += 1;                               §\C{// dependent on local variable}§
                 sout | ®i® | endl;
+                sout | ®i®;
+        }
         return bar;                                     §\C{// undefined because of local dependence}§
 …
 int main() {
         * [int]( int ) fp = foo();      §\C{// int (* fp)( int )}§
         sout | fp( 3 ) | endl;
+        sout | fp( 3 );
+}
 \end{cfa}
 …
 \begin{cfa}
 int x = 1, y = 2, z = 3;
 sout | x ®|® y ®|® z | endl;
+sout | x ®|® y ®|® z;
 \end{cfa}
+&
 …
 \begin{cfa}
 [int, [ int, int ] ] t1 = [ 1, [ 2, 3 ] ], t2 = [ 4, [ 5, 6 ] ];
 sout | t1 | t2 | endl;                                  §\C{// print tuples}§
+sout | t1 | t2;                                         §\C{// print tuples}§
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt]
 …
+&
 \begin{cfa}
 sout | x * 3 | y + 1 | z << 2 | x == y | (x | y) | (x || y) | (x > z ? 1 : 2) | endl;
+sout | x * 3 | y + 1 | z << 2 | x == y | (x | y) | (x || y) | (x > z ? 1 : 2);
 \end{cfa}
 \\
 …
 A separator does not appear at the start or end of a line.
 \begin{cfa}[belowskip=0pt]
 sout | 1 | 2 | 3 | endl;
+sout | 1 | 2 | 3;
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 …
 A separator does not appear before or after a character literal or variable.
 \begin{cfa}
 sout | '1' | '2' | '3' | endl;
+sout | '1' | '2' | '3';
 \end{cfa}
 …
 A separator does not appear before or after a null (empty) C string.
 \begin{cfa}
 sout | 1 | "" | 2 | "" | 3 | endl;
+sout | 1 | "" | 2 | "" | 3;
 \end{cfa}
 …
 \begin{cfa}[mathescape=off]
 sout | "x (" | 1 | "x [" | 2 | "x {" | 3 | "x =" | 4 | "x $" | 5 | "x £" | 6 | "x ¥"
                 | 7 | "x ¡" | 8 | "x ¿" | 9 | "x «" | 10 | endl;
+                | 7 | "x ¡" | 8 | "x ¿" | 9 | "x «" | 10;
 \end{cfa}
 %$
 …
 \begin{cfa}[belowskip=0pt]
 sout | 1 | ", x" | 2 | ". x" | 3 | "; x" | 4 | "! x" | 5 | "? x" | 6 | "% x"
                 | 7 | "¢ x" | 8 | "» x" | 9 | ") x" | 10 | "] x" | 11 | "} x" | endl;
+                | 7 | "¢ x" | 8 | "» x" | 9 | ") x" | 10 | "] x" | 11 | "} x";
 \end{cfa}
 \begin{cfa}[basicstyle=\tt,showspaces=true,aboveskip=0pt,belowskip=0pt]
 …
 A seperator does not appear before or after a C string begining/ending with the \Index*{ASCII} quote or whitespace characters: \lstinline[basicstyle=\tt,showspaces=true]@`'": \t\v\f\r\n@
 \begin{cfa}[belowskip=0pt]
 sout | "x`" | 1 | "`x'" | 2 | "'x\"" | 3 | "\"x:" | 4 | ":x " | 5 | " x\t" | 6 | "\tx" | endl;
+sout | "x`" | 1 | "`x'" | 2 | "'x\"" | 3 | "\"x:" | 4 | ":x " | 5 | " x\t" | 6 | "\tx";
 \end{cfa}
 \begin{cfa}[basicstyle=\tt,showspaces=true,showtabs=true,aboveskip=0pt,belowskip=0pt]
 …
 If a space is desired before or after one of the special string start/end characters, simply insert a space.
 \begin{cfa}[belowskip=0pt]
 sout | "x (§\color{red}\texttt{\textvisiblespace}§" | 1 | "§\color{red}\texttt{\textvisiblespace}§) x" | 2 | "§\color{red}\texttt{\textvisiblespace}§, x" | 3 | "§\color{red}\texttt{\textvisiblespace}§:x:§\color{red}\texttt{\textvisiblespace}§" | 4 | endl;
+sout | "x (§\color{red}\texttt{\textvisiblespace}§" | 1 | "§\color{red}\texttt{\textvisiblespace}§) x" | 2 | "§\color{red}\texttt{\textvisiblespace}§, x" | 3 | "§\color{red}\texttt{\textvisiblespace}§:x:§\color{red}\texttt{\textvisiblespace}§" | 4;
 \end{cfa}
 \begin{cfa}[basicstyle=\tt,showspaces=true,showtabs=true,aboveskip=0pt,belowskip=0pt]
 …
 \begin{cfa}[mathescape=off,belowskip=0pt]
 sepSet( sout, ", $" );                                          §\C{// set separator from " " to ", \$"}§
 sout | 1 | 2 | 3 | " \"" | ®sep® | "\"" | endl;
+sout | 1 | 2 | 3 | " \"" | ®sep® | "\"";
 \end{cfa}
 %$
 …
 \begin{cfa}[belowskip=0pt]
 sepSet( sout, " " );                                            §\C{// reset separator to " "}§
 sout | 1 | 2 | 3 | " \"" | ®sepGet( sout )® | "\"" | endl;
+sout | 1 | 2 | 3 | " \"" | ®sepGet( sout )® | "\"";
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt]
 …
 strcpy( store, sepGet( sout ) );                          §\C{// copy current separator}§
 sepSet( sout, "_" );                                            §\C{// change separator to underscore}§
 sout | 1 | 2 | 3 | endl;
+sout | 1 | 2 | 3;
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 …
 \begin{cfa}[belowskip=0pt]
 sepSet( sout, store );                                          §\C{// change separator back to original}§
 sout | 1 | 2 | 3 | endl;
+sout | 1 | 2 | 3;
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt]
 …
 \begin{cfa}[belowskip=0pt]
 sepSetTuple( sout, " " );                                       §\C{// set tuple separator from ", " to " "}§
 sout | t1 | t2 | " \"" | ®sepTuple® | "\"" | endl;
+sout | t1 | t2 | " \"" | ®sepTuple® | "\"";
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt]
 …
 \begin{cfa}[belowskip=0pt]
 sepSetTuple( sout, ", " );                                      §\C{// reset tuple separator to ", "}§
 sout | t1 | t2 | " \"" | ®sepGetTuple( sout )® | "\"" | endl;
+sout | t1 | t2 | " \"" | ®sepGetTuple( sout )® | "\"";
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt]
 …
 Manipulators \Indexc{sepDisable}\index{manipulator!sepDisable@©sepDisable©} and \Indexc{sepEnable}\index{manipulator!sepEnable@©sepEnable©} \emph{globally} toggle printing the separator, \ie the seperator is adjusted with respect to all subsequent printed items.
 \begin{cfa}[belowskip=0pt]
 sout | sepDisable | 1 | 2 | 3 | endl;           §\C{// globally turn off implicit separator}§
+sout | sepDisable | 1 | 2 | 3;                  §\C{// globally turn off implicit separator}§
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 …
 \end{cfa}
 \begin{cfa}[belowskip=0pt]
 sout | sepEnable | 1 | 2 | 3 | endl;            §\C{// globally turn on implicit separator}§
+sout | sepEnable | 1 | 2 | 3;           §\C{// globally turn on implicit separator}§
 \end{cfa}
 \begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
 …
 Manipulators \Indexc{sepOn}\index{manipulator!sepOn@©sepOn©} and \Indexc{sepOff}\index{manipulator!sepOff@©sepOff©} \emph{locally} toggle printing the separator, \ie the seperator is adjusted only with respect to the next printed item.
 \begin{cfa}[belowskip=0pt]
 sout | 1 | sepOff | 2 | 3 | endl;                       §\C{// locally turn off implicit separator}§
+sout | 1 | sepOff | 2 | 3;                      §\C{// locally turn off implicit separator}§
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 …
 \end{cfa}
 \begin{cfa}[belowskip=0pt]
 sout | sepDisable | 1 | sepOn | 2 | 3 | endl; §\C{// locally turn on implicit separator}§
+sout | sepDisable | 1 | sepOn | 2 | 3; §\C{// locally turn on implicit separator}§
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 …
 The tuple separator also responses to being turned on and off.
 \begin{cfa}[belowskip=0pt]
 sout | t1 | sepOff | t2 | endl;                         §\C{// locally turn on/off implicit separator}§
+sout | t1 | sepOff | t2;                                §\C{// locally turn on/off implicit separator}§
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 …
 use ©sep© to accomplish this functionality.
 \begin{cfa}[belowskip=0pt]
 sout | sepOn | 1 | 2 | 3 | sepOn | endl ;       §\C{// sepOn does nothing at start/end of line}§
+sout | sepOn | 1 | 2 | 3 | sepOn;       §\C{// sepOn does nothing at start/end of line}§
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 …
 \end{cfa}
 \begin{cfa}[belowskip=0pt]
 sout | sep | 1 | 2 | 3 | sep | endl ;           §\C{// use sep to print separator at start/end of line}§
+sout | sep | 1 | 2 | 3 | sep ;          §\C{// use sep to print separator at start/end of line}§
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 …
 int main( void ) {
         int x = 1, y = 2, z = 3;
         sout | x | y | z | endl;
+        sout | x | y | z;
         [int, [ int, int ] ] t1 = [ 1, [ 2, 3 ] ], t2 = [ 4, [ 5, 6 ] ];
         sout | t1 | t2 | endl;                                          // print tuples
         sout | x * 3 | y + 1 | z << 2 | x == y | (x | y) | (x || y) | (x > z ? 1 : 2) | endl;
         sout | 1 | 2 | 3 | endl;
         sout | '1' | '2' | '3' | endl;
         sout | 1 | "" | 2 | "" | 3 | endl;
+        sout | t1 | t2;                                         // print tuples
+        sout | x * 3 | y + 1 | z << 2 | x == y | (x | y) | (x || y) | (x > z ? 1 : 2);
+        sout | 1 | 2 | 3;
+        sout | '1' | '2' | '3';
+        sout | 1 | "" | 2 | "" | 3;
         sout | "x (" | 1 | "x [" | 2 | "x {" | 3 | "x =" | 4 | "x $" | 5 | "x £" | 6 | "x ¥"
                 | 7 | "x ¡" | 8 | "x ¿" | 9 | "x «" | 10 | endl;
+                | 7 | "x ¡" | 8 | "x ¿" | 9 | "x «" | 10;
         sout | 1 | ", x" | 2 | ". x" | 3 | "; x" | 4 | "! x" | 5 | "? x" | 6 | "% x"
                 | 7 | "¢ x" | 8 | "» x" | 9 | ") x" | 10 | "] x" | 11 | "} x" | endl;
         sout | "x`" | 1 | "`x'" | 2 | "'x\"" | 3 | "\"x:" | 4 | ":x " | 5 | " x\t" | 6 | "\tx" | endl;
         sout | "x ( " | 1 | " ) x" | 2 | " , x" | 3 | " :x: " | 4 | endl;
+                | 7 | "¢ x" | 8 | "» x" | 9 | ") x" | 10 | "] x" | 11 | "} x";
+        sout | "x`" | 1 | "`x'" | 2 | "'x\"" | 3 | "\"x:" | 4 | ":x " | 5 | " x\t" | 6 | "\tx";
+        sout | "x ( " | 1 | " ) x" | 2 | " , x" | 3 | " :x: " | 4;
         sepSet( sout, ", $" );                                          // set separator from " " to ", $"
         sout | 1 | 2 | 3 | " \"" | sep | "\"" | endl;
+        sout | 1 | 2 | 3 | " \"" | sep | "\"";
         sepSet( sout, " " );                                            // reset separator to " "
         sout | 1 | 2 | 3 | " \"" | sepGet( sout ) | "\"" | endl;
+        sout | 1 | 2 | 3 | " \"" | sepGet( sout ) | "\"";
         char store[sepSize];
         strcpy( store, sepGet( sout ) );
         sepSet( sout, "_" );
         sout | 1 | 2 | 3 | endl;
+        sout | 1 | 2 | 3;
         sepSet( sout, store );
         sout | 1 | 2 | 3 | endl;
+        sout | 1 | 2 | 3;
         sepSetTuple( sout, " " );                                       // set tuple separator from ", " to " "
         sout | t1 | t2 | " \"" | sepTuple | "\"" | endl;
+        sout | t1 | t2 | " \"" | sepTuple | "\"";
         sepSetTuple( sout, ", " );                                      // reset tuple separator to ", "
         sout | t1 | t2 | " \"" | sepGetTuple( sout ) | "\"" | endl;
         sout | sepDisable | 1 | 2 | 3 | endl;           // globally turn off implicit separator
         sout | sepEnable | 1 | 2 | 3 | endl;            // globally turn on implicit separator
         sout | 1 | sepOff | 2 | 3 | endl;                       // locally turn on implicit separator
         sout | sepDisable | 1 | sepOn | 2 | 3 | endl; // globally turn off implicit separator
+        sout | t1 | t2 | " \"" | sepGetTuple( sout ) | "\"";
+        sout | sepDisable | 1 | 2 | 3;          // globally turn off implicit separator
+        sout | sepEnable | 1 | 2 | 3;           // globally turn on implicit separator
+        sout | 1 | sepOff | 2 | 3;                      // locally turn on implicit separator
+        sout | sepDisable | 1 | sepOn | 2 | 3; // globally turn off implicit separator
         sout | sepEnable;
         sout | t1 | sepOff | t2 | endl;                         // locally turn on/off implicit separator
         sout | sepOn | 1 | 2 | 3 | sepOn | endl ;       // sepOn does nothing at start/end of line
         sout | sep | 1 | 2 | 3 | sep | endl ;           // use sep to print separator at start/end of line
+        sout | t1 | sepOff | t2;                                // locally turn on/off implicit separator
+        sout | sepOn | 1 | 2 | 3 | sepOn ;      // sepOn does nothing at start/end of line
+        sout | sep | 1 | 2 | 3 | sep ;          // use sep to print separator at start/end of line
+}
 …
         Fibonacci f1, f2;
         for ( int i = 1; i <= 10; i += 1 ) {
                 sout | next( &f1 ) | ' ' | next( &f2 ) | endl;
+                sout | next( &f1 ) | ' ' | next( &f2 );
         } // for
+}
 …
                 MyThread f[4];
+        }
         sout | global.value | endl;
+        sout | global.value;
+}
 \end{cfa}
 …
 void main( First * this ) {
         for ( int i = 0; i < 10; i += 1 ) {
                 sout | "First : Suspend No." | i + 1 | endl;
+                sout | "First : Suspend No." | i + 1;
                 yield();
+        }
 …
         wait( this->lock );
         for ( int i = 0; i < 10; i += 1 ) {
                 sout | "Second : Suspend No." | i + 1 | endl;
+                sout | "Second : Suspend No." | i + 1;
                 yield();
+        }
 …
 int main( void ) {
         signal_once lock;
         sout | "User main begin" | endl;
+        sout | "User main begin";
+        {
                 processor p;
 …
+                }
+        }
         sout | "User main end" | endl;
+        sout | "User main end";
+}
 \end{cfa}
 …
 void ?{}( Line * l ) {
         l->lnth = 0.0;
         sout | "default" | endl;
+        sout | "default";
+}
 …
 void ?{}( Line * l, float lnth ) {
         l->lnth = lnth;
         sout | "lnth" | l->lnth | endl;
+        sout | "lnth" | l->lnth;
+}
 …
 // destructor
 void ^?() {
         sout | "destroyed" | endl;
+        sout | "destroyed";
         l.lnth = 0.0;
+}
 …
 In particular, output of ©char© variable now print a character rather than the decimal ASCII value of the character.
 \begin{cfa}
 sout | 'x' | " " | (int)'x' | endl;
+sout | 'x' | " " | (int)'x';
 x 120
 \end{cfa}
 …
 #include <gmp>§\indexc{gmp}§
 int main( void ) {
         sout | "Factorial Numbers" | endl;
+        sout | "Factorial Numbers";
         Int fact = 1;
         sout | 0 | fact | endl;
+        sout | 0 | fact;
         for ( unsigned int i = 1; i <= 40; i += 1 ) {
                 fact *= i;
                 sout | i | fact | endl;
+                sout | i | fact;
+        }
+}

examples/ArrayN.c

-              rcdc02f2
+              r515a037
 forall(otype index_t)
+index_t offset_to_index(unsigned offset, index_t size)
+{
+index_t offset_to_index(unsigned offset, index_t size) {
     return [offset / size.0, offset % size.1];
+}
+int main(int argc, char* argv[])
+{
+int main(int argc, char* argv[]) {
     unsigned x = 0, y = 0, i = 0;
     unsigned sx = 4, sy = 4;
 …
     [x, y] = offset_to_index(6, [sx, sy]);
     sout | x | ' ' | y | endl;
+    sout | x | ' ' | y;
     return 0;

examples/gc_no_raii/src/internal/collector.c

-              rcdc02f2
+              r515a037
 void* gc_allocate(size_t target_size)
+{
         // sout | "Allocating " | target_size | " bytes" | endl;
+        // sout | "Allocating " | target_size | " bytes";
         size_t size = gc_compute_size(target_size + sizeof(gc_object_header));
         // sout | "Object header size: " | sizeof(gc_object_header) | " bytes" | endl;
         // sout | "Actual allocation size: " | size | " bytes" | endl;
+        // sout | "Object header size: " | sizeof(gc_object_header) | " bytes";
+        // sout | "Actual allocation size: " | size | " bytes";
         check(size < POOL_SIZE_BYTES);

examples/gc_no_raii/src/internal/state.h

rcdc02f2	r515a037
38	38	static inline bool gc_needs_collect(gc_state* state)
39	39	{
40		// sout \| "Used Space: " \| state->used_space \| " bytes" ~~\| endl~~;
	40	// sout \| "Used Space: " \| state->used_space \| " bytes";
41	41	return state->used_space * 2 > state->total_space;
42	42	}

examples/gc_no_raii/src/tools/print.h

rcdc02f2	r515a037
5	5	// #include <fstream.hfa>
6	6	//
7		// #define DEBUG_OUT(x) sout \| x ~~\| endl~~;
	7	// #define DEBUG_OUT(x) sout \| x;
8	8	//
9	9	// #else

examples/multicore.c

rcdc02f2	r515a037
15	15
16	16	int main(int argc, char* argv[]) {
17		// sout \| "User main begin" ~~\| endl~~;
	17	// sout \| "User main begin";
18	18	{
19	19	processor p;
…	…
22	22	}
23	23	}
24		// sout \| "User main end" ~~\| endl~~;
	24	// sout \| "User main end";
25	25	}

examples/prolog.c

-              rcdc02f2
+              r515a037
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Mar  8 22:09:39 2016
 // Update Count     : 5
+// Last Modified On : Tue Dec 11 23:27:19 2018
+// Update Count     : 6
 //
 #include <fstream.hfa>
 void printResult( int x ) { sout | "int" | endl; }
 void printResult( double x ) { sout | "double" | endl; }
 void printResult( char * x ) { sout | "char*" | endl; }
+void printResult( int x ) { sout | "int"; }
+void printResult( double x ) { sout | "double"; }
+void printResult( char * x ) { sout | "char*"; }
 void is_arithmetic( int x ) {}

examples/quad.c

-              rcdc02f2
+              r515a037
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Mar  8 22:07:02 2016
 // Update Count     : 8
+// Last Modified On : Tue Dec 11 23:26:58 2018
+// Update Count     : 9
 //
 …
 int main() {
         int N = 2;
         sout | "result of quad of" | N | "is" | quad( N ) | endl;
+        sout | "result of quad of" | N | "is" | quad( N );
+}

examples/square.c

-              rcdc02f2
+              r515a037
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Mar  8 22:05:48 2016
 // Update Count     : 27
+// Last Modified On : Tue Dec 11 23:28:24 2018
+// Update Count     : 28
 //
 …
 int main() {
 #if 0
         sout | "result of squaring 9 is " | endl;
+        sout | "result of squaring 9 is ";
         // char does not have multiplication.
 …
         } // ?*?
         char c = 9;
         sout | "char\t\t\t" | square( c ) | endl;
+        sout | "char\t\t\t" | square( c );
         sout | square( s ) | endl;
+        sout | square( s );
 #endif
         short s = 9;
 …
 #if 0
         signed int i = 9;
         sout | "signed int\t\t" | square( i ) | endl;
+        sout | "signed int\t\t" | square( i );
         unsigned int ui = 9;
         sout | "unsigned int\t\t" | square( ui ) | endl;
+        sout | "unsigned int\t\t" | square( ui );
         long int li = 9;
         sout | "signed long int\t\t" | square( li ) | endl;
+        sout | "signed long int\t\t" | square( li );
         unsigned long int uli = 9;
         sout | "unsigned long int\t" | square( uli ) | endl;
+        sout | "unsigned long int\t" | square( uli );
         signed long long int lli = 9;
         sout | "signed long long int\t" | square( lli ) | endl;
+        sout | "signed long long int\t" | square( lli );
         unsigned long long int ulli = 9;
         sout | "unsigned long long int\t" | square( ulli ) | endl;
+        sout | "unsigned long long int\t" | square( ulli );
         float f = 9.0;
         sout | "float\t\t\t" | square( f ) | endl;
+        sout | "float\t\t\t" | square( f );
         double d = 9.0;
         sout | "double\t\t\t" | square( d ) | endl;
+        sout | "double\t\t\t" | square( d );
         long double ld = 9.0;
         sout | "long double\t\t" | square( ld ) | endl;
+        sout | "long double\t\t" | square( ld );
 #endif
 } // main

examples/twice.c

-              rcdc02f2
+              r515a037
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Oct 19 21:52:57 2017
 // Update Count     : 46
+// Last Modified On : Tue Dec 11 23:28:08 2018
+// Update Count     : 47
 //
 …
 int main( void ) {
         sout | twice( ' ' ) | ' ' | twice( (signed char)0 ) | twice( (int)1 ) | twice( 3.2 ) | endl;
+        sout | twice( ' ' ) | ' ' | twice( (signed char)0 ) | twice( (int)1 ) | twice( 3.2 );
+}

examples/wrapper/src/main.c

-              rcdc02f2
+              r515a037
 #include "pointer.h"
+wrapper_t make_copy(wrapper_t copy)
+{
+wrapper_t make_copy(wrapper_t copy) {
         return copy;
+}
+int main(int argc, char const *argv[])
+{
+int main(int argc, char const *argv[]) {
         wrapper_t p = wrap(6);
+        sout | endl | "test started" | endl;
+        sout | nl | "test started";
         wrapper_t p2 = p;
         clear(&p);
         p = p2;
         wrapper_t p3 = make_copy(p2);
+        sout | endl | "test ended" | endl;
+        sout | nl | "test ended";
         return 0;
+}

examples/wrapper/src/pointer.h

rcdc02f2	r515a037
34	34	void ?{}(content_t* this)
35	35	{
36		sout \| "Constructing content" ~~\| endl~~;
	36	sout \| "Constructing content";
37	37	this->count = 0;
38	38	}
…	…
40	40	void ^?{}(content_t* this)
41	41	{
42		sout \| "Destroying content" ~~\| endl~~;
	42	sout \| "Destroying content";
43	43	}
44	44
…	…
53	53	void ?{}(wrapper_t* this)
54	54	{
55		sout \| "Constructing empty ref pointer" \| ~~endl \| end~~l;
	55	sout \| "Constructing empty ref pointer" \| nl;
56	56	this->ptr = NULL;
57	57	}
…	…
59	59	void ?{}(wrapper_t* this, wrapper_t rhs)
60	60	{
61		sout \| "Constructing ref pointer from copy" ~~\| endl~~;
	61	sout \| "Constructing ref pointer from copy";
62	62	this->ptr = rhs.ptr;
63	63	this->ptr->count++;
64		sout \| "Reference is " \| this->ptr->count \| ~~endl \| end~~l;
	64	sout \| "Reference is " \| this->ptr->count \| nl;
65	65	}
66	66
…	…
69	69	if(this->ptr)
70	70	{
71		sout \| "Destroying ref pointer" ~~\| endl~~;
	71	sout \| "Destroying ref pointer";
72	72	this->ptr->count--;
73		sout \| "Reference is " \| this->ptr->count \| ~~endl \| end~~l;
	73	sout \| "Reference is " \| this->ptr->count \| nl;
74	74	if(!this->ptr->count) delete(this->ptr);
75	75	}
76	76	else
77	77	{
78		sout \| "Destroying empty ref pointer" \| ~~endl \| end~~l;
	78	sout \| "Destroying empty ref pointer" \| nl;
79	79	}
80	80	}
…	…
82	82	wrapper_t ?=?(wrapper_t* this, wrapper_t rhs)
83	83	{
84		sout \| "Setting ref pointer" ~~\| endl~~;
	84	sout \| "Setting ref pointer";
85	85	if(this->ptr)
86	86	{
87	87	this->ptr->count--;
88		sout \| "Reference is " \| this->ptr->count \| ~~endl \| end~~l;
	88	sout \| "Reference is " \| this->ptr->count \| nl;
89	89	if(!this->ptr->count) delete(this->ptr);
90	90	}
91	91	this->ptr = rhs.ptr;
92	92	this->ptr->count++;
93		sout \| "Reference is " \| this->ptr->count \| ~~endl \| end~~l;
	93	sout \| "Reference is " \| this->ptr->count \| nl;
94	94	}
95	95
…	…
98	98	this->ptr = c;
99	99	this->ptr->count++;
100		sout \| "Setting ref pointer" ~~\| endl~~;
101		sout \| "Reference is " \| this->ptr->count \| ~~endl \| end~~l;
	100	sout \| "Setting ref pointer";
	101	sout \| "Reference is " \| this->ptr->count \| nl;
102	102	}
103	103
104	104	void clear(wrapper_t* this)
105	105	{
106		sout \| "Clearing ref pointer" ~~\| endl~~;
	106	sout \| "Clearing ref pointer";
107	107	this->ptr->count--;
108		sout \| "Reference is " \| this->ptr->count \| ~~endl \| end~~l;
	108	sout \| "Reference is " \| this->ptr->count \| nl;
109	109	if(!this->ptr->count) delete(this->ptr);
110	110	this->ptr = NULL;

examples/zero_one.c

rcdc02f2	r515a037
3	3	void foo(zero_t o)
4	4	{
5		sout \| "It's a Zero!" ~~\| endl~~;
	5	sout \| "It's a Zero!";
6	6	}
7	7
8	8	void foo(one_t o)
9	9	{
10		sout \| "It's a One!" ~~\| endl~~;
	10	sout \| "It's a One!";
11	11	}
12	12
13	13	void foo(int o)
14	14	{
15		sout \| "It's a Number!" ~~\| endl~~;
	15	sout \| "It's a Number!";
16	16	}
17	17

libcfa/src/fstream.cfa

-              rcdc02f2
+              r515a037
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Aug 10 18:19:40 2018
 // Update Count     : 284
+// Last Modified On : Wed Dec 12 08:34:28 2018
+// Update Count     : 298
 //
 …
 #include <stdarg.h>                                                                             // varargs
 #include <string.h>                                                                             // strlen
-#include <stdbool.h>                                                                    // true/false
 #include <float.h>                                                                              // DBL_DIG, LDBL_DIG
 #include <complex.h>                                                                    // creal, cimag
 …
 #define IO_MSG "I/O error: "
 void ?{}( ofstream & os, void * file, bool sepDefault, bool sepOnOff, const char * separator, const char * tupleSeparator ) {
+void ?{}( ofstream & os, void * file, bool sepDefault, bool sepOnOff, bool nlOnOff, bool nonlManip, const char * separator, const char * tupleSeparator ) {
         os.file = file;
         os.sepDefault = sepDefault;
         os.sepOnOff = sepOnOff;
+        os.nlOnOff = nlOnOff;
+        os.nonlManip = nonlManip;
         sepSet( os, separator );
         sepSetCur( os, sepGet( os ) );
 …
 bool getNL( ofstream & os ) { return os.sawNL; }
 void setNL( ofstream & os, bool state ) { os.sawNL = state; }
+bool getANL( ofstream & os ) { return os.nlOnOff; }
+bool getNonl( ofstream & os ) { return os.nonlManip; }
+void setNonl( ofstream & os, bool state ) { os.nonlManip = state; }
 // public
 …
 } // sepEnable
+void nlOn( ofstream & os ) { os.nlOnOff = true; }
+void nlOff( ofstream & os ) { os.nlOnOff = false; }
 const char * sepGet( ofstream & os ) { return os.separator; }
 void sepSet( ofstream & os, const char * s ) {
 …
         } // if
         #endif // __CFA_DEBUG__
         (os){ file, true, false, " ", ", " };
+        (os){ file, true, false, true, false, " ", ", " };
 } // open
 …
 } // fmt
 static ofstream soutFile = { (FILE *)(&_IO_2_1_stdout_), true, false, " ", ", " };
+static ofstream soutFile = { (FILE *)(&_IO_2_1_stdout_), true, false, true, false, " ", ", " };
 ofstream & sout = soutFile;
 static ofstream serrFile = { (FILE *)(&_IO_2_1_stderr_), true, false, " ", ", " };
+static ofstream serrFile = { (FILE *)(&_IO_2_1_stderr_), true, false, true, false, " ", ", " };
 ofstream & serr = serrFile;

libcfa/src/fstream.hfa

-              rcdc02f2
+              r515a037
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Aug 11 13:54:27 2018
 // Update Count     : 132
+// Last Modified On : Wed Dec 12 07:52:41 2018
+// Update Count     : 143
 //
 …
         bool sepDefault;
         bool sepOnOff;
+        bool nlOnOff;
+        bool nonlManip;
         bool sawNL;
         const char * sepCur;
 …
 bool getNL( ofstream & );
 void setNL( ofstream &, bool );
+bool getANL( ofstream & );
+bool getNonl( ofstream & );
+void setNonl( ofstream &, bool );
 // public
 …
 bool sepDisable( ofstream & );
 bool sepEnable( ofstream & );
+void nlOn( ofstream & );
+void nlOff( ofstream & );
 const char * sepGet( ofstream & );

libcfa/src/gmp.hfa

-              rcdc02f2
+              r515a037
 // Created On       : Tue Apr 19 08:43:43 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Dec  7 09:10:41 2017
 // Update Count     : 21
+// Last Modified On : Tue Dec  4 23:25:51 2018
+// Update Count     : 22
 //
 …
 } // ?|?
+static inline forall( dtype ostype | ostream( ostype ) )
+ostype & ?|?( ostype & os, Int mp ) {
+        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+        gmp_printf( "%Zd", mp.mpz );
+        sepOn( os );
+        return os;
+} // ?|?
+static inline forall( dtype ostype | ostream( ostype ) ) {
+        ostype & ?|?( ostype & os, Int mp ) {
+                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                gmp_printf( "%Zd", mp.mpz );
+                sepOn( os );
+                return os;
+        } // ?|?
+        void ?|?( ostype & os, Int mp ) {
+                (ostype)(os | mp); if ( getANL( os ) ) nl( os );
+        } // ?|?
+} // distribution
 // Local Variables: //

libcfa/src/iostream.cfa

-              rcdc02f2
+              r515a037
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Sep 26 18:22:57 2018
 // Update Count     : 474
+// Last Modified On : Tue Dec 11 22:02:03 2018
+// Update Count     : 546
 //
 …
 #include <stdio.h>
 #include <stdbool.h>                                                                    // true/false
 //#include <string.h>                                                                           // strlen, strcmp
+//#include <string.h>                                                                   // strlen, strcmp
 extern int strcmp (const char *__s1, const char *__s2) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
 extern size_t strlen (const char *__s) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
 …
                 return os;
         } // ?|?
+        ostype & ?|?( ostype & os, char ch ) {
+                fmt( os, "%c", ch );
+                if ( ch == '\n' ) setNL( os, true );
+                sepOff( os );
+                return os;
+        } // ?|?
+        ostype & ?|?( ostype & os, signed char c ) {
+                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                fmt( os, "%hhd", c );
+                return os;
+        } // ?|?
+        ostype & ?|?( ostype & os, unsigned char c ) {
+                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                fmt( os, "%hhu", c );
+                return os;
+        void ?|?( ostype & os, bool b ) {
+                (ostype)(os | b); if ( getANL( os ) ) nl( os );
+        } // ?|?
+        ostype & ?|?( ostype & os, char c ) {
+                fmt( os, "%c", c );
+                if ( c == '\n' ) setNL( os, true );
+                return sepOff( os );
+        } // ?|?
+        void ?|?( ostype & os, char c ) {
+                (ostype)(os | c); if ( getANL( os ) ) nl( os );
+        } // ?|?
+        ostype & ?|?( ostype & os, signed char sc ) {
+                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                fmt( os, "%hhd", sc );
+                return os;
+        } // ?|?
+        void ?|?( ostype & os, signed char sc ) {
+                (ostype)(os | sc); if ( getANL( os ) ) nl( os );
+        } // ?|?
+        ostype & ?|?( ostype & os, unsigned char usc ) {
+                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                fmt( os, "%hhu", usc );
+                return os;
+        } // ?|?
+        void ?|?( ostype & os, unsigned char usc ) {
+                (ostype)(os | usc); if ( getANL( os ) ) nl( os );
         } // ?|?
 …
                 return os;
         } // ?|?
+        void & ?|?( ostype & os, short int si ) {
+                (ostype)(os | si); if ( getANL( os ) ) nl( os );
+        } // ?|?
         ostype & ?|?( ostype & os, unsigned short int usi ) {
 …
                 return os;
         } // ?|?
+        void & ?|?( ostype & os, unsigned short int usi ) {
+                (ostype)(os | usi); if ( getANL( os ) ) nl( os );
+        } // ?|?
         ostype & ?|?( ostype & os, int i ) {
 …
                 return os;
         } // ?|?
+        void & ?|?( ostype & os, int i ) {
+                (ostype)(os | i); if ( getANL( os ) ) nl( os );
+        } // ?|?
         ostype & ?|?( ostype & os, unsigned int ui ) {
 …
                 return os;
         } // ?|?
+        void & ?|?( ostype & os, unsigned int ui ) {
+                (ostype)(os | ui); if ( getANL( os ) ) nl( os );
+        } // ?|?
         ostype & ?|?( ostype & os, long int li ) {
 …
                 return os;
         } // ?|?
+        void & ?|?( ostype & os, long int li ) {
+                (ostype)(os | li); if ( getANL( os ) ) nl( os );
+        } // ?|?
         ostype & ?|?( ostype & os, unsigned long int uli ) {
 …
                 return os;
         } // ?|?
+        void & ?|?( ostype & os, unsigned long int uli ) {
+                (ostype)(os | uli); if ( getANL( os ) ) nl( os );
+        } // ?|?
         ostype & ?|?( ostype & os, long long int lli ) {
 …
                 return os;
         } // ?|?
+        void & ?|?( ostype & os, long long int lli ) {
+                (ostype)(os | lli); if ( getANL( os ) ) nl( os );
+        } // ?|?
         ostype & ?|?( ostype & os, unsigned long long int ulli ) {
 …
                 return os;
         } // ?|?
+        void & ?|?( ostype & os, unsigned long long int ulli ) {
+                (ostype)(os | ulli); if ( getANL( os ) ) nl( os );
+        } // ?|?
         ostype & ?|?( ostype & os, float f ) {
 …
                 return os;
         } // ?|?
+        void & ?|?( ostype & os, float f ) {
+                (ostype)(os | f); if ( getANL( os ) ) nl( os );
+        } // ?|?
         ostype & ?|?( ostype & os, double d ) {
 …
                 return os;
         } // ?|?
+        void & ?|?( ostype & os, double d ) {
+                (ostype)(os | d); if ( getANL( os ) ) nl( os );
+        } // ?|?
         ostype & ?|?( ostype & os, long double ld ) {
 …
                 return os;
         } // ?|?
+        void & ?|?( ostype & os, long double ld ) {
+                (ostype)(os | ld); if ( getANL( os ) ) nl( os );
+        } // ?|?
         ostype & ?|?( ostype & os, float _Complex fc ) {
 …
                 return os;
         } // ?|?
+        void & ?|?( ostype & os, float _Complex fc ) {
+                (ostype)(os | fc); if ( getANL( os ) ) nl( os );
+        } // ?|?
         ostype & ?|?( ostype & os, double _Complex dc ) {
 …
                 return os;
         } // ?|?
+        void & ?|?( ostype & os, double _Complex dc ) {
+                (ostype)(os | dc); if ( getANL( os ) ) nl( os );
+        } // ?|?
         ostype & ?|?( ostype & os, long double _Complex ldc ) {
 …
                 fmt( os, "%.*Lg%+.*Lgi", LDBL_DIG, creall( ldc ), LDBL_DIG, cimagl( ldc ) );
                 return os;
+        } // ?|?
+        void & ?|?( ostype & os, long double _Complex ldc ) {
+                (ostype)(os | ldc); if ( getANL( os ) ) nl( os );
         } // ?|?
 …
                         // opening delimiters, no space after
                         ['('] : Open, ['['] : Open, ['{'] : Open,
                         ['='] : Open, ['$'] : Open, [(unsigned char)'£'] : Open, [(unsigned char)'¥'] : Open,
                         [(unsigned char)'¡'] : Open, [(unsigned char)'¿'] : Open, [(unsigned char)'«'] : Open,
+                        ['='] : Open, ['$'] : Open, [(unsigned char)'�'] : Open, [(unsigned char)'�'] : Open,
+                        [(unsigned char)'�'] : Open, [(unsigned char)'�'] : Open, [(unsigned char)'�'] : Open,
                         // closing delimiters, no space before
                         [','] : Close, ['.'] : Close, [';'] : Close, ['!'] : Close, ['?'] : Close,
                         ['%'] : Close, [(unsigned char)'¢'] : Close, [(unsigned char)'»'] : Close,
+                        ['%'] : Close, [(unsigned char)'�'] : Close, [(unsigned char)'�'] : Close,
                         [')'] : Close, [']'] : Close, ['}'] : Close,
                         // opening-closing delimiters, no space before or after
 …
                 return write( os, str, len );
         } // ?|?
+        void ?|?( ostype & os, const char * str ) {
+                (ostype)(os | str); if ( getANL( os ) ) nl( os );
+        } // ?|?
 //      ostype & ?|?( ostype & os, const char16_t * str ) {
 …
                 return os;
         } // ?|?
+        void ?|?( ostype & os, const void * p ) {
+                (ostype)(os | p); if ( getANL( os ) ) nl( os );
+        } // ?|?
         // manipulators
         ostype & ?|?( ostype & os, ostype & (* manip)( ostype & ) ) {
+                return manip( os );
+                (ostype)(manip( os ));
+                setNonl( os, false );                                                   // ignore nonl in middle
+                return os;
+        } // ?|?
+        void ?|?( ostype & os, ostype & (* manip)( ostype & ) ) {
+                (ostype)(manip( os ));
+                if ( getANL( os ) && ! getNonl( os ) ) nl( os ); // ignore nl if nonl at end
+                setNonl( os, false );
         } // ?|?
         ostype & sep( ostype & os ) {
+                os | sepGet( os );
+                return os;
+                return (ostype)(os | sepGet( os ));
         } // sep
         ostype & sepTuple( ostype & os ) {
+                os | sepGetTuple( os );
+                return os;
+                return os | sepGetTuple( os );
         } // sepTuple
         ostype & endl( ostype & os ) {
                 os | '\n';
+        ostype & nl( ostype & os ) {
+                (ostype)(os | '\n');
                 setNL( os, true );
                 flush( os );
+                sepOff( os );                                                                   // prepare for next line
+                return os;
+        } // endl
+                return sepOff( os );                                                    // prepare for next line
+        } // nl
+        ostype & nonl( ostype & os ) {
+                setNonl( os, true );                                                    // indicate nonl manipulator
+                return os;
+        } // nonl
         ostype & sepOn( ostype & os ) {
                 sepOn( os );
+                sepOn( os );                                                                    // call void returning
                 return os;
         } // sepOn
         ostype & sepOff( ostype & os ) {
                 sepOff( os );
+                sepOff( os );                                                                   // call void returning
                 return os;
         } // sepOff
         ostype & sepEnable( ostype & os ) {
                 sepEnable( os );
+                sepEnable( os );                                                                // call void returning
                 return os;
         } // sepEnable
         ostype & sepDisable( ostype & os ) {
                 sepDisable( os );
+                sepDisable( os );                                                               // call void returning
                 return os;
         } // sepDisable
+        ostype & nlOn( ostype & os ) {
+                nlOn( os );                                                                             // call void returning
+                return os;
+        } // nlOn
+        ostype & nlOff( ostype & os ) {
+                nlOff( os );                                                                    // call void returning
+                return os;
+        } // nlOff
 } // distribution
 // tuples
+forall( dtype ostype, otype T, ttype Params | writeable( T, ostype ) | { ostype & ?|?( ostype &, Params ); } )
+ostype & ?|?( ostype & os, T arg, Params rest ) {
+        os | arg;                                                                                       // print first argument
+        sepSetCur( os, sepGetTuple( os ) );                                     // switch to tuple separator
+        os | rest;                                                                                      // print remaining arguments
+        sepSetCur( os, sepGet( os ) );                                          // switch to regular separator
+        return os;
+} // ?|?
+forall( dtype ostype, otype T, ttype Params | writeable( T, ostype ) | { ostype & ?|?( ostype &, Params ); } ) {
+        ostype & ?|?( ostype & os, T arg, Params rest ) {
+                (ostype)(os | arg);                                                             // print first argument
+                sepSetCur( os, sepGetTuple( os ) );                             // switch to tuple separator
+                (ostype)(os | rest);                                                    // print remaining arguments
+                sepSetCur( os, sepGet( os ) );                                  // switch to regular separator
+                return os;
+        } // ?|?
+        void ?|?( ostype & os, T arg, Params rest ) {
+//              (ostype)(?|?( os, arg, rest )); if ( getANL( os ) ) nl( os );
+                (ostype)(os | arg);                                                             // print first argument
+                sepSetCur( os, sepGetTuple( os ) );                             // switch to tuple separator
+                (ostype)(os | rest);                                                    // print remaining arguments
+                sepSetCur( os, sepGet( os ) );                                  // switch to regular separator
+                if ( getANL( os ) ) nl( os );
+        } // ?|?
+} // distribution
 //---------------------------------------
 // writes the range [begin, end) to the given stream
 forall( dtype ostype, otype elt_type | writeable( elt_type, ostype ), otype iterator_type | iterator( iterator_type, elt_type ) )
 void write( iterator_type begin, iterator_type end, ostype & os ) {
         void print( elt_type i ) { os | i; }
         for_each( begin, end, print );
 } // ?|?
+forall( dtype ostype, otype elt_type | writeable( elt_type, ostype ), otype iterator_type | iterator( iterator_type, elt_type ) )
+void write_reverse( iterator_type begin, iterator_type end, ostype & os ) {
         void print( elt_type i ) { os | i; }
         for_each_reverse( begin, end, print );
 } // ?|?
+forall( dtype ostype, otype elt_type | writeable( elt_type, ostype ), otype iterator_type | iterator( iterator_type, elt_type ) ) {
+        void write( iterator_type begin, iterator_type end, ostype & os ) {
+                void print( elt_type i ) { os | i; }
+                for_each( begin, end, print );
+        } // ?|?
+        void write_reverse( iterator_type begin, iterator_type end, ostype & os ) {
+                void print( elt_type i ) { os | i; }
+                for_each_reverse( begin, end, print );
+        } // ?|?
+} // distribution
 //---------------------------------------
 …
         } // ?|?
         istype & endl( istype & is ) {
+        istype & nl( istype & is ) {
                 fmt( is, "%*[ \t\f\n\r\v]" );                                   // ignore whitespace
                 return is;
         } // endl
+        } // nl
 } // distribution

libcfa/src/iostream.hfa

-              rcdc02f2
+              r515a037
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Aug 11 08:22:49 2018
 // Update Count     : 156
+// Last Modified On : Tue Dec 11 22:01:31 2018
+// Update Count     : 213
 //
 …
         const char * sepGetCur( ostype & );                                     // get current separator string
         void sepSetCur( ostype &, const char * );                       // set current separator string
         bool getNL( ostype & );                                                 // check newline
+        bool getNL( ostype & );                                                         // check newline
         void setNL( ostype &, bool );                                           // saw newline
+        bool getANL( ostype & );                                                        // check auto newline
+        bool getNonl( ostype & );                                                       // check nonnl manipulator
+        void setNonl( ostype &, bool );                                         // set nonnl manipulator
         // public
         void sepOn( ostype & );                                                         // turn separator state on
         void sepOff( ostype & );                                                        // turn separator state off
         bool sepDisable( ostype & );                                            // set default state to off, and return previous state
+        bool sepEnable( ostype & );                                             // set default state to on, and return previous state
+        bool sepEnable( ostype & );                                                     // set default state to on, and return previous state
+        void nlOn( ostype & );                                                          // turn auto-newline state on
+        void nlOff( ostype & );                                                         // turn auto-newline state off
         const char * sepGet( ostype & );                                        // get separator string
 …
 forall( dtype ostype | ostream( ostype ) ) {
         ostype & ?|?( ostype &, bool );
+        void & ?|?( ostype &, bool );
         ostype & ?|?( ostype &, char );
+        void & ?|?( ostype &, char );
         ostype & ?|?( ostype &, signed char );
+        void & ?|?( ostype &, signed char );
         ostype & ?|?( ostype &, unsigned char );
+        void & ?|?( ostype &, unsigned char );
         ostype & ?|?( ostype &, short int );
+        void & ?|?( ostype &, short int );
         ostype & ?|?( ostype &, unsigned short int );
+        void & ?|?( ostype &, unsigned short int );
         ostype & ?|?( ostype &, int );
+        void & ?|?( ostype &, int );
         ostype & ?|?( ostype &, unsigned int );
+        void & ?|?( ostype &, unsigned int );
         ostype & ?|?( ostype &, long int );
+        void & ?|?( ostype &, long int );
         ostype & ?|?( ostype &, long long int );
+        void & ?|?( ostype &, long long int );
         ostype & ?|?( ostype &, unsigned long int );
+        void & ?|?( ostype &, unsigned long int );
         ostype & ?|?( ostype &, unsigned long long int );
+        void & ?|?( ostype &, unsigned long long int );
         ostype & ?|?( ostype &, float ); // FIX ME: should not be required
+        void & ?|?( ostype &, float ); // FIX ME: should not be required
         ostype & ?|?( ostype &, double );
+        void & ?|?( ostype &, double );
         ostype & ?|?( ostype &, long double );
+        void & ?|?( ostype &, long double );
         ostype & ?|?( ostype &, float _Complex );
+        void & ?|?( ostype &, float _Complex );
         ostype & ?|?( ostype &, double _Complex );
+        void & ?|?( ostype &, double _Complex );
         ostype & ?|?( ostype &, long double _Complex );
+        void & ?|?( ostype &, long double _Complex );
         ostype & ?|?( ostype &, const char * );
+        void & ?|?( ostype &, const char * );
         // ostype & ?|?( ostype &, const char16_t * );
 #if ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 ) // char32_t == wchar_t => ambiguous
 …
         // ostype & ?|?( ostype &, const wchar_t * );
         ostype & ?|?( ostype &, const void * );
+        void & ?|?( ostype &, const void * );
         // manipulators
         ostype & ?|?( ostype &, ostype & (*)( ostype & ) );
+        ostype & endl( ostype & );
+        void ?|?( ostype &, ostype & (*)( ostype & ) );
+        ostype & nl( ostype & );
+        ostype & nonl( ostype & );
         ostype & sep( ostype & );
         ostype & sepTuple( ostype & );
 …
         ostype & sepDisable( ostype & );
         ostype & sepEnable( ostype & );
+        ostype & nlOn( ostype & );
+        ostype & nlOff( ostype & );
 } // distribution
 // tuples
+forall( dtype ostype, otype T, ttype Params | writeable( T, ostype ) | { ostype & ?|?( ostype &, Params ); } )
+ostype & ?|?( ostype & os, T arg, Params rest );
+forall( dtype ostype, otype T, ttype Params | writeable( T, ostype ) | { ostype & ?|?( ostype &, Params ); } ) {
+        ostype & ?|?( ostype & os, T arg, Params rest );
+        void ?|?( ostype & os, T arg, Params rest );
+} // distribution
 // writes the range [begin, end) to the given stream
+forall( dtype ostype, otype elt_type | writeable( elt_type, ostype ), otype iterator_type | iterator( iterator_type, elt_type ) )
+void write( iterator_type begin, iterator_type end, ostype & os );
+forall( dtype ostype, otype elt_type | writeable( elt_type, ostype ), otype iterator_type | iterator( iterator_type, elt_type ) )
+void write_reverse( iterator_type begin, iterator_type end, ostype & os );
+forall( dtype ostype, otype elt_type | writeable( elt_type, ostype ), otype iterator_type | iterator( iterator_type, elt_type ) ) {
+        void write( iterator_type begin, iterator_type end, ostype & os );
+        void write_reverse( iterator_type begin, iterator_type end, ostype & os );
+} // distribution
 //---------------------------------------
 …
         // manipulators
         istype & ?|?( istype &, istype & (*)( istype & ) );
         istype & endl( istype & is );
+        istype & nl( istype & is );
 } // distribution
 …
+#include <time_t.hfa>                                                                           // Duration (constructors) / Time (constructors)
+forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype & os, Duration dur );
+forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype & os, Time time );
+#include <time_t.hfa>                                                                   // Duration (constructors) / Time (constructors)
+forall( dtype ostype | ostream( ostype ) ) {
+        ostype & ?|?( ostype & os, Duration dur );
+        void ?|?( ostype & os, Duration dur );
+        ostype & ?|?( ostype & os, Time time );
+        void ?|?( ostype & os, Time time );
+} // distribution
 // Local Variables: //

libcfa/src/iterator.cfa

rcdc02f2	r515a037
10	10	// Created On : Wed May 27 17:56:53 2015
11	11	// Last Modified By : Peter A. Buhr
12		// Last Modified On : ~~Wed Sep 26 18:23:10~~ 2018
	12	// Last Modified On : Fri Nov 2 07:17:37 2018
13	13	// Update Count : 29
14	14	//

libcfa/src/rational.cfa

-              rcdc02f2
+              r515a037
 // Created On       : Wed Apr  6 17:54:28 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jun  2 09:24:33 2018
 // Update Count     : 162
+// Last Modified On : Tue Dec 11 22:02:29 2018
+// Update Count     : 168
 //
 …
         static RationalImpl simplify( RationalImpl & n, RationalImpl & d ) {
                 if ( d == (RationalImpl){0} ) {
                         serr | "Invalid rational number construction: denominator cannot be equal to 0." | endl;
+                        serr | "Invalid rational number construction: denominator cannot be equal to 0.";
                         exit( EXIT_FAILURE );
                 } // exit
 …
         } // ?|?
+        forall( dtype ostype | ostream( ostype ) | { ostype & ?|?( ostype &, RationalImpl ); } )
+        ostype & ?|?( ostype & os, Rational(RationalImpl ) r ) {
+                return os | r.numerator | '/' | r.denominator;
+        } // ?|?
+        forall( dtype ostype | ostream( ostype ) | { ostype & ?|?( ostype &, RationalImpl ); } ) {
+                ostype & ?|?( ostype & os, Rational(RationalImpl) r ) {
+                        return os | r.numerator | '/' | r.denominator;
+                } // ?|?
+                void ?|?( ostype & os, Rational(RationalImpl) r ) {
+                        (ostype)(os | r); if ( getANL( os ) ) nl( os );
+                } // ?|?
+        } // distribution
 } // distribution

libcfa/src/rational.hfa

-              rcdc02f2
+              r515a037
 // Created On       : Wed Apr  6 17:56:25 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jun  2 09:10:01 2018
 // Update Count     : 105
+// Last Modified On : Tue Dec  4 23:07:46 2018
+// Update Count     : 106
 //
 …
         istype & ?|?( istype &, Rational(RationalImpl) & );
+        forall( dtype ostype | ostream( ostype ) | { ostype & ?|?( ostype &, RationalImpl ); } )
+        ostype & ?|?( ostype &, Rational(RationalImpl ) );
+        forall( dtype ostype | ostream( ostype ) | { ostype & ?|?( ostype &, RationalImpl ); } ) {
+                ostype & ?|?( ostype &, Rational(RationalImpl) );
+                void ?|?( ostype &, Rational(RationalImpl) );
+        } // distribution
 } // distribution

libcfa/src/time.cfa

-              rcdc02f2
+              r515a037
 // Created On       : Tue Mar 27 13:33:14 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun May  6 22:26:00 2018
 // Update Count     : 37
+// Last Modified On : Tue Dec 11 21:32:15 2018
+// Update Count     : 53
 //
 …
+forall( dtype ostype | ostream( ostype ) )
+ostype & ?|?( ostype & os, Duration dur ) with( dur ) {
+        os | tv / TIMEGRAN;                                                                     // print seconds
+        long int ns = (tv < 0 ? -tv : tv) % TIMEGRAN;           // compute nanoseconds
+        if ( ns != 0 ) {                                                                        // some ?
+                char buf[16];
+                os | nanomsd( ns, buf );                                                // print nanoseconds
+        } // if
+        return os;
+} // ?|?
+forall( dtype ostype | ostream( ostype ) ) {
+        ostype & ?|?( ostype & os, Duration dur ) with( dur ) {
+                (ostype)(os | tv / TIMEGRAN);                                   // print seconds
+                long int ns = (tv < 0 ? -tv : tv) % TIMEGRAN;   // compute nanoseconds
+                if ( ns != 0 ) {                                                                // some ?
+                        char buf[16];
+                        (ostype)(os | nanomsd( ns, buf ));                      // print nanoseconds
+                } // if
+                return os;
+        } // ?|?
+        void ?|?( ostype & os, Duration dur ) with( dur ) {
+                (ostype)(os | dur); if ( getANL( os ) ) nl( os );
+        } // ?|?
+} // distribution
 …
 } // strftime
+forall( dtype ostype | ostream( ostype ) )
+ostype & ?|?( ostype & os, Time time ) with( time ) {
+        char buf[32];                                                                           // at least 26
+        time_t s = tv / TIMEGRAN;
+    ctime_r( &s, (char *)&buf );                                                // 26 characters: "Wed Jun 30 21:49:08 1993\n"
+        buf[24] = '\0';                                                                         // remove trailing '\n'
+        long int ns = (tv < 0 ? -tv : tv) % TIMEGRAN;           // compute nanoseconds
+        if ( ns == 0 ) {                                                                        // none ?
+                os | buf;                                                                               // print date/time/year
+        } else {
+                buf[19] = '\0';                                                                 // truncate to "Wed Jun 30 21:49:08"
+                os | buf;                                                                               // print date/time
+                char buf2[16];
+                nanomsd( ns, buf2 );                                                    // compute nanoseconds
+                os | buf2 | ' ' | &buf[20];                                             // print nanoseconds and year
+        } // if
+        return os;
+} // ?|?
+forall( dtype ostype | ostream( ostype ) ) {
+        ostype & ?|?( ostype & os, Time time ) with( time ) {
+                char buf[32];                                                                   // at least 26
+                time_t s = tv / TIMEGRAN;
+                ctime_r( &s, (char *)&buf );                                    // 26 characters: "Wed Jun 30 21:49:08 1993\n"
+                buf[24] = '\0';                                                                 // remove trailing '\n'
+                long int ns = (tv < 0 ? -tv : tv) % TIMEGRAN;   // compute nanoseconds
+                if ( ns == 0 ) {                                                                // none ?
+                        (ostype)(os | buf);                                                     // print date/time/year
+                } else {
+                        buf[19] = '\0';                                                         // truncate to "Wed Jun 30 21:49:08"
+                        char buf2[16];
+                        nanomsd( ns, buf2 );                                            // compute nanoseconds
+                        (ostype)(os | buf | buf2 | ' ' | &buf[20]);     // print date/time, nanoseconds and year
+                } // if
+                return os;
+        } // ?|?
+        void ?|?( ostype & os, Time time ) with( time ) {
+                (ostype)(os | time); if ( getANL( os ) ) nl( os );
+        } // ?|?
+} // distribution
 // Local Variables: //

src/Parser/DeclarationNode.cc

-              rcdc02f2
+              r515a037
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 20 14:56:54 2018
 // Update Count     : 1107
+// Last Modified On : Thu Nov  1 20:54:26 2018
+// Update Count     : 1108
 //
 …
+}
 DeclarationNode * DeclarationNode::newTypeof( ExpressionNode * expr ) {
         DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Typeof );
+DeclarationNode * DeclarationNode::newTypeof( ExpressionNode * expr, bool basetypeof ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->type = new TypeData( basetypeof ? TypeData::Basetypeof : TypeData::Typeof );
         newnode->type->typeexpr = expr;
         return newnode;

src/Parser/ParseNode.h

-              rcdc02f2
+              r515a037
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Aug  4 09:39:40 2018
 // Update Count     : 853
+// Last Modified On : Thu Nov  1 20:54:53 2018
+// Update Count     : 854
 //
 …
         static DeclarationNode * newBitfield( ExpressionNode * size );
         static DeclarationNode * newTuple( DeclarationNode * members );
         static DeclarationNode * newTypeof( ExpressionNode * expr );
+        static DeclarationNode * newTypeof( ExpressionNode * expr, bool basetypeof = false );
         static DeclarationNode * newAttr( const std::string *, ExpressionNode * expr ); // @ attributes
         static DeclarationNode * newAttr( const std::string *, DeclarationNode * type ); // @ attributes

src/Parser/TypeData.cc

-              rcdc02f2
+              r515a037
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 20 14:39:31 2018
 // Update Count     : 622
+// Last Modified On : Fri Nov  2 07:54:26 2018
+// Update Count     : 624
 //
 …
                 break;
           case Typeof:
+          case Basetypeof:
                 // typeexpr = new Typeof_t;
                 typeexpr = nullptr;
 …
                 break;
           case Typeof:
+          case Basetypeof:
                 // delete typeexpr->expr;
                 delete typeexpr;
 …
                 break;
           case Typeof:
+          case Basetypeof:
                 newtype->typeexpr = maybeClone( typeexpr );
                 break;
 …
                 } // if
                 break;
+          case Basetypeof:
+                os << "base-";
+                #if defined(__GNUC__) && __GNUC__ >= 7
+                        __attribute__((fallthrough));
+                #endif
           case Typeof:
                 os << "type-of expression ";
 …
           case Tuple:
           case Typeof:
+          case Basetypeof:
           case Builtin:
                 assertf(false, "Tried to get leaf name from kind without a name: %d", kind);
 …
         switch ( td->kind ) {
           case TypeData::Unknown:
                 // fill in implicit int
                 return new BasicType( buildQualifiers( td ), BasicType::SignedInt );
+                        // fill in implicit int
+                        return new BasicType( buildQualifiers( td ), BasicType::SignedInt );
           case TypeData::Basic:
                 return buildBasicType( td );
+                        return buildBasicType( td );
           case TypeData::Pointer:
                 return buildPointer( td );
+                        return buildPointer( td );
           case TypeData::Array:
                 return buildArray( td );
+                        return buildArray( td );
           case TypeData::Reference:
                 return buildReference( td );
+                        return buildReference( td );
           case TypeData::Function:
                 return buildFunction( td );
+                        return buildFunction( td );
           case TypeData::AggregateInst:
                 return buildAggInst( td );
+                        return buildAggInst( td );
           case TypeData::EnumConstant:
                 // the name gets filled in later -- by SymTab::Validate
                 return new EnumInstType( buildQualifiers( td ), "" );
+                        // the name gets filled in later -- by SymTab::Validate
+                        return new EnumInstType( buildQualifiers( td ), "" );
           case TypeData::SymbolicInst:
                 return buildSymbolicInst( td );
+                        return buildSymbolicInst( td );
           case TypeData::Tuple:
                 return buildTuple( td );
+                        return buildTuple( td );
           case TypeData::Typeof:
+                return buildTypeof( td );
+          case TypeData::Basetypeof:
+                        return buildTypeof( td );
           case TypeData::Builtin:
                 if(td->builtintype == DeclarationNode::Zero) {
                         return new ZeroType( noQualifiers );
+                }
                 else if(td->builtintype == DeclarationNode::One) {
                         return new OneType( noQualifiers );
+                }
                 else {
                         return new VarArgsType( buildQualifiers( td ) );
+                }
+                        if (td->builtintype == DeclarationNode::Zero) {
+                                return new ZeroType( noQualifiers );
+                        }
+                        else if (td->builtintype == DeclarationNode::One) {
+                                return new OneType( noQualifiers );
+                        }
+                        else {
+                                return new VarArgsType( buildQualifiers( td ) );
+                        }
           case TypeData::GlobalScope:
                 return new GlobalScopeType();
+                        return new GlobalScopeType();
                 case TypeData::Qualified:
                 return new QualifiedType( buildQualifiers( td ), typebuild( td->qualified.parent ), typebuild( td->qualified.child ) );
+                        return new QualifiedType( buildQualifiers( td ), typebuild( td->qualified.parent ), typebuild( td->qualified.child ) );
           case TypeData::Symbolic:
           case TypeData::Enum:
           case TypeData::Aggregate:
                 assert( false );
+                        assert( false );
         } // switch
 …
 TypeofType * buildTypeof( const TypeData * td ) {
         assert( td->kind == TypeData::Typeof );
+        assert( td->kind == TypeData::Typeof || td->kind == TypeData::Basetypeof );
         assert( td->typeexpr );
         // assert( td->typeexpr->expr );
+        return new TypeofType( buildQualifiers( td ), td->typeexpr->build() );
+        return new TypeofType{
+                buildQualifiers( td ), td->typeexpr->build(), td->kind == TypeData::Basetypeof };
 } // buildTypeof

src/Parser/TypeData.h

-              rcdc02f2
+              r515a037
 // Created On       : Sat May 16 15:18:36 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 20 13:56:40 2018
 // Update Count     : 195
+// Last Modified On : Thu Nov  1 20:56:46 2018
+// Update Count     : 196
 //
 …
 struct TypeData {
         enum Kind { Basic, Pointer, Reference, Array, Function, Aggregate, AggregateInst, Enum, EnumConstant, Symbolic,
                                 SymbolicInst, Tuple, Typeof, Builtin, GlobalScope, Qualified, Unknown };
+                                SymbolicInst, Tuple, Typeof, Basetypeof, Builtin, GlobalScope, Qualified, Unknown };
         struct Aggregate_t {

src/Parser/lex.ll

rcdc02f2	r515a037
10	10	* Created On : Sat Sep 22 08:58:10 2001
11	11	* Last Modified By : Peter A. Buhr
12		* Last Modified On : ~~Sat Oct 20 09:42:4~~5 2018
	12	* Last Modified On : Thu Nov 1 20:57:35 2018
13	13	* Update Count : 687
14	14	*/

src/Parser/parser.yy

-              rcdc02f2
+              r515a037
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Oct 21 08:27:29 2018
 // Update Count     : 4045
+// Last Modified On : Thu Nov  8 18:08:23 2018
+// Update Count     : 4052
 //
 …
 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->get_expr());
         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 ) ) );
         } // if
         return new ForCtrl(
                 distAttr( DeclarationNode::newTypeof( type ), DeclarationNode::newName( index )->addInitializer( new InitializerNode( start ) ) ),
+                distAttr( DeclarationNode::newTypeof( type, true ), DeclarationNode::newName( index )->addInitializer( new InitializerNode( start ) ) ),
                 new ExpressionNode( build_binary_val( compop, new ExpressionNode( build_varref( new string( *index ) ) ), comp ) ),
                 new ExpressionNode( build_binary_val( compop == OperKinds::LThan || compop == OperKinds::LEThan ? // choose += or -= for upto/downto
                                                                                           OperKinds::PlusAssn : OperKinds::MinusAssn, new ExpressionNode( build_varref( new string( *index ) ) ), inc ) ) );
+<<<<<<< HEAD
+=======
+} // forCtrl
+ForCtrl * forCtrl( ExpressionNode * type, ExpressionNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
+        if ( NameExpr * identifier = dynamic_cast<NameExpr *>(index->get_expr()) ) {
+                return forCtrl( type, new string( identifier->name ), start, compop, comp, inc );
+        } else {
+                SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed" ); return nullptr;
+        } // if
+>>>>>>> master
 } // forCtrl
 …
         | FOR '(' push for_control_expression ')' statement pop
                 { $$ = new StatementNode( build_for( $4, $6 ) ); }
+        | FOR '(' ')' statement                                                         // CFA => for ( ;; )
+                { $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), $4 ) ); }
+        ;
 for_control_expression:
+<<<<<<< HEAD
         comma_expression_opt                                                            // CFA
+                {
 …
                         } // if
+                }
+=======
+        comma_expression                                                                        // CFA
+                { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
+                                                OperKinds::LThan, $1->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
+>>>>>>> master
         | constant_expression inclexcl constant_expression      // CFA
                 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
         | constant_expression inclexcl constant_expression '~' constant_expression // CFA
                 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, $5 ); }
+<<<<<<< HEAD
         | comma_expression_opt ';' comma_expression                     // CFA
+                {
 …
+                }
         | comma_expression_opt ';' comma_expression_opt ';' comma_expression_opt
+=======
+        | comma_expression ';' comma_expression                         // CFA
+                { $$ = forCtrl( $3, $1, new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
+                                                OperKinds::LThan, $3->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
+        | comma_expression ';' constant_expression inclexcl constant_expression // CFA
+                { $$ = forCtrl( $3, $1, $3->clone(), $4, $5, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
+        | comma_expression ';' constant_expression inclexcl constant_expression '~' constant_expression // CFA
+                { $$ = forCtrl( $3, $1, $3->clone(), $4, $5, $7 ); }
+        | comma_expression ';' comma_expression_opt ';' comma_expression_opt
+>>>>>>> master
                 { $$ = new ForCtrl( $1, $3, $5 ); }
+        | ';' comma_expression_opt ';' comma_expression_opt
+                { $$ = new ForCtrl( (ExpressionNode * )nullptr, $2, $4 ); }
         | declaration comma_expression_opt ';' comma_expression_opt // C99, declaration has ';'
                 { $$ = new ForCtrl( $1, $2, $4 ); }
 …
 indirect_type:
         TYPEOF '(' type ')'                                                                     // GCC: typeof(x) y;
+        TYPEOF '(' type ')'                                                                     // GCC: typeof( x ) y;
                 { $$ = $3; }
         | TYPEOF '(' comma_expression ')'                                       // GCC: typeof(a+b) y;
+        | TYPEOF '(' comma_expression ')'                                       // GCC: typeof( a+b ) y;
                 { $$ = DeclarationNode::newTypeof( $3 ); }
+<<<<<<< HEAD
         | BASETYPEOF '(' type ')'                                                       // CFA: basetypeof(x) y;
                 { $$ = $3; }
 …
                 { $$ = DeclarationNode::newTypeof( $3 ); }
         | ATTR_TYPEGENname '(' type ')'                                         // CFA: e.g., @type(x) y;
+=======
+        | BASETYPEOF '(' type ')'                                                       // CFA: basetypeof( x ) y;
+                { $$ = DeclarationNode::newTypeof( new ExpressionNode( new TypeExpr( maybeMoveBuildType( $3 ) ) ), true ); }
+        | BASETYPEOF '(' comma_expression ')'                           // CFA: basetypeof( a+b ) y;
+                { $$ = DeclarationNode::newTypeof( $3, true ); }
+        | ATTR_TYPEGENname '(' type ')'                                         // CFA: e.g., @type( x ) y;
+>>>>>>> master
                 { $$ = DeclarationNode::newAttr( $1, $3 ); }
         | ATTR_TYPEGENname '(' comma_expression ')'                     // CFA: e.g., @type(a+b) y;
+        | ATTR_TYPEGENname '(' comma_expression ')'                     // CFA: e.g., @type( a+b ) y;
                 { $$ = DeclarationNode::newAttr( $1, $3 ); }
         | ZERO_T                                                                                        // CFA

src/ResolvExpr/AlternativeFinder.cc

-              rcdc02f2
+              r515a037
 // Created On       : Sat May 16 23:52:08 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Feb 17 11:19:39 2018
 // Update Count     : 33
+// Last Modified On : Thu Nov  1 21:00:56 2018
+// Update Count     : 34
 //
 …
                 /// Gets name from untyped member expression (member must be NameExpr)
                 const std::string& get_member_name( UntypedMemberExpr *memberExpr ) {
+                        if ( dynamic_cast< ConstantExpr * >( memberExpr->get_member() ) ) {
+                                SemanticError( memberExpr, "Indexed access to struct fields unsupported: " );
+                        } // if
                         NameExpr * nameExpr = dynamic_cast< NameExpr * >( memberExpr->get_member() );
                         assert( nameExpr );

src/ResolvExpr/ResolveTypeof.cc

-              rcdc02f2
+              r515a037
                 std::cerr << std::endl;
 #endif
+                if ( typeofType->expr ) {
+                // pass on null expression
+                if ( ! typeofType->expr ) return typeofType;
+                bool isBasetypeof = typeofType->is_basetypeof;
+                auto oldQuals = typeofType->get_qualifiers().val;
+                Type* newType;
+                if ( TypeExpr* tyExpr = dynamic_cast<TypeExpr*>(typeofType->expr) ) {
+                        // typeof wrapping type
+                        newType = tyExpr->type;
+                        tyExpr->type = nullptr;
+                        delete tyExpr;
+                } else {
+                        // typeof wrapping expression
                         Expression * newExpr = resolveInVoidContext( typeofType->expr, indexer );
                         assert( newExpr->result && ! newExpr->result->isVoid() );
                         Type * newType = newExpr->result;
+                        newType = newExpr->result;
                         newExpr->result = nullptr;
                         delete typeofType;
                         delete newExpr;
+                        return newType;
+                } // if
+                return typeofType;
+                }
+                // clear qualifiers for base, combine with typeoftype quals in any case
+                if ( isBasetypeof ) {
+                        // replace basetypeof(<enum>) by int
+                        if ( dynamic_cast<EnumInstType*>(newType) ) {
+                                Type* newerType =
+                                        new BasicType{ newType->get_qualifiers(), BasicType::SignedInt,
+                                        newType->attributes };
+                                delete newType;
+                                newType = newerType;
+                        }
+                        newType->get_qualifiers().val
+                                = ( newType->get_qualifiers().val & ~Type::Qualifiers::Mask ) | oldQuals;
+                } else {
+                        newType->get_qualifiers().val |= oldQuals;
+                }
+                return newType;
+        }
 } // namespace ResolvExpr

src/SynTree/Type.h

-              rcdc02f2
+              r515a037
 class TypeofType : public Type {
   public:
+        Expression *expr;
+        TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        Expression *expr;    ///< expression to take the type of
+        bool is_basetypeof;  ///< true iff is basetypeof type
+        TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        TypeofType( const Type::Qualifiers & tq, Expression *expr, bool is_basetypeof,
+                const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         TypeofType( const TypeofType& );
         virtual ~TypeofType();

src/SynTree/TypeofType.cc

-              rcdc02f2
+              r515a037
 class Attribute;
+TypeofType::TypeofType( const Type::Qualifiers &tq, Expression *expr, const std::list< Attribute * > & attributes ) : Type( tq, attributes ), expr( expr ) {
+}
+TypeofType::TypeofType( const Type::Qualifiers &tq, Expression *expr,
+        const std::list< Attribute * > & attributes )
+: Type( tq, attributes ), expr( expr ), is_basetypeof(false) {}
+TypeofType::TypeofType( const TypeofType &other ) : Type( other ), expr( maybeClone( other.expr ) ) {
+}
+TypeofType::TypeofType( const Type::Qualifiers &tq, Expression *expr, bool is_basetypeof,
+        const std::list< Attribute * > & attributes )
+: Type( tq, attributes ), expr( expr ), is_basetypeof( is_basetypeof ) {}
+TypeofType::TypeofType( const TypeofType &other )
+: Type( other ), expr( maybeClone( other.expr ) ), is_basetypeof( other.is_basetypeof ) {}
 TypeofType::~TypeofType() {
 …
 void TypeofType::print( std::ostream &os, Indenter indent ) const {
         Type::print( os, indent );
+        if ( is_basetypeof ) { os << "base-"; }
         os << "type-of expression ";
         if ( expr ) {

tests/.expect/alloc-ERROR.txt

-              rcdc02f2
+              r515a037
 alloc.c:265:1 error: No reasonable alternatives for expression Applying untyped:
+alloc.cfa:265:1 error: No reasonable alternatives for expression Applying untyped:
   Name: ?=?
 ...to:
 …
 alloc.c:266:1 error: No reasonable alternatives for expression Applying untyped:
+alloc.cfa:266:1 error: No reasonable alternatives for expression Applying untyped:
   Name: ?=?
 ...to:
 …
 alloc.c:267:1 error: No reasonable alternatives for expression Applying untyped:
+alloc.cfa:267:1 error: No reasonable alternatives for expression Applying untyped:
   Name: ?=?
 ...to:
 …
 alloc.c:268:1 error: No reasonable alternatives for expression Applying untyped:
+alloc.cfa:268:1 error: No reasonable alternatives for expression Applying untyped:
   Name: ?=?
 ...to:

tests/.expect/castError.txt

-              rcdc02f2
+              r515a037
 castError.c:7:1 error: Cannot choose between 3 alternatives for expression
+castError.cfa:7:1 error: Cannot choose between 3 alternatives for expression
 Cast of:
   Name: f
 ... to:
   charAlternatives are:
+  char Alternatives are:
 Cost ( 1, 0, 0, 0 ): Cast of:
      Variable Expression: f: function

tests/.expect/completeTypeError.txt

-              rcdc02f2
+              r515a037
 completeTypeError.c:33:1 error: No reasonable alternatives for expression Applying untyped:
+completeTypeError.cfa:33:1 error: No reasonable alternatives for expression Applying untyped:
   Name: *?
 ...to:
   Name: v
 completeTypeError.c:34:1 error: No reasonable alternatives for expression Applying untyped:
+completeTypeError.cfa:34:1 error: No reasonable alternatives for expression Applying untyped:
   Name: *?
 ...to:
   Name: y
 completeTypeError.c:35:1 error: No reasonable alternatives for expression Applying untyped:
+completeTypeError.cfa:35:1 error: No reasonable alternatives for expression Applying untyped:
   Name: foo
 ...to:
   Name: v
 completeTypeError.c:36:1 error: No reasonable alternatives for expression Applying untyped:
+completeTypeError.cfa:36:1 error: No reasonable alternatives for expression Applying untyped:
   Name: baz
 ...to:
   Name: v
 completeTypeError.c:37:1 error: No reasonable alternatives for expression Applying untyped:
+completeTypeError.cfa:37:1 error: No reasonable alternatives for expression Applying untyped:
   Name: quux
 ...to:
   Name: v
 completeTypeError.c:58:1 error: No reasonable alternatives for expression Applying untyped:
+completeTypeError.cfa:58:1 error: No reasonable alternatives for expression Applying untyped:
   Name: baz
 ...to:
   Name: y
 completeTypeError.c:59:1 error: No reasonable alternatives for expression Applying untyped:
+completeTypeError.cfa:59:1 error: No reasonable alternatives for expression Applying untyped:
   Name: quux
 ...to:
   Name: y
 completeTypeError.c:60:1 error: No reasonable alternatives for expression Applying untyped:
+completeTypeError.cfa:60:1 error: No reasonable alternatives for expression Applying untyped:
   Name: *?
 ...to:
   Name: y
 completeTypeError.c:72:1 error: No reasonable alternatives for expression Applying untyped:
+completeTypeError.cfa:72:1 error: No reasonable alternatives for expression Applying untyped:
   Name: baz
 ...to:

tests/.expect/declarationErrors.txt

-              rcdc02f2
+              r515a037
 declarationErrors.c:16:1 error: duplicate static in declaration of x1: static const volatile short int
+declarationErrors.cfa:16:1 error: duplicate static in declaration of x1: static const volatile short int
 declarationErrors.c:17:1 error: conflicting extern & static in declaration of x2: extern const volatile short int
+declarationErrors.cfa:17:1 error: conflicting extern & static in declaration of x2: extern const volatile short int
 declarationErrors.c:18:1 error: conflicting extern & auto, conflicting extern & static, conflicting extern & static, duplicate extern in declaration of x3: extern const volatile short int
+declarationErrors.cfa:18:1 error: conflicting extern & auto, conflicting extern & static, conflicting extern & static, duplicate extern in declaration of x3: extern const volatile short int
 declarationErrors.c:19:1 error: duplicate static in declaration of x4: static const volatile instance of const volatile struct __anonymous0
+declarationErrors.cfa:19:1 error: duplicate static in declaration of x4: static const volatile instance of const volatile struct __anonymous0
   with members
     i: int
 …
 declarationErrors.c:20:1 error: duplicate const, duplicate static, duplicate volatile in declaration of x5: static const volatile instance of const volatile struct __anonymous1
+declarationErrors.cfa:20:1 error: duplicate const, duplicate static, duplicate volatile in declaration of x5: static const volatile instance of const volatile struct __anonymous1
   with members
     i: int
 …
 declarationErrors.c:22:1 error: duplicate static in declaration of x6: static const volatile Int
+declarationErrors.cfa:22:1 error: duplicate static in declaration of x6: static const volatile Int
 declarationErrors.c:24:1 error: duplicate const in declaration of f01: static inline function
+declarationErrors.cfa:24:1 error: duplicate const in declaration of f01: static inline function
   with no parameters
   returning const volatile int
 declarationErrors.c:25:1 error: duplicate volatile in declaration of f02: static inline function
+declarationErrors.cfa:25:1 error: duplicate volatile in declaration of f02: static inline function
   with no parameters
   returning const volatile int
 declarationErrors.c:26:1 error: duplicate const in declaration of f03: static inline function
+declarationErrors.cfa:26:1 error: duplicate const in declaration of f03: static inline function
   with no parameters
   returning const volatile int
 declarationErrors.c:27:1 error: duplicate volatile in declaration of f04: static inline function
+declarationErrors.cfa:27:1 error: duplicate volatile in declaration of f04: static inline function
   with no parameters
   returning const volatile int
 declarationErrors.c:28:1 error: duplicate const in declaration of f05: static inline function
+declarationErrors.cfa:28:1 error: duplicate const in declaration of f05: static inline function
   with no parameters
   returning const volatile int
 declarationErrors.c:29:1 error: duplicate volatile in declaration of f06: static inline function
+declarationErrors.cfa:29:1 error: duplicate volatile in declaration of f06: static inline function
   with no parameters
   returning const volatile int
 declarationErrors.c:30:1 error: duplicate const in declaration of f07: static inline function
+declarationErrors.cfa:30:1 error: duplicate const in declaration of f07: static inline function
   with no parameters
   returning const volatile int
 declarationErrors.c:31:1 error: duplicate const, duplicate volatile in declaration of f08: static inline function
+declarationErrors.cfa:31:1 error: duplicate const, duplicate volatile in declaration of f08: static inline function
   with no parameters
   returning const volatile int
 declarationErrors.c:33:1 error: duplicate const, duplicate volatile in declaration of f09: static inline function
+declarationErrors.cfa:33:1 error: duplicate const, duplicate volatile in declaration of f09: static inline function
   with no parameters
   returning const volatile int
 declarationErrors.c:34:1 error: duplicate const, duplicate _Atomic, duplicate _Atomic, duplicate const, duplicate restrict, duplicate volatile in declaration of f09: static inline function
+declarationErrors.cfa:34:1 error: duplicate const, duplicate _Atomic, duplicate _Atomic, duplicate const, duplicate restrict, duplicate volatile in declaration of f09: static inline function
   with no parameters
   returning const restrict volatile _Atomic int

tests/.expect/loopctrl.txt

-              rcdc02f2
+              r515a037
+N N N N N N N N N N
+1 2 3 4 5 6 7 8 9
+9 8 7 6 5 4 3 2 1
 6 9
 (0 0)(1 1)(2 2)(3 3)(4 4)(5 5)(6 6)(7 7)(8 8)(9 9)

tests/.expect/nested-types-ERR1.txt

rcdc02f2	r515a037
1		nested-types.c:70:1 error: Use of undefined type T
	1	nested-types.cfa:70:1 error: Use of undefined type T

tests/.expect/nested-types-ERR2.txt

-              rcdc02f2
+              r515a037
 nested-types.c:73:1 error: Use of undefined global type Z
 nested-types.c:74:1 error: Qualified type requires an aggregate on the left, but has: signed int
 nested-types.c:75:1 error: Undefined type in qualified type: Qualified Type:
+nested-types.cfa:73:1 error: Use of undefined global type Z
+nested-types.cfa:74:1 error: Qualified type requires an aggregate on the left, but has: signed int
+nested-types.cfa:75:1 error: Undefined type in qualified type: Qualified Type:
   instance of struct S with body 1
   instance of type Z (not function type)

tests/.expect/scopeErrors.txt

rcdc02f2	r515a037
1		scopeErrors.c:2:1 error: duplicate object definition for thisIsAnError: signed int
2		scopeErrors.c:20:1 error: duplicate function definition for butThisIsAnError: function
	1	scopeErrors.cfa:2:1 error: duplicate object definition for thisIsAnError: signed int
	2	scopeErrors.cfa:20:1 error: duplicate function definition for butThisIsAnError: function
3	3	... with parameters
4	4	double

tests/.expect/typedefRedef-ERR1.txt

rcdc02f2	r515a037
1		typedefRedef.c:4:1 error: Cannot redefine typedef: Foo
2		typedefRedef.c:60:1 error: Cannot redefine typedef: ARR
	1	typedefRedef.cfa:4:1 error: Cannot redefine typedef: Foo
	2	typedefRedef.cfa:60:1 error: Cannot redefine typedef: ARR

tests/KRfunctions.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // KRfunctions.c --
+// KRfunctions.cfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Thu Feb 16 15:23:17 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Aug 20 07:34:17 2017
 // Update Count     : 7
+// Last Modified On : Tue Nov  6 17:50:34 2018
+// Update Count     : 9
 //
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa KRfunctions.c" //
+// compile-command: "cfa KRfunctions.cfa" //
 // End: //

tests/Makefile.am

-              rcdc02f2
+              r515a037
 ## Created On       : Sun May 31 09:08:15 2015
 ## Last Modified By : Peter A. Buhr
 ## Last Modified On : Wed Jun  6 16:42:20 2018
 ## Update Count     : 49
+## Last Modified On : Tue Nov 20 11:18:51 2018
+## Update Count     : 68
 ###############################################################################
 AUTOMAKE_OPTIONS = foreign    # do not require all the GNU file names
+include $(top_srcdir)/src/cfa.make
 debug=yes
 …
 AM_CFLAGS += ${DEBUG_FLAGS} ${INSTALL_FLAGS} ${ARCH_FLAGS}
 CC = @CFACC@
 …
 .PHONY: list .validate
+.INTERMEDIATE: .validate .validate.c
+EXTRA_PROGRAMS = fstream_test avl_test # build but do not install
+fstream_test_SOURCES = fstream_test.c
+.INTERMEDIATE: .validate .validate.cfa
+EXTRA_PROGRAMS = avl_test # build but do not install
 avl_test_SOURCES = avltree/avl_test.c avltree/avl0.c avltree/avl1.c avltree/avl2.c avltree/avl3.c avltree/avl4.c avltree/avl-private.c
 …
         @+${TEST_PY} --list ${concurrent}
 .validate: .validate.c
         $(COMPILE) .validate.c -fsyntax-only -Wall -Wextra -Werror
+.validate: .validate.cfa
+        $(CFACOMPILE) .validate.cfa -fsyntax-only -Wall -Wextra -Werror
+.validate.c:
+.validate.cfa:
+        @echo "int main() { return 0; }" > ${@}
+dummy_hack.c:
         @echo "int main() { return 0; }" > ${@}
 …
 #----------------------------------------------------------------------------------------------------------------
 # implicit rule so not all test require a rule
 % : %.c $(CC)
         $(PRETTY_PATH) $(COMPILE) $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+% : %.c $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 declarationSpecifier: declarationSpecifier.c $(CC)
         $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+% : %.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 gccExtensions : gccExtensions.c $(CC)
         $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+declarationSpecifier: declarationSpecifier.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 extension : extension.c $(CC)
         $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+gccExtensions : gccExtensions.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 attributes : attributes.c $(CC)
         $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+extension : extension.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 functions: functions.c $(CC)
         $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+attributes : attributes.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 KRfunctions : KRfunctions.c $(CC)
         $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+functions: functions.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 sched-ext-parse : sched-ext-parse.c $(CC)
         $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+KRfunctions : KRfunctions.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+gmp : gmp.c $(CC)
+        $(PRETTY_PATH) $(COMPILE) -lgmp $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+sched-ext-parse : sched-ext-parse.c $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+gmp : gmp.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -lgmp $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 #builtins
 builtins/sync: builtins/sync.c $(CC)
         $(PRETTY_PATH) $(COMPILE) $(shell realpath --relative-to=${srcdir} ${<}) 2> $(abspath ${@}) -fsyntax-only
+builtins/sync: builtins/sync.c $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) 2> $(abspath ${@}) -fsyntax-only
 #------------------------------------------------------------------------------
 #To make errors path independent we need to cd into the correct directories
 completeTypeError : completeTypeError.c $(CC)
         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+completeTypeError : completeTypeError.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 typedefRedef-ERR1: typedefRedef.c $(CC)
         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+typedefRedef-ERR1: typedefRedef.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 alloc-ERROR: alloc.c $(CC)
         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+alloc-ERROR: alloc.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 fallthrough-ERROR: fallthrough.c $(CC)
         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+fallthrough-ERROR: fallthrough.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 nested-types-ERR1: nested-types.c $(CC)
         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+nested-types-ERR1: nested-types.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 nested-types-ERR2: nested-types.c $(CC)
         $(PRETTY_PATH) $(COMPILE) -DERR2 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+nested-types-ERR2: nested-types.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR2 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 # Constructor/destructor tests
 raii/dtor-early-exit-ERR1: raii/dtor-early-exit.c $(CC)
         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+raii/dtor-early-exit-ERR1: raii/dtor-early-exit.c $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 raii/dtor-early-exit-ERR2: raii/dtor-early-exit.c $(CC)
         $(PRETTY_PATH) $(COMPILE) -DERR2 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+raii/dtor-early-exit-ERR2: raii/dtor-early-exit.c $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR2 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 raii/memberCtors-ERR1: raii/memberCtors.c $(CC)
         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+raii/memberCtors-ERR1: raii/memberCtors.c $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 raii/ctor-autogen-ERR1: raii/ctor-autogen.c $(CC)
         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+raii/ctor-autogen-ERR1: raii/ctor-autogen.c $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 # Warnings
 warnings/self-assignment: warnings/self-assignment.c $(CC)
         $(PRETTY_PATH) $(COMPILE) $(shell realpath --relative-to=${srcdir} ${<}) 2> $(abspath ${@}) -fsyntax-only
+warnings/self-assignment: warnings/self-assignment.c $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) 2> $(abspath ${@}) -fsyntax-only

tests/Makefile.in

-              rcdc02f2
+              r515a037
 build_triplet = @build@
 host_triplet = @host@
 EXTRA_PROGRAMS = fstream_test$(EXEEXT) avl_test$(EXEEXT)
+EXTRA_PROGRAMS = avl_test$(EXEEXT)
 subdir = tests
 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
 …
 avl_test_OBJECTS = $(am_avl_test_OBJECTS)
 avl_test_LDADD = $(LDADD)
-am_fstream_test_OBJECTS = fstream_test.$(OBJEXT)
-fstream_test_OBJECTS = $(am_fstream_test_OBJECTS)
-fstream_test_LDADD = $(LDADD)
 AM_V_P = $(am__v_P_@AM_V@)
 am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
 …
 am__v_CCLD_0 = @echo "  CCLD    " $@;
 am__v_CCLD_1 =
 SOURCES = $(avl_test_SOURCES) $(fstream_test_SOURCES)
 DIST_SOURCES = $(avl_test_SOURCES) $(fstream_test_SOURCES)
+SOURCES = $(avl_test_SOURCES)
+DIST_SOURCES = $(avl_test_SOURCES)
 am__can_run_installinfo = \
   case $$AM_UPDATE_INFO_DIR in \
 …
 CTAGS = ctags
 am__DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/config.py.in \
+        $(srcdir)/test.py $(top_srcdir)/automake/depcomp
+        $(srcdir)/test.py $(top_srcdir)/automake/depcomp \
+        $(top_srcdir)/src/cfa.make
 DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
 ACLOCAL = @ACLOCAL@
 …
 top_srcdir = @top_srcdir@
 AUTOMAKE_OPTIONS = foreign    # do not require all the GNU file names
+CFACOMPILE = $(CFACC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CFAFLAGS) $(CFAFLAGS) $(AM_CFLAGS) $(CFLAGS)
+LTCFACOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+        $(LIBTOOLFLAGS) --mode=compile $(CFACC) $(DEFS) \
+        $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CFAFLAGS) $(CFAFLAGS) \
+        $(AM_CFLAGS) $(CFLAGS)
+AM_V_CFA = $(am__v_CFA_@AM_V@)
+am__v_CFA_ = $(am__v_CFA_@AM_DEFAULT_V@)
+am__v_CFA_0 = @echo "  CFA     " $@;
+am__v_CFA_1 =
+AM_V_JAVAC = $(am__v_JAVAC_@AM_V@)
+am__v_JAVAC_ = $(am__v_JAVAC_@AM_DEFAULT_V@)
+am__v_JAVAC_0 = @echo "  JAVAC   " $@;
+am__v_JAVAC_1 =
+AM_V_GOC = $(am__v_GOC_@AM_V@)
+am__v_GOC_ = $(am__v_GOC_@AM_DEFAULT_V@)
+am__v_GOC_0 = @echo "  GOC     " $@;
+am__v_GOC_1 =
+UPPCOMPILE = $(UPPCC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_UPPFLAGS) $(UPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_CFLAGS) $(CFLAGS)
+AM_V_UPP = $(am__v_UPP_@AM_V@)
+am__v_UPP_ = $(am__v_UPP_@AM_DEFAULT_V@)
+am__v_UPP_0 = @echo "  UPP     " $@;
+am__v_UPP_1 =
 debug = yes
 installed = no
 …
         ${INSTALL_FLAGS} ${ARCH_FLAGS}
 PRETTY_PATH = cd ${srcdir} &&
-fstream_test_SOURCES = fstream_test.c
 avl_test_SOURCES = avltree/avl_test.c avltree/avl0.c avltree/avl1.c avltree/avl2.c avltree/avl3.c avltree/avl4.c avltree/avl-private.c
 all: all-am
 .SUFFIXES:
 .SUFFIXES: .c .o .obj .validate
 $(srcdir)/Makefile.in:  $(srcdir)/Makefile.am  $(am__configure_deps)
+.SUFFIXES: .c .cfa .lo .o .obj .validate
+$(srcdir)/Makefile.in:  $(srcdir)/Makefile.am $(top_srcdir)/src/cfa.make $(am__configure_deps)
         @for dep in $?; do \
           case '$(am__configure_deps)' in \
 …
             cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
         esac;
+$(top_srcdir)/src/cfa.make $(am__empty):
 $(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
 …
         $(AM_V_CCLD)$(LINK) $(avl_test_OBJECTS) $(avl_test_LDADD) $(LIBS)
-fstream_test$(EXEEXT): $(fstream_test_OBJECTS) $(fstream_test_DEPENDENCIES) $(EXTRA_fstream_test_DEPENDENCIES)
-        @rm -f fstream_test$(EXEEXT)
-        $(AM_V_CCLD)$(LINK) $(fstream_test_OBJECTS) $(fstream_test_LDADD) $(LIBS)
 mostlyclean-compile:
         -rm -f *.$(OBJEXT)
 …
         -rm -f *.tab.c
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstream_test.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@avltree/$(DEPDIR)/avl-private.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@avltree/$(DEPDIR)/avl0.Po@am__quote@
 …
 distclean: distclean-am
         -rm -rf ./$(DEPDIR) avltree/$(DEPDIR)
+        -rm -rf avltree/$(DEPDIR)
         -rm -f Makefile
 distclean-am: clean-am distclean-compile distclean-generic \
 …
 maintainer-clean: maintainer-clean-am
         -rm -rf ./$(DEPDIR) avltree/$(DEPDIR)
+        -rm -rf avltree/$(DEPDIR)
         -rm -f Makefile
 maintainer-clean-am: distclean-am maintainer-clean-generic
 …
+.cfa.o:
+        $(AM_V_CFA)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
+        $(CFACOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+        $(am__mv) $$depbase.Tpo $$depbase.Po
+.cfa.lo:
+        $(AM_V_CFA)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\
+        $(LTCFACOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+        $(am__mv) $$depbase.Tpo $$depbase.Plo
 .PHONY: list .validate
 .INTERMEDIATE: .validate .validate.c
+.INTERMEDIATE: .validate .validate.cfa
 #----------------------------------------------------------------------------------------------------------------
 …
         @+${TEST_PY} --list ${concurrent}
+.validate: .validate.c
+        $(COMPILE) .validate.c -fsyntax-only -Wall -Wextra -Werror
+.validate.c:
+.validate: .validate.cfa
+        $(CFACOMPILE) .validate.cfa -fsyntax-only -Wall -Wextra -Werror
+.validate.cfa:
+        @echo "int main() { return 0; }" > ${@}
+dummy_hack.c:
         @echo "int main() { return 0; }" > ${@}
 …
 #----------------------------------------------------------------------------------------------------------------
 # implicit rule so not all test require a rule
+% : %.c $(CC)
+        $(PRETTY_PATH) $(COMPILE) $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+declarationSpecifier: declarationSpecifier.c $(CC)
+        $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+gccExtensions : gccExtensions.c $(CC)
+        $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+extension : extension.c $(CC)
+        $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+attributes : attributes.c $(CC)
+        $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+functions: functions.c $(CC)
+        $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+KRfunctions : KRfunctions.c $(CC)
+        $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+sched-ext-parse : sched-ext-parse.c $(CC)
+        $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+gmp : gmp.c $(CC)
+        $(PRETTY_PATH) $(COMPILE) -lgmp $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+% : %.c $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+% : %.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+declarationSpecifier: declarationSpecifier.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+gccExtensions : gccExtensions.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+extension : extension.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+attributes : attributes.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+functions: functions.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+KRfunctions : KRfunctions.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+sched-ext-parse : sched-ext-parse.c $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+gmp : gmp.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -lgmp $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 #builtins
 builtins/sync: builtins/sync.c $(CC)
         $(PRETTY_PATH) $(COMPILE) $(shell realpath --relative-to=${srcdir} ${<}) 2> $(abspath ${@}) -fsyntax-only
+builtins/sync: builtins/sync.c $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) 2> $(abspath ${@}) -fsyntax-only
 #------------------------------------------------------------------------------
 #To make errors path independent we need to cd into the correct directories
 completeTypeError : completeTypeError.c $(CC)
         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 typedefRedef-ERR1: typedefRedef.c $(CC)
         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 alloc-ERROR: alloc.c $(CC)
         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 fallthrough-ERROR: fallthrough.c $(CC)
         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 nested-types-ERR1: nested-types.c $(CC)
         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 nested-types-ERR2: nested-types.c $(CC)
         $(PRETTY_PATH) $(COMPILE) -DERR2 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+completeTypeError : completeTypeError.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+typedefRedef-ERR1: typedefRedef.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+alloc-ERROR: alloc.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+fallthrough-ERROR: fallthrough.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+nested-types-ERR1: nested-types.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+nested-types-ERR2: nested-types.cfa $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR2 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 # Constructor/destructor tests
 raii/dtor-early-exit-ERR1: raii/dtor-early-exit.c $(CC)
         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 raii/dtor-early-exit-ERR2: raii/dtor-early-exit.c $(CC)
         $(PRETTY_PATH) $(COMPILE) -DERR2 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 raii/memberCtors-ERR1: raii/memberCtors.c $(CC)
         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 raii/ctor-autogen-ERR1: raii/ctor-autogen.c $(CC)
         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+raii/dtor-early-exit-ERR1: raii/dtor-early-exit.c $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+raii/dtor-early-exit-ERR2: raii/dtor-early-exit.c $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR2 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+raii/memberCtors-ERR1: raii/memberCtors.c $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+raii/ctor-autogen-ERR1: raii/ctor-autogen.c $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 # Warnings
 warnings/self-assignment: warnings/self-assignment.c $(CC)
         $(PRETTY_PATH) $(COMPILE) $(shell realpath --relative-to=${srcdir} ${<}) 2> $(abspath ${@}) -fsyntax-only
+warnings/self-assignment: warnings/self-assignment.c $(CFACC)
+        $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) 2> $(abspath ${@}) -fsyntax-only
 # Tell versions [3.59,3.63) of GNU make to not export all variables.

tests/abs.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // abs.c --
+// abs.cfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Thu Jan 28 18:26:16 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Feb 22 22:31:03 2017
 // Update Count     : 52
+// Last Modified On : Tue Dec  4 21:33:15 2018
+// Update Count     : 55
 //
 …
 int main( void ) {
         signed char ch = -65;
         sout | "char\t\t\t"                                     | ch     | "\tabs " | abs( ch ) | endl;
         sout | "signed int\t\t"                         | -65    | "\tabs" | abs( -65 ) | endl;
         sout | "signed long int\t\t"            | -65l   | "\tabs" | abs( -65l ) | endl;
         sout | "signed long long int\t"         | -65ll  | "\tabs" | abs( -65ll ) | endl;
         sout | "float\t\t\t"                            | -65.0f | "\tabs" | abs( -65.0f ) | endl;
         sout | "double\t\t\t"                           | -65.0  | "\tabs" | abs( -65.0 ) | endl;
         sout | "long double\t\t"                        | -65.0l | "\tabs" | abs( -65.0l ) | endl;
         sout | "float _Complex\t\t"                     | -65.0F-2.0iF | "\tabs" | abs( -65.0F-2.0iF ) | endl;
         sout | "double _Complex\t\t"            | -65.0D-2.0iD | "\tabs" | abs( -65.0D-2.0iD ) | endl;
         sout | "long double _Complex\t"         | -65.0L-2.0iL | "\tabs" | abs( -65.0L-2.0iL ) | endl;
+        sout | "char\t\t\t"                                     | ch     | "\tabs " | abs( ch );
+        sout | "signed int\t\t"                         | -65    | "\tabs" | abs( -65 );
+        sout | "signed long int\t\t"            | -65l   | "\tabs" | abs( -65l );
+        sout | "signed long long int\t"         | -65ll  | "\tabs" | abs( -65ll );
+        sout | "float\t\t\t"                            | -65.0f | "\tabs" | abs( -65.0f );
+        sout | "double\t\t\t"                           | -65.0  | "\tabs" | abs( -65.0 );
+        sout | "long double\t\t"                        | -65.0l | "\tabs" | abs( -65.0l );
+        sout | "float _Complex\t\t"                     | -65.0F-2.0iF | "\tabs" | abs( -65.0F-2.0iF );
+        sout | "double _Complex\t\t"            | -65.0D-2.0iD | "\tabs" | abs( -65.0D-2.0iD );
+        sout | "long double _Complex\t"         | -65.0L-2.0iL | "\tabs" | abs( -65.0L-2.0iL );
 } // main
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa abs.c" //
+// compile-command: "cfa abs.cfa" //
 // End: //

tests/alloc.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // alloc.c --
+// alloc.cfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Wed Feb  3 07:56:22 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Aug  9 06:21:35 2018
 // Update Count     : 337
+// Last Modified On : Tue Nov  6 17:50:52 2018
+// Update Count     : 339
 //
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa alloc.c" //
+// compile-command: "cfa alloc.cfa" //
 // End: //

tests/ato.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // ato.c --
+// ato.cfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Thu Feb  4 08:10:57 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Nov 16 18:31:56 2017
 // Update Count     : 89
+// Last Modified On : Tue Dec  4 21:33:53 2018
+// Update Count     : 92
 //
 …
         const char * sptr = "-123";
         int i = ato( sptr );
         sout | i | sptr | endl;
+        sout | i | sptr;
         sptr = "123";
         unsigned int ui = ato( sptr );
         sout | ui | sptr | endl;
+        sout | ui | sptr;
         sptr = "-123";
         long int li = ato( sptr );
         sout | li | sptr | endl;
+        sout | li | sptr;
         sptr = "123";
         unsigned long int uli = ato( sptr );
         sout | uli | sptr | endl;
+        sout | uli | sptr;
         sptr = "-123";
         long long int lli = ato( sptr );
         sout | lli | sptr | endl;
+        sout | lli | sptr;
         sptr = "123";
         unsigned long long int ulli = ato( sptr );
         sout | ulli | sptr | endl;
+        sout | ulli | sptr;
         sptr = "-123.456";
         float f = ato( sptr );
         sout | f | sptr | endl;
+        sout | f | sptr;
         sptr = "-123.4567890123456";
         double d = ato( sptr );
         sout | d | sptr | endl;
+        sout | d | sptr;
         sptr = "-123.45678901234567890123456789";
         long double ld = ato( sptr );
         sout | ld | sptr | endl;
+        sout | ld | sptr;
         sptr = "-123.456-123.456i";
         float _Complex fc = ato( sptr );
         sout | fc | sptr | endl;
+        sout | fc | sptr;
         sptr = "-123.4567890123456+123.4567890123456i";
         double _Complex dc = ato( sptr );
         sout | dc | sptr | endl;
+        sout | dc | sptr;
         sptr = "123.45678901234567890123456789-123.45678901234567890123456789i";
         long double _Complex ldc = ato( sptr );
         sout | ldc | sptr | endl;
+        sout | ldc | sptr;
         sptr = "123.45678901234-123.4567890i";
         long double _Complex ldc2 = ato( sptr );
         sout | ldc2 | sptr | endl;
+        sout | ldc2 | sptr;
         sptr = "-123";
         i = strto( sptr, 0, 10 );
         sout | i | sptr | endl;
+        sout | i | sptr;
         sptr = "123";
         ui = strto( sptr, 0, 10 );
         sout | ui | sptr | endl;
+        sout | ui | sptr;
         sptr = "-123";
         li = strto( sptr, 0, 10 );
         sout | li | sptr | endl;
+        sout | li | sptr;
         sptr = "123";
         uli = strto( sptr, 0, 10 );
         sout | uli | sptr | endl;
+        sout | uli | sptr;
         sptr = "-123";
         lli = strto( sptr, 0, 10 );
         sout | lli | sptr | endl;
+        sout | lli | sptr;
         sptr = "123";
         ulli = strto( sptr, 0, 10 );
         sout | ulli | sptr | endl;
+        sout | ulli | sptr;
         sptr = "-123.456";
         f = strto( sptr, 0 );
         sout | f | sptr | endl;
+        sout | f | sptr;
         sptr = "-123.4567890123456";
         d = strto( sptr, 0 );
         sout | d | sptr | endl;
+        sout | d | sptr;
         sptr = "-123.45678901234567890123456789";
         ld = strto( sptr, 0 );
         sout | ld | sptr | endl;
+        sout | ld | sptr;
         sptr = "-123.456-123.456i";
         fc = strto( sptr, 0 );
         sout | fc | sptr | endl;
+        sout | fc | sptr;
         char * eptr = 0;
         // sptr = "2fred";
         // fc = strto( sptr, &eptr );
         // sout | fc | sptr | eptr | endl;
+        // sout | fc | sptr | eptr;
         sptr = "2  3";
         fc = strto( sptr, &eptr );
         sout | fc | sptr | eptr | endl;
+        sout | fc | sptr | eptr;
         sptr = "-123.4567890123456+123.4567890123456i";
         dc = strto( sptr, 0 );
         sout | dc | sptr | endl;
+        sout | dc | sptr;
         sptr = "123.45678901234567890123456789-123.45678901234567890123456789i";
         ldc = strto( sptr, 0 );
         sout | ldc | sptr | endl;
+        sout | ldc | sptr;
         sptr = "123.45678901234-123.4567890i";
         ldc2 = strto( sptr, 0 );
         sout | ldc2 | sptr | endl;
+        sout | ldc2 | sptr;
 } // main
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa ato.c" //
+// compile-command: "cfa ato.cfa" //
 // End: //

tests/attributes.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // attributes.c --
+// attributes.cfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Mon Feb  6 16:07:02 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jul 19 13:50:51 2018
 // Update Count     : 15
+// Last Modified On : Tue Nov  6 17:51:12 2018
+// Update Count     : 17
 //
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa attributes.c" //
+// compile-command: "cfa attributes.cfa" //
 // End: //

tests/complex.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // complex.c --
+// complex.cfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Wed May 24 22:07:31 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed May 24 22:08:01 2017
 // Update Count     : 1
+// Last Modified On : Tue Dec  4 21:34:21 2018
+// Update Count     : 4
 //
 …
     printf( "x:%g+%gi y:%g+%gi z:%g+%gi\n", creal(x), cimag(x), creal(y), cimag(y), creal(z), cimag(z) );
 #ifdef __CFA__
     sout | "x:" | x | "y:" | y | "z:" | z | endl;
+    sout | "x:" | x | "y:" | y | "z:" | z;
 #endif // __CFA
     x = 2.1 + 1.3i;
 …
     printf( "x:%g+%gi y:%g+%gi z:%g+%gi\n", creal(x), cimag(x), creal(y), cimag(y), creal(z), cimag(z) );
 #ifdef __CFA__
     sout | "x:" | x | "y:" | y | "z:" | z | endl;
+    sout | "x:" | x | "y:" | y | "z:" | z;
 #endif // __CFA
+}
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa complex.c" //
+// compile-command: "cfa complex.cfa" //
 // End: //

tests/concurrent/coroutineYield.c

-              rcdc02f2
+              r515a037
 #define __kick_rate 150000ul
 #include "long_tests.h"
+#include "long_tests.hfa"
 #ifndef PREEMPTION_RATE
 …
         while(true) {
                 #if !defined(TEST_FOREVER)
                         sout | "Coroutine 1" | endl;
+                        sout | "Coroutine 1";
                 #endif
                 yield();
                 #if !defined(TEST_FOREVER)
                         sout | "Coroutine 2" | endl;
+                        sout | "Coroutine 2";
                 #endif
                 suspend();
 …
         for(int i = 0; TEST(i < N); i++) {
                 #if !defined(TEST_FOREVER)
                         sout | "Thread 1" | endl;
+                        sout | "Thread 1";
                 #endif
                 resume(c);
                 #if !defined(TEST_FOREVER)
                         sout | "Thread 2" | endl;
+                        sout | "Thread 2";
                 #endif
                 yield();

tests/concurrent/examples/boundedBufferEXT.c

-              rcdc02f2
+              r515a037
 // Created On       : Wed Apr 18 22:52:12 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Aug 16 08:17:03 2018
 // Update Count     : 8
+// Last Modified On : Tue Dec 11 21:55:02 2018
+// Update Count     : 9
 //
 …
                 sum += sums[i];
         } // for
         sout | "total:" | sum | endl;
+        sout | "total:" | sum;
+}

tests/concurrent/examples/boundedBufferINT.c

-              rcdc02f2
+              r515a037
 // Created On       : Mon Oct 30 12:45:13 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Aug 16 08:17:58 2018
 // Update Count     : 83
+// Last Modified On : Tue Dec 11 21:55:45 2018
+// Update Count     : 84
 //
 …
                 sum += sums[i];
         } // for
         sout | "total:" | sum | endl;
+        sout | "total:" | sum;
+}

tests/concurrent/examples/datingService.c

-              rcdc02f2
+              r515a037
 // Created On       : Mon Oct 30 12:56:20 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun May 27 09:05:18 2018
 // Update Count     : 26
+// Last Modified On : Tue Dec 11 21:55:34 2018
+// Update Count     : 28
 //
 …
         yield( random( 100 ) );                                                         // don't all start at the same time
         unsigned int partner = girl( TheExchange, id, ccode );
         sout | "Girl:" | id | "is dating Boy at" | partner | "with ccode" | ccode | endl;
+        sout | "Girl:" | id | "is dating Boy at" | partner | "with ccode" | ccode;
         girlck[id] = partner;
 } // Girl main
 …
 thread Boy {
         DatingService &TheExchange;
+        DatingService & TheExchange;
         unsigned int id, ccode;
 }; // Boy
 …
         yield( random( 100 ) );                                                         // don't all start at the same time
         unsigned int partner = boy( TheExchange, id, ccode );
         sout | " Boy:" | id | "is dating Girl" | partner | "with ccode" | ccode | endl;
+        sout | " Boy:" | id | "is dating Girl" | partner | "with ccode" | ccode;
         boyck[id] = partner;
 } // Boy main

tests/concurrent/examples/matrixSum.c

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // matrixSum.c --
+// matrixSum.cfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Mon Oct  9 08:29:28 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Aug  9 09:17:30 2018
 // Update Count     : 13
+// Last Modified On : Tue Dec 11 21:54:55 2018
+// Update Count     : 15
 //
 …
                 total += subtotals[r];                                                  // total subtotals
         } // for
         sout | total | endl;
+        sout | total;
+}
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa matrixSum.c" //
+// compile-command: "cfa matrixSum.cfa" //
 // End: //

tests/concurrent/examples/quickSort.c

-              rcdc02f2
+              r515a037
 // Created On       : Wed Dec  6 12:15:52 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Aug 16 08:17:41 2018
 // Update Count     : 163
+// Last Modified On : Tue Dec  4 18:00:27 2018
+// Update Count     : 167
 //
 …
 void usage( char * argv[] ) {
         sout | "Usage:" | argv[0] | "( -s unsorted-file [ sorted-file ] | -t size (>= 0) [ depth (>= 0) ] )" | endl;
+        sout | "Usage:" | argv[0] | "( -s unsorted-file [ sorted-file ] | -t size (>= 0) [ depth (>= 0) ] )";
         exit( EXIT_FAILURE );                                                           // TERMINATE!
 } // usage
 …
                                 &sortedfile = new( (const char *)argv[2] ); // open the output file
                                 if ( fail( sortedfile ) ) {
                                         serr | "Error! Could not open sorted output file \"" | argv[2] | "\"" | endl;
+                                        serr | "Error! Could not open sorted output file \"" | argv[2] | "\"";
                                         usage( argv );
                                 } // if
 …
                                 &unsortedfile = new( (const char *)argv[1] ); // open the input file
                                 if ( fail( unsortedfile ) ) {
                                         serr | "Error! Could not open unsorted input file \"" | argv[1] | "\"" | endl;
+                                        serr | "Error! Could not open unsorted input file \"" | argv[1] | "\"";
                                         usage( argv );
                                 } // if
 …
                 } // if
         } // if
+        sortedfile | nlOff;                                                                     // turn off auto newline
         enum { ValuesPerLine = 22 };                                            // number of values printed per line
 …
                         for ( int counter = 0; counter < size; counter += 1 ) { // read unsorted numbers
                                 unsortedfile | values[counter];
                                 if ( counter != 0 && counter % ValuesPerLine == 0 ) sortedfile | endl | "  ";
+                                if ( counter != 0 && counter % ValuesPerLine == 0 ) sortedfile | nl | "  ";
                                 sortedfile | values[counter];
                                 if ( counter < size - 1 && (counter + 1) % ValuesPerLine != 0 ) sortedfile | ' ';
                         } // for
                         sortedfile | endl;
+                        sortedfile | nl;
                         if ( size > 0 ) {                                                       // values to sort ?
                                 Quicksort QS = { values, size - 1, 0 }; // sort values
                         } // wait until sort tasks terminate
                         for ( int counter = 0; counter < size; counter += 1 ) { // print sorted list
                                 if ( counter != 0 && counter % ValuesPerLine == 0 ) sortedfile | endl | "  ";
+                                if ( counter != 0 && counter % ValuesPerLine == 0 ) sortedfile | nl | "  ";
                                 sortedfile | values[counter];
                                 if ( counter < size - 1 && (counter + 1) % ValuesPerLine != 0 ) sortedfile | ' ';
                         } // for
                         sortedfile | endl | endl;
+                        sortedfile | nl;
                         delete( values );

tests/concurrent/monitor.c

rcdc02f2	r515a037
40	40	MyThread f[4];
41	41	}
42		sout \| global.value ~~\| endl~~;
	42	sout \| global.value;
43	43	}

tests/concurrent/multi-monitor.c

rcdc02f2	r515a037
52	52	}
53	53	}
54		sout \| global12 \| global23 \| global13 ~~\| endl~~;
	54	sout \| global12 \| global23 \| global13;
55	55	}

tests/concurrent/preempt.c

rcdc02f2	r515a037
3	3	#include <time.hfa>
4	4
5		#include "long_tests.h"
	5	#include "long_tests.hfa"
6	6
7	7	#ifndef PREEMPTION_RATE

tests/concurrent/signal/block.c

-              rcdc02f2
+              r515a037
 #include <time.hfa>
 #include "long_tests.h"
+#include "long_tests.hfa"
 #ifndef PREEMPTION_RATE
 …
         if(a.last_thread != a.last_signaller || b.last_thread != b.last_signaller ) {
                 sout | "ERROR Barging detected, expected" | a.last_signaller | b.last_signaller | "got" | a.last_thread | b.last_thread | endl;
+                sout | "ERROR Barging detected, expected" | a.last_signaller | b.last_signaller | "got" | a.last_thread | b.last_thread;
                 abort();
+        }
 …
                 if( ! signal_block( cond ) ) {
                         sout | "ERROR expected to be able to signal" | endl;
+                        sout | "ERROR expected to be able to signal";
                         abort();
+                }
 …
                 if(a.last_thread != next || b.last_thread != next) {
                         sout | "ERROR Barging detected, expected" | next | "got" | a.last_thread | b.last_thread | endl;
+                        sout | "ERROR Barging detected, expected" | next | "got" | a.last_thread | b.last_thread;
                         abort();
+                }
 …
                 Signaller s[4];
                 Barger b[13];
                 sout | "Starting waiters" | endl;
+                sout | "Starting waiters";
+                {
                         Waiter w[3];
+                }
                 sout | "Waiters done" | endl;
+                sout | "Waiters done";
                 done = true;
+        }

tests/concurrent/signal/disjoint.c

-              rcdc02f2
+              r515a037
 #include <time.hfa>
 #include "long_tests.h"
+#include "long_tests.hfa"
 #ifndef PREEMPTION_RATE
 …
         wait( cond );
         if( d.state != SIGNAL ) {
                 sout | "ERROR barging!" | endl;
+                sout | "ERROR barging!";
+        }
         #if !defined(TEST_FOREVER)
                 d.counter++;
                 if( (d.counter % 1000) == 0 ) sout | d.counter | endl;
+                if( (d.counter % 1000) == 0 ) sout | d.counter;
         #endif
 …
         bool running = TEST(data.counter < N) && data.counter > 0;
         if( data.state != SIGNAL && running ) {
                 sout | "ERROR Eager signal" | data.state | endl;
+                sout | "ERROR Eager signal" | data.state;
+        }
+}
 …
                         Waiter w[4];
+                }
                 sout | "All waiter done" | endl;
+                sout | "All waiter done";
                 all_done = true;
+        }

tests/concurrent/signal/wait.c

-              rcdc02f2
+              r515a037
 #define __kick_rate 12000ul
 #include "long_tests.h"
+#include "long_tests.hfa"
 #ifndef PREEMPTION_RATE
 …
                                 break;
                         default:
                                 sout | "Something went wrong" | endl;
+                                sout | "Something went wrong";
                                 abort();
+                }
 …
         waiter_left = 4;
         processor p[2];
         sout | "Starting" | endl;
+        sout | "Starting";
+        {
                 Signaler  e;
 …
+                }
+        }
         sout | "Done" | endl;
+        sout | "Done";
+}

tests/concurrent/thread.c

rcdc02f2	r515a037
12	12	void main(First& this) {
13	13	for(int i = 0; i < 10; i++) {
14		sout \| "First : Suspend No." \| i + 1 ~~\| endl~~;
	14	sout \| "First : Suspend No." \| i + 1;
15	15	yield();
16	16	}
…	…
21	21	P(*this.lock);
22	22	for(int i = 0; i < 10; i++) {
23		sout \| "Second : Suspend No." \| i + 1 ~~\| endl~~;
	23	sout \| "Second : Suspend No." \| i + 1;
24	24	yield();
25	25	}
…	…
29	29	int main(int argc, char* argv[]) {
30	30	semaphore lock = { 0 };
31		sout \| "User main begin" ~~\| endl~~;
	31	sout \| "User main begin";
32	32	{
33	33	processor p;
…	…
37	37	}
38	38	}
39		sout \| "User main end" ~~\| endl~~;
	39	sout \| "User main end";
40	40	}

tests/concurrent/waitfor/barge.c

rcdc02f2	r515a037
48	48	yield(random( 10 ));
49	49	if( this.state != WAITFOR && !this.done && this.started ) {
50		serr \| "Barging before caller detected" ~~\| endl~~;
	50	serr \| "Barging before caller detected";
51	51	}
52	52
…	…
66	66	this.state = WAITFOR;
67	67	waitfor(do_call, this) {
68		sout \| i ~~\| endl~~;
	68	sout \| i;
69	69	}
70	70
71	71	if( this.state != CALL ) {
72		serr \| "Barging after caller detected" ~~\| endl~~;
	72	serr \| "Barging after caller detected";
73	73	}
74	74	}
…	…
83	83
84	84	int main() {
85		sout \| "Starting" ~~\| endl~~;
	85	sout \| "Starting";
86	86	{
87	87	barger_t bargers[17];
…	…
89	89	waiter_t waiters;
90	90	}
91		sout \| "Stopping" ~~\| endl~~;
	91	sout \| "Stopping";
92	92	}

tests/concurrent/waitfor/dtor.c

-              rcdc02f2
+              r515a037
         switch(state) {
                 case CTOR  : break;
                 case MAIN  : if( this.state != CTOR  ) { serr | "ERROR Expected state to be CTOR"  | endl; abort(); } this.state = state; break;
                 case AFTER : if( this.state != MAIN  ) { serr | "ERROR Expected state to be MAIN"  | endl; abort(); } this.state = state; break;
                 case END   : if( this.state != AFTER ) { serr | "ERROR Expected state to be AFTER" | endl; abort(); } this.state = state; break;
                 case DTOR  : if( this.state != END   ) { serr | "ERROR Expected state to be END"   | endl; abort(); } this.state = state; break;
+                case MAIN  : if( this.state != CTOR  ) { serr | "ERROR Expected state to be CTOR" ; abort(); } this.state = state; break;
+                case AFTER : if( this.state != MAIN  ) { serr | "ERROR Expected state to be MAIN" ; abort(); } this.state = state; break;
+                case END   : if( this.state != AFTER ) { serr | "ERROR Expected state to be AFTER"; abort(); } this.state = state; break;
+                case DTOR  : if( this.state != END   ) { serr | "ERROR Expected state to be END"  ; abort(); } this.state = state; break;
+        }
+}
 …
 int main() {
         sout | "Starting" | endl;
+        sout | "Starting";
         processor p;
         for( int i = 0; i < N; i++ ){
 …
                 yield( random( 100 ) );
+        }
         sout | "Stopping" | endl;
+        sout | "Stopping";
+}

tests/concurrent/waitfor/else.c

-              rcdc02f2
+              r515a037
 void test( M & mutex m ) {
         int i = 0;
         sout | "Starting" | endl;
+        sout | "Starting";
         when( false ) waitfor( notcalled, m );
         sout | "Step" | i++ | endl;
+        sout | "Step" | i++;
         waitfor( notcalled, m ); or else {
                 sout | "else called" | endl;
+                sout | "else called";
+        }
         sout | "Step" | i++ | endl;
+        sout | "Step" | i++;
         when( true ) waitfor( notcalled, m ); or when( true ) else {
                 sout | "else called" | endl;
+                sout | "else called";
+        }
         sout | "Step" | i++ | endl;
+        sout | "Step" | i++;
         when( false ) waitfor( notcalled, m ); or when( true ) else {
                 sout | "else called" | endl;
+                sout | "else called";
+        }
         sout | "Step" | i++ | endl;
+        sout | "Step" | i++;
         when( false ) waitfor( notcalled, m ); or when( false ) else {
                 sout | "else called" | endl;
+                sout | "else called";
+        }
         sout | "Done" | endl;
+        sout | "Done";
+}

tests/concurrent/waitfor/recurse.c

-              rcdc02f2
+              r515a037
         rand_yield();
         sout | "1st" | endl;
+        sout | "1st" | nl;
         return this.counter < N ? (state_t)this.actions[idx] : (state_t)STOP;
 …
                         case THIRD  : while( !global.ready ) { yield(); } this.state = call3( global, this.idx ); break;
                         case LAST   : while( !global.ready ) { yield(); } this.state = call4( global, this.idx ); break;
                         case STOP   : serr | "This should not happen" | endl;
+                        case STOP   : serr | "This should not happen" | nl;
+                }
+        }
 …
 int main() {
         srandom( time(NULL) );
+        sout | "Starting" | endl;
+        sout | nlOff;                                   // turn off auto newline
+        sout | "Starting" | nl;
+        {
                 waiter_t waiters[4] = {
 …
                 the_threads = waiters;
+        }
         sout | "Stopping" | endl;
+        sout | "Stopping" | nl;
+}

tests/concurrent/waitfor/simple.c

-              rcdc02f2
+              r515a037
 void do_wait( global_t * mutex a ) {
         sout | "Waiting to accept" | endl;
+        sout | "Waiting to accept";
         yield( random( 10 ) );
         sout | "Accepting" | endl;
+        sout | "Accepting";
         __acceptable_t acceptable;
 …
         __waitfor_internal( 1, &acceptable );
         sout | "Accepted" | endl;
+        sout | "Accepted";
         yield( random( 10 ) );
+}
 …
         for( int i = 0; i < N; i++ ) {
                 do_wait( &globalA );
                 sout | i | endl;
+                sout | i;
+        }
 …
         srandom( time( NULL ) );
         printf("%p\n", &globalA);
         sout | "Starting" | endl;
+        sout | "Starting";
+        {
                 Acceptor r;
 …
+        }
         sout | "Done" | endl;
+        sout | "Done";
+}

tests/concurrent/waitfor/statment.c

-              rcdc02f2
+              r515a037
                 case 7: return call7( m );
                 default :
                         serr | "Incorrect index" | index | endl;
+                        serr | "Incorrect index" | index;
                         abort();
+        }
 …
         while( !done ) {
                    waitfor( get_index, this );
                 or waitfor( call1, this ) { sout | "Statement" | endl; if( this.last_val != 1 ) { serr | "Incorrect index: expected" | 1 | "got" | this.last_val | endl; } }
                 or waitfor( call2, this ) { sout | "Statement" | endl; if( this.last_val != 2 ) { serr | "Incorrect index: expected" | 2 | "got" | this.last_val | endl; } }
                 or waitfor( call3, this ) { sout | "Statement" | endl; if( this.last_val != 3 ) { serr | "Incorrect index: expected" | 3 | "got" | this.last_val | endl; } }
                 or waitfor( call4, this ) { sout | "Statement" | endl; if( this.last_val != 4 ) { serr | "Incorrect index: expected" | 4 | "got" | this.last_val | endl; } }
                 or waitfor( call5, this ) { sout | "Statement" | endl; if( this.last_val != 5 ) { serr | "Incorrect index: expected" | 5 | "got" | this.last_val | endl; } }
                 or waitfor( call6, this ) { sout | "Statement" | endl; if( this.last_val != 6 ) { serr | "Incorrect index: expected" | 6 | "got" | this.last_val | endl; } }
                 or waitfor( call7, this ) { sout | "Statement" | endl; if( this.last_val != 7 ) { serr | "Incorrect index: expected" | 7 | "got" | this.last_val | endl; } }
+                or waitfor( call1, this ) { sout | "Statement"; if( this.last_val != 1 ) { serr | "Incorrect index: expected" | 1 | "got" | this.last_val; } }
+                or waitfor( call2, this ) { sout | "Statement"; if( this.last_val != 2 ) { serr | "Incorrect index: expected" | 2 | "got" | this.last_val; } }
+                or waitfor( call3, this ) { sout | "Statement"; if( this.last_val != 3 ) { serr | "Incorrect index: expected" | 3 | "got" | this.last_val; } }
+                or waitfor( call4, this ) { sout | "Statement"; if( this.last_val != 4 ) { serr | "Incorrect index: expected" | 4 | "got" | this.last_val; } }
+                or waitfor( call5, this ) { sout | "Statement"; if( this.last_val != 5 ) { serr | "Incorrect index: expected" | 5 | "got" | this.last_val; } }
+                or waitfor( call6, this ) { sout | "Statement"; if( this.last_val != 6 ) { serr | "Incorrect index: expected" | 6 | "got" | this.last_val; } }
+                or waitfor( call7, this ) { sout | "Statement"; if( this.last_val != 7 ) { serr | "Incorrect index: expected" | 7 | "got" | this.last_val; } }
                 done = true;
 …
 int main() {
         processor p[2];
         sout | "Starting" | endl;
+        sout | "Starting";
+        {
                 caller c[7];
                 waiter w;
+        }
         sout | "Stopping" | endl;
+        sout | "Stopping";
+}

tests/concurrent/waitfor/when.c

-              rcdc02f2
+              r515a037
 void arbiter( global_t & mutex this ) {
         for( int i = 0; i < N; i++ ) {
                    when( this.last_call == 6 ) waitfor( call1, this ) { if( this.last_call != 1) { serr | "Expected last_call to be 1 got" | this.last_call | endl; } }
                 or when( this.last_call == 1 ) waitfor( call2, this ) { if( this.last_call != 2) { serr | "Expected last_call to be 2 got" | this.last_call | endl; } }
                 or when( this.last_call == 2 ) waitfor( call3, this ) { if( this.last_call != 3) { serr | "Expected last_call to be 3 got" | this.last_call | endl; } }
                 or when( this.last_call == 3 ) waitfor( call4, this ) { if( this.last_call != 4) { serr | "Expected last_call to be 4 got" | this.last_call | endl; } }
                 or when( this.last_call == 4 ) waitfor( call5, this ) { if( this.last_call != 5) { serr | "Expected last_call to be 5 got" | this.last_call | endl; } }
                 or when( this.last_call == 5 ) waitfor( call6, this ) { if( this.last_call != 6) { serr | "Expected last_call to be 6 got" | this.last_call | endl; } }
+                   when( this.last_call == 6 ) waitfor( call1, this ) { if( this.last_call != 1) { serr | "Expected last_call to be 1 got" | this.last_call; } }
+                or when( this.last_call == 1 ) waitfor( call2, this ) { if( this.last_call != 2) { serr | "Expected last_call to be 2 got" | this.last_call; } }
+                or when( this.last_call == 2 ) waitfor( call3, this ) { if( this.last_call != 3) { serr | "Expected last_call to be 3 got" | this.last_call; } }
+                or when( this.last_call == 3 ) waitfor( call4, this ) { if( this.last_call != 4) { serr | "Expected last_call to be 4 got" | this.last_call; } }
+                or when( this.last_call == 4 ) waitfor( call5, this ) { if( this.last_call != 5) { serr | "Expected last_call to be 5 got" | this.last_call; } }
+                or when( this.last_call == 5 ) waitfor( call6, this ) { if( this.last_call != 6) { serr | "Expected last_call to be 6 got" | this.last_call; } }
                 sout | this.last_call | endl;
+                sout | this.last_call;
+        }
 …
 int main() {
         srandom( time(NULL) );
         sout | "Starting" | endl;
+        sout | "Starting";
+        {
                 arbiter_t arbiter;
 …
+        }
         sout | "Stopping" | endl;
+        sout | "Stopping";
+}

tests/coroutine/.expect/fmtLines.txt

-              rcdc02f2
+              r515a037
 difi  ed B  y :   Pete  r A.
  Buh  r//   Last   Mod  ifie
 d On   : M  on S  ep 1  8 11
 :35:  57 2  017/  / Up  date
  Cou  nt       :   31/  /#in
+d On   : T  ue D  ec 1  1 23
+:31:  12 2  018/  / Up  date
+ Cou  nt       :   32/  /#in
 clud  e <f  stre  am.h  fa>#
 incl  ude   <cor  outi  ne.h
 …
 t )   {      if   ( fm  t.g
 != 0   ||   fmt.  b !=   0 )
+ sou  t |   endl  ;}vo  id m
+ain(   For  mat   & fm  t )
+{       fo  r (   ;; )   {
+                                  // f  or a  s ma  ny c
+hara  cter  s           f  or (   fmt
+.g =   0;   fmt.  g <   5; f
+mt.g   +=   1 )   {             /  / gr
+oups   of   5 bl  ocks                          f
+or (   fmt  .b =   0;   fmt.
+b <   4; f  mt.b   +=   1 )
+{       //   blo  cks   of 4   cha
+ract  ers                               f  or (   ;;
+) {                                                     //   for   new
+line   cha  ract  ers
+susp  end(  );                                  i  f (
+fmt.  ch !  = '\  n' )   bre
+ak;             //   igno  re n  ewli
+ne                              }   // f  or                            so
+ut |   fmt  .ch;                                                        /
+/ pr  int   char  acte  r
+} //   for                      s  out   | "
+ ";                                                             /  / pr  int
+bloc  k se  para  tor           } /
+/ fo  r         s  out   | en  dl;
+                                                                  // p  rint   gro
+up s  epar  ator        } /  / fo
+r} /  / ma  invo  id p  rt(
+Form  at &   fmt  , ch  ar c
+h )   {      fmt  .ch   = ch
+;      res  ume(   fmt   );}
+ //   prti  nt m  ain(  ) {
+Form  at f  mt;   char   ch;
+        for   ( ;  ; )   {              s  in |
+ ch;                                                                            //   rea
+d on  e ch  arac  ter       if
+ ( e  of(   sin   ) )   brea
+k;                                                      //   eof   ?            p
+rt(   fmt,   ch   );    }   //
+for}   //   main  // L  ocal
+ Var  iabl  es:   ////   tab
+-wid  th:   4 //  // c  ompi
+le-c  omma  nd:   "cfa   fmt
+Line  s.c"   ///  / En  d: /
+/
+ sou  t |   nl;}  void   mai
+n( F  orma  t &   fmt   ) {
+for   ( ;;   ) {
+                //   for   as   many   cha
+ract  ers               for   ( f  mt.g
+ = 0  ; fm  t.g   < 5;   fmt
+.g +  = 1   ) {         //   grou
+ps o  f 5   bloc  ks                    for
+ ( f  mt.b   = 0  ; fm  t.b
+< 4;   fmt  .b +  = 1   ) {
+// b  lock  s of   4 c  hara
+cter  s                         for   ( ;  ; )
+{                                                         // f  or n  ewli
+ne c  hara  cter  s                                     su
+spen  d();                                      if   ( fm
+t.ch   !=   '\n'   ) b  reak
+;               /  / ig  nore   new  line
+                                  } //   for                              sout
+ | f  mt.c  h;                                                  //
+prin  t ch  arac  ter                   }
+// f  or                        sou  t |   "  "
+;                                                               //   prin  t bl
+ock   sepa  rato  r             }   //
+for             sou  t |   nl;
+                                  // p  rint   gro  up s
+epar  ator      } /  / fo  r} /
+/ ma  invo  id p  rt(   Form
+at &   fmt  , ch  ar c  h )
+{      fmt  .ch   = ch  ;
+ res  ume(   fmt   );}   //
+prti  nt m  ain(  ) {     Form
+at f  mt;         char   ch;    for
+ ( ;  ; )   {           s  in |   ch;
+                                                                                //   rea  d on
+e ch  arac  ter     if   ( e
+of(   sin   ) )   brea  k;
+                                        //   eof   ?            p  rt(
+fmt,   ch   );  }   //   for}
+ //   main  // L  ocal   Var
+iabl  es:   ////   tab  -wid
+th:   4 //  // c  ompi  le-c
+omma  nd:   "cfa   fmt  Line
+s.c"   ///  / En  d: /  /

tests/coroutine/.in/fmtLines.txt

-              rcdc02f2
+              r515a037
 // Created On       : Sun Sep 17 21:56:15 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Sep 18 11:35:57 2017
 // Update Count     : 31
+// Last Modified On : Tue Dec 11 23:31:12 2018
+// Update Count     : 32
 //
 …
 void ^?{}( Format & fmt ) {
     if ( fmt.g != 0 || fmt.b != 0 ) sout | endl;
+    if ( fmt.g != 0 || fmt.b != 0 ) sout | nl;
+}
 …
                         sout | "  ";                                                            // print block separator
                 } // for
                 sout | endl;                                                                    // print group separator
+                sout | nl;                                                                      // print group separator
         } // for
 } // main

tests/coroutine/fibonacci.c

-              rcdc02f2
+              r515a037
 // Created On       : Thu Jun  8 07:29:37 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Aug 18 11:21:58 2018
 // Update Count     : 24
+// Last Modified On : Tue Dec 11 21:57:33 2018
+// Update Count     : 25
 //
 …
         Fibonacci f1, f2;
         for ( 10 ) {                                                                            // print N Fibonacci values
                 sout | next( f1 ) | next( f2 ) | endl;
+                sout | next( f1 ) | next( f2 );
         } // for
+}

tests/coroutine/fibonacci_1.c

-              rcdc02f2
+              r515a037
 // Created On       : Thu Apr 26 23:20:08 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Aug 18 11:21:02 2018
 // Update Count     : 13
+// Last Modified On : Tue Dec 11 21:57:54 2018
+// Update Count     : 14
 //
 …
         Fibonacci f1, f2;
         for ( 10 ) {                                                                            // print N Fibonacci values
                 sout | next( f1 ) | next( f2 ) | endl;
+                sout | next( f1 ) | next( f2 );
         } // for
+}

tests/coroutine/fmtLines.c

-              rcdc02f2
+              r515a037
 // Created On       : Sun Sep 17 21:56:15 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Aug 16 08:20:54 2018
 // Update Count     : 45
+// Last Modified On : Tue Dec 11 21:58:49 2018
+// Update Count     : 47
 //
 …
                         sout | "  ";                                                            // print block separator
                 } // for
                 sout | endl;                                                                    // print group separator
+                sout | nl;                                                                              // print group separator
         } // for
 } // main
 …
 void ^?{}( Format & fmt ) with( fmt ) {
         if ( g != 0 || b != 0 ) sout | endl;
+        if ( g != 0 || b != 0 ) sout | nl;
+}
 …
 int main() {
         Format fmt;
+        sout | nlOff;                                                                           // turn off auto newline
   eof: for () {                                                                                 // read until end of file

tests/coroutine/pingpong.c

-              rcdc02f2
+              r515a037
 // Created On       : Wed Sep 20 11:55:23 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Aug 18 11:31:11 2018
 // Update Count     : 28
+// Last Modified On : Tue Dec 11 21:58:06 2018
+// Update Count     : 29
 //
 …
 void main( PingPong & pingpong ) {                                              // ping's starter ::main, pong's starter ping
         for ( pingpong.N ) {                                                            // N ping-pongs
                 sout | pingpong.name | endl;
+                sout | pingpong.name;
                 cycle( *pingpong.part );
         } // for

tests/coroutine/prodcons.c

-              rcdc02f2
+              r515a037
 // Created On       : Mon Sep 18 12:23:39 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Aug 18 12:55:10 2018
 // Update Count     : 51
+// Last Modified On : Tue Dec 11 21:58:25 2018
+// Update Count     : 52
 //
 …
                 int p1 = random( 100 );
                 int p2 = random( 100 );
                 sout | p1 | " " | p2 | endl;
+                sout | p1 | " " | p2;
                 int status = delivery( *c, p1, p2 );
                 sout | " $" | money | endl;
                 sout | status | endl;
+                sout | " $" | money;
+                sout | status;
                 receipt += 1;
+        }
         stop( *c );
         sout | "prod stops" | endl;
+        sout | "prod stops";
+}
 int payment( Prod & prod, int money ) {
 …
         int money = 1, receipt;
         for ( ; ! done; ) {
                 sout | p1 | " " | p2 | endl;
                 sout | " $" | money | endl;
+                sout | p1 | " " | p2;
+                sout | " $" | money;
                 status += 1;
                 receipt = payment( *p, money );
                 sout | " #" | receipt | endl;
+                sout | " #" | receipt;
                 money += 1;
+        }
         sout | "cons stops" | endl;
+        sout | "cons stops";
+}
 int delivery( Cons & cons, int p1, int p2 ) {
 …
         srandom( /* getpid() */ 103 );                                          // fixed seed for testing
         start( prod, 5, cons );
         sout | "main stops" | endl;
+        sout | "main stops";
+}

tests/coroutine/runningTotal.c

-              rcdc02f2
+              r515a037
 // Created On       : Wed Dec  6 08:05:27 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Aug 16 08:22:29 2018
 // Update Count     : 3
+// Last Modified On : Tue Dec 11 21:59:00 2018
+// Update Count     : 4
 //
 …
         RunTotal rntl;
         for ( i; 10 ) {
                 sout | i | add( rntl, i ) | endl;
+                sout | i | add( rntl, i );
         } // for
+}

tests/counter.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // counter.c --
+// counter.cfa --
 //
 // Author           : Aaron B. Moss
 // Created On       : Thu Feb 22 15:27:00 2018
 // Last Modified By : Aaron B. Moss
 // Last Modified On : Thu Feb 22 15:27:00 2018
 // Update Count     : 1
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue Nov  6 17:50:23 2018
+// Update Count     : 2
 //
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa counter.c" //
+// compile-command: "cfa counter.cfa" //
 // End: //

tests/declarationErrors.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // declarationErrors.c --
+// declarationErrors.cfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Wed Aug 17 08:23:43 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Sep  9 22:57:52 2016
 // Update Count     : 31
+// Last Modified On : Tue Nov  6 17:52:47 2018
+// Update Count     : 32
 //
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa declarationErrors.c" //
+// compile-command: "cfa declarationErrors.cfa" //
 // End: //

tests/declarationSpecifier.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // declarationSpecifier.c --
+// declarationSpecifier.cfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Wed Aug 17 08:21:04 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Aug 17 08:24:33 2016
 // Update Count     : 2
+// Last Modified On : Tue Nov  6 17:52:59 2018
+// Update Count     : 3
 //
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa declarationSpecifier.c" //
+// compile-command: "cfa declarationSpecifier.cfa" //
 // End: //

tests/div.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // div.c --
+// div.cfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Tue Aug  8 16:28:43 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Dec  7 09:06:52 2017
 // Update Count     : 18
+// Last Modified On : Tue Dec  4 21:35:01 2018
+// Update Count     : 20
 //
 #include <fstream.hfa>
 #include <stdlib.hfa>                                                                           // div
+#include <stdlib.hfa>                                                                   // div
 struct T { int i; };
 …
 int main( void ) {
         sout | "div" | div( 13, 5 ) | div( 13L, 5L ) | div( 13LL, 5LL ) | endl;
+        sout | "div" | div( 13, 5 ) | div( 13L, 5L ) | div( 13LL, 5LL );
         short s1 = 13, s2 = 5;
         sout | "div" | div( s1, s2 ) | endl;
+        sout | "div" | div( s1, s2 );
         T t1 = { 13 }, t2 = { 5 };
         sout | "div" | div( t1, t2 ) | endl;                            // polymorphic div
+        sout | "div" | div( t1, t2 );                                           // polymorphic div
 } // main
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa div.c" //
+// compile-command: "cfa div.cfa" //
 // End: //

tests/except-0.cfa

-              rcdc02f2
+              r515a037
 #include <stdbool.h>
 #include "except-mac.h"
+#include "except-mac.hfa"
 TRIVIAL_EXCEPTION(yin)
 TRIVIAL_EXCEPTION(yang)
 …
 void ^?{}(signal_exit * this) {
         printf("Exiting: %s\n", this->area);
 //      sout | "Exiting:" | this->area | endl;
+//      sout | "Exiting:" | this->area;
+}

tests/except-1.cfa

rcdc02f2	r515a037
5	5	#include <stdio.h>
6	6
7		#include "except-mac.h"
	7	#include "except-mac.hfa"
8	8	TRIVIAL_EXCEPTION(yin)
9	9	TRIVIAL_EXCEPTION(yang)

tests/except-2.cfa

rcdc02f2	r515a037
3	3
4	4	#include <stdlib.hfa>
5		#include "except-mac.h"
	5	#include "except-mac.hfa"
6	6
7	7	TRIVIAL_EXCEPTION(yin)

tests/except-3.cfa

rcdc02f2	r515a037
2	2
3	3	#include <stdio.h>
4		#include "except-mac.h"
	4	#include "except-mac.hfa"
5	5	TRIVIAL_EXCEPTION(myth)
6	6

tests/extension.cfa

-              rcdc02f2
+              r515a037
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 //
 // extension.c --
+// extension.cfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Mon Jul  4 20:42:43 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Feb  6 15:44:39 2017
 // Update Count     : 46
+// Last Modified On : Tue Nov  6 17:53:21 2018
+// Update Count     : 47
 //
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa extension.c" //
+// compile-command: "cfa extension.cfa" //
 // End: //

tests/fallthrough.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // fallthrough.c --
+// fallthrough.cfa --
 //
 // Author           : Rob Schluntz
 // Created On       : Wed Mar 14 10:06:25 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Aug 16 08:21:46 2018
 // Update Count     : 14
+// Last Modified On : Tue Dec  4 21:36:14 2018
+// Update Count     : 17
 //
+#include <fstream.hfa>
 void test(int choice) {
         choose ( choice ) {
                 case 1:
                         printf("case 1\n");
+                        sout | "case 1";
                         fallthru;
                 case 2:
                         printf("case 2\n");
+                        sout | "case 2";
                         fallthru;
                         printf("did not fallthru\n");
+                        sout | "did not fallthru";
                         if ( 7 ) fallthru common2;
                         fallthru common1;
                 case 3:
                         printf("case 3\n");
+                        sout | "case 3";
                         fallthru default;
                         fallthru common1;
                 common1:
                         printf("common1\n");
+                        sout | "common1";
                 // break
                 case 4:
                         printf("case 4\n");
+                        sout | "case 4";
                         fallthru common2;
                 case 5:
                         printf("case 5\n");
+                        sout | "case 5";
                         fallthru common2;
                         fallthru default;
                 case 6:
                         printf("case 6\n");
+                        sout | "case 6";
                         fallthru common2;
                 common2:
                         printf("common2\n");
+                        sout | "common2";
                 // break
                 default:
                         printf("default\n");
+                        sout | "default";
                         fallthru;
+        }
         printf("\n");
+        sout | nl;
         switch ( choice ) {
           case 1:
                 printf("case 1\n");
+                sout | "case 1";
                 switch ( choice ) {
                   case 1:
                         printf("case 1\n");
+                        sout | "case 1";
                         for ( int i = 0; i < 4; i += 1 ) {
                                 printf("%d\n", i);
 …
                 break;
           case 5:
                 printf("case 5\n");
+                sout | "case 5";
                 if ( choice == 5 ) {
                         if ( choice != 5 ) {
                                 printf("error\n");
+                                sout | "error";
                         } else {
                                 printf("check\n");
+                                sout | "check";
                                 fallthru common;
                         } // if
 …
 int main() {
         test(1);
         printf("\n");
         test(5);
+        test( 1 );
+        sout | nl;
+        test( 5 );
+}
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa fallthrough.c" //
+// compile-command: "cfa fallthrough.cfa" //
 // End: //

tests/forall.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // forall.c --
+// forall.cfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Wed May  9 08:48:15 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jul 12 16:19:08 2018
 // Update Count     : 30
+// Last Modified On : Tue Nov  6 17:53:43 2018
+// Update Count     : 31
 //
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa forall.c" //
+// compile-command: "cfa forall.cfa" //
 // End: //

tests/fstream_test.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // fstream_test.c --
+// fstream_test.cfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Aug 24 11:30:26 2017
 // Update Count     : 65
+// Last Modified On : Tue Dec  4 21:36:34 2018
+// Update Count     : 67
 //
 …
 int main( void ) {
         int nombre;
         sout | "Entrez un nombre, s'il vous plaît:" | endl;
+        sout | "Entrez un nombre, s'il vous plaît:";
         sin  | nombre;
         sout | "Vous avez entré" | nombre | endl;
+        sout | "Vous avez entré" | nombre;
         sout | "le nombre" | nombre | "est"
                  | (nombre > 0 ? "positif" : nombre == 0 ? "zéro" : "négatif") | endl;
+                 | (nombre > 0 ? "positif" : nombre == 0 ? "zéro" : "négatif");
         sout | "Entrez trois nombres, s'il vous plaît: " | endl;
+        sout | "Entrez trois nombres, s'il vous plaît: ";
         int i, j, k;
         sin  | i | j | k;
         sout | "Vous avez entré" | "i:" | "" | i | "j:" | "" | j | "k:" | "" | k | endl;
+        sout | "Vous avez entré" | "i:" | "" | i | "j:" | "" | j | "k:" | "" | k;
+}
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa fstream_test.c" //
+// compile-command: "cfa fstream_test.cfa" //
 // End: //

tests/function-operator.cfa

-              rcdc02f2
+              r515a037
 // Created On       : Fri Aug 25 15:21:11 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Aug  2 09:27:53 2018
 // Update Count     : 8
+// Last Modified On : Tue Dec  4 21:37:09 2018
+// Update Count     : 9
 //
 …
 // TODO: abstract over (os, T)
 os_wrapper ?=?(os_wrapper & wrapper, int x) {
         *wrapper.out | x | endl;
+        *wrapper.out | x;
         return wrapper;
+}

tests/functions.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // functions.c --
+// functions.cfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Wed Aug 17 08:39:58 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Jan 17 22:44:12 2018
 // Update Count     : 12
+// Last Modified On : Tue Nov  6 17:54:09 2018
+// Update Count     : 13
 //
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa functions.c" //
+// compile-command: "cfa functions.cfa" //
 // End: //

tests/gccExtensions.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // gccExtensions.c --
+// gccExtensions.cfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Sun Aug 14 17:28:17 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Aug 17 09:26:50 2016
 // Update Count     : 10
+// Last Modified On : Tue Nov  6 17:54:20 2018
+// Update Count     : 11
 //
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa gccExtensions.c" //
+// compile-command: "cfa gccExtensions.cfa" //
 // End: //

tests/gmp.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // gmp.c --
+// gmp.cfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Tue Apr 19 08:55:51 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Aug 18 12:43:13 2018
 // Update Count     : 556
+// Last Modified On : Tue Dec  4 21:37:29 2018
+// Update Count     : 558
 //
 …
 int main( void ) {
         sout | "constructors" | endl;
+        sout | "constructors";
         short int si = 3;
         Int x = { "50000000000000000000" }, y = { si }, z = x + y;
         sout | x | y | z | endl;
         sout | "x:" | x | "y:" | y | "z:" | z | endl;
+        sout | x | y | z;
+        sout | "x:" | x | "y:" | y | "z:" | z;
         sout | "conversions" | endl;
+        sout | "conversions";
         y = 'a';
         sout | "y:" | y | endl;
+        sout | "y:" | y;
         y = "12345678901234567890123456789";
         sout | "y:" | y | endl;
+        sout | "y:" | y;
         y = 100`mp + 100`mp;
         sout | "y:" | y | endl;
+        sout | "y:" | y;
         y = -200u`mp + -200u`mp;
         sout | "y:" | y | endl;
+        sout | "y:" | y;
         y = "12345678901234567890123456789"`mp + "12345678901234567890123456789"`mp;
         sout | "y:" | y | endl;
+        sout | "y:" | y;
         y = si;
         sout | "y:" | y | endl;
+        sout | "y:" | y;
         y = -3;
         sout | "y:" | y | endl;
+        sout | "y:" | y;
         y += 7;
         sout | "y:" | y | endl;
+        sout | "y:" | y;
         y -= 1;
         sout | "y:" | y | endl;
+        sout | "y:" | y;
         int b;
         b = y;
         si = y;
         sout | "y:" | y | "b:" | b | "si:" | si | endl;
+        sout | "y:" | y | "b:" | b | "si:" | si;
         sout | "comparison" | endl;
         sout | x == x | endl;
         sout | x != x | endl;
         sout | x < x | endl;
         sout | x <= x | endl;
         sout | x > x | endl;
         sout | x >= x | endl;
+        sout | "comparison";
+        sout | x == x;
+        sout | x != x;
+        sout | x < x;
+        sout | x <= x;
+        sout | x > x;
+        sout | x >= x;
         sout | "arithmetic" | endl;
+        sout | "arithmetic";
         z = x + y + z;
         sout | "z:" | z | endl;
+        sout | "z:" | z;
         z = z = x;
         sout | "z:" | z | endl;
+        sout | "z:" | z;
         z = x - y - z;
         sout | "z:" | z | endl;
+        sout | "z:" | z;
         z = x * y * z;
         sout | "z:" | z | endl;
+        sout | "z:" | z;
         z = x * 3;
         sout | "z:" | z | endl;
+        sout | "z:" | z;
         z = 3 * x;
         sout | "z:" | z | endl;
+        sout | "z:" | z;
         z = x / 3;
         sout | "z:" | z | endl;
         sout | div( x, 3 ) | x / 3 | "," | x % 3 | endl;
+        sout | "z:" | z;
+        sout | div( x, 3 ) | x / 3 | "," | x % 3;
         [ x, y ] = div( x, 3 );
         sout | "x:" | x | "y:" | y | endl;
+        sout | "x:" | x | "y:" | y;
         sout | endl;
+        sout;
         sin | x | y | z;
         sout | x | y | z | endl;
+        sout | x | y | z;
         sout | endl;
+        sout;
         sout | "Fibonacci Numbers" | endl;
+        sout | "Fibonacci Numbers";
         Int fn, fn1, fn2;
         fn = (Int){0}; fn1 = fn;                                                        // 1st case
         sout | (int)0 | fn | endl;
+        sout | (int)0 | fn;
         fn = 1; fn2 = fn1; fn1 = fn;                                            // 2nd case
         sout | 1 | fn | endl;
+        sout | 1 | fn;
         for ( i; 2u ~= 200 ) {
                 fn = fn1 + fn2; fn2 = fn1; fn1 = fn;                    // general case
                 sout | i | fn | endl;
+                sout | i | fn;
         } // for
         sout | endl;
+        sout;
         sout | "Factorial Numbers" | endl;
+        sout | "Factorial Numbers";
         Int fact = 1;                                                                           // 1st case
         sout | (int)0 | fact | endl;
+        sout | (int)0 | fact;
         for ( i; 1u ~= 40u ) {
                 fact *= i;                                                                              // general case
                 sout | i | fact | endl;
+                sout | i | fact;
         } // for
 } // main
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa gmp.c -lgmp" //
+// compile-command: "cfa gmp.cfa -lgmp" //
 // End: //

tests/heap.cfa

-              rcdc02f2
+              r515a037
+//
+// Cforall Version 1.0.0 Copyright (C) 2017 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// heap.cfa --
+//
+// Author           : Peter A. Buhr
+// Created On       : Tue Nov  6 17:54:56 2018
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue Dec 11 21:52:40 2018
+// Update Count     : 18
+//
 #include <thread.hfa>
 #include <kernel.hfa>                                                                           // processor
 #include <stdlib.hfa>                                                                           // *allocs
+#include <kernel.hfa>                                                                   // processor
+#include <stdlib.hfa>                                                                   // *allocs
 #include <malloc.h>                                                                             // malloc_*
 …
 void main( Worker & ) {
     enum { NoOfAllocs = 5000, NoOfMmaps = 10 };
     char *locns[NoOfAllocs];
+    char * locns[NoOfAllocs];
     int i;
     // check alloc/free
     for ( int j = 0; j < 40; j += 1 ) {
                 for ( i = 0; i < NoOfAllocs; i += 1 ) {
+    for ( j; 40 ) {
+                for ( i; NoOfAllocs ) {
                         locns[i] = alloc( i );
                         //sout | (void *)locns[i] | endl;
                         for ( int k = 0; k < i; k += 1 ) locns[i][k] = '\345';
                 } // for
                 //sout | (char *)sbrk(0) - start | " bytes" | endl;
                 for ( i = 0; i < NoOfAllocs; i += 1 ) {
                         //sout | (void *)locns[i] | endl;
                         for ( int k = 0; k < i; k += 1 ) if ( locns[i][k] != '\345' ) abort( "new/delete corrupt storage1" );
+                        //sout | (void *)locns[i];
+                        for ( k; i ) locns[i][k] = '\345';
+                } // for
+                //sout | (char *)sbrk(0) - start | " bytes";
+                for ( i; NoOfAllocs ) {
+                        //sout | (void *)locns[i];
+                        for ( k; i ) if ( locns[i][k] != '\345' ) abort( "new/delete corrupt storage1" );
                         free( locns[i] );
                 } // for
                 //sout | (char *)sbrk(0) - start | " bytes" | endl;
                 for ( i = 0; i < NoOfAllocs; i += 1 ) {
+                //sout | (char *)sbrk(0) - start | " bytes";
+                for ( i; NoOfAllocs ) {
                         locns[i] = alloc( i );
                         //sout | (void *)locns[i] | endl;
                         for ( int k = 0; k < i; k += 1 ) locns[i][k] = '\345';
                 } // for
                 for ( i = NoOfAllocs - 1; i >=0 ; i -= 1 ) {
                         //sout | (void *)locns[i] | endl;
                         for ( int k = 0; k < i; k += 1 ) if ( locns[i][k] != '\345' ) abort( "new/delete corrupt storage2" );
+                        //sout | (void *)locns[i];
+                        for ( k; i ) locns[i][k] = '\345';
+                } // for
+                for ( i; NoOfAllocs - 1 -~= 0 ) {
+                        //sout | (void *)locns[i];
+                        for ( k; i ) if ( locns[i][k] != '\345' ) abort( "new/delete corrupt storage2" );
                         free( locns[i] );
                 } // for
 …
     // check malloc/free (sbrk)
     for ( i = 0; i < NoOfAllocs; i += 1 ) {
+    for ( i; NoOfAllocs ) {
                 size_t s = (i + 1) * 20;
                 char *area = (char *)malloc( s );
+                char * area = (char *)malloc( s );
                 if ( area == 0 ) abort( "malloc/free out of memory" );
                 area[0] = '\345'; area[s - 1] = '\345';                 // fill first/last
 …
     } // for
     for ( i = 0; i < NoOfAllocs; i += 1 ) {
                 size_t s = i + 1;                               // +1 to make initialization simpler
+    for ( i; NoOfAllocs ) {
+                size_t s = i + 1;                                                               // +1 to make initialization simpler
                 locns[i] = (char *)malloc( s );
                 if ( locns[i] == 0 ) abort( "malloc/free out of memory" );
 …
                 locns[i][malloc_usable_size( locns[i] ) - 1] = '\345'; // fill ultimate byte
     } // for
     for ( i = 0; i < NoOfAllocs; i += 1 ) {
+    for ( i; NoOfAllocs ) {
                 size_t s = i + 1;
                 if ( locns[i][0] != '\345' || locns[i][s - 1] != '\345' ||
 …
     // check malloc/free (mmap)
     for ( i = 0; i < NoOfMmaps; i += 1 ) {
                 size_t s = i + default_mmap_start();                            // cross over point
                 char *area = (char *)malloc( s );
+    for ( i; NoOfMmaps ) {
+                size_t s = i + default_mmap_start();                    // cross over point
+                char * area = (char *)malloc( s );
                 if ( area == 0 ) abort( "malloc/free out of memory" );
                 area[0] = '\345'; area[s - 1] = '\345';                 // fill first/last
 …
     } // for
     for ( i = 0; i < NoOfMmaps; i += 1 ) {
                 size_t s = i + default_mmap_start();                            // cross over point
+    for ( i; NoOfMmaps ) {
+                size_t s = i + default_mmap_start();                    // cross over point
                 locns[i] = (char *)malloc( s );
                 if ( locns[i] == 0 ) abort( "malloc/free out of memory" );
 …
                 locns[i][malloc_usable_size( locns[i] ) - 1] = '\345'; // fill ultimate byte
     } // for
     for ( i = 0; i < NoOfMmaps; i += 1 ) {
                 size_t s = i + default_mmap_start();                            // cross over point
+    for ( i; NoOfMmaps ) {
+                size_t s = i + default_mmap_start();                    // cross over point
                 if ( locns[i][0] != '\345' || locns[i][s - 1] != '\345' ||
                          locns[i][malloc_usable_size( locns[i] ) - 1] != '\345' ) abort( "malloc/free corrupt storage" );
 …
     // check calloc/free (sbrk)
     for ( i = 0; i < NoOfAllocs; i += 1 ) {
+    for ( i; NoOfAllocs ) {
                 size_t s = (i + 1) * 20;
                 char *area = (char *)calloc( 5, s );
+                char * area = (char *)calloc( 5, s );
                 if ( area == 0 ) abort( "calloc/free out of memory" );
                 if ( area[0] != '\0' || area[s - 1] != '\0' ||
 …
     } // for
     for ( i = 0; i < NoOfAllocs; i += 1 ) {
+    for ( i; NoOfAllocs ) {
                 size_t s = i + 1;
                 locns[i] = (char *)calloc( 5, s );
 …
                 locns[i][malloc_usable_size( locns[i] ) - 1] = '\345'; // fill ultimate byte
     } // for
     for ( i = 0; i < NoOfAllocs; i += 1 ) {
+    for ( i; NoOfAllocs ) {
                 size_t s = i + 1;
                 if ( locns[i][0] != '\345' || locns[i][s - 1] != '\345' ||
 …
     // check calloc/free (mmap)
     for ( i = 0; i < NoOfMmaps; i += 1 ) {
                 size_t s = i + default_mmap_start();                            // cross over point
                 char *area = (char *)calloc( 1, s );
+    for ( i; NoOfMmaps ) {
+                size_t s = i + default_mmap_start();                    // cross over point
+                char * area = (char *)calloc( 1, s );
                 if ( area == 0 ) abort( "calloc/free out of memory" );
                 if ( area[0] != '\0' || area[s - 1] != '\0' ) abort( "calloc/free corrupt storage4.1" );
 …
     } // for
     for ( i = 0; i < NoOfMmaps; i += 1 ) {
                 size_t s = i + default_mmap_start();                            // cross over point
+    for ( i; NoOfMmaps ) {
+                size_t s = i + default_mmap_start();                    // cross over point
                 locns[i] = (char *)calloc( 1, s );
                 if ( locns[i] == 0 ) abort( "calloc/free out of memory" );
 …
                 locns[i][malloc_usable_size( locns[i] ) - 1] = '\345'; // fill ultimate byte
     } // for
     for ( i = 0; i < NoOfMmaps; i += 1 ) {
                 size_t s = i + default_mmap_start();                            // cross over point
+    for ( i; NoOfMmaps ) {
+                size_t s = i + default_mmap_start();                    // cross over point
                 if ( locns[i][0] != '\345' || locns[i][s - 1] != '\345' ||
                          locns[i][malloc_usable_size( locns[i] ) - 1] != '\345' ) abort( "calloc/free corrupt storage6" );
 …
     enum { limit = 64 * 1024 };                                                 // check alignments up to here
     for ( size_t a = libAlign(); a <= limit; a += a ) { // generate powers of 2
                 //sout | alignments[a] | endl;
                 for ( int s = 1; s < NoOfAllocs; s += 1 ) {             // allocation of size 0 can return null
                         char *area = (char *)memalign( a, s );
+        for ( a; libAlign() ~= limit ~ a ) {                            // generate powers of 2
+                //sout | alignments[a];
+                for ( s; 1 ~ NoOfAllocs ) {                                             // allocation of size 0 can return null
+                        char * area = (char *)memalign( a, s );
                         if ( area == 0 ) abort( "memalign/free out of memory" );
                         //sout | i | " " | area | endl;
+                        //sout | i | " " | area;
                         if ( (size_t)area % a != 0 || malloc_alignment( area ) != a ) { // check for initial alignment
                                 abort( "memalign/free bad alignment : memalign(%d,%d) = %p", (int)a, s, area );
 …
     // check memalign/free (mmap)
     for ( size_t a = libAlign(); a <= limit; a += a ) { // generate powers of 2
                 //sout | alignments[a] | endl;
                 for ( i = 1; i < NoOfMmaps; i += 1 ) {
                         size_t s = i + default_mmap_start();                    // cross over point
                         char *area = (char *)memalign( a, s );
+        for ( a; libAlign() ~= limit ~ a ) {                            // generate powers of 2
+                //sout | alignments[a];
+                for ( i; 1 ~ NoOfMmaps ) {
+                        size_t s = i + default_mmap_start();            // cross over point
+                        char * area = (char *)memalign( a, s );
                         if ( area == 0 ) abort( "memalign/free out of memory" );
                         //sout | i | " " | area | endl;
+                        //sout | i | " " | area;
                         if ( (size_t)area % a != 0 || malloc_alignment( area ) != a ) { // check for initial alignment
                                 abort( "memalign/free bad alignment : memalign(%d,%d) = %p", (int)a, (int)s, area );
 …
     // check calloc/realloc/free (sbrk)
     for ( i = 1; i < 10000; i += 12 ) {
+    for ( i; 1 ~ 10_000 ~ 12 ) {
                 // initial N byte allocation
                 char *area = (char *)calloc( 5, i );
+                char * area = (char *)calloc( 5, i );
                 if ( area == 0 ) abort( "calloc/realloc/free out of memory" );
                 if ( area[0] != '\0' || area[i - 1] != '\0' ||
 …
                 // Do not start this loop index at 0 because realloc of 0 bytes frees the storage.
                 for ( int s = i; s < 256 * 1024; s += 26 ) {    // start at initial memory request
+                for ( s; i ~ 256 * 1024 ~ 26 ) {                                // start at initial memory request
                         area = (char *)realloc( area, s );                      // attempt to reuse storage
                         if ( area == 0 ) abort( "calloc/realloc/free out of memory" );
 …
     // check calloc/realloc/free (mmap)
     for ( i = 1; i < 1000; i += 12 ) {
+    for ( i; 1 ~ 10_000 ~ 12 ) {
                 // initial N byte allocation
                 size_t s = i + default_mmap_start();                            // cross over point
                 char *area = (char *)calloc( 1, s );
+                size_t s = i + default_mmap_start();                    // cross over point
+                char * area = (char *)calloc( 1, s );
                 if ( area == 0 ) abort( "calloc/realloc/free out of memory" );
                 if ( area[0] != '\0' || area[s - 1] != '\0' ||
 …
                 // Do not start this loop index at 0 because realloc of 0 bytes frees the storage.
                 for ( int r = i; r < 256 * 1024; r += 26 ) {    // start at initial memory request
                         area = (char *)realloc( area, r );              // attempt to reuse storage
+                for ( r; i ~ 256 * 1024 ~ 26 ) {                                // start at initial memory request
+                        area = (char *)realloc( area, r );                      // attempt to reuse storage
                         if ( area == 0 ) abort( "calloc/realloc/free out of memory" );
                         if ( area[0] != '\0' || area[r - 1] != '\0' ||
 …
     size_t amount = 2;
     for ( size_t a = libAlign(); a <= limit; a += a ) { // generate powers of 2
+        for ( a; libAlign() ~= limit ~ a ) {                            // generate powers of 2
                 // initial N byte allocation
                 char *area = (char *)memalign( a, amount );             // aligned N-byte allocation
+                char * area = (char *)memalign( a, amount );    // aligned N-byte allocation
                 if ( area == 0 ) abort( "memalign/realloc/free out of memory" ); // no storage ?
                 //sout | alignments[a] | " " | area | endl;
+                //sout | alignments[a] | " " | area;
                 if ( (size_t)area % a != 0 || malloc_alignment( area ) != a ) { // check for initial alignment
                         abort( "memalign/realloc/free bad alignment : memalign(%d,%d) = %p", (int)a, (int)amount, area );
 …
                 // Do not start this loop index at 0 because realloc of 0 bytes frees the storage.
                 for ( int s = amount; s < 256 * 1024; s += 1 ) { // start at initial memory request
+                for ( s; amount ~ 256 * 1024 ) {                                // start at initial memory request
                         if ( area[0] != '\345' || area[s - 2] != '\345' ) abort( "memalign/realloc/free corrupt storage" );
                         area = (char *)realloc( area, s );                      // attempt to reuse storage
                         if ( area == 0 ) abort( "memalign/realloc/free out of memory" ); // no storage ?
                         //sout | i | " " | area | endl;
+                        //sout | i | " " | area;
                         if ( (size_t)area % a != 0 ) {                          // check for initial alignment
                                 abort( "memalign/realloc/free bad alignment %p", area );
 …
     // check cmemalign/free
     for ( size_t a = libAlign(); a <= limit; a += a ) { // generate powers of 2
                 //sout | alignments[a] | endl;
                 for ( int s = 1; s < limit; s += 1 ) {                  // allocation of size 0 can return null
                         char *area = (char *)cmemalign( a, 1, s );
+        for ( a; libAlign() ~= limit ~ a ) {                            // generate powers of 2
+                //sout | alignments[a];
+                for ( s; 1 ~ limit ) {                                                  // allocation of size 0 can return null
+                        char * area = (char *)cmemalign( a, 1, s );
                         if ( area == 0 ) abort( "cmemalign/free out of memory" );
                         //sout | i | " " | area | endl;
+                        //sout | i | " " | area;
                         if ( (size_t)area % a != 0 || malloc_alignment( area ) != a ) { // check for initial alignment
                                 abort( "cmemalign/free bad alignment : cmemalign(%d,%d) = %p", (int)a, s, area );
 …
     amount = 2;
     for ( size_t a = libAlign() + libAlign(); a <= limit; a += a ) { // generate powers of 2
+        for ( a; libAlign() ~= limit ~ a ) {                            // generate powers of 2
                 // initial N byte allocation
                 char *area = (char *)cmemalign( a, 1, amount ); // aligned N-byte allocation
+                char * area = (char *)cmemalign( a, 1, amount ); // aligned N-byte allocation
                 if ( area == 0 ) abort( "cmemalign/realloc/free out of memory" ); // no storage ?
                 //sout | alignments[a] | " " | area | endl;
+                //sout | alignments[a] | " " | area;
                 if ( (size_t)area % a != 0 || malloc_alignment( area ) != a ) { // check for initial alignment
                         abort( "cmemalign/realloc/free bad alignment : cmemalign(%d,%d) = %p", (int)a, (int)amount, area );
 …
                 // Do not start this loop index at 0 because realloc of 0 bytes frees the storage.
                 for ( int s = amount; s < 256 * 1024; s += 1 ) { // start at initial memory request
+                for ( s; amount ~ 256 * 1024 ) {                                // start at initial memory request
                         if ( area[0] != '\345' || area[s - 2] != '\345' ) abort( "cmemalign/realloc/free corrupt storage2" );
                         area = (char *)realloc( area, s );                      // attempt to reuse storage
                         if ( area == 0 ) abort( "cmemalign/realloc/free out of memory" ); // no storage ?
                         //sout | i | " " | area | endl;
+                        //sout | i | " " | area;
                         if ( (size_t)area % a != 0 || malloc_alignment( area ) != a ) { // check for initial alignment
                                 abort( "cmemalign/realloc/free bad alignment %p", area );
 …
                 free( area );
     } // for
         //sout | "worker" | thisTask() | "successful completion" | endl;
+        //sout | "worker" | thisTask() | "successful completion";
 } // Worker main
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa -nodebug -O2 heap.c" //
+// compile-command: "cfa -nodebug -O2 heap.cfa" //
 // End: //

tests/identFuncDeclarator.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // identFuncDeclarator.c --
+// identFuncDeclarator.cfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Wed Aug 17 08:36:34 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Jan 17 22:39:13 2018
 // Update Count     : 2
+// Last Modified On : Tue Nov  6 17:56:33 2018
+// Update Count     : 3
 //
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa identFuncDeclarator.c" //
+// compile-command: "cfa identFuncDeclarator.cfa" //
 // End: //

tests/identParamDeclarator.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // identParamDeclarator.c --
+// identParamDeclarator.cfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Wed Aug 17 08:37:56 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Jan 17 22:36:11 2018
 // Update Count     : 2
+// Last Modified On : Tue Nov  6 17:56:44 2018
+// Update Count     : 3
 //
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa identParamDeclarator.c" //
+// compile-command: "cfa identParamDeclarator.cfa" //
 // End: //

tests/ifwhileCtl.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // ifwhileCtl.c --
+// ifwhileCtl.cfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Sat Aug 26 10:13:11 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Jun  6 17:15:09 2018
 // Update Count     : 21
+// Last Modified On : Tue Dec  4 21:39:18 2018
+// Update Count     : 23
 //
 …
         if ( int x = 1 ) {
                 sout | "x != 0 correct" | endl;
+                sout | "x != 0 correct";
         } else {
                 sout | "x == 0 incorrect" | endl;
+                sout | "x == 0 incorrect";
         } // if
         if ( int x = 4, y = 0 ) {
                 sout | "x != 0 && y != 0 incorrect" | endl;
+                sout | "x != 0 && y != 0 incorrect";
         } else if ( int x = 4, y = 1 ) {
                 sout | "x != 0 && y != 0 correct" | endl;
+                sout | "x != 0 && y != 0 correct";
         } else {
                 sout | "x == 0 || y == 0 incorrect" | endl;
+                sout | "x == 0 || y == 0 incorrect";
         } // if
         if ( int x = 5, y = f( x ); x == y ) {
                 sout | "x == y correct" | endl;
+                sout | "x == y correct";
         } else {
                 sout | "x != y incorrect" | endl;
+                sout | "x != y incorrect";
         } // if
         if ( struct S { int i; } s = { 3 }; s.i < 4 ) {
                 S s1;
                 sout | "s.i < 4 correct" | endl;
+                sout | "s.i < 4 correct";
         } else {
                 S s1;
                 sout | "s.i >= 4 incorrect" | endl;
+                sout | "s.i >= 4 incorrect";
         } // if
         while ( int x = 1 ) {
                 sout | "x != 0 correct" | endl;
+                sout | "x != 0 correct";
                 break;
         } // while
         while ( int x = 4, y = 0 ) {
                 sout | "x != 0 && y != 0 incorrect" | endl;
+                sout | "x != 0 && y != 0 incorrect";
         } // while
         while ( int x = 5, y = f( x ); x == y ) {
                 sout | "x == y correct" | endl;
+                sout | "x == y correct";
                 break;
         } // while
 …
         while ( struct S { int i; } s = { 3 }; s.i < 4 ) {
                 S s1;
                 sout | "s.i < 4 correct" | endl;
+                sout | "s.i < 4 correct";
                 break;
         } // while
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa ifwhileCtl.c" //
+// compile-command: "cfa ifwhileCtl.cfa" //
 // End: //

tests/io1.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // io1.c --
+// io1.cfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Wed Mar  2 16:56:02 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu May 24 21:17:56 2018
 // Update Count     : 104
+// Last Modified On : Tue Dec  4 21:40:28 2018
+// Update Count     : 106
 //
 …
 int main() {
         int x = 3, y = 5, z = 7;
         sout | x * 3 | y + 1 | z << 2 | x == y | (x | y) | (x || y) | (x > z ? 1 : 2) | endl;
         sout | 1 | 2 | 3 | endl;
         sout | '1' | '2' | '3' | endl;
         sout | 1 | "" | 2 | "" | 3 | endl;
         sout | endl;
+        sout | x * 3 | y + 1 | z << 2 | x == y | (x | y) | (x || y) | (x > z ? 1 : 2);
+        sout | 1 | 2 | 3;
+        sout | '1' | '2' | '3';
+        sout | 1 | "" | 2 | "" | 3;
+        sout;
         sout | "opening delimiters" | endl;
+        sout | "opening delimiters";
         sout
                  | "x (" | 1
 …
                  | "x ¿" | 9
                  | "x «" | 10
                  | endl | endl;
+                 | nl;
         sout | "closing delimiters" | endl;
+        sout | "closing delimiters";
         sout
                  | 1 | ", x"
 …
                  | 10 | "] x"
                  | 11 | "} x"
                  | endl | endl;
+                 | nl;
         sout | "opening/closing delimiters" | endl;
+        sout | "opening/closing delimiters";
         sout
                  | "x`" | 1 | "`x'" | 2
 …
                  | "\vx\n" | 9 | "\nx\r" | 10
                  | "\rx"
                  | endl | endl;
+                 | nl;
         sout | "override opening/closing delimiters" | endl;
         sout | "x ( " | 1 | " ) x" | 2 | " , x" | 3 | " :x: " | 4 | endl;
         sout | endl;
+        sout | "override opening/closing delimiters";
+        sout | "x ( " | 1 | " ) x" | 2 | " , x" | 3 | " :x: " | 4;
+        sout;
+}
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa io1.c" //
+// compile-command: "cfa io1.cfa" //
 // End: //

tests/labelledExit.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // labelledExit.c --
+// labelledExit.cfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Wed Aug 10 07:29:39 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Aug 16 08:55:39 2018
 // Update Count     : 3
+// Last Modified On : Tue Nov  6 17:57:42 2018
+// Update Count     : 4
 //
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa labelledExit.c" //
+// compile-command: "cfa labelledExit.cfa" //
 // End: //

tests/limits.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // limits.c --
+// limits.cfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Tue May 10 20:44:20 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Mar  1 16:21:55 2018
 // Update Count     : 7
+// Last Modified On : Tue Nov  6 17:57:55 2018
+// Update Count     : 8
 //
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa limits.c" //
+// compile-command: "cfa limits.cfa" //
 // End: //

tests/literals.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // literals.c --
+// literals.cfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Sat Sep  9 16:34:38 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Jul  1 15:12:15 2018
 // Update Count     : 137
+// Last Modified On : Tue Dec  4 21:44:01 2018
+// Update Count     : 139
 //
 …
 #include <fstream.hfa>
 void f( char v ) { sout | "char " | v | endl; }
 void f( signed char v ) { sout | "signed char " | v | endl; }
 void f( unsigned char v ) { sout | "unsigned char " | v | endl; }
 void f( signed short v ) { sout | "signed short int" | v | endl; }
 void f( unsigned short v ) { sout | "unsigned short int" | v | endl; }
 void f( size_t v ) { sout | "size_t" | v | endl; }
+void f( char v ) { sout | "char " | v; }
+void f( signed char v ) { sout | "signed char " | v; }
+void f( unsigned char v ) { sout | "unsigned char " | v; }
+void f( signed short v ) { sout | "signed short int" | v; }
+void f( unsigned short v ) { sout | "unsigned short int" | v; }
+void f( size_t v ) { sout | "size_t" | v; }
 #endif // __CFA__
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa literals.c" //
+// compile-command: "cfa literals.cfa" //
 // End: //

tests/math1.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // math1.c --
+// math1.cfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Fri Apr 22 14:59:21 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu May 24 21:01:15 2018
 // Update Count     : 85
+// Last Modified On : Tue Dec 11 10:24:31 2018
+// Update Count     : 88
 //
 …
         long double l;
         sout | "fmod:" | 5.0F % -2.0F | fmod( 5.0F, -2.0F ) | 5.0D % -2.0D | fmod( 5.0D, -2.0D ) | 5.0L % -2.0L | fmod( 5.0L, -2.0L ) | endl;
         sout | "remainder:" | remainder( 2.0F, 3.0F ) | remainder( 2.0D, 3.0D ) | remainder( 2.0L, 3.0L ) | endl;
+        sout | "fmod:" | 5.0F % -2.0F | fmod( 5.0F, -2.0F ) | 5.0D % -2.0D | fmod( 5.0D, -2.0D ) | 5.0L % -2.0L | fmod( 5.0L, -2.0L );
+        sout | "remainder:" | remainder( 2.0F, 3.0F ) | remainder( 2.0D, 3.0D ) | remainder( 2.0L, 3.0L );
         int quot;
         f = remquo( 3.6F, 0.5F, &quot );
         sout | "remquo:" | quot | f;
+        sout | "remquo:" | quot | f | nonl;
         d = remquo( 3.6D, 0.5F, &quot );
         sout | quot | d;
+        sout | quot | d | nonl;
         l = remquo( 3.6L, 0.5L, &quot );
         sout | quot | l | endl;
         sout | "div:" | div( 3.6F, 0.5F ) | div( 3.6D, 0.5D ) | div( 3.6L, 0.5L ) | endl;
         sout | "fma:" | fma( 3.0F, -1.0F, 1.0F ) | fma( 3.0D, -1.0D, 1.0D ) | fma( 3.0L, -1.0L, , 1.0L ) | endl;
         sout | "fdim:" | fdim( 1.0F, -1.0F ) | fdim( 1.0D, -1.0D ) | fdim( 1.0L, -1.0L ) | endl;
         sout | "nan:" | (float)nan( "" ) | (double)nan( "" ) | (long double)nan( "" ) | endl;
+        sout | quot | l;
+        sout | "div:" | div( 3.6F, 0.5F ) | div( 3.6D, 0.5D ) | div( 3.6L, 0.5L );
+        sout | "fma:" | fma( 3.0F, -1.0F, 1.0F ) | fma( 3.0D, -1.0D, 1.0D ) | fma( 3.0L, -1.0L, , 1.0L );
+        sout | "fdim:" | fdim( 1.0F, -1.0F ) | fdim( 1.0D, -1.0D ) | fdim( 1.0L, -1.0L );
+        sout | "nan:" | (float)nan( "" ) | (double)nan( "" ) | (long double)nan( "" );
         //---------------------- Exponential ----------------------
         sout | "exp:" | exp( 1.0F ) | exp( 1.0D ) | exp( 1.0L ) | exp( 1.0F+1.0FI ) | exp( 1.0D+1.0DI ) | exp( 1.0DL+1.0LI ) | endl;
         sout | "exp2:" | exp2( 1.0F ) | exp2( 1.0D ) | exp2( 1.0L ) | endl;
         sout | "expm1:" | expm1( 1.0F ) | expm1( 1.0D ) | expm1( 1.0L ) | endl;
         sout | "pow:" | pow( 1.0F, 1.0F ) | pow( 1.0D, 1.0D ) | pow( 1.0L, 1.0L ) | pow( 1.0F+1.0FI, 1.0F+1.0FI ) | pow( 1.0D+1.0DI, 1.0D+1.0DI ) | pow( 1.5DL+1.5LI, 1.5DL+1.5LI ) | endl;
+        sout | "exp:" | exp( 1.0F ) | exp( 1.0D ) | exp( 1.0L ) | exp( 1.0F+1.0FI ) | exp( 1.0D+1.0DI ) | exp( 1.0DL+1.0LI );
+        sout | "exp2:" | exp2( 1.0F ) | exp2( 1.0D ) | exp2( 1.0L );
+        sout | "expm1:" | expm1( 1.0F ) | expm1( 1.0D ) | expm1( 1.0L );
+        sout | "pow:" | pow( 1.0F, 1.0F ) | pow( 1.0D, 1.0D ) | pow( 1.0L, 1.0L ) | pow( 1.0F+1.0FI, 1.0F+1.0FI ) | pow( 1.0D+1.0DI, 1.0D+1.0DI ) | pow( 1.5DL+1.5LI, 1.5DL+1.5LI );
         int b = 4;
         unsigned int e = 2;
     b \= e;
     sout | "\\" | b | b \ e | endl;
     sout | "\\" | 'a' \ 3u | 2 \ 8u | 4 \ 3u | -4 \ 3u | 4 \ -3 | -4 \ -3 | 4.0 \ 2.1 | (1.0f+2.0fi) \ (3.0f+2.0fi) | endl;
+    sout | "\\" | b | b \ e;
+    sout | "\\" | 'a' \ 3u | 2 \ 8u | 4 \ 3u | -4 \ 3u | 4 \ -3 | -4 \ -3 | 4.0 \ 2.1 | (1.0f+2.0fi) \ (3.0f+2.0fi);
 } // main
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa math1.c" //
+// compile-command: "cfa math1.cfa" //
 // End: //

tests/math2.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // math2.c --
+// math2.cfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Fri Apr 22 14:59:21 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu May 24 21:06:10 2018
 // Update Count     : 82
+// Last Modified On : Tue Dec  4 23:11:12 2018
+// Update Count     : 85
 //
 …
         //---------------------- Logarithm ----------------------
         sout | "log:" | log( 1.0F ) | log( 1.0D ) | log( 1.0L ) | log( 1.0F+1.0FI ) | log( 1.0D+1.0DI ) | log( 1.0DL+1.0LI ) | endl;
         sout | "log2:" | log2( 8.0F ) | log2( 8.0D ) | log2( 8.0L ) | endl;
         sout | "log10:" | log10( 100.0F ) | log10( 100.0D ) | log10( 100.0L ) | endl;
         sout | "log1p:" | log1p( 1.0F ) | log1p( 1.0D ) | log1p( 1.0L ) | endl;
         sout | "ilogb:" | ilogb( 1.0F ) | ilogb( 1.0D ) | ilogb( 1.0L ) | endl;
         sout | "logb:" | logb( 8.0F ) | logb( 8.0D ) | logb( 8.0L ) | endl;
+        sout | "log:" | log( 1.0F ) | log( 1.0D ) | log( 1.0L ) | log( 1.0F+1.0FI ) | log( 1.0D+1.0DI ) | log( 1.0DL+1.0LI );
+        sout | "log2:" | log2( 8.0F ) | log2( 8.0D ) | log2( 8.0L );
+        sout | "log10:" | log10( 100.0F ) | log10( 100.0D ) | log10( 100.0L );
+        sout | "log1p:" | log1p( 1.0F ) | log1p( 1.0D ) | log1p( 1.0L );
+        sout | "ilogb:" | ilogb( 1.0F ) | ilogb( 1.0D ) | ilogb( 1.0L );
+        sout | "logb:" | logb( 8.0F ) | logb( 8.0D ) | logb( 8.0L );
         sout | "sqrt:" | sqrt( 1.0F ) | sqrt( 1.0D ) | sqrt( 1.0L ) | sqrt( 1.0F+1.0FI ) | sqrt( 1.0D+1.0DI ) | sqrt( 1.0DL+1.0LI ) | endl;
         sout | "cbrt:" | cbrt( 27.0F ) | cbrt( 27.0D ) | cbrt( 27.0L ) | endl;
         sout | "hypot:" | hypot( 1.0F, -1.0F ) | hypot( 1.0D, -1.0D ) | hypot( 1.0L, -1.0L ) | endl;
+        sout | "sqrt:" | sqrt( 1.0F ) | sqrt( 1.0D ) | sqrt( 1.0L ) | sqrt( 1.0F+1.0FI ) | sqrt( 1.0D+1.0DI ) | sqrt( 1.0DL+1.0LI );
+        sout | "cbrt:" | cbrt( 27.0F ) | cbrt( 27.0D ) | cbrt( 27.0L );
+        sout | "hypot:" | hypot( 1.0F, -1.0F ) | hypot( 1.0D, -1.0D ) | hypot( 1.0L, -1.0L );
         //---------------------- Trigonometric ----------------------
         sout | "sin:" | sin( 1.0F ) | sin( 1.0D ) | sin( 1.0L ) | sin( 1.0F+1.0FI ) | sin( 1.0D+1.0DI ) | sin( 1.0DL+1.0LI ) | endl;
         sout | "cos:" | cos( 1.0F ) | cos( 1.0D ) | cos( 1.0L ) | cos( 1.0F+1.0FI ) | cos( 1.0D+1.0DI ) | cos( 1.0DL+1.0LI ) | endl;
         sout | "tan:" | tan( 1.0F ) | tan( 1.0D ) | tan( 1.0L ) | tan( 1.0F+1.0FI ) | tan( 1.0D+1.0DI ) | tan( 1.0DL+1.0LI ) | endl;
         sout | "asin:" | asin( 1.0F ) | asin( 1.0D ) | asin( 1.0L ) | asin( 1.0F+1.0FI ) | asin( 1.0D+1.0DI ) | asin( 1.0DL+1.0LI ) | endl;
         sout | "acos:" | acos( 1.0F ) | acos( 1.0D ) | acos( 1.0L ) | acos( 1.0F+1.0FI ) | acos( 1.0D+1.0DI ) | acos( 1.0DL+1.0LI ) | endl;
         sout | "atan:" | atan( 1.0F ) | atan( 1.0D ) | atan( 1.0L ) | atan( 1.0F+1.0FI ) | atan( 1.0D+1.0DI ) | atan( 1.0DL+1.0LI ) | endl;
         sout | "atan2:" | atan2( 1.0F, 1.0F ) | atan2( 1.0D, 1.0D ) | atan2( 1.0L, 1.0L );
         sout | "atan:" | atan( 1.0F, 1.0F ) | atan( 1.0D, 1.0D ) | atan( 1.0L, 1.0L ) | endl;
+        sout | "sin:" | sin( 1.0F ) | sin( 1.0D ) | sin( 1.0L ) | sin( 1.0F+1.0FI ) | sin( 1.0D+1.0DI ) | sin( 1.0DL+1.0LI );
+        sout | "cos:" | cos( 1.0F ) | cos( 1.0D ) | cos( 1.0L ) | cos( 1.0F+1.0FI ) | cos( 1.0D+1.0DI ) | cos( 1.0DL+1.0LI );
+        sout | "tan:" | tan( 1.0F ) | tan( 1.0D ) | tan( 1.0L ) | tan( 1.0F+1.0FI ) | tan( 1.0D+1.0DI ) | tan( 1.0DL+1.0LI );
+        sout | "asin:" | asin( 1.0F ) | asin( 1.0D ) | asin( 1.0L ) | asin( 1.0F+1.0FI ) | asin( 1.0D+1.0DI ) | asin( 1.0DL+1.0LI );
+        sout | "acos:" | acos( 1.0F ) | acos( 1.0D ) | acos( 1.0L ) | acos( 1.0F+1.0FI ) | acos( 1.0D+1.0DI ) | acos( 1.0DL+1.0LI );
+        sout | "atan:" | atan( 1.0F ) | atan( 1.0D ) | atan( 1.0L ) | atan( 1.0F+1.0FI ) | atan( 1.0D+1.0DI ) | atan( 1.0DL+1.0LI );
+        sout | "atan2:" | atan2( 1.0F, 1.0F ) | atan2( 1.0D, 1.0D ) | atan2( 1.0L, 1.0L ) | nonl;
+        sout | "atan:" | atan( 1.0F, 1.0F ) | atan( 1.0D, 1.0D ) | atan( 1.0L, 1.0L );
 } // main
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa math2.c" //
+// compile-command: "cfa math2.cfa" //
 // End: //

tests/math3.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // math3.c --
+// math3.cfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Fri Apr 22 14:59:21 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu May 24 21:06:12 2018
 // Update Count     : 82
+// Last Modified On : Tue Dec 11 10:15:49 2018
+// Update Count     : 85
 //
 …
         //---------------------- Hyperbolic ----------------------
         sout | "sinh:" | sinh( 1.0F ) | sinh( 1.0D ) | sinh( 1.0L ) | sinh( 1.0F+1.0FI ) | sinh( 1.0D+1.0DI ) | sinh( 1.0DL+1.0LI ) | endl;
         sout | "cosh:" | cosh( 1.0F ) | cosh( 1.0D ) | cosh( 1.0L ) | cosh( 1.0F+1.0FI ) | cosh( 1.0D+1.0DI ) | cosh( 1.0DL+1.0LI ) | endl;
         sout | "tanh:" | tanh( 1.0F ) | tanh( 1.0D ) | tanh( 1.0L ) | tanh( 1.0F+1.0FI ) | tanh( 1.0D+1.0DI ) | tanh( 1.0DL+1.0LI ) | endl;
         sout | "acosh:" | acosh( 1.0F ) | acosh( 1.0D ) | acosh( 1.0L ) | acosh( 1.0F+1.0FI ) | acosh( 1.0D+1.0DI ) | acosh( 1.0DL+1.0LI ) | endl;
         sout | "asinh:" | asinh( 1.0F ) | asinh( 1.0D ) | asinh( 1.0L ) | asinh( 1.0F+1.0FI ) | asinh( 1.0D+1.0DI ) | asinh( 1.0DL+1.0LI ) | endl;
         sout | "atanh:" | atanh( 1.0F ) | atanh( 1.0D ) | atanh( 1.0L ) | atanh( 1.0F+1.0FI ) | atanh( 1.0D+1.0DI ) | atanh( 1.0DL+1.0LI ) | endl;
+        sout | "sinh:" | sinh( 1.0F ) | sinh( 1.0D ) | sinh( 1.0L ) | sinh( 1.0F+1.0FI ) | sinh( 1.0D+1.0DI ) | sinh( 1.0DL+1.0LI );
+        sout | "cosh:" | cosh( 1.0F ) | cosh( 1.0D ) | cosh( 1.0L ) | cosh( 1.0F+1.0FI ) | cosh( 1.0D+1.0DI ) | cosh( 1.0DL+1.0LI );
+        sout | "tanh:" | tanh( 1.0F ) | tanh( 1.0D ) | tanh( 1.0L ) | tanh( 1.0F+1.0FI ) | tanh( 1.0D+1.0DI ) | tanh( 1.0DL+1.0LI );
+        sout | "acosh:" | acosh( 1.0F ) | acosh( 1.0D ) | acosh( 1.0L ) | acosh( 1.0F+1.0FI ) | acosh( 1.0D+1.0DI ) | acosh( 1.0DL+1.0LI );
+        sout | "asinh:" | asinh( 1.0F ) | asinh( 1.0D ) | asinh( 1.0L ) | asinh( 1.0F+1.0FI ) | asinh( 1.0D+1.0DI ) | asinh( 1.0DL+1.0LI );
+        sout | "atanh:" | atanh( 1.0F ) | atanh( 1.0D ) | atanh( 1.0L ) | atanh( 1.0F+1.0FI ) | atanh( 1.0D+1.0DI ) | atanh( 1.0DL+1.0LI );
         //---------------------- Error / Gamma ----------------------
         sout | "erf:" | erf( 1.0F ) | erf( 1.0D ) | erf( 1.0L ) | endl;
         sout | "erfc:" | erfc( 1.0F ) | erfc( 1.0D ) | erfc( 1.0L ) | endl;
         sout | "lgamma:" | lgamma( 4.0F ) | lgamma( 4.0D ) | lgamma( 4.0L ) | endl;
+        sout | "erf:" | erf( 1.0F ) | erf( 1.0D ) | erf( 1.0L );
+        sout | "erfc:" | erfc( 1.0F ) | erfc( 1.0D ) | erfc( 1.0L );
+        sout | "lgamma:" | lgamma( 4.0F ) | lgamma( 4.0D ) | lgamma( 4.0L );
         int sign;
         f = lgamma( 4.0F, &sign );
         sout | "lgamma:" | f | sign;
+        sout | "lgamma:" | f | sign | nonl;
         d = lgamma( 4.0D, &sign );
         sout | d | sign;
+        sout | d | sign | nonl;
         l = lgamma( 4.0L, &sign );
         sout | l | sign | endl;
         sout | "tgamma:" | tgamma( 4.0F ) | tgamma( 4.0D ) | tgamma( 4.0L ) | endl;
+        sout | l | sign;
+        sout | "tgamma:" | tgamma( 4.0F ) | tgamma( 4.0D ) | tgamma( 4.0L );
 } // main
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa math3.c" //
+// compile-command: "cfa math3.cfa" //
 // End: //

tests/math4.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // math4.c --
+// math4.cfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Thu May 24 20:56:54 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu May 24 20:58:06 2018
 // Update Count     : 2
+// Last Modified On : Tue Dec  4 18:15:01 2018
+// Update Count     : 4
 //
 …
         //---------------------- Nearest Integer ----------------------
         sout | "floor:" | floor( 1.2F ) | floor( 1.2D ) | floor( 1.2L ) | endl;
         sout | "ceil:" | ceil( 1.6F ) | ceil( 1.6D ) | ceil( 1.6L ) | endl;
         sout | "trunc:" | trunc( 3.5F ) | trunc( 3.5D ) | trunc( 3.5L ) | endl;
         sout | "rint:" | (float)rint( 1.5F ) | (double)rint( 1.5D ) | (long double)rint( 1.5L ) | endl;
         sout | "rint:" | (long int)rint( 1.5F ) | (long int)rint( 1.5D ) | (long int)rint( 1.5L ) | endl;
         sout | "rint:" | (long long int)rint( 1.5F ) | (long long int)rint( 1.5D ) | (long long int)rint( 1.5L ) | endl;
         sout | "lrint:" | lrint( 1.5F ) | lrint( 1.5D ) | lrint( 1.5L ) | endl;
         sout | "llrint:" | llrint( 1.5F ) | llrint( 1.5D ) | llrint( 1.5L ) | endl;
         sout | "nearbyint:" | nearbyint( 3.5F ) | nearbyint( 3.5D ) | nearbyint( 3.5L ) | endl;
         sout | "round:" | (float)round( 1.5F ) | (double)round( 1.5D ) | (long double)round( 1.5L ) | endl;
         sout | "round:" | (long int)round( 1.5F ) | (long int)round( 1.5D ) | (long int)round( 1.5L ) | endl;
         sout | "round:" | (long long int)round( 1.5F ) | (long long int)round( 1.5D ) | (long long int)round( 1.5L ) | endl;
         sout | "lround:" | lround( 1.5F ) | lround( 1.5D ) | lround( 1.5L ) | endl;
         sout | "llround:" | llround( 1.5F ) | llround( 1.5D ) | llround( 1.5L ) | endl;
+        sout | "floor:" | floor( 1.2F ) | floor( 1.2D ) | floor( 1.2L );
+        sout | "ceil:" | ceil( 1.6F ) | ceil( 1.6D ) | ceil( 1.6L );
+        sout | "trunc:" | trunc( 3.5F ) | trunc( 3.5D ) | trunc( 3.5L );
+        sout | "rint:" | (float)rint( 1.5F ) | (double)rint( 1.5D ) | (long double)rint( 1.5L );
+        sout | "rint:" | (long int)rint( 1.5F ) | (long int)rint( 1.5D ) | (long int)rint( 1.5L );
+        sout | "rint:" | (long long int)rint( 1.5F ) | (long long int)rint( 1.5D ) | (long long int)rint( 1.5L );
+        sout | "lrint:" | lrint( 1.5F ) | lrint( 1.5D ) | lrint( 1.5L );
+        sout | "llrint:" | llrint( 1.5F ) | llrint( 1.5D ) | llrint( 1.5L );
+        sout | "nearbyint:" | nearbyint( 3.5F ) | nearbyint( 3.5D ) | nearbyint( 3.5L );
+        sout | "round:" | (float)round( 1.5F ) | (double)round( 1.5D ) | (long double)round( 1.5L );
+        sout | "round:" | (long int)round( 1.5F ) | (long int)round( 1.5D ) | (long int)round( 1.5L );
+        sout | "round:" | (long long int)round( 1.5F ) | (long long int)round( 1.5D ) | (long long int)round( 1.5L );
+        sout | "lround:" | lround( 1.5F ) | lround( 1.5D ) | lround( 1.5L );
+        sout | "llround:" | llround( 1.5F ) | llround( 1.5D ) | llround( 1.5L );
         //---------------------- Manipulation ----------------------
         sout | "copysign:" | copysign( 1.0F, -1.0F ) | copysign( 1.0D, -1.0D ) | copysign( 1.0L, -1.0L ) | endl;
+        sout | "copysign:" | copysign( 1.0F, -1.0F ) | copysign( 1.0D, -1.0D ) | copysign( 1.0L, -1.0L );
         int exp;
         f = frexp( 4.0F, &exp );
         sout | "frexp:" | f | exp;
+        sout | "frexp:" | f | exp | nonl;
         d = frexp( 4.0D, &exp );
         sout | d | exp;
+        sout | d | exp | nonl;
         l = frexp( 4.0L, &exp );
         sout | l | exp | endl;
         sout | "ldexp:" | ldexp( 2.0F, 2 ) | ldexp( 2.0D, 2 ) | ldexp( 2.0L, 2 ) | endl;
+        sout | l | exp;
+        sout | "ldexp:" | ldexp( 2.0F, 2 ) | ldexp( 2.0D, 2 ) | ldexp( 2.0L, 2 );
         float fi;
         double di;
         long double ldi;
         f = modf( 2.3F, &fi );
         sout | "modf:" | fi | f;
+        sout | "modf:" | fi | f | nonl;
         d = modf( 2.3D, &di );
         sout | di | d;
+        sout | di | d | nonl;
         l = modf( 2.3L, &ldi );
         sout | ldi | l | endl;
         sout | "modf:" | modf( 2.3F ) | modf( 2.3D ) | modf( 2.3L ) | endl;
         sout | "nextafter:" | nextafter( 2.0F, 3.0F ) | nextafter( 2.0D, 3.0D ) | nextafter( 2.0L, 3.0L ) | endl;
         sout | "nexttoward:" | nexttoward( 2.0F, 3.0F ) | nexttoward( 2.0D, 3.0D ) | nexttoward( 2.0L, 3.0L ) | endl;
+        sout | ldi | l;
+        sout | "modf:" | modf( 2.3F ) | modf( 2.3D ) | modf( 2.3L );
+        sout | "nextafter:" | nextafter( 2.0F, 3.0F ) | nextafter( 2.0D, 3.0D ) | nextafter( 2.0L, 3.0L );
+        sout | "nexttoward:" | nexttoward( 2.0F, 3.0F ) | nexttoward( 2.0D, 3.0D ) | nexttoward( 2.0L, 3.0L );
         sout | "scalbn:" | scalbn( 2.0F, 3 ) | scalbn( 2.0D, 3 ) | scalbn( 2.0L, 3 ) | endl;
         sout | "scalbln:" | scalbln( 2.0F, 3L ) | scalbln( 2.0D, 3L ) | scalbln( 2.0L, 3L ) | endl;
+        sout | "scalbn:" | scalbn( 2.0F, 3 ) | scalbn( 2.0D, 3 ) | scalbn( 2.0L, 3 );
+        sout | "scalbln:" | scalbln( 2.0F, 3L ) | scalbln( 2.0D, 3L ) | scalbln( 2.0L, 3L );
 } // main
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa math3.c" //
+// compile-command: "cfa math3.cfa" //
 // End: //

tests/minmax.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // minmax.c --
+// minmax.cfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Apr 10 17:29:09 2018
 // Update Count     : 50
+// Last Modified On : Tue Dec  4 21:45:31 2018
+// Update Count     : 52
 //
 …
         int ?>?( char op1, char op2 ) { return (int)op1 > (int)op2; }
         sout | "char\t\t\t"                                     | 'z' | ' ' | 'a' | "\tmin " | min( 'z', 'a' ) | endl;
         sout | "signed int\t\t"                         | 4 | 3 | "\tmin" | min( 4, 3 ) | endl;
         sout | "unsigned int\t\t"                       | 4u | 3u | "\tmin" | min( 4u, 3u ) | endl;
         sout | "signed long int\t\t"            | 4l | 3l | "\tmin" | min( 4l, 3l ) | endl;
         sout | "unsigned long int\t"            | 4ul | 3ul | "\tmin" | min( 4ul, 3ul ) | endl;
         sout | "signed long long int\t"         | 4ll | 3ll | "\tmin" | min( 4ll, 3ll ) | endl;
         sout | "unsigned long long int\t"       | 4ull | 3ull | "\tmin" | min( 4ull, 3ull ) | endl;
         sout | "float\t\t\t"                            | 4.0f | 3.1f | "\tmin" | min( 4.0f, 3.1f ) | endl;
         sout | "double\t\t\t"                           | 4.0 | 3.1 | "\tmin" | min( 4.0, 3.1 ) | endl;
         sout | "long double\t\t"                        | 4.0l | 3.1l | "\tmin" | min( 4.0l, 3.1l ) | endl;
+        sout | "char\t\t\t"                                     | 'z' | ' ' | 'a' | "\tmin " | min( 'z', 'a' );
+        sout | "signed int\t\t"                         | 4 | 3 | "\tmin" | min( 4, 3 );
+        sout | "unsigned int\t\t"                       | 4u | 3u | "\tmin" | min( 4u, 3u );
+        sout | "signed long int\t\t"            | 4l | 3l | "\tmin" | min( 4l, 3l );
+        sout | "unsigned long int\t"            | 4ul | 3ul | "\tmin" | min( 4ul, 3ul );
+        sout | "signed long long int\t"         | 4ll | 3ll | "\tmin" | min( 4ll, 3ll );
+        sout | "unsigned long long int\t"       | 4ull | 3ull | "\tmin" | min( 4ull, 3ull );
+        sout | "float\t\t\t"                            | 4.0f | 3.1f | "\tmin" | min( 4.0f, 3.1f );
+        sout | "double\t\t\t"                           | 4.0 | 3.1 | "\tmin" | min( 4.0, 3.1 );
+        sout | "long double\t\t"                        | 4.0l | 3.1l | "\tmin" | min( 4.0l, 3.1l );
         sout | endl;
+        sout | nl;
         sout | "char\t\t\t"                                     | 'z' | ' ' | 'a' | "\tmax " | max( 'z', 'a' ) | endl;
         sout | "signed int\t\t"                         | 4 | 3 | "\tmax" | max( 4, 3 ) | endl;
         sout | "unsigned int\t\t"                       | 4u | 3u | "\tmax" | max( 4u, 3u ) | endl;
         sout | "signed long int\t\t"            | 4l | 3l | "\tmax" | max( 4l, 3l ) | endl;
         sout | "unsigned long int\t"            | 4ul | 3ul | "\tmax" | max( 4ul, 3ul ) | endl;
         sout | "signed long long int\t"         | 4ll | 3ll | "\tmax" | max( 4ll, 3ll ) | endl;
         sout | "unsigned long long int\t"       | 4ull | 3ull | "\tmax" | max( 4ull, 3ull ) | endl;
         sout | "float\t\t\t"                            | 4.0f | 3.1f | "\tmax" | max( 4.0f, 3.1f ) | endl;
         sout | "double\t\t\t"                           | 4.0 | 3.1 | "\tmax" | max( 4.0, 3.1 ) | endl;
         sout | "long double\t\t"                        | 4.0l | 3.1l | "\tmax" | max( 4.0l, 3.1l ) | endl;
+        sout | "char\t\t\t"                                     | 'z' | ' ' | 'a' | "\tmax " | max( 'z', 'a' );
+        sout | "signed int\t\t"                         | 4 | 3 | "\tmax" | max( 4, 3 );
+        sout | "unsigned int\t\t"                       | 4u | 3u | "\tmax" | max( 4u, 3u );
+        sout | "signed long int\t\t"            | 4l | 3l | "\tmax" | max( 4l, 3l );
+        sout | "unsigned long int\t"            | 4ul | 3ul | "\tmax" | max( 4ul, 3ul );
+        sout | "signed long long int\t"         | 4ll | 3ll | "\tmax" | max( 4ll, 3ll );
+        sout | "unsigned long long int\t"       | 4ull | 3ull | "\tmax" | max( 4ull, 3ull );
+        sout | "float\t\t\t"                            | 4.0f | 3.1f | "\tmax" | max( 4.0f, 3.1f );
+        sout | "double\t\t\t"                           | 4.0 | 3.1 | "\tmax" | max( 4.0, 3.1 );
+        sout | "long double\t\t"                        | 4.0l | 3.1l | "\tmax" | max( 4.0l, 3.1l );
 } // main
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa minmax.c" //
+// compile-command: "cfa minmax.cfa" //
 // End: //

tests/nested-types.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // nested-types.c --
+// nested-types.cfa --
 //
 // Author           : Rob Schluntz
 // Created On       : Mon Jul 9 10:20:03 2018
 // Last Modified By : Rob Schluntz
 // Last Modified On : Mon Jul 9 10:20:03 2017
 // Update Count     : 1
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue Nov  6 17:59:40 2018
+// Update Count     : 2
 //
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa nested-types.c" //
+// compile-command: "cfa nested-types.cfa" //
 // End: //

tests/numericConstants.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // numericConstants.c --
+// numericConstants.cfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Wed May 24 22:10:36 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed May 24 22:11:36 2017
 // Update Count     : 2
+// Last Modified On : Tue Nov  6 17:59:53 2018
+// Update Count     : 3
 //
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa minmax.c" //
+// compile-command: "cfa minmax.cfa" //
 // End: //

tests/preempt_longrun/create.c

rcdc02f2	r515a037
3	3	#include <time.hfa>
4	4
5		#include "long_tests.h"
	5	#include "long_tests.hfa"
6	6
7	7	#ifndef PREEMPTION_RATE

tests/preempt_longrun/enter3.c

rcdc02f2	r515a037
5	5
6	6	#define __kick_rate 75000ul
7		#include "long_tests.h"
	7	#include "long_tests.hfa"
8	8
9	9	#ifndef PREEMPTION_RATE

tests/preempt_longrun/processor.c

rcdc02f2	r515a037
5	5	#include <unistd.h>
6	6
7		#include "long_tests.h"
	7	#include "long_tests.hfa"
8	8
9	9	#ifndef PREEMPTION_RATE

tests/preempt_longrun/yield.c

rcdc02f2	r515a037
4	4
5	5	#define __kick_rate 550000ul
6		#include "long_tests.h"
	6	#include "long_tests.hfa"
7	7
8	8	#ifndef PREEMPTION_RATE

tests/quotedKeyword.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // quoted_keyword.c -- test quoted keyword usage
+// quotedKeyword.cfa -- test quoted keyword usage
 //
 // Author           : Peter A. Buhr
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jun 30 14:03:59 2016
 // Update Count     : 19
+// Last Modified On : Tue Dec  4 21:45:53 2018
+// Update Count     : 23
 //
 …
         st.`struct` = 3;
         `throw` = 4;
         sout | `catch` + st.`otype` + st.`struct` + `throw` | endl;
+        sout | `catch` + st.`otype` + st.`struct` + `throw`;
+}
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa quoted_keyword.c" //
+// compile-command: "cfa quotedKeyword.cfa" //
 // End: //

tests/raii/dtor-early-exit.c

-              rcdc02f2
+              r515a037
 // Created On       : Wed Aug 17 08:26:25 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Aug 11 07:58:39 2018
 // Update Count     : 8
+// Last Modified On : Tue Dec 11 22:05:24 2018
+// Update Count     : 9
 //
 …
 // don't want these called
 void ?{}(A & a) { assert( false ); }
 void ?{}(A & a, const char * name) { a.name = name; sout | "construct " | name | endl; a.x = (int*)malloc(); }
+void ?{}(A & a, const char * name) { a.name = name; sout | "construct " | name; a.x = (int*)malloc(); }
 void ?{}(A & a, const char * name, int * ptr) { assert( false ); }
 A ?=?(A & a, A b) {  sout | "assign " | a.name | " " | b.name; return a; }
 void ?{}(A & a, A b) { sout | "copy construct " | b.name | endl; a.x = (int*)malloc(); }
 void ^?{}(A & a) { sout | "destruct " | a.name | endl; free(a.x); }
+void ?{}(A & a, A b) { sout | "copy construct " | b.name; a.x = (int*)malloc(); }
+void ^?{}(A & a) { sout | "destruct " | a.name; free(a.x); }
 // test returns
 void f(int i) {
         sout | "f i=" | i | endl;
+        sout | "f i=" | i;
         A x = { "x" };  // construct x
+        {
 …
 void g() {
         for (int i = 0; i < 10; i++) {
                 sout | "g for i=" | i | endl;
+                sout | "g for i=" | i;
                 A x = { "x" };
                 // construct x
                 // destruct x
+        }
         sout | endl;
+        sout | nl;
+        {
                 int i = 0;
                 while (i < 10) {
                         sout | "g while i=" | i | endl;
+                        sout | "g while i=" | i;
                         A x = { "x" };
                         // construct x
 …
+                }
+        }
         sout | endl;
+        sout;
         for (int i = 0; i < 10; i++) {
                 switch(10) {
 …
                         case 10: {
                                 A y = { "y" };
                                 sout | "g switch i=" | i | endl;
+                                sout | "g switch i=" | i;
                                 // construct y
                                 break; // destruct y
+                        }
                         default: {
                                 sout | "g switch i=" | i | endl;
+                                sout | "g switch i=" | i;
                                 A x = { "x" };
                                 // construct x
 …
+                }
+        }
         sout | endl;
+        sout | nl;
         for (int k = 0; k < 2; k++) {
                 sout | "g for k=" | k | endl;
+                sout | "g for k=" | k;
                 L1: for (int i = 0; i < 10; i++) {
                         sout | "g for i=" | i | endl;
+                        sout | "g for i=" | i;
                         A x = { "x" };
                         if (i == 2) {
                                 sout | "continue L1" | endl;
+                                sout | "continue L1";
                                 continue;  // destruct x
                         } else if (i == 3) {
                                 sout | "break L1" | endl;
+                                sout | "break L1";
                                 break;  // destruct x
+                        }
                         L2: for (int j = 0; j < 10; j++) {
                                 sout | "g for j=" | j | endl;
+                                sout | "g for j=" | j;
                                 A y = { "y" };
                                 if (j == 0) {
                                         sout | "continue L2" | endl;
+                                        sout | "continue L2";
                                         continue; // destruct y - missing because object that needs to be destructed is not a part of this block, it's a part of the for's block
                                 } else if (j == 1) {
                                         sout | "break L2" | endl;
+                                        sout | "break L2";
                                         break;  // destruct y
                                 } else if (i == 1) {
                                         sout | "continue L1" | endl;
+                                        sout | "continue L1";
                                         continue L1; // destruct x,y - note: continue takes you to destructors for block, so only generate destructor for y
                                 } else if (k == 1) {
                                         sout | "break L1" | endl;
+                                        sout | "break L1";
                                         break L1;  // destruct x,y
+                                }
 …
+        }
         sout | endl;
+        sout | nl;
         L3: if( 3 ) {
                 A w = { "w" };
                 if( 4 ) {
                         A v = { "v" };
                         sout | "break L3" | endl;
+                        sout | "break L3";
                         break L3;
+                }
 …
         // * if S_L-S_G is non-empty, error
         // * emit destructors for all variables in S_G-S_L
         sout | "h" | endl;
+        sout | "h";
+        {
                 L0: ;
 …
                         A y = { "y" };
                         // S_L1 = { y }
                 L1: sout | "L1" | endl;
+                L1: sout | "L1";
                         A x = { "x" };
                         // S_L2 = { y, x }
                 L2: sout | "L2" | endl;
+                L2: sout | "L2";
                         if (i == 0) {
                                 ++i;
                                 sout | "goto L1" | endl;
+                                sout | "goto L1";
                                 // S_G = { y, x }
                                 goto L1;  // jump back, destruct b/c before x definition
 …
                         } else if (i == 1) {
                                 ++i;
                                 sout | "goto L2" | endl;
+                                sout | "goto L2";
                                 // S_G = { y, x }
                                 goto L2;  // jump back, do not destruct
 …
                         } else if (i == 2) {
                                 ++i;
                                 sout | "goto L3" | endl;
+                                sout | "goto L3";
                                 // S_G = { y, x }
                                 goto L3;  // jump ahead, do not destruct
 …
                                 ++i;
                                 A z = { "z" };
                                 sout | "goto L3-2" | endl;
+                                sout | "goto L3-2";
                                 // S_G = { z, y, x }
                                 goto L3;
 …
                         } else {
                                 ++i;
                                 sout | "goto L4" | endl;
+                                sout | "goto L4";
                                 // S_G = { y, x }
                                 goto L4;  // jump ahead, destruct b/c left block x was defined in
 …
+                        }
                         // S_L3 = { y, x }
                 L3: sout | "L3" | endl;
                         sout | "goto L2-2" | endl;
+                L3: sout | "L3";
+                        sout | "goto L2-2";
                         // S_G = { y, x }
                         goto L2; // jump back, do not destruct
 …
+        }
         // S_L4 = {}
         L4: sout | "L4" | endl;
+        L4: sout | "L4";
         if (i == 4) {
                 sout | "goto L0" | endl;
+                sout | "goto L0";
                 // S_G = {}
                 goto L0;
 …
                 f(i);
+        }
         sout | endl;
+        sout | nl;
         g();
         sout | endl;
+        sout | nl;
         h();

tests/raii/globals.c

-              rcdc02f2
+              r515a037
 int main() {
         sout | "static\t\tinline\t\tautogen\t\tvalue" | endl;
+        sout | "static\t\tinline\t\tautogen\t\tvalue";
         sout | "no \t\tno \t\tno \t\t" | g.val.value    | endl;
         sout | "no \t\tno \t\tyes\t\t" | ga.val.value   | endl;
         sout | "no \t\tyes\t\tno \t\t" | gi.val.value   | endl;
         sout | "no \t\tyes\t\tyes\t\t" | gia.val.value  | endl;
         sout | "yes\t\tno \t\tno \t\t" | gs.val.value   | endl;
         sout | "yes\t\tno \t\tyes\t\t" | gsa.val.value  | endl;
         sout | "yes\t\tyes\t\tno \t\t" | gsi.val.value  | endl;
         sout | "yes\t\tyes\t\tyes\t\t" | gsia.val.value | endl;
+        sout | "no \t\tno \t\tno \t\t" | g.val.value;
+        sout | "no \t\tno \t\tyes\t\t" | ga.val.value;
+        sout | "no \t\tyes\t\tno \t\t" | gi.val.value;
+        sout | "no \t\tyes\t\tyes\t\t" | gia.val.value;
+        sout | "yes\t\tno \t\tno \t\t" | gs.val.value;
+        sout | "yes\t\tno \t\tyes\t\t" | gsa.val.value;
+        sout | "yes\t\tyes\t\tno \t\t" | gsi.val.value;
+        sout | "yes\t\tyes\t\tyes\t\t" | gsia.val.value;
+}

tests/random.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // random.c --
+// random.cfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Tue Jul  5 21:29:30 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Jan  2 12:19:34 2018
 // Update Count     : 19
+// Last Modified On : Tue Dec  4 21:46:25 2018
+// Update Count     : 22
 //
 #include <fstream.hfa>
 #include <stdlib.hfa>                                                                           // random
+#include <stdlib.hfa>                                                                   // random
 #include <unistd.h>                                                                             // getpid
 …
         // test polymorphic calls to random and stream
         char c = random();
         sout | c | endl;
+        sout | c;
         c = random( 'A' );
         sout | c | endl;
+        sout | c;
         c = random( 'A', 'Z' );
         sout | c | endl;
+        sout | c;
         int i = random();
     sout | i | endl;
+    sout | i;
         i = random( 10 );
     sout | i | endl;
+    sout | i;
         i = random( -10, 20 );
     sout | i | endl;
+    sout | i;
         unsigned int ui = random();
     sout | ui | endl;
+    sout | ui;
         ui = random( 10u );
     sout | ui | endl;
+    sout | ui;
         ui = random( 10u, 20u );
     sout | ui | endl;
+    sout | ui;
         long int li = random();
     sout | li | endl;
+    sout | li;
         li = random( 10l );
     sout | li | endl;
+    sout | li;
         li = random( -10l, 20l );
     sout | li | endl;
+    sout | li;
         unsigned long int uli = random();
     sout | uli | endl;
+    sout | uli;
         uli = random( 10ul );
     sout | uli | endl;
+    sout | uli;
         uli = random( 10ul, 20ul );
     sout | uli | endl;
+    sout | uli;
     float f = random();
     sout | f | endl;
+    sout | f;
     double d = random();
     sout | d | endl;
+    sout | d;
     float _Complex fc = random();
     sout | fc | endl;
+    sout | fc;
     double _Complex dc = random();
     sout | dc | endl;
+    sout | dc;
     long double _Complex ldc = random();
     sout | ldc | endl;
+    sout | ldc;
 } // main
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa random.c" //
+// compile-command: "cfa random.cfa" //
 // End: //

tests/rational.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // rational.c -- test rational number package
+// rational.cfa -- test rational number package
 //
 // Author           : Peter A. Buhr
 // Created On       : Mon Mar 28 08:43:12 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Oct 10 23:25:04 2017
 // Update Count     : 67
+// Last Modified On : Tue Dec  4 21:46:42 2018
+// Update Count     : 69
 //
 …
 int main() {
         sout | "constructor" | endl;
+        sout | "constructor";
         Rational(int) a = { 3 }, b = { 4 }, c;
         sout | a | b | c | endl;
+        sout | a | b | c;
         a = (Rational(int)){ 4, 8 };
         b = (Rational(int)){ 5, 7 };
         sout | a | b | endl;
+        sout | a | b;
         a = (Rational(int)){ -2, -3 };
         b = (Rational(int)){ 3, -2 };
         sout | a | b | endl;
+        sout | a | b;
         a = (Rational(int)){ -2, 3 };
         b = (Rational(int)){ 3, 2 };
         sout | a | b | endl;
+        sout | a | b;
         sout | "logical" | endl;
+        sout | "logical";
         a = (Rational(int)){ -2 };
         b = (Rational(int)){ -3, 2 };
         sout | a | b | endl;
 //      sout | a == 1 | endl; // FIX ME
         sout | a != b | endl;
         sout | a <  b | endl;
         sout | a <= b | endl;
         sout | a >  b | endl;
         sout | a >= b | endl;
+        sout | a | b;
+//      sout | a == 1; // FIX ME
+        sout | a != b;
+        sout | a <  b;
+        sout | a <= b;
+        sout | a >  b;
+        sout | a >= b;
         sout | "arithmetic" | endl;
         sout | a | b | endl;
         sout | a + b | endl;
         sout | a - b | endl;
         sout | a * b | endl;
         sout | a / b | endl;
+        sout | "arithmetic";
+        sout | a | b;
+        sout | a + b;
+        sout | a - b;
+        sout | a * b;
+        sout | a / b;
         sout | "conversion" | endl;
+        sout | "conversion";
         a = (Rational(int)){ 3, 4 };
         sout | widen( a ) | endl;
+        sout | widen( a );
         a = (Rational(int)){ 1, 7 };
         sout | widen( a ) | endl;
+        sout | widen( a );
         a = (Rational(int)){ 355, 113 };
         sout | widen( a ) | endl;
         sout | narrow( 0.75, 4 ) | endl;
         sout | narrow( 0.14285714285714, 16 ) | endl;
         sout | narrow( 3.14159265358979, 256 ) | endl;
+        sout | widen( a );
+        sout | narrow( 0.75, 4 );
+        sout | narrow( 0.14285714285714, 16 );
+        sout | narrow( 3.14159265358979, 256 );
         sout | "decompose" | endl;
+        sout | "decompose";
         int n, d;
 //      [n, d] = a;
 //      sout | a | n | d | endl;
+//      sout | a | n | d;
         sout | "more tests" | endl;
+        sout | "more tests";
         Rational(int) x = { 1, 2 }, y = { 2 };
         sout | x - y | endl;
         sout | x > y | endl;
         sout | x | numerator( x, 2 ) | x | endl;
         sout | y | denominator( y, -2 ) | y | endl;
+        sout | x - y;
+        sout | x > y;
+        sout | x | numerator( x, 2 ) | x;
+        sout | y | denominator( y, -2 ) | y;
         Rational(int) z = { 0, 5 };
         sout | z | endl;
+        sout | z;
         sout | x | numerator( x, 0 ) | x | endl;
+        sout | x | numerator( x, 0 ) | x;
         x = (Rational(int)){ 1, MAX } + (Rational(int)){ 1, MAX };
         sout | x | endl;
+        sout | x;
         x = (Rational(int)){ 3, MAX } + (Rational(int)){ 2, MAX };
         sout | x | endl;
+        sout | x;
         sin | a | b;
         sout | a | b | endl;
+        sout | a | b;
 } // main
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa rational.c" //
+// compile-command: "cfa rational.cfa" //
 // End: //

tests/searchsort.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // searchsort.c --
+// searchsort.cfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Thu Feb  4 18:17:50 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Aug  9 07:54:57 2018
 // Update Count     : 101
+// Last Modified On : Wed Dec  5 08:18:42 2018
+// Update Count     : 106
 //
 #include <fstream.hfa>
 #include <stdlib.hfa>                                                                           // bsearch, qsort
+#include <stdlib.hfa>                                                                   // bsearch, qsort
 #include <stdlib.h>                                                                             // C version of bsearch
 …
         int iarr[size];
+        sout | nlOff;                                                                           // turn off auto newline
         for ( i; 0u ~ size ) {
                 iarr[i] = size - i;
                 sout | iarr[i] | ", ";
         } // for
         sout | endl | endl;
+        sout | nl;
         // ascending sort/search by changing < to >
 …
                 sout | iarr[i] | ", ";
         } // for
         sout | endl;
+        sout | nl;
         for ( i; 0u ~ size ) {          // C version
                 int key = size - i;
 …
                 sout | key | ':' | *v | ", ";
         } // for
         sout | endl;
+        sout | nl;
         for ( i; 0u ~ size ) {
 …
                 sout | size - i | ':' | *v | ", ";
         } // for
         sout | endl;
+        sout | nl;
         for ( i; 0u ~ size ) {
                 unsigned int posn = bsearch( size - i, iarr, size );
                 sout | size - i | ':' | iarr[posn] | ", ";
         } // for
         sout | endl | endl;
+        sout | nl;
         // descending sort/search by changing < to >
 …
                 sout | iarr[i] | ", ";
         } // for
         sout | endl;
+        sout | nl;
+        {
                 int ?<?( int x, int y ) { return x > y; }
 …
                         sout | iarr[i] | ", ";
                 } // for
                 sout | endl;
+                sout | nl;
                 for ( i; 0u ~ size ) {
                         int * v = bsearch( size - i, iarr, size );
                         sout | size - i | ':' | *v | ", ";
                 } // for
                 sout | endl;
+                sout | nl;
                 for ( i; 0u ~ size ) {
                         unsigned int posn = bsearch( size - i, iarr, size );
 …
                 } // for
+        }
         sout | endl | endl;
+        sout | nl;
         double darr[size];
 …
                 sout | darr[i] | ", ";
         } // for
         sout | endl;
+        sout | nl;
         qsort( darr, size );
         for ( i; 0u ~ size ) {
                 sout | darr[i] | ", ";
         } // for
         sout | endl;
+        sout | nl;
         for ( i; 0u ~ size ) {
                 double * v = bsearch( size - i + 0.5, darr, size );
                 sout | size - i + 0.5 | ':' | *v | ", ";
         } // for
         sout | endl;
+        sout | nl;
         for ( i; 0u ~ size ) {
                 unsigned int posn = bsearch( size - i + 0.5, darr, size );
                 sout | size - i + 0.5 | ':' | darr[posn] | ", ";
         } // for
         sout | endl | endl;
+        sout | nl;
         struct S { int i, j; } sarr[size];
 …
                 sout | sarr[i] | ", ";
         } // for
         sout | endl;
+        sout | nl;
         qsort( sarr, size );
         for ( i; 0u ~ size ) {
                 sout | sarr[i] | ", ";
         } // for
         sout | endl;
+        sout | nl;
         for ( i; 0u ~ size ) {
                 S temp = { size - i, size - i + 1 };
 …
                 sout | temp | ':' | *v | ", ";
         } // for
         sout | endl;
+        sout | nl;
         for ( i; 0u ~ size ) {
                 S temp = { size - i, size - i + 1 };
 …
                 sout | temp | ':' | sarr[posn] | ", ";
         } // for
         sout | endl | endl;
+        sout | nl;
+        {
                 unsigned int getKey( const S & s ) { return s.j; }
 …
                         sout | sarr[i] | ", ";
                 } // for
                 sout | endl;
+                sout | nl;
                 for ( i; 0u ~ size ) {
                         S * v = bsearch( size - i + 1, sarr, size );
                         sout | size - i + 1 | ':' | *v | ", ";
                 } // for
                 sout | endl;
+                sout | nl;
                 for ( i; 0u ~ size ) {
                         unsigned int posn = bsearch( size - i + 1, sarr, size );
                         sout | size - i + 1 | ':' | sarr[posn] | ", ";
                 } // for
                 sout | endl | endl;
+                sout | nl;
+        }
 } // main
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa searchsort.c" //
+// compile-command: "cfa searchsort.cfa" //
 // End: //

tests/stdincludes.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // stdincludes.c --
+// stdincludes.cfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Tue Aug 29 08:26:14 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Aug 30 07:56:39 2017
 // Update Count     : 5
+// Last Modified On : Tue Nov  6 18:00:53 2018
+// Update Count     : 6
 //
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa stdincludes.c" //
+// compile-command: "cfa stdincludes.cfa" //
 // End: //

tests/sum.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // sum.c -- test resolvers ability to deal with many variables with the same name and to use the minimum number of casts
 //    necessary to disambiguate overloaded variable names.
+// sum.cfa -- test resolvers ability to deal with many variables with the same name and to use the minimum number of
+//    casts necessary to disambiguate overloaded variable names.
 //
 // Author           : Peter A. Buhr
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Aug  2 08:03:09 2018
 // Update Count     : 279
+// Last Modified On : Tue Dec 11 21:50:41 2018
+// Update Count     : 285
 //
 …
         } // for
         sout | "sum from" | low | "to" | High | "is"
                  | sum( size, (unsigned char *)a ) | ", check" | (int)s | endl;
+                 | sum( size, (unsigned char *)a ) | ", check" | (int)s;
         int s = 0, a[size], v = low;
 …
         } // for
         sout | "sum from" | low | "to" | High | "is"
                  | sum( size, (int *)a ) | ", check" | (int)s | endl;
+                 | sum( size, (int *)a ) | ", check" | (int)s;
         float s = 0.0f, a[size], v = low / 10.0f;
 …
         } // for
         sout | "sum from" | low / 10.0f | "to" | High / 10.0f | "is"
                  | sum( size, (float *)a ) | ", check" | (float)s | endl;
+                 | sum( size, (float *)a ) | ", check" | (float)s;
         double s = 0.0, a[size], v = low / 10.0;
 …
         } // for
         sout | "sum from" | low / 10.0 | "to" | High / 10.0 | "is"
                  | sum( size, (double *)a ) | ", check" | (double)s | endl;
+                 | sum( size, (double *)a ) | ", check" | (double)s;
         struct S { int i, j; };
 …
         S ?++( S & t ) { S temp = t; t += (S){1}; return temp; }
         ofstream & ?|?( ofstream & os, S v ) { return os | v.i | v.j; }
+        void ?|?( ofstream & os, S v ) { (ofstream)(os | v); if ( getANL( os ) ) nl( os ); }
         S s = (S){0}, a[size], v = { low, low };
 …
         } // for
         sout | "sum from" | low | "to" | High | "is"
                  | sum( size, (S *)a ) | ", check" | (S)s | endl;
+                 | sum( size, (S *)a ) | ", check" | (S)s;
         forall( otype Impl | sumable( Impl ) )
 …
         } // for
         sout | "sum from" | low | "to" | High | "is"
                  | sum( size, gs.x ) | ", check" | (int)s | endl; // add field array in generic type
+                 | sum( size, gs.x ) | ", check" | (int)s;              // add field array in generic type
         delete( gs.x );
 } // main
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa sum.c" //
+// compile-command: "cfa sum.cfa" //
 // End: //

tests/swap.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // swap.c --
+// swap.cfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Dec  7 09:13:13 2017
 // Update Count     : 71
+// Last Modified On : Tue Dec 11 10:17:40 2018
+// Update Count     : 74
 //
 …
 int main( void ) {
         char c1 = 'a', c2 = 'b';
         sout | "char\t\t\t" | c1 | ' ' | c2 | "\t\t\tswap ";
+        sout | "char\t\t\t" | c1 | ' ' | c2 | "\t\t\tswap " | nonl;
         swap( c1, c2 );
         sout | '\t' | c1 | ' ' | c2 | endl;
+        sout | '\t' | c1 | ' ' | c2;
         signed int i1 = -1, i2 = -2;
         sout | "signed int\t\t" | i1 | i2 | "\t\t\tswap ";
+        sout | "signed int\t\t" | i1 | i2 | "\t\t\tswap " | nonl;
         swap( i1, i2 );
         sout | '\t' | i1 | i2 | endl;
+        sout | '\t' | i1 | i2;
         unsigned int ui1 = 1, ui2 = 2;
         sout | "unsigned int\t\t" | ui1 | ui2 | "\t\t\tswap ";
+        sout | "unsigned int\t\t" | ui1 | ui2 | "\t\t\tswap " | nonl;
         swap( ui1, ui2 );
         sout | '\t' | ui1 | ui2 | endl;
+        sout | '\t' | ui1 | ui2;
         signed long int li1 = -1, li2 = -2;
         sout | "signed long int\t\t" | li1 | li2 | "\t\t\tswap ";
+        sout | "signed long int\t\t" | li1 | li2 | "\t\t\tswap " | nonl;
         swap( li1, li2 );
         sout | '\t' | li1 | li2 | endl;
+        sout | '\t' | li1 | li2;
         unsigned long int uli1 = 1, uli2 = 2;
         sout | "unsigned long int\t" | uli1 | uli2 | "\t\t\tswap ";
+        sout | "unsigned long int\t" | uli1 | uli2 | "\t\t\tswap " | nonl;
         swap( uli1, uli2 );
         sout | '\t' | uli1 | uli2 | endl;
+        sout | '\t' | uli1 | uli2;
         signed long long int lli1 = -1, lli2 = -2;
         sout | "signed long long int\t" | lli1 | lli2 | "\t\t\tswap ";
+        sout | "signed long long int\t" | lli1 | lli2 | "\t\t\tswap " | nonl;
         swap( lli1, lli2 );
         sout | '\t' | lli1 | lli2 | endl;
+        sout | '\t' | lli1 | lli2;
         unsigned long long int ulli1 = 1, ulli2 = 2;
         sout | "unsigned long long int\t" | ulli1 | ulli2 | "\t\t\tswap ";
+        sout | "unsigned long long int\t" | ulli1 | ulli2 | "\t\t\tswap " | nonl;
         swap( ulli1, ulli2 );
         sout | '\t' | ulli1 | ulli2 | endl;
+        sout | '\t' | ulli1 | ulli2;
         float f1 = 1.5, f2 = 2.5;
         sout | "float\t\t\t" | f1 | f2 | "\t\t\tswap ";
+        sout | "float\t\t\t" | f1 | f2 | "\t\t\tswap " | nonl;
         swap( f1, f2 );
         sout | '\t' | f1 | f2 | endl;
+        sout | '\t' | f1 | f2;
         double d1 = 1.5, d2 = 2.5;
         sout | "double\t\t\t" | d1 | d2 | "\t\t\tswap ";
+        sout | "double\t\t\t" | d1 | d2 | "\t\t\tswap " | nonl;
         swap( d1, d2 );
         sout | '\t' | d1 | d2 | endl;
+        sout | '\t' | d1 | d2;
         long double ld1 = 1.5, ld2 = 2.5;
         sout | "long double\t\t" | ld1 | ld2 | "\t\t\tswap ";
+        sout | "long double\t\t" | ld1 | ld2 | "\t\t\tswap " | nonl;
         swap( ld1, ld2 );
         sout | '\t' | ld1 | ld2 | endl;
+        sout | '\t' | ld1 | ld2;
         float _Complex fc1 = 1.5f+1.5if, fc2 = 2.5f+2.5if;
         sout | "float _Complex\t\t" | fc1 | fc2 | "\tswap ";
+        sout | "float _Complex\t\t" | fc1 | fc2 | "\tswap " | nonl;
         swap( fc1, fc2 );
         sout | '\t' | fc1 | fc2 | endl;
+        sout | '\t' | fc1 | fc2;
         double _Complex dc1 = 1.5d+1.5id, dc2 = 2.5d+2.5id;
         sout | "double _Complex\t\t" | dc1 | dc2 | "\tswap ";
+        sout | "double _Complex\t\t" | dc1 | dc2 | "\tswap " | nonl;
         swap( dc1, dc2 );
         sout | '\t' | dc1 | dc2 | endl;
+        sout | '\t' | dc1 | dc2;
         long double _Complex ldc1 = 1.5d+1.5il, ldc2 = 2.5d+2.5il;
         sout | "long double _Complex\t" | ldc1 | ldc2 | "\tswap ";
+        sout | "long double _Complex\t" | ldc1 | ldc2 | "\tswap " | nonl;
         swap( ldc1, ldc2 );
         sout | '\t' | ldc1 | ldc2 | endl;
+        sout | '\t' | ldc1 | ldc2;
         struct S { int i, j; } s1 = { 1, 2 }, s2 = { 2, 1 };
         ofstream & ?|?( ofstream & os, S s ) { return os | s.i | s.j; }
         sout | "struct S\t\t" | s1 | "," | s2 | "\t\tswap ";
+        sout | "struct S\t\t" | s1 | "," | s2 | "\t\tswap " | nonl;
         swap( s1, s2 );
         sout | '\t' | s1 | "," | s2 | endl;
+        sout | '\t' | s1 | "," | s2;
 } // main
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa swap.c" //
+// compile-command: "cfa swap.cfa" //
 // End: //

tests/switch.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // switch.c --
+// switch.cfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Tue Jul 12 06:50:22 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Mar  8 07:33:05 2018
 // Update Count     : 36
+// Last Modified On : Tue Nov  6 18:01:34 2018
+// Update Count     : 37
 //
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa switch.c" //
+// compile-command: "cfa switch.cfa" //
 // End: //

tests/tuple/tupleAssign.c

-              rcdc02f2
+              r515a037
 // Created On       : Tue Nov 15 17:24:32 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Mar  6 21:23:58 2017
 // Update Count     : 34
+// Last Modified On : Tue Dec  4 22:03:48 2018
+// Update Count     : 35
 //
 …
                 // swap x, y and store the new [x, y] in [u, v] and in z;
                 printf( "u=%d v=%d x=%d y=%d z=[%d, %d]\n", u, v, x, y, z );
                 sout | "u=" | u | "v=" | v | "x=" | x | "y=" | y | "z=[" | z | "]" | endl;
+                sout | "u=" | u | "v=" | v | "x=" | x | "y=" | y | "z=[" | z | "]";
                 z = [u, v] = [x, y] = [y, x];
                 printf( "u=%d v=%d x=%d y=%d z=[%d, %d]\n", u, v, x, y, z );
                 sout | "u=" | u | "v=" | v | "x=" | x | "y=" | y | "z=[" | z | "]" | endl;
+                sout | "u=" | u | "v=" | v | "x=" | x | "y=" | y | "z=[" | z | "]";
                 // shuffle elements -- v = z.0, z.0 = z.1, z.1 = u, u = v
                 [v, z, u] = [z, u, v];
                 printf( "u=%d v=%d z=[%d, %d]\n", u, v, z );
                 sout | "u=" | u | "v=" | v | "z=[" | z | "]" | endl;
+                sout | "u=" | u | "v=" | v | "z=[" | z | "]";
                 // multiple assignment with tuple expression on right
 …
                 [u, v] = [123, 456];
                 printf( "u=%d v=%d z=[%d, %d]\n", u, v, z );
                 sout | "u=" | u | "v=" | v | "z=[" | z | "]" | endl;
+                sout | "u=" | u | "v=" | v | "z=[" | z | "]";
+        }
+        {
 …
                 [t, x, d, i, c, x] = (double)94.12;
                 printf( "d=%lg i=%d c=%c t=[%d, %lg, %d]\n", d, i, (int)c, t );
                 sout | "d=" | d | "i=" | i | "c=" | c | ' ' | "t=[" | t | "]" | endl;
+                sout | "d=" | d | "i=" | i | "c=" | c | ' ' | "t=[" | t | "]";
                 [x, c, i, d, x, t] = (double)-94.12;
                 printf( "d=%lg i=%d c=%c t=[%d, %lg, %d]\n", d, i, c, t );
                 sout | "d=" | d | "i=" | i | "c=" | c | ' ' | "t=[" | t | "]" | endl;
+                sout | "d=" | d | "i=" | i | "c=" | c | ' ' | "t=[" | t | "]";
+        }
+}

tests/userLiterals.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // user_literals.c --
+// user_literals.cfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Wed Sep  6 21:40:50 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Apr 29 16:51:42 2018
 // Update Count     : 54
+// Last Modified On : Tue Dec  4 22:03:10 2018
+// Update Count     : 56
 //
 …
 #include <uchar.h>
 int ?`s( int s ) { sout | "secs" | s | endl; return s; }
 int ?`m( int m ) { sout | "mins" | m | endl; return m * 60; }
 int ?`h( int h ) { sout | "hours" | h | endl; return h * 3600; }
 int ?`_A_( int x ) { sout | "_A_" | x | endl; return x; }
 int ?`__thingy_( int x ) { sout | "_thingy_" | x | endl; return x; }
+int ?`s( int s ) { sout | "secs" | s; return s; }
+int ?`m( int m ) { sout | "mins" | m; return m * 60; }
+int ?`h( int h ) { sout | "hours" | h; return h * 3600; }
+int ?`_A_( int x ) { sout | "_A_" | x; return x; }
+int ?`__thingy_( int x ) { sout | "_thingy_" | x; return x; }
 int ?`s( const char * s ) { sout | "secs" | s | endl; return 0; }
 int ?`m( const char16_t * m ) { sout | "mins" | m | endl; return 0;}
 int ?`h( const char32_t * h ) { sout | "hours" | h | endl; return 0; }
 int ?`_A_( const wchar_t * str ) { sout | "_A_" | str | endl; return 0; }
 int ?`__thingy_( const char * str ) { sout | "_thingy_" | str | endl; return 0; }
+int ?`s( const char * s ) { sout | "secs" | s; return 0; }
+int ?`m( const char16_t * m ) { sout | "mins" | m; return 0;}
+int ?`h( const char32_t * h ) { sout | "hours" | h; return 0; }
+int ?`_A_( const wchar_t * str ) { sout | "_A_" | str; return 0; }
+int ?`__thingy_( const char * str ) { sout | "_thingy_" | str; return 0; }
 …
         Weight w, heavy = { 20 };                                                       // 20 stone
         w = 155`lb;
         sout | w | endl;
+        sout | w;
         w = 0b_1111`st;
         sout | w | endl;
+        sout | w;
         w = 0_233`lb;                                                                           // octal weight (155)
         sout | w | endl;
+        sout | w;
         w = 0x_9b_u`kg;
         sout | w | endl;
+        sout | w;
         w = 70.3`kg;
         sout | w | endl;
+        sout | w;
         w = 11`st + 1`lb;
         sout | w | endl;
+        sout | w;
         w = 5`st + 8`kg + 25`lb + heavy;
         sout | w | endl;
+        sout | w;
 //      0`secs;
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa user_literals.c" //
+// compile-command: "cfa user_literals.cfa" //
 // End: //

tests/variableDeclarator.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // variableDeclarator.c --
+// variableDeclarator.cfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Wed Aug 17 08:41:42 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Aug 17 08:42:21 2016
 // Update Count     : 1
+// Last Modified On : Tue Nov  6 18:02:16 2018
+// Update Count     : 2
 //
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa variableDeclarator.c" //
+// compile-command: "cfa variableDeclarator.cfa" //
 // End: //

tests/vector.cfa

-              rcdc02f2
+              r515a037
 // file "LICENCE" distributed with Cforall.
 //
 // vector.c --
+// vector.cfa --
 //
 // Author           : Thierry Delisle
 // Created On       : Mon Jul  4 23:36:19 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jan 18 17:08:08 2018
 // Update Count     : 27
+// Last Modified On : Tue Dec  4 22:02:39 2018
+// Update Count     : 29
 //
 …
         do {                                                                            \
                 if ( !(x) ) {                                                   \
                         sout | "CHECK failed :" | #x | "at" | __FILE__ | " :" | __LINE__ | endl;        \
+                        sout | "CHECK failed :" | #x | "at" | __FILE__ | " :" | __LINE__;       \
                         abort();                                                        \
                 }                                                                               \
 …
         assert( empty( &iv ) );
         assert( size( &iv ) == 0 );
         sout | size( &iv ) | endl;
+        sout | size( &iv );
         push_back( &iv, 1 );
         assert( size( &iv ) == 1 );
         sout | size( &iv ) | endl;
+        sout | size( &iv );
         push_back( &iv, 2 );
         assert( size( &iv ) == 2 );
         sout | size( &iv ) | endl;
+        sout | size( &iv );
         push_back( &iv, 3 );
         assert( size( &iv ) == 3 );
         sout | size( &iv ) | endl;
+        sout | size( &iv );
         assert( !empty( &iv ) );
 …
         assert( empty( &iv ) );
         assert( size( &iv ) == 0 );
         sout | size( &iv ) | endl;
+        sout | size( &iv );
+}
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa vector.c" //
+// compile-command: "cfa vector.cfa" //
 // End: //

Context Navigation

Legend:

Download in other formats: