Changeset f6e6a55 for src


Ignore:
Timestamp:
Apr 20, 2022, 3:00:11 PM (2 years ago)
Author:
Andrew Beach <ajbeach@…>
Branches:
ADT, ast-experimental, master, pthread-emulation, qualifiedEnum
Children:
4c530a5
Parents:
2686bc7
Message:

Added ast::WaitForClause? and changed ast::WaitForStmt? to use it. This simplified a lot of the internal code.

Location:
src
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • src/AST/Convert.cpp

    r2686bc7 rf6e6a55  
    1010// Created On       : Thu May 09 15::37::05 2019
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Wed Mar 16 15:01:00 2022
    13 // Update Count     : 42
     12// Last Modified On : Wed Apr 20 13:58:00 2022
     13// Update Count     : 43
    1414//
    1515
     
    562562                for ( auto clause : node->clauses ) {
    563563                        stmt->clauses.push_back({{
    564                                         get<Expression>().accept1( clause.target.func ),
    565                                         get<Expression>().acceptL( clause.target.args ),
     564                                        get<Expression>().accept1( clause->target_func ),
     565                                        get<Expression>().acceptL( clause->target_args ),
    566566                                },
    567                                 get<Statement>().accept1( clause.stmt ),
    568                                 get<Expression>().accept1( clause.cond ),
     567                                get<Statement>().accept1( clause->stmt ),
     568                                get<Expression>().accept1( clause->cond ),
    569569                        });
    570570                }
    571571                stmt->timeout = {
    572                         get<Expression>().accept1( node->timeout.time ),
    573                         get<Statement>().accept1( node->timeout.stmt ),
    574                         get<Expression>().accept1( node->timeout.cond ),
     572                        get<Expression>().accept1( node->timeout_time ),
     573                        get<Statement>().accept1( node->timeout_stmt ),
     574                        get<Expression>().accept1( node->timeout_cond ),
    575575                };
    576576                stmt->orelse = {
    577                         get<Statement>().accept1( node->orElse.stmt ),
    578                         get<Expression>().accept1( node->orElse.cond ),
     577                        get<Statement>().accept1( node->else_stmt ),
     578                        get<Expression>().accept1( node->else_cond ),
    579579                };
    580580                return stmtPostamble( stmt, node );
     581        }
     582
     583        const ast::WaitForClause * visit( const ast::WaitForClause * node ) override final {
     584                // There is no old-AST WaitForClause, so this should never be called.
     585                assert( !node );
     586                return nullptr;
    581587        }
    582588
     
    20962102                stmt->clauses.reserve( old->clauses.size() );
    20972103                for (size_t i = 0 ; i < old->clauses.size() ; ++i) {
    2098                         stmt->clauses.push_back({
    2099                                 ast::WaitForStmt::Target{
    2100                                         GET_ACCEPT_1(clauses[i].target.function, Expr),
    2101                                         GET_ACCEPT_V(clauses[i].target.arguments, Expr)
    2102                                 },
    2103                                 GET_ACCEPT_1(clauses[i].statement, Stmt),
    2104                                 GET_ACCEPT_1(clauses[i].condition, Expr)
    2105                         });
    2106                 }
    2107                 stmt->timeout = {
    2108                         GET_ACCEPT_1(timeout.time, Expr),
    2109                         GET_ACCEPT_1(timeout.statement, Stmt),
    2110                         GET_ACCEPT_1(timeout.condition, Expr),
    2111                 };
    2112                 stmt->orElse = {
    2113                         GET_ACCEPT_1(orelse.statement, Stmt),
    2114                         GET_ACCEPT_1(orelse.condition, Expr),
    2115                 };
     2104                        auto clause = new ast::WaitForClause( old->location );
     2105
     2106                        clause->target_func = GET_ACCEPT_1(clauses[i].target.function, Expr);
     2107                        clause->target_args = GET_ACCEPT_V(clauses[i].target.arguments, Expr);
     2108                        clause->stmt = GET_ACCEPT_1(clauses[i].statement, Stmt);
     2109                        clause->cond = GET_ACCEPT_1(clauses[i].condition, Expr);
     2110
     2111                        stmt->clauses.push_back( clause );
     2112                }
     2113                stmt->timeout_time = GET_ACCEPT_1(timeout.time, Expr);
     2114                stmt->timeout_stmt = GET_ACCEPT_1(timeout.statement, Stmt);
     2115                stmt->timeout_cond = GET_ACCEPT_1(timeout.condition, Expr);
     2116                stmt->else_stmt = GET_ACCEPT_1(orelse.statement, Stmt);
     2117                stmt->else_cond = GET_ACCEPT_1(orelse.condition, Expr);
    21162118
    21172119                this->node = stmt;
  • src/AST/Fwd.hpp

    r2686bc7 rf6e6a55  
    5656class SuspendStmt;
    5757class WaitForStmt;
     58class WaitForClause;
    5859class WithStmt;
    5960class DeclStmt;
  • src/AST/Node.cpp

    r2686bc7 rf6e6a55  
    176176template class ast::ptr_base< ast::WaitForStmt, ast::Node::ref_type::weak >;
    177177template class ast::ptr_base< ast::WaitForStmt, ast::Node::ref_type::strong >;
     178template class ast::ptr_base< ast::WaitForClause, ast::Node::ref_type::weak >;
     179template class ast::ptr_base< ast::WaitForClause, ast::Node::ref_type::strong >;
    178180template class ast::ptr_base< ast::WithStmt, ast::Node::ref_type::weak >;
    179181template class ast::ptr_base< ast::WithStmt, ast::Node::ref_type::strong >;
  • src/AST/Pass.hpp

    r2686bc7 rf6e6a55  
    158158        const ast::Stmt *             visit( const ast::SuspendStmt          * ) override final;
    159159        const ast::Stmt *             visit( const ast::WaitForStmt          * ) override final;
     160        const ast::WaitForClause *    visit( const ast::WaitForClause        * ) override final;
    160161        const ast::Decl *             visit( const ast::WithStmt             * ) override final;
    161162        const ast::NullStmt *         visit( const ast::NullStmt             * ) override final;
  • src/AST/Pass.impl.hpp

    r2686bc7 rf6e6a55  
    10101010const ast::Stmt * ast::Pass< core_t >::visit( const ast::WaitForStmt * node ) {
    10111011        VISIT_START( node );
    1012                 // for( auto & clause : node->clauses ) {
    1013                 //      maybeAccept_impl( clause.target.function, *this );
    1014                 //      maybeAccept_impl( clause.target.arguments, *this );
    1015 
    1016                 //      maybeAccept_impl( clause.statement, *this );
    1017                 //      maybeAccept_impl( clause.condition, *this );
    1018                 // }
    1019 
    1020         if ( __visit_children() ) {
    1021                 std::vector<WaitForStmt::Clause> new_clauses;
    1022                 new_clauses.reserve( node->clauses.size() );
    1023                 bool mutated = false;
    1024                 for( const auto & clause : node->clauses ) {
    1025 
    1026                         const Expr * func = clause.target.func ? clause.target.func->accept(*this) : nullptr;
    1027                         if(func != clause.target.func) mutated = true;
    1028                         else func = nullptr;
    1029 
    1030                         std::vector<ptr<Expr>> new_args;
    1031                         new_args.reserve(clause.target.args.size());
    1032                         for( const auto & arg : clause.target.args ) {
    1033                                 auto a = arg->accept(*this);
    1034                                 if( a != arg ) {
    1035                                         mutated = true;
    1036                                         new_args.push_back( a );
    1037                                 } else
    1038                                         new_args.push_back( nullptr );
    1039                         }
    1040 
    1041                         const Stmt * stmt = clause.stmt ? clause.stmt->accept(*this) : nullptr;
    1042                         if(stmt != clause.stmt) mutated = true;
    1043                         else stmt = nullptr;
    1044 
    1045                         const Expr * cond = clause.cond ? clause.cond->accept(*this) : nullptr;
    1046                         if(cond != clause.cond) mutated = true;
    1047                         else cond = nullptr;
    1048 
    1049                         new_clauses.push_back( WaitForStmt::Clause{ {func, std::move(new_args) }, stmt, cond } );
    1050                 }
    1051 
    1052                 if(mutated) {
    1053                         auto n = __pass::mutate<core_t>(node);
    1054                         for(size_t i = 0; i < new_clauses.size(); i++) {
    1055                                 if(new_clauses.at(i).target.func != nullptr) swap(n->clauses.at(i).target.func, new_clauses.at(i).target.func);
    1056 
    1057                                 for(size_t j = 0; j < new_clauses.at(i).target.args.size(); j++) {
    1058                                         if(new_clauses.at(i).target.args.at(j) != nullptr) swap(n->clauses.at(i).target.args.at(j), new_clauses.at(i).target.args.at(j));
    1059                                 }
    1060 
    1061                                 if(new_clauses.at(i).stmt != nullptr) swap(n->clauses.at(i).stmt, new_clauses.at(i).stmt);
    1062                                 if(new_clauses.at(i).cond != nullptr) swap(n->clauses.at(i).cond, new_clauses.at(i).cond);
    1063                         }
    1064                         node = n;
    1065                 }
    1066         }
    1067 
    1068         #define maybe_accept(field) \
    1069                 if(node->field) { \
    1070                         auto nval = call_accept( node->field ); \
    1071                         if(nval.differs ) { \
    1072                                 auto nparent = __pass::mutate<core_t>(node); \
    1073                                 nparent->field = nval.value; \
    1074                                 node = nparent; \
    1075                         } \
    1076                 }
    1077 
    1078         if ( __visit_children() ) {
    1079                 maybe_accept( timeout.time );
    1080                 maybe_accept( timeout.stmt );
    1081                 maybe_accept( timeout.cond );
    1082                 maybe_accept( orElse.stmt  );
    1083                 maybe_accept( orElse.cond  );
    1084         }
    1085 
    1086         #undef maybe_accept
     1012
     1013        if ( __visit_children() ) {
     1014                maybe_accept( node, &WaitForStmt::clauses );
     1015                maybe_accept( node, &WaitForStmt::timeout_time );
     1016                maybe_accept( node, &WaitForStmt::timeout_stmt );
     1017                maybe_accept( node, &WaitForStmt::timeout_cond );
     1018                maybe_accept( node, &WaitForStmt::else_stmt );
     1019                maybe_accept( node, &WaitForStmt::else_cond );
     1020        }
    10871021
    10881022        VISIT_END( Stmt, node );
     1023}
     1024
     1025//--------------------------------------------------------------------------
     1026// WaitForClause
     1027template< typename core_t >
     1028const ast::WaitForClause * ast::Pass< core_t >::visit( const ast::WaitForClause * node ) {
     1029        VISIT_START( node );
     1030
     1031        if ( __visit_children() ) {
     1032                maybe_accept( node, &WaitForClause::target_func );
     1033                maybe_accept( node, &WaitForClause::target_args );
     1034                maybe_accept( node, &WaitForClause::stmt );
     1035                maybe_accept( node, &WaitForClause::cond );
     1036        }
     1037
     1038        VISIT_END( WaitForClause, node );
    10891039}
    10901040
  • src/AST/Print.cpp

    r2686bc7 rf6e6a55  
    760760                indent += 2;
    761761                for( const auto & clause : node->clauses ) {
    762                         os << indent-1 << "target function: ";
    763                         safe_print( clause.target.func );
    764 
    765                         if ( ! clause.target.args.empty() ) {
    766                                 os << endl << indent-1 << "... with arguments:" << endl;
    767                                 for( const ast::Expr * arg : clause.target.args ) {
    768                                         arg->accept( *this );
    769                                 }
     762                        clause->accept( *this );
     763                }
     764
     765                if ( node->timeout_time ) {
     766                        os << indent-1 << "timeout of:" << endl;
     767                        node->timeout_time->accept( *this );
     768
     769                        if ( node->timeout_stmt ) {
     770                                os << indent-1 << "... with statment:" << endl;
     771                                node->timeout_stmt->accept( *this );
    770772                        }
    771773
    772                         if ( clause.stmt ) {
    773                                 os << indent-1 << "... with statment:" << endl;
    774                                 clause.stmt->accept( *this );
     774                        if ( node->timeout_cond ) {
     775                                os << indent-1 << "... with condition:" << endl;
     776                                node->timeout_cond->accept( *this );
    775777                        }
    776 
    777                         if ( clause.cond ) {
     778                }
     779
     780                if ( node->else_stmt ) {
     781                        os << indent-1 << "else:" << endl;
     782                        node->else_stmt->accept( *this );
     783
     784                        if ( node->else_cond ) {
    778785                                os << indent-1 << "... with condition:" << endl;
    779                                 clause.cond->accept( *this );
     786                                node->else_cond->accept( *this );
    780787                        }
    781788                }
    782789
    783                 if ( node->timeout.time ) {
    784                         os << indent-1 << "timeout of:" << endl;
    785                         node->timeout.time->accept( *this );
    786 
    787                         if ( node->timeout.stmt ) {
    788                                 os << indent-1 << "... with statment:" << endl;
    789                                 node->timeout.stmt->accept( *this );
     790                return node;
     791        }
     792
     793        virtual const ast::WaitForClause * visit( const ast::WaitForClause * node ) override final {
     794                os << indent-1 << "target function: ";
     795                safe_print( node->target_func );
     796
     797                if ( !node->target_args.empty() ) {
     798                        os << endl << indent-1 << "... with arguments:" << endl;
     799                        for( const ast::Expr * arg : node->target_args ) {
     800                                arg->accept( *this );
    790801                        }
    791 
    792                         if ( node->timeout.cond ) {
    793                                 os << indent-1 << "... with condition:" << endl;
    794                                 node->timeout.cond->accept( *this );
    795                         }
    796                 }
    797 
    798                 if ( node->orElse.stmt ) {
    799                         os << indent-1 << "else:" << endl;
    800                         node->orElse.stmt->accept( *this );
    801 
    802                         if ( node->orElse.cond ) {
    803                                 os << indent-1 << "... with condition:" << endl;
    804                                 node->orElse.cond->accept( *this );
    805                         }
    806                 }
    807                 indent -= 2;
     802                }
     803
     804                if ( node->stmt ) {
     805                        os << indent-1 << "... with statment:" << endl;
     806                        node->stmt->accept( *this );
     807                }
     808
     809                if ( node->cond ) {
     810                        os << indent-1 << "... with condition:" << endl;
     811                        node->cond->accept( *this );
     812                }
    808813
    809814                return node;
  • src/AST/Stmt.hpp

    r2686bc7 rf6e6a55  
    1010// Created On       : Wed May  8 13:00:00 2019
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Mon Mar 28  9:50:00 2022
    13 // Update Count     : 35
     12// Last Modified On : Wed Apr 20 14:34:00 2022
     13// Update Count     : 36
    1414//
    1515
     
    378378class WaitForStmt final : public Stmt {
    379379  public:
    380         struct Target {
    381                 ptr<Expr> func;
    382                 std::vector<ptr<Expr>> args;
    383         };
    384 
    385         struct Clause {
    386                 Target target;
    387                 ptr<Stmt> stmt;
    388                 ptr<Expr> cond;
    389         };
    390 
    391         struct Timeout {
    392                 ptr<Expr> time;
    393                 ptr<Stmt> stmt;
    394                 ptr<Expr> cond;
    395         };
    396 
    397         struct OrElse {
    398                 ptr<Stmt> stmt;
    399                 ptr<Expr> cond;
    400         };
    401 
    402         std::vector<Clause> clauses;
    403         Timeout timeout;
    404         OrElse orElse;
     380        std::vector<ptr<WaitForClause>> clauses;
     381        ptr<Expr> timeout_time;
     382        ptr<Stmt> timeout_stmt;
     383        ptr<Expr> timeout_cond;
     384        ptr<Stmt> else_stmt;
     385        ptr<Expr> else_cond;
    405386
    406387        WaitForStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
     
    411392        WaitForStmt * clone() const override { return new WaitForStmt{ *this }; }
    412393        MUTATE_FRIEND
     394};
     395
     396class WaitForClause final : public StmtClause {
     397  public:
     398    ptr<Expr> target_func;
     399    std::vector<ptr<Expr>> target_args;
     400    ptr<Stmt> stmt;
     401    ptr<Expr> cond;
     402
     403    WaitForClause( const CodeLocation & loc )
     404                : StmtClause( loc ) {}
     405
     406        const WaitForClause * accept( Visitor & v ) const override { return v.visit( this ); }
     407  private:
     408    WaitForClause * clone() const override { return new WaitForClause{ *this }; }
     409    MUTATE_FRIEND
    413410};
    414411
  • src/AST/Visitor.hpp

    r2686bc7 rf6e6a55  
    5050    virtual const ast::Stmt *             visit( const ast::SuspendStmt          * ) = 0;
    5151    virtual const ast::Stmt *             visit( const ast::WaitForStmt          * ) = 0;
     52    virtual const ast::WaitForClause *    visit( const ast::WaitForClause        * ) = 0;
    5253    virtual const ast::Decl *             visit( const ast::WithStmt             * ) = 0;
    5354    virtual const ast::NullStmt *         visit( const ast::NullStmt             * ) = 0;
  • src/Common/CodeLocationTools.cpp

    r2686bc7 rf6e6a55  
    121121    macro(SuspendStmt, Stmt) \
    122122    macro(WaitForStmt, Stmt) \
     123    macro(WaitForClause, WaitForClause) \
    123124    macro(WithStmt, Decl) \
    124125    macro(NullStmt, NullStmt) \
  • src/ResolvExpr/Resolver.cc

    r2686bc7 rf6e6a55  
    1010// Created On       : Sun May 17 12:17:01 2015
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Fri Mar 18 10:41:00 2022
    13 // Update Count     : 247
     12// Last Modified On : Wed Apr 20 10:41:00 2022
     13// Update Count     : 248
    1414//
    1515
     
    17381738                // Resolve all clauses first
    17391739                for ( unsigned i = 0; i < stmt->clauses.size(); ++i ) {
    1740                         const ast::WaitForStmt::Clause & clause = stmt->clauses[i];
     1740                        const ast::WaitForClause & clause = *stmt->clauses[i];
    17411741
    17421742                        ast::TypeEnvironment env;
     
    17441744
    17451745                        // Find all candidates for a function in canonical form
    1746                         funcFinder.find( clause.target.func, ResolvMode::withAdjustment() );
     1746                        funcFinder.find( clause.target_func, ResolvMode::withAdjustment() );
    17471747
    17481748                        if ( funcFinder.candidates.empty() ) {
    17491749                                stringstream ss;
    17501750                                ss << "Use of undeclared indentifier '";
    1751                                 ss << clause.target.func.strict_as< ast::NameExpr >()->name;
     1751                                ss << clause.target_func.strict_as< ast::NameExpr >()->name;
    17521752                                ss << "' in call to waitfor";
    17531753                                SemanticError( stmt->location, ss.str() );
    17541754                        }
    17551755
    1756                         if ( clause.target.args.empty() ) {
     1756                        if ( clause.target_args.empty() ) {
    17571757                                SemanticError( stmt->location,
    17581758                                        "Waitfor clause must have at least one mutex parameter");
     
    17611761                        // Find all alternatives for all arguments in canonical form
    17621762                        std::vector< CandidateFinder > argFinders =
    1763                                 funcFinder.findSubExprs( clause.target.args );
     1763                                funcFinder.findSubExprs( clause.target_args );
    17641764
    17651765                        // List all combinations of arguments
     
    19341934
    19351935                        // build new clause
    1936                         ast::WaitForStmt::Clause clause2;
    1937 
    1938                         clause2.target.func = funcCandidates.front()->expr;
    1939 
    1940                         clause2.target.args.reserve( clause.target.args.size() );
     1936                        auto clause2 = new ast::WaitForClause( clause.location );
     1937
     1938                        clause2->target_func = funcCandidates.front()->expr;
     1939
     1940                        clause2->target_args.reserve( clause.target_args.size() );
    19411941                        const ast::StructDecl * decl_monitor = symtab.lookupStruct( "monitor$" );
    19421942                        for ( auto arg : argsCandidates.front() ) {
     
    19551955                                );
    19561956
    1957                                 clause2.target.args.emplace_back( findSingleExpression( init, context ) );
     1957                                clause2->target_args.emplace_back( findSingleExpression( init, context ) );
    19581958                        }
    19591959
    19601960                        // Resolve the conditions as if it were an IfStmt, statements normally
    1961                         clause2.cond = findSingleExpression( clause.cond, context );
    1962                         clause2.stmt = clause.stmt->accept( *visitor );
     1961                        clause2->cond = findSingleExpression( clause.cond, context );
     1962                        clause2->stmt = clause.stmt->accept( *visitor );
    19631963
    19641964                        // set results into stmt
    19651965                        auto n = mutate( stmt );
    1966                         n->clauses[i] = std::move( clause2 );
     1966                        n->clauses[i] = clause2;
    19671967                        stmt = n;
    19681968                }
    19691969
    1970                 if ( stmt->timeout.stmt ) {
     1970                if ( stmt->timeout_stmt ) {
    19711971                        // resolve the timeout as a size_t, the conditions like IfStmt, and stmts normally
    1972                         ast::WaitForStmt::Timeout timeout2;
    1973 
    19741972                        ast::ptr< ast::Type > target =
    19751973                                new ast::BasicType{ ast::BasicType::LongLongUnsignedInt };
    1976                         timeout2.time = findSingleExpression( stmt->timeout.time, target, context );
    1977                         timeout2.cond = findSingleExpression( stmt->timeout.cond, context );
    1978                         timeout2.stmt = stmt->timeout.stmt->accept( *visitor );
     1974                        auto timeout_time = findSingleExpression( stmt->timeout_time, target, context );
     1975                        auto timeout_cond = findSingleExpression( stmt->timeout_cond, context );
     1976                        auto timeout_stmt = stmt->timeout_stmt->accept( *visitor );
    19791977
    19801978                        // set results into stmt
    19811979                        auto n = mutate( stmt );
    1982                         n->timeout = std::move( timeout2 );
     1980                        n->timeout_time = std::move( timeout_time );
     1981                        n->timeout_cond = std::move( timeout_cond );
     1982                        n->timeout_stmt = std::move( timeout_stmt );
    19831983                        stmt = n;
    19841984                }
    19851985
    1986                 if ( stmt->orElse.stmt ) {
     1986                if ( stmt->else_stmt ) {
    19871987                        // resolve the condition like IfStmt, stmts normally
    1988                         ast::WaitForStmt::OrElse orElse2;
    1989 
    1990                         orElse2.cond = findSingleExpression( stmt->orElse.cond, context );
    1991                         orElse2.stmt = stmt->orElse.stmt->accept( *visitor );
     1988                        auto else_cond = findSingleExpression( stmt->else_cond, context );
     1989                        auto else_stmt = stmt->else_stmt->accept( *visitor );
    19921990
    19931991                        // set results into stmt
    19941992                        auto n = mutate( stmt );
    1995                         n->orElse = std::move( orElse2 );
     1993                        n->else_cond = std::move( else_cond );
     1994                        n->else_stmt = std::move( else_stmt );
    19961995                        stmt = n;
    19971996                }
Note: See TracChangeset for help on using the changeset viewer.