Changeset fc12f05 for src/CodeGen/Generate.cc

Timestamp:

Nov 13, 2023, 3:43:43 AM (23 months ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

25f2798

Parents:

0030b508 (diff), 2174191 (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/CodeGen/Generate.cc (modified) (1 diff)

src/CodeGen/Generate.cc

@@ -19 +19 @@
 #include <string>                    // for operator<<
 
-#include "CodeGenerator.h"           // for CodeGenerator, doSemicolon, oper...
+#include "CodeGeneratorNew.hpp"      // for CodeGenerator_new, doSemicolon, ...
 #include "GenType.h"                 // for genPrettyType
-#include "Common/PassVisitor.h"      // for PassVisitor
-#include "SynTree/LinkageSpec.h"     // for isBuiltin, isGeneratable
-#include "SynTree/BaseSyntaxNode.h"  // for BaseSyntaxNode
-#include "SynTree/Declaration.h"     // for Declaration
-#include "SynTree/Type.h"            // for Type
 
 using namespace std;
 
 namespace CodeGen {
-        namespace {
-                /// Removes misc. nodes that should not exist in CodeGen
-                struct TreeCleaner {
-                        void premutate( CompoundStmt * stmt );
-                        Statement * postmutate( ImplicitCtorDtorStmt * stmt );
 
-                        static bool shouldClean( Declaration * );
-                };
-
-                void cleanTree( std::list< Declaration * > & translationUnit ) {
-                        PassVisitor<TreeCleaner> cleaner;
-                        filter( translationUnit, [](Declaration * decl) { return TreeCleaner::shouldClean(decl); }, false );
-                        mutateAll( translationUnit, cleaner );
-                } // cleanTree
-        } // namespace
-
-        void generate( std::list< Declaration* > translationUnit, std::ostream &os, bool doIntrinsics, bool pretty, bool generateC, bool lineMarks, bool printExprTypes ) {
-                cleanTree( translationUnit );
-
-                PassVisitor<CodeGenerator> cgv( os, pretty, generateC, lineMarks, printExprTypes );
-                for ( auto & dcl : translationUnit ) {
-                        if ( LinkageSpec::isGeneratable( dcl->get_linkage() ) && (doIntrinsics || ! LinkageSpec::isBuiltin( dcl->get_linkage() ) ) ) {
-                                cgv.pass.updateLocation( dcl );
-                                dcl->accept(cgv);
-                                if ( doSemicolon( dcl ) ) {
-                                        os << ";";
-                                } // if
-                                os << cgv.pass.endl;
-                        } // if
-                } // for
+namespace {
+        bool shouldClean( ast::Decl const * decl ) {
+                return dynamic_cast<ast::TraitDecl const *>( decl );
         }
 
-        void generate( BaseSyntaxNode * node, std::ostream & os ) {
-                if ( Type * type = dynamic_cast< Type * >( node ) ) {
-                        os << genPrettyType( type, "" );
-                } else {
-                        PassVisitor<CodeGenerator> cgv( os, true, false, false, false );
-                        node->accept( cgv );
-                }
-                os << std::endl;
-        }
-
-        namespace {
-                void TreeCleaner::premutate( CompoundStmt * cstmt ) {
-                        filter( cstmt->kids, [](Statement * stmt) {
-                                if ( DeclStmt * declStmt = dynamic_cast< DeclStmt * >( stmt ) ) {
-                                        return shouldClean( declStmt->decl );
-                                }
-                                return false;
-                        }, false );
+        /// Removes various nodes that should not exist in CodeGen.
+        struct TreeCleaner_new {
+                ast::CompoundStmt const * previsit( ast::CompoundStmt const * stmt ) {
+                        auto mutStmt = ast::mutate( stmt );
+                        erase_if( mutStmt->kids, []( ast::Stmt const * stmt ){
+                                auto declStmt = dynamic_cast<ast::DeclStmt const *>( stmt );
+                                return ( declStmt ) ? shouldClean( declStmt->decl ) : false;
+                        } );
+                        return mutStmt;
                 }
 
-                Statement * TreeCleaner::postmutate( ImplicitCtorDtorStmt * stmt ) {
-                        Statement * callStmt = nullptr;
-                        std::swap( stmt->callStmt, callStmt );
-                        delete stmt;
-                        return callStmt;
+                ast::Stmt const * postvisit( ast::ImplicitCtorDtorStmt const * stmt ) {
+                        return stmt->callStmt;
                 }
+        };
+} // namespace
 
-                bool TreeCleaner::shouldClean( Declaration * decl ) {
-                        return dynamic_cast< TraitDecl * >( decl );
+void generate( ast::TranslationUnit & translationUnit, std::ostream & os, bool doIntrinsics,
+                bool pretty, bool generateC, bool lineMarks, bool printExprTypes ) {
+        erase_if( translationUnit.decls, shouldClean );
+        ast::Pass<TreeCleaner_new>::run( translationUnit );
+
+        ast::Pass<CodeGenerator_new> cgv( os,
+                        Options( pretty, generateC, lineMarks, printExprTypes ) );
+        for ( auto & decl : translationUnit.decls ) {
+                if ( decl->linkage.is_generatable && (doIntrinsics || !decl->linkage.is_builtin ) ) {
+                        cgv.core.updateLocation( decl );
+                        decl->accept( cgv );
+                        if ( doSemicolon( decl ) ) {
+                                os << ";";
+                        }
+                        os << cgv.core.endl;
                 }
-        } // namespace
+        }
+}
+
 } // namespace CodeGen