Changeset 5a40e4e for src


Ignore:
Timestamp:
Sep 9, 2021, 3:56:32 PM (4 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
ADT, ast-experimental, enum, forall-pointer-decay, master, pthread-emulation, qualifiedEnum, stuck-waitfor-destruct
Children:
d0b9247
Parents:
dd1cc02 (diff), d8d512e (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:software/cfa/cfa-cc

Location:
src
Files:
2 added
28 edited

Legend:

Unmodified
Added
Removed

  • src/AST/Convert.cpp

    rdd1cc02 r5a40e4e  
    606606        }
    607607
     608        const ast::Stmt * visit( const ast::MutexStmt * node ) override final {
     609                if ( inCache( node ) ) return nullptr;
     610                 auto stmt = new MutexStmt(
     611                        get<Statement>().accept1( node->stmt ),
     612                        get<Expression>().acceptL( node->mutexObjs )
     613                );
     614                return stmtPostamble( stmt, node );
     615        }
     616
    608617        TypeSubstitution * convertTypeSubstitution(const ast::TypeSubstitution * src) {
    609618
    … …  
    21242133        }
    21252134
     2135        virtual void visit( const MutexStmt * old ) override final {
     2136                if ( inCache( old ) ) return;
     2137                this->node = new ast::MutexStmt(
     2138                        old->location,
     2139                        GET_ACCEPT_1(stmt, Stmt),
     2140                        GET_ACCEPT_V(mutexObjs, Expr)
     2141                );
     2142                cache.emplace( old, this->node );
     2143        }
     2144
    21262145        // TypeSubstitution shouldn't exist yet in old.
    21272146        ast::TypeSubstitution * convertTypeSubstitution(const TypeSubstitution * old) {

  • src/AST/Fwd.hpp

    rdd1cc02 r5a40e4e  
    6060class NullStmt;
    6161class ImplicitCtorDtorStmt;
     62class MutexStmt;
    6263
    6364class Expr;

  • src/AST/Node.cpp

    rdd1cc02 r5a40e4e  
    176176template class ast::ptr_base< ast::ImplicitCtorDtorStmt, ast::Node::ref_type::weak >;
    177177template class ast::ptr_base< ast::ImplicitCtorDtorStmt, ast::Node::ref_type::strong >;
     178template class ast::ptr_base< ast::MutexStmt, ast::Node::ref_type::weak >;
     179template class ast::ptr_base< ast::MutexStmt, ast::Node::ref_type::strong >;
    178180template class ast::ptr_base< ast::Expr, ast::Node::ref_type::weak >;
    179181template class ast::ptr_base< ast::Expr, ast::Node::ref_type::strong >;

  • src/AST/Pass.hpp

    rdd1cc02 r5a40e4e  
    162162        const ast::Stmt *             visit( const ast::DeclStmt             * ) override final;
    163163        const ast::Stmt *             visit( const ast::ImplicitCtorDtorStmt * ) override final;
     164        const ast::Stmt *             visit( const ast::MutexStmt            * ) override final;
    164165        const ast::Expr *             visit( const ast::ApplicationExpr      * ) override final;
    165166        const ast::Expr *             visit( const ast::UntypedExpr          * ) override final;

  • src/AST/Pass.impl.hpp

    rdd1cc02 r5a40e4e  
    10391039
    10401040//--------------------------------------------------------------------------
     1041// MutexStmt
     1042template< typename core_t >
     1043const ast::Stmt * ast::Pass< core_t >::visit( const ast::MutexStmt * node ) {
     1044        VISIT_START( node );
     1045
     1046        VISIT({
     1047                // mutex statements introduce a level of scope (for the initialization)
     1048                guard_symtab guard { *this };
     1049                maybe_accept( node, &MutexStmt::stmt );
     1050                maybe_accept( node, &MutexStmt::mutexObjs );
     1051        })
     1052
     1053        VISIT_END( Stmt, node );
     1054}
     1055
     1056//--------------------------------------------------------------------------
    10411057// ApplicationExpr
    10421058template< typename core_t >

  • src/AST/Print.cpp

    rdd1cc02 r5a40e4e  
    794794                ++indent;
    795795                safe_print( node->callStmt );
     796                --indent;
     797                os << endl;
     798
     799                return node;
     800        }
     801
     802        virtual const ast::Stmt * visit( const ast::MutexStmt * node ) override final {
     803                os << "Mutex Statement" << endl;
     804                os << indent << "... with Mutex Parameters: ";
     805                ++indent;
     806                printAll( node->mutexObjs );
     807                --indent;
     808                os << indent << "... with Statement: ";
     809                ++indent;
     810                safe_print( node->stmt );
    796811                --indent;
    797812                os << endl;

  • src/AST/Stmt.hpp

    rdd1cc02 r5a40e4e  
    426426};
    427427
     428/// Mutex Statement
     429class MutexStmt final : public Stmt {
     430public:
     431        ptr<Stmt> stmt;
     432        std::vector<ptr<Expr>> mutexObjs;
     433
     434        MutexStmt( const CodeLocation & loc, const Stmt * stmt,
     435                std::vector<ptr<Expr>> && mutexes, std::vector<Label> && labels = {} )
     436        : Stmt(loc, std::move(labels)), stmt(stmt), mutexObjs(std::move(mutexes)) {}
     437
     438        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     439private:
     440        MutexStmt * clone() const override { return new MutexStmt{ *this }; }
     441        MUTATE_FRIEND
     442};
     443
    428444}
    429445

  • src/AST/Visitor.hpp

    rdd1cc02 r5a40e4e  
    5454    virtual const ast::Stmt *             visit( const ast::DeclStmt             * ) = 0;
    5555    virtual const ast::Stmt *             visit( const ast::ImplicitCtorDtorStmt * ) = 0;
     56    virtual const ast::Stmt *             visit( const ast::MutexStmt            * ) = 0;
    5657    virtual const ast::Expr *             visit( const ast::ApplicationExpr      * ) = 0;
    5758    virtual const ast::Expr *             visit( const ast::UntypedExpr          * ) = 0;

  • src/CodeGen/CodeGenerator.cc

    rdd1cc02 r5a40e4e  
    11871187        }
    11881188
     1189        void CodeGenerator::postvisit( MutexStmt * stmt ) {
     1190                assertf( ! options.genC, "ImplicitCtorDtorStmts should not reach code generation." );
     1191                stmt->stmt->accept( *visitor );
     1192        }
     1193
    11891194        void CodeGenerator::handleStorageClass( DeclarationWithType * decl ) {
    11901195                if ( decl->get_storageClasses().any() ) {

  • src/CodeGen/CodeGenerator.h

    rdd1cc02 r5a40e4e  
    121121                void postvisit( DeclStmt * );
    122122                void postvisit( ImplicitCtorDtorStmt * );
     123                void postvisit( MutexStmt * stmt );
    123124
    124125                void genAttributes( std::list< Attribute * > & attributes );

  • src/Common/CodeLocationTools.cpp

    rdd1cc02 r5a40e4e  
    125125    macro(DeclStmt, Stmt) \
    126126    macro(ImplicitCtorDtorStmt, Stmt) \
     127    macro(MutexStmt, Stmt) \
    127128    macro(ApplicationExpr, Expr) \
    128129    macro(UntypedExpr, Expr) \

  • src/Common/PassVisitor.h

    rdd1cc02 r5a40e4e  
    124124        virtual void visit( ImplicitCtorDtorStmt * impCtorDtorStmt ) override final;
    125125        virtual void visit( const ImplicitCtorDtorStmt * impCtorDtorStmt ) override final;
     126        virtual void visit( MutexStmt * mutexStmt ) override final;
     127        virtual void visit( const MutexStmt * mutexStmt ) override final;
    126128
    127129        virtual void visit( ApplicationExpr * applicationExpr ) override final;
    … …  
    291293        virtual Statement * mutate( DeclStmt * declStmt ) override final;
    292294        virtual Statement * mutate( ImplicitCtorDtorStmt * impCtorDtorStmt ) override final;
     295        virtual Statement * mutate( MutexStmt * mutexStmt ) override final;
    293296
    294297        virtual Expression * mutate( ApplicationExpr * applicationExpr ) override final;

  • src/Common/PassVisitor.impl.h

    rdd1cc02 r5a40e4e  
    17811781
    17821782//--------------------------------------------------------------------------
     1783// MutexStmt
     1784template< typename pass_type >
     1785void PassVisitor< pass_type >::visit( MutexStmt * node ) {
     1786        VISIT_START( node );
     1787        // mutex statements introduce a level of scope (for the initialization)
     1788        maybeAccept_impl( node->mutexObjs, *this );
     1789        {
     1790                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
     1791                node->stmt = visitStatement( node->stmt );
     1792        }
     1793        VISIT_END( node );
     1794}
     1795
     1796template< typename pass_type >
     1797void PassVisitor< pass_type >::visit( const MutexStmt * node ) {
     1798        VISIT_START( node );
     1799        maybeAccept_impl( node->mutexObjs, *this );
     1800        {
     1801                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
     1802                visitStatement( node->stmt );
     1803        }
     1804        VISIT_END( node );
     1805}
     1806
     1807template< typename pass_type >
     1808Statement * PassVisitor< pass_type >::mutate( MutexStmt * node ) {
     1809        MUTATE_START( node );
     1810        maybeMutate_impl( node->mutexObjs, *this );
     1811        {
     1812                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
     1813                node->stmt = mutateStatement( node->stmt );
     1814        }
     1815        MUTATE_END( Statement, node );
     1816}
     1817
     1818//--------------------------------------------------------------------------
    17831819// ApplicationExpr
    17841820template< typename pass_type >

  • src/Concurrency/Keywords.cc

    rdd1cc02 r5a40e4e  
    9393                ObjectDecl * addField( StructDecl * );
    9494                void addRoutines( ObjectDecl *, FunctionDecl * );
     95                void addLockUnlockRoutines( StructDecl * );
    9596
    9697                virtual bool is_target( StructDecl * decl ) = 0;
    … …  
    302303                void postvisit( FunctionDecl * decl );
    303304                void postvisit(   StructDecl * decl );
     305                Statement * postmutate( MutexStmt * stmt );
    304306
    305307                std::list<DeclarationWithType*> findMutexArgs( FunctionDecl*, bool & first );
    … …  
    307309                void addDtorStatements( FunctionDecl* func, CompoundStmt *, const std::list<DeclarationWithType * > &);
    308310                void addStatements( FunctionDecl* func, CompoundStmt *, const std::list<DeclarationWithType * > &);
     311                void addStatements( CompoundStmt * body, const std::list<Expression * > & args );
    309312                void addThreadDtorStatements( FunctionDecl* func, CompoundStmt * body, const std::list<DeclarationWithType * > & args );
    310313
    … …  
    312315                        PassVisitor< MutexKeyword > impl;
    313316                        acceptAll( translationUnit, impl );
     317                        mutateAll( translationUnit, impl );
    314318                }
    315319
    … …  
    319323                StructDecl* dtor_guard_decl = nullptr;
    320324                StructDecl* thread_guard_decl = nullptr;
     325                StructDecl* lock_guard_decl = nullptr;
    321326
    322327                static std::unique_ptr< Type > generic_func;
    … …  
    460465        }
    461466
    462 
    463467        void ConcurrentSueKeyword::handle( StructDecl * decl ) {
    464468                if( ! decl->body ) return;
    … …  
    476480                FunctionDecl * func = forwardDeclare( decl );
    477481                ObjectDecl * field = addField( decl );
     482
     483                // add get_.* routine
    478484                addRoutines( field, func );
     485                // add lock/unlock routines to monitors for use by mutex stmt
     486                addLockUnlockRoutines( decl );
    479487        }
    480488
    … …  
    609617        }
    610618
     619        // This function adds the get_.* routine body for coroutines, monitors etc
     620        //              after their corresponding struct has been made
    611621        void ConcurrentSueKeyword::addRoutines( ObjectDecl * field, FunctionDecl * func ) {
    612622                CompoundStmt * statement = new CompoundStmt();
    … …  
    631641
    632642                declsToAddAfter.push_back( get_decl );
     643        }
     644
     645        // Generates lock/unlock routines for monitors to be used by mutex stmts
     646        void ConcurrentSueKeyword::addLockUnlockRoutines( StructDecl * decl ) {
     647                // this routine will be called for all ConcurrentSueKeyword children so only continue if we are a monitor
     648                if ( !decl->is_monitor() ) return;
     649
     650                FunctionType * lock_fn_type = new FunctionType( noQualifiers, false );
     651                FunctionType * unlock_fn_type = new FunctionType( noQualifiers, false );
     652
     653                // create this ptr parameter for both routines
     654                ObjectDecl * this_decl = new ObjectDecl(
     655                        "this",
     656                        noStorageClasses,
     657                        LinkageSpec::Cforall,
     658                        nullptr,
     659                        new ReferenceType(
     660                                noQualifiers,
     661                                new StructInstType(
     662                                        noQualifiers,
     663                                        decl
     664                                )
     665                        ),
     666                        nullptr
     667                );
     668
     669                lock_fn_type->get_parameters().push_back( this_decl->clone() );
     670                unlock_fn_type->get_parameters().push_back( this_decl->clone() );
     671                fixupGenerics(lock_fn_type, decl);
     672                fixupGenerics(unlock_fn_type, decl);
     673
     674                delete this_decl;
     675
     676
     677                //////////////////////////////////////////////////////////////////////
     678                // The following generates this lock routine for all monitors
     679                /*
     680                        void lock (monitor_t & this) {
     681                                lock(get_monitor(this));
     682                        }       
     683                */
     684                FunctionDecl * lock_decl = new FunctionDecl(
     685                        "lock",
     686                        Type::Static,
     687                        LinkageSpec::Cforall,
     688                        lock_fn_type,
     689                        nullptr,
     690                        { },
     691                        Type::Inline
     692                );
     693
     694                UntypedExpr * get_monitor_lock =  new UntypedExpr (
     695                        new NameExpr( "get_monitor" ),
     696                        { new VariableExpr( lock_fn_type->get_parameters().front() ) }
     697                );
     698
     699                CompoundStmt * lock_statement = new CompoundStmt();
     700                lock_statement->push_back(
     701                        new ExprStmt(
     702                                new UntypedExpr (
     703                                        new NameExpr( "lock" ),
     704                                        {
     705                                                get_monitor_lock
     706                                        }
     707                                )
     708                        )
     709                );
     710                lock_decl->set_statements( lock_statement );
     711
     712                //////////////////////////////////////////////////////////////////
     713                // The following generates this routine for all monitors
     714                /*
     715                        void unlock (monitor_t & this) {
     716                                unlock(get_monitor(this));
     717                        }       
     718                */
     719                FunctionDecl * unlock_decl = new FunctionDecl(
     720                        "unlock",
     721                        Type::Static,
     722                        LinkageSpec::Cforall,
     723                        unlock_fn_type,
     724                        nullptr,
     725                        { },
     726                        Type::Inline
     727                );
     728
     729                CompoundStmt * unlock_statement = new CompoundStmt();
     730
     731                UntypedExpr * get_monitor_unlock =  new UntypedExpr (
     732                        new NameExpr( "get_monitor" ),
     733                        { new VariableExpr( unlock_fn_type->get_parameters().front() ) }
     734                );
     735
     736                unlock_statement->push_back(
     737                        new ExprStmt(
     738                                new UntypedExpr(
     739                                        new NameExpr( "unlock" ),
     740                                        {
     741                                                get_monitor_unlock
     742                                        }
     743                                )
     744                        )
     745                );
     746                unlock_decl->set_statements( unlock_statement );
     747               
     748                // pushes routines to declsToAddAfter to add at a later time
     749                declsToAddAfter.push_back( lock_decl );
     750                declsToAddAfter.push_back( unlock_decl );
    633751        }
    634752
    … …  
    9341052                        assert( !thread_guard_decl );
    9351053                        thread_guard_decl = decl;
    936                 }
     1054                }
     1055                else if ( decl->name == "__mutex_stmt_lock_guard" && decl->body ) {
     1056                        assert( !lock_guard_decl );
     1057                        lock_guard_decl = decl;
     1058                }
     1059        }
     1060
     1061        Statement * MutexKeyword::postmutate( MutexStmt * stmt ) {
     1062                std::list<Statement *> stmtsForCtor;
     1063                stmtsForCtor.push_back(stmt->stmt);
     1064                CompoundStmt * body = new CompoundStmt( stmtsForCtor );
     1065                addStatements( body, stmt->mutexObjs);
     1066                return body;
    9371067        }
    9381068
    … …  
    10581188                        ))
    10591189                );
     1190        }
     1191
     1192        void MutexKeyword::addStatements( CompoundStmt * body, const std::list<Expression * > & args ) {
     1193                ObjectDecl * monitors = new ObjectDecl(
     1194                        "__monitors",
     1195                        noStorageClasses,
     1196                        LinkageSpec::Cforall,
     1197                        nullptr,
     1198                        new ArrayType(
     1199                                noQualifiers,
     1200                                new PointerType(
     1201                                        noQualifiers,
     1202                                        new TypeofType( noQualifiers, args.front()->clone() )
     1203                                ),
     1204                                new ConstantExpr( Constant::from_ulong( args.size() ) ),
     1205                                false,
     1206                                false
     1207                        ),
     1208                        new ListInit(
     1209                                map_range < std::list<Initializer*> > ( args, [](Expression * var ){
     1210                                        return new SingleInit( new AddressExpr( var ) );
     1211                                })
     1212                        )
     1213                );
     1214
     1215                StructInstType * lock_guard_struct = new StructInstType( noQualifiers, lock_guard_decl );
     1216                TypeExpr * lock_type_expr = new TypeExpr( new TypeofType( noQualifiers, args.front()->clone() ) );
     1217
     1218                lock_guard_struct->parameters.push_back( lock_type_expr ) ;
     1219
     1220                // in reverse order :
     1221                // monitor_guard_t __guard = { __monitors, # };
     1222                body->push_front(
     1223                        new DeclStmt( new ObjectDecl(
     1224                                "__guard",
     1225                                noStorageClasses,
     1226                                LinkageSpec::Cforall,
     1227                                nullptr,
     1228                                lock_guard_struct,
     1229                                new ListInit(
     1230                                        {
     1231                                                new SingleInit( new VariableExpr( monitors ) ),
     1232                                                new SingleInit( new ConstantExpr( Constant::from_ulong( args.size() ) ) )
     1233                                        },
     1234                                        noDesignators,
     1235                                        true
     1236                                )
     1237                        ))
     1238                );
     1239
     1240                //monitor$ * __monitors[] = { get_monitor(a), get_monitor(b) };
     1241                body->push_front( new DeclStmt( monitors) );
    10601242        }
    10611243

  • src/MakeLibCfa.h

    rdd1cc02 r5a40e4e  
    1919
    2020class Declaration;
     21namespace ast {
     22        struct TranslationUnit;
     23}
    2124
    2225namespace LibCfa {
    2326        void makeLibCfa( std::list< Declaration* > &prelude );
     27        void makeLibCfa( ast::TranslationUnit & translationUnit );
    2428} // namespace LibCfa
    2529

  • src/Makefile.am

    rdd1cc02 r5a40e4e  
    2323      CompilationState.h \
    2424      MakeLibCfa.cc \
     25          MakeLibCfaNew.cpp \
    2526        MakeLibCfa.h
    2627

  • src/Parser/ExpressionNode.cc

    rdd1cc02 r5a40e4e  
    1010// Created On       : Sat May 16 13:17:07 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug 20 14:01:46 2020
    13 // Update Count     : 1076
     12// Last Modified On : Sat Aug  7 09:18:56 2021
     13// Update Count     : 1077
    1414//
    1515
    … …  
    514514        return expr;
    515515} // build_varref
     516
    516517// TODO: get rid of this and OperKinds and reuse code from OperatorTable
    517518static const char * OperName[] = {                                              // must harmonize with OperKinds

  • src/Parser/ParseNode.h

    rdd1cc02 r5a40e4e  
    437437WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when, StatementNode * else_stmt, ExpressionNode * else_when );
    438438Statement * build_with( ExpressionNode * exprs, StatementNode * stmt );
     439Statement * build_mutex( ExpressionNode * exprs, StatementNode * stmt );
    439440
    440441//##############################################################################

  • src/Parser/StatementNode.cc

    rdd1cc02 r5a40e4e  
    374374} // build_directive
    375375
     376Statement * build_mutex( ExpressionNode * exprs, StatementNode * stmt ) {
     377        std::list< Expression * > expList;
     378        buildMoveList( exprs, expList );
     379        Statement * body = maybeMoveBuild<Statement>( stmt );
     380        return new MutexStmt( body, expList );
     381} // build_mutex
     382
    376383// Local Variables: //
    377384// tab-width: 4 //

  • src/Parser/parser.yy

    rdd1cc02 r5a40e4e  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jul 20 22:03:04 2021
    13 // Update Count     : 5031
     12// Last Modified On : Sun Aug  8 09:14:44 2021
     13// Update Count     : 5038
    1414//
    1515
    … …  
    185185                type = new ExpressionNode( new CastExpr( maybeMoveBuild<Expression>(type), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) ) );
    186186        } // if
     187//      type = new ExpressionNode( build_func( new ExpressionNode( build_varref( new string( "__for_control_index_constraints__" ) ) ), type ) );
    187188        return new ForCtrl(
    188189                distAttr( DeclarationNode::newTypeof( type, true ), DeclarationNode::newName( index )->addInitializer( new InitializerNode( start ) ) ),
    … …  
    13461347mutex_statement:
    13471348        MUTEX '(' argument_expression_list_opt ')' statement
    1348                 { SemanticError( yylloc, "Mutex statement is currently unimplemented." ); $$ = nullptr; }
     1349                { $$ = new StatementNode( build_mutex( $3, $5 ) ); }
    13491350        ;
    13501351

  • src/SynTree/Mutator.h

    rdd1cc02 r5a40e4e  
    5858        virtual Statement * mutate( DeclStmt * declStmt ) = 0;
    5959        virtual Statement * mutate( ImplicitCtorDtorStmt * impCtorDtorStmt ) = 0;
     60        virtual Statement * mutate( MutexStmt * mutexStmt ) = 0;
    6061
    6162        virtual Expression * mutate( ApplicationExpr * applicationExpr ) = 0;

  • src/SynTree/Statement.cc

    rdd1cc02 r5a40e4e  
    565565}
    566566
     567MutexStmt::MutexStmt( Statement * stmt, std::list<Expression *> mutexObjs )
     568        : Statement(), stmt( stmt ), mutexObjs( mutexObjs ) { }
     569
     570MutexStmt::MutexStmt( const MutexStmt & other ) : Statement( other ), stmt( maybeClone( other.stmt ) ) {
     571        cloneAll( other.mutexObjs, mutexObjs );
     572}
     573
     574MutexStmt::~MutexStmt() {
     575        deleteAll( mutexObjs );
     576        delete stmt;
     577}
     578
     579void MutexStmt::print( std::ostream & os, Indenter indent ) const {
     580        os << "Mutex Statement" << endl;
     581        os << indent << "... with Expressions: " << endl;
     582        for (auto * obj : mutexObjs) {
     583                os << indent+1;
     584                obj->print( os, indent+1);
     585                os << endl;
     586        }
     587        os << indent << "... with Statement: " << endl << indent+1;
     588        stmt->print( os, indent+1 );
     589}
     590
    567591// Local Variables: //
    568592// tab-width: 4 //

  • src/SynTree/Statement.h

    rdd1cc02 r5a40e4e  
    535535};
    536536
     537class MutexStmt : public Statement {
     538  public:
     539        Statement * stmt;
     540        std::list<Expression *> mutexObjs; // list of mutex objects to acquire
     541
     542        MutexStmt( Statement * stmt, std::list<Expression *> mutexObjs );
     543        MutexStmt( const MutexStmt & other );
     544        virtual ~MutexStmt();
     545
     546        virtual MutexStmt * clone() const override { return new MutexStmt( *this ); }
     547        virtual void accept( Visitor & v ) override { v.visit( this ); }
     548        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     549        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
     550        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     551};
     552
    537553// Local Variables: //
    538554// tab-width: 4 //

  • src/SynTree/SynTree.h

    rdd1cc02 r5a40e4e  
    6262class NullStmt;
    6363class ImplicitCtorDtorStmt;
     64class MutexStmt;
    6465
    6566class Expression;

  • src/SynTree/Visitor.h

    rdd1cc02 r5a40e4e  
    9292        virtual void visit( ImplicitCtorDtorStmt * node ) { visit( const_cast<const ImplicitCtorDtorStmt *>(node) ); }
    9393        virtual void visit( const ImplicitCtorDtorStmt * impCtorDtorStmt ) = 0;
     94        virtual void visit( MutexStmt * node ) { visit( const_cast<const MutexStmt *>(node) ); }
     95        virtual void visit( const MutexStmt * mutexStmt ) = 0;
    9496
    9597        virtual void visit( ApplicationExpr * node ) { visit( const_cast<const ApplicationExpr *>(node) ); }

  • src/Tuples/Tuples.h

    rdd1cc02 r5a40e4e  
    99// Author           : Rodolfo G. Esteves
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Tue Jun 18 09:36:00 2019
    13 // Update Count     : 18
     11// Last Modified By : Henry Xue
     12// Last Modified On : Mon Aug 23 15:36:09 2021
     13// Update Count     : 19
    1414//
    1515
    … …  
    3939        /// expands z.[a, b.[x, y], c] into [z.a, z.b.x, z.b.y, z.c], inserting UniqueExprs as appropriate
    4040        void expandMemberTuples( std::list< Declaration * > & translationUnit );
     41        void expandMemberTuples( ast::TranslationUnit & translationUnit );
    4142
    4243        /// replaces tuple-related elements, such as TupleType, TupleExpr, TupleAssignExpr, etc.

  • src/Tuples/module.mk

    rdd1cc02 r5a40e4e  
    1010## Author           : Richard C. Bilson
    1111## Created On       : Mon Jun  1 17:49:17 2015
    12 ## Last Modified By : Peter A. Buhr
    13 ## Last Modified On : Mon Jun  1 17:54:33 2015
    14 ## Update Count     : 1
     12## Last Modified By : Henry Xue
     13## Last Modified On : Mon Aug 23 15:36:09 2021
     14## Update Count     : 2
    1515###############################################################################
    1616
    … …  
    2020        Tuples/TupleAssignment.cc \
    2121        Tuples/TupleExpansion.cc \
     22        Tuples/TupleExpansionNew.cpp \
    2223        Tuples/Tuples.cc \
    2324        Tuples/Tuples.h

  • src/main.cc

    rdd1cc02 r5a40e4e  
    1010// Created On       : Fri May 15 23:12:02 2015
    1111// Last Modified By : Henry Xue
    12 // Last Modified On : Tue Jul 20 04:27:35 2021
    13 // Update Count     : 658
     12// Last Modified On : Mon Aug 23 15:42:08 2021
     13// Update Count     : 650
    1414//
    1515
    … …  
    335335                PASS( "Fix Names", CodeGen::fixNames( translationUnit ) );
    336336                PASS( "Gen Init", InitTweak::genInit( translationUnit ) );
    337                 PASS( "Expand Member Tuples" , Tuples::expandMemberTuples( translationUnit ) );
     337
    338338                if ( libcfap ) {
    339339                        // generate the bodies of cfa library functions
    … …  
    365365                        }
    366366                        auto transUnit = convert( move( translationUnit ) );
     367
     368                        PASS( "Expand Member Tuples" , Tuples::expandMemberTuples( transUnit ) );
     369                       
    367370                        PASS( "Resolve", ResolvExpr::resolve( transUnit ) );
    368371                        if ( exprp ) {
    … …  
    376379                        translationUnit = convert( move( transUnit ) );
    377380                } else {
     381                        PASS( "Expand Member Tuples" , Tuples::expandMemberTuples( translationUnit ) );
     382
    378383                        PASS( "Resolve", ResolvExpr::resolve( translationUnit ) );
    379384                        if ( exprp ) {
Note: See TracChangeset for help on using the changeset viewer.