1 using
2 using System.Collections;
3 using System.Lex;
4 using System.Parsing;
5
6
7
8 unnamed_ns_970E5F2188D31CA43883EC40B8FFEAB897AC0F09;using System;using System.Collections;using System.Lex;using System.Parsing;
9 {
10 public const int[4] s70 =
;
11 public const int[5] s69 =
;
12 public const int[2] s65 =
;
13 public const int[2] s64 =
;
14 public const int[2] s63 =
;
15 public const int[3] s62 =
;
16 public const int[4] s61 =
;
17 public const int[3] s60 =
;
18 public const int[2] s59 =
;
19 public const int[3] s54 =
;
20 public const int[3] s53 =
;
21 public const int[9] s52 =
;
22 public const int[3] s50 =
;
23 public const int[2] s47 =
;
24 public const int[2] s46 =
;
25 public const int[6] s45 =
;
26 public const int[10] s44 =
;
27 public const int[5] s43 =
;
28 public const int[8] s40 =
;
29 public const int[8] s39 =
;
30 public const int[6] s38 =
;
31 public const int[8] s37 =
;
32 public const int[9] s36 =
;
33 public const int[8] s35 =
;
34 public const int[8] s34 =
;
35 public const int[7] s33 =
;
36 public const int[8] s32 =
;
37 public const int[6] s31 =
;
38 public const int[6] s30 =
;
39 public const int[5] s29 =
;
40 public const int[2] s28 =
;
41 public const int[5] s27 =
;
42 public const int[9] s26 =
;
43 public const int[7] s25 =
;
44 public const int[2] s24 =
;
45 public const int[7] s23 =
;
46 public const int[3] s22 =
;
47 public const int[5] s21 =
;
48 public const int[9] s20 =
;
49 public const int[6] s14 =
;
50 public const int[6] s13 =
;
51 public const int[9] s12 =
;
52 public const int[10] s11 =
;
53 public const int[8] s8 =
;
54 public const int[7] s6 =
;
55 public const int[2] s5 =
;
56 public const int[5] s4 =
;
57 public const Range[6] s0 =
;
58 public const Range[4] s1 =
;
59 public const Range[16] s2 =
;
60 public const Range[6] s3 =
;
61 public const Range[1] s7 =
;
62 public const Range[2] s9 =
;
63 public const Range[6] s10 =
;
64 public const Range[1] s15 =
;
65 public const Range[1] s16 =
;
66 public const Range[3] s17 =
;
67 public const Range[3] s18 =
;
68 public const Range[19] s19 =
;
69 public const Range[3] s41 =
;
70 public const Range[3] s42 =
;
71 public const Range[2] s48 =
;
72 public const Range[2] s49 =
;
73 public const Range[2] s51 =
;
74 public const Range[3] s55 =
;
75 public const Range[3] s56 =
;
76 public const Range[1] s57 =
;
77 public const Range[3] s58 =
;
78 public const Range[2] s66 =
;
79 public const Range[2] s67 =
;
80 public const Range[2] s68 =
;
81 }
82
83 public static class XmlParser
84 {
85 public static void Parse(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
86 {
87 #if (DEBUG)
88 if (lexer.Log() != null)
89 {
90 lexer.Log()->WriteBeginRule(u"parse");
91 lexer.Log()->IncIndent();
92 }
93 #endif
94 ++lexer;
95 System.Lex.Span span = lexer.GetSpan();
96 Match match = Document(lexer, processor);
97 if (match.hit)
98 {
99 if (*lexer == System.Lex.END_TOKEN)
100 {
101 return;
102 }
103 else
104 {
105 lexer.ThrowFarthestError();
106 }
107 }
108 else
109 {
110 lexer.ThrowFarthestError();
111 }
112 return;
113 }
114 public static Match Document(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
115 {
116 #if (DEBUG)
117 Span debugSpan;
118 bool writeToLog = lexer.Log() != null;
119 if (writeToLog)
120 {
121 debugSpan = lexer.GetSpan();
122 System.Lex.WriteBeginRuleToLog(lexer, u"Document");
123 }
124 #endif
125 System.Lex.RuleGuard ruleGuard(lexer, 0);
126 Match match(false);
127 Match* parentMatch0 = &match;
128 {
129 Match match(false);
130 Match* parentMatch1 = &match;
131 {
132 long pos = lexer.GetPos();
133 Match match(true);
134 if (match.hit)
135 {
136 processor->StartDocument();
137 }
138 *parentMatch1 = match;
139 }
140 *parentMatch0 = match;
141 }
142 if (match.hit)
143 {
144 Match match(false);
145 Match* parentMatch2 = &match;
146 {
147 Match match(false);
148 Match* parentMatch3 = &match;
149 {
150 long pos = lexer.GetPos();
151 Match match(false);
152 Match* parentMatch4 = &match;
153 {
154 Match match(false);
155 Match* parentMatch5 = &match;
156 {
157 Match match(false);
158 Match* parentMatch6 = &match;
159 {
160 Match match = XmlParser.Prolog(lexer, processor);
161 *parentMatch6 = match;
162 }
163 if (match.hit)
164 {
165 Match match(false);
166 Match* parentMatch7 = &match;
167 {
168 Match match = XmlParser.Element(lexer, processor);
169 *parentMatch7 = match;
170 }
171 *parentMatch6 = match;
172 }
173 *parentMatch5 = match;
174 }
175 if (match.hit)
176 {
177 Match match(false);
178 Match* parentMatch8 = &match;
179 {
180 Match match(true);
181 Match* parentMatch9 = &match;
182 {
183 while (true)
184 {
185 long save = lexer.GetPos();
186 {
187 Match match(false);
188 Match* parentMatch10 = &match;
189 {
190 Match match = XmlParser.Misc(lexer, processor);
191 *parentMatch10 = match;
192 }
193 if (match.hit)
194 {
195 *parentMatch9 = match;
196 }
197 else
198 {
199 lexer.SetPos(save);
200 break;
201 }
202 }
203 }
204 }
205 *parentMatch8 = match;
206 }
207 *parentMatch5 = match;
208 }
209 *parentMatch4 = match;
210 }
211 if (match.hit)
212 {
213 processor->EndDocument();
214 }
215 *parentMatch3 = match;
216 }
217 *parentMatch2 = match;
218 }
219 *parentMatch0 = match;
220 }
221 #if (DEBUG)
222 if (writeToLog)
223 {
224 if (match.hit)
225 {
226 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Document");
227 }
228 else
229 {
230 System.Lex.WriteFailureToLog(lexer, u"Document");
231 }
232 }
233 #endif
234 if (!match.hit)
235 {
236 match.value = null;
237 }
238 return match;
239 }
240 public static Match Char(TrivialLexer& lexer)
241 {
242 #if (DEBUG)
243 Span debugSpan;
244 bool writeToLog = lexer.Log() != null;
245 if (writeToLog)
246 {
247 debugSpan = lexer.GetSpan();
248 System.Lex.WriteBeginRuleToLog(lexer, u"Char");
249 }
250 #endif
251 System.Lex.RuleGuard ruleGuard(lexer, 1);
252 Match match(false);
253 Match* parentMatch0 = &match;
254 {
255 long pos = lexer.GetPos();
256 Match match(false);
257 Match* parentMatch1 = &match;
258 {
259 Match match(false);
260 for (const Range& range : s0)
261 {
262 if (*lexer >= range.first && *lexer <= range.last)
263 {
264 match.hit = true;
265 ++lexer;
266 break;
267 }
268 }
269 *parentMatch1 = match;
270 }
271 if (match.hit)
272 {
273 Token token = lexer.GetToken(pos);
274 {
275 #if (DEBUG)
276 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Char");
277 #endif
278 return Match(true, new Value<uchar>(cast<uchar>(token.id)));
279 }
280 }
281 *parentMatch0 = match;
282 }
283 #if (DEBUG)
284 if (writeToLog)
285 {
286 if (match.hit)
287 {
288 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Char");
289 }
290 else
291 {
292 System.Lex.WriteFailureToLog(lexer, u"Char");
293 }
294 }
295 #endif
296 if (!match.hit)
297 {
298 match.value = null;
299 }
300 return match;
301 }
302 public static Match S(TrivialLexer& lexer)
303 {
304 #if (DEBUG)
305 Span debugSpan;
306 bool writeToLog = lexer.Log() != null;
307 if (writeToLog)
308 {
309 debugSpan = lexer.GetSpan();
310 System.Lex.WriteBeginRuleToLog(lexer, u"S");
311 }
312 #endif
313 System.Lex.RuleGuard ruleGuard(lexer, 2);
314 Match match(false);
315 Match* parentMatch0 = &match;
316 {
317 Match match(false);
318 for (const Range& range : s1)
319 {
320 if (*lexer >= range.first && *lexer <= range.last)
321 {
322 match.hit = true;
323 ++lexer;
324 break;
325 }
326 }
327 *parentMatch0 = match;
328 }
329 if (match.hit)
330 {
331 Match match(true);
332 Match* parentMatch1 = &match;
333 while (true)
334 {
335 long save = lexer.GetPos();
336 {
337 Match match(false);
338 for (const Range& range : s1)
339 {
340 if (*lexer >= range.first && *lexer <= range.last)
341 {
342 match.hit = true;
343 ++lexer;
344 break;
345 }
346 }
347 if (match.hit)
348 {
349 *parentMatch1 = match;
350 }
351 else
352 {
353 lexer.SetPos(save);
354 break;
355 }
356 }
357 }
358 }
359 #if (DEBUG)
360 if (writeToLog)
361 {
362 if (match.hit)
363 {
364 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"S");
365 }
366 else
367 {
368 System.Lex.WriteFailureToLog(lexer, u"S");
369 }
370 }
371 #endif
372 if (!match.hit)
373 {
374 match.value = null;
375 }
376 return match;
377 }
378 public static Match NameStartChar(TrivialLexer& lexer)
379 {
380 #if (DEBUG)
381 Span debugSpan;
382 bool writeToLog = lexer.Log() != null;
383 if (writeToLog)
384 {
385 debugSpan = lexer.GetSpan();
386 System.Lex.WriteBeginRuleToLog(lexer, u"NameStartChar");
387 }
388 #endif
389 System.Lex.RuleGuard ruleGuard(lexer, 3);
390 Match match(false);
391 for (const Range& range : s2)
392 {
393 if (*lexer >= range.first && *lexer <= range.last)
394 {
395 match.hit = true;
396 ++lexer;
397 break;
398 }
399 }
400 #if (DEBUG)
401 if (writeToLog)
402 {
403 if (match.hit)
404 {
405 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"NameStartChar");
406 }
407 else
408 {
409 System.Lex.WriteFailureToLog(lexer, u"NameStartChar");
410 }
411 }
412 #endif
413 if (!match.hit)
414 {
415 match.value = null;
416 }
417 return match;
418 }
419 public static Match NameChar(TrivialLexer& lexer)
420 {
421 #if (DEBUG)
422 Span debugSpan;
423 bool writeToLog = lexer.Log() != null;
424 if (writeToLog)
425 {
426 debugSpan = lexer.GetSpan();
427 System.Lex.WriteBeginRuleToLog(lexer, u"NameChar");
428 }
429 #endif
430 System.Lex.RuleGuard ruleGuard(lexer, 4);
431 Match match(false);
432 Match* parentMatch0 = &match;
433 {
434 long save = lexer.GetPos();
435 Match match = XmlParser.NameStartChar(lexer);
436 *parentMatch0 = match;
437 if (!match.hit)
438 {
439 Match match(false);
440 Match* parentMatch1 = &match;
441 lexer.SetPos(save);
442 {
443 Match match(false);
444 for (const Range& range : s3)
445 {
446 if (*lexer >= range.first && *lexer <= range.last)
447 {
448 match.hit = true;
449 ++lexer;
450 break;
451 }
452 }
453 *parentMatch1 = match;
454 }
455 *parentMatch0 = match;
456 }
457 }
458 #if (DEBUG)
459 if (writeToLog)
460 {
461 if (match.hit)
462 {
463 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"NameChar");
464 }
465 else
466 {
467 System.Lex.WriteFailureToLog(lexer, u"NameChar");
468 }
469 }
470 #endif
471 if (!match.hit)
472 {
473 match.value = null;
474 }
475 return match;
476 }
477 public static Match Name(TrivialLexer& lexer)
478 {
479 #if (DEBUG)
480 Span debugSpan;
481 bool writeToLog = lexer.Log() != null;
482 if (writeToLog)
483 {
484 debugSpan = lexer.GetSpan();
485 System.Lex.WriteBeginRuleToLog(lexer, u"Name");
486 }
487 #endif
488 System.Lex.RuleGuard ruleGuard(lexer, 5);
489 Span s;
490 Match match(false);
491 Match* parentMatch0 = &match;
492 {
493 long pos = lexer.GetPos();
494 Match match(false);
495 Match* parentMatch1 = &match;
496 {
497 Match match(false);
498 Match* parentMatch2 = &match;
499 {
500 Match match(false);
501 Match* parentMatch3 = &match;
502 {
503 long pos = lexer.GetPos();
504 Span span = lexer.GetSpan();
505 Match match = XmlParser.NameStartChar(lexer);
506 if (match.hit)
507 {
508 s = span;
509 }
510 *parentMatch3 = match;
511 }
512 *parentMatch2 = match;
513 }
514 if (match.hit)
515 {
516 Match match(false);
517 Match* parentMatch4 = &match;
518 {
519 Match match(true);
520 Match* parentMatch5 = &match;
521 {
522 while (true)
523 {
524 long save = lexer.GetPos();
525 {
526 Match match(false);
527 Match* parentMatch6 = &match;
528 {
529 Match match(false);
530 Match* parentMatch7 = &match;
531 {
532 long pos = lexer.GetPos();
533 Span span = lexer.GetSpan();
534 Match match = XmlParser.NameChar(lexer);
535 if (match.hit)
536 {
537 s.end = span.end;
538 }
539 *parentMatch7 = match;
540 }
541 *parentMatch6 = match;
542 }
543 if (match.hit)
544 {
545 *parentMatch5 = match;
546 }
547 else
548 {
549 lexer.SetPos(save);
550 break;
551 }
552 }
553 }
554 }
555 *parentMatch4 = match;
556 }
557 *parentMatch2 = match;
558 }
559 *parentMatch1 = match;
560 }
561 if (match.hit)
562 {
563 {
564 #if (DEBUG)
565 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Name");
566 #endif
567 return Match(true, new Value<ustring>(lexer.GetMatch(s)));
568 }
569 }
570 *parentMatch0 = match;
571 }
572 #if (DEBUG)
573 if (writeToLog)
574 {
575 if (match.hit)
576 {
577 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Name");
578 }
579 else
580 {
581 System.Lex.WriteFailureToLog(lexer, u"Name");
582 }
583 }
584 #endif
585 if (!match.hit)
586 {
587 match.value = null;
588 }
589 return match;
590 }
591 public static Match Names(TrivialLexer& lexer)
592 {
593 #if (DEBUG)
594 Span debugSpan;
595 bool writeToLog = lexer.Log() != null;
596 if (writeToLog)
597 {
598 debugSpan = lexer.GetSpan();
599 System.Lex.WriteBeginRuleToLog(lexer, u"Names");
600 }
601 #endif
602 System.Lex.RuleGuard ruleGuard(lexer, 6);
603 UniquePtr<Value<ustring>> name1;
604 UniquePtr<Value<ustring>> name2;
605 Match match(false);
606 Match* parentMatch0 = &match;
607 {
608 Match match = XmlParser.Name(lexer);
609 name1.Reset(cast<Value<ustring>*>(match.value));
610 *parentMatch0 = match;
611 }
612 if (match.hit)
613 {
614 Match match(false);
615 Match* parentMatch1 = &match;
616 {
617 Match match(true);
618 Match* parentMatch2 = &match;
619 {
620 while (true)
621 {
622 long save = lexer.GetPos();
623 {
624 Match match(false);
625 Match* parentMatch3 = &match;
626 {
627 Match match(false);
628 Match* parentMatch4 = &match;
629 {
630 Match match(false);
631 if (*lexer == 32)
632 {
633 ++lexer;
634 match.hit = true;
635 }
636 *parentMatch4 = match;
637 }
638 if (match.hit)
639 {
640 Match match(false);
641 Match* parentMatch5 = &match;
642 {
643 Match match = XmlParser.Name(lexer);
644 name2.Reset(cast<Value<ustring>*>(match.value));
645 *parentMatch5 = match;
646 }
647 *parentMatch4 = match;
648 }
649 *parentMatch3 = match;
650 }
651 if (match.hit)
652 {
653 *parentMatch2 = match;
654 }
655 else
656 {
657 lexer.SetPos(save);
658 break;
659 }
660 }
661 }
662 }
663 *parentMatch1 = match;
664 }
665 *parentMatch0 = match;
666 }
667 #if (DEBUG)
668 if (writeToLog)
669 {
670 if (match.hit)
671 {
672 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Names");
673 }
674 else
675 {
676 System.Lex.WriteFailureToLog(lexer, u"Names");
677 }
678 }
679 #endif
680 if (!match.hit)
681 {
682 match.value = null;
683 }
684 return match;
685 }
686 public static Match Nmtoken(TrivialLexer& lexer)
687 {
688 #if (DEBUG)
689 Span debugSpan;
690 bool writeToLog = lexer.Log() != null;
691 if (writeToLog)
692 {
693 debugSpan = lexer.GetSpan();
694 System.Lex.WriteBeginRuleToLog(lexer, u"Nmtoken");
695 }
696 #endif
697 System.Lex.RuleGuard ruleGuard(lexer, 7);
698 Match match(false);
699 Match* parentMatch0 = &match;
700 {
701 Match match = XmlParser.NameChar(lexer);
702 *parentMatch0 = match;
703 }
704 if (match.hit)
705 {
706 Match match(true);
707 Match* parentMatch1 = &match;
708 while (true)
709 {
710 long save = lexer.GetPos();
711 {
712 Match match = XmlParser.NameChar(lexer);
713 if (match.hit)
714 {
715 *parentMatch1 = match;
716 }
717 else
718 {
719 lexer.SetPos(save);
720 break;
721 }
722 }
723 }
724 }
725 #if (DEBUG)
726 if (writeToLog)
727 {
728 if (match.hit)
729 {
730 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Nmtoken");
731 }
732 else
733 {
734 System.Lex.WriteFailureToLog(lexer, u"Nmtoken");
735 }
736 }
737 #endif
738 if (!match.hit)
739 {
740 match.value = null;
741 }
742 return match;
743 }
744 public static Match Nmtokens(TrivialLexer& lexer)
745 {
746 #if (DEBUG)
747 Span debugSpan;
748 bool writeToLog = lexer.Log() != null;
749 if (writeToLog)
750 {
751 debugSpan = lexer.GetSpan();
752 System.Lex.WriteBeginRuleToLog(lexer, u"Nmtokens");
753 }
754 #endif
755 System.Lex.RuleGuard ruleGuard(lexer, 8);
756 Match match(false);
757 Match* parentMatch0 = &match;
758 {
759 Match match = XmlParser.Nmtoken(lexer);
760 *parentMatch0 = match;
761 }
762 if (match.hit)
763 {
764 Match match(false);
765 Match* parentMatch1 = &match;
766 {
767 Match match(true);
768 Match* parentMatch2 = &match;
769 {
770 while (true)
771 {
772 long save = lexer.GetPos();
773 {
774 Match match(false);
775 Match* parentMatch3 = &match;
776 {
777 Match match(false);
778 Match* parentMatch4 = &match;
779 {
780 Match match(false);
781 if (*lexer == 32)
782 {
783 ++lexer;
784 match.hit = true;
785 }
786 *parentMatch4 = match;
787 }
788 if (match.hit)
789 {
790 Match match(false);
791 Match* parentMatch5 = &match;
792 {
793 Match match = XmlParser.Nmtoken(lexer);
794 *parentMatch5 = match;
795 }
796 *parentMatch4 = match;
797 }
798 *parentMatch3 = match;
799 }
800 if (match.hit)
801 {
802 *parentMatch2 = match;
803 }
804 else
805 {
806 lexer.SetPos(save);
807 break;
808 }
809 }
810 }
811 }
812 *parentMatch1 = match;
813 }
814 *parentMatch0 = match;
815 }
816 #if (DEBUG)
817 if (writeToLog)
818 {
819 if (match.hit)
820 {
821 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Nmtokens");
822 }
823 else
824 {
825 System.Lex.WriteFailureToLog(lexer, u"Nmtokens");
826 }
827 }
828 #endif
829 if (!match.hit)
830 {
831 match.value = null;
832 }
833 return match;
834 }
835 public static Match Prolog(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
836 {
837 #if (DEBUG)
838 Span debugSpan;
839 bool writeToLog = lexer.Log() != null;
840 if (writeToLog)
841 {
842 debugSpan = lexer.GetSpan();
843 System.Lex.WriteBeginRuleToLog(lexer, u"Prolog");
844 }
845 #endif
846 System.Lex.RuleGuard ruleGuard(lexer, 9);
847 Match match(false);
848 Match* parentMatch0 = &match;
849 {
850 Match match(false);
851 Match* parentMatch1 = &match;
852 {
853 Match match(true);
854 long save = lexer.GetPos();
855 Match* parentMatch2 = &match;
856 {
857 Match match = XmlParser.XMLDecl(lexer, processor);
858 if (match.hit)
859 {
860 *parentMatch2 = match;
861 }
862 else
863 {
864 lexer.SetPos(save);
865 }
866 }
867 *parentMatch1 = match;
868 }
869 if (match.hit)
870 {
871 Match match(false);
872 Match* parentMatch3 = &match;
873 {
874 Match match(true);
875 Match* parentMatch4 = &match;
876 {
877 while (true)
878 {
879 long save = lexer.GetPos();
880 {
881 Match match = XmlParser.Misc(lexer, processor);
882 if (match.hit)
883 {
884 *parentMatch4 = match;
885 }
886 else
887 {
888 lexer.SetPos(save);
889 break;
890 }
891 }
892 }
893 }
894 *parentMatch3 = match;
895 }
896 *parentMatch1 = match;
897 }
898 *parentMatch0 = match;
899 }
900 if (match.hit)
901 {
902 Match match(false);
903 Match* parentMatch5 = &match;
904 {
905 Match match(true);
906 long save = lexer.GetPos();
907 Match* parentMatch6 = &match;
908 {
909 Match match(false);
910 Match* parentMatch7 = &match;
911 {
912 Match match(false);
913 Match* parentMatch8 = &match;
914 {
915 Match match = XmlParser.DocTypeDecl(lexer, processor);
916 *parentMatch8 = match;
917 }
918 if (match.hit)
919 {
920 Match match(false);
921 Match* parentMatch9 = &match;
922 {
923 Match match(true);
924 Match* parentMatch10 = &match;
925 {
926 while (true)
927 {
928 long save = lexer.GetPos();
929 {
930 Match match = XmlParser.Misc(lexer, processor);
931 if (match.hit)
932 {
933 *parentMatch10 = match;
934 }
935 else
936 {
937 lexer.SetPos(save);
938 break;
939 }
940 }
941 }
942 }
943 *parentMatch9 = match;
944 }
945 *parentMatch8 = match;
946 }
947 *parentMatch7 = match;
948 }
949 if (match.hit)
950 {
951 *parentMatch6 = match;
952 }
953 else
954 {
955 lexer.SetPos(save);
956 }
957 }
958 *parentMatch5 = match;
959 }
960 *parentMatch0 = match;
961 }
962 #if (DEBUG)
963 if (writeToLog)
964 {
965 if (match.hit)
966 {
967 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Prolog");
968 }
969 else
970 {
971 System.Lex.WriteFailureToLog(lexer, u"Prolog");
972 }
973 }
974 #endif
975 if (!match.hit)
976 {
977 match.value = null;
978 }
979 return match;
980 }
981 public static Match XMLDecl(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
982 {
983 #if (DEBUG)
984 Span debugSpan;
985 bool writeToLog = lexer.Log() != null;
986 if (writeToLog)
987 {
988 debugSpan = lexer.GetSpan();
989 System.Lex.WriteBeginRuleToLog(lexer, u"XMLDecl");
990 }
991 #endif
992 System.Lex.RuleGuard ruleGuard(lexer, 10);
993 Match match(false);
994 Match* parentMatch0 = &match;
995 {
996 Match match(false);
997 Match* parentMatch1 = &match;
998 {
999 Match match(false);
1000 Match* parentMatch2 = &match;
1001 {
1002 Match match(false);
1003 Match* parentMatch3 = &match;
1004 {
1005 Match match(false);
1006 Match* parentMatch4 = &match;
1007 {
1008 Match match(true);
1009 long __n = 5;
1010 for (long __k = 0; __k < __n; ++__k;)
1011 {
1012 int __i = s4[__k];
1013 if (*lexer == __i)
1014 {
1015 ++lexer;
1016 }
1017 else
1018 {
1019 match.hit = false;
1020 break;
1021 }
1022 }
1023 *parentMatch4 = match;
1024 }
1025 if (match.hit)
1026 {
1027 Match match(false);
1028 Match* parentMatch5 = &match;
1029 {
1030 Match match = XmlParser.VersionInfo(lexer, processor);
1031 *parentMatch5 = match;
1032 }
1033 *parentMatch4 = match;
1034 }
1035 *parentMatch3 = match;
1036 }
1037 if (match.hit)
1038 {
1039 Match match(false);
1040 Match* parentMatch6 = &match;
1041 {
1042 Match match(true);
1043 long save = lexer.GetPos();
1044 Match* parentMatch7 = &match;
1045 {
1046 Match match = XmlParser.EncodingDecl(lexer, processor);
1047 if (match.hit)
1048 {
1049 *parentMatch7 = match;
1050 }
1051 else
1052 {
1053 lexer.SetPos(save);
1054 }
1055 }
1056 *parentMatch6 = match;
1057 }
1058 *parentMatch3 = match;
1059 }
1060 *parentMatch2 = match;
1061 }
1062 if (match.hit)
1063 {
1064 Match match(false);
1065 Match* parentMatch8 = &match;
1066 {
1067 Match match(true);
1068 long save = lexer.GetPos();
1069 Match* parentMatch9 = &match;
1070 {
1071 Match match = XmlParser.SDDecl(lexer, processor);
1072 if (match.hit)
1073 {
1074 *parentMatch9 = match;
1075 }
1076 else
1077 {
1078 lexer.SetPos(save);
1079 }
1080 }
1081 *parentMatch8 = match;
1082 }
1083 *parentMatch2 = match;
1084 }
1085 *parentMatch1 = match;
1086 }
1087 if (match.hit)
1088 {
1089 Match match(false);
1090 Match* parentMatch10 = &match;
1091 {
1092 Match match(true);
1093 long save = lexer.GetPos();
1094 Match* parentMatch11 = &match;
1095 {
1096 Match match = XmlParser.S(lexer);
1097 if (match.hit)
1098 {
1099 *parentMatch11 = match;
1100 }
1101 else
1102 {
1103 lexer.SetPos(save);
1104 }
1105 }
1106 *parentMatch10 = match;
1107 }
1108 *parentMatch1 = match;
1109 }
1110 *parentMatch0 = match;
1111 }
1112 if (match.hit)
1113 {
1114 Match match(false);
1115 Match* parentMatch12 = &match;
1116 {
1117 Match match(true);
1118 long __n = 2;
1119 for (long __k = 0; __k < __n; ++__k;)
1120 {
1121 int __i = s5[__k];
1122 if (*lexer == __i)
1123 {
1124 ++lexer;
1125 }
1126 else
1127 {
1128 match.hit = false;
1129 break;
1130 }
1131 }
1132 *parentMatch12 = match;
1133 }
1134 *parentMatch0 = match;
1135 }
1136 #if (DEBUG)
1137 if (writeToLog)
1138 {
1139 if (match.hit)
1140 {
1141 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"XMLDecl");
1142 }
1143 else
1144 {
1145 System.Lex.WriteFailureToLog(lexer, u"XMLDecl");
1146 }
1147 }
1148 #endif
1149 if (!match.hit)
1150 {
1151 match.value = null;
1152 }
1153 return match;
1154 }
1155 public static Match VersionInfo(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
1156 {
1157 #if (DEBUG)
1158 Span debugSpan;
1159 bool writeToLog = lexer.Log() != null;
1160 if (writeToLog)
1161 {
1162 debugSpan = lexer.GetSpan();
1163 System.Lex.WriteBeginRuleToLog(lexer, u"VersionInfo");
1164 }
1165 #endif
1166 System.Lex.RuleGuard ruleGuard(lexer, 11);
1167 Match match(false);
1168 Match* parentMatch0 = &match;
1169 {
1170 Match match(false);
1171 Match* parentMatch1 = &match;
1172 {
1173 Match match(false);
1174 Match* parentMatch2 = &match;
1175 {
1176 Match match = XmlParser.S(lexer);
1177 *parentMatch2 = match;
1178 }
1179 if (match.hit)
1180 {
1181 Match match(false);
1182 Match* parentMatch3 = &match;
1183 {
1184 Match match(true);
1185 long __n = 7;
1186 for (long __k = 0; __k < __n; ++__k;)
1187 {
1188 int __i = s6[__k];
1189 if (*lexer == __i)
1190 {
1191 ++lexer;
1192 }
1193 else
1194 {
1195 match.hit = false;
1196 break;
1197 }
1198 }
1199 *parentMatch3 = match;
1200 }
1201 *parentMatch2 = match;
1202 }
1203 *parentMatch1 = match;
1204 }
1205 if (match.hit)
1206 {
1207 Match match(false);
1208 Match* parentMatch4 = &match;
1209 {
1210 Match match = XmlParser.Eq(lexer);
1211 *parentMatch4 = match;
1212 }
1213 *parentMatch1 = match;
1214 }
1215 *parentMatch0 = match;
1216 }
1217 if (match.hit)
1218 {
1219 Match match(false);
1220 Match* parentMatch5 = &match;
1221 {
1222 Match match = XmlParser.VersionNumber(lexer, processor);
1223 *parentMatch5 = match;
1224 }
1225 *parentMatch0 = match;
1226 }
1227 #if (DEBUG)
1228 if (writeToLog)
1229 {
1230 if (match.hit)
1231 {
1232 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"VersionInfo");
1233 }
1234 else
1235 {
1236 System.Lex.WriteFailureToLog(lexer, u"VersionInfo");
1237 }
1238 }
1239 #endif
1240 if (!match.hit)
1241 {
1242 match.value = null;
1243 }
1244 return match;
1245 }
1246 public static Match VersionNum(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
1247 {
1248 #if (DEBUG)
1249 Span debugSpan;
1250 bool writeToLog = lexer.Log() != null;
1251 if (writeToLog)
1252 {
1253 debugSpan = lexer.GetSpan();
1254 System.Lex.WriteBeginRuleToLog(lexer, u"VersionNum");
1255 }
1256 #endif
1257 System.Lex.RuleGuard ruleGuard(lexer, 12);
1258 Span s;
1259 Match match(false);
1260 Match* parentMatch0 = &match;
1261 {
1262 long pos = lexer.GetPos();
1263 Match match(false);
1264 Match* parentMatch1 = &match;
1265 {
1266 Match match(false);
1267 Match* parentMatch2 = &match;
1268 {
1269 Match match(false);
1270 Match* parentMatch3 = &match;
1271 {
1272 Match match(false);
1273 Match* parentMatch4 = &match;
1274 {
1275 long pos = lexer.GetPos();
1276 Span span = lexer.GetSpan();
1277 Match match(false);
1278 if (*lexer == 49)
1279 {
1280 ++lexer;
1281 match.hit = true;
1282 }
1283 if (match.hit)
1284 {
1285 s = span;
1286 }
1287 *parentMatch4 = match;
1288 }
1289 *parentMatch3 = match;
1290 }
1291 if (match.hit)
1292 {
1293 Match match(false);
1294 Match* parentMatch5 = &match;
1295 {
1296 Match match(false);
1297 if (*lexer == 46)
1298 {
1299 ++lexer;
1300 match.hit = true;
1301 }
1302 *parentMatch5 = match;
1303 }
1304 *parentMatch3 = match;
1305 }
1306 *parentMatch2 = match;
1307 }
1308 if (match.hit)
1309 {
1310 Match match(false);
1311 Match* parentMatch6 = &match;
1312 {
1313 Match match(false);
1314 Match* parentMatch7 = &match;
1315 {
1316 Match match(false);
1317 Match* parentMatch8 = &match;
1318 {
1319 Match match(false);
1320 Match* parentMatch9 = &match;
1321 {
1322 long pos = lexer.GetPos();
1323 Span span = lexer.GetSpan();
1324 Match match(false);
1325 for (const Range& range : s7)
1326 {
1327 if (*lexer >= range.first && *lexer <= range.last)
1328 {
1329 match.hit = true;
1330 ++lexer;
1331 break;
1332 }
1333 }
1334 if (match.hit)
1335 {
1336 s.end = span.end;
1337 }
1338 *parentMatch9 = match;
1339 }
1340 *parentMatch8 = match;
1341 }
1342 *parentMatch7 = match;
1343 }
1344 if (match.hit)
1345 {
1346 Match match(true);
1347 Match* parentMatch10 = &match;
1348 while (true)
1349 {
1350 long save = lexer.GetPos();
1351 {
1352 Match match(false);
1353 Match* parentMatch11 = &match;
1354 {
1355 Match match(false);
1356 Match* parentMatch12 = &match;
1357 {
1358 long pos = lexer.GetPos();
1359 Span span = lexer.GetSpan();
1360 Match match(false);
1361 for (const Range& range : s7)
1362 {
1363 if (*lexer >= range.first && *lexer <= range.last)
1364 {
1365 match.hit = true;
1366 ++lexer;
1367 break;
1368 }
1369 }
1370 if (match.hit)
1371 {
1372 s.end = span.end;
1373 }
1374 *parentMatch12 = match;
1375 }
1376 *parentMatch11 = match;
1377 }
1378 if (match.hit)
1379 {
1380 *parentMatch10 = match;
1381 }
1382 else
1383 {
1384 lexer.SetPos(save);
1385 break;
1386 }
1387 }
1388 }
1389 }
1390 *parentMatch6 = match;
1391 }
1392 *parentMatch2 = match;
1393 }
1394 *parentMatch1 = match;
1395 }
1396 if (match.hit)
1397 {
1398 processor->Version(lexer.GetMatch(s));
1399 }
1400 *parentMatch0 = match;
1401 }
1402 #if (DEBUG)
1403 if (writeToLog)
1404 {
1405 if (match.hit)
1406 {
1407 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"VersionNum");
1408 }
1409 else
1410 {
1411 System.Lex.WriteFailureToLog(lexer, u"VersionNum");
1412 }
1413 }
1414 #endif
1415 if (!match.hit)
1416 {
1417 match.value = null;
1418 }
1419 return match;
1420 }
1421 public static Match VersionNumDQ(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
1422 {
1423 #if (DEBUG)
1424 Span debugSpan;
1425 bool writeToLog = lexer.Log() != null;
1426 if (writeToLog)
1427 {
1428 debugSpan = lexer.GetSpan();
1429 System.Lex.WriteBeginRuleToLog(lexer, u"VersionNumDQ");
1430 }
1431 #endif
1432 System.Lex.RuleGuard ruleGuard(lexer, 13);
1433 Match match(false);
1434 Match* parentMatch0 = &match;
1435 {
1436 Match match(false);
1437 Match* parentMatch1 = &match;
1438 {
1439 Match match(false);
1440 if (*lexer == 34)
1441 {
1442 ++lexer;
1443 match.hit = true;
1444 }
1445 *parentMatch1 = match;
1446 }
1447 if (match.hit)
1448 {
1449 Match match(false);
1450 Match* parentMatch2 = &match;
1451 {
1452 Match match = XmlParser.VersionNum(lexer, processor);
1453 *parentMatch2 = match;
1454 }
1455 *parentMatch1 = match;
1456 }
1457 *parentMatch0 = match;
1458 }
1459 if (match.hit)
1460 {
1461 Match match(false);
1462 Match* parentMatch3 = &match;
1463 {
1464 Match match(false);
1465 if (*lexer == 34)
1466 {
1467 ++lexer;
1468 match.hit = true;
1469 }
1470 *parentMatch3 = match;
1471 }
1472 *parentMatch0 = match;
1473 }
1474 #if (DEBUG)
1475 if (writeToLog)
1476 {
1477 if (match.hit)
1478 {
1479 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"VersionNumDQ");
1480 }
1481 else
1482 {
1483 System.Lex.WriteFailureToLog(lexer, u"VersionNumDQ");
1484 }
1485 }
1486 #endif
1487 if (!match.hit)
1488 {
1489 match.value = null;
1490 }
1491 return match;
1492 }
1493 public static Match VersionNumSQ(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
1494 {
1495 #if (DEBUG)
1496 Span debugSpan;
1497 bool writeToLog = lexer.Log() != null;
1498 if (writeToLog)
1499 {
1500 debugSpan = lexer.GetSpan();
1501 System.Lex.WriteBeginRuleToLog(lexer, u"VersionNumSQ");
1502 }
1503 #endif
1504 System.Lex.RuleGuard ruleGuard(lexer, 14);
1505 Match match(false);
1506 Match* parentMatch0 = &match;
1507 {
1508 Match match(false);
1509 Match* parentMatch1 = &match;
1510 {
1511 Match match(false);
1512 if (*lexer == 39)
1513 {
1514 ++lexer;
1515 match.hit = true;
1516 }
1517 *parentMatch1 = match;
1518 }
1519 if (match.hit)
1520 {
1521 Match match(false);
1522 Match* parentMatch2 = &match;
1523 {
1524 Match match = XmlParser.VersionNum(lexer, processor);
1525 *parentMatch2 = match;
1526 }
1527 *parentMatch1 = match;
1528 }
1529 *parentMatch0 = match;
1530 }
1531 if (match.hit)
1532 {
1533 Match match(false);
1534 Match* parentMatch3 = &match;
1535 {
1536 Match match(false);
1537 if (*lexer == 39)
1538 {
1539 ++lexer;
1540 match.hit = true;
1541 }
1542 *parentMatch3 = match;
1543 }
1544 *parentMatch0 = match;
1545 }
1546 #if (DEBUG)
1547 if (writeToLog)
1548 {
1549 if (match.hit)
1550 {
1551 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"VersionNumSQ");
1552 }
1553 else
1554 {
1555 System.Lex.WriteFailureToLog(lexer, u"VersionNumSQ");
1556 }
1557 }
1558 #endif
1559 if (!match.hit)
1560 {
1561 match.value = null;
1562 }
1563 return match;
1564 }
1565 public static Match VersionNumber(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
1566 {
1567 #if (DEBUG)
1568 Span debugSpan;
1569 bool writeToLog = lexer.Log() != null;
1570 if (writeToLog)
1571 {
1572 debugSpan = lexer.GetSpan();
1573 System.Lex.WriteBeginRuleToLog(lexer, u"VersionNumber");
1574 }
1575 #endif
1576 System.Lex.RuleGuard ruleGuard(lexer, 15);
1577 Match match(false);
1578 Match* parentMatch0 = &match;
1579 {
1580 long save = lexer.GetPos();
1581 Match match = XmlParser.VersionNumDQ(lexer, processor);
1582 *parentMatch0 = match;
1583 if (!match.hit)
1584 {
1585 Match match(false);
1586 Match* parentMatch1 = &match;
1587 lexer.SetPos(save);
1588 {
1589 Match match = XmlParser.VersionNumSQ(lexer, processor);
1590 *parentMatch1 = match;
1591 }
1592 *parentMatch0 = match;
1593 }
1594 }
1595 #if (DEBUG)
1596 if (writeToLog)
1597 {
1598 if (match.hit)
1599 {
1600 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"VersionNumber");
1601 }
1602 else
1603 {
1604 System.Lex.WriteFailureToLog(lexer, u"VersionNumber");
1605 }
1606 }
1607 #endif
1608 if (!match.hit)
1609 {
1610 match.value = null;
1611 }
1612 return match;
1613 }
1614 public static Match EncodingDecl(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
1615 {
1616 #if (DEBUG)
1617 Span debugSpan;
1618 bool writeToLog = lexer.Log() != null;
1619 if (writeToLog)
1620 {
1621 debugSpan = lexer.GetSpan();
1622 System.Lex.WriteBeginRuleToLog(lexer, u"EncodingDecl");
1623 }
1624 #endif
1625 System.Lex.RuleGuard ruleGuard(lexer, 16);
1626 Match match(false);
1627 Match* parentMatch0 = &match;
1628 {
1629 Match match(false);
1630 Match* parentMatch1 = &match;
1631 {
1632 Match match(false);
1633 Match* parentMatch2 = &match;
1634 {
1635 Match match = XmlParser.S(lexer);
1636 *parentMatch2 = match;
1637 }
1638 if (match.hit)
1639 {
1640 Match match(false);
1641 Match* parentMatch3 = &match;
1642 {
1643 Match match(true);
1644 long __n = 8;
1645 for (long __k = 0; __k < __n; ++__k;)
1646 {
1647 int __i = s8[__k];
1648 if (*lexer == __i)
1649 {
1650 ++lexer;
1651 }
1652 else
1653 {
1654 match.hit = false;
1655 break;
1656 }
1657 }
1658 *parentMatch3 = match;
1659 }
1660 *parentMatch2 = match;
1661 }
1662 *parentMatch1 = match;
1663 }
1664 if (match.hit)
1665 {
1666 Match match(false);
1667 Match* parentMatch4 = &match;
1668 {
1669 Match match = XmlParser.Eq(lexer);
1670 *parentMatch4 = match;
1671 }
1672 *parentMatch1 = match;
1673 }
1674 *parentMatch0 = match;
1675 }
1676 if (match.hit)
1677 {
1678 Match match(false);
1679 Match* parentMatch5 = &match;
1680 {
1681 Match match = XmlParser.EncName(lexer, processor);
1682 *parentMatch5 = match;
1683 }
1684 *parentMatch0 = match;
1685 }
1686 #if (DEBUG)
1687 if (writeToLog)
1688 {
1689 if (match.hit)
1690 {
1691 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"EncodingDecl");
1692 }
1693 else
1694 {
1695 System.Lex.WriteFailureToLog(lexer, u"EncodingDecl");
1696 }
1697 }
1698 #endif
1699 if (!match.hit)
1700 {
1701 match.value = null;
1702 }
1703 return match;
1704 }
1705 public static Match EncodingName(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
1706 {
1707 #if (DEBUG)
1708 Span debugSpan;
1709 bool writeToLog = lexer.Log() != null;
1710 if (writeToLog)
1711 {
1712 debugSpan = lexer.GetSpan();
1713 System.Lex.WriteBeginRuleToLog(lexer, u"EncodingName");
1714 }
1715 #endif
1716 System.Lex.RuleGuard ruleGuard(lexer, 17);
1717 Span s;
1718 Match match(false);
1719 Match* parentMatch0 = &match;
1720 {
1721 long pos = lexer.GetPos();
1722 Match match(false);
1723 Match* parentMatch1 = &match;
1724 {
1725 Match match(false);
1726 Match* parentMatch2 = &match;
1727 {
1728 Match match(false);
1729 Match* parentMatch3 = &match;
1730 {
1731 long pos = lexer.GetPos();
1732 Span span = lexer.GetSpan();
1733 Match match(false);
1734 for (const Range& range : s9)
1735 {
1736 if (*lexer >= range.first && *lexer <= range.last)
1737 {
1738 match.hit = true;
1739 ++lexer;
1740 break;
1741 }
1742 }
1743 if (match.hit)
1744 {
1745 s = span;
1746 }
1747 *parentMatch3 = match;
1748 }
1749 *parentMatch2 = match;
1750 }
1751 if (match.hit)
1752 {
1753 Match match(false);
1754 Match* parentMatch4 = &match;
1755 {
1756 Match match(true);
1757 Match* parentMatch5 = &match;
1758 {
1759 while (true)
1760 {
1761 long save = lexer.GetPos();
1762 {
1763 Match match(false);
1764 Match* parentMatch6 = &match;
1765 {
1766 Match match(false);
1767 Match* parentMatch7 = &match;
1768 {
1769 long pos = lexer.GetPos();
1770 Span span = lexer.GetSpan();
1771 Match match(false);
1772 for (const Range& range : s10)
1773 {
1774 if (*lexer >= range.first && *lexer <= range.last)
1775 {
1776 match.hit = true;
1777 ++lexer;
1778 break;
1779 }
1780 }
1781 if (match.hit)
1782 {
1783 s.end = span.end;
1784 }
1785 *parentMatch7 = match;
1786 }
1787 *parentMatch6 = match;
1788 }
1789 if (match.hit)
1790 {
1791 *parentMatch5 = match;
1792 }
1793 else
1794 {
1795 lexer.SetPos(save);
1796 break;
1797 }
1798 }
1799 }
1800 }
1801 *parentMatch4 = match;
1802 }
1803 *parentMatch2 = match;
1804 }
1805 *parentMatch1 = match;
1806 }
1807 if (match.hit)
1808 {
1809 processor->Encoding(lexer.GetMatch(s));
1810 }
1811 *parentMatch0 = match;
1812 }
1813 #if (DEBUG)
1814 if (writeToLog)
1815 {
1816 if (match.hit)
1817 {
1818 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"EncodingName");
1819 }
1820 else
1821 {
1822 System.Lex.WriteFailureToLog(lexer, u"EncodingName");
1823 }
1824 }
1825 #endif
1826 if (!match.hit)
1827 {
1828 match.value = null;
1829 }
1830 return match;
1831 }
1832 public static Match EncNameDQ(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
1833 {
1834 #if (DEBUG)
1835 Span debugSpan;
1836 bool writeToLog = lexer.Log() != null;
1837 if (writeToLog)
1838 {
1839 debugSpan = lexer.GetSpan();
1840 System.Lex.WriteBeginRuleToLog(lexer, u"EncNameDQ");
1841 }
1842 #endif
1843 System.Lex.RuleGuard ruleGuard(lexer, 18);
1844 Match match(false);
1845 Match* parentMatch0 = &match;
1846 {
1847 Match match(false);
1848 Match* parentMatch1 = &match;
1849 {
1850 Match match(false);
1851 if (*lexer == 34)
1852 {
1853 ++lexer;
1854 match.hit = true;
1855 }
1856 *parentMatch1 = match;
1857 }
1858 if (match.hit)
1859 {
1860 Match match(false);
1861 Match* parentMatch2 = &match;
1862 {
1863 Match match = XmlParser.EncodingName(lexer, processor);
1864 *parentMatch2 = match;
1865 }
1866 *parentMatch1 = match;
1867 }
1868 *parentMatch0 = match;
1869 }
1870 if (match.hit)
1871 {
1872 Match match(false);
1873 Match* parentMatch3 = &match;
1874 {
1875 Match match(false);
1876 if (*lexer == 34)
1877 {
1878 ++lexer;
1879 match.hit = true;
1880 }
1881 *parentMatch3 = match;
1882 }
1883 *parentMatch0 = match;
1884 }
1885 #if (DEBUG)
1886 if (writeToLog)
1887 {
1888 if (match.hit)
1889 {
1890 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"EncNameDQ");
1891 }
1892 else
1893 {
1894 System.Lex.WriteFailureToLog(lexer, u"EncNameDQ");
1895 }
1896 }
1897 #endif
1898 if (!match.hit)
1899 {
1900 match.value = null;
1901 }
1902 return match;
1903 }
1904 public static Match EncNameSQ(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
1905 {
1906 #if (DEBUG)
1907 Span debugSpan;
1908 bool writeToLog = lexer.Log() != null;
1909 if (writeToLog)
1910 {
1911 debugSpan = lexer.GetSpan();
1912 System.Lex.WriteBeginRuleToLog(lexer, u"EncNameSQ");
1913 }
1914 #endif
1915 System.Lex.RuleGuard ruleGuard(lexer, 19);
1916 Match match(false);
1917 Match* parentMatch0 = &match;
1918 {
1919 Match match(false);
1920 Match* parentMatch1 = &match;
1921 {
1922 Match match(false);
1923 if (*lexer == 39)
1924 {
1925 ++lexer;
1926 match.hit = true;
1927 }
1928 *parentMatch1 = match;
1929 }
1930 if (match.hit)
1931 {
1932 Match match(false);
1933 Match* parentMatch2 = &match;
1934 {
1935 Match match = XmlParser.EncodingName(lexer, processor);
1936 *parentMatch2 = match;
1937 }
1938 *parentMatch1 = match;
1939 }
1940 *parentMatch0 = match;
1941 }
1942 if (match.hit)
1943 {
1944 Match match(false);
1945 Match* parentMatch3 = &match;
1946 {
1947 Match match(false);
1948 if (*lexer == 39)
1949 {
1950 ++lexer;
1951 match.hit = true;
1952 }
1953 *parentMatch3 = match;
1954 }
1955 *parentMatch0 = match;
1956 }
1957 #if (DEBUG)
1958 if (writeToLog)
1959 {
1960 if (match.hit)
1961 {
1962 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"EncNameSQ");
1963 }
1964 else
1965 {
1966 System.Lex.WriteFailureToLog(lexer, u"EncNameSQ");
1967 }
1968 }
1969 #endif
1970 if (!match.hit)
1971 {
1972 match.value = null;
1973 }
1974 return match;
1975 }
1976 public static Match EncName(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
1977 {
1978 #if (DEBUG)
1979 Span debugSpan;
1980 bool writeToLog = lexer.Log() != null;
1981 if (writeToLog)
1982 {
1983 debugSpan = lexer.GetSpan();
1984 System.Lex.WriteBeginRuleToLog(lexer, u"EncName");
1985 }
1986 #endif
1987 System.Lex.RuleGuard ruleGuard(lexer, 20);
1988 Match match(false);
1989 Match* parentMatch0 = &match;
1990 {
1991 long save = lexer.GetPos();
1992 Match match = XmlParser.EncNameDQ(lexer, processor);
1993 *parentMatch0 = match;
1994 if (!match.hit)
1995 {
1996 Match match(false);
1997 Match* parentMatch1 = &match;
1998 lexer.SetPos(save);
1999 {
2000 Match match = XmlParser.EncNameSQ(lexer, processor);
2001 *parentMatch1 = match;
2002 }
2003 *parentMatch0 = match;
2004 }
2005 }
2006 #if (DEBUG)
2007 if (writeToLog)
2008 {
2009 if (match.hit)
2010 {
2011 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"EncName");
2012 }
2013 else
2014 {
2015 System.Lex.WriteFailureToLog(lexer, u"EncName");
2016 }
2017 }
2018 #endif
2019 if (!match.hit)
2020 {
2021 match.value = null;
2022 }
2023 return match;
2024 }
2025 public static Match SDDecl(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
2026 {
2027 #if (DEBUG)
2028 Span debugSpan;
2029 bool writeToLog = lexer.Log() != null;
2030 if (writeToLog)
2031 {
2032 debugSpan = lexer.GetSpan();
2033 System.Lex.WriteBeginRuleToLog(lexer, u"SDDecl");
2034 }
2035 #endif
2036 System.Lex.RuleGuard ruleGuard(lexer, 21);
2037 UniquePtr<Value<bool>> yn;
2038 Match match(false);
2039 Match* parentMatch0 = &match;
2040 {
2041 Match match(false);
2042 Match* parentMatch1 = &match;
2043 {
2044 Match match(false);
2045 Match* parentMatch2 = &match;
2046 {
2047 Match match = XmlParser.S(lexer);
2048 *parentMatch2 = match;
2049 }
2050 if (match.hit)
2051 {
2052 Match match(false);
2053 Match* parentMatch3 = &match;
2054 {
2055 Match match(true);
2056 long __n = 10;
2057 for (long __k = 0; __k < __n; ++__k;)
2058 {
2059 int __i = s11[__k];
2060 if (*lexer == __i)
2061 {
2062 ++lexer;
2063 }
2064 else
2065 {
2066 match.hit = false;
2067 break;
2068 }
2069 }
2070 *parentMatch3 = match;
2071 }
2072 *parentMatch2 = match;
2073 }
2074 *parentMatch1 = match;
2075 }
2076 if (match.hit)
2077 {
2078 Match match(false);
2079 Match* parentMatch4 = &match;
2080 {
2081 Match match = XmlParser.Eq(lexer);
2082 *parentMatch4 = match;
2083 }
2084 *parentMatch1 = match;
2085 }
2086 *parentMatch0 = match;
2087 }
2088 if (match.hit)
2089 {
2090 Match match(false);
2091 Match* parentMatch5 = &match;
2092 {
2093 Match match(false);
2094 Match* parentMatch6 = &match;
2095 {
2096 long pos = lexer.GetPos();
2097 Match match = XmlParser.YesNo(lexer);
2098 yn.Reset(cast<Value<bool>*>(match.value));
2099 if (match.hit)
2100 {
2101 processor->Standalone(yn->value);
2102 }
2103 *parentMatch6 = match;
2104 }
2105 *parentMatch5 = match;
2106 }
2107 *parentMatch0 = match;
2108 }
2109 #if (DEBUG)
2110 if (writeToLog)
2111 {
2112 if (match.hit)
2113 {
2114 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"SDDecl");
2115 }
2116 else
2117 {
2118 System.Lex.WriteFailureToLog(lexer, u"SDDecl");
2119 }
2120 }
2121 #endif
2122 if (!match.hit)
2123 {
2124 match.value = null;
2125 }
2126 return match;
2127 }
2128 public static Match DocTypeDecl(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
2129 {
2130 #if (DEBUG)
2131 Span debugSpan;
2132 bool writeToLog = lexer.Log() != null;
2133 if (writeToLog)
2134 {
2135 debugSpan = lexer.GetSpan();
2136 System.Lex.WriteBeginRuleToLog(lexer, u"DocTypeDecl");
2137 }
2138 #endif
2139 System.Lex.RuleGuard ruleGuard(lexer, 22);
2140 UniquePtr<Value<ustring>> rootElementName;
2141 Match match(false);
2142 Match* parentMatch0 = &match;
2143 {
2144 Match match(false);
2145 Match* parentMatch1 = &match;
2146 {
2147 Match match(false);
2148 Match* parentMatch2 = &match;
2149 {
2150 Match match(false);
2151 Match* parentMatch3 = &match;
2152 {
2153 Match match(false);
2154 Match* parentMatch4 = &match;
2155 {
2156 Match match(false);
2157 Match* parentMatch5 = &match;
2158 {
2159 Match match(true);
2160 long __n = 9;
2161 for (long __k = 0; __k < __n; ++__k;)
2162 {
2163 int __i = s12[__k];
2164 if (*lexer == __i)
2165 {
2166 ++lexer;
2167 }
2168 else
2169 {
2170 match.hit = false;
2171 break;
2172 }
2173 }
2174 *parentMatch5 = match;
2175 }
2176 if (match.hit)
2177 {
2178 Match match(false);
2179 Match* parentMatch6 = &match;
2180 {
2181 Match match = XmlParser.S(lexer);
2182 *parentMatch6 = match;
2183 }
2184 *parentMatch5 = match;
2185 }
2186 *parentMatch4 = match;
2187 }
2188 if (match.hit)
2189 {
2190 Match match(false);
2191 Match* parentMatch7 = &match;
2192 {
2193 Match match = XmlParser.Name(lexer);
2194 rootElementName.Reset(cast<Value<ustring>*>(match.value));
2195 *parentMatch7 = match;
2196 }
2197 *parentMatch4 = match;
2198 }
2199 *parentMatch3 = match;
2200 }
2201 if (match.hit)
2202 {
2203 Match match(false);
2204 Match* parentMatch8 = &match;
2205 {
2206 Match match(true);
2207 long save = lexer.GetPos();
2208 Match* parentMatch9 = &match;
2209 {
2210 Match match(false);
2211 Match* parentMatch10 = &match;
2212 {
2213 Match match(false);
2214 Match* parentMatch11 = &match;
2215 {
2216 Match match = XmlParser.S(lexer);
2217 *parentMatch11 = match;
2218 }
2219 if (match.hit)
2220 {
2221 Match match(false);
2222 Match* parentMatch12 = &match;
2223 {
2224 Match match = XmlParser.ExternalID(lexer);
2225 *parentMatch12 = match;
2226 }
2227 *parentMatch11 = match;
2228 }
2229 *parentMatch10 = match;
2230 }
2231 if (match.hit)
2232 {
2233 *parentMatch9 = match;
2234 }
2235 else
2236 {
2237 lexer.SetPos(save);
2238 }
2239 }
2240 *parentMatch8 = match;
2241 }
2242 *parentMatch3 = match;
2243 }
2244 *parentMatch2 = match;
2245 }
2246 if (match.hit)
2247 {
2248 Match match(false);
2249 Match* parentMatch13 = &match;
2250 {
2251 Match match(true);
2252 long save = lexer.GetPos();
2253 Match* parentMatch14 = &match;
2254 {
2255 Match match = XmlParser.S(lexer);
2256 if (match.hit)
2257 {
2258 *parentMatch14 = match;
2259 }
2260 else
2261 {
2262 lexer.SetPos(save);
2263 }
2264 }
2265 *parentMatch13 = match;
2266 }
2267 *parentMatch2 = match;
2268 }
2269 *parentMatch1 = match;
2270 }
2271 if (match.hit)
2272 {
2273 Match match(false);
2274 Match* parentMatch15 = &match;
2275 {
2276 Match match(true);
2277 long save = lexer.GetPos();
2278 Match* parentMatch16 = &match;
2279 {
2280 Match match(false);
2281 Match* parentMatch17 = &match;
2282 {
2283 Match match(false);
2284 Match* parentMatch18 = &match;
2285 {
2286 Match match(false);
2287 Match* parentMatch19 = &match;
2288 {
2289 Match match(false);
2290 Match* parentMatch20 = &match;
2291 {
2292 Match match(false);
2293 if (*lexer == 91)
2294 {
2295 ++lexer;
2296 match.hit = true;
2297 }
2298 *parentMatch20 = match;
2299 }
2300 if (match.hit)
2301 {
2302 Match match(false);
2303 Match* parentMatch21 = &match;
2304 {
2305 Match match = XmlParser.IntSubset(lexer, processor);
2306 *parentMatch21 = match;
2307 }
2308 *parentMatch20 = match;
2309 }
2310 *parentMatch19 = match;
2311 }
2312 if (match.hit)
2313 {
2314 Match match(false);
2315 Match* parentMatch22 = &match;
2316 {
2317 Match match(false);
2318 if (*lexer == 93)
2319 {
2320 ++lexer;
2321 match.hit = true;
2322 }
2323 *parentMatch22 = match;
2324 }
2325 *parentMatch19 = match;
2326 }
2327 *parentMatch18 = match;
2328 }
2329 if (match.hit)
2330 {
2331 Match match(false);
2332 Match* parentMatch23 = &match;
2333 {
2334 Match match(true);
2335 long save = lexer.GetPos();
2336 Match* parentMatch24 = &match;
2337 {
2338 Match match = XmlParser.S(lexer);
2339 if (match.hit)
2340 {
2341 *parentMatch24 = match;
2342 }
2343 else
2344 {
2345 lexer.SetPos(save);
2346 }
2347 }
2348 *parentMatch23 = match;
2349 }
2350 *parentMatch18 = match;
2351 }
2352 *parentMatch17 = match;
2353 }
2354 if (match.hit)
2355 {
2356 *parentMatch16 = match;
2357 }
2358 else
2359 {
2360 lexer.SetPos(save);
2361 }
2362 }
2363 *parentMatch15 = match;
2364 }
2365 *parentMatch1 = match;
2366 }
2367 *parentMatch0 = match;
2368 }
2369 if (match.hit)
2370 {
2371 Match match(false);
2372 Match* parentMatch25 = &match;
2373 {
2374 Match match(false);
2375 if (*lexer == 62)
2376 {
2377 ++lexer;
2378 match.hit = true;
2379 }
2380 *parentMatch25 = match;
2381 }
2382 *parentMatch0 = match;
2383 }
2384 #if (DEBUG)
2385 if (writeToLog)
2386 {
2387 if (match.hit)
2388 {
2389 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"DocTypeDecl");
2390 }
2391 else
2392 {
2393 System.Lex.WriteFailureToLog(lexer, u"DocTypeDecl");
2394 }
2395 }
2396 #endif
2397 if (!match.hit)
2398 {
2399 match.value = null;
2400 }
2401 return match;
2402 }
2403 public static Match ExternalID(TrivialLexer& lexer)
2404 {
2405 #if (DEBUG)
2406 Span debugSpan;
2407 bool writeToLog = lexer.Log() != null;
2408 if (writeToLog)
2409 {
2410 debugSpan = lexer.GetSpan();
2411 System.Lex.WriteBeginRuleToLog(lexer, u"ExternalID");
2412 }
2413 #endif
2414 System.Lex.RuleGuard ruleGuard(lexer, 23);
2415 Match match(false);
2416 Match* parentMatch0 = &match;
2417 {
2418 long save = lexer.GetPos();
2419 Match match(false);
2420 Match* parentMatch1 = &match;
2421 {
2422 Match match(false);
2423 Match* parentMatch2 = &match;
2424 {
2425 Match match(false);
2426 Match* parentMatch3 = &match;
2427 {
2428 Match match(true);
2429 long __n = 6;
2430 for (long __k = 0; __k < __n; ++__k;)
2431 {
2432 int __i = s13[__k];
2433 if (*lexer == __i)
2434 {
2435 ++lexer;
2436 }
2437 else
2438 {
2439 match.hit = false;
2440 break;
2441 }
2442 }
2443 *parentMatch3 = match;
2444 }
2445 if (match.hit)
2446 {
2447 Match match(false);
2448 Match* parentMatch4 = &match;
2449 {
2450 Match match = XmlParser.S(lexer);
2451 *parentMatch4 = match;
2452 }
2453 *parentMatch3 = match;
2454 }
2455 *parentMatch2 = match;
2456 }
2457 if (match.hit)
2458 {
2459 Match match(false);
2460 Match* parentMatch5 = &match;
2461 {
2462 Match match = XmlParser.SystemLiteral(lexer);
2463 *parentMatch5 = match;
2464 }
2465 *parentMatch2 = match;
2466 }
2467 *parentMatch1 = match;
2468 }
2469 *parentMatch0 = match;
2470 if (!match.hit)
2471 {
2472 Match match(false);
2473 Match* parentMatch6 = &match;
2474 lexer.SetPos(save);
2475 {
2476 Match match(false);
2477 Match* parentMatch7 = &match;
2478 {
2479 Match match(false);
2480 Match* parentMatch8 = &match;
2481 {
2482 Match match(false);
2483 Match* parentMatch9 = &match;
2484 {
2485 Match match(false);
2486 Match* parentMatch10 = &match;
2487 {
2488 Match match(false);
2489 Match* parentMatch11 = &match;
2490 {
2491 Match match(true);
2492 long __n = 6;
2493 for (long __k = 0; __k < __n; ++__k;)
2494 {
2495 int __i = s14[__k];
2496 if (*lexer == __i)
2497 {
2498 ++lexer;
2499 }
2500 else
2501 {
2502 match.hit = false;
2503 break;
2504 }
2505 }
2506 *parentMatch11 = match;
2507 }
2508 if (match.hit)
2509 {
2510 Match match(false);
2511 Match* parentMatch12 = &match;
2512 {
2513 Match match = XmlParser.S(lexer);
2514 *parentMatch12 = match;
2515 }
2516 *parentMatch11 = match;
2517 }
2518 *parentMatch10 = match;
2519 }
2520 if (match.hit)
2521 {
2522 Match match(false);
2523 Match* parentMatch13 = &match;
2524 {
2525 Match match = XmlParser.PubidLiteral(lexer);
2526 *parentMatch13 = match;
2527 }
2528 *parentMatch10 = match;
2529 }
2530 *parentMatch9 = match;
2531 }
2532 if (match.hit)
2533 {
2534 Match match(false);
2535 Match* parentMatch14 = &match;
2536 {
2537 Match match = XmlParser.S(lexer);
2538 *parentMatch14 = match;
2539 }
2540 *parentMatch9 = match;
2541 }
2542 *parentMatch8 = match;
2543 }
2544 if (match.hit)
2545 {
2546 Match match(false);
2547 Match* parentMatch15 = &match;
2548 {
2549 Match match = XmlParser.SystemLiteral(lexer);
2550 *parentMatch15 = match;
2551 }
2552 *parentMatch8 = match;
2553 }
2554 *parentMatch7 = match;
2555 }
2556 *parentMatch6 = match;
2557 }
2558 *parentMatch0 = match;
2559 }
2560 }
2561 #if (DEBUG)
2562 if (writeToLog)
2563 {
2564 if (match.hit)
2565 {
2566 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"ExternalID");
2567 }
2568 else
2569 {
2570 System.Lex.WriteFailureToLog(lexer, u"ExternalID");
2571 }
2572 }
2573 #endif
2574 if (!match.hit)
2575 {
2576 match.value = null;
2577 }
2578 return match;
2579 }
2580 public static Match SystemLiteral(TrivialLexer& lexer)
2581 {
2582 #if (DEBUG)
2583 Span debugSpan;
2584 bool writeToLog = lexer.Log() != null;
2585 if (writeToLog)
2586 {
2587 debugSpan = lexer.GetSpan();
2588 System.Lex.WriteBeginRuleToLog(lexer, u"SystemLiteral");
2589 }
2590 #endif
2591 System.Lex.RuleGuard ruleGuard(lexer, 24);
2592 Match match(false);
2593 Match* parentMatch0 = &match;
2594 {
2595 long save = lexer.GetPos();
2596 Match match(false);
2597 Match* parentMatch1 = &match;
2598 {
2599 Match match(false);
2600 Match* parentMatch2 = &match;
2601 {
2602 Match match(false);
2603 Match* parentMatch3 = &match;
2604 {
2605 Match match(false);
2606 if (*lexer == 34)
2607 {
2608 ++lexer;
2609 match.hit = true;
2610 }
2611 *parentMatch3 = match;
2612 }
2613 if (match.hit)
2614 {
2615 Match match(false);
2616 Match* parentMatch4 = &match;
2617 {
2618 Match match(false);
2619 Match* parentMatch5 = &match;
2620 {
2621 Match match(true);
2622 Match* parentMatch6 = &match;
2623 {
2624 while (true)
2625 {
2626 long save = lexer.GetPos();
2627 {
2628 Match match(lexer.Pos() != lexer.End());
2629 for (const Range& range : s15)
2630 {
2631 if (*lexer >= range.first && *lexer <= range.last)
2632 {
2633 match.hit = false;
2634 break;
2635 }
2636 }
2637 if (match.hit)
2638 {
2639 ++lexer;
2640 }
2641 if (match.hit)
2642 {
2643 *parentMatch6 = match;
2644 }
2645 else
2646 {
2647 lexer.SetPos(save);
2648 break;
2649 }
2650 }
2651 }
2652 }
2653 *parentMatch5 = match;
2654 }
2655 *parentMatch4 = match;
2656 }
2657 *parentMatch3 = match;
2658 }
2659 *parentMatch2 = match;
2660 }
2661 if (match.hit)
2662 {
2663 Match match(false);
2664 Match* parentMatch7 = &match;
2665 {
2666 Match match(false);
2667 if (*lexer == 34)
2668 {
2669 ++lexer;
2670 match.hit = true;
2671 }
2672 *parentMatch7 = match;
2673 }
2674 *parentMatch2 = match;
2675 }
2676 *parentMatch1 = match;
2677 }
2678 *parentMatch0 = match;
2679 if (!match.hit)
2680 {
2681 Match match(false);
2682 Match* parentMatch8 = &match;
2683 lexer.SetPos(save);
2684 {
2685 Match match(false);
2686 Match* parentMatch9 = &match;
2687 {
2688 Match match(false);
2689 Match* parentMatch10 = &match;
2690 {
2691 Match match(false);
2692 Match* parentMatch11 = &match;
2693 {
2694 Match match(false);
2695 if (*lexer == 39)
2696 {
2697 ++lexer;
2698 match.hit = true;
2699 }
2700 *parentMatch11 = match;
2701 }
2702 if (match.hit)
2703 {
2704 Match match(false);
2705 Match* parentMatch12 = &match;
2706 {
2707 Match match(false);
2708 Match* parentMatch13 = &match;
2709 {
2710 Match match(true);
2711 Match* parentMatch14 = &match;
2712 {
2713 while (true)
2714 {
2715 long save = lexer.GetPos();
2716 {
2717 Match match(lexer.Pos() != lexer.End());
2718 for (const Range& range : s16)
2719 {
2720 if (*lexer >= range.first && *lexer <= range.last)
2721 {
2722 match.hit = false;
2723 break;
2724 }
2725 }
2726 if (match.hit)
2727 {
2728 ++lexer;
2729 }
2730 if (match.hit)
2731 {
2732 *parentMatch14 = match;
2733 }
2734 else
2735 {
2736 lexer.SetPos(save);
2737 break;
2738 }
2739 }
2740 }
2741 }
2742 *parentMatch13 = match;
2743 }
2744 *parentMatch12 = match;
2745 }
2746 *parentMatch11 = match;
2747 }
2748 *parentMatch10 = match;
2749 }
2750 if (match.hit)
2751 {
2752 Match match(false);
2753 Match* parentMatch15 = &match;
2754 {
2755 Match match(false);
2756 if (*lexer == 39)
2757 {
2758 ++lexer;
2759 match.hit = true;
2760 }
2761 *parentMatch15 = match;
2762 }
2763 *parentMatch10 = match;
2764 }
2765 *parentMatch9 = match;
2766 }
2767 *parentMatch8 = match;
2768 }
2769 *parentMatch0 = match;
2770 }
2771 }
2772 #if (DEBUG)
2773 if (writeToLog)
2774 {
2775 if (match.hit)
2776 {
2777 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"SystemLiteral");
2778 }
2779 else
2780 {
2781 System.Lex.WriteFailureToLog(lexer, u"SystemLiteral");
2782 }
2783 }
2784 #endif
2785 if (!match.hit)
2786 {
2787 match.value = null;
2788 }
2789 return match;
2790 }
2791 public static Match PubidLiteral(TrivialLexer& lexer)
2792 {
2793 #if (DEBUG)
2794 Span debugSpan;
2795 bool writeToLog = lexer.Log() != null;
2796 if (writeToLog)
2797 {
2798 debugSpan = lexer.GetSpan();
2799 System.Lex.WriteBeginRuleToLog(lexer, u"PubidLiteral");
2800 }
2801 #endif
2802 System.Lex.RuleGuard ruleGuard(lexer, 25);
2803 Match match(false);
2804 Match* parentMatch0 = &match;
2805 {
2806 long save = lexer.GetPos();
2807 Match match(false);
2808 Match* parentMatch1 = &match;
2809 {
2810 Match match(false);
2811 Match* parentMatch2 = &match;
2812 {
2813 Match match(false);
2814 if (*lexer == 34)
2815 {
2816 ++lexer;
2817 match.hit = true;
2818 }
2819 *parentMatch2 = match;
2820 }
2821 if (match.hit)
2822 {
2823 Match match(false);
2824 Match* parentMatch3 = &match;
2825 {
2826 Match match(false);
2827 Match* parentMatch4 = &match;
2828 {
2829 Match match(true);
2830 Match* parentMatch5 = &match;
2831 {
2832 while (true)
2833 {
2834 long save = lexer.GetPos();
2835 {
2836 Match match = XmlParser.PubidChar(lexer);
2837 if (match.hit)
2838 {
2839 *parentMatch5 = match;
2840 }
2841 else
2842 {
2843 lexer.SetPos(save);
2844 break;
2845 }
2846 }
2847 }
2848 }
2849 *parentMatch4 = match;
2850 }
2851 *parentMatch3 = match;
2852 }
2853 *parentMatch2 = match;
2854 }
2855 *parentMatch1 = match;
2856 }
2857 if (match.hit)
2858 {
2859 Match match(false);
2860 Match* parentMatch6 = &match;
2861 {
2862 Match match(false);
2863 if (*lexer == 34)
2864 {
2865 ++lexer;
2866 match.hit = true;
2867 }
2868 *parentMatch6 = match;
2869 }
2870 *parentMatch1 = match;
2871 }
2872 *parentMatch0 = match;
2873 if (!match.hit)
2874 {
2875 Match match(false);
2876 Match* parentMatch7 = &match;
2877 lexer.SetPos(save);
2878 {
2879 Match match(false);
2880 Match* parentMatch8 = &match;
2881 {
2882 Match match(false);
2883 Match* parentMatch9 = &match;
2884 {
2885 Match match(false);
2886 if (*lexer == 39)
2887 {
2888 ++lexer;
2889 match.hit = true;
2890 }
2891 *parentMatch9 = match;
2892 }
2893 if (match.hit)
2894 {
2895 Match match(false);
2896 Match* parentMatch10 = &match;
2897 {
2898 Match match(false);
2899 Match* parentMatch11 = &match;
2900 {
2901 Match match(true);
2902 Match* parentMatch12 = &match;
2903 {
2904 while (true)
2905 {
2906 long save = lexer.GetPos();
2907 {
2908 Match match(false);
2909 Match* parentMatch13 = &match;
2910 {
2911 Match match(false);
2912 Match* parentMatch14 = &match;
2913 long save = lexer.GetPos();
2914 {
2915 Match match = XmlParser.PubidChar(lexer);
2916 *parentMatch14 = match;
2917 }
2918 if (match.hit)
2919 {
2920 Match match(false);
2921 Match* parentMatch15 = &match;
2922 {
2923 long tmp = lexer.GetPos();
2924 lexer.SetPos(save);
2925 save = tmp;
2926 Match match(false);
2927 if (*lexer == 39)
2928 {
2929 ++lexer;
2930 match.hit = true;
2931 }
2932 *parentMatch15 = match;
2933 }
2934 if (!match.hit)
2935 {
2936 lexer.SetPos(save);
2937 }
2938 *parentMatch14 = Match(!match.hit, match.value);
2939 }
2940 *parentMatch13 = match;
2941 }
2942 if (match.hit)
2943 {
2944 *parentMatch12 = match;
2945 }
2946 else
2947 {
2948 lexer.SetPos(save);
2949 break;
2950 }
2951 }
2952 }
2953 }
2954 *parentMatch11 = match;
2955 }
2956 *parentMatch10 = match;
2957 }
2958 *parentMatch9 = match;
2959 }
2960 *parentMatch8 = match;
2961 }
2962 if (match.hit)
2963 {
2964 Match match(false);
2965 Match* parentMatch16 = &match;
2966 {
2967 Match match(false);
2968 if (*lexer == 39)
2969 {
2970 ++lexer;
2971 match.hit = true;
2972 }
2973 *parentMatch16 = match;
2974 }
2975 *parentMatch8 = match;
2976 }
2977 *parentMatch7 = match;
2978 }
2979 *parentMatch0 = match;
2980 }
2981 }
2982 #if (DEBUG)
2983 if (writeToLog)
2984 {
2985 if (match.hit)
2986 {
2987 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"PubidLiteral");
2988 }
2989 else
2990 {
2991 System.Lex.WriteFailureToLog(lexer, u"PubidLiteral");
2992 }
2993 }
2994 #endif
2995 if (!match.hit)
2996 {
2997 match.value = null;
2998 }
2999 return match;
3000 }
3001 public static Match PubidChar(TrivialLexer& lexer)
3002 {
3003 #if (DEBUG)
3004 Span debugSpan;
3005 bool writeToLog = lexer.Log() != null;
3006 if (writeToLog)
3007 {
3008 debugSpan = lexer.GetSpan();
3009 System.Lex.WriteBeginRuleToLog(lexer, u"PubidChar");
3010 }
3011 #endif
3012 System.Lex.RuleGuard ruleGuard(lexer, 26);
3013 Match match(false);
3014 Match* parentMatch0 = &match;
3015 {
3016 long save = lexer.GetPos();
3017 Match match(false);
3018 Match* parentMatch1 = &match;
3019 {
3020 long save = lexer.GetPos();
3021 Match match(false);
3022 for (const Range& range : s17)
3023 {
3024 if (*lexer >= range.first && *lexer <= range.last)
3025 {
3026 match.hit = true;
3027 ++lexer;
3028 break;
3029 }
3030 }
3031 *parentMatch1 = match;
3032 if (!match.hit)
3033 {
3034 Match match(false);
3035 Match* parentMatch2 = &match;
3036 lexer.SetPos(save);
3037 {
3038 Match match(false);
3039 for (const Range& range : s18)
3040 {
3041 if (*lexer >= range.first && *lexer <= range.last)
3042 {
3043 match.hit = true;
3044 ++lexer;
3045 break;
3046 }
3047 }
3048 *parentMatch2 = match;
3049 }
3050 *parentMatch1 = match;
3051 }
3052 }
3053 *parentMatch0 = match;
3054 if (!match.hit)
3055 {
3056 Match match(false);
3057 Match* parentMatch3 = &match;
3058 lexer.SetPos(save);
3059 {
3060 Match match(false);
3061 for (const Range& range : s19)
3062 {
3063 if (*lexer >= range.first && *lexer <= range.last)
3064 {
3065 match.hit = true;
3066 ++lexer;
3067 break;
3068 }
3069 }
3070 *parentMatch3 = match;
3071 }
3072 *parentMatch0 = match;
3073 }
3074 }
3075 #if (DEBUG)
3076 if (writeToLog)
3077 {
3078 if (match.hit)
3079 {
3080 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"PubidChar");
3081 }
3082 else
3083 {
3084 System.Lex.WriteFailureToLog(lexer, u"PubidChar");
3085 }
3086 }
3087 #endif
3088 if (!match.hit)
3089 {
3090 match.value = null;
3091 }
3092 return match;
3093 }
3094 public static Match IntSubset(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
3095 {
3096 #if (DEBUG)
3097 Span debugSpan;
3098 bool writeToLog = lexer.Log() != null;
3099 if (writeToLog)
3100 {
3101 debugSpan = lexer.GetSpan();
3102 System.Lex.WriteBeginRuleToLog(lexer, u"IntSubset");
3103 }
3104 #endif
3105 System.Lex.RuleGuard ruleGuard(lexer, 27);
3106 Match match(true);
3107 Match* parentMatch0 = &match;
3108 {
3109 while (true)
3110 {
3111 long save = lexer.GetPos();
3112 {
3113 Match match(false);
3114 Match* parentMatch1 = &match;
3115 {
3116 Match match(false);
3117 Match* parentMatch2 = &match;
3118 {
3119 long save = lexer.GetPos();
3120 Match match = XmlParser.MarkupDecl(lexer, processor);
3121 *parentMatch2 = match;
3122 if (!match.hit)
3123 {
3124 Match match(false);
3125 Match* parentMatch3 = &match;
3126 lexer.SetPos(save);
3127 {
3128 Match match = XmlParser.DeclSep(lexer, processor);
3129 *parentMatch3 = match;
3130 }
3131 *parentMatch2 = match;
3132 }
3133 }
3134 *parentMatch1 = match;
3135 }
3136 if (match.hit)
3137 {
3138 *parentMatch0 = match;
3139 }
3140 else
3141 {
3142 lexer.SetPos(save);
3143 break;
3144 }
3145 }
3146 }
3147 }
3148 #if (DEBUG)
3149 if (writeToLog)
3150 {
3151 if (match.hit)
3152 {
3153 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"IntSubset");
3154 }
3155 else
3156 {
3157 System.Lex.WriteFailureToLog(lexer, u"IntSubset");
3158 }
3159 }
3160 #endif
3161 if (!match.hit)
3162 {
3163 match.value = null;
3164 }
3165 return match;
3166 }
3167 public static Match MarkupDecl(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
3168 {
3169 #if (DEBUG)
3170 Span debugSpan;
3171 bool writeToLog = lexer.Log() != null;
3172 if (writeToLog)
3173 {
3174 debugSpan = lexer.GetSpan();
3175 System.Lex.WriteBeginRuleToLog(lexer, u"MarkupDecl");
3176 }
3177 #endif
3178 System.Lex.RuleGuard ruleGuard(lexer, 28);
3179 Match match(false);
3180 Match* parentMatch0 = &match;
3181 {
3182 long save = lexer.GetPos();
3183 Match match(false);
3184 Match* parentMatch1 = &match;
3185 {
3186 long save = lexer.GetPos();
3187 Match match(false);
3188 Match* parentMatch2 = &match;
3189 {
3190 long save = lexer.GetPos();
3191 Match match(false);
3192 Match* parentMatch3 = &match;
3193 {
3194 long save = lexer.GetPos();
3195 Match match(false);
3196 Match* parentMatch4 = &match;
3197 {
3198 long save = lexer.GetPos();
3199 Match match = XmlParser.ElementDecl(lexer, processor);
3200 *parentMatch4 = match;
3201 if (!match.hit)
3202 {
3203 Match match(false);
3204 Match* parentMatch5 = &match;
3205 lexer.SetPos(save);
3206 {
3207 Match match = XmlParser.AttlistDecl(lexer, processor);
3208 *parentMatch5 = match;
3209 }
3210 *parentMatch4 = match;
3211 }
3212 }
3213 *parentMatch3 = match;
3214 if (!match.hit)
3215 {
3216 Match match(false);
3217 Match* parentMatch6 = &match;
3218 lexer.SetPos(save);
3219 {
3220 Match match = XmlParser.EntityDecl(lexer, processor);
3221 *parentMatch6 = match;
3222 }
3223 *parentMatch3 = match;
3224 }
3225 }
3226 *parentMatch2 = match;
3227 if (!match.hit)
3228 {
3229 Match match(false);
3230 Match* parentMatch7 = &match;
3231 lexer.SetPos(save);
3232 {
3233 Match match = XmlParser.NotationDecl(lexer, processor);
3234 *parentMatch7 = match;
3235 }
3236 *parentMatch2 = match;
3237 }
3238 }
3239 *parentMatch1 = match;
3240 if (!match.hit)
3241 {
3242 Match match(false);
3243 Match* parentMatch8 = &match;
3244 lexer.SetPos(save);
3245 {
3246 Match match = XmlParser.PI(lexer, processor);
3247 *parentMatch8 = match;
3248 }
3249 *parentMatch1 = match;
3250 }
3251 }
3252 *parentMatch0 = match;
3253 if (!match.hit)
3254 {
3255 Match match(false);
3256 Match* parentMatch9 = &match;
3257 lexer.SetPos(save);
3258 {
3259 Match match = XmlParser.Comment(lexer, processor);
3260 *parentMatch9 = match;
3261 }
3262 *parentMatch0 = match;
3263 }
3264 }
3265 #if (DEBUG)
3266 if (writeToLog)
3267 {
3268 if (match.hit)
3269 {
3270 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"MarkupDecl");
3271 }
3272 else
3273 {
3274 System.Lex.WriteFailureToLog(lexer, u"MarkupDecl");
3275 }
3276 }
3277 #endif
3278 if (!match.hit)
3279 {
3280 match.value = null;
3281 }
3282 return match;
3283 }
3284 public static Match DeclSep(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
3285 {
3286 #if (DEBUG)
3287 Span debugSpan;
3288 bool writeToLog = lexer.Log() != null;
3289 if (writeToLog)
3290 {
3291 debugSpan = lexer.GetSpan();
3292 System.Lex.WriteBeginRuleToLog(lexer, u"DeclSep");
3293 }
3294 #endif
3295 System.Lex.RuleGuard ruleGuard(lexer, 29);
3296 Match match(false);
3297 Match* parentMatch0 = &match;
3298 {
3299 long save = lexer.GetPos();
3300 Match match = XmlParser.PEReference(lexer, processor);
3301 *parentMatch0 = match;
3302 if (!match.hit)
3303 {
3304 Match match(false);
3305 Match* parentMatch1 = &match;
3306 lexer.SetPos(save);
3307 {
3308 Match match = XmlParser.S(lexer);
3309 *parentMatch1 = match;
3310 }
3311 *parentMatch0 = match;
3312 }
3313 }
3314 #if (DEBUG)
3315 if (writeToLog)
3316 {
3317 if (match.hit)
3318 {
3319 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"DeclSep");
3320 }
3321 else
3322 {
3323 System.Lex.WriteFailureToLog(lexer, u"DeclSep");
3324 }
3325 }
3326 #endif
3327 if (!match.hit)
3328 {
3329 match.value = null;
3330 }
3331 return match;
3332 }
3333 public static Match ElementDecl(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
3334 {
3335 #if (DEBUG)
3336 Span debugSpan;
3337 bool writeToLog = lexer.Log() != null;
3338 if (writeToLog)
3339 {
3340 debugSpan = lexer.GetSpan();
3341 System.Lex.WriteBeginRuleToLog(lexer, u"ElementDecl");
3342 }
3343 #endif
3344 System.Lex.RuleGuard ruleGuard(lexer, 30);
3345 UniquePtr<Value<ustring>> elementName;
3346 Match match(false);
3347 Match* parentMatch0 = &match;
3348 {
3349 Match match(false);
3350 Match* parentMatch1 = &match;
3351 {
3352 Match match(false);
3353 Match* parentMatch2 = &match;
3354 {
3355 Match match(false);
3356 Match* parentMatch3 = &match;
3357 {
3358 Match match(false);
3359 Match* parentMatch4 = &match;
3360 {
3361 Match match(false);
3362 Match* parentMatch5 = &match;
3363 {
3364 Match match(true);
3365 long __n = 9;
3366 for (long __k = 0; __k < __n; ++__k;)
3367 {
3368 int __i = s20[__k];
3369 if (*lexer == __i)
3370 {
3371 ++lexer;
3372 }
3373 else
3374 {
3375 match.hit = false;
3376 break;
3377 }
3378 }
3379 *parentMatch5 = match;
3380 }
3381 if (match.hit)
3382 {
3383 Match match(false);
3384 Match* parentMatch6 = &match;
3385 {
3386 Match match = XmlParser.S(lexer);
3387 *parentMatch6 = match;
3388 }
3389 *parentMatch5 = match;
3390 }
3391 *parentMatch4 = match;
3392 }
3393 if (match.hit)
3394 {
3395 Match match(false);
3396 Match* parentMatch7 = &match;
3397 {
3398 Match match = XmlParser.Name(lexer);
3399 elementName.Reset(cast<Value<ustring>*>(match.value));
3400 *parentMatch7 = match;
3401 }
3402 *parentMatch4 = match;
3403 }
3404 *parentMatch3 = match;
3405 }
3406 if (match.hit)
3407 {
3408 Match match(false);
3409 Match* parentMatch8 = &match;
3410 {
3411 Match match = XmlParser.S(lexer);
3412 *parentMatch8 = match;
3413 }
3414 *parentMatch3 = match;
3415 }
3416 *parentMatch2 = match;
3417 }
3418 if (match.hit)
3419 {
3420 Match match(false);
3421 Match* parentMatch9 = &match;
3422 {
3423 Match match = XmlParser.ContentSpec(lexer);
3424 *parentMatch9 = match;
3425 }
3426 *parentMatch2 = match;
3427 }
3428 *parentMatch1 = match;
3429 }
3430 if (match.hit)
3431 {
3432 Match match(false);
3433 Match* parentMatch10 = &match;
3434 {
3435 Match match(true);
3436 long save = lexer.GetPos();
3437 Match* parentMatch11 = &match;
3438 {
3439 Match match = XmlParser.S(lexer);
3440 if (match.hit)
3441 {
3442 *parentMatch11 = match;
3443 }
3444 else
3445 {
3446 lexer.SetPos(save);
3447 }
3448 }
3449 *parentMatch10 = match;
3450 }
3451 *parentMatch1 = match;
3452 }
3453 *parentMatch0 = match;
3454 }
3455 if (match.hit)
3456 {
3457 Match match(false);
3458 Match* parentMatch12 = &match;
3459 {
3460 Match match(false);
3461 if (*lexer == 62)
3462 {
3463 ++lexer;
3464 match.hit = true;
3465 }
3466 *parentMatch12 = match;
3467 }
3468 *parentMatch0 = match;
3469 }
3470 #if (DEBUG)
3471 if (writeToLog)
3472 {
3473 if (match.hit)
3474 {
3475 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"ElementDecl");
3476 }
3477 else
3478 {
3479 System.Lex.WriteFailureToLog(lexer, u"ElementDecl");
3480 }
3481 }
3482 #endif
3483 if (!match.hit)
3484 {
3485 match.value = null;
3486 }
3487 return match;
3488 }
3489 public static Match ContentSpec(TrivialLexer& lexer)
3490 {
3491 #if (DEBUG)
3492 Span debugSpan;
3493 bool writeToLog = lexer.Log() != null;
3494 if (writeToLog)
3495 {
3496 debugSpan = lexer.GetSpan();
3497 System.Lex.WriteBeginRuleToLog(lexer, u"ContentSpec");
3498 }
3499 #endif
3500 System.Lex.RuleGuard ruleGuard(lexer, 31);
3501 Match match(false);
3502 Match* parentMatch0 = &match;
3503 {
3504 long save = lexer.GetPos();
3505 Match match(false);
3506 Match* parentMatch1 = &match;
3507 {
3508 long save = lexer.GetPos();
3509 Match match(false);
3510 Match* parentMatch2 = &match;
3511 {
3512 long save = lexer.GetPos();
3513 Match match(true);
3514 long __n = 5;
3515 for (long __k = 0; __k < __n; ++__k;)
3516 {
3517 int __i = s21[__k];
3518 if (*lexer == __i)
3519 {
3520 ++lexer;
3521 }
3522 else
3523 {
3524 match.hit = false;
3525 break;
3526 }
3527 }
3528 *parentMatch2 = match;
3529 if (!match.hit)
3530 {
3531 Match match(false);
3532 Match* parentMatch3 = &match;
3533 lexer.SetPos(save);
3534 {
3535 Match match(true);
3536 long __n = 3;
3537 for (long __k = 0; __k < __n; ++__k;)
3538 {
3539 int __i = s22[__k];
3540 if (*lexer == __i)
3541 {
3542 ++lexer;
3543 }
3544 else
3545 {
3546 match.hit = false;
3547 break;
3548 }
3549 }
3550 *parentMatch3 = match;
3551 }
3552 *parentMatch2 = match;
3553 }
3554 }
3555 *parentMatch1 = match;
3556 if (!match.hit)
3557 {
3558 Match match(false);
3559 Match* parentMatch4 = &match;
3560 lexer.SetPos(save);
3561 {
3562 Match match = XmlParser.Mixed(lexer);
3563 *parentMatch4 = match;
3564 }
3565 *parentMatch1 = match;
3566 }
3567 }
3568 *parentMatch0 = match;
3569 if (!match.hit)
3570 {
3571 Match match(false);
3572 Match* parentMatch5 = &match;
3573 lexer.SetPos(save);
3574 {
3575 Match match = XmlParser.Children(lexer);
3576 *parentMatch5 = match;
3577 }
3578 *parentMatch0 = match;
3579 }
3580 }
3581 #if (DEBUG)
3582 if (writeToLog)
3583 {
3584 if (match.hit)
3585 {
3586 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"ContentSpec");
3587 }
3588 else
3589 {
3590 System.Lex.WriteFailureToLog(lexer, u"ContentSpec");
3591 }
3592 }
3593 #endif
3594 if (!match.hit)
3595 {
3596 match.value = null;
3597 }
3598 return match;
3599 }
3600 public static Match Children(TrivialLexer& lexer)
3601 {
3602 #if (DEBUG)
3603 Span debugSpan;
3604 bool writeToLog = lexer.Log() != null;
3605 if (writeToLog)
3606 {
3607 debugSpan = lexer.GetSpan();
3608 System.Lex.WriteBeginRuleToLog(lexer, u"Children");
3609 }
3610 #endif
3611 System.Lex.RuleGuard ruleGuard(lexer, 32);
3612 Match match(false);
3613 Match* parentMatch0 = &match;
3614 {
3615 Match match(false);
3616 Match* parentMatch1 = &match;
3617 {
3618 Match match(false);
3619 Match* parentMatch2 = &match;
3620 {
3621 long save = lexer.GetPos();
3622 Match match = XmlParser.Choice(lexer);
3623 *parentMatch2 = match;
3624 if (!match.hit)
3625 {
3626 Match match(false);
3627 Match* parentMatch3 = &match;
3628 lexer.SetPos(save);
3629 {
3630 Match match = XmlParser.Seq(lexer);
3631 *parentMatch3 = match;
3632 }
3633 *parentMatch2 = match;
3634 }
3635 }
3636 *parentMatch1 = match;
3637 }
3638 *parentMatch0 = match;
3639 }
3640 if (match.hit)
3641 {
3642 Match match(false);
3643 Match* parentMatch4 = &match;
3644 {
3645 Match match(true);
3646 long save = lexer.GetPos();
3647 Match* parentMatch5 = &match;
3648 {
3649 Match match(false);
3650 Match* parentMatch6 = &match;
3651 {
3652 Match match(false);
3653 Match* parentMatch7 = &match;
3654 {
3655 long save = lexer.GetPos();
3656 Match match(false);
3657 Match* parentMatch8 = &match;
3658 {
3659 long save = lexer.GetPos();
3660 Match match(false);
3661 if (*lexer == 63)
3662 {
3663 ++lexer;
3664 match.hit = true;
3665 }
3666 *parentMatch8 = match;
3667 if (!match.hit)
3668 {
3669 Match match(false);
3670 Match* parentMatch9 = &match;
3671 lexer.SetPos(save);
3672 {
3673 Match match(false);
3674 if (*lexer == 42)
3675 {
3676 ++lexer;
3677 match.hit = true;
3678 }
3679 *parentMatch9 = match;
3680 }
3681 *parentMatch8 = match;
3682 }
3683 }
3684 *parentMatch7 = match;
3685 if (!match.hit)
3686 {
3687 Match match(false);
3688 Match* parentMatch10 = &match;
3689 lexer.SetPos(save);
3690 {
3691 Match match(false);
3692 if (*lexer == 43)
3693 {
3694 ++lexer;
3695 match.hit = true;
3696 }
3697 *parentMatch10 = match;
3698 }
3699 *parentMatch7 = match;
3700 }
3701 }
3702 *parentMatch6 = match;
3703 }
3704 if (match.hit)
3705 {
3706 *parentMatch5 = match;
3707 }
3708 else
3709 {
3710 lexer.SetPos(save);
3711 }
3712 }
3713 *parentMatch4 = match;
3714 }
3715 *parentMatch0 = match;
3716 }
3717 #if (DEBUG)
3718 if (writeToLog)
3719 {
3720 if (match.hit)
3721 {
3722 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Children");
3723 }
3724 else
3725 {
3726 System.Lex.WriteFailureToLog(lexer, u"Children");
3727 }
3728 }
3729 #endif
3730 if (!match.hit)
3731 {
3732 match.value = null;
3733 }
3734 return match;
3735 }
3736 public static Match CP(TrivialLexer& lexer)
3737 {
3738 #if (DEBUG)
3739 Span debugSpan;
3740 bool writeToLog = lexer.Log() != null;
3741 if (writeToLog)
3742 {
3743 debugSpan = lexer.GetSpan();
3744 System.Lex.WriteBeginRuleToLog(lexer, u"CP");
3745 }
3746 #endif
3747 System.Lex.RuleGuard ruleGuard(lexer, 33);
3748 UniquePtr<Value<ustring>> name;
3749 Match match(false);
3750 Match* parentMatch0 = &match;
3751 {
3752 Match match(false);
3753 Match* parentMatch1 = &match;
3754 {
3755 Match match(false);
3756 Match* parentMatch2 = &match;
3757 {
3758 long save = lexer.GetPos();
3759 Match match(false);
3760 Match* parentMatch3 = &match;
3761 {
3762 long save = lexer.GetPos();
3763 Match match = XmlParser.Name(lexer);
3764 name.Reset(cast<Value<ustring>*>(match.value));
3765 *parentMatch3 = match;
3766 if (!match.hit)
3767 {
3768 Match match(false);
3769 Match* parentMatch4 = &match;
3770 lexer.SetPos(save);
3771 {
3772 Match match = XmlParser.Choice(lexer);
3773 *parentMatch4 = match;
3774 }
3775 *parentMatch3 = match;
3776 }
3777 }
3778 *parentMatch2 = match;
3779 if (!match.hit)
3780 {
3781 Match match(false);
3782 Match* parentMatch5 = &match;
3783 lexer.SetPos(save);
3784 {
3785 Match match = XmlParser.Seq(lexer);
3786 *parentMatch5 = match;
3787 }
3788 *parentMatch2 = match;
3789 }
3790 }
3791 *parentMatch1 = match;
3792 }
3793 *parentMatch0 = match;
3794 }
3795 if (match.hit)
3796 {
3797 Match match(false);
3798 Match* parentMatch6 = &match;
3799 {
3800 Match match(true);
3801 long save = lexer.GetPos();
3802 Match* parentMatch7 = &match;
3803 {
3804 Match match(false);
3805 Match* parentMatch8 = &match;
3806 {
3807 Match match(false);
3808 Match* parentMatch9 = &match;
3809 {
3810 long save = lexer.GetPos();
3811 Match match(false);
3812 Match* parentMatch10 = &match;
3813 {
3814 long save = lexer.GetPos();
3815 Match match(false);
3816 if (*lexer == 63)
3817 {
3818 ++lexer;
3819 match.hit = true;
3820 }
3821 *parentMatch10 = match;
3822 if (!match.hit)
3823 {
3824 Match match(false);
3825 Match* parentMatch11 = &match;
3826 lexer.SetPos(save);
3827 {
3828 Match match(false);
3829 if (*lexer == 42)
3830 {
3831 ++lexer;
3832 match.hit = true;
3833 }
3834 *parentMatch11 = match;
3835 }
3836 *parentMatch10 = match;
3837 }
3838 }
3839 *parentMatch9 = match;
3840 if (!match.hit)
3841 {
3842 Match match(false);
3843 Match* parentMatch12 = &match;
3844 lexer.SetPos(save);
3845 {
3846 Match match(false);
3847 if (*lexer == 43)
3848 {
3849 ++lexer;
3850 match.hit = true;
3851 }
3852 *parentMatch12 = match;
3853 }
3854 *parentMatch9 = match;
3855 }
3856 }
3857 *parentMatch8 = match;
3858 }
3859 if (match.hit)
3860 {
3861 *parentMatch7 = match;
3862 }
3863 else
3864 {
3865 lexer.SetPos(save);
3866 }
3867 }
3868 *parentMatch6 = match;
3869 }
3870 *parentMatch0 = match;
3871 }
3872 #if (DEBUG)
3873 if (writeToLog)
3874 {
3875 if (match.hit)
3876 {
3877 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"CP");
3878 }
3879 else
3880 {
3881 System.Lex.WriteFailureToLog(lexer, u"CP");
3882 }
3883 }
3884 #endif
3885 if (!match.hit)
3886 {
3887 match.value = null;
3888 }
3889 return match;
3890 }
3891 public static Match Choice(TrivialLexer& lexer)
3892 {
3893 #if (DEBUG)
3894 Span debugSpan;
3895 bool writeToLog = lexer.Log() != null;
3896 if (writeToLog)
3897 {
3898 debugSpan = lexer.GetSpan();
3899 System.Lex.WriteBeginRuleToLog(lexer, u"Choice");
3900 }
3901 #endif
3902 System.Lex.RuleGuard ruleGuard(lexer, 34);
3903 Match match(false);
3904 Match* parentMatch0 = &match;
3905 {
3906 Match match(false);
3907 Match* parentMatch1 = &match;
3908 {
3909 Match match(false);
3910 Match* parentMatch2 = &match;
3911 {
3912 Match match(false);
3913 Match* parentMatch3 = &match;
3914 {
3915 Match match(false);
3916 Match* parentMatch4 = &match;
3917 {
3918 Match match(false);
3919 if (*lexer == 40)
3920 {
3921 ++lexer;
3922 match.hit = true;
3923 }
3924 *parentMatch4 = match;
3925 }
3926 if (match.hit)
3927 {
3928 Match match(false);
3929 Match* parentMatch5 = &match;
3930 {
3931 Match match(true);
3932 long save = lexer.GetPos();
3933 Match* parentMatch6 = &match;
3934 {
3935 Match match = XmlParser.S(lexer);
3936 if (match.hit)
3937 {
3938 *parentMatch6 = match;
3939 }
3940 else
3941 {
3942 lexer.SetPos(save);
3943 }
3944 }
3945 *parentMatch5 = match;
3946 }
3947 *parentMatch4 = match;
3948 }
3949 *parentMatch3 = match;
3950 }
3951 if (match.hit)
3952 {
3953 Match match(false);
3954 Match* parentMatch7 = &match;
3955 {
3956 Match match = XmlParser.CP(lexer);
3957 *parentMatch7 = match;
3958 }
3959 *parentMatch3 = match;
3960 }
3961 *parentMatch2 = match;
3962 }
3963 if (match.hit)
3964 {
3965 Match match(false);
3966 Match* parentMatch8 = &match;
3967 {
3968 Match match(false);
3969 Match* parentMatch9 = &match;
3970 {
3971 Match match(false);
3972 Match* parentMatch10 = &match;
3973 {
3974 Match match(false);
3975 Match* parentMatch11 = &match;
3976 {
3977 Match match(false);
3978 Match* parentMatch12 = &match;
3979 {
3980 Match match(false);
3981 Match* parentMatch13 = &match;
3982 {
3983 Match match(true);
3984 long save = lexer.GetPos();
3985 Match* parentMatch14 = &match;
3986 {
3987 Match match = XmlParser.S(lexer);
3988 if (match.hit)
3989 {
3990 *parentMatch14 = match;
3991 }
3992 else
3993 {
3994 lexer.SetPos(save);
3995 }
3996 }
3997 *parentMatch13 = match;
3998 }
3999 if (match.hit)
4000 {
4001 Match match(false);
4002 Match* parentMatch15 = &match;
4003 {
4004 Match match(false);
4005 if (*lexer == 124)
4006 {
4007 ++lexer;
4008 match.hit = true;
4009 }
4010 *parentMatch15 = match;
4011 }
4012 *parentMatch13 = match;
4013 }
4014 *parentMatch12 = match;
4015 }
4016 if (match.hit)
4017 {
4018 Match match(false);
4019 Match* parentMatch16 = &match;
4020 {
4021 Match match(true);
4022 long save = lexer.GetPos();
4023 Match* parentMatch17 = &match;
4024 {
4025 Match match = XmlParser.S(lexer);
4026 if (match.hit)
4027 {
4028 *parentMatch17 = match;
4029 }
4030 else
4031 {
4032 lexer.SetPos(save);
4033 }
4034 }
4035 *parentMatch16 = match;
4036 }
4037 *parentMatch12 = match;
4038 }
4039 *parentMatch11 = match;
4040 }
4041 if (match.hit)
4042 {
4043 Match match(false);
4044 Match* parentMatch18 = &match;
4045 {
4046 Match match = XmlParser.CP(lexer);
4047 *parentMatch18 = match;
4048 }
4049 *parentMatch11 = match;
4050 }
4051 *parentMatch10 = match;
4052 }
4053 *parentMatch9 = match;
4054 }
4055 if (match.hit)
4056 {
4057 Match match(true);
4058 Match* parentMatch19 = &match;
4059 while (true)
4060 {
4061 long save = lexer.GetPos();
4062 {
4063 Match match(false);
4064 Match* parentMatch20 = &match;
4065 {
4066 Match match(false);
4067 Match* parentMatch21 = &match;
4068 {
4069 Match match(false);
4070 Match* parentMatch22 = &match;
4071 {
4072 Match match(false);
4073 Match* parentMatch23 = &match;
4074 {
4075 Match match(true);
4076 long save = lexer.GetPos();
4077 Match* parentMatch24 = &match;
4078 {
4079 Match match = XmlParser.S(lexer);
4080 if (match.hit)
4081 {
4082 *parentMatch24 = match;
4083 }
4084 else
4085 {
4086 lexer.SetPos(save);
4087 }
4088 }
4089 *parentMatch23 = match;
4090 }
4091 if (match.hit)
4092 {
4093 Match match(false);
4094 Match* parentMatch25 = &match;
4095 {
4096 Match match(false);
4097 if (*lexer == 124)
4098 {
4099 ++lexer;
4100 match.hit = true;
4101 }
4102 *parentMatch25 = match;
4103 }
4104 *parentMatch23 = match;
4105 }
4106 *parentMatch22 = match;
4107 }
4108 if (match.hit)
4109 {
4110 Match match(false);
4111 Match* parentMatch26 = &match;
4112 {
4113 Match match(true);
4114 long save = lexer.GetPos();
4115 Match* parentMatch27 = &match;
4116 {
4117 Match match = XmlParser.S(lexer);
4118 if (match.hit)
4119 {
4120 *parentMatch27 = match;
4121 }
4122 else
4123 {
4124 lexer.SetPos(save);
4125 }
4126 }
4127 *parentMatch26 = match;
4128 }
4129 *parentMatch22 = match;
4130 }
4131 *parentMatch21 = match;
4132 }
4133 if (match.hit)
4134 {
4135 Match match(false);
4136 Match* parentMatch28 = &match;
4137 {
4138 Match match = XmlParser.CP(lexer);
4139 *parentMatch28 = match;
4140 }
4141 *parentMatch21 = match;
4142 }
4143 *parentMatch20 = match;
4144 }
4145 if (match.hit)
4146 {
4147 *parentMatch19 = match;
4148 }
4149 else
4150 {
4151 lexer.SetPos(save);
4152 break;
4153 }
4154 }
4155 }
4156 }
4157 *parentMatch8 = match;
4158 }
4159 *parentMatch2 = match;
4160 }
4161 *parentMatch1 = match;
4162 }
4163 if (match.hit)
4164 {
4165 Match match(false);
4166 Match* parentMatch29 = &match;
4167 {
4168 Match match(true);
4169 long save = lexer.GetPos();
4170 Match* parentMatch30 = &match;
4171 {
4172 Match match = XmlParser.S(lexer);
4173 if (match.hit)
4174 {
4175 *parentMatch30 = match;
4176 }
4177 else
4178 {
4179 lexer.SetPos(save);
4180 }
4181 }
4182 *parentMatch29 = match;
4183 }
4184 *parentMatch1 = match;
4185 }
4186 *parentMatch0 = match;
4187 }
4188 if (match.hit)
4189 {
4190 Match match(false);
4191 Match* parentMatch31 = &match;
4192 {
4193 Match match(false);
4194 if (*lexer == 41)
4195 {
4196 ++lexer;
4197 match.hit = true;
4198 }
4199 *parentMatch31 = match;
4200 }
4201 *parentMatch0 = match;
4202 }
4203 #if (DEBUG)
4204 if (writeToLog)
4205 {
4206 if (match.hit)
4207 {
4208 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Choice");
4209 }
4210 else
4211 {
4212 System.Lex.WriteFailureToLog(lexer, u"Choice");
4213 }
4214 }
4215 #endif
4216 if (!match.hit)
4217 {
4218 match.value = null;
4219 }
4220 return match;
4221 }
4222 public static Match Seq(TrivialLexer& lexer)
4223 {
4224 #if (DEBUG)
4225 Span debugSpan;
4226 bool writeToLog = lexer.Log() != null;
4227 if (writeToLog)
4228 {
4229 debugSpan = lexer.GetSpan();
4230 System.Lex.WriteBeginRuleToLog(lexer, u"Seq");
4231 }
4232 #endif
4233 System.Lex.RuleGuard ruleGuard(lexer, 35);
4234 Match match(false);
4235 Match* parentMatch0 = &match;
4236 {
4237 Match match(false);
4238 Match* parentMatch1 = &match;
4239 {
4240 Match match(false);
4241 Match* parentMatch2 = &match;
4242 {
4243 Match match(false);
4244 Match* parentMatch3 = &match;
4245 {
4246 Match match(false);
4247 Match* parentMatch4 = &match;
4248 {
4249 Match match(false);
4250 if (*lexer == 40)
4251 {
4252 ++lexer;
4253 match.hit = true;
4254 }
4255 *parentMatch4 = match;
4256 }
4257 if (match.hit)
4258 {
4259 Match match(false);
4260 Match* parentMatch5 = &match;
4261 {
4262 Match match(true);
4263 long save = lexer.GetPos();
4264 Match* parentMatch6 = &match;
4265 {
4266 Match match = XmlParser.S(lexer);
4267 if (match.hit)
4268 {
4269 *parentMatch6 = match;
4270 }
4271 else
4272 {
4273 lexer.SetPos(save);
4274 }
4275 }
4276 *parentMatch5 = match;
4277 }
4278 *parentMatch4 = match;
4279 }
4280 *parentMatch3 = match;
4281 }
4282 if (match.hit)
4283 {
4284 Match match(false);
4285 Match* parentMatch7 = &match;
4286 {
4287 Match match = XmlParser.CP(lexer);
4288 *parentMatch7 = match;
4289 }
4290 *parentMatch3 = match;
4291 }
4292 *parentMatch2 = match;
4293 }
4294 if (match.hit)
4295 {
4296 Match match(false);
4297 Match* parentMatch8 = &match;
4298 {
4299 Match match(true);
4300 Match* parentMatch9 = &match;
4301 {
4302 while (true)
4303 {
4304 long save = lexer.GetPos();
4305 {
4306 Match match(false);
4307 Match* parentMatch10 = &match;
4308 {
4309 Match match(false);
4310 Match* parentMatch11 = &match;
4311 {
4312 Match match(false);
4313 Match* parentMatch12 = &match;
4314 {
4315 Match match(false);
4316 Match* parentMatch13 = &match;
4317 {
4318 Match match(true);
4319 long save = lexer.GetPos();
4320 Match* parentMatch14 = &match;
4321 {
4322 Match match = XmlParser.S(lexer);
4323 if (match.hit)
4324 {
4325 *parentMatch14 = match;
4326 }
4327 else
4328 {
4329 lexer.SetPos(save);
4330 }
4331 }
4332 *parentMatch13 = match;
4333 }
4334 if (match.hit)
4335 {
4336 Match match(false);
4337 Match* parentMatch15 = &match;
4338 {
4339 Match match(false);
4340 if (*lexer == 44)
4341 {
4342 ++lexer;
4343 match.hit = true;
4344 }
4345 *parentMatch15 = match;
4346 }
4347 *parentMatch13 = match;
4348 }
4349 *parentMatch12 = match;
4350 }
4351 if (match.hit)
4352 {
4353 Match match(false);
4354 Match* parentMatch16 = &match;
4355 {
4356 Match match(true);
4357 long save = lexer.GetPos();
4358 Match* parentMatch17 = &match;
4359 {
4360 Match match = XmlParser.S(lexer);
4361 if (match.hit)
4362 {
4363 *parentMatch17 = match;
4364 }
4365 else
4366 {
4367 lexer.SetPos(save);
4368 }
4369 }
4370 *parentMatch16 = match;
4371 }
4372 *parentMatch12 = match;
4373 }
4374 *parentMatch11 = match;
4375 }
4376 if (match.hit)
4377 {
4378 Match match(false);
4379 Match* parentMatch18 = &match;
4380 {
4381 Match match = XmlParser.CP(lexer);
4382 *parentMatch18 = match;
4383 }
4384 *parentMatch11 = match;
4385 }
4386 *parentMatch10 = match;
4387 }
4388 if (match.hit)
4389 {
4390 *parentMatch9 = match;
4391 }
4392 else
4393 {
4394 lexer.SetPos(save);
4395 break;
4396 }
4397 }
4398 }
4399 }
4400 *parentMatch8 = match;
4401 }
4402 *parentMatch2 = match;
4403 }
4404 *parentMatch1 = match;
4405 }
4406 if (match.hit)
4407 {
4408 Match match(false);
4409 Match* parentMatch19 = &match;
4410 {
4411 Match match(true);
4412 long save = lexer.GetPos();
4413 Match* parentMatch20 = &match;
4414 {
4415 Match match = XmlParser.S(lexer);
4416 if (match.hit)
4417 {
4418 *parentMatch20 = match;
4419 }
4420 else
4421 {
4422 lexer.SetPos(save);
4423 }
4424 }
4425 *parentMatch19 = match;
4426 }
4427 *parentMatch1 = match;
4428 }
4429 *parentMatch0 = match;
4430 }
4431 if (match.hit)
4432 {
4433 Match match(false);
4434 Match* parentMatch21 = &match;
4435 {
4436 Match match(false);
4437 if (*lexer == 41)
4438 {
4439 ++lexer;
4440 match.hit = true;
4441 }
4442 *parentMatch21 = match;
4443 }
4444 *parentMatch0 = match;
4445 }
4446 #if (DEBUG)
4447 if (writeToLog)
4448 {
4449 if (match.hit)
4450 {
4451 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Seq");
4452 }
4453 else
4454 {
4455 System.Lex.WriteFailureToLog(lexer, u"Seq");
4456 }
4457 }
4458 #endif
4459 if (!match.hit)
4460 {
4461 match.value = null;
4462 }
4463 return match;
4464 }
4465 public static Match Mixed(TrivialLexer& lexer)
4466 {
4467 #if (DEBUG)
4468 Span debugSpan;
4469 bool writeToLog = lexer.Log() != null;
4470 if (writeToLog)
4471 {
4472 debugSpan = lexer.GetSpan();
4473 System.Lex.WriteBeginRuleToLog(lexer, u"Mixed");
4474 }
4475 #endif
4476 System.Lex.RuleGuard ruleGuard(lexer, 36);
4477 UniquePtr<Value<ustring>> name;
4478 Match match(false);
4479 Match* parentMatch0 = &match;
4480 {
4481 long save = lexer.GetPos();
4482 Match match(false);
4483 Match* parentMatch1 = &match;
4484 {
4485 Match match(false);
4486 Match* parentMatch2 = &match;
4487 {
4488 Match match(false);
4489 Match* parentMatch3 = &match;
4490 {
4491 Match match(false);
4492 Match* parentMatch4 = &match;
4493 {
4494 Match match(false);
4495 Match* parentMatch5 = &match;
4496 {
4497 Match match(false);
4498 if (*lexer == 40)
4499 {
4500 ++lexer;
4501 match.hit = true;
4502 }
4503 *parentMatch5 = match;
4504 }
4505 if (match.hit)
4506 {
4507 Match match(false);
4508 Match* parentMatch6 = &match;
4509 {
4510 Match match(true);
4511 long save = lexer.GetPos();
4512 Match* parentMatch7 = &match;
4513 {
4514 Match match = XmlParser.S(lexer);
4515 if (match.hit)
4516 {
4517 *parentMatch7 = match;
4518 }
4519 else
4520 {
4521 lexer.SetPos(save);
4522 }
4523 }
4524 *parentMatch6 = match;
4525 }
4526 *parentMatch5 = match;
4527 }
4528 *parentMatch4 = match;
4529 }
4530 if (match.hit)
4531 {
4532 Match match(false);
4533 Match* parentMatch8 = &match;
4534 {
4535 Match match(true);
4536 long __n = 7;
4537 for (long __k = 0; __k < __n; ++__k;)
4538 {
4539 int __i = s23[__k];
4540 if (*lexer == __i)
4541 {
4542 ++lexer;
4543 }
4544 else
4545 {
4546 match.hit = false;
4547 break;
4548 }
4549 }
4550 *parentMatch8 = match;
4551 }
4552 *parentMatch4 = match;
4553 }
4554 *parentMatch3 = match;
4555 }
4556 if (match.hit)
4557 {
4558 Match match(false);
4559 Match* parentMatch9 = &match;
4560 {
4561 Match match(true);
4562 Match* parentMatch10 = &match;
4563 {
4564 while (true)
4565 {
4566 long save = lexer.GetPos();
4567 {
4568 Match match(false);
4569 Match* parentMatch11 = &match;
4570 {
4571 Match match(false);
4572 Match* parentMatch12 = &match;
4573 {
4574 Match match(false);
4575 Match* parentMatch13 = &match;
4576 {
4577 Match match(false);
4578 Match* parentMatch14 = &match;
4579 {
4580 Match match(true);
4581 long save = lexer.GetPos();
4582 Match* parentMatch15 = &match;
4583 {
4584 Match match = XmlParser.S(lexer);
4585 if (match.hit)
4586 {
4587 *parentMatch15 = match;
4588 }
4589 else
4590 {
4591 lexer.SetPos(save);
4592 }
4593 }
4594 *parentMatch14 = match;
4595 }
4596 if (match.hit)
4597 {
4598 Match match(false);
4599 Match* parentMatch16 = &match;
4600 {
4601 Match match(false);
4602 if (*lexer == 124)
4603 {
4604 ++lexer;
4605 match.hit = true;
4606 }
4607 *parentMatch16 = match;
4608 }
4609 *parentMatch14 = match;
4610 }
4611 *parentMatch13 = match;
4612 }
4613 if (match.hit)
4614 {
4615 Match match(false);
4616 Match* parentMatch17 = &match;
4617 {
4618 Match match(true);
4619 long save = lexer.GetPos();
4620 Match* parentMatch18 = &match;
4621 {
4622 Match match = XmlParser.S(lexer);
4623 if (match.hit)
4624 {
4625 *parentMatch18 = match;
4626 }
4627 else
4628 {
4629 lexer.SetPos(save);
4630 }
4631 }
4632 *parentMatch17 = match;
4633 }
4634 *parentMatch13 = match;
4635 }
4636 *parentMatch12 = match;
4637 }
4638 if (match.hit)
4639 {
4640 Match match(false);
4641 Match* parentMatch19 = &match;
4642 {
4643 Match match = XmlParser.Name(lexer);
4644 name.Reset(cast<Value<ustring>*>(match.value));
4645 *parentMatch19 = match;
4646 }
4647 *parentMatch12 = match;
4648 }
4649 *parentMatch11 = match;
4650 }
4651 if (match.hit)
4652 {
4653 *parentMatch10 = match;
4654 }
4655 else
4656 {
4657 lexer.SetPos(save);
4658 break;
4659 }
4660 }
4661 }
4662 }
4663 *parentMatch9 = match;
4664 }
4665 *parentMatch3 = match;
4666 }
4667 *parentMatch2 = match;
4668 }
4669 if (match.hit)
4670 {
4671 Match match(false);
4672 Match* parentMatch20 = &match;
4673 {
4674 Match match(true);
4675 long save = lexer.GetPos();
4676 Match* parentMatch21 = &match;
4677 {
4678 Match match = XmlParser.S(lexer);
4679 if (match.hit)
4680 {
4681 *parentMatch21 = match;
4682 }
4683 else
4684 {
4685 lexer.SetPos(save);
4686 }
4687 }
4688 *parentMatch20 = match;
4689 }
4690 *parentMatch2 = match;
4691 }
4692 *parentMatch1 = match;
4693 }
4694 if (match.hit)
4695 {
4696 Match match(false);
4697 Match* parentMatch22 = &match;
4698 {
4699 Match match(true);
4700 long __n = 2;
4701 for (long __k = 0; __k < __n; ++__k;)
4702 {
4703 int __i = s24[__k];
4704 if (*lexer == __i)
4705 {
4706 ++lexer;
4707 }
4708 else
4709 {
4710 match.hit = false;
4711 break;
4712 }
4713 }
4714 *parentMatch22 = match;
4715 }
4716 *parentMatch1 = match;
4717 }
4718 *parentMatch0 = match;
4719 if (!match.hit)
4720 {
4721 Match match(false);
4722 Match* parentMatch23 = &match;
4723 lexer.SetPos(save);
4724 {
4725 Match match(false);
4726 Match* parentMatch24 = &match;
4727 {
4728 Match match(false);
4729 Match* parentMatch25 = &match;
4730 {
4731 Match match(false);
4732 Match* parentMatch26 = &match;
4733 {
4734 Match match(false);
4735 Match* parentMatch27 = &match;
4736 {
4737 Match match(false);
4738 if (*lexer == 40)
4739 {
4740 ++lexer;
4741 match.hit = true;
4742 }
4743 *parentMatch27 = match;
4744 }
4745 if (match.hit)
4746 {
4747 Match match(false);
4748 Match* parentMatch28 = &match;
4749 {
4750 Match match(true);
4751 long save = lexer.GetPos();
4752 Match* parentMatch29 = &match;
4753 {
4754 Match match = XmlParser.S(lexer);
4755 if (match.hit)
4756 {
4757 *parentMatch29 = match;
4758 }
4759 else
4760 {
4761 lexer.SetPos(save);
4762 }
4763 }
4764 *parentMatch28 = match;
4765 }
4766 *parentMatch27 = match;
4767 }
4768 *parentMatch26 = match;
4769 }
4770 if (match.hit)
4771 {
4772 Match match(false);
4773 Match* parentMatch30 = &match;
4774 {
4775 Match match(true);
4776 long __n = 7;
4777 for (long __k = 0; __k < __n; ++__k;)
4778 {
4779 int __i = s25[__k];
4780 if (*lexer == __i)
4781 {
4782 ++lexer;
4783 }
4784 else
4785 {
4786 match.hit = false;
4787 break;
4788 }
4789 }
4790 *parentMatch30 = match;
4791 }
4792 *parentMatch26 = match;
4793 }
4794 *parentMatch25 = match;
4795 }
4796 if (match.hit)
4797 {
4798 Match match(false);
4799 Match* parentMatch31 = &match;
4800 {
4801 Match match(true);
4802 long save = lexer.GetPos();
4803 Match* parentMatch32 = &match;
4804 {
4805 Match match = XmlParser.S(lexer);
4806 if (match.hit)
4807 {
4808 *parentMatch32 = match;
4809 }
4810 else
4811 {
4812 lexer.SetPos(save);
4813 }
4814 }
4815 *parentMatch31 = match;
4816 }
4817 *parentMatch25 = match;
4818 }
4819 *parentMatch24 = match;
4820 }
4821 if (match.hit)
4822 {
4823 Match match(false);
4824 Match* parentMatch33 = &match;
4825 {
4826 Match match(false);
4827 if (*lexer == 41)
4828 {
4829 ++lexer;
4830 match.hit = true;
4831 }
4832 *parentMatch33 = match;
4833 }
4834 *parentMatch24 = match;
4835 }
4836 *parentMatch23 = match;
4837 }
4838 *parentMatch0 = match;
4839 }
4840 }
4841 #if (DEBUG)
4842 if (writeToLog)
4843 {
4844 if (match.hit)
4845 {
4846 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Mixed");
4847 }
4848 else
4849 {
4850 System.Lex.WriteFailureToLog(lexer, u"Mixed");
4851 }
4852 }
4853 #endif
4854 if (!match.hit)
4855 {
4856 match.value = null;
4857 }
4858 return match;
4859 }
4860 public static Match AttlistDecl(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
4861 {
4862 #if (DEBUG)
4863 Span debugSpan;
4864 bool writeToLog = lexer.Log() != null;
4865 if (writeToLog)
4866 {
4867 debugSpan = lexer.GetSpan();
4868 System.Lex.WriteBeginRuleToLog(lexer, u"AttlistDecl");
4869 }
4870 #endif
4871 System.Lex.RuleGuard ruleGuard(lexer, 37);
4872 UniquePtr<Value<ustring>> name;
4873 Match match(false);
4874 Match* parentMatch0 = &match;
4875 {
4876 Match match(false);
4877 Match* parentMatch1 = &match;
4878 {
4879 Match match(false);
4880 Match* parentMatch2 = &match;
4881 {
4882 Match match(false);
4883 Match* parentMatch3 = &match;
4884 {
4885 Match match(false);
4886 Match* parentMatch4 = &match;
4887 {
4888 Match match(true);
4889 long __n = 9;
4890 for (long __k = 0; __k < __n; ++__k;)
4891 {
4892 int __i = s26[__k];
4893 if (*lexer == __i)
4894 {
4895 ++lexer;
4896 }
4897 else
4898 {
4899 match.hit = false;
4900 break;
4901 }
4902 }
4903 *parentMatch4 = match;
4904 }
4905 if (match.hit)
4906 {
4907 Match match(false);
4908 Match* parentMatch5 = &match;
4909 {
4910 Match match = XmlParser.S(lexer);
4911 *parentMatch5 = match;
4912 }
4913 *parentMatch4 = match;
4914 }
4915 *parentMatch3 = match;
4916 }
4917 if (match.hit)
4918 {
4919 Match match(false);
4920 Match* parentMatch6 = &match;
4921 {
4922 Match match = XmlParser.Name(lexer);
4923 name.Reset(cast<Value<ustring>*>(match.value));
4924 *parentMatch6 = match;
4925 }
4926 *parentMatch3 = match;
4927 }
4928 *parentMatch2 = match;
4929 }
4930 if (match.hit)
4931 {
4932 Match match(false);
4933 Match* parentMatch7 = &match;
4934 {
4935 Match match(true);
4936 Match* parentMatch8 = &match;
4937 {
4938 while (true)
4939 {
4940 long save = lexer.GetPos();
4941 {
4942 Match match = XmlParser.AttDef(lexer, processor);
4943 if (match.hit)
4944 {
4945 *parentMatch8 = match;
4946 }
4947 else
4948 {
4949 lexer.SetPos(save);
4950 break;
4951 }
4952 }
4953 }
4954 }
4955 *parentMatch7 = match;
4956 }
4957 *parentMatch2 = match;
4958 }
4959 *parentMatch1 = match;
4960 }
4961 if (match.hit)
4962 {
4963 Match match(false);
4964 Match* parentMatch9 = &match;
4965 {
4966 Match match(true);
4967 long save = lexer.GetPos();
4968 Match* parentMatch10 = &match;
4969 {
4970 Match match = XmlParser.S(lexer);
4971 if (match.hit)
4972 {
4973 *parentMatch10 = match;
4974 }
4975 else
4976 {
4977 lexer.SetPos(save);
4978 }
4979 }
4980 *parentMatch9 = match;
4981 }
4982 *parentMatch1 = match;
4983 }
4984 *parentMatch0 = match;
4985 }
4986 if (match.hit)
4987 {
4988 Match match(false);
4989 Match* parentMatch11 = &match;
4990 {
4991 Match match(false);
4992 if (*lexer == 62)
4993 {
4994 ++lexer;
4995 match.hit = true;
4996 }
4997 *parentMatch11 = match;
4998 }
4999 *parentMatch0 = match;
5000 }
5001 #if (DEBUG)
5002 if (writeToLog)
5003 {
5004 if (match.hit)
5005 {
5006 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"AttlistDecl");
5007 }
5008 else
5009 {
5010 System.Lex.WriteFailureToLog(lexer, u"AttlistDecl");
5011 }
5012 }
5013 #endif
5014 if (!match.hit)
5015 {
5016 match.value = null;
5017 }
5018 return match;
5019 }
5020 public static Match AttDef(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
5021 {
5022 #if (DEBUG)
5023 Span debugSpan;
5024 bool writeToLog = lexer.Log() != null;
5025 if (writeToLog)
5026 {
5027 debugSpan = lexer.GetSpan();
5028 System.Lex.WriteBeginRuleToLog(lexer, u"AttDef");
5029 }
5030 #endif
5031 System.Lex.RuleGuard ruleGuard(lexer, 38);
5032 UniquePtr<Value<ustring>> name;
5033 Match match(false);
5034 Match* parentMatch0 = &match;
5035 {
5036 Match match(false);
5037 Match* parentMatch1 = &match;
5038 {
5039 Match match(false);
5040 Match* parentMatch2 = &match;
5041 {
5042 Match match(false);
5043 Match* parentMatch3 = &match;
5044 {
5045 Match match(false);
5046 Match* parentMatch4 = &match;
5047 {
5048 Match match = XmlParser.S(lexer);
5049 *parentMatch4 = match;
5050 }
5051 if (match.hit)
5052 {
5053 Match match(false);
5054 Match* parentMatch5 = &match;
5055 {
5056 Match match = XmlParser.Name(lexer);
5057 name.Reset(cast<Value<ustring>*>(match.value));
5058 *parentMatch5 = match;
5059 }
5060 *parentMatch4 = match;
5061 }
5062 *parentMatch3 = match;
5063 }
5064 if (match.hit)
5065 {
5066 Match match(false);
5067 Match* parentMatch6 = &match;
5068 {
5069 Match match = XmlParser.S(lexer);
5070 *parentMatch6 = match;
5071 }
5072 *parentMatch3 = match;
5073 }
5074 *parentMatch2 = match;
5075 }
5076 if (match.hit)
5077 {
5078 Match match(false);
5079 Match* parentMatch7 = &match;
5080 {
5081 Match match = XmlParser.AttType(lexer);
5082 *parentMatch7 = match;
5083 }
5084 *parentMatch2 = match;
5085 }
5086 *parentMatch1 = match;
5087 }
5088 if (match.hit)
5089 {
5090 Match match(false);
5091 Match* parentMatch8 = &match;
5092 {
5093 Match match = XmlParser.S(lexer);
5094 *parentMatch8 = match;
5095 }
5096 *parentMatch1 = match;
5097 }
5098 *parentMatch0 = match;
5099 }
5100 if (match.hit)
5101 {
5102 Match match(false);
5103 Match* parentMatch9 = &match;
5104 {
5105 Match match = XmlParser.DefaultDecl(lexer, processor);
5106 *parentMatch9 = match;
5107 }
5108 *parentMatch0 = match;
5109 }
5110 #if (DEBUG)
5111 if (writeToLog)
5112 {
5113 if (match.hit)
5114 {
5115 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"AttDef");
5116 }
5117 else
5118 {
5119 System.Lex.WriteFailureToLog(lexer, u"AttDef");
5120 }
5121 }
5122 #endif
5123 if (!match.hit)
5124 {
5125 match.value = null;
5126 }
5127 return match;
5128 }
5129 public static Match AttType(TrivialLexer& lexer)
5130 {
5131 #if (DEBUG)
5132 Span debugSpan;
5133 bool writeToLog = lexer.Log() != null;
5134 if (writeToLog)
5135 {
5136 debugSpan = lexer.GetSpan();
5137 System.Lex.WriteBeginRuleToLog(lexer, u"AttType");
5138 }
5139 #endif
5140 System.Lex.RuleGuard ruleGuard(lexer, 39);
5141 Match match(false);
5142 Match* parentMatch0 = &match;
5143 {
5144 long save = lexer.GetPos();
5145 Match match(false);
5146 Match* parentMatch1 = &match;
5147 {
5148 long save = lexer.GetPos();
5149 Match match = XmlParser.StringType(lexer);
5150 *parentMatch1 = match;
5151 if (!match.hit)
5152 {
5153 Match match(false);
5154 Match* parentMatch2 = &match;
5155 lexer.SetPos(save);
5156 {
5157 Match match = XmlParser.TokenizedType(lexer);
5158 *parentMatch2 = match;
5159 }
5160 *parentMatch1 = match;
5161 }
5162 }
5163 *parentMatch0 = match;
5164 if (!match.hit)
5165 {
5166 Match match(false);
5167 Match* parentMatch3 = &match;
5168 lexer.SetPos(save);
5169 {
5170 Match match = XmlParser.EnumeratedType(lexer);
5171 *parentMatch3 = match;
5172 }
5173 *parentMatch0 = match;
5174 }
5175 }
5176 #if (DEBUG)
5177 if (writeToLog)
5178 {
5179 if (match.hit)
5180 {
5181 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"AttType");
5182 }
5183 else
5184 {
5185 System.Lex.WriteFailureToLog(lexer, u"AttType");
5186 }
5187 }
5188 #endif
5189 if (!match.hit)
5190 {
5191 match.value = null;
5192 }
5193 return match;
5194 }
5195 public static Match StringType(TrivialLexer& lexer)
5196 {
5197 #if (DEBUG)
5198 Span debugSpan;
5199 bool writeToLog = lexer.Log() != null;
5200 if (writeToLog)
5201 {
5202 debugSpan = lexer.GetSpan();
5203 System.Lex.WriteBeginRuleToLog(lexer, u"StringType");
5204 }
5205 #endif
5206 System.Lex.RuleGuard ruleGuard(lexer, 40);
5207 Match match(true);
5208 long __n = 5;
5209 for (long __k = 0; __k < __n; ++__k;)
5210 {
5211 int __i = s27[__k];
5212 if (*lexer == __i)
5213 {
5214 ++lexer;
5215 }
5216 else
5217 {
5218 match.hit = false;
5219 break;
5220 }
5221 }
5222 #if (DEBUG)
5223 if (writeToLog)
5224 {
5225 if (match.hit)
5226 {
5227 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"StringType");
5228 }
5229 else
5230 {
5231 System.Lex.WriteFailureToLog(lexer, u"StringType");
5232 }
5233 }
5234 #endif
5235 if (!match.hit)
5236 {
5237 match.value = null;
5238 }
5239 return match;
5240 }
5241 public static Match TokenizedType(TrivialLexer& lexer)
5242 {
5243 #if (DEBUG)
5244 Span debugSpan;
5245 bool writeToLog = lexer.Log() != null;
5246 if (writeToLog)
5247 {
5248 debugSpan = lexer.GetSpan();
5249 System.Lex.WriteBeginRuleToLog(lexer, u"TokenizedType");
5250 }
5251 #endif
5252 System.Lex.RuleGuard ruleGuard(lexer, 41);
5253 Match match(false);
5254 Match* parentMatch0 = &match;
5255 {
5256 long save = lexer.GetPos();
5257 Match match(false);
5258 Match* parentMatch1 = &match;
5259 {
5260 long save = lexer.GetPos();
5261 Match match(false);
5262 Match* parentMatch2 = &match;
5263 {
5264 long save = lexer.GetPos();
5265 Match match(false);
5266 Match* parentMatch3 = &match;
5267 {
5268 long save = lexer.GetPos();
5269 Match match(false);
5270 Match* parentMatch4 = &match;
5271 {
5272 long save = lexer.GetPos();
5273 Match match(false);
5274 Match* parentMatch5 = &match;
5275 {
5276 long save = lexer.GetPos();
5277 Match match(true);
5278 long __n = 2;
5279 for (long __k = 0; __k < __n; ++__k;)
5280 {
5281 int __i = s28[__k];
5282 if (*lexer == __i)
5283 {
5284 ++lexer;
5285 }
5286 else
5287 {
5288 match.hit = false;
5289 break;
5290 }
5291 }
5292 *parentMatch5 = match;
5293 if (!match.hit)
5294 {
5295 Match match(false);
5296 Match* parentMatch6 = &match;
5297 lexer.SetPos(save);
5298 {
5299 Match match(true);
5300 long __n = 5;
5301 for (long __k = 0; __k < __n; ++__k;)
5302 {
5303 int __i = s29[__k];
5304 if (*lexer == __i)
5305 {
5306 ++lexer;
5307 }
5308 else
5309 {
5310 match.hit = false;
5311 break;
5312 }
5313 }
5314 *parentMatch6 = match;
5315 }
5316 *parentMatch5 = match;
5317 }
5318 }
5319 *parentMatch4 = match;
5320 if (!match.hit)
5321 {
5322 Match match(false);
5323 Match* parentMatch7 = &match;
5324 lexer.SetPos(save);
5325 {
5326 Match match(true);
5327 long __n = 6;
5328 for (long __k = 0; __k < __n; ++__k;)
5329 {
5330 int __i = s30[__k];
5331 if (*lexer == __i)
5332 {
5333 ++lexer;
5334 }
5335 else
5336 {
5337 match.hit = false;
5338 break;
5339 }
5340 }
5341 *parentMatch7 = match;
5342 }
5343 *parentMatch4 = match;
5344 }
5345 }
5346 *parentMatch3 = match;
5347 if (!match.hit)
5348 {
5349 Match match(false);
5350 Match* parentMatch8 = &match;
5351 lexer.SetPos(save);
5352 {
5353 Match match(true);
5354 long __n = 6;
5355 for (long __k = 0; __k < __n; ++__k;)
5356 {
5357 int __i = s31[__k];
5358 if (*lexer == __i)
5359 {
5360 ++lexer;
5361 }
5362 else
5363 {
5364 match.hit = false;
5365 break;
5366 }
5367 }
5368 *parentMatch8 = match;
5369 }
5370 *parentMatch3 = match;
5371 }
5372 }
5373 *parentMatch2 = match;
5374 if (!match.hit)
5375 {
5376 Match match(false);
5377 Match* parentMatch9 = &match;
5378 lexer.SetPos(save);
5379 {
5380 Match match(true);
5381 long __n = 8;
5382 for (long __k = 0; __k < __n; ++__k;)
5383 {
5384 int __i = s32[__k];
5385 if (*lexer == __i)
5386 {
5387 ++lexer;
5388 }
5389 else
5390 {
5391 match.hit = false;
5392 break;
5393 }
5394 }
5395 *parentMatch9 = match;
5396 }
5397 *parentMatch2 = match;
5398 }
5399 }
5400 *parentMatch1 = match;
5401 if (!match.hit)
5402 {
5403 Match match(false);
5404 Match* parentMatch10 = &match;
5405 lexer.SetPos(save);
5406 {
5407 Match match(true);
5408 long __n = 7;
5409 for (long __k = 0; __k < __n; ++__k;)
5410 {
5411 int __i = s33[__k];
5412 if (*lexer == __i)
5413 {
5414 ++lexer;
5415 }
5416 else
5417 {
5418 match.hit = false;
5419 break;
5420 }
5421 }
5422 *parentMatch10 = match;
5423 }
5424 *parentMatch1 = match;
5425 }
5426 }
5427 *parentMatch0 = match;
5428 if (!match.hit)
5429 {
5430 Match match(false);
5431 Match* parentMatch11 = &match;
5432 lexer.SetPos(save);
5433 {
5434 Match match(true);
5435 long __n = 8;
5436 for (long __k = 0; __k < __n; ++__k;)
5437 {
5438 int __i = s34[__k];
5439 if (*lexer == __i)
5440 {
5441 ++lexer;
5442 }
5443 else
5444 {
5445 match.hit = false;
5446 break;
5447 }
5448 }
5449 *parentMatch11 = match;
5450 }
5451 *parentMatch0 = match;
5452 }
5453 }
5454 #if (DEBUG)
5455 if (writeToLog)
5456 {
5457 if (match.hit)
5458 {
5459 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"TokenizedType");
5460 }
5461 else
5462 {
5463 System.Lex.WriteFailureToLog(lexer, u"TokenizedType");
5464 }
5465 }
5466 #endif
5467 if (!match.hit)
5468 {
5469 match.value = null;
5470 }
5471 return match;
5472 }
5473 public static Match EnumeratedType(TrivialLexer& lexer)
5474 {
5475 #if (DEBUG)
5476 Span debugSpan;
5477 bool writeToLog = lexer.Log() != null;
5478 if (writeToLog)
5479 {
5480 debugSpan = lexer.GetSpan();
5481 System.Lex.WriteBeginRuleToLog(lexer, u"EnumeratedType");
5482 }
5483 #endif
5484 System.Lex.RuleGuard ruleGuard(lexer, 42);
5485 Match match(false);
5486 Match* parentMatch0 = &match;
5487 {
5488 long save = lexer.GetPos();
5489 Match match = XmlParser.NotationType(lexer);
5490 *parentMatch0 = match;
5491 if (!match.hit)
5492 {
5493 Match match(false);
5494 Match* parentMatch1 = &match;
5495 lexer.SetPos(save);
5496 {
5497 Match match = XmlParser.Enumeration(lexer);
5498 *parentMatch1 = match;
5499 }
5500 *parentMatch0 = match;
5501 }
5502 }
5503 #if (DEBUG)
5504 if (writeToLog)
5505 {
5506 if (match.hit)
5507 {
5508 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"EnumeratedType");
5509 }
5510 else
5511 {
5512 System.Lex.WriteFailureToLog(lexer, u"EnumeratedType");
5513 }
5514 }
5515 #endif
5516 if (!match.hit)
5517 {
5518 match.value = null;
5519 }
5520 return match;
5521 }
5522 public static Match NotationType(TrivialLexer& lexer)
5523 {
5524 #if (DEBUG)
5525 Span debugSpan;
5526 bool writeToLog = lexer.Log() != null;
5527 if (writeToLog)
5528 {
5529 debugSpan = lexer.GetSpan();
5530 System.Lex.WriteBeginRuleToLog(lexer, u"NotationType");
5531 }
5532 #endif
5533 System.Lex.RuleGuard ruleGuard(lexer, 43);
5534 UniquePtr<Value<ustring>> f;
5535 UniquePtr<Value<ustring>> n;
5536 Match match(false);
5537 Match* parentMatch0 = &match;
5538 {
5539 Match match(false);
5540 Match* parentMatch1 = &match;
5541 {
5542 Match match(false);
5543 Match* parentMatch2 = &match;
5544 {
5545 Match match(false);
5546 Match* parentMatch3 = &match;
5547 {
5548 Match match(false);
5549 Match* parentMatch4 = &match;
5550 {
5551 Match match(false);
5552 Match* parentMatch5 = &match;
5553 {
5554 Match match(false);
5555 Match* parentMatch6 = &match;
5556 {
5557 Match match(true);
5558 long __n = 8;
5559 for (long __k = 0; __k < __n; ++__k;)
5560 {
5561 int __i = s35[__k];
5562 if (*lexer == __i)
5563 {
5564 ++lexer;
5565 }
5566 else
5567 {
5568 match.hit = false;
5569 break;
5570 }
5571 }
5572 *parentMatch6 = match;
5573 }
5574 if (match.hit)
5575 {
5576 Match match(false);
5577 Match* parentMatch7 = &match;
5578 {
5579 Match match = XmlParser.S(lexer);
5580 *parentMatch7 = match;
5581 }
5582 *parentMatch6 = match;
5583 }
5584 *parentMatch5 = match;
5585 }
5586 if (match.hit)
5587 {
5588 Match match(false);
5589 Match* parentMatch8 = &match;
5590 {
5591 Match match(false);
5592 if (*lexer == 40)
5593 {
5594 ++lexer;
5595 match.hit = true;
5596 }
5597 *parentMatch8 = match;
5598 }
5599 *parentMatch5 = match;
5600 }
5601 *parentMatch4 = match;
5602 }
5603 if (match.hit)
5604 {
5605 Match match(false);
5606 Match* parentMatch9 = &match;
5607 {
5608 Match match(true);
5609 long save = lexer.GetPos();
5610 Match* parentMatch10 = &match;
5611 {
5612 Match match = XmlParser.S(lexer);
5613 if (match.hit)
5614 {
5615 *parentMatch10 = match;
5616 }
5617 else
5618 {
5619 lexer.SetPos(save);
5620 }
5621 }
5622 *parentMatch9 = match;
5623 }
5624 *parentMatch4 = match;
5625 }
5626 *parentMatch3 = match;
5627 }
5628 if (match.hit)
5629 {
5630 Match match(false);
5631 Match* parentMatch11 = &match;
5632 {
5633 Match match = XmlParser.Name(lexer);
5634 f.Reset(cast<Value<ustring>*>(match.value));
5635 *parentMatch11 = match;
5636 }
5637 *parentMatch3 = match;
5638 }
5639 *parentMatch2 = match;
5640 }
5641 if (match.hit)
5642 {
5643 Match match(false);
5644 Match* parentMatch12 = &match;
5645 {
5646 Match match(true);
5647 Match* parentMatch13 = &match;
5648 {
5649 while (true)
5650 {
5651 long save = lexer.GetPos();
5652 {
5653 Match match(false);
5654 Match* parentMatch14 = &match;
5655 {
5656 Match match(false);
5657 Match* parentMatch15 = &match;
5658 {
5659 Match match(false);
5660 Match* parentMatch16 = &match;
5661 {
5662 Match match(false);
5663 Match* parentMatch17 = &match;
5664 {
5665 Match match(true);
5666 long save = lexer.GetPos();
5667 Match* parentMatch18 = &match;
5668 {
5669 Match match = XmlParser.S(lexer);
5670 if (match.hit)
5671 {
5672 *parentMatch18 = match;
5673 }
5674 else
5675 {
5676 lexer.SetPos(save);
5677 }
5678 }
5679 *parentMatch17 = match;
5680 }
5681 if (match.hit)
5682 {
5683 Match match(false);
5684 Match* parentMatch19 = &match;
5685 {
5686 Match match(false);
5687 if (*lexer == 124)
5688 {
5689 ++lexer;
5690 match.hit = true;
5691 }
5692 *parentMatch19 = match;
5693 }
5694 *parentMatch17 = match;
5695 }
5696 *parentMatch16 = match;
5697 }
5698 if (match.hit)
5699 {
5700 Match match(false);
5701 Match* parentMatch20 = &match;
5702 {
5703 Match match(true);
5704 long save = lexer.GetPos();
5705 Match* parentMatch21 = &match;
5706 {
5707 Match match = XmlParser.S(lexer);
5708 if (match.hit)
5709 {
5710 *parentMatch21 = match;
5711 }
5712 else
5713 {
5714 lexer.SetPos(save);
5715 }
5716 }
5717 *parentMatch20 = match;
5718 }
5719 *parentMatch16 = match;
5720 }
5721 *parentMatch15 = match;
5722 }
5723 if (match.hit)
5724 {
5725 Match match(false);
5726 Match* parentMatch22 = &match;
5727 {
5728 Match match = XmlParser.Name(lexer);
5729 n.Reset(cast<Value<ustring>*>(match.value));
5730 *parentMatch22 = match;
5731 }
5732 *parentMatch15 = match;
5733 }
5734 *parentMatch14 = match;
5735 }
5736 if (match.hit)
5737 {
5738 *parentMatch13 = match;
5739 }
5740 else
5741 {
5742 lexer.SetPos(save);
5743 break;
5744 }
5745 }
5746 }
5747 }
5748 *parentMatch12 = match;
5749 }
5750 *parentMatch2 = match;
5751 }
5752 *parentMatch1 = match;
5753 }
5754 if (match.hit)
5755 {
5756 Match match(false);
5757 Match* parentMatch23 = &match;
5758 {
5759 Match match(true);
5760 long save = lexer.GetPos();
5761 Match* parentMatch24 = &match;
5762 {
5763 Match match = XmlParser.S(lexer);
5764 if (match.hit)
5765 {
5766 *parentMatch24 = match;
5767 }
5768 else
5769 {
5770 lexer.SetPos(save);
5771 }
5772 }
5773 *parentMatch23 = match;
5774 }
5775 *parentMatch1 = match;
5776 }
5777 *parentMatch0 = match;
5778 }
5779 if (match.hit)
5780 {
5781 Match match(false);
5782 Match* parentMatch25 = &match;
5783 {
5784 Match match(false);
5785 if (*lexer == 41)
5786 {
5787 ++lexer;
5788 match.hit = true;
5789 }
5790 *parentMatch25 = match;
5791 }
5792 *parentMatch0 = match;
5793 }
5794 #if (DEBUG)
5795 if (writeToLog)
5796 {
5797 if (match.hit)
5798 {
5799 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"NotationType");
5800 }
5801 else
5802 {
5803 System.Lex.WriteFailureToLog(lexer, u"NotationType");
5804 }
5805 }
5806 #endif
5807 if (!match.hit)
5808 {
5809 match.value = null;
5810 }
5811 return match;
5812 }
5813 public static Match Enumeration(TrivialLexer& lexer)
5814 {
5815 #if (DEBUG)
5816 Span debugSpan;
5817 bool writeToLog = lexer.Log() != null;
5818 if (writeToLog)
5819 {
5820 debugSpan = lexer.GetSpan();
5821 System.Lex.WriteBeginRuleToLog(lexer, u"Enumeration");
5822 }
5823 #endif
5824 System.Lex.RuleGuard ruleGuard(lexer, 44);
5825 Match match(false);
5826 Match* parentMatch0 = &match;
5827 {
5828 Match match(false);
5829 Match* parentMatch1 = &match;
5830 {
5831 Match match(false);
5832 Match* parentMatch2 = &match;
5833 {
5834 Match match(false);
5835 Match* parentMatch3 = &match;
5836 {
5837 Match match(false);
5838 Match* parentMatch4 = &match;
5839 {
5840 Match match(false);
5841 if (*lexer == 40)
5842 {
5843 ++lexer;
5844 match.hit = true;
5845 }
5846 *parentMatch4 = match;
5847 }
5848 if (match.hit)
5849 {
5850 Match match(false);
5851 Match* parentMatch5 = &match;
5852 {
5853 Match match(true);
5854 long save = lexer.GetPos();
5855 Match* parentMatch6 = &match;
5856 {
5857 Match match = XmlParser.S(lexer);
5858 if (match.hit)
5859 {
5860 *parentMatch6 = match;
5861 }
5862 else
5863 {
5864 lexer.SetPos(save);
5865 }
5866 }
5867 *parentMatch5 = match;
5868 }
5869 *parentMatch4 = match;
5870 }
5871 *parentMatch3 = match;
5872 }
5873 if (match.hit)
5874 {
5875 Match match(false);
5876 Match* parentMatch7 = &match;
5877 {
5878 Match match = XmlParser.Nmtoken(lexer);
5879 *parentMatch7 = match;
5880 }
5881 *parentMatch3 = match;
5882 }
5883 *parentMatch2 = match;
5884 }
5885 if (match.hit)
5886 {
5887 Match match(false);
5888 Match* parentMatch8 = &match;
5889 {
5890 Match match(true);
5891 Match* parentMatch9 = &match;
5892 {
5893 while (true)
5894 {
5895 long save = lexer.GetPos();
5896 {
5897 Match match(false);
5898 Match* parentMatch10 = &match;
5899 {
5900 Match match(false);
5901 Match* parentMatch11 = &match;
5902 {
5903 Match match(false);
5904 Match* parentMatch12 = &match;
5905 {
5906 Match match(false);
5907 Match* parentMatch13 = &match;
5908 {
5909 Match match(true);
5910 long save = lexer.GetPos();
5911 Match* parentMatch14 = &match;
5912 {
5913 Match match = XmlParser.S(lexer);
5914 if (match.hit)
5915 {
5916 *parentMatch14 = match;
5917 }
5918 else
5919 {
5920 lexer.SetPos(save);
5921 }
5922 }
5923 *parentMatch13 = match;
5924 }
5925 if (match.hit)
5926 {
5927 Match match(false);
5928 Match* parentMatch15 = &match;
5929 {
5930 Match match(false);
5931 if (*lexer == 124)
5932 {
5933 ++lexer;
5934 match.hit = true;
5935 }
5936 *parentMatch15 = match;
5937 }
5938 *parentMatch13 = match;
5939 }
5940 *parentMatch12 = match;
5941 }
5942 if (match.hit)
5943 {
5944 Match match(false);
5945 Match* parentMatch16 = &match;
5946 {
5947 Match match(true);
5948 long save = lexer.GetPos();
5949 Match* parentMatch17 = &match;
5950 {
5951 Match match = XmlParser.S(lexer);
5952 if (match.hit)
5953 {
5954 *parentMatch17 = match;
5955 }
5956 else
5957 {
5958 lexer.SetPos(save);
5959 }
5960 }
5961 *parentMatch16 = match;
5962 }
5963 *parentMatch12 = match;
5964 }
5965 *parentMatch11 = match;
5966 }
5967 if (match.hit)
5968 {
5969 Match match(false);
5970 Match* parentMatch18 = &match;
5971 {
5972 Match match = XmlParser.Nmtoken(lexer);
5973 *parentMatch18 = match;
5974 }
5975 *parentMatch11 = match;
5976 }
5977 *parentMatch10 = match;
5978 }
5979 if (match.hit)
5980 {
5981 *parentMatch9 = match;
5982 }
5983 else
5984 {
5985 lexer.SetPos(save);
5986 break;
5987 }
5988 }
5989 }
5990 }
5991 *parentMatch8 = match;
5992 }
5993 *parentMatch2 = match;
5994 }
5995 *parentMatch1 = match;
5996 }
5997 if (match.hit)
5998 {
5999 Match match(false);
6000 Match* parentMatch19 = &match;
6001 {
6002 Match match(true);
6003 long save = lexer.GetPos();
6004 Match* parentMatch20 = &match;
6005 {
6006 Match match = XmlParser.S(lexer);
6007 if (match.hit)
6008 {
6009 *parentMatch20 = match;
6010 }
6011 else
6012 {
6013 lexer.SetPos(save);
6014 }
6015 }
6016 *parentMatch19 = match;
6017 }
6018 *parentMatch1 = match;
6019 }
6020 *parentMatch0 = match;
6021 }
6022 if (match.hit)
6023 {
6024 Match match(false);
6025 Match* parentMatch21 = &match;
6026 {
6027 Match match(false);
6028 if (*lexer == 41)
6029 {
6030 ++lexer;
6031 match.hit = true;
6032 }
6033 *parentMatch21 = match;
6034 }
6035 *parentMatch0 = match;
6036 }
6037 #if (DEBUG)
6038 if (writeToLog)
6039 {
6040 if (match.hit)
6041 {
6042 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Enumeration");
6043 }
6044 else
6045 {
6046 System.Lex.WriteFailureToLog(lexer, u"Enumeration");
6047 }
6048 }
6049 #endif
6050 if (!match.hit)
6051 {
6052 match.value = null;
6053 }
6054 return match;
6055 }
6056 public static Match DefaultDecl(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
6057 {
6058 #if (DEBUG)
6059 Span debugSpan;
6060 bool writeToLog = lexer.Log() != null;
6061 if (writeToLog)
6062 {
6063 debugSpan = lexer.GetSpan();
6064 System.Lex.WriteBeginRuleToLog(lexer, u"DefaultDecl");
6065 }
6066 #endif
6067 System.Lex.RuleGuard ruleGuard(lexer, 45);
6068 UniquePtr<Value<ustring>> attVAlue;
6069 Match match(false);
6070 Match* parentMatch0 = &match;
6071 {
6072 long save = lexer.GetPos();
6073 Match match(false);
6074 Match* parentMatch1 = &match;
6075 {
6076 long save = lexer.GetPos();
6077 Match match(true);
6078 long __n = 9;
6079 for (long __k = 0; __k < __n; ++__k;)
6080 {
6081 int __i = s36[__k];
6082 if (*lexer == __i)
6083 {
6084 ++lexer;
6085 }
6086 else
6087 {
6088 match.hit = false;
6089 break;
6090 }
6091 }
6092 *parentMatch1 = match;
6093 if (!match.hit)
6094 {
6095 Match match(false);
6096 Match* parentMatch2 = &match;
6097 lexer.SetPos(save);
6098 {
6099 Match match(true);
6100 long __n = 8;
6101 for (long __k = 0; __k < __n; ++__k;)
6102 {
6103 int __i = s37[__k];
6104 if (*lexer == __i)
6105 {
6106 ++lexer;
6107 }
6108 else
6109 {
6110 match.hit = false;
6111 break;
6112 }
6113 }
6114 *parentMatch2 = match;
6115 }
6116 *parentMatch1 = match;
6117 }
6118 }
6119 *parentMatch0 = match;
6120 if (!match.hit)
6121 {
6122 Match match(false);
6123 Match* parentMatch3 = &match;
6124 lexer.SetPos(save);
6125 {
6126 Match match(false);
6127 Match* parentMatch4 = &match;
6128 {
6129 Match match(false);
6130 Match* parentMatch5 = &match;
6131 {
6132 Match match(true);
6133 long save = lexer.GetPos();
6134 Match* parentMatch6 = &match;
6135 {
6136 Match match(false);
6137 Match* parentMatch7 = &match;
6138 {
6139 Match match(false);
6140 Match* parentMatch8 = &match;
6141 {
6142 Match match(true);
6143 long __n = 6;
6144 for (long __k = 0; __k < __n; ++__k;)
6145 {
6146 int __i = s38[__k];
6147 if (*lexer == __i)
6148 {
6149 ++lexer;
6150 }
6151 else
6152 {
6153 match.hit = false;
6154 break;
6155 }
6156 }
6157 *parentMatch8 = match;
6158 }
6159 if (match.hit)
6160 {
6161 Match match(false);
6162 Match* parentMatch9 = &match;
6163 {
6164 Match match = XmlParser.S(lexer);
6165 *parentMatch9 = match;
6166 }
6167 *parentMatch8 = match;
6168 }
6169 *parentMatch7 = match;
6170 }
6171 if (match.hit)
6172 {
6173 *parentMatch6 = match;
6174 }
6175 else
6176 {
6177 lexer.SetPos(save);
6178 }
6179 }
6180 *parentMatch5 = match;
6181 }
6182 if (match.hit)
6183 {
6184 Match match(false);
6185 Match* parentMatch10 = &match;
6186 {
6187 Match match = XmlParser.AttValue(lexer, processor);
6188 attVAlue.Reset(cast<Value<ustring>*>(match.value));
6189 *parentMatch10 = match;
6190 }
6191 *parentMatch5 = match;
6192 }
6193 *parentMatch4 = match;
6194 }
6195 *parentMatch3 = match;
6196 }
6197 *parentMatch0 = match;
6198 }
6199 }
6200 #if (DEBUG)
6201 if (writeToLog)
6202 {
6203 if (match.hit)
6204 {
6205 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"DefaultDecl");
6206 }
6207 else
6208 {
6209 System.Lex.WriteFailureToLog(lexer, u"DefaultDecl");
6210 }
6211 }
6212 #endif
6213 if (!match.hit)
6214 {
6215 match.value = null;
6216 }
6217 return match;
6218 }
6219 public static Match EntityDecl(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
6220 {
6221 #if (DEBUG)
6222 Span debugSpan;
6223 bool writeToLog = lexer.Log() != null;
6224 if (writeToLog)
6225 {
6226 debugSpan = lexer.GetSpan();
6227 System.Lex.WriteBeginRuleToLog(lexer, u"EntityDecl");
6228 }
6229 #endif
6230 System.Lex.RuleGuard ruleGuard(lexer, 46);
6231 Match match(false);
6232 Match* parentMatch0 = &match;
6233 {
6234 long save = lexer.GetPos();
6235 Match match = XmlParser.GEDecl(lexer, processor);
6236 *parentMatch0 = match;
6237 if (!match.hit)
6238 {
6239 Match match(false);
6240 Match* parentMatch1 = &match;
6241 lexer.SetPos(save);
6242 {
6243 Match match = XmlParser.PEDecl(lexer, processor);
6244 *parentMatch1 = match;
6245 }
6246 *parentMatch0 = match;
6247 }
6248 }
6249 #if (DEBUG)
6250 if (writeToLog)
6251 {
6252 if (match.hit)
6253 {
6254 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"EntityDecl");
6255 }
6256 else
6257 {
6258 System.Lex.WriteFailureToLog(lexer, u"EntityDecl");
6259 }
6260 }
6261 #endif
6262 if (!match.hit)
6263 {
6264 match.value = null;
6265 }
6266 return match;
6267 }
6268 public static Match GEDecl(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
6269 {
6270 #if (DEBUG)
6271 Span debugSpan;
6272 bool writeToLog = lexer.Log() != null;
6273 if (writeToLog)
6274 {
6275 debugSpan = lexer.GetSpan();
6276 System.Lex.WriteBeginRuleToLog(lexer, u"GEDecl");
6277 }
6278 #endif
6279 System.Lex.RuleGuard ruleGuard(lexer, 47);
6280 UniquePtr<Value<ustring>> entityName;
6281 Match match(false);
6282 Match* parentMatch0 = &match;
6283 {
6284 Match match(false);
6285 Match* parentMatch1 = &match;
6286 {
6287 Match match(false);
6288 Match* parentMatch2 = &match;
6289 {
6290 Match match(false);
6291 Match* parentMatch3 = &match;
6292 {
6293 Match match(false);
6294 Match* parentMatch4 = &match;
6295 {
6296 Match match(false);
6297 Match* parentMatch5 = &match;
6298 {
6299 Match match(true);
6300 long __n = 8;
6301 for (long __k = 0; __k < __n; ++__k;)
6302 {
6303 int __i = s39[__k];
6304 if (*lexer == __i)
6305 {
6306 ++lexer;
6307 }
6308 else
6309 {
6310 match.hit = false;
6311 break;
6312 }
6313 }
6314 *parentMatch5 = match;
6315 }
6316 if (match.hit)
6317 {
6318 Match match(false);
6319 Match* parentMatch6 = &match;
6320 {
6321 Match match = XmlParser.S(lexer);
6322 *parentMatch6 = match;
6323 }
6324 *parentMatch5 = match;
6325 }
6326 *parentMatch4 = match;
6327 }
6328 if (match.hit)
6329 {
6330 Match match(false);
6331 Match* parentMatch7 = &match;
6332 {
6333 Match match = XmlParser.Name(lexer);
6334 entityName.Reset(cast<Value<ustring>*>(match.value));
6335 *parentMatch7 = match;
6336 }
6337 *parentMatch4 = match;
6338 }
6339 *parentMatch3 = match;
6340 }
6341 if (match.hit)
6342 {
6343 Match match(false);
6344 Match* parentMatch8 = &match;
6345 {
6346 Match match = XmlParser.S(lexer);
6347 *parentMatch8 = match;
6348 }
6349 *parentMatch3 = match;
6350 }
6351 *parentMatch2 = match;
6352 }
6353 if (match.hit)
6354 {
6355 Match match(false);
6356 Match* parentMatch9 = &match;
6357 {
6358 Match match = XmlParser.EntityDef(lexer, processor);
6359 *parentMatch9 = match;
6360 }
6361 *parentMatch2 = match;
6362 }
6363 *parentMatch1 = match;
6364 }
6365 if (match.hit)
6366 {
6367 Match match(false);
6368 Match* parentMatch10 = &match;
6369 {
6370 Match match(true);
6371 long save = lexer.GetPos();
6372 Match* parentMatch11 = &match;
6373 {
6374 Match match = XmlParser.S(lexer);
6375 if (match.hit)
6376 {
6377 *parentMatch11 = match;
6378 }
6379 else
6380 {
6381 lexer.SetPos(save);
6382 }
6383 }
6384 *parentMatch10 = match;
6385 }
6386 *parentMatch1 = match;
6387 }
6388 *parentMatch0 = match;
6389 }
6390 if (match.hit)
6391 {
6392 Match match(false);
6393 Match* parentMatch12 = &match;
6394 {
6395 Match match(false);
6396 if (*lexer == 62)
6397 {
6398 ++lexer;
6399 match.hit = true;
6400 }
6401 *parentMatch12 = match;
6402 }
6403 *parentMatch0 = match;
6404 }
6405 #if (DEBUG)
6406 if (writeToLog)
6407 {
6408 if (match.hit)
6409 {
6410 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"GEDecl");
6411 }
6412 else
6413 {
6414 System.Lex.WriteFailureToLog(lexer, u"GEDecl");
6415 }
6416 }
6417 #endif
6418 if (!match.hit)
6419 {
6420 match.value = null;
6421 }
6422 return match;
6423 }
6424 public static Match PEDecl(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
6425 {
6426 #if (DEBUG)
6427 Span debugSpan;
6428 bool writeToLog = lexer.Log() != null;
6429 if (writeToLog)
6430 {
6431 debugSpan = lexer.GetSpan();
6432 System.Lex.WriteBeginRuleToLog(lexer, u"PEDecl");
6433 }
6434 #endif
6435 System.Lex.RuleGuard ruleGuard(lexer, 48);
6436 UniquePtr<Value<ustring>> peName;
6437 Match match(false);
6438 Match* parentMatch0 = &match;
6439 {
6440 Match match(false);
6441 Match* parentMatch1 = &match;
6442 {
6443 Match match(false);
6444 Match* parentMatch2 = &match;
6445 {
6446 Match match(false);
6447 Match* parentMatch3 = &match;
6448 {
6449 Match match(false);
6450 Match* parentMatch4 = &match;
6451 {
6452 Match match(false);
6453 Match* parentMatch5 = &match;
6454 {
6455 Match match(false);
6456 Match* parentMatch6 = &match;
6457 {
6458 Match match(false);
6459 Match* parentMatch7 = &match;
6460 {
6461 Match match(true);
6462 long __n = 8;
6463 for (long __k = 0; __k < __n; ++__k;)
6464 {
6465 int __i = s40[__k];
6466 if (*lexer == __i)
6467 {
6468 ++lexer;
6469 }
6470 else
6471 {
6472 match.hit = false;
6473 break;
6474 }
6475 }
6476 *parentMatch7 = match;
6477 }
6478 if (match.hit)
6479 {
6480 Match match(false);
6481 Match* parentMatch8 = &match;
6482 {
6483 Match match = XmlParser.S(lexer);
6484 *parentMatch8 = match;
6485 }
6486 *parentMatch7 = match;
6487 }
6488 *parentMatch6 = match;
6489 }
6490 if (match.hit)
6491 {
6492 Match match(false);
6493 Match* parentMatch9 = &match;
6494 {
6495 Match match(false);
6496 if (*lexer == 37)
6497 {
6498 ++lexer;
6499 match.hit = true;
6500 }
6501 *parentMatch9 = match;
6502 }
6503 *parentMatch6 = match;
6504 }
6505 *parentMatch5 = match;
6506 }
6507 if (match.hit)
6508 {
6509 Match match(false);
6510 Match* parentMatch10 = &match;
6511 {
6512 Match match = XmlParser.S(lexer);
6513 *parentMatch10 = match;
6514 }
6515 *parentMatch5 = match;
6516 }
6517 *parentMatch4 = match;
6518 }
6519 if (match.hit)
6520 {
6521 Match match(false);
6522 Match* parentMatch11 = &match;
6523 {
6524 Match match = XmlParser.Name(lexer);
6525 peName.Reset(cast<Value<ustring>*>(match.value));
6526 *parentMatch11 = match;
6527 }
6528 *parentMatch4 = match;
6529 }
6530 *parentMatch3 = match;
6531 }
6532 if (match.hit)
6533 {
6534 Match match(false);
6535 Match* parentMatch12 = &match;
6536 {
6537 Match match = XmlParser.S(lexer);
6538 *parentMatch12 = match;
6539 }
6540 *parentMatch3 = match;
6541 }
6542 *parentMatch2 = match;
6543 }
6544 if (match.hit)
6545 {
6546 Match match(false);
6547 Match* parentMatch13 = &match;
6548 {
6549 Match match = XmlParser.PEDef(lexer, processor);
6550 *parentMatch13 = match;
6551 }
6552 *parentMatch2 = match;
6553 }
6554 *parentMatch1 = match;
6555 }
6556 if (match.hit)
6557 {
6558 Match match(false);
6559 Match* parentMatch14 = &match;
6560 {
6561 Match match(true);
6562 long save = lexer.GetPos();
6563 Match* parentMatch15 = &match;
6564 {
6565 Match match = XmlParser.S(lexer);
6566 if (match.hit)
6567 {
6568 *parentMatch15 = match;
6569 }
6570 else
6571 {
6572 lexer.SetPos(save);
6573 }
6574 }
6575 *parentMatch14 = match;
6576 }
6577 *parentMatch1 = match;
6578 }
6579 *parentMatch0 = match;
6580 }
6581 if (match.hit)
6582 {
6583 Match match(false);
6584 Match* parentMatch16 = &match;
6585 {
6586 Match match(false);
6587 if (*lexer == 62)
6588 {
6589 ++lexer;
6590 match.hit = true;
6591 }
6592 *parentMatch16 = match;
6593 }
6594 *parentMatch0 = match;
6595 }
6596 #if (DEBUG)
6597 if (writeToLog)
6598 {
6599 if (match.hit)
6600 {
6601 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"PEDecl");
6602 }
6603 else
6604 {
6605 System.Lex.WriteFailureToLog(lexer, u"PEDecl");
6606 }
6607 }
6608 #endif
6609 if (!match.hit)
6610 {
6611 match.value = null;
6612 }
6613 return match;
6614 }
6615 public static Match EntityDef(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
6616 {
6617 #if (DEBUG)
6618 Span debugSpan;
6619 bool writeToLog = lexer.Log() != null;
6620 if (writeToLog)
6621 {
6622 debugSpan = lexer.GetSpan();
6623 System.Lex.WriteBeginRuleToLog(lexer, u"EntityDef");
6624 }
6625 #endif
6626 System.Lex.RuleGuard ruleGuard(lexer, 49);
6627 Match match(false);
6628 Match* parentMatch0 = &match;
6629 {
6630 long save = lexer.GetPos();
6631 Match match = XmlParser.EntityValue(lexer, processor);
6632 *parentMatch0 = match;
6633 if (!match.hit)
6634 {
6635 Match match(false);
6636 Match* parentMatch1 = &match;
6637 lexer.SetPos(save);
6638 {
6639 Match match(false);
6640 Match* parentMatch2 = &match;
6641 {
6642 Match match(false);
6643 Match* parentMatch3 = &match;
6644 {
6645 Match match = XmlParser.ExternalID(lexer);
6646 *parentMatch3 = match;
6647 }
6648 if (match.hit)
6649 {
6650 Match match(false);
6651 Match* parentMatch4 = &match;
6652 {
6653 Match match(true);
6654 long save = lexer.GetPos();
6655 Match* parentMatch5 = &match;
6656 {
6657 Match match = XmlParser.NDataDecl(lexer);
6658 if (match.hit)
6659 {
6660 *parentMatch5 = match;
6661 }
6662 else
6663 {
6664 lexer.SetPos(save);
6665 }
6666 }
6667 *parentMatch4 = match;
6668 }
6669 *parentMatch3 = match;
6670 }
6671 *parentMatch2 = match;
6672 }
6673 *parentMatch1 = match;
6674 }
6675 *parentMatch0 = match;
6676 }
6677 }
6678 #if (DEBUG)
6679 if (writeToLog)
6680 {
6681 if (match.hit)
6682 {
6683 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"EntityDef");
6684 }
6685 else
6686 {
6687 System.Lex.WriteFailureToLog(lexer, u"EntityDef");
6688 }
6689 }
6690 #endif
6691 if (!match.hit)
6692 {
6693 match.value = null;
6694 }
6695 return match;
6696 }
6697 public static Match PEDef(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
6698 {
6699 #if (DEBUG)
6700 Span debugSpan;
6701 bool writeToLog = lexer.Log() != null;
6702 if (writeToLog)
6703 {
6704 debugSpan = lexer.GetSpan();
6705 System.Lex.WriteBeginRuleToLog(lexer, u"PEDef");
6706 }
6707 #endif
6708 System.Lex.RuleGuard ruleGuard(lexer, 50);
6709 Match match(false);
6710 Match* parentMatch0 = &match;
6711 {
6712 long save = lexer.GetPos();
6713 Match match = XmlParser.EntityValue(lexer, processor);
6714 *parentMatch0 = match;
6715 if (!match.hit)
6716 {
6717 Match match(false);
6718 Match* parentMatch1 = &match;
6719 lexer.SetPos(save);
6720 {
6721 Match match = XmlParser.ExternalID(lexer);
6722 *parentMatch1 = match;
6723 }
6724 *parentMatch0 = match;
6725 }
6726 }
6727 #if (DEBUG)
6728 if (writeToLog)
6729 {
6730 if (match.hit)
6731 {
6732 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"PEDef");
6733 }
6734 else
6735 {
6736 System.Lex.WriteFailureToLog(lexer, u"PEDef");
6737 }
6738 }
6739 #endif
6740 if (!match.hit)
6741 {
6742 match.value = null;
6743 }
6744 return match;
6745 }
6746 public static Match EntityValue(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
6747 {
6748 #if (DEBUG)
6749 Span debugSpan;
6750 bool writeToLog = lexer.Log() != null;
6751 if (writeToLog)
6752 {
6753 debugSpan = lexer.GetSpan();
6754 System.Lex.WriteBeginRuleToLog(lexer, u"EntityValue");
6755 }
6756 #endif
6757 System.Lex.RuleGuard ruleGuard(lexer, 51);
6758 Match match(false);
6759 Match* parentMatch0 = &match;
6760 {
6761 long save = lexer.GetPos();
6762 Match match(false);
6763 Match* parentMatch1 = &match;
6764 {
6765 Match match(false);
6766 Match* parentMatch2 = &match;
6767 {
6768 Match match(false);
6769 if (*lexer == 34)
6770 {
6771 ++lexer;
6772 match.hit = true;
6773 }
6774 *parentMatch2 = match;
6775 }
6776 if (match.hit)
6777 {
6778 Match match(false);
6779 Match* parentMatch3 = &match;
6780 {
6781 Match match(true);
6782 Match* parentMatch4 = &match;
6783 {
6784 while (true)
6785 {
6786 long save = lexer.GetPos();
6787 {
6788 Match match(false);
6789 Match* parentMatch5 = &match;
6790 {
6791 Match match(false);
6792 Match* parentMatch6 = &match;
6793 {
6794 long save = lexer.GetPos();
6795 Match match(false);
6796 Match* parentMatch7 = &match;
6797 {
6798 long save = lexer.GetPos();
6799 Match match(lexer.Pos() != lexer.End());
6800 for (const Range& range : s41)
6801 {
6802 if (*lexer >= range.first && *lexer <= range.last)
6803 {
6804 match.hit = false;
6805 break;
6806 }
6807 }
6808 if (match.hit)
6809 {
6810 ++lexer;
6811 }
6812 *parentMatch7 = match;
6813 if (!match.hit)
6814 {
6815 Match match(false);
6816 Match* parentMatch8 = &match;
6817 lexer.SetPos(save);
6818 {
6819 Match match = XmlParser.PEReference(lexer, processor);
6820 *parentMatch8 = match;
6821 }
6822 *parentMatch7 = match;
6823 }
6824 }
6825 *parentMatch6 = match;
6826 if (!match.hit)
6827 {
6828 Match match(false);
6829 Match* parentMatch9 = &match;
6830 lexer.SetPos(save);
6831 {
6832 Match match = XmlParser.Reference(lexer, processor);
6833 *parentMatch9 = match;
6834 }
6835 *parentMatch6 = match;
6836 }
6837 }
6838 *parentMatch5 = match;
6839 }
6840 if (match.hit)
6841 {
6842 *parentMatch4 = match;
6843 }
6844 else
6845 {
6846 lexer.SetPos(save);
6847 break;
6848 }
6849 }
6850 }
6851 }
6852 *parentMatch3 = match;
6853 }
6854 *parentMatch2 = match;
6855 }
6856 *parentMatch1 = match;
6857 }
6858 if (match.hit)
6859 {
6860 Match match(false);
6861 Match* parentMatch10 = &match;
6862 {
6863 Match match(false);
6864 if (*lexer == 34)
6865 {
6866 ++lexer;
6867 match.hit = true;
6868 }
6869 *parentMatch10 = match;
6870 }
6871 *parentMatch1 = match;
6872 }
6873 *parentMatch0 = match;
6874 if (!match.hit)
6875 {
6876 Match match(false);
6877 Match* parentMatch11 = &match;
6878 lexer.SetPos(save);
6879 {
6880 Match match(false);
6881 Match* parentMatch12 = &match;
6882 {
6883 Match match(false);
6884 Match* parentMatch13 = &match;
6885 {
6886 Match match(false);
6887 if (*lexer == 39)
6888 {
6889 ++lexer;
6890 match.hit = true;
6891 }
6892 *parentMatch13 = match;
6893 }
6894 if (match.hit)
6895 {
6896 Match match(false);
6897 Match* parentMatch14 = &match;
6898 {
6899 Match match(true);
6900 Match* parentMatch15 = &match;
6901 {
6902 while (true)
6903 {
6904 long save = lexer.GetPos();
6905 {
6906 Match match(false);
6907 Match* parentMatch16 = &match;
6908 {
6909 Match match(false);
6910 Match* parentMatch17 = &match;
6911 {
6912 long save = lexer.GetPos();
6913 Match match(false);
6914 Match* parentMatch18 = &match;
6915 {
6916 long save = lexer.GetPos();
6917 Match match(lexer.Pos() != lexer.End());
6918 for (const Range& range : s42)
6919 {
6920 if (*lexer >= range.first && *lexer <= range.last)
6921 {
6922 match.hit = false;
6923 break;
6924 }
6925 }
6926 if (match.hit)
6927 {
6928 ++lexer;
6929 }
6930 *parentMatch18 = match;
6931 if (!match.hit)
6932 {
6933 Match match(false);
6934 Match* parentMatch19 = &match;
6935 lexer.SetPos(save);
6936 {
6937 Match match = XmlParser.PEReference(lexer, processor);
6938 *parentMatch19 = match;
6939 }
6940 *parentMatch18 = match;
6941 }
6942 }
6943 *parentMatch17 = match;
6944 if (!match.hit)
6945 {
6946 Match match(false);
6947 Match* parentMatch20 = &match;
6948 lexer.SetPos(save);
6949 {
6950 Match match = XmlParser.Reference(lexer, processor);
6951 *parentMatch20 = match;
6952 }
6953 *parentMatch17 = match;
6954 }
6955 }
6956 *parentMatch16 = match;
6957 }
6958 if (match.hit)
6959 {
6960 *parentMatch15 = match;
6961 }
6962 else
6963 {
6964 lexer.SetPos(save);
6965 break;
6966 }
6967 }
6968 }
6969 }
6970 *parentMatch14 = match;
6971 }
6972 *parentMatch13 = match;
6973 }
6974 *parentMatch12 = match;
6975 }
6976 if (match.hit)
6977 {
6978 Match match(false);
6979 Match* parentMatch21 = &match;
6980 {
6981 Match match(false);
6982 if (*lexer == 39)
6983 {
6984 ++lexer;
6985 match.hit = true;
6986 }
6987 *parentMatch21 = match;
6988 }
6989 *parentMatch12 = match;
6990 }
6991 *parentMatch11 = match;
6992 }
6993 *parentMatch0 = match;
6994 }
6995 }
6996 #if (DEBUG)
6997 if (writeToLog)
6998 {
6999 if (match.hit)
7000 {
7001 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"EntityValue");
7002 }
7003 else
7004 {
7005 System.Lex.WriteFailureToLog(lexer, u"EntityValue");
7006 }
7007 }
7008 #endif
7009 if (!match.hit)
7010 {
7011 match.value = null;
7012 }
7013 return match;
7014 }
7015 public static Match NDataDecl(TrivialLexer& lexer)
7016 {
7017 #if (DEBUG)
7018 Span debugSpan;
7019 bool writeToLog = lexer.Log() != null;
7020 if (writeToLog)
7021 {
7022 debugSpan = lexer.GetSpan();
7023 System.Lex.WriteBeginRuleToLog(lexer, u"NDataDecl");
7024 }
7025 #endif
7026 System.Lex.RuleGuard ruleGuard(lexer, 52);
7027 UniquePtr<Value<ustring>> name;
7028 Match match(false);
7029 Match* parentMatch0 = &match;
7030 {
7031 Match match(false);
7032 Match* parentMatch1 = &match;
7033 {
7034 Match match(false);
7035 Match* parentMatch2 = &match;
7036 {
7037 Match match = XmlParser.S(lexer);
7038 *parentMatch2 = match;
7039 }
7040 if (match.hit)
7041 {
7042 Match match(false);
7043 Match* parentMatch3 = &match;
7044 {
7045 Match match(true);
7046 long __n = 5;
7047 for (long __k = 0; __k < __n; ++__k;)
7048 {
7049 int __i = s43[__k];
7050 if (*lexer == __i)
7051 {
7052 ++lexer;
7053 }
7054 else
7055 {
7056 match.hit = false;
7057 break;
7058 }
7059 }
7060 *parentMatch3 = match;
7061 }
7062 *parentMatch2 = match;
7063 }
7064 *parentMatch1 = match;
7065 }
7066 if (match.hit)
7067 {
7068 Match match(false);
7069 Match* parentMatch4 = &match;
7070 {
7071 Match match = XmlParser.S(lexer);
7072 *parentMatch4 = match;
7073 }
7074 *parentMatch1 = match;
7075 }
7076 *parentMatch0 = match;
7077 }
7078 if (match.hit)
7079 {
7080 Match match(false);
7081 Match* parentMatch5 = &match;
7082 {
7083 Match match = XmlParser.Name(lexer);
7084 name.Reset(cast<Value<ustring>*>(match.value));
7085 *parentMatch5 = match;
7086 }
7087 *parentMatch0 = match;
7088 }
7089 #if (DEBUG)
7090 if (writeToLog)
7091 {
7092 if (match.hit)
7093 {
7094 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"NDataDecl");
7095 }
7096 else
7097 {
7098 System.Lex.WriteFailureToLog(lexer, u"NDataDecl");
7099 }
7100 }
7101 #endif
7102 if (!match.hit)
7103 {
7104 match.value = null;
7105 }
7106 return match;
7107 }
7108 public static Match PEReference(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
7109 {
7110 #if (DEBUG)
7111 Span debugSpan;
7112 bool writeToLog = lexer.Log() != null;
7113 if (writeToLog)
7114 {
7115 debugSpan = lexer.GetSpan();
7116 System.Lex.WriteBeginRuleToLog(lexer, u"PEReference");
7117 }
7118 #endif
7119 System.Lex.RuleGuard ruleGuard(lexer, 53);
7120 UniquePtr<Value<ustring>> name;
7121 Match match(false);
7122 Match* parentMatch0 = &match;
7123 {
7124 Match match(false);
7125 Match* parentMatch1 = &match;
7126 {
7127 Match match(false);
7128 if (*lexer == 37)
7129 {
7130 ++lexer;
7131 match.hit = true;
7132 }
7133 *parentMatch1 = match;
7134 }
7135 if (match.hit)
7136 {
7137 Match match(false);
7138 Match* parentMatch2 = &match;
7139 {
7140 Match match = XmlParser.Name(lexer);
7141 name.Reset(cast<Value<ustring>*>(match.value));
7142 *parentMatch2 = match;
7143 }
7144 *parentMatch1 = match;
7145 }
7146 *parentMatch0 = match;
7147 }
7148 if (match.hit)
7149 {
7150 Match match(false);
7151 Match* parentMatch3 = &match;
7152 {
7153 Match match(false);
7154 if (*lexer == 59)
7155 {
7156 ++lexer;
7157 match.hit = true;
7158 }
7159 *parentMatch3 = match;
7160 }
7161 *parentMatch0 = match;
7162 }
7163 #if (DEBUG)
7164 if (writeToLog)
7165 {
7166 if (match.hit)
7167 {
7168 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"PEReference");
7169 }
7170 else
7171 {
7172 System.Lex.WriteFailureToLog(lexer, u"PEReference");
7173 }
7174 }
7175 #endif
7176 if (!match.hit)
7177 {
7178 match.value = null;
7179 }
7180 return match;
7181 }
7182 public static Match NotationDecl(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
7183 {
7184 #if (DEBUG)
7185 Span debugSpan;
7186 bool writeToLog = lexer.Log() != null;
7187 if (writeToLog)
7188 {
7189 debugSpan = lexer.GetSpan();
7190 System.Lex.WriteBeginRuleToLog(lexer, u"NotationDecl");
7191 }
7192 #endif
7193 System.Lex.RuleGuard ruleGuard(lexer, 54);
7194 UniquePtr<Value<ustring>> name;
7195 Match match(false);
7196 Match* parentMatch0 = &match;
7197 {
7198 Match match(false);
7199 Match* parentMatch1 = &match;
7200 {
7201 Match match(false);
7202 Match* parentMatch2 = &match;
7203 {
7204 Match match(false);
7205 Match* parentMatch3 = &match;
7206 {
7207 Match match(false);
7208 Match* parentMatch4 = &match;
7209 {
7210 Match match(false);
7211 Match* parentMatch5 = &match;
7212 {
7213 Match match(true);
7214 long __n = 10;
7215 for (long __k = 0; __k < __n; ++__k;)
7216 {
7217 int __i = s44[__k];
7218 if (*lexer == __i)
7219 {
7220 ++lexer;
7221 }
7222 else
7223 {
7224 match.hit = false;
7225 break;
7226 }
7227 }
7228 *parentMatch5 = match;
7229 }
7230 if (match.hit)
7231 {
7232 Match match(false);
7233 Match* parentMatch6 = &match;
7234 {
7235 Match match = XmlParser.S(lexer);
7236 *parentMatch6 = match;
7237 }
7238 *parentMatch5 = match;
7239 }
7240 *parentMatch4 = match;
7241 }
7242 if (match.hit)
7243 {
7244 Match match(false);
7245 Match* parentMatch7 = &match;
7246 {
7247 Match match = XmlParser.Name(lexer);
7248 name.Reset(cast<Value<ustring>*>(match.value));
7249 *parentMatch7 = match;
7250 }
7251 *parentMatch4 = match;
7252 }
7253 *parentMatch3 = match;
7254 }
7255 if (match.hit)
7256 {
7257 Match match(false);
7258 Match* parentMatch8 = &match;
7259 {
7260 Match match = XmlParser.S(lexer);
7261 *parentMatch8 = match;
7262 }
7263 *parentMatch3 = match;
7264 }
7265 *parentMatch2 = match;
7266 }
7267 if (match.hit)
7268 {
7269 Match match(false);
7270 Match* parentMatch9 = &match;
7271 {
7272 Match match(false);
7273 Match* parentMatch10 = &match;
7274 {
7275 Match match(false);
7276 Match* parentMatch11 = &match;
7277 {
7278 long save = lexer.GetPos();
7279 Match match = XmlParser.ExternalID(lexer);
7280 *parentMatch11 = match;
7281 if (!match.hit)
7282 {
7283 Match match(false);
7284 Match* parentMatch12 = &match;
7285 lexer.SetPos(save);
7286 {
7287 Match match = XmlParser.PublicID(lexer);
7288 *parentMatch12 = match;
7289 }
7290 *parentMatch11 = match;
7291 }
7292 }
7293 *parentMatch10 = match;
7294 }
7295 *parentMatch9 = match;
7296 }
7297 *parentMatch2 = match;
7298 }
7299 *parentMatch1 = match;
7300 }
7301 if (match.hit)
7302 {
7303 Match match(false);
7304 Match* parentMatch13 = &match;
7305 {
7306 Match match(true);
7307 long save = lexer.GetPos();
7308 Match* parentMatch14 = &match;
7309 {
7310 Match match = XmlParser.S(lexer);
7311 if (match.hit)
7312 {
7313 *parentMatch14 = match;
7314 }
7315 else
7316 {
7317 lexer.SetPos(save);
7318 }
7319 }
7320 *parentMatch13 = match;
7321 }
7322 *parentMatch1 = match;
7323 }
7324 *parentMatch0 = match;
7325 }
7326 if (match.hit)
7327 {
7328 Match match(false);
7329 Match* parentMatch15 = &match;
7330 {
7331 Match match(false);
7332 if (*lexer == 62)
7333 {
7334 ++lexer;
7335 match.hit = true;
7336 }
7337 *parentMatch15 = match;
7338 }
7339 *parentMatch0 = match;
7340 }
7341 #if (DEBUG)
7342 if (writeToLog)
7343 {
7344 if (match.hit)
7345 {
7346 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"NotationDecl");
7347 }
7348 else
7349 {
7350 System.Lex.WriteFailureToLog(lexer, u"NotationDecl");
7351 }
7352 }
7353 #endif
7354 if (!match.hit)
7355 {
7356 match.value = null;
7357 }
7358 return match;
7359 }
7360 public static Match PublicID(TrivialLexer& lexer)
7361 {
7362 #if (DEBUG)
7363 Span debugSpan;
7364 bool writeToLog = lexer.Log() != null;
7365 if (writeToLog)
7366 {
7367 debugSpan = lexer.GetSpan();
7368 System.Lex.WriteBeginRuleToLog(lexer, u"PublicID");
7369 }
7370 #endif
7371 System.Lex.RuleGuard ruleGuard(lexer, 55);
7372 Match match(false);
7373 Match* parentMatch0 = &match;
7374 {
7375 Match match(false);
7376 Match* parentMatch1 = &match;
7377 {
7378 Match match(true);
7379 long __n = 6;
7380 for (long __k = 0; __k < __n; ++__k;)
7381 {
7382 int __i = s45[__k];
7383 if (*lexer == __i)
7384 {
7385 ++lexer;
7386 }
7387 else
7388 {
7389 match.hit = false;
7390 break;
7391 }
7392 }
7393 *parentMatch1 = match;
7394 }
7395 if (match.hit)
7396 {
7397 Match match(false);
7398 Match* parentMatch2 = &match;
7399 {
7400 Match match = XmlParser.S(lexer);
7401 *parentMatch2 = match;
7402 }
7403 *parentMatch1 = match;
7404 }
7405 *parentMatch0 = match;
7406 }
7407 if (match.hit)
7408 {
7409 Match match(false);
7410 Match* parentMatch3 = &match;
7411 {
7412 Match match = XmlParser.PubidLiteral(lexer);
7413 *parentMatch3 = match;
7414 }
7415 *parentMatch0 = match;
7416 }
7417 #if (DEBUG)
7418 if (writeToLog)
7419 {
7420 if (match.hit)
7421 {
7422 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"PublicID");
7423 }
7424 else
7425 {
7426 System.Lex.WriteFailureToLog(lexer, u"PublicID");
7427 }
7428 }
7429 #endif
7430 if (!match.hit)
7431 {
7432 match.value = null;
7433 }
7434 return match;
7435 }
7436 public static Match Element(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
7437 {
7438 #if (DEBUG)
7439 Span debugSpan;
7440 bool writeToLog = lexer.Log() != null;
7441 if (writeToLog)
7442 {
7443 debugSpan = lexer.GetSpan();
7444 System.Lex.WriteBeginRuleToLog(lexer, u"Element");
7445 }
7446 #endif
7447 System.Lex.RuleGuard ruleGuard(lexer, 56);
7448 ustring tagName;
7449 UniquePtr<Value<ustring>> name;
7450 Match match(false);
7451 Match* parentMatch0 = &match;
7452 {
7453 Match match(false);
7454 Match* parentMatch1 = &match;
7455 {
7456 Match match(false);
7457 Match* parentMatch2 = &match;
7458 {
7459 Match match(false);
7460 Match* parentMatch3 = &match;
7461 {
7462 Match match(false);
7463 if (*lexer == 60)
7464 {
7465 ++lexer;
7466 match.hit = true;
7467 }
7468 *parentMatch3 = match;
7469 }
7470 if (match.hit)
7471 {
7472 Match match(false);
7473 Match* parentMatch4 = &match;
7474 {
7475 Match match(false);
7476 Match* parentMatch5 = &match;
7477 {
7478 long pos = lexer.GetPos();
7479 Match match = XmlParser.Name(lexer);
7480 name.Reset(cast<Value<ustring>*>(match.value));
7481 if (match.hit)
7482 {
7483 tagName = name->value;
7484 processor->BeginStartTag(tagName);
7485 }
7486 *parentMatch5 = match;
7487 }
7488 *parentMatch4 = match;
7489 }
7490 *parentMatch3 = match;
7491 }
7492 *parentMatch2 = match;
7493 }
7494 if (match.hit)
7495 {
7496 Match match(false);
7497 Match* parentMatch6 = &match;
7498 {
7499 Match match(true);
7500 Match* parentMatch7 = &match;
7501 {
7502 while (true)
7503 {
7504 long save = lexer.GetPos();
7505 {
7506 Match match(false);
7507 Match* parentMatch8 = &match;
7508 {
7509 Match match(false);
7510 Match* parentMatch9 = &match;
7511 {
7512 Match match = XmlParser.S(lexer);
7513 *parentMatch9 = match;
7514 }
7515 if (match.hit)
7516 {
7517 Match match(false);
7518 Match* parentMatch10 = &match;
7519 {
7520 Match match = XmlParser.Attribute(lexer, processor);
7521 *parentMatch10 = match;
7522 }
7523 *parentMatch9 = match;
7524 }
7525 *parentMatch8 = match;
7526 }
7527 if (match.hit)
7528 {
7529 *parentMatch7 = match;
7530 }
7531 else
7532 {
7533 lexer.SetPos(save);
7534 break;
7535 }
7536 }
7537 }
7538 }
7539 *parentMatch6 = match;
7540 }
7541 *parentMatch2 = match;
7542 }
7543 *parentMatch1 = match;
7544 }
7545 if (match.hit)
7546 {
7547 Match match(false);
7548 Match* parentMatch11 = &match;
7549 {
7550 Match match(true);
7551 long save = lexer.GetPos();
7552 Match* parentMatch12 = &match;
7553 {
7554 Match match = XmlParser.S(lexer);
7555 if (match.hit)
7556 {
7557 *parentMatch12 = match;
7558 }
7559 else
7560 {
7561 lexer.SetPos(save);
7562 }
7563 }
7564 *parentMatch11 = match;
7565 }
7566 *parentMatch1 = match;
7567 }
7568 *parentMatch0 = match;
7569 }
7570 if (match.hit)
7571 {
7572 Match match(false);
7573 Match* parentMatch13 = &match;
7574 {
7575 Match match(false);
7576 Match* parentMatch14 = &match;
7577 {
7578 Match match(false);
7579 Match* parentMatch15 = &match;
7580 {
7581 long save = lexer.GetPos();
7582 Match match(false);
7583 Match* parentMatch16 = &match;
7584 {
7585 long pos = lexer.GetPos();
7586 Span span = lexer.GetSpan();
7587 Match match(true);
7588 long __n = 2;
7589 for (long __k = 0; __k < __n; ++__k;)
7590 {
7591 int __i = s46[__k];
7592 if (*lexer == __i)
7593 {
7594 ++lexer;
7595 }
7596 else
7597 {
7598 match.hit = false;
7599 break;
7600 }
7601 }
7602 if (match.hit)
7603 {
7604 processor->EndStartTag(span, lexer.FileName());
7605 processor->EndTag(tagName, span, lexer.FileName());
7606 }
7607 *parentMatch16 = match;
7608 }
7609 *parentMatch15 = match;
7610 if (!match.hit)
7611 {
7612 Match match(false);
7613 Match* parentMatch17 = &match;
7614 lexer.SetPos(save);
7615 {
7616 Match match(false);
7617 Match* parentMatch18 = &match;
7618 {
7619 Match match(false);
7620 Match* parentMatch19 = &match;
7621 {
7622 Match match(false);
7623 Match* parentMatch20 = &match;
7624 {
7625 long pos = lexer.GetPos();
7626 Span span = lexer.GetSpan();
7627 Match match(false);
7628 if (*lexer == 62)
7629 {
7630 ++lexer;
7631 match.hit = true;
7632 }
7633 if (match.hit)
7634 {
7635 processor->EndStartTag(span, lexer.FileName());
7636 }
7637 *parentMatch20 = match;
7638 }
7639 *parentMatch19 = match;
7640 }
7641 if (match.hit)
7642 {
7643 Match match(false);
7644 Match* parentMatch21 = &match;
7645 {
7646 Match match = XmlParser.Content(lexer, processor);
7647 *parentMatch21 = match;
7648 }
7649 *parentMatch19 = match;
7650 }
7651 *parentMatch18 = match;
7652 }
7653 if (match.hit)
7654 {
7655 Match match(false);
7656 Match* parentMatch22 = &match;
7657 {
7658 Match match = XmlParser.ETag(lexer, processor);
7659 *parentMatch22 = match;
7660 }
7661 *parentMatch18 = match;
7662 }
7663 *parentMatch17 = match;
7664 }
7665 *parentMatch15 = match;
7666 }
7667 }
7668 *parentMatch14 = match;
7669 }
7670 *parentMatch13 = match;
7671 }
7672 *parentMatch0 = match;
7673 }
7674 #if (DEBUG)
7675 if (writeToLog)
7676 {
7677 if (match.hit)
7678 {
7679 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Element");
7680 }
7681 else
7682 {
7683 System.Lex.WriteFailureToLog(lexer, u"Element");
7684 }
7685 }
7686 #endif
7687 if (!match.hit)
7688 {
7689 match.value = null;
7690 }
7691 return match;
7692 }
7693 public static Match ETag(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
7694 {
7695 #if (DEBUG)
7696 Span debugSpan;
7697 bool writeToLog = lexer.Log() != null;
7698 if (writeToLog)
7699 {
7700 debugSpan = lexer.GetSpan();
7701 System.Lex.WriteBeginRuleToLog(lexer, u"ETag");
7702 }
7703 #endif
7704 System.Lex.RuleGuard ruleGuard(lexer, 57);
7705 UniquePtr<Value<ustring>> name;
7706 Match match(false);
7707 Match* parentMatch0 = &match;
7708 {
7709 Match match(false);
7710 Match* parentMatch1 = &match;
7711 {
7712 Match match(false);
7713 Match* parentMatch2 = &match;
7714 {
7715 Match match(true);
7716 long __n = 2;
7717 for (long __k = 0; __k < __n; ++__k;)
7718 {
7719 int __i = s47[__k];
7720 if (*lexer == __i)
7721 {
7722 ++lexer;
7723 }
7724 else
7725 {
7726 match.hit = false;
7727 break;
7728 }
7729 }
7730 *parentMatch2 = match;
7731 }
7732 if (match.hit)
7733 {
7734 Match match(false);
7735 Match* parentMatch3 = &match;
7736 {
7737 Match match(false);
7738 Match* parentMatch4 = &match;
7739 {
7740 long pos = lexer.GetPos();
7741 Span span = lexer.GetSpan();
7742 Match match = XmlParser.Name(lexer);
7743 name.Reset(cast<Value<ustring>*>(match.value));
7744 if (match.hit)
7745 {
7746 processor->EndTag(name->value, span, lexer.FileName());
7747 }
7748 *parentMatch4 = match;
7749 }
7750 *parentMatch3 = match;
7751 }
7752 *parentMatch2 = match;
7753 }
7754 *parentMatch1 = match;
7755 }
7756 if (match.hit)
7757 {
7758 Match match(false);
7759 Match* parentMatch5 = &match;
7760 {
7761 Match match(true);
7762 long save = lexer.GetPos();
7763 Match* parentMatch6 = &match;
7764 {
7765 Match match = XmlParser.S(lexer);
7766 if (match.hit)
7767 {
7768 *parentMatch6 = match;
7769 }
7770 else
7771 {
7772 lexer.SetPos(save);
7773 }
7774 }
7775 *parentMatch5 = match;
7776 }
7777 *parentMatch1 = match;
7778 }
7779 *parentMatch0 = match;
7780 }
7781 if (match.hit)
7782 {
7783 Match match(false);
7784 Match* parentMatch7 = &match;
7785 {
7786 Match match(false);
7787 if (*lexer == 62)
7788 {
7789 ++lexer;
7790 match.hit = true;
7791 }
7792 *parentMatch7 = match;
7793 }
7794 *parentMatch0 = match;
7795 }
7796 #if (DEBUG)
7797 if (writeToLog)
7798 {
7799 if (match.hit)
7800 {
7801 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"ETag");
7802 }
7803 else
7804 {
7805 System.Lex.WriteFailureToLog(lexer, u"ETag");
7806 }
7807 }
7808 #endif
7809 if (!match.hit)
7810 {
7811 match.value = null;
7812 }
7813 return match;
7814 }
7815 public static Match Content(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
7816 {
7817 #if (DEBUG)
7818 Span debugSpan;
7819 bool writeToLog = lexer.Log() != null;
7820 if (writeToLog)
7821 {
7822 debugSpan = lexer.GetSpan();
7823 System.Lex.WriteBeginRuleToLog(lexer, u"Content");
7824 }
7825 #endif
7826 System.Lex.RuleGuard ruleGuard(lexer, 58);
7827 Match match(false);
7828 Match* parentMatch0 = &match;
7829 {
7830 Match match(true);
7831 long save = lexer.GetPos();
7832 Match* parentMatch1 = &match;
7833 {
7834 Match match = XmlParser.CharData(lexer, processor);
7835 if (match.hit)
7836 {
7837 *parentMatch1 = match;
7838 }
7839 else
7840 {
7841 lexer.SetPos(save);
7842 }
7843 }
7844 *parentMatch0 = match;
7845 }
7846 if (match.hit)
7847 {
7848 Match match(false);
7849 Match* parentMatch2 = &match;
7850 {
7851 Match match(true);
7852 Match* parentMatch3 = &match;
7853 {
7854 while (true)
7855 {
7856 long save = lexer.GetPos();
7857 {
7858 Match match(false);
7859 Match* parentMatch4 = &match;
7860 {
7861 Match match(false);
7862 Match* parentMatch5 = &match;
7863 {
7864 Match match(false);
7865 Match* parentMatch6 = &match;
7866 {
7867 Match match(false);
7868 Match* parentMatch7 = &match;
7869 {
7870 long save = lexer.GetPos();
7871 Match match(false);
7872 Match* parentMatch8 = &match;
7873 {
7874 long save = lexer.GetPos();
7875 Match match(false);
7876 Match* parentMatch9 = &match;
7877 {
7878 long save = lexer.GetPos();
7879 Match match(false);
7880 Match* parentMatch10 = &match;
7881 {
7882 long save = lexer.GetPos();
7883 Match match = XmlParser.Element(lexer, processor);
7884 *parentMatch10 = match;
7885 if (!match.hit)
7886 {
7887 Match match(false);
7888 Match* parentMatch11 = &match;
7889 lexer.SetPos(save);
7890 {
7891 Match match = XmlParser.Reference(lexer, processor);
7892 *parentMatch11 = match;
7893 }
7894 *parentMatch10 = match;
7895 }
7896 }
7897 *parentMatch9 = match;
7898 if (!match.hit)
7899 {
7900 Match match(false);
7901 Match* parentMatch12 = &match;
7902 lexer.SetPos(save);
7903 {
7904 Match match = XmlParser.CDSect(lexer, processor);
7905 *parentMatch12 = match;
7906 }
7907 *parentMatch9 = match;
7908 }
7909 }
7910 *parentMatch8 = match;
7911 if (!match.hit)
7912 {
7913 Match match(false);
7914 Match* parentMatch13 = &match;
7915 lexer.SetPos(save);
7916 {
7917 Match match = XmlParser.PI(lexer, processor);
7918 *parentMatch13 = match;
7919 }
7920 *parentMatch8 = match;
7921 }
7922 }
7923 *parentMatch7 = match;
7924 if (!match.hit)
7925 {
7926 Match match(false);
7927 Match* parentMatch14 = &match;
7928 lexer.SetPos(save);
7929 {
7930 Match match = XmlParser.Comment(lexer, processor);
7931 *parentMatch14 = match;
7932 }
7933 *parentMatch7 = match;
7934 }
7935 }
7936 *parentMatch6 = match;
7937 }
7938 *parentMatch5 = match;
7939 }
7940 if (match.hit)
7941 {
7942 Match match(false);
7943 Match* parentMatch15 = &match;
7944 {
7945 Match match(true);
7946 long save = lexer.GetPos();
7947 Match* parentMatch16 = &match;
7948 {
7949 Match match = XmlParser.CharData(lexer, processor);
7950 if (match.hit)
7951 {
7952 *parentMatch16 = match;
7953 }
7954 else
7955 {
7956 lexer.SetPos(save);
7957 }
7958 }
7959 *parentMatch15 = match;
7960 }
7961 *parentMatch5 = match;
7962 }
7963 *parentMatch4 = match;
7964 }
7965 if (match.hit)
7966 {
7967 *parentMatch3 = match;
7968 }
7969 else
7970 {
7971 lexer.SetPos(save);
7972 break;
7973 }
7974 }
7975 }
7976 }
7977 *parentMatch2 = match;
7978 }
7979 *parentMatch0 = match;
7980 }
7981 #if (DEBUG)
7982 if (writeToLog)
7983 {
7984 if (match.hit)
7985 {
7986 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Content");
7987 }
7988 else
7989 {
7990 System.Lex.WriteFailureToLog(lexer, u"Content");
7991 }
7992 }
7993 #endif
7994 if (!match.hit)
7995 {
7996 match.value = null;
7997 }
7998 return match;
7999 }
8000 public static Match CharDataChar(TrivialLexer& lexer)
8001 {
8002 #if (DEBUG)
8003 Span debugSpan;
8004 bool writeToLog = lexer.Log() != null;
8005 if (writeToLog)
8006 {
8007 debugSpan = lexer.GetSpan();
8008 System.Lex.WriteBeginRuleToLog(lexer, u"CharDataChar");
8009 }
8010 #endif
8011 System.Lex.RuleGuard ruleGuard(lexer, 59);
8012 Match match(false);
8013 Match* parentMatch0 = &match;
8014 {
8015 long pos = lexer.GetPos();
8016 Match match(lexer.Pos() != lexer.End());
8017 for (const Range& range : s48)
8018 {
8019 if (*lexer >= range.first && *lexer <= range.last)
8020 {
8021 match.hit = false;
8022 break;
8023 }
8024 }
8025 if (match.hit)
8026 {
8027 ++lexer;
8028 }
8029 if (match.hit)
8030 {
8031 Token token = lexer.GetToken(pos);
8032 {
8033 #if (DEBUG)
8034 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"CharDataChar");
8035 #endif
8036 return Match(true, new Value<uchar>(cast<uchar>(token.id)));
8037 }
8038 }
8039 *parentMatch0 = match;
8040 }
8041 #if (DEBUG)
8042 if (writeToLog)
8043 {
8044 if (match.hit)
8045 {
8046 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"CharDataChar");
8047 }
8048 else
8049 {
8050 System.Lex.WriteFailureToLog(lexer, u"CharDataChar");
8051 }
8052 }
8053 #endif
8054 if (!match.hit)
8055 {
8056 match.value = null;
8057 }
8058 return match;
8059 }
8060 public static Match CharData(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
8061 {
8062 #if (DEBUG)
8063 Span debugSpan;
8064 bool writeToLog = lexer.Log() != null;
8065 if (writeToLog)
8066 {
8067 debugSpan = lexer.GetSpan();
8068 System.Lex.WriteBeginRuleToLog(lexer, u"CharData");
8069 }
8070 #endif
8071 System.Lex.RuleGuard ruleGuard(lexer, 60);
8072 ustring s;
8073 UniquePtr<Value<uchar>> chr;
8074 Match match(false);
8075 Match* parentMatch0 = &match;
8076 {
8077 long pos = lexer.GetPos();
8078 Match match(false);
8079 Match* parentMatch1 = &match;
8080 {
8081 Match match(false);
8082 Match* parentMatch2 = &match;
8083 long save = lexer.GetPos();
8084 {
8085 Match match(true);
8086 Match* parentMatch3 = &match;
8087 {
8088 while (true)
8089 {
8090 long save = lexer.GetPos();
8091 {
8092 Match match(false);
8093 Match* parentMatch4 = &match;
8094 {
8095 Match match(false);
8096 Match* parentMatch5 = &match;
8097 {
8098 long pos = lexer.GetPos();
8099 Match match = XmlParser.CharDataChar(lexer);
8100 chr.Reset(cast<Value<uchar>*>(match.value));
8101 if (match.hit)
8102 {
8103 s.Append(chr->value);
8104 }
8105 *parentMatch5 = match;
8106 }
8107 *parentMatch4 = match;
8108 }
8109 if (match.hit)
8110 {
8111 *parentMatch3 = match;
8112 }
8113 else
8114 {
8115 lexer.SetPos(save);
8116 break;
8117 }
8118 }
8119 }
8120 }
8121 *parentMatch2 = match;
8122 }
8123 if (match.hit)
8124 {
8125 Match match(false);
8126 Match* parentMatch6 = &match;
8127 {
8128 long tmp = lexer.GetPos();
8129 lexer.SetPos(save);
8130 save = tmp;
8131 Match match(false);
8132 Match* parentMatch7 = &match;
8133 {
8134 Match match(false);
8135 Match* parentMatch8 = &match;
8136 {
8137 Match match(false);
8138 Match* parentMatch9 = &match;
8139 {
8140 Match match(true);
8141 Match* parentMatch10 = &match;
8142 {
8143 while (true)
8144 {
8145 long save = lexer.GetPos();
8146 {
8147 Match match(lexer.Pos() != lexer.End());
8148 for (const Range& range : s49)
8149 {
8150 if (*lexer >= range.first && *lexer <= range.last)
8151 {
8152 match.hit = false;
8153 break;
8154 }
8155 }
8156 if (match.hit)
8157 {
8158 ++lexer;
8159 }
8160 if (match.hit)
8161 {
8162 *parentMatch10 = match;
8163 }
8164 else
8165 {
8166 lexer.SetPos(save);
8167 break;
8168 }
8169 }
8170 }
8171 }
8172 *parentMatch9 = match;
8173 }
8174 if (match.hit)
8175 {
8176 Match match(false);
8177 Match* parentMatch11 = &match;
8178 {
8179 Match match(true);
8180 long __n = 3;
8181 for (long __k = 0; __k < __n; ++__k;)
8182 {
8183 int __i = s50[__k];
8184 if (*lexer == __i)
8185 {
8186 ++lexer;
8187 }
8188 else
8189 {
8190 match.hit = false;
8191 break;
8192 }
8193 }
8194 *parentMatch11 = match;
8195 }
8196 *parentMatch9 = match;
8197 }
8198 *parentMatch8 = match;
8199 }
8200 if (match.hit)
8201 {
8202 Match match(false);
8203 Match* parentMatch12 = &match;
8204 {
8205 Match match(true);
8206 Match* parentMatch13 = &match;
8207 {
8208 while (true)
8209 {
8210 long save = lexer.GetPos();
8211 {
8212 Match match(lexer.Pos() != lexer.End());
8213 for (const Range& range : s51)
8214 {
8215 if (*lexer >= range.first && *lexer <= range.last)
8216 {
8217 match.hit = false;
8218 break;
8219 }
8220 }
8221 if (match.hit)
8222 {
8223 ++lexer;
8224 }
8225 if (match.hit)
8226 {
8227 *parentMatch13 = match;
8228 }
8229 else
8230 {
8231 lexer.SetPos(save);
8232 break;
8233 }
8234 }
8235 }
8236 }
8237 *parentMatch12 = match;
8238 }
8239 *parentMatch8 = match;
8240 }
8241 *parentMatch7 = match;
8242 }
8243 *parentMatch6 = match;
8244 }
8245 if (!match.hit)
8246 {
8247 lexer.SetPos(save);
8248 }
8249 *parentMatch2 = Match(!match.hit, match.value);
8250 }
8251 *parentMatch1 = match;
8252 }
8253 if (match.hit)
8254 {
8255 processor->Text(s);
8256 }
8257 *parentMatch0 = match;
8258 }
8259 #if (DEBUG)
8260 if (writeToLog)
8261 {
8262 if (match.hit)
8263 {
8264 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"CharData");
8265 }
8266 else
8267 {
8268 System.Lex.WriteFailureToLog(lexer, u"CharData");
8269 }
8270 }
8271 #endif
8272 if (!match.hit)
8273 {
8274 match.value = null;
8275 }
8276 return match;
8277 }
8278 public static Match CDSect(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
8279 {
8280 #if (DEBUG)
8281 Span debugSpan;
8282 bool writeToLog = lexer.Log() != null;
8283 if (writeToLog)
8284 {
8285 debugSpan = lexer.GetSpan();
8286 System.Lex.WriteBeginRuleToLog(lexer, u"CDSect");
8287 }
8288 #endif
8289 System.Lex.RuleGuard ruleGuard(lexer, 61);
8290 ustring s;
8291 UniquePtr<Value<uchar>> chr;
8292 Match match(false);
8293 Match* parentMatch0 = &match;
8294 {
8295 long pos = lexer.GetPos();
8296 Match match(false);
8297 Match* parentMatch1 = &match;
8298 {
8299 Match match(false);
8300 Match* parentMatch2 = &match;
8301 {
8302 Match match(false);
8303 Match* parentMatch3 = &match;
8304 {
8305 Match match(true);
8306 long __n = 9;
8307 for (long __k = 0; __k < __n; ++__k;)
8308 {
8309 int __i = s52[__k];
8310 if (*lexer == __i)
8311 {
8312 ++lexer;
8313 }
8314 else
8315 {
8316 match.hit = false;
8317 break;
8318 }
8319 }
8320 *parentMatch3 = match;
8321 }
8322 if (match.hit)
8323 {
8324 Match match(false);
8325 Match* parentMatch4 = &match;
8326 {
8327 Match match(true);
8328 Match* parentMatch5 = &match;
8329 {
8330 while (true)
8331 {
8332 long save = lexer.GetPos();
8333 {
8334 Match match(false);
8335 Match* parentMatch6 = &match;
8336 {
8337 Match match(false);
8338 Match* parentMatch7 = &match;
8339 {
8340 long pos = lexer.GetPos();
8341 Match match(false);
8342 Match* parentMatch8 = &match;
8343 {
8344 Match match(false);
8345 Match* parentMatch9 = &match;
8346 long save = lexer.GetPos();
8347 {
8348 Match match = XmlParser.Char(lexer);
8349 chr.Reset(cast<Value<uchar>*>(match.value));
8350 *parentMatch9 = match;
8351 }
8352 if (match.hit)
8353 {
8354 Match match(false);
8355 Match* parentMatch10 = &match;
8356 {
8357 long tmp = lexer.GetPos();
8358 lexer.SetPos(save);
8359 save = tmp;
8360 Match match(true);
8361 long __n = 3;
8362 for (long __k = 0; __k < __n; ++__k;)
8363 {
8364 int __i = s53[__k];
8365 if (*lexer == __i)
8366 {
8367 ++lexer;
8368 }
8369 else
8370 {
8371 match.hit = false;
8372 break;
8373 }
8374 }
8375 *parentMatch10 = match;
8376 }
8377 if (!match.hit)
8378 {
8379 lexer.SetPos(save);
8380 }
8381 *parentMatch9 = Match(!match.hit, match.value);
8382 }
8383 *parentMatch8 = match;
8384 }
8385 if (match.hit)
8386 {
8387 s.Append(chr->value);
8388 }
8389 *parentMatch7 = match;
8390 }
8391 *parentMatch6 = match;
8392 }
8393 if (match.hit)
8394 {
8395 *parentMatch5 = match;
8396 }
8397 else
8398 {
8399 lexer.SetPos(save);
8400 break;
8401 }
8402 }
8403 }
8404 }
8405 *parentMatch4 = match;
8406 }
8407 *parentMatch3 = match;
8408 }
8409 *parentMatch2 = match;
8410 }
8411 if (match.hit)
8412 {
8413 Match match(false);
8414 Match* parentMatch11 = &match;
8415 {
8416 Match match(true);
8417 long __n = 3;
8418 for (long __k = 0; __k < __n; ++__k;)
8419 {
8420 int __i = s54[__k];
8421 if (*lexer == __i)
8422 {
8423 ++lexer;
8424 }
8425 else
8426 {
8427 match.hit = false;
8428 break;
8429 }
8430 }
8431 *parentMatch11 = match;
8432 }
8433 *parentMatch2 = match;
8434 }
8435 *parentMatch1 = match;
8436 }
8437 if (match.hit)
8438 {
8439 processor->CDataSection(s);
8440 }
8441 *parentMatch0 = match;
8442 }
8443 #if (DEBUG)
8444 if (writeToLog)
8445 {
8446 if (match.hit)
8447 {
8448 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"CDSect");
8449 }
8450 else
8451 {
8452 System.Lex.WriteFailureToLog(lexer, u"CDSect");
8453 }
8454 }
8455 #endif
8456 if (!match.hit)
8457 {
8458 match.value = null;
8459 }
8460 return match;
8461 }
8462 public static Match Attribute(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
8463 {
8464 #if (DEBUG)
8465 Span debugSpan;
8466 bool writeToLog = lexer.Log() != null;
8467 if (writeToLog)
8468 {
8469 debugSpan = lexer.GetSpan();
8470 System.Lex.WriteBeginRuleToLog(lexer, u"Attribute");
8471 }
8472 #endif
8473 System.Lex.RuleGuard ruleGuard(lexer, 62);
8474 UniquePtr<Value<ustring>> attName;
8475 UniquePtr<Value<ustring>> attValue;
8476 Match match(false);
8477 Match* parentMatch0 = &match;
8478 {
8479 Match match(false);
8480 Match* parentMatch1 = &match;
8481 {
8482 Match match = XmlParser.Name(lexer);
8483 attName.Reset(cast<Value<ustring>*>(match.value));
8484 *parentMatch1 = match;
8485 }
8486 if (match.hit)
8487 {
8488 Match match(false);
8489 Match* parentMatch2 = &match;
8490 {
8491 Match match = XmlParser.Eq(lexer);
8492 *parentMatch2 = match;
8493 }
8494 *parentMatch1 = match;
8495 }
8496 *parentMatch0 = match;
8497 }
8498 if (match.hit)
8499 {
8500 Match match(false);
8501 Match* parentMatch3 = &match;
8502 {
8503 Match match(false);
8504 Match* parentMatch4 = &match;
8505 {
8506 long pos = lexer.GetPos();
8507 Span span = lexer.GetSpan();
8508 Match match = XmlParser.AttValue(lexer, processor);
8509 attValue.Reset(cast<Value<ustring>*>(match.value));
8510 if (match.hit)
8511 {
8512 processor->AddAttribute(attName->value, attValue->value, span, lexer.FileName());
8513 }
8514 *parentMatch4 = match;
8515 }
8516 *parentMatch3 = match;
8517 }
8518 *parentMatch0 = match;
8519 }
8520 #if (DEBUG)
8521 if (writeToLog)
8522 {
8523 if (match.hit)
8524 {
8525 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Attribute");
8526 }
8527 else
8528 {
8529 System.Lex.WriteFailureToLog(lexer, u"Attribute");
8530 }
8531 }
8532 #endif
8533 if (!match.hit)
8534 {
8535 match.value = null;
8536 }
8537 return match;
8538 }
8539 public static Match AttValueDQ(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
8540 {
8541 #if (DEBUG)
8542 Span debugSpan;
8543 bool writeToLog = lexer.Log() != null;
8544 if (writeToLog)
8545 {
8546 debugSpan = lexer.GetSpan();
8547 System.Lex.WriteBeginRuleToLog(lexer, u"AttValueDQ");
8548 }
8549 #endif
8550 System.Lex.RuleGuard ruleGuard(lexer, 63);
8551 Match match(false);
8552 Match* parentMatch0 = &match;
8553 {
8554 Match match(false);
8555 Match* parentMatch1 = &match;
8556 {
8557 Match match(false);
8558 Match* parentMatch2 = &match;
8559 {
8560 long pos = lexer.GetPos();
8561 Match match(false);
8562 if (*lexer == 34)
8563 {
8564 ++lexer;
8565 match.hit = true;
8566 }
8567 if (match.hit)
8568 {
8569 processor->BeginAttributeValue();
8570 }
8571 *parentMatch2 = match;
8572 }
8573 *parentMatch1 = match;
8574 }
8575 if (match.hit)
8576 {
8577 Match match(false);
8578 Match* parentMatch3 = &match;
8579 {
8580 Match match(true);
8581 Match* parentMatch4 = &match;
8582 {
8583 while (true)
8584 {
8585 long save = lexer.GetPos();
8586 {
8587 Match match(false);
8588 Match* parentMatch5 = &match;
8589 {
8590 Match match(false);
8591 Match* parentMatch6 = &match;
8592 {
8593 long save = lexer.GetPos();
8594 Match match(false);
8595 Match* parentMatch7 = &match;
8596 {
8597 long pos = lexer.GetPos();
8598 Span span = lexer.GetSpan();
8599 Match match(lexer.Pos() != lexer.End());
8600 for (const Range& range : s55)
8601 {
8602 if (*lexer >= range.first && *lexer <= range.last)
8603 {
8604 match.hit = false;
8605 break;
8606 }
8607 }
8608 if (match.hit)
8609 {
8610 ++lexer;
8611 }
8612 if (match.hit)
8613 {
8614 processor->AttValue().Append(lexer.GetMatch(span));
8615 }
8616 *parentMatch7 = match;
8617 }
8618 *parentMatch6 = match;
8619 if (!match.hit)
8620 {
8621 Match match(false);
8622 Match* parentMatch8 = &match;
8623 lexer.SetPos(save);
8624 {
8625 Match match = XmlParser.Reference(lexer, processor);
8626 *parentMatch8 = match;
8627 }
8628 *parentMatch6 = match;
8629 }
8630 }
8631 *parentMatch5 = match;
8632 }
8633 if (match.hit)
8634 {
8635 *parentMatch4 = match;
8636 }
8637 else
8638 {
8639 lexer.SetPos(save);
8640 break;
8641 }
8642 }
8643 }
8644 }
8645 *parentMatch3 = match;
8646 }
8647 *parentMatch1 = match;
8648 }
8649 *parentMatch0 = match;
8650 }
8651 if (match.hit)
8652 {
8653 Match match(false);
8654 Match* parentMatch9 = &match;
8655 {
8656 Match match(false);
8657 Match* parentMatch10 = &match;
8658 {
8659 long pos = lexer.GetPos();
8660 Match match(false);
8661 if (*lexer == 34)
8662 {
8663 ++lexer;
8664 match.hit = true;
8665 }
8666 if (match.hit)
8667 {
8668 ustring value = processor->AttValue();
8669 processor->EndAttributeValue();
8670 {
8671 #if (DEBUG)
8672 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"AttValueDQ");
8673 #endif
8674 return Match(true, new Value<ustring>(value));
8675 }
8676 }
8677 *parentMatch10 = match;
8678 }
8679 *parentMatch9 = match;
8680 }
8681 *parentMatch0 = match;
8682 }
8683 #if (DEBUG)
8684 if (writeToLog)
8685 {
8686 if (match.hit)
8687 {
8688 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"AttValueDQ");
8689 }
8690 else
8691 {
8692 System.Lex.WriteFailureToLog(lexer, u"AttValueDQ");
8693 }
8694 }
8695 #endif
8696 if (!match.hit)
8697 {
8698 match.value = null;
8699 }
8700 return match;
8701 }
8702 public static Match AttValueSQ(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
8703 {
8704 #if (DEBUG)
8705 Span debugSpan;
8706 bool writeToLog = lexer.Log() != null;
8707 if (writeToLog)
8708 {
8709 debugSpan = lexer.GetSpan();
8710 System.Lex.WriteBeginRuleToLog(lexer, u"AttValueSQ");
8711 }
8712 #endif
8713 System.Lex.RuleGuard ruleGuard(lexer, 64);
8714 Match match(false);
8715 Match* parentMatch0 = &match;
8716 {
8717 Match match(false);
8718 Match* parentMatch1 = &match;
8719 {
8720 Match match(false);
8721 Match* parentMatch2 = &match;
8722 {
8723 long pos = lexer.GetPos();
8724 Match match(false);
8725 if (*lexer == 39)
8726 {
8727 ++lexer;
8728 match.hit = true;
8729 }
8730 if (match.hit)
8731 {
8732 processor->BeginAttributeValue();
8733 }
8734 *parentMatch2 = match;
8735 }
8736 *parentMatch1 = match;
8737 }
8738 if (match.hit)
8739 {
8740 Match match(false);
8741 Match* parentMatch3 = &match;
8742 {
8743 Match match(true);
8744 Match* parentMatch4 = &match;
8745 {
8746 while (true)
8747 {
8748 long save = lexer.GetPos();
8749 {
8750 Match match(false);
8751 Match* parentMatch5 = &match;
8752 {
8753 Match match(false);
8754 Match* parentMatch6 = &match;
8755 {
8756 long save = lexer.GetPos();
8757 Match match(false);
8758 Match* parentMatch7 = &match;
8759 {
8760 long pos = lexer.GetPos();
8761 Span span = lexer.GetSpan();
8762 Match match(lexer.Pos() != lexer.End());
8763 for (const Range& range : s56)
8764 {
8765 if (*lexer >= range.first && *lexer <= range.last)
8766 {
8767 match.hit = false;
8768 break;
8769 }
8770 }
8771 if (match.hit)
8772 {
8773 ++lexer;
8774 }
8775 if (match.hit)
8776 {
8777 processor->AttValue().Append(lexer.GetMatch(span));
8778 }
8779 *parentMatch7 = match;
8780 }
8781 *parentMatch6 = match;
8782 if (!match.hit)
8783 {
8784 Match match(false);
8785 Match* parentMatch8 = &match;
8786 lexer.SetPos(save);
8787 {
8788 Match match = XmlParser.Reference(lexer, processor);
8789 *parentMatch8 = match;
8790 }
8791 *parentMatch6 = match;
8792 }
8793 }
8794 *parentMatch5 = match;
8795 }
8796 if (match.hit)
8797 {
8798 *parentMatch4 = match;
8799 }
8800 else
8801 {
8802 lexer.SetPos(save);
8803 break;
8804 }
8805 }
8806 }
8807 }
8808 *parentMatch3 = match;
8809 }
8810 *parentMatch1 = match;
8811 }
8812 *parentMatch0 = match;
8813 }
8814 if (match.hit)
8815 {
8816 Match match(false);
8817 Match* parentMatch9 = &match;
8818 {
8819 Match match(false);
8820 Match* parentMatch10 = &match;
8821 {
8822 long pos = lexer.GetPos();
8823 Match match(false);
8824 if (*lexer == 39)
8825 {
8826 ++lexer;
8827 match.hit = true;
8828 }
8829 if (match.hit)
8830 {
8831 ustring value = processor->AttValue();
8832 processor->EndAttributeValue();
8833 {
8834 #if (DEBUG)
8835 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"AttValueSQ");
8836 #endif
8837 return Match(true, new Value<ustring>(value));
8838 }
8839 }
8840 *parentMatch10 = match;
8841 }
8842 *parentMatch9 = match;
8843 }
8844 *parentMatch0 = match;
8845 }
8846 #if (DEBUG)
8847 if (writeToLog)
8848 {
8849 if (match.hit)
8850 {
8851 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"AttValueSQ");
8852 }
8853 else
8854 {
8855 System.Lex.WriteFailureToLog(lexer, u"AttValueSQ");
8856 }
8857 }
8858 #endif
8859 if (!match.hit)
8860 {
8861 match.value = null;
8862 }
8863 return match;
8864 }
8865 public static Match AttValue(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
8866 {
8867 #if (DEBUG)
8868 Span debugSpan;
8869 bool writeToLog = lexer.Log() != null;
8870 if (writeToLog)
8871 {
8872 debugSpan = lexer.GetSpan();
8873 System.Lex.WriteBeginRuleToLog(lexer, u"AttValue");
8874 }
8875 #endif
8876 System.Lex.RuleGuard ruleGuard(lexer, 65);
8877 UniquePtr<Value<ustring>> attValueDQ;
8878 UniquePtr<Value<ustring>> attValueSQ;
8879 Match match(false);
8880 Match* parentMatch0 = &match;
8881 {
8882 long save = lexer.GetPos();
8883 Match match(false);
8884 Match* parentMatch1 = &match;
8885 {
8886 long pos = lexer.GetPos();
8887 Match match = XmlParser.AttValueDQ(lexer, processor);
8888 attValueDQ.Reset(cast<Value<ustring>*>(match.value));
8889 if (match.hit)
8890 {
8891 {
8892 #if (DEBUG)
8893 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"AttValue");
8894 #endif
8895 return Match(true, new Value<ustring>(attValueDQ->value));
8896 }
8897 }
8898 *parentMatch1 = match;
8899 }
8900 *parentMatch0 = match;
8901 if (!match.hit)
8902 {
8903 Match match(false);
8904 Match* parentMatch2 = &match;
8905 lexer.SetPos(save);
8906 {
8907 Match match(false);
8908 Match* parentMatch3 = &match;
8909 {
8910 long pos = lexer.GetPos();
8911 Match match = XmlParser.AttValueSQ(lexer, processor);
8912 attValueSQ.Reset(cast<Value<ustring>*>(match.value));
8913 if (match.hit)
8914 {
8915 {
8916 #if (DEBUG)
8917 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"AttValue");
8918 #endif
8919 return Match(true, new Value<ustring>(attValueSQ->value));
8920 }
8921 }
8922 *parentMatch3 = match;
8923 }
8924 *parentMatch2 = match;
8925 }
8926 *parentMatch0 = match;
8927 }
8928 }
8929 #if (DEBUG)
8930 if (writeToLog)
8931 {
8932 if (match.hit)
8933 {
8934 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"AttValue");
8935 }
8936 else
8937 {
8938 System.Lex.WriteFailureToLog(lexer, u"AttValue");
8939 }
8940 }
8941 #endif
8942 if (!match.hit)
8943 {
8944 match.value = null;
8945 }
8946 return match;
8947 }
8948 public static Match EntityRef(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
8949 {
8950 #if (DEBUG)
8951 Span debugSpan;
8952 bool writeToLog = lexer.Log() != null;
8953 if (writeToLog)
8954 {
8955 debugSpan = lexer.GetSpan();
8956 System.Lex.WriteBeginRuleToLog(lexer, u"EntityRef");
8957 }
8958 #endif
8959 System.Lex.RuleGuard ruleGuard(lexer, 66);
8960 UniquePtr<Value<ustring>> name;
8961 Match match(false);
8962 Match* parentMatch0 = &match;
8963 {
8964 long pos = lexer.GetPos();
8965 Span span = lexer.GetSpan();
8966 Match match(false);
8967 Match* parentMatch1 = &match;
8968 {
8969 Match match(false);
8970 Match* parentMatch2 = &match;
8971 {
8972 Match match(false);
8973 Match* parentMatch3 = &match;
8974 {
8975 Match match(false);
8976 if (*lexer == 38)
8977 {
8978 ++lexer;
8979 match.hit = true;
8980 }
8981 *parentMatch3 = match;
8982 }
8983 if (match.hit)
8984 {
8985 Match match(false);
8986 Match* parentMatch4 = &match;
8987 {
8988 Match match = XmlParser.Name(lexer);
8989 name.Reset(cast<Value<ustring>*>(match.value));
8990 *parentMatch4 = match;
8991 }
8992 *parentMatch3 = match;
8993 }
8994 *parentMatch2 = match;
8995 }
8996 if (match.hit)
8997 {
8998 Match match(false);
8999 Match* parentMatch5 = &match;
9000 {
9001 Match match(false);
9002 if (*lexer == 59)
9003 {
9004 ++lexer;
9005 match.hit = true;
9006 }
9007 *parentMatch5 = match;
9008 }
9009 *parentMatch2 = match;
9010 }
9011 *parentMatch1 = match;
9012 }
9013 if (match.hit)
9014 {
9015 processor->EntityRef(name->value, span, lexer.FileName());
9016 }
9017 *parentMatch0 = match;
9018 }
9019 #if (DEBUG)
9020 if (writeToLog)
9021 {
9022 if (match.hit)
9023 {
9024 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"EntityRef");
9025 }
9026 else
9027 {
9028 System.Lex.WriteFailureToLog(lexer, u"EntityRef");
9029 }
9030 }
9031 #endif
9032 if (!match.hit)
9033 {
9034 match.value = null;
9035 }
9036 return match;
9037 }
9038 public static Match DecCodePoint(TrivialLexer& lexer)
9039 {
9040 #if (DEBUG)
9041 Span debugSpan;
9042 bool writeToLog = lexer.Log() != null;
9043 if (writeToLog)
9044 {
9045 debugSpan = lexer.GetSpan();
9046 System.Lex.WriteBeginRuleToLog(lexer, u"DecCodePoint");
9047 }
9048 #endif
9049 System.Lex.RuleGuard ruleGuard(lexer, 67);
9050 uint val;
9051 Match match(false);
9052 Match* parentMatch0 = &match;
9053 {
9054 long pos = lexer.GetPos();
9055 Match match(false);
9056 Match* parentMatch1 = &match;
9057 {
9058 Match match(false);
9059 Match* parentMatch2 = &match;
9060 {
9061 Match match(false);
9062 Match* parentMatch3 = &match;
9063 {
9064 Match match(false);
9065 Match* parentMatch4 = &match;
9066 {
9067 long pos = lexer.GetPos();
9068 Match match(false);
9069 for (const Range& range : s57)
9070 {
9071 if (*lexer >= range.first && *lexer <= range.last)
9072 {
9073 match.hit = true;
9074 ++lexer;
9075 break;
9076 }
9077 }
9078 if (match.hit)
9079 {
9080 Token token = lexer.GetToken(pos);
9081 val = 10u * val + cast<uint>(token.id) - cast<uint>('0');
9082 }
9083 *parentMatch4 = match;
9084 }
9085 *parentMatch3 = match;
9086 }
9087 *parentMatch2 = match;
9088 }
9089 if (match.hit)
9090 {
9091 Match match(true);
9092 Match* parentMatch5 = &match;
9093 while (true)
9094 {
9095 long save = lexer.GetPos();
9096 {
9097 Match match(false);
9098 Match* parentMatch6 = &match;
9099 {
9100 Match match(false);
9101 Match* parentMatch7 = &match;
9102 {
9103 long pos = lexer.GetPos();
9104 Match match(false);
9105 for (const Range& range : s57)
9106 {
9107 if (*lexer >= range.first && *lexer <= range.last)
9108 {
9109 match.hit = true;
9110 ++lexer;
9111 break;
9112 }
9113 }
9114 if (match.hit)
9115 {
9116 Token token = lexer.GetToken(pos);
9117 val = 10u * val + cast<uint>(token.id) - cast<uint>('0');
9118 }
9119 *parentMatch7 = match;
9120 }
9121 *parentMatch6 = match;
9122 }
9123 if (match.hit)
9124 {
9125 *parentMatch5 = match;
9126 }
9127 else
9128 {
9129 lexer.SetPos(save);
9130 break;
9131 }
9132 }
9133 }
9134 }
9135 *parentMatch1 = match;
9136 }
9137 if (match.hit)
9138 {
9139 {
9140 #if (DEBUG)
9141 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"DecCodePoint");
9142 #endif
9143 return Match(true, new Value<uint>(val));
9144 }
9145 }
9146 *parentMatch0 = match;
9147 }
9148 #if (DEBUG)
9149 if (writeToLog)
9150 {
9151 if (match.hit)
9152 {
9153 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"DecCodePoint");
9154 }
9155 else
9156 {
9157 System.Lex.WriteFailureToLog(lexer, u"DecCodePoint");
9158 }
9159 }
9160 #endif
9161 if (!match.hit)
9162 {
9163 match.value = null;
9164 }
9165 return match;
9166 }
9167 public static Match HexCodePoint(TrivialLexer& lexer)
9168 {
9169 #if (DEBUG)
9170 Span debugSpan;
9171 bool writeToLog = lexer.Log() != null;
9172 if (writeToLog)
9173 {
9174 debugSpan = lexer.GetSpan();
9175 System.Lex.WriteBeginRuleToLog(lexer, u"HexCodePoint");
9176 }
9177 #endif
9178 System.Lex.RuleGuard ruleGuard(lexer, 68);
9179 uint val;
9180 Match match(false);
9181 Match* parentMatch0 = &match;
9182 {
9183 long pos = lexer.GetPos();
9184 Match match(false);
9185 Match* parentMatch1 = &match;
9186 {
9187 Match match(false);
9188 Match* parentMatch2 = &match;
9189 {
9190 Match match(false);
9191 Match* parentMatch3 = &match;
9192 {
9193 Match match(false);
9194 Match* parentMatch4 = &match;
9195 {
9196 long pos = lexer.GetPos();
9197 Match match(false);
9198 for (const Range& range : s58)
9199 {
9200 if (*lexer >= range.first && *lexer <= range.last)
9201 {
9202 match.hit = true;
9203 ++lexer;
9204 break;
9205 }
9206 }
9207 if (match.hit)
9208 {
9209 Token token = lexer.GetToken(pos);
9210 if (token.id >= cast<int>('0') && token.id <= cast<int>('9')) val = 16u * val + cast<uint>(token.id) - cast<uint>('0');
9211 else if (token.id >= cast<int>('a') && token.id <= cast<int>('f')) val = 16u * val + 10u + cast<uint>(token.id) - cast<uint>('a');
9212 else if (token.id >= cast<int>('A') && token.id <= cast<int>('F')) val = 16u * val + 10u + cast<uint>(token.id) - cast<uint>('A');
9213 }
9214 *parentMatch4 = match;
9215 }
9216 *parentMatch3 = match;
9217 }
9218 *parentMatch2 = match;
9219 }
9220 if (match.hit)
9221 {
9222 Match match(true);
9223 Match* parentMatch5 = &match;
9224 while (true)
9225 {
9226 long save = lexer.GetPos();
9227 {
9228 Match match(false);
9229 Match* parentMatch6 = &match;
9230 {
9231 Match match(false);
9232 Match* parentMatch7 = &match;
9233 {
9234 long pos = lexer.GetPos();
9235 Match match(false);
9236 for (const Range& range : s58)
9237 {
9238 if (*lexer >= range.first && *lexer <= range.last)
9239 {
9240 match.hit = true;
9241 ++lexer;
9242 break;
9243 }
9244 }
9245 if (match.hit)
9246 {
9247 Token token = lexer.GetToken(pos);
9248 if (token.id >= cast<int>('0') && token.id <= cast<int>('9')) val = 16u * val + cast<uint>(token.id) - cast<uint>('0');
9249 else if (token.id >= cast<int>('a') && token.id <= cast<int>('f')) val = 16u * val + 10u + cast<uint>(token.id) - cast<uint>('a');
9250 else if (token.id >= cast<int>('A') && token.id <= cast<int>('F')) val = 16u * val + 10u + cast<uint>(token.id) - cast<uint>('A');
9251 }
9252 *parentMatch7 = match;
9253 }
9254 *parentMatch6 = match;
9255 }
9256 if (match.hit)
9257 {
9258 *parentMatch5 = match;
9259 }
9260 else
9261 {
9262 lexer.SetPos(save);
9263 break;
9264 }
9265 }
9266 }
9267 }
9268 *parentMatch1 = match;
9269 }
9270 if (match.hit)
9271 {
9272 {
9273 #if (DEBUG)
9274 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"HexCodePoint");
9275 #endif
9276 return Match(true, new Value<uint>(val));
9277 }
9278 }
9279 *parentMatch0 = match;
9280 }
9281 #if (DEBUG)
9282 if (writeToLog)
9283 {
9284 if (match.hit)
9285 {
9286 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"HexCodePoint");
9287 }
9288 else
9289 {
9290 System.Lex.WriteFailureToLog(lexer, u"HexCodePoint");
9291 }
9292 }
9293 #endif
9294 if (!match.hit)
9295 {
9296 match.value = null;
9297 }
9298 return match;
9299 }
9300 public static Match CharRef(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
9301 {
9302 #if (DEBUG)
9303 Span debugSpan;
9304 bool writeToLog = lexer.Log() != null;
9305 if (writeToLog)
9306 {
9307 debugSpan = lexer.GetSpan();
9308 System.Lex.WriteBeginRuleToLog(lexer, u"CharRef");
9309 }
9310 #endif
9311 System.Lex.RuleGuard ruleGuard(lexer, 69);
9312 UniquePtr<Value<uint>> decCodePoint;
9313 UniquePtr<Value<uint>> hexCodePoint;
9314 Match match(false);
9315 Match* parentMatch0 = &match;
9316 {
9317 long save = lexer.GetPos();
9318 Match match(false);
9319 Match* parentMatch1 = &match;
9320 {
9321 long pos = lexer.GetPos();
9322 Match match(false);
9323 Match* parentMatch2 = &match;
9324 {
9325 Match match(false);
9326 Match* parentMatch3 = &match;
9327 {
9328 Match match(false);
9329 Match* parentMatch4 = &match;
9330 {
9331 Match match(true);
9332 long __n = 2;
9333 for (long __k = 0; __k < __n; ++__k;)
9334 {
9335 int __i = s59[__k];
9336 if (*lexer == __i)
9337 {
9338 ++lexer;
9339 }
9340 else
9341 {
9342 match.hit = false;
9343 break;
9344 }
9345 }
9346 *parentMatch4 = match;
9347 }
9348 if (match.hit)
9349 {
9350 Match match(false);
9351 Match* parentMatch5 = &match;
9352 {
9353 Match match = XmlParser.DecCodePoint(lexer);
9354 decCodePoint.Reset(cast<Value<uint>*>(match.value));
9355 *parentMatch5 = match;
9356 }
9357 *parentMatch4 = match;
9358 }
9359 *parentMatch3 = match;
9360 }
9361 if (match.hit)
9362 {
9363 Match match(false);
9364 Match* parentMatch6 = &match;
9365 {
9366 Match match(false);
9367 if (*lexer == 59)
9368 {
9369 ++lexer;
9370 match.hit = true;
9371 }
9372 *parentMatch6 = match;
9373 }
9374 *parentMatch3 = match;
9375 }
9376 *parentMatch2 = match;
9377 }
9378 if (match.hit)
9379 {
9380 processor->Text(ustring(cast<uchar>(decCodePoint->value)));
9381 }
9382 *parentMatch1 = match;
9383 }
9384 *parentMatch0 = match;
9385 if (!match.hit)
9386 {
9387 Match match(false);
9388 Match* parentMatch7 = &match;
9389 lexer.SetPos(save);
9390 {
9391 Match match(false);
9392 Match* parentMatch8 = &match;
9393 {
9394 long pos = lexer.GetPos();
9395 Match match(false);
9396 Match* parentMatch9 = &match;
9397 {
9398 Match match(false);
9399 Match* parentMatch10 = &match;
9400 {
9401 Match match(false);
9402 Match* parentMatch11 = &match;
9403 {
9404 Match match(true);
9405 long __n = 3;
9406 for (long __k = 0; __k < __n; ++__k;)
9407 {
9408 int __i = s60[__k];
9409 if (*lexer == __i)
9410 {
9411 ++lexer;
9412 }
9413 else
9414 {
9415 match.hit = false;
9416 break;
9417 }
9418 }
9419 *parentMatch11 = match;
9420 }
9421 if (match.hit)
9422 {
9423 Match match(false);
9424 Match* parentMatch12 = &match;
9425 {
9426 Match match = XmlParser.HexCodePoint(lexer);
9427 hexCodePoint.Reset(cast<Value<uint>*>(match.value));
9428 *parentMatch12 = match;
9429 }
9430 *parentMatch11 = match;
9431 }
9432 *parentMatch10 = match;
9433 }
9434 if (match.hit)
9435 {
9436 Match match(false);
9437 Match* parentMatch13 = &match;
9438 {
9439 Match match(false);
9440 if (*lexer == 59)
9441 {
9442 ++lexer;
9443 match.hit = true;
9444 }
9445 *parentMatch13 = match;
9446 }
9447 *parentMatch10 = match;
9448 }
9449 *parentMatch9 = match;
9450 }
9451 if (match.hit)
9452 {
9453 processor->Text(ustring(cast<uchar>(hexCodePoint->value)));
9454 }
9455 *parentMatch8 = match;
9456 }
9457 *parentMatch7 = match;
9458 }
9459 *parentMatch0 = match;
9460 }
9461 }
9462 #if (DEBUG)
9463 if (writeToLog)
9464 {
9465 if (match.hit)
9466 {
9467 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"CharRef");
9468 }
9469 else
9470 {
9471 System.Lex.WriteFailureToLog(lexer, u"CharRef");
9472 }
9473 }
9474 #endif
9475 if (!match.hit)
9476 {
9477 match.value = null;
9478 }
9479 return match;
9480 }
9481 public static Match Reference(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
9482 {
9483 #if (DEBUG)
9484 Span debugSpan;
9485 bool writeToLog = lexer.Log() != null;
9486 if (writeToLog)
9487 {
9488 debugSpan = lexer.GetSpan();
9489 System.Lex.WriteBeginRuleToLog(lexer, u"Reference");
9490 }
9491 #endif
9492 System.Lex.RuleGuard ruleGuard(lexer, 70);
9493 Match match(false);
9494 Match* parentMatch0 = &match;
9495 {
9496 long save = lexer.GetPos();
9497 Match match = XmlParser.EntityRef(lexer, processor);
9498 *parentMatch0 = match;
9499 if (!match.hit)
9500 {
9501 Match match(false);
9502 Match* parentMatch1 = &match;
9503 lexer.SetPos(save);
9504 {
9505 Match match = XmlParser.CharRef(lexer, processor);
9506 *parentMatch1 = match;
9507 }
9508 *parentMatch0 = match;
9509 }
9510 }
9511 #if (DEBUG)
9512 if (writeToLog)
9513 {
9514 if (match.hit)
9515 {
9516 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Reference");
9517 }
9518 else
9519 {
9520 System.Lex.WriteFailureToLog(lexer, u"Reference");
9521 }
9522 }
9523 #endif
9524 if (!match.hit)
9525 {
9526 match.value = null;
9527 }
9528 return match;
9529 }
9530 public static Match Misc(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
9531 {
9532 #if (DEBUG)
9533 Span debugSpan;
9534 bool writeToLog = lexer.Log() != null;
9535 if (writeToLog)
9536 {
9537 debugSpan = lexer.GetSpan();
9538 System.Lex.WriteBeginRuleToLog(lexer, u"Misc");
9539 }
9540 #endif
9541 System.Lex.RuleGuard ruleGuard(lexer, 71);
9542 Match match(false);
9543 Match* parentMatch0 = &match;
9544 {
9545 long save = lexer.GetPos();
9546 Match match(false);
9547 Match* parentMatch1 = &match;
9548 {
9549 long save = lexer.GetPos();
9550 Match match = XmlParser.Comment(lexer, processor);
9551 *parentMatch1 = match;
9552 if (!match.hit)
9553 {
9554 Match match(false);
9555 Match* parentMatch2 = &match;
9556 lexer.SetPos(save);
9557 {
9558 Match match = XmlParser.PI(lexer, processor);
9559 *parentMatch2 = match;
9560 }
9561 *parentMatch1 = match;
9562 }
9563 }
9564 *parentMatch0 = match;
9565 if (!match.hit)
9566 {
9567 Match match(false);
9568 Match* parentMatch3 = &match;
9569 lexer.SetPos(save);
9570 {
9571 Match match = XmlParser.S(lexer);
9572 *parentMatch3 = match;
9573 }
9574 *parentMatch0 = match;
9575 }
9576 }
9577 #if (DEBUG)
9578 if (writeToLog)
9579 {
9580 if (match.hit)
9581 {
9582 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Misc");
9583 }
9584 else
9585 {
9586 System.Lex.WriteFailureToLog(lexer, u"Misc");
9587 }
9588 }
9589 #endif
9590 if (!match.hit)
9591 {
9592 match.value = null;
9593 }
9594 return match;
9595 }
9596 public static Match Comment(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
9597 {
9598 #if (DEBUG)
9599 Span debugSpan;
9600 bool writeToLog = lexer.Log() != null;
9601 if (writeToLog)
9602 {
9603 debugSpan = lexer.GetSpan();
9604 System.Lex.WriteBeginRuleToLog(lexer, u"Comment");
9605 }
9606 #endif
9607 System.Lex.RuleGuard ruleGuard(lexer, 72);
9608 ustring s;
9609 UniquePtr<Value<uchar>> chr;
9610 Match match(false);
9611 Match* parentMatch0 = &match;
9612 {
9613 long pos = lexer.GetPos();
9614 Match match(false);
9615 Match* parentMatch1 = &match;
9616 {
9617 Match match(false);
9618 Match* parentMatch2 = &match;
9619 {
9620 Match match(false);
9621 Match* parentMatch3 = &match;
9622 {
9623 Match match(true);
9624 long __n = 4;
9625 for (long __k = 0; __k < __n; ++__k;)
9626 {
9627 int __i = s61[__k];
9628 if (*lexer == __i)
9629 {
9630 ++lexer;
9631 }
9632 else
9633 {
9634 match.hit = false;
9635 break;
9636 }
9637 }
9638 *parentMatch3 = match;
9639 }
9640 if (match.hit)
9641 {
9642 Match match(false);
9643 Match* parentMatch4 = &match;
9644 {
9645 Match match(true);
9646 Match* parentMatch5 = &match;
9647 {
9648 while (true)
9649 {
9650 long save = lexer.GetPos();
9651 {
9652 Match match(false);
9653 Match* parentMatch6 = &match;
9654 {
9655 Match match(false);
9656 Match* parentMatch7 = &match;
9657 {
9658 long save = lexer.GetPos();
9659 Match match(false);
9660 Match* parentMatch8 = &match;
9661 {
9662 long pos = lexer.GetPos();
9663 Match match(false);
9664 Match* parentMatch9 = &match;
9665 {
9666 Match match(false);
9667 Match* parentMatch10 = &match;
9668 long save = lexer.GetPos();
9669 {
9670 Match match = XmlParser.Char(lexer);
9671 chr.Reset(cast<Value<uchar>*>(match.value));
9672 *parentMatch10 = match;
9673 }
9674 if (match.hit)
9675 {
9676 Match match(false);
9677 Match* parentMatch11 = &match;
9678 {
9679 long tmp = lexer.GetPos();
9680 lexer.SetPos(save);
9681 save = tmp;
9682 Match match(false);
9683 if (*lexer == 45)
9684 {
9685 ++lexer;
9686 match.hit = true;
9687 }
9688 *parentMatch11 = match;
9689 }
9690 if (!match.hit)
9691 {
9692 lexer.SetPos(save);
9693 }
9694 *parentMatch10 = Match(!match.hit, match.value);
9695 }
9696 *parentMatch9 = match;
9697 }
9698 if (match.hit)
9699 {
9700 s.Append(chr->value);
9701 }
9702 *parentMatch8 = match;
9703 }
9704 *parentMatch7 = match;
9705 if (!match.hit)
9706 {
9707 Match match(false);
9708 Match* parentMatch12 = &match;
9709 lexer.SetPos(save);
9710 {
9711 Match match(false);
9712 Match* parentMatch13 = &match;
9713 {
9714 Match match(false);
9715 if (*lexer == 45)
9716 {
9717 ++lexer;
9718 match.hit = true;
9719 }
9720 *parentMatch13 = match;
9721 }
9722 if (match.hit)
9723 {
9724 Match match(false);
9725 Match* parentMatch14 = &match;
9726 {
9727 Match match(false);
9728 Match* parentMatch15 = &match;
9729 {
9730 long pos = lexer.GetPos();
9731 Match match(false);
9732 Match* parentMatch16 = &match;
9733 {
9734 Match match(false);
9735 Match* parentMatch17 = &match;
9736 long save = lexer.GetPos();
9737 {
9738 Match match = XmlParser.Char(lexer);
9739 chr.Reset(cast<Value<uchar>*>(match.value));
9740 *parentMatch17 = match;
9741 }
9742 if (match.hit)
9743 {
9744 Match match(false);
9745 Match* parentMatch18 = &match;
9746 {
9747 long tmp = lexer.GetPos();
9748 lexer.SetPos(save);
9749 save = tmp;
9750 Match match(false);
9751 if (*lexer == 45)
9752 {
9753 ++lexer;
9754 match.hit = true;
9755 }
9756 *parentMatch18 = match;
9757 }
9758 if (!match.hit)
9759 {
9760 lexer.SetPos(save);
9761 }
9762 *parentMatch17 = Match(!match.hit, match.value);
9763 }
9764 *parentMatch16 = match;
9765 }
9766 if (match.hit)
9767 {
9768 s.Append('-').Append(chr->value);
9769 }
9770 *parentMatch15 = match;
9771 }
9772 *parentMatch14 = match;
9773 }
9774 *parentMatch13 = match;
9775 }
9776 *parentMatch12 = match;
9777 }
9778 *parentMatch7 = match;
9779 }
9780 }
9781 *parentMatch6 = match;
9782 }
9783 if (match.hit)
9784 {
9785 *parentMatch5 = match;
9786 }
9787 else
9788 {
9789 lexer.SetPos(save);
9790 break;
9791 }
9792 }
9793 }
9794 }
9795 *parentMatch4 = match;
9796 }
9797 *parentMatch3 = match;
9798 }
9799 *parentMatch2 = match;
9800 }
9801 if (match.hit)
9802 {
9803 Match match(false);
9804 Match* parentMatch19 = &match;
9805 {
9806 Match match(true);
9807 long __n = 3;
9808 for (long __k = 0; __k < __n; ++__k;)
9809 {
9810 int __i = s62[__k];
9811 if (*lexer == __i)
9812 {
9813 ++lexer;
9814 }
9815 else
9816 {
9817 match.hit = false;
9818 break;
9819 }
9820 }
9821 *parentMatch19 = match;
9822 }
9823 *parentMatch2 = match;
9824 }
9825 *parentMatch1 = match;
9826 }
9827 if (match.hit)
9828 {
9829 processor->Comment(s);
9830 }
9831 *parentMatch0 = match;
9832 }
9833 #if (DEBUG)
9834 if (writeToLog)
9835 {
9836 if (match.hit)
9837 {
9838 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Comment");
9839 }
9840 else
9841 {
9842 System.Lex.WriteFailureToLog(lexer, u"Comment");
9843 }
9844 }
9845 #endif
9846 if (!match.hit)
9847 {
9848 match.value = null;
9849 }
9850 return match;
9851 }
9852 public static Match PI(TrivialLexer& lexer, System.Xml.XmlProcessor* processor)
9853 {
9854 #if (DEBUG)
9855 Span debugSpan;
9856 bool writeToLog = lexer.Log() != null;
9857 if (writeToLog)
9858 {
9859 debugSpan = lexer.GetSpan();
9860 System.Lex.WriteBeginRuleToLog(lexer, u"PI");
9861 }
9862 #endif
9863 System.Lex.RuleGuard ruleGuard(lexer, 73);
9864 ustring data;
9865 UniquePtr<Value<ustring>> target;
9866 UniquePtr<Value<uchar>> chr;
9867 Match match(false);
9868 Match* parentMatch0 = &match;
9869 {
9870 long pos = lexer.GetPos();
9871 Match match(false);
9872 Match* parentMatch1 = &match;
9873 {
9874 Match match(false);
9875 Match* parentMatch2 = &match;
9876 {
9877 Match match(false);
9878 Match* parentMatch3 = &match;
9879 {
9880 Match match(false);
9881 Match* parentMatch4 = &match;
9882 {
9883 Match match(false);
9884 Match* parentMatch5 = &match;
9885 {
9886 Match match(true);
9887 long __n = 2;
9888 for (long __k = 0; __k < __n; ++__k;)
9889 {
9890 int __i = s63[__k];
9891 if (*lexer == __i)
9892 {
9893 ++lexer;
9894 }
9895 else
9896 {
9897 match.hit = false;
9898 break;
9899 }
9900 }
9901 *parentMatch5 = match;
9902 }
9903 if (match.hit)
9904 {
9905 Match match(false);
9906 Match* parentMatch6 = &match;
9907 {
9908 Match match = XmlParser.PITarget(lexer);
9909 target.Reset(cast<Value<ustring>*>(match.value));
9910 *parentMatch6 = match;
9911 }
9912 *parentMatch5 = match;
9913 }
9914 *parentMatch4 = match;
9915 }
9916 if (match.hit)
9917 {
9918 Match match(false);
9919 Match* parentMatch7 = &match;
9920 {
9921 Match match = XmlParser.S(lexer);
9922 *parentMatch7 = match;
9923 }
9924 *parentMatch4 = match;
9925 }
9926 *parentMatch3 = match;
9927 }
9928 if (match.hit)
9929 {
9930 Match match(false);
9931 Match* parentMatch8 = &match;
9932 {
9933 Match match(true);
9934 Match* parentMatch9 = &match;
9935 {
9936 while (true)
9937 {
9938 long save = lexer.GetPos();
9939 {
9940 Match match(false);
9941 Match* parentMatch10 = &match;
9942 {
9943 Match match(false);
9944 Match* parentMatch11 = &match;
9945 {
9946 long pos = lexer.GetPos();
9947 Match match(false);
9948 Match* parentMatch12 = &match;
9949 {
9950 Match match(false);
9951 Match* parentMatch13 = &match;
9952 long save = lexer.GetPos();
9953 {
9954 Match match = XmlParser.Char(lexer);
9955 chr.Reset(cast<Value<uchar>*>(match.value));
9956 *parentMatch13 = match;
9957 }
9958 if (match.hit)
9959 {
9960 Match match(false);
9961 Match* parentMatch14 = &match;
9962 {
9963 long tmp = lexer.GetPos();
9964 lexer.SetPos(save);
9965 save = tmp;
9966 Match match(true);
9967 long __n = 2;
9968 for (long __k = 0; __k < __n; ++__k;)
9969 {
9970 int __i = s64[__k];
9971 if (*lexer == __i)
9972 {
9973 ++lexer;
9974 }
9975 else
9976 {
9977 match.hit = false;
9978 break;
9979 }
9980 }
9981 *parentMatch14 = match;
9982 }
9983 if (!match.hit)
9984 {
9985 lexer.SetPos(save);
9986 }
9987 *parentMatch13 = Match(!match.hit, match.value);
9988 }
9989 *parentMatch12 = match;
9990 }
9991 if (match.hit)
9992 {
9993 data.Append(chr->value);
9994 }
9995 *parentMatch11 = match;
9996 }
9997 *parentMatch10 = match;
9998 }
9999 if (match.hit)
10000 {
10001 *parentMatch9 = match;
10002 }
10003 else
10004 {
10005 lexer.SetPos(save);
10006 break;
10007 }
10008 }
10009 }
10010 }
10011 *parentMatch8 = match;
10012 }
10013 *parentMatch3 = match;
10014 }
10015 *parentMatch2 = match;
10016 }
10017 if (match.hit)
10018 {
10019 Match match(false);
10020 Match* parentMatch15 = &match;
10021 {
10022 Match match(true);
10023 long __n = 2;
10024 for (long __k = 0; __k < __n; ++__k;)
10025 {
10026 int __i = s65[__k];
10027 if (*lexer == __i)
10028 {
10029 ++lexer;
10030 }
10031 else
10032 {
10033 match.hit = false;
10034 break;
10035 }
10036 }
10037 *parentMatch15 = match;
10038 }
10039 *parentMatch2 = match;
10040 }
10041 *parentMatch1 = match;
10042 }
10043 if (match.hit)
10044 {
10045 processor->PI(target->value, data);
10046 }
10047 *parentMatch0 = match;
10048 }
10049 #if (DEBUG)
10050 if (writeToLog)
10051 {
10052 if (match.hit)
10053 {
10054 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"PI");
10055 }
10056 else
10057 {
10058 System.Lex.WriteFailureToLog(lexer, u"PI");
10059 }
10060 }
10061 #endif
10062 if (!match.hit)
10063 {
10064 match.value = null;
10065 }
10066 return match;
10067 }
10068 public static Match PITarget(TrivialLexer& lexer)
10069 {
10070 #if (DEBUG)
10071 Span debugSpan;
10072 bool writeToLog = lexer.Log() != null;
10073 if (writeToLog)
10074 {
10075 debugSpan = lexer.GetSpan();
10076 System.Lex.WriteBeginRuleToLog(lexer, u"PITarget");
10077 }
10078 #endif
10079 System.Lex.RuleGuard ruleGuard(lexer, 74);
10080 UniquePtr<Value<ustring>> name;
10081 Match match(false);
10082 Match* parentMatch0 = &match;
10083 {
10084 long pos = lexer.GetPos();
10085 Match match(false);
10086 Match* parentMatch1 = &match;
10087 {
10088 Match match(false);
10089 Match* parentMatch2 = &match;
10090 long save = lexer.GetPos();
10091 {
10092 Match match = XmlParser.Name(lexer);
10093 name.Reset(cast<Value<ustring>*>(match.value));
10094 *parentMatch2 = match;
10095 }
10096 if (match.hit)
10097 {
10098 Match match(false);
10099 Match* parentMatch3 = &match;
10100 {
10101 long tmp = lexer.GetPos();
10102 lexer.SetPos(save);
10103 save = tmp;
10104 Match match = XmlParser.Xml(lexer);
10105 *parentMatch3 = match;
10106 }
10107 if (!match.hit)
10108 {
10109 lexer.SetPos(save);
10110 }
10111 *parentMatch2 = Match(!match.hit, match.value);
10112 }
10113 *parentMatch1 = match;
10114 }
10115 if (match.hit)
10116 {
10117 {
10118 #if (DEBUG)
10119 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"PITarget");
10120 #endif
10121 return Match(true, new Value<ustring>(name->value));
10122 }
10123 }
10124 *parentMatch0 = match;
10125 }
10126 #if (DEBUG)
10127 if (writeToLog)
10128 {
10129 if (match.hit)
10130 {
10131 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"PITarget");
10132 }
10133 else
10134 {
10135 System.Lex.WriteFailureToLog(lexer, u"PITarget");
10136 }
10137 }
10138 #endif
10139 if (!match.hit)
10140 {
10141 match.value = null;
10142 }
10143 return match;
10144 }
10145 public static Match Xml(TrivialLexer& lexer)
10146 {
10147 #if (DEBUG)
10148 Span debugSpan;
10149 bool writeToLog = lexer.Log() != null;
10150 if (writeToLog)
10151 {
10152 debugSpan = lexer.GetSpan();
10153 System.Lex.WriteBeginRuleToLog(lexer, u"Xml");
10154 }
10155 #endif
10156 System.Lex.RuleGuard ruleGuard(lexer, 75);
10157 Match match(false);
10158 Match* parentMatch0 = &match;
10159 {
10160 Match match(false);
10161 Match* parentMatch1 = &match;
10162 {
10163 Match match(false);
10164 for (const Range& range : s66)
10165 {
10166 if (*lexer >= range.first && *lexer <= range.last)
10167 {
10168 match.hit = true;
10169 ++lexer;
10170 break;
10171 }
10172 }
10173 *parentMatch1 = match;
10174 }
10175 if (match.hit)
10176 {
10177 Match match(false);
10178 Match* parentMatch2 = &match;
10179 {
10180 Match match(false);
10181 for (const Range& range : s67)
10182 {
10183 if (*lexer >= range.first && *lexer <= range.last)
10184 {
10185 match.hit = true;
10186 ++lexer;
10187 break;
10188 }
10189 }
10190 *parentMatch2 = match;
10191 }
10192 *parentMatch1 = match;
10193 }
10194 *parentMatch0 = match;
10195 }
10196 if (match.hit)
10197 {
10198 Match match(false);
10199 Match* parentMatch3 = &match;
10200 {
10201 Match match(false);
10202 for (const Range& range : s68)
10203 {
10204 if (*lexer >= range.first && *lexer <= range.last)
10205 {
10206 match.hit = true;
10207 ++lexer;
10208 break;
10209 }
10210 }
10211 *parentMatch3 = match;
10212 }
10213 *parentMatch0 = match;
10214 }
10215 #if (DEBUG)
10216 if (writeToLog)
10217 {
10218 if (match.hit)
10219 {
10220 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Xml");
10221 }
10222 else
10223 {
10224 System.Lex.WriteFailureToLog(lexer, u"Xml");
10225 }
10226 }
10227 #endif
10228 if (!match.hit)
10229 {
10230 match.value = null;
10231 }
10232 return match;
10233 }
10234 public static Match Eq(TrivialLexer& lexer)
10235 {
10236 #if (DEBUG)
10237 Span debugSpan;
10238 bool writeToLog = lexer.Log() != null;
10239 if (writeToLog)
10240 {
10241 debugSpan = lexer.GetSpan();
10242 System.Lex.WriteBeginRuleToLog(lexer, u"Eq");
10243 }
10244 #endif
10245 System.Lex.RuleGuard ruleGuard(lexer, 76);
10246 Match match(false);
10247 Match* parentMatch0 = &match;
10248 {
10249 Match match(false);
10250 Match* parentMatch1 = &match;
10251 {
10252 Match match(true);
10253 long save = lexer.GetPos();
10254 Match* parentMatch2 = &match;
10255 {
10256 Match match = XmlParser.S(lexer);
10257 if (match.hit)
10258 {
10259 *parentMatch2 = match;
10260 }
10261 else
10262 {
10263 lexer.SetPos(save);
10264 }
10265 }
10266 *parentMatch1 = match;
10267 }
10268 if (match.hit)
10269 {
10270 Match match(false);
10271 Match* parentMatch3 = &match;
10272 {
10273 Match match(false);
10274 if (*lexer == 61)
10275 {
10276 ++lexer;
10277 match.hit = true;
10278 }
10279 *parentMatch3 = match;
10280 }
10281 *parentMatch1 = match;
10282 }
10283 *parentMatch0 = match;
10284 }
10285 if (match.hit)
10286 {
10287 Match match(false);
10288 Match* parentMatch4 = &match;
10289 {
10290 Match match(true);
10291 long save = lexer.GetPos();
10292 Match* parentMatch5 = &match;
10293 {
10294 Match match = XmlParser.S(lexer);
10295 if (match.hit)
10296 {
10297 *parentMatch5 = match;
10298 }
10299 else
10300 {
10301 lexer.SetPos(save);
10302 }
10303 }
10304 *parentMatch4 = match;
10305 }
10306 *parentMatch0 = match;
10307 }
10308 #if (DEBUG)
10309 if (writeToLog)
10310 {
10311 if (match.hit)
10312 {
10313 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"Eq");
10314 }
10315 else
10316 {
10317 System.Lex.WriteFailureToLog(lexer, u"Eq");
10318 }
10319 }
10320 #endif
10321 if (!match.hit)
10322 {
10323 match.value = null;
10324 }
10325 return match;
10326 }
10327 public static Match YesNo(TrivialLexer& lexer)
10328 {
10329 #if (DEBUG)
10330 Span debugSpan;
10331 bool writeToLog = lexer.Log() != null;
10332 if (writeToLog)
10333 {
10334 debugSpan = lexer.GetSpan();
10335 System.Lex.WriteBeginRuleToLog(lexer, u"YesNo");
10336 }
10337 #endif
10338 System.Lex.RuleGuard ruleGuard(lexer, 77);
10339 Match match(false);
10340 Match* parentMatch0 = &match;
10341 {
10342 long save = lexer.GetPos();
10343 Match match(false);
10344 Match* parentMatch1 = &match;
10345 {
10346 long pos = lexer.GetPos();
10347 Match match(true);
10348 long __n = 5;
10349 for (long __k = 0; __k < __n; ++__k;)
10350 {
10351 int __i = s69[__k];
10352 if (*lexer == __i)
10353 {
10354 ++lexer;
10355 }
10356 else
10357 {
10358 match.hit = false;
10359 break;
10360 }
10361 }
10362 if (match.hit)
10363 {
10364 {
10365 #if (DEBUG)
10366 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"YesNo");
10367 #endif
10368 return Match(true, new Value<bool>(true));
10369 }
10370 }
10371 *parentMatch1 = match;
10372 }
10373 *parentMatch0 = match;
10374 if (!match.hit)
10375 {
10376 Match match(false);
10377 Match* parentMatch2 = &match;
10378 lexer.SetPos(save);
10379 {
10380 Match match(false);
10381 Match* parentMatch3 = &match;
10382 {
10383 long pos = lexer.GetPos();
10384 Match match(true);
10385 long __n = 4;
10386 for (long __k = 0; __k < __n; ++__k;)
10387 {
10388 int __i = s70[__k];
10389 if (*lexer == __i)
10390 {
10391 ++lexer;
10392 }
10393 else
10394 {
10395 match.hit = false;
10396 break;
10397 }
10398 }
10399 if (match.hit)
10400 {
10401 {
10402 #if (DEBUG)
10403 if (writeToLog) System.Lex.WriteSuccessToLog(lexer, debugSpan, u"YesNo");
10404 #endif
10405 return Match(true, new Value<bool>(false));
10406 }
10407 }
10408 *parentMatch3 = match;
10409 }
10410 *parentMatch2 = match;
10411 }
10412 *parentMatch0 = match;
10413 }
10414 }
10415 #if (DEBUG)
10416 if (writeToLog)
10417 {
10418 if (match.hit)
10419 {
10420 System.Lex.WriteSuccessToLog(lexer, debugSpan, u"YesNo");
10421 }
10422 else
10423 {
10424 System.Lex.WriteFailureToLog(lexer, u"YesNo");
10425 }
10426 }
10427 #endif
10428 if (!match.hit)
10429 {
10430 match.value = null;
10431 }
10432 return match;
10433 }
10434 }