Changeset b1e63ac5 for src

src/CodeGen/CodeGenerator.cc

-              r9c951e3
+              rb1e63ac5
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Wed May 10 14:45:00 2017
 // Update Count     : 484
+// Last Modified On : Thu Jun  8 16:00:00 2017
+// Update Count     : 485
 //
 …
                 } // if
         } // extension
-        ostream & CodeGenerator::Indenter::operator()( ostream & output ) const {
-          return output << string( cg.cur_indent, ' ' );
+        }
-        ostream & operator<<( ostream & output, const CodeGenerator::Indenter &indent ) {
-                return indent( output );
+        }
         CodeGenerator::LabelPrinter & CodeGenerator::LabelPrinter::operator()( std::list< Label > & l ) {
 …
+        }
+        CodeGenerator::CodeGenerator( std::ostream & os, bool pretty, bool genC, bool lineMarks ) : indent( *this), cur_indent( 0 ), insideFunction( false ), output( os ), printLabels( *this ), pretty( pretty ), genC( genC ), lineMarks( lineMarks ) {}
+        CodeGenerator::CodeGenerator( std::ostream & os, std::string init, int indentation, bool infunp )
+                        : indent( *this), cur_indent( indentation ), insideFunction( infunp ), output( os ), printLabels( *this ) {
+                //output << std::string( init );
+        }
+        CodeGenerator::CodeGenerator( std::ostream & os, char * init, int indentation, bool infunp )
+                        : indent( *this ), cur_indent( indentation ), insideFunction( infunp ), output( os ), printLabels( *this ) {
+                //output << std::string( init );
+        }
+        CodeGenerator::CodeGenerator( std::ostream & os, bool pretty, bool genC, bool lineMarks ) : indent( CodeGenerator::tabsize ), insideFunction( false ), output( os ), printLabels( *this ), pretty( pretty ), genC( genC ), lineMarks( lineMarks ) {}
         string CodeGenerator::mangleName( DeclarationWithType * decl ) {
 …
                         output << " {" << endl;
                         cur_indent += CodeGenerator::tabsize;
+                        ++indent;
                         for ( std::list< Declaration* >::iterator i = memb.begin(); i != memb.end(); i++ ) {
                                 output << lineDirective( *i ) << indent;
 …
                         } // for
                         cur_indent -= CodeGenerator::tabsize;
+                        --indent;
                         output << indent << "}";
 …
                         output << " {" << endl;
                         cur_indent += CodeGenerator::tabsize;
+                        ++indent;
                         for ( std::list< Declaration* >::iterator i = memb.begin(); i != memb.end();  i++) {
                                 ObjectDecl * obj = dynamic_cast< ObjectDecl* >( *i );
 …
                         } // for
                         cur_indent -= CodeGenerator::tabsize;
+                        --indent;
                         output << indent << "}";
 …
+        }
         void CodeGenerator::visit( TraitDecl * traitDecl ) {}
+        void CodeGenerator::visit( __attribute__((unused)) TraitDecl * traitDecl ) {}
         void CodeGenerator::visit( TypedefDecl * typeDecl ) {
 …
+        }
         void CodeGenerator::printDesignators( std::list< Expression * > & designators ) {
                 typedef std::list< Expression * > DesignatorList;
+        void CodeGenerator::visit( Designation * designation ) {
+                std::list< Expression * > designators = designation->get_designators();
                 if ( designators.size() == 0 ) return;
                 for ( DesignatorList::iterator iter = designators.begin(); iter != designators.end(); ++iter ) {
                         if ( dynamic_cast< NameExpr * >( *iter ) ) {
                                 // if expression is a name, then initializing aggregate member
+                for ( Expression * des : designators ) {
+                        if ( dynamic_cast< NameExpr * >( des ) || dynamic_cast< VariableExpr * >( des ) ) {
+                                // if expression is a NameExpr or VariableExpr, then initializing aggregate member
                                 output << ".";
                                 (*iter)->accept( *this );
+                                des->accept( *this );
                         } else {
                                 // if not a simple name, it has to be a constant expression, i.e. an array designator
+                                // otherwise, it has to be a ConstantExpr or CastExpr, initializing array eleemnt
                                 output << "[";
                                 (*iter)->accept( *this );
+                                des->accept( *this );
                                 output << "]";
                         } // if
 …
         void CodeGenerator::visit( SingleInit * init ) {
-                printDesignators( init->get_designators() );
                 init->get_value()->accept( *this );
+        }
         void CodeGenerator::visit( ListInit * init ) {
+                printDesignators( init->get_designators() );
+                auto initBegin = init->begin();
+                auto initEnd = init->end();
+                auto desigBegin = init->get_designations().begin();
+                auto desigEnd = init->get_designations().end();
                 output << "{ ";
+                if ( init->begin() == init->end() ) {
+                        // illegal to leave initializer list empty for scalar initializers, but always legal to have 0
+                        output << "0";
+                } else {
+                        genCommaList( init->begin(), init->end() );
+                } // if
+                for ( ; initBegin != initEnd && desigBegin != desigEnd; ) {
+                        (*desigBegin)->accept( *this );
+                        (*initBegin)->accept( *this );
+                        ++initBegin, ++desigBegin;
+                        if ( initBegin != initEnd ) {
+                                output << ", ";
+                        }
+                }
                 output << " }";
+        }
+        void CodeGenerator::visit( ConstructorInit * init ){
+                assertf( initBegin == initEnd && desigBegin == desigEnd, "Initializers and designators not the same length. %s", toString( init ).c_str() );
+        }
+        void CodeGenerator::visit( __attribute__((unused)) ConstructorInit * init ){
                 assertf( ! genC, "ConstructorInit nodes should not reach code generation." );
                 // xxx - generate something reasonable for constructor/destructor pairs
 …
         void CodeGenerator::visit( TypeExpr * typeExpr ) {
+                assertf( ! genC, "TypeExpr should not reach code generation." );
+                output<< genType( typeExpr->get_type(), "", pretty, genC );
+                // if ( genC ) std::cerr << "typeexpr still exists: " << typeExpr << std::endl;
+                // assertf( ! genC, "TypeExpr should not reach code generation." );
+                if ( ! genC ) {
+                        output<< genType( typeExpr->get_type(), "", pretty, genC );
+                }
+        }
 …
                 std::list< Statement * > & stmts = stmtExpr->get_statements()->get_kids();
                 output << lineDirective( stmtExpr) << "({" << std::endl;
                 cur_indent += CodeGenerator::tabsize;
+                ++indent;
                 unsigned int numStmts = stmts.size();
                 unsigned int i = 0;
 …
                         ++i;
+                }
                 cur_indent -= CodeGenerator::tabsize;
+                --indent;
                 output << indent << "})";
+        }
 …
                 output << "{" << endl;
                 cur_indent += CodeGenerator::tabsize;
+                ++indent;
                 for ( std::list<Statement *>::iterator i = ks.begin(); i != ks.end();  i++ ) {
 …
                         } // if
                 } // for
                 cur_indent -= CodeGenerator::tabsize;
+                --indent;
                 output << indent << "}";
 …
                 output << "{" << std::endl;
                 cur_indent += CodeGenerator::tabsize;
+                ++indent;
                 acceptAll( switchStmt->get_statements(), *this );
                 cur_indent -= CodeGenerator::tabsize;
+                --indent;
                 output << indent << "}";
+        }
 …
                 std::list<Statement *> sts = caseStmt->get_statements();
                 cur_indent += CodeGenerator::tabsize;
+                ++indent;
                 for ( std::list<Statement *>::iterator i = sts.begin(); i != sts.end();  i++) {
                         output << indent << printLabels( (*i)->get_labels() )  ;
 …
                         output << endl;
                 } // for
                 cur_indent -= CodeGenerator::tabsize;
+                --indent;
+        }
 …
+        }
+        void CodeGenerator::visit( ThrowStmt * throwStmt ) {
+                assertf( ! genC, "Throw statements should not reach code generation." );
+                output << ((throwStmt->get_kind() == ThrowStmt::Terminate) ?
+                           "throw" : "throwResume");
+                if (throwStmt->get_expr()) {
+                        output << " ";
+                        throwStmt->get_expr()->accept( *this );
+                }
+                if (throwStmt->get_target()) {
+                        output << " _At ";
+                        throwStmt->get_target()->accept( *this );
+                }
+                output << ";";
+        }
         void CodeGenerator::visit( WhileStmt * whileStmt ) {
                 if ( whileStmt->get_isDoWhile() ) {
 …
+        }
         void CodeGenerator::visit( NullStmt * nullStmt ) {
+        void CodeGenerator::visit( __attribute__((unused)) NullStmt * nullStmt ) {
                 //output << indent << CodeGenerator::printLabels( nullStmt->get_labels() );
                 output << "/* null statement */ ;";

src/CodeGen/CodeGenerator.h

-              r9c951e3
+              rb1e63ac5
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Wed May 10 10:57:00 2017
 // Update Count     : 51
+// Last Modified On : Thu Jun  8 15:48:00 2017
+// Update Count     : 52
 //
 …
 #include "SymTab/Indexer.h"
+#include "Common/Indenter.h"
 #include "Common/utility.h"
 …
                 //*** Initializer
+                virtual void visit( Designation * );
                 virtual void visit( SingleInit * );
                 virtual void visit( ListInit * );
 …
                 virtual void visit( BranchStmt * );
                 virtual void visit( ReturnStmt * );
+                virtual void visit( ThrowStmt * );
                 virtual void visit( WhileStmt * );
                 virtual void visit( ForStmt * );
 …
                 template< class Iterator > void genCommaList( Iterator begin, Iterator end );
-                struct Indenter {
-                        Indenter(CodeGenerator &cg) : cg(cg) {}
-                        CodeGenerator & cg;
-                        std::ostream& operator()(std::ostream & os) const;
-                };
                 struct LabelPrinter {
 …
           private:
                 Indenter indent;
-                int cur_indent;
                 bool insideFunction;
                 std::ostream &output;
 …
                 bool lineMarks = false;
-                void printDesignators( std::list< Expression * > & );
                 void handleStorageClass( DeclarationWithType *decl );
                 void handleAggregate( AggregateDecl *aggDecl, const std::string & kind );

src/CodeGen/FixNames.cc

-              r9c951e3
+              rb1e63ac5
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Mar 16 07:50:30 2017
 // Update Count     : 16
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Jun 28 15:26:00 2017
+// Update Count     : 20
 //
 …
         void FixNames::fixDWT( DeclarationWithType *dwt ) {
                 if ( dwt->get_name() != "" ) {
                         if ( LinkageSpec::isDecoratable( dwt->get_linkage() ) ) {
+                        if ( LinkageSpec::isMangled( dwt->get_linkage() ) ) {
                                 dwt->set_mangleName( SymTab::Mangler::mangle( dwt ) );
                                 dwt->set_scopeLevel( scopeLevel );
 …
                                 throw SemanticError("Main expected to have 0, 2 or 3 arguments\n", functionDecl);
+                        }
                         functionDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new ConstantExpr( Constant( new BasicType( Type::Qualifiers(), BasicType::SignedInt ), "0") ) ) );
+                        functionDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new ConstantExpr( Constant::from_int( 0 ) ) ) );
                         CodeGen::FixMain::registerMain( functionDecl );
+                }

src/CodeTools/TrackLoc.cc

-              r9c951e3
+              rb1e63ac5
 #include "TrackLoc.h"
+#include <cstdlib>
 #include <iostream>
 #include <sstream>
+#include <stack>
 #include <string>
 #include <cstdlib>
+#include <typeindex>
 #include "Common/utility.h"
+#include "Common/PassVisitor.h"
 #include "Common/VectorMap.h"
 #include "GenPoly/GenPoly.h"
 …
 #include "SynTree/Declaration.h"
 #include "SynTree/Initializer.h"
-#include "SynTree/Visitor.h"
 namespace CodeTools {
     std::ostream & operator<<(std::ostream & out, CodeLocation const & loc) {
         return out << loc.filename << '[' << loc.linenumber << ']';
+    }
+        std::ostream & operator<<(std::ostream & out, CodeLocation const & loc) {
+                return out << loc.filename << '[' << loc.linenumber << ']';
+        }
+        class LocationPrinter : public Visitor {
+                unsigned int printLevel;
+                unsigned int currentLevel;
+        class LocationPrinter {
+                size_t printLevel;
-                CodeLocation *parent;
                 CodeLocation *lastNode;
+    public:
         LocationPrinter(unsigned int printLevel) :
+            Visitor(), printLevel(printLevel), currentLevel(0),
                         parent(nullptr), lastNode(nullptr)
         {}
+                std::stack< CodeLocation * > parents;
+        public:
+                LocationPrinter(size_t printLevel) :
+                        printLevel(printLevel), lastNode(nullptr)
+                {}
         void print(char const * name, BaseSyntaxNode *node) {
             for (unsigned int i = 0 ; i < currentLevel ; ++i) {
+                void print( const std::string& name, BaseSyntaxNode *node) {
+                        for (size_t i = 0 ; i < parents.size() ; ++i) {
                                 std::cout << "    ";
+                        }
             if (2 <= printLevel) {
+                        if (2 <= printLevel) {
                                 std::cout << name << '@';
+                        }
                         std::cout << node->location << std::endl;
+        }
+                }
                 void atNode(char const * name, BaseSyntaxNode *node) {
                         if (-1 == node->location.linenumber) {
                                 if (nullptr != parent) {
                                         node->location.linenumber = parent->linenumber;
                                         node->location.filename = parent->filename;
                                 } else if (nullptr != lastNode) {
                                         node->location.linenumber = lastNode->linenumber;
                                         node->location.filename = lastNode->filename;
                                 } else {
                                         std::cerr << "Top level node has no CodeLocation " <<
                                                                  name << std::endl;
+                void atNode( BaseSyntaxNode *node ) {
+                        std::string name = std::type_index(typeid(*node)).name();
+                        if ( node->location.isUnset() ) {
+                                if ( !parents.empty() ) {
+                                        node->location = *parents.top();
+                                }
+                                else if (nullptr != lastNode) {
+                                        node->location = *lastNode;
+                                }
+                                else {
+                                        std::cerr << "Top level node has no CodeLocation " << name << std::endl;
                                         exit(EXIT_FAILURE);
+                                }
+                        }
                         if (0 < printLevel) {
                                 print(name, node);
+                                print( name, node );
+                        }
                         lastNode = &node->location;
+                }
+#define VISIT_FUNCTION(SyntaxNodeType)                          \
+                virtual void visit(SyntaxNodeType *node) {      \
+                        atNode(#SyntaxNodeType, node);                  \
+                        ++currentLevel;                                                 \
+                        CodeLocation * myParent = parent;               \
+                        parent = &node->location;                               \
+                        Visitor::visit(node);                                   \
+                        parent = myParent;                                              \
+                        --currentLevel;                                                 \
+                void previsit(BaseSyntaxNode * node) {
+                        atNode(node);
+                        parents.push( &node->location );
+                }
+                VISIT_FUNCTION(ObjectDecl)
+                VISIT_FUNCTION(FunctionDecl)
+                VISIT_FUNCTION(StructDecl)
+                VISIT_FUNCTION(UnionDecl)
+                VISIT_FUNCTION(EnumDecl)
+                VISIT_FUNCTION(TraitDecl)
+                VISIT_FUNCTION(TypeDecl)
+                VISIT_FUNCTION(TypedefDecl)
+                VISIT_FUNCTION(AsmDecl)
+                VISIT_FUNCTION(CompoundStmt)
+                VISIT_FUNCTION(ExprStmt)
+                VISIT_FUNCTION(AsmStmt)
+                VISIT_FUNCTION(IfStmt)
+                VISIT_FUNCTION(WhileStmt)
+                VISIT_FUNCTION(ForStmt)
+                VISIT_FUNCTION(SwitchStmt)
+                VISIT_FUNCTION(CaseStmt)
+                VISIT_FUNCTION(BranchStmt)
+                VISIT_FUNCTION(ReturnStmt)
+                VISIT_FUNCTION(TryStmt)
+                VISIT_FUNCTION(CatchStmt)
+                VISIT_FUNCTION(FinallyStmt)
+                VISIT_FUNCTION(NullStmt)
+                VISIT_FUNCTION(DeclStmt)
+                VISIT_FUNCTION(ImplicitCtorDtorStmt)
+                VISIT_FUNCTION(ApplicationExpr)
+                VISIT_FUNCTION(UntypedExpr)
+                VISIT_FUNCTION(NameExpr)
+                VISIT_FUNCTION(CastExpr)
+                VISIT_FUNCTION(AddressExpr)
+                VISIT_FUNCTION(LabelAddressExpr)
+                VISIT_FUNCTION(UntypedMemberExpr)
+                VISIT_FUNCTION(MemberExpr)
+                VISIT_FUNCTION(VariableExpr)
+                VISIT_FUNCTION(ConstantExpr)
+                VISIT_FUNCTION(SizeofExpr)
+                VISIT_FUNCTION(AlignofExpr)
+                VISIT_FUNCTION(UntypedOffsetofExpr)
+                VISIT_FUNCTION(OffsetofExpr)
+                VISIT_FUNCTION(OffsetPackExpr)
+                VISIT_FUNCTION(AttrExpr)
+                VISIT_FUNCTION(LogicalExpr)
+                VISIT_FUNCTION(ConditionalExpr)
+                VISIT_FUNCTION(CommaExpr)
+                VISIT_FUNCTION(TypeExpr)
+                VISIT_FUNCTION(AsmExpr)
+                VISIT_FUNCTION(ImplicitCopyCtorExpr)
+                VISIT_FUNCTION(ConstructorExpr)
+                VISIT_FUNCTION(CompoundLiteralExpr)
+                VISIT_FUNCTION(UntypedValofExpr)
+                VISIT_FUNCTION(RangeExpr)
+                VISIT_FUNCTION(UntypedTupleExpr)
+                VISIT_FUNCTION(TupleExpr)
+                VISIT_FUNCTION(TupleIndexExpr)
+                VISIT_FUNCTION(MemberTupleExpr)
+                VISIT_FUNCTION(TupleAssignExpr)
+                VISIT_FUNCTION(StmtExpr)
+                VISIT_FUNCTION(UniqueExpr)
+                VISIT_FUNCTION(VoidType)
+                VISIT_FUNCTION(BasicType)
+                VISIT_FUNCTION(PointerType)
+                VISIT_FUNCTION(ArrayType)
+                VISIT_FUNCTION(FunctionType)
+                VISIT_FUNCTION(StructInstType)
+                VISIT_FUNCTION(UnionInstType)
+                VISIT_FUNCTION(EnumInstType)
+                VISIT_FUNCTION(TraitInstType)
+                VISIT_FUNCTION(TypeInstType)
+                VISIT_FUNCTION(TupleType)
+                VISIT_FUNCTION(TypeofType)
+                VISIT_FUNCTION(AttrType)
+                VISIT_FUNCTION(VarArgsType)
+                VISIT_FUNCTION(ZeroType)
+                VISIT_FUNCTION(OneType)
+                VISIT_FUNCTION(SingleInit)
+                VISIT_FUNCTION(ListInit)
+                VISIT_FUNCTION(ConstructorInit)
+                //VISIT_FUNCTION(Subrange)
+                //VISIT_FUNCTION(Constant)
+                void postvisit( __attribute__((unused)) BaseSyntaxNode * node ) {
+                        parents.pop();
+                }
         }; // LocationPrinter
+        void fillLocations( std::list< Declaration * > & translationUnit,
+                        unsigned int printLevel) {
+                LocationPrinter printer(printLevel);
+        void fillLocations( std::list< Declaration * > & translationUnit, size_t printLevel) {
+                PassVisitor<LocationPrinter> printer(printLevel);
                 acceptAll( translationUnit, printer );
+        }

src/CodeTools/TrackLoc.h

-              r9c951e3
+              rb1e63ac5
         // printLevel: how much printing while filling in the node locations.
         // 0 - No Printing, 1 - Print Location, 2 - Print Node Type and Location
+        void fillLocations( std::list< Declaration * > &translationUnit,
+                        unsigned int printLevel = 0 );
+        void fillLocations( std::list< Declaration * > &translationUnit, size_t printLevel = 0 );
 }  // namespace CodeTools

src/Common/Assert.cc

-              r9c951e3
+              rb1e63ac5
 extern const char * __progname;                                                 // global name of running executable (argv[0])
 #define CFA_ASSERT_FMT "*CFA assertion error* from program \"%s\" in \"%s\" at line %d in file \"%s\""
+#define CFA_ASSERT_FMT "*CFA assertion error* \"%s\" from program \"%s\" in \"%s\" at line %d in file \"%s\""
 // called by macro assert in assert.h
 void __assert_fail( const char *assertion, const char *file, unsigned int line, const char *function ) {
         fprintf( stderr, CFA_ASSERT_FMT ".\n", __progname, function, line, file );
+        fprintf( stderr, CFA_ASSERT_FMT ".\n", assertion, __progname, function, line, file );
         abort();
+}
 …
 // called by macro assertf
 void __assert_fail_f( const char *assertion, const char *file, unsigned int line, const char *function, const char *fmt, ... ) {
         fprintf( stderr, CFA_ASSERT_FMT ": ", __progname, function, line, file );
+        fprintf( stderr, CFA_ASSERT_FMT ": ", assertion, __progname, function, line, file );
         va_list args;
         va_start( args, fmt );

src/Common/utility.h

-              r9c951e3
+              rb1e63ac5
 };
+template< typename T >
+struct ValueGuardPtr {
+        T old;
+        T* ref;
+        ValueGuardPtr(T * inRef) : old( inRef ? *inRef : T() ), ref(inRef) {}
+        ~ValueGuardPtr() { if( ref ) *ref = old; }
+};
+template< typename T >
+struct ValueGuardPtr< std::list< T > > {
+        std::list< T > old;
+        std::list< T >* ref;
+        ValueGuardPtr( std::list< T > * inRef) : old(), ref(inRef) {
+                if( ref ) { swap( *ref, old ); }
+        }
+        ~ValueGuardPtr() { if( ref ) { swap( *ref, old ); } }
+};
 // -----------------------------------------------------------------------------
 // Helper struct and function to support
 …
 // for ( val : group_iterate( container1, container2, ... ) ) {}
 // syntax to have a for each that iterates multiple containers of the same length
 // TODO: update to use variadic arguments
+// TODO: update to use variadic arguments, perfect forwarding
 template< typename T1, typename T2 >
 …
         {}
+        CodeLocation( const CodeLocation& rhs ) = default;
         bool isSet () const {
                 return -1 != linenumber;

src/Concurrency/Keywords.cc

-              r9c951e3
+              rb1e63ac5
                 FunctionDecl * forwardDeclare( StructDecl * );
                 ObjectDecl * addField( StructDecl * );
                 void addRoutines( StructDecl *, ObjectDecl *, FunctionDecl * );
+                void addRoutines( ObjectDecl *, FunctionDecl * );
                 virtual bool is_target( StructDecl * decl ) = 0;
 …
         void ConcurrentSueKeyword::visit(StructDecl * decl) {
                 Visitor::visit(decl);
                 if( decl->get_name() == type_name ) {
+                if( decl->get_name() == type_name && decl->has_body() ) {
                         assert( !type_decl );
                         type_decl = decl;
 …
                 FunctionDecl * func = forwardDeclare( decl );
                 ObjectDecl * field = addField( decl );
                 addRoutines( decl, field, func );
+                addRoutines( field, func );
+        }
 …
+        }
         void ConcurrentSueKeyword::addRoutines( StructDecl * decl, ObjectDecl * field, FunctionDecl * func ) {
+        void ConcurrentSueKeyword::addRoutines( ObjectDecl * field, FunctionDecl * func ) {
                 CompoundStmt * statement = new CompoundStmt( noLabels );
                 statement->push_back(

src/ControlStruct/ForExprMutator.cc

-              r9c951e3
+              rb1e63ac5
 // file "LICENCE" distributed with Cforall.
 //
 // ForExprMutator.cc --
+// ForExprMutator.cc --
 //
 // Author           : Rodolfo G. Esteves
 …
 namespace ControlStruct {
+        Statement *ForExprMutator::mutate( ForStmt *forStmt ) {
+                // recurse down all nest for loops to hoist any initializer declarations to make them C89 (rather than C99)
+                forStmt->set_body( forStmt->get_body()->acceptMutator( *this ) );
+                std::list<Statement *> &init = forStmt->get_initialization();
+        Statement *ForExprMutator::postmutate( ForStmt *forStmt ) {
+                // hoist any initializer declarations to make them C89 (rather than C99)
+                std::list<Statement *> &init = forStmt->get_initialization();
                 if ( init.size() == 0 ) {
                         return forStmt;
 …
                 forStmt->set_initialization( std::list<Statement *>() );
                 return block;
-                return forStmt;
+        }
 } // namespace ControlStruct

src/ControlStruct/ForExprMutator.h

-              r9c951e3
+              rb1e63ac5
 // file "LICENCE" distributed with Cforall.
 //
 // ForExprMutator.h --
+// ForExprMutator.h --
 //
 // Author           : Rodolfo G. Esteves
 …
 namespace ControlStruct {
         class ForExprMutator : public Mutator {
+        class ForExprMutator {
           public:
                 virtual Statement *mutate( ForStmt * );
+                Statement *postmutate( ForStmt * );
         };
 } // namespace ControlStruct

src/ControlStruct/Mutate.cc

-              r9c951e3
+              rb1e63ac5
 #include "Common/utility.h"
+#include "Common/PassVisitor.h"
 #include "SynTree/Visitor.h"
 …
         void mutate( std::list< Declaration * > translationUnit ) {
                 // hoist initialization out of for statements
                 ForExprMutator formut;
+                PassVisitor<ForExprMutator> formut;
                 // normalizes label definitions and generates multi-level exit labels

src/ControlStruct/module.mk

-              r9c951e3
+              rb1e63ac5
 ## Author           : Richard C. Bilson
 ## Created On       : Mon Jun  1 17:49:17 2015
 ## Last Modified By : Peter A. Buhr
 ## Last Modified On : Thu Aug  4 11:38:06 2016
 ## Update Count     : 3
+## Last Modified By : Andrew Beach
+## Last Modified On : Wed Jun 28 16:15:00 2017
+## Update Count     : 4
 ###############################################################################
 SRC +=  ControlStruct/LabelGenerator.cc \
         ControlStruct/LabelFixer.cc \
         ControlStruct/MLEMutator.cc \
+        ControlStruct/MLEMutator.cc \
         ControlStruct/Mutate.cc \
         ControlStruct/ForExprMutator.cc
+        ControlStruct/ForExprMutator.cc \
+        ControlStruct/ExceptTranslate.cc

src/GenPoly/Box.cc

-              r9c951e3
+              rb1e63ac5
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat May 13 09:26:38 2017
 // Update Count     : 341
+// Last Modified On : Wed Jun 21 15:49:59 2017
+// Update Count     : 346
 //
 …
 namespace GenPoly {
         namespace {
-                const std::list<Label> noLabels;
                 FunctionType *makeAdapterType( FunctionType *adaptee, const TyVarMap &tyVars );
 …
                         void passTypeVars( ApplicationExpr *appExpr, Type *polyRetType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );
                         /// wraps a function application with a new temporary for the out-parameter return value
                         Expression *addRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *retType, std::list< Expression *>::iterator &arg );
+                        Expression *addRetParam( ApplicationExpr *appExpr, Type *retType, std::list< Expression *>::iterator &arg );
                         /// Replaces all the type parameters of a generic type with their concrete equivalents under the current environment
                         void replaceParametersWithConcrete( ApplicationExpr *appExpr, std::list< Expression* >& params );
 …
                         Type *replaceWithConcrete( ApplicationExpr *appExpr, Type *type, bool doClone = true );
                         /// wraps a function application returning a polymorphic type with a new temporary for the out-parameter return value
                         Expression *addDynRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *polyType, std::list< Expression *>::iterator &arg );
+                        Expression *addDynRetParam( ApplicationExpr *appExpr, Type *polyType, std::list< Expression *>::iterator &arg );
                         Expression *applyAdapter( ApplicationExpr *appExpr, FunctionType *function, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );
                         void boxParam( Type *formal, Expression *&arg, const TyVarMap &exprTyVars );
 …
                   public:
                         template< typename DeclClass >
                         DeclClass *handleDecl( DeclClass *decl, Type *type );
+                        DeclClass *handleDecl( DeclClass *decl );
                         template< typename AggDecl >
                         AggDecl * handleAggDecl( AggDecl * aggDecl );
 …
         Statement *makeAlignTo( Expression *lhs, Expression *rhs ) {
                 // check that the lhs is zeroed out to the level of rhs
                 Expression *ifCond = makeOp( "?&?", lhs, makeOp( "?-?", rhs, new ConstantExpr( Constant( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), "1" ) ) ) );
+                Expression *ifCond = makeOp( "?&?", lhs, makeOp( "?-?", rhs, new ConstantExpr( Constant::from_ulong( 1 ) ) ) );
                 // if not aligned, increment to alignment
                 Expression *ifExpr = makeOp( "?+=?", lhs->clone(), makeOp( "?-?", rhs->clone(), ifCond->clone() ) );
 …
                 // initialize size and alignment to 0 and 1 (will have at least one member to re-edit size)
                 addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( sizeParam ), new ConstantExpr( Constant( sizeAlignType->clone(), "0" ) ) ) );
                 addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( alignParam ), new ConstantExpr( Constant( sizeAlignType->clone(), "1" ) ) ) );
+                addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( sizeParam ), new ConstantExpr( Constant::from_ulong( 0 ) ) ) );
+                addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( alignParam ), new ConstantExpr( Constant::from_ulong( 1 ) ) ) );
                 unsigned long n_members = 0;
                 bool firstMember = true;
 …
                 // calculate union layout in function body
                 addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( sizeParam ), new ConstantExpr( Constant( sizeAlignType->clone(), "1" ) ) ) );
                 addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( alignParam ), new ConstantExpr( Constant( sizeAlignType->clone(), "1" ) ) ) );
+                addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( sizeParam ), new ConstantExpr( Constant::from_ulong( 1 ) ) ) );
+                addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( alignParam ), new ConstantExpr( Constant::from_ulong( 1 ) ) ) );
                 for ( std::list< Declaration* >::const_iterator member = unionDecl->get_members().begin(); member != unionDecl->get_members().end(); ++member ) {
                         DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( *member );
 …
                 DeclarationWithType *Pass1::mutate( FunctionDecl *functionDecl ) {
                         if ( functionDecl->get_statements() ) {         // empty routine body ?
+                                // std::cerr << "mutating function: " << functionDecl->get_mangleName() << std::endl;
                                 doBeginScope();
                                 scopeTyVars.beginScope();
 …
                                 retval = oldRetval;
                                 doEndScope();
+                                // std::cerr << "end function: " << functionDecl->get_mangleName() << std::endl;
                         } // if
                         return functionDecl;
 …
+                }
                 Expression *Pass1::addRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *retType, std::list< Expression *>::iterator &arg ) {
+                Expression *Pass1::addRetParam( ApplicationExpr *appExpr, Type *retType, std::list< Expression *>::iterator &arg ) {
                         // Create temporary to hold return value of polymorphic function and produce that temporary as a result
                         // using a comma expression.
 …
+                }
                 Expression *Pass1::addDynRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *dynType, std::list< Expression *>::iterator &arg ) {
+                Expression *Pass1::addDynRetParam( ApplicationExpr *appExpr, Type *dynType, std::list< Expression *>::iterator &arg ) {
                         assert( env );
                         Type *concrete = replaceWithConcrete( appExpr, dynType );
                         // add out-parameter for return value
                         return addRetParam( appExpr, function, concrete, arg );
+                        return addRetParam( appExpr, concrete, arg );
+                }
 …
 //                      if ( ! function->get_returnVals().empty() && isPolyType( function->get_returnVals().front()->get_type(), tyVars ) ) {
                         if ( isDynRet( function, tyVars ) ) {
                                 ret = addRetParam( appExpr, function, function->get_returnVals().front()->get_type(), arg );
+                                ret = addRetParam( appExpr, function->get_returnVals().front()->get_type(), arg );
                         } // if
                         std::string mangleName = mangleAdapterName( function, tyVars );
 …
                 Expression *Pass1::mutate( ApplicationExpr *appExpr ) {
                         // std::cerr << "mutate appExpr: ";
+                        // std::cerr << "mutate appExpr: " << InitTweak::getFunctionName( appExpr ) << std::endl;
                         // for ( TyVarMap::iterator i = scopeTyVars.begin(); i != scopeTyVars.end(); ++i ) {
                         //      std::cerr << i->first << " ";
 …
                         ReferenceToType *dynRetType = isDynRet( function, exprTyVars );
+                        // std::cerr << function << std::endl;
+                        // std::cerr << "scopeTyVars: ";
+                        // printTyVarMap( std::cerr, scopeTyVars );
+                        // std::cerr << "exprTyVars: ";
+                        // printTyVarMap( std::cerr, exprTyVars );
+                        // std::cerr << "env: " << *env << std::endl;
+                        // std::cerr << needsAdapter( function, scopeTyVars ) << ! needsAdapter( function, exprTyVars) << std::endl;
                         // NOTE: addDynRetParam needs to know the actual (generated) return type so it can make a temp variable, so pass the result type from the appExpr
                         // passTypeVars needs to know the program-text return type (i.e. the distinction between _conc_T30 and T3(int))
                         // concRetType may not be a good name in one or both of these places. A more appropriate name change is welcome.
                         if ( dynRetType ) {
+                                // std::cerr << "dynRetType: " << dynRetType << std::endl;
                                 Type *concRetType = appExpr->get_result()->isVoid() ? nullptr : appExpr->get_result();
                                 ret = addDynRetParam( appExpr, function, concRetType, arg ); // xxx - used to use dynRetType instead of concRetType
+                                ret = addDynRetParam( appExpr, concRetType, arg ); // xxx - used to use dynRetType instead of concRetType
                         } else if ( needsAdapter( function, scopeTyVars ) && ! needsAdapter( function, exprTyVars) ) { // xxx - exprTyVars is used above...?
                                 // xxx - the ! needsAdapter check may be incorrect. It seems there is some situation where an adapter is applied where it shouldn't be, and this fixes it for some cases. More investigation is needed.
 …
                 template< typename DeclClass >
                 DeclClass * Pass2::handleDecl( DeclClass *decl, Type *type ) {
+                DeclClass * Pass2::handleDecl( DeclClass *decl ) {
                         DeclClass *ret = static_cast< DeclClass *>( Parent::mutate( decl ) );
 …
                 DeclarationWithType * Pass2::mutate( FunctionDecl *functionDecl ) {
                         functionDecl = safe_dynamic_cast< FunctionDecl * > ( handleDecl( functionDecl, functionDecl->get_functionType() ) );
+                        functionDecl = safe_dynamic_cast< FunctionDecl * > ( handleDecl( functionDecl ) );
                         FunctionType * ftype = functionDecl->get_functionType();
                         if ( ! ftype->get_returnVals().empty() && functionDecl->get_statements() ) {
 …
                 ObjectDecl * Pass2::mutate( ObjectDecl *objectDecl ) {
                         return handleDecl( objectDecl, objectDecl->get_type() );
+                        return handleDecl( objectDecl );
+                }
 …
                         addToTyVarMap( typeDecl, scopeTyVars );
                         if ( typeDecl->get_base() ) {
                                 return handleDecl( typeDecl, typeDecl->get_base() );
+                                return handleDecl( typeDecl );
                         } else {
                                 return Parent::mutate( typeDecl );
 …
                 TypedefDecl * Pass2::mutate( TypedefDecl *typedefDecl ) {
                         return handleDecl( typedefDecl, typedefDecl->get_base() );
+                        return handleDecl( typedefDecl );
+                }
 …
                 /// Returns an index expression into the offset array for a type
                 Expression *makeOffsetIndex( Type *objectType, long i ) {
+                        std::stringstream offset_namer;
+                        offset_namer << i;
+                        ConstantExpr *fieldIndex = new ConstantExpr( Constant( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), offset_namer.str() ) );
+                        ConstantExpr *fieldIndex = new ConstantExpr( Constant::from_ulong( i ) );
                         UntypedExpr *fieldOffset = new UntypedExpr( new NameExpr( "?[?]" ) );
                         fieldOffset->get_args().push_back( new NameExpr( offsetofName( mangleType( objectType ) ) ) );
 …
                                 // all union members are at offset zero
                                 delete offsetofExpr;
                                 return new ConstantExpr( Constant( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), "0" ) );
+                                return new ConstantExpr( Constant::from_ulong( 0 ) );
                         } else return offsetofExpr;
+                }
 …
                                         std::list< Initializer* > inits;
                                         for ( std::list< Declaration* >::const_iterator member = baseMembers.begin(); member != baseMembers.end(); ++member ) {
+                                                DeclarationWithType *memberDecl;
+                                                if ( DeclarationWithType *origMember = dynamic_cast< DeclarationWithType* >( *member ) ) {
+                                                        memberDecl = origMember->clone();
+                                                if ( DeclarationWithType *memberDecl = dynamic_cast< DeclarationWithType* >( *member ) ) {
+                                                        inits.push_back( new SingleInit( new OffsetofExpr( ty->clone(), memberDecl ) ) );
                                                 } else {
                                                         memberDecl = new ObjectDecl( (*member)->get_name(), Type::StorageClasses(), LinkageSpec::Cforall, 0, offsetType->clone(), 0 );
+                                                        assertf( false, "Requesting offset of Non-DWT member: %s", toString( *member ).c_str() );
+                                                }
-                                                inits.push_back( new SingleInit( new OffsetofExpr( ty->clone(), memberDecl ) ) );
+                                        }

src/GenPoly/CopyParams.cc

r9c951e3	rb1e63ac5
45	45
46	46	CopyParams::CopyParams() : namer( "_cp" ) {}
47
48		~~static const std::list< Label > noLabels;~~
49	47
50	48	void CopyParams::visit( FunctionDecl *funcDecl ) {

src/GenPoly/DeclMutator.cc

-              r9c951e3
+              rb1e63ac5
 // Author           : Aaron B. Moss
 // Created On       : Fri Nov 27 14:44:00 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Aug  4 11:16:43 2016
 // Update Count     : 3
+// Last Modified By : Andrew Beach
+// Last Modified On : Thu Jun 22 13:49:00 2017
+// Update Count     : 4
 //
 …
 namespace GenPoly {
-        namespace {
-                const std::list<Label> noLabels;
+        }
         DeclMutator::DeclMutator() : Mutator(), declsToAdd(1), declsToAddAfter(1) {}
         DeclMutator::~DeclMutator() {}
         void DeclMutator::mutateDeclarationList( std::list< Declaration* > &decls ) {
                 for ( std::list< Declaration* >::iterator decl = decls.begin(); ; ++decl ) {
 …
                         if ( decl == decls.end() ) break;
                         // run mutator on declaration
                         *decl = maybeMutate( *decl, *this );
 …
                 newBack->splice( newBack->end(), *back );
                 declsToAdd.pop_back();
                 back = declsToAddAfter.rbegin();
                 newBack = back + 1;
 …
                 CompoundStmt *compoundStmt = dynamic_cast< CompoundStmt* >(stmt);
                 if ( compoundStmt ) return mutate( compoundStmt );
                 doBeginScope();
                 // run mutator on statement
                 stmt = maybeMutate( stmt, *this );
 …
                 doBeginScope();
                 for ( std::list< Statement* >::iterator stmt = stmts.begin(); ; ++stmt ) {
                         // add any new declarations after the previous statement
 …
                         if ( stmt == stmts.end() ) break;
                         // run mutator on statement
                         *stmt = maybeMutate( *stmt, *this );
 …
                         declsToAdd.back().clear();
+                }
                 doEndScope();
+        }
 …
                 return compoundStmt;
+        }
         Statement* DeclMutator::mutate(IfStmt *ifStmt) {
                 ifStmt->set_condition( maybeMutate( ifStmt->get_condition(), *this ) );
 …
                 return ifStmt;
+        }
         Statement* DeclMutator::mutate(WhileStmt *whileStmt) {
                 whileStmt->set_condition( maybeMutate( whileStmt->get_condition(), *this ) );
 …
                 return whileStmt;
+        }
         Statement* DeclMutator::mutate(ForStmt *forStmt) {
                 mutateAll( forStmt->get_initialization(), *this );
 …
                 return forStmt;
+        }
         Statement* DeclMutator::mutate(SwitchStmt *switchStmt) {
                 switchStmt->set_condition( maybeMutate( switchStmt->get_condition(), *this ) );
 …
                 return switchStmt;
+        }
         Statement* DeclMutator::mutate(CaseStmt *caseStmt) {
                 caseStmt->set_condition( maybeMutate( caseStmt->get_condition(), *this ) );
 …
                 return caseStmt;
+        }
         Statement* DeclMutator::mutate(TryStmt *tryStmt) {
                 tryStmt->set_block( maybeMutate( tryStmt->get_block(), *this ) );
 …
                 return tryStmt;
+        }
         Statement* DeclMutator::mutate(CatchStmt *catchStmt) {
                 catchStmt->set_decl( maybeMutate( catchStmt->get_decl(), *this ) );
+                catchStmt->set_cond( maybeMutate( catchStmt->get_cond(), *this ) );
                 catchStmt->set_body( mutateStatement( catchStmt->get_body() ) );
                 return catchStmt;

src/GenPoly/InstantiateGeneric.cc

-              r9c951e3
+              rb1e63ac5
 #include "InstantiateGeneric.h"
-#include "DeclMutator.h"
 #include "GenPoly.h"
 #include "ScopedSet.h"
 #include "ScrubTyVars.h"
+#include "PolyMutator.h"
+#include "Common/PassVisitor.h"
+#include "Common/ScopedMap.h"
+#include "Common/UniqueName.h"
+#include "Common/utility.h"
 #include "ResolvExpr/typeops.h"
 …
 #include "SynTree/Type.h"
+#include "Common/ScopedMap.h"
 #include "Common/UniqueName.h"
+#include "Common/utility.h"
+#include "InitTweak/InitTweak.h"
 namespace GenPoly {
 …
+        }
-        // collect the environments of each TypeInstType so that type variables can be replaced
-        // xxx - possibly temporary solution. Access to type environments is required in GenericInstantiator, but it needs to be a DeclMutator which does not provide easy access to the type environments.
-        class EnvFinder final : public GenPoly::PolyMutator {
-        public:
-                using GenPoly::PolyMutator::mutate;
-                virtual Type * mutate( TypeInstType * inst ) override {
-                        if ( env ) envMap[inst] = env;
-                        return inst;
+                }
-                // don't want to associate an environment with TypeInstTypes that occur in function types - this may actually only apply to function types belonging to DeclarationWithTypes (or even just FunctionDecl)?
-                virtual Type * mutate( FunctionType * ftype ) override {
-                        return ftype;
+                }
-                std::unordered_map< ReferenceToType *, TypeSubstitution * > envMap;
-        };
         /// Mutator pass that replaces concrete instantiations of generic types with actual struct declarations, scoped appropriately
         class GenericInstantiator final : public DeclMutator {
+        struct GenericInstantiator final : public WithTypeSubstitution, public WithDeclsToAdd, public WithVisitorRef<GenericInstantiator>, public WithGuards {
                 /// Map of (generic type, parameter list) pairs to concrete type instantiations
                 InstantiationMap< AggregateDecl, AggregateDecl > instantiations;
 …
                 /// Namer for concrete types
                 UniqueName typeNamer;
+                /// Reference to mapping of environments
+                const std::unordered_map< ReferenceToType *, TypeSubstitution * > & envMap;
+        public:
+                GenericInstantiator( const std::unordered_map< ReferenceToType *, TypeSubstitution * > & envMap ) : DeclMutator(), instantiations(), dtypeStatics(), typeNamer("_conc_"), envMap( envMap ) {}
+                using DeclMutator::mutate;
+                virtual Type* mutate( StructInstType *inst ) override;
+                virtual Type* mutate( UnionInstType *inst ) override;
+                virtual void doBeginScope() override;
+                virtual void doEndScope() override;
+                /// Should not make use of type environment to replace types of function parameter and return values.
+                bool inFunctionType = false;
+                GenericInstantiator() : instantiations(), dtypeStatics(), typeNamer("_conc_") {}
+                Type* postmutate( StructInstType *inst );
+                Type* postmutate( UnionInstType *inst );
+                void premutate( FunctionType * ftype ) {
+                        GuardValue( inFunctionType );
+                        inFunctionType = true;
+                }
+                void beginScope();
+                void endScope();
         private:
                 /// Wrap instantiation lookup for structs
 …
         void instantiateGeneric( std::list< Declaration* > &translationUnit ) {
+                EnvFinder finder;
+                mutateAll( translationUnit, finder );
+                GenericInstantiator instantiator( finder.envMap );
+                instantiator.mutateDeclarationList( translationUnit );
+                PassVisitor<GenericInstantiator> instantiator;
+                mutateAll( translationUnit, instantiator );
+        }
 …
         Type *GenericInstantiator::replaceWithConcrete( Type *type, bool doClone ) {
                 if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( type ) ) {
+                        if ( envMap.count( typeInst ) ) {
+                                TypeSubstitution * env = envMap.at( typeInst );
+                        if ( env && ! inFunctionType ) {
                                 Type *concrete = env->lookup( typeInst->get_name() );
                                 if ( concrete ) {
 …
+        Type* GenericInstantiator::mutate( StructInstType *inst ) {
+                // mutate subtypes
+                Type *mutated = Mutator::mutate( inst );
+                inst = dynamic_cast< StructInstType* >( mutated );
+                if ( ! inst ) return mutated;
+        Type* GenericInstantiator::postmutate( StructInstType *inst ) {
                 // exit early if no need for further mutation
                 if ( inst->get_parameters().empty() ) return inst;
 …
                                 concDecl->set_body( inst->get_baseStruct()->has_body() );
                                 substituteMembers( inst->get_baseStruct()->get_members(), *inst->get_baseParameters(), typeSubs, concDecl->get_members() );
                                 DeclMutator::addDeclaration( concDecl );
                                 insert( inst, typeSubs, concDecl );
                                 concDecl->acceptMutator( *this ); // recursively instantiate members
+                                insert( inst, typeSubs, concDecl ); // must insert before recursion
+                                concDecl->acceptMutator( *visitor ); // recursively instantiate members
+                                declsToAddBefore.push_back( concDecl ); // must occur before declaration is added so that member instantiations appear first
+                        }
                         StructInstType *newInst = new StructInstType( inst->get_qualifiers(), concDecl->get_name() );
 …
+        }
+        Type* GenericInstantiator::mutate( UnionInstType *inst ) {
+                // mutate subtypes
+                Type *mutated = Mutator::mutate( inst );
+                inst = dynamic_cast< UnionInstType* >( mutated );
+                if ( ! inst ) return mutated;
+        Type* GenericInstantiator::postmutate( UnionInstType *inst ) {
                 // exit early if no need for further mutation
                 if ( inst->get_parameters().empty() ) return inst;
 …
                                 concDecl->set_body( inst->get_baseUnion()->has_body() );
                                 substituteMembers( inst->get_baseUnion()->get_members(), *inst->get_baseParameters(), typeSubs, concDecl->get_members() );
                                 DeclMutator::addDeclaration( concDecl );
                                 insert( inst, typeSubs, concDecl );
                                 concDecl->acceptMutator( *this ); // recursively instantiate members
+                                insert( inst, typeSubs, concDecl ); // must insert before recursion
+                                concDecl->acceptMutator( *visitor ); // recursively instantiate members
+                                declsToAddBefore.push_back( concDecl ); // must occur before declaration is added so that member instantiations appear first
+                        }
                         UnionInstType *newInst = new UnionInstType( inst->get_qualifiers(), concDecl->get_name() );
 …
+        }
+        void GenericInstantiator::doBeginScope() {
+                DeclMutator::doBeginScope();
+        void GenericInstantiator::beginScope() {
                 instantiations.beginScope();
                 dtypeStatics.beginScope();
+        }
+        void GenericInstantiator::doEndScope() {
+                DeclMutator::doEndScope();
+        void GenericInstantiator::endScope() {
                 instantiations.endScope();
                 dtypeStatics.endScope();

src/GenPoly/Lvalue.cc

r9c951e3	rb1e63ac5
36	36	namespace GenPoly {
37	37	namespace {
38		~~const std::list<Label> noLabels;~~
39
40	38	/// Replace uses of lvalue returns with appropriate pointers
41	39	class Pass1 : public Mutator {

src/GenPoly/PolyMutator.cc

-              r9c951e3
+              rb1e63ac5
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Aug  4 11:26:22 2016
 // Update Count     : 16
+// Last Modified By : Andrew Beach
+// Last Modified On : Thu Jun 22 13:47:00 2017
+// Update Count     : 17
 //
 …
         Statement * PolyMutator::mutate(TryStmt *tryStmt) {
                 tryStmt->set_block(  maybeMutate( tryStmt->get_block(), *this ) );
+                tryStmt->set_block( maybeMutate( tryStmt->get_block(), *this ) );
                 mutateAll( tryStmt->get_catchers(), *this );
+                tryStmt->set_finally( maybeMutate( tryStmt->get_finally(), *this ) );
                 return tryStmt;
+        }
         Statement * PolyMutator::mutate(CatchStmt *cathStmt) {
+                cathStmt->set_body(  mutateStatement( cathStmt->get_body() ) );
+                cathStmt->set_decl(  maybeMutate( cathStmt->get_decl(), *this ) );
+                cathStmt->set_body( mutateStatement( cathStmt->get_body() ) );
+                cathStmt->set_cond( maybeMutate( cathStmt->get_cond(), *this ) );
+                cathStmt->set_decl( maybeMutate( cathStmt->get_decl(), *this ) );
                 return cathStmt;
+        }

src/GenPoly/Specialize.cc

-              r9c951e3
+              rb1e63ac5
+        }
         bool needsTupleSpecialization( Type *formalType, Type *actualType, TypeSubstitution *env ) {
+        bool needsTupleSpecialization( Type *formalType, Type *actualType ) {
                 // Needs tuple specialization if the structure of the formal type and actual type do not match.
                 // This is the case if the formal type has ttype polymorphism, or if the structure  of tuple types
 …
                 if ( FunctionType * fftype = getFunctionType( formalType ) ) {
                         if ( fftype->isTtype() ) return true;
+                        // conversion of 0 (null) to function type does not require tuple specialization
+                        if ( dynamic_cast< ZeroType * >( actualType ) ) return false;
                         FunctionType * aftype = getFunctionType( actualType );
                         assertf( aftype, "formal type is a function type, but actual type is not." );
 …
         bool needsSpecialization( Type *formalType, Type *actualType, TypeSubstitution *env ) {
                 return needsPolySpecialization( formalType, actualType, env ) || needsTupleSpecialization( formalType, actualType, env );
+                return needsPolySpecialization( formalType, actualType, env ) || needsTupleSpecialization( formalType, actualType );
+        }

src/InitTweak/FixGlobalInit.cc

-              r9c951e3
+              rb1e63ac5
 namespace InitTweak {
-        namespace {
-                const std::list<Label> noLabels;
+        }
         class GlobalFixer : public Visitor {
           public:
 …
         // only modify global variables
         void GlobalFixer::visit( FunctionDecl *functionDecl ) {}
         void GlobalFixer::visit( StructDecl *aggregateDecl ) {}
         void GlobalFixer::visit( UnionDecl *aggregateDecl ) {}
         void GlobalFixer::visit( EnumDecl *aggregateDecl ) {}
         void GlobalFixer::visit( TraitDecl *aggregateDecl ) {}
         void GlobalFixer::visit( TypeDecl *typeDecl ) {}
+        void GlobalFixer::visit( __attribute__((unused)) FunctionDecl *functionDecl ) {}
+        void GlobalFixer::visit( __attribute__((unused)) StructDecl *aggregateDecl ) {}
+        void GlobalFixer::visit( __attribute__((unused)) UnionDecl *aggregateDecl ) {}
+        void GlobalFixer::visit( __attribute__((unused)) EnumDecl *aggregateDecl ) {}
+        void GlobalFixer::visit( __attribute__((unused)) TraitDecl *aggregateDecl ) {}
+        void GlobalFixer::visit( __attribute__((unused)) TypeDecl *typeDecl ) {}
 } // namespace InitTweak

src/InitTweak/FixInit.cc

-              r9c951e3
+              rb1e63ac5
 // Created On       : Wed Jan 13 16:29:30 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Mar 17 09:13:47 2017
 // Update Count     : 71
+// Last Modified On : Wed Jun 21 17:35:05 2017
+// Update Count     : 74
 //
 …
 #include <unordered_map>
 #include <unordered_set>
 #include "InitTweak.h"
 #include "GenInit.h"
 #include "FixInit.h"
 #include "FixGlobalInit.h"
+#include "CodeGen/GenType.h"  // for warning/error messages
+#include "Common/PassVisitor.h"
+#include "GenPoly/DeclMutator.h"
+#include "GenPoly/PolyMutator.h"
 #include "ResolvExpr/Resolver.h"
 #include "ResolvExpr/typeops.h"
+#include "SymTab/Autogen.h"
+#include "SymTab/Indexer.h"
+#include "SynTree/AddStmtVisitor.h"
+#include "SynTree/Attribute.h"
 #include "SynTree/Declaration.h"
-#include "SynTree/Type.h"
 #include "SynTree/Expression.h"
-#include "SynTree/Attribute.h"
-#include "SynTree/Statement.h"
 #include "SynTree/Initializer.h"
 #include "SynTree/Mutator.h"
+#include "SymTab/Indexer.h"
+#include "SymTab/Autogen.h"
+#include "GenPoly/PolyMutator.h"
+#include "GenPoly/DeclMutator.h"
+#include "SynTree/AddStmtVisitor.h"
+#include "CodeGen/GenType.h"  // for warning/error messages
+#include "SynTree/Statement.h"
+#include "SynTree/Type.h"
 #include "Tuples/Tuples.h"
 …
                 typedef std::unordered_map< int, int > UnqCount;
                 class InsertImplicitCalls final : public GenPoly::PolyMutator {
+                class InsertImplicitCalls : public WithTypeSubstitution {
                 public:
                         /// wrap function application expressions as ImplicitCopyCtorExpr nodes so that it is easy to identify which
 …
                         InsertImplicitCalls( EnvMap & envMap ) : envMap( envMap ) {}
+                        typedef GenPoly::PolyMutator Parent;
+                        using Parent::mutate;
+                        virtual Expression * mutate( ApplicationExpr * appExpr ) override;
+                        virtual Expression * mutate( StmtExpr * stmtExpr ) override;
+                        Expression * postmutate( ApplicationExpr * appExpr );
+                        void premutate( StmtExpr * stmtExpr );
                         // collects environments for relevant nodes
 …
                         typedef AddStmtVisitor Parent;
                         using Parent::visit;
+                        typedef std::set< ObjectDecl * > ObjectSet;
+                        // use ordered data structure to maintain ordering for set_difference and for consistent error messages
+                        typedef std::list< ObjectDecl * > ObjectSet;
                         virtual void visit( CompoundStmt *compoundStmt ) override;
                         virtual void visit( DeclStmt *stmt ) override;
                         // don't go into other functions
                         virtual void visit( FunctionDecl *decl ) override {}
+                        virtual void visit( __attribute__((unused)) FunctionDecl *decl ) override {}
                   protected:
 …
                 // debug
                 struct printSet {
                         typedef ObjDeclCollector::ObjectSet ObjectSet;
                         printSet( const ObjectSet & objs ) : objs( objs ) {}
+                template<typename ObjectSet>
+                struct PrintSet {
+                        PrintSet( const ObjectSet & objs ) : objs( objs ) {}
                         const ObjectSet & objs;
                 };
+                std::ostream & operator<<( std::ostream & out, const printSet & set) {
+                template<typename ObjectSet>
+                PrintSet<ObjectSet> printSet( const ObjectSet & objs ) { return PrintSet<ObjectSet>( objs ); }
+                template<typename ObjectSet>
+                std::ostream & operator<<( std::ostream & out, const PrintSet<ObjectSet> & set) {
                         out << "{ ";
                         for ( ObjectDecl * obj : set.objs ) {
 …
                 };
                 class FixInit final : public GenPoly::PolyMutator {
+                class FixInit : public WithStmtsToAdd {
                   public:
                         /// expand each object declaration to use its constructor after it is declared.
                         static void fixInitializers( std::list< Declaration * > &translationUnit );
+                        typedef GenPoly::PolyMutator Parent;
+                        using Parent::mutate;
+                        virtual DeclarationWithType * mutate( ObjectDecl *objDecl ) override;
+                        DeclarationWithType * postmutate( ObjectDecl *objDecl );
                         std::list< Declaration * > staticDtorDecls;
 …
         namespace {
                 void InsertImplicitCalls::insert( std::list< Declaration * > & translationUnit, EnvMap & envMap ) {
                         InsertImplicitCalls inserter( envMap );
+                        PassVisitor<InsertImplicitCalls> inserter( envMap );
                         mutateAll( translationUnit, inserter );
+                }
 …
                 void FixInit::fixInitializers( std::list< Declaration * > & translationUnit ) {
                         FixInit fixer;
+                        PassVisitor<FixInit> fixer;
                         // can't use mutateAll, because need to insert declarations at top-level
 …
                                 try {
                                         *i = maybeMutate( *i, fixer );
                                         translationUnit.splice( i, fixer.staticDtorDecls );
+                                        translationUnit.splice( i, fixer.pass.staticDtorDecls );
                                 } catch( SemanticError &e ) {
                                         e.set_location( (*i)->location );
 …
+                }
+                Expression * InsertImplicitCalls::mutate( ApplicationExpr * appExpr ) {
+                        appExpr = dynamic_cast< ApplicationExpr * >( Parent::mutate( appExpr ) );
+                Expression * InsertImplicitCalls::postmutate( ApplicationExpr * appExpr ) {
                         assert( appExpr );
 …
+                }
                 Expression * InsertImplicitCalls::mutate( StmtExpr * stmtExpr ) {
+                void InsertImplicitCalls::premutate( StmtExpr * stmtExpr ) {
                         assert( env );
                         envMap[stmtExpr] = env;
-                        return Parent::mutate( stmtExpr );
+                }
 …
+                }
+                DeclarationWithType *FixInit::mutate( ObjectDecl *objDecl ) {
+                        // first recursively handle pieces of ObjectDecl so that they aren't missed by other visitors when the init
+                        // is removed from the ObjectDecl
+                        objDecl = dynamic_cast< ObjectDecl * >( Parent::mutate( objDecl ) );
+                DeclarationWithType *FixInit::postmutate( ObjectDecl *objDecl ) {
+                        // since this removes the init field from objDecl, it must occur after children are mutated (i.e. postmutate)
                         if ( ConstructorInit * ctorInit = dynamic_cast< ConstructorInit * >( objDecl->get_init() ) ) {
                                 // a decision should have been made by the resolver, so ctor and init are not both non-NULL
 …
                                                 // static bool __objName_uninitialized = true
                                                 BasicType * boolType = new BasicType( Type::Qualifiers(), BasicType::Bool );
                                                 SingleInit * boolInitExpr = new SingleInit( new ConstantExpr( Constant( boolType->clone(), "1" ) ), noDesignators );
+                                                SingleInit * boolInitExpr = new SingleInit( new ConstantExpr( Constant::from_int( 1 ) ) );
                                                 ObjectDecl * isUninitializedVar = new ObjectDecl( objDecl->get_mangleName() + "_uninitialized", Type::StorageClasses( Type::Static ), LinkageSpec::Cforall, 0, boolType, boolInitExpr );
                                                 isUninitializedVar->fixUniqueId();
 …
                                                 UntypedExpr * setTrue = new UntypedExpr( new NameExpr( "?=?" ) );
                                                 setTrue->get_args().push_back( new VariableExpr( isUninitializedVar ) );
                                                 setTrue->get_args().push_back( new ConstantExpr( Constant( boolType->clone(), "0" ) ) );
+                                                setTrue->get_args().push_back( new ConstantExpr( Constant::from_int( 0 ) ) );
                                                 // generate body of if
 …
                                                 Statement * dtor = ctorInit->get_dtor();
                                                 objDecl->set_init( NULL );
                                                 ctorInit->set_ctor( NULL );
+                                                objDecl->set_init( nullptr );
+                                                ctorInit->set_ctor( nullptr );
                                                 ctorInit->set_dtor( nullptr );
                                                 if ( dtor ) {
 …
                                                 } else {
                                                         stmtsToAddAfter.push_back( ctor );
                                                         objDecl->set_init( NULL );
                                                         ctorInit->set_ctor( NULL );
+                                                        objDecl->set_init( nullptr );
+                                                        ctorInit->set_ctor( nullptr );
+                                                }
                                         } // if
                                 } else if ( Initializer * init = ctorInit->get_init() ) {
                                         objDecl->set_init( init );
                                         ctorInit->set_init( NULL );
+                                        ctorInit->set_init( nullptr );
                                 } else {
                                         // no constructor and no initializer, which is okay
                                         objDecl->set_init( NULL );
+                                        objDecl->set_init( nullptr );
                                 } // if
                                 delete ctorInit;
 …
                 void ObjDeclCollector::visit( CompoundStmt * compoundStmt ) {
                         std::set< ObjectDecl * > prevVars = curVars;
+                        ObjectSet prevVars = curVars;
                         Parent::visit( compoundStmt );
                         curVars = prevVars;
 …
                         // keep track of all variables currently in scope
                         if ( ObjectDecl * objDecl = dynamic_cast< ObjectDecl * > ( stmt->get_decl() ) ) {
                                 curVars.insert( objDecl );
+                                curVars.push_back( objDecl );
                         } // if
                         Parent::visit( stmt );
 …
                         Parent::visit( compoundStmt );
+                        // add destructors for the current scope that we're exiting
+                        // add destructors for the current scope that we're exiting, unless the last statement is a return, which
+                        // causes unreachable code warnings
                         std::list< Statement * > & statements = compoundStmt->get_kids();
+                        insertDtors( reverseDeclOrder.front().begin(), reverseDeclOrder.front().end(), back_inserter( statements ) );
+                        if ( ! statements.empty() && ! dynamic_cast< ReturnStmt * >( statements.back() ) ) {
+                                insertDtors( reverseDeclOrder.front().begin(), reverseDeclOrder.front().end(), back_inserter( statements ) );
+                        }
                         reverseDeclOrder.pop_front();
+                }
                 void InsertDtors::visit( ReturnStmt * returnStmt ) {
+                void InsertDtors::visit( __attribute((unused)) ReturnStmt * returnStmt ) {
                         // return exits all scopes, so dump destructors for all scopes
                         for ( OrderedDecls & od : reverseDeclOrder ) {
 …
+                        )
                         if ( ! diff.empty() ) {
+                                // create an auxilliary set for fast lookup -- can't make diff a set, because diff ordering should be consistent for error messages.
+                                std::unordered_set<ObjectDecl *> needsDestructor( diff.begin(), diff.end() );
                                 // go through decl ordered list of objectdecl. for each element that occurs in diff, output destructor
                                 OrderedDecls ordered;
                                 for ( OrderedDecls & rdo : reverseDeclOrder ) {
                                         // add elements from reverseDeclOrder into ordered if they occur in diff - it is key that this happens in reverse declaration order.
                                         copy_if( rdo.begin(), rdo.end(), back_inserter( ordered ), [&]( ObjectDecl * objDecl ) { return diff.count( objDecl ); } );
+                                        copy_if( rdo.begin(), rdo.end(), back_inserter( ordered ), [&]( ObjectDecl * objDecl ) { return needsDestructor.count( objDecl ); } );
                                 } // for
                                 insertDtors( ordered.begin(), ordered.end(), back_inserter( stmtsToAdd ) );

src/InitTweak/GenInit.cc

-              r9c951e3
+              rb1e63ac5
 #include <stack>
 #include <list>
+#include "InitTweak.h"
 #include "GenInit.h"
+#include "InitTweak.h"
+#include "Common/PassVisitor.h"
+#include "GenPoly/DeclMutator.h"
+#include "GenPoly/PolyMutator.h"
+#include "GenPoly/ScopedSet.h"
+#include "ResolvExpr/typeops.h"
 #include "SynTree/Declaration.h"
-#include "SynTree/Type.h"
 #include "SynTree/Expression.h"
-#include "SynTree/Statement.h"
 #include "SynTree/Initializer.h"
 #include "SynTree/Mutator.h"
+#include "SynTree/Statement.h"
+#include "SynTree/Type.h"
 #include "SymTab/Autogen.h"
 #include "SymTab/Mangler.h"
-#include "GenPoly/PolyMutator.h"
-#include "GenPoly/DeclMutator.h"
-#include "GenPoly/ScopedSet.h"
-#include "ResolvExpr/typeops.h"
 namespace InitTweak {
 …
+        }
+        class ReturnFixer final : public GenPoly::PolyMutator {
+          public:
+        struct ReturnFixer : public WithStmtsToAdd, public WithGuards {
                 /// consistently allocates a temporary variable for the return value
                 /// of a function so that anything which the resolver decides can be constructed
 …
                 static void makeReturnTemp( std::list< Declaration * > &translationUnit );
+                ReturnFixer();
+                typedef GenPoly::PolyMutator Parent;
+                using Parent::mutate;
+                virtual DeclarationWithType * mutate( FunctionDecl *functionDecl ) override;
+                virtual Statement * mutate( ReturnStmt * returnStmt ) override;
+                void premutate( FunctionDecl *functionDecl );
+                void premutate( ReturnStmt * returnStmt );
           protected:
 …
         };
+        class CtorDtor final : public GenPoly::PolyMutator {
+          public:
+                typedef GenPoly::PolyMutator Parent;
+                using Parent::mutate;
+        struct CtorDtor : public WithGuards, public WithShortCircuiting  {
                 /// create constructor and destructor statements for object declarations.
                 /// the actual call statements will be added in after the resolver has run
 …
                 static void generateCtorDtor( std::list< Declaration * > &translationUnit );
+                virtual DeclarationWithType * mutate( ObjectDecl * ) override;
+                virtual DeclarationWithType * mutate( FunctionDecl *functionDecl ) override;
+                void previsit( ObjectDecl * );
+                void previsit( FunctionDecl *functionDecl );
                 // should not traverse into any of these declarations to find objects
                 // that need to be constructed or destructed
                 virtual Declaration* mutate( StructDecl *aggregateDecl ) override;
                 virtual Declaration* mutate( UnionDecl *aggregateDecl ) override { return aggregateDecl; }
                 virtual Declaration* mutate( EnumDecl *aggregateDecl ) override { return aggregateDecl; }
                 virtual Declaration* mutate( TraitDecl *aggregateDecl ) override { return aggregateDecl; }
                 virtual TypeDecl* mutate( TypeDecl *typeDecl ) override { return typeDecl; }
                 virtual Declaration* mutate( TypedefDecl *typeDecl ) override { return typeDecl; }
                 virtual Type * mutate( FunctionType *funcType ) override { return funcType; }
                 virtual CompoundStmt * mutate( CompoundStmt * compoundStmt ) override;
+                void previsit( StructDecl *aggregateDecl );
+                void previsit( UnionDecl *aggregateDecl ) { visit_children = false; }
+                void previsit( EnumDecl *aggregateDecl ) { visit_children = false; }
+                void previsit( TraitDecl *aggregateDecl ) { visit_children = false; }
+                void previsit( TypeDecl *typeDecl ) { visit_children = false; }
+                void previsit( TypedefDecl *typeDecl ) { visit_children = false; }
+                void previsit( FunctionType *funcType ) { visit_children = false; }
+                void previsit( CompoundStmt * compoundStmt );
           private:
 …
         void ReturnFixer::makeReturnTemp( std::list< Declaration * > & translationUnit ) {
                 ReturnFixer fixer;
+                PassVisitor<ReturnFixer> fixer;
                 mutateAll( translationUnit, fixer );
+        }
+        ReturnFixer::ReturnFixer() {}
+        Statement *ReturnFixer::mutate( ReturnStmt *returnStmt ) {
+        void ReturnFixer::premutate( ReturnStmt *returnStmt ) {
                 std::list< DeclarationWithType * > & returnVals = ftype->get_returnVals();
                 assert( returnVals.size() == 0 || returnVals.size() == 1 );
 …
                         construct->get_args().push_back( new AddressExpr( new VariableExpr( returnVals.front() ) ) );
                         construct->get_args().push_back( returnStmt->get_expr() );
                         stmtsToAdd.push_back(new ExprStmt(noLabels, construct));
+                        stmtsToAddBefore.push_back(new ExprStmt(noLabels, construct));
                         // return the retVal object
                         returnStmt->set_expr( new VariableExpr( returnVals.front() ) );
                 } // if
+                return returnStmt;
+        }
+        DeclarationWithType* ReturnFixer::mutate( FunctionDecl *functionDecl ) {
+                ValueGuard< FunctionType * > oldFtype( ftype );
+                ValueGuard< std::string > oldFuncName( funcName );
+        }
+        void ReturnFixer::premutate( FunctionDecl *functionDecl ) {
+                GuardValue( ftype );
+                GuardValue( funcName );
                 ftype = functionDecl->get_functionType();
                 funcName = functionDecl->get_name();
-                return Parent::mutate( functionDecl );
+        }
 …
         void CtorDtor::generateCtorDtor( std::list< Declaration * > & translationUnit ) {
                 CtorDtor ctordtor;
                 mutateAll( translationUnit, ctordtor );
+                PassVisitor<CtorDtor> ctordtor;
+                acceptAll( translationUnit, ctordtor );
+        }
 …
+        }
         DeclarationWithType * CtorDtor::mutate( ObjectDecl * objDecl ) {
+        void CtorDtor::previsit( ObjectDecl * objDecl ) {
                 handleDWT( objDecl );
                 // hands off if @=, extern, builtin, etc.
 …
                         objDecl->set_init( genCtorInit( objDecl ) );
+                }
+                return Parent::mutate( objDecl );
+        }
+        DeclarationWithType * CtorDtor::mutate( FunctionDecl *functionDecl ) {
+                ValueGuard< bool > oldInFunc = inFunction;
+        }
+        void CtorDtor::previsit( FunctionDecl *functionDecl ) {
+                GuardValue( inFunction );
                 inFunction = true;
                 handleDWT( functionDecl );
                 managedTypes.beginScope();
+                GuardScope( managedTypes );
                 // go through assertions and recursively add seen ctor/dtors
                 for ( auto & tyDecl : functionDecl->get_functionType()->get_forall() ) {
                         for ( DeclarationWithType *& assertion : tyDecl->get_assertions() ) {
                                 assertion = assertion->acceptMutator( *this );
+                                handleDWT( assertion );
+                        }
+                }
+                // parameters should not be constructed and destructed, so don't mutate FunctionType
+                functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) );
+                managedTypes.endScope();
+                return functionDecl;
+        }
+        Declaration* CtorDtor::mutate( StructDecl *aggregateDecl ) {
+                PassVisitor<CtorDtor> newCtorDtor;
+                newCtorDtor.pass = *this;
+                maybeAccept( functionDecl->get_statements(), newCtorDtor );
+                visit_children = false;  // do not try and construct parameters or forall parameters - must happen after maybeAccept
+        }
+        void CtorDtor::previsit( StructDecl *aggregateDecl ) {
+                visit_children = false; // do not try to construct and destruct aggregate members
                 // don't construct members, but need to take note if there is a managed member,
                 // because that means that this type is also managed
 …
+                        }
+                }
+                return aggregateDecl;
+        }
+        CompoundStmt * CtorDtor::mutate( CompoundStmt * compoundStmt ) {
+                managedTypes.beginScope();
+                CompoundStmt * stmt = Parent::mutate( compoundStmt );
+                managedTypes.endScope();
+                return stmt;
+        }
+        }
+        void CtorDtor::previsit( CompoundStmt * compoundStmt ) {
+                GuardScope( managedTypes );
+        }
 } // namespace InitTweak

src/InitTweak/InitTweak.cc

-              r9c951e3
+              rb1e63ac5
                 public:
                         bool hasDesignations = false;
+                        template<typename Init>
+                        void handleInit( Init * init ) {
+                                if ( ! init->get_designators().empty() ) hasDesignations = true;
+                                else Visitor::visit( init );
+                        }
+                        virtual void visit( SingleInit * singleInit ) { handleInit( singleInit); }
+                        virtual void visit( ListInit * listInit ) { handleInit( listInit); }
+                        virtual void visit( Designation * des ) {
+                                if ( ! des->get_designators().empty() ) hasDesignations = true;
+                                else Visitor::visit( des );
+                        }
                 };
 …
                 InitImpl( Initializer * init ) : init( init ) {}
                 virtual std::list< Expression * > next( std::list< Expression * > & indices ) {
+                virtual std::list< Expression * > next( __attribute((unused)) std::list< Expression * > & indices ) {
                         // this is wrong, but just a placeholder for now
                         // if ( ! flattened ) flatten( indices );
 …
+        }
         Statement * ExprImpl::buildListInit( UntypedExpr * dst, std::list< Expression * > & indices ) {
+        Statement * ExprImpl::buildListInit( __attribute((unused)) UntypedExpr * dst, __attribute((unused)) std::list< Expression * > & indices ) {
                 return NULL;
+        }
 …
                 ConstExprChecker() : isConstExpr( true ) {}
+                virtual void visit( ApplicationExpr *applicationExpr ) { isConstExpr = false; }
+                virtual void visit( UntypedExpr *untypedExpr ) { isConstExpr = false; }
+                using Visitor::visit;
+                virtual void visit( __attribute((unused)) ApplicationExpr *applicationExpr ) { isConstExpr = false; }
+                virtual void visit( __attribute((unused)) UntypedExpr *untypedExpr ) { isConstExpr = false; }
                 virtual void visit( NameExpr *nameExpr ) {
                         // xxx - temporary hack, because 0 and 1 really should be constexprs, even though they technically aren't in Cforall today
 …
                         if ( ! dynamic_cast< NameExpr * >( arg) && ! dynamic_cast< VariableExpr * >( arg ) && ! dynamic_cast< MemberExpr * >( arg ) && ! dynamic_cast< UntypedMemberExpr * >( arg ) ) isConstExpr = false;
+                }
                 virtual void visit( LabelAddressExpr *labAddressExpr ) { isConstExpr = false; }
                 virtual void visit( UntypedMemberExpr *memberExpr ) { isConstExpr = false; }
                 virtual void visit( MemberExpr *memberExpr ) { isConstExpr = false; }
                 virtual void visit( VariableExpr *variableExpr ) { isConstExpr = false; }
+                virtual void visit( __attribute((unused)) LabelAddressExpr *labAddressExpr ) { isConstExpr = false; }
+                virtual void visit( __attribute((unused)) UntypedMemberExpr *memberExpr ) { isConstExpr = false; }
+                virtual void visit( __attribute((unused)) MemberExpr *memberExpr ) { isConstExpr = false; }
+                virtual void visit( __attribute((unused)) VariableExpr *variableExpr ) { isConstExpr = false; }
                 // these might be okay?
                 // virtual void visit( SizeofExpr *sizeofExpr );
 …
                 // virtual void visit( LogicalExpr *logicalExpr );
                 // virtual void visit( ConditionalExpr *conditionalExpr );
                 virtual void visit( TypeExpr *typeExpr ) { isConstExpr = false; }
                 virtual void visit( AsmExpr *asmExpr ) { isConstExpr = false; }
                 virtual void visit( UntypedValofExpr *valofExpr ) { isConstExpr = false; }
                 virtual void visit( CompoundLiteralExpr *compLitExpr ) { isConstExpr = false; }
                 virtual void visit( UntypedTupleExpr *tupleExpr ) { isConstExpr = false; }
                 virtual void visit( TupleExpr *tupleExpr ) { isConstExpr = false; }
                 virtual void visit( TupleAssignExpr *tupleExpr ) { isConstExpr = false; }
+                virtual void visit( __attribute((unused)) TypeExpr *typeExpr ) { isConstExpr = false; }
+                virtual void visit( __attribute((unused)) AsmExpr *asmExpr ) { isConstExpr = false; }
+                virtual void visit( __attribute((unused)) UntypedValofExpr *valofExpr ) { isConstExpr = false; }
+                virtual void visit( __attribute((unused)) CompoundLiteralExpr *compLitExpr ) { isConstExpr = false; }
+                virtual void visit( __attribute((unused)) UntypedTupleExpr *tupleExpr ) { isConstExpr = false; }
+                virtual void visit( __attribute((unused)) TupleExpr *tupleExpr ) { isConstExpr = false; }
+                virtual void visit( __attribute((unused)) TupleAssignExpr *tupleExpr ) { isConstExpr = false; }
                 bool isConstExpr;

src/MakeLibCfa.cc

-              r9c951e3
+              rb1e63ac5
                   case CodeGen::OT_POSTFIXASSIGN:
                   case CodeGen::OT_INFIXASSIGN:
+                  case CodeGen::OT_CTOR:
+                  case CodeGen::OT_DTOR:
                                 funcDecl->get_statements()->get_kids().push_back( new ReturnStmt( std::list< Label >(), newExpr ) );
                                 break;
-                  case CodeGen::OT_CTOR:
-                        // ctors don't return a value
-                        if ( funcDecl->get_functionType()->get_parameters().size() == 1 ) {
-                                // intrinsic default constructors should do nothing
-                                // delete newExpr;
-                                break;
-                        } else {
-                                assert( funcDecl->get_functionType()->get_parameters().size() == 2 );
-                                // anything else is a single parameter constructor that is effectively a C-style assignment
-                                // delete newExpr->get_function();
-                                assert(newExpr->get_args().size()==2);
-                                newExpr->set_function( new NameExpr( "?=?" ) );
-                                funcDecl->get_statements()->get_kids().push_back( new ExprStmt( std::list< Label >(), newExpr ) );
+                        }
-                        break;
-                  case CodeGen::OT_DTOR:
-                        // intrinsic destructors should do nothing
-                        // delete newExpr;
-                        break;
                   case CodeGen::OT_CONSTANT:
                   case CodeGen::OT_LABELADDRESS:
 …
                 assert( ! objDecl->get_init() );
                 std::list< Expression* > noDesignators;
                 objDecl->set_init( new SingleInit( new NameExpr( objDecl->get_name() ), noDesignators, false ) ); // cannot be constructed
+                objDecl->set_init( new SingleInit( new NameExpr( objDecl->get_name() ), false ) ); // cannot be constructed
                 newDecls.push_back( objDecl );
+        }

src/Makefile.am

r9c951e3	rb1e63ac5
43	43	driver_cfa_cpp_SOURCES = ${SRC}
44	44	driver_cfa_cpp_LDADD = ${LEXLIB} -ldl # yywrap
45		driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -I${abs_top_srcdir}/src/include -DYY_NO_INPUT -O2
	45	driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -I${abs_top_srcdir}/src/include -DYY_NO_INPUT -O2 -g -std=c++14
46	46	driver_cfa_cpp_LDFLAGS = -Xlinker -export-dynamic
47	47

src/Makefile.in

-              r9c951e3
+              rb1e63ac5
         ControlStruct/driver_cfa_cpp-Mutate.$(OBJEXT) \
         ControlStruct/driver_cfa_cpp-ForExprMutator.$(OBJEXT) \
+        ControlStruct/driver_cfa_cpp-ExceptTranslate.$(OBJEXT) \
         GenPoly/driver_cfa_cpp-Box.$(OBJEXT) \
         GenPoly/driver_cfa_cpp-GenPoly.$(OBJEXT) \
 …
         Parser/driver_cfa_cpp-TypeData.$(OBJEXT) \
         Parser/driver_cfa_cpp-LinkageSpec.$(OBJEXT) \
         Parser/driver_cfa_cpp-parseutility.$(OBJEXT) \
+        Parser/driver_cfa_cpp-parserutility.$(OBJEXT) \
         ResolvExpr/driver_cfa_cpp-AlternativeFinder.$(OBJEXT) \
         ResolvExpr/driver_cfa_cpp-Alternative.$(OBJEXT) \
 …
         ResolvExpr/driver_cfa_cpp-Occurs.$(OBJEXT) \
         ResolvExpr/driver_cfa_cpp-TypeEnvironment.$(OBJEXT) \
+        ResolvExpr/driver_cfa_cpp-CurrentObject.$(OBJEXT) \
         SymTab/driver_cfa_cpp-Indexer.$(OBJEXT) \
         SymTab/driver_cfa_cpp-Mangler.$(OBJEXT) \
 …
         SynTree/driver_cfa_cpp-PointerType.$(OBJEXT) \
         SynTree/driver_cfa_cpp-ArrayType.$(OBJEXT) \
-        SynTree/driver_cfa_cpp-ReferenceType.$(OBJEXT) \
         SynTree/driver_cfa_cpp-FunctionType.$(OBJEXT) \
         SynTree/driver_cfa_cpp-ReferenceToType.$(OBJEXT) \
 …
         ControlStruct/LabelGenerator.cc ControlStruct/LabelFixer.cc \
         ControlStruct/MLEMutator.cc ControlStruct/Mutate.cc \
+        ControlStruct/ForExprMutator.cc GenPoly/Box.cc \
+        ControlStruct/ForExprMutator.cc \
+        ControlStruct/ExceptTranslate.cc GenPoly/Box.cc \
         GenPoly/GenPoly.cc GenPoly/PolyMutator.cc \
         GenPoly/ScrubTyVars.cc GenPoly/Lvalue.cc GenPoly/Specialize.cc \
 …
         Parser/ExpressionNode.cc Parser/StatementNode.cc \
         Parser/InitializerNode.cc Parser/TypeData.cc \
         Parser/LinkageSpec.cc Parser/parseutility.cc \
+        Parser/LinkageSpec.cc Parser/parserutility.cc \
         ResolvExpr/AlternativeFinder.cc ResolvExpr/Alternative.cc \
         ResolvExpr/Unify.cc ResolvExpr/PtrsAssignable.cc \
 …
         ResolvExpr/RenameVars.cc ResolvExpr/FindOpenVars.cc \
         ResolvExpr/PolyCost.cc ResolvExpr/Occurs.cc \
         ResolvExpr/TypeEnvironment.cc SymTab/Indexer.cc \
         SymTab/Mangler.cc SymTab/Validate.cc SymTab/FixFunction.cc \
         SymTab/ImplementationType.cc SymTab/TypeEquality.cc \
         SymTab/Autogen.cc SynTree/Type.cc SynTree/VoidType.cc \
         SynTree/BasicType.cc SynTree/PointerType.cc \
         SynTree/ArrayType.cc SynTree/ReferenceType.cc \
+        ResolvExpr/TypeEnvironment.cc ResolvExpr/CurrentObject.cc \
+        SymTab/Indexer.cc SymTab/Mangler.cc SymTab/Validate.cc \
+        SymTab/FixFunction.cc SymTab/ImplementationType.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 \
         SynTree/TupleType.cc SynTree/TypeofType.cc SynTree/AttrType.cc \
 …
 driver_cfa_cpp_SOURCES = ${SRC}
 driver_cfa_cpp_LDADD = ${LEXLIB} -ldl                   # yywrap
 driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -I${abs_top_srcdir}/src/include -DYY_NO_INPUT -O2
+driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -I${abs_top_srcdir}/src/include -DYY_NO_INPUT -O2 -g -std=c++14
 driver_cfa_cpp_LDFLAGS = -Xlinker -export-dynamic
 all: $(BUILT_SOURCES)
 …
         ControlStruct/$(am__dirstamp) \
         ControlStruct/$(DEPDIR)/$(am__dirstamp)
+ControlStruct/driver_cfa_cpp-ExceptTranslate.$(OBJEXT):  \
+        ControlStruct/$(am__dirstamp) \
+        ControlStruct/$(DEPDIR)/$(am__dirstamp)
 GenPoly/$(am__dirstamp):
         @$(MKDIR_P) GenPoly
 …
 Parser/driver_cfa_cpp-LinkageSpec.$(OBJEXT): Parser/$(am__dirstamp) \
         Parser/$(DEPDIR)/$(am__dirstamp)
 Parser/driver_cfa_cpp-parseutility.$(OBJEXT): Parser/$(am__dirstamp) \
+Parser/driver_cfa_cpp-parserutility.$(OBJEXT): Parser/$(am__dirstamp) \
         Parser/$(DEPDIR)/$(am__dirstamp)
 ResolvExpr/$(am__dirstamp):
 …
         ResolvExpr/$(am__dirstamp) \
         ResolvExpr/$(DEPDIR)/$(am__dirstamp)
+ResolvExpr/driver_cfa_cpp-CurrentObject.$(OBJEXT):  \
+        ResolvExpr/$(am__dirstamp) \
+        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
 SymTab/$(am__dirstamp):
         @$(MKDIR_P) SymTab
 …
 SynTree/driver_cfa_cpp-ArrayType.$(OBJEXT): SynTree/$(am__dirstamp) \
         SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/driver_cfa_cpp-ReferenceType.$(OBJEXT):  \
-        SynTree/$(am__dirstamp) SynTree/$(DEPDIR)/$(am__dirstamp)
 SynTree/driver_cfa_cpp-FunctionType.$(OBJEXT):  \
         SynTree/$(am__dirstamp) SynTree/$(DEPDIR)/$(am__dirstamp)
 …
         -rm -f Common/driver_cfa_cpp-UniqueName.$(OBJEXT)
         -rm -f Concurrency/driver_cfa_cpp-Keywords.$(OBJEXT)
+        -rm -f ControlStruct/driver_cfa_cpp-ExceptTranslate.$(OBJEXT)
         -rm -f ControlStruct/driver_cfa_cpp-ForExprMutator.$(OBJEXT)
         -rm -f ControlStruct/driver_cfa_cpp-LabelFixer.$(OBJEXT)
 …
         -rm -f Parser/driver_cfa_cpp-lex.$(OBJEXT)
         -rm -f Parser/driver_cfa_cpp-parser.$(OBJEXT)
         -rm -f Parser/driver_cfa_cpp-parseutility.$(OBJEXT)
+        -rm -f Parser/driver_cfa_cpp-parserutility.$(OBJEXT)
         -rm -f ResolvExpr/driver_cfa_cpp-AdjustExprType.$(OBJEXT)
         -rm -f ResolvExpr/driver_cfa_cpp-Alternative.$(OBJEXT)
 …
         -rm -f ResolvExpr/driver_cfa_cpp-CommonType.$(OBJEXT)
         -rm -f ResolvExpr/driver_cfa_cpp-ConversionCost.$(OBJEXT)
+        -rm -f ResolvExpr/driver_cfa_cpp-CurrentObject.$(OBJEXT)
         -rm -f ResolvExpr/driver_cfa_cpp-FindOpenVars.$(OBJEXT)
         -rm -f ResolvExpr/driver_cfa_cpp-Occurs.$(OBJEXT)
 …
         -rm -f SynTree/driver_cfa_cpp-PointerType.$(OBJEXT)
         -rm -f SynTree/driver_cfa_cpp-ReferenceToType.$(OBJEXT)
-        -rm -f SynTree/driver_cfa_cpp-ReferenceType.$(OBJEXT)
         -rm -f SynTree/driver_cfa_cpp-Statement.$(OBJEXT)
         -rm -f SynTree/driver_cfa_cpp-TupleExpr.$(OBJEXT)
 …
 @AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-UniqueName.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Concurrency/$(DEPDIR)/driver_cfa_cpp-Keywords.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-ExceptTranslate.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-ForExprMutator.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelFixer.Po@am__quote@
 …
 @AMDEP_TRUE@@am__include@ @am__quote@Parser/$(DEPDIR)/driver_cfa_cpp-lex.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Parser/$(DEPDIR)/driver_cfa_cpp-parser.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Parser/$(DEPDIR)/driver_cfa_cpp-parseutility.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@Parser/$(DEPDIR)/driver_cfa_cpp-parserutility.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-AdjustExprType.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-Alternative.Po@am__quote@
 …
 @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CommonType.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-ConversionCost.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-FindOpenVars.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-Occurs.Po@am__quote@
 …
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-PointerType.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceToType.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-Statement.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-TupleExpr.Po@am__quote@
 …
 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o ControlStruct/driver_cfa_cpp-ForExprMutator.obj `if test -f 'ControlStruct/ForExprMutator.cc'; then $(CYGPATH_W) 'ControlStruct/ForExprMutator.cc'; else $(CYGPATH_W) '$(srcdir)/ControlStruct/ForExprMutator.cc'; fi`
+ControlStruct/driver_cfa_cpp-ExceptTranslate.o: ControlStruct/ExceptTranslate.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT ControlStruct/driver_cfa_cpp-ExceptTranslate.o -MD -MP -MF ControlStruct/$(DEPDIR)/driver_cfa_cpp-ExceptTranslate.Tpo -c -o ControlStruct/driver_cfa_cpp-ExceptTranslate.o `test -f 'ControlStruct/ExceptTranslate.cc' || echo '$(srcdir)/'`ControlStruct/ExceptTranslate.cc
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) ControlStruct/$(DEPDIR)/driver_cfa_cpp-ExceptTranslate.Tpo ControlStruct/$(DEPDIR)/driver_cfa_cpp-ExceptTranslate.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='ControlStruct/ExceptTranslate.cc' object='ControlStruct/driver_cfa_cpp-ExceptTranslate.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 ControlStruct/driver_cfa_cpp-ExceptTranslate.o `test -f 'ControlStruct/ExceptTranslate.cc' || echo '$(srcdir)/'`ControlStruct/ExceptTranslate.cc
+ControlStruct/driver_cfa_cpp-ExceptTranslate.obj: ControlStruct/ExceptTranslate.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT ControlStruct/driver_cfa_cpp-ExceptTranslate.obj -MD -MP -MF ControlStruct/$(DEPDIR)/driver_cfa_cpp-ExceptTranslate.Tpo -c -o ControlStruct/driver_cfa_cpp-ExceptTranslate.obj `if test -f 'ControlStruct/ExceptTranslate.cc'; then $(CYGPATH_W) 'ControlStruct/ExceptTranslate.cc'; else $(CYGPATH_W) '$(srcdir)/ControlStruct/ExceptTranslate.cc'; fi`
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) ControlStruct/$(DEPDIR)/driver_cfa_cpp-ExceptTranslate.Tpo ControlStruct/$(DEPDIR)/driver_cfa_cpp-ExceptTranslate.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='ControlStruct/ExceptTranslate.cc' object='ControlStruct/driver_cfa_cpp-ExceptTranslate.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 ControlStruct/driver_cfa_cpp-ExceptTranslate.obj `if test -f 'ControlStruct/ExceptTranslate.cc'; then $(CYGPATH_W) 'ControlStruct/ExceptTranslate.cc'; else $(CYGPATH_W) '$(srcdir)/ControlStruct/ExceptTranslate.cc'; fi`
 GenPoly/driver_cfa_cpp-Box.o: GenPoly/Box.cc
 @am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-Box.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-Box.Tpo -c -o GenPoly/driver_cfa_cpp-Box.o `test -f 'GenPoly/Box.cc' || echo '$(srcdir)/'`GenPoly/Box.cc
 …
 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o Parser/driver_cfa_cpp-LinkageSpec.obj `if test -f 'Parser/LinkageSpec.cc'; then $(CYGPATH_W) 'Parser/LinkageSpec.cc'; else $(CYGPATH_W) '$(srcdir)/Parser/LinkageSpec.cc'; fi`
 Parser/driver_cfa_cpp-parseutility.o: Parser/parseutility.cc
 @am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Parser/driver_cfa_cpp-parseutility.o -MD -MP -MF Parser/$(DEPDIR)/driver_cfa_cpp-parseutility.Tpo -c -o Parser/driver_cfa_cpp-parseutility.o `test -f 'Parser/parseutility.cc' || echo '$(srcdir)/'`Parser/parseutility.cc
 @am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) Parser/$(DEPDIR)/driver_cfa_cpp-parseutility.Tpo Parser/$(DEPDIR)/driver_cfa_cpp-parseutility.Po
 @AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='Parser/parseutility.cc' object='Parser/driver_cfa_cpp-parseutility.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 Parser/driver_cfa_cpp-parseutility.o `test -f 'Parser/parseutility.cc' || echo '$(srcdir)/'`Parser/parseutility.cc
 Parser/driver_cfa_cpp-parseutility.obj: Parser/parseutility.cc
 @am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Parser/driver_cfa_cpp-parseutility.obj -MD -MP -MF Parser/$(DEPDIR)/driver_cfa_cpp-parseutility.Tpo -c -o Parser/driver_cfa_cpp-parseutility.obj `if test -f 'Parser/parseutility.cc'; then $(CYGPATH_W) 'Parser/parseutility.cc'; else $(CYGPATH_W) '$(srcdir)/Parser/parseutility.cc'; fi`
 @am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) Parser/$(DEPDIR)/driver_cfa_cpp-parseutility.Tpo Parser/$(DEPDIR)/driver_cfa_cpp-parseutility.Po
 @AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='Parser/parseutility.cc' object='Parser/driver_cfa_cpp-parseutility.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 Parser/driver_cfa_cpp-parseutility.obj `if test -f 'Parser/parseutility.cc'; then $(CYGPATH_W) 'Parser/parseutility.cc'; else $(CYGPATH_W) '$(srcdir)/Parser/parseutility.cc'; fi`
+Parser/driver_cfa_cpp-parserutility.o: Parser/parserutility.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Parser/driver_cfa_cpp-parserutility.o -MD -MP -MF Parser/$(DEPDIR)/driver_cfa_cpp-parserutility.Tpo -c -o Parser/driver_cfa_cpp-parserutility.o `test -f 'Parser/parserutility.cc' || echo '$(srcdir)/'`Parser/parserutility.cc
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) Parser/$(DEPDIR)/driver_cfa_cpp-parserutility.Tpo Parser/$(DEPDIR)/driver_cfa_cpp-parserutility.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='Parser/parserutility.cc' object='Parser/driver_cfa_cpp-parserutility.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 Parser/driver_cfa_cpp-parserutility.o `test -f 'Parser/parserutility.cc' || echo '$(srcdir)/'`Parser/parserutility.cc
+Parser/driver_cfa_cpp-parserutility.obj: Parser/parserutility.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Parser/driver_cfa_cpp-parserutility.obj -MD -MP -MF Parser/$(DEPDIR)/driver_cfa_cpp-parserutility.Tpo -c -o Parser/driver_cfa_cpp-parserutility.obj `if test -f 'Parser/parserutility.cc'; then $(CYGPATH_W) 'Parser/parserutility.cc'; else $(CYGPATH_W) '$(srcdir)/Parser/parserutility.cc'; fi`
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) Parser/$(DEPDIR)/driver_cfa_cpp-parserutility.Tpo Parser/$(DEPDIR)/driver_cfa_cpp-parserutility.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='Parser/parserutility.cc' object='Parser/driver_cfa_cpp-parserutility.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 Parser/driver_cfa_cpp-parserutility.obj `if test -f 'Parser/parserutility.cc'; then $(CYGPATH_W) 'Parser/parserutility.cc'; else $(CYGPATH_W) '$(srcdir)/Parser/parserutility.cc'; fi`
 ResolvExpr/driver_cfa_cpp-AlternativeFinder.o: ResolvExpr/AlternativeFinder.cc
 …
 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o ResolvExpr/driver_cfa_cpp-TypeEnvironment.obj `if test -f 'ResolvExpr/TypeEnvironment.cc'; then $(CYGPATH_W) 'ResolvExpr/TypeEnvironment.cc'; else $(CYGPATH_W) '$(srcdir)/ResolvExpr/TypeEnvironment.cc'; fi`
+ResolvExpr/driver_cfa_cpp-CurrentObject.o: ResolvExpr/CurrentObject.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT ResolvExpr/driver_cfa_cpp-CurrentObject.o -MD -MP -MF ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Tpo -c -o ResolvExpr/driver_cfa_cpp-CurrentObject.o `test -f 'ResolvExpr/CurrentObject.cc' || echo '$(srcdir)/'`ResolvExpr/CurrentObject.cc
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Tpo ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='ResolvExpr/CurrentObject.cc' object='ResolvExpr/driver_cfa_cpp-CurrentObject.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 ResolvExpr/driver_cfa_cpp-CurrentObject.o `test -f 'ResolvExpr/CurrentObject.cc' || echo '$(srcdir)/'`ResolvExpr/CurrentObject.cc
+ResolvExpr/driver_cfa_cpp-CurrentObject.obj: ResolvExpr/CurrentObject.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT ResolvExpr/driver_cfa_cpp-CurrentObject.obj -MD -MP -MF ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Tpo -c -o ResolvExpr/driver_cfa_cpp-CurrentObject.obj `if test -f 'ResolvExpr/CurrentObject.cc'; then $(CYGPATH_W) 'ResolvExpr/CurrentObject.cc'; else $(CYGPATH_W) '$(srcdir)/ResolvExpr/CurrentObject.cc'; fi`
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Tpo ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='ResolvExpr/CurrentObject.cc' object='ResolvExpr/driver_cfa_cpp-CurrentObject.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 ResolvExpr/driver_cfa_cpp-CurrentObject.obj `if test -f 'ResolvExpr/CurrentObject.cc'; then $(CYGPATH_W) 'ResolvExpr/CurrentObject.cc'; else $(CYGPATH_W) '$(srcdir)/ResolvExpr/CurrentObject.cc'; fi`
 SymTab/driver_cfa_cpp-Indexer.o: SymTab/Indexer.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-Indexer.o -MD -MP -MF SymTab/$(DEPDIR)/driver_cfa_cpp-Indexer.Tpo -c -o SymTab/driver_cfa_cpp-Indexer.o `test -f 'SymTab/Indexer.cc' || echo '$(srcdir)/'`SymTab/Indexer.cc
 …
 @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 SynTree/driver_cfa_cpp-ArrayType.obj `if test -f 'SynTree/ArrayType.cc'; then $(CYGPATH_W) 'SynTree/ArrayType.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/ArrayType.cc'; fi`
-SynTree/driver_cfa_cpp-ReferenceType.o: SynTree/ReferenceType.cc
-@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-ReferenceType.o -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Tpo -c -o SynTree/driver_cfa_cpp-ReferenceType.o `test -f 'SynTree/ReferenceType.cc' || echo '$(srcdir)/'`SynTree/ReferenceType.cc
-@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/ReferenceType.cc' object='SynTree/driver_cfa_cpp-ReferenceType.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 SynTree/driver_cfa_cpp-ReferenceType.o `test -f 'SynTree/ReferenceType.cc' || echo '$(srcdir)/'`SynTree/ReferenceType.cc
-SynTree/driver_cfa_cpp-ReferenceType.obj: SynTree/ReferenceType.cc
-@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-ReferenceType.obj -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Tpo -c -o SynTree/driver_cfa_cpp-ReferenceType.obj `if test -f 'SynTree/ReferenceType.cc'; then $(CYGPATH_W) 'SynTree/ReferenceType.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/ReferenceType.cc'; fi`
-@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/ReferenceType.cc' object='SynTree/driver_cfa_cpp-ReferenceType.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 SynTree/driver_cfa_cpp-ReferenceType.obj `if test -f 'SynTree/ReferenceType.cc'; then $(CYGPATH_W) 'SynTree/ReferenceType.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/ReferenceType.cc'; fi`
 SynTree/driver_cfa_cpp-FunctionType.o: SynTree/FunctionType.cc

src/Parser/DeclarationNode.cc

-              r9c951e3
+              rb1e63ac5
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Mar 17 15:46:33 2017
 // Update Count     : 1018
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Jun 28 15:27:00 2017
+// Update Count     : 1019
 //
 …
         variable.tyClass = NoTypeClass;
         variable.assertions = nullptr;
+        variable.initializer = nullptr;
 //      attr.name = nullptr;
 …
 //      delete variable.name;
         delete variable.assertions;
+        delete variable.initializer;
         delete type;
 …
         newnode->variable.tyClass = variable.tyClass;
         newnode->variable.assertions = maybeClone( variable.assertions );
+        newnode->variable.initializer = maybeClone( variable.initializer );
 //      newnode->attr.name = attr.name ? new string( *attr.name ) : nullptr;
 …
+}
+DeclarationNode * DeclarationNode::addTypeInitializer( DeclarationNode * init ) {
+        assertf( variable.tyClass != NoTypeClass, "Called addTypeInitializer on something that isn't a type variable." );
+        variable.initializer = init;
+        return this;
+}
 DeclarationNode * DeclarationNode::cloneType( string * newName ) {
         DeclarationNode * newnode = new DeclarationNode;
 …
                 assertf( sizeof(kindMap)/sizeof(kindMap[0] == NoTypeClass-1), "DeclarationNode::build: kindMap is out of sync." );
                 assertf( variable.tyClass < sizeof(kindMap)/sizeof(kindMap[0]), "Variable's tyClass is out of bounds." );
                 TypeDecl * ret = new TypeDecl( *name, Type::StorageClasses(), nullptr, kindMap[ variable.tyClass ] );
+                TypeDecl * ret = new TypeDecl( *name, Type::StorageClasses(), nullptr, kindMap[ variable.tyClass ], variable.initializer ? variable.initializer->buildType() : nullptr );
                 buildList( variable.assertions, ret->get_assertions() );
                 return ret;
 …
           case TypeData::Enum:
           case TypeData::Aggregate: {
                   ReferenceToType * ret = buildComAggInst( type, attributes );
+                  ReferenceToType * ret = buildComAggInst( type, attributes, linkage );
                   buildList( type->aggregate.actuals, ret->get_parameters() );
                   return ret;

src/Parser/ExpressionNode.cc

-              r9c951e3
+              rb1e63ac5
 // Created On       : Sat May 16 13:17:07 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Mar 30 17:02:46 2017
 // Update Count     : 515
+// Last Modified On : Wed Jun 28 21:08:15 2017
+// Update Count     : 542
 //
 …
 #include "SynTree/Declaration.h"
 #include "Common/UnimplementedError.h"
 #include "parseutility.h"
+#include "parserutility.h"
 #include "Common/utility.h"
 …
         bool dec = true, Unsigned = false;                                      // decimal, unsigned constant
         int size;                                                                                       // 0 => int, 1 => long, 2 => long long
         unsigned long long v;                                                           // converted integral value
+        unsigned long long int v;                                                               // converted integral value
         size_t last = str.length() - 1;                                         // last character of constant
 …
         } // if
         Expression * ret = new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[Unsigned][size] ), str ) );
+        Expression * ret = new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[Unsigned][size] ), str, v ) );
         delete &str;                                                                            // created by lex
         return ret;
 …
         // floating-point constant has minimum of 2 characters: 1. or .1
         size_t last = str.length() - 1;
+        double v;
+        sscanf( str.c_str(), "%lg", &v );
         if ( checkI( str[last] ) ) {                                            // imaginary ?
 …
         } // if
         Expression * ret = new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[complx][size] ), str ) );
+        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( emptyQualifiers, BasicType::Char ), str ) );
+        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;
 …
         // string should probably be a primitive type
         ArrayType *at = new ArrayType( emptyQualifiers, new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char ),
+                                new ConstantExpr( Constant( new BasicType( emptyQualifiers, BasicType::UnsignedInt ),
+                                                                                        toString( str.size()+1-2 ) ) ),  // +1 for '\0' and -2 for '"'
+                                                                   new ConstantExpr( Constant::from_ulong( str.size() + 1 - 2 ) ),  // +1 for '\0' and -2 for '"'
                                                                    false, false );
+        ConstantExpr * ret = new ConstantExpr( Constant( at, str ) );
+        // constant 0 is ignored for pure string value
+        ConstantExpr * ret = new ConstantExpr( Constant( at, str, (unsigned long long int)0 ) );
         delete &str;                                                                            // created by lex
         return ret;
 …
 Expression *build_constantZeroOne( const std::string & str ) {
+        Expression * ret = new ConstantExpr( Constant( str == "0" ? (Type *)new ZeroType( emptyQualifiers ) : (Type*)new OneType( emptyQualifiers ), 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
         return ret;
 …
         std::stringstream ss( str );
         ss >> a >> dot >> b;
+        UntypedMemberExpr * ret = new UntypedMemberExpr(
+                new ConstantExpr( Constant( new BasicType( emptyQualifiers, BasicType::SignedInt ), toString( b ) ) ),
+                new ConstantExpr( Constant( new BasicType( emptyQualifiers, BasicType::SignedInt ), toString( a ) ) ) );
+        UntypedMemberExpr * ret = new UntypedMemberExpr( new ConstantExpr( Constant::from_int( b ) ), new ConstantExpr( Constant::from_int( a ) ) );
         delete &str;
         return ret;
 …
 } // build_field_name_fraction_constants
 Expression * build_field_name_REALFRACTIONconstant( const std::string & str ) {
         assert( str[0] == '.' );
+        if ( str.find_first_not_of( "0123456789", 1 ) != string::npos ) throw SemanticError( "invalid tuple index " + str );
         Expression * ret = build_constantInteger( *new std::string( str.substr(1) ) );
         delete &str;
 …
 Expression * build_field_name_REALDECIMALconstant( const std::string & str ) {
         assert( str[str.size()-1] == '.' );
+        if ( str[str.size()-1] != '.' ) throw SemanticError( "invalid tuple index " + str );
         Expression * ret = build_constantInteger( *new std::string( str.substr( 0, str.size()-1 ) ) );
         delete &str;
 …
 } // build_field_name_REALDECIMALconstant
 NameExpr * build_varref( const string *name, bool labelp ) {
+NameExpr * build_varref( const string *name ) {
         NameExpr *expr = new NameExpr( *name, nullptr );
         delete name;
 …
 Expression *build_valexpr( StatementNode *s ) {
         return new UntypedValofExpr( maybeMoveBuild< Statement >(s), nullptr );
+        return new StmtExpr( dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >(s) ) );
+}
 Expression *build_typevalue( DeclarationNode *decl ) {

src/Parser/InitializerNode.cc

-              r9c951e3
+              rb1e63ac5
         InitializerNode *moreInit;
         if  ( get_next() != 0 && ((moreInit = dynamic_cast< InitializerNode * >( get_next() ) ) != 0) )
+        if ( (moreInit = dynamic_cast< InitializerNode * >( get_next() ) ) ) {
                 moreInit->printOneLine( os );
+        }
+}
 Initializer *InitializerNode::build() const {
         if ( aggregate ) {
+                // steal designators from children
+                std::list< Designation * > designlist;
+                InitializerNode * child = next_init();
+                for ( ; child != nullptr; child = dynamic_cast< InitializerNode * >( child->get_next() ) ) {
+                        std::list< Expression * > desList;
+                        buildList< Expression, ExpressionNode >( child->designator, desList );
+                        designlist.push_back( new Designation( desList ) );
+                } // for
                 std::list< Initializer * > initlist;
                 buildList< Initializer, InitializerNode >( next_init(), initlist );
-                std::list< Expression * > designlist;
-                if ( designator != 0 ) {
-                        buildList< Expression, ExpressionNode >( designator, designlist );
-                } // if
                 return new ListInit( initlist, designlist, maybeConstructed );
         } else {
+                std::list< Expression * > designators;
+                if ( designator != 0 )
+                        buildList< Expression, ExpressionNode >( designator, designators );
+                if ( get_expression() != 0)
+                        return new SingleInit( maybeBuild< Expression >( get_expression() ), designators, maybeConstructed );
+                if ( get_expression() != 0) {
+                        return new SingleInit( maybeBuild< Expression >( get_expression() ), maybeConstructed );
+                }
         } // if
         return 0;
+}

src/Parser/LinkageSpec.cc

-              r9c951e3
+              rb1e63ac5
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 13:22:09 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Oct  2 23:16:21 2016
 // Update Count     : 23
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Jun 28 11:51:00 2017
+// Update Count     : 24
 //
 …
         } else if ( *spec == "\"C\"" ) {
                 return C;
+        } else if ( *spec == "\"BuiltinC\"" ) {
+                return BuiltinC;
         } else {
                 throw SemanticError( "Invalid linkage specifier " + *spec );
 …
         assert( 0 <= linkage && linkage < LinkageSpec::NoOfSpecs );
         static const char *linkageKinds[LinkageSpec::NoOfSpecs] = {
                 "intrinsic", "Cforall", "C", "automatically generated", "compiler built-in",
+                "intrinsic", "Cforall", "C", "automatically generated", "compiler built-in", "cfa built-in", "c built-in",
         };
         return linkageKinds[linkage];
+}
 bool LinkageSpec::isDecoratable( Spec spec ) {
+bool LinkageSpec::isMangled( Spec spec ) {
         assert( 0 <= spec && spec < LinkageSpec::NoOfSpecs );
         static bool decoratable[LinkageSpec::NoOfSpecs] = {
                 //      Intrinsic,      Cforall,        C,              AutoGen,        Compiler
+                //      Intrinsic,      Cforall,        C,              AutoGen,        Compiler,
                         true,           true,           false,  true,           false,
+                //      Builtin,        BuiltinC,
+                        true,           false,
         };
         return decoratable[spec];
 …
         assert( 0 <= spec && spec < LinkageSpec::NoOfSpecs );
         static bool generatable[LinkageSpec::NoOfSpecs] = {
                 //      Intrinsic,      Cforall,        C,              AutoGen,        Compiler
+                //      Intrinsic,      Cforall,        C,              AutoGen,        Compiler,
                         true,           true,           true,   true,           false,
+                //      Builtin,        BuiltinC,
+                        true,           true,
         };
         return generatable[spec];
 …
         assert( spec >= 0 && spec < LinkageSpec::NoOfSpecs );
         static bool overridable[LinkageSpec::NoOfSpecs] = {
                 //      Intrinsic,      Cforall,        C,              AutoGen,        Compiler
+                //      Intrinsic,      Cforall,        C,              AutoGen,        Compiler,
                         true,           false,          false,  true,           false,
+                //      Builtin,        BuiltinC,
+                        false,          false,
         };
         return overridable[spec];
 …
         assert( spec >= 0 && spec < LinkageSpec::NoOfSpecs );
         static bool builtin[LinkageSpec::NoOfSpecs] = {
                 //      Intrinsic,      Cforall,        C,              AutoGen,        Compiler
+                //      Intrinsic,      Cforall,        C,              AutoGen,        Compiler,
                         true,           false,          false,  false,          true,
+                //      Builtin,        BuiltinC,
+                        true,           true,
         };
         return builtin[spec];

src/Parser/LinkageSpec.h

-              r9c951e3
+              rb1e63ac5
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 13:24:28 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Oct  1 23:03:17 2016
 // Update Count     : 11
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Jun 28 11:50:00 2017
+// Update Count     : 12
 //
 …
                 AutoGen,                                                                                // built by translator (struct assignment)
                 Compiler,                                                                               // gcc internal
+                Builtin,                                                                                // mangled builtins
+                BuiltinC,                                                                               // non-mangled builtins
                 NoOfSpecs
         };
 …
         static std::string linkageName( Spec );
         static bool isDecoratable( Spec );
+        static bool isMangled( Spec );
         static bool isGeneratable( Spec );
         static bool isOverridable( Spec );

src/Parser/ParseNode.h

-              r9c951e3
+              rb1e63ac5
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Mar 17 15:42:18 2017
 // Update Count     : 777
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Jun 12 13:00:00 2017
+// Update Count     : 779
 //
 …
+        }
         virtual void print( std::ostream &os, int indent = 0 ) const {}
         virtual void printList( std::ostream &os, int indent = 0 ) const {}
+        virtual void print( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const {}
+        virtual void printList( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const {}
         static int indent_by;
 …
         ExpressionNode * set_extension( bool exten ) { extension = exten; return this; }
         virtual void print( std::ostream &os, int indent = 0 ) const override {}
         void printOneLine( std::ostream &os, int indent = 0 ) const {}
+        virtual void print( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const override {}
+        void printOneLine( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const {}
         template<typename T>
 …
 Expression * build_field_name_REALDECIMALconstant( const std::string & str );
 NameExpr * build_varref( const std::string * name, bool labelp = false );
+NameExpr * build_varref( const std::string * name );
 Expression * build_typevalue( DeclarationNode * decl );
 …
         DeclarationNode * addIdList( DeclarationNode * list ); // old-style functions
         DeclarationNode * addInitializer( InitializerNode * init );
+        DeclarationNode * addTypeInitializer( DeclarationNode * init );
         DeclarationNode * cloneType( std::string * newName );
 …
+        }
         virtual void print( std::ostream &os, int indent = 0 ) const override;
         virtual void printList( std::ostream &os, int indent = 0 ) const override;
+        virtual void print( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const override;
+        virtual void printList( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const override;
         Declaration * build() const;
 …
                 DeclarationNode::TypeClass tyClass;
                 DeclarationNode * assertions;
+                DeclarationNode * initializer;
         };
         Variable_t variable;
 …
         virtual StatementNode * append_last_case( StatementNode * );
         virtual void print( std::ostream &os, int indent = 0 ) const override {}
         virtual void printList( std::ostream &os, int indent = 0 ) const override {}
+        virtual void print( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const override {}
+        virtual void printList( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const override {}
   private:
         std::unique_ptr<Statement> stmt;
 …
 Statement * build_return( ExpressionNode * ctl );
 Statement * build_throw( ExpressionNode * ctl );
+Statement * build_resume( ExpressionNode * ctl );
+Statement * build_resume_at( ExpressionNode * ctl , ExpressionNode * target );
 Statement * build_try( StatementNode * try_stmt, StatementNode * catch_stmt, StatementNode * finally_stmt );
 Statement * build_catch( DeclarationNode * decl, StatementNode * stmt, bool catchAny = false );
+Statement * build_catch( CatchStmt::Kind kind, DeclarationNode *decl, ExpressionNode *cond, StatementNode *body );
 Statement * build_finally( StatementNode * stmt );
 Statement * build_compound( StatementNode * first );
 …
                                 result->location = cur->location;
                                 * out++ = result;
+                        } else {
+                                assertf(false, "buildList unknown type");
                         } // if
                 } catch( SemanticError &e ) {

src/Parser/StatementNode.cc

-              r9c951e3
+              rb1e63ac5
 // Created On       : Sat May 16 14:59:41 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Feb  2 22:16:40 2017
 // Update Count     : 327
+// Last Modified On : Wed Jun 28 21:08:37 2017
+// Update Count     : 330
 //
 …
 #include "SynTree/Statement.h"
 #include "SynTree/Expression.h"
 #include "parseutility.h"
+#include "parserutility.h"
 #include "Common/utility.h"
 …
         return new ReturnStmt( noLabels, exps.size() > 0 ? exps.back() : nullptr );
+}
 Statement *build_throw( ExpressionNode *ctl ) {
         std::list< Expression * > exps;
         buildMoveList( ctl, exps );
         assertf( exps.size() < 2, "This means we are leaking memory");
+        return new ReturnStmt( noLabels, !exps.empty() ? exps.back() : nullptr, true );
+        return new ThrowStmt( noLabels, ThrowStmt::Terminate, !exps.empty() ? exps.back() : nullptr );
+}
+Statement *build_resume( ExpressionNode *ctl ) {
+        std::list< Expression * > exps;
+        buildMoveList( ctl, exps );
+        assertf( exps.size() < 2, "This means we are leaking memory");
+        return new ThrowStmt( noLabels, ThrowStmt::Resume, !exps.empty() ? exps.back() : nullptr );
+}
+Statement *build_resume_at( ExpressionNode *ctl, ExpressionNode *target ) {
+        (void)ctl;
+        (void)target;
+        assertf( false, "resume at (non-local throw) is not yet supported," );
+}
 Statement *build_try( StatementNode *try_stmt, StatementNode *catch_stmt, StatementNode *finally_stmt ) {
         std::list< Statement * > branches;
         buildMoveList< Statement, StatementNode >( catch_stmt, branches );
+        std::list< CatchStmt * > branches;
+        buildMoveList< CatchStmt, StatementNode >( catch_stmt, branches );
         CompoundStmt *tryBlock = safe_dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >(try_stmt));
         FinallyStmt *finallyBlock = dynamic_cast< FinallyStmt * >(maybeMoveBuild< Statement >(finally_stmt) );
         return new TryStmt( noLabels, tryBlock, branches, finallyBlock );
+}
 Statement *build_catch( DeclarationNode *decl, StatementNode *stmt, bool catchAny ) {
         std::list< Statement * > branches;
         buildMoveList< Statement, StatementNode >( stmt, branches );
         assert( branches.size() == 1 );
         return new CatchStmt( noLabels, maybeMoveBuild< Declaration >(decl), branches.front(), catchAny );
+Statement *build_catch( CatchStmt::Kind kind, DeclarationNode *decl, ExpressionNode *cond, StatementNode *body ) {
+        std::list< Statement * > branches;
+        buildMoveList< Statement, StatementNode >( body, branches );
+        assert( branches.size() == 1 );
+        return new CatchStmt( noLabels, kind, maybeMoveBuild< Declaration >(decl), maybeMoveBuild< Expression >(cond), branches.front() );
+}
 Statement *build_finally( StatementNode *stmt ) {

src/Parser/TypeData.cc

-              r9c951e3
+              rb1e63ac5
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Mar 17 15:52:43 2017
 // Update Count     : 563
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Jun 28 15:28:00 2017
+// Update Count     : 564
 //
 …
 } // buildReference
 AggregateDecl * buildAggregate( const TypeData * td, std::list< Attribute * > attributes ) {
+AggregateDecl * buildAggregate( const TypeData * td, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) {
         assert( td->kind == TypeData::Aggregate );
         AggregateDecl * at;
 …
           case DeclarationNode::Monitor:
           case DeclarationNode::Thread:
                 at = new StructDecl( *td->aggregate.name, td->aggregate.kind, attributes );
+                at = new StructDecl( *td->aggregate.name, td->aggregate.kind, attributes, linkage );
                 buildForall( td->aggregate.params, at->get_parameters() );
                 break;
 …
 } // buildAggregate
 ReferenceToType * buildComAggInst( const TypeData * type, std::list< Attribute * > attributes ) {
+ReferenceToType * buildComAggInst( const TypeData * type, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) {
         switch ( type->kind ) {
           case TypeData::Enum: {
 …
                   ReferenceToType * ret;
                   if ( type->aggregate.body ) {
                           AggregateDecl * typedecl = buildAggregate( type, attributes );
+                          AggregateDecl * typedecl = buildAggregate( type, attributes, linkage );
                           switch ( type->aggregate.kind ) {
                                 case DeclarationNode::Struct:
 …
                 if ( cur->has_enumeratorValue() ) {
                         ObjectDecl * member = dynamic_cast< ObjectDecl * >(* members);
                         member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ), list< Expression * >() ) );
+                        member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ) ) );
                 } // if
         } // for
 …
 TupleType * buildTuple( const TypeData * td ) {
         assert( td->kind == TypeData::Tuple );
+        TupleType * ret = new TupleType( buildQualifiers( td ) );
+        buildTypeList( td->tuple, ret->get_types() );
+        std::list< Type * > types;
+        buildTypeList( td->tuple, types );
+        TupleType * ret = new TupleType( buildQualifiers( td ), types );
         buildForall( td->forall, ret->get_forall() );
         return ret;
 …
                 return decl->set_asmName( asmName );
         } else if ( td->kind == TypeData::Aggregate ) {
                 return buildAggregate( td, attributes );
+                return buildAggregate( td, attributes, linkage );
         } else if ( td->kind == TypeData::Enum ) {
                 return buildEnum( td, attributes );

src/Parser/TypeData.h

-              r9c951e3
+              rb1e63ac5
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 15:18:36 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Mar 16 08:32:39 2017
 // Update Count     : 185
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Jun 28 15:29:00 2017
+// Update Count     : 186
 //
 …
 ReferenceType * buildReference( const TypeData * );
 AggregateDecl * buildAggregate( const TypeData *, std::list< Attribute * > );
 ReferenceToType * buildComAggInst( const TypeData *, std::list< Attribute * > attributes );
+ReferenceToType * buildComAggInst( const TypeData *, std::list< Attribute * > attributes, LinkageSpec::Spec linkage );
 ReferenceToType * buildAggInst( const TypeData * );
 TypeDecl * buildVariable( const TypeData * );

src/Parser/TypedefTable.h

-              r9c951e3
+              rb1e63ac5
 // Created On       : Sat May 16 15:24:36 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Aug 15 18:25:04 2016
 // Update Count     : 28
+// Last Modified On : Wed Jun 28 21:56:34 2017
+// Update Count     : 33
 //
 …
 #include <stack>
 #include "lex.h"
+#include "parser.hh"
 #include "parser.h"

src/Parser/lex.ll

-              r9c951e3
+              rb1e63ac5
  * file "LICENCE" distributed with Cforall.
+ *
  * lex.l --
+ * lex.ll --
+ *
  * Author           : Peter A. Buhr
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
  * Last Modified On : Mon Mar 13 08:36:17 2017
  * Update Count     : 506
+ * Last Modified On : Wed Jun 28 21:03:45 2017
+ * Update Count     : 529
  */
 …
 #include <cstdio>                                                                               // FILENAME_MAX
-#include "lex.h"
-#include "parser.h"                                                                             // YACC generated definitions based on C++ grammar
 #include "ParseNode.h"
 #include "TypedefTable.h"
 …
                                 // numeric constants, CFA: '_' in constant
 hex_quad {hex}("_"?{hex}){3}
 integer_suffix "_"?(([uU][lL]?)|([uU]("ll"|"LL")?)|([lL][uU]?)|("ll"|"LL")[uU]?)
+integer_suffix "_"?(([uU](("ll"|"LL"|[lL])[iI]|[iI]?("ll"|"LL"|[lL])?))|([iI](("ll"|"LL"|[lL])[uU]|[uU]?("ll"|"LL"|[lL])?))|(("ll"|"LL"|[lL])([iI][uU]|[uU]?[iI]?)))
 octal_digits ({octal})|({octal}({octal}|"_")*{octal})
 …
 decimal_digits ({decimal})|({decimal}({decimal}|"_")*{decimal})
 real_decimal {decimal_digits}"."
 real_fraction "."{decimal_digits}
 real_constant {decimal_digits}?{real_fraction}
+real_decimal {decimal_digits}"."{exponent}?{floating_suffix}?
+real_fraction "."{decimal_digits}{exponent}?{floating_suffix}?
+real_constant {decimal_digits}{real_fraction}
 exponent "_"?[eE]"_"?[+-]?{decimal_digits}
+                                // GCC: D (double), DL (long double) and iI (imaginary) suffixes
+floating_suffix "_"?([fFdDlL][iI]?|"DL"|[iI][lLfFdD]?)
+                                //floating_suffix "_"?([fFdD]|[lL]|[D][L])|([iI][lLfFdD])|([lLfFdD][iI]))
+                                // GCC: D (double) and iI (imaginary) suffixes, and DL (long double)
+floating_suffix "_"?([fFdDlL][iI]?|[iI][lLfFdD]?|"DL")
 floating_constant (({real_constant}{exponent}?)|({decimal_digits}{exponent})){floating_suffix}?
 …
 long                    { KEYWORD_RETURN(LONG); }
 lvalue                  { KEYWORD_RETURN(LVALUE); }                             // CFA
 monitor         { KEYWORD_RETURN(MONITOR); }                    // CFA
+monitor                 { KEYWORD_RETURN(MONITOR); }                    // CFA
 mutex                   { KEYWORD_RETURN(MUTEX); }                              // CFA
 _Noreturn               { KEYWORD_RETURN(NORETURN); }                   // C11
 …
 "?"{op_binary_over}"?"  { IDENTIFIER_RETURN(); }                // binary
         /*
           This rule handles ambiguous cases with operator identifiers, e.g., "int *?*?()", where the string "*?*?"
           can be lexed as "*"/"?*?" or "*?"/"*?". Since it is common practise to put a unary operator juxtaposed
           to an identifier, e.g., "*i", users will be annoyed if they cannot do this with respect to operator
           identifiers. Even with this special hack, there are 5 general cases that cannot be handled. The first
           case is for the function-call identifier "?()":
+          int * ?()();  // declaration: space required after '*'
           * ?()();      // expression: space required after '*'
           Without the space, the string "*?()" is ambiguous without N character look ahead; it requires scanning
           ahead to determine if there is a '(', which is the start of an argument/parameter list.
+          The 4 remaining cases occur in expressions:
+          i++?i:0;              // space required before '?'
           i--?i:0;              // space required before '?'
           i?++i:0;              // space required after '?'
+          i?--i:0;              // space required after '?'
+          In the first two cases, the string "i++?" is ambiguous, where this string can be lexed as "i"/"++?" or
+          "i++"/"?"; it requires scanning ahead to determine if there is a '(', which is the start of an argument
+          list.  In the second two cases, the string "?++x" is ambiguous, where this string can be lexed as
           "?++"/"x" or "?"/"++x"; it requires scanning ahead to determine if there is a '(', which is the start of
           an argument list.
+          This rule handles ambiguous cases with operator identifiers, e.g., "int *?*?()", where the string "*?*?"  can be
+          lexed as "*?"/"*?" or "*"/"?*?". Since it is common practise to put a unary operator juxtaposed to an identifier,
+          e.g., "*i", users will be annoyed if they cannot do this with respect to operator identifiers. Therefore, there is
+          a lexical look-ahead for the second case, with backtracking to return the leading unary operator and then
+          reparsing the trailing operator identifier.  Otherwise a space is needed between the unary operator and operator
+          identifier to disambiguate this common case.
+          A similar issue occurs with the dereference, *?(...), and routine-call, ?()(...) identifiers.  The ambiguity
+          occurs when the deference operator has no parameters, *?() and *?()(...), requiring arbitrary whitespace
+          look-ahead for the routine-call parameter-list to disambiguate.  However, the dereference operator must have a
+          parameter/argument to dereference *?(...).  Hence, always interpreting the string *?() as * ?() does not preclude
+          any meaningful program.
+          The remaining cases are with the increment/decrement operators and conditional expression:
+          i++? ...(...);
+          i?++ ...(...);
+          requiring arbitrary whitespace look-ahead for the operator parameter-list, even though that interpretation is an
+      incorrect expression (juxtaposed identifiers).  Therefore, it is necessary to disambiguate these cases with a
+      space:
+          i++ ? i : 0;
+          i? ++i : 0;
         */
 {op_unary}"?"({op_unary_pre_post}|"[?]"|{op_binary_over}"?") {
+{op_unary}"?"({op_unary_pre_post}|"()"|"[?]"|{op_binary_over}"?") {
         // 1 or 2 character unary operator ?
         int i = yytext[1] == '?' ? 1 : 2;

src/Parser/module.mk

-              r9c951e3
+              rb1e63ac5
 ## Created On       : Sat May 16 15:29:09 2015
 ## Last Modified By : Peter A. Buhr
 ## Last Modified On : Tue Aug 16 17:28:34 2016
 ## Update Count     : 101
+## Last Modified On : Wed Jun 28 21:58:29 2017
+## Update Count     : 104
 ###############################################################################
 …
        Parser/TypeData.cc \
        Parser/LinkageSpec.cc \
        Parser/parseutility.cc
+       Parser/parserutility.cc
 MAINTAINERCLEANFILES += Parser/parser.output

src/Parser/parser.hh

-              r9c951e3
+              rb1e63ac5
 // file "LICENCE" distributed with Cforall.
 //
 // lex.h --
+// parser.hh --
 //
 // Author           : Peter A. Buhr
 // Created On       : Sat Sep 22 08:58:10 2001
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Aug 21 11:28:47 2016
 // Update Count     : 347
+// Last Modified On : Wed Jun 28 22:10:17 2017
+// Update Count     : 349
 //
 #ifndef PARSER_LEX_H
 #define PARSER_LEX_H
+#ifndef PARSER_HH
+#define PARSER_HH
 int yylex();
 …
 }; // Token
 #endif // PARSER_LEX_H
+#endif // PARSER_HH
 // Local Variables: //

src/Parser/parser.yy

-              r9c951e3
+              rb1e63ac5
 // file "LICENCE" distributed with Cforall.
 //
 // cfa.y --
+// parser.yy --
 //
 // Author           : Peter A. Buhr
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Mar 30 15:42:32 2017
 // Update Count     : 2318
+// Last Modified On : Wed Jun 28 22:11:22 2017
+// Update Count     : 2414
 //
 …
 #include <cstdio>
 #include <stack>
-#include "lex.h"
-#include "parser.h"
 #include "ParseNode.h"
 #include "TypedefTable.h"
 …
         } // for
 } // distExt
+bool forall = false;                                                                    // aggregate have one or more forall qualifiers ?
 %}
+// Types declaration
+%union
+{
+        Token tok;
+        ParseNode * pn;
+        ExpressionNode * en;
+        DeclarationNode * decl;
+        DeclarationNode::Aggregate aggKey;
+        DeclarationNode::TypeClass tclass;
+        StatementNode * sn;
+        ConstantExpr * constant;
+        ForCtl * fctl;
+        LabelNode * label;
+        InitializerNode * in;
+        OperKinds op;
+        std::string * str;
+        bool flag;
+}
 //************************* TERMINAL TOKENS ********************************
 …
 %token ATassign                                                                                 // @=
+// Types declaration
+%union
+{
+        Token tok;
+        ParseNode * pn;
+        ExpressionNode * en;
+        DeclarationNode * decl;
+        DeclarationNode::Aggregate aggKey;
+        DeclarationNode::TypeClass tclass;
+        StatementNode * sn;
+        ConstantExpr * constant;
+        ForCtl * fctl;
+        LabelNode * label;
+        InitializerNode * in;
+        OperKinds op;
+        std::string * str;
+        bool flag;
+}
+%type<tok> identifier  no_01_identifier  no_attr_identifier zero_one
+%type<tok> identifier_or_type_name  no_attr_identifier_or_type_name  no_01_identifier_or_type_name  attr_name
+%type<tok> identifier  no_attr_identifier  zero_one
+%type<tok> identifier_or_type_name  no_attr_identifier_or_type_name  attr_name
 %type<constant> string_literal
 %type<str> string_literal_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<sn> /* handler_list */                    handler_clause                          finally_clause
 // declarations
 …
 %type<en>   bit_subrange_size_opt bit_subrange_size
 %type<decl> basic_declaration_specifier basic_type_name basic_type_specifier direct_type_name indirect_type_name
+%type<decl> basic_declaration_specifier basic_type_name basic_type_specifier direct_type indirect_type
 %type<decl> trait_declaration trait_declaration_list trait_declaring_list trait_specifier
 …
 %type<decl> type_declarator type_declarator_name type_declaring_list
+%type<decl> typedef typedef_type_specifier typedef_declaration typedef_declaration_specifier typedef_expression
+%type<decl> type_declaration_specifier type_type_specifier type_name typegen_name
+%type<decl> typedef typedef_declaration typedef_expression
 %type<decl> variable_type_redeclarator type_ptr type_array type_function
 %type<decl> type_parameter_redeclarator type_parameter_ptr type_parameter_array type_parameter_function
+%type<decl> typegen_declaration_specifier typegen_type_specifier typegen_name
+%type<decl> type_name type_name_no_function
+%type<decl> type_parameter type_parameter_list
+%type<en> type_name_list
+%type<decl> type type_no_function
+%type<decl> type_parameter type_parameter_list type_initializer_opt
+%type<en> type_list
 %type<decl> type_qualifier type_qualifier_name type_qualifier_list_opt type_qualifier_list
 …
         IDENTIFIER
         | ATTR_IDENTIFIER                                                                       // CFA
-        | zero_one                                                                                      // CFA
+        ;
-no_01_identifier:
-        IDENTIFIER
-        | ATTR_IDENTIFIER                                                                       // CFA
+        ;
 no_attr_identifier:
         IDENTIFIER
-        | zero_one                                                                                      // CFA
+        ;
 …
         ZERO
         | ONE
+        ;
+        ;
 string_literal:
 …
         | '(' compound_statement ')'                                            // GCC, lambda expression
                 { $$ = new ExpressionNode( build_valexpr( $2 ) ); }
         | primary_expression '{' argument_expression_list '}' // CFA
+        | primary_expression '{' argument_expression_list '}' // CFA, constructor call
+                {
                         Token fn;
 …
                         $$ = new ExpressionNode( new ConstructorExpr( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $1 )->set_last( $3 ) ) ) );
+                }
+        | type_name '.' no_attr_identifier                                      // CFA, nested type
+                { $$ = nullptr; }                                                               // FIX ME
+        | type_name '.' '[' push field_list pop ']'                     // CFA, nested type / tuple field selector
+                { $$ = nullptr; }                                                               // FIX ME
+        ;
 …
         | postfix_expression DECR
                 { $$ = new ExpressionNode( build_unary_ptr( OperKinds::DecrPost, $1 ) ); }
         | '(' type_name_no_function ')' '{' initializer_list comma_opt '}' // C99, compound-literal
+        | '(' type_no_function ')' '{' initializer_list comma_opt '}' // C99, compound-literal
                 { $$ = new ExpressionNode( build_compoundLiteral( $2, new InitializerNode( $5, true ) ) ); }
         | '^' primary_expression '{' argument_expression_list '}' // CFA
 …
         | no_attr_identifier fraction_constants
+                {
                         if( (*$1) == "0" || (*$1) == "1" ) {
                                 $$ = new ExpressionNode( build_field_name_fraction_constants( build_constantZeroOne( *$1 ), $2 ) );
                         } else {
                                 $$ = new ExpressionNode( build_field_name_fraction_constants( build_varref( $1 ), $2 ) );
+                        }
+                        $$ = new ExpressionNode( build_field_name_fraction_constants( build_varref( $1 ), $2 ) );
+                }
+        | zero_one fraction_constants
+                {
+                        $$ = new ExpressionNode( build_field_name_fraction_constants( build_constantZeroOne( *$1 ), $2 ) );
+                }
+        ;
 …
         | SIZEOF unary_expression
                 { $$ = new ExpressionNode( build_sizeOfexpr( $2 ) ); }
         | SIZEOF '(' type_name_no_function ')'
+        | SIZEOF '(' type_no_function ')'
                 { $$ = new ExpressionNode( build_sizeOftype( $3 ) ); }
         | ALIGNOF unary_expression                                                      // GCC, variable alignment
                 { $$ = new ExpressionNode( build_alignOfexpr( $2 ) ); }
         | ALIGNOF '(' type_name_no_function ')'                         // GCC, type alignment
+        | ALIGNOF '(' type_no_function ')'                              // GCC, type alignment
                 { $$ = new ExpressionNode( build_alignOftype( $3 ) ); }
         | OFFSETOF '(' type_name_no_function ',' no_attr_identifier ')'
+        | OFFSETOF '(' type_no_function ',' no_attr_identifier ')'
                 { $$ = new ExpressionNode( build_offsetOf( $3, build_varref( $5 ) ) ); }
         | ATTR_IDENTIFIER
 …
         | ATTR_IDENTIFIER '(' argument_expression ')'
                 { $$ = new ExpressionNode( build_attrexpr( build_varref( $1 ), $3 ) ); }
         | ATTR_IDENTIFIER '(' type_name ')'
+        | ATTR_IDENTIFIER '(' type ')'
                 { $$ = new ExpressionNode( build_attrtype( build_varref( $1 ), $3 ) ); }
 //      | ANDAND IDENTIFIER                                                                     // GCC, address of label
 //              { $$ = new ExpressionNode( new OperatorNode( OperKinds::LabelAddress ), new ExpressionNode( build_varref( $2, true ) ); }
+//              { $$ = new ExpressionNode( new OperatorNode( OperKinds::LabelAddress ), new ExpressionNode( build_varref( $2 ) ); }
+        ;
 …
 cast_expression:
         unary_expression
         | '(' type_name_no_function ')' cast_expression
+        | '(' type_no_function ')' cast_expression
                 { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
 //      | '(' type_name_no_function ')' tuple
+//      | '(' type_no_function ')' tuple
 //              { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
+        ;
 …
         | logical_OR_expression '?' /* empty */ ':' conditional_expression // GCC, omitted first operand
                 { $$ = new ExpressionNode( build_cond( $1, $1, $4 ) ); }
-//      | logical_OR_expression '?' comma_expression ':' tuple // CFA, tuple expression
-//              { $$ = new ExpressionNode( build_cond( $1, $3, $5 ) ); }
+        ;
 …
         | unary_expression assignment_operator assignment_expression
                 { $$ = new ExpressionNode( build_binary_ptr( $2, $1, $3 ) ); }
-//      | tuple assignment_opt                                                          // CFA, tuple expression
-//              { $$ = ( $2 == 0 ) ? $1 : new ExpressionNode( build_binary_ptr( OperKinds::Assign, $1, $2 ) ); }
+        ;
 …
                 { $$ = new StatementNode( build_throw( $2 ) ); }
         | THROWRESUME assignment_expression_opt ';'                     // handles reresume
                 { $$ = new StatementNode( build_throw( $2 ) ); }
+                { $$ = new StatementNode( build_resume( $2 ) ); }
         | THROWRESUME assignment_expression_opt AT assignment_expression ';' // handles reresume
                 { $$ = new StatementNode( build_throw( $2 ) ); }
+                { $$ = new StatementNode( build_resume_at( $2, $4 ) ); }
+        ;
 exception_statement:
         TRY compound_statement handler_list
+        TRY compound_statement handler_clause
                 { $$ = new StatementNode( build_try( $2, $3, 0 ) ); }
         | TRY compound_statement finally_clause
                 { $$ = new StatementNode( build_try( $2, 0, $3 ) ); }
         | TRY compound_statement handler_list finally_clause
+        | TRY compound_statement handler_clause finally_clause
                 { $$ = new StatementNode( build_try( $2, $3, $4 ) ); }
+        ;
 handler_list:
         handler_clause
                 // ISO/IEC 9899:1999 Section 15.3(6 ) If present, a "..." handler shall be the last handler for its try block.
         | CATCH '(' ELLIPSIS ')' compound_statement
                 { $$ = new StatementNode( build_catch( 0, $5, true ) ); }
         | handler_clause CATCH '(' ELLIPSIS ')' compound_statement
                 { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( 0, $6, true ) ) ); }
         | CATCHRESUME '(' ELLIPSIS ')' compound_statement
                 { $$ = new StatementNode( build_catch( 0, $5, true ) ); }
         | handler_clause CATCHRESUME '(' ELLIPSIS ')' compound_statement
                 { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( 0, $6, true ) ) ); }
+        ;
+//handler_list:
+//      handler_clause
+//              // ISO/IEC 9899:1999 Section 15.3(6 ) If present, a "..." handler shall be the last handler for its try block.
+//      | CATCH '(' ELLIPSIS ')' compound_statement
+//              { $$ = new StatementNode( build_catch( 0, $5, true ) ); }
+//      | handler_clause CATCH '(' ELLIPSIS ')' compound_statement
+//              { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( 0, $6, true ) ) ); }
+//      | CATCHRESUME '(' ELLIPSIS ')' compound_statement
+//              { $$ = new StatementNode( build_catch( 0, $5, true ) ); }
+//      | handler_clause CATCHRESUME '(' ELLIPSIS ')' compound_statement
+//              { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( 0, $6, true ) ) ); }
+//      ;
 handler_clause:
+        CATCH '(' push push exception_declaration pop ')' compound_statement pop
+                { $$ = new StatementNode( build_catch( $5, $8 ) ); }
+        // TEMPORARY, TEST EXCEPTIONS
+        CATCH '(' push push INTEGERconstant pop ')' compound_statement pop
+                { $$ = new StatementNode( build_catch( CatchStmt::Terminate, nullptr, new ExpressionNode( build_constantInteger( *$5 ) ), $8 ) ); }
+        | handler_clause CATCH '(' push push INTEGERconstant pop ')' compound_statement pop
+                { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( CatchStmt::Terminate, nullptr, new ExpressionNode( build_constantInteger( *$6 ) ), $9 ) ) ); }
+        | CATCH '(' push push exception_declaration pop ')' compound_statement pop
+                { $$ = new StatementNode( build_catch( CatchStmt::Terminate, $5, nullptr, $8 ) ); }
         | handler_clause CATCH '(' push push exception_declaration pop ')' compound_statement pop
                 { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( $6, $9 ) ) ); }
+                { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( CatchStmt::Terminate, $6, nullptr, $9 ) ) ); }
         | CATCHRESUME '(' push push exception_declaration pop ')' compound_statement pop
                 { $$ = new StatementNode( build_catch( $5, $8 ) ); }
+                { $$ = new StatementNode( build_catch( CatchStmt::Resume, $5, nullptr, $8 ) ); }
         | handler_clause CATCHRESUME '(' push push exception_declaration pop ')' compound_statement pop
                 { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( $6, $9 ) ) ); }
+                { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( CatchStmt::Resume, $6, nullptr, $9 ) ) ); }
+        ;
 …
         basic_declaration_specifier
         | sue_declaration_specifier
+        | typedef_declaration_specifier
+        | typegen_declaration_specifier
+        | type_declaration_specifier
+        ;
 …
         basic_declaration_specifier
         | sue_declaration_specifier_nobody
+        | typedef_declaration_specifier
+        | typegen_declaration_specifier
+        | type_declaration_specifier
+        ;
 …
         basic_type_specifier
         | sue_type_specifier
+        | typedef_type_specifier
+        | typegen_type_specifier
+        | type_type_specifier
+        ;
 …
         basic_type_specifier
         | sue_type_specifier_nobody
+        | typedef_type_specifier
+        | typegen_type_specifier
+        | type_type_specifier
+        ;
 …
 basic_type_specifier:
         direct_type_name
         | type_qualifier_list_opt indirect_type_name type_qualifier_list_opt
+        direct_type
+        | type_qualifier_list_opt indirect_type type_qualifier_list_opt
                 { $$ = $2->addQualifiers( $1 )->addQualifiers( $3 ); }
+        ;
 direct_type_name:
+direct_type:
                 // A semantic check is necessary for conflicting type qualifiers.
         basic_type_name
         | type_qualifier_list basic_type_name
                 { $$ = $2->addQualifiers( $1 ); }
         | direct_type_name type_qualifier
+        | direct_type type_qualifier
                 { $$ = $1->addQualifiers( $2 ); }
         | direct_type_name basic_type_name
+        | direct_type basic_type_name
                 { $$ = $1->addType( $2 ); }
+        ;
 indirect_type_name:
         TYPEOF '(' type_name ')'                                                        // GCC: typeof(x) y;
+indirect_type:
+        TYPEOF '(' type ')'                                                                     // GCC: typeof(x) y;
                 { $$ = $3; }
         | TYPEOF '(' comma_expression ')'                                       // GCC: typeof(a+b) y;
                 { $$ = DeclarationNode::newTypeof( $3 ); }
         | ATTR_TYPEGENname '(' type_name ')'                            // CFA: e.g., @type(x) y;
+        | ATTR_TYPEGENname '(' type ')'                                         // CFA: e.g., @type(x) y;
                 { $$ = DeclarationNode::newAttr( $1, $3 ); }
         | ATTR_TYPEGENname '(' comma_expression ')'                     // CFA: e.g., @type(a+b) y;
 …
 sue_type_specifier:                                                                             // struct, union, enum + type specifier
         elaborated_type
+        | type_qualifier_list elaborated_type
+                { $$ = $2->addQualifiers( $1 ); }
+        | type_qualifier_list
+                { if ( $1->type != nullptr && $1->type->forall ) forall = true; } // remember generic type
+          elaborated_type
+                { $$ = $3->addQualifiers( $1 ); }
         | sue_type_specifier type_qualifier
                 { $$ = $1->addQualifiers( $2 ); }
 …
+        ;
 typedef_declaration_specifier:
         typedef_type_specifier
         | declaration_qualifier_list typedef_type_specifier
+type_declaration_specifier:
+        type_type_specifier
+        | declaration_qualifier_list type_type_specifier
                 { $$ = $2->addQualifiers( $1 ); }
         | typedef_declaration_specifier storage_class           // remaining OBSOLESCENT (see 2)
+        | type_declaration_specifier storage_class                      // remaining OBSOLESCENT (see 2)
                 { $$ = $1->addQualifiers( $2 ); }
         | typedef_declaration_specifier storage_class type_qualifier_list
+        | type_declaration_specifier storage_class type_qualifier_list
                 { $$ = $1->addQualifiers( $2 )->addQualifiers( $3 ); }
+        ;
+typedef_type_specifier:                                                                 // typedef types
+type_type_specifier:                                                                    // typedef types
+        type_name
+        | type_qualifier_list type_name
+                { $$ = $2->addQualifiers( $1 ); }
+        | type_type_specifier type_qualifier
+                { $$ = $1->addQualifiers( $2 ); }
+        ;
+type_name:
         TYPEDEFname
                 { $$ = DeclarationNode::newFromTypedef( $1 ); }
+        | type_qualifier_list TYPEDEFname
+                { $$ = DeclarationNode::newFromTypedef( $2 )->addQualifiers( $1 ); }
+        | typedef_type_specifier type_qualifier
+                { $$ = $1->addQualifiers( $2 ); }
+        | '.' TYPEDEFname
+                { $$ = DeclarationNode::newFromTypedef( $2 ); } // FIX ME
+        | type_name '.' TYPEDEFname
+                { $$ = DeclarationNode::newFromTypedef( $3 ); } // FIX ME
+        | typegen_name
+        | '.' typegen_name
+                { $$ = $2; }                                                                    // FIX ME
+        | type_name '.' typegen_name
+                { $$ = $3; }                                                                    // FIX ME
+        ;
+typegen_name:                                                                                   // CFA
+        TYPEGENname '(' ')'
+                { $$ = DeclarationNode::newFromTypeGen( $1, nullptr ); }
+        | TYPEGENname '(' type_list ')'
+                { $$ = DeclarationNode::newFromTypeGen( $1, $3 ); }
+        ;
 …
                 { $$ = DeclarationNode::newAggregate( $1, new string( DeclarationNode::anonymous.newName() ), nullptr, $4, true )->addQualifiers( $2 ); }
         | aggregate_key attribute_list_opt no_attr_identifier_or_type_name
+                { typedefTable.makeTypedef( *$3 ); }
+                {
+                        typedefTable.makeTypedef( *$3 );                        // create typedef
+                        if ( forall ) typedefTable.changeKind( *$3, TypedefTable::TG ); // possibly update
+                        forall = false;                                                         // reset
+                }
           '{' field_declaration_list '}'
                 { $$ = DeclarationNode::newAggregate( $1, $3, nullptr, $6, true )->addQualifiers( $2 ); }
         | aggregate_key attribute_list_opt '(' type_name_list ')' '{' field_declaration_list '}' // CFA
+        | aggregate_key attribute_list_opt '(' type_list ')' '{' field_declaration_list '}' // CFA
                 { $$ = DeclarationNode::newAggregate( $1, new string( DeclarationNode::anonymous.newName() ), $4, $7, false )->addQualifiers( $2 ); }
         | aggregate_type_nobody
 …
 aggregate_type_nobody:                                                                  // struct, union - {...}
         aggregate_key attribute_list_opt no_attr_identifier_or_type_name
+        aggregate_key attribute_list_opt no_attr_identifier
+                {
                         typedefTable.makeTypedef( *$3 );
                         $$ = DeclarationNode::newAggregate( $1, $3, nullptr, nullptr, false )->addQualifiers( $2 );
+                }
+        | aggregate_key attribute_list_opt typegen_name         // CFA, S/R conflict
+        | aggregate_key attribute_list_opt TYPEDEFname
+                {
+                        typedefTable.makeTypedef( *$3 );
+                        $$ = DeclarationNode::newAggregate( $1, $3, nullptr, nullptr, false )->addQualifiers( $2 );
+                }
+        | aggregate_key attribute_list_opt typegen_name         // CFA
                 { $$ = $3->addQualifiers( $2 ); }
+        ;
 …
+        ;
-no_01_identifier_or_type_name:
-        no_01_identifier
-        | TYPEDEFname
-        | TYPEGENname
+        ;
 no_attr_identifier_or_type_name:
         no_attr_identifier
 …
+        ;
 type_name_no_function:                                                                  // sizeof, alignof, cast (constructor)
+type_no_function:                                                                               // sizeof, alignof, cast (constructor)
         cfa_abstract_declarator_tuple                                           // CFA
         | type_specifier
 …
+        ;
 type_name:                                                                                              // typeof, assertion
         type_name_no_function
+type:                                                                                                   // typeof, assertion
+        type_no_function
         | cfa_abstract_function                                                         // CFA
+        ;
 …
 designation:
         designator_list ':'                                                                     // C99, CFA uses ":" instead of "="
         | no_attr_identifier_or_type_name ':'                           // GCC, field name
+        | no_attr_identifier ':'                                                        // GCC, field name
                 { $$ = new ExpressionNode( build_varref( $1 ) ); }
+        ;
 …
 designator:
         '.' no_attr_identifier_or_type_name                                     // C99, field name
+        '.' no_attr_identifier                                                          // C99, field name
                 { $$ = new ExpressionNode( build_varref( $2 ) ); }
         | '[' push assignment_expression pop ']'                        // C99, single array element
 …
 //     on type arguments of polymorphic functions.
-typegen_declaration_specifier:                                                  // CFA
-        typegen_type_specifier
-        | declaration_qualifier_list typegen_type_specifier
-                { $$ = $2->addQualifiers( $1 ); }
-        | typegen_declaration_specifier storage_class           // remaining OBSOLESCENT (see 2)
-                { $$ = $1->addQualifiers( $2 ); }
-        | typegen_declaration_specifier storage_class type_qualifier_list
-                { $$ = $1->addQualifiers( $2 )->addQualifiers( $3 ); }
+        ;
-typegen_type_specifier:                                                                 // CFA
-        typegen_name
-        | type_qualifier_list typegen_name
-                { $$ = $2->addQualifiers( $1 ); }
-        | typegen_type_specifier type_qualifier
-                { $$ = $1->addQualifiers( $2 ); }
+        ;
-typegen_name:                                                                                   // CFA
-        TYPEGENname '(' type_name_list ')'
-                { $$ = DeclarationNode::newFromTypeGen( $1, $3 ); }
+        ;
 type_parameter_list:                                                                    // CFA
+        type_parameter assignment_opt
+        | type_parameter_list ',' type_parameter assignment_opt
+        type_parameter
+                { $$ = $1; }
+        | type_parameter_list ',' type_parameter
                 { $$ = $1->appendList( $3 ); }
+        ;
+type_initializer_opt:                                                                   // CFA
+        // empty
+                { $$ = nullptr; }
+        | '=' type
+                { $$ = $2; }
+        ;
 …
         type_class no_attr_identifier_or_type_name
                 { typedefTable.addToEnclosingScope( *$2, TypedefTable::TD ); }
           assertion_list_opt
                 { $$ = DeclarationNode::newTypeParam( $1, $2 )->addAssertions( $4 ); }
+          type_initializer_opt assertion_list_opt
+                { $$ = DeclarationNode::newTypeParam( $1, $2 )->addTypeInitializer( $4 )->addAssertions( $5 ); }
         | type_specifier identifier_parameter_declarator
+        ;
 …
 assertion:                                                                                              // CFA
         '|' no_attr_identifier_or_type_name '(' type_name_list ')'
+        '|' no_attr_identifier_or_type_name '(' type_list ')'
+                {
                         typedefTable.openTrait( *$2 );
 …
         | '|' '{' push trait_declaration_list '}'
                 { $$ = $4; }
         | '|' '(' push type_parameter_list pop ')' '{' push trait_declaration_list '}' '(' type_name_list ')'
+        | '|' '(' push type_parameter_list pop ')' '{' push trait_declaration_list '}' '(' type_list ')'
                 { $$ = nullptr; }
+        ;
 type_name_list:                                                                                 // CFA
         type_name
+type_list:                                                                                              // CFA
+        type
                 { $$ = new ExpressionNode( build_typevalue( $1 ) ); }
         | assignment_expression
         | type_name_list ',' type_name
+        | type_list ',' type
                 { $$ = (ExpressionNode *)( $1->set_last( new ExpressionNode( build_typevalue( $3 ) ) ) ); }
         | type_name_list ',' assignment_expression
+        | type_list ',' assignment_expression
                 { $$ = (ExpressionNode *)( $1->set_last( $3 )); }
+        ;
 …
         type_declarator_name assertion_list_opt
                 { $$ = $1->addAssertions( $2 ); }
         | type_declarator_name assertion_list_opt '=' type_name
+        | type_declarator_name assertion_list_opt '=' type
                 { $$ = $1->addAssertions( $2 )->addType( $4 ); }
+        ;
 …
                         $$ = DeclarationNode::newTypeDecl( $1, 0 );
+                }
         | no_01_identifier_or_type_name '(' push type_parameter_list pop ')'
+        | no_attr_identifier_or_type_name '(' push type_parameter_list pop ')'
+                {
                         typedefTable.addToEnclosingScope( *$1, TypedefTable::TG );
 …
+        ;
 trait_declaration_list:                                                         // CFA
+trait_declaration_list:                                                                 // CFA
         trait_declaration
         | trait_declaration_list push trait_declaration
 …
+        ;
 trait_declaration:                                                                      // CFA
+trait_declaration:                                                                              // CFA
         cfa_trait_declaring_list pop ';'
         | trait_declaring_list pop ';'

src/Parser/parserutility.cc

-              r9c951e3
+              rb1e63ac5
 // file "LICENCE" distributed with Cforall.
 //
 // parseutility.cc --
+// parserutility.cc --
 //
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 15:30:39 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Aug 14 23:45:03 2016
 // Update Count     : 3
+// Last Modified On : Wed Jun 28 22:11:32 2017
+// Update Count     : 7
 //
 #include "parseutility.h"
+#include "parserutility.h"
 #include "SynTree/Type.h"
 #include "SynTree/Expression.h"
 …
         UntypedExpr *comparison = new UntypedExpr( new NameExpr( "?!=?" ) );
         comparison->get_args().push_back( orig );
         comparison->get_args().push_back( new ConstantExpr( Constant( new ZeroType( emptyQualifiers ), "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

-              r9c951e3
+              rb1e63ac5
 // file "LICENCE" distributed with Cforall.
 //
 // parseutility.h --
+// parserutility.h --
 //
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 15:31:46 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat May 16 15:32:58 2015
 // Update Count     : 2
+// Last Modified On : Wed Jun 28 22:11:40 2017
+// Update Count     : 3
 //

src/ResolvExpr/AlternativeFinder.cc

-              r9c951e3
+              rb1e63ac5
                 /// Prunes a list of alternatives down to those that have the minimum conversion cost for a given return type; skips ambiguous interpretations
                 template< typename InputIterator, typename OutputIterator >
                 void pruneAlternatives( InputIterator begin, InputIterator end, OutputIterator out, const SymTab::Indexer &indexer ) {
+                void pruneAlternatives( InputIterator begin, InputIterator end, OutputIterator out ) {
                         // select the alternatives that have the minimum conversion cost for a particular set of result types
                         std::map< std::string, PruneStruct > selected;
 …
+                        )
                         AltList::iterator oldBegin = alternatives.begin();
                         pruneAlternatives( alternatives.begin(), alternatives.end(), front_inserter( alternatives ), indexer );
+                        pruneAlternatives( alternatives.begin(), alternatives.end(), front_inserter( alternatives ) );
                         if ( alternatives.begin() == oldBegin ) {
                                 std::ostringstream stream;
 …
 //          )
                 SymTab::Indexer decls( indexer );
                 PRINT(
                         std::cerr << "============= original indexer" << std::endl;
                         indexer.print( std::cerr );
                         std::cerr << "============= new indexer" << std::endl;
                         decls.print( std::cerr );
+                )
+                // PRINT(
+                //      std::cerr << "============= original indexer" << std::endl;
+                //      indexer.print( std::cerr );
+                //      std::cerr << "============= new indexer" << std::endl;
+                //      decls.print( std::cerr );
+                // )
                 addToIndexer( have, decls );
                 AssertionSet newNeed;
 …
                 TypeEnvironment resultEnv;
                 makeUnifiableVars( funcType, openVars, resultNeed );
+                resultEnv.add( funcType->get_forall() ); // add all type variables as open variables now so that those not used in the parameter list are still considered open
                 AltList instantiatedActuals; // filled by instantiate function
                 if ( targetType && ! targetType->isVoid() && ! funcType->get_returnVals().empty() ) {
 …
+        }
+        Expression * restructureCast( Expression * argExpr, Type * toType ) {
+                if ( argExpr->get_result()->size() > 1 && ! toType->isVoid() ) {
+                        // Argument expression is a tuple and the target type is not void. Cast each member of the tuple
+                        // to its corresponding target type, producing the tuple of those cast expressions. If there are
+                        // more components of the tuple than components in the target type, then excess components do not
+                        // come out in the result expression (but UniqueExprs ensure that side effects will still be done).
+                        if ( Tuples::maybeImpure( argExpr ) && ! dynamic_cast< UniqueExpr * >( argExpr ) ) {
+                                // expressions which may contain side effects require a single unique instance of the expression.
+                                argExpr = new UniqueExpr( argExpr );
+                        }
+                        std::list< Expression * > componentExprs;
+                        for ( unsigned int i = 0; i < toType->size(); i++ ) {
+                                // cast each component
+                                TupleIndexExpr * idx = new TupleIndexExpr( argExpr->clone(), i );
+                                componentExprs.push_back( restructureCast( idx, toType->getComponent( i ) ) );
+                        }
+                        delete argExpr;
+                        assert( componentExprs.size() > 0 );
+                        // produce the tuple of casts
+                        return new TupleExpr( componentExprs );
+                } else {
+                        // handle normally
+                        return new CastExpr( argExpr, toType->clone() );
+                }
+        }
         void AlternativeFinder::visit( CastExpr *castExpr ) {
                 Type *& toType = castExpr->get_result();
 …
                                 thisCost += Cost( 0, 0, discardedValues );
+                                Expression * argExpr = i->expr->clone();
+                                if ( argExpr->get_result()->size() > 1 && ! castExpr->get_result()->isVoid() ) {
+                                        // Argument expression is a tuple and the target type is not void. Cast each member of the tuple
+                                        // to its corresponding target type, producing the tuple of those cast expressions. If there are
+                                        // more components of the tuple than components in the target type, then excess components do not
+                                        // come out in the result expression (but UniqueExprs ensure that side effects will still be done).
+                                        if ( Tuples::maybeImpure( argExpr ) && ! dynamic_cast< UniqueExpr * >( argExpr ) ) {
+                                                // expressions which may contain side effects require a single unique instance of the expression.
+                                                argExpr = new UniqueExpr( argExpr );
+                                        }
+                                        std::list< Expression * > componentExprs;
+                                        for ( unsigned int i = 0; i < castExpr->get_result()->size(); i++ ) {
+                                                // cast each component
+                                                TupleIndexExpr * idx = new TupleIndexExpr( argExpr->clone(), i );
+                                                componentExprs.push_back( new CastExpr( idx, castExpr->get_result()->getComponent( i )->clone() ) );
+                                        }
+                                        delete argExpr;
+                                        assert( componentExprs.size() > 0 );
+                                        // produce the tuple of casts
+                                        candidates.push_back( Alternative( new TupleExpr( componentExprs ), i->env, i->cost, thisCost ) );
+                                } else {
+                                        // handle normally
+                                        candidates.push_back( Alternative( new CastExpr( argExpr->clone(), toType->clone() ), i->env, i->cost, thisCost ) );
+                                }
+                                candidates.push_back( Alternative( restructureCast( i->expr->clone(), toType ), i->env, i->cost, thisCost ) );
                         } // if
                 } // for
 …
+        }
+        void AlternativeFinder::visit( UntypedInitExpr *initExpr ) {
+                // handle each option like a cast
+                AltList candidates;
+                PRINT( std::cerr << "untyped init expr: " << initExpr << std::endl; )
+                // O(N^2) checks of d-types with e-types
+                for ( InitAlternative & initAlt : initExpr->get_initAlts() ) {
+                        Type * toType = resolveTypeof( initAlt.type, indexer );
+                        SymTab::validateType( toType, &indexer );
+                        adjustExprType( toType, env, indexer );
+                        // Ideally the call to findWithAdjustment could be moved out of the loop, but unfortunately it currently has to occur inside or else
+                        // polymorphic return types are not properly bound to the initialization type, since return type variables are only open for the duration of resolving
+                        // the UntypedExpr. This is only actually an issue in initialization contexts that allow more than one possible initialization type, but it is still suboptimal.
+                        AlternativeFinder finder( indexer, env );
+                        finder.targetType = toType;
+                        finder.findWithAdjustment( initExpr->get_expr() );
+                        for ( Alternative & alt : finder.get_alternatives() ) {
+                                TypeEnvironment newEnv( alt.env );
+                                AssertionSet needAssertions, haveAssertions;
+                                OpenVarSet openVars;  // find things in env that don't have a "representative type" and claim those are open vars?
+                                PRINT( std::cerr << "  @ " << toType << " " << initAlt.designation << std::endl; )
+                                // It's possible that a cast can throw away some values in a multiply-valued expression.  (An example is a
+                                // cast-to-void, which casts from one value to zero.)  Figure out the prefix of the subexpression results
+                                // that are cast directly.  The candidate is invalid if it has fewer results than there are types to cast
+                                // to.
+                                int discardedValues = alt.expr->get_result()->size() - toType->size();
+                                if ( discardedValues < 0 ) continue;
+                                // xxx - may need to go into tuple types and extract relevant types and use unifyList. Note that currently, this does not
+                                // allow casting a tuple to an atomic type (e.g. (int)([1, 2, 3]))
+                                // unification run for side-effects
+                                unify( toType, alt.expr->get_result(), newEnv, needAssertions, haveAssertions, openVars, indexer ); // xxx - do some inspecting on this line... why isn't result bound to initAlt.type??
+                                Cost thisCost = castCost( alt.expr->get_result(), toType, indexer, newEnv );
+                                if ( thisCost != Cost::infinity ) {
+                                        // count one safe conversion for each value that is thrown away
+                                        thisCost += Cost( 0, 0, discardedValues );
+                                        candidates.push_back( Alternative( new InitExpr( restructureCast( alt.expr->clone(), toType ), initAlt.designation->clone() ), newEnv, alt.cost, thisCost ) );
+                                }
+                        }
+                }
+                // findMinCost selects the alternatives with the lowest "cost" members, but has the side effect of copying the
+                // cvtCost member to the cost member (since the old cost is now irrelevant).  Thus, calling findMinCost twice
+                // selects first based on argument cost, then on conversion cost.
+                AltList minArgCost;
+                findMinCost( candidates.begin(), candidates.end(), std::back_inserter( minArgCost ) );
+                findMinCost( minArgCost.begin(), minArgCost.end(), std::back_inserter( alternatives ) );
+        }
 } // namespace ResolvExpr

src/ResolvExpr/AlternativeFinder.h

r9c951e3	rb1e63ac5
73	73	virtual void visit( UniqueExpr *unqExpr );
74	74	virtual void visit( StmtExpr *stmtExpr );
	75	virtual void visit( UntypedInitExpr *initExpr );
75	76	/// Runs a new alternative finder on each element in [begin, end)
76	77	/// and writes each alternative finder to out.

src/ResolvExpr/CastCost.cc

-              r9c951e3
+              rb1e63ac5
 // file "LICENCE" distributed with Cforall.
 //
 // CastCost.cc --
+// CastCost.cc --
 //
 // Author           : Richard C. Bilson
 …
           public:
                 CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env );
                 virtual void visit( BasicType *basicType );
                 virtual void visit( PointerType *pointerType );
 …
                         NamedTypeDecl *namedType;
                         if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) {
+                                return castCost( src, eqvClass.type, indexer, env );
+                                if ( eqvClass.type ) {
+                                        return castCost( src, eqvClass.type, indexer, env );
+                                } else {
+                                        return Cost::infinity;
+                                }
                         } else if ( ( namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) ) {
                                 TypeDecl *type = dynamic_cast< TypeDecl* >( namedType );

src/ResolvExpr/CommonType.cc

-              r9c951e3
+              rb1e63ac5
                 void getCommonWithVoidPointer( PointerType* voidPointer, PointerType* otherPointer );
-                template< typename RefType > void handleRefType( RefType *inst, Type *other );
                 Type *result;
 …
+        }
+        void CommonType::visit( VoidType *voidType ) {
+        }
+        void CommonType::visit( __attribute((unused)) VoidType *voidType ) {}
         void CommonType::visit( BasicType *basicType ) {
 …
         void CommonType::visit( PointerType *pointerType ) {
                 if ( PointerType *otherPointer = dynamic_cast< PointerType* >( type2 ) ) {
                         if ( widenFirst && dynamic_cast< VoidType* >( otherPointer->get_base() ) && ! isFtype(pointerType->get_base(), indexer) ) {
+                        if ( widenFirst && dynamic_cast< VoidType* >( otherPointer->get_base() ) && ! isFtype(pointerType->get_base()) ) {
                                 getCommonWithVoidPointer( otherPointer, pointerType );
                         } else if ( widenSecond && dynamic_cast< VoidType* >( pointerType->get_base() ) && ! isFtype(otherPointer->get_base(), indexer) ) {
+                        } else if ( widenSecond && dynamic_cast< VoidType* >( pointerType->get_base() ) && ! isFtype(otherPointer->get_base()) ) {
                                 getCommonWithVoidPointer( pointerType, otherPointer );
                         } else if ( ( pointerType->get_base()->get_qualifiers() >= otherPointer->get_base()->get_qualifiers() || widenFirst )
 …
+        }
+        void CommonType::visit( ArrayType *arrayType ) {
+        }
+        void CommonType::visit( FunctionType *functionType ) {
+        }
+        template< typename RefType > void CommonType::handleRefType( RefType *inst, Type *other ) {
+        }
+        void CommonType::visit( StructInstType *aggregateUseType ) {
+        }
+        void CommonType::visit( UnionInstType *aggregateUseType ) {
+        }
+        void CommonType::visit( __attribute((unused)) ArrayType *arrayType ) {}
+        void CommonType::visit( __attribute((unused)) FunctionType *functionType ) {}
+        void CommonType::visit( __attribute((unused)) StructInstType *aggregateUseType ) {}
+        void CommonType::visit( __attribute((unused)) UnionInstType *aggregateUseType ) {}
         void CommonType::visit( EnumInstType *enumInstType ) {
 …
+        }
         void CommonType::visit( TraitInstType *aggregateUseType ) {
+        void CommonType::visit( __attribute((unused)) TraitInstType *aggregateUseType ) {
+        }
 …
+        }
+        void CommonType::visit( TupleType *tupleType ) {
+        }
+        void CommonType::visit( VarArgsType *varArgsType ) {
+        }
+        void CommonType::visit( __attribute((unused)) TupleType *tupleType ) {}
+        void CommonType::visit( __attribute((unused)) VarArgsType *varArgsType ) {}
         void CommonType::visit( ZeroType *zeroType ) {

src/ResolvExpr/ConversionCost.cc

-              r9c951e3
+              rb1e63ac5
 ///     std::cout << "type inst " << destAsTypeInst->get_name();
                         if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) {
+                                return conversionCost( src, eqvClass.type, indexer, env );
+                                if ( eqvClass.type ) {
+                                        return conversionCost( src, eqvClass.type, indexer, env );
+                                } else {
+                                        return Cost::infinity;
+                                }
                         } else if ( ( namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) ) {
 ///       std::cout << " found" << std::endl;
 …
         };
         void ConversionCost::visit(VoidType *voidType) {
+        void ConversionCost::visit( __attribute((unused)) VoidType *voidType ) {
                 cost = Cost::infinity;
+        }
 …
+        }
+        void ConversionCost::visit(ArrayType *arrayType) {
+        }
+        void ConversionCost::visit(FunctionType *functionType) {
+        }
+        void ConversionCost::visit(__attribute((unused)) ArrayType *arrayType) {}
+        void ConversionCost::visit(__attribute((unused)) FunctionType *functionType) {}
         void ConversionCost::visit(StructInstType *inst) {
 …
+        }
         void ConversionCost::visit(EnumInstType *inst) {
+        void ConversionCost::visit( __attribute((unused)) EnumInstType *inst ) {
                 static Type::Qualifiers q;
                 static BasicType integer( q, BasicType::SignedInt );
 …
+        }
         void ConversionCost::visit(TraitInstType *inst) {
+        void ConversionCost::visit( __attribute((unused)) TraitInstType *inst) {
+        }
 …
+        }
         void ConversionCost::visit(TupleType *tupleType) {
+        void ConversionCost::visit( __attribute((unused)) TupleType *tupleType) {
                 Cost c;
                 if ( TupleType *destAsTuple = dynamic_cast< TupleType* >( dest ) ) {
 …
+        }
         void ConversionCost::visit(VarArgsType *varArgsType) {
+        void ConversionCost::visit( __attribute((unused)) VarArgsType *varArgsType) {
                 if ( dynamic_cast< VarArgsType* >( dest ) ) {
                         cost = Cost::zero;
 …
+        }
         void ConversionCost::visit(ZeroType *zeroType) {
+        void ConversionCost::visit( __attribute((unused)) ZeroType *zeroType) {
                 if ( dynamic_cast< ZeroType* >( dest ) ) {
                         cost = Cost::zero;
 …
+        }
         void ConversionCost::visit(OneType *oneType) {
+        void ConversionCost::visit( __attribute((unused)) OneType *oneType) {
                 if ( dynamic_cast< OneType* >( dest ) ) {
                         cost = Cost::zero;

src/ResolvExpr/PtrsAssignable.cc

-              r9c951e3
+              rb1e63ac5
+        }
+        PtrsAssignable::PtrsAssignable( Type *dest, const TypeEnvironment &env ) : dest( dest ), result( 0 ), env( env ) {
+        }
+        PtrsAssignable::PtrsAssignable( Type *dest, const TypeEnvironment &env ) : dest( dest ), result( 0 ), env( env ) {}
         void PtrsAssignable::visit( VoidType *voidType ) {
+        void PtrsAssignable::visit( __attribute((unused)) VoidType *voidType ) {
                 if ( dynamic_cast< FunctionType* >( dest ) ) {
                         result = 0;
 …
+        }
+        void PtrsAssignable::visit( BasicType *basicType ) {
+        }
+        void PtrsAssignable::visit( PointerType *pointerType ) {
+        }
+        void PtrsAssignable::visit( ArrayType *arrayType ) {
+        }
+        void PtrsAssignable::visit( FunctionType *functionType ) {
+        void PtrsAssignable::visit( __attribute__((unused)) BasicType *basicType ) {}
+        void PtrsAssignable::visit( __attribute__((unused)) PointerType *pointerType ) {}
+        void PtrsAssignable::visit( __attribute__((unused)) ArrayType *arrayType ) {}
+        void PtrsAssignable::visit( __attribute__((unused)) FunctionType *functionType ) {
                 result = -1;
+        }
+        void PtrsAssignable::visit( StructInstType *inst ) {
+                // I don't think we should be doing anything here, but I'm willing to admit that I might be wrong
+        }
+        void PtrsAssignable::visit( UnionInstType *inst ) {
+                // I don't think we should be doing anything here, but I'm willing to admit that I might be wrong
+        }
+        void PtrsAssignable::visit(  __attribute__((unused)) StructInstType *inst ) {}
+        void PtrsAssignable::visit(  __attribute__((unused)) UnionInstType *inst ) {}
         void PtrsAssignable::visit( EnumInstType *inst ) {
 …
+        }
+        void PtrsAssignable::visit( TraitInstType *inst ) {
+                // I definitely don't think we should be doing anything here
+        }
+        void PtrsAssignable::visit(  __attribute__((unused)) TraitInstType *inst ) {}
         void PtrsAssignable::visit( TypeInstType *inst ) {
                 EqvClass eqvClass;
 …
+        }
+        void PtrsAssignable::visit( TupleType *tupleType ) {
+///  // This code doesn't belong here, but it might be useful somewhere else
+///   if ( TupleType *destAsTuple = dynamic_cast< TupleType* >( dest ) ) {
+///     int ret = 0;
+///     std::list< Type* >::const_iterator srcIt = tupleType->get_types().begin();
+///     std::list< Type* >::const_iterator destIt = destAsTuple->get_types().begin();
+///     while ( srcIt != tupleType->get_types().end() && destIt != destAsTuple->get_types().end() ) {
+///       int assignResult = ptrsAssignable( *srcIt++, *destIt++ );
+///       if ( assignResult == 0 ) {
+///         result = assignResult;
+///         return;
+///       } else if ( assignResult < 0 ) {
+///         ret = -1;
+///       } else if ( ret > 0 ) {
+///         ret += assignResult;
+///       }
+///     }
+///     if ( srcIt == tupleType->get_types().end() && destIt == destAsTuple->get_types().end() ) {
+///       result = ret;
+///     } else {
+///       result = 0;
+///     }
+///   }
+        }
+        void PtrsAssignable::visit( VarArgsType *varArgsType ) {
+        }
+        void PtrsAssignable::visit( ZeroType *zeroType ) {
+        }
+        void PtrsAssignable::visit( OneType *oneType ) {
+        }
+        void PtrsAssignable::visit(  __attribute__((unused)) TupleType *tupleType ) {}
+        void PtrsAssignable::visit(  __attribute__((unused)) VarArgsType *varArgsType ) {}
+        void PtrsAssignable::visit(  __attribute__((unused)) ZeroType *zeroType ) {}
+        void PtrsAssignable::visit(  __attribute__((unused)) OneType *oneType ) {}
 } // namespace ResolvExpr

src/ResolvExpr/PtrsCastable.cc

r9c951e3	rb1e63ac5
92	92	}
93	93
94		void PtrsCastable::visit(VoidType *voidType) {
	94	void PtrsCastable::visit( __attribute__((unused)) VoidType *voidType) {
95	95	result = objectCast( dest, env, indexer );
96	96	}
97	97
98		void PtrsCastable::visit(BasicType *basicType) {
	98	void PtrsCastable::visit( __attribute__((unused)) BasicType *basicType) {
99	99	result = objectCast( dest, env, indexer );
100	100	}
101	101
102		void PtrsCastable::visit(PointerType *pointerType) {
	102	void PtrsCastable::visit( __attribute__((unused)) PointerType *pointerType) {
103	103	result = objectCast( dest, env, indexer );
104	104	}
105	105
106		void PtrsCastable::visit(ArrayType *arrayType) {
	106	void PtrsCastable::visit( __attribute__((unused)) ArrayType *arrayType) {
107	107	result = objectCast( dest, env, indexer );
108	108	}
109	109
110		void PtrsCastable::visit(FunctionType *functionType) {
	110	void PtrsCastable::visit( __attribute__((unused)) FunctionType *functionType) {
111	111	// result = -1;
112	112	result = functionCast( dest, env, indexer );
113	113	}
114	114
115		void PtrsCastable::visit(StructInstType *inst) {
	115	void PtrsCastable::visit( __attribute__((unused)) StructInstType *inst) {
116	116	result = objectCast( dest, env, indexer );
117	117	}
118	118
119		void PtrsCastable::visit(UnionInstType *inst) {
	119	void PtrsCastable::visit( __attribute__((unused)) UnionInstType *inst) {
120	120	result = objectCast( dest, env, indexer );
121	121	}
122	122
123		void PtrsCastable::visit(EnumInstType *inst) {
	123	void PtrsCastable::visit( __attribute__((unused)) EnumInstType *inst) {
124	124	if ( dynamic_cast< EnumInstType* >( dest ) ) {
125	125	result = 1;
…	…
135	135	}
136	136
137		void PtrsCastable::visit(TraitInstType *inst) {
138		// I definitely don't think we should be doing anything here
139		}
	137	void PtrsCastable::visit( __attribute__((unused)) TraitInstType *inst ) {}
140	138
141	139	void PtrsCastable::visit(TypeInstType *inst) {
…	…
144	142	}
145	143
146		void PtrsCastable::visit(TupleType *tupleType) {
	144	void PtrsCastable::visit( __attribute__((unused)) TupleType *tupleType) {
147	145	result = objectCast( dest, env, indexer );
148	146	}
149	147
150		void PtrsCastable::visit(VarArgsType *varArgsType) {
	148	void PtrsCastable::visit( __attribute__((unused)) VarArgsType *varArgsType) {
151	149	result = objectCast( dest, env, indexer );
152	150	}
153	151
154		void PtrsCastable::visit(ZeroType *zeroType) {
	152	void PtrsCastable::visit( __attribute__((unused)) ZeroType *zeroType) {
155	153	result = objectCast( dest, env, indexer );
156	154	}
157	155
158		void PtrsCastable::visit(OneType *oneType) {
	156	void PtrsCastable::visit( __attribute__((unused)) OneType *oneType) {
159	157	result = objectCast( dest, env, indexer );
160	158	}

src/ResolvExpr/Resolver.cc

-              r9c951e3
+              rb1e63ac5
 //
+#include <iostream>
+#include "Alternative.h"
+#include "AlternativeFinder.h"
+#include "CurrentObject.h"
+#include "RenameVars.h"
 #include "Resolver.h"
-#include "AlternativeFinder.h"
-#include "Alternative.h"
-#include "RenameVars.h"
 #include "ResolveTypeof.h"
 #include "typeops.h"
+#include "SynTree/Expression.h"
+#include "SynTree/Initializer.h"
 #include "SynTree/Statement.h"
 #include "SynTree/Type.h"
+#include "SynTree/Expression.h"
 #include "SynTree/Initializer.h"
+#include "SymTab/Autogen.h"
 #include "SymTab/Indexer.h"
+#include "SymTab/Autogen.h"
 #include "Common/utility.h"
 #include "InitTweak/InitTweak.h"
-#include <iostream>
 using namespace std;
 …
                         if ( const Resolver * res = dynamic_cast< const Resolver * >( &other ) ) {
                                 functionReturn = res->functionReturn;
                                 initContext = res->initContext;
+                                currentObject = res->currentObject;
                                 inEnumDecl = res->inEnumDecl;
+                        }
 …
                 Type * functionReturn = nullptr;
                 Type *initContext = nullptr;
+                CurrentObject currentObject = nullptr;
                 bool inEnumDecl = false;
         };
 …
                         } // if
 #endif
                         assert( finder.get_alternatives().size() == 1 );
+                        assertf( finder.get_alternatives().size() == 1, "findSingleExpression: must have exactly one alternative at the end." );
                         Alternative &choice = finder.get_alternatives().front();
                         Expression *newExpr = choice.expr->clone();
 …
                 // each value of initContext is retained, so the type on the first analysis is preserved and used for selecting
                 // the RHS.
                 Type *temp = initContext;
                 initContext = new_type;
                 if ( inEnumDecl && dynamic_cast< EnumInstType * >( initContext ) ) {
+                ValueGuard<CurrentObject> temp( currentObject );
+                currentObject = CurrentObject( objectDecl->get_type() );
+                if ( inEnumDecl && dynamic_cast< EnumInstType * >( objectDecl->get_type() ) ) {
                         // enumerator initializers should not use the enum type to initialize, since
                         // the enum type is still incomplete at this point. Use signed int instead.
                         initContext = new BasicType( Type::Qualifiers(), BasicType::SignedInt );
+                        currentObject = CurrentObject( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
+                }
                 Parent::visit( objectDecl );
                 if ( inEnumDecl && dynamic_cast< EnumInstType * >( initContext ) ) {
+                if ( inEnumDecl && dynamic_cast< EnumInstType * >( objectDecl->get_type() ) ) {
                         // delete newly created signed int type
+                        delete initContext;
+                }
+                initContext = temp;
+                        // delete currentObject.getType();
+                }
+        }
 …
         void Resolver::visit( SwitchStmt *switchStmt ) {
                 ValueGuard< Type * > oldInitContext( initContext );
+                ValueGuard< CurrentObject > oldCurrentObject( currentObject );
                 Expression *newExpr;
                 newExpr = findIntegralExpression( switchStmt->get_condition(), *this );
 …
                 switchStmt->set_condition( newExpr );
                 initContext = newExpr->get_result();
+                currentObject = CurrentObject( newExpr->get_result() );
                 Parent::visit( switchStmt );
+        }
 …
         void Resolver::visit( CaseStmt *caseStmt ) {
                 if ( caseStmt->get_condition() ) {
+                        assert( initContext );
+                        CastExpr * castExpr = new CastExpr( caseStmt->get_condition(), initContext->clone() );
+                        std::list< InitAlternative > initAlts = currentObject.getOptions();
+                        assertf( initAlts.size() == 1, "SwitchStmt did not correctly resolve an integral expression." );
+                        CastExpr * castExpr = new CastExpr( caseStmt->get_condition(), initAlts.front().type->clone() );
                         Expression * newExpr = findSingleExpression( castExpr, *this );
                         castExpr = safe_dynamic_cast< CastExpr * >( newExpr );
 …
         void Resolver::visit( SingleInit *singleInit ) {
+                if ( singleInit->get_value() ) {
+                        // // find all the d's
+                        // std::list<Expression *> &designators = singleInit->get_designators();
+                        // std::list<Type *> types1{ initContext }, types2;
+                        // for ( Expression * expr: designators ) {
+                        //      cerr << expr << endl;
+                        //      if ( NameExpr * nexpr = dynamic_cast<NameExpr *>( expr ) ) {
+                        //              for ( Type * type: types1 ) {
+                        //                      cerr << type << endl;
+                        //                      ReferenceToType * fred = dynamic_cast<ReferenceToType *>(type);
+                        //                      std::list<Declaration *> members;
+                        //                      if ( fred ) {
+                        //                              fred->lookup( nexpr->get_name(), members ); // concatenate identical field name
+                        //                              for ( Declaration * mem: members ) {
+                        //                                      if ( DeclarationWithType * dwt = dynamic_cast<DeclarationWithType *>(mem) ) {
+                        //                                              types2.push_back( dwt->get_type() );
+                        //                                      } // if
+                        //                              } // for
+                        //                      } // if
+                        //              } // for
+                        //              types1 = types2;
+                        //              types2.clear();
+                        //      } // if
+                        // } // for
+                        // // for ( Type * type: types1 ) {
+                        // //   cerr << type << endl;
+                        // // } // for
+                        // // O(N^2) checks of d-types with f-types
+                        // // find the minimum cost
+                        CastExpr *castExpr = new CastExpr( singleInit->get_value(), initContext->clone() );
+                        Expression *newExpr = findSingleExpression( castExpr, *this );
+                        delete castExpr;
+                        singleInit->set_value( newExpr );
+                        // check if initializing type is char[]
+                        if ( ArrayType * at = dynamic_cast< ArrayType * >( initContext ) ) {
+                                if ( isCharType( at->get_base() ) ) {
+                                        // check if the resolved type is char *
+                                        if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_result() ) ) {
+                                                if ( isCharType( pt->get_base() ) ) {
+                                                        // strip cast if we're initializing a char[] with a char *, e.g.  char x[] = "hello";
+                                                        CastExpr *ce = dynamic_cast< CastExpr * >( newExpr );
+                                                        singleInit->set_value( ce->get_arg() );
+                                                        ce->set_arg( NULL );
+                                                        delete ce;
+                                                }
+                // resolve initialization using the possibilities as determined by the currentObject cursor
+                UntypedInitExpr * untyped = new UntypedInitExpr( singleInit->get_value(), currentObject.getOptions() );
+                Expression * newExpr = findSingleExpression( untyped, *this );
+                InitExpr * initExpr = safe_dynamic_cast< InitExpr * >( newExpr );
+                // move cursor to the object that is actually initialized
+                currentObject.setNext( initExpr->get_designation() );
+                // discard InitExpr wrapper and retain relevant pieces
+                newExpr = initExpr->get_expr();
+                newExpr->set_env( initExpr->get_env() );
+                initExpr->set_expr( nullptr );
+                initExpr->set_env( nullptr );
+                delete initExpr;
+                // get the actual object's type (may not exactly match what comes back from the resolver due to conversions)
+                Type * initContext = currentObject.getCurrentType();
+                // check if actual object's type is char[]
+                if ( ArrayType * at = dynamic_cast< ArrayType * >( initContext ) ) {
+                        if ( isCharType( at->get_base() ) ) {
+                                // check if the resolved type is char *
+                                if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_result() ) ) {
+                                        if ( isCharType( pt->get_base() ) ) {
+                                                // strip cast if we're initializing a char[] with a char *, e.g.  char x[] = "hello";
+                                                CastExpr *ce = safe_dynamic_cast< CastExpr * >( newExpr );
+                                                newExpr = ce->get_arg();
+                                                ce->set_arg( nullptr );
+                                                delete ce;
+                                        }
+                                }
+                        }
+                } // if
+        }
+        template< typename AggrInst >
+        TypeSubstitution makeGenericSubstitutuion( AggrInst * inst ) {
+                assert( inst );
+                assert( inst->get_baseParameters() );
+                std::list< TypeDecl * > baseParams = *inst->get_baseParameters();
+                std::list< Expression * > typeSubs = inst->get_parameters();
+                TypeSubstitution subs( baseParams.begin(), baseParams.end(), typeSubs.begin() );
+                return subs;
+        }
+        ReferenceToType * isStructOrUnion( Type * type ) {
+                if ( StructInstType * sit = dynamic_cast< StructInstType * >( type ) ) {
+                        return sit;
+                } else if ( UnionInstType * uit = dynamic_cast< UnionInstType * >( type ) ) {
+                        return uit;
+                }
+                return nullptr;
+        }
+        void Resolver::resolveSingleAggrInit( Declaration * dcl, InitIterator & init, InitIterator & initEnd, TypeSubstitution sub ) {
+                DeclarationWithType * dt = dynamic_cast< DeclarationWithType * >( dcl );
+                assert( dt );
+                // need to substitute for generic types, so that casts are to concrete types
+                initContext = dt->get_type()->clone();
+                sub.apply( initContext );
+                try {
+                        if ( init == initEnd ) return; // stop when there are no more initializers
+                        (*init)->accept( *this );
+                        ++init; // made it past an initializer
+                } catch( SemanticError & ) {
+                        // need to delve deeper, if you can
+                        if ( ReferenceToType * type = isStructOrUnion( initContext ) ) {
+                                resolveAggrInit( type, init, initEnd );
+                        } else {
+                                // member is not an aggregate type, so can't go any deeper
+                                // might need to rethink what is being thrown
+                                throw;
+                        } // if
+                }
+        }
+        void Resolver::resolveAggrInit( ReferenceToType * inst, InitIterator & init, InitIterator & initEnd ) {
+                if ( StructInstType * sit = dynamic_cast< StructInstType * >( inst ) ) {
+                        TypeSubstitution sub = makeGenericSubstitutuion( sit );
+                        StructDecl * st = sit->get_baseStruct();
+                        if(st->get_members().empty()) return;
+                        // want to resolve each initializer to the members of the struct,
+                        // but if there are more initializers than members we should stop
+                        list< Declaration * >::iterator it = st->get_members().begin();
+                        for ( ; it != st->get_members().end(); ++it) {
+                                resolveSingleAggrInit( *it, init, initEnd, sub );
+                        }
+                } else if ( UnionInstType * uit = dynamic_cast< UnionInstType * >( inst ) ) {
+                        TypeSubstitution sub = makeGenericSubstitutuion( uit );
+                        UnionDecl * un = uit->get_baseUnion();
+                        if(un->get_members().empty()) return;
+                        // only resolve to the first member of a union
+                        resolveSingleAggrInit( *un->get_members().begin(), init, initEnd, sub );
+                } // if
+                }
+                // set initializer expr to resolved express
+                singleInit->set_value( newExpr );
+                // move cursor to next object in preparation for next initializer
+                currentObject.increment();
+        }
         void Resolver::visit( ListInit * listInit ) {
+                InitIterator iter = listInit->begin();
+                InitIterator end = listInit->end();
+                if ( ArrayType * at = dynamic_cast< ArrayType * >( initContext ) ) {
+                        // resolve each member to the base type of the array
+                        for ( ; iter != end; ++iter ) {
+                                initContext = at->get_base();
+                                (*iter)->accept( *this );
+                        } // for
+                } else if ( TupleType * tt = dynamic_cast< TupleType * > ( initContext ) ) {
+                        for ( Type * t : *tt ) {
+                                if ( iter == end ) break;
+                                initContext = t;
+                                (*iter++)->accept( *this );
+                        }
+                } else if ( ReferenceToType * type = isStructOrUnion( initContext ) ) {
+                        resolveAggrInit( type, iter, end );
+                } else if ( TypeInstType * tt = dynamic_cast< TypeInstType * >( initContext ) ) {
+                        Type * base = tt->get_baseType()->get_base();
+                        if ( base ) {
+                                // know the implementation type, so try using that as the initContext
+                                initContext = base;
+                                visit( listInit );
+                        } else {
+                                // missing implementation type -- might be an unknown type variable, so try proceeding with the current init context
+                                Parent::visit( listInit );
+                        }
+                } else {
+                        assert( dynamic_cast< BasicType * >( initContext ) || dynamic_cast< PointerType * >( initContext )
+                                || dynamic_cast< ZeroType * >( initContext ) || dynamic_cast< OneType * >( initContext ) || dynamic_cast < EnumInstType * > ( initContext ) );
+                        // basic types are handled here
+                        Parent::visit( listInit );
+                }
+#if 0
+                if ( ArrayType *at = dynamic_cast<ArrayType*>(initContext) ) {
+                        std::list<Initializer *>::iterator iter( listInit->begin_initializers() );
+                        for ( ; iter != listInit->end_initializers(); ++iter ) {
+                                initContext = at->get_base();
+                                (*iter)->accept( *this );
+                        } // for
+                } else if ( StructInstType *st = dynamic_cast<StructInstType*>(initContext) ) {
+                        StructDecl *baseStruct = st->get_baseStruct();
+                        std::list<Declaration *>::iterator iter1( baseStruct->get_members().begin() );
+                        std::list<Initializer *>::iterator iter2( listInit->begin_initializers() );
+                        for ( ; iter1 != baseStruct->get_members().end() && iter2 != listInit->end_initializers(); ++iter2 ) {
+                                if ( (*iter2)->get_designators().empty() ) {
+                                        DeclarationWithType *dt = dynamic_cast<DeclarationWithType *>( *iter1 );
+                                        initContext = dt->get_type();
+                                        (*iter2)->accept( *this );
+                                        ++iter1;
+                                } else {
+                                        StructDecl *st = baseStruct;
+                                        iter1 = st->get_members().begin();
+                                        std::list<Expression *>::iterator iter3( (*iter2)->get_designators().begin() );
+                                        for ( ; iter3 != (*iter2)->get_designators().end(); ++iter3 ) {
+                                                NameExpr *key = dynamic_cast<NameExpr *>( *iter3 );
+                                                assert( key );
+                                                for ( ; iter1 != st->get_members().end(); ++iter1 ) {
+                                                        if ( key->get_name() == (*iter1)->get_name() ) {
+                                                                (*iter1)->print( cout );
+                                                                cout << key->get_name() << endl;
+                                                                ObjectDecl *fred = dynamic_cast<ObjectDecl *>( *iter1 );
+                                                                assert( fred );
+                                                                StructInstType *mary = dynamic_cast<StructInstType*>( fred->get_type() );
+                                                                assert( mary );
+                                                                st = mary->get_baseStruct();
+                                                                iter1 = st->get_members().begin();
+                                                                break;
+                                                        } // if
+                                                }  // for
+                                        } // for
+                                        ObjectDecl *fred = dynamic_cast<ObjectDecl *>( *iter1 );
+                                        assert( fred );
+                                        initContext = fred->get_type();
+                                        (*listInit->begin_initializers())->accept( *this );
+                                } // if
+                        } // for
+                } else if ( UnionInstType *st = dynamic_cast<UnionInstType*>(initContext) ) {
+                        DeclarationWithType *dt = dynamic_cast<DeclarationWithType *>( *st->get_baseUnion()->get_members().begin() );
+                        initContext = dt->get_type();
+                        (*listInit->begin_initializers())->accept( *this );
+                } // if
+#endif
+                // move cursor into brace-enclosed initializer-list
+                currentObject.enterListInit();
+                // xxx - fix this so that the list isn't copied, iterator should be used to change current element
+                std::list<Designation *> newDesignations;
+                for ( auto p : group_iterate(listInit->get_designations(), listInit->get_initializers()) ) {
+                        // iterate designations and initializers in pairs, moving the cursor to the current designated object and resolving
+                        // the initializer against that object.
+                        Designation * des = std::get<0>(p);
+                        Initializer * init = std::get<1>(p);
+                        newDesignations.push_back( currentObject.findNext( des ) );
+                        init->accept( *this );
+                }
+                // set the set of 'resolved' designations and leave the brace-enclosed initializer-list
+                listInit->get_designations() = newDesignations; // xxx - memory management
+                currentObject.exitListInit();
+                // xxx - this part has not be folded into CurrentObject yet
+                // } else if ( TypeInstType * tt = dynamic_cast< TypeInstType * >( initContext ) ) {
+                //      Type * base = tt->get_baseType()->get_base();
+                //      if ( base ) {
+                //              // know the implementation type, so try using that as the initContext
+                //              ObjectDecl tmpObj( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, base->clone(), nullptr );
+                //              currentObject = &tmpObj;
+                //              visit( listInit );
+                //      } else {
+                //              // missing implementation type -- might be an unknown type variable, so try proceeding with the current init context
+                //              Parent::visit( listInit );
+                //      }
+                // } else {
+        }

src/ResolvExpr/TypeMap.h

r9c951e3	rb1e63ac5
110	110	}
111	111
112		virtual void visit( VoidType *voidType ) {
	112	virtual void visit( __attribute__((unused)) VoidType *voidType ) {
113	113	findAndReplace( typeMap.voidValue );
114	114	}
…	…
138	138	}
139	139
140		virtual void visit( FunctionType *functionType ) {
	140	virtual void visit( __attribute__((unused)) FunctionType *functionType ) {
141	141	findAndReplace( typeMap.functionPointerValue );
142	142	}

src/ResolvExpr/Unify.cc

-              r9c951e3
+              rb1e63ac5
+        }
         bool isFtype( Type *type, const SymTab::Indexer &indexer ) {
+        bool isFtype( Type *type ) {
                 if ( dynamic_cast< FunctionType* >( type ) ) {
                         return true;
 …
+        }
         bool tyVarCompatible( const TypeDecl::Data & data, Type *type, const SymTab::Indexer &indexer ) {
+        bool tyVarCompatible( const TypeDecl::Data & data, Type *type ) {
                 switch ( data.kind ) {
                   case TypeDecl::Any:
 …
                         // type must also be complete
                         // xxx - should this also check that type is not a tuple type and that it's not a ttype?
                         return ! isFtype( type, indexer ) && (! data.isComplete || type->isComplete() );
+                        return ! isFtype( type ) && (! data.isComplete || type->isComplete() );
                   case TypeDecl::Ftype:
                         return isFtype( type, indexer );
+                        return isFtype( type );
                   case TypeDecl::Ttype:
                         // ttype unifies with any tuple type
 …
                 OpenVarSet::const_iterator tyvar = openVars.find( typeInst->get_name() );
                 assert( tyvar != openVars.end() );
                 if ( ! tyVarCompatible( tyvar->second, other, indexer ) ) {
+                if ( ! tyVarCompatible( tyvar->second, other ) ) {
                         return false;
                 } // if
 …
                 std::cerr << "unifyInexact type 1 is ";
                 type1->print( std::cerr );
                 std::cerr << "type 2 is ";
+                std::cerr << " type 2 is ";
                 type2->print( std::cerr );
                 std::cerr << std::endl;
 …
+        }
         void Unify::visit(VoidType *voidType) {
+        void Unify::visit( __attribute__((unused)) VoidType *voidType) {
                 result = dynamic_cast< VoidType* >( type2 );
+        }
 …
                         } else if ( tupleParam ) {
                                 // bundle other parameters into tuple to match
                                 TupleType* binder = new TupleType{ paramTy->get_qualifiers() };
+                                std::list< Type * > binderTypes;
                                 do {
                                         binder->get_types().push_back( otherParam->get_type()->clone() );
+                                        binderTypes.push_back( otherParam->get_type()->clone() );
                                         ++jt;
 …
                                 } while (true);
                                 otherParamTy = binder;
+                                otherParamTy = new TupleType{ paramTy->get_qualifiers(), binderTypes };
                                 ++it;  // skip ttype parameter for break
                         } else if ( otherTupleParam ) {
                                 // bundle parameters into tuple to match other
                                 TupleType* binder = new TupleType{ otherParamTy->get_qualifiers() };
+                                std::list< Type * > binderTypes;
                                 do {
                                         binder->get_types().push_back( param->get_type()->clone() );
+                                        binderTypes.push_back( param->get_type()->clone() );
                                         ++it;
 …
                                 } while (true);
                                 paramTy = binder;
+                                paramTy = new TupleType{ otherParamTy->get_qualifiers(), binderTypes };
                                 ++jt;  // skip ttype parameter for break
+                        }
 …
         template< typename Iterator1, typename Iterator2 >
         bool unifyList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
+        bool unifyList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, const SymTab::Indexer &indexer ) {
                 auto get_type = [](Type * t) { return t; };
                 for ( ; list1Begin != list1End && list2Begin != list2End; ++list1Begin, ++list2Begin ) {
 …
                         flatten( flat2.get(), back_inserter( types2 ) );
                         result = unifyList( types1.begin(), types1.end(), types2.begin(), types2.end(), env, needAssertions, haveAssertions, openVars, widenMode, indexer );
                 } // if
+        }
         void Unify::visit(VarArgsType *varArgsType) {
+                        result = unifyList( types1.begin(), types1.end(), types2.begin(), types2.end(), env, needAssertions, haveAssertions, openVars, indexer );
+                } // if
+        }
+        void Unify::visit( __attribute__((unused)) VarArgsType *varArgsType ) {
                 result = dynamic_cast< VarArgsType* >( type2 );
+        }
         void Unify::visit(ZeroType *zeroType) {
+        void Unify::visit( __attribute__((unused)) ZeroType *zeroType ) {
                 result = dynamic_cast< ZeroType* >( type2 );
+        }
         void Unify::visit(OneType *oneType) {
+        void Unify::visit( __attribute__((unused)) OneType *oneType ) {
                 result = dynamic_cast< OneType* >( type2 );
+        }
 …
                         return function->get_returnVals().front()->get_type()->clone();
                 } else {
                         TupleType * tupleType = new TupleType( Type::Qualifiers() );
+                        std::list< Type * > types;
                         for ( DeclarationWithType * decl : function->get_returnVals() ) {
                                 tupleType->get_types().push_back( decl->get_type()->clone() );
+                                types.push_back( decl->get_type()->clone() );
                         } // for
                         return tupleType;
+                        return new TupleType( Type::Qualifiers(), types );
+                }
+        }

src/ResolvExpr/module.mk

-              r9c951e3
+              rb1e63ac5
 ## file "LICENCE" distributed with Cforall.
 ##
 ## module.mk --
+## module.mk --
 ##
 ## Author           : Richard C. Bilson
 …
        ResolvExpr/PolyCost.cc \
        ResolvExpr/Occurs.cc \
+       ResolvExpr/TypeEnvironment.cc
+       ResolvExpr/TypeEnvironment.cc \
+       ResolvExpr/CurrentObject.cc

src/ResolvExpr/typeops.h

-              r9c951e3
+              rb1e63ac5
         // in Unify.cc
         bool isFtype( Type *type, const SymTab::Indexer &indexer );
+        bool isFtype( Type *type );
         bool typesCompatible( Type *, Type *, const SymTab::Indexer &indexer, const TypeEnvironment &env );
         bool typesCompatibleIgnoreQualifiers( Type *, Type *, const SymTab::Indexer &indexer, const TypeEnvironment &env );
 …
                 TypeEnvironment env;
                 return typesCompatibleIgnoreQualifiers( t1, t2, indexer, env );
+        }
-        template< typename Container1, typename Container2 >
-        bool typesCompatibleList( Container1 &c1, Container2 &c2, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
-                typename Container1::iterator i1 = c1.begin();
-                typename Container2::iterator i2 = c2.begin();
-                for ( ; i1 != c1.end() && i2 != c2.end(); ++i1, ++i2 ) {
-                        if ( ! typesCompatible( *i1, *i2, indexer ) ) {
-                                return false;
-                        } // if
+                }
-                return ( i1 == c1.end() ) && ( i2 == c2.end() );
+        }

src/SymTab/Autogen.cc

-              r9c951e3
+              rb1e63ac5
 // Author           : Rob Schluntz
 // Created On       : Thu Mar 03 15:45:56 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Mar 17 09:41:08 2017
 // Update Count     : 60
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Jun 28 15:30:00 2017
+// Update Count     : 61
 //
 …
         // E ?=?(E volatile*, int),
         //   ?=?(E _Atomic volatile*, int);
         void makeEnumFunctions( EnumDecl *enumDecl, EnumInstType *refType, unsigned int functionNesting, std::list< Declaration * > &declsToAdd ) {
+        void makeEnumFunctions( EnumInstType *refType, unsigned int functionNesting, std::list< Declaration * > &declsToAdd ) {
                 // T ?=?(E *, E);
 …
         /// generates struct constructors, destructor, and assignment functions
         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::Builtin ||
+                         aggregateDecl->get_linkage() == LinkageSpec::BuiltinC ) {
+                        return;
+                }
                 // Make function polymorphic in same parameters as generic struct, if applicable
                 const std::list< TypeDecl* > & typeParams = aggregateDecl->get_parameters(); // List of type variables to be placed on the generated functions
 …
         /// generates the body of a union assignment/copy constructor/field constructor
         void makeUnionAssignBody( FunctionDecl * funcDecl, bool isDynamicLayout ) {
+        void makeUnionAssignBody( FunctionDecl * funcDecl ) {
                 FunctionType * ftype = funcDecl->get_functionType();
                 assert( ftype->get_parameters().size() == 2 );
 …
                 // Make function polymorphic in same parameters as generic union, if applicable
                 const std::list< TypeDecl* > & typeParams = aggregateDecl->get_parameters(); // List of type variables to be placed on the generated functions
+                bool isDynamicLayout = hasDynamicLayout( aggregateDecl );  // NOTE this flag is an incredibly ugly kludge; we should fix the assignment signature instead (ditto for struct)
                 // default ctor/dtor need only first parameter
                 // void ?{}(T *); void ^?{}(T *);
 …
                 FunctionDecl *dtorDecl = genFunc( "^?{}", dtorType, functionNesting );
                 makeUnionAssignBody( assignDecl, isDynamicLayout );
+                makeUnionAssignBody( assignDecl );
                 // body of assignment and copy ctor is the same
                 makeUnionAssignBody( copyCtorDecl, isDynamicLayout );
+                makeUnionAssignBody( copyCtorDecl );
                 // create a constructor which takes the first member type as a parameter.
 …
                                 FunctionDecl * ctor = genFunc( "?{}", memCtorType, functionNesting );
                                 makeUnionAssignBody( ctor, isDynamicLayout );
+                                makeUnionAssignBody( ctor );
                                 memCtors.push_back( ctor );
                                 // only generate a ctor for the first field
 …
                         EnumInstType *enumInst = new EnumInstType( Type::Qualifiers(), enumDecl->get_name() );
                         // enumInst->set_baseEnum( enumDecl );
                         makeEnumFunctions( enumDecl, enumInst, functionNesting, declsToAddAfter );
+                        makeEnumFunctions( enumInst, functionNesting, declsToAddAfter );
+                }
+        }

src/SymTab/Autogen.h

-              r9c951e3
+              rb1e63ac5
 // Created On       : Sun May 17 21:53:34 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Mar 17 09:10:41 2017
 // Update Count     : 9
+// Last Modified On : Wed Jun 21 17:25:26 2017
+// Update Count     : 14
 //
 …
         template< typename OutputIterator >
         Statement * genScalarCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast = false ) {
                 // want to be able to generate assignment, ctor, and dtor generically,
                 // so fname is either ?=?, ?{}, or ^?{}
                 UntypedExpr *fExpr = new UntypedExpr( new NameExpr( fname ) );
+        // want to be able to generate assignment, ctor, and dtor generically,
+        // so fname is either ?=?, ?{}, or ^?{}
+        UntypedExpr *fExpr = new UntypedExpr( new NameExpr( fname ) );
+                // do something special for unnamed members
+                dstParam = new AddressExpr( dstParam );
+                if ( addCast ) {
+                        // cast to T* with qualifiers removed, so that qualified objects can be constructed
+                        // and destructed with the same functions as non-qualified objects.
+                        // unfortunately, lvalue is considered a qualifier. For AddressExpr to resolve, its argument
+                        // must have an lvalue qualified type, so remove all qualifiers except lvalue. If we ever
+                        // remove lvalue as a qualifier, this can change to
+                        //   type->get_qualifiers() = Type::Qualifiers();
+                        assert( type );
+                        Type * castType = type->clone();
+//                      castType->get_qualifiers() -= Type::Qualifiers(true, true, true, false, true, false);
+                        castType->get_qualifiers() -= Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
+                        castType->set_lvalue( true ); // xxx - might not need this
+                        dstParam = new CastExpr( dstParam, new PointerType( Type::Qualifiers(), castType ) );
+                }
+                fExpr->get_args().push_back( dstParam );
+        // do something special for unnamed members
+        dstParam = new AddressExpr( dstParam );
+        if ( addCast ) {
+                // cast to T* with qualifiers removed, so that qualified objects can be constructed
+                // and destructed with the same functions as non-qualified objects.
+                // unfortunately, lvalue is considered a qualifier. For AddressExpr to resolve, its argument
+                // must have an lvalue qualified type, so remove all qualifiers except lvalue. If we ever
+                // remove lvalue as a qualifier, this can change to
+                //   type->get_qualifiers() = Type::Qualifiers();
+                assert( type );
+                Type * castType = type->clone();
+                castType->get_qualifiers() -= Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
+                castType->set_lvalue( true ); // xxx - might not need this
+                dstParam = new CastExpr( dstParam, new PointerType( Type::Qualifiers(), castType ) );
+        }
+        fExpr->get_args().push_back( dstParam );
                 Statement * listInit = srcParam.buildListInit( fExpr );
+        Statement * listInit = srcParam.buildListInit( fExpr );
                 std::list< Expression * > args = *++srcParam;
                 fExpr->get_args().splice( fExpr->get_args().end(), args );
+        std::list< Expression * > args = *++srcParam;
+        fExpr->get_args().splice( fExpr->get_args().end(), args );
                 *out++ = new ExprStmt( noLabels, fExpr );
+        *out++ = new ExprStmt( noLabels, fExpr );
                 srcParam.clearArrayIndices();
+        srcParam.clearArrayIndices();
                 return listInit;
+        return listInit;
+        }
 …
                 Expression * begin, * end, * update, * cmp;
                 if ( forward ) {
                         // generate: for ( int i = 0; i < 0; ++i )
                         begin = new ConstantExpr( Constant( new ZeroType( emptyQualifiers ), "0" ) );
+                        // generate: for ( int i = 0; i < N; ++i )
+                        begin = new ConstantExpr( Constant::from_int( 0 ) );
                         end = array->get_dimension()->clone();
                         cmp = new NameExpr( "?<?" );
 …
                         begin = new UntypedExpr( new NameExpr( "?-?" ) );
                         ((UntypedExpr*)begin)->get_args().push_back( array->get_dimension()->clone() );
                         ((UntypedExpr*)begin)->get_args().push_back( new ConstantExpr( Constant( new OneType( emptyQualifiers ), "1" ) ) );
                         end = new ConstantExpr( Constant( new ZeroType( emptyQualifiers ), "0" ) );
+                        ((UntypedExpr*)begin)->get_args().push_back( new ConstantExpr( Constant::from_int( 1 ) ) );
+                        end = new ConstantExpr( Constant::from_int( 0 ) );
                         cmp = new NameExpr( "?>=?" );
                         update = new NameExpr( "--?" );
+                }
                 ObjectDecl *index = new ObjectDecl( indexName.newName(), Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin, std::list<Expression*>() ) );
+                ObjectDecl *index = new ObjectDecl( indexName.newName(), Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin ) );
                 UntypedExpr *cond = new UntypedExpr( cmp );

src/SymTab/FixFunction.cc

-              r9c951e3
+              rb1e63ac5
         DeclarationWithType * FixFunction::mutate(FunctionDecl *functionDecl) {
                 ObjectDecl *pointer = new ObjectDecl( functionDecl->get_name(), functionDecl->get_storageClasses(), functionDecl->get_linkage(), 0, new PointerType( Type::Qualifiers(), functionDecl->get_type()->clone() ), 0, functionDecl->get_attributes() );
+                ObjectDecl *pointer = new ObjectDecl( functionDecl->get_name(), functionDecl->get_storageClasses(), functionDecl->get_linkage(), 0, new PointerType( Type::Qualifiers(), functionDecl->get_type() ), 0, functionDecl->get_attributes() );
                 functionDecl->get_attributes().clear();
+                // can't delete function type because it may contain assertions, but can't transfer ownership without a clone since set_type checks for nullptr
+                functionDecl->set_type( functionDecl->get_type()->clone() );
                 delete functionDecl;
                 return pointer;

src/SymTab/ImplementationType.cc

-              r9c951e3
+              rb1e63ac5
 // file "LICENCE" distributed with Cforall.
 //
 // ImplementationType.cc --
+// ImplementationType.cc --
 //
 // Author           : Richard C. Bilson
 …
+        }
+        void ImplementationType::visit(VoidType *voidType) {
+        }
+        void ImplementationType::visit(BasicType *basicType) {
+        }
+        void ImplementationType::visit( __attribute__((unused)) VoidType *voidType ) {}
+        void ImplementationType::visit( __attribute__((unused)) BasicType *basicType ) {}
         void ImplementationType::visit(PointerType *pointerType) {
 …
+        }
+        void ImplementationType::visit(FunctionType *functionType) {
+///   FunctionType *newType = functionType->clone();
+///   for ( std::list< DeclarationWithType* >::iterator i = newType->get_parameters().begin(); i != newType->get_parameters().end(); ++i ) {
+///     i->set_type( implementationType( i->get_type(), indexer ) );
+///   }
+///   for ( std::list< DeclarationWithType* >::iterator i = newType->get_parameters().begin(); i != newType->get_parameters().end(); ++i ) {
+///     i->set_type( implementationType( i->get_type(), indexer ) );
+///   }
+        }
+        void ImplementationType::visit(StructInstType *aggregateUseType) {
+        }
+        void ImplementationType::visit(UnionInstType *aggregateUseType) {
+        }
+        void ImplementationType::visit(EnumInstType *aggregateUseType) {
+        }
+        void ImplementationType::visit(TraitInstType *aggregateUseType) {
+        }
+        void ImplementationType::visit( __attribute__((unused)) FunctionType *functionType ) {}
+        void ImplementationType::visit( __attribute__((unused)) StructInstType * aggregateUseType ) {}
+        void ImplementationType::visit( __attribute__((unused)) UnionInstType * aggregateUseType ) {}
+        void ImplementationType::visit( __attribute__((unused)) EnumInstType * aggregateUseType ) {}
+        void ImplementationType::visit( __attribute__((unused)) TraitInstType * aggregateUseType ) {}
         void ImplementationType::visit(TypeInstType *inst) {
 …
         void ImplementationType::visit(TupleType *tupleType) {
                 TupleType *newType = new TupleType( Type::Qualifiers() );
+                std::list< Type * > types;
                 for ( std::list< Type* >::iterator i = tupleType->get_types().begin(); i != tupleType->get_types().end(); ++i ) {
                         Type *implType = implementationType( *i, indexer );
                         implType->get_qualifiers() |= tupleType->get_qualifiers();
                         newType->get_types().push_back( implType );
+                        types.push_back( implType );
                 } // for
                 result = newType;
+                result = new TupleType( Type::Qualifiers(), types );
+        }
+        void ImplementationType::visit(VarArgsType *varArgsType) {
+        }
+        void ImplementationType::visit(ZeroType *zeroType) {
+        }
+        void ImplementationType::visit(OneType *oneType) {
+        }
+        void ImplementationType::visit( __attribute__((unused)) VarArgsType *varArgsType ) {}
+        void ImplementationType::visit( __attribute__((unused)) ZeroType *zeroType ) {}
+        void ImplementationType::visit( __attribute__((unused)) OneType *oneType ) {}
 } // namespace SymTab

src/SymTab/Indexer.cc

-              r9c951e3
+              rb1e63ac5
                         };
                         // properties for this type
+                        bool userDefinedFunc = false; // any user-defined function found
+                        bool userDefinedCtor = false; // any user-defined constructor found
+                        bool userDefinedDtor = false; // any user-defined destructor found
+                        bool userDefinedCopyFunc = false; // user-defined copy ctor found
+                        bool existsUserDefinedFunc = false;    // any user-defined function found
+                        bool existsUserDefinedCtor = false;    // any user-defined constructor found
+                        bool existsUserDefinedDtor = false;    // any user-defined destructor found
+                        bool existsUserDefinedCopyFunc = false;    // user-defined copy ctor found
+                        bool existsUserDefinedDefaultCtor = false; // user-defined default ctor found
                         std::list< DeclBall > decls;
 …
                                 bool isCopyFunc = InitTweak::isCopyFunction( function, function->get_name() );
                                 decls.push_back( DeclBall{ function, isUserDefinedFunc, isDefaultCtor, isDtor, isCopyFunc } );
+                                userDefinedFunc = userDefinedFunc || isUserDefinedFunc;
+                                userDefinedCtor = userDefinedCtor || (isUserDefinedFunc && InitTweak::isConstructor( function->get_name() ) );
+                                userDefinedDtor = userDefinedDtor || (isUserDefinedFunc && isDtor);
+                                userDefinedCopyFunc = userDefinedCopyFunc || (isUserDefinedFunc && isCopyFunc);
+                                existsUserDefinedFunc = existsUserDefinedFunc || isUserDefinedFunc;
+                                existsUserDefinedCtor = existsUserDefinedCtor || (isUserDefinedFunc && InitTweak::isConstructor( function->get_name() ) );
+                                existsUserDefinedDtor = existsUserDefinedDtor || (isUserDefinedFunc && isDtor);
+                                existsUserDefinedCopyFunc = existsUserDefinedCopyFunc || (isUserDefinedFunc && isCopyFunc);
+                                existsUserDefinedDefaultCtor = existsUserDefinedDefaultCtor || (isUserDefinedFunc && isDefaultCtor);
                                 return *this;
+                        }
 …
+                }
                 // if a type contains user defined ctor/dtors, then special rules trigger, which determine
                 // the set of ctor/dtors that are seen by the requester. In particular, if the user defines
+                // if a type contains user defined ctor/dtor/assign, then special rules trigger, which determine
+                // the set of ctor/dtor/assign that are seen by the requester. In particular, if the user defines
                 // a default ctor, then the generated default ctor should never be seen, likewise for copy ctor
                 // and dtor. If the user defines any ctor/dtor, then no generated field ctors should be seen.
+                // If the user defines any ctor then the generated default ctor should not be seen.
+                // If the user defines any ctor then the generated default ctor should not be seen (intrinsic default
+                // ctor must be overridden exactly).
                 for ( std::pair< const std::string, ValueType > & pair : funcMap ) {
                         ValueType & val = pair.second;
                         for ( ValueType::DeclBall ball : val.decls ) {
+                                if ( ! val.userDefinedFunc || ball.isUserDefinedFunc || (! val.userDefinedCtor && ball.isDefaultCtor) || (! val.userDefinedCopyFunc && ball.isCopyFunc) || (! val.userDefinedDtor && ball.isDtor) ) {
+                                bool noUserDefinedFunc = ! val.existsUserDefinedFunc;
+                                bool isUserDefinedFunc = ball.isUserDefinedFunc;
+                                bool isAcceptableDefaultCtor = (! val.existsUserDefinedCtor || (! val.existsUserDefinedDefaultCtor && ball.decl->get_linkage() == LinkageSpec::Intrinsic)) && ball.isDefaultCtor; // allow default constructors only when no user-defined constructors exist, except in the case of intrinsics, which require exact overrides
+                                bool isAcceptableCopyFunc = ! val.existsUserDefinedCopyFunc && ball.isCopyFunc; // handles copy ctor and assignment operator
+                                bool isAcceptableDtor = ! val.existsUserDefinedDtor && ball.isDtor;
+                                if ( noUserDefinedFunc || isUserDefinedFunc || isAcceptableDefaultCtor || isAcceptableCopyFunc || isAcceptableDtor ) {
                                         // decl conforms to the rules described above, so it should be seen by the requester
                                         out.push_back( ball.decl );
 …
                 addType( typeDecl );
                 acceptAll( typeDecl->get_assertions(), *this );
+                acceptNewScope( typeDecl->get_init(), *this );
+        }
 …
+        }
-        void Indexer::visit( UntypedValofExpr *valofExpr ) {
-                acceptNewScope( valofExpr->get_result(), *this );
-                maybeAccept( valofExpr->get_body(), *this );
+        }
         void Indexer::visit( RangeExpr *rangeExpr ) {
                 maybeAccept( rangeExpr->get_low(), *this );
 …
                 acceptNewScope( tupleExpr->get_result(), *this );
                 maybeAccept( tupleExpr->get_tuple(), *this );
+        }
-        void Indexer::visit( MemberTupleExpr *tupleExpr ) {
-                acceptNewScope( tupleExpr->get_result(), *this );
-                maybeAccept( tupleExpr->get_member(), *this );
-                maybeAccept( tupleExpr->get_aggregate(), *this );
+        }

src/SymTab/Indexer.h

-              r9c951e3
+              rb1e63ac5
                 virtual void visit( ConstructorExpr * ctorExpr );
                 virtual void visit( CompoundLiteralExpr *compLitExpr );
-                virtual void visit( UntypedValofExpr *valofExpr );
                 virtual void visit( RangeExpr *rangeExpr );
                 virtual void visit( UntypedTupleExpr *tupleExpr );
                 virtual void visit( TupleExpr *tupleExpr );
                 virtual void visit( TupleIndexExpr *tupleExpr );
-                virtual void visit( MemberTupleExpr *tupleExpr );
                 virtual void visit( TupleAssignExpr *tupleExpr );
                 virtual void visit( StmtExpr * stmtExpr );

src/SymTab/Mangler.cc

-              r9c951e3
+              rb1e63ac5
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:40:29 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Mar 17 09:40:01 2017
 // Update Count     : 20
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Jun 28 15:31:00 2017
+// Update Count     : 21
 //
 …
                         } else {
                                 // if we add another kind of overridable function, this has to change
                                 assert( false );
+                                assert( false && "unknown overrideable linkage" );
                         } // if
+                }
 …
+        }
         void Mangler::visit( ZeroType *zeroType ) {
+        void Mangler::visit( __attribute__((unused)) ZeroType *zeroType ) {
                 mangleName << "Z";
+        }
         void Mangler::visit( OneType *oneType ) {
+        void Mangler::visit( __attribute__((unused)) OneType *oneType ) {
                 mangleName << "O";
+        }

src/SymTab/Validate.cc

-              r9c951e3
+              rb1e63ac5
 //   definition occurs later in the input.
+#include <algorithm>
+#include <iterator>
 #include <list>
+#include <iterator>
+#include "CodeGen/CodeGenerator.h"
+#include "Common/PassVisitor.h"
 #include "Common/ScopedMap.h"
+#include "Common/UniqueName.h"
 #include "Common/utility.h"
+#include "Common/UniqueName.h"
 #include "Concurrency/Keywords.h"
+#include "Validate.h"
+#include "SynTree/Visitor.h"
+#include "SynTree/Mutator.h"
+#include "SynTree/Type.h"
+#include "SynTree/Expression.h"
+#include "SynTree/Statement.h"
+#include "SynTree/TypeSubstitution.h"
+#include "Indexer.h"
+#include "GenPoly/DeclMutator.h"
+#include "InitTweak/InitTweak.h"
+#include "AddVisit.h"
+#include "Autogen.h"
 #include "FixFunction.h"
 // #include "ImplementationType.h"
+#include "GenPoly/DeclMutator.h"
+#include "AddVisit.h"
+#include "Indexer.h"
 #include "MakeLibCfa.h"
 #include "TypeEquality.h"
+#include "Autogen.h"
+#include "Validate.h"
 #include "ResolvExpr/typeops.h"
+#include <algorithm>
+#include "InitTweak/InitTweak.h"
+#include "CodeGen/CodeGenerator.h"
+#include "SynTree/Attribute.h"
+#include "SynTree/Expression.h"
+#include "SynTree/Mutator.h"
+#include "SynTree/Statement.h"
+#include "SynTree/Type.h"
+#include "SynTree/TypeSubstitution.h"
+#include "SynTree/Visitor.h"
 #define debugPrint( x ) if ( doDebug ) { std::cout << x; }
 …
         /// Fix return types so that every function returns exactly one value
+        class ReturnTypeFixer final : public Visitor {
+          public:
+                typedef Visitor Parent;
+                using Parent::visit;
+        struct ReturnTypeFixer {
                 static void fix( std::list< Declaration * > &translationUnit );
                 virtual void visit( FunctionDecl * functionDecl );
                 virtual void visit( FunctionType * ftype );
+                void postvisit( FunctionDecl * functionDecl );
+                void postvisit( FunctionType * ftype );
         };
         /// Replaces enum types by int, and function or array types in function parameter and return lists by appropriate pointers.
+        class EnumAndPointerDecayPass final : public Visitor {
+                typedef Visitor Parent;
+                virtual void visit( EnumDecl *aggregateDecl );
+                virtual void visit( FunctionType *func );
+        struct EnumAndPointerDecay {
+                void previsit( EnumDecl *aggregateDecl );
+                void previsit( FunctionType *func );
         };
 …
           public:
                 LinkReferenceToTypes( bool doDebug, const Indexer *indexer );
-          private:
                 using Parent::visit;
                 void visit( EnumInstType *enumInst ) final;
 …
                 void visit( UnionDecl *unionDecl ) final;
                 void visit( TypeInstType *typeInst ) final;
+          private:
                 const Indexer *indexer;
 …
         };
         /// Replaces array and function types in forall lists by appropriate pointer type
         class Pass3 final : public Indexer {
+        /// Replaces array and function types in forall lists by appropriate pointer type and assigns each Object and Function declaration a unique ID.
+        class ForallPointerDecay final : public Indexer {
                 typedef Indexer Parent;
           public:
                 using Parent::visit;
                 Pass3( const Indexer *indexer );
+          private:
+                ForallPointerDecay( const Indexer *indexer );
                 virtual void visit( ObjectDecl *object ) override;
                 virtual void visit( FunctionDecl *func ) override;
 …
         };
+        class ReturnChecker : public Visitor {
+          public:
+        struct ReturnChecker : public WithGuards {
                 /// Checks that return statements return nothing if their return type is void
                 /// and return something if the return type is non-void.
                 static void checkFunctionReturns( std::list< Declaration * > & translationUnit );
+          private:
+                virtual void visit( FunctionDecl * functionDecl );
+                virtual void visit( ReturnStmt * returnStmt );
+                std::list< DeclarationWithType * > returnVals;
+                void previsit( FunctionDecl * functionDecl );
+                void previsit( ReturnStmt * returnStmt );
+                typedef std::list< DeclarationWithType * > ReturnVals;
+                ReturnVals returnVals;
         };
 …
         };
+        class VerifyCtorDtorAssign : public Visitor {
+        public:
+        struct VerifyCtorDtorAssign {
                 /// ensure that constructors, destructors, and assignment have at least one
                 /// parameter, the first of which must be a pointer, and that ctor/dtors have no
 …
                 static void verify( std::list< Declaration * > &translationUnit );
+                virtual void visit( FunctionDecl *funcDecl );
+        };
+        class ArrayLength : public Visitor {
+        public:
+                void previsit( FunctionDecl *funcDecl );
+        };
+        /// ensure that generic types have the correct number of type arguments
+        struct ValidateGenericParameters {
+                void previsit( StructInstType * inst );
+                void previsit( UnionInstType * inst );
+        };
+        struct ArrayLength {
                 /// for array types without an explicit length, compute the length and store it so that it
                 /// is known to the rest of the phases. For example,
 …
                 static void computeLength( std::list< Declaration * > & translationUnit );
                 virtual void visit( ObjectDecl * objDecl );
         };
         class CompoundLiteral final : public GenPoly::DeclMutator {
+                void previsit( ObjectDecl * objDecl );
+        };
+        struct CompoundLiteral final : public WithDeclsToAdd, public WithVisitorRef<CompoundLiteral> {
                 Type::StorageClasses storageClasses;
+                using GenPoly::DeclMutator::mutate;
+                DeclarationWithType * mutate( ObjectDecl *objectDecl ) final;
+                Expression *mutate( CompoundLiteralExpr *compLitExpr ) final;
+                void premutate( ObjectDecl *objectDecl );
+                Expression * postmutate( CompoundLiteralExpr *compLitExpr );
         };
         void validate( std::list< Declaration * > &translationUnit, bool doDebug ) {
                 EnumAndPointerDecayPass epc;
+                PassVisitor<EnumAndPointerDecay> epc;
                 LinkReferenceToTypes lrt( doDebug, 0 );
                 Pass3 pass3( 0 );
                 CompoundLiteral compoundliteral;
+                HoistStruct::hoistStruct( translationUnit );
+                ForallPointerDecay fpd( 0 );
+                PassVisitor<CompoundLiteral> compoundliteral;
+                PassVisitor<ValidateGenericParameters> genericParams;
                 EliminateTypedef::eliminateTypedef( translationUnit );
+                HoistStruct::hoistStruct( translationUnit ); // must happen after EliminateTypedef, so that aggregate typedefs occur in the correct order
                 ReturnTypeFixer::fix( translationUnit ); // must happen before autogen
                 acceptAll( translationUnit, lrt ); // must happen before autogen, because sized flag needs to propagate to generated functions
+                acceptAll( translationUnit, genericParams );  // check as early as possible - can't happen before LinkReferenceToTypes
                 acceptAll( translationUnit, epc ); // must happen before VerifyCtorDtorAssign, because void return objects should not exist
                 VerifyCtorDtorAssign::verify( translationUnit );  // must happen before autogen, because autogen examines existing ctor/dtors
                 Concurrency::applyKeywords( translationUnit );
                 autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs EnumAndPointerDecayPass
+                autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs EnumAndPointerDecay
                 Concurrency::implementMutexFuncs( translationUnit );
                 Concurrency::implementThreadStarter( translationUnit );
                 ReturnChecker::checkFunctionReturns( translationUnit );
                 compoundliteral.mutateDeclarationList( translationUnit );
                 acceptAll( translationUnit, pass3 );
+                mutateAll( translationUnit, compoundliteral );
+                acceptAll( translationUnit, fpd );
                 ArrayLength::computeLength( translationUnit );
+        }
         void validateType( Type *type, const Indexer *indexer ) {
                 EnumAndPointerDecayPass epc;
+                PassVisitor<EnumAndPointerDecay> epc;
                 LinkReferenceToTypes lrt( false, indexer );
                 Pass3 pass3( indexer );
+                ForallPointerDecay fpd( indexer );
                 type->accept( epc );
                 type->accept( lrt );
                 type->accept( pass3 );
+                type->accept( fpd );
+        }
 …
+        }
         void EnumAndPointerDecayPass::visit( EnumDecl *enumDecl ) {
+        void EnumAndPointerDecay::previsit( EnumDecl *enumDecl ) {
                 // Set the type of each member of the enumeration to be EnumConstant
                 for ( std::list< Declaration * >::iterator i = enumDecl->get_members().begin(); i != enumDecl->get_members().end(); ++i ) {
 …
                         obj->set_type( new EnumInstType( Type::Qualifiers( Type::Const ), enumDecl->get_name() ) );
                 } // for
-                Parent::visit( enumDecl );
+        }
 …
                 void fixFunctionList( DWTList & dwts, FunctionType * func ) {
                         // the only case in which "void" is valid is where it is the only one in the list; then it should be removed
                         // entirely other fix ups are handled by the FixFunction class
+                        // entirely. other fix ups are handled by the FixFunction class
                         typedef typename DWTList::iterator DWTIterator;
                         DWTIterator begin( dwts.begin() ), end( dwts.end() );
 …
                                 for ( ; i != end; ++i ) {
                                         FixFunction fixer;
                                         *i = (*i )->acceptMutator( fixer );
+                                        *i = (*i)->acceptMutator( fixer );
                                         if ( fixer.get_isVoid() ) {
                                                 throw SemanticError( "invalid type void in function type ", func );
 …
+        }
         void EnumAndPointerDecayPass::visit( FunctionType *func ) {
+        void EnumAndPointerDecay::previsit( FunctionType *func ) {
                 // Fix up parameters and return types
                 fixFunctionList( func->get_parameters(), func );
                 fixFunctionList( func->get_returnVals(), func );
-                Visitor::visit( func );
+        }
 …
         void LinkReferenceToTypes::visit( StructDecl *structDecl ) {
                 // visit struct members first so that the types of self-referencing members are updated properly
+                // xxx - need to ensure that type parameters match up between forward declarations and definition (most importantly, number of type parameters and and their defaults)
                 Parent::visit( structDecl );
                 if ( ! structDecl->get_members().empty() ) {
 …
+        }
         Pass3::Pass3( const Indexer *other_indexer ) :  Indexer( false ) {
+        ForallPointerDecay::ForallPointerDecay( const Indexer *other_indexer ) :  Indexer( false ) {
                 if ( other_indexer ) {
                         indexer = other_indexer;
 …
+        }
         void Pass3::visit( ObjectDecl *object ) {
+        void ForallPointerDecay::visit( ObjectDecl *object ) {
                 forallFixer( object->get_type() );
                 if ( PointerType *pointer = dynamic_cast< PointerType * >( object->get_type() ) ) {
 …
+        }
         void Pass3::visit( FunctionDecl *func ) {
+        void ForallPointerDecay::visit( FunctionDecl *func ) {
                 forallFixer( func->get_type() );
                 Parent::visit( func );
 …
         void ReturnChecker::checkFunctionReturns( std::list< Declaration * > & translationUnit ) {
                 ReturnChecker checker;
+                PassVisitor<ReturnChecker> checker;
                 acceptAll( translationUnit, checker );
+        }
         void ReturnChecker::visit( FunctionDecl * functionDecl ) {
                 std::list< DeclarationWithType * > oldReturnVals = returnVals;
+        void ReturnChecker::previsit( FunctionDecl * functionDecl ) {
+                GuardValue( returnVals );
                 returnVals = functionDecl->get_functionType()->get_returnVals();
+                Visitor::visit( functionDecl );
+                returnVals = oldReturnVals;
+        }
+        void ReturnChecker::visit( ReturnStmt * returnStmt ) {
+        }
+        void ReturnChecker::previsit( ReturnStmt * returnStmt ) {
                 // Previously this also checked for the existence of an expr paired with no return values on
                 // the  function return type. This is incorrect, since you can have an expression attached to
 …
         void VerifyCtorDtorAssign::verify( std::list< Declaration * > & translationUnit ) {
                 VerifyCtorDtorAssign verifier;
+                PassVisitor<VerifyCtorDtorAssign> verifier;
                 acceptAll( translationUnit, verifier );
+        }
         void VerifyCtorDtorAssign::visit( FunctionDecl * funcDecl ) {
+        void VerifyCtorDtorAssign::previsit( FunctionDecl * funcDecl ) {
                 FunctionType * funcType = funcDecl->get_functionType();
                 std::list< DeclarationWithType * > &returnVals = funcType->get_returnVals();
 …
+                        }
+                }
+                Visitor::visit( funcDecl );
+        }
+        DeclarationWithType * CompoundLiteral::mutate( ObjectDecl *objectDecl ) {
+        }
+        template< typename Aggr >
+        void validateGeneric( Aggr * inst ) {
+                std::list< TypeDecl * > * params = inst->get_baseParameters();
+                if ( params != NULL ) {
+                        std::list< Expression * > & args = inst->get_parameters();
+                        // insert defaults arguments when a type argument is missing (currently only supports missing arguments at the end of the list).
+                        // A substitution is used to ensure that defaults are replaced correctly, e.g.,
+                        //   forall(otype T, otype alloc = heap_allocator(T)) struct vector;
+                        //   vector(int) v;
+                        // after insertion of default values becomes
+                        //   vector(int, heap_allocator(T))
+                        // and the substitution is built with T=int so that after substitution, the result is
+                        //   vector(int, heap_allocator(int))
+                        TypeSubstitution sub;
+                        auto paramIter = params->begin();
+                        for ( size_t i = 0; paramIter != params->end(); ++paramIter, ++i ) {
+                                if ( i < args.size() ) {
+                                        TypeExpr * expr = safe_dynamic_cast< TypeExpr * >( *std::next( args.begin(), i ) );
+                                        sub.add( (*paramIter)->get_name(), expr->get_type()->clone() );
+                                } else if ( i == args.size() ) {
+                                        Type * defaultType = (*paramIter)->get_init();
+                                        if ( defaultType ) {
+                                                args.push_back( new TypeExpr( defaultType->clone() ) );
+                                                sub.add( (*paramIter)->get_name(), defaultType->clone() );
+                                        }
+                                }
+                        }
+                        sub.apply( inst );
+                        if ( args.size() < params->size() ) throw SemanticError( "Too few type arguments in generic type ", inst );
+                        if ( args.size() > params->size() ) throw SemanticError( "Too many type arguments in generic type ", inst );
+                }
+        }
+        void ValidateGenericParameters::previsit( StructInstType * inst ) {
+                validateGeneric( inst );
+        }
+        void ValidateGenericParameters::previsit( UnionInstType * inst ) {
+                validateGeneric( inst );
+        }
+        void CompoundLiteral::premutate( ObjectDecl *objectDecl ) {
                 storageClasses = objectDecl->get_storageClasses();
+                DeclarationWithType * temp = Mutator::mutate( objectDecl );
+                return temp;
+        }
+        Expression *CompoundLiteral::mutate( CompoundLiteralExpr *compLitExpr ) {
+        }
+        Expression *CompoundLiteral::postmutate( CompoundLiteralExpr *compLitExpr ) {
                 // transform [storage_class] ... (struct S){ 3, ... };
                 // into [storage_class] struct S temp =  { 3, ... };
                 static UniqueName indexName( "_compLit" );
                 ObjectDecl *tempvar = new ObjectDecl( indexName.newName(), storageClasses, LinkageSpec::C, 0, compLitExpr->get_result(), compLitExpr->get_initializer() );
                 compLitExpr->set_result( 0 );
                 compLitExpr->set_initializer( 0 );
+                ObjectDecl *tempvar = new ObjectDecl( indexName.newName(), storageClasses, LinkageSpec::C, nullptr, compLitExpr->get_result(), compLitExpr->get_initializer() );
+                compLitExpr->set_result( nullptr );
+                compLitExpr->set_initializer( nullptr );
                 delete compLitExpr;
+                DeclarationWithType * newtempvar = mutate( tempvar );
+                addDeclaration( newtempvar );                                   // add modified temporary to current block
+                return new VariableExpr( newtempvar );
+                declsToAddBefore.push_back( tempvar );                                  // add modified temporary to current block
+                return new VariableExpr( tempvar );
+        }
         void ReturnTypeFixer::fix( std::list< Declaration * > &translationUnit ) {
                 ReturnTypeFixer fixer;
+                PassVisitor<ReturnTypeFixer> fixer;
                 acceptAll( translationUnit, fixer );
+        }
+        void ReturnTypeFixer::visit( FunctionDecl * functionDecl ) {
+                Parent::visit( functionDecl );
+        void ReturnTypeFixer::postvisit( FunctionDecl * functionDecl ) {
                 FunctionType * ftype = functionDecl->get_functionType();
                 std::list< DeclarationWithType * > & retVals = ftype->get_returnVals();
 …
                                 ret->set_name( toString( "_retval_", CodeGen::genName( functionDecl ) ) );
+                        }
+                }
+        }
+        void ReturnTypeFixer::visit( FunctionType * ftype ) {
+                        ret->get_attributes().push_back( new Attribute( "unused" ) );
+                }
+        }
+        void ReturnTypeFixer::postvisit( FunctionType * ftype ) {
                 // xxx - need to handle named return values - this information needs to be saved somehow
                 // so that resolution has access to the names.
 …
         void ArrayLength::computeLength( std::list< Declaration * > & translationUnit ) {
                 ArrayLength len;
+                PassVisitor<ArrayLength> len;
                 acceptAll( translationUnit, len );
+        }
         void ArrayLength::visit( ObjectDecl * objDecl ) {
+        void ArrayLength::previsit( ObjectDecl * objDecl ) {
                 if ( ArrayType * at = dynamic_cast< ArrayType * >( objDecl->get_type() ) ) {
                         if ( at->get_dimension() != nullptr ) return;

src/SynTree/AggregateDecl.cc

-              r9c951e3
+              rb1e63ac5
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 23:56:39 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Mar 16 07:49:07 2017
 // Update Count     : 20
+// Last Modified By : Andrew Beach
+// Last Modified On : Tus Jun 27 15:30:00 2017
+// Update Count     : 21
 //
 …
 AggregateDecl::AggregateDecl( const std::string &name, const std::list< Attribute * > & attributes ) : Parent( name, Type::StorageClasses(), LinkageSpec::Cforall ), body( false ), attributes( attributes ) {
+AggregateDecl::AggregateDecl( const std::string &name, const std::list< Attribute * > & attributes, LinkageSpec::Spec linkage ) : Parent( name, Type::StorageClasses(), linkage ), body( false ), attributes( attributes ) {
+}

src/SynTree/Attribute.h

r9c951e3	rb1e63ac5
40	40	};
41	41
	42	const std::list< Attribute * > noAttributes;
	43
42	44	#endif
43	45

src/SynTree/BaseSyntaxNode.h

-              r9c951e3
+              rb1e63ac5
         CodeLocation location;
+        virtual void accept( Visitor & v ) = 0; // temporary -- needs to be here so that BaseSyntaxNode is polymorphic and can be dynamic_cast
+        virtual ~BaseSyntaxNode() {}
+        virtual void accept( Visitor & v ) = 0;
 };

src/SynTree/Constant.cc

-              r9c951e3
+              rb1e63ac5
 // file "LICENCE" distributed with Cforall.
 //
 // Constant.cc --
+// Constant.cc --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jul 30 15:18:38 2015
 // Update Count     : 12
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr Jun 22 10:11:00 2017
+// Update Count     : 28
 //
 …
 #include "Type.h"
+Constant::Constant( Type *type_, std::string value_ ) : type( type_ ), value( value_ ) {}
+Constant::Constant( Type * type, std::string rep, unsigned long long val ) : type( type ), rep( rep ), val( val ) {}
+Constant::Constant( Type * type, std::string rep, double val ) : type( type ), rep( rep ), val( val ) {}
 Constant::Constant( const Constant &other ) {
+Constant::Constant( const Constant &other ) : rep( other.rep ), val( other.val ) {
         type = other.type->clone();
-        value = other.value;
+}
 Constant::~Constant() { delete type; }
+Constant Constant::from_bool( bool b ) {
+        return Constant( new BasicType( Type::Qualifiers(), BasicType::Bool ), b ? "1" : "0" , (unsigned long long int)b );
+}
 Constant Constant::from_int( int i ) {
         return Constant( new BasicType( Type::Qualifiers(), BasicType::SignedInt ), std::to_string( i ) );
+        return Constant( new BasicType( Type::Qualifiers(), BasicType::SignedInt ), std::to_string( i ), (unsigned long long int)i );
+}
 Constant Constant::from_ulong( unsigned long i ) {
         return Constant( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), std::to_string( i ) );
+        return Constant( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), std::to_string( i ), (unsigned long long int)i );
+}
 Constant Constant::from_double( double d ) {
         return Constant( new BasicType( Type::Qualifiers(), BasicType::Double ), std::to_string( d ) );
+        return Constant( new BasicType( Type::Qualifiers(), BasicType::Double ), std::to_string( d ), d );
+}
+Constant *Constant::clone() const { assert( false ); return 0; }
+unsigned long long Constant::get_ival() const {
+        assertf( safe_dynamic_cast<BasicType*>(type)->isInteger(), "Attempt to retrieve ival from non-integer constant." );
+        return val.ival;
+}
+double Constant::get_dval() const {
+        assertf( ! safe_dynamic_cast<BasicType*>(type)->isInteger(), "Attempt to retrieve dval from integer constant." );
+        return val.dval;
+}
 void Constant::print( std::ostream &os ) const {
         os << "(" << value;
+        os << "(" << rep << " " << val.ival;
         if ( type ) {
                 os << ": ";

src/SynTree/Constant.h

-              r9c951e3
+              rb1e63ac5
 // file "LICENCE" distributed with Cforall.
 //
 // Constant.h --
+// Constant.h --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jun 30 13:33:17 2016
 // Update Count     : 6
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr Jun 22 10:13:00 2017
+// Update Count     : 15
 //
 …
 class Constant {
   public:
+        Constant( Type *type, std::string value );
+        Constant( const Constant &other );
+        Constant( Type * type, std::string rep, unsigned long long val );
+        Constant( Type * type, std::string rep, double val );
+        Constant( const Constant & other );
         virtual ~Constant();
+        Type *get_type() { return type; }
+        void set_type( Type *newValue ) { type = newValue; }
+        std::string &get_value() { return value; }
+        void set_value( std::string newValue ) { value = newValue; }
+        Type * get_type() { return type; }
+        void set_type( Type * newValue ) { type = newValue; }
+        std::string & get_value() { return rep; }
+        void set_value( std::string newValue ) { rep = newValue; }
+        unsigned long long get_ival() const;
+        double get_dval() const;
+        /// generates a boolean constant of the given bool
+        static Constant from_bool( bool b );
         /// generates an integer constant of the given int
         static Constant from_int( int i );
 …
         static Constant from_double( double d );
+        virtual Constant *clone() const;
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Constant *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os ) const;
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Constant * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os ) const;
   private:
+        Type *type;
+        std::string value;
+        Type * type;
+        std::string rep;
+        union Val {
+                unsigned long long ival;
+                double dval;
+                Val( unsigned long long ival ) : ival( ival ) {}
+                Val( double dval ) : dval( dval ) {}
+        } val;
 };

src/SynTree/Declaration.h

-              r9c951e3
+              rb1e63ac5
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Mar 17 16:05:08 2017
 // Update Count     : 121
+// Last Modified By : Andrew Beach
+// Last Modified On : Tus Jun 27 15:31:00 2017
+// Update Count     : 122
 //
 …
         };
         TypeDecl( const std::string &name, Type::StorageClasses scs, Type *type, Kind kind );
+        TypeDecl( const std::string &name, Type::StorageClasses scs, Type *type, Kind kind, Type * init = nullptr );
         TypeDecl( const TypeDecl &other );
+        virtual ~TypeDecl();
         Kind get_kind() const { return kind; }
+        Type * get_init() const { return init; }
+        TypeDecl * set_init( Type * newValue ) { init = newValue; return this; }
         bool isComplete() const { return kind == Any || sized; }
 …
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual TypeDecl *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
         Kind kind;
+        Type * init;
         bool sized;
 };
 …
         typedef Declaration Parent;
   public:
         AggregateDecl( const std::string &name, const std::list< Attribute * > & attributes = std::list< class Attribute * >() );
+        AggregateDecl( const std::string &name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall );
         AggregateDecl( const AggregateDecl &other );
         virtual ~AggregateDecl();
 …
         typedef AggregateDecl Parent;
   public:
         StructDecl( const std::string &name, DeclarationNode::Aggregate kind = DeclarationNode::Struct, const std::list< Attribute * > & attributes = std::list< class Attribute * >() ) : Parent( name, attributes ), kind( kind ) {}
+        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 ) {}
 …
         typedef AggregateDecl Parent;
   public:
         UnionDecl( const std::string &name, const std::list< Attribute * > & attributes = std::list< class Attribute * >() ) : Parent( name, attributes ) {}
+        UnionDecl( const std::string &name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ) {}
         UnionDecl( const UnionDecl &other ) : Parent( other ) {}
 …
         typedef AggregateDecl Parent;
   public:
         EnumDecl( const std::string &name, const std::list< Attribute * > & attributes = std::list< class Attribute * >() ) : Parent( name, attributes ) {}
+        EnumDecl( const std::string &name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ) {}
         EnumDecl( const EnumDecl &other ) : Parent( other ) {}

src/SynTree/Expression.cc

-              r9c951e3
+              rb1e63ac5
 #include <iterator>
+#include "Declaration.h"
+#include "Expression.h"
+#include "Initializer.h"
+#include "Statement.h"
 #include "Type.h"
-#include "Initializer.h"
-#include "Expression.h"
-#include "Declaration.h"
-#include "Statement.h"
 #include "TypeSubstitution.h"
+#include "VarExprReplacer.h"
 #include "Common/utility.h"
+#include "Common/PassVisitor.h"
 #include "InitTweak/InitTweak.h"
 …
         Declaration *decl = get_var();
-        // if ( decl != 0) decl->print(os, indent + 2);
         if ( decl != 0) decl->printShort(os, indent + 2);
         os << std::endl;
 …
         delete arg;
+}
-// CastExpr *CastExpr::clone() const { return 0; }
 void CastExpr::print( std::ostream &os, int indent ) const {
 …
+}
-//// is this right? It's cloning the member, but the member is a declaration so probably shouldn't be cloned...
 MemberExpr::MemberExpr( const MemberExpr &other ) :
                 Expression( other ), member( other.member ), aggregate( maybeClone( other.aggregate ) ) {
 …
 MemberExpr::~MemberExpr() {
         // delete member;
+        // don't delete the member declaration, since it points somewhere else in the tree
         delete aggregate;
+}
 …
+}
-UntypedValofExpr::UntypedValofExpr( const UntypedValofExpr & other ) : Expression( other ), body ( maybeClone( other.body ) ) {}
-UntypedValofExpr::~UntypedValofExpr() { delete body; }
-void UntypedValofExpr::print( std::ostream &os, int indent ) const {
-        os << std::string( indent, ' ' ) << "Valof Expression: " << std::endl;
-        if ( get_body() != 0 )
-                get_body()->print( os, indent + 2 );
+}
 RangeExpr::RangeExpr( Expression *low, Expression *high ) : low( low ), high( high ) {}
 RangeExpr::RangeExpr( const RangeExpr &other ) : Expression( other ), low( other.low->clone() ), high( other.high->clone() ) {}
 …
+}
+InitAlternative::InitAlternative( Type * type, Designation * designation ) : type( type ), designation( designation ) {}
+InitAlternative::InitAlternative( const InitAlternative & other ) : type( maybeClone( other.type ) ), designation( maybeClone( other.designation ) ) {}
+InitAlternative::~InitAlternative() {
+        delete type;
+        delete designation;
+}
+UntypedInitExpr::UntypedInitExpr( Expression * expr, const std::list<InitAlternative> & initAlts ) : expr( expr ), initAlts( initAlts ) {}
+UntypedInitExpr::UntypedInitExpr( const UntypedInitExpr & other ) : Expression( other ), expr( maybeClone( other.expr ) ), initAlts( other.initAlts ) {}
+UntypedInitExpr::~UntypedInitExpr() {
+        delete expr;
+}
+void UntypedInitExpr::print( std::ostream & os, int indent ) const {
+        os << "Untyped Init Expression" << std::endl << std::string( indent+2, ' ' );
+        expr->print( os, indent+2 );
+        if ( ! initAlts.empty() ) {
+                for ( const InitAlternative & alt : initAlts ) {
+                        os << std::string( indent+2, ' ' ) <<  "InitAlternative: ";
+                        alt.type->print( os, indent+2 );
+                        alt.designation->print( os, indent+2 );
+                }
+        }
+}
+InitExpr::InitExpr( Expression * expr, Designation * designation ) : expr( expr ), designation( designation ) {
+        set_result( expr->get_result()->clone() );
+}
+InitExpr::InitExpr( const InitExpr & other ) : Expression( other ), expr( maybeClone( other.expr ) ), designation( maybeClone( other.designation) ) {}
+InitExpr::~InitExpr() {
+        delete expr;
+        delete designation;
+}
+void InitExpr::print( std::ostream & os, int indent ) const {
+        os << "Init Expression" << std::endl << std::string( indent+2, ' ' );
+        expr->print( os, indent+2 );
+        os << std::string( indent+2, ' ' ) << "with designation: ";
+        designation->print( os, indent+2 );
+}
 std::ostream & operator<<( std::ostream & out, const Expression * expr ) {
         if ( expr ) {

src/SynTree/Expression.h

-              r9c951e3
+              rb1e63ac5
 };
+/// MemberExpr represents a member selection operation, e.g. q.p after processing by the expression analyzer
+/// MemberExpr represents a member selection operation, e.g. q.p after processing by the expression analyzer.
+/// Does not take ownership of member.
 class MemberExpr : public Expression {
   public:
 …
 };
+/// VariableExpr represents an expression that simply refers to the value of a named variable
+/// VariableExpr represents an expression that simply refers to the value of a named variable.
+/// Does not take ownership of var.
 class VariableExpr : public Expression {
   public:
 …
 };
-/// ValofExpr represents a GCC 'lambda expression'
-class UntypedValofExpr : public Expression {
-  public:
-        UntypedValofExpr( Statement *_body, Expression *_aname = nullptr ) : Expression( _aname ), body ( _body ) {}
-        UntypedValofExpr( const UntypedValofExpr & other );
-        virtual ~UntypedValofExpr();
-        Expression * get_value();
-        Statement * get_body() const { return body; }
-        virtual UntypedValofExpr * clone() const { return new UntypedValofExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Statement * body;
-};
 /// RangeExpr represents a range e.g. '3 ... 5' or '1~10'
 class RangeExpr : public Expression {
 …
         Expression * tuple;
         unsigned int index;
-};
-/// MemberTupleExpr represents a tuple member selection operation on a struct type, e.g. s.[a, b, c] after processing by the expression analyzer
-class MemberTupleExpr : public Expression {
-  public:
-        MemberTupleExpr( Expression * member, Expression * aggregate, Expression * _aname = nullptr );
-        MemberTupleExpr( const MemberTupleExpr & other );
-        virtual ~MemberTupleExpr();
-        Expression * get_member() const { return member; }
-        Expression * get_aggregate() const { return aggregate; }
-        MemberTupleExpr * set_member( Expression * newValue ) { member = newValue; return this; }
-        MemberTupleExpr * set_aggregate( Expression * newValue ) { aggregate = newValue; return this; }
-        virtual MemberTupleExpr * clone() const { return new MemberTupleExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Expression * member;
-        Expression * aggregate;
 };
 …
 };
+struct InitAlternative {
+public:
+        Type * type = nullptr;
+        Designation * designation = nullptr;
+        InitAlternative( Type * type, Designation * designation );
+        InitAlternative( const InitAlternative & other );
+        InitAlternative & operator=( const Initializer & other ) = delete; // at the moment this isn't used, and I don't want to implement it
+        ~InitAlternative();
+};
+class UntypedInitExpr : public Expression {
+public:
+        UntypedInitExpr( Expression * expr, const std::list<InitAlternative> & initAlts );
+        UntypedInitExpr( const UntypedInitExpr & other );
+        ~UntypedInitExpr();
+        Expression * get_expr() const { return expr; }
+        UntypedInitExpr * set_expr( Expression * newValue ) { expr = newValue; return this; }
+        std::list<InitAlternative> & get_initAlts() { return initAlts; }
+        virtual UntypedInitExpr * clone() const { return new UntypedInitExpr( * this ); }
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const;
+private:
+        Expression * expr;
+        std::list<InitAlternative> initAlts;
+};
+class InitExpr : public Expression {
+public:
+        InitExpr( Expression * expr, Designation * designation );
+        InitExpr( const InitExpr & other );
+        ~InitExpr();
+        Expression * get_expr() const { return expr; }
+        InitExpr * set_expr( Expression * newValue ) { expr = newValue; return this; }
+        Designation * get_designation() const { return designation; }
+        InitExpr * set_designation( Designation * newValue ) { designation = newValue; return this; }
+        virtual InitExpr * clone() const { return new InitExpr( * this ); }
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const;
+private:
+        Expression * expr;
+        Designation * designation;
+};
 std::ostream & operator<<( std::ostream & out, const Expression * expr );

src/SynTree/Initializer.cc

-              r9c951e3
+              rb1e63ac5
 #include "Common/utility.h"
+Designation::Designation( const std::list< Expression * > & designators ) : designators( designators ) {}
+Designation::Designation( const Designation & other ) : BaseSyntaxNode( other ) {
+        // std::cerr << "cloning designation" << std::endl;
+        cloneAll( other.designators, designators );
+        // std::cerr << "finished cloning designation" << std::endl;
+}
+Designation::~Designation() {
+        // std::cerr << "destroying designation" << std::endl;
+        deleteAll( designators );
+        // std::cerr << "finished destroying designation" << std::endl;
+}
+void Designation::print( std::ostream &os, int indent ) const {
+        if ( ! designators.empty() ) {
+                os << std::string(indent + 2, ' ' ) << "designated by: " << std::endl;
+                for ( std::list < Expression * >::const_iterator i = designators.begin(); i != designators.end(); i++ ) {
+                        os << std::string(indent + 4, ' ' );
+                        ( *i )->print(os, indent + 4 );
+                }
+                os << std::endl;
+        } // if
+}
 Initializer::Initializer( bool maybeConstructed ) : maybeConstructed( maybeConstructed ) {}
 Initializer::Initializer( const Initializer & other ) : BaseSyntaxNode( other ), maybeConstructed( other.maybeConstructed ) {
+}
 Initializer::~Initializer() {}
+std::string Initializer::designator_name( Expression *des ) {
+        if ( NameExpr *n = dynamic_cast<NameExpr *>(des) )
+                return n->get_name();
+        else
+                throw 0;
+}
+void Initializer::print( std::ostream &os, int indent ) {}
+SingleInit::SingleInit( Expression *v, const std::list< Expression *> &_designators, bool maybeConstructed ) : Initializer( maybeConstructed ), value ( v ), designators( _designators ) {
+SingleInit::SingleInit( Expression *v, bool maybeConstructed ) : Initializer( maybeConstructed ), value ( v ) {
+}
 SingleInit::SingleInit( const SingleInit &other ) : Initializer(other), value ( maybeClone( other.value ) ) {
-        cloneAll(other.designators, designators );
+}
 SingleInit::~SingleInit() {
         delete value;
-        deleteAll(designators);
+}
 void SingleInit::print( std::ostream &os, int indent ) {
         os << std::endl << std::string(indent, ' ' ) << "Simple Initializer: " << std::endl;
+void SingleInit::print( std::ostream &os, int indent ) const {
+        os << std::string(indent, ' ' ) << "Simple Initializer: " << std::endl;
         os << std::string(indent+4, ' ' );
         value->print( os, indent+4 );
-        if ( ! designators.empty() ) {
-                os << std::endl << std::string(indent + 2, ' ' ) << "designated by: " << std::endl;
-                for ( std::list < Expression * >::iterator i = designators.begin(); i != designators.end(); i++ ) {
-                        os << std::string(indent + 4, ' ' );
-                        ( *i )->print(os, indent + 4 );
+                }
-        } // if
+}
+ListInit::ListInit( const std::list<Initializer*> &_initializers, const std::list<Expression *> &_designators, bool maybeConstructed )
+        : Initializer( maybeConstructed ), initializers( _initializers ), designators( _designators ) {
+ListInit::ListInit( const std::list<Initializer*> &inits, const std::list<Designation *> &des, bool maybeConstructed )
+        : Initializer( maybeConstructed ), initializers( inits ), designations( des ) {
+                // handle the common case where a ListInit is created without designations by making a list of empty designations with the same length as the initializer
+                if ( designations.empty() ) {
+                        for ( auto & i : initializers ) {
+                                (void)i;
+                                designations.push_back( new Designation( {} ) );
+                        }
+                }
+                assertf( initializers.size() == designations.size(), "Created ListInit with mismatching initializers (%d) and designations (%d)", initializers.size(), designations.size() );
+}
 ListInit::ListInit( const ListInit & other ) : Initializer( other ) {
         cloneAll( other.initializers, initializers );
         cloneAll( other.designators, designators );
+        cloneAll( other.designations, designations );
+}
 ListInit::~ListInit() {
         deleteAll( initializers );
         deleteAll( designators );
+        deleteAll( designations );
+}
+void ListInit::print( std::ostream &os, int indent ) {
+        os << std::endl << std::string(indent, ' ') << "Compound initializer:  ";
+        if ( ! designators.empty() ) {
+                os << std::string(indent + 2, ' ' ) << "designated by: [";
+                for ( std::list < Expression * >::iterator i = designators.begin();
+                          i != designators.end(); i++ ) {
+                        ( *i )->print(os, indent + 4 );
+                } // for
+void ListInit::print( std::ostream &os, int indent ) const {
+        os << std::string(indent, ' ') << "Compound initializer:  " << std::endl;
+        for ( Designation * d : designations ) {
+                d->print( os, indent + 2 );
+        }
+                os << std::string(indent + 2, ' ' ) << "]";
+        } // if
+        for ( std::list<Initializer *>::iterator i = initializers.begin(); i != initializers.end(); i++ )
+                (*i)->print( os, indent + 2 );
+        for ( const Initializer * init : initializers ) {
+                init->print( os, indent + 2 );
+                os << std::endl;
+        }
+}
 …
+}
 void ConstructorInit::print( std::ostream &os, int indent ) {
+void ConstructorInit::print( std::ostream &os, int indent ) const {
         os << std::endl << std::string(indent, ' ') << "Constructor initializer: " << std::endl;
         if ( ctor ) {
 …
+}
+std::ostream & operator<<( std::ostream & out, Initializer * init ) {
+        init->print( out );
+std::ostream & operator<<( std::ostream & out, const Initializer * init ) {
+        if ( init ) {
+                init->print( out );
+        } else {
+                out << "nullptr";
+        }
+        return out;
+}
+std::ostream & operator<<( std::ostream & out, const Designation * des ) {
+        if ( des ) {
+                des->print( out );
+        } else {
+                out << "nullptr";
+        }
         return out;
+}

src/SynTree/Initializer.h

-              r9c951e3
+              rb1e63ac5
 #include "Visitor.h"
+const std::list<Expression*> noDesignators;
+// Designation: list of designator (NameExpr, VariableExpr, and ConstantExpr) expressions that specify an object being initialized.
+class Designation : public BaseSyntaxNode {
+public:
+        Designation( const std::list< Expression * > & designators );
+        Designation( const Designation & other );
+        virtual ~Designation();
+        std::list< Expression * > & get_designators() { return designators; }
+        virtual Designation * clone() const { return new Designation( *this ); };
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Designation * acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+private:
+        std::list< Expression * > designators;
+};
+const std::list<Designation *> noDesignators;
 // Initializer: base class for object initializers (provide default values)
 class Initializer : public BaseSyntaxNode {
   public:
-        //      Initializer( std::string _name = std::string(""), int _pos = 0 );
         Initializer( bool maybeConstructed );
         Initializer( const Initializer & other );
         virtual ~Initializer();
-        static std::string designator_name( Expression *designator );
-        //      void set_name( std::string newValue ) { name = newValue; }
-        //      std::string get_name() const { return name; }
-        //      void set_pos( int newValue ) { pos = newValue; }
-        //      int get_pos() const { return pos; }
-        virtual void set_designators( std::list<Expression *> & ) { assert(false); }
-        virtual std::list<Expression *> &get_designators() {
-                assert(false);
-                std::list<Expression *> *ret = 0; return *ret;  // never reached
+        }
         bool get_maybeConstructed() { return maybeConstructed; }
 …
         virtual void accept( Visitor &v ) = 0;
         virtual Initializer *acceptMutator( Mutator &m ) = 0;
         virtual void print( std::ostream &os, int indent = 0 );
+        virtual void print( std::ostream &os, int indent = 0 ) const = 0;
   private:
-        //      std::string name;
-        //      int pos;
         bool maybeConstructed;
 };
 …
 class SingleInit : public Initializer {
   public:
         SingleInit( Expression *value, const std::list< Expression *> &designators = std::list< Expression * >(), bool maybeConstructed = false );
+        SingleInit( Expression *value, bool maybeConstructed = false );
         SingleInit( const SingleInit &other );
         virtual ~SingleInit();
 …
         void set_value( Expression *newValue ) { value = newValue; }
-        std::list<Expression *> &get_designators() { return designators; }
-        void set_designators( std::list<Expression *> &newValue ) { designators = newValue; }
         virtual SingleInit *clone() const { return new SingleInit( *this); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 );
+        virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
         //Constant *value;
         Expression *value;      // has to be a compile-time constant
-        std::list< Expression * > designators;
 };
 …
   public:
         ListInit( const std::list<Initializer*> &initializers,
                           const std::list<Expression *> &designators = std::list< Expression * >(), bool maybeConstructed = false );
+                          const std::list<Designation *> &designators = {}, bool maybeConstructed = false );
         ListInit( const ListInit & other );
         virtual ~ListInit();
+        void set_designators( std::list<Expression *> &newValue ) { designators = newValue; }
+        std::list<Expression *> &get_designators() { return designators; }
+        void set_initializers( std::list<Initializer*> &newValue ) { initializers = newValue; }
+        std::list<Initializer*> &get_initializers() { return initializers; }
+        std::list<Designation *> & get_designations() { return designations; }
+        std::list<Initializer *> & get_initializers() { return initializers; }
         typedef std::list<Initializer*>::iterator iterator;
+        typedef std::list<Initializer*>::const_iterator const_iterator;
         iterator begin() { return initializers.begin(); }
         iterator end() { return initializers.end(); }
+        const_iterator begin() const { return initializers.begin(); }
+        const_iterator end() const { return initializers.end(); }
         virtual ListInit *clone() const { return new ListInit( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 );
+        virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
         std::list<Initializer*> initializers;  // order *is* important
         std::list<Expression *> designators;
+        std::list<Initializer *> initializers;  // order *is* important
+        std::list<Designation *> designations;  // order/length is consistent with initializers
 };
 …
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 );
+        virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
 …
 };
+std::ostream & operator<<( std::ostream & out, Initializer * init );
+std::ostream & operator<<( std::ostream & out, const Initializer * init );
+std::ostream & operator<<( std::ostream & out, const Designation * des );
 #endif // INITIALIZER_H

src/SynTree/Mutator.cc

-              r9c951e3
+              rb1e63ac5
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Mar 30 16:45:19 2017
 // Update Count     : 22
+// Last Modified By : Andrew Beach
+// Last Modified On : Thu Jun 22 13:43:00 2017
+// Update Count     : 24
 //
 …
 TypeDecl *Mutator::mutate( TypeDecl *typeDecl ) {
         handleNamedTypeDecl( typeDecl );
+        typeDecl->set_init( maybeMutate( typeDecl->get_init(), *this ) );
         return typeDecl;
+}
 …
+}
+Statement *Mutator::mutate( ThrowStmt *throwStmt ) {
+        throwStmt->set_expr( maybeMutate( throwStmt->get_expr(), *this ) );
+        throwStmt->set_target( maybeMutate( throwStmt->get_target(), *this ) );
+        return throwStmt;
+}
 Statement *Mutator::mutate( TryStmt *tryStmt ) {
         tryStmt->set_block( maybeMutate( tryStmt->get_block(), *this ) );
         mutateAll( tryStmt->get_catchers(), *this );
+        tryStmt->set_finally( maybeMutate( tryStmt->get_finally(), *this ) );
         return tryStmt;
+}
 …
 Statement *Mutator::mutate( CatchStmt *catchStmt ) {
         catchStmt->set_decl( maybeMutate( catchStmt->get_decl(), *this ) );
+        catchStmt->set_cond( maybeMutate( catchStmt->get_cond(), *this ) );
         catchStmt->set_body( maybeMutate( catchStmt->get_body(), *this ) );
         return catchStmt;
 …
+}
-Expression *Mutator::mutate( UntypedValofExpr *valofExpr ) {
-        valofExpr->set_env( maybeMutate( valofExpr->get_env(), *this ) );
-        valofExpr->set_result( maybeMutate( valofExpr->get_result(), *this ) );
-        return valofExpr;
+}
 Expression *Mutator::mutate( RangeExpr *rangeExpr ) {
         rangeExpr->set_env( maybeMutate( rangeExpr->get_env(), *this ) );
 …
         tupleExpr->set_result( maybeMutate( tupleExpr->get_result(), *this ) );
         tupleExpr->set_tuple( maybeMutate( tupleExpr->get_tuple(), *this ) );
-        return tupleExpr;
+}
-Expression *Mutator::mutate( MemberTupleExpr *tupleExpr ) {
-        tupleExpr->set_env( maybeMutate( tupleExpr->get_env(), *this ) );
-        tupleExpr->set_result( maybeMutate( tupleExpr->get_result(), *this ) );
-        tupleExpr->set_member( maybeMutate( tupleExpr->get_member(), *this ) );
-        tupleExpr->set_aggregate( maybeMutate( tupleExpr->get_aggregate(), *this ) );
         return tupleExpr;
+}
 …
+}
+Expression *Mutator::mutate( UntypedInitExpr * initExpr ) {
+        initExpr->set_env( maybeMutate( initExpr->get_env(), *this ) );
+        initExpr->set_result( maybeMutate( initExpr->get_result(), *this ) );
+        initExpr->set_expr( maybeMutate( initExpr->get_expr(), *this ) );
+        // not currently mutating initAlts, but this doesn't matter since this node is only used in the resolver.
+        return initExpr;
+}
+Expression *Mutator::mutate( InitExpr * initExpr ) {
+        initExpr->set_env( maybeMutate( initExpr->get_env(), *this ) );
+        initExpr->set_result( maybeMutate( initExpr->get_result(), *this ) );
+        initExpr->set_expr( maybeMutate( initExpr->get_expr(), *this ) );
+        initExpr->set_designation( maybeMutate( initExpr->get_designation(), *this ) );
+        return initExpr;
+}
 Type *Mutator::mutate( VoidType *voidType ) {
 …
         mutateAll( tupleType->get_forall(), *this );
         mutateAll( tupleType->get_types(), *this );
+        mutateAll( tupleType->get_members(), *this );
         return tupleType;
+}
 …
+Designation *Mutator::mutate( Designation * designation ) {
+        mutateAll( designation->get_designators(), *this );
+        return designation;
+}
 Initializer *Mutator::mutate( SingleInit *singleInit ) {
         singleInit->set_value( singleInit->get_value()->acceptMutator( *this ) );
 …
 Initializer *Mutator::mutate( ListInit *listInit ) {
         mutateAll( listInit->get_designators(), *this );
+        mutateAll( listInit->get_designations(), *this );
         mutateAll( listInit->get_initializers(), *this );
         return listInit;

src/SynTree/Mutator.h

-              r9c951e3
+              rb1e63ac5
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Feb  9 14:23:23 2017
 // Update Count     : 13
+// Last Modified By : Andrew Beach
+// Last Modified On : Thu Jun  8 15:45:00 2017
+// Update Count     : 14
 //
 #include <cassert>
 …
         virtual Statement* mutate( BranchStmt *branchStmt );
         virtual Statement* mutate( ReturnStmt *returnStmt );
+        virtual Statement* mutate( TryStmt *returnStmt );
+        virtual Statement* mutate( ThrowStmt *throwStmt );
+        virtual Statement* mutate( TryStmt *tryStmt );
         virtual Statement* mutate( CatchStmt *catchStmt );
         virtual Statement* mutate( FinallyStmt *catchStmt );
 …
         virtual Expression* mutate( ConstructorExpr *ctorExpr );
         virtual Expression* mutate( CompoundLiteralExpr *compLitExpr );
-        virtual Expression* mutate( UntypedValofExpr *valofExpr );
         virtual Expression* mutate( RangeExpr *rangeExpr );
         virtual Expression* mutate( UntypedTupleExpr *tupleExpr );
         virtual Expression* mutate( TupleExpr *tupleExpr );
         virtual Expression* mutate( TupleIndexExpr *tupleExpr );
-        virtual Expression* mutate( MemberTupleExpr *tupleExpr );
         virtual Expression* mutate( TupleAssignExpr *assignExpr );
         virtual Expression* mutate( StmtExpr * stmtExpr );
         virtual Expression* mutate( UniqueExpr * uniqueExpr );
+        virtual Expression* mutate( UntypedInitExpr * initExpr );
+        virtual Expression* mutate( InitExpr * initExpr );
         virtual Type* mutate( VoidType *basicType );
 …
         virtual Type* mutate( OneType *oneType );
+        virtual Designation* mutate( Designation *designation );
         virtual Initializer* mutate( SingleInit *singleInit );
         virtual Initializer* mutate( ListInit *listInit );

src/SynTree/ObjectDecl.cc

-              r9c951e3
+              rb1e63ac5
         if ( init ) {
                 os << " with initializer ";
                 init->print( os, indent );
                 os << std::endl << std::string(indent, ' ');
+                os << " with initializer " << std::endl;
+                init->print( os, indent+2 );
+                os << std::endl << std::string(indent+2, ' ');
                 os << "maybeConstructed? " << init->get_maybeConstructed();
         } // if

src/SynTree/Statement.cc

-              r9c951e3
+              rb1e63ac5
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Aug 12 13:58:48 2016
 // Update Count     : 62
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Jun 12 10:37:00 2017
+// Update Count     : 64
 //
 …
 Statement::Statement( std::list<Label> _labels ) : labels( _labels ) {}
 void Statement::print( std::ostream &, int indent ) const {}
+void Statement::print( __attribute__((unused)) std::ostream &, __attribute__((unused)) int indent ) const {}
 Statement::~Statement() {}
 …
+}
 ReturnStmt::ReturnStmt( std::list<Label> labels, Expression *_expr, bool throwP ) : Statement( labels ), expr( _expr ), isThrow( throwP ) {}
 ReturnStmt::ReturnStmt( const ReturnStmt & other ) : Statement( other ), expr( maybeClone( other.expr ) ), isThrow( other.isThrow ) {}
+ReturnStmt::ReturnStmt( std::list<Label> labels, Expression *_expr ) : Statement( labels ), expr( _expr ) {}
+ReturnStmt::ReturnStmt( const ReturnStmt & other ) : Statement( other ), expr( maybeClone( other.expr ) ) {}
 ReturnStmt::~ReturnStmt() {
 …
 void ReturnStmt::print( std::ostream &os, int indent ) const {
         os << string ( isThrow? "Throw":"Return" ) << " Statement, returning: ";
+        os <<  "Return Statement, returning: ";
         if ( expr != 0 ) {
                 os << endl << string( indent+2, ' ' );
 …
+}
+TryStmt::TryStmt( std::list<Label> labels, CompoundStmt *tryBlock, std::list<Statement *> &_handlers, FinallyStmt *_finallyBlock ) :
+ThrowStmt::ThrowStmt( std::list<Label> labels, Kind kind, Expression * expr, Expression * target ) :
+                Statement( labels ), kind(kind), expr(expr), target(target)     {
+        assertf(Resume == kind || nullptr == target, "Non-local termination throw is not accepted." );
+}
+ThrowStmt::ThrowStmt( const ThrowStmt &other ) :
+        Statement ( other ), kind( other.kind ), expr( maybeClone( other.expr ) ), target( maybeClone( other.target ) ) {
+}
+ThrowStmt::~ThrowStmt() {
+        delete expr;
+        delete target;
+}
+void ThrowStmt::print( std::ostream &os, int indent) const {
+        if ( target ) {
+                os << "Non-Local ";
+        }
+        os << "Throw Statement, raising: ";
+        expr->print(os, indent + 4);
+        if ( target ) {
+                os << "At: ";
+                target->print(os, indent + 4);
+        }
+}
+TryStmt::TryStmt( std::list<Label> labels, CompoundStmt *tryBlock, std::list<CatchStmt *> &_handlers, FinallyStmt *_finallyBlock ) :
         Statement( labels ), block( tryBlock ),  handlers( _handlers ), finallyBlock( _finallyBlock ) {
+}
 …
         // handlers
         os << string( indent + 2, ' ' ) << "and handlers: " << endl;
         for ( std::list<Statement *>::const_iterator i = handlers.begin(); i != handlers.end(); i++)
+        for ( std::list<CatchStmt *>::const_iterator i = handlers.begin(); i != handlers.end(); i++)
                 (*i )->print( os, indent + 4 );
 …
+}
 CatchStmt::CatchStmt( std::list<Label> labels, Declaration *_decl, Statement *_body, bool catchAny ) :
         Statement( labels ), decl ( _decl ), body( _body ), catchRest ( catchAny ) {
+CatchStmt::CatchStmt( std::list<Label> labels, Kind _kind, Declaration *_decl, Expression *_cond, Statement *_body ) :
+        Statement( labels ), kind ( _kind ), decl ( _decl ), cond ( _cond ), body( _body ) {
+}
 CatchStmt::CatchStmt( const CatchStmt & other ) :
         Statement( other ), decl ( maybeClone( other.decl ) ), body( maybeClone( other.body ) ), catchRest ( other.catchRest ) {
+        Statement( other ), kind ( other.kind ), decl ( maybeClone( other.decl ) ), cond ( maybeClone( other.cond ) ), body( maybeClone( other.body ) ) {
+}
 …
 void CatchStmt::print( std::ostream &os, int indent ) const {
         os << "Catch Statement" << endl;
+        os << "Catch " << ((Terminate == kind) ? "Terminate" : "Resume") << " Statement" << endl;
         os << string( indent, ' ' ) << "... catching" << endl;
 …
                 decl->printShort( os, indent + 4 );
                 os << endl;
+        } else if ( catchRest )
+                os << string( indent + 4 , ' ' ) << "the rest" << endl;
+        }
         else
                 os << string( indent + 4 , ' ' ) << ">>> Error:  this catch clause must have a declaration <<<" << endl;
 …
 NullStmt::NullStmt() : CompoundStmt( std::list<Label>() ) {}
 void NullStmt::print( std::ostream &os, int indent ) const {
+void NullStmt::print( std::ostream &os, __attribute__((unused)) int indent ) const {
         os << "Null Statement" << endl ;
+}

src/SynTree/Statement.h

-              r9c951e3
+              rb1e63ac5
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Aug 12 13:57:46 2016
 // Update Count     : 65
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Jun 12 13:35:00 2017
+// Update Count     : 67
 //
 …
   private:
         std::list<Statement*> kids;
+};
+class NullStmt : public CompoundStmt {
+  public:
+        NullStmt();
+        NullStmt( std::list<Label> labels );
+        virtual NullStmt *clone() const { return new NullStmt( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual NullStmt *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
 };
 …
 class ReturnStmt : public Statement {
   public:
         ReturnStmt( std::list<Label> labels, Expression *expr, bool throwP = false );
+        ReturnStmt( std::list<Label> labels, Expression *expr );
         ReturnStmt( const ReturnStmt &other );
         virtual ~ReturnStmt();
 …
   private:
         Expression *expr;
+        bool isThrow;
+};
+class NullStmt : public CompoundStmt {
+  public:
+        NullStmt();
+        NullStmt( std::list<Label> labels );
+        virtual NullStmt *clone() const { return new NullStmt( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual NullStmt *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+};
+class ThrowStmt : public Statement {
+  public:
+        enum Kind { Terminate, Resume };
+        ThrowStmt( std::list<Label> labels, Kind kind, Expression * expr, Expression * target = nullptr );
+        ThrowStmt( const ThrowStmt &other );
+        virtual ~ThrowStmt();
+        Kind get_kind() { return kind; }
+        Expression * get_expr() { return expr; }
+        void set_expr( Expression * newExpr ) { expr = newExpr; }
+        Expression * get_target() { return target; }
+        void set_target( Expression * newTarget ) { target = newTarget; }
+        virtual ThrowStmt *clone() const { return new ThrowStmt( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        Kind kind;
+        Expression * expr;
+        Expression * target;
 };
 class TryStmt : public Statement {
   public:
         TryStmt( std::list<Label> labels, CompoundStmt *tryBlock, std::list<Statement *> &handlers, FinallyStmt *finallyBlock = 0 );
+        TryStmt( std::list<Label> labels, CompoundStmt *tryBlock, std::list<CatchStmt *> &handlers, FinallyStmt *finallyBlock = 0 );
         TryStmt( const TryStmt &other );
         virtual ~TryStmt();
 …
         CompoundStmt *get_block() const { return block; }
         void set_block( CompoundStmt *newValue ) { block = newValue; }
         std::list<Statement *>& get_catchers() { return handlers; }
+        std::list<CatchStmt *>& get_catchers() { return handlers; }
         FinallyStmt *get_finally() const { return finallyBlock; }
 …
   private:
         CompoundStmt *block;
         std::list<Statement *> handlers;
+        std::list<CatchStmt *> handlers;
         FinallyStmt *finallyBlock;
 };
 …
 class CatchStmt : public Statement {
   public:
+        CatchStmt( std::list<Label> labels, Declaration *decl, Statement *body, bool catchAny = false );
+        enum Kind { Terminate, Resume };
+        CatchStmt( std::list<Label> labels, Kind kind, Declaration *decl,
+                   Expression *cond, Statement *body );
         CatchStmt( const CatchStmt &other );
         virtual ~CatchStmt();
+        Kind get_kind() { return kind; }
         Declaration *get_decl() { return decl; }
         void set_decl( Declaration *newValue ) { decl = newValue; }
+        Expression *get_cond() { return cond; }
+        void set_cond( Expression *newCond ) { cond = newCond; }
         Statement *get_body() { return body; }
         void set_body( Statement *newValue ) { body = newValue; }
 …
   private:
+        Kind kind;
         Declaration *decl;
+        Expression *cond;
         Statement *body;
-        bool catchRest;
 };

src/SynTree/SynTree.h

-              r9c951e3
+              rb1e63ac5
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Feb  9 14:23:49 2017
 // Update Count     : 8
+// Last Modified By : Andrew Beach
+// Last Modified On : Thu Jun  8 17:00:00 2017
+// Update Count     : 9
 //
 …
 class BranchStmt;
 class ReturnStmt;
+class ThrowStmt;
 class TryStmt;
 class CatchStmt;
 …
 class TupleExpr;
 class TupleIndexExpr;
-class MemberTupleExpr;
 class TupleAssignExpr;
 class StmtExpr;
 class UniqueExpr;
+class UntypedInitExpr;
+class InitExpr;
 class Type;
 …
 class OneType;
+class Designation;
 class Initializer;
 class SingleInit;

src/SynTree/TupleExpr.cc

-              r9c951e3
+              rb1e63ac5
+}
-MemberTupleExpr::MemberTupleExpr( Expression * member, Expression * aggregate, Expression * _aname ) : Expression( _aname ) {
-        set_result( maybeClone( member->get_result() ) ); // xxx - ???
+}
-MemberTupleExpr::MemberTupleExpr( const MemberTupleExpr &other ) : Expression( other ), member( other.member->clone() ), aggregate( other.aggregate->clone() ) {
+}
-MemberTupleExpr::~MemberTupleExpr() {
-        delete member;
-        delete aggregate;
+}
-void MemberTupleExpr::print( std::ostream &os, int indent ) const {
-        os << "Member Tuple Expression, with aggregate:" << std::endl;
-        os << std::string( indent+2, ' ' );
-        aggregate->print( os, indent+2 );
-        os << std::string( indent+2, ' ' ) << "with member: " << std::endl;
-        os << std::string( indent+2, ' ' );
-        member->print( os, indent+2 );
-        Expression::print( os, indent );
+}
 TupleAssignExpr::TupleAssignExpr( const std::list< Expression * > & assigns, const std::list< ObjectDecl * > & tempDecls, Expression * _aname ) : Expression( _aname ) {
         // convert internally into a StmtExpr which contains the declarations and produces the tuple of the assignments

src/SynTree/TupleType.cc

-              r9c951e3
+              rb1e63ac5
 //
+#include "Declaration.h"
+#include "Initializer.h"
 #include "Type.h"
 #include "Common/utility.h"
+#include "Parser/LinkageSpec.h"
 TupleType::TupleType( const Type::Qualifiers &tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes ) : Type( tq, attributes ), types( types ) {
+        for ( Type * t : *this ) {
+                // xxx - this is very awkward. TupleTypes should contain objects so that members can be named, but if they don't have an initializer node then
+                // they end up getting constructors, which end up being inserted causing problems. This happens because the object decls have to be visited so that
+                // their types are kept in sync with the types list here. Ultimately, the types list here should be eliminated and perhaps replaced with a list-view
+                // of the object types list, but I digress. The temporary solution here is to make a ListInit with maybeConstructed = false, that way even when the
+                // object is visited, it is never constructed. Ultimately, a better solution might be either:
+                // a) to separate TupleType from its declarations, into TupleDecl and Tuple{Inst?}Type, ala StructDecl and StructInstType
+                // b) separate initializer nodes better, e.g. add a MaybeConstructed node that is replaced by genInit, rather than what currently exists in a bool
+                members.push_back( new ObjectDecl( "" , Type::StorageClasses(), LinkageSpec::Cforall, nullptr, t->clone(), new ListInit( {}, {}, false ) ) );
+        }
+}
 TupleType::TupleType( const TupleType& other ) : Type( other ) {
         cloneAll( other.types, types );
+        cloneAll( other.members, members );
+}
 TupleType::~TupleType() {
         deleteAll( types );
+        deleteAll( members );
+}

src/SynTree/Type.h

-              r9c951e3
+              rb1e63ac5
 private:
         Type *base;
-        unsigned int level = 0;
 };
 …
         virtual void print( std::ostream & os, int indent = 0 ) const;
         virtual void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const {}
+        virtual void lookup( __attribute__((unused)) const std::string & name, __attribute__((unused)) std::list< Declaration* > & foundDecls ) const {}
   protected:
         virtual std::string typeString() const = 0;
 …
 class TupleType : public Type {
   public:
         TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types = std::list< Type * >(), const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         TupleType( const TupleType& );
         virtual ~TupleType();
 …
         typedef value_type::iterator iterator;
         std::list<Type*>& get_types() { return types; }
+        std::list<Type *> & get_types() { return types; }
         virtual unsigned size() const { return types.size(); };
+        // For now, this is entirely synthetic -- tuple types always have unnamed members.
+        // Eventually, we may allow named tuples, in which case members should subsume types
+        std::list<Declaration *> & get_members() { return members; }
         iterator begin() { return types.begin(); }
 …
         virtual void print( std::ostream & os, int indent = 0 ) const;
   private:
+        std::list<Type*> types;
+        std::list<Type *> types;
+        std::list<Declaration *> members;
 };

src/SynTree/TypeDecl.cc

-              r9c951e3
+              rb1e63ac5
 #include "Common/utility.h"
 TypeDecl::TypeDecl( const std::string &name, Type::StorageClasses scs, Type *type, Kind kind ) : Parent( name, scs, type ), kind( kind ), sized( kind == Any || kind == Ttype ) {
+TypeDecl::TypeDecl( const std::string &name, Type::StorageClasses scs, Type *type, Kind kind, Type * init ) : Parent( name, scs, type ), kind( kind ), init( init ), sized( kind == Any || kind == Ttype ) {
+}
+TypeDecl::TypeDecl( const TypeDecl &other ) : Parent( other ), kind( other.kind ), sized( other.sized ) {
+TypeDecl::TypeDecl( const TypeDecl &other ) : Parent( other ), kind( other.kind ), init( maybeClone( other.init ) ), sized( other.sized ) {
+}
+TypeDecl::~TypeDecl() {
+  delete init;
+}
 …
+}
+void TypeDecl::print( std::ostream &os, int indent ) const {
+  NamedTypeDecl::print( os, indent );
+  if ( init ) {
+    os << std::endl << std::string( indent, ' ' ) << "with type initializer: ";
+    init->print( os, indent + 2 );
+  }
+}
 std::ostream & operator<<( std::ostream & os, const TypeDecl::Data & data ) {
   return os << data.kind << ", " << data.isComplete;

src/SynTree/TypeSubstitution.cc

-              r9c951e3
+              rb1e63ac5
                         boundVars.insert( (*tyvar )->get_name() );
                 } // for
         } // if
         // bind type variables from generic type instantiations
         std::list< TypeDecl* > *baseParameters = type->get_baseParameters();
         if ( baseParameters && ! type->get_parameters().empty() ) {
                 for ( std::list< TypeDecl* >::const_iterator tyvar = baseParameters->begin(); tyvar != baseParameters->end(); ++tyvar ) {
                         boundVars.insert( (*tyvar)->get_name() );
                 } // for
+                // bind type variables from generic type instantiations
+                std::list< TypeDecl* > *baseParameters = type->get_baseParameters();
+                if ( baseParameters && ! type->get_parameters().empty() ) {
+                        for ( std::list< TypeDecl* >::const_iterator tyvar = baseParameters->begin(); tyvar != baseParameters->end(); ++tyvar ) {
+                                boundVars.insert( (*tyvar)->get_name() );
+                        } // for
+                } // if
         } // if
         Type *ret = Mutator::mutate( type );

src/SynTree/VarExprReplacer.cc

-              r9c951e3
+              rb1e63ac5
 //
+#include "Declaration.h"
 #include "Expression.h"
 #include "VarExprReplacer.h"
 VarExprReplacer::VarExprReplacer( const DeclMap & declMap ) : declMap( declMap ) {}
+VarExprReplacer::VarExprReplacer( const DeclMap & declMap, bool debug ) : declMap( declMap ), debug( debug ) {}
 // replace variable with new node from decl map
 void VarExprReplacer::visit( VariableExpr * varExpr ) {
+  // xxx - assertions and parameters aren't accounted for in this... (i.e. they aren't inserted into the map when it's made, only DeclStmts are)
+  if ( declMap.count( varExpr->get_var() ) ) {
+    varExpr->set_var( declMap.at( varExpr->get_var() ) );
+  }
+        // xxx - assertions and parameters aren't accounted for in this... (i.e. they aren't inserted into the map when it's made, only DeclStmts are)
+        if ( declMap.count( varExpr->get_var() ) ) {
+                if ( debug ) {
+                        std::cerr << "replacing variable reference: " << (void*)varExpr->get_var() << " " << varExpr->get_var() << " with " << (void*)declMap.at( varExpr->get_var() ) << " " << declMap.at( varExpr->get_var() ) << std::endl;
+                }
+                varExpr->set_var( declMap.at( varExpr->get_var() ) );
+        }
+}

src/SynTree/VarExprReplacer.h

-              r9c951e3
+              rb1e63ac5
 private:
         const DeclMap & declMap;
+  bool debug;
 public:
         VarExprReplacer( const DeclMap & declMap );
+        VarExprReplacer( const DeclMap & declMap, bool debug = false );
         // replace variable with new node from decl map

src/SynTree/Visitor.cc

-              r9c951e3
+              rb1e63ac5
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Mar 30 16:45:25 2017
 // Update Count     : 24
+// Last Modified By : Andrew Beach
+// Last Modified On : Thu Jun 22 13:41:00 2017
+// Update Count     : 26
 //
 …
 void Visitor::visit( TypeDecl *typeDecl ) {
         handleNamedTypeDecl( static_cast< NamedTypeDecl* >( typeDecl ) );
+        maybeAccept( typeDecl->get_init(), *this );
+}
 …
+}
 void Visitor::visit( BranchStmt *branchStmt ) {
+void Visitor::visit( __attribute__((unused)) BranchStmt *branchStmt ) {
+}
 void Visitor::visit( ReturnStmt *returnStmt ) {
         maybeAccept( returnStmt->get_expr(), *this );
+}
+void Visitor::visit( ThrowStmt * throwStmt ) {
+        maybeAccept( throwStmt->get_expr(), *this );
+        maybeAccept( throwStmt->get_target(), *this );
+}
 …
         maybeAccept( tryStmt->get_block(), *this );
         acceptAll( tryStmt->get_catchers(), *this );
+        maybeAccept( tryStmt->get_finally(), *this );
+}
 void Visitor::visit( CatchStmt *catchStmt ) {
         maybeAccept( catchStmt->get_decl(), *this );
+        maybeAccept( catchStmt->get_cond(), *this );
         maybeAccept( catchStmt->get_body(), *this );
+}
 …
+}
 void Visitor::visit( NullStmt *nullStmt ) {
+void Visitor::visit( __attribute__((unused)) NullStmt *nullStmt ) {
+}
 …
+}
-void Visitor::visit( UntypedValofExpr *valofExpr ) {
-        maybeAccept( valofExpr->get_result(), *this );
-        maybeAccept( valofExpr->get_body(), *this );
+}
 void Visitor::visit( RangeExpr *rangeExpr ) {
         maybeAccept( rangeExpr->get_low(), *this );
 …
         maybeAccept( tupleExpr->get_result(), *this );
         maybeAccept( tupleExpr->get_tuple(), *this );
+}
-void Visitor::visit( MemberTupleExpr *tupleExpr ) {
-        maybeAccept( tupleExpr->get_result(), *this );
-        maybeAccept( tupleExpr->get_member(), *this );
-        maybeAccept( tupleExpr->get_aggregate(), *this );
+}
 …
+}
+void Visitor::visit( UntypedInitExpr * initExpr ) {
+        maybeAccept( initExpr->get_result(), *this );
+        maybeAccept( initExpr->get_expr(), *this );
+        // not currently visiting initAlts, but this doesn't matter since this node is only used in the resolver.
+}
+void Visitor::visit( InitExpr * initExpr ) {
+        maybeAccept( initExpr->get_result(), *this );
+        maybeAccept( initExpr->get_expr(), *this );
+        maybeAccept( initExpr->get_designation(), *this );
+}
 void Visitor::visit( VoidType *voidType ) {
 …
         acceptAll( tupleType->get_forall(), *this );
         acceptAll( tupleType->get_types(), *this );
+        acceptAll( tupleType->get_members(), *this );
+}
 …
+}
+void Visitor::visit( Designation * designation ) {
+        acceptAll( designation->get_designators(), *this );
+}
 void Visitor::visit( SingleInit *singleInit ) {
 …
 void Visitor::visit( ListInit *listInit ) {
         acceptAll( listInit->get_designators(), *this );
+        acceptAll( listInit->get_designations(), *this );
         acceptAll( listInit->get_initializers(), *this );
+}
 …
 void Visitor::visit( Subrange *subrange ) {}
 void Visitor::visit( Constant *constant ) {}
+void Visitor::visit( __attribute__((unused)) Subrange *subrange ) {}
+void Visitor::visit( __attribute__((unused)) Constant *constant ) {}
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Visitor.h

-              r9c951e3
+              rb1e63ac5
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Wed May  3 08:58:00 2017
 // Update Count     : 10
+// Last Modified On : Thr Jun 08 15:45:00 2017
+// Update Count     : 11
 //
 …
         virtual void visit( BranchStmt *branchStmt );
         virtual void visit( ReturnStmt *returnStmt );
+        virtual void visit( ThrowStmt *throwStmt );
         virtual void visit( TryStmt *tryStmt );
         virtual void visit( CatchStmt *catchStmt );
 …
         virtual void visit( ConstructorExpr * ctorExpr );
         virtual void visit( CompoundLiteralExpr *compLitExpr );
-        virtual void visit( UntypedValofExpr *valofExpr );
         virtual void visit( RangeExpr *rangeExpr );
         virtual void visit( UntypedTupleExpr *tupleExpr );
         virtual void visit( TupleExpr *tupleExpr );
         virtual void visit( TupleIndexExpr *tupleExpr );
-        virtual void visit( MemberTupleExpr *tupleExpr );
         virtual void visit( TupleAssignExpr *assignExpr );
         virtual void visit( StmtExpr * stmtExpr );
         virtual void visit( UniqueExpr * uniqueExpr );
+        virtual void visit( UntypedInitExpr * initExpr );
+        virtual void visit( InitExpr * initExpr );
         virtual void visit( VoidType *basicType );
 …
         virtual void visit( OneType *oneType );
+        virtual void visit( Designation *designation );
         virtual void visit( SingleInit *singleInit );
         virtual void visit( ListInit *listInit );

src/SynTree/ZeroOneType.cc

-              r9c951e3
+              rb1e63ac5
 ZeroType::ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes ) : Type( tq, attributes ) {}
 void ZeroType::print( std::ostream &os, int indent ) const {
+void ZeroType::print( std::ostream &os, __attribute__((unused)) int indent ) const {
         os << "zero_t";
+}
 …
 OneType::OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes ) : Type( tq, attributes ) {}
 void OneType::print( std::ostream &os, int indent ) const {
+void OneType::print( std::ostream &os, __attribute__((unused)) int indent ) const {
         os << "one_t";
+}

src/Tuples/TupleExpansion.cc

-              r9c951e3
+              rb1e63ac5
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Mar 16 08:05:17 2017
 // Update Count     : 15
+// Last Modified On : Wed Jun 21 17:35:04 2017
+// Update Count     : 19
 //
 …
 #include <cassert>
 #include "Tuples.h"
+#include "Common/PassVisitor.h"
+#include "Common/ScopedMap.h"
 #include "GenPoly/DeclMutator.h"
+#include "InitTweak/GenInit.h"
+#include "InitTweak/InitTweak.h"
+#include "ResolvExpr/typeops.h"
+#include "SymTab/Mangler.h"
+#include "SynTree/Declaration.h"
+#include "SynTree/Expression.h"
+#include "SynTree/Initializer.h"
 #include "SynTree/Mutator.h"
 #include "SynTree/Statement.h"
-#include "SynTree/Declaration.h"
 #include "SynTree/Type.h"
-#include "SynTree/Expression.h"
-#include "SynTree/Initializer.h"
-#include "SymTab/Mangler.h"
-#include "Common/ScopedMap.h"
-#include "ResolvExpr/typeops.h"
-#include "InitTweak/GenInit.h"
-#include "InitTweak/InitTweak.h"
 namespace Tuples {
 …
                 };
+                class TupleIndexExpander final : public Mutator {
+                public:
+                        typedef Mutator Parent;
+                        using Parent::mutate;
+                        virtual Expression * mutate( TupleIndexExpr * tupleExpr ) override;
+                class TupleIndexExpander {
+                public:
+                        Expression * postmutate( TupleIndexExpr * tupleExpr );
                 };
 …
                 replacer.mutateDeclarationList( translationUnit );
                 TupleIndexExpander idxExpander;
+                PassVisitor<TupleIndexExpander> idxExpander;
                 mutateAll( translationUnit, idxExpander );
 …
                                 commaExpr->set_arg1( nullptr );
+                        }
                         BasicType * boolType = new BasicType( Type::Qualifiers(), BasicType::Bool );
                         ObjectDecl * finished = new ObjectDecl( toString( "_unq", id, "_finished_" ), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::Bool ), new SingleInit( new ConstantExpr( Constant( boolType->clone(), "0" ) ), noDesignators ) );
+                        ObjectDecl * finished = new ObjectDecl( toString( "_unq", id, "_finished_" ), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::Bool ),
+                                                                                                        new SingleInit( new ConstantExpr( Constant::from_int( 0 ) ) ) );
                         addDeclaration( finished );
                         // (finished ? _unq_expr_N : (_unq_expr_N = <unqExpr->get_expr()>, finished = 1, _unq_expr_N))
                         // This pattern ensures that each unique expression is evaluated once, regardless of evaluation order of the generated C code.
                         Expression * assignFinished = UntypedExpr::createAssign( new VariableExpr(finished), new ConstantExpr( Constant( boolType->clone(), "1" ) ) );
+                        Expression * assignFinished = UntypedExpr::createAssign( new VariableExpr(finished), new ConstantExpr( Constant::from_int( 1 ) ) );
                         ConditionalExpr * condExpr = new ConditionalExpr( new VariableExpr( finished ), var->clone(),
                                 new CommaExpr( new CommaExpr( assignUnq, assignFinished ), var->clone() ) );
 …
+        }
         Expression * TupleIndexExpander::mutate( TupleIndexExpr * tupleExpr ) {
                 Expression * tuple = maybeMutate( tupleExpr->get_tuple(), *this );
+        Expression * TupleIndexExpander::postmutate( TupleIndexExpr * tupleExpr ) {
+                Expression * tuple = tupleExpr->get_tuple();
                 assert( tuple );
                 tupleExpr->set_tuple( nullptr );
 …
         Type * makeTupleType( const std::list< Expression * > & exprs ) {
                 // produce the TupleType which aggregates the types of the exprs
                 TupleType *tupleType = new TupleType( Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Lvalue | Type::Atomic | Type::Mutex ) );
                 Type::Qualifiers &qualifiers = tupleType->get_qualifiers();
+                std::list< Type * > types;
+                Type::Qualifiers qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Lvalue | Type::Atomic | Type::Mutex );
                 for ( Expression * expr : exprs ) {
                         assert( expr->get_result() );
                         if ( expr->get_result()->isVoid() ) {
                                 // if the type of any expr is void, the type of the entire tuple is void
-                                delete tupleType;
                                 return new VoidType( Type::Qualifiers() );
+                        }
                         Type * type = expr->get_result()->clone();
                         tupleType->get_types().push_back( type );
+                        types.push_back( type );
                         // the qualifiers on the tuple type are the qualifiers that exist on all component types
                         qualifiers &= type->get_qualifiers();
                 } // for
                 if ( exprs.empty() ) qualifiers = Type::Qualifiers();
                 return tupleType;
+                return new TupleType( qualifiers, types );
+        }
         TypeInstType * isTtype( Type * type ) {
                 if ( TypeInstType * inst = dynamic_cast< TypeInstType * >( type ) ) {
                         if ( inst->get_baseType()->get_kind() == TypeDecl::Ttype ) {
+                        if ( inst->get_baseType() && inst->get_baseType()->get_kind() == TypeDecl::Ttype ) {
                                 return inst;
+                        }
 …
                                 maybeImpure = true;
+                        }
                         virtual void visit( UntypedExpr * untypedExpr ) { maybeImpure = true; }
+                        virtual void visit( __attribute__((unused)) UntypedExpr * untypedExpr ) { maybeImpure = true; }
                         bool maybeImpure = false;
                 };

src/driver/Makefile.am

r9c951e3	rb1e63ac5
16	16
17	17	# applies to both programs
18		AM_CXXFLAGS = -Wall -O2
	18	AM_CXXFLAGS = -Wall -O2 -g -std=c++14
19	19	if BUILD_NO_LIB
20	20	else

src/driver/Makefile.in

r9c951e3	rb1e63ac5
208	208
209	209	# applies to both programs
210		AM_CXXFLAGS = -Wall -O2 $(am__append_1) $(am__append_2) \
	210	AM_CXXFLAGS = -Wall -O2 -g -std=c++14 $(am__append_1) $(am__append_2) \
211	211	$(am__append_3)
212	212	cfa_SOURCES = cfa.cc

src/driver/cc1.cc

-              r9c951e3
+              rb1e63ac5
 void sigTermHandler( int signal ) {
+void sigTermHandler( __attribute__((unused)) int signal ) {
         if ( tmpfilefd != -1 ) {                                                        // RACE, file created ?
                 rmtmpfile();                                                                    // remove
 …
 int main( const int argc, const char * const argv[], const char * const env[] ) {
+int main( const int argc, const char * const argv[], __attribute__((unused)) const char * const env[] ) {
 #ifdef __DEBUG_H__
         for ( int i = 0; env[i] != NULL; i += 1 ) {

src/driver/cfa.cc

r9c951e3	rb1e63ac5
271	271	args[nargs] = "-ldl";
272	272	nargs += 1;
	273	args[nargs] = "-lrt";
	274	nargs += 1;
273	275	args[nargs] = "-Xlinker";
274	276	nargs += 1;

src/libcfa/Makefile.am

-              r9c951e3
+              rb1e63ac5
 ## Author           : Peter A. Buhr
 ## Created On       : Sun May 31 08:54:01 2015
 ## Last Modified By : Peter A. Buhr
 ## Last Modified On : Sun May 14 21:04:21 2017
 ## Update Count     : 214
+## Last Modified By : Andrew Beach
+## Last Modified On : Wed Jun 28 15:36:00 2017
+## Update Count     : 215
 ###############################################################################
 …
 CC = ${abs_top_srcdir}/src/driver/cfa
+headers = limits stdlib math iostream fstream iterator rational assert containers/pair containers/vector
+headers = assert fstream iostream iterator limits math rational stdlib \
+          containers/maybe containers/pair containers/result containers/vector
 # not all platforms support concurrency, add option do disable it
 …
 # not all platforms support concurrency, add option do disable it
 if BUILD_CONCURRENCY
 libsrc += concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/invoke.c
+libsrc += concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/alarm.c concurrency/invoke.c concurrency/preemption.c
 endif
 …
         ${AM_V_CC}@BACKEND_CC@ -DHAVE_CONFIG_H -I. -I../.. -O2 ${EXTRA_FLAGS} -c -o $@ $<
+libcfa_a-exception.o : exception.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_a_CFLAGS = -nodebug -O2
 libcfa_d_a_SOURCES = ${libsrc}
 libcfa_d_a_CFLAGS = -debug -O0
+libcfa_d_a_CFLAGS = -debug -O0 #No need for __CFA_DEBUG__ since we pass -debug
 stdhdr = ${shell echo stdhdr/*}

src/libcfa/Makefile.in

-              r9c951e3
+              rb1e63ac5
 # not all platforms support concurrency, add option do disable it
 @BUILD_CONCURRENCY_TRUE@am__append_4 = concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/invoke.c
+@BUILD_CONCURRENCY_TRUE@am__append_4 = concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/alarm.c concurrency/invoke.c concurrency/preemption.c
 subdir = src/libcfa
 DIST_COMMON = $(am__nobase_cfa_include_HEADERS_DIST) \
 …
 libcfa_d_a_LIBADD =
 am__libcfa_d_a_SOURCES_DIST = libcfa-prelude.c interpose.c \
+        libhdr/libdebug.c limits.c stdlib.c math.c iostream.c \
+        fstream.c iterator.c rational.c assert.c containers/pair.c \
+        containers/vector.c concurrency/coroutine.c \
+        concurrency/thread.c concurrency/kernel.c \
+        concurrency/monitor.c concurrency/CtxSwitch-@MACHINE_TYPE@.S \
+        concurrency/invoke.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 \
+        concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/alarm.c \
+        concurrency/invoke.c concurrency/preemption.c
 am__dirstamp = $(am__leading_dot)dirstamp
 @BUILD_CONCURRENCY_TRUE@am__objects_1 = concurrency/libcfa_d_a-coroutine.$(OBJEXT) \
 …
 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-kernel.$(OBJEXT) \
 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-monitor.$(OBJEXT)
+am__objects_2 = libcfa_d_a-limits.$(OBJEXT) \
+        libcfa_d_a-stdlib.$(OBJEXT) libcfa_d_a-math.$(OBJEXT) \
+        libcfa_d_a-iostream.$(OBJEXT) libcfa_d_a-fstream.$(OBJEXT) \
+        libcfa_d_a-iterator.$(OBJEXT) libcfa_d_a-rational.$(OBJEXT) \
+        libcfa_d_a-assert.$(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) \
         containers/libcfa_d_a-pair.$(OBJEXT) \
+        containers/libcfa_d_a-result.$(OBJEXT) \
         containers/libcfa_d_a-vector.$(OBJEXT) $(am__objects_1)
 @BUILD_CONCURRENCY_TRUE@am__objects_3 = concurrency/CtxSwitch-@MACHINE_TYPE@.$(OBJEXT) \
+@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-invoke.$(OBJEXT)
+@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-alarm.$(OBJEXT) \
+@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-invoke.$(OBJEXT) \
+@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-preemption.$(OBJEXT)
 am__objects_4 = libcfa_d_a-libcfa-prelude.$(OBJEXT) \
         libcfa_d_a-interpose.$(OBJEXT) \
 …
 libcfa_a_LIBADD =
 am__libcfa_a_SOURCES_DIST = libcfa-prelude.c interpose.c \
+        libhdr/libdebug.c limits.c stdlib.c math.c iostream.c \
+        fstream.c iterator.c rational.c assert.c containers/pair.c \
+        containers/vector.c concurrency/coroutine.c \
+        concurrency/thread.c concurrency/kernel.c \
+        concurrency/monitor.c concurrency/CtxSwitch-@MACHINE_TYPE@.S \
+        concurrency/invoke.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 \
+        concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/alarm.c \
+        concurrency/invoke.c concurrency/preemption.c
 @BUILD_CONCURRENCY_TRUE@am__objects_5 = concurrency/libcfa_a-coroutine.$(OBJEXT) \
 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-thread.$(OBJEXT) \
 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-kernel.$(OBJEXT) \
 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-monitor.$(OBJEXT)
+am__objects_6 = libcfa_a-limits.$(OBJEXT) libcfa_a-stdlib.$(OBJEXT) \
+        libcfa_a-math.$(OBJEXT) libcfa_a-iostream.$(OBJEXT) \
+        libcfa_a-fstream.$(OBJEXT) libcfa_a-iterator.$(OBJEXT) \
+        libcfa_a-rational.$(OBJEXT) libcfa_a-assert.$(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) \
         containers/libcfa_a-pair.$(OBJEXT) \
+        containers/libcfa_a-result.$(OBJEXT) \
         containers/libcfa_a-vector.$(OBJEXT) $(am__objects_5)
 @BUILD_CONCURRENCY_TRUE@am__objects_7 = concurrency/CtxSwitch-@MACHINE_TYPE@.$(OBJEXT) \
+@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-invoke.$(OBJEXT)
+@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-alarm.$(OBJEXT) \
+@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-invoke.$(OBJEXT) \
+@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-preemption.$(OBJEXT)
 am__objects_8 = libcfa_a-libcfa-prelude.$(OBJEXT) \
         libcfa_a-interpose.$(OBJEXT) \
 …
 DIST_SOURCES = $(am__libcfa_d_a_SOURCES_DIST) \
         $(am__libcfa_a_SOURCES_DIST)
 am__nobase_cfa_include_HEADERS_DIST = limits stdlib math iostream \
         fstream iterator rational assert containers/pair \
         containers/vector concurrency/coroutine concurrency/thread \
         concurrency/kernel concurrency/monitor ${shell echo stdhdr/*} \
         gmp concurrency/invoke.h
+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/*} gmp concurrency/invoke.h
 HEADERS = $(nobase_cfa_include_HEADERS)
 ETAGS = etags
 …
 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 = limits stdlib math iostream fstream iterator rational assert \
+        containers/pair containers/vector $(am__append_3)
+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} \
 …
 libcfa_a_CFLAGS = -nodebug -O2
 libcfa_d_a_SOURCES = ${libsrc}
 libcfa_d_a_CFLAGS = -debug -O0
+libcfa_d_a_CFLAGS = -debug -O0 #No need for __CFA_DEBUG__ since we pass -debug
 stdhdr = ${shell echo stdhdr/*}
 cfa_includedir = $(CFA_INCDIR)
 …
         @$(MKDIR_P) containers/$(DEPDIR)
         @: > containers/$(DEPDIR)/$(am__dirstamp)
+containers/libcfa_d_a-maybe.$(OBJEXT): containers/$(am__dirstamp) \
+        containers/$(DEPDIR)/$(am__dirstamp)
 containers/libcfa_d_a-pair.$(OBJEXT): containers/$(am__dirstamp) \
+        containers/$(DEPDIR)/$(am__dirstamp)
+containers/libcfa_d_a-result.$(OBJEXT): containers/$(am__dirstamp) \
         containers/$(DEPDIR)/$(am__dirstamp)
 containers/libcfa_d_a-vector.$(OBJEXT): containers/$(am__dirstamp) \
 …
         concurrency/$(am__dirstamp) \
         concurrency/$(DEPDIR)/$(am__dirstamp)
+concurrency/libcfa_d_a-alarm.$(OBJEXT): concurrency/$(am__dirstamp) \
+        concurrency/$(DEPDIR)/$(am__dirstamp)
 concurrency/libcfa_d_a-invoke.$(OBJEXT): concurrency/$(am__dirstamp) \
+        concurrency/$(DEPDIR)/$(am__dirstamp)
+concurrency/libcfa_d_a-preemption.$(OBJEXT):  \
+        concurrency/$(am__dirstamp) \
         concurrency/$(DEPDIR)/$(am__dirstamp)
 libcfa-d.a: $(libcfa_d_a_OBJECTS) $(libcfa_d_a_DEPENDENCIES) $(EXTRA_libcfa_d_a_DEPENDENCIES)
 …
 libhdr/libcfa_a-libdebug.$(OBJEXT): libhdr/$(am__dirstamp) \
         libhdr/$(DEPDIR)/$(am__dirstamp)
+containers/libcfa_a-maybe.$(OBJEXT): containers/$(am__dirstamp) \
+        containers/$(DEPDIR)/$(am__dirstamp)
 containers/libcfa_a-pair.$(OBJEXT): containers/$(am__dirstamp) \
+        containers/$(DEPDIR)/$(am__dirstamp)
+containers/libcfa_a-result.$(OBJEXT): containers/$(am__dirstamp) \
         containers/$(DEPDIR)/$(am__dirstamp)
 containers/libcfa_a-vector.$(OBJEXT): containers/$(am__dirstamp) \
 …
 concurrency/libcfa_a-monitor.$(OBJEXT): concurrency/$(am__dirstamp) \
         concurrency/$(DEPDIR)/$(am__dirstamp)
+concurrency/libcfa_a-alarm.$(OBJEXT): concurrency/$(am__dirstamp) \
+        concurrency/$(DEPDIR)/$(am__dirstamp)
 concurrency/libcfa_a-invoke.$(OBJEXT): concurrency/$(am__dirstamp) \
+        concurrency/$(DEPDIR)/$(am__dirstamp)
+concurrency/libcfa_a-preemption.$(OBJEXT):  \
+        concurrency/$(am__dirstamp) \
         concurrency/$(DEPDIR)/$(am__dirstamp)
 libcfa.a: $(libcfa_a_OBJECTS) $(libcfa_a_DEPENDENCIES) $(EXTRA_libcfa_a_DEPENDENCIES)
 …
         -rm -f *.$(OBJEXT)
         -rm -f concurrency/CtxSwitch-@MACHINE_TYPE@.$(OBJEXT)
+        -rm -f concurrency/libcfa_a-alarm.$(OBJEXT)
         -rm -f concurrency/libcfa_a-coroutine.$(OBJEXT)
         -rm -f concurrency/libcfa_a-invoke.$(OBJEXT)
         -rm -f concurrency/libcfa_a-kernel.$(OBJEXT)
         -rm -f concurrency/libcfa_a-monitor.$(OBJEXT)
+        -rm -f concurrency/libcfa_a-preemption.$(OBJEXT)
         -rm -f concurrency/libcfa_a-thread.$(OBJEXT)
+        -rm -f concurrency/libcfa_d_a-alarm.$(OBJEXT)
         -rm -f concurrency/libcfa_d_a-coroutine.$(OBJEXT)
         -rm -f concurrency/libcfa_d_a-invoke.$(OBJEXT)
         -rm -f concurrency/libcfa_d_a-kernel.$(OBJEXT)
         -rm -f concurrency/libcfa_d_a-monitor.$(OBJEXT)
+        -rm -f concurrency/libcfa_d_a-preemption.$(OBJEXT)
         -rm -f concurrency/libcfa_d_a-thread.$(OBJEXT)
+        -rm -f containers/libcfa_a-maybe.$(OBJEXT)
         -rm -f containers/libcfa_a-pair.$(OBJEXT)
+        -rm -f containers/libcfa_a-result.$(OBJEXT)
         -rm -f containers/libcfa_a-vector.$(OBJEXT)
+        -rm -f containers/libcfa_d_a-maybe.$(OBJEXT)
         -rm -f containers/libcfa_d_a-pair.$(OBJEXT)
+        -rm -f containers/libcfa_d_a-result.$(OBJEXT)
         -rm -f containers/libcfa_d_a-vector.$(OBJEXT)
         -rm -f libhdr/libcfa_a-libdebug.$(OBJEXT)
 …
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-stdlib.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@
 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-coroutine.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-invoke.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-kernel.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-monitor.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-preemption.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-thread.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-alarm.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-coroutine.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-invoke.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-kernel.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-monitor.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-preemption.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-thread.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@containers/$(DEPDIR)/libcfa_a-maybe.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@containers/$(DEPDIR)/libcfa_a-pair.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@containers/$(DEPDIR)/libcfa_a-result.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@containers/$(DEPDIR)/libcfa_a-vector.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@containers/$(DEPDIR)/libcfa_d_a-maybe.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@containers/$(DEPDIR)/libcfa_d_a-pair.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@containers/$(DEPDIR)/libcfa_d_a-result.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@containers/$(DEPDIR)/libcfa_d_a-vector.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@libhdr/$(DEPDIR)/libcfa_a-libdebug.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_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-fstream.Tpo $(DEPDIR)/libcfa_d_a-fstream.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='fstream.c' object='libcfa_d_a-fstream.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-fstream.o `test -f 'fstream.c' || echo '$(srcdir)/'`fstream.c
+libcfa_d_a-fstream.obj: 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.obj -MD -MP -MF $(DEPDIR)/libcfa_d_a-fstream.Tpo -c -o libcfa_d_a-fstream.obj `if test -f 'fstream.c'; then $(CYGPATH_W) 'fstream.c'; else $(CYGPATH_W) '$(srcdir)/fstream.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-fstream.Tpo $(DEPDIR)/libcfa_d_a-fstream.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='fstream.c' object='libcfa_d_a-fstream.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-fstream.obj `if test -f 'fstream.c'; then $(CYGPATH_W) 'fstream.c'; else $(CYGPATH_W) '$(srcdir)/fstream.c'; fi`
+libcfa_d_a-iostream.o: iostream.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-iostream.o -MD -MP -MF $(DEPDIR)/libcfa_d_a-iostream.Tpo -c -o libcfa_d_a-iostream.o `test -f 'iostream.c' || echo '$(srcdir)/'`iostream.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-iostream.Tpo $(DEPDIR)/libcfa_d_a-iostream.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='iostream.c' object='libcfa_d_a-iostream.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-iostream.o `test -f 'iostream.c' || echo '$(srcdir)/'`iostream.c
+libcfa_d_a-iostream.obj: iostream.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-iostream.obj -MD -MP -MF $(DEPDIR)/libcfa_d_a-iostream.Tpo -c -o libcfa_d_a-iostream.obj `if test -f 'iostream.c'; then $(CYGPATH_W) 'iostream.c'; else $(CYGPATH_W) '$(srcdir)/iostream.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-iostream.Tpo $(DEPDIR)/libcfa_d_a-iostream.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='iostream.c' object='libcfa_d_a-iostream.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-iostream.obj `if test -f 'iostream.c'; then $(CYGPATH_W) 'iostream.c'; else $(CYGPATH_W) '$(srcdir)/iostream.c'; fi`
+libcfa_d_a-iterator.o: iterator.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-iterator.o -MD -MP -MF $(DEPDIR)/libcfa_d_a-iterator.Tpo -c -o libcfa_d_a-iterator.o `test -f 'iterator.c' || echo '$(srcdir)/'`iterator.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-iterator.Tpo $(DEPDIR)/libcfa_d_a-iterator.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='iterator.c' object='libcfa_d_a-iterator.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-iterator.o `test -f 'iterator.c' || echo '$(srcdir)/'`iterator.c
+libcfa_d_a-iterator.obj: iterator.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-iterator.obj -MD -MP -MF $(DEPDIR)/libcfa_d_a-iterator.Tpo -c -o libcfa_d_a-iterator.obj `if test -f 'iterator.c'; then $(CYGPATH_W) 'iterator.c'; else $(CYGPATH_W) '$(srcdir)/iterator.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-iterator.Tpo $(DEPDIR)/libcfa_d_a-iterator.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='iterator.c' object='libcfa_d_a-iterator.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-iterator.obj `if test -f 'iterator.c'; then $(CYGPATH_W) 'iterator.c'; else $(CYGPATH_W) '$(srcdir)/iterator.c'; fi`
 libcfa_d_a-limits.o: limits.c
 @am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-limits.o -MD -MP -MF $(DEPDIR)/libcfa_d_a-limits.Tpo -c -o libcfa_d_a-limits.o `test -f 'limits.c' || echo '$(srcdir)/'`limits.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_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-rational.Tpo $(DEPDIR)/libcfa_d_a-rational.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='rational.c' object='libcfa_d_a-rational.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-rational.o `test -f 'rational.c' || echo '$(srcdir)/'`rational.c
+libcfa_d_a-rational.obj: 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.obj -MD -MP -MF $(DEPDIR)/libcfa_d_a-rational.Tpo -c -o libcfa_d_a-rational.obj `if test -f 'rational.c'; then $(CYGPATH_W) 'rational.c'; else $(CYGPATH_W) '$(srcdir)/rational.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-rational.Tpo $(DEPDIR)/libcfa_d_a-rational.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='rational.c' object='libcfa_d_a-rational.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-rational.obj `if test -f 'rational.c'; then $(CYGPATH_W) 'rational.c'; else $(CYGPATH_W) '$(srcdir)/rational.c'; fi`
 libcfa_d_a-stdlib.o: stdlib.c
 @am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-stdlib.o -MD -MP -MF $(DEPDIR)/libcfa_d_a-stdlib.Tpo -c -o libcfa_d_a-stdlib.o `test -f 'stdlib.c' || echo '$(srcdir)/'`stdlib.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-stdlib.obj `if test -f 'stdlib.c'; then $(CYGPATH_W) 'stdlib.c'; else $(CYGPATH_W) '$(srcdir)/stdlib.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-iostream.o: iostream.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-iostream.o -MD -MP -MF $(DEPDIR)/libcfa_d_a-iostream.Tpo -c -o libcfa_d_a-iostream.o `test -f 'iostream.c' || echo '$(srcdir)/'`iostream.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-iostream.Tpo $(DEPDIR)/libcfa_d_a-iostream.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='iostream.c' object='libcfa_d_a-iostream.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-iostream.o `test -f 'iostream.c' || echo '$(srcdir)/'`iostream.c
+libcfa_d_a-iostream.obj: iostream.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-iostream.obj -MD -MP -MF $(DEPDIR)/libcfa_d_a-iostream.Tpo -c -o libcfa_d_a-iostream.obj `if test -f 'iostream.c'; then $(CYGPATH_W) 'iostream.c'; else $(CYGPATH_W) '$(srcdir)/iostream.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-iostream.Tpo $(DEPDIR)/libcfa_d_a-iostream.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='iostream.c' object='libcfa_d_a-iostream.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-iostream.obj `if test -f 'iostream.c'; then $(CYGPATH_W) 'iostream.c'; else $(CYGPATH_W) '$(srcdir)/iostream.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_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-fstream.Tpo $(DEPDIR)/libcfa_d_a-fstream.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='fstream.c' object='libcfa_d_a-fstream.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-fstream.o `test -f 'fstream.c' || echo '$(srcdir)/'`fstream.c
+libcfa_d_a-fstream.obj: 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.obj -MD -MP -MF $(DEPDIR)/libcfa_d_a-fstream.Tpo -c -o libcfa_d_a-fstream.obj `if test -f 'fstream.c'; then $(CYGPATH_W) 'fstream.c'; else $(CYGPATH_W) '$(srcdir)/fstream.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-fstream.Tpo $(DEPDIR)/libcfa_d_a-fstream.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='fstream.c' object='libcfa_d_a-fstream.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-fstream.obj `if test -f 'fstream.c'; then $(CYGPATH_W) 'fstream.c'; else $(CYGPATH_W) '$(srcdir)/fstream.c'; fi`
+libcfa_d_a-iterator.o: iterator.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-iterator.o -MD -MP -MF $(DEPDIR)/libcfa_d_a-iterator.Tpo -c -o libcfa_d_a-iterator.o `test -f 'iterator.c' || echo '$(srcdir)/'`iterator.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-iterator.Tpo $(DEPDIR)/libcfa_d_a-iterator.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='iterator.c' object='libcfa_d_a-iterator.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-iterator.o `test -f 'iterator.c' || echo '$(srcdir)/'`iterator.c
+libcfa_d_a-iterator.obj: iterator.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-iterator.obj -MD -MP -MF $(DEPDIR)/libcfa_d_a-iterator.Tpo -c -o libcfa_d_a-iterator.obj `if test -f 'iterator.c'; then $(CYGPATH_W) 'iterator.c'; else $(CYGPATH_W) '$(srcdir)/iterator.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-iterator.Tpo $(DEPDIR)/libcfa_d_a-iterator.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='iterator.c' object='libcfa_d_a-iterator.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-iterator.obj `if test -f 'iterator.c'; then $(CYGPATH_W) 'iterator.c'; else $(CYGPATH_W) '$(srcdir)/iterator.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_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-rational.Tpo $(DEPDIR)/libcfa_d_a-rational.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='rational.c' object='libcfa_d_a-rational.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-rational.o `test -f 'rational.c' || echo '$(srcdir)/'`rational.c
+libcfa_d_a-rational.obj: 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.obj -MD -MP -MF $(DEPDIR)/libcfa_d_a-rational.Tpo -c -o libcfa_d_a-rational.obj `if test -f 'rational.c'; then $(CYGPATH_W) 'rational.c'; else $(CYGPATH_W) '$(srcdir)/rational.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-rational.Tpo $(DEPDIR)/libcfa_d_a-rational.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='rational.c' object='libcfa_d_a-rational.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-rational.obj `if test -f 'rational.c'; then $(CYGPATH_W) 'rational.c'; else $(CYGPATH_W) '$(srcdir)/rational.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`
+containers/libcfa_d_a-maybe.o: containers/maybe.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT containers/libcfa_d_a-maybe.o -MD -MP -MF containers/$(DEPDIR)/libcfa_d_a-maybe.Tpo -c -o containers/libcfa_d_a-maybe.o `test -f 'containers/maybe.c' || echo '$(srcdir)/'`containers/maybe.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) containers/$(DEPDIR)/libcfa_d_a-maybe.Tpo containers/$(DEPDIR)/libcfa_d_a-maybe.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='containers/maybe.c' object='containers/libcfa_d_a-maybe.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 containers/libcfa_d_a-maybe.o `test -f 'containers/maybe.c' || echo '$(srcdir)/'`containers/maybe.c
+containers/libcfa_d_a-maybe.obj: containers/maybe.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT containers/libcfa_d_a-maybe.obj -MD -MP -MF containers/$(DEPDIR)/libcfa_d_a-maybe.Tpo -c -o containers/libcfa_d_a-maybe.obj `if test -f 'containers/maybe.c'; then $(CYGPATH_W) 'containers/maybe.c'; else $(CYGPATH_W) '$(srcdir)/containers/maybe.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) containers/$(DEPDIR)/libcfa_d_a-maybe.Tpo containers/$(DEPDIR)/libcfa_d_a-maybe.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='containers/maybe.c' object='containers/libcfa_d_a-maybe.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 containers/libcfa_d_a-maybe.obj `if test -f 'containers/maybe.c'; then $(CYGPATH_W) 'containers/maybe.c'; else $(CYGPATH_W) '$(srcdir)/containers/maybe.c'; fi`
 containers/libcfa_d_a-pair.o: containers/pair.c
 …
 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o containers/libcfa_d_a-pair.obj `if test -f 'containers/pair.c'; then $(CYGPATH_W) 'containers/pair.c'; else $(CYGPATH_W) '$(srcdir)/containers/pair.c'; fi`
+containers/libcfa_d_a-result.o: containers/result.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT containers/libcfa_d_a-result.o -MD -MP -MF containers/$(DEPDIR)/libcfa_d_a-result.Tpo -c -o containers/libcfa_d_a-result.o `test -f 'containers/result.c' || echo '$(srcdir)/'`containers/result.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) containers/$(DEPDIR)/libcfa_d_a-result.Tpo containers/$(DEPDIR)/libcfa_d_a-result.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='containers/result.c' object='containers/libcfa_d_a-result.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 containers/libcfa_d_a-result.o `test -f 'containers/result.c' || echo '$(srcdir)/'`containers/result.c
+containers/libcfa_d_a-result.obj: containers/result.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT containers/libcfa_d_a-result.obj -MD -MP -MF containers/$(DEPDIR)/libcfa_d_a-result.Tpo -c -o containers/libcfa_d_a-result.obj `if test -f 'containers/result.c'; then $(CYGPATH_W) 'containers/result.c'; else $(CYGPATH_W) '$(srcdir)/containers/result.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) containers/$(DEPDIR)/libcfa_d_a-result.Tpo containers/$(DEPDIR)/libcfa_d_a-result.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='containers/result.c' object='containers/libcfa_d_a-result.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 containers/libcfa_d_a-result.obj `if test -f 'containers/result.c'; then $(CYGPATH_W) 'containers/result.c'; else $(CYGPATH_W) '$(srcdir)/containers/result.c'; fi`
 containers/libcfa_d_a-vector.o: containers/vector.c
 @am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT containers/libcfa_d_a-vector.o -MD -MP -MF containers/$(DEPDIR)/libcfa_d_a-vector.Tpo -c -o containers/libcfa_d_a-vector.o `test -f 'containers/vector.c' || echo '$(srcdir)/'`containers/vector.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`
+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_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-alarm.Tpo concurrency/$(DEPDIR)/libcfa_d_a-alarm.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/alarm.c' object='concurrency/libcfa_d_a-alarm.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 concurrency/libcfa_d_a-alarm.o `test -f 'concurrency/alarm.c' || echo '$(srcdir)/'`concurrency/alarm.c
+concurrency/libcfa_d_a-alarm.obj: 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.obj -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-alarm.Tpo -c -o concurrency/libcfa_d_a-alarm.obj `if test -f 'concurrency/alarm.c'; then $(CYGPATH_W) 'concurrency/alarm.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/alarm.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-alarm.Tpo concurrency/$(DEPDIR)/libcfa_d_a-alarm.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/alarm.c' object='concurrency/libcfa_d_a-alarm.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 concurrency/libcfa_d_a-alarm.obj `if test -f 'concurrency/alarm.c'; then $(CYGPATH_W) 'concurrency/alarm.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/alarm.c'; fi`
 concurrency/libcfa_d_a-invoke.obj: concurrency/invoke.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-invoke.obj -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-invoke.Tpo -c -o concurrency/libcfa_d_a-invoke.obj `if test -f 'concurrency/invoke.c'; then $(CYGPATH_W) 'concurrency/invoke.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/invoke.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 concurrency/libcfa_d_a-invoke.obj `if test -f 'concurrency/invoke.c'; then $(CYGPATH_W) 'concurrency/invoke.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/invoke.c'; fi`
+concurrency/libcfa_d_a-preemption.o: concurrency/preemption.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-preemption.o -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-preemption.Tpo -c -o concurrency/libcfa_d_a-preemption.o `test -f 'concurrency/preemption.c' || echo '$(srcdir)/'`concurrency/preemption.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-preemption.Tpo concurrency/$(DEPDIR)/libcfa_d_a-preemption.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/preemption.c' object='concurrency/libcfa_d_a-preemption.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 concurrency/libcfa_d_a-preemption.o `test -f 'concurrency/preemption.c' || echo '$(srcdir)/'`concurrency/preemption.c
+concurrency/libcfa_d_a-preemption.obj: concurrency/preemption.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-preemption.obj -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-preemption.Tpo -c -o concurrency/libcfa_d_a-preemption.obj `if test -f 'concurrency/preemption.c'; then $(CYGPATH_W) 'concurrency/preemption.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/preemption.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-preemption.Tpo concurrency/$(DEPDIR)/libcfa_d_a-preemption.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/preemption.c' object='concurrency/libcfa_d_a-preemption.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 concurrency/libcfa_d_a-preemption.obj `if test -f 'concurrency/preemption.c'; then $(CYGPATH_W) 'concurrency/preemption.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/preemption.c'; fi`
 libcfa_a-libcfa-prelude.obj: libcfa-prelude.c
 @am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-libcfa-prelude.obj -MD -MP -MF $(DEPDIR)/libcfa_a-libcfa-prelude.Tpo -c -o libcfa_a-libcfa-prelude.obj `if test -f 'libcfa-prelude.c'; then $(CYGPATH_W) 'libcfa-prelude.c'; else $(CYGPATH_W) '$(srcdir)/libcfa-prelude.c'; fi`
 …
 @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_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-fstream.Tpo $(DEPDIR)/libcfa_a-fstream.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='fstream.c' object='libcfa_a-fstream.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-fstream.o `test -f 'fstream.c' || echo '$(srcdir)/'`fstream.c
+libcfa_a-fstream.obj: fstream.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-fstream.obj -MD -MP -MF $(DEPDIR)/libcfa_a-fstream.Tpo -c -o libcfa_a-fstream.obj `if test -f 'fstream.c'; then $(CYGPATH_W) 'fstream.c'; else $(CYGPATH_W) '$(srcdir)/fstream.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-fstream.Tpo $(DEPDIR)/libcfa_a-fstream.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='fstream.c' object='libcfa_a-fstream.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-fstream.obj `if test -f 'fstream.c'; then $(CYGPATH_W) 'fstream.c'; else $(CYGPATH_W) '$(srcdir)/fstream.c'; fi`
+libcfa_a-iostream.o: iostream.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-iostream.o -MD -MP -MF $(DEPDIR)/libcfa_a-iostream.Tpo -c -o libcfa_a-iostream.o `test -f 'iostream.c' || echo '$(srcdir)/'`iostream.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-iostream.Tpo $(DEPDIR)/libcfa_a-iostream.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='iostream.c' object='libcfa_a-iostream.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-iostream.o `test -f 'iostream.c' || echo '$(srcdir)/'`iostream.c
+libcfa_a-iostream.obj: iostream.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-iostream.obj -MD -MP -MF $(DEPDIR)/libcfa_a-iostream.Tpo -c -o libcfa_a-iostream.obj `if test -f 'iostream.c'; then $(CYGPATH_W) 'iostream.c'; else $(CYGPATH_W) '$(srcdir)/iostream.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-iostream.Tpo $(DEPDIR)/libcfa_a-iostream.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='iostream.c' object='libcfa_a-iostream.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-iostream.obj `if test -f 'iostream.c'; then $(CYGPATH_W) 'iostream.c'; else $(CYGPATH_W) '$(srcdir)/iostream.c'; fi`
+libcfa_a-iterator.o: iterator.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-iterator.o -MD -MP -MF $(DEPDIR)/libcfa_a-iterator.Tpo -c -o libcfa_a-iterator.o `test -f 'iterator.c' || echo '$(srcdir)/'`iterator.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-iterator.Tpo $(DEPDIR)/libcfa_a-iterator.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='iterator.c' object='libcfa_a-iterator.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-iterator.o `test -f 'iterator.c' || echo '$(srcdir)/'`iterator.c
+libcfa_a-iterator.obj: iterator.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-iterator.obj -MD -MP -MF $(DEPDIR)/libcfa_a-iterator.Tpo -c -o libcfa_a-iterator.obj `if test -f 'iterator.c'; then $(CYGPATH_W) 'iterator.c'; else $(CYGPATH_W) '$(srcdir)/iterator.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-iterator.Tpo $(DEPDIR)/libcfa_a-iterator.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='iterator.c' object='libcfa_a-iterator.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-iterator.obj `if test -f 'iterator.c'; then $(CYGPATH_W) 'iterator.c'; else $(CYGPATH_W) '$(srcdir)/iterator.c'; fi`
 libcfa_a-limits.o: limits.c
 @am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-limits.o -MD -MP -MF $(DEPDIR)/libcfa_a-limits.Tpo -c -o libcfa_a-limits.o `test -f 'limits.c' || echo '$(srcdir)/'`limits.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_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-rational.Tpo $(DEPDIR)/libcfa_a-rational.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='rational.c' object='libcfa_a-rational.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-rational.o `test -f 'rational.c' || echo '$(srcdir)/'`rational.c
+libcfa_a-rational.obj: rational.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-rational.obj -MD -MP -MF $(DEPDIR)/libcfa_a-rational.Tpo -c -o libcfa_a-rational.obj `if test -f 'rational.c'; then $(CYGPATH_W) 'rational.c'; else $(CYGPATH_W) '$(srcdir)/rational.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-rational.Tpo $(DEPDIR)/libcfa_a-rational.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='rational.c' object='libcfa_a-rational.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-rational.obj `if test -f 'rational.c'; then $(CYGPATH_W) 'rational.c'; else $(CYGPATH_W) '$(srcdir)/rational.c'; fi`
 libcfa_a-stdlib.o: stdlib.c
 @am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-stdlib.o -MD -MP -MF $(DEPDIR)/libcfa_a-stdlib.Tpo -c -o libcfa_a-stdlib.o `test -f 'stdlib.c' || echo '$(srcdir)/'`stdlib.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-stdlib.obj `if test -f 'stdlib.c'; then $(CYGPATH_W) 'stdlib.c'; else $(CYGPATH_W) '$(srcdir)/stdlib.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-iostream.o: iostream.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-iostream.o -MD -MP -MF $(DEPDIR)/libcfa_a-iostream.Tpo -c -o libcfa_a-iostream.o `test -f 'iostream.c' || echo '$(srcdir)/'`iostream.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-iostream.Tpo $(DEPDIR)/libcfa_a-iostream.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='iostream.c' object='libcfa_a-iostream.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-iostream.o `test -f 'iostream.c' || echo '$(srcdir)/'`iostream.c
+libcfa_a-iostream.obj: iostream.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-iostream.obj -MD -MP -MF $(DEPDIR)/libcfa_a-iostream.Tpo -c -o libcfa_a-iostream.obj `if test -f 'iostream.c'; then $(CYGPATH_W) 'iostream.c'; else $(CYGPATH_W) '$(srcdir)/iostream.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-iostream.Tpo $(DEPDIR)/libcfa_a-iostream.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='iostream.c' object='libcfa_a-iostream.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-iostream.obj `if test -f 'iostream.c'; then $(CYGPATH_W) 'iostream.c'; else $(CYGPATH_W) '$(srcdir)/iostream.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_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-fstream.Tpo $(DEPDIR)/libcfa_a-fstream.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='fstream.c' object='libcfa_a-fstream.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-fstream.o `test -f 'fstream.c' || echo '$(srcdir)/'`fstream.c
+libcfa_a-fstream.obj: fstream.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-fstream.obj -MD -MP -MF $(DEPDIR)/libcfa_a-fstream.Tpo -c -o libcfa_a-fstream.obj `if test -f 'fstream.c'; then $(CYGPATH_W) 'fstream.c'; else $(CYGPATH_W) '$(srcdir)/fstream.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-fstream.Tpo $(DEPDIR)/libcfa_a-fstream.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='fstream.c' object='libcfa_a-fstream.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-fstream.obj `if test -f 'fstream.c'; then $(CYGPATH_W) 'fstream.c'; else $(CYGPATH_W) '$(srcdir)/fstream.c'; fi`
+libcfa_a-iterator.o: iterator.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-iterator.o -MD -MP -MF $(DEPDIR)/libcfa_a-iterator.Tpo -c -o libcfa_a-iterator.o `test -f 'iterator.c' || echo '$(srcdir)/'`iterator.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-iterator.Tpo $(DEPDIR)/libcfa_a-iterator.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='iterator.c' object='libcfa_a-iterator.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-iterator.o `test -f 'iterator.c' || echo '$(srcdir)/'`iterator.c
+libcfa_a-iterator.obj: iterator.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-iterator.obj -MD -MP -MF $(DEPDIR)/libcfa_a-iterator.Tpo -c -o libcfa_a-iterator.obj `if test -f 'iterator.c'; then $(CYGPATH_W) 'iterator.c'; else $(CYGPATH_W) '$(srcdir)/iterator.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-iterator.Tpo $(DEPDIR)/libcfa_a-iterator.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='iterator.c' object='libcfa_a-iterator.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-iterator.obj `if test -f 'iterator.c'; then $(CYGPATH_W) 'iterator.c'; else $(CYGPATH_W) '$(srcdir)/iterator.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_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-rational.Tpo $(DEPDIR)/libcfa_a-rational.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='rational.c' object='libcfa_a-rational.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-rational.o `test -f 'rational.c' || echo '$(srcdir)/'`rational.c
+libcfa_a-rational.obj: rational.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-rational.obj -MD -MP -MF $(DEPDIR)/libcfa_a-rational.Tpo -c -o libcfa_a-rational.obj `if test -f 'rational.c'; then $(CYGPATH_W) 'rational.c'; else $(CYGPATH_W) '$(srcdir)/rational.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-rational.Tpo $(DEPDIR)/libcfa_a-rational.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='rational.c' object='libcfa_a-rational.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-rational.obj `if test -f 'rational.c'; then $(CYGPATH_W) 'rational.c'; else $(CYGPATH_W) '$(srcdir)/rational.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`
+containers/libcfa_a-maybe.o: containers/maybe.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT containers/libcfa_a-maybe.o -MD -MP -MF containers/$(DEPDIR)/libcfa_a-maybe.Tpo -c -o containers/libcfa_a-maybe.o `test -f 'containers/maybe.c' || echo '$(srcdir)/'`containers/maybe.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) containers/$(DEPDIR)/libcfa_a-maybe.Tpo containers/$(DEPDIR)/libcfa_a-maybe.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='containers/maybe.c' object='containers/libcfa_a-maybe.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 containers/libcfa_a-maybe.o `test -f 'containers/maybe.c' || echo '$(srcdir)/'`containers/maybe.c
+containers/libcfa_a-maybe.obj: containers/maybe.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT containers/libcfa_a-maybe.obj -MD -MP -MF containers/$(DEPDIR)/libcfa_a-maybe.Tpo -c -o containers/libcfa_a-maybe.obj `if test -f 'containers/maybe.c'; then $(CYGPATH_W) 'containers/maybe.c'; else $(CYGPATH_W) '$(srcdir)/containers/maybe.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) containers/$(DEPDIR)/libcfa_a-maybe.Tpo containers/$(DEPDIR)/libcfa_a-maybe.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='containers/maybe.c' object='containers/libcfa_a-maybe.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 containers/libcfa_a-maybe.obj `if test -f 'containers/maybe.c'; then $(CYGPATH_W) 'containers/maybe.c'; else $(CYGPATH_W) '$(srcdir)/containers/maybe.c'; fi`
 containers/libcfa_a-pair.o: containers/pair.c
 …
 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o containers/libcfa_a-pair.obj `if test -f 'containers/pair.c'; then $(CYGPATH_W) 'containers/pair.c'; else $(CYGPATH_W) '$(srcdir)/containers/pair.c'; fi`
+containers/libcfa_a-result.o: containers/result.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT containers/libcfa_a-result.o -MD -MP -MF containers/$(DEPDIR)/libcfa_a-result.Tpo -c -o containers/libcfa_a-result.o `test -f 'containers/result.c' || echo '$(srcdir)/'`containers/result.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) containers/$(DEPDIR)/libcfa_a-result.Tpo containers/$(DEPDIR)/libcfa_a-result.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='containers/result.c' object='containers/libcfa_a-result.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 containers/libcfa_a-result.o `test -f 'containers/result.c' || echo '$(srcdir)/'`containers/result.c
+containers/libcfa_a-result.obj: containers/result.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT containers/libcfa_a-result.obj -MD -MP -MF containers/$(DEPDIR)/libcfa_a-result.Tpo -c -o containers/libcfa_a-result.obj `if test -f 'containers/result.c'; then $(CYGPATH_W) 'containers/result.c'; else $(CYGPATH_W) '$(srcdir)/containers/result.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) containers/$(DEPDIR)/libcfa_a-result.Tpo containers/$(DEPDIR)/libcfa_a-result.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='containers/result.c' object='containers/libcfa_a-result.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 containers/libcfa_a-result.obj `if test -f 'containers/result.c'; then $(CYGPATH_W) 'containers/result.c'; else $(CYGPATH_W) '$(srcdir)/containers/result.c'; fi`
 containers/libcfa_a-vector.o: containers/vector.c
 @am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT containers/libcfa_a-vector.o -MD -MP -MF containers/$(DEPDIR)/libcfa_a-vector.Tpo -c -o containers/libcfa_a-vector.o `test -f 'containers/vector.c' || echo '$(srcdir)/'`containers/vector.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`
+concurrency/libcfa_a-alarm.o: concurrency/alarm.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_a-alarm.o -MD -MP -MF concurrency/$(DEPDIR)/libcfa_a-alarm.Tpo -c -o concurrency/libcfa_a-alarm.o `test -f 'concurrency/alarm.c' || echo '$(srcdir)/'`concurrency/alarm.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-alarm.Tpo concurrency/$(DEPDIR)/libcfa_a-alarm.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/alarm.c' object='concurrency/libcfa_a-alarm.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 concurrency/libcfa_a-alarm.o `test -f 'concurrency/alarm.c' || echo '$(srcdir)/'`concurrency/alarm.c
+concurrency/libcfa_a-alarm.obj: concurrency/alarm.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_a-alarm.obj -MD -MP -MF concurrency/$(DEPDIR)/libcfa_a-alarm.Tpo -c -o concurrency/libcfa_a-alarm.obj `if test -f 'concurrency/alarm.c'; then $(CYGPATH_W) 'concurrency/alarm.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/alarm.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-alarm.Tpo concurrency/$(DEPDIR)/libcfa_a-alarm.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/alarm.c' object='concurrency/libcfa_a-alarm.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 concurrency/libcfa_a-alarm.obj `if test -f 'concurrency/alarm.c'; then $(CYGPATH_W) 'concurrency/alarm.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/alarm.c'; fi`
 concurrency/libcfa_a-invoke.obj: concurrency/invoke.c
 @am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_a-invoke.obj -MD -MP -MF concurrency/$(DEPDIR)/libcfa_a-invoke.Tpo -c -o concurrency/libcfa_a-invoke.obj `if test -f 'concurrency/invoke.c'; then $(CYGPATH_W) 'concurrency/invoke.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/invoke.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 concurrency/libcfa_a-invoke.obj `if test -f 'concurrency/invoke.c'; then $(CYGPATH_W) 'concurrency/invoke.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/invoke.c'; fi`
+concurrency/libcfa_a-preemption.o: concurrency/preemption.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_a-preemption.o -MD -MP -MF concurrency/$(DEPDIR)/libcfa_a-preemption.Tpo -c -o concurrency/libcfa_a-preemption.o `test -f 'concurrency/preemption.c' || echo '$(srcdir)/'`concurrency/preemption.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-preemption.Tpo concurrency/$(DEPDIR)/libcfa_a-preemption.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/preemption.c' object='concurrency/libcfa_a-preemption.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 concurrency/libcfa_a-preemption.o `test -f 'concurrency/preemption.c' || echo '$(srcdir)/'`concurrency/preemption.c
+concurrency/libcfa_a-preemption.obj: concurrency/preemption.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_a-preemption.obj -MD -MP -MF concurrency/$(DEPDIR)/libcfa_a-preemption.Tpo -c -o concurrency/libcfa_a-preemption.obj `if test -f 'concurrency/preemption.c'; then $(CYGPATH_W) 'concurrency/preemption.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/preemption.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-preemption.Tpo concurrency/$(DEPDIR)/libcfa_a-preemption.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/preemption.c' object='concurrency/libcfa_a-preemption.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 concurrency/libcfa_a-preemption.obj `if test -f 'concurrency/preemption.c'; then $(CYGPATH_W) 'concurrency/preemption.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/preemption.c'; fi`
 install-nobase_cfa_includeHEADERS: $(nobase_cfa_include_HEADERS)
         @$(NORMAL_INSTALL)
 …
         ${AM_V_CC}@BACKEND_CC@ -DHAVE_CONFIG_H -I. -I../.. -O2 ${EXTRA_FLAGS} -c -o $@ $<
+libcfa_a-exception.o : exception.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 $@ $<

src/libcfa/concurrency/coroutine

-              r9c951e3
+              rb1e63ac5
 // Suspend implementation inlined for performance
 static inline void suspend() {
       coroutine_desc * src = this_coroutine();          // optimization
+        coroutine_desc * src = this_coroutine();                // optimization
         assertf( src->last != 0,
 …
         coroutine_desc * dst = get_coroutine(cor);
       if( unlikely(!dst->stack.base) ) {
+        if( unlikely(!dst->stack.base) ) {
                 create_stack(&dst->stack, dst->stack.size);
                 CtxStart(cor, CtxInvokeCoroutine);
+        }
       // not resuming self ?
+        // not resuming self ?
         if ( src != dst ) {
                 assertf( dst->state != Halted ,
 …
                         src->name, src, dst->name, dst );
             // set last resumer
+                // set last resumer
                 dst->last = src;
         } // if
       // always done for performance testing
+        // always done for performance testing
         CoroutineCtxSwitch( src, dst );
+}
 …
         coroutine_desc * src = this_coroutine();                // optimization
       // not resuming self ?
+        // not resuming self ?
         if ( src != dst ) {
                 assertf( dst->state != Halted ,
 …
                         src->name, src, dst->name, dst );
             // set last resumer
+                // set last resumer
                 dst->last = src;
         } // if
       // always done for performance testing
+        // always done for performance testing
         CoroutineCtxSwitch( src, dst );
+}

src/libcfa/concurrency/kernel

-              r9c951e3
+              rb1e63ac5
 //-----------------------------------------------------------------------------
 // Locks
+bool try_lock( spinlock * );
 void lock( spinlock * );
 void unlock( spinlock * );
 …
         struct FinishAction finish;
+        struct alarm_node_t * preemption_alarm;
+        unsigned int preemption;
+        unsigned short disable_preempt_count;
+        bool pending_preemption;
 };
 …
 // Local Variables: //
 // mode: c //
 // tab-width: 4 //
+// mode: CFA //
+// tab-width: 6 //
 // End: //

src/libcfa/concurrency/kernel.c

-              r9c951e3
+              rb1e63ac5
 //CFA Includes
 #include "libhdr.h"
+#include "preemption.h"
 //Private includes
 …
 KERNEL_STORAGE(processorCtx_t, systemProcessorCtx);
 KERNEL_STORAGE(cluster, systemCluster);
 KERNEL_STORAGE(processor, systemProcessor);
+KERNEL_STORAGE(system_proc_t, systemProcessor);
 KERNEL_STORAGE(thread_desc, mainThread);
 KERNEL_STORAGE(machine_context_t, mainThread_context);
 cluster * systemCluster;
 processor * systemProcessor;
+system_proc_t * systemProcessor;
 thread_desc * mainThread;
 …
 // Processor coroutine
 void ?{}(processorCtx_t * this, processor * proc) {
         (&this->__cor){};
+        (&this->__cor){ "Processor" };
         this->proc = proc;
         proc->runner = this;
 …
         (&this->terminated){};
         this->is_terminated = false;
+        this->preemption_alarm = NULL;
+        this->preemption = default_preemption();
+        this->disable_preempt_count = 1;                //Start with interrupts disabled
+        this->pending_preemption = false;
         start( this );
 …
         (&this->terminated){};
         this->is_terminated = false;
+        this->disable_preempt_count = 0;
+        this->pending_preemption = false;
         this->runner = runner;
         LIB_DEBUG_PRINT_SAFE("Kernel : constructing processor context %p\n", runner);
         runner{ this };
+}
+void ?{}(system_proc_t * this, cluster * cltr, processorCtx_t * runner) {
+        (&this->alarms){};
+        (&this->alarm_lock){};
+        this->pending_alarm = false;
+        (&this->proc){ cltr, runner };
+}
 …
 void main(processorCtx_t * runner) {
         processor * this = runner->proc;
         LIB_DEBUG_PRINT_SAFE("Kernel : core %p starting\n", this);
-        thread_desc * readyThread = NULL;
-        for( unsigned int spin_count = 0; ! this->is_terminated; spin_count++ )
+        {
+                readyThread = nextThread( this->cltr );
+                if(readyThread)
+                // Setup preemption data
+                preemption_scope scope = { this };
+                LIB_DEBUG_PRINT_SAFE("Kernel : core %p started\n", this);
+                thread_desc * readyThread = NULL;
+                for( unsigned int spin_count = 0; ! this->is_terminated; spin_count++ )
+                {
+                        runThread(this, readyThread);
+                        //Some actions need to be taken from the kernel
+                        finishRunning(this);
+                        spin_count = 0;
+                }
+                else
+                {
+                        spin(this, &spin_count);
+                }
+        }
+        LIB_DEBUG_PRINT_SAFE("Kernel : core %p unlocking thread\n", this);
+                        readyThread = nextThread( this->cltr );
+                        if(readyThread)
+                        {
+                                runThread(this, readyThread);
+                                //Some actions need to be taken from the kernel
+                                finishRunning(this);
+                                spin_count = 0;
+                        }
+                        else
+                        {
+                                spin(this, &spin_count);
+                        }
+                }
+                LIB_DEBUG_PRINT_SAFE("Kernel : core %p stopping\n", this);
+        }
         signal( &this->terminated );
         LIB_DEBUG_PRINT_SAFE("Kernel : core %p terminated\n", this);
 …
         // appropriate stack.
         proc_cor_storage.__cor.state = Active;
       main( &proc_cor_storage );
       proc_cor_storage.__cor.state = Halted;
+        main( &proc_cor_storage );
+        proc_cor_storage.__cor.state = Halted;
         // Main routine of the core returned, the core is now fully terminated
 …
         LIB_DEBUG_PRINT_SAFE("Kernel : Starting core %p\n", this);
-        // pthread_attr_t attributes;
-        // pthread_attr_init( &attributes );
         pthread_create( &this->kernel_thread, NULL, CtxInvokeProcessor, (void*)this );
-        // pthread_attr_destroy( &attributes );
         LIB_DEBUG_PRINT_SAFE("Kernel : core %p started\n", this);
 …
         if( !thrd ) return;
         assertf( thrd->next == NULL, "Expected null got %p", thrd->next );
+        verifyf( thrd->next == NULL, "Expected null got %p", thrd->next );
         lock( &systemProcessor->cltr->lock );
         append( &systemProcessor->cltr->ready_queue, thrd );
         unlock( &systemProcessor->cltr->lock );
+        lock( &systemProcessor->proc.cltr->lock );
+        append( &systemProcessor->proc.cltr->ready_queue, thrd );
+        unlock( &systemProcessor->proc.cltr->lock );
+}
 …
+}
+//=============================================================================================
+// Kernel Setup logic
+//=============================================================================================
 //-----------------------------------------------------------------------------
 // Kernel boot procedures
 …
         mainThread{ &info };
+        LIB_DEBUG_PRINT_SAFE("Kernel : Main thread ready\n");
+        // Enable preemption
+        kernel_start_preemption();
         // Initialize the system cluster
         systemCluster = (cluster *)&systemCluster_storage;
         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)
         systemProcessor = (processor *)&systemProcessor_storage;
+        systemProcessor = (system_proc_t *)&systemProcessor_storage;
         systemProcessor{ systemCluster, (processorCtx_t *)&systemProcessorCtx_storage };
         // Add the main thread to the ready queue
         // once resume is called on systemProcessor->ctx the mainThread needs to be scheduled like any normal thread
+        // 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 = systemProcessor;
+        this_processor = &systemProcessor->proc;
         this_processor->current_thread = mainThread;
         this_processor->current_coroutine = &mainThread->cor;
 …
         // 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(systemProcessor->runner);
+        resume( systemProcessor->proc.runner );
 …
         // When its coroutine terminates, it return control to the mainThread
         // which is currently here
         systemProcessor->is_terminated = true;
+        systemProcessor->proc.is_terminated = true;
         suspend();
 …
         // Destroy the system processor and its context in reverse order of construction
         // These were manually constructed so we need manually destroy them
         ^(systemProcessor->runner){};
+        ^(systemProcessor->proc.runner){};
         ^(systemProcessor){};
 …
+}
+//=============================================================================================
+// Kernel Utilities
+//=============================================================================================
 //-----------------------------------------------------------------------------
 // Locks
 …
 void ^?{}( spinlock * this ) {
+}
+bool try_lock( spinlock * this ) {
+        return this->lock == 0 && __sync_lock_test_and_set_4( &this->lock, 1 ) == 0;
+}
 …
 void append( __thread_queue_t * this, thread_desc * t ) {
         assert(this->tail != NULL);
+        verify(this->tail != NULL);
         *this->tail = t;
         this->tail = &t->next;
 …
 void push( __condition_stack_t * this, __condition_criterion_t * t ) {
         assert( !t->next );
+        verify( !t->next );
         t->next = this->top;
         this->top = t;

src/libcfa/concurrency/kernel_private.h

-              r9c951e3
+              rb1e63ac5
 #include "thread"
+#include "alarm.h"
+#include "libhdr.h"
 //-----------------------------------------------------------------------------
 // Scheduler
 …
 //-----------------------------------------------------------------------------
 // Processor
 struct processorCtx_t {
+coroutine processorCtx_t {
         processor * proc;
-        coroutine_desc __cor;
 };
-DECL_COROUTINE(processorCtx_t);
 void main(processorCtx_t *);
 …
 void finishRunning(processor * this);
 void spin(processor * this, unsigned int * spin_count);
+struct system_proc_t {
+        processor proc;
+        alarm_list_t alarms;
+        spinlock alarm_lock;
+        bool pending_alarm;
+};
+extern cluster * systemCluster;
+extern system_proc_t * systemProcessor;
+extern thread_local processor * this_processor;
+static inline void disable_interrupts() {
+        __attribute__((unused)) unsigned short prev = __atomic_fetch_add_2( &this_processor->disable_preempt_count, 1, __ATOMIC_SEQ_CST );
+        assert( prev != (unsigned short) -1 );
+}
+static inline void enable_interrupts_noRF() {
+        __attribute__((unused)) unsigned short prev = __atomic_fetch_add_2( &this_processor->disable_preempt_count, -1, __ATOMIC_SEQ_CST );
+        verify( prev != (unsigned short) 0 );
+}
+static inline void enable_interrupts() {
+        __attribute__((unused)) unsigned short prev = __atomic_fetch_add_2( &this_processor->disable_preempt_count, -1, __ATOMIC_SEQ_CST );
+        verify( prev != (unsigned short) 0 );
+        if( prev == 1 && this_processor->pending_preemption ) {
+                ScheduleInternal( this_processor->current_thread );
+                this_processor->pending_preemption = false;
+        }
+}
 //-----------------------------------------------------------------------------

src/libcfa/concurrency/monitor

-              r9c951e3
+              rb1e63ac5
 static inline void ?{}(monitor_desc * this) {
         this->owner = NULL;
       this->stack_owner = NULL;
+        this->stack_owner = NULL;
         this->recursion = 0;
+}
 …
         monitor_desc ** m;
         int count;
       monitor_desc ** prev_mntrs;
       unsigned short  prev_count;
+        monitor_desc ** prev_mntrs;
+        unsigned short  prev_count;
 };
 …
         unsigned short count;                           //Number of criterions in the criteria
         __condition_node_t * next;                      //Intrusive linked list Next field
+        uintptr_t user_info;                            //Custom user info accessible before signalling
 };
 …
+}
+void wait( condition * this );
+void signal( condition * this );
+void wait( condition * this, uintptr_t user_info = 0 );
+bool signal( condition * this );
+bool signal_block( condition * this );
+static inline bool is_empty( condition * this ) { return !this->blocked.head; }
+uintptr_t front( condition * this );
+struct __acceptable_t {
+        void (*func)(void);
+        unsigned short count;
+        monitor_desc * monitors[1];
+};
+void __accept_internal( unsigned short count, __acceptable_t * acceptables, void (*func)(void) );
 #endif //MONITOR_H

src/libcfa/concurrency/monitor.c

-              r9c951e3
+              rb1e63ac5
                 else if( this->owner == thrd) {
                         //We already have the monitor, just not how many times we took it
                         assert( this->recursion > 0 );
+                        verify( this->recursion > 0 );
                         this->recursion += 1;
+                }
 …
                         //Some one else has the monitor, wait in line for it
                         append( &this->entry_queue, thrd );
+                        LIB_DEBUG_PRINT_SAFE("%p Blocking on entry\n", thrd);
                         ScheduleInternal( &this->lock );
 …
                 lock( &this->lock );
-                thread_desc * thrd = this_thread();
                 LIB_DEBUG_PRINT_SAFE("%p Leaving %p (o: %p, r: %i)\n", thrd, this, this->owner, this->recursion);
                 assertf( thrd == this->owner, "Expected owner to be %p, got %p (r: %i)", thrd, this->owner, this->recursion );
+                verifyf( this_thread() == this->owner, "Expected owner to be %p, got %p (r: %i)", this_thread(), this->owner, this->recursion );
                 //Leaving a recursion level, decrement the counter
 …
                 unlock( &this->lock );
+                LIB_DEBUG_PRINT_SAFE("Next owner is %p\n", new_owner);
                 //We need to wake-up the thread
                 ScheduleThread( new_owner );
 …
+}
+void debug_break() __attribute__(( noinline ))
+{
+void ?{}(__condition_node_t * this, thread_desc * waiting_thread, unsigned short count, uintptr_t user_info ) {
+        this->waiting_thread = waiting_thread;
+        this->count = count;
+        this->next = NULL;
+        this->user_info = user_info;
+}
+void ?{}(__condition_criterion_t * this ) {
+        this->ready  = false;
+        this->target = NULL;
+        this->owner  = NULL;
+        this->next   = NULL;
+}
+void ?{}(__condition_criterion_t * this, monitor_desc * target, __condition_node_t * owner ) {
+        this->ready  = false;
+        this->target = target;
+        this->owner  = owner;
+        this->next   = NULL;
+}
 //-----------------------------------------------------------------------------
 // Internal scheduling
 void wait( condition * this ) {
+void wait( condition * this, uintptr_t user_info = 0 ) {
         LIB_DEBUG_PRINT_SAFE("Waiting\n");
 …
         //Check that everything is as expected
         assertf( this->monitors != NULL, "Waiting with no monitors (%p)", this->monitors );
+        assertf( this->monitor_count != 0, "Waiting with 0 monitors (%i)", this->monitor_count );
+        verifyf( this->monitor_count != 0, "Waiting with 0 monitors (%i)", this->monitor_count );
+        verifyf( this->monitor_count < 32u, "Excessive monitor count (%i)", this->monitor_count );
         unsigned short count = this->monitor_count;
 …
         LIB_DEBUG_PRINT_SAFE("count %i\n", count);
+        __condition_node_t waiter;
+        waiter.waiting_thread = this_thread();
+        waiter.count = count;
+        waiter.next = NULL;
+        __condition_node_t waiter = { this_thread(), count, user_info };
         __condition_criterion_t criteria[count];
         for(int i = 0; i < count; i++) {
+                criteria[i].ready  = false;
+                criteria[i].target = this->monitors[i];
+                criteria[i].owner  = &waiter;
+                criteria[i].next   = NULL;
+                (&criteria[i]){ this->monitors[i], &waiter };
                 LIB_DEBUG_PRINT_SAFE( "Criterion %p\n", &criteria[i] );
+        }
 …
+        }
-        debug_break();
         for( int i = 0; i < count; i++) {
                 thread_desc * new_owner = next_thread( this->monitors[i] );
                 thread_count = insert_unique( threads, thread_count, new_owner );
+        }
-        debug_break();
         LIB_DEBUG_PRINT_SAFE("Will unblock: ");
 …
+}
 void signal( condition * this ) {
         if( !this->blocked.head ) {
+bool signal( condition * this ) {
+        if( is_empty( this ) ) {
                 LIB_DEBUG_PRINT_SAFE("Nothing to signal\n");
                 return;
+                return false;
+        }
         //Check that everything is as expected
         assert( this->monitors );
         assert( this->monitor_count != 0 );
+        verify( this->monitors );
+        verify( this->monitor_count != 0 );
         unsigned short count = this->monitor_count;
+        //Some more checking in debug
         LIB_DEBUG_DO(
                 thread_desc * this_thrd = this_thread();
 …
         );
+        //Lock all the monitors
         lock_all( this->monitors, NULL, count );
         LIB_DEBUG_PRINT_SAFE("Signalling");
+        //Pop the head of the waiting queue
         __condition_node_t * node = pop_head( &this->blocked );
+        //Add the thread to the proper AS stack
         for(int i = 0; i < count; i++) {
                 __condition_criterion_t * crit = &node->criteria[i];
 …
         LIB_DEBUG_PRINT_SAFE("\n");
+        //Release
         unlock_all( this->monitors, count );
+        return true;
+}
+bool signal_block( condition * this ) {
+        if( !this->blocked.head ) {
+                LIB_DEBUG_PRINT_SAFE("Nothing to signal\n");
+                return false;
+        }
+        //Check that everything is as expected
+        verifyf( this->monitors != NULL, "Waiting with no monitors (%p)", this->monitors );
+        verifyf( this->monitor_count != 0, "Waiting with 0 monitors (%i)", this->monitor_count );
+        unsigned short count = this->monitor_count;
+        unsigned int recursions[ count ];               //Save the current recursion levels to restore them later
+        spinlock *   locks     [ count ];               //We need to pass-in an array of locks to ScheduleInternal
+        lock_all( this->monitors, locks, count );
+        //create creteria
+        __condition_node_t waiter = { this_thread(), count, 0 };
+        __condition_criterion_t criteria[count];
+        for(int i = 0; i < count; i++) {
+                (&criteria[i]){ this->monitors[i], &waiter };
+                LIB_DEBUG_PRINT_SAFE( "Criterion %p\n", &criteria[i] );
+                push( &criteria[i].target->signal_stack, &criteria[i] );
+        }
+        waiter.criteria = criteria;
+        //save contexts
+        save_recursion( this->monitors, recursions, count );
+        //Find the thread to run
+        thread_desc * signallee = pop_head( &this->blocked )->waiting_thread;
+        for(int i = 0; i < count; i++) {
+                set_owner( this->monitors[i], signallee );
+        }
+        LIB_DEBUG_PRINT_SAFE( "Waiting on signal block\n" );
+        //Everything is ready to go to sleep
+        ScheduleInternal( locks, count, &signallee, 1 );
+        LIB_DEBUG_PRINT_SAFE( "Back from signal block\n" );
+        //We are back, restore the owners and recursions
+        lock_all( locks, count );
+        restore_recursion( this->monitors, recursions, count );
+        unlock_all( locks, count );
+        return true;
+}
+uintptr_t front( condition * this ) {
+        verifyf( !is_empty(this),
+                "Attempt to access user data on an empty condition.\n"
+                "Possible cause is not checking if the condition is empty before reading stored data."
+        );
+        return this->blocked.head->user_info;
+}
+//-----------------------------------------------------------------------------
+// Internal scheduling
+void __accept_internal( unsigned short count, __acceptable_t * acceptables, void (*func)(void) ) {
+        // thread_desc * this = this_thread();
+        // unsigned short count = this->current_monitor_count;
+        // unsigned int recursions[ count ];            //Save the current recursion levels to restore them later
+        // spinlock *   locks     [ count ];            //We need to pass-in an array of locks to ScheduleInternal
+        // lock_all( this->current_monitors, locks, count );
+        // // // Everything is ready to go to sleep
+        // // ScheduleInternal( locks, count, threads, thread_count );
+        // //WE WOKE UP
+        // //We are back, restore the owners and recursions
+        // lock_all( locks, count );
+        // restore_recursion( this->monitors, recursions, count );
+        // unlock_all( locks, count );
+}
 …
         for(    int i = 0; i < count; i++ ) {
                 LIB_DEBUG_PRINT_SAFE( "Checking %p for %p\n", &criteria[i], target );
                 if( &criteria[i] == target ) {
 …
 void append( __condition_blocked_queue_t * this, __condition_node_t * c ) {
         assert(this->tail != NULL);
+        verify(this->tail != NULL);
         *this->tail = c;
         this->tail = &c->next;

src/libcfa/concurrency/thread

r9c951e3	rb1e63ac5
82	82
83	83	void yield();
	84	void yield( unsigned times );
84	85
85	86	#endif //THREADS_H

src/libcfa/concurrency/thread.c

-              r9c951e3
+              rb1e63ac5
+}
+void yield( unsigned times ) {
+        for( unsigned i = 0; i < times; i++ ) {
+                yield();
+        }
+}
 void ThreadCtxSwitch(coroutine_desc* src, coroutine_desc* dst) {
         // set state of current coroutine to inactive

src/libcfa/containers/vector

-              r9c951e3
+              rb1e63ac5
 //------------------------------------------------------------------------------
+//Allocator
+forall(otype T)
+struct heap_allocator
+{
+        T* storage;
+        size_t capacity;
+};
+forall(otype T)
+void ?{}(heap_allocator(T)* this);
+forall(otype T)
+void ?{}(heap_allocator(T)* this, heap_allocator(T) rhs);
+forall(otype T)
+heap_allocator(T) ?=?(heap_allocator(T)* this, heap_allocator(T) rhs);
+forall(otype T)
+void ^?{}(heap_allocator(T)* this);
+forall(otype T)
+void realloc_storage(heap_allocator(T)* this, size_t size);
+forall(otype T)
+static inline T* data(heap_allocator(T)* this)
+{
+        return this->storage;
+}
+//------------------------------------------------------------------------------
 //Declaration
 trait allocator_c(otype T, otype allocator_t)
 …
 };
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(otype T, otype allocator_t = heap_allocator(T) | allocator_c(T, allocator_t))
 struct vector;
 …
 void ^?{}(vector(T, allocator_t)* this);
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(otype T, otype allocator_t = heap_allocator(T) | allocator_c(T, allocator_t))
 struct vector
+{
 …
 // }
-//------------------------------------------------------------------------------
-//Allocator
-forall(otype T)
-struct heap_allocator
+{
-        T* storage;
-        size_t capacity;
-};
-forall(otype T)
-void ?{}(heap_allocator(T)* this);
-forall(otype T)
-void ?{}(heap_allocator(T)* this, heap_allocator(T) rhs);
-forall(otype T)
-heap_allocator(T) ?=?(heap_allocator(T)* this, heap_allocator(T) rhs);
-forall(otype T)
-void ^?{}(heap_allocator(T)* this);
-forall(otype T)
-void realloc_storage(heap_allocator(T)* this, size_t size);
-forall(otype T)
-static inline T* data(heap_allocator(T)* this)
+{
-        return this->storage;
+}
 #endif // VECTOR_H

src/libcfa/gmp

-              r9c951e3
+              rb1e63ac5
 // Created On       : Tue Apr 19 08:43:43 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun May 14 23:47:36 2017
 // Update Count     : 9
+// Last Modified On : Sat May 27 09:55:51 2017
+// Update Count     : 14
 //
 …
 // constructor
 void ?{}( Int * this ) { mpz_init( this->mpz ); }
 void ?{}( Int * this, Int init ) { mpz_init_set( this->mpz, init.mpz ); }
 void ?{}( Int * this, zero_t ) { mpz_init_set_si( this->mpz, 0 ); }
 void ?{}( Int * this, one_t ) { mpz_init_set_si( this->mpz, 1 ); }
 void ?{}( Int * this, signed long int init ) { mpz_init_set_si( this->mpz, init ); }
 void ?{}( Int * this, unsigned long int init ) { mpz_init_set_ui( this->mpz, init ); }
 void ?{}( Int * this, const char * val ) { if ( mpz_init_set_str( this->mpz, val, 0 ) ) abort(); }
 void ^?{}( Int * this ) { mpz_clear( this->mpz ); }
+static inline void ?{}( Int * this ) { mpz_init( this->mpz ); }
+static inline void ?{}( Int * this, Int init ) { mpz_init_set( this->mpz, init.mpz ); }
+static inline void ?{}( Int * this, zero_t ) { mpz_init_set_si( this->mpz, 0 ); }
+static inline void ?{}( Int * this, one_t ) { mpz_init_set_si( this->mpz, 1 ); }
+static inline void ?{}( Int * this, signed long int init ) { mpz_init_set_si( this->mpz, init ); }
+static inline void ?{}( Int * this, unsigned long int init ) { mpz_init_set_ui( this->mpz, init ); }
+static inline void ?{}( Int * this, const char * val ) { if ( mpz_init_set_str( this->mpz, val, 0 ) ) abort(); }
+static inline void ^?{}( Int * this ) { mpz_clear( this->mpz ); }
 // assignment
 Int ?=?( Int * lhs, Int rhs ) { mpz_set( lhs->mpz, rhs.mpz ); return *lhs; }
 Int ?=?( Int * lhs, long int rhs ) { mpz_set_si( lhs->mpz, rhs ); return *lhs; }
 Int ?=?( Int * lhs, unsigned long int rhs ) { mpz_set_ui( lhs->mpz, rhs ); return *lhs; }
 //Int ?=?( Int * lhs, const char * rhs ) { if ( mpq_set_str( lhs->mpz, rhs, 0 ) ) abort(); return *lhs; }
 char ?=?( char * lhs, Int rhs ) { char val = mpz_get_si( rhs.mpz ); *lhs = val; return val; }
 short int ?=?( short int * lhs, Int rhs ) { short int val = mpz_get_si( rhs.mpz ); *lhs = val; return val; }
 int ?=?( int * lhs, Int rhs ) { int val = mpz_get_si( rhs.mpz ); *lhs = val; return val; }
 long int ?=?( long int * lhs, Int rhs ) { long int val = mpz_get_si( rhs.mpz ); *lhs = val; return val; }
 unsigned char ?=?( unsigned char * lhs, Int rhs ) { unsigned char val = mpz_get_ui( rhs.mpz ); *lhs = val; return val; }
 unsigned short int ?=?( unsigned short int * lhs, Int rhs ) { unsigned short int val = mpz_get_ui( rhs.mpz ); *lhs = val; return val; }
 unsigned int ?=?( unsigned int * lhs, Int rhs ) { unsigned int val = mpz_get_ui( rhs.mpz ); *lhs = val; return val; }
 unsigned long int ?=?( unsigned long int * lhs, Int rhs ) { unsigned long int val = mpz_get_ui( rhs.mpz ); *lhs = val; return val; }
+static inline Int ?=?( Int * lhs, Int rhs ) { mpz_set( lhs->mpz, rhs.mpz ); return *lhs; }
+static inline Int ?=?( Int * lhs, long int rhs ) { mpz_set_si( lhs->mpz, rhs ); return *lhs; }
+static inline Int ?=?( Int * lhs, unsigned long int rhs ) { mpz_set_ui( lhs->mpz, rhs ); return *lhs; }
+static inline Int ?=?( Int * lhs, const char * rhs ) { if ( mpz_set_str( lhs->mpz, rhs, 0 ) ) { printf( "invalid string conversion\n" ); abort(); } return *lhs; }
+static inline char ?=?( char * lhs, Int rhs ) { char val = mpz_get_si( rhs.mpz ); *lhs = val; return val; }
+static inline short int ?=?( short int * lhs, Int rhs ) { short int val = mpz_get_si( rhs.mpz ); *lhs = val; return val; }
+static inline int ?=?( int * lhs, Int rhs ) { int val = mpz_get_si( rhs.mpz ); *lhs = val; return val; }
+static inline long int ?=?( long int * lhs, Int rhs ) { long int val = mpz_get_si( rhs.mpz ); *lhs = val; return val; }
+static inline unsigned char ?=?( unsigned char * lhs, Int rhs ) { unsigned char val = mpz_get_ui( rhs.mpz ); *lhs = val; return val; }
+static inline unsigned short int ?=?( unsigned short int * lhs, Int rhs ) { unsigned short int val = mpz_get_ui( rhs.mpz ); *lhs = val; return val; }
+static inline unsigned int ?=?( unsigned int * lhs, Int rhs ) { unsigned int val = mpz_get_ui( rhs.mpz ); *lhs = val; return val; }
+static inline unsigned long int ?=?( unsigned long int * lhs, Int rhs ) { unsigned long int val = mpz_get_ui( rhs.mpz ); *lhs = val; return val; }
 // conversions
 long int narrow( Int val ) { return mpz_get_si( val.mpz ); }
 unsigned long int narrow( Int val ) { return mpz_get_ui( val.mpz ); }
+static inline long int narrow( Int val ) { return mpz_get_si( val.mpz ); }
+static inline unsigned long int narrow( Int val ) { return mpz_get_ui( val.mpz ); }
 // comparison
 int ?==?( Int oper1, Int oper2 ) { return mpz_cmp( oper1.mpz, oper2.mpz ) == 0; }
 int ?==?( Int oper1, long int oper2 ) { return mpz_cmp_si( oper1.mpz, oper2 ) == 0; }
 int ?==?( long int oper2, Int oper1 ) { return mpz_cmp_si( oper1.mpz, oper2 ) == 0; }
 int ?==?( Int oper1, unsigned long int oper2 ) { return mpz_cmp_ui( oper1.mpz, oper2 ) == 0; }
 int ?==?( unsigned long int oper2, Int oper1 ) { return mpz_cmp_ui( oper1.mpz, oper2 ) == 0; }
 int ?!=?( Int oper1, Int oper2 ) { return ! ( oper1 == oper2 ); }
 int ?!=?( Int oper1, long int oper2 ) { return ! ( oper1 == oper2 ); }
 int ?!=?( long int oper1, Int oper2 ) { return ! ( oper1 == oper2 ); }
 int ?!=?( Int oper1, unsigned long int oper2 ) { return ! ( oper1 == oper2 ); }
 int ?!=?( unsigned long int oper1, Int oper2 ) { return ! ( oper1 == oper2 ); }
 int ?<?( Int oper1, Int oper2 ) { return mpz_cmp( oper1.mpz, oper2.mpz ) < 0; }
 int ?<?( Int oper1, long int oper2 ) { return mpz_cmp_si( oper1.mpz, oper2 ) < 0; }
 int ?<?( long int oper2, Int oper1 ) { return mpz_cmp_si( oper1.mpz, oper2 ) < 0; }
 int ?<?( Int oper1, unsigned long int oper2 ) { return mpz_cmp_ui( oper1.mpz, oper2 ) < 0; }
 int ?<?( unsigned long int oper2, Int oper1 ) { return mpz_cmp_ui( oper1.mpz, oper2 ) < 0; }
 int ?<=?( Int oper1, Int oper2 ) { return mpz_cmp( oper1.mpz, oper2.mpz ) <= 0; }
 int ?<=?( Int oper1, long int oper2 ) { return mpz_cmp_si( oper1.mpz, oper2 ) <= 0; }
 int ?<=?( long int oper2, Int oper1 ) { return mpz_cmp_si( oper1.mpz, oper2 ) <= 0; }
 int ?<=?( Int oper1, unsigned long int oper2 ) { return mpz_cmp_ui( oper1.mpz, oper2 ) <= 0; }
 int ?<=?( unsigned long int oper2, Int oper1 ) { return mpz_cmp_ui( oper1.mpz, oper2 ) <= 0; }
 int ?>?( Int oper1, Int oper2 ) { return ! ( oper1 <= oper2 ); }
 int ?>?( Int oper1, long int oper2 ) { return ! ( oper1 <= oper2 ); }
 int ?>?( long int oper1, Int oper2 ) { return ! ( oper1 <= oper2 ); }
 int ?>?( Int oper1, unsigned long int oper2 ) { return ! ( oper1 <= oper2 ); }
 int ?>?( unsigned long int oper1, Int oper2 ) { return ! ( oper1 <= oper2 ); }
 int ?>=?( Int oper1, Int oper2 ) { return ! ( oper1 < oper2 ); }
 int ?>=?( Int oper1, long int oper2 ) { return ! ( oper1 < oper2 ); }
 int ?>=?( long int oper1, Int oper2 ) { return ! ( oper1 < oper2 ); }
 int ?>=?( Int oper1, unsigned long int oper2 ) { return ! ( oper1 < oper2 ); }
 int ?>=?( unsigned long int oper1, Int oper2 ) { return ! ( oper1 < oper2 ); }
+static inline int ?==?( Int oper1, Int oper2 ) { return mpz_cmp( oper1.mpz, oper2.mpz ) == 0; }
+static inline int ?==?( Int oper1, long int oper2 ) { return mpz_cmp_si( oper1.mpz, oper2 ) == 0; }
+static inline int ?==?( long int oper2, Int oper1 ) { return mpz_cmp_si( oper1.mpz, oper2 ) == 0; }
+static inline int ?==?( Int oper1, unsigned long int oper2 ) { return mpz_cmp_ui( oper1.mpz, oper2 ) == 0; }
+static inline int ?==?( unsigned long int oper2, Int oper1 ) { return mpz_cmp_ui( oper1.mpz, oper2 ) == 0; }
+static inline int ?!=?( Int oper1, Int oper2 ) { return ! ( oper1 == oper2 ); }
+static inline int ?!=?( Int oper1, long int oper2 ) { return ! ( oper1 == oper2 ); }
+static inline int ?!=?( long int oper1, Int oper2 ) { return ! ( oper1 == oper2 ); }
+static inline int ?!=?( Int oper1, unsigned long int oper2 ) { return ! ( oper1 == oper2 ); }
+static inline int ?!=?( unsigned long int oper1, Int oper2 ) { return ! ( oper1 == oper2 ); }
+static inline int ?<?( Int oper1, Int oper2 ) { return mpz_cmp( oper1.mpz, oper2.mpz ) < 0; }
+static inline int ?<?( Int oper1, long int oper2 ) { return mpz_cmp_si( oper1.mpz, oper2 ) < 0; }
+static inline int ?<?( long int oper2, Int oper1 ) { return mpz_cmp_si( oper1.mpz, oper2 ) < 0; }
+static inline int ?<?( Int oper1, unsigned long int oper2 ) { return mpz_cmp_ui( oper1.mpz, oper2 ) < 0; }
+static inline int ?<?( unsigned long int oper2, Int oper1 ) { return mpz_cmp_ui( oper1.mpz, oper2 ) < 0; }
+static inline int ?<=?( Int oper1, Int oper2 ) { return mpz_cmp( oper1.mpz, oper2.mpz ) <= 0; }
+static inline int ?<=?( Int oper1, long int oper2 ) { return mpz_cmp_si( oper1.mpz, oper2 ) <= 0; }
+static inline int ?<=?( long int oper2, Int oper1 ) { return mpz_cmp_si( oper1.mpz, oper2 ) <= 0; }
+static inline int ?<=?( Int oper1, unsigned long int oper2 ) { return mpz_cmp_ui( oper1.mpz, oper2 ) <= 0; }
+static inline int ?<=?( unsigned long int oper2, Int oper1 ) { return mpz_cmp_ui( oper1.mpz, oper2 ) <= 0; }
+static inline int ?>?( Int oper1, Int oper2 ) { return ! ( oper1 <= oper2 ); }
+static inline int ?>?( Int oper1, long int oper2 ) { return ! ( oper1 <= oper2 ); }
+static inline int ?>?( long int oper1, Int oper2 ) { return ! ( oper1 <= oper2 ); }
+static inline int ?>?( Int oper1, unsigned long int oper2 ) { return ! ( oper1 <= oper2 ); }
+static inline int ?>?( unsigned long int oper1, Int oper2 ) { return ! ( oper1 <= oper2 ); }
+static inline int ?>=?( Int oper1, Int oper2 ) { return ! ( oper1 < oper2 ); }
+static inline int ?>=?( Int oper1, long int oper2 ) { return ! ( oper1 < oper2 ); }
+static inline int ?>=?( long int oper1, Int oper2 ) { return ! ( oper1 < oper2 ); }
+static inline int ?>=?( Int oper1, unsigned long int oper2 ) { return ! ( oper1 < oper2 ); }
+static inline int ?>=?( unsigned long int oper1, Int oper2 ) { return ! ( oper1 < oper2 ); }
 // arithmetic
 Int +?( Int oper ) { Int pos; mpz_set( pos.mpz, oper.mpz ); return pos; }
 Int -?( Int oper ) { Int neg; mpz_neg( neg.mpz, oper.mpz ); return neg; }
 Int ~?( Int oper ) { Int comp; mpz_com( comp.mpz, oper.mpz ); return comp; }
 Int ?&?( Int oper1, Int oper2 ) { Int conjunction; mpz_and( conjunction.mpz, oper1.mpz, oper2.mpz ); return conjunction; }
 Int ?&?( Int oper1, long int oper2 ) { Int conjunction, temp; mpz_set_si( temp.mpz, oper2 ); mpz_and( conjunction.mpz, oper1.mpz, temp.mpz ); return conjunction; }
 Int ?&?( long int oper1, Int oper2 ) { Int conjunction, temp; mpz_set_si( temp.mpz, oper1 ); mpz_and( conjunction.mpz, temp.mpz, oper2.mpz ); return conjunction; }
 Int ?&?( Int oper1, unsigned long int oper2 ) { Int conjunction, temp; mpz_set_ui( temp.mpz, oper2 ); mpz_and( conjunction.mpz, oper1.mpz, temp.mpz ); return conjunction; }
 Int ?&?( unsigned long int oper1, Int oper2 ) { Int conjunction, temp; mpz_set_ui( temp.mpz, oper1 ); mpz_and( conjunction.mpz, temp.mpz, oper2.mpz ); return conjunction; }
 Int ?&=?( Int * lhs, Int rhs ) { return *lhs = *lhs & rhs; }
 Int ?|?( Int oper1, Int oper2 ) { Int disjunction; mpz_ior( disjunction.mpz, oper1.mpz, oper2.mpz ); return disjunction; }
 Int ?|?( Int oper1, long int oper2 ) { Int disjunction, temp; mpz_set_si( temp.mpz, oper2 ); mpz_ior( disjunction.mpz, oper1.mpz, temp.mpz ); return disjunction; }
 Int ?|?( long int oper1, Int oper2 ) { Int disjunction, temp; mpz_set_si( temp.mpz, oper1 ); mpz_ior( disjunction.mpz, temp.mpz, oper2.mpz ); return disjunction; }
 Int ?|?( Int oper1, unsigned long int oper2 ) { Int disjunction, temp; mpz_set_ui( temp.mpz, oper2 ); mpz_ior( disjunction.mpz, oper1.mpz, temp.mpz ); return disjunction; }
 Int ?|?( unsigned long int oper1, Int oper2 ) { Int disjunction, temp; mpz_set_ui( temp.mpz, oper1 ); mpz_ior( disjunction.mpz, temp.mpz, oper2.mpz ); return disjunction; }
 Int ?|=?( Int * lhs, Int rhs ) { return *lhs = *lhs | rhs; }
 Int ?^?( Int oper1, Int oper2 ) { Int disjunction; mpz_xor( disjunction.mpz, oper1.mpz, oper2.mpz ); return disjunction; }
 Int ?^?( Int oper1, long int oper2 ) { Int disjunction, temp; mpz_set_si( temp.mpz, oper2 ); mpz_ior( disjunction.mpz, oper1.mpz, temp.mpz ); return disjunction; }
 Int ?^?( long int oper1, Int oper2 ) { Int disjunction, temp; mpz_set_si( temp.mpz, oper1 ); mpz_ior( disjunction.mpz, temp.mpz, oper2.mpz ); return disjunction; }
 Int ?^?( Int oper1, unsigned long int oper2 ) { Int disjunction, temp; mpz_set_ui( temp.mpz, oper2 ); mpz_ior( disjunction.mpz, oper1.mpz, temp.mpz ); return disjunction; }
 Int ?^?( unsigned long int oper1, Int oper2 ) { Int disjunction, temp; mpz_set_ui( temp.mpz, oper1 ); mpz_ior( disjunction.mpz, temp.mpz, oper2.mpz ); return disjunction; }
 Int ?^=?( Int * lhs, Int rhs ) { return *lhs = *lhs ^ rhs; }
 Int ?+?( Int addend1, Int addend2 ) { Int sum; mpz_add( sum.mpz, addend1.mpz, addend2.mpz ); return sum; }
 Int ?+?( Int addend1, long int addend2 ) { Int sum; if ( addend2 >= 0 ) mpz_add_ui( sum.mpz, addend1.mpz, addend2 ); else mpz_sub_ui( sum.mpz, addend1.mpz, -addend2 ); return sum; }
 Int ?+?( long int addend2, Int addend1 ) { Int sum; if ( addend2 >= 0 ) mpz_add_ui( sum.mpz, addend1.mpz, addend2 ); else mpz_sub_ui( sum.mpz, addend1.mpz, -addend2 ); return sum; }
 Int ?+?( Int addend1, unsigned long int addend2 ) { Int sum; mpz_add_ui( sum.mpz, addend1.mpz, addend2 ); return sum; }
 Int ?+?( unsigned long int addend2, Int addend1 ) { Int sum; mpz_add_ui( sum.mpz, addend1.mpz, addend2 ); return sum; }
 Int ?+=?( Int * lhs, Int rhs ) { return *lhs = *lhs + rhs; }
 Int ?+=?( Int * lhs, long int rhs ) { return *lhs = *lhs + rhs; }
 Int ?+=?( Int * lhs, unsigned long int rhs ) { return *lhs = *lhs + rhs; }
 Int ++?( Int * lhs ) { return *lhs += 1; }
 Int ?++( Int * lhs ) { Int ret = *lhs; *lhs += 1; return ret; }
 Int ?-?( Int minuend, Int subtrahend ) { Int diff; mpz_sub( diff.mpz, minuend.mpz, subtrahend.mpz ); return diff; }
 Int ?-?( Int minuend, long int subtrahend ) { Int diff; if ( subtrahend >= 0 ) mpz_sub_ui( diff.mpz, minuend.mpz, subtrahend ); else mpz_add_ui( diff.mpz, minuend.mpz, -subtrahend ); return diff; }
 Int ?-?( long int minuend, Int subtrahend ) { Int diff; if ( subtrahend >= 0 ) mpz_ui_sub( diff.mpz, minuend, subtrahend.mpz ); else { mpz_add_ui( diff.mpz, subtrahend.mpz, -minuend ); mpz_neg( diff.mpz, diff.mpz ); } return diff; }
 Int ?-?( Int minuend, unsigned long int subtrahend ) { Int diff; mpz_sub_ui( diff.mpz, minuend.mpz, subtrahend ); return diff; }
 Int ?-?( unsigned long int minuend, Int subtrahend ) { Int diff; mpz_ui_sub( diff.mpz, minuend, subtrahend.mpz ); return diff; }
 Int ?-=?( Int * lhs, Int rhs ) { return *lhs = *lhs - rhs; }
 Int ?-=?( Int * lhs, long int rhs ) { return *lhs = *lhs - rhs; }
 Int ?-=?( Int * lhs, unsigned long int rhs ) { return *lhs = *lhs - rhs; }
 Int --?( Int * lhs ) { return *lhs -= 1; }
 Int ?--( Int * lhs ) { Int ret = *lhs; *lhs -= 1; return ret; }
 Int ?*?( Int multiplicator, Int multiplicand ) { Int product; mpz_mul( product.mpz, multiplicator.mpz, multiplicand.mpz ); return product; }
 Int ?*?( Int multiplicator, long int multiplicand ) { Int product; mpz_mul_si( product.mpz, multiplicator.mpz, multiplicand ); return product; }
 Int ?*?( long int multiplicand, Int multiplicator ) { Int product; mpz_mul_si( product.mpz, multiplicator.mpz, multiplicand ); return product; }
 Int ?*?( Int multiplicator, unsigned long int multiplicand ) { Int product; mpz_mul_ui( product.mpz, multiplicator.mpz, multiplicand ); return product; }
 Int ?*?( unsigned long int multiplicand, Int multiplicator ) { Int product; mpz_mul_ui( product.mpz, multiplicator.mpz, multiplicand ); return product; }
 Int ?*=?( Int * lhs, Int rhs ) { return *lhs = *lhs * rhs; }
 Int ?*=?( Int * lhs, long int rhs ) { return *lhs = *lhs * rhs; }
 Int ?*=?( Int * lhs, unsigned long int rhs ) { return *lhs = *lhs * rhs; }
+static inline Int +?( Int oper ) { Int pos; mpz_set( pos.mpz, oper.mpz ); return pos; }
+static inline Int -?( Int oper ) { Int neg; mpz_neg( neg.mpz, oper.mpz ); return neg; }
+static inline Int ~?( Int oper ) { Int comp; mpz_com( comp.mpz, oper.mpz ); return comp; }
+static inline Int ?&?( Int oper1, Int oper2 ) { Int conjunction; mpz_and( conjunction.mpz, oper1.mpz, oper2.mpz ); return conjunction; }
+static inline Int ?&?( Int oper1, long int oper2 ) { Int conjunction, temp; mpz_set_si( temp.mpz, oper2 ); mpz_and( conjunction.mpz, oper1.mpz, temp.mpz ); return conjunction; }
+static inline Int ?&?( long int oper1, Int oper2 ) { Int conjunction, temp; mpz_set_si( temp.mpz, oper1 ); mpz_and( conjunction.mpz, temp.mpz, oper2.mpz ); return conjunction; }
+static inline Int ?&?( Int oper1, unsigned long int oper2 ) { Int conjunction, temp; mpz_set_ui( temp.mpz, oper2 ); mpz_and( conjunction.mpz, oper1.mpz, temp.mpz ); return conjunction; }
+static inline Int ?&?( unsigned long int oper1, Int oper2 ) { Int conjunction, temp; mpz_set_ui( temp.mpz, oper1 ); mpz_and( conjunction.mpz, temp.mpz, oper2.mpz ); return conjunction; }
+static inline Int ?&=?( Int * lhs, Int rhs ) { return *lhs = *lhs & rhs; }
+static inline Int ?|?( Int oper1, Int oper2 ) { Int disjunction; mpz_ior( disjunction.mpz, oper1.mpz, oper2.mpz ); return disjunction; }
+static inline Int ?|?( Int oper1, long int oper2 ) { Int disjunction, temp; mpz_set_si( temp.mpz, oper2 ); mpz_ior( disjunction.mpz, oper1.mpz, temp.mpz ); return disjunction; }
+static inline Int ?|?( long int oper1, Int oper2 ) { Int disjunction, temp; mpz_set_si( temp.mpz, oper1 ); mpz_ior( disjunction.mpz, temp.mpz, oper2.mpz ); return disjunction; }
+static inline Int ?|?( Int oper1, unsigned long int oper2 ) { Int disjunction, temp; mpz_set_ui( temp.mpz, oper2 ); mpz_ior( disjunction.mpz, oper1.mpz, temp.mpz ); return disjunction; }
+static inline Int ?|?( unsigned long int oper1, Int oper2 ) { Int disjunction, temp; mpz_set_ui( temp.mpz, oper1 ); mpz_ior( disjunction.mpz, temp.mpz, oper2.mpz ); return disjunction; }
+static inline Int ?|=?( Int * lhs, Int rhs ) { return *lhs = *lhs | rhs; }
+static inline Int ?^?( Int oper1, Int oper2 ) { Int disjunction; mpz_xor( disjunction.mpz, oper1.mpz, oper2.mpz ); return disjunction; }
+static inline Int ?^?( Int oper1, long int oper2 ) { Int disjunction, temp; mpz_set_si( temp.mpz, oper2 ); mpz_ior( disjunction.mpz, oper1.mpz, temp.mpz ); return disjunction; }
+static inline Int ?^?( long int oper1, Int oper2 ) { Int disjunction, temp; mpz_set_si( temp.mpz, oper1 ); mpz_ior( disjunction.mpz, temp.mpz, oper2.mpz ); return disjunction; }
+static inline Int ?^?( Int oper1, unsigned long int oper2 ) { Int disjunction, temp; mpz_set_ui( temp.mpz, oper2 ); mpz_ior( disjunction.mpz, oper1.mpz, temp.mpz ); return disjunction; }
+static inline Int ?^?( unsigned long int oper1, Int oper2 ) { Int disjunction, temp; mpz_set_ui( temp.mpz, oper1 ); mpz_ior( disjunction.mpz, temp.mpz, oper2.mpz ); return disjunction; }
+static inline Int ?^=?( Int * lhs, Int rhs ) { return *lhs = *lhs ^ rhs; }
+static inline Int ?+?( Int addend1, Int addend2 ) { Int sum; mpz_add( sum.mpz, addend1.mpz, addend2.mpz ); return sum; }
+static inline Int ?+?( Int addend1, long int addend2 ) { Int sum; if ( addend2 >= 0 ) mpz_add_ui( sum.mpz, addend1.mpz, addend2 ); else mpz_sub_ui( sum.mpz, addend1.mpz, -addend2 ); return sum; }
+static inline Int ?+?( long int addend2, Int addend1 ) { Int sum; if ( addend2 >= 0 ) mpz_add_ui( sum.mpz, addend1.mpz, addend2 ); else mpz_sub_ui( sum.mpz, addend1.mpz, -addend2 ); return sum; }
+static inline Int ?+?( Int addend1, unsigned long int addend2 ) { Int sum; mpz_add_ui( sum.mpz, addend1.mpz, addend2 ); return sum; }
+static inline Int ?+?( unsigned long int addend2, Int addend1 ) { Int sum; mpz_add_ui( sum.mpz, addend1.mpz, addend2 ); return sum; }
+static inline Int ?+=?( Int * lhs, Int rhs ) { return *lhs = *lhs + rhs; }
+static inline Int ?+=?( Int * lhs, long int rhs ) { return *lhs = *lhs + rhs; }
+static inline Int ?+=?( Int * lhs, unsigned long int rhs ) { return *lhs = *lhs + rhs; }
+static inline Int ++?( Int * lhs ) { return *lhs += 1; }
+static inline Int ?++( Int * lhs ) { Int ret = *lhs; *lhs += 1; return ret; }
+static inline Int ?-?( Int minuend, Int subtrahend ) { Int diff; mpz_sub( diff.mpz, minuend.mpz, subtrahend.mpz ); return diff; }
+static inline Int ?-?( Int minuend, long int subtrahend ) { Int diff; if ( subtrahend >= 0 ) mpz_sub_ui( diff.mpz, minuend.mpz, subtrahend ); else mpz_add_ui( diff.mpz, minuend.mpz, -subtrahend ); return diff; }
+static inline Int ?-?( long int minuend, Int subtrahend ) { Int diff; if ( subtrahend >= 0 ) mpz_ui_sub( diff.mpz, minuend, subtrahend.mpz ); else { mpz_add_ui( diff.mpz, subtrahend.mpz, -minuend ); mpz_neg( diff.mpz, diff.mpz ); } return diff; }
+static inline Int ?-?( Int minuend, unsigned long int subtrahend ) { Int diff; mpz_sub_ui( diff.mpz, minuend.mpz, subtrahend ); return diff; }
+static inline Int ?-?( unsigned long int minuend, Int subtrahend ) { Int diff; mpz_ui_sub( diff.mpz, minuend, subtrahend.mpz ); return diff; }
+static inline Int ?-=?( Int * lhs, Int rhs ) { return *lhs = *lhs - rhs; }
+static inline Int ?-=?( Int * lhs, long int rhs ) { return *lhs = *lhs - rhs; }
+static inline Int ?-=?( Int * lhs, unsigned long int rhs ) { return *lhs = *lhs - rhs; }
+static inline Int --?( Int * lhs ) { return *lhs -= 1; }
+static inline Int ?--( Int * lhs ) { Int ret = *lhs; *lhs -= 1; return ret; }
+static inline Int ?*?( Int multiplicator, Int multiplicand ) { Int product; mpz_mul( product.mpz, multiplicator.mpz, multiplicand.mpz ); return product; }
+static inline Int ?*?( Int multiplicator, long int multiplicand ) { Int product; mpz_mul_si( product.mpz, multiplicator.mpz, multiplicand ); return product; }
+static inline Int ?*?( long int multiplicand, Int multiplicator ) { Int product; mpz_mul_si( product.mpz, multiplicator.mpz, multiplicand ); return product; }
+static inline Int ?*?( Int multiplicator, unsigned long int multiplicand ) { Int product; mpz_mul_ui( product.mpz, multiplicator.mpz, multiplicand ); return product; }
+static inline Int ?*?( unsigned long int multiplicand, Int multiplicator ) { Int product; mpz_mul_ui( product.mpz, multiplicator.mpz, multiplicand ); return product; }
+static inline Int ?*=?( Int * lhs, Int rhs ) { return *lhs = *lhs * rhs; }
+static inline Int ?*=?( Int * lhs, long int rhs ) { return *lhs = *lhs * rhs; }
+static inline Int ?*=?( Int * lhs, unsigned long int rhs ) { return *lhs = *lhs * rhs; }
 // some code for operators "/" and "%" taken from g++ gmpxx.h
 Int ?/?( Int dividend, Int divisor ) { Int quotient; mpz_tdiv_q( quotient.mpz, dividend.mpz, divisor.mpz ); return quotient; }
 Int ?/?( Int dividend, unsigned long int divisor ) { Int quotient; mpz_tdiv_q_ui( quotient.mpz, dividend.mpz, divisor ); return quotient; }
 Int ?/?( unsigned long int dividend, Int divisor ) {
+static inline Int ?/?( Int dividend, Int divisor ) { Int quotient; mpz_tdiv_q( quotient.mpz, dividend.mpz, divisor.mpz ); return quotient; }
+static inline Int ?/?( Int dividend, unsigned long int divisor ) { Int quotient; mpz_tdiv_q_ui( quotient.mpz, dividend.mpz, divisor ); return quotient; }
+static inline Int ?/?( unsigned long int dividend, Int divisor ) {
         Int quotient;
     if ( mpz_sgn( divisor.mpz ) >= 0 ) {
 …
         return quotient;
 } // ?/?
 Int ?/?( Int dividend, long int divisor ) {
+static inline Int ?/?( Int dividend, long int divisor ) {
         Int quotient;
     if ( divisor >= 0 )
 …
         return quotient;
 } // ?/?
 Int ?/?( long int dividend, Int divisor ) {
+static inline Int ?/?( long int dividend, Int divisor ) {
         Int quotient;
     if ( mpz_fits_slong_p( divisor.mpz ) )
 …
         return quotient;
 } // ?/?
 Int ?/=?( Int * lhs, Int rhs ) { return *lhs = *lhs / rhs; }
 Int ?/=?( Int * lhs, long int rhs ) { return *lhs = *lhs / rhs; }
 Int ?/=?( Int * lhs, unsigned long int rhs ) { return *lhs = *lhs / rhs; }
 [ Int, Int ] div( Int dividend, Int divisor ) { Int quotient, remainder; mpz_fdiv_qr( quotient.mpz, remainder.mpz, dividend.mpz, divisor.mpz ); return [ quotient, remainder ]; }
 [ Int, Int ] div( Int dividend, unsigned long int divisor ) { Int quotient, remainder; mpz_fdiv_qr_ui( quotient.mpz, remainder.mpz, dividend.mpz, divisor ); return [ quotient, remainder ]; }
 Int ?%?( Int dividend, Int divisor ) { Int remainder; mpz_tdiv_r( remainder.mpz, dividend.mpz, divisor.mpz ); return remainder; }
 Int ?%?( Int dividend, unsigned long int divisor ) { Int remainder; mpz_tdiv_r_ui( remainder.mpz, dividend.mpz, divisor ); return remainder; }
 Int ?%?( unsigned long int dividend, Int divisor ) {
+static inline Int ?/=?( Int * lhs, Int rhs ) { return *lhs = *lhs / rhs; }
+static inline Int ?/=?( Int * lhs, long int rhs ) { return *lhs = *lhs / rhs; }
+static inline Int ?/=?( Int * lhs, unsigned long int rhs ) { return *lhs = *lhs / rhs; }
+static inline [ Int, Int ] div( Int dividend, Int divisor ) { Int quotient, remainder; mpz_fdiv_qr( quotient.mpz, remainder.mpz, dividend.mpz, divisor.mpz ); return [ quotient, remainder ]; }
+static inline [ Int, Int ] div( Int dividend, unsigned long int divisor ) { Int quotient, remainder; mpz_fdiv_qr_ui( quotient.mpz, remainder.mpz, dividend.mpz, divisor ); return [ quotient, remainder ]; }
+static inline Int ?%?( Int dividend, Int divisor ) { Int remainder; mpz_tdiv_r( remainder.mpz, dividend.mpz, divisor.mpz ); return remainder; }
+static inline Int ?%?( Int dividend, unsigned long int divisor ) { Int remainder; mpz_tdiv_r_ui( remainder.mpz, dividend.mpz, divisor ); return remainder; }
+static inline Int ?%?( unsigned long int dividend, Int divisor ) {
         Int remainder;
     if ( mpz_sgn( divisor.mpz ) >= 0 ) {
 …
         return remainder;
 } // ?%?
 Int ?%?( Int dividend, long int divisor ) {
+static inline Int ?%?( Int dividend, long int divisor ) {
         Int remainder;
     mpz_tdiv_r_ui( remainder.mpz, dividend.mpz, (divisor >= 0 ? divisor : -divisor));
         return remainder;
 } // ?%?
 Int ?%?( long int dividend, Int divisor ) {
+static inline Int ?%?( long int dividend, Int divisor ) {
         Int remainder;
     if ( mpz_fits_slong_p( divisor.mpz ) )
 …
         return remainder;
 } // ?%?
 Int ?%=?( Int * lhs, Int rhs ) { return *lhs = *lhs % rhs; }
 Int ?%=?( Int * lhs, long int rhs ) { return *lhs = *lhs % rhs; }
 Int ?%=?( Int * lhs, unsigned long int rhs ) { return *lhs = *lhs % rhs; }
 Int ?<<?( Int shiften, mp_bitcnt_t shift ) { Int shifted; mpz_mul_2exp( shifted.mpz, shiften.mpz, shift ); return shifted; }
 Int ?<<=?( Int * lhs, mp_bitcnt_t shift ) { return *lhs = *lhs << shift; }
 Int ?>>?( Int shiften, mp_bitcnt_t shift ) { Int shifted; mpz_fdiv_q_2exp( shifted.mpz, shiften.mpz, shift ); return shifted; }
 Int ?>>=?( Int * lhs, mp_bitcnt_t shift ) { return *lhs = *lhs >> shift; }
+static inline Int ?%=?( Int * lhs, Int rhs ) { return *lhs = *lhs % rhs; }
+static inline Int ?%=?( Int * lhs, long int rhs ) { return *lhs = *lhs % rhs; }
+static inline Int ?%=?( Int * lhs, unsigned long int rhs ) { return *lhs = *lhs % rhs; }
+static inline Int ?<<?( Int shiften, mp_bitcnt_t shift ) { Int shifted; mpz_mul_2exp( shifted.mpz, shiften.mpz, shift ); return shifted; }
+static inline Int ?<<=?( Int * lhs, mp_bitcnt_t shift ) { return *lhs = *lhs << shift; }
+static inline Int ?>>?( Int shiften, mp_bitcnt_t shift ) { Int shifted; mpz_fdiv_q_2exp( shifted.mpz, shiften.mpz, shift ); return shifted; }
+static inline Int ?>>=?( Int * lhs, mp_bitcnt_t shift ) { return *lhs = *lhs >> shift; }
 // number functions
 Int abs( Int oper ) { Int positive; mpz_abs( positive.mpz, oper.mpz ); return positive; }
 Int fact( unsigned long int N ) { Int factorial; mpz_fac_ui( factorial.mpz, N ); return factorial; }
 Int gcd( Int oper1, Int oper2 ) { Int gcdret; mpz_gcd( gcdret.mpz, oper1.mpz, oper2.mpz ); return gcdret; }
 Int pow( Int base, unsigned long int exponent ) { Int power; mpz_pow_ui( power.mpz, base.mpz, exponent ); return power; }
 Int pow( unsigned long int base, unsigned long int exponent ) { Int power; mpz_ui_pow_ui( power.mpz, base, exponent ); return power; }
 void srandom( gmp_randstate_t state ) { gmp_randinit_default( state ); }
 Int random( gmp_randstate_t state, mp_bitcnt_t n ) { Int rand; mpz_urandomb( rand.mpz, state, n ); return rand; }
 Int random( gmp_randstate_t state, Int n ) { Int rand; mpz_urandomm( rand.mpz, state, n.mpz ); return rand; }
 Int random( gmp_randstate_t state, mp_size_t max_size ) { Int rand; mpz_random( rand.mpz, max_size ); return rand; }
 int sgn( Int oper ) { return mpz_sgn( oper.mpz ); }
 Int sqrt( Int oper ) { Int root; mpz_sqrt( root.mpz, oper.mpz ); return root; }
+static inline Int abs( Int oper ) { Int positive; mpz_abs( positive.mpz, oper.mpz ); return positive; }
+static inline Int fact( unsigned long int N ) { Int factorial; mpz_fac_ui( factorial.mpz, N ); return factorial; }
+static inline Int gcd( Int oper1, Int oper2 ) { Int gcdret; mpz_gcd( gcdret.mpz, oper1.mpz, oper2.mpz ); return gcdret; }
+static inline Int pow( Int base, unsigned long int exponent ) { Int power; mpz_pow_ui( power.mpz, base.mpz, exponent ); return power; }
+static inline Int pow( unsigned long int base, unsigned long int exponent ) { Int power; mpz_ui_pow_ui( power.mpz, base, exponent ); return power; }
+static inline void srandom( gmp_randstate_t state ) { gmp_randinit_default( state ); }
+static inline Int random( gmp_randstate_t state, mp_bitcnt_t n ) { Int rand; mpz_urandomb( rand.mpz, state, n ); return rand; }
+static inline Int random( gmp_randstate_t state, Int n ) { Int rand; mpz_urandomm( rand.mpz, state, n.mpz ); return rand; }
+static inline Int random( gmp_randstate_t state, mp_size_t max_size ) { Int rand; mpz_random( rand.mpz, max_size ); return rand; }
+static inline int sgn( Int oper ) { return mpz_sgn( oper.mpz ); }
+static inline Int sqrt( Int oper ) { Int root; mpz_sqrt( root.mpz, oper.mpz ); return root; }
 // I/O
 forall( dtype istype | istream( istype ) )
+static inline forall( dtype istype | istream( istype ) )
 istype * ?|?( istype * is, Int * mp ) {
         gmp_scanf( "%Zd", mp );
 …
 } // ?|?
 forall( dtype ostype | ostream( ostype ) )
+static inline forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype * os, Int mp ) {
         if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );

src/libcfa/libhdr/libdebug.h

-              r9c951e3
+              rb1e63ac5
 #ifdef __CFA_DEBUG__
       #define LIB_DEBUG_DO(x) x
       #define LIB_NO_DEBUG_DO(x) ((void)0)
+        #define LIB_DEBUG_DO(x) x
+        #define LIB_NO_DEBUG_DO(x) ((void)0)
 #else
       #define LIB_DEBUG_DO(x) ((void)0)
       #define LIB_NO_DEBUG_DO(x) x
+        #define LIB_DEBUG_DO(x) ((void)0)
+        #define LIB_NO_DEBUG_DO(x) x
 #endif
+#if !defined(NDEBUG) && (defined(__CFA_DEBUG__) || defined(__CFA_VERIFY__))
+        #define verify(x) assert(x)
+        #define verifyf(x, ...) assertf(x, __VA_ARGS__)
+#else
+        #define verify(x)
+        #define verifyf(x, ...)
+#endif
 #ifdef __cforall

src/libcfa/math

-              r9c951e3
+              rb1e63ac5
 // Created On       : Mon Apr 18 23:37:04 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Apr 24 12:45:02 2016
 // Update Count     : 59
+// Last Modified On : Wed May 24 17:40:39 2017
+// Update Count     : 60
 //
 …
 #include <math.h>                                                                               // fpclassify, isfinite, isnormal, isnan, isinf
 } // extern "C"
-float fabs( float );
-// extern "C" { double fabs( double ); }
-long double fabs( long double );
-float cabs( float _Complex );
-// extern "C" { double cabs( double _Complex ); }
-long double cabs( long double _Complex );
 float ?%?( float, float );

src/libcfa/math.c

-              r9c951e3
+              rb1e63ac5
 // Created On       : Tue Apr 19 22:23:08 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Apr 24 08:52:31 2016
 // Update Count     : 75
+// Last Modified On : Tue May 23 22:52:13 2017
+// Update Count     : 76
 //
 …
 #include <complex.h>
 } // extern "C"
-float fabs( float x ) { return fabsf( x ); }
-long double fabs( long double x ) { return fabsl( x ); }
-float cabs( float _Complex x ) { return cabsf( x ); }
-long double cabs( long double _Complex x ) { return cabsl( x ); }
 float ?%?( float x, float y ) { return fmodf( x, y ); }

src/libcfa/stdlib

-              r9c951e3
+              rb1e63ac5
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue May  9 08:42:44 2017
 // Update Count     : 107
+// Last Modified On : Fri Jun  2 15:51:03 2017
+// Update Count     : 218
 //
 …
 //---------------------------------------
+extern "C" { void * malloc( size_t ); }                                 // use default C routine for void *
+forall( dtype T | sized(T) ) T * malloc( void );
+forall( dtype T | sized(T) ) T * malloc( char fill );
+forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size );
+forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size, unsigned char fill );
+extern "C" { void * calloc( size_t nmemb, size_t size ); } // use default C routine for void *
+forall( dtype T | sized(T) ) T * calloc( size_t nmemb );
+extern "C" { void * realloc( void * ptr, size_t size ); } // use default C routine for void *
+forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size );
+forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, unsigned char fill );
+forall( dtype T | sized(T) ) T * aligned_alloc( size_t alignment );
+forall( dtype T | sized(T) ) T * memalign( size_t alignment );          // deprecated
+forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t alignment );
+extern "C" {
+void * memset( void * ptr, int fill, size_t size );
+void free( void * ptr );
+} // extern "C"
+forall( dtype T, ttype Params | sized(T) | { void ?{}(T *, Params); } ) T * new( Params p );
+forall( dtype T | { void ^?{}(T *); } ) void delete( T * ptr );
+forall( dtype T, ttype Params | { void ^?{}(T *); void delete(Params); } ) void delete( T * ptr, Params rest );
+// allocation, non-array types
+static inline forall( dtype T | sized(T) ) T * malloc( void ) {
+        //printf( "X1\n" );
+        return (T *)(void *)malloc( (size_t)sizeof(T) );        // C malloc
+} // malloc
+extern "C" { void * calloc( size_t dim, size_t size ); } // default C routine
+static inline forall( dtype T | sized(T) ) T * calloc( size_t dim ) {
+        //printf( "X2\n" );
+        return (T *)(void *)calloc( dim, sizeof(T) );           // C cmalloc
+}
+extern "C" { void * realloc( void * ptr, size_t size ); } // default C routine for void *
+static inline forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size ) {
+        //printf( "X3\n" );
+        return (T *)(void *)realloc( (void *)ptr, size );
+}
+extern "C" { void * memalign( size_t align, size_t size ); } // use default C routine for void *
+static inline forall( dtype T | sized(T) ) T * memalign( size_t align ) {
+        //printf( "X4\n" );
+        return (T *)memalign( align, sizeof(T) );
+} // memalign
+static inline forall( dtype T | sized(T) ) T * aligned_alloc( size_t align ) {
+        //printf( "X5\n" );
+        return (T *)memalign( align, sizeof(T) );
+} // aligned_alloc
+extern "C" { int posix_memalign( void ** ptr, size_t align, size_t size ); } // use default C routine for void *
+static inline forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t align ) {
+        //printf( "X6\n" );
+        return posix_memalign( (void **)ptr, align, sizeof(T) );
+} // posix_memalign
+extern "C" { void * memset( void * dest, int c, size_t size ); } // use default C routine for void *
+static inline forall( dtype T | sized(T) ) T * alloc( void ) {
+        //printf( "X7\n" );
+        return (T *)(void *)malloc( (size_t)sizeof(T) );        // C malloc
+} // alloc
+static inline forall( dtype T | sized(T) ) T * alloc( char fill ) {
+        //printf( "X8\n" );
+        T * ptr = (T *)(void *)malloc( (size_t)sizeof(T) );     // C malloc
+    return memset( ptr, (int)fill, sizeof(T) );                 // initial with fill value
+} // alloc
+static inline forall( dtype T | sized(T) ) T * alloc( size_t dim ) {
+        //printf( "X9\n" );
+        return (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc
+} // alloc
+static inline forall( dtype T | sized(T) ) T * alloc( size_t dim, char fill ) {
+        //printf( "X10\n" );
+        T * ptr = (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc
+    return memset( ptr, (int)fill, dim * sizeof(T) );
+} // alloc
+static inline forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim ) {
+        //printf( "X11\n" );
+        return (void *)realloc( (void *)ptr, dim * (size_t)sizeof(T) ); // C realloc
+} // alloc
+forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill );
+static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align ) {
+        //printf( "X13\n" );
+        return (T *)memalign( align, sizeof(T) );
+} // align_alloc
+static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, char fill ) {
+        //printf( "X14\n" );
+    T * ptr = (T *)memalign( align, sizeof(T) );
+    return memset( ptr, (int)fill, sizeof(T) );
+} // align_alloc
+static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim ) {
+        //printf( "X15\n" );
+        return (T *)memalign( align, dim * sizeof(T) );
+} // align_alloc
+static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim, char fill ) {
+        //printf( "X16\n" );
+    T * ptr = (T *)memalign( align, dim * sizeof(T) );
+    return memset( ptr, (int)fill, dim * sizeof(T) );
+} // align_alloc
+// data, non-array types
+static inline forall( dtype T | sized(T) ) T * memset( T * dest, char c ) {
+        //printf( "X17\n" );
+        return memset( dest, c, sizeof(T) );
+} // memset
+extern "C" { void * memcpy( void * dest, const void * src, size_t size ); } // use default C routine for void *
+static inline forall( dtype T | sized(T) ) T * memcpy( T * dest, const T * src ) {
+        //printf( "X18\n" );
+        return memcpy( dest, src, sizeof(T) );
+} // memcpy
+// data, array types
+static inline forall( dtype T | sized(T) ) T * memset( T dest[], size_t dim, char c ) {
+        //printf( "X19\n" );
+        return (void *)memset( dest, c, dim * sizeof(T) );      // C memset
+} // memset
+static inline forall( dtype T | sized(T) ) T * memcpy( T dest[], const T src[], size_t dim ) {
+        //printf( "X20\n" );
+        return (void *)memcpy( dest, src, dim * sizeof(T) ); // C memcpy
+} // memcpy
+// allocation/deallocation and constructor/destructor, non-array types
+forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * new( Params p );
+forall( dtype T | { void ^?{}( T * ); } ) void delete( T * ptr );
+forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } ) void delete( T * ptr, Params rest );
+// allocation/deallocation and constructor/destructor, array types
+forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * anew( size_t dim, Params p );
+forall( dtype T | sized(T) | { void ^?{}( T * ); } ) void adelete( size_t dim, T arr[] );
+forall( dtype T | sized(T) | { void ^?{}( T * ); }, ttype Params | { void adelete( Params ); } ) void adelete( size_t dim, T arr[], Params rest );
 //---------------------------------------
 …
 forall( otype T | { int ?<?( T, T ); } )
 T * bsearch( T key, const T * arr, size_t dimension );
 forall( otype T | { int ?<?( T, T ); } )
 unsigned int bsearch( T key, const T * arr, size_t dimension );
 forall( otype T | { int ?<?( T, T ); } )
 void qsort( const T * arr, size_t dimension );
+T * bsearch( T key, const T * arr, size_t dim );
+forall( otype T | { int ?<?( T, T ); } )
+unsigned int bsearch( T key, const T * arr, size_t dim );
+forall( otype T | { int ?<?( T, T ); } )
+void qsort( const T * arr, size_t dim );
 //---------------------------------------
 …
 double abs( double _Complex );
 long double abs( long double _Complex );
 forall ( otype T | { void ?{}( T *, zero_t ); int ?<?( T, T ); T -?( T ); } )
+forall( otype T | { void ?{}( T *, zero_t ); int ?<?( T, T ); T -?( T ); } )
 T abs( T );
 …
 void rand48seed( long int s );
 char rand48();
 int rand48();
 unsigned int rand48();
 long int rand48();
 unsigned long int rand48();
 float rand48();
 double rand48();
 float _Complex rand48();
 double _Complex rand48();
 long double _Complex rand48();
+char rand48( void );
+int rand48( void );
+unsigned int rand48( void );
+long int rand48( void );
+unsigned long int rand48( void );
+float rand48( void );
+double rand48( void );
+float _Complex rand48( void );
+double _Complex rand48( void );
+long double _Complex rand48( void );
 //---------------------------------------

src/libcfa/stdlib.c

-              r9c951e3
+              rb1e63ac5
 // Created On       : Thu Jan 28 17:10:29 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue May  9 08:43:00 2017
 // Update Count     : 191
+// Last Modified On : Thu Jun  1 21:52:57 2017
+// Update Count     : 280
 //
 …
 #define _XOPEN_SOURCE 600                                                               // posix_memalign, *rand48
 #include <stdlib.h>                                                                             // malloc, free, calloc, realloc, memalign, posix_memalign, bsearch
 #include <string.h>                                                                             // memset
+#include <string.h>                                                                             // memcpy, memset
 #include <malloc.h>                                                                             // malloc_usable_size
 #include <math.h>                                                                               // fabsf, fabs, fabsl
 …
 } // extern "C"
+forall( dtype T | sized(T) ) T * malloc( void ) {               // type-safe
+    return (T *)(void *)malloc( (size_t)sizeof(T) );
+} // malloc
+forall( dtype T | sized(T) ) T * malloc( char fill ) {  // initial with fill value (like calloc)
+        T * ptr = (T *)(void *)malloc( (size_t)sizeof(T) );
+    return memset( ptr, (int)fill, sizeof(T) );
+} // malloc
+forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size ) { // alternative realloc
+    return (T *)realloc( ptr, size );
+} // malloc
+forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size, unsigned char fill ) { // alternative realloc with fill value
+    return (T *)realloc( ptr, size, fill );
+} // malloc
+forall( dtype T | sized(T) ) T * calloc( size_t nmemb ) { // type-safe array initialization with fill 0
+    return (T *)calloc( nmemb, sizeof(T) );
+} // calloc
+forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size ) { // type-safe
+    return (T *)(void *)realloc( (void *)ptr, size );
+} // realloc
+forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, unsigned char fill ) { // alternative realloc with fill value
+    char * nptr = (T *)(void *)realloc( (void *)ptr, size );
+    size_t unused = malloc_usable_size( nptr );
+    memset( nptr + size - unused, (int)fill, unused );  // initialize any new storage
+    return nptr;
+} // realloc
+forall( dtype T | sized(T) ) T * aligned_alloc( size_t alignment ) { // aligned allocation
+    return (T *)memalign( alignment, sizeof(T) );
+} // aligned_alloc
+forall( dtype T | sized(T) ) T * memalign( size_t alignment ) {
+    return (T *)memalign( alignment, sizeof(T) );
+} // memalign
+forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t alignment ) {
+    return posix_memalign( (void **)ptr, alignment, sizeof(T) );
+} // posix_memalign
+forall( dtype T, ttype Params | sized(T) | { void ?{}( T *, Params ); } ) //  new
+// resize, non-array types
+forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill ) {
+        size_t olen = malloc_usable_size( ptr );                        // current allocation
+    char * nptr = (void *)realloc( (void *)ptr, dim * (size_t)sizeof(T) ); // C realloc
+        size_t nlen = malloc_usable_size( nptr );                       // new allocation
+        if ( nlen > olen ) {                                                            // larger ?
+                memset( nptr + olen, (int)fill, nlen - olen );  // initialize added storage
+        } //
+    return (T *)nptr;
+} // alloc
+// allocation/deallocation and constructor/destructor, non-array types
+forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } )
 T * new( Params p ) {
         return ((T *)malloc()){ p };
+        return (malloc()){ p };                                                         // run constructor
 } // new
 forall( dtype T | { void ^?{}(T *); } )                                 // delete
+forall( dtype T | { void ^?{}( T * ); } )
 void delete( T * ptr ) {
         if ( ptr ) {
                 ^ptr{};
+        if ( ptr ) {                                                                            // ignore null
+                ^ptr{};                                                                                 // run destructor
                 free( ptr );
+        }
+        } // if
 } // delete
 forall( dtype T, ttype Params | { void ^?{}(T *); void delete(Params); } )
+forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } )
 void delete( T * ptr, Params rest ) {
         if ( ptr ) {
                 ^ptr{};
+        if ( ptr ) {                                                                            // ignore null
+                ^ptr{};                                                                                 // run destructor
                 free( ptr );
+        }
+        } // if
         delete( rest );
 } // delete
+// allocation/deallocation and constructor/destructor, array types
+forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } )
+T * anew( size_t dim, Params p ) {
+        T *arr = alloc( dim );
+        for ( unsigned int i = 0; i < dim; i += 1 ) {
+                (&arr[i]){ p };                                                                 // run constructor
+        } // for
+        return arr;
+} // anew
+forall( dtype T | sized(T) | { void ^?{}( T * ); } )
+void adelete( size_t dim, T arr[] ) {
+        if ( arr ) {                                                                            // ignore null
+                for ( int i = dim - 1; i >= 0; i -= 1 ) {               // reverse allocation order, must be unsigned
+                        ^(&arr[i]){};                                                           // run destructor
+                } // for
+                free( arr );
+        } // if
+} // adelete
+forall( dtype T | sized(T) | { void ^?{}( T * ); }, ttype Params | { void adelete( Params ); } )
+void adelete( size_t dim, T arr[], Params rest ) {
+        if ( arr ) {                                                                            // ignore null
+                for ( int i = dim - 1; i >= 0; i -= 1 ) {               // reverse allocation order, must be unsigned
+                        ^(&arr[i]){};                                                           // run destructor
+                } // for
+                free( arr );
+        } // if
+        adelete( rest );
+} // adelete
 //---------------------------------------
 …
 forall( otype T | { int ?<?( T, T ); } )
 T * bsearch( T key, const T * arr, size_t dimension ) {
+T * bsearch( T key, const T * arr, size_t dim ) {
         int comp( const void * t1, const void * t2 ) { return *(T *)t1 < *(T *)t2 ? -1 : *(T *)t2 < *(T *)t1 ? 1 : 0; }
         return (T *)bsearch( &key, arr, dimension, sizeof(T), comp );
+        return (T *)bsearch( &key, arr, dim, sizeof(T), comp );
 } // bsearch
 forall( otype T | { int ?<?( T, T ); } )
 unsigned int bsearch( T key, const T * arr, size_t dimension ) {
         T *result = bsearch( key, arr, dimension );
         return result ? result - arr : dimension;                       // pointer subtraction includes sizeof(T)
+unsigned int bsearch( T key, const T * arr, size_t dim ) {
+        T *result = bsearch( key, arr, dim );
+        return result ? result - arr : dim;                                     // pointer subtraction includes sizeof(T)
 } // bsearch
 forall( otype T | { int ?<?( T, T ); } )
 void qsort( const T * arr, size_t dimension ) {
+void qsort( const T * arr, size_t dim ) {
         int comp( const void * t1, const void * t2 ) { return *(T *)t1 < *(T *)t2 ? -1 : *(T *)t2 < *(T *)t1 ? 1 : 0; }
         qsort( arr, dimension, sizeof(T), comp );
+        qsort( arr, dim, sizeof(T), comp );
 } // qsort
 …
 void rand48seed( long int s ) { srand48( s ); }
 char rand48() { return mrand48(); }
 int rand48() { return mrand48(); }
 unsigned int rand48() { return lrand48(); }
 long int rand48() { return mrand48(); }
 unsigned long int rand48() { return lrand48(); }
 float rand48() { return (float)drand48(); }                             // otherwise float uses lrand48
 double rand48() { return drand48(); }
 float _Complex rand48() { return (float)drand48() + (float _Complex)(drand48() * _Complex_I); }
 double _Complex rand48() { return drand48() + (double _Complex)(drand48() * _Complex_I); }
 long double _Complex rand48() { return (long double)drand48() + (long double _Complex)(drand48() * _Complex_I); }
+char rand48( void ) { return mrand48(); }
+int rand48( void ) { return mrand48(); }
+unsigned int rand48( void ) { return lrand48(); }
+long int rand48( void ) { return mrand48(); }
+unsigned long int rand48( void ) { return lrand48(); }
+float rand48( void ) { return (float)drand48(); }               // otherwise float uses lrand48
+double rand48( void ) { return drand48(); }
+float _Complex rand48( void ) { return (float)drand48() + (float _Complex)(drand48() * _Complex_I); }
+double _Complex rand48( void ) { return drand48() + (double _Complex)(drand48() * _Complex_I); }
+long double _Complex rand48( void) { return (long double)drand48() + (long double _Complex)(drand48() * _Complex_I); }
 //---------------------------------------

src/main.cc

-              r9c951e3
+              rb1e63ac5
 // Author           : Richard C. Bilson
 // Created On       : Fri May 15 23:12:02 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Wed May 10 14:45:00 2017
 // Update Count     : 437
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Jun 29 12:46:50 2017
+// Update Count     : 441
 //
 …
 using namespace std;
+#include "Parser/lex.h"
+#include "Parser/parser.h"
+#include "Parser/parser.hh"
 #include "Parser/TypedefTable.h"
 #include "GenPoly/Lvalue.h"
 …
         bresolvep = false,
         bboxp = false,
+        bcodegenp = false,
         ctorinitp = false,
         declstatsp = false,
 …
 } // sigSegvBusHandler
 void sigAbortHandler( int sig_num ) {
+void sigAbortHandler( __attribute__((unused)) int sig_num ) {
         backtrace( 6 );                                                                         // skip first 6 stack frames
         signal( SIGABRT, SIG_DFL);                                                      // reset default signal handler
 …
                 if ( ! nopreludep ) {                                                   // include gcc builtins
                         // -l is for initial build ONLY and builtins.cf is not in the lib directory so access it here.
+                        FILE * builtins = fopen( libcfap | treep ? "../prelude/builtins.cf" : CFA_LIBDIR "/builtins.cf", "r" );
+                        assertf( builtins, "cannot open builtins.cf\n" );
+                        parse( builtins, LinkageSpec::Compiler );
+                        // Read to gcc builtins, if not generating the cfa library
+                        FILE * gcc_builtins = fopen( libcfap | treep ? "../prelude/gcc-builtins.cf" : CFA_LIBDIR "/gcc-builtins.cf", "r" );
+                        assertf( gcc_builtins, "cannot open gcc-builtins.cf\n" );
+                        parse( gcc_builtins, LinkageSpec::Compiler );
                         // read the extra prelude in, if not generating the cfa library
 …
                                 assertf( prelude, "cannot open prelude.cf\n" );
                                 parse( prelude, LinkageSpec::Intrinsic );
+                                // Read to cfa builtins, if not generating the cfa library
+                                FILE * builtins = fopen( libcfap | treep ? "../prelude/builtins.cf" : CFA_LIBDIR "/builtins.cf", "r" );
+                                assertf( builtins, "cannot open builtins.cf\n" );
+                                parse( builtins, LinkageSpec::Builtin );
                         } // if
                 } // if
 …
                 OPTPRINT( "box" )
                 GenPoly::box( translationUnit );
+                if ( bcodegenp ) {
+                        dump( translationUnit );
+                        return 0;
+                }
                 if ( optind < argc ) {                                                  // any commands after the flags and input file ? => output file name
 …
         int c;
         while ( (c = getopt_long( argc, argv, "abBcdefglLmnpqrstTvyzZD:F:", long_opts, &long_index )) != -1 ) {
+        while ( (c = getopt_long( argc, argv, "abBcCdefglLmnpqrstTvyzZD:F:", long_opts, &long_index )) != -1 ) {
                 switch ( c ) {
                   case Ast:
 …
                         ctorinitp = true;
                         break;
+                  case 'C':                                                                             // print before code generation
+                        bcodegenp = true;
+                        break;
                   case DeclStats:
                   case 'd':
 …
                         break;
                   case '?':
+                        assertf( false, "Unknown option: '%c'\n", (char)optopt );
+                        if ( optopt ) {                                                         // short option ?
+                                assertf( false, "Unknown option: -%c\n", (char)optopt );
+                        } else {
+                                assertf( false, "Unknown option: %s\n", argv[optind - 1] );
+                        } // if
                   default:
                         abort();

src/prelude/Makefile.am

-              r9c951e3
+              rb1e63ac5
 # put into lib for now
 cfalibdir = ${CFA_LIBDIR}
 cfalib_DATA = builtins.cf extras.cf prelude.cf bootloader.c
+cfalib_DATA = gcc-builtins.cf builtins.cf extras.cf prelude.cf bootloader.c
 noinst_DATA = ../libcfa/libcfa-prelude.c
+$(DEPDIR) :
+        mkdir $(DEPDIR)
+$(DEPDIR)/builtins.Po : $(DEPDIR)
+        touch ${@}
 # create extra forward types/declarations to reduce inclusion of library files
 …
 # create forward declarations for gcc builtins
 builtins.cf : builtins.c prototypes.sed
+gcc-builtins.cf : gcc-builtins.c prototypes.sed
         ${AM_V_GEN}@BACKEND_CC@ -E -P $< | sed -f prototypes.sed > $@
 builtins.c : builtins.def prototypes.awk
+gcc-builtins.c : builtins.def prototypes.awk
         ${AM_V_GEN}@BACKEND_CC@ -E prototypes.c | awk -f prototypes.awk > $@
 …
 prototypes.awk :
+../libcfa/libcfa-prelude.c : prelude.cf extras.cf builtins.cf ${abs_top_srcdir}/src/driver/cfa-cpp
+# create forward declarations for cfa builtins
+builtins.cf : builtins.c
+        ${AM_V_GEN}@BACKEND_CC@ -E -P ${<} -o ${@} -MD -MP -MF $(DEPDIR)/builtins.Po
+        ${AM_V_at}sed -i 's/builtins.o/builtins.cf/g' $(DEPDIR)/builtins.Po
+include $(DEPDIR)/builtins.Po
+../libcfa/libcfa-prelude.c : prelude.cf extras.cf gcc-builtins.cf builtins.cf ${abs_top_srcdir}/src/driver/cfa-cpp
         ${AM_V_GEN}${abs_top_srcdir}/src/driver/cfa-cpp -l prelude.cf $@  # use src/cfa-cpp as not in lib until after install
 bootloader.c : bootloader.cf prelude.cf extras.cf builtins.cf ${abs_top_srcdir}/src/driver/cfa-cpp
+bootloader.c : bootloader.cf prelude.cf extras.cf gcc-builtins.cf builtins.cf ${abs_top_srcdir}/src/driver/cfa-cpp
         ${AM_V_GEN}${abs_top_srcdir}/src/driver/cfa-cpp -tpmL bootloader.cf $@  # use src/cfa-cpp as not in lib until after install
+MAINTAINERCLEANFILES = builtins.c builtins.cf extras.cf bootloader.c ${addprefix ${libdir}/,${cfalib_DATA}} ${addprefix ${libdir}/,${lib_LIBRARIES}}
+maintainer-clean-local :
+        rm -rf $(DEPDIR)
+MAINTAINERCLEANFILES = gcc-builtins.c gcc-builtins.cf builtins.cf extras.cf bootloader.c ${addprefix ${libdir}/,${cfalib_DATA}} ${addprefix ${libdir}/,${lib_LIBRARIES}}

src/prelude/Makefile.in

-              r9c951e3
+              rb1e63ac5
 # put into lib for now
 cfalibdir = ${CFA_LIBDIR}
 cfalib_DATA = builtins.cf extras.cf prelude.cf bootloader.c
+cfalib_DATA = gcc-builtins.cf builtins.cf extras.cf prelude.cf bootloader.c
 noinst_DATA = ../libcfa/libcfa-prelude.c
 MAINTAINERCLEANFILES = builtins.c builtins.cf extras.cf bootloader.c ${addprefix ${libdir}/,${cfalib_DATA}} ${addprefix ${libdir}/,${lib_LIBRARIES}}
+MAINTAINERCLEANFILES = gcc-builtins.c gcc-builtins.cf builtins.cf extras.cf bootloader.c ${addprefix ${libdir}/,${cfalib_DATA}} ${addprefix ${libdir}/,${lib_LIBRARIES}}
 all: all-am
 …
 maintainer-clean: maintainer-clean-am
         -rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+maintainer-clean-am: distclean-am maintainer-clean-generic \
+        maintainer-clean-local
 mostlyclean: mostlyclean-am
 …
         install-ps install-ps-am install-strip installcheck \
         installcheck-am installdirs maintainer-clean \
+        maintainer-clean-generic mostlyclean mostlyclean-generic pdf \
+        pdf-am ps ps-am uninstall uninstall-am uninstall-cfalibDATA
+        maintainer-clean-generic maintainer-clean-local mostlyclean \
+        mostlyclean-generic pdf pdf-am ps ps-am uninstall uninstall-am \
+        uninstall-cfalibDATA
+$(DEPDIR) :
+        mkdir $(DEPDIR)
+$(DEPDIR)/builtins.Po : $(DEPDIR)
+        touch ${@}
 # create extra forward types/declarations to reduce inclusion of library files
 …
 # create forward declarations for gcc builtins
 builtins.cf : builtins.c prototypes.sed
+gcc-builtins.cf : gcc-builtins.c prototypes.sed
         ${AM_V_GEN}@BACKEND_CC@ -E -P $< | sed -f prototypes.sed > $@
 builtins.c : builtins.def prototypes.awk
+gcc-builtins.c : builtins.def prototypes.awk
         ${AM_V_GEN}@BACKEND_CC@ -E prototypes.c | awk -f prototypes.awk > $@
 …
 prototypes.awk :
+../libcfa/libcfa-prelude.c : prelude.cf extras.cf builtins.cf ${abs_top_srcdir}/src/driver/cfa-cpp
+# create forward declarations for cfa builtins
+builtins.cf : builtins.c
+        ${AM_V_GEN}@BACKEND_CC@ -E -P ${<} -o ${@} -MD -MP -MF $(DEPDIR)/builtins.Po
+        ${AM_V_at}sed -i 's/builtins.o/builtins.cf/g' $(DEPDIR)/builtins.Po
+include $(DEPDIR)/builtins.Po
+../libcfa/libcfa-prelude.c : prelude.cf extras.cf gcc-builtins.cf builtins.cf ${abs_top_srcdir}/src/driver/cfa-cpp
         ${AM_V_GEN}${abs_top_srcdir}/src/driver/cfa-cpp -l prelude.cf $@  # use src/cfa-cpp as not in lib until after install
 bootloader.c : bootloader.cf prelude.cf extras.cf builtins.cf ${abs_top_srcdir}/src/driver/cfa-cpp
+bootloader.c : bootloader.cf prelude.cf extras.cf gcc-builtins.cf builtins.cf ${abs_top_srcdir}/src/driver/cfa-cpp
         ${AM_V_GEN}${abs_top_srcdir}/src/driver/cfa-cpp -tpmL bootloader.cf $@  # use src/cfa-cpp as not in lib until after install
+maintainer-clean-local :
+        rm -rf $(DEPDIR)
 # Tell versions [3.59,3.63) of GNU make to not export all variables.

src/prelude/prelude.cf

-              r9c951e3
+              rb1e63ac5
 // forall( dtype DT ) signed int ?!=?( const volatile void *, const volatile DT * );
 // forall( dtype DT ) signed int ?==?( const volatile DT *, forall( dtype DT2 )const DT2 * );
 // forall( dtype DT ) signed int ?==?( forall( dtype DT2 )const DT2 *, const volatile DT * );
 // forall( ftype FT ) signed int ?==?( FT *, forall( ftype FT2 )FT2 * );
 // forall( ftype FT ) signed int ?==?( forall( ftype FT2 )FT2 *, FT * );
 // forall( dtype DT ) signed int ?!=?( const volatile DT *, forall( dtype DT2 )const DT2 * );
 // forall( dtype DT ) signed int ?!=?( forall( dtype DT2 )const DT2 *, const volatile DT * );
 // forall( ftype FT ) signed int ?!=?( FT *, forall( ftype FT2 )FT2 * );
 // forall( ftype FT ) signed int ?!=?( forall( ftype FT2 )FT2 *, FT * );
+// forall( dtype DT ) signed int ?==?( const volatile DT *, zero_t );
+// forall( dtype DT ) signed int ?==?( zero_t, const volatile DT * );
+// forall( ftype FT ) signed int ?==?( FT *, zero_t );
+// forall( ftype FT ) signed int ?==?( zero_t, FT * );
+// forall( dtype DT ) signed int ?!=?( const volatile DT *, zero_t );
+// forall( dtype DT ) signed int ?!=?( zero_t, const volatile DT * );
+// forall( ftype FT ) signed int ?!=?( FT *, zero_t );
+// forall( ftype FT ) signed int ?!=?( zero_t, FT * );
 // ------------------------------------------------------------
 …
 const volatile void *   ?=?( const volatile void * volatile *, const volatile void * );
 //forall( dtype DT ) DT *                       ?=?(                DT *          *, forall( dtype DT2 ) const DT2 * );
 //forall( dtype DT ) DT *                       ?=?(                DT * volatile *, forall( dtype DT2 ) const DT2 * );
 forall( dtype DT ) const DT *           ?=?( const          DT *          *, forall( dtype DT2 ) const DT2 * );
 forall( dtype DT ) const DT *           ?=?( const          DT * volatile *, forall( dtype DT2 ) const DT2 * );
 //forall( dtype DT ) volatile DT *      ?=?( volatile       DT *          *, forall( dtype DT2 ) const DT2 * );
 //forall( dtype DT ) volatile DT *      ?=?( volatile       DT * volatile *, forall( dtype DT2 ) const DT2 * );
 forall( dtype DT ) const volatile DT *  ?=?( const volatile DT *          *, forall( dtype DT2 ) const DT2 * );
 forall( dtype DT ) const volatile DT *  ?=?( const volatile DT * volatile *, forall( dtype DT2 ) const DT2 * );
 forall( ftype FT ) FT *                 ?=?( FT *          *, forall( ftype FT2 ) FT2 * );
 forall( ftype FT ) FT *                 ?=?( FT * volatile *, forall( ftype FT2 ) FT2 * );
+// //forall( dtype DT ) DT *                    ?=?(                DT *          *, zero_t );
+// //forall( dtype DT ) DT *                    ?=?(                DT * volatile *, zero_t );
+// forall( dtype DT ) const DT *                ?=?( const          DT *          *, zero_t );
+// forall( dtype DT ) const DT *                ?=?( const          DT * volatile *, zero_t );
+// //forall( dtype DT ) volatile DT *   ?=?( volatile       DT *          *, zero_t );
+// //forall( dtype DT ) volatile DT *   ?=?( volatile       DT * volatile *,  );
+// forall( dtype DT ) const volatile DT *       ?=?( const volatile DT *          *, zero_t );
+// forall( dtype DT ) const volatile DT *       ?=?( const volatile DT * volatile *, zero_t );
+// forall( ftype FT ) FT *                      ?=?( FT *          *, zero_t );
+// forall( ftype FT ) FT *                      ?=?( FT * volatile *, zero_t );
 forall( dtype T | sized(T) ) T *                        ?+=?(                T *          *, ptrdiff_t );
 …
 void    ?{}( const volatile void *          *, const volatile void * );
 //forall( dtype DT ) void ?{}(              DT *          *, forall( dtype DT2 ) const DT2 * );
 //forall( dtype DT ) void ?{}(              DT * volatile *, forall( dtype DT2 ) const DT2 * );
 forall( dtype DT ) void ?{}( const          DT *          *, forall( dtype DT2 ) const DT2 * );
 //forall( dtype DT ) void ?{}( volatile     DT *          *, forall( dtype DT2 ) const DT2 * );
 //forall( dtype DT ) void ?{}( volatile     DT * volatile *, forall( dtype DT2 ) const DT2 * );
 forall( dtype DT ) void ?{}( const volatile DT *          *, forall( dtype DT2 ) const DT2 * );
 forall( ftype FT ) void ?{}( FT *          *, forall( ftype FT2 ) FT2 * );
+// //forall( dtype DT ) void ?{}(                   DT *          *, zero_t );
+// //forall( dtype DT ) void ?{}(                   DT * volatile *, zero_t );
+// forall( dtype DT ) void ?{}( const       DT *          *, zero_t );
+// //forall( dtype DT ) void ?{}( volatile          DT *          *, zero_t );
+// //forall( dtype DT ) void ?{}( volatile          DT * volatile *, zero_t );
+// forall( dtype DT ) void ?{}( const volatile DT *       *, zero_t );
+// forall( ftype FT ) void      ?{}( FT *          *, zero_t );
 // default ctors

src/tests/.expect/32/KRfunctions.txt

r9c951e3	rb1e63ac5
6	6	extern int printf(const char *__restrict __format, ...);
7	7	int __f0__Fi_iPCii__1(int __a__i_1, const int *__b__PCi_1, int __c__i_1){
8		int ___retval_f0__i_1;
	8	__attribute__ ((unused)) int ___retval_f0__i_1;
9	9	}
10	10	int __f1__Fi_PiiPi__1(int __a__Pi_1, __attribute__ ((unused)) int __b__i_1, int __c__Pi_1){
11		int ___retval_f1__i_1;
	11	__attribute__ ((unused)) int ___retval_f1__i_1;
12	12	}
13	13	int __f2__Fi_iPiPi__1(int __a__i_1, int __b__Pi_1, int __c__Pi_1){
14		int ___retval_f2__i_1;
	14	__attribute__ ((unused)) int ___retval_f2__i_1;
15	15	}
16	16	struct S {
…	…
40	40	}
41	41	int __f3__Fi_2sS2sSPi__1(struct S __a__2sS_1, struct S __b__2sS_1, int *__c__Pi_1){
42		int ___retval_f3__i_1;
	42	__attribute__ ((unused)) int ___retval_f3__i_1;
43	43	struct S __s__2sS_2;
44	44	}
45	45	int __f4__Fi_iPiPi__1(int __a__i_1, int __b__Pi_1, int __c__Pi_1){
46		int ___retval_f4__i_1;
	46	__attribute__ ((unused)) int ___retval_f4__i_1;
47	47	}
48	48	int __f5__Fi_iPiPi__1(int __a__i_1, int __b__Pi_1, int __c__Pi_1){
49		int ___retval_f5__i_1;
	49	__attribute__ ((unused)) int ___retval_f5__i_1;
50	50	}
51	51	int (__f6__FPFi_i__iPiPi__1(int __a__i_1, int __b__Pi_1, int *__c__Pi_1))(int __anonymous_object0){
52		int (*___retval_f6__PFi_i__1)(int __anonymous_object1);
	52	__attribute__ ((unused)) int (*___retval_f6__PFi_i__1)(int __anonymous_object1);
53	53	}
54	54	int (__f7__FPFi_ii__iPiPi__1(int __a__i_1, int __b__Pi_1, int *__c__Pi_1))(int __a__i_1, int __b__i_1){
55		int (*___retval_f7__PFi_ii__1)(int __a__i_1, int __b__i_1);
	55	__attribute__ ((unused)) int (*___retval_f7__PFi_ii__1)(int __a__i_1, int __b__i_1);
56	56	}
57	57	int __f8__FPi_iPiPi__1(int __a__i_1, int __b__Pi_1, int *__c__Pi_1){
58		int *___retval_f8__Pi_1;
	58	__attribute__ ((unused)) int *___retval_f8__Pi_1;
59	59	}
60	60	int const __f9__FCPi_PiiPi__1(int __a__Pi_1, int __b__i_1, int *__c__Pi_1){
61		int *const ___retval_f9__CPi_1;
	61	__attribute__ ((unused)) int *const ___retval_f9__CPi_1;
62	62	}
63	63	int (__f10__FPFPi_ii__iPiPid__1(int __a__i_1, int __b__Pi_1, int __c__Pi_1, double __y__d_1))(int __x__i_1, int __y__i_1){
64		int (___retval_f10__PFPi_ii__1)(int __x__i_1, int __y__i_1);
	64	__attribute__ ((unused)) int (___retval_f10__PFPi_ii__1)(int __x__i_1, int __y__i_1);
65	65	int *__x__FPi_ii__2(int __anonymous_object2, int __anonymous_object3);
66	66	((void)(___retval_f10__PFPi_ii__1=__x__FPi_ii__2) /* ?{} */);
…	…
68	68	}
69	69	int (__f11__FPA0i_iPiPi__1(int __a__i_1, int __b__Pi_1, int *__c__Pi_1))[]{
70		int (*___retval_f11__PA0i_1)[];
	70	__attribute__ ((unused)) int (*___retval_f11__PA0i_1)[];
71	71	}
72	72	int (__f12__FPA0A0i_iPiPi__1(int __a__i_1, int __b__Pi_1, int *__c__Pi_1))[][((unsigned int )10)]{
73		int (*___retval_f12__PA0A0i_1)[][((unsigned int )10)];
	73	__attribute__ ((unused)) int (*___retval_f12__PA0A0i_1)[][((unsigned int )10)];
74	74	}
75	75	int (__f13__FPA0A0i_iPiPi__1(int __a__i_1, int __b__Pi_1, int *__c__Pi_1))[][((unsigned int )10)]{
76		int (*___retval_f13__PA0A0i_1)[][((unsigned int )10)];
	76	__attribute__ ((unused)) int (*___retval_f13__PA0A0i_1)[][((unsigned int )10)];
77	77	}
78	78	int (__f14__FPA0A0i_iPiPi__1(int __a__i_1, int __b__Pi_1, int *__c__Pi_1))[][((unsigned int )10)]{
79		int (*___retval_f14__PA0A0i_1)[][((unsigned int )10)];
	79	__attribute__ ((unused)) int (*___retval_f14__PA0A0i_1)[][((unsigned int )10)];
80	80	}
81	81	const int __fred__FCi___1(){
82		const int ___retval_fred__Ci_1;
	82	__attribute__ ((unused)) const int ___retval_fred__Ci_1;
83	83	int (__x__PFPi_ii__2)(int __anonymous_object4, int __anonymous_object5);
84	84	int __a__i_2;
…	…
88	88	((void)((((int (*)(int __x__i_1, int __y__i_1))(&_tmp_cp_ret0)))) / ^?{} */);
89	89	const int __f1__FCi_iPiPi__2(int __a__i_2, int __b__Pi_2, int __c__Pi_2){
90		const int ___retval_f1__Ci_2;
	90	__attribute__ ((unused)) const int ___retval_f1__Ci_2;
91	91	}
92	92	const int __f2__FCi_iii__2(int __a__i_2, int __b__i_2, int __c__i_2){
93		const int ___retval_f2__Ci_2;
	93	__attribute__ ((unused)) const int ___retval_f2__Ci_2;
94	94	}
95	95	}

src/tests/.expect/32/attributes.txt

-              r9c951e3
+              rb1e63ac5
 extern int printf(const char *__restrict __format, ...);
 int __la__Fi___1(){
     int ___retval_la__i_1;
+    __attribute__ ((unused)) int ___retval_la__i_1;
     L: __attribute__ ((unused)) ((void)1);
+}
 …
 __attribute__ ((unused,used)) int __f1__Fi___1();
 __attribute__ ((unused)) int __f1__Fi___1(){
     int ___retval_f1__i_1;
+    __attribute__ ((unused)) int ___retval_f1__i_1;
+}
 __attribute__ ((unused,unused,unused,used)) int **const __f2__FCPPi___1();
 __attribute__ ((unused,unused,unused)) int **const __f2__FCPPi___1(){
     int **const ___retval_f2__CPPi_1;
+    __attribute__ ((unused)) int **const ___retval_f2__CPPi_1;
+}
 __attribute__ ((unused,used,unused)) int (*__f3__FPA0i_i__1(int __anonymous_object1))[];
 __attribute__ ((unused,unused)) int (*__f3__FPA0i_i__1(int __p__i_1))[]{
     int (*___retval_f3__PA0i_1)[];
+    __attribute__ ((unused)) int (*___retval_f3__PA0i_1)[];
+}
 __attribute__ ((unused,used,unused)) int (*__f4__FPFi_i____1())(int __anonymous_object2);
 __attribute__ ((unused,unused)) int (*__f4__FPFi_i____1())(int __anonymous_object3){
     int (*___retval_f4__PFi_i__1)(int __anonymous_object4);
+    __attribute__ ((unused)) int (*___retval_f4__PFi_i__1)(int __anonymous_object4);
+}
 int __vtr__Fi___1(){
     int ___retval_vtr__i_1;
+    __attribute__ ((unused)) int ___retval_vtr__i_1;
     __attribute__ ((unused,unused,used)) int __t1__i_2;
     __attribute__ ((unused,unused,unused,unused,unused)) int **__t2__PPi_2;
 …
 int __ipd1__Fi_ii__1(__attribute__ ((unused,unused,unused)) int __p__i_1, __attribute__ ((unused,unused,unused)) int __q__i_1);
 int __ipd1__Fi_ii__1(__attribute__ ((unused,unused,unused)) int __p__i_1, __attribute__ ((unused,unused,unused)) int __q__i_1){
     int ___retval_ipd1__i_1;
+    __attribute__ ((unused)) int ___retval_ipd1__i_1;
+}
 int __ipd2__Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) int *__p__Pi_1, __attribute__ ((unused,unused,unused)) int *__q__Pi_1);
 int __ipd2__Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) int *__p__Pi_1, __attribute__ ((unused,unused,unused)) int *__q__Pi_1){
     int ___retval_ipd2__i_1;
+    __attribute__ ((unused)) int ___retval_ipd2__i_1;
+}
 int __ipd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) int *__p__Pi_1, __attribute__ ((unused,unused,unused)) int *__q__Pi_1);
 int __ipd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) int *__p__Pi_1, __attribute__ ((unused,unused,unused)) int *__q__Pi_1){
     int ___retval_ipd3__i_1;
+    __attribute__ ((unused)) int ___retval_ipd3__i_1;
+}
 int __ipd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) int (*__p__PFi___1)(), __attribute__ ((unused,unused,unused)) int (*__q__PFi___1)());
 int __ipd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) int (*__p__PFi___1)(), __attribute__ ((unused,unused,unused)) int (*__q__PFi___1)()){
     int ___retval_ipd4__i_1;
+    __attribute__ ((unused)) int ___retval_ipd4__i_1;
+}
 int __tpr1__Fi_i__1(__attribute__ ((unused,unused,unused)) int __Foo__i_1);
 …
 int __tpr7__Fi_PFi_PFi_i____1(__attribute__ ((unused,unused)) int (*__anonymous_object7)(__attribute__ ((unused)) int (*__anonymous_object8)(__attribute__ ((unused,unused)) int __anonymous_object9)));
 int __ad__Fi___1(){
     int ___retval_ad__i_1;
+    __attribute__ ((unused)) int ___retval_ad__i_1;
     __attribute__ ((used,unused)) int __ad1__i_2;
     __attribute__ ((unused,unused,unused)) int *__ad2__Pi_2;

src/tests/.expect/32/declarationSpecifier.txt

-              r9c951e3
+              rb1e63ac5
 static inline volatile const short __f48__FCVs___1();
 int __main__Fi_iPPCc__1(int __argc__i_1, const char **__argv__PPCc_1){
     int ___retval_main__i_1;
+    __attribute__ ((unused)) int ___retval_main__i_1;
     ((void)(___retval_main__i_1=((int )0)) /* ?{} */);
     return ((int )___retval_main__i_1);
 …
 static inline int invoke_main(int argc, char **argv, char **envp);
 int main(int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){
     int ___retval_main__i_1;
+    __attribute__ ((unused)) int ___retval_main__i_1;
     int _tmp_cp_ret0;
     ((void)(___retval_main__i_1=((_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1)) , _tmp_cp_ret0)) /* ?{} */);

src/tests/.expect/32/extension.txt

-              r9c951e3
+              rb1e63ac5
 __extension__ int j;
 __extension__ int __fred__Fi_i__1(int __p__i_1){
     int ___retval_fred__i_1;
+    __attribute__ ((unused)) int ___retval_fred__i_1;
     __extension__ struct S {
         __extension__ int __a__i_2;
 …
     ((void)((*((int *)(&_tmp_cp_ret0)))) /* ^?{} */);
     __extension__ int __mary__Fi_i__2(int __p__i_2){
         int ___retval_mary__i_2;
+        __attribute__ ((unused)) int ___retval_mary__i_2;
+    }
     ((void)__extension__ sizeof(3));

src/tests/.expect/32/gccExtensions.txt

-              r9c951e3
+              rb1e63ac5
 extern int __x__i_1 asm ( "xx" );
 int __main__Fi_iPPCc__1(int __argc__i_1, const char **__argv__PPCc_1){
     int ___retval_main__i_1;
+    __attribute__ ((unused)) int ___retval_main__i_1;
     asm ( "nop" :  :  :  );
     asm ( "nop" :  :  :  );
 …
     const int __i3__Ci_2;
     inline int __f1__Fi___2(){
         int ___retval_f1__i_2;
+        __attribute__ ((unused)) int ___retval_f1__i_2;
+    }
     inline int __f2__Fi___2(){
         int ___retval_f2__i_2;
+        __attribute__ ((unused)) int ___retval_f2__i_2;
+    }
     int __s1__i_2;
 …
 static inline int invoke_main(int argc, char **argv, char **envp);
 int main(int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){
     int ___retval_main__i_1;
+    __attribute__ ((unused)) int ___retval_main__i_1;
     int _tmp_cp_ret0;
     ((void)(___retval_main__i_1=((_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1)) , _tmp_cp_ret0)) /* ?{} */);

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

-              r9c951e3
+              rb1e63ac5
+fabs: 1 1 1 1.41421 1.41421356237309505 1.41421356237309505
+fmod: 1 1 1 1 1 1
+remainder: -1 -1 -1
+remquo: 7 0.0999999 7 0.1 7 0.0999999999999999999
+div: 7 0.0999999 7 0.1 7 0.0999999999999999999
+fma: -2 -2 -2
+fdim: 2 2 2
+nan: nan nan nan
+exp: 2.71828 2.71828182845905 2.71828182845904524 1.46869+2.28736i 1.46869393991589+2.28735528717884i 1.46869393991588516+2.28735528717884239i
+exp2: 2 2 2
+expm1: 1.71828 1.71828182845905 1.71828182845904524
+log: 0 0 0 0.346574+0.785398i 0.346573590279973+0.785398163397448i 0.346573590279972655+0.78539816339744831i
+log2: 3 3 3
+log10: 2 2 2
+log1p: 0.693147 0.693147180559945 0.693147180559945309
+ilogb: 0 0 0
+logb: 3 3 3
+sqrt: 1 1 1 1.09868+0.45509i 1.09868411346781+0.455089860562227i 1.09868411346780997+0.455089860562227341i
+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
+tan: 1.55741 1.5574077246549 1.55740772465490223 0.271753+1.08392i 0.271752585319512+1.08392332733869i 0.271752585319511717+1.08392332733869454i
+asin: 1.5708 1.5707963267949 1.57079632679489662 0.66624+1.06128i 0.666239432492515+1.06127506190504i 0.666239432492515255+1.06127506190503565i
+acos: 0 0 0 0.904557-1.06128i 0.904556894302381-1.06127506190504i 0.904556894302381364-1.06127506190503565i
+atan: 0.785398 0.785398163397448 0.78539816339744831 1.01722+0.402359i 1.01722196789785+0.402359478108525i 1.01722196789785137+0.402359478108525094i
+atan2: 0.785398 0.785398163397448 0.78539816339744831 atan: 0.785398 0.785398163397448 0.78539816339744831 sinh: 1.1752 1.1752011936438 1.17520119364380146 0.634964+1.29846i 0.634963914784736+1.29845758141598i 0.634963914784736108+1.29845758141597729i
+cosh: 1.54308 1.54308063481524 1.54308063481524378 0.83373+0.988898i 0.833730025131149+0.988897705762865i 0.833730025131149049+0.988897705762865096i
+tanh: 0.761594 0.761594155955765 0.761594155955764888 1.08392+0.271753i 1.08392332733869+0.271752585319512i 1.08392332733869454+0.271752585319511717i
+acosh: 0 0 0 1.06128+0.904557i 1.06127506190504+0.904556894302381i 1.06127506190503565+0.904556894302381364i
+asinh: 0.881374 0.881373587019543 0.881373587019543025 1.06128+0.666239i 1.06127506190504+0.666239432492515i 1.06127506190503565+0.666239432492515255i
+atanh: inf inf inf 0.402359+1.01722i 0.402359478108525+1.01722196789785i 0.402359478108525094+1.01722196789785137i
+erf: 0.842701 0.842700792949715 0.842700792949714869
+erfc: 0.157299 0.157299207050285 0.157299207050285131
+lgamma: 1.79176 1.79175946922805 1.791759469228055
+lgamma: 1.79176 1 1.79175946922805 1 1.791759469228055 1
+tgamma: 6 6 6
+floor: 1 1 1
+ceil: 2 2 2
+trunc: 3 3 3
+rint: 2 2 2
+rint: 2 2 2
+rint: 2 2 2
+lrint: 2 2 2
+llrint: 2 2 2
+nearbyint: 4 4 4
+round: 2 2 2
+round: 2 2 2
+round: 2 2 2
+lround: 2 2 2
+llround: 2 2 2
+copysign: -1 -1 -1
+frexp: 0.5 3 0.5 3 0.5 3
+ldexp: 8 8 8
+modf: 2 0.3 2 0.3 2 0.3 nextafter: 2 2 2
+nexttoward: 2 2 2
+scalbn: 16 16 16
+scalbln: 16 16 16
+fmod:1 1 1 1 1 1
+remainder:-1 -1 -1
+remquo:7 0.0999999 7 0.1 7 0.0999999999999999999
+div:7 0.0999999 7 0.1 7 0.0999999999999999999
+fma:-2 -2 -2
+fdim:2 2 2
+nan:nan nan nan
+exp:2.71828 2.71828182845905 2.71828182845904524 1.46869+2.28736i 1.46869393991589+2.28735528717884i 1.46869393991588516+2.28735528717884239i
+exp2:2 2 2
+expm1:1.71828 1.71828182845905 1.71828182845904524
+log:0 0 0 0.346574+0.785398i 0.346573590279973+0.785398163397448i 0.346573590279972655+0.78539816339744831i
+log2:3 3 3
+log10:2 2 2
+log1p:0.693147 0.693147180559945 0.693147180559945309
+ilogb:0 0 0
+logb:3 3 3
+sqrt:1 1 1 1.09868+0.45509i 1.09868411346781+0.455089860562227i 1.09868411346780997+0.455089860562227341i
+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
+tan:1.55741 1.5574077246549 1.55740772465490223 0.271753+1.08392i 0.271752585319512+1.08392332733869i 0.271752585319511717+1.08392332733869454i
+asin:1.5708 1.5707963267949 1.57079632679489662 0.66624+1.06128i 0.666239432492515+1.06127506190504i 0.666239432492515255+1.06127506190503565i
+acos:0 0 0 0.904557-1.06128i 0.904556894302381-1.06127506190504i 0.904556894302381364-1.06127506190503565i
+atan:0.785398 0.785398163397448 0.78539816339744831 1.01722+0.402359i 1.01722196789785+0.402359478108525i 1.01722196789785137+0.402359478108525094i
+atan2:0.785398 0.785398163397448 0.78539816339744831 atan:0.785398 0.785398163397448 0.78539816339744831 sinh:1.1752 1.1752011936438 1.17520119364380146 0.634964+1.29846i 0.634963914784736+1.29845758141598i 0.634963914784736108+1.29845758141597729i
+cosh:1.54308 1.54308063481524 1.54308063481524378 0.83373+0.988898i 0.833730025131149+0.988897705762865i 0.833730025131149049+0.988897705762865096i
+tanh:0.761594 0.761594155955765 0.761594155955764888 1.08392+0.271753i 1.08392332733869+0.271752585319512i 1.08392332733869454+0.271752585319511717i
+acosh:0 0 0 1.06128+0.904557i 1.06127506190504+0.904556894302381i 1.06127506190503565+0.904556894302381364i
+asinh:0.881374 0.881373587019543 0.881373587019543025 1.06128+0.666239i 1.06127506190504+0.666239432492515i 1.06127506190503565+0.666239432492515255i
+atanh:inf inf inf 0.402359+1.01722i 0.402359478108525+1.01722196789785i 0.402359478108525094+1.01722196789785137i
+erf:0.842701 0.842700792949715 0.842700792949714869
+erfc:0.157299 0.157299207050285 0.157299207050285131
+lgamma:1.79176 1.79175946922805 1.791759469228055
+lgamma:1.79176 1 1.79175946922805 1 1.791759469228055 1
+tgamma:6 6 6
+floor:1 1 1
+ceil:2 2 2
+trunc:3 3 3
+rint:2 2 2
+rint:2 2 2
+rint:2 2 2
+lrint:2 2 2
+llrint:2 2 2
+nearbyint:4 4 4
+round:2 2 2
+round:2 2 2
+round:2 2 2
+lround:2 2 2
+llround:2 2 2
+copysign:-1 -1 -1
+frexp:0.5 3 0.5 3 0.5 3
+ldexp:8 8 8
+modf:2 0.3 2 0.3 2 0.3 nextafter:2 2 2
+nexttoward:2 2 2
+scalbn:16 16 16
+scalbln:16 16 16

src/tests/.expect/64/KRfunctions.txt

r9c951e3	rb1e63ac5
6	6	extern int printf(const char *__restrict __format, ...);
7	7	int __f0__Fi_iPCii__1(int __a__i_1, const int *__b__PCi_1, int __c__i_1){
8		int ___retval_f0__i_1;
	8	__attribute__ ((unused)) int ___retval_f0__i_1;
9	9	}
10	10	int __f1__Fi_PiiPi__1(int __a__Pi_1, __attribute__ ((unused)) int __b__i_1, int __c__Pi_1){
11		int ___retval_f1__i_1;
	11	__attribute__ ((unused)) int ___retval_f1__i_1;
12	12	}
13	13	int __f2__Fi_iPiPi__1(int __a__i_1, int __b__Pi_1, int __c__Pi_1){
14		int ___retval_f2__i_1;
	14	__attribute__ ((unused)) int ___retval_f2__i_1;
15	15	}
16	16	struct S {
…	…
40	40	}
41	41	int __f3__Fi_2sS2sSPi__1(struct S __a__2sS_1, struct S __b__2sS_1, int *__c__Pi_1){
42		int ___retval_f3__i_1;
	42	__attribute__ ((unused)) int ___retval_f3__i_1;
43	43	struct S __s__2sS_2;
44	44	}
45	45	int __f4__Fi_iPiPi__1(int __a__i_1, int __b__Pi_1, int __c__Pi_1){
46		int ___retval_f4__i_1;
	46	__attribute__ ((unused)) int ___retval_f4__i_1;
47	47	}
48	48	int __f5__Fi_iPiPi__1(int __a__i_1, int __b__Pi_1, int __c__Pi_1){
49		int ___retval_f5__i_1;
	49	__attribute__ ((unused)) int ___retval_f5__i_1;
50	50	}
51	51	int (__f6__FPFi_i__iPiPi__1(int __a__i_1, int __b__Pi_1, int *__c__Pi_1))(int __anonymous_object0){
52		int (*___retval_f6__PFi_i__1)(int __anonymous_object1);
	52	__attribute__ ((unused)) int (*___retval_f6__PFi_i__1)(int __anonymous_object1);
53	53	}
54	54	int (__f7__FPFi_ii__iPiPi__1(int __a__i_1, int __b__Pi_1, int *__c__Pi_1))(int __a__i_1, int __b__i_1){
55		int (*___retval_f7__PFi_ii__1)(int __a__i_1, int __b__i_1);
	55	__attribute__ ((unused)) int (*___retval_f7__PFi_ii__1)(int __a__i_1, int __b__i_1);
56	56	}
57	57	int __f8__FPi_iPiPi__1(int __a__i_1, int __b__Pi_1, int *__c__Pi_1){
58		int *___retval_f8__Pi_1;
	58	__attribute__ ((unused)) int *___retval_f8__Pi_1;
59	59	}
60	60	int const __f9__FCPi_PiiPi__1(int __a__Pi_1, int __b__i_1, int *__c__Pi_1){
61		int *const ___retval_f9__CPi_1;
	61	__attribute__ ((unused)) int *const ___retval_f9__CPi_1;
62	62	}
63	63	int (__f10__FPFPi_ii__iPiPid__1(int __a__i_1, int __b__Pi_1, int __c__Pi_1, double __y__d_1))(int __x__i_1, int __y__i_1){
64		int (___retval_f10__PFPi_ii__1)(int __x__i_1, int __y__i_1);
	64	__attribute__ ((unused)) int (___retval_f10__PFPi_ii__1)(int __x__i_1, int __y__i_1);
65	65	int *__x__FPi_ii__2(int __anonymous_object2, int __anonymous_object3);
66	66	((void)(___retval_f10__PFPi_ii__1=__x__FPi_ii__2) /* ?{} */);
…	…
68	68	}
69	69	int (__f11__FPA0i_iPiPi__1(int __a__i_1, int __b__Pi_1, int *__c__Pi_1))[]{
70		int (*___retval_f11__PA0i_1)[];
	70	__attribute__ ((unused)) int (*___retval_f11__PA0i_1)[];
71	71	}
72	72	int (__f12__FPA0A0i_iPiPi__1(int __a__i_1, int __b__Pi_1, int *__c__Pi_1))[][((long unsigned int )10)]{
73		int (*___retval_f12__PA0A0i_1)[][((long unsigned int )10)];
	73	__attribute__ ((unused)) int (*___retval_f12__PA0A0i_1)[][((long unsigned int )10)];
74	74	}
75	75	int (__f13__FPA0A0i_iPiPi__1(int __a__i_1, int __b__Pi_1, int *__c__Pi_1))[][((long unsigned int )10)]{
76		int (*___retval_f13__PA0A0i_1)[][((long unsigned int )10)];
	76	__attribute__ ((unused)) int (*___retval_f13__PA0A0i_1)[][((long unsigned int )10)];
77	77	}
78	78	int (__f14__FPA0A0i_iPiPi__1(int __a__i_1, int __b__Pi_1, int *__c__Pi_1))[][((long unsigned int )10)]{
79		int (*___retval_f14__PA0A0i_1)[][((long unsigned int )10)];
	79	__attribute__ ((unused)) int (*___retval_f14__PA0A0i_1)[][((long unsigned int )10)];
80	80	}
81	81	const int __fred__FCi___1(){
82		const int ___retval_fred__Ci_1;
	82	__attribute__ ((unused)) const int ___retval_fred__Ci_1;
83	83	int (__x__PFPi_ii__2)(int __anonymous_object4, int __anonymous_object5);
84	84	int __a__i_2;
…	…
88	88	((void)((((int (*)(int __x__i_1, int __y__i_1))(&_tmp_cp_ret0)))) / ^?{} */);
89	89	const int __f1__FCi_iPiPi__2(int __a__i_2, int __b__Pi_2, int __c__Pi_2){
90		const int ___retval_f1__Ci_2;
	90	__attribute__ ((unused)) const int ___retval_f1__Ci_2;
91	91	}
92	92	const int __f2__FCi_iii__2(int __a__i_2, int __b__i_2, int __c__i_2){
93		const int ___retval_f2__Ci_2;
	93	__attribute__ ((unused)) const int ___retval_f2__Ci_2;
94	94	}
95	95	}

src/tests/.expect/64/attributes.txt

-              r9c951e3
+              rb1e63ac5
 extern int printf(const char *__restrict __format, ...);
 int __la__Fi___1(){
     int ___retval_la__i_1;
+    __attribute__ ((unused)) int ___retval_la__i_1;
     L: __attribute__ ((unused)) ((void)1);
+}
 …
 __attribute__ ((unused,used)) int __f1__Fi___1();
 __attribute__ ((unused)) int __f1__Fi___1(){
     int ___retval_f1__i_1;
+    __attribute__ ((unused)) int ___retval_f1__i_1;
+}
 __attribute__ ((unused,unused,unused,used)) int **const __f2__FCPPi___1();
 __attribute__ ((unused,unused,unused)) int **const __f2__FCPPi___1(){
     int **const ___retval_f2__CPPi_1;
+    __attribute__ ((unused)) int **const ___retval_f2__CPPi_1;
+}
 __attribute__ ((unused,used,unused)) int (*__f3__FPA0i_i__1(int __anonymous_object1))[];
 __attribute__ ((unused,unused)) int (*__f3__FPA0i_i__1(int __p__i_1))[]{
     int (*___retval_f3__PA0i_1)[];
+    __attribute__ ((unused)) int (*___retval_f3__PA0i_1)[];
+}
 __attribute__ ((unused,used,unused)) int (*__f4__FPFi_i____1())(int __anonymous_object2);
 __attribute__ ((unused,unused)) int (*__f4__FPFi_i____1())(int __anonymous_object3){
     int (*___retval_f4__PFi_i__1)(int __anonymous_object4);
+    __attribute__ ((unused)) int (*___retval_f4__PFi_i__1)(int __anonymous_object4);
+}
 int __vtr__Fi___1(){
     int ___retval_vtr__i_1;
+    __attribute__ ((unused)) int ___retval_vtr__i_1;
     __attribute__ ((unused,unused,used)) int __t1__i_2;
     __attribute__ ((unused,unused,unused,unused,unused)) int **__t2__PPi_2;
 …
 int __ipd1__Fi_ii__1(__attribute__ ((unused,unused,unused)) int __p__i_1, __attribute__ ((unused,unused,unused)) int __q__i_1);
 int __ipd1__Fi_ii__1(__attribute__ ((unused,unused,unused)) int __p__i_1, __attribute__ ((unused,unused,unused)) int __q__i_1){
     int ___retval_ipd1__i_1;
+    __attribute__ ((unused)) int ___retval_ipd1__i_1;
+}
 int __ipd2__Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) int *__p__Pi_1, __attribute__ ((unused,unused,unused)) int *__q__Pi_1);
 int __ipd2__Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) int *__p__Pi_1, __attribute__ ((unused,unused,unused)) int *__q__Pi_1){
     int ___retval_ipd2__i_1;
+    __attribute__ ((unused)) int ___retval_ipd2__i_1;
+}
 int __ipd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) int *__p__Pi_1, __attribute__ ((unused,unused,unused)) int *__q__Pi_1);
 int __ipd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) int *__p__Pi_1, __attribute__ ((unused,unused,unused)) int *__q__Pi_1){
     int ___retval_ipd3__i_1;
+    __attribute__ ((unused)) int ___retval_ipd3__i_1;
+}
 int __ipd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) int (*__p__PFi___1)(), __attribute__ ((unused,unused,unused)) int (*__q__PFi___1)());
 int __ipd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) int (*__p__PFi___1)(), __attribute__ ((unused,unused,unused)) int (*__q__PFi___1)()){
     int ___retval_ipd4__i_1;
+    __attribute__ ((unused)) int ___retval_ipd4__i_1;
+}
 int __tpr1__Fi_i__1(__attribute__ ((unused,unused,unused)) int __Foo__i_1);
 …
 int __tpr7__Fi_PFi_PFi_i____1(__attribute__ ((unused,unused)) int (*__anonymous_object7)(__attribute__ ((unused)) int (*__anonymous_object8)(__attribute__ ((unused,unused)) int __anonymous_object9)));
 int __ad__Fi___1(){
     int ___retval_ad__i_1;
+    __attribute__ ((unused)) int ___retval_ad__i_1;
     __attribute__ ((used,unused)) int __ad1__i_2;
     __attribute__ ((unused,unused,unused)) int *__ad2__Pi_2;

src/tests/.expect/64/declarationSpecifier.txt

-              r9c951e3
+              rb1e63ac5
 static inline volatile const short __f48__FCVs___1();
 int __main__Fi_iPPCc__1(int __argc__i_1, const char **__argv__PPCc_1){
     int ___retval_main__i_1;
+    __attribute__ ((unused)) int ___retval_main__i_1;
     ((void)(___retval_main__i_1=((int )0)) /* ?{} */);
     return ((int )___retval_main__i_1);
 …
 static inline int invoke_main(int argc, char **argv, char **envp);
 int main(int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){
     int ___retval_main__i_1;
+    __attribute__ ((unused)) int ___retval_main__i_1;
     int _tmp_cp_ret0;
     ((void)(___retval_main__i_1=((_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1)) , _tmp_cp_ret0)) /* ?{} */);

src/tests/.expect/64/extension.txt

-              r9c951e3
+              rb1e63ac5
 __extension__ int j;
 __extension__ int __fred__Fi_i__1(int __p__i_1){
     int ___retval_fred__i_1;
+    __attribute__ ((unused)) int ___retval_fred__i_1;
     __extension__ struct S {
         __extension__ int __a__i_2;
 …
     ((void)((*((int *)(&_tmp_cp_ret0)))) /* ^?{} */);
     __extension__ int __mary__Fi_i__2(int __p__i_2){
         int ___retval_mary__i_2;
+        __attribute__ ((unused)) int ___retval_mary__i_2;
+    }
     ((void)__extension__ sizeof(3));

src/tests/.expect/64/gccExtensions.txt

-              r9c951e3
+              rb1e63ac5
 extern int __x__i_1 asm ( "xx" );
 int __main__Fi_iPPCc__1(int __argc__i_1, const char **__argv__PPCc_1){
     int ___retval_main__i_1;
+    __attribute__ ((unused)) int ___retval_main__i_1;
     asm ( "nop" :  :  :  );
     asm ( "nop" :  :  :  );
 …
     const int __i3__Ci_2;
     inline int __f1__Fi___2(){
         int ___retval_f1__i_2;
+        __attribute__ ((unused)) int ___retval_f1__i_2;
+    }
     inline int __f2__Fi___2(){
         int ___retval_f2__i_2;
+        __attribute__ ((unused)) int ___retval_f2__i_2;
+    }
     int __s1__i_2;
 …
 static inline int invoke_main(int argc, char **argv, char **envp);
 int main(int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){
     int ___retval_main__i_1;
+    __attribute__ ((unused)) int ___retval_main__i_1;
     int _tmp_cp_ret0;
     ((void)(___retval_main__i_1=((_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1)) , _tmp_cp_ret0)) /* ?{} */);

src/tests/.expect/64/gmp.txt

-              r9c951e3
+              rb1e63ac5
 conversions
 y:97
+y:12345678901234567890123456789
 y:3
 y:-3
 …
 z:150000000000000000000
 z:16666666666666666666
+16666666666666666666, 2 16666666666666666666, 2
 x:16666666666666666666 y:2

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

-              r9c951e3
+              rb1e63ac5
+fabs: 1 1 1 1.41421 1.41421356237309505 1.41421356237309505
+fmod: 1 1 1 1 1 1
+remainder: -1 -1 -1
+remquo: 7 0.0999999 7 0.1 7 0.0999999999999999999
+div: 7 0.0999999 7 0.1 7 0.0999999999999999999
+fma: -2 -2 -2
+fdim: 2 2 2
+nan: nan nan nan
+exp: 2.71828 2.71828182845905 2.71828182845904524 1.46869+2.28736i 1.46869393991589+2.28735528717884i 1.46869393991588516+2.28735528717884239i
+exp2: 2 2 2
+expm1: 1.71828 1.71828182845905 1.71828182845904524
+log: 0 0 0 0.346574+0.785398i 0.346573590279973+0.785398163397448i 0.346573590279972655+0.78539816339744831i
+log2: 3 3 3
+log10: 2 2 2
+log1p: 0.693147 0.693147180559945 0.693147180559945309
+ilogb: 0 0 0
+logb: 3 3 3
+sqrt: 1 1 1 1.09868+0.45509i 1.09868411346781+0.455089860562227i 1.09868411346780997+0.455089860562227341i
+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
+tan: 1.55741 1.5574077246549 1.55740772465490223 0.271753+1.08392i 0.271752585319512+1.08392332733869i 0.271752585319511717+1.08392332733869454i
+asin: 1.5708 1.5707963267949 1.57079632679489662 0.666239+1.06128i 0.666239432492515+1.06127506190504i 0.666239432492515255+1.06127506190503565i
+acos: 0 0 0 0.904557-1.06128i 0.904556894302381-1.06127506190504i 0.904556894302381364-1.06127506190503565i
+atan: 0.785398 0.785398163397448 0.78539816339744831 1.01722+0.402359i 1.01722196789785+0.402359478108525i 1.01722196789785137+0.402359478108525094i
+atan2: 0.785398 0.785398163397448 0.78539816339744831 atan: 0.785398 0.785398163397448 0.78539816339744831 sinh: 1.1752 1.1752011936438 1.17520119364380146 0.634964+1.29846i 0.634963914784736+1.29845758141598i 0.634963914784736108+1.29845758141597729i
+cosh: 1.54308 1.54308063481524 1.54308063481524378 0.83373+0.988898i 0.833730025131149+0.988897705762865i 0.833730025131149049+0.988897705762865096i
+tanh: 0.761594 0.761594155955765 0.761594155955764888 1.08392+0.271753i 1.08392332733869+0.271752585319512i 1.08392332733869454+0.271752585319511717i
+acosh: 0 0 0 1.06128+0.904557i 1.06127506190504+0.904556894302381i 1.06127506190503565+0.904556894302381364i
+asinh: 0.881374 0.881373587019543 0.881373587019543025 1.06128+0.666239i 1.06127506190504+0.666239432492515i 1.06127506190503565+0.666239432492515255i
+atanh: inf inf inf 0.402359+1.01722i 0.402359478108525+1.01722196789785i 0.402359478108525094+1.01722196789785137i
+erf: 0.842701 0.842700792949715 0.842700792949714869
+erfc: 0.157299 0.157299207050285 0.157299207050285131
+lgamma: 1.79176 1.79175946922805 1.791759469228055
+lgamma: 1.79176 1 1.79175946922805 1 1.791759469228055 1
+tgamma: 6 6 6
+floor: 1 1 1
+ceil: 2 2 2
+trunc: 3 3 3
+rint: 2 2 2
+rint: 2 2 2
+rint: 2 2 2
+lrint: 2 2 2
+llrint: 2 2 2
+nearbyint: 4 4 4
+round: 2 2 2
+round: 2 2 2
+round: 2 2 2
+lround: 2 2 2
+llround: 2 2 2
+copysign: -1 -1 -1
+frexp: 0.5 3 0.5 3 0.5 3
+ldexp: 8 8 8
+modf: 2 0.3 2 0.3 2 0.3 nextafter: 2 2 2
+nexttoward: 2 2 2
+scalbn: 16 16 16
+scalbln: 16 16 16
+fmod:1 1 1 1 1 1
+remainder:-1 -1 -1
+remquo:7 0.0999999 7 0.1 7 0.0999999999999999999
+div:7 0.0999999 7 0.1 7 0.0999999999999999999
+fma:-2 -2 -2
+fdim:2 2 2
+nan:nan nan nan
+exp:2.71828 2.71828182845905 2.71828182845904524 1.46869+2.28736i 1.46869393991589+2.28735528717884i 1.46869393991588516+2.28735528717884239i
+exp2:2 2 2
+expm1:1.71828 1.71828182845905 1.71828182845904524
+log:0 0 0 0.346574+0.785398i 0.346573590279973+0.785398163397448i 0.346573590279972655+0.78539816339744831i
+log2:3 3 3
+log10:2 2 2
+log1p:0.693147 0.693147180559945 0.693147180559945309
+ilogb:0 0 0
+logb:3 3 3
+sqrt:1 1 1 1.09868+0.45509i 1.09868411346781+0.455089860562227i 1.09868411346780997+0.455089860562227341i
+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
+tan:1.55741 1.5574077246549 1.55740772465490223 0.271753+1.08392i 0.271752585319512+1.08392332733869i 0.271752585319511717+1.08392332733869454i
+asin:1.5708 1.5707963267949 1.57079632679489662 0.666239+1.06128i 0.666239432492515+1.06127506190504i 0.666239432492515255+1.06127506190503565i
+acos:0 0 0 0.904557-1.06128i 0.904556894302381-1.06127506190504i 0.904556894302381364-1.06127506190503565i
+atan:0.785398 0.785398163397448 0.78539816339744831 1.01722+0.402359i 1.01722196789785+0.402359478108525i 1.01722196789785137+0.402359478108525094i
+atan2:0.785398 0.785398163397448 0.78539816339744831 atan:0.785398 0.785398163397448 0.78539816339744831 sinh:1.1752 1.1752011936438 1.17520119364380146 0.634964+1.29846i 0.634963914784736+1.29845758141598i 0.634963914784736108+1.29845758141597729i
+cosh:1.54308 1.54308063481524 1.54308063481524378 0.83373+0.988898i 0.833730025131149+0.988897705762865i 0.833730025131149049+0.988897705762865096i
+tanh:0.761594 0.761594155955765 0.761594155955764888 1.08392+0.271753i 1.08392332733869+0.271752585319512i 1.08392332733869454+0.271752585319511717i
+acosh:0 0 0 1.06128+0.904557i 1.06127506190504+0.904556894302381i 1.06127506190503565+0.904556894302381364i
+asinh:0.881374 0.881373587019543 0.881373587019543025 1.06128+0.666239i 1.06127506190504+0.666239432492515i 1.06127506190503565+0.666239432492515255i
+atanh:inf inf inf 0.402359+1.01722i 0.402359478108525+1.01722196789785i 0.402359478108525094+1.01722196789785137i
+erf:0.842701 0.842700792949715 0.842700792949714869
+erfc:0.157299 0.157299207050285 0.157299207050285131
+lgamma:1.79176 1.79175946922805 1.791759469228055
+lgamma:1.79176 1 1.79175946922805 1 1.791759469228055 1
+tgamma:6 6 6
+floor:1 1 1
+ceil:2 2 2
+trunc:3 3 3
+rint:2 2 2
+rint:2 2 2
+rint:2 2 2
+lrint:2 2 2
+llrint:2 2 2
+nearbyint:4 4 4
+round:2 2 2
+round:2 2 2
+round:2 2 2
+lround:2 2 2
+llround:2 2 2
+copysign:-1 -1 -1
+frexp:0.5 3 0.5 3 0.5 3
+ldexp:8 8 8
+modf:2 0.3 2 0.3 2 0.3 nextafter:2 2 2
+nexttoward:2 2 2
+scalbn:16 16 16
+scalbln:16 16 16

src/tests/.expect/io.txt

-              r9c951e3
+              rb1e63ac5
+x (1 x [2 x {3 x =4 x $5 x £6 x ¥7 x ¡8 x ¿9 x «10
+, x 2. x 3; x 4! x 5? x 6% x 7¢ x 8» x 9) x 10] x 11} x
+x`1`x'2'x"3"x:4:x 5 x   6       x
+x
+x
+x
+x
+x ( 1 ) x 2 , x 3 :x: 4
+A
 2 3 4 5 6 7 8
 …
 abc, $xyz
+v(27 v[27 v{27 $27 =27 £27 ¥27 ¡27 ¿27 «27
+, 25. 25: 25; 25! 25? 25% 25¢ 25» 25) 25] 25}
+'27 25`27 25"27 25 27 25
+25
+25
+25   27 25
+, 2, 3, 4
+, $2, $3 ", $"
+2 3 " "
+2 3
+3
+23
+2 3
+2 3 4 " "
+, 2, 3, 4 ", "
+, 2, 3, 4
 , 4, a, 7.2
 , 4, a, 7.2
 4 a 7.2
 4 a 7.234a7.2 3 4 a 7.2
+4 a 7.234a7.23 4 a 7.2
 -4-a-7.2^3^4-3-4-a-7.2

src/tests/.expect/scopeErrors.txt

-              r9c951e3
+              rb1e63ac5
   with parameters
     double
+  returning
+    _retval_butThisIsAnError: double
+  with body
+  returning
+    _retval_butThisIsAnError:       Attribute with name: unused
+double
+  with body
     CompoundStmt

src/tests/KRfunctions.c

-              r9c951e3
+              rb1e63ac5
-//                               -*- Mode: C -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2017 University of Waterloo
 …
 // Created On       : Thu Feb 16 15:23:17 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Feb 16 15:25:52 2017
 // Update Count     : 2
+// Last Modified On : Wed May 24 22:05:00 2017
+// Update Count     : 3
 //

src/tests/Makefile.am

-              r9c951e3
+              rb1e63ac5
 ## Created On       : Sun May 31 09:08:15 2015
 ## Last Modified By : Peter A. Buhr
 ## Last Modified On : Sun May 14 14:43:48 2017
 ## Update Count     : 42
+## Last Modified On : Thu Jun  8 07:41:43 2017
+## Update Count     : 44
 ###############################################################################
 …
 if BUILD_CONCURRENCY
 concurrent=yes
 quick_test+= coroutine thread monitor
 concurrent_test=coroutine thread monitor multi-monitor sched-int-disjoint sched-int-barge sched-int-wait sched-ext sched-ext-multi preempt
+concurrent = yes
+quick_test += coroutine thread monitor
+concurrent_test = coroutine thread monitor multi-monitor sched-int-barge sched-int-block sched-int-disjoint sched-int-wait sched-ext sched-ext-multi preempt
 else
 concurrent=no
 …
 .PHONY : list
 EXTRA_PROGRAMS = fstream_test vector_test avl_test constant0-1DP constant0-1ND constant0-1NDDP # build but do not install
+EXTRA_PROGRAMS = fstream_test vector_test avl_test # build but do not install
 fstream_test_SOURCES = fstream_test.c
 …
         @+python test.py --debug=${debug} --concurrent=${concurrent} ${concurrent_test}
 .dummy : .dummy.c
+.dummy : .dummy.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${BUILD_FLAGS} -XCFA -n ${<} -o ${@}                              #don't use CFLAGS, this rule is not a real test
-constant0-1DP : constant0-1.c
-        ${CC} ${CFLAGS} -DDUPS ${<} -o ${@}
+constant0-1ND : constant0-1.c
         ${CC} ${CFLAGS} -DNEWDECL ${<} -o ${@}
+% : %.c @CFA_BINDIR@/@CFA_NAME@
+        ${CC} ${CFLAGS} ${<} -o ${@}
+constant0-1NDDP : constant0-1.c
+        ${CC} ${CFLAGS} -DNEWDECL -DDUPS ${<} -o ${@}
+dtor-early-exit-ERR1: dtor-early-exit.c
+dtor-early-exit-ERR1: dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${CFLAGS} -DERR1 ${<} -o ${@}
 dtor-early-exit-ERR2: dtor-early-exit.c
+dtor-early-exit-ERR2: dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${CFLAGS} -DERR2 ${<} -o ${@}
 declarationSpecifier: declarationSpecifier.c
+declarationSpecifier: declarationSpecifier.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
 gccExtensions : gccExtensions.c
+gccExtensions : gccExtensions.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
 extension : extension.c
+extension : extension.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
 attributes : attributes.c
+attributes : attributes.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
 KRfunctions : KRfunctions.c
+KRfunctions : KRfunctions.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
 gmp : gmp.c
+gmp : gmp.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${CFLAGS} -lgmp ${<} -o ${@}
 memberCtors-ERR1: memberCtors.c
+memberCtors-ERR1: memberCtors.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${CFLAGS} -DERR1 ${<} -o ${@}
 completeTypeError : completeTypeError.c
+completeTypeError : completeTypeError.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${CFLAGS} -DERR1 ${<} -o ${@}

src/tests/Makefile.in

-              r9c951e3
+              rb1e63ac5
 @BUILD_CONCURRENCY_TRUE@am__append_1 = coroutine thread monitor
 EXTRA_PROGRAMS = fstream_test$(EXEEXT) vector_test$(EXEEXT) \
+        avl_test$(EXEEXT) constant0-1DP$(EXEEXT) \
+        constant0-1ND$(EXEEXT) constant0-1NDDP$(EXEEXT)
+        avl_test$(EXEEXT)
 subdir = src/tests
 DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in
 …
 avl_test_OBJECTS = $(am_avl_test_OBJECTS)
 avl_test_LDADD = $(LDADD)
-constant0_1DP_SOURCES = constant0-1DP.c
-constant0_1DP_OBJECTS = constant0-1DP.$(OBJEXT)
-constant0_1DP_LDADD = $(LDADD)
-constant0_1ND_SOURCES = constant0-1ND.c
-constant0_1ND_OBJECTS = constant0-1ND.$(OBJEXT)
-constant0_1ND_LDADD = $(LDADD)
-constant0_1NDDP_SOURCES = constant0-1NDDP.c
-constant0_1NDDP_OBJECTS = constant0-1NDDP.$(OBJEXT)
-constant0_1NDDP_LDADD = $(LDADD)
 am_fstream_test_OBJECTS = fstream_test.$(OBJEXT)
 fstream_test_OBJECTS = $(am_fstream_test_OBJECTS)
 …
 am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
 am__v_GEN_0 = @echo "  GEN   " $@;
+SOURCES = $(avl_test_SOURCES) constant0-1DP.c constant0-1ND.c \
+        constant0-1NDDP.c $(fstream_test_SOURCES) \
+SOURCES = $(avl_test_SOURCES) $(fstream_test_SOURCES) \
         $(vector_test_SOURCES)
+DIST_SOURCES = $(avl_test_SOURCES) constant0-1DP.c constant0-1ND.c \
+        constant0-1NDDP.c $(fstream_test_SOURCES) \
+DIST_SOURCES = $(avl_test_SOURCES) $(fstream_test_SOURCES) \
         $(vector_test_SOURCES)
 ETAGS = etags
 …
 @BUILD_CONCURRENCY_TRUE@concurrent = yes
 @BUILD_CONCURRENCY_FALSE@concurrent_test =
 @BUILD_CONCURRENCY_TRUE@concurrent_test = coroutine thread monitor multi-monitor sched-int-disjoint sched-int-barge sched-int-wait sched-ext sched-ext-multi preempt
+@BUILD_CONCURRENCY_TRUE@concurrent_test = coroutine thread monitor multi-monitor sched-int-barge sched-int-block sched-int-disjoint sched-int-wait sched-ext sched-ext-multi preempt
 # applies to both programs
 …
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/avl4.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/avl_test.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/constant0-1DP.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/constant0-1ND.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/constant0-1NDDP.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstream_test.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/vector_int.Po@am__quote@
 …
         @+python test.py --debug=${debug} --concurrent=${concurrent} ${concurrent_test}
 .dummy : .dummy.c
+.dummy : .dummy.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${BUILD_FLAGS} -XCFA -n ${<} -o ${@}                              #don't use CFLAGS, this rule is not a real test
+constant0-1DP : constant0-1.c
+        ${CC} ${CFLAGS} -DDUPS ${<} -o ${@}
+constant0-1ND : constant0-1.c
+        ${CC} ${CFLAGS} -DNEWDECL ${<} -o ${@}
+constant0-1NDDP : constant0-1.c
+        ${CC} ${CFLAGS} -DNEWDECL -DDUPS ${<} -o ${@}
+dtor-early-exit-ERR1: dtor-early-exit.c
+% : %.c @CFA_BINDIR@/@CFA_NAME@
+        ${CC} ${CFLAGS} ${<} -o ${@}
+dtor-early-exit-ERR1: dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${CFLAGS} -DERR1 ${<} -o ${@}
 dtor-early-exit-ERR2: dtor-early-exit.c
+dtor-early-exit-ERR2: dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${CFLAGS} -DERR2 ${<} -o ${@}
 declarationSpecifier: declarationSpecifier.c
+declarationSpecifier: declarationSpecifier.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
 gccExtensions : gccExtensions.c
+gccExtensions : gccExtensions.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
 extension : extension.c
+extension : extension.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
 attributes : attributes.c
+attributes : attributes.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
 KRfunctions : KRfunctions.c
+KRfunctions : KRfunctions.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
 gmp : gmp.c
+gmp : gmp.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${CFLAGS} -lgmp ${<} -o ${@}
 memberCtors-ERR1: memberCtors.c
+memberCtors-ERR1: memberCtors.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${CFLAGS} -DERR1 ${<} -o ${@}
 completeTypeError : completeTypeError.c
+completeTypeError : completeTypeError.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${CFLAGS} -DERR1 ${<} -o ${@}

src/tests/coroutine.c

-              r9c951e3
+              rb1e63ac5
+//
+// Cforall Version 1.0.0 Copyright (C) 2017 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// fibonacci.c --
+//
+// Author           : Thierry Delisle
+// Created On       : Thu Jun  8 07:29:37 2017
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Jun  8 07:37:12 2017
+// Update Count     : 5
+//
 #include <fstream>
 #include <coroutine>
 coroutine Fibonacci {
       int fn; // used for communication
+        int fn;                                         // used for communication
 };
 void ?{}(Fibonacci* this) {
       this->fn = 0;
+void ?{}( Fibonacci * this ) {
+        this->fn = 0;
+}
 void main(Fibonacci* this) {
       int fn1, fn2;             // retained between resumes
+      this->fn = 0;
       fn1 = this->fn;
       suspend();                // return to last resume
+void main( Fibonacci * this ) {
+        int fn1, fn2;                                   // retained between resumes
+        this->fn = 0;                                   // case 0
+        fn1 = this->fn;
+        suspend();                                              // return to last resume
+      this->fn = 1;
       fn2 = fn1;
       fn1 = this->fn;
       suspend();                // return to last resume
+        this->fn = 1;                                   // case 1
+        fn2 = fn1;
+        fn1 = this->fn;
+        suspend();                                              // return to last resume
+      for ( ;; ) {
             this->fn = fn1 + fn2;
             fn2 = fn1;
             fn1 = this->fn;
             suspend();  // return to last resume
+      }
+        for ( ;; ) {                                    // general case
+                this->fn = fn1 + fn2;
+                fn2 = fn1;
+                fn1 = this->fn;
+                suspend();                                      // return to last resume
+        } // for
+}
 int next(Fibonacci* this) {
       resume(this); // transfer to last suspend
       return this->fn;
+int next( Fibonacci * this ) {
+        resume( this );                                 // transfer to last suspend
+        return this->fn;
+}
 int main() {
+      Fibonacci f1, f2;
+      for ( int i = 1; i <= 10; i += 1 ) {
+            sout | next(&f1) | ' ' | next(&f2) | endl;
+      }
+        Fibonacci f1, f2;
+        for ( int i = 1; i <= 10; i += 1 ) {
+                sout | next( &f1 ) | ' ' | next( &f2 ) | endl;
+        } // for
+}
+      return 0;
+}
+// Local Variables: //
+// tab-width: 4 //
+// compile-command: "cfa fibonacci.c" //
+// End: //

src/tests/gmp.c

-              r9c951e3
+              rb1e63ac5
 // Created On       : Tue Apr 19 08:55:51 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun May 14 14:46:50 2017
 // Update Count     : 530
+// Last Modified On : Wed May 24 22:05:38 2017
+// Update Count     : 540
 //
 #include <gmp>
 int main() {
+int main( void ) {
         sout | "constructors" | endl;
         short int si = 3;
 …
         sout | "conversions" | endl;
         y = 'a';
+        sout | "y:" | y | endl;
+        y = "12345678901234567890123456789";
         sout | "y:" | y | endl;
         y = si;
 …
         z = x / 3;
         sout | "z:" | z | endl;
+        sout | div( x, 3 ) | x / 3 | "," | x % 3 | endl;
         [ x, y ] = div( x, 3 );
         sout | "x:" | x | "y:" | y | endl;
-//      sout | div( x, 3 ) | x / 3 | "," | x % 3 | endl;
         sout | endl;
 …
         fn = (Int){0}; fn1 = fn;                                                        // 1st case
         sout | (int)0 | fn | endl;
         fn = (Int){1}; fn2 = fn1; fn1 = fn;                                     // 2nd case
+        fn = 1; fn2 = fn1; fn1 = fn;                                            // 2nd case
         sout | 1 | fn | endl;
         for ( int i = 2; i <= 200; i += 1 ) {
+        for ( unsigned int i = 2; i <= 200; i += 1 ) {
                 fn = fn1 + fn2; fn2 = fn1; fn1 = fn;                    // general case
                 sout | i | fn | endl;
 …
         sout | "Factorial Numbers" | endl;
         Int fact;
         fact = (Int){1};                                                                        // 1st case
+        fact = 1;                                                                                       // 1st case
         sout | (int)0 | fact | endl;
         for ( int i = 1; i <= 40; i += 1 ) {
                 fact = fact * i;                                                                // general case
+        for ( unsigned int i = 1; i <= 40; i += 1 ) {
+                fact *= i;                                                                              // general case
                 sout | i | fact | endl;
         } // for
 …
 // Local Variables: //
-// mode: c //
 // tab-width: 4 //
+// compile-command: "cfa gmp.c -l gmp" //
 // End: //

src/tests/identity.c

-              r9c951e3
+              rb1e63ac5
 // identity.c --
 //
 // Author           : Richard C. Bilson
+// Author           : Peter A. Buhr
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Mar  8 22:15:08 2016
 // Update Count     : 13
+// Last Modified On : Thu Jun  8 08:21:32 2017
+// Update Count     : 18
 //
 …
         sout | "double\t\t\t"                           | identity( 4.1 ) | endl;
         sout | "long double\t\t"                        | identity( 4.1l ) | endl;
+        sout | "float _Complex\t\t"                     | identity( -4.1F-2.0iF ) | endl;
+        sout | "double _Complex\t\t"            | identity( -4.1D-2.0iD ) | endl;
+        sout | "long double _Complex\t"         | identity( -4.1L-2.0iL ) | endl;
+}

src/tests/io.c

-              r9c951e3
+              rb1e63ac5
 // Created On       : Wed Mar  2 16:56:02 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Mar 21 22:36:06 2017
 // Update Count     : 48
+// Last Modified On : Thu Jun  8 09:52:10 2017
+// Update Count     : 51
 //
 …
 int main() {
         char c;                                                                                                         // basic types
+        char c;                                                                                         // basic types
         short int si;
         unsigned short int usi;
 …
         double _Complex dc;
         long double _Complex ldc;
+        char s1[10], s2[10];
+        enum { size = 10 };
+        char s1[size], s2[size];
         int x = 3, y = 5, z = 7;
 …
         sout | endl;
+        ifstream in;                                                                                            // create / open file
+        sout
+                // opening delimiters
+                | "x (" | 1
+                | "x [" | 2
+                | "x {" | 3
+                | "x =" | 4
+                | "x $" | 5
+                | "x £" | 6
+                | "x ¥" | 7
+                | "x ¡" | 8
+                | "x ¿" | 9
+                | "x «" | 10
+                | endl;
+        sout
+                // closing delimiters
+                | 1 | ", x"
+                | 2 | ". x"
+                | 3 | "; x"
+                | 4 | "! x"
+                | 5 | "? x"
+                | 6 | "% x"
+                | 7 | "¢ x"
+                | 8 | "» x"
+                | 9 | ") x"
+                | 10 | "] x"
+                | 11 | "} x"
+                | endl;
+        sout
+                // opening-closing delimiters
+                | "x`" | 1 | "`x'" | 2
+                | "'x\"" | 3 | "\"x:" | 4
+                | ":x " | 5 | " x\t" | 6
+                | "\tx\f" | 7 | "\fx\v" | 8
+                | "\vx\n" | 9 | "\nx\r" | 10
+                | "\rx" |
+                endl;
+        sout | "x ( " | 1 | " ) x" | 2 | " , x" | 3 | " :x: " | 4 | endl;
+        ifstream in;                                                                            // create / open file
         open( &in, "io.data", "r" );
         &in | &c                                                                                                        // character
                 | &si | &usi | &i | &ui | &li | &uli | &lli | &ulli             // integral
                 | &f | &d | &ld                                                                                 // floating point
                 | &fc | &dc | &ldc                                                                              // floating-point complex
                 | cstr( s1 ) | cstr( s2, 10 );                                                  // C string, length unchecked and checked
+        &in | &c                                                                                        // character
+                | &si | &usi | &i | &ui | &li | &uli | &lli | &ulli     // integral
+                | &f | &d | &ld                                                                 // floating point
+                | &fc | &dc | &ldc                                                              // floating-point complex
+                | cstr( s1 ) | cstr( s2, size );                                // C string, length unchecked and checked
         sout | c | ' ' | endl                                                                           // character
                  | si | usi | i | ui | li | uli | lli | ulli | endl             // integral
                  | f | d | ld | endl                                                                    // floating point
                  | fc | dc | ldc | endl;                                                                // complex
+        sout | c | ' ' | endl                                                           // character
+                | si | usi | i | ui | li | uli | lli | ulli | endl // integral
+                | f | d | ld | endl                                                             // floating point
+                | fc | dc | ldc | endl;                                                 // complex
         sout | endl;
         sout | f | "" | d | "" | ld | endl                                                      // floating point without separator
                  | sepDisable | fc | dc | ldc | sepEnable | endl                // complex without separator
                  | sepOn | s1 | sepOff | s2 | endl                                              // local separator removal
                  | s1 | "" | s2 | endl;                                                                 // C string without separator
+        sout | f | "" | d | "" | ld | endl                                      // floating point without separator
+                | sepDisable | fc | dc | ldc | sepEnable | endl // complex without separator
+                | sepOn | s1 | sepOff | s2 | endl                               // local separator removal
+                | s1 | "" | s2 | endl;                                                  // C string without separator
         sout | endl;
         sepSet( sout, ", $" );                                                                          // change separator, maximum of 15 characters
+        sepSet( sout, ", $" );                                                          // change separator, maximum of 15 characters
         sout | f | d | ld | endl
                  | fc | dc | ldc | endl
                  | s1 | s2 | endl;
+                | fc | dc | ldc | endl
+                | s1 | s2 | endl;
         sout | endl;
+        [int, int] t1 = [1, 2], t2 = [3, 4];
+        sout | t1 | t2 | endl;                                                          // print tuple
         sepSet( sout, " " );
+        sepSet( sout, ", $" );                                                          // set separator from " " to ", $"
+        sout | 1 | 2 | 3 | " \"" | sepGet( sout ) | "\"" | endl;
+        sepSet( sout, " " );                                                            // reset separator to " "
+        sout | 1 | 2 | 3 | " \"" | sepGet( sout ) | "\"" | endl;
+        sout
+                // opening delimiters
+                | "v(" | 27
+                | "v[" | 27
+                | "v{" | 27
+                | "$" | 27
+                | "=" | 27
+                | "£" | 27
+                | "¥" | 27
+                | "¡" | 27
+                | "¿" | 27
+                | "«" | 27
+                | endl
+                // closing delimiters
+                | 25 | ","
+                | 25 | "."
+                | 25 | ":"
+                | 25 | ";"
+                | 25 | "!"
+                | 25 | "?"
+                | 25 | "%"
+                | 25 | "¢"
+                | 25 | "»"
+                | 25 | ")"
+                | 25 | "]"
+                | 25 | "}"
+                | endl
+                // opening-closing delimiters
+                | 25 | "'" | 27
+                | 25 | "`" | 27
+                | 25 | "\"" | 27
+                | 25 | " " | 27
+                | 25 | "\f" | 27
+                | 25 | "\n" | 27
+                | 25 | "\r" | 27
+                | 25 | "\t" | 27
+                | 25 | "\v" | 27
+                | endl;
+        sout | sepOn | 1 | 2 | 3 | sepOn | endl;                        // separator at start of line
+        sout | 1 | sepOff | 2 | 3 | endl;                                       // locally turn off implicit separator
+        [int, int, const char *, double] t = { 3, 4, "a", 7.2 };
+        sout | sepDisable | 1 | 2 | 3 | endl;                           // globally turn off implicit separation
+        sout | 1 | sepOn | 2 | 3 | endl;                                        // locally turn on implicit separator
+        sout | sepEnable | 1 | 2 | 3 | endl;                            // globally turn on implicit separation
+        sepSetTuple( sout, " " );                                                       // set tuple separator from ", " to " "
+        sout | t1 | t2 | " \"" | sepGetTuple( sout ) | "\"" | endl;
+        sepSetTuple( sout, ", " );                                                      // reset tuple separator to ", "
+        sout | t1 | t2 | " \"" | sepGetTuple( sout ) | "\"" | endl;
+        sout | t1 | t2 | endl;                                                          // print tuple
+        [int, int, const char *, double] t3 = { 3, 4, "a", 7.2 };
         sout | [ 3, 4, "a", 7.2 ] | endl;
         sout | t | endl;
+        sout | t3 | endl;
         sepSetTuple( sout, " " );
         sout | t | endl;
         sout | sepOn | t | sepDisable | t | sepEnable | t | endl;
+        sout | t3 | endl;
+        sout | sepOn | t3 | sepDisable | t3 | sepEnable | t3 | endl;
         sepSet( sout, "^" );
         sepSetTuple( sout, "-" );
         sout | t | 3 | 4 | t | endl;
+        sout | t3 | 3 | 4 | t3 | endl;
+}

src/tests/libcfa_vector.c

r9c951e3	rb1e63ac5
27	27
28	28	int main() {
29		vector( int~~, heap_allocator(int)~~ ) iv;
	29	vector( int ) iv;
30	30
31	31	assert( empty( &iv ) );

src/tests/math.c

-              r9c951e3
+              rb1e63ac5
 // Created On       : Fri Apr 22 14:59:21 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Apr 24 13:24:20 2016
 // Update Count     : 70
+// Last Modified On : Wed May 24 13:04:33 2017
+// Update Count     : 71
 //
 …
         long double l;
-        sout | "fabs:" | fabs( -1.0F ) | fabs( -1.0D ) | fabs( -1.0L ) | cabs( -1.0F+1.0FI ) | cabs( -1.0D+1.0DI ) | cabs( -1.0DL+1.0LI ) | endl;
         sout | "fmod:" | 5.0F % -2.0F | fmod( 5.0F, -2.0F ) | 5.0D % -2.0D | fmod( 5.0D, -2.0D ) | 5.0L % -2.0L | fmod( 5.0L, -2.0L ) | endl;
         sout | "remainder:" | remainder( 2.0F, 3.0F ) | remainder( 2.0D, 3.0D ) | remainder( 2.0L, 3.0L ) | endl;

src/tests/numericConstants.c

-              r9c951e3
+              rb1e63ac5
+//
+// 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.
+//
+// numericConstants.c --
+//
+// Author           : Peter A. Buhr
+// Created On       : Wed May 24 22:10:36 2017
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Wed May 24 22:11:36 2017
+// Update Count     : 2
+//
 int main() {
 ;                                                      // decimal
 …
 x_ff.ffp0;                                     // hex real
 x_1.ffff_ffff_p_128_l;
+}
+} // main
+// Local Variables: //
+// tab-width: 4 //
+// compile-command: "cfa minmax.c" //
+// End: //

src/tests/rational.c

-              r9c951e3
+              rb1e63ac5
 // Created On       : Mon Mar 28 08:43:12 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon May 15 21:32:22 2017
 // Update Count     : 64
+// Last Modified On : Wed May 17 15:46:35 2017
+// Update Count     : 65
 //

src/tests/sched-int-disjoint.c

-              r9c951e3
+              rb1e63ac5
 #include <thread>
+#ifndef N
 #define N 100_000
+#endif
 enum state_t { WAIT, SIGNAL, BARGE };
 …
         signal( &cond, a, &data );
+        int pauses = (unsigned)rand48() % 10;
+        for(int i = 0; i < pauses; i++) {
+                yield();
+        }
+        yield( (unsigned)rand48() % 10 );
         //This is technically a mutual exclusion violation but the mutex monitor protects us

src/tests/sched-int-wait.c

-              r9c951e3
+              rb1e63ac5
 #include <thread>
+static const int N = 10_000;
+#ifndef N
+#define N 10_000
+#endif
 monitor global_t {};

src/tests/test.py

-              r9c951e3
+              rb1e63ac5
                         # fetch return code and error from the diff command
                         retcode, error = diff(".expect/%s.txt" % test.path, ".out/%s.log" % test.name, dry_run)
+        else:
+                with open (out_file, "r") as myfile:
+                        error = myfile.read()
         # clean the executable
         sh("rm -f %s > /dev/null 2>&1" % test.name, dry_run)
 …
         # for each test to run
         try :
                 results = pool.map_async(partial(run_test_worker, generate=generate, dry_run=dry_run, debug=debug), tests ).get(3600)
+                results = pool.map_async(partial(run_test_worker, generate=generate, dry_run=dry_run, debug=debug), tests, chunksize = 1 ).get(7200)
         except KeyboardInterrupt:
                 pool.terminate()

src/tests/tuplePolymorphism.c

-              r9c951e3
+              rb1e63ac5
 // Author           : Rob Schluntz
 // Created On       : Tue Nov 16 10:38:00 2016
 // Last Modified By : Rob Schluntz
 // Last Modified On : Tue Nov 16 10:39:18 2016
 // Update Count     : 2
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu May 18 18:05:12 2017
+// Update Count     : 4
 //
 // packed is needed so that structs are not passed with the same alignment as function arguments
 __attribute__((packed)) struct A {
   double x;
   char y;
   double z;
+        double x;
+        char y;
+        double z;
 };
 __attribute__((packed)) struct B {
   long long x;
   char y;
   long long z;
+        long long x;
+        char y;
+        long long z;
 };
 …
 int main() {
   int x1 = 123, x3 = 456;
   double x2 = 999.123;
+        int x1 = 123, x3 = 456;
+        double x2 = 999.123;
   int i1 = 111, i3 = 222;
   double i2 = 333;
+        int i1 = 111, i3 = 222;
+        double i2 = 333;
   int d1 = 555, d3 = 444;
   double d2 = 666;
+        int d1 = 555, d3 = 444;
+        double d2 = 666;
   [i1, i2, i3] = ([x1, (int)x2, x3]) + ([9, 2, 3]);
   [d1, d2, d3] = ([x1, x2, x3]) + ([9, 2, 3]);
   printf("%d %g %d\n", i1, i2, i3);
   printf("%d %g %d\n", d1, d2, d3);
+        [i1, i2, i3] = ([x1, (int)x2, x3]) + ([9, 2, 3]);
+        [d1, d2, d3] = ([x1, x2, x3]) + ([9, 2, 3]);
+        printf("%d %g %d\n", i1, i2, i3);
+        printf("%d %g %d\n", d1, d2, d3);
   [double, double, double] zzz;
   zzz = [x1, x2, x3];
   printf("%g %g %g\n", zzz);
   [x1, x2, x3] = zzz+zzz;
   printf("%d %g %d\n", x1, x2, x3);
+        [double, double, double] zzz;
+        zzz = [x1, x2, x3];
+        printf("%g %g %g\n", zzz);
+        [x1, x2, x3] = zzz+zzz;
+        printf("%d %g %d\n", x1, x2, x3);
   // ensure non-matching assertions are specialized correctly
   g((A){ 1.21, 'x', 10.21}, (B){ 1111LL, 'v', 54385938LL });
+        // ensure non-matching assertions are specialized correctly
+        g((A){ 1.21, 'x', 10.21}, (B){ 1111LL, 'v', 54385938LL });
+}
 …
 // tab-width: 4 //
 // End: //

Context Navigation

Legend:

Download in other formats: