GCC Code Coverage Report

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