Changeset 23bb1b9 for src/SynTree

Timestamp:

Nov 9, 2016, 2:10:00 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:

141b786

Parents:

b3b2077

git-author:

Rob Schluntz <rschlunt@…> (11/09/16 14:09:29)

git-committer:

Rob Schluntz <rschlunt@…> (11/09/16 14:10:00)

Message:

refactor VarExprReplacer? and reuse it in TupleAssignExpr?

Location:

src/SynTree

Files:

• CompoundStmt.cc (modified) (2 diffs)
• TupleExpr.cc (modified) (2 diffs)
• VarExprReplacer.cc (added)
• VarExprReplacer.h (added)
• module.mk (modified) (1 diff)

src/SynTree/CompoundStmt.cc

@@ -20 +20 @@
 #include "Expression.h"
 #include "Declaration.h"
+#include "SynTree/VarExprReplacer.h"
 
 using std::string;
 using std::endl;
-
-class VarExprReplacer : public Visitor {
-public:
-  typedef std::map< DeclarationWithType *, DeclarationWithType * > DeclMap;
-private:
-  const DeclMap & declMap;
-public:
-  VarExprReplacer( const DeclMap & declMap ) : declMap( declMap ) {}
-
-  // replace variable with new node from decl map
-  virtual void visit( VariableExpr * varExpr ) {
-    if ( declMap.count( varExpr->get_var() ) ) {
-      varExpr->set_var( declMap.at( varExpr->get_var() ) );
-    }
-  }
-};
-
 
 CompoundStmt::CompoundStmt( std::list<Label> labels ) : Statement( labels ) {
@@ -47 +31 @@
         cloneAll( other.kids, kids );
 
-  // when cloning a compound statement, we may end up cloning declarations which
-  // are referred to by VariableExprs throughout the block. Cloning a VariableExpr
-  // does a shallow copy, so the VariableExpr will end up pointing to the original
-  // declaration. If the original declaration is deleted, e.g. because the original
-  // CompoundStmt is deleted, then we have a dangling pointer. To avoid this case,
-  // find all DeclarationWithType nodes (since a VariableExpr must point to a
-  // DeclarationWithType) in the original CompoundStmt and map them to the cloned
-  // node in the new CompoundStmt ('this'), then replace the Declarations referred to
-  // by each VariableExpr according to the constructed map. Note that only the declarations
-  // in the current level are collected into the map, because child CompoundStmts will
-  // recursively execute this routine. There may be more efficient ways of doing
-  // this.
-  VarExprReplacer::DeclMap declMap;
-  std::list< Statement * >::const_iterator origit = other.kids.begin();
-  for ( Statement * s : kids ) {
-    assert( origit != other.kids.end() );
-    if ( DeclStmt * declStmt = dynamic_cast< DeclStmt * >( s ) ) {
-      DeclStmt * origDeclStmt = dynamic_cast< DeclStmt * >( *origit );
-      assert( origDeclStmt );
-      if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * > ( declStmt->get_decl() ) ) {
-        DeclarationWithType * origdwt = dynamic_cast< DeclarationWithType * > ( origDeclStmt->get_decl() );
-        assert( origdwt );
-        declMap[ origdwt ] = dwt;
-      }
-    }
-  }
-  if ( ! declMap.empty() ) {
-    VarExprReplacer replacer( declMap );
-    accept( replacer );
-  }
+        // when cloning a compound statement, we may end up cloning declarations which
+        // are referred to by VariableExprs throughout the block. Cloning a VariableExpr
+        // does a shallow copy, so the VariableExpr will end up pointing to the original
+        // declaration. If the original declaration is deleted, e.g. because the original
+        // CompoundStmt is deleted, then we have a dangling pointer. To avoid this case,
+        // find all DeclarationWithType nodes (since a VariableExpr must point to a
+        // DeclarationWithType) in the original CompoundStmt and map them to the cloned
+        // node in the new CompoundStmt ('this'), then replace the Declarations referred to
+        // by each VariableExpr according to the constructed map. Note that only the declarations
+        // in the current level are collected into the map, because child CompoundStmts will
+        // recursively execute this routine. There may be more efficient ways of doing
+        // this.
+        VarExprReplacer::DeclMap declMap;
+        std::list< Statement * >::const_iterator origit = other.kids.begin();
+        for ( Statement * s : kids ) {
+                assert( origit != other.kids.end() );
+                Statement * origStmt = *origit++;
+                if ( DeclStmt * declStmt = dynamic_cast< DeclStmt * >( s ) ) {
+                        DeclStmt * origDeclStmt = dynamic_cast< DeclStmt * >( origStmt );
+                        assert( origDeclStmt );
+                        if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * > ( declStmt->get_decl() ) ) {
+                                DeclarationWithType * origdwt = dynamic_cast< DeclarationWithType * > ( origDeclStmt->get_decl() );
+                                assert( origdwt );
+                                assert( dwt->get_name() == origdwt->get_name() );
+                                declMap[ origdwt ] = dwt;
+                        }
+                }
+        }
+        if ( ! declMap.empty() ) {
+                VarExprReplacer replacer( declMap );
+                accept( replacer );
+        }
 }
 

src/SynTree/TupleExpr.cc

@@ -19 +19 @@
 #include "Declaration.h"
 #include "Tuples/Tuples.h"
+#include "VarExprReplacer.h"
 
 TupleExpr::TupleExpr( const std::list< Expression * > & exprs, Expression *_aname ) : Expression( _aname ), exprs( exprs ) {
@@ -91 +92 @@
 }
 
-TupleAssignExpr::TupleAssignExpr( const TupleAssignExpr &other ) : Expression( other ), tempDecls( other.tempDecls ) /* temporary */ {
+TupleAssignExpr::TupleAssignExpr( const TupleAssignExpr &other ) : Expression( other ) {
         cloneAll( other.assigns, assigns );
-        // xxx - clone needs to go into assigns and replace tempDecls
+        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 );
+                }
+        }
 }
 

src/SynTree/module.mk

@@ -49 +49 @@
        SynTree/AddStmtVisitor.cc \
        SynTree/TypeSubstitution.cc \
-       SynTree/Attribute.cc
+       SynTree/Attribute.cc \
+       SynTree/VarExprReplacer.cc