Changeset 135b431 for src/Parser

Timestamp:

Aug 25, 2017, 11:09:02 AM (8 years ago)

Author:

Thierry Delisle <tdelisle@…>

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:

6b224a52

Parents:

3eab0ef6

Message:

First step for waitfor statments, does nothing but is there

Location:

src/Parser

Files:

• ParseNode.h (modified) (1 diff)
• StatementNode.cc (modified) (2 diffs)
• parser.yy (modified) (5 diffs)

src/Parser/ParseNode.h

@@ -414 +414 @@
 Statement * build_compound( StatementNode * first );
 Statement * build_asmstmt( bool voltile, ConstantExpr * instruction, ExpressionNode * output = nullptr, ExpressionNode * input = nullptr, ExpressionNode * clobber = nullptr, LabelNode * gotolabels = nullptr );
+WaitForStmt * build_waitfor( ExpressionNode * target, StatementNode * stmt, ExpressionNode * when );
+WaitForStmt * build_waitfor( ExpressionNode * target, StatementNode * stmt, ExpressionNode * when, WaitForStmt * existing );
+WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when );
+WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when, StatementNode * else_stmt, ExpressionNode * else_when );
 
 //##############################################################################

src/Parser/StatementNode.cc

@@ -93 +93 @@
                 elseb = branches.front();
         } // if
-        
+
         std::list< Statement * > init;
         if ( ctl->init != 0 ) {
@@ -207 +207 @@
 }
 
+WaitForStmt * build_waitfor( ExpressionNode * targetExpr, StatementNode * stmt, ExpressionNode * when ) {
+        auto node = new WaitForStmt();
+
+        WaitForStmt::Target target;
+        target.function = maybeBuild<Expression>( targetExpr );
+        buildMoveList< Expression >( targetExpr, target.arguments );
+        delete targetExpr;
+
+        node->clauses.push_back( WaitForStmt::Clause{
+                target,
+                maybeMoveBuild<Statement >( stmt ),
+                maybeMoveBuild<Expression>( when )
+        });
+
+        return node;
+}
+
+WaitForStmt * build_waitfor( ExpressionNode * targetExpr, StatementNode * stmt, ExpressionNode * when, WaitForStmt * node ) {
+        WaitForStmt::Target target;
+
+        target.function = maybeBuild<Expression>( targetExpr );
+        buildMoveList< Expression >( targetExpr, target.arguments );
+        delete targetExpr;
+
+        node->clauses.push_back( WaitForStmt::Clause{
+                std::move( target ),
+                maybeMoveBuild<Statement >( stmt ),
+                maybeMoveBuild<Expression>( when )
+        });
+
+        return node;
+}
+
+WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when ) {
+        auto node = new WaitForStmt();
+
+        if( timeout ) {
+                node->timeout.time      = maybeMoveBuild<Expression>( timeout );
+                node->timeout.statement = maybeMoveBuild<Statement >( stmt    );
+                node->timeout.condition = maybeMoveBuild<Expression>( when    );
+        }
+        else {
+                node->orelse.statement  = maybeMoveBuild<Statement >( stmt    );
+                node->orelse.condition  = maybeMoveBuild<Expression>( when    );
+        }
+
+        return node;
+}
+
+WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when,  StatementNode * else_stmt, ExpressionNode * else_when ) {
+        auto node = new WaitForStmt();
+
+        node->timeout.time      = maybeMoveBuild<Expression>( timeout );
+        node->timeout.statement = maybeMoveBuild<Statement >( stmt    );
+        node->timeout.condition = maybeMoveBuild<Expression>( when    );
+
+        node->orelse.statement = maybeMoveBuild<Statement >( else_stmt );
+        node->orelse.condition = maybeMoveBuild<Expression>( else_when );
+
+        return node;
+}
+
+// WaitForStmt::Target build_waitfor( const std::string * name, ExpressionNode * arguments ) {
+//       return WaitForStmt::Clause{
+
+//       };
+// }
+
 Statement *build_compound( StatementNode *first ) {
         CompoundStmt *cs = new CompoundStmt( noLabels );

src/Parser/parser.yy

@@ -97 +97 @@
         DeclarationNode::TypeClass tclass;
         StatementNode * sn;
+        WaitForStmt * wfs;
         ConstantExpr * constant;
         IfCtl * ifctl;
@@ -187 +188 @@
 %type<flag> asm_volatile_opt
 %type<en> handler_predicate_opt
+%type<en> when_clause_opt timeout
 
 // statements
@@ -192 +194 @@
 %type<sn> iteration_statement                   jump_statement
 %type<sn> with_statement                                exception_statement                     asm_statement
-%type<sn> when_clause_opt                               waitfor_statement                       waitfor_clause                          waitfor                         timeout
+%type<sn> waitfor_statement
 %type<sn> fall_through_opt                              fall_through
 %type<sn> statement                                             statement_list
@@ -202 +204 @@
 %type<sn> handler_clause                                finally_clause
 %type<catch_kind> handler_key
+%type<wfs> waitfor_clause
+%type<en> waitfor
 
 // declarations
@@ -979 +983 @@
 when_clause_opt:
         // empty
-                { $$ = nullptr; }                                                               // FIX ME
+                { $$ = nullptr; }
         | WHEN '(' comma_expression ')'
-                { $$ = nullptr; }                                                               // FIX ME
+                { $$ = $3; }
         ;
 
 waitfor:
         WAITFOR '(' identifier ')'
-                { $$ = nullptr; }                                                               // FIX ME
+                {
+                        $$ = new ExpressionNode( new NameExpr( *$3 ) );
+                        delete $3;
+                }
         | WAITFOR '(' identifier ',' argument_expression_list ')'
-                { $$ = nullptr; }                                                               // FIX ME
+                {
+                        $$ = new ExpressionNode( new NameExpr( *$3 ) );
+                        $$->set_last( $5 );
+                        delete $3;
+                }
         ;
 
 timeout:
         TIMEOUT '(' comma_expression ')'
-                { $$ = nullptr; }                                                               // FIX ME
+                { $$ = $3; }
         ;
 
 waitfor_clause:
         when_clause_opt waitfor statement %prec THEN
-                { $$ = nullptr; }                                                               // FIX ME
+                { $$ = build_waitfor( $2, $3, $1 ); }
         | when_clause_opt waitfor statement WOR waitfor_clause
-                { $$ = nullptr; }                                                               // FIX ME
+                { $$ = build_waitfor( $2, $3, $1, $5 ); }
         | when_clause_opt timeout statement %prec THEN
-                { $$ = nullptr; }                                                               // FIX ME
+                { $$ = build_waitfor_timeout( $2, $3, $1 ); }
         | when_clause_opt ELSE statement
-                { $$ = nullptr; }                                                               // FIX ME
+                { $$ = build_waitfor_timeout( nullptr, $3, $1 ); }
         | when_clause_opt timeout statement WOR when_clause_opt ELSE statement
-                { $$ = nullptr; }                                                               // FIX ME
+                { $$ = build_waitfor_timeout( $2, $3, $1, $7, $5 ); }
         ;
 
 waitfor_statement:
         when_clause_opt waitfor statement %prec THEN
-                { $$ = nullptr; }                                                               // FIX ME
+                { $$ = new StatementNode( build_waitfor( $2, $3, $1 ) ); }
         | when_clause_opt waitfor statement WOR waitfor_clause
-                { $$ = nullptr; }                                                               // FIX ME
+                { $$ = new StatementNode( build_waitfor( $2, $3, $1, $5 ) ); }
         ;