1 #include "Class.hpp"
2 #include <soulng/util/Unicode.hpp>
3 #include <sngcm/cmparser/Attribute.hpp>
4 #include <sngcm/cmparser/Specifier.hpp>
5 #include <sngcm/cmparser/Identifier.hpp>
6 #include <sngcm/cmparser/TypeExpr.hpp>
7 #include <sngcm/cmparser/Concept.hpp>
8 #include <sngcm/cmparser/Expression.hpp>
9 #include <sngcm/cmparser/Statement.hpp>
10 #include <sngcm/cmparser/Parameter.hpp>
11 #include <sngcm/cmparser/Function.hpp>
12 #include <sngcm/cmparser/Template.hpp>
13 #include <sngcm/cmparser/Typedef.hpp>
14 #include <sngcm/cmparser/Enumeration.hpp>
15 #include <sngcm/cmparser/Constant.hpp>
16 #include <sngcm/cmparser/Delegate.hpp>
17 #include <sngcm/cmlexer/CmajorLexer.hpp>
18 #include <sngcm/cmlexer/CmajorTokens.hpp>
19
20
21
22 using namespace soulng::unicode;
23 using namespace sngcm::ast;
24 using namespace CmajorTokens;
25
26 soulng::parser::Match ClassParser::Class(CmajorLexer& lexer, boost::uuids::uuid* moduleId, ParsingContext* ctx)
27 {
28 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
29
30
31
32
33
34
35
36 #endif // SOULNG_PARSER_DEBUG_SUPPORT
37 std::unique_ptr<ClassNode> cls = std::unique_ptr<ClassNode>();
38 Span s = Span();
39 Span specifierSpan = Span();
40 Span classSpan = Span();
41 Span beginBraceSpan = Span();
42 Span endBraceSpan = Span();
43 std::unique_ptr<sngcm::ast::AttributesNode> attrs;
44 std::unique_ptr<soulng::parser::soulng::parser::Value<sngcm::ast::Specifiers>>specifiers;
45 std::unique_ptr<IdentifierNode> id;
46 std::unique_ptr<WhereConstraintNode> constraint;
47 soulng::parser::Match match(false);
48 soulng::parser::Match* parentMatch0 = &match;
49 {
50 soulng::parser::Match match(false);
51 soulng::parser::Match* parentMatch1 = &match;
52 {
53 soulng::parser::Match match(false);
54 soulng::parser::Match* parentMatch2 = &match;
55 {
56 soulng::parser::Match match(false);
57 soulng::parser::Match* parentMatch3 = &match;
58 {
59 soulng::parser::Match match(false);
60 soulng::parser::Match* parentMatch4 = &match;
61 {
62 soulng::parser::Match match(false);
63 soulng::parser::Match* parentMatch5 = &match;
64 {
65 soulng::parser::Match match(false);
66 soulng::parser::Match* parentMatch6 = &match;
67 {
68 soulng::parser::Match match(false);
69 soulng::parser::Match* parentMatch7 = &match;
70 {
71 soulng::parser::Match match(false);
72 soulng::parser::Match* parentMatch8 = &match;
73 {
74 soulng::parser::Match match(false);
75 soulng::parser::Match* parentMatch9 = &match;
76 {
77 soulng::parser::Match match(false);
78 soulng::parser::Match* parentMatch10 = &match;
79 {
80 int64_t pos = lexer.GetPos();
81 soulng::lexer::Span span = lexer.GetSpan();
82 soulng::parser::Match match(true);
83 if (match.hit)
84 {
85 s = span;
86 }
87 *parentMatch10 = match;
88 }
89 *parentMatch9 = match;
90 }
91 if (match.hit)
92 {
93 soulng::parser::Match match(false);
94 soulng::parser::Match* parentMatch11 = &match;
95 {
96 soulng::parser::Match match(true);
97 int64_t save = lexer.GetPos();
98 soulng::parser::Match* parentMatch12 = &match;
99 {
100 soulng::parser::Match match = AttributeParser::Attributes(lexer, moduleId);
101 attrs.reset(static_cast<sngcm::ast::AttributesNode*>(match.value));
102 if (match.hit)
103 {
104 *parentMatch12 = match;
105 }
106 else
107 {
108 lexer.SetPos(save);
109 }
110 }
111 *parentMatch11 = match;
112 }
113 *parentMatch9 = match;
114 }
115 *parentMatch8 = match;
116 }
117 if (match.hit)
118 {
119 soulng::parser::Match match(false);
120 soulng::parser::Match* parentMatch13 = &match;
121 {
122 soulng::parser::Match match(false);
123 soulng::parser::Match* parentMatch14 = &match;
124 {
125 soulng::parser::Match match(false);
126 soulng::parser::Match* parentMatch15 = &match;
127 int64_t save = lexer.GetPos();
128 {
129 soulng::parser::Match match(false);
130 soulng::parser::Match* parentMatch16 = &match;
131 {
132 int64_t pos = lexer.GetPos();
133 soulng::lexer::Span span = lexer.GetSpan();
134 soulng::parser::Match match = SpecifierParser::Specifiers(lexer);
135 specifiers.reset(static_cast<soulng::parser::soulng::parser::Value<sngcm::ast::Specifiers>*>(match.value));
136 if (match.hit)
137 {
138 specifierSpan = span;
139 }
140 *parentMatch16 = match;
141 }
142 *parentMatch15 = match;
143 }
144 if (match.hit)
145 {
146 soulng::parser::Match match(false);
147 soulng::parser::Match* parentMatch17 = &match;
148 {
149 int64_t tmp = lexer.GetPos();
150 lexer.SetPos(save);
151 save = tmp;
152 soulng::parser::Match match(false);
153 if (*lexer == NEW)
154 {
155 ++lexer;
156 match.hit = true;
157 }
158 *parentMatch17 = match;
159 }
160 if (!match.hit)
161 {
162 lexer.SetPos(save);
163 }
164 *parentMatch15 = soulng::parser::Match(!match.hit, match.value);
165 }
166 *parentMatch14 = match;
167 }
168 *parentMatch13 = match;
169 }
170 *parentMatch8 = match;
171 }
172 *parentMatch7 = match;
173 }
174 if (match.hit)
175 {
176 soulng::parser::Match match(false);
177 soulng::parser::Match* parentMatch18 = &match;
178 {
179 soulng::parser::Match match(false);
180 soulng::parser::Match* parentMatch19 = &match;
181 {
182 int64_t pos = lexer.GetPos();
183 soulng::lexer::Span span = lexer.GetSpan();
184 soulng::parser::Match match(false);
185 if (*lexer == CLASS)
186 {
187 ++lexer;
188 match.hit = true;
189 }
190 if (match.hit)
191 {
192 classSpan = span;
193 }
194 *parentMatch19 = match;
195 }
196 *parentMatch18 = match;
197 }
198 *parentMatch7 = match;
199 }
200 *parentMatch6 = match;
201 }
202 if (match.hit)
203 {
204 soulng::parser::Match match(false);
205 soulng::parser::Match* parentMatch20 = &match;
206 {
207 soulng::parser::Match match(false);
208 soulng::parser::Match* parentMatch21 = &match;
209 {
210 int64_t pos = lexer.GetPos();
211 soulng::lexer::Span span = lexer.GetSpan();
212 soulng::parser::Match match = IdentifierParser::Identifier(lexer, moduleId);
213 id.reset(static_cast<IdentifierNode*>(match.value));
214 if (match.hit)
215 {
216 s.end = span.end;
217 cls.reset(new ClassNode(s, *moduleId, specifiers->value, id.release(), attrs.release()));
218 cls->SetSpecifierSpan(specifierSpan);
219 cls->SetClassSpan(classSpan);
220 }
221 *parentMatch21 = match;
222 }
223 *parentMatch20 = match;
224 }
225 *parentMatch6 = match;
226 }
227 *parentMatch5 = match;
228 }
229 if (match.hit)
230 {
231 soulng::parser::Match match(false);
232 soulng::parser::Match* parentMatch22 = &match;
233 {
234 soulng::parser::Match match(true);
235 int64_t save = lexer.GetPos();
236 soulng::parser::Match* parentMatch23 = &match;
237 {
238 soulng::parser::Match match = TemplateParser::TemplateParameterList(lexer, moduleId, ctx, cls.get());
239 if (match.hit)
240 {
241 *parentMatch23 = match;
242 }
243 else
244 {
245 lexer.SetPos(save);
246 }
247 }
248 *parentMatch22 = match;
249 }
250 *parentMatch5 = match;
251 }
252 *parentMatch4 = match;
253 }
254 if (match.hit)
255 {
256 soulng::parser::Match match(false);
257 soulng::parser::Match* parentMatch24 = &match;
258 {
259 soulng::parser::Match match(true);
260 int64_t save = lexer.GetPos();
261 soulng::parser::Match* parentMatch25 = &match;
262 {
263 soulng::parser::Match match = ClassParser::InheritanceAndInterfaces(lexer, moduleId, ctx, cls.get());
264 if (match.hit)
265 {
266 *parentMatch25 = match;
267 }
268 else
269 {
270 lexer.SetPos(save);
271 }
272 }
273 *parentMatch24 = match;
274 }
275 *parentMatch4 = match;
276 }
277 *parentMatch3 = match;
278 }
279 if (match.hit)
280 {
281 soulng::parser::Match match(false);
282 soulng::parser::Match* parentMatch26 = &match;
283 {
284 soulng::parser::Match match(true);
285 int64_t save = lexer.GetPos();
286 soulng::parser::Match* parentMatch27 = &match;
287 {
288 soulng::parser::Match match(false);
289 soulng::parser::Match* parentMatch28 = &match;
290 {
291 soulng::parser::Match match(false);
292 soulng::parser::Match* parentMatch29 = &match;
293 {
294 int64_t pos = lexer.GetPos();
295 soulng::parser::Match match = ConceptParser::WhereConstraint(lexer, moduleId, ctx);
296 constraint.reset(static_cast<WhereConstraintNode*>(match.value));
297 if (match.hit)
298 {
299 cls->SetConstraint(constraint.release());
300 }
301 *parentMatch29 = match;
302 }
303 *parentMatch28 = match;
304 }
305 if (match.hit)
306 {
307 *parentMatch27 = match;
308 }
309 else
310 {
311 lexer.SetPos(save);
312 }
313 }
314 *parentMatch26 = match;
315 }
316 *parentMatch3 = match;
317 }
318 *parentMatch2 = match;
319 }
320 if (match.hit)
321 {
322 soulng::parser::Match match(false);
323 soulng::parser::Match* parentMatch30 = &match;
324 {
325 soulng::parser::Match match(false);
326 soulng::parser::Match* parentMatch31 = &match;
327 {
328 int64_t pos = lexer.GetPos();
329 soulng::lexer::Span span = lexer.GetSpan();
330 soulng::parser::Match match(true);
331 soulng::parser::Match* parentMatch32 = &match;
332 {
333 soulng::lexer::Span span = lexer.GetSpan();
334 soulng::parser::Match match(false);
335 if (*lexer == LBRACE)
336 {
337 ++lexer;
338 match.hit = true;
339 }
340 if (match.hit)
341 {
342 *parentMatch32 = match;
343 }
344 else
345 {
346 lexer.ThrowExpectationFailure(span, ToUtf32(GetTokenInfo(LBRACE)));
347 }
348 }
349 if (match.hit)
350 {
351 beginBraceSpan = span;
352 }
353 *parentMatch31 = match;
354 }
355 *parentMatch30 = match;
356 }
357 *parentMatch2 = match;
358 }
359 *parentMatch1 = match;
360 }
361 if (match.hit)
362 {
363 soulng::parser::Match match(false);
364 soulng::parser::Match* parentMatch33 = &match;
365 {
366 soulng::parser::Match match = ClassParser::ClassContent(lexer, moduleId, ctx, cls.get());
367 *parentMatch33 = match;
368 }
369 *parentMatch1 = match;
370 }
371 *parentMatch0 = match;
372 }
373 if (match.hit)
374 {
375 soulng::parser::Match match(false);
376 soulng::parser::Match* parentMatch34 = &match;
377 {
378 soulng::parser::Match match(false);
379 soulng::parser::Match* parentMatch35 = &match;
380 {
381 int64_t pos = lexer.GetPos();
382 soulng::lexer::Span span = lexer.GetSpan();
383 soulng::parser::Match match(true);
384 soulng::parser::Match* parentMatch36 = &match;
385 {
386 soulng::lexer::Span span = lexer.GetSpan();
387 soulng::parser::Match match(false);
388 if (*lexer == RBRACE)
389 {
390 ++lexer;
391 match.hit = true;
392 }
393 if (match.hit)
394 {
395 *parentMatch36 = match;
396 }
397 else
398 {
399 lexer.ThrowExpectationFailure(span, ToUtf32(GetTokenInfo(RBRACE)));
400 }
401 }
402 if (match.hit)
403 {
404 endBraceSpan = span;
405 cls->SetBeginBraceSpan(beginBraceSpan);
406 cls->SetEndBraceSpan(endBraceSpan);
407 {
408 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
409
410 #endif // SOULNG_PARSER_DEBUG_SUPPORT
411 return soulng::parser::Match(true, cls.release());
412 }
413 }
414 *parentMatch35 = match;
415 }
416 *parentMatch34 = match;
417 }
418 *parentMatch0 = match;
419 }
420 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
421
422
423
424
425
426 #endif // SOULNG_PARSER_DEBUG_SUPPORT
427 if (!match.hit)
428 {
429 match.value = nullptr;
430 }
431 return match;
432 }
433
434 soulng::parser::Match ClassParser::InheritanceAndInterfaces(CmajorLexer& lexer, boost::uuids::uuid* moduleId, ParsingContext* ctx, sngcm::ast::ClassNode* classNode)
435 {
436 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
437
438
439
440
441
442
443
444 #endif // SOULNG_PARSER_DEBUG_SUPPORT
445 std::unique_ptr<Node> baseOrIntf;
446 soulng::parser::Match match(false);
447 soulng::parser::Match* parentMatch0 = &match;
448 {
449 soulng::parser::Match match(false);
450 if (*lexer == COLON)
451 {
452 ++lexer;
453 match.hit = true;
454 }
455 *parentMatch0 = match;
456 }
457 if (match.hit)
458 {
459 soulng::parser::Match match(false);
460 soulng::parser::Match* parentMatch1 = &match;
461 {
462 soulng::parser::Match match(false);
463 soulng::parser::Match* parentMatch2 = &match;
464 {
465 soulng::parser::Match match(false);
466 soulng::parser::Match* parentMatch3 = &match;
467 {
468 soulng::parser::Match match(false);
469 soulng::parser::Match* parentMatch4 = &match;
470 {
471 soulng::parser::Match match(false);
472 soulng::parser::Match* parentMatch5 = &match;
473 {
474 int64_t pos = lexer.GetPos();
475 soulng::parser::Match match(true);
476 if (match.hit)
477 {
478 ctx->BeginParsingTypeExpr();
479 }
480 *parentMatch5 = match;
481 }
482 *parentMatch4 = match;
483 }
484 if (match.hit)
485 {
486 soulng::parser::Match match(false);
487 soulng::parser::Match* parentMatch6 = &match;
488 {
489 soulng::parser::Match match(false);
490 soulng::parser::Match* parentMatch7 = &match;
491 {
492 int64_t pos = lexer.GetPos();
493 soulng::parser::Match match = ClassParser::BaseClassOrInterface(lexer, moduleId, ctx);
494 baseOrIntf.reset(static_cast<Node*>(match.value));
495 if (match.hit)
496 {
497 classNode->AddBaseClassOrInterface(baseOrIntf.release());
498 ctx->EndParsingTypeExpr();
499 }
500 else
501 {
502 ctx->EndParsingTypeExpr();
503 }
504 *parentMatch7 = match;
505 }
506 *parentMatch6 = match;
507 }
508 *parentMatch4 = match;
509 }
510 *parentMatch3 = match;
511 }
512 *parentMatch2 = match;
513 }
514 if (match.hit)
515 {
516 soulng::parser::Match match(false);
517 soulng::parser::Match* parentMatch8 = &match;
518 {
519 soulng::parser::Match match(true);
520 soulng::parser::Match* parentMatch9 = &match;
521 {
522 while (true)
523 {
524 int64_t save = lexer.GetPos();
525 {
526 soulng::parser::Match match(false);
527 soulng::parser::Match* parentMatch10 = &match;
528 {
529 soulng::parser::Match match(false);
530 if (*lexer == COMMA)
531 {
532 ++lexer;
533 match.hit = true;
534 }
535 *parentMatch10 = match;
536 }
537 if (match.hit)
538 {
539 soulng::parser::Match match(false);
540 soulng::parser::Match* parentMatch11 = &match;
541 {
542 soulng::parser::Match match(false);
543 soulng::parser::Match* parentMatch12 = &match;
544 {
545 soulng::parser::Match match(false);
546 soulng::parser::Match* parentMatch13 = &match;
547 {
548 soulng::parser::Match match(false);
549 soulng::parser::Match* parentMatch14 = &match;
550 {
551 int64_t pos = lexer.GetPos();
552 soulng::parser::Match match(true);
553 if (match.hit)
554 {
555 ctx->BeginParsingTypeExpr();
556 }
557 *parentMatch14 = match;
558 }
559 *parentMatch13 = match;
560 }
561 if (match.hit)
562 {
563 soulng::parser::Match match(false);
564 soulng::parser::Match* parentMatch15 = &match;
565 {
566 soulng::parser::Match match(false);
567 soulng::parser::Match* parentMatch16 = &match;
568 {
569 int64_t pos = lexer.GetPos();
570 soulng::parser::Match match = ClassParser::BaseClassOrInterface(lexer, moduleId, ctx);
571 baseOrIntf.reset(static_cast<Node*>(match.value));
572 if (match.hit)
573 {
574 classNode->AddBaseClassOrInterface(baseOrIntf.release());
575 ctx->EndParsingTypeExpr();
576 }
577 else
578 {
579 ctx->EndParsingTypeExpr();
580 }
581 *parentMatch16 = match;
582 }
583 *parentMatch15 = match;
584 }
585 *parentMatch13 = match;
586 }
587 *parentMatch12 = match;
588 }
589 *parentMatch11 = match;
590 }
591 *parentMatch10 = match;
592 }
593 if (match.hit)
594 {
595 *parentMatch9 = match;
596 }
597 else
598 {
599 lexer.SetPos(save);
600 break;
601 }
602 }
603 }
604 }
605 *parentMatch8 = match;
606 }
607 *parentMatch2 = match;
608 }
609 *parentMatch1 = match;
610 }
611 *parentMatch0 = match;
612 }
613 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
614
615
616
617
618
619 #endif // SOULNG_PARSER_DEBUG_SUPPORT
620 if (!match.hit)
621 {
622 match.value = nullptr;
623 }
624 return match;
625 }
626
627 soulng::parser::Match ClassParser::BaseClassOrInterface(CmajorLexer& lexer, boost::uuids::uuid* moduleId, ParsingContext* ctx)
628 {
629 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
630
631
632
633
634
635
636
637 #endif // SOULNG_PARSER_DEBUG_SUPPORT
638 std::unique_ptr<TemplateIdNode> templateId;
639 std::unique_ptr<IdentifierNode> qid;
640 soulng::parser::Match match(false);
641 soulng::parser::Match* parentMatch0 = &match;
642 {
643 int64_t save = lexer.GetPos();
644 soulng::parser::Match match(false);
645 soulng::parser::Match* parentMatch1 = &match;
646 {
647 int64_t pos = lexer.GetPos();
648 soulng::parser::Match match = TemplateParser::TemplateId(lexer, moduleId, ctx);
649 templateId.reset(static_cast<TemplateIdNode*>(match.value));
650 if (match.hit)
651 {
652 {
653 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
654
655 #endif // SOULNG_PARSER_DEBUG_SUPPORT
656 return soulng::parser::Match(true, templateId.release());
657 }
658 }
659 *parentMatch1 = match;
660 }
661 *parentMatch0 = match;
662 if (!match.hit)
663 {
664 soulng::parser::Match match(false);
665 soulng::parser::Match* parentMatch2 = &match;
666 lexer.SetPos(save);
667 {
668 soulng::parser::Match match(false);
669 soulng::parser::Match* parentMatch3 = &match;
670 {
671 int64_t pos = lexer.GetPos();
672 soulng::parser::Match match = IdentifierParser::QualifiedId(lexer, moduleId);
673 qid.reset(static_cast<IdentifierNode*>(match.value));
674 if (match.hit)
675 {
676 {
677 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
678
679 #endif // SOULNG_PARSER_DEBUG_SUPPORT
680 return soulng::parser::Match(true, qid.release());
681 }
682 }
683 *parentMatch3 = match;
684 }
685 *parentMatch2 = match;
686 }
687 *parentMatch0 = match;
688 }
689 }
690 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
691
692
693
694
695
696 #endif // SOULNG_PARSER_DEBUG_SUPPORT
697 if (!match.hit)
698 {
699 match.value = nullptr;
700 }
701 return match;
702 }
703
704 soulng::parser::Match ClassParser::ClassContent(CmajorLexer& lexer, boost::uuids::uuid* moduleId, ParsingContext* ctx, sngcm::ast::ClassNode* classNode)
705 {
706 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
707
708
709
710
711
712
713
714 #endif // SOULNG_PARSER_DEBUG_SUPPORT
715 std::unique_ptr<Node> classMember;
716 soulng::parser::Match match(true);
717 soulng::parser::Match* parentMatch0 = &match;
718 {
719 while (true)
720 {
721 int64_t save = lexer.GetPos();
722 {
723 soulng::parser::Match match(false);
724 soulng::parser::Match* parentMatch1 = &match;
725 {
726 soulng::parser::Match match(false);
727 soulng::parser::Match* parentMatch2 = &match;
728 {
729 int64_t pos = lexer.GetPos();
730 soulng::parser::Match match = ClassParser::ClassMember(lexer, moduleId, ctx, classNode);
731 classMember.reset(static_cast<Node*>(match.value));
732 if (match.hit)
733 {
734 classNode->AddMember(classMember.release());
735 }
736 *parentMatch2 = match;
737 }
738 *parentMatch1 = match;
739 }
740 if (match.hit)
741 {
742 *parentMatch0 = match;
743 }
744 else
745 {
746 lexer.SetPos(save);
747 break;
748 }
749 }
750 }
751 }
752 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
753
754
755
756
757
758 #endif // SOULNG_PARSER_DEBUG_SUPPORT
759 if (!match.hit)
760 {
761 match.value = nullptr;
762 }
763 return match;
764 }
765
766 soulng::parser::Match ClassParser::ClassMember(CmajorLexer& lexer, boost::uuids::uuid* moduleId, ParsingContext* ctx, sngcm::ast::ClassNode* classNode)
767 {
768 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
769
770
771
772
773
774
775
776 #endif // SOULNG_PARSER_DEBUG_SUPPORT
777 std::unique_ptr<StaticConstructorNode> staticConstructor;
778 std::unique_ptr<Node> constructor;
779 std::unique_ptr<Node> destructor;
780 std::unique_ptr<Node> memberFunction;
781 std::unique_ptr<Node> conversionFunction;
782 std::unique_ptr<MemberVariableNode> memberVariable;
783 std::unique_ptr<TypedefNode> typedefinition;
784 std::unique_ptr<ClassNode> cls;
785 std::unique_ptr<EnumTypeNode> enumType;
786 std::unique_ptr<ConstantNode> constant;
787 std::unique_ptr<DelegateNode> delegate;
788 std::unique_ptr<ClassDelegateNode> classDelegate;
789 soulng::parser::Match match(false);
790 soulng::parser::Match* parentMatch0 = &match;
791 {
792 int64_t save = lexer.GetPos();
793 soulng::parser::Match match(false);
794 soulng::parser::Match* parentMatch1 = &match;
795 {
796 int64_t save = lexer.GetPos();
797 soulng::parser::Match match(false);
798 soulng::parser::Match* parentMatch2 = &match;
799 {
800 int64_t save = lexer.GetPos();
801 soulng::parser::Match match(false);
802 soulng::parser::Match* parentMatch3 = &match;
803 {
804 int64_t save = lexer.GetPos();
805 soulng::parser::Match match(false);
806 soulng::parser::Match* parentMatch4 = &match;
807 {
808 int64_t save = lexer.GetPos();
809 soulng::parser::Match match(false);
810 soulng::parser::Match* parentMatch5 = &match;
811 {
812 int64_t save = lexer.GetPos();
813 soulng::parser::Match match(false);
814 soulng::parser::Match* parentMatch6 = &match;
815 {
816 int64_t save = lexer.GetPos();
817 soulng::parser::Match match(false);
818 soulng::parser::Match* parentMatch7 = &match;
819 {
820 int64_t save = lexer.GetPos();
821 soulng::parser::Match match(false);
822 soulng::parser::Match* parentMatch8 = &match;
823 {
824 int64_t save = lexer.GetPos();
825 soulng::parser::Match match(false);
826 soulng::parser::Match* parentMatch9 = &match;
827 {
828 int64_t save = lexer.GetPos();
829 soulng::parser::Match match(false);
830 soulng::parser::Match* parentMatch10 = &match;
831 {
832 int64_t save = lexer.GetPos();
833 soulng::parser::Match match(false);
834 soulng::parser::Match* parentMatch11 = &match;
835 {
836 int64_t pos = lexer.GetPos();
837 soulng::parser::Match match = ClassParser::StaticConstructor(lexer, moduleId, ctx, classNode);
838 staticConstructor.reset(static_cast<StaticConstructorNode*>(match.value));
839 if (match.hit)
840 {
841 {
842 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
843
844 #endif // SOULNG_PARSER_DEBUG_SUPPORT
845 return soulng::parser::Match(true, staticConstructor.release());
846 }
847 }
848 *parentMatch11 = match;
849 }
850 *parentMatch10 = match;
851 if (!match.hit)
852 {
853 soulng::parser::Match match(false);
854 soulng::parser::Match* parentMatch12 = &match;
855 lexer.SetPos(save);
856 {
857 soulng::parser::Match match(false);
858 soulng::parser::Match* parentMatch13 = &match;
859 {
860 int64_t pos = lexer.GetPos();
861 soulng::parser::Match match = ClassParser::Constructor(lexer, moduleId, ctx, classNode);
862 constructor.reset(static_cast<Node*>(match.value));
863 if (match.hit)
864 {
865 {
866 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
867
868 #endif // SOULNG_PARSER_DEBUG_SUPPORT
869 return soulng::parser::Match(true, constructor.release());
870 }
871 }
872 *parentMatch13 = match;
873 }
874 *parentMatch12 = match;
875 }
876 *parentMatch10 = match;
877 }
878 }
879 *parentMatch9 = match;
880 if (!match.hit)
881 {
882 soulng::parser::Match match(false);
883 soulng::parser::Match* parentMatch14 = &match;
884 lexer.SetPos(save);
885 {
886 soulng::parser::Match match(false);
887 soulng::parser::Match* parentMatch15 = &match;
888 {
889 int64_t pos = lexer.GetPos();
890 soulng::parser::Match match = ClassParser::Destructor(lexer, moduleId, ctx, classNode);
891 destructor.reset(static_cast<Node*>(match.value));
892 if (match.hit)
893 {
894 {
895 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
896
897 #endif // SOULNG_PARSER_DEBUG_SUPPORT
898 return soulng::parser::Match(true, destructor.release());
899 }
900 }
901 *parentMatch15 = match;
902 }
903 *parentMatch14 = match;
904 }
905 *parentMatch9 = match;
906 }
907 }
908 *parentMatch8 = match;
909 if (!match.hit)
910 {
911 soulng::parser::Match match(false);
912 soulng::parser::Match* parentMatch16 = &match;
913 lexer.SetPos(save);
914 {
915 soulng::parser::Match match(false);
916 soulng::parser::Match* parentMatch17 = &match;
917 {
918 int64_t pos = lexer.GetPos();
919 soulng::parser::Match match = ClassParser::MemberFunction(lexer, moduleId, ctx);
920 memberFunction.reset(static_cast<Node*>(match.value));
921 if (match.hit)
922 {
923 {
924 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
925
926 #endif // SOULNG_PARSER_DEBUG_SUPPORT
927 return soulng::parser::Match(true, memberFunction.release());
928 }
929 }
930 *parentMatch17 = match;
931 }
932 *parentMatch16 = match;
933 }
934 *parentMatch8 = match;
935 }
936 }
937 *parentMatch7 = match;
938 if (!match.hit)
939 {
940 soulng::parser::Match match(false);
941 soulng::parser::Match* parentMatch18 = &match;
942 lexer.SetPos(save);
943 {
944 soulng::parser::Match match(false);
945 soulng::parser::Match* parentMatch19 = &match;
946 {
947 int64_t pos = lexer.GetPos();
948 soulng::parser::Match match = ClassParser::ConversionFunction(lexer, moduleId, ctx);
949 conversionFunction.reset(static_cast<Node*>(match.value));
950 if (match.hit)
951 {
952 {
953 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
954
955 #endif // SOULNG_PARSER_DEBUG_SUPPORT
956 return soulng::parser::Match(true, conversionFunction.release());
957 }
958 }
959 *parentMatch19 = match;
960 }
961 *parentMatch18 = match;
962 }
963 *parentMatch7 = match;
964 }
965 }
966 *parentMatch6 = match;
967 if (!match.hit)
968 {
969 soulng::parser::Match match(false);
970 soulng::parser::Match* parentMatch20 = &match;
971 lexer.SetPos(save);
972 {
973 soulng::parser::Match match(false);
974 soulng::parser::Match* parentMatch21 = &match;
975 {
976 int64_t pos = lexer.GetPos();
977 soulng::parser::Match match = ClassParser::MemberVariable(lexer, moduleId, ctx);
978 memberVariable.reset(static_cast<MemberVariableNode*>(match.value));
979 if (match.hit)
980 {
981 {
982 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
983
984 #endif // SOULNG_PARSER_DEBUG_SUPPORT
985 return soulng::parser::Match(true, memberVariable.release());
986 }
987 }
988 *parentMatch21 = match;
989 }
990 *parentMatch20 = match;
991 }
992 *parentMatch6 = match;
993 }
994 }
995 *parentMatch5 = match;
996 if (!match.hit)
997 {
998 soulng::parser::Match match(false);
999 soulng::parser::Match* parentMatch22 = &match;
1000 lexer.SetPos(save);
1001 {
1002 soulng::parser::Match match(false);
1003 soulng::parser::Match* parentMatch23 = &match;
1004 {
1005 int64_t pos = lexer.GetPos();
1006 soulng::parser::Match match = TypedefParser::Typedef(lexer, moduleId, ctx);
1007 typedefinition.reset(static_cast<TypedefNode*>(match.value));
1008 if (match.hit)
1009 {
1010 {
1011 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1012
1013 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1014 return soulng::parser::Match(true, typedefinition.release());
1015 }
1016 }
1017 *parentMatch23 = match;
1018 }
1019 *parentMatch22 = match;
1020 }
1021 *parentMatch5 = match;
1022 }
1023 }
1024 *parentMatch4 = match;
1025 if (!match.hit)
1026 {
1027 soulng::parser::Match match(false);
1028 soulng::parser::Match* parentMatch24 = &match;
1029 lexer.SetPos(save);
1030 {
1031 soulng::parser::Match match(false);
1032 soulng::parser::Match* parentMatch25 = &match;
1033 {
1034 int64_t pos = lexer.GetPos();
1035 soulng::parser::Match match = ClassParser::Class(lexer, moduleId, ctx);
1036 cls.reset(static_cast<ClassNode*>(match.value));
1037 if (match.hit)
1038 {
1039 {
1040 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1041
1042 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1043 return soulng::parser::Match(true, cls.release());
1044 }
1045 }
1046 *parentMatch25 = match;
1047 }
1048 *parentMatch24 = match;
1049 }
1050 *parentMatch4 = match;
1051 }
1052 }
1053 *parentMatch3 = match;
1054 if (!match.hit)
1055 {
1056 soulng::parser::Match match(false);
1057 soulng::parser::Match* parentMatch26 = &match;
1058 lexer.SetPos(save);
1059 {
1060 soulng::parser::Match match(false);
1061 soulng::parser::Match* parentMatch27 = &match;
1062 {
1063 int64_t pos = lexer.GetPos();
1064 soulng::parser::Match match = EnumerationParser::EnumType(lexer, moduleId, ctx);
1065 enumType.reset(static_cast<EnumTypeNode*>(match.value));
1066 if (match.hit)
1067 {
1068 {
1069 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1070
1071 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1072 return soulng::parser::Match(true, enumType.release());
1073 }
1074 }
1075 *parentMatch27 = match;
1076 }
1077 *parentMatch26 = match;
1078 }
1079 *parentMatch3 = match;
1080 }
1081 }
1082 *parentMatch2 = match;
1083 if (!match.hit)
1084 {
1085 soulng::parser::Match match(false);
1086 soulng::parser::Match* parentMatch28 = &match;
1087 lexer.SetPos(save);
1088 {
1089 soulng::parser::Match match(false);
1090 soulng::parser::Match* parentMatch29 = &match;
1091 {
1092 int64_t pos = lexer.GetPos();
1093 soulng::parser::Match match = ConstantParser::Constant(lexer, moduleId, ctx);
1094 constant.reset(static_cast<ConstantNode*>(match.value));
1095 if (match.hit)
1096 {
1097 {
1098 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1099
1100 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1101 return soulng::parser::Match(true, constant.release());
1102 }
1103 }
1104 *parentMatch29 = match;
1105 }
1106 *parentMatch28 = match;
1107 }
1108 *parentMatch2 = match;
1109 }
1110 }
1111 *parentMatch1 = match;
1112 if (!match.hit)
1113 {
1114 soulng::parser::Match match(false);
1115 soulng::parser::Match* parentMatch30 = &match;
1116 lexer.SetPos(save);
1117 {
1118 soulng::parser::Match match(false);
1119 soulng::parser::Match* parentMatch31 = &match;
1120 {
1121 int64_t pos = lexer.GetPos();
1122 soulng::parser::Match match = DelegateParser::Delegate(lexer, moduleId, ctx);
1123 delegate.reset(static_cast<DelegateNode*>(match.value));
1124 if (match.hit)
1125 {
1126 {
1127 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1128
1129 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1130 return soulng::parser::Match(true, delegate.release());
1131 }
1132 }
1133 *parentMatch31 = match;
1134 }
1135 *parentMatch30 = match;
1136 }
1137 *parentMatch1 = match;
1138 }
1139 }
1140 *parentMatch0 = match;
1141 if (!match.hit)
1142 {
1143 soulng::parser::Match match(false);
1144 soulng::parser::Match* parentMatch32 = &match;
1145 lexer.SetPos(save);
1146 {
1147 soulng::parser::Match match(false);
1148 soulng::parser::Match* parentMatch33 = &match;
1149 {
1150 int64_t pos = lexer.GetPos();
1151 soulng::parser::Match match = DelegateParser::ClassDelegate(lexer, moduleId, ctx);
1152 classDelegate.reset(static_cast<ClassDelegateNode*>(match.value));
1153 if (match.hit)
1154 {
1155 {
1156 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1157
1158 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1159 return soulng::parser::Match(true, classDelegate.release());
1160 }
1161 }
1162 *parentMatch33 = match;
1163 }
1164 *parentMatch32 = match;
1165 }
1166 *parentMatch0 = match;
1167 }
1168 }
1169 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1170
1171
1172
1173
1174
1175 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1176 if (!match.hit)
1177 {
1178 match.value = nullptr;
1179 }
1180 return match;
1181 }
1182
1183 soulng::parser::Match ClassParser::StaticConstructor(CmajorLexer& lexer, boost::uuids::uuid* moduleId, ParsingContext* ctx, sngcm::ast::ClassNode* classNode)
1184 {
1185 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1186
1187
1188
1189
1190
1191
1192
1193 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1194 std::unique_ptr<StaticConstructorNode> staticConstructor = std::unique_ptr<StaticConstructorNode>();
1195 Span s = Span();
1196 Span specifierSpan = Span();
1197 std::u32string className = std::u32string();
1198 std::unique_ptr<sngcm::ast::AttributesNode> attrs;
1199 std::unique_ptr<soulng::parser::soulng::parser::Value<sngcm::ast::Specifiers>>specifiers;
1200 std::unique_ptr<IdentifierNode> id;
1201 std::unique_ptr<InitializerNode> initializer;
1202 std::unique_ptr<WhereConstraintNode> constraint;
1203 std::unique_ptr<CompoundStatementNode> body;
1204 soulng::parser::Match match(false);
1205 soulng::parser::Match* parentMatch0 = &match;
1206 {
1207 int64_t pos = lexer.GetPos();
1208 soulng::parser::Match match(false);
1209 soulng::parser::Match* parentMatch1 = &match;
1210 {
1211 soulng::parser::Match match(false);
1212 soulng::parser::Match* parentMatch2 = &match;
1213 {
1214 soulng::parser::Match match(false);
1215 soulng::parser::Match* parentMatch3 = &match;
1216 {
1217 soulng::parser::Match match(false);
1218 soulng::parser::Match* parentMatch4 = &match;
1219 {
1220 soulng::parser::Match match(false);
1221 soulng::parser::Match* parentMatch5 = &match;
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 soulng::parser::Match* parentMatch8 = &match;
1231 {
1232 soulng::parser::Match match(false);
1233 soulng::parser::Match* parentMatch9 = &match;
1234 {
1235 soulng::parser::Match match(false);
1236 soulng::parser::Match* parentMatch10 = &match;
1237 {
1238 int64_t pos = lexer.GetPos();
1239 soulng::lexer::Span span = lexer.GetSpan();
1240 soulng::parser::Match match(true);
1241 if (match.hit)
1242 {
1243 s = span;
1244 }
1245 *parentMatch10 = match;
1246 }
1247 *parentMatch9 = match;
1248 }
1249 if (match.hit)
1250 {
1251 soulng::parser::Match match(false);
1252 soulng::parser::Match* parentMatch11 = &match;
1253 {
1254 soulng::parser::Match match(true);
1255 int64_t save = lexer.GetPos();
1256 soulng::parser::Match* parentMatch12 = &match;
1257 {
1258 soulng::parser::Match match = AttributeParser::Attributes(lexer, moduleId);
1259 attrs.reset(static_cast<sngcm::ast::AttributesNode*>(match.value));
1260 if (match.hit)
1261 {
1262 *parentMatch12 = match;
1263 }
1264 else
1265 {
1266 lexer.SetPos(save);
1267 }
1268 }
1269 *parentMatch11 = match;
1270 }
1271 *parentMatch9 = match;
1272 }
1273 *parentMatch8 = match;
1274 }
1275 if (match.hit)
1276 {
1277 soulng::parser::Match match(false);
1278 soulng::parser::Match* parentMatch13 = &match;
1279 {
1280 soulng::parser::Match match(false);
1281 soulng::parser::Match* parentMatch14 = &match;
1282 {
1283 int64_t pos = lexer.GetPos();
1284 soulng::lexer::Span span = lexer.GetSpan();
1285 soulng::parser::Match match = SpecifierParser::Specifiers(lexer);
1286 specifiers.reset(static_cast<soulng::parser::soulng::parser::Value<sngcm::ast::Specifiers>*>(match.value));
1287 if (match.hit)
1288 {
1289 specifierSpan = span;
1290 }
1291 *parentMatch14 = match;
1292 }
1293 *parentMatch13 = match;
1294 }
1295 *parentMatch8 = match;
1296 }
1297 *parentMatch7 = match;
1298 }
1299 if (match.hit)
1300 {
1301 soulng::parser::Match match(false);
1302 soulng::parser::Match* parentMatch15 = &match;
1303 {
1304 soulng::parser::Match match(false);
1305 soulng::parser::Match* parentMatch16 = &match;
1306 {
1307 int64_t pos = lexer.GetPos();
1308 soulng::lexer::Span span = lexer.GetSpan();
1309 soulng::parser::Match match = IdentifierParser::Identifier(lexer, moduleId);
1310 id.reset(static_cast<IdentifierNode*>(match.value));
1311 if (match.hit)
1312 {
1313 className = lexer.GetMatch(span);
1314 }
1315 *parentMatch16 = match;
1316 }
1317 *parentMatch15 = match;
1318 }
1319 *parentMatch7 = match;
1320 }
1321 *parentMatch6 = match;
1322 }
1323 if (match.hit)
1324 {
1325 soulng::parser::Match match(false);
1326 soulng::parser::Match* parentMatch17 = &match;
1327 {
1328 soulng::parser::Match match(false);
1329 if (*lexer == LPAREN)
1330 {
1331 ++lexer;
1332 match.hit = true;
1333 }
1334 *parentMatch17 = match;
1335 }
1336 *parentMatch6 = match;
1337 }
1338 *parentMatch5 = match;
1339 }
1340 if (match.hit)
1341 {
1342 soulng::parser::Match match(false);
1343 soulng::parser::Match* parentMatch18 = &match;
1344 {
1345 soulng::parser::Match match(false);
1346 soulng::parser::Match* parentMatch19 = &match;
1347 {
1348 int64_t pos = lexer.GetPos();
1349 soulng::lexer::Span span = lexer.GetSpan();
1350 bool pass = true;
1351 soulng::parser::Match match(false);
1352 if (*lexer == RPAREN)
1353 {
1354 ++lexer;
1355 match.hit = true;
1356 }
1357 if (match.hit)
1358 {
1359 s.end = span.end;
1360 if (className != classNode->Id()->Str()) pass = false;
1361 else if (!StaticConstructorSpecifiers(specifiers->value)) pass = false;
1362 else
1363 {
1364 staticConstructor.reset(new StaticConstructorNode(s, *moduleId, specifiers->value, attrs.release()));
1365 staticConstructor->SetClassId(id.release());
1366 staticConstructor->SetSpecifierSpan(specifierSpan);
1367 }
1368 }
1369 if (match.hit && !pass)
1370 {
1371 match = soulng::parser::Match(false);
1372 }
1373 *parentMatch19 = match;
1374 }
1375 *parentMatch18 = match;
1376 }
1377 *parentMatch5 = match;
1378 }
1379 *parentMatch4 = match;
1380 }
1381 if (match.hit)
1382 {
1383 soulng::parser::Match match(false);
1384 soulng::parser::Match* parentMatch20 = &match;
1385 {
1386 soulng::parser::Match match(true);
1387 int64_t save = lexer.GetPos();
1388 soulng::parser::Match* parentMatch21 = &match;
1389 {
1390 soulng::parser::Match match(false);
1391 soulng::parser::Match* parentMatch22 = &match;
1392 {
1393 soulng::parser::Match match(false);
1394 soulng::parser::Match* parentMatch23 = &match;
1395 {
1396 soulng::parser::Match match(false);
1397 if (*lexer == COLON)
1398 {
1399 ++lexer;
1400 match.hit = true;
1401 }
1402 *parentMatch23 = match;
1403 }
1404 if (match.hit)
1405 {
1406 soulng::parser::Match match(false);
1407 soulng::parser::Match* parentMatch24 = &match;
1408 {
1409 soulng::parser::Match match(false);
1410 soulng::parser::Match* parentMatch25 = &match;
1411 {
1412 soulng::parser::Match match(false);
1413 soulng::parser::Match* parentMatch26 = &match;
1414 {
1415 soulng::parser::Match match(false);
1416 soulng::parser::Match* parentMatch27 = &match;
1417 {
1418 int64_t pos = lexer.GetPos();
1419 soulng::parser::Match match = ClassParser::Initializer(lexer, moduleId, ctx);
1420 initializer.reset(static_cast<InitializerNode*>(match.value));
1421 if (match.hit)
1422 {
1423 staticConstructor->AddInitializer(initializer.release());
1424 }
1425 *parentMatch27 = match;
1426 }
1427 *parentMatch26 = match;
1428 }
1429 if (match.hit)
1430 {
1431 soulng::parser::Match match(false);
1432 soulng::parser::Match* parentMatch28 = &match;
1433 {
1434 soulng::parser::Match match(true);
1435 soulng::parser::Match* parentMatch29 = &match;
1436 {
1437 while (true)
1438 {
1439 int64_t save = lexer.GetPos();
1440 {
1441 soulng::parser::Match match(false);
1442 soulng::parser::Match* parentMatch30 = &match;
1443 {
1444 soulng::parser::Match match(false);
1445 if (*lexer == COMMA)
1446 {
1447 ++lexer;
1448 match.hit = true;
1449 }
1450 *parentMatch30 = match;
1451 }
1452 if (match.hit)
1453 {
1454 soulng::parser::Match match(false);
1455 soulng::parser::Match* parentMatch31 = &match;
1456 {
1457 soulng::parser::Match match(false);
1458 soulng::parser::Match* parentMatch32 = &match;
1459 {
1460 int64_t pos = lexer.GetPos();
1461 soulng::parser::Match match = ClassParser::Initializer(lexer, moduleId, ctx);
1462 initializer.reset(static_cast<InitializerNode*>(match.value));
1463 if (match.hit)
1464 {
1465 staticConstructor->AddInitializer(initializer.release());
1466 }
1467 *parentMatch32 = match;
1468 }
1469 *parentMatch31 = match;
1470 }
1471 *parentMatch30 = match;
1472 }
1473 if (match.hit)
1474 {
1475 *parentMatch29 = match;
1476 }
1477 else
1478 {
1479 lexer.SetPos(save);
1480 break;
1481 }
1482 }
1483 }
1484 }
1485 *parentMatch28 = match;
1486 }
1487 *parentMatch26 = match;
1488 }
1489 *parentMatch25 = match;
1490 }
1491 *parentMatch24 = match;
1492 }
1493 *parentMatch23 = match;
1494 }
1495 *parentMatch22 = match;
1496 }
1497 if (match.hit)
1498 {
1499 *parentMatch21 = match;
1500 }
1501 else
1502 {
1503 lexer.SetPos(save);
1504 }
1505 }
1506 *parentMatch20 = match;
1507 }
1508 *parentMatch4 = match;
1509 }
1510 *parentMatch3 = match;
1511 }
1512 if (match.hit)
1513 {
1514 soulng::parser::Match match(false);
1515 soulng::parser::Match* parentMatch33 = &match;
1516 {
1517 soulng::parser::Match match(true);
1518 int64_t save = lexer.GetPos();
1519 soulng::parser::Match* parentMatch34 = &match;
1520 {
1521 soulng::parser::Match match(false);
1522 soulng::parser::Match* parentMatch35 = &match;
1523 {
1524 soulng::parser::Match match(false);
1525 soulng::parser::Match* parentMatch36 = &match;
1526 {
1527 int64_t pos = lexer.GetPos();
1528 soulng::parser::Match match = ConceptParser::WhereConstraint(lexer, moduleId, ctx);
1529 constraint.reset(static_cast<WhereConstraintNode*>(match.value));
1530 if (match.hit)
1531 {
1532 staticConstructor->SetConstraint(constraint.release());
1533 }
1534 *parentMatch36 = match;
1535 }
1536 *parentMatch35 = match;
1537 }
1538 if (match.hit)
1539 {
1540 *parentMatch34 = match;
1541 }
1542 else
1543 {
1544 lexer.SetPos(save);
1545 }
1546 }
1547 *parentMatch33 = match;
1548 }
1549 *parentMatch3 = match;
1550 }
1551 *parentMatch2 = match;
1552 }
1553 if (match.hit)
1554 {
1555 soulng::parser::Match match(false);
1556 soulng::parser::Match* parentMatch37 = &match;
1557 {
1558 soulng::parser::Match match(false);
1559 soulng::parser::Match* parentMatch38 = &match;
1560 {
1561 soulng::parser::Match match(false);
1562 soulng::parser::Match* parentMatch39 = &match;
1563 {
1564 int64_t save = lexer.GetPos();
1565 soulng::parser::Match match(false);
1566 soulng::parser::Match* parentMatch40 = &match;
1567 {
1568 int64_t pos = lexer.GetPos();
1569 soulng::parser::Match match = StatementParser::CompoundStatement(lexer, moduleId, ctx);
1570 body.reset(static_cast<CompoundStatementNode*>(match.value));
1571 if (match.hit)
1572 {
1573 staticConstructor->SetBody(body.release());
1574 }
1575 *parentMatch40 = match;
1576 }
1577 *parentMatch39 = match;
1578 if (!match.hit)
1579 {
1580 soulng::parser::Match match(false);
1581 soulng::parser::Match* parentMatch41 = &match;
1582 lexer.SetPos(save);
1583 {
1584 soulng::parser::Match match(false);
1585 if (*lexer == SEMICOLON)
1586 {
1587 ++lexer;
1588 match.hit = true;
1589 }
1590 *parentMatch41 = match;
1591 }
1592 *parentMatch39 = match;
1593 }
1594 }
1595 *parentMatch38 = match;
1596 }
1597 *parentMatch37 = match;
1598 }
1599 *parentMatch2 = match;
1600 }
1601 *parentMatch1 = match;
1602 }
1603 if (match.hit)
1604 {
1605 {
1606 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1607
1608 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1609 return soulng::parser::Match(true, staticConstructor.release());
1610 }
1611 }
1612 *parentMatch0 = match;
1613 }
1614 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1615
1616
1617
1618
1619
1620 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1621 if (!match.hit)
1622 {
1623 match.value = nullptr;
1624 }
1625 return match;
1626 }
1627
1628 soulng::parser::Match ClassParser::Constructor(CmajorLexer& lexer, boost::uuids::uuid* moduleId, ParsingContext* ctx, sngcm::ast::ClassNode* classNode)
1629 {
1630 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1631
1632
1633
1634
1635
1636
1637
1638 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1639 std::unique_ptr<ConstructorNode> ctor = std::unique_ptr<ConstructorNode>();
1640 Span s = Span();
1641 Span specifierSpan = Span();
1642 std::unique_ptr<sngcm::ast::AttributesNode> attrs;
1643 std::unique_ptr<soulng::parser::soulng::parser::Value<sngcm::ast::Specifiers>>specifiers;
1644 std::unique_ptr<IdentifierNode> id;
1645 std::unique_ptr<InitializerNode> initializer;
1646 std::unique_ptr<WhereConstraintNode> constraint;
1647 std::unique_ptr<CompoundStatementNode> body;
1648 soulng::parser::Match match(false);
1649 soulng::parser::Match* parentMatch0 = &match;
1650 {
1651 int64_t pos = lexer.GetPos();
1652 soulng::parser::Match match(false);
1653 soulng::parser::Match* parentMatch1 = &match;
1654 {
1655 soulng::parser::Match match(false);
1656 soulng::parser::Match* parentMatch2 = &match;
1657 {
1658 soulng::parser::Match match(false);
1659 soulng::parser::Match* parentMatch3 = &match;
1660 {
1661 soulng::parser::Match match(false);
1662 soulng::parser::Match* parentMatch4 = &match;
1663 {
1664 soulng::parser::Match match(false);
1665 soulng::parser::Match* parentMatch5 = &match;
1666 {
1667 soulng::parser::Match match(false);
1668 soulng::parser::Match* parentMatch6 = &match;
1669 {
1670 soulng::parser::Match match(false);
1671 soulng::parser::Match* parentMatch7 = &match;
1672 {
1673 soulng::parser::Match match(false);
1674 soulng::parser::Match* parentMatch8 = &match;
1675 {
1676 soulng::parser::Match match(false);
1677 soulng::parser::Match* parentMatch9 = &match;
1678 {
1679 int64_t pos = lexer.GetPos();
1680 soulng::lexer::Span span = lexer.GetSpan();
1681 soulng::parser::Match match(true);
1682 if (match.hit)
1683 {
1684 s = span;
1685 }
1686 *parentMatch9 = match;
1687 }
1688 *parentMatch8 = match;
1689 }
1690 if (match.hit)
1691 {
1692 soulng::parser::Match match(false);
1693 soulng::parser::Match* parentMatch10 = &match;
1694 {
1695 soulng::parser::Match match(true);
1696 int64_t save = lexer.GetPos();
1697 soulng::parser::Match* parentMatch11 = &match;
1698 {
1699 soulng::parser::Match match = AttributeParser::Attributes(lexer, moduleId);
1700 attrs.reset(static_cast<sngcm::ast::AttributesNode*>(match.value));
1701 if (match.hit)
1702 {
1703 *parentMatch11 = match;
1704 }
1705 else
1706 {
1707 lexer.SetPos(save);
1708 }
1709 }
1710 *parentMatch10 = match;
1711 }
1712 *parentMatch8 = match;
1713 }
1714 *parentMatch7 = match;
1715 }
1716 if (match.hit)
1717 {
1718 soulng::parser::Match match(false);
1719 soulng::parser::Match* parentMatch12 = &match;
1720 {
1721 soulng::parser::Match match(false);
1722 soulng::parser::Match* parentMatch13 = &match;
1723 {
1724 int64_t pos = lexer.GetPos();
1725 soulng::lexer::Span span = lexer.GetSpan();
1726 soulng::parser::Match match = SpecifierParser::Specifiers(lexer);
1727 specifiers.reset(static_cast<soulng::parser::soulng::parser::Value<sngcm::ast::Specifiers>*>(match.value));
1728 if (match.hit)
1729 {
1730 specifierSpan = span;
1731 }
1732 *parentMatch13 = match;
1733 }
1734 *parentMatch12 = match;
1735 }
1736 *parentMatch7 = match;
1737 }
1738 *parentMatch6 = match;
1739 }
1740 if (match.hit)
1741 {
1742 soulng::parser::Match match(false);
1743 soulng::parser::Match* parentMatch14 = &match;
1744 {
1745 soulng::parser::Match match(false);
1746 soulng::parser::Match* parentMatch15 = &match;
1747 {
1748 int64_t pos = lexer.GetPos();
1749 soulng::lexer::Span span = lexer.GetSpan();
1750 bool pass = true;
1751 soulng::parser::Match match = IdentifierParser::Identifier(lexer, moduleId);
1752 id.reset(static_cast<IdentifierNode*>(match.value));
1753 if (match.hit)
1754 {
1755 std::u32string className = lexer.GetMatch(span);
1756 s.end = span.end;
1757 if (className != classNode->Id()->Str()) pass = false;
1758 else
1759 {
1760 ctor.reset(new ConstructorNode(s, *moduleId, specifiers->value, attrs.release()));
1761 ctor->SetClassId(id.release());
1762 ctor->SetSpecifierSpan(specifierSpan);
1763 }
1764 }
1765 if (match.hit && !pass)
1766 {
1767 match = soulng::parser::Match(false);
1768 }
1769 *parentMatch15 = match;
1770 }
1771 *parentMatch14 = match;
1772 }
1773 *parentMatch6 = match;
1774 }
1775 *parentMatch5 = match;
1776 }
1777 if (match.hit)
1778 {
1779 soulng::parser::Match match(false);
1780 soulng::parser::Match* parentMatch16 = &match;
1781 {
1782 soulng::parser::Match match = ParameterParser::ParameterList(lexer, moduleId, ctx, ctor.get());
1783 *parentMatch16 = match;
1784 }
1785 *parentMatch5 = match;
1786 }
1787 *parentMatch4 = match;
1788 }
1789 if (match.hit)
1790 {
1791 soulng::parser::Match match(false);
1792 soulng::parser::Match* parentMatch17 = &match;
1793 {
1794 soulng::parser::Match match(true);
1795 int64_t save = lexer.GetPos();
1796 soulng::parser::Match* parentMatch18 = &match;
1797 {
1798 soulng::parser::Match match(false);
1799 soulng::parser::Match* parentMatch19 = &match;
1800 {
1801 soulng::parser::Match match(false);
1802 soulng::parser::Match* parentMatch20 = &match;
1803 {
1804 soulng::parser::Match match(false);
1805 if (*lexer == COLON)
1806 {
1807 ++lexer;
1808 match.hit = true;
1809 }
1810 *parentMatch20 = match;
1811 }
1812 if (match.hit)
1813 {
1814 soulng::parser::Match match(false);
1815 soulng::parser::Match* parentMatch21 = &match;
1816 {
1817 soulng::parser::Match match(false);
1818 soulng::parser::Match* parentMatch22 = &match;
1819 {
1820 soulng::parser::Match match(false);
1821 soulng::parser::Match* parentMatch23 = &match;
1822 {
1823 soulng::parser::Match match(false);
1824 soulng::parser::Match* parentMatch24 = &match;
1825 {
1826 int64_t pos = lexer.GetPos();
1827 soulng::parser::Match match = ClassParser::Initializer(lexer, moduleId, ctx);
1828 initializer.reset(static_cast<InitializerNode*>(match.value));
1829 if (match.hit)
1830 {
1831 ctor->AddInitializer(initializer.release());
1832 }
1833 *parentMatch24 = match;
1834 }
1835 *parentMatch23 = match;
1836 }
1837 if (match.hit)
1838 {
1839 soulng::parser::Match match(false);
1840 soulng::parser::Match* parentMatch25 = &match;
1841 {
1842 soulng::parser::Match match(true);
1843 soulng::parser::Match* parentMatch26 = &match;
1844 {
1845 while (true)
1846 {
1847 int64_t save = lexer.GetPos();
1848 {
1849 soulng::parser::Match match(false);
1850 soulng::parser::Match* parentMatch27 = &match;
1851 {
1852 soulng::parser::Match match(false);
1853 if (*lexer == COMMA)
1854 {
1855 ++lexer;
1856 match.hit = true;
1857 }
1858 *parentMatch27 = match;
1859 }
1860 if (match.hit)
1861 {
1862 soulng::parser::Match match(false);
1863 soulng::parser::Match* parentMatch28 = &match;
1864 {
1865 soulng::parser::Match match(false);
1866 soulng::parser::Match* parentMatch29 = &match;
1867 {
1868 int64_t pos = lexer.GetPos();
1869 soulng::parser::Match match = ClassParser::Initializer(lexer, moduleId, ctx);
1870 initializer.reset(static_cast<InitializerNode*>(match.value));
1871 if (match.hit)
1872 {
1873 ctor->AddInitializer(initializer.release());
1874 }
1875 *parentMatch29 = match;
1876 }
1877 *parentMatch28 = match;
1878 }
1879 *parentMatch27 = match;
1880 }
1881 if (match.hit)
1882 {
1883 *parentMatch26 = match;
1884 }
1885 else
1886 {
1887 lexer.SetPos(save);
1888 break;
1889 }
1890 }
1891 }
1892 }
1893 *parentMatch25 = match;
1894 }
1895 *parentMatch23 = match;
1896 }
1897 *parentMatch22 = match;
1898 }
1899 *parentMatch21 = match;
1900 }
1901 *parentMatch20 = match;
1902 }
1903 *parentMatch19 = match;
1904 }
1905 if (match.hit)
1906 {
1907 *parentMatch18 = match;
1908 }
1909 else
1910 {
1911 lexer.SetPos(save);
1912 }
1913 }
1914 *parentMatch17 = match;
1915 }
1916 *parentMatch4 = match;
1917 }
1918 *parentMatch3 = match;
1919 }
1920 if (match.hit)
1921 {
1922 soulng::parser::Match match(false);
1923 soulng::parser::Match* parentMatch30 = &match;
1924 {
1925 soulng::parser::Match match(true);
1926 int64_t save = lexer.GetPos();
1927 soulng::parser::Match* parentMatch31 = &match;
1928 {
1929 soulng::parser::Match match(false);
1930 soulng::parser::Match* parentMatch32 = &match;
1931 {
1932 soulng::parser::Match match(false);
1933 soulng::parser::Match* parentMatch33 = &match;
1934 {
1935 int64_t pos = lexer.GetPos();
1936 soulng::parser::Match match = ConceptParser::WhereConstraint(lexer, moduleId, ctx);
1937 constraint.reset(static_cast<WhereConstraintNode*>(match.value));
1938 if (match.hit)
1939 {
1940 ctor->SetConstraint(constraint.release());
1941 }
1942 *parentMatch33 = match;
1943 }
1944 *parentMatch32 = match;
1945 }
1946 if (match.hit)
1947 {
1948 *parentMatch31 = match;
1949 }
1950 else
1951 {
1952 lexer.SetPos(save);
1953 }
1954 }
1955 *parentMatch30 = match;
1956 }
1957 *parentMatch3 = match;
1958 }
1959 *parentMatch2 = match;
1960 }
1961 if (match.hit)
1962 {
1963 soulng::parser::Match match(false);
1964 soulng::parser::Match* parentMatch34 = &match;
1965 {
1966 soulng::parser::Match match(false);
1967 soulng::parser::Match* parentMatch35 = &match;
1968 {
1969 soulng::parser::Match match(false);
1970 soulng::parser::Match* parentMatch36 = &match;
1971 {
1972 int64_t save = lexer.GetPos();
1973 soulng::parser::Match match(false);
1974 soulng::parser::Match* parentMatch37 = &match;
1975 {
1976 int64_t pos = lexer.GetPos();
1977 soulng::parser::Match match = StatementParser::CompoundStatement(lexer, moduleId, ctx);
1978 body.reset(static_cast<CompoundStatementNode*>(match.value));
1979 if (match.hit)
1980 {
1981 ctor->SetBody(body.release());
1982 }
1983 *parentMatch37 = match;
1984 }
1985 *parentMatch36 = match;
1986 if (!match.hit)
1987 {
1988 soulng::parser::Match match(false);
1989 soulng::parser::Match* parentMatch38 = &match;
1990 lexer.SetPos(save);
1991 {
1992 soulng::parser::Match match(false);
1993 if (*lexer == SEMICOLON)
1994 {
1995 ++lexer;
1996 match.hit = true;
1997 }
1998 *parentMatch38 = match;
1999 }
2000 *parentMatch36 = match;
2001 }
2002 }
2003 *parentMatch35 = match;
2004 }
2005 *parentMatch34 = match;
2006 }
2007 *parentMatch2 = match;
2008 }
2009 *parentMatch1 = match;
2010 }
2011 if (match.hit)
2012 {
2013 {
2014 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2015
2016 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2017 return soulng::parser::Match(true, ctor.release());
2018 }
2019 }
2020 *parentMatch0 = match;
2021 }
2022 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2023
2024
2025
2026
2027
2028 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2029 if (!match.hit)
2030 {
2031 match.value = nullptr;
2032 }
2033 return match;
2034 }
2035
2036 soulng::parser::Match ClassParser::Destructor(CmajorLexer& lexer, boost::uuids::uuid* moduleId, ParsingContext* ctx, sngcm::ast::ClassNode* classNode)
2037 {
2038 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2039
2040
2041
2042
2043
2044
2045
2046 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2047 std::unique_ptr<DestructorNode> dtor = std::unique_ptr<DestructorNode>();
2048 Span s = Span();
2049 Span specifierSpan = Span();
2050 std::u32string className = std::u32string();
2051 std::unique_ptr<sngcm::ast::AttributesNode> attrs;
2052 std::unique_ptr<soulng::parser::soulng::parser::Value<sngcm::ast::Specifiers>>specifiers;
2053 std::unique_ptr<IdentifierNode> id;
2054 std::unique_ptr<WhereConstraintNode> contraint;
2055 std::unique_ptr<CompoundStatementNode> body;
2056 soulng::parser::Match match(false);
2057 soulng::parser::Match* parentMatch0 = &match;
2058 {
2059 int64_t pos = lexer.GetPos();
2060 soulng::parser::Match match(false);
2061 soulng::parser::Match* parentMatch1 = &match;
2062 {
2063 soulng::parser::Match match(false);
2064 soulng::parser::Match* parentMatch2 = &match;
2065 {
2066 soulng::parser::Match match(false);
2067 soulng::parser::Match* parentMatch3 = &match;
2068 {
2069 soulng::parser::Match match(false);
2070 soulng::parser::Match* parentMatch4 = &match;
2071 {
2072 soulng::parser::Match match(false);
2073 soulng::parser::Match* parentMatch5 = &match;
2074 {
2075 soulng::parser::Match match(false);
2076 soulng::parser::Match* parentMatch6 = &match;
2077 {
2078 soulng::parser::Match match(false);
2079 soulng::parser::Match* parentMatch7 = &match;
2080 {
2081 soulng::parser::Match match(false);
2082 soulng::parser::Match* parentMatch8 = &match;
2083 {
2084 soulng::parser::Match match(false);
2085 soulng::parser::Match* parentMatch9 = &match;
2086 {
2087 soulng::parser::Match match(false);
2088 soulng::parser::Match* parentMatch10 = &match;
2089 {
2090 int64_t pos = lexer.GetPos();
2091 soulng::lexer::Span span = lexer.GetSpan();
2092 soulng::parser::Match match(true);
2093 if (match.hit)
2094 {
2095 s = span;
2096 }
2097 *parentMatch10 = match;
2098 }
2099 *parentMatch9 = match;
2100 }
2101 if (match.hit)
2102 {
2103 soulng::parser::Match match(false);
2104 soulng::parser::Match* parentMatch11 = &match;
2105 {
2106 soulng::parser::Match match(true);
2107 int64_t save = lexer.GetPos();
2108 soulng::parser::Match* parentMatch12 = &match;
2109 {
2110 soulng::parser::Match match = AttributeParser::Attributes(lexer, moduleId);
2111 attrs.reset(static_cast<sngcm::ast::AttributesNode*>(match.value));
2112 if (match.hit)
2113 {
2114 *parentMatch12 = match;
2115 }
2116 else
2117 {
2118 lexer.SetPos(save);
2119 }
2120 }
2121 *parentMatch11 = match;
2122 }
2123 *parentMatch9 = match;
2124 }
2125 *parentMatch8 = match;
2126 }
2127 if (match.hit)
2128 {
2129 soulng::parser::Match match(false);
2130 soulng::parser::Match* parentMatch13 = &match;
2131 {
2132 soulng::parser::Match match(false);
2133 soulng::parser::Match* parentMatch14 = &match;
2134 {
2135 int64_t pos = lexer.GetPos();
2136 soulng::lexer::Span span = lexer.GetSpan();
2137 soulng::parser::Match match = SpecifierParser::Specifiers(lexer);
2138 specifiers.reset(static_cast<soulng::parser::soulng::parser::Value<sngcm::ast::Specifiers>*>(match.value));
2139 if (match.hit)
2140 {
2141 specifierSpan = span;
2142 }
2143 *parentMatch14 = match;
2144 }
2145 *parentMatch13 = match;
2146 }
2147 *parentMatch8 = match;
2148 }
2149 *parentMatch7 = match;
2150 }
2151 if (match.hit)
2152 {
2153 soulng::parser::Match match(false);
2154 soulng::parser::Match* parentMatch15 = &match;
2155 {
2156 soulng::parser::Match match(false);
2157 if (*lexer == CPL)
2158 {
2159 ++lexer;
2160 match.hit = true;
2161 }
2162 *parentMatch15 = match;
2163 }
2164 *parentMatch7 = match;
2165 }
2166 *parentMatch6 = match;
2167 }
2168 if (match.hit)
2169 {
2170 soulng::parser::Match match(false);
2171 soulng::parser::Match* parentMatch16 = &match;
2172 {
2173 soulng::parser::Match match(false);
2174 soulng::parser::Match* parentMatch17 = &match;
2175 {
2176 int64_t pos = lexer.GetPos();
2177 soulng::lexer::Span span = lexer.GetSpan();
2178 soulng::parser::Match match = IdentifierParser::Identifier(lexer, moduleId);
2179 id.reset(static_cast<IdentifierNode*>(match.value));
2180 if (match.hit)
2181 {
2182 className = lexer.GetMatch(span);
2183 }
2184 *parentMatch17 = match;
2185 }
2186 *parentMatch16 = match;
2187 }
2188 *parentMatch6 = match;
2189 }
2190 *parentMatch5 = match;
2191 }
2192 if (match.hit)
2193 {
2194 soulng::parser::Match match(false);
2195 soulng::parser::Match* parentMatch18 = &match;
2196 {
2197 soulng::parser::Match match(true);
2198 soulng::parser::Match* parentMatch19 = &match;
2199 {
2200 soulng::lexer::Span span = lexer.GetSpan();
2201 soulng::parser::Match match(false);
2202 if (*lexer == LPAREN)
2203 {
2204 ++lexer;
2205 match.hit = true;
2206 }
2207 if (match.hit)
2208 {
2209 *parentMatch19 = match;
2210 }
2211 else
2212 {
2213 lexer.ThrowExpectationFailure(span, ToUtf32(GetTokenInfo(LPAREN)));
2214 }
2215 }
2216 *parentMatch18 = match;
2217 }
2218 *parentMatch5 = match;
2219 }
2220 *parentMatch4 = match;
2221 }
2222 if (match.hit)
2223 {
2224 soulng::parser::Match match(false);
2225 soulng::parser::Match* parentMatch20 = &match;
2226 {
2227 soulng::parser::Match match(false);
2228 soulng::parser::Match* parentMatch21 = &match;
2229 {
2230 int64_t pos = lexer.GetPos();
2231 soulng::lexer::Span span = lexer.GetSpan();
2232 bool pass = true;
2233 soulng::parser::Match match(true);
2234 soulng::parser::Match* parentMatch22 = &match;
2235 {
2236 soulng::lexer::Span span = lexer.GetSpan();
2237 soulng::parser::Match match(false);
2238 if (*lexer == RPAREN)
2239 {
2240 ++lexer;
2241 match.hit = true;
2242 }
2243 if (match.hit)
2244 {
2245 *parentMatch22 = match;
2246 }
2247 else
2248 {
2249 lexer.ThrowExpectationFailure(span, ToUtf32(GetTokenInfo(RPAREN)));
2250 }
2251 }
2252 if (match.hit)
2253 {
2254 s.end = span.end;
2255 if (className != classNode->Id()->Str()) pass = false;
2256 else
2257 {
2258 dtor.reset(new DestructorNode(s, *moduleId, specifiers->value, attrs.release()));
2259 dtor->SetClassId(id.release());
2260 dtor->SetSpecifierSpan(specifierSpan);
2261 }
2262 }
2263 if (match.hit && !pass)
2264 {
2265 match = soulng::parser::Match(false);
2266 }
2267 *parentMatch21 = match;
2268 }
2269 *parentMatch20 = match;
2270 }
2271 *parentMatch4 = match;
2272 }
2273 *parentMatch3 = match;
2274 }
2275 if (match.hit)
2276 {
2277 soulng::parser::Match match(false);
2278 soulng::parser::Match* parentMatch23 = &match;
2279 {
2280 soulng::parser::Match match(true);
2281 int64_t save = lexer.GetPos();
2282 soulng::parser::Match* parentMatch24 = &match;
2283 {
2284 soulng::parser::Match match(false);
2285 soulng::parser::Match* parentMatch25 = &match;
2286 {
2287 soulng::parser::Match match(false);
2288 soulng::parser::Match* parentMatch26 = &match;
2289 {
2290 int64_t pos = lexer.GetPos();
2291 soulng::parser::Match match = ConceptParser::WhereConstraint(lexer, moduleId, ctx);
2292 contraint.reset(static_cast<WhereConstraintNode*>(match.value));
2293 if (match.hit)
2294 {
2295 dtor->SetConstraint(contraint.release());
2296 }
2297 *parentMatch26 = match;
2298 }
2299 *parentMatch25 = match;
2300 }
2301 if (match.hit)
2302 {
2303 *parentMatch24 = match;
2304 }
2305 else
2306 {
2307 lexer.SetPos(save);
2308 }
2309 }
2310 *parentMatch23 = match;
2311 }
2312 *parentMatch3 = match;
2313 }
2314 *parentMatch2 = match;
2315 }
2316 if (match.hit)
2317 {
2318 soulng::parser::Match match(false);
2319 soulng::parser::Match* parentMatch27 = &match;
2320 {
2321 soulng::parser::Match match(false);
2322 soulng::parser::Match* parentMatch28 = &match;
2323 {
2324 soulng::parser::Match match(false);
2325 soulng::parser::Match* parentMatch29 = &match;
2326 {
2327 int64_t save = lexer.GetPos();
2328 soulng::parser::Match match(false);
2329 soulng::parser::Match* parentMatch30 = &match;
2330 {
2331 int64_t pos = lexer.GetPos();
2332 soulng::parser::Match match = StatementParser::CompoundStatement(lexer, moduleId, ctx);
2333 body.reset(static_cast<CompoundStatementNode*>(match.value));
2334 if (match.hit)
2335 {
2336 dtor->SetBody(body.release());
2337 }
2338 *parentMatch30 = match;
2339 }
2340 *parentMatch29 = match;
2341 if (!match.hit)
2342 {
2343 soulng::parser::Match match(false);
2344 soulng::parser::Match* parentMatch31 = &match;
2345 lexer.SetPos(save);
2346 {
2347 soulng::parser::Match match(false);
2348 if (*lexer == SEMICOLON)
2349 {
2350 ++lexer;
2351 match.hit = true;
2352 }
2353 *parentMatch31 = match;
2354 }
2355 *parentMatch29 = match;
2356 }
2357 }
2358 *parentMatch28 = match;
2359 }
2360 *parentMatch27 = match;
2361 }
2362 *parentMatch2 = match;
2363 }
2364 *parentMatch1 = match;
2365 }
2366 if (match.hit)
2367 {
2368 {
2369 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2370
2371 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2372 return soulng::parser::Match(true, dtor.release());
2373 }
2374 }
2375 *parentMatch0 = match;
2376 }
2377 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2378
2379
2380
2381
2382
2383 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2384 if (!match.hit)
2385 {
2386 match.value = nullptr;
2387 }
2388 return match;
2389 }
2390
2391 soulng::parser::Match ClassParser::Initializer(CmajorLexer& lexer, boost::uuids::uuid* moduleId, ParsingContext* ctx)
2392 {
2393 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2394
2395
2396
2397
2398
2399
2400
2401 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2402 std::unique_ptr<InitializerNode> initializer = std::unique_ptr<InitializerNode>();
2403 std::unique_ptr<IdentifierNode> id;
2404 soulng::parser::Match match(false);
2405 soulng::parser::Match* parentMatch0 = &match;
2406 {
2407 int64_t pos = lexer.GetPos();
2408 soulng::parser::Match match(false);
2409 soulng::parser::Match* parentMatch1 = &match;
2410 {
2411 soulng::parser::Match match(false);
2412 soulng::parser::Match* parentMatch2 = &match;
2413 {
2414 int64_t save = lexer.GetPos();
2415 soulng::parser::Match match(false);
2416 soulng::parser::Match* parentMatch3 = &match;
2417 {
2418 int64_t save = lexer.GetPos();
2419 soulng::parser::Match match(false);
2420 soulng::parser::Match* parentMatch4 = &match;
2421 {
2422 soulng::parser::Match match(false);
2423 soulng::parser::Match* parentMatch5 = &match;
2424 {
2425 soulng::parser::Match match(false);
2426 soulng::parser::Match* parentMatch6 = &match;
2427 {
2428 soulng::parser::Match match(false);
2429 soulng::parser::Match* parentMatch7 = &match;
2430 {
2431 int64_t pos = lexer.GetPos();
2432 soulng::lexer::Span span = lexer.GetSpan();
2433 soulng::parser::Match match(false);
2434 if (*lexer == THIS)
2435 {
2436 ++lexer;
2437 match.hit = true;
2438 }
2439 if (match.hit)
2440 {
2441 initializer.reset(new ThisInitializerNode(span, *moduleId));
2442 }
2443 *parentMatch7 = match;
2444 }
2445 *parentMatch6 = match;
2446 }
2447 if (match.hit)
2448 {
2449 soulng::parser::Match match(false);
2450 soulng::parser::Match* parentMatch8 = &match;
2451 {
2452 soulng::parser::Match match(true);
2453 soulng::parser::Match* parentMatch9 = &match;
2454 {
2455 soulng::lexer::Span span = lexer.GetSpan();
2456 soulng::parser::Match match(false);
2457 if (*lexer == LPAREN)
2458 {
2459 ++lexer;
2460 match.hit = true;
2461 }
2462 if (match.hit)
2463 {
2464 *parentMatch9 = match;
2465 }
2466 else
2467 {
2468 lexer.ThrowExpectationFailure(span, ToUtf32(GetTokenInfo(LPAREN)));
2469 }
2470 }
2471 *parentMatch8 = match;
2472 }
2473 *parentMatch6 = match;
2474 }
2475 *parentMatch5 = match;
2476 }
2477 if (match.hit)
2478 {
2479 soulng::parser::Match match(false);
2480 soulng::parser::Match* parentMatch10 = &match;
2481 {
2482 soulng::parser::Match match(true);
2483 soulng::parser::Match* parentMatch11 = &match;
2484 {
2485 soulng::lexer::Span span = lexer.GetSpan();
2486 soulng::parser::Match match = ExpressionParser::ArgumentList(lexer, moduleId, ctx, initializer.get());
2487 if (match.hit)
2488 {
2489 *parentMatch11 = match;
2490 }
2491 else
2492 {
2493 lexer.ThrowExpectationFailure(span, U"argument list");
2494 }
2495 }
2496 *parentMatch10 = match;
2497 }
2498 *parentMatch5 = match;
2499 }
2500 *parentMatch4 = match;
2501 }
2502 if (match.hit)
2503 {
2504 soulng::parser::Match match(false);
2505 soulng::parser::Match* parentMatch12 = &match;
2506 {
2507 soulng::parser::Match match(true);
2508 soulng::parser::Match* parentMatch13 = &match;
2509 {
2510 soulng::lexer::Span span = lexer.GetSpan();
2511 soulng::parser::Match match(false);
2512 if (*lexer == RPAREN)
2513 {
2514 ++lexer;
2515 match.hit = true;
2516 }
2517 if (match.hit)
2518 {
2519 *parentMatch13 = match;
2520 }
2521 else
2522 {
2523 lexer.ThrowExpectationFailure(span, ToUtf32(GetTokenInfo(RPAREN)));
2524 }
2525 }
2526 *parentMatch12 = match;
2527 }
2528 *parentMatch4 = match;
2529 }
2530 *parentMatch3 = match;
2531 if (!match.hit)
2532 {
2533 soulng::parser::Match match(false);
2534 soulng::parser::Match* parentMatch14 = &match;
2535 lexer.SetPos(save);
2536 {
2537 soulng::parser::Match match(false);
2538 soulng::parser::Match* parentMatch15 = &match;
2539 {
2540 soulng::parser::Match match(false);
2541 soulng::parser::Match* parentMatch16 = &match;
2542 {
2543 soulng::parser::Match match(false);
2544 soulng::parser::Match* parentMatch17 = &match;
2545 {
2546 soulng::parser::Match match(false);
2547 soulng::parser::Match* parentMatch18 = &match;
2548 {
2549 int64_t pos = lexer.GetPos();
2550 soulng::lexer::Span span = lexer.GetSpan();
2551 soulng::parser::Match match(false);
2552 if (*lexer == BASE)
2553 {
2554 ++lexer;
2555 match.hit = true;
2556 }
2557 if (match.hit)
2558 {
2559 initializer.reset(new BaseInitializerNode(span, *moduleId));
2560 }
2561 *parentMatch18 = match;
2562 }
2563 *parentMatch17 = match;
2564 }
2565 if (match.hit)
2566 {
2567 soulng::parser::Match match(false);
2568 soulng::parser::Match* parentMatch19 = &match;
2569 {
2570 soulng::parser::Match match(true);
2571 soulng::parser::Match* parentMatch20 = &match;
2572 {
2573 soulng::lexer::Span span = lexer.GetSpan();
2574 soulng::parser::Match match(false);
2575 if (*lexer == LPAREN)
2576 {
2577 ++lexer;
2578 match.hit = true;
2579 }
2580 if (match.hit)
2581 {
2582 *parentMatch20 = match;
2583 }
2584 else
2585 {
2586 lexer.ThrowExpectationFailure(span, ToUtf32(GetTokenInfo(LPAREN)));
2587 }
2588 }
2589 *parentMatch19 = match;
2590 }
2591 *parentMatch17 = match;
2592 }
2593 *parentMatch16 = match;
2594 }
2595 if (match.hit)
2596 {
2597 soulng::parser::Match match(false);
2598 soulng::parser::Match* parentMatch21 = &match;
2599 {
2600 soulng::parser::Match match(true);
2601 soulng::parser::Match* parentMatch22 = &match;
2602 {
2603 soulng::lexer::Span span = lexer.GetSpan();
2604 soulng::parser::Match match = ExpressionParser::ArgumentList(lexer, moduleId, ctx, initializer.get());
2605 if (match.hit)
2606 {
2607 *parentMatch22 = match;
2608 }
2609 else
2610 {
2611 lexer.ThrowExpectationFailure(span, U"argument list");
2612 }
2613 }
2614 *parentMatch21 = match;
2615 }
2616 *parentMatch16 = match;
2617 }
2618 *parentMatch15 = match;
2619 }
2620 if (match.hit)
2621 {
2622 soulng::parser::Match match(false);
2623 soulng::parser::Match* parentMatch23 = &match;
2624 {
2625 soulng::parser::Match match(true);
2626 soulng::parser::Match* parentMatch24 = &match;
2627 {
2628 soulng::lexer::Span span = lexer.GetSpan();
2629 soulng::parser::Match match(false);
2630 if (*lexer == RPAREN)
2631 {
2632 ++lexer;
2633 match.hit = true;
2634 }
2635 if (match.hit)
2636 {
2637 *parentMatch24 = match;
2638 }
2639 else
2640 {
2641 lexer.ThrowExpectationFailure(span, ToUtf32(GetTokenInfo(RPAREN)));
2642 }
2643 }
2644 *parentMatch23 = match;
2645 }
2646 *parentMatch15 = match;
2647 }
2648 *parentMatch14 = match;
2649 }
2650 *parentMatch3 = match;
2651 }
2652 }
2653 *parentMatch2 = match;
2654 if (!match.hit)
2655 {
2656 soulng::parser::Match match(false);
2657 soulng::parser::Match* parentMatch25 = &match;
2658 lexer.SetPos(save);
2659 {
2660 soulng::parser::Match match(false);
2661 soulng::parser::Match* parentMatch26 = &match;
2662 {
2663 soulng::parser::Match match(false);
2664 soulng::parser::Match* parentMatch27 = &match;
2665 {
2666 soulng::parser::Match match(false);
2667 soulng::parser::Match* parentMatch28 = &match;
2668 {
2669 soulng::parser::Match match(false);
2670 soulng::parser::Match* parentMatch29 = &match;
2671 {
2672 int64_t pos = lexer.GetPos();
2673 soulng::lexer::Span span = lexer.GetSpan();
2674 soulng::parser::Match match = IdentifierParser::Identifier(lexer, moduleId);
2675 id.reset(static_cast<IdentifierNode*>(match.value));
2676 if (match.hit)
2677 {
2678 initializer.reset(new MemberInitializerNode(span, *moduleId, id.release()));
2679 }
2680 *parentMatch29 = match;
2681 }
2682 *parentMatch28 = match;
2683 }
2684 if (match.hit)
2685 {
2686 soulng::parser::Match match(false);
2687 soulng::parser::Match* parentMatch30 = &match;
2688 {
2689 soulng::parser::Match match(true);
2690 soulng::parser::Match* parentMatch31 = &match;
2691 {
2692 soulng::lexer::Span span = lexer.GetSpan();
2693 soulng::parser::Match match(false);
2694 if (*lexer == LPAREN)
2695 {
2696 ++lexer;
2697 match.hit = true;
2698 }
2699 if (match.hit)
2700 {
2701 *parentMatch31 = match;
2702 }
2703 else
2704 {
2705 lexer.ThrowExpectationFailure(span, ToUtf32(GetTokenInfo(LPAREN)));
2706 }
2707 }
2708 *parentMatch30 = match;
2709 }
2710 *parentMatch28 = match;
2711 }
2712 *parentMatch27 = match;
2713 }
2714 if (match.hit)
2715 {
2716 soulng::parser::Match match(false);
2717 soulng::parser::Match* parentMatch32 = &match;
2718 {
2719 soulng::parser::Match match(true);
2720 soulng::parser::Match* parentMatch33 = &match;
2721 {
2722 soulng::lexer::Span span = lexer.GetSpan();
2723 soulng::parser::Match match = ExpressionParser::ArgumentList(lexer, moduleId, ctx, initializer.get());
2724 if (match.hit)
2725 {
2726 *parentMatch33 = match;
2727 }
2728 else
2729 {
2730 lexer.ThrowExpectationFailure(span, U"argument list");
2731 }
2732 }
2733 *parentMatch32 = match;
2734 }
2735 *parentMatch27 = match;
2736 }
2737 *parentMatch26 = match;
2738 }
2739 if (match.hit)
2740 {
2741 soulng::parser::Match match(false);
2742 soulng::parser::Match* parentMatch34 = &match;
2743 {
2744 soulng::parser::Match match(true);
2745 soulng::parser::Match* parentMatch35 = &match;
2746 {
2747 soulng::lexer::Span span = lexer.GetSpan();
2748 soulng::parser::Match match(false);
2749 if (*lexer == RPAREN)
2750 {
2751 ++lexer;
2752 match.hit = true;
2753 }
2754 if (match.hit)
2755 {
2756 *parentMatch35 = match;
2757 }
2758 else
2759 {
2760 lexer.ThrowExpectationFailure(span, ToUtf32(GetTokenInfo(RPAREN)));
2761 }
2762 }
2763 *parentMatch34 = match;
2764 }
2765 *parentMatch26 = match;
2766 }
2767 *parentMatch25 = match;
2768 }
2769 *parentMatch2 = match;
2770 }
2771 }
2772 *parentMatch1 = match;
2773 }
2774 if (match.hit)
2775 {
2776 {
2777 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2778
2779 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2780 return soulng::parser::Match(true, initializer.release());
2781 }
2782 }
2783 *parentMatch0 = match;
2784 }
2785 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2786
2787
2788
2789
2790
2791 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2792 if (!match.hit)
2793 {
2794 match.value = nullptr;
2795 }
2796 return match;
2797 }
2798
2799 soulng::parser::Match ClassParser::MemberFunction(CmajorLexer& lexer, boost::uuids::uuid* moduleId, ParsingContext* ctx)
2800 {
2801 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2802
2803
2804
2805
2806
2807
2808
2809 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2810 std::unique_ptr<MemberFunctionNode> memFun = std::unique_ptr<MemberFunctionNode>();
2811 Span s = Span();
2812 Span specifierSpan = Span();
2813 Span groupIdSpan = Span();
2814 std::unique_ptr<sngcm::ast::AttributesNode> attrs;
2815 std::unique_ptr<soulng::parser::soulng::parser::Value<sngcm::ast::Specifiers>>specifiers;
2816 std::unique_ptr<sngcm::ast::Node> returnType;
2817 std::unique_ptr<soulng::parser::soulng::parser::Value<std::u32string>>groupId;
2818 std::unique_ptr<WhereConstraintNode> constraint;
2819 std::unique_ptr<CompoundStatementNode> body;
2820 soulng::parser::Match match(false);
2821 soulng::parser::Match* parentMatch0 = &match;
2822 {
2823 int64_t pos = lexer.GetPos();
2824 soulng::parser::Match match(false);
2825 soulng::parser::Match* parentMatch1 = &match;
2826 {
2827 soulng::parser::Match match(false);
2828 soulng::parser::Match* parentMatch2 = &match;
2829 {
2830 soulng::parser::Match match(false);
2831 soulng::parser::Match* parentMatch3 = &match;
2832 {
2833 soulng::parser::Match match(false);
2834 soulng::parser::Match* parentMatch4 = &match;
2835 {
2836 soulng::parser::Match match(false);
2837 soulng::parser::Match* parentMatch5 = &match;
2838 {
2839 soulng::parser::Match match(false);
2840 soulng::parser::Match* parentMatch6 = &match;
2841 {
2842 soulng::parser::Match match(false);
2843 soulng::parser::Match* parentMatch7 = &match;
2844 {
2845 soulng::parser::Match match(false);
2846 soulng::parser::Match* parentMatch8 = &match;
2847 {
2848 soulng::parser::Match match(false);
2849 soulng::parser::Match* parentMatch9 = &match;
2850 {
2851 soulng::parser::Match match(false);
2852 soulng::parser::Match* parentMatch10 = &match;
2853 {
2854 int64_t pos = lexer.GetPos();
2855 soulng::lexer::Span span = lexer.GetSpan();
2856 soulng::parser::Match match(true);
2857 if (match.hit)
2858 {
2859 s = span;
2860 }
2861 *parentMatch10 = match;
2862 }
2863 *parentMatch9 = match;
2864 }
2865 if (match.hit)
2866 {
2867 soulng::parser::Match match(false);
2868 soulng::parser::Match* parentMatch11 = &match;
2869 {
2870 soulng::parser::Match match(true);
2871 int64_t save = lexer.GetPos();
2872 soulng::parser::Match* parentMatch12 = &match;
2873 {
2874 soulng::parser::Match match = AttributeParser::Attributes(lexer, moduleId);
2875 attrs.reset(static_cast<sngcm::ast::AttributesNode*>(match.value));
2876 if (match.hit)
2877 {
2878 *parentMatch12 = match;
2879 }
2880 else
2881 {
2882 lexer.SetPos(save);
2883 }
2884 }
2885 *parentMatch11 = match;
2886 }
2887 *parentMatch9 = match;
2888 }
2889 *parentMatch8 = match;
2890 }
2891 if (match.hit)
2892 {
2893 soulng::parser::Match match(false);
2894 soulng::parser::Match* parentMatch13 = &match;
2895 {
2896 soulng::parser::Match match(false);
2897 soulng::parser::Match* parentMatch14 = &match;
2898 {
2899 int64_t pos = lexer.GetPos();
2900 soulng::lexer::Span span = lexer.GetSpan();
2901 soulng::parser::Match match = SpecifierParser::Specifiers(lexer);
2902 specifiers.reset(static_cast<soulng::parser::soulng::parser::Value<sngcm::ast::Specifiers>*>(match.value));
2903 if (match.hit)
2904 {
2905 specifierSpan = span;
2906 }
2907 *parentMatch14 = match;
2908 }
2909 *parentMatch13 = match;
2910 }
2911 *parentMatch8 = match;
2912 }
2913 *parentMatch7 = match;
2914 }
2915 if (match.hit)
2916 {
2917 soulng::parser::Match match(false);
2918 soulng::parser::Match* parentMatch15 = &match;
2919 {
2920 soulng::parser::Match match = TypeExprParser::TypeExpr(lexer, moduleId, ctx);
2921 returnType.reset(static_cast<sngcm::ast::Node*>(match.value));
2922 *parentMatch15 = match;
2923 }
2924 *parentMatch7 = match;
2925 }
2926 *parentMatch6 = match;
2927 }
2928 if (match.hit)
2929 {
2930 soulng::parser::Match match(false);
2931 soulng::parser::Match* parentMatch16 = &match;
2932 {
2933 soulng::parser::Match match(false);
2934 soulng::parser::Match* parentMatch17 = &match;
2935 {
2936 int64_t pos = lexer.GetPos();
2937 soulng::lexer::Span span = lexer.GetSpan();
2938 soulng::parser::Match match = FunctionParser::FunctionGroupId(lexer, moduleId, ctx);
2939 groupId.reset(static_cast<soulng::parser::soulng::parser::Value<std::u32string>*>(match.value));
2940 if (match.hit)
2941 {
2942 s.end = span.end;
2943 groupIdSpan = span;
2944 memFun.reset(new MemberFunctionNode(s, *moduleId, specifiers->value, returnType.release(), groupId->value, attrs.release()));
2945 memFun->SetSpecifierSpan(specifierSpan);
2946 memFun->SetGroupIdSpan(groupIdSpan);
2947 }
2948 *parentMatch17 = match;
2949 }
2950 *parentMatch16 = match;
2951 }
2952 *parentMatch6 = match;
2953 }
2954 *parentMatch5 = match;
2955 }
2956 if (match.hit)
2957 {
2958 soulng::parser::Match match(false);
2959 soulng::parser::Match* parentMatch18 = &match;
2960 {
2961 soulng::parser::Match match = ParameterParser::ParameterList(lexer, moduleId, ctx, memFun.get());
2962 *parentMatch18 = match;
2963 }
2964 *parentMatch5 = match;
2965 }
2966 *parentMatch4 = match;
2967 }
2968 if (match.hit)
2969 {
2970 soulng::parser::Match match(false);
2971 soulng::parser::Match* parentMatch19 = &match;
2972 {
2973 soulng::parser::Match match(true);
2974 int64_t save = lexer.GetPos();
2975 soulng::parser::Match* parentMatch20 = &match;
2976 {
2977 soulng::parser::Match match(false);
2978 soulng::parser::Match* parentMatch21 = &match;
2979 {
2980 soulng::parser::Match match(false);
2981 soulng::parser::Match* parentMatch22 = &match;
2982 {
2983 int64_t pos = lexer.GetPos();
2984 soulng::parser::Match match(false);
2985 if (*lexer == CONST)
2986 {
2987 ++lexer;
2988 match.hit = true;
2989 }
2990 if (match.hit)
2991 {
2992 memFun->SetConst();
2993 }
2994 *parentMatch22 = match;
2995 }
2996 *parentMatch21 = match;
2997 }
2998 if (match.hit)
2999 {
3000 *parentMatch20 = match;
3001 }
3002 else
3003 {
3004 lexer.SetPos(save);
3005 }
3006 }
3007 *parentMatch19 = match;
3008 }
3009 *parentMatch4 = match;
3010 }
3011 *parentMatch3 = match;
3012 }
3013 if (match.hit)
3014 {
3015 soulng::parser::Match match(false);
3016 soulng::parser::Match* parentMatch23 = &match;
3017 {
3018 soulng::parser::Match match(true);
3019 int64_t save = lexer.GetPos();
3020 soulng::parser::Match* parentMatch24 = &match;
3021 {
3022 soulng::parser::Match match(false);
3023 soulng::parser::Match* parentMatch25 = &match;
3024 {
3025 soulng::parser::Match match(false);
3026 soulng::parser::Match* parentMatch26 = &match;
3027 {
3028 int64_t pos = lexer.GetPos();
3029 soulng::parser::Match match = ConceptParser::WhereConstraint(lexer, moduleId, ctx);
3030 constraint.reset(static_cast<WhereConstraintNode*>(match.value));
3031 if (match.hit)
3032 {
3033 memFun->SetConstraint(constraint.release());
3034 }
3035 *parentMatch26 = match;
3036 }
3037 *parentMatch25 = match;
3038 }
3039 if (match.hit)
3040 {
3041 *parentMatch24 = match;
3042 }
3043 else
3044 {
3045 lexer.SetPos(save);
3046 }
3047 }
3048 *parentMatch23 = match;
3049 }
3050 *parentMatch3 = match;
3051 }
3052 *parentMatch2 = match;
3053 }
3054 if (match.hit)
3055 {
3056 soulng::parser::Match match(false);
3057 soulng::parser::Match* parentMatch27 = &match;
3058 {
3059 soulng::parser::Match match(false);
3060 soulng::parser::Match* parentMatch28 = &match;
3061 {
3062 soulng::parser::Match match(false);
3063 soulng::parser::Match* parentMatch29 = &match;
3064 {
3065 int64_t save = lexer.GetPos();
3066 soulng::parser::Match match(false);
3067 soulng::parser::Match* parentMatch30 = &match;
3068 {
3069 int64_t pos = lexer.GetPos();
3070 soulng::parser::Match match = StatementParser::CompoundStatement(lexer, moduleId, ctx);
3071 body.reset(static_cast<CompoundStatementNode*>(match.value));
3072 if (match.hit)
3073 {
3074 memFun->SetBody(body.release());
3075 }
3076 *parentMatch30 = match;
3077 }
3078 *parentMatch29 = match;
3079 if (!match.hit)
3080 {
3081 soulng::parser::Match match(false);
3082 soulng::parser::Match* parentMatch31 = &match;
3083 lexer.SetPos(save);
3084 {
3085 soulng::parser::Match match(false);
3086 if (*lexer == SEMICOLON)
3087 {
3088 ++lexer;
3089 match.hit = true;
3090 }
3091 *parentMatch31 = match;
3092 }
3093 *parentMatch29 = match;
3094 }
3095 }
3096 *parentMatch28 = match;
3097 }
3098 *parentMatch27 = match;
3099 }
3100 *parentMatch2 = match;
3101 }
3102 *parentMatch1 = match;
3103 }
3104 if (match.hit)
3105 {
3106 {
3107 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3108
3109 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3110 return soulng::parser::Match(true, memFun.release());
3111 }
3112 }
3113 *parentMatch0 = match;
3114 }
3115 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3116
3117
3118
3119
3120
3121 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3122 if (!match.hit)
3123 {
3124 match.value = nullptr;
3125 }
3126 return match;
3127 }
3128
3129 soulng::parser::Match ClassParser::ConversionFunction(CmajorLexer& lexer, boost::uuids::uuid* moduleId, ParsingContext* ctx)
3130 {
3131 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3132
3133
3134
3135
3136
3137
3138
3139 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3140 std::unique_ptr<ConversionFunctionNode> conversionFun = std::unique_ptr<ConversionFunctionNode>();
3141 Span s = Span();
3142 Span specifierSpan = Span();
3143 std::unique_ptr<sngcm::ast::AttributesNode> attrs;
3144 std::unique_ptr<soulng::parser::soulng::parser::Value<sngcm::ast::Specifiers>>specifiers;
3145 std::unique_ptr<sngcm::ast::Node> type;
3146 std::unique_ptr<WhereConstraintNode> constraint;
3147 std::unique_ptr<CompoundStatementNode> body;
3148 soulng::parser::Match match(false);
3149 soulng::parser::Match* parentMatch0 = &match;
3150 {
3151 int64_t pos = lexer.GetPos();
3152 soulng::parser::Match match(false);
3153 soulng::parser::Match* parentMatch1 = &match;
3154 {
3155 soulng::parser::Match match(false);
3156 soulng::parser::Match* parentMatch2 = &match;
3157 {
3158 soulng::parser::Match match(false);
3159 soulng::parser::Match* parentMatch3 = &match;
3160 {
3161 soulng::parser::Match match(false);
3162 soulng::parser::Match* parentMatch4 = &match;
3163 {
3164 soulng::parser::Match match(false);
3165 soulng::parser::Match* parentMatch5 = &match;
3166 {
3167 soulng::parser::Match match(false);
3168 soulng::parser::Match* parentMatch6 = &match;
3169 {
3170 soulng::parser::Match match(false);
3171 soulng::parser::Match* parentMatch7 = &match;
3172 {
3173 soulng::parser::Match match(false);
3174 soulng::parser::Match* parentMatch8 = &match;
3175 {
3176 soulng::parser::Match match(false);
3177 soulng::parser::Match* parentMatch9 = &match;
3178 {
3179 soulng::parser::Match match(false);
3180 soulng::parser::Match* parentMatch10 = &match;
3181 {
3182 soulng::parser::Match match(false);
3183 soulng::parser::Match* parentMatch11 = &match;
3184 {
3185 int64_t pos = lexer.GetPos();
3186 soulng::lexer::Span span = lexer.GetSpan();
3187 soulng::parser::Match match(true);
3188 if (match.hit)
3189 {
3190 s = span;
3191 }
3192 *parentMatch11 = match;
3193 }
3194 *parentMatch10 = match;
3195 }
3196 if (match.hit)
3197 {
3198 soulng::parser::Match match(false);
3199 soulng::parser::Match* parentMatch12 = &match;
3200 {
3201 soulng::parser::Match match(true);
3202 int64_t save = lexer.GetPos();
3203 soulng::parser::Match* parentMatch13 = &match;
3204 {
3205 soulng::parser::Match match = AttributeParser::Attributes(lexer, moduleId);
3206 attrs.reset(static_cast<sngcm::ast::AttributesNode*>(match.value));
3207 if (match.hit)
3208 {
3209 *parentMatch13 = match;
3210 }
3211 else
3212 {
3213 lexer.SetPos(save);
3214 }
3215 }
3216 *parentMatch12 = match;
3217 }
3218 *parentMatch10 = match;
3219 }
3220 *parentMatch9 = match;
3221 }
3222 if (match.hit)
3223 {
3224 soulng::parser::Match match(false);
3225 soulng::parser::Match* parentMatch14 = &match;
3226 {
3227 soulng::parser::Match match(false);
3228 soulng::parser::Match* parentMatch15 = &match;
3229 {
3230 int64_t pos = lexer.GetPos();
3231 soulng::lexer::Span span = lexer.GetSpan();
3232 soulng::parser::Match match = SpecifierParser::Specifiers(lexer);
3233 specifiers.reset(static_cast<soulng::parser::soulng::parser::Value<sngcm::ast::Specifiers>*>(match.value));
3234 if (match.hit)
3235 {
3236 specifierSpan = span;
3237 }
3238 *parentMatch15 = match;
3239 }
3240 *parentMatch14 = match;
3241 }
3242 *parentMatch9 = match;
3243 }
3244 *parentMatch8 = match;
3245 }
3246 if (match.hit)
3247 {
3248 soulng::parser::Match match(false);
3249 soulng::parser::Match* parentMatch16 = &match;
3250 {
3251 soulng::parser::Match match(false);
3252 if (*lexer == OPERATOR)
3253 {
3254 ++lexer;
3255 match.hit = true;
3256 }
3257 *parentMatch16 = match;
3258 }
3259 *parentMatch8 = match;
3260 }
3261 *parentMatch7 = match;
3262 }
3263 if (match.hit)
3264 {
3265 soulng::parser::Match match(false);
3266 soulng::parser::Match* parentMatch17 = &match;
3267 {
3268 soulng::parser::Match match = TypeExprParser::TypeExpr(lexer, moduleId, ctx);
3269 type.reset(static_cast<sngcm::ast::Node*>(match.value));
3270 *parentMatch17 = match;
3271 }
3272 *parentMatch7 = match;
3273 }
3274 *parentMatch6 = match;
3275 }
3276 if (match.hit)
3277 {
3278 soulng::parser::Match match(false);
3279 soulng::parser::Match* parentMatch18 = &match;
3280 {
3281 soulng::parser::Match match(true);
3282 soulng::parser::Match* parentMatch19 = &match;
3283 {
3284 soulng::lexer::Span span = lexer.GetSpan();
3285 soulng::parser::Match match(false);
3286 if (*lexer == LPAREN)
3287 {
3288 ++lexer;
3289 match.hit = true;
3290 }
3291 if (match.hit)
3292 {
3293 *parentMatch19 = match;
3294 }
3295 else
3296 {
3297 lexer.ThrowExpectationFailure(span, ToUtf32(GetTokenInfo(LPAREN)));
3298 }
3299 }
3300 *parentMatch18 = match;
3301 }
3302 *parentMatch6 = match;
3303 }
3304 *parentMatch5 = match;
3305 }
3306 if (match.hit)
3307 {
3308 soulng::parser::Match match(false);
3309 soulng::parser::Match* parentMatch20 = &match;
3310 {
3311 soulng::parser::Match match(false);
3312 soulng::parser::Match* parentMatch21 = &match;
3313 {
3314 int64_t pos = lexer.GetPos();
3315 soulng::lexer::Span span = lexer.GetSpan();
3316 soulng::parser::Match match(true);
3317 soulng::parser::Match* parentMatch22 = &match;
3318 {
3319 soulng::lexer::Span span = lexer.GetSpan();
3320 soulng::parser::Match match(false);
3321 if (*lexer == RPAREN)
3322 {
3323 ++lexer;
3324 match.hit = true;
3325 }
3326 if (match.hit)
3327 {
3328 *parentMatch22 = match;
3329 }
3330 else
3331 {
3332 lexer.ThrowExpectationFailure(span, ToUtf32(GetTokenInfo(RPAREN)));
3333 }
3334 }
3335 if (match.hit)
3336 {
3337 s.end = span.end;
3338 conversionFun.reset(new ConversionFunctionNode(s, *moduleId, specifiers->value, type.release(), attrs.release()));
3339 conversionFun->SetSpecifierSpan(specifierSpan);
3340 }
3341 *parentMatch21 = match;
3342 }
3343 *parentMatch20 = match;
3344 }
3345 *parentMatch5 = match;
3346 }
3347 *parentMatch4 = match;
3348 }
3349 if (match.hit)
3350 {
3351 soulng::parser::Match match(false);
3352 soulng::parser::Match* parentMatch23 = &match;
3353 {
3354 soulng::parser::Match match(true);
3355 int64_t save = lexer.GetPos();
3356 soulng::parser::Match* parentMatch24 = &match;
3357 {
3358 soulng::parser::Match match(false);
3359 soulng::parser::Match* parentMatch25 = &match;
3360 {
3361 soulng::parser::Match match(false);
3362 soulng::parser::Match* parentMatch26 = &match;
3363 {
3364 int64_t pos = lexer.GetPos();
3365 soulng::parser::Match match(false);
3366 if (*lexer == CONST)
3367 {
3368 ++lexer;
3369 match.hit = true;
3370 }
3371 if (match.hit)
3372 {
3373 conversionFun->SetConst();
3374 }
3375 *parentMatch26 = match;
3376 }
3377 *parentMatch25 = match;
3378 }
3379 if (match.hit)
3380 {
3381 *parentMatch24 = match;
3382 }
3383 else
3384 {
3385 lexer.SetPos(save);
3386 }
3387 }
3388 *parentMatch23 = match;
3389 }
3390 *parentMatch4 = match;
3391 }
3392 *parentMatch3 = match;
3393 }
3394 if (match.hit)
3395 {
3396 soulng::parser::Match match(false);
3397 soulng::parser::Match* parentMatch27 = &match;
3398 {
3399 soulng::parser::Match match(true);
3400 int64_t save = lexer.GetPos();
3401 soulng::parser::Match* parentMatch28 = &match;
3402 {
3403 soulng::parser::Match match(false);
3404 soulng::parser::Match* parentMatch29 = &match;
3405 {
3406 soulng::parser::Match match(false);
3407 soulng::parser::Match* parentMatch30 = &match;
3408 {
3409 int64_t pos = lexer.GetPos();
3410 soulng::parser::Match match = ConceptParser::WhereConstraint(lexer, moduleId, ctx);
3411 constraint.reset(static_cast<WhereConstraintNode*>(match.value));
3412 if (match.hit)
3413 {
3414 conversionFun->SetConstraint(constraint.release());
3415 }
3416 *parentMatch30 = match;
3417 }
3418 *parentMatch29 = match;
3419 }
3420 if (match.hit)
3421 {
3422 *parentMatch28 = match;
3423 }
3424 else
3425 {
3426 lexer.SetPos(save);
3427 }
3428 }
3429 *parentMatch27 = match;
3430 }
3431 *parentMatch3 = match;
3432 }
3433 *parentMatch2 = match;
3434 }
3435 if (match.hit)
3436 {
3437 soulng::parser::Match match(false);
3438 soulng::parser::Match* parentMatch31 = &match;
3439 {
3440 soulng::parser::Match match(false);
3441 soulng::parser::Match* parentMatch32 = &match;
3442 {
3443 soulng::parser::Match match(false);
3444 soulng::parser::Match* parentMatch33 = &match;
3445 {
3446 int64_t save = lexer.GetPos();
3447 soulng::parser::Match match(false);
3448 soulng::parser::Match* parentMatch34 = &match;
3449 {
3450 int64_t pos = lexer.GetPos();
3451 soulng::parser::Match match = StatementParser::CompoundStatement(lexer, moduleId, ctx);
3452 body.reset(static_cast<CompoundStatementNode*>(match.value));
3453 if (match.hit)
3454 {
3455 conversionFun->SetBody(body.release());
3456 }
3457 *parentMatch34 = match;
3458 }
3459 *parentMatch33 = match;
3460 if (!match.hit)
3461 {
3462 soulng::parser::Match match(false);
3463 soulng::parser::Match* parentMatch35 = &match;
3464 lexer.SetPos(save);
3465 {
3466 soulng::parser::Match match(false);
3467 if (*lexer == SEMICOLON)
3468 {
3469 ++lexer;
3470 match.hit = true;
3471 }
3472 *parentMatch35 = match;
3473 }
3474 *parentMatch33 = match;
3475 }
3476 }
3477 *parentMatch32 = match;
3478 }
3479 *parentMatch31 = match;
3480 }
3481 *parentMatch2 = match;
3482 }
3483 *parentMatch1 = match;
3484 }
3485 if (match.hit)
3486 {
3487 {
3488 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3489
3490 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3491 return soulng::parser::Match(true, conversionFun.release());
3492 }
3493 }
3494 *parentMatch0 = match;
3495 }
3496 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3497
3498
3499
3500
3501
3502 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3503 if (!match.hit)
3504 {
3505 match.value = nullptr;
3506 }
3507 return match;
3508 }
3509
3510 soulng::parser::Match ClassParser::MemberVariable(CmajorLexer& lexer, boost::uuids::uuid* moduleId, ParsingContext* ctx)
3511 {
3512 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3513
3514
3515
3516
3517
3518
3519
3520 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3521 Span s = Span();
3522 Span specifierSpan = Span();
3523 std::unique_ptr<sngcm::ast::AttributesNode> attrs;
3524 std::unique_ptr<soulng::parser::soulng::parser::Value<sngcm::ast::Specifiers>>specifiers;
3525 std::unique_ptr<sngcm::ast::Node> type;
3526 std::unique_ptr<IdentifierNode> id;
3527 soulng::parser::Match match(false);
3528 soulng::parser::Match* parentMatch0 = &match;
3529 {
3530 soulng::parser::Match match(false);
3531 soulng::parser::Match* parentMatch1 = &match;
3532 {
3533 soulng::parser::Match match(false);
3534 soulng::parser::Match* parentMatch2 = &match;
3535 {
3536 soulng::parser::Match match(false);
3537 soulng::parser::Match* parentMatch3 = &match;
3538 {
3539 soulng::parser::Match match(false);
3540 soulng::parser::Match* parentMatch4 = &match;
3541 {
3542 soulng::parser::Match match(false);
3543 soulng::parser::Match* parentMatch5 = &match;
3544 {
3545 int64_t pos = lexer.GetPos();
3546 soulng::lexer::Span span = lexer.GetSpan();
3547 soulng::parser::Match match(true);
3548 if (match.hit)
3549 {
3550 s = span;
3551 }
3552 *parentMatch5 = match;
3553 }
3554 *parentMatch4 = match;
3555 }
3556 if (match.hit)
3557 {
3558 soulng::parser::Match match(false);
3559 soulng::parser::Match* parentMatch6 = &match;
3560 {
3561 soulng::parser::Match match(true);
3562 int64_t save = lexer.GetPos();
3563 soulng::parser::Match* parentMatch7 = &match;
3564 {
3565 soulng::parser::Match match = AttributeParser::Attributes(lexer, moduleId);
3566 attrs.reset(static_cast<sngcm::ast::AttributesNode*>(match.value));
3567 if (match.hit)
3568 {
3569 *parentMatch7 = match;
3570 }
3571 else
3572 {
3573 lexer.SetPos(save);
3574 }
3575 }
3576 *parentMatch6 = match;
3577 }
3578 *parentMatch4 = match;
3579 }
3580 *parentMatch3 = match;
3581 }
3582 if (match.hit)
3583 {
3584 soulng::parser::Match match(false);
3585 soulng::parser::Match* parentMatch8 = &match;
3586 {
3587 soulng::parser::Match match(false);
3588 soulng::parser::Match* parentMatch9 = &match;
3589 {
3590 int64_t pos = lexer.GetPos();
3591 soulng::lexer::Span span = lexer.GetSpan();
3592 soulng::parser::Match match = SpecifierParser::Specifiers(lexer);
3593 specifiers.reset(static_cast<soulng::parser::soulng::parser::Value<sngcm::ast::Specifiers>*>(match.value));
3594 if (match.hit)
3595 {
3596 specifierSpan = span;
3597 }
3598 *parentMatch9 = match;
3599 }
3600 *parentMatch8 = match;
3601 }
3602 *parentMatch3 = match;
3603 }
3604 *parentMatch2 = match;
3605 }
3606 if (match.hit)
3607 {
3608 soulng::parser::Match match(false);
3609 soulng::parser::Match* parentMatch10 = &match;
3610 {
3611 soulng::parser::Match match = TypeExprParser::TypeExpr(lexer, moduleId, ctx);
3612 type.reset(static_cast<sngcm::ast::Node*>(match.value));
3613 *parentMatch10 = match;
3614 }
3615 *parentMatch2 = match;
3616 }
3617 *parentMatch1 = match;
3618 }
3619 if (match.hit)
3620 {
3621 soulng::parser::Match match(false);
3622 soulng::parser::Match* parentMatch11 = &match;
3623 {
3624 soulng::parser::Match match = IdentifierParser::Identifier(lexer, moduleId);
3625 id.reset(static_cast<IdentifierNode*>(match.value));
3626 *parentMatch11 = match;
3627 }
3628 *parentMatch1 = match;
3629 }
3630 *parentMatch0 = match;
3631 }
3632 if (match.hit)
3633 {
3634 soulng::parser::Match match(false);
3635 soulng::parser::Match* parentMatch12 = &match;
3636 {
3637 soulng::parser::Match match(false);
3638 soulng::parser::Match* parentMatch13 = &match;
3639 {
3640 int64_t pos = lexer.GetPos();
3641 soulng::lexer::Span span = lexer.GetSpan();
3642 soulng::parser::Match match(false);
3643 if (*lexer == SEMICOLON)
3644 {
3645 ++lexer;
3646 match.hit = true;
3647 }
3648 if (match.hit)
3649 {
3650 s.end = span.end;
3651 MemberVariableNode* value = new MemberVariableNode(s, *moduleId, specifiers->value, type.release(), id.release(), attrs.release());
3652 value->SetSpecifierSpan(specifierSpan);
3653 {
3654 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3655
3656 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3657 return soulng::parser::Match(true, value);
3658 }
3659 }
3660 *parentMatch13 = match;
3661 }
3662 *parentMatch12 = match;
3663 }
3664 *parentMatch0 = match;
3665 }
3666 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
3667
3668
3669
3670
3671
3672 #endif // SOULNG_PARSER_DEBUG_SUPPORT
3673 if (!match.hit)
3674 {
3675 match.value = nullptr;
3676 }
3677 return match;
3678 }