Ignore:
Timestamp:
Jul 12, 2019, 4:34:56 PM (3 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
arm-eh, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr
Children:
e3d7f9f
Parents:
8fd52e9
Message:

Resolver now uses constant interface

File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/InitTweak/InitTweak.cc

    r8fd52e9 r6f096d2  
    318318        virtual ~ExpanderImpl() = default;
    319319        virtual std::vector< ast::ptr< ast::Expr > > next( IndexList & indices ) = 0;
    320         virtual ast::ptr< ast::Stmt > buildListInit( 
     320        virtual ast::ptr< ast::Stmt > buildListInit(
    321321                ast::UntypedExpr * callExpr, IndexList & indices ) = 0;
    322322};
     
    324324namespace {
    325325        template< typename Out >
    326         void buildCallExpr( 
    327                 ast::UntypedExpr * callExpr, const ast::Expr * index, const ast::Expr * dimension, 
     326        void buildCallExpr(
     327                ast::UntypedExpr * callExpr, const ast::Expr * index, const ast::Expr * dimension,
    328328                const ast::Init * init, Out & out
    329329        ) {
    330330                const CodeLocation & loc = init->location;
    331331
    332                 auto cond = new ast::UntypedExpr{ 
     332                auto cond = new ast::UntypedExpr{
    333333                        loc, new ast::NameExpr{ loc, "?<?" }, { index, dimension } };
    334                
     334
    335335                std::vector< ast::ptr< ast::Expr > > args = makeInitList( init );
    336336                splice( callExpr->args, args );
     
    338338                out.emplace_back( new ast::IfStmt{ loc, cond, new ast::ExprStmt{ loc, callExpr } } );
    339339
    340                 out.emplace_back( new ast::ExprStmt{ 
     340                out.emplace_back( new ast::ExprStmt{
    341341                        loc, new ast::UntypedExpr{ loc, new ast::NameExpr{ loc, "++?" }, { index } } } );
    342342        }
     
    344344        template< typename Out >
    345345        void build(
    346                 ast::UntypedExpr * callExpr, const InitExpander_new::IndexList & indices, 
     346                ast::UntypedExpr * callExpr, const InitExpander_new::IndexList & indices,
    347347                const ast::Init * init, Out & out
    348348        ) {
     
    371371
    372372                        static UniqueName targetLabel( "L__autogen__" );
    373                         ast::Label switchLabel{ 
     373                        ast::Label switchLabel{
    374374                                loc, targetLabel.newName(), { new ast::Attribute{ "unused" } } };
    375                        
     375
    376376                        std::vector< ast::ptr< ast::Stmt > > branches;
    377377                        for ( const ast::Init * init : *listInit ) {
     
    381381                                std::vector< ast::ptr< ast::Stmt > > stmts;
    382382                                build( callExpr, indices, init, stmts );
    383                                 stmts.emplace_back( 
     383                                stmts.emplace_back(
    384384                                        new ast::BranchStmt{ loc, ast::BranchStmt::Break, switchLabel } );
    385385                                branches.emplace_back( new ast::CaseStmt{ loc, condition, std::move( stmts ) } );
     
    398398                        return makeInitList( init );
    399399                }
    400                
    401                 ast::ptr< ast::Stmt > buildListInit( 
    402                         ast::UntypedExpr * callExpr, InitExpander_new::IndexList & indices 
     400
     401                ast::ptr< ast::Stmt > buildListInit(
     402                        ast::UntypedExpr * callExpr, InitExpander_new::IndexList & indices
    403403                ) override {
    404                         // If array came with an initializer list, initialize each element. We may have more 
    405                         // initializers than elements of the array; need to check at each index that we have 
    406                         // not exceeded size. We may have fewer initializers than elements in the array; need 
    407                         // to default-construct remaining elements. To accomplish this, generate switch 
     404                        // If array came with an initializer list, initialize each element. We may have more
     405                        // initializers than elements of the array; need to check at each index that we have
     406                        // not exceeded size. We may have fewer initializers than elements in the array; need
     407                        // to default-construct remaining elements. To accomplish this, generate switch
    408408                        // statement consuming all of expander's elements
    409409
     
    427427                ExprImpl_new( const ast::Expr * a ) : arg( a ) {}
    428428
    429                 std::vector< ast::ptr< ast::Expr > > next( 
    430                         InitExpander_new::IndexList & indices 
     429                std::vector< ast::ptr< ast::Expr > > next(
     430                        InitExpander_new::IndexList & indices
    431431                ) override {
    432432                        if ( ! arg ) return {};
     
    437437                                // go through indices and layer on subscript exprs ?[?]
    438438                                ++it;
    439                                 expr = new ast::UntypedExpr{ 
     439                                expr = new ast::UntypedExpr{
    440440                                        loc, new ast::NameExpr{ loc, "?[?]" }, { expr, *it } };
    441441                        }
    442442                        return { expr };
    443443                }
    444                
    445                 ast::ptr< ast::Stmt > buildListInit( 
    446                         ast::UntypedExpr *, InitExpander_new::IndexList & 
    447                 ) override { 
     444
     445                ast::ptr< ast::Stmt > buildListInit(
     446                        ast::UntypedExpr *, InitExpander_new::IndexList &
     447                ) override {
    448448                        return {};
    449449                }
     
    464464}
    465465
    466 /// builds statement which has the same semantics as a C-style list initializer (for array 
     466/// builds statement which has the same semantics as a C-style list initializer (for array
    467467/// initializers) using callExpr as the base expression to perform initialization
    468468ast::ptr< ast::Stmt > InitExpander_new::buildListInit( ast::UntypedExpr * callExpr ) {
     
    668668
    669669                const ast::DeclWithType * func = getCalledFunction( appExpr->func );
    670                 assertf( func, 
     670                assertf( func,
    671671                        "getCalledFunction returned nullptr: %s", toString( appExpr->func ).c_str() );
    672                
    673                 // check for Intrinsic only -- don't want to remove all overridable ctor/dtor because 
    674                 // autogenerated ctor/dtor will call all member dtors, and some members may have a 
     672
     673                // check for Intrinsic only -- don't want to remove all overridable ctor/dtor because
     674                // autogenerated ctor/dtor will call all member dtors, and some members may have a
    675675                // user-defined dtor
    676676                return func->linkage == ast::Linkage::Intrinsic ? appExpr : nullptr;
     
    707707                return allofCtorDtor( stmt, []( const ast::Expr * callExpr ){
    708708                        if ( const ast::ApplicationExpr * appExpr = isIntrinsicCallExpr( callExpr ) ) {
    709                                 const ast::FunctionType * funcType = 
     709                                const ast::FunctionType * funcType =
    710710                                        GenPoly::getFunctionType( appExpr->func->result );
    711711                                assert( funcType );
     
    997997        bool isCtorDtorAssign( const std::string & str ) { return isCtorDtor( str ) || isAssignment( str ); }
    998998
    999         FunctionDecl * isCopyFunction( Declaration * decl, const std::string & fname ) {
    1000                 FunctionDecl * function = dynamic_cast< FunctionDecl * >( decl );
     999        const FunctionDecl * isCopyFunction( const Declaration * decl, const std::string & fname ) {
     1000                const FunctionDecl * function = dynamic_cast< const FunctionDecl * >( decl );
    10011001                if ( ! function ) return nullptr;
    10021002                if ( function->name != fname ) return nullptr;
     
    10221022                if ( ! t1 ) return false;
    10231023                const ast::Type * t2 = ftype->params.back()->get_type();
    1024                
     1024
    10251025                return ResolvExpr::typesCompatibleIgnoreQualifiers( t1, t2, ast::SymbolTable{} );
    10261026        }
    10271027
    1028         FunctionDecl * isAssignment( Declaration * decl ) {
     1028        const FunctionDecl * isAssignment( const Declaration * decl ) {
    10291029                return isCopyFunction( decl, "?=?" );
    10301030        }
    1031         FunctionDecl * isDestructor( Declaration * decl ) {
    1032                 if ( isDestructor( decl->get_name() ) ) {
    1033                         return dynamic_cast< FunctionDecl * >( decl );
     1031        const FunctionDecl * isDestructor( const Declaration * decl ) {
     1032                if ( isDestructor( decl->name ) ) {
     1033                        return dynamic_cast< const FunctionDecl * >( decl );
    10341034                }
    10351035                return nullptr;
    10361036        }
    1037         FunctionDecl * isDefaultConstructor( Declaration * decl ) {
     1037        const FunctionDecl * isDefaultConstructor( const Declaration * decl ) {
    10381038                if ( isConstructor( decl->name ) ) {
    1039                         if ( FunctionDecl * func = dynamic_cast< FunctionDecl * >( decl ) ) {
     1039                        if ( const FunctionDecl * func = dynamic_cast< const FunctionDecl * >( decl ) ) {
    10401040                                if ( func->type->parameters.size() == 1 ) {
    10411041                                        return func;
     
    10451045                return nullptr;
    10461046        }
    1047         FunctionDecl * isCopyConstructor( Declaration * decl ) {
     1047        const FunctionDecl * isCopyConstructor( const Declaration * decl ) {
    10481048                return isCopyFunction( decl, "?{}" );
    10491049        }
Note: See TracChangeset for help on using the changeset viewer.