Changeset 6380f78 for src/AST/DeclReplacer.cpp

Timestamp:

May 22, 2019, 3:40:36 PM (5 years ago)

Author:

Aaron Moss <a3moss@…>

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:

76ed81f

Parents:

d8938622 (diff), f4c2f1a (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

• src/AST/DeclReplacer.cpp (modified) (1 diff)

src/AST/DeclReplacer.cpp

@@ -14 +14 @@
 //
 
-#warning unimplemented
+#include "DeclReplacer.hpp"
+#include "Expr.hpp"
+#include "Type.hpp"
+
+#include "Pass.hpp"
+
+namespace ast {
+
+namespace DeclReplacer {
+        namespace {
+                struct DeclReplacer {
+                private:
+                        const DeclMap & declMap;
+                        const TypeMap & typeMap;
+                        bool debug;
+
+                public:
+                        DeclReplacer(const DeclMap & declMap, const TypeMap & typeMap, bool debug)
+                                : declMap( declMap ), typeMap( typeMap ), debug( debug )
+                        {}
+
+                        const ast::VariableExpr * previsit( const ast::VariableExpr * );
+                        const ast::TypeInstType * previsit( const ast::TypeInstType * );
+                };
+        }
+
+        const ast::Node * replace( const ast::Node * node, const DeclMap & declMap, const TypeMap & typeMap, bool debug ) {
+                if(!node) return nullptr;
+                Pass<DeclReplacer> replacer = { declMap, typeMap, debug };
+                return node->accept( replacer );
+        }
+
+        const ast::Node * replace( const ast::Node * node, const DeclMap & declMap, bool debug ) {
+                TypeMap typeMap;
+                return replace( node, declMap, typeMap, debug );
+        }
+
+        const ast::Node * replace( const ast::Node * node, const TypeMap & typeMap, bool debug ) {
+                DeclMap declMap;
+                return replace( node, declMap, typeMap, debug );
+        }
+
+        namespace {
+                // replace variable with new node from decl map
+                const ast::VariableExpr * DeclReplacer::previsit( const 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 ) ) return varExpr;
+
+                        auto replacement = declMap.at( varExpr->var );
+                        if ( debug ) {
+                                std::cerr << "replacing variable reference: "
+                                        << (void*)varExpr->var.get() << " " << varExpr->var
+                                        << " with " << (void*)replacement << " " << replacement
+                                        << std::endl;
+                        }
+                        auto nexpr = mutate(varExpr);
+                        nexpr->var = replacement;
+                        return nexpr;
+                }
+
+                const TypeInstType * DeclReplacer::previsit( const TypeInstType * inst ) {
+                        if ( !typeMap.count( inst->base ) ) return inst;
+
+                        auto replacement = typeMap.at( inst->base );
+                        if ( debug ) {
+                                std::cerr << "replacing type reference: "
+                                        << (void*)inst->base.get() << " " << inst->base
+                                        << " with " << (void*)replacement << " " << replacement
+                                        << std::endl;
+                        }
+                        auto ninst = mutate(inst);
+                        ninst->base = replacement;
+                        return ninst;
+                }
+        }
+}
+
+}
 
 // Local Variables: //