Changeset 0690350

Timestamp:

Jan 12, 2018, 4:57:40 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, 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

Location:

src

Files:

• GenPoly/Box.cc (modified) (4 diffs)
• GenPoly/Lvalue.cc (modified) (7 diffs)
• SynTree/AggregateDecl.cc (modified) (1 diff)
• SynTree/Expression.cc (modified) (2 diffs)

src/GenPoly/Box.cc

@@ -302 +302 @@
         Expression *makeOp( const std::string &name, Expression *arg ) {
                 UntypedExpr *expr = new UntypedExpr( new NameExpr( name ) );
-                expr->get_args().push_back( arg );
+                expr->args.push_back( arg );
                 return expr;
         }
@@ -309 +309 @@
         Expression *makeOp( const std::string &name, Expression *lhs, Expression *rhs ) {
                 UntypedExpr *expr = new UntypedExpr( new NameExpr( name ) );
-                expr->get_args().push_back( lhs );
-                expr->get_args().push_back( rhs );
+                expr->args.push_back( lhs );
+                expr->args.push_back( rhs );
                 return expr;
         }
@@ -316 +316 @@
         /// Returns the dereference of a local pointer variable
         Expression *derefVar( ObjectDecl *var ) {
-                return makeOp( "*?", new VariableExpr( var ) );
+                return UntypedExpr::createDeref( new VariableExpr( var ) );
         }
 
@@ -831 +831 @@
                                 if ( ! isPolyType( arg->get_type() ) ) {
                                         UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
-                                        deref->get_args().push_back( new CastExpr( new VariableExpr( param ), new PointerType( Type::Qualifiers(), arg->get_type()->clone() ) ) );
-                                        deref->set_result( arg->get_type()->clone() );
+                                        deref->args.push_back( new CastExpr( new VariableExpr( param ), new PointerType( Type::Qualifiers(), arg->get_type()->clone() ) ) );
+                                        deref->result = arg->get_type()->clone();
                                         return deref;
                                 } // if

src/GenPoly/Lvalue.cc

@@ -47 +47 @@
                         if ( SymTab::dereferenceOperator ) {
                                 VariableExpr * deref = new VariableExpr( SymTab::dereferenceOperator );
-                                deref->set_result( new PointerType( Type::Qualifiers(), deref->get_result() ) );
-                                Type * base = InitTweak::getPointerBase( arg->get_result() );
-                                assertf( base, "expected pointer type in dereference (type was %s)", toString( arg->get_result() ).c_str() );
+                                deref->result = new PointerType( Type::Qualifiers(), deref->result );
+                                Type * base = InitTweak::getPointerBase( arg->result );
+                                assertf( base, "expected pointer type in dereference (type was %s)", toString( arg->result ).c_str() );
                                 ApplicationExpr * ret = new ApplicationExpr( deref, { arg } );
-                                delete ret->get_result();
-                                ret->set_result( base->clone() );
-                                ret->get_result()->set_lvalue( true );
+                                delete ret->result;
+                                ret->result = base->clone();
+                                ret->result->set_lvalue( true );
                                 return ret;
                         } else {
@@ -308 +308 @@
                                         int diff = depth1-depth2;
                                         if ( diff == 0 ) {
+                                                // conversion between references of the same depth
                                                 assertf( depth1 == depth2, "non-intrinsic reference with cast of reference to reference not yet supported: %d %d %s", depth1, depth2, toString( castExpr ).c_str() );
                                                 PRINT( std::cerr << castExpr << std::endl; )
                                                 return castExpr;
                                         } else if ( diff < 0 ) {
-                                                Expression * ret = castExpr->get_arg();
+                                                // conversion from reference to reference with less depth (e.g. int && -> int &): add dereferences
+                                                Expression * ret = castExpr->arg;
                                                 for ( int i = 0; i < diff; ++i ) {
                                                         ret = mkDeref( ret );
                                                 }
-                                                ret->set_env( castExpr->get_env() );
-                                                delete ret->get_result();
-                                                ret->set_result( castExpr->get_result() );
-                                                castExpr->set_env( nullptr );
-                                                castExpr->set_arg( nullptr );
-                                                castExpr->set_result( nullptr );
+                                                ret->env = castExpr->env;
+                                                delete ret->result;
+                                                ret->result = castExpr->result;
+                                                castExpr->env = nullptr;
+                                                castExpr->arg = nullptr;
+                                                castExpr->result = nullptr;
                                                 delete castExpr;
                                                 return ret;
                                         } else if ( diff > 0 ) {
-                                                Expression * ret = castExpr->get_arg();
+                                                // conversion from reference to reference with more depth (e.g. int & -> int &&): add address-of
+                                                Expression * ret = castExpr->arg;
                                                 for ( int i = 0; i < diff; ++i ) {
                                                         ret = new AddressExpr( ret );
                                                 }
-                                                ret->set_env( castExpr->get_env() );
-                                                delete ret->get_result();
-                                                ret->set_result( castExpr->get_result() );
-                                                castExpr->set_env( nullptr );
-                                                castExpr->set_arg( nullptr );
-                                                castExpr->set_result( nullptr );
+                                                ret->env = castExpr->env;
+                                                delete ret->result;
+                                                ret->result = castExpr->result;
+                                                castExpr->env = nullptr;
+                                                castExpr->arg = nullptr;
+                                                castExpr->result = nullptr;
                                                 delete castExpr;
                                                 return ret;
@@ -342 +345 @@
                                         PRINT( std::cerr << castExpr << std::endl; )
                                         return castExpr;
-                                } else if ( castExpr->get_arg()->get_result()->get_lvalue() ) {
+                                } else if ( castExpr->arg->result->get_lvalue() ) {
                                         // conversion from lvalue to reference
                                         // xxx - keep cast, but turn into pointer cast??
@@ -348 +351 @@
                                         PRINT(
                                                 std::cerr << "convert lvalue to reference -- &" << std::endl;
-                                                std::cerr << castExpr->get_arg() << std::endl;
+                                                std::cerr << castExpr->arg << std::endl;
                                         )
-                                        AddressExpr * ret = new AddressExpr( castExpr->get_arg() );
-                                        if ( refType->get_base()->get_qualifiers() != castExpr->get_arg()->get_result()->get_qualifiers() ) {
+                                        AddressExpr * ret = new AddressExpr( castExpr->arg );
+                                        if ( refType->base->get_qualifiers() != castExpr->arg->result->get_qualifiers() ) {
                                                 // must keep cast if cast-to type is different from the actual type
-                                                castExpr->set_arg( ret );
+                                                castExpr->arg = ret;
                                                 return castExpr;
                                         }
-                                        ret->set_env( castExpr->get_env() );
-                                        delete ret->get_result();
-                                        ret->set_result( castExpr->get_result() );
-                                        castExpr->set_env( nullptr );
-                                        castExpr->set_arg( nullptr );
-                                        castExpr->set_result( nullptr );
+                                        ret->env = castExpr->env;
+                                        delete ret->result;
+                                        ret->result = castExpr->result;
+                                        castExpr->env = nullptr;
+                                        castExpr->arg = nullptr;
+                                        castExpr->result = nullptr;
                                         delete castExpr;
                                         return ret;
@@ -368 +371 @@
                                 }
                                 assertf( false, "Only conversions to reference from lvalue are currently supported: %s", toString( castExpr ).c_str() );
-                        } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( castExpr->get_arg()->get_result() ) ) {
+                        } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( castExpr->arg->result ) ) {
                                 (void)refType;
                                 // conversion from reference to rvalue
@@ -375 +378 @@
                                         std::cerr << "was = " << castExpr << std::endl;
                                 )
-                                Expression * ret = castExpr->get_arg();
-                                TypeSubstitution * env = castExpr->get_env();
+                                Expression * ret = castExpr->arg;
+                                TypeSubstitution * env = castExpr->env;
                                 castExpr->set_env( nullptr );
                                 if ( ! isIntrinsicReference( ret ) ) {
@@ -382 +385 @@
                                         ret = mkDeref( ret );
                                 }
-                                if ( ResolvExpr::typesCompatibleIgnoreQualifiers( castExpr->get_result(), castExpr->get_arg()->get_result()->stripReferences(), SymTab::Indexer() ) ) {
+                                if ( ResolvExpr::typesCompatibleIgnoreQualifiers( castExpr->result, castExpr->arg->result->stripReferences(), SymTab::Indexer() ) ) {
                                         // can remove cast if types are compatible, changing expression type to value type
-                                        ret->set_result( castExpr->get_result()->clone() );
-                                        castExpr->set_arg( nullptr );
+                                        ret->result = castExpr->result->clone();
+                                        castExpr->arg = nullptr;
                                         delete castExpr;
                                 } else {
                                         // must keep cast if types are different
-                                        castExpr->set_arg( ret );
+                                        castExpr->arg = ret;
                                         ret = castExpr;
                                 }

src/SynTree/AggregateDecl.cc

@@ -92 +92 @@
                 } else if ( ConstantExpr * constExpr = dynamic_cast< ConstantExpr * >( expr ) ) {
                         return constExpr->intValue();
+                // can be -1, +1, etc.
+                // } else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * >( expr ) ) {
+                //      if ( untypedExpr-> )
                 } else {
                         assertf( false, "Unhandled expression type in getConstValue for enumerators: %s", toString( expr ).c_str() );

src/SynTree/Expression.cc

@@ -108 +108 @@
         //      assert( inst->baseEnum );
         //      EnumDecl * decl = inst->baseEnum;
-        //      for ( Declaration * member : decl->members ) {
-        //              if ( member == _var ) {
-        //                      type->set_lvalue( false );
-        //              }
+        //      long long int value;
+        //      if ( decl->valueOf( var, value ) ) {
+        //              type->set_lvalue( false );
         //      }
         // }
@@ -416 +415 @@
                 } else {
                         // references have been removed, in which case dereference returns an lvalue of the base type.
-                        ret->get_result()->set_lvalue( true );
+                        ret->result->set_lvalue( true );
                 }
         }