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