Changeset 9a705dc8

Timestamp:

Apr 19, 2018, 5:18:46 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

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, with_gc

Children:

da9d79b

Parents:

60ba456

Message:

Implement concurrency keyword casts

Location:

src

Files:

• Common/PassVisitor.h (modified) (2 diffs)
• Common/PassVisitor.impl.h (modified) (1 diff)
• Concurrency/Keywords.cc (modified) (11 diffs)
• Parser/ExpressionNode.cc (modified) (1 diff)
• Parser/ParseNode.h (modified) (1 diff)
• Parser/parser.yy (modified) (1 diff)
• SynTree/Expression.cc (modified) (1 diff)
• SynTree/Expression.h (modified) (2 diffs)
• SynTree/Mutator.h (modified) (1 diff)
• SynTree/SynTree.h (modified) (1 diff)
• SynTree/Visitor.h (modified) (1 diff)

src/Common/PassVisitor.h

@@ -92 +92 @@
         virtual void visit( NameExpr * nameExpr ) override final;
         virtual void visit( CastExpr * castExpr ) override final;
+        virtual void visit( KeywordCastExpr * castExpr ) override final;
         virtual void visit( VirtualCastExpr * castExpr ) override final;
         virtual void visit( AddressExpr * addressExpr ) override final;
@@ -187 +188 @@
         virtual Expression * mutate( UntypedExpr * untypedExpr ) override final;
         virtual Expression * mutate( NameExpr * nameExpr ) override final;
-        virtual Expression * mutate( AddressExpr * castExpr ) override final;
+        virtual Expression * mutate( AddressExpr * addrExpr ) override final;
         virtual Expression * mutate( LabelAddressExpr * labAddressExpr ) override final;
         virtual Expression * mutate( CastExpr * castExpr ) override final;
+        virtual Expression * mutate( KeywordCastExpr * castExpr ) override final;
         virtual Expression * mutate( VirtualCastExpr * castExpr ) override final;
         virtual Expression * mutate( UntypedMemberExpr * memberExpr ) override final;

src/Common/PassVisitor.impl.h

@@ -1259 +1259 @@
 
 //--------------------------------------------------------------------------
+// KeywordCastExpr
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( KeywordCastExpr * node ) {
+        VISIT_START( node );
+
+        indexerScopedAccept( node->result, *this );
+        maybeAccept_impl        ( node->arg   , *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( KeywordCastExpr * node ) {
+        MUTATE_START( node );
+
+        indexerScopedMutate( node->env   , *this );
+        indexerScopedMutate( node->result, *this );
+        maybeMutate_impl   ( node->arg   , *this );
+
+        MUTATE_END( Expression, node );
+}
+
+//--------------------------------------------------------------------------
 // VirtualCastExpr
 template< typename pass_type >

src/Concurrency/Keywords.cc

@@ -53 +53 @@
           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 ) {}
+                ConcurrentSueKeyword( std::string&& type_name, std::string&& field_name, std::string&& getter_name, std::string&& context_error, bool needs_main, KeywordCastExpr::Target cast_target ) :
+                  type_name( type_name ), field_name( field_name ), getter_name( getter_name ), context_error( context_error ), needs_main( needs_main ), cast_target( cast_target ) {}
 
                 virtual ~ConcurrentSueKeyword() {}
 
-                void postvisit( StructDecl * decl );
+                Declaration * postmutate( StructDecl * decl );
 
                 void handle( StructDecl * );
@@ -66 +66 @@
 
                 virtual bool is_target( StructDecl * decl ) = 0;
+
+                Expression * postmutate( KeywordCastExpr * cast );
 
           private:
@@ -73 +75 @@
                 const std::string context_error;
                 bool needs_main;
+                KeywordCastExpr::Target cast_target;
 
                 StructDecl* type_decl = nullptr;
@@ -95 +98 @@
                         "get_thread",
                         "thread keyword requires threads to be in scope, add #include <thread>",
-                        true
+                        true,
+                        KeywordCastExpr::Thread
                 )
                 {}
@@ -105 +109 @@
                 static void implement( std::list< Declaration * > & translationUnit ) {
                         PassVisitor< ThreadKeyword > impl;
-                        acceptAll( translationUnit, impl );
+                        mutateAll( translationUnit, impl );
                 }
         };
@@ -126 +130 @@
                         "get_coroutine",
                         "coroutine keyword requires coroutines to be in scope, add #include <coroutine>",
-                        true
+                        true,
+                        KeywordCastExpr::Coroutine
                 )
                 {}
@@ -136 +141 @@
                 static void implement( std::list< Declaration * > & translationUnit ) {
                         PassVisitor< CoroutineKeyword > impl;
-                        acceptAll( translationUnit, impl );
+                        mutateAll( translationUnit, impl );
                 }
         };
@@ -157 +162 @@
                         "get_monitor",
                         "monitor keyword requires monitors to be in scope, add #include <monitor>",
-                        false
+                        false,
+                        KeywordCastExpr::Monitor
                 )
                 {}
@@ -167 +173 @@
                 static void implement( std::list< Declaration * > & translationUnit ) {
                         PassVisitor< MonitorKeyword > impl;
-                        acceptAll( translationUnit, impl );
+                        mutateAll( translationUnit, impl );
                 }
         };
@@ -267 +273 @@
         }
 
-        void ConcurrentSueKeyword::postvisit(StructDecl * decl) {
+        Declaration * ConcurrentSueKeyword::postmutate(StructDecl * decl) {
                 if( decl->name == type_name && decl->body ) {
                         assert( !type_decl );
@@ -275 +281 @@
                         handle( decl );
                 }
-        }
+                return decl;
+        }
+
+        Expression * ConcurrentSueKeyword::postmutate( KeywordCastExpr * cast ) {
+                if ( cast_target == cast->target ) {
+                        // convert (thread &)t to (thread_desc &)*get_thread(t), etc.
+                        if( !type_decl ) SemanticError( cast, context_error );
+                        Expression * arg = cast->arg;
+                        cast->arg = nullptr;
+                        delete cast;
+                        return new CastExpr(
+                                UntypedExpr::createDeref(
+                                        new UntypedExpr( new NameExpr( getter_name ), { arg } )
+                                ),
+                                new ReferenceType(
+                                        noQualifiers,
+                                        new StructInstType( noQualifiers, type_decl ) )
+                                );
+                }
+                return cast;
+        }
+
 
         void ConcurrentSueKeyword::handle( StructDecl * decl ) {

src/Parser/ExpressionNode.cc

@@ -414 +414 @@
 } // build_cast
 
+Expression * build_keyword_cast( KeywordCastExpr::Target target, ExpressionNode * expr_node ) {
+        return new KeywordCastExpr( maybeMoveBuild< Expression >(expr_node), target );
+}
+
 Expression * build_virtual_cast( DeclarationNode * decl_node, ExpressionNode * expr_node ) {
         return new VirtualCastExpr( maybeMoveBuild< Expression >( expr_node ), maybeMoveBuildType( decl_node ) );

src/Parser/ParseNode.h

@@ -179 +179 @@
 
 Expression * build_cast( DeclarationNode * decl_node, ExpressionNode * expr_node );
+Expression * build_keyword_cast( KeywordCastExpr::Target target, ExpressionNode * expr_node );
 Expression * build_virtual_cast( DeclarationNode * decl_node, ExpressionNode * expr_node );
 Expression * build_fieldSel( ExpressionNode * expr_node, Expression * member );

src/Parser/parser.yy

@@ -688 +688 @@
                 { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
         | '(' COROUTINE '&' ')' cast_expression                         // CFA
-                { SemanticError( yylloc, "coroutine cast is currently unimplemented." ); $$ = nullptr; }
+                { $$ = new ExpressionNode( build_keyword_cast( KeywordCastExpr::Coroutine, $5 ) ); }
         | '(' THREAD '&' ')' cast_expression                            // CFA
-                { SemanticError( yylloc, "monitor cast is currently unimplemented." ); $$ = nullptr; }
+                { $$ = new ExpressionNode( build_keyword_cast( KeywordCastExpr::Thread, $5 ) ); }
         | '(' MONITOR '&' ')' cast_expression                           // CFA
-                { SemanticError( yylloc, "thread cast is currently unimplemented." ); $$ = nullptr; }
+                { $$ = new ExpressionNode( build_keyword_cast( KeywordCastExpr::Monitor, $5 ) ); }
                 // VIRTUAL cannot be opt because of look ahead issues
         | '(' VIRTUAL ')' cast_expression                                       // CFA

src/SynTree/Expression.cc

@@ -299 +299 @@
 }
 
+KeywordCastExpr::KeywordCastExpr( Expression *arg, Target target ) : Expression(), arg(arg), target( target ) {
+}
+
+KeywordCastExpr::KeywordCastExpr( const KeywordCastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ), target( other.target ) {
+}
+
+KeywordCastExpr::~KeywordCastExpr() {
+        delete arg;
+}
+
+const std::string & KeywordCastExpr::targetString() const {
+        static const std::string targetStrs[] = {
+                "coroutine", "thread", "monitor"
+        };
+        static_assert(
+                (sizeof(targetStrs) / sizeof(targetStrs[0])) == ((unsigned long)NUMBER_OF_TARGETS),
+                "Each KeywordCastExpr::Target should have a corresponding string representation"
+        );
+        return targetStrs[(unsigned long)target];
+}
+
+void KeywordCastExpr::print( std::ostream &os, Indenter indent ) const {
+        os << "Keyword Cast of:" << std::endl << indent+1;
+        arg->print(os, indent+1);
+        os << std::endl << indent << "... to: ";
+        os << targetString();
+        Expression::print( os, indent );
+}
+
 VirtualCastExpr::VirtualCastExpr( Expression *arg_, Type *toType ) : Expression(), arg(arg_) {
         set_result(toType);

src/SynTree/Expression.h

@@ -192 +192 @@
         CastExpr( Expression * arg, bool isGenerated = true );
         CastExpr( Expression * arg, Type * toType, bool isGenerated = true );
+        CastExpr( Expression * arg, void * ) = delete; // prevent accidentally passing pointers for isGenerated in the first constructor
         CastExpr( const CastExpr & other );
         virtual ~CastExpr();
@@ -199 +200 @@
 
         virtual CastExpr * clone() const { return new CastExpr( * this ); }
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+};
+
+/// KeywordCastExpr represents a cast to 'keyword types', e.g. (thread &)t
+class KeywordCastExpr : public Expression {
+public:
+        Expression * arg;
+        enum Target {
+                Coroutine, Thread, Monitor, NUMBER_OF_TARGETS
+        } target;
+
+        KeywordCastExpr( Expression * arg, Target target );
+        KeywordCastExpr( const KeywordCastExpr & other );
+        virtual ~KeywordCastExpr();
+
+        const std::string & targetString() const;
+
+        virtual KeywordCastExpr * clone() const { return new KeywordCastExpr( * this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }

src/SynTree/Mutator.h

@@ -59 +59 @@
         virtual Expression * mutate( UntypedExpr * untypedExpr ) = 0;
         virtual Expression * mutate( NameExpr * nameExpr ) = 0;
-        virtual Expression * mutate( AddressExpr * castExpr ) = 0;
+        virtual Expression * mutate( AddressExpr * addrExpr ) = 0;
         virtual Expression * mutate( LabelAddressExpr * labAddressExpr ) = 0;
         virtual Expression * mutate( CastExpr * castExpr ) = 0;
+        virtual Expression * mutate( KeywordCastExpr * castExpr ) = 0;
         virtual Expression * mutate( VirtualCastExpr * castExpr ) = 0;
         virtual Expression * mutate( UntypedMemberExpr * memberExpr ) = 0;

src/SynTree/SynTree.h

@@ -69 +69 @@
 class LabelAddressExpr;
 class CastExpr;
+class KeywordCastExpr;
 class VirtualCastExpr;
 class MemberExpr;

src/SynTree/Visitor.h

@@ -62 +62 @@
         virtual void visit( NameExpr * nameExpr ) = 0;
         virtual void visit( CastExpr * castExpr ) = 0;
+        virtual void visit( KeywordCastExpr * castExpr ) = 0;
         virtual void visit( VirtualCastExpr * castExpr ) = 0;
         virtual void visit( AddressExpr * addressExpr ) = 0;