source: src/Parser/parser.yy@ 198e335

ADT arm-eh ast-experimental enum forall-pointer-decay jacob/cs343-translation new-ast-unique-expr pthread-emulation qualifiedEnum stuck-waitfor-destruct
Last change on this file since 198e335 was ca33b15, checked in by Peter A. Buhr <pabuhr@…>, 5 years ago

create downstream data structures for array-type for-control
  • Property mode set to 100644
File size: 144.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// parser.yy --
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 : Tue Mar 30 18:39:23 2021
13// Update Count : 4965
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
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#define YYERROR_VERBOSE // more information in syntax errors
46
47#undef __GNUC_MINOR__
48
49#include <cstdio>
50#include <stack>
51using namespace std;
52
53#include "SynTree/Declaration.h"
54#include "ParseNode.h"
55#include "TypedefTable.h"
56#include "TypeData.h"
57#include "SynTree/LinkageSpec.h"
58#include "Common/SemanticError.h" // error_str
59#include "Common/utility.h" // for maybeMoveBuild, maybeBuild, CodeLo...
60
61extern DeclarationNode * parseTree;
62extern LinkageSpec::Spec linkage;
63extern TypedefTable typedefTable;
64
65stack<LinkageSpec::Spec> linkageStack;
66
67bool appendStr( string & to, string & from ) {
68 // 1. Multiple strings are concatenated into a single string but not combined internally. The reason is that
69 // "\x12" "3" is treated as 2 characters versus 1 because "escape sequences are converted into single members of
70 // the execution character set just prior to adjacent string literal concatenation" (C11, Section 6.4.5-8). It is
71 // easier to let the C compiler handle this case.
72 //
73 // 2. String encodings are transformed into canonical form (one encoding at start) so the encoding can be found
74 // without searching the string, e.g.: "abc" L"def" L"ghi" => L"abc" "def" "ghi". Multiple encodings must match,
75 // i.e., u"a" U"b" L"c" is disallowed.
76
77 if ( from[0] != '"' ) { // encoding ?
78 if ( to[0] != '"' ) { // encoding ?
79 if ( to[0] != from[0] || to[1] != from[1] ) { // different encodings ?
80 yyerror( "non-matching string encodings for string-literal concatenation" );
81 return false; // parse error, must call YYERROR in action
82 } else if ( from[1] == '8' ) {
83 from.erase( 0, 1 ); // remove 2nd encoding
84 } // if
85 } else {
86 if ( from[1] == '8' ) { // move encoding to start
87 to = "u8" + to;
88 from.erase( 0, 1 ); // remove 2nd encoding
89 } else {
90 to = from[0] + to;
91 } // if
92 } // if
93 from.erase( 0, 1 ); // remove 2nd encoding
94 } // if
95 to += " " + from; // concatenated into single string
96 return true;
97} // appendStr
98
99DeclarationNode * distAttr( DeclarationNode * specifier, DeclarationNode * declList ) {
100 // distribute declaration_specifier across all declared variables, e.g., static, const, __attribute__.
101 DeclarationNode * cur = declList, * cl = (new DeclarationNode)->addType( specifier );
102 for ( cur = dynamic_cast<DeclarationNode *>( cur->get_next() ); cur != nullptr; cur = dynamic_cast<DeclarationNode *>( cur->get_next() ) ) {
103 cl->cloneBaseType( cur );
104 } // for
105 declList->addType( cl );
106 return declList;
107} // distAttr
108
109void distExt( DeclarationNode * declaration ) {
110 // distribute EXTENSION across all declarations
111 for ( DeclarationNode *iter = declaration; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) {
112 iter->set_extension( true );
113 } // for
114} // distExt
115
116void distInl( DeclarationNode * declaration ) {
117 // distribute EXTENSION across all declarations
118 for ( DeclarationNode *iter = declaration; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) {
119 iter->set_inLine( true );
120 } // for
121} // distInl
122
123void distQual( DeclarationNode * declaration, DeclarationNode * qualifiers ) {
124 // distribute qualifiers across all non-variable declarations in a distribution statemement
125 for ( DeclarationNode * iter = declaration; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) {
126 // SKULLDUGGERY: Distributions are parsed inside out, so qualifiers are added to declarations inside out. Since
127 // addQualifiers appends to the back of the list, the forall clauses are in the wrong order (right to left). To
128 // get the qualifiers in the correct order and still use addQualifiers (otherwise, 90% of addQualifiers has to
129 // be copied to add to front), the appropriate forall pointers are interchanged before calling addQualifiers.
130 DeclarationNode * clone = qualifiers->clone();
131 if ( qualifiers->type ) { // forall clause ? (handles SC)
132 if ( iter->type->kind == TypeData::Aggregate ) { // struct/union ?
133 swap( clone->type->forall, iter->type->aggregate.params );
134 iter->addQualifiers( clone );
135 } else if ( iter->type->kind == TypeData::AggregateInst && iter->type->aggInst.aggregate->aggregate.body ) { // struct/union ?
136 // Create temporary node to hold aggregate, call addQualifiers as above, then put nodes back together.
137 DeclarationNode newnode;
138 swap( newnode.type, iter->type->aggInst.aggregate );
139 swap( clone->type->forall, newnode.type->aggregate.params );
140 newnode.addQualifiers( clone );
141 swap( newnode.type, iter->type->aggInst.aggregate );
142 } else if ( iter->type->kind == TypeData::Function ) { // routines ?
143 swap( clone->type->forall, iter->type->forall );
144 iter->addQualifiers( clone );
145 } // if
146 } else { // just SC qualifiers
147 iter->addQualifiers( clone );
148 } // if
149 } // for
150 delete qualifiers;
151} // distQual
152
153// There is an ambiguity for inline generic-routine return-types and generic routines.
154// forall( otype T ) struct S { int i; } bar( T ) {}
155// Does the forall bind to the struct or the routine, and how would it be possible to explicitly specify the binding.
156// forall( otype T ) struct S { int T; } forall( otype W ) bar( W ) {}
157// Currently, the forall is associated with the routine, and the generic type has to be separately defined:
158// forall( otype T ) struct S { int T; };
159// forall( otype W ) bar( W ) {}
160
161void rebindForall( DeclarationNode * declSpec, DeclarationNode * funcDecl ) {
162 if ( declSpec->type->kind == TypeData::Aggregate ) { // ignore aggregate definition
163 funcDecl->type->forall = declSpec->type->aggregate.params; // move forall from aggregate to function type
164 declSpec->type->aggregate.params = nullptr;
165 } // if
166} // rebindForall
167
168string * build_postfix_name( string * name ) {
169 *name = string("__postfix_func_") + *name;
170 return name;
171} // build_postfix_name
172
173DeclarationNode * fieldDecl( DeclarationNode * typeSpec, DeclarationNode * fieldList ) {
174 if ( ! fieldList ) { // field declarator ?
175 if ( ! ( typeSpec->type && (typeSpec->type->kind == TypeData::Aggregate || typeSpec->type->kind == TypeData::Enum) ) ) {
176 stringstream ss;
177 typeSpec->type->print( ss );
178 SemanticWarning( yylloc, Warning::SuperfluousDecl, ss.str().c_str() );
179 return nullptr;
180 } // if
181 fieldList = DeclarationNode::newName( nullptr );
182 } // if
183 return distAttr( typeSpec, fieldList ); // mark all fields in list
184} // fieldDecl
185
186ForCtrl * forCtrl( ExpressionNode * type, string * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
187 ConstantExpr * constant = dynamic_cast<ConstantExpr *>(type->expr.get());
188 if ( constant && (constant->get_constant()->get_value() == "0" || constant->get_constant()->get_value() == "1") ) {
189 type = new ExpressionNode( new CastExpr( maybeMoveBuild<Expression>(type), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) ) );
190 } // if
191 return new ForCtrl(
192 distAttr( DeclarationNode::newTypeof( type, true ), DeclarationNode::newName( index )->addInitializer( new InitializerNode( start ) ) ),
193 // NULL comp/inc => leave blank
194 comp ? new ExpressionNode( build_binary_val( compop, new ExpressionNode( build_varref( new string( *index ) ) ), comp ) ) : 0,
195 inc ? new ExpressionNode( build_binary_val( compop == OperKinds::LThan || compop == OperKinds::LEThan ? // choose += or -= for upto/downto
196 OperKinds::PlusAssn : OperKinds::MinusAssn, new ExpressionNode( build_varref( new string( *index ) ) ), inc ) ) : 0 );
197} // forCtrl
198
199ForCtrl * forCtrl( ExpressionNode * type, ExpressionNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
200 if ( NameExpr * identifier = dynamic_cast<NameExpr *>(index->expr.get()) ) {
201 return forCtrl( type, new string( identifier->name ), start, compop, comp, inc );
202 } else if ( CommaExpr * commaExpr = dynamic_cast<CommaExpr *>(index->expr.get()) ) {
203 if ( NameExpr * identifier = dynamic_cast<NameExpr *>(commaExpr->arg1 ) ) {
204 return forCtrl( type, new string( identifier->name ), start, compop, comp, inc );
205 } else {
206 SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed." ); return nullptr;
207 } // if
208 } else {
209 SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed." ); return nullptr;
210 } // if
211} // forCtrl
212
213bool forall = false, yyy = false; // aggregate have one or more forall qualifiers ?
214
215// https://www.gnu.org/software/bison/manual/bison.html#Location-Type
216#define YYLLOC_DEFAULT(Cur, Rhs, N) \
217if ( N ) { \
218 (Cur).first_line = YYRHSLOC( Rhs, 1 ).first_line; \
219 (Cur).first_column = YYRHSLOC( Rhs, 1 ).first_column; \
220 (Cur).last_line = YYRHSLOC( Rhs, N ).last_line; \
221 (Cur).last_column = YYRHSLOC( Rhs, N ).last_column; \
222 (Cur).filename = YYRHSLOC( Rhs, 1 ).filename; \
223} else { \
224 (Cur).first_line = (Cur).last_line = YYRHSLOC( Rhs, 0 ).last_line; \
225 (Cur).first_column = (Cur).last_column = YYRHSLOC( Rhs, 0 ).last_column; \
226 (Cur).filename = YYRHSLOC( Rhs, 0 ).filename; \
227}
228%}
229
230%define parse.error verbose
231
232// Types declaration for productions
233%union {
234 Token tok;
235 ParseNode * pn;
236 ExpressionNode * en;
237 DeclarationNode * decl;
238 AggregateDecl::Aggregate aggKey;
239 TypeDecl::Kind tclass;
240 StatementNode * sn;
241 WaitForStmt * wfs;
242 Expression * constant;
243 IfCtrl * ifctl;
244 ForCtrl * fctl;
245 enum OperKinds compop;
246 LabelNode * label;
247 InitializerNode * in;
248 OperKinds op;
249 std::string * str;
250 bool flag;
251 CatchStmt::Kind catch_kind;
252 GenericExpr * genexpr;
253}
254
255//************************* TERMINAL TOKENS ********************************
256
257// keywords
258%token TYPEDEF
259%token EXTERN STATIC AUTO REGISTER
260%token THREADLOCAL // C11
261%token INLINE FORTRAN // C99, extension ISO/IEC 9899:1999 Section J.5.9(1)
262%token NORETURN // C11
263%token CONST VOLATILE
264%token RESTRICT // C99
265%token ATOMIC // C11
266%token FORALL MUTEX VIRTUAL COERCE // CFA
267%token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED
268%token BOOL COMPLEX IMAGINARY // C99
269%token INT128 UINT128 uuFLOAT80 uuFLOAT128 // GCC
270%token uFLOAT16 uFLOAT32 uFLOAT32X uFLOAT64 uFLOAT64X uFLOAT128 // GCC
271%token ZERO_T ONE_T // CFA
272%token VALIST // GCC
273%token AUTO_TYPE // GCC
274%token TYPEOF BASETYPEOF LABEL // GCC
275%token ENUM STRUCT UNION
276%token EXCEPTION // CFA
277%token GENERATOR COROUTINE MONITOR THREAD // CFA
278%token OTYPE FTYPE DTYPE TTYPE TRAIT // CFA
279%token SIZEOF OFFSETOF
280// %token RESUME // CFA
281%token SUSPEND // CFA
282%token ATTRIBUTE EXTENSION // GCC
283%token IF ELSE SWITCH CASE DEFAULT DO WHILE FOR BREAK CONTINUE GOTO RETURN
284%token CHOOSE DISABLE ENABLE FALLTHRU FALLTHROUGH TRY THROW THROWRESUME AT WITH WHEN WAITFOR // CFA
285%token ASM // C99, extension ISO/IEC 9899:1999 Section J.5.10(1)
286%token ALIGNAS ALIGNOF GENERIC STATICASSERT // C11
287
288// names and constants: lexer differentiates between identifier and typedef names
289%token<tok> IDENTIFIER QUOTED_IDENTIFIER TYPEDEFname TYPEGENname
290%token<tok> TIMEOUT WOR CATCH RECOVER CATCHRESUME FIXUP FINALLY // CFA
291%token<tok> INTEGERconstant CHARACTERconstant STRINGliteral
292%token<tok> DIRECTIVE
293// Floating point constant is broken into three kinds of tokens because of the ambiguity with tuple indexing and
294// overloading constants 0/1, e.g., x.1 is lexed as (x)(.1), where (.1) is a factional constant, but is semantically
295// converted into the tuple index (.)(1). e.g., 3.x
296%token<tok> FLOATING_DECIMALconstant FLOATING_FRACTIONconstant FLOATINGconstant
297
298// multi-character operators
299%token ARROW // ->
300%token ICR DECR // ++ --
301%token LS RS // << >>
302%token LE GE EQ NE // <= >= == !=
303%token ANDAND OROR // && ||
304%token ELLIPSIS // ...
305
306%token EXPassign MULTassign DIVassign MODassign // \= *= /= %=
307%token PLUSassign MINUSassign // += -=
308%token LSassign RSassign // <<= >>=
309%token ANDassign ERassign ORassign // &= ^= |=
310
311%token ErangeUpEq ErangeDown ErangeDownEq // ~= -~ -~=
312%token ATassign // @=
313
314%type<tok> identifier
315%type<tok> identifier_or_type_name attr_name
316%type<tok> quasi_keyword
317%type<constant> string_literal
318%type<str> string_literal_list
319
320// expressions
321%type<en> constant
322%type<en> tuple tuple_expression_list
323%type<op> ptrref_operator unary_operator assignment_operator simple_assignment_operator compound_assignment_operator
324%type<en> primary_expression postfix_expression unary_expression
325%type<en> cast_expression_list cast_expression exponential_expression multiplicative_expression additive_expression
326%type<en> shift_expression relational_expression equality_expression
327%type<en> AND_expression exclusive_OR_expression inclusive_OR_expression
328%type<en> logical_AND_expression logical_OR_expression
329%type<en> conditional_expression constant_expression assignment_expression assignment_expression_opt
330%type<en> comma_expression comma_expression_opt
331%type<en> argument_expression_list_opt argument_expression default_initializer_opt
332%type<ifctl> if_control_expression
333%type<fctl> for_control_expression for_control_expression_list
334%type<compop> inclexcl
335%type<en> subrange
336%type<decl> asm_name_opt
337%type<en> asm_operands_opt asm_operands_list asm_operand
338%type<label> label_list
339%type<en> asm_clobbers_list_opt
340%type<flag> asm_volatile_opt
341%type<en> handler_predicate_opt
342%type<genexpr> generic_association generic_assoc_list
343
344// statements
345%type<sn> statement labeled_statement compound_statement
346%type<sn> statement_decl statement_decl_list statement_list_nodecl
347%type<sn> selection_statement if_statement
348%type<sn> switch_clause_list_opt switch_clause_list
349%type<en> case_value
350%type<sn> case_clause case_value_list case_label case_label_list
351%type<sn> iteration_statement jump_statement
352%type<sn> expression_statement asm_statement
353%type<sn> with_statement
354%type<en> with_clause_opt
355%type<sn> exception_statement handler_clause finally_clause
356%type<catch_kind> handler_key
357%type<sn> mutex_statement
358%type<en> when_clause when_clause_opt waitfor timeout
359%type<sn> waitfor_statement
360%type<wfs> waitfor_clause
361
362// declarations
363%type<decl> abstract_declarator abstract_ptr abstract_array abstract_function array_dimension multi_array_dimension
364%type<decl> abstract_parameter_declarator abstract_parameter_ptr abstract_parameter_array abstract_parameter_function array_parameter_dimension array_parameter_1st_dimension
365%type<decl> abstract_parameter_declaration
366
367%type<aggKey> aggregate_key aggregate_data aggregate_control
368%type<decl> aggregate_type aggregate_type_nobody
369
370%type<decl> assertion assertion_list assertion_list_opt
371
372%type<en> bit_subrange_size_opt bit_subrange_size
373
374%type<decl> basic_declaration_specifier basic_type_name basic_type_specifier direct_type indirect_type
375
376%type<decl> trait_declaration trait_declaration_list trait_declaring_list trait_specifier
377
378%type<decl> declaration declaration_list declaration_list_opt declaration_qualifier_list
379%type<decl> declaration_specifier declaration_specifier_nobody declarator declaring_list
380
381%type<decl> elaborated_type elaborated_type_nobody
382
383%type<decl> enumerator_list enum_type enum_type_nobody
384%type<en> enumerator_value_opt
385
386%type<decl> external_definition external_definition_list external_definition_list_opt
387
388%type<decl> exception_declaration
389
390%type<decl> field_declaration_list_opt field_declaration field_declaring_list_opt field_declarator field_abstract_list_opt field_abstract
391%type<en> field field_name_list field_name fraction_constants_opt
392
393%type<decl> external_function_definition function_definition function_array function_declarator function_no_ptr function_ptr
394
395%type<decl> identifier_parameter_declarator identifier_parameter_ptr identifier_parameter_array identifier_parameter_function
396%type<decl> identifier_list
397
398%type<decl> cfa_abstract_array cfa_abstract_declarator_no_tuple cfa_abstract_declarator_tuple
399%type<decl> cfa_abstract_function cfa_abstract_parameter_declaration cfa_abstract_parameter_list
400%type<decl> cfa_abstract_ptr cfa_abstract_tuple
401
402%type<decl> cfa_array_parameter_1st_dimension
403
404%type<decl> cfa_trait_declaring_list cfa_declaration cfa_field_declaring_list cfa_field_abstract_list
405%type<decl> cfa_function_declaration cfa_function_return cfa_function_specifier
406
407%type<decl> cfa_identifier_parameter_array cfa_identifier_parameter_declarator_no_tuple
408%type<decl> cfa_identifier_parameter_declarator_tuple cfa_identifier_parameter_ptr
409
410%type<decl> cfa_parameter_declaration cfa_parameter_list cfa_parameter_ellipsis_list_opt
411
412%type<decl> cfa_typedef_declaration cfa_variable_declaration cfa_variable_specifier
413
414%type<decl> c_declaration static_assert
415%type<decl> KR_function_declarator KR_function_no_ptr KR_function_ptr KR_function_array
416%type<decl> KR_parameter_list KR_parameter_list_opt
417
418%type<decl> parameter_declaration parameter_list parameter_type_list_opt
419
420%type<decl> paren_identifier paren_type
421
422%type<decl> storage_class storage_class_list
423
424%type<decl> sue_declaration_specifier sue_declaration_specifier_nobody sue_type_specifier sue_type_specifier_nobody
425
426%type<tclass> type_class new_type_class
427%type<decl> type_declarator type_declarator_name type_declaring_list
428
429%type<decl> type_declaration_specifier type_type_specifier type_name typegen_name
430%type<decl> typedef_name typedef_declaration typedef_expression
431
432%type<decl> variable_type_redeclarator type_ptr type_array type_function
433
434%type<decl> type_parameter_redeclarator type_parameter_ptr type_parameter_array type_parameter_function
435
436%type<decl> type type_no_function
437%type<decl> type_parameter type_parameter_list type_initializer_opt
438
439%type<en> type_parameters_opt type_list
440
441%type<decl> type_qualifier type_qualifier_name forall type_qualifier_list_opt type_qualifier_list
442%type<decl> type_specifier type_specifier_nobody
443
444%type<decl> variable_declarator variable_ptr variable_array variable_function
445%type<decl> variable_abstract_declarator variable_abstract_ptr variable_abstract_array variable_abstract_function
446
447%type<decl> attribute_list_opt attribute_list attribute attribute_name_list attribute_name
448
449// initializers
450%type<in> initializer initializer_list_opt initializer_opt
451
452// designators
453%type<en> designator designator_list designation
454
455
456// Handle shift/reduce conflict for dangling else by shifting the ELSE token. For example, this string is ambiguous:
457// .---------. matches IF '(' comma_expression ')' statement . (reduce)
458// if ( C ) S1 else S2
459// `-----------------' matches IF '(' comma_expression ')' statement . (shift) ELSE statement */
460// Similar issues exit with the waitfor statement.
461
462// Order of these lines matters (low-to-high precedence). THEN is left associative over WOR/TIMEOUT/ELSE, WOR is left
463// associative over TIMEOUT/ELSE, and TIMEOUT is left associative over ELSE.
464%precedence THEN // rule precedence for IF/WAITFOR statement
465%precedence WOR // token precedence for start of WOR in WAITFOR statement
466%precedence TIMEOUT // token precedence for start of TIMEOUT in WAITFOR statement
467%precedence CATCH // token precedence for start of TIMEOUT in WAITFOR statement
468%precedence RECOVER // token precedence for start of TIMEOUT in WAITFOR statement
469%precedence CATCHRESUME // token precedence for start of TIMEOUT in WAITFOR statement
470%precedence FIXUP // token precedence for start of TIMEOUT in WAITFOR statement
471%precedence FINALLY // token precedence for start of TIMEOUT in WAITFOR statement
472%precedence ELSE // token precedence for start of else clause in IF/WAITFOR statement
473
474
475// Handle shift/reduce conflict for generic type by shifting the '(' token. For example, this string is ambiguous:
476// forall( otype T ) struct Foo { T v; };
477// .-----. matches pointer to function returning a generic (which is impossible without a type)
478// Foo ( *fp )( int );
479// `---' matches start of TYPEGENname '('
480// must be:
481// Foo( int ) ( *fp )( int );
482// The same problem occurs here:
483// forall( otype T ) struct Foo { T v; } ( *fp )( int );
484// must be:
485// forall( otype T ) struct Foo { T v; } ( int ) ( *fp )( int );
486
487// Order of these lines matters (low-to-high precedence).
488%precedence TYPEGENname
489%precedence '}'
490%precedence '('
491
492// %precedence RESUME
493// %precedence '{'
494// %precedence ')'
495
496%locations // support location tracking for error messages
497
498%start translation_unit // parse-tree root
499
500%%
501//************************* Namespace Management ********************************
502
503// The C grammar is not context free because it relies on the distinct terminal symbols "identifier" and "TYPEDEFname",
504// which are lexically identical.
505//
506// typedef int foo; // identifier foo must now be scanned as TYPEDEFname
507// foo f; // to allow it to appear in this context
508//
509// While it may be possible to write a purely context-free grammar, such a grammar would obscure the relationship
510// between syntactic and semantic constructs. Cforall compounds this problem by introducing type names local to the
511// scope of a declaration (for instance, those introduced through "forall" qualifiers), and by introducing "type
512// generators" -- parameterized types. This latter type name creates a third class of identifiers, "TYPEGENname", which
513// must be distinguished by the lexical scanner.
514//
515// Since the scanner cannot distinguish among the different classes of identifiers without some context information,
516// there is a type table (typedefTable), which holds type names and identifiers that override type names, for each named
517// scope. During parsing, semantic actions update the type table by adding new identifiers in the current scope. For
518// each context that introduces a name scope, a new level is created in the type table and that level is popped on
519// exiting the scope. Since type names can be local to a particular declaration, each declaration is itself a scope.
520// This requires distinguishing between type names that are local to the current declaration scope and those that
521// persist past the end of the declaration (i.e., names defined in "typedef" or "otype" declarations).
522//
523// The non-terminals "push" and "pop" denote the opening and closing of named scopes. Every push has a matching pop in
524// the production rule. There are multiple lists of declarations, where each declaration is a named scope, so pop/push
525// around the list separator.
526//
527// int f( forall(T) T (*f1) T , forall( S ) S (*f2)( S ) );
528// push pop push pop
529
530push:
531 { typedefTable.enterScope(); }
532 ;
533
534pop:
535 { typedefTable.leaveScope(); }
536 ;
537
538//************************* CONSTANTS ********************************
539
540constant:
541 // ENUMERATIONconstant is not included here; it is treated as a variable with type "enumeration constant".
542 INTEGERconstant { $$ = new ExpressionNode( build_constantInteger( *$1 ) ); }
543 | FLOATING_DECIMALconstant { $$ = new ExpressionNode( build_constantFloat( *$1 ) ); }
544 | FLOATING_FRACTIONconstant { $$ = new ExpressionNode( build_constantFloat( *$1 ) ); }
545 | FLOATINGconstant { $$ = new ExpressionNode( build_constantFloat( *$1 ) ); }
546 | CHARACTERconstant { $$ = new ExpressionNode( build_constantChar( *$1 ) ); }
547 ;
548
549quasi_keyword: // CFA
550 TIMEOUT
551 | WOR
552 | CATCH
553 | RECOVER
554 | CATCHRESUME
555 | FIXUP
556 | FINALLY
557 ;
558
559identifier:
560 IDENTIFIER
561 | quasi_keyword
562 | '@' // CFA
563 { Token tok = { new string( DeclarationNode::anonymous.newName() ), yylval.tok.loc }; $$ = tok; }
564 ;
565
566string_literal:
567 string_literal_list { $$ = build_constantStr( *$1 ); }
568 ;
569
570string_literal_list: // juxtaposed strings are concatenated
571 STRINGliteral { $$ = $1; } // conversion from tok to str
572 | string_literal_list STRINGliteral
573 {
574 if ( ! appendStr( *$1, *$2 ) ) YYERROR; // append 2nd juxtaposed string to 1st
575 delete $2; // allocated by lexer
576 $$ = $1; // conversion from tok to str
577 }
578 ;
579
580//************************* EXPRESSIONS ********************************
581
582primary_expression:
583 IDENTIFIER // typedef name cannot be used as a variable name
584 { $$ = new ExpressionNode( build_varref( $1 ) ); }
585 | quasi_keyword
586 { $$ = new ExpressionNode( build_varref( $1 ) ); }
587 | tuple
588 | '(' comma_expression ')'
589 { $$ = $2; }
590 | '(' compound_statement ')' // GCC, lambda expression
591 { $$ = new ExpressionNode( new StmtExpr( dynamic_cast<CompoundStmt *>(maybeMoveBuild<Statement>($2) ) ) ); }
592 | type_name '.' identifier // CFA, nested type
593 { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
594 | type_name '.' '[' field_name_list ']' // CFA, nested type / tuple field selector
595 { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
596 | GENERIC '(' assignment_expression ',' generic_assoc_list ')' // C11
597 {
598 // add the missing control expression to the GenericExpr and return it
599 $5->control = maybeMoveBuild<Expression>( $3 );
600 $$ = new ExpressionNode( $5 );
601 }
602 // | RESUME '(' comma_expression ')'
603 // { SemanticError( yylloc, "Resume expression is currently unimplemented." ); $$ = nullptr; }
604 // | RESUME '(' comma_expression ')' compound_statement
605 // { SemanticError( yylloc, "Resume expression is currently unimplemented." ); $$ = nullptr; }
606 ;
607
608generic_assoc_list: // C11
609 generic_association
610 | generic_assoc_list ',' generic_association
611 {
612 // steal the association node from the singleton and delete the wrapper
613 $1->associations.splice($1->associations.end(), $3->associations);
614 delete $3;
615 $$ = $1;
616 }
617 ;
618
619generic_association: // C11
620 type_no_function ':' assignment_expression
621 {
622 // create a GenericExpr wrapper with one association pair
623 $$ = new GenericExpr( nullptr, { { maybeMoveBuildType($1), maybeMoveBuild<Expression>( $3 ) } } );
624 }
625 | DEFAULT ':' assignment_expression
626 { $$ = new GenericExpr( nullptr, { { maybeMoveBuild<Expression>( $3 ) } } ); }
627 ;
628
629postfix_expression:
630 primary_expression
631 | postfix_expression '[' assignment_expression ',' comma_expression ']'
632 // { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, $1, new ExpressionNode( build_binary_val( OperKinds::Index, $3, $5 ) ) ) ); }
633 { SemanticError( yylloc, "New array subscript is currently unimplemented." ); $$ = nullptr; }
634 | postfix_expression '[' assignment_expression ']'
635 // CFA, comma_expression disallowed in this context because it results in a common user error: subscripting a
636 // matrix with x[i,j] instead of x[i][j]. While this change is not backwards compatible, there seems to be
637 // little advantage to this feature and many disadvantages. It is possible to write x[(i,j)] in CFA, which is
638 // equivalent to the old x[i,j].
639 { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, $1, $3 ) ); }
640 | postfix_expression '{' argument_expression_list_opt '}' // CFA, constructor call
641 {
642 Token fn;
643 fn.str = new std::string( "?{}" ); // location undefined - use location of '{'?
644 $$ = new ExpressionNode( new ConstructorExpr( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $1 )->set_last( $3 ) ) ) );
645 }
646 | postfix_expression '(' argument_expression_list_opt ')'
647 { $$ = new ExpressionNode( build_func( $1, $3 ) ); }
648 | postfix_expression '`' identifier // CFA, postfix call
649 { $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( build_postfix_name( $3 ) ) ), $1 ) ); }
650 | constant '`' identifier // CFA, postfix call
651 { $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( build_postfix_name( $3 ) ) ), $1 ) ); }
652 | string_literal '`' identifier // CFA, postfix call
653 { $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( build_postfix_name( $3 ) ) ), new ExpressionNode( $1 ) ) ); }
654 | postfix_expression '.' identifier
655 { $$ = new ExpressionNode( build_fieldSel( $1, build_varref( $3 ) ) ); }
656 | postfix_expression '.' INTEGERconstant // CFA, tuple index
657 { $$ = new ExpressionNode( build_fieldSel( $1, build_constantInteger( *$3 ) ) ); }
658 | postfix_expression FLOATING_FRACTIONconstant // CFA, tuple index
659 { $$ = new ExpressionNode( build_fieldSel( $1, build_field_name_FLOATING_FRACTIONconstant( *$2 ) ) ); }
660 | postfix_expression '.' '[' field_name_list ']' // CFA, tuple field selector
661 { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $4 ) ) ); }
662 | postfix_expression '.' aggregate_control
663 { $$ = new ExpressionNode( build_keyword_cast( $3, $1 ) ); }
664 | postfix_expression ARROW identifier
665 { $$ = new ExpressionNode( build_pfieldSel( $1, build_varref( $3 ) ) ); }
666 | postfix_expression ARROW INTEGERconstant // CFA, tuple index
667 { $$ = new ExpressionNode( build_pfieldSel( $1, build_constantInteger( *$3 ) ) ); }
668 | postfix_expression ARROW '[' field_name_list ']' // CFA, tuple field selector
669 { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $4 ) ) ); }
670 | postfix_expression ICR
671 { $$ = new ExpressionNode( build_unary_ptr( OperKinds::IncrPost, $1 ) ); }
672 | postfix_expression DECR
673 { $$ = new ExpressionNode( build_unary_ptr( OperKinds::DecrPost, $1 ) ); }
674 | '(' type_no_function ')' '{' initializer_list_opt comma_opt '}' // C99, compound-literal
675 { $$ = new ExpressionNode( build_compoundLiteral( $2, new InitializerNode( $5, true ) ) ); }
676 | '(' type_no_function ')' '@' '{' initializer_list_opt comma_opt '}' // CFA, explicit C compound-literal
677 { $$ = new ExpressionNode( build_compoundLiteral( $2, (new InitializerNode( $6, true ))->set_maybeConstructed( false ) ) ); }
678 | '^' primary_expression '{' argument_expression_list_opt '}' // CFA, destructor call
679 {
680 Token fn;
681 fn.str = new string( "^?{}" ); // location undefined
682 $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $2 )->set_last( $4 ) ) );
683 }
684 ;
685
686argument_expression_list_opt:
687 // empty
688 { $$ = nullptr; }
689 | argument_expression
690 | argument_expression_list_opt ',' argument_expression
691 { $$ = (ExpressionNode *)($1->set_last( $3 )); }
692 ;
693
694argument_expression:
695 '@' // CFA, default parameter
696 { SemanticError( yylloc, "Default parameter for argument is currently unimplemented." ); $$ = nullptr; }
697 // { $$ = new ExpressionNode( build_constantInteger( *new string( "2" ) ) ); }
698 | assignment_expression
699 ;
700
701field_name_list: // CFA, tuple field selector
702 field
703 | field_name_list ',' field { $$ = (ExpressionNode *)($1->set_last( $3 )); }
704 ;
705
706field: // CFA, tuple field selector
707 field_name
708 | FLOATING_DECIMALconstant field
709 { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( *$1 ) ), maybeMoveBuild<Expression>( $2 ) ) ); }
710 | FLOATING_DECIMALconstant '[' field_name_list ']'
711 { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( *$1 ) ), build_tuple( $3 ) ) ); }
712 | field_name '.' field
713 { $$ = new ExpressionNode( build_fieldSel( $1, maybeMoveBuild<Expression>( $3 ) ) ); }
714 | field_name '.' '[' field_name_list ']'
715 { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $4 ) ) ); }
716 | field_name ARROW field
717 { $$ = new ExpressionNode( build_pfieldSel( $1, maybeMoveBuild<Expression>( $3 ) ) ); }
718 | field_name ARROW '[' field_name_list ']'
719 { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $4 ) ) ); }
720 ;
721
722field_name:
723 INTEGERconstant fraction_constants_opt
724 { $$ = new ExpressionNode( build_field_name_fraction_constants( build_constantInteger( *$1 ), $2 ) ); }
725 | FLOATINGconstant fraction_constants_opt
726 { $$ = new ExpressionNode( build_field_name_fraction_constants( build_field_name_FLOATINGconstant( *$1 ), $2 ) ); }
727 | identifier fraction_constants_opt
728 {
729 $$ = new ExpressionNode( build_field_name_fraction_constants( build_varref( $1 ), $2 ) );
730 }
731 ;
732
733fraction_constants_opt:
734 // empty
735 { $$ = nullptr; }
736 | fraction_constants_opt FLOATING_FRACTIONconstant
737 {
738 Expression * constant = build_field_name_FLOATING_FRACTIONconstant( *$2 );
739 $$ = $1 != nullptr ? new ExpressionNode( build_fieldSel( $1, constant ) ) : new ExpressionNode( constant );
740 }
741 ;
742
743unary_expression:
744 postfix_expression
745 // first location where constant/string can have operator applied: sizeof 3/sizeof "abc" still requires
746 // semantics checks, e.g., ++3, 3--, *3, &&3
747 | constant
748 | string_literal
749 { $$ = new ExpressionNode( $1 ); }
750 | EXTENSION cast_expression // GCC
751 { $$ = $2->set_extension( true ); }
752 // '*' ('&') is separated from unary_operator because of shift/reduce conflict in:
753 // { * X; } // dereference X
754 // { * int X; } // CFA declaration of pointer to int
755 | ptrref_operator cast_expression // CFA
756 {
757 switch ( $1 ) {
758 case OperKinds::AddressOf:
759 $$ = new ExpressionNode( new AddressExpr( maybeMoveBuild<Expression>( $2 ) ) );
760 break;
761 case OperKinds::PointTo:
762 $$ = new ExpressionNode( build_unary_val( $1, $2 ) );
763 break;
764 case OperKinds::And:
765 $$ = new ExpressionNode( new AddressExpr( new AddressExpr( maybeMoveBuild<Expression>( $2 ) ) ) );
766 break;
767 default:
768 assert( false );
769 }
770 }
771 | unary_operator cast_expression
772 { $$ = new ExpressionNode( build_unary_val( $1, $2 ) ); }
773 | ICR unary_expression
774 { $$ = new ExpressionNode( build_unary_ptr( OperKinds::Incr, $2 ) ); }
775 | DECR unary_expression
776 { $$ = new ExpressionNode( build_unary_ptr( OperKinds::Decr, $2 ) ); }
777 | SIZEOF unary_expression
778 { $$ = new ExpressionNode( new SizeofExpr( maybeMoveBuild<Expression>( $2 ) ) ); }
779 | SIZEOF '(' type_no_function ')'
780 { $$ = new ExpressionNode( new SizeofExpr( maybeMoveBuildType( $3 ) ) ); }
781 | ALIGNOF unary_expression // GCC, variable alignment
782 { $$ = new ExpressionNode( new AlignofExpr( maybeMoveBuild<Expression>( $2 ) ) ); }
783 | ALIGNOF '(' type_no_function ')' // GCC, type alignment
784 { $$ = new ExpressionNode( new AlignofExpr( maybeMoveBuildType( $3 ) ) ); }
785 | OFFSETOF '(' type_no_function ',' identifier ')'
786 { $$ = new ExpressionNode( build_offsetOf( $3, build_varref( $5 ) ) ); }
787 ;
788
789ptrref_operator:
790 '*' { $$ = OperKinds::PointTo; }
791 | '&' { $$ = OperKinds::AddressOf; }
792 // GCC, address of label must be handled by semantic check for ref,ref,label
793 | ANDAND { $$ = OperKinds::And; }
794 ;
795
796unary_operator:
797 '+' { $$ = OperKinds::UnPlus; }
798 | '-' { $$ = OperKinds::UnMinus; }
799 | '!' { $$ = OperKinds::Neg; }
800 | '~' { $$ = OperKinds::BitNeg; }
801 ;
802
803cast_expression:
804 unary_expression
805 | '(' type_no_function ')' cast_expression
806 { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
807 | '(' aggregate_control '&' ')' cast_expression // CFA
808 { $$ = new ExpressionNode( build_keyword_cast( $2, $5 ) ); }
809 | '(' VIRTUAL ')' cast_expression // CFA
810 { $$ = new ExpressionNode( new VirtualCastExpr( maybeMoveBuild<Expression>( $4 ), maybeMoveBuildType( nullptr ) ) ); }
811 | '(' VIRTUAL type_no_function ')' cast_expression // CFA
812 { $$ = new ExpressionNode( new VirtualCastExpr( maybeMoveBuild<Expression>( $5 ), maybeMoveBuildType( $3 ) ) ); }
813 | '(' RETURN type_no_function ')' cast_expression // CFA
814 { SemanticError( yylloc, "Return cast is currently unimplemented." ); $$ = nullptr; }
815 | '(' COERCE type_no_function ')' cast_expression // CFA
816 { SemanticError( yylloc, "Coerce cast is currently unimplemented." ); $$ = nullptr; }
817 | '(' qualifier_cast_list ')' cast_expression // CFA
818 { SemanticError( yylloc, "Qualifier cast is currently unimplemented." ); $$ = nullptr; }
819// | '(' type_no_function ')' tuple
820// { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
821 ;
822
823qualifier_cast_list:
824 cast_modifier type_qualifier_name
825 | cast_modifier MUTEX
826 | qualifier_cast_list cast_modifier type_qualifier_name
827 | qualifier_cast_list cast_modifier MUTEX
828 ;
829
830cast_modifier:
831 '-'
832 | '+'
833 ;
834
835exponential_expression:
836 cast_expression
837 | exponential_expression '\\' cast_expression
838 { $$ = new ExpressionNode( build_binary_val( OperKinds::Exp, $1, $3 ) ); }
839 ;
840
841multiplicative_expression:
842 exponential_expression
843 | multiplicative_expression '*' exponential_expression
844 { $$ = new ExpressionNode( build_binary_val( OperKinds::Mul, $1, $3 ) ); }
845 | multiplicative_expression '/' exponential_expression
846 { $$ = new ExpressionNode( build_binary_val( OperKinds::Div, $1, $3 ) ); }
847 | multiplicative_expression '%' exponential_expression
848 { $$ = new ExpressionNode( build_binary_val( OperKinds::Mod, $1, $3 ) ); }
849 ;
850
851additive_expression:
852 multiplicative_expression
853 | additive_expression '+' multiplicative_expression
854 { $$ = new ExpressionNode( build_binary_val( OperKinds::Plus, $1, $3 ) ); }
855 | additive_expression '-' multiplicative_expression
856 { $$ = new ExpressionNode( build_binary_val( OperKinds::Minus, $1, $3 ) ); }
857 ;
858
859shift_expression:
860 additive_expression
861 | shift_expression LS additive_expression
862 { $$ = new ExpressionNode( build_binary_val( OperKinds::LShift, $1, $3 ) ); }
863 | shift_expression RS additive_expression
864 { $$ = new ExpressionNode( build_binary_val( OperKinds::RShift, $1, $3 ) ); }
865 ;
866
867relational_expression:
868 shift_expression
869 | relational_expression '<' shift_expression
870 { $$ = new ExpressionNode( build_binary_val( OperKinds::LThan, $1, $3 ) ); }
871 | relational_expression '>' shift_expression
872 { $$ = new ExpressionNode( build_binary_val( OperKinds::GThan, $1, $3 ) ); }
873 | relational_expression LE shift_expression
874 { $$ = new ExpressionNode( build_binary_val( OperKinds::LEThan, $1, $3 ) ); }
875 | relational_expression GE shift_expression
876 { $$ = new ExpressionNode( build_binary_val( OperKinds::GEThan, $1, $3 ) ); }
877 ;
878
879equality_expression:
880 relational_expression
881 | equality_expression EQ relational_expression
882 { $$ = new ExpressionNode( build_binary_val( OperKinds::Eq, $1, $3 ) ); }
883 | equality_expression NE relational_expression
884 { $$ = new ExpressionNode( build_binary_val( OperKinds::Neq, $1, $3 ) ); }
885 ;
886
887AND_expression:
888 equality_expression
889 | AND_expression '&' equality_expression
890 { $$ = new ExpressionNode( build_binary_val( OperKinds::BitAnd, $1, $3 ) ); }
891 ;
892
893exclusive_OR_expression:
894 AND_expression
895 | exclusive_OR_expression '^' AND_expression
896 { $$ = new ExpressionNode( build_binary_val( OperKinds::Xor, $1, $3 ) ); }
897 ;
898
899inclusive_OR_expression:
900 exclusive_OR_expression
901 | inclusive_OR_expression '|' exclusive_OR_expression
902 { $$ = new ExpressionNode( build_binary_val( OperKinds::BitOr, $1, $3 ) ); }
903 ;
904
905logical_AND_expression:
906 inclusive_OR_expression
907 | logical_AND_expression ANDAND inclusive_OR_expression
908 { $$ = new ExpressionNode( build_and_or( $1, $3, true ) ); }
909 ;
910
911logical_OR_expression:
912 logical_AND_expression
913 | logical_OR_expression OROR logical_AND_expression
914 { $$ = new ExpressionNode( build_and_or( $1, $3, false ) ); }
915 ;
916
917conditional_expression:
918 logical_OR_expression
919 | logical_OR_expression '?' comma_expression ':' conditional_expression
920 { $$ = new ExpressionNode( build_cond( $1, $3, $5 ) ); }
921 // FIX ME: computes $1 twice
922 | logical_OR_expression '?' /* empty */ ':' conditional_expression // GCC, omitted first operand
923 { $$ = new ExpressionNode( build_cond( $1, $1, $4 ) ); }
924 ;
925
926constant_expression:
927 conditional_expression
928 ;
929
930assignment_expression:
931 // CFA, assignment is separated from assignment_operator to ensure no assignment operations for tuples
932 conditional_expression
933 | unary_expression assignment_operator assignment_expression
934 {
935// if ( $2 == OperKinds::AtAssn ) {
936// SemanticError( yylloc, "C @= assignment is currently unimplemented." ); $$ = nullptr;
937// } else {
938 $$ = new ExpressionNode( build_binary_val( $2, $1, $3 ) );
939// } // if
940 }
941 | unary_expression '=' '{' initializer_list_opt comma_opt '}'
942 { SemanticError( yylloc, "Initializer assignment is currently unimplemented." ); $$ = nullptr; }
943 ;
944
945assignment_expression_opt:
946 // empty
947 { $$ = nullptr; }
948 | assignment_expression
949 ;
950
951assignment_operator:
952 simple_assignment_operator
953 | compound_assignment_operator
954 ;
955
956simple_assignment_operator:
957 '=' { $$ = OperKinds::Assign; }
958 | ATassign { $$ = OperKinds::AtAssn; } // CFA
959 ;
960
961compound_assignment_operator:
962 EXPassign { $$ = OperKinds::ExpAssn; }
963 | MULTassign { $$ = OperKinds::MulAssn; }
964 | DIVassign { $$ = OperKinds::DivAssn; }
965 | MODassign { $$ = OperKinds::ModAssn; }
966 | PLUSassign { $$ = OperKinds::PlusAssn; }
967 | MINUSassign { $$ = OperKinds::MinusAssn; }
968 | LSassign { $$ = OperKinds::LSAssn; }
969 | RSassign { $$ = OperKinds::RSAssn; }
970 | ANDassign { $$ = OperKinds::AndAssn; }
971 | ERassign { $$ = OperKinds::ERAssn; }
972 | ORassign { $$ = OperKinds::OrAssn; }
973 ;
974
975tuple: // CFA, tuple
976 // CFA, one assignment_expression is factored out of comma_expression to eliminate a shift/reduce conflict with
977 // comma_expression in cfa_identifier_parameter_array and cfa_abstract_array
978// '[' ']'
979// { $$ = new ExpressionNode( build_tuple() ); }
980// | '[' push assignment_expression pop ']'
981// { $$ = new ExpressionNode( build_tuple( $3 ) ); }
982 '[' ',' tuple_expression_list ']'
983 { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( $3 ) ) ); }
984 | '[' push assignment_expression pop ',' tuple_expression_list ']'
985 { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)($3->set_last( $6 ) ) )); }
986 ;
987
988tuple_expression_list:
989 assignment_expression
990 | '@' // CFA
991 { SemanticError( yylloc, "Eliding tuple element with '@' is currently unimplemented." ); $$ = nullptr; }
992 | tuple_expression_list ',' assignment_expression
993 { $$ = (ExpressionNode *)($1->set_last( $3 )); }
994 | tuple_expression_list ',' '@'
995 { SemanticError( yylloc, "Eliding tuple element with '@' is currently unimplemented." ); $$ = nullptr; }
996 ;
997
998comma_expression:
999 assignment_expression
1000 | comma_expression ',' assignment_expression
1001 { $$ = new ExpressionNode( new CommaExpr( maybeMoveBuild<Expression>( $1 ), maybeMoveBuild<Expression>( $3 ) ) ); }
1002 ;
1003
1004comma_expression_opt:
1005 // empty
1006 { $$ = nullptr; }
1007 | comma_expression
1008 ;
1009
1010//*************************** STATEMENTS *******************************
1011
1012statement:
1013 labeled_statement
1014 | compound_statement
1015 | expression_statement
1016 | selection_statement
1017 | iteration_statement
1018 | jump_statement
1019 | with_statement
1020 | mutex_statement
1021 | waitfor_statement
1022 | exception_statement
1023 | enable_disable_statement
1024 { SemanticError( yylloc, "enable/disable statement is currently unimplemented." ); $$ = nullptr; }
1025 | asm_statement
1026 | DIRECTIVE
1027 { $$ = new StatementNode( build_directive( $1 ) ); }
1028 ;
1029
1030labeled_statement:
1031 // labels cannot be identifiers 0 or 1
1032 identifier_or_type_name ':' attribute_list_opt statement
1033 { $$ = $4->add_label( $1, $3 ); }
1034 ;
1035
1036compound_statement:
1037 '{' '}'
1038 { $$ = new StatementNode( build_compound( (StatementNode *)0 ) ); }
1039 | '{' push
1040 local_label_declaration_opt // GCC, local labels appear at start of block
1041 statement_decl_list // C99, intermix declarations and statements
1042 pop '}'
1043 { $$ = new StatementNode( build_compound( $4 ) ); }
1044 ;
1045
1046statement_decl_list: // C99
1047 statement_decl
1048 | statement_decl_list statement_decl
1049 { assert( $1 ); $1->set_last( $2 ); $$ = $1; }
1050 ;
1051
1052statement_decl:
1053 declaration // CFA, new & old style declarations
1054 { $$ = new StatementNode( $1 ); }
1055 | EXTENSION declaration // GCC
1056 { distExt( $2 ); $$ = new StatementNode( $2 ); }
1057 | function_definition
1058 { $$ = new StatementNode( $1 ); }
1059 | EXTENSION function_definition // GCC
1060 { distExt( $2 ); $$ = new StatementNode( $2 ); }
1061 | statement
1062 ;
1063
1064statement_list_nodecl:
1065 statement
1066 | statement_list_nodecl statement
1067 { assert( $1 ); $1->set_last( $2 ); $$ = $1; }
1068 ;
1069
1070expression_statement:
1071 comma_expression_opt ';'
1072 { $$ = new StatementNode( build_expr( $1 ) ); }
1073 ;
1074
1075selection_statement:
1076 // pop causes a S/R conflict without separating the IF statement into a non-terminal even after resolving
1077 // the inherent S/R conflict with THEN/ELSE.
1078 push if_statement pop
1079 { $$ = $2; }
1080 | SWITCH '(' comma_expression ')' case_clause
1081 { $$ = new StatementNode( build_switch( true, $3, $5 ) ); }
1082 | SWITCH '(' comma_expression ')' '{' push declaration_list_opt switch_clause_list_opt pop '}' // CFA
1083 {
1084 StatementNode *sw = new StatementNode( build_switch( true, $3, $8 ) );
1085 // The semantics of the declaration list is changed to include associated initialization, which is performed
1086 // *before* the transfer to the appropriate case clause by hoisting the declarations into a compound
1087 // statement around the switch. Statements after the initial declaration list can never be executed, and
1088 // therefore, are removed from the grammar even though C allows it. The change also applies to choose
1089 // statement.
1090 $$ = $7 ? new StatementNode( build_compound( (StatementNode *)((new StatementNode( $7 ))->set_last( sw )) ) ) : sw;
1091 }
1092 | CHOOSE '(' comma_expression ')' case_clause // CFA
1093 { $$ = new StatementNode( build_switch( false, $3, $5 ) ); }
1094 | CHOOSE '(' comma_expression ')' '{' push declaration_list_opt switch_clause_list_opt pop '}' // CFA
1095 {
1096 StatementNode *sw = new StatementNode( build_switch( false, $3, $8 ) );
1097 $$ = $7 ? new StatementNode( build_compound( (StatementNode *)((new StatementNode( $7 ))->set_last( sw )) ) ) : sw;
1098 }
1099 ;
1100
1101if_statement:
1102 IF '(' if_control_expression ')' statement %prec THEN
1103 // explicitly deal with the shift/reduce conflict on if/else
1104 { $$ = new StatementNode( build_if( $3, maybe_build_compound( $5 ), nullptr ) ); }
1105 | IF '(' if_control_expression ')' statement ELSE statement
1106 { $$ = new StatementNode( build_if( $3, maybe_build_compound( $5 ), maybe_build_compound( $7 ) ) ); }
1107 ;
1108
1109if_control_expression:
1110 comma_expression
1111 { $$ = new IfCtrl( nullptr, $1 ); }
1112 | c_declaration // no semi-colon
1113 { $$ = new IfCtrl( $1, nullptr ); }
1114 | cfa_declaration // no semi-colon
1115 { $$ = new IfCtrl( $1, nullptr ); }
1116 | declaration comma_expression // semi-colon separated
1117 { $$ = new IfCtrl( $1, $2 ); }
1118 ;
1119
1120// CASE and DEFAULT clauses are only allowed in the SWITCH statement, precluding Duff's device. In addition, a case
1121// clause allows a list of values and subranges.
1122
1123case_value: // CFA
1124 constant_expression { $$ = $1; }
1125 | constant_expression ELLIPSIS constant_expression // GCC, subrange
1126 { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild<Expression>( $1 ), maybeMoveBuild<Expression>( $3 ) ) ); }
1127 | subrange // CFA, subrange
1128 ;
1129
1130case_value_list: // CFA
1131 case_value { $$ = new StatementNode( build_case( $1 ) ); }
1132 // convert case list, e.g., "case 1, 3, 5:" into "case 1: case 3: case 5"
1133 | case_value_list ',' case_value { $$ = (StatementNode *)($1->set_last( new StatementNode( build_case( $3 ) ) ) ); }
1134 ;
1135
1136case_label: // CFA
1137 CASE case_value_list ':' { $$ = $2; }
1138 | DEFAULT ':' { $$ = new StatementNode( build_default() ); }
1139 // A semantic check is required to ensure only one default clause per switch/choose statement.
1140 ;
1141
1142//label_list_opt:
1143// // empty
1144// | identifier_or_type_name ':'
1145// | label_list_opt identifier_or_type_name ':'
1146// ;
1147
1148case_label_list: // CFA
1149 case_label
1150 | case_label_list case_label { $$ = (StatementNode *)( $1->set_last( $2 )); }
1151 ;
1152
1153case_clause: // CFA
1154 case_label_list statement { $$ = $1->append_last_case( maybe_build_compound( $2 ) ); }
1155 ;
1156
1157switch_clause_list_opt: // CFA
1158 // empty
1159 { $$ = nullptr; }
1160 | switch_clause_list
1161 ;
1162
1163switch_clause_list: // CFA
1164 case_label_list statement_list_nodecl
1165 { $$ = $1->append_last_case( new StatementNode( build_compound( $2 ) ) ); }
1166 | switch_clause_list case_label_list statement_list_nodecl
1167 { $$ = (StatementNode *)( $1->set_last( $2->append_last_case( new StatementNode( build_compound( $3 ) ) ) ) ); }
1168 ;
1169
1170iteration_statement:
1171 WHILE '(' push if_control_expression ')' statement pop
1172 { $$ = new StatementNode( build_while( $4, maybe_build_compound( $6 ) ) ); }
1173 | WHILE '(' ')' statement // CFA => while ( 1 )
1174 { $$ = new StatementNode( build_while( new IfCtrl( nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ), maybe_build_compound( $4 ) ) ); }
1175 | DO statement WHILE '(' comma_expression ')' ';'
1176 { $$ = new StatementNode( build_do_while( $5, maybe_build_compound( $2 ) ) ); }
1177 | DO statement WHILE '(' ')' ';' // CFA => do while( 1 )
1178 { $$ = new StatementNode( build_do_while( new ExpressionNode( build_constantInteger( *new string( "1" ) ) ), maybe_build_compound( $2 ) ) ); }
1179 | FOR '(' push for_control_expression_list ')' statement pop
1180 { $$ = new StatementNode( build_for( $4, maybe_build_compound( $6 ) ) ); }
1181 | FOR '(' ')' statement // CFA => for ( ;; )
1182 { $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), maybe_build_compound( $4 ) ) ); }
1183 ;
1184
1185for_control_expression_list:
1186 for_control_expression
1187 | for_control_expression_list ':' for_control_expression
1188 // ForCtrl + ForCtrl:
1189 // init + init => multiple declaration statements that are hoisted
1190 // condition + condition => (expression) && (expression)
1191 // change + change => (expression), (expression)
1192 {
1193 $1->init->set_last( $3->init );
1194 if ( $1->condition ) {
1195 if ( $3->condition ) {
1196 $1->condition->expr.reset( new LogicalExpr( $1->condition->expr.release(), $3->condition->expr.release(), true ) );
1197 } // if
1198 } else $1->condition = $3->condition;
1199 if ( $1->change ) {
1200 if ( $3->change ) {
1201 $1->change->expr.reset( new CommaExpr( $1->change->expr.release(), $3->change->expr.release() ) );
1202 } // if
1203 } else $1->change = $3->change;
1204 $$ = $1;
1205 }
1206 ;
1207
1208for_control_expression:
1209 ';' comma_expression_opt ';' comma_expression_opt
1210 { $$ = new ForCtrl( (ExpressionNode * )nullptr, $2, $4 ); }
1211 | comma_expression ';' comma_expression_opt ';' comma_expression_opt
1212 { $$ = new ForCtrl( $1, $3, $5 ); }
1213 | declaration comma_expression_opt ';' comma_expression_opt // C99, declaration has ';'
1214 { $$ = new ForCtrl( $1, $2, $4 ); }
1215
1216 | comma_expression // CFA
1217 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
1218 OperKinds::LThan, $1->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
1219 | '=' comma_expression // CFA
1220 { $$ = forCtrl( $2, new string( DeclarationNode::anonymous.newName() ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
1221 OperKinds::LEThan, $2->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
1222 | comma_expression inclexcl comma_expression // CFA
1223 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
1224 | comma_expression inclexcl comma_expression '~' comma_expression // CFA
1225 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, $5 ); }
1226 | comma_expression ';' // CFA
1227 { $$ = forCtrl( new ExpressionNode( build_constantInteger( *new string( "0u" ) ) ), $1, nullptr, OperKinds::LThan, nullptr, nullptr ); }
1228 | comma_expression ';' comma_expression // CFA
1229 { $$ = forCtrl( $3, $1, new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
1230 OperKinds::LThan, $3->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
1231 | comma_expression ';' '=' comma_expression // CFA
1232 { $$ = forCtrl( $4, $1, new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
1233 OperKinds::LEThan, $4->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
1234 | comma_expression ';' comma_expression inclexcl comma_expression // CFA
1235 { $$ = forCtrl( $3, $1, $3->clone(), $4, $5, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
1236 | comma_expression ';' comma_expression inclexcl comma_expression '~' comma_expression // CFA
1237 { $$ = forCtrl( $3, $1, $3->clone(), $4, $5, $7 ); }
1238
1239 | comma_expression ';' TYPEDEFname // CFA, array type
1240 {
1241 SemanticError( yylloc, "Array interator is currently unimplemented." ); $$ = nullptr;
1242 $$ = forCtrl( new ExpressionNode( build_varref( $3 ) ), $1, nullptr, OperKinds::Range, nullptr, nullptr );
1243 }
1244
1245 // There is a S/R conflicit if ~ and -~ are factored out.
1246 | comma_expression ';' comma_expression '~' '@' // CFA
1247 { $$ = forCtrl( $3, $1, $3->clone(), OperKinds::LThan, nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
1248 | comma_expression ';' comma_expression ErangeDown '@' // CFA
1249 { $$ = forCtrl( $3, $1, $3->clone(), OperKinds::GThan, nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
1250 | comma_expression ';' comma_expression '~' '@' '~' comma_expression // CFA
1251 { $$ = forCtrl( $3, $1, $3->clone(), OperKinds::LThan, nullptr, $7 ); }
1252 | comma_expression ';' comma_expression ErangeDown '@' '~' comma_expression // CFA
1253 { $$ = forCtrl( $3, $1, $3->clone(), OperKinds::GThan, nullptr, $7 ); }
1254 | comma_expression ';' comma_expression '~' '@' '~' '@' // CFA
1255 { $$ = forCtrl( $3, $1, $3->clone(), OperKinds::LThan, nullptr, nullptr ); }
1256 ;
1257
1258inclexcl:
1259 '~'
1260 { $$ = OperKinds::LThan; }
1261 | ErangeUpEq
1262 { $$ = OperKinds::LEThan; }
1263 | ErangeDown
1264 { $$ = OperKinds::GThan; }
1265 | ErangeDownEq
1266 { $$ = OperKinds::GEThan; }
1267 ;
1268
1269jump_statement:
1270 GOTO identifier_or_type_name ';'
1271 { $$ = new StatementNode( build_branch( $2, BranchStmt::Goto ) ); }
1272 | GOTO '*' comma_expression ';' // GCC, computed goto
1273 // The syntax for the GCC computed goto violates normal expression precedence, e.g., goto *i+3; => goto *(i+3);
1274 // whereas normal operator precedence yields goto (*i)+3;
1275 { $$ = new StatementNode( build_computedgoto( $3 ) ); }
1276 // A semantic check is required to ensure fallthru appears only in the body of a choose statement.
1277 | fall_through_name ';' // CFA
1278 { $$ = new StatementNode( build_branch( BranchStmt::FallThrough ) ); }
1279 | fall_through_name identifier_or_type_name ';' // CFA
1280 { $$ = new StatementNode( build_branch( $2, BranchStmt::FallThrough ) ); }
1281 | fall_through_name DEFAULT ';' // CFA
1282 { $$ = new StatementNode( build_branch( BranchStmt::FallThroughDefault ) ); }
1283 | CONTINUE ';'
1284 // A semantic check is required to ensure this statement appears only in the body of an iteration statement.
1285 { $$ = new StatementNode( build_branch( BranchStmt::Continue ) ); }
1286 | CONTINUE identifier_or_type_name ';' // CFA, multi-level continue
1287 // A semantic check is required to ensure this statement appears only in the body of an iteration statement, and
1288 // the target of the transfer appears only at the start of an iteration statement.
1289 { $$ = new StatementNode( build_branch( $2, BranchStmt::Continue ) ); }
1290 | BREAK ';'
1291 // A semantic check is required to ensure this statement appears only in the body of an iteration statement.
1292 { $$ = new StatementNode( build_branch( BranchStmt::Break ) ); }
1293 | BREAK identifier_or_type_name ';' // CFA, multi-level exit
1294 // A semantic check is required to ensure this statement appears only in the body of an iteration statement, and
1295 // the target of the transfer appears only at the start of an iteration statement.
1296 { $$ = new StatementNode( build_branch( $2, BranchStmt::Break ) ); }
1297 | RETURN comma_expression_opt ';'
1298 { $$ = new StatementNode( build_return( $2 ) ); }
1299 | RETURN '{' initializer_list_opt comma_opt '}' ';'
1300 { SemanticError( yylloc, "Initializer return is currently unimplemented." ); $$ = nullptr; }
1301 | SUSPEND ';'
1302 { $$ = new StatementNode( build_suspend( nullptr ) ); }
1303 | SUSPEND compound_statement
1304 { $$ = new StatementNode( build_suspend( $2 ) ); }
1305 | SUSPEND COROUTINE ';'
1306 { $$ = new StatementNode( build_suspend( nullptr, SuspendStmt::Coroutine ) ); }
1307 | SUSPEND COROUTINE compound_statement
1308 { $$ = new StatementNode( build_suspend( $3, SuspendStmt::Coroutine ) ); }
1309 | SUSPEND GENERATOR ';'
1310 { $$ = new StatementNode( build_suspend( nullptr, SuspendStmt::Generator ) ); }
1311 | SUSPEND GENERATOR compound_statement
1312 { $$ = new StatementNode( build_suspend( $3, SuspendStmt::Generator ) ); }
1313 | THROW assignment_expression_opt ';' // handles rethrow
1314 { $$ = new StatementNode( build_throw( $2 ) ); }
1315 | THROWRESUME assignment_expression_opt ';' // handles reresume
1316 { $$ = new StatementNode( build_resume( $2 ) ); }
1317 | THROWRESUME assignment_expression_opt AT assignment_expression ';' // handles reresume
1318 { $$ = new StatementNode( build_resume_at( $2, $4 ) ); }
1319 ;
1320
1321fall_through_name: // CFA
1322 FALLTHRU
1323 | FALLTHROUGH
1324 ;
1325
1326with_statement:
1327 WITH '(' tuple_expression_list ')' statement
1328 {
1329 $$ = new StatementNode( build_with( $3, $5 ) );
1330 }
1331 ;
1332
1333// If MUTEX becomes a general qualifier, there are shift/reduce conflicts, so change syntax to "with mutex".
1334mutex_statement:
1335 MUTEX '(' argument_expression_list_opt ')' statement
1336 { SemanticError( yylloc, "Mutex statement is currently unimplemented." ); $$ = nullptr; }
1337 ;
1338
1339when_clause:
1340 WHEN '(' comma_expression ')' { $$ = $3; }
1341 ;
1342
1343when_clause_opt:
1344 // empty
1345 { $$ = nullptr; }
1346 | when_clause
1347 ;
1348
1349waitfor:
1350 WAITFOR '(' cast_expression ')'
1351 { $$ = $3; }
1352// | WAITFOR '(' cast_expression ',' argument_expression_list_opt ')'
1353// { $$ = (ExpressionNode *)$3->set_last( $5 ); }
1354 | WAITFOR '(' cast_expression_list ':' argument_expression_list_opt ')'
1355 { $$ = (ExpressionNode *)($3->set_last( $5 )); }
1356 ;
1357
1358cast_expression_list:
1359 cast_expression
1360 | cast_expression_list ',' cast_expression
1361 // { $$ = (ExpressionNode *)($1->set_last( $3 )); }
1362 { SemanticError( yylloc, "List of mutex member is currently unimplemented." ); $$ = nullptr; }
1363 ;
1364
1365timeout:
1366 TIMEOUT '(' comma_expression ')' { $$ = $3; }
1367 ;
1368
1369waitfor_clause:
1370 when_clause_opt waitfor statement %prec THEN
1371 { $$ = build_waitfor( $2, maybe_build_compound( $3 ), $1 ); }
1372 | when_clause_opt waitfor statement WOR waitfor_clause
1373 { $$ = build_waitfor( $2, maybe_build_compound( $3 ), $1, $5 ); }
1374 | when_clause_opt timeout statement %prec THEN
1375 { $$ = build_waitfor_timeout( $2, maybe_build_compound( $3 ), $1 ); }
1376 | when_clause_opt ELSE statement
1377 { $$ = build_waitfor_timeout( nullptr, maybe_build_compound( $3 ), $1 ); }
1378 // "else" must be conditional after timeout or timeout is never triggered (i.e., it is meaningless)
1379 | when_clause_opt timeout statement WOR ELSE statement
1380 { SemanticError( yylloc, "else clause must be conditional after timeout or timeout never triggered." ); $$ = nullptr; }
1381 | when_clause_opt timeout statement WOR when_clause ELSE statement
1382 { $$ = build_waitfor_timeout( $2, maybe_build_compound( $3 ), $1, maybe_build_compound( $7 ), $5 ); }
1383 ;
1384
1385waitfor_statement:
1386 when_clause_opt waitfor statement %prec THEN
1387 { $$ = new StatementNode( build_waitfor( $2, $3, $1 ) ); }
1388 | when_clause_opt waitfor statement WOR waitfor_clause
1389 { $$ = new StatementNode( build_waitfor( $2, $3, $1, $5 ) ); }
1390 ;
1391
1392exception_statement:
1393 TRY compound_statement handler_clause %prec THEN
1394 { $$ = new StatementNode( build_try( $2, $3, 0 ) ); }
1395 | TRY compound_statement finally_clause
1396 { $$ = new StatementNode( build_try( $2, 0, $3 ) ); }
1397 | TRY compound_statement handler_clause finally_clause
1398 { $$ = new StatementNode( build_try( $2, $3, $4 ) ); }
1399 ;
1400
1401handler_clause:
1402 handler_key '(' push exception_declaration pop handler_predicate_opt ')' compound_statement
1403 { $$ = new StatementNode( build_catch( $1, $4, $6, $8 ) ); }
1404 | handler_clause handler_key '(' push exception_declaration pop handler_predicate_opt ')' compound_statement
1405 { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( $2, $5, $7, $9 ) ) ); }
1406 ;
1407
1408handler_predicate_opt:
1409 // empty
1410 { $$ = nullptr; }
1411 | ';' conditional_expression { $$ = $2; }
1412 ;
1413
1414handler_key:
1415 CATCH { $$ = CatchStmt::Terminate; }
1416 | RECOVER { $$ = CatchStmt::Terminate; }
1417 | CATCHRESUME { $$ = CatchStmt::Resume; }
1418 | FIXUP { $$ = CatchStmt::Resume; }
1419 ;
1420
1421finally_clause:
1422 FINALLY compound_statement { $$ = new StatementNode( build_finally( $2 ) ); }
1423 ;
1424
1425exception_declaration:
1426 // No SUE declaration in parameter list.
1427 type_specifier_nobody
1428 | type_specifier_nobody declarator
1429 { $$ = $2->addType( $1 ); }
1430 | type_specifier_nobody variable_abstract_declarator
1431 { $$ = $2->addType( $1 ); }
1432 | cfa_abstract_declarator_tuple identifier // CFA
1433 { $$ = $1->addName( $2 ); }
1434 | cfa_abstract_declarator_tuple // CFA
1435 ;
1436
1437enable_disable_statement:
1438 enable_disable_key identifier_list compound_statement
1439 ;
1440
1441enable_disable_key:
1442 ENABLE
1443 | DISABLE
1444 ;
1445
1446asm_statement:
1447 ASM asm_volatile_opt '(' string_literal ')' ';'
1448 { $$ = new StatementNode( build_asm( $2, $4, 0 ) ); }
1449 | ASM asm_volatile_opt '(' string_literal ':' asm_operands_opt ')' ';' // remaining GCC
1450 { $$ = new StatementNode( build_asm( $2, $4, $6 ) ); }
1451 | ASM asm_volatile_opt '(' string_literal ':' asm_operands_opt ':' asm_operands_opt ')' ';'
1452 { $$ = new StatementNode( build_asm( $2, $4, $6, $8 ) ); }
1453 | ASM asm_volatile_opt '(' string_literal ':' asm_operands_opt ':' asm_operands_opt ':' asm_clobbers_list_opt ')' ';'
1454 { $$ = new StatementNode( build_asm( $2, $4, $6, $8, $10 ) ); }
1455 | ASM asm_volatile_opt GOTO '(' string_literal ':' ':' asm_operands_opt ':' asm_clobbers_list_opt ':' label_list ')' ';'
1456 { $$ = new StatementNode( build_asm( $2, $5, 0, $8, $10, $12 ) ); }
1457 ;
1458
1459asm_volatile_opt: // GCC
1460 // empty
1461 { $$ = false; }
1462 | VOLATILE
1463 { $$ = true; }
1464 ;
1465
1466asm_operands_opt: // GCC
1467 // empty
1468 { $$ = nullptr; } // use default argument
1469 | asm_operands_list
1470 ;
1471
1472asm_operands_list: // GCC
1473 asm_operand
1474 | asm_operands_list ',' asm_operand
1475 { $$ = (ExpressionNode *)($1->set_last( $3 )); }
1476 ;
1477
1478asm_operand: // GCC
1479 string_literal '(' constant_expression ')'
1480 { $$ = new ExpressionNode( new AsmExpr( nullptr, $1, maybeMoveBuild<Expression>( $3 ) ) ); }
1481 | '[' IDENTIFIER ']' string_literal '(' constant_expression ')'
1482 { $$ = new ExpressionNode( new AsmExpr( $2, $4, maybeMoveBuild<Expression>( $6 ) ) ); }
1483 ;
1484
1485asm_clobbers_list_opt: // GCC
1486 // empty
1487 { $$ = nullptr; } // use default argument
1488 | string_literal
1489 { $$ = new ExpressionNode( $1 ); }
1490 | asm_clobbers_list_opt ',' string_literal
1491 { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( $3 ) )); }
1492 ;
1493
1494label_list:
1495 identifier
1496 {
1497 $$ = new LabelNode(); $$->labels.push_back( *$1 );
1498 delete $1; // allocated by lexer
1499 }
1500 | label_list ',' identifier
1501 {
1502 $$ = $1; $1->labels.push_back( *$3 );
1503 delete $3; // allocated by lexer
1504 }
1505 ;
1506
1507//******************************* DECLARATIONS *********************************
1508
1509declaration_list_opt: // used at beginning of switch statement
1510 // empty
1511 { $$ = nullptr; }
1512 | declaration_list
1513 ;
1514
1515declaration_list:
1516 declaration
1517 | declaration_list declaration
1518 { $$ = $1->appendList( $2 ); }
1519 ;
1520
1521KR_parameter_list_opt: // used to declare parameter types in K&R style functions
1522 // empty
1523 { $$ = nullptr; }
1524 | KR_parameter_list
1525 ;
1526
1527KR_parameter_list:
1528 push c_declaration pop ';'
1529 { $$ = $2; }
1530 | KR_parameter_list push c_declaration pop ';'
1531 { $$ = $1->appendList( $3 ); }
1532 ;
1533
1534local_label_declaration_opt: // GCC, local label
1535 // empty
1536 | local_label_declaration_list
1537 ;
1538
1539local_label_declaration_list: // GCC, local label
1540 LABEL local_label_list ';'
1541 | local_label_declaration_list LABEL local_label_list ';'
1542 ;
1543
1544local_label_list: // GCC, local label
1545 identifier_or_type_name
1546 | local_label_list ',' identifier_or_type_name
1547 ;
1548
1549declaration: // old & new style declarations
1550 c_declaration ';'
1551 | cfa_declaration ';' // CFA
1552 | static_assert // C11
1553 ;
1554
1555static_assert:
1556 STATICASSERT '(' constant_expression ',' string_literal ')' ';' // C11
1557 { $$ = DeclarationNode::newStaticAssert( $3, $5 ); }
1558 | STATICASSERT '(' constant_expression ')' ';' // CFA
1559 { $$ = DeclarationNode::newStaticAssert( $3, build_constantStr( *new string( "\"\"" ) ) ); }
1560
1561// C declaration syntax is notoriously confusing and error prone. Cforall provides its own type, variable and function
1562// declarations. CFA declarations use the same declaration tokens as in C; however, CFA places declaration modifiers to
1563// the left of the base type, while C declarations place modifiers to the right of the base type. CFA declaration
1564// modifiers are interpreted from left to right and the entire type specification is distributed across all variables in
1565// the declaration list (as in Pascal). ANSI C and the new CFA declarations may appear together in the same program
1566// block, but cannot be mixed within a specific declaration.
1567//
1568// CFA C
1569// [10] int x; int x[10]; // array of 10 integers
1570// [10] * char y; char *y[10]; // array of 10 pointers to char
1571
1572cfa_declaration: // CFA
1573 cfa_variable_declaration
1574 | cfa_typedef_declaration
1575 | cfa_function_declaration
1576 | type_declaring_list
1577 { SemanticError( yylloc, "otype declaration is currently unimplemented." ); $$ = nullptr; }
1578 | trait_specifier
1579 ;
1580
1581cfa_variable_declaration: // CFA
1582 cfa_variable_specifier initializer_opt
1583 { $$ = $1->addInitializer( $2 ); }
1584 | declaration_qualifier_list cfa_variable_specifier initializer_opt
1585 // declaration_qualifier_list also includes type_qualifier_list, so a semantic check is necessary to preclude
1586 // them as a type_qualifier cannot appear in that context.
1587 { $$ = $2->addQualifiers( $1 )->addInitializer( $3 ); }
1588 | cfa_variable_declaration pop ',' push identifier_or_type_name initializer_opt
1589 { $$ = $1->appendList( $1->cloneType( $5 )->addInitializer( $6 ) ); }
1590 ;
1591
1592cfa_variable_specifier: // CFA
1593 // A semantic check is required to ensure asm_name only appears on declarations with implicit or explicit static
1594 // storage-class
1595 cfa_abstract_declarator_no_tuple identifier_or_type_name asm_name_opt
1596 { $$ = $1->addName( $2 )->addAsmName( $3 ); }
1597 | cfa_abstract_tuple identifier_or_type_name asm_name_opt
1598 { $$ = $1->addName( $2 )->addAsmName( $3 ); }
1599 | type_qualifier_list cfa_abstract_tuple identifier_or_type_name asm_name_opt
1600 { $$ = $2->addQualifiers( $1 )->addName( $3 )->addAsmName( $4 ); }
1601 ;
1602
1603cfa_function_declaration: // CFA
1604 cfa_function_specifier
1605 | type_qualifier_list cfa_function_specifier
1606 { $$ = $2->addQualifiers( $1 ); }
1607 | declaration_qualifier_list cfa_function_specifier
1608 { $$ = $2->addQualifiers( $1 ); }
1609 | declaration_qualifier_list type_qualifier_list cfa_function_specifier
1610 { $$ = $3->addQualifiers( $1 )->addQualifiers( $2 ); }
1611 | cfa_function_declaration ',' identifier_or_type_name '(' push cfa_parameter_ellipsis_list_opt pop ')'
1612 {
1613 // Append the return type at the start (left-hand-side) to each identifier in the list.
1614 DeclarationNode * ret = new DeclarationNode;
1615 ret->type = maybeClone( $1->type->base );
1616 $$ = $1->appendList( DeclarationNode::newFunction( $3, ret, $6, nullptr ) );
1617 }
1618 ;
1619
1620cfa_function_specifier: // CFA
1621// '[' ']' identifier_or_type_name '(' push cfa_parameter_ellipsis_list_opt pop ')' // S/R conflict
1622// {
1623// $$ = DeclarationNode::newFunction( $3, DeclarationNode::newTuple( 0 ), $6, 0, true );
1624// }
1625// '[' ']' identifier '(' push cfa_parameter_ellipsis_list_opt pop ')'
1626// {
1627// typedefTable.setNextIdentifier( *$5 );
1628// $$ = DeclarationNode::newFunction( $5, DeclarationNode::newTuple( 0 ), $8, 0, true );
1629// }
1630// | '[' ']' TYPEDEFname '(' push cfa_parameter_ellipsis_list_opt pop ')'
1631// {
1632// typedefTable.setNextIdentifier( *$5 );
1633// $$ = DeclarationNode::newFunction( $5, DeclarationNode::newTuple( 0 ), $8, 0, true );
1634// }
1635// | '[' ']' typegen_name
1636 // identifier_or_type_name must be broken apart because of the sequence:
1637 //
1638 // '[' ']' identifier_or_type_name '(' cfa_parameter_ellipsis_list_opt ')'
1639 // '[' ']' type_specifier
1640 //
1641 // type_specifier can resolve to just TYPEDEFname (e.g., typedef int T; int f( T );). Therefore this must be
1642 // flattened to allow lookahead to the '(' without having to reduce identifier_or_type_name.
1643 cfa_abstract_tuple identifier_or_type_name '(' push cfa_parameter_ellipsis_list_opt pop ')' attribute_list_opt
1644 // To obtain LR(1 ), this rule must be factored out from function return type (see cfa_abstract_declarator).
1645 { $$ = DeclarationNode::newFunction( $2, $1, $5, 0 )->addQualifiers( $8 ); }
1646 | cfa_function_return identifier_or_type_name '(' push cfa_parameter_ellipsis_list_opt pop ')' attribute_list_opt
1647 { $$ = DeclarationNode::newFunction( $2, $1, $5, 0 )->addQualifiers( $8 ); }
1648 ;
1649
1650cfa_function_return: // CFA
1651 '[' push cfa_parameter_list pop ']'
1652 { $$ = DeclarationNode::newTuple( $3 ); }
1653 | '[' push cfa_parameter_list pop ',' push cfa_abstract_parameter_list pop ']'
1654 // To obtain LR(1 ), the last cfa_abstract_parameter_list is added into this flattened rule to lookahead to the ']'.
1655 { $$ = DeclarationNode::newTuple( $3->appendList( $7 ) ); }
1656 ;
1657
1658cfa_typedef_declaration: // CFA
1659 TYPEDEF cfa_variable_specifier
1660 {
1661 typedefTable.addToEnclosingScope( *$2->name, TYPEDEFname, "1" );
1662 $$ = $2->addTypedef();
1663 }
1664 | TYPEDEF cfa_function_specifier
1665 {
1666 typedefTable.addToEnclosingScope( *$2->name, TYPEDEFname, "2" );
1667 $$ = $2->addTypedef();
1668 }
1669 | cfa_typedef_declaration pop ',' push identifier
1670 {
1671 typedefTable.addToEnclosingScope( *$5, TYPEDEFname, "3" );
1672 $$ = $1->appendList( $1->cloneType( $5 ) );
1673 }
1674 ;
1675
1676// Traditionally typedef is part of storage-class specifier for syntactic convenience only. Here, it is factored out as
1677// a separate form of declaration, which syntactically precludes storage-class specifiers and initialization.
1678
1679typedef_declaration:
1680 TYPEDEF type_specifier declarator
1681 {
1682 typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname, "4" );
1683 $$ = $3->addType( $2 )->addTypedef();
1684 }
1685 | typedef_declaration pop ',' push declarator
1686 {
1687 typedefTable.addToEnclosingScope( *$5->name, TYPEDEFname, "5" );
1688 $$ = $1->appendList( $1->cloneBaseType( $5 )->addTypedef() );
1689 }
1690 | type_qualifier_list TYPEDEF type_specifier declarator // remaining OBSOLESCENT (see 2 )
1691 {
1692 typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname, "6" );
1693 $$ = $4->addType( $3 )->addQualifiers( $1 )->addTypedef();
1694 }
1695 | type_specifier TYPEDEF declarator
1696 {
1697 typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname, "7" );
1698 $$ = $3->addType( $1 )->addTypedef();
1699 }
1700 | type_specifier TYPEDEF type_qualifier_list declarator
1701 {
1702 typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname, "8" );
1703 $$ = $4->addQualifiers( $1 )->addTypedef()->addType( $1 );
1704 }
1705 ;
1706
1707typedef_expression:
1708 // deprecated GCC, naming expression type: typedef name = exp; gives a name to the type of an expression
1709 TYPEDEF identifier '=' assignment_expression
1710 {
1711 SemanticError( yylloc, "Typedef expression is deprecated, use typeof(...) instead." ); $$ = nullptr;
1712 }
1713 | typedef_expression pop ',' push identifier '=' assignment_expression
1714 {
1715 SemanticError( yylloc, "Typedef expression is deprecated, use typeof(...) instead." ); $$ = nullptr;
1716 }
1717 ;
1718
1719c_declaration:
1720 declaration_specifier declaring_list
1721 { $$ = distAttr( $1, $2 ); }
1722 | typedef_declaration
1723 | typedef_expression // deprecated GCC, naming expression type
1724 | sue_declaration_specifier
1725 ;
1726
1727declaring_list:
1728 // A semantic check is required to ensure asm_name only appears on declarations with implicit or explicit static
1729 // storage-class
1730 declarator asm_name_opt initializer_opt
1731 { $$ = $1->addAsmName( $2 )->addInitializer( $3 ); }
1732 | declaring_list ',' attribute_list_opt declarator asm_name_opt initializer_opt
1733 { $$ = $1->appendList( $4->addQualifiers( $3 )->addAsmName( $5 )->addInitializer( $6 ) ); }
1734 ;
1735
1736declaration_specifier: // type specifier + storage class
1737 basic_declaration_specifier
1738 | sue_declaration_specifier
1739 | type_declaration_specifier
1740 ;
1741
1742declaration_specifier_nobody: // type specifier + storage class - {...}
1743 // Preclude SUE declarations in restricted scopes:
1744 //
1745 // int f( struct S { int i; } s1, Struct S s2 ) { struct S s3; ... }
1746 //
1747 // because it is impossible to call f due to name equivalence.
1748 basic_declaration_specifier
1749 | sue_declaration_specifier_nobody
1750 | type_declaration_specifier
1751 ;
1752
1753type_specifier: // type specifier
1754 basic_type_specifier
1755 | sue_type_specifier
1756 | type_type_specifier
1757 ;
1758
1759type_specifier_nobody: // type specifier - {...}
1760 // Preclude SUE declarations in restricted scopes:
1761 //
1762 // int f( struct S { int i; } s1, Struct S s2 ) { struct S s3; ... }
1763 //
1764 // because it is impossible to call f due to name equivalence.
1765 basic_type_specifier
1766 | sue_type_specifier_nobody
1767 | type_type_specifier
1768 ;
1769
1770type_qualifier_list_opt: // GCC, used in asm_statement
1771 // empty
1772 { $$ = nullptr; }
1773 | type_qualifier_list
1774 ;
1775
1776type_qualifier_list:
1777 // A semantic check is necessary to ensure a type qualifier is appropriate for the kind of declaration.
1778 //
1779 // ISO/IEC 9899:1999 Section 6.7.3(4 ) : If the same qualifier appears more than once in the same
1780 // specifier-qualifier-list, either directly or via one or more typedefs, the behavior is the same as if it
1781 // appeared only once.
1782 type_qualifier
1783 | type_qualifier_list type_qualifier
1784 { $$ = $1->addQualifiers( $2 ); }
1785 ;
1786
1787type_qualifier:
1788 type_qualifier_name
1789 | attribute // trick handles most atrribute locations
1790 ;
1791
1792type_qualifier_name:
1793 CONST
1794 { $$ = DeclarationNode::newTypeQualifier( Type::Const ); }
1795 | RESTRICT
1796 { $$ = DeclarationNode::newTypeQualifier( Type::Restrict ); }
1797 | VOLATILE
1798 { $$ = DeclarationNode::newTypeQualifier( Type::Volatile ); }
1799 | ATOMIC
1800 { $$ = DeclarationNode::newTypeQualifier( Type::Atomic ); }
1801 | forall
1802 ;
1803
1804forall:
1805 FORALL '(' type_parameter_list ')' // CFA
1806 { $$ = DeclarationNode::newForall( $3 ); }
1807 ;
1808
1809declaration_qualifier_list:
1810 storage_class_list
1811 | type_qualifier_list storage_class_list // remaining OBSOLESCENT (see 2 )
1812 { $$ = $1->addQualifiers( $2 ); }
1813 | declaration_qualifier_list type_qualifier_list storage_class_list
1814 { $$ = $1->addQualifiers( $2 )->addQualifiers( $3 ); }
1815 ;
1816
1817storage_class_list:
1818 // A semantic check is necessary to ensure a storage class is appropriate for the kind of declaration and that
1819 // only one of each is specified, except for inline, which can appear with the others.
1820 //
1821 // ISO/IEC 9899:1999 Section 6.7.1(2) : At most, one storage-class specifier may be given in the declaration
1822 // specifiers in a declaration.
1823 storage_class
1824 | storage_class_list storage_class
1825 { $$ = $1->addQualifiers( $2 ); }
1826 ;
1827
1828storage_class:
1829 EXTERN
1830 { $$ = DeclarationNode::newStorageClass( Type::Extern ); }
1831 | STATIC
1832 { $$ = DeclarationNode::newStorageClass( Type::Static ); }
1833 | AUTO
1834 { $$ = DeclarationNode::newStorageClass( Type::Auto ); }
1835 | REGISTER
1836 { $$ = DeclarationNode::newStorageClass( Type::Register ); }
1837 | THREADLOCAL // C11
1838 { $$ = DeclarationNode::newStorageClass( Type::Threadlocal ); }
1839 // Put function specifiers here to simplify parsing rules, but separate them semantically.
1840 | INLINE // C99
1841 { $$ = DeclarationNode::newFuncSpecifier( Type::Inline ); }
1842 | FORTRAN // C99
1843 { $$ = DeclarationNode::newFuncSpecifier( Type::Fortran ); }
1844 | NORETURN // C11
1845 { $$ = DeclarationNode::newFuncSpecifier( Type::Noreturn ); }
1846 ;
1847
1848basic_type_name:
1849 VOID
1850 { $$ = DeclarationNode::newBasicType( DeclarationNode::Void ); }
1851 | BOOL // C99
1852 { $$ = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
1853 | CHAR
1854 { $$ = DeclarationNode::newBasicType( DeclarationNode::Char ); }
1855 | INT
1856 { $$ = DeclarationNode::newBasicType( DeclarationNode::Int ); }
1857 | INT128
1858 { $$ = DeclarationNode::newBasicType( DeclarationNode::Int128 ); }
1859 | UINT128
1860 { $$ = DeclarationNode::newBasicType( DeclarationNode::Int128 )->addType( DeclarationNode::newSignedNess( DeclarationNode::Unsigned ) ); }
1861 | FLOAT
1862 { $$ = DeclarationNode::newBasicType( DeclarationNode::Float ); }
1863 | DOUBLE
1864 { $$ = DeclarationNode::newBasicType( DeclarationNode::Double ); }
1865 | uuFLOAT80
1866 { $$ = DeclarationNode::newBasicType( DeclarationNode::uuFloat80 ); }
1867 | uuFLOAT128
1868 { $$ = DeclarationNode::newBasicType( DeclarationNode::uuFloat128 ); }
1869 | uFLOAT16
1870 { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat16 ); }
1871 | uFLOAT32
1872 { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat32 ); }
1873 | uFLOAT32X
1874 { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat32x ); }
1875 | uFLOAT64
1876 { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat64 ); }
1877 | uFLOAT64X
1878 { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat64x ); }
1879 | uFLOAT128
1880 { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat128 ); }
1881 | COMPLEX // C99
1882 { $$ = DeclarationNode::newComplexType( DeclarationNode::Complex ); }
1883 | IMAGINARY // C99
1884 { $$ = DeclarationNode::newComplexType( DeclarationNode::Imaginary ); }
1885 | SIGNED
1886 { $$ = DeclarationNode::newSignedNess( DeclarationNode::Signed ); }
1887 | UNSIGNED
1888 { $$ = DeclarationNode::newSignedNess( DeclarationNode::Unsigned ); }
1889 | SHORT
1890 { $$ = DeclarationNode::newLength( DeclarationNode::Short ); }
1891 | LONG
1892 { $$ = DeclarationNode::newLength( DeclarationNode::Long ); }
1893 | VALIST // GCC, __builtin_va_list
1894 { $$ = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); }
1895 | AUTO_TYPE
1896 { $$ = DeclarationNode::newBuiltinType( DeclarationNode::AutoType ); }
1897 ;
1898
1899basic_declaration_specifier:
1900 // A semantic check is necessary for conflicting storage classes.
1901 basic_type_specifier
1902 | declaration_qualifier_list basic_type_specifier
1903 { $$ = $2->addQualifiers( $1 ); }
1904 | basic_declaration_specifier storage_class // remaining OBSOLESCENT (see 2)
1905 { $$ = $1->addQualifiers( $2 ); }
1906 | basic_declaration_specifier storage_class type_qualifier_list
1907 { $$ = $1->addQualifiers( $2 )->addQualifiers( $3 ); }
1908 | basic_declaration_specifier storage_class basic_type_specifier
1909 { $$ = $3->addQualifiers( $2 )->addType( $1 ); }
1910 ;
1911
1912basic_type_specifier:
1913 direct_type
1914 // Cannot have type modifiers, e.g., short, long, etc.
1915 | type_qualifier_list_opt indirect_type type_qualifier_list_opt
1916 { $$ = $2->addQualifiers( $1 )->addQualifiers( $3 ); }
1917 ;
1918
1919direct_type:
1920 basic_type_name
1921 | type_qualifier_list basic_type_name
1922 { $$ = $2->addQualifiers( $1 ); }
1923 | direct_type type_qualifier
1924 { $$ = $1->addQualifiers( $2 ); }
1925 | direct_type basic_type_name
1926 { $$ = $1->addType( $2 ); }
1927 ;
1928
1929indirect_type:
1930 TYPEOF '(' type ')' // GCC: typeof( x ) y;
1931 { $$ = $3; }
1932 | TYPEOF '(' comma_expression ')' // GCC: typeof( a+b ) y;
1933 { $$ = DeclarationNode::newTypeof( $3 ); }
1934 | BASETYPEOF '(' type ')' // CFA: basetypeof( x ) y;
1935 { $$ = DeclarationNode::newTypeof( new ExpressionNode( new TypeExpr( maybeMoveBuildType( $3 ) ) ), true ); }
1936 | BASETYPEOF '(' comma_expression ')' // CFA: basetypeof( a+b ) y;
1937 { $$ = DeclarationNode::newTypeof( $3, true ); }
1938 | ZERO_T // CFA
1939 { $$ = DeclarationNode::newBuiltinType( DeclarationNode::Zero ); }
1940 | ONE_T // CFA
1941 { $$ = DeclarationNode::newBuiltinType( DeclarationNode::One ); }
1942 ;
1943
1944sue_declaration_specifier: // struct, union, enum + storage class + type specifier
1945 sue_type_specifier
1946 | declaration_qualifier_list sue_type_specifier
1947 { $$ = $2->addQualifiers( $1 ); }
1948 | sue_declaration_specifier storage_class // remaining OBSOLESCENT (see 2)
1949 { $$ = $1->addQualifiers( $2 ); }
1950 | sue_declaration_specifier storage_class type_qualifier_list
1951 { $$ = $1->addQualifiers( $2 )->addQualifiers( $3 ); }
1952 ;
1953
1954sue_type_specifier: // struct, union, enum + type specifier
1955 elaborated_type
1956 | type_qualifier_list
1957 { if ( $1->type != nullptr && $1->type->forall ) forall = true; } // remember generic type
1958 elaborated_type
1959 { $$ = $3->addQualifiers( $1 ); }
1960 | sue_type_specifier type_qualifier
1961 {
1962 if ( $2->type != nullptr && $2->type->forall ) forall = true; // remember generic type
1963 $$ = $1->addQualifiers( $2 );
1964 }
1965 ;
1966
1967sue_declaration_specifier_nobody: // struct, union, enum - {...} + storage class + type specifier
1968 sue_type_specifier_nobody
1969 | declaration_qualifier_list sue_type_specifier_nobody
1970 { $$ = $2->addQualifiers( $1 ); }
1971 | sue_declaration_specifier_nobody storage_class // remaining OBSOLESCENT (see 2)
1972 { $$ = $1->addQualifiers( $2 ); }
1973 | sue_declaration_specifier_nobody storage_class type_qualifier_list
1974 { $$ = $1->addQualifiers( $2 )->addQualifiers( $3 ); }
1975 ;
1976
1977sue_type_specifier_nobody: // struct, union, enum - {...} + type specifier
1978 elaborated_type_nobody
1979 | type_qualifier_list elaborated_type_nobody
1980 { $$ = $2->addQualifiers( $1 ); }
1981 | sue_type_specifier_nobody type_qualifier
1982 { $$ = $1->addQualifiers( $2 ); }
1983 ;
1984
1985type_declaration_specifier:
1986 type_type_specifier
1987 | declaration_qualifier_list type_type_specifier
1988 { $$ = $2->addQualifiers( $1 ); }
1989 | type_declaration_specifier storage_class // remaining OBSOLESCENT (see 2)
1990 { $$ = $1->addQualifiers( $2 ); }
1991 | type_declaration_specifier storage_class type_qualifier_list
1992 { $$ = $1->addQualifiers( $2 )->addQualifiers( $3 ); }
1993 ;
1994
1995type_type_specifier: // typedef types
1996 type_name
1997 | type_qualifier_list type_name
1998 { $$ = $2->addQualifiers( $1 ); }
1999 | type_type_specifier type_qualifier
2000 { $$ = $1->addQualifiers( $2 ); }
2001 ;
2002
2003type_name:
2004 TYPEDEFname
2005 { $$ = DeclarationNode::newFromTypedef( $1 ); }
2006 | '.' TYPEDEFname
2007 { $$ = DeclarationNode::newQualifiedType( DeclarationNode::newFromGlobalScope(), DeclarationNode::newFromTypedef( $2 ) ); }
2008 | type_name '.' TYPEDEFname
2009 { $$ = DeclarationNode::newQualifiedType( $1, DeclarationNode::newFromTypedef( $3 ) ); }
2010 | typegen_name
2011 | '.' typegen_name
2012 { $$ = DeclarationNode::newQualifiedType( DeclarationNode::newFromGlobalScope(), $2 ); }
2013 | type_name '.' typegen_name
2014 { $$ = DeclarationNode::newQualifiedType( $1, $3 ); }
2015 ;
2016
2017typegen_name: // CFA
2018 TYPEGENname
2019 { $$ = DeclarationNode::newFromTypeGen( $1, nullptr ); }
2020 | TYPEGENname '(' ')'
2021 { $$ = DeclarationNode::newFromTypeGen( $1, nullptr ); }
2022 | TYPEGENname '(' type_list ')'
2023 { $$ = DeclarationNode::newFromTypeGen( $1, $3 ); }
2024 ;
2025
2026elaborated_type: // struct, union, enum
2027 aggregate_type
2028 | enum_type
2029 ;
2030
2031elaborated_type_nobody: // struct, union, enum - {...}
2032 aggregate_type_nobody
2033 | enum_type_nobody
2034 ;
2035
2036aggregate_type: // struct, union
2037 aggregate_key attribute_list_opt
2038 { forall = false; } // reset
2039 '{' field_declaration_list_opt '}' type_parameters_opt
2040 { $$ = DeclarationNode::newAggregate( $1, nullptr, $7, $5, true )->addQualifiers( $2 ); }
2041 | aggregate_key attribute_list_opt identifier
2042 {
2043 typedefTable.makeTypedef( *$3, forall || typedefTable.getEnclForall() ? TYPEGENname : TYPEDEFname ); // create typedef
2044 forall = false; // reset
2045 }
2046 '{' field_declaration_list_opt '}' type_parameters_opt
2047 { $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 ); }
2048 | aggregate_key attribute_list_opt TYPEDEFname // unqualified type name
2049 {
2050 typedefTable.makeTypedef( *$3, forall || typedefTable.getEnclForall() ? TYPEGENname : TYPEDEFname ); // create typedef
2051 forall = false; // reset
2052 }
2053 '{' field_declaration_list_opt '}' type_parameters_opt
2054 {
2055 DeclarationNode::newFromTypedef( $3 );
2056 $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 );
2057 }
2058 | aggregate_key attribute_list_opt TYPEGENname // unqualified type name
2059 {
2060 typedefTable.makeTypedef( *$3, forall || typedefTable.getEnclForall() ? TYPEGENname : TYPEDEFname ); // create typedef
2061 forall = false; // reset
2062 }
2063 '{' field_declaration_list_opt '}' type_parameters_opt
2064 {
2065 DeclarationNode::newFromTypeGen( $3, nullptr );
2066 $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 );
2067 }
2068 | aggregate_type_nobody
2069 ;
2070
2071type_parameters_opt:
2072 // empty
2073 { $$ = nullptr; } %prec '}'
2074 | '(' type_list ')'
2075 { $$ = $2; }
2076 ;
2077
2078aggregate_type_nobody: // struct, union - {...}
2079 aggregate_key attribute_list_opt identifier
2080 {
2081 typedefTable.makeTypedef( *$3, forall || typedefTable.getEnclForall() ? TYPEGENname : TYPEDEFname );
2082 forall = false; // reset
2083 $$ = DeclarationNode::newAggregate( $1, $3, nullptr, nullptr, false )->addQualifiers( $2 );
2084 }
2085 | aggregate_key attribute_list_opt type_name
2086 {
2087 forall = false; // reset
2088 // Create new generic declaration with same name as previous forward declaration, where the IDENTIFIER is
2089 // switched to a TYPEGENname. Link any generic arguments from typegen_name to new generic declaration and
2090 // delete newFromTypeGen.
2091 $$ = DeclarationNode::newAggregate( $1, $3->type->symbolic.name, $3->type->symbolic.actuals, nullptr, false )->addQualifiers( $2 );
2092 $3->type->symbolic.name = nullptr;
2093 $3->type->symbolic.actuals = nullptr;
2094 delete $3;
2095 }
2096 ;
2097
2098aggregate_key:
2099 aggregate_data
2100 | aggregate_control
2101 ;
2102
2103aggregate_data:
2104 STRUCT
2105 { yyy = true; $$ = AggregateDecl::Struct; }
2106 | UNION
2107 { yyy = true; $$ = AggregateDecl::Union; }
2108 | EXCEPTION // CFA
2109 // { yyy = true; $$ = AggregateDecl::Exception; }
2110 { SemanticError( yylloc, "exception aggregate is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
2111 ;
2112
2113aggregate_control: // CFA
2114 MONITOR
2115 { yyy = true; $$ = AggregateDecl::Monitor; }
2116 | MUTEX STRUCT
2117 { yyy = true; $$ = AggregateDecl::Monitor; }
2118 | GENERATOR
2119 { yyy = true; $$ = AggregateDecl::Generator; }
2120 | MUTEX GENERATOR
2121 { SemanticError( yylloc, "monitor generator is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
2122 | COROUTINE
2123 { yyy = true; $$ = AggregateDecl::Coroutine; }
2124 | MUTEX COROUTINE
2125 { SemanticError( yylloc, "monitor coroutine is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
2126 | THREAD
2127 { yyy = true; $$ = AggregateDecl::Thread; }
2128 | MUTEX THREAD
2129 { SemanticError( yylloc, "monitor thread is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
2130 ;
2131
2132field_declaration_list_opt:
2133 // empty
2134 { $$ = nullptr; }
2135 | field_declaration_list_opt field_declaration
2136 { $$ = $1 ? $1->appendList( $2 ) : $2; }
2137 ;
2138
2139field_declaration:
2140 type_specifier field_declaring_list_opt ';'
2141 { $$ = fieldDecl( $1, $2 ); }
2142 | EXTENSION type_specifier field_declaring_list_opt ';' // GCC
2143 { $$ = fieldDecl( $2, $3 ); distExt( $$ ); }
2144 | INLINE type_specifier field_abstract_list_opt ';' // CFA
2145 {
2146 if ( ! $3 ) { // field declarator ?
2147 $3 = DeclarationNode::newName( nullptr );
2148 } // if
2149 $3->inLine = true;
2150 $$ = distAttr( $2, $3 ); // mark all fields in list
2151 distInl( $3 );
2152 }
2153 | INLINE aggregate_control ';' // CFA
2154 { SemanticError( yylloc, "INLINE aggregate control currently unimplemented." ); $$ = nullptr; }
2155 | typedef_declaration ';' // CFA
2156 | cfa_field_declaring_list ';' // CFA, new style field declaration
2157 | EXTENSION cfa_field_declaring_list ';' // GCC
2158 { distExt( $2 ); $$ = $2; } // mark all fields in list
2159 | INLINE cfa_field_abstract_list ';' // CFA, new style field declaration
2160 { $$ = $2; } // mark all fields in list
2161 | cfa_typedef_declaration ';' // CFA
2162 | static_assert // C11
2163 ;
2164
2165field_declaring_list_opt:
2166 // empty
2167 { $$ = nullptr; }
2168 | field_declarator
2169 | field_declaring_list_opt ',' attribute_list_opt field_declarator
2170 { $$ = $1->appendList( $4->addQualifiers( $3 ) ); }
2171 ;
2172
2173field_declarator:
2174 bit_subrange_size // C special case, no field name
2175 { $$ = DeclarationNode::newBitfield( $1 ); }
2176 | variable_declarator bit_subrange_size_opt
2177 // A semantic check is required to ensure bit_subrange only appears on integral types.
2178 { $$ = $1->addBitfield( $2 ); }
2179 | variable_type_redeclarator bit_subrange_size_opt
2180 // A semantic check is required to ensure bit_subrange only appears on integral types.
2181 { $$ = $1->addBitfield( $2 ); }
2182 ;
2183
2184field_abstract_list_opt:
2185 // empty
2186 { $$ = nullptr; }
2187 | field_abstract
2188 | field_abstract_list_opt ',' attribute_list_opt field_abstract
2189 { $$ = $1->appendList( $4->addQualifiers( $3 ) ); }
2190 ;
2191
2192field_abstract:
2193 // no bit fields
2194 variable_abstract_declarator
2195 ;
2196
2197cfa_field_declaring_list: // CFA, new style field declaration
2198 // bit-fields are handled by C declarations
2199 cfa_abstract_declarator_tuple identifier_or_type_name
2200 { $$ = $1->addName( $2 ); }
2201 | cfa_field_declaring_list ',' identifier_or_type_name
2202 { $$ = $1->appendList( $1->cloneType( $3 ) ); }
2203 ;
2204
2205cfa_field_abstract_list: // CFA, new style field declaration
2206 // bit-fields are handled by C declarations
2207 cfa_abstract_declarator_tuple
2208 | cfa_field_abstract_list ','
2209 { $$ = $1->appendList( $1->cloneType( 0 ) ); }
2210 ;
2211
2212bit_subrange_size_opt:
2213 // empty
2214 { $$ = nullptr; }
2215 | bit_subrange_size
2216 ;
2217
2218bit_subrange_size:
2219 ':' assignment_expression
2220 { $$ = $2; }
2221 ;
2222
2223enum_type: // enum
2224 ENUM attribute_list_opt '{' enumerator_list comma_opt '}'
2225 { $$ = DeclarationNode::newEnum( nullptr, $4, true )->addQualifiers( $2 ); }
2226 | ENUM attribute_list_opt identifier
2227 { typedefTable.makeTypedef( *$3 ); }
2228 '{' enumerator_list comma_opt '}'
2229 { $$ = DeclarationNode::newEnum( $3, $6, true )->addQualifiers( $2 ); }
2230 | ENUM attribute_list_opt typedef_name // unqualified type name
2231 '{' enumerator_list comma_opt '}'
2232 { $$ = DeclarationNode::newEnum( $3->name, $5, true )->addQualifiers( $2 ); }
2233 | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt '{' enumerator_list comma_opt '}'
2234 {
2235 if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 ) { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
2236 SemanticError( yylloc, "Typed enumeration is currently unimplemented." ); $$ = nullptr;
2237 }
2238 | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt identifier attribute_list_opt
2239 {
2240 if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 ) { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
2241 typedefTable.makeTypedef( *$6 );
2242 }
2243 '{' enumerator_list comma_opt '}'
2244 {
2245 SemanticError( yylloc, "Typed enumeration is currently unimplemented." ); $$ = nullptr;
2246 }
2247 | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt typedef_name attribute_list_opt '{' enumerator_list comma_opt '}'
2248 {
2249 if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 ) { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
2250 typedefTable.makeTypedef( *$6->name );
2251 SemanticError( yylloc, "Typed enumeration is currently unimplemented." ); $$ = nullptr;
2252 }
2253 | enum_type_nobody
2254 ;
2255
2256enum_type_nobody: // enum - {...}
2257 ENUM attribute_list_opt identifier
2258 { typedefTable.makeTypedef( *$3 ); $$ = DeclarationNode::newEnum( $3, 0, false )->addQualifiers( $2 ); }
2259 | ENUM attribute_list_opt type_name // qualified type name
2260 { typedefTable.makeTypedef( *$3->type->symbolic.name ); $$ = DeclarationNode::newEnum( $3->type->symbolic.name, 0, false )->addQualifiers( $2 ); }
2261 ;
2262
2263enumerator_list:
2264 identifier_or_type_name enumerator_value_opt
2265 { $$ = DeclarationNode::newEnumConstant( $1, $2 ); }
2266 | INLINE type_name
2267 { $$ = DeclarationNode::newEnumConstant( new string("inline"), nullptr ); }
2268 | enumerator_list ',' identifier_or_type_name enumerator_value_opt
2269 { $$ = $1->appendList( DeclarationNode::newEnumConstant( $3, $4 ) ); }
2270 | enumerator_list ',' INLINE type_name enumerator_value_opt
2271 { $$ = $1->appendList( DeclarationNode::newEnumConstant( new string("inline"), nullptr ) ); }
2272 ;
2273
2274enumerator_value_opt:
2275 // empty
2276 { $$ = nullptr; }
2277 // | '=' constant_expression
2278 // { $$ = $2; }
2279 | simple_assignment_operator initializer
2280 { $$ = $2->get_expression(); } // FIX ME: enum only deals with constant_expression
2281 ;
2282
2283cfa_parameter_ellipsis_list_opt: // CFA, abstract + real
2284 // empty
2285 { $$ = DeclarationNode::newBasicType( DeclarationNode::Void ); }
2286 | ELLIPSIS
2287 { $$ = nullptr; }
2288 | cfa_abstract_parameter_list
2289 | cfa_parameter_list
2290 | cfa_parameter_list pop ',' push cfa_abstract_parameter_list
2291 { $$ = $1->appendList( $5 ); }
2292 | cfa_abstract_parameter_list pop ',' push ELLIPSIS
2293 { $$ = $1->addVarArgs(); }
2294 | cfa_parameter_list pop ',' push ELLIPSIS
2295 { $$ = $1->addVarArgs(); }
2296 ;
2297
2298cfa_parameter_list: // CFA
2299 // To obtain LR(1) between cfa_parameter_list and cfa_abstract_tuple, the last cfa_abstract_parameter_list is
2300 // factored out from cfa_parameter_list, flattening the rules to get lookahead to the ']'.
2301 cfa_parameter_declaration
2302 | cfa_abstract_parameter_list pop ',' push cfa_parameter_declaration
2303 { $$ = $1->appendList( $5 ); }
2304 | cfa_parameter_list pop ',' push cfa_parameter_declaration
2305 { $$ = $1->appendList( $5 ); }
2306 | cfa_parameter_list pop ',' push cfa_abstract_parameter_list pop ',' push cfa_parameter_declaration
2307 { $$ = $1->appendList( $5 )->appendList( $9 ); }
2308 ;
2309
2310cfa_abstract_parameter_list: // CFA, new & old style abstract
2311 cfa_abstract_parameter_declaration
2312 | cfa_abstract_parameter_list pop ',' push cfa_abstract_parameter_declaration
2313 { $$ = $1->appendList( $5 ); }
2314 ;
2315
2316parameter_type_list_opt:
2317 // empty
2318 { $$ = nullptr; }
2319 | ELLIPSIS
2320 { $$ = nullptr; }
2321 | parameter_list
2322 | parameter_list pop ',' push ELLIPSIS
2323 { $$ = $1->addVarArgs(); }
2324 ;
2325
2326parameter_list: // abstract + real
2327 abstract_parameter_declaration
2328 | parameter_declaration
2329 | parameter_list pop ',' push abstract_parameter_declaration
2330 { $$ = $1->appendList( $5 ); }
2331 | parameter_list pop ',' push parameter_declaration
2332 { $$ = $1->appendList( $5 ); }
2333 ;
2334
2335// Provides optional identifier names (abstract_declarator/variable_declarator), no initialization, different semantics
2336// for typedef name by using type_parameter_redeclarator instead of typedef_redeclarator, and function prototypes.
2337
2338cfa_parameter_declaration: // CFA, new & old style parameter declaration
2339 parameter_declaration
2340 | cfa_identifier_parameter_declarator_no_tuple identifier_or_type_name default_initializer_opt
2341 { $$ = $1->addName( $2 ); }
2342 | cfa_abstract_tuple identifier_or_type_name default_initializer_opt
2343 // To obtain LR(1), these rules must be duplicated here (see cfa_abstract_declarator).
2344 { $$ = $1->addName( $2 ); }
2345 | type_qualifier_list cfa_abstract_tuple identifier_or_type_name default_initializer_opt
2346 { $$ = $2->addName( $3 )->addQualifiers( $1 ); }
2347 | cfa_function_specifier
2348 ;
2349
2350cfa_abstract_parameter_declaration: // CFA, new & old style parameter declaration
2351 abstract_parameter_declaration
2352 | cfa_identifier_parameter_declarator_no_tuple
2353 | cfa_abstract_tuple
2354 // To obtain LR(1), these rules must be duplicated here (see cfa_abstract_declarator).
2355 | type_qualifier_list cfa_abstract_tuple
2356 { $$ = $2->addQualifiers( $1 ); }
2357 | cfa_abstract_function
2358 ;
2359
2360parameter_declaration:
2361 // No SUE declaration in parameter list.
2362 declaration_specifier_nobody identifier_parameter_declarator default_initializer_opt
2363 { $$ = $2->addType( $1 )->addInitializer( $3 ? new InitializerNode( $3 ) : nullptr ); }
2364 | declaration_specifier_nobody type_parameter_redeclarator default_initializer_opt
2365 { $$ = $2->addType( $1 )->addInitializer( $3 ? new InitializerNode( $3 ) : nullptr ); }
2366 ;
2367
2368abstract_parameter_declaration:
2369 declaration_specifier_nobody default_initializer_opt
2370 { $$ = $1->addInitializer( $2 ? new InitializerNode( $2 ) : nullptr ); }
2371 | declaration_specifier_nobody abstract_parameter_declarator default_initializer_opt
2372 { $$ = $2->addType( $1 )->addInitializer( $3 ? new InitializerNode( $3 ) : nullptr ); }
2373 ;
2374
2375// ISO/IEC 9899:1999 Section 6.9.1(6) : "An identifier declared as a typedef name shall not be redeclared as a
2376// parameter." Because the scope of the K&R-style parameter-list sees the typedef first, the following is based only on
2377// identifiers. The ANSI-style parameter-list can redefine a typedef name.
2378
2379identifier_list: // K&R-style parameter list => no types
2380 identifier
2381 { $$ = DeclarationNode::newName( $1 ); }
2382 | identifier_list ',' identifier
2383 { $$ = $1->appendList( DeclarationNode::newName( $3 ) ); }
2384 ;
2385
2386identifier_or_type_name:
2387 identifier
2388 | TYPEDEFname
2389 | TYPEGENname
2390 ;
2391
2392type_no_function: // sizeof, alignof, cast (constructor)
2393 cfa_abstract_declarator_tuple // CFA
2394 | type_specifier
2395 | type_specifier abstract_declarator
2396 { $$ = $2->addType( $1 ); }
2397 ;
2398
2399type: // typeof, assertion
2400 type_no_function
2401 | cfa_abstract_function // CFA
2402 ;
2403
2404initializer_opt:
2405 // empty
2406 { $$ = nullptr; }
2407 | simple_assignment_operator initializer { $$ = $1 == OperKinds::Assign ? $2 : $2->set_maybeConstructed( false ); }
2408 | '=' VOID { $$ = new InitializerNode( true ); }
2409 ;
2410
2411initializer:
2412 assignment_expression { $$ = new InitializerNode( $1 ); }
2413 | '{' initializer_list_opt comma_opt '}' { $$ = new InitializerNode( $2, true ); }
2414 ;
2415
2416initializer_list_opt:
2417 // empty
2418 { $$ = nullptr; }
2419 | initializer
2420 | designation initializer { $$ = $2->set_designators( $1 ); }
2421 | initializer_list_opt ',' initializer { $$ = (InitializerNode *)( $1->set_last( $3 ) ); }
2422 | initializer_list_opt ',' designation initializer
2423 { $$ = (InitializerNode *)($1->set_last( $4->set_designators( $3 ) )); }
2424 ;
2425
2426// There is an unreconcileable parsing problem between C99 and CFA with respect to designators. The problem is use of
2427// '=' to separator the designator from the initializer value, as in:
2428//
2429// int x[10] = { [1] = 3 };
2430//
2431// The string "[1] = 3" can be parsed as a designator assignment or a tuple assignment. To disambiguate this case, CFA
2432// changes the syntax from "=" to ":" as the separator between the designator and initializer. GCC does uses ":" for
2433// field selection. The optional use of the "=" in GCC, or in this case ":", cannot be supported either due to
2434// shift/reduce conflicts
2435
2436designation:
2437 designator_list ':' // C99, CFA uses ":" instead of "="
2438 | identifier ':' // GCC, field name
2439 { $$ = new ExpressionNode( build_varref( $1 ) ); }
2440 ;
2441
2442designator_list: // C99
2443 designator
2444 | designator_list designator
2445 { $$ = (ExpressionNode *)($1->set_last( $2 )); }
2446 //| designator_list designator { $$ = new ExpressionNode( $1, $2 ); }
2447 ;
2448
2449designator:
2450 '.' identifier // C99, field name
2451 { $$ = new ExpressionNode( build_varref( $2 ) ); }
2452 | '[' push assignment_expression pop ']' // C99, single array element
2453 // assignment_expression used instead of constant_expression because of shift/reduce conflicts with tuple.
2454 { $$ = $3; }
2455 | '[' push subrange pop ']' // CFA, multiple array elements
2456 { $$ = $3; }
2457 | '[' push constant_expression ELLIPSIS constant_expression pop ']' // GCC, multiple array elements
2458 { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild<Expression>( $3 ), maybeMoveBuild<Expression>( $5 ) ) ); }
2459 | '.' '[' push field_name_list pop ']' // CFA, tuple field selector
2460 { $$ = $4; }
2461 ;
2462
2463// The CFA type system is based on parametric polymorphism, the ability to declare functions with type parameters,
2464// rather than an object-oriented type system. This required four groups of extensions:
2465//
2466// Overloading: function, data, and operator identifiers may be overloaded.
2467//
2468// Type declarations: "otype" is used to generate new types for declaring objects. Similarly, "dtype" is used for object
2469// and incomplete types, and "ftype" is used for function types. Type declarations with initializers provide
2470// definitions of new types. Type declarations with storage class "extern" provide opaque types.
2471//
2472// Polymorphic functions: A forall clause declares a type parameter. The corresponding argument is inferred at the call
2473// site. A polymorphic function is not a template; it is a function, with an address and a type.
2474//
2475// Specifications and Assertions: Specifications are collections of declarations parameterized by one or more
2476// types. They serve many of the purposes of abstract classes, and specification hierarchies resemble subclass
2477// hierarchies. Unlike classes, they can define relationships between types. Assertions declare that a type or
2478// types provide the operations declared by a specification. Assertions are normally used to declare requirements
2479// on type arguments of polymorphic functions.
2480
2481type_parameter_list: // CFA
2482 type_parameter
2483 | type_parameter_list ',' type_parameter
2484 { $$ = $1->appendList( $3 ); }
2485 ;
2486
2487type_initializer_opt: // CFA
2488 // empty
2489 { $$ = nullptr; }
2490 | '=' type
2491 { $$ = $2; }
2492 ;
2493
2494type_parameter: // CFA
2495 type_class identifier_or_type_name
2496 {
2497 typedefTable.addToScope( *$2, TYPEDEFname, "9" );
2498 if ( $1 == TypeDecl::Otype ) { SemanticError( yylloc, "otype keyword is deprecated, use T " ); }
2499 if ( $1 == TypeDecl::Dtype ) { SemanticError( yylloc, "dtype keyword is deprecated, use T &" ); }
2500 if ( $1 == TypeDecl::Ttype ) { SemanticError( yylloc, "ttype keyword is deprecated, use T ..." ); }
2501 }
2502 type_initializer_opt assertion_list_opt
2503 { $$ = DeclarationNode::newTypeParam( $1, $2 )->addTypeInitializer( $4 )->addAssertions( $5 ); }
2504 | identifier_or_type_name new_type_class
2505 { typedefTable.addToScope( *$1, TYPEDEFname, "9" ); }
2506 type_initializer_opt assertion_list_opt
2507 { $$ = DeclarationNode::newTypeParam( $2, $1 )->addTypeInitializer( $4 )->addAssertions( $5 ); }
2508 | '[' identifier_or_type_name ']'
2509 {
2510 typedefTable.addToScope( *$2, TYPEDEFname, "9" );
2511 $$ = DeclarationNode::newTypeParam( TypeDecl::ALtype, $2 );
2512 }
2513 // | type_specifier identifier_parameter_declarator
2514 | assertion_list
2515 { $$ = DeclarationNode::newTypeParam( TypeDecl::Dtype, new string( DeclarationNode::anonymous.newName() ) )->addAssertions( $1 ); }
2516 ;
2517
2518new_type_class: // CFA
2519 // empty
2520 { $$ = TypeDecl::Otype; }
2521 | '&'
2522 { $$ = TypeDecl::Dtype; }
2523 | '*'
2524 { $$ = TypeDecl::DStype; } // dtype + sized
2525 | ELLIPSIS
2526 { $$ = TypeDecl::Ttype; }
2527 ;
2528
2529type_class: // CFA
2530 OTYPE
2531 { $$ = TypeDecl::Otype; }
2532 | DTYPE
2533 { $$ = TypeDecl::Dtype; }
2534 | FTYPE
2535 { $$ = TypeDecl::Ftype; }
2536 | TTYPE
2537 { $$ = TypeDecl::Ttype; }
2538 ;
2539
2540assertion_list_opt: // CFA
2541 // empty
2542 { $$ = nullptr; }
2543 | assertion_list
2544 ;
2545
2546assertion_list: // CFA
2547 assertion
2548 | assertion_list assertion
2549 { $$ = $1->appendList( $2 ); }
2550 ;
2551
2552assertion: // CFA
2553 '|' identifier_or_type_name '(' type_list ')'
2554 { $$ = DeclarationNode::newTraitUse( $2, $4 ); }
2555 | '|' '{' push trait_declaration_list pop '}'
2556 { $$ = $4; }
2557 // | '|' '(' push type_parameter_list pop ')' '{' push trait_declaration_list pop '}' '(' type_list ')'
2558 // { SemanticError( yylloc, "Generic data-type assertion is currently unimplemented." ); $$ = nullptr; }
2559 ;
2560
2561type_list: // CFA
2562 type
2563 { $$ = new ExpressionNode( new TypeExpr( maybeMoveBuildType( $1 ) ) ); }
2564 | assignment_expression
2565 { SemanticError( yylloc, toString("Expression generic parameters are currently unimplemented: ", $1->build()) ); $$ = nullptr; }
2566 | type_list ',' type
2567 { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new TypeExpr( maybeMoveBuildType( $3 ) ) ) )); }
2568 | type_list ',' assignment_expression
2569 { SemanticError( yylloc, toString("Expression generic parameters are currently unimplemented: ", $3->build()) ); $$ = nullptr; }
2570 // { $$ = (ExpressionNode *)( $1->set_last( $3 )); }
2571 ;
2572
2573type_declaring_list: // CFA
2574 OTYPE type_declarator
2575 { $$ = $2; }
2576 | storage_class_list OTYPE type_declarator
2577 { $$ = $3->addQualifiers( $1 ); }
2578 | type_declaring_list ',' type_declarator
2579 { $$ = $1->appendList( $3->copySpecifiers( $1 ) ); }
2580 ;
2581
2582type_declarator: // CFA
2583 type_declarator_name assertion_list_opt
2584 { $$ = $1->addAssertions( $2 ); }
2585 | type_declarator_name assertion_list_opt '=' type
2586 { $$ = $1->addAssertions( $2 )->addType( $4 ); }
2587 ;
2588
2589type_declarator_name: // CFA
2590 identifier_or_type_name
2591 {
2592 typedefTable.addToEnclosingScope( *$1, TYPEDEFname, "10" );
2593 $$ = DeclarationNode::newTypeDecl( $1, 0 );
2594 }
2595 | identifier_or_type_name '(' type_parameter_list ')'
2596 {
2597 typedefTable.addToEnclosingScope( *$1, TYPEGENname, "11" );
2598 $$ = DeclarationNode::newTypeDecl( $1, $3 );
2599 }
2600 ;
2601
2602trait_specifier: // CFA
2603 TRAIT identifier_or_type_name '(' type_parameter_list ')' '{' '}'
2604 { $$ = DeclarationNode::newTrait( $2, $4, 0 ); }
2605 | TRAIT identifier_or_type_name '(' type_parameter_list ')' '{' push trait_declaration_list pop '}'
2606 { $$ = DeclarationNode::newTrait( $2, $4, $8 ); }
2607 ;
2608
2609trait_declaration_list: // CFA
2610 trait_declaration
2611 | trait_declaration_list pop push trait_declaration
2612 { $$ = $1->appendList( $4 ); }
2613 ;
2614
2615trait_declaration: // CFA
2616 cfa_trait_declaring_list ';'
2617 | trait_declaring_list ';'
2618 ;
2619
2620cfa_trait_declaring_list: // CFA
2621 cfa_variable_specifier
2622 | cfa_function_specifier
2623 | cfa_trait_declaring_list pop ',' push identifier_or_type_name
2624 { $$ = $1->appendList( $1->cloneType( $5 ) ); }
2625 ;
2626
2627trait_declaring_list: // CFA
2628 type_specifier declarator
2629 { $$ = $2->addType( $1 ); }
2630 | trait_declaring_list pop ',' push declarator
2631 { $$ = $1->appendList( $1->cloneBaseType( $5 ) ); }
2632 ;
2633
2634//***************************** EXTERNAL DEFINITIONS *****************************
2635
2636translation_unit:
2637 // empty, input file
2638 | external_definition_list
2639 { parseTree = parseTree ? parseTree->appendList( $1 ) : $1; }
2640 ;
2641
2642external_definition_list:
2643 push external_definition pop
2644 { $$ = $2; }
2645 | external_definition_list push external_definition pop
2646 { $$ = $1 ? $1->appendList( $3 ) : $3; }
2647 ;
2648
2649external_definition_list_opt:
2650 // empty
2651 { $$ = nullptr; }
2652 | external_definition_list
2653 ;
2654
2655up:
2656 { typedefTable.up( forall ); forall = false; }
2657 ;
2658
2659down:
2660 { typedefTable.down(); }
2661 ;
2662
2663external_definition:
2664 DIRECTIVE
2665 { $$ = DeclarationNode::newDirectiveStmt( new StatementNode( build_directive( $1 ) ) ); }
2666 | declaration
2667 | external_function_definition
2668 | EXTENSION external_definition // GCC, multiple __extension__ allowed, meaning unknown
2669 {
2670 distExt( $2 ); // mark all fields in list
2671 $$ = $2;
2672 }
2673 | ASM '(' string_literal ')' ';' // GCC, global assembler statement
2674 { $$ = DeclarationNode::newAsmStmt( new StatementNode( build_asm( false, $3, 0 ) ) ); }
2675 | EXTERN STRINGliteral // C++-style linkage specifier
2676 {
2677 linkageStack.push( linkage ); // handle nested extern "C"/"Cforall"
2678 linkage = LinkageSpec::update( yylloc, linkage, $2 );
2679 }
2680 '{' up external_definition_list_opt down '}'
2681 {
2682 linkage = linkageStack.top();
2683 linkageStack.pop();
2684 $$ = $6;
2685 }
2686 | type_qualifier_list
2687 {
2688 if ( $1->type->qualifiers.val ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
2689 if ( $1->type->forall ) forall = true; // remember generic type
2690 }
2691 '{' up external_definition_list_opt down '}' // CFA, namespace
2692 {
2693 distQual( $5, $1 );
2694 forall = false;
2695 $$ = $5;
2696 }
2697 | declaration_qualifier_list
2698 {
2699 if ( $1->type && $1->type->qualifiers.val ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
2700 if ( $1->type && $1->type->forall ) forall = true; // remember generic type
2701 }
2702 '{' up external_definition_list_opt down '}' // CFA, namespace
2703 {
2704 distQual( $5, $1 );
2705 forall = false;
2706 $$ = $5;
2707 }
2708 | declaration_qualifier_list type_qualifier_list
2709 {
2710 if ( ($1->type && $1->type->qualifiers.val) || $2->type->qualifiers.val ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
2711 if ( ($1->type && $1->type->forall) || $2->type->forall ) forall = true; // remember generic type
2712 }
2713 '{' up external_definition_list_opt down '}' // CFA, namespace
2714 {
2715 distQual( $6, $1->addQualifiers( $2 ) );
2716 forall = false;
2717 $$ = $6;
2718 }
2719 ;
2720
2721external_function_definition:
2722 function_definition
2723 // These rules are a concession to the "implicit int" type_specifier because there is a significant amount of
2724 // legacy code with global functions missing the type-specifier for the return type, and assuming "int".
2725 // Parsing is possible because function_definition does not appear in the context of an expression (nested
2726 // functions preclude this concession, i.e., all nested function must have a return type). A function prototype
2727 // declaration must still have a type_specifier. OBSOLESCENT (see 1)
2728 | function_declarator compound_statement
2729 { $$ = $1->addFunctionBody( $2 ); }
2730 | KR_function_declarator KR_parameter_list_opt compound_statement
2731 { $$ = $1->addOldDeclList( $2 )->addFunctionBody( $3 ); }
2732 ;
2733
2734with_clause_opt:
2735 // empty
2736 { $$ = nullptr; forall = false; }
2737 | WITH '(' tuple_expression_list ')'
2738 { $$ = $3; forall = false; }
2739 ;
2740
2741function_definition:
2742 cfa_function_declaration with_clause_opt compound_statement // CFA
2743 {
2744 // Add the function body to the last identifier in the function definition list, i.e., foo3:
2745 // [const double] foo1(), foo2( int ), foo3( double ) { return 3.0; }
2746 $1->get_last()->addFunctionBody( $3, $2 );
2747 $$ = $1;
2748 }
2749 | declaration_specifier function_declarator with_clause_opt compound_statement
2750 {
2751 rebindForall( $1, $2 );
2752 $$ = $2->addFunctionBody( $4, $3 )->addType( $1 );
2753 }
2754 | declaration_specifier variable_type_redeclarator with_clause_opt compound_statement
2755 {
2756 rebindForall( $1, $2 );
2757 $$ = $2->addFunctionBody( $4, $3 )->addType( $1 );
2758 }
2759 // handles default int return type, OBSOLESCENT (see 1)
2760 | type_qualifier_list function_declarator with_clause_opt compound_statement
2761 { $$ = $2->addFunctionBody( $4, $3 )->addQualifiers( $1 ); }
2762 // handles default int return type, OBSOLESCENT (see 1)
2763 | declaration_qualifier_list function_declarator with_clause_opt compound_statement
2764 { $$ = $2->addFunctionBody( $4, $3 )->addQualifiers( $1 ); }
2765 // handles default int return type, OBSOLESCENT (see 1)
2766 | declaration_qualifier_list type_qualifier_list function_declarator with_clause_opt compound_statement
2767 { $$ = $3->addFunctionBody( $5, $4 )->addQualifiers( $2 )->addQualifiers( $1 ); }
2768
2769 // Old-style K&R function definition, OBSOLESCENT (see 4)
2770 | declaration_specifier KR_function_declarator KR_parameter_list_opt with_clause_opt compound_statement
2771 {
2772 rebindForall( $1, $2 );
2773 $$ = $2->addOldDeclList( $3 )->addFunctionBody( $5, $4 )->addType( $1 );
2774 }
2775 // handles default int return type, OBSOLESCENT (see 1)
2776 | type_qualifier_list KR_function_declarator KR_parameter_list_opt with_clause_opt compound_statement
2777 { $$ = $2->addOldDeclList( $3 )->addFunctionBody( $5, $4 )->addQualifiers( $1 ); }
2778 // handles default int return type, OBSOLESCENT (see 1)
2779 | declaration_qualifier_list KR_function_declarator KR_parameter_list_opt with_clause_opt compound_statement
2780 { $$ = $2->addOldDeclList( $3 )->addFunctionBody( $5, $4 )->addQualifiers( $1 ); }
2781 // handles default int return type, OBSOLESCENT (see 1)
2782 | declaration_qualifier_list type_qualifier_list KR_function_declarator KR_parameter_list_opt with_clause_opt compound_statement
2783 { $$ = $3->addOldDeclList( $4 )->addFunctionBody( $6, $5 )->addQualifiers( $2 )->addQualifiers( $1 ); }
2784 ;
2785
2786declarator:
2787 variable_declarator
2788 | variable_type_redeclarator
2789 | function_declarator
2790 ;
2791
2792subrange:
2793 constant_expression '~' constant_expression // CFA, integer subrange
2794 { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild<Expression>( $1 ), maybeMoveBuild<Expression>( $3 ) ) ); }
2795 ;
2796
2797asm_name_opt: // GCC
2798 // empty
2799 { $$ = nullptr; }
2800 | ASM '(' string_literal ')' attribute_list_opt
2801 {
2802 DeclarationNode * name = new DeclarationNode();
2803 name->asmName = $3;
2804 $$ = name->addQualifiers( $5 );
2805 }
2806 ;
2807
2808attribute_list_opt: // GCC
2809 // empty
2810 { $$ = nullptr; }
2811 | attribute_list
2812 ;
2813
2814attribute_list: // GCC
2815 attribute
2816 | attribute_list attribute
2817 { $$ = $2->addQualifiers( $1 ); }
2818 ;
2819
2820attribute: // GCC
2821 ATTRIBUTE '(' '(' attribute_name_list ')' ')'
2822 { $$ = $4; }
2823 ;
2824
2825attribute_name_list: // GCC
2826 attribute_name
2827 | attribute_name_list ',' attribute_name
2828 { $$ = $3->addQualifiers( $1 ); }
2829 ;
2830
2831attribute_name: // GCC
2832 // empty
2833 { $$ = nullptr; }
2834 | attr_name
2835 { $$ = DeclarationNode::newAttribute( $1 ); }
2836 | attr_name '(' argument_expression_list_opt ')'
2837 { $$ = DeclarationNode::newAttribute( $1, $3 ); }
2838 ;
2839
2840attr_name: // GCC
2841 IDENTIFIER
2842 | quasi_keyword
2843 | TYPEDEFname
2844 | TYPEGENname
2845 | FALLTHROUGH
2846 { $$ = Token{ new string( "fallthrough" ), { nullptr, -1 } }; }
2847 | CONST
2848 { $$ = Token{ new string( "__const__" ), { nullptr, -1 } }; }
2849 ;
2850
2851// ============================================================================
2852// The following sections are a series of grammar patterns used to parse declarators. Multiple patterns are necessary
2853// because the type of an identifier in wrapped around the identifier in the same form as its usage in an expression, as
2854// in:
2855//
2856// int (*f())[10] { ... };
2857// ... (*f())[3] += 1; // definition mimics usage
2858//
2859// Because these patterns are highly recursive, changes at a lower level in the recursion require copying some or all of
2860// the pattern. Each of these patterns has some subtle variation to ensure correct syntax in a particular context.
2861// ============================================================================
2862
2863// ----------------------------------------------------------------------------
2864// The set of valid declarators before a compound statement for defining a function is less than the set of declarators
2865// to define a variable or function prototype, e.g.:
2866//
2867// valid declaration invalid definition
2868// ----------------- ------------------
2869// int f; int f {}
2870// int *f; int *f {}
2871// int f[10]; int f[10] {}
2872// int (*f)(int); int (*f)(int) {}
2873//
2874// To preclude this syntactic anomaly requires separating the grammar rules for variable and function declarators, hence
2875// variable_declarator and function_declarator.
2876// ----------------------------------------------------------------------------
2877
2878// This pattern parses a declaration of a variable that is not redefining a typedef name. The pattern precludes
2879// declaring an array of functions versus a pointer to an array of functions.
2880
2881paren_identifier:
2882 identifier
2883 { $$ = DeclarationNode::newName( $1 ); }
2884 | '(' paren_identifier ')' // redundant parenthesis
2885 { $$ = $2; }
2886 ;
2887
2888variable_declarator:
2889 paren_identifier attribute_list_opt
2890 { $$ = $1->addQualifiers( $2 ); }
2891 | variable_ptr
2892 | variable_array attribute_list_opt
2893 { $$ = $1->addQualifiers( $2 ); }
2894 | variable_function attribute_list_opt
2895 { $$ = $1->addQualifiers( $2 ); }
2896 ;
2897
2898variable_ptr:
2899 ptrref_operator variable_declarator
2900 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
2901 | ptrref_operator type_qualifier_list variable_declarator
2902 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
2903 | '(' variable_ptr ')' attribute_list_opt // redundant parenthesis
2904 { $$ = $2->addQualifiers( $4 ); }
2905 | '(' attribute_list variable_ptr ')' attribute_list_opt // redundant parenthesis
2906 { $$ = $3->addQualifiers( $2 )->addQualifiers( $5 ); }
2907 ;
2908
2909variable_array:
2910 paren_identifier array_dimension
2911 { $$ = $1->addArray( $2 ); }
2912 | '(' variable_ptr ')' array_dimension
2913 { $$ = $2->addArray( $4 ); }
2914 | '(' attribute_list variable_ptr ')' array_dimension
2915 { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
2916 | '(' variable_array ')' multi_array_dimension // redundant parenthesis
2917 { $$ = $2->addArray( $4 ); }
2918 | '(' attribute_list variable_array ')' multi_array_dimension // redundant parenthesis
2919 { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
2920 | '(' variable_array ')' // redundant parenthesis
2921 { $$ = $2; }
2922 | '(' attribute_list variable_array ')' // redundant parenthesis
2923 { $$ = $3->addQualifiers( $2 ); }
2924 ;
2925
2926variable_function:
2927 '(' variable_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
2928 { $$ = $2->addParamList( $6 ); }
2929 | '(' attribute_list variable_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
2930 { $$ = $3->addQualifiers( $2 )->addParamList( $7 ); }
2931 | '(' variable_function ')' // redundant parenthesis
2932 { $$ = $2; }
2933 | '(' attribute_list variable_function ')' // redundant parenthesis
2934 { $$ = $3->addQualifiers( $2 ); }
2935 ;
2936
2937// This pattern parses a function declarator that is not redefining a typedef name. For non-nested functions, there is
2938// no context where a function definition can redefine a typedef name, i.e., the typedef and function name cannot exist
2939// is the same scope. The pattern precludes returning arrays and functions versus pointers to arrays and functions.
2940
2941function_declarator:
2942 function_no_ptr attribute_list_opt
2943 { $$ = $1->addQualifiers( $2 ); }
2944 | function_ptr
2945 | function_array attribute_list_opt
2946 { $$ = $1->addQualifiers( $2 ); }
2947 ;
2948
2949function_no_ptr:
2950 paren_identifier '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
2951 { $$ = $1->addParamList( $4 ); }
2952 | '(' function_ptr ')' '(' push parameter_type_list_opt pop ')'
2953 { $$ = $2->addParamList( $6 ); }
2954 | '(' attribute_list function_ptr ')' '(' push parameter_type_list_opt pop ')'
2955 { $$ = $3->addQualifiers( $2 )->addParamList( $7 ); }
2956 | '(' function_no_ptr ')' // redundant parenthesis
2957 { $$ = $2; }
2958 | '(' attribute_list function_no_ptr ')' // redundant parenthesis
2959 { $$ = $3->addQualifiers( $2 ); }
2960 ;
2961
2962function_ptr:
2963 ptrref_operator function_declarator
2964 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
2965 | ptrref_operator type_qualifier_list function_declarator
2966 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
2967 | '(' function_ptr ')' attribute_list_opt
2968 { $$ = $2->addQualifiers( $4 ); }
2969 | '(' attribute_list function_ptr ')' attribute_list_opt
2970 { $$ = $3->addQualifiers( $2 )->addQualifiers( $5 ); }
2971 ;
2972
2973function_array:
2974 '(' function_ptr ')' array_dimension
2975 { $$ = $2->addArray( $4 ); }
2976 | '(' attribute_list function_ptr ')' array_dimension
2977 { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
2978 | '(' function_array ')' multi_array_dimension // redundant parenthesis
2979 { $$ = $2->addArray( $4 ); }
2980 | '(' attribute_list function_array ')' multi_array_dimension // redundant parenthesis
2981 { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
2982 | '(' function_array ')' // redundant parenthesis
2983 { $$ = $2; }
2984 | '(' attribute_list function_array ')' // redundant parenthesis
2985 { $$ = $3->addQualifiers( $2 ); }
2986 ;
2987
2988// This pattern parses an old-style K&R function declarator (OBSOLESCENT, see 4)
2989//
2990// f( a, b, c ) int a, *b, c[]; {}
2991//
2992// that is not redefining a typedef name (see function_declarator for additional comments). The pattern precludes
2993// returning arrays and functions versus pointers to arrays and functions.
2994
2995KR_function_declarator:
2996 KR_function_no_ptr
2997 | KR_function_ptr
2998 | KR_function_array
2999 ;
3000
3001KR_function_no_ptr:
3002 paren_identifier '(' identifier_list ')' // function_declarator handles empty parameter
3003 { $$ = $1->addIdList( $3 ); }
3004 | '(' KR_function_ptr ')' '(' push parameter_type_list_opt pop ')'
3005 { $$ = $2->addParamList( $6 ); }
3006 | '(' attribute_list KR_function_ptr ')' '(' push parameter_type_list_opt pop ')'
3007 { $$ = $3->addQualifiers( $2 )->addParamList( $7 ); }
3008 | '(' KR_function_no_ptr ')' // redundant parenthesis
3009 { $$ = $2; }
3010 | '(' attribute_list KR_function_no_ptr ')' // redundant parenthesis
3011 { $$ = $3->addQualifiers( $2 ); }
3012 ;
3013
3014KR_function_ptr:
3015 ptrref_operator KR_function_declarator
3016 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
3017 | ptrref_operator type_qualifier_list KR_function_declarator
3018 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
3019 | '(' KR_function_ptr ')'
3020 { $$ = $2; }
3021 | '(' attribute_list KR_function_ptr ')'
3022 { $$ = $3->addQualifiers( $2 ); }
3023 ;
3024
3025KR_function_array:
3026 '(' KR_function_ptr ')' array_dimension
3027 { $$ = $2->addArray( $4 ); }
3028 | '(' attribute_list KR_function_ptr ')' array_dimension
3029 { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
3030 | '(' KR_function_array ')' multi_array_dimension // redundant parenthesis
3031 { $$ = $2->addArray( $4 ); }
3032 | '(' attribute_list KR_function_array ')' multi_array_dimension // redundant parenthesis
3033 { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
3034 | '(' KR_function_array ')' // redundant parenthesis
3035 { $$ = $2; }
3036 | '(' attribute_list KR_function_array ')' // redundant parenthesis
3037 { $$ = $3->addQualifiers( $2 ); }
3038 ;
3039
3040// This pattern parses a declaration for a variable or function prototype that redefines a type name, e.g.:
3041//
3042// typedef int foo;
3043// {
3044// int foo; // redefine typedef name in new scope
3045// }
3046//
3047// The pattern precludes declaring an array of functions versus a pointer to an array of functions, and returning arrays
3048// and functions versus pointers to arrays and functions.
3049
3050paren_type:
3051 typedef_name
3052 {
3053 // hide type name in enclosing scope by variable name
3054 typedefTable.addToEnclosingScope( *$1->name, IDENTIFIER, "ID" );
3055 }
3056 | '(' paren_type ')'
3057 { $$ = $2; }
3058 ;
3059
3060variable_type_redeclarator:
3061 paren_type attribute_list_opt
3062 { $$ = $1->addQualifiers( $2 ); }
3063 | type_ptr
3064 | type_array attribute_list_opt
3065 { $$ = $1->addQualifiers( $2 ); }
3066 | type_function attribute_list_opt
3067 { $$ = $1->addQualifiers( $2 ); }
3068 ;
3069
3070type_ptr:
3071 ptrref_operator variable_type_redeclarator
3072 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
3073 | ptrref_operator type_qualifier_list variable_type_redeclarator
3074 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
3075 | '(' type_ptr ')' attribute_list_opt // redundant parenthesis
3076 { $$ = $2->addQualifiers( $4 ); }
3077 | '(' attribute_list type_ptr ')' attribute_list_opt // redundant parenthesis
3078 { $$ = $3->addQualifiers( $2 )->addQualifiers( $5 ); }
3079 ;
3080
3081type_array:
3082 paren_type array_dimension
3083 { $$ = $1->addArray( $2 ); }
3084 | '(' type_ptr ')' array_dimension
3085 { $$ = $2->addArray( $4 ); }
3086 | '(' attribute_list type_ptr ')' array_dimension
3087 { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
3088 | '(' type_array ')' multi_array_dimension // redundant parenthesis
3089 { $$ = $2->addArray( $4 ); }
3090 | '(' attribute_list type_array ')' multi_array_dimension // redundant parenthesis
3091 { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
3092 | '(' type_array ')' // redundant parenthesis
3093 { $$ = $2; }
3094 | '(' attribute_list type_array ')' // redundant parenthesis
3095 { $$ = $3->addQualifiers( $2 ); }
3096 ;
3097
3098type_function:
3099 paren_type '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
3100 { $$ = $1->addParamList( $4 ); }
3101 | '(' type_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
3102 { $$ = $2->addParamList( $6 ); }
3103 | '(' attribute_list type_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
3104 { $$ = $3->addQualifiers( $2 )->addParamList( $7 ); }
3105 | '(' type_function ')' // redundant parenthesis
3106 { $$ = $2; }
3107 | '(' attribute_list type_function ')' // redundant parenthesis
3108 { $$ = $3->addQualifiers( $2 ); }
3109 ;
3110
3111// This pattern parses a declaration for a parameter variable of a function prototype or actual that is not redefining a
3112// typedef name and allows the C99 array options, which can only appear in a parameter list. The pattern precludes
3113// declaring an array of functions versus a pointer to an array of functions, and returning arrays and functions versus
3114// pointers to arrays and functions.
3115
3116identifier_parameter_declarator:
3117 paren_identifier attribute_list_opt
3118 { $$ = $1->addQualifiers( $2 ); }
3119 | '&' MUTEX paren_identifier attribute_list_opt
3120 { $$ = $3->addPointer( DeclarationNode::newPointer( DeclarationNode::newTypeQualifier( Type::Mutex ), OperKinds::AddressOf ) )->addQualifiers( $4 ); }
3121 | identifier_parameter_ptr
3122 | identifier_parameter_array attribute_list_opt
3123 { $$ = $1->addQualifiers( $2 ); }
3124 | identifier_parameter_function attribute_list_opt
3125 { $$ = $1->addQualifiers( $2 ); }
3126 ;
3127
3128identifier_parameter_ptr:
3129 ptrref_operator identifier_parameter_declarator
3130 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
3131 | ptrref_operator type_qualifier_list identifier_parameter_declarator
3132 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
3133 | '(' identifier_parameter_ptr ')' attribute_list_opt // redundant parenthesis
3134 { $$ = $2->addQualifiers( $4 ); }
3135 ;
3136
3137identifier_parameter_array:
3138 paren_identifier array_parameter_dimension
3139 { $$ = $1->addArray( $2 ); }
3140 | '(' identifier_parameter_ptr ')' array_dimension
3141 { $$ = $2->addArray( $4 ); }
3142 | '(' identifier_parameter_array ')' multi_array_dimension // redundant parenthesis
3143 { $$ = $2->addArray( $4 ); }
3144 | '(' identifier_parameter_array ')' // redundant parenthesis
3145 { $$ = $2; }
3146 ;
3147
3148identifier_parameter_function:
3149 paren_identifier '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
3150 { $$ = $1->addParamList( $4 ); }
3151 | '(' identifier_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
3152 { $$ = $2->addParamList( $6 ); }
3153 | '(' identifier_parameter_function ')' // redundant parenthesis
3154 { $$ = $2; }
3155 ;
3156
3157// This pattern parses a declaration for a parameter variable or function prototype that is redefining a typedef name,
3158// e.g.:
3159//
3160// typedef int foo;
3161// forall( otype T ) struct foo;
3162// int f( int foo ); // redefine typedef name in new scope
3163//
3164// and allows the C99 array options, which can only appear in a parameter list.
3165
3166type_parameter_redeclarator:
3167 typedef_name attribute_list_opt
3168 { $$ = $1->addQualifiers( $2 ); }
3169 | '&' MUTEX typedef_name attribute_list_opt
3170 { $$ = $3->addPointer( DeclarationNode::newPointer( DeclarationNode::newTypeQualifier( Type::Mutex ), OperKinds::AddressOf ) )->addQualifiers( $4 ); }
3171 | type_parameter_ptr
3172 | type_parameter_array attribute_list_opt
3173 { $$ = $1->addQualifiers( $2 ); }
3174 | type_parameter_function attribute_list_opt
3175 { $$ = $1->addQualifiers( $2 ); }
3176 ;
3177
3178typedef_name:
3179 TYPEDEFname
3180 { $$ = DeclarationNode::newName( $1 ); }
3181 | TYPEGENname
3182 { $$ = DeclarationNode::newName( $1 ); }
3183 ;
3184
3185type_parameter_ptr:
3186 ptrref_operator type_parameter_redeclarator
3187 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
3188 | ptrref_operator type_qualifier_list type_parameter_redeclarator
3189 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
3190 | '(' type_parameter_ptr ')' attribute_list_opt // redundant parenthesis
3191 { $$ = $2->addQualifiers( $4 ); }
3192 ;
3193
3194type_parameter_array:
3195 typedef_name array_parameter_dimension
3196 { $$ = $1->addArray( $2 ); }
3197 | '(' type_parameter_ptr ')' array_parameter_dimension
3198 { $$ = $2->addArray( $4 ); }
3199 ;
3200
3201type_parameter_function:
3202 typedef_name '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
3203 { $$ = $1->addParamList( $4 ); }
3204 | '(' type_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
3205 { $$ = $2->addParamList( $6 ); }
3206 ;
3207
3208// This pattern parses a declaration of an abstract variable or function prototype, i.e., there is no identifier to
3209// which the type applies, e.g.:
3210//
3211// sizeof( int );
3212// sizeof( int * );
3213// sizeof( int [10] );
3214// sizeof( int (*)() );
3215// sizeof( int () );
3216//
3217// The pattern precludes declaring an array of functions versus a pointer to an array of functions, and returning arrays
3218// and functions versus pointers to arrays and functions.
3219
3220abstract_declarator:
3221 abstract_ptr
3222 | abstract_array attribute_list_opt
3223 { $$ = $1->addQualifiers( $2 ); }
3224 | abstract_function attribute_list_opt
3225 { $$ = $1->addQualifiers( $2 ); }
3226 ;
3227
3228abstract_ptr:
3229 ptrref_operator
3230 { $$ = DeclarationNode::newPointer( 0, $1 ); }
3231 | ptrref_operator type_qualifier_list
3232 { $$ = DeclarationNode::newPointer( $2, $1 ); }
3233 | ptrref_operator abstract_declarator
3234 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
3235 | ptrref_operator type_qualifier_list abstract_declarator
3236 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
3237 | '(' abstract_ptr ')' attribute_list_opt
3238 { $$ = $2->addQualifiers( $4 ); }
3239 ;
3240
3241abstract_array:
3242 array_dimension
3243 | '(' abstract_ptr ')' array_dimension
3244 { $$ = $2->addArray( $4 ); }
3245 | '(' abstract_array ')' multi_array_dimension // redundant parenthesis
3246 { $$ = $2->addArray( $4 ); }
3247 | '(' abstract_array ')' // redundant parenthesis
3248 { $$ = $2; }
3249 ;
3250
3251abstract_function:
3252 '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
3253 { $$ = DeclarationNode::newFunction( nullptr, nullptr, $3, nullptr ); }
3254 | '(' abstract_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
3255 { $$ = $2->addParamList( $6 ); }
3256 | '(' abstract_function ')' // redundant parenthesis
3257 { $$ = $2; }
3258 ;
3259
3260array_dimension:
3261 // Only the first dimension can be empty.
3262 '[' ']'
3263 { $$ = DeclarationNode::newArray( 0, 0, false ); }
3264 | '[' ']' multi_array_dimension
3265 { $$ = DeclarationNode::newArray( 0, 0, false )->addArray( $3 ); }
3266 | '[' push assignment_expression pop ',' comma_expression ']'
3267 { $$ = DeclarationNode::newArray( $3, 0, false )->addArray( DeclarationNode::newArray( $6, 0, false ) ); }
3268 // { SemanticError( yylloc, "New array dimension is currently unimplemented." ); $$ = nullptr; }
3269 | multi_array_dimension
3270 ;
3271
3272multi_array_dimension:
3273 '[' push assignment_expression pop ']'
3274 { $$ = DeclarationNode::newArray( $3, 0, false ); }
3275 | '[' push '*' pop ']' // C99
3276 { $$ = DeclarationNode::newVarArray( 0 ); }
3277 | multi_array_dimension '[' push assignment_expression pop ']'
3278 { $$ = $1->addArray( DeclarationNode::newArray( $4, 0, false ) ); }
3279 | multi_array_dimension '[' push '*' pop ']' // C99
3280 { $$ = $1->addArray( DeclarationNode::newVarArray( 0 ) ); }
3281 ;
3282
3283// This pattern parses a declaration of a parameter abstract variable or function prototype, i.e., there is no
3284// identifier to which the type applies, e.g.:
3285//
3286// int f( int ); // not handled here
3287// int f( int * ); // abstract function-prototype parameter; no parameter name specified
3288// int f( int (*)() ); // abstract function-prototype parameter; no parameter name specified
3289// int f( int (int) ); // abstract function-prototype parameter; no parameter name specified
3290//
3291// The pattern precludes declaring an array of functions versus a pointer to an array of functions, and returning arrays
3292// and functions versus pointers to arrays and functions. In addition, the pattern handles the
3293// special meaning of parenthesis around a typedef name:
3294//
3295// ISO/IEC 9899:1999 Section 6.7.5.3(11) : "In a parameter declaration, a single typedef name in
3296// parentheses is taken to be an abstract declarator that specifies a function with a single parameter,
3297// not as redundant parentheses around the identifier."
3298//
3299// For example:
3300//
3301// typedef float T;
3302// int f( int ( T [5] ) ); // see abstract_parameter_declarator
3303// int g( int ( T ( int ) ) ); // see abstract_parameter_declarator
3304// int f( int f1( T a[5] ) ); // see identifier_parameter_declarator
3305// int g( int g1( T g2( int p ) ) ); // see identifier_parameter_declarator
3306//
3307// In essence, a '(' immediately to the left of typedef name, T, is interpreted as starting a parameter type list, and
3308// not as redundant parentheses around a redeclaration of T. Finally, the pattern also precludes declaring an array of
3309// functions versus a pointer to an array of functions, and returning arrays and functions versus pointers to arrays and
3310// functions.
3311
3312abstract_parameter_declarator:
3313 abstract_parameter_ptr
3314 | '&' MUTEX attribute_list_opt
3315 { $$ = DeclarationNode::newPointer( DeclarationNode::newTypeQualifier( Type::Mutex ), OperKinds::AddressOf )->addQualifiers( $3 ); }
3316 | abstract_parameter_array attribute_list_opt
3317 { $$ = $1->addQualifiers( $2 ); }
3318 | abstract_parameter_function attribute_list_opt
3319 { $$ = $1->addQualifiers( $2 ); }
3320 ;
3321
3322abstract_parameter_ptr:
3323 ptrref_operator
3324 { $$ = DeclarationNode::newPointer( nullptr, $1 ); }
3325 | ptrref_operator type_qualifier_list
3326 { $$ = DeclarationNode::newPointer( $2, $1 ); }
3327 | ptrref_operator abstract_parameter_declarator
3328 { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
3329 | ptrref_operator type_qualifier_list abstract_parameter_declarator
3330 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
3331 | '(' abstract_parameter_ptr ')' attribute_list_opt // redundant parenthesis
3332 { $$ = $2->addQualifiers( $4 ); }
3333 ;
3334
3335abstract_parameter_array:
3336 array_parameter_dimension
3337 | '(' abstract_parameter_ptr ')' array_parameter_dimension
3338 { $$ = $2->addArray( $4 ); }
3339 | '(' abstract_parameter_array ')' multi_array_dimension // redundant parenthesis
3340 { $$ = $2->addArray( $4 ); }
3341 | '(' abstract_parameter_array ')' // redundant parenthesis
3342 { $$ = $2; }
3343 ;
3344
3345abstract_parameter_function:
3346 '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
3347 { $$ = DeclarationNode::newFunction( nullptr, nullptr, $3, nullptr ); }
3348 | '(' abstract_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
3349 { $$ = $2->addParamList( $6 ); }
3350 | '(' abstract_parameter_function ')' // redundant parenthesis
3351 { $$ = $2; }
3352 ;
3353
3354array_parameter_dimension:
3355 // Only the first dimension can be empty or have qualifiers.
3356 array_parameter_1st_dimension
3357 | array_parameter_1st_dimension multi_array_dimension
3358 { $$ = $1->addArray( $2 ); }
3359 | multi_array_dimension
3360 ;
3361
3362// The declaration of an array parameter has additional syntax over arrays in normal variable declarations:
3363//
3364// ISO/IEC 9899:1999 Section 6.7.5.2(1) : "The optional type qualifiers and the keyword static shall appear only in
3365// a declaration of a function parameter with an array type, and then only in the outermost array type derivation."
3366
3367array_parameter_1st_dimension:
3368 '[' ']'
3369 { $$ = DeclarationNode::newArray( 0, 0, false ); }
3370 // multi_array_dimension handles the '[' '*' ']' case
3371 | '[' push type_qualifier_list '*' pop ']' // remaining C99
3372 { $$ = DeclarationNode::newVarArray( $3 ); }
3373 | '[' push type_qualifier_list pop ']'
3374 { $$ = DeclarationNode::newArray( 0, $3, false ); }
3375 // multi_array_dimension handles the '[' assignment_expression ']' case
3376 | '[' push type_qualifier_list assignment_expression pop ']'
3377 { $$ = DeclarationNode::newArray( $4, $3, false ); }
3378 | '[' push STATIC type_qualifier_list_opt assignment_expression pop ']'
3379 { $$ = DeclarationNode::newArray( $5, $4, true ); }
3380 | '[' push type_qualifier_list STATIC assignment_expression pop ']'
3381 { $$ = DeclarationNode::newArray( $5, $3, true ); }
3382 ;
3383
3384// This pattern parses a declaration of an abstract variable, but does not allow "int ()" for a function pointer.
3385//
3386// struct S {
3387// int;
3388// int *;
3389// int [10];
3390// int (*)();
3391// };
3392
3393variable_abstract_declarator:
3394 variable_abstract_ptr
3395 | variable_abstract_array attribute_list_opt
3396 { $$ = $1->addQualifiers( $2 ); }
3397 | variable_abstract_function attribute_list_opt
3398 { $$ = $1->addQualifiers( $2 ); }
3399 ;
3400
3401variable_abstract_ptr:
3402 ptrref_operator
3403 { $$ = DeclarationNode::newPointer( 0, $1 ); }
3404 | ptrref_operator type_qualifier_list
3405 { $$ = DeclarationNode::newPointer( $2, $1 ); }
3406 | ptrref_operator variable_abstract_declarator
3407 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
3408 | ptrref_operator type_qualifier_list variable_abstract_declarator
3409 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
3410 | '(' variable_abstract_ptr ')' attribute_list_opt // redundant parenthesis
3411 { $$ = $2->addQualifiers( $4 ); }
3412 ;
3413
3414variable_abstract_array:
3415 array_dimension
3416 | '(' variable_abstract_ptr ')' array_dimension
3417 { $$ = $2->addArray( $4 ); }
3418 | '(' variable_abstract_array ')' multi_array_dimension // redundant parenthesis
3419 { $$ = $2->addArray( $4 ); }
3420 | '(' variable_abstract_array ')' // redundant parenthesis
3421 { $$ = $2; }
3422 ;
3423
3424variable_abstract_function:
3425 '(' variable_abstract_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
3426 { $$ = $2->addParamList( $6 ); }
3427 | '(' variable_abstract_function ')' // redundant parenthesis
3428 { $$ = $2; }
3429 ;
3430
3431// This pattern parses a new-style declaration for a parameter variable or function prototype that is either an
3432// identifier or typedef name and allows the C99 array options, which can only appear in a parameter list.
3433
3434cfa_identifier_parameter_declarator_tuple: // CFA
3435 cfa_identifier_parameter_declarator_no_tuple
3436 | cfa_abstract_tuple
3437 | type_qualifier_list cfa_abstract_tuple
3438 { $$ = $2->addQualifiers( $1 ); }
3439 ;
3440
3441cfa_identifier_parameter_declarator_no_tuple: // CFA
3442 cfa_identifier_parameter_ptr
3443 | cfa_identifier_parameter_array
3444 ;
3445
3446cfa_identifier_parameter_ptr: // CFA
3447 // No SUE declaration in parameter list.
3448 ptrref_operator type_specifier_nobody
3449 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
3450 | type_qualifier_list ptrref_operator type_specifier_nobody
3451 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
3452 | ptrref_operator cfa_abstract_function
3453 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
3454 | type_qualifier_list ptrref_operator cfa_abstract_function
3455 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
3456 | ptrref_operator cfa_identifier_parameter_declarator_tuple
3457 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
3458 | type_qualifier_list ptrref_operator cfa_identifier_parameter_declarator_tuple
3459 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
3460 ;
3461
3462cfa_identifier_parameter_array: // CFA
3463 // Only the first dimension can be empty or have qualifiers. Empty dimension must be factored out due to
3464 // shift/reduce conflict with new-style empty (void) function return type.
3465 '[' ']' type_specifier_nobody
3466 { $$ = $3->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
3467 | cfa_array_parameter_1st_dimension type_specifier_nobody
3468 { $$ = $2->addNewArray( $1 ); }
3469 | '[' ']' multi_array_dimension type_specifier_nobody
3470 { $$ = $4->addNewArray( $3 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
3471 | cfa_array_parameter_1st_dimension multi_array_dimension type_specifier_nobody
3472 { $$ = $3->addNewArray( $2 )->addNewArray( $1 ); }
3473 | multi_array_dimension type_specifier_nobody
3474 { $$ = $2->addNewArray( $1 ); }
3475
3476 | '[' ']' cfa_identifier_parameter_ptr
3477 { $$ = $3->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
3478 | cfa_array_parameter_1st_dimension cfa_identifier_parameter_ptr
3479 { $$ = $2->addNewArray( $1 ); }
3480 | '[' ']' multi_array_dimension cfa_identifier_parameter_ptr
3481 { $$ = $4->addNewArray( $3 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
3482 | cfa_array_parameter_1st_dimension multi_array_dimension cfa_identifier_parameter_ptr
3483 { $$ = $3->addNewArray( $2 )->addNewArray( $1 ); }
3484 | multi_array_dimension cfa_identifier_parameter_ptr
3485 { $$ = $2->addNewArray( $1 ); }
3486 ;
3487
3488cfa_array_parameter_1st_dimension:
3489 '[' push type_qualifier_list '*' pop ']' // remaining C99
3490 { $$ = DeclarationNode::newVarArray( $3 ); }
3491 | '[' push type_qualifier_list assignment_expression pop ']'
3492 { $$ = DeclarationNode::newArray( $4, $3, false ); }
3493 | '[' push declaration_qualifier_list assignment_expression pop ']'
3494 // declaration_qualifier_list must be used because of shift/reduce conflict with
3495 // assignment_expression, so a semantic check is necessary to preclude them as a type_qualifier cannot
3496 // appear in this context.
3497 { $$ = DeclarationNode::newArray( $4, $3, true ); }
3498 | '[' push declaration_qualifier_list type_qualifier_list assignment_expression pop ']'
3499 { $$ = DeclarationNode::newArray( $5, $4->addQualifiers( $3 ), true ); }
3500 ;
3501
3502// This pattern parses a new-style declaration of an abstract variable or function prototype, i.e., there is no
3503// identifier to which the type applies, e.g.:
3504//
3505// [int] f( int ); // abstract variable parameter; no parameter name specified
3506// [int] f( [int] (int) ); // abstract function-prototype parameter; no parameter name specified
3507//
3508// These rules need LR(3):
3509//
3510// cfa_abstract_tuple identifier_or_type_name
3511// '[' cfa_parameter_list ']' identifier_or_type_name '(' cfa_parameter_ellipsis_list_opt ')'
3512//
3513// since a function return type can be syntactically identical to a tuple type:
3514//
3515// [int, int] t;
3516// [int, int] f( int );
3517//
3518// Therefore, it is necessary to look at the token after identifier_or_type_name to know when to reduce
3519// cfa_abstract_tuple. To make this LR(1), several rules have to be flattened (lengthened) to allow the necessary
3520// lookahead. To accomplish this, cfa_abstract_declarator has an entry point without tuple, and tuple declarations are
3521// duplicated when appearing with cfa_function_specifier.
3522
3523cfa_abstract_declarator_tuple: // CFA
3524 cfa_abstract_tuple
3525 | type_qualifier_list cfa_abstract_tuple
3526 { $$ = $2->addQualifiers( $1 ); }
3527 | cfa_abstract_declarator_no_tuple
3528 ;
3529
3530cfa_abstract_declarator_no_tuple: // CFA
3531 cfa_abstract_ptr
3532 | cfa_abstract_array
3533 ;
3534
3535cfa_abstract_ptr: // CFA
3536 ptrref_operator type_specifier
3537 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
3538 | type_qualifier_list ptrref_operator type_specifier
3539 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
3540 | ptrref_operator cfa_abstract_function
3541 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
3542 | type_qualifier_list ptrref_operator cfa_abstract_function
3543 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
3544 | ptrref_operator cfa_abstract_declarator_tuple
3545 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
3546 | type_qualifier_list ptrref_operator cfa_abstract_declarator_tuple
3547 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
3548 ;
3549
3550cfa_abstract_array: // CFA
3551 // Only the first dimension can be empty. Empty dimension must be factored out due to shift/reduce conflict with
3552 // empty (void) function return type.
3553 '[' ']' type_specifier
3554 { $$ = $3->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
3555 | '[' ']' multi_array_dimension type_specifier
3556 { $$ = $4->addNewArray( $3 )->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
3557 | multi_array_dimension type_specifier
3558 { $$ = $2->addNewArray( $1 ); }
3559 | '[' ']' cfa_abstract_ptr
3560 { $$ = $3->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
3561 | '[' ']' multi_array_dimension cfa_abstract_ptr
3562 { $$ = $4->addNewArray( $3 )->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
3563 | multi_array_dimension cfa_abstract_ptr
3564 { $$ = $2->addNewArray( $1 ); }
3565 ;
3566
3567cfa_abstract_tuple: // CFA
3568 '[' push cfa_abstract_parameter_list pop ']'
3569 { $$ = DeclarationNode::newTuple( $3 ); }
3570 | '[' push type_specifier_nobody ELLIPSIS pop ']'
3571 { SemanticError( yylloc, "Tuple array currently unimplemented." ); $$ = nullptr; }
3572 | '[' push type_specifier_nobody ELLIPSIS constant_expression pop ']'
3573 { SemanticError( yylloc, "Tuple array currently unimplemented." ); $$ = nullptr; }
3574 ;
3575
3576cfa_abstract_function: // CFA
3577// '[' ']' '(' cfa_parameter_ellipsis_list_opt ')'
3578// { $$ = DeclarationNode::newFunction( nullptr, DeclarationNode::newTuple( nullptr ), $4, nullptr ); }
3579 cfa_abstract_tuple '(' push cfa_parameter_ellipsis_list_opt pop ')'
3580 { $$ = DeclarationNode::newFunction( nullptr, $1, $4, nullptr ); }
3581 | cfa_function_return '(' push cfa_parameter_ellipsis_list_opt pop ')'
3582 { $$ = DeclarationNode::newFunction( nullptr, $1, $4, nullptr ); }
3583 ;
3584
3585// 1) ISO/IEC 9899:1999 Section 6.7.2(2) : "At least one type specifier shall be given in the declaration specifiers in
3586// each declaration, and in the specifier-qualifier list in each structure declaration and type name."
3587//
3588// 2) ISO/IEC 9899:1999 Section 6.11.5(1) : "The placement of a storage-class specifier other than at the beginning of
3589// the declaration specifiers in a declaration is an obsolescent feature."
3590//
3591// 3) ISO/IEC 9899:1999 Section 6.11.6(1) : "The use of function declarators with empty parentheses (not
3592// prototype-format parameter type declarators) is an obsolescent feature."
3593//
3594// 4) ISO/IEC 9899:1999 Section 6.11.7(1) : "The use of function definitions with separate parameter identifier and
3595// declaration lists (not prototype-format parameter type and identifier declarators) is an obsolescent feature.
3596
3597//************************* MISCELLANEOUS ********************************
3598
3599comma_opt: // redundant comma
3600 // empty
3601 | ','
3602 ;
3603
3604default_initializer_opt:
3605 // empty
3606 { $$ = nullptr; }
3607 | '=' assignment_expression
3608 { $$ = $2; }
3609 ;
3610
3611%%
3612
3613// ----end of grammar----
3614
3615// Local Variables: //
3616// mode: c++ //
3617// tab-width: 4 //
3618// compile-command: "make install" //
3619// End: //
Note: See TracBrowser for help on using the repository browser.