1 using System;
2 using System.Collections;
3 using System.Lex;
4 using System.Parsing;
5 using Cm.Ast;
6 using ParserFileTokens;
7
8
9
10 public static class ExpressionParser
11 {
12 public static Match Expression(ParserFileLexer& lexer, ParsingContext* ctx)
13 {
14 #if (DEBUG)
15 Span debugSpan;
16 bool writeToLog = lexer.Log() != null;
17 if (writeToLog)
18 {
19 debugSpan = lexer.GetSpan();
20 System.Lex.WriteBeginRuleToLog(lexer, u"Expression");
21 }
22 #endif
23 UniquePtr<Node> equivalence;
24 Match match(false);
25 Match* parentMatch0 = &match;
26 {
27 long pos = lexer.GetPos();
28 Match match = ExpressionParser.Equivalence(lexer, ctx);
29 equivalence.Reset(cast<Node*>(match.value));
30 if (match.hit)
31 {
32 {
33 #if (DEBUG)
34 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Expression");
35 #endif
36 return Match(true, equivalence.Release());
37 }
38 }
39 *parentMatch0 = match;
40 }
41 #if (DEBUG)
42 if (writeToLog)
43 {
44 if (match.hit)
45 {
46 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Expression");
47 }
48 else
49 {
50 System.Lex.WriteFailureToLog(lexer, u"Expression");
51 }
52 }
53 #endif
54 if (!match.hit)
55 {
56 match.value = null;
57 }
58 return match;
59 }
60 public static Match Equivalence(ParserFileLexer& lexer, ParsingContext* ctx)
61 {
62 #if (DEBUG)
63 Span debugSpan;
64 bool writeToLog = lexer.Log() != null;
65 if (writeToLog)
66 {
67 debugSpan = lexer.GetSpan();
68 System.Lex.WriteBeginRuleToLog(lexer, u"Equivalence");
69 }
70 #endif
71 UniquePtr<Node> expr;
72 Span s;
73 UniquePtr<Node> left;
74 UniquePtr<Node> right;
75 Match match(false);
76 Match* parentMatch0 = &match;
77 {
78 long pos = lexer.GetPos();
79 Match match(false);
80 Match* parentMatch1 = &match;
81 {
82 Match match(false);
83 Match* parentMatch2 = &match;
84 {
85 Match match(false);
86 Match* parentMatch3 = &match;
87 {
88 long pos = lexer.GetPos();
89 Span span = lexer.GetSpan();
90 Match match = ExpressionParser.Implication(lexer, ctx);
91 left.Reset(cast<Node*>(match.value));
92 if (match.hit)
93 {
94 s = span;
95 expr.Reset(left.Release());
96 }
97 *parentMatch3 = match;
98 }
99 *parentMatch2 = match;
100 }
101 if (match.hit)
102 {
103 Match match(false);
104 Match* parentMatch4 = &match;
105 {
106 Match match(true);
107 Match* parentMatch5 = &match;
108 {
109 while (true)
110 {
111 long save = lexer.GetPos();
112 {
113 Match match(false);
114 Match* parentMatch6 = &match;
115 {
116 Match match(false);
117 Match* parentMatch7 = &match;
118 {
119 Match match(false);
120 Match* parentMatch8 = &match;
121 {
122 long pos = lexer.GetPos();
123 bool pass = true;
124 Match match(false);
125 if (*lexer == EQUIVALENCE)
126 {
127 ++lexer;
128 match.hit = true;
129 }
130 if (match.hit)
131 {
132 if (!ctx->parsingConcept || ctx->parsingTemplateId) pass = false;
133 }
134 if (match.hit && !pass)
135 {
136 match = Match(false);
137 }
138 *parentMatch8 = match;
139 }
140 *parentMatch7 = match;
141 }
142 if (match.hit)
143 {
144 Match match(false);
145 Match* parentMatch9 = &match;
146 {
147 Match match(false);
148 Match* parentMatch10 = &match;
149 {
150 long pos = lexer.GetPos();
151 Span span = lexer.GetSpan();
152 Match match(true);
153 Match* parentMatch11 = &match;
154 {
155 System.Lex.Span span = lexer.GetSpan();
156 Match match = ExpressionParser.Implication(lexer, ctx);
157 right.Reset(cast<Node*>(match.value));
158 if (match.hit)
159 {
160 *parentMatch11 = match;
161 }
162 else
163 {
164 lexer.ThrowExpectationFailure(span, u"implication expression");
165 }
166 }
167 if (match.hit)
168 {
169 s.end = span.end;
170 expr.Reset(new EquivalenceNode(s, ctx->ModuleId(), expr.Release(), right.Release()));
171 }
172 *parentMatch10 = match;
173 }
174 *parentMatch9 = match;
175 }
176 *parentMatch7 = match;
177 }
178 *parentMatch6 = match;
179 }
180 if (match.hit)
181 {
182 *parentMatch5 = match;
183 }
184 else
185 {
186 lexer.SetPos(save);
187 break;
188 }
189 }
190 }
191 }
192 *parentMatch4 = match;
193 }
194 *parentMatch2 = match;
195 }
196 *parentMatch1 = match;
197 }
198 if (match.hit)
199 {
200 {
201 #if (DEBUG)
202 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Equivalence");
203 #endif
204 return Match(true, expr.Release());
205 }
206 }
207 *parentMatch0 = match;
208 }
209 #if (DEBUG)
210 if (writeToLog)
211 {
212 if (match.hit)
213 {
214 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Equivalence");
215 }
216 else
217 {
218 System.Lex.WriteFailureToLog(lexer, u"Equivalence");
219 }
220 }
221 #endif
222 if (!match.hit)
223 {
224 match.value = null;
225 }
226 return match;
227 }
228 public static Match Implication(ParserFileLexer& lexer, ParsingContext* ctx)
229 {
230 #if (DEBUG)
231 Span debugSpan;
232 bool writeToLog = lexer.Log() != null;
233 if (writeToLog)
234 {
235 debugSpan = lexer.GetSpan();
236 System.Lex.WriteBeginRuleToLog(lexer, u"Implication");
237 }
238 #endif
239 UniquePtr<Node> expr;
240 Span s;
241 UniquePtr<Node> left;
242 UniquePtr<Node> right;
243 Match match(false);
244 Match* parentMatch0 = &match;
245 {
246 long pos = lexer.GetPos();
247 Match match(false);
248 Match* parentMatch1 = &match;
249 {
250 Match match(false);
251 Match* parentMatch2 = &match;
252 {
253 Match match(false);
254 Match* parentMatch3 = &match;
255 {
256 long pos = lexer.GetPos();
257 Span span = lexer.GetSpan();
258 Match match = ExpressionParser.Disjunction(lexer, ctx);
259 left.Reset(cast<Node*>(match.value));
260 if (match.hit)
261 {
262 s = span;
263 expr.Reset(left.Release());
264 }
265 *parentMatch3 = match;
266 }
267 *parentMatch2 = match;
268 }
269 if (match.hit)
270 {
271 Match match(false);
272 Match* parentMatch4 = &match;
273 {
274 Match match(true);
275 long save = lexer.GetPos();
276 Match* parentMatch5 = &match;
277 {
278 Match match(false);
279 Match* parentMatch6 = &match;
280 {
281 Match match(false);
282 Match* parentMatch7 = &match;
283 {
284 Match match(false);
285 Match* parentMatch8 = &match;
286 {
287 long pos = lexer.GetPos();
288 bool pass = true;
289 Match match(false);
290 if (*lexer == IMPLICATION)
291 {
292 ++lexer;
293 match.hit = true;
294 }
295 if (match.hit)
296 {
297 if (!ctx->parsingConcept || ctx->parsingTemplateId) pass = false;
298 }
299 if (match.hit && !pass)
300 {
301 match = Match(false);
302 }
303 *parentMatch8 = match;
304 }
305 *parentMatch7 = match;
306 }
307 if (match.hit)
308 {
309 Match match(false);
310 Match* parentMatch9 = &match;
311 {
312 Match match(false);
313 Match* parentMatch10 = &match;
314 {
315 long pos = lexer.GetPos();
316 Span span = lexer.GetSpan();
317 Match match(true);
318 Match* parentMatch11 = &match;
319 {
320 System.Lex.Span span = lexer.GetSpan();
321 Match match = ExpressionParser.Implication(lexer, ctx);
322 right.Reset(cast<Node*>(match.value));
323 if (match.hit)
324 {
325 *parentMatch11 = match;
326 }
327 else
328 {
329 lexer.ThrowExpectationFailure(span, u"implication expression");
330 }
331 }
332 if (match.hit)
333 {
334 s.end = span.end;
335 expr.Reset(new ImplicationNode(s, ctx->ModuleId(), expr.Release(), right.Release()));
336 }
337 *parentMatch10 = match;
338 }
339 *parentMatch9 = match;
340 }
341 *parentMatch7 = match;
342 }
343 *parentMatch6 = match;
344 }
345 if (match.hit)
346 {
347 *parentMatch5 = match;
348 }
349 else
350 {
351 lexer.SetPos(save);
352 }
353 }
354 *parentMatch4 = match;
355 }
356 *parentMatch2 = match;
357 }
358 *parentMatch1 = match;
359 }
360 if (match.hit)
361 {
362 {
363 #if (DEBUG)
364 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Implication");
365 #endif
366 return Match(true, expr.Release());
367 }
368 }
369 *parentMatch0 = match;
370 }
371 #if (DEBUG)
372 if (writeToLog)
373 {
374 if (match.hit)
375 {
376 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Implication");
377 }
378 else
379 {
380 System.Lex.WriteFailureToLog(lexer, u"Implication");
381 }
382 }
383 #endif
384 if (!match.hit)
385 {
386 match.value = null;
387 }
388 return match;
389 }
390 public static Match Disjunction(ParserFileLexer& lexer, ParsingContext* ctx)
391 {
392 #if (DEBUG)
393 Span debugSpan;
394 bool writeToLog = lexer.Log() != null;
395 if (writeToLog)
396 {
397 debugSpan = lexer.GetSpan();
398 System.Lex.WriteBeginRuleToLog(lexer, u"Disjunction");
399 }
400 #endif
401 UniquePtr<Node> expr;
402 Span s;
403 UniquePtr<Node> left;
404 UniquePtr<Node> right;
405 Match match(false);
406 Match* parentMatch0 = &match;
407 {
408 long pos = lexer.GetPos();
409 Match match(false);
410 Match* parentMatch1 = &match;
411 {
412 Match match(false);
413 Match* parentMatch2 = &match;
414 {
415 Match match(false);
416 Match* parentMatch3 = &match;
417 {
418 long pos = lexer.GetPos();
419 Span span = lexer.GetSpan();
420 Match match = ExpressionParser.Conjunction(lexer, ctx);
421 left.Reset(cast<Node*>(match.value));
422 if (match.hit)
423 {
424 s = span;
425 expr.Reset(left.Release());
426 }
427 *parentMatch3 = match;
428 }
429 *parentMatch2 = match;
430 }
431 if (match.hit)
432 {
433 Match match(false);
434 Match* parentMatch4 = &match;
435 {
436 Match match(true);
437 Match* parentMatch5 = &match;
438 {
439 while (true)
440 {
441 long save = lexer.GetPos();
442 {
443 Match match(false);
444 Match* parentMatch6 = &match;
445 {
446 Match match(false);
447 Match* parentMatch7 = &match;
448 {
449 Match match(false);
450 Match* parentMatch8 = &match;
451 {
452 long pos = lexer.GetPos();
453 bool pass = true;
454 Match match(false);
455 if (*lexer == DISJUNCTION)
456 {
457 ++lexer;
458 match.hit = true;
459 }
460 if (match.hit)
461 {
462 if (ctx->parsingLvalue || ctx->parsingExpressionStatement && !ctx->parsingArguments) pass = false;
463 }
464 if (match.hit && !pass)
465 {
466 match = Match(false);
467 }
468 *parentMatch8 = match;
469 }
470 *parentMatch7 = match;
471 }
472 if (match.hit)
473 {
474 Match match(false);
475 Match* parentMatch9 = &match;
476 {
477 Match match(false);
478 Match* parentMatch10 = &match;
479 {
480 long pos = lexer.GetPos();
481 Span span = lexer.GetSpan();
482 Match match(true);
483 Match* parentMatch11 = &match;
484 {
485 System.Lex.Span span = lexer.GetSpan();
486 Match match = ExpressionParser.Conjunction(lexer, ctx);
487 right.Reset(cast<Node*>(match.value));
488 if (match.hit)
489 {
490 *parentMatch11 = match;
491 }
492 else
493 {
494 lexer.ThrowExpectationFailure(span, u"conjunctive expression");
495 }
496 }
497 if (match.hit)
498 {
499 s.end = span.end;
500 expr.Reset(new DisjunctionNode(s, ctx->ModuleId(), expr.Release(), right.Release()));
501 }
502 *parentMatch10 = match;
503 }
504 *parentMatch9 = match;
505 }
506 *parentMatch7 = match;
507 }
508 *parentMatch6 = match;
509 }
510 if (match.hit)
511 {
512 *parentMatch5 = match;
513 }
514 else
515 {
516 lexer.SetPos(save);
517 break;
518 }
519 }
520 }
521 }
522 *parentMatch4 = match;
523 }
524 *parentMatch2 = match;
525 }
526 *parentMatch1 = match;
527 }
528 if (match.hit)
529 {
530 {
531 #if (DEBUG)
532 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Disjunction");
533 #endif
534 return Match(true, expr.Release());
535 }
536 }
537 *parentMatch0 = match;
538 }
539 #if (DEBUG)
540 if (writeToLog)
541 {
542 if (match.hit)
543 {
544 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Disjunction");
545 }
546 else
547 {
548 System.Lex.WriteFailureToLog(lexer, u"Disjunction");
549 }
550 }
551 #endif
552 if (!match.hit)
553 {
554 match.value = null;
555 }
556 return match;
557 }
558 public static Match Conjunction(ParserFileLexer& lexer, ParsingContext* ctx)
559 {
560 #if (DEBUG)
561 Span debugSpan;
562 bool writeToLog = lexer.Log() != null;
563 if (writeToLog)
564 {
565 debugSpan = lexer.GetSpan();
566 System.Lex.WriteBeginRuleToLog(lexer, u"Conjunction");
567 }
568 #endif
569 UniquePtr<Node> expr;
570 Span s;
571 UniquePtr<Node> left;
572 UniquePtr<Node> right;
573 Match match(false);
574 Match* parentMatch0 = &match;
575 {
576 long pos = lexer.GetPos();
577 Match match(false);
578 Match* parentMatch1 = &match;
579 {
580 Match match(false);
581 Match* parentMatch2 = &match;
582 {
583 Match match(false);
584 Match* parentMatch3 = &match;
585 {
586 long pos = lexer.GetPos();
587 Span span = lexer.GetSpan();
588 Match match = ExpressionParser.BitOr(lexer, ctx);
589 left.Reset(cast<Node*>(match.value));
590 if (match.hit)
591 {
592 s = span;
593 expr.Reset(left.Release());
594 }
595 *parentMatch3 = match;
596 }
597 *parentMatch2 = match;
598 }
599 if (match.hit)
600 {
601 Match match(false);
602 Match* parentMatch4 = &match;
603 {
604 Match match(true);
605 Match* parentMatch5 = &match;
606 {
607 while (true)
608 {
609 long save = lexer.GetPos();
610 {
611 Match match(false);
612 Match* parentMatch6 = &match;
613 {
614 Match match(false);
615 Match* parentMatch7 = &match;
616 {
617 Match match(false);
618 Match* parentMatch8 = &match;
619 {
620 long pos = lexer.GetPos();
621 bool pass = true;
622 Match match(false);
623 if (*lexer == AMPAMP)
624 {
625 ++lexer;
626 match.hit = true;
627 }
628 if (match.hit)
629 {
630 if (ctx->parsingLvalue || ctx->parsingExpressionStatement && !ctx->parsingArguments) pass = false;
631 }
632 if (match.hit && !pass)
633 {
634 match = Match(false);
635 }
636 *parentMatch8 = match;
637 }
638 *parentMatch7 = match;
639 }
640 if (match.hit)
641 {
642 Match match(false);
643 Match* parentMatch9 = &match;
644 {
645 Match match(false);
646 Match* parentMatch10 = &match;
647 {
648 long pos = lexer.GetPos();
649 Span span = lexer.GetSpan();
650 Match match(true);
651 Match* parentMatch11 = &match;
652 {
653 System.Lex.Span span = lexer.GetSpan();
654 Match match = ExpressionParser.BitOr(lexer, ctx);
655 right.Reset(cast<Node*>(match.value));
656 if (match.hit)
657 {
658 *parentMatch11 = match;
659 }
660 else
661 {
662 lexer.ThrowExpectationFailure(span, u"bitwise or expression ");
663 }
664 }
665 if (match.hit)
666 {
667 s.end = span.end;
668 expr.Reset(new ConjunctionNode(s, ctx->ModuleId(), expr.Release(), right.Release()));
669 }
670 *parentMatch10 = match;
671 }
672 *parentMatch9 = match;
673 }
674 *parentMatch7 = match;
675 }
676 *parentMatch6 = match;
677 }
678 if (match.hit)
679 {
680 *parentMatch5 = match;
681 }
682 else
683 {
684 lexer.SetPos(save);
685 break;
686 }
687 }
688 }
689 }
690 *parentMatch4 = match;
691 }
692 *parentMatch2 = match;
693 }
694 *parentMatch1 = match;
695 }
696 if (match.hit)
697 {
698 {
699 #if (DEBUG)
700 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Conjunction");
701 #endif
702 return Match(true, expr.Release());
703 }
704 }
705 *parentMatch0 = match;
706 }
707 #if (DEBUG)
708 if (writeToLog)
709 {
710 if (match.hit)
711 {
712 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Conjunction");
713 }
714 else
715 {
716 System.Lex.WriteFailureToLog(lexer, u"Conjunction");
717 }
718 }
719 #endif
720 if (!match.hit)
721 {
722 match.value = null;
723 }
724 return match;
725 }
726 public static Match BitOr(ParserFileLexer& lexer, ParsingContext* ctx)
727 {
728 #if (DEBUG)
729 Span debugSpan;
730 bool writeToLog = lexer.Log() != null;
731 if (writeToLog)
732 {
733 debugSpan = lexer.GetSpan();
734 System.Lex.WriteBeginRuleToLog(lexer, u"BitOr");
735 }
736 #endif
737 UniquePtr<Node> expr;
738 Span s;
739 UniquePtr<Node> left;
740 UniquePtr<Node> right;
741 Match match(false);
742 Match* parentMatch0 = &match;
743 {
744 long pos = lexer.GetPos();
745 Match match(false);
746 Match* parentMatch1 = &match;
747 {
748 Match match(false);
749 Match* parentMatch2 = &match;
750 {
751 Match match(false);
752 Match* parentMatch3 = &match;
753 {
754 long pos = lexer.GetPos();
755 Span span = lexer.GetSpan();
756 Match match = ExpressionParser.BitXor(lexer, ctx);
757 left.Reset(cast<Node*>(match.value));
758 if (match.hit)
759 {
760 s = span;
761 expr.Reset(left.Release());
762 }
763 *parentMatch3 = match;
764 }
765 *parentMatch2 = match;
766 }
767 if (match.hit)
768 {
769 Match match(false);
770 Match* parentMatch4 = &match;
771 {
772 Match match(true);
773 Match* parentMatch5 = &match;
774 {
775 while (true)
776 {
777 long save = lexer.GetPos();
778 {
779 Match match(false);
780 Match* parentMatch6 = &match;
781 {
782 Match match(false);
783 Match* parentMatch7 = &match;
784 {
785 Match match(false);
786 Match* parentMatch8 = &match;
787 {
788 long pos = lexer.GetPos();
789 bool pass = true;
790 Match match(false);
791 if (*lexer == BITOR)
792 {
793 ++lexer;
794 match.hit = true;
795 }
796 if (match.hit)
797 {
798 if (ctx->parsingLvalue || ctx->parsingExpressionStatement && !ctx->parsingArguments) pass = false;
799 }
800 if (match.hit && !pass)
801 {
802 match = Match(false);
803 }
804 *parentMatch8 = match;
805 }
806 *parentMatch7 = match;
807 }
808 if (match.hit)
809 {
810 Match match(false);
811 Match* parentMatch9 = &match;
812 {
813 Match match(false);
814 Match* parentMatch10 = &match;
815 {
816 long pos = lexer.GetPos();
817 Span span = lexer.GetSpan();
818 Match match(true);
819 Match* parentMatch11 = &match;
820 {
821 System.Lex.Span span = lexer.GetSpan();
822 Match match = ExpressionParser.BitXor(lexer, ctx);
823 right.Reset(cast<Node*>(match.value));
824 if (match.hit)
825 {
826 *parentMatch11 = match;
827 }
828 else
829 {
830 lexer.ThrowExpectationFailure(span, u"bitwise exclusive or expression");
831 }
832 }
833 if (match.hit)
834 {
835 s.end = span.end;
836 expr.Reset(new BitOrNode(s, ctx->ModuleId(), expr.Release(), right.Release()));
837 }
838 *parentMatch10 = match;
839 }
840 *parentMatch9 = match;
841 }
842 *parentMatch7 = match;
843 }
844 *parentMatch6 = match;
845 }
846 if (match.hit)
847 {
848 *parentMatch5 = match;
849 }
850 else
851 {
852 lexer.SetPos(save);
853 break;
854 }
855 }
856 }
857 }
858 *parentMatch4 = match;
859 }
860 *parentMatch2 = match;
861 }
862 *parentMatch1 = match;
863 }
864 if (match.hit)
865 {
866 {
867 #if (DEBUG)
868 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"BitOr");
869 #endif
870 return Match(true, expr.Release());
871 }
872 }
873 *parentMatch0 = match;
874 }
875 #if (DEBUG)
876 if (writeToLog)
877 {
878 if (match.hit)
879 {
880 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"BitOr");
881 }
882 else
883 {
884 System.Lex.WriteFailureToLog(lexer, u"BitOr");
885 }
886 }
887 #endif
888 if (!match.hit)
889 {
890 match.value = null;
891 }
892 return match;
893 }
894 public static Match BitXor(ParserFileLexer& lexer, ParsingContext* ctx)
895 {
896 #if (DEBUG)
897 Span debugSpan;
898 bool writeToLog = lexer.Log() != null;
899 if (writeToLog)
900 {
901 debugSpan = lexer.GetSpan();
902 System.Lex.WriteBeginRuleToLog(lexer, u"BitXor");
903 }
904 #endif
905 UniquePtr<Node> expr;
906 Span s;
907 UniquePtr<Node> left;
908 UniquePtr<Node> right;
909 Match match(false);
910 Match* parentMatch0 = &match;
911 {
912 long pos = lexer.GetPos();
913 Match match(false);
914 Match* parentMatch1 = &match;
915 {
916 Match match(false);
917 Match* parentMatch2 = &match;
918 {
919 Match match(false);
920 Match* parentMatch3 = &match;
921 {
922 long pos = lexer.GetPos();
923 Span span = lexer.GetSpan();
924 Match match = ExpressionParser.BitAnd(lexer, ctx);
925 left.Reset(cast<Node*>(match.value));
926 if (match.hit)
927 {
928 s = span;
929 expr.Reset(left.Release());
930 }
931 *parentMatch3 = match;
932 }
933 *parentMatch2 = match;
934 }
935 if (match.hit)
936 {
937 Match match(false);
938 Match* parentMatch4 = &match;
939 {
940 Match match(true);
941 Match* parentMatch5 = &match;
942 {
943 while (true)
944 {
945 long save = lexer.GetPos();
946 {
947 Match match(false);
948 Match* parentMatch6 = &match;
949 {
950 Match match(false);
951 Match* parentMatch7 = &match;
952 {
953 Match match(false);
954 Match* parentMatch8 = &match;
955 {
956 long pos = lexer.GetPos();
957 bool pass = true;
958 Match match(false);
959 if (*lexer == BITXOR)
960 {
961 ++lexer;
962 match.hit = true;
963 }
964 if (match.hit)
965 {
966 if (ctx->parsingLvalue || ctx->parsingExpressionStatement && !ctx->parsingArguments) pass = false;
967 }
968 if (match.hit && !pass)
969 {
970 match = Match(false);
971 }
972 *parentMatch8 = match;
973 }
974 *parentMatch7 = match;
975 }
976 if (match.hit)
977 {
978 Match match(false);
979 Match* parentMatch9 = &match;
980 {
981 Match match(false);
982 Match* parentMatch10 = &match;
983 {
984 long pos = lexer.GetPos();
985 Span span = lexer.GetSpan();
986 Match match(true);
987 Match* parentMatch11 = &match;
988 {
989 System.Lex.Span span = lexer.GetSpan();
990 Match match = ExpressionParser.BitAnd(lexer, ctx);
991 right.Reset(cast<Node*>(match.value));
992 if (match.hit)
993 {
994 *parentMatch11 = match;
995 }
996 else
997 {
998 lexer.ThrowExpectationFailure(span, u"bitwise and expression");
999 }
1000 }
1001 if (match.hit)
1002 {
1003 s.end = span.end;
1004 expr.Reset(new BitXorNode(s, ctx->ModuleId(), expr.Release(), right.Release()));
1005 }
1006 *parentMatch10 = match;
1007 }
1008 *parentMatch9 = match;
1009 }
1010 *parentMatch7 = match;
1011 }
1012 *parentMatch6 = match;
1013 }
1014 if (match.hit)
1015 {
1016 *parentMatch5 = match;
1017 }
1018 else
1019 {
1020 lexer.SetPos(save);
1021 break;
1022 }
1023 }
1024 }
1025 }
1026 *parentMatch4 = match;
1027 }
1028 *parentMatch2 = match;
1029 }
1030 *parentMatch1 = match;
1031 }
1032 if (match.hit)
1033 {
1034 {
1035 #if (DEBUG)
1036 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"BitXor");
1037 #endif
1038 return Match(true, expr.Release());
1039 }
1040 }
1041 *parentMatch0 = match;
1042 }
1043 #if (DEBUG)
1044 if (writeToLog)
1045 {
1046 if (match.hit)
1047 {
1048 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"BitXor");
1049 }
1050 else
1051 {
1052 System.Lex.WriteFailureToLog(lexer, u"BitXor");
1053 }
1054 }
1055 #endif
1056 if (!match.hit)
1057 {
1058 match.value = null;
1059 }
1060 return match;
1061 }
1062 public static Match BitAnd(ParserFileLexer& lexer, ParsingContext* ctx)
1063 {
1064 #if (DEBUG)
1065 Span debugSpan;
1066 bool writeToLog = lexer.Log() != null;
1067 if (writeToLog)
1068 {
1069 debugSpan = lexer.GetSpan();
1070 System.Lex.WriteBeginRuleToLog(lexer, u"BitAnd");
1071 }
1072 #endif
1073 UniquePtr<Node> expr;
1074 Span s;
1075 UniquePtr<Node> left;
1076 UniquePtr<Node> right;
1077 Match match(false);
1078 Match* parentMatch0 = &match;
1079 {
1080 long pos = lexer.GetPos();
1081 Match match(false);
1082 Match* parentMatch1 = &match;
1083 {
1084 Match match(false);
1085 Match* parentMatch2 = &match;
1086 {
1087 Match match(false);
1088 Match* parentMatch3 = &match;
1089 {
1090 long pos = lexer.GetPos();
1091 Span span = lexer.GetSpan();
1092 Match match = ExpressionParser.Equality(lexer, ctx);
1093 left.Reset(cast<Node*>(match.value));
1094 if (match.hit)
1095 {
1096 s = span;
1097 expr.Reset(left.Release());
1098 }
1099 *parentMatch3 = match;
1100 }
1101 *parentMatch2 = match;
1102 }
1103 if (match.hit)
1104 {
1105 Match match(false);
1106 Match* parentMatch4 = &match;
1107 {
1108 Match match(true);
1109 Match* parentMatch5 = &match;
1110 {
1111 while (true)
1112 {
1113 long save = lexer.GetPos();
1114 {
1115 Match match(false);
1116 Match* parentMatch6 = &match;
1117 {
1118 Match match(false);
1119 Match* parentMatch7 = &match;
1120 {
1121 Match match(false);
1122 Match* parentMatch8 = &match;
1123 {
1124 long pos = lexer.GetPos();
1125 bool pass = true;
1126 Match match(false);
1127 if (*lexer == AMP)
1128 {
1129 ++lexer;
1130 match.hit = true;
1131 }
1132 if (match.hit)
1133 {
1134 if (ctx->parsingLvalue || ctx->parsingExpressionStatement && !ctx->parsingArguments) pass = false;
1135 }
1136 if (match.hit && !pass)
1137 {
1138 match = Match(false);
1139 }
1140 *parentMatch8 = match;
1141 }
1142 *parentMatch7 = match;
1143 }
1144 if (match.hit)
1145 {
1146 Match match(false);
1147 Match* parentMatch9 = &match;
1148 {
1149 Match match(false);
1150 Match* parentMatch10 = &match;
1151 {
1152 long pos = lexer.GetPos();
1153 Span span = lexer.GetSpan();
1154 Match match(true);
1155 Match* parentMatch11 = &match;
1156 {
1157 System.Lex.Span span = lexer.GetSpan();
1158 Match match = ExpressionParser.Equality(lexer, ctx);
1159 right.Reset(cast<Node*>(match.value));
1160 if (match.hit)
1161 {
1162 *parentMatch11 = match;
1163 }
1164 else
1165 {
1166 lexer.ThrowExpectationFailure(span, u"equality expression");
1167 }
1168 }
1169 if (match.hit)
1170 {
1171 s.end = span.end;
1172 expr.Reset(new BitAndNode(s, ctx->ModuleId(), expr.Release(), right.Release()));
1173 }
1174 *parentMatch10 = match;
1175 }
1176 *parentMatch9 = match;
1177 }
1178 *parentMatch7 = match;
1179 }
1180 *parentMatch6 = match;
1181 }
1182 if (match.hit)
1183 {
1184 *parentMatch5 = match;
1185 }
1186 else
1187 {
1188 lexer.SetPos(save);
1189 break;
1190 }
1191 }
1192 }
1193 }
1194 *parentMatch4 = match;
1195 }
1196 *parentMatch2 = match;
1197 }
1198 *parentMatch1 = match;
1199 }
1200 if (match.hit)
1201 {
1202 {
1203 #if (DEBUG)
1204 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"BitAnd");
1205 #endif
1206 return Match(true, expr.Release());
1207 }
1208 }
1209 *parentMatch0 = match;
1210 }
1211 #if (DEBUG)
1212 if (writeToLog)
1213 {
1214 if (match.hit)
1215 {
1216 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"BitAnd");
1217 }
1218 else
1219 {
1220 System.Lex.WriteFailureToLog(lexer, u"BitAnd");
1221 }
1222 }
1223 #endif
1224 if (!match.hit)
1225 {
1226 match.value = null;
1227 }
1228 return match;
1229 }
1230 public static Match Equality(ParserFileLexer& lexer, ParsingContext* ctx)
1231 {
1232 #if (DEBUG)
1233 Span debugSpan;
1234 bool writeToLog = lexer.Log() != null;
1235 if (writeToLog)
1236 {
1237 debugSpan = lexer.GetSpan();
1238 System.Lex.WriteBeginRuleToLog(lexer, u"Equality");
1239 }
1240 #endif
1241 UniquePtr<Node> expr;
1242 Span s;
1243 Operator op;
1244 UniquePtr<Node> left;
1245 UniquePtr<Node> right;
1246 Match match(false);
1247 Match* parentMatch0 = &match;
1248 {
1249 long pos = lexer.GetPos();
1250 Match match(false);
1251 Match* parentMatch1 = &match;
1252 {
1253 Match match(false);
1254 Match* parentMatch2 = &match;
1255 {
1256 Match match(false);
1257 Match* parentMatch3 = &match;
1258 {
1259 long pos = lexer.GetPos();
1260 Span span = lexer.GetSpan();
1261 Match match = ExpressionParser.Relational(lexer, ctx);
1262 left.Reset(cast<Node*>(match.value));
1263 if (match.hit)
1264 {
1265 s = span;
1266 expr.Reset(left.Release());
1267 }
1268 *parentMatch3 = match;
1269 }
1270 *parentMatch2 = match;
1271 }
1272 if (match.hit)
1273 {
1274 Match match(false);
1275 Match* parentMatch4 = &match;
1276 {
1277 Match match(true);
1278 Match* parentMatch5 = &match;
1279 {
1280 while (true)
1281 {
1282 long save = lexer.GetPos();
1283 {
1284 Match match(false);
1285 Match* parentMatch6 = &match;
1286 {
1287 Match match(false);
1288 Match* parentMatch7 = &match;
1289 {
1290 Match match(false);
1291 Match* parentMatch8 = &match;
1292 {
1293 Match match(false);
1294 Match* parentMatch9 = &match;
1295 {
1296 long save = lexer.GetPos();
1297 Match match(false);
1298 Match* parentMatch10 = &match;
1299 {
1300 long pos = lexer.GetPos();
1301 bool pass = true;
1302 Match match(false);
1303 if (*lexer == EQ)
1304 {
1305 ++lexer;
1306 match.hit = true;
1307 }
1308 if (match.hit)
1309 {
1310 if (ctx->parsingLvalue || ctx->parsingExpressionStatement && !ctx->parsingArguments) pass = false;
1311 else op = Operator.eq;
1312 }
1313 if (match.hit && !pass)
1314 {
1315 match = Match(false);
1316 }
1317 *parentMatch10 = match;
1318 }
1319 *parentMatch9 = match;
1320 if (!match.hit)
1321 {
1322 Match match(false);
1323 Match* parentMatch11 = &match;
1324 lexer.SetPos(save);
1325 {
1326 Match match(false);
1327 Match* parentMatch12 = &match;
1328 {
1329 long pos = lexer.GetPos();
1330 bool pass = true;
1331 Match match(false);
1332 if (*lexer == NEQ)
1333 {
1334 ++lexer;
1335 match.hit = true;
1336 }
1337 if (match.hit)
1338 {
1339 if (ctx->parsingLvalue || ctx->parsingExpressionStatement && !ctx->parsingArguments) pass = false;
1340 else op = Operator.neq;
1341 }
1342 if (match.hit && !pass)
1343 {
1344 match = Match(false);
1345 }
1346 *parentMatch12 = match;
1347 }
1348 *parentMatch11 = match;
1349 }
1350 *parentMatch9 = match;
1351 }
1352 }
1353 *parentMatch8 = match;
1354 }
1355 *parentMatch7 = match;
1356 }
1357 if (match.hit)
1358 {
1359 Match match(false);
1360 Match* parentMatch13 = &match;
1361 {
1362 Match match(false);
1363 Match* parentMatch14 = &match;
1364 {
1365 long pos = lexer.GetPos();
1366 Span span = lexer.GetSpan();
1367 Match match(true);
1368 Match* parentMatch15 = &match;
1369 {
1370 System.Lex.Span span = lexer.GetSpan();
1371 Match match = ExpressionParser.Relational(lexer, ctx);
1372 right.Reset(cast<Node*>(match.value));
1373 if (match.hit)
1374 {
1375 *parentMatch15 = match;
1376 }
1377 else
1378 {
1379 lexer.ThrowExpectationFailure(span, u"relational expression");
1380 }
1381 }
1382 if (match.hit)
1383 {
1384 switch (op)
1385 {
1386 case Operator.eq: s.end = span.end;
1387 expr.Reset(new EqualNode(s, ctx->ModuleId(), expr.Release(), right.Release()));
1388 break;
1389 case Operator.neq: s.end = span.end;
1390 expr.Reset(new NotEqualNode(s, ctx->ModuleId(), expr.Release(), right.Release()));
1391 break;
1392 }
1393 }
1394 *parentMatch14 = match;
1395 }
1396 *parentMatch13 = match;
1397 }
1398 *parentMatch7 = match;
1399 }
1400 *parentMatch6 = match;
1401 }
1402 if (match.hit)
1403 {
1404 *parentMatch5 = match;
1405 }
1406 else
1407 {
1408 lexer.SetPos(save);
1409 break;
1410 }
1411 }
1412 }
1413 }
1414 *parentMatch4 = match;
1415 }
1416 *parentMatch2 = match;
1417 }
1418 *parentMatch1 = match;
1419 }
1420 if (match.hit)
1421 {
1422 {
1423 #if (DEBUG)
1424 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Equality");
1425 #endif
1426 return Match(true, expr.Release());
1427 }
1428 }
1429 *parentMatch0 = match;
1430 }
1431 #if (DEBUG)
1432 if (writeToLog)
1433 {
1434 if (match.hit)
1435 {
1436 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Equality");
1437 }
1438 else
1439 {
1440 System.Lex.WriteFailureToLog(lexer, u"Equality");
1441 }
1442 }
1443 #endif
1444 if (!match.hit)
1445 {
1446 match.value = null;
1447 }
1448 return match;
1449 }
1450 public static Match Relational(ParserFileLexer& lexer, ParsingContext* ctx)
1451 {
1452 #if (DEBUG)
1453 Span debugSpan;
1454 bool writeToLog = lexer.Log() != null;
1455 if (writeToLog)
1456 {
1457 debugSpan = lexer.GetSpan();
1458 System.Lex.WriteBeginRuleToLog(lexer, u"Relational");
1459 }
1460 #endif
1461 UniquePtr<Node> expr;
1462 Span s;
1463 Operator op;
1464 UniquePtr<Node> left;
1465 UniquePtr<Node> isType;
1466 UniquePtr<Node> asType;
1467 UniquePtr<Node> right;
1468 Match match(false);
1469 Match* parentMatch0 = &match;
1470 {
1471 long pos = lexer.GetPos();
1472 Match match(false);
1473 Match* parentMatch1 = &match;
1474 {
1475 Match match(false);
1476 Match* parentMatch2 = &match;
1477 {
1478 Match match(false);
1479 Match* parentMatch3 = &match;
1480 {
1481 long pos = lexer.GetPos();
1482 Span span = lexer.GetSpan();
1483 Match match = ExpressionParser.Shift(lexer, ctx);
1484 left.Reset(cast<Node*>(match.value));
1485 if (match.hit)
1486 {
1487 s = span;
1488 expr.Reset(left.Release());
1489 }
1490 *parentMatch3 = match;
1491 }
1492 *parentMatch2 = match;
1493 }
1494 if (match.hit)
1495 {
1496 Match match(false);
1497 Match* parentMatch4 = &match;
1498 {
1499 Match match(true);
1500 Match* parentMatch5 = &match;
1501 {
1502 while (true)
1503 {
1504 long save = lexer.GetPos();
1505 {
1506 Match match(false);
1507 Match* parentMatch6 = &match;
1508 {
1509 Match match(false);
1510 Match* parentMatch7 = &match;
1511 {
1512 Match match(false);
1513 Match* parentMatch8 = &match;
1514 {
1515 Match match(false);
1516 Match* parentMatch9 = &match;
1517 {
1518 long save = lexer.GetPos();
1519 Match match(false);
1520 Match* parentMatch10 = &match;
1521 {
1522 long save = lexer.GetPos();
1523 Match match(false);
1524 Match* parentMatch11 = &match;
1525 {
1526 long save = lexer.GetPos();
1527 Match match(false);
1528 Match* parentMatch12 = &match;
1529 {
1530 long save = lexer.GetPos();
1531 Match match(false);
1532 Match* parentMatch13 = &match;
1533 {
1534 long save = lexer.GetPos();
1535 Match match(false);
1536 Match* parentMatch14 = &match;
1537 {
1538 long pos = lexer.GetPos();
1539 bool pass = true;
1540 Match match(false);
1541 if (*lexer == LEQ)
1542 {
1543 ++lexer;
1544 match.hit = true;
1545 }
1546 if (match.hit)
1547 {
1548 if (ctx->parsingLvalue || ctx->parsingExpressionStatement && !ctx->parsingArguments) pass = false;
1549 else
1550 {
1551 op = Operator.lessOrEq;
1552 ctx->PushParsingIsOrAs(false);
1553 }
1554 }
1555 if (match.hit && !pass)
1556 {
1557 match = Match(false);
1558 }
1559 *parentMatch14 = match;
1560 }
1561 *parentMatch13 = match;
1562 if (!match.hit)
1563 {
1564 Match match(false);
1565 Match* parentMatch15 = &match;
1566 lexer.SetPos(save);
1567 {
1568 Match match(false);
1569 Match* parentMatch16 = &match;
1570 {
1571 long pos = lexer.GetPos();
1572 bool pass = true;
1573 Match match(false);
1574 if (*lexer == GEQ)
1575 {
1576 ++lexer;
1577 match.hit = true;
1578 }
1579 if (match.hit)
1580 {
1581 if (ctx->parsingLvalue || ctx->parsingExpressionStatement && !ctx->parsingArguments) pass = false;
1582 else
1583 {
1584 op = Operator.greaterOrEq;
1585 ctx->PushParsingIsOrAs(false);
1586 }
1587 }
1588 if (match.hit && !pass)
1589 {
1590 match = Match(false);
1591 }
1592 *parentMatch16 = match;
1593 }
1594 *parentMatch15 = match;
1595 }
1596 *parentMatch13 = match;
1597 }
1598 }
1599 *parentMatch12 = match;
1600 if (!match.hit)
1601 {
1602 Match match(false);
1603 Match* parentMatch17 = &match;
1604 lexer.SetPos(save);
1605 {
1606 Match match(false);
1607 Match* parentMatch18 = &match;
1608 {
1609 long pos = lexer.GetPos();
1610 bool pass = true;
1611 Match match(false);
1612 if (*lexer == LANGLE)
1613 {
1614 ++lexer;
1615 match.hit = true;
1616 }
1617 if (match.hit)
1618 {
1619 if (ctx->parsingLvalue || ctx->parsingExpressionStatement && !ctx->parsingArguments) pass = false;
1620 else
1621 {
1622 op = Operator.less;
1623 ctx->PushParsingIsOrAs(false);
1624 }
1625 }
1626 if (match.hit && !pass)
1627 {
1628 match = Match(false);
1629 }
1630 *parentMatch18 = match;
1631 }
1632 *parentMatch17 = match;
1633 }
1634 *parentMatch12 = match;
1635 }
1636 }
1637 *parentMatch11 = match;
1638 if (!match.hit)
1639 {
1640 Match match(false);
1641 Match* parentMatch19 = &match;
1642 lexer.SetPos(save);
1643 {
1644 Match match(false);
1645 Match* parentMatch20 = &match;
1646 {
1647 long pos = lexer.GetPos();
1648 bool pass = true;
1649 Match match(false);
1650 if (*lexer == RANGLE)
1651 {
1652 ++lexer;
1653 match.hit = true;
1654 }
1655 if (match.hit)
1656 {
1657 if (ctx->parsingLvalue || ctx->parsingExpressionStatement && !ctx->parsingArguments) pass = false;
1658 else
1659 {
1660 op = Operator.greater;
1661 ctx->PushParsingIsOrAs(false);
1662 }
1663 }
1664 if (match.hit && !pass)
1665 {
1666 match = Match(false);
1667 }
1668 *parentMatch20 = match;
1669 }
1670 *parentMatch19 = match;
1671 }
1672 *parentMatch11 = match;
1673 }
1674 }
1675 *parentMatch10 = match;
1676 if (!match.hit)
1677 {
1678 Match match(false);
1679 Match* parentMatch21 = &match;
1680 lexer.SetPos(save);
1681 {
1682 Match match(false);
1683 Match* parentMatch22 = &match;
1684 {
1685 Match match(false);
1686 Match* parentMatch23 = &match;
1687 {
1688 long pos = lexer.GetPos();
1689 bool pass = true;
1690 Match match(false);
1691 if (*lexer == IS)
1692 {
1693 ++lexer;
1694 match.hit = true;
1695 }
1696 if (match.hit)
1697 {
1698 if (ctx->parsingLvalue || ctx->parsingExpressionStatement && !ctx->parsingArguments) pass = false;
1699 else
1700 {
1701 op = Operator.is_;
1702 ctx->PushParsingIsOrAs(true);
1703 }
1704 }
1705 if (match.hit && !pass)
1706 {
1707 match = Match(false);
1708 }
1709 *parentMatch23 = match;
1710 }
1711 *parentMatch22 = match;
1712 }
1713 if (match.hit)
1714 {
1715 Match match(false);
1716 Match* parentMatch24 = &match;
1717 {
1718 Match match = TypeExprParser.TypeExpr(lexer, ctx);
1719 isType.Reset(cast<Node*>(match.value));
1720 *parentMatch24 = match;
1721 }
1722 *parentMatch22 = match;
1723 }
1724 *parentMatch21 = match;
1725 }
1726 *parentMatch10 = match;
1727 }
1728 }
1729 *parentMatch9 = match;
1730 if (!match.hit)
1731 {
1732 Match match(false);
1733 Match* parentMatch25 = &match;
1734 lexer.SetPos(save);
1735 {
1736 Match match(false);
1737 Match* parentMatch26 = &match;
1738 {
1739 Match match(false);
1740 Match* parentMatch27 = &match;
1741 {
1742 long pos = lexer.GetPos();
1743 bool pass = true;
1744 Match match(false);
1745 if (*lexer == AS)
1746 {
1747 ++lexer;
1748 match.hit = true;
1749 }
1750 if (match.hit)
1751 {
1752 if (ctx->parsingLvalue || ctx->parsingExpressionStatement && !ctx->parsingArguments) pass = false;
1753 else
1754 {
1755 op = Operator.as_;
1756 ctx->PushParsingIsOrAs(true);
1757 }
1758 }
1759 if (match.hit && !pass)
1760 {
1761 match = Match(false);
1762 }
1763 *parentMatch27 = match;
1764 }
1765 *parentMatch26 = match;
1766 }
1767 if (match.hit)
1768 {
1769 Match match(false);
1770 Match* parentMatch28 = &match;
1771 {
1772 Match match = TypeExprParser.TypeExpr(lexer, ctx);
1773 asType.Reset(cast<Node*>(match.value));
1774 *parentMatch28 = match;
1775 }
1776 *parentMatch26 = match;
1777 }
1778 *parentMatch25 = match;
1779 }
1780 *parentMatch9 = match;
1781 }
1782 }
1783 *parentMatch8 = match;
1784 }
1785 *parentMatch7 = match;
1786 }
1787 if (match.hit)
1788 {
1789 Match match(false);
1790 Match* parentMatch29 = &match;
1791 {
1792 Match match(false);
1793 Match* parentMatch30 = &match;
1794 {
1795 long pos = lexer.GetPos();
1796 Span span = lexer.GetSpan();
1797 Match match(false);
1798 Match* parentMatch31 = &match;
1799 {
1800 Match match(false);
1801 Match* parentMatch32 = &match;
1802 {
1803 long save = lexer.GetPos();
1804 Match match = ExpressionParser.Shift(lexer, ctx);
1805 right.Reset(cast<Node*>(match.value));
1806 *parentMatch32 = match;
1807 if (!match.hit)
1808 {
1809 Match match(false);
1810 Match* parentMatch33 = &match;
1811 lexer.SetPos(save);
1812 {
1813 Match match(false);
1814 Match* parentMatch34 = &match;
1815 {
1816 long pos = lexer.GetPos();
1817 bool pass = true;
1818 Match match(true);
1819 if (match.hit)
1820 {
1821 if (!ctx->parsingIsOrAs) pass = false;
1822 }
1823 if (match.hit && !pass)
1824 {
1825 match = Match(false);
1826 }
1827 *parentMatch34 = match;
1828 }
1829 *parentMatch33 = match;
1830 }
1831 *parentMatch32 = match;
1832 }
1833 }
1834 *parentMatch31 = match;
1835 }
1836 if (match.hit)
1837 {
1838 ctx->PopParsingIsOrAs();
1839 switch (op)
1840 {
1841 case Operator.lessOrEq: s.end = span.end;
1842 expr.Reset(new LessOrEqualNode(s, ctx->ModuleId(), expr.Release(), right.Release()));
1843 break;
1844 case Operator.greaterOrEq: s.end = span.end;
1845 expr.Reset(new GreaterOrEqualNode(s, ctx->ModuleId(), expr.Release(), right.Release()));
1846 break;
1847 case Operator.less: s.end = span.end;
1848 expr.Reset(new LessNode(s, ctx->ModuleId(), expr.Release(), right.Release()));
1849 break;
1850 case Operator.greater: s.end = span.end;
1851 expr.Reset(new GreaterNode(s, ctx->ModuleId(), expr.Release(), right.Release()));
1852 break;
1853 case Operator.is_: s.end = span.end;
1854 expr.Reset(new IsNode(s, ctx->ModuleId(), expr.Release(), isType.Release()));
1855 break;
1856 case Operator.as_: s.end = span.end;
1857 expr.Reset(new AsNode(s, ctx->ModuleId(), expr.Release(), asType.Release()));
1858 break;
1859 }
1860 }
1861 *parentMatch30 = match;
1862 }
1863 *parentMatch29 = match;
1864 }
1865 *parentMatch7 = match;
1866 }
1867 *parentMatch6 = match;
1868 }
1869 if (match.hit)
1870 {
1871 *parentMatch5 = match;
1872 }
1873 else
1874 {
1875 lexer.SetPos(save);
1876 break;
1877 }
1878 }
1879 }
1880 }
1881 *parentMatch4 = match;
1882 }
1883 *parentMatch2 = match;
1884 }
1885 *parentMatch1 = match;
1886 }
1887 if (match.hit)
1888 {
1889 {
1890 #if (DEBUG)
1891 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Relational");
1892 #endif
1893 return Match(true, expr.Release());
1894 }
1895 }
1896 *parentMatch0 = match;
1897 }
1898 #if (DEBUG)
1899 if (writeToLog)
1900 {
1901 if (match.hit)
1902 {
1903 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Relational");
1904 }
1905 else
1906 {
1907 System.Lex.WriteFailureToLog(lexer, u"Relational");
1908 }
1909 }
1910 #endif
1911 if (!match.hit)
1912 {
1913 match.value = null;
1914 }
1915 return match;
1916 }
1917 public static Match Shift(ParserFileLexer& lexer, ParsingContext* ctx)
1918 {
1919 #if (DEBUG)
1920 Span debugSpan;
1921 bool writeToLog = lexer.Log() != null;
1922 if (writeToLog)
1923 {
1924 debugSpan = lexer.GetSpan();
1925 System.Lex.WriteBeginRuleToLog(lexer, u"Shift");
1926 }
1927 #endif
1928 UniquePtr<Node> expr;
1929 Span s;
1930 Operator op;
1931 UniquePtr<Node> left;
1932 UniquePtr<Node> right;
1933 Match match(false);
1934 Match* parentMatch0 = &match;
1935 {
1936 long pos = lexer.GetPos();
1937 Match match(false);
1938 Match* parentMatch1 = &match;
1939 {
1940 Match match(false);
1941 Match* parentMatch2 = &match;
1942 {
1943 Match match(false);
1944 Match* parentMatch3 = &match;
1945 {
1946 long pos = lexer.GetPos();
1947 Span span = lexer.GetSpan();
1948 Match match = ExpressionParser.Additive(lexer, ctx);
1949 left.Reset(cast<Node*>(match.value));
1950 if (match.hit)
1951 {
1952 s = span;
1953 expr.Reset(left.Release());
1954 }
1955 *parentMatch3 = match;
1956 }
1957 *parentMatch2 = match;
1958 }
1959 if (match.hit)
1960 {
1961 Match match(false);
1962 Match* parentMatch4 = &match;
1963 {
1964 Match match(true);
1965 Match* parentMatch5 = &match;
1966 {
1967 while (true)
1968 {
1969 long save = lexer.GetPos();
1970 {
1971 Match match(false);
1972 Match* parentMatch6 = &match;
1973 {
1974 Match match(false);
1975 Match* parentMatch7 = &match;
1976 {
1977 Match match(false);
1978 Match* parentMatch8 = &match;
1979 {
1980 Match match(false);
1981 Match* parentMatch9 = &match;
1982 {
1983 Match match(false);
1984 Match* parentMatch10 = &match;
1985 {
1986 long save = lexer.GetPos();
1987 Match match(false);
1988 Match* parentMatch11 = &match;
1989 {
1990 long pos = lexer.GetPos();
1991 bool pass = true;
1992 Match match(false);
1993 if (*lexer == SHIFTLEFT)
1994 {
1995 ++lexer;
1996 match.hit = true;
1997 }
1998 if (match.hit)
1999 {
2000 if (ctx->parsingLvalue) pass = false;
2001 else op = Operator.shiftLeft;
2002 }
2003 if (match.hit && !pass)
2004 {
2005 match = Match(false);
2006 }
2007 *parentMatch11 = match;
2008 }
2009 *parentMatch10 = match;
2010 if (!match.hit)
2011 {
2012 Match match(false);
2013 Match* parentMatch12 = &match;
2014 lexer.SetPos(save);
2015 {
2016 Match match(false);
2017 Match* parentMatch13 = &match;
2018 {
2019 long pos = lexer.GetPos();
2020 bool pass = true;
2021 Match match(false);
2022 if (*lexer == SHIFTRIGHT)
2023 {
2024 ++lexer;
2025 match.hit = true;
2026 }
2027 if (match.hit)
2028 {
2029 if (ctx->parsingLvalue) pass = false;
2030 else op = Operator.shiftRight;
2031 }
2032 if (match.hit && !pass)
2033 {
2034 match = Match(false);
2035 }
2036 *parentMatch13 = match;
2037 }
2038 *parentMatch12 = match;
2039 }
2040 *parentMatch10 = match;
2041 }
2042 }
2043 *parentMatch9 = match;
2044 }
2045 *parentMatch8 = match;
2046 }
2047 if (match.hit)
2048 {
2049 Match match(false);
2050 Match* parentMatch14 = &match;
2051 {
2052 Match match(false);
2053 Match* parentMatch15 = &match;
2054 {
2055 long pos = lexer.GetPos();
2056 Match match(true);
2057 if (match.hit)
2058 {
2059 ctx->BeginParsingArguments();
2060 }
2061 *parentMatch15 = match;
2062 }
2063 *parentMatch14 = match;
2064 }
2065 *parentMatch8 = match;
2066 }
2067 *parentMatch7 = match;
2068 }
2069 if (match.hit)
2070 {
2071 Match match(false);
2072 Match* parentMatch16 = &match;
2073 {
2074 Match match(false);
2075 Match* parentMatch17 = &match;
2076 {
2077 long pos = lexer.GetPos();
2078 Span span = lexer.GetSpan();
2079 Match match(true);
2080 Match* parentMatch18 = &match;
2081 {
2082 System.Lex.Span span = lexer.GetSpan();
2083 Match match = ExpressionParser.Additive(lexer, ctx);
2084 right.Reset(cast<Node*>(match.value));
2085 if (match.hit)
2086 {
2087 *parentMatch18 = match;
2088 }
2089 else
2090 {
2091 lexer.ThrowExpectationFailure(span, u"additive expression");
2092 }
2093 }
2094 if (match.hit)
2095 {
2096 switch (op)
2097 {
2098 case Operator.shiftLeft: s.end = span.end;
2099 expr.Reset(new ShiftLeftNode(s, ctx->ModuleId(), expr.Release(), right.Release()));
2100 break;
2101 case Operator.shiftRight: s.end = span.end;
2102 expr.Reset(new ShiftRightNode(s, ctx->ModuleId(), expr.Release(), right.Release()));
2103 break;
2104 }
2105 ctx->EndParsingArguments();
2106 }
2107 else
2108 {
2109 ctx->EndParsingArguments();
2110 }
2111 *parentMatch17 = match;
2112 }
2113 *parentMatch16 = match;
2114 }
2115 *parentMatch7 = match;
2116 }
2117 *parentMatch6 = match;
2118 }
2119 if (match.hit)
2120 {
2121 *parentMatch5 = match;
2122 }
2123 else
2124 {
2125 lexer.SetPos(save);
2126 break;
2127 }
2128 }
2129 }
2130 }
2131 *parentMatch4 = match;
2132 }
2133 *parentMatch2 = match;
2134 }
2135 *parentMatch1 = match;
2136 }
2137 if (match.hit)
2138 {
2139 {
2140 #if (DEBUG)
2141 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Shift");
2142 #endif
2143 return Match(true, expr.Release());
2144 }
2145 }
2146 *parentMatch0 = match;
2147 }
2148 #if (DEBUG)
2149 if (writeToLog)
2150 {
2151 if (match.hit)
2152 {
2153 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Shift");
2154 }
2155 else
2156 {
2157 System.Lex.WriteFailureToLog(lexer, u"Shift");
2158 }
2159 }
2160 #endif
2161 if (!match.hit)
2162 {
2163 match.value = null;
2164 }
2165 return match;
2166 }
2167 public static Match Additive(ParserFileLexer& lexer, ParsingContext* ctx)
2168 {
2169 #if (DEBUG)
2170 Span debugSpan;
2171 bool writeToLog = lexer.Log() != null;
2172 if (writeToLog)
2173 {
2174 debugSpan = lexer.GetSpan();
2175 System.Lex.WriteBeginRuleToLog(lexer, u"Additive");
2176 }
2177 #endif
2178 UniquePtr<Node> expr;
2179 Span s;
2180 Operator op;
2181 UniquePtr<Node> left;
2182 UniquePtr<Node> right;
2183 Match match(false);
2184 Match* parentMatch0 = &match;
2185 {
2186 long pos = lexer.GetPos();
2187 Match match(false);
2188 Match* parentMatch1 = &match;
2189 {
2190 Match match(false);
2191 Match* parentMatch2 = &match;
2192 {
2193 Match match(false);
2194 Match* parentMatch3 = &match;
2195 {
2196 long pos = lexer.GetPos();
2197 Span span = lexer.GetSpan();
2198 Match match = ExpressionParser.Multiplicative(lexer, ctx);
2199 left.Reset(cast<Node*>(match.value));
2200 if (match.hit)
2201 {
2202 s = span;
2203 expr.Reset(left.Release());
2204 }
2205 *parentMatch3 = match;
2206 }
2207 *parentMatch2 = match;
2208 }
2209 if (match.hit)
2210 {
2211 Match match(false);
2212 Match* parentMatch4 = &match;
2213 {
2214 Match match(true);
2215 Match* parentMatch5 = &match;
2216 {
2217 while (true)
2218 {
2219 long save = lexer.GetPos();
2220 {
2221 Match match(false);
2222 Match* parentMatch6 = &match;
2223 {
2224 Match match(false);
2225 Match* parentMatch7 = &match;
2226 {
2227 Match match(false);
2228 Match* parentMatch8 = &match;
2229 {
2230 Match match(false);
2231 Match* parentMatch9 = &match;
2232 {
2233 long save = lexer.GetPos();
2234 Match match(false);
2235 Match* parentMatch10 = &match;
2236 {
2237 long pos = lexer.GetPos();
2238 bool pass = true;
2239 Match match(false);
2240 if (*lexer == PLUS)
2241 {
2242 ++lexer;
2243 match.hit = true;
2244 }
2245 if (match.hit)
2246 {
2247 if (ctx->parsingLvalue || ctx->parsingExpressionStatement && !ctx->parsingArguments) pass = false;
2248 else op = Operator.plus;
2249 }
2250 if (match.hit && !pass)
2251 {
2252 match = Match(false);
2253 }
2254 *parentMatch10 = match;
2255 }
2256 *parentMatch9 = match;
2257 if (!match.hit)
2258 {
2259 Match match(false);
2260 Match* parentMatch11 = &match;
2261 lexer.SetPos(save);
2262 {
2263 Match match(false);
2264 Match* parentMatch12 = &match;
2265 {
2266 long pos = lexer.GetPos();
2267 bool pass = true;
2268 Match match(false);
2269 if (*lexer == MINUS)
2270 {
2271 ++lexer;
2272 match.hit = true;
2273 }
2274 if (match.hit)
2275 {
2276 if (ctx->parsingLvalue || ctx->parsingExpressionStatement && !ctx->parsingArguments) pass = false;
2277 else op = Operator.minus;
2278 }
2279 if (match.hit && !pass)
2280 {
2281 match = Match(false);
2282 }
2283 *parentMatch12 = match;
2284 }
2285 *parentMatch11 = match;
2286 }
2287 *parentMatch9 = match;
2288 }
2289 }
2290 *parentMatch8 = match;
2291 }
2292 *parentMatch7 = match;
2293 }
2294 if (match.hit)
2295 {
2296 Match match(false);
2297 Match* parentMatch13 = &match;
2298 {
2299 Match match(false);
2300 Match* parentMatch14 = &match;
2301 {
2302 long pos = lexer.GetPos();
2303 Span span = lexer.GetSpan();
2304 Match match(true);
2305 Match* parentMatch15 = &match;
2306 {
2307 System.Lex.Span span = lexer.GetSpan();
2308 Match match = ExpressionParser.Multiplicative(lexer, ctx);
2309 right.Reset(cast<Node*>(match.value));
2310 if (match.hit)
2311 {
2312 *parentMatch15 = match;
2313 }
2314 else
2315 {
2316 lexer.ThrowExpectationFailure(span, u"multiplicative expression");
2317 }
2318 }
2319 if (match.hit)
2320 {
2321 switch (op)
2322 {
2323 case Operator.plus: s.end = span.end;
2324 expr.Reset(new AddNode(s, ctx->ModuleId(), expr.Release(), right.Release()));
2325 break;
2326 case Operator.minus: s.end = span.end;
2327 expr.Reset(new SubNode(s, ctx->ModuleId(), expr.Release(), right.Release()));
2328 break;
2329 }
2330 }
2331 *parentMatch14 = match;
2332 }
2333 *parentMatch13 = match;
2334 }
2335 *parentMatch7 = match;
2336 }
2337 *parentMatch6 = match;
2338 }
2339 if (match.hit)
2340 {
2341 *parentMatch5 = match;
2342 }
2343 else
2344 {
2345 lexer.SetPos(save);
2346 break;
2347 }
2348 }
2349 }
2350 }
2351 *parentMatch4 = match;
2352 }
2353 *parentMatch2 = match;
2354 }
2355 *parentMatch1 = match;
2356 }
2357 if (match.hit)
2358 {
2359 {
2360 #if (DEBUG)
2361 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Additive");
2362 #endif
2363 return Match(true, expr.Release());
2364 }
2365 }
2366 *parentMatch0 = match;
2367 }
2368 #if (DEBUG)
2369 if (writeToLog)
2370 {
2371 if (match.hit)
2372 {
2373 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Additive");
2374 }
2375 else
2376 {
2377 System.Lex.WriteFailureToLog(lexer, u"Additive");
2378 }
2379 }
2380 #endif
2381 if (!match.hit)
2382 {
2383 match.value = null;
2384 }
2385 return match;
2386 }
2387 public static Match Multiplicative(ParserFileLexer& lexer, ParsingContext* ctx)
2388 {
2389 #if (DEBUG)
2390 Span debugSpan;
2391 bool writeToLog = lexer.Log() != null;
2392 if (writeToLog)
2393 {
2394 debugSpan = lexer.GetSpan();
2395 System.Lex.WriteBeginRuleToLog(lexer, u"Multiplicative");
2396 }
2397 #endif
2398 UniquePtr<Node> expr;
2399 Span s;
2400 Operator op;
2401 UniquePtr<Node> left;
2402 UniquePtr<Node> right;
2403 Match match(false);
2404 Match* parentMatch0 = &match;
2405 {
2406 long pos = lexer.GetPos();
2407 Match match(false);
2408 Match* parentMatch1 = &match;
2409 {
2410 Match match(false);
2411 Match* parentMatch2 = &match;
2412 {
2413 Match match(false);
2414 Match* parentMatch3 = &match;
2415 {
2416 long pos = lexer.GetPos();
2417 Span span = lexer.GetSpan();
2418 Match match = ExpressionParser.Prefix(lexer, ctx);
2419 left.Reset(cast<Node*>(match.value));
2420 if (match.hit)
2421 {
2422 s = span;
2423 expr.Reset(left.Release());
2424 }
2425 *parentMatch3 = match;
2426 }
2427 *parentMatch2 = match;
2428 }
2429 if (match.hit)
2430 {
2431 Match match(false);
2432 Match* parentMatch4 = &match;
2433 {
2434 Match match(true);
2435 Match* parentMatch5 = &match;
2436 {
2437 while (true)
2438 {
2439 long save = lexer.GetPos();
2440 {
2441 Match match(false);
2442 Match* parentMatch6 = &match;
2443 {
2444 Match match(false);
2445 Match* parentMatch7 = &match;
2446 {
2447 Match match(false);
2448 Match* parentMatch8 = &match;
2449 {
2450 Match match(false);
2451 Match* parentMatch9 = &match;
2452 {
2453 long save = lexer.GetPos();
2454 Match match(false);
2455 Match* parentMatch10 = &match;
2456 {
2457 long save = lexer.GetPos();
2458 Match match(false);
2459 Match* parentMatch11 = &match;
2460 {
2461 long pos = lexer.GetPos();
2462 bool pass = true;
2463 Match match(false);
2464 if (*lexer == STAR)
2465 {
2466 ++lexer;
2467 match.hit = true;
2468 }
2469 if (match.hit)
2470 {
2471 if (ctx->parsingLvalue || ctx->parsingExpressionStatement && !ctx->parsingArguments) pass = false;
2472 else op = Operator.mul;
2473 }
2474 if (match.hit && !pass)
2475 {
2476 match = Match(false);
2477 }
2478 *parentMatch11 = match;
2479 }
2480 *parentMatch10 = match;
2481 if (!match.hit)
2482 {
2483 Match match(false);
2484 Match* parentMatch12 = &match;
2485 lexer.SetPos(save);
2486 {
2487 Match match(false);
2488 Match* parentMatch13 = &match;
2489 {
2490 long pos = lexer.GetPos();
2491 bool pass = true;
2492 Match match(false);
2493 if (*lexer == DIV)
2494 {
2495 ++lexer;
2496 match.hit = true;
2497 }
2498 if (match.hit)
2499 {
2500 if (ctx->parsingLvalue || ctx->parsingExpressionStatement && !ctx->parsingArguments) pass = false;
2501 else op = Operator.div;
2502 }
2503 if (match.hit && !pass)
2504 {
2505 match = Match(false);
2506 }
2507 *parentMatch13 = match;
2508 }
2509 *parentMatch12 = match;
2510 }
2511 *parentMatch10 = match;
2512 }
2513 }
2514 *parentMatch9 = match;
2515 if (!match.hit)
2516 {
2517 Match match(false);
2518 Match* parentMatch14 = &match;
2519 lexer.SetPos(save);
2520 {
2521 Match match(false);
2522 Match* parentMatch15 = &match;
2523 {
2524 long pos = lexer.GetPos();
2525 bool pass = true;
2526 Match match(false);
2527 if (*lexer == REM)
2528 {
2529 ++lexer;
2530 match.hit = true;
2531 }
2532 if (match.hit)
2533 {
2534 if (ctx->parsingLvalue || ctx->parsingExpressionStatement && !ctx->parsingArguments) pass = false;
2535 else op = Operator.rem;
2536 }
2537 if (match.hit && !pass)
2538 {
2539 match = Match(false);
2540 }
2541 *parentMatch15 = match;
2542 }
2543 *parentMatch14 = match;
2544 }
2545 *parentMatch9 = match;
2546 }
2547 }
2548 *parentMatch8 = match;
2549 }
2550 *parentMatch7 = match;
2551 }
2552 if (match.hit)
2553 {
2554 Match match(false);
2555 Match* parentMatch16 = &match;
2556 {
2557 Match match(false);
2558 Match* parentMatch17 = &match;
2559 {
2560 long pos = lexer.GetPos();
2561 Span span = lexer.GetSpan();
2562 Match match(true);
2563 Match* parentMatch18 = &match;
2564 {
2565 System.Lex.Span span = lexer.GetSpan();
2566 Match match = ExpressionParser.Prefix(lexer, ctx);
2567 right.Reset(cast<Node*>(match.value));
2568 if (match.hit)
2569 {
2570 *parentMatch18 = match;
2571 }
2572 else
2573 {
2574 lexer.ThrowExpectationFailure(span, u"prefix expression");
2575 }
2576 }
2577 if (match.hit)
2578 {
2579 switch (op)
2580 {
2581 case Operator.mul: s.end = span.end;
2582 expr.Reset(new MulNode(s, ctx->ModuleId(), expr.Release(), right.Release()));
2583 break;
2584 case Operator.div: s.end = span.end;
2585 expr.Reset(new DivNode(s, ctx->ModuleId(), expr.Release(), right.Release()));
2586 break;
2587 case Operator.rem: s.end = span.end;
2588 expr.Reset(new RemNode(s, ctx->ModuleId(), expr.Release(), right.Release()));
2589 break;
2590 }
2591 }
2592 *parentMatch17 = match;
2593 }
2594 *parentMatch16 = match;
2595 }
2596 *parentMatch7 = match;
2597 }
2598 *parentMatch6 = match;
2599 }
2600 if (match.hit)
2601 {
2602 *parentMatch5 = match;
2603 }
2604 else
2605 {
2606 lexer.SetPos(save);
2607 break;
2608 }
2609 }
2610 }
2611 }
2612 *parentMatch4 = match;
2613 }
2614 *parentMatch2 = match;
2615 }
2616 *parentMatch1 = match;
2617 }
2618 if (match.hit)
2619 {
2620 {
2621 #if (DEBUG)
2622 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Multiplicative");
2623 #endif
2624 return Match(true, expr.Release());
2625 }
2626 }
2627 *parentMatch0 = match;
2628 }
2629 #if (DEBUG)
2630 if (writeToLog)
2631 {
2632 if (match.hit)
2633 {
2634 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Multiplicative");
2635 }
2636 else
2637 {
2638 System.Lex.WriteFailureToLog(lexer, u"Multiplicative");
2639 }
2640 }
2641 #endif
2642 if (!match.hit)
2643 {
2644 match.value = null;
2645 }
2646 return match;
2647 }
2648 public static Match Prefix(ParserFileLexer& lexer, ParsingContext* ctx)
2649 {
2650 #if (DEBUG)
2651 Span debugSpan;
2652 bool writeToLog = lexer.Log() != null;
2653 if (writeToLog)
2654 {
2655 debugSpan = lexer.GetSpan();
2656 System.Lex.WriteBeginRuleToLog(lexer, u"Prefix");
2657 }
2658 #endif
2659 UniquePtr<Node> prefix;
2660 Span s;
2661 Operator op;
2662 UniquePtr<Node> p;
2663 UniquePtr<Node> postfix;
2664 Match match(false);
2665 Match* parentMatch0 = &match;
2666 {
2667 Match match(false);
2668 Match* parentMatch1 = &match;
2669 {
2670 long save = lexer.GetPos();
2671 Match match(false);
2672 Match* parentMatch2 = &match;
2673 {
2674 Match match(false);
2675 Match* parentMatch3 = &match;
2676 {
2677 Match match(false);
2678 Match* parentMatch4 = &match;
2679 {
2680 long save = lexer.GetPos();
2681 Match match(false);
2682 Match* parentMatch5 = &match;
2683 {
2684 long save = lexer.GetPos();
2685 Match match(false);
2686 Match* parentMatch6 = &match;
2687 {
2688 long save = lexer.GetPos();
2689 Match match(false);
2690 Match* parentMatch7 = &match;
2691 {
2692 long save = lexer.GetPos();
2693 Match match(false);
2694 Match* parentMatch8 = &match;
2695 {
2696 long save = lexer.GetPos();
2697 Match match(false);
2698 Match* parentMatch9 = &match;
2699 {
2700 long save = lexer.GetPos();
2701 Match match(false);
2702 Match* parentMatch10 = &match;
2703 {
2704 long save = lexer.GetPos();
2705 Match match(false);
2706 Match* parentMatch11 = &match;
2707 {
2708 long pos = lexer.GetPos();
2709 Span span = lexer.GetSpan();
2710 Match match(false);
2711 if (*lexer == PLUSPLUS)
2712 {
2713 ++lexer;
2714 match.hit = true;
2715 }
2716 if (match.hit)
2717 {
2718 s = span;
2719 op = Operator.plusplus;
2720 }
2721 *parentMatch11 = match;
2722 }
2723 *parentMatch10 = match;
2724 if (!match.hit)
2725 {
2726 Match match(false);
2727 Match* parentMatch12 = &match;
2728 lexer.SetPos(save);
2729 {
2730 Match match(false);
2731 Match* parentMatch13 = &match;
2732 {
2733 long pos = lexer.GetPos();
2734 Span span = lexer.GetSpan();
2735 Match match(false);
2736 if (*lexer == MINUSMINUS)
2737 {
2738 ++lexer;
2739 match.hit = true;
2740 }
2741 if (match.hit)
2742 {
2743 s = span;
2744 op = Operator.minusminus;
2745 }
2746 *parentMatch13 = match;
2747 }
2748 *parentMatch12 = match;
2749 }
2750 *parentMatch10 = match;
2751 }
2752 }
2753 *parentMatch9 = match;
2754 if (!match.hit)
2755 {
2756 Match match(false);
2757 Match* parentMatch14 = &match;
2758 lexer.SetPos(save);
2759 {
2760 Match match(false);
2761 Match* parentMatch15 = &match;
2762 {
2763 long pos = lexer.GetPos();
2764 Span span = lexer.GetSpan();
2765 bool pass = true;
2766 Match match(false);
2767 if (*lexer == PLUS)
2768 {
2769 ++lexer;
2770 match.hit = true;
2771 }
2772 if (match.hit)
2773 {
2774 if (ctx->parsingExpressionStatement && !ctx->parsingArguments) pass = false;
2775 else
2776 {
2777 s = span;
2778 op = Operator.plus;
2779 }
2780 }
2781 if (match.hit && !pass)
2782 {
2783 match = Match(false);
2784 }
2785 *parentMatch15 = match;
2786 }
2787 *parentMatch14 = match;
2788 }
2789 *parentMatch9 = match;
2790 }
2791 }
2792 *parentMatch8 = match;
2793 if (!match.hit)
2794 {
2795 Match match(false);
2796 Match* parentMatch16 = &match;
2797 lexer.SetPos(save);
2798 {
2799 Match match(false);
2800 Match* parentMatch17 = &match;
2801 {
2802 long pos = lexer.GetPos();
2803 Span span = lexer.GetSpan();
2804 bool pass = true;
2805 Match match(false);
2806 if (*lexer == MINUS)
2807 {
2808 ++lexer;
2809 match.hit = true;
2810 }
2811 if (match.hit)
2812 {
2813 if (ctx->parsingExpressionStatement && !ctx->parsingArguments) pass = false;
2814 else
2815 {
2816 s = span;
2817 op = Operator.minus;
2818 }
2819 }
2820 if (match.hit && !pass)
2821 {
2822 match = Match(false);
2823 }
2824 *parentMatch17 = match;
2825 }
2826 *parentMatch16 = match;
2827 }
2828 *parentMatch8 = match;
2829 }
2830 }
2831 *parentMatch7 = match;
2832 if (!match.hit)
2833 {
2834 Match match(false);
2835 Match* parentMatch18 = &match;
2836 lexer.SetPos(save);
2837 {
2838 Match match(false);
2839 Match* parentMatch19 = &match;
2840 {
2841 long pos = lexer.GetPos();
2842 Span span = lexer.GetSpan();
2843 bool pass = true;
2844 Match match(false);
2845 if (*lexer == EXCLAMATION)
2846 {
2847 ++lexer;
2848 match.hit = true;
2849 }
2850 if (match.hit)
2851 {
2852 if (ctx->parsingExpressionStatement && !ctx->parsingArguments) pass = false;
2853 else
2854 {
2855 s = span;
2856 op = Operator.not_;
2857 }
2858 }
2859 if (match.hit && !pass)
2860 {
2861 match = Match(false);
2862 }
2863 *parentMatch19 = match;
2864 }
2865 *parentMatch18 = match;
2866 }
2867 *parentMatch7 = match;
2868 }
2869 }
2870 *parentMatch6 = match;
2871 if (!match.hit)
2872 {
2873 Match match(false);
2874 Match* parentMatch20 = &match;
2875 lexer.SetPos(save);
2876 {
2877 Match match(false);
2878 Match* parentMatch21 = &match;
2879 {
2880 long pos = lexer.GetPos();
2881 Span span = lexer.GetSpan();
2882 bool pass = true;
2883 Match match(false);
2884 if (*lexer == CPL)
2885 {
2886 ++lexer;
2887 match.hit = true;
2888 }
2889 if (match.hit)
2890 {
2891 if (ctx->parsingExpressionStatement && !ctx->parsingArguments) pass = false;
2892 else
2893 {
2894 s = span;
2895 op = Operator.complement;
2896 }
2897 }
2898 if (match.hit && !pass)
2899 {
2900 match = Match(false);
2901 }
2902 *parentMatch21 = match;
2903 }
2904 *parentMatch20 = match;
2905 }
2906 *parentMatch6 = match;
2907 }
2908 }
2909 *parentMatch5 = match;
2910 if (!match.hit)
2911 {
2912 Match match(false);
2913 Match* parentMatch22 = &match;
2914 lexer.SetPos(save);
2915 {
2916 Match match(false);
2917 Match* parentMatch23 = &match;
2918 {
2919 long pos = lexer.GetPos();
2920 Span span = lexer.GetSpan();
2921 bool pass = true;
2922 Match match(false);
2923 if (*lexer == STAR)
2924 {
2925 ++lexer;
2926 match.hit = true;
2927 }
2928 if (match.hit)
2929 {
2930 if (ctx->parsingExpressionStatement && !ctx->parsingArguments) pass = false;
2931 else
2932 {
2933 s = span;
2934 op = Operator.deref;
2935 }
2936 }
2937 if (match.hit && !pass)
2938 {
2939 match = Match(false);
2940 }
2941 *parentMatch23 = match;
2942 }
2943 *parentMatch22 = match;
2944 }
2945 *parentMatch5 = match;
2946 }
2947 }
2948 *parentMatch4 = match;
2949 if (!match.hit)
2950 {
2951 Match match(false);
2952 Match* parentMatch24 = &match;
2953 lexer.SetPos(save);
2954 {
2955 Match match(false);
2956 Match* parentMatch25 = &match;
2957 {
2958 long pos = lexer.GetPos();
2959 Span span = lexer.GetSpan();
2960 bool pass = true;
2961 Match match(false);
2962 if (*lexer == AMP)
2963 {
2964 ++lexer;
2965 match.hit = true;
2966 }
2967 if (match.hit)
2968 {
2969 if (ctx->parsingExpressionStatement && !ctx->parsingArguments) pass = false;
2970 else
2971 {
2972 s = span;
2973 op = Operator.addrOf;
2974 }
2975 }
2976 if (match.hit && !pass)
2977 {
2978 match = Match(false);
2979 }
2980 *parentMatch25 = match;
2981 }
2982 *parentMatch24 = match;
2983 }
2984 *parentMatch4 = match;
2985 }
2986 }
2987 *parentMatch3 = match;
2988 }
2989 *parentMatch2 = match;
2990 }
2991 if (match.hit)
2992 {
2993 Match match(false);
2994 Match* parentMatch26 = &match;
2995 {
2996 Match match(false);
2997 Match* parentMatch27 = &match;
2998 {
2999 long pos = lexer.GetPos();
3000 Span span = lexer.GetSpan();
3001 Match match = ExpressionParser.Prefix(lexer, ctx);
3002 p.Reset(cast<Node*>(match.value));
3003 if (match.hit)
3004 {
3005 prefix.Reset(p.Release());
3006 s.end = span.end;
3007 switch (op)
3008 {
3009 case Operator.plusplus:
3010 {
3011 #if (DEBUG)
3012 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Prefix");
3013 #endif
3014 return Match(true, new PrefixIncrementNode(s, ctx->ModuleId(), prefix.Release()));
3015 }
3016 case Operator.minusminus:
3017 {
3018 #if (DEBUG)
3019 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Prefix");
3020 #endif
3021 return Match(true, new PrefixDecrementNode(s, ctx->ModuleId(), prefix.Release()));
3022 }
3023 case Operator.plus:
3024 {
3025 #if (DEBUG)
3026 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Prefix");
3027 #endif
3028 return Match(true, new UnaryPlusNode(s, ctx->ModuleId(), prefix.Release()));
3029 }
3030 case Operator.minus:
3031 {
3032 #if (DEBUG)
3033 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Prefix");
3034 #endif
3035 return Match(true, new UnaryMinusNode(s, ctx->ModuleId(), prefix.Release()));
3036 }
3037 case Operator.not_:
3038 {
3039 #if (DEBUG)
3040 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Prefix");
3041 #endif
3042 return Match(true, new NotNode(s, ctx->ModuleId(), prefix.Release()));
3043 }
3044 case Operator.complement:
3045 {
3046 #if (DEBUG)
3047 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Prefix");
3048 #endif
3049 return Match(true, new ComplementNode(s, ctx->ModuleId(), prefix.Release()));
3050 }
3051 case Operator.deref:
3052 {
3053 #if (DEBUG)
3054 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Prefix");
3055 #endif
3056 return Match(true, new DerefNode(s, ctx->ModuleId(), prefix.Release()));
3057 }
3058 case Operator.addrOf:
3059 {
3060 #if (DEBUG)
3061 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Prefix");
3062 #endif
3063 return Match(true, new AddrOfNode(s, ctx->ModuleId(), prefix.Release()));
3064 }
3065 }
3066 }
3067 *parentMatch27 = match;
3068 }
3069 *parentMatch26 = match;
3070 }
3071 *parentMatch2 = match;
3072 }
3073 *parentMatch1 = match;
3074 if (!match.hit)
3075 {
3076 Match match(false);
3077 Match* parentMatch28 = &match;
3078 lexer.SetPos(save);
3079 {
3080 Match match(false);
3081 Match* parentMatch29 = &match;
3082 {
3083 long pos = lexer.GetPos();
3084 Match match = ExpressionParser.Postfix(lexer, ctx);
3085 postfix.Reset(cast<Node*>(match.value));
3086 if (match.hit)
3087 {
3088 {
3089 #if (DEBUG)
3090 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Prefix");
3091 #endif
3092 return Match(true, postfix.Release());
3093 }
3094 }
3095 *parentMatch29 = match;
3096 }
3097 *parentMatch28 = match;
3098 }
3099 *parentMatch1 = match;
3100 }
3101 }
3102 *parentMatch0 = match;
3103 }
3104 #if (DEBUG)
3105 if (writeToLog)
3106 {
3107 if (match.hit)
3108 {
3109 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Prefix");
3110 }
3111 else
3112 {
3113 System.Lex.WriteFailureToLog(lexer, u"Prefix");
3114 }
3115 }
3116 #endif
3117 if (!match.hit)
3118 {
3119 match.value = null;
3120 }
3121 return match;
3122 }
3123 public static Match Postfix(ParserFileLexer& lexer, ParsingContext* ctx)
3124 {
3125 #if (DEBUG)
3126 Span debugSpan;
3127 bool writeToLog = lexer.Log() != null;
3128 if (writeToLog)
3129 {
3130 debugSpan = lexer.GetSpan();
3131 System.Lex.WriteBeginRuleToLog(lexer, u"Postfix");
3132 }
3133 #endif
3134 UniquePtr<Node> expr;
3135 Span s;
3136 UniquePtr<Node> primary;
3137 UniquePtr<IdentifierNode> dotMember;
3138 UniquePtr<IdentifierNode> arrowMember;
3139 UniquePtr<Node> index;
3140 Match match(false);
3141 Match* parentMatch0 = &match;
3142 {
3143 long pos = lexer.GetPos();
3144 Match match(false);
3145 Match* parentMatch1 = &match;
3146 {
3147 Match match(false);
3148 Match* parentMatch2 = &match;
3149 {
3150 Match match(false);
3151 Match* parentMatch3 = &match;
3152 {
3153 long pos = lexer.GetPos();
3154 Span span = lexer.GetSpan();
3155 Match match = ExpressionParser.Primary(lexer, ctx);
3156 primary.Reset(cast<Node*>(match.value));
3157 if (match.hit)
3158 {
3159 s = span;
3160 expr.Reset(primary.Release());
3161 }
3162 *parentMatch3 = match;
3163 }
3164 *parentMatch2 = match;
3165 }
3166 if (match.hit)
3167 {
3168 Match match(false);
3169 Match* parentMatch4 = &match;
3170 {
3171 Match match(true);
3172 Match* parentMatch5 = &match;
3173 {
3174 while (true)
3175 {
3176 long save = lexer.GetPos();
3177 {
3178 Match match(false);
3179 Match* parentMatch6 = &match;
3180 {
3181 Match match(false);
3182 Match* parentMatch7 = &match;
3183 {
3184 long save = lexer.GetPos();
3185 Match match(false);
3186 Match* parentMatch8 = &match;
3187 {
3188 long save = lexer.GetPos();
3189 Match match(false);
3190 Match* parentMatch9 = &match;
3191 {
3192 long save = lexer.GetPos();
3193 Match match(false);
3194 Match* parentMatch10 = &match;
3195 {
3196 long save = lexer.GetPos();
3197 Match match(false);
3198 Match* parentMatch11 = &match;
3199 {
3200 long save = lexer.GetPos();
3201 Match match(false);
3202 Match* parentMatch12 = &match;
3203 {
3204 long pos = lexer.GetPos();
3205 Span span = lexer.GetSpan();
3206 Match match(false);
3207 if (*lexer == PLUSPLUS)
3208 {
3209 ++lexer;
3210 match.hit = true;
3211 }
3212 if (match.hit)
3213 {
3214 s.end = span.end;
3215 expr.Reset(new PostfixIncrementNode(s, ctx->ModuleId(), expr.Release()));
3216 }
3217 *parentMatch12 = match;
3218 }
3219 *parentMatch11 = match;
3220 if (!match.hit)
3221 {
3222 Match match(false);
3223 Match* parentMatch13 = &match;
3224 lexer.SetPos(save);
3225 {
3226 Match match(false);
3227 Match* parentMatch14 = &match;
3228 {
3229 long pos = lexer.GetPos();
3230 Span span = lexer.GetSpan();
3231 Match match(false);
3232 if (*lexer == MINUSMINUS)
3233 {
3234 ++lexer;
3235 match.hit = true;
3236 }
3237 if (match.hit)
3238 {
3239 s.end = span.end;
3240 expr.Reset(new PostfixDecrementNode(s, ctx->ModuleId(), expr.Release()));
3241 }
3242 *parentMatch14 = match;
3243 }
3244 *parentMatch13 = match;
3245 }
3246 *parentMatch11 = match;
3247 }
3248 }
3249 *parentMatch10 = match;
3250 if (!match.hit)
3251 {
3252 Match match(false);
3253 Match* parentMatch15 = &match;
3254 lexer.SetPos(save);
3255 {
3256 Match match(false);
3257 Match* parentMatch16 = &match;
3258 {
3259 Match match(false);
3260 if (*lexer == DOT)
3261 {
3262 ++lexer;
3263 match.hit = true;
3264 }
3265 *parentMatch16 = match;
3266 }
3267 if (match.hit)
3268 {
3269 Match match(false);
3270 Match* parentMatch17 = &match;
3271 {
3272 Match match(false);
3273 Match* parentMatch18 = &match;
3274 {
3275 long pos = lexer.GetPos();
3276 Span span = lexer.GetSpan();
3277 Match match = IdentifierParser.Identifier(lexer, ctx);
3278 dotMember.Reset(cast<IdentifierNode*>(match.value));
3279 if (match.hit)
3280 {
3281 s.end = span.end;
3282 expr.Reset(new DotNode(s, ctx->ModuleId(), expr.Release(), dotMember.Release()));
3283 }
3284 *parentMatch18 = match;
3285 }
3286 *parentMatch17 = match;
3287 }
3288 *parentMatch16 = match;
3289 }
3290 *parentMatch15 = match;
3291 }
3292 *parentMatch10 = match;
3293 }
3294 }
3295 *parentMatch9 = match;
3296 if (!match.hit)
3297 {
3298 Match match(false);
3299 Match* parentMatch19 = &match;
3300 lexer.SetPos(save);
3301 {
3302 Match match(false);
3303 Match* parentMatch20 = &match;
3304 {
3305 Match match(false);
3306 if (*lexer == ARROW)
3307 {
3308 ++lexer;
3309 match.hit = true;
3310 }
3311 *parentMatch20 = match;
3312 }
3313 if (match.hit)
3314 {
3315 Match match(false);
3316 Match* parentMatch21 = &match;
3317 {
3318 Match match(false);
3319 Match* parentMatch22 = &match;
3320 {
3321 long pos = lexer.GetPos();
3322 Span span = lexer.GetSpan();
3323 Match match = IdentifierParser.Identifier(lexer, ctx);
3324 arrowMember.Reset(cast<IdentifierNode*>(match.value));
3325 if (match.hit)
3326 {
3327 s.end = span.end;
3328 expr.Reset(new ArrowNode(s, ctx->ModuleId(), expr.Release(), arrowMember.Release()));
3329 }
3330 *parentMatch22 = match;
3331 }
3332 *parentMatch21 = match;
3333 }
3334 *parentMatch20 = match;
3335 }
3336 *parentMatch19 = match;
3337 }
3338 *parentMatch9 = match;
3339 }
3340 }
3341 *parentMatch8 = match;
3342 if (!match.hit)
3343 {
3344 Match match(false);
3345 Match* parentMatch23 = &match;
3346 lexer.SetPos(save);
3347 {
3348 Match match(false);
3349 Match* parentMatch24 = &match;
3350 {
3351 Match match(false);
3352 Match* parentMatch25 = &match;
3353 {
3354 Match match(false);
3355 Match* parentMatch26 = &match;
3356 {
3357 long pos = lexer.GetPos();
3358 Match match(false);
3359 if (*lexer == LBRACKET)
3360 {
3361 ++lexer;
3362 match.hit = true;
3363 }
3364 if (match.hit)
3365 {
3366 ctx->PushParsingLvalue(false);
3367 ctx->PushParsingExpressionStatement(false);
3368 }
3369 *parentMatch26 = match;
3370 }
3371 *parentMatch25 = match;
3372 }
3373 if (match.hit)
3374 {
3375 Match match(false);
3376 Match* parentMatch27 = &match;
3377 {
3378 Match match(false);
3379 Match* parentMatch28 = &match;
3380 {
3381 long pos = lexer.GetPos();
3382 Match match = ExpressionParser.Expression(lexer, ctx);
3383 index.Reset(cast<Node*>(match.value));
3384 if (match.hit)
3385 {
3386 ctx->PopParsingExpressionStatement();
3387 ctx->PopParsingLvalue();
3388 }
3389 *parentMatch28 = match;
3390 }
3391 *parentMatch27 = match;
3392 }
3393 *parentMatch25 = match;
3394 }
3395 *parentMatch24 = match;
3396 }
3397 if (match.hit)
3398 {
3399 Match match(false);
3400 Match* parentMatch29 = &match;
3401 {
3402 Match match(false);
3403 Match* parentMatch30 = &match;
3404 {
3405 long pos = lexer.GetPos();
3406 Span span = lexer.GetSpan();
3407 Match match(true);
3408 Match* parentMatch31 = &match;
3409 {
3410 System.Lex.Span span = lexer.GetSpan();
3411 Match match(false);
3412 if (*lexer == RBRACKET)
3413 {
3414 ++lexer;
3415 match.hit = true;
3416 }
3417 if (match.hit)
3418 {
3419 *parentMatch31 = match;
3420 }
3421 else
3422 {
3423 lexer.ThrowExpectationFailure(span, GetTokenName(RBRACKET));
3424 }
3425 }
3426 if (match.hit)
3427 {
3428 s.end = span.end;
3429 expr.Reset(new IndexingNode(s, ctx->ModuleId(), expr.Release(), index.Release()));
3430 }
3431 *parentMatch30 = match;
3432 }
3433 *parentMatch29 = match;
3434 }
3435 *parentMatch24 = match;
3436 }
3437 *parentMatch23 = match;
3438 }
3439 *parentMatch8 = match;
3440 }
3441 }
3442 *parentMatch7 = match;
3443 if (!match.hit)
3444 {
3445 Match match(false);
3446 Match* parentMatch32 = &match;
3447 lexer.SetPos(save);
3448 {
3449 Match match(false);
3450 Match* parentMatch33 = &match;
3451 {
3452 Match match(false);
3453 Match* parentMatch34 = &match;
3454 {
3455 Match match(false);
3456 Match* parentMatch35 = &match;
3457 {
3458 long pos = lexer.GetPos();
3459 Match match(false);
3460 if (*lexer == LPAREN)
3461 {
3462 ++lexer;
3463 match.hit = true;
3464 }
3465 if (match.hit)
3466 {
3467 expr.Reset(new InvokeNode(s, ctx->ModuleId(), expr.Release()));
3468 }
3469 *parentMatch35 = match;
3470 }
3471 *parentMatch34 = match;
3472 }
3473 if (match.hit)
3474 {
3475 Match match(false);
3476 Match* parentMatch36 = &match;
3477 {
3478 Match match = ExpressionParser.ArgumentList(lexer, ctx, expr.Get());
3479 *parentMatch36 = match;
3480 }
3481 *parentMatch34 = match;
3482 }
3483 *parentMatch33 = match;
3484 }
3485 if (match.hit)
3486 {
3487 Match match(false);
3488 Match* parentMatch37 = &match;
3489 {
3490 Match match(false);
3491 Match* parentMatch38 = &match;
3492 {
3493 long pos = lexer.GetPos();
3494 Span span = lexer.GetSpan();
3495 Match match(true);
3496 Match* parentMatch39 = &match;
3497 {
3498 System.Lex.Span span = lexer.GetSpan();
3499 Match match(false);
3500 if (*lexer == RPAREN)
3501 {
3502 ++lexer;
3503 match.hit = true;
3504 }
3505 if (match.hit)
3506 {
3507 *parentMatch39 = match;
3508 }
3509 else
3510 {
3511 lexer.ThrowExpectationFailure(span, GetTokenName(RPAREN));
3512 }
3513 }
3514 if (match.hit)
3515 {
3516 expr->SetSpanEnd(span.end);
3517 }
3518 *parentMatch38 = match;
3519 }
3520 *parentMatch37 = match;
3521 }
3522 *parentMatch33 = match;
3523 }
3524 *parentMatch32 = match;
3525 }
3526 *parentMatch7 = match;
3527 }
3528 }
3529 *parentMatch6 = match;
3530 }
3531 if (match.hit)
3532 {
3533 *parentMatch5 = match;
3534 }
3535 else
3536 {
3537 lexer.SetPos(save);
3538 break;
3539 }
3540 }
3541 }
3542 }
3543 *parentMatch4 = match;
3544 }
3545 *parentMatch2 = match;
3546 }
3547 *parentMatch1 = match;
3548 }
3549 if (match.hit)
3550 {
3551 {
3552 #if (DEBUG)
3553 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Postfix");
3554 #endif
3555 return Match(true, expr.Release());
3556 }
3557 }
3558 *parentMatch0 = match;
3559 }
3560 #if (DEBUG)
3561 if (writeToLog)
3562 {
3563 if (match.hit)
3564 {
3565 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Postfix");
3566 }
3567 else
3568 {
3569 System.Lex.WriteFailureToLog(lexer, u"Postfix");
3570 }
3571 }
3572 #endif
3573 if (!match.hit)
3574 {
3575 match.value = null;
3576 }
3577 return match;
3578 }
3579 public static Match Primary(ParserFileLexer& lexer, ParsingContext* ctx)
3580 {
3581 #if (DEBUG)
3582 Span debugSpan;
3583 bool writeToLog = lexer.Log() != null;
3584 if (writeToLog)
3585 {
3586 debugSpan = lexer.GetSpan();
3587 System.Lex.WriteBeginRuleToLog(lexer, u"Primary");
3588 }
3589 #endif
3590 Span s;
3591 UniquePtr<Node> expr;
3592 UniquePtr<LiteralNode> literal;
3593 UniquePtr<Node> basicType;
3594 UniquePtr<Node> templateId;
3595 UniquePtr<IdentifierNode> id;
3596 UniquePtr<Node> sizeOf;
3597 UniquePtr<Node> typeName;
3598 UniquePtr<Node> typeId;
3599 UniquePtr<Node> castExpr;
3600 UniquePtr<Node> constructExpr;
3601 UniquePtr<Node> newExpr;
3602 Match match(false);
3603 Match* parentMatch0 = &match;
3604 {
3605 long save = lexer.GetPos();
3606 Match match(false);
3607 Match* parentMatch1 = &match;
3608 {
3609 long save = lexer.GetPos();
3610 Match match(false);
3611 Match* parentMatch2 = &match;
3612 {
3613 long save = lexer.GetPos();
3614 Match match(false);
3615 Match* parentMatch3 = &match;
3616 {
3617 long save = lexer.GetPos();
3618 Match match(false);
3619 Match* parentMatch4 = &match;
3620 {
3621 long save = lexer.GetPos();
3622 Match match(false);
3623 Match* parentMatch5 = &match;
3624 {
3625 long save = lexer.GetPos();
3626 Match match(false);
3627 Match* parentMatch6 = &match;
3628 {
3629 long save = lexer.GetPos();
3630 Match match(false);
3631 Match* parentMatch7 = &match;
3632 {
3633 long save = lexer.GetPos();
3634 Match match(false);
3635 Match* parentMatch8 = &match;
3636 {
3637 long save = lexer.GetPos();
3638 Match match(false);
3639 Match* parentMatch9 = &match;
3640 {
3641 long save = lexer.GetPos();
3642 Match match(false);
3643 Match* parentMatch10 = &match;
3644 {
3645 long save = lexer.GetPos();
3646 Match match(false);
3647 Match* parentMatch11 = &match;
3648 {
3649 long save = lexer.GetPos();
3650 Match match(false);
3651 Match* parentMatch12 = &match;
3652 {
3653 long pos = lexer.GetPos();
3654 Match match(false);
3655 Match* parentMatch13 = &match;
3656 {
3657 Match match(false);
3658 Match* parentMatch14 = &match;
3659 {
3660 Match match(false);
3661 Match* parentMatch15 = &match;
3662 {
3663 Match match(false);
3664 Match* parentMatch16 = &match;
3665 {
3666 long pos = lexer.GetPos();
3667 Span span = lexer.GetSpan();
3668 Match match(false);
3669 if (*lexer == LPAREN)
3670 {
3671 ++lexer;
3672 match.hit = true;
3673 }
3674 if (match.hit)
3675 {
3676 s = span;
3677 }
3678 *parentMatch16 = match;
3679 }
3680 *parentMatch15 = match;
3681 }
3682 if (match.hit)
3683 {
3684 Match match(false);
3685 Match* parentMatch17 = &match;
3686 {
3687 Match match = ExpressionParser.Expression(lexer, ctx);
3688 expr.Reset(cast<Node*>(match.value));
3689 *parentMatch17 = match;
3690 }
3691 *parentMatch15 = match;
3692 }
3693 *parentMatch14 = match;
3694 }
3695 if (match.hit)
3696 {
3697 Match match(false);
3698 Match* parentMatch18 = &match;
3699 {
3700 Match match(false);
3701 Match* parentMatch19 = &match;
3702 {
3703 long pos = lexer.GetPos();
3704 Span span = lexer.GetSpan();
3705 Match match(false);
3706 if (*lexer == RPAREN)
3707 {
3708 ++lexer;
3709 match.hit = true;
3710 }
3711 if (match.hit)
3712 {
3713 s.end = span.end;
3714 }
3715 *parentMatch19 = match;
3716 }
3717 *parentMatch18 = match;
3718 }
3719 *parentMatch14 = match;
3720 }
3721 *parentMatch13 = match;
3722 }
3723 if (match.hit)
3724 {
3725 {
3726 #if (DEBUG)
3727 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Primary");
3728 #endif
3729 return Match(true, new ParenthesizedExpressionNode(s, ctx->ModuleId(), expr.Release()));
3730 }
3731 }
3732 *parentMatch12 = match;
3733 }
3734 *parentMatch11 = match;
3735 if (!match.hit)
3736 {
3737 Match match(false);
3738 Match* parentMatch20 = &match;
3739 lexer.SetPos(save);
3740 {
3741 Match match(false);
3742 Match* parentMatch21 = &match;
3743 {
3744 long pos = lexer.GetPos();
3745 Match match = LiteralParser.Literal(lexer, ctx);
3746 literal.Reset(cast<LiteralNode*>(match.value));
3747 if (match.hit)
3748 {
3749 {
3750 #if (DEBUG)
3751 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Primary");
3752 #endif
3753 return Match(true, literal.Release());
3754 }
3755 }
3756 *parentMatch21 = match;
3757 }
3758 *parentMatch20 = match;
3759 }
3760 *parentMatch11 = match;
3761 }
3762 }
3763 *parentMatch10 = match;
3764 if (!match.hit)
3765 {
3766 Match match(false);
3767 Match* parentMatch22 = &match;
3768 lexer.SetPos(save);
3769 {
3770 Match match(false);
3771 Match* parentMatch23 = &match;
3772 {
3773 long pos = lexer.GetPos();
3774 Match match = BasicTypeParser.BasicType(lexer, ctx);
3775 basicType.Reset(cast<Node*>(match.value));
3776 if (match.hit)
3777 {
3778 {
3779 #if (DEBUG)
3780 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Primary");
3781 #endif
3782 return Match(true, basicType.Release());
3783 }
3784 }
3785 *parentMatch23 = match;
3786 }
3787 *parentMatch22 = match;
3788 }
3789 *parentMatch10 = match;
3790 }
3791 }
3792 *parentMatch9 = match;
3793 if (!match.hit)
3794 {
3795 Match match(false);
3796 Match* parentMatch24 = &match;
3797 lexer.SetPos(save);
3798 {
3799 Match match(false);
3800 Match* parentMatch25 = &match;
3801 {
3802 long pos = lexer.GetPos();
3803 Match match = TemplateParser.TemplateId(lexer, ctx);
3804 templateId.Reset(cast<Node*>(match.value));
3805 if (match.hit)
3806 {
3807 {
3808 #if (DEBUG)
3809 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Primary");
3810 #endif
3811 return Match(true, templateId.Release());
3812 }
3813 }
3814 *parentMatch25 = match;
3815 }
3816 *parentMatch24 = match;
3817 }
3818 *parentMatch9 = match;
3819 }
3820 }
3821 *parentMatch8 = match;
3822 if (!match.hit)
3823 {
3824 Match match(false);
3825 Match* parentMatch26 = &match;
3826 lexer.SetPos(save);
3827 {
3828 Match match(false);
3829 Match* parentMatch27 = &match;
3830 {
3831 long pos = lexer.GetPos();
3832 Match match = IdentifierParser.Identifier(lexer, ctx);
3833 id.Reset(cast<IdentifierNode*>(match.value));
3834 if (match.hit)
3835 {
3836 {
3837 #if (DEBUG)
3838 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Primary");
3839 #endif
3840 return Match(true, id.Release());
3841 }
3842 }
3843 *parentMatch27 = match;
3844 }
3845 *parentMatch26 = match;
3846 }
3847 *parentMatch8 = match;
3848 }
3849 }
3850 *parentMatch7 = match;
3851 if (!match.hit)
3852 {
3853 Match match(false);
3854 Match* parentMatch28 = &match;
3855 lexer.SetPos(save);
3856 {
3857 Match match(false);
3858 Match* parentMatch29 = &match;
3859 {
3860 long pos = lexer.GetPos();
3861 Span span = lexer.GetSpan();
3862 Match match(false);
3863 if (*lexer == THIS)
3864 {
3865 ++lexer;
3866 match.hit = true;
3867 }
3868 if (match.hit)
3869 {
3870 {
3871 #if (DEBUG)
3872 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Primary");
3873 #endif
3874 return Match(true, new ThisNode(span, ctx->ModuleId()));
3875 }
3876 }
3877 *parentMatch29 = match;
3878 }
3879 *parentMatch28 = match;
3880 }
3881 *parentMatch7 = match;
3882 }
3883 }
3884 *parentMatch6 = match;
3885 if (!match.hit)
3886 {
3887 Match match(false);
3888 Match* parentMatch30 = &match;
3889 lexer.SetPos(save);
3890 {
3891 Match match(false);
3892 Match* parentMatch31 = &match;
3893 {
3894 long pos = lexer.GetPos();
3895 Span span = lexer.GetSpan();
3896 Match match(false);
3897 if (*lexer == BASE)
3898 {
3899 ++lexer;
3900 match.hit = true;
3901 }
3902 if (match.hit)
3903 {
3904 {
3905 #if (DEBUG)
3906 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Primary");
3907 #endif
3908 return Match(true, new BaseNode(span, ctx->ModuleId()));
3909 }
3910 }
3911 *parentMatch31 = match;
3912 }
3913 *parentMatch30 = match;
3914 }
3915 *parentMatch6 = match;
3916 }
3917 }
3918 *parentMatch5 = match;
3919 if (!match.hit)
3920 {
3921 Match match(false);
3922 Match* parentMatch32 = &match;
3923 lexer.SetPos(save);
3924 {
3925 Match match(false);
3926 Match* parentMatch33 = &match;
3927 {
3928 long pos = lexer.GetPos();
3929 Match match = ExpressionParser.SizeOfExpr(lexer, ctx);
3930 sizeOf.Reset(cast<Node*>(match.value));
3931 if (match.hit)
3932 {
3933 {
3934 #if (DEBUG)
3935 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Primary");
3936 #endif
3937 return Match(true, sizeOf.Release());
3938 }
3939 }
3940 *parentMatch33 = match;
3941 }
3942 *parentMatch32 = match;
3943 }
3944 *parentMatch5 = match;
3945 }
3946 }
3947 *parentMatch4 = match;
3948 if (!match.hit)
3949 {
3950 Match match(false);
3951 Match* parentMatch34 = &match;
3952 lexer.SetPos(save);
3953 {
3954 Match match(false);
3955 Match* parentMatch35 = &match;
3956 {
3957 long pos = lexer.GetPos();
3958 Match match = ExpressionParser.TypeNameExpr(lexer, ctx);
3959 typeName.Reset(cast<Node*>(match.value));
3960 if (match.hit)
3961 {
3962 {
3963 #if (DEBUG)
3964 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Primary");
3965 #endif
3966 return Match(true, typeName.Release());
3967 }
3968 }
3969 *parentMatch35 = match;
3970 }
3971 *parentMatch34 = match;
3972 }
3973 *parentMatch4 = match;
3974 }
3975 }
3976 *parentMatch3 = match;
3977 if (!match.hit)
3978 {
3979 Match match(false);
3980 Match* parentMatch36 = &match;
3981 lexer.SetPos(save);
3982 {
3983 Match match(false);
3984 Match* parentMatch37 = &match;
3985 {
3986 long pos = lexer.GetPos();
3987 Match match = ExpressionParser.TypeIdExpr(lexer, ctx);
3988 typeId.Reset(cast<Node*>(match.value));
3989 if (match.hit)
3990 {
3991 {
3992 #if (DEBUG)
3993 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Primary");
3994 #endif
3995 return Match(true, typeId.Release());
3996 }
3997 }
3998 *parentMatch37 = match;
3999 }
4000 *parentMatch36 = match;
4001 }
4002 *parentMatch3 = match;
4003 }
4004 }
4005 *parentMatch2 = match;
4006 if (!match.hit)
4007 {
4008 Match match(false);
4009 Match* parentMatch38 = &match;
4010 lexer.SetPos(save);
4011 {
4012 Match match(false);
4013 Match* parentMatch39 = &match;
4014 {
4015 long pos = lexer.GetPos();
4016 Match match = ExpressionParser.CastExpr(lexer, ctx);
4017 castExpr.Reset(cast<Node*>(match.value));
4018 if (match.hit)
4019 {
4020 {
4021 #if (DEBUG)
4022 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Primary");
4023 #endif
4024 return Match(true, castExpr.Release());
4025 }
4026 }
4027 *parentMatch39 = match;
4028 }
4029 *parentMatch38 = match;
4030 }
4031 *parentMatch2 = match;
4032 }
4033 }
4034 *parentMatch1 = match;
4035 if (!match.hit)
4036 {
4037 Match match(false);
4038 Match* parentMatch40 = &match;
4039 lexer.SetPos(save);
4040 {
4041 Match match(false);
4042 Match* parentMatch41 = &match;
4043 {
4044 long pos = lexer.GetPos();
4045 Match match = ExpressionParser.ConstructExpr(lexer, ctx);
4046 constructExpr.Reset(cast<Node*>(match.value));
4047 if (match.hit)
4048 {
4049 {
4050 #if (DEBUG)
4051 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Primary");
4052 #endif
4053 return Match(true, constructExpr.Release());
4054 }
4055 }
4056 *parentMatch41 = match;
4057 }
4058 *parentMatch40 = match;
4059 }
4060 *parentMatch1 = match;
4061 }
4062 }
4063 *parentMatch0 = match;
4064 if (!match.hit)
4065 {
4066 Match match(false);
4067 Match* parentMatch42 = &match;
4068 lexer.SetPos(save);
4069 {
4070 Match match(false);
4071 Match* parentMatch43 = &match;
4072 {
4073 long pos = lexer.GetPos();
4074 Match match = ExpressionParser.NewExpr(lexer, ctx);
4075 newExpr.Reset(cast<Node*>(match.value));
4076 if (match.hit)
4077 {
4078 {
4079 #if (DEBUG)
4080 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Primary");
4081 #endif
4082 return Match(true, newExpr.Release());
4083 }
4084 }
4085 *parentMatch43 = match;
4086 }
4087 *parentMatch42 = match;
4088 }
4089 *parentMatch0 = match;
4090 }
4091 }
4092 #if (DEBUG)
4093 if (writeToLog)
4094 {
4095 if (match.hit)
4096 {
4097 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Primary");
4098 }
4099 else
4100 {
4101 System.Lex.WriteFailureToLog(lexer, u"Primary");
4102 }
4103 }
4104 #endif
4105 if (!match.hit)
4106 {
4107 match.value = null;
4108 }
4109 return match;
4110 }
4111 public static Match SizeOfExpr(ParserFileLexer& lexer, ParsingContext* ctx)
4112 {
4113 #if (DEBUG)
4114 Span debugSpan;
4115 bool writeToLog = lexer.Log() != null;
4116 if (writeToLog)
4117 {
4118 debugSpan = lexer.GetSpan();
4119 System.Lex.WriteBeginRuleToLog(lexer, u"SizeOfExpr");
4120 }
4121 #endif
4122 Span s;
4123 UniquePtr<Node> expr;
4124 Match match(false);
4125 Match* parentMatch0 = &match;
4126 {
4127 long pos = lexer.GetPos();
4128 Span span = lexer.GetSpan();
4129 Match match(false);
4130 Match* parentMatch1 = &match;
4131 {
4132 Match match(false);
4133 Match* parentMatch2 = &match;
4134 {
4135 Match match(false);
4136 Match* parentMatch3 = &match;
4137 {
4138 Match match(false);
4139 Match* parentMatch4 = &match;
4140 {
4141 Match match(false);
4142 Match* parentMatch5 = &match;
4143 {
4144 long pos = lexer.GetPos();
4145 Span span = lexer.GetSpan();
4146 Match match(false);
4147 if (*lexer == SIZEOF)
4148 {
4149 ++lexer;
4150 match.hit = true;
4151 }
4152 if (match.hit)
4153 {
4154 s = span;
4155 }
4156 *parentMatch5 = match;
4157 }
4158 *parentMatch4 = match;
4159 }
4160 if (match.hit)
4161 {
4162 Match match(false);
4163 Match* parentMatch6 = &match;
4164 {
4165 Match match(true);
4166 Match* parentMatch7 = &match;
4167 {
4168 System.Lex.Span span = lexer.GetSpan();
4169 Match match(false);
4170 if (*lexer == LPAREN)
4171 {
4172 ++lexer;
4173 match.hit = true;
4174 }
4175 if (match.hit)
4176 {
4177 *parentMatch7 = match;
4178 }
4179 else
4180 {
4181 lexer.ThrowExpectationFailure(span, GetTokenName(LPAREN));
4182 }
4183 }
4184 *parentMatch6 = match;
4185 }
4186 *parentMatch4 = match;
4187 }
4188 *parentMatch3 = match;
4189 }
4190 if (match.hit)
4191 {
4192 Match match(false);
4193 Match* parentMatch8 = &match;
4194 {
4195 Match match(true);
4196 Match* parentMatch9 = &match;
4197 {
4198 System.Lex.Span span = lexer.GetSpan();
4199 Match match = ExpressionParser.Expression(lexer, ctx);
4200 expr.Reset(cast<Node*>(match.value));
4201 if (match.hit)
4202 {
4203 *parentMatch9 = match;
4204 }
4205 else
4206 {
4207 lexer.ThrowExpectationFailure(span, u"expression");
4208 }
4209 }
4210 *parentMatch8 = match;
4211 }
4212 *parentMatch3 = match;
4213 }
4214 *parentMatch2 = match;
4215 }
4216 if (match.hit)
4217 {
4218 Match match(false);
4219 Match* parentMatch10 = &match;
4220 {
4221 Match match(true);
4222 Match* parentMatch11 = &match;
4223 {
4224 System.Lex.Span span = lexer.GetSpan();
4225 Match match(false);
4226 if (*lexer == RPAREN)
4227 {
4228 ++lexer;
4229 match.hit = true;
4230 }
4231 if (match.hit)
4232 {
4233 *parentMatch11 = match;
4234 }
4235 else
4236 {
4237 lexer.ThrowExpectationFailure(span, GetTokenName(RPAREN));
4238 }
4239 }
4240 *parentMatch10 = match;
4241 }
4242 *parentMatch2 = match;
4243 }
4244 *parentMatch1 = match;
4245 }
4246 if (match.hit)
4247 {
4248 s.end = span.end;
4249 {
4250 #if (DEBUG)
4251 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"SizeOfExpr");
4252 #endif
4253 return Match(true, new SizeOfNode(s, ctx->ModuleId(), expr.Release()));
4254 }
4255 }
4256 *parentMatch0 = match;
4257 }
4258 #if (DEBUG)
4259 if (writeToLog)
4260 {
4261 if (match.hit)
4262 {
4263 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"SizeOfExpr");
4264 }
4265 else
4266 {
4267 System.Lex.WriteFailureToLog(lexer, u"SizeOfExpr");
4268 }
4269 }
4270 #endif
4271 if (!match.hit)
4272 {
4273 match.value = null;
4274 }
4275 return match;
4276 }
4277 public static Match TypeNameExpr(ParserFileLexer& lexer, ParsingContext* ctx)
4278 {
4279 #if (DEBUG)
4280 Span debugSpan;
4281 bool writeToLog = lexer.Log() != null;
4282 if (writeToLog)
4283 {
4284 debugSpan = lexer.GetSpan();
4285 System.Lex.WriteBeginRuleToLog(lexer, u"TypeNameExpr");
4286 }
4287 #endif
4288 Span s;
4289 UniquePtr<Node> expr;
4290 Match match(false);
4291 Match* parentMatch0 = &match;
4292 {
4293 long pos = lexer.GetPos();
4294 Span span = lexer.GetSpan();
4295 Match match(false);
4296 Match* parentMatch1 = &match;
4297 {
4298 Match match(false);
4299 Match* parentMatch2 = &match;
4300 {
4301 Match match(false);
4302 Match* parentMatch3 = &match;
4303 {
4304 Match match(false);
4305 Match* parentMatch4 = &match;
4306 {
4307 Match match(false);
4308 Match* parentMatch5 = &match;
4309 {
4310 long pos = lexer.GetPos();
4311 Span span = lexer.GetSpan();
4312 Match match(false);
4313 if (*lexer == TYPENAME)
4314 {
4315 ++lexer;
4316 match.hit = true;
4317 }
4318 if (match.hit)
4319 {
4320 s = span;
4321 }
4322 *parentMatch5 = match;
4323 }
4324 *parentMatch4 = match;
4325 }
4326 if (match.hit)
4327 {
4328 Match match(false);
4329 Match* parentMatch6 = &match;
4330 {
4331 Match match(true);
4332 Match* parentMatch7 = &match;
4333 {
4334 System.Lex.Span span = lexer.GetSpan();
4335 Match match(false);
4336 if (*lexer == LPAREN)
4337 {
4338 ++lexer;
4339 match.hit = true;
4340 }
4341 if (match.hit)
4342 {
4343 *parentMatch7 = match;
4344 }
4345 else
4346 {
4347 lexer.ThrowExpectationFailure(span, GetTokenName(LPAREN));
4348 }
4349 }
4350 *parentMatch6 = match;
4351 }
4352 *parentMatch4 = match;
4353 }
4354 *parentMatch3 = match;
4355 }
4356 if (match.hit)
4357 {
4358 Match match(false);
4359 Match* parentMatch8 = &match;
4360 {
4361 Match match(true);
4362 Match* parentMatch9 = &match;
4363 {
4364 System.Lex.Span span = lexer.GetSpan();
4365 Match match = ExpressionParser.Expression(lexer, ctx);
4366 expr.Reset(cast<Node*>(match.value));
4367 if (match.hit)
4368 {
4369 *parentMatch9 = match;
4370 }
4371 else
4372 {
4373 lexer.ThrowExpectationFailure(span, u"expression");
4374 }
4375 }
4376 *parentMatch8 = match;
4377 }
4378 *parentMatch3 = match;
4379 }
4380 *parentMatch2 = match;
4381 }
4382 if (match.hit)
4383 {
4384 Match match(false);
4385 Match* parentMatch10 = &match;
4386 {
4387 Match match(true);
4388 Match* parentMatch11 = &match;
4389 {
4390 System.Lex.Span span = lexer.GetSpan();
4391 Match match(false);
4392 if (*lexer == RPAREN)
4393 {
4394 ++lexer;
4395 match.hit = true;
4396 }
4397 if (match.hit)
4398 {
4399 *parentMatch11 = match;
4400 }
4401 else
4402 {
4403 lexer.ThrowExpectationFailure(span, GetTokenName(RPAREN));
4404 }
4405 }
4406 *parentMatch10 = match;
4407 }
4408 *parentMatch2 = match;
4409 }
4410 *parentMatch1 = match;
4411 }
4412 if (match.hit)
4413 {
4414 s.end = span.end;
4415 {
4416 #if (DEBUG)
4417 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"TypeNameExpr");
4418 #endif
4419 return Match(true, new TypeNameNode(s, ctx->ModuleId(), expr.Release()));
4420 }
4421 }
4422 *parentMatch0 = match;
4423 }
4424 #if (DEBUG)
4425 if (writeToLog)
4426 {
4427 if (match.hit)
4428 {
4429 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"TypeNameExpr");
4430 }
4431 else
4432 {
4433 System.Lex.WriteFailureToLog(lexer, u"TypeNameExpr");
4434 }
4435 }
4436 #endif
4437 if (!match.hit)
4438 {
4439 match.value = null;
4440 }
4441 return match;
4442 }
4443 public static Match TypeIdExpr(ParserFileLexer& lexer, ParsingContext* ctx)
4444 {
4445 #if (DEBUG)
4446 Span debugSpan;
4447 bool writeToLog = lexer.Log() != null;
4448 if (writeToLog)
4449 {
4450 debugSpan = lexer.GetSpan();
4451 System.Lex.WriteBeginRuleToLog(lexer, u"TypeIdExpr");
4452 }
4453 #endif
4454 Span s;
4455 UniquePtr<Node> expr;
4456 Match match(false);
4457 Match* parentMatch0 = &match;
4458 {
4459 long pos = lexer.GetPos();
4460 Span span = lexer.GetSpan();
4461 Match match(false);
4462 Match* parentMatch1 = &match;
4463 {
4464 Match match(false);
4465 Match* parentMatch2 = &match;
4466 {
4467 Match match(false);
4468 Match* parentMatch3 = &match;
4469 {
4470 Match match(false);
4471 Match* parentMatch4 = &match;
4472 {
4473 Match match(false);
4474 Match* parentMatch5 = &match;
4475 {
4476 long pos = lexer.GetPos();
4477 Span span = lexer.GetSpan();
4478 Match match(false);
4479 if (*lexer == TYPEID)
4480 {
4481 ++lexer;
4482 match.hit = true;
4483 }
4484 if (match.hit)
4485 {
4486 s = span;
4487 }
4488 *parentMatch5 = match;
4489 }
4490 *parentMatch4 = match;
4491 }
4492 if (match.hit)
4493 {
4494 Match match(false);
4495 Match* parentMatch6 = &match;
4496 {
4497 Match match(true);
4498 Match* parentMatch7 = &match;
4499 {
4500 System.Lex.Span span = lexer.GetSpan();
4501 Match match(false);
4502 if (*lexer == LPAREN)
4503 {
4504 ++lexer;
4505 match.hit = true;
4506 }
4507 if (match.hit)
4508 {
4509 *parentMatch7 = match;
4510 }
4511 else
4512 {
4513 lexer.ThrowExpectationFailure(span, GetTokenName(LPAREN));
4514 }
4515 }
4516 *parentMatch6 = match;
4517 }
4518 *parentMatch4 = match;
4519 }
4520 *parentMatch3 = match;
4521 }
4522 if (match.hit)
4523 {
4524 Match match(false);
4525 Match* parentMatch8 = &match;
4526 {
4527 Match match(true);
4528 Match* parentMatch9 = &match;
4529 {
4530 System.Lex.Span span = lexer.GetSpan();
4531 Match match = ExpressionParser.Expression(lexer, ctx);
4532 expr.Reset(cast<Node*>(match.value));
4533 if (match.hit)
4534 {
4535 *parentMatch9 = match;
4536 }
4537 else
4538 {
4539 lexer.ThrowExpectationFailure(span, u"expression");
4540 }
4541 }
4542 *parentMatch8 = match;
4543 }
4544 *parentMatch3 = match;
4545 }
4546 *parentMatch2 = match;
4547 }
4548 if (match.hit)
4549 {
4550 Match match(false);
4551 Match* parentMatch10 = &match;
4552 {
4553 Match match(true);
4554 Match* parentMatch11 = &match;
4555 {
4556 System.Lex.Span span = lexer.GetSpan();
4557 Match match(false);
4558 if (*lexer == RPAREN)
4559 {
4560 ++lexer;
4561 match.hit = true;
4562 }
4563 if (match.hit)
4564 {
4565 *parentMatch11 = match;
4566 }
4567 else
4568 {
4569 lexer.ThrowExpectationFailure(span, GetTokenName(RPAREN));
4570 }
4571 }
4572 *parentMatch10 = match;
4573 }
4574 *parentMatch2 = match;
4575 }
4576 *parentMatch1 = match;
4577 }
4578 if (match.hit)
4579 {
4580 s.end = span.end;
4581 {
4582 #if (DEBUG)
4583 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"TypeIdExpr");
4584 #endif
4585 return Match(true, new TypeIdNode(s, ctx->ModuleId(), expr.Release()));
4586 }
4587 }
4588 *parentMatch0 = match;
4589 }
4590 #if (DEBUG)
4591 if (writeToLog)
4592 {
4593 if (match.hit)
4594 {
4595 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"TypeIdExpr");
4596 }
4597 else
4598 {
4599 System.Lex.WriteFailureToLog(lexer, u"TypeIdExpr");
4600 }
4601 }
4602 #endif
4603 if (!match.hit)
4604 {
4605 match.value = null;
4606 }
4607 return match;
4608 }
4609 public static Match CastExpr(ParserFileLexer& lexer, ParsingContext* ctx)
4610 {
4611 #if (DEBUG)
4612 Span debugSpan;
4613 bool writeToLog = lexer.Log() != null;
4614 if (writeToLog)
4615 {
4616 debugSpan = lexer.GetSpan();
4617 System.Lex.WriteBeginRuleToLog(lexer, u"CastExpr");
4618 }
4619 #endif
4620 Span s;
4621 UniquePtr<Node> typeExpr;
4622 UniquePtr<Node> expr;
4623 Match match(false);
4624 Match* parentMatch0 = &match;
4625 {
4626 long pos = lexer.GetPos();
4627 Span span = lexer.GetSpan();
4628 Match match(false);
4629 Match* parentMatch1 = &match;
4630 {
4631 Match match(false);
4632 Match* parentMatch2 = &match;
4633 {
4634 Match match(false);
4635 Match* parentMatch3 = &match;
4636 {
4637 Match match(false);
4638 Match* parentMatch4 = &match;
4639 {
4640 Match match(false);
4641 Match* parentMatch5 = &match;
4642 {
4643 Match match(false);
4644 Match* parentMatch6 = &match;
4645 {
4646 Match match(false);
4647 Match* parentMatch7 = &match;
4648 {
4649 Match match(false);
4650 Match* parentMatch8 = &match;
4651 {
4652 long pos = lexer.GetPos();
4653 Span span = lexer.GetSpan();
4654 Match match(false);
4655 if (*lexer == CAST)
4656 {
4657 ++lexer;
4658 match.hit = true;
4659 }
4660 if (match.hit)
4661 {
4662 s = span;
4663 }
4664 *parentMatch8 = match;
4665 }
4666 *parentMatch7 = match;
4667 }
4668 if (match.hit)
4669 {
4670 Match match(false);
4671 Match* parentMatch9 = &match;
4672 {
4673 Match match(true);
4674 Match* parentMatch10 = &match;
4675 {
4676 System.Lex.Span span = lexer.GetSpan();
4677 Match match(false);
4678 if (*lexer == LANGLE)
4679 {
4680 ++lexer;
4681 match.hit = true;
4682 }
4683 if (match.hit)
4684 {
4685 *parentMatch10 = match;
4686 }
4687 else
4688 {
4689 lexer.ThrowExpectationFailure(span, GetTokenName(LANGLE));
4690 }
4691 }
4692 *parentMatch9 = match;
4693 }
4694 *parentMatch7 = match;
4695 }
4696 *parentMatch6 = match;
4697 }
4698 if (match.hit)
4699 {
4700 Match match(false);
4701 Match* parentMatch11 = &match;
4702 {
4703 Match match(true);
4704 Match* parentMatch12 = &match;
4705 {
4706 System.Lex.Span span = lexer.GetSpan();
4707 Match match = TypeExprParser.TypeExpr(lexer, ctx);
4708 typeExpr.Reset(cast<Node*>(match.value));
4709 if (match.hit)
4710 {
4711 *parentMatch12 = match;
4712 }
4713 else
4714 {
4715 lexer.ThrowExpectationFailure(span, u"type expression");
4716 }
4717 }
4718 *parentMatch11 = match;
4719 }
4720 *parentMatch6 = match;
4721 }
4722 *parentMatch5 = match;
4723 }
4724 if (match.hit)
4725 {
4726 Match match(false);
4727 Match* parentMatch13 = &match;
4728 {
4729 Match match(true);
4730 Match* parentMatch14 = &match;
4731 {
4732 System.Lex.Span span = lexer.GetSpan();
4733 Match match(false);
4734 if (*lexer == RANGLE)
4735 {
4736 ++lexer;
4737 match.hit = true;
4738 }
4739 if (match.hit)
4740 {
4741 *parentMatch14 = match;
4742 }
4743 else
4744 {
4745 lexer.ThrowExpectationFailure(span, GetTokenName(RANGLE));
4746 }
4747 }
4748 *parentMatch13 = match;
4749 }
4750 *parentMatch5 = match;
4751 }
4752 *parentMatch4 = match;
4753 }
4754 if (match.hit)
4755 {
4756 Match match(false);
4757 Match* parentMatch15 = &match;
4758 {
4759 Match match(true);
4760 Match* parentMatch16 = &match;
4761 {
4762 System.Lex.Span span = lexer.GetSpan();
4763 Match match(false);
4764 if (*lexer == LPAREN)
4765 {
4766 ++lexer;
4767 match.hit = true;
4768 }
4769 if (match.hit)
4770 {
4771 *parentMatch16 = match;
4772 }
4773 else
4774 {
4775 lexer.ThrowExpectationFailure(span, GetTokenName(LPAREN));
4776 }
4777 }
4778 *parentMatch15 = match;
4779 }
4780 *parentMatch4 = match;
4781 }
4782 *parentMatch3 = match;
4783 }
4784 if (match.hit)
4785 {
4786 Match match(false);
4787 Match* parentMatch17 = &match;
4788 {
4789 Match match(true);
4790 Match* parentMatch18 = &match;
4791 {
4792 System.Lex.Span span = lexer.GetSpan();
4793 Match match = ExpressionParser.Expression(lexer, ctx);
4794 expr.Reset(cast<Node*>(match.value));
4795 if (match.hit)
4796 {
4797 *parentMatch18 = match;
4798 }
4799 else
4800 {
4801 lexer.ThrowExpectationFailure(span, u"expression");
4802 }
4803 }
4804 *parentMatch17 = match;
4805 }
4806 *parentMatch3 = match;
4807 }
4808 *parentMatch2 = match;
4809 }
4810 if (match.hit)
4811 {
4812 Match match(false);
4813 Match* parentMatch19 = &match;
4814 {
4815 Match match(true);
4816 Match* parentMatch20 = &match;
4817 {
4818 System.Lex.Span span = lexer.GetSpan();
4819 Match match(false);
4820 if (*lexer == RPAREN)
4821 {
4822 ++lexer;
4823 match.hit = true;
4824 }
4825 if (match.hit)
4826 {
4827 *parentMatch20 = match;
4828 }
4829 else
4830 {
4831 lexer.ThrowExpectationFailure(span, GetTokenName(RPAREN));
4832 }
4833 }
4834 *parentMatch19 = match;
4835 }
4836 *parentMatch2 = match;
4837 }
4838 *parentMatch1 = match;
4839 }
4840 if (match.hit)
4841 {
4842 s.end = span.end;
4843 {
4844 #if (DEBUG)
4845 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"CastExpr");
4846 #endif
4847 return Match(true, new CastNode(s, ctx->ModuleId(), typeExpr.Release(), expr.Release()));
4848 }
4849 }
4850 *parentMatch0 = match;
4851 }
4852 #if (DEBUG)
4853 if (writeToLog)
4854 {
4855 if (match.hit)
4856 {
4857 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"CastExpr");
4858 }
4859 else
4860 {
4861 System.Lex.WriteFailureToLog(lexer, u"CastExpr");
4862 }
4863 }
4864 #endif
4865 if (!match.hit)
4866 {
4867 match.value = null;
4868 }
4869 return match;
4870 }
4871 public static Match ConstructExpr(ParserFileLexer& lexer, ParsingContext* ctx)
4872 {
4873 #if (DEBUG)
4874 Span debugSpan;
4875 bool writeToLog = lexer.Log() != null;
4876 if (writeToLog)
4877 {
4878 debugSpan = lexer.GetSpan();
4879 System.Lex.WriteBeginRuleToLog(lexer, u"ConstructExpr");
4880 }
4881 #endif
4882 UniquePtr<Node> expr;
4883 Span s;
4884 UniquePtr<Node> typeExpr;
4885 Match match(false);
4886 Match* parentMatch0 = &match;
4887 {
4888 Match match(false);
4889 Match* parentMatch1 = &match;
4890 {
4891 Match match(false);
4892 Match* parentMatch2 = &match;
4893 {
4894 Match match(false);
4895 Match* parentMatch3 = &match;
4896 {
4897 long pos = lexer.GetPos();
4898 Match match(false);
4899 Match* parentMatch4 = &match;
4900 {
4901 Match match(false);
4902 Match* parentMatch5 = &match;
4903 {
4904 Match match(false);
4905 Match* parentMatch6 = &match;
4906 {
4907 Match match(false);
4908 Match* parentMatch7 = &match;
4909 {
4910 Match match(false);
4911 Match* parentMatch8 = &match;
4912 {
4913 long pos = lexer.GetPos();
4914 Span span = lexer.GetSpan();
4915 Match match(false);
4916 if (*lexer == CONSTRUCT)
4917 {
4918 ++lexer;
4919 match.hit = true;
4920 }
4921 if (match.hit)
4922 {
4923 s = span;
4924 }
4925 *parentMatch8 = match;
4926 }
4927 *parentMatch7 = match;
4928 }
4929 if (match.hit)
4930 {
4931 Match match(false);
4932 Match* parentMatch9 = &match;
4933 {
4934 Match match(true);
4935 Match* parentMatch10 = &match;
4936 {
4937 System.Lex.Span span = lexer.GetSpan();
4938 Match match(false);
4939 if (*lexer == LANGLE)
4940 {
4941 ++lexer;
4942 match.hit = true;
4943 }
4944 if (match.hit)
4945 {
4946 *parentMatch10 = match;
4947 }
4948 else
4949 {
4950 lexer.ThrowExpectationFailure(span, GetTokenName(LANGLE));
4951 }
4952 }
4953 *parentMatch9 = match;
4954 }
4955 *parentMatch7 = match;
4956 }
4957 *parentMatch6 = match;
4958 }
4959 if (match.hit)
4960 {
4961 Match match(false);
4962 Match* parentMatch11 = &match;
4963 {
4964 Match match(true);
4965 Match* parentMatch12 = &match;
4966 {
4967 System.Lex.Span span = lexer.GetSpan();
4968 Match match = TypeExprParser.TypeExpr(lexer, ctx);
4969 typeExpr.Reset(cast<Node*>(match.value));
4970 if (match.hit)
4971 {
4972 *parentMatch12 = match;
4973 }
4974 else
4975 {
4976 lexer.ThrowExpectationFailure(span, u"type expression");
4977 }
4978 }
4979 *parentMatch11 = match;
4980 }
4981 *parentMatch6 = match;
4982 }
4983 *parentMatch5 = match;
4984 }
4985 if (match.hit)
4986 {
4987 Match match(false);
4988 Match* parentMatch13 = &match;
4989 {
4990 Match match(true);
4991 Match* parentMatch14 = &match;
4992 {
4993 System.Lex.Span span = lexer.GetSpan();
4994 Match match(false);
4995 if (*lexer == RANGLE)
4996 {
4997 ++lexer;
4998 match.hit = true;
4999 }
5000 if (match.hit)
5001 {
5002 *parentMatch14 = match;
5003 }
5004 else
5005 {
5006 lexer.ThrowExpectationFailure(span, GetTokenName(RANGLE));
5007 }
5008 }
5009 *parentMatch13 = match;
5010 }
5011 *parentMatch5 = match;
5012 }
5013 *parentMatch4 = match;
5014 }
5015 if (match.hit)
5016 {
5017 expr.Reset(new ConstructNode(s, ctx->ModuleId(), typeExpr.Release()));
5018 }
5019 *parentMatch3 = match;
5020 }
5021 *parentMatch2 = match;
5022 }
5023 if (match.hit)
5024 {
5025 Match match(false);
5026 Match* parentMatch15 = &match;
5027 {
5028 Match match(true);
5029 Match* parentMatch16 = &match;
5030 {
5031 System.Lex.Span span = lexer.GetSpan();
5032 Match match(false);
5033 if (*lexer == LPAREN)
5034 {
5035 ++lexer;
5036 match.hit = true;
5037 }
5038 if (match.hit)
5039 {
5040 *parentMatch16 = match;
5041 }
5042 else
5043 {
5044 lexer.ThrowExpectationFailure(span, GetTokenName(LPAREN));
5045 }
5046 }
5047 *parentMatch15 = match;
5048 }
5049 *parentMatch2 = match;
5050 }
5051 *parentMatch1 = match;
5052 }
5053 if (match.hit)
5054 {
5055 Match match(false);
5056 Match* parentMatch17 = &match;
5057 {
5058 Match match(true);
5059 Match* parentMatch18 = &match;
5060 {
5061 System.Lex.Span span = lexer.GetSpan();
5062 Match match = ExpressionParser.ExpressionList(lexer, ctx, expr.Get());
5063 if (match.hit)
5064 {
5065 *parentMatch18 = match;
5066 }
5067 else
5068 {
5069 lexer.ThrowExpectationFailure(span, u"expression list");
5070 }
5071 }
5072 *parentMatch17 = match;
5073 }
5074 *parentMatch1 = match;
5075 }
5076 *parentMatch0 = match;
5077 }
5078 if (match.hit)
5079 {
5080 Match match(false);
5081 Match* parentMatch19 = &match;
5082 {
5083 Match match(false);
5084 Match* parentMatch20 = &match;
5085 {
5086 long pos = lexer.GetPos();
5087 Span span = lexer.GetSpan();
5088 Match match(true);
5089 Match* parentMatch21 = &match;
5090 {
5091 System.Lex.Span span = lexer.GetSpan();
5092 Match match(false);
5093 if (*lexer == RPAREN)
5094 {
5095 ++lexer;
5096 match.hit = true;
5097 }
5098 if (match.hit)
5099 {
5100 *parentMatch21 = match;
5101 }
5102 else
5103 {
5104 lexer.ThrowExpectationFailure(span, GetTokenName(RPAREN));
5105 }
5106 }
5107 if (match.hit)
5108 {
5109 expr->SetSpanEnd(span.end);
5110 {
5111 #if (DEBUG)
5112 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"ConstructExpr");
5113 #endif
5114 return Match(true, expr.Release());
5115 }
5116 }
5117 *parentMatch20 = match;
5118 }
5119 *parentMatch19 = match;
5120 }
5121 *parentMatch0 = match;
5122 }
5123 #if (DEBUG)
5124 if (writeToLog)
5125 {
5126 if (match.hit)
5127 {
5128 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"ConstructExpr");
5129 }
5130 else
5131 {
5132 System.Lex.WriteFailureToLog(lexer, u"ConstructExpr");
5133 }
5134 }
5135 #endif
5136 if (!match.hit)
5137 {
5138 match.value = null;
5139 }
5140 return match;
5141 }
5142 public static Match NewExpr(ParserFileLexer& lexer, ParsingContext* ctx)
5143 {
5144 #if (DEBUG)
5145 Span debugSpan;
5146 bool writeToLog = lexer.Log() != null;
5147 if (writeToLog)
5148 {
5149 debugSpan = lexer.GetSpan();
5150 System.Lex.WriteBeginRuleToLog(lexer, u"NewExpr");
5151 }
5152 #endif
5153 UniquePtr<Node> expr;
5154 Span s;
5155 UniquePtr<Node> typeExpr;
5156 Match match(false);
5157 Match* parentMatch0 = &match;
5158 {
5159 long pos = lexer.GetPos();
5160 Match match(false);
5161 Match* parentMatch1 = &match;
5162 {
5163 Match match(false);
5164 Match* parentMatch2 = &match;
5165 {
5166 Match match(false);
5167 Match* parentMatch3 = &match;
5168 {
5169 Match match(false);
5170 Match* parentMatch4 = &match;
5171 {
5172 long pos = lexer.GetPos();
5173 Span span = lexer.GetSpan();
5174 Match match(false);
5175 if (*lexer == NEW)
5176 {
5177 ++lexer;
5178 match.hit = true;
5179 }
5180 if (match.hit)
5181 {
5182 s = span;
5183 }
5184 *parentMatch4 = match;
5185 }
5186 *parentMatch3 = match;
5187 }
5188 if (match.hit)
5189 {
5190 Match match(false);
5191 Match* parentMatch5 = &match;
5192 {
5193 Match match(false);
5194 Match* parentMatch6 = &match;
5195 {
5196 long pos = lexer.GetPos();
5197 Span span = lexer.GetSpan();
5198 Match match(true);
5199 Match* parentMatch7 = &match;
5200 {
5201 System.Lex.Span span = lexer.GetSpan();
5202 Match match = TypeExprParser.TypeExpr(lexer, ctx);
5203 typeExpr.Reset(cast<Node*>(match.value));
5204 if (match.hit)
5205 {
5206 *parentMatch7 = match;
5207 }
5208 else
5209 {
5210 lexer.ThrowExpectationFailure(span, u"type expression");
5211 }
5212 }
5213 if (match.hit)
5214 {
5215 s.end = span.end;
5216 expr.Reset(new NewNode(s, ctx->ModuleId(), typeExpr.Release()));
5217 }
5218 *parentMatch6 = match;
5219 }
5220 *parentMatch5 = match;
5221 }
5222 *parentMatch3 = match;
5223 }
5224 *parentMatch2 = match;
5225 }
5226 if (match.hit)
5227 {
5228 Match match(false);
5229 Match* parentMatch8 = &match;
5230 {
5231 Match match(true);
5232 long save = lexer.GetPos();
5233 Match* parentMatch9 = &match;
5234 {
5235 Match match(false);
5236 Match* parentMatch10 = &match;
5237 {
5238 Match match(false);
5239 Match* parentMatch11 = &match;
5240 {
5241 Match match(false);
5242 Match* parentMatch12 = &match;
5243 {
5244 Match match(false);
5245 if (*lexer == LPAREN)
5246 {
5247 ++lexer;
5248 match.hit = true;
5249 }
5250 *parentMatch12 = match;
5251 }
5252 if (match.hit)
5253 {
5254 Match match(false);
5255 Match* parentMatch13 = &match;
5256 {
5257 Match match = ExpressionParser.ArgumentList(lexer, ctx, expr.Get());
5258 *parentMatch13 = match;
5259 }
5260 *parentMatch12 = match;
5261 }
5262 *parentMatch11 = match;
5263 }
5264 if (match.hit)
5265 {
5266 Match match(false);
5267 Match* parentMatch14 = &match;
5268 {
5269 Match match(false);
5270 Match* parentMatch15 = &match;
5271 {
5272 long pos = lexer.GetPos();
5273 Span span = lexer.GetSpan();
5274 Match match(false);
5275 if (*lexer == RPAREN)
5276 {
5277 ++lexer;
5278 match.hit = true;
5279 }
5280 if (match.hit)
5281 {
5282 expr->SetSpanEnd(span.end);
5283 }
5284 *parentMatch15 = match;
5285 }
5286 *parentMatch14 = match;
5287 }
5288 *parentMatch11 = match;
5289 }
5290 *parentMatch10 = match;
5291 }
5292 if (match.hit)
5293 {
5294 *parentMatch9 = match;
5295 }
5296 else
5297 {
5298 lexer.SetPos(save);
5299 }
5300 }
5301 *parentMatch8 = match;
5302 }
5303 *parentMatch2 = match;
5304 }
5305 *parentMatch1 = match;
5306 }
5307 if (match.hit)
5308 {
5309 {
5310 #if (DEBUG)
5311 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"NewExpr");
5312 #endif
5313 return Match(true, expr.Release());
5314 }
5315 }
5316 *parentMatch0 = match;
5317 }
5318 #if (DEBUG)
5319 if (writeToLog)
5320 {
5321 if (match.hit)
5322 {
5323 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"NewExpr");
5324 }
5325 else
5326 {
5327 System.Lex.WriteFailureToLog(lexer, u"NewExpr");
5328 }
5329 }
5330 #endif
5331 if (!match.hit)
5332 {
5333 match.value = null;
5334 }
5335 return match;
5336 }
5337 public static Match ArgumentList(ParserFileLexer& lexer, ParsingContext* ctx, Node* node)
5338 {
5339 #if (DEBUG)
5340 Span debugSpan;
5341 bool writeToLog = lexer.Log() != null;
5342 if (writeToLog)
5343 {
5344 debugSpan = lexer.GetSpan();
5345 System.Lex.WriteBeginRuleToLog(lexer, u"ArgumentList");
5346 }
5347 #endif
5348 Match match(false);
5349 Match* parentMatch0 = &match;
5350 {
5351 Match match(true);
5352 long save = lexer.GetPos();
5353 Match* parentMatch1 = &match;
5354 {
5355 Match match = ExpressionParser.ExpressionList(lexer, ctx, node);
5356 if (match.hit)
5357 {
5358 *parentMatch1 = match;
5359 }
5360 else
5361 {
5362 lexer.SetPos(save);
5363 }
5364 }
5365 *parentMatch0 = match;
5366 }
5367 #if (DEBUG)
5368 if (writeToLog)
5369 {
5370 if (match.hit)
5371 {
5372 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"ArgumentList");
5373 }
5374 else
5375 {
5376 System.Lex.WriteFailureToLog(lexer, u"ArgumentList");
5377 }
5378 }
5379 #endif
5380 if (!match.hit)
5381 {
5382 match.value = null;
5383 }
5384 return match;
5385 }
5386 public static Match ExpressionList(ParserFileLexer& lexer, ParsingContext* ctx, Node* node)
5387 {
5388 #if (DEBUG)
5389 Span debugSpan;
5390 bool writeToLog = lexer.Log() != null;
5391 if (writeToLog)
5392 {
5393 debugSpan = lexer.GetSpan();
5394 System.Lex.WriteBeginRuleToLog(lexer, u"ExpressionList");
5395 }
5396 #endif
5397 UniquePtr<Node> arg;
5398 Match match(false);
5399 Match* parentMatch0 = &match;
5400 {
5401 Match match(false);
5402 Match* parentMatch1 = &match;
5403 {
5404 long pos = lexer.GetPos();
5405 Match match(true);
5406 if (match.hit)
5407 {
5408 ctx->BeginParsingArguments();
5409 }
5410 *parentMatch1 = match;
5411 }
5412 *parentMatch0 = match;
5413 }
5414 if (match.hit)
5415 {
5416 Match match(false);
5417 Match* parentMatch2 = &match;
5418 {
5419 Match match(false);
5420 Match* parentMatch3 = &match;
5421 {
5422 long pos = lexer.GetPos();
5423 Match match(false);
5424 Match* parentMatch4 = &match;
5425 {
5426 Match match(false);
5427 Match* parentMatch5 = &match;
5428 {
5429 Match match(false);
5430 Match* parentMatch6 = &match;
5431 {
5432 Match match(false);
5433 Match* parentMatch7 = &match;
5434 {
5435 long pos = lexer.GetPos();
5436 Match match = ExpressionParser.Expression(lexer, ctx);
5437 arg.Reset(cast<Node*>(match.value));
5438 if (match.hit)
5439 {
5440 node->AddArgument(arg.Release());
5441 }
5442 *parentMatch7 = match;
5443 }
5444 *parentMatch6 = match;
5445 }
5446 *parentMatch5 = match;
5447 }
5448 if (match.hit)
5449 {
5450 Match match(false);
5451 Match* parentMatch8 = &match;
5452 {
5453 Match match(true);
5454 Match* parentMatch9 = &match;
5455 {
5456 while (true)
5457 {
5458 long save = lexer.GetPos();
5459 {
5460 Match match(false);
5461 Match* parentMatch10 = &match;
5462 {
5463 Match match(false);
5464 if (*lexer == COMMA)
5465 {
5466 ++lexer;
5467 match.hit = true;
5468 }
5469 *parentMatch10 = match;
5470 }
5471 if (match.hit)
5472 {
5473 Match match(false);
5474 Match* parentMatch11 = &match;
5475 {
5476 Match match(false);
5477 Match* parentMatch12 = &match;
5478 {
5479 Match match(false);
5480 Match* parentMatch13 = &match;
5481 {
5482 long pos = lexer.GetPos();
5483 Match match = ExpressionParser.Expression(lexer, ctx);
5484 arg.Reset(cast<Node*>(match.value));
5485 if (match.hit)
5486 {
5487 node->AddArgument(arg.Release());
5488 }
5489 *parentMatch13 = match;
5490 }
5491 *parentMatch12 = match;
5492 }
5493 *parentMatch11 = match;
5494 }
5495 *parentMatch10 = match;
5496 }
5497 if (match.hit)
5498 {
5499 *parentMatch9 = match;
5500 }
5501 else
5502 {
5503 lexer.SetPos(save);
5504 break;
5505 }
5506 }
5507 }
5508 }
5509 *parentMatch8 = match;
5510 }
5511 *parentMatch5 = match;
5512 }
5513 *parentMatch4 = match;
5514 }
5515 if (match.hit)
5516 {
5517 ctx->EndParsingArguments();
5518 }
5519 else
5520 {
5521 ctx->EndParsingArguments();
5522 }
5523 *parentMatch3 = match;
5524 }
5525 *parentMatch2 = match;
5526 }
5527 *parentMatch0 = match;
5528 }
5529 #if (DEBUG)
5530 if (writeToLog)
5531 {
5532 if (match.hit)
5533 {
5534 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"ExpressionList");
5535 }
5536 else
5537 {
5538 System.Lex.WriteFailureToLog(lexer, u"ExpressionList");
5539 }
5540 }
5541 #endif
5542 if (!match.hit)
5543 {
5544 match.value = null;
5545 }
5546 return match;
5547 }
5548 public static Match InvokeExpr(ParserFileLexer& lexer, ParsingContext* ctx)
5549 {
5550 #if (DEBUG)
5551 Span debugSpan;
5552 bool writeToLog = lexer.Log() != null;
5553 if (writeToLog)
5554 {
5555 debugSpan = lexer.GetSpan();
5556 System.Lex.WriteBeginRuleToLog(lexer, u"InvokeExpr");
5557 }
5558 #endif
5559 UniquePtr<Node> expr;
5560 Span s;
5561 UniquePtr<Node> templateId;
5562 UniquePtr<IdentifierNode> id;
5563 UniquePtr<IdentifierNode> dotMemberId;
5564 Match match(false);
5565 Match* parentMatch0 = &match;
5566 {
5567 long pos = lexer.GetPos();
5568 Match match(false);
5569 Match* parentMatch1 = &match;
5570 {
5571 Match match(false);
5572 Match* parentMatch2 = &match;
5573 {
5574 Match match(false);
5575 Match* parentMatch3 = &match;
5576 {
5577 Match match(false);
5578 Match* parentMatch4 = &match;
5579 {
5580 Match match(false);
5581 Match* parentMatch5 = &match;
5582 {
5583 Match match(false);
5584 Match* parentMatch6 = &match;
5585 {
5586 Match match(false);
5587 Match* parentMatch7 = &match;
5588 {
5589 long save = lexer.GetPos();
5590 Match match(false);
5591 Match* parentMatch8 = &match;
5592 {
5593 long pos = lexer.GetPos();
5594 Span span = lexer.GetSpan();
5595 Match match = TemplateParser.TemplateId(lexer, ctx);
5596 templateId.Reset(cast<Node*>(match.value));
5597 if (match.hit)
5598 {
5599 s = span;
5600 expr.Reset(templateId.Release());
5601 }
5602 *parentMatch8 = match;
5603 }
5604 *parentMatch7 = match;
5605 if (!match.hit)
5606 {
5607 Match match(false);
5608 Match* parentMatch9 = &match;
5609 lexer.SetPos(save);
5610 {
5611 Match match(false);
5612 Match* parentMatch10 = &match;
5613 {
5614 long pos = lexer.GetPos();
5615 Span span = lexer.GetSpan();
5616 Match match = IdentifierParser.Identifier(lexer, ctx);
5617 id.Reset(cast<IdentifierNode*>(match.value));
5618 if (match.hit)
5619 {
5620 s = span;
5621 expr.Reset(id.Release());
5622 }
5623 *parentMatch10 = match;
5624 }
5625 *parentMatch9 = match;
5626 }
5627 *parentMatch7 = match;
5628 }
5629 }
5630 *parentMatch6 = match;
5631 }
5632 *parentMatch5 = match;
5633 }
5634 if (match.hit)
5635 {
5636 Match match(false);
5637 Match* parentMatch11 = &match;
5638 {
5639 Match match(true);
5640 Match* parentMatch12 = &match;
5641 {
5642 while (true)
5643 {
5644 long save = lexer.GetPos();
5645 {
5646 Match match(false);
5647 Match* parentMatch13 = &match;
5648 {
5649 Match match(false);
5650 Match* parentMatch14 = &match;
5651 {
5652 Match match(false);
5653 if (*lexer == DOT)
5654 {
5655 ++lexer;
5656 match.hit = true;
5657 }
5658 *parentMatch14 = match;
5659 }
5660 if (match.hit)
5661 {
5662 Match match(false);
5663 Match* parentMatch15 = &match;
5664 {
5665 Match match(false);
5666 Match* parentMatch16 = &match;
5667 {
5668 long pos = lexer.GetPos();
5669 Span span = lexer.GetSpan();
5670 Match match(true);
5671 Match* parentMatch17 = &match;
5672 {
5673 System.Lex.Span span = lexer.GetSpan();
5674 Match match = IdentifierParser.Identifier(lexer, ctx);
5675 dotMemberId.Reset(cast<IdentifierNode*>(match.value));
5676 if (match.hit)
5677 {
5678 *parentMatch17 = match;
5679 }
5680 else
5681 {
5682 lexer.ThrowExpectationFailure(span, u"identifier");
5683 }
5684 }
5685 if (match.hit)
5686 {
5687 s.end = span.end;
5688 expr.Reset(new DotNode(s, ctx->ModuleId(), expr.Release(), dotMemberId.Release()));
5689 }
5690 *parentMatch16 = match;
5691 }
5692 *parentMatch15 = match;
5693 }
5694 *parentMatch14 = match;
5695 }
5696 *parentMatch13 = match;
5697 }
5698 if (match.hit)
5699 {
5700 *parentMatch12 = match;
5701 }
5702 else
5703 {
5704 lexer.SetPos(save);
5705 break;
5706 }
5707 }
5708 }
5709 }
5710 *parentMatch11 = match;
5711 }
5712 *parentMatch5 = match;
5713 }
5714 *parentMatch4 = match;
5715 }
5716 if (match.hit)
5717 {
5718 Match match(false);
5719 Match* parentMatch18 = &match;
5720 {
5721 Match match(false);
5722 Match* parentMatch19 = &match;
5723 {
5724 long pos = lexer.GetPos();
5725 Match match(false);
5726 if (*lexer == LPAREN)
5727 {
5728 ++lexer;
5729 match.hit = true;
5730 }
5731 if (match.hit)
5732 {
5733 expr.Reset(new InvokeNode(s, ctx->ModuleId(), expr.Release()));
5734 }
5735 *parentMatch19 = match;
5736 }
5737 *parentMatch18 = match;
5738 }
5739 *parentMatch4 = match;
5740 }
5741 *parentMatch3 = match;
5742 }
5743 if (match.hit)
5744 {
5745 Match match(false);
5746 Match* parentMatch20 = &match;
5747 {
5748 Match match = ExpressionParser.ArgumentList(lexer, ctx, expr.Get());
5749 *parentMatch20 = match;
5750 }
5751 *parentMatch3 = match;
5752 }
5753 *parentMatch2 = match;
5754 }
5755 if (match.hit)
5756 {
5757 Match match(false);
5758 Match* parentMatch21 = &match;
5759 {
5760 Match match(false);
5761 Match* parentMatch22 = &match;
5762 {
5763 long pos = lexer.GetPos();
5764 Span span = lexer.GetSpan();
5765 Match match(true);
5766 Match* parentMatch23 = &match;
5767 {
5768 System.Lex.Span span = lexer.GetSpan();
5769 Match match(false);
5770 if (*lexer == RPAREN)
5771 {
5772 ++lexer;
5773 match.hit = true;
5774 }
5775 if (match.hit)
5776 {
5777 *parentMatch23 = match;
5778 }
5779 else
5780 {
5781 lexer.ThrowExpectationFailure(span, GetTokenName(RPAREN));
5782 }
5783 }
5784 if (match.hit)
5785 {
5786 expr->SetSpanEnd(span.end);
5787 }
5788 *parentMatch22 = match;
5789 }
5790 *parentMatch21 = match;
5791 }
5792 *parentMatch2 = match;
5793 }
5794 *parentMatch1 = match;
5795 }
5796 if (match.hit)
5797 {
5798 {
5799 #if (DEBUG)
5800 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"InvokeExpr");
5801 #endif
5802 return Match(true, expr.Release());
5803 }
5804 }
5805 *parentMatch0 = match;
5806 }
5807 #if (DEBUG)
5808 if (writeToLog)
5809 {
5810 if (match.hit)
5811 {
5812 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"InvokeExpr");
5813 }
5814 else
5815 {
5816 System.Lex.WriteFailureToLog(lexer, u"InvokeExpr");
5817 }
5818 }
5819 #endif
5820 if (!match.hit)
5821 {
5822 match.value = null;
5823 }
5824 return match;
5825 }
5826 }