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

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