Changes in src/SynTree/CompoundStmt.cc [60089f4:23bb1b9]

File:

• src/SynTree/CompoundStmt.cc (modified) (3 diffs)

src/SynTree/CompoundStmt.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Rob Schluntz
-// Last Modified On : Mon May 02 15:10:47 2016
+// Last Modified On : Mon May 02 15:19:17 2016
 // Update Count     : 3
 //
@@ -18 +18 @@
 #include <algorithm>
 #include <functional>
+#include "Expression.h"
+#include "Declaration.h"
+#include "SynTree/VarExprReplacer.h"
 
 using std::string;
@@ -27 +30 @@
 CompoundStmt::CompoundStmt( const CompoundStmt &other ) : Statement( other ) {
         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() );
+                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 );
+        }
 }