1 // $ANTLR 3.1.3 Mar 17, 2009 19:23:44 DTD.g 2009-10-21 09:39:48
\r
3 //--------------------------------------------------
\r
4 // Xerial -- Transactional XML Database System
\r
7 // Since 2007/07/25 11:40:17
\r
9 //--------------------------------------------------
\r
10 package org.xerial.util.xml.dtd.impl;
\r
11 //import org.xerial.util.log.Logger;
\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
21 import org.antlr.runtime.tree.*;
\r
23 public class DTDParser extends Parser {
\r
24 public static final String[] tokenNames = new String[] {
\r
25 "<invalid>", "<EOR>", "<DOWN>", "<UP>", "DTD", "STRINGTYPE", "TOKENIZEDTYPE", "ENUMTYPE", "NAME", "ATTRIBUTE", "ATTLIST", "DECL", "TYPE", "ELEMENT", "COMPONENT", "OCCURRENCE", "CONTENTSPEC", "ENTITY", "ENTITY_REF", "VALUE", "ML_COMMENT", "At", "Colon", "Comma", "Apos", "Quot", "Dot", "SemiColon", "LParen", "RParen", "Letter", "Digit", "Digits", "NameChar", "WhiteSpaceChar", "String", "Name", "Reference", "AttValue", "EntityRef", "CharRef", "DefaultDecl", "Element", "'>'", "'EMPTY'", "'ANY'", "'?'", "'*'", "'+'", "'|'", "'#PCDATA'", "'<!ATTLIST'", "'NOTATION'", "'CDATA'", "'ID'", "'IDREF'", "'IDREFS'", "'ENTITY'", "'ENTITIES'", "'NMTOKEN'", "'NMTOKENS'", "'<!ENTITY'", "'%'"
\r
27 public static final int TYPE=12;
\r
28 public static final int CONTENTSPEC=16;
\r
29 public static final int ELEMENT=13;
\r
30 public static final int DefaultDecl=41;
\r
31 public static final int ENTITY_REF=18;
\r
32 public static final int Digit=31;
\r
33 public static final int Apos=24;
\r
34 public static final int T__57=57;
\r
35 public static final int SemiColon=27;
\r
36 public static final int T__51=51;
\r
37 public static final int T__47=47;
\r
38 public static final int T__50=50;
\r
39 public static final int ENTITY=17;
\r
40 public static final int ATTLIST=10;
\r
41 public static final int TOKENIZEDTYPE=6;
\r
42 public static final int VALUE=19;
\r
43 public static final int AttValue=38;
\r
44 public static final int Letter=30;
\r
45 public static final int T__52=52;
\r
46 public static final int T__46=46;
\r
47 public static final int Comma=23;
\r
48 public static final int Dot=26;
\r
49 public static final int T__62=62;
\r
50 public static final int T__49=49;
\r
51 public static final int T__61=61;
\r
52 public static final int T__59=59;
\r
53 public static final int DECL=11;
\r
54 public static final int ML_COMMENT=20;
\r
55 public static final int T__54=54;
\r
56 public static final int T__48=48;
\r
57 public static final int EntityRef=39;
\r
58 public static final int Colon=22;
\r
59 public static final int T__56=56;
\r
60 public static final int At=21;
\r
61 public static final int STRINGTYPE=5;
\r
62 public static final int NameChar=33;
\r
63 public static final int DTD=4;
\r
64 public static final int T__58=58;
\r
65 public static final int T__44=44;
\r
66 public static final int RParen=29;
\r
67 public static final int Name=36;
\r
68 public static final int T__55=55;
\r
69 public static final int T__45=45;
\r
70 public static final int LParen=28;
\r
71 public static final int String=35;
\r
72 public static final int CharRef=40;
\r
73 public static final int OCCURRENCE=15;
\r
74 public static final int T__43=43;
\r
75 public static final int WhiteSpaceChar=34;
\r
76 public static final int EOF=-1;
\r
77 public static final int Reference=37;
\r
78 public static final int T__53=53;
\r
79 public static final int COMPONENT=14;
\r
80 public static final int Quot=25;
\r
81 public static final int ATTRIBUTE=9;
\r
82 public static final int T__60=60;
\r
83 public static final int NAME=8;
\r
84 public static final int Digits=32;
\r
85 public static final int Element=42;
\r
86 public static final int ENUMTYPE=7;
\r
92 public DTDParser(TokenStream input) {
\r
93 this(input, new RecognizerSharedState());
\r
95 public DTDParser(TokenStream input, RecognizerSharedState state) {
\r
96 super(input, state);
\r
100 protected TreeAdaptor adaptor = new CommonTreeAdaptor();
\r
102 public void setTreeAdaptor(TreeAdaptor adaptor) {
\r
103 this.adaptor = adaptor;
\r
105 public TreeAdaptor getTreeAdaptor() {
\r
109 public String[] getTokenNames() { return DTDParser.tokenNames; }
\r
110 public String getGrammarFileName() { return "DTD.g"; }
\r
113 public static class dtd_return extends ParserRuleReturnScope {
\r
115 public Object getTree() { return tree; }
\r
118 // $ANTLR start "dtd"
\r
119 // DTD.g:152:1: dtd : ( markupdecl )* -> ^( DTD ( markupdecl )* ) ;
\r
120 public final DTDParser.dtd_return dtd() throws RecognitionException {
\r
121 DTDParser.dtd_return retval = new DTDParser.dtd_return();
\r
122 retval.start = input.LT(1);
\r
124 Object root_0 = null;
\r
126 DTDParser.markupdecl_return markupdecl1 = null;
\r
129 RewriteRuleSubtreeStream stream_markupdecl=new RewriteRuleSubtreeStream(adaptor,"rule markupdecl");
\r
131 // DTD.g:152:4: ( ( markupdecl )* -> ^( DTD ( markupdecl )* ) )
\r
132 // DTD.g:152:6: ( markupdecl )*
\r
134 // DTD.g:152:6: ( markupdecl )*
\r
138 int LA1_0 = input.LA(1);
\r
140 if ( (LA1_0==Element||LA1_0==51||LA1_0==61) ) {
\r
147 // DTD.g:152:6: markupdecl
\r
149 pushFollow(FOLLOW_markupdecl_in_dtd552);
\r
150 markupdecl1=markupdecl();
\r
153 if (state.failed) return retval;
\r
154 if ( state.backtracking==0 ) stream_markupdecl.add(markupdecl1.getTree());
\r
167 // elements: markupdecl
\r
169 // rule labels: retval
\r
170 // token list labels:
\r
171 // rule list labels:
\r
172 // wildcard labels:
\r
173 if ( state.backtracking==0 ) {
\r
174 retval.tree = root_0;
\r
175 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
177 root_0 = (Object)adaptor.nil();
\r
178 // 153:3: -> ^( DTD ( markupdecl )* )
\r
180 // DTD.g:153:6: ^( DTD ( markupdecl )* )
\r
182 Object root_1 = (Object)adaptor.nil();
\r
183 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(DTD, "DTD"), root_1);
\r
185 // DTD.g:153:12: ( markupdecl )*
\r
186 while ( stream_markupdecl.hasNext() ) {
\r
187 adaptor.addChild(root_1, stream_markupdecl.nextTree());
\r
190 stream_markupdecl.reset();
\r
192 adaptor.addChild(root_0, root_1);
\r
197 retval.tree = root_0;}
\r
200 retval.stop = input.LT(-1);
\r
202 if ( state.backtracking==0 ) {
\r
204 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
\r
205 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
208 catch (RecognitionException re) {
\r
211 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
218 // $ANTLR end "dtd"
\r
220 public static class markupdecl_return extends ParserRuleReturnScope {
\r
222 public Object getTree() { return tree; }
\r
225 // $ANTLR start "markupdecl"
\r
226 // DTD.g:156:1: fragment markupdecl : ( elementDecl | attlistDecl | entityDecl );
\r
227 public final DTDParser.markupdecl_return markupdecl() throws RecognitionException {
\r
228 DTDParser.markupdecl_return retval = new DTDParser.markupdecl_return();
\r
229 retval.start = input.LT(1);
\r
231 Object root_0 = null;
\r
233 DTDParser.elementDecl_return elementDecl2 = null;
\r
235 DTDParser.attlistDecl_return attlistDecl3 = null;
\r
237 DTDParser.entityDecl_return entityDecl4 = null;
\r
242 // DTD.g:157:11: ( elementDecl | attlistDecl | entityDecl )
\r
244 switch ( input.LA(1) ) {
\r
261 if (state.backtracking>0) {state.failed=true; return retval;}
\r
262 NoViableAltException nvae =
\r
263 new NoViableAltException("", 2, 0, input);
\r
270 // DTD.g:157:13: elementDecl
\r
272 root_0 = (Object)adaptor.nil();
\r
274 pushFollow(FOLLOW_elementDecl_in_markupdecl574);
\r
275 elementDecl2=elementDecl();
\r
278 if (state.failed) return retval;
\r
279 if ( state.backtracking==0 ) adaptor.addChild(root_0, elementDecl2.getTree());
\r
284 // DTD.g:157:27: attlistDecl
\r
286 root_0 = (Object)adaptor.nil();
\r
288 pushFollow(FOLLOW_attlistDecl_in_markupdecl578);
\r
289 attlistDecl3=attlistDecl();
\r
292 if (state.failed) return retval;
\r
293 if ( state.backtracking==0 ) adaptor.addChild(root_0, attlistDecl3.getTree());
\r
298 // DTD.g:157:41: entityDecl
\r
300 root_0 = (Object)adaptor.nil();
\r
302 pushFollow(FOLLOW_entityDecl_in_markupdecl582);
\r
303 entityDecl4=entityDecl();
\r
306 if (state.failed) return retval;
\r
307 if ( state.backtracking==0 ) adaptor.addChild(root_0, entityDecl4.getTree());
\r
313 retval.stop = input.LT(-1);
\r
315 if ( state.backtracking==0 ) {
\r
317 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
\r
318 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
321 catch (RecognitionException re) {
\r
324 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
331 // $ANTLR end "markupdecl"
\r
333 public static class elementDecl_return extends ParserRuleReturnScope {
\r
335 public Object getTree() { return tree; }
\r
338 // $ANTLR start "elementDecl"
\r
339 // DTD.g:159:1: elementDecl : Element Name contentSpec '>' -> ^( ELEMENT NAME[$Name.text] contentSpec ) ;
\r
340 public final DTDParser.elementDecl_return elementDecl() throws RecognitionException {
\r
341 DTDParser.elementDecl_return retval = new DTDParser.elementDecl_return();
\r
342 retval.start = input.LT(1);
\r
344 Object root_0 = null;
\r
346 Token Element5=null;
\r
348 Token char_literal8=null;
\r
349 DTDParser.contentSpec_return contentSpec7 = null;
\r
352 Object Element5_tree=null;
\r
353 Object Name6_tree=null;
\r
354 Object char_literal8_tree=null;
\r
355 RewriteRuleTokenStream stream_43=new RewriteRuleTokenStream(adaptor,"token 43");
\r
356 RewriteRuleTokenStream stream_Element=new RewriteRuleTokenStream(adaptor,"token Element");
\r
357 RewriteRuleTokenStream stream_Name=new RewriteRuleTokenStream(adaptor,"token Name");
\r
358 RewriteRuleSubtreeStream stream_contentSpec=new RewriteRuleSubtreeStream(adaptor,"rule contentSpec");
\r
360 // DTD.g:159:12: ( Element Name contentSpec '>' -> ^( ELEMENT NAME[$Name.text] contentSpec ) )
\r
361 // DTD.g:159:14: Element Name contentSpec '>'
\r
363 Element5=(Token)match(input,Element,FOLLOW_Element_in_elementDecl590); if (state.failed) return retval;
\r
364 if ( state.backtracking==0 ) stream_Element.add(Element5);
\r
366 Name6=(Token)match(input,Name,FOLLOW_Name_in_elementDecl592); if (state.failed) return retval;
\r
367 if ( state.backtracking==0 ) stream_Name.add(Name6);
\r
369 pushFollow(FOLLOW_contentSpec_in_elementDecl594);
\r
370 contentSpec7=contentSpec();
\r
373 if (state.failed) return retval;
\r
374 if ( state.backtracking==0 ) stream_contentSpec.add(contentSpec7.getTree());
\r
375 char_literal8=(Token)match(input,43,FOLLOW_43_in_elementDecl596); if (state.failed) return retval;
\r
376 if ( state.backtracking==0 ) stream_43.add(char_literal8);
\r
381 // elements: contentSpec
\r
383 // rule labels: retval
\r
384 // token list labels:
\r
385 // rule list labels:
\r
386 // wildcard labels:
\r
387 if ( state.backtracking==0 ) {
\r
388 retval.tree = root_0;
\r
389 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
391 root_0 = (Object)adaptor.nil();
\r
392 // 160:3: -> ^( ELEMENT NAME[$Name.text] contentSpec )
\r
394 // DTD.g:160:6: ^( ELEMENT NAME[$Name.text] contentSpec )
\r
396 Object root_1 = (Object)adaptor.nil();
\r
397 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(ELEMENT, "ELEMENT"), root_1);
\r
399 adaptor.addChild(root_1, (Object)adaptor.create(NAME, (Name6!=null?Name6.getText():null)));
\r
400 adaptor.addChild(root_1, stream_contentSpec.nextTree());
\r
402 adaptor.addChild(root_0, root_1);
\r
407 retval.tree = root_0;}
\r
410 retval.stop = input.LT(-1);
\r
412 if ( state.backtracking==0 ) {
\r
414 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
\r
415 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
418 catch (RecognitionException re) {
\r
421 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
428 // $ANTLR end "elementDecl"
\r
430 public static class contentSpec_return extends ParserRuleReturnScope {
\r
432 public Object getTree() { return tree; }
\r
435 // $ANTLR start "contentSpec"
\r
436 // DTD.g:163:1: fragment contentSpec : ( 'EMPTY' -> CONTENTSPEC[\"EMPTY\"] | 'ANY' -> CONTENTSPEC[\"ANY\"] | mixed | children );
\r
437 public final DTDParser.contentSpec_return contentSpec() throws RecognitionException {
\r
438 DTDParser.contentSpec_return retval = new DTDParser.contentSpec_return();
\r
439 retval.start = input.LT(1);
\r
441 Object root_0 = null;
\r
443 Token string_literal9=null;
\r
444 Token string_literal10=null;
\r
445 DTDParser.mixed_return mixed11 = null;
\r
447 DTDParser.children_return children12 = null;
\r
450 Object string_literal9_tree=null;
\r
451 Object string_literal10_tree=null;
\r
452 RewriteRuleTokenStream stream_44=new RewriteRuleTokenStream(adaptor,"token 44");
\r
453 RewriteRuleTokenStream stream_45=new RewriteRuleTokenStream(adaptor,"token 45");
\r
456 // DTD.g:165:3: ( 'EMPTY' -> CONTENTSPEC[\"EMPTY\"] | 'ANY' -> CONTENTSPEC[\"ANY\"] | mixed | children )
\r
458 switch ( input.LA(1) ) {
\r
471 int LA3_3 = input.LA(2);
\r
473 if ( (LA3_3==50) ) {
\r
476 else if ( (LA3_3==LParen||LA3_3==Name) ) {
\r
480 if (state.backtracking>0) {state.failed=true; return retval;}
\r
481 NoViableAltException nvae =
\r
482 new NoViableAltException("", 3, 3, input);
\r
489 if (state.backtracking>0) {state.failed=true; return retval;}
\r
490 NoViableAltException nvae =
\r
491 new NoViableAltException("", 3, 0, input);
\r
498 // DTD.g:165:5: 'EMPTY'
\r
500 string_literal9=(Token)match(input,44,FOLLOW_44_in_contentSpec624); if (state.failed) return retval;
\r
501 if ( state.backtracking==0 ) stream_44.add(string_literal9);
\r
508 // rule labels: retval
\r
509 // token list labels:
\r
510 // rule list labels:
\r
511 // wildcard labels:
\r
512 if ( state.backtracking==0 ) {
\r
513 retval.tree = root_0;
\r
514 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
516 root_0 = (Object)adaptor.nil();
\r
517 // 165:13: -> CONTENTSPEC[\"EMPTY\"]
\r
519 adaptor.addChild(root_0, (Object)adaptor.create(CONTENTSPEC, "EMPTY"));
\r
523 retval.tree = root_0;}
\r
527 // DTD.g:166:5: 'ANY'
\r
529 string_literal10=(Token)match(input,45,FOLLOW_45_in_contentSpec635); if (state.failed) return retval;
\r
530 if ( state.backtracking==0 ) stream_45.add(string_literal10);
\r
537 // rule labels: retval
\r
538 // token list labels:
\r
539 // rule list labels:
\r
540 // wildcard labels:
\r
541 if ( state.backtracking==0 ) {
\r
542 retval.tree = root_0;
\r
543 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
545 root_0 = (Object)adaptor.nil();
\r
546 // 166:13: -> CONTENTSPEC[\"ANY\"]
\r
548 adaptor.addChild(root_0, (Object)adaptor.create(CONTENTSPEC, "ANY"));
\r
552 retval.tree = root_0;}
\r
556 // DTD.g:167:5: mixed
\r
558 root_0 = (Object)adaptor.nil();
\r
560 pushFollow(FOLLOW_mixed_in_contentSpec648);
\r
564 if (state.failed) return retval;
\r
565 if ( state.backtracking==0 ) adaptor.addChild(root_0, mixed11.getTree());
\r
570 // DTD.g:168:5: children
\r
572 root_0 = (Object)adaptor.nil();
\r
574 pushFollow(FOLLOW_children_in_contentSpec655);
\r
575 children12=children();
\r
578 if (state.failed) return retval;
\r
579 if ( state.backtracking==0 ) adaptor.addChild(root_0, children12.getTree());
\r
585 retval.stop = input.LT(-1);
\r
587 if ( state.backtracking==0 ) {
\r
589 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
\r
590 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
593 catch (RecognitionException re) {
\r
596 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
603 // $ANTLR end "contentSpec"
\r
605 public static class children_return extends ParserRuleReturnScope {
\r
607 public Object getTree() { return tree; }
\r
610 // $ANTLR start "children"
\r
611 // DTD.g:171:1: fragment children : ( ( choice )=> choice ( plural )? -> ^( COMPONENT TYPE[\"choice\"] choice ( plural )? ) | ( seq )=> seq ( plural )? -> ^( COMPONENT TYPE[\"seq\"] seq ( plural )? ) );
\r
612 public final DTDParser.children_return children() throws RecognitionException {
\r
613 DTDParser.children_return retval = new DTDParser.children_return();
\r
614 retval.start = input.LT(1);
\r
616 Object root_0 = null;
\r
618 DTDParser.choice_return choice13 = null;
\r
620 DTDParser.plural_return plural14 = null;
\r
622 DTDParser.seq_return seq15 = null;
\r
624 DTDParser.plural_return plural16 = null;
\r
627 RewriteRuleSubtreeStream stream_seq=new RewriteRuleSubtreeStream(adaptor,"rule seq");
\r
628 RewriteRuleSubtreeStream stream_choice=new RewriteRuleSubtreeStream(adaptor,"rule choice");
\r
629 RewriteRuleSubtreeStream stream_plural=new RewriteRuleSubtreeStream(adaptor,"rule plural");
\r
631 // DTD.g:173:1: ( ( choice )=> choice ( plural )? -> ^( COMPONENT TYPE[\"choice\"] choice ( plural )? ) | ( seq )=> seq ( plural )? -> ^( COMPONENT TYPE[\"seq\"] seq ( plural )? ) )
\r
633 int LA6_0 = input.LA(1);
\r
635 if ( (LA6_0==LParen) ) {
\r
636 int LA6_1 = input.LA(2);
\r
638 if ( (synpred1_DTD()) ) {
\r
641 else if ( (synpred2_DTD()) ) {
\r
645 if (state.backtracking>0) {state.failed=true; return retval;}
\r
646 NoViableAltException nvae =
\r
647 new NoViableAltException("", 6, 1, input);
\r
653 if (state.backtracking>0) {state.failed=true; return retval;}
\r
654 NoViableAltException nvae =
\r
655 new NoViableAltException("", 6, 0, input);
\r
661 // DTD.g:173:3: ( choice )=> choice ( plural )?
\r
663 pushFollow(FOLLOW_choice_in_children678);
\r
667 if (state.failed) return retval;
\r
668 if ( state.backtracking==0 ) stream_choice.add(choice13.getTree());
\r
669 // DTD.g:173:23: ( plural )?
\r
671 int LA4_0 = input.LA(1);
\r
673 if ( ((LA4_0>=46 && LA4_0<=48)) ) {
\r
678 // DTD.g:173:23: plural
\r
680 pushFollow(FOLLOW_plural_in_children681);
\r
684 if (state.failed) return retval;
\r
685 if ( state.backtracking==0 ) stream_plural.add(plural14.getTree());
\r
695 // elements: plural, choice
\r
697 // rule labels: retval
\r
698 // token list labels:
\r
699 // rule list labels:
\r
700 // wildcard labels:
\r
701 if ( state.backtracking==0 ) {
\r
702 retval.tree = root_0;
\r
703 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
705 root_0 = (Object)adaptor.nil();
\r
706 // 173:31: -> ^( COMPONENT TYPE[\"choice\"] choice ( plural )? )
\r
708 // DTD.g:173:34: ^( COMPONENT TYPE[\"choice\"] choice ( plural )? )
\r
710 Object root_1 = (Object)adaptor.nil();
\r
711 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(COMPONENT, "COMPONENT"), root_1);
\r
713 adaptor.addChild(root_1, (Object)adaptor.create(TYPE, "choice"));
\r
714 adaptor.addChild(root_1, stream_choice.nextTree());
\r
715 // DTD.g:173:69: ( plural )?
\r
716 if ( stream_plural.hasNext() ) {
\r
717 adaptor.addChild(root_1, stream_plural.nextTree());
\r
720 stream_plural.reset();
\r
722 adaptor.addChild(root_0, root_1);
\r
727 retval.tree = root_0;}
\r
731 // DTD.g:174:3: ( seq )=> seq ( plural )?
\r
733 pushFollow(FOLLOW_seq_in_children707);
\r
737 if (state.failed) return retval;
\r
738 if ( state.backtracking==0 ) stream_seq.add(seq15.getTree());
\r
739 // DTD.g:174:16: ( plural )?
\r
741 int LA5_0 = input.LA(1);
\r
743 if ( ((LA5_0>=46 && LA5_0<=48)) ) {
\r
748 // DTD.g:174:16: plural
\r
750 pushFollow(FOLLOW_plural_in_children709);
\r
754 if (state.failed) return retval;
\r
755 if ( state.backtracking==0 ) stream_plural.add(plural16.getTree());
\r
765 // elements: seq, plural
\r
767 // rule labels: retval
\r
768 // token list labels:
\r
769 // rule list labels:
\r
770 // wildcard labels:
\r
771 if ( state.backtracking==0 ) {
\r
772 retval.tree = root_0;
\r
773 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
775 root_0 = (Object)adaptor.nil();
\r
776 // 174:24: -> ^( COMPONENT TYPE[\"seq\"] seq ( plural )? )
\r
778 // DTD.g:174:27: ^( COMPONENT TYPE[\"seq\"] seq ( plural )? )
\r
780 Object root_1 = (Object)adaptor.nil();
\r
781 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(COMPONENT, "COMPONENT"), root_1);
\r
783 adaptor.addChild(root_1, (Object)adaptor.create(TYPE, "seq"));
\r
784 adaptor.addChild(root_1, stream_seq.nextTree());
\r
785 // DTD.g:174:55: ( plural )?
\r
786 if ( stream_plural.hasNext() ) {
\r
787 adaptor.addChild(root_1, stream_plural.nextTree());
\r
790 stream_plural.reset();
\r
792 adaptor.addChild(root_0, root_1);
\r
797 retval.tree = root_0;}
\r
802 retval.stop = input.LT(-1);
\r
804 if ( state.backtracking==0 ) {
\r
806 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
\r
807 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
810 catch (RecognitionException re) {
\r
813 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
820 // $ANTLR end "children"
\r
822 public static class cp_return extends ParserRuleReturnScope {
\r
824 public Object getTree() { return tree; }
\r
827 // $ANTLR start "cp"
\r
828 // DTD.g:177:1: fragment cp : ( ( Name )=> Name ( plural )? -> ^( COMPONENT NAME[$Name.text] ( plural )? ) | ( choice )=> choice ( plural )? -> ^( COMPONENT TYPE[\"choice\"] choice ( plural )? ) | ( seq )=> seq ( plural )? -> ^( COMPONENT TYPE[\"seq\"] seq ( plural )? ) );
\r
829 public final DTDParser.cp_return cp() throws RecognitionException {
\r
830 DTDParser.cp_return retval = new DTDParser.cp_return();
\r
831 retval.start = input.LT(1);
\r
833 Object root_0 = null;
\r
836 DTDParser.plural_return plural18 = null;
\r
838 DTDParser.choice_return choice19 = null;
\r
840 DTDParser.plural_return plural20 = null;
\r
842 DTDParser.seq_return seq21 = null;
\r
844 DTDParser.plural_return plural22 = null;
\r
847 Object Name17_tree=null;
\r
848 RewriteRuleTokenStream stream_Name=new RewriteRuleTokenStream(adaptor,"token Name");
\r
849 RewriteRuleSubtreeStream stream_seq=new RewriteRuleSubtreeStream(adaptor,"rule seq");
\r
850 RewriteRuleSubtreeStream stream_choice=new RewriteRuleSubtreeStream(adaptor,"rule choice");
\r
851 RewriteRuleSubtreeStream stream_plural=new RewriteRuleSubtreeStream(adaptor,"rule plural");
\r
853 // DTD.g:179:1: ( ( Name )=> Name ( plural )? -> ^( COMPONENT NAME[$Name.text] ( plural )? ) | ( choice )=> choice ( plural )? -> ^( COMPONENT TYPE[\"choice\"] choice ( plural )? ) | ( seq )=> seq ( plural )? -> ^( COMPONENT TYPE[\"seq\"] seq ( plural )? ) )
\r
855 int LA10_0 = input.LA(1);
\r
857 if ( (LA10_0==Name) && (synpred3_DTD())) {
\r
860 else if ( (LA10_0==LParen) ) {
\r
861 int LA10_2 = input.LA(2);
\r
863 if ( (synpred4_DTD()) ) {
\r
866 else if ( (synpred5_DTD()) ) {
\r
870 if (state.backtracking>0) {state.failed=true; return retval;}
\r
871 NoViableAltException nvae =
\r
872 new NoViableAltException("", 10, 2, input);
\r
878 if (state.backtracking>0) {state.failed=true; return retval;}
\r
879 NoViableAltException nvae =
\r
880 new NoViableAltException("", 10, 0, input);
\r
886 // DTD.g:179:3: ( Name )=> Name ( plural )?
\r
888 Name17=(Token)match(input,Name,FOLLOW_Name_in_cp743); if (state.failed) return retval;
\r
889 if ( state.backtracking==0 ) stream_Name.add(Name17);
\r
891 // DTD.g:179:19: ( plural )?
\r
893 int LA7_0 = input.LA(1);
\r
895 if ( ((LA7_0>=46 && LA7_0<=48)) ) {
\r
900 // DTD.g:179:19: plural
\r
902 pushFollow(FOLLOW_plural_in_cp746);
\r
906 if (state.failed) return retval;
\r
907 if ( state.backtracking==0 ) stream_plural.add(plural18.getTree());
\r
917 // elements: plural
\r
919 // rule labels: retval
\r
920 // token list labels:
\r
921 // rule list labels:
\r
922 // wildcard labels:
\r
923 if ( state.backtracking==0 ) {
\r
924 retval.tree = root_0;
\r
925 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
927 root_0 = (Object)adaptor.nil();
\r
928 // 179:27: -> ^( COMPONENT NAME[$Name.text] ( plural )? )
\r
930 // DTD.g:179:30: ^( COMPONENT NAME[$Name.text] ( plural )? )
\r
932 Object root_1 = (Object)adaptor.nil();
\r
933 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(COMPONENT, "COMPONENT"), root_1);
\r
935 adaptor.addChild(root_1, (Object)adaptor.create(NAME, (Name17!=null?Name17.getText():null)));
\r
936 // DTD.g:179:59: ( plural )?
\r
937 if ( stream_plural.hasNext() ) {
\r
938 adaptor.addChild(root_1, stream_plural.nextTree());
\r
941 stream_plural.reset();
\r
943 adaptor.addChild(root_0, root_1);
\r
948 retval.tree = root_0;}
\r
952 // DTD.g:180:4: ( choice )=> choice ( plural )?
\r
954 pushFollow(FOLLOW_choice_in_cp770);
\r
958 if (state.failed) return retval;
\r
959 if ( state.backtracking==0 ) stream_choice.add(choice19.getTree());
\r
960 // DTD.g:180:24: ( plural )?
\r
962 int LA8_0 = input.LA(1);
\r
964 if ( ((LA8_0>=46 && LA8_0<=48)) ) {
\r
969 // DTD.g:180:24: plural
\r
971 pushFollow(FOLLOW_plural_in_cp773);
\r
975 if (state.failed) return retval;
\r
976 if ( state.backtracking==0 ) stream_plural.add(plural20.getTree());
\r
986 // elements: choice, plural
\r
988 // rule labels: retval
\r
989 // token list labels:
\r
990 // rule list labels:
\r
991 // wildcard labels:
\r
992 if ( state.backtracking==0 ) {
\r
993 retval.tree = root_0;
\r
994 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
996 root_0 = (Object)adaptor.nil();
\r
997 // 180:32: -> ^( COMPONENT TYPE[\"choice\"] choice ( plural )? )
\r
999 // DTD.g:180:35: ^( COMPONENT TYPE[\"choice\"] choice ( plural )? )
\r
1001 Object root_1 = (Object)adaptor.nil();
\r
1002 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(COMPONENT, "COMPONENT"), root_1);
\r
1004 adaptor.addChild(root_1, (Object)adaptor.create(TYPE, "choice"));
\r
1005 adaptor.addChild(root_1, stream_choice.nextTree());
\r
1006 // DTD.g:180:69: ( plural )?
\r
1007 if ( stream_plural.hasNext() ) {
\r
1008 adaptor.addChild(root_1, stream_plural.nextTree());
\r
1011 stream_plural.reset();
\r
1013 adaptor.addChild(root_0, root_1);
\r
1018 retval.tree = root_0;}
\r
1022 // DTD.g:181:4: ( seq )=> seq ( plural )?
\r
1024 pushFollow(FOLLOW_seq_in_cp799);
\r
1028 if (state.failed) return retval;
\r
1029 if ( state.backtracking==0 ) stream_seq.add(seq21.getTree());
\r
1030 // DTD.g:181:18: ( plural )?
\r
1032 int LA9_0 = input.LA(1);
\r
1034 if ( ((LA9_0>=46 && LA9_0<=48)) ) {
\r
1039 // DTD.g:181:18: plural
\r
1041 pushFollow(FOLLOW_plural_in_cp802);
\r
1042 plural22=plural();
\r
1045 if (state.failed) return retval;
\r
1046 if ( state.backtracking==0 ) stream_plural.add(plural22.getTree());
\r
1056 // elements: seq, plural
\r
1058 // rule labels: retval
\r
1059 // token list labels:
\r
1060 // rule list labels:
\r
1061 // wildcard labels:
\r
1062 if ( state.backtracking==0 ) {
\r
1063 retval.tree = root_0;
\r
1064 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
1066 root_0 = (Object)adaptor.nil();
\r
1067 // 181:26: -> ^( COMPONENT TYPE[\"seq\"] seq ( plural )? )
\r
1069 // DTD.g:181:29: ^( COMPONENT TYPE[\"seq\"] seq ( plural )? )
\r
1071 Object root_1 = (Object)adaptor.nil();
\r
1072 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(COMPONENT, "COMPONENT"), root_1);
\r
1074 adaptor.addChild(root_1, (Object)adaptor.create(TYPE, "seq"));
\r
1075 adaptor.addChild(root_1, stream_seq.nextTree());
\r
1076 // DTD.g:181:57: ( plural )?
\r
1077 if ( stream_plural.hasNext() ) {
\r
1078 adaptor.addChild(root_1, stream_plural.nextTree());
\r
1081 stream_plural.reset();
\r
1083 adaptor.addChild(root_0, root_1);
\r
1088 retval.tree = root_0;}
\r
1093 retval.stop = input.LT(-1);
\r
1095 if ( state.backtracking==0 ) {
\r
1097 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
\r
1098 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
1101 catch (RecognitionException re) {
\r
1103 recover(input,re);
\r
1104 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
1111 // $ANTLR end "cp"
\r
1113 public static class plural_return extends ParserRuleReturnScope {
\r
1115 public Object getTree() { return tree; }
\r
1118 // $ANTLR start "plural"
\r
1119 // DTD.g:184:1: fragment plural : ( '?' -> OCCURRENCE[\"ZERO_OR_ONE\"] | '*' -> OCCURRENCE[\"ZERO_OR_MORE\"] | '+' -> OCCURRENCE[\"ONE_OR_MORE\"] );
\r
1120 public final DTDParser.plural_return plural() throws RecognitionException {
\r
1121 DTDParser.plural_return retval = new DTDParser.plural_return();
\r
1122 retval.start = input.LT(1);
\r
1124 Object root_0 = null;
\r
1126 Token char_literal23=null;
\r
1127 Token char_literal24=null;
\r
1128 Token char_literal25=null;
\r
1130 Object char_literal23_tree=null;
\r
1131 Object char_literal24_tree=null;
\r
1132 Object char_literal25_tree=null;
\r
1133 RewriteRuleTokenStream stream_48=new RewriteRuleTokenStream(adaptor,"token 48");
\r
1134 RewriteRuleTokenStream stream_46=new RewriteRuleTokenStream(adaptor,"token 46");
\r
1135 RewriteRuleTokenStream stream_47=new RewriteRuleTokenStream(adaptor,"token 47");
\r
1138 // DTD.g:186:3: ( '?' -> OCCURRENCE[\"ZERO_OR_ONE\"] | '*' -> OCCURRENCE[\"ZERO_OR_MORE\"] | '+' -> OCCURRENCE[\"ONE_OR_MORE\"] )
\r
1140 switch ( input.LA(1) ) {
\r
1157 if (state.backtracking>0) {state.failed=true; return retval;}
\r
1158 NoViableAltException nvae =
\r
1159 new NoViableAltException("", 11, 0, input);
\r
1166 // DTD.g:186:5: '?'
\r
1168 char_literal23=(Token)match(input,46,FOLLOW_46_in_plural830); if (state.failed) return retval;
\r
1169 if ( state.backtracking==0 ) stream_46.add(char_literal23);
\r
1176 // rule labels: retval
\r
1177 // token list labels:
\r
1178 // rule list labels:
\r
1179 // wildcard labels:
\r
1180 if ( state.backtracking==0 ) {
\r
1181 retval.tree = root_0;
\r
1182 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
1184 root_0 = (Object)adaptor.nil();
\r
1185 // 186:9: -> OCCURRENCE[\"ZERO_OR_ONE\"]
\r
1187 adaptor.addChild(root_0, (Object)adaptor.create(OCCURRENCE, "ZERO_OR_ONE"));
\r
1191 retval.tree = root_0;}
\r
1195 // DTD.g:187:5: '*'
\r
1197 char_literal24=(Token)match(input,47,FOLLOW_47_in_plural841); if (state.failed) return retval;
\r
1198 if ( state.backtracking==0 ) stream_47.add(char_literal24);
\r
1205 // rule labels: retval
\r
1206 // token list labels:
\r
1207 // rule list labels:
\r
1208 // wildcard labels:
\r
1209 if ( state.backtracking==0 ) {
\r
1210 retval.tree = root_0;
\r
1211 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
1213 root_0 = (Object)adaptor.nil();
\r
1214 // 187:9: -> OCCURRENCE[\"ZERO_OR_MORE\"]
\r
1216 adaptor.addChild(root_0, (Object)adaptor.create(OCCURRENCE, "ZERO_OR_MORE"));
\r
1220 retval.tree = root_0;}
\r
1224 // DTD.g:188:5: '+'
\r
1226 char_literal25=(Token)match(input,48,FOLLOW_48_in_plural852); if (state.failed) return retval;
\r
1227 if ( state.backtracking==0 ) stream_48.add(char_literal25);
\r
1234 // rule labels: retval
\r
1235 // token list labels:
\r
1236 // rule list labels:
\r
1237 // wildcard labels:
\r
1238 if ( state.backtracking==0 ) {
\r
1239 retval.tree = root_0;
\r
1240 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
1242 root_0 = (Object)adaptor.nil();
\r
1243 // 188:9: -> OCCURRENCE[\"ONE_OR_MORE\"]
\r
1245 adaptor.addChild(root_0, (Object)adaptor.create(OCCURRENCE, "ONE_OR_MORE"));
\r
1249 retval.tree = root_0;}
\r
1254 retval.stop = input.LT(-1);
\r
1256 if ( state.backtracking==0 ) {
\r
1258 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
\r
1259 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
1262 catch (RecognitionException re) {
\r
1264 recover(input,re);
\r
1265 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
1272 // $ANTLR end "plural"
\r
1274 public static class choice_return extends ParserRuleReturnScope {
\r
1276 public Object getTree() { return tree; }
\r
1279 // $ANTLR start "choice"
\r
1280 // DTD.g:192:1: fragment choice : LParen cp ( '|' cp )* RParen -> ( cp )+ ;
\r
1281 public final DTDParser.choice_return choice() throws RecognitionException {
\r
1282 DTDParser.choice_return retval = new DTDParser.choice_return();
\r
1283 retval.start = input.LT(1);
\r
1285 Object root_0 = null;
\r
1287 Token LParen26=null;
\r
1288 Token char_literal28=null;
\r
1289 Token RParen30=null;
\r
1290 DTDParser.cp_return cp27 = null;
\r
1292 DTDParser.cp_return cp29 = null;
\r
1295 Object LParen26_tree=null;
\r
1296 Object char_literal28_tree=null;
\r
1297 Object RParen30_tree=null;
\r
1298 RewriteRuleTokenStream stream_RParen=new RewriteRuleTokenStream(adaptor,"token RParen");
\r
1299 RewriteRuleTokenStream stream_49=new RewriteRuleTokenStream(adaptor,"token 49");
\r
1300 RewriteRuleTokenStream stream_LParen=new RewriteRuleTokenStream(adaptor,"token LParen");
\r
1301 RewriteRuleSubtreeStream stream_cp=new RewriteRuleSubtreeStream(adaptor,"rule cp");
\r
1303 // DTD.g:193:7: ( LParen cp ( '|' cp )* RParen -> ( cp )+ )
\r
1304 // DTD.g:193:9: LParen cp ( '|' cp )* RParen
\r
1306 LParen26=(Token)match(input,LParen,FOLLOW_LParen_in_choice872); if (state.failed) return retval;
\r
1307 if ( state.backtracking==0 ) stream_LParen.add(LParen26);
\r
1309 pushFollow(FOLLOW_cp_in_choice874);
\r
1313 if (state.failed) return retval;
\r
1314 if ( state.backtracking==0 ) stream_cp.add(cp27.getTree());
\r
1315 // DTD.g:193:19: ( '|' cp )*
\r
1319 int LA12_0 = input.LA(1);
\r
1321 if ( (LA12_0==49) ) {
\r
1328 // DTD.g:193:20: '|' cp
\r
1330 char_literal28=(Token)match(input,49,FOLLOW_49_in_choice877); if (state.failed) return retval;
\r
1331 if ( state.backtracking==0 ) stream_49.add(char_literal28);
\r
1333 pushFollow(FOLLOW_cp_in_choice879);
\r
1337 if (state.failed) return retval;
\r
1338 if ( state.backtracking==0 ) stream_cp.add(cp29.getTree());
\r
1348 RParen30=(Token)match(input,RParen,FOLLOW_RParen_in_choice883); if (state.failed) return retval;
\r
1349 if ( state.backtracking==0 ) stream_RParen.add(RParen30);
\r
1356 // rule labels: retval
\r
1357 // token list labels:
\r
1358 // rule list labels:
\r
1359 // wildcard labels:
\r
1360 if ( state.backtracking==0 ) {
\r
1361 retval.tree = root_0;
\r
1362 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
1364 root_0 = (Object)adaptor.nil();
\r
1365 // 194:3: -> ( cp )+
\r
1367 if ( !(stream_cp.hasNext()) ) {
\r
1368 throw new RewriteEarlyExitException();
\r
1370 while ( stream_cp.hasNext() ) {
\r
1371 adaptor.addChild(root_0, stream_cp.nextTree());
\r
1374 stream_cp.reset();
\r
1378 retval.tree = root_0;}
\r
1381 retval.stop = input.LT(-1);
\r
1383 if ( state.backtracking==0 ) {
\r
1385 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
\r
1386 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
1389 catch (RecognitionException re) {
\r
1391 recover(input,re);
\r
1392 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
1399 // $ANTLR end "choice"
\r
1401 public static class seq_return extends ParserRuleReturnScope {
\r
1403 public Object getTree() { return tree; }
\r
1406 // $ANTLR start "seq"
\r
1407 // DTD.g:197:1: fragment seq : ( LParen cp Comma )=> LParen cp ( Comma cp )+ RParen -> ( cp )+ ;
\r
1408 public final DTDParser.seq_return seq() throws RecognitionException {
\r
1409 DTDParser.seq_return retval = new DTDParser.seq_return();
\r
1410 retval.start = input.LT(1);
\r
1412 Object root_0 = null;
\r
1414 Token LParen31=null;
\r
1415 Token Comma33=null;
\r
1416 Token RParen35=null;
\r
1417 DTDParser.cp_return cp32 = null;
\r
1419 DTDParser.cp_return cp34 = null;
\r
1422 Object LParen31_tree=null;
\r
1423 Object Comma33_tree=null;
\r
1424 Object RParen35_tree=null;
\r
1425 RewriteRuleTokenStream stream_Comma=new RewriteRuleTokenStream(adaptor,"token Comma");
\r
1426 RewriteRuleTokenStream stream_RParen=new RewriteRuleTokenStream(adaptor,"token RParen");
\r
1427 RewriteRuleTokenStream stream_LParen=new RewriteRuleTokenStream(adaptor,"token LParen");
\r
1428 RewriteRuleSubtreeStream stream_cp=new RewriteRuleSubtreeStream(adaptor,"rule cp");
\r
1430 // DTD.g:198:4: ( ( LParen cp Comma )=> LParen cp ( Comma cp )+ RParen -> ( cp )+ )
\r
1431 // DTD.g:198:6: ( LParen cp Comma )=> LParen cp ( Comma cp )+ RParen
\r
1433 LParen31=(Token)match(input,LParen,FOLLOW_LParen_in_seq912); if (state.failed) return retval;
\r
1434 if ( state.backtracking==0 ) stream_LParen.add(LParen31);
\r
1436 pushFollow(FOLLOW_cp_in_seq914);
\r
1440 if (state.failed) return retval;
\r
1441 if ( state.backtracking==0 ) stream_cp.add(cp32.getTree());
\r
1442 // DTD.g:198:37: ( Comma cp )+
\r
1447 int LA13_0 = input.LA(1);
\r
1449 if ( (LA13_0==Comma) ) {
\r
1456 // DTD.g:198:38: Comma cp
\r
1458 Comma33=(Token)match(input,Comma,FOLLOW_Comma_in_seq917); if (state.failed) return retval;
\r
1459 if ( state.backtracking==0 ) stream_Comma.add(Comma33);
\r
1461 pushFollow(FOLLOW_cp_in_seq919);
\r
1465 if (state.failed) return retval;
\r
1466 if ( state.backtracking==0 ) stream_cp.add(cp34.getTree());
\r
1472 if ( cnt13 >= 1 ) break loop13;
\r
1473 if (state.backtracking>0) {state.failed=true; return retval;}
\r
1474 EarlyExitException eee =
\r
1475 new EarlyExitException(13, input);
\r
1481 RParen35=(Token)match(input,RParen,FOLLOW_RParen_in_seq923); if (state.failed) return retval;
\r
1482 if ( state.backtracking==0 ) stream_RParen.add(RParen35);
\r
1489 // rule labels: retval
\r
1490 // token list labels:
\r
1491 // rule list labels:
\r
1492 // wildcard labels:
\r
1493 if ( state.backtracking==0 ) {
\r
1494 retval.tree = root_0;
\r
1495 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
1497 root_0 = (Object)adaptor.nil();
\r
1498 // 199:3: -> ( cp )+
\r
1500 if ( !(stream_cp.hasNext()) ) {
\r
1501 throw new RewriteEarlyExitException();
\r
1503 while ( stream_cp.hasNext() ) {
\r
1504 adaptor.addChild(root_0, stream_cp.nextTree());
\r
1507 stream_cp.reset();
\r
1511 retval.tree = root_0;}
\r
1514 retval.stop = input.LT(-1);
\r
1516 if ( state.backtracking==0 ) {
\r
1518 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
\r
1519 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
1522 catch (RecognitionException re) {
\r
1524 recover(input,re);
\r
1525 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
1532 // $ANTLR end "seq"
\r
1534 public static class mixed_return extends ParserRuleReturnScope {
\r
1536 public Object getTree() { return tree; }
\r
1539 // $ANTLR start "mixed"
\r
1540 // DTD.g:202:1: fragment mixed : ( LParen '#PCDATA' ( '|' mixed_i )* RParen '*' -> ^( COMPONENT TYPE[\"mixed\"] ( mixed_i )* ) | LParen '#PCDATA' RParen -> ^( COMPONENT TYPE[\"pcdata\"] ) );
\r
1541 public final DTDParser.mixed_return mixed() throws RecognitionException {
\r
1542 DTDParser.mixed_return retval = new DTDParser.mixed_return();
\r
1543 retval.start = input.LT(1);
\r
1545 Object root_0 = null;
\r
1547 Token LParen36=null;
\r
1548 Token string_literal37=null;
\r
1549 Token char_literal38=null;
\r
1550 Token RParen40=null;
\r
1551 Token char_literal41=null;
\r
1552 Token LParen42=null;
\r
1553 Token string_literal43=null;
\r
1554 Token RParen44=null;
\r
1555 DTDParser.mixed_i_return mixed_i39 = null;
\r
1558 Object LParen36_tree=null;
\r
1559 Object string_literal37_tree=null;
\r
1560 Object char_literal38_tree=null;
\r
1561 Object RParen40_tree=null;
\r
1562 Object char_literal41_tree=null;
\r
1563 Object LParen42_tree=null;
\r
1564 Object string_literal43_tree=null;
\r
1565 Object RParen44_tree=null;
\r
1566 RewriteRuleTokenStream stream_RParen=new RewriteRuleTokenStream(adaptor,"token RParen");
\r
1567 RewriteRuleTokenStream stream_50=new RewriteRuleTokenStream(adaptor,"token 50");
\r
1568 RewriteRuleTokenStream stream_47=new RewriteRuleTokenStream(adaptor,"token 47");
\r
1569 RewriteRuleTokenStream stream_49=new RewriteRuleTokenStream(adaptor,"token 49");
\r
1570 RewriteRuleTokenStream stream_LParen=new RewriteRuleTokenStream(adaptor,"token LParen");
\r
1571 RewriteRuleSubtreeStream stream_mixed_i=new RewriteRuleSubtreeStream(adaptor,"rule mixed_i");
\r
1573 // DTD.g:204:3: ( LParen '#PCDATA' ( '|' mixed_i )* RParen '*' -> ^( COMPONENT TYPE[\"mixed\"] ( mixed_i )* ) | LParen '#PCDATA' RParen -> ^( COMPONENT TYPE[\"pcdata\"] ) )
\r
1575 int LA15_0 = input.LA(1);
\r
1577 if ( (LA15_0==LParen) ) {
\r
1578 int LA15_1 = input.LA(2);
\r
1580 if ( (LA15_1==50) ) {
\r
1581 int LA15_2 = input.LA(3);
\r
1583 if ( (LA15_2==RParen) ) {
\r
1584 int LA15_3 = input.LA(4);
\r
1586 if ( (LA15_3==47) ) {
\r
1589 else if ( (LA15_3==43) ) {
\r
1593 if (state.backtracking>0) {state.failed=true; return retval;}
\r
1594 NoViableAltException nvae =
\r
1595 new NoViableAltException("", 15, 3, input);
\r
1600 else if ( (LA15_2==49) ) {
\r
1604 if (state.backtracking>0) {state.failed=true; return retval;}
\r
1605 NoViableAltException nvae =
\r
1606 new NoViableAltException("", 15, 2, input);
\r
1612 if (state.backtracking>0) {state.failed=true; return retval;}
\r
1613 NoViableAltException nvae =
\r
1614 new NoViableAltException("", 15, 1, input);
\r
1620 if (state.backtracking>0) {state.failed=true; return retval;}
\r
1621 NoViableAltException nvae =
\r
1622 new NoViableAltException("", 15, 0, input);
\r
1628 // DTD.g:204:5: LParen '#PCDATA' ( '|' mixed_i )* RParen '*'
\r
1630 LParen36=(Token)match(input,LParen,FOLLOW_LParen_in_mixed945); if (state.failed) return retval;
\r
1631 if ( state.backtracking==0 ) stream_LParen.add(LParen36);
\r
1633 string_literal37=(Token)match(input,50,FOLLOW_50_in_mixed947); if (state.failed) return retval;
\r
1634 if ( state.backtracking==0 ) stream_50.add(string_literal37);
\r
1636 // DTD.g:204:22: ( '|' mixed_i )*
\r
1640 int LA14_0 = input.LA(1);
\r
1642 if ( (LA14_0==49) ) {
\r
1649 // DTD.g:204:23: '|' mixed_i
\r
1651 char_literal38=(Token)match(input,49,FOLLOW_49_in_mixed950); if (state.failed) return retval;
\r
1652 if ( state.backtracking==0 ) stream_49.add(char_literal38);
\r
1654 pushFollow(FOLLOW_mixed_i_in_mixed952);
\r
1655 mixed_i39=mixed_i();
\r
1658 if (state.failed) return retval;
\r
1659 if ( state.backtracking==0 ) stream_mixed_i.add(mixed_i39.getTree());
\r
1669 RParen40=(Token)match(input,RParen,FOLLOW_RParen_in_mixed956); if (state.failed) return retval;
\r
1670 if ( state.backtracking==0 ) stream_RParen.add(RParen40);
\r
1672 char_literal41=(Token)match(input,47,FOLLOW_47_in_mixed958); if (state.failed) return retval;
\r
1673 if ( state.backtracking==0 ) stream_47.add(char_literal41);
\r
1678 // elements: mixed_i
\r
1680 // rule labels: retval
\r
1681 // token list labels:
\r
1682 // rule list labels:
\r
1683 // wildcard labels:
\r
1684 if ( state.backtracking==0 ) {
\r
1685 retval.tree = root_0;
\r
1686 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
1688 root_0 = (Object)adaptor.nil();
\r
1689 // 205:5: -> ^( COMPONENT TYPE[\"mixed\"] ( mixed_i )* )
\r
1691 // DTD.g:205:8: ^( COMPONENT TYPE[\"mixed\"] ( mixed_i )* )
\r
1693 Object root_1 = (Object)adaptor.nil();
\r
1694 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(COMPONENT, "COMPONENT"), root_1);
\r
1696 adaptor.addChild(root_1, (Object)adaptor.create(TYPE, "mixed"));
\r
1697 // DTD.g:205:34: ( mixed_i )*
\r
1698 while ( stream_mixed_i.hasNext() ) {
\r
1699 adaptor.addChild(root_1, stream_mixed_i.nextTree());
\r
1702 stream_mixed_i.reset();
\r
1704 adaptor.addChild(root_0, root_1);
\r
1709 retval.tree = root_0;}
\r
1713 // DTD.g:206:5: LParen '#PCDATA' RParen
\r
1715 LParen42=(Token)match(input,LParen,FOLLOW_LParen_in_mixed980); if (state.failed) return retval;
\r
1716 if ( state.backtracking==0 ) stream_LParen.add(LParen42);
\r
1718 string_literal43=(Token)match(input,50,FOLLOW_50_in_mixed982); if (state.failed) return retval;
\r
1719 if ( state.backtracking==0 ) stream_50.add(string_literal43);
\r
1721 RParen44=(Token)match(input,RParen,FOLLOW_RParen_in_mixed984); if (state.failed) return retval;
\r
1722 if ( state.backtracking==0 ) stream_RParen.add(RParen44);
\r
1729 // rule labels: retval
\r
1730 // token list labels:
\r
1731 // rule list labels:
\r
1732 // wildcard labels:
\r
1733 if ( state.backtracking==0 ) {
\r
1734 retval.tree = root_0;
\r
1735 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
1737 root_0 = (Object)adaptor.nil();
\r
1738 // 207:5: -> ^( COMPONENT TYPE[\"pcdata\"] )
\r
1740 // DTD.g:207:8: ^( COMPONENT TYPE[\"pcdata\"] )
\r
1742 Object root_1 = (Object)adaptor.nil();
\r
1743 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(COMPONENT, "COMPONENT"), root_1);
\r
1745 adaptor.addChild(root_1, (Object)adaptor.create(TYPE, "pcdata"));
\r
1747 adaptor.addChild(root_0, root_1);
\r
1752 retval.tree = root_0;}
\r
1757 retval.stop = input.LT(-1);
\r
1759 if ( state.backtracking==0 ) {
\r
1761 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
\r
1762 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
1765 catch (RecognitionException re) {
\r
1767 recover(input,re);
\r
1768 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
1775 // $ANTLR end "mixed"
\r
1777 public static class mixed_i_return extends ParserRuleReturnScope {
\r
1779 public Object getTree() { return tree; }
\r
1782 // $ANTLR start "mixed_i"
\r
1783 // DTD.g:210:1: mixed_i : Name -> NAME[$Name.text] ;
\r
1784 public final DTDParser.mixed_i_return mixed_i() throws RecognitionException {
\r
1785 DTDParser.mixed_i_return retval = new DTDParser.mixed_i_return();
\r
1786 retval.start = input.LT(1);
\r
1788 Object root_0 = null;
\r
1790 Token Name45=null;
\r
1792 Object Name45_tree=null;
\r
1793 RewriteRuleTokenStream stream_Name=new RewriteRuleTokenStream(adaptor,"token Name");
\r
1796 // DTD.g:211:3: ( Name -> NAME[$Name.text] )
\r
1797 // DTD.g:211:5: Name
\r
1799 Name45=(Token)match(input,Name,FOLLOW_Name_in_mixed_i1013); if (state.failed) return retval;
\r
1800 if ( state.backtracking==0 ) stream_Name.add(Name45);
\r
1807 // rule labels: retval
\r
1808 // token list labels:
\r
1809 // rule list labels:
\r
1810 // wildcard labels:
\r
1811 if ( state.backtracking==0 ) {
\r
1812 retval.tree = root_0;
\r
1813 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
1815 root_0 = (Object)adaptor.nil();
\r
1816 // 211:10: -> NAME[$Name.text]
\r
1818 adaptor.addChild(root_0, (Object)adaptor.create(NAME, (Name45!=null?Name45.getText():null)));
\r
1822 retval.tree = root_0;}
\r
1825 retval.stop = input.LT(-1);
\r
1827 if ( state.backtracking==0 ) {
\r
1829 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
\r
1830 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
1833 catch (RecognitionException re) {
\r
1835 recover(input,re);
\r
1836 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
1843 // $ANTLR end "mixed_i"
\r
1845 public static class attlistDecl_return extends ParserRuleReturnScope {
\r
1847 public Object getTree() { return tree; }
\r
1850 // $ANTLR start "attlistDecl"
\r
1851 // DTD.g:214:1: attlistDecl : '<!ATTLIST' Name ( attDef )* '>' -> ^( ATTLIST NAME[$Name.text] ( attDef )* ) ;
\r
1852 public final DTDParser.attlistDecl_return attlistDecl() throws RecognitionException {
\r
1853 DTDParser.attlistDecl_return retval = new DTDParser.attlistDecl_return();
\r
1854 retval.start = input.LT(1);
\r
1856 Object root_0 = null;
\r
1858 Token string_literal46=null;
\r
1859 Token Name47=null;
\r
1860 Token char_literal49=null;
\r
1861 DTDParser.attDef_return attDef48 = null;
\r
1864 Object string_literal46_tree=null;
\r
1865 Object Name47_tree=null;
\r
1866 Object char_literal49_tree=null;
\r
1867 RewriteRuleTokenStream stream_43=new RewriteRuleTokenStream(adaptor,"token 43");
\r
1868 RewriteRuleTokenStream stream_Name=new RewriteRuleTokenStream(adaptor,"token Name");
\r
1869 RewriteRuleTokenStream stream_51=new RewriteRuleTokenStream(adaptor,"token 51");
\r
1870 RewriteRuleSubtreeStream stream_attDef=new RewriteRuleSubtreeStream(adaptor,"rule attDef");
\r
1872 // DTD.g:214:12: ( '<!ATTLIST' Name ( attDef )* '>' -> ^( ATTLIST NAME[$Name.text] ( attDef )* ) )
\r
1873 // DTD.g:214:14: '<!ATTLIST' Name ( attDef )* '>'
\r
1875 string_literal46=(Token)match(input,51,FOLLOW_51_in_attlistDecl1034); if (state.failed) return retval;
\r
1876 if ( state.backtracking==0 ) stream_51.add(string_literal46);
\r
1878 Name47=(Token)match(input,Name,FOLLOW_Name_in_attlistDecl1036); if (state.failed) return retval;
\r
1879 if ( state.backtracking==0 ) stream_Name.add(Name47);
\r
1881 // DTD.g:214:31: ( attDef )*
\r
1885 int LA16_0 = input.LA(1);
\r
1887 if ( (LA16_0==Name) ) {
\r
1894 // DTD.g:214:31: attDef
\r
1896 pushFollow(FOLLOW_attDef_in_attlistDecl1038);
\r
1897 attDef48=attDef();
\r
1900 if (state.failed) return retval;
\r
1901 if ( state.backtracking==0 ) stream_attDef.add(attDef48.getTree());
\r
1911 char_literal49=(Token)match(input,43,FOLLOW_43_in_attlistDecl1041); if (state.failed) return retval;
\r
1912 if ( state.backtracking==0 ) stream_43.add(char_literal49);
\r
1917 // elements: attDef
\r
1919 // rule labels: retval
\r
1920 // token list labels:
\r
1921 // rule list labels:
\r
1922 // wildcard labels:
\r
1923 if ( state.backtracking==0 ) {
\r
1924 retval.tree = root_0;
\r
1925 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
1927 root_0 = (Object)adaptor.nil();
\r
1928 // 215:3: -> ^( ATTLIST NAME[$Name.text] ( attDef )* )
\r
1930 // DTD.g:215:6: ^( ATTLIST NAME[$Name.text] ( attDef )* )
\r
1932 Object root_1 = (Object)adaptor.nil();
\r
1933 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(ATTLIST, "ATTLIST"), root_1);
\r
1935 adaptor.addChild(root_1, (Object)adaptor.create(NAME, (Name47!=null?Name47.getText():null)));
\r
1936 // DTD.g:215:33: ( attDef )*
\r
1937 while ( stream_attDef.hasNext() ) {
\r
1938 adaptor.addChild(root_1, stream_attDef.nextTree());
\r
1941 stream_attDef.reset();
\r
1943 adaptor.addChild(root_0, root_1);
\r
1948 retval.tree = root_0;}
\r
1951 retval.stop = input.LT(-1);
\r
1953 if ( state.backtracking==0 ) {
\r
1955 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
\r
1956 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
1959 catch (RecognitionException re) {
\r
1961 recover(input,re);
\r
1962 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
1969 // $ANTLR end "attlistDecl"
\r
1971 public static class attDef_return extends ParserRuleReturnScope {
\r
1973 public Object getTree() { return tree; }
\r
1976 // $ANTLR start "attDef"
\r
1977 // DTD.g:218:1: fragment attDef : Name attType DefaultDecl -> ^( ATTRIBUTE NAME[$Name.text] attType DECL[$DefaultDecl.text] ) ;
\r
1978 public final DTDParser.attDef_return attDef() throws RecognitionException {
\r
1979 DTDParser.attDef_return retval = new DTDParser.attDef_return();
\r
1980 retval.start = input.LT(1);
\r
1982 Object root_0 = null;
\r
1984 Token Name50=null;
\r
1985 Token DefaultDecl52=null;
\r
1986 DTDParser.attType_return attType51 = null;
\r
1989 Object Name50_tree=null;
\r
1990 Object DefaultDecl52_tree=null;
\r
1991 RewriteRuleTokenStream stream_DefaultDecl=new RewriteRuleTokenStream(adaptor,"token DefaultDecl");
\r
1992 RewriteRuleTokenStream stream_Name=new RewriteRuleTokenStream(adaptor,"token Name");
\r
1993 RewriteRuleSubtreeStream stream_attType=new RewriteRuleSubtreeStream(adaptor,"rule attType");
\r
1995 // DTD.g:219:7: ( Name attType DefaultDecl -> ^( ATTRIBUTE NAME[$Name.text] attType DECL[$DefaultDecl.text] ) )
\r
1996 // DTD.g:219:9: Name attType DefaultDecl
\r
1998 Name50=(Token)match(input,Name,FOLLOW_Name_in_attDef1067); if (state.failed) return retval;
\r
1999 if ( state.backtracking==0 ) stream_Name.add(Name50);
\r
2001 pushFollow(FOLLOW_attType_in_attDef1069);
\r
2002 attType51=attType();
\r
2005 if (state.failed) return retval;
\r
2006 if ( state.backtracking==0 ) stream_attType.add(attType51.getTree());
\r
2007 DefaultDecl52=(Token)match(input,DefaultDecl,FOLLOW_DefaultDecl_in_attDef1071); if (state.failed) return retval;
\r
2008 if ( state.backtracking==0 ) stream_DefaultDecl.add(DefaultDecl52);
\r
2013 // elements: attType
\r
2015 // rule labels: retval
\r
2016 // token list labels:
\r
2017 // rule list labels:
\r
2018 // wildcard labels:
\r
2019 if ( state.backtracking==0 ) {
\r
2020 retval.tree = root_0;
\r
2021 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
2023 root_0 = (Object)adaptor.nil();
\r
2024 // 220:3: -> ^( ATTRIBUTE NAME[$Name.text] attType DECL[$DefaultDecl.text] )
\r
2026 // DTD.g:220:6: ^( ATTRIBUTE NAME[$Name.text] attType DECL[$DefaultDecl.text] )
\r
2028 Object root_1 = (Object)adaptor.nil();
\r
2029 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(ATTRIBUTE, "ATTRIBUTE"), root_1);
\r
2031 adaptor.addChild(root_1, (Object)adaptor.create(NAME, (Name50!=null?Name50.getText():null)));
\r
2032 adaptor.addChild(root_1, stream_attType.nextTree());
\r
2033 adaptor.addChild(root_1, (Object)adaptor.create(DECL, (DefaultDecl52!=null?DefaultDecl52.getText():null)));
\r
2035 adaptor.addChild(root_0, root_1);
\r
2040 retval.tree = root_0;}
\r
2043 retval.stop = input.LT(-1);
\r
2045 if ( state.backtracking==0 ) {
\r
2047 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
\r
2048 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
2051 catch (RecognitionException re) {
\r
2053 recover(input,re);
\r
2054 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
2061 // $ANTLR end "attDef"
\r
2063 public static class attType_return extends ParserRuleReturnScope {
\r
2065 public Object getTree() { return tree; }
\r
2068 // $ANTLR start "attType"
\r
2069 // DTD.g:223:1: fragment attType : ( stringType -> STRINGTYPE[$stringType.text] | tokenizedType -> TOKENIZEDTYPE[$tokenizedType.text] | enumeratedType -> ENUMTYPE[$enumeratedType.text] );
\r
2070 public final DTDParser.attType_return attType() throws RecognitionException {
\r
2071 DTDParser.attType_return retval = new DTDParser.attType_return();
\r
2072 retval.start = input.LT(1);
\r
2074 Object root_0 = null;
\r
2076 DTDParser.stringType_return stringType53 = null;
\r
2078 DTDParser.tokenizedType_return tokenizedType54 = null;
\r
2080 DTDParser.enumeratedType_return enumeratedType55 = null;
\r
2083 RewriteRuleSubtreeStream stream_enumeratedType=new RewriteRuleSubtreeStream(adaptor,"rule enumeratedType");
\r
2084 RewriteRuleSubtreeStream stream_tokenizedType=new RewriteRuleSubtreeStream(adaptor,"rule tokenizedType");
\r
2085 RewriteRuleSubtreeStream stream_stringType=new RewriteRuleSubtreeStream(adaptor,"rule stringType");
\r
2087 // DTD.g:225:3: ( stringType -> STRINGTYPE[$stringType.text] | tokenizedType -> TOKENIZEDTYPE[$tokenizedType.text] | enumeratedType -> ENUMTYPE[$enumeratedType.text] )
\r
2089 switch ( input.LA(1) ) {
\r
2113 if (state.backtracking>0) {state.failed=true; return retval;}
\r
2114 NoViableAltException nvae =
\r
2115 new NoViableAltException("", 17, 0, input);
\r
2122 // DTD.g:225:5: stringType
\r
2124 pushFollow(FOLLOW_stringType_in_attType1103);
\r
2125 stringType53=stringType();
\r
2128 if (state.failed) return retval;
\r
2129 if ( state.backtracking==0 ) stream_stringType.add(stringType53.getTree());
\r
2135 // rule labels: retval
\r
2136 // token list labels:
\r
2137 // rule list labels:
\r
2138 // wildcard labels:
\r
2139 if ( state.backtracking==0 ) {
\r
2140 retval.tree = root_0;
\r
2141 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
2143 root_0 = (Object)adaptor.nil();
\r
2144 // 225:16: -> STRINGTYPE[$stringType.text]
\r
2146 adaptor.addChild(root_0, (Object)adaptor.create(STRINGTYPE, (stringType53!=null?input.toString(stringType53.start,stringType53.stop):null)));
\r
2150 retval.tree = root_0;}
\r
2154 // DTD.g:226:5: tokenizedType
\r
2156 pushFollow(FOLLOW_tokenizedType_in_attType1115);
\r
2157 tokenizedType54=tokenizedType();
\r
2160 if (state.failed) return retval;
\r
2161 if ( state.backtracking==0 ) stream_tokenizedType.add(tokenizedType54.getTree());
\r
2167 // rule labels: retval
\r
2168 // token list labels:
\r
2169 // rule list labels:
\r
2170 // wildcard labels:
\r
2171 if ( state.backtracking==0 ) {
\r
2172 retval.tree = root_0;
\r
2173 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
2175 root_0 = (Object)adaptor.nil();
\r
2176 // 226:19: -> TOKENIZEDTYPE[$tokenizedType.text]
\r
2178 adaptor.addChild(root_0, (Object)adaptor.create(TOKENIZEDTYPE, (tokenizedType54!=null?input.toString(tokenizedType54.start,tokenizedType54.stop):null)));
\r
2182 retval.tree = root_0;}
\r
2186 // DTD.g:227:5: enumeratedType
\r
2188 pushFollow(FOLLOW_enumeratedType_in_attType1127);
\r
2189 enumeratedType55=enumeratedType();
\r
2192 if (state.failed) return retval;
\r
2193 if ( state.backtracking==0 ) stream_enumeratedType.add(enumeratedType55.getTree());
\r
2199 // rule labels: retval
\r
2200 // token list labels:
\r
2201 // rule list labels:
\r
2202 // wildcard labels:
\r
2203 if ( state.backtracking==0 ) {
\r
2204 retval.tree = root_0;
\r
2205 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
2207 root_0 = (Object)adaptor.nil();
\r
2208 // 227:20: -> ENUMTYPE[$enumeratedType.text]
\r
2210 adaptor.addChild(root_0, (Object)adaptor.create(ENUMTYPE, (enumeratedType55!=null?input.toString(enumeratedType55.start,enumeratedType55.stop):null)));
\r
2214 retval.tree = root_0;}
\r
2219 retval.stop = input.LT(-1);
\r
2221 if ( state.backtracking==0 ) {
\r
2223 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
\r
2224 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
2227 catch (RecognitionException re) {
\r
2229 recover(input,re);
\r
2230 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
2237 // $ANTLR end "attType"
\r
2239 public static class enumeration_return extends ParserRuleReturnScope {
\r
2241 public Object getTree() { return tree; }
\r
2244 // $ANTLR start "enumeration"
\r
2245 // DTD.g:230:1: fragment enumeration : LParen Name ( '|' Name )* RParen ;
\r
2246 public final DTDParser.enumeration_return enumeration() throws RecognitionException {
\r
2247 DTDParser.enumeration_return retval = new DTDParser.enumeration_return();
\r
2248 retval.start = input.LT(1);
\r
2250 Object root_0 = null;
\r
2252 Token LParen56=null;
\r
2253 Token Name57=null;
\r
2254 Token char_literal58=null;
\r
2255 Token Name59=null;
\r
2256 Token RParen60=null;
\r
2258 Object LParen56_tree=null;
\r
2259 Object Name57_tree=null;
\r
2260 Object char_literal58_tree=null;
\r
2261 Object Name59_tree=null;
\r
2262 Object RParen60_tree=null;
\r
2265 // DTD.g:231:12: ( LParen Name ( '|' Name )* RParen )
\r
2266 // DTD.g:231:14: LParen Name ( '|' Name )* RParen
\r
2268 root_0 = (Object)adaptor.nil();
\r
2270 LParen56=(Token)match(input,LParen,FOLLOW_LParen_in_enumeration1144); if (state.failed) return retval;
\r
2271 if ( state.backtracking==0 ) {
\r
2272 LParen56_tree = (Object)adaptor.create(LParen56);
\r
2273 adaptor.addChild(root_0, LParen56_tree);
\r
2275 Name57=(Token)match(input,Name,FOLLOW_Name_in_enumeration1146); if (state.failed) return retval;
\r
2276 if ( state.backtracking==0 ) {
\r
2277 Name57_tree = (Object)adaptor.create(Name57);
\r
2278 adaptor.addChild(root_0, Name57_tree);
\r
2280 // DTD.g:231:26: ( '|' Name )*
\r
2284 int LA18_0 = input.LA(1);
\r
2286 if ( (LA18_0==49) ) {
\r
2293 // DTD.g:231:27: '|' Name
\r
2295 char_literal58=(Token)match(input,49,FOLLOW_49_in_enumeration1149); if (state.failed) return retval;
\r
2296 if ( state.backtracking==0 ) {
\r
2297 char_literal58_tree = (Object)adaptor.create(char_literal58);
\r
2298 adaptor.addChild(root_0, char_literal58_tree);
\r
2300 Name59=(Token)match(input,Name,FOLLOW_Name_in_enumeration1151); if (state.failed) return retval;
\r
2301 if ( state.backtracking==0 ) {
\r
2302 Name59_tree = (Object)adaptor.create(Name59);
\r
2303 adaptor.addChild(root_0, Name59_tree);
\r
2314 RParen60=(Token)match(input,RParen,FOLLOW_RParen_in_enumeration1155); if (state.failed) return retval;
\r
2315 if ( state.backtracking==0 ) {
\r
2316 RParen60_tree = (Object)adaptor.create(RParen60);
\r
2317 adaptor.addChild(root_0, RParen60_tree);
\r
2322 retval.stop = input.LT(-1);
\r
2324 if ( state.backtracking==0 ) {
\r
2326 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
\r
2327 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
2330 catch (RecognitionException re) {
\r
2332 recover(input,re);
\r
2333 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
2340 // $ANTLR end "enumeration"
\r
2342 public static class enumeratedType_return extends ParserRuleReturnScope {
\r
2344 public Object getTree() { return tree; }
\r
2347 // $ANTLR start "enumeratedType"
\r
2348 // DTD.g:232:1: fragment enumeratedType : ( notationType | enumeration );
\r
2349 public final DTDParser.enumeratedType_return enumeratedType() throws RecognitionException {
\r
2350 DTDParser.enumeratedType_return retval = new DTDParser.enumeratedType_return();
\r
2351 retval.start = input.LT(1);
\r
2353 Object root_0 = null;
\r
2355 DTDParser.notationType_return notationType61 = null;
\r
2357 DTDParser.enumeration_return enumeration62 = null;
\r
2362 // DTD.g:233:15: ( notationType | enumeration )
\r
2364 int LA19_0 = input.LA(1);
\r
2366 if ( (LA19_0==52) ) {
\r
2369 else if ( (LA19_0==LParen) ) {
\r
2373 if (state.backtracking>0) {state.failed=true; return retval;}
\r
2374 NoViableAltException nvae =
\r
2375 new NoViableAltException("", 19, 0, input);
\r
2381 // DTD.g:233:17: notationType
\r
2383 root_0 = (Object)adaptor.nil();
\r
2385 pushFollow(FOLLOW_notationType_in_enumeratedType1163);
\r
2386 notationType61=notationType();
\r
2389 if (state.failed) return retval;
\r
2390 if ( state.backtracking==0 ) adaptor.addChild(root_0, notationType61.getTree());
\r
2395 // DTD.g:233:32: enumeration
\r
2397 root_0 = (Object)adaptor.nil();
\r
2399 pushFollow(FOLLOW_enumeration_in_enumeratedType1167);
\r
2400 enumeration62=enumeration();
\r
2403 if (state.failed) return retval;
\r
2404 if ( state.backtracking==0 ) adaptor.addChild(root_0, enumeration62.getTree());
\r
2410 retval.stop = input.LT(-1);
\r
2412 if ( state.backtracking==0 ) {
\r
2414 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
\r
2415 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
2418 catch (RecognitionException re) {
\r
2420 recover(input,re);
\r
2421 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
2428 // $ANTLR end "enumeratedType"
\r
2430 public static class notationType_return extends ParserRuleReturnScope {
\r
2432 public Object getTree() { return tree; }
\r
2435 // $ANTLR start "notationType"
\r
2436 // DTD.g:234:1: fragment notationType : 'NOTATION' LParen Name ( '|' Name )* RParen ;
\r
2437 public final DTDParser.notationType_return notationType() throws RecognitionException {
\r
2438 DTDParser.notationType_return retval = new DTDParser.notationType_return();
\r
2439 retval.start = input.LT(1);
\r
2441 Object root_0 = null;
\r
2443 Token string_literal63=null;
\r
2444 Token LParen64=null;
\r
2445 Token Name65=null;
\r
2446 Token char_literal66=null;
\r
2447 Token Name67=null;
\r
2448 Token RParen68=null;
\r
2450 Object string_literal63_tree=null;
\r
2451 Object LParen64_tree=null;
\r
2452 Object Name65_tree=null;
\r
2453 Object char_literal66_tree=null;
\r
2454 Object Name67_tree=null;
\r
2455 Object RParen68_tree=null;
\r
2458 // DTD.g:235:13: ( 'NOTATION' LParen Name ( '|' Name )* RParen )
\r
2459 // DTD.g:235:15: 'NOTATION' LParen Name ( '|' Name )* RParen
\r
2461 root_0 = (Object)adaptor.nil();
\r
2463 string_literal63=(Token)match(input,52,FOLLOW_52_in_notationType1175); if (state.failed) return retval;
\r
2464 if ( state.backtracking==0 ) {
\r
2465 string_literal63_tree = (Object)adaptor.create(string_literal63);
\r
2466 adaptor.addChild(root_0, string_literal63_tree);
\r
2468 LParen64=(Token)match(input,LParen,FOLLOW_LParen_in_notationType1177); if (state.failed) return retval;
\r
2469 if ( state.backtracking==0 ) {
\r
2470 LParen64_tree = (Object)adaptor.create(LParen64);
\r
2471 adaptor.addChild(root_0, LParen64_tree);
\r
2473 Name65=(Token)match(input,Name,FOLLOW_Name_in_notationType1179); if (state.failed) return retval;
\r
2474 if ( state.backtracking==0 ) {
\r
2475 Name65_tree = (Object)adaptor.create(Name65);
\r
2476 adaptor.addChild(root_0, Name65_tree);
\r
2478 // DTD.g:235:38: ( '|' Name )*
\r
2482 int LA20_0 = input.LA(1);
\r
2484 if ( (LA20_0==49) ) {
\r
2491 // DTD.g:235:39: '|' Name
\r
2493 char_literal66=(Token)match(input,49,FOLLOW_49_in_notationType1182); if (state.failed) return retval;
\r
2494 if ( state.backtracking==0 ) {
\r
2495 char_literal66_tree = (Object)adaptor.create(char_literal66);
\r
2496 adaptor.addChild(root_0, char_literal66_tree);
\r
2498 Name67=(Token)match(input,Name,FOLLOW_Name_in_notationType1184); if (state.failed) return retval;
\r
2499 if ( state.backtracking==0 ) {
\r
2500 Name67_tree = (Object)adaptor.create(Name67);
\r
2501 adaptor.addChild(root_0, Name67_tree);
\r
2512 RParen68=(Token)match(input,RParen,FOLLOW_RParen_in_notationType1188); if (state.failed) return retval;
\r
2513 if ( state.backtracking==0 ) {
\r
2514 RParen68_tree = (Object)adaptor.create(RParen68);
\r
2515 adaptor.addChild(root_0, RParen68_tree);
\r
2520 retval.stop = input.LT(-1);
\r
2522 if ( state.backtracking==0 ) {
\r
2524 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
\r
2525 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
2528 catch (RecognitionException re) {
\r
2530 recover(input,re);
\r
2531 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
2538 // $ANTLR end "notationType"
\r
2540 public static class stringType_return extends ParserRuleReturnScope {
\r
2542 public Object getTree() { return tree; }
\r
2545 // $ANTLR start "stringType"
\r
2546 // DTD.g:237:1: fragment stringType : 'CDATA' ;
\r
2547 public final DTDParser.stringType_return stringType() throws RecognitionException {
\r
2548 DTDParser.stringType_return retval = new DTDParser.stringType_return();
\r
2549 retval.start = input.LT(1);
\r
2551 Object root_0 = null;
\r
2553 Token string_literal69=null;
\r
2555 Object string_literal69_tree=null;
\r
2558 // DTD.g:238:11: ( 'CDATA' )
\r
2559 // DTD.g:238:13: 'CDATA'
\r
2561 root_0 = (Object)adaptor.nil();
\r
2563 string_literal69=(Token)match(input,53,FOLLOW_53_in_stringType1197); if (state.failed) return retval;
\r
2564 if ( state.backtracking==0 ) {
\r
2565 string_literal69_tree = (Object)adaptor.create(string_literal69);
\r
2566 adaptor.addChild(root_0, string_literal69_tree);
\r
2571 retval.stop = input.LT(-1);
\r
2573 if ( state.backtracking==0 ) {
\r
2575 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
\r
2576 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
2579 catch (RecognitionException re) {
\r
2581 recover(input,re);
\r
2582 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
2589 // $ANTLR end "stringType"
\r
2591 public static class tokenizedType_return extends ParserRuleReturnScope {
\r
2593 public Object getTree() { return tree; }
\r
2596 // $ANTLR start "tokenizedType"
\r
2597 // DTD.g:241:1: fragment tokenizedType : ( 'ID' | 'IDREF' | 'IDREFS' | 'ENTITY' | 'ENTITIES' | 'NMTOKEN' | 'NMTOKENS' );
\r
2598 public final DTDParser.tokenizedType_return tokenizedType() throws RecognitionException {
\r
2599 DTDParser.tokenizedType_return retval = new DTDParser.tokenizedType_return();
\r
2600 retval.start = input.LT(1);
\r
2602 Object root_0 = null;
\r
2606 Object set70_tree=null;
\r
2609 // DTD.g:243:3: ( 'ID' | 'IDREF' | 'IDREFS' | 'ENTITY' | 'ENTITIES' | 'NMTOKEN' | 'NMTOKENS' )
\r
2612 root_0 = (Object)adaptor.nil();
\r
2614 set70=(Token)input.LT(1);
\r
2615 if ( (input.LA(1)>=54 && input.LA(1)<=60) ) {
\r
2617 if ( state.backtracking==0 ) adaptor.addChild(root_0, (Object)adaptor.create(set70));
\r
2618 state.errorRecovery=false;state.failed=false;
\r
2621 if (state.backtracking>0) {state.failed=true; return retval;}
\r
2622 MismatchedSetException mse = new MismatchedSetException(null,input);
\r
2629 retval.stop = input.LT(-1);
\r
2631 if ( state.backtracking==0 ) {
\r
2633 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
\r
2634 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
2637 catch (RecognitionException re) {
\r
2639 recover(input,re);
\r
2640 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
2647 // $ANTLR end "tokenizedType"
\r
2649 public static class entityDecl_return extends ParserRuleReturnScope {
\r
2651 public Object getTree() { return tree; }
\r
2654 // $ANTLR start "entityDecl"
\r
2655 // DTD.g:247:1: entityDecl : ( '<!ENTITY' Name String '>' -> ^( ENTITY NAME[$Name.text] VALUE[$String.text] ) | '<!ENTITY' '%' Name String '>' -> ^( ENTITY_REF NAME[$Name.text] VALUE[$String.text] ) );
\r
2656 public final DTDParser.entityDecl_return entityDecl() throws RecognitionException {
\r
2657 DTDParser.entityDecl_return retval = new DTDParser.entityDecl_return();
\r
2658 retval.start = input.LT(1);
\r
2660 Object root_0 = null;
\r
2662 Token string_literal71=null;
\r
2663 Token Name72=null;
\r
2664 Token String73=null;
\r
2665 Token char_literal74=null;
\r
2666 Token string_literal75=null;
\r
2667 Token char_literal76=null;
\r
2668 Token Name77=null;
\r
2669 Token String78=null;
\r
2670 Token char_literal79=null;
\r
2672 Object string_literal71_tree=null;
\r
2673 Object Name72_tree=null;
\r
2674 Object String73_tree=null;
\r
2675 Object char_literal74_tree=null;
\r
2676 Object string_literal75_tree=null;
\r
2677 Object char_literal76_tree=null;
\r
2678 Object Name77_tree=null;
\r
2679 Object String78_tree=null;
\r
2680 Object char_literal79_tree=null;
\r
2681 RewriteRuleTokenStream stream_String=new RewriteRuleTokenStream(adaptor,"token String");
\r
2682 RewriteRuleTokenStream stream_43=new RewriteRuleTokenStream(adaptor,"token 43");
\r
2683 RewriteRuleTokenStream stream_61=new RewriteRuleTokenStream(adaptor,"token 61");
\r
2684 RewriteRuleTokenStream stream_62=new RewriteRuleTokenStream(adaptor,"token 62");
\r
2685 RewriteRuleTokenStream stream_Name=new RewriteRuleTokenStream(adaptor,"token Name");
\r
2688 // DTD.g:248:3: ( '<!ENTITY' Name String '>' -> ^( ENTITY NAME[$Name.text] VALUE[$String.text] ) | '<!ENTITY' '%' Name String '>' -> ^( ENTITY_REF NAME[$Name.text] VALUE[$String.text] ) )
\r
2690 int LA21_0 = input.LA(1);
\r
2692 if ( (LA21_0==61) ) {
\r
2693 int LA21_1 = input.LA(2);
\r
2695 if ( (LA21_1==Name) ) {
\r
2698 else if ( (LA21_1==62) ) {
\r
2702 if (state.backtracking>0) {state.failed=true; return retval;}
\r
2703 NoViableAltException nvae =
\r
2704 new NoViableAltException("", 21, 1, input);
\r
2710 if (state.backtracking>0) {state.failed=true; return retval;}
\r
2711 NoViableAltException nvae =
\r
2712 new NoViableAltException("", 21, 0, input);
\r
2718 // DTD.g:248:5: '<!ENTITY' Name String '>'
\r
2720 string_literal71=(Token)match(input,61,FOLLOW_61_in_entityDecl1249); if (state.failed) return retval;
\r
2721 if ( state.backtracking==0 ) stream_61.add(string_literal71);
\r
2723 Name72=(Token)match(input,Name,FOLLOW_Name_in_entityDecl1251); if (state.failed) return retval;
\r
2724 if ( state.backtracking==0 ) stream_Name.add(Name72);
\r
2726 String73=(Token)match(input,String,FOLLOW_String_in_entityDecl1253); if (state.failed) return retval;
\r
2727 if ( state.backtracking==0 ) stream_String.add(String73);
\r
2729 char_literal74=(Token)match(input,43,FOLLOW_43_in_entityDecl1255); if (state.failed) return retval;
\r
2730 if ( state.backtracking==0 ) stream_43.add(char_literal74);
\r
2737 // rule labels: retval
\r
2738 // token list labels:
\r
2739 // rule list labels:
\r
2740 // wildcard labels:
\r
2741 if ( state.backtracking==0 ) {
\r
2742 retval.tree = root_0;
\r
2743 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
2745 root_0 = (Object)adaptor.nil();
\r
2746 // 248:32: -> ^( ENTITY NAME[$Name.text] VALUE[$String.text] )
\r
2748 // DTD.g:248:35: ^( ENTITY NAME[$Name.text] VALUE[$String.text] )
\r
2750 Object root_1 = (Object)adaptor.nil();
\r
2751 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(ENTITY, "ENTITY"), root_1);
\r
2753 adaptor.addChild(root_1, (Object)adaptor.create(NAME, (Name72!=null?Name72.getText():null)));
\r
2754 adaptor.addChild(root_1, (Object)adaptor.create(VALUE, (String73!=null?String73.getText():null)));
\r
2756 adaptor.addChild(root_0, root_1);
\r
2761 retval.tree = root_0;}
\r
2765 // DTD.g:249:5: '<!ENTITY' '%' Name String '>'
\r
2767 string_literal75=(Token)match(input,61,FOLLOW_61_in_entityDecl1273); if (state.failed) return retval;
\r
2768 if ( state.backtracking==0 ) stream_61.add(string_literal75);
\r
2770 char_literal76=(Token)match(input,62,FOLLOW_62_in_entityDecl1275); if (state.failed) return retval;
\r
2771 if ( state.backtracking==0 ) stream_62.add(char_literal76);
\r
2773 Name77=(Token)match(input,Name,FOLLOW_Name_in_entityDecl1277); if (state.failed) return retval;
\r
2774 if ( state.backtracking==0 ) stream_Name.add(Name77);
\r
2776 String78=(Token)match(input,String,FOLLOW_String_in_entityDecl1279); if (state.failed) return retval;
\r
2777 if ( state.backtracking==0 ) stream_String.add(String78);
\r
2779 char_literal79=(Token)match(input,43,FOLLOW_43_in_entityDecl1281); if (state.failed) return retval;
\r
2780 if ( state.backtracking==0 ) stream_43.add(char_literal79);
\r
2787 // rule labels: retval
\r
2788 // token list labels:
\r
2789 // rule list labels:
\r
2790 // wildcard labels:
\r
2791 if ( state.backtracking==0 ) {
\r
2792 retval.tree = root_0;
\r
2793 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
\r
2795 root_0 = (Object)adaptor.nil();
\r
2796 // 249:36: -> ^( ENTITY_REF NAME[$Name.text] VALUE[$String.text] )
\r
2798 // DTD.g:249:39: ^( ENTITY_REF NAME[$Name.text] VALUE[$String.text] )
\r
2800 Object root_1 = (Object)adaptor.nil();
\r
2801 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(ENTITY_REF, "ENTITY_REF"), root_1);
\r
2803 adaptor.addChild(root_1, (Object)adaptor.create(NAME, (Name77!=null?Name77.getText():null)));
\r
2804 adaptor.addChild(root_1, (Object)adaptor.create(VALUE, (String78!=null?String78.getText():null)));
\r
2806 adaptor.addChild(root_0, root_1);
\r
2811 retval.tree = root_0;}
\r
2816 retval.stop = input.LT(-1);
\r
2818 if ( state.backtracking==0 ) {
\r
2820 retval.tree = (Object)adaptor.rulePostProcessing(root_0);
\r
2821 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
\r
2824 catch (RecognitionException re) {
\r
2826 recover(input,re);
\r
2827 retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
\r
2834 // $ANTLR end "entityDecl"
\r
2836 // $ANTLR start synpred1_DTD
\r
2837 public final void synpred1_DTD_fragment() throws RecognitionException {
\r
2838 // DTD.g:173:3: ( choice )
\r
2839 // DTD.g:173:4: choice
\r
2841 pushFollow(FOLLOW_choice_in_synpred1_DTD673);
\r
2845 if (state.failed) return ;
\r
2849 // $ANTLR end synpred1_DTD
\r
2851 // $ANTLR start synpred2_DTD
\r
2852 public final void synpred2_DTD_fragment() throws RecognitionException {
\r
2853 // DTD.g:174:3: ( seq )
\r
2854 // DTD.g:174:4: seq
\r
2856 pushFollow(FOLLOW_seq_in_synpred2_DTD702);
\r
2860 if (state.failed) return ;
\r
2864 // $ANTLR end synpred2_DTD
\r
2866 // $ANTLR start synpred3_DTD
\r
2867 public final void synpred3_DTD_fragment() throws RecognitionException {
\r
2868 // DTD.g:179:3: ( Name )
\r
2869 // DTD.g:179:4: Name
\r
2871 match(input,Name,FOLLOW_Name_in_synpred3_DTD738); if (state.failed) return ;
\r
2875 // $ANTLR end synpred3_DTD
\r
2877 // $ANTLR start synpred4_DTD
\r
2878 public final void synpred4_DTD_fragment() throws RecognitionException {
\r
2879 // DTD.g:180:4: ( choice )
\r
2880 // DTD.g:180:5: choice
\r
2882 pushFollow(FOLLOW_choice_in_synpred4_DTD765);
\r
2886 if (state.failed) return ;
\r
2890 // $ANTLR end synpred4_DTD
\r
2892 // $ANTLR start synpred5_DTD
\r
2893 public final void synpred5_DTD_fragment() throws RecognitionException {
\r
2894 // DTD.g:181:4: ( seq )
\r
2895 // DTD.g:181:5: seq
\r
2897 pushFollow(FOLLOW_seq_in_synpred5_DTD794);
\r
2901 if (state.failed) return ;
\r
2905 // $ANTLR end synpred5_DTD
\r
2907 // Delegated rules
\r
2909 public final boolean synpred5_DTD() {
\r
2910 state.backtracking++;
\r
2911 int start = input.mark();
\r
2913 synpred5_DTD_fragment(); // can never throw exception
\r
2914 } catch (RecognitionException re) {
\r
2915 System.err.println("impossible: "+re);
\r
2917 boolean success = !state.failed;
\r
2918 input.rewind(start);
\r
2919 state.backtracking--;
\r
2920 state.failed=false;
\r
2923 public final boolean synpred2_DTD() {
\r
2924 state.backtracking++;
\r
2925 int start = input.mark();
\r
2927 synpred2_DTD_fragment(); // can never throw exception
\r
2928 } catch (RecognitionException re) {
\r
2929 System.err.println("impossible: "+re);
\r
2931 boolean success = !state.failed;
\r
2932 input.rewind(start);
\r
2933 state.backtracking--;
\r
2934 state.failed=false;
\r
2937 public final boolean synpred1_DTD() {
\r
2938 state.backtracking++;
\r
2939 int start = input.mark();
\r
2941 synpred1_DTD_fragment(); // can never throw exception
\r
2942 } catch (RecognitionException re) {
\r
2943 System.err.println("impossible: "+re);
\r
2945 boolean success = !state.failed;
\r
2946 input.rewind(start);
\r
2947 state.backtracking--;
\r
2948 state.failed=false;
\r
2951 public final boolean synpred3_DTD() {
\r
2952 state.backtracking++;
\r
2953 int start = input.mark();
\r
2955 synpred3_DTD_fragment(); // can never throw exception
\r
2956 } catch (RecognitionException re) {
\r
2957 System.err.println("impossible: "+re);
\r
2959 boolean success = !state.failed;
\r
2960 input.rewind(start);
\r
2961 state.backtracking--;
\r
2962 state.failed=false;
\r
2965 public final boolean synpred4_DTD() {
\r
2966 state.backtracking++;
\r
2967 int start = input.mark();
\r
2969 synpred4_DTD_fragment(); // can never throw exception
\r
2970 } catch (RecognitionException re) {
\r
2971 System.err.println("impossible: "+re);
\r
2973 boolean success = !state.failed;
\r
2974 input.rewind(start);
\r
2975 state.backtracking--;
\r
2976 state.failed=false;
\r
2983 public static final BitSet FOLLOW_markupdecl_in_dtd552 = new BitSet(new long[]{0x2008040000000002L});
\r
2984 public static final BitSet FOLLOW_elementDecl_in_markupdecl574 = new BitSet(new long[]{0x0000000000000002L});
\r
2985 public static final BitSet FOLLOW_attlistDecl_in_markupdecl578 = new BitSet(new long[]{0x0000000000000002L});
\r
2986 public static final BitSet FOLLOW_entityDecl_in_markupdecl582 = new BitSet(new long[]{0x0000000000000002L});
\r
2987 public static final BitSet FOLLOW_Element_in_elementDecl590 = new BitSet(new long[]{0x0000001000000000L});
\r
2988 public static final BitSet FOLLOW_Name_in_elementDecl592 = new BitSet(new long[]{0x0000300010000000L});
\r
2989 public static final BitSet FOLLOW_contentSpec_in_elementDecl594 = new BitSet(new long[]{0x0000080000000000L});
\r
2990 public static final BitSet FOLLOW_43_in_elementDecl596 = new BitSet(new long[]{0x0000000000000002L});
\r
2991 public static final BitSet FOLLOW_44_in_contentSpec624 = new BitSet(new long[]{0x0000000000000002L});
\r
2992 public static final BitSet FOLLOW_45_in_contentSpec635 = new BitSet(new long[]{0x0000000000000002L});
\r
2993 public static final BitSet FOLLOW_mixed_in_contentSpec648 = new BitSet(new long[]{0x0000000000000002L});
\r
2994 public static final BitSet FOLLOW_children_in_contentSpec655 = new BitSet(new long[]{0x0000000000000002L});
\r
2995 public static final BitSet FOLLOW_choice_in_children678 = new BitSet(new long[]{0x0001C00000000002L});
\r
2996 public static final BitSet FOLLOW_plural_in_children681 = new BitSet(new long[]{0x0000000000000002L});
\r
2997 public static final BitSet FOLLOW_seq_in_children707 = new BitSet(new long[]{0x0001C00000000002L});
\r
2998 public static final BitSet FOLLOW_plural_in_children709 = new BitSet(new long[]{0x0000000000000002L});
\r
2999 public static final BitSet FOLLOW_Name_in_cp743 = new BitSet(new long[]{0x0001C00000000002L});
\r
3000 public static final BitSet FOLLOW_plural_in_cp746 = new BitSet(new long[]{0x0000000000000002L});
\r
3001 public static final BitSet FOLLOW_choice_in_cp770 = new BitSet(new long[]{0x0001C00000000002L});
\r
3002 public static final BitSet FOLLOW_plural_in_cp773 = new BitSet(new long[]{0x0000000000000002L});
\r
3003 public static final BitSet FOLLOW_seq_in_cp799 = new BitSet(new long[]{0x0001C00000000002L});
\r
3004 public static final BitSet FOLLOW_plural_in_cp802 = new BitSet(new long[]{0x0000000000000002L});
\r
3005 public static final BitSet FOLLOW_46_in_plural830 = new BitSet(new long[]{0x0000000000000002L});
\r
3006 public static final BitSet FOLLOW_47_in_plural841 = new BitSet(new long[]{0x0000000000000002L});
\r
3007 public static final BitSet FOLLOW_48_in_plural852 = new BitSet(new long[]{0x0000000000000002L});
\r
3008 public static final BitSet FOLLOW_LParen_in_choice872 = new BitSet(new long[]{0x0000301010000000L});
\r
3009 public static final BitSet FOLLOW_cp_in_choice874 = new BitSet(new long[]{0x0002000020000000L});
\r
3010 public static final BitSet FOLLOW_49_in_choice877 = new BitSet(new long[]{0x0000301010000000L});
\r
3011 public static final BitSet FOLLOW_cp_in_choice879 = new BitSet(new long[]{0x0002000020000000L});
\r
3012 public static final BitSet FOLLOW_RParen_in_choice883 = new BitSet(new long[]{0x0000000000000002L});
\r
3013 public static final BitSet FOLLOW_LParen_in_seq912 = new BitSet(new long[]{0x0000301010000000L});
\r
3014 public static final BitSet FOLLOW_cp_in_seq914 = new BitSet(new long[]{0x0000000000800000L});
\r
3015 public static final BitSet FOLLOW_Comma_in_seq917 = new BitSet(new long[]{0x0000301010000000L});
\r
3016 public static final BitSet FOLLOW_cp_in_seq919 = new BitSet(new long[]{0x0000000020800000L});
\r
3017 public static final BitSet FOLLOW_RParen_in_seq923 = new BitSet(new long[]{0x0000000000000002L});
\r
3018 public static final BitSet FOLLOW_LParen_in_mixed945 = new BitSet(new long[]{0x0004000000000000L});
\r
3019 public static final BitSet FOLLOW_50_in_mixed947 = new BitSet(new long[]{0x0002000020000000L});
\r
3020 public static final BitSet FOLLOW_49_in_mixed950 = new BitSet(new long[]{0x0000001000000000L});
\r
3021 public static final BitSet FOLLOW_mixed_i_in_mixed952 = new BitSet(new long[]{0x0002000020000000L});
\r
3022 public static final BitSet FOLLOW_RParen_in_mixed956 = new BitSet(new long[]{0x0000800000000000L});
\r
3023 public static final BitSet FOLLOW_47_in_mixed958 = new BitSet(new long[]{0x0000000000000002L});
\r
3024 public static final BitSet FOLLOW_LParen_in_mixed980 = new BitSet(new long[]{0x0004000000000000L});
\r
3025 public static final BitSet FOLLOW_50_in_mixed982 = new BitSet(new long[]{0x0000000020000000L});
\r
3026 public static final BitSet FOLLOW_RParen_in_mixed984 = new BitSet(new long[]{0x0000000000000002L});
\r
3027 public static final BitSet FOLLOW_Name_in_mixed_i1013 = new BitSet(new long[]{0x0000000000000002L});
\r
3028 public static final BitSet FOLLOW_51_in_attlistDecl1034 = new BitSet(new long[]{0x0000001000000000L});
\r
3029 public static final BitSet FOLLOW_Name_in_attlistDecl1036 = new BitSet(new long[]{0x0000081000000000L});
\r
3030 public static final BitSet FOLLOW_attDef_in_attlistDecl1038 = new BitSet(new long[]{0x0000081000000000L});
\r
3031 public static final BitSet FOLLOW_43_in_attlistDecl1041 = new BitSet(new long[]{0x0000000000000002L});
\r
3032 public static final BitSet FOLLOW_Name_in_attDef1067 = new BitSet(new long[]{0x1FF0000010000000L});
\r
3033 public static final BitSet FOLLOW_attType_in_attDef1069 = new BitSet(new long[]{0x0000020000000000L});
\r
3034 public static final BitSet FOLLOW_DefaultDecl_in_attDef1071 = new BitSet(new long[]{0x0000000000000002L});
\r
3035 public static final BitSet FOLLOW_stringType_in_attType1103 = new BitSet(new long[]{0x0000000000000002L});
\r
3036 public static final BitSet FOLLOW_tokenizedType_in_attType1115 = new BitSet(new long[]{0x0000000000000002L});
\r
3037 public static final BitSet FOLLOW_enumeratedType_in_attType1127 = new BitSet(new long[]{0x0000000000000002L});
\r
3038 public static final BitSet FOLLOW_LParen_in_enumeration1144 = new BitSet(new long[]{0x0000001000000000L});
\r
3039 public static final BitSet FOLLOW_Name_in_enumeration1146 = new BitSet(new long[]{0x0002000020000000L});
\r
3040 public static final BitSet FOLLOW_49_in_enumeration1149 = new BitSet(new long[]{0x0000001000000000L});
\r
3041 public static final BitSet FOLLOW_Name_in_enumeration1151 = new BitSet(new long[]{0x0002000020000000L});
\r
3042 public static final BitSet FOLLOW_RParen_in_enumeration1155 = new BitSet(new long[]{0x0000000000000002L});
\r
3043 public static final BitSet FOLLOW_notationType_in_enumeratedType1163 = new BitSet(new long[]{0x0000000000000002L});
\r
3044 public static final BitSet FOLLOW_enumeration_in_enumeratedType1167 = new BitSet(new long[]{0x0000000000000002L});
\r
3045 public static final BitSet FOLLOW_52_in_notationType1175 = new BitSet(new long[]{0x0000000010000000L});
\r
3046 public static final BitSet FOLLOW_LParen_in_notationType1177 = new BitSet(new long[]{0x0000001000000000L});
\r
3047 public static final BitSet FOLLOW_Name_in_notationType1179 = new BitSet(new long[]{0x0002000020000000L});
\r
3048 public static final BitSet FOLLOW_49_in_notationType1182 = new BitSet(new long[]{0x0000001000000000L});
\r
3049 public static final BitSet FOLLOW_Name_in_notationType1184 = new BitSet(new long[]{0x0002000020000000L});
\r
3050 public static final BitSet FOLLOW_RParen_in_notationType1188 = new BitSet(new long[]{0x0000000000000002L});
\r
3051 public static final BitSet FOLLOW_53_in_stringType1197 = new BitSet(new long[]{0x0000000000000002L});
\r
3052 public static final BitSet FOLLOW_set_in_tokenizedType0 = new BitSet(new long[]{0x0000000000000002L});
\r
3053 public static final BitSet FOLLOW_61_in_entityDecl1249 = new BitSet(new long[]{0x0000001000000000L});
\r
3054 public static final BitSet FOLLOW_Name_in_entityDecl1251 = new BitSet(new long[]{0x0000000800000000L});
\r
3055 public static final BitSet FOLLOW_String_in_entityDecl1253 = new BitSet(new long[]{0x0000080000000000L});
\r
3056 public static final BitSet FOLLOW_43_in_entityDecl1255 = new BitSet(new long[]{0x0000000000000002L});
\r
3057 public static final BitSet FOLLOW_61_in_entityDecl1273 = new BitSet(new long[]{0x4000000000000000L});
\r
3058 public static final BitSet FOLLOW_62_in_entityDecl1275 = new BitSet(new long[]{0x0000001000000000L});
\r
3059 public static final BitSet FOLLOW_Name_in_entityDecl1277 = new BitSet(new long[]{0x0000000800000000L});
\r
3060 public static final BitSet FOLLOW_String_in_entityDecl1279 = new BitSet(new long[]{0x0000080000000000L});
\r
3061 public static final BitSet FOLLOW_43_in_entityDecl1281 = new BitSet(new long[]{0x0000000000000002L});
\r
3062 public static final BitSet FOLLOW_choice_in_synpred1_DTD673 = new BitSet(new long[]{0x0000000000000002L});
\r
3063 public static final BitSet FOLLOW_seq_in_synpred2_DTD702 = new BitSet(new long[]{0x0000000000000002L});
\r
3064 public static final BitSet FOLLOW_Name_in_synpred3_DTD738 = new BitSet(new long[]{0x0000000000000002L});
\r
3065 public static final BitSet FOLLOW_choice_in_synpred4_DTD765 = new BitSet(new long[]{0x0000000000000002L});
\r
3066 public static final BitSet FOLLOW_seq_in_synpred5_DTD794 = new BitSet(new long[]{0x0000000000000002L});
\r
OSDN Git Service
