Changes in / [656ee4f:626da644]

Files:

• doc/working/exception/README (added)
• doc/working/exception/except.c (added)
• doc/working/exception/except.h (added)
• doc/working/exception/lsda.h (added)
• doc/working/exception/main.c (added)
• doc/working/exception/main.cfa (added)
• src/Concurrency/Keywords.cc (modified) (14 diffs)
• src/Concurrency/Keywords.h (modified) (1 diff)
• src/Parser/lex.ll (modified) (2 diffs)
• src/SymTab/Autogen.cc (modified) (2 diffs)
• src/SymTab/Validate.cc (modified) (2 diffs)
• src/libcfa/concurrency/thread (modified) (1 diff)
• src/libcfa/concurrency/thread.c (modified) (4 diffs)
• src/main.cc (modified) (2 diffs)
• src/tests/monitor.c (modified) (3 diffs)
• src/tests/multi-monitor.c (modified) (1 diff)
• src/tests/thread.c (modified) (2 diffs)

src/Concurrency/Keywords.cc

@@ -17 +17 @@
 #include "Concurrency/Keywords.h"
 
+#include "InitTweak/InitTweak.h"
 #include "SymTab/AddVisit.h"
 #include "SynTree/Declaration.h"
 #include "SynTree/Expression.h"
 #include "SynTree/Initializer.h"
-#include "SynTree/Mutator.h"
 #include "SynTree/Statement.h"
 #include "SynTree/Type.h"
@@ -38 +38 @@
         // Visitors declaration
         //=============================================================================================
+
+        //-----------------------------------------------------------------------------
+        //Handles sue type declarations :
+        // sue MyType {                             struct MyType {
+        //      int data;                                  int data;
+        //      a_struct_t more_data;                      a_struct_t more_data;
+        //                                =>             NewField_t newField;
+        // };                                        };
+        //                                           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 );
+          public:
+
+                ConcurrentSueKeyword( std::string&& type_name, std::string&& field_name, std::string&& getter_name, std::string&& context_error, bool needs_main ) :
+                  type_name( type_name ), field_name( field_name ), getter_name( getter_name ), context_error( context_error ), needs_main( needs_main ) {}
+
+                virtual ~ConcurrentSueKeyword() {}
+
+                using Visitor::visit;
+                virtual void visit( StructDecl * decl ) override final;
+
+                void handle( StructDecl * );
+                FunctionDecl * forwardDeclare( StructDecl * );
+                ObjectDecl * addField( StructDecl * );
+                void addRoutines( StructDecl *, ObjectDecl *, FunctionDecl * );
+
+                virtual bool is_target( StructDecl * decl ) = 0;
+
+          private:
+                const std::string type_name;
+                const std::string field_name;
+                const std::string getter_name;
+                const std::string context_error;
+                bool needs_main;
+
+                std::list< Declaration * > declsToAdd, declsToAddAfter;
+                StructDecl* type_decl = nullptr;
+        };
+
 
         //-----------------------------------------------------------------------------
@@ -47 +89 @@
         // };                                        };
         //                                           static inline thread_desc * get_thread( MyThread * this ) { return &this->__thrd_d; }
-        //                                           void main( MyThread * this );
         //
-        class ThreadKeyword final : public Mutator {
+        class ThreadKeyword final : public ConcurrentSueKeyword {
           public:
 
-                static void implement( std::list< Declaration * > & translationUnit ) {}
+                ThreadKeyword() : ConcurrentSueKeyword(
+                        "thread_desc",
+                        "__thrd",
+                        "get_thread",
+                        "thread keyword requires threads to be in scope, add #include <thread>",
+                        true
+                )
+                {}
+
+                virtual ~ThreadKeyword() {}
+
+                virtual bool is_target( StructDecl * decl ) override final { return decl->is_thread(); }
+
+                static void implement( std::list< Declaration * > & translationUnit ) {
+                        ThreadKeyword impl;
+                        SymTab::acceptAndAdd( translationUnit, impl );
+                }
         };
 
@@ -63 +120 @@
         // };                                        };
         //                                           static inline coroutine_desc * get_coroutine( MyCoroutine * this ) { return &this->__cor_d; }
-        //                                           void main( MyCoroutine * this );
         //
-        class CoroutineKeyword final : public Visitor {
-            template< typename Visitor >
-            friend void SymTab::acceptAndAdd( std::list< Declaration * > &translationUnit, Visitor &visitor );
+        class CoroutineKeyword final : public ConcurrentSueKeyword {
           public:
 
-                using Visitor::visit;
-                virtual void visit( StructDecl * decl ) override final;
-
-                void handle( StructDecl * );
-                Declaration * addField( StructDecl * );
-                void addRoutines( StructDecl *, Declaration * );
+                CoroutineKeyword() : ConcurrentSueKeyword(
+                        "coroutine_desc",
+                        "__cor",
+                        "get_coroutine",
+                        "coroutine keyword requires coroutines to be in scope, add #include <coroutine>",
+                        true
+                )
+                {}
+
+                virtual ~CoroutineKeyword() {}
+
+                virtual bool is_target( StructDecl * decl ) override final { return decl->is_coroutine(); }
 
                 static void implement( std::list< Declaration * > & translationUnit ) {
@@ -81 +141 @@
                         SymTab::acceptAndAdd( translationUnit, impl );
                 }
-
-          private:
-                std::list< Declaration * > declsToAdd, declsToAddAfter;
-                StructDecl* coroutine_decl = nullptr;
         };
 
@@ -95 +151 @@
         // };                                        };
         //                                           static inline monitor_desc * get_coroutine( MyMonitor * this ) { return &this->__cor_d; }
-        //                                           void main( MyMonitor * this );
         //
-        class MonitorKeyword final : public Mutator {
+        class MonitorKeyword final : public ConcurrentSueKeyword {
           public:
 
-                static void implement( std::list< Declaration * > & translationUnit ) {}
+                MonitorKeyword() : ConcurrentSueKeyword(
+                        "monitor_desc",
+                        "__mon",
+                        "get_monitor",
+                        "monitor keyword requires monitors to be in scope, add #include <monitor>",
+                        false
+                )
+                {}
+
+                virtual ~MonitorKeyword() {}
+
+                virtual bool is_target( StructDecl * decl ) override final { return decl->is_monitor(); }
+
+                static void implement( std::list< Declaration * > & translationUnit ) {
+                        MonitorKeyword impl;
+                        SymTab::acceptAndAdd( translationUnit, impl );
+                }
         };
 
@@ -132 +203 @@
         };
 
+        //-----------------------------------------------------------------------------
+        //Handles mutex routines definitions :
+        // void foo( A * mutex a, B * mutex b,  int i ) {                  void foo( A * a, B * b,  int i ) {
+        //                                                                       monitor_desc * __monitors[] = { get_monitor(a), get_monitor(b) };
+        //                                                                       monitor_guard_t __guard = { __monitors, 2 };
+        //    /*Some code*/                                       =>           /*Some code*/
+        // }                                                               }
+        //
+        class ThreadStarter final : public Visitor {
+          public:
+
+                using Visitor::visit;
+                virtual void visit( FunctionDecl * decl ) override final;
+
+                void addStartStatement( FunctionDecl * decl, DeclarationWithType * param );
+
+                static void implement( std::list< Declaration * > & translationUnit ) {
+                        ThreadStarter impl;
+                        acceptAll( translationUnit, impl );
+                }
+        };
+
         //=============================================================================================
         // General entry routine
@@ -139 +232 @@
                 CoroutineKeyword        ::implement( translationUnit );
                 MonitorKeyword  ::implement( translationUnit );
+        }
+
+        void implementMutexFuncs( std::list< Declaration * > & translationUnit ) {
                 MutexKeyword    ::implement( translationUnit );
         }
 
-        //=============================================================================================
-        // Coroutine keyword implementation
-        //=============================================================================================
-        void CoroutineKeyword::visit(StructDecl * decl) {
-                if( decl->get_name() == "coroutine_desc" ) {
-                        assert( !coroutine_decl );
-                        coroutine_decl = decl;
-                }
-                else if ( decl->is_coroutine() ) {
+        void implementThreadStarter( std::list< Declaration * > & translationUnit ) {
+                ThreadStarter   ::implement( translationUnit );
+        }
+
+        //=============================================================================================
+        // Generic keyword implementation
+        //=============================================================================================
+        void ConcurrentSueKeyword::visit(StructDecl * decl) {
+                if( decl->get_name() == type_name ) {
+                        assert( !type_decl );
+                        type_decl = decl;
+                }
+                else if ( is_target(decl) ) {
                         handle( decl );
                 }
@@ -156 +256 @@
         }
 
-        void CoroutineKeyword::handle( StructDecl * decl ) {
+        void ConcurrentSueKeyword::handle( StructDecl * decl ) {
                 if( ! decl->has_body() ) return;
 
-                if( !coroutine_decl ) throw SemanticError( "coroutine keyword requires coroutines to be in scope, add #include <coroutine>", decl );
-
-                Declaration * field = addField( decl );
-                addRoutines( decl, field );
-        }
-
-        Declaration * CoroutineKeyword::addField( StructDecl * decl ) {
-                Declaration * cor = new ObjectDecl(
-                        "__cor",
+                if( !type_decl ) throw SemanticError( context_error, decl );
+
+                FunctionDecl * func = forwardDeclare( decl );
+                ObjectDecl * field = addField( decl );
+                addRoutines( decl, field, func );
+        }
+
+        FunctionDecl * ConcurrentSueKeyword::forwardDeclare( StructDecl * decl ) {
+
+                StructDecl * forward = decl->clone();
+                forward->set_body( false );
+                deleteAll( forward->get_members() );
+                forward->get_members().clear();
+
+                FunctionType * get_type = new FunctionType( noQualifiers, false );
+                ObjectDecl * this_decl = new ObjectDecl(
+                        "this",
                         noStorage,
                         LinkageSpec::Cforall,
                         nullptr,
-                        new StructInstType(
+                        new PointerType(
                                 noQualifiers,
-                                coroutine_decl
+                                new StructInstType(
+                                        noQualifiers,
+                                        decl
+                                )
                         ),
                         nullptr
                 );
 
-                decl->get_members().push_back( cor );
-
-                return cor;
-        }
-
-        void CoroutineKeyword::addRoutines( StructDecl * decl, Declaration * field ) {
-                FunctionType * type = new FunctionType( noQualifiers, false );
-                type->get_parameters().push_back(
-                        new ObjectDecl(
-                                "this",
-                                noStorage,
-                                LinkageSpec::Cforall,
-                                nullptr,
-                                new PointerType(
-                                        noQualifiers,
-                                        new StructInstType(
-                                                noQualifiers,
-                                                decl
-                                        )
-                                ),
-                                nullptr
-                        )
-                );
-                type->get_returnVals().push_back(
+                get_type->get_parameters().push_back( this_decl );
+                get_type->get_returnVals().push_back(
                         new ObjectDecl(
                                 "ret",
@@ -211 +300 @@
                                         new StructInstType(
                                                 noQualifiers,
-                                                coroutine_decl
+                                                type_decl
                                         )
                                 ),
@@ -218 +307 @@
                 );
 
+                FunctionDecl * get_decl = new FunctionDecl(
+                        getter_name,
+                        Type::Static,
+                        LinkageSpec::Cforall,
+                        get_type,
+                        nullptr,
+                        noAttributes,
+                        Type::Inline
+                );
+
+                FunctionDecl * main_decl = nullptr;
+
+                if( needs_main ) {
+                        FunctionType * main_type = new FunctionType( noQualifiers, false );
+                        
+                        main_type->get_parameters().push_back( this_decl->clone() );
+
+                        main_decl = new FunctionDecl(
+                                "main",
+                                noStorage,
+                                LinkageSpec::Cforall,
+                                main_type,
+                                nullptr
+                        );
+                }
+
+                declsToAdd.push_back( forward );
+                if( needs_main ) declsToAdd.push_back( main_decl );
+                declsToAdd.push_back( get_decl );
+
+                return get_decl;
+        }
+
+        ObjectDecl * ConcurrentSueKeyword::addField( StructDecl * decl ) {
+                ObjectDecl * field = new ObjectDecl(
+                        field_name,
+                        noStorage,
+                        LinkageSpec::Cforall,
+                        nullptr,
+                        new StructInstType(
+                                noQualifiers,
+                                type_decl
+                        ),
+                        nullptr
+                );
+
+                decl->get_members().push_back( field );
+
+                return field;
+        }
+
+        void ConcurrentSueKeyword::addRoutines( StructDecl * decl, ObjectDecl * field, FunctionDecl * func ) {
                 CompoundStmt * statement = new CompoundStmt( noLabels );
                 statement->push_back( 
@@ -223 +364 @@
                                 noLabels,
                                 new AddressExpr(
-                                        new UntypedMemberExpr(
-                                                new NameExpr( "__cor" ),
-                                                new UntypedExpr(
-                                                        new NameExpr( "*?" ),
-                                                        { new NameExpr( "this" ) }
-                                                )
+                                        new MemberExpr(
+                                                field,
+                                                UntypedExpr::createDeref( new VariableExpr( func->get_functionType()->get_parameters().front() ) )
                                         )
                                 )
@@ -234 +372 @@
                 );
 
-                FunctionDecl * get_decl = new FunctionDecl(
-                        "get_coroutine",
-                        Type::Static,
-                        LinkageSpec::Cforall,
-                        type,
-                        statement,
-                        noAttributes,
-                        Type::Inline
-                );
+                FunctionDecl * get_decl = func->clone();
+
+                get_decl->set_statements( statement );
 
                 declsToAddAfter.push_back( get_decl );
 
-                get_decl->fixUniqueId();
-        }
-        
+                // get_decl->fixUniqueId();
+        }
 
         //=============================================================================================
@@ -368 +499 @@
                 body->push_front( new DeclStmt( noLabels, monitors) );
         }
+
+        //=============================================================================================
+        // General entry routine
+        //=============================================================================================
+        void ThreadStarter::visit(FunctionDecl * decl) {
+                if( ! InitTweak::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() );
+                // if( type ) std::cerr << "FRED2" << std::endl;
+                if( type && type->get_baseStruct()->is_thread() ) {
+                        addStartStatement( decl, param );
+                }
+        }
+
+        void ThreadStarter::addStartStatement( FunctionDecl * decl, DeclarationWithType * param ) {
+                CompoundStmt * stmt = decl->get_statements();
+
+                if( ! stmt ) return;
+
+                stmt->push_back( 
+                        new ExprStmt(
+                                noLabels,
+                                new UntypedExpr(
+                                        new NameExpr( "__thrd_start" ),
+                                        { new VariableExpr( param ) }
+                                )
+                        )
+                );
+        }
 };

src/Concurrency/Keywords.h

@@ -24 +24 @@
 namespace Concurrency {
         void applyKeywords( std::list< Declaration * > & translationUnit );
+        void implementMutexFuncs( std::list< Declaration * > & translationUnit );
+        void implementThreadStarter( std::list< Declaration * > & translationUnit );
 };
 

src/Parser/lex.ll

@@ -236 +236 @@
 long                    { KEYWORD_RETURN(LONG); }
 lvalue                  { KEYWORD_RETURN(LVALUE); }                             // CFA
-_Monitor                { KEYWORD_RETURN(MONITOR); }                    // CFA
+monitor         { KEYWORD_RETURN(MONITOR); }                    // CFA
 mutex                   { KEYWORD_RETURN(MUTEX); }                              // CFA
 _Noreturn               { KEYWORD_RETURN(NORETURN); }                   // C11
@@ -256 +256 @@
 struct                  { KEYWORD_RETURN(STRUCT); }
 switch                  { KEYWORD_RETURN(SWITCH); }
-_Thread                 { KEYWORD_RETURN(THREAD); }                             // C11
+thread                  { KEYWORD_RETURN(THREAD); }                             // C11
 _Thread_local   { KEYWORD_RETURN(THREADLOCAL); }                // C11
 throw                   { KEYWORD_RETURN(THROW); }                              // CFA

src/SymTab/Autogen.cc

@@ -218 +218 @@
 
                 /// generates a function (?{}, ?=?, ^?{}) based on the data argument and members. If function is generated, inserts the type into the map.
-                void gen( const FuncData & data ) {
+                void gen( const FuncData & data, bool concurrent_type ) {
                         if ( ! shouldGenerate( data.map, aggregateDecl ) ) return;
                         FunctionType * ftype = data.genType( refType );
+
+                        if(concurrent_type && InitTweak::isDestructor( data.fname )) {
+                                ftype->get_parameters().front()->get_type()->set_mutex( true );
+                        }
+
                         cloneAll( typeParams, ftype->get_forall() );
                         *out++ = genFunc( data.fname, ftype, functionNesting );
@@ -403 +408 @@
                 auto generator = makeFuncGenerator( aggregateDecl, refType, functionNesting, typeParams, back_inserter( newFuncs ) );
                 for ( const FuncData & d : data ) {
-                        generator.gen( d );
-                }
+                        generator.gen( d, aggregateDecl->is_thread() || aggregateDecl->is_monitor() );
+                }
+
                 // field ctors are only generated if default constructor and copy constructor are both generated
                 unsigned numCtors = std::count_if( newFuncs.begin(), newFuncs.end(), [](FunctionDecl * dcl) { return InitTweak::isConstructor( dcl->get_name() ); } );

src/SymTab/Validate.cc

@@ -43 +43 @@
 #include "Common/utility.h"
 #include "Common/UniqueName.h"
+#include "Concurrency/Keywords.h"
 #include "Validate.h"
 #include "SynTree/Visitor.h"
@@ -225 +226 @@
                 ReturnTypeFixer::fix( translationUnit ); // must happen before autogen
                 acceptAll( translationUnit, lrt ); // must happen before autogen, because sized flag needs to propagate to generated functions
+                Concurrency::applyKeywords( translationUnit );
                 autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs EnumAndPointerDecayPass
+                Concurrency::implementMutexFuncs( translationUnit );
+                Concurrency::implementThreadStarter( translationUnit );
                 acceptAll( translationUnit, epc );
                 ReturnChecker::checkFunctionReturns( translationUnit );

src/libcfa/concurrency/thread

@@ -56 +56 @@
 thread_desc * this_thread(void);
 
+forall( dtype T | is_thread(T) )
+void __thrd_start( T* this );
+
 //-----------------------------------------------------------------------------
 // Ctors and dtors

src/libcfa/concurrency/thread.c

@@ -31 +31 @@
 
 //-----------------------------------------------------------------------------
-// Forward declarations
-forall( dtype T | is_thread(T) )
-void start( T* this );
-
-//-----------------------------------------------------------------------------
 // Thread ctors and dtors
 
@@ -53 +48 @@
 void ?{}( scoped(T)* this ) {
         (&this->handle){};
-        start(&this->handle);
+        __thrd_start(&this->handle);
 }
 
@@ -59 +54 @@
 void ?{}( scoped(T)* this, P params ) {
         (&this->handle){ params };
-        start(&this->handle);
+        __thrd_start(&this->handle);
 }
 
@@ -70 +65 @@
 // Starting and stopping threads
 forall( dtype T | is_thread(T) )
-void start( T* this ) {
+void __thrd_start( T* this ) {
         coroutine_desc* thrd_c = get_coroutine(this);
         thread_desc*  thrd_h = get_thread   (this);

src/main.cc

@@ -216 +216 @@
                 } // if
 
+                // OPTPRINT( "Concurrency" )
+                // Concurrency::applyKeywords( translationUnit );
+
                 // add the assignment statement after the initialization of a type parameter
                 OPTPRINT( "validate" )
@@ -237 +240 @@
                 OPTPRINT( "mutate" )
                 ControlStruct::mutate( translationUnit );
-                OPTPRINT( "Concurrency" )
-                Concurrency::applyKeywords( translationUnit );
                 OPTPRINT( "fixNames" )
                 CodeGen::fixNames( translationUnit );

src/tests/monitor.c

@@ -4 +4 @@
 #include <thread>
 
-struct global_t {
+monitor global_t {
         int value;
-        monitor_desc m;
 };
 
 void ?{}(global_t * this) {
         this->value = 0;
-}
-
-monitor_desc * get_monitor( global_t * this ) {
-        return &this->m;
 }
 
@@ -31 +26 @@
 }
 
-struct MyThread { thread_desc __thrd; };
-
-DECL_THREAD(MyThread);
-
-void ?{}( MyThread * this ) {}
-void ^?{}( MyThread * mutex this ) {}
+thread MyThread {};
 
 void main( MyThread* this ) {
@@ -45 +35 @@
 
 int main(int argc, char* argv[]) {
-        assert( global.m.entry_queue.tail != NULL );
+        assert( global.__mon.entry_queue.tail != NULL );
         processor p;
         {
-                scoped(MyThread) f[4];
+                MyThread f[4];
         }
         sout | global.value | endl;

src/tests/multi-monitor.c

@@ -6 +6 @@
 static int global12, global23, global13;
 
-struct monitor_t {
-        monitor_desc m;
-};
-
-monitor_desc * get_monitor( monitor_t * this ) {
-        return &this->m;
-}
+monitor monitor_t {};
 
 static monitor_t m1, m2, m3;

src/tests/thread.c

@@ -4 +4 @@
 #include <thread>
 
-struct First { thread_desc __thrd; signal_once* lock; };
-struct Second { thread_desc __thrd; signal_once* lock; };
+// thread First;
+// void main(First* this);
 
-DECL_THREAD(First);
-DECL_THREAD(Second);
+// thread Second;
+// void main(Second* this);
+
+thread First  { signal_once* lock; };
+thread Second { signal_once* lock; };
 
 void ?{}( First * this, signal_once* lock ) { this->lock = lock; }
 void ?{}( Second * this, signal_once* lock ) { this->lock = lock; }
-
-void ^?{}( First  * mutex this ) {}
-void ^?{}( Second * mutex this ) {}
 
 void main(First* this) {
@@ -39 +39 @@
                 processor p;
                 {
-                        scoped(First)  f = { &lock };
-                        scoped(Second) s = { &lock };
+                        First  f = { &lock };
+                        Second s = { &lock };
                 }
         }