Changeset f80f840 for src

Timestamp:

Dec 10, 2019, 4:24:49 PM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

2a3d446

Parents:

b798713 (diff), e307e12 (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:

Merge branch 'master' into relaxed_ready

Location:

src

Files:

• Concurrency/Keywords.cc (modified) (1 diff)
• Parser/parser.yy (modified) (7 diffs)
• ResolvExpr/AlternativeFinder.cc (modified) (2 diffs)
• SynTree/Expression.h (modified) (1 diff)
• cfa.make (modified) (1 diff)

src/Concurrency/Keywords.cc

@@ -309 +309 @@
                         if( !type_decl ) SemanticError( cast, context_error );
                         if( !dtor_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 ) )
-                                );
+                        assert( cast->result == nullptr );
+                        cast->set_result( new ReferenceType( noQualifiers, new StructInstType( noQualifiers, type_decl ) ) );
+                        cast->concrete_target.field  = field_name;
+                        cast->concrete_target.getter = getter_name;
                 }
                 return cast;

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Aug  4 21:48:23 2019
-// Update Count     : 4364
+// Last Modified On : Sat Dec  7 10:43:44 2019
+// Update Count     : 4394
 //
 
@@ -211 +211 @@
 } // forCtrl
 
+KeywordCastExpr::Target Aggregate2Target( DeclarationNode::Aggregate aggr ) {
+        KeywordCastExpr::Target target;
+        switch ( aggr ) {
+          case DeclarationNode::Coroutine: target = KeywordCastExpr::Coroutine; break;
+          case DeclarationNode::Monitor: target = KeywordCastExpr::Monitor; break;
+          case DeclarationNode::Thread: target = KeywordCastExpr::Thread; break;
+          default: abort();
+        } // switch
+        return target;
+} // Aggregate2Target
+
 
 bool forall = false, yyy = false;                                               // aggregate have one or more forall qualifiers ?
@@ -365 +376 @@
 %type<decl> abstract_parameter_declaration
 
-%type<aggKey> aggregate_key
+%type<aggKey> aggregate_key aggregate_data aggregate_control
 %type<decl> aggregate_type aggregate_type_nobody
 
@@ -650 +661 @@
         | postfix_expression '.' '[' field_name_list ']'        // CFA, tuple field selector
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $4 ) ) ); }
+        | postfix_expression '.' aggregate_control
+                { $$ = new ExpressionNode( build_keyword_cast( Aggregate2Target( $3 ), $1 ) ); }
         | postfix_expression ARROW identifier
                 { $$ = new ExpressionNode( build_pfieldSel( $1, build_varref( $3 ) ) ); }
@@ -793 +806 @@
         | '(' type_no_function ')' cast_expression
                 { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
-                // keyword cast cannot be grouped because of reduction in aggregate_key
-        | '(' GENERATOR '&' ')' cast_expression                         // CFA
-                { $$ = new ExpressionNode( build_keyword_cast( KeywordCastExpr::Coroutine, $5 ) ); }
-        | '(' COROUTINE '&' ')' cast_expression                         // CFA
-                { $$ = new ExpressionNode( build_keyword_cast( KeywordCastExpr::Coroutine, $5 ) ); }
-        | '(' THREAD '&' ')' cast_expression                            // CFA
-                { $$ = new ExpressionNode( build_keyword_cast( KeywordCastExpr::Thread, $5 ) ); }
-        | '(' MONITOR '&' ')' cast_expression                           // CFA
-                { $$ = new ExpressionNode( build_keyword_cast( KeywordCastExpr::Monitor, $5 ) ); }
+        | '(' aggregate_control '&' ')' cast_expression         // CFA
+                { $$ = new ExpressionNode( build_keyword_cast( Aggregate2Target( $2 ), $5 ) ); }
                 // VIRTUAL cannot be opt because of look ahead issues
         | '(' VIRTUAL ')' cast_expression                                       // CFA
@@ -2059 +2065 @@
 
 aggregate_key:
+        aggregate_data
+        | aggregate_control
+        ;
+
+aggregate_data:
         STRUCT
                 { yyy = true; $$ = DeclarationNode::Struct; }
         | UNION
                 { yyy = true; $$ = DeclarationNode::Union; }
-        | EXCEPTION
+        | EXCEPTION                                                                                     // CFA
                 { yyy = true; $$ = DeclarationNode::Exception; }
-        | GENERATOR
+        ;
+
+aggregate_control:                                                                              // CFA
+        GENERATOR
                 { yyy = true; $$ = DeclarationNode::Coroutine; }
         | COROUTINE
@@ -2096 +2110 @@
                         distInl( $3 );
                 }
+        | INLINE aggregate_control ';'                                          // CFA
+                { SemanticError( yylloc, "INLINE aggregate control currently unimplemented." ); $$ = nullptr; }
         | typedef_declaration ';'                                                       // CFA
         | cfa_field_declaring_list ';'                                          // CFA, new style field declaration

src/ResolvExpr/AlternativeFinder.cc

@@ -69 +69 @@
                 void postvisit( CastExpr * castExpr );
                 void postvisit( VirtualCastExpr * castExpr );
+                void postvisit( KeywordCastExpr * castExpr );
                 void postvisit( UntypedMemberExpr * memberExpr );
                 void postvisit( MemberExpr * memberExpr );
@@ -1255 +1256 @@
         }
 
+        void AlternativeFinder::Finder::postvisit( KeywordCastExpr * castExpr ) {
+                assertf( castExpr->get_result(), "Cast target should have been set in Validate." );
+                auto ref = dynamic_cast<ReferenceType*>(castExpr->get_result());
+                assert(ref);
+                auto inst = dynamic_cast<StructInstType*>(ref->base);
+                assert(inst);
+                auto target = inst->baseStruct;
+
+                AlternativeFinder finder( indexer, env );
+
+                auto pick_alternatives = [target, this](AltList & found, bool expect_ref) {
+                        for(auto & alt : found) {
+                                Type * expr = alt.expr->get_result();
+                                if(expect_ref) {
+                                        auto res = dynamic_cast<ReferenceType*>(expr);
+                                        if(!res) { continue; }
+                                        expr = res->base;
+                                }
+
+                                if(auto insttype = dynamic_cast<TypeInstType*>(expr)) {
+                                        auto td = alt.env.lookup(insttype->name);
+                                        if(!td) { continue; }
+                                        expr = td->type;
+                                }
+
+                                if(auto base = dynamic_cast<StructInstType*>(expr)) {
+                                        if(base->baseStruct == target) {
+                                                alternatives.push_back(
+                                                        std::move(alt)
+                                                );
+                                        }
+                                }
+                        }
+                };
+
+                try {
+                        // Attempt 1 : turn (thread&)X into (thread_desc&)X.__thrd
+                        // Clone is purely for memory management
+                        std::unique_ptr<Expression> tech1 { new UntypedMemberExpr(new NameExpr(castExpr->concrete_target.field), castExpr->arg->clone()) };
+
+                        // don't prune here, since it's guaranteed all alternatives will have the same type
+                        finder.findWithoutPrune( tech1.get() );
+                        pick_alternatives(finder.alternatives, false);
+
+                        return;
+                } catch(SemanticErrorException & ) {}
+
+                // Fallback : turn (thread&)X into (thread_desc&)get_thread(X)
+                std::unique_ptr<Expression> fallback { UntypedExpr::createDeref( new UntypedExpr(new NameExpr(castExpr->concrete_target.getter), { castExpr->arg->clone() })) };
+                // don't prune here, since it's guaranteed all alternatives will have the same type
+                finder.findWithoutPrune( fallback.get() );
+
+                pick_alternatives(finder.alternatives, true);
+
+                // Whatever happens here, we have no more fallbacks
+        }
+
         namespace {
                 /// Gets name from untyped member expression (member must be NameExpr)

src/SynTree/Expression.h

@@ -231 +231 @@
         enum Target {
                 Coroutine, Thread, Monitor, NUMBER_OF_TARGETS
-        } target;
+        };
+        struct Concrete {
+                std::string field;
+                std::string getter;
+        };
+        Target target;
+        Concrete concrete_target;
 
         KeywordCastExpr( Expression * arg, Target target );

src/cfa.make

@@ -4 +4 @@
 LTCFACOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
         $(LIBTOOLFLAGS) --mode=compile $(CFACC) $(DEFS) \
-        $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CFAFLAGS) $(CFAFLAGS) \
-        $(AM_CFLAGS) $(CFLAGS)
+        $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CFAFLAGS) $(AM_CFLAGS) $(CFAFLAGS) $(CFLAGS)
 
 AM_V_CFA = $(am__v_CFA_@AM_V@)