Changeset 8c3a0336

Timestamp:

Apr 23, 2019, 10:26:14 AM (4 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

ffe2fad

Parents:

deca0f5 (diff), 8f194ee (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' into ctxswitch

Files:

• benchmark/Makefile.am (modified) (1 diff)
• benchmark/Makefile.in (modified) (1 diff)
• doc/proposals/interned_string.cc (added)
• doc/proposals/interned_string.h (added)
• doc/proposals/vtable.md (modified) (5 diffs)
• doc/user/user.tex (modified) (5 diffs)
• libcfa/prelude/prelude-gen.cc (modified) (2 diffs)
• libcfa/src/fstream.cfa (modified) (4 diffs)
• libcfa/src/fstream.hfa (modified) (2 diffs)
• libcfa/src/gmp.hfa (modified) (2 diffs)
• libcfa/src/iostream.cfa (modified) (3 diffs)
• libcfa/src/iostream.hfa (modified) (3 diffs)
• src/Parser/ParseNode.h (modified) (2 diffs)
• src/Parser/parser.yy (modified) (7 diffs)
• src/ResolvExpr/AlternativeFinder.cc (modified) (1 diff)
• src/ResolvExpr/ResolveAssertions.cc (modified) (6 diffs)
• src/ResolvExpr/ResolveAssertions.h (modified) (1 diff)
• src/ResolvExpr/TypeEnvironment.cc (modified) (4 diffs)
• src/ResolvExpr/TypeEnvironment.h (modified) (1 diff)
• src/ResolvExpr/Unify.cc (modified) (1 diff)
• src/SynTree/Declaration.h (modified) (1 diff)
• tests/.expect/completeTypeError.txt (modified) (2 diffs)
• tests/.expect/loopctrl.txt (modified) (2 diffs)
• tests/Makefile.am (modified) (2 diffs)
• tests/Makefile.in (modified) (2 diffs)
• tests/completeTypeError.cfa (modified) (5 diffs)
• tests/coroutine/cntparens.cfa (added)
• tests/coroutine/devicedriver.cfa (modified) (2 diffs)
• tests/function-operator.cfa (modified) (2 diffs)
• tests/io2.cfa (modified) (2 diffs)
• tests/loopctrl.cfa (modified) (3 diffs)

benchmark/Makefile.am

@@ -21 +21 @@
 include $(top_srcdir)/src/cfa.make
 
-AM_CFLAGS = -O2 -Wall -I$(srcdir) -lrt -pthread
-AM_CFAFLAGS = -quiet -in-tree -nodebug -std=c++14
-AM_UPPFLAGS = -quiet -nodebug -multi
+AM_CFLAGS = -O2 -Wall -Wextra -Werror -I$(srcdir) -lrt -pthread
+AM_CFAFLAGS = -quiet -nodebug -in-tree
+AM_UPPFLAGS = -quiet -nodebug -multi -std=c++14
 
 BENCH_V_CC = $(__bench_v_CC_$(__quiet))

benchmark/Makefile.in

@@ -371 +371 @@
 
 # applies to both programs
-AM_CFLAGS = -O2 -Wall -I$(srcdir) -lrt -pthread
-AM_CFAFLAGS = -quiet -in-tree -nodebug -std=c++14
-AM_UPPFLAGS = -quiet -nodebug -multi
+AM_CFLAGS = -O2 -Wall -Wextra -Werror -I$(srcdir) -lrt -pthread
+AM_CFAFLAGS = -quiet -nodebug -in-tree
+AM_UPPFLAGS = -quiet -nodebug -multi -std=c++14
 BENCH_V_CC = $(__bench_v_CC_$(__quiet))
 BENCH_V_CFA = $(__bench_v_CFA_$(__quiet))

doc/proposals/vtable.md

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

doc/user/user.tex

@@ -11 +11 @@
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
-%% Last Modified On : Tue Mar 26 22:10:49 2019
-%% Update Count     : 3411
+%% Last Modified On : Sun Apr 14 11:02:34 2019
+%% Update Count     : 3443
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -514 +514 @@
 sout | 1 ®\® 0 | 1 ®\® 1 | 2 ®\® 8 | -4 ®\® 3 | 5 ®\® 3 | 5 ®\® 32 | 5L ®\® 32 | 5L ®\® 64 | -4 ®\® -3 | -4.0 ®\® -3 | 4.0 ®\® 2.1
            | (1.0f+2.0fi) ®\® (3.0f+2.0fi);
-1 1 256 -64 125 0 3273344365508751233 0 0 -0.015625 18.3791736799526 0.264715-1.1922i
-\end{cfa}
+1 1 256 -64 125 ®0® 3273344365508751233 ®0® ®0® -0.015625 18.3791736799526 0.264715-1.1922i
+\end{cfa}
+Note, ©5 ®\® 32© and ©5L ®\® 64© overflow, and ©-4 ®\® -3© is a fraction but stored in an integer so all three computations generate an integral zero.
 Parenthesis are necessary for complex constants or the expression is parsed as ©1.0f+®(®2.0fi \ 3.0f®)®+2.0fi©.
 The exponentiation operator is available for all the basic types, but for user-defined types, only the integral-computation version is available.
@@ -524 +525 @@
 OT ?®\®?( OT ep, unsigned long int y );
 \end{cfa}
-The user type ©T© must define multiplication one, ©1©, and, ©*©.
+The user type ©T© must define multiplication, one, ©1©, and, ©*©.
 
 
@@ -554 +555 @@
 \subsection{Loop Control}
 
-The ©for©/©while©/©do-while© loop-control allows empty or simplified ranges.
+The ©for©/©while©/©do-while© loop-control allows empty or simplified ranges (see Figure~\ref{f:LoopControlExamples}).
+\begin{itemize}
+\item
 An empty conditional implies ©1©.
-The up-to range ©~©\index{~@©~©} means exclusive range [M,N);
-the up-to range ©~=©\index{~=@©~=©} means inclusive range [M,N].
-The down-to range ©-~©\index{-~@©-~©} means exclusive range [N,M);
-the down-to range ©-~=©\index{-~=@©-~=©} means inclusive range [N,M].
+\item
+The up-to range ©~©\index{~@©~©} means exclusive range [M,N).
+\item
+The up-to range ©~=©\index{~=@©~=©} means inclusive range [M,N].
+\item
+The down-to range ©-~©\index{-~@©-~©} means exclusive range [N,M).
+\item
+The down-to range ©-~=©\index{-~=@©-~=©} means inclusive range [N,M].
+\item
+©@© means put nothing in this field.
+\item
 ©0© is the implicit start value;
+\item
 ©1© is the implicit increment value.
+\item
 The up-to range uses ©+=© for increment;
-the down-to range uses ©-=© for decrement.
+\item
+The down-to range uses ©-=© for decrement.
+\item
 The loop index is polymorphic in the type of the start value or comparison value when start is implicitly ©0©.
+\end{itemize}
+
+\begin{figure}
 \begin{cquote}
-\begin{tabular}{@{}ll|l@{}}
-\multicolumn{2}{c|}{loop control} & \multicolumn{1}{c}{output} \\
+\begin{tabular}{@{}l|l@{}}
+\multicolumn{1}{c|}{loop control} & \multicolumn{1}{c}{output} \\
 \hline
 \begin{cfa}
-while ®()® { sout | "empty"; break; }
-do { sout | "empty"; break; } while ®()®;
-for ®()® { sout | "empty"; break; }
-for ( ®0® ) { sout | "A"; }
-for ( ®1® ) { sout | "A"; }
-for ( ®10® ) { sout | "A"; }
-for ( ®1 ~= 10 ~ 2® ) { sout | "B"; }
-for ( ®10 -~= 1 ~ 2® ) { sout | "C"; }
-for ( ®0.5 ~ 5.5® ) { sout | "D"; }
-for ( ®5.5 -~ 0.5® ) { sout | "E"; }
-for ( ®i; 10® ) { sout | i; }
-for ( ®i; 1 ~= 10 ~ 2® ) { sout | i; }
-for ( ®i; 10 -~= 1 ~ 2® ) { sout | i; }
-for ( ®i; 0.5 ~ 5.5® ) { sout | i; }
-for ( ®i; 5.5 -~ 0.5® ) { sout | i; }
-for ( ®ui; 2u ~= 10u ~ 2u® ) { sout | ui; }
-for ( ®ui; 10u -~= 2u ~ 2u® ) { sout | ui; }
+sout | nlOff;
+while ®()® { sout | "empty"; break; } sout | nl;
+do { sout | "empty"; break; } while ®()®; sout | nl;
+for ®()® { sout | "empty"; break; } sout | nl;
+for ( ®0® ) { sout | "A"; } sout | "zero" | nl;
+for ( ®1® ) { sout | "A"; } sout | nl;
+for ( ®10® ) { sout | "A"; } sout | nl;
+for ( ®1 ~= 10 ~ 2® ) { sout | "B"; } sout | nl;
+for ( ®10 -~= 1 ~ 2® ) { sout | "C"; } sout | nl;
+for ( ®0.5 ~ 5.5® ) { sout | "D"; } sout | nl;
+for ( ®5.5 -~ 0.5® ) { sout | "E"; } sout | nl;
+for ( ®i; 10® ) { sout | i; } sout | nl;
+for ( ®i; 1 ~= 10 ~ 2® ) { sout | i; } sout | nl;
+for ( ®i; 10 -~= 1 ~ 2® ) { sout | i; } sout | nl;
+for ( ®i; 0.5 ~ 5.5® ) { sout | i; } sout | nl;
+for ( ®i; 5.5 -~ 0.5® ) { sout | i; } sout | nl;
+for ( ®ui; 2u ~= 10u ~ 2u® ) { sout | ui; } sout | nl;
+for ( ®ui; 10u -~= 2u ~ 2u® ) { sout | ui; } sout | nl;
 enum { N = 10 };
-for ( ®N® ) { sout | "N"; }
-for ( ®i; N® ) { sout | i; }
-for ( ®i; N -~ 0® ) { sout | i; }
+for ( ®N® ) { sout | "N"; } sout | nl;
+for ( ®i; N® ) { sout | i; } sout | nl;
+for ( ®i; N -~ 0® ) { sout | i; } sout | nl;
 const int start = 3, comp = 10, inc = 2;
-for ( ®i; start ~ comp ~ inc + 1® ) { sout | i; }
+for ( ®i; start ~ comp ~ inc + 1® ) { sout | i; } sout | nl;
+for ( ®i; 1 ~ @® ) { if ( i > 10 ) break;
+        sout | i; } sout | nl;
+for ( ®i; 10 -~ @® ) { if ( i < 0 ) break;
+        sout | i; } sout | nl;
+for ( ®i; 2 ~ @ ~ 2® ) { if ( i > 10 ) break;
+        sout | i; } sout | nl;
+for ( ®i; 2.1 ~ @ ~ @® ) { if ( i > 10.5 ) break;
+        sout | i; i += 1.7; } sout | nl;
+for ( ®i; 10 -~ @ ~ 2® ) { if ( i < 0 ) break;
+        sout | i; } sout | nl;
+for ( ®i; 12.1 ~ @ ~ @® ) { if ( i < 2.5 ) break;
+        sout | i; i -= 1.7; } sout | nl;
+for ( ®i; 5 : j; -5 ~ @® ) { sout | i | j; } sout | nl;
+for ( ®i; 5 : j; -5 -~ @® ) { sout | i | j; } sout | nl;
+for ( ®i; 5 : j; -5 ~ @ ~ 2® ) { sout | i | j; } sout | nl;
+for ( ®i; 5 : j; -5 -~ @ ~ 2® ) { sout | i | j; } sout | nl;
+for ( ®j; -5 ~ @ : i; 5® ) { sout | i | j; } sout | nl;
+for ( ®j; -5 -~ @ : i; 5® ) { sout | i | j; } sout | nl;
+for ( ®j; -5 ~ @ ~ 2 : i; 5® ) { sout | i | j; } sout | nl;
+for ( ®j; -5 -~ @ ~ 2 : i; 5® ) { sout | i | j; } sout | nl;
+for ( ®j; -5 -~ @ ~ 2 : i; 5 : k; 1.5 ~ @® ) {
+        sout | i | j | k; } sout | nl;
+for ( ®j; -5 -~ @ ~ 2 : k; 1.5 ~ @ : i; 5® ) {
+        sout | i | j | k; } sout | nl;
+for ( ®k; 1.5 ~ @ : j; -5 -~ @ ~ 2 : i; 5® ) {
+        sout | i | j | k; } sout | nl;
 \end{cfa}
 &
 \begin{cfa}
-sout | nl;
-sout | nl;
-sout | nl;
-sout | "zero" | nl;
-sout | nl;
-sout | nl;
-sout | nl;
-sout | nl;
-sout | nl;
-sout | nl;
-sout | nl;
-sout | nl;
-sout | nl;
-sout | nl;
-sout | nl;
-sout | nl;
-sout | nl | nl;
-
-sout | nl;
-sout | nl;
-sout | nl | nl;
-
-sout | nl;
-\end{cfa}
-&
-\begin{cfa}
+
 empty
 empty
@@ -645 +664 @@
 
 3 6 9
+
+1 2 3 4 5 6 7 8 9 10
+
+10 9 8 7 6 5 4 3 2 1 0
+
+2 4 6 8 10
+
+2.1 3.8 5.5 7.2 8.9
+
+10 8 6 4 2 0
+
+12.1 10.4 8.7 7 5.3 3.6
+0 -5 1 -4 2 -3 3 -2 4 -1
+0 -5 1 -6 2 -7 3 -8 4 -9
+0 -5 1 -3 2 -1 3 1 4 3
+0 -5 1 -7 2 -9 3 -11 4 -13
+0 -5 1 -4 2 -3 3 -2 4 -1
+0 -5 1 -6 2 -7 3 -8 4 -9
+0 -5 1 -3 2 -1 3 1 4 3
+0 -5 1 -7 2 -9 3 -11 4 -13
+
+0 -5 1.5 1 -7 2.5 2 -9 3.5 3 -11 4.5 4 -13 5.5
+
+0 -5 1.5 1 -7 2.5 2 -9 3.5 3 -11 4.5 4 -13 5.5
+
+0 -5 1.5 1 -7 2.5 2 -9 3.5 3 -11 4.5 4 -13 5.5
 \end{cfa}
 \end{tabular}
 \end{cquote}
+\caption{Loop Control Examples}
+\label{f:LoopControlExamples}
+\end{figure}
 
 

libcfa/prelude/prelude-gen.cc

@@ -10 +10 @@
 // Created On       : Sat Feb 16 08:44:58 2019
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Mar 19 08:19:35 2019
-// Update Count     : 28
+// Last Modified On : Tue Apr  2 17:18:24 2019
+// Update Count     : 37
 // 
 
@@ -118 +118 @@
         { "?!=?", false, "signed int", Normal, "" },
         { "?=?", true, "", Normal, "" }, // void * LHS, zero_t RHS ???
-        { "*?", false, "&", Normal, " | sized(DT)" }, // & ???
+//      { "*?", false, "&", Normal, " | sized(DT)" }, // & ???
+        { "*?", false, "&", Normal, "" }, // & ???
 
         { "?-?", false, "ptrdiff_t", Normal, " | sized(DT)" },

libcfa/src/fstream.cfa

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Mar 28 17:39:53 2019
-// Update Count     : 307
+// Last Modified On : Sat Apr 20 12:03:43 2019
+// Update Count     : 311
 //
 
@@ -33 +33 @@
         os.nlOnOff = nlOnOff;
         os.prt = prt;
+        os.sawNL = false;
         sepSet( os, separator );
         sepSetCur( os, sepGet( os ) );
@@ -162 +163 @@
 void ?{}( ifstream & is, void * file ) {
         is.file = file;
+        is.nlOnOff = false;
 }
 
@@ -173 +175 @@
         open( is, name, "r" );
 }
+
+void nlOn( ifstream & os ) { os.nlOnOff = true; }
+void nlOff( ifstream & os ) { os.nlOnOff = false; }
+bool getANL( ifstream & os ) { return os.nlOnOff; }
 
 int fail( ifstream & is ) {

libcfa/src/fstream.hfa

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

libcfa/src/gmp.hfa

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

libcfa/src/iostream.cfa

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

libcfa/src/iostream.hfa

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

src/Parser/ParseNode.h

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

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Mar 15 14:25:43 2019
-// Update Count     : 4248
+// Last Modified On : Mon Apr 15 15:02:56 2019
+// Update Count     : 4290
 //
 
@@ -185 +185 @@
 
 ForCtrl * forCtrl( ExpressionNode * type, string * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
-        ConstantExpr * constant = dynamic_cast<ConstantExpr *>(type->get_expr());
+        ConstantExpr * constant = dynamic_cast<ConstantExpr *>(type->expr.get());
         if ( constant && (constant->get_constant()->get_value() == "0" || constant->get_constant()->get_value() == "1") ) {
         type = new ExpressionNode( new CastExpr( maybeMoveBuild< Expression >(type), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) ) );
@@ -198 +198 @@
 
 ForCtrl * forCtrl( ExpressionNode * type, ExpressionNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
-        if ( NameExpr * identifier = dynamic_cast<NameExpr *>(index->get_expr()) ) {
+        if ( NameExpr * identifier = dynamic_cast<NameExpr *>(index->expr.get()) ) {
                 return forCtrl( type, new string( identifier->name ), start, compop, comp, inc );
-        } else if ( CommaExpr * commaExpr = dynamic_cast<CommaExpr *>(index->get_expr()) ) {
+        } else if ( CommaExpr * commaExpr = dynamic_cast<CommaExpr *>(index->expr.get()) ) {
                 if ( NameExpr * identifier = dynamic_cast<NameExpr *>(commaExpr->arg1 ) ) {
                         return forCtrl( type, new string( identifier->name ), start, compop, comp, inc );
@@ -334 +334 @@
 %type<en> subrange
 %type<decl> asm_name_opt
-%type<en> asm_operands_opt asm_operands_list asm_operand
+%type<en> asm_operands_opt                              asm_operands_list                       asm_operand
 %type<label> label_list
 %type<en> asm_clobbers_list_opt
 %type<flag> asm_volatile_opt
 %type<en> handler_predicate_opt
-%type<genexpr> generic_association generic_assoc_list
+%type<genexpr> generic_association              generic_assoc_list
 
 // statements
@@ -1164 +1164 @@
         for_control_expression
         | for_control_expression_list ':' for_control_expression
-                { $$ = $3; }
+                // ForCtrl + ForCtrl:
+                //    init + init => multiple declaration statements that are hoisted
+                //    condition + condition => (expression) && (expression)
+                //    change + change => (expression), (expression)
+                {
+                        $1->init->set_last( $3->init );
+                        if ( $1->condition ) {
+                                if ( $3->condition ) {
+                                        $1->condition->expr.reset( new LogicalExpr( $1->condition->expr.release(), $3->condition->expr.release(), true ) );
+                                } // if
+                        } else $1->condition = $3->condition;
+                        if ( $1->change ) {
+                                if ( $3->change ) {
+                                        $1->change->expr.reset( new CommaExpr( $1->change->expr.release(), $3->change->expr.release() ) );
+                                } // if
+                        } else $1->change = $3->change;
+                        $$ = $1;
+                }
         ;
 
@@ -1174 +1191 @@
         | declaration comma_expression_opt ';' comma_expression_opt // C99, declaration has ';'
                 { $$ = new ForCtrl( $1, $2, $4 ); }
+
         | comma_expression                                                                      // CFA
                 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
@@ -1188 +1206 @@
         | comma_expression ';' comma_expression inclexcl comma_expression '~' comma_expression // CFA
                 { $$ = forCtrl( $3, $1, $3->clone(), $4, $5, $7 ); }
+
+                // There is a S/R conflicit if ~ and -~ are factored out.
+        | comma_expression ';' comma_expression '~' '@'         // CFA
+                { $$ = forCtrl( $3, $1, $3->clone(), OperKinds::LThan, nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
+        | comma_expression ';' comma_expression ErangeDown '@' // CFA
+                { $$ = forCtrl( $3, $1, $3->clone(), OperKinds::GThan, nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
         | comma_expression ';' comma_expression '~' '@' '~' comma_expression // CFA
                 { $$ = forCtrl( $3, $1, $3->clone(), OperKinds::LThan, nullptr, $7 ); }

src/ResolvExpr/AlternativeFinder.cc

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

src/ResolvExpr/ResolveAssertions.cc

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

src/ResolvExpr/ResolveAssertions.h

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

src/ResolvExpr/TypeEnvironment.cc

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

src/ResolvExpr/TypeEnvironment.h

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

src/ResolvExpr/Unify.cc

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

src/SynTree/Declaration.h

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

tests/.expect/completeTypeError.txt

@@ -1 @@
-completeTypeError.cfa:33:1 error: No reasonable alternatives for expression Applying untyped:
-  Name: *?
-...to:
-  Name: v
+completeTypeError.cfa:34:1 error: Cannot choose between 2 alternatives for expression
+Generated Cast of:
+  Applying untyped:
+    Name: *?
+  ...to:
+    Name: x
 
-completeTypeError.cfa:34:1 error: No reasonable alternatives for expression Applying untyped:
-  Name: *?
-...to:
-  Name: y
+... to: nothing Alternatives are:
+Cost ( 0, 1, 2, 0, 1, -1, 0 ): Generated Cast of:
+     Application of
+       Variable Expression: *?: forall
+         DT: object type
+         function
+       ... with parameters
+         intrinsic pointer to instance of type DT (not function type)
+       ... returning
+         _retval__operator_deref: reference to instance of type DT (not function type)
+         ... with attributes:
+           Attribute with name: unused
+
+
+     ... to arguments
+       Variable Expression: x: pointer to instance of struct A with body 0
+
+   ... to: nothing
+ (types:
+   void 
+ )
+ Environment:( _80_4_DT ) -> instance of struct A with body 0 (no widening)
+
+
+Cost ( 0, 1, 2, 0, 1, -1, 0 ): Generated Cast of:
+     Application of
+       Variable Expression: *?: forall
+         DT: object type
+         function
+       ... with parameters
+         intrinsic pointer to instance of type DT (not function type)
+       ... returning
+         _retval__operator_deref: reference to instance of type DT (not function type)
+         ... with attributes:
+           Attribute with name: unused
+
+
+     ... to arguments
+       Variable Expression: x: pointer to instance of struct B with body 1
+
+   ... to: nothing
+ (types:
+   void 
+ )
+ Environment:( _80_4_DT ) -> instance of struct B with body 1 (no widening)
+
+
 
 completeTypeError.cfa:35:1 error: No reasonable alternatives for expression Applying untyped:
@@ -24 +69 @@
   Name: v
 
-completeTypeError.cfa:58:1 error: No reasonable alternatives for expression Applying untyped:
+completeTypeError.cfa:59:1 error: No reasonable alternatives for expression Applying untyped:
   Name: baz
 ...to:
   Name: y
 
-completeTypeError.cfa:59:1 error: No reasonable alternatives for expression Applying untyped:
+completeTypeError.cfa:60:1 error: No reasonable alternatives for expression Applying untyped:
   Name: quux
 ...to:
   Name: y
 
-completeTypeError.cfa:60:1 error: No reasonable alternatives for expression Applying untyped:
-  Name: *?
-...to:
-  Name: y
-
-completeTypeError.cfa:72:1 error: No resolvable alternatives for expression Applying untyped:
+completeTypeError.cfa:72:1 error: No alternatives with satisfiable assertions for Applying untyped:
   Name: baz
 ...to:
   Name: z
 
-Alternatives with failing assertions are:
+   Unsatisfiable alternative:
 Cost ( 0, 1, 0, 0, 1, -5, 0 ): Application of
-     Variable Expression: baz: forall
-       T: sized object type
-       ... with assertions
-         ?=?: pointer to function
-         ... with parameters
-           reference to instance of type T (not function type)
-           instance of type T (not function type)
-         ... returning
-           _retval__operator_assign: instance of type T (not function type)
-           ... with attributes:
-             Attribute with name: unused
+         Variable Expression: baz: forall
+           T: sized object type
+           ... with assertions
+             ?=?: pointer to function
+             ... with parameters
+               reference to instance of type T (not function type)
+               instance of type T (not function type)
+             ... returning
+               _retval__operator_assign: instance of type T (not function type)
+               ... with attributes:
+                 Attribute with name: unused
 
 
-         ?{}: pointer to function
+             ?{}: pointer to function
+             ... with parameters
+               reference to instance of type T (not function type)
+             ... returning nothing
+
+             ?{}: pointer to function
+             ... with parameters
+               reference to instance of type T (not function type)
+               instance of type T (not function type)
+             ... returning nothing
+
+             ^?{}: pointer to function
+             ... with parameters
+               reference to instance of type T (not function type)
+             ... returning nothing
+
+
+           function
          ... with parameters
-           reference to instance of type T (not function type)
+           pointer to instance of type T (not function type)
          ... returning nothing
 
-         ?{}: pointer to function
-         ... with parameters
-           reference to instance of type T (not function type)
-           instance of type T (not function type)
-         ... returning nothing
+       ... to arguments
+         Variable Expression: z: pointer to instance of type T (not function type)
 
-         ^?{}: pointer to function
-         ... with parameters
-           reference to instance of type T (not function type)
-         ... returning nothing
+     (types:
+       void 
+     )
+     Environment:( _99_0_T ) -> instance of type T (not function type) (no widening)
+
+   Could not satisfy assertion:
+?=?: pointer to function
+     ... with parameters
+       reference to instance of type _99_0_T (not function type)
+       instance of type _99_0_T (not function type)
+     ... returning
+       _retval__operator_assign: instance of type _99_0_T (not function type)
+       ... with attributes:
+         Attribute with name: unused
 
 
-       function
-     ... with parameters
-       pointer to instance of type T (not function type)
-     ... returning nothing
-
-   ... to arguments
-     Variable Expression: z: pointer to instance of type T (not function type)
-
- (types:
-   void 
- )
- Environment:( _99_0_T ) -> instance of type T (not function type) (no widening)
-
-
-

tests/.expect/loopctrl.txt

@@ -19 +19 @@
 10 8 6 4 2
 
+1 2 3 4 5 6 7 8 9 10
+10 9 8 7 6 5 4 3 2 1 0
 2 4 6 8 10
 2.1 3.8 5.5 7.2 8.9
@@ -42 +44 @@
 (10 10)(9 9)(8 8)(7 7)(6 6)(5 5)(4 4)(3 3)(2 2)(1 1)(0 0)
 (10 10)(9 9)(8 8)(7 7)(6 6)(5 5)(4 4)(3 3)(2 2)(1 1)(0 0)
+
+0 -5 1 -4 2 -3 3 -2 4 -1 5 0 6 1 7 2 8 3 9 4
+0 -5 1 -6 2 -7 3 -8 4 -9 5 -10 6 -11 7 -12 8 -13 9 -14
+0 -5 1 -3 2 -1 3 1 4 3 5 5 6 7 7 9 8 11 9 13
+0 -5 1 -7 2 -9 3 -11 4 -13 5 -15 6 -17 7 -19 8 -21 9 -23
+
+0 -5 1 -4 2 -3 3 -2 4 -1 5 0 6 1 7 2 8 3 9 4
+0 -5 1 -6 2 -7 3 -8 4 -9 5 -10 6 -11 7 -12 8 -13 9 -14
+0 -5 1 -3 2 -1 3 1 4 3 5 5 6 7 7 9 8 11 9 13
+0 -5 1 -7 2 -9 3 -11 4 -13 5 -15 6 -17 7 -19 8 -21 9 -23
+
+0 -5 1.5 1 -7 2.5 2 -9 3.5 3 -11 4.5 4 -13 5.5 5 -15 6.5 6 -17 7.5 7 -19 8.5 8 -21 9.5 9 -23 10.5
+0 -5 1.5 1 -7 2.5 2 -9 3.5 3 -11 4.5 4 -13 5.5 5 -15 6.5 6 -17 7.5 7 -19 8.5 8 -21 9.5 9 -23 10.5
+0 -5 1.5 1 -7 2.5 2 -9 3.5 3 -11 4.5 4 -13 5.5 5 -15 6.5 6 -17 7.5 7 -19 8.5 8 -21 9.5 9 -23 10.5

tests/Makefile.am

@@ -44 +44 @@
 CC = @CFACC@
 
-PRETTY_PATH=cd ${srcdir} &&
+PRETTY_PATH=mkdir -p $(dir $(abspath ${@})) && cd ${srcdir} &&
 
 .PHONY: list .validate
@@ -85 +85 @@
 #----------------------------------------------------------------------------------------------------------------
 
+# Use for all tests, make sure the path are correct and all flags are added
+CFACOMPILETEST=$(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) $($(shell echo "${@}_FLAGS" | sed 's/-\|\//_/g'))
+
+# Use for tests that either generate an executable, print directyl to stdout or the make command is expected to fail
+CFATEST_STDOUT=$(CFACOMPILETEST) -o $(abspath ${@})
+
+# Use for tests where the make command is expecte to succeed but the expected.txt should be compared to stderr
+CFATEST_STDERR=$(CFACOMPILETEST) 2> $(abspath ${@})
+
+#----------------------------------------------------------------------------------------------------------------
+
 # implicit rule so not all test require a rule
 % : %.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+        $(CFATEST_STDOUT)
 
 % : %.cpp
         $(PRETTY_PATH) $(CXXCOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 
-declarationSpecifier: declarationSpecifier.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+#------------------------------------------------------------------------------
+# TARGET WITH STANDARD RULE BUT CUSTOM FLAGS
+#------------------------------------------------------------------------------
+# Expected failures
+declarationSpecifier_FLAGS= -CFA -XCFA -p
+gccExtensions_FLAGS= -CFA -XCFA -p
+extension_FLAGS= -CFA -XCFA -p
+attributes_FLAGS= -CFA -XCFA -p
+functions_FLAGS= -CFA -XCFA -p
+KRfunctions_FLAGS= -CFA -XCFA -p
+gmp_FLAGS= -lgmp
 
-gccExtensions : gccExtensions.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+#------------------------------------------------------------------------------
+# Expected failures
+completeTypeError_FLAGS= -DERR1
 
-extension : extension.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+#------------------------------------------------------------------------------
+# CUSTOM TARGET
+#------------------------------------------------------------------------------
+typedefRedef-ERR1: typedefRedef.cfa $(CFACC)
+        $(CFATEST_STDOUT) -DERR1
 
-attributes : attributes.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+alloc-ERROR: alloc.cfa $(CFACC)
+        $(CFATEST_STDOUT) -DERR1
 
-functions: functions.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+nested-types-ERR1: nested-types.cfa $(CFACC)
+        $(CFATEST_STDOUT) -DERR1
 
-KRfunctions : KRfunctions.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+nested-types-ERR2: nested-types.cfa $(CFACC)
+        $(CFATEST_STDOUT) -DERR2
 
-sched-ext-parse : sched-ext-parse.c $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+raii/dtor-early-exit-ERR1: raii/dtor-early-exit.cfa $(CFACC)
+        $(CFATEST_STDOUT) -DERR1
 
-gmp : gmp.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) -lgmp $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+raii/dtor-early-exit-ERR2: raii/dtor-early-exit.cfa $(CFACC)
+        $(CFATEST_STDOUT) -DERR2
+
+raii/memberCtors-ERR1: raii/memberCtors.cfa $(CFACC)
+        $(CFATEST_STDOUT) -DERR1
+
+raii/ctor-autogen-ERR1: raii/ctor-autogen.cfa $(CFACC)
+        $(CFATEST_STDOUT) -DERR1
 
 #builtins
 builtins/sync: builtins/sync.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) 2> $(abspath ${@}) -fsyntax-only
-
-#------------------------------------------------------------------------------
-
-#To make errors path independent we need to cd into the correct directories
-completeTypeError : completeTypeError.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
-
-typedefRedef-ERR1: typedefRedef.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
-
-alloc-ERROR: alloc.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
-
-fallthrough-ERROR: fallthrough.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
-
-nested-types-ERR1: nested-types.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
-
-nested-types-ERR2: nested-types.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) -DERR2 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
-
-# Constructor/destructor tests
-raii/dtor-early-exit-ERR1: raii/dtor-early-exit.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
-
-raii/dtor-early-exit-ERR2: raii/dtor-early-exit.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) -DERR2 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
-
-raii/memberCtors-ERR1: raii/memberCtors.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
-
-raii/ctor-autogen-ERR1: raii/ctor-autogen.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+        $(CFATEST_STDERR) -fsyntax-only
 
 # Warnings
 warnings/self-assignment: warnings/self-assignment.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) 2> $(abspath ${@}) -fsyntax-only
+        $(CFATEST_STDERR) -fsyntax-only

tests/Makefile.in

@@ -386 +386 @@
         -quiet @CFA_FLAGS@ -DIN_DIR="${abs_srcdir}/.in/" \
         ${DEBUG_FLAGS} ${INSTALL_FLAGS} ${ARCH_FLAGS}
-PRETTY_PATH = cd ${srcdir} &&
+PRETTY_PATH = mkdir -p $(dir $(abspath ${@})) && cd ${srcdir} &&
 avl_test_SOURCES = avltree/avl_test.cfa avltree/avl0.cfa avltree/avl1.cfa avltree/avl2.cfa avltree/avl3.cfa avltree/avl4.cfa avltree/avl-private.cfa
 # automake doesn't know we still need C/CPP rules so pretend like we have a C program
 _dummy_hack_SOURCES = .dummy_hack.c .dummy_hackxx.cpp
+
+#----------------------------------------------------------------------------------------------------------------
+
+# Use for all tests, make sure the path are correct and all flags are added
+CFACOMPILETEST = $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) $($(shell echo "${@}_FLAGS" | sed 's/-\|\//_/g'))
+
+# Use for tests that either generate an executable, print directyl to stdout or the make command is expected to fail
+CFATEST_STDOUT = $(CFACOMPILETEST) -o $(abspath ${@})
+
+# Use for tests where the make command is expecte to succeed but the expected.txt should be compared to stderr
+CFATEST_STDERR = $(CFACOMPILETEST) 2> $(abspath ${@})
+
+#------------------------------------------------------------------------------
+# TARGET WITH STANDARD RULE BUT CUSTOM FLAGS
+#------------------------------------------------------------------------------
+# Expected failures
+declarationSpecifier_FLAGS = -CFA -XCFA -p
+gccExtensions_FLAGS = -CFA -XCFA -p
+extension_FLAGS = -CFA -XCFA -p
+attributes_FLAGS = -CFA -XCFA -p
+functions_FLAGS = -CFA -XCFA -p
+KRfunctions_FLAGS = -CFA -XCFA -p
+gmp_FLAGS = -lgmp
+
+#------------------------------------------------------------------------------
+# Expected failures
+completeTypeError_FLAGS = -DERR1
 all: all-am
 
@@ -772 +799 @@
 # implicit rule so not all test require a rule
 % : %.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+        $(CFATEST_STDOUT)
 
 % : %.cpp
         $(PRETTY_PATH) $(CXXCOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 
-declarationSpecifier: declarationSpecifier.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
-
-gccExtensions : gccExtensions.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
-
-extension : extension.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
-
-attributes : attributes.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
-
-functions: functions.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
-
-KRfunctions : KRfunctions.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
-
-sched-ext-parse : sched-ext-parse.c $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
-
-gmp : gmp.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) -lgmp $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+#------------------------------------------------------------------------------
+# CUSTOM TARGET
+#------------------------------------------------------------------------------
+typedefRedef-ERR1: typedefRedef.cfa $(CFACC)
+        $(CFATEST_STDOUT) -DERR1
+
+alloc-ERROR: alloc.cfa $(CFACC)
+        $(CFATEST_STDOUT) -DERR1
+
+nested-types-ERR1: nested-types.cfa $(CFACC)
+        $(CFATEST_STDOUT) -DERR1
+
+nested-types-ERR2: nested-types.cfa $(CFACC)
+        $(CFATEST_STDOUT) -DERR2
+
+raii/dtor-early-exit-ERR1: raii/dtor-early-exit.cfa $(CFACC)
+        $(CFATEST_STDOUT) -DERR1
+
+raii/dtor-early-exit-ERR2: raii/dtor-early-exit.cfa $(CFACC)
+        $(CFATEST_STDOUT) -DERR2
+
+raii/memberCtors-ERR1: raii/memberCtors.cfa $(CFACC)
+        $(CFATEST_STDOUT) -DERR1
+
+raii/ctor-autogen-ERR1: raii/ctor-autogen.cfa $(CFACC)
+        $(CFATEST_STDOUT) -DERR1
 
 #builtins
 builtins/sync: builtins/sync.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) 2> $(abspath ${@}) -fsyntax-only
-
-#------------------------------------------------------------------------------
-
-#To make errors path independent we need to cd into the correct directories
-completeTypeError : completeTypeError.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
-
-typedefRedef-ERR1: typedefRedef.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
-
-alloc-ERROR: alloc.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
-
-fallthrough-ERROR: fallthrough.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
-
-nested-types-ERR1: nested-types.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
-
-nested-types-ERR2: nested-types.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) -DERR2 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
-
-# Constructor/destructor tests
-raii/dtor-early-exit-ERR1: raii/dtor-early-exit.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
-
-raii/dtor-early-exit-ERR2: raii/dtor-early-exit.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) -DERR2 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
-
-raii/memberCtors-ERR1: raii/memberCtors.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
-
-raii/ctor-autogen-ERR1: raii/ctor-autogen.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
+        $(CFATEST_STDERR) -fsyntax-only
 
 # Warnings
 warnings/self-assignment: warnings/self-assignment.cfa $(CFACC)
-        $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) 2> $(abspath ${@}) -fsyntax-only
+        $(CFATEST_STDERR) -fsyntax-only
 
 # Tell versions [3.59,3.63) of GNU make to not export all variables.

tests/completeTypeError.cfa

@@ -5 +5 @@
 forall(dtype T | sized(T)) void quux(T *);
 
-struct A; // incomplete
-struct B {}; // complete
+struct A;       // incomplete
+struct B {};    // complete
 
 int main() {
-        int *i;
-        void *v;
+        int * i;
+        void * v;
 
         A * x;
@@ -19 +19 @@
         // okay
         *i;
-        *x; // picks B
+        *y;
         *z;
         foo(i);
@@ -32 +32 @@
         // bad
         *v;
-        *y;
+        *x;     // ambiguous
         foo(v);
         baz(v);
@@ -52 +52 @@
 void qux(T * y) {
         // okay
+        *y;
         bar(y);
         qux(y);
@@ -58 +59 @@
         baz(y);
         quux(y);
-        *y;
 }
 

tests/coroutine/devicedriver.cfa

@@ -10 +10 @@
 // Created On       : Sat Mar 16 15:30:34 2019
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Mar 19 15:59:06 2019
-// Update Count     : 87
+// Last Modified On : Sat Apr 20 09:07:19 2019
+// Update Count     : 90
 // 
 
@@ -67 +67 @@
         char msg[65], byte;
         Driver driver = { msg };
+
+        sin | nlOn;                                                                                     // read newline (all) characters
   eof: for () {                                                                                 // read until end of file
                 sin | byte;                                                                             // read one character

tests/function-operator.cfa

@@ -10 +10 @@
 // Created On       : Fri Aug 25 15:21:11 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Dec  4 21:37:09 2018
-// Update Count     : 9
+// Last Modified On : Thu Apr 11 18:27:45 2019
+// Update Count     : 10
 //
 
@@ -62 +62 @@
 
 // test ?()(T, ...) -- ?() with function call-by-reference
-forall(otype Generator, otype GenRet | { GenRet ?()(Generator &); }, dtype Iter, otype T| Iterator(Iter, T) | Assignable(T, GenRet))
+forall(otype Generator, otype GenRet | { GenRet ?()(Generator &); }, dtype Iter, otype T | Iterator(Iter, T) | Assignable(T, GenRet))
 void generate(Iter first, Iter last, Generator & gen) {
         int i = 0;

tests/io2.cfa

@@ -10 +10 @@
 // Created On       : Wed Mar  2 16:56:02 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Dec 21 08:20:14 2018
-// Update Count     : 112
+// Last Modified On : Thu Apr 18 08:03:30 2019
+// Update Count     : 113
 //
 
@@ -97 +97 @@
         sout | 1 | sepOff | 2 | 3;                                                      // locally turn off implicit separator
         sout | sepOn | sepOn | 1 | 2 | 3 | sepOn | sepOff | sepOn | '\n' | nonl; // no separator at start/end of line
-        sout | 1 | 2 | 3 | "\n\n" | sepOn | nonl;                                       // no separator at start of next line
+        sout | 1 | 2 | 3 | "\n\n" | sepOn | nonl;                       // no separator at start of next line
         sout | 1 | 2 | 3;
         sout | nl;

tests/loopctrl.cfa

@@ -10 +10 @@
 // Created On       : Wed Aug  8 18:32:59 2018
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb 21 08:54:47 2019
-// Update Count     : 86
+// Last Modified On : Sat Apr 13 11:03:09 2019
+// Update Count     : 104
 // 
 
@@ -56 +56 @@
         for ( ui; 10u -~= 2u ~ 2u ) { sout | ui; }                      sout | nl | nl;
 
+        // @ means do nothing
+        for ( i; 1 ~ @ ) {
+          if ( i > 10 ) break;
+                sout | i;
+        }                                                                                                       sout | nl;
+        for ( i; 10 -~ @ ) {
+          if ( i < 0 ) break;
+                sout | i;
+        }                                                                                                       sout | nl;
         for ( i; 2 ~ @ ~ 2 ) {
           if ( i > 10 ) break;
@@ -94 +103 @@
         for ( s; (S){10,10} -~ (S){0} ~ (S){1} ) { sout | s; } sout | nl;
         for ( s; (S){10,10} -~= (S){0} ) { sout | s; }           sout | nl;
-        for ( s; (S){10,10} -~= (S){0} ~ (S){1} ) { sout | s; } sout | nl;
+        for ( s; (S){10,10} -~= (S){0} ~ (S){1} ) { sout | s; } sout | nl | nl;
+
+        for ( i; 10 : j; -5 ~ @ ) { sout | i | j; } sout | nl;
+        for ( i; 10 : j; -5 -~ @ ) { sout | i | j; } sout | nl;
+        for ( i; 10 : j; -5 ~ @ ~ 2 ) { sout | i | j; } sout | nl;
+        for ( i; 10 : j; -5 -~ @ ~ 2 ) { sout | i | j; } sout | nl | nl;
+
+        for ( j; -5 ~ @ : i; 10 ) { sout | i | j; } sout | nl;
+        for ( j; -5 -~ @ : i; 10 ) { sout | i | j; } sout | nl;
+        for ( j; -5 ~ @ ~ 2 : i; 10 ) { sout | i | j; } sout | nl;
+        for ( j; -5 -~ @ ~ 2 : i; 10 ) { sout | i | j; } sout | nl | nl;
+
+        for ( j; -5 -~ @ ~ 2 : i; 10 : k; 1.5 ~ @ ) { sout | i | j | k; } sout | nl;
+        for ( j; -5 -~ @ ~ 2 : k; 1.5 ~ @ : i; 10 ) { sout | i | j | k; } sout | nl;
+        for ( k; 1.5 ~ @ : j; -5 -~ @ ~ 2 : i; 10 ) { sout | i | j | k; } sout | nl;
 }