Index: src/Parser/StatementNode.cc =================================================================== --- src/Parser/StatementNode.cc (revision 923558834ec63344a407046c8e08622d03055144) +++ src/Parser/StatementNode.cc (revision 950c58e5affa0dfadc94439fbe02b463ccdfaa3a) @@ -10,7 +10,7 @@ // 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,90 +361,82 @@ 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 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 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; } Index: src/Parser/StatementNode.h =================================================================== --- src/Parser/StatementNode.h (revision 923558834ec63344a407046c8e08622d03055144) +++ src/Parser/StatementNode.h (revision 950c58e5affa0dfadc94439fbe02b463ccdfaa3a) @@ -9,7 +9,7 @@ // 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,5 +102,4 @@ 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 ); Index: src/Parser/TypedefTable.cc =================================================================== --- src/Parser/TypedefTable.cc (revision 923558834ec63344a407046c8e08622d03055144) +++ src/Parser/TypedefTable.cc (revision 950c58e5affa0dfadc94439fbe02b463ccdfaa3a) @@ -10,6 +10,6 @@ // 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,13 +17,13 @@ #include "TypedefTable.h" -#include // for assert -#include // for string -#include // for iostream +#include // for assert +#include // for string +#include // 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,5 +72,5 @@ // "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,4 +80,5 @@ // 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,11 +86,12 @@ } // 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,5 +100,5 @@ 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 Index: src/Parser/TypedefTable.h =================================================================== --- src/Parser/TypedefTable.h (revision 923558834ec63344a407046c8e08622d03055144) +++ src/Parser/TypedefTable.h (revision 950c58e5affa0dfadc94439fbe02b463ccdfaa3a) @@ -10,6 +10,6 @@ // 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,5 +21,8 @@ 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,6 +34,6 @@ 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 * ); Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision 923558834ec63344a407046c8e08622d03055144) +++ src/Parser/parser.yy (revision 950c58e5affa0dfadc94439fbe02b463ccdfaa3a) @@ -10,6 +10,6 @@ // 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,24 +385,24 @@ %type string_literal_list -%type hide_opt visible_hide_opt +%type hide_opt visible_hide_opt // expressions %type constant -%type tuple tuple_expression_list +%type tuple tuple_expression_list %type ptrref_operator unary_operator assignment_operator simple_assignment_operator compound_assignment_operator %type primary_expression postfix_expression unary_expression -%type cast_expression_list cast_expression exponential_expression multiplicative_expression additive_expression -%type shift_expression relational_expression equality_expression +%type cast_expression_list cast_expression exponential_expression multiplicative_expression additive_expression +%type shift_expression relational_expression equality_expression %type AND_expression exclusive_OR_expression inclusive_OR_expression %type logical_AND_expression logical_OR_expression %type conditional_expression constant_expression assignment_expression assignment_expression_opt -%type comma_expression comma_expression_opt -%type argument_expression_list_opt argument_expression_list argument_expression default_initializer_opt +%type comma_expression comma_expression_opt +%type argument_expression_list_opt argument_expression_list argument_expression default_initializer_opt %type conditional_declaration -%type for_control_expression for_control_expression_list +%type for_control_expression for_control_expression_list %type upupeq updown updowneq downupdowneq %type subrange %type asm_name_opt -%type asm_operands_opt asm_operands_list asm_operand +%type asm_operands_opt asm_operands_list asm_operand %type label_list %type asm_clobbers_list_opt @@ -412,12 +412,12 @@ // statements -%type statement labeled_statement compound_statement +%type statement labeled_statement compound_statement %type statement_decl statement_decl_list statement_list_nodecl %type selection_statement if_statement -%type switch_clause_list_opt switch_clause_list +%type switch_clause_list_opt switch_clause_list %type case_value -%type case_clause case_value_list case_label case_label_list +%type case_clause case_value_list case_label case_label_list %type iteration_statement jump_statement -%type expression_statement asm_statement +%type expression_statement asm_statement %type with_statement %type with_clause_opt @@ -427,5 +427,5 @@ %type mutex_statement %type when_clause when_clause_opt waitfor waituntil timeout -%type waitfor_statement waituntil_statement +%type waitfor_statement waituntil_statement %type wor_waitfor_clause %type waituntil_clause wand_waituntil_clause wor_waituntil_clause @@ -601,5 +601,5 @@ // around the list separator. // -// int f( forall(T) T (*f1) T , forall( S ) S (*f2)( S ) ); +// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX // push pop push pop @@ -689,15 +689,15 @@ // | 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,5 +1275,5 @@ | 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,13 +1405,13 @@ 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,10 +1434,10 @@ 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,5 +1452,5 @@ | 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,5 +1511,5 @@ 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,5 +1666,5 @@ { $$ = 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,23 +1708,9 @@ | 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,8 +1854,8 @@ 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,15 +1993,15 @@ 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,13 +2014,13 @@ 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,5 +2038,5 @@ 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,5 +2451,5 @@ | 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,5 +2460,5 @@ | 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,5 +2470,5 @@ | 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,5 +2491,5 @@ 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,10 +2666,11 @@ 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,4 +2681,12 @@ $$ = 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,5 +2694,5 @@ 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,8 +2700,15 @@ $$ = 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,7 +2724,13 @@ 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,5 +2800,5 @@ { $$ = nullptr; } | parameter_list - | parameter_list pop ',' push ELLIPSIS + | parameter_list ',' ELLIPSIS { $$ = $1->addVarArgs(); } ; @@ -2799,8 +2807,8 @@ 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,5 +2977,5 @@ 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,10 +2985,10 @@ { $$ = 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,10 +3072,10 @@ 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,13 +3171,13 @@ | 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,8 +3466,8 @@ 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,10 +3489,10 @@ 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,8 +3543,8 @@ 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,5 +3590,5 @@ { // 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,8 +3635,8 @@ 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,10 +3658,10 @@ 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,8 +3734,8 @@ 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,8 +3787,8 @@ 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,8 +3837,8 @@ 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,8 +3960,8 @@ 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,10 +4000,10 @@ // 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,6 +4039,6 @@ 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; }