Diff [33218c6845f9825be5a63043ef89bb8a0a80d009:e0a653db8aa583cd75afd672597c8a9f188a1add] for / – Cforall

configure

-              r33218c6
+              re0a653d
         case $host_cpu in
                 i386)
                         CFLAGS+=" -m32 "
                         CXXFLAGS+=" -m32 "
                         CFAFLAGS+=" -m32 "
                         LDFLAGS+=" -m32 "
+                        CFLAGS+="-m32"
+                        CXXFLAGS+="-m32"
+                        CFAFLAGS+="-m32"
+                        LDFLAGS+="-m32"
                         ;;
                 i686)
                         CFLAGS+=" -m32 "
                   CXXFLAGS+=" -m32 "
                   CFAFLAGS+=" -m32 "
                   LDFLAGS+=" -m32 "
+                        CFLAGS+="-m32"
+                        CXXFLAGS+="-m32"
+                        CFAFLAGS+="-m32"
+                        LDFLAGS+="-m32"
                         ;;
                 x86_64)
                         CFLAGS+=" -m64 "
                         CXXFLAGS+=" -m64 "
                         CFAFLAGS+=" -m64 "
                         LDFLAGS+=" -m64 "
+                        CFLAGS+="-m64"
+                        CXXFLAGS+="-m64"
+                        CFAFLAGS+="-m64"
+                        LDFLAGS+="-m64"
                         ;;
         esac

configure.ac

-              r33218c6
+              re0a653d
 AC_SUBST([MACHINE_TYPE],[$host_cpu])
 if ! test "$host_cpu" = "$build_cpu"; then
+if ! test "$host_cpu" = "$build_cpu"; then
         case $host_cpu in
                 i386)
                         CFLAGS+=" -m32 "
                         CXXFLAGS+=" -m32 "
                         CFAFLAGS+=" -m32 "
                         LDFLAGS+=" -m32 "
+                        CFLAGS+="-m32"
+                        CXXFLAGS+="-m32"
+                        CFAFLAGS+="-m32"
+                        LDFLAGS+="-m32"
                         ;;
                 i686)
                         CFLAGS+=" -m32 "
                   CXXFLAGS+=" -m32 "
                   CFAFLAGS+=" -m32 "
                   LDFLAGS+=" -m32 "
+                        CFLAGS+="-m32"
+                        CXXFLAGS+="-m32"
+                        CFAFLAGS+="-m32"
+                        LDFLAGS+="-m32"
                         ;;
                 x86_64)
                         CFLAGS+=" -m64 "
                         CXXFLAGS+=" -m64 "
                         CFAFLAGS+=" -m64 "
                         LDFLAGS+=" -m64 "
+                        CFLAGS+="-m64"
+                        CXXFLAGS+="-m64"
+                        CFAFLAGS+="-m64"
+                        LDFLAGS+="-m64"
                         ;;
         esac

doc/LaTeXmacros/common.tex

-              r33218c6
+              re0a653d
 %% Created On       : Sat Apr  9 10:06:17 2016
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Mon Jul 17 10:21:17 2017
 %% Update Count     : 348
+%% Last Modified On : Sun Jun 18 20:32:32 2017
+%% Update Count     : 319
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 % Names used in the document.
 \newcommand{\CFAIcon}{\textsf{C}\raisebox{\depth}{\rotatebox{180}{\textsf{A}}}\xspace} % Cforall symbolic name
+\newcommand{\CFAIcon}{\textrm{C}\raisebox{\depth}{\rotatebox{180}{\textsf{A}}}\xspace} % Cforall symbolic name
 \newcommand{\CFA}{\protect\CFAIcon} % safe for section/caption
 \newcommand{\CFL}{\textrm{Cforall}\xspace} % Cforall symbolic name
 …
 \setlength{\parindentlnth}{\parindent}
-\newcommand{\LstKeywordStyle}[1]{{\lst@basicstyle{\lst@keywordstyle{#1}}}}
-\newcommand{\LstCommentStyle}[1]{{\lst@basicstyle{\lst@commentstyle{#1}}}}
 \newlength{\gcolumnposn}                                % temporary hack because lstlisting does not handle tabs correctly
 \newlength{\columnposn}
 \setlength{\gcolumnposn}{2.5in}
 \setlength{\columnposn}{\gcolumnposn}
 \newcommand{\C}[2][\@empty]{\ifx#1\@empty\else\global\setlength{\columnposn}{#1}\global\columnposn=\columnposn\fi\hfill\makebox[\textwidth-\columnposn][l]{\lst@basicstyle{\LstCommentStyle{#2}}}}
+\newcommand{\C}[2][\@empty]{\ifx#1\@empty\else\global\setlength{\columnposn}{#1}\global\columnposn=\columnposn\fi\hfill\makebox[\textwidth-\columnposn][l]{\lst@commentstyle{#2}}}
 \newcommand{\CRT}{\global\columnposn=\gcolumnposn}
 …
 % inline text and code index (cannot use ©)
 \newcommand{\Indexc}[2][\@empty]{\lstinline[#1]$#2$\index{#2@\lstinline[#1]$#2$}}
+\newcommand{\Indexc}[1]{\lstinline$#1$\index{#1@\lstinline$#1$}}
 % code index (cannot use ©)
 \newcommand{\indexc}[2][\@empty]{\index{#2@\lstinline[#1]$#2$}}
+\newcommand{\indexc}[1]{\index{#1@\lstinline$#1$}}
 % Denote newterms in particular font and index them without particular font and in lowercase, e.g., \newterm{abc}.
 …
 basicstyle=\linespread{0.9}\sf,                                                 % reduce line spacing and use sanserif font
 stringstyle=\tt,                                                                                % use typewriter font
 tabsize=6,                                                                                              % N space tabbing
+tabsize=4,                                                                                              % 4 space tabbing
 xleftmargin=\parindentlnth,                                                             % indent code to paragraph indentation
 extendedchars=true,                                                                             % allow ASCII characters in the range 128-255

doc/LaTeXmacros/lstlang.sty

-              r33218c6
+              re0a653d
 %% Created On       : Sat May 13 16:34:42 2017
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Wed Jul 12 22:42:09 2017
 %% Update Count     : 12
+%% Last Modified On : Thu Jun 22 07:40:31 2017
+%% Update Count     : 10
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
                 finally, forall, ftype, _Generic, _Imaginary, inline, __label__, lvalue, _Noreturn, one_t,
                 otype, restrict, _Static_assert, throw, throwResume, trait, try, ttype, typeof, __typeof,
                 __typeof__, with, zero_t},
+                __typeof__, zero_t},
         morekeywords=[2]{
                 _Atomic, coroutine, is_coroutine, is_monitor, is_thread, monitor, mutex, nomutex,
 …
         moredirectives={defined,include_next}%
+}
-% C++ programming language
-\lstdefinelanguage{C++}[ANSI]{C++}{}
 % uC++ programming language, based on ANSI C++

doc/bibliography/cfa.bib

-              r33218c6
+              re0a653d
 @manual{JavaScript,
     keywords    = {JavaScript},
     contributer = {pabuhr@plg},
+    contributer = {pabuhr},
     title       = {ECMAScript 2015 Language Specification {JavaScript}},
     organization= {ECAM International},
 …
 @manual{Erlang,
     keywords    = {Erlang},
     contributer = {pabuhr@plg},
+    contributer = {pabuhr},
     title       = {Erlang Reference Manual User's Guide, Vertion 7.0},
     organization= {Erlang/OTP System Documentation},
 …
     publisher   = {ACM},
     address     = {New York, NY, USA},
+}
-@article{Yang95,
-    keywords    = {software solutions, N-thread, mutual exclusions},
-    contributer = {pabuhr@plg},
-    author      = {Jae-Heon Yang and James H. Anderson},
-    title       = {A Fast, Scalable Mutual Exclusion Algorithm},
-    journal     = {Distributed Computing},
-    publisher   = {Springer-Verlag},
-    volume      = {9},
-    number      = {1},
-    year        = {1995},
-    pages       = {51-60},
+}
 …
     contributer = {pabuhr@plg},
     author      = {Kathleen Jensen and Niklaus Wirth},
     title       = {{P}ascal User Manual and Report, ISO Pascal Standard},
+    title       = {{P}ascal User Manual and Report},
     publisher   = {Springer--Verlag},
     year        = 1991,
     edition     = {4th},
     note        = {Revised by Andrew B. Mickel and James F. Miner}
+    year        = 1985,
+    edition     = {3rd},
+    note        = {Revised by Andrew B. Mickel and James F. Miner, ISO Pascal Standard}
+}

doc/proposals/virtual.txt

-              r33218c6
+              re0a653d
 Proposal for virtual functionality
-There are two types of virtual inheritance in this proposal, relaxed
-(implicit) and strict (explicit). Relaxed is the simpler case that uses the
-existing trait system with the addition of trait references and vtables.
-Strict adds some constraints and requires some additional notation but allows
-for down-casting.
-Relaxed Virtual Inheritance:
 Imagine the following code :
 …
 void draw(line*);
 While all the members of this simple UI support drawing, creating a UI that
 easily supports both these UI requires some tedious boiler-plate code:
+While all the members of this simple UI support drawing creating a UI that easily
+supports both these UI requires some tedious boiler-plate code :
 enum type_t { text, line };
 …
+}
+While this code will work as implemented, adding any new widgets or any new
+widget behaviors requires changing existing code to add the desired
+functionality. To ease this maintenance effort required CFA introduces the
+concept of trait references.
+While this code will work as indented, adding any new widgets or any new widget behaviors
+requires changing existing code to add the desired functionality. To ease this maintenance
+effort required CFA introduces the concept of dynamic types, in a manner similar to C++.
 Using trait references to implement the above gives the following :
+A simple usage of dynamic type with the previous example would look like :
 trait drawable objects[10];
+drawable* objects[10];
 fill_objects(objects);
 while(running) {
       for(drawable object : objects) {
+      for(drawable* object : objects) {
             draw(object);
+      }
+}
+The keyword trait is optional (by the same rules as the struct keyword). This
+is not currently supported in CFA and the lookup is not possible to implement
+statically. Therefore we need to add a new feature to handle having dynamic
 lookups like this.
+However, this is not currently do-able in the current CFA and furthermore is not
+possible to implement statically. Therefore we need to add a new feature to handle
+having dynamic types like this (That is types that are found dynamically not types
+that change dynamically).
+What we really want to do is express the fact that calling draw() on a trait
+reference should find the underlying type of the given parameter and find how
+it implements the routine, as in the example with the enumeration and union.
+C++ uses inheritance and virtual functions to find the
+desired type dynamically. CFA takes inspiration from this solution.
+For instance specifying that the drawable trait reference looks up the type
+of the first argument to find the implementation would be :
+What we really want to do is express the fact that calling draw() on a object
+should find the dynamic type of the parameter before calling the routine, much like the
+hand written example given above. We can express this by adding the virtual keyword on
+the parameter of the constraints on our trait:
 trait drawable(otype T) {
 …
 };
 This could be implied in simple cases like this one (single parameter on the
+trait and single generic parameter on the function). In more complex cases it
+would have to be explicitly given, or a strong convention would have to be
+enforced (e.g. implementation of trait functions is always drawn from the
 first polymorphic parameter).
+This expresses the idea that drawable is similar to an abstract base class in C++ and
+also gives meaning to trying to take a pointer of drawable. That is anything that can
+be cast to a drawable pointer has the necessary information to call the draw routine on
+that type. Before that drawable was only a abstract type while now it also points to a
+piece of storage which specify which behavior the object will have at run time.
+Once a function in a trait has been marked as virtual it defines a new
+function that takes in that trait's reference and then dynamically calls the
+underlying type implementation. Hence a trait reference becomes a kind of
+abstract type, cannot be directly instantiated but can still be used.
+This storage needs to be allocate somewhere. C++ just adds an invisible pointer at
+the beginning of the struct but we can do something more explicit for users, actually
+have a visible special field :
+One of the limitations of this design is that it does not support double
+dispatching, which concretely means traits cannot have routines with more than
+one virtual parameter. The program must have a single table to look up the
+function on. Using trait references with traits with more than one parameter
+is also restricted, initially forbidden, see extension.
+struct text {
+      char* text;
+      vtable drawable;
+};
+Extension: Multi-parameter Virtual Traits:
+struct line{
+      vtable drawable;
+      vec2 start;
+      vec2 end;
+};
+This implementation can be extended to traits with multiple parameters if
+one is called out as being the virtual trait. For example :
+With these semantics, adding a "vtable drawable" means that text pointers and line pointers are now
+convertible to drawable pointers. This conversion will not necessarily be a type only change however, indeed,
+the drawable pointer will point to the field "vtable drawable" not the head of the struct. However, since all
+the types are known at compile time, converting pointers becomes a simple offset operations.
+trait iterator(otype T, dtype Item) {
+        Maybe(Item) next(virtual T *);
+The vtable field contains a pointer to a vtable which contains all the information needed for the caller
+to find the function pointer of the desired behavior.
+One of the limitations of this design is that it does not support double dispatching, which
+concretely means traits cannot have routines with more than one virtual parameter. This design
+would have many ambiguities if it did support multiple virtual parameter. A futher limitation is
+that traits over more than one type cannot have vtables meaningfully defined for them, as the
+particular vtable to use would be a function of the other type(s) the trait is defined over.
+It is worth noting that the function pointers in these vtables are bound at object construction, rather than
+function call-site, as in Cforall's existing polymorphic functions. As such, it is possible that two objects
+with the same static type would have a different vtable (consider what happens if draw(line*) is overridden
+between the definitions of two line objects). Given that the virtual drawable* erases static types though,
+this should not be confusing in practice. A more distressing possibility is that of creating an object that
+outlives the scope of one of the functions in its vtable. This is certainly a possible bug, but it is of a
+type that C programmers are familiar with, and should be able to avoid by the usual methods.
+Extensibility.
+One of the obvious critics of this implementation is that it lacks extensibility for classes
+that cannot be modified (ex: Linux C headers). However this solution can be extended to
+allow more extensibility by adding "Fat pointers".
+Indeed, users could already "solve" this issue by writing their own fat pointers as such:
+trait MyContext(otype T) {
+      void* get_stack(virtual T*)
+};
+void* get_stack(ucontext_t *context);
+struct fat_ucontext_t {
+      vtable MyContext;
+      ucontext_t *context;
+}
+iterator(int) generators[10];
+Which creates a collection of iterators that produce integers, regardless of
+how those iterators are implemented. This may require a note that this trait
+is virtual on T and not Item, but noting it on the functions may be enough.
+Strict Virtual Inheritance:
+One powerful feature relaxed virtual does not support is the idea of down
+casting. Once something has been converted into a trait reference there is
+very little we can do to recover and of the type information, only the trait's
+required function implementations are kept.
+To allow down casting strict virtual requires that all traits and structures
+involved be organized into a tree. Each trait or struct must have a unique
+position on this tree (no multiple inheritance).
+This is declared as follows :
+trait error(otype T) virtual {
+        const char * msg(T *);
+//Tedious forwarding routine
+void* get_stack(fat_ucontext_t *ptr) {
+      return get_stack(ptr->context);
+}
+trait io_error(otype T) virtual error {
+        FILE * src(T *);
+}
+However, users would have to write all the virtual methods they want to override and make
+them all simply forward to the existing method that takes the corresponding POCO(Plain Old C Object).
+struct eof_error virtual io_error {
+        FILE * fd;
+The alternative we propose is to use language level fat pointers :
+trait MyContext(otype T) {
+      void* get_stack(virtual T*)
 };
+So the trait error is the head of a new tree and io_error is a child of it.
+void* get_stack(ucontext_t *context);
+Also the parent trait is implicitly part of the assertions of the children,
+so all children implement the same operations as the parent. By the unique
+path down the tree, we can also uniquely order them so that a prefix of a
+child's vtable has the same format as its parent's.
+//The type vptr(ucontext_t) all
+vptr(ucontext_t) context;
+This gives us an important extra feature, runtime checking of the parent-child
+relationship with a C++ dynamic_cast like operation. Allowing checked
+conversions from trait references to more particular references, which works
+if the underlying type is, or is a child of, the new trait type.
+These behave exactly as the previous example but all the forwarding routines are automatically generated.
+Extension: Multiple Parents
+Bikeshedding.
+Although each trait/struct must have a unique position on each tree, it could
+have positions on multiple trees. All this requires is the ability to give
+multiple parents, as here :
+It may be desirable to add fewer new keywords than discussed in this proposal; it is possible that "virtual"
+could replace both "vtable" and "vptr" above with unambiguous contextual meaning. However, for purposes of
+clarity in the design discussion it is beneficial to keep the keywords for separate concepts distinct.
-trait region(otype T) virtual drawable, collider;
-The restriction being, the parents must come from different trees. This
-object (and all of its children) can be cast to either tree. This is handled
-by generating a separate vtable for each tree the structure is in.
-Extension: Multi-parameter Strict Virtual
-If a trait has multiple parameters then one must be called out to be the one
-we generate separate vtables for, as in :
-trait example(otype T, otype U) virtual(T) ...
-This can generate a separate vtable for each U for which all the T+U
-implementations are provided. These are then separate nodes in the tree (or
-the root of different trees) as if each was created individually. Providing a
-single unique instance of these nodes would be the most difficult aspect of
-this extension, possibly intractable, though with sufficient hoisting and
-link-once duplication it may be possible.
-Example:
-trait argument(otype T) virtual {
-        char short_name(virtual T *);
-        bool is_set(virtual T *);
-};
-trait value_argument(otype T, otype U) virtual(T) argument {
-        U get_value(virtual T *);
-};
-Extension: Structural Inheritance
-Currently traits must be the internal nodes and structs the leaf nodes.
-Structs could be made internal nodes as well, in which case the child structs
-would likely structurally inherit the fields of their parents.
-Storing the Virtual Lookup Table (vtable):
-We have so far been silent on how the vtable is created, stored and accessed.
-Creation happens at compile time. Function pointers are found by using the
-same best match rules as elsewhere (additional rules for defaults from the
-parent may or may not be required). For strict virtual this must happen at the
-global scope and forbidding static functions, to ensure that a single unique
-vtable is created. Similarly, there may have to be stricter matching rules
-for the functions that go into the vtable, possibly requiring an exact match.
-Relaxed virtual could relax both restrictions, if we allow different vtable
-at different conversion (struct to trait reference) sites. If it is allowed
-local functions being bound to a vtable could cause issues when they go out
-of scope, however this should follow the lifetime rules most C programs
-already follow implicitly.
-Most vtables should be stored statically, the only exception being some of
-the relaxed vtables that could have local function pointers. These may be able
-to be stack allocated. All vtables should be immutable and require no manual
-cleanup.
-Access has two main options:
-The first is through the use of fat pointers, or a tuple of pointers. When the
-object is converted to a trait reference, the pointers to its vtables are
-stored along side it.
-This allows for compatibility with existing structures (such as those imported
-from C) and is the default storage method unless a different one is given.
-The other is by inlining the vtable pointer as "intrusive vtables". This adds
-a field to the structure to the vtable. The trait reference then has a single
-pointer to this field, the vtable includes an offset to find the beginning of
-the structure again.
-This is used if you specify a vtable field in the structure. If given in the
-trait the vtable pointer in the trait reference can then become a single
-pointer to the vtable field and use that to recover the original object
-pointer as well as retrieve all operations.
-trait drawable(otype T) {
-        vtable drawable;
-};
-struct line {
-        vtable drawable;
-        vec2 start;
-        vec2 end;
-};
-This inline code allows trait references to be converted to plain pointers
-(although they still must be called specially). The vtable field may just be
-an opaque block of memory or it may allow user access to the vtable. If so
-then there should be some way to retrieve the type of the vtable, which will be
-autogenerated and often unique.
-Keyword Usage:
-It may be desirable to add fewer new keywords than discussed in this proposal.
-It is possible that "virtual" could replace both "vtable" above with
-unambiguous contextual meaning. However, for purposes of clarity in the design
-discussion it is beneficial to keep the keywords for separate concepts distinct.
-Trait References and Operations:
-sizeof(drawable) will return the size of the trait object itself. However :
-line a_line;
-drawable widget = a_line;
-sizeof(widget);
-Will instead return the sizeof the underlying object, although the trait must
-require that its implementation is sized for there to be a meaningful value
-to return. You may also get the size of the trait reference with
-sizeof(&widget);
-Calling free on a trait reference will free the memory for the object. It will
-leave the vtables alone, as those are (always?) statically allocated.

doc/user/EHMHierarchy.fig

-              r33218c6
+              re0a653d
 #FIG 3.2  Produced by xfig version 3.2.5c
+#FIG 3.2  Produced by xfig version 3.2.5b
 Landscape
 Center
 …
 1 0 1 0 7 100 0 -1 0.000 0 0 -1 1 0 2
 1 1.00 60.00 90.00
 1425 2925 1200
+1425 3000 1200
 1 0 1 0 7 100 0 -1 0.000 0 0 -1 1 0 2
 1 1.00 60.00 90.00
 …
 1 1.00 60.00 90.00
 1950 4950 1725
 1 0 50 -1 0 13 0.0000 2 135 225 1950 1650 IO\001
 1 0 50 -1 0 13 0.0000 2 135 915 4950 1650 Arithmetic\001
 1 0 50 -1 0 13 0.0000 2 150 330 1350 2100 File\001
 1 0 50 -1 0 13 0.0000 2 135 735 2550 2100 Network\001
 1 0 50 -1 0 13 0.0000 2 180 1215 3750 2100 DivideByZero\001
 1 0 50 -1 0 13 0.0000 2 150 810 4950 2100 Overflow\001
 1 0 50 -1 0 13 0.0000 2 150 915 6000 2100 Underflow\001
 1 0 50 -1 0 13 0.0000 2 180 855 3450 1200 Exception\001
+1 0 100 0 0 12 0.0000 0 135 195 1950 1650 IO\001
+1 0 100 0 0 12 0.0000 0 135 870 4950 1650 Arithmetic\001
+1 0 100 0 0 12 0.0000 0 135 315 1350 2100 File\001
+1 0 100 0 0 12 0.0000 0 135 690 2550 2100 Network\001
+1 0 100 0 0 12 0.0000 0 180 1170 3750 2100 DivideByZero\001
+1 0 100 0 0 12 0.0000 0 135 750 4950 2100 Overflow\001
+1 0 100 0 0 12 0.0000 0 135 855 6000 2100 Underflow\001
+1 0 100 0 0 12 0.0000 0 180 840 3450 1200 Exception\001

doc/user/Makefile

r33218c6	re0a653d
1	1	## Define the appropriate configuration variables.
2	2
3		TeXLIB = .:../LaTeXmacros:../bibliography/:
	3	TeXLIB = .:../LaTeXmacros:../LaTeXmacros/listings:../LaTeXmacros/enumitem:../bibliography/:
4	4	LaTeX = TEXINPUTS=${TeXLIB} && export TEXINPUTS && latex -halt-on-error
5	5	BibTeX = BIBINPUTS=${TeXLIB} && export BIBINPUTS && bibtex

doc/user/user.tex

-              r33218c6
+              re0a653d
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Sat Jul 22 11:01:19 2017
 %% Update Count     : 2878
+%% Last Modified On : Fri Jul  7 10:36:39 2017
+%% Update Count     : 2547
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 \CFAStyle                                                                                               % use default CFA format-style
-\lstnewenvironment{C++}[1][]
-{\lstset{language=C++,moredelim=**[is][\protect\color{red}]{®}{®}#1}}
-{}
 % inline code ©...© (copyright symbol) emacs: C-q M-)
 % red highlighting ®...® (registered trademark symbol) emacs: C-q M-.
 …
 \CFA{}\index{cforall@\CFA}\footnote{Pronounced ``\Index*{C-for-all}'', and written \CFA, CFA, or \CFL.} is a modern general-purpose programming-language, designed as an evolutionary step forward for the C programming language.
 The syntax of \CFA builds from C and should look immediately familiar to C/\Index*[C++]{\CC{}} programmers.
+The syntax of the \CFA language builds from C, and should look immediately familiar to C/\Index*[C++]{\CC{}} programmers.
 % Any language feature that is not described here can be assumed to be using the standard \Celeven syntax.
 \CFA adds many modern programming-language features that directly lead to increased \emph{\Index{safety}} and \emph{\Index{productivity}}, while maintaining interoperability with existing C programs and achieving similar performance.
 Like C, \CFA is a statically typed, procedural (non-\Index{object-oriented}) language with a low-overhead runtime, meaning there is no global \Index{garbage-collection}, but \Index{regional garbage-collection}\index{garbage-collection!regional} is possible.
+\CFA adds many modern programming-language features that directly lead to increased \emph{\Index{safety}} and \emph{\Index{productivity}}, while maintaining interoperability with existing C programs and achieving C performance.
+Like C, \CFA is a statically typed, procedural language with a low-overhead runtime, meaning there is no global \Index{garbage-collection}, but \Index{regional garbage-collection}\index{garbage-collection!regional} is possible.
 The primary new features include parametric-polymorphic routines and types, exceptions, concurrency, and modules.
+One of the main design philosophies of \CFA is to ``\Index{describe not prescribe}'', which means \CFA tries to provide a pathway from low-level C programming to high-level \CFA programming, but it does not force programmers to ``do the right thing''.
+Programmers can cautiously add \CFA extensions to their C programs in any order and at any time to incrementally move towards safer, higher-level programming.
+A programmer is always free to reach back to C from \CFA, for any reason, and in many cases, new \CFA features can be locally switched back to there C counterpart.
+There is no notion or requirement for \emph{rewriting} a legacy C program in \CFA;
+instead, a programmer evolves a legacy program into \CFA by incrementally incorporating \CFA features.
+As well, new programs can be written in \CFA using a combination of C and \CFA features.
+\Index*[C++]{\CC{}} had a similar goal 30 years ago, allowing object-oriented programming to be incrementally added to C.
+However, \CC currently has the disadvantages of a strong object-oriented bias, multiple legacy design-choices that cannot be updated, and active divergence of the language model from C, all of which requires significant effort and training to incrementally add \CC to a C-based project.
+One of the main design philosophies of \CFA is to ``describe not prescribe'', which means \CFA tries to provide a pathway from low-level C programming to high-level \CFA programming, but it does not force programmers to ``do the right thing''.
+Programmers can cautiously add \CFA extensions to their C programs in any order and at any time to incrementally move towards safer, higher-level programming features.
+A programmer is always free to reach back to C from \CFA for any reason, and in many cases, new \CFA features have a fallback to a C mechanism.
+There is no notion or requirement for rewriting a legacy C program in \CFA;
+instead, a programmer evolves an existing C program into \CFA by incrementally incorporating \CFA features.
+New programs can be written in \CFA using a combination of C and \CFA features.
+\Index*[C++]{\CC{}} had a similar goal 30 years ago, but currently has the disadvantages of multiple legacy design-choices that cannot be updated and active divergence of the language model from C, requiring significant effort and training to incrementally add \CC to a C-based project.
 In contrast, \CFA has 30 years of hindsight and a clean starting point.
 …
 \begin{quote2}
 \begin{tabular}{@{}l@{\hspace{1.5em}}l@{\hspace{1.5em}}l@{}}
+\multicolumn{1}{c@{\hspace{1.5em}}}{\textbf{C}} & \multicolumn{1}{c}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{\CC}}      \\
+\begin{cfa}
+\multicolumn{1}{c@{\hspace{1.5em}}}{\textbf{\CFA}}      & \multicolumn{1}{c}{\textbf{C}}        & \multicolumn{1}{c}{\textbf{\CC}}      \\
+\begin{cfa}
+#include <fstream>§\indexc{fstream}§
+int main( void ) {
+        int x = 0, y = 1, z = 2;
+        ®sout | x | y | z | endl;®
+}
+\end{cfa}
+&
+\begin{lstlisting}
 #include <stdio.h>§\indexc{stdio.h}§
 …
         ®printf( "%d %d %d\n", x, y, z );®
+}
 \end{cfa}
+\end{lstlisting}
+&
+\begin{cfa}
+#include <fstream>§\indexc{fstream}§
+int main( void ) {
+        int x = 0, y = 1, z = 2;
+        ®sout | x | y | z | endl;®§\indexc{sout}§
+}
+\end{cfa}
+&
+\begin{cfa}
+\begin{lstlisting}
 #include <iostream>§\indexc{iostream}§
 using namespace std;
 …
         ®cout<<x<<" "<<y<<" "<<z<<endl;®
+}
 \end{cfa}
+\end{lstlisting}
 \end{tabular}
 \end{quote2}
 While the \CFA I/O looks similar to the \Index*[C++]{\CC{}} output style, there are important differences, such as automatic spacing between variables as in \Index*{Python} (see~\VRef{s:IOLibrary}).
-\subsection{Background}
 This document is a programmer reference-manual for the \CFA programming language.
 The manual covers the core features of the language and runtime-system, with simple examples illustrating syntax and semantics of each feature.
 The manual does not teach programming, i.e., how to combine the new constructs to build complex programs.
 A reader should already have an intermediate knowledge of control flow, data structures, and concurrency issues to understand the ideas presented, as well as some experience programming in C/\CC.
 Implementers should refer to the \CFA Programming Language Specification for details about the language syntax and semantics.
+A reader should already have an intermediate knowledge of control flow, data structures, and concurrency issues to understand the ideas presented as well as some experience programming in C/\CC.
+Implementers may refer to the \CFA Programming Language Specification for details about the language syntax and semantics.
 Changes to the syntax and additional features are expected to be included in later revisions.
 …
 This installation base and the programmers producing it represent a massive software-engineering investment spanning decades and likely to continue for decades more.
 Even with all its problems, C continues to be popular because it allows writing software at virtually any level in a computer system without restriction.
 For system programming, where direct access to hardware, storage management, and real-time issues are a requirement, C is usually the only language of choice.
+For system programming, where direct access to hardware and dealing with real-time issues is a requirement, C is usually the language of choice.
 The TIOBE index~\cite{TIOBE} for March 2016 showed the following programming-language popularity: \Index*{Java} 20.5\%, C 14.5\%, \Index*[C++]{\CC{}} 6.7\%, \Csharp 4.3\%, \Index*{Python} 4.3\%, where the next 50 languages are less than 3\% each with a long tail.
 As well, for 30 years, C has been the number 1 and 2 most popular programming language:
 …
 \end{center}
 Hence, C is still an extremely important programming language, with double the usage of \Index*[C++]{\CC{}}; in many cases, \CC is often used solely as a better C.
 Love it or hate it, C has been an important and influential part of computer science for 40 years and its appeal is not diminishing.
 Unfortunately, C has many problems and omissions that make it an unacceptable programming language for modern needs.
 As stated, the goal of the \CFA project is to engineer modern language-features into C in an evolutionary rather than revolutionary way.
+Love it or hate it, C has been an important and influential part of computer science for 40 years and sit appeal is not diminishing.
+Unfortunately, C has too many problems and omissions to make it an acceptable programming language for modern needs.
+As stated, the goal of the \CFA project is to engineer modern language features into C in an evolutionary rather than revolutionary way.
 \CC~\cite{C++14,C++} is an example of a similar project;
 however, it largely extended the C language, and did not address most of C's existing problems.\footnote{%
+however, it largely extended the language, and did not address many existing problems.\footnote{%
 Two important existing problems addressed were changing the type of character literals from ©int© to ©char© and enumerator from ©int© to the type of its enumerators.}
 \Index*{Fortran}~\cite{Fortran08}, \Index*{Ada}~\cite{Ada12}, and \Index*{Cobol}~\cite{Cobol14} are examples of programming languages that took an evolutionary approach, where modern language-features (\eg objects, concurrency) are added and problems fixed within the framework of the existing language.
+\Index*{Fortran}~\cite{Fortran08}, \Index*{Ada}~\cite{Ada12}, and \Index*{Cobol}~\cite{Cobol14} are examples of programming languages that took an evolutionary approach, where modern language features (\eg objects, concurrency) are added and problems fixed within the framework of the existing language.
 \Index*{Java}~\cite{Java8}, \Index*{Go}~\cite{Go}, \Index*{Rust}~\cite{Rust} and \Index*{D}~\cite{D} are examples of the revolutionary approach for modernizing C/\CC, resulting in a new language rather than an extension of the descendent.
 These languages have different syntax and semantics from C, do not interoperate directly with C, and are not systems languages because of restrictive memory-management or garbage collection.
+These languages have different syntax and semantics from C, and do not interoperate directly with C, largely because of garbage collection.
 As a result, there is a significant learning curve to move to these languages, and C legacy-code must be rewritten.
 These costs can be prohibitive for many companies with a large software-base in C/\CC, and a significant number of programmers require retraining to the new programming language.
 The result of this project is a language that is largely backwards compatible with \Index*[C11]{\Celeven{}}~\cite{C11}, but fixes many of the well known C problems while containing modern language-features.
+These costs can be prohibitive for many companies with a large software base in C/\CC, and a significant number of programmers requiring retraining to a new programming language.
+The result of this project is a language that is largely backwards compatible with \Index*[C11]{\Celeven{}}~\cite{C11}, but fixing some of the well known C problems and containing many modern language features.
 Without significant extension to the C programming language, it is becoming unable to cope with the needs of modern programming problems and programmers;
 as a result, it will fade into disuse.
 Considering the large body of existing C code and programmers, there is significant impetus to ensure C is transformed into a modern programming language.
 While \Index*[C11]{\Celeven{}} made a few simple extensions to the language, nothing was added to address existing problems in the language or to augment the language with modern language-features.
 While some may argue that modern language-features may make C complex and inefficient, it is clear a language without modern capabilities is insufficient for the advanced programming problems existing today.
+While \Index*[C11]{\Celeven{}} made a few simple extensions to the language, nothing was added to address existing problems in the language or to augment the language with modern language features.
+While some may argue that modern language features may make C complex and inefficient, it is clear a language without modern capabilities is insufficient for the advanced programming problems existing today.
 \section{History}
 The \CFA project started with \Index*{K-W C}~\cite{Buhr94a,Till89}, which extended C with new declaration syntax, multiple return values from routines, and advanced assignment capabilities using the notion of tuples.
+The \CFA project started with \Index*{K-W C}~\cite{Buhr94a,Till89}, which extended C with new declaration syntax, multiple return values from routines, and extended assignment capabilities using the notion of tuples.
 (See~\cite{Werther96} for similar work in \Index*[C++]{\CC{}}.)
+The first \CFA implementation of these extensions was by Esteves~\cite{Esteves04}.
+The signature feature of \CFA is \emph{\Index{overload}able} \Index{parametric-polymorphic} functions~\cite{forceone:impl,Cormack90,Duggan96} with functions generalized using a ©forall© clause (giving the language its name):
+A first \CFA implementation of these extensions was by Esteves~\cite{Esteves04}.
+The signature feature of \CFA is parametric-polymorphic functions~\cite{forceone:impl,Cormack90,Duggan96} with functions generalized using a ©forall© clause (giving the language its name):
 \begin{lstlisting}
 ®forall( otype T )® T identity( T val ) { return val; }
 …
 \end{lstlisting}
 % extending the C type system with parametric polymorphism and overloading, as opposed to the \Index*[C++]{\CC{}} approach of object-oriented extensions.
 \CFA{}\hspace{1pt}'s polymorphism was originally formalized by Ditchfield~\cite{Ditchfield92}, and first implemented by Bilson~\cite{Bilson03}.
+\CFA{}\hspace{1pt}'s polymorphism was originally formalized by Ditchfiled~\cite{Ditchfield92}, and first implemented by Bilson~\cite{Bilson03}.
 However, at that time, there was little interesting in extending C, so work did not continue.
 As the saying goes, ``\Index*{What goes around, comes around.}'', and there is now renewed interest in the C programming language because of legacy code-bases, so the \CFA project has been restarted.
+As the saying goes, ``What goes around, comes around.'', and there is now renewed interest in the C programming language because of legacy code-bases, so the \CFA project has been restarted.
 …
 \CFA is designed to integrate directly with existing C programs and libraries.
 The most important feature of \Index{interoperability} is using the same \Index{calling convention}s, so there is no complex interface or overhead to call existing C routines.
+The most important feature of \Index{interoperability} is using the same \Index{calling convention}s, so there is no overhead to call existing C routines.
 This feature allows \CFA programmers to take advantage of the existing panoply of C libraries to access thousands of external software features.
 Language developers often state that adequate \Index{library support} takes more work than designing and implementing the language itself.
 Fortunately, \CFA, like \Index*[C++]{\CC{}}, starts with immediate access to all exiting C libraries, and in many cases, can easily wrap library routines with simpler and safer interfaces, at very low cost.
 Hence, \CFA begins by leveraging the large repository of C libraries, and than allows programmers to incrementally augment their C programs with modern \Index{backward-compatible} features.
+Hence, \CFA begins by leveraging the large repository of C libraries with little cost.
 \begin{comment}
 …
 \end{comment}
 However, it is necessary to differentiate between C and \CFA code because of name \Index{overload}ing, as for \CC.
+However, it is necessary to differentiate between C and \CFA code because of name overloading, as for \CC.
 For example, the C math-library provides the following routines for computing the absolute value of the basic types: ©abs©, ©labs©, ©llabs©, ©fabs©, ©fabsf©, ©fabsl©, ©cabsf©, ©cabs©, and ©cabsl©.
 Whereas, \CFA wraps each of these routines into ones with the overloaded name ©abs©:
+Whereas, \CFA wraps each of these routines into ones with the common name ©abs©:
 \begin{cfa}
 char abs( char );
+®extern "C" {® int abs( int ); ®}®              §\C{// use default C routine for int}§
+®extern "C" {®
+int abs( int );                                                 §\C{// use default C routine for int}§
+®}® // extern "C"
 long int abs( long int );
 long long int abs( long long int );
 …
 Hence, there is the same need as in \CC, to know if a name is a C or \CFA name, so it can be correctly formed.
 There is no way around this problem, other than C's approach of creating unique names for each pairing of operation and type.
+This example strongly illustrates a core idea in \CFA: \emph{the \Index{power of a name}}.
+This example strongly illustrates a core idea in \CFA: \emph{the power of a name}.
 The name ``©abs©'' evokes the notion of absolute value, and many mathematical types provide the notion of absolute value.
 Hence, knowing the name ©abs© is sufficient to apply it to any type where it is applicable.
 The time savings and safety of using one name uniformly versus $N$ unique names cannot be underestimated.
 \section[Compiling a CFA Program]{Compiling a \CFA Program}
 The command ©cfa© is used to compile a \CFA program and is based on the \Index{GNU} \Indexc{gcc} command, \eg:
 \begin{cfa}
 cfa§\indexc{cfa}\index{compilation!cfa@©cfa©}§ [ gcc-options ] C/§\CFA{}§-files [ assembler/loader-files ]
+Hence, knowing the name ©abs© should be sufficient to apply it to any type where it is applicable.
+The time savings and safety of using one name uniformly versus $N$ unique names should not be underestimated.
+\section[Compiling CFA Program]{Compiling \CFA Program}
+The command ©cfa© is used to compile \CFA program(s), and is based on the GNU \Indexc{gcc} command, \eg:
+\begin{cfa}
+cfa§\indexc{cfa}\index{compilation!cfa@©cfa©}§ [ gcc-options ] C/§\CFA§-files [ assembler/loader-files ]
 \end{cfa}
 \CFA programs having the following ©gcc© flags turned on:
 …
 The 1999 C standard plus GNU extensions.
 \item
+\Indexc[deletekeywords=inline]{-fgnu89-inline}\index{compilation option!-fgnu89-inline@{\lstinline[deletekeywords=inline]$-fgnu89-inline$}}
+{\lstset{deletekeywords={inline}}
+\Indexc{-fgnu89-inline}\index{compilation option!-fgnu89-inline@{©-fgnu89-inline©}}
 Use the traditional GNU semantics for inline routines in C99 mode, which allows inline routines in header files.
+}%
 \end{description}
 The following new \CFA options are available:
 …
 \Indexc{-CFA}\index{compilation option!-CFA@©-CFA©}
 Only the C preprocessor and the \CFA translator steps are performed and the transformed program is written to standard output, which makes it possible to examine the code generated by the \CFA translator.
 The generated code starts with the standard \CFA \Index{prelude}.
+The generated code started with the standard \CFA prelude.
 \item
 \Indexc{-debug}\index{compilation option!-debug@©-debug©}
 The program is linked with the debugging version of the runtime system.
 The debug version performs runtime checks to help during the debugging phase of a \CFA program, but can substantially slow program execution.
+The debug version performs runtime checks to help during the debugging phase of a \CFA program, but substantially slows the execution of the program.
 The runtime checks should only be removed after the program is completely debugged.
 \textbf{This option is the default.}
 …
 \Indexc{-nodebug}\index{compilation option!-nodebug@©-nodebug©}
 The program is linked with the non-debugging version of the runtime system, so the execution of the program is faster.
 \Emph{However, no runtime checks or ©assert©s are performed so errors usually result in abnormal program behaviour or termination.}
+\Emph{However, no runtime checks or ©assert©s are performed so errors usually result in abnormal program termination.}
 \item
 …
 \textbf{This option is the default.}
-\begin{comment}
 \item
 \Indexc{-no-include-stdhdr}\index{compilation option!-no-include-stdhdr@©-no-include-stdhdr©}
 Do not supply ©extern "C"© wrappers for \Celeven standard include files (see~\VRef{s:StandardHeaders}).
 \textbf{This option is \emph{not} the default.}
-\end{comment}
 \end{description}
 …
 \item
 \Indexc{__CFA__}\index{preprocessor variables!__CFA__@©__CFA__©},
 \Indexc{__CFORALL__}\index{preprocessor variables!__CFORALL__@©__CFORALL__©}, and
+\Indexc{__CFORALL__}\index{preprocessor variables!__CFORALL__@©__CFORALL__©} and
 \Indexc{__cforall}\index{preprocessor variables!__cforall@©__cforall©}
 are always available during preprocessing and have no value.
 \end{description}
 These preprocessor variables allow conditional compilation of programs that must work differently in these situations.
 For example, to toggle between C and \CFA extensions, use the following:
+For example, to toggle between C and \CFA extensions, using the following:
 \begin{cfa}
 #ifndef __CFORALL__
 …
 \section{Constant Underscores}
 Numeric constants are extended to allow \Index{underscore}s\index{constant!underscore}, \eg:
+\section{Constants Underscores}
+Numeric constants are extended to allow \Index{underscore}s within constants\index{constant!underscore}, \eg:
 \begin{cfa}
 ®_®147®_®483®_®648;                                    §\C{// decimal constant}§
 …
 L®_®§"\texttt{\textbackslash{x}}§®_®§\texttt{ff}§®_®§\texttt{ee}"§;     §\C{// wide character constant}§
 \end{cfa}
 The rules for placement of underscores are:
 \begin{enumerate}[topsep=5pt,itemsep=5pt,parsep=0pt]
+The rules for placement of underscores is as follows:
+\begin{enumerate}
 \item
 A sequence of underscores is disallowed, \eg ©12__34© is invalid.
 …
 \label{s:BackquoteIdentifiers}
+\CFA introduces several new keywords (see \VRef{s:CFAKeywords}) that can clash with existing C variable-names in legacy code.
+Keyword clashes are accommodated by syntactic transformations using the \CFA backquote escape-mechanism:
+\CFA accommodates keyword clashes with existing C variable-names by syntactic transformations using the \CFA backquote escape-mechanism:
 \begin{cfa}
 int ®`®otype®`® = 3;                    §\C{// make keyword an identifier}§
 double ®`®forall®`® = 3.5;
 \end{cfa}
 Existing C programs with keyword clashes can be converted by enclosing keyword identifiers in backquotes, and eventually the identifier name can be changed to a non-keyword name.
+\VRef[Figure]{f:HeaderFileInterposition} shows how clashes in existing C header-files (see~\VRef{s:StandardHeaders}) can be handled using preprocessor \newterm{interposition}: ©#include_next© and ©-I filename©.
+Several common C header-files with keyword clashes are fixed in the standard \CFA header-library, so there is a seamless programming-experience.
+\VRef[Figure]{f:InterpositionHeaderFile} shows how clashes in C header files (see~\VRef{s:StandardHeaders}) can be handled using preprocessor \newterm{interposition}: ©#include_next© and ©-I filename©:
 \begin{figure}
 \begin{cfa}
 // include file uses the CFA keyword "with".
 #if ! defined( with )                   §\C{// nesting ?}§
 #define with ®`®with®`®                 §\C{// make keyword an identifier}§
+// include file uses the CFA keyword "otype".
+#if ! defined( otype )                  §\C{// nesting ?}§
+#define otype ®`®otype®`®               §\C{// make keyword an identifier}§
 #define __CFA_BFD_H__
 #endif
 ®#include_next <bfdlink.h>              §\C{// must have internal check for multiple expansion}§
+®
 #if defined( with ) && defined( __CFA_BFD_H__ ) §\C{// reset only if set}§
 #undef with
+#endif // ! otype
+#®include_next® <bfd.h>                 §\C{// must have internal check for multiple expansion}§
+#if defined( otype ) && defined( __CFA_BFD_H__ )        §\C{// reset only if set}§
+#undef otype
 #undef __CFA_BFD_H__
 #endif
 \end{cfa}
 \caption{Header-File Interposition}
 \label{f:HeaderFileInterposition}
+#endif // otype && __CFA_BFD_H__
+\end{cfa}
+\caption{Interposition of Header File}
+\label{f:InterpositionHeaderFile}
 \end{figure}
 \section{\texorpdfstring{Labelled \LstKeywordStyle{continue} / \LstKeywordStyle{break}}{Labelled continue / break}}
+\section{Labelled Continue/Break}
 While C provides ©continue© and ©break© statements for altering control flow, both are restricted to one level of nesting for a particular control structure.
 Unfortunately, this restriction forces programmers to use \Indexc{goto} to achieve the equivalent control-flow for more than one level of nesting.
 To prevent having to switch to the ©goto©, \CFA extends the \Indexc{continue}\index{continue@\lstinline $continue$!labelled}\index{labelled!continue@©continue©} and \Indexc{break}\index{break@\lstinline $break$!labelled}\index{labelled!break@©break©} with a target label to support static multi-level exit\index{multi-level exit}\index{static multi-level exit}~\cite{Buhr85}, as in Java.
+To prevent having to switch to the ©goto©, \CFA extends the \Indexc{continue}\index{continue@\lstinline $continue$!labelled}\index{labelled!continue@©continue©} and \Indexc{break}\index{break@\lstinline $break$!labelled}\index{labelled!break@©break©} with a target label to support static multi-level exit\index{multi-level exit}\index{static multi-level exit}~\cite{Buhr85,Java}.
 For both ©continue© and ©break©, the target label must be directly associated with a ©for©, ©while© or ©do© statement;
 for ©break©, the target label can also be associated with a ©switch©, ©if© or compound (©{}©) statement.
 …
                         ®LF:® for ( ... ) {
                                 ®LW:® while ( ... ) {
                                         ... break ®LC®; ...             // terminate compound
                                         ... break ®LS®; ...             // terminate switch
                                         ... break ®LIF®; ...    // terminate if
                                         ... continue ®LF;® ...  // resume loop
                                         ... break ®LF®; ...             // terminate loop
                                         ... continue ®LW®; ...  // resume loop
                                         ... break ®LW®; ...             // terminate loop
+                                        ... break ®LC®; ...                     // terminate compound
+                                        ... break ®LS®; ...                     // terminate switch
+                                        ... break ®LIF®; ...                    // terminate if
+                                        ... continue ®LF;® ...   // resume loop
+                                        ... break ®LF®; ...                     // terminate loop
+                                        ... continue ®LW®; ...   // resume loop
+                                        ... break ®LW®; ...               // terminate loop
                                 } // while
                         } // for
                 } else {
                         ... break ®LIF®; ...                    // terminate if
+                        ... break ®LIF®; ...                                     // terminate if
                 } // if
         } // switch
 …
                           LF: for ( ;; ) {
                                   LW: while ( 1 ) {
                                                 break LC;               // terminate compound
                                                 break LS;               // terminate switch
                                                 break LIF;              // terminate if
                                                 continue LF;    // resume loop
                                                 break LF;               // terminate loop
                                                 continue LW;    // resume loop
                                                 break LW;               // terminate loop
+                                                break LC;                       // terminate compound
+                                                break LS;                       // terminate switch
+                                                break LIF;                      // terminate if
+                                                continue LF;     // resume loop
+                                                break LF;                       // terminate loop
+                                                continue LW;     // resume loop
+                                                break LW;                 // terminate loop
                                         } // while
                                 } // for
                         } else {
                                 break LIF;                               // terminate if
+                                break LIF;                                       // terminate if
                         } // if
                 } // switch
 …
 \item
 They cannot branch into a control structure.
 This restriction prevents missing declarations and/or initializations at the start of a control structure resulting in undefined behaviour.
+This restriction prevents missing initialization at the start of a control structure resulting in undefined behaviour.
 \end{itemize}
 The advantage of the labelled ©continue©/©break© is allowing static multi-level exits without having to use the ©goto© statement, and tying control flow to the target control structure rather than an arbitrary point in a program.
 Furthermore, the location of the label at the \emph{beginning} of the target control structure informs the reader (\Index{eye candy}) that complex control-flow is occurring in the body of the control structure.
+Furthermore, the location of the label at the \emph{beginning} of the target control structure informs the reader that complex control-flow is occurring in the body of the control structure.
 With ©goto©, the label is at the end of the control structure, which fails to convey this important clue early enough to the reader.
 Finally, using an explicit target for the transfer instead of an implicit target allows new constructs to be added or removed without affecting existing constructs.
 …
 \section{\texorpdfstring{\LstKeywordStyle{switch} Statement}{switch Statement}}
+\section{Switch Statement}
 C allows a number of questionable forms for the ©switch© statement:
 …
         ®// open input file
 ®} else if ( argc == 2 ) {
         ®// open input file (duplicate)
+        ®// open input file
 ®} else {
 …
 \begin{cfa}
 switch ( i ) {
   ®case 1: case 3: case 5:®     // odd values
         // odd action
+  case 1: case 3: case 5:       // odd values
+        // same action
         break;
   ®case 2: case 4: case 6:®     // even values
         // even action
+  case 2: case 4: case 6:       // even values
+        // same action
         break;
+}
 …
 However, this situation is handled in other languages without fall-through by allowing a list of case values.
 While fall-through itself is not a problem, the problem occurs when fall-through is the default, as this semantics is unintuitive to many programmers and is different from virtually all other programming languages with a ©switch© statement.
 Hence, default fall-through semantics results in a large number of programming errors as programmers often \emph{forget} the ©break© statement at the end of a ©case© clause, resulting in inadvertent fall-through.
+Hence, default fall-through semantics results in a large number of programming errors as programmers often forget the ©break© statement at the end of a ©case© clause, resulting in inadvertent fall-through.
 \item
 …
 The problem with this usage is branching into control structures, which is known to cause both comprehension and technical difficulties.
 The comprehension problem occurs from the inability to determine how control reaches a particular point due to the number of branches leading to it.
+The technical problem results from the inability to ensure declaration and initialization of variables when blocks are not entered at the beginning.
+There are no positive arguments for this kind of control flow, and therefore, there is a strong impetus to eliminate it.
+The technical problem results from the inability to ensure allocation and initialization of variables when blocks are not entered at the beginning.
+Often transferring into a block can bypass variable declaration and/or its initialization, which results in subsequent errors.
+There are virtually no positive arguments for this kind of control flow, and therefore, there is a strong impetus to eliminate it.
 Nevertheless, C does have an idiom where this capability is used, known as ``\Index*{Duff's device}''~\cite{Duff83}:
 \begin{cfa}
 …
 and there is only a medium amount of fall-through from one ©case© clause to the next, and most of these result from a list of case values executing common code, rather than a sequence of case actions that compound.
 \end{itemize}
 These observations put into perspective the \CFA changes to the ©switch©.
+These observations help to put the \CFA changes to the ©switch© into perspective.
 \begin{enumerate}
 \item
 …
   case 7:
         ...
         ®break®                                         §\C{// redundant explicit end of switch}§
+        ®break®                                         §\C{// explicit end of switch}§
   default:
         j = 3;
 …
 \end{cfa}
 Like the ©switch© statement, the ©choose© statement retains the fall-through semantics for a list of ©case© clauses;
 An implicit ©break© is applied only at the end of the \emph{statements} following a ©case© clause.
 An explicit ©fallthru© is retained because it is a C-idiom most C programmers expect, and its absence might discourage programmers from using the ©choose© statement.
+the implicit ©break© is applied only at the end of the \emph{statements} following a ©case© clause.
+The explicit ©fallthru© is retained because it is a C-idiom most C programmers expect, and its absence might discourage programmers from using the ©choose© statement.
 As well, allowing an explicit ©break© from the ©choose© is a carry over from the ©switch© statement, and expected by C programmers.
 \item
 …
 \section{\texorpdfstring{\LstKeywordStyle{case} Clause}{case Clause}}
+\section{Case Clause}
 C restricts the ©case© clause of a ©switch© statement to a single value.
 …
-\section{\texorpdfstring{\LstKeywordStyle{with} Clause / Statement}{with Clause / Statement}}
-\label{s:WithClauseStatement}
-In \Index{object-oriented} programming, there is an implicit first parameter, often names \textbf{©self©} or \textbf{©this©}, which is elided.
-\begin{C++}
-class C {
-        int i, j;
-        int mem() {              ®// implicit "this" parameter
-®               i = 1;          ®// this->i
-®               j = 3;          ®// this->j
-®       }
+}
-\end{C++}
-Since CFA is non-object-oriented, the equivalent object-oriented program looks like:
-\begin{cfa}
-struct S { int i, j; };
-int mem( S &this ) {    // explicit "this" parameter
-        ®this.®i = 1;                     // "this" is not elided
-        ®this.®j = 2;
+}
-\end{cfa}
-but it is cumbersome having to write "©this.©" many times in a member.
-\CFA provides a ©with© clause/statement (see Pascal~\cite[\S~4.F]{Pascal}) to elided the "©this.©" by opening a scope containing field identifiers, changing the qualified fields into variables and giving an opportunity for optimizing qualified references.
-\begin{cfa}
-int mem( S &this ) ®with this® {        // with clause
-        i = 1;                  ®// this.i
-®       j = 2;                  ®// this.j
-®}
-\end{cfa}
-which extends to multiple routine parameters:
-\begin{cfa}
-struct T { double m, n; };
-int mem2( S &this1, T &this2 ) ®with this1, this2® {
-        i = 1; j = 2;
-        m = 1.0; n = 2.0;
+}
-\end{cfa}
-The statement form is used within a block:
-\begin{cfa}
-int foo() {
-        struct S1 { ... } s1;
-        struct S2 { ... } s2;
-        ®with s1® {                     // with statement
-                // access fields of s1 without qualification
-                ®with s2® {  // nesting
-                        // access fields of s1 and s2 without qualification
+                }
+        }
-        ®with s1, s2® {
-                // access unambiguous fields of s1 and s2 without qualification
+        }
+}
-\end{cfa}
-When opening multiple structures, fields with the same name and type are ambiguous and must be fully qualified.
-For fields with the same name but different type, context/cast can be used to disambiguate.
-\begin{cfa}
-struct S { int i; int j; double m; } a, c;
-struct T { int i; int k; int m } b, c;
-®with a, b® {
-        j + k;                                          §\C{// unambiguous, unique names define unique types}§
-        i;                                                      §\C{// ambiguous, same name and type}§
-        a.i + b.i;                                      §\C{// unambiguous, qualification defines unique names}§
-        m;                                                      §\C{// ambiguous, same name and no context to define unique type}§
-        m = 5.0;                                        §\C{// unambiguous, same name and context defines unique type}§
-        m = 1;                                          §\C{// unambiguous, same name and context defines unique type}§
+}
-®with c® { ... }                                §\C{// ambiguous, same name and no context}§
-®with (S)c® { ... }                             §\C{// unambiguous, same name and cast defines unique type}§
-\end{cfa}
 \section{Exception Handling}
-\label{s:ExceptionHandling}
 Exception handling provides two mechanism: change of control flow from a raise to a handler, and communication from the raise to the handler.
+Transfer of control can be local, within a routine, or non-local, among routines.
+Non-local transfer can cause stack unwinding, i.e., non-local routine termination, depending on the kind of raise.
+\begin{cfa}
+exception_t E {};                               §\C{// exception type}§
+\begin{cfa}
+exception void h( int i );
+exception int h( int i, double d );
 void f(...) {
+        ... throw E{}; ...                      §\C{// termination}§
+        ... throwResume E{}; ...        §\C{// resumption}§
+}
+        ... throw h( 3 );
+        ... i = resume h( 3, 5.1 );
+}
 try {
         f(...);
 } catch( E e : §boolean-predicate§ ) {                  §\C{// termination handler}§
         // recover and continue
 } catchResume( E e : §boolean-predicate§ ) {    §\C{// resumption handler}§
         // repair and return
+} catch h( int w ) {
+        // reset
+} resume h( int p, double x ) {
+        return 17;  // recover
 } finally {
+        // always executed
+}
+\end{cfa}
+The kind of raise and handler match: ©throw© with ©catch© and ©throwResume© with ©catchResume©.
+Then the exception type must match along with any additonal predicate must be true.
+The ©catch© and ©catchResume© handlers may appear in any oder.
+However, the ©finally© clause must appear at the end of the ©try© statement.
+}
+\end{cfa}
+So the type raised would be the mangled name of the exception prototype and that name would be matched at the handler clauses by comparing the strings.
+The arguments for the call would have to be packed in a message and unpacked at handler clause and then a call made to the handler.
 …
+\section{Exponentiation Operator}
+C, \CC, and Java (and many other programming languages) have no exponentiation operator\index{exponentiation!operator}\index{operator!exponentiation}, \ie $x^y$, and instead use a routine, like \Indexc{pow}, to perform the exponentiation operation.
+\CFA extends the basic operators with the exponentiation operator ©?\?©\index{?\\?@\lstinline$?\?$} and ©?\=?©\index{?\\=?@\lstinline$?\=?$}, as in, ©x \ y© and ©x \= y©, which means $x^y$ and $x \leftarrow x^y$.
+The priority of the exponentiation operator is between the cast and multiplicative operators, so that ©w * (int)x \ (int)y * z© is parenthesized as ©((w * (((int)x) \ ((int)y))) * z)©.
+As for \Index{division}, there are exponentiation operators for integral and floating-point types, including the builtin \Index{complex} types.
+Unsigned integral exponentiation\index{exponentiation!unsigned integral} is performed with repeated multiplication (or shifting if the base is 2).
+Signed integral exponentiation\index{exponentiation!signed integral} is performed with repeated multiplication (or shifting if the base is 2), but yields a floating-point result because $b^{-e}=1/b^e$.
+Hence, it is important to designate exponent integral-constants as unsigned or signed: ©3 \ 3u© return an integral result, while ©3 \ 3© returns a floating-point result.
+Floating-point exponentiation\index{exponentiation!floating point} 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;
+64 -64 0.015625 -0.015625 18.3791736799526 0.264715-1.1922i
+\end{cfa}
+Parenthesis are necessary for the complex constants or the expresion is parsed as ©1.0f+(2.0fi \ 3.0f)+2.0fi©.
+The exponentiation operator is available for all the basic types, but for user-defined types, only the integral-computation versions are available.
+For returning an integral value, the user type ©T© must define multiplication, ©*©, and one, ©1©;
+for returning a floating-point value, an additional divide of type ©T© into a ©double© returning a ©double© (©double ?/?( double, T )©) is necessary for negative exponents.
+\section{Pointer / Reference}
+\section{Pointer/Reference}
 C provides a \newterm{pointer type};
 …
 An integer constant expression with the value 0, or such an expression cast to type ©void *©, is called a \newterm{null-pointer constant}.\footnote{
 One way to conceptualize the null pointer is that no variable is placed at this address, so the null-pointer address can be used to denote an uninitialized pointer/reference object;
+\ie the null pointer is guaranteed to compare unequal to a pointer to any object or routine.
+In general, a value with special meaning among a set of values is called a \emph{\Index{sentinel value}}, \eg ©-1© as a return code value.}
+\ie the null pointer is guaranteed to compare unequal to a pointer to any object or routine.}
 An address is \newterm{sound}, if it points to a valid memory location in scope, \ie within the program's execution-environment and has not been freed.
 Dereferencing an \newterm{unsound} address, including the null pointer, is \Index{undefined}, often resulting in a \Index{memory fault}.
 …
 \hline
 \begin{cfa}
 lda             r1,100  // load address of x
 ld               r2,(r1)          // load value of x
 lda             r3,104  // load address of y
 st               r2,(r3)          // store x into y
+lda             r1,100                  // load address of x
+ld               r2,(r1)                  // load value of x
+lda             r3,104                  // load address of y
+st               r2,(r3)                  // store x into y
 \end{cfa}
+&
 \begin{cfa}
 ld              r2,(100)        // load value of x
 st              r2,(104)        // store x into y
+ld              r2,(100)                // load value of x
+st              r2,(104)                // store x into y
 \end{cfa}
 \end{tabular}
 …
 \item
 lvalue to reference conversion: \lstinline[deletekeywords=lvalue]$lvalue-type cv1 T$ converts to ©cv2 T &©, which allows implicitly converting variables to references.
+lvalue to reference conversion: \lstinline[deletekeywords={lvalue}]@lvalue-type cv1 T@ converts to ©cv2 T &©, which allows implicitly converting variables to references.
 \begin{cfa}
 int x, &r = ®x®, f( int & p ); // lvalue variable (int) convert to reference (int &)
 …
 \begin{cfa}[belowskip=0pt]
 char store[®sepSize®];                                          §\C{// sepSize is the maximum separator size}§
 strcpy( store, sepGet( sout ) );                          §\C{// copy current separator}§
 sepSet( sout, "_" );                                            §\C{// change separator to underscore}§
+strcpy( store, sepGet( sout ) );
+sepSet( sout, "_" );
 sout | 1 | 2 | 3 | endl;
 \end{cfa}
 …
 \end{cfa}
 \begin{cfa}[belowskip=0pt]
 sepSet( sout, store );                                          §\C{// change separator back to original}§
+sepSet( sout, store );
 sout | 1 | 2 | 3 | endl;
 \end{cfa}
 …
 \Indexc{gcc} provides ©typeof© to declare a secondary variable from a primary variable.
 \CFA also relies heavily on the specification of the left-hand side of assignment for type inferencing, so in many cases it is crucial to specify the type of the left-hand side to select the correct type of the right-hand expression.
 Only for overloaded routines \emph{with the same return type} is variable type-inferencing possible.
+Only for overloaded routines with the same return type is variable type-inferencing possible.
 Finally, ©auto© presents the programming problem of tracking down a type when the type is actually needed.
 For example, given
 …
 \section{\texorpdfstring{\CFA Keywords}{Cforall Keywords}}
+\section{\CFA Keywords}
 \label{s:CFAKeywords}
-\CFA introduces the following new keywords.
 \begin{quote2}
 \begin{tabular}{lllll}
+\begin{tabular}{llll}
 \begin{tabular}{@{}l@{}}
 ©_At©                   \\
+©_AT©                   \\
 ©catch©                 \\
 ©catchResume©   \\
 ©choose©                \\
 ©coroutine©             \\
+©disable©               \\
 \end{tabular}
+&
 \begin{tabular}{@{}l@{}}
-©disable©               \\
 ©dtype©                 \\
 ©enable©                \\
 ©fallthrough©   \\
 ©fallthru©              \\
+©finally©               \\
+©forall©                \\
 \end{tabular}
+&
 \begin{tabular}{@{}l@{}}
-©finally©               \\
-©forall©                \\
 ©ftype©                 \\
 ©lvalue©                \\
 ©monitor©               \\
+©mutex©                 \\
+©one_t©                 \\
+©otype©                 \\
 \end{tabular}
+&
 \begin{tabular}{@{}l@{}}
-©mutex©                 \\
-©one_t©                 \\
-©otype©                 \\
 ©throw©                 \\
 ©throwResume©   \\
-\end{tabular}
+&
-\begin{tabular}{@{}l@{}}
 ©trait©                 \\
 ©try©                   \\
 ©ttype©                 \\
-©with©                  \\
 ©zero_t©                \\
 \end{tabular}
 …
 g( p1, p2 ) int p1, p2;                 §\C{// int g( int p1, int p2 );}§
 \end{cfa}
 \CFA continues to support K\&R routine definitions:
+\CFA supports K\&R routine definitions:
 \begin{cfa}
 f( a, b, c )                                    §\C{// default int return}§
 …
 \Celeven prescribes the following standard header-files~\cite[\S~7.1.2]{C11} and \CFA adds to this list:
 \begin{quote2}
+\begin{tabular}{@{}lllll|l@{}}
+\multicolumn{5}{c|}{C11} & \multicolumn{1}{c}{\CFA}             \\
+\lstset{deletekeywords={float}}
+\begin{tabular}{@{}llll|l@{}}
+\multicolumn{4}{c|}{C11} & \multicolumn{1}{c}{\CFA}             \\
 \hline
 \begin{tabular}{@{}l@{}}
 …
 \Indexc{errno.h}                \\
 \Indexc{fenv.h}                 \\
+\Indexc[deletekeywords=float]{float.h} \\
+\Indexc{float.h}                \\
+\Indexc{inttypes.h}             \\
+\Indexc{iso646.h}               \\
 \end{tabular}
+&
 \begin{tabular}{@{}l@{}}
-\Indexc{inttypes.h}             \\
-\Indexc{iso646.h}               \\
 \Indexc{limits.h}               \\
 \Indexc{locale.h}               \\
 \Indexc{math.h}                 \\
 \Indexc{setjmp.h}               \\
-\end{tabular}
+&
-\begin{tabular}{@{}l@{}}
 \Indexc{signal.h}               \\
 \Indexc{stdalign.h}             \\
 \Indexc{stdarg.h}               \\
 \Indexc{stdatomic.h}    \\
-\Indexc{stdbool.h}              \\
-\Indexc{stddef.h}               \\
 \end{tabular}
+&
 \begin{tabular}{@{}l@{}}
+\Indexc{stdbool.h}              \\
+\Indexc{stddef.h}               \\
 \Indexc{stdint.h}               \\
 \Indexc{stdio.h}                \\
 …
 \Indexc{wctype.h}               \\
                                                 \\
+                                                \\
+                                                \\
 \end{tabular}
+&
 …
 \Indexc{unistd.h}               \\
 \Indexc{gmp.h}                  \\
+                                                \\
+                                                \\
                                                 \\
                                                 \\
 …
 The table shows allocation routines supporting different combinations of storage-management capabilities:
 \begin{center}
 \begin{tabular}{@{}r|r|l|l|l|l@{}}
 \multicolumn{1}{c}{}&           & \multicolumn{1}{c|}{fill}     & resize        & alignment     & array \\
+\begin{tabular}{@{}lr|l|l|l|l@{}}
+                &                                       & \multicolumn{1}{c|}{fill}     & resize        & alignment     & array \\
 \hline
 C               & ©malloc©                      & no                    & no            & no            & no    \\
 …
                 & ©memalign©            & no                    & no            & yes           & no    \\
                 & ©posix_memalign©      & no                    & no            & yes           & no    \\
-\hline
 C11             & ©aligned_alloc©       & no                    & no            & yes           & no    \\
-\hline
 \CFA    & ©alloc©                       & no/copy/yes   & no/yes        & no            & yes   \\
                 & ©align_alloc©         & no/yes                & no            & yes           & yes   \\

src/CodeGen/CodeGenerator.h

-              r33218c6
+              re0a653d
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:16:21 2017
 // Update Count     : 53
+// Last Modified By : Andrew Beach
+// Last Modified On : Thu Jun  8 15:48:00 2017
+// Update Count     : 52
 //
+#pragma once
+#ifndef CODEGENV_H
+#define CODEGENV_H
 #include <list>                   // for list
 …
 } // namespace CodeGen
+#endif // CODEGENV_H
 // Local Variables: //
 // tab-width: 4 //

src/CodeGen/FixMain.h

-              r33218c6
+              re0a653d
 // Author           : Thierry Delisle
 // Created On       : Thr Jan 12 14:11:09 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:16:59 2017
 // Update Count     : 1
+// Last Modified By :
+// Last Modified On :
+// Update Count     : 0
 //
+#pragma once
+#ifndef FIXMAIN_H
+#define FIXMAIN_H
 #include <iosfwd>
 …
         };
 };
+#endif //FIXMAIN_H

src/CodeGen/FixNames.h

-              r33218c6
+              re0a653d
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:17:33 2017
 // Update Count     : 3
+// Last Modified On : Mon May 18 23:37:32 2015
+// Update Count     : 2
 //
+#pragma once
+#ifndef FIXNAMES_H
+#define FIXNAMES_H
 #include <list>  // for list
 …
 } // namespace CodeGen
+#endif // FIXNAMES_H
 // Local Variables: //
 // tab-width: 4 //

src/CodeGen/GenType.h

-              r33218c6
+              re0a653d
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:17:23 2017
 // Update Count     : 2
+// Last Modified On : Mon May 18 23:38:53 2015
+// Update Count     : 1
 //
+#pragma once
+#ifndef _GENTYPE_H
+#define _GENTYPE_H
 #include <string>  // for string
 …
 } // namespace CodeGen
+#endif // _GENTYPE_H
 // Local Variables: //
 // tab-width: 4 //

src/CodeGen/Generate.h

-              r33218c6
+              re0a653d
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:16:35 2017
 // Update Count     : 2
+// Last Modified On : Mon May 18 23:39:51 2015
+// Update Count     : 1
 //
+#pragma once
+#ifndef GENERATE_H
+#define GENERATE_H
 #include <iostream>  // for ostream
 …
 } // namespace CodeGen
+#endif // GENERATE_H
 // Local Variables: //
 // tab-width: 4 //

src/CodeGen/OperatorTable.cc

-              r33218c6
+              re0a653d
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 15 17:12:22 2017
 // Update Count     : 15
+// Last Modified On : Tue Dec 13 14:33:05 2016
+// Update Count     : 10
 //
 …
                         {       "++?",          "++",   "_operator_preincr",                    OT_PREFIXASSIGN         },
                         {       "--?",          "--",   "_operator_predecr",                    OT_PREFIXASSIGN         },
-                        {       "?\\?",         "\\",   "_operator_exponential",                OT_INFIX                        },
                         {       "?*?",          "*",    "_operator_multiply",                   OT_INFIX                        },
                         {       "?/?",          "/",    "_operator_divide",                             OT_INFIX                        },
 …
                         {       "?|?",          "|",    "_operator_bitor",                              OT_INFIX                        },
                         {       "?=?",          "=",    "_operator_assign",                             OT_INFIXASSIGN          },
-                        {       "?\\=?",        "\\=",  "_operator_expassign",                  OT_INFIXASSIGN          },
                         {       "?*=?",         "*=",   "_operator_multassign",                 OT_INFIXASSIGN          },
                         {       "?/=?",         "/=",   "_operator_divassign",                  OT_INFIXASSIGN          },

src/CodeGen/OperatorTable.h

-              r33218c6
+              re0a653d
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:17:11 2017
 // Update Count     : 6
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Jun 24 16:17:57 2015
+// Update Count     : 5
 //
+#pragma once
+#ifndef _OPERATORTABLE_H
+#define _OPERATORTABLE_H
 #include <string>
 …
 } // namespace CodeGen
+#endif // _OPERATORTABLE_H
 // Local Variables: //
 // tab-width: 4 //

src/CodeTools/DeclStats.h

-              r33218c6
+              re0a653d
 // Author           : Aaron Moss
 // Created On       : Wed Jan 31 16:40:00 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:17:56 2017
 // Update Count     : 2
+// Last Modified By : Aaron Moss
+// Last Modified On : Wed Jan 31 16:40:00 2016
+// Update Count     : 1
 //
+#pragma once
+#ifndef DECLSTATS_H
+#define DECLSTATS_H
 #include <list>  // for list
 …
 }  // namespace CodeTools
+#endif // DECLSTATS_H
 // Local Variables: //
 // tab-width: 4 //

src/CodeTools/TrackLoc.h

-              r33218c6
+              re0a653d
 // Author           : Andrew Beach
 // Created On       : Tues May 2 15:40:00 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:17:44 2017
 // Update Count     : 1
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed May 3 14:42:00 2017
+// Update Count     : 0
 //
+#pragma once
+#ifndef TRACKLOC_H
+#define TRACKLOC_H
 #include <cstddef>   // for size_t
 …
 }  // namespace CodeTools
+#endif // TRACKLOC_H
 // Local Variables: //
 // tab-width: 4 //

src/Common/CompilerError.h

-              r33218c6
+              re0a653d
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:18:07 2017
 // Update Count     : 4
+// Last Modified On : Thu Aug 18 23:41:30 2016
+// Update Count     : 3
 //
+#pragma once
+#ifndef COMPILER_ERROR_H
+#define COMPILER_ERROR_H
 #include <string>
 …
 };
+#endif // COMPILER_ERROR_H
 // Local Variables: //
 // tab-width: 4 //

src/Common/ScopedMap.h

-              r33218c6
+              re0a653d
 // Author           : Aaron B. Moss
 // Created On       : Wed Dec 2 11:37:00 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Jul 21 22:18:24 2017
+// Update Count     : 2
+//
+#pragma once
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Wed Dec 2 11:37:00 2015
+// Update Count     : 1
+//
+#ifndef _SCOPEDMAP_H
+#define _SCOPEDMAP_H
 #include <cassert>
 …
 };
+#endif // _SCOPEDMAP_H
 // Local Variables: //
 // tab-width: 4 //

src/Common/SemanticError.h

-              r33218c6
+              re0a653d
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:18:59 2017
 // Update Count     : 6
+// Last Modified On : Sat Sep 24 15:13:42 2016
+// Update Count     : 5
 //
+#pragma once
+#ifndef SEMANTICERROR_H
+#define SEMANTICERROR_H
 #include <exception>  // for exception
 …
+}
+#endif // SEMANTICERROR_H
 // Local Variables: //
 // tab-width: 4 //

src/Common/UnimplementedError.h

-              r33218c6
+              re0a653d
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:18:35 2017
 // Update Count     : 2
+// Last Modified On : Tue May 19 07:23:08 2015
+// Update Count     : 1
 //
+#pragma once
+#ifndef _UNIMPLEMENTEDERROR_H
+#define _UNIMPLEMENTEDERROR_H
 #include <string>
 …
 };
+#endif // _UNIMPLEMENTEDERROR_H
 // Local Variables: //
 // tab-width: 4 //

src/Common/UniqueName.h

-              r33218c6
+              re0a653d
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:18:45 2017
 // Update Count     : 2
+// Last Modified On : Tue May 19 07:24:20 2015
+// Update Count     : 1
 //
+#pragma once
+#ifndef UNIQUENAME_H
+#define UNIQUENAME_H
 #include <string>
 …
 };
+#endif // UNIQUENAME_H
 // Local Variables: //
 // tab-width: 4 //

src/Common/VectorMap.h

-              r33218c6
+              re0a653d
 // file "LICENCE" distributed with Cforall.
 //
 // VectorMap.h --
+// ScopedMap.h --
 //
 // Author           : Aaron B. Moss
 // Created On       : Wed Feb  1 16:55:00 2017
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Jul 21 22:19:29 2017
+// Update Count     : 2
+//
+#pragma once
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Wed Feb  1 16:55:00 2017
+// Update Count     : 1
+//
+#ifndef _VECTORMAP_H
+#define _VECTORMAP_H
 #include <iterator>
 …
+}
+#endif // _VECTORMAP_H
 // Local Variables: //
 // tab-width: 4 //

src/Common/utility.h

-              r33218c6
+              re0a653d
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Jul 21 22:19:13 2017
+// Update Count     : 33
+//
+#pragma once
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri May 5 11:03:00 2017
+// Update Count     : 32
+//
+#ifndef _UTILITY_H
+#define _UTILITY_H
 #include <cctype>
 …
+}
+#endif // _UTILITY_H
 // Local Variables: //
 // tab-width: 4 //

src/Concurrency/Keywords.cc

-              r33218c6
+              re0a653d
+//                              -*- Mode: CPP -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Last Modified By :
 // Last Modified On :
 // Update Count     : 5
+// Update Count     : 3
 //
 …
+        }
 };
-// Local Variables: //
-// mode: c //
-// tab-width: 4 //
-// End: //

src/Concurrency/Keywords.h

-              r33218c6
+              re0a653d
+//                              -*- Mode: CPP -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Last Modified By :
 // Last Modified On :
 // Update Count     : 1
+// Update Count     : 0
 //
+#pragma once
+#ifndef KEYWORDS_H
+#define KEYWORDS_H
 #include <list>  // for list
 …
 };
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
+#endif //KEYWORDS_H

src/ControlStruct/ExceptTranslate.cc

-              r33218c6
+              re0a653d
 // Created On       : Wed Jun 14 16:49:00 2017
 // Last Modified By : Andrew Beach
 // Last Modified On : Tus Jul 18 10:09:00 2017
 // Update Count     : 4
+// Last Modified On : Wed Jul 12 15:07:00 2017
+// Update Count     : 3
 //
 …
                         LinkageSpec::Cforall,
                         /*bitfieldWidth*/ NULL,
                         new BasicType( noQualifiers, BasicType::SignedInt ),
+                        new BasicType( emptyQualifiers, BasicType::SignedInt ),
                         /*init*/ NULL
                         );
 …
                         /*bitfieldWidth*/ NULL,
                         new PointerType(
                                 noQualifiers,
                                 new BasicType( noQualifiers, BasicType::SignedInt )
+                                emptyQualifiers,
+                                new BasicType( emptyQualifiers, BasicType::SignedInt )
                                 ),
                         /*init*/ NULL
 …
                         LinkageSpec::Cforall,
                         /*bitfieldWidth*/ NULL,
                         new BasicType(noQualifiers, BasicType::Bool),
+                        new BasicType(emptyQualifiers, BasicType::Bool),
                         /*init*/ NULL
                         );
 …
                         NULL,
                         new PointerType(
                                 noQualifiers,
+                                emptyQualifiers,
                                 new VoidType(
                                         noQualifiers
+                                        emptyQualifiers
                                         ),
                                 std::list<Attribute *>{new Attribute("unused")}
 …
                         LinkageSpec::Cforall,
                         NULL,
                         new BasicType( noQualifiers, BasicType::SignedInt ),
+                        new BasicType( emptyQualifiers, BasicType::SignedInt ),
                         new SingleInit( throwStmt->get_expr() )
                         );
 …
                         nullptr,
                         new StructInstType(
                                 noQualifiers,
+                                emptyQualifiers,
                                 hook_decl
                                 ),

src/ControlStruct/ExceptTranslate.h

-              r33218c6
+              re0a653d
 // Author           : Andrew Beach
 // Created On       : Tus Jun 06 10:13:00 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:19:23 2017
 // Update Count     : 4
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Jun 30 10:20:00 2017
+// Update Count     : 2
 //
+#pragma once
+#ifndef EXCEPT_TRANSLATE_H
+#define EXCEPT_TRANSLATE_H
 #include <list>
 …
 namespace ControlStruct {
         void translateEHM( std::list< Declaration *> & translationUnit );
+        // Converts exception handling structures into their underlying C code.  Translation does use the exception
+        // handling header, make sure it is visible wherever translation occurs.
+        /* Converts exception handling structures into their underlying C code.
+         * Translation does use the exception handling header, make sure it is
+         * visible wherever translation occurs.
+         */
+}
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
+#endif // EXCEPT_TRANSLATE_H

src/ControlStruct/ForExprMutator.h

-              r33218c6
+              re0a653d
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:17:08 2017
 // Update Count     : 4
+// Last Modified On : Mon Jan 25 21:22:13 2016
+// Update Count     : 3
 //
+#pragma once
+#ifndef FOR_MUTATOR_H
+#define FOR_MUTATOR_H
 #include "SynTree/Mutator.h"
 …
 } // namespace ControlStruct
+#endif // CHOOSE_MUTATOR_H
 // Local Variables: //
 // tab-width: 4 //

src/ControlStruct/LabelFixer.h

-              r33218c6
+              re0a653d
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:17:24 2017
 // Update Count     : 34
+// Last Modified On : Tue Jul 12 17:36:16 2016
+// Update Count     : 33
 //
+#pragma once
+#ifndef LABEL_FIXER_H
+#define LABEL_FIXER_H
 #include "Common/utility.h"
 …
 } // namespace ControlStruct
+#endif // LABEL_FIXER_H
 // Local Variables: //
 // tab-width: 4 //

src/ControlStruct/LabelGenerator.h

-              r33218c6
+              re0a653d
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:20:14 2017
 // Update Count     : 6
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Jun 03 14:16:26 2015
+// Update Count     : 5
 //
+#pragma once
+#ifndef LABEL_GENERATOR_H
+#define LABEL_GENERATOR_H
 #include "SynTree/SynTree.h"
 …
 } // namespace ControlStruct
+#endif // LABEL_GENERATOR_H
 // Local Variables: //
 // tab-width: 4 //

src/ControlStruct/MLEMutator.h

-              r33218c6
+              re0a653d
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:19:59 2017
 // Update Count     : 35
+// Last Modified On : Tue Jul 12 17:37:01 2016
+// Update Count     : 34
 //
+#pragma once
+#ifndef MLE_MUTATOR_H
+#define MLE_MUTATOR_H
 #include <map>
 …
 } // namespace ControlStruct
+#endif // MLE_MUTATOR_H
 // Local Variables: //
 // tab-width: 4 //

src/ControlStruct/Mutate.h

-              r33218c6
+              re0a653d
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:17:59 2017
 // Update Count     : 3
+// Last Modified On : Tue May 19 15:31:20 2015
+// Update Count     : 2
 //
+#pragma once
+#ifndef CTRLS_MUTATE_H
+#define CTRLS_MUTATE_H
 #include <list>
 …
 } // namespace ControlStruct
+#endif // CTRLS_MUTATE_H
 // Local Variables: //
 // tab-width: 4 //

src/GenPoly/Box.cc

-              r33218c6
+              re0a653d
                 };
                 /// Replaces initialization of polymorphic values with alloca, declaration of dtype/ftype with appropriate void expression, sizeof expressions of polymorphic types with the proper variable, and strips fields from generic struct declarations.
+                /// Replaces initialization of polymorphic values with alloca, declaration of dtype/ftype with appropriate void expression, and sizeof expressions of polymorphic types with the proper variable
                 class Pass3 final : public PolyMutator {
                   public:
 …
                         using PolyMutator::mutate;
                         virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
-                        virtual Declaration *mutate( StructDecl *structDecl ) override;
-                        virtual Declaration *mutate( UnionDecl *unionDecl ) override;
                         virtual ObjectDecl *mutate( ObjectDecl *objectDecl ) override;
                         virtual TypedefDecl *mutate( TypedefDecl *objectDecl ) override;
 …
+                }
-                /// Strips the members from a generic aggregate
-                void stripGenericMembers(AggregateDecl* decl) {
-                        if ( ! decl->get_parameters().empty() ) decl->get_members().clear();
+                }
-                Declaration *Pass3::mutate( StructDecl *structDecl ) {
-                        stripGenericMembers( structDecl );
-                        return structDecl;
+                }
-                Declaration *Pass3::mutate( UnionDecl *unionDecl ) {
-                        stripGenericMembers( unionDecl );
-                        return unionDecl;
+                }
                 TypeDecl * Pass3::mutate( TypeDecl *typeDecl ) {
 //   Initializer *init = 0;

src/GenPoly/Box.h

-              r33218c6
+              re0a653d
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:23:52 2017
 // Update Count     : 6
+// Last Modified On : Thu Nov 19 17:24:01 2015
+// Update Count     : 5
 //
+#pragma once
+#ifndef _BOX_H
+#define _BOX_H
 #include <list>
 …
 } // namespace GenPoly
+#endif // _BOX_H
 // Local Variables: //
 // tab-width: 4 //

src/GenPoly/CopyParams.h

-              r33218c6
+              re0a653d
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:23:09 2017
 // Update Count     : 2
+// Last Modified On : Tue May 19 07:34:25 2015
+// Update Count     : 1
 //
+#pragma once
+#ifndef _COPYPARAMS_H
+#define _COPYPARAMS_H
 #include "SynTree/SynTree.h"
 …
 } // namespace GenPoly
+#endif // _COPYPARAMS_H
 // Local Variables: //
 // tab-width: 4 //

src/GenPoly/DeclMutator.h

-              r33218c6
+              re0a653d
 // Created On       : Fri Nov 27 14:44:00 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:21:12 2017
 // Update Count     : 4
+// Last Modified On : Tue Jul 12 17:39:01 2016
+// Update Count     : 2
 //
+#pragma once
+#ifndef _DECLMUTATOR_H
+#define _DECLMUTATOR_H
 #include <list>
 …
         /// Mutates a list of declarations, providing a means of adding new declarations into the list
         class DeclMutator : public Mutator {
           public:
+        public:
                 typedef Mutator Parent;
 …
                 /// Called on exit from a scope; overriders should call this as a super-class call
                 virtual void doEndScope();
           protected:
+        protected:
                 /// Mutate a statement that forms its own scope
                 Statement* mutateStatement( Statement *stmt );
 …
                 /// Add a declaration to the list to be added after the current position
                 void addDeclarationAfter( Declaration* decl );
           private:
+        private:
                 /// A stack of declarations to add before the current declaration or statement
                 std::vector< std::list< Declaration* > > declsToAdd;
 …
 } // namespace
+#endif // _DECLMUTATOR_H
 // Local Variables: //
 // tab-width: 4 //

src/GenPoly/ErasableScopedMap.h

-              r33218c6
+              re0a653d
 // Author           : Aaron B. Moss
 // Created On       : Wed Dec 2 11:37:00 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat Jul 22 09:23:24 2017
+// Update Count     : 2
+//
+#pragma once
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Wed Dec 2 11:37:00 2015
+// Update Count     : 1
+//
+#ifndef _ERASABLESCOPEDMAP_H
+#define _ERASABLESCOPEDMAP_H
 #include <cassert>
 …
 } // namespace GenPoly
+#endif // _ERASABLESCOPEDMAP_H
 // Local Variables: //
 // tab-width: 4 //

src/GenPoly/FindFunction.h

-              r33218c6
+              re0a653d
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:23:36 2017
 // Update Count     : 2
+// Last Modified On : Tue May 19 07:36:35 2015
+// Update Count     : 1
 //
+#pragma once
+#ifndef FINDFUNCTION_H
+#define FINDFUNCTION_H
 #include "SynTree/SynTree.h"
 …
 } // namespace GenPoly
+#endif // FINDFUNCTION_H
 // Local Variables: //
 // tab-width: 4 //

src/GenPoly/GenPoly.h

-              r33218c6
+              re0a653d
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:22:57 2017
 // Update Count     : 7
+// Last Modified By : Rob Schluntz
+// Last Modified On : Tue Nov 24 15:24:38 2015
+// Update Count     : 6
 //
+#pragma once
+#ifndef GENPOLY_H
+#define GENPOLY_H
 #include <string>
 …
 } // namespace GenPoly
+#endif // GENPOLY_H
 // Local Variables: //
 // tab-width: 4 //

src/GenPoly/InstantiateGeneric.h

-              r33218c6
+              re0a653d
 // Author           : Aaron B. Moss
 // Created On       : Thu Aug 04 18:33:00 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:22:42 2017
 // Update Count     : 2
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Thu Aug 04 18:33:00 2016
+// Update Count     : 1
 //
+#pragma once
+#ifndef _INSTANTIATEGENERIC_H
+#define _INSTANTIATEGENERIC_H
 #include "SynTree/SynTree.h"
 …
 } // namespace GenPoly
+#endif // _INSTANTIATEGENERIC_H
 // Local Variables: //
 // tab-width: 4 //

src/GenPoly/Lvalue.h

-              r33218c6
+              re0a653d
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:21:59 2017
 // Update Count     : 2
+// Last Modified On : Tue May 19 07:42:09 2015
+// Update Count     : 1
 //
+#pragma once
+#ifndef _LVALUE_H
+#define _LVALUE_H
 #include <list>
 …
 } // namespace GenPoly
+#endif // _LVALUE_H
 // Local Variables: //
 // tab-width: 4 //

src/GenPoly/PolyMutator.h

-              r33218c6
+              re0a653d
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:20:31 2017
 // Update Count     : 7
+// Last Modified On : Tue Jul 12 17:39:41 2016
+// Update Count     : 6
 //
+#pragma once
+#ifndef _POLYMUTATOR_H
+#define _POLYMUTATOR_H
 #include <map>
 …
 } // namespace
+#endif // _POLYMUTATOR_H
 // Local Variables: //
 // tab-width: 4 //

src/GenPoly/ScopedSet.h

-              r33218c6
+              re0a653d
 // Author           : Aaron B. Moss
 // Created On       : Thu Dec 3 11:51:00 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat Jul 22 09:22:17 2017
+// Update Count     : 2
+//
+#pragma once
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Thu Dec 3 11:51:00 2015
+// Update Count     : 1
+//
+#ifndef _SCOPEDSET_H
+#define _SCOPEDSET_H
 #include <iterator>
 …
 } // namespace GenPoly
+#endif // _SCOPEDSET_H
 // Local Variables: //
 // tab-width: 4 //

src/GenPoly/ScrubTyVars.h

-              r33218c6
+              re0a653d
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:21:47 2017
 // Update Count     : 2
+// Last Modified On : Tue May 19 07:48:14 2015
+// Update Count     : 1
 //
+#pragma once
+#ifndef _SCRUBTYVARS_H
+#define _SCRUBTYVARS_H
 #include <string>
 …
 } // namespace GenPoly
+#endif // _SCRUBTYVARS_H
 // Local Variables: //
 // tab-width: 4 //

src/GenPoly/Specialize.h

-              r33218c6
+              re0a653d
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:22:31 2017
 // Update Count     : 2
+// Last Modified On : Tue May 19 07:53:58 2015
+// Update Count     : 1
 //
+#pragma once
+#ifndef _SPECIALIZE_H
+#define _SPECIALIZE_H
 #include <list>
 …
 } // namespace GenPoly
+#endif // _SPECIALIZE_H
 // Local Variables: //
 // tab-width: 4 //

src/InitTweak/FixGlobalInit.h

-              r33218c6
+              re0a653d
 // Author           : Rob Schluntz
 // Created On       : Mon May 04 15:14:56 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:30:54 2017
 // Update Count     : 3
+// Last Modified By : Rob Schluntz
+// Last Modified On : Fri May 06 16:07:47 2016
+// Update Count     : 2
 //
+#pragma once
+#ifndef FIX_GLOBAL_INIT_H
+#define FIX_GLOBAL_INIT_H
 #include <string>
 …
 } // namespace
+#endif // GENPOLY_POLYMUTATOR_H
 // Local Variables: //
 // tab-width: 4 //

src/InitTweak/FixInit.h

-              r33218c6
+              re0a653d
 // Author           : Rob Schluntz
 // Created On       : Wed Jan 13 16:29:30 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:31:06 2017
 // Update Count     : 6
+// Last Modified By : Rob Schluntz
+// Last Modified On : Fri May 13 11:27:52 2016
+// Update Count     : 5
 //
+#pragma once
+#ifndef FIX_INIT_H
+#define FIX_INIT_H
 #include <string>
 …
 } // namespace
+#endif // GENPOLY_POLYMUTATOR_H
 // Local Variables: //
 // tab-width: 4 //

src/InitTweak/GenInit.h

-              r33218c6
+              re0a653d
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:31:19 2017
 // Update Count     : 4
+// Last Modified By : Rob Schluntz
+// Last Modified On : Fri May 13 11:27:19 2016
+// Update Count     : 3
 //
+#pragma once
+#ifndef GEN_INIT_H
+#define GEN_INIT_H
 #include <string>
 …
 } // namespace
+#endif // INITTWEAK_GENINIT_H
 // Local Variables: //
 // tab-width: 4 //

src/InitTweak/InitTweak.h

-              r33218c6
+              re0a653d
 // Author           : Rob Schluntz
 // Created On       : Fri May 13 11:26:36 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:30:33 2017
 // Update Count     : 4
+// Last Modified By : Rob Schluntz
+// Last Modified On : Fri May 13 11:35:36 2016
+// Update Count     : 3
 //
+#pragma once
+#ifndef INIT_TWEAK_H
+#define INIT_TWEAK_H
 #include <string>
 …
 } // namespace
+#endif // INITTWEAK_GENINIT_H
 // Local Variables: //
 // tab-width: 4 //

src/MakeLibCfa.h

-              r33218c6
+              re0a653d
 // Created On       : Sat May 16 10:42:14 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:31:35 2017
 // Update Count     : 2
+// Last Modified On : Sat May 16 10:43:29 2015
+// Update Count     : 1
 //
+#pragma once
+#ifndef LIBCFA_MAKELIBCFA_H
+#define LIBCFA_MAKELIBCFA_H
 #include <list>  // for list
 …
 } // namespace LibCfa
+#endif // LIBCFA_MAKELIBCFA_H
 // Local Variables: //
 // tab-width: 4 //

src/Makefile.in

-              r33218c6
+              re0a653d
         SymTab/driver_cfa_cpp-TypeEquality.$(OBJEXT) \
         SymTab/driver_cfa_cpp-Autogen.$(OBJEXT) \
-        SymTab/driver_cfa_cpp-TreeStruct.$(OBJEXT) \
         SynTree/driver_cfa_cpp-Type.$(OBJEXT) \
         SynTree/driver_cfa_cpp-VoidType.$(OBJEXT) \
 …
         SymTab/Indexer.cc SymTab/Mangler.cc SymTab/Validate.cc \
         SymTab/FixFunction.cc SymTab/ImplementationType.cc \
         SymTab/TypeEquality.cc SymTab/Autogen.cc SymTab/TreeStruct.cc \
         SynTree/Type.cc SynTree/VoidType.cc SynTree/BasicType.cc \
+        SymTab/TypeEquality.cc SymTab/Autogen.cc SynTree/Type.cc \
+        SynTree/VoidType.cc SynTree/BasicType.cc \
         SynTree/PointerType.cc SynTree/ArrayType.cc \
         SynTree/FunctionType.cc SynTree/ReferenceToType.cc \
 …
 SymTab/driver_cfa_cpp-Autogen.$(OBJEXT): SymTab/$(am__dirstamp) \
         SymTab/$(DEPDIR)/$(am__dirstamp)
-SymTab/driver_cfa_cpp-TreeStruct.$(OBJEXT): SymTab/$(am__dirstamp) \
-        SymTab/$(DEPDIR)/$(am__dirstamp)
 SynTree/$(am__dirstamp):
         @$(MKDIR_P) SynTree
 …
 @AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-Indexer.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-Mangler.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-TreeStruct.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-TypeEquality.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-Validate.Po@am__quote@
 …
 @AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SymTab/driver_cfa_cpp-Autogen.obj `if test -f 'SymTab/Autogen.cc'; then $(CYGPATH_W) 'SymTab/Autogen.cc'; else $(CYGPATH_W) '$(srcdir)/SymTab/Autogen.cc'; fi`
-SymTab/driver_cfa_cpp-TreeStruct.o: SymTab/TreeStruct.cc
-@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SymTab/driver_cfa_cpp-TreeStruct.o -MD -MP -MF SymTab/$(DEPDIR)/driver_cfa_cpp-TreeStruct.Tpo -c -o SymTab/driver_cfa_cpp-TreeStruct.o `test -f 'SymTab/TreeStruct.cc' || echo '$(srcdir)/'`SymTab/TreeStruct.cc
-@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SymTab/$(DEPDIR)/driver_cfa_cpp-TreeStruct.Tpo SymTab/$(DEPDIR)/driver_cfa_cpp-TreeStruct.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SymTab/TreeStruct.cc' object='SymTab/driver_cfa_cpp-TreeStruct.o' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SymTab/driver_cfa_cpp-TreeStruct.o `test -f 'SymTab/TreeStruct.cc' || echo '$(srcdir)/'`SymTab/TreeStruct.cc
-SymTab/driver_cfa_cpp-TreeStruct.obj: SymTab/TreeStruct.cc
-@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SymTab/driver_cfa_cpp-TreeStruct.obj -MD -MP -MF SymTab/$(DEPDIR)/driver_cfa_cpp-TreeStruct.Tpo -c -o SymTab/driver_cfa_cpp-TreeStruct.obj `if test -f 'SymTab/TreeStruct.cc'; then $(CYGPATH_W) 'SymTab/TreeStruct.cc'; else $(CYGPATH_W) '$(srcdir)/SymTab/TreeStruct.cc'; fi`
-@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SymTab/$(DEPDIR)/driver_cfa_cpp-TreeStruct.Tpo SymTab/$(DEPDIR)/driver_cfa_cpp-TreeStruct.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SymTab/TreeStruct.cc' object='SymTab/driver_cfa_cpp-TreeStruct.obj' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SymTab/driver_cfa_cpp-TreeStruct.obj `if test -f 'SymTab/TreeStruct.cc'; then $(CYGPATH_W) 'SymTab/TreeStruct.cc'; else $(CYGPATH_W) '$(srcdir)/SymTab/TreeStruct.cc'; fi`
 SynTree/driver_cfa_cpp-Type.o: SynTree/Type.cc

src/Parser/DeclarationNode.cc

-              r33218c6
+              re0a653d
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Fri Jul 14 16:55:00 2017
 // Update Count     : 1020
+// Last Modified On : Wed Jun 28 15:27:00 2017
+// Update Count     : 1019
 //
 …
         newnode->type->aggregate.fields = fields;
         newnode->type->aggregate.body = body;
-        newnode->type->aggregate.tagged = false;
-        newnode->type->aggregate.parent = nullptr;
         return newnode;
 } // DeclarationNode::newAggregate
 …
         return newnode;
 } // DeclarationNode::newEnumConstant
-DeclarationNode * DeclarationNode::newTreeStruct( Aggregate kind, const string * name, const string * parent, ExpressionNode * actuals, DeclarationNode * fields, bool body ) {
-        assert( name );
-        DeclarationNode * newnode = new DeclarationNode;
-        newnode->type = new TypeData( TypeData::Aggregate );
-        newnode->type->aggregate.kind = kind;
-        newnode->type->aggregate.name = name;
-        newnode->type->aggregate.actuals = actuals;
-        newnode->type->aggregate.fields = fields;
-        newnode->type->aggregate.body = body;
-        newnode->type->aggregate.tagged = true;
-        newnode->type->aggregate.parent = parent;
-        return newnode;
-} // DeclarationNode::newTreeStruct
 DeclarationNode * DeclarationNode::newName( string * name ) {

src/Parser/ExpressionNode.cc

-              r33218c6
+              re0a653d
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 13:17:07 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Tus Jul 18 10:08:00 2017
 // Update Count     : 550
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Wed Jun 28 21:08:15 2017
+// Update Count     : 542
 //
 …
 // type.
 Type::Qualifiers noQualifiers;                          // no qualifiers on constants
+Type::Qualifiers emptyQualifiers;                               // no qualifiers on constants
 static inline bool checkU( char c ) { return c == 'u' || c == 'U'; }
 …
         } // if
         Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[Unsigned][size] ), str, v ) );
+        Expression * ret = new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[Unsigned][size] ), str, v ) );
         delete &str;                                                                            // created by lex
         return ret;
 …
         } // if
         Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[complx][size] ), str, v ) );
+        Expression * ret = new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[complx][size] ), str, v ) );
         delete &str;                                                                            // created by lex
         return ret;
 …
 Expression *build_constantChar( const std::string & str ) {
         Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, BasicType::Char ), str, (unsigned long long int)(unsigned char)str[1] ) );
+        Expression * ret = new ConstantExpr( Constant( new BasicType( emptyQualifiers, BasicType::Char ), str, (unsigned long long int)(unsigned char)str[1] ) );
         delete &str;                                                                            // created by lex
         return ret;
 …
 ConstantExpr *build_constantStr( const std::string & str ) {
         // string should probably be a primitive type
         ArrayType *at = new ArrayType( noQualifiers, new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char ),
+        ArrayType *at = new ArrayType( emptyQualifiers, new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char ),
                                                                    new ConstantExpr( Constant::from_ulong( str.size() + 1 - 2 ) ),  // +1 for '\0' and -2 for '"'
                                                                    false, false );
 …
 Expression *build_constantZeroOne( const std::string & str ) {
         Expression * ret = new ConstantExpr( Constant( str == "0" ? (Type *)new ZeroType( noQualifiers ) : (Type*)new OneType( noQualifiers ), str,
+        Expression * ret = new ConstantExpr( Constant( str == "0" ? (Type *)new ZeroType( emptyQualifiers ) : (Type*)new OneType( emptyQualifiers ), str,
                                                                                                    str == "0" ? (unsigned long long int)0 : (unsigned long long int)1 ) );
         delete &str;                                                                            // created by lex
 …
+}
-// Must harmonize with OperKinds.
 static const char *OperName[] = {
         // diadic
         "SizeOf", "AlignOf", "OffsetOf", "?+?", "?-?", "?\\?", "?*?", "?/?", "?%?", "||", "&&",
+        "SizeOf", "AlignOf", "OffsetOf", "?+?", "?-?", "?*?", "?/?", "?%?", "||", "&&",
         "?|?", "?&?", "?^?", "Cast", "?<<?", "?>>?", "?<?", "?>?", "?<=?", "?>=?", "?==?", "?!=?",
         "?=?", "?@=?", "?\\=?", "?*=?", "?/=?", "?%=?", "?+=?", "?-=?", "?<<=?", "?>>=?", "?&=?", "?^=?", "?|=?",
+        "?=?", "?@=?", "?*=?", "?/=?", "?%=?", "?+=?", "?-=?", "?<<=?", "?>>=?", "?&=?", "?^=?", "?|=?",
         "?[?]", "...",
         // monadic

src/Parser/LinkageSpec.h

-              r33218c6
+              re0a653d
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 13:24:28 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:32:16 2017
 // Update Count     : 14
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Jul  7 11:03:00 2017
+// Update Count     : 13
 //
+#pragma once
+#ifndef LINKAGESPEC_H
+#define LINKAGESPEC_H
 #include <string>
 …
 };
+#endif // LINKAGESPEC_H
 // Local Variables: //
 // tab-width: 4 //

src/Parser/ParseNode.h

-              r33218c6
+              re0a653d
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:32:30 2017
 // Update Count     : 786
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Jun 12 13:00:00 2017
+// Update Count     : 779
 //
+#pragma once
+#ifndef PARSENODE_H
+#define PARSENODE_H
 #include <string>
 …
 };
-// Must harmonize with OperName.
 enum class OperKinds {
         // diadic
         SizeOf, AlignOf, OffsetOf, Plus, Minus, Exp, Mul, Div, Mod, Or, And,
+        SizeOf, AlignOf, OffsetOf, Plus, Minus, Mul, Div, Mod, Or, And,
         BitOr, BitAnd, Xor, Cast, LShift, RShift, LThan, GThan, LEThan, GEThan, Eq, Neq,
         Assign, AtAssn, ExpAssn, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, ERAssn, OrAssn,
+        Assign, AtAssn, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, ERAssn, OrAssn,
         Index, Range,
         // monadic
 …
         static DeclarationNode * newAsmStmt( StatementNode * stmt ); // gcc external asm statement
-        // Perhaps this would best fold into newAggragate.
-        static DeclarationNode * newTreeStruct( Aggregate kind, const std::string * name, const std::string * parent, ExpressionNode * actuals, DeclarationNode * fields, bool body );
         DeclarationNode();
         ~DeclarationNode();
 …
         static UniqueName anonymous;
-        // Temp to test TreeStruct
-        const std::string * parent_name;
 }; // DeclarationNode
 …
 std::ostream & operator<<( std::ostream & out, const ParseNode * node );
+#endif // PARSENODE_H
 // Local Variables: //
 // tab-width: 4 //

src/Parser/ParserTypes.h

-              r33218c6
+              re0a653d
 // Created On       : Sat Sep 22 08:58:10 2001
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:33:28 2017
 // Update Count     : 350
+// Last Modified On : Wed Jun 28 22:10:17 2017
+// Update Count     : 349
 //
+#pragma once
+#ifndef PARSER_HH
+#define PARSER_HH
 int yylex();
 …
 }; // Token
+#endif // PARSER_HH
 // Local Variables: //
 // tab-width: 4 //

src/Parser/TypeData.cc

-              r33218c6
+              re0a653d
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Tus Jul 18 10:10:00 2017
 // Update Count     : 566
+// Last Modified On : Wed Jun 28 15:28:00 2017
+// Update Count     : 564
 //
 …
                 aggregate.fields = nullptr;
                 aggregate.body = false;
-                aggregate.tagged = false;
-                aggregate.parent = nullptr;
                 break;
           case AggregateInst:
 …
                 delete aggregate.actuals;
                 delete aggregate.fields;
-                delete aggregate.parent;
                 // delete aggregate;
                 break;
 …
                 newtype->aggregate.kind = aggregate.kind;
                 newtype->aggregate.body = aggregate.body;
-                newtype->aggregate.tagged = aggregate.tagged;
-                newtype->aggregate.parent = aggregate.parent ? new string( *aggregate.parent ) : nullptr;
                 break;
           case AggregateInst:
 …
           case TypeData::Builtin:
                 if(td->builtintype == DeclarationNode::Zero) {
                         return new ZeroType( noQualifiers );
+                        return new ZeroType( emptyQualifiers );
+                }
                 else if(td->builtintype == DeclarationNode::One) {
                         return new OneType( noQualifiers );
+                        return new OneType( emptyQualifiers );
+                }
                 else {
 …
         switch ( td->aggregate.kind ) {
           case DeclarationNode::Struct:
-                if ( td->aggregate.tagged ) {
-                        at = new StructDecl( *td->aggregate.name, td->aggregate.parent, attributes, linkage );
-                        buildForall( td->aggregate.params, at->get_parameters() );
-                        break;
+                }
           case DeclarationNode::Coroutine:
           case DeclarationNode::Monitor:

src/Parser/TypeData.h

-              r33218c6
+              re0a653d
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 15:18:36 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:32:47 2017
 // Update Count     : 188
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Jun 28 15:29:00 2017
+// Update Count     : 186
 //
+#pragma once
+#ifndef TYPEDATA_H
+#define TYPEDATA_H
 #include "ParseNode.h"
 …
                 DeclarationNode * fields;
                 bool body;
-                bool tagged;
-                const std::string * parent;
         };
 …
 void buildKRFunction( const TypeData::Function_t & function );
+#endif // TYPEDATA_H
 // Local Variables: //
 // tab-width: 4 //

src/Parser/TypedefTable.h

-              r33218c6
+              re0a653d
 // Created On       : Sat May 16 15:24:36 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:33:14 2017
 // Update Count     : 34
+// Last Modified On : Wed Jun 28 21:56:34 2017
+// Update Count     : 33
 //
+#pragma once
+#ifndef TYPEDEFTABLE_H
+#define TYPEDEFTABLE_H
 #include <map>
 …
 };
+#endif // TYPEDEFTABLE_H
 // Local Variables: //
 // tab-width: 4 //

src/Parser/lex.ll

-              r33218c6
+              re0a653d
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
  * Last Modified On : Mon Jul 24 08:27:23 2017
  * Update Count     : 545
+ * Last Modified On : Tue Jul 11 21:30:51 2017
+ * Update Count     : 534
  */
 …
 op_unary {op_unary_only}|{op_unary_binary}|{op_unary_pre_post}
 op_binary_only "/"|"%"|"\\"|"^"|"&"|"|"|"<"|">"|"="|"=="|"!="|"<<"|">>"|"<="|">="|"+="|"-="|"*="|"/="|"%="|"\\="|"&="|"|="|"^="|"<<="|">>="
+op_binary_only "/"|"%"|"^"|"&"|"|"|"<"|">"|"="|"=="|"!="|"<<"|">>"|"<="|">="|"+="|"-="|"*="|"/="|"%="|"&="|"|="|"^="|"<<="|">>="
 op_binary_over {op_unary_binary}|{op_binary_only}
                                 // op_binary_not_over "?"|"->"|"."|"&&"|"||"|"@="
 …
 %%
                                 /* line directives */
+                                   /* line directives */
 ^{h_white}*"#"{h_white}*[0-9]+{h_white}*["][^"\n]+["].*"\n" {
         /* " stop highlighting */
 …
 int                             { KEYWORD_RETURN(INT); }
 __int128                { KEYWORD_RETURN(INT); }                                // GCC
-__int128_t              { KEYWORD_RETURN(INT); }                                // GCC
 __label__               { KEYWORD_RETURN(LABEL); }                              // GCC
 long                    { KEYWORD_RETURN(LONG); }
 …
 __typeof                { KEYWORD_RETURN(TYPEOF); }                             // GCC
 __typeof__              { KEYWORD_RETURN(TYPEOF); }                             // GCC
-__uint128_t             { KEYWORD_RETURN(INT); }                                // GCC
 union                   { KEYWORD_RETURN(UNION); }
 unsigned                { KEYWORD_RETURN(UNSIGNED); }
 __builtin_va_list { KEYWORD_RETURN(VALIST); }                   // GCC
-virtual                 { KEYWORD_RETURN(VIRTUAL); }                    // CFA
 void                    { KEYWORD_RETURN(VOID); }
 volatile                { KEYWORD_RETURN(VOLATILE); }
 …
 __volatile__    { KEYWORD_RETURN(VOLATILE); }                   // GCC
 while                   { KEYWORD_RETURN(WHILE); }
-with                    { KEYWORD_RETURN(WITH); }                               // CFA
 zero_t                  { NUMERIC_RETURN(ZERO_T); }                             // CFA
 …
 "-"                             { ASCIIOP_RETURN(); }
 "*"                             { ASCIIOP_RETURN(); }
-"\\"                    { ASCIIOP_RETURN(); }                                   // CFA, exponentiation
 "/"                             { ASCIIOP_RETURN(); }
 "%"                             { ASCIIOP_RETURN(); }
 …
 "+="                    { NAMEDOP_RETURN(PLUSassign); }
 "-="                    { NAMEDOP_RETURN(MINUSassign); }
-"\\="                   { NAMEDOP_RETURN(EXPassign); }                  // CFA, exponentiation
 "*="                    { NAMEDOP_RETURN(MULTassign); }
 "/="                    { NAMEDOP_RETURN(DIVassign); }

src/Parser/parser.yy

-              r33218c6
+              re0a653d
 // Author           : Peter A. Buhr
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Jul 24 09:01:14 2017
 // Update Count     : 2463
+// Last Modified By : Andrew Beach
+// Last Modified On : Tus Jul 11 13:39:00 2017
+// Update Count     : 2416
 //
 …
 %token RESTRICT                                                                                 // C99
 %token ATOMIC                                                                                   // C11
+%token FORALL LVALUE MUTEX VIRTUAL                                              // CFA
+%token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED
+%token FORALL LVALUE MUTEX                                                              // CFA
+%token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED ZERO_T ONE_T
+%token VALIST                                                                                   // GCC
 %token BOOL COMPLEX IMAGINARY                                                   // C99
-%token ZERO_T ONE_T                                                                             // CFA
-%token VALIST                                                                                   // GCC
 %token TYPEOF LABEL                                                                             // GCC
 %token ENUM STRUCT UNION
 …
 %token ATTRIBUTE EXTENSION                                                              // GCC
 %token IF ELSE SWITCH CASE DEFAULT DO WHILE FOR BREAK CONTINUE GOTO RETURN
 %token CHOOSE DISABLE ENABLE FALLTHRU TRY CATCH CATCHRESUME FINALLY THROW THROWRESUME AT WITH   // CFA
+%token CHOOSE DISABLE ENABLE FALLTHRU TRY CATCH CATCHRESUME FINALLY THROW THROWRESUME AT        // CFA
 %token ASM                                                                                              // C99, extension ISO/IEC 9899:1999 Section J.5.10(1)
 %token ALIGNAS ALIGNOF GENERIC STATICASSERT                             // C11
 …
 %token ELLIPSIS                                                                                 // ...
 %token EXPassign        MULTassign      DIVassign       MODassign       // \=   *=      /=      %=
+%token MULTassign       DIVassign       MODassign                               // *=   /=      %=/
 %token PLUSassign       MINUSassign                                                     // +=   -=
 %token LSassign         RSassign                                                        // <<=  >>=
 …
 %type<op> ptrref_operator                               unary_operator                          assignment_operator
 %type<en> primary_expression                    postfix_expression                      unary_expression
+%type<en> cast_expression                               exponential_expression          multiplicative_expression       additive_expression
+%type<en> shift_expression                              relational_expression           equality_expression
+%type<en> AND_expression                                exclusive_OR_expression         inclusive_OR_expression
+%type<en> logical_AND_expression                logical_OR_expression
+%type<en> conditional_expression                constant_expression                     assignment_expression           assignment_expression_opt
+%type<en> cast_expression                               multiplicative_expression       additive_expression                     shift_expression
+%type<en> relational_expression                 equality_expression                     AND_expression                          exclusive_OR_expression
+%type<en> inclusive_OR_expression               logical_AND_expression          logical_OR_expression           conditional_expression
+%type<en> constant_expression                   assignment_expression           assignment_expression_opt
 %type<en> comma_expression                              comma_expression_opt
 %type<en> argument_expression_list              argument_expression                     default_initialize_opt
+%type<en> argument_expression_list              argument_expression                     assignment_opt
 %type<fctl> for_control_expression
 %type<en> subrange
 …
 // statements
 %type<sn> labeled_statement                             compound_statement                      expression_statement            selection_statement
+%type<sn> iteration_statement                   jump_statement
+%type<sn> with_statement                                exception_statement                     asm_statement
+%type<sn> iteration_statement                   jump_statement                          exception_statement                     asm_statement
 %type<sn> fall_through_opt                              fall_through
 %type<sn> statement                                             statement_list
 %type<sn> block_item_list                               block_item
 %type<sn> with_clause_opt
+%type<sn> case_clause
 %type<en> case_value
 %type<sn> case_clause                                   case_value_list                         case_label                                      case_label_list
+%type<sn> case_value_list                               case_label                                      case_label_list
 %type<sn> switch_clause_list_opt                switch_clause_list                      choose_clause_list_opt          choose_clause_list
 %type<sn> /* handler_list */                    handler_clause                          finally_clause
 …
         | '(' type_no_function ')' cast_expression
                 { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
-                // VIRTUAL cannot be opt because of look ahead issues
-        | '(' VIRTUAL ')' cast_expression
-                { $$ = new ExpressionNode( build_cast( nullptr, $4 ) ); }
-        | '(' VIRTUAL type_no_function ')' cast_expression
-                { $$ = new ExpressionNode( build_cast( $3, $5 ) ); }
 //      | '(' type_no_function ')' tuple
 //              { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
+        ;
 exponential_expression:
+multiplicative_expression:
         cast_expression
+        | exponential_expression '\\' cast_expression
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::Exp, $1, $3 ) ); }
+        ;
+multiplicative_expression:
+        exponential_expression
+        | multiplicative_expression '*' exponential_expression
+        | multiplicative_expression '*' cast_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Mul, $1, $3 ) ); }
         | multiplicative_expression '/' exponential_expression
+        | multiplicative_expression '/' cast_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Div, $1, $3 ) ); }
         | multiplicative_expression '%' exponential_expression
+        | multiplicative_expression '%' cast_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Mod, $1, $3 ) ); }
+        ;
 …
         '='                                                                                     { $$ = OperKinds::Assign; }
         | ATassign                                                                      { $$ = OperKinds::AtAssn; }
-        | EXPassign                                                                     { $$ = OperKinds::ExpAssn; }
         | MULTassign                                                            { $$ = OperKinds::MulAssn; }
         | DIVassign                                                                     { $$ = OperKinds::DivAssn; }
 …
         | iteration_statement
         | jump_statement
-        | with_statement
         | exception_statement
         | asm_statement
 …
+        ;
-with_statement:
-        WITH '(' tuple_expression_list ')' compound_statement
-                { $$ = (StatementNode *)0; }                                    // FIX ME
+        ;
 exception_statement:
         TRY compound_statement handler_clause
 …
                 { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( $2, nullptr, new ExpressionNode( build_constantInteger( *$6 ) ), $9 ) ) ); }
+        | handler_key '(' push push exception_declaration pop handler_predicate_opt ')' compound_statement pop
+                { $$ = new StatementNode( build_catch( $1, $5, nullptr, $9 ) ); }
+        | handler_clause handler_key '(' push push exception_declaration pop handler_predicate_opt ')' compound_statement pop
+                { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( $2, $6, nullptr, $10 ) ) ); }
+        ;
+handler_predicate_opt:
+        //empty
+        | ';' conditional_expression
+        | handler_key '(' push push exception_declaration pop ')' compound_statement pop
+                { $$ = new StatementNode( build_catch( $1, $5, nullptr, $8 ) ); }
+        | handler_clause handler_key '(' push push exception_declaration pop ')' compound_statement pop
+                { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( $2, $6, nullptr, $9 ) ) ); }
+        ;
 …
         | IMAGINARY                                                                                     // C99
                 { $$ = DeclarationNode::newComplexType( DeclarationNode::Imaginary ); }
+        | VALIST                                                                                        // GCC, __builtin_va_list
+                { $$ = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); }
         | ZERO_T
                 { $$ = DeclarationNode::newBuiltinType( DeclarationNode::Zero ); }
         | ONE_T
                 { $$ = DeclarationNode::newBuiltinType( DeclarationNode::One ); }
-        | VALIST                                                                                        // GCC, __builtin_va_list
-                { $$ = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); }
+        ;
 …
         | aggregate_key attribute_list_opt typegen_name         // CFA
                 { $$ = $3->addQualifiers( $2 ); }
-// Temp, testing TreeStruct
-    | STRUCT TRY attribute_list_opt no_attr_identifier_or_type_name
+        {
-            typedefTable.makeTypedef( *$4 );            // create typedef
-            if ( forall ) typedefTable.changeKind( *$4, TypedefTable::TG ); // $
-            forall = false;                             // reset
+        }
-      '{' field_declaration_list '}'
+        {
-            $$ = DeclarationNode::newTreeStruct( DeclarationNode::Struct,
-                $4, nullptr, nullptr, $7, true )->addQualifiers( $3 );
+        }
-    | STRUCT TRY attribute_list_opt no_attr_identifier_or_type_name TYPEDEFname
+        {
-            typedefTable.makeTypedef( *$4 );            // create typedef
-            if ( forall ) typedefTable.changeKind( *$4, TypedefTable::TG ); // $
-            forall = false;                             // reset
+        }
-      '{' field_declaration_list '}'
+        {
-            $$ = DeclarationNode::newTreeStruct( DeclarationNode::Struct,
-                $4, $5, nullptr, $8, true )->addQualifiers( $3 );
+        }
+        ;
 …
 cfa_parameter_declaration:                                                              // CFA, new & old style parameter declaration
         parameter_declaration
         | cfa_identifier_parameter_declarator_no_tuple identifier_or_type_name default_initialize_opt
+        | cfa_identifier_parameter_declarator_no_tuple identifier_or_type_name assignment_opt
                 { $$ = $1->addName( $2 ); }
         | cfa_abstract_tuple identifier_or_type_name default_initialize_opt
+        | cfa_abstract_tuple identifier_or_type_name assignment_opt
                 // To obtain LR(1), these rules must be duplicated here (see cfa_abstract_declarator).
                 { $$ = $1->addName( $2 ); }
         | type_qualifier_list cfa_abstract_tuple identifier_or_type_name default_initialize_opt
+        | type_qualifier_list cfa_abstract_tuple identifier_or_type_name assignment_opt
                 { $$ = $2->addName( $3 )->addQualifiers( $1 ); }
         | cfa_function_specifier
 …
 parameter_declaration:
                 // No SUE declaration in parameter list.
         declaration_specifier_nobody identifier_parameter_declarator default_initialize_opt
+        declaration_specifier_nobody identifier_parameter_declarator assignment_opt
+                {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
                         $$ = $2->addType( $1 )->addInitializer( $3 ? new InitializerNode( $3 ) : nullptr );
+                }
         | declaration_specifier_nobody type_parameter_redeclarator default_initialize_opt
+        | declaration_specifier_nobody type_parameter_redeclarator assignment_opt
+                {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
 …
 abstract_parameter_declaration:
         declaration_specifier_nobody default_initialize_opt
+        declaration_specifier_nobody assignment_opt
                 { $$ = $1->addInitializer( $2 ? new InitializerNode( $2 ) : nullptr ); }
         | declaration_specifier_nobody abstract_parameter_declarator default_initialize_opt
+        | declaration_specifier_nobody abstract_parameter_declarator assignment_opt
                 { $$ = $2->addType( $1 )->addInitializer( $3 ? new InitializerNode( $3 ) : nullptr ); }
+        ;
 …
+        ;
-with_clause_opt:
-        // empty
-                { $$ = (StatementNode *)0; }                                    // FIX ME
-        | WITH '(' tuple_expression_list ')'
-                { $$ = (StatementNode *)0; }                                    // FIX ME
+        ;
 function_definition:
         cfa_function_declaration with_clause_opt compound_statement     // CFA
+        cfa_function_declaration compound_statement                     // CFA
+                {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
                         typedefTable.leaveScope();
                         $$ = $1->addFunctionBody( $3 );
+                }
         | declaration_specifier function_declarator with_clause_opt compound_statement
+                        $$ = $1->addFunctionBody( $2 );
+                }
+        | declaration_specifier function_declarator compound_statement
+                {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
                         typedefTable.leaveScope();
                         $$ = $2->addFunctionBody( $4 )->addType( $1 );
+                }
         | type_qualifier_list function_declarator with_clause_opt compound_statement
+                        $$ = $2->addFunctionBody( $3 )->addType( $1 );
+                }
+        | type_qualifier_list function_declarator compound_statement
+                {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
                         typedefTable.leaveScope();
                         $$ = $2->addFunctionBody( $4 )->addQualifiers( $1 );
+                }
         | declaration_qualifier_list function_declarator with_clause_opt compound_statement
+                        $$ = $2->addFunctionBody( $3 )->addQualifiers( $1 );
+                }
+        | declaration_qualifier_list function_declarator compound_statement
+                {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
                         typedefTable.leaveScope();
                         $$ = $2->addFunctionBody( $4 )->addQualifiers( $1 );
+                }
         | declaration_qualifier_list type_qualifier_list function_declarator with_clause_opt compound_statement
+                        $$ = $2->addFunctionBody( $3 )->addQualifiers( $1 );
+                }
+        | declaration_qualifier_list type_qualifier_list function_declarator compound_statement
+                {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
                         typedefTable.leaveScope();
                         $$ = $3->addFunctionBody( $5 )->addQualifiers( $2 )->addQualifiers( $1 );
+                        $$ = $3->addFunctionBody( $4 )->addQualifiers( $2 )->addQualifiers( $1 );
+                }
                 // Old-style K&R function definition, OBSOLESCENT (see 4)
         | declaration_specifier KR_function_declarator push KR_declaration_list_opt with_clause_opt compound_statement
+        | declaration_specifier KR_function_declarator push KR_declaration_list_opt compound_statement
+                {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
                         typedefTable.leaveScope();
                         $$ = $2->addOldDeclList( $4 )->addFunctionBody( $6 )->addType( $1 );
+                }
         | type_qualifier_list KR_function_declarator push KR_declaration_list_opt with_clause_opt compound_statement
+                        $$ = $2->addOldDeclList( $4 )->addFunctionBody( $5 )->addType( $1 );
+                }
+        | type_qualifier_list KR_function_declarator push KR_declaration_list_opt compound_statement
+                {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
                         typedefTable.leaveScope();
                         $$ = $2->addOldDeclList( $4 )->addFunctionBody( $6 )->addQualifiers( $1 );
+                        $$ = $2->addOldDeclList( $4 )->addFunctionBody( $5 )->addQualifiers( $1 );
+                }
                 // Old-style K&R function definition with "implicit int" type_specifier, OBSOLESCENT (see 4)
         | declaration_qualifier_list KR_function_declarator push KR_declaration_list_opt with_clause_opt compound_statement
+        | declaration_qualifier_list KR_function_declarator push KR_declaration_list_opt compound_statement
+                {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
                         typedefTable.leaveScope();
                         $$ = $2->addOldDeclList( $4 )->addFunctionBody( $6 )->addQualifiers( $1 );
+                }
         | declaration_qualifier_list type_qualifier_list KR_function_declarator push KR_declaration_list_opt with_clause_opt compound_statement
+                        $$ = $2->addOldDeclList( $4 )->addFunctionBody( $5 )->addQualifiers( $1 );
+                }
+        | declaration_qualifier_list type_qualifier_list KR_function_declarator push KR_declaration_list_opt compound_statement
+                {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
                         typedefTable.leaveScope();
                         $$ = $3->addOldDeclList( $5 )->addFunctionBody( $7 )->addQualifiers( $2 )->addQualifiers( $1 );
+                        $$ = $3->addOldDeclList( $5 )->addFunctionBody( $6 )->addQualifiers( $2 )->addQualifiers( $1 );
+                }
+        ;
 …
+        ;
 default_initialize_opt:
+assignment_opt:
         // empty
                 { $$ = nullptr; }

src/Parser/parserutility.cc

-              r33218c6
+              re0a653d
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 15:30:39 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Tus Jul 18 10:12:00 2017
 // Update Count     : 8
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Wed Jun 28 22:11:32 2017
+// Update Count     : 7
 //
 …
         UntypedExpr *comparison = new UntypedExpr( new NameExpr( "?!=?" ) );
         comparison->get_args().push_back( orig );
         comparison->get_args().push_back( new ConstantExpr( Constant( new ZeroType( noQualifiers ), "0", (unsigned long long int)0 ) ) );
+        comparison->get_args().push_back( new ConstantExpr( Constant( new ZeroType( emptyQualifiers ), "0", (unsigned long long int)0 ) ) );
         return new CastExpr( comparison, new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
+}

src/Parser/parserutility.h

-              r33218c6
+              re0a653d
 // Created On       : Sat May 16 15:31:46 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:32:58 2017
 // Update Count     : 4
+// Last Modified On : Wed Jun 28 22:11:40 2017
+// Update Count     : 3
 //
+#pragma once
+#ifndef PARSEUTILITY_H
+#define PARSEUTILITY_H
 #include "SynTree/SynTree.h"
 Expression *notZeroExpr( Expression *orig );
+#endif // PARSEUTILITY_H
 // Local Variables: //

src/ResolvExpr/Alternative.h

-              r33218c6
+              re0a653d
 // Created On       : Sat May 16 23:45:43 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:36:36 2017
 // Update Count     : 3
+// Last Modified On : Sat May 16 23:54:39 2015
+// Update Count     : 2
 //
+#pragma once
+#ifndef ALTERNATIVE_H
+#define ALTERNATIVE_H
 #include <list>
 …
 } // namespace ResolvExpr
+#endif // ALTERNATIVE_H
 // Local Variables: //
 // tab-width: 4 //

src/ResolvExpr/AlternativeFinder.h

-              r33218c6
+              re0a653d
 // Author           : Richard C. Bilson
 // Created On       : Sat May 16 23:56:12 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:35:32 2017
 // Update Count     : 3
+// Last Modified By : Rob Schluntz
+// Last Modified On : Tue Apr 19 11:44:53 2016
+// Update Count     : 2
 //
+#pragma once
+#ifndef ALTERNATIVEFINDER_H
+#define ALTERNATIVEFINDER_H
 #include <set>
 …
 } // namespace ResolvExpr
+#endif // ALTERNATIVEFINDER_H
 // Local Variables: //
 // tab-width: 4 //

src/ResolvExpr/AlternativePrinter.h

-              r33218c6
+              re0a653d
 // Created On       : Sun May 17 06:55:43 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:37:09 2017
 // Update Count     : 4
+// Last Modified On : Sun May 17 06:57:12 2015
+// Update Count     : 3
 //
+#pragma once
+#ifndef ALTERNATIVEPRINTER_H
+#define ALTERNATIVEPRINTER_H
 #include <iostream>
 …
 } // namespace ResolvExpr
+#endif // ALTERNATIVEPRINTER_H
 // Local Variables: //
 // tab-width: 4 //

src/ResolvExpr/ConversionCost.h

-              r33218c6
+              re0a653d
 // Created On       : Sun May 17 09:37:28 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:38:24 2017
 // Update Count     : 4
+// Last Modified On : Wed Mar  2 17:35:56 2016
+// Update Count     : 3
 //
+#pragma once
+#ifndef CONVERSIONCOST_H
+#define CONVERSIONCOST_H
 #include "SynTree/Visitor.h"
 …
 } // namespace ResolvExpr
+#endif // CONVERSIONCOST_H */
 // Local Variables: //
 // tab-width: 4 //

src/ResolvExpr/Cost.h

-              r33218c6
+              re0a653d
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 09:39:50 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:35:55 2017
 // Update Count     : 5
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Jul 22 16:43:10 2015
+// Update Count     : 4
 //
+#pragma once
+#ifndef COST_H
+#define COST_H
 #include <iostream>
 …
 } // namespace ResolvExpr
+#endif // COST_H
 // Local Variables: //
 // tab-width: 4 //

src/ResolvExpr/CurrentObject.h

-              r33218c6
+              re0a653d
 // Author           : Rob Schluntz
 // Created On       : Thu Jun  8 11:07:25 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:36:48 2017
 // Update Count     : 3
+// Last Modified By : Rob Schluntz
+// Last Modified On : Thu Jun  8 11:07:41 2017
+// Update Count     : 2
 //
+#pragma once
+#ifndef CURRENT_OBJECT_H
+#define CURRENT_OBJECT_H
 #include <stack>
 …
 } // namespace ResolvExpr
+#endif // CURRENT_OBJECT_H
 // Local Variables: //
 // tab-width: 4 //

src/ResolvExpr/FindOpenVars.h

-              r33218c6
+              re0a653d
 // Created On       : Sun May 17 09:46:04 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:35:18 2017
 // Update Count     : 3
+// Last Modified On : Sun May 17 09:47:20 2015
+// Update Count     : 2
 //
+#pragma once
+#ifndef FINDOPENVARS_H
+#define FINDOPENVARS_H
 #include "Unify.h"
 …
 } // namespace ResolvExpr
+#endif // FINDOPENVARS_H
 // Local Variables: //
 // tab-width: 4 //

src/ResolvExpr/RenameVars.h

-              r33218c6
+              re0a653d
 // Created On       : Sun May 17 12:10:28 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:33:54 2017
 // Update Count     : 4
+// Last Modified On : Wed Mar  2 17:36:39 2016
+// Update Count     : 3
 //
+#pragma once
+#ifndef RESOLVEXPR_RENAMEVARS_H
+#define RESOLVEXPR_RENAMEVARS_H
 #include <list>
 …
 } // namespace ResolvExpr
+#endif // RENAMEVARS_H
 // Local Variables: //
 // tab-width: 4 //

src/ResolvExpr/ResolveTypeof.h

-              r33218c6
+              re0a653d
 // Created On       : Sun May 17 12:14:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:38:35 2017
 // Update Count     : 3
+// Last Modified On : Sun May 17 12:16:29 2015
+// Update Count     : 2
 //
+#pragma once
+#ifndef RESOLVETYPEOF_H
+#define RESOLVETYPEOF_H
 #include "SynTree/SynTree.h"
 …
 } // namespace ResolvExpr
+#endif // RESOLVETYPEOF_H
 // Local Variables: //
 // tab-width: 4 //

src/ResolvExpr/Resolver.h

-              r33218c6
+              re0a653d
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 12:18:34 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:36:57 2017
 // Update Count     : 3
+// Last Modified By : Rob Schluntz
+// Last Modified On : Thu Apr 14 15:06:53 2016
+// Update Count     : 2
 //
+#pragma once
+#ifndef RESOLVER_H
+#define RESOLVER_H
 #include "SynTree/SynTree.h"
 …
 } // namespace ResolvExpr
+#endif // RESOLVER_H
 // Local Variables: //
 // tab-width: 4 //

src/ResolvExpr/TypeEnvironment.h

-              r33218c6
+              re0a653d
 // Created On       : Sun May 17 12:24:58 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:35:45 2017
 // Update Count     : 3
+// Last Modified On : Sun May 17 12:26:52 2015
+// Update Count     : 2
 //
+#pragma once
+#ifndef TYPEENVIRONMENT_H
+#define TYPEENVIRONMENT_H
 #include <string>
 …
 } // namespace ResolvExpr
+#endif // TYPEENVIRONMENT_H */
 // Local Variables: //
 // tab-width: 4 //

src/ResolvExpr/TypeMap.h

-              r33218c6
+              re0a653d
 // Author           : Aaron B. Moss
 // Created On       : Fri Feb 19 13:55:00 2016
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat Jul 22 09:37:19 2017
+// Update Count     : 2
+//
+#pragma once
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Fri Feb 19 13:55:00 2016
+// Update Count     : 1
+//
+#ifndef _TYPEMAP_H
+#define _TYPEMAP_H
 #include <map>
 …
 }  // namespace ResolvExpr
+#endif // _TYPEMAP_H
 // Local Variables: //
 // tab-width: 4 //

src/ResolvExpr/Unify.h

-              r33218c6
+              re0a653d
 // Created On       : Sun May 17 13:09:04 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 23:09:34 2017
 // Update Count     : 3
+// Last Modified On : Sun May 17 13:10:34 2015
+// Update Count     : 2
 //
+#pragma once
+#ifndef UNIFY_H
+#define UNIFY_H
 #include <map>
 …
 } // namespace ResolvExpr
+#endif // UNIFY_H
 // Local Variables: //
 // tab-width: 4 //

src/ResolvExpr/typeops.h

-              r33218c6
+              re0a653d
 // Created On       : Sun May 17 07:28:22 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:36:18 2017
 // Update Count     : 3
+// Last Modified On : Sun May 17 07:33:11 2015
+// Update Count     : 2
 //
+#pragma once
+#ifndef TYPEOPS_H
+#define TYPEOPS_H
 #include "SynTree/SynTree.h"
 …
 } // namespace ResolvExpr
+#endif // TYPEOPS_H
 // Local Variables: //
 // tab-width: 4 //

src/SymTab/Autogen.cc

-              r33218c6
+              re0a653d
 // Created On       : Thu Mar 03 15:45:56 2016
 // Last Modified By : Andrew Beach
 // Last Modified On : Fri Jul 14 16:41:00 2017
 // Update Count     : 62
+// Last Modified On : Wed Jun 28 15:30:00 2017
+// Update Count     : 61
 //
 #include "Autogen.h"
 …
         void makeStructFunctions( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting, std::list< Declaration * > & declsToAdd, const std::vector< FuncData > & data ) {
                 // Builtins do not use autogeneration.
                 if ( aggregateDecl->get_linkage() == LinkageSpec::BuiltinCFA ||
+                if ( aggregateDecl->get_linkage() == LinkageSpec::Builtin ||
                          aggregateDecl->get_linkage() == LinkageSpec::BuiltinC ) {
                         return;

src/SymTab/Autogen.h

-              r33218c6
+              re0a653d
 // Created On       : Sun May 17 21:53:34 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:50:25 2017
 // Update Count     : 15
+// Last Modified On : Wed Jun 21 17:25:26 2017
+// Update Count     : 14
 //
+#pragma once
+#ifndef AUTOGEN_H
+#define AUTOGEN_H
 #include <cassert>                // for assert
 …
+        }
 } // namespace SymTab
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
+#endif // AUTOGEN_H

src/SymTab/FixFunction.h

-              r33218c6
+              re0a653d
 // Created On       : Sun May 17 17:02:08 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:45:55 2017
 // Update Count     : 4
+// Last Modified On : Wed Mar  2 17:34:06 2016
+// Update Count     : 3
 //
+#pragma once
+#ifndef FIXFUNCTION_H
+#define FIXFUNCTION_H
 #include "SynTree/Mutator.h"  // for Mutator
 …
 } // namespace SymTab
+#endif // FIXFUNCTION_H
 // Local Variables: //
 // tab-width: 4 //

src/SymTab/ImplementationType.h

-              r33218c6
+              re0a653d
 // Created On       : Sun May 17 21:35:41 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:46:19 2017
 // Update Count     : 3
+// Last Modified On : Sun May 17 21:37:15 2015
+// Update Count     : 2
 //
+#pragma once
+#ifndef IMPLEMENTATIONTYPE_H
+#define IMPLEMENTATIONTYPE_H
 class Type;
 …
 } // namespace SymTab
+#endif // IMPLEMENTATIONTYPE_H
 // Local Variables: //
 // tab-width: 4 //

src/SymTab/Indexer.h

-              r33218c6
+              re0a653d
 // Created On       : Sun May 17 21:38:55 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:46:34 2017
 // Update Count     : 7
+// Last Modified On : Wed Mar  2 17:34:14 2016
+// Update Count     : 6
 //
+#pragma once
+#ifndef INDEXER_H
+#define INDEXER_H
 #include <iosfwd>             // for ostream
 …
 } // namespace SymTab
+#endif // INDEXER_H
 // Local Variables: //
 // tab-width: 4 //

src/SymTab/Mangler.h

-              r33218c6
+              re0a653d
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:44:03 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:45:30 2017
 // Update Count     : 15
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Aug 19 15:48:46 2015
+// Update Count     : 14
 //
+#pragma once
+#ifndef MANGLER_H
+#define MANGLER_H
 #include <map>                // for map, map<>::value_compare
 …
 } // SymTab
+#endif // MANGLER_H
 // Local Variables: //
 // tab-width: 4 //

src/SymTab/Validate.h

-              r33218c6
+              re0a653d
 // Created On       : Sun May 17 21:53:34 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:46:07 2017
 // Update Count     : 4
+// Last Modified On : Tue May 19 16:49:43 2015
+// Update Count     : 3
 //
+#pragma once
+#ifndef VALIDATE_H
+#define VALIDATE_H
 #include <list>  // for list
 …
 } // namespace SymTab
+#endif // VALIDATE_H
 // Local Variables: //
 // tab-width: 4 //

src/SymTab/module.mk

-              r33218c6
+              re0a653d
 ## Author           : Richard C. Bilson
 ## Created On       : Mon Jun  1 17:49:17 2015
 ## Last Modified By : Andrew Beach
 ## Last Modified On : Wed Jul 12 13:06:00 2017
 ## Update Count     : 3
+## Last Modified By : Rob Schluntz
+## Last Modified On : Tue Jul 07 16:22:23 2015
+## Update Count     : 2
 ###############################################################################
 …
        SymTab/ImplementationType.cc \
        SymTab/TypeEquality.cc \
+       SymTab/Autogen.cc \
+       SymTab/TreeStruct.cc
+       SymTab/Autogen.cc

src/SynTree/AddStmtVisitor.h

-              r33218c6
+              re0a653d
 // Created On       : Wed Jun 22 12:05:48 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:51:08 2017
 // Update Count     : 9
+// Last Modified On : Tue Jul 12 17:50:32 2016
+// Update Count     : 8
 //
+#pragma once
+#ifndef ADD_STATEMENT_VISITOR_H
+#define ADD_STATEMENT_VISITOR_H
 #include <list>
 …
 };
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
+#endif // ADD_STATEMENT_VISITOR_H

src/SynTree/Attribute.h

-              r33218c6
+              re0a653d
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:54:14 2017
 // Update Count     : 39
+// Last Modified On : Wed Jan 18 16:27:11 2017
+// Update Count     : 38
 //
+#pragma once
+#ifndef GCC_ATTRIBUTE_H
+#define GCC_ATTRIBUTE_H
 #include "SynTree.h"
 …
 const std::list< Attribute * > noAttributes;
+#endif
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/BaseSyntaxNode.h

-              r33218c6
+              re0a653d
 //
+#pragma once
+#ifndef BASE_SYNTAX_NODE_H
+#define BASE_SYNTAX_NODE_H
 #include "Common/utility.h"
 …
 };
+#endif // BASE_SYNTAX_NODE_H
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Constant.cc

-              r33218c6
+              re0a653d
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Fri Jul 14 14:50:00 2017
 // Update Count     : 29
+// Last Modified On : Thr Jun 22 10:11:00 2017
+// Update Count     : 28
 //
 …
+}
-Constant Constant::null( Type * ptrtype ) {
-        if ( nullptr == ptrtype ) {
-                ptrtype = new PointerType(
-                        Type::Qualifiers(),
-                        new VoidType( Type::Qualifiers() )
-                        );
+        }
-        return Constant( ptrtype, "0", (unsigned long long int)0 );
+}
 unsigned long long Constant::get_ival() const {
         assertf( safe_dynamic_cast<BasicType*>(type)->isInteger(), "Attempt to retrieve ival from non-integer constant." );

src/SynTree/Constant.h

-              r33218c6
+              re0a653d
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:54:46 2017
 // Update Count     : 17
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr Jun 22 10:13:00 2017
+// Update Count     : 15
 //
+#pragma once
+#ifndef CONSTANT_H
+#define CONSTANT_H
 #include "SynTree.h"
 …
         static Constant from_double( double d );
-        /// generates a null pointer value for the given type. void * if omitted.
-        static Constant null( Type * ptrtype = nullptr );
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Constant * acceptMutator( Mutator & m ) { return m.mutate( this ); }
 …
 };
+#endif // CONSTANT_H
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Declaration.h

-              r33218c6
+              re0a653d
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat Jul 22 09:52:59 2017
+// Update Count     : 124
+//
+#pragma once
+// Last Modified By : Andrew Beach
+// Last Modified On : Tus Jun 27 15:31:00 2017
+// Update Count     : 122
+//
+#ifndef DECLARATION_H
+#define DECLARATION_H
 #include <string>
 …
         typedef AggregateDecl Parent;
   public:
+        StructDecl( const std::string &name, DeclarationNode::Aggregate kind = DeclarationNode::Struct, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ), kind( kind ), tagged( false ), parent_name( "" ) {}
+        StructDecl( const std::string &name, const std::string *parent, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ), kind( DeclarationNode::Struct ), tagged( true ), parent_name( parent ? *parent : "" ) {}
+        StructDecl( const std::string &name, DeclarationNode::Aggregate kind = DeclarationNode::Struct, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ), kind( kind ) {}
         StructDecl( const StructDecl &other ) : Parent( other ) {}
 …
         bool is_thread() { return kind == DeclarationNode::Thread; }
-        // Tagged/Tree Structure Excetion
-        bool get_tagged() { return tagged; }
-        void set_tagged( bool newValue ) { tagged = newValue; }
-        bool has_parent() { return parent_name != ""; }
-        std::string get_parentName() { return parent_name; }
         virtual StructDecl *clone() const { return new StructDecl( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
 …
         DeclarationNode::Aggregate kind;
         virtual std::string typeString() const;
-        bool tagged;
-        std::string parent_name;
 };
 …
 std::ostream & operator<<( std::ostream & out, const Declaration * decl );
 std::ostream & operator<<( std::ostream & os, const TypeDecl::Data & data );
+#endif // DECLARATION_H
 // Local Variables: //

src/SynTree/Expression.h

-              r33218c6
+              re0a653d
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:53:16 2017
 // Update Count     : 42
+// Last Modified On : Thu Mar 30 16:44:00 2017
+// Update Count     : 41
 //
+#pragma once
+#ifndef EXPRESSION_H
+#define EXPRESSION_H
 #include <map>
 …
 std::ostream & operator<<( std::ostream & out, const Expression * expr );
+#endif // EXPRESSION_H
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Initializer.h

-              r33218c6
+              re0a653d
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:52:02 2017
 // Update Count     : 21
+// Last Modified On : Thu Mar 23 16:12:42 2017
+// Update Count     : 20
 //
+#pragma once
+#ifndef INITIALIZER_H
+#define INITIALIZER_H
 #include <cassert>
 …
 std::ostream & operator<<( std::ostream & out, const Designation * des );
+#endif // INITIALIZER_H
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Label.h

-              r33218c6
+              re0a653d
 // Created On       : Wed Jun 8 12:53:12 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:52:44 2017
 // Update Count     : 3
+// Last Modified On : Sun Aug  7 14:44:29 2016
+// Update Count     : 2
 //
+#pragma once
+#ifndef LABEL_H
+#define LABEL_H
 #include <string>
 …
 static const std::list< Label > noLabels;
+#endif // LABEL_H
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Mutator.h

-              r33218c6
+              re0a653d
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:51:30 2017
 // Update Count     : 15
+// Last Modified By : Andrew Beach
+// Last Modified On : Thu Jun  8 15:45:00 2017
+// Update Count     : 14
 //
 #include <cassert>
 …
 #include "Common/SemanticError.h"
+#pragma once
+#ifndef MUTATOR_H
+#define MUTATOR_H
 class Mutator {
 …
+}
+#endif // MUTATOR_H
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Statement.h

-              r33218c6
+              re0a653d
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:54:32 2017
 // Update Count     : 68
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Jun 12 13:35:00 2017
+// Update Count     : 67
 //
+#pragma once
+#ifndef STATEMENT_H
+#define STATEMENT_H
 #include "BaseSyntaxNode.h"
 …
 std::ostream & operator<<( std::ostream & out, const Statement * statement );
+#endif // STATEMENT_H
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/SynTree.h

-              r33218c6
+              re0a653d
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:51:46 2017
 // Update Count     : 10
+// Last Modified By : Andrew Beach
+// Last Modified On : Thu Jun  8 17:00:00 2017
+// Update Count     : 9
 //
+#pragma once
+#ifndef SYNTREE_H
+#define SYNTREE_H
 #include <string>
 …
 class Attribute;
+#endif // SYNTREE_H
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Type.h

-              r33218c6
+              re0a653d
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:53:29 2017
 // Update Count     : 151
+// Last Modified On : Thu Mar 23 16:16:36 2017
+// Update Count     : 149
 //
+#pragma once
+#ifndef TYPE_H
+#define TYPE_H
 #include "BaseSyntaxNode.h"
 …
 };
 extern Type::Qualifiers noQualifiers;                           // no qualifiers on constants
+extern Type::Qualifiers emptyQualifiers;                                // no qualifiers on constants
 class VoidType : public Type {
 …
 std::ostream & operator<<( std::ostream & out, const Type * type );
+#endif // TYPE_H
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/TypeSubstitution.h

-              r33218c6
+              re0a653d
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:52:24 2017
 // Update Count     : 3
+// Last Modified By : Rob Schluntz
+// Last Modified On : Fri Apr 29 15:00:20 2016
+// Update Count     : 2
 //
+#pragma once
+#ifndef TYPESUBSTITUTION_H
+#define TYPESUBSTITUTION_H
 #include <map>
 …
 std::ostream & operator<<( std::ostream & out, const TypeSubstitution & sub );
+#endif // TYPESUBSTITUTION_H
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/VarExprReplacer.h

-              r33218c6
+              re0a653d
 // Author           : Rob Schluntz
 // Created On       : Wed Jan 13 16:29:30 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:53:41 2017
 // Update Count     : 6
+// Last Modified By : Rob Schluntz
+// Last Modified On : Fri May 13 11:27:52 2016
+// Update Count     : 5
 //
+#pragma once
+#ifndef VAR_EXPR_REPLACER_H
+#define VAR_EXPR_REPLACER_H
 #include <map>
 …
 };
+#endif // VAR_EXPR_REPLACER_H
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Visitor.h

-              r33218c6
+              re0a653d
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:54:04 2017
 // Update Count     : 12
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr Jun 08 15:45:00 2017
+// Update Count     : 11
 //
+#pragma once
+#ifndef VISITOR_H
+#define VISITOR_H
 #include "SynTree.h"
 …
+}
+#endif // VISITOR_H
 // Local Variables: //
 // tab-width: 4 //

src/Tuples/Explode.h

-              r33218c6
+              re0a653d
 // Author           : Rob Schluntz
 // Created On       : Wed Nov 9 13:12:24 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:55:16 2017
 // Update Count     : 3
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Nov 9 13:20:24 2016
+// Update Count     : 2
 //
+#pragma once
+#ifndef _EXPLODE_H_
+#define _EXPLODE_H_
 #include "ResolvExpr/AlternativeFinder.h"
 …
 } // namespace Tuples
+#endif // _TUPLE_ASSIGNMENT_H_
 // Local Variables: //
 // tab-width: 4 //

src/Tuples/Tuples.h

-              r33218c6
+              re0a653d
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:55:00 2017
 // Update Count     : 16
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Nov 9 13:17:58 2016
+// Update Count     : 15
 //
+#pragma once
+#ifndef _TUPLES_H_
+#define _TUPLES_H_
 #include <string>
 …
 } // namespace Tuples
+#endif // _TUPLE_ASSIGNMENT_H_
 // Local Variables: //
 // tab-width: 4 //

src/benchmark/create_pthrd.c

-              r33218c6
+              re0a653d
                 n = atoi(argv[1]);
+        }
         printf("create %lu pthreads ... ", n);
+        printf("%lu\n", n);
         for (size_t i = 0; i < n; i++) {
+                pthread_t thread;
+                if (pthread_create(&thread, NULL, foo, NULL) < 0) {
+                        perror( "failure" );
+                pthread_attr_t attr;
+                if (pthread_attr_init(&attr) < 0) {
                         return 1;
+                }
+                if (pthread_join( thread, NULL) < 0) {
+                        perror( "failure" );
+                if (pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) < 0) {
+                        return 1;
+                }
+                pthread_t thread;
+                if (pthread_create(&thread, &attr, foo, NULL) < 0) {
                         return 1;
+                }
+        }
+        printf("finish\n");
+        pthread_exit(NULL);
+        return 0;
+}

src/driver/cfa.cc

-              r33218c6
+              re0a653d
 // Created On       : Tue Aug 20 13:44:49 2002
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jul 20 15:54:45 2017
 // Update Count     : 156
+// Last Modified On : Fri Jan 20 14:38:45 2017
+// Update Count     : 155
 //
 …
         bool cpp_flag = false;                                                          // -E or -M flag, preprocessor only
         bool std_flag = false;                                                          // -std= flag
+        bool noincstd_flag = false;                                                     // -no-include-stdhdr= flag
         bool debugging __attribute(( unused )) = false;         // -g flag
 …
                         } else if ( arg == "-nohelp" ) {
                                 help = false;                                                   // strip the nohelp flag
+                        } else if ( arg == "-no-include-stdhdr" ) {
+                                noincstd_flag = true;                                   // strip the no-include-stdhdr flag
                         } else if ( arg == "-compiler" ) {
                                 // use the user specified compiler
 …
         args[nargs] = "-I" CFA_INCDIR;
         nargs += 1;
+        args[nargs] = "-I" CFA_INCDIR "/stdhdr";
+        nargs += 1;
+        if ( ! noincstd_flag ) {                                                        // do not use during build
+                args[nargs] = "-I" CFA_INCDIR "/stdhdr";
+                nargs += 1;
+        } // if
         args[nargs] = "-I" CFA_INCDIR "/concurrency";
         nargs += 1;

src/libcfa/Makefile.am

-              r33218c6
+              re0a653d
 ## Author           : Peter A. Buhr
 ## Created On       : Sun May 31 08:54:01 2015
 ## Last Modified By : Peter A. Buhr
 ## Last Modified On : Thu Jul 20 23:09:34 2017
 ## Update Count     : 220
+## Last Modified By : Andrew Beach
+## Last Modified On : Wed Jun 28 15:36:00 2017
+## Update Count     : 215
 ###############################################################################
 …
 AM_CCASFLAGS = @CFA_FLAGS@
 CFLAGS = -quiet -I${abs_top_srcdir}/src/libcfa/stdhdr -XCFA -t -B${abs_top_srcdir}/src/driver ${EXTRA_FLAGS}
+CFLAGS = -quiet -no-include-stdhdr -XCFA -t -B${abs_top_srcdir}/src/driver ${EXTRA_FLAGS}
 CC = ${abs_top_srcdir}/src/driver/cfa
 headers = fstream iostream iterator limits rational stdlib \
+headers = assert fstream iostream iterator limits math rational stdlib \
           containers/maybe containers/pair containers/result containers/vector
 …
 libobjs = ${headers:=.o}
+libsrc = libcfa-prelude.c interpose.c libhdr/libdebug.c ${headers:=.c} \
+         assert.c exception.c typeobject.c
+libsrc = libcfa-prelude.c interpose.c libhdr/libdebug.c ${headers:=.c} exception.c
 # not all platforms support concurrency, add option do disable it
 …
         ${AM_V_CC}@BACKEND_CC@ -DHAVE_CONFIG_H -I. -I../.. -O2 ${EXTRA_FLAGS} -c -o $@ $<
-libcfa_a-typeobject.o : typeobject.c
-        ${AM_V_CC}@BACKEND_CC@ -DHAVE_CONFIG_H -I. -I../.. -O2 ${EXTRA_FLAGS} -c -o $@ $<
 concurrency/libcfa_d_a-invoke.o : concurrency/invoke.c
         ${AM_V_CC}@BACKEND_CC@ -DHAVE_CONFIG_H -I. -I../.. -D__CFA_DEBUG__ -O0 ${EXTRA_FLAGS} -c -o $@ $<
 libcfa_d_a-exception.o : exception.c
-        ${AM_V_CC}@BACKEND_CC@ -DHAVE_CONFIG_H -I. -I../.. -D__CFA_DEBUG__ -O0 ${EXTRA_FLAGS} -c -o $@ $<
-libcfa_d_a-typeobject.o : typeobject.c
         ${AM_V_CC}@BACKEND_CC@ -DHAVE_CONFIG_H -I. -I../.. -D__CFA_DEBUG__ -O0 ${EXTRA_FLAGS} -c -o $@ $<
 …
 cfa_includedir = $(CFA_INCDIR)
 nobase_cfa_include_HEADERS = ${headers} ${stdhdr} math gmp concurrency/invoke.h
+nobase_cfa_include_HEADERS = ${headers} ${stdhdr} gmp concurrency/invoke.h
 CLEANFILES = libcfa-prelude.c

src/libcfa/Makefile.in

-              r33218c6
+              re0a653d
 libcfa_d_a_LIBADD =
 am__libcfa_d_a_SOURCES_DIST = libcfa-prelude.c interpose.c \
         libhdr/libdebug.c fstream.c iostream.c iterator.c limits.c \
         rational.c stdlib.c containers/maybe.c containers/pair.c \
         containers/result.c containers/vector.c \
+        libhdr/libdebug.c assert.c fstream.c iostream.c iterator.c \
+        limits.c math.c rational.c stdlib.c containers/maybe.c \
+        containers/pair.c containers/result.c containers/vector.c \
         concurrency/coroutine.c concurrency/thread.c \
+        concurrency/kernel.c concurrency/monitor.c assert.c \
+        exception.c typeobject.c \
+        concurrency/kernel.c concurrency/monitor.c exception.c \
         concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/alarm.c \
         concurrency/invoke.c concurrency/preemption.c
 …
 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-kernel.$(OBJEXT) \
 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-monitor.$(OBJEXT)
+am__objects_2 = libcfa_d_a-fstream.$(OBJEXT) \
+        libcfa_d_a-iostream.$(OBJEXT) libcfa_d_a-iterator.$(OBJEXT) \
+        libcfa_d_a-limits.$(OBJEXT) libcfa_d_a-rational.$(OBJEXT) \
+am__objects_2 = libcfa_d_a-assert.$(OBJEXT) \
+        libcfa_d_a-fstream.$(OBJEXT) libcfa_d_a-iostream.$(OBJEXT) \
+        libcfa_d_a-iterator.$(OBJEXT) libcfa_d_a-limits.$(OBJEXT) \
+        libcfa_d_a-math.$(OBJEXT) libcfa_d_a-rational.$(OBJEXT) \
         libcfa_d_a-stdlib.$(OBJEXT) \
         containers/libcfa_d_a-maybe.$(OBJEXT) \
 …
         libcfa_d_a-interpose.$(OBJEXT) \
         libhdr/libcfa_d_a-libdebug.$(OBJEXT) $(am__objects_2) \
+        libcfa_d_a-assert.$(OBJEXT) libcfa_d_a-exception.$(OBJEXT) \
+        libcfa_d_a-typeobject.$(OBJEXT) $(am__objects_3)
+        libcfa_d_a-exception.$(OBJEXT) $(am__objects_3)
 am_libcfa_d_a_OBJECTS = $(am__objects_4)
 libcfa_d_a_OBJECTS = $(am_libcfa_d_a_OBJECTS)
 …
 libcfa_a_LIBADD =
 am__libcfa_a_SOURCES_DIST = libcfa-prelude.c interpose.c \
         libhdr/libdebug.c fstream.c iostream.c iterator.c limits.c \
         rational.c stdlib.c containers/maybe.c containers/pair.c \
         containers/result.c containers/vector.c \
+        libhdr/libdebug.c assert.c fstream.c iostream.c iterator.c \
+        limits.c math.c rational.c stdlib.c containers/maybe.c \
+        containers/pair.c containers/result.c containers/vector.c \
         concurrency/coroutine.c concurrency/thread.c \
+        concurrency/kernel.c concurrency/monitor.c assert.c \
+        exception.c typeobject.c \
+        concurrency/kernel.c concurrency/monitor.c exception.c \
         concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/alarm.c \
         concurrency/invoke.c concurrency/preemption.c
 …
 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-kernel.$(OBJEXT) \
 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-monitor.$(OBJEXT)
+am__objects_6 = libcfa_a-fstream.$(OBJEXT) libcfa_a-iostream.$(OBJEXT) \
+        libcfa_a-iterator.$(OBJEXT) libcfa_a-limits.$(OBJEXT) \
+am__objects_6 = libcfa_a-assert.$(OBJEXT) libcfa_a-fstream.$(OBJEXT) \
+        libcfa_a-iostream.$(OBJEXT) libcfa_a-iterator.$(OBJEXT) \
+        libcfa_a-limits.$(OBJEXT) libcfa_a-math.$(OBJEXT) \
         libcfa_a-rational.$(OBJEXT) libcfa_a-stdlib.$(OBJEXT) \
         containers/libcfa_a-maybe.$(OBJEXT) \
 …
         libcfa_a-interpose.$(OBJEXT) \
         libhdr/libcfa_a-libdebug.$(OBJEXT) $(am__objects_6) \
+        libcfa_a-assert.$(OBJEXT) libcfa_a-exception.$(OBJEXT) \
+        libcfa_a-typeobject.$(OBJEXT) $(am__objects_7)
+        libcfa_a-exception.$(OBJEXT) $(am__objects_7)
 am_libcfa_a_OBJECTS = $(am__objects_8)
 libcfa_a_OBJECTS = $(am_libcfa_a_OBJECTS)
 …
     *) (install-info --version) >/dev/null 2>&1;; \
   esac
 am__nobase_cfa_include_HEADERS_DIST = fstream iostream iterator limits \
         rational stdlib containers/maybe containers/pair \
+am__nobase_cfa_include_HEADERS_DIST = assert fstream iostream iterator \
+        limits math rational stdlib containers/maybe containers/pair \
         containers/result containers/vector concurrency/coroutine \
         concurrency/thread concurrency/kernel concurrency/monitor \
         ${shell echo stdhdr/*} math gmp concurrency/invoke.h
+        ${shell echo stdhdr/*} gmp concurrency/invoke.h
 HEADERS = $(nobase_cfa_include_HEADERS)
 am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
 …
 CFA_NAME = @CFA_NAME@
 CFA_PREFIX = @CFA_PREFIX@
 CFLAGS = -quiet -I${abs_top_srcdir}/src/libcfa/stdhdr -XCFA -t -B${abs_top_srcdir}/src/driver ${EXTRA_FLAGS}
+CFLAGS = -quiet -no-include-stdhdr -XCFA -t -B${abs_top_srcdir}/src/driver ${EXTRA_FLAGS}
 CPP = @CPP@
 CPPFLAGS = @CPPFLAGS@
 …
 EXTRA_FLAGS = -g -Wall -Werror -Wno-unused-function -I${abs_top_srcdir}/src/libcfa/libhdr -imacros libcfa-prelude.c @CFA_FLAGS@
 AM_CCASFLAGS = @CFA_FLAGS@
 headers = fstream iostream iterator limits rational stdlib \
+headers = assert fstream iostream iterator limits math rational stdlib \
         containers/maybe containers/pair containers/result \
         containers/vector $(am__append_3)
 libobjs = ${headers:=.o}
 libsrc = libcfa-prelude.c interpose.c libhdr/libdebug.c ${headers:=.c} \
         assert.c exception.c typeobject.c $(am__append_4)
+        exception.c $(am__append_4)
 libcfa_a_SOURCES = ${libsrc}
 libcfa_a_CFLAGS = -nodebug -O2
 …
 stdhdr = ${shell echo stdhdr/*}
 cfa_includedir = $(CFA_INCDIR)
 nobase_cfa_include_HEADERS = ${headers} ${stdhdr} math gmp concurrency/invoke.h
+nobase_cfa_include_HEADERS = ${headers} ${stdhdr} gmp concurrency/invoke.h
 CLEANFILES = libcfa-prelude.c
 all: all-am
 …
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_a-libcfa-prelude.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_a-limits.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_a-math.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_a-rational.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_a-stdlib.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_a-typeobject.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-assert.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-exception.Po@am__quote@
 …
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-libcfa-prelude.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-limits.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-math.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-rational.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-stdlib.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-typeobject.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/CtxSwitch-@MACHINE_TYPE@.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-alarm.Po@am__quote@
 …
 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libhdr/libcfa_d_a-libdebug.obj `if test -f 'libhdr/libdebug.c'; then $(CYGPATH_W) 'libhdr/libdebug.c'; else $(CYGPATH_W) '$(srcdir)/libhdr/libdebug.c'; fi`
+libcfa_d_a-assert.o: assert.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-assert.o -MD -MP -MF $(DEPDIR)/libcfa_d_a-assert.Tpo -c -o libcfa_d_a-assert.o `test -f 'assert.c' || echo '$(srcdir)/'`assert.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-assert.Tpo $(DEPDIR)/libcfa_d_a-assert.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='assert.c' object='libcfa_d_a-assert.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-assert.o `test -f 'assert.c' || echo '$(srcdir)/'`assert.c
+libcfa_d_a-assert.obj: assert.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-assert.obj -MD -MP -MF $(DEPDIR)/libcfa_d_a-assert.Tpo -c -o libcfa_d_a-assert.obj `if test -f 'assert.c'; then $(CYGPATH_W) 'assert.c'; else $(CYGPATH_W) '$(srcdir)/assert.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-assert.Tpo $(DEPDIR)/libcfa_d_a-assert.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='assert.c' object='libcfa_d_a-assert.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-assert.obj `if test -f 'assert.c'; then $(CYGPATH_W) 'assert.c'; else $(CYGPATH_W) '$(srcdir)/assert.c'; fi`
 libcfa_d_a-fstream.o: fstream.c
 @am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-fstream.o -MD -MP -MF $(DEPDIR)/libcfa_d_a-fstream.Tpo -c -o libcfa_d_a-fstream.o `test -f 'fstream.c' || echo '$(srcdir)/'`fstream.c
 …
 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-limits.obj `if test -f 'limits.c'; then $(CYGPATH_W) 'limits.c'; else $(CYGPATH_W) '$(srcdir)/limits.c'; fi`
+libcfa_d_a-math.o: math.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-math.o -MD -MP -MF $(DEPDIR)/libcfa_d_a-math.Tpo -c -o libcfa_d_a-math.o `test -f 'math.c' || echo '$(srcdir)/'`math.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-math.Tpo $(DEPDIR)/libcfa_d_a-math.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='math.c' object='libcfa_d_a-math.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-math.o `test -f 'math.c' || echo '$(srcdir)/'`math.c
+libcfa_d_a-math.obj: math.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-math.obj -MD -MP -MF $(DEPDIR)/libcfa_d_a-math.Tpo -c -o libcfa_d_a-math.obj `if test -f 'math.c'; then $(CYGPATH_W) 'math.c'; else $(CYGPATH_W) '$(srcdir)/math.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-math.Tpo $(DEPDIR)/libcfa_d_a-math.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='math.c' object='libcfa_d_a-math.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-math.obj `if test -f 'math.c'; then $(CYGPATH_W) 'math.c'; else $(CYGPATH_W) '$(srcdir)/math.c'; fi`
 libcfa_d_a-rational.o: rational.c
 @am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-rational.o -MD -MP -MF $(DEPDIR)/libcfa_d_a-rational.Tpo -c -o libcfa_d_a-rational.o `test -f 'rational.c' || echo '$(srcdir)/'`rational.c
 …
 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_d_a-monitor.obj `if test -f 'concurrency/monitor.c'; then $(CYGPATH_W) 'concurrency/monitor.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/monitor.c'; fi`
-libcfa_d_a-assert.o: assert.c
-@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-assert.o -MD -MP -MF $(DEPDIR)/libcfa_d_a-assert.Tpo -c -o libcfa_d_a-assert.o `test -f 'assert.c' || echo '$(srcdir)/'`assert.c
-@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-assert.Tpo $(DEPDIR)/libcfa_d_a-assert.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='assert.c' object='libcfa_d_a-assert.o' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-assert.o `test -f 'assert.c' || echo '$(srcdir)/'`assert.c
-libcfa_d_a-assert.obj: assert.c
-@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-assert.obj -MD -MP -MF $(DEPDIR)/libcfa_d_a-assert.Tpo -c -o libcfa_d_a-assert.obj `if test -f 'assert.c'; then $(CYGPATH_W) 'assert.c'; else $(CYGPATH_W) '$(srcdir)/assert.c'; fi`
-@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-assert.Tpo $(DEPDIR)/libcfa_d_a-assert.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='assert.c' object='libcfa_d_a-assert.obj' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-assert.obj `if test -f 'assert.c'; then $(CYGPATH_W) 'assert.c'; else $(CYGPATH_W) '$(srcdir)/assert.c'; fi`
 libcfa_d_a-exception.obj: exception.c
 @am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-exception.obj -MD -MP -MF $(DEPDIR)/libcfa_d_a-exception.Tpo -c -o libcfa_d_a-exception.obj `if test -f 'exception.c'; then $(CYGPATH_W) 'exception.c'; else $(CYGPATH_W) '$(srcdir)/exception.c'; fi`
 …
 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-exception.obj `if test -f 'exception.c'; then $(CYGPATH_W) 'exception.c'; else $(CYGPATH_W) '$(srcdir)/exception.c'; fi`
-libcfa_d_a-typeobject.obj: typeobject.c
-@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-typeobject.obj -MD -MP -MF $(DEPDIR)/libcfa_d_a-typeobject.Tpo -c -o libcfa_d_a-typeobject.obj `if test -f 'typeobject.c'; then $(CYGPATH_W) 'typeobject.c'; else $(CYGPATH_W) '$(srcdir)/typeobject.c'; fi`
-@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-typeobject.Tpo $(DEPDIR)/libcfa_d_a-typeobject.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='typeobject.c' object='libcfa_d_a-typeobject.obj' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-typeobject.obj `if test -f 'typeobject.c'; then $(CYGPATH_W) 'typeobject.c'; else $(CYGPATH_W) '$(srcdir)/typeobject.c'; fi`
 concurrency/libcfa_d_a-alarm.o: concurrency/alarm.c
 @am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_d_a-alarm.o -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-alarm.Tpo -c -o concurrency/libcfa_d_a-alarm.o `test -f 'concurrency/alarm.c' || echo '$(srcdir)/'`concurrency/alarm.c
 …
 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libhdr/libcfa_a-libdebug.obj `if test -f 'libhdr/libdebug.c'; then $(CYGPATH_W) 'libhdr/libdebug.c'; else $(CYGPATH_W) '$(srcdir)/libhdr/libdebug.c'; fi`
+libcfa_a-assert.o: assert.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-assert.o -MD -MP -MF $(DEPDIR)/libcfa_a-assert.Tpo -c -o libcfa_a-assert.o `test -f 'assert.c' || echo '$(srcdir)/'`assert.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-assert.Tpo $(DEPDIR)/libcfa_a-assert.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='assert.c' object='libcfa_a-assert.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-assert.o `test -f 'assert.c' || echo '$(srcdir)/'`assert.c
+libcfa_a-assert.obj: assert.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-assert.obj -MD -MP -MF $(DEPDIR)/libcfa_a-assert.Tpo -c -o libcfa_a-assert.obj `if test -f 'assert.c'; then $(CYGPATH_W) 'assert.c'; else $(CYGPATH_W) '$(srcdir)/assert.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-assert.Tpo $(DEPDIR)/libcfa_a-assert.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='assert.c' object='libcfa_a-assert.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-assert.obj `if test -f 'assert.c'; then $(CYGPATH_W) 'assert.c'; else $(CYGPATH_W) '$(srcdir)/assert.c'; fi`
 libcfa_a-fstream.o: fstream.c
 @am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-fstream.o -MD -MP -MF $(DEPDIR)/libcfa_a-fstream.Tpo -c -o libcfa_a-fstream.o `test -f 'fstream.c' || echo '$(srcdir)/'`fstream.c
 …
 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-limits.obj `if test -f 'limits.c'; then $(CYGPATH_W) 'limits.c'; else $(CYGPATH_W) '$(srcdir)/limits.c'; fi`
+libcfa_a-math.o: math.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-math.o -MD -MP -MF $(DEPDIR)/libcfa_a-math.Tpo -c -o libcfa_a-math.o `test -f 'math.c' || echo '$(srcdir)/'`math.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-math.Tpo $(DEPDIR)/libcfa_a-math.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='math.c' object='libcfa_a-math.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-math.o `test -f 'math.c' || echo '$(srcdir)/'`math.c
+libcfa_a-math.obj: math.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-math.obj -MD -MP -MF $(DEPDIR)/libcfa_a-math.Tpo -c -o libcfa_a-math.obj `if test -f 'math.c'; then $(CYGPATH_W) 'math.c'; else $(CYGPATH_W) '$(srcdir)/math.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-math.Tpo $(DEPDIR)/libcfa_a-math.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='math.c' object='libcfa_a-math.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-math.obj `if test -f 'math.c'; then $(CYGPATH_W) 'math.c'; else $(CYGPATH_W) '$(srcdir)/math.c'; fi`
 libcfa_a-rational.o: rational.c
 @am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-rational.o -MD -MP -MF $(DEPDIR)/libcfa_a-rational.Tpo -c -o libcfa_a-rational.o `test -f 'rational.c' || echo '$(srcdir)/'`rational.c
 …
 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_a-monitor.obj `if test -f 'concurrency/monitor.c'; then $(CYGPATH_W) 'concurrency/monitor.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/monitor.c'; fi`
-libcfa_a-assert.o: assert.c
-@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-assert.o -MD -MP -MF $(DEPDIR)/libcfa_a-assert.Tpo -c -o libcfa_a-assert.o `test -f 'assert.c' || echo '$(srcdir)/'`assert.c
-@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-assert.Tpo $(DEPDIR)/libcfa_a-assert.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='assert.c' object='libcfa_a-assert.o' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-assert.o `test -f 'assert.c' || echo '$(srcdir)/'`assert.c
-libcfa_a-assert.obj: assert.c
-@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-assert.obj -MD -MP -MF $(DEPDIR)/libcfa_a-assert.Tpo -c -o libcfa_a-assert.obj `if test -f 'assert.c'; then $(CYGPATH_W) 'assert.c'; else $(CYGPATH_W) '$(srcdir)/assert.c'; fi`
-@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-assert.Tpo $(DEPDIR)/libcfa_a-assert.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='assert.c' object='libcfa_a-assert.obj' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-assert.obj `if test -f 'assert.c'; then $(CYGPATH_W) 'assert.c'; else $(CYGPATH_W) '$(srcdir)/assert.c'; fi`
 libcfa_a-exception.obj: exception.c
 @am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-exception.obj -MD -MP -MF $(DEPDIR)/libcfa_a-exception.Tpo -c -o libcfa_a-exception.obj `if test -f 'exception.c'; then $(CYGPATH_W) 'exception.c'; else $(CYGPATH_W) '$(srcdir)/exception.c'; fi`
 …
 @AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-exception.obj `if test -f 'exception.c'; then $(CYGPATH_W) 'exception.c'; else $(CYGPATH_W) '$(srcdir)/exception.c'; fi`
-libcfa_a-typeobject.obj: typeobject.c
-@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-typeobject.obj -MD -MP -MF $(DEPDIR)/libcfa_a-typeobject.Tpo -c -o libcfa_a-typeobject.obj `if test -f 'typeobject.c'; then $(CYGPATH_W) 'typeobject.c'; else $(CYGPATH_W) '$(srcdir)/typeobject.c'; fi`
-@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-typeobject.Tpo $(DEPDIR)/libcfa_a-typeobject.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='typeobject.c' object='libcfa_a-typeobject.obj' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-typeobject.obj `if test -f 'typeobject.c'; then $(CYGPATH_W) 'typeobject.c'; else $(CYGPATH_W) '$(srcdir)/typeobject.c'; fi`
 concurrency/libcfa_a-alarm.o: concurrency/alarm.c
 …
         ${AM_V_CC}@BACKEND_CC@ -DHAVE_CONFIG_H -I. -I../.. -O2 ${EXTRA_FLAGS} -c -o $@ $<
-libcfa_a-typeobject.o : typeobject.c
-        ${AM_V_CC}@BACKEND_CC@ -DHAVE_CONFIG_H -I. -I../.. -O2 ${EXTRA_FLAGS} -c -o $@ $<
 concurrency/libcfa_d_a-invoke.o : concurrency/invoke.c
         ${AM_V_CC}@BACKEND_CC@ -DHAVE_CONFIG_H -I. -I../.. -D__CFA_DEBUG__ -O0 ${EXTRA_FLAGS} -c -o $@ $<
 libcfa_d_a-exception.o : exception.c
-        ${AM_V_CC}@BACKEND_CC@ -DHAVE_CONFIG_H -I. -I../.. -D__CFA_DEBUG__ -O0 ${EXTRA_FLAGS} -c -o $@ $<
-libcfa_d_a-typeobject.o : typeobject.c
         ${AM_V_CC}@BACKEND_CC@ -DHAVE_CONFIG_H -I. -I../.. -D__CFA_DEBUG__ -O0 ${EXTRA_FLAGS} -c -o $@ $<

src/libcfa/assert.c

-              r33218c6
+              re0a653d
 // Author           : Thierry Delisle
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jul 20 15:10:26 2017
 // Update Count     : 2
+// Last Modified By : Thierry Delisle
+// Last Modified On : Mon Nov 28 12:27:26 2016
+// Update Count     : 0
 //
 #include <assert.h>
 #include <stdarg.h>                                                             // varargs
+#include <stdio.h>                                                              // fprintf
+#include "assert"
+#include "stdlib"                                                                               // abort
 #include "libhdr/libdebug.h"
 extern "C" {
+        #include <stdarg.h>                                                             // varargs
+        #include <stdio.h>                                                              // fprintf
         extern const char * __progname;                                         // global name of running executable (argv[0])
 …
                 abort();
+        }
+}

src/libcfa/concurrency/CtxSwitch-i386.S

-              r33218c6
+              re0a653d
+//                               -*- Mode: Asm -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Tue Dec 6 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:29:25 2017
 // Update Count     : 1
+// Last Modified By : Thierry Delisle
+// Last Modified On : Tue Dec 6 12:27:26 2016
+// Update Count     : 0
 //
 // This  library is free  software; you  can redistribute  it and/or  modify it
 …
 // Local Variables: //
+// mode: c //
+// tab-width: 4 //
+// compile-command: "make install" //
 // End: //

src/libcfa/concurrency/CtxSwitch-x86_64.S

-              r33218c6
+              re0a653d
+//                               -*- Mode: Asm -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:28:11 2017
 // Update Count     : 1
+// Last Modified By : Thierry Delisle
+// Last Modified On : Mon Nov 28 12:27:26 2016
+// Update Count     : 0
 //
 // This  library is free  software; you  can redistribute  it and/or  modify it

src/libcfa/concurrency/alarm.c

-              r33218c6
+              re0a653d
+//                              -*- Mode: CFA -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Fri Jun 2 11:31:25 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:35:18 2017
 // Update Count     : 1
+// Last Modified By : Thierry Delisle
+// Last Modified On : --
+// Update Count     : 0
 //
 …
 //=============================================================================================
-// time type
-//=============================================================================================
-#define one_second         1_000_000_000ul
-#define one_milisecond         1_000_000ul
-#define one_microsecond            1_000ul
-#define one_nanosecond                 1ul
-__cfa_time_t zero_time = { 0 };
-void ?{}( __cfa_time_t * this ) { this->val = 0; }
-void ?{}( __cfa_time_t * this, zero_t zero ) { this->val = 0; }
-void ?{}( itimerval * this, __cfa_time_t * alarm ) {
-        this->it_value.tv_sec = alarm->val / one_second;                        // seconds
-        this->it_value.tv_usec = max( (alarm->val % one_second) / one_microsecond, 1000 ); // microseconds
-        this->it_interval.tv_sec = 0;
-        this->it_interval.tv_usec = 0;
+}
-void ?{}( __cfa_time_t * this, timespec * curr ) {
-        uint64_t secs  = curr->tv_sec;
-        uint64_t nsecs = curr->tv_nsec;
-        this->val = (secs * one_second) + nsecs;
+}
-__cfa_time_t ?=?( __cfa_time_t * this, zero_t rhs ) {
-        this->val = 0;
-        return *this;
+}
-__cfa_time_t from_s ( uint64_t val ) { __cfa_time_t ret; ret.val = val * 1_000_000_000ul; return ret; }
-__cfa_time_t from_ms( uint64_t val ) { __cfa_time_t ret; ret.val = val *     1_000_000ul; return ret; }
-__cfa_time_t from_us( uint64_t val ) { __cfa_time_t ret; ret.val = val *         1_000ul; return ret; }
-__cfa_time_t from_ns( uint64_t val ) { __cfa_time_t ret; ret.val = val *             1ul; return ret; }
-//=============================================================================================
 // Clock logic
 //=============================================================================================
 …
         timespec curr;
         clock_gettime( CLOCK_REALTIME, &curr );
+        return (__cfa_time_t){ &curr };
+        __cfa_time_t curr_time = ((__cfa_time_t)curr.tv_sec * TIMEGRAN) + curr.tv_nsec;
+        // LIB_DEBUG_PRINT_BUFFER_DECL( STDERR_FILENO, "Kernel : current time is %lu\n", curr_time );
+        return curr_time;
+}
 void __kernel_set_timer( __cfa_time_t alarm ) {
+        itimerval val = { &alarm };
+        LIB_DEBUG_PRINT_BUFFER_DECL( STDERR_FILENO, "Kernel : set timer to %lu\n", (__cfa_time_t)alarm );
+        itimerval val;
+        val.it_value.tv_sec = alarm / TIMEGRAN;                 // seconds
+        val.it_value.tv_usec = (alarm % TIMEGRAN) / ( TIMEGRAN / 1_000_000L ); // microseconds
+        val.it_interval.tv_sec = 0;
+        val.it_interval.tv_usec = 0;
         setitimer( ITIMER_REAL, &val, NULL );
+}
 …
 //=============================================================================================
 void ?{}( alarm_node_t * this, thread_desc * thrd, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ) {
+void ?{}( alarm_node_t * this, thread_desc * thrd, __cfa_time_t alarm = 0, __cfa_time_t period = 0 ) {
         this->thrd = thrd;
         this->alarm = alarm;
 …
+}
 void ?{}( alarm_node_t * this, processor   * proc, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ) {
+void ?{}( alarm_node_t * this, processor   * proc, __cfa_time_t alarm = 0, __cfa_time_t period = 0 ) {
         this->proc = proc;
         this->alarm = alarm;
 …
 void register_self( alarm_node_t * this ) {
+        alarm_list_t * alarms = &event_kernel->alarms;
+        disable_interrupts();
+        verify( !systemProcessor->pending_alarm );
+        lock( &systemProcessor->alarm_lock DEBUG_CTX2 );
+        {
+                verify( validate( &systemProcessor->alarms ) );
+                bool first = !systemProcessor->alarms.head;
+        disable_interrupts();
+        lock( &event_kernel->lock DEBUG_CTX2 );
+        {
+                verify( validate( alarms ) );
+                bool first = !alarms->head;
+                insert( alarms, this );
+                insert( &systemProcessor->alarms, this );
+                if( systemProcessor->pending_alarm ) {
+                        tick_preemption();
+                }
                 if( first ) {
                         __kernel_set_timer( alarms->head->alarm - __kernel_get_time() );
+                        __kernel_set_timer( systemProcessor->alarms.head->alarm - __kernel_get_time() );
+                }
+        }
         unlock( &event_kernel->lock );
+        unlock( &systemProcessor->alarm_lock );
         this->set = true;
         enable_interrupts( DEBUG_CTX );
 …
 void unregister_self( alarm_node_t * this ) {
+        // LIB_DEBUG_PRINT_BUFFER_DECL( STDERR_FILENO, "Kernel : unregister %p start\n", this );
         disable_interrupts();
         lock( &event_kernel->lock DEBUG_CTX2 );
+        lock( &systemProcessor->alarm_lock DEBUG_CTX2 );
+        {
                 verify( validate( &event_kernel->alarms ) );
                 remove( &event_kernel->alarms, this );
+                verify( validate( &systemProcessor->alarms ) );
+                remove( &systemProcessor->alarms, this );
+        }
         unlock( &event_kernel->lock );
+        unlock( &systemProcessor->alarm_lock );
         enable_interrupts( DEBUG_CTX );
         this->set = false;
+        // LIB_DEBUG_PRINT_BUFFER_LOCAL( STDERR_FILENO, "Kernel : unregister %p end\n", this );
+}
-// Local Variables: //
-// mode: c //
-// tab-width: 4 //
-// End: //

src/libcfa/concurrency/alarm.h

-              r33218c6
+              re0a653d
+//                              -*- Mode: CFA -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Fri Jun 2 11:31:25 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:59:27 2017
 // Update Count     : 3
+// Last Modified By : Thierry Delisle
+// Last Modified On : --
+// Update Count     : 0
 //
+#pragma once
+#ifndef ALARM_H
+#define ALARM_H
 #include <stdbool.h>
-#include <stdint.h>
+#include <assert.h>
+#include "assert"
+typedef unsigned long int __cfa_time_t;
 struct thread_desc;
 struct processor;
-struct timespec;
-struct itimerval;
-//=============================================================================================
-// time type
-//=============================================================================================
-struct __cfa_time_t {
-        uint64_t val;
-};
-// ctors
-void ?{}( __cfa_time_t * this );
-void ?{}( __cfa_time_t * this, zero_t zero );
-void ?{}( __cfa_time_t * this, timespec * curr );
-void ?{}( itimerval * this, __cfa_time_t * alarm );
-__cfa_time_t ?=?( __cfa_time_t * this, zero_t rhs );
-// logical ops
-static inline bool ?==?( __cfa_time_t lhs, __cfa_time_t rhs ) { return lhs.val == rhs.val; }
-static inline bool ?!=?( __cfa_time_t lhs, __cfa_time_t rhs ) { return lhs.val != rhs.val; }
-static inline bool ?>? ( __cfa_time_t lhs, __cfa_time_t rhs ) { return lhs.val >  rhs.val; }
-static inline bool ?<? ( __cfa_time_t lhs, __cfa_time_t rhs ) { return lhs.val <  rhs.val; }
-static inline bool ?>=?( __cfa_time_t lhs, __cfa_time_t rhs ) { return lhs.val >= rhs.val; }
-static inline bool ?<=?( __cfa_time_t lhs, __cfa_time_t rhs ) { return lhs.val <= rhs.val; }
-static inline bool ?==?( __cfa_time_t lhs, zero_t rhs ) { return lhs.val == rhs; }
-static inline bool ?!=?( __cfa_time_t lhs, zero_t rhs ) { return lhs.val != rhs; }
-static inline bool ?>? ( __cfa_time_t lhs, zero_t rhs ) { return lhs.val >  rhs; }
-static inline bool ?<? ( __cfa_time_t lhs, zero_t rhs ) { return lhs.val <  rhs; }
-static inline bool ?>=?( __cfa_time_t lhs, zero_t rhs ) { return lhs.val >= rhs; }
-static inline bool ?<=?( __cfa_time_t lhs, zero_t rhs ) { return lhs.val <= rhs; }
-// addition/substract
-static inline __cfa_time_t ?+?( __cfa_time_t lhs, __cfa_time_t rhs ) {
-        __cfa_time_t ret;
-        ret.val = lhs.val + rhs.val;
-        return ret;
+}
-static inline __cfa_time_t ?-?( __cfa_time_t lhs, __cfa_time_t rhs ) {
-        __cfa_time_t ret;
-        ret.val = lhs.val - rhs.val;
-        return ret;
+}
-__cfa_time_t from_s ( uint64_t );
-__cfa_time_t from_ms( uint64_t );
-__cfa_time_t from_us( uint64_t );
-__cfa_time_t from_ns( uint64_t );
-extern __cfa_time_t zero_time;
 //=============================================================================================
 // Clock logic
 //=============================================================================================
+#define TIMEGRAN 1_000_000_000L                         // nanosecond granularity, except for timeval
 __cfa_time_t __kernel_get_time();
 …
 typedef alarm_node_t ** __alarm_it_t;
 void ?{}( alarm_node_t * this, thread_desc * thrd, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time );
 void ?{}( alarm_node_t * this, processor   * proc, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time );
+void ?{}( alarm_node_t * this, thread_desc * thrd, __cfa_time_t alarm = 0, __cfa_time_t period = 0 );
+void ?{}( alarm_node_t * this, processor   * proc, __cfa_time_t alarm = 0, __cfa_time_t period = 0 );
 void ^?{}( alarm_node_t * this );
 …
 void unregister_self( alarm_node_t * this );
+#endif
 // Local Variables: //
 // mode: c //
+// mode: CFA //
 // tab-width: 6 //
 // End: //

src/libcfa/concurrency/coroutine

-              r33218c6
+              re0a653d
 // Author           : Thierry Delisle
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:57:17 2017
 // Update Count     : 2
+// Last Modified By : Thierry Delisle
+// Last Modified On : Mon Nov 28 12:27:26 2016
+// Update Count     : 0
 //
+#pragma once
+#ifndef COROUTINES_H
+#define COROUTINES_H
 #include <assert.h>
+#include "assert"
 #include "invoke.h"
 …
 // Get current coroutine
 extern thread_local coroutine_desc * volatile this_coroutine;
+extern volatile thread_local coroutine_desc * this_coroutine;
 // Private wrappers for context switch and stack creation
 …
+}
+#endif //COROUTINES_H
 // Local Variables: //
 // mode: c //

src/libcfa/concurrency/coroutine.c

-              r33218c6
+              re0a653d
+//                              -*- Mode: CFA -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:34:57 2017
 // Update Count     : 1
+// Last Modified By : Thierry Delisle
+// Last Modified On : Mon Nov 28 12:27:26 2016
+// Update Count     : 0
 //
 …
+}
+#include "kernel_private.h"
+#include "kernel"
+#include "libhdr.h"
 #define __CFA_INVOKE_PRIVATE__
 #include "invoke.h"
+extern volatile thread_local processor * this_processor;
 //-----------------------------------------------------------------------------

src/libcfa/concurrency/invoke.c

-              r33218c6
+              re0a653d
+//                              -*- Mode: C -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Tue Jan 17 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:28:33 2017
 // Update Count     : 1
+// Last Modified By : Thierry Delisle
+// Last Modified On : --
+// Update Count     : 0
 //
 …
 #endif
+}
-// Local Variables: //
-// mode: c //
-// tab-width: 4 //
-// End: //

src/libcfa/concurrency/invoke.h

-              r33218c6
+              re0a653d
+//                              -*- Mode: C -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Tue Jan 17 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:28:56 2017
 // Update Count     : 1
+// Last Modified By : Thierry Delisle
+// Last Modified On : --
+// Update Count     : 0
 //
 …
+}
 #endif
-// Local Variables: //
-// mode: c //
-// tab-width: 4 //
-// End: //

src/libcfa/concurrency/kernel

-              r33218c6
+              re0a653d
+//                              -*- Mode: CFA -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:58:39 2017
 // Update Count     : 2
+// Last Modified By : Thierry Delisle
+// Last Modified On : --
+// Update Count     : 0
 //
+#pragma once
+#ifndef KERNEL_H
+#define KERNEL_H
 #include <stdbool.h>
 …
 //-----------------------------------------------------------------------------
 // Locks
+void lock      ( spinlock * DEBUG_CTX_PARAM2 );       // Lock the spinlock, spin if already acquired
 void lock_yield( spinlock * DEBUG_CTX_PARAM2 );       // Lock the spinlock, yield repeatedly if already acquired
+bool try_lock  ( spinlock * DEBUG_CTX_PARAM2 );       // Lock the spinlock, return false if already acquired
 void unlock    ( spinlock * );                        // Unlock the spinlock
+bool try_lock  ( spinlock * DEBUG_CTX_PARAM2 );
+void lock      ( spinlock * DEBUG_CTX_PARAM2 );
+void lock_yield( spinlock * DEBUG_CTX_PARAM2 );
+void unlock    ( spinlock * );
 struct semaphore {
 …
 // Cluster
 struct cluster {
+        spinlock ready_queue_lock;                      // Ready queue locks
+        __thread_queue_t ready_queue;                   // Ready queue for threads
+        unsigned long long int preemption;              // Preemption rate on this cluster
+        __thread_queue_t ready_queue;
+        spinlock lock;
 };
 …
 static inline void ^?{}(FinishAction * this) {}
-// Processor
-// Wrapper around kernel threads
 struct processor {
+        // Main state
+        struct processorCtx_t * runner;                 // Coroutine ctx who does keeps the state of the processor
+        cluster * cltr;                                 // Cluster from which to get threads
+        pthread_t kernel_thread;                        // Handle to pthreads
+        struct processorCtx_t * runner;
+        cluster * cltr;
+        pthread_t kernel_thread;
+        // Termination
+        volatile bool do_terminate;                     // Set to true to notify the processor should terminate
+        semaphore terminated;                           // Termination synchronisation
+        semaphore terminated;
+        volatile bool is_terminated;
+        // RunThread data
+        struct FinishAction finish;                     // Action to do after a thread is ran
+        struct FinishAction finish;
+        // Preemption data
+        struct alarm_node_t * preemption_alarm;         // Node which is added in the discrete event simulaiton
+        bool pending_preemption;                        // If true, a preemption was triggered in an unsafe region, the processor must preempt as soon as possible
+        struct alarm_node_t * preemption_alarm;
+        unsigned int preemption;
+#ifdef __CFA_DEBUG__
+        char * last_enable;                             // Last function to enable preemption on this processor
+#endif
+        bool pending_preemption;
+        char * last_enable;
 };
 …
 void ^?{}(processor * this);
+#endif //KERNEL_H
 // Local Variables: //
 // mode: c //
 // tab-width: 4 //
+// mode: CFA //
+// tab-width: 6 //
 // End: //

src/libcfa/concurrency/kernel.c

-              r33218c6
+              re0a653d
+//                              -*- Mode: CFA -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:33:18 2017
 // Update Count     : 2
+// Last Modified By : Thierry Delisle
+// Last Modified On : --
+// Update Count     : 0
 //
 …
 //-----------------------------------------------------------------------------
 // Kernel storage
+KERNEL_STORAGE(cluster,           mainCluster);
+KERNEL_STORAGE(processor,         mainProcessor);
+KERNEL_STORAGE(processorCtx_t,    mainProcessorCtx);
+KERNEL_STORAGE(thread_desc,       mainThread);
+#define KERNEL_STORAGE(T,X) static char X##Storage[sizeof(T)]
+KERNEL_STORAGE(processorCtx_t, systemProcessorCtx);
+KERNEL_STORAGE(cluster, systemCluster);
+KERNEL_STORAGE(system_proc_t, systemProcessor);
+KERNEL_STORAGE(thread_desc, mainThread);
 KERNEL_STORAGE(machine_context_t, mainThreadCtx);
 cluster *     mainCluster;
 processor *   mainProcessor;
+cluster * systemCluster;
+system_proc_t * systemProcessor;
 thread_desc * mainThread;
 …
 // Global state
+thread_local coroutine_desc * volatile this_coroutine;
+thread_local thread_desc *    volatile this_thread;
+thread_local processor *      volatile this_processor;
+volatile thread_local bool preemption_in_progress = 0;
+volatile thread_local processor * this_processor;
+volatile thread_local coroutine_desc * this_coroutine;
+volatile thread_local thread_desc * this_thread;
 volatile thread_local unsigned short disable_preempt_count = 1;
 …
         this->limit = (void *)(((intptr_t)this->base) - this->size);
         this->context = &storage_mainThreadCtx;
+        this->context = &mainThreadCtxStorage;
         this->top = this->base;
+}
 …
 void ?{}(processor * this) {
         this{ mainCluster };
+        this{ systemCluster };
+}
 …
         this->cltr = cltr;
         (&this->terminated){ 0 };
         this->do_terminate = false;
+        this->is_terminated = false;
         this->preemption_alarm = NULL;
+        this->preemption = default_preemption();
         this->pending_preemption = false;
 …
         this->cltr = cltr;
         (&this->terminated){ 0 };
         this->do_terminate = false;
+        this->is_terminated = false;
         this->preemption_alarm = NULL;
+        this->preemption = default_preemption();
         this->pending_preemption = false;
         this->kernel_thread = pthread_self();
         this->runner = runner;
         LIB_DEBUG_PRINT_SAFE("Kernel : constructing main processor context %p\n", runner);
+        LIB_DEBUG_PRINT_SAFE("Kernel : constructing system processor context %p\n", runner);
         runner{ this };
+}
+LIB_DEBUG_DO( bool validate( alarm_list_t * this ); )
+void ?{}(system_proc_t * this, cluster * cltr, processorCtx_t * runner) {
+        (&this->alarms){};
+        (&this->alarm_lock){};
+        this->pending_alarm = false;
+        (&this->proc){ cltr, runner };
+        verify( validate( &this->alarms ) );
+}
 void ^?{}(processor * this) {
         if( ! this->do_terminate ) {
+        if( ! this->is_terminated ) {
                 LIB_DEBUG_PRINT_SAFE("Kernel : core %p signaling termination\n", this);
                 this->do_terminate = true;
+                this->is_terminated = true;
                 P( &this->terminated );
                 pthread_join( this->kernel_thread, NULL );
 …
 void ?{}(cluster * this) {
         ( &this->ready_queue ){};
+        ( &this->ready_queue_lock ){};
+        this->preemption = default_preemption();
+        ( &this->lock ){};
+}
 …
                 thread_desc * readyThread = NULL;
                 for( unsigned int spin_count = 0; ! this->do_terminate; spin_count++ )
+                for( unsigned int spin_count = 0; ! this->is_terminated; spin_count++ )
+                {
                         readyThread = nextThread( this->cltr );
 …
         verifyf( thrd->next == NULL, "Expected null got %p", thrd->next );
         lock(   &this_processor->cltr->ready_queue_lock DEBUG_CTX2 );
         append( &this_processor->cltr->ready_queue, thrd );
         unlock( &this_processor->cltr->ready_queue_lock );
+        lock( &systemProcessor->proc.cltr->lock DEBUG_CTX2 );
+        append( &systemProcessor->proc.cltr->ready_queue, thrd );
+        unlock( &systemProcessor->proc.cltr->lock );
         verify( disable_preempt_count > 0 );
 …
 thread_desc * nextThread(cluster * this) {
         verify( disable_preempt_count > 0 );
         lock( &this->ready_queue_lock DEBUG_CTX2 );
+        lock( &this->lock DEBUG_CTX2 );
         thread_desc * head = pop_head( &this->ready_queue );
         unlock( &this->ready_queue_lock );
+        unlock( &this->lock );
         verify( disable_preempt_count > 0 );
         return head;
 …
         // Start by initializing the main thread
         // SKULLDUGGERY: the mainThread steals the process main thread
         // which will then be scheduled by the mainProcessor normally
         mainThread = (thread_desc *)&storage_mainThread;
+        // which will then be scheduled by the systemProcessor normally
+        mainThread = (thread_desc *)&mainThreadStorage;
         current_stack_info_t info;
         mainThread{ &info };
 …
         LIB_DEBUG_PRINT_SAFE("Kernel : Main thread ready\n");
         // Initialize the main cluster
         mainCluster = (cluster *)&storage_mainCluster;
         mainCluster{};
         LIB_DEBUG_PRINT_SAFE("Kernel : main cluster ready\n");
         // Initialize the main processor and the main processor ctx
+        // Initialize the system cluster
+        systemCluster = (cluster *)&systemClusterStorage;
+        systemCluster{};
+        LIB_DEBUG_PRINT_SAFE("Kernel : System cluster ready\n");
+        // Initialize the system processor and the system processor ctx
         // (the coroutine that contains the processing control flow)
+        mainProcessor = (processor *)&storage_mainProcessor;
+        mainProcessor{ mainCluster, (processorCtx_t *)&storage_mainProcessorCtx };
+        systemProcessor = (system_proc_t *)&systemProcessorStorage;
+        systemProcessor{ systemCluster, (processorCtx_t *)&systemProcessorCtxStorage };
+        // Add the main thread to the ready queue
+        // once resume is called on systemProcessor->runner the mainThread needs to be scheduled like any normal thread
+        ScheduleThread(mainThread);
         //initialize the global state variables
         this_processor = mainProcessor;
+        this_processor = &systemProcessor->proc;
         this_thread = mainThread;
         this_coroutine = &mainThread->cor;
+        disable_preempt_count = 1;
         // Enable preemption
         kernel_start_preemption();
+        // Add the main thread to the ready queue
+        // once resume is called on mainProcessor->runner the mainThread needs to be scheduled like any normal thread
+        ScheduleThread(mainThread);
+        // SKULLDUGGERY: Force a context switch to the main processor to set the main thread's context to the current UNIX
+        // SKULLDUGGERY: Force a context switch to the system processor to set the main thread's context to the current UNIX
         // context. Hence, the main thread does not begin through CtxInvokeThread, like all other threads. The trick here is that
         // mainThread is on the ready queue when this call is made.
         resume( mainProcessor->runner );
+        resume( systemProcessor->proc.runner );
 …
         disable_interrupts();
         // SKULLDUGGERY: Notify the mainProcessor it needs to terminates.
+        // SKULLDUGGERY: Notify the systemProcessor it needs to terminates.
         // When its coroutine terminates, it return control to the mainThread
         // which is currently here
         mainProcessor->do_terminate = true;
+        systemProcessor->proc.is_terminated = true;
         suspend();
 …
         kernel_stop_preemption();
         // Destroy the main processor and its context in reverse order of construction
+        // Destroy the system processor and its context in reverse order of construction
         // These were manually constructed so we need manually destroy them
         ^(mainProcessor->runner){};
         ^(mainProcessor){};
+        ^(systemProcessor->proc.runner){};
+        ^(systemProcessor){};
         // Final step, destroy the main thread since it is no longer needed
 …
         return top;
+}
 // Local Variables: //
 // mode: c //

src/libcfa/concurrency/kernel_private.h

-              r33218c6
+              re0a653d
+//                              -*- Mode: CFA -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Mon Feb 13 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:58:09 2017
 // Update Count     : 2
+// Last Modified By : Thierry Delisle
+// Last Modified On : --
+// Update Count     : 0
 //
+#pragma once
+#ifndef KERNEL_PRIVATE_H
+#define KERNEL_PRIVATE_H
 #include "libhdr.h"
 …
 extern "C" {
         void disable_interrupts();
         void enable_interrupts_noPoll();
+        void enable_interrupts_noRF();
         void enable_interrupts( DEBUG_CTX_PARAM );
+}
 …
 thread_desc * nextThread(cluster * this);
-//Block current thread and release/wake-up the following resources
 void BlockInternal(void);
 void BlockInternal(spinlock * lock);
 …
 void spin(processor * this, unsigned int * spin_count);
+struct event_kernel_t {
+struct system_proc_t {
+        processor proc;
         alarm_list_t alarms;
+        spinlock lock;
+        spinlock alarm_lock;
+        bool pending_alarm;
 };
+extern event_kernel_t * event_kernel;
+extern thread_local coroutine_desc * volatile this_coroutine;
+extern thread_local thread_desc *    volatile this_thread;
+extern thread_local processor *      volatile this_processor;
+extern volatile thread_local bool preemption_in_progress;
+extern cluster * systemCluster;
+extern system_proc_t * systemProcessor;
+extern volatile thread_local processor * this_processor;
+extern volatile thread_local coroutine_desc * this_coroutine;
+extern volatile thread_local thread_desc * this_thread;
 extern volatile thread_local unsigned short disable_preempt_count;
 …
 extern void ThreadCtxSwitch(coroutine_desc * src, coroutine_desc * dst);
+//-----------------------------------------------------------------------------
+// Utils
+#define KERNEL_STORAGE(T,X) static char storage_##X[sizeof(T)]
+#endif //KERNEL_PRIVATE_H
 // Local Variables: //

src/libcfa/concurrency/monitor

-              r33218c6
+              re0a653d
+//                              -*- Mode: CFA -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Thd Feb 23 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:59:01 2017
 // Update Count     : 3
+// Last Modified By : Thierry Delisle
+// Last Modified On : --
+// Update Count     : 0
 //
+#pragma once
+#ifndef MONITOR_H
+#define MONITOR_H
 #include <stddef.h>
 #include <assert.h>
+#include "assert"
 #include "invoke.h"
 #include "stdlib"
 …
 void __accept_internal( unsigned short count, __acceptable_t * acceptables, void (*func)(void) );
+// Local Variables: //
+// mode: c //
+// tab-width: 4 //
+// End: //
+#endif //MONITOR_H

src/libcfa/concurrency/monitor.c

-              r33218c6
+              re0a653d
+//                              -*- Mode: CFA -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Thd Feb 23 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:37:11 2017
 // Update Count     : 1
+// Last Modified By : Thierry Delisle
+// Last Modified On : --
+// Update Count     : 0
 //
 …
         return head;
+}
-// Local Variables: //
-// mode: c //
-// tab-width: 4 //
-// End: //

src/libcfa/concurrency/preemption.c

-              r33218c6
+              re0a653d
+//                              -*- Mode: CFA -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Mon Jun 5 14:20:42 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:36:05 2017
 // Update Count     : 2
+// Last Modified By : Thierry Delisle
+// Last Modified On : --
+// Update Count     : 0
 //
 …
 #endif
-//TODO move to defaults
 #define __CFA_DEFAULT_PREEMPTION__ 10000
-//TODO move to defaults
 __attribute__((weak)) unsigned int default_preemption() {
         return __CFA_DEFAULT_PREEMPTION__;
+}
-// Short hands for signal context information
 #define __CFA_SIGCXT__ ucontext_t *
 #define __CFA_SIGPARMS__ __attribute__((unused)) int sig, __attribute__((unused)) siginfo_t *sfp, __attribute__((unused)) __CFA_SIGCXT__ cxt
-// FwdDeclarations : timeout handlers
 static void preempt( processor   * this );
 static void timeout( thread_desc * this );
-// FwdDeclarations : Signal handlers
 void sigHandler_ctxSwitch( __CFA_SIGPARMS__ );
+void sigHandler_alarm    ( __CFA_SIGPARMS__ );
 void sigHandler_segv     ( __CFA_SIGPARMS__ );
 void sigHandler_abort    ( __CFA_SIGPARMS__ );
-// FwdDeclarations : sigaction wrapper
 static void __kernel_sigaction( int sig, void (*handler)(__CFA_SIGPARMS__), int flags );
+// FwdDeclarations : alarm thread main
+void * alarm_loop( __attribute__((unused)) void * args );
+// Machine specific register name
+LIB_DEBUG_DO( bool validate( alarm_list_t * this ); )
 #ifdef __x86_64__
 #define CFA_REG_IP REG_RIP
 …
 #endif
-KERNEL_STORAGE(event_kernel_t, event_kernel);         // private storage for event kernel
-event_kernel_t * event_kernel;                        // kernel public handle to even kernel
-static pthread_t alarm_thread;                        // pthread handle to alarm thread
-void ?{}(event_kernel_t * this) {
-        (&this->alarms){};
-        (&this->lock){};
+}
 //=============================================================================================
 …
 //=============================================================================================
-// Get next expired node
-static inline alarm_node_t * get_expired( alarm_list_t * alarms, __cfa_time_t currtime ) {
-        if( !alarms->head ) return NULL;                          // If no alarms return null
-        if( alarms->head->alarm >= currtime ) return NULL;        // If alarms head not expired return null
-        return pop(alarms);                                       // Otherwise just pop head
+}
-// Tick one frame of the Discrete Event Simulation for alarms
 void tick_preemption() {
         alarm_node_t * node = NULL;                     // Used in the while loop but cannot be declared in the while condition
+        alarm_list_t * alarms = &event_kernel->alarms;  // Local copy for ease of reading
         __cfa_time_t currtime = __kernel_get_time();    // Check current time once so we everything "happens at once"
         //Loop throught every thing expired
         while( node = get_expired( alarms, currtime ) ) {
+                // Check if this is a kernel
+        // LIB_DEBUG_PRINT_BUFFER_DECL( STDERR_FILENO, "Ticking preemption\n" );
+        alarm_list_t * alarms = &systemProcessor->alarms;
+        __cfa_time_t currtime = __kernel_get_time();
+        while( alarms->head && alarms->head->alarm < currtime ) {
+                alarm_node_t * node = pop(alarms);
+                // LIB_DEBUG_PRINT_BUFFER_LOCAL( STDERR_FILENO, "Ticking %p\n", node );
                 if( node->kernel_alarm ) {
                         preempt( node->proc );
 …
+                }
                 // Check if this is a periodic alarm
+                __cfa_time_t period = node->period;
                 if( period > 0 ) {
                         node->alarm = currtime + period;    // Alarm is periodic, add currtime to it (used cached current time)
                         insert( alarms, node );             // Reinsert the node for the next time it triggers
+                verify( validate( alarms ) );
+                if( node->period > 0 ) {
+                        node->alarm = currtime + node->period;
+                        insert( alarms, node );
+                }
                 else {
+                        node->set = false;                  // Node is one-shot, just mark it as not pending
+                }
+        }
+        // If there are still alarms pending, reset the timer
+        if( alarms->head ) { __kernel_set_timer( alarms->head->alarm - currtime ); }
+}
+// Update the preemption of a processor and notify interested parties
+                        node->set = false;
+                }
+        }
+        if( alarms->head ) {
+                __kernel_set_timer( alarms->head->alarm - currtime );
+        }
+        verify( validate( alarms ) );
+        // LIB_DEBUG_PRINT_BUFFER_LOCAL( STDERR_FILENO, "Ticking preemption done\n" );
+}
 void update_preemption( processor * this, __cfa_time_t duration ) {
+        LIB_DEBUG_PRINT_BUFFER_DECL( STDERR_FILENO, "Processor : %p updating preemption to %lu\n", this, duration );
         alarm_node_t * alarm = this->preemption_alarm;
+        duration *= 1000;
         // Alarms need to be enabled
 …
 extern "C" {
-        // Disable interrupts by incrementing the counter
         void disable_interrupts() {
                 __attribute__((unused)) unsigned short new_val = __atomic_add_fetch_2( &disable_preempt_count, 1, __ATOMIC_SEQ_CST );
+                verify( new_val < 65_000u );              // If this triggers someone is disabling interrupts without enabling them
+        }
+        // Enable interrupts by decrementing the counter
+        // If counter reaches 0, execute any pending CtxSwitch
+                verify( new_val < (unsigned short)65_000 );
+                verify( new_val != (unsigned short) 0 );
+        }
+        void enable_interrupts_noRF() {
+                __attribute__((unused)) unsigned short prev = __atomic_fetch_add_2( &disable_preempt_count, -1, __ATOMIC_SEQ_CST );
+                verify( prev != (unsigned short) 0 );
+        }
         void enable_interrupts( DEBUG_CTX_PARAM ) {
+                processor * proc   = this_processor;      // Cache the processor now since interrupts can start happening after the atomic add
+                thread_desc * thrd = this_thread;         // Cache the thread now since interrupts can start happening after the atomic add
+                processor * proc   = this_processor;
+                thread_desc * thrd = this_thread;
                 unsigned short prev = __atomic_fetch_add_2( &disable_preempt_count, -1, __ATOMIC_SEQ_CST );
+                verify( prev != 0u );                     // If this triggers someone is enabled already enabled interruptsverify( prev != 0u );
+                // Check if we need to prempt the thread because an interrupt was missed
+                verify( prev != (unsigned short) 0 );
                 if( prev == 1 && proc->pending_preemption ) {
                         proc->pending_preemption = false;
 …
+                }
-                // For debugging purposes : keep track of the last person to enable the interrupts
                 LIB_DEBUG_DO( proc->last_enable = caller; )
+        }
+        // Disable interrupts by incrementint the counter
+        // Don't execute any pending CtxSwitch even if counter reaches 0
+        void enable_interrupts_noPoll() {
+                __attribute__((unused)) unsigned short prev = __atomic_fetch_add_2( &disable_preempt_count, -1, __ATOMIC_SEQ_CST );
+                verify( prev != 0u );                     // If this triggers someone is enabled already enabled interrupts
+        }
+}
+// sigprocmask wrapper : unblock a single signal
+}
 static inline void signal_unblock( int sig ) {
         sigset_t mask;
 …
+}
-// sigprocmask wrapper : block a single signal
 static inline void signal_block( int sig ) {
         sigset_t mask;
 …
+}
+// kill wrapper : signal a processor
+static inline bool preemption_ready() {
+        return disable_preempt_count == 0;
+}
+static inline void defer_ctxSwitch() {
+        this_processor->pending_preemption = true;
+}
+static inline void defer_alarm() {
+        systemProcessor->pending_alarm = true;
+}
 static void preempt( processor * this ) {
         pthread_kill( this->kernel_thread, SIGUSR1 );
+}
-// reserved for future use
 static void timeout( thread_desc * this ) {
         //TODO : implement waking threads
+}
-// Check if a CtxSwitch signal handler shoud defer
-// If true  : preemption is safe
-// If false : preemption is unsafe and marked as pending
-static inline bool preemption_ready() {
-        bool ready = disable_preempt_count == 0 && !preemption_in_progress; // Check if preemption is safe
-        this_processor->pending_preemption = !ready;                        // Adjust the pending flag accordingly
-        return ready;
+}
 //=============================================================================================
 // Kernel Signal Startup/Shutdown logic
 //=============================================================================================
+// Startup routine to activate preemption
+// Called from kernel_startup
+static pthread_t alarm_thread;
+void * alarm_loop( __attribute__((unused)) void * args );
 void kernel_start_preemption() {
         LIB_DEBUG_PRINT_SAFE("Kernel : Starting preemption\n");
+        // Start with preemption disabled until ready
+        disable_preempt_count = 1;
+        // Initialize the event kernel
+        event_kernel = (event_kernel_t *)&storage_event_kernel;
+        event_kernel{};
+        // Setup proper signal handlers
+        __kernel_sigaction( SIGUSR1, sigHandler_ctxSwitch, SA_SIGINFO );         // CtxSwitch handler
+        // __kernel_sigaction( SIGSEGV, sigHandler_segv     , SA_SIGINFO );      // Failure handler
+        // __kernel_sigaction( SIGBUS , sigHandler_segv     , SA_SIGINFO );      // Failure handler
+        __kernel_sigaction( SIGUSR1, sigHandler_ctxSwitch, SA_SIGINFO );
+        // __kernel_sigaction( SIGSEGV, sigHandler_segv     , SA_SIGINFO );
+        // __kernel_sigaction( SIGBUS , sigHandler_segv     , SA_SIGINFO );
         signal_block( SIGALRM );
 …
+}
-// Shutdown routine to deactivate preemption
-// Called from kernel_shutdown
 void kernel_stop_preemption() {
-        LIB_DEBUG_PRINT_SAFE("Kernel : Preemption stopping\n");
-        // Block all signals since we are already shutting down
         sigset_t mask;
         sigfillset( &mask );
         sigprocmask( SIG_BLOCK, &mask, NULL );
+        // Notify the alarm thread of the shutdown
+        sigval val = { 1 };
+        pthread_sigqueue( alarm_thread, SIGALRM, val );
+        // Wait for the preemption thread to finish
+        pthread_kill( alarm_thread, SIGINT );
         pthread_join( alarm_thread, NULL );
-        // Preemption is now fully stopped
         LIB_DEBUG_PRINT_SAFE("Kernel : Preemption stopped\n");
+}
-// Raii ctor/dtor for the preemption_scope
-// Used by thread to control when they want to receive preemption signals
 void ?{}( preemption_scope * this, processor * proc ) {
         (&this->alarm){ proc, zero_time, zero_time };
+        (&this->alarm){ proc };
         this->proc = proc;
         this->proc->preemption_alarm = &this->alarm;
+        update_preemption( this->proc, from_us(this->proc->cltr->preemption) );
+        update_preemption( this->proc, this->proc->preemption );
+}
 …
         disable_interrupts();
         update_preemption( this->proc, zero_time );
+        update_preemption( this->proc, 0 );
+}
 …
 //=============================================================================================
-// Context switch signal handler
-// Receives SIGUSR1 signal and causes the current thread to yield
 void sigHandler_ctxSwitch( __CFA_SIGPARMS__ ) {
         LIB_DEBUG_DO( last_interrupt = (void *)(cxt->uc_mcontext.gregs[CFA_REG_IP]); )
+        // Check if it is safe to preempt here
+        if( !preemption_ready() ) { return; }
+        preemption_in_progress = true;                      // Sync flag : prevent recursive calls to the signal handler
+        signal_unblock( SIGUSR1 );                          // We are about to CtxSwitch out of the signal handler, let other handlers in
+        preemption_in_progress = false;                     // Clear the in progress flag
+        // Preemption can occur here
+        BlockInternal( (thread_desc*)this_thread );         // Do the actual CtxSwitch
+}
+// Main of the alarm thread
+// Waits on SIGALRM and send SIGUSR1 to whom ever needs it
+        if( preemption_ready() ) {
+                signal_unblock( SIGUSR1 );
+                BlockInternal( (thread_desc*)this_thread );
+        }
+        else {
+                defer_ctxSwitch();
+        }
+}
+// void sigHandler_alarm( __CFA_SIGPARMS__ ) {
+//      LIB_DEBUG_DO( last_interrupt = (void *)(cxt->uc_mcontext.gregs[CFA_REG_IP]); )
+//      verify( this_processor == systemProcessor );
+//      if( try_lock( &systemProcessor->alarm_lock DEBUG_CTX2 ) ) {
+//              tick_preemption();
+//              systemProcessor->pending_alarm = false;
+//              unlock( &systemProcessor->alarm_lock );
+//      }
+//      else {
+//              defer_alarm();
+//      }
+//      signal_unblock( SIGALRM );
+//      if( preemption_ready() && this_processor->pending_preemption ) {
+//              this_processor->pending_preemption = false;
+//              BlockInternal( (thread_desc*)this_thread );
+//      }
+// }
 void * alarm_loop( __attribute__((unused)) void * args ) {
-        // Block sigalrms to control when they arrive
         sigset_t mask;
         sigemptyset( &mask );
         sigaddset( &mask, SIGALRM );
+        sigaddset( &mask, SIGUSR2 );
+        sigaddset( &mask, SIGINT  );
         if ( pthread_sigmask( SIG_BLOCK, &mask, NULL ) == -1 ) {
 …
+        }
-        // Main loop
         while( true ) {
+                // Wait for a sigalrm
+                siginfo_t info;
+                int sig = sigwaitinfo( &mask, &info );
+                // If another signal arrived something went wrong
+                assertf(sig == SIGALRM, "Kernel Internal Error, sigwait: Unexpected signal %d (%d : %d)\n", sig, info.si_code, info.si_value.sival_int);
+                LIB_DEBUG_PRINT_SAFE("Kernel : Caught alarm from %d with %d\n", info.si_code, info.si_value.sival_int );
+                // Switch on the code (a.k.a. the sender) to
+                switch( info.si_code )
+                {
+                // Timers can apparently be marked as sent for the kernel
+                // In either case, tick preemption
+                case SI_TIMER:
+                case SI_KERNEL:
+                        LIB_DEBUG_PRINT_SAFE("Kernel : Preemption thread tick\n");
+                        lock( &event_kernel->lock DEBUG_CTX2 );
+                        tick_preemption();
+                        unlock( &event_kernel->lock );
+                        break;
+                // Signal was not sent by the kernel but by an other thread
+                case SI_QUEUE:
+                        // For now, other thread only signal the alarm thread to shut it down
+                        // If this needs to change use info.si_value and handle the case here
+                        goto EXIT;
+                }
+        }
+EXIT:
+        LIB_DEBUG_PRINT_SAFE("Kernel : Preemption thread stopping\n");
+        return NULL;
+}
+// Sigaction wrapper : register an signal handler
+                int sig;
+                if( sigwait( &mask, &sig ) != 0  ) {
+                        abortf( "internal error, sigwait" );
+                }
+                switch( sig) {
+                        case SIGALRM:
+                                LIB_DEBUG_PRINT_SAFE("Kernel : Preemption thread tick\n");
+                                lock( &systemProcessor->alarm_lock DEBUG_CTX2 );
+                                tick_preemption();
+                                unlock( &systemProcessor->alarm_lock );
+                                break;
+                        case SIGUSR2:
+                                //TODO other actions
+                                break;
+                        case SIGINT:
+                                LIB_DEBUG_PRINT_SAFE("Kernel : Preemption thread stopping\n");
+                                return NULL;
+                        default:
+                                abortf( "internal error, sigwait returned sig %d", sig );
+                                break;
+                }
+        }
+}
 static void __kernel_sigaction( int sig, void (*handler)(__CFA_SIGPARMS__), int flags ) {
         struct sigaction act;
 …
+}
+// Sigaction wrapper : restore default handler
+typedef void (*sa_handler_t)(int);
 static void __kernel_sigdefault( int sig ) {
         struct sigaction act;
         act.sa_handler = SIG_DFL;
+        // act.sa_handler = SIG_DFL;
         act.sa_flags = 0;
         sigemptyset( &act.sa_mask );
 …
 //      raise( SIGABRT );
 // }
-// Local Variables: //
-// mode: c //
-// tab-width: 4 //
-// End: //

src/libcfa/concurrency/preemption.h

-              r33218c6
+              re0a653d
+//                              -*- Mode: CFA -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Mon Jun 5 14:20:42 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:34:25 2017
 // Update Count     : 1
+// Last Modified By : Thierry Delisle
+// Last Modified On : --
+// Update Count     : 0
 //
+#pragma once
+#ifndef PREEMPTION_H
+#define PREEMPTION_H
 #include "alarm.h"
 …
 void ^?{}( preemption_scope * this );
+// Local Variables: //
+// mode: c //
+// tab-width: 4 //
+// End: //
+#endif //PREEMPTION_H

src/libcfa/concurrency/thread

-              r33218c6
+              re0a653d
+//                              -*- Mode: CFA -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:59:40 2017
 // Update Count     : 3
+// Last Modified By : Thierry Delisle
+// Last Modified On : --
+// Update Count     : 0
 //
+#pragma once
+#ifndef THREADS_H
+#define THREADS_H
 #include <assert.h>
+#include "assert"
 #include "invoke.h"
 …
+}
 extern thread_local thread_desc * volatile this_thread;
+extern volatile thread_local thread_desc * this_thread;
 forall( dtype T | is_thread(T) )
 …
 void yield( unsigned times );
+#endif //THREADS_H
 // Local Variables: //
 // mode: c //

src/libcfa/concurrency/thread.c

-              r33218c6
+              re0a653d
+//                              -*- Mode: CFA -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:34:46 2017
 // Update Count     : 1
+// Last Modified By : Thierry Delisle
+// Last Modified On : --
+// Update Count     : 0
 //
 …
 void yield( void ) {
         BlockInternal( this_thread );
+        BlockInternal( (thread_desc *)this_thread );
+}

src/libcfa/containers/maybe

-              r33218c6
+              re0a653d
 // Author           : Andrew Beach
 // Created On       : Wed May 24 14:43:00 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 10:00:52 2017
 // Update Count     : 4
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Jun 16 15:42:00 2017
+// Update Count     : 2
 //
+#pragma once
+#ifndef MAYBE_H
+#define MAYBE_H
 #include <stdbool.h>
 …
 void set_none(maybe(T) * this);
+// Local Variables: //
+// mode: c //
+// tab-width: 4 //
+// End: //
+#endif // MAYBE_H

src/libcfa/containers/maybe.c

-              r33218c6
+              re0a653d
 // Author           : Andrew Beach
 // Created On       : Wed May 24 15:40:00 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jul 20 15:23:50 2017
 // Update Count     : 2
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr May 25 15:24:00 2017
+// Update Count     : 1
 //
 #include <containers/maybe>
 #include <assert.h>
+#include <assert>

src/libcfa/containers/pair

-              r33218c6
+              re0a653d
 // Author           : Aaron Moss
 // Created On       : Wed Apr 12 15:32:00 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:59:53 2017
 // Update Count     : 2
+// Last Modified By : Aaron Moss
+// Last Modified On : Wed Apr 12 15:32:00 2017
+// Update Count     : 1
 //
+#pragma once
+#ifndef PAIR_H
+#define PAIR_H
 forall(otype R, otype S) struct pair {
 …
 int ?>=?(pair(R, S) p, pair(R, S) q);
+#endif // PAIR_H
 // Local Variables: //
 // mode: c //

src/libcfa/containers/result

-              r33218c6
+              re0a653d
 // Author           : Andrew Beach
 // Created On       : Wed May 24 14:45:00 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 10:00:44 2017
 // Update Count     : 3
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Jun 16 15:41:00 2017
+// Update Count     : 2
 //
+#pragma once
+#ifndef RESULT_H
+#define RESULT_H
 #include <stdbool.h>
 …
 void set_error(result(T, E) * this, E error);
+// Local Variables: //
+// mode: c //
+// tab-width: 4 //
+// End: //
+#endif // RESULT_H

src/libcfa/containers/result.c

-              r33218c6
+              re0a653d
 // Author           : Andrew Beach
 // Created On       : Wed May 24 15:40:00 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jul 20 15:23:58 2017
 // Update Count     : 2
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr May 25 15:27:00 2017
+// Update Count     : 1
 //
 #include <containers/result>
 #include <assert.h>
+#include <assert>

src/libcfa/containers/vector

-              r33218c6
+              re0a653d
 // Created On       : Tue Jul  5 18:00:07 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 10:01:18 2017
 // Update Count     : 3
+// Last Modified On : Tue Jul  5 18:01:35 2016
+// Update Count     : 2
 //
+#pragma once
+#ifndef VECTOR_H
+#define VECTOR_H
 extern "C" {
 …
 // }
+#endif // VECTOR_H
 // Local Variables: //
 // mode: c //

src/libcfa/exception.h

-              r33218c6
+              re0a653d
 // Author           : Andrew Beach
 // Created On       : Mon Jun 26 15:11:00 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:57:02 2017
 // Update Count     : 3
+// Last Modified By : Andrew Beach
+// Last Modified On : Tus Jul 11 16:31:00 2017
+// Update Count     : 2
 //
+#pragma once
+#ifndef EXCEPTION_H
+#define EXCEPTION_H
 // Later to be a special structure type.
 …
+}
 #endif
+#endif //EXCEPTION_H

src/libcfa/fstream.c

-              r33218c6
+              re0a653d
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jul 20 15:20:49 2017
 // Update Count     : 252
+// Last Modified On : Thu Jul  6 18:38:25 2017
+// Update Count     : 251
 //
 #include "fstream"
+extern "C" {
 #include <stdio.h>                                                                              // vfprintf, vfscanf
 #include <stdlib.h>                                                                             // exit
 …
 #include <float.h>                                                                              // DBL_DIG, LDBL_DIG
 #include <complex.h>                                                                    // creal, cimag
+#include <assert.h>
+}
+#include "assert"
 #define IO_MSG "I/O error: "

src/libcfa/interpose.c

-              r33218c6
+              re0a653d
+//                              -*- Mode: CFA -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Wed Mar 29 16:10:31 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:27:33 2017
 // Update Count     : 1
+// Last Modified By :
+// Last Modified On :
+// Update Count     : 0
 //
 …
+        }
+}
-// Local Variables: //
-// mode: c //
-// tab-width: 4 //
-// End: //

src/libcfa/interpose.h

-              r33218c6
+              re0a653d
+//                              -*- Mode: CFA -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Wed Mar 29 15:56:41 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:33:02 2017
 // Update Count     : 2
+// Last Modified By :
+// Last Modified On :
+// Update Count     : 0
 //
+#pragma once
+#ifndef INTERPOSE_H
+#define INTERPOSE_H
 void * interpose_symbol( const char* symbol, , const char *version );
 …
 extern __typeof__( exit ) libc_abort __attribute__(( noreturn ));
+// Local Variables: //
+// mode: c //
+// tab-width: 4 //
+// End: //
+#endif //INTERPOSE_H

src/libcfa/iostream.c

-              r33218c6
+              re0a653d
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Jul 16 21:12:03 2017
 // Update Count     : 398
+// Last Modified On : Thu Jul  6 18:14:17 2017
+// Update Count     : 396
 //
 …
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype * os, float _Complex fc ) {
+        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+        fmt( os, "%g%+gi", crealf( fc ), cimagf( fc ) );
+        os | crealf( fc );
+        _Bool temp = sepDisable( os );                                          // disable separators within complex value
+        if ( cimagf( fc ) >= 0 ) os | '+';                                      // negative value prints '-'
+        os | cimagf( fc ) | 'i';
+        sepReset( os, temp );                                                           // reset separator
         return os;
 } // ?|?
 …
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype * os, double _Complex dc ) {
+        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+        fmt( os, "%.*lg%+.*lgi", DBL_DIG, creal( dc ), DBL_DIG, cimag( dc ) );
+        os | creal( dc );
+        _Bool temp = sepDisable( os );                                          // disable separators within complex value
+        if ( cimag( dc ) >= 0 ) os | '+';                                       // negative value prints '-'
+        os | cimag( dc ) | 'i';
+        sepReset( os, temp );                                                           // reset separator
         return os;
 } // ?|?
 …
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype * os, long double _Complex ldc ) {
+        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+        fmt( os, "%.*Lg%+.*Lgi", LDBL_DIG, creall( ldc ), LDBL_DIG, cimagl( ldc ) );
+        os | creall( ldc );
+        _Bool temp = sepDisable( os );                                          // disable separators within complex value
+        if ( cimagl( ldc ) >= 0 ) os | '+';                                     // negative value prints '-'
+        os | cimagl( ldc ) | 'i';
+        sepReset( os, temp );                                                           // reset separator
         return os;
 } // ?|?

src/libcfa/libhdr.h

-              r33218c6
+              re0a653d
 // Author           : Thierry Delisle
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:56:32 2017
 // Update Count     : 1
+// Last Modified By : Thierry Delisle
+// Last Modified On : Mon Nov 28 12:27:26 2016
+// Update Count     : 0
 //
+#pragma once
+#ifndef __LIB_HDR_H__
+#define __LIB_HDR_H__
 #include "libalign.h"
 …
 #include "libtools.h"
+#endif //__LIB_HDR_H__
 // Local Variables: //
 // mode: c //

src/libcfa/libhdr/libalign.h

-              r33218c6
+              re0a653d
+//                              -*- Mode: C++ -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 23:05:35 2017
 // Update Count     : 2
+// Last Modified By : Thierry Delisle
+// Last Modified On : Mon Nov 28 12:27:26 2016
+// Update Count     : 0
 //
 // This  library is free  software; you  can redistribute  it and/or  modify it
 …
 //
-#pragma once
+#include <assert.h>
+#ifndef __LIB_ALIGN_H__
+#define __LIB_ALIGN_H__
+#include "assert"
 #include <stdbool.h>
 …
 } // uCeiling
+#endif // __LIB_ALIGN_H__
 // Local Variables: //
 // compile-command: "make install" //

src/libcfa/libhdr/libdebug.h

-              r33218c6
+              re0a653d
 // Author           : Thierry Delisle
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 10:02:24 2017
 // Update Count     : 1
+// Last Modified By : Thierry Delisle
+// Last Modified On : Mon Nov 28 12:27:26 2016
+// Update Count     : 0
 //
+#pragma once
+#ifndef __LIB_DEBUG_H__
+#define __LIB_DEBUG_H__
 #ifdef __CFA_DEBUG__
 …
 #endif
+#endif //__LIB_DEBUG_H__
 // Local Variables: //
 // mode: c //

src/libcfa/libhdr/libtools.h

-              r33218c6
+              re0a653d
 // Author           : Thierry Delisle
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 10:02:10 2017
 // Update Count     : 1
+// Last Modified By : Thierry Delisle
+// Last Modified On : Mon Nov 28 12:27:26 2016
+// Update Count     : 0
 //
+#pragma once
+#ifndef __LIB_TOOLS_H__
+#define __LIB_TOOLS_H__
 // void abortf( const char *fmt, ... ) {
 …
 #endif
+#endif //__LIB_TOOLS_H__
 // Local Variables: //
 // mode: c //

src/libcfa/math

-              r33218c6
+              re0a653d
 // Created On       : Mon Apr 18 23:37:04 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 17:03:13 2017
 // Update Count     : 101
+// Last Modified On : Fri Jul  7 09:34:15 2017
+// Update Count     : 61
 //
 #pragma once
+#include <math.h>
+#include <complex.h>
+static inline float ?%?( float x, float y ) { return fmodf( x, y ); }
+static inline float fmod( float x, float y ) { return fmodf( x, y ); }
+static inline double ?%?( double x, double y ) { return fmod( x, y ); }
+extern "C" {
+#include <math.h>                                                                               // fpclassify, isfinite, isnormal, isnan, isinf
+} // extern "C"
+float ?%?( float, float );
+float fmod( float, float );
+double ?%?( double, double );
 // extern "C" { double fmod( double, double ); }
+static inline long double ?%?( long double x, long double y ) { return fmodl( x, y ); }
+static inline long double fmod( long double x, long double y ) { return fmodl( x, y ); }
+static inline float remainder( float x, float y ) { return remainderf( x, y ); }
+long double ?%?( long double, long double );
+long double fmod( long double, long double );
+float remainder( float, float );
 // extern "C" { double remainder( double, double ); }
+static inline long double remainder( long double x, long double y ) { return remainderl( x, y ); }
+static inline float remquo( float x, float y, int * quo ) { return remquof( x, y, quo ); }
+// extern "C" { double remquo( double x, double y, int * quo ); }
+static inline long double remquo( long double x, long double y, int * quo ) { return remquol( x, y, quo ); }
+static inline [ int, float ] remquo( float x, float y ) { int quo; x = remquof( x, y, &quo ); return [ quo, x ]; }
+static inline [ int, double ] remquo( double x, double y ) { int quo; x = remquo( x, y, &quo ); return [ quo, x ]; }
+static inline [ int, long double ] remquo( long double x, long double y ) { int quo; x = remquol( x, y, &quo ); return [ quo, x ]; }
+// alternative name for remquo
+static inline float div( float x, float y, int * quo ) { return remquof( x, y, quo ); }
+static inline double div( double x, double y, int * quo ) { return remquo( x, y, quo ); }
+static inline long double div( long double x, long double y, int * quo ) { return remquol( x, y, quo ); }
+static inline [ int, float ] div( float x, float y ) { int quo; x = remquof( x, y, &quo ); return [ quo, x ]; }
+static inline [ int, double ] div( double x, double y ) { int quo; x = remquo( x, y, &quo ); return [ quo, x ]; }
+static inline [ int, long double ] div( long double x, long double y ) { int quo; x = remquol( x, y, &quo ); return [ quo, x ]; }
+static inline float fma( float x, float y, float z ) { return fmaf( x, y, z ); }
+long double remainder( long double, long double );
+[ int, float ] remquo( float, float );
+float remquo( float, float, int * );
+[ int, double ] remquo( double, double );
+// extern "C" { double remquo( double, double, int * ); }
+[ int, long double ] remquo( long double, long double );
+long double remquo( long double, long double, int * );
+[ int, float ] div( float, float );                                             // alternative name for remquo
+float div( float, float, int * );
+[ int, double ] div( double, double );
+// extern "C" { double div( double, double, int * ); }
+[ int, long double ] div( long double, long double );
+long double div( long double, long double, int * );
+float fma( float, float, float );
 // extern "C" { double fma( double, double, double ); }
+static inline long double fma( long double x, long double y, long double z ) { return fmal( x, y, z ); }
+static inline float fdim( float x, float y ) { return fdimf( x, y ); }
+long double fma( long double, long double, long double );
+float fdim( float, float );
 // extern "C" { double fdim( double, double ); }
+static inline long double fdim( long double x, long double y ) { return fdiml( x, y ); }
+static inline float nan( const char * tag ) { return nanf( tag ); }
+long double fdim( long double, long double );
+float nan( const char * );
 // extern "C" { double nan( const char * ); }
+static inline long double nan( const char * tag ) { return nanl( tag ); }
+long double nan( const char * );
 //---------------------- Exponential ----------------------
+static inline float exp( float x ) { return expf( x ); }
+float exp( float );
 // extern "C" { double exp( double ); }
+static inline long double exp( long double x ) { return expl( x ); }
+static inline float _Complex exp( float _Complex x ) { return cexpf( x ); }
+static inline double _Complex exp( double _Complex x ) { return cexp( x ); }
+static inline long double _Complex exp( long double _Complex x ) { return cexpl( x ); }
+static inline float exp2( float x ) { return exp2f( x ); }
+long double exp( long double );
+float _Complex exp( float _Complex );
+double _Complex exp( double _Complex );
+long double _Complex exp( long double _Complex );
+float exp2( float );
 // extern "C" { double exp2( double ); }
+static inline long double exp2( long double x ) { return exp2l( x ); }
 //static inline float _Complex exp2( float _Complex x ) { return cexp2f( x ); }
 //static inline double _Complex exp2( double _Complex x ) { return cexp2( x ); }
 //static inline long double _Complex exp2( long double _Complex x ) { return cexp2l( x ); }
+static inline float expm1( float x ) { return expm1f( x ); }
+long double exp2( long double );
+// float _Complex exp2( float _Complex );
+// double _Complex exp2( double _Complex );
+// long double _Complex exp2( long double _Complex );
+float expm1( float );
 // extern "C" { double expm1( double ); }
+static inline long double expm1( long double x ) { return expm1l( x ); }
+static inline float pow( float x, float y ) { return powf( x, y ); }
+long double expm1( long double );
+float log( float );
+// extern "C" { double log( double ); }
+long double log( long double );
+float _Complex log( float _Complex );
+double _Complex log( double _Complex );
+long double _Complex log( long double _Complex );
+float log2( float );
+// extern "C" { double log2( double ); }
+long double log2( long double );
+// float _Complex log2( float _Complex );
+// double _Complex log2( double _Complex );
+// long double _Complex log2( long double _Complex );
+float log10( float );
+// extern "C" { double log10( double ); }
+long double log10( long double );
+// float _Complex log10( float _Complex );
+// double _Complex log10( double _Complex );
+// long double _Complex log10( long double _Complex );
+float log1p( float );
+// extern "C" { double log1p( double ); }
+long double log1p( long double );
+int ilogb( float );
+// extern "C" { int ilogb( double ); }
+int ilogb( long double );
+float logb( float );
+// extern "C" { double logb( double ); }
+long double logb( long double );
+//---------------------- Power ----------------------
+float sqrt( float );
+// extern "C" { double sqrt( double ); }
+long double sqrt( long double );
+float _Complex sqrt( float _Complex );
+double _Complex sqrt( double _Complex );
+long double _Complex sqrt( long double _Complex );
+float cbrt( float );
+// extern "C" { double cbrt( double ); }
+long double cbrt( long double );
+float hypot( float, float );
+// extern "C" { double hypot( double, double ); }
+long double hypot( long double, long double );
+float pow( float, float );
 // extern "C" { double pow( double, double ); }
+static inline long double pow( long double x, long double y ) { return powl( x, y ); }
+static inline float _Complex pow( float _Complex x, float _Complex y ) { return cpowf( x, y ); }
+static inline double _Complex pow( double _Complex x, double _Complex y ) { return cpow( x, y ); }
+static inline long double _Complex pow( long double _Complex x, long double _Complex y ) { return cpowl( x, y ); }
+//---------------------- Logarithm ----------------------
+static inline float log( float x ) { return logf( x ); }
+// extern "C" { double log( double ); }
+static inline long double log( long double x ) { return logl( x ); }
+static inline float _Complex log( float _Complex x ) { return clogf( x ); }
+static inline double _Complex log( double _Complex x ) { return clog( x ); }
+static inline long double _Complex log( long double _Complex x ) { return clogl( x ); }
+static inline float log2( float x ) { return log2f( x ); }
+// extern "C" { double log2( double ); }
+static inline long double log2( long double x ) { return log2l( x ); }
+// static inline float _Complex log2( float _Complex x ) { return clog2f( x ); }
+// static inline double _Complex log2( double _Complex x ) { return clog2( x ); }
+// static inline long double _Complex log2( long double _Complex x ) { return clog2l( x ); }
+static inline float log10( float x ) { return log10f( x ); }
+// extern "C" { double log10( double ); }
+static inline long double log10( long double x ) { return log10l( x ); }
+// static inline float _Complex log10( float _Complex x ) { return clog10f( x ); }
+// static inline double _Complex log10( double _Complex x ) { return clog10( x ); }
+// static inline long double _Complex log10( long double _Complex x ) { return clog10l( x ); }
+static inline float log1p( float x ) { return log1pf( x ); }
+// extern "C" { double log1p( double ); }
+static inline long double log1p( long double x ) { return log1pl( x ); }
+static inline int ilogb( float x ) { return ilogbf( x ); }
+// extern "C" { int ilogb( double ); }
+static inline int ilogb( long double x ) { return ilogbl( x ); }
+static inline float logb( float x ) { return logbf( x ); }
+// extern "C" { double logb( double ); }
+static inline long double logb( long double x ) { return logbl( x ); }
+static inline float sqrt( float x ) { return sqrtf( x ); }
+// extern "C" { double sqrt( double ); }
+static inline long double sqrt( long double x ) { return sqrtl( x ); }
+static inline float _Complex sqrt( float _Complex x ) { return csqrtf( x ); }
+static inline double _Complex sqrt( double _Complex x ) { return csqrt( x ); }
+static inline long double _Complex sqrt( long double _Complex x ) { return csqrtl( x ); }
+static inline float cbrt( float x ) { return cbrtf( x ); }
+// extern "C" { double cbrt( double ); }
+static inline long double cbrt( long double x ) { return cbrtl( x ); }
+static inline float hypot( float x, float y ) { return hypotf( x, y ); }
+// extern "C" { double hypot( double, double ); }
+static inline long double hypot( long double x, long double y ) { return hypotl( x, y ); }
+long double pow( long double, long double );
+float _Complex pow( float _Complex, float _Complex );
+double _Complex pow( double _Complex, double _Complex );
+long double _Complex pow( long double _Complex, long double _Complex );
 //---------------------- Trigonometric ----------------------
+static inline float sin( float x ) { return sinf( x ); }
+float sin( float );
 // extern "C" { double sin( double ); }
+static inline long double sin( long double x ) { return sinl( x ); }
+static inline float _Complex sin( float _Complex x ) { return csinf( x ); }
+static inline double _Complex sin( double _Complex x ) { return csin( x ); }
+static inline long double _Complex sin( long double _Complex x ) { return csinl( x ); }
+static inline float cos( float x ) { return cosf( x ); }
+long double sin( long double );
+float _Complex sin( float _Complex );
+double _Complex sin( double _Complex );
+long double _Complex sin( long double _Complex );
+float cos( float );
 // extern "C" { double cos( double ); }
+static inline long double cos( long double x ) { return cosl( x ); }
+static inline float _Complex cos( float _Complex x ) { return ccosf( x ); }
+static inline double _Complex cos( double _Complex x ) { return ccos( x ); }
+static inline long double _Complex cos( long double _Complex x ) { return ccosl( x ); }
+static inline float tan( float x ) { return tanf( x ); }
+long double cos( long double );
+float _Complex cos( float _Complex );
+double _Complex cos( double _Complex );
+long double _Complex cos( long double _Complex );
+float tan( float );
 // extern "C" { double tan( double ); }
+static inline long double tan( long double x ) { return tanl( x ); }
+static inline float _Complex tan( float _Complex x ) { return ctanf( x ); }
+static inline double _Complex tan( double _Complex x ) { return ctan( x ); }
+static inline long double _Complex tan( long double _Complex x ) { return ctanl( x ); }
+static inline float asin( float x ) { return asinf( x ); }
+long double tan( long double );
+float _Complex tan( float _Complex );
+double _Complex tan( double _Complex );
+long double _Complex tan( long double _Complex );
+float asin( float );
 // extern "C" { double asin( double ); }
+static inline long double asin( long double x ) { return asinl( x ); }
+static inline float _Complex asin( float _Complex x ) { return casinf( x ); }
+static inline double _Complex asin( double _Complex x ) { return casin( x ); }
+static inline long double _Complex asin( long double _Complex x ) { return casinl( x ); }
+static inline float acos( float x ) { return acosf( x ); }
+long double asin( long double );
+float _Complex asin( float _Complex );
+double _Complex asin( double _Complex );
+long double _Complex asin( long double _Complex );
+float acos( float );
 // extern "C" { double acos( double ); }
+static inline long double acos( long double x ) { return acosl( x ); }
+static inline float _Complex acos( float _Complex x ) { return cacosf( x ); }
+static inline double _Complex acos( double _Complex x ) { return cacos( x ); }
+static inline long double _Complex acos( long double _Complex x ) { return cacosl( x ); }
+static inline float atan( float x ) { return atanf( x ); }
+long double acos( long double );
+float _Complex acos( float _Complex );
+double _Complex acos( double _Complex );
+long double _Complex acos( long double _Complex );
+float atan( float );
 // extern "C" { double atan( double ); }
+static inline long double atan( long double x ) { return atanl( x ); }
+static inline float _Complex atan( float _Complex x ) { return catanf( x ); }
+static inline double _Complex atan( double _Complex x ) { return catan( x ); }
+static inline long double _Complex atan( long double _Complex x ) { return catanl( x ); }
+static inline float atan2( float x, float y ) { return atan2f( x, y ); }
+long double atan( long double );
+float _Complex atan( float _Complex );
+double _Complex atan( double _Complex );
+long double _Complex atan( long double _Complex );
+float atan2( float, float );
 // extern "C" { double atan2( double, double ); }
+static inline long double atan2( long double x, long double y ) { return atan2l( x, y ); }
+// alternative name for atan2
+static inline float atan( float x, float y ) { return atan2f( x, y ); }
+static inline double atan( double x, double y ) { return atan2( x, y ); }
+static inline long double atan( long double x, long double y ) { return atan2l( x, y ); }
+long double atan2( long double, long double );
+float atan( float, float );                                                             // alternative name for atan2
+double atan( double, double );
+long double atan( long double, long double );
 //---------------------- Hyperbolic ----------------------
+static inline float sinh( float x ) { return sinhf( x ); }
+float sinh( float );
 // extern "C" { double sinh( double ); }
+static inline long double sinh( long double x ) { return sinhl( x ); }
+static inline float _Complex sinh( float _Complex x ) { return csinhf( x ); }
+static inline double _Complex sinh( double _Complex x ) { return csinh( x ); }
+static inline long double _Complex sinh( long double _Complex x ) { return csinhl( x ); }
+static inline float cosh( float x ) { return coshf( x ); }
+long double sinh( long double );
+float _Complex sinh( float _Complex );
+double _Complex sinh( double _Complex );
+long double _Complex sinh( long double _Complex );
+float cosh( float );
 // extern "C" { double cosh( double ); }
+static inline long double cosh( long double x ) { return coshl( x ); }
+static inline float _Complex cosh( float _Complex x ) { return ccoshf( x ); }
+static inline double _Complex cosh( double _Complex x ) { return ccosh( x ); }
+static inline long double _Complex cosh( long double _Complex x ) { return ccoshl( x ); }
+static inline float tanh( float x ) { return tanhf( x ); }
+long double cosh( long double );
+float _Complex cosh( float _Complex );
+double _Complex cosh( double _Complex );
+long double _Complex cosh( long double _Complex );
+float tanh( float );
 // extern "C" { double tanh( double ); }
+static inline long double tanh( long double x ) { return tanhl( x ); }
+static inline float _Complex tanh( float _Complex x ) { return ctanhf( x ); }
+static inline double _Complex tanh( double _Complex x ) { return ctanh( x ); }
+static inline long double _Complex tanh( long double _Complex x ) { return ctanhl( x ); }
+static inline float asinh( float x ) { return asinhf( x ); }
+long double tanh( long double );
+float _Complex tanh( float _Complex );
+double _Complex tanh( double _Complex );
+long double _Complex tanh( long double _Complex );
+float asinh( float );
 // extern "C" { double asinh( double ); }
+static inline long double asinh( long double x ) { return asinhl( x ); }
+static inline float _Complex asinh( float _Complex x ) { return casinhf( x ); }
+static inline double _Complex asinh( double _Complex x ) { return casinh( x ); }
+static inline long double _Complex asinh( long double _Complex x ) { return casinhl( x ); }
+static inline float acosh( float x ) { return acoshf( x ); }
+long double asinh( long double );
+float _Complex asinh( float _Complex );
+double _Complex asinh( double _Complex );
+long double _Complex asinh( long double _Complex );
+float acosh( float );
 // extern "C" { double acosh( double ); }
+static inline long double acosh( long double x ) { return acoshl( x ); }
+static inline float _Complex acosh( float _Complex x ) { return cacoshf( x ); }
+static inline double _Complex acosh( double _Complex x ) { return cacosh( x ); }
+static inline long double _Complex acosh( long double _Complex x ) { return cacoshl( x ); }
+static inline float atanh( float x ) { return atanhf( x ); }
+long double acosh( long double );
+float _Complex acosh( float _Complex );
+double _Complex acosh( double _Complex );
+long double _Complex acosh( long double _Complex );
+float atanh( float );
 // extern "C" { double atanh( double ); }
+static inline long double atanh( long double x ) { return atanhl( x ); }
+static inline float _Complex atanh( float _Complex x ) { return catanhf( x ); }
+static inline double _Complex atanh( double _Complex x ) { return catanh( x ); }
+static inline long double _Complex atanh( long double _Complex x ) { return catanhl( x ); }
+long double atanh( long double );
+float _Complex atanh( float _Complex );
+double _Complex atanh( double _Complex );
+long double _Complex atanh( long double _Complex );
 //---------------------- Error / Gamma ----------------------
+static inline float erf( float x ) { return erff( x ); }
+float erf( float );
 // extern "C" { double erf( double ); }
+static inline long double erf( long double x ) { return erfl( x ); }
+long double erf( long double );
 // float _Complex erf( float _Complex );
 // double _Complex erf( double _Complex );
 // long double _Complex erf( long double _Complex );
+static inline float erfc( float x ) { return erfcf( x ); }
+float erfc( float );
 // extern "C" { double erfc( double ); }
+static inline long double erfc( long double x ) { return erfcl( x ); }
+long double erfc( long double );
 // float _Complex erfc( float _Complex );
 // double _Complex erfc( double _Complex );
 // long double _Complex erfc( long double _Complex );
+static inline float lgamma( float x ) { return lgammaf( x ); }
+float lgamma( float );
 // extern "C" { double lgamma( double ); }
+static inline long double lgamma( long double x ) { return lgammal( x ); }
+static inline float lgamma( float x, int * sign ) { return lgammaf_r( x, sign ); }
+static inline double lgamma( double x, int * sign ) { return lgamma_r( x, sign ); }
+static inline long double lgamma( long double x, int * sign ) { return lgammal_r( x, sign ); }
+static inline float tgamma( float x ) { return tgammaf( x ); }
+long double lgamma( long double );
+float lgamma( float, int * );
+double lgamma( double, int * );
+long double lgamma( long double, int * );
+float tgamma( float );
 // extern "C" { double tgamma( double ); }
+static inline long double tgamma( long double x ) { return tgammal( x ); }
+long double tgamma( long double );
 //---------------------- Nearest Integer ----------------------
+static inline float floor( float x ) { return floorf( x ); }
+float floor( float );
 // extern "C" { double floor( double ); }
+static inline long double floor( long double x ) { return floorl( x ); }
+static inline float ceil( float x ) { return ceilf( x ); }
+long double floor( long double );
+float ceil( float );
 // extern "C" { double ceil( double ); }
+static inline long double ceil( long double x ) { return ceill( x ); }
+static inline float trunc( float x ) { return truncf( x ); }
+long double ceil( long double );
+float trunc( float );
 // extern "C" { double trunc( double ); }
+static inline long double trunc( long double x ) { return truncl( x ); }
+static inline float rint( float x ) { return rintf( x ); }
+// extern "C" { double rint( double x ); }
+static inline long double rint( long double x ) { return rintl( x ); }
+static inline long int rint( float x ) { return lrintf( x ); }
+static inline long int rint( double x ) { return lrint( x ); }
+static inline long int rint( long double x ) { return lrintl( x ); }
+static inline long long int rint( float x ) { return llrintf( x ); }
+static inline long long int rint( double x ) { return llrint( x ); }
+static inline long long int rint( long double x ) { return llrintl( x ); }
+static inline long int lrint( float x ) { return lrintf( x ); }
+long double trunc( long double );
+float rint( float );
+long double rint( long double );
+long int rint( float );
+long int rint( double );
+long int rint( long double );
+long long int rint( float );
+long long int rint( double );
+long long int rint( long double );
+long int lrint( float );
 // extern "C" { long int lrint( double ); }
+static inline long int lrint( long double x ) { return lrintl( x ); }
+static inline long long int llrint( float x ) { return llrintf( x ); }
+long int lrint( long double );
+long long int llrint( float );
 // extern "C" { long long int llrint( double ); }
+static inline long long int llrint( long double x ) { return llrintl( x ); }
+static inline float nearbyint( float x ) { return nearbyintf( x ); }
+long long int llrint( long double );
+float nearbyint( float );
 // extern "C" { double nearbyint( double ); }
+static inline long double nearbyint( long double x ) { return nearbyintl( x ); }
+static inline float round( float x ) { return roundf( x ); }
+// extern "C" { double round( double x ); }
+static inline long double round( long double x ) { return roundl( x ); }
+static inline long int round( float x ) { return lroundf( x ); }
+static inline long int round( double x ) { return lround( x ); }
+static inline long int round( long double x ) { return lroundl( x ); }
+static inline long long int round( float x ) { return llroundf( x ); }
+static inline long long int round( double x ) { return llround( x ); }
+static inline long long int round( long double x ) { return llroundl( x ); }
+static inline long int lround( float x ) { return lroundf( x ); }
+long double nearbyint( long double );
+float round( float );
+long double round( long double );
+long int round( float );
+long int round( double );
+long int round( long double );
+long long int round( float );
+long long int round( double );
+long long int round( long double );
+long int lround( float );
 // extern "C" { long int lround( double ); }
+static inline long int lround( long double x ) { return lroundl( x ); }
+static inline long long int llround( float x ) { return llroundf( x ); }
+long int lround( long double );
+long long int llround( float );
 // extern "C" { long long int llround( double ); }
+static inline long long int llround( long double x ) { return llroundl( x ); }
+long long int llround( long double );
 //---------------------- Manipulation ----------------------
+static inline float copysign( float x, float y ) { return copysignf( x, y ); }
+float copysign( float, float );
 // extern "C" { double copysign( double, double ); }
+static inline long double copysign( long double x, long double y ) { return copysignl( x, y ); }
+static inline float frexp( float x, int * ip ) { return frexpf( x, ip ); }
+long double copysign( long double, long double );
+float frexp( float, int * );
 // extern "C" { double frexp( double, int * ); }
+static inline long double frexp( long double x, int * ip ) { return frexpl( x, ip ); }
+static inline float ldexp( float x, int exp2 ) { return ldexpf( x, exp2 ); }
+long double frexp( long double, int * );
+float ldexp( float, int );
 // extern "C" { double ldexp( double, int ); }
+static inline long double ldexp( long double x, int exp2 ) { return ldexpl( x, exp2 ); }
+static inline [ float, float ] modf( float x ) { float i; x = modff( x, &i ); return [ i, x ]; }
+static inline float modf( float x, float * i ) { return modff( x, i ); }
+static inline [ double, double ] modf( double x ) { double i; x = modf( x, &i ); return [ i, x ]; }
+long double ldexp( long double, int );
+[ float, float ] modf( float );
+float modf( float, float * );
+[ double, double ] modf( double );
 // extern "C" { double modf( double, double * ); }
+static inline [ long double, long double ] modf( long double x ) { long double i; x = modfl( x, &i ); return [ i, x ]; }
+static inline long double modf( long double x, long double * i ) { return modfl( x, i ); }
+static inline float nextafter( float x, float y ) { return nextafterf( x, y ); }
+[ long double, long double ] modf( long double );
+long double modf( long double, long double * );
+float nextafter( float, float );
 // extern "C" { double nextafter( double, double ); }
+static inline long double nextafter( long double x, long double y ) { return nextafterl( x, y ); }
+static inline float nexttoward( float x, long double y ) { return nexttowardf( x, y ); }
+long double nextafter( long double, long double );
+float nexttoward( float, long double );
 // extern "C" { double nexttoward( double, long double ); }
+static inline long double nexttoward( long double x, long double y ) { return nexttowardl( x, y ); }
+static inline float scalbn( float x, int exp ) { return scalbnf( x, exp ); }
+long double nexttoward( long double, long double );
+float scalbn( float, int );
 // extern "C" { double scalbn( double, int ); }
+static inline long double scalbn( long double x, int exp ) { return scalbnl( x, exp ); }
+static inline float scalbn( float x, long int exp ) { return scalblnf( x, exp ); }
+static inline double scalbn( double x, long int exp ) { return scalbln( x, exp ); }
+static inline long double scalbn( long double x, long int exp ) { return scalblnl( x, exp ); }
+static inline float scalbln( float x, long int exp ) { return scalblnf( x, exp ); }
+long double scalbn( long double, int );
+float scalbln( float, long int );
 // extern "C" { double scalbln( double, long int ); }
+static inline long double scalbln( long double x, long int exp ) { return scalblnl( x, exp ); }
+long double scalbln( long double, long int );
 // Local Variables: //

src/libcfa/startup.h

-              r33218c6
+              re0a653d
+//                              -*- Mode: CFA -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Author           : Thierry Delisle
 // Created On       : Wed Mar 29 15:56:41 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jul 20 21:37:11 2017
 // Update Count     : 2
+// Last Modified By :
+// Last Modified On :
+// Update Count     : 0
 //
+#pragma once
+#ifndef STARTUP_H
+#define STARTUP_H
 #if GCC_VERSION > 50000
 …
 #endif
+// Local Variables: //
+// mode: c //
+// tab-width: 4 //
+// End: //
+#endif //STARTUP_H

src/libcfa/stdhdr/assert.h

-              r33218c6
+              re0a653d
 // Created On       : Mon Jul  4 23:25:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jul 20 21:06:48 2017
 // Update Count     : 11
+// Last Modified On : Tue Jul  5 20:34:23 2016
+// Update Count     : 8
 //
 …
 #endif //__CFORALL__
+// has internal check for multiple expansion
 #include_next <assert.h>
-#ifdef NDEBUG
-        #define assertf( expr, fmt, ... ) ((void)0)
-#else
-        #define __STRINGIFY__(str) #str
-        #define __VSTRINGIFY__(str) __STRINGIFY__(str)
-        #define assertf(expr, fmt, ...) ((expr) ? ((void)0) : __assert_fail_f(__VSTRINGIFY__(expr), __FILE__, __LINE__, __PRETTY_FUNCTION__, fmt, ## __VA_ARGS__ ))
-        void __assert_fail_f( const char *assertion, const char *file, unsigned int line, const char *function, const char *fmt, ... ) __attribute__((noreturn));
-#endif
 #ifdef __CFORALL__

src/libcfa/stdhdr/gmp.h

-              r33218c6
+              re0a653d
+//                               -*- Mode: C -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 …
 // Created On       : Sun May 14 23:46:01 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jul 20 18:10:52 2017
 // Update Count     : 4
+// Last Modified On : Sun May 14 23:46:34 2017
+// Update Count     : 1
 //

src/libcfa/stdlib

-              r33218c6
+              re0a653d
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jul 20 14:32:37 2017
 // Update Count     : 220
+// Last Modified On : Fri Jul  7 09:34:49 2017
+// Update Count     : 219
 //
 …
 //---------------------------------------
+extern "C" {
 #ifndef EXIT_FAILURE
 #define EXIT_FAILURE    1                                                               // failing exit status
 #define EXIT_SUCCESS    0                                                               // successful exit status
 #endif // ! EXIT_FAILURE
+} // extern "C"
 //---------------------------------------

src/libcfa/stdlib.c

-              r33218c6
+              re0a653d
 // Created On       : Thu Jan 28 17:10:29 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jul 20 16:01:40 2017
 // Update Count     : 282
+// Last Modified On : Thu Jun  1 21:52:57 2017
+// Update Count     : 280
 //
 …
 //---------------------------------------
+extern "C" {
 #define _XOPEN_SOURCE 600                                                               // posix_memalign, *rand48
 #include <stdlib.h>                                                                             // malloc, free, calloc, realloc, memalign, posix_memalign, bsearch
 …
 #include <math.h>                                                                               // fabsf, fabs, fabsl
 #include <complex.h>                                                                    // _Complex_I
+} // extern "C"
 // resize, non-array types

src/prelude/builtins.c

-              r33218c6
+              re0a653d
-//
-// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
-//
-// The contents of this file are covered under the licence agreement in the
-// file "LICENCE" distributed with Cforall.
-//
-// builtins.c --
-//
-// Author           : Peter A. Buhr
-// Created On       : Fri Jul 21 16:21:03 2017
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 10:34:20 2017
-// Update Count     : 13
-//
-// exception implementation
 typedef unsigned long long __cfaabi_exception_type_t;
 #include "../libcfa/exception.h"
-// exponentiation operator implementation
-extern "C" {
-        float powf( float x, float y );
-        double pow( double x, double y );
-        long double powl( long double x, long double y );
-        float _Complex cpowf( float _Complex x, _Complex float z );
-        double _Complex cpow( double _Complex x, _Complex double z );
-        long double _Complex cpowl( long double _Complex x, _Complex long double z );
-} // extern "C"
-static inline float ?\?( float x, float y ) { return powf( x, y ); }
-static inline double ?\?( double x, double y ) { return pow( x, y ); }
-static inline long double ?\?( long double x, long double y ) { return powl( x, y ); }
-static inline float _Complex ?\?( float _Complex x, _Complex float y ) { return cpowf(x, y ); }
-static inline double _Complex ?\?( double _Complex x, _Complex double y ) { return cpow( x, y ); }
-static inline long double _Complex ?\?( long double _Complex x, _Complex long double y ) { return cpowl( x, y ); }
-static inline long int ?\?( long int ep, unsigned long int y ) { // disallow negative exponent
-        if ( y == 0 ) return 1;                                                         // base case
-    if ( ep == 2 ) return ep << (y - 1);                                // special case, positive shifting only
-    typeof( ep ) op = 1;                                                                // accumulate odd product
-    for ( ; y > 1; y >>= 1 ) {                                                  // squaring exponentiation, O(log2 y)
-                if ( (y & 1) == 1 ) op *= ep;                                   // odd ?
-                ep *= ep;
-        } // for
-    return ep * op;
-} // ?\?
-// FIX ME, cannot resolve the "T op = 1".
-// static inline forall( otype T | { void ?{}( T * this, one_t ); T ?*?( T, T ); } )
-// T ?\?( T ep, unsigned long int y ) {
-//     if ( y == 0 ) return 1;
-//     T op = 1;
-//     for ( ; y > 1; y >>= 1 ) {                                                       // squaring exponentiation, O(log2 y)
-//              if ( (y & 1) == 1 ) op = op * ep;                               // odd ?
-//              ep = ep * ep;
-//     } // for
-//     return ep * op;
-// } // ?\?
-// unsigned computation may be faster and larger
-static inline unsigned long int ?\?( unsigned long int ep, unsigned long int y ) { // disallow negative exponent
-        if ( y == 0 ) return 1;                                                         // base case
-    if ( ep == 2 ) return ep << (y - 1);                                // special case, positive shifting only
-    typeof( ep ) op = 1;                                                                // accumulate odd product
-    for ( ; y > 1; y >>= 1 ) {                                                  // squaring exponentiation, O(log2 y)
-                if ( (y & 1) == 1 ) op *= ep;                                   // odd ?
-                ep *= ep;
-        } // for
-    return ep * op;
-} // ?\?
-static inline double ?\?( long int x, signed long int y ) {     // allow negative exponent
-    if ( y >=  0 ) return (double)(x \ (unsigned long int)y);
-    else return 1.0 / x \ (unsigned int)(-y);
-} // ?\?
-static inline forall( otype T | { void ?{}( T * this, one_t ); T ?*?( T, T ); double ?/?( double, T ); } )
-double ?\?( T x, signed long int y ) {
-    if ( y >=  0 ) return (double)(x \ (unsigned long int)y);
-    else return 1.0 / x \ (unsigned long int)(-y);
-} // ?\?
-static inline long int ?\=?( long int * x, unsigned long int y ) { *x = *x \ y; return *x; }
-static inline unsigned long int ?\=?( unsigned long int * x, unsigned long int y ) { *x = *x \ y; return *x; }
-static inline int ?\=?( int * x, unsigned long int y ) { *x = *x \ y; return *x; }
-static inline unsigned int ?\=?( unsigned int * x, unsigned long int y ) { *x = *x \ y; return *x; }
-// Local Variables: //
-// mode: c //
-// tab-width: 4 //
-// End: //

src/tests/.expect/32/math.txt

-              r33218c6
+              re0a653d
 exp2:2 2 2
 expm1:1.71828 1.71828182845905 1.71828182845904524
-pow:1 1 1 0.273957+0.583701i 0.273957253830121+0.583700758758615i 0.273957253830121071+0.583700758758614628i
-256
-256 64 -64 0.015625 -0.015625 18.3791736799526 0.264715-1.1922i
 log:0 0 0 0.346574+0.785398i 0.346573590279973+0.785398163397448i 0.346573590279972655+0.78539816339744831i
 log2:3 3 3
 …
 cbrt:3 3 3
 hypot:1.41421 1.4142135623731 1.41421356237309505
+pow:1 1 1 0.273957+0.583701i 0.273957253830121+0.583700758758615i 0.273957253830121071+0.583700758758614628i
 sin:0.841471 0.841470984807897 0.841470984807896507 1.29846+0.634964i 1.29845758141598+0.634963914784736i 1.29845758141597729+0.634963914784736108i
 cos:0.540302 0.54030230586814 0.540302305868139717 0.83373-0.988898i 0.833730025131149-0.988897705762865i 0.833730025131149049-0.988897705762865096i

src/tests/.expect/64/math.txt

-              r33218c6
+              re0a653d
 exp2:2 2 2
 expm1:1.71828 1.71828182845905 1.71828182845904524
-pow:1 1 1 0.273957+0.583701i 0.273957253830121+0.583700758758615i 0.273957253830121071+0.583700758758614627i
-256
-256 64 -64 0.015625 -0.015625 18.3791736799526 0.264715-1.1922i
 log:0 0 0 0.346574+0.785398i 0.346573590279973+0.785398163397448i 0.346573590279972655+0.78539816339744831i
 log2:3 3 3
 …
 cbrt:3 3 3
 hypot:1.41421 1.4142135623731 1.41421356237309505
+pow:1 1 1 0.273957+0.583701i 0.273957253830121+0.583700758758615i 0.273957253830121071+0.583700758758614628i
 sin:0.841471 0.841470984807897 0.841470984807896507 1.29846+0.634964i 1.29845758141598+0.634963914784736i 1.29845758141597729+0.634963914784736108i
 cos:0.540302 0.54030230586814 0.540302305868139717 0.83373-0.988898i 0.833730025131149-0.988897705762865i 0.833730025131149049-0.988897705762865096i

src/tests/alloc.c

-              r33218c6
+              re0a653d
 // Created On       : Wed Feb  3 07:56:22 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jul 20 16:01:10 2017
 // Update Count     : 318
+// Last Modified On : Fri Jun  2 15:13:03 2017
+// Update Count     : 316
 //
+#include <assert.h>
+#include <assert>
+extern "C" {
 #include <malloc.h>                                                                             // malloc_usable_size
 #include <stdint.h>                                                                             // uintptr_t
 #include <stdlib.h>                                                                             // posix_memalign
+} // extern
 #include <fstream>
 #include <stdlib>                                                                               // access C malloc, realloc

src/tests/attributes.c

-              r33218c6
+              re0a653d
+//                               -*- Mode: C -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2017 University of Waterloo
 …
 // Created On       : Mon Feb  6 16:07:02 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 23:05:52 2017
 // Update Count     : 3
+// Last Modified On : Mon Feb  6 16:08:21 2017
+// Update Count     : 2
 //

src/tests/avltree/avl-private.h

-              r33218c6
+              re0a653d
 #pragma once
+#ifndef AVL_PRIVATE_H
 #include "avl.h"
 …
 forall(otype K | Comparable(K), otype V)
 int height(tree(K, V) * t);
+#endif

src/tests/avltree/avl.h

-              r33218c6
+              re0a653d
+#pragma once
+#ifndef AVL_TREE_H
+#define AVL_TREE_H
 extern "C" {
 …
 //     printTree(t, 0);
 // }
+#endif

src/tests/gmp.c

-              r33218c6
+              re0a653d
 // Created On       : Tue Apr 19 08:55:51 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jul 13 16:35:01 2017
 // Update Count     : 541
+// Last Modified On : Wed May 24 22:05:38 2017
+// Update Count     : 540
 //
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa gmp.c -lgmp" //
+// compile-command: "cfa gmp.c -l gmp" //
 // End: //

src/tests/math.c

-              r33218c6
+              re0a653d
 // Created On       : Fri Apr 22 14:59:21 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 10:32:04 2017
 // Update Count     : 73
+// Last Modified On : Wed May 24 13:04:33 2017
+// Update Count     : 71
 //
 …
         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.0DL+1.0LI, 1.0DL+1.0LI ) | endl;
-        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;
-        //---------------------- 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 | "logb:" | logb( 8.0F ) | logb( 8.0D ) | logb( 8.0L ) | endl;
+        //---------------------- Power ----------------------
         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 | "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.0DL+1.0LI, 1.0DL+1.0LI ) | endl;
         //---------------------- Trigonometric ----------------------

src/tests/maybe.c

-              r33218c6
+              re0a653d
 // Author           : Andrew Beach
 // Created On       : Thr May 25 16:02:00 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jul 20 15:24:07 2017
 // Update Count     : 1
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri May 16 15:43:00 2017
+// Update Count     : 0
 //
 #include <assert.h>
+#include <assert>
 #include <containers/maybe>

src/tests/preempt_longrun/Makefile.am

-              r33218c6
+              re0a653d
 repeats=10
 max_time=600
+max_time=30
 preempt=1_000ul
 …
 CC = @CFA_BINDIR@/@CFA_NAME@
 TESTS = block create disjoint enter enter3 processor stack wait yield
+TESTS = barge block create disjoint enter enter3 processor stack wait yield
 .INTERMEDIATE: ${TESTS}
 all-local: ${TESTS:=.run}
-clean-local:
-        rm -f ${TESTS}
 % : %.c ${CC}

src/tests/preempt_longrun/Makefile.in

-              r33218c6
+              re0a653d
 top_srcdir = @top_srcdir@
 repeats = 10
 max_time = 600
+max_time = 30
 preempt = 1_000ul
 REPEAT = ${abs_top_srcdir}/tools/repeat -s
 BUILD_FLAGS = -g -Wall -Wno-unused-function -quiet @CFA_FLAGS@ -debug -O2 -DPREEMPTION_RATE=${preempt}
 TESTS = block create disjoint enter enter3 processor stack wait yield
+TESTS = barge block create disjoint enter enter3 processor stack wait yield
 all: all-am
 …
                 TEST_LOGS="$$log_list"; \
         exit $$?
+barge.log: barge
+        @p='barge'; \
+        b='barge'; \
+        $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+        --log-file $$b.log --trs-file $$b.trs \
+        $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+        "$$tst" $(AM_TESTS_FD_REDIRECT)
 block.log: block
         @p='block'; \
 …
 clean: clean-am
 clean-am: clean-generic clean-local mostlyclean-am
+clean-am: clean-generic mostlyclean-am
 distclean: distclean-am
 …
 .PHONY: all all-am all-local check check-TESTS check-am clean \
         clean-generic clean-local cscopelist-am ctags-am distclean \
+        clean-generic cscopelist-am ctags-am distclean \
         distclean-generic distdir dvi dvi-am html html-am info info-am \
         install install-am install-data install-data-am install-dvi \
 …
 all-local: ${TESTS:=.run}
-clean-local:
-        rm -f ${TESTS}
 % : %.c ${CC}
         ${AM_V_GEN}${CC} ${CFLAGS} ${<} -o ${@}

src/tests/preempt_longrun/create.c

-              r33218c6
+              re0a653d
 #include <kernel>
 #include <thread>
-static const unsigned long N = 2_000ul;
 #ifndef PREEMPTION_RATE
 …
 int main(int argc, char* argv[]) {
+        processor p;
+        for(int i = 0; i < N; i++) {
+        for(int i = 0; i < 10_000ul; i++) {
                 worker_t w[7];
+        }

src/tests/preempt_longrun/enter.c

r33218c6	re0a653d
3	3	#include <thread>
4	4
	5	#undef N
5	6	static const unsigned long N = 70_000ul;
6	7

src/tests/preempt_longrun/enter3.c

r33218c6	re0a653d
3	3	#include <thread>
4	4
	5	#undef N
5	6	static const unsigned long N = 50_000ul;
6	7

src/tests/preempt_longrun/processor.c

-              r33218c6
+              re0a653d
 #include <kernel>
 #include <thread>
-static const unsigned long N = 5_000ul;
 #ifndef PREEMPTION_RATE
 …
 int main(int argc, char* argv[]) {
         for(int i = 0; i < N; i++) {
+        for(int i = 0; i < 10_000ul; i++) {
                 processor p;
+        }

src/tests/preempt_longrun/yield.c

-              r33218c6
+              re0a653d
 #include <kernel>
 #include <thread>
-static const unsigned long N = 325_000ul;
 #ifndef PREEMPTION_RATE
 …
 void main(worker_t * this) {
         for(int i = 0; i < N; i++) {
+        for(int i = 0; i < 325_000ul; i++) {
                 yield();
+        }

src/tests/result.c

-              r33218c6
+              re0a653d
 // Author           : Andrew Beach
 // Created On       : Thr May 25 16:50:00 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jul 20 15:24:12 2017
 // Update Count     : 1
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Jun 16 15:42:00 2017
+// Update Count     : 0
 //
 #include <assert.h>
+#include <assert>
 #include <containers/result>

src/tests/sched-int-barge.c

-              r33218c6
+              re0a653d
 #include <thread>
-static const unsigned long N = 50_000ul;
-#ifndef PREEMPTION_RATE
-#define PREEMPTION_RATE 10_000ul
-#endif
-unsigned int default_preemption() {
-        return 0;
+}
 enum state_t { WAIT, SIGNAL, BARGE };
 …
 monitor global_data_t {
         volatile bool done;
+        bool done;
         int counter;
         state_t state;
 …
                 c->do_wait2 = ((unsigned)rand48()) % (c->do_signal);
                 if(c->do_wait1 == c->do_wait2) sout | "Same" | endl;
+                // if(c->do_wait1 == c->do_wait2) sout | "Same" | endl;
+        }
 …
+        }
         if( c->counter >= N ) c->done = true;
+        if( c->counter >= 100_000 ) c->done = true;
         return !c->done;
+}
 …
+}
-static thread_desc * volatile the_threads;
 int main(int argc, char* argv[]) {
+        rand48seed(0);
+        processor p;
+        {
+                Threads t[17];
+                the_threads = (thread_desc*)t;
+        }
+        rand48seed(0);
+        processor p;
+        {
+                Threads t[17];
+        }
+}

src/tests/sched-int-block.c

-              r33218c6
+              re0a653d
 #include <thread>
+#include <time.h>
+static const unsigned long N = 5_000ul;
+#ifndef PREEMPTION_RATE
+#define PREEMPTION_RATE 10_000ul
+#ifndef N
+#define N 10_000
 #endif
-unsigned int default_preemption() {
-        return PREEMPTION_RATE;
+}
 enum state_t { WAITED, SIGNAL, BARGE };
 …
 int main(int argc, char* argv[]) {
         rand48seed( time( NULL ) );
+        rand48seed(0);
         done = false;
         processor p;

src/tests/sched-int-disjoint.c

-              r33218c6
+              re0a653d
 #include <thread>
+static const unsigned long N = 10_000ul;
+#ifndef PREEMPTION_RATE
+#define PREEMPTION_RATE 10_000ul
+#ifndef N
+#define N 10_000
 #endif
-unsigned int default_preemption() {
-        return PREEMPTION_RATE;
+}
 enum state_t { WAIT, SIGNAL, BARGE };

src/tests/sched-int-wait.c

-              r33218c6
+              re0a653d
 #include <thread>
+static const unsigned long N = 10_000ul;
+#ifndef PREEMPTION_RATE
+#define PREEMPTION_RATE 10_000ul
+#ifndef N
+#define N 10_000
 #endif
-unsigned int default_preemption() {
-        return PREEMPTION_RATE;
+}
 monitor global_t {};
 …
 int main(int argc, char* argv[]) {
         waiter_left = 4;
         processor p[2];
+        processor p;
         sout | "Starting" | endl;
+        {

src/tests/test.py

-              r33218c6
+              re0a653d
                 if   retcode == TestResult.SUCCESS:     result_txt = "Done"
                 elif retcode == TestResult.TIMEOUT:     result_txt = "TIMEOUT"
                 else :                                          result_txt = "ERROR code %d" % retcode
+                else :                                          result_txt = "ERROR"
         else :
                 if   retcode == TestResult.SUCCESS:     result_txt = "PASSED"
                 elif retcode == TestResult.TIMEOUT:     result_txt = "TIMEOUT"
                 else :                                          result_txt = "FAILED with code %d" % retcode
+                else :                                          result_txt = "FAILED"
         #print result with error if needed

src/tests/vector/array.h

-              r33218c6
+              re0a653d
 // Author           : Richard C. Bilson
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 10:04:20 2017
 // Update Count     : 6
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Apr 27 17:26:04 2016
+// Update Count     : 5
 //
+#pragma once
+#ifndef ARRAY_H
+#define ARRAY_H
 //#include <iterator>
 …
 elt_type * end( array_type * array );
+#endif // ARRAY_H
 // Local Variables: //
 // tab-width: 4 //

src/tests/vector/vector_int.h

-              r33218c6
+              re0a653d
 // Author           : Richard C. Bilson
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 10:04:02 2017
 // Update Count     : 4
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Apr 27 17:26:59 2016
+// Update Count     : 2
 //
+#pragma once
+#ifndef VECTOR_INT_H
+#define VECTOR_INT_H
 // A flexible array, similar to a C++ vector, that holds integers and can be resized dynamically
 …
 void ?{}( vector_int * );                                                               // allocate vector with default capacity
 void ?{}( vector_int *, int reserve );                                  // allocate vector with specified capacity
 void ?{}( vector_int * vec, vector_int other );                 // copy constructor
+void ?{}( vector_int *, int reserve );          // allocate vector with specified capacity
+void ?{}( vector_int * vec, vector_int other ); // copy constructor
 void ^?{}( vector_int * );                                                              // deallocate vector's storage
 …
 lvalue int ?[?]( vector_int * vec, int index );                 // access to arbitrary element (does not resize)
+int last( vector_int * vec );                                                   // return last element
+int last( vector_int * vec );                                                           // return last element
+#endif // VECTOR_INT_H
 // Local Variables: //

tools/cfa.nanorc

-              r33218c6
+              re0a653d
 # Types
 color green "\<(forall|trait|(o|d|f|t)type|mutex|_Bool|volatile|virtual)\>"
+color green "\<(forall|otype|dtype|ftype|trait|mutex|_Bool|volatile)\>"
 color green "\<(float|double|bool|char|int|short|long|sizeof|enum|void|auto)\>"
 color green "\<(static|const|struct|union|typedef|extern|(un)?signed|inline)\>"
 …
 # Declarations
+color brightgreen "\<(struct|union|typedef|trait|coroutine|monitor|thread)\>"
+color brightgreen "\<(with)\>"
+color brightgreen "\<(struct|union|typedef|trait|coroutine|monitor)\>"
 # Control Flow Structures

tools/prettyprinter/ParserTypes.h

-              r33218c6
+              re0a653d
 // Created On       : Sun Dec 16 15:00:49 2001
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 10:13:09 2017
 // Update Count     : 175
+// Last Modified On : Wed Jun 28 22:59:27 2017
+// Update Count     : 174
 //
+#pragma once
+#ifndef __PARSER_HH__
+#define __PARSER_HH__
 int yylex();
 …
 #include "token.h"
+#endif // __PARSER_HH__
 // Local Variables: //
 // mode: c++ //

tools/prettyprinter/filter.h

-              r33218c6
+              re0a653d
 // Created On       : Tue Apr  9 22:31:18 2002
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 10:12:55 2017
 // Update Count     : 11
+// Last Modified On : Thu Jun 29 08:28:32 2017
+// Update Count     : 10
 //
+#pragma once
+#ifndef __FILTER_H__
+#define __FILTER_H__
 #include "ParserTypes.h"
 …
 void HTML( Token * tree );
+#endif // __FILTER_H__
 // Local Variables: //
 // mode: c++ //

tools/prettyprinter/lex.ll

-              r33218c6
+              re0a653d
+/*
+/*                               -*- Mode: C -*-
+ *
  * Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+ *
 …
  * Created On       : Sat Dec 15 11:45:59 2001
  * Last Modified By : Peter A. Buhr
  * Last Modified On : Fri Jul 21 23:06:16 2017
  * Update Count     : 254
+ * Last Modified On : Wed Jun 28 22:57:17 2017
+ * Update Count     : 253
  */

tools/prettyprinter/test.y

-              r33218c6
+              re0a653d
+        ;
+rules1  :
+        /* empty */
+        {}
+rules1  : /* empty */
         | xxx
           /* fred */ yyy

tools/prettyprinter/token.cc

-              r33218c6
+              re0a653d
+//                              -*- Mode: C++ -*-
 //
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+// Copyright (C) Peter A. Buhr 2017
 //
 // Pretty Printer, Copyright (C) Richard C. Bilson and Rodolfo G. Esteves 2001
 …
 // Created On       : Wed Jun 28 22:46:23 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 23:07:04 2017
 // Update Count     : 10
+// Last Modified On : Thu Jun 29 09:33:49 2017
+// Update Count     : 9
 //

tools/prettyprinter/token.h

-              r33218c6
+              re0a653d
 // Created On       : Wed Jun 28 22:47:58 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 10:12:42 2017
 // Update Count     : 6
+// Last Modified On : Wed Jun 28 23:02:06 2017
+// Update Count     : 5
 //
+#pragma once
+#ifndef __TOKEN_H__
+#define __TOKEN_H__
 struct Token {
 …
 };
+#endif // __TOKEN_H__
 // Local Variables: //
 // tab-width: 4 //

Context Navigation

Changes in / [33218c6:e0a653d]

Legend: