Changes in / [f2e40a9f:bf4ac09]

Files:

• Jenkins/FullBuild (modified) (3 diffs)
• Jenkinsfile (modified) (3 diffs)
• doc/proposals/concurrency/thePlan.md (modified) (1 diff)
• doc/proposals/flags.md (modified) (1 diff)
• src/Concurrency/Keywords.cc (modified) (7 diffs)
• src/GenPoly/Box.cc (modified) (2 diffs)
• src/GenPoly/GenPoly.cc (modified) (5 diffs)
• src/GenPoly/GenPoly.h (modified) (2 diffs)
• src/GenPoly/InstantiateGeneric.cc (modified) (5 diffs)
• src/GenPoly/ScrubTyVars.cc (modified) (1 diff)
• src/GenPoly/ScrubTyVars.h (modified) (5 diffs)
• src/SymTab/Validate.cc (modified) (2 diffs)
• src/SynTree/Type.h (modified) (36 diffs)
• src/benchmark/CorCtxSwitch.c (modified) (2 diffs)
• src/benchmark/ThrdCtxSwitch.c (modified) (1 diff)
• src/benchmark/bench.c (modified) (5 diffs)
• src/benchmark/csv-data.c (modified) (2 diffs)
• src/examples/multicore.c (modified) (1 diff)
• src/libcfa/Makefile.am (modified) (1 diff)
• src/libcfa/Makefile.in (modified) (10 diffs)
• src/libcfa/concurrency/coroutine (deleted)
• src/libcfa/concurrency/coroutine.c (deleted)
• src/libcfa/concurrency/coroutines (added)
• src/libcfa/concurrency/coroutines.c (added)
• src/libcfa/concurrency/invoke.c (modified) (3 diffs)
• src/libcfa/concurrency/invoke.h (modified) (3 diffs)
• src/libcfa/concurrency/kernel (modified) (3 diffs)
• src/libcfa/concurrency/kernel.c (modified) (13 diffs)
• src/libcfa/concurrency/kernel_private.h (modified) (5 diffs)
• src/libcfa/concurrency/monitor (modified) (3 diffs)
• src/libcfa/concurrency/monitor.c (modified) (6 diffs)
• src/libcfa/concurrency/thread (deleted)
• src/libcfa/concurrency/thread.c (deleted)
• src/libcfa/concurrency/threads (added)
• src/libcfa/concurrency/threads.c (added)
• src/tests/coroutine.c (modified) (3 diffs)
• src/tests/monitor.c (modified) (3 diffs)
• src/tests/multi-monitor.c (modified) (2 diffs)
• src/tests/test.py (modified) (1 diff)
• src/tests/thread.c (modified) (1 diff)

Jenkins/FullBuild

@@ -20 +20 @@
 
                                         parallel (
-                                                gcc_6_x64: { trigger_build( 'gcc-6',   'x64', true  ) },
-                                                gcc_6_x86: { trigger_build( 'gcc-6',   'x86', true  ) },
-                                                gcc_5_x64: { trigger_build( 'gcc-5',   'x64', false ) },
-                                                gcc_5_x86: { trigger_build( 'gcc-5',   'x86', false ) },
-                                                gcc_4_x64: { trigger_build( 'gcc-4.9', 'x64', false ) },
-                                                gcc_4_x86: { trigger_build( 'gcc-4.9', 'x86', false ) },
-                                                clang_x64: { trigger_build( 'clang',   'x64', false ) },
-                                                clang_x86: { trigger_build( 'clang',   'x86', false ) },
+                                                gcc_6_x64: { trigger_build( 'gcc-6',   'x64' ) },
+                                                gcc_6_x86: { trigger_build( 'gcc-6',   'x86' ) },
+                                                gcc_5_x64: { trigger_build( 'gcc-5',   'x64' ) },
+                                                gcc_5_x86: { trigger_build( 'gcc-5',   'x86' ) },
+                                                gcc_4_x64: { trigger_build( 'gcc-4.9', 'x64' ) },
+                                                gcc_4_x86: { trigger_build( 'gcc-4.9', 'x86' ) },
+                                                clang_x64: { trigger_build( 'clang',   'x64' ) },
+                                                clang_x86: { trigger_build( 'clang',   'x86' ) },
                                         )
 
@@ -62 +62 @@
 //===========================================================================================================
 
-def trigger_build(String cc, String arch, Boolean publish) {
+def trigger_build(String cc, String arch) {
         def result = build job: 'Cforall/master',               \
                 parameters: [                                           \
@@ -82 +82 @@
                         [$class: 'BooleanParameterValue',               \
                           name: 'pPublish',                             \
-                          value: publish],                                      \
+                          value: true],                                         \
                         [$class: 'BooleanParameterValue',               \
                           name: 'pSilent',                              \

Jenkinsfile

@@ -131 +131 @@
                                 [$class: 'BooleanParameterDefinition',                                                  \
                                         description: 'If true, jenkins also builds documentation',              \
-                                        name: 'pBuildDocumentation',                                                    \
+                                        name: 'pBuildDocumentation',                                                            \
                                         defaultValue: true,                                                             \
                                 ],                                                                                              \
@@ -137 +137 @@
                                         description: 'If true, jenkins also publishes results',                 \
                                         name: 'pPublish',                                                               \
-                                        defaultValue: false,                                                            \
+                                        defaultValue: true,                                                             \
                                 ],                                                                                              \
                                 [$class: 'BooleanParameterDefinition',                                                  \
                                         description: 'If true, jenkins will not send emails',           \
-                                        name: 'pSilent',                                                                        \
+                                        name: 'pSilent',                                                \
                                         defaultValue: false,                                                            \
                                 ],                                                                                              \
@@ -159 +159 @@
         echo """Compiler                : ${compiler.cc_name} (${compiler.cpp_cc}/${compiler.cfa_cc})
 Architecture            : ${arch_name}
-Arc Flags               : ${architecture}
+Arc Flags                       : ${architecture}
 Run All Tests           : ${ pRunAllTests.toString() }
 Run Benchmark           : ${ pRunBenchmark.toString() }

doc/proposals/concurrency/thePlan.md

@@ -7 +7 @@
 
 _Phase 2_ : Minimum Viable Product
-done - Monitor type and enter/leave mutex member routines
+Monitor type and enter/leave mutex member routines
 Monitors as a language feature (not calling enter/leave by hand)
 Internal scheduling

doc/proposals/flags.md

@@ -69 +69 @@
 In each of the cases above, `FOO` could be replaced by `(BAR | BAZ)` to do the same operation or test on multiple flags at once.
 
-### Alternative/Additional Features ###
-
-#### User-defined enum discriminant iterator ####
-It may be useful to provide a more general method for changing the enum discriminant assignment function, e.g. the flag enum discriminants could be defined by something like the following:
-
-        ```
-        enum(@ << 1) TCP_Flags {  // each discriminant is left-shifted by 1 from the previous
-                FIN = 0x1,  // first flag is 1
-                SYN,
-                ACK,
-                ...
-        }
-        ```
-
-#### Member expression for enums ####
-As a more ergonomic way to set and unset enum flags, we could define a member expression for flags enums. Since only unions and structs can have member expressions now, this change would be backwards compatible. Basically, given a `FunFlags f`, `f.FOO` would return a proxy object which could be implicitly converted to `bool` (with semantics `f & FOO`, i.e. "check if `FOO` is set on `f`"), as well as having `bool` assigned to it (with semantics `f |= FOO` on true or `f -= FOO` on false, i.e. "set or unset `FOO` on `f` as appropriate"). With this member function, the operations above can be expressed as follows (possibly more ergonomically):
-
-        ```
-        FunFlags f = some_val();
-        if ( f.FOO ) { sout | "f has FOO set" | endl; }
-        f.FOO = true;    // set FOO
-        f.FOO = false;   // unset FOO
-        f.FOO = ! f.FOO; // toggle FOO
-        ```
-
 ### Related Work ###
 C# has the [`[Flags]`][1] enum attribute, but their proposal does not go as far; specifically, the flag discriminants must be manually specified, and they do not automatically implement the bitwise operators on the flags. 

src/Concurrency/Keywords.cc

@@ -88 +88 @@
         //Handles mutex routines definitions :
         // void foo( A * mutex a, B * mutex b,  int i ) {                  void foo( A * a, B * b,  int i ) {
-        //                                                                       monitor_desc * __monitors[] = { get_monitor(a), get_monitor(b) };
+        //                                                                       monitor_desc * __monitors[] = { a, b };
         //                                                                       monitor_guard_t __guard = { __monitors, 2 };
         //    /*Some code*/                                       =>           /*Some code*/
@@ -98 +98 @@
                 using Visitor::visit;
                 virtual void visit( FunctionDecl *functionDecl ) override final;
-                virtual void visit(   StructDecl *functionDecl ) override final;
 
                 std::list<DeclarationWithType*> findMutexArgs( FunctionDecl* );
@@ -108 +107 @@
                         acceptAll( translationUnit, impl );
                 }
-
-          private:
-                StructDecl* monitor_decl = nullptr;
         };
 
@@ -137 +133 @@
                 if( ! body ) return;
 
-                assert(monitor_decl);
                 addStatments( body, mutexArgs );
-        }
-
-        void MutexKeyword::visit(StructDecl* decl) {
-                if( decl->get_name() == "monitor_desc" ) {
-                        assert( !monitor_decl );
-                        monitor_decl = decl;
-                }
         }
 
@@ -179 +167 @@
 
         void MutexKeyword::addStatments( CompoundStmt * body, const std::list<DeclarationWithType * > & args ) {
-
-                ObjectDecl * monitors = new ObjectDecl(
-                        "__monitors",
-                        noStorage,
-                        LinkageSpec::Cforall,
-                        nullptr,
-                        new ArrayType(
-                                noQualifiers,
-                                new PointerType(
-                                        noQualifiers,
-                                        new StructInstType(
-                                                noQualifiers,
-                                                monitor_decl
-                                        )
-                                ),
-                                new ConstantExpr( Constant::from_ulong( args.size() ) ),
-                                false,
-                                false
-                        ),
-                        new ListInit(
-                                map_range < std::list<Initializer*> > ( args, [](DeclarationWithType * var ){
-                                        return new SingleInit( new UntypedExpr(
-                                                new NameExpr( "get_monitor" ),
-                                                {  new VariableExpr( var ) }
-                                        ) );
-                                })
-                        )
-                );
-
                 //in reverse order :
                 // monitor_guard_t __guard = { __monitors, # };
@@ -222 +181 @@
                                 new ListInit(
                                         {
-                                                new SingleInit( new VariableExpr( monitors ) ),
+                                                new SingleInit( new NameExpr( "__monitors" ) ),
                                                 new SingleInit( new ConstantExpr( Constant::from_ulong( args.size() ) ) )
                                         }
@@ -230 +189 @@
 
                 //monitor_desc * __monitors[] = { a, b };
-                body->push_front( new DeclStmt( noLabels, monitors) );
+                body->push_front(
+                        new DeclStmt( noLabels, new ObjectDecl(
+                                "__monitors",
+                                noStorage,
+                                LinkageSpec::Cforall,
+                                nullptr,
+                                new ArrayType(
+                                        noQualifiers,
+                                        new PointerType(
+                                                noQualifiers,
+                                                new StructInstType(
+                                                        noQualifiers,
+                                                        "monitor_desc"
+                                                )
+                                        ),
+                                        new ConstantExpr( Constant::from_ulong( args.size() ) ),
+                                        false,
+                                        false
+                                ),
+                                new ListInit(
+                                        map_range < std::list<Initializer*> > ( args, [](DeclarationWithType * var ){
+                                                return new SingleInit( new VariableExpr( var ) );
+                                        })
+                                )
+                        ))
+                );
         }
 };

src/GenPoly/Box.cc

@@ -381 +381 @@
                 // calculate struct layout in function body
 
-                // initialize size and alignment to 0 and 1 (will have at least one member to re-edit size)
+                // 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" ) ) ) );
@@ -1852 +1852 @@
 
                         DeclClass *ret = static_cast< DeclClass *>( Mutator::mutate( decl ) );
-                        // ScrubTyVars::scrub( decl, scopeTyVars );
-                        ScrubTyVars::scrubAll( decl );
+                        ScrubTyVars::scrub( decl, scopeTyVars );
 
                         scopeTyVars.endScope();

src/GenPoly/GenPoly.cc

@@ -15 +15 @@
 
 #include "GenPoly.h"
-#include "assert.h"
 
 #include "SynTree/Expression.h"
 #include "SynTree/Type.h"
-#include "ResolvExpr/typeops.h"
 
 #include <iostream>
-#include <iterator>
-#include <list>
-#include <typeindex>
-#include <typeinfo>
-#include <vector>
 using namespace std;
 
@@ -45 +38 @@
                         for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
                                 TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
-                                assertf(paramType, "Aggregate parameters should be type expressions");
+                                assert(paramType && "Aggregate parameters should be type expressions");
                                 if ( isPolyType( paramType->get_type(), tyVars, env ) ) return true;
                         }
@@ -55 +48 @@
                         for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
                                 TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
-                                assertf(paramType, "Aggregate parameters should be type expressions");
+                                assert(paramType && "Aggregate parameters should be type expressions");
                                 if ( isDynType( paramType->get_type(), tyVars, env ) ) return true;
-                        }
-                        return false;
-                }
-
-                /// Checks a parameter list for inclusion of polymorphic parameters; will substitute according to env if present
-                bool includesPolyParams( std::list< Expression* >& params, const TypeSubstitution *env ) {
-                        for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
-                                TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
-                                assertf(paramType, "Aggregate parameters should be type expressions");
-                                if ( includesPolyType( paramType->get_type(), env ) ) return true;
-                        }
-                        return false;
-                }
-
-                /// Checks a parameter list for inclusion of polymorphic parameters from tyVars; will substitute according to env if present
-                bool includesPolyParams( std::list< Expression* >& params, const TyVarMap &tyVars, const TypeSubstitution *env ) {
-                        for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
-                                TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
-                                assertf(paramType, "Aggregate parameters should be type expressions");
-                                if ( includesPolyType( paramType->get_type(), tyVars, env ) ) return true;
                         }
                         return false;
@@ -214 +187 @@
 
                 return isPolyType( type, tyVars, env );
-        }
-
-        bool includesPolyType( Type *type, const TypeSubstitution *env ) {
-                type = replaceTypeInst( type, env );
-
-                if ( dynamic_cast< TypeInstType * >( type ) ) {
-                        return true;
-                } else if ( PointerType *pointerType = dynamic_cast< PointerType* >( type ) ) {
-                        if ( includesPolyType( pointerType->get_base(), env ) ) return true;
-                } else if ( StructInstType *structType = dynamic_cast< StructInstType* >( type ) ) {
-                        if ( includesPolyParams( structType->get_parameters(), env ) ) return true;
-                } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( type ) ) {
-                        if ( includesPolyParams( unionType->get_parameters(), env ) ) return true;
-                }
-                return false;
-        }
-
-        bool includesPolyType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env ) {
-                type = replaceTypeInst( type, env );
-
-                if ( TypeInstType *typeInstType = dynamic_cast< TypeInstType * >( type ) ) {
-                        if ( tyVars.find( typeInstType->get_name() ) != tyVars.end() ) {
-                                return true;
-                        }
-                } else if ( PointerType *pointerType = dynamic_cast< PointerType* >( type ) ) {
-                        if ( includesPolyType( pointerType->get_base(), tyVars, env ) ) return true;
-                } else if ( StructInstType *structType = dynamic_cast< StructInstType* >( type ) ) {
-                        if ( includesPolyParams( structType->get_parameters(), tyVars, env ) ) return true;
-                } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( type ) ) {
-                        if ( includesPolyParams( unionType->get_parameters(), tyVars, env ) ) return true;
-                }
-                return false;
         }
 
@@ -296 +237 @@
         }
 
-        namespace {
-                /// Checks if is a pointer to D
-                template<typename D, typename B>
-                bool is( const B* p ) { return type_index{typeid(D)} == type_index{typeid(*p)}; }
-
-                /// Converts to a pointer to D without checking for safety
-                template<typename D, typename B>
-                inline D* as( B* p ) { return reinterpret_cast<D*>(p); }
-
-                /// Flattens a declaration list
-                template<typename Output>
-                void flattenList( list< DeclarationWithType* > src, Output out ) {
-                        for ( DeclarationWithType* decl : src ) {
-                                ResolvExpr::flatten( decl->get_type(), out );
-                        }
-                }
-
-                /// Flattens a list of types
-                template<typename Output>
-                void flattenList( list< Type* > src, Output out ) {
-                        for ( Type* ty : src ) {
-                                ResolvExpr::flatten( ty, out );
-                        }
-                }
-
-                /// Checks if two lists of parameters are equal up to polymorphic substitution.
-                bool paramListsPolyCompatible( const list< Expression* >& aparams, const list< Expression* >& bparams ) {
-                        if ( aparams.size() != bparams.size() ) return false;
-
-                        for ( list< Expression* >::const_iterator at = aparams.begin(), bt = bparams.begin();
-                                        at != aparams.end(); ++at, ++bt ) {
-                                TypeExpr *aparam = dynamic_cast< TypeExpr* >(*at);
-                                assertf(aparam, "Aggregate parameters should be type expressions");
-                                TypeExpr *bparam = dynamic_cast< TypeExpr* >(*bt);
-                                assertf(bparam, "Aggregate parameters should be type expressions");
-
-                                // xxx - might need to let VoidType be a wildcard here too; could have some voids 
-                                // stuffed in for dtype-statics.
-                                // if ( is<VoidType>( aparam->get_type() ) || is<VoidType>( bparam->get_type() ) ) continue;
-                                if ( ! typesPolyCompatible( aparam->get_type(), bparam->get_type() ) ) return false;
-                        }
-                        
-                        return true;
-                }
-        }
-
-        bool typesPolyCompatible( Type *a, Type *b ) {
-                type_index aid{ typeid(*a) };
-                // polymorphic types always match
-                if ( aid == type_index{typeid(TypeInstType)} ) return true;
-                
-                type_index bid{ typeid(*b) };
-                // polymorphic types always match
-                if ( bid == type_index{typeid(TypeInstType)} ) return true;
-                
-                // can't match otherwise if different types
-                if ( aid != bid ) return false;
-
-                // recurse through type structure (conditions borrowed from Unify.cc)
-                if ( aid == type_index{typeid(BasicType)} ) {
-                        return as<BasicType>(a)->get_kind() == as<BasicType>(b)->get_kind();
-                } else if ( aid == type_index{typeid(PointerType)} ) {
-                        PointerType *ap = as<PointerType>(a), *bp = as<PointerType>(b);
-
-                        // void pointers should match any other pointer type
-                        return is<VoidType>( ap->get_base() ) || is<VoidType>( bp->get_base() )
-                                || typesPolyCompatible( ap->get_base(), bp->get_base() );
-                } else if ( aid == type_index{typeid(ArrayType)} ) {
-                        ArrayType *aa = as<ArrayType>(a), *ba = as<ArrayType>(b);
-
-                        if ( aa->get_isVarLen() ) {
-                                if ( ! ba->get_isVarLen() ) return false;
-                        } else {
-                                if ( ba->get_isVarLen() ) return false;
-
-                                ConstantExpr *ad = dynamic_cast<ConstantExpr*>( aa->get_dimension() );
-                                ConstantExpr *bd = dynamic_cast<ConstantExpr*>( ba->get_dimension() );
-                                if ( ad && bd 
-                                                && ad->get_constant()->get_value() != bd->get_constant()->get_value() )
-                                        return false;
-                        }
-
-                        return typesPolyCompatible( aa->get_base(), ba->get_base() );
-                } else if ( aid == type_index{typeid(FunctionType)} ) {
-                        FunctionType *af = as<FunctionType>(a), *bf = as<FunctionType>(b);
-
-                        vector<Type*> aparams, bparams;
-                        flattenList( af->get_parameters(), back_inserter( aparams ) );
-                        flattenList( bf->get_parameters(), back_inserter( bparams ) );
-                        if ( aparams.size() != bparams.size() ) return false;
-
-                        vector<Type*> areturns, breturns;
-                        flattenList( af->get_returnVals(), back_inserter( areturns ) );
-                        flattenList( bf->get_returnVals(), back_inserter( breturns ) );
-                        if ( areturns.size() != breturns.size() ) return false;
-
-                        for ( unsigned i = 0; i < aparams.size(); ++i ) {
-                                if ( ! typesPolyCompatible( aparams[i], bparams[i] ) ) return false;
-                        }
-                        for ( unsigned i = 0; i < areturns.size(); ++i ) {
-                                if ( ! typesPolyCompatible( areturns[i], breturns[i] ) ) return false;
-                        }
-                        return true;
-                } else if ( aid == type_index{typeid(StructInstType)} ) {
-                        StructInstType *aa = as<StructInstType>(a), *ba = as<StructInstType>(b);
-
-                        if ( aa->get_name() != ba->get_name() ) return false;
-                        return paramListsPolyCompatible( aa->get_parameters(), ba->get_parameters() );
-                } else if ( aid == type_index{typeid(UnionInstType)} ) {
-                        UnionInstType *aa = as<UnionInstType>(a), *ba = as<UnionInstType>(b);
-
-                        if ( aa->get_name() != ba->get_name() ) return false;
-                        return paramListsPolyCompatible( aa->get_parameters(), ba->get_parameters() );
-                } else if ( aid == type_index{typeid(EnumInstType)} ) {
-                        return as<EnumInstType>(a)->get_name() == as<EnumInstType>(b)->get_name();
-                } else if ( aid == type_index{typeid(TraitInstType)} ) {
-                        return as<TraitInstType>(a)->get_name() == as<TraitInstType>(b)->get_name();
-                } else if ( aid == type_index{typeid(TupleType)} ) {
-                        TupleType *at = as<TupleType>(a), *bt = as<TupleType>(b);
-
-                        vector<Type*> atypes, btypes;
-                        flattenList( at->get_types(), back_inserter( atypes ) );
-                        flattenList( bt->get_types(), back_inserter( btypes ) );
-                        if ( atypes.size() != btypes.size() ) return false;
-
-                        for ( unsigned i = 0; i < atypes.size(); ++i ) {
-                                if ( ! typesPolyCompatible( atypes[i], btypes[i] ) ) return false;
-                        }
-                        return true;
-                } else return true; // VoidType, VarArgsType, ZeroType & OneType just need the same type
-        }
-
         void addToTyVarMap( TypeDecl * tyVar, TyVarMap &tyVarMap ) {
                 tyVarMap[ tyVar->get_name() ] = TypeDecl::Data{ tyVar };

src/GenPoly/GenPoly.h

@@ -67 +67 @@
         Type *hasPolyBase( Type *type, const TyVarMap &tyVars, int *levels = 0, const TypeSubstitution *env = 0 );
 
-        /// true iff this type or some base of this type after dereferencing pointers is either polymorphic or a generic type with at least one 
-        /// polymorphic parameter; will look up substitution in env if provided.
-        bool includesPolyType( Type *type, const TypeSubstitution *env = 0 );
-
-        /// true iff this type or some base of this type after dereferencing pointers is either polymorphic in tyVars, or a generic type with 
-        /// at least one polymorphic parameter in tyVars; will look up substitution in env if provided.
-        bool includesPolyType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env = 0 );
-
         /// Returns a pointer to the base FunctionType if ty is the type of a function (or pointer to one), NULL otherwise
         FunctionType *getFunctionType( Type *ty );
@@ -81 +73 @@
         /// N will be stored in levels, if provided
         VariableExpr *getBaseVar( Expression *expr, int *levels = 0 );
-
-        /// true iff types are structurally identical, where TypeInstType's match any type.
-        bool typesPolyCompatible( Type *aty, Type *bty );
 
         /// Adds the type variable `tyVar` to `tyVarMap`

src/GenPoly/InstantiateGeneric.cc

@@ -16 +16 @@
 #include <cassert>
 #include <list>
-#include <unordered_map>
 #include <utility>
 #include <vector>
+#include <unordered_map>
 
 #include "InstantiateGeneric.h"
@@ -25 +25 @@
 #include "GenPoly.h"
 #include "ScopedSet.h"
-#include "ScrubTyVars.h"
 #include "PolyMutator.h"
 
@@ -78 +77 @@
                         if ( params.size() != that.params.size() ) return false;
 
+                        SymTab::Indexer dummy;
                         for ( std::list< Type* >::const_iterator it = params.begin(), jt = that.params.begin(); it != params.end(); ++it, ++jt ) {
-                                if ( ! typesPolyCompatible( *it, *jt ) ) return false;
+                                if ( ! ResolvExpr::typesCompatible( *it, *jt, dummy ) ) return false;
                         }
                         return true;
@@ -227 +227 @@
                         if ( (*baseParam)->isComplete() ) {
                                 // substitute parameter for complete (otype or sized dtype) type
-                                if ( isPolyType( paramType->get_type() ) ) {
-                                        // substitute polymorphic parameter type in to generic type
+                                int pointerLevels = 0;
+                                if ( hasPolyBase( paramType->get_type(), &pointerLevels ) && pointerLevels > 0 ) {
+                                        // Make a void* with equivalent nesting
+                                        Type* voidPtr = new VoidType( Type::Qualifiers() );
+                                        while ( pointerLevels > 0 ) {
+                                                // Just about data layout, so qualifiers *shouldn't* matter
+                                                voidPtr = new PointerType( Type::Qualifiers(), voidPtr );
+                                                --pointerLevels;
+                                        }
+                                        out.push_back( new TypeExpr( voidPtr ) );
+                                } else {
+                                        // Just clone parameter type
                                         out.push_back( paramType->clone() );
-                                        gt = genericType::dynamic;
-                                } else {
-                                        // normalize possibly dtype-static parameter type
-                                        out.push_back( new TypeExpr{ 
-                                                ScrubTyVars::scrubAll( paramType->get_type()->clone() ) } );
-                                        gt |= genericType::concrete;
                                 }
+                                // make the struct concrete or dynamic depending on the parameter
+                                gt |= isPolyType( paramType->get_type() ) ? genericType::dynamic : genericType::concrete;
                         } else switch ( (*baseParam)->get_kind() ) {
                                 case TypeDecl::Dtype:
@@ -366 +372 @@
                                 concDecl = new StructDecl( typeNamer.newName( inst->get_name() ) );
                                 concDecl->set_body( inst->get_baseStruct()->has_body() );
-                                substituteMembers( inst->get_baseStruct()->get_members(), *inst->get_baseParameters(), typeSubs, concDecl->get_members() );
+                                substituteMembers( inst->get_baseStruct()->get_members(), *inst->get_baseParameters(), typeSubs,        concDecl->get_members() );
                                 DeclMutator::addDeclaration( concDecl );
                                 insert( inst, typeSubs, concDecl );

src/GenPoly/ScrubTyVars.cc

@@ -26 +26 @@
 namespace GenPoly {
         Type * ScrubTyVars::mutate( TypeInstType *typeInst ) {
-                if ( ! tyVars ) {
-                        if ( typeInst->get_isFtype() ) {
-                                delete typeInst;
-                                return new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) );
-                        } else {
-                                PointerType *ret = new PointerType( Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) );
-                                delete typeInst;
-                                return ret;
-                        }
-                }
-
-                TyVarMap::const_iterator tyVar = tyVars->find( typeInst->get_name() );
-                if ( tyVar != tyVars->end() ) {
+                TyVarMap::const_iterator tyVar = tyVars.find( typeInst->get_name() );
+                if ( tyVar != tyVars.end() ) {
                         switch ( tyVar->second.kind ) {
                           case TypeDecl::Any:

src/GenPoly/ScrubTyVars.h

@@ -26 +26 @@
 namespace GenPoly {
         class ScrubTyVars : public Mutator {
-                /// Whether to scrub all type variables from the provided map, dynamic type variables from the provided map, or all type variables
-                enum ScrubMode { FromMap, DynamicFromMap, All };
+          public:
+                ScrubTyVars( const TyVarMap &tyVars, bool dynamicOnly = false ): tyVars( tyVars ), dynamicOnly( dynamicOnly ) {}
 
-                ScrubTyVars() : tyVars(nullptr), mode( All ) {}
-
-                ScrubTyVars( const TyVarMap &tyVars, ScrubMode mode = FromMap ): tyVars( &tyVars ), mode( mode ) {}
-
-        public:
                 /// For all polymorphic types with type variables in `tyVars`, replaces generic types, dtypes, and ftypes with the appropriate void type,
                 /// and sizeof/alignof expressions with the proper variable
@@ -43 +38 @@
                 template< typename SynTreeClass >
                 static SynTreeClass *scrubDynamic( SynTreeClass *target, const TyVarMap &tyVars );
-
-                /// For all polymorphic types, replaces generic types, dtypes, and ftypes with the appropriate void type,
-                /// and sizeof/alignof expressions with the proper variable
-                template< typename SynTreeClass >
-                static SynTreeClass *scrubAll( SynTreeClass *target );
 
                 virtual Type* mutate( TypeInstType *typeInst );
@@ -59 +49 @@
                 /// Returns the type if it should be scrubbed, NULL otherwise.
                 Type* shouldScrub( Type *ty ) {
-                        switch ( mode ) {
-                        case FromMap: return isPolyType( ty, *tyVars );
-                        case DynamicFromMap: return isDynType( ty, *tyVars );
-                        case All: return isPolyType( ty );
-                        }
-                        assert(false); return nullptr; // unreachable
-                        // return dynamicOnly ? isDynType( ty, tyVars ) : isPolyType( ty, tyVars );
+                        return dynamicOnly ? isDynType( ty, tyVars ) : isPolyType( ty, tyVars );
+//                      if ( ! dynamicOnly ) return isPolyType( ty, tyVars );
+// 
+//                      if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( ty ) ) {
+//                              return tyVars.find( typeInst->get_name() ) != tyVars.end() ? ty : 0;
+//                      }
+// 
+//                      return isDynType( ty, tyVars );
                 }
                 
@@ -71 +62 @@
                 Type* mutateAggregateType( Type *ty );
                 
-                const TyVarMap *tyVars;  ///< Type variables to scrub
-                ScrubMode mode;          ///< which type variables to scrub? [FromMap]
+                const TyVarMap &tyVars;  ///< Type variables to scrub
+                bool dynamicOnly;        ///< only scrub the types with dynamic layout? [false]
         };
 
@@ -83 +74 @@
         template< typename SynTreeClass >
         SynTreeClass * ScrubTyVars::scrubDynamic( SynTreeClass *target, const TyVarMap &tyVars ) {
-                ScrubTyVars scrubber( tyVars, ScrubTyVars::DynamicFromMap );
-                return static_cast< SynTreeClass * >( target->acceptMutator( scrubber ) );
-        }
-
-        template< typename SynTreeClass >
-        SynTreeClass * ScrubTyVars::scrubAll( SynTreeClass *target ) {
-                ScrubTyVars scrubber;
+                ScrubTyVars scrubber( tyVars, true );
                 return static_cast< SynTreeClass * >( target->acceptMutator( scrubber ) );
         }

src/SymTab/Validate.cc

@@ -10 +10 @@
 // Created On       : Sun May 17 21:50:04 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Mar 14 23:30:27 2017
-// Update Count     : 350
+// Last Modified On : Tue Mar  7 07:51:36 2017
+// Update Count     : 349
 //
 
@@ -323 +323 @@
                         ObjectDecl * obj = dynamic_cast< ObjectDecl * >( *i );
                         assert( obj );
-                        obj->set_type( new EnumInstType( Type::Qualifiers( Type::Const ), enumDecl->get_name() ) );
+                        obj->set_type( new EnumInstType( Type::Qualifiers( true, false, false, false, false, false ), enumDecl->get_name() ) );
                 } // for
                 Parent::visit( enumDecl );

src/SynTree/Type.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Mar 15 21:28:09 2017
-// Update Count     : 85
+// Last Modified On : Wed Mar 15 21:23:08 2017
+// Update Count     : 84
 //
 
@@ -24 +24 @@
 class Type : public BaseSyntaxNode {
   public:
+        // struct Qualifiers {
+        //      Qualifiers(): isConst( false ), isVolatile( false ), isRestrict( false ), isLvalue( false ), isAtomic( false ), isMutex( false ) {}
+        //      Qualifiers( bool isConst, bool isVolatile, bool isRestrict, bool isLvalue, bool isAtomic, bool isMutex ): isConst( isConst ), isVolatile( isVolatile ), isRestrict( isRestrict ), isLvalue( isLvalue ), isAtomic( isAtomic ), isMutex( isMutex ) {}
+
+        //      Qualifiers &operator&=( const Qualifiers &other );
+        //      Qualifiers &operator+=( const Qualifiers &other );
+        //      Qualifiers &operator-=( const Qualifiers &other );
+        //      Qualifiers operator+( const Type::Qualifiers &other );
+        //      bool operator==( const Qualifiers &other );
+        //      bool operator!=( const Qualifiers &other );
+        //      bool operator<=( const Qualifiers &other );
+        //      bool operator>=( const Qualifiers &other );
+        //      bool operator<( const Qualifiers &other );
+        //      bool operator>( const Qualifiers &other );
+        //      void print( std::ostream &os, int indent = 0 ) const;
+
+        //      bool isConst;
+        //      bool isVolatile;
+        //      bool isRestrict;
+        //      bool isLvalue;
+        //      bool isAtomic;
+        //      bool isMutex;
+        // };
+
         static const char * QualifierNames[];
 
@@ -76 +100 @@
                         return q;
                 }
-                void print( std::ostream & os, int indent = 0 ) const {
+                void print( std::ostream &os, int indent = 0 ) const {
                         if ( (*this).any() ) {                                          // any type qualifiers ?
                                 for ( unsigned int i = 0; i < NumTypeQualifier; i += 1 ) {
@@ -87 +111 @@
         }; // Qualifiers
 
-        Type( const Qualifiers & tq, const std::list< Attribute * > & attributes );
-        Type( const Type & other );
+        Type( const Qualifiers &tq, const std::list< Attribute * > & attributes );
+        Type( const Type &other );
         virtual ~Type();
 
-        Qualifiers & get_qualifiers() { return tq; }
+        Qualifiers &get_qualifiers() { return tq; }
         bool get_isConst() { return tq.isConst; }
         bool get_isVolatile() { return tq.isVolatile; }
@@ -117 +141 @@
 
         virtual Type *clone() const = 0;
-        virtual void accept( Visitor & v ) = 0;
-        virtual Type *acceptMutator( Mutator & m ) = 0;
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void accept( Visitor &v ) = 0;
+        virtual Type *acceptMutator( Mutator &m ) = 0;
+        virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
         Qualifiers tq;
@@ -130 +154 @@
 class VoidType : public Type {
   public:
-        VoidType( const Type::Qualifiers & tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        VoidType( const Type::Qualifiers &tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
 
         virtual unsigned size() const { return 0; };
@@ -136 +160 @@
 
         virtual VoidType *clone() const { return new VoidType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
 };
 
@@ -170 +194 @@
         static const char *typeNames[];                                         // string names for basic types, MUST MATCH with Kind
 
-        BasicType( const Type::Qualifiers & tq, Kind bt, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        BasicType( const Type::Qualifiers &tq, Kind bt, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
 
         Kind get_kind() { return kind; }
@@ -176 +200 @@
 
         virtual BasicType *clone() const { return new BasicType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
 
         bool isInteger() const;
@@ -187 +211 @@
 class PointerType : public Type {
   public:
-        PointerType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
-        PointerType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        PointerType( const Type::Qualifiers &tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        PointerType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         PointerType( const PointerType& );
         virtual ~PointerType();
@@ -202 +226 @@
 
         virtual PointerType *clone() const { return new PointerType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
         Type *base;
@@ -216 +240 @@
 class ArrayType : public Type {
   public:
-        ArrayType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        ArrayType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         ArrayType( const ArrayType& );
         virtual ~ArrayType();
@@ -232 +256 @@
 
         virtual ArrayType *clone() const { return new ArrayType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
         Type *base;
@@ -244 +268 @@
 class FunctionType : public Type {
   public:
-        FunctionType( const Type::Qualifiers & tq, bool isVarArgs, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        FunctionType( const Type::Qualifiers &tq, bool isVarArgs, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         FunctionType( const FunctionType& );
         virtual ~FunctionType();
@@ -255 +279 @@
 
         virtual FunctionType *clone() const { return new FunctionType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
         std::list<DeclarationWithType*> returnVals;
@@ -271 +295 @@
 class ReferenceToType : public Type {
   public:
-        ReferenceToType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes );
-        ReferenceToType( const ReferenceToType & other );
+        ReferenceToType( const Type::Qualifiers &tq, const std::string &name, const std::list< Attribute * > & attributes );
+        ReferenceToType( const ReferenceToType &other );
         virtual ~ReferenceToType();
 
-        const std::string & get_name() const { return name; }
+        const std::string &get_name() const { return name; }
         void set_name( std::string newValue ) { name = newValue; }
         std::list< Expression* >& get_parameters() { return parameters; }
@@ -282 +306 @@
 
         virtual ReferenceToType *clone() const = 0;
-        virtual void accept( Visitor & v ) = 0;
-        virtual Type *acceptMutator( Mutator & m ) = 0;
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void accept( Visitor &v ) = 0;
+        virtual Type *acceptMutator( Mutator &m ) = 0;
+        virtual void print( std::ostream &os, int indent = 0 ) const;
   protected:
         virtual std::string typeString() const = 0;
@@ -296 +320 @@
         typedef ReferenceToType Parent;
   public:
-        StructInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
-        StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
-        StructInstType( const StructInstType & other ) : Parent( other ), baseStruct( other.baseStruct ) {}
+        StructInstType( const Type::Qualifiers &tq, const std::string &name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
+        StructInstType( const Type::Qualifiers &tq, StructDecl * baseStruct, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        StructInstType( const StructInstType &other ) : Parent( other ), baseStruct( other.baseStruct ) {}
 
         StructDecl *get_baseStruct() const { return baseStruct; }
@@ -310 +334 @@
         /// Looks up the members of this struct named "name" and places them into "foundDecls".
         /// Clones declarations into "foundDecls", caller responsible for freeing
-        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const;
+        void lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const;
 
         virtual StructInstType *clone() const { return new StructInstType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+
+        virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
         virtual std::string typeString() const;
@@ -328 +352 @@
         typedef ReferenceToType Parent;
   public:
-        UnionInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
-        UnionInstType( const Type::Qualifiers & tq, UnionDecl * baseUnion, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
-        UnionInstType( const UnionInstType & other ) : Parent( other ), baseUnion( other.baseUnion ) {}
+        UnionInstType( const Type::Qualifiers &tq, const std::string &name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
+        UnionInstType( const Type::Qualifiers &tq, UnionDecl * baseUnion, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        UnionInstType( const UnionInstType &other ) : Parent( other ), baseUnion( other.baseUnion ) {}
 
         UnionDecl *get_baseUnion() const { return baseUnion; }
@@ -342 +366 @@
         /// looks up the members of this union named "name" and places them into "foundDecls"
         /// Clones declarations into "foundDecls", caller responsible for freeing
-        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const;
+        void lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const;
 
         virtual UnionInstType *clone() const { return new UnionInstType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+
+        virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
         virtual std::string typeString() const;
@@ -360 +384 @@
         typedef ReferenceToType Parent;
   public:
-        EnumInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
-        EnumInstType( const Type::Qualifiers & tq, EnumDecl * baseEnum, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
-        EnumInstType( const EnumInstType & other ) : Parent( other ), baseEnum( other.baseEnum ) {}
+        EnumInstType( const Type::Qualifiers &tq, const std::string &name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
+        EnumInstType( const Type::Qualifiers &tq, EnumDecl * baseEnum, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        EnumInstType( const EnumInstType &other ) : Parent( other ), baseEnum( other.baseEnum ) {}
 
         EnumDecl *get_baseEnum() const { return baseEnum; }
@@ -370 +394 @@
 
         virtual EnumInstType *clone() const { return new EnumInstType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
   private:
         virtual std::string typeString() const;
@@ -383 +407 @@
         typedef ReferenceToType Parent;
   public:
-        TraitInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
-        TraitInstType( const TraitInstType & other );
+        TraitInstType( const Type::Qualifiers &tq, const std::string &name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
+        TraitInstType( const TraitInstType &other );
         ~TraitInstType();
 
@@ -392 +416 @@
 
         virtual TraitInstType *clone() const { return new TraitInstType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
   private:
         virtual std::string typeString() const;
@@ -405 +429 @@
         typedef ReferenceToType Parent;
   public:
-        TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
-        TypeInstType( const Type::Qualifiers & tq, const std::string & name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
-        TypeInstType( const TypeInstType & other );
+        TypeInstType( const Type::Qualifiers &tq, const std::string &name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        TypeInstType( const Type::Qualifiers &tq, const std::string &name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        TypeInstType( const TypeInstType &other );
         ~TypeInstType();
 
@@ -418 +442 @@
 
         virtual TypeInstType *clone() const { return new TypeInstType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
         virtual std::string typeString() const;
@@ -431 +455 @@
 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 = std::list< Type * >(), const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         TupleType( const TupleType& );
         virtual ~TupleType();
@@ -452 +476 @@
 
         virtual TupleType *clone() const { return new TupleType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
         std::list<Type*> types;
@@ -461 +485 @@
 class TypeofType : public Type {
   public:
-        TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        TypeofType( const Type::Qualifiers &tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         TypeofType( const TypeofType& );
         virtual ~TypeofType();
@@ -471 +495 @@
 
         virtual TypeofType *clone() const { return new TypeofType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
         Expression *expr;
@@ -480 +504 @@
 class AttrType : public Type {
   public:
-        AttrType( const Type::Qualifiers & tq, const std::string & name, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
-        AttrType( const Type::Qualifiers & tq, const std::string & name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        AttrType( const Type::Qualifiers &tq, const std::string &name, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        AttrType( const Type::Qualifiers &tq, const std::string &name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         AttrType( const AttrType& );
         virtual ~AttrType();
 
-        const std::string & get_name() const { return name; }
-        void set_name( const std::string & newValue ) { name = newValue; }
+        const std::string &get_name() const { return name; }
+        void set_name( const std::string &newValue ) { name = newValue; }
         Expression *get_expr() const { return expr; }
         void set_expr( Expression *newValue ) { expr = newValue; }
@@ -497 +521 @@
 
         virtual AttrType *clone() const { return new AttrType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
         std::string name;
@@ -516 +540 @@
 
         virtual VarArgsType *clone() const { return new VarArgsType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
 };
 
@@ -528 +552 @@
 
         virtual ZeroType *clone() const { return new ZeroType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
 };
 
@@ -540 +564 @@
 
         virtual OneType *clone() const { return new OneType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
 };
 

src/benchmark/CorCtxSwitch.c

@@ -1 +1 @@
 #include <fstream>
 #include <stdlib>
-#include <thread>
+#include <threads>
 
 #include <unistd.h>                                     // sysconf
@@ -24 +24 @@
 
 struct GreatSuspender {
-        coroutine_desc c;
+        coroutine c;
 };
 

src/benchmark/ThrdCtxSwitch.c

@@ -1 +1 @@
 #include <fstream>
 #include <stdlib>
-#include <thread>
+#include <threads>
 
 #include <unistd.h>                                     // sysconf

src/benchmark/bench.c

@@ -2 +2 @@
 #include <fstream>
 #include <stdlib>
-#include <thread>
+#include <threads>
 
 #include <unistd.h>                                     // sysconf
@@ -86 +86 @@
 //=======================================
 
-struct CoroutineDummy { coroutine_desc c; };
+struct CoroutineDummy { coroutine c; };
 DECL_COROUTINE(CoroutineDummy);
 void main(CoroutineDummy * this) {}
@@ -119 +119 @@
 struct CoroutineResume {
     int N;
-    coroutine_desc c;
+    coroutine c;
 };
 
@@ -150 +150 @@
 //=======================================
 
-struct ThreadDummy { thread_desc t; };
+struct ThreadDummy { thread t; };
 DECL_THREAD(ThreadDummy);
 void main(ThreadDummy * this) {}
@@ -180 +180 @@
     int N;
     long long result;
-    thread_desc t;
+    thread t;
 };
 

src/benchmark/csv-data.c

@@ -1 +1 @@
 #include <fstream>
 #include <stdlib>
-#include <thread>
+#include <threads>
 
 extern "C" {
@@ -26 +26 @@
 
 struct GreatSuspender {
-        coroutine_desc c;
+        coroutine c;
 };
 

src/examples/multicore.c

@@ -1 +1 @@
 #include <kernel>
-#include <thread>
+#include <threads>
 
-struct MyThread { thread_desc t; };
+struct MyThread { thread t; };
 
 DECL_THREAD(MyThread);

src/libcfa/Makefile.am

@@ -45 +45 @@
 # not all platforms support concurrency, add option do disable it
 if BUILD_CONCURRENCY
-headers += containers/vector concurrency/coroutine concurrency/thread concurrency/kernel concurrency/monitor
+headers += containers/vector concurrency/coroutines concurrency/threads concurrency/kernel concurrency/monitor
 endif
 

src/libcfa/Makefile.in

@@ -43 +43 @@
 
 # not all platforms support concurrency, add option do disable it
-@BUILD_CONCURRENCY_TRUE@am__append_3 = containers/vector concurrency/coroutine concurrency/thread concurrency/kernel concurrency/monitor
+@BUILD_CONCURRENCY_TRUE@am__append_3 = containers/vector concurrency/coroutines concurrency/threads concurrency/kernel concurrency/monitor
 
 # not all platforms support concurrency, add option do disable it
@@ -99 +99 @@
 am__libcfa_d_a_SOURCES_DIST = libcfa-prelude.c limits.c stdlib.c \
         math.c iostream.c fstream.c iterator.c rational.c assert.c \
-        containers/vector.c concurrency/coroutine.c \
-        concurrency/thread.c concurrency/kernel.c \
+        containers/vector.c concurrency/coroutines.c \
+        concurrency/threads.c concurrency/kernel.c \
         concurrency/monitor.c concurrency/CtxSwitch-@MACHINE_TYPE@.S \
         concurrency/invoke.c
 am__dirstamp = $(am__leading_dot)dirstamp
 @BUILD_CONCURRENCY_TRUE@am__objects_1 = containers/libcfa_d_a-vector.$(OBJEXT) \
-@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-coroutine.$(OBJEXT) \
-@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-thread.$(OBJEXT) \
+@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-coroutines.$(OBJEXT) \
+@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-threads.$(OBJEXT) \
 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-kernel.$(OBJEXT) \
 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-monitor.$(OBJEXT)
@@ -124 +124 @@
 am__libcfa_a_SOURCES_DIST = libcfa-prelude.c limits.c stdlib.c math.c \
         iostream.c fstream.c iterator.c rational.c assert.c \
-        containers/vector.c concurrency/coroutine.c \
-        concurrency/thread.c concurrency/kernel.c \
+        containers/vector.c concurrency/coroutines.c \
+        concurrency/threads.c concurrency/kernel.c \
         concurrency/monitor.c concurrency/CtxSwitch-@MACHINE_TYPE@.S \
         concurrency/invoke.c
 @BUILD_CONCURRENCY_TRUE@am__objects_5 =  \
 @BUILD_CONCURRENCY_TRUE@        containers/libcfa_a-vector.$(OBJEXT) \
-@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-coroutine.$(OBJEXT) \
-@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-thread.$(OBJEXT) \
+@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-coroutines.$(OBJEXT) \
+@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-threads.$(OBJEXT) \
 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-kernel.$(OBJEXT) \
 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-monitor.$(OBJEXT)
@@ -175 +175 @@
 am__nobase_cfa_include_HEADERS_DIST = limits stdlib math iostream \
         fstream iterator rational assert containers/vector \
-        concurrency/coroutine concurrency/thread concurrency/kernel \
+        concurrency/coroutines concurrency/threads concurrency/kernel \
         concurrency/monitor ${shell echo stdhdr/*} \
         concurrency/invoke.h
@@ -397 +397 @@
         @$(MKDIR_P) concurrency/$(DEPDIR)
         @: > concurrency/$(DEPDIR)/$(am__dirstamp)
-concurrency/libcfa_d_a-coroutine.$(OBJEXT):  \
+concurrency/libcfa_d_a-coroutines.$(OBJEXT):  \
         concurrency/$(am__dirstamp) \
         concurrency/$(DEPDIR)/$(am__dirstamp)
-concurrency/libcfa_d_a-thread.$(OBJEXT): concurrency/$(am__dirstamp) \
+concurrency/libcfa_d_a-threads.$(OBJEXT): concurrency/$(am__dirstamp) \
         concurrency/$(DEPDIR)/$(am__dirstamp)
 concurrency/libcfa_d_a-kernel.$(OBJEXT): concurrency/$(am__dirstamp) \
@@ -417 +417 @@
 containers/libcfa_a-vector.$(OBJEXT): containers/$(am__dirstamp) \
         containers/$(DEPDIR)/$(am__dirstamp)
-concurrency/libcfa_a-coroutine.$(OBJEXT): concurrency/$(am__dirstamp) \
+concurrency/libcfa_a-coroutines.$(OBJEXT):  \
+        concurrency/$(am__dirstamp) \
         concurrency/$(DEPDIR)/$(am__dirstamp)
-concurrency/libcfa_a-thread.$(OBJEXT): concurrency/$(am__dirstamp) \
+concurrency/libcfa_a-threads.$(OBJEXT): concurrency/$(am__dirstamp) \
         concurrency/$(DEPDIR)/$(am__dirstamp)
 concurrency/libcfa_a-kernel.$(OBJEXT): concurrency/$(am__dirstamp) \
@@ -435 +436 @@
         -rm -f *.$(OBJEXT)
         -rm -f concurrency/CtxSwitch-@MACHINE_TYPE@.$(OBJEXT)
-        -rm -f concurrency/libcfa_a-coroutine.$(OBJEXT)
+        -rm -f concurrency/libcfa_a-coroutines.$(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-thread.$(OBJEXT)
-        -rm -f concurrency/libcfa_d_a-coroutine.$(OBJEXT)
+        -rm -f concurrency/libcfa_a-threads.$(OBJEXT)
+        -rm -f concurrency/libcfa_d_a-coroutines.$(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-thread.$(OBJEXT)
+        -rm -f concurrency/libcfa_d_a-threads.$(OBJEXT)
         -rm -f containers/libcfa_a-vector.$(OBJEXT)
         -rm -f containers/libcfa_d_a-vector.$(OBJEXT)
@@ -470 +471 @@
 @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-coroutine.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-coroutines.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-thread.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_a-threads.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-coroutines.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-thread.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-threads.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-vector.Po@am__quote@
@@ -648 +649 @@
 @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-vector.obj `if test -f 'containers/vector.c'; then $(CYGPATH_W) 'containers/vector.c'; else $(CYGPATH_W) '$(srcdir)/containers/vector.c'; fi`
 
-concurrency/libcfa_d_a-coroutine.o: concurrency/coroutine.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-coroutine.o -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-coroutine.Tpo -c -o concurrency/libcfa_d_a-coroutine.o `test -f 'concurrency/coroutine.c' || echo '$(srcdir)/'`concurrency/coroutine.c
-@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-coroutine.Tpo concurrency/$(DEPDIR)/libcfa_d_a-coroutine.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/coroutine.c' object='concurrency/libcfa_d_a-coroutine.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-coroutine.o `test -f 'concurrency/coroutine.c' || echo '$(srcdir)/'`concurrency/coroutine.c
-
-concurrency/libcfa_d_a-coroutine.obj: concurrency/coroutine.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-coroutine.obj -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-coroutine.Tpo -c -o concurrency/libcfa_d_a-coroutine.obj `if test -f 'concurrency/coroutine.c'; then $(CYGPATH_W) 'concurrency/coroutine.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/coroutine.c'; fi`
-@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-coroutine.Tpo concurrency/$(DEPDIR)/libcfa_d_a-coroutine.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/coroutine.c' object='concurrency/libcfa_d_a-coroutine.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-coroutine.obj `if test -f 'concurrency/coroutine.c'; then $(CYGPATH_W) 'concurrency/coroutine.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/coroutine.c'; fi`
-
-concurrency/libcfa_d_a-thread.o: concurrency/thread.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-thread.o -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-thread.Tpo -c -o concurrency/libcfa_d_a-thread.o `test -f 'concurrency/thread.c' || echo '$(srcdir)/'`concurrency/thread.c
-@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-thread.Tpo concurrency/$(DEPDIR)/libcfa_d_a-thread.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/thread.c' object='concurrency/libcfa_d_a-thread.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-thread.o `test -f 'concurrency/thread.c' || echo '$(srcdir)/'`concurrency/thread.c
-
-concurrency/libcfa_d_a-thread.obj: concurrency/thread.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-thread.obj -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-thread.Tpo -c -o concurrency/libcfa_d_a-thread.obj `if test -f 'concurrency/thread.c'; then $(CYGPATH_W) 'concurrency/thread.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/thread.c'; fi`
-@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-thread.Tpo concurrency/$(DEPDIR)/libcfa_d_a-thread.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/thread.c' object='concurrency/libcfa_d_a-thread.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-thread.obj `if test -f 'concurrency/thread.c'; then $(CYGPATH_W) 'concurrency/thread.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/thread.c'; fi`
+concurrency/libcfa_d_a-coroutines.o: concurrency/coroutines.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-coroutines.o -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-coroutines.Tpo -c -o concurrency/libcfa_d_a-coroutines.o `test -f 'concurrency/coroutines.c' || echo '$(srcdir)/'`concurrency/coroutines.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-coroutines.Tpo concurrency/$(DEPDIR)/libcfa_d_a-coroutines.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/coroutines.c' object='concurrency/libcfa_d_a-coroutines.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-coroutines.o `test -f 'concurrency/coroutines.c' || echo '$(srcdir)/'`concurrency/coroutines.c
+
+concurrency/libcfa_d_a-coroutines.obj: concurrency/coroutines.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-coroutines.obj -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-coroutines.Tpo -c -o concurrency/libcfa_d_a-coroutines.obj `if test -f 'concurrency/coroutines.c'; then $(CYGPATH_W) 'concurrency/coroutines.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/coroutines.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-coroutines.Tpo concurrency/$(DEPDIR)/libcfa_d_a-coroutines.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/coroutines.c' object='concurrency/libcfa_d_a-coroutines.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-coroutines.obj `if test -f 'concurrency/coroutines.c'; then $(CYGPATH_W) 'concurrency/coroutines.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/coroutines.c'; fi`
+
+concurrency/libcfa_d_a-threads.o: concurrency/threads.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-threads.o -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-threads.Tpo -c -o concurrency/libcfa_d_a-threads.o `test -f 'concurrency/threads.c' || echo '$(srcdir)/'`concurrency/threads.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-threads.Tpo concurrency/$(DEPDIR)/libcfa_d_a-threads.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/threads.c' object='concurrency/libcfa_d_a-threads.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-threads.o `test -f 'concurrency/threads.c' || echo '$(srcdir)/'`concurrency/threads.c
+
+concurrency/libcfa_d_a-threads.obj: concurrency/threads.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-threads.obj -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-threads.Tpo -c -o concurrency/libcfa_d_a-threads.obj `if test -f 'concurrency/threads.c'; then $(CYGPATH_W) 'concurrency/threads.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/threads.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-threads.Tpo concurrency/$(DEPDIR)/libcfa_d_a-threads.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/threads.c' object='concurrency/libcfa_d_a-threads.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-threads.obj `if test -f 'concurrency/threads.c'; then $(CYGPATH_W) 'concurrency/threads.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/threads.c'; fi`
 
 concurrency/libcfa_d_a-kernel.o: concurrency/kernel.c
@@ -844 +845 @@
 @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-vector.obj `if test -f 'containers/vector.c'; then $(CYGPATH_W) 'containers/vector.c'; else $(CYGPATH_W) '$(srcdir)/containers/vector.c'; fi`
 
-concurrency/libcfa_a-coroutine.o: concurrency/coroutine.c
-@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_a-coroutine.o -MD -MP -MF concurrency/$(DEPDIR)/libcfa_a-coroutine.Tpo -c -o concurrency/libcfa_a-coroutine.o `test -f 'concurrency/coroutine.c' || echo '$(srcdir)/'`concurrency/coroutine.c
-@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-coroutine.Tpo concurrency/$(DEPDIR)/libcfa_a-coroutine.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/coroutine.c' object='concurrency/libcfa_a-coroutine.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-coroutine.o `test -f 'concurrency/coroutine.c' || echo '$(srcdir)/'`concurrency/coroutine.c
-
-concurrency/libcfa_a-coroutine.obj: concurrency/coroutine.c
-@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_a-coroutine.obj -MD -MP -MF concurrency/$(DEPDIR)/libcfa_a-coroutine.Tpo -c -o concurrency/libcfa_a-coroutine.obj `if test -f 'concurrency/coroutine.c'; then $(CYGPATH_W) 'concurrency/coroutine.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/coroutine.c'; fi`
-@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-coroutine.Tpo concurrency/$(DEPDIR)/libcfa_a-coroutine.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/coroutine.c' object='concurrency/libcfa_a-coroutine.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-coroutine.obj `if test -f 'concurrency/coroutine.c'; then $(CYGPATH_W) 'concurrency/coroutine.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/coroutine.c'; fi`
-
-concurrency/libcfa_a-thread.o: concurrency/thread.c
-@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_a-thread.o -MD -MP -MF concurrency/$(DEPDIR)/libcfa_a-thread.Tpo -c -o concurrency/libcfa_a-thread.o `test -f 'concurrency/thread.c' || echo '$(srcdir)/'`concurrency/thread.c
-@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-thread.Tpo concurrency/$(DEPDIR)/libcfa_a-thread.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/thread.c' object='concurrency/libcfa_a-thread.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-thread.o `test -f 'concurrency/thread.c' || echo '$(srcdir)/'`concurrency/thread.c
-
-concurrency/libcfa_a-thread.obj: concurrency/thread.c
-@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_a-thread.obj -MD -MP -MF concurrency/$(DEPDIR)/libcfa_a-thread.Tpo -c -o concurrency/libcfa_a-thread.obj `if test -f 'concurrency/thread.c'; then $(CYGPATH_W) 'concurrency/thread.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/thread.c'; fi`
-@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-thread.Tpo concurrency/$(DEPDIR)/libcfa_a-thread.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/thread.c' object='concurrency/libcfa_a-thread.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-thread.obj `if test -f 'concurrency/thread.c'; then $(CYGPATH_W) 'concurrency/thread.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/thread.c'; fi`
+concurrency/libcfa_a-coroutines.o: concurrency/coroutines.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_a-coroutines.o -MD -MP -MF concurrency/$(DEPDIR)/libcfa_a-coroutines.Tpo -c -o concurrency/libcfa_a-coroutines.o `test -f 'concurrency/coroutines.c' || echo '$(srcdir)/'`concurrency/coroutines.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-coroutines.Tpo concurrency/$(DEPDIR)/libcfa_a-coroutines.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/coroutines.c' object='concurrency/libcfa_a-coroutines.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-coroutines.o `test -f 'concurrency/coroutines.c' || echo '$(srcdir)/'`concurrency/coroutines.c
+
+concurrency/libcfa_a-coroutines.obj: concurrency/coroutines.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_a-coroutines.obj -MD -MP -MF concurrency/$(DEPDIR)/libcfa_a-coroutines.Tpo -c -o concurrency/libcfa_a-coroutines.obj `if test -f 'concurrency/coroutines.c'; then $(CYGPATH_W) 'concurrency/coroutines.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/coroutines.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-coroutines.Tpo concurrency/$(DEPDIR)/libcfa_a-coroutines.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/coroutines.c' object='concurrency/libcfa_a-coroutines.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-coroutines.obj `if test -f 'concurrency/coroutines.c'; then $(CYGPATH_W) 'concurrency/coroutines.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/coroutines.c'; fi`
+
+concurrency/libcfa_a-threads.o: concurrency/threads.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_a-threads.o -MD -MP -MF concurrency/$(DEPDIR)/libcfa_a-threads.Tpo -c -o concurrency/libcfa_a-threads.o `test -f 'concurrency/threads.c' || echo '$(srcdir)/'`concurrency/threads.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-threads.Tpo concurrency/$(DEPDIR)/libcfa_a-threads.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/threads.c' object='concurrency/libcfa_a-threads.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-threads.o `test -f 'concurrency/threads.c' || echo '$(srcdir)/'`concurrency/threads.c
+
+concurrency/libcfa_a-threads.obj: concurrency/threads.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_a-threads.obj -MD -MP -MF concurrency/$(DEPDIR)/libcfa_a-threads.Tpo -c -o concurrency/libcfa_a-threads.obj `if test -f 'concurrency/threads.c'; then $(CYGPATH_W) 'concurrency/threads.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/threads.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-threads.Tpo concurrency/$(DEPDIR)/libcfa_a-threads.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/threads.c' object='concurrency/libcfa_a-threads.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-threads.obj `if test -f 'concurrency/threads.c'; then $(CYGPATH_W) 'concurrency/threads.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/threads.c'; fi`
 
 concurrency/libcfa_a-kernel.o: concurrency/kernel.c

src/libcfa/concurrency/invoke.c

@@ -29 +29 @@
 
 extern void __suspend_internal(void);
-extern void __thread_signal_termination(struct thread_desc*);
+extern void __thread_signal_termination(struct thread*);
 
 void CtxInvokeCoroutine(
       void (*main)(void *), 
-      struct coroutine_desc *(*get_coroutine)(void *), 
+      struct coroutine *(*get_coroutine)(void *), 
       void *this
 ) {
       // LIB_DEBUG_PRINTF("Invoke Coroutine : Received %p (main %p, get_c %p)\n", this, main, get_coroutine);
 
-      struct coroutine_desc* cor = get_coroutine( this );
+      struct coroutine* cor = get_coroutine( this );
 
       if(cor->state == Primed) {
@@ -57 +57 @@
 void CtxInvokeThread(
       void (*main)(void *), 
-      struct thread_desc *(*get_thread)(void *), 
+      struct thread *(*get_thread)(void *), 
       void *this
 ) {
       __suspend_internal();
 
-      struct thread_desc* thrd = get_thread( this );
-      struct coroutine_desc* cor = &thrd->c;
+      struct thread* thrd = get_thread( this );
+      struct coroutine* cor = &thrd->c;
       cor->state = Active;
 
@@ -79 +79 @@
 void CtxStart(
       void (*main)(void *), 
-      struct coroutine_desc *(*get_coroutine)(void *), 
+      struct coroutine *(*get_coroutine)(void *), 
       void *this, 
       void (*invoke)(void *)

src/libcfa/concurrency/invoke.h

@@ -35 +35 @@
 
       struct simple_thread_list {
-            struct thread_desc * head;
-            struct thread_desc ** tail;
+            struct thread * head;
+            struct thread ** tail;
       };
 
@@ -48 +48 @@
       extern "Cforall" {
             void ?{}( struct simple_thread_list * );
-            void append( struct simple_thread_list *, struct thread_desc * );
-            struct thread_desc * pop_head( struct simple_thread_list * );
+            void append( struct simple_thread_list *, struct thread * );
+            struct thread * pop_head( struct simple_thread_list * );
 
             void ?{}(spinlock * this);
@@ -71 +71 @@
       enum coroutine_state { Halted, Start, Inactive, Active, Primed };
 
-      struct coroutine_desc {
+      struct coroutine {
             struct coStack_t stack;
             const char *name;                         // textual name for coroutine/task, initialized by uC++ generated code
             int errno_;                               // copy of global UNIX variable errno
             enum coroutine_state state;       // current execution status for coroutine
-            struct coroutine_desc *starter;           // first coroutine to resume this one
-            struct coroutine_desc *last;                      // last coroutine to resume this one
+            struct coroutine *starter;        // first coroutine to resume this one
+            struct coroutine *last;                   // last coroutine to resume this one
       };
 
-      struct thread_desc {
-            struct coroutine_desc c;                 // coroutine body used to store context
+      struct thread {
+            struct coroutine c;                 // coroutine body used to store context
             struct signal_once terminated;      // indicate if execuation state is not halted
-            struct thread_desc * next;               // instrusive link field for threads
+            struct thread * next;               // instrusive link field for threads
       };
 

src/libcfa/concurrency/kernel

@@ -6 +6 @@
 // file "LICENCE" distributed with Cforall.
 //
-// kernel --
+// threads --
 //
 // Author           : Thierry Delisle
@@ -49 +49 @@
 struct FinishAction {
         FinishOpCode action_code;
-        thread_desc * thrd;
+        thread * thrd;
         spinlock * lock;
 };
@@ -62 +62 @@
         struct processorCtx_t * runner;
         cluster * cltr;
-        coroutine_desc * current_coroutine;
-        thread_desc * current_thread;
+        coroutine * current_coroutine;
+        thread * current_thread;
         pthread_t kernel_thread;
         

src/libcfa/concurrency/kernel.c

@@ -43 +43 @@
 KERNEL_STORAGE(cluster, systemCluster);
 KERNEL_STORAGE(processor, systemProcessor);
-KERNEL_STORAGE(thread_desc, mainThread);
+KERNEL_STORAGE(thread, mainThread);
 KERNEL_STORAGE(machine_context_t, mainThread_context);
 
 cluster * systemCluster;
 processor * systemProcessor;
-thread_desc * mainThread;
+thread * mainThread;
 
 //-----------------------------------------------------------------------------
@@ -55 +55 @@
 thread_local processor * this_processor;
 
-coroutine_desc * this_coroutine(void) {
+processor * get_this_processor() {
+        return this_processor;
+}
+
+coroutine * this_coroutine(void) {
         return this_processor->current_coroutine;
 }
 
-thread_desc * this_thread(void) {
+thread * this_thread(void) {
         return this_processor->current_thread;
 }
@@ -99 +103 @@
 }
 
-void ?{}( coroutine_desc * this, current_stack_info_t * info) {
+void ?{}( coroutine * this, current_stack_info_t * info) {
         (&this->stack){ info }; 
         this->name = "Main Thread";
@@ -106 +110 @@
 }
 
-void ?{}( thread_desc * this, current_stack_info_t * info) {
+void ?{}( thread * this, current_stack_info_t * info) {
         (&this->c){ info };
 }
@@ -175 +179 @@
         LIB_DEBUG_PRINTF("Kernel : core %p starting\n", this);
 
-        thread_desc * readyThread = NULL;
+        thread * readyThread = NULL;
         for( unsigned int spin_count = 0; ! this->is_terminated; spin_count++ ) 
         {
@@ -202 +206 @@
 // runThread runs a thread by context switching 
 // from the processor coroutine to the target thread 
-void runThread(processor * this, thread_desc * dst) {
-        coroutine_desc * proc_cor = get_coroutine(this->runner);
-        coroutine_desc * thrd_cor = get_coroutine(dst);
+void runThread(processor * this, thread * dst) {
+        coroutine * proc_cor = get_coroutine(this->runner);
+        coroutine * thrd_cor = get_coroutine(dst);
         
         //Reset the terminating actions here
@@ -293 +297 @@
 //-----------------------------------------------------------------------------
 // Scheduler routines
-void ScheduleThread( thread_desc * thrd ) {
+void ScheduleThread( thread * thrd ) {
         assertf( thrd->next == NULL, "Expected null got %p", thrd->next );
         
@@ -301 +305 @@
 }
 
-thread_desc * nextThread(cluster * this) {
+thread * nextThread(cluster * this) {
         lock( &this->lock );
-        thread_desc * head = pop_head( &this->ready_queue );
+        thread * head = pop_head( &this->ready_queue );
         unlock( &this->lock );
         return head;
@@ -313 +317 @@
 
 void ScheduleInternal( spinlock * lock ) {
-        this_processor->finish.action_code = Release;
-        this_processor->finish.lock = lock;
+        get_this_processor()->finish.action_code = Release;
+        get_this_processor()->finish.lock = lock;
         suspend();
 }
 
-void ScheduleInternal( thread_desc * thrd ) {
-        this_processor->finish.action_code = Schedule;
-        this_processor->finish.thrd = thrd;
+void ScheduleInternal( thread * thrd ) {
+        get_this_processor()->finish.action_code = Schedule;
+        get_this_processor()->finish.thrd = thrd;
         suspend();
 }
 
-void ScheduleInternal( spinlock * lock, thread_desc * thrd ) {
-        this_processor->finish.action_code = Release_Schedule;
-        this_processor->finish.lock = lock;
-        this_processor->finish.thrd = thrd;
+void ScheduleInternal( spinlock * lock, thread * thrd ) {
+        get_this_processor()->finish.action_code = Release_Schedule;
+        get_this_processor()->finish.lock = lock;
+        get_this_processor()->finish.thrd = thrd;
         suspend();
 }
@@ -339 +343 @@
         // SKULLDUGGERY: the mainThread steals the process main thread 
         // which will then be scheduled by the systemProcessor normally
-        mainThread = (thread_desc *)&mainThread_storage;
+        mainThread = (thread *)&mainThread_storage;
         current_stack_info_t info;
         mainThread{ &info };
@@ -436 +440 @@
                 this->condition = true;
 
-                thread_desc * it;
+                thread * it;
                 while( it = pop_head( &this->blocked) ) {
                         ScheduleThread( it );
@@ -451 +455 @@
 }
 
-void append( simple_thread_list * this, thread_desc * t ) {
+void append( simple_thread_list * this, thread * t ) {
         assert(this->tail != NULL);
         *this->tail = t;
@@ -457 +461 @@
 }
 
-thread_desc * pop_head( simple_thread_list * this ) {
-        thread_desc * head = this->head;
+thread * pop_head( simple_thread_list * this ) {
+        thread * head = this->head;
         if( head ) {
                 this->head = head->next;

src/libcfa/concurrency/kernel_private.h

@@ -6 +6 @@
 // file "LICENCE" distributed with Cforall.
 //
-// kernel_private.h --
+// threads --
 //
 // Author           : Thierry Delisle
@@ -19 +19 @@
 
 #include "kernel"
-#include "thread"
+#include "threads"
 
 //-----------------------------------------------------------------------------
 // Scheduler
-void ScheduleThread( thread_desc * );
-thread_desc * nextThread(cluster * this);
+void ScheduleThread( thread * );
+thread * nextThread(cluster * this);
 
 void ScheduleInternal();
 void ScheduleInternal(spinlock * lock);
-void ScheduleInternal(thread_desc * thrd);
-void ScheduleInternal(spinlock * lock, thread_desc * thrd);
+void ScheduleInternal(thread * thrd);
+void ScheduleInternal(spinlock * lock, thread * thrd);
 
 //-----------------------------------------------------------------------------
@@ -35 +35 @@
 struct processorCtx_t {
         processor * proc;
-        coroutine_desc c;
+        coroutine c;
 };
 
@@ -42 +42 @@
 void main(processorCtx_t *);
 void start(processor * this);
-void runThread(processor * this, thread_desc * dst);
+void runThread(processor * this, thread * dst);
 void finishRunning(processor * this);
 void spin(processor * this, unsigned int * spin_count);
@@ -53 +53 @@
 }
 
-extern void ThreadCtxSwitch(coroutine_desc * src, coroutine_desc * dst);
+extern void ThreadCtxSwitch(coroutine * src, coroutine * dst);
 
 #endif //KERNEL_PRIVATE_H

src/libcfa/concurrency/monitor

@@ -22 +22 @@
 #include "stdlib"
 
-struct monitor_desc {
+struct __monitor_t {
         spinlock lock;
-        thread_desc * owner;
+        thread * owner;
         simple_thread_list entry_queue;
         unsigned int recursion;
 };
 
-static inline void ?{}(monitor_desc * this) {
+static inline void ?{}(__monitor_t * this) {
         this->owner = 0;
         this->recursion = 0;
@@ -35 +35 @@
 
 //Basic entering routine
-void enter(monitor_desc *);
-void leave(monitor_desc *);
+void enter(__monitor_t *);
+void leave(__monitor_t *);
 
 //Array entering routine
-void enter(monitor_desc **, int count);
-void leave(monitor_desc **, int count);
+void enter(__monitor_t **, int count);
+void leave(__monitor_t **, int count);
 
 struct monitor_guard_t {
-        monitor_desc ** m;
+        __monitor_t ** m;
         int count;
 };
 
-static inline int ?<?(monitor_desc* lhs, monitor_desc* rhs) {
+static inline int ?<?(__monitor_t* lhs, __monitor_t* rhs) {
         return ((intptr_t)lhs) < ((intptr_t)rhs);
 }
 
-static inline void ?{}( monitor_guard_t * this, monitor_desc ** m ) {
+static inline void ?{}( monitor_guard_t * this, __monitor_t ** m ) {
         this->m = m;
         this->count = 1;
@@ -57 +57 @@
 }
 
-static inline void ?{}( monitor_guard_t * this, monitor_desc ** m, int count ) {
+static inline void ?{}( monitor_guard_t * this, __monitor_t ** m, int count ) {
         this->m = m;
         this->count = count;

src/libcfa/concurrency/monitor.c

@@ -6 +6 @@
 // file "LICENCE" distributed with Cforall.
 //
-// monitor_desc.c --
+// __monitor_t.c --
 //
 // Author           : Thierry Delisle
@@ -19 +19 @@
 #include "kernel_private.h"
 
-void enter(monitor_desc * this) {
+void enter(__monitor_t * this) {
         lock( &this->lock );
-        thread_desc * thrd = this_thread();
+        thread * thrd = this_thread();
 
         if( !this->owner ) {
@@ -45 +45 @@
 }
 
-void leave(monitor_desc * this) {
+void leave(__monitor_t * this) {
         lock( &this->lock );
 
-        thread_desc * thrd = this_thread();
+        thread * thrd = this_thread();
         assert( thrd == this->owner );
 
@@ -55 +55 @@
 
         //If we left the last level of recursion it means we are changing who owns the monitor
-        thread_desc * new_owner = 0;
+        thread * new_owner = 0;
         if( this->recursion == 0) {
                 //Get the next thread in the list
@@ -72 +72 @@
 }
 
-void enter(monitor_desc ** monitors, int count) {
+void enter(__monitor_t ** monitors, int count) {
         for(int i = 0; i < count; i++) {
                 // printf("%d\n", i);
@@ -79 +79 @@
 }
 
-void leave(monitor_desc ** monitors, int count) {
+void leave(__monitor_t ** monitors, int count) {
         for(int i = count - 1; i >= 0; i--) {
                 // printf("%d\n", i);

src/tests/coroutine.c

@@ -1 +1 @@
 #include <fstream>
-#include <coroutine>
+#include <coroutines>
 
 struct Fibonacci {
       int fn; // used for communication
-      coroutine_desc c;
+      coroutine c;
 };
 
@@ -11 +11 @@
 }
 
-coroutine_desc* get_coroutine(Fibonacci* this) {
+coroutine* get_coroutine(Fibonacci* this) {
       return &this->c;
 }
@@ -47 +47 @@
 #ifdef MORE_DEBUG      
       Fibonacci *pf1 = &f1, *pf2 = &f2;
-      coroutine_desc *cf1 = &f1.c, *cf2 = &f2.c;
+      coroutine *cf1 = &f1.c, *cf2 = &f2.c;
       covptr_t  *vf1 = vtable(pf1), *vf2 = vtable(pf2);
-      coroutine_desc *cv1 = get_coroutine(vf1), *cv2 = get_coroutine(vf2);
+      coroutine *cv1 = get_coroutine(vf1), *cv2 = get_coroutine(vf2);
       Fibonacci *ov1 = (Fibonacci *)get_object(vf1), *ov2 = (Fibonacci *)get_object(vf2);
 

src/tests/monitor.c

@@ -2 +2 @@
 #include <kernel>
 #include <monitor>
-#include <thread>
+#include <threads>
 
 struct global_t {
         int value;
-        monitor_desc m;
+        __monitor_t m;
 };
 
@@ -16 +16 @@
 
 void increment( /*mutex*/ global_t * this ) {
-        monitor_desc * mon = &this->m;
+        __monitor_t * mon = &this->m;
         monitor_guard_t g1 = { &mon };
         {
@@ -27 +27 @@
 }
 
-struct MyThread { thread_desc t; };
+struct MyThread { thread t; };
 
 DECL_THREAD(MyThread);

src/tests/multi-monitor.c

@@ -2 +2 @@
 #include <kernel>
 #include <monitor>
-#include <thread>
+#include <threads>
 
 static int global12, global23, global13;
 
-static monitor_desc m1, m2, m3;
+static __monitor_t m1, m2, m3;
 
-void increment( /*mutex*/ monitor_desc * p1, /*mutex*/ monitor_desc * p2, int * value ) {
-        monitor_desc * mons[] = { p1, p2 };
+void increment( /*mutex*/ __monitor_t * p1, /*mutex*/ __monitor_t * p2, int * value ) {
+        __monitor_t * mons[] = { p1, p2 };
         monitor_guard_t g = { mons, 2 };
         *value += 1;
@@ -15 +15 @@
 
 struct MyThread { 
-        thread_desc t; 
+        thread t; 
         int target;
 };

src/tests/test.py

@@ -250 +250 @@
 parser = argparse.ArgumentParser(description='Script which runs cforall tests')
 parser.add_argument('--debug', help='Run all tests in debug or release', type=yes_no, default='no')
-parser.add_argument('--concurrent', help='Run concurrent tests', type=yes_no, default='yes')
+parser.add_argument('--concurrent', help='Run concurrent tests', type=yes_no, default='no')
 parser.add_argument('--dry-run', help='Don\'t run the tests, only output the commands', action='store_true')
 parser.add_argument('--list', help='List all test available', action='store_true')

src/tests/thread.c

@@ -2 +2 @@
 #include <kernel>
 #include <stdlib>
-#include <thread>
+#include <threads>
 
-struct First { thread_desc t; signal_once* lock; };
-struct Second { thread_desc t; signal_once* lock; };
+struct First { thread t; signal_once* lock; };
+struct Second { thread t; signal_once* lock; };
 
 DECL_THREAD(First);