1 #include "Expression.hpp"
2 #include <soulng/util/Unicode.hpp>
3 #include <sngcpp/parser/Declarator.hpp>
4 #include <sngcpp/parser/Function.hpp>
5 #include <sngcpp/parser/Identifier.hpp>
6 #include <sngcpp/parser/Literal.hpp>
7 #include <sngcpp/parser/SimpleType.hpp>
8 #include <sngcpp/parser/Statement.hpp>
9 #include <sngcpp/parser/Template.hpp>
10 #include <sngcpp/parser/TypeExpr.hpp>
11 #include <sngcpp/lexer/CppLexer.hpp>
12 #include <sngcpp/lexer/CppTokens.hpp>
13
14
15
16 using namespace soulng::unicode;
17 using namespace CppTokens;
18 using namespace soulng::lexer;
19
20 std::std::unique_ptr<sngcpp::ast::Node>ExpressionParser::Parse(CppLexer&lexer, sngcpp::cppparser::ParsingContext*ctx)
21 {
22 std::unique_ptr<sngcpp::ast::Node> value;
23 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
24
25
26
27
28
29 #endif // SOULNG_PARSER_DEBUG_SUPPORT
30 ++lexer;
31 soulng::lexer::Span span = lexer.GetSpan();
32 soulng::parser::Match match = ExpressionParser::Expression(lexer, ctx);
33 value.reset(static_cast<sngcpp::ast::Node*>(match.value));
34 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
35
36
37
38
39
40 #endif // SOULNG_PARSER_DEBUG_SUPPORT
41 if (match.hit)
42 {
43 if (*lexer == soulng::lexer::END_TOKEN)
44 {
45 return value;
46 }
47 else
48 {
49 lexer.ThrowExpectationFailure(lexer.GetSpan(), ToUtf32(soulng::lexer::GetEndTokenInfo()));
50 }
51 }
52 else
53 {
54 lexer.ThrowExpectationFailure(span, U"Expression");
55 }
56 return value;
57 }
58
59 soulng::parser::Match ExpressionParser::Expression(CppLexer& lexer, sngcpp::cppparser::ParsingContext* ctx)
60 {
61 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
62
63
64
65
66
67
68
69 #endif // SOULNG_PARSER_DEBUG_SUPPORT
70 std::unique_ptr<sngcpp::ast::Node> expr = std::unique_ptr<sngcpp::ast::Node>();
71 Span s = Span();
72 std::unique_ptr<sngcpp::ast::Node> left;
73 std::unique_ptr<sngcpp::ast::Node> right;
74 soulng::parser::Match match(false);
75 soulng::parser::Match* parentMatch0 = &match;
76 {
77 int64_t pos = lexer.GetPos();
78 soulng::parser::Match match(false);
79 soulng::parser::Match* parentMatch1 = &match;
80 {
81 soulng::parser::Match match(false);
82 soulng::parser::Match* parentMatch2 = &match;
83 {
84 soulng::parser::Match match(false);
85 soulng::parser::Match* parentMatch3 = &match;
86 {
87 int64_t pos = lexer.GetPos();
88 soulng::lexer::Span span = lexer.GetSpan();
89 soulng::parser::Match match = ExpressionParser::AssignmentExpression(lexer, ctx);
90 left.reset(static_cast<sngcpp::ast::Node*>(match.value));
91 if (match.hit)
92 {
93 expr.reset(left.release());
94 s = span;
95 }
96 *parentMatch3 = match;
97 }
98 *parentMatch2 = match;
99 }
100 if (match.hit)
101 {
102 soulng::parser::Match match(false);
103 soulng::parser::Match* parentMatch4 = &match;
104 {
105 soulng::parser::Match match(true);
106 soulng::parser::Match* parentMatch5 = &match;
107 {
108 while (true)
109 {
110 int64_t save = lexer.GetPos();
111 {
112 soulng::parser::Match match(false);
113 soulng::parser::Match* parentMatch6 = &match;
114 {
115 soulng::parser::Match match(false);
116 soulng::parser::Match* parentMatch7 = &match;
117 {
118 soulng::parser::Match match(false);
119 if (*lexer == COMMA)
120 {
121 ++lexer;
122 match.hit = true;
123 }
124 *parentMatch7 = match;
125 }
126 if (match.hit)
127 {
128 soulng::parser::Match match(false);
129 soulng::parser::Match* parentMatch8 = &match;
130 {
131 soulng::parser::Match match(false);
132 soulng::parser::Match* parentMatch9 = &match;
133 {
134 int64_t pos = lexer.GetPos();
135 soulng::lexer::Span span = lexer.GetSpan();
136 soulng::parser::Match match = ExpressionParser::AssignmentExpression(lexer, ctx);
137 right.reset(static_cast<sngcpp::ast::Node*>(match.value));
138 if (match.hit)
139 {
140 s.end = span.end;
141 expr.reset(new sngcpp::ast::CommaExpressionNode(s, expr.release(), right.release()));
142 }
143 *parentMatch9 = match;
144 }
145 *parentMatch8 = match;
146 }
147 *parentMatch7 = match;
148 }
149 *parentMatch6 = match;
150 }
151 if (match.hit)
152 {
153 *parentMatch5 = match;
154 }
155 else
156 {
157 lexer.SetPos(save);
158 break;
159 }
160 }
161 }
162 }
163 *parentMatch4 = match;
164 }
165 *parentMatch2 = match;
166 }
167 *parentMatch1 = match;
168 }
169 if (match.hit)
170 {
171 {
172 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
173
174 #endif // SOULNG_PARSER_DEBUG_SUPPORT
175 return soulng::parser::Match(true, expr.release());
176 }
177 }
178 *parentMatch0 = match;
179 }
180 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
181
182
183
184
185
186 #endif // SOULNG_PARSER_DEBUG_SUPPORT
187 if (!match.hit)
188 {
189 match.value = nullptr;
190 }
191 return match;
192 }
193
194 soulng::parser::Match ExpressionParser::ConstantExpression(CppLexer& lexer, sngcpp::cppparser::ParsingContext* ctx)
195 {
196 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
197
198
199
200
201
202
203
204 #endif // SOULNG_PARSER_DEBUG_SUPPORT
205 std::unique_ptr<sngcpp::ast::Node> expr;
206 soulng::parser::Match match(false);
207 soulng::parser::Match* parentMatch0 = &match;
208 {
209 int64_t pos = lexer.GetPos();
210 soulng::parser::Match match = ExpressionParser::ConditionalExpression(lexer, ctx);
211 expr.reset(static_cast<sngcpp::ast::Node*>(match.value));
212 if (match.hit)
213 {
214 {
215 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
216
217 #endif // SOULNG_PARSER_DEBUG_SUPPORT
218 return soulng::parser::Match(true, expr.release());
219 }
220 }
221 *parentMatch0 = match;
222 }
223 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
224
225
226
227
228
229 #endif // SOULNG_PARSER_DEBUG_SUPPORT
230 if (!match.hit)
231 {
232 match.value = nullptr;
233 }
234 return match;
235 }
236
237 soulng::parser::Match ExpressionParser::AssignmentExpression(CppLexer& lexer, sngcpp::cppparser::ParsingContext* ctx)
238 {
239 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
240
241
242
243
244
245
246
247 #endif // SOULNG_PARSER_DEBUG_SUPPORT
248 std::unique_ptr<sngcpp::ast::Node> expr = std::unique_ptr<sngcpp::ast::Node>();
249 Span s = Span();
250 std::unique_ptr<sngcpp::ast::Node> logicalOrExpression;
251 std::unique_ptr<soulng::parser::soulng::parser::Value<sngcpp::ast::Operator>>op;
252 std::unique_ptr<sngcpp::ast::Node> initializerClause;
253 std::unique_ptr<sngcpp::ast::Node> conditionalExpression;
254 std::unique_ptr<sngcpp::ast::Node> throwExpression;
255 soulng::parser::Match match(false);
256 soulng::parser::Match* parentMatch0 = &match;
257 {
258 soulng::parser::Match match(false);
259 soulng::parser::Match* parentMatch1 = &match;
260 {
261 int64_t pos = lexer.GetPos();
262 soulng::parser::Match match(true);
263 if (match.hit)
264 {
265 ctx->BeginParsingLvalue();
266 }
267 *parentMatch1 = match;
268 }
269 *parentMatch0 = match;
270 }
271 if (match.hit)
272 {
273 soulng::parser::Match match(false);
274 soulng::parser::Match* parentMatch2 = &match;
275 {
276 soulng::parser::Match match(false);
277 soulng::parser::Match* parentMatch3 = &match;
278 {
279 int64_t pos = lexer.GetPos();
280 soulng::parser::Match match(false);
281 soulng::parser::Match* parentMatch4 = &match;
282 {
283 soulng::parser::Match match(false);
284 soulng::parser::Match* parentMatch5 = &match;
285 {
286 int64_t save = lexer.GetPos();
287 soulng::parser::Match match(false);
288 soulng::parser::Match* parentMatch6 = &match;
289 {
290 int64_t save = lexer.GetPos();
291 soulng::parser::Match match(false);
292 soulng::parser::Match* parentMatch7 = &match;
293 {
294 soulng::parser::Match match(false);
295 soulng::parser::Match* parentMatch8 = &match;
296 {
297 soulng::parser::Match match(false);
298 soulng::parser::Match* parentMatch9 = &match;
299 {
300 int64_t pos = lexer.GetPos();
301 soulng::lexer::Span span = lexer.GetSpan();
302 soulng::parser::Match match = ExpressionParser::LogicalOrExpression(lexer, ctx);
303 logicalOrExpression.reset(static_cast<sngcpp::ast::Node*>(match.value));
304 if (match.hit)
305 {
306 s = span;
307 ctx->EndParsingLvalue();
308 expr.reset(logicalOrExpression.release());
309 }
310 else
311 {
312 ctx->EndParsingLvalue();
313 }
314 *parentMatch9 = match;
315 }
316 *parentMatch8 = match;
317 }
318 if (match.hit)
319 {
320 soulng::parser::Match match(false);
321 soulng::parser::Match* parentMatch10 = &match;
322 {
323 soulng::parser::Match match = ExpressionParser::AssignmentOperator(lexer);
324 op.reset(static_cast<soulng::parser::soulng::parser::Value<sngcpp::ast::Operator>*>(match.value));
325 *parentMatch10 = match;
326 }
327 *parentMatch8 = match;
328 }
329 *parentMatch7 = match;
330 }
331 if (match.hit)
332 {
333 soulng::parser::Match match(false);
334 soulng::parser::Match* parentMatch11 = &match;
335 {
336 soulng::parser::Match match(false);
337 soulng::parser::Match* parentMatch12 = &match;
338 {
339 int64_t pos = lexer.GetPos();
340 soulng::lexer::Span span = lexer.GetSpan();
341 soulng::parser::Match match = DeclaratorParser::InitializerClause(lexer, ctx);
342 initializerClause.reset(static_cast<sngcpp::ast::Node*>(match.value));
343 if (match.hit)
344 {
345 s.end = span.end;
346 expr.reset(new sngcpp::ast::AssignmentExpressionNode(s, expr.release(), op->value, initializerClause.release()));
347 }
348 *parentMatch12 = match;
349 }
350 *parentMatch11 = match;
351 }
352 *parentMatch7 = match;
353 }
354 *parentMatch6 = match;
355 if (!match.hit)
356 {
357 soulng::parser::Match match(false);
358 soulng::parser::Match* parentMatch13 = &match;
359 lexer.SetPos(save);
360 {
361 soulng::parser::Match match(false);
362 soulng::parser::Match* parentMatch14 = &match;
363 {
364 int64_t pos = lexer.GetPos();
365 soulng::parser::Match match = ExpressionParser::ConditionalExpression(lexer, ctx);
366 conditionalExpression.reset(static_cast<sngcpp::ast::Node*>(match.value));
367 if (match.hit)
368 {
369 expr.reset(conditionalExpression.release());
370 }
371 *parentMatch14 = match;
372 }
373 *parentMatch13 = match;
374 }
375 *parentMatch6 = match;
376 }
377 }
378 *parentMatch5 = match;
379 if (!match.hit)
380 {
381 soulng::parser::Match match(false);
382 soulng::parser::Match* parentMatch15 = &match;
383 lexer.SetPos(save);
384 {
385 soulng::parser::Match match(false);
386 soulng::parser::Match* parentMatch16 = &match;
387 {
388 int64_t pos = lexer.GetPos();
389 soulng::parser::Match match = ExpressionParser::ThrowExpression(lexer, ctx);
390 throwExpression.reset(static_cast<sngcpp::ast::Node*>(match.value));
391 if (match.hit)
392 {
393 expr.reset(throwExpression.release());
394 }
395 *parentMatch16 = match;
396 }
397 *parentMatch15 = match;
398 }
399 *parentMatch5 = match;
400 }
401 }
402 *parentMatch4 = match;
403 }
404 if (match.hit)
405 {
406 {
407 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
408
409 #endif // SOULNG_PARSER_DEBUG_SUPPORT
410 return soulng::parser::Match(true, expr.release());
411 }
412 }
413 *parentMatch3 = match;
414 }
415 *parentMatch2 = match;
416 }
417 *parentMatch0 = match;
418 }
419 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
420
421
422
423
424
425 #endif // SOULNG_PARSER_DEBUG_SUPPORT
426 if (!match.hit)
427 {
428 match.value = nullptr;
429 }
430 return match;
431 }
432
433 soulng::parser::Match ExpressionParser::AssignmentOperator(CppLexer& lexer)
434 {
435 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
436
437
438
439
440
441
442
443 #endif // SOULNG_PARSER_DEBUG_SUPPORT
444 soulng::parser::Match match(false);
445 int64_t pos = lexer.GetPos();
446 soulng::lexer::Span span = lexer.GetSpan();
447 switch (*lexer)
448 {
449 case ASSIGN:
450 {
451 ++lexer;
452 {
453 {
454 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
455
456 #endif // SOULNG_PARSER_DEBUG_SUPPORT
457 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::assign));
458 }
459 }
460 break;
461 }
462 case MULASSIGN:
463 {
464 ++lexer;
465 {
466 {
467 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
468
469 #endif // SOULNG_PARSER_DEBUG_SUPPORT
470 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::mulAssign));
471 }
472 }
473 break;
474 }
475 case DIVASSIGN:
476 {
477 ++lexer;
478 {
479 {
480 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
481
482 #endif // SOULNG_PARSER_DEBUG_SUPPORT
483 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::divAssign));
484 }
485 }
486 break;
487 }
488 case REMASSIGN:
489 {
490 ++lexer;
491 {
492 {
493 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
494
495 #endif // SOULNG_PARSER_DEBUG_SUPPORT
496 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::remAssign));
497 }
498 }
499 break;
500 }
501 case ADDASSIGN:
502 {
503 ++lexer;
504 {
505 {
506 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
507
508 #endif // SOULNG_PARSER_DEBUG_SUPPORT
509 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::addAssign));
510 }
511 }
512 break;
513 }
514 case SUBASSIGN:
515 {
516 ++lexer;
517 {
518 {
519 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
520
521 #endif // SOULNG_PARSER_DEBUG_SUPPORT
522 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::subAssign));
523 }
524 }
525 break;
526 }
527 case SHIFTRIGHTASSIGN:
528 {
529 ++lexer;
530 {
531 {
532 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
533
534 #endif // SOULNG_PARSER_DEBUG_SUPPORT
535 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::shiftRightAssign));
536 }
537 }
538 break;
539 }
540 case SHIFTLEFTASSIGN:
541 {
542 ++lexer;
543 {
544 {
545 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
546
547 #endif // SOULNG_PARSER_DEBUG_SUPPORT
548 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::shiftLeftAssign));
549 }
550 }
551 break;
552 }
553 case ANDASSIGN:
554 {
555 ++lexer;
556 {
557 {
558 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
559
560 #endif // SOULNG_PARSER_DEBUG_SUPPORT
561 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::andAssign));
562 }
563 }
564 break;
565 }
566 case XORASSIGN:
567 {
568 ++lexer;
569 {
570 {
571 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
572
573 #endif // SOULNG_PARSER_DEBUG_SUPPORT
574 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::xorAssign));
575 }
576 }
577 break;
578 }
579 case ORASSIGN:
580 {
581 ++lexer;
582 {
583 {
584 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
585
586 #endif // SOULNG_PARSER_DEBUG_SUPPORT
587 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::orAssign));
588 }
589 }
590 break;
591 }
592 }
593 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
594
595
596
597
598
599 #endif // SOULNG_PARSER_DEBUG_SUPPORT
600 if (!match.hit)
601 {
602 match.value = nullptr;
603 }
604 return match;
605 }
606
607 soulng::parser::Match ExpressionParser::ConditionalExpression(CppLexer& lexer, sngcpp::cppparser::ParsingContext* ctx)
608 {
609 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
610
611
612
613
614
615
616
617 #endif // SOULNG_PARSER_DEBUG_SUPPORT
618 std::unique_ptr<sngcpp::ast::Node> expr = std::unique_ptr<sngcpp::ast::Node>();
619 Span s = Span();
620 std::unique_ptr<sngcpp::ast::Node> logicalOrExpression;
621 std::unique_ptr<sngcpp::ast::Node> thenExpr;
622 std::unique_ptr<sngcpp::ast::Node> elseExpr;
623 soulng::parser::Match match(false);
624 soulng::parser::Match* parentMatch0 = &match;
625 {
626 int64_t pos = lexer.GetPos();
627 soulng::parser::Match match(false);
628 soulng::parser::Match* parentMatch1 = &match;
629 {
630 soulng::parser::Match match(false);
631 soulng::parser::Match* parentMatch2 = &match;
632 {
633 soulng::parser::Match match(false);
634 soulng::parser::Match* parentMatch3 = &match;
635 {
636 int64_t pos = lexer.GetPos();
637 soulng::lexer::Span span = lexer.GetSpan();
638 soulng::parser::Match match = ExpressionParser::LogicalOrExpression(lexer, ctx);
639 logicalOrExpression.reset(static_cast<sngcpp::ast::Node*>(match.value));
640 if (match.hit)
641 {
642 expr.reset(logicalOrExpression.release());
643 s = span;
644 }
645 *parentMatch3 = match;
646 }
647 *parentMatch2 = match;
648 }
649 if (match.hit)
650 {
651 soulng::parser::Match match(false);
652 soulng::parser::Match* parentMatch4 = &match;
653 {
654 soulng::parser::Match match(true);
655 int64_t save = lexer.GetPos();
656 soulng::parser::Match* parentMatch5 = &match;
657 {
658 soulng::parser::Match match(false);
659 soulng::parser::Match* parentMatch6 = &match;
660 {
661 soulng::parser::Match match(false);
662 soulng::parser::Match* parentMatch7 = &match;
663 {
664 soulng::parser::Match match(false);
665 soulng::parser::Match* parentMatch8 = &match;
666 {
667 soulng::parser::Match match(false);
668 soulng::parser::Match* parentMatch9 = &match;
669 {
670 soulng::parser::Match match(false);
671 if (*lexer == QUEST)
672 {
673 ++lexer;
674 match.hit = true;
675 }
676 *parentMatch9 = match;
677 }
678 if (match.hit)
679 {
680 soulng::parser::Match match(false);
681 soulng::parser::Match* parentMatch10 = &match;
682 {
683 soulng::parser::Match match = ExpressionParser::Expression(lexer, ctx);
684 thenExpr.reset(static_cast<sngcpp::ast::Node*>(match.value));
685 *parentMatch10 = match;
686 }
687 *parentMatch9 = match;
688 }
689 *parentMatch8 = match;
690 }
691 if (match.hit)
692 {
693 soulng::parser::Match match(false);
694 soulng::parser::Match* parentMatch11 = &match;
695 {
696 soulng::parser::Match match(false);
697 if (*lexer == COLON)
698 {
699 ++lexer;
700 match.hit = true;
701 }
702 *parentMatch11 = match;
703 }
704 *parentMatch8 = match;
705 }
706 *parentMatch7 = match;
707 }
708 if (match.hit)
709 {
710 soulng::parser::Match match(false);
711 soulng::parser::Match* parentMatch12 = &match;
712 {
713 soulng::parser::Match match(false);
714 soulng::parser::Match* parentMatch13 = &match;
715 {
716 int64_t pos = lexer.GetPos();
717 soulng::lexer::Span span = lexer.GetSpan();
718 soulng::parser::Match match = ExpressionParser::AssignmentExpression(lexer, ctx);
719 elseExpr.reset(static_cast<sngcpp::ast::Node*>(match.value));
720 if (match.hit)
721 {
722 s.end = span.end;
723 expr.reset(new sngcpp::ast::ConditionalExpressionNode(s, expr.release(), thenExpr.release(), elseExpr.release()));
724 }
725 *parentMatch13 = match;
726 }
727 *parentMatch12 = match;
728 }
729 *parentMatch7 = match;
730 }
731 *parentMatch6 = match;
732 }
733 if (match.hit)
734 {
735 *parentMatch5 = match;
736 }
737 else
738 {
739 lexer.SetPos(save);
740 }
741 }
742 *parentMatch4 = match;
743 }
744 *parentMatch2 = match;
745 }
746 *parentMatch1 = match;
747 }
748 if (match.hit)
749 {
750 {
751 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
752
753 #endif // SOULNG_PARSER_DEBUG_SUPPORT
754 return soulng::parser::Match(true, expr.release());
755 }
756 }
757 *parentMatch0 = match;
758 }
759 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
760
761
762
763
764
765 #endif // SOULNG_PARSER_DEBUG_SUPPORT
766 if (!match.hit)
767 {
768 match.value = nullptr;
769 }
770 return match;
771 }
772
773 soulng::parser::Match ExpressionParser::ThrowExpression(CppLexer& lexer, sngcpp::cppparser::ParsingContext* ctx)
774 {
775 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
776
777
778
779
780
781
782
783 #endif // SOULNG_PARSER_DEBUG_SUPPORT
784 Span s = Span();
785 std::unique_ptr<sngcpp::ast::Node> exception;
786 soulng::parser::Match match(false);
787 soulng::parser::Match* parentMatch0 = &match;
788 {
789 int64_t pos = lexer.GetPos();
790 soulng::parser::Match match(false);
791 soulng::parser::Match* parentMatch1 = &match;
792 {
793 soulng::parser::Match match(false);
794 soulng::parser::Match* parentMatch2 = &match;
795 {
796 soulng::parser::Match match(false);
797 soulng::parser::Match* parentMatch3 = &match;
798 {
799 int64_t pos = lexer.GetPos();
800 soulng::lexer::Span span = lexer.GetSpan();
801 soulng::parser::Match match(false);
802 if (*lexer == THROW)
803 {
804 ++lexer;
805 match.hit = true;
806 }
807 if (match.hit)
808 {
809 s = span;
810 }
811 *parentMatch3 = match;
812 }
813 *parentMatch2 = match;
814 }
815 if (match.hit)
816 {
817 soulng::parser::Match match(false);
818 soulng::parser::Match* parentMatch4 = &match;
819 {
820 soulng::parser::Match match(true);
821 int64_t save = lexer.GetPos();
822 soulng::parser::Match* parentMatch5 = &match;
823 {
824 soulng::parser::Match match(false);
825 soulng::parser::Match* parentMatch6 = &match;
826 {
827 soulng::parser::Match match(false);
828 soulng::parser::Match* parentMatch7 = &match;
829 {
830 int64_t pos = lexer.GetPos();
831 soulng::lexer::Span span = lexer.GetSpan();
832 soulng::parser::Match match = ExpressionParser::AssignmentExpression(lexer, ctx);
833 exception.reset(static_cast<sngcpp::ast::Node*>(match.value));
834 if (match.hit)
835 {
836 s.end = span.end;
837 }
838 *parentMatch7 = match;
839 }
840 *parentMatch6 = match;
841 }
842 if (match.hit)
843 {
844 *parentMatch5 = match;
845 }
846 else
847 {
848 lexer.SetPos(save);
849 }
850 }
851 *parentMatch4 = match;
852 }
853 *parentMatch2 = match;
854 }
855 *parentMatch1 = match;
856 }
857 if (match.hit)
858 {
859 {
860 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
861
862 #endif // SOULNG_PARSER_DEBUG_SUPPORT
863 return soulng::parser::Match(true, new sngcpp::ast::ThrowExpressionNode(s, exception.release()));
864 }
865 }
866 *parentMatch0 = match;
867 }
868 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
869
870
871
872
873
874 #endif // SOULNG_PARSER_DEBUG_SUPPORT
875 if (!match.hit)
876 {
877 match.value = nullptr;
878 }
879 return match;
880 }
881
882 soulng::parser::Match ExpressionParser::LogicalOrExpression(CppLexer& lexer, sngcpp::cppparser::ParsingContext* ctx)
883 {
884 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
885
886
887
888
889
890
891
892 #endif // SOULNG_PARSER_DEBUG_SUPPORT
893 std::unique_ptr<sngcpp::ast::Node> expr = std::unique_ptr<sngcpp::ast::Node>();
894 Span s = Span();
895 std::unique_ptr<sngcpp::ast::Node> left;
896 std::unique_ptr<sngcpp::ast::Node> right;
897 soulng::parser::Match match(false);
898 soulng::parser::Match* parentMatch0 = &match;
899 {
900 int64_t pos = lexer.GetPos();
901 soulng::parser::Match match(false);
902 soulng::parser::Match* parentMatch1 = &match;
903 {
904 soulng::parser::Match match(false);
905 soulng::parser::Match* parentMatch2 = &match;
906 {
907 soulng::parser::Match match(false);
908 soulng::parser::Match* parentMatch3 = &match;
909 {
910 int64_t pos = lexer.GetPos();
911 soulng::lexer::Span span = lexer.GetSpan();
912 soulng::parser::Match match = ExpressionParser::LogicalAndExpression(lexer, ctx);
913 left.reset(static_cast<sngcpp::ast::Node*>(match.value));
914 if (match.hit)
915 {
916 expr.reset(left.release());
917 s = span;
918 }
919 *parentMatch3 = match;
920 }
921 *parentMatch2 = match;
922 }
923 if (match.hit)
924 {
925 soulng::parser::Match match(false);
926 soulng::parser::Match* parentMatch4 = &match;
927 {
928 soulng::parser::Match match(true);
929 soulng::parser::Match* parentMatch5 = &match;
930 {
931 while (true)
932 {
933 int64_t save = lexer.GetPos();
934 {
935 soulng::parser::Match match(false);
936 soulng::parser::Match* parentMatch6 = &match;
937 {
938 soulng::parser::Match match(false);
939 soulng::parser::Match* parentMatch7 = &match;
940 {
941 soulng::parser::Match match(false);
942 if (*lexer == OROR)
943 {
944 ++lexer;
945 match.hit = true;
946 }
947 *parentMatch7 = match;
948 }
949 if (match.hit)
950 {
951 soulng::parser::Match match(false);
952 soulng::parser::Match* parentMatch8 = &match;
953 {
954 soulng::parser::Match match(false);
955 soulng::parser::Match* parentMatch9 = &match;
956 {
957 int64_t pos = lexer.GetPos();
958 soulng::lexer::Span span = lexer.GetSpan();
959 bool pass = true;
960 soulng::parser::Match match = ExpressionParser::LogicalAndExpression(lexer, ctx);
961 right.reset(static_cast<sngcpp::ast::Node*>(match.value));
962 if (match.hit)
963 {
964 if (ctx->ParsingTemplateIdOrLvalueAndNotArguments()) pass = false;
965 else
966 {
967 s.end = span.end;
968 expr.reset(new sngcpp::ast::LogicalOrExpressionNode(s, expr.release(), right.release()));
969 }
970 }
971 if (match.hit && !pass)
972 {
973 match = soulng::parser::Match(false);
974 }
975 *parentMatch9 = match;
976 }
977 *parentMatch8 = match;
978 }
979 *parentMatch7 = match;
980 }
981 *parentMatch6 = match;
982 }
983 if (match.hit)
984 {
985 *parentMatch5 = match;
986 }
987 else
988 {
989 lexer.SetPos(save);
990 break;
991 }
992 }
993 }
994 }
995 *parentMatch4 = match;
996 }
997 *parentMatch2 = match;
998 }
999 *parentMatch1 = match;
1000 }
1001 if (match.hit)
1002 {
1003 {
1004 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1005
1006 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1007 return soulng::parser::Match(true, expr.release());
1008 }
1009 }
1010 *parentMatch0 = match;
1011 }
1012 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1013
1014
1015
1016
1017
1018 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1019 if (!match.hit)
1020 {
1021 match.value = nullptr;
1022 }
1023 return match;
1024 }
1025
1026 soulng::parser::Match ExpressionParser::LogicalAndExpression(CppLexer& lexer, sngcpp::cppparser::ParsingContext* ctx)
1027 {
1028 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1029
1030
1031
1032
1033
1034
1035
1036 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1037 std::unique_ptr<sngcpp::ast::Node> expr = std::unique_ptr<sngcpp::ast::Node>();
1038 Span s = Span();
1039 std::unique_ptr<sngcpp::ast::Node> left;
1040 std::unique_ptr<sngcpp::ast::Node> right;
1041 soulng::parser::Match match(false);
1042 soulng::parser::Match* parentMatch0 = &match;
1043 {
1044 int64_t pos = lexer.GetPos();
1045 soulng::parser::Match match(false);
1046 soulng::parser::Match* parentMatch1 = &match;
1047 {
1048 soulng::parser::Match match(false);
1049 soulng::parser::Match* parentMatch2 = &match;
1050 {
1051 soulng::parser::Match match(false);
1052 soulng::parser::Match* parentMatch3 = &match;
1053 {
1054 int64_t pos = lexer.GetPos();
1055 soulng::lexer::Span span = lexer.GetSpan();
1056 soulng::parser::Match match = ExpressionParser::InclusiveOrExpression(lexer, ctx);
1057 left.reset(static_cast<sngcpp::ast::Node*>(match.value));
1058 if (match.hit)
1059 {
1060 expr.reset(left.release());
1061 s = span;
1062 }
1063 *parentMatch3 = match;
1064 }
1065 *parentMatch2 = match;
1066 }
1067 if (match.hit)
1068 {
1069 soulng::parser::Match match(false);
1070 soulng::parser::Match* parentMatch4 = &match;
1071 {
1072 soulng::parser::Match match(true);
1073 soulng::parser::Match* parentMatch5 = &match;
1074 {
1075 while (true)
1076 {
1077 int64_t save = lexer.GetPos();
1078 {
1079 soulng::parser::Match match(false);
1080 soulng::parser::Match* parentMatch6 = &match;
1081 {
1082 soulng::parser::Match match(false);
1083 soulng::parser::Match* parentMatch7 = &match;
1084 {
1085 soulng::parser::Match match(false);
1086 if (*lexer == AMPAMP)
1087 {
1088 ++lexer;
1089 match.hit = true;
1090 }
1091 *parentMatch7 = match;
1092 }
1093 if (match.hit)
1094 {
1095 soulng::parser::Match match(false);
1096 soulng::parser::Match* parentMatch8 = &match;
1097 {
1098 soulng::parser::Match match(false);
1099 soulng::parser::Match* parentMatch9 = &match;
1100 {
1101 int64_t pos = lexer.GetPos();
1102 soulng::lexer::Span span = lexer.GetSpan();
1103 bool pass = true;
1104 soulng::parser::Match match = ExpressionParser::InclusiveOrExpression(lexer, ctx);
1105 right.reset(static_cast<sngcpp::ast::Node*>(match.value));
1106 if (match.hit)
1107 {
1108 if (ctx->ParsingTemplateIdOrLvalueAndNotArguments()) pass = false;
1109 else
1110 {
1111 s.end = span.end;
1112 expr.reset(new sngcpp::ast::LogicalAndExpressionNode(s, expr.release(), right.release()));
1113 }
1114 }
1115 if (match.hit && !pass)
1116 {
1117 match = soulng::parser::Match(false);
1118 }
1119 *parentMatch9 = match;
1120 }
1121 *parentMatch8 = match;
1122 }
1123 *parentMatch7 = match;
1124 }
1125 *parentMatch6 = match;
1126 }
1127 if (match.hit)
1128 {
1129 *parentMatch5 = match;
1130 }
1131 else
1132 {
1133 lexer.SetPos(save);
1134 break;
1135 }
1136 }
1137 }
1138 }
1139 *parentMatch4 = match;
1140 }
1141 *parentMatch2 = match;
1142 }
1143 *parentMatch1 = match;
1144 }
1145 if (match.hit)
1146 {
1147 {
1148 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1149
1150 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1151 return soulng::parser::Match(true, expr.release());
1152 }
1153 }
1154 *parentMatch0 = match;
1155 }
1156 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1157
1158
1159
1160
1161
1162 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1163 if (!match.hit)
1164 {
1165 match.value = nullptr;
1166 }
1167 return match;
1168 }
1169
1170 soulng::parser::Match ExpressionParser::InclusiveOrExpression(CppLexer& lexer, sngcpp::cppparser::ParsingContext* ctx)
1171 {
1172 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1173
1174
1175
1176
1177
1178
1179
1180 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1181 std::unique_ptr<sngcpp::ast::Node> expr = std::unique_ptr<sngcpp::ast::Node>();
1182 Span s = Span();
1183 std::unique_ptr<sngcpp::ast::Node> left;
1184 std::unique_ptr<sngcpp::ast::Node> right;
1185 soulng::parser::Match match(false);
1186 soulng::parser::Match* parentMatch0 = &match;
1187 {
1188 int64_t pos = lexer.GetPos();
1189 soulng::parser::Match match(false);
1190 soulng::parser::Match* parentMatch1 = &match;
1191 {
1192 soulng::parser::Match match(false);
1193 soulng::parser::Match* parentMatch2 = &match;
1194 {
1195 soulng::parser::Match match(false);
1196 soulng::parser::Match* parentMatch3 = &match;
1197 {
1198 int64_t pos = lexer.GetPos();
1199 soulng::lexer::Span span = lexer.GetSpan();
1200 soulng::parser::Match match = ExpressionParser::ExclusiveOrExpression(lexer, ctx);
1201 left.reset(static_cast<sngcpp::ast::Node*>(match.value));
1202 if (match.hit)
1203 {
1204 expr.reset(left.release());
1205 s = span;
1206 }
1207 *parentMatch3 = match;
1208 }
1209 *parentMatch2 = match;
1210 }
1211 if (match.hit)
1212 {
1213 soulng::parser::Match match(false);
1214 soulng::parser::Match* parentMatch4 = &match;
1215 {
1216 soulng::parser::Match match(true);
1217 soulng::parser::Match* parentMatch5 = &match;
1218 {
1219 while (true)
1220 {
1221 int64_t save = lexer.GetPos();
1222 {
1223 soulng::parser::Match match(false);
1224 soulng::parser::Match* parentMatch6 = &match;
1225 {
1226 soulng::parser::Match match(false);
1227 soulng::parser::Match* parentMatch7 = &match;
1228 {
1229 soulng::parser::Match match(false);
1230 if (*lexer == OR)
1231 {
1232 ++lexer;
1233 match.hit = true;
1234 }
1235 *parentMatch7 = match;
1236 }
1237 if (match.hit)
1238 {
1239 soulng::parser::Match match(false);
1240 soulng::parser::Match* parentMatch8 = &match;
1241 {
1242 soulng::parser::Match match(false);
1243 soulng::parser::Match* parentMatch9 = &match;
1244 {
1245 int64_t pos = lexer.GetPos();
1246 soulng::lexer::Span span = lexer.GetSpan();
1247 bool pass = true;
1248 soulng::parser::Match match = ExpressionParser::ExclusiveOrExpression(lexer, ctx);
1249 right.reset(static_cast<sngcpp::ast::Node*>(match.value));
1250 if (match.hit)
1251 {
1252 if (ctx->ParsingLvalueAndNotArguments()) pass = false;
1253 else
1254 {
1255 s.end = span.end;
1256 expr.reset(new sngcpp::ast::InclusiveOrExpressionNode(s, expr.release(), right.release()));
1257 }
1258 }
1259 if (match.hit && !pass)
1260 {
1261 match = soulng::parser::Match(false);
1262 }
1263 *parentMatch9 = match;
1264 }
1265 *parentMatch8 = match;
1266 }
1267 *parentMatch7 = match;
1268 }
1269 *parentMatch6 = match;
1270 }
1271 if (match.hit)
1272 {
1273 *parentMatch5 = match;
1274 }
1275 else
1276 {
1277 lexer.SetPos(save);
1278 break;
1279 }
1280 }
1281 }
1282 }
1283 *parentMatch4 = match;
1284 }
1285 *parentMatch2 = match;
1286 }
1287 *parentMatch1 = match;
1288 }
1289 if (match.hit)
1290 {
1291 {
1292 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1293
1294 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1295 return soulng::parser::Match(true, expr.release());
1296 }
1297 }
1298 *parentMatch0 = match;
1299 }
1300 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1301
1302
1303
1304
1305
1306 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1307 if (!match.hit)
1308 {
1309 match.value = nullptr;
1310 }
1311 return match;
1312 }
1313
1314 soulng::parser::Match ExpressionParser::ExclusiveOrExpression(CppLexer& lexer, sngcpp::cppparser::ParsingContext* ctx)
1315 {
1316 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1317
1318
1319
1320
1321
1322
1323
1324 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1325 std::unique_ptr<sngcpp::ast::Node> expr = std::unique_ptr<sngcpp::ast::Node>();
1326 Span s = Span();
1327 std::unique_ptr<sngcpp::ast::Node> left;
1328 std::unique_ptr<sngcpp::ast::Node> right;
1329 soulng::parser::Match match(false);
1330 soulng::parser::Match* parentMatch0 = &match;
1331 {
1332 int64_t pos = lexer.GetPos();
1333 soulng::parser::Match match(false);
1334 soulng::parser::Match* parentMatch1 = &match;
1335 {
1336 soulng::parser::Match match(false);
1337 soulng::parser::Match* parentMatch2 = &match;
1338 {
1339 soulng::parser::Match match(false);
1340 soulng::parser::Match* parentMatch3 = &match;
1341 {
1342 int64_t pos = lexer.GetPos();
1343 soulng::lexer::Span span = lexer.GetSpan();
1344 soulng::parser::Match match = ExpressionParser::AndExpression(lexer, ctx);
1345 left.reset(static_cast<sngcpp::ast::Node*>(match.value));
1346 if (match.hit)
1347 {
1348 expr.reset(left.release());
1349 s = span;
1350 }
1351 *parentMatch3 = match;
1352 }
1353 *parentMatch2 = match;
1354 }
1355 if (match.hit)
1356 {
1357 soulng::parser::Match match(false);
1358 soulng::parser::Match* parentMatch4 = &match;
1359 {
1360 soulng::parser::Match match(true);
1361 soulng::parser::Match* parentMatch5 = &match;
1362 {
1363 while (true)
1364 {
1365 int64_t save = lexer.GetPos();
1366 {
1367 soulng::parser::Match match(false);
1368 soulng::parser::Match* parentMatch6 = &match;
1369 {
1370 soulng::parser::Match match(false);
1371 soulng::parser::Match* parentMatch7 = &match;
1372 {
1373 soulng::parser::Match match(false);
1374 if (*lexer == XOR)
1375 {
1376 ++lexer;
1377 match.hit = true;
1378 }
1379 *parentMatch7 = match;
1380 }
1381 if (match.hit)
1382 {
1383 soulng::parser::Match match(false);
1384 soulng::parser::Match* parentMatch8 = &match;
1385 {
1386 soulng::parser::Match match(false);
1387 soulng::parser::Match* parentMatch9 = &match;
1388 {
1389 int64_t pos = lexer.GetPos();
1390 soulng::lexer::Span span = lexer.GetSpan();
1391 bool pass = true;
1392 soulng::parser::Match match = ExpressionParser::AndExpression(lexer, ctx);
1393 right.reset(static_cast<sngcpp::ast::Node*>(match.value));
1394 if (match.hit)
1395 {
1396 if (ctx->ParsingLvalueAndNotArguments()) pass = false;
1397 else
1398 {
1399 s.end = span.end;
1400 expr.reset(new sngcpp::ast::ExclusiveOrExpressionNode(s, expr.release(), right.release()));
1401 }
1402 }
1403 if (match.hit && !pass)
1404 {
1405 match = soulng::parser::Match(false);
1406 }
1407 *parentMatch9 = match;
1408 }
1409 *parentMatch8 = match;
1410 }
1411 *parentMatch7 = match;
1412 }
1413 *parentMatch6 = match;
1414 }
1415 if (match.hit)
1416 {
1417 *parentMatch5 = match;
1418 }
1419 else
1420 {
1421 lexer.SetPos(save);
1422 break;
1423 }
1424 }
1425 }
1426 }
1427 *parentMatch4 = match;
1428 }
1429 *parentMatch2 = match;
1430 }
1431 *parentMatch1 = match;
1432 }
1433 if (match.hit)
1434 {
1435 {
1436 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1437
1438 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1439 return soulng::parser::Match(true, expr.release());
1440 }
1441 }
1442 *parentMatch0 = match;
1443 }
1444 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1445
1446
1447
1448
1449
1450 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1451 if (!match.hit)
1452 {
1453 match.value = nullptr;
1454 }
1455 return match;
1456 }
1457
1458 soulng::parser::Match ExpressionParser::AndExpression(CppLexer& lexer, sngcpp::cppparser::ParsingContext* ctx)
1459 {
1460 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1461
1462
1463
1464
1465
1466
1467
1468 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1469 std::unique_ptr<sngcpp::ast::Node> expr = std::unique_ptr<sngcpp::ast::Node>();
1470 Span s = Span();
1471 std::unique_ptr<sngcpp::ast::Node> left;
1472 std::unique_ptr<sngcpp::ast::Node> right;
1473 soulng::parser::Match match(false);
1474 soulng::parser::Match* parentMatch0 = &match;
1475 {
1476 int64_t pos = lexer.GetPos();
1477 soulng::parser::Match match(false);
1478 soulng::parser::Match* parentMatch1 = &match;
1479 {
1480 soulng::parser::Match match(false);
1481 soulng::parser::Match* parentMatch2 = &match;
1482 {
1483 soulng::parser::Match match(false);
1484 soulng::parser::Match* parentMatch3 = &match;
1485 {
1486 int64_t pos = lexer.GetPos();
1487 soulng::lexer::Span span = lexer.GetSpan();
1488 soulng::parser::Match match = ExpressionParser::EqualityExpression(lexer, ctx);
1489 left.reset(static_cast<sngcpp::ast::Node*>(match.value));
1490 if (match.hit)
1491 {
1492 expr.reset(left.release());
1493 s = span;
1494 }
1495 *parentMatch3 = match;
1496 }
1497 *parentMatch2 = match;
1498 }
1499 if (match.hit)
1500 {
1501 soulng::parser::Match match(false);
1502 soulng::parser::Match* parentMatch4 = &match;
1503 {
1504 soulng::parser::Match match(true);
1505 soulng::parser::Match* parentMatch5 = &match;
1506 {
1507 while (true)
1508 {
1509 int64_t save = lexer.GetPos();
1510 {
1511 soulng::parser::Match match(false);
1512 soulng::parser::Match* parentMatch6 = &match;
1513 {
1514 soulng::parser::Match match(false);
1515 soulng::parser::Match* parentMatch7 = &match;
1516 {
1517 soulng::parser::Match match(false);
1518 if (*lexer == AMP)
1519 {
1520 ++lexer;
1521 match.hit = true;
1522 }
1523 *parentMatch7 = match;
1524 }
1525 if (match.hit)
1526 {
1527 soulng::parser::Match match(false);
1528 soulng::parser::Match* parentMatch8 = &match;
1529 {
1530 soulng::parser::Match match(false);
1531 soulng::parser::Match* parentMatch9 = &match;
1532 {
1533 int64_t pos = lexer.GetPos();
1534 soulng::lexer::Span span = lexer.GetSpan();
1535 bool pass = true;
1536 soulng::parser::Match match = ExpressionParser::EqualityExpression(lexer, ctx);
1537 right.reset(static_cast<sngcpp::ast::Node*>(match.value));
1538 if (match.hit)
1539 {
1540 if (ctx->ParsingLvalueAndNotArguments()) pass = false;
1541 else
1542 {
1543 s.end = span.end;
1544 expr.reset(new sngcpp::ast::AndExpressionNode(s, expr.release(), right.release()));
1545 }
1546 }
1547 if (match.hit && !pass)
1548 {
1549 match = soulng::parser::Match(false);
1550 }
1551 *parentMatch9 = match;
1552 }
1553 *parentMatch8 = match;
1554 }
1555 *parentMatch7 = match;
1556 }
1557 *parentMatch6 = match;
1558 }
1559 if (match.hit)
1560 {
1561 *parentMatch5 = match;
1562 }
1563 else
1564 {
1565 lexer.SetPos(save);
1566 break;
1567 }
1568 }
1569 }
1570 }
1571 *parentMatch4 = match;
1572 }
1573 *parentMatch2 = match;
1574 }
1575 *parentMatch1 = match;
1576 }
1577 if (match.hit)
1578 {
1579 {
1580 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1581
1582 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1583 return soulng::parser::Match(true, expr.release());
1584 }
1585 }
1586 *parentMatch0 = match;
1587 }
1588 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1589
1590
1591
1592
1593
1594 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1595 if (!match.hit)
1596 {
1597 match.value = nullptr;
1598 }
1599 return match;
1600 }
1601
1602 soulng::parser::Match ExpressionParser::EqualityExpression(CppLexer& lexer, sngcpp::cppparser::ParsingContext* ctx)
1603 {
1604 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1605
1606
1607
1608
1609
1610
1611
1612 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1613 std::unique_ptr<sngcpp::ast::Node> expr = std::unique_ptr<sngcpp::ast::Node>();
1614 Span s = Span();
1615 std::unique_ptr<sngcpp::ast::Node> left;
1616 std::unique_ptr<soulng::parser::soulng::parser::Value<sngcpp::ast::Operator>>op;
1617 std::unique_ptr<sngcpp::ast::Node> right;
1618 soulng::parser::Match match(false);
1619 soulng::parser::Match* parentMatch0 = &match;
1620 {
1621 int64_t pos = lexer.GetPos();
1622 soulng::parser::Match match(false);
1623 soulng::parser::Match* parentMatch1 = &match;
1624 {
1625 soulng::parser::Match match(false);
1626 soulng::parser::Match* parentMatch2 = &match;
1627 {
1628 soulng::parser::Match match(false);
1629 soulng::parser::Match* parentMatch3 = &match;
1630 {
1631 int64_t pos = lexer.GetPos();
1632 soulng::lexer::Span span = lexer.GetSpan();
1633 soulng::parser::Match match = ExpressionParser::RelationalExpression(lexer, ctx);
1634 left.reset(static_cast<sngcpp::ast::Node*>(match.value));
1635 if (match.hit)
1636 {
1637 expr.reset(left.release());
1638 s = span;
1639 }
1640 *parentMatch3 = match;
1641 }
1642 *parentMatch2 = match;
1643 }
1644 if (match.hit)
1645 {
1646 soulng::parser::Match match(false);
1647 soulng::parser::Match* parentMatch4 = &match;
1648 {
1649 soulng::parser::Match match(true);
1650 soulng::parser::Match* parentMatch5 = &match;
1651 {
1652 while (true)
1653 {
1654 int64_t save = lexer.GetPos();
1655 {
1656 soulng::parser::Match match(false);
1657 soulng::parser::Match* parentMatch6 = &match;
1658 {
1659 soulng::parser::Match match(false);
1660 soulng::parser::Match* parentMatch7 = &match;
1661 {
1662 soulng::parser::Match match = ExpressionParser::EqualityOperator(lexer);
1663 op.reset(static_cast<soulng::parser::soulng::parser::Value<sngcpp::ast::Operator>*>(match.value));
1664 *parentMatch7 = match;
1665 }
1666 if (match.hit)
1667 {
1668 soulng::parser::Match match(false);
1669 soulng::parser::Match* parentMatch8 = &match;
1670 {
1671 soulng::parser::Match match(false);
1672 soulng::parser::Match* parentMatch9 = &match;
1673 {
1674 int64_t pos = lexer.GetPos();
1675 soulng::lexer::Span span = lexer.GetSpan();
1676 bool pass = true;
1677 soulng::parser::Match match = ExpressionParser::RelationalExpression(lexer, ctx);
1678 right.reset(static_cast<sngcpp::ast::Node*>(match.value));
1679 if (match.hit)
1680 {
1681 if (ctx->ParsingLvalueAndNotArguments()) pass = false;
1682 else
1683 {
1684 s.end = span.end;
1685 expr.reset(new sngcpp::ast::EqualityExpressionNode(s, expr.release(), right.release(), op->value));
1686 }
1687 }
1688 if (match.hit && !pass)
1689 {
1690 match = soulng::parser::Match(false);
1691 }
1692 *parentMatch9 = match;
1693 }
1694 *parentMatch8 = match;
1695 }
1696 *parentMatch7 = match;
1697 }
1698 *parentMatch6 = match;
1699 }
1700 if (match.hit)
1701 {
1702 *parentMatch5 = match;
1703 }
1704 else
1705 {
1706 lexer.SetPos(save);
1707 break;
1708 }
1709 }
1710 }
1711 }
1712 *parentMatch4 = match;
1713 }
1714 *parentMatch2 = match;
1715 }
1716 *parentMatch1 = match;
1717 }
1718 if (match.hit)
1719 {
1720 {
1721 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1722
1723 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1724 return soulng::parser::Match(true, expr.release());
1725 }
1726 }
1727 *parentMatch0 = match;
1728 }
1729 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1730
1731
1732
1733
1734
1735 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1736 if (!match.hit)
1737 {
1738 match.value = nullptr;
1739 }
1740 return match;
1741 }
1742
1743 soulng::parser::Match ExpressionParser::EqualityOperator(CppLexer& lexer)
1744 {
1745 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1746
1747
1748
1749
1750
1751
1752
1753 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1754 soulng::parser::Match match(false);
1755 int64_t pos = lexer.GetPos();
1756 soulng::lexer::Span span = lexer.GetSpan();
1757 switch (*lexer)
1758 {
1759 case EQ:
1760 {
1761 ++lexer;
1762 {
1763 {
1764 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1765
1766 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1767 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::equal));
1768 }
1769 }
1770 break;
1771 }
1772 case NEQ:
1773 {
1774 ++lexer;
1775 {
1776 {
1777 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1778
1779 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1780 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::notEqual));
1781 }
1782 }
1783 break;
1784 }
1785 }
1786 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1787
1788
1789
1790
1791
1792 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1793 if (!match.hit)
1794 {
1795 match.value = nullptr;
1796 }
1797 return match;
1798 }
1799
1800 soulng::parser::Match ExpressionParser::RelationalExpression(CppLexer& lexer, sngcpp::cppparser::ParsingContext* ctx)
1801 {
1802 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1803
1804
1805
1806
1807
1808
1809
1810 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1811 std::unique_ptr<sngcpp::ast::Node> expr = std::unique_ptr<sngcpp::ast::Node>();
1812 Span s = Span();
1813 std::unique_ptr<sngcpp::ast::Node> left;
1814 std::unique_ptr<soulng::parser::soulng::parser::Value<sngcpp::ast::Operator>>op;
1815 std::unique_ptr<sngcpp::ast::Node> right;
1816 soulng::parser::Match match(false);
1817 soulng::parser::Match* parentMatch0 = &match;
1818 {
1819 int64_t pos = lexer.GetPos();
1820 soulng::parser::Match match(false);
1821 soulng::parser::Match* parentMatch1 = &match;
1822 {
1823 soulng::parser::Match match(false);
1824 soulng::parser::Match* parentMatch2 = &match;
1825 {
1826 soulng::parser::Match match(false);
1827 soulng::parser::Match* parentMatch3 = &match;
1828 {
1829 int64_t pos = lexer.GetPos();
1830 soulng::lexer::Span span = lexer.GetSpan();
1831 soulng::parser::Match match = ExpressionParser::ShiftExpression(lexer, ctx);
1832 left.reset(static_cast<sngcpp::ast::Node*>(match.value));
1833 if (match.hit)
1834 {
1835 expr.reset(left.release());
1836 s = span;
1837 }
1838 *parentMatch3 = match;
1839 }
1840 *parentMatch2 = match;
1841 }
1842 if (match.hit)
1843 {
1844 soulng::parser::Match match(false);
1845 soulng::parser::Match* parentMatch4 = &match;
1846 {
1847 soulng::parser::Match match(true);
1848 soulng::parser::Match* parentMatch5 = &match;
1849 {
1850 while (true)
1851 {
1852 int64_t save = lexer.GetPos();
1853 {
1854 soulng::parser::Match match(false);
1855 soulng::parser::Match* parentMatch6 = &match;
1856 {
1857 soulng::parser::Match match(false);
1858 soulng::parser::Match* parentMatch7 = &match;
1859 {
1860 soulng::parser::Match match = ExpressionParser::RelationalOperator(lexer);
1861 op.reset(static_cast<soulng::parser::soulng::parser::Value<sngcpp::ast::Operator>*>(match.value));
1862 *parentMatch7 = match;
1863 }
1864 if (match.hit)
1865 {
1866 soulng::parser::Match match(false);
1867 soulng::parser::Match* parentMatch8 = &match;
1868 {
1869 soulng::parser::Match match(false);
1870 soulng::parser::Match* parentMatch9 = &match;
1871 {
1872 int64_t pos = lexer.GetPos();
1873 soulng::lexer::Span span = lexer.GetSpan();
1874 bool pass = true;
1875 soulng::parser::Match match = ExpressionParser::ShiftExpression(lexer, ctx);
1876 right.reset(static_cast<sngcpp::ast::Node*>(match.value));
1877 if (match.hit)
1878 {
1879 if (ctx->ParsingTemplateIdOrLvalueAndNotArguments()) pass = false;
1880 else
1881 {
1882 s.end = span.end;
1883 expr.reset(new sngcpp::ast::RelationalExpressionNode(s, expr.release(), right.release(), op->value));
1884 }
1885 }
1886 if (match.hit && !pass)
1887 {
1888 match = soulng::parser::Match(false);
1889 }
1890 *parentMatch9 = match;
1891 }
1892 *parentMatch8 = match;
1893 }
1894 *parentMatch7 = match;
1895 }
1896 *parentMatch6 = match;
1897 }
1898 if (match.hit)
1899 {
1900 *parentMatch5 = match;
1901 }
1902 else
1903 {
1904 lexer.SetPos(save);
1905 break;
1906 }
1907 }
1908 }
1909 }
1910 *parentMatch4 = match;
1911 }
1912 *parentMatch2 = match;
1913 }
1914 *parentMatch1 = match;
1915 }
1916 if (match.hit)
1917 {
1918 {
1919 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1920
1921 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1922 return soulng::parser::Match(true, expr.release());
1923 }
1924 }
1925 *parentMatch0 = match;
1926 }
1927 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1928
1929
1930
1931
1932
1933 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1934 if (!match.hit)
1935 {
1936 match.value = nullptr;
1937 }
1938 return match;
1939 }
1940
1941 soulng::parser::Match ExpressionParser::RelationalOperator(CppLexer& lexer)
1942 {
1943 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1944
1945
1946
1947
1948
1949
1950
1951 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1952 soulng::parser::Match match(false);
1953 int64_t pos = lexer.GetPos();
1954 soulng::lexer::Span span = lexer.GetSpan();
1955 switch (*lexer)
1956 {
1957 case LEQ:
1958 {
1959 ++lexer;
1960 {
1961 {
1962 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1963
1964 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1965 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::lessOrEqual));
1966 }
1967 }
1968 break;
1969 }
1970 case GEQ:
1971 {
1972 ++lexer;
1973 {
1974 {
1975 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1976
1977 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1978 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::greaterOrEqual));
1979 }
1980 }
1981 break;
1982 }
1983 case LANGLE:
1984 {
1985 ++lexer;
1986 {
1987 {
1988 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1989
1990 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1991 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::less));
1992 }
1993 }
1994 break;
1995 }
1996 case RANGLE:
1997 {
1998 ++lexer;
1999 {
2000 {
2001 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2002
2003 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2004 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::greater));
2005 }
2006 }
2007 break;
2008 }
2009 }
2010 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2011
2012
2013
2014
2015
2016 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2017 if (!match.hit)
2018 {
2019 match.value = nullptr;
2020 }
2021 return match;
2022 }
2023
2024 soulng::parser::Match ExpressionParser::ShiftExpression(CppLexer& lexer, sngcpp::cppparser::ParsingContext* ctx)
2025 {
2026 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2027
2028
2029
2030
2031
2032
2033
2034 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2035 std::unique_ptr<sngcpp::ast::Node> expr = std::unique_ptr<sngcpp::ast::Node>();
2036 Span s = Span();
2037 std::unique_ptr<sngcpp::ast::Node> left;
2038 std::unique_ptr<soulng::parser::soulng::parser::Value<sngcpp::ast::Operator>>op;
2039 std::unique_ptr<sngcpp::ast::Node> right;
2040 soulng::parser::Match match(false);
2041 soulng::parser::Match* parentMatch0 = &match;
2042 {
2043 int64_t pos = lexer.GetPos();
2044 soulng::parser::Match match(false);
2045 soulng::parser::Match* parentMatch1 = &match;
2046 {
2047 soulng::parser::Match match(false);
2048 soulng::parser::Match* parentMatch2 = &match;
2049 {
2050 soulng::parser::Match match(false);
2051 soulng::parser::Match* parentMatch3 = &match;
2052 {
2053 int64_t pos = lexer.GetPos();
2054 soulng::lexer::Span span = lexer.GetSpan();
2055 soulng::parser::Match match = ExpressionParser::AdditiveExpression(lexer, ctx);
2056 left.reset(static_cast<sngcpp::ast::Node*>(match.value));
2057 if (match.hit)
2058 {
2059 expr.reset(left.release());
2060 s = span;
2061 }
2062 *parentMatch3 = match;
2063 }
2064 *parentMatch2 = match;
2065 }
2066 if (match.hit)
2067 {
2068 soulng::parser::Match match(false);
2069 soulng::parser::Match* parentMatch4 = &match;
2070 {
2071 soulng::parser::Match match(true);
2072 soulng::parser::Match* parentMatch5 = &match;
2073 {
2074 while (true)
2075 {
2076 int64_t save = lexer.GetPos();
2077 {
2078 soulng::parser::Match match(false);
2079 soulng::parser::Match* parentMatch6 = &match;
2080 {
2081 soulng::parser::Match match(false);
2082 soulng::parser::Match* parentMatch7 = &match;
2083 {
2084 soulng::parser::Match match = ExpressionParser::ShiftOperator(lexer);
2085 op.reset(static_cast<soulng::parser::soulng::parser::Value<sngcpp::ast::Operator>*>(match.value));
2086 *parentMatch7 = match;
2087 }
2088 if (match.hit)
2089 {
2090 soulng::parser::Match match(false);
2091 soulng::parser::Match* parentMatch8 = &match;
2092 {
2093 soulng::parser::Match match(false);
2094 soulng::parser::Match* parentMatch9 = &match;
2095 {
2096 int64_t pos = lexer.GetPos();
2097 soulng::lexer::Span span = lexer.GetSpan();
2098 bool pass = true;
2099 soulng::parser::Match match = ExpressionParser::AdditiveExpression(lexer, ctx);
2100 right.reset(static_cast<sngcpp::ast::Node*>(match.value));
2101 if (match.hit)
2102 {
2103 if (ctx->ParsingTemplateIdOrLvalueAndNotArguments()) pass = false;
2104 else
2105 {
2106 s.end = span.end;
2107 expr.reset(new sngcpp::ast::ShiftExpressionNode(s, expr.release(), right.release(), op->value));
2108 }
2109 }
2110 if (match.hit && !pass)
2111 {
2112 match = soulng::parser::Match(false);
2113 }
2114 *parentMatch9 = match;
2115 }
2116 *parentMatch8 = match;
2117 }
2118 *parentMatch7 = match;
2119 }
2120 *parentMatch6 = match;
2121 }
2122 if (match.hit)
2123 {
2124 *parentMatch5 = match;
2125 }
2126 else
2127 {
2128 lexer.SetPos(save);
2129 break;
2130 }
2131 }
2132 }
2133 }
2134 *parentMatch4 = match;
2135 }
2136 *parentMatch2 = match;
2137 }
2138 *parentMatch1 = match;
2139 }
2140 if (match.hit)
2141 {
2142 {
2143 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2144
2145 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2146 return soulng::parser::Match(true, expr.release());
2147 }
2148 }
2149 *parentMatch0 = match;
2150 }
2151 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2152
2153
2154
2155
2156
2157 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2158 if (!match.hit)
2159 {
2160 match.value = nullptr;
2161 }
2162 return match;
2163 }
2164
2165 soulng::parser::Match ExpressionParser::ShiftOperator(CppLexer& lexer)
2166 {
2167 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2168
2169
2170
2171
2172
2173
2174
2175 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2176 soulng::parser::Match match(false);
2177 int64_t pos = lexer.GetPos();
2178 soulng::lexer::Span span = lexer.GetSpan();
2179 switch (*lexer)
2180 {
2181 case SHIFTLEFT:
2182 {
2183 ++lexer;
2184 {
2185 {
2186 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2187
2188 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2189 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::shiftLeft));
2190 }
2191 }
2192 break;
2193 }
2194 case SHIFTRIGHT:
2195 {
2196 ++lexer;
2197 {
2198 {
2199 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2200
2201 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2202 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::shiftRight));
2203 }
2204 }
2205 break;
2206 }
2207 }
2208 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2209
2210
2211
2212
2213
2214 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2215 if (!match.hit)
2216 {
2217 match.value = nullptr;
2218 }
2219 return match;
2220 }
2221
2222 soulng::parser::Match ExpressionParser::AdditiveExpression(CppLexer& lexer, sngcpp::cppparser::ParsingContext* ctx)
2223 {
2224 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2225
2226
2227
2228
2229
2230
2231
2232 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2233 std::unique_ptr<sngcpp::ast::Node> expr = std::unique_ptr<sngcpp::ast::Node>();
2234 Span s = Span();
2235 std::unique_ptr<sngcpp::ast::Node> left;
2236 std::unique_ptr<soulng::parser::soulng::parser::Value<sngcpp::ast::Operator>>op;
2237 std::unique_ptr<sngcpp::ast::Node> right;
2238 soulng::parser::Match match(false);
2239 soulng::parser::Match* parentMatch0 = &match;
2240 {
2241 int64_t pos = lexer.GetPos();
2242 soulng::parser::Match match(false);
2243 soulng::parser::Match* parentMatch1 = &match;
2244 {
2245 soulng::parser::Match match(false);
2246 soulng::parser::Match* parentMatch2 = &match;
2247 {
2248 soulng::parser::Match match(false);
2249 soulng::parser::Match* parentMatch3 = &match;
2250 {
2251 int64_t pos = lexer.GetPos();
2252 soulng::lexer::Span span = lexer.GetSpan();
2253 soulng::parser::Match match = ExpressionParser::MultiplicativeExpression(lexer, ctx);
2254 left.reset(static_cast<sngcpp::ast::Node*>(match.value));
2255 if (match.hit)
2256 {
2257 expr.reset(left.release());
2258 s = span;
2259 }
2260 *parentMatch3 = match;
2261 }
2262 *parentMatch2 = match;
2263 }
2264 if (match.hit)
2265 {
2266 soulng::parser::Match match(false);
2267 soulng::parser::Match* parentMatch4 = &match;
2268 {
2269 soulng::parser::Match match(true);
2270 soulng::parser::Match* parentMatch5 = &match;
2271 {
2272 while (true)
2273 {
2274 int64_t save = lexer.GetPos();
2275 {
2276 soulng::parser::Match match(false);
2277 soulng::parser::Match* parentMatch6 = &match;
2278 {
2279 soulng::parser::Match match(false);
2280 soulng::parser::Match* parentMatch7 = &match;
2281 {
2282 soulng::parser::Match match = ExpressionParser::AdditiveOperator(lexer);
2283 op.reset(static_cast<soulng::parser::soulng::parser::Value<sngcpp::ast::Operator>*>(match.value));
2284 *parentMatch7 = match;
2285 }
2286 if (match.hit)
2287 {
2288 soulng::parser::Match match(false);
2289 soulng::parser::Match* parentMatch8 = &match;
2290 {
2291 soulng::parser::Match match(false);
2292 soulng::parser::Match* parentMatch9 = &match;
2293 {
2294 int64_t pos = lexer.GetPos();
2295 soulng::lexer::Span span = lexer.GetSpan();
2296 bool pass = true;
2297 soulng::parser::Match match = ExpressionParser::MultiplicativeExpression(lexer, ctx);
2298 right.reset(static_cast<sngcpp::ast::Node*>(match.value));
2299 if (match.hit)
2300 {
2301 if (ctx->ParsingLvalueAndNotArguments()) pass = false;
2302 else
2303 {
2304 s.end = span.end;
2305 expr.reset(new sngcpp::ast::AdditiveExpressionNode(s, expr.release(), right.release(), op->value));
2306 }
2307 }
2308 if (match.hit && !pass)
2309 {
2310 match = soulng::parser::Match(false);
2311 }
2312 *parentMatch9 = match;
2313 }
2314 *parentMatch8 = match;
2315 }
2316 *parentMatch7 = match;
2317 }
2318 *parentMatch6 = match;
2319 }
2320 if (match.hit)
2321 {
2322 *parentMatch5 = match;
2323 }
2324 else
2325 {
2326 lexer.SetPos(save);
2327 break;
2328 }
2329 }
2330 }
2331 }
2332 *parentMatch4 = match;
2333 }
2334 *parentMatch2 = match;
2335 }
2336 *parentMatch1 = match;
2337 }
2338 if (match.hit)
2339 {
2340 {
2341 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2342
2343 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2344 return soulng::parser::Match(true, expr.release());
2345 }
2346 }
2347 *parentMatch0 = match;
2348 }
2349 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2350
2351
2352
2353
2354
2355 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2356 if (!match.hit)
2357 {
2358 match.value = nullptr;
2359 }
2360 return match;
2361 }
2362
2363 soulng::parser::Match ExpressionParser::AdditiveOperator(CppLexer& lexer)
2364 {
2365 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2366
2367
2368
2369
2370
2371
2372
2373 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2374 soulng::parser::Match match(false);
2375 int64_t pos = lexer.GetPos();
2376 soulng::lexer::Span span = lexer.GetSpan();
2377 switch (*lexer)
2378 {
2379 case PLUS:
2380 {
2381 ++lexer;
2382 {
2383 {
2384 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2385
2386 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2387 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::add));
2388 }
2389 }
2390 break;
2391 }
2392 case MINUS:
2393 {
2394 ++lexer;
2395 {
2396 {
2397 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2398
2399 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2400 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::sub));
2401 }
2402 }
2403 break;
2404 }
2405 }
2406 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2407
2408
2409
2410
2411
2412 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2413 if (!match.hit)
2414 {
2415 match.value = nullptr;
2416 }
2417 return match;
2418 }
2419
2420 soulng::parser::Match ExpressionParser::MultiplicativeExpression(CppLexer& lexer, sngcpp::cppparser::ParsingContext* ctx)
2421 {
2422 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2423
2424
2425
2426
2427
2428
2429
2430 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2431 std::unique_ptr<sngcpp::ast::Node> expr = std::unique_ptr<sngcpp::ast::Node>();
2432 Span s = Span();
2433 std::unique_ptr<sngcpp::ast::Node> left;
2434 std::unique_ptr<soulng::parser::soulng::parser::Value<sngcpp::ast::Operator>>op;
2435 std::unique_ptr<sngcpp::ast::Node> right;
2436 soulng::parser::Match match(false);
2437 soulng::parser::Match* parentMatch0 = &match;
2438 {
2439 int64_t pos = lexer.GetPos();
2440 soulng::parser::Match match(false);
2441 soulng::parser::Match* parentMatch1 = &match;
2442 {
2443 soulng::parser::Match match(false);
2444 soulng::parser::Match* parentMatch2 = &match;
2445 {
2446 soulng::parser::Match match(false);
2447 soulng::parser::Match* parentMatch3 = &match;
2448 {
2449 int64_t pos = lexer.GetPos();
2450 soulng::lexer::Span span = lexer.GetSpan();
2451 soulng::parser::Match match = ExpressionParser::PMExpression(lexer, ctx);
2452 left.reset(static_cast<sngcpp::ast::Node*>(match.value));
2453 if (match.hit)
2454 {
2455 expr.reset(left.release());
2456 s = span;
2457 }
2458 *parentMatch3 = match;
2459 }
2460 *parentMatch2 = match;
2461 }
2462 if (match.hit)
2463 {
2464 soulng::parser::Match match(false);
2465 soulng::parser::Match* parentMatch4 = &match;
2466 {
2467 soulng::parser::Match match(true);
2468 soulng::parser::Match* parentMatch5 = &match;
2469 {
2470 while (true)
2471 {
2472 int64_t save = lexer.GetPos();
2473 {
2474 soulng::parser::Match match(false);
2475 soulng::parser::Match* parentMatch6 = &match;
2476 {
2477 soulng::parser::Match match(false);
2478 soulng::parser::Match* parentMatch7 = &match;
2479 {
2480 soulng::parser::Match match = ExpressionParser::MultiplicativeOperator(lexer);
2481 op.reset(static_cast<soulng::parser::soulng::parser::Value<sngcpp::ast::Operator>*>(match.value));
2482 *parentMatch7 = match;
2483 }
2484 if (match.hit)
2485 {
2486 soulng::parser::Match match(false);
2487 soulng::parser::Match* parentMatch8 = &match;
2488 {
2489 soulng::parser::Match match(false);
2490 soulng::parser::Match* parentMatch9 = &match;
2491 {
2492 int64_t pos = lexer.GetPos();
2493 soulng::lexer::Span span = lexer.GetSpan();
2494 bool pass = true;
2495 soulng::parser::Match match = ExpressionParser::PMExpression(lexer, ctx);
2496 right.reset(static_cast<sngcpp::ast::Node*>(match.value));
2497 if (match.hit)
2498 {
2499 if (ctx->ParsingLvalueAndNotArguments()) pass = false;
2500 else
2501 {
2502 s.end = span.end;
2503 expr.reset(new sngcpp::ast::MultiplicativeExpressionNode(s, expr.release(), right.release(), op->value));
2504 }
2505 }
2506 if (match.hit && !pass)
2507 {
2508 match = soulng::parser::Match(false);
2509 }
2510 *parentMatch9 = match;
2511 }
2512 *parentMatch8 = match;
2513 }
2514 *parentMatch7 = match;
2515 }
2516 *parentMatch6 = match;
2517 }
2518 if (match.hit)
2519 {
2520 *parentMatch5 = match;
2521 }
2522 else
2523 {
2524 lexer.SetPos(save);
2525 break;
2526 }
2527 }
2528 }
2529 }
2530 *parentMatch4 = match;
2531 }
2532 *parentMatch2 = match;
2533 }
2534 *parentMatch1 = match;
2535 }
2536 if (match.hit)
2537 {
2538 {
2539 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2540
2541 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2542 return soulng::parser::Match(true, expr.release());
2543 }
2544 }
2545 *parentMatch0 = match;
2546 }
2547 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2548
2549
2550
2551
2552
2553 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2554 if (!match.hit)
2555 {
2556 match.value = nullptr;
2557 }
2558 return match;
2559 }
2560
2561 soulng::parser::Match ExpressionParser::MultiplicativeOperator(CppLexer& lexer)
2562 {
2563 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2564
2565
2566
2567
2568
2569
2570
2571 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2572 soulng::parser::Match match(false);
2573 int64_t pos = lexer.GetPos();
2574 soulng::lexer::Span span = lexer.GetSpan();
2575 switch (*lexer)
2576 {
2577 case STAR:
2578 {
2579 ++lexer;
2580 {
2581 {
2582 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2583
2584 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2585 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::mul));
2586 }
2587 }
2588 break;
2589 }
2590 case DIV:
2591 {
2592 ++lexer;
2593 {
2594 {
2595 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2596
2597 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2598 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::div));
2599 }
2600 }
2601 break;
2602 }
2603 case MOD:
2604 {
2605 ++lexer;
2606 {
2607 {
2608 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2609
2610 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2611 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::rem));
2612 }
2613 }
2614 break;
2615 }
2616 }
2617 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2618
2619
2620
2621
2622
2623 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2624 if (!match.hit)
2625 {
2626 match.value = nullptr;
2627 }
2628 return match;
2629 }
2630
2631 soulng::parser::Match ExpressionParser::PMExpression(CppLexer& lexer, sngcpp::cppparser::ParsingContext* ctx)
2632 {
2633 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2634
2635
2636
2637
2638
2639
2640
2641 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2642 std::unique_ptr<sngcpp::ast::Node> expr = std::unique_ptr<sngcpp::ast::Node>();
2643 Span s = Span();
2644 std::unique_ptr<sngcpp::ast::Node> left;
2645 std::unique_ptr<soulng::parser::soulng::parser::Value<sngcpp::ast::Operator>>op;
2646 std::unique_ptr<sngcpp::ast::Node> right;
2647 soulng::parser::Match match(false);
2648 soulng::parser::Match* parentMatch0 = &match;
2649 {
2650 int64_t pos = lexer.GetPos();
2651 soulng::parser::Match match(false);
2652 soulng::parser::Match* parentMatch1 = &match;
2653 {
2654 soulng::parser::Match match(false);
2655 soulng::parser::Match* parentMatch2 = &match;
2656 {
2657 soulng::parser::Match match(false);
2658 soulng::parser::Match* parentMatch3 = &match;
2659 {
2660 int64_t pos = lexer.GetPos();
2661 soulng::lexer::Span span = lexer.GetSpan();
2662 soulng::parser::Match match = ExpressionParser::CastExpression(lexer, ctx);
2663 left.reset(static_cast<sngcpp::ast::Node*>(match.value));
2664 if (match.hit)
2665 {
2666 expr.reset(left.release());
2667 s = span;
2668 }
2669 *parentMatch3 = match;
2670 }
2671 *parentMatch2 = match;
2672 }
2673 if (match.hit)
2674 {
2675 soulng::parser::Match match(false);
2676 soulng::parser::Match* parentMatch4 = &match;
2677 {
2678 soulng::parser::Match match(true);
2679 soulng::parser::Match* parentMatch5 = &match;
2680 {
2681 while (true)
2682 {
2683 int64_t save = lexer.GetPos();
2684 {
2685 soulng::parser::Match match(false);
2686 soulng::parser::Match* parentMatch6 = &match;
2687 {
2688 soulng::parser::Match match(false);
2689 soulng::parser::Match* parentMatch7 = &match;
2690 {
2691 soulng::parser::Match match = ExpressionParser::PMOperator(lexer);
2692 op.reset(static_cast<soulng::parser::soulng::parser::Value<sngcpp::ast::Operator>*>(match.value));
2693 *parentMatch7 = match;
2694 }
2695 if (match.hit)
2696 {
2697 soulng::parser::Match match(false);
2698 soulng::parser::Match* parentMatch8 = &match;
2699 {
2700 soulng::parser::Match match(false);
2701 soulng::parser::Match* parentMatch9 = &match;
2702 {
2703 int64_t pos = lexer.GetPos();
2704 soulng::lexer::Span span = lexer.GetSpan();
2705 soulng::parser::Match match = ExpressionParser::CastExpression(lexer, ctx);
2706 right.reset(static_cast<sngcpp::ast::Node*>(match.value));
2707 if (match.hit)
2708 {
2709 s.end = span.end;
2710 expr.reset(new sngcpp::ast::PMExpressionNode(s, expr.release(), right.release(), op->value));
2711 }
2712 *parentMatch9 = match;
2713 }
2714 *parentMatch8 = match;
2715 }
2716 *parentMatch7 = match;
2717 }
2718 *parentMatch6 = match;
2719 }
2720 if (match.hit)
2721 {
2722 *parentMatch5 = match;
2723 }
2724 else
2725 {
2726 lexer.SetPos(save);
2727 break;
2728 }
2729 }
2730 }
2731 }
2732 *parentMatch4 = match;
2733 }
2734 *parentMatch2 = match;
2735 }
2736 *parentMatch1 = match;
2737 }
2738 if (match.hit)
2739 {
2740 {
2741 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2742
2743 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2744 return soulng::parser::Match(true, expr.release());
2745 }
2746 }
2747 *parentMatch0 = match;
2748 }
2749 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2750
2751
2752
2753
2754
2755 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2756 if (!match.hit)
2757 {
2758 match.value = nullptr;
2759 }
2760 return match;
2761 }
2762
2763 soulng::parser::Match ExpressionParser::PMOperator(CppLexer& lexer)
2764 {
2765 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2766
2767
2768
2769
2770
2771
2772
2773 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2774 soulng::parser::Match match(false);
2775 int64_t pos = lexer.GetPos();
2776 soulng::lexer::Span span = lexer.GetSpan();
2777 switch (*lexer)
2778 {
2779 case DOTSTAR:
2780 {
2781 ++lexer;
2782 {
2783 {
2784 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2785
2786 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2787 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::dotStar));
2788 }
2789 }
2790 break;
2791 }
2792 case ARROWSTAR:
2793 {
2794 ++lexer;
2795 {
2796 {
2797 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2798
2799 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2800 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::arrowStar));
2801 }
2802 }
2803 break;
2804 }
2805 }
2806 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2807
2808
2809
2810
2811
2812 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2813 if (!match.hit)
2814 {
2815 match.value = nullptr;
2816 }
2817 return match;
2818 }
2819
2820 soulng::parser::Match ExpressionParser::CastExpression(CppLexer& lexer, sngcpp::cppparser::ParsingContext* ctx)
2821 {
2822 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2823
2824
2825
2826
2827
2828
2829
2830 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2831 Span s = Span();
2832 std::unique_ptr<sngcpp::ast::Node> typeExpr;
2833 std::unique_ptr<sngcpp::ast::Node> castExpr;
2834 std::unique_ptr<sngcpp::ast::Node> unaryExpression;
2835 soulng::parser::Match match(false);
2836 soulng::parser::Match* parentMatch0 = &match;
2837 {
2838 int64_t save = lexer.GetPos();
2839 soulng::parser::Match match(false);
2840 soulng::parser::Match* parentMatch1 = &match;
2841 {
2842 soulng::parser::Match match(false);
2843 soulng::parser::Match* parentMatch2 = &match;
2844 {
2845 soulng::parser::Match match(false);
2846 soulng::parser::Match* parentMatch3 = &match;
2847 {
2848 soulng::parser::Match match(false);
2849 soulng::parser::Match* parentMatch4 = &match;
2850 {
2851 int64_t pos = lexer.GetPos();
2852 soulng::lexer::Span span = lexer.GetSpan();
2853 soulng::parser::Match match(false);
2854 if (*lexer == LPAREN)
2855 {
2856 ++lexer;
2857 match.hit = true;
2858 }
2859 if (match.hit)
2860 {
2861 s = span;
2862 }
2863 *parentMatch4 = match;
2864 }
2865 *parentMatch3 = match;
2866 }
2867 if (match.hit)
2868 {
2869 soulng::parser::Match match(false);
2870 soulng::parser::Match* parentMatch5 = &match;
2871 {
2872 soulng::parser::Match match = TypeExprParser::TypeExpr(lexer, ctx);
2873 typeExpr.reset(static_cast<sngcpp::ast::Node*>(match.value));
2874 *parentMatch5 = match;
2875 }
2876 *parentMatch3 = match;
2877 }
2878 *parentMatch2 = match;
2879 }
2880 if (match.hit)
2881 {
2882 soulng::parser::Match match(false);
2883 soulng::parser::Match* parentMatch6 = &match;
2884 {
2885 soulng::parser::Match match(false);
2886 if (*lexer == RPAREN)
2887 {
2888 ++lexer;
2889 match.hit = true;
2890 }
2891 *parentMatch6 = match;
2892 }
2893 *parentMatch2 = match;
2894 }
2895 *parentMatch1 = match;
2896 }
2897 if (match.hit)
2898 {
2899 soulng::parser::Match match(false);
2900 soulng::parser::Match* parentMatch7 = &match;
2901 {
2902 soulng::parser::Match match(false);
2903 soulng::parser::Match* parentMatch8 = &match;
2904 {
2905 int64_t pos = lexer.GetPos();
2906 soulng::lexer::Span span = lexer.GetSpan();
2907 soulng::parser::Match match = ExpressionParser::CastExpression(lexer, ctx);
2908 castExpr.reset(static_cast<sngcpp::ast::Node*>(match.value));
2909 if (match.hit)
2910 {
2911 s.end = span.end;
2912 {
2913 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2914
2915 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2916 return soulng::parser::Match(true, new sngcpp::ast::CastExpressionNode(s, typeExpr.release(), castExpr.release()));
2917 }
2918 }
2919 *parentMatch8 = match;
2920 }
2921 *parentMatch7 = match;
2922 }
2923 *parentMatch1 = match;
2924 }
2925 *parentMatch0 = match;
2926 if (!match.hit)
2927 {
2928 soulng::parser::Match match(false);
2929 soulng::parser::Match* parentMatch9 = &match;
2930 lexer.SetPos(save);
2931 {
2932 soulng::parser::Match match(false);
2933 soulng::parser::Match* parentMatch10 = &match;
2934 {
2935 int64_t pos = lexer.GetPos();
2936 soulng::parser::Match match = ExpressionParser::UnaryExpression(lexer, ctx);
2937 unaryExpression.reset(static_cast<sngcpp::ast::Node*>(match.value));
2938 if (match.hit)
2939 {
2940 {
2941 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2942
2943 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2944 return soulng::parser::Match(true, unaryExpression.release());
2945 }
2946 }
2947 *parentMatch10 = match;
2948 }
2949 *parentMatch9 = match;
2950 }
2951 *parentMatch0 = match;
2952 }
2953 }
2954 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2955
2956
2957
2958
2959
2960 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2961 if (!match.hit)
2962 {
2963 match.value = nullptr;
2964 }
2965 return match;
2966 }
2967
2968 soulng::parser::Match ExpressionParser::UnaryExpression(CppLexer& lexer, sngcpp::cppparser::ParsingContext* ctx)
2969 {
2970 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2971
2972
2973
2974
2975
2976
2977
2978 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2979 Span s = Span();
2980 std::unique_ptr<sngcpp::ast::Node> c1;
2981 std::unique_ptr<sngcpp::ast::Node> c2;
2982 std::unique_ptr<soulng::parser::soulng::parser::Value<sngcpp::ast::Operator>>op;
2983 std::unique_ptr<sngcpp::ast::Node> c3;
2984 std::unique_ptr<sngcpp::ast::Node> u4;
2985 std::unique_ptr<sngcpp::ast::Node> t5;
2986 std::unique_ptr<sngcpp::ast::Node> newExpr;
2987 std::unique_ptr<sngcpp::ast::Node> deleteExpr;
2988 std::unique_ptr<sngcpp::ast::Node> postfixExpr;
2989 soulng::parser::Match match(false);
2990 soulng::parser::Match* parentMatch0 = &match;
2991 {
2992 int64_t save = lexer.GetPos();
2993 soulng::parser::Match match(false);
2994 soulng::parser::Match* parentMatch1 = &match;
2995 {
2996 int64_t save = lexer.GetPos();
2997 soulng::parser::Match match(false);
2998 soulng::parser::Match* parentMatch2 = &match;
2999 {
3000 int64_t save = lexer.GetPos();
3001 soulng::parser::Match match(false);
3002 soulng::parser::Match* parentMatch3 = &match;
3003 {
3004 int64_t save = lexer.GetPos();
3005 soulng::parser::Match match(false);
3006 soulng::parser::Match* parentMatch4 = &match;
3007 {
3008 int64_t save = lexer.GetPos();
3009 soulng::parser::Match match(false);
3010 soulng::parser::Match* parentMatch5 = &match;
3011 {
3012 int64_t save = lexer.GetPos();
3013 soulng::parser::Match match(false);
3014 soulng::parser::Match* parentMatch6 = &match;
3015 {
3016 int64_t save = lexer.GetPos();
3017 soulng::parser::Match match(false);
3018 soulng::parser::Match* parentMatch7 = &match;
3019 {
3020 soulng::parser::Match match(false);
3021 soulng::parser::Match* parentMatch8 = &match;
3022 {
3023 int64_t pos = lexer.GetPos();
3024 soulng::lexer::Span span = lexer.GetSpan();
3025 soulng::parser::Match match(false);
3026 if (*lexer == PLUSPLUS)
3027 {
3028 ++lexer;
3029 match.hit = true;
3030 }
3031 if (match.hit)
3032 {
3033 s = span;
3034 }
3035 *parentMatch8 = match;
3036 }
3037 *parentMatch7 = match;
3038 }
3039 if (match.hit)
3040 {
3041 soulng::parser::Match match(false);
3042 soulng::parser::Match* parentMatch9 = &match;
3043 {
3044 soulng::parser::Match match(false);
3045 soulng::parser::Match* parentMatch10 = &match;
3046 {
3047 int64_t pos = lexer.GetPos();
3048 soulng::lexer::Span span = lexer.GetSpan();
3049 soulng::parser::Match match = ExpressionParser::CastExpression(lexer, ctx);
3050 c1.reset(static_cast<sngcpp::ast::Node*>(match.value));
3051 if (match.hit)
3052 {
3053 s.end = span.end;
3054 {
3055 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3056
3057 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3058 return soulng::parser::Match(true, new sngcpp::ast::UnaryExpressionNode(s, sngcpp::ast::Operator::inc, c1.release()));
3059 }
3060 }
3061 *parentMatch10 = match;
3062 }
3063 *parentMatch9 = match;
3064 }
3065 *parentMatch7 = match;
3066 }
3067 *parentMatch6 = match;
3068 if (!match.hit)
3069 {
3070 soulng::parser::Match match(false);
3071 soulng::parser::Match* parentMatch11 = &match;
3072 lexer.SetPos(save);
3073 {
3074 soulng::parser::Match match(false);
3075 soulng::parser::Match* parentMatch12 = &match;
3076 {
3077 soulng::parser::Match match(false);
3078 soulng::parser::Match* parentMatch13 = &match;
3079 {
3080 int64_t pos = lexer.GetPos();
3081 soulng::lexer::Span span = lexer.GetSpan();
3082 soulng::parser::Match match(false);
3083 if (*lexer == MINUSMINUS)
3084 {
3085 ++lexer;
3086 match.hit = true;
3087 }
3088 if (match.hit)
3089 {
3090 s = span;
3091 }
3092 *parentMatch13 = match;
3093 }
3094 *parentMatch12 = match;
3095 }
3096 if (match.hit)
3097 {
3098 soulng::parser::Match match(false);
3099 soulng::parser::Match* parentMatch14 = &match;
3100 {
3101 soulng::parser::Match match(false);
3102 soulng::parser::Match* parentMatch15 = &match;
3103 {
3104 int64_t pos = lexer.GetPos();
3105 soulng::lexer::Span span = lexer.GetSpan();
3106 soulng::parser::Match match = ExpressionParser::CastExpression(lexer, ctx);
3107 c2.reset(static_cast<sngcpp::ast::Node*>(match.value));
3108 if (match.hit)
3109 {
3110 s.end = span.end;
3111 {
3112 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3113
3114 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3115 return soulng::parser::Match(true, new sngcpp::ast::UnaryExpressionNode(s, sngcpp::ast::Operator::dec, c2.release()));
3116 }
3117 }
3118 *parentMatch15 = match;
3119 }
3120 *parentMatch14 = match;
3121 }
3122 *parentMatch12 = match;
3123 }
3124 *parentMatch11 = match;
3125 }
3126 *parentMatch6 = match;
3127 }
3128 }
3129 *parentMatch5 = match;
3130 if (!match.hit)
3131 {
3132 soulng::parser::Match match(false);
3133 soulng::parser::Match* parentMatch16 = &match;
3134 lexer.SetPos(save);
3135 {
3136 soulng::parser::Match match(false);
3137 soulng::parser::Match* parentMatch17 = &match;
3138 {
3139 soulng::parser::Match match(false);
3140 soulng::parser::Match* parentMatch18 = &match;
3141 {
3142 int64_t pos = lexer.GetPos();
3143 soulng::lexer::Span span = lexer.GetSpan();
3144 soulng::parser::Match match = ExpressionParser::UnaryOperator(lexer);
3145 op.reset(static_cast<soulng::parser::soulng::parser::Value<sngcpp::ast::Operator>*>(match.value));
3146 if (match.hit)
3147 {
3148 s = span;
3149 }
3150 *parentMatch18 = match;
3151 }
3152 *parentMatch17 = match;
3153 }
3154 if (match.hit)
3155 {
3156 soulng::parser::Match match(false);
3157 soulng::parser::Match* parentMatch19 = &match;
3158 {
3159 soulng::parser::Match match(false);
3160 soulng::parser::Match* parentMatch20 = &match;
3161 {
3162 int64_t pos = lexer.GetPos();
3163 soulng::lexer::Span span = lexer.GetSpan();
3164 soulng::parser::Match match = ExpressionParser::CastExpression(lexer, ctx);
3165 c3.reset(static_cast<sngcpp::ast::Node*>(match.value));
3166 if (match.hit)
3167 {
3168 s.end = span.end;
3169 {
3170 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3171
3172 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3173 return soulng::parser::Match(true, new sngcpp::ast::UnaryExpressionNode(s, op->value, c3.release()));
3174 }
3175 }
3176 *parentMatch20 = match;
3177 }
3178 *parentMatch19 = match;
3179 }
3180 *parentMatch17 = match;
3181 }
3182 *parentMatch16 = match;
3183 }
3184 *parentMatch5 = match;
3185 }
3186 }
3187 *parentMatch4 = match;
3188 if (!match.hit)
3189 {
3190 soulng::parser::Match match(false);
3191 soulng::parser::Match* parentMatch21 = &match;
3192 lexer.SetPos(save);
3193 {
3194 soulng::parser::Match match(false);
3195 soulng::parser::Match* parentMatch22 = &match;
3196 {
3197 soulng::parser::Match match(false);
3198 soulng::parser::Match* parentMatch23 = &match;
3199 {
3200 int64_t pos = lexer.GetPos();
3201 soulng::lexer::Span span = lexer.GetSpan();
3202 soulng::parser::Match match(false);
3203 if (*lexer == SIZEOF)
3204 {
3205 ++lexer;
3206 match.hit = true;
3207 }
3208 if (match.hit)
3209 {
3210 s = span;
3211 }
3212 *parentMatch23 = match;
3213 }
3214 *parentMatch22 = match;
3215 }
3216 if (match.hit)
3217 {
3218 soulng::parser::Match match(false);
3219 soulng::parser::Match* parentMatch24 = &match;
3220 {
3221 soulng::parser::Match match(false);
3222 soulng::parser::Match* parentMatch25 = &match;
3223 {
3224 int64_t pos = lexer.GetPos();
3225 soulng::lexer::Span span = lexer.GetSpan();
3226 soulng::parser::Match match = ExpressionParser::UnaryExpression(lexer, ctx);
3227 u4.reset(static_cast<sngcpp::ast::Node*>(match.value));
3228 if (match.hit)
3229 {
3230 s.end = span.end;
3231 {
3232 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3233
3234 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3235 return soulng::parser::Match(true, new sngcpp::ast::UnaryExpressionNode(s, sngcpp::ast::Operator::sizeOf, u4.release()));
3236 }
3237 }
3238 *parentMatch25 = match;
3239 }
3240 *parentMatch24 = match;
3241 }
3242 *parentMatch22 = match;
3243 }
3244 *parentMatch21 = match;
3245 }
3246 *parentMatch4 = match;
3247 }
3248 }
3249 *parentMatch3 = match;
3250 if (!match.hit)
3251 {
3252 soulng::parser::Match match(false);
3253 soulng::parser::Match* parentMatch26 = &match;
3254 lexer.SetPos(save);
3255 {
3256 soulng::parser::Match match(false);
3257 soulng::parser::Match* parentMatch27 = &match;
3258 {
3259 soulng::parser::Match match(false);
3260 soulng::parser::Match* parentMatch28 = &match;
3261 {
3262 soulng::parser::Match match(false);
3263 soulng::parser::Match* parentMatch29 = &match;
3264 {
3265 soulng::parser::Match match(false);
3266 soulng::parser::Match* parentMatch30 = &match;
3267 {
3268 int64_t pos = lexer.GetPos();
3269 soulng::lexer::Span span = lexer.GetSpan();
3270 soulng::parser::Match match(false);
3271 if (*lexer == ALIGNOF)
3272 {
3273 ++lexer;
3274 match.hit = true;
3275 }
3276 if (match.hit)
3277 {
3278 s = span;
3279 }
3280 *parentMatch30 = match;
3281 }
3282 *parentMatch29 = match;
3283 }
3284 if (match.hit)
3285 {
3286 soulng::parser::Match match(false);
3287 soulng::parser::Match* parentMatch31 = &match;
3288 {
3289 soulng::parser::Match match(false);
3290 if (*lexer == LPAREN)
3291 {
3292 ++lexer;
3293 match.hit = true;
3294 }
3295 *parentMatch31 = match;
3296 }
3297 *parentMatch29 = match;
3298 }
3299 *parentMatch28 = match;
3300 }
3301 if (match.hit)
3302 {
3303 soulng::parser::Match match(false);
3304 soulng::parser::Match* parentMatch32 = &match;
3305 {
3306 soulng::parser::Match match = TypeExprParser::TypeExpr(lexer, ctx);
3307 t5.reset(static_cast<sngcpp::ast::Node*>(match.value));
3308 *parentMatch32 = match;
3309 }
3310 *parentMatch28 = match;
3311 }
3312 *parentMatch27 = match;
3313 }
3314 if (match.hit)
3315 {
3316 soulng::parser::Match match(false);
3317 soulng::parser::Match* parentMatch33 = &match;
3318 {
3319 soulng::parser::Match match(false);
3320 soulng::parser::Match* parentMatch34 = &match;
3321 {
3322 int64_t pos = lexer.GetPos();
3323 soulng::lexer::Span span = lexer.GetSpan();
3324 soulng::parser::Match match(false);
3325 if (*lexer == RPAREN)
3326 {
3327 ++lexer;
3328 match.hit = true;
3329 }
3330 if (match.hit)
3331 {
3332 s.end = span.end;
3333 {
3334 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3335
3336 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3337 return soulng::parser::Match(true, new sngcpp::ast::UnaryExpressionNode(s, sngcpp::ast::Operator::alignOf, t5.release()));
3338 }
3339 }
3340 *parentMatch34 = match;
3341 }
3342 *parentMatch33 = match;
3343 }
3344 *parentMatch27 = match;
3345 }
3346 *parentMatch26 = match;
3347 }
3348 *parentMatch3 = match;
3349 }
3350 }
3351 *parentMatch2 = match;
3352 if (!match.hit)
3353 {
3354 soulng::parser::Match match(false);
3355 soulng::parser::Match* parentMatch35 = &match;
3356 lexer.SetPos(save);
3357 {
3358 soulng::parser::Match match(false);
3359 soulng::parser::Match* parentMatch36 = &match;
3360 {
3361 int64_t pos = lexer.GetPos();
3362 soulng::parser::Match match = ExpressionParser::NewExpression(lexer, ctx);
3363 newExpr.reset(static_cast<sngcpp::ast::Node*>(match.value));
3364 if (match.hit)
3365 {
3366 {
3367 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3368
3369 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3370 return soulng::parser::Match(true, newExpr.release());
3371 }
3372 }
3373 *parentMatch36 = match;
3374 }
3375 *parentMatch35 = match;
3376 }
3377 *parentMatch2 = match;
3378 }
3379 }
3380 *parentMatch1 = match;
3381 if (!match.hit)
3382 {
3383 soulng::parser::Match match(false);
3384 soulng::parser::Match* parentMatch37 = &match;
3385 lexer.SetPos(save);
3386 {
3387 soulng::parser::Match match(false);
3388 soulng::parser::Match* parentMatch38 = &match;
3389 {
3390 int64_t pos = lexer.GetPos();
3391 soulng::parser::Match match = ExpressionParser::DeleteExpression(lexer, ctx);
3392 deleteExpr.reset(static_cast<sngcpp::ast::Node*>(match.value));
3393 if (match.hit)
3394 {
3395 {
3396 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3397
3398 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3399 return soulng::parser::Match(true, deleteExpr.release());
3400 }
3401 }
3402 *parentMatch38 = match;
3403 }
3404 *parentMatch37 = match;
3405 }
3406 *parentMatch1 = match;
3407 }
3408 }
3409 *parentMatch0 = match;
3410 if (!match.hit)
3411 {
3412 soulng::parser::Match match(false);
3413 soulng::parser::Match* parentMatch39 = &match;
3414 lexer.SetPos(save);
3415 {
3416 soulng::parser::Match match(false);
3417 soulng::parser::Match* parentMatch40 = &match;
3418 {
3419 int64_t pos = lexer.GetPos();
3420 soulng::parser::Match match = ExpressionParser::PostfixExpression(lexer, ctx);
3421 postfixExpr.reset(static_cast<sngcpp::ast::Node*>(match.value));
3422 if (match.hit)
3423 {
3424 {
3425 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3426
3427 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3428 return soulng::parser::Match(true, postfixExpr.release());
3429 }
3430 }
3431 *parentMatch40 = match;
3432 }
3433 *parentMatch39 = match;
3434 }
3435 *parentMatch0 = match;
3436 }
3437 }
3438 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3439
3440
3441
3442
3443
3444 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3445 if (!match.hit)
3446 {
3447 match.value = nullptr;
3448 }
3449 return match;
3450 }
3451
3452 soulng::parser::Match ExpressionParser::UnaryOperator(CppLexer& lexer)
3453 {
3454 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3455
3456
3457
3458
3459
3460
3461
3462 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3463 soulng::parser::Match match(false);
3464 int64_t pos = lexer.GetPos();
3465 soulng::lexer::Span span = lexer.GetSpan();
3466 switch (*lexer)
3467 {
3468 case STAR:
3469 {
3470 ++lexer;
3471 {
3472 {
3473 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3474
3475 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3476 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::deref));
3477 }
3478 }
3479 break;
3480 }
3481 case AMP:
3482 {
3483 ++lexer;
3484 {
3485 {
3486 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3487
3488 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3489 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::addrOf));
3490 }
3491 }
3492 break;
3493 }
3494 case PLUS:
3495 {
3496 ++lexer;
3497 {
3498 {
3499 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3500
3501 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3502 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::unaryPlus));
3503 }
3504 }
3505 break;
3506 }
3507 case MINUS:
3508 {
3509 ++lexer;
3510 {
3511 {
3512 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3513
3514 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3515 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::unaryMinus));
3516 }
3517 }
3518 break;
3519 }
3520 case EXCLAMATION:
3521 {
3522 ++lexer;
3523 {
3524 {
3525 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3526
3527 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3528 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::not_));
3529 }
3530 }
3531 break;
3532 }
3533 case TILDE:
3534 {
3535 ++lexer;
3536 {
3537 {
3538 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3539
3540 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3541 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::complement));
3542 }
3543 }
3544 break;
3545 }
3546 }
3547 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3548
3549
3550
3551
3552
3553 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3554 if (!match.hit)
3555 {
3556 match.value = nullptr;
3557 }
3558 return match;
3559 }
3560
3561 soulng::parser::Match ExpressionParser::NewExpression(CppLexer& lexer, sngcpp::cppparser::ParsingContext* ctx)
3562 {
3563 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3564
3565
3566
3567
3568
3569
3570
3571 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3572 Span s = Span();
3573 std::unique_ptr<sngcpp::ast::Node> placement;
3574 std::unique_ptr<sngcpp::ast::Node> typeExpr;
3575 std::unique_ptr<sngcpp::ast::Node> initializer;
3576 soulng::parser::Match match(false);
3577 soulng::parser::Match* parentMatch0 = &match;
3578 {
3579 int64_t pos = lexer.GetPos();
3580 soulng::parser::Match match(false);
3581 soulng::parser::Match* parentMatch1 = &match;
3582 {
3583 soulng::parser::Match match(false);
3584 soulng::parser::Match* parentMatch2 = &match;
3585 {
3586 soulng::parser::Match match(false);
3587 soulng::parser::Match* parentMatch3 = &match;
3588 {
3589 soulng::parser::Match match(false);
3590 soulng::parser::Match* parentMatch4 = &match;
3591 {
3592 soulng::parser::Match match(false);
3593 soulng::parser::Match* parentMatch5 = &match;
3594 {
3595 int64_t pos = lexer.GetPos();
3596 soulng::lexer::Span span = lexer.GetSpan();
3597 soulng::parser::Match match(false);
3598 if (*lexer == NEW)
3599 {
3600 ++lexer;
3601 match.hit = true;
3602 }
3603 if (match.hit)
3604 {
3605 s = span;
3606 }
3607 *parentMatch5 = match;
3608 }
3609 *parentMatch4 = match;
3610 }
3611 if (match.hit)
3612 {
3613 soulng::parser::Match match(false);
3614 soulng::parser::Match* parentMatch6 = &match;
3615 {
3616 soulng::parser::Match match(true);
3617 int64_t save = lexer.GetPos();
3618 soulng::parser::Match* parentMatch7 = &match;
3619 {
3620 soulng::parser::Match match = ExpressionParser::NewPlacement(lexer, ctx);
3621 placement.reset(static_cast<sngcpp::ast::Node*>(match.value));
3622 if (match.hit)
3623 {
3624 *parentMatch7 = match;
3625 }
3626 else
3627 {
3628 lexer.SetPos(save);
3629 }
3630 }
3631 *parentMatch6 = match;
3632 }
3633 *parentMatch4 = match;
3634 }
3635 *parentMatch3 = match;
3636 }
3637 if (match.hit)
3638 {
3639 soulng::parser::Match match(false);
3640 soulng::parser::Match* parentMatch8 = &match;
3641 {
3642 soulng::parser::Match match(false);
3643 soulng::parser::Match* parentMatch9 = &match;
3644 {
3645 int64_t pos = lexer.GetPos();
3646 soulng::lexer::Span span = lexer.GetSpan();
3647 soulng::parser::Match match = TypeExprParser::TypeExpr(lexer, ctx);
3648 typeExpr.reset(static_cast<sngcpp::ast::Node*>(match.value));
3649 if (match.hit)
3650 {
3651 s.end = span.end;
3652 }
3653 *parentMatch9 = match;
3654 }
3655 *parentMatch8 = match;
3656 }
3657 *parentMatch3 = match;
3658 }
3659 *parentMatch2 = match;
3660 }
3661 if (match.hit)
3662 {
3663 soulng::parser::Match match(false);
3664 soulng::parser::Match* parentMatch10 = &match;
3665 {
3666 soulng::parser::Match match(true);
3667 int64_t save = lexer.GetPos();
3668 soulng::parser::Match* parentMatch11 = &match;
3669 {
3670 soulng::parser::Match match(false);
3671 soulng::parser::Match* parentMatch12 = &match;
3672 {
3673 soulng::parser::Match match(false);
3674 soulng::parser::Match* parentMatch13 = &match;
3675 {
3676 int64_t pos = lexer.GetPos();
3677 soulng::lexer::Span span = lexer.GetSpan();
3678 soulng::parser::Match match = ExpressionParser::NewInitializer(lexer, ctx);
3679 initializer.reset(static_cast<sngcpp::ast::Node*>(match.value));
3680 if (match.hit)
3681 {
3682 s.end = span.end;
3683 }
3684 *parentMatch13 = match;
3685 }
3686 *parentMatch12 = match;
3687 }
3688 if (match.hit)
3689 {
3690 *parentMatch11 = match;
3691 }
3692 else
3693 {
3694 lexer.SetPos(save);
3695 }
3696 }
3697 *parentMatch10 = match;
3698 }
3699 *parentMatch2 = match;
3700 }
3701 *parentMatch1 = match;
3702 }
3703 if (match.hit)
3704 {
3705 {
3706 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3707
3708 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3709 return soulng::parser::Match(true, new sngcpp::ast::NewExpressionNode(s, placement.release(), typeExpr.release(), initializer.release()));
3710 }
3711 }
3712 *parentMatch0 = match;
3713 }
3714 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3715
3716
3717
3718
3719
3720 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3721 if (!match.hit)
3722 {
3723 match.value = nullptr;
3724 }
3725 return match;
3726 }
3727
3728 soulng::parser::Match ExpressionParser::NewPlacement(CppLexer& lexer, sngcpp::cppparser::ParsingContext* ctx)
3729 {
3730 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3731
3732
3733
3734
3735
3736
3737
3738 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3739 std::unique_ptr<sngcpp::ast::Node> exprList;
3740 soulng::parser::Match match(false);
3741 soulng::parser::Match* parentMatch0 = &match;
3742 {
3743 soulng::parser::Match match(false);
3744 soulng::parser::Match* parentMatch1 = &match;
3745 {
3746 soulng::parser::Match match(false);
3747 if (*lexer == LPAREN)
3748 {
3749 ++lexer;
3750 match.hit = true;
3751 }
3752 *parentMatch1 = match;
3753 }
3754 if (match.hit)
3755 {
3756 soulng::parser::Match match(false);
3757 soulng::parser::Match* parentMatch2 = &match;
3758 {
3759 soulng::parser::Match match = ExpressionParser::ExpressionList(lexer, ctx);
3760 exprList.reset(static_cast<sngcpp::ast::Node*>(match.value));
3761 *parentMatch2 = match;
3762 }
3763 *parentMatch1 = match;
3764 }
3765 *parentMatch0 = match;
3766 }
3767 if (match.hit)
3768 {
3769 soulng::parser::Match match(false);
3770 soulng::parser::Match* parentMatch3 = &match;
3771 {
3772 soulng::parser::Match match(false);
3773 soulng::parser::Match* parentMatch4 = &match;
3774 {
3775 int64_t pos = lexer.GetPos();
3776 soulng::parser::Match match(false);
3777 if (*lexer == RPAREN)
3778 {
3779 ++lexer;
3780 match.hit = true;
3781 }
3782 if (match.hit)
3783 {
3784 {
3785 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3786
3787 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3788 return soulng::parser::Match(true, exprList.release());
3789 }
3790 }
3791 *parentMatch4 = match;
3792 }
3793 *parentMatch3 = match;
3794 }
3795 *parentMatch0 = match;
3796 }
3797 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3798
3799
3800
3801
3802
3803 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3804 if (!match.hit)
3805 {
3806 match.value = nullptr;
3807 }
3808 return match;
3809 }
3810
3811 soulng::parser::Match ExpressionParser::NewInitializer(CppLexer& lexer, sngcpp::cppparser::ParsingContext* ctx)
3812 {
3813 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3814
3815
3816
3817
3818
3819
3820
3821 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3822 std::unique_ptr<sngcpp::ast::Node> args;
3823 soulng::parser::Match match(false);
3824 soulng::parser::Match* parentMatch0 = &match;
3825 {
3826 soulng::parser::Match match(false);
3827 soulng::parser::Match* parentMatch1 = &match;
3828 {
3829 soulng::parser::Match match(false);
3830 if (*lexer == LPAREN)
3831 {
3832 ++lexer;
3833 match.hit = true;
3834 }
3835 *parentMatch1 = match;
3836 }
3837 if (match.hit)
3838 {
3839 soulng::parser::Match match(false);
3840 soulng::parser::Match* parentMatch2 = &match;
3841 {
3842 soulng::parser::Match match = ExpressionParser::ArgumentList(lexer, ctx);
3843 args.reset(static_cast<sngcpp::ast::Node*>(match.value));
3844 *parentMatch2 = match;
3845 }
3846 *parentMatch1 = match;
3847 }
3848 *parentMatch0 = match;
3849 }
3850 if (match.hit)
3851 {
3852 soulng::parser::Match match(false);
3853 soulng::parser::Match* parentMatch3 = &match;
3854 {
3855 soulng::parser::Match match(false);
3856 soulng::parser::Match* parentMatch4 = &match;
3857 {
3858 int64_t pos = lexer.GetPos();
3859 soulng::parser::Match match(false);
3860 if (*lexer == RPAREN)
3861 {
3862 ++lexer;
3863 match.hit = true;
3864 }
3865 if (match.hit)
3866 {
3867 {
3868 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3869
3870 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3871 return soulng::parser::Match(true, args.release());
3872 }
3873 }
3874 *parentMatch4 = match;
3875 }
3876 *parentMatch3 = match;
3877 }
3878 *parentMatch0 = match;
3879 }
3880 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3881
3882
3883
3884
3885
3886 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3887 if (!match.hit)
3888 {
3889 match.value = nullptr;
3890 }
3891 return match;
3892 }
3893
3894 soulng::parser::Match ExpressionParser::ExpressionList(CppLexer& lexer, sngcpp::cppparser::ParsingContext* ctx)
3895 {
3896 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3897
3898
3899
3900
3901
3902
3903
3904 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3905 std::unique_ptr<sngcpp::ast::Node> initializerList;
3906 soulng::parser::Match match(false);
3907 soulng::parser::Match* parentMatch0 = &match;
3908 {
3909 int64_t pos = lexer.GetPos();
3910 soulng::parser::Match match = DeclaratorParser::InitializerList(lexer, ctx);
3911 initializerList.reset(static_cast<sngcpp::ast::Node*>(match.value));
3912 if (match.hit)
3913 {
3914 {
3915 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3916
3917 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3918 return soulng::parser::Match(true, initializerList.release());
3919 }
3920 }
3921 *parentMatch0 = match;
3922 }
3923 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3924
3925
3926
3927
3928
3929 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3930 if (!match.hit)
3931 {
3932 match.value = nullptr;
3933 }
3934 return match;
3935 }
3936
3937 soulng::parser::Match ExpressionParser::ArgumentList(CppLexer& lexer, sngcpp::cppparser::ParsingContext* ctx)
3938 {
3939 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3940
3941
3942
3943
3944
3945
3946
3947 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3948 std::unique_ptr<sngcpp::ast::Node> exprList;
3949 soulng::parser::Match match(false);
3950 soulng::parser::Match* parentMatch0 = &match;
3951 {
3952 int64_t save = lexer.GetPos();
3953 soulng::parser::Match match(false);
3954 soulng::parser::Match* parentMatch1 = &match;
3955 {
3956 int64_t pos = lexer.GetPos();
3957 soulng::parser::Match match = ExpressionParser::ExpressionList(lexer, ctx);
3958 exprList.reset(static_cast<sngcpp::ast::Node*>(match.value));
3959 if (match.hit)
3960 {
3961 {
3962 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3963
3964 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3965 return soulng::parser::Match(true, exprList.release());
3966 }
3967 }
3968 *parentMatch1 = match;
3969 }
3970 *parentMatch0 = match;
3971 if (!match.hit)
3972 {
3973 soulng::parser::Match match(false);
3974 soulng::parser::Match* parentMatch2 = &match;
3975 lexer.SetPos(save);
3976 {
3977 soulng::parser::Match match(false);
3978 soulng::parser::Match* parentMatch3 = &match;
3979 {
3980 int64_t pos = lexer.GetPos();
3981 soulng::parser::Match match(true);
3982 if (match.hit)
3983 {
3984 {
3985 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3986
3987 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3988 return soulng::parser::Match(true, nullptr);
3989 }
3990 }
3991 *parentMatch3 = match;
3992 }
3993 *parentMatch2 = match;
3994 }
3995 *parentMatch0 = match;
3996 }
3997 }
3998 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3999
4000
4001
4002
4003
4004 #endif // SOULNG_PARSER_DEBUG_SUPPORT
4005 if (!match.hit)
4006 {
4007 match.value = nullptr;
4008 }
4009 return match;
4010 }
4011
4012 soulng::parser::Match ExpressionParser::DeleteExpression(CppLexer& lexer, sngcpp::cppparser::ParsingContext* ctx)
4013 {
4014 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
4015
4016
4017
4018
4019
4020
4021
4022 #endif // SOULNG_PARSER_DEBUG_SUPPORT
4023 bool array = bool();
4024 Span s = Span();
4025 std::unique_ptr<sngcpp::ast::Node> castExpr;
4026 soulng::parser::Match match(false);
4027 soulng::parser::Match* parentMatch0 = &match;
4028 {
4029 soulng::parser::Match match(false);
4030 soulng::parser::Match* parentMatch1 = &match;
4031 {
4032 soulng::parser::Match match(false);
4033 soulng::parser::Match* parentMatch2 = &match;
4034 {
4035 int64_t pos = lexer.GetPos();
4036 soulng::lexer::Span span = lexer.GetSpan();
4037 soulng::parser::Match match(false);
4038 if (*lexer == DELETE)
4039 {
4040 ++lexer;
4041 match.hit = true;
4042 }
4043 if (match.hit)
4044 {
4045 s = span;
4046 }
4047 *parentMatch2 = match;
4048 }
4049 *parentMatch1 = match;
4050 }
4051 if (match.hit)
4052 {
4053 soulng::parser::Match match(false);
4054 soulng::parser::Match* parentMatch3 = &match;
4055 {
4056 soulng::parser::Match match(true);
4057 int64_t save = lexer.GetPos();
4058 soulng::parser::Match* parentMatch4 = &match;
4059 {
4060 soulng::parser::Match match(false);
4061 soulng::parser::Match* parentMatch5 = &match;
4062 {
4063 soulng::parser::Match match(false);
4064 soulng::parser::Match* parentMatch6 = &match;
4065 {
4066 soulng::parser::Match match(false);
4067 if (*lexer == LBRACKET)
4068 {
4069 ++lexer;
4070 match.hit = true;
4071 }
4072 *parentMatch6 = match;
4073 }
4074 if (match.hit)
4075 {
4076 soulng::parser::Match match(false);
4077 soulng::parser::Match* parentMatch7 = &match;
4078 {
4079 soulng::parser::Match match(false);
4080 soulng::parser::Match* parentMatch8 = &match;
4081 {
4082 int64_t pos = lexer.GetPos();
4083 soulng::parser::Match match(false);
4084 if (*lexer == RBRACKET)
4085 {
4086 ++lexer;
4087 match.hit = true;
4088 }
4089 if (match.hit)
4090 {
4091 array = true;
4092 }
4093 *parentMatch8 = match;
4094 }
4095 *parentMatch7 = match;
4096 }
4097 *parentMatch6 = match;
4098 }
4099 *parentMatch5 = match;
4100 }
4101 if (match.hit)
4102 {
4103 *parentMatch4 = match;
4104 }
4105 else
4106 {
4107 lexer.SetPos(save);
4108 }
4109 }
4110 *parentMatch3 = match;
4111 }
4112 *parentMatch1 = match;
4113 }
4114 *parentMatch0 = match;
4115 }
4116 if (match.hit)
4117 {
4118 soulng::parser::Match match(false);
4119 soulng::parser::Match* parentMatch9 = &match;
4120 {
4121 soulng::parser::Match match(false);
4122 soulng::parser::Match* parentMatch10 = &match;
4123 {
4124 int64_t pos = lexer.GetPos();
4125 soulng::lexer::Span span = lexer.GetSpan();
4126 soulng::parser::Match match = ExpressionParser::CastExpression(lexer, ctx);
4127 castExpr.reset(static_cast<sngcpp::ast::Node*>(match.value));
4128 if (match.hit)
4129 {
4130 s.end = span.end;
4131 {
4132 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
4133
4134 #endif // SOULNG_PARSER_DEBUG_SUPPORT
4135 return soulng::parser::Match(true, new sngcpp::ast::DeleteExpressionNode(s, array, castExpr.release()));
4136 }
4137 }
4138 *parentMatch10 = match;
4139 }
4140 *parentMatch9 = match;
4141 }
4142 *parentMatch0 = match;
4143 }
4144 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
4145
4146
4147
4148
4149
4150 #endif // SOULNG_PARSER_DEBUG_SUPPORT
4151 if (!match.hit)
4152 {
4153 match.value = nullptr;
4154 }
4155 return match;
4156 }
4157
4158 soulng::parser::Match ExpressionParser::PostfixExpression(CppLexer& lexer, sngcpp::cppparser::ParsingContext* ctx)
4159 {
4160 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
4161
4162
4163
4164
4165
4166
4167
4168 #endif // SOULNG_PARSER_DEBUG_SUPPORT
4169 std::unique_ptr<sngcpp::ast::Node> expr = std::unique_ptr<sngcpp::ast::Node>();
4170 Span s = Span();
4171 std::unique_ptr<sngcpp::ast::Node> primaryExpr;
4172 std::unique_ptr<sngcpp::ast::Node> index;
4173 std::unique_ptr<sngcpp::ast::Node> args;
4174 std::unique_ptr<sngcpp::ast::Node> id1;
4175 std::unique_ptr<sngcpp::ast::Node> id2;
4176 soulng::parser::Match match(false);
4177 soulng::parser::Match* parentMatch0 = &match;
4178 {
4179 int64_t pos = lexer.GetPos();
4180 soulng::parser::Match match(false);
4181 soulng::parser::Match* parentMatch1 = &match;
4182 {
4183 soulng::parser::Match match(false);
4184 soulng::parser::Match* parentMatch2 = &match;
4185 {
4186 soulng::parser::Match match(false);
4187 soulng::parser::Match* parentMatch3 = &match;
4188 {
4189 int64_t pos = lexer.GetPos();
4190 soulng::lexer::Span span = lexer.GetSpan();
4191 soulng::parser::Match match = ExpressionParser::PrimaryExpression(lexer, ctx);
4192 primaryExpr.reset(static_cast<sngcpp::ast::Node*>(match.value));
4193 if (match.hit)
4194 {
4195 expr.reset(primaryExpr.release());
4196 s = span;
4197 }
4198 *parentMatch3 = match;
4199 }
4200 *parentMatch2 = match;
4201 }
4202 if (match.hit)
4203 {
4204 soulng::parser::Match match(false);
4205 soulng::parser::Match* parentMatch4 = &match;
4206 {
4207 soulng::parser::Match match(true);
4208 soulng::parser::Match* parentMatch5 = &match;
4209 {
4210 while (true)
4211 {
4212 int64_t save = lexer.GetPos();
4213 {
4214 soulng::parser::Match match(false);
4215 soulng::parser::Match* parentMatch6 = &match;
4216 {
4217 soulng::parser::Match match(false);
4218 soulng::parser::Match* parentMatch7 = &match;
4219 {
4220 int64_t save = lexer.GetPos();
4221 soulng::parser::Match match(false);
4222 soulng::parser::Match* parentMatch8 = &match;
4223 {
4224 int64_t save = lexer.GetPos();
4225 soulng::parser::Match match(false);
4226 soulng::parser::Match* parentMatch9 = &match;
4227 {
4228 int64_t save = lexer.GetPos();
4229 soulng::parser::Match match(false);
4230 soulng::parser::Match* parentMatch10 = &match;
4231 {
4232 int64_t save = lexer.GetPos();
4233 soulng::parser::Match match(false);
4234 soulng::parser::Match* parentMatch11 = &match;
4235 {
4236 int64_t save = lexer.GetPos();
4237 soulng::parser::Match match(false);
4238 soulng::parser::Match* parentMatch12 = &match;
4239 {
4240 soulng::parser::Match match(false);
4241 soulng::parser::Match* parentMatch13 = &match;
4242 {
4243 int64_t pos = lexer.GetPos();
4244 soulng::parser::Match match(false);
4245 if (*lexer == LBRACKET)
4246 {
4247 ++lexer;
4248 match.hit = true;
4249 }
4250 if (match.hit)
4251 {
4252 ctx->BeginParsingArguments();
4253 }
4254 *parentMatch13 = match;
4255 }
4256 *parentMatch12 = match;
4257 }
4258 if (match.hit)
4259 {
4260 soulng::parser::Match match(false);
4261 soulng::parser::Match* parentMatch14 = &match;
4262 {
4263 soulng::parser::Match match(false);
4264 soulng::parser::Match* parentMatch15 = &match;
4265 {
4266 int64_t pos = lexer.GetPos();
4267 soulng::lexer::Span span = lexer.GetSpan();
4268 soulng::parser::Match match(false);
4269 soulng::parser::Match* parentMatch16 = &match;
4270 {
4271 soulng::parser::Match match(false);
4272 soulng::parser::Match* parentMatch17 = &match;
4273 {
4274 soulng::parser::Match match = ExpressionParser::Expression(lexer, ctx);
4275 index.reset(static_cast<sngcpp::ast::Node*>(match.value));
4276 *parentMatch17 = match;
4277 }
4278 if (match.hit)
4279 {
4280 soulng::parser::Match match(false);
4281 soulng::parser::Match* parentMatch18 = &match;
4282 {
4283 soulng::parser::Match match(false);
4284 if (*lexer == RBRACKET)
4285 {
4286 ++lexer;
4287 match.hit = true;
4288 }
4289 *parentMatch18 = match;
4290 }
4291 *parentMatch17 = match;
4292 }
4293 *parentMatch16 = match;
4294 }
4295 if (match.hit)
4296 {
4297 s.end = span.end;
4298 ctx->EndParsingArguments();
4299 expr.reset(new sngcpp::ast::SubscriptExpressionNode(s, expr.release(), index.release()));
4300 }
4301 else
4302 {
4303 ctx->EndParsingArguments();
4304 }
4305 *parentMatch15 = match;
4306 }
4307 *parentMatch14 = match;
4308 }
4309 *parentMatch12 = match;
4310 }
4311 *parentMatch11 = match;
4312 if (!match.hit)
4313 {
4314 soulng::parser::Match match(false);
4315 soulng::parser::Match* parentMatch19 = &match;
4316 lexer.SetPos(save);
4317 {
4318 soulng::parser::Match match(false);
4319 soulng::parser::Match* parentMatch20 = &match;
4320 {
4321 soulng::parser::Match match(false);
4322 soulng::parser::Match* parentMatch21 = &match;
4323 {
4324 int64_t pos = lexer.GetPos();
4325 soulng::parser::Match match(false);
4326 if (*lexer == LPAREN)
4327 {
4328 ++lexer;
4329 match.hit = true;
4330 }
4331 if (match.hit)
4332 {
4333 ctx->BeginParsingArguments();
4334 }
4335 *parentMatch21 = match;
4336 }
4337 *parentMatch20 = match;
4338 }
4339 if (match.hit)
4340 {
4341 soulng::parser::Match match(false);
4342 soulng::parser::Match* parentMatch22 = &match;
4343 {
4344 soulng::parser::Match match(false);
4345 soulng::parser::Match* parentMatch23 = &match;
4346 {
4347 int64_t pos = lexer.GetPos();
4348 soulng::lexer::Span span = lexer.GetSpan();
4349 soulng::parser::Match match(false);
4350 soulng::parser::Match* parentMatch24 = &match;
4351 {
4352 soulng::parser::Match match(false);
4353 soulng::parser::Match* parentMatch25 = &match;
4354 {
4355 soulng::parser::Match match = ExpressionParser::ArgumentList(lexer, ctx);
4356 args.reset(static_cast<sngcpp::ast::Node*>(match.value));
4357 *parentMatch25 = match;
4358 }
4359 if (match.hit)
4360 {
4361 soulng::parser::Match match(false);
4362 soulng::parser::Match* parentMatch26 = &match;
4363 {
4364 soulng::parser::Match match(false);
4365 if (*lexer == RPAREN)
4366 {
4367 ++lexer;
4368 match.hit = true;
4369 }
4370 *parentMatch26 = match;
4371 }
4372 *parentMatch25 = match;
4373 }
4374 *parentMatch24 = match;
4375 }
4376 if (match.hit)
4377 {
4378 s.end = span.end;
4379 ctx->EndParsingArguments();
4380 expr.reset(new sngcpp::ast::InvokeExpressionNode(s, expr.release(), args.release()));
4381 }
4382 else
4383 {
4384 ctx->EndParsingArguments();
4385 }
4386 *parentMatch23 = match;
4387 }
4388 *parentMatch22 = match;
4389 }
4390 *parentMatch20 = match;
4391 }
4392 *parentMatch19 = match;
4393 }
4394 *parentMatch11 = match;
4395 }
4396 }
4397 *parentMatch10 = match;
4398 if (!match.hit)
4399 {
4400 soulng::parser::Match match(false);
4401 soulng::parser::Match* parentMatch27 = &match;
4402 lexer.SetPos(save);
4403 {
4404 soulng::parser::Match match(false);
4405 soulng::parser::Match* parentMatch28 = &match;
4406 {
4407 soulng::parser::Match match(false);
4408 if (*lexer == DOT)
4409 {
4410 ++lexer;
4411 match.hit = true;
4412 }
4413 *parentMatch28 = match;
4414 }
4415 if (match.hit)
4416 {
4417 soulng::parser::Match match(false);
4418 soulng::parser::Match* parentMatch29 = &match;
4419 {
4420 soulng::parser::Match match(false);
4421 soulng::parser::Match* parentMatch30 = &match;
4422 {
4423 int64_t pos = lexer.GetPos();
4424 soulng::lexer::Span span = lexer.GetSpan();
4425 soulng::parser::Match match = ExpressionParser::IdExpression(lexer, ctx);
4426 id1.reset(static_cast<sngcpp::ast::Node*>(match.value));
4427 if (match.hit)
4428 {
4429 s.end = span.end;
4430 expr.reset(new sngcpp::ast::DotNode(s, expr.release(), id1.release()));
4431 }
4432 *parentMatch30 = match;
4433 }
4434 *parentMatch29 = match;
4435 }
4436 *parentMatch28 = match;
4437 }
4438 *parentMatch27 = match;
4439 }
4440 *parentMatch10 = match;
4441 }
4442 }
4443 *parentMatch9 = match;
4444 if (!match.hit)
4445 {
4446 soulng::parser::Match match(false);
4447 soulng::parser::Match* parentMatch31 = &match;
4448 lexer.SetPos(save);
4449 {
4450 soulng::parser::Match match(false);
4451 soulng::parser::Match* parentMatch32 = &match;
4452 {
4453 soulng::parser::Match match(false);
4454 if (*lexer == ARROW)
4455 {
4456 ++lexer;
4457 match.hit = true;
4458 }
4459 *parentMatch32 = match;
4460 }
4461 if (match.hit)
4462 {
4463 soulng::parser::Match match(false);
4464 soulng::parser::Match* parentMatch33 = &match;
4465 {
4466 soulng::parser::Match match(false);
4467 soulng::parser::Match* parentMatch34 = &match;
4468 {
4469 int64_t pos = lexer.GetPos();
4470 soulng::lexer::Span span = lexer.GetSpan();
4471 soulng::parser::Match match = ExpressionParser::IdExpression(lexer, ctx);
4472 id2.reset(static_cast<sngcpp::ast::Node*>(match.value));
4473 if (match.hit)
4474 {
4475 s.end = span.end;
4476 expr.reset(new sngcpp::ast::ArrowNode(s, expr.release(), id2.release()));
4477 }
4478 *parentMatch34 = match;
4479 }
4480 *parentMatch33 = match;
4481 }
4482 *parentMatch32 = match;
4483 }
4484 *parentMatch31 = match;
4485 }
4486 *parentMatch9 = match;
4487 }
4488 }
4489 *parentMatch8 = match;
4490 if (!match.hit)
4491 {
4492 soulng::parser::Match match(false);
4493 soulng::parser::Match* parentMatch35 = &match;
4494 lexer.SetPos(save);
4495 {
4496 soulng::parser::Match match(false);
4497 soulng::parser::Match* parentMatch36 = &match;
4498 {
4499 int64_t pos = lexer.GetPos();
4500 soulng::lexer::Span span = lexer.GetSpan();
4501 soulng::parser::Match match(false);
4502 if (*lexer == PLUSPLUS)
4503 {
4504 ++lexer;
4505 match.hit = true;
4506 }
4507 if (match.hit)
4508 {
4509 s.end = span.end;
4510 expr.reset(new sngcpp::ast::PostfixIncNode(s, expr.release()));
4511 }
4512 *parentMatch36 = match;
4513 }
4514 *parentMatch35 = match;
4515 }
4516 *parentMatch8 = match;
4517 }
4518 }
4519 *parentMatch7 = match;
4520 if (!match.hit)
4521 {
4522 soulng::parser::Match match(false);
4523 soulng::parser::Match* parentMatch37 = &match;
4524 lexer.SetPos(save);
4525 {
4526 soulng::parser::Match match(false);
4527 soulng::parser::Match* parentMatch38 = &match;
4528 {
4529 int64_t pos = lexer.GetPos();
4530 soulng::lexer::Span span = lexer.GetSpan();
4531 soulng::parser::Match match(false);
4532 if (*lexer == MINUSMINUS)
4533 {
4534 ++lexer;
4535 match.hit = true;
4536 }
4537 if (match.hit)
4538 {
4539 s.end = span.end;
4540 expr.reset(new sngcpp::ast::PostfixDecNode(s, expr.release()));
4541 }
4542 *parentMatch38 = match;
4543 }
4544 *parentMatch37 = match;
4545 }
4546 *parentMatch7 = match;
4547 }
4548 }
4549 *parentMatch6 = match;
4550 }
4551 if (match.hit)
4552 {
4553 *parentMatch5 = match;
4554 }
4555 else
4556 {
4557 lexer.SetPos(save);
4558 break;
4559 }
4560 }
4561 }
4562 }
4563 *parentMatch4 = match;
4564 }
4565 *parentMatch2 = match;
4566 }
4567 *parentMatch1 = match;
4568 }
4569 if (match.hit)
4570 {
4571 {
4572 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
4573
4574 #endif // SOULNG_PARSER_DEBUG_SUPPORT
4575 return soulng::parser::Match(true, expr.release());
4576 }
4577 }
4578 *parentMatch0 = match;
4579 }
4580 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
4581
4582
4583
4584
4585
4586 #endif // SOULNG_PARSER_DEBUG_SUPPORT
4587 if (!match.hit)
4588 {
4589 match.value = nullptr;
4590 }
4591 return match;
4592 }
4593
4594 soulng::parser::Match ExpressionParser::PrimaryExpression(CppLexer& lexer, sngcpp::cppparser::ParsingContext* ctx)
4595 {
4596 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
4597
4598
4599
4600
4601
4602
4603
4604 #endif // SOULNG_PARSER_DEBUG_SUPPORT
4605 std::unique_ptr<sngcpp::ast::Node> expr = std::unique_ptr<sngcpp::ast::Node>();
4606 Span s = Span();
4607 std::unique_ptr<sngcpp::ast::LiteralNode> literal;
4608 std::unique_ptr<sngcpp::ast::Node> e;
4609 std::unique_ptr<sngcpp::ast::Node> cppCastExpr;
4610 std::unique_ptr<sngcpp::ast::Node> typeIdExpr;
4611 std::unique_ptr<soulng::parser::soulng::parser::Value<sngcpp::ast::SimpleTypeSpecifier>>s1;
4612 std::unique_ptr<sngcpp::ast::Node> args1;
4613 std::unique_ptr<soulng::parser::soulng::parser::Value<sngcpp::ast::SimpleTypeSpecifier>>s2;
4614 std::unique_ptr<sngcpp::ast::Node> bracedInitializerList1;
4615 std::unique_ptr<sngcpp::ast::Node> t1;
4616 std::unique_ptr<sngcpp::ast::Node> args2;
4617 std::unique_ptr<sngcpp::ast::Node> t2;
4618 std::unique_ptr<sngcpp::ast::Node> bracedInitializerList2;
4619 std::unique_ptr<sngcpp::ast::Node> idExpr;
4620 std::unique_ptr<sngcpp::ast::Node> lambdaExpr;
4621 soulng::parser::Match match(false);
4622 soulng::parser::Match* parentMatch0 = &match;
4623 {
4624 int64_t pos = lexer.GetPos();
4625 soulng::parser::Match match(false);
4626 soulng::parser::Match* parentMatch1 = &match;
4627 {
4628 soulng::parser::Match match(false);
4629 soulng::parser::Match* parentMatch2 = &match;
4630 {
4631 int64_t save = lexer.GetPos();
4632 soulng::parser::Match match(false);
4633 soulng::parser::Match* parentMatch3 = &match;
4634 {
4635 int64_t save = lexer.GetPos();
4636 soulng::parser::Match match(false);
4637 soulng::parser::Match* parentMatch4 = &match;
4638 {
4639 int64_t save = lexer.GetPos();
4640 soulng::parser::Match match(false);
4641 soulng::parser::Match* parentMatch5 = &match;
4642 {
4643 int64_t save = lexer.GetPos();
4644 soulng::parser::Match match(false);
4645 soulng::parser::Match* parentMatch6 = &match;
4646 {
4647 int64_t save = lexer.GetPos();
4648 soulng::parser::Match match(false);
4649 soulng::parser::Match* parentMatch7 = &match;
4650 {
4651 int64_t save = lexer.GetPos();
4652 soulng::parser::Match match(false);
4653 soulng::parser::Match* parentMatch8 = &match;
4654 {
4655 int64_t save = lexer.GetPos();
4656 soulng::parser::Match match(false);
4657 soulng::parser::Match* parentMatch9 = &match;
4658 {
4659 int64_t save = lexer.GetPos();
4660 soulng::parser::Match match(false);
4661 soulng::parser::Match* parentMatch10 = &match;
4662 {
4663 int64_t save = lexer.GetPos();
4664 soulng::parser::Match match(false);
4665 soulng::parser::Match* parentMatch11 = &match;
4666 {
4667 int64_t save = lexer.GetPos();
4668 soulng::parser::Match match(false);
4669 soulng::parser::Match* parentMatch12 = &match;
4670 {
4671 int64_t pos = lexer.GetPos();
4672 soulng::parser::Match match = LiteralParser::Literal(lexer);
4673 literal.reset(static_cast<sngcpp::ast::LiteralNode*>(match.value));
4674 if (match.hit)
4675 {
4676 expr.reset(literal.release());
4677 }
4678 *parentMatch12 = match;
4679 }
4680 *parentMatch11 = match;
4681 if (!match.hit)
4682 {
4683 soulng::parser::Match match(false);
4684 soulng::parser::Match* parentMatch13 = &match;
4685 lexer.SetPos(save);
4686 {
4687 soulng::parser::Match match(false);
4688 soulng::parser::Match* parentMatch14 = &match;
4689 {
4690 int64_t pos = lexer.GetPos();
4691 soulng::lexer::Span span = lexer.GetSpan();
4692 soulng::parser::Match match(false);
4693 if (*lexer == THIS)
4694 {
4695 ++lexer;
4696 match.hit = true;
4697 }
4698 if (match.hit)
4699 {
4700 expr.reset(new sngcpp::ast::ThisNode(span));
4701 }
4702 *parentMatch14 = match;
4703 }
4704 *parentMatch13 = match;
4705 }
4706 *parentMatch11 = match;
4707 }
4708 }
4709 *parentMatch10 = match;
4710 if (!match.hit)
4711 {
4712 soulng::parser::Match match(false);
4713 soulng::parser::Match* parentMatch15 = &match;
4714 lexer.SetPos(save);
4715 {
4716 soulng::parser::Match match(false);
4717 soulng::parser::Match* parentMatch16 = &match;
4718 {
4719 soulng::parser::Match match(false);
4720 soulng::parser::Match* parentMatch17 = &match;
4721 {
4722 soulng::parser::Match match(false);
4723 soulng::parser::Match* parentMatch18 = &match;
4724 {
4725 int64_t pos = lexer.GetPos();
4726 soulng::lexer::Span span = lexer.GetSpan();
4727 soulng::parser::Match match(false);
4728 if (*lexer == LPAREN)
4729 {
4730 ++lexer;
4731 match.hit = true;
4732 }
4733 if (match.hit)
4734 {
4735 s = span;
4736 }
4737 *parentMatch18 = match;
4738 }
4739 *parentMatch17 = match;
4740 }
4741 if (match.hit)
4742 {
4743 soulng::parser::Match match(false);
4744 soulng::parser::Match* parentMatch19 = &match;
4745 {
4746 soulng::parser::Match match = ExpressionParser::Expression(lexer, ctx);
4747 e.reset(static_cast<sngcpp::ast::Node*>(match.value));
4748 *parentMatch19 = match;
4749 }
4750 *parentMatch17 = match;
4751 }
4752 *parentMatch16 = match;
4753 }
4754 if (match.hit)
4755 {
4756 soulng::parser::Match match(false);
4757 soulng::parser::Match* parentMatch20 = &match;
4758 {
4759 soulng::parser::Match match(false);
4760 soulng::parser::Match* parentMatch21 = &match;
4761 {
4762 int64_t pos = lexer.GetPos();
4763 soulng::lexer::Span span = lexer.GetSpan();
4764 soulng::parser::Match match(false);
4765 if (*lexer == RPAREN)
4766 {
4767 ++lexer;
4768 match.hit = true;
4769 }
4770 if (match.hit)
4771 {
4772 s.end = span.end;
4773 expr.reset(new sngcpp::ast::ParenthesizedExprNode(s, e.release()));
4774 }
4775 *parentMatch21 = match;
4776 }
4777 *parentMatch20 = match;
4778 }
4779 *parentMatch16 = match;
4780 }
4781 *parentMatch15 = match;
4782 }
4783 *parentMatch10 = match;
4784 }
4785 }
4786 *parentMatch9 = match;
4787 if (!match.hit)
4788 {
4789 soulng::parser::Match match(false);
4790 soulng::parser::Match* parentMatch22 = &match;
4791 lexer.SetPos(save);
4792 {
4793 soulng::parser::Match match(false);
4794 soulng::parser::Match* parentMatch23 = &match;
4795 {
4796 int64_t pos = lexer.GetPos();
4797 soulng::parser::Match match = ExpressionParser::CppCastExpression(lexer, ctx);
4798 cppCastExpr.reset(static_cast<sngcpp::ast::Node*>(match.value));
4799 if (match.hit)
4800 {
4801 expr.reset(cppCastExpr.release());
4802 }
4803 *parentMatch23 = match;
4804 }
4805 *parentMatch22 = match;
4806 }
4807 *parentMatch9 = match;
4808 }
4809 }
4810 *parentMatch8 = match;
4811 if (!match.hit)
4812 {
4813 soulng::parser::Match match(false);
4814 soulng::parser::Match* parentMatch24 = &match;
4815 lexer.SetPos(save);
4816 {
4817 soulng::parser::Match match(false);
4818 soulng::parser::Match* parentMatch25 = &match;
4819 {
4820 int64_t pos = lexer.GetPos();
4821 soulng::parser::Match match = ExpressionParser::TypeIdExpression(lexer, ctx);
4822 typeIdExpr.reset(static_cast<sngcpp::ast::Node*>(match.value));
4823 if (match.hit)
4824 {
4825 expr.reset(typeIdExpr.release());
4826 }
4827 *parentMatch25 = match;
4828 }
4829 *parentMatch24 = match;
4830 }
4831 *parentMatch8 = match;
4832 }
4833 }
4834 *parentMatch7 = match;
4835 if (!match.hit)
4836 {
4837 soulng::parser::Match match(false);
4838 soulng::parser::Match* parentMatch26 = &match;
4839 lexer.SetPos(save);
4840 {
4841 soulng::parser::Match match(false);
4842 soulng::parser::Match* parentMatch27 = &match;
4843 {
4844 soulng::parser::Match match(false);
4845 soulng::parser::Match* parentMatch28 = &match;
4846 {
4847 soulng::parser::Match match(false);
4848 soulng::parser::Match* parentMatch29 = &match;
4849 {
4850 soulng::parser::Match match(false);
4851 soulng::parser::Match* parentMatch30 = &match;
4852 {
4853 int64_t pos = lexer.GetPos();
4854 soulng::lexer::Span span = lexer.GetSpan();
4855 soulng::parser::Match match = SimpleTypeParser::SimpleTypeSpecifier(lexer);
4856 s1.reset(static_cast<soulng::parser::soulng::parser::Value<sngcpp::ast::SimpleTypeSpecifier>*>(match.value));
4857 if (match.hit)
4858 {
4859 s = span;
4860 }
4861 *parentMatch30 = match;
4862 }
4863 *parentMatch29 = match;
4864 }
4865 if (match.hit)
4866 {
4867 soulng::parser::Match match(false);
4868 soulng::parser::Match* parentMatch31 = &match;
4869 {
4870 soulng::parser::Match match(false);
4871 if (*lexer == LPAREN)
4872 {
4873 ++lexer;
4874 match.hit = true;
4875 }
4876 *parentMatch31 = match;
4877 }
4878 *parentMatch29 = match;
4879 }
4880 *parentMatch28 = match;
4881 }
4882 if (match.hit)
4883 {
4884 soulng::parser::Match match(false);
4885 soulng::parser::Match* parentMatch32 = &match;
4886 {
4887 soulng::parser::Match match = ExpressionParser::ArgumentList(lexer, ctx);
4888 args1.reset(static_cast<sngcpp::ast::Node*>(match.value));
4889 *parentMatch32 = match;
4890 }
4891 *parentMatch28 = match;
4892 }
4893 *parentMatch27 = match;
4894 }
4895 if (match.hit)
4896 {
4897 soulng::parser::Match match(false);
4898 soulng::parser::Match* parentMatch33 = &match;
4899 {
4900 soulng::parser::Match match(false);
4901 soulng::parser::Match* parentMatch34 = &match;
4902 {
4903 int64_t pos = lexer.GetPos();
4904 soulng::lexer::Span span = lexer.GetSpan();
4905 soulng::parser::Match match(false);
4906 if (*lexer == RPAREN)
4907 {
4908 ++lexer;
4909 match.hit = true;
4910 }
4911 if (match.hit)
4912 {
4913 s.end = span.end;
4914 expr.reset(new sngcpp::ast::InvokeExpressionNode(s, new sngcpp::ast::SimpleTypeNode(s, std::vector< sngcpp::ast::SimpleTypeSpecifier>( 1, s1->value)), args1.release()));
4915 }
4916 *parentMatch34 = match;
4917 }
4918 *parentMatch33 = match;
4919 }
4920 *parentMatch27 = match;
4921 }
4922 *parentMatch26 = match;
4923 }
4924 *parentMatch7 = match;
4925 }
4926 }
4927 *parentMatch6 = match;
4928 if (!match.hit)
4929 {
4930 soulng::parser::Match match(false);
4931 soulng::parser::Match* parentMatch35 = &match;
4932 lexer.SetPos(save);
4933 {
4934 soulng::parser::Match match(false);
4935 soulng::parser::Match* parentMatch36 = &match;
4936 {
4937 soulng::parser::Match match(false);
4938 soulng::parser::Match* parentMatch37 = &match;
4939 {
4940 int64_t pos = lexer.GetPos();
4941 soulng::lexer::Span span = lexer.GetSpan();
4942 soulng::parser::Match match = SimpleTypeParser::SimpleTypeSpecifier(lexer);
4943 s2.reset(static_cast<soulng::parser::soulng::parser::Value<sngcpp::ast::SimpleTypeSpecifier>*>(match.value));
4944 if (match.hit)
4945 {
4946 s = span;
4947 }
4948 *parentMatch37 = match;
4949 }
4950 *parentMatch36 = match;
4951 }
4952 if (match.hit)
4953 {
4954 soulng::parser::Match match(false);
4955 soulng::parser::Match* parentMatch38 = &match;
4956 {
4957 soulng::parser::Match match(false);
4958 soulng::parser::Match* parentMatch39 = &match;
4959 {
4960 int64_t pos = lexer.GetPos();
4961 soulng::lexer::Span span = lexer.GetSpan();
4962 soulng::parser::Match match = DeclaratorParser::BracedInitializerList(lexer, ctx);
4963 bracedInitializerList1.reset(static_cast<sngcpp::ast::Node*>(match.value));
4964 if (match.hit)
4965 {
4966 s.end = span.end;
4967 expr.reset(new sngcpp::ast::InvokeExpressionNode(s, new sngcpp::ast::SimpleTypeNode(s, std::vector< sngcpp::ast::SimpleTypeSpecifier>( 1, s2->value)), bracedInitializerList1.release()));
4968 }
4969 *parentMatch39 = match;
4970 }
4971 *parentMatch38 = match;
4972 }
4973 *parentMatch36 = match;
4974 }
4975 *parentMatch35 = match;
4976 }
4977 *parentMatch6 = match;
4978 }
4979 }
4980 *parentMatch5 = match;
4981 if (!match.hit)
4982 {
4983 soulng::parser::Match match(false);
4984 soulng::parser::Match* parentMatch40 = &match;
4985 lexer.SetPos(save);
4986 {
4987 soulng::parser::Match match(false);
4988 soulng::parser::Match* parentMatch41 = &match;
4989 {
4990 soulng::parser::Match match(false);
4991 soulng::parser::Match* parentMatch42 = &match;
4992 {
4993 soulng::parser::Match match(false);
4994 soulng::parser::Match* parentMatch43 = &match;
4995 {
4996 soulng::parser::Match match(false);
4997 soulng::parser::Match* parentMatch44 = &match;
4998 {
4999 int64_t pos = lexer.GetPos();
5000 soulng::lexer::Span span = lexer.GetSpan();
5001 soulng::parser::Match match = TypeExprParser::TypeExpr(lexer, ctx);
5002 t1.reset(static_cast<sngcpp::ast::Node*>(match.value));
5003 if (match.hit)
5004 {
5005 s = span;
5006 }
5007 *parentMatch44 = match;
5008 }
5009 *parentMatch43 = match;
5010 }
5011 if (match.hit)
5012 {
5013 soulng::parser::Match match(false);
5014 soulng::parser::Match* parentMatch45 = &match;
5015 {
5016 soulng::parser::Match match(false);
5017 if (*lexer == LPAREN)
5018 {
5019 ++lexer;
5020 match.hit = true;
5021 }
5022 *parentMatch45 = match;
5023 }
5024 *parentMatch43 = match;
5025 }
5026 *parentMatch42 = match;
5027 }
5028 if (match.hit)
5029 {
5030 soulng::parser::Match match(false);
5031 soulng::parser::Match* parentMatch46 = &match;
5032 {
5033 soulng::parser::Match match = ExpressionParser::ArgumentList(lexer, ctx);
5034 args2.reset(static_cast<sngcpp::ast::Node*>(match.value));
5035 *parentMatch46 = match;
5036 }
5037 *parentMatch42 = match;
5038 }
5039 *parentMatch41 = match;
5040 }
5041 if (match.hit)
5042 {
5043 soulng::parser::Match match(false);
5044 soulng::parser::Match* parentMatch47 = &match;
5045 {
5046 soulng::parser::Match match(false);
5047 soulng::parser::Match* parentMatch48 = &match;
5048 {
5049 int64_t pos = lexer.GetPos();
5050 soulng::lexer::Span span = lexer.GetSpan();
5051 soulng::parser::Match match(false);
5052 if (*lexer == RPAREN)
5053 {
5054 ++lexer;
5055 match.hit = true;
5056 }
5057 if (match.hit)
5058 {
5059 s.end = span.end;
5060 expr.reset(new sngcpp::ast::InvokeExpressionNode(s, t1.release(), args2.release()));
5061 }
5062 *parentMatch48 = match;
5063 }
5064 *parentMatch47 = match;
5065 }
5066 *parentMatch41 = match;
5067 }
5068 *parentMatch40 = match;
5069 }
5070 *parentMatch5 = match;
5071 }
5072 }
5073 *parentMatch4 = match;
5074 if (!match.hit)
5075 {
5076 soulng::parser::Match match(false);
5077 soulng::parser::Match* parentMatch49 = &match;
5078 lexer.SetPos(save);
5079 {
5080 soulng::parser::Match match(false);
5081 soulng::parser::Match* parentMatch50 = &match;
5082 {
5083 soulng::parser::Match match(false);
5084 soulng::parser::Match* parentMatch51 = &match;
5085 {
5086 int64_t pos = lexer.GetPos();
5087 soulng::lexer::Span span = lexer.GetSpan();
5088 soulng::parser::Match match = TypeExprParser::TypeExpr(lexer, ctx);
5089 t2.reset(static_cast<sngcpp::ast::Node*>(match.value));
5090 if (match.hit)
5091 {
5092 s = span;
5093 }
5094 *parentMatch51 = match;
5095 }
5096 *parentMatch50 = match;
5097 }
5098 if (match.hit)
5099 {
5100 soulng::parser::Match match(false);
5101 soulng::parser::Match* parentMatch52 = &match;
5102 {
5103 soulng::parser::Match match(false);
5104 soulng::parser::Match* parentMatch53 = &match;
5105 {
5106 int64_t pos = lexer.GetPos();
5107 soulng::lexer::Span span = lexer.GetSpan();
5108 soulng::parser::Match match = DeclaratorParser::BracedInitializerList(lexer, ctx);
5109 bracedInitializerList2.reset(static_cast<sngcpp::ast::Node*>(match.value));
5110 if (match.hit)
5111 {
5112 s.end = span.end;
5113 expr.reset(new sngcpp::ast::InvokeExpressionNode(s, t2.release(), bracedInitializerList2.release()));
5114 }
5115 *parentMatch53 = match;
5116 }
5117 *parentMatch52 = match;
5118 }
5119 *parentMatch50 = match;
5120 }
5121 *parentMatch49 = match;
5122 }
5123 *parentMatch4 = match;
5124 }
5125 }
5126 *parentMatch3 = match;
5127 if (!match.hit)
5128 {
5129 soulng::parser::Match match(false);
5130 soulng::parser::Match* parentMatch54 = &match;
5131 lexer.SetPos(save);
5132 {
5133 soulng::parser::Match match(false);
5134 soulng::parser::Match* parentMatch55 = &match;
5135 {
5136 int64_t pos = lexer.GetPos();
5137 soulng::parser::Match match = ExpressionParser::IdExpression(lexer, ctx);
5138 idExpr.reset(static_cast<sngcpp::ast::Node*>(match.value));
5139 if (match.hit)
5140 {
5141 expr.reset(idExpr.release());
5142 }
5143 *parentMatch55 = match;
5144 }
5145 *parentMatch54 = match;
5146 }
5147 *parentMatch3 = match;
5148 }
5149 }
5150 *parentMatch2 = match;
5151 if (!match.hit)
5152 {
5153 soulng::parser::Match match(false);
5154 soulng::parser::Match* parentMatch56 = &match;
5155 lexer.SetPos(save);
5156 {
5157 soulng::parser::Match match(false);
5158 soulng::parser::Match* parentMatch57 = &match;
5159 {
5160 int64_t pos = lexer.GetPos();
5161 soulng::parser::Match match = ExpressionParser::LambdaExpression(lexer, ctx);
5162 lambdaExpr.reset(static_cast<sngcpp::ast::Node*>(match.value));
5163 if (match.hit)
5164 {
5165 {
5166 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
5167
5168 #endif // SOULNG_PARSER_DEBUG_SUPPORT
5169 return soulng::parser::Match(true, lambdaExpr.release());
5170 }
5171 }
5172 *parentMatch57 = match;
5173 }
5174 *parentMatch56 = match;
5175 }
5176 *parentMatch2 = match;
5177 }
5178 }
5179 *parentMatch1 = match;
5180 }
5181 if (match.hit)
5182 {
5183 {
5184 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
5185
5186 #endif // SOULNG_PARSER_DEBUG_SUPPORT
5187 return soulng::parser::Match(true, expr.release());
5188 }
5189 }
5190 *parentMatch0 = match;
5191 }
5192 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
5193
5194
5195
5196
5197
5198 #endif // SOULNG_PARSER_DEBUG_SUPPORT
5199 if (!match.hit)
5200 {
5201 match.value = nullptr;
5202 }
5203 return match;
5204 }
5205
5206 soulng::parser::Match ExpressionParser::CppCastExpression(CppLexer& lexer, sngcpp::cppparser::ParsingContext* ctx)
5207 {
5208 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
5209
5210
5211
5212
5213
5214
5215
5216 #endif // SOULNG_PARSER_DEBUG_SUPPORT
5217 sngcpp::ast::Operator op = sngcpp::ast::Operator();
5218 Span s = Span();
5219 std::unique_ptr<sngcpp::ast::Node> typeExpr;
5220 std::unique_ptr<sngcpp::ast::Node> exprList;
5221 soulng::parser::Match match(false);
5222 soulng::parser::Match* parentMatch0 = &match;
5223 {
5224 int64_t pos = lexer.GetPos();
5225 soulng::parser::Match match(false);
5226 soulng::parser::Match* parentMatch1 = &match;
5227 {
5228 soulng::parser::Match match(false);
5229 soulng::parser::Match* parentMatch2 = &match;
5230 {
5231 soulng::parser::Match match(false);
5232 soulng::parser::Match* parentMatch3 = &match;
5233 {
5234 soulng::parser::Match match(false);
5235 soulng::parser::Match* parentMatch4 = &match;
5236 {
5237 soulng::parser::Match match(false);
5238 soulng::parser::Match* parentMatch5 = &match;
5239 {
5240 soulng::parser::Match match(false);
5241 soulng::parser::Match* parentMatch6 = &match;
5242 {
5243 soulng::parser::Match match(false);
5244 soulng::parser::Match* parentMatch7 = &match;
5245 {
5246 soulng::parser::Match match(false);
5247 soulng::parser::Match* parentMatch8 = &match;
5248 {
5249 soulng::parser::Match match(false);
5250 soulng::parser::Match* parentMatch9 = &match;
5251 {
5252 int64_t save = lexer.GetPos();
5253 soulng::parser::Match match(false);
5254 soulng::parser::Match* parentMatch10 = &match;
5255 {
5256 int64_t save = lexer.GetPos();
5257 soulng::parser::Match match(false);
5258 soulng::parser::Match* parentMatch11 = &match;
5259 {
5260 int64_t save = lexer.GetPos();
5261 soulng::parser::Match match(false);
5262 soulng::parser::Match* parentMatch12 = &match;
5263 {
5264 int64_t pos = lexer.GetPos();
5265 soulng::lexer::Span span = lexer.GetSpan();
5266 soulng::parser::Match match(false);
5267 if (*lexer == DYNAMIC_CAST)
5268 {
5269 ++lexer;
5270 match.hit = true;
5271 }
5272 if (match.hit)
5273 {
5274 s = span;
5275 op = sngcpp::ast::Operator::dynamicCast;
5276 }
5277 *parentMatch12 = match;
5278 }
5279 *parentMatch11 = match;
5280 if (!match.hit)
5281 {
5282 soulng::parser::Match match(false);
5283 soulng::parser::Match* parentMatch13 = &match;
5284 lexer.SetPos(save);
5285 {
5286 soulng::parser::Match match(false);
5287 soulng::parser::Match* parentMatch14 = &match;
5288 {
5289 int64_t pos = lexer.GetPos();
5290 soulng::lexer::Span span = lexer.GetSpan();
5291 soulng::parser::Match match(false);
5292 if (*lexer == STATIC_CAST)
5293 {
5294 ++lexer;
5295 match.hit = true;
5296 }
5297 if (match.hit)
5298 {
5299 s = span;
5300 op = sngcpp::ast::Operator::staticCast;
5301 }
5302 *parentMatch14 = match;
5303 }
5304 *parentMatch13 = match;
5305 }
5306 *parentMatch11 = match;
5307 }
5308 }
5309 *parentMatch10 = match;
5310 if (!match.hit)
5311 {
5312 soulng::parser::Match match(false);
5313 soulng::parser::Match* parentMatch15 = &match;
5314 lexer.SetPos(save);
5315 {
5316 soulng::parser::Match match(false);
5317 soulng::parser::Match* parentMatch16 = &match;
5318 {
5319 int64_t pos = lexer.GetPos();
5320 soulng::lexer::Span span = lexer.GetSpan();
5321 soulng::parser::Match match(false);
5322 if (*lexer == REINTERPRET_CAST)
5323 {
5324 ++lexer;
5325 match.hit = true;
5326 }
5327 if (match.hit)
5328 {
5329 s = span;
5330 op = sngcpp::ast::Operator::reinterpretCast;
5331 }
5332 *parentMatch16 = match;
5333 }
5334 *parentMatch15 = match;
5335 }
5336 *parentMatch10 = match;
5337 }
5338 }
5339 *parentMatch9 = match;
5340 if (!match.hit)
5341 {
5342 soulng::parser::Match match(false);
5343 soulng::parser::Match* parentMatch17 = &match;
5344 lexer.SetPos(save);
5345 {
5346 soulng::parser::Match match(false);
5347 soulng::parser::Match* parentMatch18 = &match;
5348 {
5349 int64_t pos = lexer.GetPos();
5350 soulng::lexer::Span span = lexer.GetSpan();
5351 soulng::parser::Match match(false);
5352 if (*lexer == CONST_CAST)
5353 {
5354 ++lexer;
5355 match.hit = true;
5356 }
5357 if (match.hit)
5358 {
5359 s = span;
5360 op = sngcpp::ast::Operator::constCast;
5361 }
5362 *parentMatch18 = match;
5363 }
5364 *parentMatch17 = match;
5365 }
5366 *parentMatch9 = match;
5367 }
5368 }
5369 *parentMatch8 = match;
5370 }
5371 *parentMatch7 = match;
5372 }
5373 if (match.hit)
5374 {
5375 soulng::parser::Match match(false);
5376 soulng::parser::Match* parentMatch19 = &match;
5377 {
5378 soulng::parser::Match match(false);
5379 if (*lexer == LANGLE)
5380 {
5381 ++lexer;
5382 match.hit = true;
5383 }
5384 *parentMatch19 = match;
5385 }
5386 *parentMatch7 = match;
5387 }
5388 *parentMatch6 = match;
5389 }
5390 if (match.hit)
5391 {
5392 soulng::parser::Match match(false);
5393 soulng::parser::Match* parentMatch20 = &match;
5394 {
5395 soulng::parser::Match match = TypeExprParser::TypeExpr(lexer, ctx);
5396 typeExpr.reset(static_cast<sngcpp::ast::Node*>(match.value));
5397 *parentMatch20 = match;
5398 }
5399 *parentMatch6 = match;
5400 }
5401 *parentMatch5 = match;
5402 }
5403 if (match.hit)
5404 {
5405 soulng::parser::Match match(false);
5406 soulng::parser::Match* parentMatch21 = &match;
5407 {
5408 soulng::parser::Match match(false);
5409 if (*lexer == RANGLE)
5410 {
5411 ++lexer;
5412 match.hit = true;
5413 }
5414 *parentMatch21 = match;
5415 }
5416 *parentMatch5 = match;
5417 }
5418 *parentMatch4 = match;
5419 }
5420 if (match.hit)
5421 {
5422 soulng::parser::Match match(false);
5423 soulng::parser::Match* parentMatch22 = &match;
5424 {
5425 soulng::parser::Match match(false);
5426 if (*lexer == LPAREN)
5427 {
5428 ++lexer;
5429 match.hit = true;
5430 }
5431 *parentMatch22 = match;
5432 }
5433 *parentMatch4 = match;
5434 }
5435 *parentMatch3 = match;
5436 }
5437 if (match.hit)
5438 {
5439 soulng::parser::Match match(false);
5440 soulng::parser::Match* parentMatch23 = &match;
5441 {
5442 soulng::parser::Match match = ExpressionParser::ExpressionList(lexer, ctx);
5443 exprList.reset(static_cast<sngcpp::ast::Node*>(match.value));
5444 *parentMatch23 = match;
5445 }
5446 *parentMatch3 = match;
5447 }
5448 *parentMatch2 = match;
5449 }
5450 if (match.hit)
5451 {
5452 soulng::parser::Match match(false);
5453 soulng::parser::Match* parentMatch24 = &match;
5454 {
5455 soulng::parser::Match match(false);
5456 soulng::parser::Match* parentMatch25 = &match;
5457 {
5458 int64_t pos = lexer.GetPos();
5459 soulng::lexer::Span span = lexer.GetSpan();
5460 soulng::parser::Match match(false);
5461 if (*lexer == RPAREN)
5462 {
5463 ++lexer;
5464 match.hit = true;
5465 }
5466 if (match.hit)
5467 {
5468 s.end = span.end;
5469 }
5470 *parentMatch25 = match;
5471 }
5472 *parentMatch24 = match;
5473 }
5474 *parentMatch2 = match;
5475 }
5476 *parentMatch1 = match;
5477 }
5478 if (match.hit)
5479 {
5480 {
5481 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
5482
5483 #endif // SOULNG_PARSER_DEBUG_SUPPORT
5484 return soulng::parser::Match(true, new sngcpp::ast::CppCastExpressionNode(s, typeExpr.release(), exprList.release(), op));
5485 }
5486 }
5487 *parentMatch0 = match;
5488 }
5489 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
5490
5491
5492
5493
5494
5495 #endif // SOULNG_PARSER_DEBUG_SUPPORT
5496 if (!match.hit)
5497 {
5498 match.value = nullptr;
5499 }
5500 return match;
5501 }
5502
5503 soulng::parser::Match ExpressionParser::TypeIdExpression(CppLexer& lexer, sngcpp::cppparser::ParsingContext* ctx)
5504 {
5505 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
5506
5507
5508
5509
5510
5511
5512
5513 #endif // SOULNG_PARSER_DEBUG_SUPPORT
5514 Span s = Span();
5515 std::unique_ptr<sngcpp::ast::Node> typeExpr;
5516 std::unique_ptr<sngcpp::ast::Node> expr;
5517 soulng::parser::Match match(false);
5518 soulng::parser::Match* parentMatch0 = &match;
5519 {
5520 int64_t save = lexer.GetPos();
5521 soulng::parser::Match match(false);
5522 soulng::parser::Match* parentMatch1 = &match;
5523 {
5524 soulng::parser::Match match(false);
5525 soulng::parser::Match* parentMatch2 = &match;
5526 {
5527 soulng::parser::Match match(false);
5528 soulng::parser::Match* parentMatch3 = &match;
5529 {
5530 soulng::parser::Match match(false);
5531 soulng::parser::Match* parentMatch4 = &match;
5532 {
5533 int64_t pos = lexer.GetPos();
5534 soulng::lexer::Span span = lexer.GetSpan();
5535 soulng::parser::Match match(false);
5536 if (*lexer == TYPEID)
5537 {
5538 ++lexer;
5539 match.hit = true;
5540 }
5541 if (match.hit)
5542 {
5543 s = span;
5544 }
5545 *parentMatch4 = match;
5546 }
5547 *parentMatch3 = match;
5548 }
5549 if (match.hit)
5550 {
5551 soulng::parser::Match match(false);
5552 soulng::parser::Match* parentMatch5 = &match;
5553 {
5554 soulng::parser::Match match(false);
5555 if (*lexer == LPAREN)
5556 {
5557 ++lexer;
5558 match.hit = true;
5559 }
5560 *parentMatch5 = match;
5561 }
5562 *parentMatch3 = match;
5563 }
5564 *parentMatch2 = match;
5565 }
5566 if (match.hit)
5567 {
5568 soulng::parser::Match match(false);
5569 soulng::parser::Match* parentMatch6 = &match;
5570 {
5571 soulng::parser::Match match = TypeExprParser::TypeExpr(lexer, ctx);
5572 typeExpr.reset(static_cast<sngcpp::ast::Node*>(match.value));
5573 *parentMatch6 = match;
5574 }
5575 *parentMatch2 = match;
5576 }
5577 *parentMatch1 = match;
5578 }
5579 if (match.hit)
5580 {
5581 soulng::parser::Match match(false);
5582 soulng::parser::Match* parentMatch7 = &match;
5583 {
5584 soulng::parser::Match match(false);
5585 soulng::parser::Match* parentMatch8 = &match;
5586 {
5587 int64_t pos = lexer.GetPos();
5588 soulng::lexer::Span span = lexer.GetSpan();
5589 soulng::parser::Match match(false);
5590 if (*lexer == RPAREN)
5591 {
5592 ++lexer;
5593 match.hit = true;
5594 }
5595 if (match.hit)
5596 {
5597 s.end = span.end;
5598 {
5599 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
5600
5601 #endif // SOULNG_PARSER_DEBUG_SUPPORT
5602 return soulng::parser::Match(true, new sngcpp::ast::TypeIdExpressionNode(s, typeExpr.release()));
5603 }
5604 }
5605 *parentMatch8 = match;
5606 }
5607 *parentMatch7 = match;
5608 }
5609 *parentMatch1 = match;
5610 }
5611 *parentMatch0 = match;
5612 if (!match.hit)
5613 {
5614 soulng::parser::Match match(false);
5615 soulng::parser::Match* parentMatch9 = &match;
5616 lexer.SetPos(save);
5617 {
5618 soulng::parser::Match match(false);
5619 soulng::parser::Match* parentMatch10 = &match;
5620 {
5621 soulng::parser::Match match(false);
5622 soulng::parser::Match* parentMatch11 = &match;
5623 {
5624 soulng::parser::Match match(false);
5625 soulng::parser::Match* parentMatch12 = &match;
5626 {
5627 soulng::parser::Match match(false);
5628 soulng::parser::Match* parentMatch13 = &match;
5629 {
5630 int64_t pos = lexer.GetPos();
5631 soulng::lexer::Span span = lexer.GetSpan();
5632 soulng::parser::Match match(false);
5633 if (*lexer == TYPEID)
5634 {
5635 ++lexer;
5636 match.hit = true;
5637 }
5638 if (match.hit)
5639 {
5640 s = span;
5641 }
5642 *parentMatch13 = match;
5643 }
5644 *parentMatch12 = match;
5645 }
5646 if (match.hit)
5647 {
5648 soulng::parser::Match match(false);
5649 soulng::parser::Match* parentMatch14 = &match;
5650 {
5651 soulng::parser::Match match(false);
5652 if (*lexer == LPAREN)
5653 {
5654 ++lexer;
5655 match.hit = true;
5656 }
5657 *parentMatch14 = match;
5658 }
5659 *parentMatch12 = match;
5660 }
5661 *parentMatch11 = match;
5662 }
5663 if (match.hit)
5664 {
5665 soulng::parser::Match match(false);
5666 soulng::parser::Match* parentMatch15 = &match;
5667 {
5668 soulng::parser::Match match = ExpressionParser::Expression(lexer, ctx);
5669 expr.reset(static_cast<sngcpp::ast::Node*>(match.value));
5670 *parentMatch15 = match;
5671 }
5672 *parentMatch11 = match;
5673 }
5674 *parentMatch10 = match;
5675 }
5676 if (match.hit)
5677 {
5678 soulng::parser::Match match(false);
5679 soulng::parser::Match* parentMatch16 = &match;
5680 {
5681 soulng::parser::Match match(false);
5682 soulng::parser::Match* parentMatch17 = &match;
5683 {
5684 int64_t pos = lexer.GetPos();
5685 soulng::lexer::Span span = lexer.GetSpan();
5686 soulng::parser::Match match(false);
5687 if (*lexer == RPAREN)
5688 {
5689 ++lexer;
5690 match.hit = true;
5691 }
5692 if (match.hit)
5693 {
5694 s.end = span.end;
5695 {
5696 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
5697
5698 #endif // SOULNG_PARSER_DEBUG_SUPPORT
5699 return soulng::parser::Match(true, new sngcpp::ast::TypeIdExpressionNode(s, expr.release()));
5700 }
5701 }
5702 *parentMatch17 = match;
5703 }
5704 *parentMatch16 = match;
5705 }
5706 *parentMatch10 = match;
5707 }
5708 *parentMatch9 = match;
5709 }
5710 *parentMatch0 = match;
5711 }
5712 }
5713 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
5714
5715
5716
5717
5718
5719 #endif // SOULNG_PARSER_DEBUG_SUPPORT
5720 if (!match.hit)
5721 {
5722 match.value = nullptr;
5723 }
5724 return match;
5725 }
5726
5727 soulng::parser::Match ExpressionParser::IdExpression(CppLexer& lexer, sngcpp::cppparser::ParsingContext* ctx)
5728 {
5729 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
5730
5731
5732
5733
5734
5735
5736
5737 #endif // SOULNG_PARSER_DEBUG_SUPPORT
5738 std::unique_ptr<sngcpp::ast::Node> qualifiedId;
5739 std::unique_ptr<sngcpp::ast::Node> unqualifiedId;
5740 soulng::parser::Match match(false);
5741 soulng::parser::Match* parentMatch0 = &match;
5742 {
5743 int64_t save = lexer.GetPos();
5744 soulng::parser::Match match(false);
5745 soulng::parser::Match* parentMatch1 = &match;
5746 {
5747 int64_t pos = lexer.GetPos();
5748 soulng::parser::Match match = ExpressionParser::QualifiedId(lexer, ctx);
5749 qualifiedId.reset(static_cast<sngcpp::ast::Node*>(match.value));
5750 if (match.hit)
5751 {
5752 {
5753 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
5754
5755 #endif // SOULNG_PARSER_DEBUG_SUPPORT
5756 return soulng::parser::Match(true, qualifiedId.release());
5757 }
5758 }
5759 *parentMatch1 = match;
5760 }
5761 *parentMatch0 = match;
5762 if (!match.hit)
5763 {
5764 soulng::parser::Match match(false);
5765 soulng::parser::Match* parentMatch2 = &match;
5766 lexer.SetPos(save);
5767 {
5768 soulng::parser::Match match(false);
5769 soulng::parser::Match* parentMatch3 = &match;
5770 {
5771 int64_t pos = lexer.GetPos();
5772 soulng::parser::Match match = ExpressionParser::UnqualifiedId(lexer, ctx);
5773 unqualifiedId.reset(static_cast<sngcpp::ast::Node*>(match.value));
5774 if (match.hit)
5775 {
5776 {
5777 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
5778
5779 #endif // SOULNG_PARSER_DEBUG_SUPPORT
5780 return soulng::parser::Match(true, unqualifiedId.release());
5781 }
5782 }
5783 *parentMatch3 = match;
5784 }
5785 *parentMatch2 = match;
5786 }
5787 *parentMatch0 = match;
5788 }
5789 }
5790 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
5791
5792
5793
5794
5795
5796 #endif // SOULNG_PARSER_DEBUG_SUPPORT
5797 if (!match.hit)
5798 {
5799 match.value = nullptr;
5800 }
5801 return match;
5802 }
5803
5804 soulng::parser::Match ExpressionParser::UnqualifiedId(CppLexer& lexer, sngcpp::cppparser::ParsingContext* ctx)
5805 {
5806 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
5807
5808
5809
5810
5811
5812
5813
5814 #endif // SOULNG_PARSER_DEBUG_SUPPORT
5815 Span s = Span();
5816 std::unique_ptr<sngcpp::ast::Node> templateId;
5817 std::unique_ptr<soulng::parser::soulng::parser::Value<std::u32string>>id1;
5818 std::unique_ptr<sngcpp::ast::Node> operatorFunctionId;
5819 std::unique_ptr<sngcpp::ast::Node> conversionFunctionId;
5820 std::unique_ptr<soulng::parser::soulng::parser::Value<std::u32string>>id2;
5821 soulng::parser::Match match(false);
5822 soulng::parser::Match* parentMatch0 = &match;
5823 {
5824 int64_t save = lexer.GetPos();
5825 soulng::parser::Match match(false);
5826 soulng::parser::Match* parentMatch1 = &match;
5827 {
5828 int64_t save = lexer.GetPos();
5829 soulng::parser::Match match(false);
5830 soulng::parser::Match* parentMatch2 = &match;
5831 {
5832 int64_t save = lexer.GetPos();
5833 soulng::parser::Match match(false);
5834 soulng::parser::Match* parentMatch3 = &match;
5835 {
5836 int64_t save = lexer.GetPos();
5837 soulng::parser::Match match(false);
5838 soulng::parser::Match* parentMatch4 = &match;
5839 {
5840 int64_t pos = lexer.GetPos();
5841 soulng::parser::Match match = TemplateParser::TemplateId(lexer, ctx);
5842 templateId.reset(static_cast<sngcpp::ast::Node*>(match.value));
5843 if (match.hit)
5844 {
5845 {
5846 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
5847
5848 #endif // SOULNG_PARSER_DEBUG_SUPPORT
5849 return soulng::parser::Match(true, templateId.release());
5850 }
5851 }
5852 *parentMatch4 = match;
5853 }
5854 *parentMatch3 = match;
5855 if (!match.hit)
5856 {
5857 soulng::parser::Match match(false);
5858 soulng::parser::Match* parentMatch5 = &match;
5859 lexer.SetPos(save);
5860 {
5861 soulng::parser::Match match(false);
5862 soulng::parser::Match* parentMatch6 = &match;
5863 {
5864 int64_t pos = lexer.GetPos();
5865 soulng::lexer::Span span = lexer.GetSpan();
5866 soulng::parser::Match match = IdentifierParser::Identifier(lexer);
5867 id1.reset(static_cast<soulng::parser::soulng::parser::Value<std::u32string>*>(match.value));
5868 if (match.hit)
5869 {
5870 {
5871 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
5872
5873 #endif // SOULNG_PARSER_DEBUG_SUPPORT
5874 return soulng::parser::Match(true, new sngcpp::ast::IdentifierNode(span, id1->value));
5875 }
5876 }
5877 *parentMatch6 = match;
5878 }
5879 *parentMatch5 = match;
5880 }
5881 *parentMatch3 = match;
5882 }
5883 }
5884 *parentMatch2 = match;
5885 if (!match.hit)
5886 {
5887 soulng::parser::Match match(false);
5888 soulng::parser::Match* parentMatch7 = &match;
5889 lexer.SetPos(save);
5890 {
5891 soulng::parser::Match match(false);
5892 soulng::parser::Match* parentMatch8 = &match;
5893 {
5894 int64_t pos = lexer.GetPos();
5895 soulng::parser::Match match = ExpressionParser::OperatorFunctionId(lexer);
5896 operatorFunctionId.reset(static_cast<sngcpp::ast::Node*>(match.value));
5897 if (match.hit)
5898 {
5899 {
5900 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
5901
5902 #endif // SOULNG_PARSER_DEBUG_SUPPORT
5903 return soulng::parser::Match(true, operatorFunctionId.release());
5904 }
5905 }
5906 *parentMatch8 = match;
5907 }
5908 *parentMatch7 = match;
5909 }
5910 *parentMatch2 = match;
5911 }
5912 }
5913 *parentMatch1 = match;
5914 if (!match.hit)
5915 {
5916 soulng::parser::Match match(false);
5917 soulng::parser::Match* parentMatch9 = &match;
5918 lexer.SetPos(save);
5919 {
5920 soulng::parser::Match match(false);
5921 soulng::parser::Match* parentMatch10 = &match;
5922 {
5923 int64_t pos = lexer.GetPos();
5924 soulng::parser::Match match = ExpressionParser::ConversionFunctionId(lexer, ctx);
5925 conversionFunctionId.reset(static_cast<sngcpp::ast::Node*>(match.value));
5926 if (match.hit)
5927 {
5928 {
5929 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
5930
5931 #endif // SOULNG_PARSER_DEBUG_SUPPORT
5932 return soulng::parser::Match(true, conversionFunctionId.release());
5933 }
5934 }
5935 *parentMatch10 = match;
5936 }
5937 *parentMatch9 = match;
5938 }
5939 *parentMatch1 = match;
5940 }
5941 }
5942 *parentMatch0 = match;
5943 if (!match.hit)
5944 {
5945 soulng::parser::Match match(false);
5946 soulng::parser::Match* parentMatch11 = &match;
5947 lexer.SetPos(save);
5948 {
5949 soulng::parser::Match match(false);
5950 soulng::parser::Match* parentMatch12 = &match;
5951 {
5952 soulng::parser::Match match(false);
5953 soulng::parser::Match* parentMatch13 = &match;
5954 {
5955 int64_t pos = lexer.GetPos();
5956 soulng::lexer::Span span = lexer.GetSpan();
5957 soulng::parser::Match match(false);
5958 if (*lexer == TILDE)
5959 {
5960 ++lexer;
5961 match.hit = true;
5962 }
5963 if (match.hit)
5964 {
5965 s = span;
5966 }
5967 *parentMatch13 = match;
5968 }
5969 *parentMatch12 = match;
5970 }
5971 if (match.hit)
5972 {
5973 soulng::parser::Match match(false);
5974 soulng::parser::Match* parentMatch14 = &match;
5975 {
5976 soulng::parser::Match match(false);
5977 soulng::parser::Match* parentMatch15 = &match;
5978 {
5979 int64_t pos = lexer.GetPos();
5980 soulng::lexer::Span span = lexer.GetSpan();
5981 soulng::parser::Match match = IdentifierParser::Identifier(lexer);
5982 id2.reset(static_cast<soulng::parser::soulng::parser::Value<std::u32string>*>(match.value));
5983 if (match.hit)
5984 {
5985 s.end = span.end;
5986 {
5987 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
5988
5989 #endif // SOULNG_PARSER_DEBUG_SUPPORT
5990 return soulng::parser::Match(true, new sngcpp::ast::DtorIdNode(s, id2->value));
5991 }
5992 }
5993 *parentMatch15 = match;
5994 }
5995 *parentMatch14 = match;
5996 }
5997 *parentMatch12 = match;
5998 }
5999 *parentMatch11 = match;
6000 }
6001 *parentMatch0 = match;
6002 }
6003 }
6004 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
6005
6006
6007
6008
6009
6010 #endif // SOULNG_PARSER_DEBUG_SUPPORT
6011 if (!match.hit)
6012 {
6013 match.value = nullptr;
6014 }
6015 return match;
6016 }
6017
6018 soulng::parser::Match ExpressionParser::QualifiedId(CppLexer& lexer, sngcpp::cppparser::ParsingContext* ctx)
6019 {
6020 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
6021
6022
6023
6024
6025
6026
6027
6028 #endif // SOULNG_PARSER_DEBUG_SUPPORT
6029 Span s = Span();
6030 std::unique_ptr<sngcpp::ast::Node> templateId;
6031 std::unique_ptr<sngcpp::ast::Node> ns1;
6032 std::unique_ptr<sngcpp::ast::Node> uid1;
6033 std::unique_ptr<soulng::parser::soulng::parser::Value<std::u32string>>id1;
6034 std::unique_ptr<sngcpp::ast::Node> operatorFunctionId;
6035 std::unique_ptr<sngcpp::ast::Node> ns2;
6036 std::unique_ptr<sngcpp::ast::Node> uid2;
6037 soulng::parser::Match match(false);
6038 soulng::parser::Match* parentMatch0 = &match;
6039 {
6040 int64_t save = lexer.GetPos();
6041 soulng::parser::Match match(false);
6042 soulng::parser::Match* parentMatch1 = &match;
6043 {
6044 int64_t save = lexer.GetPos();
6045 soulng::parser::Match match(false);
6046 soulng::parser::Match* parentMatch2 = &match;
6047 {
6048 int64_t save = lexer.GetPos();
6049 soulng::parser::Match match(false);
6050 soulng::parser::Match* parentMatch3 = &match;
6051 {
6052 int64_t save = lexer.GetPos();
6053 soulng::parser::Match match(false);
6054 soulng::parser::Match* parentMatch4 = &match;
6055 {
6056 soulng::parser::Match match(false);
6057 soulng::parser::Match* parentMatch5 = &match;
6058 {
6059 int64_t pos = lexer.GetPos();
6060 soulng::lexer::Span span = lexer.GetSpan();
6061 soulng::parser::Match match(false);
6062 if (*lexer == COLONCOLON)
6063 {
6064 ++lexer;
6065 match.hit = true;
6066 }
6067 if (match.hit)
6068 {
6069 s = span;
6070 }
6071 *parentMatch5 = match;
6072 }
6073 *parentMatch4 = match;
6074 }
6075 if (match.hit)
6076 {
6077 soulng::parser::Match match(false);
6078 soulng::parser::Match* parentMatch6 = &match;
6079 {
6080 soulng::parser::Match match(false);
6081 soulng::parser::Match* parentMatch7 = &match;
6082 {
6083 int64_t pos = lexer.GetPos();
6084 soulng::lexer::Span span = lexer.GetSpan();
6085 soulng::parser::Match match = TemplateParser::TemplateId(lexer, ctx);
6086 templateId.reset(static_cast<sngcpp::ast::Node*>(match.value));
6087 if (match.hit)
6088 {
6089 s.end = span.end;
6090 {
6091 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
6092
6093 #endif // SOULNG_PARSER_DEBUG_SUPPORT
6094 return soulng::parser::Match(true, new sngcpp::ast::NestedIdNode(s, nullptr, templateId.release()));
6095 }
6096 }
6097 *parentMatch7 = match;
6098 }
6099 *parentMatch6 = match;
6100 }
6101 *parentMatch4 = match;
6102 }
6103 *parentMatch3 = match;
6104 if (!match.hit)
6105 {
6106 soulng::parser::Match match(false);
6107 soulng::parser::Match* parentMatch8 = &match;
6108 lexer.SetPos(save);
6109 {
6110 soulng::parser::Match match(false);
6111 soulng::parser::Match* parentMatch9 = &match;
6112 {
6113 soulng::parser::Match match(false);
6114 soulng::parser::Match* parentMatch10 = &match;
6115 {
6116 soulng::parser::Match match(false);
6117 soulng::parser::Match* parentMatch11 = &match;
6118 {
6119 int64_t pos = lexer.GetPos();
6120 soulng::lexer::Span span = lexer.GetSpan();
6121 soulng::parser::Match match(false);
6122 if (*lexer == COLONCOLON)
6123 {
6124 ++lexer;
6125 match.hit = true;
6126 }
6127 if (match.hit)
6128 {
6129 s = span;
6130 }
6131 *parentMatch11 = match;
6132 }
6133 *parentMatch10 = match;
6134 }
6135 if (match.hit)
6136 {
6137 soulng::parser::Match match(false);
6138 soulng::parser::Match* parentMatch12 = &match;
6139 {
6140 soulng::parser::Match match = IdentifierParser::NestedNameSpecifier(lexer, ctx);
6141 ns1.reset(static_cast<sngcpp::ast::Node*>(match.value));
6142 *parentMatch12 = match;
6143 }
6144 *parentMatch10 = match;
6145 }
6146 *parentMatch9 = match;
6147 }
6148 if (match.hit)
6149 {
6150 soulng::parser::Match match(false);
6151 soulng::parser::Match* parentMatch13 = &match;
6152 {
6153 soulng::parser::Match match(false);
6154 soulng::parser::Match* parentMatch14 = &match;
6155 {
6156 int64_t pos = lexer.GetPos();
6157 soulng::lexer::Span span = lexer.GetSpan();
6158 soulng::parser::Match match = ExpressionParser::UnqualifiedId(lexer, ctx);
6159 uid1.reset(static_cast<sngcpp::ast::Node*>(match.value));
6160 if (match.hit)
6161 {
6162 s.end = span.end;
6163 {
6164 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
6165
6166 #endif // SOULNG_PARSER_DEBUG_SUPPORT
6167 return soulng::parser::Match(true, new sngcpp::ast::NestedIdNode(s, new sngcpp::ast::NestedIdNode(s, nullptr, ns1.release()), uid1.release()));
6168 }
6169 }
6170 *parentMatch14 = match;
6171 }
6172 *parentMatch13 = match;
6173 }
6174 *parentMatch9 = match;
6175 }
6176 *parentMatch8 = match;
6177 }
6178 *parentMatch3 = match;
6179 }
6180 }
6181 *parentMatch2 = match;
6182 if (!match.hit)
6183 {
6184 soulng::parser::Match match(false);
6185 soulng::parser::Match* parentMatch15 = &match;
6186 lexer.SetPos(save);
6187 {
6188 soulng::parser::Match match(false);
6189 soulng::parser::Match* parentMatch16 = &match;
6190 {
6191 soulng::parser::Match match(false);
6192 soulng::parser::Match* parentMatch17 = &match;
6193 {
6194 int64_t pos = lexer.GetPos();
6195 soulng::lexer::Span span = lexer.GetSpan();
6196 soulng::parser::Match match(false);
6197 if (*lexer == COLONCOLON)
6198 {
6199 ++lexer;
6200 match.hit = true;
6201 }
6202 if (match.hit)
6203 {
6204 s = span;
6205 }
6206 *parentMatch17 = match;
6207 }
6208 *parentMatch16 = match;
6209 }
6210 if (match.hit)
6211 {
6212 soulng::parser::Match match(false);
6213 soulng::parser::Match* parentMatch18 = &match;
6214 {
6215 soulng::parser::Match match(false);
6216 soulng::parser::Match* parentMatch19 = &match;
6217 {
6218 int64_t pos = lexer.GetPos();
6219 soulng::lexer::Span span = lexer.GetSpan();
6220 soulng::parser::Match match = IdentifierParser::Identifier(lexer);
6221 id1.reset(static_cast<soulng::parser::soulng::parser::Value<std::u32string>*>(match.value));
6222 if (match.hit)
6223 {
6224 s.end = span.end;
6225 {
6226 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
6227
6228 #endif // SOULNG_PARSER_DEBUG_SUPPORT
6229 return soulng::parser::Match(true, new sngcpp::ast::NestedIdNode(s, nullptr, new sngcpp::ast::IdentifierNode(s, id1->value)));
6230 }
6231 }
6232 *parentMatch19 = match;
6233 }
6234 *parentMatch18 = match;
6235 }
6236 *parentMatch16 = match;
6237 }
6238 *parentMatch15 = match;
6239 }
6240 *parentMatch2 = match;
6241 }
6242 }
6243 *parentMatch1 = match;
6244 if (!match.hit)
6245 {
6246 soulng::parser::Match match(false);
6247 soulng::parser::Match* parentMatch20 = &match;
6248 lexer.SetPos(save);
6249 {
6250 soulng::parser::Match match(false);
6251 soulng::parser::Match* parentMatch21 = &match;
6252 {
6253 soulng::parser::Match match(false);
6254 soulng::parser::Match* parentMatch22 = &match;
6255 {
6256 int64_t pos = lexer.GetPos();
6257 soulng::lexer::Span span = lexer.GetSpan();
6258 soulng::parser::Match match(false);
6259 if (*lexer == COLONCOLON)
6260 {
6261 ++lexer;
6262 match.hit = true;
6263 }
6264 if (match.hit)
6265 {
6266 s = span;
6267 }
6268 *parentMatch22 = match;
6269 }
6270 *parentMatch21 = match;
6271 }
6272 if (match.hit)
6273 {
6274 soulng::parser::Match match(false);
6275 soulng::parser::Match* parentMatch23 = &match;
6276 {
6277 soulng::parser::Match match(false);
6278 soulng::parser::Match* parentMatch24 = &match;
6279 {
6280 int64_t pos = lexer.GetPos();
6281 soulng::lexer::Span span = lexer.GetSpan();
6282 soulng::parser::Match match = ExpressionParser::OperatorFunctionId(lexer);
6283 operatorFunctionId.reset(static_cast<sngcpp::ast::Node*>(match.value));
6284 if (match.hit)
6285 {
6286 s.end = span.end;
6287 {
6288 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
6289
6290 #endif // SOULNG_PARSER_DEBUG_SUPPORT
6291 return soulng::parser::Match(true, new sngcpp::ast::NestedIdNode(s, nullptr, operatorFunctionId.release()));
6292 }
6293 }
6294 *parentMatch24 = match;
6295 }
6296 *parentMatch23 = match;
6297 }
6298 *parentMatch21 = match;
6299 }
6300 *parentMatch20 = match;
6301 }
6302 *parentMatch1 = match;
6303 }
6304 }
6305 *parentMatch0 = match;
6306 if (!match.hit)
6307 {
6308 soulng::parser::Match match(false);
6309 soulng::parser::Match* parentMatch25 = &match;
6310 lexer.SetPos(save);
6311 {
6312 soulng::parser::Match match(false);
6313 soulng::parser::Match* parentMatch26 = &match;
6314 {
6315 soulng::parser::Match match(false);
6316 soulng::parser::Match* parentMatch27 = &match;
6317 {
6318 int64_t pos = lexer.GetPos();
6319 soulng::lexer::Span span = lexer.GetSpan();
6320 soulng::parser::Match match = IdentifierParser::NestedNameSpecifier(lexer, ctx);
6321 ns2.reset(static_cast<sngcpp::ast::Node*>(match.value));
6322 if (match.hit)
6323 {
6324 s = span;
6325 }
6326 *parentMatch27 = match;
6327 }
6328 *parentMatch26 = match;
6329 }
6330 if (match.hit)
6331 {
6332 soulng::parser::Match match(false);
6333 soulng::parser::Match* parentMatch28 = &match;
6334 {
6335 soulng::parser::Match match(false);
6336 soulng::parser::Match* parentMatch29 = &match;
6337 {
6338 int64_t pos = lexer.GetPos();
6339 soulng::lexer::Span span = lexer.GetSpan();
6340 soulng::parser::Match match = ExpressionParser::UnqualifiedId(lexer, ctx);
6341 uid2.reset(static_cast<sngcpp::ast::Node*>(match.value));
6342 if (match.hit)
6343 {
6344 s.end = span.end;
6345 {
6346 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
6347
6348 #endif // SOULNG_PARSER_DEBUG_SUPPORT
6349 return soulng::parser::Match(true, new sngcpp::ast::NestedIdNode(s, ns2.release(), uid2.release()));
6350 }
6351 }
6352 *parentMatch29 = match;
6353 }
6354 *parentMatch28 = match;
6355 }
6356 *parentMatch26 = match;
6357 }
6358 *parentMatch25 = match;
6359 }
6360 *parentMatch0 = match;
6361 }
6362 }
6363 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
6364
6365
6366
6367
6368
6369 #endif // SOULNG_PARSER_DEBUG_SUPPORT
6370 if (!match.hit)
6371 {
6372 match.value = nullptr;
6373 }
6374 return match;
6375 }
6376
6377 soulng::parser::Match ExpressionParser::OperatorFunctionId(CppLexer& lexer)
6378 {
6379 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
6380
6381
6382
6383
6384
6385
6386
6387 #endif // SOULNG_PARSER_DEBUG_SUPPORT
6388 Span s = Span();
6389 std::unique_ptr<soulng::parser::soulng::parser::Value<sngcpp::ast::Operator>>op;
6390 soulng::parser::Match match(false);
6391 soulng::parser::Match* parentMatch0 = &match;
6392 {
6393 soulng::parser::Match match(false);
6394 soulng::parser::Match* parentMatch1 = &match;
6395 {
6396 int64_t pos = lexer.GetPos();
6397 soulng::lexer::Span span = lexer.GetSpan();
6398 soulng::parser::Match match(false);
6399 if (*lexer == OPERATOR)
6400 {
6401 ++lexer;
6402 match.hit = true;
6403 }
6404 if (match.hit)
6405 {
6406 s = span;
6407 }
6408 *parentMatch1 = match;
6409 }
6410 *parentMatch0 = match;
6411 }
6412 if (match.hit)
6413 {
6414 soulng::parser::Match match(false);
6415 soulng::parser::Match* parentMatch2 = &match;
6416 {
6417 soulng::parser::Match match(false);
6418 soulng::parser::Match* parentMatch3 = &match;
6419 {
6420 int64_t pos = lexer.GetPos();
6421 soulng::lexer::Span span = lexer.GetSpan();
6422 soulng::parser::Match match = ExpressionParser::Operator(lexer);
6423 op.reset(static_cast<soulng::parser::soulng::parser::Value<sngcpp::ast::Operator>*>(match.value));
6424 if (match.hit)
6425 {
6426 s.end = span.end;
6427 {
6428 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
6429
6430 #endif // SOULNG_PARSER_DEBUG_SUPPORT
6431 return soulng::parser::Match(true, new sngcpp::ast::OperatorFunctionIdNode(s, op->value));
6432 }
6433 }
6434 *parentMatch3 = match;
6435 }
6436 *parentMatch2 = match;
6437 }
6438 *parentMatch0 = match;
6439 }
6440 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
6441
6442
6443
6444
6445
6446 #endif // SOULNG_PARSER_DEBUG_SUPPORT
6447 if (!match.hit)
6448 {
6449 match.value = nullptr;
6450 }
6451 return match;
6452 }
6453
6454 soulng::parser::Match ExpressionParser::Operator(CppLexer& lexer)
6455 {
6456 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
6457
6458
6459
6460
6461
6462
6463
6464 #endif // SOULNG_PARSER_DEBUG_SUPPORT
6465 std::unique_ptr<soulng::parser::soulng::parser::Value<sngcpp::ast::Operator>>assignmentOp;
6466 soulng::parser::Match match(false);
6467 soulng::parser::Match* parentMatch0 = &match;
6468 {
6469 int64_t save = lexer.GetPos();
6470 soulng::parser::Match match(false);
6471 soulng::parser::Match* parentMatch1 = &match;
6472 {
6473 int64_t save = lexer.GetPos();
6474 soulng::parser::Match match(false);
6475 soulng::parser::Match* parentMatch2 = &match;
6476 {
6477 int64_t save = lexer.GetPos();
6478 soulng::parser::Match match(false);
6479 soulng::parser::Match* parentMatch3 = &match;
6480 {
6481 int64_t save = lexer.GetPos();
6482 soulng::parser::Match match(false);
6483 soulng::parser::Match* parentMatch4 = &match;
6484 {
6485 int64_t save = lexer.GetPos();
6486 soulng::parser::Match match(false);
6487 soulng::parser::Match* parentMatch5 = &match;
6488 {
6489 int64_t save = lexer.GetPos();
6490 soulng::parser::Match match(false);
6491 soulng::parser::Match* parentMatch6 = &match;
6492 {
6493 int64_t save = lexer.GetPos();
6494 soulng::parser::Match match(false);
6495 soulng::parser::Match* parentMatch7 = &match;
6496 {
6497 int64_t save = lexer.GetPos();
6498 soulng::parser::Match match(false);
6499 soulng::parser::Match* parentMatch8 = &match;
6500 {
6501 int64_t save = lexer.GetPos();
6502 soulng::parser::Match match(false);
6503 soulng::parser::Match* parentMatch9 = &match;
6504 {
6505 int64_t save = lexer.GetPos();
6506 soulng::parser::Match match(false);
6507 soulng::parser::Match* parentMatch10 = &match;
6508 {
6509 int64_t save = lexer.GetPos();
6510 soulng::parser::Match match(false);
6511 soulng::parser::Match* parentMatch11 = &match;
6512 {
6513 int64_t save = lexer.GetPos();
6514 soulng::parser::Match match(false);
6515 soulng::parser::Match* parentMatch12 = &match;
6516 {
6517 int64_t save = lexer.GetPos();
6518 soulng::parser::Match match(false);
6519 soulng::parser::Match* parentMatch13 = &match;
6520 {
6521 int64_t save = lexer.GetPos();
6522 soulng::parser::Match match(false);
6523 soulng::parser::Match* parentMatch14 = &match;
6524 {
6525 int64_t save = lexer.GetPos();
6526 soulng::parser::Match match(false);
6527 soulng::parser::Match* parentMatch15 = &match;
6528 {
6529 int64_t save = lexer.GetPos();
6530 soulng::parser::Match match(false);
6531 soulng::parser::Match* parentMatch16 = &match;
6532 {
6533 int64_t save = lexer.GetPos();
6534 soulng::parser::Match match(false);
6535 soulng::parser::Match* parentMatch17 = &match;
6536 {
6537 int64_t save = lexer.GetPos();
6538 soulng::parser::Match match(false);
6539 soulng::parser::Match* parentMatch18 = &match;
6540 {
6541 int64_t save = lexer.GetPos();
6542 soulng::parser::Match match(false);
6543 soulng::parser::Match* parentMatch19 = &match;
6544 {
6545 int64_t save = lexer.GetPos();
6546 soulng::parser::Match match(false);
6547 soulng::parser::Match* parentMatch20 = &match;
6548 {
6549 int64_t save = lexer.GetPos();
6550 soulng::parser::Match match(false);
6551 soulng::parser::Match* parentMatch21 = &match;
6552 {
6553 int64_t save = lexer.GetPos();
6554 soulng::parser::Match match(false);
6555 soulng::parser::Match* parentMatch22 = &match;
6556 {
6557 int64_t save = lexer.GetPos();
6558 soulng::parser::Match match(false);
6559 soulng::parser::Match* parentMatch23 = &match;
6560 {
6561 int64_t save = lexer.GetPos();
6562 soulng::parser::Match match(false);
6563 soulng::parser::Match* parentMatch24 = &match;
6564 {
6565 int64_t save = lexer.GetPos();
6566 soulng::parser::Match match(false);
6567 soulng::parser::Match* parentMatch25 = &match;
6568 {
6569 int64_t save = lexer.GetPos();
6570 soulng::parser::Match match(false);
6571 soulng::parser::Match* parentMatch26 = &match;
6572 {
6573 int64_t save = lexer.GetPos();
6574 soulng::parser::Match match(false);
6575 soulng::parser::Match* parentMatch27 = &match;
6576 {
6577 int64_t save = lexer.GetPos();
6578 soulng::parser::Match match(false);
6579 soulng::parser::Match* parentMatch28 = &match;
6580 {
6581 int64_t save = lexer.GetPos();
6582 soulng::parser::Match match(false);
6583 soulng::parser::Match* parentMatch29 = &match;
6584 {
6585 int64_t save = lexer.GetPos();
6586 soulng::parser::Match match(false);
6587 soulng::parser::Match* parentMatch30 = &match;
6588 {
6589 int64_t save = lexer.GetPos();
6590 soulng::parser::Match match(false);
6591 soulng::parser::Match* parentMatch31 = &match;
6592 {
6593 int64_t save = lexer.GetPos();
6594 soulng::parser::Match match(false);
6595 soulng::parser::Match* parentMatch32 = &match;
6596 {
6597 soulng::parser::Match match(false);
6598 soulng::parser::Match* parentMatch33 = &match;
6599 {
6600 soulng::parser::Match match(false);
6601 if (*lexer == NEW)
6602 {
6603 ++lexer;
6604 match.hit = true;
6605 }
6606 *parentMatch33 = match;
6607 }
6608 if (match.hit)
6609 {
6610 soulng::parser::Match match(false);
6611 soulng::parser::Match* parentMatch34 = &match;
6612 {
6613 soulng::parser::Match match(false);
6614 if (*lexer == LBRACKET)
6615 {
6616 ++lexer;
6617 match.hit = true;
6618 }
6619 *parentMatch34 = match;
6620 }
6621 *parentMatch33 = match;
6622 }
6623 *parentMatch32 = match;
6624 }
6625 if (match.hit)
6626 {
6627 soulng::parser::Match match(false);
6628 soulng::parser::Match* parentMatch35 = &match;
6629 {
6630 soulng::parser::Match match(false);
6631 soulng::parser::Match* parentMatch36 = &match;
6632 {
6633 int64_t pos = lexer.GetPos();
6634 soulng::parser::Match match(false);
6635 if (*lexer == RBRACKET)
6636 {
6637 ++lexer;
6638 match.hit = true;
6639 }
6640 if (match.hit)
6641 {
6642 {
6643 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
6644
6645 #endif // SOULNG_PARSER_DEBUG_SUPPORT
6646 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::newArray));
6647 }
6648 }
6649 *parentMatch36 = match;
6650 }
6651 *parentMatch35 = match;
6652 }
6653 *parentMatch32 = match;
6654 }
6655 *parentMatch31 = match;
6656 if (!match.hit)
6657 {
6658 soulng::parser::Match match(false);
6659 soulng::parser::Match* parentMatch37 = &match;
6660 lexer.SetPos(save);
6661 {
6662 soulng::parser::Match match(false);
6663 soulng::parser::Match* parentMatch38 = &match;
6664 {
6665 soulng::parser::Match match(false);
6666 soulng::parser::Match* parentMatch39 = &match;
6667 {
6668 soulng::parser::Match match(false);
6669 if (*lexer == DELETE)
6670 {
6671 ++lexer;
6672 match.hit = true;
6673 }
6674 *parentMatch39 = match;
6675 }
6676 if (match.hit)
6677 {
6678 soulng::parser::Match match(false);
6679 soulng::parser::Match* parentMatch40 = &match;
6680 {
6681 soulng::parser::Match match(false);
6682 if (*lexer == LBRACKET)
6683 {
6684 ++lexer;
6685 match.hit = true;
6686 }
6687 *parentMatch40 = match;
6688 }
6689 *parentMatch39 = match;
6690 }
6691 *parentMatch38 = match;
6692 }
6693 if (match.hit)
6694 {
6695 soulng::parser::Match match(false);
6696 soulng::parser::Match* parentMatch41 = &match;
6697 {
6698 soulng::parser::Match match(false);
6699 soulng::parser::Match* parentMatch42 = &match;
6700 {
6701 int64_t pos = lexer.GetPos();
6702 soulng::parser::Match match(false);
6703 if (*lexer == RBRACKET)
6704 {
6705 ++lexer;
6706 match.hit = true;
6707 }
6708 if (match.hit)
6709 {
6710 {
6711 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
6712
6713 #endif // SOULNG_PARSER_DEBUG_SUPPORT
6714 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::deleteArray));
6715 }
6716 }
6717 *parentMatch42 = match;
6718 }
6719 *parentMatch41 = match;
6720 }
6721 *parentMatch38 = match;
6722 }
6723 *parentMatch37 = match;
6724 }
6725 *parentMatch31 = match;
6726 }
6727 }
6728 *parentMatch30 = match;
6729 if (!match.hit)
6730 {
6731 soulng::parser::Match match(false);
6732 soulng::parser::Match* parentMatch43 = &match;
6733 lexer.SetPos(save);
6734 {
6735 soulng::parser::Match match(false);
6736 soulng::parser::Match* parentMatch44 = &match;
6737 {
6738 int64_t pos = lexer.GetPos();
6739 soulng::parser::Match match(false);
6740 if (*lexer == NEW)
6741 {
6742 ++lexer;
6743 match.hit = true;
6744 }
6745 if (match.hit)
6746 {
6747 {
6748 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
6749
6750 #endif // SOULNG_PARSER_DEBUG_SUPPORT
6751 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::new_));
6752 }
6753 }
6754 *parentMatch44 = match;
6755 }
6756 *parentMatch43 = match;
6757 }
6758 *parentMatch30 = match;
6759 }
6760 }
6761 *parentMatch29 = match;
6762 if (!match.hit)
6763 {
6764 soulng::parser::Match match(false);
6765 soulng::parser::Match* parentMatch45 = &match;
6766 lexer.SetPos(save);
6767 {
6768 soulng::parser::Match match(false);
6769 soulng::parser::Match* parentMatch46 = &match;
6770 {
6771 int64_t pos = lexer.GetPos();
6772 soulng::parser::Match match(false);
6773 if (*lexer == DELETE)
6774 {
6775 ++lexer;
6776 match.hit = true;
6777 }
6778 if (match.hit)
6779 {
6780 {
6781 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
6782
6783 #endif // SOULNG_PARSER_DEBUG_SUPPORT
6784 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::delete_));
6785 }
6786 }
6787 *parentMatch46 = match;
6788 }
6789 *parentMatch45 = match;
6790 }
6791 *parentMatch29 = match;
6792 }
6793 }
6794 *parentMatch28 = match;
6795 if (!match.hit)
6796 {
6797 soulng::parser::Match match(false);
6798 soulng::parser::Match* parentMatch47 = &match;
6799 lexer.SetPos(save);
6800 {
6801 soulng::parser::Match match(false);
6802 soulng::parser::Match* parentMatch48 = &match;
6803 {
6804 int64_t pos = lexer.GetPos();
6805 soulng::parser::Match match = ExpressionParser::AssignmentOperator(lexer);
6806 assignmentOp.reset(static_cast<soulng::parser::soulng::parser::Value<sngcpp::ast::Operator>*>(match.value));
6807 if (match.hit)
6808 {
6809 {
6810 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
6811
6812 #endif // SOULNG_PARSER_DEBUG_SUPPORT
6813 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(assignmentOp->value));
6814 }
6815 }
6816 *parentMatch48 = match;
6817 }
6818 *parentMatch47 = match;
6819 }
6820 *parentMatch28 = match;
6821 }
6822 }
6823 *parentMatch27 = match;
6824 if (!match.hit)
6825 {
6826 soulng::parser::Match match(false);
6827 soulng::parser::Match* parentMatch49 = &match;
6828 lexer.SetPos(save);
6829 {
6830 soulng::parser::Match match(false);
6831 soulng::parser::Match* parentMatch50 = &match;
6832 {
6833 int64_t pos = lexer.GetPos();
6834 soulng::parser::Match match(false);
6835 if (*lexer == PLUSPLUS)
6836 {
6837 ++lexer;
6838 match.hit = true;
6839 }
6840 if (match.hit)
6841 {
6842 {
6843 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
6844
6845 #endif // SOULNG_PARSER_DEBUG_SUPPORT
6846 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::inc));
6847 }
6848 }
6849 *parentMatch50 = match;
6850 }
6851 *parentMatch49 = match;
6852 }
6853 *parentMatch27 = match;
6854 }
6855 }
6856 *parentMatch26 = match;
6857 if (!match.hit)
6858 {
6859 soulng::parser::Match match(false);
6860 soulng::parser::Match* parentMatch51 = &match;
6861 lexer.SetPos(save);
6862 {
6863 soulng::parser::Match match(false);
6864 soulng::parser::Match* parentMatch52 = &match;
6865 {
6866 int64_t pos = lexer.GetPos();
6867 soulng::parser::Match match(false);
6868 if (*lexer == MINUSMINUS)
6869 {
6870 ++lexer;
6871 match.hit = true;
6872 }
6873 if (match.hit)
6874 {
6875 {
6876 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
6877
6878 #endif // SOULNG_PARSER_DEBUG_SUPPORT
6879 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::dec));
6880 }
6881 }
6882 *parentMatch52 = match;
6883 }
6884 *parentMatch51 = match;
6885 }
6886 *parentMatch26 = match;
6887 }
6888 }
6889 *parentMatch25 = match;
6890 if (!match.hit)
6891 {
6892 soulng::parser::Match match(false);
6893 soulng::parser::Match* parentMatch53 = &match;
6894 lexer.SetPos(save);
6895 {
6896 soulng::parser::Match match(false);
6897 soulng::parser::Match* parentMatch54 = &match;
6898 {
6899 int64_t pos = lexer.GetPos();
6900 soulng::parser::Match match(false);
6901 if (*lexer == SHIFTLEFT)
6902 {
6903 ++lexer;
6904 match.hit = true;
6905 }
6906 if (match.hit)
6907 {
6908 {
6909 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
6910
6911 #endif // SOULNG_PARSER_DEBUG_SUPPORT
6912 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::shiftLeft));
6913 }
6914 }
6915 *parentMatch54 = match;
6916 }
6917 *parentMatch53 = match;
6918 }
6919 *parentMatch25 = match;
6920 }
6921 }
6922 *parentMatch24 = match;
6923 if (!match.hit)
6924 {
6925 soulng::parser::Match match(false);
6926 soulng::parser::Match* parentMatch55 = &match;
6927 lexer.SetPos(save);
6928 {
6929 soulng::parser::Match match(false);
6930 soulng::parser::Match* parentMatch56 = &match;
6931 {
6932 int64_t pos = lexer.GetPos();
6933 soulng::parser::Match match(false);
6934 if (*lexer == SHIFTRIGHT)
6935 {
6936 ++lexer;
6937 match.hit = true;
6938 }
6939 if (match.hit)
6940 {
6941 {
6942 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
6943
6944 #endif // SOULNG_PARSER_DEBUG_SUPPORT
6945 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::shiftRight));
6946 }
6947 }
6948 *parentMatch56 = match;
6949 }
6950 *parentMatch55 = match;
6951 }
6952 *parentMatch24 = match;
6953 }
6954 }
6955 *parentMatch23 = match;
6956 if (!match.hit)
6957 {
6958 soulng::parser::Match match(false);
6959 soulng::parser::Match* parentMatch57 = &match;
6960 lexer.SetPos(save);
6961 {
6962 soulng::parser::Match match(false);
6963 soulng::parser::Match* parentMatch58 = &match;
6964 {
6965 int64_t pos = lexer.GetPos();
6966 soulng::parser::Match match(false);
6967 if (*lexer == AMPAMP)
6968 {
6969 ++lexer;
6970 match.hit = true;
6971 }
6972 if (match.hit)
6973 {
6974 {
6975 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
6976
6977 #endif // SOULNG_PARSER_DEBUG_SUPPORT
6978 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::logicalAnd));
6979 }
6980 }
6981 *parentMatch58 = match;
6982 }
6983 *parentMatch57 = match;
6984 }
6985 *parentMatch23 = match;
6986 }
6987 }
6988 *parentMatch22 = match;
6989 if (!match.hit)
6990 {
6991 soulng::parser::Match match(false);
6992 soulng::parser::Match* parentMatch59 = &match;
6993 lexer.SetPos(save);
6994 {
6995 soulng::parser::Match match(false);
6996 soulng::parser::Match* parentMatch60 = &match;
6997 {
6998 int64_t pos = lexer.GetPos();
6999 soulng::parser::Match match(false);
7000 if (*lexer == OROR)
7001 {
7002 ++lexer;
7003 match.hit = true;
7004 }
7005 if (match.hit)
7006 {
7007 {
7008 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
7009
7010 #endif // SOULNG_PARSER_DEBUG_SUPPORT
7011 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::logicalOr));
7012 }
7013 }
7014 *parentMatch60 = match;
7015 }
7016 *parentMatch59 = match;
7017 }
7018 *parentMatch22 = match;
7019 }
7020 }
7021 *parentMatch21 = match;
7022 if (!match.hit)
7023 {
7024 soulng::parser::Match match(false);
7025 soulng::parser::Match* parentMatch61 = &match;
7026 lexer.SetPos(save);
7027 {
7028 soulng::parser::Match match(false);
7029 soulng::parser::Match* parentMatch62 = &match;
7030 {
7031 int64_t pos = lexer.GetPos();
7032 soulng::parser::Match match(false);
7033 if (*lexer == EQ)
7034 {
7035 ++lexer;
7036 match.hit = true;
7037 }
7038 if (match.hit)
7039 {
7040 {
7041 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
7042
7043 #endif // SOULNG_PARSER_DEBUG_SUPPORT
7044 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::equal));
7045 }
7046 }
7047 *parentMatch62 = match;
7048 }
7049 *parentMatch61 = match;
7050 }
7051 *parentMatch21 = match;
7052 }
7053 }
7054 *parentMatch20 = match;
7055 if (!match.hit)
7056 {
7057 soulng::parser::Match match(false);
7058 soulng::parser::Match* parentMatch63 = &match;
7059 lexer.SetPos(save);
7060 {
7061 soulng::parser::Match match(false);
7062 soulng::parser::Match* parentMatch64 = &match;
7063 {
7064 int64_t pos = lexer.GetPos();
7065 soulng::parser::Match match(false);
7066 if (*lexer == NEQ)
7067 {
7068 ++lexer;
7069 match.hit = true;
7070 }
7071 if (match.hit)
7072 {
7073 {
7074 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
7075
7076 #endif // SOULNG_PARSER_DEBUG_SUPPORT
7077 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::notEqual));
7078 }
7079 }
7080 *parentMatch64 = match;
7081 }
7082 *parentMatch63 = match;
7083 }
7084 *parentMatch20 = match;
7085 }
7086 }
7087 *parentMatch19 = match;
7088 if (!match.hit)
7089 {
7090 soulng::parser::Match match(false);
7091 soulng::parser::Match* parentMatch65 = &match;
7092 lexer.SetPos(save);
7093 {
7094 soulng::parser::Match match(false);
7095 soulng::parser::Match* parentMatch66 = &match;
7096 {
7097 int64_t pos = lexer.GetPos();
7098 soulng::parser::Match match(false);
7099 if (*lexer == LEQ)
7100 {
7101 ++lexer;
7102 match.hit = true;
7103 }
7104 if (match.hit)
7105 {
7106 {
7107 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
7108
7109 #endif // SOULNG_PARSER_DEBUG_SUPPORT
7110 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::lessOrEqual));
7111 }
7112 }
7113 *parentMatch66 = match;
7114 }
7115 *parentMatch65 = match;
7116 }
7117 *parentMatch19 = match;
7118 }
7119 }
7120 *parentMatch18 = match;
7121 if (!match.hit)
7122 {
7123 soulng::parser::Match match(false);
7124 soulng::parser::Match* parentMatch67 = &match;
7125 lexer.SetPos(save);
7126 {
7127 soulng::parser::Match match(false);
7128 soulng::parser::Match* parentMatch68 = &match;
7129 {
7130 int64_t pos = lexer.GetPos();
7131 soulng::parser::Match match(false);
7132 if (*lexer == GEQ)
7133 {
7134 ++lexer;
7135 match.hit = true;
7136 }
7137 if (match.hit)
7138 {
7139 {
7140 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
7141
7142 #endif // SOULNG_PARSER_DEBUG_SUPPORT
7143 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::greaterOrEqual));
7144 }
7145 }
7146 *parentMatch68 = match;
7147 }
7148 *parentMatch67 = match;
7149 }
7150 *parentMatch18 = match;
7151 }
7152 }
7153 *parentMatch17 = match;
7154 if (!match.hit)
7155 {
7156 soulng::parser::Match match(false);
7157 soulng::parser::Match* parentMatch69 = &match;
7158 lexer.SetPos(save);
7159 {
7160 soulng::parser::Match match(false);
7161 soulng::parser::Match* parentMatch70 = &match;
7162 {
7163 int64_t pos = lexer.GetPos();
7164 soulng::parser::Match match(false);
7165 if (*lexer == LANGLE)
7166 {
7167 ++lexer;
7168 match.hit = true;
7169 }
7170 if (match.hit)
7171 {
7172 {
7173 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
7174
7175 #endif // SOULNG_PARSER_DEBUG_SUPPORT
7176 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::less));
7177 }
7178 }
7179 *parentMatch70 = match;
7180 }
7181 *parentMatch69 = match;
7182 }
7183 *parentMatch17 = match;
7184 }
7185 }
7186 *parentMatch16 = match;
7187 if (!match.hit)
7188 {
7189 soulng::parser::Match match(false);
7190 soulng::parser::Match* parentMatch71 = &match;
7191 lexer.SetPos(save);
7192 {
7193 soulng::parser::Match match(false);
7194 soulng::parser::Match* parentMatch72 = &match;
7195 {
7196 int64_t pos = lexer.GetPos();
7197 soulng::parser::Match match(false);
7198 if (*lexer == RANGLE)
7199 {
7200 ++lexer;
7201 match.hit = true;
7202 }
7203 if (match.hit)
7204 {
7205 {
7206 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
7207
7208 #endif // SOULNG_PARSER_DEBUG_SUPPORT
7209 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::greater));
7210 }
7211 }
7212 *parentMatch72 = match;
7213 }
7214 *parentMatch71 = match;
7215 }
7216 *parentMatch16 = match;
7217 }
7218 }
7219 *parentMatch15 = match;
7220 if (!match.hit)
7221 {
7222 soulng::parser::Match match(false);
7223 soulng::parser::Match* parentMatch73 = &match;
7224 lexer.SetPos(save);
7225 {
7226 soulng::parser::Match match(false);
7227 soulng::parser::Match* parentMatch74 = &match;
7228 {
7229 int64_t pos = lexer.GetPos();
7230 soulng::parser::Match match(false);
7231 if (*lexer == DOTSTAR)
7232 {
7233 ++lexer;
7234 match.hit = true;
7235 }
7236 if (match.hit)
7237 {
7238 {
7239 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
7240
7241 #endif // SOULNG_PARSER_DEBUG_SUPPORT
7242 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::dotStar));
7243 }
7244 }
7245 *parentMatch74 = match;
7246 }
7247 *parentMatch73 = match;
7248 }
7249 *parentMatch15 = match;
7250 }
7251 }
7252 *parentMatch14 = match;
7253 if (!match.hit)
7254 {
7255 soulng::parser::Match match(false);
7256 soulng::parser::Match* parentMatch75 = &match;
7257 lexer.SetPos(save);
7258 {
7259 soulng::parser::Match match(false);
7260 soulng::parser::Match* parentMatch76 = &match;
7261 {
7262 int64_t pos = lexer.GetPos();
7263 soulng::parser::Match match(false);
7264 if (*lexer == ARROWSTAR)
7265 {
7266 ++lexer;
7267 match.hit = true;
7268 }
7269 if (match.hit)
7270 {
7271 {
7272 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
7273
7274 #endif // SOULNG_PARSER_DEBUG_SUPPORT
7275 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::arrowStar));
7276 }
7277 }
7278 *parentMatch76 = match;
7279 }
7280 *parentMatch75 = match;
7281 }
7282 *parentMatch14 = match;
7283 }
7284 }
7285 *parentMatch13 = match;
7286 if (!match.hit)
7287 {
7288 soulng::parser::Match match(false);
7289 soulng::parser::Match* parentMatch77 = &match;
7290 lexer.SetPos(save);
7291 {
7292 soulng::parser::Match match(false);
7293 soulng::parser::Match* parentMatch78 = &match;
7294 {
7295 int64_t pos = lexer.GetPos();
7296 soulng::parser::Match match(false);
7297 if (*lexer == ARROW)
7298 {
7299 ++lexer;
7300 match.hit = true;
7301 }
7302 if (match.hit)
7303 {
7304 {
7305 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
7306
7307 #endif // SOULNG_PARSER_DEBUG_SUPPORT
7308 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::arrow));
7309 }
7310 }
7311 *parentMatch78 = match;
7312 }
7313 *parentMatch77 = match;
7314 }
7315 *parentMatch13 = match;
7316 }
7317 }
7318 *parentMatch12 = match;
7319 if (!match.hit)
7320 {
7321 soulng::parser::Match match(false);
7322 soulng::parser::Match* parentMatch79 = &match;
7323 lexer.SetPos(save);
7324 {
7325 soulng::parser::Match match(false);
7326 soulng::parser::Match* parentMatch80 = &match;
7327 {
7328 soulng::parser::Match match(false);
7329 if (*lexer == LPAREN)
7330 {
7331 ++lexer;
7332 match.hit = true;
7333 }
7334 *parentMatch80 = match;
7335 }
7336 if (match.hit)
7337 {
7338 soulng::parser::Match match(false);
7339 soulng::parser::Match* parentMatch81 = &match;
7340 {
7341 soulng::parser::Match match(false);
7342 soulng::parser::Match* parentMatch82 = &match;
7343 {
7344 int64_t pos = lexer.GetPos();
7345 soulng::parser::Match match(false);
7346 if (*lexer == RPAREN)
7347 {
7348 ++lexer;
7349 match.hit = true;
7350 }
7351 if (match.hit)
7352 {
7353 {
7354 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
7355
7356 #endif // SOULNG_PARSER_DEBUG_SUPPORT
7357 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::apply));
7358 }
7359 }
7360 *parentMatch82 = match;
7361 }
7362 *parentMatch81 = match;
7363 }
7364 *parentMatch80 = match;
7365 }
7366 *parentMatch79 = match;
7367 }
7368 *parentMatch12 = match;
7369 }
7370 }
7371 *parentMatch11 = match;
7372 if (!match.hit)
7373 {
7374 soulng::parser::Match match(false);
7375 soulng::parser::Match* parentMatch83 = &match;
7376 lexer.SetPos(save);
7377 {
7378 soulng::parser::Match match(false);
7379 soulng::parser::Match* parentMatch84 = &match;
7380 {
7381 soulng::parser::Match match(false);
7382 if (*lexer == LBRACKET)
7383 {
7384 ++lexer;
7385 match.hit = true;
7386 }
7387 *parentMatch84 = match;
7388 }
7389 if (match.hit)
7390 {
7391 soulng::parser::Match match(false);
7392 soulng::parser::Match* parentMatch85 = &match;
7393 {
7394 soulng::parser::Match match(false);
7395 soulng::parser::Match* parentMatch86 = &match;
7396 {
7397 int64_t pos = lexer.GetPos();
7398 soulng::parser::Match match(false);
7399 if (*lexer == RBRACKET)
7400 {
7401 ++lexer;
7402 match.hit = true;
7403 }
7404 if (match.hit)
7405 {
7406 {
7407 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
7408
7409 #endif // SOULNG_PARSER_DEBUG_SUPPORT
7410 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::subscript));
7411 }
7412 }
7413 *parentMatch86 = match;
7414 }
7415 *parentMatch85 = match;
7416 }
7417 *parentMatch84 = match;
7418 }
7419 *parentMatch83 = match;
7420 }
7421 *parentMatch11 = match;
7422 }
7423 }
7424 *parentMatch10 = match;
7425 if (!match.hit)
7426 {
7427 soulng::parser::Match match(false);
7428 soulng::parser::Match* parentMatch87 = &match;
7429 lexer.SetPos(save);
7430 {
7431 soulng::parser::Match match(false);
7432 soulng::parser::Match* parentMatch88 = &match;
7433 {
7434 int64_t pos = lexer.GetPos();
7435 soulng::parser::Match match(false);
7436 if (*lexer == PLUS)
7437 {
7438 ++lexer;
7439 match.hit = true;
7440 }
7441 if (match.hit)
7442 {
7443 {
7444 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
7445
7446 #endif // SOULNG_PARSER_DEBUG_SUPPORT
7447 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::add));
7448 }
7449 }
7450 *parentMatch88 = match;
7451 }
7452 *parentMatch87 = match;
7453 }
7454 *parentMatch10 = match;
7455 }
7456 }
7457 *parentMatch9 = match;
7458 if (!match.hit)
7459 {
7460 soulng::parser::Match match(false);
7461 soulng::parser::Match* parentMatch89 = &match;
7462 lexer.SetPos(save);
7463 {
7464 soulng::parser::Match match(false);
7465 soulng::parser::Match* parentMatch90 = &match;
7466 {
7467 int64_t pos = lexer.GetPos();
7468 soulng::parser::Match match(false);
7469 if (*lexer == MINUS)
7470 {
7471 ++lexer;
7472 match.hit = true;
7473 }
7474 if (match.hit)
7475 {
7476 {
7477 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
7478
7479 #endif // SOULNG_PARSER_DEBUG_SUPPORT
7480 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::sub));
7481 }
7482 }
7483 *parentMatch90 = match;
7484 }
7485 *parentMatch89 = match;
7486 }
7487 *parentMatch9 = match;
7488 }
7489 }
7490 *parentMatch8 = match;
7491 if (!match.hit)
7492 {
7493 soulng::parser::Match match(false);
7494 soulng::parser::Match* parentMatch91 = &match;
7495 lexer.SetPos(save);
7496 {
7497 soulng::parser::Match match(false);
7498 soulng::parser::Match* parentMatch92 = &match;
7499 {
7500 int64_t pos = lexer.GetPos();
7501 soulng::parser::Match match(false);
7502 if (*lexer == STAR)
7503 {
7504 ++lexer;
7505 match.hit = true;
7506 }
7507 if (match.hit)
7508 {
7509 {
7510 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
7511
7512 #endif // SOULNG_PARSER_DEBUG_SUPPORT
7513 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::mul));
7514 }
7515 }
7516 *parentMatch92 = match;
7517 }
7518 *parentMatch91 = match;
7519 }
7520 *parentMatch8 = match;
7521 }
7522 }
7523 *parentMatch7 = match;
7524 if (!match.hit)
7525 {
7526 soulng::parser::Match match(false);
7527 soulng::parser::Match* parentMatch93 = &match;
7528 lexer.SetPos(save);
7529 {
7530 soulng::parser::Match match(false);
7531 soulng::parser::Match* parentMatch94 = &match;
7532 {
7533 int64_t pos = lexer.GetPos();
7534 soulng::parser::Match match(false);
7535 if (*lexer == DIV)
7536 {
7537 ++lexer;
7538 match.hit = true;
7539 }
7540 if (match.hit)
7541 {
7542 {
7543 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
7544
7545 #endif // SOULNG_PARSER_DEBUG_SUPPORT
7546 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::div));
7547 }
7548 }
7549 *parentMatch94 = match;
7550 }
7551 *parentMatch93 = match;
7552 }
7553 *parentMatch7 = match;
7554 }
7555 }
7556 *parentMatch6 = match;
7557 if (!match.hit)
7558 {
7559 soulng::parser::Match match(false);
7560 soulng::parser::Match* parentMatch95 = &match;
7561 lexer.SetPos(save);
7562 {
7563 soulng::parser::Match match(false);
7564 soulng::parser::Match* parentMatch96 = &match;
7565 {
7566 int64_t pos = lexer.GetPos();
7567 soulng::parser::Match match(false);
7568 if (*lexer == MOD)
7569 {
7570 ++lexer;
7571 match.hit = true;
7572 }
7573 if (match.hit)
7574 {
7575 {
7576 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
7577
7578 #endif // SOULNG_PARSER_DEBUG_SUPPORT
7579 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::rem));
7580 }
7581 }
7582 *parentMatch96 = match;
7583 }
7584 *parentMatch95 = match;
7585 }
7586 *parentMatch6 = match;
7587 }
7588 }
7589 *parentMatch5 = match;
7590 if (!match.hit)
7591 {
7592 soulng::parser::Match match(false);
7593 soulng::parser::Match* parentMatch97 = &match;
7594 lexer.SetPos(save);
7595 {
7596 soulng::parser::Match match(false);
7597 soulng::parser::Match* parentMatch98 = &match;
7598 {
7599 int64_t pos = lexer.GetPos();
7600 soulng::parser::Match match(false);
7601 if (*lexer == XOR)
7602 {
7603 ++lexer;
7604 match.hit = true;
7605 }
7606 if (match.hit)
7607 {
7608 {
7609 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
7610
7611 #endif // SOULNG_PARSER_DEBUG_SUPPORT
7612 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::xor_));
7613 }
7614 }
7615 *parentMatch98 = match;
7616 }
7617 *parentMatch97 = match;
7618 }
7619 *parentMatch5 = match;
7620 }
7621 }
7622 *parentMatch4 = match;
7623 if (!match.hit)
7624 {
7625 soulng::parser::Match match(false);
7626 soulng::parser::Match* parentMatch99 = &match;
7627 lexer.SetPos(save);
7628 {
7629 soulng::parser::Match match(false);
7630 soulng::parser::Match* parentMatch100 = &match;
7631 {
7632 int64_t pos = lexer.GetPos();
7633 soulng::parser::Match match(false);
7634 if (*lexer == AMP)
7635 {
7636 ++lexer;
7637 match.hit = true;
7638 }
7639 if (match.hit)
7640 {
7641 {
7642 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
7643
7644 #endif // SOULNG_PARSER_DEBUG_SUPPORT
7645 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::and_));
7646 }
7647 }
7648 *parentMatch100 = match;
7649 }
7650 *parentMatch99 = match;
7651 }
7652 *parentMatch4 = match;
7653 }
7654 }
7655 *parentMatch3 = match;
7656 if (!match.hit)
7657 {
7658 soulng::parser::Match match(false);
7659 soulng::parser::Match* parentMatch101 = &match;
7660 lexer.SetPos(save);
7661 {
7662 soulng::parser::Match match(false);
7663 soulng::parser::Match* parentMatch102 = &match;
7664 {
7665 int64_t pos = lexer.GetPos();
7666 soulng::parser::Match match(false);
7667 if (*lexer == OR)
7668 {
7669 ++lexer;
7670 match.hit = true;
7671 }
7672 if (match.hit)
7673 {
7674 {
7675 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
7676
7677 #endif // SOULNG_PARSER_DEBUG_SUPPORT
7678 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::or_));
7679 }
7680 }
7681 *parentMatch102 = match;
7682 }
7683 *parentMatch101 = match;
7684 }
7685 *parentMatch3 = match;
7686 }
7687 }
7688 *parentMatch2 = match;
7689 if (!match.hit)
7690 {
7691 soulng::parser::Match match(false);
7692 soulng::parser::Match* parentMatch103 = &match;
7693 lexer.SetPos(save);
7694 {
7695 soulng::parser::Match match(false);
7696 soulng::parser::Match* parentMatch104 = &match;
7697 {
7698 int64_t pos = lexer.GetPos();
7699 soulng::parser::Match match(false);
7700 if (*lexer == TILDE)
7701 {
7702 ++lexer;
7703 match.hit = true;
7704 }
7705 if (match.hit)
7706 {
7707 {
7708 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
7709
7710 #endif // SOULNG_PARSER_DEBUG_SUPPORT
7711 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::complement));
7712 }
7713 }
7714 *parentMatch104 = match;
7715 }
7716 *parentMatch103 = match;
7717 }
7718 *parentMatch2 = match;
7719 }
7720 }
7721 *parentMatch1 = match;
7722 if (!match.hit)
7723 {
7724 soulng::parser::Match match(false);
7725 soulng::parser::Match* parentMatch105 = &match;
7726 lexer.SetPos(save);
7727 {
7728 soulng::parser::Match match(false);
7729 soulng::parser::Match* parentMatch106 = &match;
7730 {
7731 int64_t pos = lexer.GetPos();
7732 soulng::parser::Match match(false);
7733 if (*lexer == EXCLAMATION)
7734 {
7735 ++lexer;
7736 match.hit = true;
7737 }
7738 if (match.hit)
7739 {
7740 {
7741 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
7742
7743 #endif // SOULNG_PARSER_DEBUG_SUPPORT
7744 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::not_));
7745 }
7746 }
7747 *parentMatch106 = match;
7748 }
7749 *parentMatch105 = match;
7750 }
7751 *parentMatch1 = match;
7752 }
7753 }
7754 *parentMatch0 = match;
7755 if (!match.hit)
7756 {
7757 soulng::parser::Match match(false);
7758 soulng::parser::Match* parentMatch107 = &match;
7759 lexer.SetPos(save);
7760 {
7761 soulng::parser::Match match(false);
7762 soulng::parser::Match* parentMatch108 = &match;
7763 {
7764 int64_t pos = lexer.GetPos();
7765 soulng::parser::Match match(false);
7766 if (*lexer == COMMA)
7767 {
7768 ++lexer;
7769 match.hit = true;
7770 }
7771 if (match.hit)
7772 {
7773 {
7774 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
7775
7776 #endif // SOULNG_PARSER_DEBUG_SUPPORT
7777 return soulng::parser::Match(true, new soulng::parser::Value<sngcpp::ast::Operator>(sngcpp::ast::Operator::comma));
7778 }
7779 }
7780 *parentMatch108 = match;
7781 }
7782 *parentMatch107 = match;
7783 }
7784 *parentMatch0 = match;
7785 }
7786 }
7787 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
7788
7789
7790
7791
7792
7793 #endif // SOULNG_PARSER_DEBUG_SUPPORT
7794 if (!match.hit)
7795 {
7796 match.value = nullptr;
7797 }
7798 return match;
7799 }
7800
7801 soulng::parser::Match ExpressionParser::ConversionFunctionId(CppLexer& lexer, sngcpp::cppparser::ParsingContext* ctx)
7802 {
7803 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
7804
7805
7806
7807
7808
7809
7810
7811 #endif // SOULNG_PARSER_DEBUG_SUPPORT
7812 Span s = Span();
7813 std::unique_ptr<sngcpp::ast::Node> typeExpr;
7814 soulng::parser::Match match(false);
7815 soulng::parser::Match* parentMatch0 = &match;
7816 {
7817 soulng::parser::Match match(false);
7818 soulng::parser::Match* parentMatch1 = &match;
7819 {
7820 int64_t pos = lexer.GetPos();
7821 soulng::lexer::Span span = lexer.GetSpan();
7822 soulng::parser::Match match(false);
7823 if (*lexer == OPERATOR)
7824 {
7825 ++lexer;
7826 match.hit = true;
7827 }
7828 if (match.hit)
7829 {
7830 s = span;
7831 }
7832 *parentMatch1 = match;
7833 }
7834 *parentMatch0 = match;
7835 }
7836 if (match.hit)
7837 {
7838 soulng::parser::Match match(false);
7839 soulng::parser::Match* parentMatch2 = &match;
7840 {
7841 soulng::parser::Match match(false);
7842 soulng::parser::Match* parentMatch3 = &match;
7843 {
7844 int64_t pos = lexer.GetPos();
7845 soulng::lexer::Span span = lexer.GetSpan();
7846 soulng::parser::Match match = TypeExprParser::TypeExpr(lexer, ctx);
7847 typeExpr.reset(static_cast<sngcpp::ast::Node*>(match.value));
7848 if (match.hit)
7849 {
7850 s.end = span.end;
7851 {
7852 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
7853
7854 #endif // SOULNG_PARSER_DEBUG_SUPPORT
7855 return soulng::parser::Match(true, new sngcpp::ast::ConversionFunctionIdNode(s, typeExpr.release()));
7856 }
7857 }
7858 *parentMatch3 = match;
7859 }
7860 *parentMatch2 = match;
7861 }
7862 *parentMatch0 = match;
7863 }
7864 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
7865
7866
7867
7868
7869
7870 #endif // SOULNG_PARSER_DEBUG_SUPPORT
7871 if (!match.hit)
7872 {
7873 match.value = nullptr;
7874 }
7875 return match;
7876 }
7877
7878 soulng::parser::Match ExpressionParser::LambdaExpression(CppLexer& lexer, sngcpp::cppparser::ParsingContext* ctx)
7879 {
7880 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
7881
7882
7883
7884
7885
7886
7887
7888 #endif // SOULNG_PARSER_DEBUG_SUPPORT
7889 std::unique_ptr<sngcpp::ast::LambdaExpressionNode> node = std::unique_ptr<sngcpp::ast::LambdaExpressionNode>();
7890 std::unique_ptr<sngcpp::ast::Node> params;
7891 std::unique_ptr<sngcpp::ast::CompoundStatementNode> body;
7892 soulng::parser::Match match(false);
7893 soulng::parser::Match* parentMatch0 = &match;
7894 {
7895 soulng::parser::Match match(false);
7896 soulng::parser::Match* parentMatch1 = &match;
7897 {
7898 soulng::parser::Match match(false);
7899 soulng::parser::Match* parentMatch2 = &match;
7900 {
7901 soulng::parser::Match match(false);
7902 soulng::parser::Match* parentMatch3 = &match;
7903 {
7904 soulng::parser::Match match(false);
7905 soulng::parser::Match* parentMatch4 = &match;
7906 {
7907 int64_t pos = lexer.GetPos();
7908 soulng::lexer::Span span = lexer.GetSpan();
7909 soulng::parser::Match match(false);
7910 if (*lexer == LBRACKET)
7911 {
7912 ++lexer;
7913 match.hit = true;
7914 }
7915 if (match.hit)
7916 {
7917 node.reset(new sngcpp::ast::LambdaExpressionNode(span));
7918 }
7919 *parentMatch4 = match;
7920 }
7921 *parentMatch3 = match;
7922 }
7923 if (match.hit)
7924 {
7925 soulng::parser::Match match(false);
7926 soulng::parser::Match* parentMatch5 = &match;
7927 {
7928 soulng::parser::Match match = ExpressionParser::LambdaCaptures(lexer, node.get());
7929 *parentMatch5 = match;
7930 }
7931 *parentMatch3 = match;
7932 }
7933 *parentMatch2 = match;
7934 }
7935 if (match.hit)
7936 {
7937 soulng::parser::Match match(false);
7938 soulng::parser::Match* parentMatch6 = &match;
7939 {
7940 soulng::parser::Match match(true);
7941 soulng::parser::Match* parentMatch7 = &match;
7942 {
7943 soulng::lexer::Span span = lexer.GetSpan();
7944 soulng::parser::Match match(false);
7945 if (*lexer == RBRACKET)
7946 {
7947 ++lexer;
7948 match.hit = true;
7949 }
7950 if (match.hit)
7951 {
7952 *parentMatch7 = match;
7953 }
7954 else
7955 {
7956 lexer.ThrowExpectationFailure(span, ToUtf32(GetTokenInfo(RBRACKET)));
7957 }
7958 }
7959 *parentMatch6 = match;
7960 }
7961 *parentMatch2 = match;
7962 }
7963 *parentMatch1 = match;
7964 }
7965 if (match.hit)
7966 {
7967 soulng::parser::Match match(false);
7968 soulng::parser::Match* parentMatch8 = &match;
7969 {
7970 soulng::parser::Match match(true);
7971 int64_t save = lexer.GetPos();
7972 soulng::parser::Match* parentMatch9 = &match;
7973 {
7974 soulng::parser::Match match(false);
7975 soulng::parser::Match* parentMatch10 = &match;
7976 {
7977 soulng::parser::Match match(false);
7978 soulng::parser::Match* parentMatch11 = &match;
7979 {
7980 int64_t pos = lexer.GetPos();
7981 soulng::parser::Match match = FunctionParser::ParameterList(lexer, ctx);
7982 params.reset(static_cast<sngcpp::ast::Node*>(match.value));
7983 if (match.hit)
7984 {
7985 node->SetParameters(params.release());
7986 }
7987 *parentMatch11 = match;
7988 }
7989 *parentMatch10 = match;
7990 }
7991 if (match.hit)
7992 {
7993 *parentMatch9 = match;
7994 }
7995 else
7996 {
7997 lexer.SetPos(save);
7998 }
7999 }
8000 *parentMatch8 = match;
8001 }
8002 *parentMatch1 = match;
8003 }
8004 *parentMatch0 = match;
8005 }
8006 if (match.hit)
8007 {
8008 soulng::parser::Match match(false);
8009 soulng::parser::Match* parentMatch12 = &match;
8010 {
8011 soulng::parser::Match match(false);
8012 soulng::parser::Match* parentMatch13 = &match;
8013 {
8014 int64_t pos = lexer.GetPos();
8015 soulng::parser::Match match(true);
8016 soulng::parser::Match* parentMatch14 = &match;
8017 {
8018 soulng::lexer::Span span = lexer.GetSpan();
8019 soulng::parser::Match match = StatementParser::CompoundStatement(lexer, ctx);
8020 body.reset(static_cast<sngcpp::ast::CompoundStatementNode*>(match.value));
8021 if (match.hit)
8022 {
8023 *parentMatch14 = match;
8024 }
8025 else
8026 {
8027 lexer.ThrowExpectationFailure(span, U"CompoundStatement");
8028 }
8029 }
8030 if (match.hit)
8031 {
8032 node->SetBody(body.release());
8033 {
8034 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
8035
8036 #endif // SOULNG_PARSER_DEBUG_SUPPORT
8037 return soulng::parser::Match(true, node.release());
8038 }
8039 }
8040 *parentMatch13 = match;
8041 }
8042 *parentMatch12 = match;
8043 }
8044 *parentMatch0 = match;
8045 }
8046 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
8047
8048
8049
8050
8051
8052 #endif // SOULNG_PARSER_DEBUG_SUPPORT
8053 if (!match.hit)
8054 {
8055 match.value = nullptr;
8056 }
8057 return match;
8058 }
8059
8060 soulng::parser::Match ExpressionParser::LambdaCaptures(CppLexer& lexer, sngcpp::ast::LambdaExpressionNode* lambdaExpression)
8061 {
8062 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
8063
8064
8065
8066
8067
8068
8069
8070 #endif // SOULNG_PARSER_DEBUG_SUPPORT
8071 std::unique_ptr<sngcpp::ast::Node> captureDefault;
8072 soulng::parser::Match match(false);
8073 soulng::parser::Match* parentMatch0 = &match;
8074 {
8075 soulng::parser::Match match(true);
8076 int64_t save = lexer.GetPos();
8077 soulng::parser::Match* parentMatch1 = &match;
8078 {
8079 soulng::parser::Match match(false);
8080 soulng::parser::Match* parentMatch2 = &match;
8081 {
8082 soulng::parser::Match match(false);
8083 soulng::parser::Match* parentMatch3 = &match;
8084 {
8085 int64_t pos = lexer.GetPos();
8086 soulng::parser::Match match = ExpressionParser::CaptureDefault(lexer);
8087 captureDefault.reset(static_cast<sngcpp::ast::Node*>(match.value));
8088 if (match.hit)
8089 {
8090 lambdaExpression->AddCapture(captureDefault.release());
8091 }
8092 *parentMatch3 = match;
8093 }
8094 *parentMatch2 = match;
8095 }
8096 if (match.hit)
8097 {
8098 *parentMatch1 = match;
8099 }
8100 else
8101 {
8102 lexer.SetPos(save);
8103 }
8104 }
8105 *parentMatch0 = match;
8106 }
8107 if (match.hit)
8108 {
8109 soulng::parser::Match match(false);
8110 soulng::parser::Match* parentMatch4 = &match;
8111 {
8112 soulng::parser::Match match(true);
8113 int64_t save = lexer.GetPos();
8114 soulng::parser::Match* parentMatch5 = &match;
8115 {
8116 soulng::parser::Match match = ExpressionParser::Captures(lexer, lambdaExpression);
8117 if (match.hit)
8118 {
8119 *parentMatch5 = match;
8120 }
8121 else
8122 {
8123 lexer.SetPos(save);
8124 }
8125 }
8126 *parentMatch4 = match;
8127 }
8128 *parentMatch0 = match;
8129 }
8130 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
8131
8132
8133
8134
8135
8136 #endif // SOULNG_PARSER_DEBUG_SUPPORT
8137 if (!match.hit)
8138 {
8139 match.value = nullptr;
8140 }
8141 return match;
8142 }
8143
8144 soulng::parser::Match ExpressionParser::CaptureDefault(CppLexer& lexer)
8145 {
8146 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
8147
8148
8149
8150
8151
8152
8153
8154 #endif // SOULNG_PARSER_DEBUG_SUPPORT
8155 soulng::parser::Match match(false);
8156 int64_t pos = lexer.GetPos();
8157 soulng::lexer::Span span = lexer.GetSpan();
8158 switch (*lexer)
8159 {
8160 case ASSIGN:
8161 {
8162 ++lexer;
8163 {
8164 {
8165 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
8166
8167 #endif // SOULNG_PARSER_DEBUG_SUPPORT
8168 return soulng::parser::Match(true, new sngcpp::ast::AssignCaptureNode(span));
8169 }
8170 }
8171 break;
8172 }
8173 case AMP:
8174 {
8175 ++lexer;
8176 {
8177 {
8178 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
8179
8180 #endif // SOULNG_PARSER_DEBUG_SUPPORT
8181 return soulng::parser::Match(true, new sngcpp::ast::RefCaptureNode(span));
8182 }
8183 }
8184 break;
8185 }
8186 }
8187 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
8188
8189
8190
8191
8192
8193 #endif // SOULNG_PARSER_DEBUG_SUPPORT
8194 if (!match.hit)
8195 {
8196 match.value = nullptr;
8197 }
8198 return match;
8199 }
8200
8201 soulng::parser::Match ExpressionParser::Captures(CppLexer& lexer, sngcpp::ast::LambdaExpressionNode* lambdaExpression)
8202 {
8203 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
8204
8205
8206
8207
8208
8209
8210
8211 #endif // SOULNG_PARSER_DEBUG_SUPPORT
8212 std::unique_ptr<sngcpp::ast::Node> left;
8213 std::unique_ptr<sngcpp::ast::Node> right;
8214 soulng::parser::Match match(false);
8215 soulng::parser::Match* parentMatch0 = &match;
8216 {
8217 soulng::parser::Match match(false);
8218 soulng::parser::Match* parentMatch1 = &match;
8219 {
8220 int64_t pos = lexer.GetPos();
8221 soulng::parser::Match match = ExpressionParser::Capture(lexer);
8222 left.reset(static_cast<sngcpp::ast::Node*>(match.value));
8223 if (match.hit)
8224 {
8225 lambdaExpression->AddCapture(left.release());
8226 }
8227 *parentMatch1 = match;
8228 }
8229 *parentMatch0 = match;
8230 }
8231 if (match.hit)
8232 {
8233 soulng::parser::Match match(false);
8234 soulng::parser::Match* parentMatch2 = &match;
8235 {
8236 soulng::parser::Match match(true);
8237 soulng::parser::Match* parentMatch3 = &match;
8238 {
8239 while (true)
8240 {
8241 int64_t save = lexer.GetPos();
8242 {
8243 soulng::parser::Match match(false);
8244 soulng::parser::Match* parentMatch4 = &match;
8245 {
8246 soulng::parser::Match match(false);
8247 soulng::parser::Match* parentMatch5 = &match;
8248 {
8249 soulng::parser::Match match(false);
8250 if (*lexer == COMMA)
8251 {
8252 ++lexer;
8253 match.hit = true;
8254 }
8255 *parentMatch5 = match;
8256 }
8257 if (match.hit)
8258 {
8259 soulng::parser::Match match(false);
8260 soulng::parser::Match* parentMatch6 = &match;
8261 {
8262 soulng::parser::Match match(false);
8263 soulng::parser::Match* parentMatch7 = &match;
8264 {
8265 int64_t pos = lexer.GetPos();
8266 soulng::parser::Match match = ExpressionParser::Capture(lexer);
8267 right.reset(static_cast<sngcpp::ast::Node*>(match.value));
8268 if (match.hit)
8269 {
8270 lambdaExpression->AddCapture(right.release());
8271 }
8272 *parentMatch7 = match;
8273 }
8274 *parentMatch6 = match;
8275 }
8276 *parentMatch5 = match;
8277 }
8278 *parentMatch4 = match;
8279 }
8280 if (match.hit)
8281 {
8282 *parentMatch3 = match;
8283 }
8284 else
8285 {
8286 lexer.SetPos(save);
8287 break;
8288 }
8289 }
8290 }
8291 }
8292 *parentMatch2 = match;
8293 }
8294 *parentMatch0 = match;
8295 }
8296 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
8297
8298
8299
8300
8301
8302 #endif // SOULNG_PARSER_DEBUG_SUPPORT
8303 if (!match.hit)
8304 {
8305 match.value = nullptr;
8306 }
8307 return match;
8308 }
8309
8310 soulng::parser::Match ExpressionParser::Capture(CppLexer& lexer)
8311 {
8312 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
8313
8314
8315
8316
8317
8318
8319
8320 #endif // SOULNG_PARSER_DEBUG_SUPPORT
8321 std::unique_ptr<soulng::parser::soulng::parser::Value<std::u32string>>id;
8322 soulng::parser::Match match(false);
8323 soulng::parser::Match* parentMatch0 = &match;
8324 {
8325 int64_t save = lexer.GetPos();
8326 soulng::parser::Match match(false);
8327 soulng::parser::Match* parentMatch1 = &match;
8328 {
8329 int64_t pos = lexer.GetPos();
8330 soulng::lexer::Span span = lexer.GetSpan();
8331 soulng::parser::Match match = IdentifierParser::Identifier(lexer);
8332 id.reset(static_cast<soulng::parser::soulng::parser::Value<std::u32string>*>(match.value));
8333 if (match.hit)
8334 {
8335 {
8336 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
8337
8338 #endif // SOULNG_PARSER_DEBUG_SUPPORT
8339 return soulng::parser::Match(true, new sngcpp::ast::IdentifierCaptureNode(span, new sngcpp::ast::IdentifierNode(span, id->value)));
8340 }
8341 }
8342 *parentMatch1 = match;
8343 }
8344 *parentMatch0 = match;
8345 if (!match.hit)
8346 {
8347 soulng::parser::Match match(false);
8348 soulng::parser::Match* parentMatch2 = &match;
8349 lexer.SetPos(save);
8350 {
8351 soulng::parser::Match match(false);
8352 soulng::parser::Match* parentMatch3 = &match;
8353 {
8354 int64_t pos = lexer.GetPos();
8355 soulng::lexer::Span span = lexer.GetSpan();
8356 soulng::parser::Match match(false);
8357 if (*lexer == THIS)
8358 {
8359 ++lexer;
8360 match.hit = true;
8361 }
8362 if (match.hit)
8363 {
8364 {
8365 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
8366
8367 #endif // SOULNG_PARSER_DEBUG_SUPPORT
8368 return soulng::parser::Match(true, new sngcpp::ast::ThisCaptureNode(span));
8369 }
8370 }
8371 *parentMatch3 = match;
8372 }
8373 *parentMatch2 = match;
8374 }
8375 *parentMatch0 = match;
8376 }
8377 }
8378 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
8379
8380
8381
8382
8383
8384 #endif // SOULNG_PARSER_DEBUG_SUPPORT
8385 if (!match.hit)
8386 {
8387 match.value = nullptr;
8388 }
8389 return match;
8390 }