Changeset d5556a3 for src/SynTree

Timestamp:

Dec 13, 2016, 5:37:15 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:

31f379c

Parents:

1d2b64f

Message:

change rework TupleAssignExpr? and StmtExpr?

Location:

src/SynTree

Files:

• Expression.cc (modified) (6 diffs)
• Expression.h (modified) (5 diffs)
• Mutator.cc (modified) (4 diffs)
• TupleExpr.cc (modified) (1 diff)
• Visitor.cc (modified) (4 diffs)

src/SynTree/Expression.cc ¶

@@ -524 +524 @@
 
 ImplicitCopyCtorExpr::~ImplicitCopyCtorExpr() {
+        set_env( nullptr ); // ImplicitCopyCtorExpr does not take ownership of an environment
         delete callExpr;
         deleteAll( tempDecls );
@@ -533 +534 @@
         os <<  "Implicit Copy Constructor Expression: " << std::endl;
         assert( callExpr );
+        os << std::string( indent+2, ' ' );
         callExpr->print( os, indent + 2 );
         os << std::endl << std::string( indent, ' ' ) << "with temporaries:" << std::endl;
@@ -584 +586 @@
         os << std::string( indent+2, ' ' );
         initializer->print( os, indent + 2 );
+        Expression::print( os, indent );
 }
 
@@ -603 +606 @@
         os << " ... ";
         high->print( os, indent );
+        Expression::print( os, indent );
 }
 
@@ -614 +618 @@
         }
 }
-StmtExpr::StmtExpr( const StmtExpr &other ) : Expression( other ), statements( other.statements->clone() ) {}
+StmtExpr::StmtExpr( const StmtExpr &other ) : Expression( other ), statements( other.statements->clone() ) {
+        cloneAll( other.returnDecls, returnDecls );
+        cloneAll( other.dtors, dtors );
+}
 StmtExpr::~StmtExpr() {
         delete statements;
+        deleteAll( dtors );
+        deleteAll( returnDecls );
 }
 void StmtExpr::print( std::ostream &os, int indent ) const {
         os << "Statement Expression: " << std::endl << std::string( indent, ' ' );
         statements->print( os, indent+2 );
+        if ( ! returnDecls.empty() ) {
+                os << std::string( indent+2, ' ' ) << "with returnDecls: ";
+                printAll( returnDecls, os, indent+2 );
+        }
+        if ( ! dtors.empty() ) {
+                os << std::string( indent+2, ' ' ) << "with dtors: ";
+                printAll( dtors, os, indent+2 );
+        }
+        Expression::print( os, indent );
 }
 
@@ -644 +662 @@
         get_expr()->print( os, indent+2 );
         if ( get_object() ) {
-                os << " with decl: ";
+                os << std::string( indent+2, ' ' ) << "with decl: ";
                 get_object()->printShort( os, indent+2 );
         }
+        Expression::print( os, indent );
 }
 

src/SynTree/Expression.h ¶

@@ -543 +543 @@
 
         std::list< ObjectDecl * > & get_tempDecls() { return tempDecls; }
-        void set_tempDecls( std::list< ObjectDecl * > newValue ) { tempDecls = newValue; }
-
         std::list< ObjectDecl * > & get_returnDecls() { return returnDecls; }
-        void set_returnDecls( std::list< ObjectDecl * > newValue ) { returnDecls = newValue; }
-
         std::list< Expression * > & get_dtors() { return dtors; }
-        void set_dtors( std::list< Expression * > newValue ) { dtors = newValue; }
 
         virtual ImplicitCopyCtorExpr *clone() const { return new ImplicitCopyCtorExpr( *this ); }
@@ -706 +701 @@
         virtual ~TupleAssignExpr();
 
-        std::list< Expression * > & get_assigns() { return assigns; }
-        std::list< ObjectDecl * > & get_tempDecls() { return tempDecls; }
+        TupleAssignExpr * set_stmtExpr( StmtExpr * newValue ) { stmtExpr = newValue; return this; }
+        StmtExpr * get_stmtExpr() const { return stmtExpr; }
 
         virtual TupleAssignExpr *clone() const { return new TupleAssignExpr( *this ); }
@@ -714 +709 @@
         virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
-        std::list< Expression * > assigns; // assignment expressions that use tempDecls
-        std::list< ObjectDecl * > tempDecls; // temporaries for address of lhs exprs
+        StmtExpr * stmtExpr = nullptr;
 };
 
@@ -728 +722 @@
         StmtExpr * set_statements( CompoundStmt * newValue ) { statements = newValue; return this; }
 
+        std::list< ObjectDecl * > & get_returnDecls() { return returnDecls; }
+        std::list< Expression * > & get_dtors() { return dtors; }
+
         virtual StmtExpr *clone() const { return new StmtExpr( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
@@ -734 +731 @@
 private:
         CompoundStmt * statements;
+        std::list< ObjectDecl * > returnDecls; // return variable(s) for stmt expression
+        std::list< Expression * > dtors; // destructor(s) for return variable(s)
 };
 

src/SynTree/Mutator.cc ¶

@@ -325 +325 @@
         mutateAll( impCpCtorExpr->get_tempDecls(), *this );
         mutateAll( impCpCtorExpr->get_returnDecls(), *this );
+        mutateAll( impCpCtorExpr->get_dtors(), *this );
         return impCpCtorExpr;
 }
@@ -373 +374 @@
 Expression *Mutator::mutate( TupleAssignExpr *assignExpr ) {
         assignExpr->set_result( maybeMutate( assignExpr->get_result(), *this ) );
-        mutateAll( assignExpr->get_tempDecls(), *this );
-        mutateAll( assignExpr->get_assigns(), *this );
+        assignExpr->set_stmtExpr( maybeMutate( assignExpr->get_stmtExpr(), *this ) );
         return assignExpr;
 }
@@ -381 +381 @@
         stmtExpr->set_result( maybeMutate( stmtExpr->get_result(), *this ) );
         stmtExpr->set_statements( maybeMutate( stmtExpr->get_statements(), *this ) );
+        mutateAll( stmtExpr->get_returnDecls(), *this );
+        mutateAll( stmtExpr->get_dtors(), *this );
         return stmtExpr;
 }
@@ -503 +505 @@
 Initializer *Mutator::mutate( ConstructorInit *ctorInit ) {
         ctorInit->set_ctor( maybeMutate( ctorInit->get_ctor(), *this ) );
+        ctorInit->set_dtor( maybeMutate( ctorInit->get_dtor(), *this ) );
         ctorInit->set_init( maybeMutate( ctorInit->get_init(), *this ) );
         return ctorInit;

src/SynTree/TupleExpr.cc ¶

@@ -87 +87 @@
 }
 
-
-TupleAssignExpr::TupleAssignExpr( const std::list< Expression * > & assigns, const std::list< ObjectDecl * > & tempDecls, Expression * _aname ) : Expression( _aname ), assigns( assigns ), tempDecls( tempDecls ) {
+TupleAssignExpr::TupleAssignExpr( const std::list< Expression * > & assigns, const std::list< ObjectDecl * > & tempDecls, Expression * _aname ) : Expression( _aname ) {
+        // convert internally into a StmtExpr which contains the declarations and produces the tuple of the assignments
         set_result( Tuples::makeTupleType( assigns ) );
+        CompoundStmt * compoundStmt = new CompoundStmt( noLabels );
+        std::list< Statement * > & stmts = compoundStmt->get_kids();
+        for ( ObjectDecl * obj : tempDecls ) {
+                stmts.push_back( new DeclStmt( noLabels, obj ) );
+        }
+        TupleExpr * tupleExpr = new TupleExpr( assigns );
+        assert( tupleExpr->get_result() );
+        stmts.push_back( new ExprStmt( noLabels, tupleExpr ) );
+        stmtExpr = new StmtExpr( compoundStmt );
 }
 
 TupleAssignExpr::TupleAssignExpr( const TupleAssignExpr &other ) : Expression( other ) {
-        cloneAll( other.assigns, assigns );
-        cloneAll( other.tempDecls, tempDecls );
-
-        // clone needs to go into assigns and replace tempDecls
-        VarExprReplacer::DeclMap declMap;
-        std::list< ObjectDecl * >::const_iterator origit = other.tempDecls.begin();
-        for ( ObjectDecl * temp : tempDecls ) {
-                assert( origit != other.tempDecls.end() );
-                ObjectDecl * origTemp = *origit++;
-                assert( origTemp );
-                assert( temp->get_name() == origTemp->get_name() );
-                declMap[ origTemp ] = temp;
-        }
-        if ( ! declMap.empty() ) {
-                VarExprReplacer replacer( declMap );
-                for ( Expression * assn : assigns ) {
-                        assn->accept( replacer );
-                }
-        }
+        assert( other.stmtExpr );
+        stmtExpr = other.stmtExpr->clone();
 }
 
 TupleAssignExpr::~TupleAssignExpr() {
-        deleteAll( assigns );
-        // deleteAll( tempDecls );
+        delete stmtExpr;
 }
 
 void TupleAssignExpr::print( std::ostream &os, int indent ) const {
-        os << "Tuple Assignment Expression, with temporaries:" << std::endl;
-        printAll( tempDecls, os, indent+4 );
-        os << std::string( indent+2, ' ' ) << "with assignments: " << std::endl;
-        printAll( assigns, os, indent+4 );
+        os << "Tuple Assignment Expression, with stmt expr:" << std::endl;
+        os << std::string( indent+2, ' ' );
+        stmtExpr->print( os, indent+4 );
         Expression::print( os, indent );
 }

src/SynTree/Visitor.cc ¶

@@ -276 +276 @@
         acceptAll( impCpCtorExpr->get_tempDecls(), *this );
         acceptAll( impCpCtorExpr->get_returnDecls(), *this );
+        acceptAll( impCpCtorExpr->get_dtors(), *this );
 }
 
@@ -317 +318 @@
 void Visitor::visit( TupleAssignExpr *assignExpr ) {
         maybeAccept( assignExpr->get_result(), *this );
-        acceptAll( assignExpr->get_tempDecls(), *this );
-        acceptAll( assignExpr->get_assigns(), *this );
+        maybeAccept( assignExpr->get_stmtExpr(), *this );
 }
 
@@ -324 +324 @@
         maybeAccept( stmtExpr->get_result(), *this );
         maybeAccept( stmtExpr->get_statements(), *this );
+        acceptAll( stmtExpr->get_returnDecls(), *this );
+        acceptAll( stmtExpr->get_dtors(), *this );
 }
 
@@ -425 +427 @@
 void Visitor::visit( ConstructorInit *ctorInit ) {
         maybeAccept( ctorInit->get_ctor(), *this );
+        maybeAccept( ctorInit->get_dtor(), *this );
         maybeAccept( ctorInit->get_init(), *this );
 }