source: src/Parser/parser.yy@ 2988eeb

ADT aaron-thesis arm-eh ast-experimental cleanup-dtors deferred_resn demangler enum forall-pointer-decay jacob/cs343-translation jenkins-sandbox new-ast new-ast-unique-expr new-env no_list persistent-indexer pthread-emulation qualifiedEnum resolv-new with_gc
Last change on this file since 2988eeb was dd020c0, checked in by Peter A. Buhr <pabuhr@…>, 9 years ago

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