GCC Code Coverage Report

Directory: src/
File: src/frontend/gyoji.y
Date: 2025-10-15 09:43:47
Exec Total Coverage
Lines: 893 983 90.8%
Functions: 1 1 100.0%
Branches: 7 14 50.0%
Line Branch Exec Source
1 %{
2 #include <iostream>
3 #include <string>
4 #include <cmath>
5 #include <memory>
6 #include <gyoji.l.hpp>
7 #include <gyoji-frontend.hpp>
8 #include <gyoji-misc/jstring.hpp>
9
10 using namespace Gyoji::context;
11 using namespace Gyoji::frontend::namespaces;
12
13 %}
14
15 %require "3.7.4"
16 %language "C++"
17
18 %define api.parser.class {YaccParser}
19 %define api.namespace {Gyoji::frontend::yacc}
20 %define api.value.type variant
21 %param {yyscan_t scanner}
22 %define parse.error verbose
23
24 %code provides
25 {
26 #define DEBUG_NONTERMINALS 0
27 #if DEBUG_NONTERMINALS
28 #define PRINT_NONTERMINALS(s) printf("%s\n", s->get_syntax_node()->get_type().c_str())
29 #else
30 #define PRINT_NONTERMINALS(s) /**/
31 #endif
32
33 #define YY_DECL \
34 int yylex(Gyoji::frontend::yacc::YaccParser::semantic_type *yylval, yyscan_t yyscanner)
35 YY_DECL;
36 }
37
38 %token INVALID_INPUT
39 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> YYEOF
40 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> IDENTIFIER
41 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> NAMESPACE_NAME
42 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> TYPE_NAME
43 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> CLASS
44 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> ENUM
45
46 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> NAMESPACE
47 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> AS
48 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> USING
49 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> TYPEDEF
50 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> STRUCT
51 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> UNION
52 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> SIZEOF
53 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> TYPEOF
54 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> CAST
55 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> UNSAFE
56 //%token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> VAR
57 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> CONST
58 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> VOLATILE
59
60 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> PUBLIC
61 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> PRIVATE
62 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> PROTECTED
63
64 /* Logical Operations */
65 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> LOGICAL_NOT
66 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> LOGICAL_AND
67 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> LOGICAL_OR
68
69 /* Control Flow */
70 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> RETURN
71 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> IF
72 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> ELSE
73 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> WHILE
74 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> FOR
75 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> CONTINUE
76 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> GOTO
77 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> LABEL
78 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> BREAK
79 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> SWITCH
80 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> CASE
81 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> DEFAULT
82
83 /* Binary operations */
84 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> PLUS
85 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> MINUS
86 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> SLASH
87 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> PERCENT
88 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> STAR
89 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> ASSIGNMENT
90 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> BANG
91 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> TILDE
92 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> ANDPERSAND
93 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> MUL_ASSIGNMENT
94 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> DIV_ASSIGNMENT
95 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> MOD_ASSIGNMENT
96 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> ADD_ASSIGNMENT
97 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> SUB_ASSIGNMENT
98 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> LEFT_ASSIGNMENT
99 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> RIGHT_ASSIGNMENT
100 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> AND_ASSIGNMENT
101 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> XOR_ASSIGNMENT
102 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> OR_ASSIGNMENT
103
104 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> LITERAL_CHAR
105 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> LITERAL_FLOAT
106 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> LITERAL_INT
107 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> LITERAL_STRING
108 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> LITERAL_BOOL
109 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> LITERAL_NULL
110
111 %token NST_COMMENT_MULTILINE
112 %token NST_COMMENT_SINGLE_LINE
113 %token NST_WHITESPACE
114 %token NST_FILE_METADATA
115
116 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> COMPARE_LESS
117 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> COMPARE_GREATER
118 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> COMPARE_LESS_EQUAL
119 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> COMPARE_GREATER_EQUAL
120 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> COMPARE_NOT_EQUAL
121 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> COMPARE_EQUAL
122
123 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> XOR_OP
124 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> AND_OP
125 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> PIPE
126 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> OR_OP
127 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> LEFT_OP
128 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> RIGHT_OP
129
130 /* Common punctuation */
131 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> COMMA
132 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> INC_OP
133 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> DEC_OP
134 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> PTR_OP
135 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> DOT
136 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> PAREN_L
137 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> PAREN_R
138 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> BRACE_L
139 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> BRACKET_R
140 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> BRACKET_L
141 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> BRACE_R
142 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> SEMICOLON
143 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> COLON
144 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> QUESTIONMARK
145
146 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> PREC_FIRST
147 %token <Gyoji::owned<Gyoji::frontend::tree::Terminal>> PREC_SECOND
148
149 %nterm <Gyoji::owned<Gyoji::frontend::tree::TranslationUnit>> translation_unit;
150
151 %nterm <Gyoji::owned<Gyoji::frontend::tree::FileStatementList>> opt_file_statement_list;
152 %nterm <Gyoji::owned<Gyoji::frontend::tree::FileStatementList>> file_statement_list;
153 %nterm <Gyoji::owned<Gyoji::frontend::tree::FileStatement>> file_statement;
154 %nterm <Gyoji::owned<Gyoji::frontend::tree::FileStatementFunctionDeclStart>> function_decl_start;
155 %nterm <Gyoji::owned<Gyoji::frontend::tree::FileStatementFunctionDefinition>> file_statement_function_definition;
156 %nterm <Gyoji::owned<Gyoji::frontend::tree::FileStatementFunctionDeclaration>> file_statement_function_declaration;
157 %nterm <Gyoji::owned<Gyoji::frontend::tree::TypeDefinition>> type_definition;
158 %nterm <Gyoji::owned<Gyoji::frontend::tree::ClassDefinition>> class_definition;
159 %nterm <Gyoji::owned<Gyoji::frontend::tree::ClassDeclaration>> class_declaration;
160 %nterm <Gyoji::owned<Gyoji::frontend::tree::ClassDeclStart>> class_decl_start;
161 %nterm <Gyoji::owned<Gyoji::frontend::tree::ClassArgumentList>> opt_class_argument_list;
162 %nterm <Gyoji::owned<Gyoji::frontend::tree::ClassArgumentList>> class_argument_list;
163
164
165 %nterm <Gyoji::owned<Gyoji::frontend::tree::EnumDefinition>> enum_definition;
166 %nterm <Gyoji::owned<Gyoji::frontend::tree::EnumDefinitionValueList>> opt_enum_value_list;
167 %nterm <Gyoji::owned<Gyoji::frontend::tree::EnumDefinitionValueList>> enum_value_list;
168 %nterm <Gyoji::owned<Gyoji::frontend::tree::EnumDefinitionValue>> enum_value;
169
170 %nterm <Gyoji::owned<Gyoji::frontend::tree::UnsafeModifier>> opt_unsafe
171 %nterm <Gyoji::owned<Gyoji::frontend::tree::NamespaceDeclaration>> namespace_declaration;
172 %nterm <Gyoji::owned<Gyoji::frontend::tree::FileStatementNamespace>> file_statement_namespace;
173 %nterm <Gyoji::owned<Gyoji::frontend::tree::UsingAs>> opt_as;
174 %nterm <Gyoji::owned<Gyoji::frontend::tree::FileStatementUsing>> file_statement_using;
175 %nterm <Gyoji::owned<Gyoji::frontend::tree::FileStatementGlobalDefinition>> file_statement_global_definition;
176 %nterm <Gyoji::owned<Gyoji::frontend::tree::GlobalInitializer>> opt_global_initializer;
177
178 %nterm <Gyoji::owned<Gyoji::frontend::tree::GlobalInitializerExpressionPrimary>> global_initializer_expression_primary;
179 %nterm <Gyoji::owned<Gyoji::frontend::tree::GlobalInitializerAddressofExpressionPrimary>> global_initializer_addressof_expression_primary;
180 %nterm <Gyoji::owned<Gyoji::frontend::tree::GlobalInitializerStructInitializerList>> global_initializer_struct_initializer_list;
181 %nterm <Gyoji::owned<Gyoji::frontend::tree::GlobalInitializer>> global_initializer;
182 %nterm <Gyoji::owned<Gyoji::frontend::tree::StructInitializerList>> opt_struct_initializer_list;
183 %nterm <Gyoji::owned<Gyoji::frontend::tree::StructInitializerList>> struct_initializer_list;
184 %nterm <Gyoji::owned<Gyoji::frontend::tree::StructInitializer>> struct_initializer;
185
186 %nterm <Gyoji::owned<Gyoji::frontend::tree::AccessModifier>> opt_access_modifier;
187 %nterm <Gyoji::owned<Gyoji::frontend::tree::Terminal>> access_modifier;
188
189 %nterm <Gyoji::owned<Gyoji::frontend::tree::ScopeBody>> scope_body;
190 %nterm <Gyoji::owned<Gyoji::frontend::tree::StatementList>> statement_list;
191 %nterm <Gyoji::owned<Gyoji::frontend::tree::Statement>> statement;
192 %nterm <Gyoji::owned<Gyoji::frontend::tree::StatementVariableDeclaration>> statement_variable_declaration;
193 %nterm <Gyoji::owned<Gyoji::frontend::tree::StatementBlock>> statement_block;
194 %nterm <Gyoji::owned<Gyoji::frontend::tree::StatementExpression>> statement_expression;
195 %nterm <Gyoji::owned<Gyoji::frontend::tree::StatementIfElse>> statement_ifelse;
196 %nterm <Gyoji::owned<Gyoji::frontend::tree::StatementWhile>> statement_while;
197 %nterm <Gyoji::owned<Gyoji::frontend::tree::StatementFor>> statement_for;
198 %nterm <Gyoji::owned<Gyoji::frontend::tree::StatementSwitch>> statement_switch;
199 %nterm <Gyoji::owned<Gyoji::frontend::tree::StatementLabel>> statement_label;
200 %nterm <Gyoji::owned<Gyoji::frontend::tree::StatementGoto>> statement_goto;
201 %nterm <Gyoji::owned<Gyoji::frontend::tree::StatementBreak>> statement_break;
202 %nterm <Gyoji::owned<Gyoji::frontend::tree::StatementContinue>> statement_continue;
203 %nterm <Gyoji::owned<Gyoji::frontend::tree::StatementReturn>> statement_return;
204
205 %nterm <Gyoji::owned<Gyoji::frontend::tree::StatementSwitchBlock>> statement_switch_block;
206 %nterm <Gyoji::owned<Gyoji::frontend::tree::StatementSwitchContent>> statement_switch_content;
207 %nterm <Gyoji::owned<Gyoji::frontend::tree::StatementSwitchContent>> opt_statement_switch_content;
208
209 %nterm <Gyoji::owned<Gyoji::frontend::tree::FunctionDefinitionArgList>> opt_function_definition_arg_list;
210 %nterm <Gyoji::owned<Gyoji::frontend::tree::FunctionDefinitionArgList>> function_definition_arg_list;
211 %nterm <Gyoji::owned<Gyoji::frontend::tree::FunctionDefinitionArg>> function_definition_arg
212
213 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_primary;
214 %nterm <Gyoji::owned<Gyoji::frontend::tree::ExpressionPrimaryNested>> expression_primary_nested;
215 %nterm <Gyoji::owned<Gyoji::frontend::tree::ExpressionPrimaryIdentifier>> expression_primary_identifier;
216 %nterm <Gyoji::owned<Gyoji::frontend::tree::ExpressionPrimaryLiteralInt>> expression_primary_literal_int;
217 %nterm <Gyoji::owned<Gyoji::frontend::tree::ExpressionPrimaryLiteralChar>> expression_primary_literal_char;
218 %nterm <Gyoji::owned<Gyoji::frontend::tree::ExpressionPrimaryLiteralString>> expression_primary_literal_string;
219 %nterm <Gyoji::owned<Gyoji::frontend::tree::ExpressionPrimaryLiteralFloat>> expression_primary_literal_float;
220 %nterm <Gyoji::owned<Gyoji::frontend::tree::ExpressionPrimaryLiteralBool>> expression_primary_literal_bool;
221 %nterm <Gyoji::owned<Gyoji::frontend::tree::ExpressionPrimaryLiteralNull>> expression_primary_literal_null;
222
223 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_postfix;
224 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_postfix_primary;
225 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_postfix_arrayindex;
226 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_postfix_function_call;
227 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_postfix_dot;
228 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_postfix_arrow;
229 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_postfix_increment;
230 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_postfix_decrement;
231
232 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_unary;
233 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_unary_increment;
234 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_unary_decrement;
235 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_unary_prefix;
236 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_unary_sizeof_type;
237
238 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_cast;
239 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_cast_unary;
240 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_cast_cast;
241
242 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_multiplicative;
243 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_multiplicative_cast;
244 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_multiplicative_multiply;
245 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_multiplicative_divide;
246 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_multiplicative_modulo;
247
248 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_additive;
249 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_additive_multiplicative;
250 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_additive_plus;
251 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_additive_minus;
252
253 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_shift;
254 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_shift_additive;
255 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_shift_left;
256 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_shift_right;
257
258 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_relational;
259 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_relational_shift;
260 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_relational_gt;
261 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_relational_lt;
262 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_relational_le;
263 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_relational_ge;
264
265 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_equality;
266 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_and;
267 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_exclusive_or;
268 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_inclusive_or;
269 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_logical_and;
270 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_logical_or;
271
272 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_conditional;
273 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression_assignment;
274
275 %nterm <Gyoji::owned<Gyoji::frontend::tree::InitializerExpression>> initializer_expression;
276
277 %nterm <Gyoji::owned<Gyoji::frontend::tree::TypeSpecifier>> type_specifier;
278 %nterm <Gyoji::owned<Gyoji::frontend::tree::TypeSpecifierCallArgs>> type_specifier_call_args;
279 %nterm <Gyoji::owned<Gyoji::frontend::tree::TypeName>> type_name;
280 %nterm <Gyoji::owned<Gyoji::frontend::tree::AccessQualifier>> type_access_qualifier;
281
282 %nterm <Gyoji::owned<Gyoji::frontend::tree::ClassMemberDeclarationList>> opt_class_member_declaration_list;
283 %nterm <Gyoji::owned<Gyoji::frontend::tree::ClassMemberDeclarationList>> class_member_declaration_list;
284 %nterm <Gyoji::owned<Gyoji::frontend::tree::ClassMemberDeclaration>> class_member_declaration;
285
286 %nterm <
287 std::pair<
288 Gyoji::frontend::tree::ExpressionUnaryPrefix::OperationType,
289 Gyoji::owned<Gyoji::frontend::tree::Terminal>
290 >
291 > operator_unary;
292 %nterm <
293 std::pair<
294 Gyoji::frontend::tree::ExpressionBinary::OperationType,
295 Gyoji::owned<Gyoji::frontend::tree::Terminal>
296 >
297 > operator_assignment;
298 %nterm <Gyoji::owned<Gyoji::frontend::tree::ArgumentExpressionList>> opt_argument_expression_list;
299 %nterm <Gyoji::owned<Gyoji::frontend::tree::ArgumentExpressionList>> argument_expression_list;
300
301 %nterm <Gyoji::owned<Gyoji::frontend::tree::Expression>> expression;
302
303 %parse-param {Gyoji::frontend::ParseResult & return_data}
304
305 %code
306 {
307
308 } // %code
309
310 %%
311
312 /*** Rules Section ***/
313 translation_unit
314 : opt_file_statement_list YYEOF {
315 240 $$ = std::make_unique<Gyoji::frontend::tree::TranslationUnit>(std::move($1), std::move($2));
316 PRINT_NONTERMINALS($$);
317 240 return_data.set_translation_unit(std::move($$));
318 }
319 ;
320
321 opt_file_statement_list
322 : /**/ YYEOF {
323 18 $$ = std::make_unique<Gyoji::frontend::tree::FileStatementList>(std::move($1));
324 PRINT_NONTERMINALS($$);
325 }
326 | file_statement_list {
327 340 $$ = std::move($1);
328 PRINT_NONTERMINALS($$);
329 }
330 ;
331
332 file_statement_list
333 : file_statement {
334 342 $$ = std::make_unique<Gyoji::frontend::tree::FileStatementList>(return_data.compiler_context.get_token_stream().get_current_source_ref());
335 342 $$->add_statement(std::move($1));
336 PRINT_NONTERMINALS($$);
337 }
338 | file_statement_list file_statement {
339 938 $$ = std::move($1);
340 938 $$->add_statement(std::move($2));
341 PRINT_NONTERMINALS($$);
342 }
343 ;
344
345 file_statement
346 : file_statement_function_definition {
347 444 const Gyoji::frontend::ast::SyntaxNode &sn = *($1);
348 888 $$ = std::make_unique<Gyoji::frontend::tree::FileStatement>(
349 444 std::move($1),
350 sn
351 444 );
352 PRINT_NONTERMINALS($$);
353 }
354 | file_statement_function_declaration {
355 224 const Gyoji::frontend::ast::SyntaxNode &sn = *($1);
356 448 $$ = std::make_unique<Gyoji::frontend::tree::FileStatement>(
357 224 std::move($1),
358 sn
359 224 );
360 PRINT_NONTERMINALS($$);
361 }
362 | file_statement_global_definition {
363 124 const Gyoji::frontend::ast::SyntaxNode &sn = *($1);
364 248 $$ = std::make_unique<Gyoji::frontend::tree::FileStatement>(
365 124 std::move($1),
366 sn
367 124 );
368 PRINT_NONTERMINALS($$);
369 }
370 | class_declaration {
371 56 const Gyoji::frontend::ast::SyntaxNode &sn = *($1);
372 112 $$ = std::make_unique<Gyoji::frontend::tree::FileStatement>(
373 56 std::move($1),
374 sn
375 56 );
376 PRINT_NONTERMINALS($$);
377 }
378 | class_definition {
379 112 const Gyoji::frontend::ast::SyntaxNode &sn = *($1);
380 224 $$ = std::make_unique<Gyoji::frontend::tree::FileStatement>(
381 112 std::move($1),
382 sn
383 112 );
384 PRINT_NONTERMINALS($$);
385 }
386 | enum_definition {
387 18 const Gyoji::frontend::ast::SyntaxNode &sn = *($1);
388 36 $$ = std::make_unique<Gyoji::frontend::tree::FileStatement>(
389 18 std::move($1),
390 sn
391 18 );
392 PRINT_NONTERMINALS($$);
393 }
394 | type_definition {
395 138 const Gyoji::frontend::ast::SyntaxNode &sn = *($1);
396 276 $$ = std::make_unique<Gyoji::frontend::tree::FileStatement>(
397 138 std::move($1),
398 sn
399 138 );
400 PRINT_NONTERMINALS($$);
401 }
402 | file_statement_namespace {
403 118 const Gyoji::frontend::ast::SyntaxNode &sn = *($1);
404 236 $$ = std::make_unique<Gyoji::frontend::tree::FileStatement>(
405 118 std::move($1),
406 sn
407 118 );
408 PRINT_NONTERMINALS($$);
409 }
410 | file_statement_using {
411 46 const Gyoji::frontend::ast::SyntaxNode &sn = *($1);
412 92 $$ = std::make_unique<Gyoji::frontend::tree::FileStatement>(
413 46 std::move($1),
414 sn
415 46 );
416 PRINT_NONTERMINALS($$);
417 }
418 ;
419
420 file_statement_global_definition
421 : opt_access_modifier opt_unsafe type_specifier IDENTIFIER opt_global_initializer SEMICOLON {
422 124 std::string global_name = $4->get_value();
423 124 NS2Entity *ns2_entity = return_data.identifier_get_or_create($4->get_value(), true, $4->get_source_ref());
424 124 $4->set_ns2_entity(ns2_entity);
425
426 248 $$ = std::make_unique<Gyoji::frontend::tree::FileStatementGlobalDefinition>(
427 124 std::move($1),
428 124 std::move($2),
429 124 std::move($3),
430 124 std::move($4),
431 124 std::move($5),
432 124 std::move($6)
433 124 );
434 PRINT_NONTERMINALS($$);
435 124 }
436 ;
437
438 opt_global_initializer
439 : /**/ {
440 116 $$ = std::make_unique<Gyoji::frontend::tree::GlobalInitializer>(return_data.compiler_context.get_token_stream().get_current_source_ref());
441 PRINT_NONTERMINALS($$);
442 }
443 | global_initializer {
444 8 $$ = std::move($1);
445 PRINT_NONTERMINALS($$);
446 }
447 ;
448
449 global_initializer
450 : global_initializer_expression_primary {
451 8 const Gyoji::frontend::ast::SyntaxNode &sn = *($1);
452 8 $$ = std::make_unique<Gyoji::frontend::tree::GlobalInitializer>(std::move($1), sn);
453 }
454 | global_initializer_addressof_expression_primary {
455 8 const Gyoji::frontend::ast::SyntaxNode &sn = *($1);
456 8 $$ = std::make_unique<Gyoji::frontend::tree::GlobalInitializer>(std::move($1), sn);
457 }
458 | global_initializer_struct_initializer_list {
459 8 const Gyoji::frontend::ast::SyntaxNode &sn = *($1);
460 8 $$ = std::make_unique<Gyoji::frontend::tree::GlobalInitializer>(std::move($1), sn);
461 }
462 ;
463
464 global_initializer_expression_primary
465 : ASSIGNMENT expression_primary {
466 16 $$ = std::make_unique<Gyoji::frontend::tree::GlobalInitializerExpressionPrimary>(std::move($1),
467 16 std::move($2));
468 PRINT_NONTERMINALS($$);
469 }
470 ;
471
472 global_initializer_addressof_expression_primary
473 : ASSIGNMENT ANDPERSAND expression_primary {
474 16 $$ = std::make_unique<Gyoji::frontend::tree::GlobalInitializerAddressofExpressionPrimary>(std::move($1),
475 8 std::move($2),
476 8 std::move($3)
477 8 );
478 PRINT_NONTERMINALS($$);
479 }
480 ;
481
482 global_initializer_struct_initializer_list
483 : ASSIGNMENT BRACE_L opt_struct_initializer_list BRACE_R {
484 16 $$ = std::make_unique<Gyoji::frontend::tree::GlobalInitializerStructInitializerList>(std::move($1),
485 8 std::move($2),
486 8 std::move($3),
487 8 std::move($4)
488 8 );
489 PRINT_NONTERMINALS($$);
490 }
491 ;
492
493
494 opt_struct_initializer_list
495 : /**/ {
496 ✗ $$ = std::make_unique<Gyoji::frontend::tree::StructInitializerList>(return_data.compiler_context.get_token_stream().get_current_source_ref());
497 PRINT_NONTERMINALS($$);
498 }
499 | struct_initializer_list {
500 8 $$ = std::move($1);
501 PRINT_NONTERMINALS($$);
502 }
503 ;
504
505 struct_initializer_list
506 : struct_initializer {
507 8 $$ = std::make_unique<Gyoji::frontend::tree::StructInitializerList>($1->get_source_ref());
508 8 $$->add_initializer(std::move($1));
509 PRINT_NONTERMINALS($$);
510 }
511 | struct_initializer_list struct_initializer {
512 8 $$ = std::move($1);
513 8 $$->add_initializer(std::move($2));
514 PRINT_NONTERMINALS($$);
515 }
516 ;
517
518 struct_initializer
519 : DOT IDENTIFIER global_initializer SEMICOLON {
520 16 $2->set_identifier_type(Gyoji::frontend::tree::Terminal::IDENTIFIER_LOCAL_SCOPE);
521
522 32 $$ = std::make_unique<Gyoji::frontend::tree::StructInitializer>(
523 16 std::move($1),
524 16 std::move($2),
525 16 std::move($3),
526 16 std::move($4)
527 16 );
528 PRINT_NONTERMINALS($$);
529 }
530 ;
531
532 opt_access_modifier
533 : /**/ {
534 1300 $$ = std::make_unique<Gyoji::frontend::tree::AccessModifier>(return_data.compiler_context.get_token_stream().get_current_source_ref());
535 PRINT_NONTERMINALS($$);
536 }
537 | access_modifier {
538 596 $$ = std::make_unique<Gyoji::frontend::tree::AccessModifier>(
539 298 std::move($1)
540 298 );
541 PRINT_NONTERMINALS($$);
542 }
543 ;
544
545 access_modifier
546 : PUBLIC {
547 230 $$ = std::move($1);
548 PRINT_NONTERMINALS($$);
549 }
550 | PRIVATE {
551 50 $$ = std::move($1);
552 PRINT_NONTERMINALS($$);
553 }
554 | PROTECTED {
555 18 $$ = std::move($1);
556 PRINT_NONTERMINALS($$);
557 }
558 ;
559
560 namespace_declaration
561 : opt_access_modifier NAMESPACE IDENTIFIER {
562 118 Gyoji::frontend::namespaces::NS2Entity *ns = return_data.namespace_get_or_create($3->get_value(), $3->get_source_ref());
563 118 $3->set_ns2_entity(ns);
564 118 return_data.ns2_context->namespace_push(ns);
565
566 236 $$ = std::make_unique<Gyoji::frontend::tree::NamespaceDeclaration>(
567 118 std::move($1),
568 118 std::move($2),
569 118 std::move($3)
570 118 );
571
572 PRINT_NONTERMINALS($$);
573 }
574 | opt_access_modifier NAMESPACE NAMESPACE_NAME {
575 ✗ Gyoji::frontend::namespaces::NS2Entity *ns = return_data.ns2_context->namespace_find($3->get_value());
576 ✗ return_data.ns2_context->namespace_push(ns);
577
578 ✗ $$ = std::make_unique<Gyoji::frontend::tree::NamespaceDeclaration>(
579 ✗ std::move($1),
580 ✗ std::move($2),
581 ✗ std::move($3)
582 ✗ );
583 PRINT_NONTERMINALS($$);
584 }
585 ;
586
587 file_statement_namespace
588 : namespace_declaration BRACE_L opt_file_statement_list BRACE_R SEMICOLON {
589 236 $$ = std::make_unique<Gyoji::frontend::tree::FileStatementNamespace>(
590 118 std::move($1),
591 118 std::move($2),
592 118 std::move($3),
593 118 std::move($4),
594 118 std::move($5)
595 118 );
596 118 return_data.ns2_context->namespace_pop();
597 PRINT_NONTERMINALS($$);
598 }
599 ;
600
601 opt_as
602 : /**/ {
603 34 $$ = std::make_unique<Gyoji::frontend::tree::UsingAs>(return_data.compiler_context.get_token_stream().get_current_source_ref());
604 PRINT_NONTERMINALS($$);
605 }
606 | AS IDENTIFIER {
607 24 $$ = std::make_unique<Gyoji::frontend::tree::UsingAs>(
608 12 std::move($1),
609 12 std::move($2)
610 12 );
611 PRINT_NONTERMINALS($$);
612 }
613 ;
614
615 file_statement_using
616 : opt_access_modifier USING NAMESPACE NAMESPACE_NAME opt_as SEMICOLON {
617 38 std::string namespace_name = $4->get_value();
618 38 std::string as_name = $5->get_using_name();
619 38 NS2Entity *entity = return_data.ns2_context->namespace_find(namespace_name);
620
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 38 times.
 38 if (entity == nullptr) {
621 ✗ auto error = std::make_unique<Gyoji::context::Error>(std::string("Invalid identifier") + namespace_name + std::string("."));
622 ✗ error->add_message($4->get_source_ref(), std::string("") + namespace_name + std::string(" is not a namespace."));
623 ✗ return_data.get_compiler_context().get_errors().add_error(std::move(error));
624 ✗ return -1;
625 ✗ }
626 38 return_data.ns2_context->namespace_using(as_name, entity);
627
628 76 $$ = std::make_unique<Gyoji::frontend::tree::FileStatementUsing>(
629 38 std::move($1),
630 38 std::move($2),
631 38 std::move($3),
632 38 std::move($4),
633 38 std::move($5),
634 38 std::move($6)
635 38 );
636 PRINT_NONTERMINALS($$);
637
2/4
✓ Branch 1 taken 38 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 38 times.
✗ Branch 5 not taken.
 38 }
638 | opt_access_modifier USING NAMESPACE TYPE_NAME opt_as SEMICOLON {
639 8 std::string namespace_name = $4->get_value();
640 8 std::string as_name = $5->get_using_name();
641
642 8 NS2Entity *entity = return_data.ns2_context->namespace_find(namespace_name);
643
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
 8 if (entity == nullptr) {
644 ✗ auto error = std::make_unique<Gyoji::context::Error>(std::string("Invalid identifier") + namespace_name + std::string("."));
645 ✗ error->add_message($4->get_source_ref(), std::string("") + namespace_name + std::string(" is not a namespace."));
646 ✗ return_data.get_compiler_context().get_errors().add_error(std::move(error));
647 ✗ return -1;
648 ✗ }
649 8 return_data.ns2_context->namespace_using(as_name, entity);
650
651 16 $$ = std::make_unique<Gyoji::frontend::tree::FileStatementUsing>(
652 8 std::move($1),
653 8 std::move($2),
654 8 std::move($3),
655 8 std::move($4),
656 8 std::move($5),
657 8 std::move($6)
658 8 );
659 PRINT_NONTERMINALS($$);
660
2/4
✓ Branch 1 taken 8 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 8 times.
✗ Branch 5 not taken.
 8 }
661 ;
662
663 // If this is the first time we see the declaration,
664 // it will be an identifier. Once the class has been
665 // seen before (forward-declared), it will then become
666 // a type instead of an identifier.
667 class_decl_start
668 : opt_access_modifier CLASS IDENTIFIER opt_class_argument_list {
669 138 NS2Entity *ns2_entity = return_data.class_get_or_create($3->get_value(), $3->get_source_ref());
670 138 $3->set_ns2_entity(ns2_entity);
671 138 return_data.ns2_context->namespace_push(ns2_entity);
672 276 $$ = std::make_unique<Gyoji::frontend::tree::ClassDeclStart>(
673 138 std::move($1),
674 138 std::move($2),
675 138 std::move($3),
676 138 std::move($4),
677 276 true // is_identifier
678 138 );
679
680
681 PRINT_NONTERMINALS($$);
682 }
683 | opt_access_modifier CLASS TYPE_NAME opt_class_argument_list {
684 46 return_data.ns2_context->namespace_push($3->get_ns2_entity());
685 92 $$ = std::make_unique<Gyoji::frontend::tree::ClassDeclStart>(
686 46 std::move($1),
687 46 std::move($2),
688 46 std::move($3),
689 46 std::move($4),
690 92 false // is_identifier
691 46 );
692 }
693 ;
694
695 opt_class_argument_list
696 : /**/ {
697 184 $$ = std::make_unique<Gyoji::frontend::tree::ClassArgumentList>(return_data.compiler_context.get_token_stream().get_current_source_ref());
698 PRINT_NONTERMINALS($$);
699 }
700 | PAREN_L class_argument_list PAREN_R {
701 ✗ $$ = std::move($2);
702 ✗ $$->add_parens(std::move($1), std::move($3));
703 PRINT_NONTERMINALS($$);
704 }
705 ;
706
707 // At this stage, the arguments
708 // are identifiers. Once they are
709 // recognized, they are turned into
710 // types scoped private in the class.
711 class_argument_list
712 : IDENTIFIER {
713 ✗ NS2Entity *ns2_entity = return_data.identifier_get_or_create($1->get_value(), true, $1->get_source_ref());
714 ✗ $1->set_ns2_entity(ns2_entity);
715 ✗ $$ = std::make_unique<Gyoji::frontend::tree::ClassArgumentList>(
716 ✗ std::move($1)
717 ✗ );
718 PRINT_NONTERMINALS($$);
719 }
720 | class_argument_list COMMA IDENTIFIER {
721 ✗ NS2Entity *ns2_entity = return_data.identifier_get_or_create($3->get_value(), true, $3->get_source_ref());
722 ✗ $3->set_ns2_entity(ns2_entity);
723 ✗ $$ = std::move($1);
724 ✗ $$->add_argument(std::move($2), std::move($3));
725 PRINT_NONTERMINALS($$);
726 }
727 ;
728
729 // Forwar-declaration of a class.
730 class_declaration
731 : class_decl_start SEMICOLON {
732 112 $$ = std::make_unique<Gyoji::frontend::tree::ClassDeclaration>(
733 56 std::move($1),
734 56 std::move($2)
735 56 );
736 56 return_data.ns2_context->namespace_pop();
737 PRINT_NONTERMINALS($$);
738 }
739 ;
740
741 class_definition
742 : class_decl_start BRACE_L opt_class_member_declaration_list BRACE_R SEMICOLON {
743 256 $$ = std::make_unique<Gyoji::frontend::tree::ClassDefinition>(
744 128 std::move($1),
745 128 std::move($2),
746 128 std::move($3),
747 128 std::move($4),
748 128 std::move($5)
749 128 );
750 128 return_data.ns2_context->namespace_pop();
751 PRINT_NONTERMINALS($$);
752 }
753 ;
754
755 type_definition
756 : opt_access_modifier TYPEDEF type_specifier IDENTIFIER SEMICOLON {
757 146 Gyoji::frontend::namespaces::NS2Entity *ns2_entity = return_data.type_get_or_create($4->get_value(), $4->get_source_ref());
758 146 $4->set_ns2_entity(ns2_entity);
759 146 fprintf(stderr, "Defined type %s\n", $4->get_fully_qualified_name().c_str());
760 292 $$ = std::make_unique<Gyoji::frontend::tree::TypeDefinition>(
761 146 std::move($1),
762 146 std::move($2),
763 146 std::move($3),
764 146 std::move($4),
765 146 std::move($5)
766 146 );
767
768
769 PRINT_NONTERMINALS($$);
770 }
771 ;
772
773 enum_definition
774 : opt_access_modifier ENUM TYPE_NAME IDENTIFIER BRACE_L opt_enum_value_list BRACE_R SEMICOLON {
775 26 Gyoji::frontend::namespaces::NS2Entity *ns2_entity = return_data.type_get_or_create($4->get_value(), $4->get_source_ref());
776 26 $4->set_ns2_entity(ns2_entity);
777 52 $$ = std::make_unique<Gyoji::frontend::tree::EnumDefinition>(
778 26 std::move($1),
779 26 std::move($2),
780 26 std::move($3),
781 26 std::move($4),
782 26 std::move($5),
783 26 std::move($6),
784 26 std::move($7),
785 26 std::move($8)
786 26 );
787 PRINT_NONTERMINALS($$);
788 }
789 ;
790
791 opt_enum_value_list
792 : /**/ {
793 ✗ $$ = std::make_unique<Gyoji::frontend::tree::EnumDefinitionValueList>(return_data.compiler_context.get_token_stream().get_current_source_ref());
794 PRINT_NONTERMINALS($$);
795 }
796 | enum_value_list {
797 26 $$ = std::move($1);
798 PRINT_NONTERMINALS($$);
799 }
800 ;
801
802 enum_value_list
803 : enum_value {
804 26 $$ = std::make_unique<Gyoji::frontend::tree::EnumDefinitionValueList>(return_data.compiler_context.get_token_stream().get_current_source_ref());
805 26 $$->add_value(std::move($1));
806 PRINT_NONTERMINALS($$);
807 }
808 | enum_value_list enum_value {
809 42 $$ = std::move($1);
810 42 $$->add_value(std::move($2));
811 PRINT_NONTERMINALS($$);
812 }
813 ;
814
815 enum_value
816 : IDENTIFIER ASSIGNMENT expression_primary SEMICOLON {
817 68 Gyoji::frontend::namespaces::NS2Entity *ns2_entity = return_data.type_get_or_create($1->get_value(), $1->get_source_ref());
818 68 $1->set_ns2_entity(ns2_entity);
819 136 $$ = std::make_unique<Gyoji::frontend::tree::EnumDefinitionValue>(
820 68 std::move($1),
821 68 std::move($2),
822 68 std::move($3),
823 68 std::move($4)
824 68 );
825 PRINT_NONTERMINALS($$);
826 }
827 ;
828
829 opt_unsafe
830 : /**/ {
831 788 $$ = std::make_unique<Gyoji::frontend::tree::UnsafeModifier>(return_data.compiler_context.get_token_stream().get_current_source_ref());
832 PRINT_NONTERMINALS($$);
833 }
834 | UNSAFE {
835 28 $$ = std::make_unique<Gyoji::frontend::tree::UnsafeModifier>(std::move($1));
836 PRINT_NONTERMINALS($$);
837 }
838 ;
839
840 file_statement_function_declaration
841 : function_decl_start PAREN_L opt_function_definition_arg_list PAREN_R SEMICOLON {
842 // This is the point at which we need to fully-qualify our symbol name
843 // because it may be in a namespace and we need to find it unambiguously
844 // in a possibly large namespace. We don't want the MIR or code-gen layers
845 // to have to care about how we name functions.
846 // In future, we may support name mangling, but again, that's not the concern of the
847 // back-end layers.
848 448 $$ = std::make_unique<Gyoji::frontend::tree::FileStatementFunctionDeclaration>(
849 224 std::move($1),
850 224 std::move($2),
851 224 std::move($3),
852 224 std::move($4),
853 224 std::move($5)
854 224 );
855 224 return_data.ns2_context->namespace_pop();
856 PRINT_NONTERMINALS($$);
857 }
858 ;
859
860 function_decl_start
861 : opt_access_modifier opt_unsafe type_specifier IDENTIFIER {
862 668 NS2Entity *ns2_entity = return_data.identifier_get_or_create($4->get_value(), true, $4->get_source_ref());
863
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 668 times.
 668 if (ns2_entity == nullptr) {
864 ✗ return -1;
865 }
866 668 $4->set_ns2_entity(ns2_entity);
867 668 return_data.ns2_context->namespace_push(ns2_entity);
868 1336 $$ = std::make_unique<Gyoji::frontend::tree::FileStatementFunctionDeclStart>(
869 668 std::move($1),
870 668 std::move($2),
871 668 std::move($3),
872 668 std::move($4)
873 668 );
874 }
875 ;
876
877 file_statement_function_definition
878 : function_decl_start PAREN_L opt_function_definition_arg_list PAREN_R scope_body {
879 // This is the point at which we need to fully-qualify our symbol name
880 // because it may be in a namespace and we need to find it unambiguously
881 // in a possibly large namespace. We don't want the MIR or code-gen layers
882 // to have to care about how we name functions.
883 // In future, we may support name mangling, but again, that's not the concern of the
884 // back-end layers.
885
886 // For a function definition, we may want to also 'push' the namespace
887 // resolution context for a class if the identifier is declared inside
888 // a class' namespace. but that needs to happen before we actually push the scope
889 // and function identifiers.
890
891 888 $$ = std::make_unique<Gyoji::frontend::tree::FileStatementFunctionDefinition>(
892 444 std::move($1),
893 444 std::move($2),
894 444 std::move($3),
895 444 std::move($4),
896 444 std::move($5)
897 444 );
898 444 return_data.ns2_context->namespace_pop();
899 PRINT_NONTERMINALS($$);
900 }
901 ;
902
903 opt_function_definition_arg_list
904 : /**/ {
905 110 $$ = std::make_unique<Gyoji::frontend::tree::FunctionDefinitionArgList>(return_data.compiler_context.get_token_stream().get_current_source_ref());
906 PRINT_NONTERMINALS($$);
907 }
908 | function_definition_arg_list {
909 592 $$ = std::move($1);
910 PRINT_NONTERMINALS($$);
911 }
912 ;
913
914 function_definition_arg_list
915 : function_definition_arg {
916 592 $$ = std::make_unique<Gyoji::frontend::tree::FunctionDefinitionArgList>($1->get_source_ref());
917 592 $$->add_argument(std::move($1));
918 PRINT_NONTERMINALS($$);
919 }
920 | function_definition_arg_list COMMA function_definition_arg {
921 502 $$ = std::move($1);
922 502 $$->add_comma(std::move($2));
923 502 $$->add_argument(std::move($3));
924 PRINT_NONTERMINALS($$);
925 }
926 ;
927 function_definition_arg
928 : type_specifier IDENTIFIER {
929 1094 NS2Entity *ns2_entity = return_data.identifier_get_or_create($2->get_value(), true, $2->get_source_ref());
930 1094 $2->set_ns2_entity(ns2_entity);
931 2188 $$ = std::make_unique<Gyoji::frontend::tree::FunctionDefinitionArg>(
932 1094 std::move($1),
933 1094 std::move($2)
934 1094 );
935 PRINT_NONTERMINALS($$);
936 }
937 ;
938
939 scope_body
940 : BRACE_L statement_list BRACE_R {
941 1648 $$ = std::make_unique<Gyoji::frontend::tree::ScopeBody>(
942 824 std::move($1),
943 824 std::move($2),
944 824 std::move($3)
945 824 );
946 PRINT_NONTERMINALS($$);
947 }
948 ;
949
950 statement_list
951 : /**/ {
952 824 $$ = std::make_unique<Gyoji::frontend::tree::StatementList>(return_data.compiler_context.get_token_stream().get_current_source_ref());
953 PRINT_NONTERMINALS($$);
954 }
955 | statement_list statement {
956 3220 $$ = std::move($1);
957 3220 $$->add_statement(std::move($2));
958 PRINT_NONTERMINALS($$);
959 }
960 ;
961
962 statement
963 : statement_variable_declaration {
964 516 const Gyoji::frontend::ast::SyntaxNode &sn = *($1);
965 516 $$ = std::make_unique<Gyoji::frontend::tree::Statement>(std::move($1), sn);
966 PRINT_NONTERMINALS($$);
967 }
968 | statement_block {
969 22 const Gyoji::frontend::ast::SyntaxNode &sn = *($1);
970 22 $$ = std::make_unique<Gyoji::frontend::tree::Statement>(std::move($1), sn);
971 PRINT_NONTERMINALS($$);
972 }
973 | statement_expression {
974 1918 const Gyoji::frontend::ast::SyntaxNode &sn = *($1);
975 1918 $$ = std::make_unique<Gyoji::frontend::tree::Statement>(std::move($1), sn);
976 PRINT_NONTERMINALS($$);
977 }
978 | statement_ifelse {
979 186 const Gyoji::frontend::ast::SyntaxNode &sn = *($1);
980 186 $$ = std::make_unique<Gyoji::frontend::tree::Statement>(std::move($1), sn);
981 PRINT_NONTERMINALS($$);
982 }
983 | statement_while {
984 34 const Gyoji::frontend::ast::SyntaxNode &sn = *($1);
985 34 $$ = std::make_unique<Gyoji::frontend::tree::Statement>(std::move($1), sn);
986 PRINT_NONTERMINALS($$);
987 }
988 | statement_for {
989 2 const Gyoji::frontend::ast::SyntaxNode &sn = *($1);
990 2 $$ = std::make_unique<Gyoji::frontend::tree::Statement>(std::move($1), sn);
991 PRINT_NONTERMINALS($$);
992 }
993 | statement_switch {
994 8 const Gyoji::frontend::ast::SyntaxNode &sn = *($1);
995 8 $$ = std::make_unique<Gyoji::frontend::tree::Statement>(std::move($1), sn);
996 PRINT_NONTERMINALS($$);
997 }
998 | statement_label {
999 10 const Gyoji::frontend::ast::SyntaxNode &sn = *($1);
1000 10 $$ = std::make_unique<Gyoji::frontend::tree::Statement>(std::move($1), sn);
1001 PRINT_NONTERMINALS($$);
1002 }
1003 | statement_goto {
1004 10 const Gyoji::frontend::ast::SyntaxNode &sn = *($1);
1005 10 $$ = std::make_unique<Gyoji::frontend::tree::Statement>(std::move($1), sn);
1006 PRINT_NONTERMINALS($$);
1007 }
1008 | statement_break {
1009 10 const Gyoji::frontend::ast::SyntaxNode &sn = *($1);
1010 10 $$ = std::make_unique<Gyoji::frontend::tree::Statement>(std::move($1), sn);
1011 PRINT_NONTERMINALS($$);
1012 }
1013 | statement_continue {
1014 10 const Gyoji::frontend::ast::SyntaxNode &sn = *($1);
1015 10 $$ = std::make_unique<Gyoji::frontend::tree::Statement>(std::move($1), sn);
1016 PRINT_NONTERMINALS($$);
1017 }
1018 | statement_return {
1019 494 const Gyoji::frontend::ast::SyntaxNode &sn = *($1);
1020 494 $$ = std::make_unique<Gyoji::frontend::tree::Statement>(std::move($1), sn);
1021 PRINT_NONTERMINALS($$);
1022 }
1023 ;
1024
1025 initializer_expression
1026 : /**/ {
1027 496 $$ = std::make_unique<Gyoji::frontend::tree::InitializerExpression>(return_data.compiler_context.get_token_stream().get_current_source_ref());
1028 PRINT_NONTERMINALS($$);
1029 }
1030 | ASSIGNMENT expression {
1031 40 $$ = std::make_unique<Gyoji::frontend::tree::InitializerExpression>(
1032 20 std::move($1),
1033 20 std::move($2)
1034 20 );
1035 PRINT_NONTERMINALS($$);
1036 }
1037 ;
1038
1039 statement_variable_declaration
1040 : type_specifier IDENTIFIER initializer_expression SEMICOLON {
1041 516 NS2Entity *ns2_entity = return_data.identifier_get_or_create($2->get_value(), true, $2->get_source_ref());
1042 516 $2->set_ns2_entity(ns2_entity);
1043 1032 $$ = std::make_unique<Gyoji::frontend::tree::StatementVariableDeclaration>(
1044 516 std::move($1),
1045 516 std::move($2),
1046 516 std::move($3),
1047 516 std::move($4)
1048 516 );
1049 PRINT_NONTERMINALS($$);
1050 }
1051 ;
1052
1053 statement_block
1054 : opt_unsafe scope_body {
1055 44 $$ = std::make_unique<Gyoji::frontend::tree::StatementBlock>(
1056 22 std::move($1),
1057 22 std::move($2)
1058 22 );
1059 PRINT_NONTERMINALS($$);
1060 }
1061 ;
1062
1063 statement_expression
1064 : expression SEMICOLON {
1065 3836 $$ = std::make_unique<Gyoji::frontend::tree::StatementExpression>(
1066 1918 std::move($1),
1067 1918 std::move($2)
1068 1918 );
1069 PRINT_NONTERMINALS($$);
1070 }
1071 ;
1072 statement_goto
1073 : GOTO IDENTIFIER SEMICOLON {
1074 10 NS2Entity *ns2_entity = return_data.identifier_get_or_create($2->get_value(), true, $2->get_source_ref());
1075 10 $2->set_ns2_entity(ns2_entity);
1076 20 $$ = std::make_unique<Gyoji::frontend::tree::StatementGoto>(
1077 10 std::move($1),
1078 10 std::move($2),
1079 10 std::move($3)
1080 10 );
1081 PRINT_NONTERMINALS($$);
1082 }
1083 ;
1084 statement_break
1085 : BREAK SEMICOLON {
1086 20 $$ = std::make_unique<Gyoji::frontend::tree::StatementBreak>(
1087 10 std::move($1),
1088 10 std::move($2)
1089 10 );
1090 PRINT_NONTERMINALS($$);
1091 }
1092 ;
1093 statement_continue
1094 : CONTINUE SEMICOLON {
1095 20 $$ = std::make_unique<Gyoji::frontend::tree::StatementContinue>(
1096 10 std::move($1),
1097 10 std::move($2)
1098 10 );
1099 PRINT_NONTERMINALS($$);
1100 }
1101 ;
1102 statement_label
1103 : LABEL IDENTIFIER COLON {
1104 10 NS2Entity *ns2_entity = return_data.identifier_get_or_create($2->get_value(), true, $2->get_source_ref());
1105 10 $2->set_ns2_entity(ns2_entity);
1106 20 $$ = std::make_unique<Gyoji::frontend::tree::StatementLabel>(
1107 10 std::move($1),
1108 10 std::move($2),
1109 10 std::move($3)
1110 10 );
1111 PRINT_NONTERMINALS($$);
1112 }
1113 ;
1114
1115 statement_return
1116 : RETURN expression SEMICOLON {
1117 984 $$ = std::make_unique<Gyoji::frontend::tree::StatementReturn>(
1118 492 std::move($1),
1119 492 std::move($2),
1120 492 std::move($3)
1121 492 );
1122 PRINT_NONTERMINALS($$);
1123 }
1124 | RETURN SEMICOLON {
1125 4 $$ = std::make_unique<Gyoji::frontend::tree::StatementReturn>(
1126 2 std::move($1),
1127 2 std::move($2)
1128 2 );
1129 PRINT_NONTERMINALS($$);
1130 }
1131
1132 ;
1133
1134 statement_ifelse
1135 : IF PAREN_L expression PAREN_R scope_body {
1136 228 $$ = std::make_unique<Gyoji::frontend::tree::StatementIfElse>(
1137 114 std::move($1),
1138 114 std::move($2),
1139 114 std::move($3),
1140 114 std::move($4),
1141 114 std::move($5)
1142 114 );
1143 PRINT_NONTERMINALS($$);
1144 }
1145 | IF PAREN_L expression PAREN_R scope_body ELSE statement_ifelse {
1146 64 $$ = std::make_unique<Gyoji::frontend::tree::StatementIfElse>(
1147 32 std::move($1),
1148 32 std::move($2),
1149 32 std::move($3),
1150 32 std::move($4),
1151 32 std::move($5),
1152 32 std::move($6),
1153 32 std::move($7)
1154 32 );
1155 PRINT_NONTERMINALS($$);
1156 }
1157 | IF PAREN_L expression PAREN_R scope_body ELSE scope_body {
1158 144 $$ = std::make_unique<Gyoji::frontend::tree::StatementIfElse>(
1159 72 std::move($1),
1160 72 std::move($2),
1161 72 std::move($3),
1162 72 std::move($4),
1163 72 std::move($5),
1164 72 std::move($6),
1165 72 std::move($7)
1166 72 );
1167 PRINT_NONTERMINALS($$);
1168 }
1169 ;
1170
1171 statement_while
1172 : WHILE PAREN_L expression PAREN_R scope_body {
1173 68 $$ = std::make_unique<Gyoji::frontend::tree::StatementWhile>(
1174 34 std::move($1),
1175 34 std::move($2),
1176 34 std::move($3),
1177 34 std::move($4),
1178 34 std::move($5)
1179 34 );
1180 PRINT_NONTERMINALS($$);
1181 }
1182 ;
1183
1184 statement_for
1185 : FOR PAREN_L expression SEMICOLON expression SEMICOLON expression PAREN_R scope_body {
1186 // This variation is just a plain expression.
1187 ✗ $$ = std::make_unique<Gyoji::frontend::tree::StatementFor>(
1188 ✗ std::move($1),
1189 ✗ std::move($2),
1190 ✗ std::move($3),
1191 ✗ std::move($4),
1192 ✗ std::move($5),
1193 ✗ std::move($6),
1194 ✗ std::move($7),
1195 ✗ std::move($8),
1196 ✗ std::move($9)
1197 ✗ );
1198 PRINT_NONTERMINALS($$);
1199 }
1200 | FOR PAREN_L type_specifier IDENTIFIER ASSIGNMENT expression SEMICOLON expression SEMICOLON expression PAREN_R scope_body {
1201 2 NS2Entity *ns2_entity = return_data.identifier_get_or_create($4->get_value(), true, $4->get_source_ref());
1202 2 $2->set_ns2_entity(ns2_entity);
1203 // This variation is a declaration and assignment
1204 4 $$ = std::make_unique<Gyoji::frontend::tree::StatementFor>(
1205 2 std::move($1),
1206 2 std::move($2),
1207 2 std::move($3),
1208 2 std::move($4),
1209 2 std::move($5),
1210 2 std::move($6),
1211 2 std::move($7),
1212 2 std::move($8),
1213 2 std::move($9),
1214 2 std::move($10),
1215 2 std::move($11),
1216 2 std::move($12)
1217 2 );
1218 PRINT_NONTERMINALS($$);
1219 }
1220 ;
1221
1222 statement_switch
1223 : SWITCH PAREN_L expression PAREN_R BRACE_L opt_statement_switch_content BRACE_R {
1224 16 $$ = std::make_unique<Gyoji::frontend::tree::StatementSwitch>(
1225 8 std::move($1),
1226 8 std::move($2),
1227 8 std::move($3),
1228 8 std::move($4),
1229 8 std::move($5),
1230 8 std::move($6),
1231 8 std::move($7)
1232 8 );
1233 PRINT_NONTERMINALS($$);
1234 }
1235 ;
1236
1237 opt_statement_switch_content
1238 : /**/ {
1239 ✗ $$ = std::make_unique<Gyoji::frontend::tree::StatementSwitchContent>(return_data.compiler_context.get_token_stream().get_current_source_ref());
1240 PRINT_NONTERMINALS($$);
1241 }
1242 | statement_switch_content {
1243 8 $$ = std::move($1);
1244 PRINT_NONTERMINALS($$);
1245 }
1246 ;
1247
1248 statement_switch_content
1249 : statement_switch_block {
1250 8 $$ = std::make_unique<Gyoji::frontend::tree::StatementSwitchContent>($1->get_source_ref());
1251 8 $$->add_block(std::move($1));
1252 PRINT_NONTERMINALS($$);
1253 }
1254 | statement_switch_content statement_switch_block {
1255 24 $$ = std::move($1);
1256 24 $$->add_block(std::move($2));
1257 PRINT_NONTERMINALS($$);
1258 }
1259 ;
1260
1261 statement_switch_block
1262 : DEFAULT COLON scope_body {
1263 16 $$ = std::make_unique<Gyoji::frontend::tree::StatementSwitchBlock>(
1264 8 std::move($1),
1265 8 std::move($2),
1266 8 std::move($3)
1267 8 );
1268 PRINT_NONTERMINALS($$);
1269 }
1270 | CASE expression COLON scope_body {
1271 48 $$ = std::make_unique<Gyoji::frontend::tree::StatementSwitchBlock>(
1272 24 std::move($1),
1273 24 std::move($2),
1274 24 std::move($3),
1275 24 std::move($4)
1276 24 );
1277 PRINT_NONTERMINALS($$);
1278 }
1279 ;
1280
1281 expression_primary
1282 : expression_primary_identifier {
1283 3168 const Gyoji::frontend::ast::SyntaxNode &sn = *($1);
1284 3168 $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move($1), sn);
1285 PRINT_NONTERMINALS($$);
1286 }
1287 | expression_primary_nested {
1288 76 const Gyoji::frontend::ast::SyntaxNode &sn = *($1);
1289 76 $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move($1), sn);
1290 PRINT_NONTERMINALS($$);
1291 }
1292 | expression_primary_literal_int {
1293 1110 const Gyoji::frontend::ast::SyntaxNode &sn = *($1);
1294 1110 $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move($1), sn);
1295 PRINT_NONTERMINALS($$);
1296 }
1297 | expression_primary_literal_char {
1298 168 const Gyoji::frontend::ast::SyntaxNode &sn = *($1);
1299 168 $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move($1), sn);
1300 PRINT_NONTERMINALS($$);
1301 }
1302 | expression_primary_literal_string {
1303 122 const Gyoji::frontend::ast::SyntaxNode &sn = *($1);
1304 122 $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move($1), sn);
1305 PRINT_NONTERMINALS($$);
1306 }
1307 | expression_primary_literal_float {
1308 78 const Gyoji::frontend::ast::SyntaxNode &sn = *($1);
1309 78 $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move($1), sn);
1310 PRINT_NONTERMINALS($$);
1311 }
1312 | expression_primary_literal_bool {
1313 ✗ const Gyoji::frontend::ast::SyntaxNode &sn = *($1);
1314 ✗ $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move($1), sn);
1315 PRINT_NONTERMINALS($$);
1316 }
1317 | expression_primary_literal_null {
1318 ✗ const Gyoji::frontend::ast::SyntaxNode &sn = *($1);
1319 ✗ $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move($1), sn);
1320 PRINT_NONTERMINALS($$);
1321 }
1322 ;
1323
1324 expression_primary_identifier
1325 : IDENTIFIER {
1326 3168 NS2Entity *ns2_entity = return_data.identifier_get_or_create($1->get_value(), true, $1->get_source_ref());
1327 3168 $1->set_ns2_entity(ns2_entity);
1328 3168 $$ = std::make_unique<Gyoji::frontend::tree::ExpressionPrimaryIdentifier>(std::move($1));
1329 PRINT_NONTERMINALS($$);
1330 }
1331 ;
1332
1333 expression_primary_literal_int
1334 : LITERAL_INT {
1335 1110 $$ = std::make_unique<Gyoji::frontend::tree::ExpressionPrimaryLiteralInt>(std::move($1));
1336 PRINT_NONTERMINALS($$);
1337 }
1338 ;
1339 expression_primary_literal_char
1340 : LITERAL_CHAR {
1341 168 $$ = std::make_unique<Gyoji::frontend::tree::ExpressionPrimaryLiteralChar>(std::move($1));
1342 PRINT_NONTERMINALS($$);
1343 }
1344 ;
1345 expression_primary_literal_string
1346 : LITERAL_STRING {
1347 122 $$ = std::make_unique<Gyoji::frontend::tree::ExpressionPrimaryLiteralString>(std::move($1));
1348 PRINT_NONTERMINALS($$);
1349 }
1350 | expression_primary_literal_string LITERAL_STRING {
1351 10 $$ = std::move($1);
1352 10 $$->add_string(std::move($2));
1353 PRINT_NONTERMINALS($$);
1354 }
1355 ;
1356
1357 expression_primary_literal_float
1358 : LITERAL_FLOAT {
1359 78 $$ = std::make_unique<Gyoji::frontend::tree::ExpressionPrimaryLiteralFloat>(std::move($1));
1360 PRINT_NONTERMINALS($$);
1361 }
1362 ;
1363
1364 expression_primary_literal_bool
1365 : LITERAL_BOOL {
1366 ✗ $$ = std::make_unique<Gyoji::frontend::tree::ExpressionPrimaryLiteralBool>(std::move($1));
1367 PRINT_NONTERMINALS($$);
1368 }
1369 ;
1370
1371 expression_primary_literal_null
1372 : LITERAL_NULL {
1373 ✗ $$ = std::make_unique<Gyoji::frontend::tree::ExpressionPrimaryLiteralNull>(std::move($1));
1374 PRINT_NONTERMINALS($$);
1375 }
1376 ;
1377
1378 expression_primary_nested
1379 : PAREN_L expression PAREN_R {
1380 152 $$ = std::make_unique<Gyoji::frontend::tree::ExpressionPrimaryNested>(
1381 76 std::move($1),
1382 76 std::move($2),
1383 76 std::move($3)
1384 76 );
1385 PRINT_NONTERMINALS($$);
1386 }
1387 ;
1388
1389 expression_postfix
1390 : expression_postfix_primary {
1391 4638 $$ = std::move($1);
1392 PRINT_NONTERMINALS($$);
1393 }
1394 | expression_postfix_arrayindex {
1395 58 $$ = std::move($1);
1396 PRINT_NONTERMINALS($$);
1397 }
1398 | expression_postfix_function_call {
1399 450 $$ = std::move($1);
1400 PRINT_NONTERMINALS($$);
1401 }
1402 | expression_postfix_dot {
1403 66 $$ = std::move($1);
1404 PRINT_NONTERMINALS($$);
1405 }
1406 | expression_postfix_arrow {
1407 50 $$ = std::move($1);
1408 PRINT_NONTERMINALS($$);
1409 }
1410 | expression_postfix_increment {
1411 210 $$ = std::move($1);
1412 PRINT_NONTERMINALS($$);
1413 }
1414 | expression_postfix_decrement {
1415 72 $$ = std::move($1);
1416 PRINT_NONTERMINALS($$);
1417 }
1418 ;
1419
1420 expression_postfix_primary
1421 : expression_primary {
1422 4638 $$ = std::move($1);
1423 PRINT_NONTERMINALS($$);
1424 }
1425 ;
1426
1427 expression_postfix_arrayindex
1428 : expression_postfix BRACKET_L expression BRACKET_R {
1429 auto expr = std::make_unique<Gyoji::frontend::tree::ExpressionPostfixArrayIndex>(
1430 58 std::move($1),
1431 58 std::move($2),
1432 58 std::move($3),
1433 58 std::move($4)
1434 58 );
1435 58 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
1436 58 $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move(expr), sn);
1437 PRINT_NONTERMINALS($$);
1438 58 }
1439 ;
1440
1441 expression_postfix_function_call
1442 : expression_postfix PAREN_L opt_argument_expression_list PAREN_R {
1443 auto expr = std::make_unique<Gyoji::frontend::tree::ExpressionPostfixFunctionCall>(
1444 450 std::move($1),
1445 450 std::move($2),
1446 450 std::move($3),
1447 450 std::move($4)
1448 450 );
1449 450 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
1450 450 $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move(expr), sn);
1451 PRINT_NONTERMINALS($$);
1452 450 }
1453 ;
1454
1455 expression_postfix_dot
1456 : expression_postfix DOT IDENTIFIER {
1457 66 $3->set_identifier_type(Gyoji::frontend::tree::Terminal::IDENTIFIER_LOCAL_SCOPE);
1458 auto expr = std::make_unique<Gyoji::frontend::tree::ExpressionPostfixDot>(
1459 66 std::move($1),
1460 66 std::move($2),
1461 66 std::move($3)
1462 66 );
1463 66 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
1464 66 $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move(expr), sn);
1465 PRINT_NONTERMINALS($$);
1466 66 }
1467 ;
1468
1469 expression_postfix_arrow
1470 : expression_postfix PTR_OP IDENTIFIER {
1471 50 $3->set_identifier_type(Gyoji::frontend::tree::Terminal::IDENTIFIER_LOCAL_SCOPE);
1472 auto expr = std::make_unique<Gyoji::frontend::tree::ExpressionPostfixArrow>(
1473 50 std::move($1),
1474 50 std::move($2),
1475 50 std::move($3)
1476 50 );
1477 50 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
1478 50 $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move(expr), sn);
1479 PRINT_NONTERMINALS($$);
1480 50 }
1481 ;
1482
1483 expression_postfix_increment
1484 : expression_postfix INC_OP {
1485 auto expr = std::make_unique<Gyoji::frontend::tree::ExpressionPostfixIncDec>(
1486 210 std::move($1),
1487 210 std::move($2),
1488 210 Gyoji::frontend::tree::ExpressionPostfixIncDec::INCREMENT
1489 210 );
1490 210 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
1491 210 $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move(expr), sn);
1492 PRINT_NONTERMINALS($$);
1493 210 }
1494 ;
1495
1496 expression_postfix_decrement
1497 : expression_postfix DEC_OP {
1498 auto expr = std::make_unique<Gyoji::frontend::tree::ExpressionPostfixIncDec>(
1499 72 std::move($1),
1500 72 std::move($2),
1501 72 Gyoji::frontend::tree::ExpressionPostfixIncDec::DECREMENT
1502 72 );
1503 72 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
1504 72 $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move(expr), sn);
1505 PRINT_NONTERMINALS($$);
1506 72 }
1507 ;
1508
1509 expression_unary
1510 : expression_postfix {
1511 4638 $$ = std::move($1);
1512 PRINT_NONTERMINALS($$);
1513 }
1514 | expression_unary_increment {
1515 16 $$ = std::move($1);
1516 PRINT_NONTERMINALS($$);
1517 }
1518 | expression_unary_decrement {
1519 72 $$ = std::move($1);
1520 PRINT_NONTERMINALS($$);
1521 }
1522 | expression_unary_prefix {
1523 190 $$ = std::move($1);
1524 PRINT_NONTERMINALS($$);
1525 }
1526 | expression_unary_sizeof_type {
1527 72 $$ = std::move($1);
1528 PRINT_NONTERMINALS($$);
1529 }
1530 ;
1531
1532 expression_unary_increment
1533 : INC_OP expression_unary {
1534 auto expr = std::make_unique<Gyoji::frontend::tree::ExpressionUnaryPrefix>(
1535 16 std::move($1),
1536 16 std::move($2),
1537 16 Gyoji::frontend::tree::ExpressionUnaryPrefix::INCREMENT
1538 16 );
1539 16 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
1540 16 $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move(expr), sn);
1541 PRINT_NONTERMINALS($$);
1542 16 }
1543 ;
1544 expression_unary_decrement
1545 : DEC_OP expression_unary {
1546 auto expr = std::make_unique<Gyoji::frontend::tree::ExpressionUnaryPrefix>(
1547 72 std::move($1),
1548 72 std::move($2),
1549 72 Gyoji::frontend::tree::ExpressionUnaryPrefix::DECREMENT
1550 72 );
1551 72 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
1552 72 $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move(expr), sn);
1553 PRINT_NONTERMINALS($$);
1554 72 }
1555 ;
1556 expression_unary_prefix
1557 : operator_unary expression_cast {
1558 auto expr = std::make_unique<Gyoji::frontend::tree::ExpressionUnaryPrefix>(
1559 190 std::move($1.second),
1560 std::move($2),
1561 $1.first
1562 );
1563 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
1564 190 $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move(expr), sn);
1565 190 PRINT_NONTERMINALS($$);
1566 190 }
1567 ;
1568 expression_unary_sizeof_type
1569 : SIZEOF PAREN_L type_specifier PAREN_R {
1570 auto expr = std::make_unique<Gyoji::frontend::tree::ExpressionUnarySizeofType>(
1571 262 std::move($1),
1572 262 std::move($2),
1573 262 std::move($3),
1574 262 std::move($4)
1575 72 );
1576 262 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
1577 72 $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move(expr), sn);
1578 PRINT_NONTERMINALS($$);
1579 72 }
1580 ;
1581
1582
1583
1584 operator_unary
1585 : ANDPERSAND {
1586 $$ = std::pair(
1587 Gyoji::frontend::tree::ExpressionUnaryPrefix::ADDRESSOF,
1588 std::move($1)
1589 );
1590 PRINT_NONTERMINALS(($$.second));
1591 64 }
1592 64 | STAR {
1593 32 $$ = std::pair(
1594 32 Gyoji::frontend::tree::ExpressionUnaryPrefix::DEREFERENCE,
1595 std::move($1)
1596 );
1597 PRINT_NONTERMINALS(($$.second));
1598 168 }
1599 168 | PLUS {
1600 84 $$ = std::pair(
1601 84 Gyoji::frontend::tree::ExpressionUnaryPrefix::PLUS,
1602 std::move($1)
1603 );
1604 PRINT_NONTERMINALS(($$.second));
1605 ✗ }
1606 ✗ | MINUS {
1607 ✗ $$ = std::pair(
1608 ✗ Gyoji::frontend::tree::ExpressionUnaryPrefix::MINUS,
1609 std::move($1)
1610 );
1611 PRINT_NONTERMINALS(($$.second));
1612 16 }
1613 16 | TILDE {
1614 8 $$ = std::pair(
1615 8 Gyoji::frontend::tree::ExpressionUnaryPrefix::BITWISE_NOT,
1616 std::move($1)
1617 );
1618 PRINT_NONTERMINALS(($$.second));
1619 64 }
1620 64 | BANG {
1621 32 $$ = std::pair(
1622 32 Gyoji::frontend::tree::ExpressionUnaryPrefix::LOGICAL_NOT,
1623 std::move($1)
1624 );
1625 PRINT_NONTERMINALS(($$.second));
1626 68 }
1627 68 ;
1628 34
1629 34 expression_cast
1630 : expression_cast_unary {
1631 4016 $$ = std::move($1);
1632 PRINT_NONTERMINALS($$);
1633 }
1634 | expression_cast_cast {
1635 104 $$ = std::move($1);
1636 PRINT_NONTERMINALS($$);
1637 }
1638 ;
1639
1640 expression_cast_unary
1641 : expression_unary {
1642 4016 $$ = std::move($1);
1643 PRINT_NONTERMINALS($$);
1644 }
1645 ;
1646
1647 expression_cast_cast
1648 : CAST PAREN_L type_specifier COMMA expression PAREN_R {
1649 auto expr = std::make_unique<Gyoji::frontend::tree::ExpressionCast>(
1650 104 std::move($1),
1651 104 std::move($2),
1652 104 std::move($3),
1653 104 std::move($4),
1654 104 std::move($5),
1655 104 std::move($6)
1656 104 );
1657 104 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
1658 104 $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move(expr), sn);
1659 PRINT_NONTERMINALS($$);
1660 104 }
1661 ;
1662
1663
1664 expression_multiplicative
1665 : expression_multiplicative_cast {
1666 3736 $$ = std::move($1);
1667 PRINT_NONTERMINALS($$);
1668 }
1669 | expression_multiplicative_multiply {
1670 104 $$ = std::move($1);
1671 PRINT_NONTERMINALS($$);
1672 }
1673 | expression_multiplicative_divide {
1674 48 $$ = std::move($1);
1675 PRINT_NONTERMINALS($$);
1676 }
1677 | expression_multiplicative_modulo {
1678 42 $$ = std::move($1);
1679 PRINT_NONTERMINALS($$);
1680 }
1681 ;
1682
1683 expression_multiplicative_cast
1684 : expression_cast {
1685 3736 $$ = std::move($1);
1686 PRINT_NONTERMINALS($$);
1687 }
1688 ;
1689 expression_multiplicative_multiply
1690 : expression_multiplicative STAR expression_cast {
1691 auto expr = std::make_unique<Gyoji::frontend::tree::ExpressionBinary>(
1692 104 std::move($1),
1693 104 std::move($2),
1694 104 std::move($3),
1695 104 Gyoji::frontend::tree::ExpressionBinary::MULTIPLY
1696 104 );
1697 104 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
1698 104 $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move(expr), sn);
1699 PRINT_NONTERMINALS($$);
1700 104 }
1701 ;
1702 expression_multiplicative_divide
1703 : expression_multiplicative SLASH expression_cast {
1704 auto expr = std::make_unique<Gyoji::frontend::tree::ExpressionBinary>(
1705 48 std::move($1),
1706 48 std::move($2),
1707 48 std::move($3),
1708 48 Gyoji::frontend::tree::ExpressionBinary::DIVIDE
1709 48 );
1710 48 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
1711 48 $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move(expr), sn);
1712 PRINT_NONTERMINALS($$);
1713 48 }
1714 ;
1715 expression_multiplicative_modulo
1716 : expression_multiplicative PERCENT expression_cast {
1717 auto expr = std::make_unique<Gyoji::frontend::tree::ExpressionBinary>(
1718 42 std::move($1),
1719 42 std::move($2),
1720 42 std::move($3),
1721 42 Gyoji::frontend::tree::ExpressionBinary::MODULO
1722 42 );
1723 42 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
1724 42 $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move(expr), sn);
1725 PRINT_NONTERMINALS($$);
1726 42 }
1727 ;
1728
1729 expression_additive
1730 : expression_additive_multiplicative {
1731 3600 $$ = std::move($1);
1732 PRINT_NONTERMINALS($$);
1733 }
1734 | expression_additive_plus {
1735 88 $$ = std::move($1);
1736 PRINT_NONTERMINALS($$);
1737 }
1738 | expression_additive_minus {
1739 48 $$ = std::move($1);
1740 PRINT_NONTERMINALS($$);
1741 }
1742 ;
1743 expression_additive_multiplicative
1744 : expression_multiplicative {
1745 3600 $$ = std::move($1);
1746 PRINT_NONTERMINALS($$);
1747 }
1748 ;
1749 expression_additive_plus
1750 : expression_additive PLUS expression_multiplicative {
1751 auto expr = std::make_unique<Gyoji::frontend::tree::ExpressionBinary>(
1752 88 std::move($1),
1753 88 std::move($2),
1754 88 std::move($3),
1755 88 Gyoji::frontend::tree::ExpressionBinary::ADD
1756 88 );
1757 88 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
1758 88 $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move(expr), sn);
1759 PRINT_NONTERMINALS($$);
1760 88 }
1761 ;
1762 expression_additive_minus
1763 : expression_additive MINUS expression_multiplicative {
1764 auto expr = std::make_unique<Gyoji::frontend::tree::ExpressionBinary>(
1765 48 std::move($1),
1766 48 std::move($2),
1767 48 std::move($3),
1768 48 Gyoji::frontend::tree::ExpressionBinary::SUBTRACT
1769 48 );
1770 48 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
1771 48 $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move(expr), sn);
1772 PRINT_NONTERMINALS($$);
1773 48 }
1774 ;
1775
1776 expression_shift
1777 : expression_shift_additive {
1778 3568 $$ = std::move($1);
1779 PRINT_NONTERMINALS($$);
1780 }
1781 | expression_shift_left {
1782 8 $$ = std::move($1);
1783 PRINT_NONTERMINALS($$);
1784 }
1785 | expression_shift_right {
1786 24 $$ = std::move($1);
1787 PRINT_NONTERMINALS($$);
1788 }
1789 ;
1790
1791 expression_shift_additive
1792 : expression_additive {
1793 3568 $$ = std::move($1);
1794 PRINT_NONTERMINALS($$);
1795 }
1796 ;
1797 expression_shift_left
1798 : expression_shift LEFT_OP expression_additive {
1799 auto expr = std::make_unique<Gyoji::frontend::tree::ExpressionBinary>(
1800 8 std::move($1),
1801 8 std::move($2),
1802 8 std::move($3),
1803 8 Gyoji::frontend::tree::ExpressionBinary::SHIFT_LEFT
1804 8 );
1805 8 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
1806 8 $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move(expr), sn);
1807 PRINT_NONTERMINALS($$);
1808 8 }
1809 ;
1810 expression_shift_right
1811 : expression_shift RIGHT_OP expression_additive {
1812 auto expr = std::make_unique<Gyoji::frontend::tree::ExpressionBinary>(
1813 24 std::move($1),
1814 24 std::move($2),
1815 24 std::move($3),
1816 24 Gyoji::frontend::tree::ExpressionBinary::SHIFT_RIGHT
1817 24 );
1818 24 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
1819 24 $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move(expr), sn);
1820 PRINT_NONTERMINALS($$);
1821 24 }
1822 ;
1823
1824
1825 expression_relational
1826 : expression_relational_shift {
1827 3514 $$ = std::move($1);
1828 PRINT_NONTERMINALS($$);
1829 }
1830 | expression_relational_lt {
1831 22 $$ = std::move($1);
1832 PRINT_NONTERMINALS($$);
1833 }
1834 | expression_relational_gt {
1835 8 $$ = std::move($1);
1836 PRINT_NONTERMINALS($$);
1837 }
1838 | expression_relational_le {
1839 8 $$ = std::move($1);
1840 PRINT_NONTERMINALS($$);
1841 }
1842 | expression_relational_ge {
1843 16 $$ = std::move($1);
1844 PRINT_NONTERMINALS($$);
1845 }
1846 ;
1847
1848 expression_relational_shift
1849 : expression_shift {
1850 3514 $$ = std::move($1);
1851 PRINT_NONTERMINALS($$);
1852 }
1853 ;
1854 expression_relational_lt
1855 : expression_relational COMPARE_LESS expression_shift {
1856 auto expr = std::make_unique<Gyoji::frontend::tree::ExpressionBinary>(
1857 22 std::move($1),
1858 22 std::move($2),
1859 22 std::move($3),
1860 22 Gyoji::frontend::tree::ExpressionBinary::COMPARE_LESS
1861 22 );
1862 22 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
1863 22 $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move(expr), sn);
1864 PRINT_NONTERMINALS($$);
1865 22 }
1866 ;
1867 expression_relational_gt
1868 : expression_relational COMPARE_GREATER expression_shift {
1869 auto expr = std::make_unique<Gyoji::frontend::tree::ExpressionBinary>(
1870 8 std::move($1),
1871 8 std::move($2),
1872 8 std::move($3),
1873 8 Gyoji::frontend::tree::ExpressionBinary::COMPARE_GREATER
1874 8 );
1875 8 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
1876 8 $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move(expr), sn);
1877 PRINT_NONTERMINALS($$);
1878 8 }
1879 ;
1880 expression_relational_le
1881 : expression_relational COMPARE_LESS_EQUAL expression_shift {
1882 auto expr = std::make_unique<Gyoji::frontend::tree::ExpressionBinary>(
1883 8 std::move($1),
1884 8 std::move($2),
1885 8 std::move($3),
1886 8 Gyoji::frontend::tree::ExpressionBinary::COMPARE_LESS_EQUAL
1887 8 );
1888 8 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
1889 8 $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move(expr), sn);
1890 PRINT_NONTERMINALS($$);
1891 8 }
1892 ;
1893 expression_relational_ge
1894 : expression_relational COMPARE_GREATER_EQUAL expression_shift {
1895 auto expr = std::make_unique<Gyoji::frontend::tree::ExpressionBinary>(
1896 16 std::move($1),
1897 16 std::move($2),
1898 16 std::move($3),
1899 16 Gyoji::frontend::tree::ExpressionBinary::COMPARE_GREATER_EQUAL
1900 16 );
1901 16 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
1902 16 $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move(expr), sn);
1903 PRINT_NONTERMINALS($$);
1904 16 }
1905 ;
1906
1907 expression_equality
1908 : expression_relational {
1909 3282 $$ = std::move($1);
1910 PRINT_NONTERMINALS($$);
1911 }
1912 | expression_equality COMPARE_EQUAL expression_relational {
1913 auto expr = std::make_unique<Gyoji::frontend::tree::ExpressionBinary>(
1914 142 std::move($1),
1915 142 std::move($2),
1916 142 std::move($3),
1917 142 Gyoji::frontend::tree::ExpressionBinary::COMPARE_EQUAL
1918 142 );
1919 142 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
1920 142 $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move(expr), sn);
1921 PRINT_NONTERMINALS($$);
1922 142 }
1923 | expression_equality COMPARE_NOT_EQUAL expression_relational {
1924 auto expr = std::make_unique<Gyoji::frontend::tree::ExpressionBinary>(
1925 90 std::move($1),
1926 90 std::move($2),
1927 90 std::move($3),
1928 90 Gyoji::frontend::tree::ExpressionBinary::COMPARE_NOT_EQUAL
1929 90 );
1930 90 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
1931 90 $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move(expr), sn);
1932 PRINT_NONTERMINALS($$);
1933 90 }
1934 ;
1935
1936 expression_and
1937 : expression_equality {
1938 3266 $$ = std::move($1);
1939 PRINT_NONTERMINALS($$);
1940 }
1941 | expression_and ANDPERSAND expression_equality {
1942 auto expr = std::make_unique<Gyoji::frontend::tree::ExpressionBinary>(
1943 16 std::move($1),
1944 16 std::move($2),
1945 16 std::move($3),
1946 16 Gyoji::frontend::tree::ExpressionBinary::BITWISE_AND
1947 16 );
1948 16 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
1949 16 $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move(expr), sn);
1950 PRINT_NONTERMINALS($$);
1951 16 }
1952 ;
1953
1954 expression_exclusive_or
1955 : expression_and {
1956 3258 $$ = std::move($1);
1957 PRINT_NONTERMINALS($$);
1958 }
1959 | expression_exclusive_or XOR_OP expression_and {
1960 auto expr = std::make_unique<Gyoji::frontend::tree::ExpressionBinary>(
1961 8 std::move($1),
1962 8 std::move($2),
1963 8 std::move($3),
1964 8 Gyoji::frontend::tree::ExpressionBinary::BITWISE_XOR
1965 8 );
1966 8 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
1967 8 $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move(expr), sn);
1968 PRINT_NONTERMINALS($$);
1969 8 }
1970 ;
1971
1972 expression_inclusive_or
1973 : expression_exclusive_or {
1974 3250 $$ = std::move($1);
1975 PRINT_NONTERMINALS($$);
1976 }
1977 | expression_inclusive_or PIPE expression_exclusive_or {
1978 auto expr = std::make_unique<Gyoji::frontend::tree::ExpressionBinary>(
1979 8 std::move($1),
1980 8 std::move($2),
1981 8 std::move($3),
1982 8 Gyoji::frontend::tree::ExpressionBinary::BITWISE_OR
1983 8 );
1984 8 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
1985 8 $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move(expr), sn);
1986 PRINT_NONTERMINALS($$);
1987 8 }
1988 ;
1989
1990 expression_logical_and
1991 : expression_inclusive_or {
1992 3250 $$ = std::move($1);
1993 PRINT_NONTERMINALS($$);
1994 }
1995 | expression_logical_and ANDPERSAND ANDPERSAND expression_inclusive_or {
1996 auto expr = std::make_unique<Gyoji::frontend::tree::ExpressionBinary>(
1997 ✗ std::move($1),
1998 ✗ std::move($2),
1999 ✗ std::move($3),
2000 ✗ std::move($4),
2001 ✗ Gyoji::frontend::tree::ExpressionBinary::LOGICAL_AND
2002 ✗ );
2003 ✗ const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
2004 ✗ $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move(expr), sn);
2005 PRINT_NONTERMINALS($$);
2006 ✗ }
2007 ;
2008
2009 expression_logical_or
2010 : expression_logical_and {
2011 3234 $$ = std::move($1);
2012 PRINT_NONTERMINALS($$);
2013 }
2014 | expression_logical_or OR_OP expression_logical_and {
2015 auto expr = std::make_unique<Gyoji::frontend::tree::ExpressionBinary>(
2016 16 std::move($1),
2017 16 std::move($2),
2018 16 std::move($3),
2019 16 Gyoji::frontend::tree::ExpressionBinary::LOGICAL_OR
2020 16 );
2021 16 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
2022 16 $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move(expr), sn);
2023 PRINT_NONTERMINALS($$);
2024 16 }
2025 ;
2026
2027 expression_conditional
2028 : expression_logical_or {
2029 3234 $$ = std::move($1);
2030 PRINT_NONTERMINALS($$);
2031 }
2032 | expression_logical_or QUESTIONMARK expression COLON expression_conditional {
2033 auto expr = std::make_unique<Gyoji::frontend::tree::ExpressionTrinary>(
2034 ✗ std::move($1),
2035 ✗ std::move($2),
2036 ✗ std::move($3),
2037 ✗ std::move($4),
2038 ✗ std::move($5)
2039 ✗ );
2040 ✗ const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
2041 ✗ $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move(expr), sn);
2042 PRINT_NONTERMINALS($$);
2043 ✗ }
2044 ;
2045
2046 expression_assignment
2047 : expression_conditional {
2048 3234 $$ = std::move($1);
2049 PRINT_NONTERMINALS($$);
2050 }
2051 | expression_unary operator_assignment expression_assignment {
2052 auto expr = std::make_unique<Gyoji::frontend::tree::ExpressionBinary>(
2053 884 std::move($1),
2054 884 std::move($2.second),
2055 std::move($3),
2056 $2.first
2057 );
2058 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
2059 884 $$ = std::make_unique<Gyoji::frontend::tree::Expression>(std::move(expr), sn);
2060 884 PRINT_NONTERMINALS($$);
2061 884 }
2062 ;
2063
2064 operator_assignment
2065 : ASSIGNMENT {
2066 884 $$ = std::pair(
2067 884 Gyoji::frontend::tree::ExpressionBinary::ASSIGNMENT,
2068 884 std::move($1)
2069 884 );
2070 PRINT_NONTERMINALS(($$.second));
2071 2548 }
2072 1664 | MUL_ASSIGNMENT {
2073 832 $$ = std::pair(
2074 832 Gyoji::frontend::tree::ExpressionBinary::MUL_ASSIGNMENT,
2075 std::move($1)
2076 );
2077 PRINT_NONTERMINALS(($$.second));
2078 16 }
2079 16 | DIV_ASSIGNMENT {
2080 8 $$ = std::pair(
2081 8 Gyoji::frontend::tree::ExpressionBinary::DIV_ASSIGNMENT,
2082 std::move($1)
2083 );
2084 PRINT_NONTERMINALS(($$.second));
2085 16 }
2086 16 | MOD_ASSIGNMENT {
2087 8 $$ = std::pair(
2088 8 Gyoji::frontend::tree::ExpressionBinary::MOD_ASSIGNMENT,
2089 std::move($1)
2090 );
2091 PRINT_NONTERMINALS(($$.second));
2092 ✗ }
2093 ✗ | ADD_ASSIGNMENT {
2094 ✗ $$ = std::pair(
2095 ✗ Gyoji::frontend::tree::ExpressionBinary::ADD_ASSIGNMENT,
2096 std::move($1)
2097 );
2098 PRINT_NONTERMINALS(($$.second));
2099 24 }
2100 24 | SUB_ASSIGNMENT {
2101 12 $$ = std::pair(
2102 12 Gyoji::frontend::tree::ExpressionBinary::SUB_ASSIGNMENT,
2103 std::move($1)
2104 );
2105 PRINT_NONTERMINALS(($$.second));
2106 16 }
2107 16 | LEFT_ASSIGNMENT {
2108 8 $$ = std::pair(
2109 8 Gyoji::frontend::tree::ExpressionBinary::LEFT_ASSIGNMENT,
2110 std::move($1)
2111 );
2112 PRINT_NONTERMINALS(($$.second));
2113 16 }
2114 16 | RIGHT_ASSIGNMENT {
2115 8 $$ = std::pair(
2116 8 Gyoji::frontend::tree::ExpressionBinary::RIGHT_ASSIGNMENT,
2117 std::move($1)
2118 );
2119 PRINT_NONTERMINALS(($$.second));
2120 16 }
2121 16 | AND_ASSIGNMENT {
2122 8 $$ = std::pair(
2123 8 Gyoji::frontend::tree::ExpressionBinary::AND_ASSIGNMENT,
2124 std::move($1)
2125 );
2126 PRINT_NONTERMINALS(($$.second));
2127 ✗ }
2128 ✗ | XOR_ASSIGNMENT {
2129 ✗ $$ = std::pair(
2130 ✗ Gyoji::frontend::tree::ExpressionBinary::XOR_ASSIGNMENT,
2131 std::move($1)
2132 );
2133 PRINT_NONTERMINALS(($$.second));
2134 ✗ }
2135 ✗ | OR_ASSIGNMENT {
2136 ✗ $$ = std::pair(
2137 ✗ Gyoji::frontend::tree::ExpressionBinary::OR_ASSIGNMENT,
2138 std::move($1)
2139 );
2140 PRINT_NONTERMINALS(($$.second));
2141 ✗ }
2142 ✗ ;
2143 ✗
2144 ✗ expression
2145 : expression_assignment {
2146 3234 $$ = std::move($1);
2147 PRINT_NONTERMINALS($$);
2148 }
2149 ;
2150
2151
2152 type_name
2153 : TYPEOF PAREN_L expression PAREN_R {
2154 32 $$ = std::make_unique<Gyoji::frontend::tree::TypeName>(
2155 16 std::move($1),
2156 16 std::move($2),
2157 16 std::move($3),
2158 16 std::move($4)
2159 16 );
2160 PRINT_NONTERMINALS($$);
2161 }
2162 | TYPE_NAME {
2163 6056 $$ = std::make_unique<Gyoji::frontend::tree::TypeName>(
2164 3028 std::move($1)
2165 3028 );
2166 PRINT_NONTERMINALS($$);
2167 }
2168 ;
2169
2170 opt_class_member_declaration_list
2171 : /**/ {
2172 ✗ $$ = std::make_unique<Gyoji::frontend::tree::ClassMemberDeclarationList>(return_data.compiler_context.get_token_stream().get_current_source_ref());
2173 PRINT_NONTERMINALS($$);
2174 }
2175 | class_member_declaration_list {
2176 128 $$ = std::move($1);
2177 PRINT_NONTERMINALS($$);
2178 }
2179 ;
2180
2181 class_member_declaration_list
2182 : class_member_declaration {
2183 128 $$ = std::make_unique<Gyoji::frontend::tree::ClassMemberDeclarationList>($1->get_source_ref());
2184 128 $$->add_member(std::move($1));
2185 PRINT_NONTERMINALS($$);
2186 }
2187 | class_member_declaration_list class_member_declaration {
2188 188 $$ = std::move($1);
2189 188 $$->add_member(std::move($2));
2190 PRINT_NONTERMINALS($$);
2191 }
2192 ;
2193
2194 class_member_declaration
2195 : opt_access_modifier type_specifier IDENTIFIER SEMICOLON {
2196 // Member Variable
2197 258 $3->set_identifier_type(Gyoji::frontend::tree::Terminal::IDENTIFIER_LOCAL_SCOPE);
2198 258 NS2Entity *entity = return_data.identifier_get_or_create($3->get_value(), false, $3->get_source_ref());
2199 258 $3->set_ns2_entity(entity);
2200 auto expr = std::make_unique<Gyoji::frontend::tree::ClassMemberDeclarationVariable>(
2201 258 std::move($1),
2202 258 std::move($2),
2203 258 std::move($3),
2204 258 std::move($4)
2205 258 );
2206 258 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
2207 258 $$ = std::make_unique<Gyoji::frontend::tree::ClassMemberDeclaration>(std::move(expr), sn);
2208 PRINT_NONTERMINALS($$);
2209 258 }
2210 | opt_access_modifier type_specifier IDENTIFIER PAREN_L opt_function_definition_arg_list PAREN_R SEMICOLON {
2211 // Method
2212 10 $3->set_identifier_type(Gyoji::frontend::tree::Terminal::IDENTIFIER_LOCAL_SCOPE);
2213 10 NS2Entity *entity = return_data.identifier_get_or_create($3->get_value(), false, $3->get_source_ref());
2214 10 $3->set_ns2_entity(entity);
2215 auto expr = std::make_unique<Gyoji::frontend::tree::ClassMemberDeclarationMethod>(
2216 10 std::move($1),
2217 10 std::move($2),
2218 10 std::move($3),
2219 10 std::move($4),
2220 10 std::move($5),
2221 10 std::move($6),
2222 10 std::move($7)
2223 10 );
2224 10 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
2225 10 $$ = std::make_unique<Gyoji::frontend::tree::ClassMemberDeclaration>(std::move(expr), sn);
2226 PRINT_NONTERMINALS($$);
2227 10 }
2228 | opt_access_modifier type_specifier PAREN_L opt_function_definition_arg_list PAREN_R SEMICOLON {
2229 // Constructor
2230 auto expr = std::make_unique<Gyoji::frontend::tree::ClassMemberDeclarationConstructor>(
2231 8 std::move($1),
2232 8 std::move($2),
2233 8 std::move($3),
2234 8 std::move($4),
2235 8 std::move($5),
2236 8 std::move($6)
2237 8 );
2238 8 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
2239 8 $$ = std::make_unique<Gyoji::frontend::tree::ClassMemberDeclaration>(std::move(expr), sn);
2240 PRINT_NONTERMINALS($$);
2241 8 }
2242 | opt_access_modifier TILDE type_specifier PAREN_L opt_function_definition_arg_list PAREN_R SEMICOLON {
2243 // Destructor
2244 auto expr = std::make_unique<Gyoji::frontend::tree::ClassMemberDeclarationDestructor>(
2245 8 std::move($1),
2246 8 std::move($2),
2247 8 std::move($3),
2248 8 std::move($4),
2249 8 std::move($5),
2250 8 std::move($6),
2251 8 std::move($7)
2252 8 );
2253 8 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
2254 8 $$ = std::make_unique<Gyoji::frontend::tree::ClassMemberDeclaration>(std::move(expr), sn);
2255 PRINT_NONTERMINALS($$);
2256 8 }
2257 | class_declaration {
2258 ✗ const Gyoji::frontend::ast::SyntaxNode &sn = *($1);
2259 ✗ $$ = std::make_unique<Gyoji::frontend::tree::ClassMemberDeclaration>(std::move($1), sn);
2260 PRINT_NONTERMINALS($$);
2261 }
2262 | class_definition {
2263 16 const Gyoji::frontend::ast::SyntaxNode &sn = *($1);
2264 16 $$ = std::make_unique<Gyoji::frontend::tree::ClassMemberDeclaration>(std::move($1), sn);
2265 PRINT_NONTERMINALS($$);
2266 }
2267 | enum_definition {
2268 8 const Gyoji::frontend::ast::SyntaxNode &sn = *($1);
2269 8 $$ = std::make_unique<Gyoji::frontend::tree::ClassMemberDeclaration>(std::move($1), sn);
2270 PRINT_NONTERMINALS($$);
2271 }
2272 | type_definition {
2273 8 const Gyoji::frontend::ast::SyntaxNode &sn = *($1);
2274 8 $$ = std::make_unique<Gyoji::frontend::tree::ClassMemberDeclaration>(std::move($1), sn);
2275 PRINT_NONTERMINALS($$);
2276 }
2277 ;
2278
2279
2280 type_access_qualifier
2281 : /**/ {
2282 3422 $$ = std::make_unique<Gyoji::frontend::tree::AccessQualifier>(return_data.compiler_context.get_token_stream().get_current_source_ref());
2283 PRINT_NONTERMINALS($$);
2284 }
2285 | CONST {
2286 192 $$ = std::make_unique<Gyoji::frontend::tree::AccessQualifier>(
2287 96 std::move($1)
2288 96 );
2289 PRINT_NONTERMINALS($$);
2290 }
2291 | VOLATILE {
2292 172 $$ = std::make_unique<Gyoji::frontend::tree::AccessQualifier>(
2293 86 std::move($1)
2294 86 );
2295 PRINT_NONTERMINALS($$);
2296 }
2297 ;
2298
2299 type_specifier_call_args
2300 : type_specifier {
2301 24 $$ = std::make_unique<Gyoji::frontend::tree::TypeSpecifierCallArgs>(return_data.compiler_context.get_token_stream().get_current_source_ref());
2302 24 $$->add_argument(std::move($1));
2303 PRINT_NONTERMINALS($$);
2304 }
2305 | type_specifier_call_args COMMA type_specifier {
2306 8 $$ = std::move($1);
2307 8 $$->add_argument(std::move($2), std::move($3));
2308 PRINT_NONTERMINALS($$);
2309 }
2310 ;
2311
2312 type_specifier
2313 : type_access_qualifier type_name {
2314 auto expr = std::make_unique<Gyoji::frontend::tree::TypeSpecifierSimple>(
2315 3044 std::move($1),
2316 3044 std::move($2)
2317 3044 );
2318 3044 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
2319 3044 $$ = std::make_unique<Gyoji::frontend::tree::TypeSpecifier>(std::move(expr), sn);
2320 PRINT_NONTERMINALS($$);
2321 3044 }
2322 | type_specifier BRACKET_L LITERAL_INT BRACKET_R {
2323 auto expr = std::make_unique<Gyoji::frontend::tree::TypeSpecifierArray>(
2324 10 std::move($1),
2325 10 std::move($2),
2326 10 std::move($3),
2327 10 std::move($4)
2328 10 );
2329 10 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
2330 10 $$ = std::make_unique<Gyoji::frontend::tree::TypeSpecifier>(std::move(expr), sn);
2331 PRINT_NONTERMINALS($$);
2332 10 }
2333 | type_specifier PAREN_L type_specifier_call_args PAREN_R {
2334 auto expr = std::make_unique<Gyoji::frontend::tree::TypeSpecifierTemplate>(
2335 24 std::move($1),
2336 24 std::move($2),
2337 24 std::move($3),
2338 24 std::move($4)
2339 24 );
2340 24 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
2341 24 $$ = std::make_unique<Gyoji::frontend::tree::TypeSpecifier>(std::move(expr), sn);
2342 PRINT_NONTERMINALS($$);
2343 24 }
2344 | type_specifier PAREN_L STAR IDENTIFIER PAREN_R PAREN_L opt_function_definition_arg_list PAREN_R {
2345 8 NS2Entity *entity = return_data.type_get_or_create($4->get_value(), $4->get_source_ref());
2346 8 $4->set_ns2_entity(entity);
2347 auto expr = std::make_unique<Gyoji::frontend::tree::TypeSpecifierFunctionPointer>(
2348 8 std::move($1),
2349 8 std::move($2),
2350 8 std::move($3),
2351 8 std::move($4),
2352 8 std::move($5),
2353 8 std::move($6),
2354 8 std::move($7),
2355 8 std::move($8)
2356 8 );
2357 8 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
2358 8 $$ = std::make_unique<Gyoji::frontend::tree::TypeSpecifier>(std::move(expr), sn);
2359 PRINT_NONTERMINALS($$);
2360 8 }
2361 | type_specifier STAR type_access_qualifier {
2362 auto expr = std::make_unique<Gyoji::frontend::tree::TypeSpecifierPointerTo>(
2363 510 std::move($1),
2364 510 std::move($2),
2365 510 std::move($3)
2366 510 );
2367 510 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
2368 510 $$ = std::make_unique<Gyoji::frontend::tree::TypeSpecifier>(std::move(expr), sn);
2369 PRINT_NONTERMINALS($$);
2370 510 }
2371 | type_specifier ANDPERSAND type_access_qualifier {
2372 auto expr = std::make_unique<Gyoji::frontend::tree::TypeSpecifierReferenceTo>(
2373 50 std::move($1),
2374 50 std::move($2),
2375 50 std::move($3)
2376 50 );
2377 50 const Gyoji::frontend::ast::SyntaxNode &sn = *(expr);
2378 50 $$ = std::make_unique<Gyoji::frontend::tree::TypeSpecifier>(std::move(expr), sn);
2379 PRINT_NONTERMINALS($$);
2380 50 }
2381 ;
2382
2383 opt_argument_expression_list
2384 : /**/ {
2385 266 $$ = std::make_unique<Gyoji::frontend::tree::ArgumentExpressionList>(return_data.compiler_context.get_token_stream().get_current_source_ref());
2386 PRINT_NONTERMINALS($$);
2387 }
2388 | argument_expression_list {
2389 184 $$ = std::move($1);
2390 PRINT_NONTERMINALS($$);
2391 }
2392 ;
2393
2394 argument_expression_list
2395 : expression {
2396 184 $$ = std::make_unique<Gyoji::frontend::tree::ArgumentExpressionList>($1->get_source_ref());
2397 184 $$->add_argument(std::move($1));
2398 PRINT_NONTERMINALS($$);
2399 }
2400 | argument_expression_list COMMA expression {
2401 76 $$ = std::move($1);
2402 76 $$->add_argument(std::move($2), std::move($3));
2403 PRINT_NONTERMINALS($$);
2404 }
2405 ;
2406
2407 %%
2408
2409 2 void Gyoji::frontend::yacc::YaccParser::error(const std::string& msg) {
2410 2 LexContext *lex_context = (LexContext*)yyget_extra(scanner);
2411
2412 2 const SourceReference & src_ref = lex_context->compiler_context.get_token_stream().get_current_source_ref();
2413
2414 // We don't directly print an error here, we report it
2415 // to the error reporting system so that it can
2416 // write error information when it needs to, presumably
2417 // after collecting possibly multiple errors
2418
2419 // We want to consume more context from the next few
2420 // lines so we can produce a good syntax error with
2421 // following context.
2422 #if 0
2423 size_t error_context_lines = 5;
2424 while (true) {
2425 Gyoji::frontend::yacc::YaccParser::semantic_type lvalue;
2426 int rc = yylex (&lvalue, scanner);
2427 if (rc == 0) {
2428 break;
2429 }
2430 const SourceReference & cur_ref = lex_context->compiler_context.get_token_stream().get_current_source_ref();
2431 if (cur_ref.get_line() - src_ref.get_line() >= error_context_lines) {
2432 break;
2433 }
2434 }
2435 #endif
2436 2 auto error = std::make_unique<Gyoji::context::Error>("Syntax Error");
2437 2 error->add_message(src_ref, msg);
2438 2 return_data.compiler_context.get_errors().add_error(std::move(error));
2439 2 }
2440