src/main/java/org/xerial/util/xml/dtd/impl/DTDParser.java

   1 // $ANTLR 3.1.1 F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g 2008-10-06 10:58:12\r
   2 \r
   3 //--------------------------------------------------\r
   4 // Xerial -- Transactional XML Database System      \r
   5 // \r
   6 // DTDParser.g\r
   7 // Since  2007/07/25 11:40:17\r
   8 // \r
   9 //--------------------------------------------------\r
  10 package org.xerial.util.xml.dtd.impl;\r
  11 //import org.xerial.util.log.Logger;\r
  12 \r
  13 \r
  14 import org.antlr.runtime.*;\r
  15 import java.util.Stack;\r
  16 import java.util.List;\r
  17 import java.util.ArrayList;\r
  18 import java.util.Map;\r
  19 import java.util.HashMap;\r
  20 \r
  21 import org.antlr.runtime.tree.*;\r
  22 \r
  23 public class DTDParser extends Parser {\r
  24     public static final String[] tokenNames = new String[] {\r
  25         "<invalid>", "<EOR>", "<DOWN>", "<UP>", "NUMBER", "STRING", "ML_COMMENT", "At", "Colon", "Comma", "Apos", "Quot", "Dot", "SemiColon", "LParen", "RParen", "Letter", "Digit", "Digits", "NameChar", "WhiteSpaceChar", "StringLiteral", "Name", "Reference", "AttValue", "EntityRef", "CharRef", "DefaultDecl", "Element", "'>'", "'EMPTY'", "'ANY'", "'?'", "'*'", "'+'", "'|'", "'#PCDATA'", "'<!ATTLIST'", "'NOTATION'", "'CDATA'", "'ID'", "'IDREF'", "'IDREFS'", "'ENTITY'", "'ENTITIES'", "'NMTOKEN'", "'NMTOKENS'"\r
  26     };\r
  27     public static final int CharRef=26;\r
  28     public static final int T__29=29;\r
  29     public static final int DefaultDecl=27;\r
  30     public static final int Apos=10;\r
  31     public static final int EOF=-1;\r
  32     public static final int AttValue=24;\r
  33     public static final int ML_COMMENT=6;\r
  34     public static final int Digits=18;\r
  35     public static final int WhiteSpaceChar=20;\r
  36     public static final int Reference=23;\r
  37     public static final int Quot=11;\r
  38     public static final int T__42=42;\r
  39     public static final int T__43=43;\r
  40     public static final int SemiColon=13;\r
  41     public static final int T__40=40;\r
  42     public static final int RParen=15;\r
  43     public static final int T__41=41;\r
  44     public static final int T__46=46;\r
  45     public static final int T__44=44;\r
  46     public static final int At=7;\r
  47     public static final int T__45=45;\r
  48     public static final int LParen=14;\r
  49     public static final int NUMBER=4;\r
  50     public static final int NameChar=19;\r
  51     public static final int Colon=8;\r
  52     public static final int Digit=17;\r
  53     public static final int EntityRef=25;\r
  54     public static final int StringLiteral=21;\r
  55     public static final int T__30=30;\r
  56     public static final int T__31=31;\r
  57     public static final int T__32=32;\r
  58     public static final int T__33=33;\r
  59     public static final int T__34=34;\r
  60     public static final int T__35=35;\r
  61     public static final int T__36=36;\r
  62     public static final int T__37=37;\r
  63     public static final int T__38=38;\r
  64     public static final int T__39=39;\r
  65     public static final int Dot=12;\r
  66     public static final int Name=22;\r
  67     public static final int Comma=9;\r
  68     public static final int Letter=16;\r
  69     public static final int Element=28;\r
  70     public static final int STRING=5;\r
  71 \r
  72     // delegates\r
  73     // delegators\r
  74 \r
  75 \r
  76         public DTDParser(TokenStream input) {\r
  77             this(input, new RecognizerSharedState());\r
  78         }\r
  79         public DTDParser(TokenStream input, RecognizerSharedState state) {\r
  80             super(input, state);\r
  81              \r
  82         }\r
  83         \r
  84     protected TreeAdaptor adaptor = new CommonTreeAdaptor();\r
  85 \r
  86     public void setTreeAdaptor(TreeAdaptor adaptor) {\r
  87         this.adaptor = adaptor;\r
  88     }\r
  89     public TreeAdaptor getTreeAdaptor() {\r
  90         return adaptor;\r
  91     }\r
  92 \r
  93     public String[] getTokenNames() { return DTDParser.tokenNames; }\r
  94     public String getGrammarFileName() { return "F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g"; }\r
  95 \r
  96 \r
  97     public static class integerLiteral_return extends ParserRuleReturnScope {\r
  98         Object tree;\r
  99         public Object getTree() { return tree; }\r
 100     };\r
 101 \r
 102     // $ANTLR start "integerLiteral"\r
 103     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:115:1: integerLiteral : Digits ;\r
 104     public final DTDParser.integerLiteral_return integerLiteral() throws RecognitionException {\r
 105         DTDParser.integerLiteral_return retval = new DTDParser.integerLiteral_return();\r
 106         retval.start = input.LT(1);\r
 107 \r
 108         Object root_0 = null;\r
 109 \r
 110         Token Digits1=null;\r
 111 \r
 112         Object Digits1_tree=null;\r
 113 \r
 114         try {\r
 115             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:115:15: ( Digits )\r
 116             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:115:17: Digits\r
 117             {\r
 118             root_0 = (Object)adaptor.nil();\r
 119 \r
 120             Digits1=(Token)match(input,Digits,FOLLOW_Digits_in_integerLiteral491); if (state.failed) return retval;\r
 121             if ( state.backtracking==0 ) {\r
 122             Digits1_tree = (Object)adaptor.create(Digits1);\r
 123             adaptor.addChild(root_0, Digits1_tree);\r
 124             }\r
 125 \r
 126             }\r
 127 \r
 128             retval.stop = input.LT(-1);\r
 129 \r
 130             if ( state.backtracking==0 ) {\r
 131 \r
 132             retval.tree = (Object)adaptor.rulePostProcessing(root_0);\r
 133             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);\r
 134             }\r
 135         }\r
 136         catch (RecognitionException re) {\r
 137             reportError(re);\r
 138             recover(input,re);\r
 139         retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);\r
 140 \r
 141         }\r
 142         finally {\r
 143         }\r
 144         return retval;\r
 145     }\r
 146     // $ANTLR end "integerLiteral"\r
 147 \r
 148     public static class decimalLiteral_return extends ParserRuleReturnScope {\r
 149         Object tree;\r
 150         public Object getTree() { return tree; }\r
 151     };\r
 152 \r
 153     // $ANTLR start "decimalLiteral"\r
 154     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:116:1: decimalLiteral : ( Dot Digits | Digits Dot Digits );\r
 155     public final DTDParser.decimalLiteral_return decimalLiteral() throws RecognitionException {\r
 156         DTDParser.decimalLiteral_return retval = new DTDParser.decimalLiteral_return();\r
 157         retval.start = input.LT(1);\r
 158 \r
 159         Object root_0 = null;\r
 160 \r
 161         Token Dot2=null;\r
 162         Token Digits3=null;\r
 163         Token Digits4=null;\r
 164         Token Dot5=null;\r
 165         Token Digits6=null;\r
 166 \r
 167         Object Dot2_tree=null;\r
 168         Object Digits3_tree=null;\r
 169         Object Digits4_tree=null;\r
 170         Object Dot5_tree=null;\r
 171         Object Digits6_tree=null;\r
 172 \r
 173         try {\r
 174             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:116:15: ( Dot Digits | Digits Dot Digits )\r
 175             int alt1=2;\r
 176             int LA1_0 = input.LA(1);\r
 177 \r
 178             if ( (LA1_0==Dot) ) {\r
 179                 alt1=1;\r
 180             }\r
 181             else if ( (LA1_0==Digits) ) {\r
 182                 alt1=2;\r
 183             }\r
 184             else {\r
 185                 if (state.backtracking>0) {state.failed=true; return retval;}\r
 186                 NoViableAltException nvae =\r
 187                     new NoViableAltException("", 1, 0, input);\r
 188 \r
 189                 throw nvae;\r
 190             }\r
 191             switch (alt1) {\r
 192                 case 1 :\r
 193                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:116:17: Dot Digits\r
 194                     {\r
 195                     root_0 = (Object)adaptor.nil();\r
 196 \r
 197                     Dot2=(Token)match(input,Dot,FOLLOW_Dot_in_decimalLiteral497); if (state.failed) return retval;\r
 198                     if ( state.backtracking==0 ) {\r
 199                     Dot2_tree = (Object)adaptor.create(Dot2);\r
 200                     adaptor.addChild(root_0, Dot2_tree);\r
 201                     }\r
 202                     Digits3=(Token)match(input,Digits,FOLLOW_Digits_in_decimalLiteral499); if (state.failed) return retval;\r
 203                     if ( state.backtracking==0 ) {\r
 204                     Digits3_tree = (Object)adaptor.create(Digits3);\r
 205                     adaptor.addChild(root_0, Digits3_tree);\r
 206                     }\r
 207 \r
 208                     }\r
 209                     break;\r
 210                 case 2 :\r
 211                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:116:29: Digits Dot Digits\r
 212                     {\r
 213                     root_0 = (Object)adaptor.nil();\r
 214 \r
 215                     Digits4=(Token)match(input,Digits,FOLLOW_Digits_in_decimalLiteral502); if (state.failed) return retval;\r
 216                     if ( state.backtracking==0 ) {\r
 217                     Digits4_tree = (Object)adaptor.create(Digits4);\r
 218                     adaptor.addChild(root_0, Digits4_tree);\r
 219                     }\r
 220                     Dot5=(Token)match(input,Dot,FOLLOW_Dot_in_decimalLiteral504); if (state.failed) return retval;\r
 221                     if ( state.backtracking==0 ) {\r
 222                     Dot5_tree = (Object)adaptor.create(Dot5);\r
 223                     adaptor.addChild(root_0, Dot5_tree);\r
 224                     }\r
 225                     Digits6=(Token)match(input,Digits,FOLLOW_Digits_in_decimalLiteral506); if (state.failed) return retval;\r
 226                     if ( state.backtracking==0 ) {\r
 227                     Digits6_tree = (Object)adaptor.create(Digits6);\r
 228                     adaptor.addChild(root_0, Digits6_tree);\r
 229                     }\r
 230 \r
 231                     }\r
 232                     break;\r
 233 \r
 234             }\r
 235             retval.stop = input.LT(-1);\r
 236 \r
 237             if ( state.backtracking==0 ) {\r
 238 \r
 239             retval.tree = (Object)adaptor.rulePostProcessing(root_0);\r
 240             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);\r
 241             }\r
 242         }\r
 243         catch (RecognitionException re) {\r
 244             reportError(re);\r
 245             recover(input,re);\r
 246         retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);\r
 247 \r
 248         }\r
 249         finally {\r
 250         }\r
 251         return retval;\r
 252     }\r
 253     // $ANTLR end "decimalLiteral"\r
 254 \r
 255     public static class literal_return extends ParserRuleReturnScope {\r
 256         Object tree;\r
 257         public Object getTree() { return tree; }\r
 258     };\r
 259 \r
 260     // $ANTLR start "literal"\r
 261     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:118:1: literal : ( | numericLiteral -> ^( NUMBER numericLiteral ) | StringLiteral -> ^( STRING StringLiteral ) );\r
 262     public final DTDParser.literal_return literal() throws RecognitionException {\r
 263         DTDParser.literal_return retval = new DTDParser.literal_return();\r
 264         retval.start = input.LT(1);\r
 265 \r
 266         Object root_0 = null;\r
 267 \r
 268         Token StringLiteral8=null;\r
 269         DTDParser.numericLiteral_return numericLiteral7 = null;\r
 270 \r
 271 \r
 272         Object StringLiteral8_tree=null;\r
 273         RewriteRuleTokenStream stream_StringLiteral=new RewriteRuleTokenStream(adaptor,"token StringLiteral");\r
 274         RewriteRuleSubtreeStream stream_numericLiteral=new RewriteRuleSubtreeStream(adaptor,"rule numericLiteral");\r
 275         try {\r
 276             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:118:8: ( | numericLiteral -> ^( NUMBER numericLiteral ) | StringLiteral -> ^( STRING StringLiteral ) )\r
 277             int alt2=3;\r
 278             switch ( input.LA(1) ) {\r
 279             case EOF:\r
 280                 {\r
 281                 alt2=1;\r
 282                 }\r
 283                 break;\r
 284             case Dot:\r
 285             case Digits:\r
 286                 {\r
 287                 alt2=2;\r
 288                 }\r
 289                 break;\r
 290             case StringLiteral:\r
 291                 {\r
 292                 alt2=3;\r
 293                 }\r
 294                 break;\r
 295             default:\r
 296                 if (state.backtracking>0) {state.failed=true; return retval;}\r
 297                 NoViableAltException nvae =\r
 298                     new NoViableAltException("", 2, 0, input);\r
 299 \r
 300                 throw nvae;\r
 301             }\r
 302 \r
 303             switch (alt2) {\r
 304                 case 1 :\r
 305                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:119:2: \r
 306                     {\r
 307                     root_0 = (Object)adaptor.nil();\r
 308 \r
 309                     }\r
 310                     break;\r
 311                 case 2 :\r
 312                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:119:4: numericLiteral\r
 313                     {\r
 314                     pushFollow(FOLLOW_numericLiteral_in_literal517);\r
 315                     numericLiteral7=numericLiteral();\r
 316 \r
 317                     state._fsp--;\r
 318                     if (state.failed) return retval;\r
 319                     if ( state.backtracking==0 ) stream_numericLiteral.add(numericLiteral7.getTree());\r
 320 \r
 321 \r
 322                     // AST REWRITE\r
 323                     // elements: numericLiteral\r
 324                     // token labels: \r
 325                     // rule labels: retval\r
 326                     // token list labels: \r
 327                     // rule list labels: \r
 328                     if ( state.backtracking==0 ) {\r
 329                     retval.tree = root_0;\r
 330                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);\r
 331 \r
 332                     root_0 = (Object)adaptor.nil();\r
 333                     // 119:19: -> ^( NUMBER numericLiteral )\r
 334                     {\r
 335                         // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:119:22: ^( NUMBER numericLiteral )\r
 336                         {\r
 337                         Object root_1 = (Object)adaptor.nil();\r
 338                         root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(NUMBER, "NUMBER"), root_1);\r
 339 \r
 340                         adaptor.addChild(root_1, stream_numericLiteral.nextTree());\r
 341 \r
 342                         adaptor.addChild(root_0, root_1);\r
 343                         }\r
 344 \r
 345                     }\r
 346 \r
 347                     retval.tree = root_0;}\r
 348                     }\r
 349                     break;\r
 350                 case 3 :\r
 351                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:120:4: StringLiteral\r
 352                     {\r
 353                     StringLiteral8=(Token)match(input,StringLiteral,FOLLOW_StringLiteral_in_literal530); if (state.failed) return retval; \r
 354                     if ( state.backtracking==0 ) stream_StringLiteral.add(StringLiteral8);\r
 355 \r
 356 \r
 357 \r
 358                     // AST REWRITE\r
 359                     // elements: StringLiteral\r
 360                     // token labels: \r
 361                     // rule labels: retval\r
 362                     // token list labels: \r
 363                     // rule list labels: \r
 364                     if ( state.backtracking==0 ) {\r
 365                     retval.tree = root_0;\r
 366                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);\r
 367 \r
 368                     root_0 = (Object)adaptor.nil();\r
 369                     // 120:18: -> ^( STRING StringLiteral )\r
 370                     {\r
 371                         // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:120:21: ^( STRING StringLiteral )\r
 372                         {\r
 373                         Object root_1 = (Object)adaptor.nil();\r
 374                         root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(STRING, "STRING"), root_1);\r
 375 \r
 376                         adaptor.addChild(root_1, stream_StringLiteral.nextNode());\r
 377 \r
 378                         adaptor.addChild(root_0, root_1);\r
 379                         }\r
 380 \r
 381                     }\r
 382 \r
 383                     retval.tree = root_0;}\r
 384                     }\r
 385                     break;\r
 386 \r
 387             }\r
 388             retval.stop = input.LT(-1);\r
 389 \r
 390             if ( state.backtracking==0 ) {\r
 391 \r
 392             retval.tree = (Object)adaptor.rulePostProcessing(root_0);\r
 393             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);\r
 394             }\r
 395         }\r
 396         catch (RecognitionException re) {\r
 397             reportError(re);\r
 398             recover(input,re);\r
 399         retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);\r
 400 \r
 401         }\r
 402         finally {\r
 403         }\r
 404         return retval;\r
 405     }\r
 406     // $ANTLR end "literal"\r
 407 \r
 408     public static class numericLiteral_return extends ParserRuleReturnScope {\r
 409         Object tree;\r
 410         public Object getTree() { return tree; }\r
 411     };\r
 412 \r
 413     // $ANTLR start "numericLiteral"\r
 414     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:123:1: numericLiteral : ( integerLiteral | decimalLiteral );\r
 415     public final DTDParser.numericLiteral_return numericLiteral() throws RecognitionException {\r
 416         DTDParser.numericLiteral_return retval = new DTDParser.numericLiteral_return();\r
 417         retval.start = input.LT(1);\r
 418 \r
 419         Object root_0 = null;\r
 420 \r
 421         DTDParser.integerLiteral_return integerLiteral9 = null;\r
 422 \r
 423         DTDParser.decimalLiteral_return decimalLiteral10 = null;\r
 424 \r
 425 \r
 426 \r
 427         try {\r
 428             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:124:2: ( integerLiteral | decimalLiteral )\r
 429             int alt3=2;\r
 430             int LA3_0 = input.LA(1);\r
 431 \r
 432             if ( (LA3_0==Digits) ) {\r
 433                 int LA3_1 = input.LA(2);\r
 434 \r
 435                 if ( (LA3_1==Dot) ) {\r
 436                     alt3=2;\r
 437                 }\r
 438                 else if ( (LA3_1==EOF) ) {\r
 439                     alt3=1;\r
 440                 }\r
 441                 else {\r
 442                     if (state.backtracking>0) {state.failed=true; return retval;}\r
 443                     NoViableAltException nvae =\r
 444                         new NoViableAltException("", 3, 1, input);\r
 445 \r
 446                     throw nvae;\r
 447                 }\r
 448             }\r
 449             else if ( (LA3_0==Dot) ) {\r
 450                 alt3=2;\r
 451             }\r
 452             else {\r
 453                 if (state.backtracking>0) {state.failed=true; return retval;}\r
 454                 NoViableAltException nvae =\r
 455                     new NoViableAltException("", 3, 0, input);\r
 456 \r
 457                 throw nvae;\r
 458             }\r
 459             switch (alt3) {\r
 460                 case 1 :\r
 461                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:124:4: integerLiteral\r
 462                     {\r
 463                     root_0 = (Object)adaptor.nil();\r
 464 \r
 465                     pushFollow(FOLLOW_integerLiteral_in_numericLiteral550);\r
 466                     integerLiteral9=integerLiteral();\r
 467 \r
 468                     state._fsp--;\r
 469                     if (state.failed) return retval;\r
 470                     if ( state.backtracking==0 ) adaptor.addChild(root_0, integerLiteral9.getTree());\r
 471 \r
 472                     }\r
 473                     break;\r
 474                 case 2 :\r
 475                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:125:4: decimalLiteral\r
 476                     {\r
 477                     root_0 = (Object)adaptor.nil();\r
 478 \r
 479                     pushFollow(FOLLOW_decimalLiteral_in_numericLiteral556);\r
 480                     decimalLiteral10=decimalLiteral();\r
 481 \r
 482                     state._fsp--;\r
 483                     if (state.failed) return retval;\r
 484                     if ( state.backtracking==0 ) adaptor.addChild(root_0, decimalLiteral10.getTree());\r
 485 \r
 486                     }\r
 487                     break;\r
 488 \r
 489             }\r
 490             retval.stop = input.LT(-1);\r
 491 \r
 492             if ( state.backtracking==0 ) {\r
 493 \r
 494             retval.tree = (Object)adaptor.rulePostProcessing(root_0);\r
 495             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);\r
 496             }\r
 497         }\r
 498         catch (RecognitionException re) {\r
 499             reportError(re);\r
 500             recover(input,re);\r
 501         retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);\r
 502 \r
 503         }\r
 504         finally {\r
 505         }\r
 506         return retval;\r
 507     }\r
 508     // $ANTLR end "numericLiteral"\r
 509 \r
 510     public static class dtd_return extends ParserRuleReturnScope {\r
 511         Object tree;\r
 512         public Object getTree() { return tree; }\r
 513     };\r
 514 \r
 515     // $ANTLR start "dtd"\r
 516     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:129:1: dtd : ( markupdecl )* ;\r
 517     public final DTDParser.dtd_return dtd() throws RecognitionException {\r
 518         DTDParser.dtd_return retval = new DTDParser.dtd_return();\r
 519         retval.start = input.LT(1);\r
 520 \r
 521         Object root_0 = null;\r
 522 \r
 523         DTDParser.markupdecl_return markupdecl11 = null;\r
 524 \r
 525 \r
 526 \r
 527         try {\r
 528             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:129:4: ( ( markupdecl )* )\r
 529             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:129:6: ( markupdecl )*\r
 530             {\r
 531             root_0 = (Object)adaptor.nil();\r
 532 \r
 533             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:129:6: ( markupdecl )*\r
 534             loop4:\r
 535             do {\r
 536                 int alt4=2;\r
 537                 int LA4_0 = input.LA(1);\r
 538 \r
 539                 if ( (LA4_0==Element||LA4_0==37) ) {\r
 540                     alt4=1;\r
 541                 }\r
 542 \r
 543 \r
 544                 switch (alt4) {\r
 545                 case 1 :\r
 546                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:129:6: markupdecl\r
 547                     {\r
 548                     pushFollow(FOLLOW_markupdecl_in_dtd567);\r
 549                     markupdecl11=markupdecl();\r
 550 \r
 551                     state._fsp--;\r
 552                     if (state.failed) return retval;\r
 553                     if ( state.backtracking==0 ) adaptor.addChild(root_0, markupdecl11.getTree());\r
 554 \r
 555                     }\r
 556                     break;\r
 557 \r
 558                 default :\r
 559                     break loop4;\r
 560                 }\r
 561             } while (true);\r
 562 \r
 563 \r
 564             }\r
 565 \r
 566             retval.stop = input.LT(-1);\r
 567 \r
 568             if ( state.backtracking==0 ) {\r
 569 \r
 570             retval.tree = (Object)adaptor.rulePostProcessing(root_0);\r
 571             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);\r
 572             }\r
 573         }\r
 574         catch (RecognitionException re) {\r
 575             reportError(re);\r
 576             recover(input,re);\r
 577         retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);\r
 578 \r
 579         }\r
 580         finally {\r
 581         }\r
 582         return retval;\r
 583     }\r
 584     // $ANTLR end "dtd"\r
 585 \r
 586     public static class markupdecl_return extends ParserRuleReturnScope {\r
 587         Object tree;\r
 588         public Object getTree() { return tree; }\r
 589     };\r
 590 \r
 591     // $ANTLR start "markupdecl"\r
 592     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:131:1: markupdecl : ( elementDecl | attlistDecl );\r
 593     public final DTDParser.markupdecl_return markupdecl() throws RecognitionException {\r
 594         DTDParser.markupdecl_return retval = new DTDParser.markupdecl_return();\r
 595         retval.start = input.LT(1);\r
 596 \r
 597         Object root_0 = null;\r
 598 \r
 599         DTDParser.elementDecl_return elementDecl12 = null;\r
 600 \r
 601         DTDParser.attlistDecl_return attlistDecl13 = null;\r
 602 \r
 603 \r
 604 \r
 605         try {\r
 606             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:131:11: ( elementDecl | attlistDecl )\r
 607             int alt5=2;\r
 608             int LA5_0 = input.LA(1);\r
 609 \r
 610             if ( (LA5_0==Element) ) {\r
 611                 alt5=1;\r
 612             }\r
 613             else if ( (LA5_0==37) ) {\r
 614                 alt5=2;\r
 615             }\r
 616             else {\r
 617                 if (state.backtracking>0) {state.failed=true; return retval;}\r
 618                 NoViableAltException nvae =\r
 619                     new NoViableAltException("", 5, 0, input);\r
 620 \r
 621                 throw nvae;\r
 622             }\r
 623             switch (alt5) {\r
 624                 case 1 :\r
 625                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:131:13: elementDecl\r
 626                     {\r
 627                     root_0 = (Object)adaptor.nil();\r
 628 \r
 629                     pushFollow(FOLLOW_elementDecl_in_markupdecl575);\r
 630                     elementDecl12=elementDecl();\r
 631 \r
 632                     state._fsp--;\r
 633                     if (state.failed) return retval;\r
 634                     if ( state.backtracking==0 ) adaptor.addChild(root_0, elementDecl12.getTree());\r
 635 \r
 636                     }\r
 637                     break;\r
 638                 case 2 :\r
 639                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:131:27: attlistDecl\r
 640                     {\r
 641                     root_0 = (Object)adaptor.nil();\r
 642 \r
 643                     pushFollow(FOLLOW_attlistDecl_in_markupdecl579);\r
 644                     attlistDecl13=attlistDecl();\r
 645 \r
 646                     state._fsp--;\r
 647                     if (state.failed) return retval;\r
 648                     if ( state.backtracking==0 ) adaptor.addChild(root_0, attlistDecl13.getTree());\r
 649 \r
 650                     }\r
 651                     break;\r
 652 \r
 653             }\r
 654             retval.stop = input.LT(-1);\r
 655 \r
 656             if ( state.backtracking==0 ) {\r
 657 \r
 658             retval.tree = (Object)adaptor.rulePostProcessing(root_0);\r
 659             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);\r
 660             }\r
 661         }\r
 662         catch (RecognitionException re) {\r
 663             reportError(re);\r
 664             recover(input,re);\r
 665         retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);\r
 666 \r
 667         }\r
 668         finally {\r
 669         }\r
 670         return retval;\r
 671     }\r
 672     // $ANTLR end "markupdecl"\r
 673 \r
 674     public static class elementDecl_return extends ParserRuleReturnScope {\r
 675         Object tree;\r
 676         public Object getTree() { return tree; }\r
 677     };\r
 678 \r
 679     // $ANTLR start "elementDecl"\r
 680     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:134:1: elementDecl : Element Name contentSpec '>' ;\r
 681     public final DTDParser.elementDecl_return elementDecl() throws RecognitionException {\r
 682         DTDParser.elementDecl_return retval = new DTDParser.elementDecl_return();\r
 683         retval.start = input.LT(1);\r
 684 \r
 685         Object root_0 = null;\r
 686 \r
 687         Token Element14=null;\r
 688         Token Name15=null;\r
 689         Token char_literal17=null;\r
 690         DTDParser.contentSpec_return contentSpec16 = null;\r
 691 \r
 692 \r
 693         Object Element14_tree=null;\r
 694         Object Name15_tree=null;\r
 695         Object char_literal17_tree=null;\r
 696 \r
 697         try {\r
 698             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:134:12: ( Element Name contentSpec '>' )\r
 699             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:134:14: Element Name contentSpec '>'\r
 700             {\r
 701             root_0 = (Object)adaptor.nil();\r
 702 \r
 703             Element14=(Token)match(input,Element,FOLLOW_Element_in_elementDecl587); if (state.failed) return retval;\r
 704             if ( state.backtracking==0 ) {\r
 705             Element14_tree = (Object)adaptor.create(Element14);\r
 706             adaptor.addChild(root_0, Element14_tree);\r
 707             }\r
 708             Name15=(Token)match(input,Name,FOLLOW_Name_in_elementDecl589); if (state.failed) return retval;\r
 709             if ( state.backtracking==0 ) {\r
 710             Name15_tree = (Object)adaptor.create(Name15);\r
 711             adaptor.addChild(root_0, Name15_tree);\r
 712             }\r
 713             pushFollow(FOLLOW_contentSpec_in_elementDecl591);\r
 714             contentSpec16=contentSpec();\r
 715 \r
 716             state._fsp--;\r
 717             if (state.failed) return retval;\r
 718             if ( state.backtracking==0 ) adaptor.addChild(root_0, contentSpec16.getTree());\r
 719             char_literal17=(Token)match(input,29,FOLLOW_29_in_elementDecl593); if (state.failed) return retval;\r
 720             if ( state.backtracking==0 ) {\r
 721             char_literal17_tree = (Object)adaptor.create(char_literal17);\r
 722             adaptor.addChild(root_0, char_literal17_tree);\r
 723             }\r
 724 \r
 725             }\r
 726 \r
 727             retval.stop = input.LT(-1);\r
 728 \r
 729             if ( state.backtracking==0 ) {\r
 730 \r
 731             retval.tree = (Object)adaptor.rulePostProcessing(root_0);\r
 732             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);\r
 733             }\r
 734         }\r
 735         catch (RecognitionException re) {\r
 736             reportError(re);\r
 737             recover(input,re);\r
 738         retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);\r
 739 \r
 740         }\r
 741         finally {\r
 742         }\r
 743         return retval;\r
 744     }\r
 745     // $ANTLR end "elementDecl"\r
 746 \r
 747     public static class contentSpec_return extends ParserRuleReturnScope {\r
 748         Object tree;\r
 749         public Object getTree() { return tree; }\r
 750     };\r
 751 \r
 752     // $ANTLR start "contentSpec"\r
 753     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:137:1: contentSpec : ( 'EMPTY' | 'ANY' | mixed | children );\r
 754     public final DTDParser.contentSpec_return contentSpec() throws RecognitionException {\r
 755         DTDParser.contentSpec_return retval = new DTDParser.contentSpec_return();\r
 756         retval.start = input.LT(1);\r
 757 \r
 758         Object root_0 = null;\r
 759 \r
 760         Token string_literal18=null;\r
 761         Token string_literal19=null;\r
 762         DTDParser.mixed_return mixed20 = null;\r
 763 \r
 764         DTDParser.children_return children21 = null;\r
 765 \r
 766 \r
 767         Object string_literal18_tree=null;\r
 768         Object string_literal19_tree=null;\r
 769 \r
 770         try {\r
 771             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:137:12: ( 'EMPTY' | 'ANY' | mixed | children )\r
 772             int alt6=4;\r
 773             switch ( input.LA(1) ) {\r
 774             case 30:\r
 775                 {\r
 776                 alt6=1;\r
 777                 }\r
 778                 break;\r
 779             case 31:\r
 780                 {\r
 781                 alt6=2;\r
 782                 }\r
 783                 break;\r
 784             case LParen:\r
 785                 {\r
 786                 int LA6_3 = input.LA(2);\r
 787 \r
 788                 if ( (LA6_3==36) ) {\r
 789                     alt6=3;\r
 790                 }\r
 791                 else if ( (LA6_3==LParen||LA6_3==Name) ) {\r
 792                     alt6=4;\r
 793                 }\r
 794                 else {\r
 795                     if (state.backtracking>0) {state.failed=true; return retval;}\r
 796                     NoViableAltException nvae =\r
 797                         new NoViableAltException("", 6, 3, input);\r
 798 \r
 799                     throw nvae;\r
 800                 }\r
 801                 }\r
 802                 break;\r
 803             default:\r
 804                 if (state.backtracking>0) {state.failed=true; return retval;}\r
 805                 NoViableAltException nvae =\r
 806                     new NoViableAltException("", 6, 0, input);\r
 807 \r
 808                 throw nvae;\r
 809             }\r
 810 \r
 811             switch (alt6) {\r
 812                 case 1 :\r
 813                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:137:14: 'EMPTY'\r
 814                     {\r
 815                     root_0 = (Object)adaptor.nil();\r
 816 \r
 817                     string_literal18=(Token)match(input,30,FOLLOW_30_in_contentSpec603); if (state.failed) return retval;\r
 818                     if ( state.backtracking==0 ) {\r
 819                     string_literal18_tree = (Object)adaptor.create(string_literal18);\r
 820                     adaptor.addChild(root_0, string_literal18_tree);\r
 821                     }\r
 822 \r
 823                     }\r
 824                     break;\r
 825                 case 2 :\r
 826                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:137:24: 'ANY'\r
 827                     {\r
 828                     root_0 = (Object)adaptor.nil();\r
 829 \r
 830                     string_literal19=(Token)match(input,31,FOLLOW_31_in_contentSpec607); if (state.failed) return retval;\r
 831                     if ( state.backtracking==0 ) {\r
 832                     string_literal19_tree = (Object)adaptor.create(string_literal19);\r
 833                     adaptor.addChild(root_0, string_literal19_tree);\r
 834                     }\r
 835 \r
 836                     }\r
 837                     break;\r
 838                 case 3 :\r
 839                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:137:32: mixed\r
 840                     {\r
 841                     root_0 = (Object)adaptor.nil();\r
 842 \r
 843                     pushFollow(FOLLOW_mixed_in_contentSpec611);\r
 844                     mixed20=mixed();\r
 845 \r
 846                     state._fsp--;\r
 847                     if (state.failed) return retval;\r
 848                     if ( state.backtracking==0 ) adaptor.addChild(root_0, mixed20.getTree());\r
 849 \r
 850                     }\r
 851                     break;\r
 852                 case 4 :\r
 853                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:137:40: children\r
 854                     {\r
 855                     root_0 = (Object)adaptor.nil();\r
 856 \r
 857                     pushFollow(FOLLOW_children_in_contentSpec615);\r
 858                     children21=children();\r
 859 \r
 860                     state._fsp--;\r
 861                     if (state.failed) return retval;\r
 862                     if ( state.backtracking==0 ) adaptor.addChild(root_0, children21.getTree());\r
 863 \r
 864                     }\r
 865                     break;\r
 866 \r
 867             }\r
 868             retval.stop = input.LT(-1);\r
 869 \r
 870             if ( state.backtracking==0 ) {\r
 871 \r
 872             retval.tree = (Object)adaptor.rulePostProcessing(root_0);\r
 873             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);\r
 874             }\r
 875         }\r
 876         catch (RecognitionException re) {\r
 877             reportError(re);\r
 878             recover(input,re);\r
 879         retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);\r
 880 \r
 881         }\r
 882         finally {\r
 883         }\r
 884         return retval;\r
 885     }\r
 886     // $ANTLR end "contentSpec"\r
 887 \r
 888     public static class children_return extends ParserRuleReturnScope {\r
 889         Object tree;\r
 890         public Object getTree() { return tree; }\r
 891     };\r
 892 \r
 893     // $ANTLR start "children"\r
 894     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:140:1: children : ( ( choice )=> choice ( '?' | '*' | '+' )? | ( seq )=> seq ( '?' | '*' | '+' )? );\r
 895     public final DTDParser.children_return children() throws RecognitionException {\r
 896         DTDParser.children_return retval = new DTDParser.children_return();\r
 897         retval.start = input.LT(1);\r
 898 \r
 899         Object root_0 = null;\r
 900 \r
 901         Token set23=null;\r
 902         Token set25=null;\r
 903         DTDParser.choice_return choice22 = null;\r
 904 \r
 905         DTDParser.seq_return seq24 = null;\r
 906 \r
 907 \r
 908         Object set23_tree=null;\r
 909         Object set25_tree=null;\r
 910 \r
 911         try {\r
 912             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:141:1: ( ( choice )=> choice ( '?' | '*' | '+' )? | ( seq )=> seq ( '?' | '*' | '+' )? )\r
 913             int alt9=2;\r
 914             int LA9_0 = input.LA(1);\r
 915 \r
 916             if ( (LA9_0==LParen) ) {\r
 917                 int LA9_1 = input.LA(2);\r
 918 \r
 919                 if ( (synpred1_DTD()) ) {\r
 920                     alt9=1;\r
 921                 }\r
 922                 else if ( (synpred2_DTD()) ) {\r
 923                     alt9=2;\r
 924                 }\r
 925                 else {\r
 926                     if (state.backtracking>0) {state.failed=true; return retval;}\r
 927                     NoViableAltException nvae =\r
 928                         new NoViableAltException("", 9, 1, input);\r
 929 \r
 930                     throw nvae;\r
 931                 }\r
 932             }\r
 933             else {\r
 934                 if (state.backtracking>0) {state.failed=true; return retval;}\r
 935                 NoViableAltException nvae =\r
 936                     new NoViableAltException("", 9, 0, input);\r
 937 \r
 938                 throw nvae;\r
 939             }\r
 940             switch (alt9) {\r
 941                 case 1 :\r
 942                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:141:3: ( choice )=> choice ( '?' | '*' | '+' )?\r
 943                     {\r
 944                     root_0 = (Object)adaptor.nil();\r
 945 \r
 946                     pushFollow(FOLLOW_choice_in_children634);\r
 947                     choice22=choice();\r
 948 \r
 949                     state._fsp--;\r
 950                     if (state.failed) return retval;\r
 951                     if ( state.backtracking==0 ) adaptor.addChild(root_0, choice22.getTree());\r
 952                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:141:23: ( '?' | '*' | '+' )?\r
 953                     int alt7=2;\r
 954                     int LA7_0 = input.LA(1);\r
 955 \r
 956                     if ( ((LA7_0>=32 && LA7_0<=34)) ) {\r
 957                         alt7=1;\r
 958                     }\r
 959                     switch (alt7) {\r
 960                         case 1 :\r
 961                             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:\r
 962                             {\r
 963                             set23=(Token)input.LT(1);\r
 964                             if ( (input.LA(1)>=32 && input.LA(1)<=34) ) {\r
 965                                 input.consume();\r
 966                                 if ( state.backtracking==0 ) adaptor.addChild(root_0, (Object)adaptor.create(set23));\r
 967                                 state.errorRecovery=false;state.failed=false;\r
 968                             }\r
 969                             else {\r
 970                                 if (state.backtracking>0) {state.failed=true; return retval;}\r
 971                                 MismatchedSetException mse = new MismatchedSetException(null,input);\r
 972                                 throw mse;\r
 973                             }\r
 974 \r
 975 \r
 976                             }\r
 977                             break;\r
 978 \r
 979                     }\r
 980 \r
 981 \r
 982                     }\r
 983                     break;\r
 984                 case 2 :\r
 985                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:142:3: ( seq )=> seq ( '?' | '*' | '+' )?\r
 986                     {\r
 987                     root_0 = (Object)adaptor.nil();\r
 988 \r
 989                     pushFollow(FOLLOW_seq_in_children658);\r
 990                     seq24=seq();\r
 991 \r
 992                     state._fsp--;\r
 993                     if (state.failed) return retval;\r
 994                     if ( state.backtracking==0 ) adaptor.addChild(root_0, seq24.getTree());\r
 995                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:142:16: ( '?' | '*' | '+' )?\r
 996                     int alt8=2;\r
 997                     int LA8_0 = input.LA(1);\r
 998 \r
 999                     if ( ((LA8_0>=32 && LA8_0<=34)) ) {\r
1000                         alt8=1;\r
1001                     }\r
1002                     switch (alt8) {\r
1003                         case 1 :\r
1004                             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:\r
1005                             {\r
1006                             set25=(Token)input.LT(1);\r
1007                             if ( (input.LA(1)>=32 && input.LA(1)<=34) ) {\r
1008                                 input.consume();\r
1009                                 if ( state.backtracking==0 ) adaptor.addChild(root_0, (Object)adaptor.create(set25));\r
1010                                 state.errorRecovery=false;state.failed=false;\r
1011                             }\r
1012                             else {\r
1013                                 if (state.backtracking>0) {state.failed=true; return retval;}\r
1014                                 MismatchedSetException mse = new MismatchedSetException(null,input);\r
1015                                 throw mse;\r
1016                             }\r
1017 \r
1018 \r
1019                             }\r
1020                             break;\r
1021 \r
1022                     }\r
1023 \r
1024 \r
1025                     }\r
1026                     break;\r
1027 \r
1028             }\r
1029             retval.stop = input.LT(-1);\r
1030 \r
1031             if ( state.backtracking==0 ) {\r
1032 \r
1033             retval.tree = (Object)adaptor.rulePostProcessing(root_0);\r
1034             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);\r
1035             }\r
1036         }\r
1037         catch (RecognitionException re) {\r
1038             reportError(re);\r
1039             recover(input,re);\r
1040         retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);\r
1041 \r
1042         }\r
1043         finally {\r
1044         }\r
1045         return retval;\r
1046     }\r
1047     // $ANTLR end "children"\r
1048 \r
1049     public static class cp_return extends ParserRuleReturnScope {\r
1050         Object tree;\r
1051         public Object getTree() { return tree; }\r
1052     };\r
1053 \r
1054     // $ANTLR start "cp"\r
1055     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:145:1: cp : ( ( Name )=> Name ( '?' | '*' | '+' )? | ( choice )=> choice ( '?' | '*' | '+' )? | ( seq )=> seq ( '?' | '*' | '+' )? );\r
1056     public final DTDParser.cp_return cp() throws RecognitionException {\r
1057         DTDParser.cp_return retval = new DTDParser.cp_return();\r
1058         retval.start = input.LT(1);\r
1059 \r
1060         Object root_0 = null;\r
1061 \r
1062         Token Name26=null;\r
1063         Token set27=null;\r
1064         Token set29=null;\r
1065         Token set31=null;\r
1066         DTDParser.choice_return choice28 = null;\r
1067 \r
1068         DTDParser.seq_return seq30 = null;\r
1069 \r
1070 \r
1071         Object Name26_tree=null;\r
1072         Object set27_tree=null;\r
1073         Object set29_tree=null;\r
1074         Object set31_tree=null;\r
1075 \r
1076         try {\r
1077             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:146:1: ( ( Name )=> Name ( '?' | '*' | '+' )? | ( choice )=> choice ( '?' | '*' | '+' )? | ( seq )=> seq ( '?' | '*' | '+' )? )\r
1078             int alt13=3;\r
1079             int LA13_0 = input.LA(1);\r
1080 \r
1081             if ( (LA13_0==Name) && (synpred3_DTD())) {\r
1082                 alt13=1;\r
1083             }\r
1084             else if ( (LA13_0==LParen) ) {\r
1085                 int LA13_2 = input.LA(2);\r
1086 \r
1087                 if ( (synpred4_DTD()) ) {\r
1088                     alt13=2;\r
1089                 }\r
1090                 else if ( (synpred5_DTD()) ) {\r
1091                     alt13=3;\r
1092                 }\r
1093                 else {\r
1094                     if (state.backtracking>0) {state.failed=true; return retval;}\r
1095                     NoViableAltException nvae =\r
1096                         new NoViableAltException("", 13, 2, input);\r
1097 \r
1098                     throw nvae;\r
1099                 }\r
1100             }\r
1101             else {\r
1102                 if (state.backtracking>0) {state.failed=true; return retval;}\r
1103                 NoViableAltException nvae =\r
1104                     new NoViableAltException("", 13, 0, input);\r
1105 \r
1106                 throw nvae;\r
1107             }\r
1108             switch (alt13) {\r
1109                 case 1 :\r
1110                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:146:3: ( Name )=> Name ( '?' | '*' | '+' )?\r
1111                     {\r
1112                     root_0 = (Object)adaptor.nil();\r
1113 \r
1114                     Name26=(Token)match(input,Name,FOLLOW_Name_in_cp688); if (state.failed) return retval;\r
1115                     if ( state.backtracking==0 ) {\r
1116                     Name26_tree = (Object)adaptor.create(Name26);\r
1117                     adaptor.addChild(root_0, Name26_tree);\r
1118                     }\r
1119                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:146:19: ( '?' | '*' | '+' )?\r
1120                     int alt10=2;\r
1121                     int LA10_0 = input.LA(1);\r
1122 \r
1123                     if ( ((LA10_0>=32 && LA10_0<=34)) ) {\r
1124                         alt10=1;\r
1125                     }\r
1126                     switch (alt10) {\r
1127                         case 1 :\r
1128                             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:\r
1129                             {\r
1130                             set27=(Token)input.LT(1);\r
1131                             if ( (input.LA(1)>=32 && input.LA(1)<=34) ) {\r
1132                                 input.consume();\r
1133                                 if ( state.backtracking==0 ) adaptor.addChild(root_0, (Object)adaptor.create(set27));\r
1134                                 state.errorRecovery=false;state.failed=false;\r
1135                             }\r
1136                             else {\r
1137                                 if (state.backtracking>0) {state.failed=true; return retval;}\r
1138                                 MismatchedSetException mse = new MismatchedSetException(null,input);\r
1139                                 throw mse;\r
1140                             }\r
1141 \r
1142 \r
1143                             }\r
1144                             break;\r
1145 \r
1146                     }\r
1147 \r
1148 \r
1149                     }\r
1150                     break;\r
1151                 case 2 :\r
1152                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:147:4: ( choice )=> choice ( '?' | '*' | '+' )?\r
1153                     {\r
1154                     root_0 = (Object)adaptor.nil();\r
1155 \r
1156                     pushFollow(FOLLOW_choice_in_cp713);\r
1157                     choice28=choice();\r
1158 \r
1159                     state._fsp--;\r
1160                     if (state.failed) return retval;\r
1161                     if ( state.backtracking==0 ) adaptor.addChild(root_0, choice28.getTree());\r
1162                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:147:24: ( '?' | '*' | '+' )?\r
1163                     int alt11=2;\r
1164                     int LA11_0 = input.LA(1);\r
1165 \r
1166                     if ( ((LA11_0>=32 && LA11_0<=34)) ) {\r
1167                         alt11=1;\r
1168                     }\r
1169                     switch (alt11) {\r
1170                         case 1 :\r
1171                             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:\r
1172                             {\r
1173                             set29=(Token)input.LT(1);\r
1174                             if ( (input.LA(1)>=32 && input.LA(1)<=34) ) {\r
1175                                 input.consume();\r
1176                                 if ( state.backtracking==0 ) adaptor.addChild(root_0, (Object)adaptor.create(set29));\r
1177                                 state.errorRecovery=false;state.failed=false;\r
1178                             }\r
1179                             else {\r
1180                                 if (state.backtracking>0) {state.failed=true; return retval;}\r
1181                                 MismatchedSetException mse = new MismatchedSetException(null,input);\r
1182                                 throw mse;\r
1183                             }\r
1184 \r
1185 \r
1186                             }\r
1187                             break;\r
1188 \r
1189                     }\r
1190 \r
1191 \r
1192                     }\r
1193                     break;\r
1194                 case 3 :\r
1195                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:148:4: ( seq )=> seq ( '?' | '*' | '+' )?\r
1196                     {\r
1197                     root_0 = (Object)adaptor.nil();\r
1198 \r
1199                     pushFollow(FOLLOW_seq_in_cp738);\r
1200                     seq30=seq();\r
1201 \r
1202                     state._fsp--;\r
1203                     if (state.failed) return retval;\r
1204                     if ( state.backtracking==0 ) adaptor.addChild(root_0, seq30.getTree());\r
1205                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:148:18: ( '?' | '*' | '+' )?\r
1206                     int alt12=2;\r
1207                     int LA12_0 = input.LA(1);\r
1208 \r
1209                     if ( ((LA12_0>=32 && LA12_0<=34)) ) {\r
1210                         alt12=1;\r
1211                     }\r
1212                     switch (alt12) {\r
1213                         case 1 :\r
1214                             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:\r
1215                             {\r
1216                             set31=(Token)input.LT(1);\r
1217                             if ( (input.LA(1)>=32 && input.LA(1)<=34) ) {\r
1218                                 input.consume();\r
1219                                 if ( state.backtracking==0 ) adaptor.addChild(root_0, (Object)adaptor.create(set31));\r
1220                                 state.errorRecovery=false;state.failed=false;\r
1221                             }\r
1222                             else {\r
1223                                 if (state.backtracking>0) {state.failed=true; return retval;}\r
1224                                 MismatchedSetException mse = new MismatchedSetException(null,input);\r
1225                                 throw mse;\r
1226                             }\r
1227 \r
1228 \r
1229                             }\r
1230                             break;\r
1231 \r
1232                     }\r
1233 \r
1234 \r
1235                     }\r
1236                     break;\r
1237 \r
1238             }\r
1239             retval.stop = input.LT(-1);\r
1240 \r
1241             if ( state.backtracking==0 ) {\r
1242 \r
1243             retval.tree = (Object)adaptor.rulePostProcessing(root_0);\r
1244             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);\r
1245             }\r
1246         }\r
1247         catch (RecognitionException re) {\r
1248             reportError(re);\r
1249             recover(input,re);\r
1250         retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);\r
1251 \r
1252         }\r
1253         finally {\r
1254         }\r
1255         return retval;\r
1256     }\r
1257     // $ANTLR end "cp"\r
1258 \r
1259     public static class choice_return extends ParserRuleReturnScope {\r
1260         Object tree;\r
1261         public Object getTree() { return tree; }\r
1262     };\r
1263 \r
1264     // $ANTLR start "choice"\r
1265     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:151:1: choice : LParen cp ( '|' cp )* RParen ;\r
1266     public final DTDParser.choice_return choice() throws RecognitionException {\r
1267         DTDParser.choice_return retval = new DTDParser.choice_return();\r
1268         retval.start = input.LT(1);\r
1269 \r
1270         Object root_0 = null;\r
1271 \r
1272         Token LParen32=null;\r
1273         Token char_literal34=null;\r
1274         Token RParen36=null;\r
1275         DTDParser.cp_return cp33 = null;\r
1276 \r
1277         DTDParser.cp_return cp35 = null;\r
1278 \r
1279 \r
1280         Object LParen32_tree=null;\r
1281         Object char_literal34_tree=null;\r
1282         Object RParen36_tree=null;\r
1283 \r
1284         try {\r
1285             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:151:7: ( LParen cp ( '|' cp )* RParen )\r
1286             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:151:9: LParen cp ( '|' cp )* RParen\r
1287             {\r
1288             root_0 = (Object)adaptor.nil();\r
1289 \r
1290             LParen32=(Token)match(input,LParen,FOLLOW_LParen_in_choice760); if (state.failed) return retval;\r
1291             if ( state.backtracking==0 ) {\r
1292             LParen32_tree = (Object)adaptor.create(LParen32);\r
1293             adaptor.addChild(root_0, LParen32_tree);\r
1294             }\r
1295             pushFollow(FOLLOW_cp_in_choice762);\r
1296             cp33=cp();\r
1297 \r
1298             state._fsp--;\r
1299             if (state.failed) return retval;\r
1300             if ( state.backtracking==0 ) adaptor.addChild(root_0, cp33.getTree());\r
1301             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:151:19: ( '|' cp )*\r
1302             loop14:\r
1303             do {\r
1304                 int alt14=2;\r
1305                 int LA14_0 = input.LA(1);\r
1306 \r
1307                 if ( (LA14_0==35) ) {\r
1308                     alt14=1;\r
1309                 }\r
1310 \r
1311 \r
1312                 switch (alt14) {\r
1313                 case 1 :\r
1314                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:151:20: '|' cp\r
1315                     {\r
1316                     char_literal34=(Token)match(input,35,FOLLOW_35_in_choice765); if (state.failed) return retval;\r
1317                     if ( state.backtracking==0 ) {\r
1318                     char_literal34_tree = (Object)adaptor.create(char_literal34);\r
1319                     adaptor.addChild(root_0, char_literal34_tree);\r
1320                     }\r
1321                     pushFollow(FOLLOW_cp_in_choice767);\r
1322                     cp35=cp();\r
1323 \r
1324                     state._fsp--;\r
1325                     if (state.failed) return retval;\r
1326                     if ( state.backtracking==0 ) adaptor.addChild(root_0, cp35.getTree());\r
1327 \r
1328                     }\r
1329                     break;\r
1330 \r
1331                 default :\r
1332                     break loop14;\r
1333                 }\r
1334             } while (true);\r
1335 \r
1336             RParen36=(Token)match(input,RParen,FOLLOW_RParen_in_choice771); if (state.failed) return retval;\r
1337             if ( state.backtracking==0 ) {\r
1338             RParen36_tree = (Object)adaptor.create(RParen36);\r
1339             adaptor.addChild(root_0, RParen36_tree);\r
1340             }\r
1341 \r
1342             }\r
1343 \r
1344             retval.stop = input.LT(-1);\r
1345 \r
1346             if ( state.backtracking==0 ) {\r
1347 \r
1348             retval.tree = (Object)adaptor.rulePostProcessing(root_0);\r
1349             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);\r
1350             }\r
1351         }\r
1352         catch (RecognitionException re) {\r
1353             reportError(re);\r
1354             recover(input,re);\r
1355         retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);\r
1356 \r
1357         }\r
1358         finally {\r
1359         }\r
1360         return retval;\r
1361     }\r
1362     // $ANTLR end "choice"\r
1363 \r
1364     public static class seq_return extends ParserRuleReturnScope {\r
1365         Object tree;\r
1366         public Object getTree() { return tree; }\r
1367     };\r
1368 \r
1369     // $ANTLR start "seq"\r
1370     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:154:1: seq : ( LParen cp Comma )=> LParen cp ( Comma cp )+ RParen ;\r
1371     public final DTDParser.seq_return seq() throws RecognitionException {\r
1372         DTDParser.seq_return retval = new DTDParser.seq_return();\r
1373         retval.start = input.LT(1);\r
1374 \r
1375         Object root_0 = null;\r
1376 \r
1377         Token LParen37=null;\r
1378         Token Comma39=null;\r
1379         Token RParen41=null;\r
1380         DTDParser.cp_return cp38 = null;\r
1381 \r
1382         DTDParser.cp_return cp40 = null;\r
1383 \r
1384 \r
1385         Object LParen37_tree=null;\r
1386         Object Comma39_tree=null;\r
1387         Object RParen41_tree=null;\r
1388 \r
1389         try {\r
1390             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:154:4: ( ( LParen cp Comma )=> LParen cp ( Comma cp )+ RParen )\r
1391             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:154:6: ( LParen cp Comma )=> LParen cp ( Comma cp )+ RParen\r
1392             {\r
1393             root_0 = (Object)adaptor.nil();\r
1394 \r
1395             LParen37=(Token)match(input,LParen,FOLLOW_LParen_in_seq791); if (state.failed) return retval;\r
1396             if ( state.backtracking==0 ) {\r
1397             LParen37_tree = (Object)adaptor.create(LParen37);\r
1398             adaptor.addChild(root_0, LParen37_tree);\r
1399             }\r
1400             pushFollow(FOLLOW_cp_in_seq793);\r
1401             cp38=cp();\r
1402 \r
1403             state._fsp--;\r
1404             if (state.failed) return retval;\r
1405             if ( state.backtracking==0 ) adaptor.addChild(root_0, cp38.getTree());\r
1406             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:154:37: ( Comma cp )+\r
1407             int cnt15=0;\r
1408             loop15:\r
1409             do {\r
1410                 int alt15=2;\r
1411                 int LA15_0 = input.LA(1);\r
1412 \r
1413                 if ( (LA15_0==Comma) ) {\r
1414                     alt15=1;\r
1415                 }\r
1416 \r
1417 \r
1418                 switch (alt15) {\r
1419                 case 1 :\r
1420                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:154:38: Comma cp\r
1421                     {\r
1422                     Comma39=(Token)match(input,Comma,FOLLOW_Comma_in_seq796); if (state.failed) return retval;\r
1423                     if ( state.backtracking==0 ) {\r
1424                     Comma39_tree = (Object)adaptor.create(Comma39);\r
1425                     adaptor.addChild(root_0, Comma39_tree);\r
1426                     }\r
1427                     pushFollow(FOLLOW_cp_in_seq798);\r
1428                     cp40=cp();\r
1429 \r
1430                     state._fsp--;\r
1431                     if (state.failed) return retval;\r
1432                     if ( state.backtracking==0 ) adaptor.addChild(root_0, cp40.getTree());\r
1433 \r
1434                     }\r
1435                     break;\r
1436 \r
1437                 default :\r
1438                     if ( cnt15 >= 1 ) break loop15;\r
1439                     if (state.backtracking>0) {state.failed=true; return retval;}\r
1440                         EarlyExitException eee =\r
1441                             new EarlyExitException(15, input);\r
1442                         throw eee;\r
1443                 }\r
1444                 cnt15++;\r
1445             } while (true);\r
1446 \r
1447             RParen41=(Token)match(input,RParen,FOLLOW_RParen_in_seq802); if (state.failed) return retval;\r
1448             if ( state.backtracking==0 ) {\r
1449             RParen41_tree = (Object)adaptor.create(RParen41);\r
1450             adaptor.addChild(root_0, RParen41_tree);\r
1451             }\r
1452 \r
1453             }\r
1454 \r
1455             retval.stop = input.LT(-1);\r
1456 \r
1457             if ( state.backtracking==0 ) {\r
1458 \r
1459             retval.tree = (Object)adaptor.rulePostProcessing(root_0);\r
1460             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);\r
1461             }\r
1462         }\r
1463         catch (RecognitionException re) {\r
1464             reportError(re);\r
1465             recover(input,re);\r
1466         retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);\r
1467 \r
1468         }\r
1469         finally {\r
1470         }\r
1471         return retval;\r
1472     }\r
1473     // $ANTLR end "seq"\r
1474 \r
1475     public static class mixed_return extends ParserRuleReturnScope {\r
1476         Object tree;\r
1477         public Object getTree() { return tree; }\r
1478     };\r
1479 \r
1480     // $ANTLR start "mixed"\r
1481     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:157:1: mixed : ( LParen '#PCDATA' ( '|' Name )* RParen '*' | LParen '#PCDATA' RParen );\r
1482     public final DTDParser.mixed_return mixed() throws RecognitionException {\r
1483         DTDParser.mixed_return retval = new DTDParser.mixed_return();\r
1484         retval.start = input.LT(1);\r
1485 \r
1486         Object root_0 = null;\r
1487 \r
1488         Token LParen42=null;\r
1489         Token string_literal43=null;\r
1490         Token char_literal44=null;\r
1491         Token Name45=null;\r
1492         Token RParen46=null;\r
1493         Token char_literal47=null;\r
1494         Token LParen48=null;\r
1495         Token string_literal49=null;\r
1496         Token RParen50=null;\r
1497 \r
1498         Object LParen42_tree=null;\r
1499         Object string_literal43_tree=null;\r
1500         Object char_literal44_tree=null;\r
1501         Object Name45_tree=null;\r
1502         Object RParen46_tree=null;\r
1503         Object char_literal47_tree=null;\r
1504         Object LParen48_tree=null;\r
1505         Object string_literal49_tree=null;\r
1506         Object RParen50_tree=null;\r
1507 \r
1508         try {\r
1509             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:157:6: ( LParen '#PCDATA' ( '|' Name )* RParen '*' | LParen '#PCDATA' RParen )\r
1510             int alt17=2;\r
1511             int LA17_0 = input.LA(1);\r
1512 \r
1513             if ( (LA17_0==LParen) ) {\r
1514                 int LA17_1 = input.LA(2);\r
1515 \r
1516                 if ( (LA17_1==36) ) {\r
1517                     int LA17_2 = input.LA(3);\r
1518 \r
1519                     if ( (LA17_2==RParen) ) {\r
1520                         int LA17_3 = input.LA(4);\r
1521 \r
1522                         if ( (LA17_3==33) ) {\r
1523                             alt17=1;\r
1524                         }\r
1525                         else if ( (LA17_3==29) ) {\r
1526                             alt17=2;\r
1527                         }\r
1528                         else {\r
1529                             if (state.backtracking>0) {state.failed=true; return retval;}\r
1530                             NoViableAltException nvae =\r
1531                                 new NoViableAltException("", 17, 3, input);\r
1532 \r
1533                             throw nvae;\r
1534                         }\r
1535                     }\r
1536                     else if ( (LA17_2==35) ) {\r
1537                         alt17=1;\r
1538                     }\r
1539                     else {\r
1540                         if (state.backtracking>0) {state.failed=true; return retval;}\r
1541                         NoViableAltException nvae =\r
1542                             new NoViableAltException("", 17, 2, input);\r
1543 \r
1544                         throw nvae;\r
1545                     }\r
1546                 }\r
1547                 else {\r
1548                     if (state.backtracking>0) {state.failed=true; return retval;}\r
1549                     NoViableAltException nvae =\r
1550                         new NoViableAltException("", 17, 1, input);\r
1551 \r
1552                     throw nvae;\r
1553                 }\r
1554             }\r
1555             else {\r
1556                 if (state.backtracking>0) {state.failed=true; return retval;}\r
1557                 NoViableAltException nvae =\r
1558                     new NoViableAltException("", 17, 0, input);\r
1559 \r
1560                 throw nvae;\r
1561             }\r
1562             switch (alt17) {\r
1563                 case 1 :\r
1564                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:157:8: LParen '#PCDATA' ( '|' Name )* RParen '*'\r
1565                     {\r
1566                     root_0 = (Object)adaptor.nil();\r
1567 \r
1568                     LParen42=(Token)match(input,LParen,FOLLOW_LParen_in_mixed812); if (state.failed) return retval;\r
1569                     if ( state.backtracking==0 ) {\r
1570                     LParen42_tree = (Object)adaptor.create(LParen42);\r
1571                     adaptor.addChild(root_0, LParen42_tree);\r
1572                     }\r
1573                     string_literal43=(Token)match(input,36,FOLLOW_36_in_mixed814); if (state.failed) return retval;\r
1574                     if ( state.backtracking==0 ) {\r
1575                     string_literal43_tree = (Object)adaptor.create(string_literal43);\r
1576                     adaptor.addChild(root_0, string_literal43_tree);\r
1577                     }\r
1578                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:157:25: ( '|' Name )*\r
1579                     loop16:\r
1580                     do {\r
1581                         int alt16=2;\r
1582                         int LA16_0 = input.LA(1);\r
1583 \r
1584                         if ( (LA16_0==35) ) {\r
1585                             alt16=1;\r
1586                         }\r
1587 \r
1588 \r
1589                         switch (alt16) {\r
1590                         case 1 :\r
1591                             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:157:26: '|' Name\r
1592                             {\r
1593                             char_literal44=(Token)match(input,35,FOLLOW_35_in_mixed817); if (state.failed) return retval;\r
1594                             if ( state.backtracking==0 ) {\r
1595                             char_literal44_tree = (Object)adaptor.create(char_literal44);\r
1596                             adaptor.addChild(root_0, char_literal44_tree);\r
1597                             }\r
1598                             Name45=(Token)match(input,Name,FOLLOW_Name_in_mixed819); if (state.failed) return retval;\r
1599                             if ( state.backtracking==0 ) {\r
1600                             Name45_tree = (Object)adaptor.create(Name45);\r
1601                             adaptor.addChild(root_0, Name45_tree);\r
1602                             }\r
1603 \r
1604                             }\r
1605                             break;\r
1606 \r
1607                         default :\r
1608                             break loop16;\r
1609                         }\r
1610                     } while (true);\r
1611 \r
1612                     RParen46=(Token)match(input,RParen,FOLLOW_RParen_in_mixed823); if (state.failed) return retval;\r
1613                     if ( state.backtracking==0 ) {\r
1614                     RParen46_tree = (Object)adaptor.create(RParen46);\r
1615                     adaptor.addChild(root_0, RParen46_tree);\r
1616                     }\r
1617                     char_literal47=(Token)match(input,33,FOLLOW_33_in_mixed825); if (state.failed) return retval;\r
1618                     if ( state.backtracking==0 ) {\r
1619                     char_literal47_tree = (Object)adaptor.create(char_literal47);\r
1620                     adaptor.addChild(root_0, char_literal47_tree);\r
1621                     }\r
1622 \r
1623                     }\r
1624                     break;\r
1625                 case 2 :\r
1626                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:158:5: LParen '#PCDATA' RParen\r
1627                     {\r
1628                     root_0 = (Object)adaptor.nil();\r
1629 \r
1630                     LParen48=(Token)match(input,LParen,FOLLOW_LParen_in_mixed832); if (state.failed) return retval;\r
1631                     if ( state.backtracking==0 ) {\r
1632                     LParen48_tree = (Object)adaptor.create(LParen48);\r
1633                     adaptor.addChild(root_0, LParen48_tree);\r
1634                     }\r
1635                     string_literal49=(Token)match(input,36,FOLLOW_36_in_mixed834); if (state.failed) return retval;\r
1636                     if ( state.backtracking==0 ) {\r
1637                     string_literal49_tree = (Object)adaptor.create(string_literal49);\r
1638                     adaptor.addChild(root_0, string_literal49_tree);\r
1639                     }\r
1640                     RParen50=(Token)match(input,RParen,FOLLOW_RParen_in_mixed836); if (state.failed) return retval;\r
1641                     if ( state.backtracking==0 ) {\r
1642                     RParen50_tree = (Object)adaptor.create(RParen50);\r
1643                     adaptor.addChild(root_0, RParen50_tree);\r
1644                     }\r
1645 \r
1646                     }\r
1647                     break;\r
1648 \r
1649             }\r
1650             retval.stop = input.LT(-1);\r
1651 \r
1652             if ( state.backtracking==0 ) {\r
1653 \r
1654             retval.tree = (Object)adaptor.rulePostProcessing(root_0);\r
1655             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);\r
1656             }\r
1657         }\r
1658         catch (RecognitionException re) {\r
1659             reportError(re);\r
1660             recover(input,re);\r
1661         retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);\r
1662 \r
1663         }\r
1664         finally {\r
1665         }\r
1666         return retval;\r
1667     }\r
1668     // $ANTLR end "mixed"\r
1669 \r
1670     public static class attlistDecl_return extends ParserRuleReturnScope {\r
1671         Object tree;\r
1672         public Object getTree() { return tree; }\r
1673     };\r
1674 \r
1675     // $ANTLR start "attlistDecl"\r
1676     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:161:1: attlistDecl : '<!ATTLIST' Name ( attDef )* '>' ;\r
1677     public final DTDParser.attlistDecl_return attlistDecl() throws RecognitionException {\r
1678         DTDParser.attlistDecl_return retval = new DTDParser.attlistDecl_return();\r
1679         retval.start = input.LT(1);\r
1680 \r
1681         Object root_0 = null;\r
1682 \r
1683         Token string_literal51=null;\r
1684         Token Name52=null;\r
1685         Token char_literal54=null;\r
1686         DTDParser.attDef_return attDef53 = null;\r
1687 \r
1688 \r
1689         Object string_literal51_tree=null;\r
1690         Object Name52_tree=null;\r
1691         Object char_literal54_tree=null;\r
1692 \r
1693         try {\r
1694             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:161:12: ( '<!ATTLIST' Name ( attDef )* '>' )\r
1695             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:161:14: '<!ATTLIST' Name ( attDef )* '>'\r
1696             {\r
1697             root_0 = (Object)adaptor.nil();\r
1698 \r
1699             string_literal51=(Token)match(input,37,FOLLOW_37_in_attlistDecl848); if (state.failed) return retval;\r
1700             if ( state.backtracking==0 ) {\r
1701             string_literal51_tree = (Object)adaptor.create(string_literal51);\r
1702             adaptor.addChild(root_0, string_literal51_tree);\r
1703             }\r
1704             Name52=(Token)match(input,Name,FOLLOW_Name_in_attlistDecl850); if (state.failed) return retval;\r
1705             if ( state.backtracking==0 ) {\r
1706             Name52_tree = (Object)adaptor.create(Name52);\r
1707             adaptor.addChild(root_0, Name52_tree);\r
1708             }\r
1709             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:161:31: ( attDef )*\r
1710             loop18:\r
1711             do {\r
1712                 int alt18=2;\r
1713                 int LA18_0 = input.LA(1);\r
1714 \r
1715                 if ( (LA18_0==Name) ) {\r
1716                     alt18=1;\r
1717                 }\r
1718 \r
1719 \r
1720                 switch (alt18) {\r
1721                 case 1 :\r
1722                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:161:31: attDef\r
1723                     {\r
1724                     pushFollow(FOLLOW_attDef_in_attlistDecl852);\r
1725                     attDef53=attDef();\r
1726 \r
1727                     state._fsp--;\r
1728                     if (state.failed) return retval;\r
1729                     if ( state.backtracking==0 ) adaptor.addChild(root_0, attDef53.getTree());\r
1730 \r
1731                     }\r
1732                     break;\r
1733 \r
1734                 default :\r
1735                     break loop18;\r
1736                 }\r
1737             } while (true);\r
1738 \r
1739             char_literal54=(Token)match(input,29,FOLLOW_29_in_attlistDecl855); if (state.failed) return retval;\r
1740             if ( state.backtracking==0 ) {\r
1741             char_literal54_tree = (Object)adaptor.create(char_literal54);\r
1742             adaptor.addChild(root_0, char_literal54_tree);\r
1743             }\r
1744 \r
1745             }\r
1746 \r
1747             retval.stop = input.LT(-1);\r
1748 \r
1749             if ( state.backtracking==0 ) {\r
1750 \r
1751             retval.tree = (Object)adaptor.rulePostProcessing(root_0);\r
1752             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);\r
1753             }\r
1754         }\r
1755         catch (RecognitionException re) {\r
1756             reportError(re);\r
1757             recover(input,re);\r
1758         retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);\r
1759 \r
1760         }\r
1761         finally {\r
1762         }\r
1763         return retval;\r
1764     }\r
1765     // $ANTLR end "attlistDecl"\r
1766 \r
1767     public static class attDef_return extends ParserRuleReturnScope {\r
1768         Object tree;\r
1769         public Object getTree() { return tree; }\r
1770     };\r
1771 \r
1772     // $ANTLR start "attDef"\r
1773     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:164:1: attDef : Name attType DefaultDecl ;\r
1774     public final DTDParser.attDef_return attDef() throws RecognitionException {\r
1775         DTDParser.attDef_return retval = new DTDParser.attDef_return();\r
1776         retval.start = input.LT(1);\r
1777 \r
1778         Object root_0 = null;\r
1779 \r
1780         Token Name55=null;\r
1781         Token DefaultDecl57=null;\r
1782         DTDParser.attType_return attType56 = null;\r
1783 \r
1784 \r
1785         Object Name55_tree=null;\r
1786         Object DefaultDecl57_tree=null;\r
1787 \r
1788         try {\r
1789             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:164:7: ( Name attType DefaultDecl )\r
1790             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:164:9: Name attType DefaultDecl\r
1791             {\r
1792             root_0 = (Object)adaptor.nil();\r
1793 \r
1794             Name55=(Token)match(input,Name,FOLLOW_Name_in_attDef865); if (state.failed) return retval;\r
1795             if ( state.backtracking==0 ) {\r
1796             Name55_tree = (Object)adaptor.create(Name55);\r
1797             adaptor.addChild(root_0, Name55_tree);\r
1798             }\r
1799             pushFollow(FOLLOW_attType_in_attDef867);\r
1800             attType56=attType();\r
1801 \r
1802             state._fsp--;\r
1803             if (state.failed) return retval;\r
1804             if ( state.backtracking==0 ) adaptor.addChild(root_0, attType56.getTree());\r
1805             DefaultDecl57=(Token)match(input,DefaultDecl,FOLLOW_DefaultDecl_in_attDef869); if (state.failed) return retval;\r
1806             if ( state.backtracking==0 ) {\r
1807             DefaultDecl57_tree = (Object)adaptor.create(DefaultDecl57);\r
1808             adaptor.addChild(root_0, DefaultDecl57_tree);\r
1809             }\r
1810 \r
1811             }\r
1812 \r
1813             retval.stop = input.LT(-1);\r
1814 \r
1815             if ( state.backtracking==0 ) {\r
1816 \r
1817             retval.tree = (Object)adaptor.rulePostProcessing(root_0);\r
1818             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);\r
1819             }\r
1820         }\r
1821         catch (RecognitionException re) {\r
1822             reportError(re);\r
1823             recover(input,re);\r
1824         retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);\r
1825 \r
1826         }\r
1827         finally {\r
1828         }\r
1829         return retval;\r
1830     }\r
1831     // $ANTLR end "attDef"\r
1832 \r
1833     public static class attType_return extends ParserRuleReturnScope {\r
1834         Object tree;\r
1835         public Object getTree() { return tree; }\r
1836     };\r
1837 \r
1838     // $ANTLR start "attType"\r
1839     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:167:1: attType : ( stringType | tokenizedType | enumeratedType );\r
1840     public final DTDParser.attType_return attType() throws RecognitionException {\r
1841         DTDParser.attType_return retval = new DTDParser.attType_return();\r
1842         retval.start = input.LT(1);\r
1843 \r
1844         Object root_0 = null;\r
1845 \r
1846         DTDParser.stringType_return stringType58 = null;\r
1847 \r
1848         DTDParser.tokenizedType_return tokenizedType59 = null;\r
1849 \r
1850         DTDParser.enumeratedType_return enumeratedType60 = null;\r
1851 \r
1852 \r
1853 \r
1854         try {\r
1855             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:167:8: ( stringType | tokenizedType | enumeratedType )\r
1856             int alt19=3;\r
1857             switch ( input.LA(1) ) {\r
1858             case 39:\r
1859                 {\r
1860                 alt19=1;\r
1861                 }\r
1862                 break;\r
1863             case 40:\r
1864             case 41:\r
1865             case 42:\r
1866             case 43:\r
1867             case 44:\r
1868             case 45:\r
1869             case 46:\r
1870                 {\r
1871                 alt19=2;\r
1872                 }\r
1873                 break;\r
1874             case LParen:\r
1875             case 38:\r
1876                 {\r
1877                 alt19=3;\r
1878                 }\r
1879                 break;\r
1880             default:\r
1881                 if (state.backtracking>0) {state.failed=true; return retval;}\r
1882                 NoViableAltException nvae =\r
1883                     new NoViableAltException("", 19, 0, input);\r
1884 \r
1885                 throw nvae;\r
1886             }\r
1887 \r
1888             switch (alt19) {\r
1889                 case 1 :\r
1890                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:167:10: stringType\r
1891                     {\r
1892                     root_0 = (Object)adaptor.nil();\r
1893 \r
1894                     pushFollow(FOLLOW_stringType_in_attType880);\r
1895                     stringType58=stringType();\r
1896 \r
1897                     state._fsp--;\r
1898                     if (state.failed) return retval;\r
1899                     if ( state.backtracking==0 ) adaptor.addChild(root_0, stringType58.getTree());\r
1900 \r
1901                     }\r
1902                     break;\r
1903                 case 2 :\r
1904                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:167:23: tokenizedType\r
1905                     {\r
1906                     root_0 = (Object)adaptor.nil();\r
1907 \r
1908                     pushFollow(FOLLOW_tokenizedType_in_attType884);\r
1909                     tokenizedType59=tokenizedType();\r
1910 \r
1911                     state._fsp--;\r
1912                     if (state.failed) return retval;\r
1913                     if ( state.backtracking==0 ) adaptor.addChild(root_0, tokenizedType59.getTree());\r
1914 \r
1915                     }\r
1916                     break;\r
1917                 case 3 :\r
1918                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:167:39: enumeratedType\r
1919                     {\r
1920                     root_0 = (Object)adaptor.nil();\r
1921 \r
1922                     pushFollow(FOLLOW_enumeratedType_in_attType888);\r
1923                     enumeratedType60=enumeratedType();\r
1924 \r
1925                     state._fsp--;\r
1926                     if (state.failed) return retval;\r
1927                     if ( state.backtracking==0 ) adaptor.addChild(root_0, enumeratedType60.getTree());\r
1928 \r
1929                     }\r
1930                     break;\r
1931 \r
1932             }\r
1933             retval.stop = input.LT(-1);\r
1934 \r
1935             if ( state.backtracking==0 ) {\r
1936 \r
1937             retval.tree = (Object)adaptor.rulePostProcessing(root_0);\r
1938             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);\r
1939             }\r
1940         }\r
1941         catch (RecognitionException re) {\r
1942             reportError(re);\r
1943             recover(input,re);\r
1944         retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);\r
1945 \r
1946         }\r
1947         finally {\r
1948         }\r
1949         return retval;\r
1950     }\r
1951     // $ANTLR end "attType"\r
1952 \r
1953     public static class enumeration_return extends ParserRuleReturnScope {\r
1954         Object tree;\r
1955         public Object getTree() { return tree; }\r
1956     };\r
1957 \r
1958     // $ANTLR start "enumeration"\r
1959     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:169:1: enumeration : LParen Name ( '|' Name )* RParen ;\r
1960     public final DTDParser.enumeration_return enumeration() throws RecognitionException {\r
1961         DTDParser.enumeration_return retval = new DTDParser.enumeration_return();\r
1962         retval.start = input.LT(1);\r
1963 \r
1964         Object root_0 = null;\r
1965 \r
1966         Token LParen61=null;\r
1967         Token Name62=null;\r
1968         Token char_literal63=null;\r
1969         Token Name64=null;\r
1970         Token RParen65=null;\r
1971 \r
1972         Object LParen61_tree=null;\r
1973         Object Name62_tree=null;\r
1974         Object char_literal63_tree=null;\r
1975         Object Name64_tree=null;\r
1976         Object RParen65_tree=null;\r
1977 \r
1978         try {\r
1979             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:169:12: ( LParen Name ( '|' Name )* RParen )\r
1980             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:169:14: LParen Name ( '|' Name )* RParen\r
1981             {\r
1982             root_0 = (Object)adaptor.nil();\r
1983 \r
1984             LParen61=(Token)match(input,LParen,FOLLOW_LParen_in_enumeration895); if (state.failed) return retval;\r
1985             if ( state.backtracking==0 ) {\r
1986             LParen61_tree = (Object)adaptor.create(LParen61);\r
1987             adaptor.addChild(root_0, LParen61_tree);\r
1988             }\r
1989             Name62=(Token)match(input,Name,FOLLOW_Name_in_enumeration897); if (state.failed) return retval;\r
1990             if ( state.backtracking==0 ) {\r
1991             Name62_tree = (Object)adaptor.create(Name62);\r
1992             adaptor.addChild(root_0, Name62_tree);\r
1993             }\r
1994             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:169:26: ( '|' Name )*\r
1995             loop20:\r
1996             do {\r
1997                 int alt20=2;\r
1998                 int LA20_0 = input.LA(1);\r
1999 \r
2000                 if ( (LA20_0==35) ) {\r
2001                     alt20=1;\r
2002                 }\r
2003 \r
2004 \r
2005                 switch (alt20) {\r
2006                 case 1 :\r
2007                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:169:27: '|' Name\r
2008                     {\r
2009                     char_literal63=(Token)match(input,35,FOLLOW_35_in_enumeration900); if (state.failed) return retval;\r
2010                     if ( state.backtracking==0 ) {\r
2011                     char_literal63_tree = (Object)adaptor.create(char_literal63);\r
2012                     adaptor.addChild(root_0, char_literal63_tree);\r
2013                     }\r
2014                     Name64=(Token)match(input,Name,FOLLOW_Name_in_enumeration902); if (state.failed) return retval;\r
2015                     if ( state.backtracking==0 ) {\r
2016                     Name64_tree = (Object)adaptor.create(Name64);\r
2017                     adaptor.addChild(root_0, Name64_tree);\r
2018                     }\r
2019 \r
2020                     }\r
2021                     break;\r
2022 \r
2023                 default :\r
2024                     break loop20;\r
2025                 }\r
2026             } while (true);\r
2027 \r
2028             RParen65=(Token)match(input,RParen,FOLLOW_RParen_in_enumeration906); if (state.failed) return retval;\r
2029             if ( state.backtracking==0 ) {\r
2030             RParen65_tree = (Object)adaptor.create(RParen65);\r
2031             adaptor.addChild(root_0, RParen65_tree);\r
2032             }\r
2033 \r
2034             }\r
2035 \r
2036             retval.stop = input.LT(-1);\r
2037 \r
2038             if ( state.backtracking==0 ) {\r
2039 \r
2040             retval.tree = (Object)adaptor.rulePostProcessing(root_0);\r
2041             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);\r
2042             }\r
2043         }\r
2044         catch (RecognitionException re) {\r
2045             reportError(re);\r
2046             recover(input,re);\r
2047         retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);\r
2048 \r
2049         }\r
2050         finally {\r
2051         }\r
2052         return retval;\r
2053     }\r
2054     // $ANTLR end "enumeration"\r
2055 \r
2056     public static class enumeratedType_return extends ParserRuleReturnScope {\r
2057         Object tree;\r
2058         public Object getTree() { return tree; }\r
2059     };\r
2060 \r
2061     // $ANTLR start "enumeratedType"\r
2062     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:170:1: enumeratedType : ( notationType | enumeration );\r
2063     public final DTDParser.enumeratedType_return enumeratedType() throws RecognitionException {\r
2064         DTDParser.enumeratedType_return retval = new DTDParser.enumeratedType_return();\r
2065         retval.start = input.LT(1);\r
2066 \r
2067         Object root_0 = null;\r
2068 \r
2069         DTDParser.notationType_return notationType66 = null;\r
2070 \r
2071         DTDParser.enumeration_return enumeration67 = null;\r
2072 \r
2073 \r
2074 \r
2075         try {\r
2076             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:170:15: ( notationType | enumeration )\r
2077             int alt21=2;\r
2078             int LA21_0 = input.LA(1);\r
2079 \r
2080             if ( (LA21_0==38) ) {\r
2081                 alt21=1;\r
2082             }\r
2083             else if ( (LA21_0==LParen) ) {\r
2084                 alt21=2;\r
2085             }\r
2086             else {\r
2087                 if (state.backtracking>0) {state.failed=true; return retval;}\r
2088                 NoViableAltException nvae =\r
2089                     new NoViableAltException("", 21, 0, input);\r
2090 \r
2091                 throw nvae;\r
2092             }\r
2093             switch (alt21) {\r
2094                 case 1 :\r
2095                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:170:17: notationType\r
2096                     {\r
2097                     root_0 = (Object)adaptor.nil();\r
2098 \r
2099                     pushFollow(FOLLOW_notationType_in_enumeratedType912);\r
2100                     notationType66=notationType();\r
2101 \r
2102                     state._fsp--;\r
2103                     if (state.failed) return retval;\r
2104                     if ( state.backtracking==0 ) adaptor.addChild(root_0, notationType66.getTree());\r
2105 \r
2106                     }\r
2107                     break;\r
2108                 case 2 :\r
2109                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:170:32: enumeration\r
2110                     {\r
2111                     root_0 = (Object)adaptor.nil();\r
2112 \r
2113                     pushFollow(FOLLOW_enumeration_in_enumeratedType916);\r
2114                     enumeration67=enumeration();\r
2115 \r
2116                     state._fsp--;\r
2117                     if (state.failed) return retval;\r
2118                     if ( state.backtracking==0 ) adaptor.addChild(root_0, enumeration67.getTree());\r
2119 \r
2120                     }\r
2121                     break;\r
2122 \r
2123             }\r
2124             retval.stop = input.LT(-1);\r
2125 \r
2126             if ( state.backtracking==0 ) {\r
2127 \r
2128             retval.tree = (Object)adaptor.rulePostProcessing(root_0);\r
2129             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);\r
2130             }\r
2131         }\r
2132         catch (RecognitionException re) {\r
2133             reportError(re);\r
2134             recover(input,re);\r
2135         retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);\r
2136 \r
2137         }\r
2138         finally {\r
2139         }\r
2140         return retval;\r
2141     }\r
2142     // $ANTLR end "enumeratedType"\r
2143 \r
2144     public static class notationType_return extends ParserRuleReturnScope {\r
2145         Object tree;\r
2146         public Object getTree() { return tree; }\r
2147     };\r
2148 \r
2149     // $ANTLR start "notationType"\r
2150     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:171:1: notationType : 'NOTATION' LParen Name ( '|' Name )* RParen ;\r
2151     public final DTDParser.notationType_return notationType() throws RecognitionException {\r
2152         DTDParser.notationType_return retval = new DTDParser.notationType_return();\r
2153         retval.start = input.LT(1);\r
2154 \r
2155         Object root_0 = null;\r
2156 \r
2157         Token string_literal68=null;\r
2158         Token LParen69=null;\r
2159         Token Name70=null;\r
2160         Token char_literal71=null;\r
2161         Token Name72=null;\r
2162         Token RParen73=null;\r
2163 \r
2164         Object string_literal68_tree=null;\r
2165         Object LParen69_tree=null;\r
2166         Object Name70_tree=null;\r
2167         Object char_literal71_tree=null;\r
2168         Object Name72_tree=null;\r
2169         Object RParen73_tree=null;\r
2170 \r
2171         try {\r
2172             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:171:13: ( 'NOTATION' LParen Name ( '|' Name )* RParen )\r
2173             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:171:15: 'NOTATION' LParen Name ( '|' Name )* RParen\r
2174             {\r
2175             root_0 = (Object)adaptor.nil();\r
2176 \r
2177             string_literal68=(Token)match(input,38,FOLLOW_38_in_notationType922); if (state.failed) return retval;\r
2178             if ( state.backtracking==0 ) {\r
2179             string_literal68_tree = (Object)adaptor.create(string_literal68);\r
2180             adaptor.addChild(root_0, string_literal68_tree);\r
2181             }\r
2182             LParen69=(Token)match(input,LParen,FOLLOW_LParen_in_notationType924); if (state.failed) return retval;\r
2183             if ( state.backtracking==0 ) {\r
2184             LParen69_tree = (Object)adaptor.create(LParen69);\r
2185             adaptor.addChild(root_0, LParen69_tree);\r
2186             }\r
2187             Name70=(Token)match(input,Name,FOLLOW_Name_in_notationType926); if (state.failed) return retval;\r
2188             if ( state.backtracking==0 ) {\r
2189             Name70_tree = (Object)adaptor.create(Name70);\r
2190             adaptor.addChild(root_0, Name70_tree);\r
2191             }\r
2192             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:171:38: ( '|' Name )*\r
2193             loop22:\r
2194             do {\r
2195                 int alt22=2;\r
2196                 int LA22_0 = input.LA(1);\r
2197 \r
2198                 if ( (LA22_0==35) ) {\r
2199                     alt22=1;\r
2200                 }\r
2201 \r
2202 \r
2203                 switch (alt22) {\r
2204                 case 1 :\r
2205                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:171:39: '|' Name\r
2206                     {\r
2207                     char_literal71=(Token)match(input,35,FOLLOW_35_in_notationType929); if (state.failed) return retval;\r
2208                     if ( state.backtracking==0 ) {\r
2209                     char_literal71_tree = (Object)adaptor.create(char_literal71);\r
2210                     adaptor.addChild(root_0, char_literal71_tree);\r
2211                     }\r
2212                     Name72=(Token)match(input,Name,FOLLOW_Name_in_notationType931); if (state.failed) return retval;\r
2213                     if ( state.backtracking==0 ) {\r
2214                     Name72_tree = (Object)adaptor.create(Name72);\r
2215                     adaptor.addChild(root_0, Name72_tree);\r
2216                     }\r
2217 \r
2218                     }\r
2219                     break;\r
2220 \r
2221                 default :\r
2222                     break loop22;\r
2223                 }\r
2224             } while (true);\r
2225 \r
2226             RParen73=(Token)match(input,RParen,FOLLOW_RParen_in_notationType935); if (state.failed) return retval;\r
2227             if ( state.backtracking==0 ) {\r
2228             RParen73_tree = (Object)adaptor.create(RParen73);\r
2229             adaptor.addChild(root_0, RParen73_tree);\r
2230             }\r
2231 \r
2232             }\r
2233 \r
2234             retval.stop = input.LT(-1);\r
2235 \r
2236             if ( state.backtracking==0 ) {\r
2237 \r
2238             retval.tree = (Object)adaptor.rulePostProcessing(root_0);\r
2239             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);\r
2240             }\r
2241         }\r
2242         catch (RecognitionException re) {\r
2243             reportError(re);\r
2244             recover(input,re);\r
2245         retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);\r
2246 \r
2247         }\r
2248         finally {\r
2249         }\r
2250         return retval;\r
2251     }\r
2252     // $ANTLR end "notationType"\r
2253 \r
2254     public static class stringType_return extends ParserRuleReturnScope {\r
2255         Object tree;\r
2256         public Object getTree() { return tree; }\r
2257     };\r
2258 \r
2259     // $ANTLR start "stringType"\r
2260     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:173:1: stringType : 'CDATA' ;\r
2261     public final DTDParser.stringType_return stringType() throws RecognitionException {\r
2262         DTDParser.stringType_return retval = new DTDParser.stringType_return();\r
2263         retval.start = input.LT(1);\r
2264 \r
2265         Object root_0 = null;\r
2266 \r
2267         Token string_literal74=null;\r
2268 \r
2269         Object string_literal74_tree=null;\r
2270 \r
2271         try {\r
2272             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:173:11: ( 'CDATA' )\r
2273             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:173:13: 'CDATA'\r
2274             {\r
2275             root_0 = (Object)adaptor.nil();\r
2276 \r
2277             string_literal74=(Token)match(input,39,FOLLOW_39_in_stringType942); if (state.failed) return retval;\r
2278             if ( state.backtracking==0 ) {\r
2279             string_literal74_tree = (Object)adaptor.create(string_literal74);\r
2280             adaptor.addChild(root_0, string_literal74_tree);\r
2281             }\r
2282 \r
2283             }\r
2284 \r
2285             retval.stop = input.LT(-1);\r
2286 \r
2287             if ( state.backtracking==0 ) {\r
2288 \r
2289             retval.tree = (Object)adaptor.rulePostProcessing(root_0);\r
2290             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);\r
2291             }\r
2292         }\r
2293         catch (RecognitionException re) {\r
2294             reportError(re);\r
2295             recover(input,re);\r
2296         retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);\r
2297 \r
2298         }\r
2299         finally {\r
2300         }\r
2301         return retval;\r
2302     }\r
2303     // $ANTLR end "stringType"\r
2304 \r
2305     public static class tokenizedType_return extends ParserRuleReturnScope {\r
2306         Object tree;\r
2307         public Object getTree() { return tree; }\r
2308     };\r
2309 \r
2310     // $ANTLR start "tokenizedType"\r
2311     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:176:1: tokenizedType : ( 'ID' | 'IDREF' | 'IDREFS' | 'ENTITY' | 'ENTITIES' | 'NMTOKEN' | 'NMTOKENS' );\r
2312     public final DTDParser.tokenizedType_return tokenizedType() throws RecognitionException {\r
2313         DTDParser.tokenizedType_return retval = new DTDParser.tokenizedType_return();\r
2314         retval.start = input.LT(1);\r
2315 \r
2316         Object root_0 = null;\r
2317 \r
2318         Token set75=null;\r
2319 \r
2320         Object set75_tree=null;\r
2321 \r
2322         try {\r
2323             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:176:14: ( 'ID' | 'IDREF' | 'IDREFS' | 'ENTITY' | 'ENTITIES' | 'NMTOKEN' | 'NMTOKENS' )\r
2324             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:\r
2325             {\r
2326             root_0 = (Object)adaptor.nil();\r
2327 \r
2328             set75=(Token)input.LT(1);\r
2329             if ( (input.LA(1)>=40 && input.LA(1)<=46) ) {\r
2330                 input.consume();\r
2331                 if ( state.backtracking==0 ) adaptor.addChild(root_0, (Object)adaptor.create(set75));\r
2332                 state.errorRecovery=false;state.failed=false;\r
2333             }\r
2334             else {\r
2335                 if (state.backtracking>0) {state.failed=true; return retval;}\r
2336                 MismatchedSetException mse = new MismatchedSetException(null,input);\r
2337                 throw mse;\r
2338             }\r
2339 \r
2340 \r
2341             }\r
2342 \r
2343             retval.stop = input.LT(-1);\r
2344 \r
2345             if ( state.backtracking==0 ) {\r
2346 \r
2347             retval.tree = (Object)adaptor.rulePostProcessing(root_0);\r
2348             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);\r
2349             }\r
2350         }\r
2351         catch (RecognitionException re) {\r
2352             reportError(re);\r
2353             recover(input,re);\r
2354         retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);\r
2355 \r
2356         }\r
2357         finally {\r
2358         }\r
2359         return retval;\r
2360     }\r
2361     // $ANTLR end "tokenizedType"\r
2362 \r
2363     // $ANTLR start synpred1_DTD\r
2364     public final void synpred1_DTD_fragment() throws RecognitionException {   \r
2365         // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:141:3: ( choice )\r
2366         // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:141:4: choice\r
2367         {\r
2368         pushFollow(FOLLOW_choice_in_synpred1_DTD629);\r
2369         choice();\r
2370 \r
2371         state._fsp--;\r
2372         if (state.failed) return ;\r
2373 \r
2374         }\r
2375     }\r
2376     // $ANTLR end synpred1_DTD\r
2377 \r
2378     // $ANTLR start synpred2_DTD\r
2379     public final void synpred2_DTD_fragment() throws RecognitionException {   \r
2380         // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:142:3: ( seq )\r
2381         // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:142:4: seq\r
2382         {\r
2383         pushFollow(FOLLOW_seq_in_synpred2_DTD653);\r
2384         seq();\r
2385 \r
2386         state._fsp--;\r
2387         if (state.failed) return ;\r
2388 \r
2389         }\r
2390     }\r
2391     // $ANTLR end synpred2_DTD\r
2392 \r
2393     // $ANTLR start synpred3_DTD\r
2394     public final void synpred3_DTD_fragment() throws RecognitionException {   \r
2395         // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:146:3: ( Name )\r
2396         // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:146:4: Name\r
2397         {\r
2398         match(input,Name,FOLLOW_Name_in_synpred3_DTD683); if (state.failed) return ;\r
2399 \r
2400         }\r
2401     }\r
2402     // $ANTLR end synpred3_DTD\r
2403 \r
2404     // $ANTLR start synpred4_DTD\r
2405     public final void synpred4_DTD_fragment() throws RecognitionException {   \r
2406         // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:147:4: ( choice )\r
2407         // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:147:5: choice\r
2408         {\r
2409         pushFollow(FOLLOW_choice_in_synpred4_DTD708);\r
2410         choice();\r
2411 \r
2412         state._fsp--;\r
2413         if (state.failed) return ;\r
2414 \r
2415         }\r
2416     }\r
2417     // $ANTLR end synpred4_DTD\r
2418 \r
2419     // $ANTLR start synpred5_DTD\r
2420     public final void synpred5_DTD_fragment() throws RecognitionException {   \r
2421         // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:148:4: ( seq )\r
2422         // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\util\\xml\\dtd\\impl\\DTD.g:148:5: seq\r
2423         {\r
2424         pushFollow(FOLLOW_seq_in_synpred5_DTD733);\r
2425         seq();\r
2426 \r
2427         state._fsp--;\r
2428         if (state.failed) return ;\r
2429 \r
2430         }\r
2431     }\r
2432     // $ANTLR end synpred5_DTD\r
2433 \r
2434     // Delegated rules\r
2435 \r
2436     public final boolean synpred3_DTD() {\r
2437         state.backtracking++;\r
2438         int start = input.mark();\r
2439         try {\r
2440             synpred3_DTD_fragment(); // can never throw exception\r
2441         } catch (RecognitionException re) {\r
2442             System.err.println("impossible: "+re);\r
2443         }\r
2444         boolean success = !state.failed;\r
2445         input.rewind(start);\r
2446         state.backtracking--;\r
2447         state.failed=false;\r
2448         return success;\r
2449     }\r
2450     public final boolean synpred2_DTD() {\r
2451         state.backtracking++;\r
2452         int start = input.mark();\r
2453         try {\r
2454             synpred2_DTD_fragment(); // can never throw exception\r
2455         } catch (RecognitionException re) {\r
2456             System.err.println("impossible: "+re);\r
2457         }\r
2458         boolean success = !state.failed;\r
2459         input.rewind(start);\r
2460         state.backtracking--;\r
2461         state.failed=false;\r
2462         return success;\r
2463     }\r
2464     public final boolean synpred4_DTD() {\r
2465         state.backtracking++;\r
2466         int start = input.mark();\r
2467         try {\r
2468             synpred4_DTD_fragment(); // can never throw exception\r
2469         } catch (RecognitionException re) {\r
2470             System.err.println("impossible: "+re);\r
2471         }\r
2472         boolean success = !state.failed;\r
2473         input.rewind(start);\r
2474         state.backtracking--;\r
2475         state.failed=false;\r
2476         return success;\r
2477     }\r
2478     public final boolean synpred1_DTD() {\r
2479         state.backtracking++;\r
2480         int start = input.mark();\r
2481         try {\r
2482             synpred1_DTD_fragment(); // can never throw exception\r
2483         } catch (RecognitionException re) {\r
2484             System.err.println("impossible: "+re);\r
2485         }\r
2486         boolean success = !state.failed;\r
2487         input.rewind(start);\r
2488         state.backtracking--;\r
2489         state.failed=false;\r
2490         return success;\r
2491     }\r
2492     public final boolean synpred5_DTD() {\r
2493         state.backtracking++;\r
2494         int start = input.mark();\r
2495         try {\r
2496             synpred5_DTD_fragment(); // can never throw exception\r
2497         } catch (RecognitionException re) {\r
2498             System.err.println("impossible: "+re);\r
2499         }\r
2500         boolean success = !state.failed;\r
2501         input.rewind(start);\r
2502         state.backtracking--;\r
2503         state.failed=false;\r
2504         return success;\r
2505     }\r
2506 \r
2507 \r
2508  \r
2509 \r
2510     public static final BitSet FOLLOW_Digits_in_integerLiteral491 = new BitSet(new long[]{0x0000000000000002L});\r
2511     public static final BitSet FOLLOW_Dot_in_decimalLiteral497 = new BitSet(new long[]{0x0000000000040000L});\r
2512     public static final BitSet FOLLOW_Digits_in_decimalLiteral499 = new BitSet(new long[]{0x0000000000000002L});\r
2513     public static final BitSet FOLLOW_Digits_in_decimalLiteral502 = new BitSet(new long[]{0x0000000000001000L});\r
2514     public static final BitSet FOLLOW_Dot_in_decimalLiteral504 = new BitSet(new long[]{0x0000000000040000L});\r
2515     public static final BitSet FOLLOW_Digits_in_decimalLiteral506 = new BitSet(new long[]{0x0000000000000002L});\r
2516     public static final BitSet FOLLOW_numericLiteral_in_literal517 = new BitSet(new long[]{0x0000000000000002L});\r
2517     public static final BitSet FOLLOW_StringLiteral_in_literal530 = new BitSet(new long[]{0x0000000000000002L});\r
2518     public static final BitSet FOLLOW_integerLiteral_in_numericLiteral550 = new BitSet(new long[]{0x0000000000000002L});\r
2519     public static final BitSet FOLLOW_decimalLiteral_in_numericLiteral556 = new BitSet(new long[]{0x0000000000000002L});\r
2520     public static final BitSet FOLLOW_markupdecl_in_dtd567 = new BitSet(new long[]{0x0000002010000002L});\r
2521     public static final BitSet FOLLOW_elementDecl_in_markupdecl575 = new BitSet(new long[]{0x0000000000000002L});\r
2522     public static final BitSet FOLLOW_attlistDecl_in_markupdecl579 = new BitSet(new long[]{0x0000000000000002L});\r
2523     public static final BitSet FOLLOW_Element_in_elementDecl587 = new BitSet(new long[]{0x0000000000400000L});\r
2524     public static final BitSet FOLLOW_Name_in_elementDecl589 = new BitSet(new long[]{0x00000000C0004000L});\r
2525     public static final BitSet FOLLOW_contentSpec_in_elementDecl591 = new BitSet(new long[]{0x0000000020000000L});\r
2526     public static final BitSet FOLLOW_29_in_elementDecl593 = new BitSet(new long[]{0x0000000000000002L});\r
2527     public static final BitSet FOLLOW_30_in_contentSpec603 = new BitSet(new long[]{0x0000000000000002L});\r
2528     public static final BitSet FOLLOW_31_in_contentSpec607 = new BitSet(new long[]{0x0000000000000002L});\r
2529     public static final BitSet FOLLOW_mixed_in_contentSpec611 = new BitSet(new long[]{0x0000000000000002L});\r
2530     public static final BitSet FOLLOW_children_in_contentSpec615 = new BitSet(new long[]{0x0000000000000002L});\r
2531     public static final BitSet FOLLOW_choice_in_children634 = new BitSet(new long[]{0x0000000700000002L});\r
2532     public static final BitSet FOLLOW_set_in_children637 = new BitSet(new long[]{0x0000000000000002L});\r
2533     public static final BitSet FOLLOW_seq_in_children658 = new BitSet(new long[]{0x0000000700000002L});\r
2534     public static final BitSet FOLLOW_set_in_children660 = new BitSet(new long[]{0x0000000000000002L});\r
2535     public static final BitSet FOLLOW_Name_in_cp688 = new BitSet(new long[]{0x0000000700000002L});\r
2536     public static final BitSet FOLLOW_set_in_cp691 = new BitSet(new long[]{0x0000000000000002L});\r
2537     public static final BitSet FOLLOW_choice_in_cp713 = new BitSet(new long[]{0x0000000700000002L});\r
2538     public static final BitSet FOLLOW_set_in_cp716 = new BitSet(new long[]{0x0000000000000002L});\r
2539     public static final BitSet FOLLOW_seq_in_cp738 = new BitSet(new long[]{0x0000000700000002L});\r
2540     public static final BitSet FOLLOW_set_in_cp741 = new BitSet(new long[]{0x0000000000000002L});\r
2541     public static final BitSet FOLLOW_LParen_in_choice760 = new BitSet(new long[]{0x00000000C0404000L});\r
2542     public static final BitSet FOLLOW_cp_in_choice762 = new BitSet(new long[]{0x0000000800008000L});\r
2543     public static final BitSet FOLLOW_35_in_choice765 = new BitSet(new long[]{0x00000000C0404000L});\r
2544     public static final BitSet FOLLOW_cp_in_choice767 = new BitSet(new long[]{0x0000000800008000L});\r
2545     public static final BitSet FOLLOW_RParen_in_choice771 = new BitSet(new long[]{0x0000000000000002L});\r
2546     public static final BitSet FOLLOW_LParen_in_seq791 = new BitSet(new long[]{0x00000000C0404000L});\r
2547     public static final BitSet FOLLOW_cp_in_seq793 = new BitSet(new long[]{0x0000000000000200L});\r
2548     public static final BitSet FOLLOW_Comma_in_seq796 = new BitSet(new long[]{0x00000000C0404000L});\r
2549     public static final BitSet FOLLOW_cp_in_seq798 = new BitSet(new long[]{0x0000000000008200L});\r
2550     public static final BitSet FOLLOW_RParen_in_seq802 = new BitSet(new long[]{0x0000000000000002L});\r
2551     public static final BitSet FOLLOW_LParen_in_mixed812 = new BitSet(new long[]{0x0000001000000000L});\r
2552     public static final BitSet FOLLOW_36_in_mixed814 = new BitSet(new long[]{0x0000000800008000L});\r
2553     public static final BitSet FOLLOW_35_in_mixed817 = new BitSet(new long[]{0x0000000000400000L});\r
2554     public static final BitSet FOLLOW_Name_in_mixed819 = new BitSet(new long[]{0x0000000800008000L});\r
2555     public static final BitSet FOLLOW_RParen_in_mixed823 = new BitSet(new long[]{0x0000000200000000L});\r
2556     public static final BitSet FOLLOW_33_in_mixed825 = new BitSet(new long[]{0x0000000000000002L});\r
2557     public static final BitSet FOLLOW_LParen_in_mixed832 = new BitSet(new long[]{0x0000001000000000L});\r
2558     public static final BitSet FOLLOW_36_in_mixed834 = new BitSet(new long[]{0x0000000000008000L});\r
2559     public static final BitSet FOLLOW_RParen_in_mixed836 = new BitSet(new long[]{0x0000000000000002L});\r
2560     public static final BitSet FOLLOW_37_in_attlistDecl848 = new BitSet(new long[]{0x0000000000400000L});\r
2561     public static final BitSet FOLLOW_Name_in_attlistDecl850 = new BitSet(new long[]{0x0000000020400000L});\r
2562     public static final BitSet FOLLOW_attDef_in_attlistDecl852 = new BitSet(new long[]{0x0000000020400000L});\r
2563     public static final BitSet FOLLOW_29_in_attlistDecl855 = new BitSet(new long[]{0x0000000000000002L});\r
2564     public static final BitSet FOLLOW_Name_in_attDef865 = new BitSet(new long[]{0x00007FC000004000L});\r
2565     public static final BitSet FOLLOW_attType_in_attDef867 = new BitSet(new long[]{0x0000000008000000L});\r
2566     public static final BitSet FOLLOW_DefaultDecl_in_attDef869 = new BitSet(new long[]{0x0000000000000002L});\r
2567     public static final BitSet FOLLOW_stringType_in_attType880 = new BitSet(new long[]{0x0000000000000002L});\r
2568     public static final BitSet FOLLOW_tokenizedType_in_attType884 = new BitSet(new long[]{0x0000000000000002L});\r
2569     public static final BitSet FOLLOW_enumeratedType_in_attType888 = new BitSet(new long[]{0x0000000000000002L});\r
2570     public static final BitSet FOLLOW_LParen_in_enumeration895 = new BitSet(new long[]{0x0000000000400000L});\r
2571     public static final BitSet FOLLOW_Name_in_enumeration897 = new BitSet(new long[]{0x0000000800008000L});\r
2572     public static final BitSet FOLLOW_35_in_enumeration900 = new BitSet(new long[]{0x0000000000400000L});\r
2573     public static final BitSet FOLLOW_Name_in_enumeration902 = new BitSet(new long[]{0x0000000800008000L});\r
2574     public static final BitSet FOLLOW_RParen_in_enumeration906 = new BitSet(new long[]{0x0000000000000002L});\r
2575     public static final BitSet FOLLOW_notationType_in_enumeratedType912 = new BitSet(new long[]{0x0000000000000002L});\r
2576     public static final BitSet FOLLOW_enumeration_in_enumeratedType916 = new BitSet(new long[]{0x0000000000000002L});\r
2577     public static final BitSet FOLLOW_38_in_notationType922 = new BitSet(new long[]{0x0000000000004000L});\r
2578     public static final BitSet FOLLOW_LParen_in_notationType924 = new BitSet(new long[]{0x0000000000400000L});\r
2579     public static final BitSet FOLLOW_Name_in_notationType926 = new BitSet(new long[]{0x0000000800008000L});\r
2580     public static final BitSet FOLLOW_35_in_notationType929 = new BitSet(new long[]{0x0000000000400000L});\r
2581     public static final BitSet FOLLOW_Name_in_notationType931 = new BitSet(new long[]{0x0000000800008000L});\r
2582     public static final BitSet FOLLOW_RParen_in_notationType935 = new BitSet(new long[]{0x0000000000000002L});\r
2583     public static final BitSet FOLLOW_39_in_stringType942 = new BitSet(new long[]{0x0000000000000002L});\r
2584     public static final BitSet FOLLOW_set_in_tokenizedType0 = new BitSet(new long[]{0x0000000000000002L});\r
2585     public static final BitSet FOLLOW_choice_in_synpred1_DTD629 = new BitSet(new long[]{0x0000000000000002L});\r
2586     public static final BitSet FOLLOW_seq_in_synpred2_DTD653 = new BitSet(new long[]{0x0000000000000002L});\r
2587     public static final BitSet FOLLOW_Name_in_synpred3_DTD683 = new BitSet(new long[]{0x0000000000000002L});\r
2588     public static final BitSet FOLLOW_choice_in_synpred4_DTD708 = new BitSet(new long[]{0x0000000000000002L});\r
2589     public static final BitSet FOLLOW_seq_in_synpred5_DTD733 = new BitSet(new long[]{0x0000000000000002L});\r
2590 \r
2591 }