1 #include "PPParser.hpp"
2 #include <soulng/util/Unicode.hpp>
3 #include <sngcpp/pp/PPLexer.hpp>
4 #include <sngcpp/pp/PPTokens.hpp>
5
6
7
8 using namespace soulng::unicode;
9 using namespace PPTokens;
10
11 void PPLineParser::Parse(PPLexer& lexer, sngcpp::pp::PP* pp)
12 {
13 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
14
15
16
17
18
19 #endif // SOULNG_PARSER_DEBUG_SUPPORT
20 ++lexer;
21 soulng::lexer::Span span = lexer.GetSpan();
22 soulng::parser::Match match = PPLineParser::PPLine(lexer, pp);
23 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
24
25
26
27
28
29 #endif // SOULNG_PARSER_DEBUG_SUPPORT
30 if (match.hit)
31 {
32 if (*lexer == soulng::lexer::END_TOKEN)
33 {
34 return;
35 }
36 else
37 {
38 lexer.ThrowExpectationFailure(lexer.GetSpan(), ToUtf32(soulng::lexer::GetEndTokenInfo()));
39 }
40 }
41 else
42 {
43 lexer.ThrowExpectationFailure(span, U"PPLine");
44 }
45 return;
46 }
47
48 soulng::parser::Match PPLineParser::PPLine(PPLexer& lexer, sngcpp::pp::PP* pp)
49 {
50 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
51
52
53
54
55
56
57
58 #endif // SOULNG_PARSER_DEBUG_SUPPORT
59 soulng::parser::Match match(false);
60 soulng::parser::Match* parentMatch0 = &match;
61 {
62 int64_t save = lexer.GetPos();
63 soulng::parser::Match match(false);
64 soulng::parser::Match* parentMatch1 = &match;
65 {
66 int64_t save = lexer.GetPos();
67 soulng::parser::Match match(false);
68 soulng::parser::Match* parentMatch2 = &match;
69 {
70 int64_t save = lexer.GetPos();
71 soulng::parser::Match match(false);
72 soulng::parser::Match* parentMatch3 = &match;
73 {
74 int64_t save = lexer.GetPos();
75 soulng::parser::Match match(false);
76 soulng::parser::Match* parentMatch4 = &match;
77 {
78 int64_t save = lexer.GetPos();
79 soulng::parser::Match match(false);
80 soulng::parser::Match* parentMatch5 = &match;
81 {
82 int64_t save = lexer.GetPos();
83 soulng::parser::Match match(false);
84 soulng::parser::Match* parentMatch6 = &match;
85 {
86 int64_t save = lexer.GetPos();
87 soulng::parser::Match match(false);
88 soulng::parser::Match* parentMatch7 = &match;
89 {
90 int64_t save = lexer.GetPos();
91 soulng::parser::Match match = PPLineParser::Define(lexer, pp);
92 *parentMatch7 = match;
93 if (!match.hit)
94 {
95 soulng::parser::Match match(false);
96 soulng::parser::Match* parentMatch8 = &match;
97 lexer.SetPos(save);
98 {
99 soulng::parser::Match match = PPLineParser::Include(lexer, pp);
100 *parentMatch8 = match;
101 }
102 *parentMatch7 = match;
103 }
104 }
105 *parentMatch6 = match;
106 if (!match.hit)
107 {
108 soulng::parser::Match match(false);
109 soulng::parser::Match* parentMatch9 = &match;
110 lexer.SetPos(save);
111 {
112 soulng::parser::Match match = PPLineParser::If(lexer, pp);
113 *parentMatch9 = match;
114 }
115 *parentMatch6 = match;
116 }
117 }
118 *parentMatch5 = match;
119 if (!match.hit)
120 {
121 soulng::parser::Match match(false);
122 soulng::parser::Match* parentMatch10 = &match;
123 lexer.SetPos(save);
124 {
125 soulng::parser::Match match = PPLineParser::Ifdef(lexer, pp);
126 *parentMatch10 = match;
127 }
128 *parentMatch5 = match;
129 }
130 }
131 *parentMatch4 = match;
132 if (!match.hit)
133 {
134 soulng::parser::Match match(false);
135 soulng::parser::Match* parentMatch11 = &match;
136 lexer.SetPos(save);
137 {
138 soulng::parser::Match match = PPLineParser::Ifndef(lexer, pp);
139 *parentMatch11 = match;
140 }
141 *parentMatch4 = match;
142 }
143 }
144 *parentMatch3 = match;
145 if (!match.hit)
146 {
147 soulng::parser::Match match(false);
148 soulng::parser::Match* parentMatch12 = &match;
149 lexer.SetPos(save);
150 {
151 soulng::parser::Match match = PPLineParser::Elif(lexer, pp);
152 *parentMatch12 = match;
153 }
154 *parentMatch3 = match;
155 }
156 }
157 *parentMatch2 = match;
158 if (!match.hit)
159 {
160 soulng::parser::Match match(false);
161 soulng::parser::Match* parentMatch13 = &match;
162 lexer.SetPos(save);
163 {
164 soulng::parser::Match match = PPLineParser::Else(lexer, pp);
165 *parentMatch13 = match;
166 }
167 *parentMatch2 = match;
168 }
169 }
170 *parentMatch1 = match;
171 if (!match.hit)
172 {
173 soulng::parser::Match match(false);
174 soulng::parser::Match* parentMatch14 = &match;
175 lexer.SetPos(save);
176 {
177 soulng::parser::Match match = PPLineParser::Endif(lexer, pp);
178 *parentMatch14 = match;
179 }
180 *parentMatch1 = match;
181 }
182 }
183 *parentMatch0 = match;
184 if (!match.hit)
185 {
186 soulng::parser::Match match(false);
187 soulng::parser::Match* parentMatch15 = &match;
188 lexer.SetPos(save);
189 {
190 soulng::parser::Match match = PPLineParser::Other(lexer, pp);
191 *parentMatch15 = match;
192 }
193 *parentMatch0 = match;
194 }
195 }
196 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
197
198
199
200
201
202 #endif // SOULNG_PARSER_DEBUG_SUPPORT
203 if (!match.hit)
204 {
205 match.value = nullptr;
206 }
207 return match;
208 }
209
210 soulng::parser::Match PPLineParser::Define(PPLexer& lexer, sngcpp::pp::PP* pp)
211 {
212 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
213
214
215
216
217
218
219
220 #endif // SOULNG_PARSER_DEBUG_SUPPORT
221 std::std::vector<soulng::lexer::Token>*tokens=nullptr;
222 std::unique_ptr<int> ppToken;
223 soulng::parser::Match match(false);
224 soulng::parser::Match* parentMatch0 = &match;
225 {
226 int64_t pos = lexer.GetPos();
227 soulng::parser::Match match(false);
228 soulng::parser::Match* parentMatch1 = &match;
229 {
230 soulng::parser::Match match(false);
231 soulng::parser::Match* parentMatch2 = &match;
232 {
233 soulng::parser::Match match(false);
234 soulng::parser::Match* parentMatch3 = &match;
235 {
236 soulng::parser::Match match(false);
237 soulng::parser::Match* parentMatch4 = &match;
238 {
239 soulng::parser::Match match(false);
240 if (*lexer == HASH)
241 {
242 ++lexer;
243 match.hit = true;
244 }
245 *parentMatch4 = match;
246 }
247 if (match.hit)
248 {
249 soulng::parser::Match match(false);
250 soulng::parser::Match* parentMatch5 = &match;
251 {
252 soulng::parser::Match match(false);
253 if (*lexer == DEFINE)
254 {
255 ++lexer;
256 match.hit = true;
257 }
258 *parentMatch5 = match;
259 }
260 *parentMatch4 = match;
261 }
262 *parentMatch3 = match;
263 }
264 if (match.hit)
265 {
266 soulng::parser::Match match(false);
267 soulng::parser::Match* parentMatch6 = &match;
268 {
269 soulng::parser::Match match(false);
270 soulng::parser::Match* parentMatch7 = &match;
271 {
272 int64_t pos = lexer.GetPos();
273 soulng::parser::Match match(false);
274 if (*lexer == ID)
275 {
276 ++lexer;
277 match.hit = true;
278 }
279 if (match.hit)
280 {
281 soulng::lexer::Token id = lexer.GetToken(pos);
282 tokens = pp->BeginDefine(id.match);
283 }
284 *parentMatch7 = match;
285 }
286 *parentMatch6 = match;
287 }
288 *parentMatch3 = match;
289 }
290 *parentMatch2 = match;
291 }
292 if (match.hit)
293 {
294 soulng::parser::Match match(false);
295 soulng::parser::Match* parentMatch8 = &match;
296 {
297 soulng::parser::Match match(true);
298 soulng::parser::Match* parentMatch9 = &match;
299 {
300 while (true)
301 {
302 int64_t save = lexer.GetPos();
303 {
304 soulng::parser::Match match = PPLineParser::PPToken(lexer, tokens);
305 ppToken.reset(static_cast<int*>(match.value));
306 if (match.hit)
307 {
308 *parentMatch9 = match;
309 }
310 else
311 {
312 lexer.SetPos(save);
313 break;
314 }
315 }
316 }
317 }
318 *parentMatch8 = match;
319 }
320 *parentMatch2 = match;
321 }
322 *parentMatch1 = match;
323 }
324 if (match.hit)
325 {
326 pp->EndDefine(*tokens);
327 }
328 *parentMatch0 = match;
329 }
330 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
331
332
333
334
335
336 #endif // SOULNG_PARSER_DEBUG_SUPPORT
337 if (!match.hit)
338 {
339 match.value = nullptr;
340 }
341 return match;
342 }
343
344 soulng::parser::Match PPLineParser::Include(PPLexer& lexer, sngcpp::pp::PP* pp)
345 {
346 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
347
348
349
350
351
352
353
354 #endif // SOULNG_PARSER_DEBUG_SUPPORT
355 bool isAngleHeader = bool();
356 std::string headerName = std::string();
357 soulng::parser::Match match(false);
358 soulng::parser::Match* parentMatch0 = &match;
359 {
360 soulng::parser::Match match(false);
361 soulng::parser::Match* parentMatch1 = &match;
362 {
363 soulng::parser::Match match(false);
364 if (*lexer == HASH)
365 {
366 ++lexer;
367 match.hit = true;
368 }
369 *parentMatch1 = match;
370 }
371 if (match.hit)
372 {
373 soulng::parser::Match match(false);
374 soulng::parser::Match* parentMatch2 = &match;
375 {
376 soulng::parser::Match match(false);
377 if (*lexer == INCLUDE)
378 {
379 ++lexer;
380 match.hit = true;
381 }
382 *parentMatch2 = match;
383 }
384 *parentMatch1 = match;
385 }
386 *parentMatch0 = match;
387 }
388 if (match.hit)
389 {
390 soulng::parser::Match match(false);
391 soulng::parser::Match* parentMatch3 = &match;
392 {
393 soulng::parser::Match match(false);
394 soulng::parser::Match* parentMatch4 = &match;
395 {
396 int64_t pos = lexer.GetPos();
397 soulng::parser::Match match(false);
398 soulng::parser::Match* parentMatch5 = &match;
399 {
400 soulng::parser::Match match(false);
401 soulng::parser::Match* parentMatch6 = &match;
402 {
403 int64_t save = lexer.GetPos();
404 soulng::parser::Match match(false);
405 soulng::parser::Match* parentMatch7 = &match;
406 {
407 int64_t pos = lexer.GetPos();
408 soulng::parser::Match match(false);
409 if (*lexer == ANGLEHEADERNAME)
410 {
411 ++lexer;
412 match.hit = true;
413 }
414 if (match.hit)
415 {
416 isAngleHeader = true;
417 soulng::lexer::Token headerNameToken = lexer.GetToken(pos);
418 headerName = sngcpp::pp::ParseAngleHeaderName(lexer.FileName(), headerNameToken);
419 }
420 *parentMatch7 = match;
421 }
422 *parentMatch6 = match;
423 if (!match.hit)
424 {
425 soulng::parser::Match match(false);
426 soulng::parser::Match* parentMatch8 = &match;
427 lexer.SetPos(save);
428 {
429 soulng::parser::Match match(false);
430 soulng::parser::Match* parentMatch9 = &match;
431 {
432 int64_t pos = lexer.GetPos();
433 soulng::parser::Match match(false);
434 if (*lexer == QUOTEHEADERNAME)
435 {
436 ++lexer;
437 match.hit = true;
438 }
439 if (match.hit)
440 {
441 isAngleHeader = false;
442 soulng::lexer::Token headerNameToken = lexer.GetToken(pos);
443 headerName = sngcpp::pp::ParseQuoteHeaderName(lexer.FileName(), headerNameToken);
444 }
445 *parentMatch9 = match;
446 }
447 *parentMatch8 = match;
448 }
449 *parentMatch6 = match;
450 }
451 }
452 *parentMatch5 = match;
453 }
454 if (match.hit)
455 {
456 pp->Include(isAngleHeader, headerName);
457 }
458 *parentMatch4 = match;
459 }
460 *parentMatch3 = match;
461 }
462 *parentMatch0 = match;
463 }
464 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
465
466
467
468
469
470 #endif // SOULNG_PARSER_DEBUG_SUPPORT
471 if (!match.hit)
472 {
473 match.value = nullptr;
474 }
475 return match;
476 }
477
478 soulng::parser::Match PPLineParser::If(PPLexer& lexer, sngcpp::pp::PP* pp)
479 {
480 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
481
482
483
484
485
486
487
488 #endif // SOULNG_PARSER_DEBUG_SUPPORT
489 std::vector<soulng::lexer::Token> exprTokens = std::vector<soulng::lexer::Token>();
490 std::unique_ptr<int> ppToken;
491 soulng::parser::Match match(false);
492 soulng::parser::Match* parentMatch0 = &match;
493 {
494 int64_t pos = lexer.GetPos();
495 soulng::parser::Match match(false);
496 soulng::parser::Match* parentMatch1 = &match;
497 {
498 soulng::parser::Match match(false);
499 soulng::parser::Match* parentMatch2 = &match;
500 {
501 soulng::parser::Match match(false);
502 soulng::parser::Match* parentMatch3 = &match;
503 {
504 soulng::parser::Match match(false);
505 if (*lexer == HASH)
506 {
507 ++lexer;
508 match.hit = true;
509 }
510 *parentMatch3 = match;
511 }
512 if (match.hit)
513 {
514 soulng::parser::Match match(false);
515 soulng::parser::Match* parentMatch4 = &match;
516 {
517 soulng::parser::Match match(false);
518 if (*lexer == IF)
519 {
520 ++lexer;
521 match.hit = true;
522 }
523 *parentMatch4 = match;
524 }
525 *parentMatch3 = match;
526 }
527 *parentMatch2 = match;
528 }
529 if (match.hit)
530 {
531 soulng::parser::Match match(false);
532 soulng::parser::Match* parentMatch5 = &match;
533 {
534 soulng::parser::Match match(true);
535 soulng::parser::Match* parentMatch6 = &match;
536 {
537 while (true)
538 {
539 int64_t save = lexer.GetPos();
540 {
541 soulng::parser::Match match = PPLineParser::PPToken(lexer, &exprTokens);
542 ppToken.reset(static_cast<int*>(match.value));
543 if (match.hit)
544 {
545 *parentMatch6 = match;
546 }
547 else
548 {
549 lexer.SetPos(save);
550 break;
551 }
552 }
553 }
554 }
555 *parentMatch5 = match;
556 }
557 *parentMatch2 = match;
558 }
559 *parentMatch1 = match;
560 }
561 if (match.hit)
562 {
563 pp->If(exprTokens);
564 }
565 *parentMatch0 = match;
566 }
567 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
568
569
570
571
572
573 #endif // SOULNG_PARSER_DEBUG_SUPPORT
574 if (!match.hit)
575 {
576 match.value = nullptr;
577 }
578 return match;
579 }
580
581 soulng::parser::Match PPLineParser::Ifdef(PPLexer& lexer, sngcpp::pp::PP* pp)
582 {
583 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
584
585
586
587
588
589
590
591 #endif // SOULNG_PARSER_DEBUG_SUPPORT
592 bool defined = bool();
593 soulng::parser::Match match(false);
594 soulng::parser::Match* parentMatch0 = &match;
595 {
596 int64_t pos = lexer.GetPos();
597 soulng::parser::Match match(false);
598 soulng::parser::Match* parentMatch1 = &match;
599 {
600 soulng::parser::Match match(false);
601 soulng::parser::Match* parentMatch2 = &match;
602 {
603 soulng::parser::Match match(false);
604 soulng::parser::Match* parentMatch3 = &match;
605 {
606 soulng::parser::Match match(false);
607 if (*lexer == HASH)
608 {
609 ++lexer;
610 match.hit = true;
611 }
612 *parentMatch3 = match;
613 }
614 if (match.hit)
615 {
616 soulng::parser::Match match(false);
617 soulng::parser::Match* parentMatch4 = &match;
618 {
619 soulng::parser::Match match(false);
620 if (*lexer == IFDEF)
621 {
622 ++lexer;
623 match.hit = true;
624 }
625 *parentMatch4 = match;
626 }
627 *parentMatch3 = match;
628 }
629 *parentMatch2 = match;
630 }
631 if (match.hit)
632 {
633 soulng::parser::Match match(false);
634 soulng::parser::Match* parentMatch5 = &match;
635 {
636 soulng::parser::Match match(false);
637 soulng::parser::Match* parentMatch6 = &match;
638 {
639 int64_t pos = lexer.GetPos();
640 soulng::parser::Match match(false);
641 if (*lexer == ID)
642 {
643 ++lexer;
644 match.hit = true;
645 }
646 if (match.hit)
647 {
648 soulng::lexer::Token token = lexer.GetToken(pos);
649 defined = pp->IsDefined(token.match);
650 }
651 *parentMatch6 = match;
652 }
653 *parentMatch5 = match;
654 }
655 *parentMatch2 = match;
656 }
657 *parentMatch1 = match;
658 }
659 if (match.hit)
660 {
661 pp->Ifdef(defined);
662 }
663 *parentMatch0 = match;
664 }
665 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
666
667
668
669
670
671 #endif // SOULNG_PARSER_DEBUG_SUPPORT
672 if (!match.hit)
673 {
674 match.value = nullptr;
675 }
676 return match;
677 }
678
679 soulng::parser::Match PPLineParser::Ifndef(PPLexer& lexer, sngcpp::pp::PP* pp)
680 {
681 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
682
683
684
685
686
687
688
689 #endif // SOULNG_PARSER_DEBUG_SUPPORT
690 bool defined = bool();
691 soulng::parser::Match match(false);
692 soulng::parser::Match* parentMatch0 = &match;
693 {
694 int64_t pos = lexer.GetPos();
695 soulng::parser::Match match(false);
696 soulng::parser::Match* parentMatch1 = &match;
697 {
698 soulng::parser::Match match(false);
699 soulng::parser::Match* parentMatch2 = &match;
700 {
701 soulng::parser::Match match(false);
702 soulng::parser::Match* parentMatch3 = &match;
703 {
704 soulng::parser::Match match(false);
705 if (*lexer == HASH)
706 {
707 ++lexer;
708 match.hit = true;
709 }
710 *parentMatch3 = match;
711 }
712 if (match.hit)
713 {
714 soulng::parser::Match match(false);
715 soulng::parser::Match* parentMatch4 = &match;
716 {
717 soulng::parser::Match match(false);
718 if (*lexer == IFNDEF)
719 {
720 ++lexer;
721 match.hit = true;
722 }
723 *parentMatch4 = match;
724 }
725 *parentMatch3 = match;
726 }
727 *parentMatch2 = match;
728 }
729 if (match.hit)
730 {
731 soulng::parser::Match match(false);
732 soulng::parser::Match* parentMatch5 = &match;
733 {
734 soulng::parser::Match match(false);
735 soulng::parser::Match* parentMatch6 = &match;
736 {
737 int64_t pos = lexer.GetPos();
738 soulng::parser::Match match(false);
739 if (*lexer == ID)
740 {
741 ++lexer;
742 match.hit = true;
743 }
744 if (match.hit)
745 {
746 soulng::lexer::Token token = lexer.GetToken(pos);
747 defined = pp->IsDefined(token.match);
748 }
749 *parentMatch6 = match;
750 }
751 *parentMatch5 = match;
752 }
753 *parentMatch2 = match;
754 }
755 *parentMatch1 = match;
756 }
757 if (match.hit)
758 {
759 pp->Ifndef(defined);
760 }
761 *parentMatch0 = match;
762 }
763 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
764
765
766
767
768
769 #endif // SOULNG_PARSER_DEBUG_SUPPORT
770 if (!match.hit)
771 {
772 match.value = nullptr;
773 }
774 return match;
775 }
776
777 soulng::parser::Match PPLineParser::Elif(PPLexer& lexer, sngcpp::pp::PP* pp)
778 {
779 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
780
781
782
783
784
785
786
787 #endif // SOULNG_PARSER_DEBUG_SUPPORT
788 std::vector<soulng::lexer::Token> exprTokens = std::vector<soulng::lexer::Token>();
789 std::unique_ptr<int> ppToken;
790 soulng::parser::Match match(false);
791 soulng::parser::Match* parentMatch0 = &match;
792 {
793 int64_t pos = lexer.GetPos();
794 soulng::parser::Match match(false);
795 soulng::parser::Match* parentMatch1 = &match;
796 {
797 soulng::parser::Match match(false);
798 soulng::parser::Match* parentMatch2 = &match;
799 {
800 soulng::parser::Match match(false);
801 soulng::parser::Match* parentMatch3 = &match;
802 {
803 soulng::parser::Match match(false);
804 if (*lexer == HASH)
805 {
806 ++lexer;
807 match.hit = true;
808 }
809 *parentMatch3 = match;
810 }
811 if (match.hit)
812 {
813 soulng::parser::Match match(false);
814 soulng::parser::Match* parentMatch4 = &match;
815 {
816 soulng::parser::Match match(false);
817 if (*lexer == ELIF)
818 {
819 ++lexer;
820 match.hit = true;
821 }
822 *parentMatch4 = match;
823 }
824 *parentMatch3 = match;
825 }
826 *parentMatch2 = match;
827 }
828 if (match.hit)
829 {
830 soulng::parser::Match match(false);
831 soulng::parser::Match* parentMatch5 = &match;
832 {
833 soulng::parser::Match match(true);
834 soulng::parser::Match* parentMatch6 = &match;
835 {
836 while (true)
837 {
838 int64_t save = lexer.GetPos();
839 {
840 soulng::parser::Match match = PPLineParser::PPToken(lexer, &exprTokens);
841 ppToken.reset(static_cast<int*>(match.value));
842 if (match.hit)
843 {
844 *parentMatch6 = match;
845 }
846 else
847 {
848 lexer.SetPos(save);
849 break;
850 }
851 }
852 }
853 }
854 *parentMatch5 = match;
855 }
856 *parentMatch2 = match;
857 }
858 *parentMatch1 = match;
859 }
860 if (match.hit)
861 {
862 pp->Elif(exprTokens);
863 }
864 *parentMatch0 = match;
865 }
866 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
867
868
869
870
871
872 #endif // SOULNG_PARSER_DEBUG_SUPPORT
873 if (!match.hit)
874 {
875 match.value = nullptr;
876 }
877 return match;
878 }
879
880 soulng::parser::Match PPLineParser::Else(PPLexer& lexer, sngcpp::pp::PP* pp)
881 {
882 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
883
884
885
886
887
888
889
890 #endif // SOULNG_PARSER_DEBUG_SUPPORT
891 soulng::parser::Match match(false);
892 soulng::parser::Match* parentMatch0 = &match;
893 {
894 int64_t pos = lexer.GetPos();
895 soulng::parser::Match match(false);
896 soulng::parser::Match* parentMatch1 = &match;
897 {
898 soulng::parser::Match match(false);
899 soulng::parser::Match* parentMatch2 = &match;
900 {
901 soulng::parser::Match match(false);
902 if (*lexer == HASH)
903 {
904 ++lexer;
905 match.hit = true;
906 }
907 *parentMatch2 = match;
908 }
909 if (match.hit)
910 {
911 soulng::parser::Match match(false);
912 soulng::parser::Match* parentMatch3 = &match;
913 {
914 soulng::parser::Match match(false);
915 if (*lexer == ELSE)
916 {
917 ++lexer;
918 match.hit = true;
919 }
920 *parentMatch3 = match;
921 }
922 *parentMatch2 = match;
923 }
924 *parentMatch1 = match;
925 }
926 if (match.hit)
927 {
928 pp->Else();
929 }
930 *parentMatch0 = match;
931 }
932 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
933
934
935
936
937
938 #endif // SOULNG_PARSER_DEBUG_SUPPORT
939 if (!match.hit)
940 {
941 match.value = nullptr;
942 }
943 return match;
944 }
945
946 soulng::parser::Match PPLineParser::Endif(PPLexer& lexer, sngcpp::pp::PP* pp)
947 {
948 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
949
950
951
952
953
954
955
956 #endif // SOULNG_PARSER_DEBUG_SUPPORT
957 soulng::parser::Match match(false);
958 soulng::parser::Match* parentMatch0 = &match;
959 {
960 int64_t pos = lexer.GetPos();
961 soulng::parser::Match match(false);
962 soulng::parser::Match* parentMatch1 = &match;
963 {
964 soulng::parser::Match match(false);
965 soulng::parser::Match* parentMatch2 = &match;
966 {
967 soulng::parser::Match match(false);
968 if (*lexer == HASH)
969 {
970 ++lexer;
971 match.hit = true;
972 }
973 *parentMatch2 = match;
974 }
975 if (match.hit)
976 {
977 soulng::parser::Match match(false);
978 soulng::parser::Match* parentMatch3 = &match;
979 {
980 soulng::parser::Match match(false);
981 if (*lexer == ENDIF)
982 {
983 ++lexer;
984 match.hit = true;
985 }
986 *parentMatch3 = match;
987 }
988 *parentMatch2 = match;
989 }
990 *parentMatch1 = match;
991 }
992 if (match.hit)
993 {
994 pp->Endif();
995 }
996 *parentMatch0 = match;
997 }
998 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
999
1000
1001
1002
1003
1004 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1005 if (!match.hit)
1006 {
1007 match.value = nullptr;
1008 }
1009 return match;
1010 }
1011
1012 soulng::parser::Match PPLineParser::Other(PPLexer& lexer, sngcpp::pp::PP* pp)
1013 {
1014 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1015
1016
1017
1018
1019
1020
1021
1022 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1023 std::unique_ptr<int> ppToken;
1024 soulng::parser::Match match(false);
1025 soulng::parser::Match* parentMatch0 = &match;
1026 {
1027 soulng::parser::Match match(false);
1028 soulng::parser::Match* parentMatch1 = &match;
1029 {
1030 soulng::parser::Match match(false);
1031 if (*lexer == HASH)
1032 {
1033 ++lexer;
1034 match.hit = true;
1035 }
1036 *parentMatch1 = match;
1037 }
1038 if (match.hit)
1039 {
1040 soulng::parser::Match match(false);
1041 soulng::parser::Match* parentMatch2 = &match;
1042 {
1043 soulng::parser::Match match(true);
1044 soulng::parser::Match* parentMatch3 = &match;
1045 {
1046 while (true)
1047 {
1048 int64_t save = lexer.GetPos();
1049 {
1050 soulng::parser::Match match = PPLineParser::PPToken(lexer, nullptr);
1051 ppToken.reset(static_cast<int*>(match.value));
1052 if (match.hit)
1053 {
1054 *parentMatch3 = match;
1055 }
1056 else
1057 {
1058 lexer.SetPos(save);
1059 break;
1060 }
1061 }
1062 }
1063 }
1064 *parentMatch2 = match;
1065 }
1066 *parentMatch1 = match;
1067 }
1068 *parentMatch0 = match;
1069 }
1070 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1071
1072
1073
1074
1075
1076 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1077 if (!match.hit)
1078 {
1079 match.value = nullptr;
1080 }
1081 return match;
1082 }
1083
1084 soulng::parser::Match PPLineParser::PPToken(PPLexer& lexer, std::std::vector<soulng::lexer::Token>*tokens)
1085 {
1086 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1087
1088
1089
1090
1091
1092
1093
1094 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1095 soulng::parser::Match match(false);
1096 int64_t pos = lexer.GetPos();
1097 soulng::lexer::Span span = lexer.GetSpan();
1098 switch (*lexer)
1099 {
1100 case ID:
1101 {
1102 ++lexer;
1103 {
1104 if (tokens) tokens->push_back(lexer.GetToken(pos));
1105 {
1106 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1107
1108 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1109 return soulng::parser::Match(true, nullptr);
1110 }
1111 }
1112 break;
1113 }
1114 case DEFINED:
1115 {
1116 ++lexer;
1117 {
1118 if (tokens) tokens->push_back(lexer.GetToken(pos));
1119 {
1120 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1121
1122 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1123 return soulng::parser::Match(true, nullptr);
1124 }
1125 }
1126 break;
1127 }
1128 case ANGLEHEADERNAME:
1129 {
1130 ++lexer;
1131 {
1132 if (tokens) tokens->push_back(lexer.GetToken(pos));
1133 {
1134 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1135
1136 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1137 return soulng::parser::Match(true, nullptr);
1138 }
1139 }
1140 break;
1141 }
1142 case QUOTEHEADERNAME:
1143 {
1144 ++lexer;
1145 {
1146 if (tokens) tokens->push_back(lexer.GetToken(pos));
1147 {
1148 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1149
1150 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1151 return soulng::parser::Match(true, nullptr);
1152 }
1153 }
1154 break;
1155 }
1156 case PPNUMBER:
1157 {
1158 ++lexer;
1159 {
1160 if (tokens) tokens->push_back(lexer.GetToken(pos));
1161 {
1162 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1163
1164 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1165 return soulng::parser::Match(true, nullptr);
1166 }
1167 }
1168 break;
1169 }
1170 case CHARLITERAL:
1171 {
1172 ++lexer;
1173 {
1174 if (tokens) tokens->push_back(lexer.GetToken(pos));
1175 {
1176 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1177
1178 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1179 return soulng::parser::Match(true, nullptr);
1180 }
1181 }
1182 break;
1183 }
1184 case STRINGLITERAL:
1185 {
1186 ++lexer;
1187 {
1188 if (tokens) tokens->push_back(lexer.GetToken(pos));
1189 {
1190 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1191
1192 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1193 return soulng::parser::Match(true, nullptr);
1194 }
1195 }
1196 break;
1197 }
1198 case CHAR:
1199 {
1200 ++lexer;
1201 {
1202 if (tokens) tokens->push_back(lexer.GetToken(pos));
1203 {
1204 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1205
1206 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1207 return soulng::parser::Match(true, nullptr);
1208 }
1209 }
1210 break;
1211 }
1212 case COLONCOLON:
1213 {
1214 ++lexer;
1215 {
1216 if (tokens) tokens->push_back(lexer.GetToken(pos));
1217 {
1218 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1219
1220 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1221 return soulng::parser::Match(true, nullptr);
1222 }
1223 }
1224 break;
1225 }
1226 case COMMA:
1227 {
1228 ++lexer;
1229 {
1230 if (tokens) tokens->push_back(lexer.GetToken(pos));
1231 {
1232 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1233
1234 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1235 return soulng::parser::Match(true, nullptr);
1236 }
1237 }
1238 break;
1239 }
1240 case ASSIGN:
1241 {
1242 ++lexer;
1243 {
1244 if (tokens) tokens->push_back(lexer.GetToken(pos));
1245 {
1246 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1247
1248 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1249 return soulng::parser::Match(true, nullptr);
1250 }
1251 }
1252 break;
1253 }
1254 case MULASSIGN:
1255 {
1256 ++lexer;
1257 {
1258 if (tokens) tokens->push_back(lexer.GetToken(pos));
1259 {
1260 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1261
1262 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1263 return soulng::parser::Match(true, nullptr);
1264 }
1265 }
1266 break;
1267 }
1268 case DIVASSIGN:
1269 {
1270 ++lexer;
1271 {
1272 if (tokens) tokens->push_back(lexer.GetToken(pos));
1273 {
1274 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1275
1276 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1277 return soulng::parser::Match(true, nullptr);
1278 }
1279 }
1280 break;
1281 }
1282 case REMASSIGN:
1283 {
1284 ++lexer;
1285 {
1286 if (tokens) tokens->push_back(lexer.GetToken(pos));
1287 {
1288 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1289
1290 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1291 return soulng::parser::Match(true, nullptr);
1292 }
1293 }
1294 break;
1295 }
1296 case ADDASSIGN:
1297 {
1298 ++lexer;
1299 {
1300 if (tokens) tokens->push_back(lexer.GetToken(pos));
1301 {
1302 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1303
1304 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1305 return soulng::parser::Match(true, nullptr);
1306 }
1307 }
1308 break;
1309 }
1310 case SUBASSIGN:
1311 {
1312 ++lexer;
1313 {
1314 if (tokens) tokens->push_back(lexer.GetToken(pos));
1315 {
1316 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1317
1318 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1319 return soulng::parser::Match(true, nullptr);
1320 }
1321 }
1322 break;
1323 }
1324 case SHIFTRIGHTASSIGN:
1325 {
1326 ++lexer;
1327 {
1328 if (tokens) tokens->push_back(lexer.GetToken(pos));
1329 {
1330 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1331
1332 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1333 return soulng::parser::Match(true, nullptr);
1334 }
1335 }
1336 break;
1337 }
1338 case SHIFTLEFTASSIGN:
1339 {
1340 ++lexer;
1341 {
1342 if (tokens) tokens->push_back(lexer.GetToken(pos));
1343 {
1344 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1345
1346 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1347 return soulng::parser::Match(true, nullptr);
1348 }
1349 }
1350 break;
1351 }
1352 case ANDASSIGN:
1353 {
1354 ++lexer;
1355 {
1356 if (tokens) tokens->push_back(lexer.GetToken(pos));
1357 {
1358 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1359
1360 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1361 return soulng::parser::Match(true, nullptr);
1362 }
1363 }
1364 break;
1365 }
1366 case XORASSIGN:
1367 {
1368 ++lexer;
1369 {
1370 if (tokens) tokens->push_back(lexer.GetToken(pos));
1371 {
1372 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1373
1374 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1375 return soulng::parser::Match(true, nullptr);
1376 }
1377 }
1378 break;
1379 }
1380 case ORASSIGN:
1381 {
1382 ++lexer;
1383 {
1384 if (tokens) tokens->push_back(lexer.GetToken(pos));
1385 {
1386 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1387
1388 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1389 return soulng::parser::Match(true, nullptr);
1390 }
1391 }
1392 break;
1393 }
1394 case QUEST:
1395 {
1396 ++lexer;
1397 {
1398 if (tokens) tokens->push_back(lexer.GetToken(pos));
1399 {
1400 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1401
1402 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1403 return soulng::parser::Match(true, nullptr);
1404 }
1405 }
1406 break;
1407 }
1408 case COLON:
1409 {
1410 ++lexer;
1411 {
1412 if (tokens) tokens->push_back(lexer.GetToken(pos));
1413 {
1414 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1415
1416 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1417 return soulng::parser::Match(true, nullptr);
1418 }
1419 }
1420 break;
1421 }
1422 case OROR:
1423 {
1424 ++lexer;
1425 {
1426 if (tokens) tokens->push_back(lexer.GetToken(pos));
1427 {
1428 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1429
1430 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1431 return soulng::parser::Match(true, nullptr);
1432 }
1433 }
1434 break;
1435 }
1436 case AMPAMP:
1437 {
1438 ++lexer;
1439 {
1440 if (tokens) tokens->push_back(lexer.GetToken(pos));
1441 {
1442 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1443
1444 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1445 return soulng::parser::Match(true, nullptr);
1446 }
1447 }
1448 break;
1449 }
1450 case OR:
1451 {
1452 ++lexer;
1453 {
1454 if (tokens) tokens->push_back(lexer.GetToken(pos));
1455 {
1456 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1457
1458 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1459 return soulng::parser::Match(true, nullptr);
1460 }
1461 }
1462 break;
1463 }
1464 case XOR:
1465 {
1466 ++lexer;
1467 {
1468 if (tokens) tokens->push_back(lexer.GetToken(pos));
1469 {
1470 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1471
1472 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1473 return soulng::parser::Match(true, nullptr);
1474 }
1475 }
1476 break;
1477 }
1478 case AMP:
1479 {
1480 ++lexer;
1481 {
1482 if (tokens) tokens->push_back(lexer.GetToken(pos));
1483 {
1484 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1485
1486 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1487 return soulng::parser::Match(true, nullptr);
1488 }
1489 }
1490 break;
1491 }
1492 case EQ:
1493 {
1494 ++lexer;
1495 {
1496 if (tokens) tokens->push_back(lexer.GetToken(pos));
1497 {
1498 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1499
1500 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1501 return soulng::parser::Match(true, nullptr);
1502 }
1503 }
1504 break;
1505 }
1506 case NEQ:
1507 {
1508 ++lexer;
1509 {
1510 if (tokens) tokens->push_back(lexer.GetToken(pos));
1511 {
1512 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1513
1514 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1515 return soulng::parser::Match(true, nullptr);
1516 }
1517 }
1518 break;
1519 }
1520 case LEQ:
1521 {
1522 ++lexer;
1523 {
1524 if (tokens) tokens->push_back(lexer.GetToken(pos));
1525 {
1526 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1527
1528 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1529 return soulng::parser::Match(true, nullptr);
1530 }
1531 }
1532 break;
1533 }
1534 case GEQ:
1535 {
1536 ++lexer;
1537 {
1538 if (tokens) tokens->push_back(lexer.GetToken(pos));
1539 {
1540 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1541
1542 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1543 return soulng::parser::Match(true, nullptr);
1544 }
1545 }
1546 break;
1547 }
1548 case SPACESHIP:
1549 {
1550 ++lexer;
1551 {
1552 if (tokens) tokens->push_back(lexer.GetToken(pos));
1553 {
1554 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1555
1556 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1557 return soulng::parser::Match(true, nullptr);
1558 }
1559 }
1560 break;
1561 }
1562 case LANGLE:
1563 {
1564 ++lexer;
1565 {
1566 if (tokens) tokens->push_back(lexer.GetToken(pos));
1567 {
1568 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1569
1570 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1571 return soulng::parser::Match(true, nullptr);
1572 }
1573 }
1574 break;
1575 }
1576 case RANGLE:
1577 {
1578 ++lexer;
1579 {
1580 if (tokens) tokens->push_back(lexer.GetToken(pos));
1581 {
1582 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1583
1584 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1585 return soulng::parser::Match(true, nullptr);
1586 }
1587 }
1588 break;
1589 }
1590 case SHIFTLEFT:
1591 {
1592 ++lexer;
1593 {
1594 if (tokens) tokens->push_back(lexer.GetToken(pos));
1595 {
1596 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1597
1598 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1599 return soulng::parser::Match(true, nullptr);
1600 }
1601 }
1602 break;
1603 }
1604 case SHIFTRIGHT:
1605 {
1606 ++lexer;
1607 {
1608 if (tokens) tokens->push_back(lexer.GetToken(pos));
1609 {
1610 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1611
1612 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1613 return soulng::parser::Match(true, nullptr);
1614 }
1615 }
1616 break;
1617 }
1618 case PLUS:
1619 {
1620 ++lexer;
1621 {
1622 if (tokens) tokens->push_back(lexer.GetToken(pos));
1623 {
1624 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1625
1626 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1627 return soulng::parser::Match(true, nullptr);
1628 }
1629 }
1630 break;
1631 }
1632 case MINUS:
1633 {
1634 ++lexer;
1635 {
1636 if (tokens) tokens->push_back(lexer.GetToken(pos));
1637 {
1638 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1639
1640 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1641 return soulng::parser::Match(true, nullptr);
1642 }
1643 }
1644 break;
1645 }
1646 case STAR:
1647 {
1648 ++lexer;
1649 {
1650 if (tokens) tokens->push_back(lexer.GetToken(pos));
1651 {
1652 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1653
1654 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1655 return soulng::parser::Match(true, nullptr);
1656 }
1657 }
1658 break;
1659 }
1660 case DIV:
1661 {
1662 ++lexer;
1663 {
1664 if (tokens) tokens->push_back(lexer.GetToken(pos));
1665 {
1666 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1667
1668 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1669 return soulng::parser::Match(true, nullptr);
1670 }
1671 }
1672 break;
1673 }
1674 case MOD:
1675 {
1676 ++lexer;
1677 {
1678 if (tokens) tokens->push_back(lexer.GetToken(pos));
1679 {
1680 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1681
1682 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1683 return soulng::parser::Match(true, nullptr);
1684 }
1685 }
1686 break;
1687 }
1688 case DOTSTAR:
1689 {
1690 ++lexer;
1691 {
1692 if (tokens) tokens->push_back(lexer.GetToken(pos));
1693 {
1694 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1695
1696 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1697 return soulng::parser::Match(true, nullptr);
1698 }
1699 }
1700 break;
1701 }
1702 case ARROWSTAR:
1703 {
1704 ++lexer;
1705 {
1706 if (tokens) tokens->push_back(lexer.GetToken(pos));
1707 {
1708 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1709
1710 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1711 return soulng::parser::Match(true, nullptr);
1712 }
1713 }
1714 break;
1715 }
1716 case LPAREN:
1717 {
1718 ++lexer;
1719 {
1720 if (tokens) tokens->push_back(lexer.GetToken(pos));
1721 {
1722 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1723
1724 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1725 return soulng::parser::Match(true, nullptr);
1726 }
1727 }
1728 break;
1729 }
1730 case RPAREN:
1731 {
1732 ++lexer;
1733 {
1734 if (tokens) tokens->push_back(lexer.GetToken(pos));
1735 {
1736 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1737
1738 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1739 return soulng::parser::Match(true, nullptr);
1740 }
1741 }
1742 break;
1743 }
1744 case PLUSPLUS:
1745 {
1746 ++lexer;
1747 {
1748 if (tokens) tokens->push_back(lexer.GetToken(pos));
1749 {
1750 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1751
1752 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1753 return soulng::parser::Match(true, nullptr);
1754 }
1755 }
1756 break;
1757 }
1758 case MINUSMINUS:
1759 {
1760 ++lexer;
1761 {
1762 if (tokens) tokens->push_back(lexer.GetToken(pos));
1763 {
1764 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1765
1766 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1767 return soulng::parser::Match(true, nullptr);
1768 }
1769 }
1770 break;
1771 }
1772 case EXCLAMATION:
1773 {
1774 ++lexer;
1775 {
1776 if (tokens) tokens->push_back(lexer.GetToken(pos));
1777 {
1778 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1779
1780 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1781 return soulng::parser::Match(true, nullptr);
1782 }
1783 }
1784 break;
1785 }
1786 case TILDE:
1787 {
1788 ++lexer;
1789 {
1790 if (tokens) tokens->push_back(lexer.GetToken(pos));
1791 {
1792 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1793
1794 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1795 return soulng::parser::Match(true, nullptr);
1796 }
1797 }
1798 break;
1799 }
1800 case LBRACKET:
1801 {
1802 ++lexer;
1803 {
1804 if (tokens) tokens->push_back(lexer.GetToken(pos));
1805 {
1806 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1807
1808 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1809 return soulng::parser::Match(true, nullptr);
1810 }
1811 }
1812 break;
1813 }
1814 case RBRACKET:
1815 {
1816 ++lexer;
1817 {
1818 if (tokens) tokens->push_back(lexer.GetToken(pos));
1819 {
1820 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1821
1822 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1823 return soulng::parser::Match(true, nullptr);
1824 }
1825 }
1826 break;
1827 }
1828 case DOT:
1829 {
1830 ++lexer;
1831 {
1832 if (tokens) tokens->push_back(lexer.GetToken(pos));
1833 {
1834 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1835
1836 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1837 return soulng::parser::Match(true, nullptr);
1838 }
1839 }
1840 break;
1841 }
1842 case ARROW:
1843 {
1844 ++lexer;
1845 {
1846 if (tokens) tokens->push_back(lexer.GetToken(pos));
1847 {
1848 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1849
1850 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1851 return soulng::parser::Match(true, nullptr);
1852 }
1853 }
1854 break;
1855 }
1856 case SEMICOLON:
1857 {
1858 ++lexer;
1859 {
1860 if (tokens) tokens->push_back(lexer.GetToken(pos));
1861 {
1862 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1863
1864 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1865 return soulng::parser::Match(true, nullptr);
1866 }
1867 }
1868 break;
1869 }
1870 case ELLIPSES:
1871 {
1872 ++lexer;
1873 {
1874 if (tokens) tokens->push_back(lexer.GetToken(pos));
1875 {
1876 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1877
1878 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1879 return soulng::parser::Match(true, nullptr);
1880 }
1881 }
1882 break;
1883 }
1884 }
1885 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1886
1887
1888
1889
1890
1891 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1892 if (!match.hit)
1893 {
1894 match.value = nullptr;
1895 }
1896 return match;
1897 }