Changeset b3b2077

Timestamp:

Nov 9, 2016, 2:05:09 PM (8 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:

23bb1b9

Parents:

8780e30

Message:

refactor some code that generates dereference and assignment calls

Location:

src

Files:

• GenPoly/Specialize.cc (modified) (1 diff)
• InitTweak/FixInit.cc (modified) (1 diff)
• SymTab/Validate.cc (modified) (1 diff)
• SynTree/Expression.cc (modified) (2 diffs)
• SynTree/Expression.h (modified) (1 diff)
• Tuples/TupleAssignment.cc (modified) (5 diffs)

src/GenPoly/Specialize.cc

@@ -147 +147 @@
 
         Expression * Specialize::doSpecialization( Type *formalType, Expression *actual, InferredParams *inferParams ) {
-                assert( actual->has_result() );
+                assertf( actual->has_result(), "attempting to specialize an untyped expression" );
                 if ( needsSpecialization( formalType, actual->get_result(), env ) ) {
                         FunctionType *funType;

src/InitTweak/FixInit.cc

@@ -509 +509 @@
                                         // an AddressExpr.  Effectively, this turns
                                         //   lvalue T f();
-                                        //   &*f()
+                                        //   &*f();
                                         // into
+                                        //   T * f();
                                         //   T * tmp_cp_retN;
-                                        //   tmp_cp_ret_N = &*(tmp_cp_ret_N = &*f(), tmp_cp_ret);
+                                        //   &*(tmp_cp_retN = &*f(), tmp_cp_retN);              // the first * and second & are generated here
                                         // which work out in terms of types, but is pretty messy. It would be nice to find a better way.
                                         assign->get_args().back() = new AddressExpr( assign->get_args().back() );
 
-                                        Type * resultType = returnDecl->get_type()->clone();
                                         returnDecl->set_type( new PointerType( Type::Qualifiers(), returnDecl->get_type() ) );
-                                        UntypedExpr * deref = new UntypedExpr( new NameExpr( "*?" ) );
-                                        deref->get_args().push_back( retExpr );
-                                        deref->set_result( resultType );
-                                        retExpr = deref;
+                                        retExpr->set_result( new PointerType( Type::Qualifiers(), retExpr->get_result() ) );
+                                        retExpr = UntypedExpr::createDeref( retExpr );
                                 } // if
                                 retExpr->set_env( env->clone() );

src/SymTab/Validate.cc

@@ -241 +241 @@
                 return dynamic_cast< StructDecl * >( decl ) || dynamic_cast< UnionDecl * >( decl );
         }
-
+        // xxx - shouldn't this be declsToAddBefore?
         template< typename AggDecl >
         void HoistStruct::handleAggregate( AggDecl *aggregateDecl ) {

src/SynTree/Expression.cc

@@ -380 +380 @@
 }
 
+UntypedExpr * UntypedExpr::createDeref( Expression * expr ) {
+        UntypedExpr * ret = new UntypedExpr( new NameExpr("*?"), std::list< Expression * >{ expr } );
+        if ( Type * type = expr->get_result() ) {
+                Type * base = InitTweak::getPointerBase( type );
+                if ( ! base ) {
+                        std::cerr << type << std::endl;
+                }
+                assertf( base, "expected pointer type in dereference\n" );
+                ret->set_result( maybeClone( base ) );
+        }
+        return ret;
+}
+
+UntypedExpr * UntypedExpr::createAssign( Expression * arg1, Expression * arg2 ) {
+        assert( arg1 && arg2 );
+        UntypedExpr * ret = new UntypedExpr( new NameExpr( "?=?" ), std::list< Expression * >{ arg1, arg2 } );
+        if ( arg1->get_result() && arg2->get_result() ) {
+                // if both expressions are typed, assumes that this assignment is a C bitwise assignment,
+                // so the result is the type of the RHS
+                ret->set_result( arg2->get_result()->clone() );
+        }
+        return ret;
+}
+
+
 void UntypedExpr::print( std::ostream &os, int indent ) const {
         os << "Applying untyped: " << std::endl;
@@ -446 +471 @@
 
 void ConditionalExpr::print( std::ostream &os, int indent ) const {
-        os << std::string( indent, ' ' ) << "Conditional expression on: " << std::endl;
+        os << "Conditional expression on: " << std::endl;
+        os << std::string( indent+2, ' ' );
         arg1->print( os, indent+2 );
         os << std::string( indent, ' ' ) << "First alternative:" << std::endl;
+        os << std::string( indent+2, ' ' );
         arg2->print( os, indent+2 );
         os << std::string( indent, ' ' ) << "Second alternative:" << std::endl;
+        os << std::string( indent+2, ' ' );
         arg3->print( os, indent+2 );
         os << std::endl;

src/SynTree/Expression.h

@@ -111 +111 @@
         std::list<Expression*>& get_args() { return args; }
 
+        static UntypedExpr * createDeref( Expression * arg );
+        static UntypedExpr * createAssign( Expression * arg1, Expression * arg2 );
+
         virtual UntypedExpr *clone() const { return new UntypedExpr( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }

src/Tuples/TupleAssignment.cc

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Mon May 18 15:02:53 2015
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Nov 9 13:48:42 2016
 // Update Count     : 2
 //
@@ -180 +180 @@
                 // explode the lhs so that each field of the tuple-valued-expr is assigned.
                 explode( lhsAlt, spotter.currentFinder.get_indexer(), back_inserter(lhs) );
+
                 // and finally, re-add the cast to each lhs expr, so that qualified tuple fields can be constructed
                 if ( isCast ) {
@@ -192 +193 @@
                         }
                 }
-                // }
-        }
-
-        TupleAssignSpotter::MassAssignMatcher::MassAssignMatcher( TupleAssignSpotter &spotter,const ResolvExpr::AltList & alts ) : Matcher( spotter, alts ) {
+        }
+
+        TupleAssignSpotter::MassAssignMatcher::MassAssignMatcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList & alts ) : Matcher( spotter, alts ) {
                 assert( alts.size() == 1 || alts.size() == 2 );
                 if ( alts.size() == 2 ) {
@@ -210 +210 @@
                 assert( left );
                 std::list< Expression * > args;
-                args.push_back( new AddressExpr( new UntypedExpr( new NameExpr("*?"), std::list< Expression * >{ new VariableExpr( left ) } ) ) );
+                args.push_back( new AddressExpr( UntypedExpr::createDeref( new VariableExpr( left ) ) ) );
                 // args.push_back( new AddressExpr( new VariableExpr( left ) ) );
                 if ( right ) args.push_back( new VariableExpr( right ) );
@@ -238 +238 @@
                 static UniqueName lhsNamer( "__multassign_L" );
                 static UniqueName rhsNamer( "__multassign_R" );
+
                 // xxx - need more complicated matching?
                 if ( lhs.size() == rhs.size() ) {