Changeset 1fbab5a


Ignore:
Timestamp:
Mar 16, 2017, 4:50:08 PM (5 years ago)
Author:
Rob Schluntz <rschlunt@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
395fc37, 64ac636, ef42b143
Parents:
2f26687 (diff), d6d747d (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of plg.uwaterloo.ca:/u/cforall/software/cfa/cfa-cc

Files:
57 edited
4 moved

Legend:

Unmodified
Added
Removed
  • Jenkins/FullBuild

    r2f26687 r1fbab5a  
    2020
    2121                                        parallel (
    22                                                 gcc_6_x64: { trigger_build( 'gcc-6',   'x64' ) },
    23                                                 gcc_6_x86: { trigger_build( 'gcc-6',   'x86' ) },
    24                                                 gcc_5_x64: { trigger_build( 'gcc-5',   'x64' ) },
    25                                                 gcc_5_x86: { trigger_build( 'gcc-5',   'x86' ) },
    26                                                 gcc_4_x64: { trigger_build( 'gcc-4.9', 'x64' ) },
    27                                                 gcc_4_x86: { trigger_build( 'gcc-4.9', 'x86' ) },
    28                                                 clang_x64: { trigger_build( 'clang',   'x64' ) },
    29                                                 clang_x86: { trigger_build( 'clang',   'x86' ) },
     22                                                gcc_6_x64: { trigger_build( 'gcc-6',   'x64', true ) },
     23                                                gcc_6_x86: { trigger_build( 'gcc-6',   'x86', true ) },
     24                                                gcc_5_x64: { trigger_build( 'gcc-5',   'x64', false ) },
     25                                                gcc_5_x86: { trigger_build( 'gcc-5',   'x86', false ) },
     26                                                gcc_4_x64: { trigger_build( 'gcc-4.9', 'x64', false ) },
     27                                                gcc_4_x86: { trigger_build( 'gcc-4.9', 'x86', false ) },
     28                                                clang_x64: { trigger_build( 'clang',   'x64', false ) },
     29                                                clang_x86: { trigger_build( 'clang',   'x86', false ) },
    3030                                        )
    3131
     
    6262//===========================================================================================================
    6363
    64 def trigger_build(String cc, String arch) {
     64def trigger_build(String cc, String arch, Boolean publish) {
    6565        def result = build job: 'Cforall/master',               \
    6666                parameters: [                                           \
     
    8282                        [$class: 'BooleanParameterValue',               \
    8383                          name: 'pPublish',                             \
    84                           value: true],                                         \
     84                          value: publish],                                      \
    8585                        [$class: 'BooleanParameterValue',               \
    8686                          name: 'pSilent',                              \
  • Jenkinsfile

    r2f26687 r1fbab5a  
    131131                                [$class: 'BooleanParameterDefinition',                                                  \
    132132                                        description: 'If true, jenkins also builds documentation',              \
    133                                         name: 'pBuildDocumentation',                                                            \
     133                                        name: 'pBuildDocumentation',                                                    \
    134134                                        defaultValue: true,                                                             \
    135135                                ],                                                                                              \
     
    137137                                        description: 'If true, jenkins also publishes results',                 \
    138138                                        name: 'pPublish',                                                               \
    139                                         defaultValue: true,                                                             \
     139                                        defaultValue: false,                                                            \
    140140                                ],                                                                                              \
    141141                                [$class: 'BooleanParameterDefinition',                                                  \
    142142                                        description: 'If true, jenkins will not send emails',           \
    143                                         name: 'pSilent',                                                \
     143                                        name: 'pSilent',                                                                        \
    144144                                        defaultValue: false,                                                            \
    145145                                ],                                                                                              \
     
    159159        echo """Compiler                : ${compiler.cc_name} (${compiler.cpp_cc}/${compiler.cfa_cc})
    160160Architecture            : ${arch_name}
    161 Arc Flags                       : ${architecture}
     161Arc Flags               : ${architecture}
    162162Run All Tests           : ${ pRunAllTests.toString() }
    163163Run Benchmark           : ${ pRunBenchmark.toString() }
  • doc/proposals/concurrency/thePlan.md

    r2f26687 r1fbab5a  
    77
    88_Phase 2_ : Minimum Viable Product
    9 Monitor type and enter/leave mutex member routines
     9done - Monitor type and enter/leave mutex member routines
    1010Monitors as a language feature (not calling enter/leave by hand)
    1111Internal scheduling
  • doc/proposals/flags.md

    r2f26687 r1fbab5a  
    6969In each of the cases above, `FOO` could be replaced by `(BAR | BAZ)` to do the same operation or test on multiple flags at once.
    7070
     71### Alternative/Additional Features ###
     72
     73#### User-defined enum discriminant iterator ####
     74It 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:
     75
     76        ```
     77        enum(@ << 1) TCP_Flags {  // each discriminant is left-shifted by 1 from the previous
     78                FIN = 0x1,  // first flag is 1
     79                SYN,
     80                ACK,
     81                ...
     82        }
     83        ```
     84
     85#### Member expression for enums ####
     86As 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):
     87
     88        ```
     89        FunFlags f = some_val();
     90        if ( f.FOO ) { sout | "f has FOO set" | endl; }
     91        f.FOO = true;    // set FOO
     92        f.FOO = false;   // unset FOO
     93        f.FOO = ! f.FOO; // toggle FOO
     94        ```
     95
    7196### Related Work ###
    7297C# 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/CodeGen/CodeGenerator.cc

    r2f26687 r1fbab5a  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Mar 13 23:56:59 2017
    13 // Update Count     : 477
     12// Last Modified On : Thu Mar 16 09:09:09 2017
     13// Update Count     : 480
    1414//
    1515
     
    134134
    135135                handleStorageClass( functionDecl );
    136                 DeclarationNode::print_FuncSpec( output, functionDecl->get_funcSpec() );
     136                functionDecl->get_funcSpec().print( output );
    137137
    138138                output << genType( functionDecl->get_functionType(), mangleName( functionDecl ), pretty );
     
    895895
    896896        void CodeGenerator::handleStorageClass( DeclarationWithType * decl ) {
    897                 if ( decl->get_storageClasses().val != 0 ) {
    898                         DeclarationNode::print_StorageClass( output, decl->get_storageClasses() );
     897                if ( decl->get_storageClasses().any() ) {
     898                        decl->get_storageClasses().print( output );
    899899                } // if
    900900        } // CodeGenerator::handleStorageClass
  • src/CodeGen/FixNames.cc

    r2f26687 r1fbab5a  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Mar  6 23:32:08 2017
    13 // Update Count     : 15
     12// Last Modified On : Thu Mar 16 07:50:30 2017
     13// Update Count     : 16
    1414//
    1515
     
    3939        std::string mangle_main() {
    4040                FunctionType* main_type;
    41                 std::unique_ptr<FunctionDecl> mainDecl { new FunctionDecl( "main", DeclarationNode::StorageClasses(), LinkageSpec::Cforall,
     41                std::unique_ptr<FunctionDecl> mainDecl { new FunctionDecl( "main", Type::StorageClasses(), LinkageSpec::Cforall,
    4242                                                                                                                                   main_type = new FunctionType( Type::Qualifiers(), true ), nullptr )
    4343                                };
    4444                main_type->get_returnVals().push_back(
    45                         new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr )
     45                        new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr )
    4646                );
    4747
     
    5252        std::string mangle_main_args() {
    5353                FunctionType* main_type;
    54                 std::unique_ptr<FunctionDecl> mainDecl { new FunctionDecl( "main", DeclarationNode::StorageClasses(), LinkageSpec::Cforall,
     54                std::unique_ptr<FunctionDecl> mainDecl { new FunctionDecl( "main", Type::StorageClasses(), LinkageSpec::Cforall,
    5555                                                                                                                                   main_type = new FunctionType( Type::Qualifiers(), false ), nullptr )
    5656                                };
    5757                main_type->get_returnVals().push_back(
    58                         new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr )
     58                        new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr )
    5959                );
    6060
    6161                mainDecl->get_functionType()->get_parameters().push_back(
    62                         new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr )
     62                        new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr )
    6363                );
    6464
    6565                mainDecl->get_functionType()->get_parameters().push_back(
    66                         new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0,
     66                        new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0,
    6767                        new PointerType( Type::Qualifiers(), new PointerType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::Char ) ) ),
    6868                        nullptr )
  • src/Concurrency/Keywords.cc

    r2f26687 r1fbab5a  
    1212// Last Modified By :
    1313// Last Modified On :
    14 // Update Count     : 0
     14// Update Count     : 1
    1515//
    1616
     
    2929        namespace {
    3030                const std::list<Label> noLabels;
    31                 DeclarationNode::StorageClasses noStorage;
     31                Type::StorageClasses noStorage;
    3232                Type::Qualifiers noQualifiers;
    3333        }
     
    8888        //Handles mutex routines definitions :
    8989        // void foo( A * mutex a, B * mutex b,  int i ) {                  void foo( A * a, B * b,  int i ) {
    90         //                                                                       monitor_desc * __monitors[] = { a, b };
     90        //                                                                       monitor_desc * __monitors[] = { get_monitor(a), get_monitor(b) };
    9191        //                                                                       monitor_guard_t __guard = { __monitors, 2 };
    9292        //    /*Some code*/                                       =>           /*Some code*/
     
    9898                using Visitor::visit;
    9999                virtual void visit( FunctionDecl *functionDecl ) override final;
     100                virtual void visit(   StructDecl *functionDecl ) override final;
    100101
    101102                std::list<DeclarationWithType*> findMutexArgs( FunctionDecl* );
     
    107108                        acceptAll( translationUnit, impl );
    108109                }
     110
     111          private:
     112                StructDecl* monitor_decl = nullptr;
    109113        };
    110114
     
    133137                if( ! body ) return;
    134138
     139                assert(monitor_decl);
    135140                addStatments( body, mutexArgs );
     141        }
     142
     143        void MutexKeyword::visit(StructDecl* decl) {
     144                if( decl->get_name() == "monitor_desc" ) {
     145                        assert( !monitor_decl );
     146                        monitor_decl = decl;
     147                }
    136148        }
    137149
     
    167179
    168180        void MutexKeyword::addStatments( CompoundStmt * body, const std::list<DeclarationWithType * > & args ) {
     181
     182                ObjectDecl * monitors = new ObjectDecl(
     183                        "__monitors",
     184                        noStorage,
     185                        LinkageSpec::Cforall,
     186                        nullptr,
     187                        new ArrayType(
     188                                noQualifiers,
     189                                new PointerType(
     190                                        noQualifiers,
     191                                        new StructInstType(
     192                                                noQualifiers,
     193                                                monitor_decl
     194                                        )
     195                                ),
     196                                new ConstantExpr( Constant::from_ulong( args.size() ) ),
     197                                false,
     198                                false
     199                        ),
     200                        new ListInit(
     201                                map_range < std::list<Initializer*> > ( args, [](DeclarationWithType * var ){
     202                                        return new SingleInit( new UntypedExpr(
     203                                                new NameExpr( "get_monitor" ),
     204                                                {  new VariableExpr( var ) }
     205                                        ) );
     206                                })
     207                        )
     208                );
     209
    169210                //in reverse order :
    170211                // monitor_guard_t __guard = { __monitors, # };
     
    181222                                new ListInit(
    182223                                        {
    183                                                 new SingleInit( new NameExpr( "__monitors" ) ),
     224                                                new SingleInit( new VariableExpr( monitors ) ),
    184225                                                new SingleInit( new ConstantExpr( Constant::from_ulong( args.size() ) ) )
    185226                                        }
     
    189230
    190231                //monitor_desc * __monitors[] = { a, b };
    191                 body->push_front(
    192                         new DeclStmt( noLabels, new ObjectDecl(
    193                                 "__monitors",
    194                                 noStorage,
    195                                 LinkageSpec::Cforall,
    196                                 nullptr,
    197                                 new ArrayType(
    198                                         noQualifiers,
    199                                         new PointerType(
    200                                                 noQualifiers,
    201                                                 new StructInstType(
    202                                                         noQualifiers,
    203                                                         "monitor_desc"
    204                                                 )
    205                                         ),
    206                                         new ConstantExpr( Constant::from_ulong( args.size() ) ),
    207                                         false,
    208                                         false
    209                                 ),
    210                                 new ListInit(
    211                                         map_range < std::list<Initializer*> > ( args, [](DeclarationWithType * var ){
    212                                                 return new SingleInit( new VariableExpr( var ) );
    213                                         })
    214                                 )
    215                         ))
    216                 );
     232                body->push_front( new DeclStmt( noLabels, monitors) );
    217233        }
    218234};
  • src/GenPoly/Box.cc

    r2f26687 r1fbab5a  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Mar 14 07:45:29 2017
    13 // Update Count     : 334
     12// Last Modified On : Thu Mar 16 08:35:33 2017
     13// Update Count     : 338
    1414//
    1515
     
    289289                        TypeInstType paramType( Type::Qualifiers(), (*param)->get_name(), *param );
    290290                        std::string paramName = mangleType( &paramType );
    291                         layoutFnType->get_parameters().push_back( new ObjectDecl( sizeofName( paramName ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) );
    292                         layoutFnType->get_parameters().push_back( new ObjectDecl( alignofName( paramName ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) );
     291                        layoutFnType->get_parameters().push_back( new ObjectDecl( sizeofName( paramName ), Type::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) );
     292                        layoutFnType->get_parameters().push_back( new ObjectDecl( alignofName( paramName ), Type::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) );
    293293                }
    294294        }
     
    299299                // because each unit generates copies of the default routines for each aggregate.
    300300                FunctionDecl *layoutDecl = new FunctionDecl( layoutofName( typeDecl ),
    301                                                                                                          functionNesting > 0 ? DeclarationNode::StorageClasses() : DeclarationNode::StorageClasses( DeclarationNode::Static ),
     301                                                                                                         functionNesting > 0 ? Type::StorageClasses() : Type::StorageClasses( Type::Static ),
    302302                                                                                                         LinkageSpec::AutoGen, layoutFnType, new CompoundStmt( noLabels ),
    303                                                                                                          std::list< Attribute * >(), DeclarationNode::FuncSpecifiers( DeclarationNode::Inline ) );
     303                                                                                                         std::list< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) );
    304304                layoutDecl->fixUniqueId();
    305305                return layoutDecl;
     
    368368                PointerType *sizeAlignOutType = new PointerType( Type::Qualifiers(), sizeAlignType );
    369369
    370                 ObjectDecl *sizeParam = new ObjectDecl( sizeofName( structDecl->get_name() ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
     370                ObjectDecl *sizeParam = new ObjectDecl( sizeofName( structDecl->get_name() ), Type::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
    371371                layoutFnType->get_parameters().push_back( sizeParam );
    372                 ObjectDecl *alignParam = new ObjectDecl( alignofName( structDecl->get_name() ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
     372                ObjectDecl *alignParam = new ObjectDecl( alignofName( structDecl->get_name() ), Type::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
    373373                layoutFnType->get_parameters().push_back( alignParam );
    374                 ObjectDecl *offsetParam = new ObjectDecl( offsetofName( structDecl->get_name() ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
     374                ObjectDecl *offsetParam = new ObjectDecl( offsetofName( structDecl->get_name() ), Type::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
    375375                layoutFnType->get_parameters().push_back( offsetParam );
    376376                addOtypeParams( layoutFnType, otypeParams );
     
    381381                // calculate struct layout in function body
    382382
    383                 // initialize size and alignment to 0 and 1 (will have at least one member to re-edit size
     383                // initialize size and alignment to 0 and 1 (will have at least one member to re-edit size)
    384384                addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( sizeParam ), new ConstantExpr( Constant( sizeAlignType->clone(), "0" ) ) ) );
    385385                addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( alignParam ), new ConstantExpr( Constant( sizeAlignType->clone(), "1" ) ) ) );
     
    429429                PointerType *sizeAlignOutType = new PointerType( Type::Qualifiers(), sizeAlignType );
    430430
    431                 ObjectDecl *sizeParam = new ObjectDecl( sizeofName( unionDecl->get_name() ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
     431                ObjectDecl *sizeParam = new ObjectDecl( sizeofName( unionDecl->get_name() ), Type::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
    432432                layoutFnType->get_parameters().push_back( sizeParam );
    433                 ObjectDecl *alignParam = new ObjectDecl( alignofName( unionDecl->get_name() ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
     433                ObjectDecl *alignParam = new ObjectDecl( alignofName( unionDecl->get_name() ), Type::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
    434434                layoutFnType->get_parameters().push_back( alignParam );
    435435                addOtypeParams( layoutFnType, otypeParams );
     
    537537                                        if ( adapters.find( mangleName ) == adapters.end() ) {
    538538                                                std::string adapterName = makeAdapterName( mangleName );
    539                                                 adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, new ObjectDecl( adapterName, DeclarationNode::StorageClasses(), LinkageSpec::C, nullptr, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), nullptr ) ) );
     539                                                adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, new ObjectDecl( adapterName, Type::StorageClasses(), LinkageSpec::C, nullptr, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), nullptr ) ) );
    540540                                        } // if
    541541                                } // for
     
    656656
    657657                ObjectDecl *Pass1::makeTemporary( Type *type ) {
    658                         ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, 0, type, 0 );
     658                        ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, type, 0 );
    659659                        stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
    660660                        return newObj;
     
    765765                                        Type * newType = param->clone();
    766766                                        if ( env ) env->apply( newType );
    767                                         ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, 0, newType, 0 );
     767                                        ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, newType, 0 );
    768768                                        newObj->get_type()->get_qualifiers() = Type::Qualifiers(); // TODO: is this right???
    769769                                        stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
     
    831831                                makeRetParm( adapter );
    832832                        } // if
    833                         adapter->get_parameters().push_front( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 ) );
     833                        adapter->get_parameters().push_front( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 ) );
    834834                        return adapter;
    835835                }
     
    912912                        adapterBody->get_kids().push_back( bodyStmt );
    913913                        std::string adapterName = makeAdapterName( mangleName );
    914                         return new FunctionDecl( adapterName, DeclarationNode::StorageClasses(), LinkageSpec::C, adapterType, adapterBody );
     914                        return new FunctionDecl( adapterName, Type::StorageClasses(), LinkageSpec::C, adapterType, adapterBody );
    915915                }
    916916
     
    12731273                                if ( adaptersDone.find( mangleName ) == adaptersDone.end() ) {
    12741274                                        std::string adapterName = makeAdapterName( mangleName );
    1275                                         paramList.push_front( new ObjectDecl( adapterName, DeclarationNode::StorageClasses(), LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), 0 ) );
     1275                                        paramList.push_front( new ObjectDecl( adapterName, Type::StorageClasses(), LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), 0 ) );
    12761276                                        adaptersDone.insert( adaptersDone.begin(), mangleName );
    12771277                                }
     
    13791379                        std::list< DeclarationWithType *>::iterator last = funcType->get_parameters().begin();
    13801380                        std::list< DeclarationWithType *> inferredParams;
    1381                         ObjectDecl newObj( "", DeclarationNode::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0 );
    1382                         ObjectDecl newPtr( "", DeclarationNode::StorageClasses(), LinkageSpec::C, 0,
     1381                        ObjectDecl newObj( "", Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0 );
     1382                        ObjectDecl newPtr( "", Type::StorageClasses(), LinkageSpec::C, 0,
    13831383                                           new PointerType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) ), 0 );
    13841384                        for ( Type::ForallList::const_iterator tyParm = funcType->get_forall().begin(); tyParm != funcType->get_forall().end(); ++tyParm ) {
     
    16341634
    16351635                ObjectDecl *PolyGenericCalculator::makeVar( const std::string &name, Type *type, Initializer *init ) {
    1636                         ObjectDecl *newObj = new ObjectDecl( name, DeclarationNode::StorageClasses(), LinkageSpec::C, 0, type, init );
     1636                        ObjectDecl *newObj = new ObjectDecl( name, Type::StorageClasses(), LinkageSpec::C, 0, type, init );
    16371637                        stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
    16381638                        return newObj;
     
    18181818                                                        memberDecl = origMember->clone();
    18191819                                                } else {
    1820                                                         memberDecl = new ObjectDecl( (*member)->get_name(), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, offsetType->clone(), 0 );
     1820                                                        memberDecl = new ObjectDecl( (*member)->get_name(), Type::StorageClasses(), LinkageSpec::Cforall, 0, offsetType->clone(), 0 );
    18211821                                                }
    18221822                                                inits.push_back( new SingleInit( new OffsetofExpr( ty->clone(), memberDecl ) ) );
     
    18521852
    18531853                        DeclClass *ret = static_cast< DeclClass *>( Mutator::mutate( decl ) );
    1854                         ScrubTyVars::scrub( decl, scopeTyVars );
     1854                        // ScrubTyVars::scrub( decl, scopeTyVars );
     1855                        ScrubTyVars::scrubAll( decl );
    18551856
    18561857                        scopeTyVars.endScope();
  • src/GenPoly/GenPoly.cc

    r2f26687 r1fbab5a  
    1515
    1616#include "GenPoly.h"
     17#include "assert.h"
    1718
    1819#include "SynTree/Expression.h"
    1920#include "SynTree/Type.h"
     21#include "ResolvExpr/typeops.h"
    2022
    2123#include <iostream>
     24#include <iterator>
     25#include <list>
     26#include <typeindex>
     27#include <typeinfo>
     28#include <vector>
    2229using namespace std;
    2330
     
    3845                        for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
    3946                                TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
    40                                 assert(paramType && "Aggregate parameters should be type expressions");
     47                                assertf(paramType, "Aggregate parameters should be type expressions");
    4148                                if ( isPolyType( paramType->get_type(), tyVars, env ) ) return true;
    4249                        }
     
    4855                        for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
    4956                                TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
    50                                 assert(paramType && "Aggregate parameters should be type expressions");
     57                                assertf(paramType, "Aggregate parameters should be type expressions");
    5158                                if ( isDynType( paramType->get_type(), tyVars, env ) ) return true;
     59                        }
     60                        return false;
     61                }
     62
     63                /// Checks a parameter list for inclusion of polymorphic parameters; will substitute according to env if present
     64                bool includesPolyParams( std::list< Expression* >& params, const TypeSubstitution *env ) {
     65                        for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
     66                                TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
     67                                assertf(paramType, "Aggregate parameters should be type expressions");
     68                                if ( includesPolyType( paramType->get_type(), env ) ) return true;
     69                        }
     70                        return false;
     71                }
     72
     73                /// Checks a parameter list for inclusion of polymorphic parameters from tyVars; will substitute according to env if present
     74                bool includesPolyParams( std::list< Expression* >& params, const TyVarMap &tyVars, const TypeSubstitution *env ) {
     75                        for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
     76                                TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
     77                                assertf(paramType, "Aggregate parameters should be type expressions");
     78                                if ( includesPolyType( paramType->get_type(), tyVars, env ) ) return true;
    5279                        }
    5380                        return false;
     
    187214
    188215                return isPolyType( type, tyVars, env );
     216        }
     217
     218        bool includesPolyType( Type *type, const TypeSubstitution *env ) {
     219                type = replaceTypeInst( type, env );
     220
     221                if ( dynamic_cast< TypeInstType * >( type ) ) {
     222                        return true;
     223                } else if ( PointerType *pointerType = dynamic_cast< PointerType* >( type ) ) {
     224                        if ( includesPolyType( pointerType->get_base(), env ) ) return true;
     225                } else if ( StructInstType *structType = dynamic_cast< StructInstType* >( type ) ) {
     226                        if ( includesPolyParams( structType->get_parameters(), env ) ) return true;
     227                } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( type ) ) {
     228                        if ( includesPolyParams( unionType->get_parameters(), env ) ) return true;
     229                }
     230                return false;
     231        }
     232
     233        bool includesPolyType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env ) {
     234                type = replaceTypeInst( type, env );
     235
     236                if ( TypeInstType *typeInstType = dynamic_cast< TypeInstType * >( type ) ) {
     237                        if ( tyVars.find( typeInstType->get_name() ) != tyVars.end() ) {
     238                                return true;
     239                        }
     240                } else if ( PointerType *pointerType = dynamic_cast< PointerType* >( type ) ) {
     241                        if ( includesPolyType( pointerType->get_base(), tyVars, env ) ) return true;
     242                } else if ( StructInstType *structType = dynamic_cast< StructInstType* >( type ) ) {
     243                        if ( includesPolyParams( structType->get_parameters(), tyVars, env ) ) return true;
     244                } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( type ) ) {
     245                        if ( includesPolyParams( unionType->get_parameters(), tyVars, env ) ) return true;
     246                }
     247                return false;
    189248        }
    190249
     
    237296        }
    238297
     298        namespace {
     299                /// Checks if is a pointer to D
     300                template<typename D, typename B>
     301                bool is( const B* p ) { return type_index{typeid(D)} == type_index{typeid(*p)}; }
     302
     303                /// Converts to a pointer to D without checking for safety
     304                template<typename D, typename B>
     305                inline D* as( B* p ) { return reinterpret_cast<D*>(p); }
     306
     307                /// Flattens a declaration list
     308                template<typename Output>
     309                void flattenList( list< DeclarationWithType* > src, Output out ) {
     310                        for ( DeclarationWithType* decl : src ) {
     311                                ResolvExpr::flatten( decl->get_type(), out );
     312                        }
     313                }
     314
     315                /// Flattens a list of types
     316                template<typename Output>
     317                void flattenList( list< Type* > src, Output out ) {
     318                        for ( Type* ty : src ) {
     319                                ResolvExpr::flatten( ty, out );
     320                        }
     321                }
     322
     323                /// Checks if two lists of parameters are equal up to polymorphic substitution.
     324                bool paramListsPolyCompatible( const list< Expression* >& aparams, const list< Expression* >& bparams ) {
     325                        if ( aparams.size() != bparams.size() ) return false;
     326
     327                        for ( list< Expression* >::const_iterator at = aparams.begin(), bt = bparams.begin();
     328                                        at != aparams.end(); ++at, ++bt ) {
     329                                TypeExpr *aparam = dynamic_cast< TypeExpr* >(*at);
     330                                assertf(aparam, "Aggregate parameters should be type expressions");
     331                                TypeExpr *bparam = dynamic_cast< TypeExpr* >(*bt);
     332                                assertf(bparam, "Aggregate parameters should be type expressions");
     333
     334                                // xxx - might need to let VoidType be a wildcard here too; could have some voids
     335                                // stuffed in for dtype-statics.
     336                                // if ( is<VoidType>( aparam->get_type() ) || is<VoidType>( bparam->get_type() ) ) continue;
     337                                if ( ! typesPolyCompatible( aparam->get_type(), bparam->get_type() ) ) return false;
     338                        }
     339                       
     340                        return true;
     341                }
     342        }
     343
     344        bool typesPolyCompatible( Type *a, Type *b ) {
     345                type_index aid{ typeid(*a) };
     346                // polymorphic types always match
     347                if ( aid == type_index{typeid(TypeInstType)} ) return true;
     348               
     349                type_index bid{ typeid(*b) };
     350                // polymorphic types always match
     351                if ( bid == type_index{typeid(TypeInstType)} ) return true;
     352               
     353                // can't match otherwise if different types
     354                if ( aid != bid ) return false;
     355
     356                // recurse through type structure (conditions borrowed from Unify.cc)
     357                if ( aid == type_index{typeid(BasicType)} ) {
     358                        return as<BasicType>(a)->get_kind() == as<BasicType>(b)->get_kind();
     359                } else if ( aid == type_index{typeid(PointerType)} ) {
     360                        PointerType *ap = as<PointerType>(a), *bp = as<PointerType>(b);
     361
     362                        // void pointers should match any other pointer type
     363                        return is<VoidType>( ap->get_base() ) || is<VoidType>( bp->get_base() )
     364                                || typesPolyCompatible( ap->get_base(), bp->get_base() );
     365                } else if ( aid == type_index{typeid(ArrayType)} ) {
     366                        ArrayType *aa = as<ArrayType>(a), *ba = as<ArrayType>(b);
     367
     368                        if ( aa->get_isVarLen() ) {
     369                                if ( ! ba->get_isVarLen() ) return false;
     370                        } else {
     371                                if ( ba->get_isVarLen() ) return false;
     372
     373                                ConstantExpr *ad = dynamic_cast<ConstantExpr*>( aa->get_dimension() );
     374                                ConstantExpr *bd = dynamic_cast<ConstantExpr*>( ba->get_dimension() );
     375                                if ( ad && bd
     376                                                && ad->get_constant()->get_value() != bd->get_constant()->get_value() )
     377                                        return false;
     378                        }
     379
     380                        return typesPolyCompatible( aa->get_base(), ba->get_base() );
     381                } else if ( aid == type_index{typeid(FunctionType)} ) {
     382                        FunctionType *af = as<FunctionType>(a), *bf = as<FunctionType>(b);
     383
     384                        vector<Type*> aparams, bparams;
     385                        flattenList( af->get_parameters(), back_inserter( aparams ) );
     386                        flattenList( bf->get_parameters(), back_inserter( bparams ) );
     387                        if ( aparams.size() != bparams.size() ) return false;
     388
     389                        vector<Type*> areturns, breturns;
     390                        flattenList( af->get_returnVals(), back_inserter( areturns ) );
     391                        flattenList( bf->get_returnVals(), back_inserter( breturns ) );
     392                        if ( areturns.size() != breturns.size() ) return false;
     393
     394                        for ( unsigned i = 0; i < aparams.size(); ++i ) {
     395                                if ( ! typesPolyCompatible( aparams[i], bparams[i] ) ) return false;
     396                        }
     397                        for ( unsigned i = 0; i < areturns.size(); ++i ) {
     398                                if ( ! typesPolyCompatible( areturns[i], breturns[i] ) ) return false;
     399                        }
     400                        return true;
     401                } else if ( aid == type_index{typeid(StructInstType)} ) {
     402                        StructInstType *aa = as<StructInstType>(a), *ba = as<StructInstType>(b);
     403
     404                        if ( aa->get_name() != ba->get_name() ) return false;
     405                        return paramListsPolyCompatible( aa->get_parameters(), ba->get_parameters() );
     406                } else if ( aid == type_index{typeid(UnionInstType)} ) {
     407                        UnionInstType *aa = as<UnionInstType>(a), *ba = as<UnionInstType>(b);
     408
     409                        if ( aa->get_name() != ba->get_name() ) return false;
     410                        return paramListsPolyCompatible( aa->get_parameters(), ba->get_parameters() );
     411                } else if ( aid == type_index{typeid(EnumInstType)} ) {
     412                        return as<EnumInstType>(a)->get_name() == as<EnumInstType>(b)->get_name();
     413                } else if ( aid == type_index{typeid(TraitInstType)} ) {
     414                        return as<TraitInstType>(a)->get_name() == as<TraitInstType>(b)->get_name();
     415                } else if ( aid == type_index{typeid(TupleType)} ) {
     416                        TupleType *at = as<TupleType>(a), *bt = as<TupleType>(b);
     417
     418                        vector<Type*> atypes, btypes;
     419                        flattenList( at->get_types(), back_inserter( atypes ) );
     420                        flattenList( bt->get_types(), back_inserter( btypes ) );
     421                        if ( atypes.size() != btypes.size() ) return false;
     422
     423                        for ( unsigned i = 0; i < atypes.size(); ++i ) {
     424                                if ( ! typesPolyCompatible( atypes[i], btypes[i] ) ) return false;
     425                        }
     426                        return true;
     427                } else return true; // VoidType, VarArgsType, ZeroType & OneType just need the same type
     428        }
     429
    239430        void addToTyVarMap( TypeDecl * tyVar, TyVarMap &tyVarMap ) {
    240431                tyVarMap[ tyVar->get_name() ] = TypeDecl::Data{ tyVar };
  • src/GenPoly/GenPoly.h

    r2f26687 r1fbab5a  
    6767        Type *hasPolyBase( Type *type, const TyVarMap &tyVars, int *levels = 0, const TypeSubstitution *env = 0 );
    6868
     69        /// true iff this type or some base of this type after dereferencing pointers is either polymorphic or a generic type with at least one
     70        /// polymorphic parameter; will look up substitution in env if provided.
     71        bool includesPolyType( Type *type, const TypeSubstitution *env = 0 );
     72
     73        /// true iff this type or some base of this type after dereferencing pointers is either polymorphic in tyVars, or a generic type with
     74        /// at least one polymorphic parameter in tyVars; will look up substitution in env if provided.
     75        bool includesPolyType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env = 0 );
     76
    6977        /// Returns a pointer to the base FunctionType if ty is the type of a function (or pointer to one), NULL otherwise
    7078        FunctionType *getFunctionType( Type *ty );
     
    7381        /// N will be stored in levels, if provided
    7482        VariableExpr *getBaseVar( Expression *expr, int *levels = 0 );
     83
     84        /// true iff types are structurally identical, where TypeInstType's match any type.
     85        bool typesPolyCompatible( Type *aty, Type *bty );
    7586
    7687        /// Adds the type variable `tyVar` to `tyVarMap`
  • src/GenPoly/InstantiateGeneric.cc

    r2f26687 r1fbab5a  
    1616#include <cassert>
    1717#include <list>
     18#include <unordered_map>
    1819#include <utility>
    1920#include <vector>
    20 #include <unordered_map>
    2121
    2222#include "InstantiateGeneric.h"
     
    2525#include "GenPoly.h"
    2626#include "ScopedSet.h"
     27#include "ScrubTyVars.h"
    2728#include "PolyMutator.h"
    2829
     
    7778                        if ( params.size() != that.params.size() ) return false;
    7879
    79                         SymTab::Indexer dummy;
    8080                        for ( std::list< Type* >::const_iterator it = params.begin(), jt = that.params.begin(); it != params.end(); ++it, ++jt ) {
    81                                 if ( ! ResolvExpr::typesCompatible( *it, *jt, dummy ) ) return false;
     81                                if ( ! typesPolyCompatible( *it, *jt ) ) return false;
    8282                        }
    8383                        return true;
     
    227227                        if ( (*baseParam)->isComplete() ) {
    228228                                // substitute parameter for complete (otype or sized dtype) type
    229                                 int pointerLevels = 0;
    230                                 if ( hasPolyBase( paramType->get_type(), &pointerLevels ) && pointerLevels > 0 ) {
    231                                         // Make a void* with equivalent nesting
    232                                         Type* voidPtr = new VoidType( Type::Qualifiers() );
    233                                         while ( pointerLevels > 0 ) {
    234                                                 // Just about data layout, so qualifiers *shouldn't* matter
    235                                                 voidPtr = new PointerType( Type::Qualifiers(), voidPtr );
    236                                                 --pointerLevels;
    237                                         }
    238                                         out.push_back( new TypeExpr( voidPtr ) );
     229                                if ( isPolyType( paramType->get_type() ) ) {
     230                                        // substitute polymorphic parameter type in to generic type
     231                                        out.push_back( paramType->clone() );
     232                                        gt = genericType::dynamic;
    239233                                } else {
    240                                         // Just clone parameter type
    241                                         out.push_back( paramType->clone() );
     234                                        // normalize possibly dtype-static parameter type
     235                                        out.push_back( new TypeExpr{
     236                                                ScrubTyVars::scrubAll( paramType->get_type()->clone() ) } );
     237                                        gt |= genericType::concrete;
    242238                                }
    243                                 // make the struct concrete or dynamic depending on the parameter
    244                                 gt |= isPolyType( paramType->get_type() ) ? genericType::dynamic : genericType::concrete;
    245239                        } else switch ( (*baseParam)->get_kind() ) {
    246240                                case TypeDecl::Dtype:
     
    372366                                concDecl = new StructDecl( typeNamer.newName( inst->get_name() ) );
    373367                                concDecl->set_body( inst->get_baseStruct()->has_body() );
    374                                 substituteMembers( inst->get_baseStruct()->get_members(), *inst->get_baseParameters(), typeSubs,        concDecl->get_members() );
     368                                substituteMembers( inst->get_baseStruct()->get_members(), *inst->get_baseParameters(), typeSubs, concDecl->get_members() );
    375369                                DeclMutator::addDeclaration( concDecl );
    376370                                insert( inst, typeSubs, concDecl );
  • src/GenPoly/ScrubTyVars.cc

    r2f26687 r1fbab5a  
    2626namespace GenPoly {
    2727        Type * ScrubTyVars::mutate( TypeInstType *typeInst ) {
    28                 TyVarMap::const_iterator tyVar = tyVars.find( typeInst->get_name() );
    29                 if ( tyVar != tyVars.end() ) {
     28                if ( ! tyVars ) {
     29                        if ( typeInst->get_isFtype() ) {
     30                                delete typeInst;
     31                                return new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) );
     32                        } else {
     33                                PointerType *ret = new PointerType( Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) );
     34                                delete typeInst;
     35                                return ret;
     36                        }
     37                }
     38
     39                TyVarMap::const_iterator tyVar = tyVars->find( typeInst->get_name() );
     40                if ( tyVar != tyVars->end() ) {
    3041                        switch ( tyVar->second.kind ) {
    3142                          case TypeDecl::Any:
  • src/GenPoly/ScrubTyVars.h

    r2f26687 r1fbab5a  
    2626namespace GenPoly {
    2727        class ScrubTyVars : public Mutator {
    28           public:
    29                 ScrubTyVars( const TyVarMap &tyVars, bool dynamicOnly = false ): tyVars( tyVars ), dynamicOnly( dynamicOnly ) {}
     28                /// Whether to scrub all type variables from the provided map, dynamic type variables from the provided map, or all type variables
     29                enum ScrubMode { FromMap, DynamicFromMap, All };
    3030
     31                ScrubTyVars() : tyVars(nullptr), mode( All ) {}
     32
     33                ScrubTyVars( const TyVarMap &tyVars, ScrubMode mode = FromMap ): tyVars( &tyVars ), mode( mode ) {}
     34
     35        public:
    3136                /// For all polymorphic types with type variables in `tyVars`, replaces generic types, dtypes, and ftypes with the appropriate void type,
    3237                /// and sizeof/alignof expressions with the proper variable
     
    3843                template< typename SynTreeClass >
    3944                static SynTreeClass *scrubDynamic( SynTreeClass *target, const TyVarMap &tyVars );
     45
     46                /// For all polymorphic types, replaces generic types, dtypes, and ftypes with the appropriate void type,
     47                /// and sizeof/alignof expressions with the proper variable
     48                template< typename SynTreeClass >
     49                static SynTreeClass *scrubAll( SynTreeClass *target );
    4050
    4151                virtual Type* mutate( TypeInstType *typeInst );
     
    4959                /// Returns the type if it should be scrubbed, NULL otherwise.
    5060                Type* shouldScrub( Type *ty ) {
    51                         return dynamicOnly ? isDynType( ty, tyVars ) : isPolyType( ty, tyVars );
    52 //                      if ( ! dynamicOnly ) return isPolyType( ty, tyVars );
    53 //
    54 //                      if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( ty ) ) {
    55 //                              return tyVars.find( typeInst->get_name() ) != tyVars.end() ? ty : 0;
    56 //                      }
    57 //
    58 //                      return isDynType( ty, tyVars );
     61                        switch ( mode ) {
     62                        case FromMap: return isPolyType( ty, *tyVars );
     63                        case DynamicFromMap: return isDynType( ty, *tyVars );
     64                        case All: return isPolyType( ty );
     65                        }
     66                        assert(false); return nullptr; // unreachable
     67                        // return dynamicOnly ? isDynType( ty, tyVars ) : isPolyType( ty, tyVars );
    5968                }
    6069               
     
    6271                Type* mutateAggregateType( Type *ty );
    6372               
    64                 const TyVarMap &tyVars;  ///< Type variables to scrub
    65                 bool dynamicOnly;        ///< only scrub the types with dynamic layout? [false]
     73                const TyVarMap *tyVars;  ///< Type variables to scrub
     74                ScrubMode mode;          ///< which type variables to scrub? [FromMap]
    6675        };
    6776
     
    7483        template< typename SynTreeClass >
    7584        SynTreeClass * ScrubTyVars::scrubDynamic( SynTreeClass *target, const TyVarMap &tyVars ) {
    76                 ScrubTyVars scrubber( tyVars, true );
     85                ScrubTyVars scrubber( tyVars, ScrubTyVars::DynamicFromMap );
     86                return static_cast< SynTreeClass * >( target->acceptMutator( scrubber ) );
     87        }
     88
     89        template< typename SynTreeClass >
     90        SynTreeClass * ScrubTyVars::scrubAll( SynTreeClass *target ) {
     91                ScrubTyVars scrubber;
    7792                return static_cast< SynTreeClass * >( target->acceptMutator( scrubber ) );
    7893        }
  • src/GenPoly/Specialize.cc

    r2f26687 r1fbab5a  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Mar  6 23:13:00 2017
    13 // Update Count     : 30
     12// Last Modified On : Thu Mar 16 07:53:59 2017
     13// Update Count     : 31
    1414//
    1515
     
    179179                } // if
    180180                // create new thunk with same signature as formal type (C linkage, empty body)
    181                 FunctionDecl *thunkFunc = new FunctionDecl( thunkNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, newType, new CompoundStmt( noLabels ) );
     181                FunctionDecl *thunkFunc = new FunctionDecl( thunkNamer.newName(), Type::StorageClasses(), LinkageSpec::C, newType, new CompoundStmt( noLabels ) );
    182182                thunkFunc->fixUniqueId();
    183183
  • src/InitTweak/FixGlobalInit.cc

    r2f26687 r1fbab5a  
    1010// Created On       : Mon May 04 15:14:56 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Mar 13 23:58:27 2017
    13 // Update Count     : 16
     12// Last Modified On : Thu Mar 16 07:53:11 2017
     13// Update Count     : 18
    1414//
    1515
     
    8787                        dtorParameters.push_back( new ConstantExpr( Constant::from_int( 102 ) ) );
    8888                }
    89                 initFunction = new FunctionDecl( "_init_" + fixedName, DeclarationNode::StorageClasses( DeclarationNode::Static ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
     89                initFunction = new FunctionDecl( "_init_" + fixedName, Type::StorageClasses( Type::Static ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
    9090                initFunction->get_attributes().push_back( new Attribute( "constructor", ctorParameters ) );
    91                 destroyFunction = new FunctionDecl( "_destroy_" + fixedName, DeclarationNode::StorageClasses( DeclarationNode::Static ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
     91                destroyFunction = new FunctionDecl( "_destroy_" + fixedName, Type::StorageClasses( Type::Static ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
    9292                destroyFunction->get_attributes().push_back( new Attribute( "destructor", dtorParameters ) );
    9393        }
  • src/InitTweak/FixInit.cc

    r2f26687 r1fbab5a  
    1010// Created On       : Wed Jan 13 16:29:30 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Mar 14 08:05:28 2017
    13 // Update Count     : 63
     12// Last Modified On : Thu Mar 16 08:08:04 2017
     13// Update Count     : 67
    1414//
    1515
     
    437437                        result = result->clone();
    438438                        env->apply( result );
    439                         ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, 0, result, 0 );
     439                        ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, result, 0 );
    440440                        tmp->get_type()->set_isConst( false );
    441441
     
    483483                                result = result->clone();
    484484                                env->apply( result );
    485                                 ObjectDecl * ret = new ObjectDecl( retNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, 0, result, 0 );
     485                                ObjectDecl * ret = new ObjectDecl( retNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, result, 0 );
    486486                                ret->get_type()->set_isConst( false );
    487487                                impCpCtorExpr->get_returnDecls().push_back( ret );
     
    506506                                result = result->clone();
    507507                                env->apply( result );
    508                                 ObjectDecl * ret = new ObjectDecl( retNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, 0, result, 0 );
     508                                ObjectDecl * ret = new ObjectDecl( retNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, result, 0 );
    509509                                ret->get_type()->set_isConst( false );
    510510                                stmtExpr->get_returnDecls().push_front( ret );
     
    538538                        } else {
    539539                                // expr isn't a call expr, so create a new temporary variable to use to hold the value of the unique expression
    540                                 unqExpr->set_object( new ObjectDecl( toString("_unq_expr_", unqExpr->get_id()), DeclarationNode::StorageClasses(), LinkageSpec::C, nullptr, unqExpr->get_result()->clone(), nullptr ) );
     540                                unqExpr->set_object( new ObjectDecl( toString("_unq_expr_", unqExpr->get_id()), Type::StorageClasses(), LinkageSpec::C, nullptr, unqExpr->get_result()->clone(), nullptr ) );
    541541                                unqExpr->set_var( new VariableExpr( unqExpr->get_object() ) );
    542542                        }
     
    704704                                                BasicType * boolType = new BasicType( Type::Qualifiers(), BasicType::Bool );
    705705                                                SingleInit * boolInitExpr = new SingleInit( new ConstantExpr( Constant( boolType->clone(), "1" ) ), noDesignators );
    706                                                 ObjectDecl * isUninitializedVar = new ObjectDecl( objDecl->get_mangleName() + "_uninitialized", DeclarationNode::StorageClasses( DeclarationNode::Static ), LinkageSpec::Cforall, 0, boolType, boolInitExpr );
     706                                                ObjectDecl * isUninitializedVar = new ObjectDecl( objDecl->get_mangleName() + "_uninitialized", Type::StorageClasses( Type::Static ), LinkageSpec::Cforall, 0, boolType, boolInitExpr );
    707707                                                isUninitializedVar->fixUniqueId();
    708708
     
    731731
    732732                                                        // void __objName_dtor_atexitN(...) {...}
    733                                                         FunctionDecl * dtorCaller = new FunctionDecl( objDecl->get_mangleName() + dtorCallerNamer.newName(), DeclarationNode::StorageClasses( DeclarationNode::Static ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
     733                                                        FunctionDecl * dtorCaller = new FunctionDecl( objDecl->get_mangleName() + dtorCallerNamer.newName(), Type::StorageClasses( Type::Static ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
    734734                                                        dtorCaller->fixUniqueId();
    735735                                                        dtorCaller->get_statements()->push_back( dtorStmt );
     
    764764                                                        // create a new object which is never used
    765765                                                        static UniqueName dummyNamer( "_dummy" );
    766                                                         ObjectDecl * dummy = new ObjectDecl( dummyNamer.newName(), DeclarationNode::StorageClasses( DeclarationNode::Static ), LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ), 0, std::list< Attribute * >{ new Attribute("unused") } );
     766                                                        ObjectDecl * dummy = new ObjectDecl( dummyNamer.newName(), Type::StorageClasses( Type::Static ), LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ), 0, std::list< Attribute * >{ new Attribute("unused") } );
    767767                                                        return dummy;
    768768                                                }
     
    11181118
    11191119                        // xxx - ideally we would reuse the temporary generated from the copy constructor passes from within firstArg if it exists and not generate a temporary if it's unnecessary.
    1120                         ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, nullptr, ctorExpr->get_result()->clone(), nullptr );
     1120                        ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, nullptr, ctorExpr->get_result()->clone(), nullptr );
    11211121                        addDeclaration( tmp );
    11221122
  • src/InitTweak/GenInit.cc

    r2f26687 r1fbab5a  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Mar 13 23:59:09 2017
    13 // Update Count     : 180
     12// Last Modified On : Thu Mar 16 08:01:25 2017
     13// Update Count     : 181
    1414//
    1515
     
    120120                void hoist( Type * type );
    121121
    122                 DeclarationNode::StorageClasses storageClasses;
     122                Type::StorageClasses storageClasses;
    123123                bool inFunction = false;
    124124        };
  • src/Parser/DeclarationNode.cc

    r2f26687 r1fbab5a  
    1010// Created On       : Sat May 16 12:34:05 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Mar 14 10:19:38 2017
    13 // Update Count     : 964
     12// Last Modified On : Thu Mar 16 09:10:57 2017
     13// Update Count     : 1007
    1414//
    1515
     
    3333
    3434// These must remain in the same order as the corresponding DeclarationNode enumerations.
    35 const char * DeclarationNode::storageClassNames[] = { "extern", "static", "auto", "register", "_Thread_local", "NoStorageClassNames" };
    36 const char * DeclarationNode::funcSpecifierNames[] = { "inline", "fortran", "_Noreturn", "NoFunctionSpecifierNames" };
    37 const char * DeclarationNode::typeQualifierNames[] = { "const", "restrict", "volatile", "lvalue", "mutex", "_Atomic", "NoTypeQualifierNames" };
    3835const char * DeclarationNode::basicTypeNames[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "NoBasicTypeNames" };
    3936const char * DeclarationNode::complexTypeNames[] = { "_Complex", "_Imaginary", "NoComplexTypeNames" };
     
    116113}
    117114
    118 void DeclarationNode::print_StorageClass( std::ostream & output, StorageClasses storageClasses ) {
    119         if ( storageClasses.val != 0 ) {                                        // storage classes ?
    120                 for ( unsigned int i = 0; i < DeclarationNode::NoStorageClass; i += 1 ) {
    121                         if ( storageClasses[i] ) {
    122                                 output << DeclarationNode::storageClassNames[i] << ' ';
    123                         } // if
    124                 } // for
    125         } // if
    126 } // print_StorageClass
    127 
    128 void DeclarationNode::print_FuncSpec( std::ostream & output, DeclarationNode::FuncSpecifiers funcSpec ) {
    129         if ( funcSpec.val != 0 ) {                                                      // function specifiers ?
    130                 for ( unsigned int i = 0; i < DeclarationNode::NoFuncSpecifier; i += 1 ) {
    131                         if ( funcSpec[i] ) {
    132                                 output << DeclarationNode::funcSpecifierNames[i] << ' ';
    133                         } // if
    134                 } // for
    135         } // if
    136 } // print_FuncSpec
    137 
    138115void DeclarationNode::print( std::ostream &os, int indent ) const {
    139116        os << string( indent, ' ' );
     
    148125        } // if
    149126
    150         print_StorageClass( os, storageClasses );
    151         print_FuncSpec( os, funcSpecs );
     127        storageClasses.print( os );
     128        funcSpecs.print( os );
    152129
    153130        if ( type ) {
     
    202179
    203180
    204 DeclarationNode * DeclarationNode::newStorageClass( DeclarationNode::StorageClasses sc ) {
     181DeclarationNode * DeclarationNode::newStorageClass( Type::StorageClasses sc ) {
    205182        DeclarationNode * newnode = new DeclarationNode;
    206183        newnode->storageClasses = sc;
     
    208185} // DeclarationNode::newStorageClass
    209186
    210 DeclarationNode * DeclarationNode::newFuncSpecifier( DeclarationNode::FuncSpecifiers fs ) {
     187DeclarationNode * DeclarationNode::newFuncSpecifier( Type::FuncSpecifiers fs ) {
    211188        DeclarationNode * newnode = new DeclarationNode;
    212189        newnode->funcSpecs = fs;
     
    214191} // DeclarationNode::newFuncSpecifier
    215192
    216 DeclarationNode * DeclarationNode::newTypeQualifier( TypeQualifier tq ) {
     193DeclarationNode * DeclarationNode::newTypeQualifier( Type::Qualifiers tq ) {
    217194        DeclarationNode * newnode = new DeclarationNode;
    218195        newnode->type = new TypeData();
    219         newnode->type->typeQualifiers[ tq ] = true;
     196        newnode->type->qualifiers = tq;
    220197        return newnode;
    221198} // DeclarationNode::newQualifier
     
    457434
    458435void DeclarationNode::checkQualifiers( const TypeData * src, const TypeData * dst ) {
    459         const TypeData::TypeQualifiers qsrc = src->typeQualifiers, qdst = dst->typeQualifiers; // optimization
    460 
    461         if ( (qsrc & qdst).any() ) {                                            // duplicates ?
    462                 for ( unsigned int i = 0; i < NoTypeQualifier; i += 1 ) { // find duplicates
     436        const Type::Qualifiers qsrc = src->qualifiers, qdst = dst->qualifiers; // optimization
     437
     438        if ( (qsrc.val & qdst.val) != 0 ) {                                     // duplicates ?
     439                for ( unsigned int i = 0; i < Type::NumTypeQualifier; i += 1 ) { // find duplicates
    463440                        if ( qsrc[i] && qdst[i] ) {
    464                                 appendError( error, string( "duplicate " ) + DeclarationNode::typeQualifierNames[i] );
     441                                appendError( error, string( "duplicate " ) + Type::Qualifiers::Names[i] );
    465442                        } // if
    466443                } // for
     
    469446
    470447void DeclarationNode::checkSpecifiers( DeclarationNode * src ) {
    471         if ( (funcSpecs.val & src->funcSpecs.val) != 0 ) {                // duplicates ?
    472                 for ( unsigned int i = 0; i < NoFuncSpecifier; i += 1 ) { // find duplicates
     448        if ( (funcSpecs.val & src->funcSpecs.val) != 0 ) {      // duplicates ?
     449                for ( unsigned int i = 0; i < Type::NumFuncSpecifier; i += 1 ) { // find duplicates
    473450                        if ( funcSpecs[i] && src->funcSpecs[i] ) {
    474                                 appendError( error, string( "duplicate " ) + DeclarationNode::funcSpecifierNames[i] );
     451                                appendError( error, string( "duplicate " ) + Type::FuncSpecifiers::Names[i] );
    475452                        } // if
    476453                } // for
    477454        } // if
    478455
    479         if ( storageClasses.val != 0 && src->storageClasses.val != 0 ) { // any reason to check ?
     456        if ( storageClasses.any() && src->storageClasses.any() ) { // any reason to check ?
    480457                if ( (storageClasses.val & src->storageClasses.val ) != 0 ) { // duplicates ?
    481                         for ( unsigned int i = 0; i < NoStorageClass; i += 1 ) { // find duplicates
     458                        for ( unsigned int i = 0; i < Type::NumStorageClass; i += 1 ) { // find duplicates
    482459                                if ( storageClasses[i] && src->storageClasses[i] ) {
    483                                         appendError( error, string( "duplicate " ) + storageClassNames[i] );
     460                                        appendError( error, string( "duplicate " ) + Type::StorageClasses::Names[i] );
    484461                                } // if
    485462                        } // for
    486463                        // src is the new item being added and has a single bit
    487464                } else if ( ! src->storageClasses.is_threadlocal ) { // conflict ?
    488                         appendError( error, string( "conflicting " ) + storageClassNames[ffs( storageClasses.val ) - 1] +
    489                                                  " & " + storageClassNames[ffs( src->storageClasses.val ) - 1] );
     465                        appendError( error, string( "conflicting " ) + Type::StorageClasses::Names[ffs( storageClasses.val ) - 1] +
     466                                                 " & " + Type::StorageClasses::Names[ffs( src->storageClasses.val ) - 1] );
    490467                        src->storageClasses.val = 0;                            // FIX to preserve invariant of one basic storage specifier
    491468                } // if
     
    496473
    497474DeclarationNode * DeclarationNode::copySpecifiers( DeclarationNode * q ) {
    498         funcSpecs.val = funcSpecs.val | q->funcSpecs.val;
    499         storageClasses.val = storageClasses.val | q->storageClasses.val;
     475        funcSpecs.val |= q->funcSpecs.val;
     476        storageClasses.val |= q->storageClasses.val;
    500477
    501478        for ( Attribute *attr: reverseIterate( q->attributes ) ) {
     
    520497                src = nullptr;
    521498        } else {
    522                 dst->typeQualifiers |= src->typeQualifiers;
     499                dst->qualifiers += src->qualifiers;
    523500        } // if
    524501} // addQualifiersToType
     
    578555                switch ( dst->kind ) {
    579556                  case TypeData::Unknown:
    580                         src->typeQualifiers |= dst->typeQualifiers;
     557                        src->qualifiers += dst->qualifiers;
    581558                        dst = src;
    582559                        src = nullptr;
    583560                        break;
    584561                  case TypeData::Basic:
    585                         dst->typeQualifiers |= src->typeQualifiers;
     562                        dst->qualifiers += src->qualifiers;
    586563                        if ( src->kind != TypeData::Unknown ) {
    587564                                assert( src->kind == TypeData::Basic );
     
    619596                                        dst->base->aggInst.params = maybeClone( src->aggregate.actuals );
    620597                                } // if
    621                                 dst->base->typeQualifiers |= src->typeQualifiers;
     598                                dst->base->qualifiers += src->qualifiers;
    622599                                src = nullptr;
    623600                                break;
     
    651628                                                type->aggInst.hoistType = o->type->enumeration.body;
    652629                                        } // if
    653                                         type->typeQualifiers |= o->type->typeQualifiers;
     630                                        type->qualifiers += o->type->qualifiers;
    654631                                } else {
    655632                                        type = o->type;
     
    807784                                        p->type->base->aggInst.params = maybeClone( type->aggregate.actuals );
    808785                                } // if
    809                                 p->type->base->typeQualifiers |= type->typeQualifiers;
     786                                p->type->base->qualifiers += type->qualifiers;
    810787                                break;
    811788
     
    832809
    833810DeclarationNode * DeclarationNode::addNewArray( DeclarationNode * a ) {
    834         if ( a ) {
    835                 assert( a->type->kind == TypeData::Array );
    836                 TypeData * lastArray = findLast( a->type );
    837                 if ( type ) {
    838                         switch ( type->kind ) {
    839                           case TypeData::Aggregate:
    840                           case TypeData::Enum:
    841                                 lastArray->base = new TypeData( TypeData::AggregateInst );
    842                                 lastArray->base->aggInst.aggregate = type;
    843                                 if ( type->kind == TypeData::Aggregate ) {
    844                                         lastArray->base->aggInst.params = maybeClone( type->aggregate.actuals );
    845                                 } // if
    846                                 lastArray->base->typeQualifiers |= type->typeQualifiers;
    847                                 break;
    848                           default:
    849                                 lastArray->base = type;
    850                         } // switch
    851                         type = nullptr;
    852                 } // if
    853                 delete this;
    854                 return a;
    855         } else {
    856                 return this;
    857         } // if
     811  if ( ! a ) return this;
     812        assert( a->type->kind == TypeData::Array );
     813        TypeData * lastArray = findLast( a->type );
     814        if ( type ) {
     815                switch ( type->kind ) {
     816                  case TypeData::Aggregate:
     817                  case TypeData::Enum:
     818                        lastArray->base = new TypeData( TypeData::AggregateInst );
     819                        lastArray->base->aggInst.aggregate = type;
     820                        if ( type->kind == TypeData::Aggregate ) {
     821                                lastArray->base->aggInst.params = maybeClone( type->aggregate.actuals );
     822                        } // if
     823                        lastArray->base->qualifiers += type->qualifiers;
     824                        break;
     825                  default:
     826                        lastArray->base = type;
     827                } // switch
     828                type = nullptr;
     829        } // if
     830        delete this;
     831        return a;
    858832}
    859833
     
    994968                                } else if ( StructDecl * agg = dynamic_cast< StructDecl * >( decl ) ) {
    995969                                        StructInstType * inst = new StructInstType( Type::Qualifiers(), agg->get_name() );
    996                                         auto obj = new ObjectDecl( "", DeclarationNode::StorageClasses(), linkage, nullptr, inst, nullptr );
     970                                        auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
    997971                                        obj->location = cur->location;
    998972                                        * out++ = obj;
     
    1000974                                } else if ( UnionDecl * agg = dynamic_cast< UnionDecl * >( decl ) ) {
    1001975                                        UnionInstType * inst = new UnionInstType( Type::Qualifiers(), agg->get_name() );
    1002                                         auto obj = new ObjectDecl( "", DeclarationNode::StorageClasses(), linkage, nullptr, inst, nullptr );
     976                                        auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
    1003977                                        obj->location = cur->location;
    1004978                                        * out++ = obj;
     
    10471021                assertf( sizeof(kindMap)/sizeof(kindMap[0] == NoTypeClass-1), "DeclarationNode::build: kindMap is out of sync." );
    10481022                assertf( variable.tyClass < sizeof(kindMap)/sizeof(kindMap[0]), "Variable's tyClass is out of bounds." );
    1049                 TypeDecl * ret = new TypeDecl( *name, DeclarationNode::StorageClasses(), nullptr, kindMap[ variable.tyClass ] );
     1023                TypeDecl * ret = new TypeDecl( *name, Type::StorageClasses(), nullptr, kindMap[ variable.tyClass ] );
    10501024                buildList( variable.assertions, ret->get_assertions() );
    10511025                return ret;
     
    10581032                //    inline _Noreturn int g( int i );  // allowed
    10591033                //    inline _Noreturn int i;                   // disallowed
    1060                 if ( type->kind != TypeData::Function && funcSpecs.val != 0 ) {
     1034                if ( type->kind != TypeData::Function && funcSpecs.any() ) {
    10611035                        throw SemanticError( "invalid function specifier for ", this );
    10621036                } // if
     
    10681042        //    inlne _Noreturn struct S { ... };         // disallowed
    10691043        //    inlne _Noreturn enum   E { ... };         // disallowed
    1070         if ( funcSpecs.val != 0 ) {
     1044        if ( funcSpecs.any() ) {
    10711045                throw SemanticError( "invalid function specifier for ", this );
    10721046        } // if
  • src/Parser/ParseNode.h

    r2f26687 r1fbab5a  
    1010// Created On       : Sat May 16 13:28:16 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Mar 14 11:05:05 2017
    13 // Update Count     : 752
     12// Last Modified On : Thu Mar 16 08:32:43 2017
     13// Update Count     : 776
    1414//
    1515
     
    1919#include <string>
    2020#include <list>
    21 #include <bitset>
    2221#include <iterator>
    2322#include <memory>
     
    202201class DeclarationNode : public ParseNode {
    203202  public:
    204         // These must remain in the same order as the corresponding DeclarationNode names.
    205 
    206         enum { Extern = 1 << 0, Static = 1 << 1, Auto = 1 << 2, Register = 1 << 3, Threadlocal = 1 << 4, NoStorageClass = 5 };
    207         union StorageClasses {
    208                 unsigned int val;
    209                 struct {
    210                         bool is_extern : 1;
    211                         bool is_static : 1;
    212                         bool is_auto : 1;
    213                         bool is_register : 1;
    214                         bool is_threadlocal : 1;
    215                 };
    216                 StorageClasses() : val( 0 ) {}
    217                 StorageClasses( unsigned int val ) : val( val ) {}
    218                 bool operator[]( unsigned int i ) const { return val & (1 << i); }
    219         }; // StorageClasses
    220 
    221         enum { Inline = 1 << 0, Noreturn = 1 << 1, Fortran = 1 << 2, NoFuncSpecifier = 3 };
    222         union FuncSpecifiers {
    223                 unsigned int val;
    224                 struct {
    225                         bool is_inline : 1;
    226                         bool is_noreturn : 1;
    227                         bool is_fortran : 1;
    228                 };
    229                 FuncSpecifiers() : val( 0 ) {}
    230                 FuncSpecifiers( unsigned int val ) : val( val ) {}
    231                 bool operator[]( unsigned int i ) const { return val & (1 << i); }
    232         }; // FuncSpecifiers
    233 
    234         enum TypeQualifier { Const, Restrict, Volatile, Lvalue, Mutex, Atomic, NoTypeQualifier };
    235203        enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, NoBasicType };
    236204        enum ComplexType { Complex, Imaginary, NoComplexType };
     
    241209        enum BuiltinType { Valist, Zero, One, NoBuiltinType };
    242210
    243         static const char * storageClassNames[];
    244         static const char * funcSpecifierNames[];
    245         static const char * typeQualifierNames[];
    246211        static const char * basicTypeNames[];
    247212        static const char * complexTypeNames[];
     
    252217        static const char * builtinTypeNames[];
    253218
    254         static DeclarationNode * newStorageClass( StorageClasses );
    255         static DeclarationNode * newFuncSpecifier( FuncSpecifiers );
    256         static DeclarationNode * newTypeQualifier( TypeQualifier );
     219        static DeclarationNode * newStorageClass( Type::StorageClasses );
     220        static DeclarationNode * newFuncSpecifier( Type::FuncSpecifiers );
     221        static DeclarationNode * newTypeQualifier( Type::Qualifiers );
    257222        static DeclarationNode * newBasicType( BasicType );
    258223        static DeclarationNode * newComplexType( ComplexType );
     
    350315        TypeData * type;
    351316
    352         StorageClasses storageClasses;
    353         static void print_StorageClass( std::ostream & output, StorageClasses storageClasses );
    354 
    355         FuncSpecifiers funcSpecs;
    356         static void print_FuncSpec( std::ostream & output, FuncSpecifiers funcSpecs );
     317        Type::FuncSpecifiers funcSpecs;
     318        Type::StorageClasses storageClasses;
    357319
    358320        ExpressionNode * bitfieldWidth;
  • src/Parser/TypeData.cc

    r2f26687 r1fbab5a  
    1010// Created On       : Sat May 16 15:12:51 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Mar  7 08:08:21 2017
    13 // Update Count     : 538
     12// Last Modified On : Thu Mar 16 08:32:42 2017
     13// Update Count     : 559
    1414//
    1515
     
    2626using namespace std;
    2727
    28 TypeData::TypeData( Kind k ) : kind( k ), base( nullptr ), forall( nullptr ) {
     28TypeData::TypeData( Kind k ) : kind( k ), base( nullptr ), forall( nullptr ) /*, PTR1( (void*)(0xdeadbeefdeadbeef)), PTR2( (void*)(0xdeadbeefdeadbeef) ) */ {
    2929        switch ( kind ) {
    3030          case Unknown:
     
    5050                function.newStyle = false;
    5151                break;
     52                // Enum is an Aggregate, so both structures are initialized together.
     53          case Enum:
     54                // enumeration = new Enumeration_t;
     55                enumeration.name = nullptr;
     56                enumeration.constants = nullptr;
     57                enumeration.body = false;
    5258          case Aggregate:
    5359                // aggregate = new Aggregate_t;
     
    6470                aggInst.hoistType = false;;
    6571                break;
    66           case Enum:
    67                 // enumeration = new Enumeration_t;
    68                 enumeration.name = nullptr;
    69                 enumeration.constants = nullptr;
    70                 enumeration.body = false;
    71                 break;
    7272          case Symbolic:
    7373          case SymbolicInst:
     
    157157TypeData * TypeData::clone() const {
    158158        TypeData * newtype = new TypeData( kind );
    159         newtype->typeQualifiers = typeQualifiers;
     159        newtype->qualifiers = qualifiers;
    160160        newtype->base = maybeClone( base );
    161161        newtype->forall = maybeClone( forall );
     
    226226
    227227void TypeData::print( ostream &os, int indent ) const {
    228         for ( int i = 0; i < DeclarationNode::NoTypeQualifier; i += 1 ) {
    229                 if ( typeQualifiers[i] ) os << DeclarationNode::typeQualifierNames[ i ] << ' ';
     228        for ( int i = 0; i < Type::NumTypeQualifier; i += 1 ) {
     229                if ( qualifiers[i] ) os << Type::Qualifiers::Names[ i ] << ' ';
    230230        } // for
    231231
     
    398398                        // add dtor:  void ^?{}(T *)
    399399                        FunctionType * dtorType = new FunctionType( Type::Qualifiers(), false );
    400                         dtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
    401                         td->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, dtorType, nullptr ) );
     400                        dtorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
     401                        td->get_assertions().push_front( new FunctionDecl( "^?{}", Type::StorageClasses(), LinkageSpec::Cforall, dtorType, nullptr ) );
    402402
    403403                        // add copy ctor:  void ?{}(T *, T)
    404404                        FunctionType * copyCtorType = new FunctionType( Type::Qualifiers(), false );
    405                         copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
    406                         copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
    407                         td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, copyCtorType, nullptr ) );
     405                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
     406                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
     407                        td->get_assertions().push_front( new FunctionDecl( "?{}", Type::StorageClasses(), LinkageSpec::Cforall, copyCtorType, nullptr ) );
    408408
    409409                        // add default ctor:  void ?{}(T *)
    410410                        FunctionType * ctorType = new FunctionType( Type::Qualifiers(), false );
    411                         ctorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
    412                         td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, ctorType, nullptr ) );
     411                        ctorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
     412                        td->get_assertions().push_front( new FunctionDecl( "?{}", Type::StorageClasses(), LinkageSpec::Cforall, ctorType, nullptr ) );
    413413
    414414                        // add assignment operator:  T * ?=?(T *, T)
    415415                        FunctionType * assignType = new FunctionType( Type::Qualifiers(), false );
    416                         assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
    417                         assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
    418                         assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
    419                         td->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, assignType, nullptr ) );
     416                        assignType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
     417                        assignType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
     418                        assignType->get_returnVals().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
     419                        td->get_assertions().push_front( new FunctionDecl( "?=?", Type::StorageClasses(), LinkageSpec::Cforall, assignType, nullptr ) );
    420420                } // if
    421421        } // for
     
    493493
    494494Type::Qualifiers buildQualifiers( const TypeData * td ) {
    495         Type::Qualifiers q;
    496         q.isConst = td->typeQualifiers[ DeclarationNode::Const ];
    497         q.isVolatile = td->typeQualifiers[ DeclarationNode::Volatile ];
    498         q.isRestrict = td->typeQualifiers[ DeclarationNode::Restrict ];
    499         q.isLvalue = td->typeQualifiers[ DeclarationNode::Lvalue ];
    500         q.isAtomic = td->typeQualifiers[ DeclarationNode::Atomic ];;
    501         return q;
     495        return td->qualifiers;
    502496} // buildQualifiers
    503497
     
    732726} // buildAggInst
    733727
    734 NamedTypeDecl * buildSymbolic( const TypeData * td, const string & name, DeclarationNode::StorageClasses scs ) {
     728NamedTypeDecl * buildSymbolic( const TypeData * td, const string & name, Type::StorageClasses scs ) {
    735729        assert( td->kind == TypeData::Symbolic );
    736730        NamedTypeDecl * ret;
     
    784778} // buildTypeof
    785779
    786 Declaration * buildDecl( const TypeData * td, const string &name, DeclarationNode::StorageClasses scs, Expression * bitfieldWidth, DeclarationNode::FuncSpecifiers funcSpec, LinkageSpec::Spec linkage, ConstantExpr *asmName, Initializer * init, std::list< Attribute * > attributes ) {
     780Declaration * buildDecl( const TypeData * td, const string &name, Type::StorageClasses scs, Expression * bitfieldWidth, Type::FuncSpecifiers funcSpec, LinkageSpec::Spec linkage, ConstantExpr *asmName, Initializer * init, std::list< Attribute * > attributes ) {
    787781        if ( td->kind == TypeData::Function ) {
    788782                if ( td->function.idList ) {                                    // KR function ?
     
    820814                        break;
    821815                  default:
    822                         ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType * >( buildDecl( td->base, "", DeclarationNode::StorageClasses(), nullptr, DeclarationNode::FuncSpecifiers(), LinkageSpec::Cforall, nullptr ) ) );
     816                        ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType * >( buildDecl( td->base, "", Type::StorageClasses(), nullptr, Type::FuncSpecifiers(), LinkageSpec::Cforall, nullptr ) ) );
    823817                } // switch
    824818        } else {
    825                 ft->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) );
     819                ft->get_returnVals().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) );
    826820        } // if
    827821        return ft;
  • src/Parser/TypeData.h

    r2f26687 r1fbab5a  
    1010// Created On       : Sat May 16 15:18:36 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Mar  8 22:28:33 2017
    13 // Update Count     : 174
     12// Last Modified On : Thu Mar 16 08:32:39 2017
     13// Update Count     : 185
    1414//
    1515
    1616#ifndef TYPEDATA_H
    1717#define TYPEDATA_H
    18 
    19 #include <bitset>
    2018
    2119#include "ParseNode.h"
     
    7775        DeclarationNode::BuiltinType builtintype = DeclarationNode::NoBuiltinType;
    7876
    79         typedef std::bitset< DeclarationNode::NoTypeQualifier > TypeQualifiers;
    80         TypeQualifiers typeQualifiers;
     77        Type::Qualifiers qualifiers;
    8178        DeclarationNode * forall;
    8279
     
    112109TupleType * buildTuple( const TypeData * );
    113110TypeofType * buildTypeof( const TypeData * );
    114 Declaration * buildDecl( const TypeData *, const std::string &, DeclarationNode::StorageClasses, Expression *, DeclarationNode::FuncSpecifiers funcSpec, LinkageSpec::Spec, ConstantExpr *asmName, Initializer * init = nullptr, std::list< class Attribute * > attributes = std::list< class Attribute * >() );
     111Declaration * buildDecl( const TypeData *, const std::string &, Type::StorageClasses, Expression *, Type::FuncSpecifiers funcSpec, LinkageSpec::Spec, ConstantExpr *asmName, Initializer * init = nullptr, std::list< class Attribute * > attributes = std::list< class Attribute * >() );
    115112FunctionType * buildFunction( const TypeData * );
    116113void buildKRFunction( const TypeData::Function_t & function );
  • src/Parser/parser.yy

    r2f26687 r1fbab5a  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Mar  9 21:40:20 2017
    13 // Update Count     : 2292
     12// Last Modified On : Thu Mar 16 08:36:17 2017
     13// Update Count     : 2310
    1414//
    1515
     
    441441argument_expression:
    442442        // empty
    443                 { $$ = nullptr; }                                                               // use default argument
     443                { $$ = nullptr; }
     444        // | '@'                                                                                                // use default argument
     445        //      { $$ = new ExpressionNode( build_constantInteger( *new string( "2" ) ) ); }
    444446        | assignment_expression
    445447        ;
     
    14081410type_qualifier_name:
    14091411        CONST
    1410                 { $$ = DeclarationNode::newTypeQualifier( DeclarationNode::Const ); }
     1412                { $$ = DeclarationNode::newTypeQualifier( Type::Const ); }
    14111413        | RESTRICT
    1412                 { $$ = DeclarationNode::newTypeQualifier( DeclarationNode::Restrict ); }
     1414                { $$ = DeclarationNode::newTypeQualifier( Type::Restrict ); }
    14131415        | VOLATILE
    1414                 { $$ = DeclarationNode::newTypeQualifier( DeclarationNode::Volatile ); }
     1416                { $$ = DeclarationNode::newTypeQualifier( Type::Volatile ); }
    14151417        | LVALUE                                                                                        // CFA
    1416                 { $$ = DeclarationNode::newTypeQualifier( DeclarationNode::Lvalue ); }
     1418                { $$ = DeclarationNode::newTypeQualifier( Type::Lvalue ); }
    14171419        | MUTEX
    1418                 { $$ = DeclarationNode::newTypeQualifier( DeclarationNode::Mutex ); }
     1420                { $$ = DeclarationNode::newTypeQualifier( Type::Mutex ); }
    14191421        | ATOMIC
    1420                 { $$ = DeclarationNode::newTypeQualifier( DeclarationNode::Atomic ); }
     1422                { $$ = DeclarationNode::newTypeQualifier( Type::Atomic ); }
    14211423        | FORALL '('
    14221424                {
     
    14511453storage_class:
    14521454        EXTERN
    1453                 { $$ = DeclarationNode::newStorageClass( DeclarationNode::Extern ); }
     1455                { $$ = DeclarationNode::newStorageClass( Type::Extern ); }
    14541456        | STATIC
    1455                 { $$ = DeclarationNode::newStorageClass( DeclarationNode::Static ); }
     1457                { $$ = DeclarationNode::newStorageClass( Type::Static ); }
    14561458        | AUTO
    1457                 { $$ = DeclarationNode::newStorageClass( DeclarationNode::Auto ); }
     1459                { $$ = DeclarationNode::newStorageClass( Type::Auto ); }
    14581460        | REGISTER
    1459                 { $$ = DeclarationNode::newStorageClass( DeclarationNode::Register ); }
     1461                { $$ = DeclarationNode::newStorageClass( Type::Register ); }
    14601462        | THREADLOCAL                                                                           // C11
    1461                 { $$ = DeclarationNode::newStorageClass( DeclarationNode::Threadlocal ); }
     1463                { $$ = DeclarationNode::newStorageClass( Type::Threadlocal ); }
    14621464                // Put function specifiers here to simplify parsing rules, but separate them semantically.
    14631465        | INLINE                                                                                        // C99
    1464                 { $$ = DeclarationNode::newFuncSpecifier( DeclarationNode::Inline ); }
     1466                { $$ = DeclarationNode::newFuncSpecifier( Type::Inline ); }
    14651467        | FORTRAN                                                                                       // C99
    1466                 { $$ = DeclarationNode::newFuncSpecifier( DeclarationNode::Fortran ); }
     1468                { $$ = DeclarationNode::newFuncSpecifier( Type::Fortran ); }
    14671469        | NORETURN                                                                                      // C11
    1468                 { $$ = DeclarationNode::newFuncSpecifier( DeclarationNode::Noreturn ); }
     1470                { $$ = DeclarationNode::newFuncSpecifier( Type::Noreturn ); }
    14691471        ;
    14701472
     
    16861688        // empty
    16871689                { $$ = DeclarationNode::newName( 0 ); /* XXX */ } // CFA, no field name
     1690        // '@' // empty
     1691        //      { $$ = DeclarationNode::newName( 0 ); /* XXX */ } // CFA, no field name
    16881692        | bit_subrange_size                                                                     // no field name
    16891693                { $$ = DeclarationNode::newBitfield( $1 ); }
  • src/ResolvExpr/Unify.cc

    r2f26687 r1fbab5a  
    1010// Created On       : Sun May 17 12:27:10 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Mar  6 23:37:38 2017
    13 // Update Count     : 39
     12// Last Modified On : Thu Mar 16 07:59:59 2017
     13// Update Count     : 40
    1414//
    1515
     
    541541                        flatten( dcl->get_type(), back_inserter( types ) );
    542542                        for ( Type * t : types ) {
    543                                 dst.push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::C, nullptr, t, nullptr ) );
     543                                dst.push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::C, nullptr, t, nullptr ) );
    544544                        }
    545545                        delete dcl;
  • src/SymTab/Autogen.cc

    r2f26687 r1fbab5a  
    1010// Created On       : Thu Mar 03 15:45:56 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Mar 14 07:45:00 2017
    13 // Update Count     : 54
     12// Last Modified On : Thu Mar 16 08:37:22 2017
     13// Update Count     : 59
    1414//
    1515
     
    125125        FunctionType * genDefaultType( Type * paramType ) {
    126126                FunctionType *ftype = new FunctionType( Type::Qualifiers(), false );
    127                 ObjectDecl *dstParam = new ObjectDecl( "_dst", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), paramType->clone() ), nullptr );
     127                ObjectDecl *dstParam = new ObjectDecl( "_dst", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), paramType->clone() ), nullptr );
    128128                ftype->get_parameters().push_back( dstParam );
    129129
     
    134134        FunctionType * genCopyType( Type * paramType ) {
    135135                FunctionType *ftype = genDefaultType( paramType );
    136                 ObjectDecl *srcParam = new ObjectDecl( "_src", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, paramType->clone(), nullptr );
     136                ObjectDecl *srcParam = new ObjectDecl( "_src", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, paramType->clone(), nullptr );
    137137                ftype->get_parameters().push_back( srcParam );
    138138                return ftype;
     
    142142        FunctionType * genAssignType( Type * paramType ) {
    143143                FunctionType *ftype = genCopyType( paramType );
    144                 ObjectDecl *returnVal = new ObjectDecl( "_ret", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, paramType->clone(), nullptr );
     144                ObjectDecl *returnVal = new ObjectDecl( "_ret", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, paramType->clone(), nullptr );
    145145                ftype->get_returnVals().push_back( returnVal );
    146146                return ftype;
     
    162162                // because each unit generates copies of the default routines for each aggregate.
    163163//              DeclarationNode::StorageClass sc = functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static;
    164                 DeclarationNode::StorageClasses scs = functionNesting > 0 ? DeclarationNode::StorageClasses() : DeclarationNode::StorageClasses( DeclarationNode::Static );
     164                Type::StorageClasses scs = functionNesting > 0 ? Type::StorageClasses() : Type::StorageClasses( Type::Static );
    165165                LinkageSpec::Spec spec = isIntrinsic ? LinkageSpec::Intrinsic : LinkageSpec::AutoGen;
    166166                FunctionDecl * decl = new FunctionDecl( fname, scs, spec, ftype, new CompoundStmt( noLabels ),
    167                                                                                                 std::list< Attribute * >(), DeclarationNode::FuncSpecifiers( DeclarationNode::Inline ) );
     167                                                                                                std::list< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) );
    168168                decl->fixUniqueId();
    169169                return decl;
     
    460460                                        continue;
    461461                                }
    462                                 memCtorType->get_parameters().push_back( new ObjectDecl( member->get_name(), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, member->get_type()->clone(), 0 ) );
     462                                memCtorType->get_parameters().push_back( new ObjectDecl( member->get_name(), Type::StorageClasses(), LinkageSpec::Cforall, 0, member->get_type()->clone(), 0 ) );
    463463                                FunctionDecl * ctor = genFunc( "?{}", memCtorType->clone(), functionNesting );
    464464                                makeStructFieldCtorBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), ctor, isDynamicLayout );
     
    540540                for ( Declaration * member : aggregateDecl->get_members() ) {
    541541                        if ( DeclarationWithType * field = dynamic_cast< DeclarationWithType * >( member ) ) {
    542                                 ObjectDecl * srcParam = new ObjectDecl( "src", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, field->get_type()->clone(), 0 );
     542                                ObjectDecl * srcParam = new ObjectDecl( "src", Type::StorageClasses(), LinkageSpec::Cforall, 0, field->get_type()->clone(), 0 );
    543543
    544544                                FunctionType * memCtorType = ctorType->clone();
     
    605605                TypeInstType *typeInst = new TypeInstType( Type::Qualifiers(), typeDecl->get_name(), false );
    606606                typeInst->set_baseType( typeDecl );
    607                 ObjectDecl *src = new ObjectDecl( "_src", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, typeInst->clone(), nullptr );
    608                 ObjectDecl *dst = new ObjectDecl( "_dst", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), typeInst->clone() ), nullptr );
     607                ObjectDecl *src = new ObjectDecl( "_src", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, typeInst->clone(), nullptr );
     608                ObjectDecl *dst = new ObjectDecl( "_dst", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), typeInst->clone() ), nullptr );
    609609
    610610                std::list< Statement * > stmts;
     
    618618                } // if
    619619                FunctionType *type = new FunctionType( Type::Qualifiers(), false );
    620                 type->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, typeInst, 0 ) );
     620                type->get_returnVals().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, typeInst, 0 ) );
    621621                type->get_parameters().push_back( dst );
    622622                type->get_parameters().push_back( src );
     
    717717                        if ( TypeInstType * ty = dynamic_cast< TypeInstType * >( t ) ) {
    718718                                if ( ! done.count( ty->get_baseType() ) ) {
    719                                         TypeDecl * newDecl = new TypeDecl( ty->get_baseType()->get_name(), DeclarationNode::StorageClasses(), nullptr, TypeDecl::Any );
     719                                        TypeDecl * newDecl = new TypeDecl( ty->get_baseType()->get_name(), Type::StorageClasses(), nullptr, TypeDecl::Any );
    720720                                        TypeInstType * inst = new TypeInstType( Type::Qualifiers(), newDecl->get_name(), newDecl );
    721                                         newDecl->get_assertions().push_back( new FunctionDecl( "?=?", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, genAssignType( inst ), nullptr,
    722                                                                                                                                                    std::list< Attribute * >(), DeclarationNode::FuncSpecifiers( DeclarationNode::Inline ) ) );
    723                                         newDecl->get_assertions().push_back( new FunctionDecl( "?{}", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, genDefaultType( inst ), nullptr,
    724                                                                                                                                                    std::list< Attribute * >(), DeclarationNode::FuncSpecifiers( DeclarationNode::Inline ) ) );
    725                                         newDecl->get_assertions().push_back( new FunctionDecl( "?{}", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, genCopyType( inst ), nullptr,
    726                                                                                                                                                    std::list< Attribute * >(), DeclarationNode::FuncSpecifiers( DeclarationNode::Inline ) ) );
    727                                         newDecl->get_assertions().push_back( new FunctionDecl( "^?{}", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, genDefaultType( inst ), nullptr,
    728                                                                                                                                                    std::list< Attribute * >(), DeclarationNode::FuncSpecifiers( DeclarationNode::Inline ) ) );
     721                                        newDecl->get_assertions().push_back( new FunctionDecl( "?=?", Type::StorageClasses(), LinkageSpec::Cforall, genAssignType( inst ), nullptr,
     722                                                                                                                                                   std::list< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) ) );
     723                                        newDecl->get_assertions().push_back( new FunctionDecl( "?{}", Type::StorageClasses(), LinkageSpec::Cforall, genDefaultType( inst ), nullptr,
     724                                                                                                                                                   std::list< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) ) );
     725                                        newDecl->get_assertions().push_back( new FunctionDecl( "?{}", Type::StorageClasses(), LinkageSpec::Cforall, genCopyType( inst ), nullptr,
     726                                                                                                                                                   std::list< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) ) );
     727                                        newDecl->get_assertions().push_back( new FunctionDecl( "^?{}", Type::StorageClasses(), LinkageSpec::Cforall, genDefaultType( inst ), nullptr,
     728                                                                                                                                                   std::list< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) ) );
    729729                                        typeParams.push_back( newDecl );
    730730                                        done.insert( ty->get_baseType() );
  • src/SymTab/Autogen.h

    r2f26687 r1fbab5a  
    1010// Created On       : Sun May 17 21:53:34 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Mar  6 23:33:01 2017
    13 // Update Count     : 4
     12// Last Modified On : Thu Mar 16 07:51:39 2017
     13// Update Count     : 8
    1414//
    1515
     
    5858                        assert( type );
    5959                        Type * castType = type->clone();
    60                         castType->get_qualifiers() -= Type::Qualifiers(true, true, true, false, true, false);
     60//                      castType->get_qualifiers() -= Type::Qualifiers(true, true, true, false, true, false);
     61                        castType->get_qualifiers() -= Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
    6162                        castType->set_isLvalue( true ); // xxx - might not need this
    6263                        dstParam = new CastExpr( dstParam, new PointerType( Type::Qualifiers(), castType ) );
     
    102103                }
    103104
    104                 ObjectDecl *index = new ObjectDecl( indexName.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin, std::list<Expression*>() ) );
     105                ObjectDecl *index = new ObjectDecl( indexName.newName(), Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin, std::list<Expression*>() ) );
    105106
    106107                UntypedExpr *cond = new UntypedExpr( cmp );
  • src/SymTab/Validate.cc

    r2f26687 r1fbab5a  
    1010// Created On       : Sun May 17 21:50:04 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Mar  7 07:51:36 2017
    13 // Update Count     : 349
     12// Last Modified On : Thu Mar 16 08:02:54 2017
     13// Update Count     : 351
    1414//
    1515
     
    208208
    209209        class CompoundLiteral final : public GenPoly::DeclMutator {
    210                 DeclarationNode::StorageClasses storageClasses;
     210                Type::StorageClasses storageClasses;
    211211
    212212                using GenPoly::DeclMutator::mutate;
     
    323323                        ObjectDecl * obj = dynamic_cast< ObjectDecl * >( *i );
    324324                        assert( obj );
    325                         obj->set_type( new EnumInstType( Type::Qualifiers( true, false, false, false, false, false ), enumDecl->get_name() ) );
     325                        obj->set_type( new EnumInstType( Type::Qualifiers( Type::Const ), enumDecl->get_name() ) );
    326326                } // for
    327327                Parent::visit( enumDecl );
     
    754754                                type = new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() );
    755755                        } // if
    756                         TypedefDeclPtr tyDecl( new TypedefDecl( aggDecl->get_name(), DeclarationNode::StorageClasses(), type ) );
     756                        TypedefDeclPtr tyDecl( new TypedefDecl( aggDecl->get_name(), Type::StorageClasses(), type ) );
    757757                        typedefNames[ aggDecl->get_name() ] = std::make_pair( std::move( tyDecl ), scopeLevel );
    758758                } // if
     
    857857                        TupleType * tupleType = safe_dynamic_cast< TupleType * >( ResolvExpr::extractResultType( ftype ) );
    858858                        // ensure return value is not destructed by explicitly creating an empty ListInit node wherein maybeConstruct is false.
    859                         ObjectDecl * newRet = new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, tupleType, new ListInit( std::list<Initializer*>(), noDesignators, false ) );
     859                        ObjectDecl * newRet = new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, tupleType, new ListInit( std::list<Initializer*>(), noDesignators, false ) );
    860860                        deleteAll( retVals );
    861861                        retVals.clear();
  • src/SynTree/AggregateDecl.cc

    r2f26687 r1fbab5a  
    1010// Created On       : Sun May 17 23:56:39 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Mar  7 07:31:47 2017
    13 // Update Count     : 19
     12// Last Modified On : Thu Mar 16 07:49:07 2017
     13// Update Count     : 20
    1414//
    1515
     
    2020
    2121
    22 AggregateDecl::AggregateDecl( const std::string &name, const std::list< Attribute * > & attributes ) : Parent( name, DeclarationNode::StorageClasses(), LinkageSpec::Cforall ), body( false ), attributes( attributes ) {
     22AggregateDecl::AggregateDecl( const std::string &name, const std::list< Attribute * > & attributes ) : Parent( name, Type::StorageClasses(), LinkageSpec::Cforall ), body( false ), attributes( attributes ) {
    2323}
    2424
  • src/SynTree/Declaration.cc

    r2f26687 r1fbab5a  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Mar  7 07:31:11 2017
    13 // Update Count     : 23
     12// Last Modified On : Thu Mar 16 07:49:18 2017
     13// Update Count     : 24
    1414//
    1515
     
    2727static IdMapType idMap;
    2828
    29 Declaration::Declaration( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage )
     29Declaration::Declaration( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage )
    3030                : name( name ), storageClasses( scs ), linkage( linkage ), uniqueId( 0 ) {
    3131}
     
    6666
    6767
    68 AsmDecl::AsmDecl( AsmStmt *stmt ) : Declaration( "", DeclarationNode::StorageClasses(), LinkageSpec::C ), stmt( stmt ) {
     68AsmDecl::AsmDecl( AsmStmt *stmt ) : Declaration( "", Type::StorageClasses(), LinkageSpec::C ), stmt( stmt ) {
    6969}
    7070
  • src/SynTree/Declaration.h

    r2f26687 r1fbab5a  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Mar  7 07:40:42 2017
    13 // Update Count     : 113
     12// Last Modified On : Thu Mar 16 08:34:11 2017
     13// Update Count     : 118
    1414//
    1515
     
    2828class Declaration : public BaseSyntaxNode {
    2929  public:
    30         Declaration( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage );
     30        Declaration( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage );
    3131        Declaration( const Declaration &other );
    3232        virtual ~Declaration();
     
    3535        void set_name( std::string newValue ) { name = newValue; }
    3636
    37         DeclarationNode::StorageClasses get_storageClasses() const { return storageClasses; }
     37        Type::StorageClasses get_storageClasses() const { return storageClasses; }
    3838
    3939        LinkageSpec::Spec get_linkage() const { return linkage; }
     
    5656  private:
    5757        std::string name;
    58         DeclarationNode::StorageClasses storageClasses;
     58        Type::StorageClasses storageClasses;
    5959        LinkageSpec::Spec linkage;
    6060        UniqueId uniqueId;
     
    6464class DeclarationWithType : public Declaration {
    6565  public:
    66         DeclarationWithType( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, DeclarationNode::FuncSpecifiers fs );
     66        DeclarationWithType( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, Type::FuncSpecifiers fs );
    6767        DeclarationWithType( const DeclarationWithType &other );
    6868        virtual ~DeclarationWithType();
     
    8282        const std::list< Attribute * >& get_attributes() const { return attributes; }
    8383
    84         DeclarationNode::FuncSpecifiers get_funcSpec() const { return fs; }
    85         //void set_functionSpecifiers( DeclarationNode::FuncSpecifiers newValue ) { fs = newValue; }
     84        Type::FuncSpecifiers get_funcSpec() const { return fs; }
     85        //void set_functionSpecifiers( Type::FuncSpecifiers newValue ) { fs = newValue; }
    8686
    8787        virtual DeclarationWithType *clone() const = 0;
     
    9898        ConstantExpr *asmName;
    9999        std::list< Attribute * > attributes;
    100         DeclarationNode::FuncSpecifiers fs;
     100        Type::FuncSpecifiers fs;
    101101};
    102102
     
    104104        typedef DeclarationWithType Parent;
    105105  public:
    106         ObjectDecl( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage, Expression *bitfieldWidth, Type *type, Initializer *init,
    107                                 const std::list< Attribute * > attributes = std::list< Attribute * >(), DeclarationNode::FuncSpecifiers fs = DeclarationNode::FuncSpecifiers() );
     106        ObjectDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, Expression *bitfieldWidth, Type *type, Initializer *init,
     107                                const std::list< Attribute * > attributes = std::list< Attribute * >(), Type::FuncSpecifiers fs = Type::FuncSpecifiers() );
    108108        ObjectDecl( const ObjectDecl &other );
    109109        virtual ~ObjectDecl();
     
    132132        typedef DeclarationWithType Parent;
    133133  public:
    134         FunctionDecl( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements,
    135                                   const std::list< Attribute * > attributes = std::list< Attribute * >(), DeclarationNode::FuncSpecifiers fs = DeclarationNode::FuncSpecifiers() );
     134        FunctionDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements,
     135                                  const std::list< Attribute * > attributes = std::list< Attribute * >(), Type::FuncSpecifiers fs = Type::FuncSpecifiers() );
    136136        FunctionDecl( const FunctionDecl &other );
    137137        virtual ~FunctionDecl();
     
    158158        typedef Declaration Parent;
    159159  public:
    160         NamedTypeDecl( const std::string &name, DeclarationNode::StorageClasses scs, Type *type );
     160        NamedTypeDecl( const std::string &name, Type::StorageClasses scs, Type *type );
    161161        NamedTypeDecl( const NamedTypeDecl &other );
    162162        virtual ~NamedTypeDecl();
     
    193193        };
    194194
    195         TypeDecl( const std::string &name, DeclarationNode::StorageClasses scs, Type *type, Kind kind );
     195        TypeDecl( const std::string &name, Type::StorageClasses scs, Type *type, Kind kind );
    196196        TypeDecl( const TypeDecl &other );
    197197
     
    214214        typedef NamedTypeDecl Parent;
    215215  public:
    216         TypedefDecl( const std::string &name, DeclarationNode::StorageClasses scs, Type *type ) : Parent( name, scs, type ) {}
     216        TypedefDecl( const std::string &name, Type::StorageClasses scs, Type *type ) : Parent( name, scs, type ) {}
    217217        TypedefDecl( const TypedefDecl &other ) : Parent( other ) {}
    218218
  • src/SynTree/DeclarationWithType.cc

    r2f26687 r1fbab5a  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Mar  7 07:32:14 2017
    13 // Update Count     : 23
     12// Last Modified On : Thu Mar 16 08:34:35 2017
     13// Update Count     : 25
    1414//
    1515
     
    1919#include "Common/utility.h"
    2020
    21 DeclarationWithType::DeclarationWithType( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, DeclarationNode::FuncSpecifiers fs )
     21DeclarationWithType::DeclarationWithType( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, Type::FuncSpecifiers fs )
    2222        : Declaration( name, scs, linkage ), asmName( nullptr ), attributes( attributes ), fs( fs ) {
    2323}
  • src/SynTree/FunctionDecl.cc

    r2f26687 r1fbab5a  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Mar  7 07:54:58 2017
    13 // Update Count     : 68
     12// Last Modified On : Thu Mar 16 08:33:41 2017
     13// Update Count     : 74
    1414//
    1515
     
    2626extern bool translation_unit_nomain;
    2727
    28 FunctionDecl::FunctionDecl( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements, std::list< Attribute * > attributes, DeclarationNode::FuncSpecifiers fs )
     28FunctionDecl::FunctionDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements, std::list< Attribute * > attributes, Type::FuncSpecifiers fs )
    2929        : Parent( name, scs, linkage, attributes, fs ), type( type ), statements( statements ) {
    3030        // hack forcing the function "main" to have Cforall linkage to replace main even if it is inside an extern
     
    6565        printAll( get_attributes(), os, indent );
    6666
    67         DeclarationNode::print_StorageClass( os, get_storageClasses() );
    68         DeclarationNode::print_FuncSpec( os, get_funcSpec() );
     67        get_storageClasses().print( os );
     68        get_funcSpec().print( os );
    6969
    7070        if ( get_type() ) {
     
    9191        // xxx - should printShort print attributes?
    9292
    93         DeclarationNode::print_StorageClass( os, get_storageClasses() );
    94         DeclarationNode::print_FuncSpec( os, get_funcSpec() );
     93        get_storageClasses().print( os );
     94        get_funcSpec().print( os );
    9595
    9696        if ( get_type() ) {
  • src/SynTree/NamedTypeDecl.cc

    r2f26687 r1fbab5a  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Mar  7 07:39:41 2017
    13 // Update Count     : 10
     12// Last Modified On : Thu Mar 16 07:49:44 2017
     13// Update Count     : 13
    1414//
    1515
     
    1818#include "Common/utility.h"
    1919
    20 NamedTypeDecl::NamedTypeDecl( const std::string &name, DeclarationNode::StorageClasses scs, Type *base )
     20NamedTypeDecl::NamedTypeDecl( const std::string &name, Type::StorageClasses scs, Type *base )
    2121        : Parent( name, scs, LinkageSpec::Cforall ), base( base ) {}
    2222
     
    3939                os << get_name() << ": ";
    4040        } // if
    41         DeclarationNode::print_StorageClass( os, get_storageClasses() );
     41        get_storageClasses().print( os );
    4242        os << typeString();
    4343        if ( base ) {
     
    6161                os << get_name() << ": ";
    6262        } // if
    63         DeclarationNode::print_StorageClass( os, get_storageClasses() );
     63        get_storageClasses().print( os );
    6464        os << typeString();
    6565        if ( base ) {
  • src/SynTree/ObjectDecl.cc

    r2f26687 r1fbab5a  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Mar  7 07:55:24 2017
    13 // Update Count     : 54
     12// Last Modified On : Thu Mar 16 08:34:27 2017
     13// Update Count     : 59
    1414//
    1515
     
    2222#include "Statement.h"
    2323
    24 ObjectDecl::ObjectDecl( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage, Expression *bitfieldWidth, Type *type, Initializer *init, const std::list< Attribute * > attributes, DeclarationNode::FuncSpecifiers fs )
     24ObjectDecl::ObjectDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, Expression *bitfieldWidth, Type *type, Initializer *init, const std::list< Attribute * > attributes, Type::FuncSpecifiers fs )
    2525        : Parent( name, scs, linkage, attributes, fs ), type( type ), init( init ), bitfieldWidth( bitfieldWidth ) {
    2626}
     
    4747        printAll( get_attributes(), os, indent );
    4848
    49         DeclarationNode::print_StorageClass( os, get_storageClasses() );
     49        get_storageClasses().print( os );
    5050
    5151        if ( get_type() ) {
     
    8181        // xxx - should printShort print attributes?
    8282
    83         DeclarationNode::print_StorageClass( os, get_storageClasses() );
     83        get_storageClasses().print( os );
    8484
    8585        if ( get_type() ) {
  • src/SynTree/Type.cc

    r2f26687 r1fbab5a  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb  2 11:26:24 2017
    13 // Update Count     : 12
     12// Last Modified On : Thu Mar 16 10:25:06 2017
     13// Update Count     : 23
    1414//
    1515
     
    5959}
    6060
    61 void Type::Qualifiers::print( std::ostream &os, int indent ) const {
    62         if ( isConst ) {
    63                 os << "const ";
    64         } // if
    65         if ( isVolatile ) {
    66                 os << "volatile ";
    67         } // if
    68         if ( isRestrict ) {
    69                 os << "restrict ";
    70         } // if
    71         if ( isLvalue ) {
    72                 os << "lvalue ";
    73         } // if
    74         if ( isAtomic ) {
    75                 os << "_Atomic ";
    76         } // if
    77 }
     61// These must remain in the same order as the corresponding bit fields.
     62const char * Type::FuncSpecifiers::Names[] = { "inline", "fortran", "_Noreturn" };
     63const char * Type::StorageClasses::Names[] = { "extern", "static", "auto", "register", "_Thread_local" };
     64const char * Type::Qualifiers::Names[] = { "const", "restrict", "volatile", "lvalue", "mutex", "_Atomic" };
    7865
    7966void Type::print( std::ostream &os, int indent ) const {
     
    8976        } // if
    9077       
    91         tq.print( os, indent );
     78        tq.print( os );
    9279}
    9380
  • src/SynTree/Type.h

    r2f26687 r1fbab5a  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Mar  1 09:11:45 2017
    13 // Update Count     : 41
     12// Last Modified On : Thu Mar 16 12:11:50 2017
     13// Update Count     : 116
    1414//
    1515
     
    2424class Type : public BaseSyntaxNode {
    2525  public:
    26         struct Qualifiers {
    27                 Qualifiers(): isConst( false ), isVolatile( false ), isRestrict( false ), isLvalue( false ), isAtomic( false ), isMutex( false ) {}
    28                 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 ) {}
    29 
    30                 Qualifiers &operator&=( const Qualifiers &other );
    31                 Qualifiers &operator+=( const Qualifiers &other );
    32                 Qualifiers &operator-=( const Qualifiers &other );
    33                 Qualifiers operator+( const Type::Qualifiers &other );
    34                 bool operator==( const Qualifiers &other );
    35                 bool operator!=( const Qualifiers &other );
    36                 bool operator<=( const Qualifiers &other );
    37                 bool operator>=( const Qualifiers &other );
    38                 bool operator<( const Qualifiers &other );
    39                 bool operator>( const Qualifiers &other );
    40                 void print( std::ostream &os, int indent = 0 ) const;
    41 
    42                 bool isConst;
    43                 bool isVolatile;
    44                 bool isRestrict;
    45                 bool isLvalue;
    46                 bool isAtomic;
    47                 bool isMutex;
    48         };
    49 
    50         Type( const Qualifiers &tq, const std::list< Attribute * > & attributes );
    51         Type( const Type &other );
     26        #define CommonBF( N ) \
     27                bool operator[]( unsigned int i ) const { return val & (1 << i); } \
     28                bool any() const { return val != 0; } \
     29                static const char * Names[]; \
     30                void print( std::ostream & os ) const { \
     31                        if ( (*this).any() ) { \
     32                                for ( unsigned int i = 0; i < N; i += 1 ) { \
     33                                        if ( (*this)[i] ) { \
     34                                                os << Names[i] << ' '; \
     35                                        } \
     36                                } \
     37                        } \
     38                }
     39
     40        // enum must remain in the same order as the corresponding bit fields.
     41
     42        enum { Inline = 1 << 0, Noreturn = 1 << 1, Fortran = 1 << 2, NumFuncSpecifier = 3 };
     43        union FuncSpecifiers {
     44                unsigned int val;
     45                struct {
     46                        bool is_inline : 1;
     47                        bool is_noreturn : 1;
     48                        bool is_fortran : 1;
     49                };
     50                FuncSpecifiers() : val( 0 ) {}
     51                FuncSpecifiers( unsigned int val ) : val( val ) {}
     52                CommonBF( NumFuncSpecifier )
     53        }; // FuncSpecifiers
     54
     55        enum { Extern = 1 << 0, Static = 1 << 1, Auto = 1 << 2, Register = 1 << 3, Threadlocal = 1 << 4, NumStorageClass = 5 };
     56        union StorageClasses {
     57                unsigned int val;
     58                struct {
     59                        bool is_extern : 1;
     60                        bool is_static : 1;
     61                        bool is_auto : 1;
     62                        bool is_register : 1;
     63                        bool is_threadlocal : 1;
     64                };
     65
     66                StorageClasses() : val( 0 ) {}
     67                StorageClasses( unsigned int val ) : val( val ) {}
     68                CommonBF( NumStorageClass )
     69        }; // StorageClasses
     70
     71        enum { Const = 1 << 0, Restrict = 1 << 1, Volatile = 1 << 2, Lvalue = 1 << 3, Mutex = 1 << 4, Atomic = 1 << 5, NumTypeQualifier = 6 };
     72        union Qualifiers {
     73                enum { Mask = ~(Restrict | Lvalue) };
     74                unsigned int val;
     75                struct {
     76                        bool isConst : 1;
     77                        bool isRestrict : 1;
     78                        bool isVolatile : 1;
     79                        bool isLvalue : 1;
     80                        bool isMutex : 1;
     81                        bool isAtomic : 1;
     82                };
     83
     84                Qualifiers() : val( 0 ) {}
     85                Qualifiers( unsigned int val ) : val( val ) {}
     86                bool operator==( Qualifiers other ) const {
     87                        return (val & Mask) == (other.val & Mask);
     88                }
     89                bool operator!=( Qualifiers other ) const {
     90                        return (val & Mask) != (other.val & Mask);
     91                }
     92                bool operator<=( Qualifiers other ) const {
     93                        return isConst <= other.isConst && isVolatile <= other.isVolatile &&
     94                                isMutex == other.isMutex && isAtomic == other.isAtomic;
     95                }
     96                bool operator>=( Qualifiers other ) const {
     97                        return isConst >= other.isConst && isVolatile >= other.isVolatile &&
     98                                isMutex == other.isMutex && isAtomic == other.isAtomic;
     99                }
     100                bool operator<( Qualifiers other ) const {
     101                        return *this != other && *this <= other;
     102                }
     103                bool operator>( Qualifiers other ) const {
     104                        return *this != other && *this >= other;
     105                }
     106                Qualifiers operator&=( Type::Qualifiers other ) {
     107                        val &= other.val; return *this;
     108                }
     109                Qualifiers operator+=( Qualifiers other ) {
     110                        val |= other.val; return *this;
     111                }
     112                Qualifiers operator-=( Qualifiers other ) {
     113                        val &= ~other.val; return *this;
     114                }
     115                Qualifiers operator+( Qualifiers other ) const {
     116                        Qualifiers q = other;
     117                        q += *this;
     118                        return q;
     119                }
     120                CommonBF( NumTypeQualifier )
     121        }; // Qualifiers
     122
     123        Type( const Qualifiers & tq, const std::list< Attribute * > & attributes );
     124        Type( const Type & other );
    52125        virtual ~Type();
    53126
    54         Qualifiers &get_qualifiers() { return tq; }
     127        Qualifiers & get_qualifiers() { return tq; }
    55128        bool get_isConst() { return tq.isConst; }
    56129        bool get_isVolatile() { return tq.isVolatile; }
     
    78151
    79152        virtual Type *clone() const = 0;
    80         virtual void accept( Visitor &v ) = 0;
    81         virtual Type *acceptMutator( Mutator &m ) = 0;
    82         virtual void print( std::ostream &os, int indent = 0 ) const;
     153        virtual void accept( Visitor & v ) = 0;
     154        virtual Type *acceptMutator( Mutator & m ) = 0;
     155        virtual void print( std::ostream & os, int indent = 0 ) const;
    83156  private:
    84157        Qualifiers tq;
     
    91164class VoidType : public Type {
    92165  public:
    93         VoidType( const Type::Qualifiers &tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
     166        VoidType( const Type::Qualifiers & tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    94167
    95168        virtual unsigned size() const { return 0; };
     
    97170
    98171        virtual VoidType *clone() const { return new VoidType( *this ); }
    99         virtual void accept( Visitor &v ) { v.visit( this ); }
    100         virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    101         virtual void print( std::ostream &os, int indent = 0 ) const;
     172        virtual void accept( Visitor & v ) { v.visit( this ); }
     173        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
     174        virtual void print( std::ostream & os, int indent = 0 ) const;
    102175};
    103176
     
    131204        static const char *typeNames[];                                         // string names for basic types, MUST MATCH with Kind
    132205
    133         BasicType( const Type::Qualifiers &tq, Kind bt, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
     206        BasicType( const Type::Qualifiers & tq, Kind bt, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    134207
    135208        Kind get_kind() { return kind; }
     
    137210
    138211        virtual BasicType *clone() const { return new BasicType( *this ); }
    139         virtual void accept( Visitor &v ) { v.visit( this ); }
    140         virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    141         virtual void print( std::ostream &os, int indent = 0 ) const;
     212        virtual void accept( Visitor & v ) { v.visit( this ); }
     213        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
     214        virtual void print( std::ostream & os, int indent = 0 ) const;
    142215
    143216        bool isInteger() const;
     
    148221class PointerType : public Type {
    149222  public:
    150         PointerType( const Type::Qualifiers &tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    151         PointerType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
     223        PointerType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
     224        PointerType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    152225        PointerType( const PointerType& );
    153226        virtual ~PointerType();
     
    163236
    164237        virtual PointerType *clone() const { return new PointerType( *this ); }
    165         virtual void accept( Visitor &v ) { v.visit( this ); }
    166         virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    167         virtual void print( std::ostream &os, int indent = 0 ) const;
     238        virtual void accept( Visitor & v ) { v.visit( this ); }
     239        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
     240        virtual void print( std::ostream & os, int indent = 0 ) const;
    168241  private:
    169242        Type *base;
     
    177250class ArrayType : public Type {
    178251  public:
    179         ArrayType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
     252        ArrayType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    180253        ArrayType( const ArrayType& );
    181254        virtual ~ArrayType();
     
    193266
    194267        virtual ArrayType *clone() const { return new ArrayType( *this ); }
    195         virtual void accept( Visitor &v ) { v.visit( this ); }
    196         virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    197         virtual void print( std::ostream &os, int indent = 0 ) const;
     268        virtual void accept( Visitor & v ) { v.visit( this ); }
     269        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
     270        virtual void print( std::ostream & os, int indent = 0 ) const;
    198271  private:
    199272        Type *base;
     
    205278class FunctionType : public Type {
    206279  public:
    207         FunctionType( const Type::Qualifiers &tq, bool isVarArgs, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
     280        FunctionType( const Type::Qualifiers & tq, bool isVarArgs, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    208281        FunctionType( const FunctionType& );
    209282        virtual ~FunctionType();
     
    216289
    217290        virtual FunctionType *clone() const { return new FunctionType( *this ); }
    218         virtual void accept( Visitor &v ) { v.visit( this ); }
    219         virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    220         virtual void print( std::ostream &os, int indent = 0 ) const;
     291        virtual void accept( Visitor & v ) { v.visit( this ); }
     292        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
     293        virtual void print( std::ostream & os, int indent = 0 ) const;
    221294  private:
    222295        std::list<DeclarationWithType*> returnVals;
     
    232305class ReferenceToType : public Type {
    233306  public:
    234         ReferenceToType( const Type::Qualifiers &tq, const std::string &name, const std::list< Attribute * > & attributes );
    235         ReferenceToType( const ReferenceToType &other );
     307        ReferenceToType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes );
     308        ReferenceToType( const ReferenceToType & other );
    236309        virtual ~ReferenceToType();
    237310
    238         const std::string &get_name() const { return name; }
     311        const std::string & get_name() const { return name; }
    239312        void set_name( std::string newValue ) { name = newValue; }
    240313        std::list< Expression* >& get_parameters() { return parameters; }
     
    243316
    244317        virtual ReferenceToType *clone() const = 0;
    245         virtual void accept( Visitor &v ) = 0;
    246         virtual Type *acceptMutator( Mutator &m ) = 0;
    247         virtual void print( std::ostream &os, int indent = 0 ) const;
     318        virtual void accept( Visitor & v ) = 0;
     319        virtual Type *acceptMutator( Mutator & m ) = 0;
     320        virtual void print( std::ostream & os, int indent = 0 ) const;
    248321  protected:
    249322        virtual std::string typeString() const = 0;
     
    257330        typedef ReferenceToType Parent;
    258331  public:
    259         StructInstType( const Type::Qualifiers &tq, const std::string &name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
    260         StructInstType( const Type::Qualifiers &tq, StructDecl * baseStruct, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
    261         StructInstType( const StructInstType &other ) : Parent( other ), baseStruct( other.baseStruct ) {}
     332        StructInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
     333        StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
     334        StructInstType( const StructInstType & other ) : Parent( other ), baseStruct( other.baseStruct ) {}
    262335
    263336        StructDecl *get_baseStruct() const { return baseStruct; }
     
    271344        /// Looks up the members of this struct named "name" and places them into "foundDecls".
    272345        /// Clones declarations into "foundDecls", caller responsible for freeing
    273         void lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const;
     346        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const;
    274347
    275348        virtual StructInstType *clone() const { return new StructInstType( *this ); }
    276         virtual void accept( Visitor &v ) { v.visit( this ); }
    277         virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    278 
    279         virtual void print( std::ostream &os, int indent = 0 ) const;
     349        virtual void accept( Visitor & v ) { v.visit( this ); }
     350        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
     351
     352        virtual void print( std::ostream & os, int indent = 0 ) const;
    280353  private:
    281354        virtual std::string typeString() const;
     
    289362        typedef ReferenceToType Parent;
    290363  public:
    291         UnionInstType( const Type::Qualifiers &tq, const std::string &name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
    292         UnionInstType( const Type::Qualifiers &tq, UnionDecl * baseUnion, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
    293         UnionInstType( const UnionInstType &other ) : Parent( other ), baseUnion( other.baseUnion ) {}
     364        UnionInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
     365        UnionInstType( const Type::Qualifiers & tq, UnionDecl * baseUnion, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
     366        UnionInstType( const UnionInstType & other ) : Parent( other ), baseUnion( other.baseUnion ) {}
    294367
    295368        UnionDecl *get_baseUnion() const { return baseUnion; }
     
    303376        /// looks up the members of this union named "name" and places them into "foundDecls"
    304377        /// Clones declarations into "foundDecls", caller responsible for freeing
    305         void lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const;
     378        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const;
    306379
    307380        virtual UnionInstType *clone() const { return new UnionInstType( *this ); }
    308         virtual void accept( Visitor &v ) { v.visit( this ); }
    309         virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    310 
    311         virtual void print( std::ostream &os, int indent = 0 ) const;
     381        virtual void accept( Visitor & v ) { v.visit( this ); }
     382        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
     383
     384        virtual void print( std::ostream & os, int indent = 0 ) const;
    312385  private:
    313386        virtual std::string typeString() const;
     
    321394        typedef ReferenceToType Parent;
    322395  public:
    323         EnumInstType( const Type::Qualifiers &tq, const std::string &name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
    324         EnumInstType( const Type::Qualifiers &tq, EnumDecl * baseEnum, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
    325         EnumInstType( const EnumInstType &other ) : Parent( other ), baseEnum( other.baseEnum ) {}
     396        EnumInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
     397        EnumInstType( const Type::Qualifiers & tq, EnumDecl * baseEnum, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
     398        EnumInstType( const EnumInstType & other ) : Parent( other ), baseEnum( other.baseEnum ) {}
    326399
    327400        EnumDecl *get_baseEnum() const { return baseEnum; }
     
    331404
    332405        virtual EnumInstType *clone() const { return new EnumInstType( *this ); }
    333         virtual void accept( Visitor &v ) { v.visit( this ); }
    334         virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     406        virtual void accept( Visitor & v ) { v.visit( this ); }
     407        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
    335408  private:
    336409        virtual std::string typeString() const;
     
    344417        typedef ReferenceToType Parent;
    345418  public:
    346         TraitInstType( const Type::Qualifiers &tq, const std::string &name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
    347         TraitInstType( const TraitInstType &other );
     419        TraitInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
     420        TraitInstType( const TraitInstType & other );
    348421        ~TraitInstType();
    349422
     
    353426
    354427        virtual TraitInstType *clone() const { return new TraitInstType( *this ); }
    355         virtual void accept( Visitor &v ) { v.visit( this ); }
    356         virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     428        virtual void accept( Visitor & v ) { v.visit( this ); }
     429        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
    357430  private:
    358431        virtual std::string typeString() const;
     
    366439        typedef ReferenceToType Parent;
    367440  public:
    368         TypeInstType( const Type::Qualifiers &tq, const std::string &name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
    369         TypeInstType( const Type::Qualifiers &tq, const std::string &name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
    370         TypeInstType( const TypeInstType &other );
     441        TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
     442        TypeInstType( const Type::Qualifiers & tq, const std::string & name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
     443        TypeInstType( const TypeInstType & other );
    371444        ~TypeInstType();
    372445
     
    379452
    380453        virtual TypeInstType *clone() const { return new TypeInstType( *this ); }
    381         virtual void accept( Visitor &v ) { v.visit( this ); }
    382         virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    383         virtual void print( std::ostream &os, int indent = 0 ) const;
     454        virtual void accept( Visitor & v ) { v.visit( this ); }
     455        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
     456        virtual void print( std::ostream & os, int indent = 0 ) const;
    384457  private:
    385458        virtual std::string typeString() const;
     
    392465class TupleType : public Type {
    393466  public:
    394         TupleType( const Type::Qualifiers &tq, const std::list< Type * > & types = std::list< Type * >(), const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
     467        TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types = std::list< Type * >(), const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
    395468        TupleType( const TupleType& );
    396469        virtual ~TupleType();
     
    413486
    414487        virtual TupleType *clone() const { return new TupleType( *this ); }
    415         virtual void accept( Visitor &v ) { v.visit( this ); }
    416         virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    417         virtual void print( std::ostream &os, int indent = 0 ) const;
     488        virtual void accept( Visitor & v ) { v.visit( this ); }
     489        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
     490        virtual void print( std::ostream & os, int indent = 0 ) const;
    418491  private:
    419492        std::list<Type*> types;
     
    422495class TypeofType : public Type {
    423496  public:
    424         TypeofType( const Type::Qualifiers &tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
     497        TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
    425498        TypeofType( const TypeofType& );
    426499        virtual ~TypeofType();
     
    432505
    433506        virtual TypeofType *clone() const { return new TypeofType( *this ); }
    434         virtual void accept( Visitor &v ) { v.visit( this ); }
    435         virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    436         virtual void print( std::ostream &os, int indent = 0 ) const;
     507        virtual void accept( Visitor & v ) { v.visit( this ); }
     508        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
     509        virtual void print( std::ostream & os, int indent = 0 ) const;
    437510  private:
    438511        Expression *expr;
     
    441514class AttrType : public Type {
    442515  public:
    443         AttrType( const Type::Qualifiers &tq, const std::string &name, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    444         AttrType( const Type::Qualifiers &tq, const std::string &name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
     516        AttrType( const Type::Qualifiers & tq, const std::string & name, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
     517        AttrType( const Type::Qualifiers & tq, const std::string & name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
    445518        AttrType( const AttrType& );
    446519        virtual ~AttrType();
    447520
    448         const std::string &get_name() const { return name; }
    449         void set_name( const std::string &newValue ) { name = newValue; }
     521        const std::string & get_name() const { return name; }
     522        void set_name( const std::string & newValue ) { name = newValue; }
    450523        Expression *get_expr() const { return expr; }
    451524        void set_expr( Expression *newValue ) { expr = newValue; }
     
    458531
    459532        virtual AttrType *clone() const { return new AttrType( *this ); }
    460         virtual void accept( Visitor &v ) { v.visit( this ); }
    461         virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    462         virtual void print( std::ostream &os, int indent = 0 ) const;
     533        virtual void accept( Visitor & v ) { v.visit( this ); }
     534        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
     535        virtual void print( std::ostream & os, int indent = 0 ) const;
    463536  private:
    464537        std::string name;
     
    477550
    478551        virtual VarArgsType *clone() const { return new VarArgsType( *this ); }
    479         virtual void accept( Visitor &v ) { v.visit( this ); }
    480         virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    481         virtual void print( std::ostream &os, int indent = 0 ) const;
     552        virtual void accept( Visitor & v ) { v.visit( this ); }
     553        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
     554        virtual void print( std::ostream & os, int indent = 0 ) const;
    482555};
    483556
     
    489562
    490563        virtual ZeroType *clone() const { return new ZeroType( *this ); }
    491         virtual void accept( Visitor &v ) { v.visit( this ); }
    492         virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    493         virtual void print( std::ostream &os, int indent = 0 ) const;
     564        virtual void accept( Visitor & v ) { v.visit( this ); }
     565        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
     566        virtual void print( std::ostream & os, int indent = 0 ) const;
    494567};
    495568
     
    501574
    502575        virtual OneType *clone() const { return new OneType( *this ); }
    503         virtual void accept( Visitor &v ) { v.visit( this ); }
    504         virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    505         virtual void print( std::ostream &os, int indent = 0 ) const;
    506 };
    507 
    508 inline Type::Qualifiers &Type::Qualifiers::operator&=( const Type::Qualifiers &other ) {
    509         isConst &= other.isConst;
    510         isVolatile &= other.isVolatile;
    511         isRestrict &= other.isRestrict;
    512         isLvalue &= other.isLvalue;
    513         isAtomic &= other.isAtomic;
    514         isMutex &= other.isMutex;
    515         return *this;
    516 }
    517 
    518 inline Type::Qualifiers &Type::Qualifiers::operator+=( const Type::Qualifiers &other ) {
    519         isConst |= other.isConst;
    520         isVolatile |= other.isVolatile;
    521         isRestrict |= other.isRestrict;
    522         isLvalue |= other.isLvalue;
    523         isAtomic |= other.isAtomic;
    524         isMutex |= other.isMutex;
    525         return *this;
    526 }
    527 
    528 inline Type::Qualifiers &Type::Qualifiers::operator-=( const Type::Qualifiers &other ) {
    529         if ( other.isConst ) isConst = 0;
    530         if ( other.isVolatile ) isVolatile = 0;
    531         if ( other.isRestrict ) isRestrict = 0;
    532         if ( other.isAtomic ) isAtomic = 0;
    533         if ( other.isMutex ) isMutex = 0;
    534         return *this;
    535 }
    536 
    537 inline Type::Qualifiers Type::Qualifiers::operator+( const Type::Qualifiers &other ) {
    538         Qualifiers q = other;
    539         q += *this;
    540         return q;
    541 }
    542 
    543 inline bool Type::Qualifiers::operator==( const Qualifiers &other ) {
    544         return isConst == other.isConst
    545                 && isVolatile == other.isVolatile
    546 //              && isRestrict == other.isRestrict
    547 //              && isLvalue == other.isLvalue
    548                 && isAtomic == other.isAtomic;
    549 }
    550 
    551 inline bool Type::Qualifiers::operator!=( const Qualifiers &other ) {
    552         return isConst != other.isConst
    553                 || isVolatile != other.isVolatile
    554 //              || isRestrict != other.isRestrict
    555 //              || isLvalue != other.isLvalue
    556                 || isAtomic != other.isAtomic;
    557 }
    558 
    559 inline bool Type::Qualifiers::operator<=( const Type::Qualifiers &other ) {
    560         return isConst <= other.isConst
    561                 && isVolatile <= other.isVolatile
    562 //              && isRestrict <= other.isRestrict
    563 //              && isLvalue >= other.isLvalue
    564                 && isAtomic == other.isAtomic;
    565 }
    566 
    567 inline bool Type::Qualifiers::operator>=( const Type::Qualifiers &other ) {
    568         return isConst >= other.isConst
    569                 && isVolatile >= other.isVolatile
    570 //              && isRestrict >= other.isRestrict
    571 //              && isLvalue <= other.isLvalue
    572                 && isAtomic == other.isAtomic;
    573 }
    574 
    575 inline bool Type::Qualifiers::operator<( const Type::Qualifiers &other ) {
    576         return operator!=( other ) && operator<=( other );
    577 }
    578 
    579 inline bool Type::Qualifiers::operator>( const Type::Qualifiers &other ) {
    580         return operator!=( other ) && operator>=( other );
    581 }
     576        virtual void accept( Visitor & v ) { v.visit( this ); }
     577        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
     578        virtual void print( std::ostream & os, int indent = 0 ) const;
     579};
    582580
    583581std::ostream & operator<<( std::ostream & out, const Type * type );
  • src/SynTree/TypeDecl.cc

    r2f26687 r1fbab5a  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Mar  7 07:39:09 2017
    13 // Update Count     : 4
     12// Last Modified On : Thu Mar 16 07:49:58 2017
     13// Update Count     : 5
    1414//
    1515
     
    1818#include "Common/utility.h"
    1919
    20 TypeDecl::TypeDecl( const std::string &name, DeclarationNode::StorageClasses scs, Type *type, Kind kind ) : Parent( name, scs, type ), kind( kind ), sized( kind == Any || kind == Ttype ) {
     20TypeDecl::TypeDecl( const std::string &name, Type::StorageClasses scs, Type *type, Kind kind ) : Parent( name, scs, type ), kind( kind ), sized( kind == Any || kind == Ttype ) {
    2121}
    2222
  • src/Tuples/TupleAssignment.cc

    r2f26687 r1fbab5a  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Mar  6 23:40:14 2017
    13 // Update Count     : 5
     12// Last Modified On : Thu Mar 16 08:04:51 2017
     13// Update Count     : 7
    1414//
    1515
     
    199199                                Type * type = InitTweak::getPointerBase( castType );
    200200                                assert( type );
    201                                 type->get_qualifiers() -= Type::Qualifiers(true, true, true, false, true, false);
     201                                type->get_qualifiers() -= Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
    202202                                type->set_isLvalue( true ); // xxx - might not need this
    203203                                expr = new CastExpr( expr, castType );
     
    240240        ObjectDecl * TupleAssignSpotter::Matcher::newObject( UniqueName & namer, Expression * expr ) {
    241241                assert( expr->has_result() && ! expr->get_result()->isVoid() );
    242                 ObjectDecl * ret = new ObjectDecl( namer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, expr->get_result()->clone(), new SingleInit( expr->clone() ) );
     242                ObjectDecl * ret = new ObjectDecl( namer.newName(), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, expr->get_result()->clone(), new SingleInit( expr->clone() ) );
    243243                ConstructorInit * ctorInit = InitTweak::genCtorInit( ret );
    244244                ret->set_init( ctorInit );
  • src/Tuples/TupleExpansion.cc

    r2f26687 r1fbab5a  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Mar  7 07:43:56 2017
    13 // Update Count     : 12
     12// Last Modified On : Thu Mar 16 08:05:17 2017
     13// Update Count     : 15
    1414//
    1515
     
    187187                        }
    188188                        BasicType * boolType = new BasicType( Type::Qualifiers(), BasicType::Bool );
    189                         ObjectDecl * finished = new ObjectDecl( toString( "_unq_expr_finished_", id ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::Bool ), new SingleInit( new ConstantExpr( Constant( boolType->clone(), "0" ) ), noDesignators ) );
     189                        ObjectDecl * finished = new ObjectDecl( toString( "_unq_expr_finished_", id ), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::Bool ), new SingleInit( new ConstantExpr( Constant( boolType->clone(), "0" ) ), noDesignators ) );
    190190                        addDeclaration( finished );
    191191                        // (finished ? _unq_expr_N : (_unq_expr_N = <unqExpr->get_expr()>, finished = 1, _unq_expr_N))
     
    221221                        decl->set_body( true );
    222222                        for ( size_t i = 0; i < tupleSize; ++i ) {
    223                                 TypeDecl * tyParam = new TypeDecl( toString( "tuple_param_", i ), DeclarationNode::StorageClasses(), nullptr, TypeDecl::Any );
    224                                 decl->get_members().push_back( new ObjectDecl( toString("field_", i ), DeclarationNode::StorageClasses(), LinkageSpec::C, nullptr, new TypeInstType( Type::Qualifiers(), tyParam->get_name(), tyParam ), nullptr ) );
     223                                TypeDecl * tyParam = new TypeDecl( toString( "tuple_param_", i ), Type::StorageClasses(), nullptr, TypeDecl::Any );
     224                                decl->get_members().push_back( new ObjectDecl( toString("field_", i ), Type::StorageClasses(), LinkageSpec::C, nullptr, new TypeInstType( Type::Qualifiers(), tyParam->get_name(), tyParam ), nullptr ) );
    225225                                decl->get_parameters().push_back( tyParam );
    226226                        }
    227227                        if ( tupleSize == 0 ) {
    228228                                // empty structs are not standard C. Add a dummy field to empty tuples to silence warnings when a compound literal Tuple0 is created.
    229                                 decl->get_members().push_back( new ObjectDecl( "dummy", DeclarationNode::StorageClasses(), LinkageSpec::C, nullptr, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) );
     229                                decl->get_members().push_back( new ObjectDecl( "dummy", Type::StorageClasses(), LinkageSpec::C, nullptr, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) );
    230230                        }
    231231                        typeMap[tupleSize] = decl;
     
    305305        Type * makeTupleType( const std::list< Expression * > & exprs ) {
    306306                // produce the TupleType which aggregates the types of the exprs
    307                 TupleType *tupleType = new TupleType( Type::Qualifiers(true, true, true, true, true, true) );
     307                TupleType *tupleType = new TupleType( Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Lvalue | Type::Atomic | Type::Mutex ) );
    308308                Type::Qualifiers &qualifiers = tupleType->get_qualifiers();
    309309                for ( Expression * expr : exprs ) {
  • src/benchmark/CorCtxSwitch.c

    r2f26687 r1fbab5a  
    11#include <fstream>
    22#include <stdlib>
    3 #include <threads>
     3#include <thread>
    44
    55#include <unistd.h>                                     // sysconf
     
    2424
    2525struct GreatSuspender {
    26         coroutine c;
     26        coroutine_desc c;
    2727};
    2828
  • src/benchmark/ThrdCtxSwitch.c

    r2f26687 r1fbab5a  
    11#include <fstream>
    22#include <stdlib>
    3 #include <threads>
     3#include <thread>
    44
    55#include <unistd.h>                                     // sysconf
  • src/benchmark/bench.c

    r2f26687 r1fbab5a  
    22#include <fstream>
    33#include <stdlib>
    4 #include <threads>
     4#include <thread>
    55
    66#include <unistd.h>                                     // sysconf
     
    8686//=======================================
    8787
    88 struct CoroutineDummy { coroutine c; };
     88struct CoroutineDummy { coroutine_desc c; };
    8989DECL_COROUTINE(CoroutineDummy);
    9090void main(CoroutineDummy * this) {}
     
    119119struct CoroutineResume {
    120120    int N;
    121     coroutine c;
     121    coroutine_desc c;
    122122};
    123123
     
    150150//=======================================
    151151
    152 struct ThreadDummy { thread t; };
     152struct ThreadDummy { thread_desc t; };
    153153DECL_THREAD(ThreadDummy);
    154154void main(ThreadDummy * this) {}
     
    180180    int N;
    181181    long long result;
    182     thread t;
     182    thread_desc t;
    183183};
    184184
  • src/benchmark/csv-data.c

    r2f26687 r1fbab5a  
    11#include <fstream>
    22#include <stdlib>
    3 #include <threads>
     3#include <thread>
    44
    55extern "C" {
     
    2626
    2727struct GreatSuspender {
    28         coroutine c;
     28        coroutine_desc c;
    2929};
    3030
  • src/examples/multicore.c

    r2f26687 r1fbab5a  
    11#include <kernel>
    2 #include <threads>
     2#include <thread>
    33
    4 struct MyThread { thread t; };
     4struct MyThread { thread_desc t; };
    55
    66DECL_THREAD(MyThread);
  • src/libcfa/Makefile.am

    r2f26687 r1fbab5a  
    4545# not all platforms support concurrency, add option do disable it
    4646if BUILD_CONCURRENCY
    47 headers += containers/vector concurrency/coroutines concurrency/threads concurrency/kernel concurrency/monitor
     47headers += containers/vector concurrency/coroutine concurrency/thread concurrency/kernel concurrency/monitor
    4848endif
    4949
  • src/libcfa/Makefile.in

    r2f26687 r1fbab5a  
    4343
    4444# not all platforms support concurrency, add option do disable it
    45 @BUILD_CONCURRENCY_TRUE@am__append_3 = containers/vector concurrency/coroutines concurrency/threads concurrency/kernel concurrency/monitor
     45@BUILD_CONCURRENCY_TRUE@am__append_3 = containers/vector concurrency/coroutine concurrency/thread concurrency/kernel concurrency/monitor
    4646
    4747# not all platforms support concurrency, add option do disable it
     
    9999am__libcfa_d_a_SOURCES_DIST = libcfa-prelude.c limits.c stdlib.c \
    100100        math.c iostream.c fstream.c iterator.c rational.c assert.c \
    101         containers/vector.c concurrency/coroutines.c \
    102         concurrency/threads.c concurrency/kernel.c \
     101        containers/vector.c concurrency/coroutine.c \
     102        concurrency/thread.c concurrency/kernel.c \
    103103        concurrency/monitor.c concurrency/CtxSwitch-@MACHINE_TYPE@.S \
    104104        concurrency/invoke.c
    105105am__dirstamp = $(am__leading_dot)dirstamp
    106106@BUILD_CONCURRENCY_TRUE@am__objects_1 = containers/libcfa_d_a-vector.$(OBJEXT) \
    107 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-coroutines.$(OBJEXT) \
    108 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-threads.$(OBJEXT) \
     107@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-coroutine.$(OBJEXT) \
     108@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-thread.$(OBJEXT) \
    109109@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-kernel.$(OBJEXT) \
    110110@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-monitor.$(OBJEXT)
     
    124124am__libcfa_a_SOURCES_DIST = libcfa-prelude.c limits.c stdlib.c math.c \
    125125        iostream.c fstream.c iterator.c rational.c assert.c \
    126         containers/vector.c concurrency/coroutines.c \
    127         concurrency/threads.c concurrency/kernel.c \
     126        containers/vector.c concurrency/coroutine.c \
     127        concurrency/thread.c concurrency/kernel.c \
    128128        concurrency/monitor.c concurrency/CtxSwitch-@MACHINE_TYPE@.S \
    129129        concurrency/invoke.c
    130130@BUILD_CONCURRENCY_TRUE@am__objects_5 =  \
    131131@BUILD_CONCURRENCY_TRUE@        containers/libcfa_a-vector.$(OBJEXT) \
    132 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-coroutines.$(OBJEXT) \
    133 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-threads.$(OBJEXT) \
     132@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-coroutine.$(OBJEXT) \
     133@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-thread.$(OBJEXT) \
    134134@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-kernel.$(OBJEXT) \
    135135@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-monitor.$(OBJEXT)
     
    175175am__nobase_cfa_include_HEADERS_DIST = limits stdlib math iostream \
    176176        fstream iterator rational assert containers/vector \
    177         concurrency/coroutines concurrency/threads concurrency/kernel \
     177        concurrency/coroutine concurrency/thread concurrency/kernel \
    178178        concurrency/monitor ${shell echo stdhdr/*} \
    179179        concurrency/invoke.h
     
    397397        @$(MKDIR_P) concurrency/$(DEPDIR)
    398398        @: > concurrency/$(DEPDIR)/$(am__dirstamp)
    399 concurrency/libcfa_d_a-coroutines.$(OBJEXT):  \
     399concurrency/libcfa_d_a-coroutine.$(OBJEXT):  \
    400400        concurrency/$(am__dirstamp) \
    401401        concurrency/$(DEPDIR)/$(am__dirstamp)
    402 concurrency/libcfa_d_a-threads.$(OBJEXT): concurrency/$(am__dirstamp) \
     402concurrency/libcfa_d_a-thread.$(OBJEXT): concurrency/$(am__dirstamp) \
    403403        concurrency/$(DEPDIR)/$(am__dirstamp)
    404404concurrency/libcfa_d_a-kernel.$(OBJEXT): concurrency/$(am__dirstamp) \
     
    417417containers/libcfa_a-vector.$(OBJEXT): containers/$(am__dirstamp) \
    418418        containers/$(DEPDIR)/$(am__dirstamp)
    419 concurrency/libcfa_a-coroutines.$(OBJEXT):  \
    420         concurrency/$(am__dirstamp) \
     419concurrency/libcfa_a-coroutine.$(OBJEXT): concurrency/$(am__dirstamp) \
    421420        concurrency/$(DEPDIR)/$(am__dirstamp)
    422 concurrency/libcfa_a-threads.$(OBJEXT): concurrency/$(am__dirstamp) \
     421concurrency/libcfa_a-thread.$(OBJEXT): concurrency/$(am__dirstamp) \
    423422        concurrency/$(DEPDIR)/$(am__dirstamp)
    424423concurrency/libcfa_a-kernel.$(OBJEXT): concurrency/$(am__dirstamp) \
     
    436435        -rm -f *.$(OBJEXT)
    437436        -rm -f concurrency/CtxSwitch-@MACHINE_TYPE@.$(OBJEXT)
    438         -rm -f concurrency/libcfa_a-coroutines.$(OBJEXT)
     437        -rm -f concurrency/libcfa_a-coroutine.$(OBJEXT)
    439438        -rm -f concurrency/libcfa_a-invoke.$(OBJEXT)
    440439        -rm -f concurrency/libcfa_a-kernel.$(OBJEXT)
    441440        -rm -f concurrency/libcfa_a-monitor.$(OBJEXT)
    442         -rm -f concurrency/libcfa_a-threads.$(OBJEXT)
    443         -rm -f concurrency/libcfa_d_a-coroutines.$(OBJEXT)
     441        -rm -f concurrency/libcfa_a-thread.$(OBJEXT)
     442        -rm -f concurrency/libcfa_d_a-coroutine.$(OBJEXT)
    444443        -rm -f concurrency/libcfa_d_a-invoke.$(OBJEXT)
    445444        -rm -f concurrency/libcfa_d_a-kernel.$(OBJEXT)
    446445        -rm -f concurrency/libcfa_d_a-monitor.$(OBJEXT)
    447         -rm -f concurrency/libcfa_d_a-threads.$(OBJEXT)
     446        -rm -f concurrency/libcfa_d_a-thread.$(OBJEXT)
    448447        -rm -f containers/libcfa_a-vector.$(OBJEXT)
    449448        -rm -f containers/libcfa_d_a-vector.$(OBJEXT)
     
    471470@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-stdlib.Po@am__quote@
    472471@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/CtxSwitch-@MACHINE_TYPE@.Po@am__quote@
    473 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-coroutines.Po@am__quote@
     472@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-coroutine.Po@am__quote@
    474473@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-invoke.Po@am__quote@
    475474@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-kernel.Po@am__quote@
    476475@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-monitor.Po@am__quote@
    477 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-threads.Po@am__quote@
    478 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-coroutines.Po@am__quote@
     476@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-thread.Po@am__quote@
     477@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-coroutine.Po@am__quote@
    479478@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-invoke.Po@am__quote@
    480479@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-kernel.Po@am__quote@
    481480@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-monitor.Po@am__quote@
    482 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-threads.Po@am__quote@
     481@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-thread.Po@am__quote@
    483482@AMDEP_TRUE@@am__include@ @am__quote@containers/$(DEPDIR)/libcfa_a-vector.Po@am__quote@
    484483@AMDEP_TRUE@@am__include@ @am__quote@containers/$(DEPDIR)/libcfa_d_a-vector.Po@am__quote@
     
    649648@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`
    650649
    651 concurrency/libcfa_d_a-coroutines.o: concurrency/coroutines.c
    652 @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
    653 @am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-coroutines.Tpo concurrency/$(DEPDIR)/libcfa_d_a-coroutines.Po
    654 @AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/coroutines.c' object='concurrency/libcfa_d_a-coroutines.o' libtool=no @AMDEPBACKSLASH@
    655 @AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    656 @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
    657 
    658 concurrency/libcfa_d_a-coroutines.obj: concurrency/coroutines.c
    659 @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`
    660 @am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-coroutines.Tpo concurrency/$(DEPDIR)/libcfa_d_a-coroutines.Po
    661 @AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/coroutines.c' object='concurrency/libcfa_d_a-coroutines.obj' libtool=no @AMDEPBACKSLASH@
    662 @AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    663 @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`
    664 
    665 concurrency/libcfa_d_a-threads.o: concurrency/threads.c
    666 @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
    667 @am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-threads.Tpo concurrency/$(DEPDIR)/libcfa_d_a-threads.Po
    668 @AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/threads.c' object='concurrency/libcfa_d_a-threads.o' libtool=no @AMDEPBACKSLASH@
    669 @AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    670 @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
    671 
    672 concurrency/libcfa_d_a-threads.obj: concurrency/threads.c
    673 @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`
    674 @am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-threads.Tpo concurrency/$(DEPDIR)/libcfa_d_a-threads.Po
    675 @AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/threads.c' object='concurrency/libcfa_d_a-threads.obj' libtool=no @AMDEPBACKSLASH@
    676 @AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    677 @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`
     650concurrency/libcfa_d_a-coroutine.o: concurrency/coroutine.c
     651@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
     652@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-coroutine.Tpo concurrency/$(DEPDIR)/libcfa_d_a-coroutine.Po
     653@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/coroutine.c' object='concurrency/libcfa_d_a-coroutine.o' libtool=no @AMDEPBACKSLASH@
     654@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     655@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
     656
     657concurrency/libcfa_d_a-coroutine.obj: concurrency/coroutine.c
     658@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`
     659@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-coroutine.Tpo concurrency/$(DEPDIR)/libcfa_d_a-coroutine.Po
     660@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/coroutine.c' object='concurrency/libcfa_d_a-coroutine.obj' libtool=no @AMDEPBACKSLASH@
     661@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     662@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`
     663
     664concurrency/libcfa_d_a-thread.o: concurrency/thread.c
     665@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
     666@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-thread.Tpo concurrency/$(DEPDIR)/libcfa_d_a-thread.Po
     667@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/thread.c' object='concurrency/libcfa_d_a-thread.o' libtool=no @AMDEPBACKSLASH@
     668@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     669@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
     670
     671concurrency/libcfa_d_a-thread.obj: concurrency/thread.c
     672@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`
     673@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-thread.Tpo concurrency/$(DEPDIR)/libcfa_d_a-thread.Po
     674@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/thread.c' object='concurrency/libcfa_d_a-thread.obj' libtool=no @AMDEPBACKSLASH@
     675@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     676@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`
    678677
    679678concurrency/libcfa_d_a-kernel.o: concurrency/kernel.c
     
    845844@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`
    846845
    847 concurrency/libcfa_a-coroutines.o: concurrency/coroutines.c
    848 @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
    849 @am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-coroutines.Tpo concurrency/$(DEPDIR)/libcfa_a-coroutines.Po
    850 @AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/coroutines.c' object='concurrency/libcfa_a-coroutines.o' libtool=no @AMDEPBACKSLASH@
    851 @AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    852 @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
    853 
    854 concurrency/libcfa_a-coroutines.obj: concurrency/coroutines.c
    855 @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`
    856 @am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-coroutines.Tpo concurrency/$(DEPDIR)/libcfa_a-coroutines.Po
    857 @AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/coroutines.c' object='concurrency/libcfa_a-coroutines.obj' libtool=no @AMDEPBACKSLASH@
    858 @AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    859 @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`
    860 
    861 concurrency/libcfa_a-threads.o: concurrency/threads.c
    862 @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
    863 @am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-threads.Tpo concurrency/$(DEPDIR)/libcfa_a-threads.Po
    864 @AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/threads.c' object='concurrency/libcfa_a-threads.o' libtool=no @AMDEPBACKSLASH@
    865 @AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    866 @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
    867 
    868 concurrency/libcfa_a-threads.obj: concurrency/threads.c
    869 @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`
    870 @am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-threads.Tpo concurrency/$(DEPDIR)/libcfa_a-threads.Po
    871 @AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/threads.c' object='concurrency/libcfa_a-threads.obj' libtool=no @AMDEPBACKSLASH@
    872 @AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    873 @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`
     846concurrency/libcfa_a-coroutine.o: concurrency/coroutine.c
     847@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
     848@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-coroutine.Tpo concurrency/$(DEPDIR)/libcfa_a-coroutine.Po
     849@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/coroutine.c' object='concurrency/libcfa_a-coroutine.o' libtool=no @AMDEPBACKSLASH@
     850@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     851@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
     852
     853concurrency/libcfa_a-coroutine.obj: concurrency/coroutine.c
     854@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`
     855@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-coroutine.Tpo concurrency/$(DEPDIR)/libcfa_a-coroutine.Po
     856@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/coroutine.c' object='concurrency/libcfa_a-coroutine.obj' libtool=no @AMDEPBACKSLASH@
     857@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     858@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`
     859
     860concurrency/libcfa_a-thread.o: concurrency/thread.c
     861@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
     862@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-thread.Tpo concurrency/$(DEPDIR)/libcfa_a-thread.Po
     863@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/thread.c' object='concurrency/libcfa_a-thread.o' libtool=no @AMDEPBACKSLASH@
     864@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     865@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
     866
     867concurrency/libcfa_a-thread.obj: concurrency/thread.c
     868@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`
     869@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-thread.Tpo concurrency/$(DEPDIR)/libcfa_a-thread.Po
     870@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/thread.c' object='concurrency/libcfa_a-thread.obj' libtool=no @AMDEPBACKSLASH@
     871@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     872@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`
    874873
    875874concurrency/libcfa_a-kernel.o: concurrency/kernel.c
  • src/libcfa/concurrency/coroutine

    r2f26687 r1fbab5a  
    66// file "LICENCE" distributed with Cforall.
    77//
    8 // coroutines --
     8// coroutine --
    99//
    1010// Author           : Thierry Delisle
     
    2727trait is_coroutine(dtype T) {
    2828      void main(T * this);
    29       coroutine * get_coroutine(T * this);
     29      coroutine_desc * get_coroutine(T * this);
    3030};
    3131
    32 #define DECL_COROUTINE(X) static inline coroutine* get_coroutine(X* this) { return &this->c; } void main(X* this)
     32#define DECL_COROUTINE(X) static inline coroutine_desc* get_coroutine(X* this) { return &this->c; } void main(X* this)
    3333
    3434//-----------------------------------------------------------------------------
    3535// Ctors and dtors
    3636void ?{}(coStack_t * this);
    37 void ?{}(coroutine * this);
    38 void ?{}(coroutine * this, const char * name);
     37void ?{}(coroutine_desc * this);
     38void ?{}(coroutine_desc * this, const char * name);
    3939void ^?{}(coStack_t * this);
    40 void ^?{}(coroutine * this);
     40void ^?{}(coroutine_desc * this);
    4141
    4242//-----------------------------------------------------------------------------
     
    6363
    6464// Get current coroutine
    65 coroutine * this_coroutine(void);
     65coroutine_desc * this_coroutine(void);
    6666
    6767// Private wrappers for context switch and stack creation
    68 extern void CoroutineCtxSwitch(coroutine * src, coroutine * dst);
     68extern void CoroutineCtxSwitch(coroutine_desc * src, coroutine_desc * dst);
    6969extern void create_stack( coStack_t * this, unsigned int storageSize );
    7070
    7171// Suspend implementation inlined for performance
    7272static inline void suspend() {
    73       coroutine * src = this_coroutine();               // optimization
     73      coroutine_desc * src = this_coroutine();          // optimization
    7474
    7575        assertf( src->last != 0,
     
    8888forall(dtype T | is_coroutine(T))
    8989static inline void resume(T * cor) {
    90         coroutine * src = this_coroutine();             // optimization
    91         coroutine * dst = get_coroutine(cor);
     90        coroutine_desc * src = this_coroutine();                // optimization
     91        coroutine_desc * dst = get_coroutine(cor);
    9292
    9393      if( unlikely(!dst->stack.base) ) {
     
    111111}
    112112
    113 static inline void resume(coroutine * dst) {
    114         coroutine * src = this_coroutine();             // optimization
     113static inline void resume(coroutine_desc * dst) {
     114        coroutine_desc * src = this_coroutine();                // optimization
    115115
    116116      // not resuming self ?
  • src/libcfa/concurrency/coroutine.c

    r2f26687 r1fbab5a  
    66// file "LICENCE" distributed with Cforall.
    77//
    8 // coroutines.c --
     8// coroutine.c --
    99//
    1010// Author           : Thierry Delisle
     
    1515//
    1616
    17 #include "coroutines"
     17#include "coroutine"
    1818
    1919extern "C" {
     
    3232#include "invoke.h"
    3333
    34 extern processor * get_this_processor();
     34extern thread_local processor * this_processor;
    3535
    3636//-----------------------------------------------------------------------------
     
    6060}
    6161
    62 void ?{}(coroutine* this) {
     62void ?{}(coroutine_desc* this) {
    6363        this{ "Anonymous Coroutine" };
    6464}
    6565
    66 void ?{}(coroutine* this, const char * name) {
     66void ?{}(coroutine_desc* this, const char * name) {
    6767        this->name = name;
    6868        this->errno_ = 0;
     
    7272}
    7373
    74 void ?{}(coroutine* this, size_t size) {
     74void ?{}(coroutine_desc* this, size_t size) {
    7575        this{};
    7676        (&this->stack){size};
     
    8888}
    8989
    90 void ^?{}(coroutine* this) {}
     90void ^?{}(coroutine_desc* this) {}
    9191
    9292// Part of the Public API
     
    9494forall(dtype T | is_coroutine(T))
    9595void prime(T* cor) {
    96         coroutine* this = get_coroutine(cor);
     96        coroutine_desc* this = get_coroutine(cor);
    9797        assert(this->state == Start);
    9898
     
    102102
    103103// Wrapper for co
    104 void CoroutineCtxSwitch(coroutine* src, coroutine* dst) {
     104void CoroutineCtxSwitch(coroutine_desc* src, coroutine_desc* dst) {
    105105        // THREAD_GETMEM( This )->disableInterrupts();
    106106
     
    109109
    110110        // set new coroutine that task is executing
    111         get_this_processor()->current_coroutine = dst;                 
     111        this_processor->current_coroutine = dst;
    112112
    113113        // context switch to specified coroutine
  • src/libcfa/concurrency/invoke.c

    r2f26687 r1fbab5a  
    2929
    3030extern void __suspend_internal(void);
    31 extern void __thread_signal_termination(struct thread*);
     31extern void __thread_signal_termination(struct thread_desc*);
    3232
    3333void CtxInvokeCoroutine(
    3434      void (*main)(void *),
    35       struct coroutine *(*get_coroutine)(void *),
     35      struct coroutine_desc *(*get_coroutine)(void *),
    3636      void *this
    3737) {
    3838      // LIB_DEBUG_PRINTF("Invoke Coroutine : Received %p (main %p, get_c %p)\n", this, main, get_coroutine);
    3939
    40       struct coroutine* cor = get_coroutine( this );
     40      struct coroutine_desc* cor = get_coroutine( this );
    4141
    4242      if(cor->state == Primed) {
     
    5757void CtxInvokeThread(
    5858      void (*main)(void *),
    59       struct thread *(*get_thread)(void *),
     59      struct thread_desc *(*get_thread)(void *),
    6060      void *this
    6161) {
    6262      __suspend_internal();
    6363
    64       struct thread* thrd = get_thread( this );
    65       struct coroutine* cor = &thrd->c;
     64      struct thread_desc* thrd = get_thread( this );
     65      struct coroutine_desc* cor = &thrd->c;
    6666      cor->state = Active;
    6767
     
    7979void CtxStart(
    8080      void (*main)(void *),
    81       struct coroutine *(*get_coroutine)(void *),
     81      struct coroutine_desc *(*get_coroutine)(void *),
    8282      void *this,
    8383      void (*invoke)(void *)
  • src/libcfa/concurrency/invoke.h

    r2f26687 r1fbab5a  
    3535
    3636      struct simple_thread_list {
    37             struct thread * head;
    38             struct thread ** tail;
     37            struct thread_desc * head;
     38            struct thread_desc ** tail;
    3939      };
    4040
     
    4848      extern "Cforall" {
    4949            void ?{}( struct simple_thread_list * );
    50             void append( struct simple_thread_list *, struct thread * );
    51             struct thread * pop_head( struct simple_thread_list * );
     50            void append( struct simple_thread_list *, struct thread_desc * );
     51            struct thread_desc * pop_head( struct simple_thread_list * );
    5252
    5353            void ?{}(spinlock * this);
     
    7171      enum coroutine_state { Halted, Start, Inactive, Active, Primed };
    7272
    73       struct coroutine {
     73      struct coroutine_desc {
    7474            struct coStack_t stack;
    7575            const char *name;                         // textual name for coroutine/task, initialized by uC++ generated code
    7676            int errno_;                               // copy of global UNIX variable errno
    7777            enum coroutine_state state;       // current execution status for coroutine
    78             struct coroutine *starter;        // first coroutine to resume this one
    79             struct coroutine *last;                   // last coroutine to resume this one
     78            struct coroutine_desc *starter;           // first coroutine to resume this one
     79            struct coroutine_desc *last;                      // last coroutine to resume this one
    8080      };
    8181
    82       struct thread {
    83             struct coroutine c;                 // coroutine body used to store context
     82      struct thread_desc {
     83            struct coroutine_desc c;                 // coroutine body used to store context
    8484            struct signal_once terminated;      // indicate if execuation state is not halted
    85             struct thread * next;               // instrusive link field for threads
     85            struct thread_desc * next;               // instrusive link field for threads
    8686      };
    8787
  • src/libcfa/concurrency/kernel

    r2f26687 r1fbab5a  
    66// file "LICENCE" distributed with Cforall.
    77//
    8 // threads --
     8// kernel --
    99//
    1010// Author           : Thierry Delisle
     
    4949struct FinishAction {
    5050        FinishOpCode action_code;
    51         thread * thrd;
     51        thread_desc * thrd;
    5252        spinlock * lock;
    5353};
     
    6262        struct processorCtx_t * runner;
    6363        cluster * cltr;
    64         coroutine * current_coroutine;
    65         thread * current_thread;
     64        coroutine_desc * current_coroutine;
     65        thread_desc * current_thread;
    6666        pthread_t kernel_thread;
    6767       
  • src/libcfa/concurrency/kernel.c

    r2f26687 r1fbab5a  
    4343KERNEL_STORAGE(cluster, systemCluster);
    4444KERNEL_STORAGE(processor, systemProcessor);
    45 KERNEL_STORAGE(thread, mainThread);
     45KERNEL_STORAGE(thread_desc, mainThread);
    4646KERNEL_STORAGE(machine_context_t, mainThread_context);
    4747
    4848cluster * systemCluster;
    4949processor * systemProcessor;
    50 thread * mainThread;
     50thread_desc * mainThread;
    5151
    5252//-----------------------------------------------------------------------------
     
    5555thread_local processor * this_processor;
    5656
    57 processor * get_this_processor() {
    58         return this_processor;
    59 }
    60 
    61 coroutine * this_coroutine(void) {
     57coroutine_desc * this_coroutine(void) {
    6258        return this_processor->current_coroutine;
    6359}
    6460
    65 thread * this_thread(void) {
     61thread_desc * this_thread(void) {
    6662        return this_processor->current_thread;
    6763}
     
    10399}
    104100
    105 void ?{}( coroutine * this, current_stack_info_t * info) {
     101void ?{}( coroutine_desc * this, current_stack_info_t * info) {
    106102        (&this->stack){ info };
    107103        this->name = "Main Thread";
     
    110106}
    111107
    112 void ?{}( thread * this, current_stack_info_t * info) {
     108void ?{}( thread_desc * this, current_stack_info_t * info) {
    113109        (&this->c){ info };
    114110}
     
    179175        LIB_DEBUG_PRINTF("Kernel : core %p starting\n", this);
    180176
    181         thread * readyThread = NULL;
     177        thread_desc * readyThread = NULL;
    182178        for( unsigned int spin_count = 0; ! this->is_terminated; spin_count++ )
    183179        {
     
    206202// runThread runs a thread by context switching
    207203// from the processor coroutine to the target thread
    208 void runThread(processor * this, thread * dst) {
    209         coroutine * proc_cor = get_coroutine(this->runner);
    210         coroutine * thrd_cor = get_coroutine(dst);
     204void runThread(processor * this, thread_desc * dst) {
     205        coroutine_desc * proc_cor = get_coroutine(this->runner);
     206        coroutine_desc * thrd_cor = get_coroutine(dst);
    211207       
    212208        //Reset the terminating actions here
     
    297293//-----------------------------------------------------------------------------
    298294// Scheduler routines
    299 void ScheduleThread( thread * thrd ) {
     295void ScheduleThread( thread_desc * thrd ) {
    300296        assertf( thrd->next == NULL, "Expected null got %p", thrd->next );
    301297       
     
    305301}
    306302
    307 thread * nextThread(cluster * this) {
     303thread_desc * nextThread(cluster * this) {
    308304        lock( &this->lock );
    309         thread * head = pop_head( &this->ready_queue );
     305        thread_desc * head = pop_head( &this->ready_queue );
    310306        unlock( &this->lock );
    311307        return head;
     
    317313
    318314void ScheduleInternal( spinlock * lock ) {
    319         get_this_processor()->finish.action_code = Release;
    320         get_this_processor()->finish.lock = lock;
     315        this_processor->finish.action_code = Release;
     316        this_processor->finish.lock = lock;
    321317        suspend();
    322318}
    323319
    324 void ScheduleInternal( thread * thrd ) {
    325         get_this_processor()->finish.action_code = Schedule;
    326         get_this_processor()->finish.thrd = thrd;
     320void ScheduleInternal( thread_desc * thrd ) {
     321        this_processor->finish.action_code = Schedule;
     322        this_processor->finish.thrd = thrd;
    327323        suspend();
    328324}
    329325
    330 void ScheduleInternal( spinlock * lock, thread * thrd ) {
    331         get_this_processor()->finish.action_code = Release_Schedule;
    332         get_this_processor()->finish.lock = lock;
    333         get_this_processor()->finish.thrd = thrd;
     326void ScheduleInternal( spinlock * lock, thread_desc * thrd ) {
     327        this_processor->finish.action_code = Release_Schedule;
     328        this_processor->finish.lock = lock;
     329        this_processor->finish.thrd = thrd;
    334330        suspend();
    335331}
     
    343339        // SKULLDUGGERY: the mainThread steals the process main thread
    344340        // which will then be scheduled by the systemProcessor normally
    345         mainThread = (thread *)&mainThread_storage;
     341        mainThread = (thread_desc *)&mainThread_storage;
    346342        current_stack_info_t info;
    347343        mainThread{ &info };
     
    440436                this->condition = true;
    441437
    442                 thread * it;
     438                thread_desc * it;
    443439                while( it = pop_head( &this->blocked) ) {
    444440                        ScheduleThread( it );
     
    455451}
    456452
    457 void append( simple_thread_list * this, thread * t ) {
     453void append( simple_thread_list * this, thread_desc * t ) {
    458454        assert(this->tail != NULL);
    459455        *this->tail = t;
     
    461457}
    462458
    463 thread * pop_head( simple_thread_list * this ) {
    464         thread * head = this->head;
     459thread_desc * pop_head( simple_thread_list * this ) {
     460        thread_desc * head = this->head;
    465461        if( head ) {
    466462                this->head = head->next;
  • src/libcfa/concurrency/kernel_private.h

    r2f26687 r1fbab5a  
    66// file "LICENCE" distributed with Cforall.
    77//
    8 // threads --
     8// kernel_private.h --
    99//
    1010// Author           : Thierry Delisle
     
    1919
    2020#include "kernel"
    21 #include "threads"
     21#include "thread"
    2222
    2323//-----------------------------------------------------------------------------
    2424// Scheduler
    25 void ScheduleThread( thread * );
    26 thread * nextThread(cluster * this);
     25void ScheduleThread( thread_desc * );
     26thread_desc * nextThread(cluster * this);
    2727
    2828void ScheduleInternal();
    2929void ScheduleInternal(spinlock * lock);
    30 void ScheduleInternal(thread * thrd);
    31 void ScheduleInternal(spinlock * lock, thread * thrd);
     30void ScheduleInternal(thread_desc * thrd);
     31void ScheduleInternal(spinlock * lock, thread_desc * thrd);
    3232
    3333//-----------------------------------------------------------------------------
     
    3535struct processorCtx_t {
    3636        processor * proc;
    37         coroutine c;
     37        coroutine_desc c;
    3838};
    3939
     
    4242void main(processorCtx_t *);
    4343void start(processor * this);
    44 void runThread(processor * this, thread * dst);
     44void runThread(processor * this, thread_desc * dst);
    4545void finishRunning(processor * this);
    4646void spin(processor * this, unsigned int * spin_count);
     
    5353}
    5454
    55 extern void ThreadCtxSwitch(coroutine * src, coroutine * dst);
     55extern void ThreadCtxSwitch(coroutine_desc * src, coroutine_desc * dst);
    5656
    5757#endif //KERNEL_PRIVATE_H
  • src/libcfa/concurrency/monitor

    r2f26687 r1fbab5a  
    2222#include "stdlib"
    2323
    24 struct __monitor_t {
     24struct monitor_desc {
    2525        spinlock lock;
    26         thread * owner;
     26        thread_desc * owner;
    2727        simple_thread_list entry_queue;
    2828        unsigned int recursion;
    2929};
    3030
    31 static inline void ?{}(__monitor_t * this) {
     31static inline void ?{}(monitor_desc * this) {
    3232        this->owner = 0;
    3333        this->recursion = 0;
     
    3535
    3636//Basic entering routine
    37 void enter(__monitor_t *);
    38 void leave(__monitor_t *);
     37void enter(monitor_desc *);
     38void leave(monitor_desc *);
    3939
    4040//Array entering routine
    41 void enter(__monitor_t **, int count);
    42 void leave(__monitor_t **, int count);
     41void enter(monitor_desc **, int count);
     42void leave(monitor_desc **, int count);
    4343
    4444struct monitor_guard_t {
    45         __monitor_t ** m;
     45        monitor_desc ** m;
    4646        int count;
    4747};
    4848
    49 static inline int ?<?(__monitor_t* lhs, __monitor_t* rhs) {
     49static inline int ?<?(monitor_desc* lhs, monitor_desc* rhs) {
    5050        return ((intptr_t)lhs) < ((intptr_t)rhs);
    5151}
    5252
    53 static inline void ?{}( monitor_guard_t * this, __monitor_t ** m ) {
     53static inline void ?{}( monitor_guard_t * this, monitor_desc ** m ) {
    5454        this->m = m;
    5555        this->count = 1;
     
    5757}
    5858
    59 static inline void ?{}( monitor_guard_t * this, __monitor_t ** m, int count ) {
     59static inline void ?{}( monitor_guard_t * this, monitor_desc ** m, int count ) {
    6060        this->m = m;
    6161        this->count = count;
  • src/libcfa/concurrency/monitor.c

    r2f26687 r1fbab5a  
    66// file "LICENCE" distributed with Cforall.
    77//
    8 // __monitor_t.c --
     8// monitor_desc.c --
    99//
    1010// Author           : Thierry Delisle
     
    1919#include "kernel_private.h"
    2020
    21 void enter(__monitor_t * this) {
     21void enter(monitor_desc * this) {
    2222        lock( &this->lock );
    23         thread * thrd = this_thread();
     23        thread_desc * thrd = this_thread();
    2424
    2525        if( !this->owner ) {
     
    4545}
    4646
    47 void leave(__monitor_t * this) {
     47void leave(monitor_desc * this) {
    4848        lock( &this->lock );
    4949
    50         thread * thrd = this_thread();
     50        thread_desc * thrd = this_thread();
    5151        assert( thrd == this->owner );
    5252
     
    5555
    5656        //If we left the last level of recursion it means we are changing who owns the monitor
    57         thread * new_owner = 0;
     57        thread_desc * new_owner = 0;
    5858        if( this->recursion == 0) {
    5959                //Get the next thread in the list
     
    7272}
    7373
    74 void enter(__monitor_t ** monitors, int count) {
     74void enter(monitor_desc ** monitors, int count) {
    7575        for(int i = 0; i < count; i++) {
    7676                // printf("%d\n", i);
     
    7979}
    8080
    81 void leave(__monitor_t ** monitors, int count) {
     81void leave(monitor_desc ** monitors, int count) {
    8282        for(int i = count - 1; i >= 0; i--) {
    8383                // printf("%d\n", i);
  • src/libcfa/concurrency/thread

    r2f26687 r1fbab5a  
    66// file "LICENCE" distributed with Cforall.
    77//
    8 // threads --
     8// thread --
    99//
    1010// Author           : Thierry Delisle
     
    2121#include "invoke.h"
    2222
    23 #include "coroutines"
     23#include "coroutine"
    2424
    2525//-----------------------------------------------------------------------------
     
    2929trait is_thread(dtype T) {
    3030      void main(T* this);
    31       thread* get_thread(T* this);
     31      thread_desc* get_thread(T* this);
    3232};
    3333
    34 #define DECL_THREAD(X) thread* get_thread(X* this) { return &this->t; } void main(X* this)
     34#define DECL_THREAD(X) thread_desc* get_thread(X* this) { return &this->t; } void main(X* this)
    3535
    3636forall( dtype T | is_thread(T) )
    37 static inline coroutine* get_coroutine(T* this) {
     37static inline coroutine_desc* get_coroutine(T* this) {
    3838        return &get_thread(this)->c;
    3939}
    4040
    41 static inline coroutine* get_coroutine(thread* this) {
     41static inline coroutine_desc* get_coroutine(thread_desc* this) {
    4242        return &this->c;
    4343}
    4444
    45 thread * this_thread(void);
     45thread_desc * this_thread(void);
    4646
    4747//-----------------------------------------------------------------------------
    4848// Ctors and dtors
    49 void ?{}(thread* this);
    50 void ^?{}(thread* this);
     49void ?{}(thread_desc* this);
     50void ^?{}(thread_desc* this);
    5151
    5252//-----------------------------------------------------------------------------
  • src/libcfa/concurrency/thread.c

    r2f26687 r1fbab5a  
    66// file "LICENCE" distributed with Cforall.
    77//
    8 // threads.c --
     8// thread.c --
    99//
    1010// Author           : Thierry Delisle
     
    1515//
    1616
    17 #include "threads"
     17#include "thread"
    1818
    1919#include "kernel_private.h"
     
    2828}
    2929
    30 extern processor * get_this_processor();
     30extern thread_local processor * this_processor;
    3131
    3232//-----------------------------------------------------------------------------
     
    4141// Thread ctors and dtors
    4242
    43 void ?{}(thread* this) {
     43void ?{}(thread_desc* this) {
    4444        (&this->c){};
    4545        this->c.name = "Anonymous Coroutine";
     
    4848}
    4949
    50 void ^?{}(thread* this) {
     50void ^?{}(thread_desc* this) {
    5151        ^(&this->c){};
    5252}
     
    7474forall( dtype T | is_thread(T) )
    7575void start( T* this ) {
    76         coroutine* thrd_c = get_coroutine(this);
    77         thread*  thrd_h = get_thread   (this);
     76        coroutine_desc* thrd_c = get_coroutine(this);
     77        thread_desc*  thrd_h = get_thread   (this);
    7878        thrd_c->last = this_coroutine();
    79         get_this_processor()->current_coroutine = thrd_c;
     79        this_processor->current_coroutine = thrd_c;
    8080
    8181        LIB_DEBUG_PRINTF("Thread start : %p (t %p, c %p)\n", this, thrd_c, thrd_h);
     
    9494
    9595void yield( void ) {
    96         ScheduleInternal( get_this_processor()->current_thread );
     96        ScheduleInternal( this_processor->current_thread );
    9797}
    9898
    99 void ThreadCtxSwitch(coroutine* src, coroutine* dst) {
     99void ThreadCtxSwitch(coroutine_desc* src, coroutine_desc* dst) {
    100100        // set state of current coroutine to inactive
    101101        src->state = Inactive;
     
    107107        // set new coroutine that the processor is executing
    108108        // and context switch to it
    109         get_this_processor()->current_coroutine = dst; 
     109        this_processor->current_coroutine = dst;
    110110        CtxSwitch( src->stack.context, dst->stack.context );
    111         get_this_processor()->current_coroutine = src; 
     111        this_processor->current_coroutine = src;
    112112
    113113        // set state of new coroutine to active
     
    116116}
    117117
    118 // C Helper to signal the termination of a thread
     118// C Helper to signal the termination of a thread_desc
    119119// Used in invoke.c
    120120extern "C" {
    121         void __thread_signal_termination( thread * this ) {
     121        void __thread_signal_termination( thread_desc * this ) {
    122122                this->c.state = Halted;
    123123                LIB_DEBUG_PRINTF("Thread end : %p\n", this);
  • src/tests/coroutine.c

    r2f26687 r1fbab5a  
    11#include <fstream>
    2 #include <coroutines>
     2#include <coroutine>
    33
    44struct Fibonacci {
    55      int fn; // used for communication
    6       coroutine c;
     6      coroutine_desc c;
    77};
    88
     
    1111}
    1212
    13 coroutine* get_coroutine(Fibonacci* this) {
     13coroutine_desc* get_coroutine(Fibonacci* this) {
    1414      return &this->c;
    1515}
     
    4747#ifdef MORE_DEBUG     
    4848      Fibonacci *pf1 = &f1, *pf2 = &f2;
    49       coroutine *cf1 = &f1.c, *cf2 = &f2.c;
     49      coroutine_desc *cf1 = &f1.c, *cf2 = &f2.c;
    5050      covptr_t  *vf1 = vtable(pf1), *vf2 = vtable(pf2);
    51       coroutine *cv1 = get_coroutine(vf1), *cv2 = get_coroutine(vf2);
     51      coroutine_desc *cv1 = get_coroutine(vf1), *cv2 = get_coroutine(vf2);
    5252      Fibonacci *ov1 = (Fibonacci *)get_object(vf1), *ov2 = (Fibonacci *)get_object(vf2);
    5353
  • src/tests/monitor.c

    r2f26687 r1fbab5a  
    22#include <kernel>
    33#include <monitor>
    4 #include <threads>
     4#include <thread>
    55
    66struct global_t {
    77        int value;
    8         __monitor_t m;
     8        monitor_desc m;
    99};
    1010
     
    1616
    1717void increment( /*mutex*/ global_t * this ) {
    18         __monitor_t * mon = &this->m;
     18        monitor_desc * mon = &this->m;
    1919        monitor_guard_t g1 = { &mon };
    2020        {
     
    2727}
    2828
    29 struct MyThread { thread t; };
     29struct MyThread { thread_desc t; };
    3030
    3131DECL_THREAD(MyThread);
  • src/tests/multi-monitor.c

    r2f26687 r1fbab5a  
    22#include <kernel>
    33#include <monitor>
    4 #include <threads>
     4#include <thread>
    55
    66static int global12, global23, global13;
    77
    8 static __monitor_t m1, m2, m3;
     8static monitor_desc m1, m2, m3;
    99
    10 void increment( /*mutex*/ __monitor_t * p1, /*mutex*/ __monitor_t * p2, int * value ) {
    11         __monitor_t * mons[] = { p1, p2 };
     10void increment( /*mutex*/ monitor_desc * p1, /*mutex*/ monitor_desc * p2, int * value ) {
     11        monitor_desc * mons[] = { p1, p2 };
    1212        monitor_guard_t g = { mons, 2 };
    1313        *value += 1;
     
    1515
    1616struct MyThread {
    17         thread t;
     17        thread_desc t;
    1818        int target;
    1919};
  • src/tests/test.py

    r2f26687 r1fbab5a  
    250250parser = argparse.ArgumentParser(description='Script which runs cforall tests')
    251251parser.add_argument('--debug', help='Run all tests in debug or release', type=yes_no, default='no')
    252 parser.add_argument('--concurrent', help='Run concurrent tests', type=yes_no, default='no')
     252parser.add_argument('--concurrent', help='Run concurrent tests', type=yes_no, default='yes')
    253253parser.add_argument('--dry-run', help='Don\'t run the tests, only output the commands', action='store_true')
    254254parser.add_argument('--list', help='List all test available', action='store_true')
  • src/tests/thread.c

    r2f26687 r1fbab5a  
    22#include <kernel>
    33#include <stdlib>
    4 #include <threads>
     4#include <thread>
    55
    6 struct First { thread t; signal_once* lock; };
    7 struct Second { thread t; signal_once* lock; };
     6struct First { thread_desc t; signal_once* lock; };
     7struct Second { thread_desc t; signal_once* lock; };
    88
    99DECL_THREAD(First);
Note: See TracChangeset for help on using the changeset viewer.