Index: src/Parser/lex.ll =================================================================== --- src/Parser/lex.ll (revision 24d6572fc571b2a894d56a9335edd57899c448c0) +++ src/Parser/lex.ll (revision 0e0f25d58c9caefe73048b0f2bff78564ae44acf) @@ -10,6 +10,6 @@ * Created On : Sat Sep 22 08:58:10 2001 * Last Modified By : Peter A. Buhr - * Last Modified On : Tue May 2 08:45:21 2023 - * Update Count : 769 + * Last Modified On : Fri Jun 9 10:04:00 2023 + * Update Count : 770 */ @@ -319,4 +319,5 @@ static { KEYWORD_RETURN(STATIC); } _Static_assert { KEYWORD_RETURN(STATICASSERT); } // C11 +_static_assert { KEYWORD_RETURN(STATICASSERT); } // C23 struct { KEYWORD_RETURN(STRUCT); } suspend { KEYWORD_RETURN(SUSPEND); } // CFA Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision 24d6572fc571b2a894d56a9335edd57899c448c0) +++ src/Parser/parser.yy (revision 0e0f25d58c9caefe73048b0f2bff78564ae44acf) @@ -10,6 +10,6 @@ // Created On : Sat Sep 1 20:22:55 2001 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Apr 26 16:45:37 2023 -// Update Count : 6330 +// Last Modified On : Wed Jun 7 14:32:28 2023 +// Update Count : 6341 // @@ -108,9 +108,9 @@ assert( declList ); // printf( "distAttr1 typeSpec %p\n", typeSpec ); typeSpec->print( std::cout ); - DeclarationNode * cur = declList, * cl = (new DeclarationNode)->addType( typeSpec ); + DeclarationNode * cl = (new DeclarationNode)->addType( typeSpec ); // printf( "distAttr2 cl %p\n", cl ); cl->type->print( std::cout ); // cl->type->aggregate.name = cl->type->aggInst.aggregate->aggregate.name; - for ( cur = dynamic_cast( cur->get_next() ); cur != nullptr; cur = dynamic_cast( cur->get_next() ) ) { + for ( DeclarationNode * cur = dynamic_cast( declList->get_next() ); cur != nullptr; cur = dynamic_cast( cur->get_next() ) ) { cl->cloneBaseType( cur ); } // for @@ -206,7 +206,7 @@ #define NEW_ONE new ExpressionNode( build_constantInteger( yylloc, *new string( "1" ) ) ) #define UPDOWN( compop, left, right ) (compop == OperKinds::LThan || compop == OperKinds::LEThan ? left : right) -#define MISSING_ANON_FIELD "Missing loop fields with an anonymous loop index is meaningless as loop index is unavailable in loop body." -#define MISSING_LOW "Missing low value for up-to range so index is uninitialized." -#define MISSING_HIGH "Missing high value for down-to range so index is uninitialized." +#define MISSING_ANON_FIELD "syntax error, missing loop fields with an anonymous loop index is meaningless as loop index is unavailable in loop body." +#define MISSING_LOW "syntax error, missing low value for up-to range so index is uninitialized." +#define MISSING_HIGH "syntax error, missing high value for down-to range so index is uninitialized." static ForCtrl * makeForCtrl( @@ -232,8 +232,8 @@ ForCtrl * forCtrl( const CodeLocation & location, DeclarationNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) { if ( index->initializer ) { - SemanticError( yylloc, "Direct initialization disallowed. Use instead: type var; initialization ~ comparison ~ increment." ); + SemanticError( yylloc, "syntax error, direct initialization disallowed. Use instead: type var; initialization ~ comparison ~ increment." ); } // if if ( index->next ) { - SemanticError( yylloc, "Multiple loop indexes disallowed in for-loop declaration." ); + SemanticError( yylloc, "syntax error, multiple loop indexes disallowed in for-loop declaration." ); } // if DeclarationNode * initDecl = index->addInitializer( new InitializerNode( start ) ); @@ -260,18 +260,18 @@ return forCtrl( location, type, new string( identifier->name ), start, compop, comp, inc ); } else { - SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed." ); return nullptr; + SemanticError( yylloc, "syntax error, loop-index name missing. Expression disallowed." ); return nullptr; } // if } else { - SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed." ); return nullptr; + SemanticError( yylloc, "syntax error, loop-index name missing. Expression disallowed. ." ); return nullptr; } // if } // forCtrl static void IdentifierBeforeIdentifier( string & identifier1, string & identifier2, const char * kind ) { - SemanticError( yylloc, ::toString( "Adjacent identifiers \"", identifier1, "\" and \"", identifier2, "\" are not meaningful in a", kind, ".\n" + SemanticError( yylloc, ::toString( "syntax error, adjacent identifiers \"", identifier1, "\" and \"", identifier2, "\" are not meaningful in a", kind, ".\n" "Possible cause is misspelled type name or missing generic parameter." ) ); } // IdentifierBeforeIdentifier static void IdentifierBeforeType( string & identifier, const char * kind ) { - SemanticError( yylloc, ::toString( "Identifier \"", identifier, "\" cannot appear before a ", kind, ".\n" + SemanticError( yylloc, ::toString( "syntax error, identifier \"", identifier, "\" cannot appear before a ", kind, ".\n" "Possible cause is misspelled storage/CV qualifier, misspelled typename, or missing generic parameter." ) ); } // IdentifierBeforeType @@ -689,15 +689,15 @@ // | RESUME '(' comma_expression ')' compound_statement // { SemanticError( yylloc, "Resume expression is currently unimplemented." ); $$ = nullptr; } - | IDENTIFIER IDENTIFIER // syntax error + | IDENTIFIER IDENTIFIER // invalid syntax rules { IdentifierBeforeIdentifier( *$1.str, *$2.str, "n expression" ); $$ = nullptr; } - | IDENTIFIER type_qualifier // syntax error + | IDENTIFIER type_qualifier // invalid syntax rules { IdentifierBeforeType( *$1.str, "type qualifier" ); $$ = nullptr; } - | IDENTIFIER storage_class // syntax error + | IDENTIFIER storage_class // invalid syntax rules { IdentifierBeforeType( *$1.str, "storage class" ); $$ = nullptr; } - | IDENTIFIER basic_type_name // syntax error + | IDENTIFIER basic_type_name // invalid syntax rules { IdentifierBeforeType( *$1.str, "type" ); $$ = nullptr; } - | IDENTIFIER TYPEDEFname // syntax error + | IDENTIFIER TYPEDEFname // invalid syntax rules { IdentifierBeforeType( *$1.str, "type" ); $$ = nullptr; } - | IDENTIFIER TYPEGENname // syntax error + | IDENTIFIER TYPEGENname // invalid syntax rules { IdentifierBeforeType( *$1.str, "type" ); $$ = nullptr; } ; @@ -1152,7 +1152,7 @@ identifier_or_type_name ':' attribute_list_opt statement { $$ = $4->add_label( yylloc, $1, $3 ); } - | identifier_or_type_name ':' attribute_list_opt error // syntax error - { - SemanticError( yylloc, ::toString( "Label \"", *$1.str, "\" must be associated with a statement, " + | identifier_or_type_name ':' attribute_list_opt error // invalid syntax rule + { + SemanticError( yylloc, ::toString( "syntx error, label \"", *$1.str, "\" must be associated with a statement, " "where a declaration, case, or default is not a statement. " "Move the label or terminate with a semi-colon." ) ); @@ -1193,6 +1193,6 @@ | statement_list_nodecl statement { assert( $1 ); $1->set_last( $2 ); $$ = $1; } - | statement_list_nodecl error // syntax error - { SemanticError( yylloc, "Declarations only allowed at the start of the switch body, i.e., after the '{'." ); $$ = nullptr; } + | statement_list_nodecl error // invalid syntax rule + { SemanticError( yylloc, "syntax error, declarations only allowed at the start of the switch body, i.e., after the '{'." ); $$ = nullptr; } ; @@ -1219,6 +1219,6 @@ $$ = $7 ? new StatementNode( build_compound( yylloc, (StatementNode *)((new StatementNode( $7 ))->set_last( sw )) ) ) : sw; } - | SWITCH '(' comma_expression ')' '{' error '}' // CFA, syntax error - { SemanticError( yylloc, "Only declarations can appear before the list of case clauses." ); $$ = nullptr; } + | SWITCH '(' comma_expression ')' '{' error '}' // CFA, invalid syntax rule error + { SemanticError( yylloc, "synatx error, declarations can only appear before the list of case clauses." ); $$ = nullptr; } | CHOOSE '(' comma_expression ')' case_clause // CFA { $$ = new StatementNode( build_switch( yylloc, false, $3, $5 ) ); } @@ -1228,6 +1228,6 @@ $$ = $7 ? new StatementNode( build_compound( yylloc, (StatementNode *)((new StatementNode( $7 ))->set_last( sw )) ) ) : sw; } - | CHOOSE '(' comma_expression ')' '{' error '}' // CFA, syntax error - { SemanticError( yylloc, "Only declarations can appear before the list of case clauses." ); $$ = nullptr; } + | CHOOSE '(' comma_expression ')' '{' error '}' // CFA, invalid syntax rule + { SemanticError( yylloc, "syntax error, declarations can only appear before the list of case clauses." ); $$ = nullptr; } ; @@ -1268,13 +1268,13 @@ case_label: // CFA - CASE error // syntax error - { SemanticError( yylloc, "Missing case list after case." ); $$ = nullptr; } + CASE error // invalid syntax rule + { SemanticError( yylloc, "syntax error, case list missing after case." ); $$ = nullptr; } | CASE case_value_list ':' { $$ = $2; } - | CASE case_value_list error // syntax error - { SemanticError( yylloc, "Missing colon after case list." ); $$ = nullptr; } + | CASE case_value_list error // invalid syntax rule + { SemanticError( yylloc, "syntax error, colon missing after case list." ); $$ = nullptr; } | DEFAULT ':' { $$ = new ClauseNode( build_default( yylloc ) ); } // A semantic check is required to ensure only one default clause per switch/choose statement. - | DEFAULT error // syntax error - { SemanticError( yylloc, "Missing colon after default." ); $$ = nullptr; } + | DEFAULT error // invalid syntax rules + { 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, error + | comma_expression updowneq comma_expression '~' '@' // CFA, invalid syntax rules { SemanticError( yylloc, MISSING_ANON_FIELD ); $$ = nullptr; } - | '@' updowneq '@' // CFA, error + | '@' updowneq '@' // CFA, invalid syntax rules { SemanticError( yylloc, MISSING_ANON_FIELD ); $$ = nullptr; } - | '@' updowneq comma_expression '~' '@' // CFA, error + | '@' updowneq comma_expression '~' '@' // CFA, invalid syntax rules { SemanticError( yylloc, MISSING_ANON_FIELD ); $$ = nullptr; } - | comma_expression updowneq '@' '~' '@' // CFA, error + | comma_expression updowneq '@' '~' '@' // CFA, invalid syntax rules { SemanticError( yylloc, MISSING_ANON_FIELD ); $$ = nullptr; } - | '@' updowneq '@' '~' '@' // CFA, error + | '@' updowneq '@' '~' '@' // CFA, invalid syntax rules { SemanticError( yylloc, MISSING_ANON_FIELD ); $$ = nullptr; } @@ -1431,13 +1431,13 @@ { if ( $4 == OperKinds::GThan || $4 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; } - else if ( $4 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; } + else if ( $4 == OperKinds::LEThan ) { SemanticError( yylloc, "syntax error, equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; } else $$ = forCtrl( yylloc, $3, $1, $3->clone(), $4, nullptr, NEW_ONE ); } - | comma_expression ';' '@' updowneq '@' // CFA, error - { SemanticError( yylloc, "Missing low/high value for up/down-to range so index is uninitialized." ); $$ = nullptr; } + | comma_expression ';' '@' updowneq '@' // CFA, invalid syntax rules + { 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, error + | comma_expression ';' '@' updowneq comma_expression '~' comma_expression // CFA, invalid syntax rules { if ( $4 == OperKinds::LThan || $4 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; } @@ -1447,10 +1447,10 @@ { if ( $4 == OperKinds::GThan || $4 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; } - else if ( $4 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; } + else if ( $4 == OperKinds::LEThan ) { SemanticError( yylloc, "syntax error, equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; } else $$ = forCtrl( yylloc, $3, $1, $3->clone(), $4, nullptr, $7 ); } | 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, error + | comma_expression ';' '@' updowneq comma_expression '~' '@' // CFA, invalid syntax rules { if ( $4 == OperKinds::LThan || $4 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; } @@ -1460,9 +1460,9 @@ { if ( $4 == OperKinds::GThan || $4 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; } - else if ( $4 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; } + else if ( $4 == OperKinds::LEThan ) { SemanticError( yylloc, "syntax error, equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; } else $$ = forCtrl( yylloc, $3, $1, $3->clone(), $4, nullptr, nullptr ); } | comma_expression ';' '@' updowneq '@' '~' '@' // CFA - { SemanticError( yylloc, "Missing low/high value for up/down-to range so index is uninitialized." ); $$ = nullptr; } + { SemanticError( yylloc, "syntax error, missing low/high value for up/down-to range so index is uninitialized." ); $$ = nullptr; } | declaration comma_expression // CFA @@ -1481,5 +1481,5 @@ { if ( $3 == OperKinds::GThan || $3 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; } - else if ( $3 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; } + else if ( $3 == OperKinds::LEThan ) { SemanticError( yylloc, "syntax error, equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; } else $$ = forCtrl( yylloc, $1, $2, $3, nullptr, NEW_ONE ); } @@ -1495,5 +1495,5 @@ { if ( $3 == OperKinds::GThan || $3 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; } - else if ( $3 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; } + else if ( $3 == OperKinds::LEThan ) { SemanticError( yylloc, "syntax error, equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; } else $$ = forCtrl( yylloc, $1, $2, $3, nullptr, $6 ); } @@ -1508,9 +1508,9 @@ { if ( $3 == OperKinds::GThan || $3 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; } - else if ( $3 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; } + else if ( $3 == OperKinds::LEThan ) { SemanticError( yylloc, "syntax error, equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; } else $$ = forCtrl( yylloc, $1, $2, $3, nullptr, nullptr ); } - | declaration '@' updowneq '@' '~' '@' // CFA, error - { SemanticError( yylloc, "Missing low/high value for up/down-to range so index is uninitialized." ); $$ = nullptr; } + | declaration '@' updowneq '@' '~' '@' // CFA, invalid syntax rules + { SemanticError( yylloc, "syntax error, missing low/high value for up/down-to range so index is uninitialized." ); $$ = nullptr; } | comma_expression ';' TYPEDEFname // CFA, array type @@ -1521,5 +1521,7 @@ | comma_expression ';' downupdowneq TYPEDEFname // CFA, array type { - if ( $3 == OperKinds::LEThan || $3 == OperKinds::GEThan ) { SemanticError( yylloc, "All enumation ranges are equal (all values). Remove \"=~\"." ); $$ = nullptr; } + if ( $3 == OperKinds::LEThan || $3 == OperKinds::GEThan ) { + SemanticError( yylloc, "syntax error, all enumeration ranges are equal (all values). Remove \"=~\"." ); $$ = nullptr; + } SemanticError( yylloc, "Type iterator is currently unimplemented." ); $$ = nullptr; } @@ -1616,5 +1618,5 @@ MUTEX '(' argument_expression_list_opt ')' statement { - if ( ! $3 ) { SemanticError( yylloc, "mutex argument list cannot be empty." ); $$ = nullptr; } + if ( ! $3 ) { SemanticError( yylloc, "syntax error, mutex argument list cannot be empty." ); $$ = nullptr; } $$ = new StatementNode( build_mutex( yylloc, $3, $5 ) ); } @@ -1664,6 +1666,6 @@ { $$ = 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 // syntax error - { SemanticError( yylloc, "else clause must be conditional after timeout or timeout never triggered." ); $$ = nullptr; } + | wor_waitfor_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_waitfor_clause wor when_clause_opt timeout statement wor when_clause ELSE statement { $$ = build_waitfor_else( yylloc, build_waitfor_timeout( yylloc, $1, $3, $4, maybe_build_compound( yylloc, $5 ) ), $7, maybe_build_compound( yylloc, $9 ) ); } @@ -1709,6 +1711,6 @@ { $$ = 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 // syntax error - { SemanticError( yylloc, "else clause must be conditional after timeout or timeout never triggered." ); $$ = nullptr; } + | 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, @@ -2065,9 +2067,9 @@ assert( $1->type ); if ( $1->type->qualifiers.any() ) { // CV qualifiers ? - SemanticError( yylloc, "Useless type qualifier(s) in empty declaration." ); $$ = nullptr; + SemanticError( yylloc, "syntax error, useless type qualifier(s) in empty declaration." ); $$ = nullptr; } // enums are never empty declarations because there must have at least one enumeration. if ( $1->type->kind == TypeData::AggregateInst && $1->storageClasses.any() ) { // storage class ? - SemanticError( yylloc, "Useless storage qualifier(s) in empty aggregate declaration." ); $$ = nullptr; + SemanticError( yylloc, "syntax error, useless storage qualifier(s) in empty aggregate declaration." ); $$ = nullptr; } } @@ -2100,9 +2102,9 @@ | type_declaration_specifier | sue_declaration_specifier - | sue_declaration_specifier invalid_types - { - SemanticError( yylloc, ::toString( "Missing ';' after end of ", + | sue_declaration_specifier invalid_types // invalid syntax rule + { + SemanticError( yylloc, ::toString( "syntax error, expecting ';' at end of ", $1->type->enumeration.name ? "enum" : ast::AggregateDecl::aggrString( $1->type->aggregate.kind ), - " declaration" ) ); + " declaration." ) ); $$ = nullptr; } @@ -2584,4 +2586,9 @@ // } // for } + | type_specifier field_declaring_list_opt '}' // invalid syntax rule + { + SemanticError( yylloc, ::toString( "syntax error, expecting ';' at end of previous declaration." ) ); + $$ = nullptr; + } | EXTENSION type_specifier field_declaring_list_opt ';' // GCC { $$ = fieldDecl( $2, $3 ); distExt( $$ ); } @@ -2682,7 +2689,7 @@ | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt '{' enumerator_list comma_opt '}' { - if ( $3->storageClasses.val != 0 || $3->type->qualifiers.any() ) - { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); } - + if ( $3->storageClasses.val != 0 || $3->type->qualifiers.any() ) { + SemanticError( yylloc, "syntax error, storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); + } $$ = DeclarationNode::newEnum( nullptr, $7, true, true, $3 )->addQualifiers( $5 ); } @@ -2693,5 +2700,7 @@ | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt identifier attribute_list_opt { - if ( $3->storageClasses.any() || $3->type->qualifiers.val != 0 ) { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); } + if ( $3->storageClasses.any() || $3->type->qualifiers.val != 0 ) { + SemanticError( yylloc, "syntax error, storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); + } typedefTable.makeTypedef( *$6 ); } @@ -3166,13 +3175,13 @@ | IDENTIFIER IDENTIFIER { IdentifierBeforeIdentifier( *$1.str, *$2.str, " declaration" ); $$ = nullptr; } - | IDENTIFIER type_qualifier // syntax error + | IDENTIFIER type_qualifier // invalid syntax rules { IdentifierBeforeType( *$1.str, "type qualifier" ); $$ = nullptr; } - | IDENTIFIER storage_class // syntax error + | IDENTIFIER storage_class // invalid syntax rules { IdentifierBeforeType( *$1.str, "storage class" ); $$ = nullptr; } - | IDENTIFIER basic_type_name // syntax error + | IDENTIFIER basic_type_name // invalid syntax rules { IdentifierBeforeType( *$1.str, "type" ); $$ = nullptr; } - | IDENTIFIER TYPEDEFname // syntax error + | IDENTIFIER TYPEDEFname // invalid syntax rules { IdentifierBeforeType( *$1.str, "type" ); $$ = nullptr; } - | IDENTIFIER TYPEGENname // syntax error + | IDENTIFIER TYPEGENname // invalid syntax rules { IdentifierBeforeType( *$1.str, "type" ); $$ = nullptr; } | external_function_definition @@ -3209,5 +3218,7 @@ | type_qualifier_list { - if ( $1->type->qualifiers.any() ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); } + if ( $1->type->qualifiers.any() ) { + SemanticError( yylloc, "syntax error, CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); + } if ( $1->type->forall ) forall = true; // remember generic type } @@ -3220,5 +3231,7 @@ | declaration_qualifier_list { - if ( $1->type && $1->type->qualifiers.any() ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); } + if ( $1->type && $1->type->qualifiers.any() ) { + SemanticError( yylloc, "syntax error, CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); + } if ( $1->type && $1->type->forall ) forall = true; // remember generic type } @@ -3231,5 +3244,7 @@ | declaration_qualifier_list type_qualifier_list { - if ( ($1->type && $1->type->qualifiers.any()) || ($2->type && $2->type->qualifiers.any()) ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); } + if ( ($1->type && $1->type->qualifiers.any()) || ($2->type && $2->type->qualifiers.any()) ) { + SemanticError( yylloc, "syntax error, CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); + } if ( ($1->type && $1->type->forall) || ($2->type && $2->type->forall) ) forall = true; // remember generic type } @@ -3262,5 +3277,5 @@ $$ = $3; forall = false; if ( $5 ) { - SemanticError( yylloc, "Attributes cannot be associated with function body. Move attribute(s) before \"with\" clause." ); + SemanticError( yylloc, "syntax error, attributes cannot be associated with function body. Move attribute(s) before \"with\" clause." ); $$ = nullptr; } // if