Changeset 87d13cd for src/Concurrency/Keywords.cc

Timestamp:

Mar 21, 2017, 10:07:52 PM (7 years ago)

Author:

Peter A. Buhr <pabuhr@…>

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:

cb91437

Parents:

829c907 (diff), a53e10a (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:

fix conflicit in iostream.c

File:

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

src/Concurrency/Keywords.cc

@@ -17 +17 @@
 #include "Concurrency/Keywords.h"
 
+#include "SymTab/AddVisit.h"
 #include "SynTree/Declaration.h"
 #include "SynTree/Expression.h"
@@ -29 +30 @@
         namespace {
                 const std::list<Label> noLabels;
+                const std::list< Attribute * > noAttributes;
                 Type::StorageClasses noStorage;
                 Type::Qualifiers noQualifiers;
@@ -63 +65 @@
         //                                           void main( MyCoroutine * this );
         //
-        class CoroutineKeyword final : public Mutator {
+        class CoroutineKeyword final : public Visitor {
+            template< typename Visitor >
+            friend void SymTab::acceptAndAdd( std::list< Declaration * > &translationUnit, Visitor &visitor );
           public:
 
-                static void implement( std::list< Declaration * > & translationUnit ) {}
+                using Visitor::visit;
+                virtual void visit( StructDecl * decl ) override final;
+
+                void handle( StructDecl * );
+                Declaration * addField( StructDecl * );
+                void addRoutines( StructDecl *, Declaration * );
+
+                static void implement( std::list< Declaration * > & translationUnit ) {
+                        CoroutineKeyword impl;
+                        SymTab::acceptAndAdd( translationUnit, impl );
+                }
+
+          private:
+                std::list< Declaration * > declsToAdd, declsToAddAfter;
+                StructDecl* coroutine_decl = nullptr;
         };
 
@@ -97 +115 @@
 
                 using Visitor::visit;
-                virtual void visit( FunctionDecl *functionDecl ) override final;
-                virtual void visit(   StructDecl *functionDecl ) override final;
+                virtual void visit( FunctionDecl * decl ) override final;
+                virtual void visit(   StructDecl * decl ) override final;
 
                 std::list<DeclarationWithType*> findMutexArgs( FunctionDecl* );
@@ -111 +129 @@
           private:
                 StructDecl* monitor_decl = nullptr;
+                StructDecl* guard_decl = nullptr;
         };
 
@@ -124 +143 @@
 
         //=============================================================================================
+        // 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() ) {
+                        handle( decl );
+                }
+
+        }
+
+        void CoroutineKeyword::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",
+                        noStorage,
+                        LinkageSpec::Cforall,
+                        nullptr,
+                        new StructInstType(
+                                noQualifiers,
+                                coroutine_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(
+                        new ObjectDecl(
+                                "ret",
+                                noStorage,
+                                LinkageSpec::Cforall,
+                                nullptr,
+                                new PointerType(
+                                        noQualifiers,
+                                        new StructInstType(
+                                                noQualifiers,
+                                                coroutine_decl
+                                        )
+                                ),
+                                nullptr
+                        )
+                );
+
+                CompoundStmt * statement = new CompoundStmt( noLabels );
+                statement->push_back( 
+                        new ReturnStmt(
+                                noLabels,
+                                new AddressExpr(
+                                        new UntypedMemberExpr(
+                                                new NameExpr( "__cor" ),
+                                                new UntypedExpr(
+                                                        new NameExpr( "*?" ),
+                                                        { new NameExpr( "this" ) }
+                                                )
+                                        )
+                                )
+                        )
+                );
+
+                FunctionDecl * get_decl = new FunctionDecl(
+                        "get_coroutine",
+                        Type::Static,
+                        LinkageSpec::Cforall,
+                        type,
+                        statement,
+                        noAttributes,
+                        Type::Inline
+                );
+
+                declsToAddAfter.push_back( get_decl );
+
+                get_decl->fixUniqueId();
+        }
+        
+
+        //=============================================================================================
         // Mutex keyword implementation
         //=============================================================================================
@@ -137 +264 @@
                 if( ! body ) return;
 
-                assert(monitor_decl);
+                if( !monitor_decl ) throw SemanticError( "mutex keyword requires monitors to be in scope, add #include <monitor>", decl );
+                if( !guard_decl ) throw SemanticError( "mutex keyword requires monitors to be in scope, add #include <monitor>", decl );
+
                 addStatments( body, mutexArgs );
         }
@@ -146 +275 @@
                         monitor_decl = decl;
                 }
+                else if( decl->get_name() == "monitor_guard_t" ) {
+                        assert( !guard_decl );
+                        guard_decl = decl;
+                }
         }
 
@@ -175 +308 @@
 
                 //Make sure that typed isn't mutex
-                if( ! base->get_mutex() ) throw SemanticError( "mutex keyword may only appear once per argument ", arg );
+                if( base->get_mutex() ) throw SemanticError( "mutex keyword may only appear once per argument ", arg );
         }
 
         void MutexKeyword::addStatments( CompoundStmt * body, const std::list<DeclarationWithType * > & args ) {
-
                 ObjectDecl * monitors = new ObjectDecl(
                         "__monitors",
@@ -199 +331 @@
                         ),
                         new ListInit(
-                                map_range < std::list<Initializer*> > ( args, [](DeclarationWithType * var ){
+                                map_range < std::list<Initializer*> > ( args, [this](DeclarationWithType * var ){
+                                        Type * type = var->get_type()->clone();
+                                        type->set_mutex( false );
                                         return new SingleInit( new UntypedExpr(
                                                 new NameExpr( "get_monitor" ),
-                                                {  new VariableExpr( var ) }
+                                                {  new CastExpr( new VariableExpr( var ), type ) }
                                         ) );
                                 })
@@ -218 +352 @@
                                 new StructInstType(
                                         noQualifiers,
-                                        "monitor_guard_t"
+                                        guard_decl
                                 ),
                                 new ListInit(
@@ -224 +358 @@
                                                 new SingleInit( new VariableExpr( monitors ) ),
                                                 new SingleInit( new ConstantExpr( Constant::from_ulong( args.size() ) ) )
-                                        }
+                                        },
+                                        noDesignators,
+                                        true
                                 )
                         ))
                 );
 
-                //monitor_desc * __monitors[] = { a, b };
+                //monitor_desc * __monitors[] = { get_monitor(a), get_monitor(b) };
                 body->push_front( new DeclStmt( noLabels, monitors) );
         }