Changeset 2a301ff for src/Parser

Timestamp:

Aug 31, 2023, 11:31:15 PM (10 months ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

950c58e

Parents:

92355883 (diff), 686912c (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:

Resolve conflict

Location:

src/Parser

Files:

• StatementNode.cc (modified) (2 diffs)
• StatementNode.h (modified) (2 diffs)
• TypedefTable.cc (modified) (6 diffs)
• TypedefTable.h (modified) (3 diffs)
• parser.yy (modified) (44 diffs)

src/Parser/StatementNode.cc

@@ -10 +10 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 14:59:41 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Tue Apr 11 10:16:00 2023
-// Update Count     : 428
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Aug 11 11:44:15 2023
+// Update Count     : 429
 //
 
@@ -361 +361 @@
 
 ast::WaitUntilStmt::ClauseNode * build_waituntil_clause( const CodeLocation & loc, ExpressionNode * when, ExpressionNode * targetExpr, StatementNode * stmt ) {
-    ast::WhenClause * clause = new ast::WhenClause( loc );
-    clause->when_cond = notZeroExpr( maybeMoveBuild( when ) );
-    clause->stmt = maybeMoveBuild( stmt );
-    clause->target = maybeMoveBuild( targetExpr );
-    return new ast::WaitUntilStmt::ClauseNode( clause );
+        ast::WhenClause * clause = new ast::WhenClause( loc );
+        clause->when_cond = notZeroExpr( maybeMoveBuild( when ) );
+        clause->stmt = maybeMoveBuild( stmt );
+        clause->target = maybeMoveBuild( targetExpr );
+        return new ast::WaitUntilStmt::ClauseNode( clause );
 }
 ast::WaitUntilStmt::ClauseNode * build_waituntil_else( const CodeLocation & loc, ExpressionNode * when, StatementNode * stmt ) {
-    ast::WhenClause * clause = new ast::WhenClause( loc );
-    clause->when_cond = notZeroExpr( maybeMoveBuild( when ) );
-    clause->stmt = maybeMoveBuild( stmt );
-    return new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::ELSE, clause );
-}
-ast::WaitUntilStmt::ClauseNode * build_waituntil_timeout( const CodeLocation & loc, ExpressionNode * when, ExpressionNode * timeout, StatementNode * stmt ) {
-    ast::WhenClause * clause = new ast::WhenClause( loc );
-    clause->when_cond = notZeroExpr( maybeMoveBuild( when ) );
-    clause->stmt = maybeMoveBuild( stmt );
-    clause->target = maybeMoveBuild( timeout );
-    return new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::TIMEOUT, clause );
+        ast::WhenClause * clause = new ast::WhenClause( loc );
+        clause->when_cond = notZeroExpr( maybeMoveBuild( when ) );
+        clause->stmt = maybeMoveBuild( stmt );
+        return new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::ELSE, clause );
 }
 
 ast::WaitUntilStmt * build_waituntil_stmt( const CodeLocation & loc, ast::WaitUntilStmt::ClauseNode * root ) {
-    ast::WaitUntilStmt * retStmt = new ast::WaitUntilStmt( loc );
-    retStmt->predicateTree = root;
-    
-    // iterative tree traversal
-    std::vector<ast::WaitUntilStmt::ClauseNode *> nodeStack; // stack needed for iterative traversal
-    ast::WaitUntilStmt::ClauseNode * currNode = nullptr;
-    ast::WaitUntilStmt::ClauseNode * lastInternalNode = nullptr;
-    ast::WaitUntilStmt::ClauseNode * cleanup = nullptr; // used to cleanup removed else/timeout
-    nodeStack.push_back(root);
-
-    do {
-        currNode = nodeStack.back();
-        nodeStack.pop_back(); // remove node since it will be processed
-
-        switch (currNode->op) {
-            case ast::WaitUntilStmt::ClauseNode::LEAF:
-                retStmt->clauses.push_back(currNode->leaf);
-                break;
-            case ast::WaitUntilStmt::ClauseNode::ELSE:
-                retStmt->else_stmt = currNode->leaf->stmt 
-                    ? ast::deepCopy( currNode->leaf->stmt )
-                    : nullptr;
-                
-                retStmt->else_cond = currNode->leaf->when_cond
-                    ? ast::deepCopy( currNode->leaf->when_cond )
-                    : nullptr;
-
-                delete currNode->leaf;
-                break;
-            case ast::WaitUntilStmt::ClauseNode::TIMEOUT:
-                retStmt->timeout_time = currNode->leaf->target 
-                    ? ast::deepCopy( currNode->leaf->target )
-                    : nullptr;
-                retStmt->timeout_stmt = currNode->leaf->stmt
-                    ? ast::deepCopy( currNode->leaf->stmt )
-                    : nullptr;
-                retStmt->timeout_cond = currNode->leaf->when_cond
-                    ? ast::deepCopy( currNode->leaf->when_cond )
-                    : nullptr;
-
-                delete currNode->leaf;
-                break;
-            default:
-                nodeStack.push_back( currNode->right ); // process right after left
-                nodeStack.push_back( currNode->left );
-
-                // Cut else/timeout out of the tree
-                if ( currNode->op == ast::WaitUntilStmt::ClauseNode::LEFT_OR ) {
-                    if ( lastInternalNode )
-                        lastInternalNode->right = currNode->left;
-                    else    // if not set then root is LEFT_OR 
-                        retStmt->predicateTree = currNode->left;
-    
-                    currNode->left = nullptr;
-                    cleanup = currNode;
-                }
-                
-                lastInternalNode = currNode;
-                break;
-        }
-    } while ( !nodeStack.empty() );
-
-    if ( cleanup ) delete cleanup;
-
-    return retStmt;
+        ast::WaitUntilStmt * retStmt = new ast::WaitUntilStmt( loc );
+        retStmt->predicateTree = root;
+
+        // iterative tree traversal
+        std::vector<ast::WaitUntilStmt::ClauseNode *> nodeStack; // stack needed for iterative traversal
+        ast::WaitUntilStmt::ClauseNode * currNode = nullptr;
+        ast::WaitUntilStmt::ClauseNode * lastInternalNode = nullptr;
+        ast::WaitUntilStmt::ClauseNode * cleanup = nullptr; // used to cleanup removed else/timeout
+        nodeStack.push_back(root);
+
+        do {
+                currNode = nodeStack.back();
+                nodeStack.pop_back(); // remove node since it will be processed
+
+                switch (currNode->op) {
+                case ast::WaitUntilStmt::ClauseNode::LEAF:
+                        retStmt->clauses.push_back(currNode->leaf);
+                        break;
+                case ast::WaitUntilStmt::ClauseNode::ELSE:
+                        retStmt->else_stmt = currNode->leaf->stmt
+                                ? ast::deepCopy( currNode->leaf->stmt )
+                                : nullptr;
+                        retStmt->else_cond = currNode->leaf->when_cond
+                                ? ast::deepCopy( currNode->leaf->when_cond )
+                                : nullptr;
+
+                        delete currNode->leaf;
+                        break;
+                case ast::WaitUntilStmt::ClauseNode::TIMEOUT:
+                        retStmt->timeout_time = currNode->leaf->target
+                                ? ast::deepCopy( currNode->leaf->target )
+                                : nullptr;
+                        retStmt->timeout_stmt = currNode->leaf->stmt
+                                ? ast::deepCopy( currNode->leaf->stmt )
+                                : nullptr;
+                        retStmt->timeout_cond = currNode->leaf->when_cond
+                                ? ast::deepCopy( currNode->leaf->when_cond )
+                                : nullptr;
+
+                        delete currNode->leaf;
+                        break;
+                default:
+                        nodeStack.push_back( currNode->right ); // process right after left
+                        nodeStack.push_back( currNode->left );
+
+                        // Cut else/timeout out of the tree
+                        if ( currNode->op == ast::WaitUntilStmt::ClauseNode::LEFT_OR ) {
+                                if ( lastInternalNode )
+                                        lastInternalNode->right = currNode->left;
+                                else // if not set then root is LEFT_OR
+                                        retStmt->predicateTree = currNode->left;
+
+                                currNode->left = nullptr;
+                                cleanup = currNode;
+                        }
+
+                        lastInternalNode = currNode;
+                        break;
+                }
+        } while ( !nodeStack.empty() );
+
+        if ( cleanup ) delete cleanup;
+
+        return retStmt;
 }
 

src/Parser/StatementNode.h

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Wed Apr  5 11:42:00 2023
-// Last Modified By : Andrew Beach
-// Last Modified On : Tue Apr 11  9:43:00 2023
-// Update Count     : 1
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Aug 11 11:44:07 2023
+// Update Count     : 2
 //
 
@@ -102 +102 @@
 ast::WaitUntilStmt::ClauseNode * build_waituntil_clause( const CodeLocation &, ExpressionNode * when, ExpressionNode * targetExpr, StatementNode * stmt );
 ast::WaitUntilStmt::ClauseNode * build_waituntil_else( const CodeLocation &, ExpressionNode * when, StatementNode * stmt );
-ast::WaitUntilStmt::ClauseNode * build_waituntil_timeout( const CodeLocation &, ExpressionNode * when, ExpressionNode * timeout, StatementNode * stmt );
 ast::WaitUntilStmt * build_waituntil_stmt( const CodeLocation &, ast::WaitUntilStmt::ClauseNode * root );
 ast::Stmt * build_with( const CodeLocation &, ExpressionNode * exprs, StatementNode * stmt );

src/Parser/TypedefTable.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 15:20:13 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb 15 08:27:24 2022
-// Update Count     : 275
+// Last Modified On : Wed Jul 12 06:11:28 2023
+// Update Count     : 276
 //
 
@@ -17 +17 @@
 #include "TypedefTable.h"
 
-#include <cassert>                                // for assert
-#include <string>                                 // for string
-#include <iostream>                               // for iostream
+#include <cassert>                                                                              // for assert
+#include <string>                                                                               // for string
+#include <iostream>                                                                             // for iostream
 
-#include "ExpressionNode.h"                       // for LabelNode
-#include "ParserTypes.h"                          // for Token
-#include "StatementNode.h"                        // for CondCtl, ForCtrl
+#include "ExpressionNode.h"                                                             // for LabelNode
+#include "ParserTypes.h"                                                                // for Token
+#include "StatementNode.h"                                                              // for CondCtl, ForCtrl
 // This (generated) header must come late as it is missing includes.
-#include "parser.hh"              // for IDENTIFIER, TYPEDEFname, TYPEGENname
+#include "parser.hh"                                                                    // for IDENTIFIER, TYPEDEFname, TYPEGENname
 
 using namespace std;
@@ -72 +72 @@
 // "struct". Only generate the typedef, if the name is not in use. The typedef is implicitly (silently) removed if the
 // name is explicitly used.
-void TypedefTable::makeTypedef( const string & name, int kind ) {
+void TypedefTable::makeTypedef( const string & name, int kind, const char * locn __attribute__((unused)) ) {
 //    Check for existence is necessary to handle:
 //        struct Fred {};
@@ -80 +80 @@
 //           Fred();
 //        }
+        debugPrint( cerr << "Make typedef at " << locn << " \"" << name << "\" as " << kindName( kind ) << " scope " << kindTable.currentScope() << endl );
         if ( ! typedefTable.exists( name ) ) {
                 typedefTable.addToEnclosingScope( name, kind, "MTD" );
@@ -85 +86 @@
 } // TypedefTable::makeTypedef
 
-void TypedefTable::makeTypedef( const string & name ) {
-        return makeTypedef( name, TYPEDEFname );
+void TypedefTable::makeTypedef( const string & name, const char * locn __attribute__((unused)) ) {
+        debugPrint( cerr << "Make typedef at " << locn << " \"" << name << " scope " << kindTable.currentScope() << endl );
+        return makeTypedef( name, TYPEDEFname, "makeTypede" );
 } // TypedefTable::makeTypedef
 
 void TypedefTable::addToScope( const string & identifier, int kind, const char * locn __attribute__((unused)) ) {
         KindTable::size_type scope = kindTable.currentScope();
-        debugPrint( cerr << "Adding current at " << locn << " " << identifier << " as " << kindName( kind ) << " scope " << scope << endl );
+        debugPrint( cerr << "Adding current at " << locn << " \"" << identifier << "\" as " << kindName( kind ) << " scope " << scope << endl );
         kindTable.insertAt( scope, identifier, kind );
 } // TypedefTable::addToScope
@@ -98 +100 @@
         KindTable::size_type scope = kindTable.currentScope() - 1 - kindTable.getNote( kindTable.currentScope() - 1 ).level;
 //      size_type scope = level - kindTable.getNote( kindTable.currentScope() - 1 ).level;
-        debugPrint( cerr << "Adding enclosing at " << locn << " " << identifier << " as " << kindName( kind ) << " scope " << scope << " level " << level << " note " << kindTable.getNote( kindTable.currentScope() - 1 ).level << endl );
+        debugPrint( cerr << "Adding enclosing at " << locn << " \"" << identifier << "\" as " << kindName( kind ) << " scope " << scope << " level " << level << " note " << kindTable.getNote( kindTable.currentScope() - 1 ).level << endl );
         pair< KindTable::iterator, bool > ret = kindTable.insertAt( scope, identifier, kind );
         if ( ! ret.second ) ret.first->second = kind;           // exists => update

src/Parser/TypedefTable.h

@@ -10 +10 @@
 // Created On       : Sat May 16 15:24:36 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Feb 15 08:06:37 2020
-// Update Count     : 117
+// Last Modified On : Wed Jul 12 06:09:37 2023
+// Update Count     : 118
 //
 
@@ -21 +21 @@
 
 class TypedefTable {
-        struct Note { size_t level; bool forall; };
+        struct Note {
+                size_t level;
+                bool forall;
+        };
         typedef ScopedMap< std::string, int, Note > KindTable;
         KindTable kindTable;
@@ -31 +34 @@
         bool existsCurr( const std::string & identifier ) const;
         int isKind( const std::string & identifier ) const;
-        void makeTypedef( const std::string & name, int kind );
-        void makeTypedef( const std::string & name );
+        void makeTypedef( const std::string & name, int kind, const char * );
+        void makeTypedef( const std::string & name, const char * );
         void addToScope( const std::string & identifier, int kind, const char * );
         void addToEnclosingScope( const std::string & identifier, int kind, const char * );

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jun 17 18:53:24 2023
-// Update Count     : 6347
+// Last Modified On : Tue Jul 18 22:51:30 2023
+// Update Count     : 6391
 //
 
@@ -385 +385 @@
 %type<str> string_literal_list
 
-%type<enum_hiding> hide_opt                                     visible_hide_opt
+%type<enum_hiding> hide_opt                             visible_hide_opt
 
 // expressions
 %type<expr> constant
-%type<expr> tuple                                                       tuple_expression_list
+%type<expr> tuple                                               tuple_expression_list
 %type<oper> ptrref_operator                             unary_operator                          assignment_operator                     simple_assignment_operator      compound_assignment_operator
 %type<expr> primary_expression                  postfix_expression                      unary_expression
-%type<expr> cast_expression_list                        cast_expression                         exponential_expression          multiplicative_expression       additive_expression
-%type<expr> shift_expression                            relational_expression           equality_expression
+%type<expr> cast_expression_list                cast_expression                         exponential_expression          multiplicative_expression       additive_expression
+%type<expr> shift_expression                    relational_expression           equality_expression
 %type<expr> AND_expression                              exclusive_OR_expression         inclusive_OR_expression
 %type<expr> logical_AND_expression              logical_OR_expression
 %type<expr> conditional_expression              constant_expression                     assignment_expression           assignment_expression_opt
-%type<expr> comma_expression                            comma_expression_opt
-%type<expr> argument_expression_list_opt        argument_expression_list        argument_expression                     default_initializer_opt
+%type<expr> comma_expression                    comma_expression_opt
+%type<expr> argument_expression_list_opt argument_expression_list       argument_expression                     default_initializer_opt
 %type<ifctl> conditional_declaration
-%type<forctl> for_control_expression            for_control_expression_list
+%type<forctl> for_control_expression    for_control_expression_list
 %type<oper> upupeq updown updowneq downupdowneq
 %type<expr> subrange
 %type<decl> asm_name_opt
-%type<expr> asm_operands_opt                            asm_operands_list                       asm_operand
+%type<expr> asm_operands_opt                    asm_operands_list                       asm_operand
 %type<labels> label_list
 %type<expr> asm_clobbers_list_opt
@@ -412 +412 @@
 
 // statements
-%type<stmt> statement                                           labeled_statement                       compound_statement
+%type<stmt> statement                                   labeled_statement                       compound_statement
 %type<stmt> statement_decl                              statement_decl_list                     statement_list_nodecl
 %type<stmt> selection_statement                 if_statement
-%type<clause> switch_clause_list_opt            switch_clause_list
+%type<clause> switch_clause_list_opt    switch_clause_list
 %type<expr> case_value
-%type<clause> case_clause                               case_value_list                         case_label                                      case_label_list
+%type<clause> case_clause                               case_value_list                         case_label      case_label_list
 %type<stmt> iteration_statement                 jump_statement
-%type<stmt> expression_statement                        asm_statement
+%type<stmt> expression_statement                asm_statement
 %type<stmt> with_statement
 %type<expr> with_clause_opt
@@ -427 +427 @@
 %type<stmt> mutex_statement
 %type<expr> when_clause                                 when_clause_opt                         waitfor         waituntil               timeout
-%type<stmt> waitfor_statement                           waituntil_statement
+%type<stmt> waitfor_statement                   waituntil_statement
 %type<wfs> wor_waitfor_clause
 %type<wucn> waituntil_clause                    wand_waituntil_clause       wor_waituntil_clause
@@ -601 +601 @@
 // around the list separator.
 //
-//  int f( forall(T) T (*f1) T , forall( S ) S (*f2)( S ) );
+//  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 //      push               pop   push                   pop
 
@@ -689 +689 @@
         // | RESUME '(' comma_expression ')' compound_statement
         //      { SemanticError( yylloc, "Resume expression is currently unimplemented." ); $$ = nullptr; }
-        | IDENTIFIER IDENTIFIER                                                         // invalid syntax rules
+        | IDENTIFIER IDENTIFIER                                                         // invalid syntax rule
                 { IdentifierBeforeIdentifier( *$1.str, *$2.str, "n expression" ); $$ = nullptr; }
-        | IDENTIFIER type_qualifier                                                     // invalid syntax rules
+        | IDENTIFIER type_qualifier                                                     // invalid syntax rule
                 { IdentifierBeforeType( *$1.str, "type qualifier" ); $$ = nullptr; }
-        | IDENTIFIER storage_class                                                      // invalid syntax rules
+        | IDENTIFIER storage_class                                                      // invalid syntax rule
                 { IdentifierBeforeType( *$1.str, "storage class" ); $$ = nullptr; }
-        | IDENTIFIER basic_type_name                                            // invalid syntax rules
+        | IDENTIFIER basic_type_name                                            // invalid syntax rule
                 { IdentifierBeforeType( *$1.str, "type" ); $$ = nullptr; }
-        | IDENTIFIER TYPEDEFname                                                        // invalid syntax rules
+        | IDENTIFIER TYPEDEFname                                                        // invalid syntax rule
                 { IdentifierBeforeType( *$1.str, "type" ); $$ = nullptr; }
-        | IDENTIFIER TYPEGENname                                                        // invalid syntax rules
+        | IDENTIFIER TYPEGENname                                                        // invalid syntax rule
                 { IdentifierBeforeType( *$1.str, "type" ); $$ = nullptr; }
         ;
@@ -1275 +1275 @@
         | DEFAULT ':'                                                           { $$ = new ClauseNode( build_default( yylloc ) ); }
                 // A semantic check is required to ensure only one default clause per switch/choose statement.
-        | DEFAULT error                                                                         //  invalid syntax rules
+        | DEFAULT error                                                                         //  invalid syntax rule
                 { SemanticError( yylloc, "syntax error, colon missing after default." ); $$ = nullptr; }
         ;
@@ -1405 +1405 @@
                         else { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; }
                 }
-        | comma_expression updowneq comma_expression '~' '@' // CFA, invalid syntax rules
+        | comma_expression updowneq comma_expression '~' '@' // CFA, invalid syntax rule
                 { SemanticError( yylloc, MISSING_ANON_FIELD ); $$ = nullptr; }
-        | '@' updowneq '@'                                                                      // CFA, invalid syntax rules
+        | '@' updowneq '@'                                                                      // CFA, invalid syntax rule
                 { SemanticError( yylloc, MISSING_ANON_FIELD ); $$ = nullptr; }
-        | '@' updowneq comma_expression '~' '@'                         // CFA, invalid syntax rules
+        | '@' updowneq comma_expression '~' '@'                         // CFA, invalid syntax rule
                 { SemanticError( yylloc, MISSING_ANON_FIELD ); $$ = nullptr; }
-        | comma_expression updowneq '@' '~' '@'                         // CFA, invalid syntax rules
+        | comma_expression updowneq '@' '~' '@'                         // CFA, invalid syntax rule
                 { SemanticError( yylloc, MISSING_ANON_FIELD ); $$ = nullptr; }
-        | '@' updowneq '@' '~' '@'                                                      // CFA, invalid syntax rules
+        | '@' updowneq '@' '~' '@'                                                      // CFA, invalid syntax rule
                 { SemanticError( yylloc, MISSING_ANON_FIELD ); $$ = nullptr; }
 
@@ -1434 +1434 @@
                         else $$ = forCtrl( yylloc, $3, $1, $3->clone(), $4, nullptr, NEW_ONE );
                 }
-        | comma_expression ';' '@' updowneq '@'                         // CFA, invalid syntax rules
+        | comma_expression ';' '@' updowneq '@'                         // CFA, invalid syntax rule
                 { SemanticError( yylloc, "syntax error, missing low/high value for up/down-to range so index is uninitialized." ); $$ = nullptr; }
 
         | comma_expression ';' comma_expression updowneq comma_expression '~' comma_expression // CFA
                 { $$ = forCtrl( yylloc, $3, $1, UPDOWN( $4, $3->clone(), $5 ), $4, UPDOWN( $4, $5->clone(), $3->clone() ), $7 ); }
-        | comma_expression ';' '@' updowneq comma_expression '~' comma_expression // CFA, invalid syntax rules
+        | comma_expression ';' '@' updowneq comma_expression '~' comma_expression // CFA, invalid syntax rule
                 {
                         if ( $4 == OperKinds::LThan || $4 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
@@ -1452 +1452 @@
         | comma_expression ';' comma_expression updowneq comma_expression '~' '@' // CFA
                 { $$ = forCtrl( yylloc, $3, $1, UPDOWN( $4, $3->clone(), $5 ), $4, UPDOWN( $4, $5->clone(), $3->clone() ), nullptr ); }
-        | comma_expression ';' '@' updowneq comma_expression '~' '@' // CFA, invalid syntax rules
+        | comma_expression ';' '@' updowneq comma_expression '~' '@' // CFA, invalid syntax rule
                 {
                         if ( $4 == OperKinds::LThan || $4 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
@@ -1511 +1511 @@
                         else $$ = forCtrl( yylloc, $1, $2, $3, nullptr, nullptr );
                 }
-        | declaration '@' updowneq '@' '~' '@'                          // CFA, invalid syntax rules
+        | declaration '@' updowneq '@' '~' '@'                          // CFA, invalid syntax rule
                 { SemanticError( yylloc, "syntax error, missing low/high value for up/down-to range so index is uninitialized." ); $$ = nullptr; }
 
@@ -1666 +1666 @@
                 { $$ = build_waitfor_timeout( yylloc, $1, $3, $4, maybe_build_compound( yylloc, $5 ) ); }
         // "else" must be conditional after timeout or timeout is never triggered (i.e., it is meaningless)
-        | wor_waitfor_clause wor when_clause_opt timeout statement wor ELSE statement // invalid syntax rules
+        | wor_waitfor_clause wor when_clause_opt timeout statement wor ELSE statement // invalid syntax rule
                 { SemanticError( yylloc, "syntax error, else clause must be conditional after timeout or timeout never triggered." ); $$ = nullptr; }
         | wor_waitfor_clause wor when_clause_opt timeout statement wor when_clause ELSE statement
@@ -1708 +1708 @@
         | wor_waituntil_clause wor when_clause_opt ELSE statement
                 { $$ = new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::LEFT_OR, $1, build_waituntil_else( yylloc, $3, maybe_build_compound( yylloc, $5 ) ) ); }
-        | wor_waituntil_clause wor when_clause_opt timeout statement    %prec THEN
-                { $$ = new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::LEFT_OR, $1, build_waituntil_timeout( yylloc, $3, $4, maybe_build_compound( yylloc, $5 ) ) ); }
-        // "else" must be conditional after timeout or timeout is never triggered (i.e., it is meaningless)
-        | wor_waituntil_clause wor when_clause_opt timeout statement wor ELSE statement // invalid syntax rules
-                { SemanticError( yylloc, "syntax error, else clause must be conditional after timeout or timeout never triggered." ); $$ = nullptr; }
-        | wor_waituntil_clause wor when_clause_opt timeout statement wor when_clause ELSE statement
-                { $$ = new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::LEFT_OR, $1,
-                new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::OR, 
-                    build_waituntil_timeout( yylloc, $3, $4, maybe_build_compound( yylloc, $5 ) ), 
-                    build_waituntil_else( yylloc, $7, maybe_build_compound( yylloc, $9 ) ) ) ); }
         ;
 
 waituntil_statement:
         wor_waituntil_clause                                                            %prec THEN
-                // SKULLDUGGERY: create an empty compound statement to test parsing of waituntil statement.
-                {
-            $$ = new StatementNode( build_waituntil_stmt( yylloc, $1 ) );
-            // $$ = new StatementNode( build_compound( yylloc, nullptr ) );
-        }
+                { $$ = new StatementNode( build_waituntil_stmt( yylloc, $1 ) ); }
         ;
 
@@ -1868 +1854 @@
 
 KR_parameter_list:
-        push c_declaration pop ';'
-                { $$ = $2; }
-        | KR_parameter_list push c_declaration pop ';'
-                { $$ = $1->appendList( $3 ); }
+        c_declaration ';'
+                { $$ = $1; }
+        | KR_parameter_list c_declaration ';'
+                { $$ = $1->appendList( $2 ); }
         ;
 
@@ -2007 +1993 @@
         TYPEDEF cfa_variable_specifier
                 {
-                        typedefTable.addToEnclosingScope( *$2->name, TYPEDEFname, "1" );
+                        typedefTable.addToEnclosingScope( *$2->name, TYPEDEFname, "cfa_typedef_declaration 1" );
                         $$ = $2->addTypedef();
                 }
         | TYPEDEF cfa_function_specifier
                 {
-                        typedefTable.addToEnclosingScope( *$2->name, TYPEDEFname, "2" );
+                        typedefTable.addToEnclosingScope( *$2->name, TYPEDEFname, "cfa_typedef_declaration 2" );
                         $$ = $2->addTypedef();
                 }
         | cfa_typedef_declaration pop ',' push identifier
                 {
-                        typedefTable.addToEnclosingScope( *$5, TYPEDEFname, "3" );
+                        typedefTable.addToEnclosingScope( *$5, TYPEDEFname, "cfa_typedef_declaration 3" );
                         $$ = $1->appendList( $1->cloneType( $5 ) );
                 }
@@ -2028 +2014 @@
         TYPEDEF type_specifier declarator
                 {
-                        typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname, "4" );
+                        typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname, "typedef_declaration 1" );
                         if ( $2->type->forall || ($2->type->kind == TypeData::Aggregate && $2->type->aggregate.params) ) {
                                 SemanticError( yylloc, "forall qualifier in typedef is currently unimplemented." ); $$ = nullptr;
                         } else $$ = $3->addType( $2 )->addTypedef(); // watchout frees $2 and $3
                 }
-        | typedef_declaration pop ',' push declarator
-                {
-                        typedefTable.addToEnclosingScope( *$5->name, TYPEDEFname, "5" );
-                        $$ = $1->appendList( $1->cloneBaseType( $5 )->addTypedef() );
+        | typedef_declaration ',' declarator
+                {
+                        typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname, "typedef_declaration 2" );
+                        $$ = $1->appendList( $1->cloneBaseType( $3 )->addTypedef() );
                 }
         | type_qualifier_list TYPEDEF type_specifier declarator // remaining OBSOLESCENT (see 2 )
@@ -2052 +2038 @@
                         SemanticError( yylloc, "TYPEDEF expression is deprecated, use typeof(...) instead." ); $$ = nullptr;
                 }
-        | typedef_expression pop ',' push identifier '=' assignment_expression
+        | typedef_expression ',' identifier '=' assignment_expression
                 {
                         SemanticError( yylloc, "TYPEDEF expression is deprecated, use typeof(...) instead." ); $$ = nullptr;
@@ -2465 +2451 @@
         | aggregate_key attribute_list_opt identifier
                 {
-                        typedefTable.makeTypedef( *$3, forall || typedefTable.getEnclForall() ? TYPEGENname : TYPEDEFname ); // create typedef
+                        typedefTable.makeTypedef( *$3, forall || typedefTable.getEnclForall() ? TYPEGENname : TYPEDEFname, "aggregate_type: 1" );
                         forall = false;                                                         // reset
                 }
@@ -2474 +2460 @@
         | aggregate_key attribute_list_opt TYPEDEFname          // unqualified type name
                 {
-                        typedefTable.makeTypedef( *$3, forall || typedefTable.getEnclForall() ? TYPEGENname : TYPEDEFname ); // create typedef
+                        typedefTable.makeTypedef( *$3, forall || typedefTable.getEnclForall() ? TYPEGENname : TYPEDEFname, "aggregate_type: 2" );
                         forall = false;                                                         // reset
                 }
@@ -2484 +2470 @@
         | aggregate_key attribute_list_opt TYPEGENname          // unqualified type name
                 {
-                        typedefTable.makeTypedef( *$3, forall || typedefTable.getEnclForall() ? TYPEGENname : TYPEDEFname ); // create typedef
+                        typedefTable.makeTypedef( *$3, forall || typedefTable.getEnclForall() ? TYPEGENname : TYPEDEFname, "aggregate_type: 3" );
                         forall = false;                                                         // reset
                 }
@@ -2505 +2491 @@
         aggregate_key attribute_list_opt identifier
                 {
-                        typedefTable.makeTypedef( *$3, forall || typedefTable.getEnclForall() ? TYPEGENname : TYPEDEFname );
+                        typedefTable.makeTypedef( *$3, forall || typedefTable.getEnclForall() ? TYPEGENname : TYPEDEFname, "aggregate_type_nobody" );
                         forall = false;                                                         // reset
                         $$ = DeclarationNode::newAggregate( $1, $3, nullptr, nullptr, false )->addQualifiers( $2 );
@@ -2680 +2666 @@
         ENUM attribute_list_opt '{' enumerator_list comma_opt '}'
                 { $$ = DeclarationNode::newEnum( nullptr, $4, true, false )->addQualifiers( $2 ); }
+        | ENUM attribute_list_opt '!' '{' enumerator_list comma_opt '}' // invalid syntax rule
+                { SemanticError( yylloc, "syntax error, hiding '!' the enumerator names of an anonymous enumeration means the names are inaccessible." ); $$ = nullptr; }
         | ENUM attribute_list_opt identifier
-                { typedefTable.makeTypedef( *$3 ); }
+                { typedefTable.makeTypedef( *$3, "enum_type 1" ); }
           hide_opt '{' enumerator_list comma_opt '}'
                 { $$ = DeclarationNode::newEnum( $3, $7, true, false, nullptr, $5 )->addQualifiers( $2 ); }
-        | ENUM attribute_list_opt typedef_name                          // unqualified type name
-          hide_opt '{' enumerator_list comma_opt '}'
+        | ENUM attribute_list_opt typedef_name hide_opt '{' enumerator_list comma_opt '}' // unqualified type name
                 { $$ = DeclarationNode::newEnum( $3->name, $6, true, false, nullptr, $4 )->addQualifiers( $2 ); }
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt '{' enumerator_list comma_opt '}'
@@ -2694 +2681 @@
                         $$ = DeclarationNode::newEnum( nullptr, $7, true, true, $3 )->addQualifiers( $5 );
                 }
+        | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt '!' '{' enumerator_list comma_opt '}' // unqualified type name
+                { SemanticError( yylloc, "syntax error, hiding '!' the enumerator names of an anonymous enumeration means the names are inaccessible." ); $$ = nullptr; }
+        | ENUM '(' ')' attribute_list_opt '{' enumerator_list comma_opt '}'
+                {
+                        $$ = DeclarationNode::newEnum( nullptr, $6, true, true )->addQualifiers( $4 );
+                }
+        | ENUM '(' ')' attribute_list_opt '!' '{' enumerator_list comma_opt '}' // invalid syntax rule
+                { SemanticError( yylloc, "syntax error, hiding '!' the enumerator names of an anonymous enumeration means the names are inaccessible." ); $$ = nullptr; }
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt identifier attribute_list_opt
                 {
@@ -2699 +2694 @@
                                 SemanticError( yylloc, "syntax error, storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." );
                         }
-                        typedefTable.makeTypedef( *$6 );
+                        typedefTable.makeTypedef( *$6, "enum_type 2" );
                 }
           hide_opt '{' enumerator_list comma_opt '}'
@@ -2705 +2700 @@
                         $$ = DeclarationNode::newEnum( $6, $11, true, true, $3, $9 )->addQualifiers( $5 )->addQualifiers( $7 );
                 }
-        | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt typedef_name attribute_list_opt
-          hide_opt '{' enumerator_list comma_opt '}'
+        | ENUM '(' ')' attribute_list_opt identifier attribute_list_opt hide_opt '{' enumerator_list comma_opt '}'
+                {
+                        $$ = DeclarationNode::newEnum( $5, $9, true, true, nullptr, $7 )->addQualifiers( $4 )->addQualifiers( $6 );
+                }
+        | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt typedef_name attribute_list_opt hide_opt '{' enumerator_list comma_opt '}'
                 {
                         $$ = DeclarationNode::newEnum( $6->name, $10, true, true, $3, $8 )->addQualifiers( $5 )->addQualifiers( $7 );
+                }
+        | ENUM '(' ')' attribute_list_opt typedef_name attribute_list_opt hide_opt '{' enumerator_list comma_opt '}'
+                {
+                        $$ = DeclarationNode::newEnum( $5->name, $9, true, true, nullptr, $7 )->addQualifiers( $4 )->addQualifiers( $6 );
                 }
         | enum_type_nobody
@@ -2722 +2724 @@
 enum_type_nobody:                                                                               // enum - {...}
         ENUM attribute_list_opt identifier
-                { typedefTable.makeTypedef( *$3 ); $$ = DeclarationNode::newEnum( $3, nullptr, false, false )->addQualifiers( $2 ); }
+                {
+                        typedefTable.makeTypedef( *$3, "enum_type_nobody 1" );
+                        $$ = DeclarationNode::newEnum( $3, nullptr, false, false )->addQualifiers( $2 );
+                }
         | ENUM attribute_list_opt type_name
-                { typedefTable.makeTypedef( *$3->type->symbolic.name ); $$ = DeclarationNode::newEnum( $3->type->symbolic.name, nullptr, false, false )->addQualifiers( $2 ); }
+                {
+                        typedefTable.makeTypedef( *$3->type->symbolic.name, "enum_type_nobody 2" );
+                        $$ = DeclarationNode::newEnum( $3->type->symbolic.name, nullptr, false, false )->addQualifiers( $2 );
+                }
         ;
 
@@ -2792 +2800 @@
                 { $$ = nullptr; }
         | parameter_list
-        | parameter_list pop ',' push ELLIPSIS
+        | parameter_list ',' ELLIPSIS
                 { $$ = $1->addVarArgs(); }
         ;
@@ -2799 +2807 @@
         abstract_parameter_declaration
         | parameter_declaration
-        | parameter_list pop ',' push abstract_parameter_declaration
-                { $$ = $1->appendList( $5 ); }
-        | parameter_list pop ',' push parameter_declaration
-                { $$ = $1->appendList( $5 ); }
+        | parameter_list ',' abstract_parameter_declaration
+                { $$ = $1->appendList( $3 ); }
+        | parameter_list ',' parameter_declaration
+                { $$ = $1->appendList( $3 ); }
         ;
 
@@ -2969 +2977 @@
         type_class identifier_or_type_name
                 {
-                        typedefTable.addToScope( *$2, TYPEDEFname, "9" );
+                        typedefTable.addToScope( *$2, TYPEDEFname, "type_parameter 1" );
                         if ( $1 == ast::TypeDecl::Otype ) { SemanticError( yylloc, "otype keyword is deprecated, use T " ); }
                         if ( $1 == ast::TypeDecl::Dtype ) { SemanticError( yylloc, "dtype keyword is deprecated, use T &" ); }
@@ -2977 +2985 @@
                 { $$ = DeclarationNode::newTypeParam( $1, $2 )->addTypeInitializer( $4 )->addAssertions( $5 ); }
         | identifier_or_type_name new_type_class
-                { typedefTable.addToScope( *$1, TYPEDEFname, "9" ); }
+                { typedefTable.addToScope( *$1, TYPEDEFname, "type_parameter 2" ); }
           type_initializer_opt assertion_list_opt
                 { $$ = DeclarationNode::newTypeParam( $2, $1 )->addTypeInitializer( $4 )->addAssertions( $5 ); }
         | '[' identifier_or_type_name ']'
                 {
-                        typedefTable.addToScope( *$2, TYPEDIMname, "9" );
+                        typedefTable.addToScope( *$2, TYPEDIMname, "type_parameter 3" );
                         $$ = DeclarationNode::newTypeParam( ast::TypeDecl::Dimension, $2 );
                 }
@@ -3064 +3072 @@
         identifier_or_type_name
                 {
-                        typedefTable.addToEnclosingScope( *$1, TYPEDEFname, "10" );
+                        typedefTable.addToEnclosingScope( *$1, TYPEDEFname, "type_declarator_name 1" );
                         $$ = DeclarationNode::newTypeDecl( $1, nullptr );
                 }
         | identifier_or_type_name '(' type_parameter_list ')'
                 {
-                        typedefTable.addToEnclosingScope( *$1, TYPEGENname, "11" );
+                        typedefTable.addToEnclosingScope( *$1, TYPEGENname, "type_declarator_name 2" );
                         $$ = DeclarationNode::newTypeDecl( $1, $3 );
                 }
@@ -3163 +3171 @@
         | IDENTIFIER IDENTIFIER
                 { IdentifierBeforeIdentifier( *$1.str, *$2.str, " declaration" ); $$ = nullptr; }
-        | IDENTIFIER type_qualifier                                                     // invalid syntax rules
+        | IDENTIFIER type_qualifier                                                     // invalid syntax rule
                 { IdentifierBeforeType( *$1.str, "type qualifier" ); $$ = nullptr; }
-        | IDENTIFIER storage_class                                                      // invalid syntax rules
+        | IDENTIFIER storage_class                                                      // invalid syntax rule
                 { IdentifierBeforeType( *$1.str, "storage class" ); $$ = nullptr; }
-        | IDENTIFIER basic_type_name                                            // invalid syntax rules
+        | IDENTIFIER basic_type_name                                            // invalid syntax rule
                 { IdentifierBeforeType( *$1.str, "type" ); $$ = nullptr; }
-        | IDENTIFIER TYPEDEFname                                                        // invalid syntax rules
+        | IDENTIFIER TYPEDEFname                                                        // invalid syntax rule
                 { IdentifierBeforeType( *$1.str, "type" ); $$ = nullptr; }
-        | IDENTIFIER TYPEGENname                                                        // invalid syntax rules
+        | IDENTIFIER TYPEGENname                                                        // invalid syntax rule
                 { IdentifierBeforeType( *$1.str, "type" ); $$ = nullptr; }
         | external_function_definition
@@ -3458 +3466 @@
 
 variable_function:
-        '(' variable_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
-                { $$ = $2->addParamList( $6 ); }
-        | '(' attribute_list variable_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
-                { $$ = $3->addQualifiers( $2 )->addParamList( $7 ); }
+        '(' variable_ptr ')' '(' parameter_type_list_opt ')' // empty parameter list OBSOLESCENT (see 3)
+                { $$ = $2->addParamList( $5 ); }
+        | '(' attribute_list variable_ptr ')' '(' parameter_type_list_opt ')' // empty parameter list OBSOLESCENT (see 3)
+                { $$ = $3->addQualifiers( $2 )->addParamList( $6 ); }
         | '(' variable_function ')'                                                     // redundant parenthesis
                 { $$ = $2; }
@@ -3481 +3489 @@
 
 function_no_ptr:
-        paren_identifier '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
-                { $$ = $1->addParamList( $4 ); }
-        | '(' function_ptr ')' '(' push parameter_type_list_opt pop ')'
-                { $$ = $2->addParamList( $6 ); }
-        | '(' attribute_list function_ptr ')' '(' push parameter_type_list_opt pop ')'
-                { $$ = $3->addQualifiers( $2 )->addParamList( $7 ); }
+        paren_identifier '(' parameter_type_list_opt ')' // empty parameter list OBSOLESCENT (see 3)
+                { $$ = $1->addParamList( $3 ); }
+        | '(' function_ptr ')' '(' parameter_type_list_opt ')'
+                { $$ = $2->addParamList( $5 ); }
+        | '(' attribute_list function_ptr ')' '(' parameter_type_list_opt ')'
+                { $$ = $3->addQualifiers( $2 )->addParamList( $6 ); }
         | '(' function_no_ptr ')'                                                       // redundant parenthesis
                 { $$ = $2; }
@@ -3535 +3543 @@
         paren_identifier '(' identifier_list ')'                        // function_declarator handles empty parameter
                 { $$ = $1->addIdList( $3 ); }
-        | '(' KR_function_ptr ')' '(' push parameter_type_list_opt pop ')'
-                { $$ = $2->addParamList( $6 ); }
-        | '(' attribute_list KR_function_ptr ')' '(' push parameter_type_list_opt pop ')'
-                { $$ = $3->addQualifiers( $2 )->addParamList( $7 ); }
+        | '(' KR_function_ptr ')' '(' parameter_type_list_opt ')'
+                { $$ = $2->addParamList( $5 ); }
+        | '(' attribute_list KR_function_ptr ')' '(' parameter_type_list_opt ')'
+                { $$ = $3->addQualifiers( $2 )->addParamList( $6 ); }
         | '(' KR_function_no_ptr ')'                                            // redundant parenthesis
                 { $$ = $2; }
@@ -3582 +3590 @@
                 {
                         // hide type name in enclosing scope by variable name
-                        typedefTable.addToEnclosingScope( *$1->name, IDENTIFIER, "ID" );
+                        typedefTable.addToEnclosingScope( *$1->name, IDENTIFIER, "paren_type" );
                 }
         | '(' paren_type ')'
@@ -3627 +3635 @@
 
 variable_type_function:
-        '(' variable_type_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
-                { $$ = $2->addParamList( $6 ); }
-        | '(' attribute_list variable_type_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
-                { $$ = $3->addQualifiers( $2 )->addParamList( $7 ); }
+        '(' variable_type_ptr ')' '(' parameter_type_list_opt ')' // empty parameter list OBSOLESCENT (see 3)
+                { $$ = $2->addParamList( $5 ); }
+        | '(' attribute_list variable_type_ptr ')' '(' parameter_type_list_opt ')' // empty parameter list OBSOLESCENT (see 3)
+                { $$ = $3->addQualifiers( $2 )->addParamList( $6 ); }
         | '(' variable_type_function ')'                                        // redundant parenthesis
                 { $$ = $2; }
@@ -3650 +3658 @@
 
 function_type_no_ptr:
-        paren_type '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
-                { $$ = $1->addParamList( $4 ); }
-        | '(' function_type_ptr ')' '(' push parameter_type_list_opt pop ')'
-                { $$ = $2->addParamList( $6 ); }
-        | '(' attribute_list function_type_ptr ')' '(' push parameter_type_list_opt pop ')'
-                { $$ = $3->addQualifiers( $2 )->addParamList( $7 ); }
+        paren_type '(' parameter_type_list_opt ')' // empty parameter list OBSOLESCENT (see 3)
+                { $$ = $1->addParamList( $3 ); }
+        | '(' function_type_ptr ')' '(' parameter_type_list_opt ')'
+                { $$ = $2->addParamList( $5 ); }
+        | '(' attribute_list function_type_ptr ')' '(' parameter_type_list_opt ')'
+                { $$ = $3->addQualifiers( $2 )->addParamList( $6 ); }
         | '(' function_type_no_ptr ')'                                          // redundant parenthesis
                 { $$ = $2; }
@@ -3726 +3734 @@
 
 identifier_parameter_function:
-        paren_identifier '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
-                { $$ = $1->addParamList( $4 ); }
-        | '(' identifier_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
-                { $$ = $2->addParamList( $6 ); }
+        paren_identifier '(' parameter_type_list_opt ')' // empty parameter list OBSOLESCENT (see 3)
+                { $$ = $1->addParamList( $3 ); }
+        | '(' identifier_parameter_ptr ')' '(' parameter_type_list_opt ')' // empty parameter list OBSOLESCENT (see 3)
+                { $$ = $2->addParamList( $5 ); }
         | '(' identifier_parameter_function ')'                         // redundant parenthesis
                 { $$ = $2; }
@@ -3779 +3787 @@
 
 type_parameter_function:
-        typedef_name '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
-                { $$ = $1->addParamList( $4 ); }
-        | '(' type_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
-                { $$ = $2->addParamList( $6 ); }
+        typedef_name '(' parameter_type_list_opt ')' // empty parameter list OBSOLESCENT (see 3)
+                { $$ = $1->addParamList( $3 ); }
+        | '(' type_parameter_ptr ')' '(' parameter_type_list_opt ')' // empty parameter list OBSOLESCENT (see 3)
+                { $$ = $2->addParamList( $5 ); }
         ;
 
@@ -3829 +3837 @@
 
 abstract_function:
-        '(' push parameter_type_list_opt pop ')'                        // empty parameter list OBSOLESCENT (see 3)
-                { $$ = DeclarationNode::newFunction( nullptr, nullptr, $3, nullptr ); }
-        | '(' abstract_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
-                { $$ = $2->addParamList( $6 ); }
+        '(' parameter_type_list_opt ')'                 // empty parameter list OBSOLESCENT (see 3)
+                { $$ = DeclarationNode::newFunction( nullptr, nullptr, $2, nullptr ); }
+        | '(' abstract_ptr ')' '(' parameter_type_list_opt ')' // empty parameter list OBSOLESCENT (see 3)
+                { $$ = $2->addParamList( $5 ); }
         | '(' abstract_function ')'                                                     // redundant parenthesis
                 { $$ = $2; }
@@ -3952 +3960 @@
 
 abstract_parameter_function:
-        '(' push parameter_type_list_opt pop ')'                        // empty parameter list OBSOLESCENT (see 3)
-                { $$ = DeclarationNode::newFunction( nullptr, nullptr, $3, nullptr ); }
-        | '(' abstract_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
-                { $$ = $2->addParamList( $6 ); }
+        '(' parameter_type_list_opt ')'                 // empty parameter list OBSOLESCENT (see 3)
+                { $$ = DeclarationNode::newFunction( nullptr, nullptr, $2, nullptr ); }
+        | '(' abstract_parameter_ptr ')' '(' parameter_type_list_opt ')' // empty parameter list OBSOLESCENT (see 3)
+                { $$ = $2->addParamList( $5 ); }
         | '(' abstract_parameter_function ')'                           // redundant parenthesis
                 { $$ = $2; }
@@ -3992 +4000 @@
 // This pattern parses a declaration of an abstract variable, but does not allow "int ()" for a function pointer.
 //
-//              struct S {
-//          int;
-//          int *;
-//          int [10];
-//          int (*)();
-//      };
+//   struct S {
+//       int;
+//       int *;
+//       int [10];
+//       int (*)();
+//   };
 
 variable_abstract_declarator:
@@ -4031 +4039 @@
 
 variable_abstract_function:
-        '(' variable_abstract_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
-                { $$ = $2->addParamList( $6 ); }
+        '(' variable_abstract_ptr ')' '(' parameter_type_list_opt ')' // empty parameter list OBSOLESCENT (see 3)
+                { $$ = $2->addParamList( $5 ); }
         | '(' variable_abstract_function ')'                            // redundant parenthesis
                 { $$ = $2; }