Ignore:
Timestamp:
Jan 12, 2018, 4:57:40 PM (4 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:
1a4bef3
Parents:
bd0b6b62
git-author:
Rob Schluntz <rschlunt@…> (01/12/18 15:24:25)
git-committer:
Rob Schluntz <rschlunt@…> (01/12/18 16:57:40)
Message:

Minor code cleanup

File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/GenPoly/Lvalue.cc

    rbd0b6b62 r0690350  
    4747                        if ( SymTab::dereferenceOperator ) {
    4848                                VariableExpr * deref = new VariableExpr( SymTab::dereferenceOperator );
    49                                 deref->set_result( new PointerType( Type::Qualifiers(), deref->get_result() ) );
    50                                 Type * base = InitTweak::getPointerBase( arg->get_result() );
    51                                 assertf( base, "expected pointer type in dereference (type was %s)", toString( arg->get_result() ).c_str() );
     49                                deref->result = new PointerType( Type::Qualifiers(), deref->result );
     50                                Type * base = InitTweak::getPointerBase( arg->result );
     51                                assertf( base, "expected pointer type in dereference (type was %s)", toString( arg->result ).c_str() );
    5252                                ApplicationExpr * ret = new ApplicationExpr( deref, { arg } );
    53                                 delete ret->get_result();
    54                                 ret->set_result( base->clone() );
    55                                 ret->get_result()->set_lvalue( true );
     53                                delete ret->result;
     54                                ret->result = base->clone();
     55                                ret->result->set_lvalue( true );
    5656                                return ret;
    5757                        } else {
     
    308308                                        int diff = depth1-depth2;
    309309                                        if ( diff == 0 ) {
     310                                                // conversion between references of the same depth
    310311                                                assertf( depth1 == depth2, "non-intrinsic reference with cast of reference to reference not yet supported: %d %d %s", depth1, depth2, toString( castExpr ).c_str() );
    311312                                                PRINT( std::cerr << castExpr << std::endl; )
    312313                                                return castExpr;
    313314                                        } else if ( diff < 0 ) {
    314                                                 Expression * ret = castExpr->get_arg();
     315                                                // conversion from reference to reference with less depth (e.g. int && -> int &): add dereferences
     316                                                Expression * ret = castExpr->arg;
    315317                                                for ( int i = 0; i < diff; ++i ) {
    316318                                                        ret = mkDeref( ret );
    317319                                                }
    318                                                 ret->set_env( castExpr->get_env() );
    319                                                 delete ret->get_result();
    320                                                 ret->set_result( castExpr->get_result() );
    321                                                 castExpr->set_env( nullptr );
    322                                                 castExpr->set_arg( nullptr );
    323                                                 castExpr->set_result( nullptr );
     320                                                ret->env = castExpr->env;
     321                                                delete ret->result;
     322                                                ret->result = castExpr->result;
     323                                                castExpr->env = nullptr;
     324                                                castExpr->arg = nullptr;
     325                                                castExpr->result = nullptr;
    324326                                                delete castExpr;
    325327                                                return ret;
    326328                                        } else if ( diff > 0 ) {
    327                                                 Expression * ret = castExpr->get_arg();
     329                                                // conversion from reference to reference with more depth (e.g. int & -> int &&): add address-of
     330                                                Expression * ret = castExpr->arg;
    328331                                                for ( int i = 0; i < diff; ++i ) {
    329332                                                        ret = new AddressExpr( ret );
    330333                                                }
    331                                                 ret->set_env( castExpr->get_env() );
    332                                                 delete ret->get_result();
    333                                                 ret->set_result( castExpr->get_result() );
    334                                                 castExpr->set_env( nullptr );
    335                                                 castExpr->set_arg( nullptr );
    336                                                 castExpr->set_result( nullptr );
     334                                                ret->env = castExpr->env;
     335                                                delete ret->result;
     336                                                ret->result = castExpr->result;
     337                                                castExpr->env = nullptr;
     338                                                castExpr->arg = nullptr;
     339                                                castExpr->result = nullptr;
    337340                                                delete castExpr;
    338341                                                return ret;
     
    342345                                        PRINT( std::cerr << castExpr << std::endl; )
    343346                                        return castExpr;
    344                                 } else if ( castExpr->get_arg()->get_result()->get_lvalue() ) {
     347                                } else if ( castExpr->arg->result->get_lvalue() ) {
    345348                                        // conversion from lvalue to reference
    346349                                        // xxx - keep cast, but turn into pointer cast??
     
    348351                                        PRINT(
    349352                                                std::cerr << "convert lvalue to reference -- &" << std::endl;
    350                                                 std::cerr << castExpr->get_arg() << std::endl;
     353                                                std::cerr << castExpr->arg << std::endl;
    351354                                        )
    352                                         AddressExpr * ret = new AddressExpr( castExpr->get_arg() );
    353                                         if ( refType->get_base()->get_qualifiers() != castExpr->get_arg()->get_result()->get_qualifiers() ) {
     355                                        AddressExpr * ret = new AddressExpr( castExpr->arg );
     356                                        if ( refType->base->get_qualifiers() != castExpr->arg->result->get_qualifiers() ) {
    354357                                                // must keep cast if cast-to type is different from the actual type
    355                                                 castExpr->set_arg( ret );
     358                                                castExpr->arg = ret;
    356359                                                return castExpr;
    357360                                        }
    358                                         ret->set_env( castExpr->get_env() );
    359                                         delete ret->get_result();
    360                                         ret->set_result( castExpr->get_result() );
    361                                         castExpr->set_env( nullptr );
    362                                         castExpr->set_arg( nullptr );
    363                                         castExpr->set_result( nullptr );
     361                                        ret->env = castExpr->env;
     362                                        delete ret->result;
     363                                        ret->result = castExpr->result;
     364                                        castExpr->env = nullptr;
     365                                        castExpr->arg = nullptr;
     366                                        castExpr->result = nullptr;
    364367                                        delete castExpr;
    365368                                        return ret;
     
    368371                                }
    369372                                assertf( false, "Only conversions to reference from lvalue are currently supported: %s", toString( castExpr ).c_str() );
    370                         } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( castExpr->get_arg()->get_result() ) ) {
     373                        } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( castExpr->arg->result ) ) {
    371374                                (void)refType;
    372375                                // conversion from reference to rvalue
     
    375378                                        std::cerr << "was = " << castExpr << std::endl;
    376379                                )
    377                                 Expression * ret = castExpr->get_arg();
    378                                 TypeSubstitution * env = castExpr->get_env();
     380                                Expression * ret = castExpr->arg;
     381                                TypeSubstitution * env = castExpr->env;
    379382                                castExpr->set_env( nullptr );
    380383                                if ( ! isIntrinsicReference( ret ) ) {
     
    382385                                        ret = mkDeref( ret );
    383386                                }
    384                                 if ( ResolvExpr::typesCompatibleIgnoreQualifiers( castExpr->get_result(), castExpr->get_arg()->get_result()->stripReferences(), SymTab::Indexer() ) ) {
     387                                if ( ResolvExpr::typesCompatibleIgnoreQualifiers( castExpr->result, castExpr->arg->result->stripReferences(), SymTab::Indexer() ) ) {
    385388                                        // can remove cast if types are compatible, changing expression type to value type
    386                                         ret->set_result( castExpr->get_result()->clone() );
    387                                         castExpr->set_arg( nullptr );
     389                                        ret->result = castExpr->result->clone();
     390                                        castExpr->arg = nullptr;
    388391                                        delete castExpr;
    389392                                } else {
    390393                                        // must keep cast if types are different
    391                                         castExpr->set_arg( ret );
     394                                        castExpr->arg = ret;
    392395                                        ret = castExpr;
    393396                                }
Note: See TracChangeset for help on using the changeset viewer.