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

File:

• src/Concurrency/Keywords.cc (modified) (21 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 "CodeGen/OperatorTable.h" // for isConstructor
-#include "InitTweak/InitTweak.h"   // for getPointerBase
+#include "InitTweak/InitTweak.h"   // for isConstructor
 #include "Parser/LinkageSpec.h"    // for Cforall
 #include "SymTab/AddVisit.h"       // for acceptAndAdd
@@ -47 +45 @@
 
         //=============================================================================================
-        // Pass declarations
+        // Visitors declaration
         //=============================================================================================
 
@@ -59 +57 @@
         //                                           static inline NewField_t * getter_name( MyType * this ) { return &this->newField; }
         //
-        class ConcurrentSueKeyword : public WithDeclsToAdd {
+        class ConcurrentSueKeyword : public Visitor {
+          protected:
+            template< typename Visitor >
+            friend void SymTab::acceptAndAdd( std::list< Declaration * > &translationUnit, Visitor &visitor );
           public:
 
@@ -67 +68 @@
                 virtual ~ConcurrentSueKeyword() {}
 
-                void postvisit( StructDecl * decl );
+                using Visitor::visit;
+                virtual void visit( StructDecl * decl ) override final;
 
                 void handle( StructDecl * );
@@ -83 +85 @@
                 bool needs_main;
 
+                std::list< Declaration * > declsToAdd, declsToAddAfter;
                 StructDecl* type_decl = nullptr;
         };
@@ -113 +116 @@
 
                 static void implement( std::list< Declaration * > & translationUnit ) {
-                        PassVisitor< ThreadKeyword > impl;
-                        acceptAll( translationUnit, impl );
+                        ThreadKeyword impl;
+                        SymTab::acceptAndAdd( translationUnit, impl );
                 }
         };
@@ -144 +147 @@
 
                 static void implement( std::list< Declaration * > & translationUnit ) {
-                        PassVisitor< CoroutineKeyword > impl;
-                        acceptAll( translationUnit, impl );
+                        CoroutineKeyword impl;
+                        SymTab::acceptAndAdd( translationUnit, impl );
                 }
         };
@@ -175 +178 @@
 
                 static void implement( std::list< Declaration * > & translationUnit ) {
-                        PassVisitor< MonitorKeyword > impl;
-                        acceptAll( translationUnit, impl );
+                        MonitorKeyword impl;
+                        SymTab::acceptAndAdd( translationUnit, impl );
                 }
         };
@@ -188 +191 @@
         // }                                                               }
         //
-        class MutexKeyword final {
+        class MutexKeyword final : public Visitor {
           public:
 
-                void postvisit( FunctionDecl * decl );
-                void postvisit(   StructDecl * decl );
+                using Visitor::visit;
+                virtual void visit( FunctionDecl * decl ) override final;
+                virtual void visit(   StructDecl * decl ) override final;
 
                 std::list<DeclarationWithType*> findMutexArgs( FunctionDecl* );
                 void validate( DeclarationWithType * );
-                void addStatments( FunctionDecl* func, CompoundStmt *, const std::list<DeclarationWithType * > &);
+                void addStatments( CompoundStmt *, const std::list<DeclarationWithType * > &);
 
                 static void implement( std::list< Declaration * > & translationUnit ) {
-                        PassVisitor< MutexKeyword > impl;
+                        MutexKeyword impl;
                         acceptAll( translationUnit, impl );
                 }
@@ -206 +210 @@
                 StructDecl* monitor_decl = nullptr;
                 StructDecl* guard_decl = nullptr;
-
-                static std::unique_ptr< Type > generic_func;
         };
-
-        std::unique_ptr< Type > MutexKeyword::generic_func = std::unique_ptr< Type >(
-                new FunctionType(
-                        noQualifiers,
-                        true
-                )
-        );
 
         //-----------------------------------------------------------------------------
@@ -225 +220 @@
         // }                                                               }
         //
-        class ThreadStarter final {
+        class ThreadStarter final : public Visitor {
           public:
 
-                void postvisit( FunctionDecl * decl );
+                using Visitor::visit;
+                virtual void visit( FunctionDecl * decl ) override final;
 
                 void addStartStatement( FunctionDecl * decl, DeclarationWithType * param );
 
                 static void implement( std::list< Declaration * > & translationUnit ) {
-                        PassVisitor< ThreadStarter > impl;
+                        ThreadStarter impl;
                         acceptAll( translationUnit, impl );
                 }
@@ -258 +254 @@
         // Generic keyword implementation
         //=============================================================================================
-        void ConcurrentSueKeyword::postvisit(StructDecl * decl) {
+        void ConcurrentSueKeyword::visit(StructDecl * decl) {
+                Visitor::visit(decl);
                 if( decl->get_name() == type_name && decl->has_body() ) {
                         assert( !type_decl );
@@ -292 +289 @@
                         LinkageSpec::Cforall,
                         nullptr,
-                        new ReferenceType(
+                        new PointerType(
                                 noQualifiers,
                                 new StructInstType(
@@ -346 +343 @@
                 }
 
-                declsToAddBefore.push_back( forward );
-                if( needs_main ) declsToAddBefore.push_back( main_decl );
-                declsToAddBefore.push_back( get_decl );
+                declsToAdd.push_back( forward );
+                if( needs_main ) declsToAdd.push_back( main_decl );
+                declsToAdd.push_back( get_decl );
 
                 return get_decl;
@@ -397 +394 @@
         // Mutex keyword implementation
         //=============================================================================================
-
-        void MutexKeyword::postvisit(FunctionDecl* decl) {
+        void MutexKeyword::visit(FunctionDecl* decl) {
+                Visitor::visit(decl);
 
                 std::list<DeclarationWithType*> mutexArgs = findMutexArgs( decl );
@@ -413 +410 @@
                 if( !guard_decl ) throw SemanticError( "mutex keyword requires monitors to be in scope, add #include <monitor>", decl );
 
-                addStatments( decl, body, mutexArgs );
-        }
-
-        void MutexKeyword::postvisit(StructDecl* decl) {
+                addStatments( body, mutexArgs );
+        }
+
+        void MutexKeyword::visit(StructDecl* decl) {
+                Visitor::visit(decl);
 
                 if( decl->get_name() == "monitor_desc" ) {
@@ -447 +445 @@
 
                 //Makes sure it's not a copy
-                ReferenceType* rty = dynamic_cast< ReferenceType * >( ty );
-                if( ! rty ) throw SemanticError( "Mutex argument must be of reference type ", arg );
+                PointerType* pty = dynamic_cast< PointerType * >( ty );
+                if( ! pty ) throw SemanticError( "Mutex argument must be of pointer/reference type ", arg );
 
                 //Make sure the we are pointing directly to a type
-                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 );
+                Type* base = pty->get_base();
+                if(  dynamic_cast< PointerType * >( base ) ) throw SemanticError( "Mutex argument have exactly one level of indirection ", arg );
 
                 //Make sure that typed isn't mutex
@@ -459 +456 @@
         }
 
-        void MutexKeyword::addStatments( FunctionDecl* func, CompoundStmt * body, const std::list<DeclarationWithType * > & args ) {
+        void MutexKeyword::addStatments( CompoundStmt * body, const std::list<DeclarationWithType * > & args ) {
                 ObjectDecl * monitors = new ObjectDecl(
                         "__monitors",
@@ -490 +487 @@
                 );
 
-                assert(generic_func);
-
                 //in reverse order :
-                // monitor_guard_t __guard = { __monitors, #, func };
+                // monitor_guard_t __guard = { __monitors, # };
                 body->push_front(
                         new DeclStmt( noLabels, new ObjectDecl(
@@ -507 +502 @@
                                         {
                                                 new SingleInit( new VariableExpr( monitors ) ),
-                                                new SingleInit( new ConstantExpr( Constant::from_ulong( args.size() ) ) ),
-                                                new SingleInit( new CastExpr( new VariableExpr( func ), generic_func->clone() ) )
+                                                new SingleInit( new ConstantExpr( Constant::from_ulong( args.size() ) ) )
                                         },
                                         noDesignators,
@@ -523 +517 @@
         // General entry routine
         //=============================================================================================
-        void ThreadStarter::postvisit(FunctionDecl * decl) {
-                if( ! CodeGen::isConstructor(decl->get_name()) ) return;
+        void ThreadStarter::visit(FunctionDecl * decl) {
+                Visitor::visit(decl);
+
+                if( ! InitTweak::isConstructor(decl->get_name()) ) return;
 
                 DeclarationWithType * param = decl->get_functionType()->get_parameters().front();
-                auto type  = dynamic_cast< StructInstType * >( InitTweak::getPointerBase( param->get_type() ) );
+                auto ptr = dynamic_cast< PointerType * >( param->get_type() );
+                // if( ptr ) std::cerr << "FRED1" << std::endl;
+                auto type  = dynamic_cast< StructInstType * >( ptr->get_base() );
                 // if( type ) std::cerr << "FRED2" << std::endl;
                 if( type && type->get_baseStruct()->is_thread() ) {