Changes in src/Concurrency/Keywords.cc [97e3296:2065609]

File:

• src/Concurrency/Keywords.cc (modified) (18 diffs)

src/Concurrency/Keywords.cc ¶

@@ -19 +19 @@
 #include <string>                  // for string, operator==
 
+#include "Common/PassVisitor.h"    // for PassVisitor
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/utility.h"        // for deleteAll, map_range
-#include "InitTweak/InitTweak.h"   // for isConstructor
+#include "CodeGen/OperatorTable.h" // for isConstructor
+#include "InitTweak/InitTweak.h"   // for getPointerBase
 #include "Parser/LinkageSpec.h"    // for Cforall
 #include "SymTab/AddVisit.h"       // for acceptAndAdd
@@ -45 +47 @@
 
         //=============================================================================================
-        // Visitors declaration
+        // Pass declarations
         //=============================================================================================
 
@@ -57 +59 @@
         //                                           static inline NewField_t * getter_name( MyType * this ) { return &this->newField; }
         //
-        class ConcurrentSueKeyword : public Visitor {
-          protected:
-            template< typename Visitor >
-            friend void SymTab::acceptAndAdd( std::list< Declaration * > &translationUnit, Visitor &visitor );
+        class ConcurrentSueKeyword : public WithDeclsToAdd {
           public:
 
@@ -68 +67 @@
                 virtual ~ConcurrentSueKeyword() {}
 
-                using Visitor::visit;
-                virtual void visit( StructDecl * decl ) override final;
+                void postvisit( StructDecl * decl );
 
                 void handle( StructDecl * );
@@ -85 +83 @@
                 bool needs_main;
 
-                std::list< Declaration * > declsToAdd, declsToAddAfter;
                 StructDecl* type_decl = nullptr;
         };
@@ -116 +113 @@
 
                 static void implement( std::list< Declaration * > & translationUnit ) {
-                        ThreadKeyword impl;
-                        SymTab::acceptAndAdd( translationUnit, impl );
+                        PassVisitor< ThreadKeyword > impl;
+                        acceptAll( translationUnit, impl );
                 }
         };
@@ -147 +144 @@
 
                 static void implement( std::list< Declaration * > & translationUnit ) {
-                        CoroutineKeyword impl;
-                        SymTab::acceptAndAdd( translationUnit, impl );
+                        PassVisitor< CoroutineKeyword > impl;
+                        acceptAll( translationUnit, impl );
                 }
         };
@@ -178 +175 @@
 
                 static void implement( std::list< Declaration * > & translationUnit ) {
-                        MonitorKeyword impl;
-                        SymTab::acceptAndAdd( translationUnit, impl );
+                        PassVisitor< MonitorKeyword > impl;
+                        acceptAll( translationUnit, impl );
                 }
         };
@@ -191 +188 @@
         // }                                                               }
         //
-        class MutexKeyword final : public Visitor {
+        class MutexKeyword final {
           public:
 
-                using Visitor::visit;
-                virtual void visit( FunctionDecl * decl ) override final;
-                virtual void visit(   StructDecl * decl ) override final;
+                void postvisit( FunctionDecl * decl );
+                void postvisit(   StructDecl * decl );
 
                 std::list<DeclarationWithType*> findMutexArgs( FunctionDecl* );
@@ -203 +199 @@
 
                 static void implement( std::list< Declaration * > & translationUnit ) {
-                        MutexKeyword impl;
+                        PassVisitor< MutexKeyword > impl;
                         acceptAll( translationUnit, impl );
                 }
@@ -229 +225 @@
         // }                                                               }
         //
-        class ThreadStarter final : public Visitor {
+        class ThreadStarter final {
           public:
 
-                using Visitor::visit;
-                virtual void visit( FunctionDecl * decl ) override final;
+                void postvisit( FunctionDecl * decl );
 
                 void addStartStatement( FunctionDecl * decl, DeclarationWithType * param );
 
                 static void implement( std::list< Declaration * > & translationUnit ) {
-                        ThreadStarter impl;
+                        PassVisitor< ThreadStarter > impl;
                         acceptAll( translationUnit, impl );
                 }
@@ -263 +258 @@
         // Generic keyword implementation
         //=============================================================================================
-        void ConcurrentSueKeyword::visit(StructDecl * decl) {
-                Visitor::visit(decl);
+        void ConcurrentSueKeyword::postvisit(StructDecl * decl) {
                 if( decl->get_name() == type_name && decl->has_body() ) {
                         assert( !type_decl );
@@ -298 +292 @@
                         LinkageSpec::Cforall,
                         nullptr,
-                        new PointerType(
+                        new ReferenceType(
                                 noQualifiers,
                                 new StructInstType(
@@ -352 +346 @@
                 }
 
-                declsToAdd.push_back( forward );
-                if( needs_main ) declsToAdd.push_back( main_decl );
-                declsToAdd.push_back( get_decl );
+                declsToAddBefore.push_back( forward );
+                if( needs_main ) declsToAddBefore.push_back( main_decl );
+                declsToAddBefore.push_back( get_decl );
 
                 return get_decl;
@@ -404 +398 @@
         //=============================================================================================
 
-        void MutexKeyword::visit(FunctionDecl* decl) {
-                Visitor::visit(decl);
+        void MutexKeyword::postvisit(FunctionDecl* decl) {
 
                 std::list<DeclarationWithType*> mutexArgs = findMutexArgs( decl );
@@ -423 +416 @@
         }
 
-        void MutexKeyword::visit(StructDecl* decl) {
-                Visitor::visit(decl);
+        void MutexKeyword::postvisit(StructDecl* decl) {
 
                 if( decl->get_name() == "monitor_desc" ) {
@@ -455 +447 @@
 
                 //Makes sure it's not a copy
-                PointerType* pty = dynamic_cast< PointerType * >( ty );
-                if( ! pty ) throw SemanticError( "Mutex argument must be of pointer/reference type ", arg );
+                ReferenceType* rty = dynamic_cast< ReferenceType * >( ty );
+                if( ! rty ) throw SemanticError( "Mutex argument must be of reference type ", arg );
 
                 //Make sure the we are pointing directly to a type
-                Type* base = pty->get_base();
-                if(  dynamic_cast< PointerType * >( base ) ) throw SemanticError( "Mutex argument have exactly one level of indirection ", arg );
+                Type* base = rty->get_base();
+                if( dynamic_cast< ReferenceType * >( base ) ) throw SemanticError( "Mutex argument have exactly one level of indirection ", arg );
+                if( dynamic_cast< PointerType * >( base ) ) throw SemanticError( "Mutex argument have exactly one level of indirection ", arg );
 
                 //Make sure that typed isn't mutex
@@ -530 +523 @@
         // General entry routine
         //=============================================================================================
-        void ThreadStarter::visit(FunctionDecl * decl) {
-                Visitor::visit(decl);
-
-                if( ! InitTweak::isConstructor(decl->get_name()) ) return;
+        void ThreadStarter::postvisit(FunctionDecl * decl) {
+                if( ! CodeGen::isConstructor(decl->get_name()) ) return;
 
                 DeclarationWithType * param = decl->get_functionType()->get_parameters().front();
-                auto ptr = dynamic_cast< PointerType * >( param->get_type() );
-                // if( ptr ) std::cerr << "FRED1" << std::endl;
-                auto type  = dynamic_cast< StructInstType * >( ptr->get_base() );
+                auto type  = dynamic_cast< StructInstType * >( InitTweak::getPointerBase( param->get_type() ) );
                 // if( type ) std::cerr << "FRED2" << std::endl;
                 if( type && type->get_baseStruct()->is_thread() ) {