Changeset 74bba15 for src/SymTab/Autogen.cc

Timestamp:

Sep 26, 2017, 5:19:32 PM (7 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

5dc26f5

Parents:

af58ee0 (diff), a7d151f (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/SymTab/Autogen.cc (modified) (17 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
@@ -27 +26 @@
 #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
@@ -53 +54 @@
         };
 
-        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;
-
+        struct AutogenerateRoutines final : public WithDeclsToAdd, public WithVisitorRef<AutogenerateRoutines>, public WithGuards, public WithShortCircuiting {
                 AutogenerateRoutines();
 
-                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 );
+                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 );
 
           private:
-                template< typename StmtClass > void visitStatement( StmtClass *stmt );
-
-                std::list< Declaration * > declsToAdd, declsToAddAfter;
-                std::set< std::string > structsDone;
+                GenPoly::ScopedSet< 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
@@ -93 +80 @@
 
         /// generates routines for tuple types.
-        /// Doesn't really need to be a mutator, but it's easier to reuse DeclMutator than it is to use AddVisit
-        /// or anything we currently have that supports adding new declarations for visitors
-        class AutogenTupleRoutines : public GenPoly::DeclMutator {
-          public:
-                typedef GenPoly::DeclMutator Parent;
-                using Parent::mutate;
-
-                virtual DeclarationWithType * mutate( FunctionDecl *functionDecl );
-
-                virtual Type * mutate( TupleType *tupleType );
-
-                virtual CompoundStmt * mutate( CompoundStmt *compoundStmt );
+        struct AutogenTupleRoutines : public WithDeclsToAdd, public WithVisitorRef<AutogenTupleRoutines>, public WithGuards, public WithShortCircuiting {
+                void previsit( FunctionDecl *functionDecl );
+
+                void postvisit( TupleType *tupleType );
+
+                void previsit( CompoundStmt *compoundStmt );
 
           private:
@@ -112 +93 @@
 
         void autogenerateRoutines( std::list< Declaration * > &translationUnit ) {
-                AutogenerateRoutines generator;
-                acceptAndAdd( translationUnit, generator );
+                PassVisitor<AutogenerateRoutines> generator;
+                acceptAll( translationUnit, generator );
 
                 // needs to be done separately because AutogenerateRoutines skips types that appear as function arguments, etc.
                 // AutogenTupleRoutines tupleGenerator;
-                // tupleGenerator.mutateDeclarationList( translationUnit );
+                // acceptAll( translationUnit, tupleGenerator );
         }
 
         bool isUnnamedBitfield( ObjectDecl * obj ) {
-                return obj != NULL && obj->get_name() == "" && obj->get_bitfieldWidth() != NULL;
+                return obj != nullptr && obj->get_name() == "" && obj->get_bitfieldWidth() != nullptr;
         }
 
@@ -128 +109 @@
                 FunctionDecl * decl = functionDecl->clone();
                 delete decl->get_statements();
-                decl->set_statements( NULL );
+                decl->set_statements( nullptr );
                 declsToAdd.push_back( decl );
                 decl->fixUniqueId();
@@ -339 +320 @@
                                 assert( ! func->get_functionType()->get_parameters().empty() );
                                 ObjectDecl * dstParam = dynamic_cast<ObjectDecl*>( func->get_functionType()->get_parameters().front() );
-                                ObjectDecl * srcParam = NULL;
+                                ObjectDecl * srcParam = nullptr;
                                 if ( func->get_functionType()->get_parameters().size() == 2 ) {
                                         srcParam = dynamic_cast<ObjectDecl*>( func->get_functionType()->get_parameters().back() );
@@ -346 +327 @@
                                 assert( dstParam );
 
-                                Expression *srcselect = srcParam ? new MemberExpr( field, new VariableExpr( srcParam ) ) : NULL;
+                                Expression *srcselect = srcParam ? new MemberExpr( field, new VariableExpr( srcParam ) ) : nullptr;
                                 makeStructMemberOp( dstParam, srcselect, field, func, forward );
                         } // if
@@ -385 +366 @@
                                 } else {
                                         // no matching parameter, initialize field with default ctor
-                                        makeStructMemberOp( dstParam, NULL, field, func );
+                                        makeStructMemberOp( dstParam, nullptr, field, func );
                                 }
                         }
@@ -401 +382 @@
         void makeStructFunctions( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting, std::list< Declaration * > & declsToAdd, const std::vector< FuncData > & data ) {
                 // Builtins do not use autogeneration.
-                if ( aggregateDecl->get_linkage() == LinkageSpec::BuiltinCFA ||
-                         aggregateDecl->get_linkage() == LinkageSpec::BuiltinC ) {
+                if ( LinkageSpec::isBuiltin( aggregateDecl->get_linkage() ) ) {
                         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
@@ -572 +552 @@
                 // the order here determines the order that these functions are generated.
                 // assignment should come last since it uses copy constructor in return.
-                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 ) {
+                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;
                 if ( ! enumDecl->get_members().empty() ) {
                         EnumInstType *enumInst = new EnumInstType( Type::Qualifiers(), enumDecl->get_name() );
@@ -586 +567 @@
         }
 
-        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() ) {
+        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 ) {
                                 // need to visit assertions so that they are added to the appropriate maps
-                                acceptAll( typeDecl->get_assertions(), *this );
-                                structInst.get_parameters().push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeDecl->get_name(), typeDecl ) ) );
+                                acceptAll( typeDecl->assertions, *visitor );
+                                structInst.parameters.push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeDecl->name, typeDecl ) ) );
                         }
                         structInst.set_baseStruct( structDecl );
                         makeStructFunctions( structDecl, &structInst, functionNesting, declsToAddAfter, data );
-                        structsDone.insert( structDecl->get_name() );
+                        structsDone.insert( structDecl->name );
                 } // if
         }
 
-        void AutogenerateRoutines::visit( UnionDecl *unionDecl ) {
+        void AutogenerateRoutines::previsit( UnionDecl * unionDecl ) {
+                visit_children = false;
                 if ( ! unionDecl->get_members().empty() ) {
                         UnionInstType unionInst( Type::Qualifiers(), unionDecl->get_name() );
@@ -619 +602 @@
 
         // generate ctor/dtors/assign for typedecls, e.g., otype T = int *;
-        void AutogenerateRoutines::visit( TypeDecl *typeDecl ) {
+        void AutogenerateRoutines::previsit( TypeDecl * typeDecl ) {
+                visit_children = false;
                 if ( ! typeDecl->base ) return;
 
@@ -664 +648 @@
         }
 
-        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 *) {
+        void AutogenerateRoutines::previsit( FunctionType *) {
                 // ensure that we don't add assignment ops for types defined as part of the function
-        }
-
-        void AutogenerateRoutines::visit( PointerType *) {
+                visit_children = false;
+        }
+
+        void AutogenerateRoutines::previsit( PointerType *) {
                 // ensure that we don't add assignment ops for types defined as part of the pointer
-        }
-
-        void AutogenerateRoutines::visit( TraitDecl *) {
+                visit_children = false;
+        }
+
+        void AutogenerateRoutines::previsit( TraitDecl * ) {
                 // ensure that we don't add assignment ops for types defined as part of the trait
-        }
-
-        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 ) {
+                visit_children = false;
+        }
+
+        void AutogenerateRoutines::previsit( FunctionDecl * functionDecl ) {
+                visit_children = false;
                 // record the existence of this function as appropriate
                 insert( functionDecl, constructable, InitTweak::isDefaultConstructor );
@@ -697 +671 @@
                 insert( functionDecl, destructable, InitTweak::isDestructor );
 
-                maybeAccept( functionDecl->get_functionType(), *this );
+                maybeAccept( functionDecl->type, *visitor );
                 functionNesting += 1;
-                maybeAccept( functionDecl->get_statements(), *this );
+                maybeAccept( functionDecl->statements, *visitor );
                 functionNesting -= 1;
         }
 
-        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 );
+        void AutogenerateRoutines::previsit( CompoundStmt * ) {
+                GuardScope( constructable );
+                GuardScope( assignable );
+                GuardScope( copyable );
+                GuardScope( destructable );
+                GuardScope( structsDone );
         }
 
@@ -734 +700 @@
         }
 
-        Type * AutogenTupleRoutines::mutate( TupleType * tupleType ) {
-                tupleType = strict_dynamic_cast< TupleType * >( Parent::mutate( tupleType ) );
+        void AutogenTupleRoutines::postvisit( TupleType * tupleType ) {
                 std::string mangleName = SymTab::Mangler::mangleType( tupleType );
-                if ( seenTuples.find( mangleName ) != seenTuples.end() ) return tupleType;
+                if ( seenTuples.find( mangleName ) != seenTuples.end() ) return;
                 seenTuples.insert( mangleName );
 
@@ -785 +750 @@
                 makeTupleFunctionBody( dtorDecl );
 
-                addDeclaration( ctorDecl );
-                addDeclaration( copyCtorDecl );
-                addDeclaration( dtorDecl );
-                addDeclaration( assignDecl ); // assignment should come last since it uses copy constructor in return
-
-                return tupleType;
-        }
-
-        DeclarationWithType * AutogenTupleRoutines::mutate( FunctionDecl *functionDecl ) {
-                functionDecl->set_functionType( maybeMutate( functionDecl->get_functionType(), *this ) );
+                declsToAddBefore.push_back( ctorDecl );
+                declsToAddBefore.push_back( copyCtorDecl );
+                declsToAddBefore.push_back( dtorDecl );
+                declsToAddBefore.push_back( assignDecl ); // assignment should come last since it uses copy constructor in return
+        }
+
+        void AutogenTupleRoutines::previsit( FunctionDecl *functionDecl ) {
+                visit_children = false;
+                maybeAccept( functionDecl->type, *visitor );
                 functionNesting += 1;
-                functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) );
+                maybeAccept( functionDecl->statements, *visitor );
                 functionNesting -= 1;
-                return functionDecl;
-        }
-
-        CompoundStmt * AutogenTupleRoutines::mutate( CompoundStmt *compoundStmt ) {
-                seenTuples.beginScope();
-                compoundStmt = strict_dynamic_cast< CompoundStmt * >( Parent::mutate( compoundStmt ) );
-                seenTuples.endScope();
-                return compoundStmt;
+        }
+
+        void AutogenTupleRoutines::previsit( CompoundStmt * ) {
+                GuardScope( seenTuples );
         }
 } // SymTab