Index: translator/Parser/DeclarationNode.cc =================================================================== --- translator/Parser/DeclarationNode.cc (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) +++ translator/Parser/DeclarationNode.cc (revision 4bf529812249ca5fe41f98e56debf210638aa7e9) @@ -50,7 +50,7 @@ const char *storageClassName[] = { // order must correspond with DeclarationNode::StorageClass + "extern", "static", "auto", - "extern", "register", "inline", @@ -880,9 +880,9 @@ Declaration::StorageClass DeclarationNode::buildStorageClass() const { static const Declaration::StorageClass scMap[] = { + Declaration::Extern, Declaration::Static, Declaration::Auto, - Declaration::Extern, Declaration::Register, - Declaration::NoStorageClass, // inline + Declaration::Inline, Declaration::Fortran }; Index: translator/Parser/ParseNode.h =================================================================== --- translator/Parser/ParseNode.h (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) +++ translator/Parser/ParseNode.h (revision 4bf529812249ca5fe41f98e56debf210638aa7e9) @@ -262,6 +262,6 @@ class DeclarationNode : public ParseNode { public: - enum Qualifier { Const, Restrict, Volatile, Lvalue, Atomic }; - enum StorageClass { Static, Auto, Extern, Register, Inline, Fortran }; + enum Qualifier { Const, Restrict, Volatile, Lvalue, Atomic, Attribute }; + enum StorageClass { Extern, Static, Auto, Register, Inline, Fortran }; enum BasicType { Char, Int, Float, Double, Void, Bool, Complex, Imaginary }; enum Modifier { Signed, Unsigned, Short, Long }; Index: translator/Parser/TypeData.cc =================================================================== --- translator/Parser/TypeData.cc (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) +++ translator/Parser/TypeData.cc (revision 4bf529812249ca5fe41f98e56debf210638aa7e9) @@ -544,4 +544,7 @@ case DeclarationNode::Atomic: q.isAtomic = true; + break; + case DeclarationNode::Attribute: + q.isAttribute = true; break; } Index: translator/Parser/cfa.y =================================================================== --- translator/Parser/cfa.y (revision bdd516a5257cb93cc0c5b4a4c343cc112252022a) +++ translator/Parser/cfa.y (revision 4bf529812249ca5fe41f98e56debf210638aa7e9) @@ -1,49 +1,46 @@ -/* -*- Mode: C -*- - * - * CForall Grammar Version 1.0, Copyright (C) Peter A. Buhr 2001 -- Permission is granted to copy this - * grammar and to use it within software systems. THIS GRAMMAR IS PROVIDED "AS IS" AND WITHOUT - * ANY EXPRESS OR IMPLIED WARRANTIES. - * - * cfa.y -- - * - * Author : Peter A. Buhr - * Created On : Sat Sep 1 20:22:55 2001 - * Last Modified By : Peter A. Buhr - * Last Modified On : Wed Apr 15 15:11:16 2015 - * Update Count : 913 - */ - -/* This grammar is based on the ANSI99/11 C grammar, specifically parts of EXPRESSION and STATEMENTS, and on - the C grammar by James A. Roskind, specifically parts of DECLARATIONS and EXTERNAL DEFINITIONS. While - parts have been copied, important changes have been made in all sections; these changes are sufficient to - constitute a new grammar. In particular, this grammar attempts to be more syntactically precise, i.e., it - parses less incorrect language syntax that must be subsequently rejected by semantic checks. Nevertheless, - there are still several semantic checks required and many are noted in the grammar. Finally, the grammar is - extended with GCC and CFA language extensions. */ - -/* Acknowledgments to Richard Bilson, Glen Ditchfield, and Rodolfo Gabriel Esteves who all helped when I got - stuck with the grammar. */ - -/* The root language for this grammar is ANSI99/11 C. All of ANSI99/11 is parsed, except for: - - 1. designation with '=' (use ':' instead) - - Most of the syntactic extensions from ANSI90 to ANSI11 C are marked with the comment "C99/C11". This grammar - also has two levels of extensions. The first extensions cover most of the GCC C extensions, except for: - - 1. nested functions - 2. generalized lvalues - 3. designation with and without '=' (use ':' instead) - 4. attributes not allowed in parenthesis of declarator - - All of the syntactic extensions for GCC C are marked with the comment "GCC". The second extensions are for - Cforall (CFA), which fixes several of C's outstanding problems and extends C with many modern language - concepts. All of the syntactic extensions for CFA C are marked with the comment "CFA". As noted above, - there is one unreconcileable parsing problem between C99 and CFA with respect to designators; this is - discussed in detail before the "designation" grammar rule. */ +// -*- Mode: C++ -*- +// +// CForall Grammar Version 1.0, Copyright (C) Peter A. Buhr 2001 +// +// cfa.y -- +// +// Author : Peter A. Buhr +// Created On : Sat Sep 1 20:22:55 2001 +// Last Modified By : Peter A. Buhr +// Last Modified On : Tue May 12 17:24:53 2015 +// Update Count : 963 +// + +// This grammar is based on the ANSI99/11 C grammar, specifically parts of EXPRESSION and STATEMENTS, and on the C +// grammar by James A. Roskind, specifically parts of DECLARATIONS and EXTERNAL DEFINITIONS. While parts have been +// copied, important changes have been made in all sections; these changes are sufficient to constitute a new grammar. +// In particular, this grammar attempts to be more syntactically precise, i.e., it parses less incorrect language syntax +// that must be subsequently rejected by semantic checks. Nevertheless, there are still several semantic checks +// required and many are noted in the grammar. Finally, the grammar is extended with GCC and CFA language extensions. + +// Acknowledgments to Richard Bilson, Glen Ditchfield, and Rodolfo Gabriel Esteves who all helped when I got stuck with +// the grammar. + +// The root language for this grammar is ANSI99/11 C. All of ANSI99/11 is parsed, except for: +// +// 1. designation with '=' (use ':' instead) +// +// Most of the syntactic extensions from ANSI90 to ANSI11 C are marked with the comment "C99/C11". This grammar also has +// two levels of extensions. The first extensions cover most of the GCC C extensions, except for: +// +// 1. nested functions +// 2. generalized lvalues +// 3. designation with and without '=' (use ':' instead) +// 4. attributes not allowed in parenthesis of declarator +// +// All of the syntactic extensions for GCC C are marked with the comment "GCC". The second extensions are for Cforall +// (CFA), which fixes several of C's outstanding problems and extends C with many modern language concepts. All of the +// syntactic extensions for CFA C are marked with the comment "CFA". As noted above, there is one unreconcileable +// parsing problem between C99 and CFA with respect to designators; this is discussed in detail before the "designation" +// grammar rule. %{ -#define YYDEBUG_LEXER_TEXT (yylval) /* lexer loads this up each time */ -#define YYDEBUG 1 /* get the pretty debugging code to compile*/ +#define YYDEBUG_LEXER_TEXT (yylval) // lexer loads this up each time +#define YYDEBUG 1 // get the pretty debugging code to compile #undef __GNUC_MINOR__ @@ -56,5 +53,5 @@ #include "LinkageSpec.h" -DeclarationNode *theTree = 0; /* the resulting parse tree */ +DeclarationNode *theTree = 0; // the resulting parse tree LinkageSpec::Type linkage = LinkageSpec::Cforall; std::stack< LinkageSpec::Type > linkageStack; @@ -62,33 +59,33 @@ %} -/************************* TERMINAL TOKENS ********************************/ - -/* keywords */ +//************************* TERMINAL TOKENS ******************************** + +// keywords %token TYPEDEF %token AUTO EXTERN REGISTER STATIC -%token INLINE /* C99 */ -%token FORTRAN /* C99, extension ISO/IEC 9899:1999 Section J.5.9(1) */ +%token INLINE // C99 +%token FORTRAN // C99, extension ISO/IEC 9899:1999 Section J.5.9(1) %token CONST VOLATILE -%token RESTRICT /* C99 */ -%token FORALL LVALUE /* CFA */ +%token RESTRICT // C99 +%token FORALL LVALUE // CFA %token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED -%token BOOL COMPLEX IMAGINARY /* C99 */ -%token TYPEOF LABEL /* GCC */ +%token BOOL COMPLEX IMAGINARY // C99 +%token TYPEOF LABEL // GCC %token ENUM STRUCT UNION -%token TYPE FTYPE DTYPE CONTEXT /* CFA */ +%token TYPE FTYPE DTYPE CONTEXT // CFA %token SIZEOF -%token ATTRIBUTE EXTENSION /* GCC */ +%token ATTRIBUTE EXTENSION // GCC %token IF ELSE SWITCH CASE DEFAULT DO WHILE FOR BREAK CONTINUE GOTO RETURN -%token CHOOSE FALLTHRU TRY CATCH FINALLY THROW /* CFA */ -%token ASM /* C99, extension ISO/IEC 9899:1999 Section J.5.10(1) */ -%token ALIGNAS ALIGNOF ATOMIC GENERIC NORETURN STATICASSERT THREADLOCAL /* C11 */ - -/* names and constants: lexer differentiates between identifier and typedef names */ +%token CHOOSE FALLTHRU TRY CATCH FINALLY THROW // CFA +%token ASM // C99, extension ISO/IEC 9899:1999 Section J.5.10(1) +%token ALIGNAS ALIGNOF ATOMIC GENERIC NORETURN STATICASSERT THREADLOCAL // C11 + +// names and constants: lexer differentiates between identifier and typedef names %token IDENTIFIER QUOTED_IDENTIFIER TYPEDEFname TYPEGENname %token ATTR_IDENTIFIER ATTR_TYPEDEFname ATTR_TYPEGENname %token INTEGERconstant FLOATINGconstant CHARACTERconstant STRINGliteral -%token ZERO ONE /* CFA */ - -/* multi-character operators */ +%token ZERO ONE // CFA + +// multi-character operators %token ARROW /* -> */ %token ICR DECR /* ++ -- */ @@ -103,16 +100,16 @@ %token ANDassign ERassign ORassign /* &= ^= |= */ -/* Types declaration */ +// Types declaration %union { - Token tok; - ParseNode *pn; - ExpressionNode *en; - DeclarationNode *decl; - DeclarationNode::TyCon aggKey; - DeclarationNode::TypeClass tclass; - StatementNode *sn; - ConstantNode *constant; - InitializerNode *in; + Token tok; + ParseNode *pn; + ExpressionNode *en; + DeclarationNode *decl; + DeclarationNode::TyCon aggKey; + DeclarationNode::TypeClass tclass; + StatementNode *sn; + ConstantNode *constant; + InitializerNode *in; } @@ -121,5 +118,5 @@ %type string_literal_list -/* expressions */ +// expressions %type constant %type tuple tuple_expression_list @@ -134,5 +131,5 @@ %type subrange -/* statements */ +// statements %type labeled_statement compound_statement expression_statement selection_statement %type iteration_statement jump_statement exception_statement asm_statement @@ -146,5 +143,5 @@ %type handler_list handler_clause finally_clause -/* declarations */ +// declarations %type abstract_array abstract_declarator abstract_function abstract_parameter_array %type abstract_parameter_declaration abstract_parameter_declarator abstract_parameter_function @@ -228,53 +225,51 @@ %type variable_abstract_ptr variable_array variable_declarator variable_function variable_ptr -/* initializers */ +// initializers %type initializer initializer_list initializer_opt -/* designators */ +// designators %type designator designator_list designation -/* Handle single shift/reduce conflict for dangling else by shifting the ELSE token. For example, this string - is ambiguous: - .---------. matches IF '(' comma_expression ')' statement - if ( C ) S1 else S2 - `-----------------' matches IF '(' comma_expression ')' statement ELSE statement */ - -%nonassoc THEN /* rule precedence for IF '(' comma_expression ')' statement */ -%nonassoc ELSE /* token precedence for start of else clause in IF statement */ - -%start translation_unit /* parse-tree root */ +// Handle single shift/reduce conflict for dangling else by shifting the ELSE token. For example, this string is +// ambiguous: +// .---------. matches IF '(' comma_expression ')' statement +// if ( C ) S1 else S2 +// `-----------------' matches IF '(' comma_expression ')' statement ELSE statement */ + +%nonassoc THEN // rule precedence for IF '(' comma_expression ')' statement +%nonassoc ELSE // token precedence for start of else clause in IF statement + +%start translation_unit // parse-tree root %% -/************************* Namespace Management ********************************/ - -/* The grammar in the ANSI C standard is not strictly context-free, since it relies upon the distinct terminal - symbols "identifier" and "TYPEDEFname" that are lexically identical. While it is possible to write a - purely context-free grammar, such a grammar would obscure the relationship between syntactic and semantic - constructs. Hence, this grammar uses the ANSI style. - - Cforall compounds this problem by introducing type names local to the scope of a declaration (for instance, - those introduced through "forall" qualifiers), and by introducing "type generators" -- parametrized types. - This latter type name creates a third class of identifiers that must be distinguished by the scanner. - - Since the scanner cannot distinguish among the different classes of identifiers without some context - information, it accesses a data structure (the TypedefTable) to allow classification of an identifier that - it has just read. Semantic actions during the parser update this data structure when the class of - identifiers change. - - Because the Cforall language is block-scoped, there is the possibility that an identifier can change its - class in a local scope; it must revert to its original class at the end of the block. Since type names can - be local to a particular declaration, each declaration is itself a scope. This requires distinguishing - between type names that are local to the current declaration scope and those that persist past the end of - the declaration (i.e., names defined in "typedef" or "type" declarations). - - The non-terminals "push" and "pop" derive the empty string; their only use is to denote the opening and - closing of scopes. Every push must have a matching pop, although it is regrettable the matching pairs do - not always occur within the same rule. These non-terminals may appear in more contexts than strictly - necessary from a semantic point of view. Unfortunately, these extra rules are necessary to prevent parsing - conflicts -- the parser may not have enough context and look-ahead information to decide whether a new - scope is necessary, so the effect of these extra rules is to open a new scope unconditionally. As the - grammar evolves, it may be neccesary to add or move around "push" and "pop" nonterminals to resolve - conflicts of this sort. */ +//************************* Namespace Management ******************************** + +// The grammar in the ANSI C standard is not strictly context-free, since it relies upon the distinct terminal symbols +// "identifier" and "TYPEDEFname" that are lexically identical. While it is possible to write a purely context-free +// grammar, such a grammar would obscure the relationship between syntactic and semantic constructs. Hence, this +// grammar uses the ANSI style. +// +// Cforall compounds this problem by introducing type names local to the scope of a declaration (for instance, those +// introduced through "forall" qualifiers), and by introducing "type generators" -- parametrized types. This latter +// type name creates a third class of identifiers that must be distinguished by the scanner. +// +// Since the scanner cannot distinguish among the different classes of identifiers without some context information, it +// accesses a data structure (the TypedefTable) to allow classification of an identifier that it has just read. +// Semantic actions during the parser update this data structure when the class of identifiers change. +// +// Because the Cforall language is block-scoped, there is the possibility that an identifier can change its class in a +// local scope; it must revert to its original class at the end of the block. Since type names can be local to a +// particular declaration, each declaration is itself a scope. This requires distinguishing between type names that are +// local to the current declaration scope and those that persist past the end of the declaration (i.e., names defined in +// "typedef" or "type" declarations). +// +// The non-terminals "push" and "pop" derive the empty string; their only use is to denote the opening and closing of +// scopes. Every push must have a matching pop, although it is regrettable the matching pairs do not always occur +// within the same rule. These non-terminals may appear in more contexts than strictly necessary from a semantic point +// of view. Unfortunately, these extra rules are necessary to prevent parsing conflicts -- the parser may not have +// enough context and look-ahead information to decide whether a new scope is necessary, so the effect of these extra +// rules is to open a new scope unconditionally. As the grammar evolves, it may be neccesary to add or move around +// "push" and "pop" nonterminals to resolve conflicts of this sort. push: @@ -290,9 +285,9 @@ ; -/************************* CONSTANTS ********************************/ +//************************* CONSTANTS ******************************** constant: - /* ENUMERATIONconstant is not included here; it is treated as a variable with type - "enumeration constant". */ + // ENUMERATIONconstant is not included here; it is treated as a variable with type "enumeration + // constant". INTEGERconstant { $$ = new ConstantNode(ConstantNode::Integer, $1); } | FLOATINGconstant { $$ = new ConstantNode(ConstantNode::Float, $1); } @@ -302,11 +297,11 @@ identifier: IDENTIFIER - | ATTR_IDENTIFIER /* CFA */ - | zero_one /* CFA */ + | ATTR_IDENTIFIER // CFA + | zero_one // CFA ; no_01_identifier: IDENTIFIER - | ATTR_IDENTIFIER /* CFA */ + | ATTR_IDENTIFIER // CFA ; @@ -315,18 +310,18 @@ ; -zero_one: /* CFA */ +zero_one: // CFA ZERO | ONE ; -string_literal_list: /* juxtaposed strings are concatenated */ +string_literal_list: // juxtaposed strings are concatenated STRINGliteral { $$ = new ConstantNode(ConstantNode::String, $1); } | string_literal_list STRINGliteral { $$ = $1->append( $2 ); } ; -/************************* EXPRESSIONS ********************************/ +//************************* EXPRESSIONS ******************************** primary_expression: - IDENTIFIER /* typedef name cannot be used as a variable name */ + IDENTIFIER // typedef name cannot be used as a variable name { $$ = new VarRefNode($1); } | zero_one @@ -338,5 +333,5 @@ | '(' comma_expression ')' { $$ = $2; } - | '(' compound_statement ')' /* GCC, lambda expression */ + | '(' compound_statement ')' // GCC, lambda expression { $$ = new ValofExprNode($2); } ; @@ -345,8 +340,8 @@ primary_expression | postfix_expression '[' push assignment_expression pop ']' - /* CFA, comma_expression disallowed in the context because it results in a commom user error: - subscripting a matrix with x[i,j] instead of x[i][j]. While this change is not backwards - compatible, there seems to be little advantage to this feature and many disadvantages. It - is possible to write x[(i,j)] in CFA, which is equivalent to the old x[i,j]. */ + // CFA, comma_expression disallowed in the context because it results in a commom user error: + // subscripting a matrix with x[i,j] instead of x[i][j]. While this change is not backwards + // compatible, there seems to be little advantage to this feature and many disadvantages. It is + // possible to write x[(i,j)] in CFA, which is equivalent to the old x[i,j]. { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Index), $1, $4); } | postfix_expression '(' argument_expression_list ')' @@ -354,14 +349,14 @@ | postfix_expression '.' no_attr_identifier { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::FieldSel), $1, new VarRefNode($3)); } - | postfix_expression '.' '[' push field_list pop ']' /* CFA, tuple field selector */ + | postfix_expression '.' '[' push field_list pop ']' // CFA, tuple field selector | postfix_expression ARROW no_attr_identifier { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::PFieldSel), $1, new VarRefNode($3)); } - | postfix_expression ARROW '[' push field_list pop ']' /* CFA, tuple field selector */ + | postfix_expression ARROW '[' push field_list pop ']' // CFA, tuple field selector | postfix_expression ICR { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::IncrPost), $1); } | postfix_expression DECR { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::DecrPost), $1); } - /* GCC has priority: cast_expression */ - | '(' type_name_no_function ')' '{' initializer_list comma_opt '}' /* C99 */ + // GCC has priority: cast_expression + | '(' type_name_no_function ')' '{' initializer_list comma_opt '}' // C99 { $$ = 0; } ; @@ -374,24 +369,24 @@ argument_expression: - /* empty */ /* use default argument */ - { $$ = 0; } + // empty + { $$ = 0; } // use default argument | assignment_expression | no_attr_identifier ':' assignment_expression { $$ = $3->set_asArgName($1); } - /* Only a list of no_attr_identifier_or_typedef_name is allowed in this context. However, there - is insufficient look ahead to distinguish between this list of parameter names and a tuple, - so the tuple form must be used with an appropriate semantic check. */ + // Only a list of no_attr_identifier_or_typedef_name is allowed in this context. However, there is + // insufficient look ahead to distinguish between this list of parameter names and a tuple, so the + // tuple form must be used with an appropriate semantic check. | '[' push assignment_expression pop ']' ':' assignment_expression - { $$ = $7->set_asArgName($3); } + { $$ = $7->set_asArgName($3); } | '[' push assignment_expression ',' tuple_expression_list pop ']' ':' assignment_expression - { $$ = $9->set_asArgName(new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)$3->set_link( flattenCommas( $5 )))); } - ; - -field_list: /* CFA, tuple field selector */ + { $$ = $9->set_asArgName(new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)$3->set_link( flattenCommas( $5 )))); } + ; + +field_list: // CFA, tuple field selector field | field_list ',' field { $$ = (ExpressionNode *)$1->set_link( $3 ); } ; -field: /* CFA, tuple field selector */ +field: // CFA, tuple field selector no_attr_identifier { $$ = new VarRefNode( $1 ); } @@ -412,5 +407,5 @@ | DECR unary_expression { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Decr), $2); } - | EXTENSION cast_expression /* GCC */ + | EXTENSION cast_expression // GCC { $$ = $2; } | unary_operator cast_expression @@ -418,10 +413,10 @@ | '!' cast_expression { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Neg), $2); } - | '*' cast_expression /* CFA */ + | '*' cast_expression // CFA { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::PointTo), $2); } - /* '*' is is separated from unary_operator because of shift/reduce conflict in: - { * X; } // dereference X - { * int X; } // CFA declaration of pointer to int - '&' must be moved here if C++ reference variables are supported. */ + // '*' is is separated from unary_operator because of shift/reduce conflict in: + // { * X; } // dereference X + // { * int X; } // CFA declaration of pointer to int + // '&' must be moved here if C++ reference variables are supported. | SIZEOF unary_expression { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::SizeOf), $2); } @@ -434,9 +429,9 @@ | ATTR_IDENTIFIER '(' argument_expression ')' { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Attr), new VarRefNode($1), $3); } - | ALIGNOF unary_expression /* GCC, variable alignment */ + | ALIGNOF unary_expression // GCC, variable alignment { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::AlignOf), $2); } - | ALIGNOF '(' type_name_no_function ')' /* GCC, type alignment */ + | ALIGNOF '(' type_name_no_function ')' // GCC, type alignment { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::AlignOf), new TypeValueNode($3)); } - | ANDAND no_attr_identifier /* GCC, address of label */ + | ANDAND no_attr_identifier // GCC, address of label { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::LabelAddress), new VarRefNode($2, true)); } ; @@ -538,7 +533,7 @@ { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Cond), (ExpressionNode *)mkList((*$1,*$3,*$5))); } - | logical_OR_expression '?' /* empty */ ':' conditional_expression /* GCC, omitted first operand */ + | logical_OR_expression '?' /* empty */ ':' conditional_expression // GCC, omitted first operand { $$=new CompositeExprNode(new OperatorNode(OperatorNode::NCond),$1,$4); } - | logical_OR_expression '?' comma_expression ':' tuple /* CFA, tuple expression */ + | logical_OR_expression '?' comma_expression ':' tuple // CFA, tuple expression { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Cond), (ExpressionNode *)mkList(( *$1, *$3, *$5 ))); } @@ -550,6 +545,5 @@ assignment_expression: - /* CFA, assignment is separated from assignment_operator to ensure no assignment operations - for tuples */ + // CFA, assignment is separated from assignment_operator to ensure no assignment operations for tuples conditional_expression | unary_expression '=' assignment_expression @@ -557,5 +551,5 @@ | unary_expression assignment_operator assignment_expression { $$ =new CompositeExprNode($2, $1, $3); } - | tuple assignment_opt /* CFA, tuple expression */ + | tuple assignment_opt // CFA, tuple expression { if ( $2 == 0 ) { @@ -568,13 +562,12 @@ assignment_expression_opt: - /* empty */ + // empty { $$ = new NullExprNode; } | assignment_expression ; -tuple: /* CFA, tuple */ - /* CFA, one assignment_expression is factored out of comma_expression to eliminate a - shift/reduce conflict with comma_expression in new_identifier_parameter_array and - new_abstract_array */ +tuple: // CFA, tuple + // CFA, one assignment_expression is factored out of comma_expression to eliminate a shift/reduce + // conflict with comma_expression in new_identifier_parameter_array and new_abstract_array '[' push pop ']' { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ) ); } @@ -608,14 +601,15 @@ comma_expression: assignment_expression - | comma_expression ',' assignment_expression /* { $$ = (ExpressionNode *)$1->add_to_list($3); } */ + | comma_expression ',' assignment_expression // { $$ = (ExpressionNode *)$1->add_to_list($3); } { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Comma),$1,$3); } ; comma_expression_opt: - /* empty */ { $$ = 0; } + // empty + { $$ = 0; } | comma_expression ; -/*************************** STATEMENTS *******************************/ +//*************************** STATEMENTS ******************************* statement: @@ -639,13 +633,13 @@ { $$ = new CompoundStmtNode( (StatementNode *)0 ); } | '{' - /* Two scopes are necessary because the block itself has a scope, but every declaration within - the block also requires its own scope */ + // Two scopes are necessary because the block itself has a scope, but every declaration within the block + // also requires its own scope push push - label_declaration_opt /* GCC, local labels */ - block_item_list pop '}' /* C99, intermix declarations and statements */ + label_declaration_opt // GCC, local labels + block_item_list pop '}' // C99, intermix declarations and statements { $$ = new CompoundStmtNode( $5 ); } ; -block_item_list: /* C99 */ +block_item_list: // C99 block_item | block_item_list push block_item @@ -654,7 +648,7 @@ block_item: - declaration /* CFA, new & old style declarations */ + declaration // CFA, new & old style declarations { $$ = new StatementNode( $1 ); } - | EXTENSION declaration /* GCC */ + | EXTENSION declaration // GCC { $$ = new StatementNode( $2 ); } | statement pop @@ -674,33 +668,33 @@ selection_statement: IF '(' comma_expression ')' statement %prec THEN - /* explicitly deal with the shift/reduce conflict on if/else */ + // explicitly deal with the shift/reduce conflict on if/else { $$ = new StatementNode(StatementNode::If, $3, $5); } | IF '(' comma_expression ')' statement ELSE statement { $$ = new StatementNode(StatementNode::If, $3, (StatementNode *)mkList((*$5, *$7)) ); } - | SWITCH '(' comma_expression ')' case_clause /* CFA */ + | SWITCH '(' comma_expression ')' case_clause // CFA { $$ = new StatementNode(StatementNode::Switch, $3, $5); } - | SWITCH '(' comma_expression ')' '{' push declaration_list_opt switch_clause_list_opt '}' /* CFA */ + | SWITCH '(' comma_expression ')' '{' push declaration_list_opt switch_clause_list_opt '}' // CFA { $$ = new StatementNode(StatementNode::Switch, $3, $8); /* xxx */ } - /* The semantics of the declaration list is changed to include any associated initialization, - which is performed *before* the transfer to the appropriate case clause. Statements after - the initial declaration list can never be executed, and therefore, are removed from the - grammar even though C allows it. */ - | CHOOSE '(' comma_expression ')' case_clause /* CFA */ + // The semantics of the declaration list is changed to include any associated initialization, which is + // performed *before* the transfer to the appropriate case clause. Statements after the initial + // declaration list can never be executed, and therefore, are removed from the grammar even though C + // allows it. + | CHOOSE '(' comma_expression ')' case_clause // CFA { $$ = new StatementNode(StatementNode::Choose, $3, $5); } - | CHOOSE '(' comma_expression ')' '{' push declaration_list_opt choose_clause_list_opt '}' /* CFA */ + | CHOOSE '(' comma_expression ')' '{' push declaration_list_opt choose_clause_list_opt '}' // CFA { $$ = new StatementNode(StatementNode::Choose, $3, $8); } ; -/* CASE and DEFAULT clauses are only allowed in the SWITCH statement, precluding Duff's device. In addition, a - case clause allows a list of values and subranges. */ - -case_value: /* CFA */ +// CASE and DEFAULT clauses are only allowed in the SWITCH statement, precluding Duff's device. In addition, a case +// clause allows a list of values and subranges. + +case_value: // CFA constant_expression { $$ = $1; } - | constant_expression ELLIPSIS constant_expression /* GCC, subrange */ + | constant_expression ELLIPSIS constant_expression // GCC, subrange { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Range),$1,$3); } - | subrange /* CFA, subrange */ - ; - -case_value_list: /* CFA */ + | subrange // CFA, subrange + ; + +case_value_list: // CFA case_value | case_value_list ',' case_value @@ -708,26 +702,26 @@ ; -case_label: /* CFA */ +case_label: // CFA CASE case_value_list ':' { $$ = new StatementNode(StatementNode::Case, $2, 0); } | DEFAULT ':' { $$ = new StatementNode(StatementNode::Default); } - /* A semantic check is required to ensure only one default clause per switch/choose - statement. */ - ; - -case_label_list: /* CFA */ + // A semantic check is required to ensure only one default clause per switch/choose statement. + ; + +case_label_list: // CFA case_label | case_label_list case_label { $$ = (StatementNode *)($1->set_link($2)); } ; -case_clause: /* CFA */ +case_clause: // CFA case_label_list statement { $$ = $1->append_last_case($2); } ; -switch_clause_list_opt: /* CFA */ - /* empty */ { $$ = 0; } +switch_clause_list_opt: // CFA + // empty + { $$ = 0; } | switch_clause_list ; -switch_clause_list: /* CFA */ +switch_clause_list: // CFA case_label_list statement_list { $$ = $1->append_last_case($2); } @@ -736,26 +730,28 @@ ; -choose_clause_list_opt: /* CFA */ - /* empty */ { $$ = 0; } +choose_clause_list_opt: // CFA + // empty + { $$ = 0; } | choose_clause_list ; -choose_clause_list: /* CFA */ +choose_clause_list: // CFA case_label_list fall_through - { $$ = $1->append_last_case($2); } + { $$ = $1->append_last_case($2); } | case_label_list statement_list fall_through_opt - { $$ = $1->append_last_case((StatementNode *)mkList((*$2,*$3))); } + { $$ = $1->append_last_case((StatementNode *)mkList((*$2,*$3))); } | choose_clause_list case_label_list fall_through - { $$ = (StatementNode *)($1->set_link($2->append_last_case($3))); } + { $$ = (StatementNode *)($1->set_link($2->append_last_case($3))); } | choose_clause_list case_label_list statement_list fall_through_opt - { $$ = (StatementNode *)($1->set_link($2->append_last_case((StatementNode *)mkList((*$3,*$4))))); } - ; - -fall_through_opt: /* CFA */ - /* empty */ { $$ = 0; } + { $$ = (StatementNode *)($1->set_link($2->append_last_case((StatementNode *)mkList((*$3,*$4))))); } + ; + +fall_through_opt: // CFA + // empty + { $$ = 0; } | fall_through ; -fall_through: /* CFA */ +fall_through: // CFA FALLTHRU { $$ = new StatementNode(StatementNode::Fallthru, 0, 0); } | FALLTHRU ';' { $$ = new StatementNode(StatementNode::Fallthru, 0, 0); } @@ -774,6 +770,6 @@ comma_expression_opt pop ';' comma_expression_opt ';' comma_expression_opt { $$ = new ForCtlExprNode($1, $4, $6); } - | declaration comma_expression_opt ';' comma_expression_opt /* C99 */ - /* Like C++, the loop index can be declared local to the loop. */ + | declaration comma_expression_opt ';' comma_expression_opt // C99 + // Like C++, the loop index can be declared local to the loop. { $$ = new ForCtlExprNode($1, $2, $4); } ; @@ -782,25 +778,23 @@ GOTO no_attr_identifier ';' { $$ = new StatementNode(StatementNode::Goto, $2); } - | GOTO '*' comma_expression ';' /* GCC, computed goto */ - /* The syntax for the GCC computed goto violates normal expression precedence, e.g., - goto *i+3; => goto *(i+3); whereas normal operator precedence yields goto (*i)+3; */ + | GOTO '*' comma_expression ';' // GCC, computed goto + // The syntax for the GCC computed goto violates normal expression precedence, e.g., goto *i+3; => + // goto *(i+3); whereas normal operator precedence yields goto (*i)+3; { $$ = new StatementNode(StatementNode::Goto, $3); } | CONTINUE ';' - /* A semantic check is required to ensure this statement appears only in the body of an - iteration statement. */ + // A semantic check is required to ensure this statement appears only in the body of an iteration + // statement. { $$ = new StatementNode(StatementNode::Continue, 0, 0); } - | CONTINUE no_attr_identifier ';' /* CFA, multi-level continue */ - /* A semantic check is required to ensure this statement appears only in the body of an - iteration statement, and the target of the transfer appears only at the start of an - iteration statement. */ + | CONTINUE no_attr_identifier ';' // CFA, multi-level continue + // A semantic check is required to ensure this statement appears only in the body of an iteration + // statement, and the target of the transfer appears only at the start of an iteration statement. { $$ = new StatementNode(StatementNode::Continue, $2); } | BREAK ';' - /* A semantic check is required to ensure this statement appears only in the body of an - iteration statement. */ + // A semantic check is required to ensure this statement appears only in the body of an iteration + // statement. { $$ = new StatementNode(StatementNode::Break, 0, 0); } - | BREAK no_attr_identifier ';' /* CFA, multi-level exit */ - /* A semantic check is required to ensure this statement appears only in the body of an - iteration statement, and the target of the transfer appears only at the start of an - iteration statement. */ + | BREAK no_attr_identifier ';' // CFA, multi-level exit + // A semantic check is required to ensure this statement appears only in the body of an iteration + // statement, and the target of the transfer appears only at the start of an iteration statement. { $$ = new StatementNode(StatementNode::Break, $2 ); } | RETURN comma_expression_opt ';' @@ -825,8 +819,8 @@ handler_list: - /* There must be at least one catch clause */ + // There must be at least one catch clause handler_clause - /* ISO/IEC 9899:1999 Section 15.3(6) If present, a "..." handler shall be the last handler for - its try block. */ + // ISO/IEC 9899:1999 Section 15.3(6) If present, a "..." handler shall be the last handler for its try + // block. | CATCH '(' ELLIPSIS ')' compound_statement { $$ = StatementNode::newCatchStmt( 0, $5, true ); } @@ -850,9 +844,9 @@ exception_declaration: - /* A semantic check is required to ensure type_specifier does not create a new type, e.g.: - - catch ( struct { int i; } x ) ... - - This new type cannot catch any thrown type because of name equivalence among types. */ + // A semantic check is required to ensure type_specifier does not create a new type, e.g.: + // + // catch ( struct { int i; } x ) ... + // + // This new type cannot catch any thrown type because of name equivalence among types. type_specifier | type_specifier declarator @@ -863,10 +857,10 @@ | type_specifier variable_abstract_declarator { $$ = $2->addType( $1 ); } - | new_abstract_declarator_tuple no_attr_identifier /* CFA */ + | new_abstract_declarator_tuple no_attr_identifier // CFA { typedefTable.addToEnclosingScope( TypedefTable::ID ); $$ = $1->addName( $2 ); } - | new_abstract_declarator_tuple /* CFA */ + | new_abstract_declarator_tuple // CFA ; @@ -874,5 +868,5 @@ ASM type_qualifier_list_opt '(' constant_expression ')' ';' { $$ = new StatementNode(StatementNode::Asm, 0, 0); } - | ASM type_qualifier_list_opt '(' constant_expression ':' asm_operands_opt ')' ';' /* remaining GCC */ + | ASM type_qualifier_list_opt '(' constant_expression ':' asm_operands_opt ')' ';' // remaining GCC { $$ = new StatementNode(StatementNode::Asm, 0, 0); } | ASM type_qualifier_list_opt '(' constant_expression ':' asm_operands_opt ':' asm_operands_opt ')' ';' @@ -883,26 +877,26 @@ ; -asm_operands_opt: /* GCC */ - /* empty */ +asm_operands_opt: // GCC + // empty | asm_operands_list ; -asm_operands_list: /* GCC */ +asm_operands_list: // GCC asm_operand | asm_operands_list ',' asm_operand ; -asm_operand: /* GCC */ +asm_operand: // GCC STRINGliteral '(' constant_expression ')' {} ; -asm_clobbers_list: /* GCC */ +asm_clobbers_list: // GCC STRINGliteral {} | asm_clobbers_list ',' STRINGliteral ; -/******************************* DECLARATIONS *********************************/ - -declaration_list_opt: /* used at beginning of switch statement */ +//******************************* DECLARATIONS ********************************* + +declaration_list_opt: // used at beginning of switch statement pop { $$ = 0; } @@ -916,5 +910,5 @@ ; -old_declaration_list_opt: /* used to declare parameter types in K&R style functions */ +old_declaration_list_opt: // used to declare parameter types in K&R style functions pop { $$ = 0; } @@ -928,38 +922,36 @@ ; -label_declaration_opt: /* GCC, local label */ - /* empty */ +label_declaration_opt: // GCC, local label + // empty | label_declaration_list ; -label_declaration_list: /* GCC, local label */ +label_declaration_list: // GCC, local label LABEL label_list ';' | label_declaration_list LABEL label_list ';' ; -label_list: /* GCC, local label */ +label_list: // GCC, local label no_attr_identifier_or_typedef_name {} | label_list ',' no_attr_identifier_or_typedef_name {} ; -declaration: /* CFA, new & old style declarations */ +declaration: // CFA, new & old style declarations new_declaration | old_declaration ; -/* C declaration syntax is notoriously confusing and error prone. Cforall provides its own type, variable and - function declarations. CFA declarations use the same declaration tokens as in C; however, CFA places - declaration modifiers to the left of the base type, while C declarations place modifiers to the right of - the base type. CFA declaration modifiers are interpreted from left to right and the entire type - specification is distributed across all variables in the declaration list (as in Pascal). ANSI C and the - new CFA declarations may appear together in the same program block, but cannot be mixed within a specific - declaration. - - CFA C - [10] int x; int x[10]; // array of 10 integers - [10] * char y; char *y[10]; // array of 10 pointers to char - */ - -new_declaration: /* CFA */ +// C declaration syntax is notoriously confusing and error prone. Cforall provides its own type, variable and function +// declarations. CFA declarations use the same declaration tokens as in C; however, CFA places declaration modifiers to +// the left of the base type, while C declarations place modifiers to the right of the base type. CFA declaration +// modifiers are interpreted from left to right and the entire type specification is distributed across all variables in +// the declaration list (as in Pascal). ANSI C and the new CFA declarations may appear together in the same program +// block, but cannot be mixed within a specific declaration. +// +// CFA C +// [10] int x; int x[10]; // array of 10 integers +// [10] * char y; char *y[10]; // array of 10 pointers to char + +new_declaration: // CFA new_variable_declaration pop ';' | new_typedef_declaration pop ';' @@ -969,27 +961,27 @@ ; -new_variable_declaration: /* CFA */ +new_variable_declaration: // CFA new_variable_specifier initializer_opt { - typedefTable.addToEnclosingScope( TypedefTable::ID); + typedefTable.addToEnclosingScope( TypedefTable::ID ); $$ = $1; } | declaration_qualifier_list new_variable_specifier initializer_opt - /* declaration_qualifier_list also includes type_qualifier_list, so a semantic check is - necessary to preclude them as a type_qualifier cannot appear in that context. */ - { - typedefTable.addToEnclosingScope( TypedefTable::ID); + // declaration_qualifier_list also includes type_qualifier_list, so a semantic check is necessary to + // preclude them as a type_qualifier cannot appear in that context. + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); $$ = $2->addQualifiers( $1 ); } | new_variable_declaration pop ',' push identifier_or_typedef_name initializer_opt { - typedefTable.addToEnclosingScope( *$5, TypedefTable::ID); + typedefTable.addToEnclosingScope( *$5, TypedefTable::ID ); $$ = $1->appendList( $1->cloneType( $5 ) ); } ; -new_variable_specifier: /* CFA */ - /* A semantic check is required to ensure asm_name only appears on declarations with implicit - or explicit static storage-class */ +new_variable_specifier: // CFA + // A semantic check is required to ensure asm_name only appears on declarations with implicit or + // explicit static storage-class new_abstract_declarator_no_tuple identifier_or_typedef_name asm_name_opt { @@ -1009,25 +1001,25 @@ ; -new_function_declaration: /* CFA */ +new_function_declaration: // CFA new_function_specifier { - typedefTable.addToEnclosingScope( TypedefTable::ID); + typedefTable.addToEnclosingScope( TypedefTable::ID ); $$ = $1; } | declaration_qualifier_list new_function_specifier - /* declaration_qualifier_list also includes type_qualifier_list, so a semantic check is - necessary to preclude them as a type_qualifier cannot appear in this context. */ - { - typedefTable.addToEnclosingScope( TypedefTable::ID); + // declaration_qualifier_list also includes type_qualifier_list, so a semantic check is necessary to + // preclude them as a type_qualifier cannot appear in this context. + { + typedefTable.addToEnclosingScope( TypedefTable::ID ); $$ = $2->addQualifiers( $1 ); } | new_function_declaration pop ',' push identifier_or_typedef_name { - typedefTable.addToEnclosingScope( *$5, TypedefTable::ID); + typedefTable.addToEnclosingScope( *$5, TypedefTable::ID ); $$ = $1->appendList( $1->cloneType( $5 ) ); } ; -new_function_specifier: /* CFA */ +new_function_specifier: // CFA '[' push pop ']' identifier '(' push new_parameter_type_list_opt pop ')' { @@ -1060,5 +1052,5 @@ ; -new_function_return: /* CFA */ +new_function_return: // CFA '[' push new_parameter_list pop ']' { $$ = DeclarationNode::newTuple( $3 ); } @@ -1069,5 +1061,5 @@ ; -new_typedef_declaration: /* CFA */ +new_typedef_declaration: // CFA TYPEDEF new_variable_specifier { @@ -1102,5 +1094,5 @@ $$ = $1->appendList( $1->cloneBaseType( $5 )->addTypedef() ); } - | type_qualifier_list TYPEDEF type_specifier declarator /* remaining OBSOLESCENT (see 2) */ + | type_qualifier_list TYPEDEF type_specifier declarator // remaining OBSOLESCENT (see 2) { typedefTable.addToEnclosingScope( TypedefTable::TD); @@ -1119,5 +1111,5 @@ ; -typedef_expression: /* GCC, naming expression type */ +typedef_expression: // GCC, naming expression type TYPEDEF no_attr_identifier '=' assignment_expression { @@ -1135,5 +1127,5 @@ declaring_list pop ';' | typedef_declaration pop ';' - | typedef_expression pop ';' /* GCC, naming expression type */ + | typedef_expression pop ';' // GCC, naming expression type | sue_declaration_specifier pop ';' ; @@ -1149,10 +1141,10 @@ | declaring_list ',' attribute_list_opt declarator asm_name_opt initializer_opt { - typedefTable.addToEnclosingScope( TypedefTable::ID); + typedefTable.addToEnclosingScope( TypedefTable::ID ); $$ = $1->appendList( $1->cloneBaseType( $4->addInitializer($6) ) ); } ; -declaration_specifier: /* type specifier + storage class */ +declaration_specifier: // type specifier + storage class basic_declaration_specifier | sue_declaration_specifier @@ -1161,5 +1153,5 @@ ; -type_specifier: /* declaration specifier - storage class */ +type_specifier: // declaration specifier - storage class basic_type_specifier | sue_type_specifier @@ -1168,6 +1160,6 @@ ; -type_qualifier_list_opt: /* GCC, used in asm_statement */ - /* empty */ +type_qualifier_list_opt: // GCC, used in asm_statement + // empty { $$ = 0; } | type_qualifier_list @@ -1189,5 +1181,5 @@ type_qualifier_name | attribute - { $$ = DeclarationNode::newQualifier( DeclarationNode::Const ); } + { $$ = DeclarationNode::newQualifier( DeclarationNode::Attribute ); } ; @@ -1199,13 +1191,13 @@ | VOLATILE { $$ = DeclarationNode::newQualifier( DeclarationNode::Volatile ); } - | LVALUE /* CFA */ + | LVALUE // CFA { $$ = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); } | ATOMIC { $$ = DeclarationNode::newQualifier( DeclarationNode::Atomic ); } - | FORALL '(' + | FORALL '(' { typedefTable.enterScope(); } - type_parameter_list ')' /* CFA */ + type_parameter_list ')' // CFA { typedefTable.leaveScope(); @@ -1216,5 +1208,5 @@ declaration_qualifier_list: storage_class_list - | type_qualifier_list storage_class_list /* remaining OBSOLESCENT (see 2) */ + | type_qualifier_list storage_class_list // remaining OBSOLESCENT (see 2) { $$ = $1->addQualifiers( $2 ); } | declaration_qualifier_list type_qualifier_list storage_class_list @@ -1239,16 +1231,16 @@ storage_class_name: - AUTO + EXTERN + { $$ = DeclarationNode::newStorageClass( DeclarationNode::Extern ); } + | STATIC + { $$ = DeclarationNode::newStorageClass( DeclarationNode::Static ); } + | AUTO { $$ = DeclarationNode::newStorageClass( DeclarationNode::Auto ); } - | EXTERN - { $$ = DeclarationNode::newStorageClass( DeclarationNode::Extern ); } | REGISTER { $$ = DeclarationNode::newStorageClass( DeclarationNode::Register ); } - | STATIC - { $$ = DeclarationNode::newStorageClass( DeclarationNode::Static ); } - | INLINE /* C99 */ - /* INLINE is essentially a storage class specifier for functions, and hence, belongs here. */ + | INLINE // C99 + // INLINE is essentially a storage class specifier for functions, and hence, belongs here. { $$ = DeclarationNode::newStorageClass( DeclarationNode::Inline ); } - | FORTRAN /* C99 */ + | FORTRAN // C99 { $$ = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); } ; @@ -1273,18 +1265,18 @@ | VOID { $$ = DeclarationNode::newBasicType( DeclarationNode::Void ); } - | BOOL /* C99 */ + | BOOL // C99 { $$ = DeclarationNode::newBasicType( DeclarationNode::Bool ); } - | COMPLEX /* C99 */ + | COMPLEX // C99 { $$ = DeclarationNode::newBasicType( DeclarationNode::Complex ); } - | IMAGINARY /* C99 */ + | IMAGINARY // C99 { $$ = DeclarationNode::newBasicType( DeclarationNode::Imaginary ); } ; basic_declaration_specifier: - /* A semantic check is necessary for conflicting storage classes. */ + // A semantic check is necessary for conflicting storage classes. basic_type_specifier | declaration_qualifier_list basic_type_specifier { $$ = $2->addQualifiers( $1 ); } - | basic_declaration_specifier storage_class /* remaining OBSOLESCENT (see 2) */ + | basic_declaration_specifier storage_class // remaining OBSOLESCENT (see 2) { $$ = $1->addQualifiers( $2 ); } | basic_declaration_specifier storage_class type_qualifier_list @@ -1301,5 +1293,5 @@ direct_type_name: - /* A semantic check is necessary for conflicting type qualifiers. */ + // A semantic check is necessary for conflicting type qualifiers. basic_type_name | type_qualifier_list basic_type_name @@ -1312,11 +1304,11 @@ indirect_type_name: - TYPEOF '(' type_name ')' /* GCC: typeof(x) y; */ + TYPEOF '(' type_name ')' // GCC: typeof(x) y; { $$ = $3; } - | TYPEOF '(' comma_expression ')' /* GCC: typeof(a+b) y; */ + | TYPEOF '(' comma_expression ')' // GCC: typeof(a+b) y; { $$ = DeclarationNode::newTypeof( $3 ); } - | ATTR_TYPEGENname '(' type_name ')' /* CFA: e.g., @type(x) y; */ + | ATTR_TYPEGENname '(' type_name ')' // CFA: e.g., @type(x) y; { $$ = DeclarationNode::newAttr( $1, $3 ); } - | ATTR_TYPEGENname '(' comma_expression ')' /* CFA: e.g., @type(a+b) y; */ + | ATTR_TYPEGENname '(' comma_expression ')' // CFA: e.g., @type(a+b) y; { $$ = DeclarationNode::newAttr( $1, $3 ); } ; @@ -1326,5 +1318,5 @@ | declaration_qualifier_list sue_type_specifier { $$ = $2->addQualifiers( $1 ); } - | sue_declaration_specifier storage_class /* remaining OBSOLESCENT (see 2) */ + | sue_declaration_specifier storage_class // remaining OBSOLESCENT (see 2) { $$ = $1->addQualifiers( $2 ); } | sue_declaration_specifier storage_class type_qualifier_list @@ -1333,5 +1325,5 @@ sue_type_specifier: - elaborated_type_name /* struct, union, enum */ + elaborated_type_name // struct, union, enum | type_qualifier_list elaborated_type_name { $$ = $2->addQualifiers( $1 ); } @@ -1344,5 +1336,5 @@ | declaration_qualifier_list typedef_type_specifier { $$ = $2->addQualifiers( $1 ); } - | typedef_declaration_specifier storage_class /* remaining OBSOLESCENT (see 2) */ + | typedef_declaration_specifier storage_class // remaining OBSOLESCENT (see 2) { $$ = $1->addQualifiers( $2 ); } | typedef_declaration_specifier storage_class type_qualifier_list @@ -1350,5 +1342,5 @@ ; -typedef_type_specifier: /* typedef types */ +typedef_type_specifier: // typedef types TYPEDEFname { $$ = DeclarationNode::newFromTypedef( $1 ); } @@ -1371,16 +1363,16 @@ | aggregate_key no_attr_identifier_or_typedef_name '{' field_declaration_list '}' { $$ = DeclarationNode::newAggregate( $1, $2, 0, 0, $4 ); } - | aggregate_key '(' push type_parameter_list pop ')' '{' field_declaration_list '}' /* CFA */ + | aggregate_key '(' push type_parameter_list pop ')' '{' field_declaration_list '}' // CFA { $$ = DeclarationNode::newAggregate( $1, 0, $4, 0, $8 ); } - | aggregate_key '(' push type_parameter_list pop ')' no_attr_identifier_or_typedef_name /* CFA */ + | aggregate_key '(' push type_parameter_list pop ')' no_attr_identifier_or_typedef_name // CFA { $$ = DeclarationNode::newAggregate( $1, $7, $4, 0, 0 ); } - | aggregate_key '(' push type_parameter_list pop ')' no_attr_identifier_or_typedef_name '{' field_declaration_list '}' /* CFA */ + | aggregate_key '(' push type_parameter_list pop ')' no_attr_identifier_or_typedef_name '{' field_declaration_list '}' // CFA { $$ = DeclarationNode::newAggregate( $1, $7, $4, 0, $9 ); } - | aggregate_key '(' push type_parameter_list pop ')' '(' type_name_list ')' '{' field_declaration_list '}' /* CFA */ + | aggregate_key '(' push type_parameter_list pop ')' '(' type_name_list ')' '{' field_declaration_list '}' // CFA { $$ = DeclarationNode::newAggregate( $1, 0, $4, $8, $11 ); } - | aggregate_key '(' push type_name_list pop ')' no_attr_identifier_or_typedef_name /* CFA */ - /* push and pop are only to prevent S/R conflicts */ + | aggregate_key '(' push type_name_list pop ')' no_attr_identifier_or_typedef_name // CFA + // push and pop are only to prevent S/R conflicts { $$ = DeclarationNode::newAggregate( $1, $7, 0, $4, 0 ); } - | aggregate_key '(' push type_parameter_list pop ')' '(' type_name_list ')' no_attr_identifier_or_typedef_name '{' field_declaration_list '}' /* CFA */ + | aggregate_key '(' push type_parameter_list pop ')' '(' type_name_list ')' no_attr_identifier_or_typedef_name '{' field_declaration_list '}' // CFA { $$ = DeclarationNode::newAggregate( $1, $10, $4, $8, $12 ); } ; @@ -1401,19 +1393,19 @@ field_declaration: - new_field_declaring_list ';' /* CFA, new style field declaration */ - | EXTENSION new_field_declaring_list ';' /* GCC */ + new_field_declaring_list ';' // CFA, new style field declaration + | EXTENSION new_field_declaring_list ';' // GCC { $$ = $2; } | field_declaring_list ';' - | EXTENSION field_declaring_list ';' /* GCC */ - { $$ = $2; } - ; - -new_field_declaring_list: /* CFA, new style field declaration */ - new_abstract_declarator_tuple /* CFA, no field name */ + | EXTENSION field_declaring_list ';' // GCC + { $$ = $2; } + ; + +new_field_declaring_list: // CFA, new style field declaration + new_abstract_declarator_tuple // CFA, no field name | new_abstract_declarator_tuple no_attr_identifier_or_typedef_name { $$ = $1->addName( $2 ); } | new_field_declaring_list ',' no_attr_identifier_or_typedef_name { $$ = $1->appendList( $1->cloneType( $3 ) ); } - | new_field_declaring_list ',' /* CFA, no field name */ + | new_field_declaring_list ',' // CFA, no field name { $$ = $1->appendList( $1->cloneType( 0 ) ); } ; @@ -1427,19 +1419,19 @@ field_declarator: - /* empty */ /* CFA, no field name */ - { $$ = DeclarationNode::newName( 0 ); /* XXX */ } - | bit_subrange_size /* no field name */ + // empty + { $$ = DeclarationNode::newName( 0 ); /* XXX */ } // CFA, no field name + | bit_subrange_size // no field name { $$ = DeclarationNode::newBitfield( $1 ); } | variable_declarator bit_subrange_size_opt - /* A semantic check is required to ensure bit_subrange only appears on base type int. */ + // A semantic check is required to ensure bit_subrange only appears on base type int. { $$ = $1->addBitfield( $2 ); } | typedef_redeclarator bit_subrange_size_opt - /* A semantic check is required to ensure bit_subrange only appears on base type int. */ + // A semantic check is required to ensure bit_subrange only appears on base type int. { $$ = $1->addBitfield( $2 ); } - | variable_abstract_declarator /* CFA, no field name */ + | variable_abstract_declarator // CFA, no field name ; bit_subrange_size_opt: - /* empty */ + // empty { $$ = 0; } | bit_subrange_size @@ -1473,5 +1465,5 @@ enumerator_value_opt: - /* empty */ + // empty { $$ = 0; } | '=' constant_expression @@ -1479,13 +1471,13 @@ ; -/* Minimum of one parameter after which ellipsis is allowed only at the end. */ - -new_parameter_type_list_opt: /* CFA */ - /* empty */ +// Minimum of one parameter after which ellipsis is allowed only at the end. + +new_parameter_type_list_opt: // CFA + // empty { $$ = 0; } | new_parameter_type_list ; -new_parameter_type_list: /* CFA, abstract + real */ +new_parameter_type_list: // CFA, abstract + real new_abstract_parameter_list | new_parameter_list @@ -1498,8 +1490,8 @@ ; -new_parameter_list: /* CFA */ - /* To obtain LR(1) between new_parameter_list and new_abstract_tuple, the last - new_abstract_parameter_list is factored out from new_parameter_list, flattening the rules - to get lookahead to the ']'. */ +new_parameter_list: // CFA + // To obtain LR(1) between new_parameter_list and new_abstract_tuple, the last + // new_abstract_parameter_list is factored out from new_parameter_list, flattening the rules + // to get lookahead to the ']'. new_parameter_declaration | new_abstract_parameter_list pop ',' push new_parameter_declaration @@ -1511,5 +1503,5 @@ ; -new_abstract_parameter_list: /* CFA, new & old style abstract */ +new_abstract_parameter_list: // CFA, new & old style abstract new_abstract_parameter_declaration | new_abstract_parameter_list pop ',' push new_abstract_parameter_declaration @@ -1518,5 +1510,5 @@ parameter_type_list_opt: - /* empty */ + // empty { $$ = 0; } | parameter_type_list @@ -1529,5 +1521,5 @@ ; -parameter_list: /* abstract + real */ +parameter_list: // abstract + real abstract_parameter_declaration | parameter_declaration @@ -1538,14 +1530,14 @@ ; -/* Provides optional identifier names (abstract_declarator/variable_declarator), no initialization, different - semantics for typedef name by using typedef_parameter_redeclarator instead of typedef_redeclarator, and - function prototypes. */ - -new_parameter_declaration: /* CFA, new & old style parameter declaration */ +// Provides optional identifier names (abstract_declarator/variable_declarator), no initialization, different +// semantics for typedef name by using typedef_parameter_redeclarator instead of typedef_redeclarator, and +// function prototypes. + +new_parameter_declaration: // CFA, new & old style parameter declaration parameter_declaration | new_identifier_parameter_declarator_no_tuple identifier_or_typedef_name assignment_opt { $$ = $1->addName( $2 ); } | new_abstract_tuple identifier_or_typedef_name assignment_opt - /* To obtain LR(1), these rules must be duplicated here (see new_abstract_declarator). */ + // To obtain LR(1), these rules must be duplicated here (see new_abstract_declarator). { $$ = $1->addName( $2 ); } | type_qualifier_list new_abstract_tuple identifier_or_typedef_name assignment_opt @@ -1554,9 +1546,9 @@ ; -new_abstract_parameter_declaration: /* CFA, new & old style parameter declaration */ +new_abstract_parameter_declaration: // CFA, new & old style parameter declaration abstract_parameter_declaration | new_identifier_parameter_declarator_no_tuple | new_abstract_tuple - /* To obtain LR(1), these rules must be duplicated here (see new_abstract_declarator). */ + // To obtain LR(1), these rules must be duplicated here (see new_abstract_declarator). | type_qualifier_list new_abstract_tuple { $$ = $2->addQualifiers( $1 ); } @@ -1567,10 +1559,10 @@ declaration_specifier identifier_parameter_declarator assignment_opt { - typedefTable.addToEnclosingScope( TypedefTable::ID); + typedefTable.addToEnclosingScope( TypedefTable::ID ); $$ = $2->addType( $1 )->addInitializer( new InitializerNode($3) ); } | declaration_specifier typedef_parameter_redeclarator assignment_opt { - typedefTable.addToEnclosingScope( TypedefTable::ID); + typedefTable.addToEnclosingScope( TypedefTable::ID ); $$ = $2->addType( $1 )->addInitializer( new InitializerNode($3) ); } @@ -1583,9 +1575,9 @@ ; -/* ISO/IEC 9899:1999 Section 6.9.1(6) : "An identifier declared as a typedef name shall not be redeclared as a - parameter." Because the scope of the K&R-style parameter-list sees the typedef first, the following is - based only on identifiers. The ANSI-style parameter-list can redefine a typedef name. */ - -identifier_list: /* K&R-style parameter list => no types */ +// ISO/IEC 9899:1999 Section 6.9.1(6) : "An identifier declared as a typedef name shall not be redeclared as a +// parameter." Because the scope of the K&R-style parameter-list sees the typedef first, the following is +// based only on identifiers. The ANSI-style parameter-list can redefine a typedef name. + +identifier_list: // K&R-style parameter list => no types no_attr_identifier { $$ = DeclarationNode::newName( $1 ); } @@ -1612,6 +1604,6 @@ ; -type_name_no_function: /* sizeof, alignof, cast (constructor) */ - new_abstract_declarator_tuple /* CFA */ +type_name_no_function: // sizeof, alignof, cast (constructor) + new_abstract_declarator_tuple // CFA | type_specifier | type_specifier variable_abstract_declarator @@ -1619,7 +1611,7 @@ ; -type_name: /* typeof, assertion */ - new_abstract_declarator_tuple /* CFA */ - | new_abstract_function /* CFA */ +type_name: // typeof, assertion + new_abstract_declarator_tuple // CFA + | new_abstract_function // CFA | type_specifier | type_specifier abstract_declarator @@ -1645,21 +1637,21 @@ ; -/* There is an unreconcileable parsing problem between C99 and CFA with respect to designators. The problem - is use of '=' to separator the designator from the initializer value, as in: - - int x[10] = { [1] = 3 }; - - The string "[1] = 3" can be parsed as a designator assignment or a tuple assignment. To disambiguate this - case, CFA changes the syntax from "=" to ":" as the separator between the designator and initializer. GCC - does uses ":" for field selection. The optional use of the "=" in GCC, or in this case ":", cannot be - supported either due to shift/reduce conflicts */ +// There is an unreconcileable parsing problem between C99 and CFA with respect to designators. The problem +// is use of '=' to separator the designator from the initializer value, as in: +// +// int x[10] = { [1] = 3 }; +// +// The string "[1] = 3" can be parsed as a designator assignment or a tuple assignment. To disambiguate this +// case, CFA changes the syntax from "=" to ":" as the separator between the designator and initializer. GCC +// does uses ":" for field selection. The optional use of the "=" in GCC, or in this case ":", cannot be +// supported either due to shift/reduce conflicts designation: - designator_list ':' /* C99, CFA uses ":" instead of "=" */ - | no_attr_identifier_or_typedef_name ':' /* GCC, field name */ + designator_list ':' // C99, CFA uses ":" instead of "=" + | no_attr_identifier_or_typedef_name ':' // GCC, field name { $$ = new VarRefNode( $1 ); } ; -designator_list: /* C99 */ +designator_list: // C99 designator | designator_list designator { $$ = (ExpressionNode *)($1->set_link( $2 )); } @@ -1667,42 +1659,42 @@ designator: - '.' no_attr_identifier_or_typedef_name /* C99, field name */ + '.' no_attr_identifier_or_typedef_name // C99, field name { $$ = new VarRefNode( $2 ); } - | '[' push assignment_expression pop ']' /* C99, single array element */ + | '[' push assignment_expression pop ']' // C99, single array element /* assignment_expression used instead of constant_expression because of shift/reduce conflicts with tuple. */ { $$ = $3; } - | '[' push subrange pop ']' /* CFA, multiple array elements */ + | '[' push subrange pop ']' // CFA, multiple array elements { $$ = $3; } - | '[' push constant_expression ELLIPSIS constant_expression pop ']' /* GCC, multiple array elements */ + | '[' push constant_expression ELLIPSIS constant_expression pop ']' // GCC, multiple array elements { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Range), $3, $5); } - | '.' '[' push field_list pop ']' /* CFA, tuple field selector */ + | '.' '[' push field_list pop ']' // CFA, tuple field selector { $$ = $4; } ; -/* The CFA type system is based on parametric polymorphism, the ability to declare functions with type - parameters, rather than an object-oriented type system. This required four groups of extensions: - - Overloading: function, data, and operator identifiers may be overloaded. - - Type declarations: "type" is used to generate new types for declaring objects. Similarly, "dtype" is used - for object and incomplete types, and "ftype" is used for function types. Type declarations with - initializers provide definitions of new types. Type declarations with storage class "extern" provide - opaque types. - - Polymorphic functions: A forall clause declares a type parameter. The corresponding argument is inferred at - the call site. A polymorphic function is not a template; it is a function, with an address and a type. - - Specifications and Assertions: Specifications are collections of declarations parameterized by one or more - types. They serve many of the purposes of abstract classes, and specification hierarchies resemble - subclass hierarchies. Unlike classes, they can define relationships between types. Assertions declare - that a type or types provide the operations declared by a specification. Assertions are normally used - to declare requirements on type arguments of polymorphic functions. */ - -typegen_declaration_specifier: /* CFA */ +// The CFA type system is based on parametric polymorphism, the ability to declare functions with type +// parameters, rather than an object-oriented type system. This required four groups of extensions: +// +// Overloading: function, data, and operator identifiers may be overloaded. +// +// Type declarations: "type" is used to generate new types for declaring objects. Similarly, "dtype" is used +// for object and incomplete types, and "ftype" is used for function types. Type declarations with +// initializers provide definitions of new types. Type declarations with storage class "extern" provide +// opaque types. +// +// Polymorphic functions: A forall clause declares a type parameter. The corresponding argument is inferred at +// the call site. A polymorphic function is not a template; it is a function, with an address and a type. +// +// Specifications and Assertions: Specifications are collections of declarations parameterized by one or more +// types. They serve many of the purposes of abstract classes, and specification hierarchies resemble +// subclass hierarchies. Unlike classes, they can define relationships between types. Assertions declare +// that a type or types provide the operations declared by a specification. Assertions are normally used +// to declare requirements on type arguments of polymorphic functions. + +typegen_declaration_specifier: // CFA typegen_type_specifier | declaration_qualifier_list typegen_type_specifier { $$ = $2->addQualifiers( $1 ); } - | typegen_declaration_specifier storage_class /* remaining OBSOLESCENT (see 2) */ + | typegen_declaration_specifier storage_class // remaining OBSOLESCENT (see 2) { $$ = $1->addQualifiers( $2 ); } | typegen_declaration_specifier storage_class type_qualifier_list @@ -1710,5 +1702,5 @@ ; -typegen_type_specifier: /* CFA */ +typegen_type_specifier: // CFA TYPEGENname '(' type_name_list ')' { $$ = DeclarationNode::newFromTypeGen( $1, $3 ); } @@ -1719,5 +1711,5 @@ ; -type_parameter_list: /* CFA */ +type_parameter_list: // CFA type_parameter assignment_opt | type_parameter_list ',' type_parameter assignment_opt @@ -1725,5 +1717,5 @@ ; -type_parameter: /* CFA */ +type_parameter: // CFA type_class no_attr_identifier_or_typedef_name { typedefTable.addToEnclosingScope(*($2), TypedefTable::TD); } @@ -1733,5 +1725,5 @@ ; -type_class: /* CFA */ +type_class: // CFA TYPE { $$ = DeclarationNode::Type; } @@ -1742,6 +1734,6 @@ ; -assertion_list_opt: /* CFA */ - /* empty */ +assertion_list_opt: // CFA + // empty { $$ = 0; } | assertion_list_opt assertion @@ -1749,5 +1741,5 @@ ; -assertion: /* CFA */ +assertion: // CFA '|' no_attr_identifier_or_typedef_name '(' type_name_list ')' { @@ -1761,5 +1753,5 @@ ; -type_name_list: /* CFA */ +type_name_list: // CFA type_name { $$ = new TypeValueNode( $1 ); } @@ -1771,5 +1763,5 @@ ; -type_declaring_list: /* CFA */ +type_declaring_list: // CFA TYPE type_declarator { $$ = $2; } @@ -1780,5 +1772,5 @@ ; -type_declarator: /* CFA */ +type_declarator: // CFA type_declarator_name assertion_list_opt { $$ = $1->addAssertions( $2 ); } @@ -1787,5 +1779,5 @@ ; -type_declarator_name: /* CFA */ +type_declarator_name: // CFA no_attr_identifier_or_typedef_name { @@ -1800,8 +1792,8 @@ ; -context_specifier: /* CFA */ +context_specifier: // CFA CONTEXT no_attr_identifier_or_typedef_name '(' push type_parameter_list pop ')' '{' '}' { - typedefTable.addToEnclosingScope(*($2), TypedefTable::ID); + typedefTable.addToEnclosingScope(*($2), TypedefTable::ID ); $$ = DeclarationNode::newContext( $2, $5, 0 ); } @@ -1814,10 +1806,10 @@ { typedefTable.leaveContext(); - typedefTable.addToEnclosingScope(*($2), TypedefTable::ID); + typedefTable.addToEnclosingScope(*($2), TypedefTable::ID ); $$ = DeclarationNode::newContext( $2, $5, $10 ); } ; -context_declaration_list: /* CFA */ +context_declaration_list: // CFA context_declaration | context_declaration_list push context_declaration @@ -1825,10 +1817,10 @@ ; -context_declaration: /* CFA */ +context_declaration: // CFA new_context_declaring_list pop ';' | context_declaring_list pop ';' ; -new_context_declaring_list: /* CFA */ +new_context_declaring_list: // CFA new_variable_specifier { @@ -1848,22 +1840,22 @@ ; -context_declaring_list: /* CFA */ +context_declaring_list: // CFA type_specifier declarator { - typedefTable.addToEnclosingScope2( TypedefTable::ID); + typedefTable.addToEnclosingScope2( TypedefTable::ID ); $$ = $2->addType( $1 ); } | context_declaring_list pop ',' push declarator { - typedefTable.addToEnclosingScope2( TypedefTable::ID); + typedefTable.addToEnclosingScope2( TypedefTable::ID ); $$ = $1->appendList( $1->cloneBaseType( $5 ) ); } ; -/***************************** EXTERNAL DEFINITIONS *****************************/ +//***************************** EXTERNAL DEFINITIONS ***************************** translation_unit: - /* empty */ /* empty input file */ - {} + // empty + {} // empty input file | external_definition_list { @@ -1880,17 +1872,15 @@ | external_definition_list push external_definition { - if ( $1 ) { - $$ = $1->appendList( $3 ); - } else { - $$ = $3; - } + if ( $1 ) { + $$ = $1->appendList( $3 ); + } else { + $$ = $3; + } } ; external_definition_list_opt: - /* empty */ - { - $$ = 0; - } + // empty + { $$ = 0; } | external_definition_list ; @@ -1899,5 +1889,5 @@ declaration | function_definition - | asm_statement /* GCC, global assembler statement */ + | asm_statement // GCC, global assembler statement {} | EXTERN STRINGliteral @@ -1906,5 +1896,5 @@ linkage = LinkageSpec::fromString( *$2 ); } - '{' external_definition_list_opt '}' /* C++-style linkage specifier */ + '{' external_definition_list_opt '}' // C++-style linkage specifier { linkage = linkageStack.top(); @@ -1917,5 +1907,5 @@ function_definition: - new_function_specifier compound_statement /* CFA */ + new_function_specifier compound_statement // CFA { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -1923,7 +1913,7 @@ $$ = $1->addFunctionBody( $2 ); } - | declaration_qualifier_list new_function_specifier compound_statement /* CFA */ - /* declaration_qualifier_list also includes type_qualifier_list, so a semantic check is - necessary to preclude them as a type_qualifier cannot appear in this context. */ + | declaration_qualifier_list new_function_specifier compound_statement // CFA + // declaration_qualifier_list also includes type_qualifier_list, so a semantic check is + // necessary to preclude them as a type_qualifier cannot appear in this context. { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -1939,9 +1929,9 @@ } - /* These rules are a concession to the "implicit int" type_specifier because there is a - significant amount of code with functions missing a type-specifier on the return type. - Parsing is possible because function_definition does not appear in the context of an - expression (nested functions would preclude this concession). A function prototype - declaration must still have a type_specifier. OBSOLESCENT (see 1) */ + // These rules are a concession to the "implicit int" type_specifier because there is a + // significant amount of code with functions missing a type-specifier on the return type. + // Parsing is possible because function_definition does not appear in the context of an + // expression (nested functions would preclude this concession). A function prototype + // declaration must still have a type_specifier. OBSOLESCENT (see 1) | function_declarator compound_statement { @@ -1969,5 +1959,5 @@ } - /* Old-style K&R function definition, OBSOLESCENT (see 4) */ + // Old-style K&R function definition, OBSOLESCENT (see 4) | declaration_specifier old_function_declarator push old_declaration_list_opt compound_statement { @@ -1989,5 +1979,5 @@ } - /* Old-style K&R function definition with "implicit int" type_specifier, OBSOLESCENT (see 4) */ + // Old-style K&R function definition with "implicit int" type_specifier, OBSOLESCENT (see 4) | declaration_qualifier_list old_function_declarator push old_declaration_list_opt compound_statement { @@ -2012,39 +2002,39 @@ subrange: - constant_expression '~' constant_expression /* CFA, integer subrange */ + constant_expression '~' constant_expression // CFA, integer subrange { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Range), $1, $3); } ; -asm_name_opt: /* GCC */ - /* empty */ +asm_name_opt: // GCC + // empty | ASM '(' string_literal_list ')' attribute_list_opt ; -attribute_list_opt: /* GCC */ - /* empty */ +attribute_list_opt: // GCC + // empty | attribute_list ; -attribute_list: /* GCC */ +attribute_list: // GCC attribute | attribute_list attribute ; -attribute: /* GCC */ +attribute: // GCC ATTRIBUTE '(' '(' attribute_parameter_list ')' ')' ; -attribute_parameter_list: /* GCC */ +attribute_parameter_list: // GCC attrib | attribute_parameter_list ',' attrib ; -attrib: /* GCC */ - /* empty */ +attrib: // GCC + // empty | any_word | any_word '(' comma_expression_opt ')' ; -any_word: /* GCC */ +any_word: // GCC identifier_or_typedef_name {} | storage_class_name {} @@ -2053,34 +2043,34 @@ ; -/* ============================================================================ - The following sections are a series of grammar patterns used to parse declarators. Multiple patterns are - necessary because the type of an identifier in wrapped around the identifier in the same form as its usage - in an expression, as in: - - int (*f())[10] { ... }; - ... (*f())[3] += 1; // definition mimics usage - - Because these patterns are highly recursive, changes at a lower level in the recursion require copying some - or all of the pattern. Each of these patterns has some subtle variation to ensure correct syntax in a - particular context. - ============================================================================ */ - -/* ---------------------------------------------------------------------------- - The set of valid declarators before a compound statement for defining a function is less than the set of - declarators to define a variable or function prototype, e.g.: - - valid declaration invalid definition - ----------------- ------------------ - int f; int f {} - int *f; int *f {} - int f[10]; int f[10] {} - int (*f)(int); int (*f)(int) {} - - To preclude this syntactic anomaly requires separating the grammar rules for variable and function - declarators, hence variable_declarator and function_declarator. - ---------------------------------------------------------------------------- */ - -/* This pattern parses a declaration of a variable that is not redefining a typedef name. The pattern - precludes declaring an array of functions versus a pointer to an array of functions. */ +// ============================================================================ +// The following sections are a series of grammar patterns used to parse declarators. Multiple patterns are +// necessary because the type of an identifier in wrapped around the identifier in the same form as its usage +// in an expression, as in: +// +// int (*f())[10] { ... }; +// ... (*f())[3] += 1; // definition mimics usage +// +// Because these patterns are highly recursive, changes at a lower level in the recursion require copying some +// or all of the pattern. Each of these patterns has some subtle variation to ensure correct syntax in a +// particular context. +// ============================================================================ + +// ---------------------------------------------------------------------------- +// The set of valid declarators before a compound statement for defining a function is less than the set of +// declarators to define a variable or function prototype, e.g.: +// +// valid declaration invalid definition +// ----------------- ------------------ +// int f; int f {} +// int *f; int *f {} +// int f[10]; int f[10] {} +// int (*f)(int); int (*f)(int) {} +// +// To preclude this syntactic anomaly requires separating the grammar rules for variable and function +// declarators, hence variable_declarator and function_declarator. +// ---------------------------------------------------------------------------- + +// This pattern parses a declaration of a variable that is not redefining a typedef name. The pattern +// precludes declaring an array of functions versus a pointer to an array of functions. variable_declarator: @@ -2097,5 +2087,5 @@ $$ = DeclarationNode::newName( $1 ); } - | '(' paren_identifier ')' /* redundant parenthesis */ + | '(' paren_identifier ')' // redundant parenthesis { $$ = $2; } ; @@ -2115,21 +2105,21 @@ | '(' variable_ptr ')' array_dimension { $$ = $2->addArray( $4 ); } - | '(' variable_array ')' multi_array_dimension /* redundant parenthesis */ + | '(' variable_array ')' multi_array_dimension // redundant parenthesis { $$ = $2->addArray( $4 ); } - | '(' variable_array ')' /* redundant parenthesis */ + | '(' variable_array ')' // redundant parenthesis { $$ = $2; } ; variable_function: - '(' variable_ptr ')' '(' push parameter_type_list_opt pop ')' /* empty parameter list OBSOLESCENT (see 3) */ + '(' variable_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) { $$ = $2->addParamList( $6 ); } - | '(' variable_function ')' /* redundant parenthesis */ - { $$ = $2; } - ; - -/* This pattern parses a function declarator that is not redefining a typedef name. Because functions cannot - be nested, there is no context where a function definition can redefine a typedef name. To allow nested - functions requires further separation of variable and function declarators in typedef_redeclarator. The - pattern precludes returning arrays and functions versus pointers to arrays and functions. */ + | '(' variable_function ')' // redundant parenthesis + { $$ = $2; } + ; + +// This pattern parses a function declarator that is not redefining a typedef name. Because functions cannot +// be nested, there is no context where a function definition can redefine a typedef name. To allow nested +// functions requires further separation of variable and function declarators in typedef_redeclarator. The +// pattern precludes returning arrays and functions versus pointers to arrays and functions. function_declarator: @@ -2140,9 +2130,9 @@ function_no_ptr: - paren_identifier '(' push parameter_type_list_opt pop ')' /* empty parameter list OBSOLESCENT (see 3) */ + 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 ); } - | '(' function_no_ptr ')' /* redundant parenthesis */ + | '(' function_no_ptr ')' // redundant parenthesis { $$ = $2; } ; @@ -2160,13 +2150,13 @@ '(' function_ptr ')' array_dimension { $$ = $2->addArray( $4 ); } - | '(' function_array ')' multi_array_dimension /* redundant parenthesis */ + | '(' function_array ')' multi_array_dimension // redundant parenthesis { $$ = $2->addArray( $4 ); } - | '(' function_array ')' /* redundant parenthesis */ - { $$ = $2; } - ; - -/* This pattern parses an old-style K&R function declarator (OBSOLESCENT, see 4) that is not redefining a - typedef name (see function_declarator for additional comments). The pattern precludes returning arrays and - functions versus pointers to arrays and functions. */ + | '(' function_array ')' // redundant parenthesis + { $$ = $2; } + ; + +// This pattern parses an old-style K&R function declarator (OBSOLESCENT, see 4) that is not redefining a +// typedef name (see function_declarator for additional comments). The pattern precludes returning arrays and +// functions versus pointers to arrays and functions. old_function_declarator: @@ -2177,9 +2167,9 @@ old_function_no_ptr: - paren_identifier '(' identifier_list ')' /* function_declarator handles empty parameter */ + paren_identifier '(' identifier_list ')' // function_declarator handles empty parameter { $$ = $1->addIdList( $3 ); } | '(' old_function_ptr ')' '(' identifier_list ')' { $$ = $2->addIdList( $5 ); } - | '(' old_function_no_ptr ')' /* redundant parenthesis */ + | '(' old_function_no_ptr ')' // redundant parenthesis { $$ = $2; } ; @@ -2197,19 +2187,19 @@ '(' old_function_ptr ')' array_dimension { $$ = $2->addArray( $4 ); } - | '(' old_function_array ')' multi_array_dimension /* redundant parenthesis */ + | '(' old_function_array ')' multi_array_dimension // redundant parenthesis { $$ = $2->addArray( $4 ); } - | '(' old_function_array ')' /* redundant parenthesis */ - { $$ = $2; } - ; - -/* This pattern parses a declaration for a variable or function prototype that redefines a typedef name, e.g.: - - typedef int foo; - { - int foo; // redefine typedef name in new scope - } - - The pattern precludes declaring an array of functions versus a pointer to an array of functions, and - returning arrays and functions versus pointers to arrays and functions. */ + | '(' old_function_array ')' // redundant parenthesis + { $$ = $2; } + ; + +// This pattern parses a declaration for a variable or function prototype that redefines a typedef name, e.g.: +// +// typedef int foo; +// { +// int foo; // redefine typedef name in new scope +// } +// +// The pattern precludes declaring an array of functions versus a pointer to an array of functions, and +// returning arrays and functions versus pointers to arrays and functions. typedef_redeclarator: @@ -2244,23 +2234,23 @@ | '(' typedef_ptr ')' array_dimension { $$ = $2->addArray( $4 ); } - | '(' typedef_array ')' multi_array_dimension /* redundant parenthesis */ + | '(' typedef_array ')' multi_array_dimension // redundant parenthesis { $$ = $2->addArray( $4 ); } - | '(' typedef_array ')' /* redundant parenthesis */ + | '(' typedef_array ')' // redundant parenthesis { $$ = $2; } ; typedef_function: - paren_typedef '(' push parameter_type_list_opt pop ')' /* empty parameter list OBSOLESCENT (see 3) */ + paren_typedef '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) { $$ = $1->addParamList( $4 ); } - | '(' typedef_ptr ')' '(' push parameter_type_list_opt pop ')' /* empty parameter list OBSOLESCENT (see 3) */ + | '(' typedef_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) { $$ = $2->addParamList( $6 ); } - | '(' typedef_function ')' /* redundant parenthesis */ - { $$ = $2; } - ; - -/* This pattern parses a declaration for a parameter variable or function prototype that is not redefining a - typedef name and allows the C99 array options, which can only appear in a parameter list. The pattern - precludes declaring an array of functions versus a pointer to an array of functions, and returning arrays - and functions versus pointers to arrays and functions. */ + | '(' typedef_function ')' // redundant parenthesis + { $$ = $2; } + ; + +// This pattern parses a declaration for a parameter variable or function prototype that is not redefining a +// typedef name and allows the C99 array options, which can only appear in a parameter list. The pattern +// precludes declaring an array of functions versus a pointer to an array of functions, and returning arrays +// and functions versus pointers to arrays and functions. identifier_parameter_declarator: @@ -2285,44 +2275,44 @@ | '(' identifier_parameter_ptr ')' array_dimension { $$ = $2->addArray( $4 ); } - | '(' identifier_parameter_array ')' multi_array_dimension /* redundant parenthesis */ + | '(' identifier_parameter_array ')' multi_array_dimension // redundant parenthesis { $$ = $2->addArray( $4 ); } - | '(' identifier_parameter_array ')' /* redundant parenthesis */ + | '(' identifier_parameter_array ')' // redundant parenthesis { $$ = $2; } ; identifier_parameter_function: - paren_identifier '(' push parameter_type_list_opt pop ')' /* empty parameter list OBSOLESCENT (see 3) */ + 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) */ + | '(' identifier_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) { $$ = $2->addParamList( $6 ); } - | '(' identifier_parameter_function ')' /* redundant parenthesis */ - { $$ = $2; } - ; - -/* This pattern parses a declaration for a parameter variable or function prototype that is redefining a - typedef name, e.g.: - - typedef int foo; - int f( int foo ); // redefine typedef name in new scope - - and allows the C99 array options, which can only appear in a parameter list. In addition, the pattern - handles the special meaning of parenthesis around a typedef name: - - ISO/IEC 9899:1999 Section 6.7.5.3(11) : "In a parameter declaration, a single typedef name in - parentheses is taken to be an abstract declarator that specifies a function with a single parameter, - not as redundant parentheses around the identifier." - - which precludes the following cases: - - typedef float T; - int f( int ( T [5] ) ); // see abstract_parameter_declarator - int g( int ( T ( int ) ) ); // see abstract_parameter_declarator - int f( int f1( T a[5] ) ); // see identifier_parameter_declarator - int g( int g1( T g2( int p ) ) ); // see identifier_parameter_declarator - - In essence, a '(' immediately to the left of typedef name, T, is interpreted as starting a parameter type - list, and not as redundant parentheses around a redeclaration of T. Finally, the pattern also precludes - declaring an array of functions versus a pointer to an array of functions, and returning arrays and - functions versus pointers to arrays and functions. */ + | '(' identifier_parameter_function ')' // redundant parenthesis + { $$ = $2; } + ; + +// This pattern parses a declaration for a parameter variable or function prototype that is redefining a typedef name, +// e.g.: +// +// typedef int foo; +// int f( int foo ); // redefine typedef name in new scope +// +// and allows the C99 array options, which can only appear in a parameter list. In addition, the pattern handles the +// special meaning of parenthesis around a typedef name: +// +// ISO/IEC 9899:1999 Section 6.7.5.3(11) : "In a parameter declaration, a single typedef name in +// parentheses is taken to be an abstract declarator that specifies a function with a single parameter, +// not as redundant parentheses around the identifier." +// +// which precludes the following cases: +// +// typedef float T; +// int f( int ( T [5] ) ); // see abstract_parameter_declarator +// int g( int ( T ( int ) ) ); // see abstract_parameter_declarator +// int f( int f1( T a[5] ) ); // see identifier_parameter_declarator +// int g( int g1( T g2( int p ) ) ); // see identifier_parameter_declarator +// +// In essence, a '(' immediately to the left of typedef name, T, is interpreted as starting a parameter type list, and +// not as redundant parentheses around a redeclaration of T. Finally, the pattern also precludes declaring an array of +// functions versus a pointer to an array of functions, and returning arrays and functions versus pointers to arrays and +// functions. typedef_parameter_redeclarator: @@ -2358,18 +2348,18 @@ typedef_parameter_function: - typedef '(' push parameter_type_list_opt pop ')' /* empty parameter list OBSOLESCENT (see 3) */ + typedef '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) { $$ = $1->addParamList( $4 ); } - | '(' typedef_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' /* empty parameter list OBSOLESCENT (see 3) */ + | '(' typedef_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) { $$ = $2->addParamList( $6 ); } ; -/* This pattern parses a declaration of an abstract variable or function prototype, i.e., there is no - identifier to which the type applies, e.g.: - - sizeof( int ); - sizeof( int [10] ); - - The pattern precludes declaring an array of functions versus a pointer to an array of functions, and - returning arrays and functions versus pointers to arrays and functions. */ +// This pattern parses a declaration of an abstract variable or function prototype, i.e., there is no identifier to +// which the type applies, e.g.: +// +// sizeof( int ); +// sizeof( int [10] ); +// +// The pattern precludes declaring an array of functions versus a pointer to an array of functions, and returning arrays +// and functions versus pointers to arrays and functions. abstract_declarator: @@ -2396,21 +2386,21 @@ | '(' abstract_ptr ')' array_dimension { $$ = $2->addArray( $4 ); } - | '(' abstract_array ')' multi_array_dimension /* redundant parenthesis */ + | '(' abstract_array ')' multi_array_dimension // redundant parenthesis { $$ = $2->addArray( $4 ); } - | '(' abstract_array ')' /* redundant parenthesis */ + | '(' abstract_array ')' // redundant parenthesis { $$ = $2; } ; abstract_function: - '(' push parameter_type_list_opt pop ')' /* empty parameter list OBSOLESCENT (see 3) */ + '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) { $$ = DeclarationNode::newFunction( 0, 0, $3, 0 ); } - | '(' abstract_ptr ')' '(' push parameter_type_list_opt pop ')' /* empty parameter list OBSOLESCENT (see 3) */ + | '(' abstract_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) { $$ = $2->addParamList( $6 ); } - | '(' abstract_function ')' /* redundant parenthesis */ + | '(' abstract_function ')' // redundant parenthesis { $$ = $2; } ; array_dimension: - /* Only the first dimension can be empty. */ + // Only the first dimension can be empty. '[' push pop ']' { $$ = DeclarationNode::newArray( 0, 0, false ); } @@ -2423,20 +2413,20 @@ '[' push assignment_expression pop ']' { $$ = DeclarationNode::newArray( $3, 0, false ); } - | '[' push '*' pop ']' /* C99 */ + | '[' push '*' pop ']' // C99 { $$ = DeclarationNode::newVarArray( 0 ); } | multi_array_dimension '[' push assignment_expression pop ']' { $$ = $1->addArray( DeclarationNode::newArray( $4, 0, false ) ); } - | multi_array_dimension '[' push '*' pop ']' /* C99 */ + | multi_array_dimension '[' push '*' pop ']' // C99 { $$ = $1->addArray( DeclarationNode::newVarArray( 0 ) ); } ; -/* This pattern parses a declaration of a parameter abstract variable or function prototype, i.e., there is no - identifier to which the type applies, e.g.: - - int f( int ); // abstract variable parameter; no parameter name specified - int f( int (int) ); // abstract function-prototype parameter; no parameter name specified - - The pattern precludes declaring an array of functions versus a pointer to an array of functions, and - returning arrays and functions versus pointers to arrays and functions. */ +// This pattern parses a declaration of a parameter abstract variable or function prototype, i.e., there is no +// identifier to which the type applies, e.g.: +// +// int f( int ); // abstract variable parameter; no parameter name specified +// int f( int (int) ); // abstract function-prototype parameter; no parameter name specified +// +// The pattern precludes declaring an array of functions versus a pointer to an array of functions, and returning arrays +// and functions versus pointers to arrays and functions. */ abstract_parameter_declarator: @@ -2463,21 +2453,21 @@ | '(' abstract_parameter_ptr ')' array_parameter_dimension { $$ = $2->addArray( $4 ); } - | '(' abstract_parameter_array ')' multi_array_dimension /* redundant parenthesis */ + | '(' abstract_parameter_array ')' multi_array_dimension // redundant parenthesis { $$ = $2->addArray( $4 ); } - | '(' abstract_parameter_array ')' /* redundant parenthesis */ + | '(' abstract_parameter_array ')' // redundant parenthesis { $$ = $2; } ; abstract_parameter_function: - '(' push parameter_type_list_opt pop ')' /* empty parameter list OBSOLESCENT (see 3) */ + '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) { $$ = DeclarationNode::newFunction( 0, 0, $3, 0 ); } - | '(' abstract_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' /* empty parameter list OBSOLESCENT (see 3) */ + | '(' abstract_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) { $$ = $2->addParamList( $6 ); } - | '(' abstract_parameter_function ')' /* redundant parenthesis */ + | '(' abstract_parameter_function ')' // redundant parenthesis { $$ = $2; } ; array_parameter_dimension: - /* Only the first dimension can be empty or have qualifiers. */ + // Only the first dimension can be empty or have qualifiers. array_parameter_1st_dimension | array_parameter_1st_dimension multi_array_dimension @@ -2486,9 +2476,8 @@ ; -/* The declaration of an array parameter has additional syntax over arrays in normal variable declarations: - - ISO/IEC 9899:1999 Section 6.7.5.2(1) : "The optional type qualifiers and the keyword static shall - appear only in a declaration of a function parameter with an array type, and then only in the - outermost array type derivation." */ +// The declaration of an array parameter has additional syntax over arrays in normal variable declarations: +// +// ISO/IEC 9899:1999 Section 6.7.5.2(1) : "The optional type qualifiers and the keyword static shall appear only in +// a declaration of a function parameter with an array type, and then only in the outermost array type derivation." array_parameter_1st_dimension: @@ -2496,5 +2485,5 @@ { $$ = DeclarationNode::newArray( 0, 0, false ); } // multi_array_dimension handles the '[' '*' ']' case - | '[' push type_qualifier_list '*' pop ']' /* remaining C99 */ + | '[' push type_qualifier_list '*' pop ']' // remaining C99 { $$ = DeclarationNode::newVarArray( $3 ); } | '[' push type_qualifier_list pop ']' @@ -2509,11 +2498,11 @@ ; -/* This pattern parses a declaration of an abstract variable, i.e., there is no identifier to which the type - applies, e.g.: - - sizeof( int ); // abstract variable; no identifier name specified - - The pattern precludes declaring an array of functions versus a pointer to an array of functions, and - returning arrays and functions versus pointers to arrays and functions. */ +// This pattern parses a declaration of an abstract variable, i.e., there is no identifier to which the type applies, +// e.g.: +// +// sizeof( int ); // abstract variable; no identifier name specified +// +// The pattern precludes declaring an array of functions versus a pointer to an array of functions, and returning arrays +// and functions versus pointers to arrays and functions. */ variable_abstract_declarator: @@ -2540,22 +2529,21 @@ | '(' variable_abstract_ptr ')' array_dimension { $$ = $2->addArray( $4 ); } - | '(' variable_abstract_array ')' multi_array_dimension /* redundant parenthesis */ + | '(' variable_abstract_array ')' multi_array_dimension // redundant parenthesis { $$ = $2->addArray( $4 ); } - | '(' variable_abstract_array ')' /* redundant parenthesis */ + | '(' variable_abstract_array ')' // redundant parenthesis { $$ = $2; } ; variable_abstract_function: - '(' variable_abstract_ptr ')' '(' push parameter_type_list_opt pop ')' /* empty parameter list OBSOLESCENT (see 3) */ + '(' variable_abstract_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) { $$ = $2->addParamList( $6 ); } - | '(' variable_abstract_function ')' /* redundant parenthesis */ - { $$ = $2; } - ; - -/* This pattern parses a new-style declaration for a parameter variable or function prototype that is either - an identifier or typedef name and allows the C99 array options, which can only appear in a parameter - list. */ - -new_identifier_parameter_declarator_tuple: /* CFA */ + | '(' variable_abstract_function ')' // redundant parenthesis + { $$ = $2; } + ; + +// This pattern parses a new-style declaration for a parameter variable or function prototype that is either an +// identifier or typedef name and allows the C99 array options, which can only appear in a parameter list. + +new_identifier_parameter_declarator_tuple: // CFA new_identifier_parameter_declarator_no_tuple | new_abstract_tuple @@ -2564,10 +2552,10 @@ ; -new_identifier_parameter_declarator_no_tuple: /* CFA */ +new_identifier_parameter_declarator_no_tuple: // CFA new_identifier_parameter_ptr | new_identifier_parameter_array ; -new_identifier_parameter_ptr: /* CFA */ +new_identifier_parameter_ptr: // CFA '*' type_specifier { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); } @@ -2584,7 +2572,7 @@ ; -new_identifier_parameter_array: /* CFA */ - /* Only the first dimension can be empty or have qualifiers. Empty dimension must be factored - out due to shift/reduce conflict with new-style empty (void) function return type. */ +new_identifier_parameter_array: // CFA + // Only the first dimension can be empty or have qualifiers. Empty dimension must be factored out due to + // shift/reduce conflict with new-style empty (void) function return type. */ '[' push pop ']' type_specifier { $$ = $5->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } @@ -2610,12 +2598,12 @@ new_array_parameter_1st_dimension: - '[' push type_qualifier_list '*' pop ']' /* remaining C99 */ + '[' push type_qualifier_list '*' pop ']' // remaining C99 { $$ = DeclarationNode::newVarArray( $3 ); } | '[' push type_qualifier_list assignment_expression pop ']' { $$ = DeclarationNode::newArray( $4, $3, false ); } | '[' push declaration_qualifier_list assignment_expression pop ']' - /* declaration_qualifier_list must be used because of shift/reduce conflict with - assignment_expression, so a semantic check is necessary to preclude them as a - type_qualifier cannot appear in this context. */ + // declaration_qualifier_list must be used because of shift/reduce conflict with assignment_expression, + // so a semantic check is necessary to preclude them as a type_qualifier cannot appear in this + // context. { $$ = DeclarationNode::newArray( $4, $3, true ); } | '[' push declaration_qualifier_list type_qualifier_list assignment_expression pop ']' @@ -2623,26 +2611,26 @@ ; -/* This pattern parses a new-style declaration of an abstract variable or function prototype, i.e., there is - no identifier to which the type applies, e.g.: - - [int] f( int ); // abstract variable parameter; no parameter name specified - [int] f( [int] (int) ); // abstract function-prototype parameter; no parameter name specified - - These rules need LR(3): - - new_abstract_tuple identifier_or_typedef_name - '[' new_parameter_list ']' identifier_or_typedef_name '(' new_parameter_type_list_opt ')' - - since a function return type can be syntactically identical to a tuple type: - - [int, int] t; - [int, int] f( int ); - - Therefore, it is necessary to look at the token after identifier_or_typedef_name to know when to reduce - new_abstract_tuple. To make this LR(1), several rules have to be flattened (lengthened) to allow - the necessary lookahead. To accomplish this, new_abstract_declarator has an entry point without tuple, and - tuple declarations are duplicated when appearing with new_function_specifier. */ - -new_abstract_declarator_tuple: /* CFA */ +// This pattern parses a new-style declaration of an abstract variable or function prototype, i.e., there is no +// identifier to which the type applies, e.g.: +// +// [int] f( int ); // abstract variable parameter; no parameter name specified +// [int] f( [int] (int) ); // abstract function-prototype parameter; no parameter name specified +// +// These rules need LR(3): +// +// new_abstract_tuple identifier_or_typedef_name +// '[' new_parameter_list ']' identifier_or_typedef_name '(' new_parameter_type_list_opt ')' +// +// since a function return type can be syntactically identical to a tuple type: +// +// [int, int] t; +// [int, int] f( int ); +// +// Therefore, it is necessary to look at the token after identifier_or_typedef_name to know when to reduce +// new_abstract_tuple. To make this LR(1), several rules have to be flattened (lengthened) to allow the necessary +// lookahead. To accomplish this, new_abstract_declarator has an entry point without tuple, and tuple declarations are +// duplicated when appearing with new_function_specifier. + +new_abstract_declarator_tuple: // CFA new_abstract_tuple | type_qualifier_list new_abstract_tuple @@ -2651,10 +2639,10 @@ ; -new_abstract_declarator_no_tuple: /* CFA */ +new_abstract_declarator_no_tuple: // CFA new_abstract_ptr | new_abstract_array ; -new_abstract_ptr: /* CFA */ +new_abstract_ptr: // CFA '*' type_specifier { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); } @@ -2671,7 +2659,7 @@ ; -new_abstract_array: /* CFA */ - /* Only the first dimension can be empty. Empty dimension must be factored out due to - shift/reduce conflict with empty (void) function return type. */ +new_abstract_array: // CFA + // Only the first dimension can be empty. Empty dimension must be factored out due to shift/reduce + // conflict with empty (void) function return type. '[' push pop ']' type_specifier { $$ = $5->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } @@ -2688,10 +2676,10 @@ ; -new_abstract_tuple: /* CFA */ +new_abstract_tuple: // CFA '[' push new_abstract_parameter_list pop ']' { $$ = DeclarationNode::newTuple( $3 ); } ; -new_abstract_function: /* CFA */ +new_abstract_function: // CFA '[' push pop ']' '(' new_parameter_type_list_opt ')' { $$ = DeclarationNode::newFunction( 0, DeclarationNode::newTuple( 0 ), $6, 0 ); } @@ -2702,27 +2690,25 @@ ; -/* 1) ISO/IEC 9899:1999 Section 6.7.2(2) : "At least one type specifier shall be given in the declaration - specifiers in each declaration, and in the specifier-qualifier list in each structure declaration and - type name." - - 2) ISO/IEC 9899:1999 Section 6.11.5(1) : "The placement of a storage-class specifier other than at the - beginning of the declaration specifiers in a declaration is an obsolescent feature." - - 3) ISO/IEC 9899:1999 Section 6.11.6(1) : "The use of function declarators with empty parentheses (not - prototype-format parameter type declarators) is an obsolescent feature." - - 4) ISO/IEC 9899:1999 Section 6.11.7(1) : "The use of function definitions with separate parameter - identifier and declaration lists (not prototype-format parameter type and identifier declarators) is - an obsolescent feature." */ - -/************************* MISCELLANEOUS ********************************/ - -comma_opt: /* redundant comma */ - /* empty */ +// 1) ISO/IEC 9899:1999 Section 6.7.2(2) : "At least one type specifier shall be given in the declaration specifiers in +// each declaration, and in the specifier-qualifier list in each structure declaration and type name." +// +// 2) ISO/IEC 9899:1999 Section 6.11.5(1) : "The placement of a storage-class specifier other than at the beginning of +// the declaration specifiers in a declaration is an obsolescent feature." +// +// 3) ISO/IEC 9899:1999 Section 6.11.6(1) : "The use of function declarators with empty parentheses (not +// prototype-format parameter type declarators) is an obsolescent feature." +// +// 4) ISO/IEC 9899:1999 Section 6.11.7(1) : "The use of function definitions with separate parameter identifier and +// declaration lists (not prototype-format parameter type and identifier declarators) is an obsolescent feature. + +//************************* MISCELLANEOUS ******************************** + +comma_opt: // redundant comma + // empty | ',' ; assignment_opt: - /* empty */ + // empty { $$ = 0; } | '=' assignment_expression @@ -2731,5 +2717,5 @@ %% -/* ----end of grammar----*/ +// ----end of grammar---- void yyerror( char *string ) { @@ -2743,6 +2729,6 @@ } -/* Local Variables: */ -/* fill-column: 110 */ -/* compile-command: "make install" */ -/* End: */ +// Local Variables: // +// fill-column: 110 // +// compile-command: "make install" // +// End: //