source: src/Parser/parser.yy @ a61fea9a

ADTaaron-thesisarm-ehast-experimentalcleanup-dtorsctordeferred_resndemanglerenumforall-pointer-decaygc_noraiijacob/cs343-translationjenkins-sandboxmemorynew-astnew-ast-unique-exprnew-envno_listpersistent-indexerpthread-emulationqualifiedEnumresolv-newstringwith_gc
Last change on this file since a61fea9a was a61fea9a, checked in by Peter A. Buhr <pabuhr@…>, 9 years ago

enable AM_MAINTAINER_MODE, add operator ?{}, formatting

  • Property mode set to 100644
File size: 98.7 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// cfa.y --
8//
9// Author           : Peter A. Buhr
10// Created On       : Sat Sep  1 20:22:55 2001
11// Last Modified By : Peter A. Buhr
12// Last Modified On : Wed Jun  3 22:03:06 2015
13// Update Count     : 1020
14//
15
16// This grammar is based on the ANSI99/11 C grammar, specifically parts of EXPRESSION and STATEMENTS, and on
17// the C grammar by James A. Roskind, specifically parts of DECLARATIONS and EXTERNAL DEFINITIONS.  While
18// parts have been copied, important changes have been made in all sections; these changes are sufficient to
19// constitute a new grammar.  In particular, this grammar attempts to be more syntactically precise, i.e., it
20// parses less incorrect language syntax that must be subsequently rejected by semantic checks.  Nevertheless,
21// there are still several semantic checks required and many are noted in the grammar. Finally, the grammar is
22// extended with GCC and CFA language extensions.
23
24// Acknowledgments to Richard Bilson, Glen Ditchfield, and Rodolfo Gabriel Esteves who all helped when I got
25// stuck with the grammar.
26
27// The root language for this grammar is ANSI99/11 C. All of ANSI99/11 is parsed, except for:
28//
29// 1. designation with '=' (use ':' instead)
30//
31// Most of the syntactic extensions from ANSI90 to ANSI11 C are marked with the comment "C99/C11". This
32// grammar also has two levels of extensions. The first extensions cover most of the GCC C extensions, except for:
33//
34// 1. nested functions
35// 2. generalized lvalues
36// 3. designation with and without '=' (use ':' instead)
37// 4. attributes not allowed in parenthesis of declarator
38//
39// All of the syntactic extensions for GCC C are marked with the comment "GCC". The second extensions are for
40// Cforall (CFA), which fixes several of C's outstanding problems and extends C with many modern language
41// concepts. All of the syntactic extensions for CFA C are marked with the comment "CFA". As noted above,
42// there is one unreconcileable parsing problem between C99 and CFA with respect to designators; this is
43// discussed in detail before the "designation" grammar rule.
44
45%{
46#define YYDEBUG_LEXER_TEXT (yylval)                                             // lexer loads this up each time
47#define YYDEBUG 1                                                                               // get the pretty debugging code to compile
48
49#undef __GNUC_MINOR__
50
51#include <cstdio>
52#include <stack>
53#include "TypedefTable.h"
54#include "lex.h"
55#include "ParseNode.h"
56#include "LinkageSpec.h"
57
58DeclarationNode *theTree = 0;                                                   // the resulting parse tree
59LinkageSpec::Type linkage = LinkageSpec::Cforall;
60std::stack< LinkageSpec::Type > linkageStack;
61TypedefTable typedefTable;
62%}
63
64//************************* TERMINAL TOKENS ********************************
65
66// keywords
67%token TYPEDEF
68%token AUTO EXTERN REGISTER STATIC
69%token INLINE                                                                                   // C99
70%token FORTRAN                                                                                  // C99, extension ISO/IEC 9899:1999 Section J.5.9(1)
71%token CONST VOLATILE
72%token RESTRICT                                                                                 // C99
73%token FORALL LVALUE                                                                    // CFA
74%token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED
75%token BOOL COMPLEX IMAGINARY                                                   // C99
76%token TYPEOF LABEL                                                                             // GCC
77%token ENUM STRUCT UNION
78%token TYPE FTYPE DTYPE CONTEXT                                                 // CFA
79%token SIZEOF
80%token ATTRIBUTE EXTENSION                                                              // GCC
81%token IF ELSE SWITCH CASE DEFAULT DO WHILE FOR BREAK CONTINUE GOTO RETURN
82%token CHOOSE FALLTHRU TRY CATCH FINALLY THROW                  // CFA
83%token ASM                                                                                              // C99, extension ISO/IEC 9899:1999 Section J.5.10(1)
84%token ALIGNAS ALIGNOF ATOMIC GENERIC NORETURN STATICASSERT THREADLOCAL // C11
85
86// names and constants: lexer differentiates between identifier and typedef names
87%token<tok> IDENTIFIER                  QUOTED_IDENTIFIER               TYPEDEFname                             TYPEGENname
88%token<tok> ATTR_IDENTIFIER             ATTR_TYPEDEFname                ATTR_TYPEGENname
89%token<tok> INTEGERconstant             FLOATINGconstant                CHARACTERconstant               STRINGliteral
90%token<tok> ZERO                                ONE                                             // CFA
91
92// multi-character operators
93%token ARROW                                                                                    // ->
94%token ICR DECR                                                                                 // ++   --
95%token LS RS                                                                                    // <<   >>
96%token LE GE EQ NE                                                                              // <=   >=      ==      !=
97%token ANDAND OROR                                                                              // &&   ||
98%token ELLIPSIS                                                                                 // ...
99
100%token MULTassign       DIVassign       MODassign                               // *=   /=      %=/
101%token PLUSassign       MINUSassign                                                     // +=   -=
102%token LSassign         RSassign                                                        // <<=  >>=
103%token ANDassign        ERassign        ORassign                                // &=   ^=      |=
104
105// Types declaration
106%union
107{
108        Token tok;
109        ParseNode *pn;
110        ExpressionNode *en;
111        DeclarationNode *decl;
112        DeclarationNode::TyCon aggKey;
113        DeclarationNode::TypeClass tclass;
114        StatementNode *sn;
115        ConstantNode *constant;
116        InitializerNode *in;
117}
118
119%type<tok> zero_one  identifier  no_attr_identifier  no_01_identifier
120%type<tok> identifier_or_typedef_name  no_attr_identifier_or_typedef_name  no_01_identifier_or_typedef_name
121%type<constant> string_literal_list
122
123// expressions
124%type<constant> constant
125%type<en> tuple                                                 tuple_expression_list
126%type<en> unary_operator                                assignment_operator
127%type<en> primary_expression                    postfix_expression                      unary_expression
128%type<en> cast_expression                               multiplicative_expression       additive_expression                     shift_expression
129%type<en> relational_expression                 equality_expression                     AND_expression                          exclusive_OR_expression
130%type<en> inclusive_OR_expression               logical_AND_expression          logical_OR_expression           conditional_expression
131%type<en> constant_expression                   assignment_expression           assignment_expression_opt
132%type<en> comma_expression                              comma_expression_opt
133%type<en> argument_expression_list              argument_expression                     for_control_expression          assignment_opt
134%type<en> subrange
135
136// statements
137%type<sn> labeled_statement                             compound_statement                      expression_statement            selection_statement
138%type<sn> iteration_statement                   jump_statement                          exception_statement                     asm_statement
139%type<sn> fall_through_opt                              fall_through
140%type<sn> statement                                             statement_list
141%type<sn> block_item_list                               block_item
142%type<sn> case_clause
143%type<en> case_value                                    case_value_list
144%type<sn> case_label                                    case_label_list
145%type<sn> switch_clause_list_opt                switch_clause_list                      choose_clause_list_opt          choose_clause_list
146%type<pn> handler_list                                  handler_clause                          finally_clause
147
148// declarations
149%type<decl> abstract_array abstract_declarator abstract_function abstract_parameter_array
150%type<decl> abstract_parameter_declaration abstract_parameter_declarator abstract_parameter_function
151%type<decl> abstract_parameter_ptr abstract_ptr
152
153%type<aggKey> aggregate_key
154%type<decl>  aggregate_name
155
156%type<decl> array_dimension array_parameter_1st_dimension array_parameter_dimension multi_array_dimension
157
158%type<decl> assertion assertion_list_opt
159
160%type<en>   bit_subrange_size_opt bit_subrange_size
161
162%type<decl> basic_declaration_specifier basic_type_name basic_type_specifier direct_type_name indirect_type_name
163
164%type<decl> context_declaration context_declaration_list context_declaring_list context_specifier
165
166%type<decl> declaration declaration_list declaration_list_opt declaration_qualifier_list
167%type<decl> declaration_specifier declarator declaring_list
168
169%type<decl> elaborated_type_name
170
171%type<decl> enumerator_list enum_name
172%type<en> enumerator_value_opt
173
174%type<decl> exception_declaration external_definition external_definition_list external_definition_list_opt
175
176%type<decl> field_declaration field_declaration_list field_declarator field_declaring_list
177%type<en> field field_list
178
179%type<decl> external_function_definition function_definition function_array function_declarator function_no_ptr function_ptr
180
181%type<decl> identifier_parameter_array identifier_parameter_declarator identifier_parameter_function
182%type<decl> identifier_parameter_ptr identifier_list
183
184%type<decl> new_abstract_array new_abstract_declarator_no_tuple new_abstract_declarator_tuple
185%type<decl> new_abstract_function new_abstract_parameter_declaration new_abstract_parameter_list
186%type<decl> new_abstract_ptr new_abstract_tuple
187
188%type<decl> new_array_parameter_1st_dimension
189
190%type<decl> new_context_declaring_list new_declaration new_field_declaring_list
191%type<decl> new_function_declaration new_function_return new_function_specifier
192
193%type<decl> new_identifier_parameter_array new_identifier_parameter_declarator_no_tuple
194%type<decl> new_identifier_parameter_declarator_tuple new_identifier_parameter_ptr
195
196%type<decl> new_parameter_declaration new_parameter_list new_parameter_type_list new_parameter_type_list_opt
197
198%type<decl> new_typedef_declaration new_variable_declaration new_variable_specifier
199
200%type<decl> old_declaration old_declaration_list old_declaration_list_opt old_function_array
201%type<decl> old_function_declarator old_function_no_ptr old_function_ptr
202
203%type<decl> parameter_declaration parameter_list parameter_type_list
204%type<decl> parameter_type_list_opt
205
206%type<decl> paren_identifier paren_typedef
207
208%type<decl> storage_class storage_class_name storage_class_list
209
210%type<decl> sue_declaration_specifier sue_type_specifier
211
212%type<tclass> type_class
213%type<decl> type_declarator type_declarator_name type_declaring_list
214
215%type<decl> typedef typedef_array typedef_declaration typedef_declaration_specifier typedef_expression
216%type<decl> typedef_function typedef_parameter_array typedef_parameter_function typedef_parameter_ptr
217%type<decl> typedef_parameter_redeclarator typedef_ptr typedef_redeclarator typedef_type_specifier
218%type<decl> typegen_declaration_specifier typegen_type_specifier
219
220%type<decl> type_name type_name_no_function
221%type<decl> type_parameter type_parameter_list
222
223%type<en> type_name_list
224
225%type<decl> type_qualifier type_qualifier_name type_qualifier_list type_qualifier_list_opt type_specifier
226
227%type<decl> variable_abstract_array variable_abstract_declarator variable_abstract_function
228%type<decl> variable_abstract_ptr variable_array variable_declarator variable_function variable_ptr
229
230// initializers
231%type<in>  initializer initializer_list initializer_opt
232
233// designators
234%type<en>  designator designator_list designation
235
236
237// Handle single shift/reduce conflict for dangling else by shifting the ELSE token. For example, this string
238// is ambiguous:
239// .---------.                          matches IF '(' comma_expression ')' statement
240// if ( C ) S1 else S2
241// `-----------------'          matches IF '(' comma_expression ')' statement ELSE statement */
242
243%nonassoc THEN  // rule precedence for IF '(' comma_expression ')' statement
244%nonassoc ELSE  // token precedence for start of else clause in IF statement
245
246%start translation_unit                                                                 // parse-tree root
247
248%%
249//************************* Namespace Management ********************************
250
251// The grammar in the ANSI C standard is not strictly context-free, since it relies upon the distinct terminal
252// symbols "identifier" and "TYPEDEFname" that are lexically identical.  While it is possible to write a
253// purely context-free grammar, such a grammar would obscure the relationship between syntactic and semantic
254// constructs.  Hence, this grammar uses the ANSI style.
255//
256// Cforall compounds this problem by introducing type names local to the scope of a declaration (for instance,
257// those introduced through "forall" qualifiers), and by introducing "type generators" -- parametrized types.
258// This latter type name creates a third class of identifiers that must be distinguished by the scanner.
259//
260// Since the scanner cannot distinguish among the different classes of identifiers without some context
261// information, it accesses a data structure (the TypedefTable) to allow classification of an identifier that
262// it has just read.  Semantic actions during the parser update this data structure when the class of
263// identifiers change.
264//
265// Because the Cforall language is block-scoped, there is the possibility that an identifier can change its
266// class in a local scope; it must revert to its original class at the end of the block.  Since type names can
267// be local to a particular declaration, each declaration is itself a scope.  This requires distinguishing
268// between type names that are local to the current declaration scope and those that persist past the end of
269// the declaration (i.e., names defined in "typedef" or "type" declarations).
270//
271// The non-terminals "push" and "pop" derive the empty string; their only use is to denote the opening and
272// closing of scopes.  Every push must have a matching pop, although it is regrettable the matching pairs do
273// not always occur within the same rule.  These non-terminals may appear in more contexts than strictly
274// necessary from a semantic point of view.  Unfortunately, these extra rules are necessary to prevent parsing
275// conflicts -- the parser may not have enough context and look-ahead information to decide whether a new
276// scope is necessary, so the effect of these extra rules is to open a new scope unconditionally.  As the
277// grammar evolves, it may be neccesary to add or move around "push" and "pop" nonterminals to resolve
278// conflicts of this sort.
279
280push:
281                {
282                        typedefTable.enterScope();
283                }
284        ;
285
286pop:
287                {
288                        typedefTable.leaveScope();
289                }
290        ;
291
292//************************* CONSTANTS ********************************
293
294constant:
295                // ENUMERATIONconstant is not included here; it is treated as a variable with type
296                // "enumeration constant".
297        INTEGERconstant                                                         { $$ = new ConstantNode(ConstantNode::Integer, $1); }
298        | FLOATINGconstant                                                      { $$ = new ConstantNode(ConstantNode::Float, $1); }
299        | CHARACTERconstant                                                     { $$ = new ConstantNode(ConstantNode::Character, $1); }
300        ;
301
302identifier:
303        IDENTIFIER
304        | ATTR_IDENTIFIER                                                                       // CFA
305        | zero_one                                                                                      // CFA
306        ;
307
308no_01_identifier:
309        IDENTIFIER
310        | ATTR_IDENTIFIER                                                                       // CFA
311        ;
312
313no_attr_identifier:
314        IDENTIFIER
315        ;
316
317zero_one:                                                                                               // CFA
318        ZERO
319        | ONE
320        ;
321
322string_literal_list:                                                                    // juxtaposed strings are concatenated
323        STRINGliteral                                                           { $$ = new ConstantNode(ConstantNode::String, $1); }
324        | string_literal_list STRINGliteral                     { $$ = $1->append( $2 ); }
325        ;
326
327//************************* EXPRESSIONS ********************************
328
329primary_expression:
330        IDENTIFIER                                                                                      // typedef name cannot be used as a variable name
331                { $$ = new VarRefNode($1); }
332        | zero_one
333                { $$ = new VarRefNode($1); }
334        | constant
335                { $$ = $1; }
336        | string_literal_list
337                { $$ = $1; }
338        | '(' comma_expression ')'
339                { $$ = $2; }
340        | '(' compound_statement ')'                                            // GCC, lambda expression
341                { $$ = new ValofExprNode($2); }
342        ;
343
344postfix_expression:
345        primary_expression
346        | postfix_expression '[' push assignment_expression pop ']'
347                // CFA, comma_expression disallowed in the context because it results in a commom user error:
348                // subscripting a matrix with x[i,j] instead of x[i][j]. While this change is not backwards
349                // compatible, there seems to be little advantage to this feature and many disadvantages. It is
350                // possible to write x[(i,j)] in CFA, which is equivalent to the old x[i,j].
351                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Index), $1, $4); }
352        | postfix_expression '(' argument_expression_list ')'
353                { $$ = new CompositeExprNode($1, $3); }
354        | postfix_expression '.' no_attr_identifier
355                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::FieldSel), $1, new VarRefNode($3)); }
356        | postfix_expression '.' '[' push field_list pop ']' // CFA, tuple field selector
357        | postfix_expression ARROW no_attr_identifier
358                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::PFieldSel), $1, new VarRefNode($3)); }
359        | postfix_expression ARROW '[' push field_list pop ']' // CFA, tuple field selector
360        | postfix_expression ICR
361                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::IncrPost), $1); }
362        | postfix_expression DECR
363                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::DecrPost), $1); }
364                // GCC has priority: cast_expression
365        | '(' type_name_no_function ')' '{' initializer_list comma_opt '}' // C99
366                { $$ = 0; }
367        ;
368
369argument_expression_list:
370        argument_expression
371        | argument_expression_list ',' argument_expression
372                { $$ = (ExpressionNode *)($1->set_link($3)); }
373        ;
374
375argument_expression:
376        // empty
377                { $$ = 0; }                                                                             // use default argument
378        | assignment_expression
379        | no_attr_identifier ':' assignment_expression
380                { $$ = $3->set_asArgName($1); }
381                // Only a list of no_attr_identifier_or_typedef_name is allowed in this context. However, there is
382                // insufficient look ahead to distinguish between this list of parameter names and a tuple, so the
383                // tuple form must be used with an appropriate semantic check.
384        | '[' push assignment_expression pop ']' ':' assignment_expression
385                { $$ = $7->set_asArgName($3); }
386        | '[' push assignment_expression ',' tuple_expression_list pop ']' ':' assignment_expression
387                { $$ = $9->set_asArgName( new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)$3->set_link( flattenCommas( $5 )))); }
388        ;
389
390field_list:                                                                                             // CFA, tuple field selector
391        field
392        | field_list ',' field                                          { $$ = (ExpressionNode *)$1->set_link( $3 ); }
393        ;
394
395field:                                                                                                  // CFA, tuple field selector
396        no_attr_identifier
397                { $$ = new VarRefNode( $1 ); }
398        | no_attr_identifier '.' field
399                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::FieldSel), new VarRefNode( $1 ), $3); }
400        | no_attr_identifier '.' '[' push field_list pop ']'
401                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::FieldSel), new VarRefNode( $1 ), $5); }
402        | no_attr_identifier ARROW field
403                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::PFieldSel), new VarRefNode( $1 ), $3); }
404        | no_attr_identifier ARROW '[' push field_list pop ']'
405                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::PFieldSel), new VarRefNode( $1 ), $5); }
406        ;
407
408unary_expression:
409        postfix_expression
410        | ICR unary_expression
411                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Incr), $2); }
412        | DECR unary_expression
413                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Decr), $2); }
414        | EXTENSION cast_expression                                                     // GCC
415                { $$ = $2; }
416        | unary_operator cast_expression
417                { $$ = new CompositeExprNode($1, $2); }
418        | '!' cast_expression
419                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Neg), $2); }
420        | '*' cast_expression                                                           // CFA
421                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::PointTo), $2); }
422                // '*' is is separated from unary_operator because of shift/reduce conflict in:
423                //              { * X; } // dereference X
424                //              { * int X; } // CFA declaration of pointer to int
425                // '&' must be moved here if C++ reference variables are supported.
426        | SIZEOF unary_expression
427                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::SizeOf), $2); }
428        | SIZEOF '(' type_name_no_function ')'
429                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::SizeOf), new TypeValueNode($3)); }
430        | ATTR_IDENTIFIER
431                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Attr), new VarRefNode($1)); }
432        | ATTR_IDENTIFIER '(' type_name ')'
433                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Attr), new VarRefNode($1), new TypeValueNode($3)); }
434        | ATTR_IDENTIFIER '(' argument_expression ')'
435                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Attr), new VarRefNode($1), $3); }
436        | ALIGNOF unary_expression                                                      // GCC, variable alignment
437                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::AlignOf), $2); }
438        | ALIGNOF '(' type_name_no_function ')'                         // GCC, type alignment
439                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::AlignOf), new TypeValueNode($3)); }
440        | ANDAND no_attr_identifier                                                     // GCC, address of label
441                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::LabelAddress), new VarRefNode($2, true)); }
442        ;
443
444unary_operator:
445        '&'                                                                                     { $$ = new OperatorNode(OperatorNode::AddressOf); }
446        | '+'                                                                           { $$ = new OperatorNode(OperatorNode::UnPlus); }
447        | '-'                                                                           { $$ = new OperatorNode(OperatorNode::UnMinus); }
448        | '~'                                                                           { $$ = new OperatorNode(OperatorNode::BitNeg); }
449        ;
450
451cast_expression:
452        unary_expression
453        | '(' type_name_no_function ')' cast_expression
454                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Cast), new TypeValueNode($2), $4); }
455        | '(' type_name_no_function ')' tuple
456                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Cast), new TypeValueNode($2), $4); }
457        ;
458
459multiplicative_expression:
460        cast_expression
461        | multiplicative_expression '*' cast_expression
462                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Mul),$1,$3); }
463        | multiplicative_expression '/' cast_expression
464                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Div),$1,$3); }
465        | multiplicative_expression '%' cast_expression
466                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Mod),$1,$3); }
467        ;
468
469additive_expression:
470        multiplicative_expression
471        | additive_expression '+' multiplicative_expression
472                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Plus),$1,$3); }
473        | additive_expression '-' multiplicative_expression
474                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Minus),$1,$3); }
475        ;
476
477shift_expression:
478        additive_expression
479        | shift_expression LS additive_expression
480                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::LShift),$1,$3); }
481        | shift_expression RS additive_expression
482                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::RShift),$1,$3); }
483        ;
484
485relational_expression:
486        shift_expression
487        | relational_expression '<' shift_expression
488                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::LThan),$1,$3); }
489        | relational_expression '>' shift_expression
490                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::GThan),$1,$3); }
491        | relational_expression LE shift_expression
492                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::LEThan),$1,$3); }
493        | relational_expression GE shift_expression
494                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::GEThan),$1,$3); }
495        ;
496
497equality_expression:
498        relational_expression
499        | equality_expression EQ relational_expression
500                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Eq), $1, $3); }
501        | equality_expression NE relational_expression
502                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Neq), $1, $3); }
503        ;
504
505AND_expression:
506        equality_expression
507        | AND_expression '&' equality_expression
508                { $$ =new CompositeExprNode(new OperatorNode(OperatorNode::BitAnd), $1, $3); }
509        ;
510
511exclusive_OR_expression:
512        AND_expression
513        | exclusive_OR_expression '^' AND_expression
514                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Xor), $1, $3); }
515        ;
516
517inclusive_OR_expression:
518        exclusive_OR_expression
519        | inclusive_OR_expression '|' exclusive_OR_expression
520                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::BitOr), $1, $3); }
521        ;
522
523logical_AND_expression:
524        inclusive_OR_expression
525        | logical_AND_expression ANDAND inclusive_OR_expression
526                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::And), $1, $3); }
527        ;
528
529logical_OR_expression:
530        logical_AND_expression
531        | logical_OR_expression OROR logical_AND_expression
532                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Or), $1, $3); }
533        ;
534
535conditional_expression:
536        logical_OR_expression
537        | logical_OR_expression '?' comma_expression ':' conditional_expression
538                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Cond), (ExpressionNode *)mkList((*$1,*$3,*$5))); }
539        | logical_OR_expression '?' /* empty */ ':' conditional_expression // GCC, omitted first operand
540                { $$=new CompositeExprNode(new OperatorNode(OperatorNode::NCond),$1,$4); }
541        | logical_OR_expression '?' comma_expression ':' tuple // CFA, tuple expression
542                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Cond), (ExpressionNode *)mkList(( *$1, *$3, *$5 ))); }
543        ;
544
545constant_expression:
546        conditional_expression
547        ;
548
549assignment_expression:
550                // CFA, assignment is separated from assignment_operator to ensure no assignment operations for tuples
551        conditional_expression
552        | unary_expression '=' assignment_expression
553                { $$ =new CompositeExprNode(new OperatorNode(OperatorNode::Assign), $1, $3); }
554        | unary_expression assignment_operator assignment_expression
555                { $$ =new CompositeExprNode($2, $1, $3); }
556        | tuple assignment_opt                                                          // CFA, tuple expression
557                { $$ = ($2 == 0) ? $1 : new CompositeExprNode( new OperatorNode( OperatorNode::Assign ), $1, $2 ); }
558        ;
559
560assignment_expression_opt:
561        // empty
562                { $$ = new NullExprNode; }
563        | assignment_expression
564        ;
565
566tuple:                                                                                                  // CFA, tuple
567                // CFA, one assignment_expression is factored out of comma_expression to eliminate a shift/reduce
568                // conflict with comma_expression in new_identifier_parameter_array and new_abstract_array
569        '[' push pop ']'
570                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ) ); }
571        | '[' push assignment_expression pop ']'
572                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), $3 ); }
573        | '[' push ',' tuple_expression_list pop ']'
574                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)(new NullExprNode)->set_link( $4 ) ); }
575        | '[' push assignment_expression ',' tuple_expression_list pop ']'
576                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)$3->set_link( flattenCommas( $5 ) ) ); }
577        ;
578
579tuple_expression_list:
580        assignment_expression_opt
581        | tuple_expression_list ',' assignment_expression_opt
582                { $$ = (ExpressionNode *)$1->set_link( $3 ); }
583        ;
584
585assignment_operator:
586        MULTassign                                                                      { $$ = new OperatorNode(OperatorNode::MulAssn); }
587        | DIVassign                                                                     { $$ = new OperatorNode(OperatorNode::DivAssn); }
588        | MODassign                                                                     { $$ = new OperatorNode(OperatorNode::ModAssn); }
589        | PLUSassign                                                            { $$ = new OperatorNode(OperatorNode::PlusAssn); }
590        | MINUSassign                                                           { $$ = new OperatorNode(OperatorNode::MinusAssn); }
591        | LSassign                                                                      { $$ = new OperatorNode(OperatorNode::LSAssn); }
592        | RSassign                                                                      { $$ = new OperatorNode(OperatorNode::RSAssn); }
593        | ANDassign                                                                     { $$ = new OperatorNode(OperatorNode::AndAssn); }
594        | ERassign                                                                      { $$ = new OperatorNode(OperatorNode::ERAssn); }
595        | ORassign                                                                      { $$ = new OperatorNode(OperatorNode::OrAssn); }
596        ;
597
598comma_expression:
599        assignment_expression
600        | comma_expression ',' assignment_expression    // { $$ = (ExpressionNode *)$1->add_to_list($3); }
601                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Comma),$1,$3); }
602        ;
603
604comma_expression_opt:
605        // empty
606                { $$ = 0; }
607        | comma_expression
608        ;
609
610//*************************** STATEMENTS *******************************
611
612statement:
613        labeled_statement
614        | compound_statement
615        | expression_statement                                          { $$ = $1; }
616        | selection_statement
617        | iteration_statement
618        | jump_statement
619        | exception_statement
620        | asm_statement
621        ;
622
623labeled_statement:
624        no_attr_identifier ':' attribute_list_opt statement
625                { $$ = $4->add_label($1);}
626        ;
627
628compound_statement:
629        '{' '}'
630                { $$ = new CompoundStmtNode( (StatementNode *)0 ); }
631        | '{'
632                // Two scopes are necessary because the block itself has a scope, but every declaration within the
633                // block also requires its own scope
634          push push
635          label_declaration_opt                                                         // GCC, local labels
636          block_item_list pop '}'                                                       // C99, intermix declarations and statements
637                { $$ = new CompoundStmtNode( $5 ); }
638        ;
639
640block_item_list:                                                                                // C99
641        block_item
642        | block_item_list push block_item
643                { if ($1 != 0) { $1->set_link($3); $$ = $1; } }
644        ;
645
646block_item:
647        declaration                                                                                     // CFA, new & old style declarations
648                { $$ = new StatementNode( $1 ); }
649        | EXTENSION declaration                                                         // GCC
650                { $$ = new StatementNode( $2 ); }
651        | function_definition
652                { $$ = new StatementNode( $1 ); }
653        | statement pop
654        ;
655
656statement_list:
657        statement
658        | statement_list statement
659                { if ($1 != 0) { $1->set_link($2); $$ = $1; } }
660        ;
661
662expression_statement:
663        comma_expression_opt ';'
664                { $$ = new StatementNode(StatementNode::Exp, $1, 0); }
665        ;
666
667selection_statement:
668        IF '(' comma_expression ')' statement                           %prec THEN
669                // explicitly deal with the shift/reduce conflict on if/else
670                { $$ = new StatementNode(StatementNode::If, $3, $5); }
671        | IF '(' comma_expression ')' statement ELSE statement
672                { $$ = new StatementNode(StatementNode::If, $3, (StatementNode *)mkList((*$5, *$7)) ); }
673        | SWITCH '(' comma_expression ')' case_clause           // CFA
674                { $$ = new StatementNode(StatementNode::Switch, $3, $5); }
675        | SWITCH '(' comma_expression ')' '{' push declaration_list_opt switch_clause_list_opt '}' // CFA
676                { $$ = new StatementNode(StatementNode::Switch, $3, $8); /* xxx */ }
677                // The semantics of the declaration list is changed to include any associated initialization, which is
678                // performed *before* the transfer to the appropriate case clause.  Statements after the initial
679                // declaration list can never be executed, and therefore, are removed from the grammar even though C
680                // allows it.
681        | CHOOSE '(' comma_expression ')' case_clause           // CFA
682                { $$ = new StatementNode(StatementNode::Choose, $3, $5); }
683        | CHOOSE '(' comma_expression ')' '{' push declaration_list_opt choose_clause_list_opt '}' // CFA
684                { $$ = new StatementNode(StatementNode::Choose, $3, $8); }
685        ;
686
687// CASE and DEFAULT clauses are only allowed in the SWITCH statement, precluding Duff's device. In addition, a
688// case clause allows a list of values and subranges.
689
690case_value:                                                                                             // CFA
691        constant_expression                                                     { $$ = $1; }
692        | constant_expression ELLIPSIS constant_expression      // GCC, subrange
693                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Range),$1,$3); }
694        | subrange                                                                                      // CFA, subrange
695        ;
696
697case_value_list:                                                                                // CFA
698        case_value
699        | case_value_list ',' case_value
700                { $$ = new CompositeExprNode(new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)(tupleContents($1))->set_link($3) ); }
701        ;
702
703case_label:                                                                                             // CFA
704        CASE case_value_list ':'                                        { $$ = new StatementNode(StatementNode::Case, $2, 0); }
705        | DEFAULT ':'                                                           { $$ = new StatementNode(StatementNode::Default); }
706                // A semantic check is required to ensure only one default clause per switch/choose statement.
707        ;
708
709case_label_list:                                                                                // CFA
710        case_label
711        | case_label_list case_label                            { $$ = (StatementNode *)($1->set_link($2)); }
712        ;
713
714case_clause:                                                                                    // CFA
715        case_label_list statement                                       { $$ = $1->append_last_case($2); }
716        ;
717
718switch_clause_list_opt:                                                                 // CFA
719        // empty
720                { $$ = 0; }
721        | switch_clause_list
722        ;
723
724switch_clause_list:                                                                             // CFA
725        case_label_list statement_list
726                { $$ = $1->append_last_case($2); }
727        | switch_clause_list case_label_list statement_list
728                { $$ = (StatementNode *)($1->set_link($2->append_last_case($3))); }
729        ;
730
731choose_clause_list_opt:                                                                 // CFA
732        // empty
733                { $$ = 0; }
734        | choose_clause_list
735        ;
736
737choose_clause_list:                                                                             // CFA
738        case_label_list fall_through
739                { $$ = $1->append_last_case($2); }
740        | case_label_list statement_list fall_through_opt
741                { $$ = $1->append_last_case((StatementNode *)mkList((*$2,*$3))); }
742        | choose_clause_list case_label_list fall_through
743                { $$ = (StatementNode *)($1->set_link($2->append_last_case($3))); }
744        | choose_clause_list case_label_list statement_list fall_through_opt
745                { $$ = (StatementNode *)($1->set_link($2->append_last_case((StatementNode *)mkList((*$3,*$4))))); }
746        ;
747
748fall_through_opt:                                                                               // CFA
749        // empty
750                { $$ = 0; }
751        | fall_through
752        ;
753
754fall_through:                                                                                   // CFA
755        FALLTHRU                                                                        { $$ = new StatementNode(StatementNode::Fallthru, 0, 0); }
756        | FALLTHRU ';'                                                          { $$ = new StatementNode(StatementNode::Fallthru, 0, 0); }
757        ;
758
759iteration_statement:
760        WHILE '(' comma_expression ')' statement
761                { $$ = new StatementNode(StatementNode::While, $3, $5); }
762        | DO statement WHILE '(' comma_expression ')' ';'
763                { $$ = new StatementNode(StatementNode::Do, $5, $2); }
764        | FOR '(' push for_control_expression ')' statement
765                { $$ = new StatementNode(StatementNode::For, $4, $6); }
766        ;
767
768for_control_expression:
769        comma_expression_opt pop ';' comma_expression_opt ';' comma_expression_opt
770                { $$ = new ForCtlExprNode($1, $4, $6); }
771        | declaration comma_expression_opt ';' comma_expression_opt // C99
772                { $$ = new ForCtlExprNode($1, $2, $4); }
773        ;
774
775jump_statement:
776        GOTO no_attr_identifier ';'
777                { $$ = new StatementNode(StatementNode::Goto, $2); }
778        | GOTO '*' comma_expression ';'                                         // GCC, computed goto
779                // The syntax for the GCC computed goto violates normal expression precedence, e.g., goto *i+3; =>
780                // goto *(i+3); whereas normal operator precedence yields goto (*i)+3;
781                { $$ = new StatementNode(StatementNode::Goto, $3); }
782        | CONTINUE ';'
783                // A semantic check is required to ensure this statement appears only in the body of an iteration
784                // statement.
785                { $$ = new StatementNode(StatementNode::Continue, 0, 0); }
786        | CONTINUE no_attr_identifier ';'                                       // CFA, multi-level continue
787                // A semantic check is required to ensure this statement appears only in the body of an iteration
788                // statement, and the target of the transfer appears only at the start of an iteration statement.
789                { $$ = new StatementNode(StatementNode::Continue, $2); }
790        | BREAK ';'
791                // A semantic check is required to ensure this statement appears only in the body of an iteration
792                // statement.
793                { $$ = new StatementNode(StatementNode::Break, 0, 0); }
794        | BREAK no_attr_identifier ';'                                          // CFA, multi-level exit
795                // A semantic check is required to ensure this statement appears only in the body of an iteration
796                // statement, and the target of the transfer appears only at the start of an iteration statement.
797                { $$ = new StatementNode(StatementNode::Break, $2 ); }
798        | RETURN comma_expression_opt ';'
799                { $$ = new StatementNode(StatementNode::Return, $2, 0); }
800        | THROW assignment_expression ';'
801                { $$ = new StatementNode(StatementNode::Throw, $2, 0); }
802        | THROW ';'
803                { $$ = new StatementNode(StatementNode::Throw, 0, 0); }
804        ;
805
806exception_statement:
807        TRY compound_statement handler_list
808                { $$ = new StatementNode(StatementNode::Try, 0,(StatementNode *)(mkList((*$2,*$3)))); }
809        | TRY compound_statement finally_clause
810                { $$ = new StatementNode(StatementNode::Try, 0,(StatementNode *)(mkList((*$2,*$3)))); }
811        | TRY compound_statement handler_list finally_clause
812                {
813                        $3->set_link($4);
814                        $$ = new StatementNode(StatementNode::Try, 0,(StatementNode *)(mkList((*$2,*$3))));
815                }
816        ;
817
818handler_list:
819                // There must be at least one catch clause
820        handler_clause
821                // ISO/IEC 9899:1999 Section 15.3(6) If present, a "..." handler shall be the last handler for its try
822                // block.
823        | CATCH '(' ELLIPSIS ')' compound_statement
824                { $$ = StatementNode::newCatchStmt( 0, $5, true ); }
825        | handler_clause CATCH '(' ELLIPSIS ')' compound_statement
826                { $$ = $1->set_link( StatementNode::newCatchStmt( 0, $6, true ) ); }
827        ;
828
829handler_clause:
830        CATCH '(' push push exception_declaration pop ')' compound_statement pop
831                { $$ = StatementNode::newCatchStmt($5, $8); }
832        | handler_clause CATCH '(' push push exception_declaration pop ')' compound_statement pop
833                { $$ = $1->set_link( StatementNode::newCatchStmt($6, $9) ); }
834        ;
835
836finally_clause:
837        FINALLY compound_statement
838                {
839                        $$ = new StatementNode(StatementNode::Finally, 0, $2);
840                        std::cout << "Just created a finally node" << std::endl;
841                }
842        ;
843
844exception_declaration:
845                // A semantic check is required to ensure type_specifier does not create a new type, e.g.:
846                //
847                //              catch ( struct { int i; } x ) ...
848                //
849                // This new type cannot catch any thrown type because of name equivalence among types.
850        type_specifier
851        | type_specifier declarator
852                {
853                        typedefTable.addToEnclosingScope( TypedefTable::ID );
854                        $$ = $2->addType( $1 );
855                }
856        | type_specifier variable_abstract_declarator
857                { $$ = $2->addType( $1 ); }
858        | new_abstract_declarator_tuple no_attr_identifier      // CFA
859                {
860                        typedefTable.addToEnclosingScope( TypedefTable::ID );
861                        $$ = $1->addName( $2 );
862                }
863        | new_abstract_declarator_tuple                                         // CFA
864        ;
865
866asm_statement:
867        ASM type_qualifier_list_opt '(' constant_expression ')' ';'
868                { $$ = new StatementNode(StatementNode::Asm, 0, 0); }
869        | ASM type_qualifier_list_opt '(' constant_expression ':' asm_operands_opt ')' ';' // remaining GCC
870                { $$ = new StatementNode(StatementNode::Asm, 0, 0); }
871        | ASM type_qualifier_list_opt '(' constant_expression ':' asm_operands_opt ':' asm_operands_opt ')' ';'
872                { $$ = new StatementNode(StatementNode::Asm, 0, 0); }
873        | ASM type_qualifier_list_opt '(' constant_expression ':' asm_operands_opt ':' asm_operands_opt ':' asm_clobbers_list ')' ';'
874                { $$ = new StatementNode(StatementNode::Asm, 0, 0); }
875        ;
876
877asm_operands_opt:                                                                               // GCC
878        // empty
879        | asm_operands_list
880        ;
881
882asm_operands_list:                                                                              // GCC
883        asm_operand
884        | asm_operands_list ',' asm_operand
885        ;
886
887asm_operand:                                                                                    // GCC
888        STRINGliteral '(' constant_expression ')'               {}
889        ;
890
891asm_clobbers_list:                                                                              // GCC
892        STRINGliteral                                                           {}
893        | asm_clobbers_list ',' STRINGliteral
894        ;
895
896//******************************* DECLARATIONS *********************************
897
898declaration_list_opt:                                                                   // used at beginning of switch statement
899        pop
900                { $$ = 0; }
901        | declaration_list
902        ;
903
904declaration_list:
905        declaration
906        | declaration_list push declaration
907                { $$ = $1->appendList( $3 ); }
908        ;
909
910old_declaration_list_opt:                                                               // used to declare parameter types in K&R style functions
911        pop
912                { $$ = 0; }
913        | old_declaration_list
914        ;
915
916old_declaration_list:
917        old_declaration
918        | old_declaration_list push old_declaration
919                { $$ = $1->appendList( $3 ); }
920        ;
921
922label_declaration_opt:                                                                  // GCC, local label
923        // empty
924        | label_declaration_list
925        ;
926
927label_declaration_list:                                                                 // GCC, local label
928        LABEL label_list ';'
929        | label_declaration_list LABEL label_list ';'
930        ;
931
932label_list:                                                                                             // GCC, local label
933        no_attr_identifier_or_typedef_name                      {}
934        | label_list ',' no_attr_identifier_or_typedef_name {}
935        ;
936
937declaration:                                                                                    // CFA, new & old style declarations
938        new_declaration
939        | old_declaration
940        ;
941
942// C declaration syntax is notoriously confusing and error prone. Cforall provides its own type, variable and
943// function declarations. CFA declarations use the same declaration tokens as in C; however, CFA places
944// declaration modifiers to the left of the base type, while C declarations place modifiers to the right of
945// the base type. CFA declaration modifiers are interpreted from left to right and the entire type
946// specification is distributed across all variables in the declaration list (as in Pascal).  ANSI C and the
947// new CFA declarations may appear together in the same program block, but cannot be mixed within a specific
948// declaration.
949//
950//                      CFA                                     C
951//              [10] int x;                     int x[10];              // array of 10 integers
952//              [10] * char y;          char *y[10];    // array of 10 pointers to char
953
954new_declaration:                                                                                // CFA
955        new_variable_declaration pop ';'
956        | new_typedef_declaration pop ';'
957        | new_function_declaration pop ';'
958        | type_declaring_list pop ';'
959        | context_specifier pop ';'
960        ;
961
962new_variable_declaration:                                                               // CFA
963        new_variable_specifier initializer_opt
964                {
965                        typedefTable.addToEnclosingScope( TypedefTable::ID );
966                        $$ = $1;
967                }
968        | declaration_qualifier_list new_variable_specifier initializer_opt
969                // declaration_qualifier_list also includes type_qualifier_list, so a semantic check is necessary to
970                // preclude them as a type_qualifier cannot appear in that context.
971                {
972                        typedefTable.addToEnclosingScope( TypedefTable::ID );
973                        $$ = $2->addQualifiers( $1 );
974                }
975        | new_variable_declaration pop ',' push identifier_or_typedef_name initializer_opt
976                {
977                        typedefTable.addToEnclosingScope( *$5, TypedefTable::ID );
978                        $$ = $1->appendList( $1->cloneType( $5 ) );
979                }
980        ;
981
982new_variable_specifier:                                                                 // CFA
983                // A semantic check is required to ensure asm_name only appears on declarations with implicit or
984                // explicit static storage-class
985        new_abstract_declarator_no_tuple identifier_or_typedef_name asm_name_opt
986                {
987                        typedefTable.setNextIdentifier( *$2 );
988                        $$ = $1->addName( $2 );
989                }
990        | new_abstract_tuple identifier_or_typedef_name asm_name_opt
991                {
992                        typedefTable.setNextIdentifier( *$2 );
993                        $$ = $1->addName( $2 );
994                }
995        | type_qualifier_list new_abstract_tuple identifier_or_typedef_name asm_name_opt
996                {
997                        typedefTable.setNextIdentifier( *$3 );
998                        $$ = $2->addQualifiers( $1 )->addName( $3 );
999                }
1000        ;
1001
1002new_function_declaration:                                                               // CFA
1003        new_function_specifier
1004                {
1005                        typedefTable.addToEnclosingScope( TypedefTable::ID );
1006                        $$ = $1;
1007                }
1008        | type_qualifier_list new_function_specifier
1009                {
1010                        typedefTable.addToEnclosingScope( TypedefTable::ID );
1011                        $$ = $2->addQualifiers( $1 );
1012                }
1013        | declaration_qualifier_list new_function_specifier
1014                {
1015                        typedefTable.addToEnclosingScope( TypedefTable::ID );
1016                        $$ = $2->addQualifiers( $1 );
1017                }
1018        | declaration_qualifier_list type_qualifier_list new_function_specifier
1019                {
1020                        typedefTable.addToEnclosingScope( TypedefTable::ID );
1021                        $$ = $3->addQualifiers( $1 )->addQualifiers( $2 );
1022                }
1023        | new_function_declaration pop ',' push identifier_or_typedef_name
1024                {
1025                        typedefTable.addToEnclosingScope( *$5, TypedefTable::ID );
1026                        $$ = $1->appendList( $1->cloneType( $5 ) );
1027                }
1028        ;
1029
1030new_function_specifier:                                                                 // CFA
1031        '[' push pop ']' identifier '(' push new_parameter_type_list_opt pop ')'
1032                {
1033                        typedefTable.setNextIdentifier( *($5) );
1034                        $$ = DeclarationNode::newFunction( $5, DeclarationNode::newTuple( 0 ), $8, 0, true );
1035                }
1036        | '[' push pop ']' TYPEDEFname '(' push new_parameter_type_list_opt pop ')'
1037                {
1038                        typedefTable.setNextIdentifier( *($5) );
1039                        $$ = DeclarationNode::newFunction( $5, DeclarationNode::newTuple( 0 ), $8, 0, true );
1040                }
1041                // identifier_or_typedef_name must be broken apart because of the sequence:
1042                //
1043                //   '[' ']' identifier_or_typedef_name '(' new_parameter_type_list_opt ')'
1044                //   '[' ']' type_specifier
1045                //
1046                // type_specifier can resolve to just TYPEDEFname (e.g. typedef int T; int f( T );). Therefore this
1047                // must be flattened to allow lookahead to the '(' without having to reduce
1048                // identifier_or_typedef_name.
1049        | new_abstract_tuple identifier_or_typedef_name '(' push new_parameter_type_list_opt pop ')'
1050                // To obtain LR(1), this rule must be factored out from function return type (see
1051                //   new_abstract_declarator).
1052                {
1053                        $$ = DeclarationNode::newFunction( $2, $1, $5, 0, true );
1054                }
1055        | new_function_return identifier_or_typedef_name '(' push new_parameter_type_list_opt pop ')'
1056                {
1057                        $$ = DeclarationNode::newFunction( $2, $1, $5, 0, true );
1058                }
1059        ;
1060
1061new_function_return:                                                                    // CFA
1062        '[' push new_parameter_list pop ']'
1063                { $$ = DeclarationNode::newTuple( $3 ); }
1064        | '[' push new_parameter_list pop ',' push new_abstract_parameter_list pop ']'
1065                // To obtain LR(1), the last new_abstract_parameter_list is added into this flattened rule to
1066                // lookahead to the ']'.
1067                { $$ = DeclarationNode::newTuple( $3->appendList( $7 ) ); }
1068        ;
1069
1070new_typedef_declaration:                                                                // CFA
1071        TYPEDEF new_variable_specifier
1072                {
1073                        typedefTable.addToEnclosingScope( TypedefTable::TD);
1074                        $$ = $2->addTypedef();
1075                }
1076        | TYPEDEF new_function_specifier
1077                {
1078                        typedefTable.addToEnclosingScope( TypedefTable::TD);
1079                        $$ = $2->addTypedef();
1080                }
1081        | new_typedef_declaration pop ',' push no_attr_identifier
1082                {
1083                        typedefTable.addToEnclosingScope( *$5, TypedefTable::TD);
1084                        $$ = $1->appendList( $1->cloneType( $5 ) );
1085                }
1086        ;
1087
1088// Traditionally typedef is part of storage-class specifier for syntactic convenience only. Here, it is
1089// factored out as a separate form of declaration, which syntactically precludes storage-class specifiers and
1090// initialization.
1091
1092typedef_declaration:
1093        TYPEDEF type_specifier declarator
1094                {
1095                        typedefTable.addToEnclosingScope( TypedefTable::TD);
1096                        $$ = $3->addType( $2 )->addTypedef();
1097                }
1098        | typedef_declaration pop ',' push declarator
1099                {
1100                        typedefTable.addToEnclosingScope( TypedefTable::TD);
1101                        $$ = $1->appendList( $1->cloneBaseType( $5 )->addTypedef() );
1102                }
1103        | type_qualifier_list TYPEDEF type_specifier declarator // remaining OBSOLESCENT (see 2)
1104                {
1105                        typedefTable.addToEnclosingScope( TypedefTable::TD);
1106                        $$ = $4->addType( $3 )->addQualifiers( $1 )->addTypedef();
1107                }
1108        | type_specifier TYPEDEF declarator
1109                {
1110                        typedefTable.addToEnclosingScope( TypedefTable::TD);
1111                        $$ = $3->addType( $1 )->addTypedef();
1112                }
1113        | type_specifier TYPEDEF type_qualifier_list declarator
1114                {
1115                        typedefTable.addToEnclosingScope( TypedefTable::TD);
1116                        $$ = $4->addQualifiers($1)->addTypedef()->addType($1);
1117                }
1118        ;
1119
1120typedef_expression:                                                                             // GCC, naming expression type
1121        TYPEDEF no_attr_identifier '=' assignment_expression
1122                {
1123                        typedefTable.addToEnclosingScope(*($2), TypedefTable::TD);
1124                        $$ = DeclarationNode::newName( 0 ); // XXX
1125                }
1126        | typedef_expression pop ',' push no_attr_identifier '=' assignment_expression
1127                {
1128                        typedefTable.addToEnclosingScope(*($5), TypedefTable::TD);
1129                        $$ = DeclarationNode::newName( 0 ); // XXX
1130                }
1131        ;
1132
1133old_declaration:
1134        declaring_list pop ';'
1135        | typedef_declaration pop ';'
1136        | typedef_expression pop ';'                                            // GCC, naming expression type
1137        | sue_declaration_specifier pop ';'
1138        ;
1139
1140declaring_list:
1141                // A semantic check is required to ensure asm_name only appears on declarations with implicit or
1142                // explicit static storage-class
1143        declaration_specifier declarator asm_name_opt initializer_opt
1144                {
1145                        typedefTable.addToEnclosingScope( TypedefTable::ID );
1146                        $$ = ($2->addType( $1 ))->addInitializer($4);
1147                }
1148        | declaring_list ',' attribute_list_opt declarator asm_name_opt initializer_opt
1149                {
1150                        typedefTable.addToEnclosingScope( TypedefTable::ID );
1151                        $$ = $1->appendList( $1->cloneBaseType( $4->addInitializer($6) ) );
1152                }
1153        ;
1154
1155declaration_specifier:                                                                  // type specifier + storage class
1156        basic_declaration_specifier
1157        | sue_declaration_specifier
1158        | typedef_declaration_specifier
1159        | typegen_declaration_specifier
1160        ;
1161
1162type_specifier:                                                                                 // declaration specifier - storage class
1163        basic_type_specifier
1164        | sue_type_specifier
1165        | typedef_type_specifier
1166        | typegen_type_specifier
1167        ;
1168
1169type_qualifier_list_opt:                                                                // GCC, used in asm_statement
1170        // empty
1171                { $$ = 0; }
1172        | type_qualifier_list
1173        ;
1174
1175type_qualifier_list:
1176                // A semantic check is necessary to ensure a type qualifier is appropriate for the kind of
1177                // declaration.
1178                //
1179                // ISO/IEC 9899:1999 Section 6.7.3(4) : If the same qualifier appears more than once in the same
1180                // specifier-qualifier-list, either directly or via one or more typedefs, the behavior is the same as
1181                // if it appeared only once.
1182        type_qualifier
1183        | type_qualifier_list type_qualifier
1184                { $$ = $1->addQualifiers( $2 ); }
1185        ;
1186
1187type_qualifier:
1188        type_qualifier_name
1189        | attribute
1190                { $$ = DeclarationNode::newQualifier( DeclarationNode::Attribute ); }
1191        ;
1192
1193type_qualifier_name:
1194        CONST
1195                { $$ = DeclarationNode::newQualifier( DeclarationNode::Const ); }
1196        | RESTRICT
1197                { $$ = DeclarationNode::newQualifier( DeclarationNode::Restrict ); }
1198        | VOLATILE
1199                { $$ = DeclarationNode::newQualifier( DeclarationNode::Volatile ); }
1200        | LVALUE                                                                                        // CFA
1201                { $$ = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); }
1202        | ATOMIC
1203                { $$ = DeclarationNode::newQualifier( DeclarationNode::Atomic ); }
1204        | FORALL '('
1205                {
1206                        typedefTable.enterScope();
1207                }
1208          type_parameter_list ')'                                                       // CFA
1209                {
1210                        typedefTable.leaveScope();
1211                        $$ = DeclarationNode::newForall( $4 );
1212                }
1213        ;
1214
1215declaration_qualifier_list:
1216        storage_class_list
1217        | type_qualifier_list storage_class_list                        // remaining OBSOLESCENT (see 2)
1218                { $$ = $1->addQualifiers( $2 ); }
1219        | declaration_qualifier_list type_qualifier_list storage_class_list
1220                { $$ = $1->addQualifiers( $2 )->addQualifiers( $3 ); }
1221        ;
1222
1223storage_class_list:
1224                // A semantic check is necessary to ensure a storage class is appropriate for the kind of declaration
1225                // and that only one of each is specified, except for inline, which can appear with the others.
1226                //
1227                // ISO/IEC 9899:1999 Section 6.7.1(2) : At most, one storage-class specifier may be given in the
1228                // declaration specifiers in a declaration.
1229        storage_class
1230        | storage_class_list storage_class
1231                { $$ = $1->addQualifiers( $2 ); }
1232        ;
1233
1234storage_class:
1235        storage_class_name
1236        ;
1237
1238storage_class_name:
1239        EXTERN
1240                { $$ = DeclarationNode::newStorageClass( DeclarationNode::Extern ); }
1241        | STATIC
1242                { $$ = DeclarationNode::newStorageClass( DeclarationNode::Static ); }
1243        | AUTO
1244                { $$ = DeclarationNode::newStorageClass( DeclarationNode::Auto ); }
1245        | REGISTER
1246                { $$ = DeclarationNode::newStorageClass( DeclarationNode::Register ); }
1247        | INLINE                                                                                        // C99
1248                // INLINE is essentially a storage class specifier for functions, and hence, belongs here.
1249                { $$ = DeclarationNode::newStorageClass( DeclarationNode::Inline ); }
1250        | FORTRAN                                                                                       // C99
1251                { $$ = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); }
1252        ;
1253
1254basic_type_name:
1255        CHAR
1256                { $$ = DeclarationNode::newBasicType( DeclarationNode::Char ); }
1257        | DOUBLE
1258                { $$ = DeclarationNode::newBasicType( DeclarationNode::Double ); }
1259        | FLOAT
1260                { $$ = DeclarationNode::newBasicType( DeclarationNode::Float ); }
1261        | INT
1262                { $$ = DeclarationNode::newBasicType( DeclarationNode::Int ); }
1263        | LONG
1264                { $$ = DeclarationNode::newModifier( DeclarationNode::Long ); }
1265        | SHORT
1266                { $$ = DeclarationNode::newModifier( DeclarationNode::Short ); }
1267        | SIGNED
1268                { $$ = DeclarationNode::newModifier( DeclarationNode::Signed ); }
1269        | UNSIGNED
1270                { $$ = DeclarationNode::newModifier( DeclarationNode::Unsigned ); }
1271        | VOID
1272                { $$ = DeclarationNode::newBasicType( DeclarationNode::Void ); }
1273        | BOOL                                                                                          // C99
1274                { $$ = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
1275        | COMPLEX                                                                                       // C99
1276                { $$ = DeclarationNode::newBasicType( DeclarationNode::Complex ); }
1277        | IMAGINARY                                                                                     // C99
1278                { $$ = DeclarationNode::newBasicType( DeclarationNode::Imaginary ); }
1279        ;
1280
1281basic_declaration_specifier:
1282                // A semantic check is necessary for conflicting storage classes.
1283        basic_type_specifier
1284        | declaration_qualifier_list basic_type_specifier
1285                { $$ = $2->addQualifiers( $1 ); }
1286        | basic_declaration_specifier storage_class                     // remaining OBSOLESCENT (see 2)
1287                { $$ = $1->addQualifiers( $2 ); }
1288        | basic_declaration_specifier storage_class type_qualifier_list
1289                { $$ = $1->addQualifiers( $2 )->addQualifiers( $3 ); }
1290        | basic_declaration_specifier storage_class basic_type_specifier
1291                { $$ = $3->addQualifiers( $2 )->addType( $1 ); }
1292        ;
1293
1294basic_type_specifier:
1295        direct_type_name
1296        | type_qualifier_list_opt indirect_type_name type_qualifier_list_opt
1297                { $$ = $2->addQualifiers( $1 )->addQualifiers( $3 ); }
1298        ;
1299
1300direct_type_name:
1301                // A semantic check is necessary for conflicting type qualifiers.
1302        basic_type_name
1303        | type_qualifier_list basic_type_name
1304                { $$ = $2->addQualifiers( $1 ); }
1305        | direct_type_name type_qualifier
1306                { $$ = $1->addQualifiers( $2 ); }
1307        | direct_type_name basic_type_name
1308                { $$ = $1->addType( $2 ); }
1309        ;
1310
1311indirect_type_name:
1312        TYPEOF '(' type_name ')'                                                        // GCC: typeof(x) y;
1313                { $$ = $3; }
1314        | TYPEOF '(' comma_expression ')'                                       // GCC: typeof(a+b) y;
1315                { $$ = DeclarationNode::newTypeof( $3 ); }
1316        | ATTR_TYPEGENname '(' type_name ')'                            // CFA: e.g., @type(x) y;
1317                { $$ = DeclarationNode::newAttr( $1, $3 ); }
1318        | ATTR_TYPEGENname '(' comma_expression ')'                     // CFA: e.g., @type(a+b) y;
1319                { $$ = DeclarationNode::newAttr( $1, $3 ); }
1320        ;
1321
1322sue_declaration_specifier:
1323        sue_type_specifier
1324        | declaration_qualifier_list sue_type_specifier
1325                { $$ = $2->addQualifiers( $1 ); }
1326        | sue_declaration_specifier storage_class                       // remaining OBSOLESCENT (see 2)
1327                { $$ = $1->addQualifiers( $2 ); }
1328        | sue_declaration_specifier storage_class type_qualifier_list
1329                { $$ = $1->addQualifiers( $2 )->addQualifiers( $3 ); }
1330        ;
1331
1332sue_type_specifier:
1333        elaborated_type_name                                                            // struct, union, enum
1334        | type_qualifier_list elaborated_type_name
1335                { $$ = $2->addQualifiers( $1 ); }
1336        | sue_type_specifier type_qualifier
1337                { $$ = $1->addQualifiers( $2 ); }
1338        ;
1339
1340typedef_declaration_specifier:
1341        typedef_type_specifier
1342        | declaration_qualifier_list typedef_type_specifier
1343                { $$ = $2->addQualifiers( $1 ); }
1344        | typedef_declaration_specifier storage_class           // remaining OBSOLESCENT (see 2)
1345                { $$ = $1->addQualifiers( $2 ); }
1346        | typedef_declaration_specifier storage_class type_qualifier_list
1347                { $$ = $1->addQualifiers( $2 )->addQualifiers( $3 ); }
1348        ;
1349
1350typedef_type_specifier:                                                                 // typedef types
1351        TYPEDEFname
1352                { $$ = DeclarationNode::newFromTypedef( $1 ); }
1353        | type_qualifier_list TYPEDEFname
1354                { $$ = DeclarationNode::newFromTypedef( $2 )->addQualifiers( $1 ); }
1355        | typedef_type_specifier type_qualifier
1356                { $$ = $1->addQualifiers( $2 ); }
1357        ;
1358
1359elaborated_type_name:
1360        aggregate_name
1361        | enum_name
1362        ;
1363
1364aggregate_name:
1365        aggregate_key '{' field_declaration_list '}'
1366                { $$ = DeclarationNode::newAggregate( $1, 0, 0, 0, $3 ); }
1367        | aggregate_key no_attr_identifier_or_typedef_name
1368                { $$ = DeclarationNode::newAggregate( $1, $2, 0, 0, 0 ); }
1369        | aggregate_key no_attr_identifier_or_typedef_name '{' field_declaration_list '}'
1370                { $$ = DeclarationNode::newAggregate( $1, $2, 0, 0, $4 ); }
1371        | aggregate_key '(' push type_parameter_list pop ')' '{' field_declaration_list '}' // CFA
1372                { $$ = DeclarationNode::newAggregate( $1, 0, $4, 0, $8 ); }
1373        | aggregate_key '(' push type_parameter_list pop ')' no_attr_identifier_or_typedef_name // CFA
1374                { $$ = DeclarationNode::newAggregate( $1, $7, $4, 0, 0 ); }
1375        | aggregate_key '(' push type_parameter_list pop ')' no_attr_identifier_or_typedef_name '{' field_declaration_list '}' // CFA
1376                { $$ = DeclarationNode::newAggregate( $1, $7, $4, 0, $9 ); }
1377        | aggregate_key '(' push type_parameter_list pop ')' '(' type_name_list ')' '{' field_declaration_list '}' // CFA
1378                { $$ = DeclarationNode::newAggregate( $1, 0, $4, $8, $11 ); }
1379        | aggregate_key '(' push type_name_list pop ')' no_attr_identifier_or_typedef_name // CFA
1380                // push and pop are only to prevent S/R conflicts
1381                { $$ = DeclarationNode::newAggregate( $1, $7, 0, $4, 0 ); }
1382        | aggregate_key '(' push type_parameter_list pop ')' '(' type_name_list ')' no_attr_identifier_or_typedef_name '{' field_declaration_list '}' // CFA
1383                { $$ = DeclarationNode::newAggregate( $1, $10, $4, $8, $12 ); }
1384        ;
1385
1386aggregate_key:
1387        STRUCT attribute_list_opt
1388                { $$ = DeclarationNode::Struct; }
1389        | UNION attribute_list_opt
1390                { $$ = DeclarationNode::Union; }
1391        ;
1392
1393field_declaration_list:
1394        field_declaration
1395                { $$ = $1; }
1396        | field_declaration_list field_declaration
1397                { $$ = $1->appendList( $2 ); }
1398        ;
1399
1400field_declaration:
1401        new_field_declaring_list ';'                                            // CFA, new style field declaration
1402        | EXTENSION new_field_declaring_list ';'                        // GCC
1403                { $$ = $2; }
1404        | field_declaring_list ';'
1405        | EXTENSION field_declaring_list ';'                            // GCC
1406                { $$ = $2; }
1407        ;
1408
1409new_field_declaring_list:                                                               // CFA, new style field declaration
1410        new_abstract_declarator_tuple                                           // CFA, no field name
1411        | new_abstract_declarator_tuple no_attr_identifier_or_typedef_name
1412                { $$ = $1->addName( $2 ); }
1413        | new_field_declaring_list ',' no_attr_identifier_or_typedef_name
1414                { $$ = $1->appendList( $1->cloneType( $3 ) ); }
1415        | new_field_declaring_list ','                                          // CFA, no field name
1416                { $$ = $1->appendList( $1->cloneType( 0 ) ); }
1417        ;
1418
1419field_declaring_list:
1420        type_specifier field_declarator
1421                { $$ = $2->addType( $1 ); }
1422        | field_declaring_list ',' attribute_list_opt field_declarator
1423                { $$ = $1->appendList( $1->cloneBaseType( $4 ) ); }
1424        ;
1425
1426field_declarator:
1427        // empty
1428                { $$ = DeclarationNode::newName( 0 ); /* XXX */ } // CFA, no field name
1429        | bit_subrange_size                                                                     // no field name
1430                { $$ = DeclarationNode::newBitfield( $1 ); }
1431        | variable_declarator bit_subrange_size_opt
1432                // A semantic check is required to ensure bit_subrange only appears on base type int.
1433                { $$ = $1->addBitfield( $2 ); }
1434        | typedef_redeclarator bit_subrange_size_opt
1435                // A semantic check is required to ensure bit_subrange only appears on base type int.
1436                { $$ = $1->addBitfield( $2 ); }
1437        | variable_abstract_declarator                                          // CFA, no field name
1438        ;
1439
1440bit_subrange_size_opt:
1441        // empty
1442                { $$ = 0; }
1443        | bit_subrange_size
1444                { $$ = $1; }
1445        ;
1446
1447bit_subrange_size:
1448        ':' constant_expression
1449                { $$ = $2; }
1450        ;
1451
1452enum_key:
1453        ENUM attribute_list_opt
1454        ;
1455
1456enum_name:
1457        enum_key '{' enumerator_list comma_opt '}'
1458                { $$ = DeclarationNode::newEnum( 0, $3 ); }
1459        | enum_key no_attr_identifier_or_typedef_name '{' enumerator_list comma_opt '}'
1460                { $$ = DeclarationNode::newEnum( $2, $4 ); }
1461        | enum_key no_attr_identifier_or_typedef_name
1462                { $$ = DeclarationNode::newEnum( $2, 0 ); }
1463        ;
1464
1465enumerator_list:
1466        no_attr_identifier_or_typedef_name enumerator_value_opt
1467                { $$ = DeclarationNode::newEnumConstant( $1, $2 ); }
1468        | enumerator_list ',' no_attr_identifier_or_typedef_name enumerator_value_opt
1469                { $$ = $1->appendList( DeclarationNode::newEnumConstant( $3, $4 ) ); }
1470        ;
1471
1472enumerator_value_opt:
1473        // empty
1474                { $$ = 0; }
1475        | '=' constant_expression
1476                { $$ = $2; }
1477        ;
1478
1479// Minimum of one parameter after which ellipsis is allowed only at the end.
1480
1481new_parameter_type_list_opt:                                                    // CFA
1482        // empty
1483                { $$ = 0; }
1484        | new_parameter_type_list
1485        ;
1486
1487new_parameter_type_list:                                                                // CFA, abstract + real
1488        new_abstract_parameter_list
1489        | new_parameter_list
1490        | new_parameter_list pop ',' push new_abstract_parameter_list
1491                { $$ = $1->appendList( $5 ); }
1492        | new_abstract_parameter_list pop ',' push ELLIPSIS
1493                { $$ = $1->addVarArgs(); }
1494        | new_parameter_list pop ',' push ELLIPSIS
1495                { $$ = $1->addVarArgs(); }
1496        ;
1497
1498new_parameter_list:                                                                             // CFA
1499                // To obtain LR(1) between new_parameter_list and new_abstract_tuple, the last
1500                // new_abstract_parameter_list is factored out from new_parameter_list, flattening the rules to get
1501                // lookahead to the ']'.
1502        new_parameter_declaration
1503        | new_abstract_parameter_list pop ',' push new_parameter_declaration
1504                { $$ = $1->appendList( $5 ); }
1505        | new_parameter_list pop ',' push new_parameter_declaration
1506                { $$ = $1->appendList( $5 ); }
1507        | new_parameter_list pop ',' push new_abstract_parameter_list pop ',' push new_parameter_declaration
1508                { $$ = $1->appendList( $5 )->appendList( $9 ); }
1509        ;
1510
1511new_abstract_parameter_list:                                                    // CFA, new & old style abstract
1512        new_abstract_parameter_declaration
1513        | new_abstract_parameter_list pop ',' push new_abstract_parameter_declaration
1514                { $$ = $1->appendList( $5 ); }
1515        ;
1516
1517parameter_type_list_opt:
1518        // empty
1519                { $$ = 0; }
1520        | parameter_type_list
1521        ;
1522
1523parameter_type_list:
1524        parameter_list
1525        | parameter_list pop ',' push ELLIPSIS
1526                { $$ = $1->addVarArgs(); }
1527        ;
1528
1529parameter_list:                                                                                 // abstract + real
1530        abstract_parameter_declaration
1531        | parameter_declaration
1532        | parameter_list pop ',' push abstract_parameter_declaration
1533                { $$ = $1->appendList( $5 ); }
1534        | parameter_list pop ',' push parameter_declaration
1535                { $$ = $1->appendList( $5 ); }
1536        ;
1537
1538// Provides optional identifier names (abstract_declarator/variable_declarator), no initialization, different
1539// semantics for typedef name by using typedef_parameter_redeclarator instead of typedef_redeclarator, and
1540// function prototypes.
1541
1542new_parameter_declaration:                                                              // CFA, new & old style parameter declaration
1543        parameter_declaration
1544        | new_identifier_parameter_declarator_no_tuple identifier_or_typedef_name assignment_opt
1545                { $$ = $1->addName( $2 ); }
1546        | new_abstract_tuple identifier_or_typedef_name assignment_opt
1547                // To obtain LR(1), these rules must be duplicated here (see new_abstract_declarator).
1548                { $$ = $1->addName( $2 ); }
1549        | type_qualifier_list new_abstract_tuple identifier_or_typedef_name assignment_opt
1550                { $$ = $2->addName( $3 )->addQualifiers( $1 ); }
1551        | new_function_specifier
1552        ;
1553
1554new_abstract_parameter_declaration:                                             // CFA, new & old style parameter declaration
1555        abstract_parameter_declaration
1556        | new_identifier_parameter_declarator_no_tuple
1557        | new_abstract_tuple
1558                // To obtain LR(1), these rules must be duplicated here (see new_abstract_declarator).
1559        | type_qualifier_list new_abstract_tuple
1560                { $$ = $2->addQualifiers( $1 ); }
1561        | new_abstract_function
1562        ;
1563
1564parameter_declaration:
1565        declaration_specifier identifier_parameter_declarator assignment_opt
1566                {
1567                        typedefTable.addToEnclosingScope( TypedefTable::ID );
1568                        $$ = $2->addType( $1 )->addInitializer( new InitializerNode($3) );
1569                }
1570        | declaration_specifier typedef_parameter_redeclarator assignment_opt
1571                {
1572                        typedefTable.addToEnclosingScope( TypedefTable::ID );
1573                        $$ = $2->addType( $1 )->addInitializer( new InitializerNode($3) );
1574                }
1575        ;
1576
1577abstract_parameter_declaration:
1578        declaration_specifier
1579        | declaration_specifier abstract_parameter_declarator
1580                { $$ = $2->addType( $1 ); }
1581        ;
1582
1583// ISO/IEC 9899:1999 Section 6.9.1(6) : "An identifier declared as a typedef name shall not be redeclared as a
1584// parameter." Because the scope of the K&R-style parameter-list sees the typedef first, the following is
1585// based only on identifiers.  The ANSI-style parameter-list can redefine a typedef name.
1586
1587identifier_list:                                                                                // K&R-style parameter list => no types
1588        no_attr_identifier
1589                { $$ = DeclarationNode::newName( $1 ); }
1590        | identifier_list ',' no_attr_identifier
1591                { $$ = $1->appendList( DeclarationNode::newName( $3 ) ); }
1592        ;
1593
1594identifier_or_typedef_name:
1595        identifier
1596        | TYPEDEFname
1597        | TYPEGENname
1598        ;
1599
1600no_01_identifier_or_typedef_name:
1601        no_01_identifier
1602        | TYPEDEFname
1603        | TYPEGENname
1604        ;
1605
1606no_attr_identifier_or_typedef_name:
1607        no_attr_identifier
1608        | TYPEDEFname
1609        | TYPEGENname
1610        ;
1611
1612type_name_no_function:                                                                  // sizeof, alignof, cast (constructor)
1613        new_abstract_declarator_tuple                                           // CFA
1614        | type_specifier
1615        | type_specifier variable_abstract_declarator
1616                { $$ = $2->addType( $1 ); }
1617        ;
1618
1619type_name:                                                                                              // typeof, assertion
1620        new_abstract_declarator_tuple                                           // CFA
1621        | new_abstract_function                                                         // CFA
1622        | type_specifier
1623        | type_specifier abstract_declarator
1624                { $$ = $2->addType( $1 ); }
1625        ;
1626
1627initializer_opt:
1628        // empty
1629                { $$ = 0; }
1630        | '=' initializer                                                       { $$ = $2; }
1631        ;
1632
1633initializer:
1634        assignment_expression                                           { $$ = new InitializerNode($1); }
1635        | '{' initializer_list comma_opt '}'            { $$ = new InitializerNode($2, true); }
1636        ;
1637
1638initializer_list:
1639        initializer
1640        | designation initializer                                       { $$ = $2->set_designators( $1 ); }
1641        | initializer_list ',' initializer                      { $$ = (InitializerNode *)( $1->set_link($3) ); }
1642        | initializer_list ',' designation initializer
1643                { $$ = (InitializerNode *)( $1->set_link( $4->set_designators($3) ) ); }
1644        ;
1645
1646// There is an unreconcileable parsing problem between C99 and CFA with respect to designators. The problem is
1647// use of '=' to separator the designator from the initializer value, as in:
1648//
1649//              int x[10] = { [1] = 3 };
1650//
1651// The string "[1] = 3" can be parsed as a designator assignment or a tuple assignment.  To disambiguate this
1652// case, CFA changes the syntax from "=" to ":" as the separator between the designator and initializer. GCC
1653// does uses ":" for field selection. The optional use of the "=" in GCC, or in this case ":", cannot be
1654// supported either due to shift/reduce conflicts
1655
1656designation:
1657        designator_list ':'                                                                     // C99, CFA uses ":" instead of "="
1658        | no_attr_identifier_or_typedef_name ':'                        // GCC, field name
1659                                { $$ = new VarRefNode( $1 ); }
1660        ;
1661
1662designator_list:                                                                                // C99
1663        designator
1664        | designator_list designator                                    { $$ = (ExpressionNode *)($1->set_link( $2 )); }
1665        ;
1666
1667designator:
1668        '.' no_attr_identifier_or_typedef_name                          // C99, field name
1669                { $$ = new VarRefNode( $2 ); }
1670        | '[' push assignment_expression pop ']'                        // C99, single array element
1671                // assignment_expression used instead of constant_expression because of shift/reduce conflicts with
1672                // tuple.
1673                { $$ = $3; }
1674        | '[' push subrange pop ']'                                                     // CFA, multiple array elements
1675                { $$ = $3; }
1676        | '[' push constant_expression ELLIPSIS constant_expression pop ']' // GCC, multiple array elements
1677                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Range), $3, $5); }
1678        | '.' '[' push field_list pop ']'                                       // CFA, tuple field selector
1679                { $$ = $4; }
1680        ;
1681
1682// The CFA type system is based on parametric polymorphism, the ability to declare functions with type
1683// parameters, rather than an object-oriented type system. This required four groups of extensions:
1684//
1685// Overloading: function, data, and operator identifiers may be overloaded.
1686//
1687// Type declarations: "type" is used to generate new types for declaring objects. Similarly, "dtype" is used
1688//     for object and incomplete types, and "ftype" is used for function types. Type declarations with
1689//     initializers provide definitions of new types. Type declarations with storage class "extern" provide
1690//     opaque types.
1691//
1692// Polymorphic functions: A forall clause declares a type parameter. The corresponding argument is inferred at
1693//     the call site. A polymorphic function is not a template; it is a function, with an address and a type.
1694//
1695// Specifications and Assertions: Specifications are collections of declarations parameterized by one or more
1696//     types. They serve many of the purposes of abstract classes, and specification hierarchies resemble
1697//     subclass hierarchies. Unlike classes, they can define relationships between types.  Assertions declare
1698//     that a type or types provide the operations declared by a specification.  Assertions are normally used
1699//     to declare requirements on type arguments of polymorphic functions.
1700
1701typegen_declaration_specifier:                                                  // CFA
1702        typegen_type_specifier
1703        | declaration_qualifier_list typegen_type_specifier
1704                { $$ = $2->addQualifiers( $1 ); }
1705        | typegen_declaration_specifier storage_class           // remaining OBSOLESCENT (see 2)
1706                { $$ = $1->addQualifiers( $2 ); }
1707        | typegen_declaration_specifier storage_class type_qualifier_list
1708                { $$ = $1->addQualifiers( $2 )->addQualifiers( $3 ); }
1709        ;
1710
1711typegen_type_specifier:                                                                 // CFA
1712        TYPEGENname '(' type_name_list ')'
1713                { $$ = DeclarationNode::newFromTypeGen( $1, $3 ); }
1714        | type_qualifier_list TYPEGENname '(' type_name_list ')'
1715                { $$ = DeclarationNode::newFromTypeGen( $2, $4 )->addQualifiers( $1 ); }
1716        | typegen_type_specifier type_qualifier
1717                { $$ = $1->addQualifiers( $2 ); }
1718        ;
1719
1720type_parameter_list:                                                                    // CFA
1721        type_parameter assignment_opt
1722        | type_parameter_list ',' type_parameter assignment_opt
1723                { $$ = $1->appendList( $3 ); }
1724        ;
1725
1726type_parameter:                                                                                 // CFA
1727        type_class no_attr_identifier_or_typedef_name
1728                { typedefTable.addToEnclosingScope(*($2), TypedefTable::TD); }
1729          assertion_list_opt
1730                { $$ = DeclarationNode::newTypeParam( $1, $2 )->addAssertions( $4 ); }
1731        | type_specifier identifier_parameter_declarator
1732        ;
1733
1734type_class:                                                                                             // CFA
1735        TYPE
1736                { $$ = DeclarationNode::Type; }
1737        | DTYPE
1738                { $$ = DeclarationNode::Ftype; }
1739        | FTYPE
1740                { $$ = DeclarationNode::Dtype; }
1741        ;
1742
1743assertion_list_opt:                                                                             // CFA
1744        // empty
1745                { $$ = 0; }
1746        | assertion_list_opt assertion
1747                { $$ = $1 == 0 ? $2 : $1->appendList( $2 ); }
1748        ;
1749
1750assertion:                                                                                              // CFA
1751        '|' no_attr_identifier_or_typedef_name '(' type_name_list ')'
1752                {
1753                        typedefTable.openContext( *($2) );
1754                        $$ = DeclarationNode::newContextUse( $2, $4 );
1755                }
1756        | '|' '{' push context_declaration_list '}'
1757                { $$ = $4; }
1758        | '|' '(' push type_parameter_list pop ')' '{' push context_declaration_list '}' '(' type_name_list ')'
1759                { $$ = 0; }
1760        ;
1761
1762type_name_list:                                                                                 // CFA
1763        type_name
1764                { $$ = new TypeValueNode( $1 ); }
1765        | assignment_expression
1766        | type_name_list ',' type_name
1767                { $$ = (ExpressionNode *)($1->set_link(new TypeValueNode( $3 ))); }
1768        | type_name_list ',' assignment_expression
1769                { $$ = (ExpressionNode *)($1->set_link($3)); }
1770        ;
1771
1772type_declaring_list:                                                                    // CFA
1773        TYPE type_declarator
1774                { $$ = $2; }
1775        | storage_class_list TYPE type_declarator
1776                { $$ = $3->addQualifiers( $1 ); }
1777        | type_declaring_list ',' type_declarator
1778                { $$ = $1->appendList( $3->copyStorageClasses( $1 ) ); }
1779        ;
1780
1781type_declarator:                                                                                // CFA
1782        type_declarator_name assertion_list_opt
1783                { $$ = $1->addAssertions( $2 ); }
1784        | type_declarator_name assertion_list_opt '=' type_name
1785                { $$ = $1->addAssertions( $2 )->addType( $4 ); }
1786        ;
1787
1788type_declarator_name:                                                                   // CFA
1789        no_attr_identifier_or_typedef_name
1790                {
1791                        typedefTable.addToEnclosingScope(*($1), TypedefTable::TD);
1792                        $$ = DeclarationNode::newTypeDecl( $1, 0 );
1793                }
1794        | no_01_identifier_or_typedef_name '(' push type_parameter_list pop ')'
1795                {
1796                        typedefTable.addToEnclosingScope(*($1), TypedefTable::TG);
1797                        $$ = DeclarationNode::newTypeDecl( $1, $4 );
1798                }
1799        ;
1800
1801context_specifier:                                                                              // CFA
1802        CONTEXT no_attr_identifier_or_typedef_name '(' push type_parameter_list pop ')' '{' '}'
1803                {
1804                        typedefTable.addToEnclosingScope(*($2), TypedefTable::ID );
1805                        $$ = DeclarationNode::newContext( $2, $5, 0 );
1806                }
1807        | CONTEXT no_attr_identifier_or_typedef_name '(' push type_parameter_list pop ')' '{'
1808                {
1809                        typedefTable.enterContext( *($2) );
1810                        typedefTable.enterScope();
1811                }
1812          context_declaration_list '}'
1813                {
1814                        typedefTable.leaveContext();
1815                        typedefTable.addToEnclosingScope(*($2), TypedefTable::ID );
1816                        $$ = DeclarationNode::newContext( $2, $5, $10 );
1817                }
1818        ;
1819
1820context_declaration_list:                                                               // CFA
1821        context_declaration
1822        | context_declaration_list push context_declaration
1823                { $$ = $1->appendList( $3 ); }
1824        ;
1825
1826context_declaration:                                                                    // CFA
1827        new_context_declaring_list pop ';'
1828        | context_declaring_list pop ';'
1829        ;
1830
1831new_context_declaring_list:                                                             // CFA
1832        new_variable_specifier
1833                {
1834                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
1835                        $$ = $1;
1836                }
1837        | new_function_specifier
1838                {
1839                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
1840                        $$ = $1;
1841                }
1842        | new_context_declaring_list pop ',' push identifier_or_typedef_name
1843                {
1844                        typedefTable.addToEnclosingScope2( *($5), TypedefTable::ID );
1845                        $$ = $1->appendList( $1->cloneType( $5 ) );
1846                }
1847        ;
1848
1849context_declaring_list:                                                                 // CFA
1850        type_specifier declarator
1851                {
1852                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
1853                        $$ = $2->addType( $1 );
1854                }
1855        | context_declaring_list pop ',' push declarator
1856                {
1857                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
1858                        $$ = $1->appendList( $1->cloneBaseType( $5 ) );
1859                }
1860        ;
1861
1862//***************************** EXTERNAL DEFINITIONS *****************************
1863
1864translation_unit:
1865        // empty
1866                {}                                                                                              // empty input file
1867        | external_definition_list
1868                {
1869                        if ( theTree ) {
1870                                theTree->appendList( $1 );
1871                        } else {
1872                                theTree = $1;
1873                        }
1874                }
1875        ;
1876
1877external_definition_list:
1878        external_definition
1879        | external_definition_list push external_definition
1880                { $$ = ($1 != NULL ) ? $1->appendList( $3 ) : $3; }
1881        ;
1882
1883external_definition_list_opt:
1884        // empty
1885                { $$ = 0; }
1886        | external_definition_list
1887        ;
1888
1889external_definition:
1890        declaration
1891        | external_function_definition
1892        | asm_statement                                                                         // GCC, global assembler statement
1893                {}
1894        | EXTERN STRINGliteral
1895                {
1896                        linkageStack.push( linkage );
1897                        linkage = LinkageSpec::fromString( *$2 );
1898                }
1899          '{' external_definition_list_opt '}'                          // C++-style linkage specifier
1900                {
1901                        linkage = linkageStack.top();
1902                        linkageStack.pop();
1903                        $$ = $5;
1904                }
1905        | EXTENSION external_definition
1906                { $$ = $2; }
1907        ;
1908
1909external_function_definition:
1910        function_definition
1911
1912                // These rules are a concession to the "implicit int" type_specifier because there is a significant
1913                // amount of code with functions missing a type-specifier on the return type.  Parsing is possible
1914                // because function_definition does not appear in the context of an expression (nested functions would
1915                // preclude this concession). A function prototype declaration must still have a type_specifier.
1916                // OBSOLESCENT (see 1)
1917        | function_declarator compound_statement
1918                {
1919                        typedefTable.addToEnclosingScope( TypedefTable::ID );
1920                        typedefTable.leaveScope();
1921                        $$ = $1->addFunctionBody( $2 );
1922                }
1923        | old_function_declarator push old_declaration_list_opt compound_statement
1924                {
1925                        typedefTable.addToEnclosingScope( TypedefTable::ID );
1926                        typedefTable.leaveScope();
1927                        $$ = $1->addOldDeclList( $3 )->addFunctionBody( $4 );
1928                }
1929        ;
1930
1931function_definition:
1932        new_function_declaration compound_statement                     // CFA
1933                {
1934                        typedefTable.addToEnclosingScope( TypedefTable::ID );
1935                        typedefTable.leaveScope();
1936                        $$ = $1->addFunctionBody( $2 );
1937                }
1938        | declaration_specifier function_declarator compound_statement
1939                {
1940                        typedefTable.addToEnclosingScope( TypedefTable::ID );
1941                        typedefTable.leaveScope();
1942                        $$ = $2->addFunctionBody( $3 )->addType( $1 );
1943                }
1944        | type_qualifier_list function_declarator compound_statement
1945                {
1946                        typedefTable.addToEnclosingScope( TypedefTable::ID );
1947                        typedefTable.leaveScope();
1948                        $$ = $2->addFunctionBody( $3 )->addQualifiers( $1 );
1949                }
1950        | declaration_qualifier_list function_declarator compound_statement
1951                {
1952                        typedefTable.addToEnclosingScope( TypedefTable::ID );
1953                        typedefTable.leaveScope();
1954                        $$ = $2->addFunctionBody( $3 )->addQualifiers( $1 );
1955                }
1956        | declaration_qualifier_list type_qualifier_list function_declarator compound_statement
1957                {
1958                        typedefTable.addToEnclosingScope( TypedefTable::ID );
1959                        typedefTable.leaveScope();
1960                        $$ = $3->addFunctionBody( $4 )->addQualifiers( $2 )->addQualifiers( $1 );
1961                }
1962
1963                // Old-style K&R function definition, OBSOLESCENT (see 4)
1964        | declaration_specifier old_function_declarator push old_declaration_list_opt compound_statement
1965                {
1966                        typedefTable.addToEnclosingScope( TypedefTable::ID );
1967                        typedefTable.leaveScope();
1968                        $$ = $2->addOldDeclList( $4 )->addFunctionBody( $5 )->addType( $1 );
1969                }
1970        | type_qualifier_list old_function_declarator push old_declaration_list_opt compound_statement
1971                {
1972                        typedefTable.addToEnclosingScope( TypedefTable::ID );
1973                        typedefTable.leaveScope();
1974                        $$ = $2->addOldDeclList( $4 )->addFunctionBody( $5 )->addQualifiers( $1 );
1975                }
1976
1977                // Old-style K&R function definition with "implicit int" type_specifier, OBSOLESCENT (see 4)
1978        | declaration_qualifier_list old_function_declarator push old_declaration_list_opt compound_statement
1979                {
1980                        typedefTable.addToEnclosingScope( TypedefTable::ID );
1981                        typedefTable.leaveScope();
1982                        $$ = $2->addOldDeclList( $4 )->addFunctionBody( $5 )->addQualifiers( $1 );
1983                }
1984        | declaration_qualifier_list type_qualifier_list old_function_declarator push old_declaration_list_opt compound_statement
1985                {
1986                        typedefTable.addToEnclosingScope( TypedefTable::ID );
1987                        typedefTable.leaveScope();
1988                        $$ = $3->addOldDeclList( $5 )->addFunctionBody( $6 )->addQualifiers( $2 )->addQualifiers( $1 );
1989                }
1990        ;
1991
1992declarator:
1993        variable_declarator
1994        | function_declarator
1995        | typedef_redeclarator
1996        ;
1997
1998subrange:
1999        constant_expression '~' constant_expression                     // CFA, integer subrange
2000                { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Range), $1, $3); }
2001        ;
2002
2003asm_name_opt:                                                                                   // GCC
2004        // empty
2005        | ASM '(' string_literal_list ')' attribute_list_opt
2006        ;
2007
2008attribute_list_opt:                                                                             // GCC
2009        // empty
2010        | attribute_list
2011        ;
2012
2013attribute_list:                                                                                 // GCC
2014        attribute
2015        | attribute_list attribute
2016        ;
2017
2018attribute:                                                                                              // GCC
2019        ATTRIBUTE '(' '(' attribute_parameter_list ')' ')'
2020        ;
2021
2022attribute_parameter_list:                                                               // GCC
2023        attrib
2024        | attribute_parameter_list ',' attrib
2025        ;
2026
2027attrib:                                                                                                 // GCC
2028        // empty
2029        | any_word
2030        | any_word '(' comma_expression_opt ')'
2031        ;
2032
2033any_word:                                                                                               // GCC
2034        identifier_or_typedef_name {}
2035        | storage_class_name {}
2036        | basic_type_name {}
2037        | type_qualifier {}
2038        ;
2039
2040// ============================================================================
2041// The following sections are a series of grammar patterns used to parse declarators. Multiple patterns are
2042// necessary because the type of an identifier in wrapped around the identifier in the same form as its usage
2043// in an expression, as in:
2044//
2045//              int (*f())[10] { ... };
2046//              ... (*f())[3] += 1;             // definition mimics usage
2047//
2048// Because these patterns are highly recursive, changes at a lower level in the recursion require copying some
2049// or all of the pattern. Each of these patterns has some subtle variation to ensure correct syntax in a
2050// particular context.
2051// ============================================================================
2052
2053// ----------------------------------------------------------------------------
2054// The set of valid declarators before a compound statement for defining a function is less than the set of
2055// declarators to define a variable or function prototype, e.g.:
2056//
2057//              valid declaration               invalid definition
2058//              -----------------               ------------------
2059//              int f;                                  int f {}
2060//              int *f;                                 int *f {}
2061//              int f[10];                              int f[10] {}
2062//              int (*f)(int);                  int (*f)(int) {}
2063//
2064// To preclude this syntactic anomaly requires separating the grammar rules for variable and function
2065// declarators, hence variable_declarator and function_declarator.
2066// ----------------------------------------------------------------------------
2067
2068// This pattern parses a declaration of a variable that is not redefining a typedef name. The pattern
2069// precludes declaring an array of functions versus a pointer to an array of functions.
2070
2071variable_declarator:
2072        paren_identifier attribute_list_opt
2073        | variable_ptr
2074        | variable_array attribute_list_opt
2075        | variable_function attribute_list_opt
2076        ;
2077
2078paren_identifier:
2079        identifier
2080                {
2081                        typedefTable.setNextIdentifier( *($1) );
2082                        $$ = DeclarationNode::newName( $1 );
2083                }
2084        | '(' paren_identifier ')'                                                      // redundant parenthesis
2085                { $$ = $2; }
2086        ;
2087
2088variable_ptr:
2089        '*' variable_declarator
2090                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
2091        | '*' type_qualifier_list variable_declarator
2092                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
2093        | '(' variable_ptr ')'
2094                { $$ = $2; }
2095        ;
2096
2097variable_array:
2098        paren_identifier array_dimension
2099                { $$ = $1->addArray( $2 ); }
2100        | '(' variable_ptr ')' array_dimension
2101                { $$ = $2->addArray( $4 ); }
2102        | '(' variable_array ')' multi_array_dimension          // redundant parenthesis
2103                { $$ = $2->addArray( $4 ); }
2104        | '(' variable_array ')'                                                        // redundant parenthesis
2105                { $$ = $2; }
2106        ;
2107
2108variable_function:
2109        '(' variable_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
2110                { $$ = $2->addParamList( $6 ); }
2111        | '(' variable_function ')'                                                     // redundant parenthesis
2112                { $$ = $2; }
2113        ;
2114
2115// This pattern parses a function declarator that is not redefining a typedef name. Because functions cannot
2116// be nested, there is no context where a function definition can redefine a typedef name. To allow nested
2117// functions requires further separation of variable and function declarators in typedef_redeclarator.  The
2118// pattern precludes returning arrays and functions versus pointers to arrays and functions.
2119
2120function_declarator:
2121        function_no_ptr attribute_list_opt
2122        | function_ptr
2123        | function_array attribute_list_opt
2124        ;
2125
2126function_no_ptr:
2127        paren_identifier '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
2128                { $$ = $1->addParamList( $4 ); }
2129        | '(' function_ptr ')' '(' push parameter_type_list_opt pop ')'
2130                { $$ = $2->addParamList( $6 ); }
2131        | '(' function_no_ptr ')'                                                       // redundant parenthesis
2132                { $$ = $2; }
2133        ;
2134
2135function_ptr:
2136        '*' function_declarator
2137                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
2138        | '*' type_qualifier_list function_declarator
2139                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
2140        | '(' function_ptr ')'
2141                { $$ = $2; }
2142        ;
2143
2144function_array:
2145        '(' function_ptr ')' array_dimension
2146                { $$ = $2->addArray( $4 ); }
2147        | '(' function_array ')' multi_array_dimension          // redundant parenthesis
2148                { $$ = $2->addArray( $4 ); }
2149        | '(' function_array ')'                                                        // redundant parenthesis
2150                { $$ = $2; }
2151        ;
2152
2153// This pattern parses an old-style K&R function declarator (OBSOLESCENT, see 4) that is not redefining a
2154// typedef name (see function_declarator for additional comments). The pattern precludes returning arrays and
2155// functions versus pointers to arrays and functions.
2156
2157old_function_declarator:
2158        old_function_no_ptr
2159        | old_function_ptr
2160        | old_function_array
2161        ;
2162
2163old_function_no_ptr:
2164        paren_identifier '(' identifier_list ')'                        // function_declarator handles empty parameter
2165                { $$ = $1->addIdList( $3 ); }
2166        | '(' old_function_ptr ')' '(' identifier_list ')'
2167                { $$ = $2->addIdList( $5 ); }
2168        | '(' old_function_no_ptr ')'                                           // redundant parenthesis
2169                { $$ = $2; }
2170        ;
2171
2172old_function_ptr:
2173        '*' old_function_declarator
2174                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
2175        | '*' type_qualifier_list old_function_declarator
2176                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
2177        | '(' old_function_ptr ')'
2178                { $$ = $2; }
2179        ;
2180
2181old_function_array:
2182        '(' old_function_ptr ')' array_dimension
2183                { $$ = $2->addArray( $4 ); }
2184        | '(' old_function_array ')' multi_array_dimension      // redundant parenthesis
2185                { $$ = $2->addArray( $4 ); }
2186        | '(' old_function_array ')'                                            // redundant parenthesis
2187                { $$ = $2; }
2188        ;
2189
2190// This pattern parses a declaration for a variable or function prototype that redefines a typedef name, e.g.:
2191//
2192//              typedef int foo;
2193//              {
2194//                 int foo; // redefine typedef name in new scope
2195//              }
2196//
2197// The pattern precludes declaring an array of functions versus a pointer to an array of functions, and
2198// returning arrays and functions versus pointers to arrays and functions.
2199
2200typedef_redeclarator:
2201        paren_typedef attribute_list_opt
2202        | typedef_ptr
2203        | typedef_array attribute_list_opt
2204        | typedef_function attribute_list_opt
2205        ;
2206
2207paren_typedef:
2208        TYPEDEFname
2209                {
2210                        typedefTable.setNextIdentifier( *($1) );
2211                        $$ = DeclarationNode::newName( $1 );
2212                }
2213        | '(' paren_typedef ')'
2214                { $$ = $2; }
2215        ;
2216
2217typedef_ptr:
2218        '*' typedef_redeclarator
2219                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
2220        | '*' type_qualifier_list typedef_redeclarator
2221                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
2222        | '(' typedef_ptr ')'
2223                { $$ = $2; }
2224        ;
2225
2226typedef_array:
2227        paren_typedef array_dimension
2228                { $$ = $1->addArray( $2 ); }
2229        | '(' typedef_ptr ')' array_dimension
2230                { $$ = $2->addArray( $4 ); }
2231        | '(' typedef_array ')' multi_array_dimension           // redundant parenthesis
2232                { $$ = $2->addArray( $4 ); }
2233        | '(' typedef_array ')'                                                         // redundant parenthesis
2234                { $$ = $2; }
2235        ;
2236
2237typedef_function:
2238        paren_typedef '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
2239                { $$ = $1->addParamList( $4 ); }
2240        | '(' typedef_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
2241                { $$ = $2->addParamList( $6 ); }
2242        | '(' typedef_function ')'                                                      // redundant parenthesis
2243                { $$ = $2; }
2244        ;
2245
2246// This pattern parses a declaration for a parameter variable or function prototype that is not redefining a
2247// typedef name and allows the C99 array options, which can only appear in a parameter list.  The pattern
2248// precludes declaring an array of functions versus a pointer to an array of functions, and returning arrays
2249// and functions versus pointers to arrays and functions.
2250
2251identifier_parameter_declarator:
2252        paren_identifier attribute_list_opt
2253        | identifier_parameter_ptr
2254        | identifier_parameter_array attribute_list_opt
2255        | identifier_parameter_function attribute_list_opt
2256        ;
2257
2258identifier_parameter_ptr:
2259        '*' identifier_parameter_declarator
2260                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
2261        | '*' type_qualifier_list identifier_parameter_declarator
2262                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
2263        | '(' identifier_parameter_ptr ')'
2264                { $$ = $2; }
2265        ;
2266
2267identifier_parameter_array:
2268        paren_identifier array_parameter_dimension
2269                { $$ = $1->addArray( $2 ); }
2270        | '(' identifier_parameter_ptr ')' array_dimension
2271                { $$ = $2->addArray( $4 ); }
2272        | '(' identifier_parameter_array ')' multi_array_dimension // redundant parenthesis
2273                { $$ = $2->addArray( $4 ); }
2274        | '(' identifier_parameter_array ')'                            // redundant parenthesis
2275                { $$ = $2; }
2276        ;
2277
2278identifier_parameter_function:
2279        paren_identifier '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
2280                { $$ = $1->addParamList( $4 ); }
2281        | '(' identifier_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
2282                { $$ = $2->addParamList( $6 ); }
2283        | '(' identifier_parameter_function ')'                         // redundant parenthesis
2284                { $$ = $2; }
2285        ;
2286
2287// This pattern parses a declaration for a parameter variable or function prototype that is redefining a
2288// typedef name, e.g.:
2289//
2290//              typedef int foo;
2291//              int f( int foo ); // redefine typedef name in new scope
2292//
2293// and allows the C99 array options, which can only appear in a parameter list.  In addition, the pattern
2294// handles the special meaning of parenthesis around a typedef name:
2295//
2296//              ISO/IEC 9899:1999 Section 6.7.5.3(11) : "In a parameter declaration, a single typedef name in
2297//              parentheses is taken to be an abstract declarator that specifies a function with a single parameter,
2298//              not as redundant parentheses around the identifier."
2299//
2300// which precludes the following cases:
2301//
2302//              typedef float T;
2303//              int f( int ( T [5] ) );                                 // see abstract_parameter_declarator
2304//              int g( int ( T ( int ) ) );                             // see abstract_parameter_declarator
2305//              int f( int f1( T a[5] ) );                              // see identifier_parameter_declarator
2306//              int g( int g1( T g2( int p ) ) );               // see identifier_parameter_declarator
2307//
2308// In essence, a '(' immediately to the left of typedef name, T, is interpreted as starting a parameter type
2309// list, and not as redundant parentheses around a redeclaration of T. Finally, the pattern also precludes
2310// declaring an array of functions versus a pointer to an array of functions, and returning arrays and
2311// functions versus pointers to arrays and functions.
2312
2313typedef_parameter_redeclarator:
2314        typedef attribute_list_opt
2315        | typedef_parameter_ptr
2316        | typedef_parameter_array attribute_list_opt
2317        | typedef_parameter_function attribute_list_opt
2318        ;
2319
2320typedef:
2321        TYPEDEFname
2322                {
2323                        typedefTable.setNextIdentifier( *($1) );
2324                        $$ = DeclarationNode::newName( $1 );
2325                }
2326        ;
2327
2328typedef_parameter_ptr:
2329        '*' typedef_parameter_redeclarator
2330                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
2331        | '*' type_qualifier_list typedef_parameter_redeclarator
2332                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
2333        | '(' typedef_parameter_ptr ')'
2334                { $$ = $2; }
2335        ;
2336
2337typedef_parameter_array:
2338        typedef array_parameter_dimension
2339                { $$ = $1->addArray( $2 ); }
2340        | '(' typedef_parameter_ptr ')' array_parameter_dimension
2341                { $$ = $2->addArray( $4 ); }
2342        ;
2343
2344typedef_parameter_function:
2345        typedef '(' push parameter_type_list_opt pop ')'        // empty parameter list OBSOLESCENT (see 3)
2346                { $$ = $1->addParamList( $4 ); }
2347        | '(' typedef_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
2348                { $$ = $2->addParamList( $6 ); }
2349        ;
2350
2351// This pattern parses a declaration of an abstract variable or function prototype, i.e., there is no
2352// identifier to which the type applies, e.g.:
2353//
2354//              sizeof( int );
2355//              sizeof( int [10] );
2356//
2357// The pattern precludes declaring an array of functions versus a pointer to an array of functions, and
2358// returning arrays and functions versus pointers to arrays and functions.
2359
2360abstract_declarator:
2361        abstract_ptr
2362        | abstract_array attribute_list_opt
2363        | abstract_function attribute_list_opt
2364        ;
2365
2366abstract_ptr:
2367        '*'
2368                { $$ = DeclarationNode::newPointer( 0 ); }
2369        | '*' type_qualifier_list
2370                { $$ = DeclarationNode::newPointer( $2 ); }
2371        | '*' abstract_declarator
2372                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
2373        | '*' type_qualifier_list abstract_declarator
2374                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
2375        | '(' abstract_ptr ')'
2376                { $$ = $2; }
2377        ;
2378
2379abstract_array:
2380        array_dimension
2381        | '(' abstract_ptr ')' array_dimension
2382                { $$ = $2->addArray( $4 ); }
2383        | '(' abstract_array ')' multi_array_dimension          // redundant parenthesis
2384                { $$ = $2->addArray( $4 ); }
2385        | '(' abstract_array ')'                                                        // redundant parenthesis
2386                { $$ = $2; }
2387        ;
2388
2389abstract_function:
2390        '(' push parameter_type_list_opt pop ')'                        // empty parameter list OBSOLESCENT (see 3)
2391                { $$ = DeclarationNode::newFunction( 0, 0, $3, 0 ); }
2392        | '(' abstract_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
2393                { $$ = $2->addParamList( $6 ); }
2394        | '(' abstract_function ')'                                                     // redundant parenthesis
2395                { $$ = $2; }
2396        ;
2397
2398array_dimension:
2399                // Only the first dimension can be empty.
2400        '[' push pop ']'
2401                { $$ = DeclarationNode::newArray( 0, 0, false ); }
2402        | '[' push pop ']' multi_array_dimension
2403                { $$ = DeclarationNode::newArray( 0, 0, false )->addArray( $5 ); }
2404        | multi_array_dimension
2405        ;
2406
2407multi_array_dimension:
2408        '[' push assignment_expression pop ']'
2409                { $$ = DeclarationNode::newArray( $3, 0, false ); }
2410        | '[' push '*' pop ']'                                                          // C99
2411                { $$ = DeclarationNode::newVarArray( 0 ); }
2412        | multi_array_dimension '[' push assignment_expression pop ']'
2413                { $$ = $1->addArray( DeclarationNode::newArray( $4, 0, false ) ); }
2414        | multi_array_dimension '[' push '*' pop ']'            // C99
2415                { $$ = $1->addArray( DeclarationNode::newVarArray( 0 ) ); }
2416        ;
2417
2418// This pattern parses a declaration of a parameter abstract variable or function prototype, i.e., there is no
2419// identifier to which the type applies, e.g.:
2420//
2421//              int f( int );                   // abstract variable parameter; no parameter name specified
2422//              int f( int (int) );             // abstract function-prototype parameter; no parameter name specified
2423//
2424// The pattern precludes declaring an array of functions versus a pointer to an array of functions, and
2425// returning arrays and functions versus pointers to arrays and functions.
2426
2427abstract_parameter_declarator:
2428        abstract_parameter_ptr
2429        | abstract_parameter_array attribute_list_opt
2430        | abstract_parameter_function attribute_list_opt
2431        ;
2432
2433abstract_parameter_ptr:
2434        '*'
2435                { $$ = DeclarationNode::newPointer( 0 ); }
2436        | '*' type_qualifier_list
2437                { $$ = DeclarationNode::newPointer( $2 ); }
2438        | '*' abstract_parameter_declarator
2439                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
2440        | '*' type_qualifier_list abstract_parameter_declarator
2441                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
2442        | '(' abstract_parameter_ptr ')'
2443                { $$ = $2; }
2444        ;
2445
2446abstract_parameter_array:
2447        array_parameter_dimension
2448        | '(' abstract_parameter_ptr ')' array_parameter_dimension
2449                { $$ = $2->addArray( $4 ); }
2450        | '(' abstract_parameter_array ')' multi_array_dimension // redundant parenthesis
2451                { $$ = $2->addArray( $4 ); }
2452        | '(' abstract_parameter_array ')'                                      // redundant parenthesis
2453                { $$ = $2; }
2454        ;
2455
2456abstract_parameter_function:
2457        '(' push parameter_type_list_opt pop ')'                        // empty parameter list OBSOLESCENT (see 3)
2458                { $$ = DeclarationNode::newFunction( 0, 0, $3, 0 ); }
2459        | '(' abstract_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
2460                { $$ = $2->addParamList( $6 ); }
2461        | '(' abstract_parameter_function ')'                           // redundant parenthesis
2462                { $$ = $2; }
2463        ;
2464
2465array_parameter_dimension:
2466                // Only the first dimension can be empty or have qualifiers.
2467        array_parameter_1st_dimension
2468        | array_parameter_1st_dimension multi_array_dimension
2469                { $$ = $1->addArray( $2 ); }
2470        | multi_array_dimension
2471        ;
2472
2473// The declaration of an array parameter has additional syntax over arrays in normal variable declarations:
2474//
2475//              ISO/IEC 9899:1999 Section 6.7.5.2(1) : "The optional type qualifiers and the keyword static shall
2476//              appear only in a declaration of a function parameter with an array type, and then only in the
2477//              outermost array type derivation."
2478
2479array_parameter_1st_dimension:
2480        '[' push pop ']'
2481                { $$ = DeclarationNode::newArray( 0, 0, false ); }
2482        // multi_array_dimension handles the '[' '*' ']' case
2483        | '[' push type_qualifier_list '*' pop ']'                      // remaining C99
2484                { $$ = DeclarationNode::newVarArray( $3 ); }
2485        | '[' push type_qualifier_list pop ']'
2486                { $$ = DeclarationNode::newArray( 0, $3, false ); }
2487        // multi_array_dimension handles the '[' assignment_expression ']' case
2488        | '[' push type_qualifier_list assignment_expression pop ']'
2489                { $$ = DeclarationNode::newArray( $4, $3, false ); }
2490        | '[' push STATIC type_qualifier_list_opt assignment_expression pop ']'
2491                { $$ = DeclarationNode::newArray( $5, $4, true ); }
2492        | '[' push type_qualifier_list STATIC assignment_expression pop ']'
2493                { $$ = DeclarationNode::newArray( $5, $3, true ); }
2494        ;
2495
2496// This pattern parses a declaration of an abstract variable, i.e., there is no identifier to which the type
2497// applies, e.g.:
2498//
2499//              sizeof( int ); // abstract variable; no identifier name specified
2500//
2501// The pattern precludes declaring an array of functions versus a pointer to an array of functions, and
2502// returning arrays and functions versus pointers to arrays and functions.
2503
2504variable_abstract_declarator:
2505        variable_abstract_ptr
2506        | variable_abstract_array attribute_list_opt
2507        | variable_abstract_function attribute_list_opt
2508        ;
2509
2510variable_abstract_ptr:
2511        '*'
2512                { $$ = DeclarationNode::newPointer( 0 ); }
2513        | '*' type_qualifier_list
2514                { $$ = DeclarationNode::newPointer( $2 ); }
2515        | '*' variable_abstract_declarator
2516                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
2517        | '*' type_qualifier_list variable_abstract_declarator
2518                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
2519        | '(' variable_abstract_ptr ')'
2520                { $$ = $2; }
2521        ;
2522
2523variable_abstract_array:
2524        array_dimension
2525        | '(' variable_abstract_ptr ')' array_dimension
2526                { $$ = $2->addArray( $4 ); }
2527        | '(' variable_abstract_array ')' multi_array_dimension // redundant parenthesis
2528                { $$ = $2->addArray( $4 ); }
2529        | '(' variable_abstract_array ')'                                       // redundant parenthesis
2530                { $$ = $2; }
2531        ;
2532
2533variable_abstract_function:
2534        '(' variable_abstract_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
2535                { $$ = $2->addParamList( $6 ); }
2536        | '(' variable_abstract_function ')'                            // redundant parenthesis
2537                { $$ = $2; }
2538        ;
2539
2540// This pattern parses a new-style declaration for a parameter variable or function prototype that is either
2541// an identifier or typedef name and allows the C99 array options, which can only appear in a parameter list.
2542
2543new_identifier_parameter_declarator_tuple:                              // CFA
2544        new_identifier_parameter_declarator_no_tuple
2545        | new_abstract_tuple
2546        | type_qualifier_list new_abstract_tuple
2547                { $$ = $2->addQualifiers( $1 ); }
2548        ;
2549
2550new_identifier_parameter_declarator_no_tuple:                   // CFA
2551        new_identifier_parameter_ptr
2552        | new_identifier_parameter_array
2553        ;
2554
2555new_identifier_parameter_ptr:                                                   // CFA
2556        '*' type_specifier
2557                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
2558        | type_qualifier_list '*' type_specifier
2559                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
2560        | '*' new_abstract_function
2561                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
2562        | type_qualifier_list '*' new_abstract_function
2563                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
2564        | '*' new_identifier_parameter_declarator_tuple
2565                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
2566        | type_qualifier_list '*' new_identifier_parameter_declarator_tuple
2567                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
2568        ;
2569
2570new_identifier_parameter_array:                                                 // CFA
2571                // Only the first dimension can be empty or have qualifiers. Empty dimension must be factored out due
2572                // to shift/reduce conflict with new-style empty (void) function return type.
2573        '[' push pop ']' type_specifier
2574                { $$ = $5->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
2575        | new_array_parameter_1st_dimension type_specifier
2576                { $$ = $2->addNewArray( $1 ); }
2577        | '[' push pop ']' multi_array_dimension type_specifier
2578                { $$ = $6->addNewArray( $5 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
2579        | new_array_parameter_1st_dimension multi_array_dimension type_specifier
2580                { $$ = $3->addNewArray( $2 )->addNewArray( $1 ); }
2581        | multi_array_dimension type_specifier
2582                { $$ = $2->addNewArray( $1 ); }
2583        | '[' push pop ']' new_identifier_parameter_ptr
2584                { $$ = $5->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
2585        | new_array_parameter_1st_dimension new_identifier_parameter_ptr
2586                { $$ = $2->addNewArray( $1 ); }
2587        | '[' push pop ']' multi_array_dimension new_identifier_parameter_ptr
2588                { $$ = $6->addNewArray( $5 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
2589        | new_array_parameter_1st_dimension multi_array_dimension new_identifier_parameter_ptr
2590                { $$ = $3->addNewArray( $2 )->addNewArray( $1 ); }
2591        | multi_array_dimension new_identifier_parameter_ptr
2592                { $$ = $2->addNewArray( $1 ); }
2593        ;
2594
2595new_array_parameter_1st_dimension:
2596        '[' push type_qualifier_list '*' pop ']'                        // remaining C99
2597                { $$ = DeclarationNode::newVarArray( $3 ); }
2598        | '[' push type_qualifier_list assignment_expression pop ']'
2599                { $$ = DeclarationNode::newArray( $4, $3, false ); }
2600        | '[' push declaration_qualifier_list assignment_expression pop ']'
2601                // declaration_qualifier_list must be used because of shift/reduce conflict with
2602                // assignment_expression, so a semantic check is necessary to preclude them as a type_qualifier cannot
2603                // appear in this context.
2604                { $$ = DeclarationNode::newArray( $4, $3, true ); }
2605        | '[' push declaration_qualifier_list type_qualifier_list assignment_expression pop ']'
2606                { $$ = DeclarationNode::newArray( $5, $4->addQualifiers( $3 ), true ); }
2607        ;
2608
2609// This pattern parses a new-style declaration of an abstract variable or function prototype, i.e., there is
2610// no identifier to which the type applies, e.g.:
2611//
2612//              [int] f( int );                         // abstract variable parameter; no parameter name specified
2613//              [int] f( [int] (int) );         // abstract function-prototype parameter; no parameter name specified
2614//
2615// These rules need LR(3):
2616//
2617//              new_abstract_tuple identifier_or_typedef_name
2618//              '[' new_parameter_list ']' identifier_or_typedef_name '(' new_parameter_type_list_opt ')'
2619//
2620// since a function return type can be syntactically identical to a tuple type:
2621//
2622//              [int, int] t;
2623//              [int, int] f( int );
2624//
2625// Therefore, it is necessary to look at the token after identifier_or_typedef_name to know when to reduce
2626// new_abstract_tuple. To make this LR(1), several rules have to be flattened (lengthened) to allow the
2627// necessary lookahead. To accomplish this, new_abstract_declarator has an entry point without tuple, and
2628// tuple declarations are duplicated when appearing with new_function_specifier.
2629
2630new_abstract_declarator_tuple:                                                  // CFA
2631        new_abstract_tuple
2632        | type_qualifier_list new_abstract_tuple
2633                { $$ = $2->addQualifiers( $1 ); }
2634        | new_abstract_declarator_no_tuple
2635        ;
2636
2637new_abstract_declarator_no_tuple:                                               // CFA
2638        new_abstract_ptr
2639        | new_abstract_array
2640        ;
2641
2642new_abstract_ptr:                                                                               // CFA
2643        '*' type_specifier
2644                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
2645        | type_qualifier_list '*' type_specifier
2646                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
2647        | '*' new_abstract_function
2648                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
2649        | type_qualifier_list '*' new_abstract_function
2650                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
2651        | '*' new_abstract_declarator_tuple
2652                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
2653        | type_qualifier_list '*' new_abstract_declarator_tuple
2654                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
2655        ;
2656
2657new_abstract_array:                                                                             // CFA
2658                // Only the first dimension can be empty. Empty dimension must be factored out due to shift/reduce
2659                // conflict with empty (void) function return type.
2660        '[' push pop ']' type_specifier
2661                { $$ = $5->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
2662        | '[' push pop ']' multi_array_dimension type_specifier
2663                { $$ = $6->addNewArray( $5 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
2664        | multi_array_dimension type_specifier
2665                { $$ = $2->addNewArray( $1 ); }
2666        | '[' push pop ']' new_abstract_ptr
2667                { $$ = $5->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
2668        | '[' push pop ']' multi_array_dimension new_abstract_ptr
2669                { $$ = $6->addNewArray( $5 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
2670        | multi_array_dimension new_abstract_ptr
2671                { $$ = $2->addNewArray( $1 ); }
2672        ;
2673
2674new_abstract_tuple:                                                                             // CFA
2675        '[' push new_abstract_parameter_list pop ']'
2676                { $$ = DeclarationNode::newTuple( $3 ); }
2677        ;
2678
2679new_abstract_function:                                                                  // CFA
2680        '[' push pop ']' '(' new_parameter_type_list_opt ')'
2681                { $$ = DeclarationNode::newFunction( 0, DeclarationNode::newTuple( 0 ), $6, 0 ); }
2682        | new_abstract_tuple '(' push new_parameter_type_list_opt pop ')'
2683                { $$ = DeclarationNode::newFunction( 0, $1, $4, 0 ); }
2684        | new_function_return '(' push new_parameter_type_list_opt pop ')'
2685                { $$ = DeclarationNode::newFunction( 0, $1, $4, 0 ); }
2686        ;
2687
2688// 1) ISO/IEC 9899:1999 Section 6.7.2(2) : "At least one type specifier shall be given in the declaration
2689//    specifiers in each declaration, and in the specifier-qualifier list in each structure declaration and
2690//    type name."
2691//
2692// 2) ISO/IEC 9899:1999 Section 6.11.5(1) : "The placement of a storage-class specifier other than at the
2693//    beginning of the declaration specifiers in a declaration is an obsolescent feature."
2694//
2695// 3) ISO/IEC 9899:1999 Section 6.11.6(1) : "The use of function declarators with empty parentheses (not
2696//    prototype-format parameter type declarators) is an obsolescent feature."
2697//
2698// 4) ISO/IEC 9899:1999 Section 6.11.7(1) : "The use of function definitions with separate parameter
2699//    identifier and declaration lists (not prototype-format parameter type and identifier declarators) is an
2700//    obsolescent feature.
2701
2702//************************* MISCELLANEOUS ********************************
2703
2704comma_opt:                                                                                              // redundant comma
2705        // empty
2706        | ','
2707        ;
2708
2709assignment_opt:
2710        // empty
2711                { $$ = 0; }
2712        | '=' assignment_expression
2713                { $$ = $2; }
2714        ;
2715
2716%%
2717// ----end of grammar----
2718
2719void yyerror( char *string ) {
2720        using std::cout;
2721        using std::endl;
2722        cout << "Error ";
2723        if ( yyfilename ) {
2724                cout << "in file " << yyfilename << " ";
2725        }
2726        cout << "at line " << yylineno << " reading token \"" << *(yylval.tok.str) << "\"" << endl;
2727}
2728
2729// Local Variables: //
2730// fill-column: 110 //
2731// tab-width: 4 //
2732// mode: c++ //
2733// compile-command: "make install" //
2734// End: //
Note: See TracBrowser for help on using the repository browser.