Changes in src/SymTab/Autogen.cc [8b11840:4e8949f]

File:

• src/SymTab/Autogen.cc (modified) (15 diffs)

src/SymTab/Autogen.cc

@@ -16 +16 @@
 #include "Autogen.h"
 
+#include <cstddef>                 // for NULL
 #include <algorithm>               // for count_if
 #include <cassert>                 // for strict_dynamic_cast, assert, assertf
@@ -26 +27 @@
 #include "AddVisit.h"              // for addVisit
 #include "CodeGen/OperatorTable.h" // for isCtorDtor, isCtorDtorAssign
-#include "Common/PassVisitor.h"    // for PassVisitor
 #include "Common/ScopedMap.h"      // for ScopedMap<>::const_iterator, Scope...
 #include "Common/utility.h"        // for cloneAll, operator+
 #include "GenPoly/DeclMutator.h"   // for DeclMutator
 #include "GenPoly/ScopedSet.h"     // for ScopedSet, ScopedSet<>::iterator
-#include "InitTweak/GenInit.h"     // for fixReturnStatements
-#include "ResolvExpr/Resolver.h"   // for resolveDecl
 #include "SymTab/Mangler.h"        // for Mangler
 #include "SynTree/Attribute.h"     // For Attribute
@@ -55 +53 @@
         };
 
-        struct AutogenerateRoutines final : public WithDeclsToAdd, public WithVisitorRef<AutogenerateRoutines>, public WithGuards, public WithShortCircuiting {
+        class AutogenerateRoutines final : public Visitor {
+            template< typename Visitor >
+            friend void acceptAndAdd( std::list< Declaration * > &translationUnit, Visitor &visitor );
+            template< typename Visitor >
+            friend void addVisitStatementList( std::list< Statement* > &stmts, Visitor &visitor );
+          public:
+                std::list< Declaration * > &get_declsToAdd() { return declsToAdd; }
+
+                typedef Visitor Parent;
+                using Parent::visit;
+
                 AutogenerateRoutines();
 
-                void previsit( EnumDecl * enumDecl );
-                void previsit( StructDecl * structDecl );
-                void previsit( UnionDecl * structDecl );
-                void previsit( TypeDecl * typeDecl );
-                void previsit( TraitDecl * traitDecl );
-                void previsit( FunctionDecl * functionDecl );
-
-                void previsit( FunctionType * ftype );
-                void previsit( PointerType * ptype );
-
-                void previsit( CompoundStmt * compoundStmt );
+                virtual void visit( EnumDecl *enumDecl );
+                virtual void visit( StructDecl *structDecl );
+                virtual void visit( UnionDecl *structDecl );
+                virtual void visit( TypeDecl *typeDecl );
+                virtual void visit( TraitDecl *ctxDecl );
+                virtual void visit( FunctionDecl *functionDecl );
+
+                virtual void visit( FunctionType *ftype );
+                virtual void visit( PointerType *ftype );
+
+                virtual void visit( CompoundStmt *compoundStmt );
+                virtual void visit( SwitchStmt *switchStmt );
 
           private:
-                GenPoly::ScopedSet< std::string > structsDone;
+                template< typename StmtClass > void visitStatement( StmtClass *stmt );
+
+                std::list< Declaration * > declsToAdd, declsToAddAfter;
+                std::set< std::string > structsDone;
                 unsigned int functionNesting = 0;     // current level of nested functions
                 /// Note: the following maps could be ScopedSets, but it should be easier to work
@@ -100 +112 @@
 
         void autogenerateRoutines( std::list< Declaration * > &translationUnit ) {
-                PassVisitor<AutogenerateRoutines> generator;
-                acceptAll( translationUnit, generator );
+                AutogenerateRoutines generator;
+                acceptAndAdd( translationUnit, generator );
 
                 // needs to be done separately because AutogenerateRoutines skips types that appear as function arguments, etc.
@@ -109 +121 @@
 
         bool isUnnamedBitfield( ObjectDecl * obj ) {
-                return obj != nullptr && obj->get_name() == "" && obj->get_bitfieldWidth() != nullptr;
+                return obj != NULL && obj->get_name() == "" && obj->get_bitfieldWidth() != NULL;
         }
 
@@ -116 +128 @@
                 FunctionDecl * decl = functionDecl->clone();
                 delete decl->get_statements();
-                decl->set_statements( nullptr );
+                decl->set_statements( NULL );
                 declsToAdd.push_back( decl );
                 decl->fixUniqueId();
@@ -327 +339 @@
                                 assert( ! func->get_functionType()->get_parameters().empty() );
                                 ObjectDecl * dstParam = dynamic_cast<ObjectDecl*>( func->get_functionType()->get_parameters().front() );
-                                ObjectDecl * srcParam = nullptr;
+                                ObjectDecl * srcParam = NULL;
                                 if ( func->get_functionType()->get_parameters().size() == 2 ) {
                                         srcParam = dynamic_cast<ObjectDecl*>( func->get_functionType()->get_parameters().back() );
@@ -334 +346 @@
                                 assert( dstParam );
 
-                                Expression *srcselect = srcParam ? new MemberExpr( field, new VariableExpr( srcParam ) ) : nullptr;
+                                Expression *srcselect = srcParam ? new MemberExpr( field, new VariableExpr( srcParam ) ) : NULL;
                                 makeStructMemberOp( dstParam, srcselect, field, func, forward );
                         } // if
@@ -373 +385 @@
                                 } else {
                                         // no matching parameter, initialize field with default ctor
-                                        makeStructMemberOp( dstParam, nullptr, field, func );
+                                        makeStructMemberOp( dstParam, NULL, field, func );
                                 }
                         }
@@ -389 +401 @@
         void makeStructFunctions( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting, std::list< Declaration * > & declsToAdd, const std::vector< FuncData > & data ) {
                 // Builtins do not use autogeneration.
-                if ( LinkageSpec::isBuiltin( aggregateDecl->get_linkage() ) ) {
+                if ( aggregateDecl->get_linkage() == LinkageSpec::BuiltinCFA ||
+                         aggregateDecl->get_linkage() == LinkageSpec::BuiltinC ) {
                         return;
                 }
 
                 // Make function polymorphic in same parameters as generic struct, if applicable
-                const std::list< TypeDecl * > & typeParams = aggregateDecl->get_parameters(); // List of type variables to be placed on the generated functions
+                const std::list< TypeDecl* > & typeParams = aggregateDecl->get_parameters(); // List of type variables to be placed on the generated functions
 
                 // generate each of the functions based on the supplied FuncData objects
@@ -559 +572 @@
                 // the order here determines the order that these functions are generated.
                 // assignment should come last since it uses copy constructor in return.
-                data.emplace_back( "?{}", genDefaultType, constructable );
-                data.emplace_back( "?{}", genCopyType, copyable );
-                data.emplace_back( "^?{}", genDefaultType, destructable );
-                data.emplace_back( "?=?", genAssignType, assignable );
-        }
-
-        void AutogenerateRoutines::previsit( EnumDecl * enumDecl ) {
-                visit_children = false;
+                data.push_back( FuncData( "?{}", genDefaultType, constructable ) );
+                data.push_back( FuncData( "?{}", genCopyType, copyable ) );
+                data.push_back( FuncData( "^?{}", genDefaultType, destructable ) );
+                data.push_back( FuncData( "?=?", genAssignType, assignable ) );
+        }
+
+        void AutogenerateRoutines::visit( EnumDecl *enumDecl ) {
                 if ( ! enumDecl->get_members().empty() ) {
                         EnumInstType *enumInst = new EnumInstType( Type::Qualifiers(), enumDecl->get_name() );
@@ -574 +586 @@
         }
 
-        void AutogenerateRoutines::previsit( StructDecl * structDecl ) {
-                visit_children = false;
-                if ( structDecl->has_body() && structsDone.find( structDecl->name ) == structsDone.end() ) {
-                        StructInstType structInst( Type::Qualifiers(), structDecl->name );
-                        for ( TypeDecl * typeDecl : structDecl->parameters ) {
+        void AutogenerateRoutines::visit( StructDecl *structDecl ) {
+                if ( structDecl->has_body() && structsDone.find( structDecl->get_name() ) == structsDone.end() ) {
+                        StructInstType structInst( Type::Qualifiers(), structDecl->get_name() );
+                        for ( TypeDecl * typeDecl : structDecl->get_parameters() ) {
                                 // need to visit assertions so that they are added to the appropriate maps
-                                acceptAll( typeDecl->assertions, *visitor );
-                                structInst.parameters.push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeDecl->name, typeDecl ) ) );
+                                acceptAll( typeDecl->get_assertions(), *this );
+                                structInst.get_parameters().push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeDecl->get_name(), typeDecl ) ) );
                         }
                         structInst.set_baseStruct( structDecl );
                         makeStructFunctions( structDecl, &structInst, functionNesting, declsToAddAfter, data );
-                        structsDone.insert( structDecl->name );
+                        structsDone.insert( structDecl->get_name() );
                 } // if
         }
 
-        void AutogenerateRoutines::previsit( UnionDecl * unionDecl ) {
-                visit_children = false;
+        void AutogenerateRoutines::visit( UnionDecl *unionDecl ) {
                 if ( ! unionDecl->get_members().empty() ) {
                         UnionInstType unionInst( Type::Qualifiers(), unionDecl->get_name() );
@@ -609 +619 @@
 
         // generate ctor/dtors/assign for typedecls, e.g., otype T = int *;
-        void AutogenerateRoutines::previsit( TypeDecl * typeDecl ) {
-                visit_children = false;
+        void AutogenerateRoutines::visit( TypeDecl *typeDecl ) {
                 if ( ! typeDecl->base ) return;
 
@@ -655 +664 @@
         }
 
-        void AutogenerateRoutines::previsit( FunctionType *) {
+        void addDecls( std::list< Declaration * > &declsToAdd, std::list< Statement * > &statements, std::list< Statement * >::iterator i ) {
+                for ( std::list< Declaration * >::iterator decl = declsToAdd.begin(); decl != declsToAdd.end(); ++decl ) {
+                        statements.insert( i, new DeclStmt( noLabels, *decl ) );
+                } // for
+                declsToAdd.clear();
+        }
+
+        void AutogenerateRoutines::visit( FunctionType *) {
                 // ensure that we don't add assignment ops for types defined as part of the function
-                visit_children = false;
-        }
-
-        void AutogenerateRoutines::previsit( PointerType *) {
+        }
+
+        void AutogenerateRoutines::visit( PointerType *) {
                 // ensure that we don't add assignment ops for types defined as part of the pointer
-                visit_children = false;
-        }
-
-        void AutogenerateRoutines::previsit( TraitDecl * ) {
+        }
+
+        void AutogenerateRoutines::visit( TraitDecl *) {
                 // ensure that we don't add assignment ops for types defined as part of the trait
-                visit_children = false;
-        }
-
-        void AutogenerateRoutines::previsit( FunctionDecl * functionDecl ) {
-                visit_children = false;
+        }
+
+        template< typename StmtClass >
+        inline void AutogenerateRoutines::visitStatement( StmtClass *stmt ) {
+                std::set< std::string > oldStructs = structsDone;
+                addVisit( stmt, *this );
+                structsDone = oldStructs;
+        }
+
+        void AutogenerateRoutines::visit( FunctionDecl *functionDecl ) {
                 // record the existence of this function as appropriate
                 insert( functionDecl, constructable, InitTweak::isDefaultConstructor );
@@ -678 +697 @@
                 insert( functionDecl, destructable, InitTweak::isDestructor );
 
-                maybeAccept( functionDecl->type, *visitor );
+                maybeAccept( functionDecl->get_functionType(), *this );
                 functionNesting += 1;
-                maybeAccept( functionDecl->statements, *visitor );
+                maybeAccept( functionDecl->get_statements(), *this );
                 functionNesting -= 1;
         }
 
-        void AutogenerateRoutines::previsit( CompoundStmt * ) {
-                GuardScope( constructable );
-                GuardScope( assignable );
-                GuardScope( copyable );
-                GuardScope( destructable );
-                GuardScope( structsDone );
+        void AutogenerateRoutines::visit( CompoundStmt *compoundStmt ) {
+                constructable.beginScope();
+                assignable.beginScope();
+                copyable.beginScope();
+                destructable.beginScope();
+                visitStatement( compoundStmt );
+                constructable.endScope();
+                assignable.endScope();
+                copyable.endScope();
+                destructable.endScope();
+        }
+
+        void AutogenerateRoutines::visit( SwitchStmt *switchStmt ) {
+                visitStatement( switchStmt );
         }