Changeset 7543dec for src/SynTree

Timestamp:

Nov 9, 2017, 1:01:14 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

96fc67b

Parents:

049ead9

git-author:

Rob Schluntz <rschlunt@…> (11/08/17 16:40:12)

git-committer:

Rob Schluntz <rschlunt@…> (11/09/17 13:01:14)

Message:

Modify VarExprReplacer? to replace VariableExpr? with arbitrary expression

Location:

src/SynTree

Files:

• CompoundStmt.cc (modified) (2 diffs)
• FunctionDecl.cc (modified) (1 diff)
• VarExprReplacer.cc (modified) (1 diff)
• VarExprReplacer.h (modified) (2 diffs)

src/SynTree/CompoundStmt.cc

@@ -59 +59 @@
                                 DeclarationWithType * origdwt = strict_dynamic_cast< DeclarationWithType * > ( origDeclStmt->get_decl() );
                                 assert( dwt->get_name() == origdwt->get_name() );
-                                declMap[ origdwt ] = dwt;
+                                declMap[ origdwt ] = new VariableExpr( dwt );
                         } else assert( ! dynamic_cast< DeclarationWithType * > ( origDeclStmt->get_decl() ) );
                 } else assert( ! dynamic_cast< DeclStmt * > ( s ) );
@@ -65 +65 @@
         if ( ! declMap.empty() ) {
                 VarExprReplacer replacer( declMap );
-                accept( replacer );
+                acceptMutator( replacer );
         }
 }

src/SynTree/FunctionDecl.cc

@@ -43 +43 @@
         VarExprReplacer::DeclMap declMap;
         for ( auto p : group_iterate( other.type->parameters, type->parameters ) ) {
-                declMap[ std::get<0>(p) ] = std::get<1>(p);
+                declMap[ std::get<0>(p) ] = new VariableExpr( std::get<1>(p) );
         }
         for ( auto p : group_iterate( other.type->returnVals, type->returnVals ) ) {
-                declMap[ std::get<0>(p) ] = std::get<1>(p);
+                declMap[ std::get<0>(p) ] = new VariableExpr( std::get<1>(p) );
         }
         if ( ! declMap.empty() ) {
                 VarExprReplacer replacer( declMap );
-                accept( replacer );
+                acceptMutator( replacer );
         }
 }

src/SynTree/VarExprReplacer.cc

@@ -22 +22 @@
 VarExprReplacer::VarExprReplacer( const DeclMap & declMap, bool debug ) : declMap( declMap ), debug( debug ) {}
 
-// replace variable with new node from decl map
-void VarExprReplacer::visit( VariableExpr * varExpr ) {
-        // xxx - assertions and parameters aren't accounted for in this... (i.e. they aren't inserted into the map when it's made, only DeclStmts are)
-        if ( declMap.count( varExpr->get_var() ) ) {
-                if ( debug ) {
-                        std::cerr << "replacing variable reference: " << (void*)varExpr->get_var() << " " << varExpr->get_var() << " with " << (void*)declMap.at( varExpr->get_var() ) << " " << declMap.at( varExpr->get_var() ) << std::endl;
-                }
-                varExpr->set_var( declMap.at( varExpr->get_var() ) );
+VarExprReplacer::~VarExprReplacer() {
+        for ( auto p : declMap ) {
+                delete p.second;
         }
 }
+
+// replace variable with new node from decl map
+Expression * VarExprReplacer::mutate( VariableExpr * varExpr ) {
+        // xxx - assertions and parameters aren't accounted for in this... (i.e. they aren't inserted into the map when it's made, only DeclStmts are)
+        if ( declMap.count( varExpr->var ) ) {
+                Expression * expr = declMap.at( varExpr->var );
+                if ( debug ) {
+                        std::cerr << "replacing variable reference: " << (void*)varExpr->var << " " << varExpr->var << " with " << (void*)expr << " " << expr << std::endl;
+                }
+                delete varExpr;
+                return expr->clone();
+        }
+        return varExpr;
+}

src/SynTree/VarExprReplacer.h

@@ -24 +24 @@
 
 /// Visitor that replaces the declarations that VariableExprs refer to, according to the supplied mapping
-class VarExprReplacer : public Visitor {
+class VarExprReplacer : public Mutator {
 public:
-        typedef std::map< DeclarationWithType *, DeclarationWithType * > DeclMap;
+        typedef std::map< DeclarationWithType *, Expression * > DeclMap;
 private:
         const DeclMap & declMap;
@@ -32 +32 @@
 public:
         VarExprReplacer( const DeclMap & declMap, bool debug = false );
+        ~VarExprReplacer();
 
         // replace variable with new node from decl map
-        virtual void visit( VariableExpr * varExpr );
+        virtual Expression * mutate( VariableExpr * varExpr );
 
-        static void replace( BaseSyntaxNode * node, const DeclMap & declMap, bool debug = false ) {
+        template<typename Node>
+        static void replace( Node *& node, const DeclMap & declMap, bool debug = false ) {
                 VarExprReplacer replacer( declMap, debug );
-                maybeAccept( node, replacer );
+                node = maybeMutate( node, replacer );
         }
 };