1 using 
    2 using System.Collections;
    3 using System.Lex;
    4 using System.Parsing;
    5 
    6 // this file has been automatically generated from 'C:/work/cmajorm/cmajor/system/System.Xml/XmlParser.parser' using soulcm parser generator scmpg version 5.0.0
    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 } // namespace
   82 
   83 public static class XmlParser
   84 {
   85     public static void Parse(TrivialLexer& lexerSystem.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(lexerprocessor);
   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& lexerSystem.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(lexeru"Document");
  123             }
  124         #endif
  125         System.Lex.RuleGuard ruleGuard(lexer0);
  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(lexerprocessor);
  161                                 *parentMatch6 = match;
  162                             }
  163                             if (match.hit)
  164                             {
  165                                 Match match(false);
  166                                 Match* parentMatch7 = &match;
  167                                 {
  168                                     Match match = XmlParser.Element(lexerprocessor);
  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(lexerprocessor);
  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(lexerdebugSpanu"Document");
  227                 }
  228                 else
  229                 {
  230                     System.Lex.WriteFailureToLog(lexeru"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(lexeru"Char");
  249             }
  250         #endif
  251         System.Lex.RuleGuard ruleGuard(lexer1);
  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(lexerdebugSpanu"Char");
  277                     #endif
  278                     return Match(truenew 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(lexerdebugSpanu"Char");
  289                 }
  290                 else
  291                 {
  292                     System.Lex.WriteFailureToLog(lexeru"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(lexeru"S");
  311             }
  312         #endif
  313         System.Lex.RuleGuard ruleGuard(lexer2);
  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(lexerdebugSpanu"S");
  365                 }
  366                 else
  367                 {
  368                     System.Lex.WriteFailureToLog(lexeru"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(lexeru"NameStartChar");
  387             }
  388         #endif
  389         System.Lex.RuleGuard ruleGuard(lexer3);
  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(lexerdebugSpanu"NameStartChar");
  406                 }
  407                 else
  408                 {
  409                     System.Lex.WriteFailureToLog(lexeru"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(lexeru"NameChar");
  428             }
  429         #endif
  430         System.Lex.RuleGuard ruleGuard(lexer4);
  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(lexerdebugSpanu"NameChar");
  464                 }
  465                 else
  466                 {
  467                     System.Lex.WriteFailureToLog(lexeru"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(lexeru"Name");
  486             }
  487         #endif
  488         System.Lex.RuleGuard ruleGuard(lexer5);
  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(lexerdebugSpanu"Name");
  566                     #endif
  567                     return Match(truenew 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(lexerdebugSpanu"Name");
  578                 }
  579                 else
  580                 {
  581                     System.Lex.WriteFailureToLog(lexeru"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(lexeru"Names");
  600             }
  601         #endif
  602         System.Lex.RuleGuard ruleGuard(lexer6);
  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(lexerdebugSpanu"Names");
  673                 }
  674                 else
  675                 {
  676                     System.Lex.WriteFailureToLog(lexeru"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(lexeru"Nmtoken");
  695             }
  696         #endif
  697         System.Lex.RuleGuard ruleGuard(lexer7);
  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(lexerdebugSpanu"Nmtoken");
  731                 }
  732                 else
  733                 {
  734                     System.Lex.WriteFailureToLog(lexeru"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(lexeru"Nmtokens");
  753             }
  754         #endif
  755         System.Lex.RuleGuard ruleGuard(lexer8);
  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(lexerdebugSpanu"Nmtokens");
  822                 }
  823                 else
  824                 {
  825                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"Prolog");
  844             }
  845         #endif
  846         System.Lex.RuleGuard ruleGuard(lexer9);
  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(lexerprocessor);
  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(lexerprocessor);
  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(lexerprocessor);
  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(lexerprocessor);
  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(lexerdebugSpanu"Prolog");
  968                 }
  969                 else
  970                 {
  971                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"XMLDecl");
  990             }
  991         #endif
  992         System.Lex.RuleGuard ruleGuard(lexer10);
  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(lexerprocessor);
 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(lexerprocessor);
 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(lexerprocessor);
 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(lexerdebugSpanu"XMLDecl");
 1142                 }
 1143                 else
 1144                 {
 1145                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"VersionInfo");
 1164             }
 1165         #endif
 1166         System.Lex.RuleGuard ruleGuard(lexer11);
 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(lexerprocessor);
 1223                 *parentMatch5 = match;
 1224             }
 1225             *parentMatch0 = match;
 1226         }
 1227         #if (DEBUG)
 1228             if (writeToLog)
 1229             {
 1230                 if (match.hit)
 1231                 {
 1232                     System.Lex.WriteSuccessToLog(lexerdebugSpanu"VersionInfo");
 1233                 }
 1234                 else
 1235                 {
 1236                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"VersionNum");
 1255             }
 1256         #endif
 1257         System.Lex.RuleGuard ruleGuard(lexer12);
 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(lexerdebugSpanu"VersionNum");
 1408                 }
 1409                 else
 1410                 {
 1411                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"VersionNumDQ");
 1430             }
 1431         #endif
 1432         System.Lex.RuleGuard ruleGuard(lexer13);
 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(lexerprocessor);
 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(lexerdebugSpanu"VersionNumDQ");
 1480                 }
 1481                 else
 1482                 {
 1483                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"VersionNumSQ");
 1502             }
 1503         #endif
 1504         System.Lex.RuleGuard ruleGuard(lexer14);
 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(lexerprocessor);
 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(lexerdebugSpanu"VersionNumSQ");
 1552                 }
 1553                 else
 1554                 {
 1555                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"VersionNumber");
 1574             }
 1575         #endif
 1576         System.Lex.RuleGuard ruleGuard(lexer15);
 1577         Match match(false);
 1578         Match* parentMatch0 = &match;
 1579         {
 1580             long save = lexer.GetPos();
 1581             Match match = XmlParser.VersionNumDQ(lexerprocessor);
 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(lexerprocessor);
 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(lexerdebugSpanu"VersionNumber");
 1601                 }
 1602                 else
 1603                 {
 1604                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"EncodingDecl");
 1623             }
 1624         #endif
 1625         System.Lex.RuleGuard ruleGuard(lexer16);
 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(lexerprocessor);
 1682                 *parentMatch5 = match;
 1683             }
 1684             *parentMatch0 = match;
 1685         }
 1686         #if (DEBUG)
 1687             if (writeToLog)
 1688             {
 1689                 if (match.hit)
 1690                 {
 1691                     System.Lex.WriteSuccessToLog(lexerdebugSpanu"EncodingDecl");
 1692                 }
 1693                 else
 1694                 {
 1695                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"EncodingName");
 1714             }
 1715         #endif
 1716         System.Lex.RuleGuard ruleGuard(lexer17);
 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(lexerdebugSpanu"EncodingName");
 1819                 }
 1820                 else
 1821                 {
 1822                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"EncNameDQ");
 1841             }
 1842         #endif
 1843         System.Lex.RuleGuard ruleGuard(lexer18);
 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(lexerprocessor);
 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(lexerdebugSpanu"EncNameDQ");
 1891                 }
 1892                 else
 1893                 {
 1894                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"EncNameSQ");
 1913             }
 1914         #endif
 1915         System.Lex.RuleGuard ruleGuard(lexer19);
 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(lexerprocessor);
 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(lexerdebugSpanu"EncNameSQ");
 1963                 }
 1964                 else
 1965                 {
 1966                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"EncName");
 1985             }
 1986         #endif
 1987         System.Lex.RuleGuard ruleGuard(lexer20);
 1988         Match match(false);
 1989         Match* parentMatch0 = &match;
 1990         {
 1991             long save = lexer.GetPos();
 1992             Match match = XmlParser.EncNameDQ(lexerprocessor);
 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(lexerprocessor);
 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(lexerdebugSpanu"EncName");
 2012                 }
 2013                 else
 2014                 {
 2015                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"SDDecl");
 2034             }
 2035         #endif
 2036         System.Lex.RuleGuard ruleGuard(lexer21);
 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(lexerdebugSpanu"SDDecl");
 2115                 }
 2116                 else
 2117                 {
 2118                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"DocTypeDecl");
 2137             }
 2138         #endif
 2139         System.Lex.RuleGuard ruleGuard(lexer22);
 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(lexerprocessor);
 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(lexerdebugSpanu"DocTypeDecl");
 2390                 }
 2391                 else
 2392                 {
 2393                     System.Lex.WriteFailureToLog(lexeru"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(lexeru"ExternalID");
 2412             }
 2413         #endif
 2414         System.Lex.RuleGuard ruleGuard(lexer23);
 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(lexerdebugSpanu"ExternalID");
 2567                 }
 2568                 else
 2569                 {
 2570                     System.Lex.WriteFailureToLog(lexeru"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(lexeru"SystemLiteral");
 2589             }
 2590         #endif
 2591         System.Lex.RuleGuard ruleGuard(lexer24);
 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(lexerdebugSpanu"SystemLiteral");
 2778                 }
 2779                 else
 2780                 {
 2781                     System.Lex.WriteFailureToLog(lexeru"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(lexeru"PubidLiteral");
 2800             }
 2801         #endif
 2802         System.Lex.RuleGuard ruleGuard(lexer25);
 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.hitmatch.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(lexerdebugSpanu"PubidLiteral");
 2988                 }
 2989                 else
 2990                 {
 2991                     System.Lex.WriteFailureToLog(lexeru"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(lexeru"PubidChar");
 3010             }
 3011         #endif
 3012         System.Lex.RuleGuard ruleGuard(lexer26);
 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(lexerdebugSpanu"PubidChar");
 3081                 }
 3082                 else
 3083                 {
 3084                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"IntSubset");
 3103             }
 3104         #endif
 3105         System.Lex.RuleGuard ruleGuard(lexer27);
 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(lexerprocessor);
 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(lexerprocessor);
 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(lexerdebugSpanu"IntSubset");
 3154                 }
 3155                 else
 3156                 {
 3157                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"MarkupDecl");
 3176             }
 3177         #endif
 3178         System.Lex.RuleGuard ruleGuard(lexer28);
 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(lexerprocessor);
 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(lexerprocessor);
 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(lexerprocessor);
 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(lexerprocessor);
 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(lexerprocessor);
 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(lexerprocessor);
 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(lexerdebugSpanu"MarkupDecl");
 3271                 }
 3272                 else
 3273                 {
 3274                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"DeclSep");
 3293             }
 3294         #endif
 3295         System.Lex.RuleGuard ruleGuard(lexer29);
 3296         Match match(false);
 3297         Match* parentMatch0 = &match;
 3298         {
 3299             long save = lexer.GetPos();
 3300             Match match = XmlParser.PEReference(lexerprocessor);
 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(lexerdebugSpanu"DeclSep");
 3320                 }
 3321                 else
 3322                 {
 3323                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"ElementDecl");
 3342             }
 3343         #endif
 3344         System.Lex.RuleGuard ruleGuard(lexer30);
 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(lexerdebugSpanu"ElementDecl");
 3476                 }
 3477                 else
 3478                 {
 3479                     System.Lex.WriteFailureToLog(lexeru"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(lexeru"ContentSpec");
 3498             }
 3499         #endif
 3500         System.Lex.RuleGuard ruleGuard(lexer31);
 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(lexerdebugSpanu"ContentSpec");
 3587                 }
 3588                 else
 3589                 {
 3590                     System.Lex.WriteFailureToLog(lexeru"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(lexeru"Children");
 3609             }
 3610         #endif
 3611         System.Lex.RuleGuard ruleGuard(lexer32);
 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(lexerdebugSpanu"Children");
 3723                 }
 3724                 else
 3725                 {
 3726                     System.Lex.WriteFailureToLog(lexeru"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(lexeru"CP");
 3745             }
 3746         #endif
 3747         System.Lex.RuleGuard ruleGuard(lexer33);
 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(lexerdebugSpanu"CP");
 3878                 }
 3879                 else
 3880                 {
 3881                     System.Lex.WriteFailureToLog(lexeru"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(lexeru"Choice");
 3900             }
 3901         #endif
 3902         System.Lex.RuleGuard ruleGuard(lexer34);
 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(lexerdebugSpanu"Choice");
 4209                 }
 4210                 else
 4211                 {
 4212                     System.Lex.WriteFailureToLog(lexeru"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(lexeru"Seq");
 4231             }
 4232         #endif
 4233         System.Lex.RuleGuard ruleGuard(lexer35);
 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(lexerdebugSpanu"Seq");
 4452                 }
 4453                 else
 4454                 {
 4455                     System.Lex.WriteFailureToLog(lexeru"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(lexeru"Mixed");
 4474             }
 4475         #endif
 4476         System.Lex.RuleGuard ruleGuard(lexer36);
 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(lexerdebugSpanu"Mixed");
 4847                 }
 4848                 else
 4849                 {
 4850                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"AttlistDecl");
 4869             }
 4870         #endif
 4871         System.Lex.RuleGuard ruleGuard(lexer37);
 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(lexerprocessor);
 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(lexerdebugSpanu"AttlistDecl");
 5007                 }
 5008                 else
 5009                 {
 5010                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"AttDef");
 5029             }
 5030         #endif
 5031         System.Lex.RuleGuard ruleGuard(lexer38);
 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(lexerprocessor);
 5106                 *parentMatch9 = match;
 5107             }
 5108             *parentMatch0 = match;
 5109         }
 5110         #if (DEBUG)
 5111             if (writeToLog)
 5112             {
 5113                 if (match.hit)
 5114                 {
 5115                     System.Lex.WriteSuccessToLog(lexerdebugSpanu"AttDef");
 5116                 }
 5117                 else
 5118                 {
 5119                     System.Lex.WriteFailureToLog(lexeru"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(lexeru"AttType");
 5138             }
 5139         #endif
 5140         System.Lex.RuleGuard ruleGuard(lexer39);
 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(lexerdebugSpanu"AttType");
 5182                 }
 5183                 else
 5184                 {
 5185                     System.Lex.WriteFailureToLog(lexeru"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(lexeru"StringType");
 5204             }
 5205         #endif
 5206         System.Lex.RuleGuard ruleGuard(lexer40);
 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(lexerdebugSpanu"StringType");
 5228                 }
 5229                 else
 5230                 {
 5231                     System.Lex.WriteFailureToLog(lexeru"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(lexeru"TokenizedType");
 5250             }
 5251         #endif
 5252         System.Lex.RuleGuard ruleGuard(lexer41);
 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(lexerdebugSpanu"TokenizedType");
 5460                 }
 5461                 else
 5462                 {
 5463                     System.Lex.WriteFailureToLog(lexeru"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(lexeru"EnumeratedType");
 5482             }
 5483         #endif
 5484         System.Lex.RuleGuard ruleGuard(lexer42);
 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(lexerdebugSpanu"EnumeratedType");
 5509                 }
 5510                 else
 5511                 {
 5512                     System.Lex.WriteFailureToLog(lexeru"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(lexeru"NotationType");
 5531             }
 5532         #endif
 5533         System.Lex.RuleGuard ruleGuard(lexer43);
 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(lexerdebugSpanu"NotationType");
 5800                 }
 5801                 else
 5802                 {
 5803                     System.Lex.WriteFailureToLog(lexeru"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(lexeru"Enumeration");
 5822             }
 5823         #endif
 5824         System.Lex.RuleGuard ruleGuard(lexer44);
 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(lexerdebugSpanu"Enumeration");
 6043                 }
 6044                 else
 6045                 {
 6046                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"DefaultDecl");
 6065             }
 6066         #endif
 6067         System.Lex.RuleGuard ruleGuard(lexer45);
 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(lexerprocessor);
 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(lexerdebugSpanu"DefaultDecl");
 6206                 }
 6207                 else
 6208                 {
 6209                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"EntityDecl");
 6228             }
 6229         #endif
 6230         System.Lex.RuleGuard ruleGuard(lexer46);
 6231         Match match(false);
 6232         Match* parentMatch0 = &match;
 6233         {
 6234             long save = lexer.GetPos();
 6235             Match match = XmlParser.GEDecl(lexerprocessor);
 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(lexerprocessor);
 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(lexerdebugSpanu"EntityDecl");
 6255                 }
 6256                 else
 6257                 {
 6258                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"GEDecl");
 6277             }
 6278         #endif
 6279         System.Lex.RuleGuard ruleGuard(lexer47);
 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(lexerprocessor);
 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(lexerdebugSpanu"GEDecl");
 6411                 }
 6412                 else
 6413                 {
 6414                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"PEDecl");
 6433             }
 6434         #endif
 6435         System.Lex.RuleGuard ruleGuard(lexer48);
 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(lexerprocessor);
 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(lexerdebugSpanu"PEDecl");
 6602                 }
 6603                 else
 6604                 {
 6605                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"EntityDef");
 6624             }
 6625         #endif
 6626         System.Lex.RuleGuard ruleGuard(lexer49);
 6627         Match match(false);
 6628         Match* parentMatch0 = &match;
 6629         {
 6630             long save = lexer.GetPos();
 6631             Match match = XmlParser.EntityValue(lexerprocessor);
 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(lexerdebugSpanu"EntityDef");
 6684                 }
 6685                 else
 6686                 {
 6687                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"PEDef");
 6706             }
 6707         #endif
 6708         System.Lex.RuleGuard ruleGuard(lexer50);
 6709         Match match(false);
 6710         Match* parentMatch0 = &match;
 6711         {
 6712             long save = lexer.GetPos();
 6713             Match match = XmlParser.EntityValue(lexerprocessor);
 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(lexerdebugSpanu"PEDef");
 6733                 }
 6734                 else
 6735                 {
 6736                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"EntityValue");
 6755             }
 6756         #endif
 6757         System.Lex.RuleGuard ruleGuard(lexer51);
 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(lexerprocessor);
 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(lexerprocessor);
 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(lexerprocessor);
 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(lexerprocessor);
 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(lexerdebugSpanu"EntityValue");
 7002                 }
 7003                 else
 7004                 {
 7005                     System.Lex.WriteFailureToLog(lexeru"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(lexeru"NDataDecl");
 7024             }
 7025         #endif
 7026         System.Lex.RuleGuard ruleGuard(lexer52);
 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(lexerdebugSpanu"NDataDecl");
 7095                 }
 7096                 else
 7097                 {
 7098                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"PEReference");
 7117             }
 7118         #endif
 7119         System.Lex.RuleGuard ruleGuard(lexer53);
 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(lexerdebugSpanu"PEReference");
 7169                 }
 7170                 else
 7171                 {
 7172                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"NotationDecl");
 7191             }
 7192         #endif
 7193         System.Lex.RuleGuard ruleGuard(lexer54);
 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(lexerdebugSpanu"NotationDecl");
 7347                 }
 7348                 else
 7349                 {
 7350                     System.Lex.WriteFailureToLog(lexeru"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(lexeru"PublicID");
 7369             }
 7370         #endif
 7371         System.Lex.RuleGuard ruleGuard(lexer55);
 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(lexerdebugSpanu"PublicID");
 7423                 }
 7424                 else
 7425                 {
 7426                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"Element");
 7445             }
 7446         #endif
 7447         System.Lex.RuleGuard ruleGuard(lexer56);
 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(lexerprocessor);
 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(spanlexer.FileName());
 7605                                 processor->EndTag(tagNamespanlexer.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(spanlexer.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(lexerprocessor);
 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(lexerprocessor);
 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(lexerdebugSpanu"Element");
 7680                 }
 7681                 else
 7682                 {
 7683                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"ETag");
 7702             }
 7703         #endif
 7704         System.Lex.RuleGuard ruleGuard(lexer57);
 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->valuespanlexer.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(lexerdebugSpanu"ETag");
 7802                 }
 7803                 else
 7804                 {
 7805                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"Content");
 7824             }
 7825         #endif
 7826         System.Lex.RuleGuard ruleGuard(lexer58);
 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(lexerprocessor);
 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(lexerprocessor);
 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(lexerprocessor);
 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(lexerprocessor);
 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(lexerprocessor);
 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(lexerprocessor);
 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(lexerprocessor);
 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(lexerdebugSpanu"Content");
 7987                 }
 7988                 else
 7989                 {
 7990                     System.Lex.WriteFailureToLog(lexeru"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(lexeru"CharDataChar");
 8009             }
 8010         #endif
 8011         System.Lex.RuleGuard ruleGuard(lexer59);
 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(lexerdebugSpanu"CharDataChar");
 8035                     #endif
 8036                     return Match(truenew 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(lexerdebugSpanu"CharDataChar");
 8047                 }
 8048                 else
 8049                 {
 8050                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"CharData");
 8069             }
 8070         #endif
 8071         System.Lex.RuleGuard ruleGuard(lexer60);
 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.hitmatch.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(lexerdebugSpanu"CharData");
 8265                 }
 8266                 else
 8267                 {
 8268                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"CDSect");
 8287             }
 8288         #endif
 8289         System.Lex.RuleGuard ruleGuard(lexer61);
 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.hitmatch.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(lexerdebugSpanu"CDSect");
 8449                 }
 8450                 else
 8451                 {
 8452                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"Attribute");
 8471             }
 8472         #endif
 8473         System.Lex.RuleGuard ruleGuard(lexer62);
 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(lexerprocessor);
 8509                     attValue.Reset(cast<Value<ustring>*>(match.value));
 8510                     if (match.hit)
 8511                     {
 8512                         processor->AddAttribute(attName->valueattValue->valuespanlexer.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(lexerdebugSpanu"Attribute");
 8526                 }
 8527                 else
 8528                 {
 8529                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"AttValueDQ");
 8548             }
 8549         #endif
 8550         System.Lex.RuleGuard ruleGuard(lexer63);
 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(lexerprocessor);
 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(lexerdebugSpanu"AttValueDQ");
 8673                             #endif
 8674                             return Match(truenew 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(lexerdebugSpanu"AttValueDQ");
 8689                 }
 8690                 else
 8691                 {
 8692                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"AttValueSQ");
 8711             }
 8712         #endif
 8713         System.Lex.RuleGuard ruleGuard(lexer64);
 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(lexerprocessor);
 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(lexerdebugSpanu"AttValueSQ");
 8836                             #endif
 8837                             return Match(truenew 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(lexerdebugSpanu"AttValueSQ");
 8852                 }
 8853                 else
 8854                 {
 8855                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"AttValue");
 8874             }
 8875         #endif
 8876         System.Lex.RuleGuard ruleGuard(lexer65);
 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(lexerprocessor);
 8888                 attValueDQ.Reset(cast<Value<ustring>*>(match.value));
 8889                 if (match.hit)
 8890                 {
 8891                     {
 8892                         #if (DEBUG)
 8893                             if (writeToLog) System.Lex.WriteSuccessToLog(lexerdebugSpanu"AttValue");
 8894                         #endif
 8895                         return Match(truenew 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(lexerprocessor);
 8912                         attValueSQ.Reset(cast<Value<ustring>*>(match.value));
 8913                         if (match.hit)
 8914                         {
 8915                             {
 8916                                 #if (DEBUG)
 8917                                     if (writeToLog) System.Lex.WriteSuccessToLog(lexerdebugSpanu"AttValue");
 8918                                 #endif
 8919                                 return Match(truenew 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(lexerdebugSpanu"AttValue");
 8935                 }
 8936                 else
 8937                 {
 8938                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"EntityRef");
 8957             }
 8958         #endif
 8959         System.Lex.RuleGuard ruleGuard(lexer66);
 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->valuespanlexer.FileName());
 9016             }
 9017             *parentMatch0 = match;
 9018         }
 9019         #if (DEBUG)
 9020             if (writeToLog)
 9021             {
 9022                 if (match.hit)
 9023                 {
 9024                     System.Lex.WriteSuccessToLog(lexerdebugSpanu"EntityRef");
 9025                 }
 9026                 else
 9027                 {
 9028                     System.Lex.WriteFailureToLog(lexeru"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(lexeru"DecCodePoint");
 9047             }
 9048         #endif
 9049         System.Lex.RuleGuard ruleGuard(lexer67);
 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(lexerdebugSpanu"DecCodePoint");
 9142                     #endif
 9143                     return Match(truenew 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(lexerdebugSpanu"DecCodePoint");
 9154                 }
 9155                 else
 9156                 {
 9157                     System.Lex.WriteFailureToLog(lexeru"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(lexeru"HexCodePoint");
 9176             }
 9177         #endif
 9178         System.Lex.RuleGuard ruleGuard(lexer68);
 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(lexerdebugSpanu"HexCodePoint");
 9275                     #endif
 9276                     return Match(truenew 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(lexerdebugSpanu"HexCodePoint");
 9287                 }
 9288                 else
 9289                 {
 9290                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"CharRef");
 9309             }
 9310         #endif
 9311         System.Lex.RuleGuard ruleGuard(lexer69);
 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(lexerdebugSpanu"CharRef");
 9468                 }
 9469                 else
 9470                 {
 9471                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"Reference");
 9490             }
 9491         #endif
 9492         System.Lex.RuleGuard ruleGuard(lexer70);
 9493         Match match(false);
 9494         Match* parentMatch0 = &match;
 9495         {
 9496             long save = lexer.GetPos();
 9497             Match match = XmlParser.EntityRef(lexerprocessor);
 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(lexerprocessor);
 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(lexerdebugSpanu"Reference");
 9517                 }
 9518                 else
 9519                 {
 9520                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"Misc");
 9539             }
 9540         #endif
 9541         System.Lex.RuleGuard ruleGuard(lexer71);
 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(lexerprocessor);
 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(lexerprocessor);
 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(lexerdebugSpanu"Misc");
 9583                 }
 9584                 else
 9585                 {
 9586                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"Comment");
 9605             }
 9606         #endif
 9607         System.Lex.RuleGuard ruleGuard(lexer72);
 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.hitmatch.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.hitmatch.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(lexerdebugSpanu"Comment");
 9839                 }
 9840                 else
 9841                 {
 9842                     System.Lex.WriteFailureToLog(lexeru"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& lexerSystem.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(lexeru"PI");
 9861             }
 9862         #endif
 9863         System.Lex.RuleGuard ruleGuard(lexer73);
 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.hitmatch.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->valuedata);
10046             }
10047             *parentMatch0 = match;
10048         }
10049         #if (DEBUG)
10050             if (writeToLog)
10051             {
10052                 if (match.hit)
10053                 {
10054                     System.Lex.WriteSuccessToLog(lexerdebugSpanu"PI");
10055                 }
10056                 else
10057                 {
10058                     System.Lex.WriteFailureToLog(lexeru"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(lexeru"PITarget");
10077             }
10078         #endif
10079         System.Lex.RuleGuard ruleGuard(lexer74);
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.hitmatch.value);
10112                 }
10113                 *parentMatch1 = match;
10114             }
10115             if (match.hit)
10116             {
10117                 {
10118                     #if (DEBUG)
10119                         if (writeToLog) System.Lex.WriteSuccessToLog(lexerdebugSpanu"PITarget");
10120                     #endif
10121                     return Match(truenew 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(lexerdebugSpanu"PITarget");
10132                 }
10133                 else
10134                 {
10135                     System.Lex.WriteFailureToLog(lexeru"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(lexeru"Xml");
10154             }
10155         #endif
10156         System.Lex.RuleGuard ruleGuard(lexer75);
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(lexerdebugSpanu"Xml");
10221                 }
10222                 else
10223                 {
10224                     System.Lex.WriteFailureToLog(lexeru"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(lexeru"Eq");
10243             }
10244         #endif
10245         System.Lex.RuleGuard ruleGuard(lexer76);
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(lexerdebugSpanu"Eq");
10314                 }
10315                 else
10316                 {
10317                     System.Lex.WriteFailureToLog(lexeru"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(lexeru"YesNo");
10336             }
10337         #endif
10338         System.Lex.RuleGuard ruleGuard(lexer77);
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(lexerdebugSpanu"YesNo");
10367                         #endif
10368                         return Match(truenew 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(lexerdebugSpanu"YesNo");
10404                                 #endif
10405                                 return Match(truenew 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(lexerdebugSpanu"YesNo");
10421                 }
10422                 else
10423                 {
10424                     System.Lex.WriteFailureToLog(lexeru"YesNo");
10425                 }
10426             }
10427         #endif
10428         if (!match.hit)
10429         {
10430             match.value = null;
10431         }
10432         return match;
10433     }
10434 }