1/* 2 * Copyright (c) 2005, 2012, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25/* 26 * Copyright (C) 2004-2011 27 * 28 * Permission is hereby granted, free of charge, to any person obtaining a copy 29 * of this software and associated documentation files (the "Software"), to deal 30 * in the Software without restriction, including without limitation the rights 31 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 32 * copies of the Software, and to permit persons to whom the Software is 33 * furnished to do so, subject to the following conditions: 34 * 35 * The above copyright notice and this permission notice shall be included in 36 * all copies or substantial portions of the Software. 37 * 38 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 39 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 40 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 41 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 42 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 43 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 44 * THE SOFTWARE. 45 */ 46/* Generated By:JavaCC: Do not edit this line. CompactSyntax.java */ 47package com.sun.xml.internal.rngom.parse.compact; 48 49import java.io.Reader; 50import java.net.MalformedURLException; 51import java.net.URL; 52import java.util.Arrays; 53import java.util.ArrayList; 54import java.util.Collections; 55import java.util.Enumeration; 56import java.util.Hashtable; 57import java.util.List; 58 59import com.sun.xml.internal.rngom.ast.builder.Annotations; 60import com.sun.xml.internal.rngom.ast.builder.BuildException; 61import com.sun.xml.internal.rngom.ast.builder.CommentList; 62import com.sun.xml.internal.rngom.ast.builder.DataPatternBuilder; 63import com.sun.xml.internal.rngom.ast.builder.Div; 64import com.sun.xml.internal.rngom.ast.builder.ElementAnnotationBuilder; 65import com.sun.xml.internal.rngom.ast.builder.Grammar; 66import com.sun.xml.internal.rngom.ast.builder.GrammarSection; 67import com.sun.xml.internal.rngom.ast.builder.Include; 68import com.sun.xml.internal.rngom.ast.builder.IncludedGrammar; 69import com.sun.xml.internal.rngom.ast.builder.NameClassBuilder; 70import com.sun.xml.internal.rngom.ast.builder.SchemaBuilder; 71import com.sun.xml.internal.rngom.ast.builder.Scope; 72import com.sun.xml.internal.rngom.ast.om.Location; 73import com.sun.xml.internal.rngom.ast.om.ParsedElementAnnotation; 74import com.sun.xml.internal.rngom.ast.om.ParsedNameClass; 75import com.sun.xml.internal.rngom.ast.om.ParsedPattern; 76import com.sun.xml.internal.rngom.parse.Context; 77import com.sun.xml.internal.rngom.parse.IllegalSchemaException; 78import com.sun.xml.internal.rngom.parse.Parseable; 79import org.xml.sax.ErrorHandler; 80import org.xml.sax.SAXException; 81import org.xml.sax.SAXParseException; 82import org.xml.sax.helpers.LocatorImpl; 83 84import com.sun.xml.internal.rngom.util.Localizer; 85import com.sun.xml.internal.rngom.xml.util.WellKnownNamespaces; 86 87 88public class CompactSyntax implements Context, CompactSyntaxConstants { 89 private static final int IN_ELEMENT = 0; 90 private static final int IN_ATTRIBUTE = 1; 91 private static final int IN_ANY_NAME = 2; 92 private static final int IN_NS_NAME = 4; 93 94 private String defaultNamespace; 95 private String compatibilityPrefix = null; 96 private SchemaBuilder sb; 97 private NameClassBuilder ncb; 98 private String sourceUri; 99 /** 100 * This is what we are parsing right now. 101 */ 102 private CompactParseable parseable; 103 private ErrorHandler eh; 104 private final Hashtable namespaceTable = new Hashtable(); 105 private final Hashtable datatypesTable = new Hashtable(); 106 private boolean hadError = false; 107 private static final Localizer localizer = new Localizer(new Localizer(Parseable.class),CompactSyntax.class); 108 private final Hashtable attributeNameTable = new Hashtable(); 109 private boolean annotationsIncludeElements = false; 110 111 /** 112 * String that represents the inherited namespace. 113 * 114 * <p> 115 * HACK: we always allocate a new String instance so that 116 * we can distinguish inherited value from the explicitly 117 * given value. 118 */ 119 private /*final*/ String inheritedNs; // essentially final but JavaCC don't let us declare it as so. 120 121 final class LocatedString { 122 private final String str; 123 private final Token tok; 124 125 LocatedString(String str, Token tok) { 126 this.str = str; 127 this.tok = tok; 128 } 129 130 String getString() { 131 return str; 132 } 133 134 Location getLocation() { 135 return makeLocation(tok); 136 } 137 138 Token getToken() { 139 return tok; 140 } 141 142 } 143 144 public CompactSyntax(CompactParseable parseable, Reader r, String sourceUri, SchemaBuilder sb, ErrorHandler eh, String inheritedNs) { 145 this(r); 146 this.sourceUri = sourceUri; 147 this.parseable = parseable; 148 this.sb = sb; 149 this.ncb = sb.getNameClassBuilder(); 150 this.eh = eh; 151 // this causes the root pattern to have non-null annotations 152 // which is useful because it gives a context to trang 153 this.topLevelComments = sb.makeCommentList(); 154 this.inheritedNs = defaultNamespace = new String(inheritedNs); 155 } 156 157 ParsedPattern parse(Scope scope) throws IllegalSchemaException { 158 try { 159 ParsedPattern p = Input(scope); 160 if (!hadError) 161 return p; 162 } 163 catch (ParseException e) { 164 error("syntax_error", e.getMessage(), e.currentToken.next); 165 } 166 catch (EscapeSyntaxException e) { 167 reportEscapeSyntaxException(e); 168 } 169 throw new IllegalSchemaException(); 170 } 171 172 ParsedPattern parseInclude(IncludedGrammar g) throws IllegalSchemaException { 173 try { 174 ParsedPattern p = IncludedGrammar(g); 175 if (!hadError) 176 return p; 177 } 178 catch (ParseException e) { 179 error("syntax_error", e.getMessage(), e.currentToken.next); 180 } 181 catch (EscapeSyntaxException e) { 182 reportEscapeSyntaxException(e); 183 } 184 throw new IllegalSchemaException(); 185 } 186 187 private void checkNsName(int context, LocatedString ns) { 188 if ((context & IN_NS_NAME) != 0) 189 error("ns_name_except_contains_ns_name", ns.getToken()); 190 } 191 192 private void checkAnyName(int context, Token t) { 193 if ((context & IN_NS_NAME) != 0) 194 error("ns_name_except_contains_any_name", t); 195 if ((context & IN_ANY_NAME) != 0) 196 error("any_name_except_contains_any_name", t); 197 } 198 199 private void error(String key, Token tok) { 200 doError(localizer.message(key), tok); 201 } 202 203 private void error(String key, String arg, Token tok) { 204 doError(localizer.message(key, arg), tok); 205 } 206 207 private void error(String key, String arg1, String arg2, Token tok) { 208 doError(localizer.message(key, arg1, arg2), tok); 209 } 210 211 private void doError(String message, Token tok) { 212 hadError = true; 213 if (eh != null) { 214 LocatorImpl loc = new LocatorImpl(); 215 loc.setLineNumber(tok.beginLine); 216 loc.setColumnNumber(tok.beginColumn); 217 loc.setSystemId(sourceUri); 218 try { 219 eh.error(new SAXParseException(message, loc)); 220 } 221 catch (SAXException se) { 222 throw new BuildException(se); 223 } 224 } 225 } 226 227 private void reportEscapeSyntaxException(EscapeSyntaxException e) { 228 if (eh != null) { 229 LocatorImpl loc = new LocatorImpl(); 230 loc.setLineNumber(e.getLineNumber()); 231 loc.setColumnNumber(e.getColumnNumber()); 232 loc.setSystemId(sourceUri); 233 try { 234 eh.error(new SAXParseException(localizer.message(e.getKey()), loc)); 235 } 236 catch (SAXException se) { 237 throw new BuildException(se); 238 } 239 } 240 } 241 242 private static String unquote(String s) { 243 if (s.length() >= 6 && s.charAt(0) == s.charAt(1)) { 244 s = s.replace('\u0000', '\u005cn'); 245 return s.substring(3, s.length() - 3); 246 } 247 else 248 return s.substring(1, s.length() - 1); 249 } 250 251 Location makeLocation(Token t) { 252 return sb.makeLocation(sourceUri, t.beginLine, t.beginColumn); 253 } 254 255 private static ParsedPattern[] addPattern(ParsedPattern[] patterns, int i, ParsedPattern p) { 256 if (i >= patterns.length) { 257 ParsedPattern[] oldPatterns = patterns; 258 patterns = new ParsedPattern[oldPatterns.length*2]; 259 System.arraycopy(oldPatterns, 0, patterns, 0, oldPatterns.length); 260 } 261 patterns[i] = p; 262 return patterns; 263 } 264 265 String getCompatibilityPrefix() { 266 if (compatibilityPrefix == null) { 267 compatibilityPrefix = "a"; 268 while (namespaceTable.get(compatibilityPrefix) != null) 269 compatibilityPrefix = compatibilityPrefix + "a"; 270 } 271 return compatibilityPrefix; 272 } 273 274 public String resolveNamespacePrefix(String prefix) { 275 String result = (String)namespaceTable.get(prefix); 276 if (result.length() == 0) 277 return null; 278 return result; 279 } 280 281 public Enumeration prefixes() { 282 return namespaceTable.keys(); 283 } 284 285 public String getBaseUri() { 286 return sourceUri; 287 } 288 289 public boolean isUnparsedEntity(String entityName) { 290 return false; 291 } 292 293 public boolean isNotation(String notationName) { 294 return false; 295 } 296 297 public Context copy() { 298 return this; 299 } 300 301 private Context getContext() { 302 return this; 303 } 304 305 private CommentList getComments() { 306 return getComments(getTopLevelComments()); 307 } 308 309 private CommentList topLevelComments; 310 311 private CommentList getTopLevelComments() { 312 CommentList tem = topLevelComments; 313 topLevelComments = null; 314 return tem; 315 } 316 317 private void noteTopLevelComments() { 318 topLevelComments = getComments(topLevelComments); 319 } 320 321 private void topLevelComments(GrammarSection section) { 322 section.topLevelComment(getComments(null)); 323 } 324 325 private Token lastCommentSourceToken = null; 326 327 private CommentList getComments(CommentList comments) { 328 Token nextToken = getToken(1); 329 if (lastCommentSourceToken != nextToken) { 330 if (lastCommentSourceToken == null) 331 lastCommentSourceToken = token; 332 do { 333 lastCommentSourceToken = lastCommentSourceToken.next; 334 Token t = lastCommentSourceToken.specialToken; 335 if (t != null) { 336 while (t.specialToken != null) 337 t = t.specialToken; 338 if (comments == null) 339 comments = sb.makeCommentList(); 340 for (; t != null; t = t.next) { 341 String s = mungeComment(t.image); 342 Location loc = makeLocation(t); 343 if (t.next != null 344 && t.next.kind == CompactSyntaxConstants.SINGLE_LINE_COMMENT_CONTINUE) { 345 StringBuffer buf = new StringBuffer(s); 346 do { 347 t = t.next; 348 buf.append('\u005cn'); 349 buf.append(mungeComment(t.image)); 350 } while (t.next != null 351 && t.next.kind == CompactSyntaxConstants.SINGLE_LINE_COMMENT_CONTINUE); 352 s = buf.toString(); 353 } 354 comments.addComment(s, loc); 355 } 356 } 357 } while (lastCommentSourceToken != nextToken); 358 } 359 return comments; 360 } 361 362 private ParsedPattern afterComments(ParsedPattern p) { 363 CommentList comments = getComments(null); 364 if (comments == null) 365 return p; 366 return sb.commentAfter(p, comments); 367 } 368 369 private ParsedNameClass afterComments(ParsedNameClass nc) { 370 CommentList comments = getComments(null); 371 if (comments == null) 372 return nc; 373 return ncb.commentAfter(nc, comments); 374 } 375 376 private static String mungeComment(String image) { 377 int i = image.indexOf('#') + 1; 378 while (i < image.length() && image.charAt(i) == '#') 379 i++; 380 if (i < image.length() && image.charAt(i) == ' ') 381 i++; 382 return image.substring(i); 383 } 384 385 private Annotations getCommentsAsAnnotations() { 386 CommentList comments = getComments(); 387 if (comments == null) 388 return null; 389 return sb.makeAnnotations(comments, getContext()); 390 } 391 392 private Annotations addCommentsToChildAnnotations(Annotations a) { 393 CommentList comments = getComments(); 394 if (comments == null) 395 return a; 396 if (a == null) 397 a = sb.makeAnnotations(null, getContext()); 398 a.addComment(comments); 399 return a; 400 } 401 402 private Annotations addCommentsToLeadingAnnotations(Annotations a) { 403 CommentList comments = getComments(); 404 if (comments == null) 405 return a; 406 if (a == null) 407 return sb.makeAnnotations(comments, getContext()); 408 a.addLeadingComment(comments); 409 return a; 410 } 411 412 private Annotations getTopLevelCommentsAsAnnotations() { 413 CommentList comments = getTopLevelComments(); 414 if (comments == null) 415 return null; 416 return sb.makeAnnotations(comments, getContext()); 417 } 418 419 private void clearAttributeList() { 420 attributeNameTable.clear(); 421 } 422 423 private void addAttribute(Annotations a, String ns, String localName, String prefix, String value, Token tok) { 424 String key = ns + "#" + localName; 425 if (attributeNameTable.get(key) != null) 426 error("duplicate_attribute", ns, localName, tok); 427 else { 428 attributeNameTable.put(key, key); 429 a.addAttribute(ns, localName, prefix, value, makeLocation(tok)); 430 } 431 } 432 433 private void checkExcept(Token[] except) { 434 if (except[0] != null) 435 error("except_missing_parentheses", except[0]); 436 } 437 438 private String lookupPrefix(String prefix, Token t) { 439 String ns = (String)namespaceTable.get(prefix); 440 if (ns == null) { 441 error("undeclared_prefix", prefix, t); 442 return "#error"; 443 } 444 return ns; 445 } 446 private String lookupDatatype(String prefix, Token t) { 447 String ns = (String)datatypesTable.get(prefix); 448 if (ns == null) { 449 error("undeclared_prefix", prefix, t); 450 return ""; // XXX 451 } 452 return ns; 453 } 454 private String resolve(String str) { 455 try { 456 return new URL(new URL(sourceUri), str).toString(); 457 } 458 catch (MalformedURLException e) { } 459 return str; 460 } 461 462 final public ParsedPattern Input(Scope scope) throws ParseException { 463 ParsedPattern p; 464 Preamble(); 465 if (jj_2_1(2147483647)) { 466 p = TopLevelGrammar(scope); 467 } else { 468 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 469 case 1: 470 case 10: 471 case 17: 472 case 18: 473 case 19: 474 case 26: 475 case 27: 476 case 28: 477 case 31: 478 case 32: 479 case 33: 480 case 34: 481 case 35: 482 case 36: 483 case DOCUMENTATION: 484 case DOCUMENTATION_AFTER_SINGLE_LINE_COMMENT: 485 case IDENTIFIER: 486 case ESCAPED_IDENTIFIER: 487 case PREFIXED_NAME: 488 case LITERAL: 489 p = Expr(true, scope, null, null); 490 p = afterComments(p); 491 jj_consume_token(0); 492 break; 493 default: 494 jj_la1[0] = jj_gen; 495 jj_consume_token(-1); 496 throw new ParseException(); 497 } 498 } 499 {if (true) return p;} 500 throw new Error("Missing return statement in function"); 501 } 502 503 final public void TopLevelLookahead() throws ParseException { 504 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 505 case PREFIXED_NAME: 506 jj_consume_token(PREFIXED_NAME); 507 jj_consume_token(1); 508 break; 509 case IDENTIFIER: 510 case ESCAPED_IDENTIFIER: 511 Identifier(); 512 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 513 case 1: 514 jj_consume_token(1); 515 break; 516 case 2: 517 jj_consume_token(2); 518 break; 519 case 3: 520 jj_consume_token(3); 521 break; 522 case 4: 523 jj_consume_token(4); 524 break; 525 default: 526 jj_la1[1] = jj_gen; 527 jj_consume_token(-1); 528 throw new ParseException(); 529 } 530 break; 531 case 5: 532 case 6: 533 case 7: 534 LookaheadGrammarKeyword(); 535 break; 536 case 1: 537 LookaheadBody(); 538 LookaheadAfterAnnotations(); 539 break; 540 case DOCUMENTATION: 541 case DOCUMENTATION_AFTER_SINGLE_LINE_COMMENT: 542 LookaheadDocumentation(); 543 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 544 case 1: 545 LookaheadBody(); 546 break; 547 default: 548 jj_la1[2] = jj_gen; 549 ; 550 } 551 LookaheadAfterAnnotations(); 552 break; 553 default: 554 jj_la1[3] = jj_gen; 555 jj_consume_token(-1); 556 throw new ParseException(); 557 } 558 } 559 560 final public void LookaheadAfterAnnotations() throws ParseException { 561 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 562 case IDENTIFIER: 563 case ESCAPED_IDENTIFIER: 564 Identifier(); 565 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 566 case 2: 567 jj_consume_token(2); 568 break; 569 case 3: 570 jj_consume_token(3); 571 break; 572 case 4: 573 jj_consume_token(4); 574 break; 575 default: 576 jj_la1[4] = jj_gen; 577 jj_consume_token(-1); 578 throw new ParseException(); 579 } 580 break; 581 case 5: 582 case 6: 583 case 7: 584 LookaheadGrammarKeyword(); 585 break; 586 default: 587 jj_la1[5] = jj_gen; 588 jj_consume_token(-1); 589 throw new ParseException(); 590 } 591 } 592 593 final public void LookaheadGrammarKeyword() throws ParseException { 594 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 595 case 5: 596 jj_consume_token(5); 597 break; 598 case 6: 599 jj_consume_token(6); 600 break; 601 case 7: 602 jj_consume_token(7); 603 break; 604 default: 605 jj_la1[6] = jj_gen; 606 jj_consume_token(-1); 607 throw new ParseException(); 608 } 609 } 610 611 final public void LookaheadDocumentation() throws ParseException { 612 label_1: 613 while (true) { 614 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 615 case DOCUMENTATION: 616 jj_consume_token(DOCUMENTATION); 617 break; 618 case DOCUMENTATION_AFTER_SINGLE_LINE_COMMENT: 619 jj_consume_token(DOCUMENTATION_AFTER_SINGLE_LINE_COMMENT); 620 break; 621 default: 622 jj_la1[7] = jj_gen; 623 jj_consume_token(-1); 624 throw new ParseException(); 625 } 626 label_2: 627 while (true) { 628 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 629 case DOCUMENTATION_CONTINUE: 630 ; 631 break; 632 default: 633 jj_la1[8] = jj_gen; 634 break label_2; 635 } 636 jj_consume_token(DOCUMENTATION_CONTINUE); 637 } 638 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 639 case DOCUMENTATION: 640 case DOCUMENTATION_AFTER_SINGLE_LINE_COMMENT: 641 ; 642 break; 643 default: 644 jj_la1[9] = jj_gen; 645 break label_1; 646 } 647 } 648 } 649 650 final public void LookaheadBody() throws ParseException { 651 jj_consume_token(1); 652 label_3: 653 while (true) { 654 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 655 case 1: 656 case 2: 657 case 5: 658 case 6: 659 case 7: 660 case 8: 661 case 10: 662 case 13: 663 case 14: 664 case 15: 665 case 16: 666 case 17: 667 case 18: 668 case 19: 669 case 26: 670 case 27: 671 case 31: 672 case 32: 673 case 33: 674 case 34: 675 case 35: 676 case 36: 677 case IDENTIFIER: 678 case ESCAPED_IDENTIFIER: 679 case PREFIXED_NAME: 680 case LITERAL: 681 ; 682 break; 683 default: 684 jj_la1[10] = jj_gen; 685 break label_3; 686 } 687 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 688 case PREFIXED_NAME: 689 jj_consume_token(PREFIXED_NAME); 690 break; 691 case 5: 692 case 6: 693 case 7: 694 case 10: 695 case 13: 696 case 14: 697 case 15: 698 case 16: 699 case 17: 700 case 18: 701 case 19: 702 case 26: 703 case 27: 704 case 31: 705 case 32: 706 case 33: 707 case 34: 708 case 35: 709 case 36: 710 case IDENTIFIER: 711 case ESCAPED_IDENTIFIER: 712 UnprefixedName(); 713 break; 714 case 2: 715 jj_consume_token(2); 716 break; 717 case LITERAL: 718 jj_consume_token(LITERAL); 719 break; 720 case 8: 721 jj_consume_token(8); 722 break; 723 case 1: 724 LookaheadBody(); 725 break; 726 default: 727 jj_la1[11] = jj_gen; 728 jj_consume_token(-1); 729 throw new ParseException(); 730 } 731 } 732 jj_consume_token(9); 733 } 734 735 final public ParsedPattern IncludedGrammar(IncludedGrammar g) throws ParseException { 736 Annotations a; 737 ParsedPattern p; 738 Preamble(); 739 if (jj_2_2(2147483647)) { 740 a = GrammarBody(g, g, getTopLevelCommentsAsAnnotations()); 741 } else { 742 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 743 case 1: 744 case 10: 745 case DOCUMENTATION: 746 case DOCUMENTATION_AFTER_SINGLE_LINE_COMMENT: 747 a = Annotations(); 748 jj_consume_token(10); 749 jj_consume_token(11); 750 a = GrammarBody(g, g, a); 751 topLevelComments(g); 752 jj_consume_token(12); 753 break; 754 default: 755 jj_la1[12] = jj_gen; 756 jj_consume_token(-1); 757 throw new ParseException(); 758 } 759 } 760 p = afterComments(g.endIncludedGrammar(sb.makeLocation(sourceUri, 1, 1), a)); 761 jj_consume_token(0); 762 {if (true) return p;} 763 throw new Error("Missing return statement in function"); 764 } 765 766 final public ParsedPattern TopLevelGrammar(Scope scope) throws ParseException { 767 Annotations a = getTopLevelCommentsAsAnnotations(); 768 Grammar g; 769 ParsedPattern p; 770 g = sb.makeGrammar(scope); 771 a = GrammarBody(g, g, a); 772 p = afterComments(g.endGrammar(sb.makeLocation(sourceUri, 1, 1), a)); 773 jj_consume_token(0); 774 {if (true) return p;} 775 throw new Error("Missing return statement in function"); 776 } 777 778 final public void Preamble() throws ParseException { 779 label_4: 780 while (true) { 781 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 782 case 13: 783 case 14: 784 case 16: 785 ; 786 break; 787 default: 788 jj_la1[13] = jj_gen; 789 break label_4; 790 } 791 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 792 case 13: 793 case 14: 794 NamespaceDecl(); 795 break; 796 case 16: 797 DatatypesDecl(); 798 break; 799 default: 800 jj_la1[14] = jj_gen; 801 jj_consume_token(-1); 802 throw new ParseException(); 803 } 804 } 805 namespaceTable.put("xml", WellKnownNamespaces.XML); 806 if (datatypesTable.get("xsd") == null) 807 datatypesTable.put("xsd", WellKnownNamespaces.XML_SCHEMA_DATATYPES); 808 } 809 810 final public void NamespaceDecl() throws ParseException { 811 LocatedString prefix = null; 812 boolean isDefault = false; 813 String namespaceName; 814 noteTopLevelComments(); 815 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 816 case 13: 817 jj_consume_token(13); 818 prefix = UnprefixedName(); 819 break; 820 case 14: 821 jj_consume_token(14); 822 isDefault = true; 823 jj_consume_token(13); 824 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 825 case 5: 826 case 6: 827 case 7: 828 case 10: 829 case 13: 830 case 14: 831 case 15: 832 case 16: 833 case 17: 834 case 18: 835 case 19: 836 case 26: 837 case 27: 838 case 31: 839 case 32: 840 case 33: 841 case 34: 842 case 35: 843 case 36: 844 case IDENTIFIER: 845 case ESCAPED_IDENTIFIER: 846 prefix = UnprefixedName(); 847 break; 848 default: 849 jj_la1[15] = jj_gen; 850 ; 851 } 852 break; 853 default: 854 jj_la1[16] = jj_gen; 855 jj_consume_token(-1); 856 throw new ParseException(); 857 } 858 jj_consume_token(2); 859 namespaceName = NamespaceName(); 860 if (isDefault) 861 defaultNamespace = namespaceName; 862 if (prefix != null) { 863 if (prefix.getString().equals("xmlns")) 864 error("xmlns_prefix", prefix.getToken()); 865 else if (prefix.getString().equals("xml")) { 866 if (!namespaceName.equals(WellKnownNamespaces.XML)) 867 error("xml_prefix_bad_uri", prefix.getToken()); 868 } 869 else if (namespaceName.equals(WellKnownNamespaces.XML)) 870 error("xml_uri_bad_prefix", prefix.getToken()); 871 else { 872 if (namespaceName.equals(WellKnownNamespaces.RELAX_NG_COMPATIBILITY_ANNOTATIONS)) 873 compatibilityPrefix = prefix.getString(); 874 namespaceTable.put(prefix.getString(), namespaceName); 875 } 876 } 877 } 878 879 final public String NamespaceName() throws ParseException { 880 String r; 881 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 882 case LITERAL: 883 r = Literal(); 884 break; 885 case 15: 886 jj_consume_token(15); 887 r = this.inheritedNs; 888 break; 889 default: 890 jj_la1[17] = jj_gen; 891 jj_consume_token(-1); 892 throw new ParseException(); 893 } 894 {if (true) return r;} 895 throw new Error("Missing return statement in function"); 896 } 897 898 final public void DatatypesDecl() throws ParseException { 899 LocatedString prefix; 900 String uri; 901 noteTopLevelComments(); 902 jj_consume_token(16); 903 prefix = UnprefixedName(); 904 jj_consume_token(2); 905 uri = Literal(); 906 datatypesTable.put(prefix.getString(), uri); 907 } 908 909 final public ParsedPattern AnnotatedPrimaryExpr(boolean topLevel, Scope scope, Token[] except) throws ParseException { 910 Annotations a; 911 ParsedPattern p; 912 ParsedElementAnnotation e; 913 Token t; 914 a = Annotations(); 915 p = PrimaryExpr(topLevel, scope, a, except); 916 label_5: 917 while (true) { 918 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 919 case FANNOTATE: 920 ; 921 break; 922 default: 923 jj_la1[18] = jj_gen; 924 break label_5; 925 } 926 t = jj_consume_token(FANNOTATE); 927 e = AnnotationElement(false); 928 if (topLevel) 929 error("top_level_follow_annotation", t); 930 else 931 p = sb.annotateAfter(p, e); 932 } 933 {if (true) return p;} 934 throw new Error("Missing return statement in function"); 935 } 936 937 final public ParsedPattern PrimaryExpr(boolean topLevel, Scope scope, Annotations a, Token[] except) throws ParseException { 938 ParsedPattern p; 939 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 940 case 26: 941 p = ElementExpr(scope, a); 942 break; 943 case 27: 944 p = AttributeExpr(scope, a); 945 break; 946 case 10: 947 p = GrammarExpr(scope, a); 948 break; 949 case 33: 950 p = ExternalRefExpr(scope, a); 951 break; 952 case 31: 953 p = ListExpr(scope, a); 954 break; 955 case 32: 956 p = MixedExpr(scope, a); 957 break; 958 case 28: 959 p = ParenExpr(topLevel, scope, a); 960 break; 961 case IDENTIFIER: 962 case ESCAPED_IDENTIFIER: 963 p = IdentifierExpr(scope, a); 964 break; 965 case 34: 966 p = ParentExpr(scope, a); 967 break; 968 case 35: 969 case 36: 970 case PREFIXED_NAME: 971 p = DataExpr(topLevel, scope, a, except); 972 break; 973 case LITERAL: 974 p = ValueExpr(topLevel, a); 975 break; 976 case 18: 977 p = TextExpr(a); 978 break; 979 case 17: 980 p = EmptyExpr(a); 981 break; 982 case 19: 983 p = NotAllowedExpr(a); 984 break; 985 default: 986 jj_la1[19] = jj_gen; 987 jj_consume_token(-1); 988 throw new ParseException(); 989 } 990 {if (true) return p;} 991 throw new Error("Missing return statement in function"); 992 } 993 994 final public ParsedPattern EmptyExpr(Annotations a) throws ParseException { 995 Token t; 996 t = jj_consume_token(17); 997 {if (true) return sb.makeEmpty(makeLocation(t), a);} 998 throw new Error("Missing return statement in function"); 999 } 1000 1001 final public ParsedPattern TextExpr(Annotations a) throws ParseException { 1002 Token t; 1003 t = jj_consume_token(18); 1004 {if (true) return sb.makeText(makeLocation(t), a);} 1005 throw new Error("Missing return statement in function"); 1006 } 1007 1008 final public ParsedPattern NotAllowedExpr(Annotations a) throws ParseException { 1009 Token t; 1010 t = jj_consume_token(19); 1011 {if (true) return sb.makeNotAllowed(makeLocation(t), a);} 1012 throw new Error("Missing return statement in function"); 1013 } 1014 1015 final public ParsedPattern Expr(boolean topLevel, Scope scope, Token t, Annotations a) throws ParseException { 1016 List patterns = new ArrayList(); 1017 ParsedPattern p; 1018 boolean[] hadOccur = new boolean[1]; 1019 Token[] except = new Token[1]; 1020 p = UnaryExpr(topLevel, scope, hadOccur, except); 1021 patterns.add(p); 1022 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1023 case 20: 1024 case 21: 1025 case 22: 1026 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1027 case 20: 1028 checkExcept(except); 1029 label_6: 1030 while (true) { 1031 t = jj_consume_token(20); 1032 p = UnaryExpr(topLevel, scope, null, except); 1033 patterns.add(p); checkExcept(except); 1034 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1035 case 20: 1036 ; 1037 break; 1038 default: 1039 jj_la1[20] = jj_gen; 1040 break label_6; 1041 } 1042 } 1043 p = sb.makeChoice(patterns, makeLocation(t), a); 1044 break; 1045 case 21: 1046 label_7: 1047 while (true) { 1048 t = jj_consume_token(21); 1049 p = UnaryExpr(topLevel, scope, null, except); 1050 patterns.add(p); checkExcept(except); 1051 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1052 case 21: 1053 ; 1054 break; 1055 default: 1056 jj_la1[21] = jj_gen; 1057 break label_7; 1058 } 1059 } 1060 p = sb.makeInterleave(patterns, makeLocation(t), a); 1061 break; 1062 case 22: 1063 label_8: 1064 while (true) { 1065 t = jj_consume_token(22); 1066 p = UnaryExpr(topLevel, scope, null, except); 1067 patterns.add(p); checkExcept(except); 1068 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1069 case 22: 1070 ; 1071 break; 1072 default: 1073 jj_la1[22] = jj_gen; 1074 break label_8; 1075 } 1076 } 1077 p = sb.makeGroup(patterns, makeLocation(t), a); 1078 break; 1079 default: 1080 jj_la1[23] = jj_gen; 1081 jj_consume_token(-1); 1082 throw new ParseException(); 1083 } 1084 break; 1085 default: 1086 jj_la1[24] = jj_gen; 1087 ; 1088 } 1089 if (patterns.size() == 1 && a != null) { 1090 if (hadOccur[0]) 1091 p = sb.annotate(p, a); 1092 else 1093 p = sb.makeGroup(patterns, makeLocation(t), a); 1094 } 1095 {if (true) return p;} 1096 throw new Error("Missing return statement in function"); 1097 } 1098 1099 final public ParsedPattern UnaryExpr(boolean topLevel, Scope scope, boolean[] hadOccur, Token[] except) throws ParseException { 1100 ParsedPattern p; 1101 Token t; 1102 ParsedElementAnnotation e; 1103 p = AnnotatedPrimaryExpr(topLevel, scope, except); 1104 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1105 case 23: 1106 case 24: 1107 case 25: 1108 if (hadOccur != null) hadOccur[0] = true; 1109 p = afterComments(p); 1110 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1111 case 23: 1112 t = jj_consume_token(23); 1113 checkExcept(except); p = sb.makeOneOrMore(p, makeLocation(t), null); 1114 break; 1115 case 24: 1116 t = jj_consume_token(24); 1117 checkExcept(except); p = sb.makeOptional(p, makeLocation(t), null); 1118 break; 1119 case 25: 1120 t = jj_consume_token(25); 1121 checkExcept(except); p = sb.makeZeroOrMore(p, makeLocation(t), null); 1122 break; 1123 default: 1124 jj_la1[25] = jj_gen; 1125 jj_consume_token(-1); 1126 throw new ParseException(); 1127 } 1128 label_9: 1129 while (true) { 1130 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1131 case FANNOTATE: 1132 ; 1133 break; 1134 default: 1135 jj_la1[26] = jj_gen; 1136 break label_9; 1137 } 1138 t = jj_consume_token(FANNOTATE); 1139 e = AnnotationElement(false); 1140 if (topLevel) 1141 error("top_level_follow_annotation", t); 1142 else 1143 p = sb.annotateAfter(p, e); 1144 } 1145 break; 1146 default: 1147 jj_la1[27] = jj_gen; 1148 ; 1149 } 1150 {if (true) return p;} 1151 throw new Error("Missing return statement in function"); 1152 } 1153 1154 final public ParsedPattern ElementExpr(Scope scope, Annotations a) throws ParseException { 1155 Token t; 1156 ParsedNameClass nc; 1157 ParsedPattern p; 1158 t = jj_consume_token(26); 1159 nc = NameClass(IN_ELEMENT, null); 1160 jj_consume_token(11); 1161 p = Expr(false, scope, null, null); 1162 p = afterComments(p); 1163 jj_consume_token(12); 1164 {if (true) return sb.makeElement(nc, p, makeLocation(t), a);} 1165 throw new Error("Missing return statement in function"); 1166 } 1167 1168 final public ParsedPattern AttributeExpr(Scope scope, Annotations a) throws ParseException { 1169 Token t; 1170 ParsedNameClass nc; 1171 ParsedPattern p; 1172 t = jj_consume_token(27); 1173 nc = NameClass(IN_ATTRIBUTE, null); 1174 jj_consume_token(11); 1175 p = Expr(false, scope, null, null); 1176 p = afterComments(p); 1177 jj_consume_token(12); 1178 {if (true) return sb.makeAttribute(nc, p, makeLocation(t), a);} 1179 throw new Error("Missing return statement in function"); 1180 } 1181 1182 final public ParsedNameClass NameClass(int context, Annotations[] pa) throws ParseException { 1183 Annotations a; 1184 ParsedNameClass nc; 1185 a = Annotations(); 1186 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1187 case 5: 1188 case 6: 1189 case 7: 1190 case 10: 1191 case 13: 1192 case 14: 1193 case 15: 1194 case 16: 1195 case 17: 1196 case 18: 1197 case 19: 1198 case 26: 1199 case 27: 1200 case 28: 1201 case 31: 1202 case 32: 1203 case 33: 1204 case 34: 1205 case 35: 1206 case 36: 1207 case IDENTIFIER: 1208 case ESCAPED_IDENTIFIER: 1209 case PREFIXED_NAME: 1210 nc = PrimaryNameClass(context, a); 1211 nc = AnnotateAfter(nc); 1212 nc = NameClassAlternatives(context, nc, pa); 1213 break; 1214 case 25: 1215 nc = AnyNameExceptClass(context, a, pa); 1216 break; 1217 case PREFIX_STAR: 1218 nc = NsNameExceptClass(context, a, pa); 1219 break; 1220 default: 1221 jj_la1[28] = jj_gen; 1222 jj_consume_token(-1); 1223 throw new ParseException(); 1224 } 1225 {if (true) return nc;} 1226 throw new Error("Missing return statement in function"); 1227 } 1228 1229 final public ParsedNameClass AnnotateAfter(ParsedNameClass nc) throws ParseException { 1230 ParsedElementAnnotation e; 1231 label_10: 1232 while (true) { 1233 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1234 case FANNOTATE: 1235 ; 1236 break; 1237 default: 1238 jj_la1[29] = jj_gen; 1239 break label_10; 1240 } 1241 jj_consume_token(FANNOTATE); 1242 e = AnnotationElement(false); 1243 nc = ncb.annotateAfter(nc, e); 1244 } 1245 {if (true) return nc;} 1246 throw new Error("Missing return statement in function"); 1247 } 1248 1249 final public ParsedNameClass NameClassAlternatives(int context, ParsedNameClass nc, Annotations[] pa) throws ParseException { 1250 Token t; 1251 ParsedNameClass[] nameClasses; 1252 int nNameClasses; 1253 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1254 case 20: 1255 nameClasses = new ParsedNameClass[2]; 1256 nameClasses[0] = nc; 1257 nNameClasses = 1; 1258 label_11: 1259 while (true) { 1260 t = jj_consume_token(20); 1261 nc = BasicNameClass(context); 1262 nc = AnnotateAfter(nc); 1263 if (nNameClasses >= nameClasses.length) { 1264 ParsedNameClass[] oldNameClasses = nameClasses; 1265 nameClasses = new ParsedNameClass[oldNameClasses.length*2]; 1266 System.arraycopy(oldNameClasses, 0, nameClasses, 0, oldNameClasses.length); 1267 } 1268 nameClasses[nNameClasses++] = nc; 1269 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1270 case 20: 1271 ; 1272 break; 1273 default: 1274 jj_la1[30] = jj_gen; 1275 break label_11; 1276 } 1277 } 1278 Annotations a; 1279 if (pa == null) 1280 a = null; 1281 else { 1282 a = pa[0]; 1283 pa[0] = null; 1284 } 1285 nc = ncb.makeChoice(Arrays.asList(nameClasses).subList(0,nNameClasses), makeLocation(t), a); 1286 break; 1287 default: 1288 jj_la1[31] = jj_gen; 1289 ; 1290 } 1291 {if (true) return nc;} 1292 throw new Error("Missing return statement in function"); 1293 } 1294 1295 final public ParsedNameClass BasicNameClass(int context) throws ParseException { 1296 Annotations a; 1297 ParsedNameClass nc; 1298 a = Annotations(); 1299 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1300 case 5: 1301 case 6: 1302 case 7: 1303 case 10: 1304 case 13: 1305 case 14: 1306 case 15: 1307 case 16: 1308 case 17: 1309 case 18: 1310 case 19: 1311 case 26: 1312 case 27: 1313 case 28: 1314 case 31: 1315 case 32: 1316 case 33: 1317 case 34: 1318 case 35: 1319 case 36: 1320 case IDENTIFIER: 1321 case ESCAPED_IDENTIFIER: 1322 case PREFIXED_NAME: 1323 nc = PrimaryNameClass(context, a); 1324 break; 1325 case 25: 1326 case PREFIX_STAR: 1327 nc = OpenNameClass(context, a); 1328 break; 1329 default: 1330 jj_la1[32] = jj_gen; 1331 jj_consume_token(-1); 1332 throw new ParseException(); 1333 } 1334 {if (true) return nc;} 1335 throw new Error("Missing return statement in function"); 1336 } 1337 1338 final public ParsedNameClass PrimaryNameClass(int context, Annotations a) throws ParseException { 1339 ParsedNameClass nc; 1340 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1341 case 5: 1342 case 6: 1343 case 7: 1344 case 10: 1345 case 13: 1346 case 14: 1347 case 15: 1348 case 16: 1349 case 17: 1350 case 18: 1351 case 19: 1352 case 26: 1353 case 27: 1354 case 31: 1355 case 32: 1356 case 33: 1357 case 34: 1358 case 35: 1359 case 36: 1360 case IDENTIFIER: 1361 case ESCAPED_IDENTIFIER: 1362 nc = UnprefixedNameClass(context, a); 1363 break; 1364 case PREFIXED_NAME: 1365 nc = PrefixedNameClass(a); 1366 break; 1367 case 28: 1368 nc = ParenNameClass(context, a); 1369 break; 1370 default: 1371 jj_la1[33] = jj_gen; 1372 jj_consume_token(-1); 1373 throw new ParseException(); 1374 } 1375 {if (true) return nc;} 1376 throw new Error("Missing return statement in function"); 1377 } 1378 1379 final public ParsedNameClass OpenNameClass(int context, Annotations a) throws ParseException { 1380 Token t; 1381 LocatedString ns; 1382 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1383 case PREFIX_STAR: 1384 ns = NsName(); 1385 checkNsName(context, ns); {if (true) return ncb.makeNsName(ns.getString(), ns.getLocation(), a);} 1386 break; 1387 case 25: 1388 t = jj_consume_token(25); 1389 checkAnyName(context, t); {if (true) return ncb.makeAnyName(makeLocation(t), a);} 1390 break; 1391 default: 1392 jj_la1[34] = jj_gen; 1393 jj_consume_token(-1); 1394 throw new ParseException(); 1395 } 1396 throw new Error("Missing return statement in function"); 1397 } 1398 1399 final public ParsedNameClass UnprefixedNameClass(int context, Annotations a) throws ParseException { 1400 LocatedString name; 1401 name = UnprefixedName(); 1402 String ns; 1403 if ((context & (IN_ATTRIBUTE|IN_ELEMENT)) == IN_ATTRIBUTE) 1404 ns = ""; 1405 else 1406 ns = defaultNamespace; 1407 {if (true) return ncb.makeName(ns, name.getString(), null, name.getLocation(), a);} 1408 throw new Error("Missing return statement in function"); 1409 } 1410 1411 final public ParsedNameClass PrefixedNameClass(Annotations a) throws ParseException { 1412 Token t; 1413 t = jj_consume_token(PREFIXED_NAME); 1414 String qn = t.image; 1415 int colon = qn.indexOf(':'); 1416 String prefix = qn.substring(0, colon); 1417 {if (true) return ncb.makeName(lookupPrefix(prefix, t), qn.substring(colon + 1), prefix, makeLocation(t), a);} 1418 throw new Error("Missing return statement in function"); 1419 } 1420 1421 final public ParsedNameClass NsNameExceptClass(int context, Annotations a, Annotations[] pa) throws ParseException { 1422 LocatedString ns; 1423 ParsedNameClass nc; 1424 ns = NsName(); 1425 checkNsName(context, ns); 1426 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1427 case 30: 1428 nc = ExceptNameClass(context | IN_NS_NAME); 1429 nc = ncb.makeNsName(ns.getString(), nc, ns.getLocation(), a); 1430 nc = AnnotateAfter(nc); 1431 break; 1432 default: 1433 jj_la1[35] = jj_gen; 1434 nc = ncb.makeNsName(ns.getString(), ns.getLocation(), a); 1435 nc = AnnotateAfter(nc); 1436 nc = NameClassAlternatives(context, nc, pa); 1437 } 1438 {if (true) return nc;} 1439 throw new Error("Missing return statement in function"); 1440 } 1441 1442 final public LocatedString NsName() throws ParseException { 1443 Token t; 1444 t = jj_consume_token(PREFIX_STAR); 1445 String qn = t.image; 1446 String prefix = qn.substring(0, qn.length() - 2); 1447 {if (true) return new LocatedString(lookupPrefix(prefix, t), t);} 1448 throw new Error("Missing return statement in function"); 1449 } 1450 1451 final public ParsedNameClass AnyNameExceptClass(int context, Annotations a, Annotations[] pa) throws ParseException { 1452 Token t; 1453 ParsedNameClass nc; 1454 t = jj_consume_token(25); 1455 checkAnyName(context, t); 1456 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1457 case 30: 1458 nc = ExceptNameClass(context | IN_ANY_NAME); 1459 nc = ncb.makeAnyName(nc, makeLocation(t), a); 1460 nc = AnnotateAfter(nc); 1461 break; 1462 default: 1463 jj_la1[36] = jj_gen; 1464 nc = ncb.makeAnyName(makeLocation(t), a); 1465 nc = AnnotateAfter(nc); 1466 nc = NameClassAlternatives(context, nc, pa); 1467 } 1468 {if (true) return nc;} 1469 throw new Error("Missing return statement in function"); 1470 } 1471 1472 final public ParsedNameClass ParenNameClass(int context, Annotations a) throws ParseException { 1473 Token t; 1474 ParsedNameClass nc; 1475 Annotations[] pa = new Annotations[]{ a }; 1476 t = jj_consume_token(28); 1477 nc = NameClass(context, pa); 1478 nc = afterComments(nc); 1479 jj_consume_token(29); 1480 if (pa[0] != null) 1481 nc = ncb.makeChoice(Collections.singletonList(nc), makeLocation(t), pa[0]); 1482 {if (true) return nc;} 1483 throw new Error("Missing return statement in function"); 1484 } 1485 1486 final public ParsedNameClass ExceptNameClass(int context) throws ParseException { 1487 ParsedNameClass nc; 1488 jj_consume_token(30); 1489 nc = BasicNameClass(context); 1490 {if (true) return nc;} 1491 throw new Error("Missing return statement in function"); 1492 } 1493 1494 final public ParsedPattern ListExpr(Scope scope, Annotations a) throws ParseException { 1495 Token t; 1496 ParsedPattern p; 1497 t = jj_consume_token(31); 1498 jj_consume_token(11); 1499 p = Expr(false, scope, null, null); 1500 p = afterComments(p); 1501 jj_consume_token(12); 1502 {if (true) return sb.makeList(p, makeLocation(t), a);} 1503 throw new Error("Missing return statement in function"); 1504 } 1505 1506 final public ParsedPattern MixedExpr(Scope scope, Annotations a) throws ParseException { 1507 Token t; 1508 ParsedPattern p; 1509 t = jj_consume_token(32); 1510 jj_consume_token(11); 1511 p = Expr(false, scope, null, null); 1512 p = afterComments(p); 1513 jj_consume_token(12); 1514 {if (true) return sb.makeMixed(p, makeLocation(t), a);} 1515 throw new Error("Missing return statement in function"); 1516 } 1517 1518 final public ParsedPattern GrammarExpr(Scope scope, Annotations a) throws ParseException { 1519 Token t; 1520 Grammar g; 1521 t = jj_consume_token(10); 1522 g = sb.makeGrammar(scope); 1523 jj_consume_token(11); 1524 a = GrammarBody(g, g, a); 1525 topLevelComments(g); 1526 jj_consume_token(12); 1527 {if (true) return g.endGrammar(makeLocation(t), a);} 1528 throw new Error("Missing return statement in function"); 1529 } 1530 1531 final public ParsedPattern ParenExpr(boolean topLevel, Scope scope, Annotations a) throws ParseException { 1532 Token t; 1533 ParsedPattern p; 1534 t = jj_consume_token(28); 1535 p = Expr(topLevel, scope, t, a); 1536 p = afterComments(p); 1537 jj_consume_token(29); 1538 {if (true) return p;} 1539 throw new Error("Missing return statement in function"); 1540 } 1541 1542 final public Annotations GrammarBody(GrammarSection section, Scope scope, Annotations a) throws ParseException { 1543 ParsedElementAnnotation e; 1544 label_12: 1545 while (true) { 1546 if (jj_2_3(2)) { 1547 ; 1548 } else { 1549 break label_12; 1550 } 1551 e = AnnotationElementNotKeyword(); 1552 if (a == null) a = sb.makeAnnotations(null, getContext()); a.addElement(e); 1553 } 1554 label_13: 1555 while (true) { 1556 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1557 case 1: 1558 case 5: 1559 case 6: 1560 case 7: 1561 case DOCUMENTATION: 1562 case DOCUMENTATION_AFTER_SINGLE_LINE_COMMENT: 1563 case IDENTIFIER: 1564 case ESCAPED_IDENTIFIER: 1565 ; 1566 break; 1567 default: 1568 jj_la1[37] = jj_gen; 1569 break label_13; 1570 } 1571 GrammarComponent(section, scope); 1572 } 1573 {if (true) return a;} 1574 throw new Error("Missing return statement in function"); 1575 } 1576 1577 final public void GrammarComponent(GrammarSection section, Scope scope) throws ParseException { 1578 ParsedElementAnnotation e; 1579 Annotations a; 1580 a = Annotations(); 1581 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1582 case 5: 1583 case IDENTIFIER: 1584 case ESCAPED_IDENTIFIER: 1585 Definition(section, scope, a); 1586 break; 1587 case 7: 1588 Include(section, scope, a); 1589 break; 1590 case 6: 1591 Div(section, scope, a); 1592 break; 1593 default: 1594 jj_la1[38] = jj_gen; 1595 jj_consume_token(-1); 1596 throw new ParseException(); 1597 } 1598 label_14: 1599 while (true) { 1600 if (jj_2_4(2)) { 1601 ; 1602 } else { 1603 break label_14; 1604 } 1605 e = AnnotationElementNotKeyword(); 1606 section.topLevelAnnotation(e); 1607 } 1608 } 1609 1610 final public void Definition(GrammarSection section, Scope scope, Annotations a) throws ParseException { 1611 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1612 case IDENTIFIER: 1613 case ESCAPED_IDENTIFIER: 1614 Define(section, scope, a); 1615 break; 1616 case 5: 1617 Start(section, scope, a); 1618 break; 1619 default: 1620 jj_la1[39] = jj_gen; 1621 jj_consume_token(-1); 1622 throw new ParseException(); 1623 } 1624 } 1625 1626 final public void Start(GrammarSection section, Scope scope, Annotations a) throws ParseException { 1627 Token t; 1628 GrammarSection.Combine combine; 1629 ParsedPattern p; 1630 t = jj_consume_token(5); 1631 combine = AssignOp(); 1632 p = Expr(false, scope, null, null); 1633 section.define(GrammarSection.START, combine, p, makeLocation(t), a); 1634 } 1635 1636 final public void Define(GrammarSection section, Scope scope, Annotations a) throws ParseException { 1637 LocatedString name; 1638 GrammarSection.Combine combine; 1639 ParsedPattern p; 1640 name = Identifier(); 1641 combine = AssignOp(); 1642 p = Expr(false, scope, null, null); 1643 section.define(name.getString(), combine, p, name.getLocation(), a); 1644 } 1645 1646 final public GrammarSection.Combine AssignOp() throws ParseException { 1647 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1648 case 2: 1649 jj_consume_token(2); 1650 {if (true) return null;} 1651 break; 1652 case 4: 1653 jj_consume_token(4); 1654 {if (true) return GrammarSection.COMBINE_CHOICE;} 1655 break; 1656 case 3: 1657 jj_consume_token(3); 1658 {if (true) return GrammarSection.COMBINE_INTERLEAVE;} 1659 break; 1660 default: 1661 jj_la1[40] = jj_gen; 1662 jj_consume_token(-1); 1663 throw new ParseException(); 1664 } 1665 throw new Error("Missing return statement in function"); 1666 } 1667 1668 final public void Include(GrammarSection section, Scope scope, Annotations a) throws ParseException { 1669 Token t; 1670 String href; 1671 String ns; 1672 Include include = section.makeInclude(); 1673 t = jj_consume_token(7); 1674 href = Literal(); 1675 ns = Inherit(); 1676 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1677 case 11: 1678 jj_consume_token(11); 1679 a = IncludeBody(include, scope, a); 1680 topLevelComments(include); 1681 jj_consume_token(12); 1682 break; 1683 default: 1684 jj_la1[41] = jj_gen; 1685 ; 1686 } 1687 try { 1688 include.endInclude(parseable, resolve(href), ns, makeLocation(t), a); 1689 } 1690 catch (IllegalSchemaException e) { } 1691 } 1692 1693 final public Annotations IncludeBody(GrammarSection section, Scope scope, Annotations a) throws ParseException { 1694 ParsedElementAnnotation e; 1695 label_15: 1696 while (true) { 1697 if (jj_2_5(2)) { 1698 ; 1699 } else { 1700 break label_15; 1701 } 1702 e = AnnotationElementNotKeyword(); 1703 if (a == null) a = sb.makeAnnotations(null, getContext()); a.addElement(e); 1704 } 1705 label_16: 1706 while (true) { 1707 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1708 case 1: 1709 case 5: 1710 case 6: 1711 case DOCUMENTATION: 1712 case DOCUMENTATION_AFTER_SINGLE_LINE_COMMENT: 1713 case IDENTIFIER: 1714 case ESCAPED_IDENTIFIER: 1715 ; 1716 break; 1717 default: 1718 jj_la1[42] = jj_gen; 1719 break label_16; 1720 } 1721 IncludeComponent(section, scope); 1722 } 1723 {if (true) return a;} 1724 throw new Error("Missing return statement in function"); 1725 } 1726 1727 final public void IncludeComponent(GrammarSection section, Scope scope) throws ParseException { 1728 ParsedElementAnnotation e; 1729 Annotations a; 1730 a = Annotations(); 1731 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1732 case 5: 1733 case IDENTIFIER: 1734 case ESCAPED_IDENTIFIER: 1735 Definition(section, scope, a); 1736 break; 1737 case 6: 1738 IncludeDiv(section, scope, a); 1739 break; 1740 default: 1741 jj_la1[43] = jj_gen; 1742 jj_consume_token(-1); 1743 throw new ParseException(); 1744 } 1745 label_17: 1746 while (true) { 1747 if (jj_2_6(2)) { 1748 ; 1749 } else { 1750 break label_17; 1751 } 1752 e = AnnotationElementNotKeyword(); 1753 section.topLevelAnnotation(e); 1754 } 1755 } 1756 1757 final public void Div(GrammarSection section, Scope scope, Annotations a) throws ParseException { 1758 Token t; 1759 Div div = section.makeDiv(); 1760 t = jj_consume_token(6); 1761 jj_consume_token(11); 1762 a = GrammarBody(div, scope, a); 1763 topLevelComments(div); 1764 jj_consume_token(12); 1765 div.endDiv(makeLocation(t), a); 1766 } 1767 1768 final public void IncludeDiv(GrammarSection section, Scope scope, Annotations a) throws ParseException { 1769 Token t; 1770 Div div = section.makeDiv(); 1771 t = jj_consume_token(6); 1772 jj_consume_token(11); 1773 a = IncludeBody(div, scope, a); 1774 topLevelComments(div); 1775 jj_consume_token(12); 1776 div.endDiv(makeLocation(t), a); 1777 } 1778 1779 final public ParsedPattern ExternalRefExpr(Scope scope, Annotations a) throws ParseException { 1780 Token t; 1781 String href; 1782 String ns; 1783 t = jj_consume_token(33); 1784 href = Literal(); 1785 ns = Inherit(); 1786 try { 1787 {if (true) return sb.makeExternalRef(parseable, resolve(href), ns, scope, makeLocation(t), a);} 1788 } 1789 catch (IllegalSchemaException e) { 1790 {if (true) return sb.makeErrorPattern();} 1791 } 1792 throw new Error("Missing return statement in function"); 1793 } 1794 1795 final public String Inherit() throws ParseException { 1796 String ns = null; 1797 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1798 case 15: 1799 jj_consume_token(15); 1800 jj_consume_token(2); 1801 ns = Prefix(); 1802 break; 1803 default: 1804 jj_la1[44] = jj_gen; 1805 ; 1806 } 1807 if (ns == null) 1808 ns = defaultNamespace; 1809 {if (true) return ns;} 1810 throw new Error("Missing return statement in function"); 1811 } 1812 1813 final public ParsedPattern ParentExpr(Scope scope, Annotations a) throws ParseException { 1814 LocatedString name; 1815 jj_consume_token(34); 1816 a = addCommentsToChildAnnotations(a); 1817 name = Identifier(); 1818 if(scope==null) { 1819 error("parent_ref_outside_grammar",name.getToken()); 1820 {if (true) return sb.makeErrorPattern();} 1821 } else { 1822 {if (true) return scope.makeParentRef(name.getString(), name.getLocation(), a);} 1823 } 1824 throw new Error("Missing return statement in function"); 1825 } 1826 1827 final public ParsedPattern IdentifierExpr(Scope scope, Annotations a) throws ParseException { 1828 LocatedString name; 1829 name = Identifier(); 1830 if(scope==null) { 1831 error("ref_outside_grammar",name.getToken()); 1832 {if (true) return sb.makeErrorPattern();} 1833 } else { 1834 {if (true) return scope.makeRef(name.getString(), name.getLocation(), a);} 1835 } 1836 throw new Error("Missing return statement in function"); 1837 } 1838 1839 final public ParsedPattern ValueExpr(boolean topLevel, Annotations a) throws ParseException { 1840 LocatedString s; 1841 s = LocatedLiteral(); 1842 if (topLevel && annotationsIncludeElements) { 1843 error("top_level_follow_annotation", s.getToken()); 1844 a = null; 1845 } 1846 {if (true) return sb.makeValue("", "token", s.getString(), getContext(), defaultNamespace, s.getLocation(), a);} 1847 throw new Error("Missing return statement in function"); 1848 } 1849 1850 final public ParsedPattern DataExpr(boolean topLevel, Scope scope, Annotations a, Token[] except) throws ParseException { 1851 Token datatypeToken; 1852 Location loc; 1853 String datatype; 1854 String datatypeUri = null; 1855 String s = null; 1856 ParsedPattern e = null; 1857 DataPatternBuilder dpb; 1858 datatypeToken = DatatypeName(); 1859 datatype = datatypeToken.image; 1860 loc = makeLocation(datatypeToken); 1861 int colon = datatype.indexOf(':'); 1862 if (colon < 0) 1863 datatypeUri = ""; 1864 else { 1865 String prefix = datatype.substring(0, colon); 1866 datatypeUri = lookupDatatype(prefix, datatypeToken); 1867 datatype = datatype.substring(colon + 1); 1868 } 1869 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1870 case LITERAL: 1871 s = Literal(); 1872 if (topLevel && annotationsIncludeElements) { 1873 error("top_level_follow_annotation", datatypeToken); 1874 a = null; 1875 } 1876 {if (true) return sb.makeValue(datatypeUri, datatype, s, getContext(), defaultNamespace, loc, a);} 1877 break; 1878 default: 1879 jj_la1[48] = jj_gen; 1880 dpb = sb.makeDataPatternBuilder(datatypeUri, datatype, loc); 1881 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1882 case 11: 1883 Params(dpb); 1884 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1885 case 30: 1886 e = Except(scope, except); 1887 break; 1888 default: 1889 jj_la1[45] = jj_gen; 1890 ; 1891 } 1892 break; 1893 default: 1894 jj_la1[47] = jj_gen; 1895 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1896 case 30: 1897 e = Except(scope, except); 1898 break; 1899 default: 1900 jj_la1[46] = jj_gen; 1901 ; 1902 } 1903 } 1904 {if (true) return e == null ? dpb.makePattern(loc, a) : dpb.makePattern(e, loc, a);} 1905 } 1906 throw new Error("Missing return statement in function"); 1907 } 1908 1909 final public Token DatatypeName() throws ParseException { 1910 Token t; 1911 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1912 case 35: 1913 t = jj_consume_token(35); 1914 break; 1915 case 36: 1916 t = jj_consume_token(36); 1917 break; 1918 case PREFIXED_NAME: 1919 t = jj_consume_token(PREFIXED_NAME); 1920 break; 1921 default: 1922 jj_la1[49] = jj_gen; 1923 jj_consume_token(-1); 1924 throw new ParseException(); 1925 } 1926 {if (true) return t;} 1927 throw new Error("Missing return statement in function"); 1928 } 1929 1930 final public LocatedString Identifier() throws ParseException { 1931 LocatedString s; 1932 Token t; 1933 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1934 case IDENTIFIER: 1935 t = jj_consume_token(IDENTIFIER); 1936 s = new LocatedString(t.image, t); 1937 break; 1938 case ESCAPED_IDENTIFIER: 1939 t = jj_consume_token(ESCAPED_IDENTIFIER); 1940 s = new LocatedString(t.image.substring(1), t); 1941 break; 1942 default: 1943 jj_la1[50] = jj_gen; 1944 jj_consume_token(-1); 1945 throw new ParseException(); 1946 } 1947 {if (true) return s;} 1948 throw new Error("Missing return statement in function"); 1949 } 1950 1951 final public String Prefix() throws ParseException { 1952 Token t; 1953 String prefix; 1954 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1955 case IDENTIFIER: 1956 t = jj_consume_token(IDENTIFIER); 1957 prefix = t.image; 1958 break; 1959 case ESCAPED_IDENTIFIER: 1960 t = jj_consume_token(ESCAPED_IDENTIFIER); 1961 prefix = t.image.substring(1); 1962 break; 1963 case 5: 1964 case 6: 1965 case 7: 1966 case 10: 1967 case 13: 1968 case 14: 1969 case 15: 1970 case 16: 1971 case 17: 1972 case 18: 1973 case 19: 1974 case 26: 1975 case 27: 1976 case 31: 1977 case 32: 1978 case 33: 1979 case 34: 1980 case 35: 1981 case 36: 1982 t = Keyword(); 1983 prefix = t.image; 1984 break; 1985 default: 1986 jj_la1[51] = jj_gen; 1987 jj_consume_token(-1); 1988 throw new ParseException(); 1989 } 1990 {if (true) return lookupPrefix(prefix, t);} 1991 throw new Error("Missing return statement in function"); 1992 } 1993 1994 final public LocatedString UnprefixedName() throws ParseException { 1995 LocatedString s; 1996 Token t; 1997 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1998 case IDENTIFIER: 1999 case ESCAPED_IDENTIFIER: 2000 s = Identifier(); 2001 break; 2002 case 5: 2003 case 6: 2004 case 7: 2005 case 10: 2006 case 13: 2007 case 14: 2008 case 15: 2009 case 16: 2010 case 17: 2011 case 18: 2012 case 19: 2013 case 26: 2014 case 27: 2015 case 31: 2016 case 32: 2017 case 33: 2018 case 34: 2019 case 35: 2020 case 36: 2021 t = Keyword(); 2022 s = new LocatedString(t.image, t); 2023 break; 2024 default: 2025 jj_la1[52] = jj_gen; 2026 jj_consume_token(-1); 2027 throw new ParseException(); 2028 } 2029 {if (true) return s;} 2030 throw new Error("Missing return statement in function"); 2031 } 2032 2033 final public void Params(DataPatternBuilder dpb) throws ParseException { 2034 jj_consume_token(11); 2035 label_18: 2036 while (true) { 2037 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2038 case 1: 2039 case 5: 2040 case 6: 2041 case 7: 2042 case 10: 2043 case 13: 2044 case 14: 2045 case 15: 2046 case 16: 2047 case 17: 2048 case 18: 2049 case 19: 2050 case 26: 2051 case 27: 2052 case 31: 2053 case 32: 2054 case 33: 2055 case 34: 2056 case 35: 2057 case 36: 2058 case DOCUMENTATION: 2059 case DOCUMENTATION_AFTER_SINGLE_LINE_COMMENT: 2060 case IDENTIFIER: 2061 case ESCAPED_IDENTIFIER: 2062 ; 2063 break; 2064 default: 2065 jj_la1[53] = jj_gen; 2066 break label_18; 2067 } 2068 Param(dpb); 2069 } 2070 jj_consume_token(12); 2071 } 2072 2073 final public void Param(DataPatternBuilder dpb) throws ParseException { 2074 LocatedString name; 2075 Annotations a; 2076 String value; 2077 a = Annotations(); 2078 name = UnprefixedName(); 2079 jj_consume_token(2); 2080 a = addCommentsToLeadingAnnotations(a); 2081 value = Literal(); 2082 dpb.addParam(name.getString(), value, getContext(), defaultNamespace, name.getLocation(), a); 2083 } 2084 2085 final public ParsedPattern Except(Scope scope, Token[] except) throws ParseException { 2086 Annotations a; 2087 ParsedPattern p; 2088 Token t; 2089 Token[] innerExcept = new Token[1]; 2090 t = jj_consume_token(30); 2091 a = Annotations(); 2092 p = PrimaryExpr(false, scope, a, innerExcept); 2093 checkExcept(innerExcept); 2094 except[0] = t; 2095 {if (true) return p;} 2096 throw new Error("Missing return statement in function"); 2097 } 2098 2099 final public ParsedElementAnnotation Documentation() throws ParseException { 2100 CommentList comments = getComments(); 2101 ElementAnnotationBuilder eab; 2102 Token t; 2103 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2104 case DOCUMENTATION: 2105 t = jj_consume_token(DOCUMENTATION); 2106 break; 2107 case DOCUMENTATION_AFTER_SINGLE_LINE_COMMENT: 2108 t = jj_consume_token(DOCUMENTATION_AFTER_SINGLE_LINE_COMMENT); 2109 break; 2110 default: 2111 jj_la1[54] = jj_gen; 2112 jj_consume_token(-1); 2113 throw new ParseException(); 2114 } 2115 eab = sb.makeElementAnnotationBuilder(WellKnownNamespaces.RELAX_NG_COMPATIBILITY_ANNOTATIONS, 2116 "documentation", 2117 getCompatibilityPrefix(), 2118 makeLocation(t), 2119 comments, 2120 getContext()); 2121 eab.addText(mungeComment(t.image), makeLocation(t), null); 2122 label_19: 2123 while (true) { 2124 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2125 case DOCUMENTATION_CONTINUE: 2126 ; 2127 break; 2128 default: 2129 jj_la1[55] = jj_gen; 2130 break label_19; 2131 } 2132 t = jj_consume_token(DOCUMENTATION_CONTINUE); 2133 eab.addText("\u005cn" + mungeComment(t.image), makeLocation(t), null); 2134 } 2135 {if (true) return eab.makeElementAnnotation();} 2136 throw new Error("Missing return statement in function"); 2137 } 2138 2139 final public Annotations Annotations() throws ParseException { 2140 CommentList comments = getComments(); 2141 Annotations a = null; 2142 ParsedElementAnnotation e; 2143 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2144 case DOCUMENTATION: 2145 case DOCUMENTATION_AFTER_SINGLE_LINE_COMMENT: 2146 a = sb.makeAnnotations(comments, getContext()); 2147 label_20: 2148 while (true) { 2149 e = Documentation(); 2150 a.addElement(e); 2151 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2152 case DOCUMENTATION: 2153 case DOCUMENTATION_AFTER_SINGLE_LINE_COMMENT: 2154 ; 2155 break; 2156 default: 2157 jj_la1[56] = jj_gen; 2158 break label_20; 2159 } 2160 } 2161 comments = getComments(); 2162 if (comments != null) 2163 a.addLeadingComment(comments); 2164 break; 2165 default: 2166 jj_la1[57] = jj_gen; 2167 ; 2168 } 2169 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2170 case 1: 2171 jj_consume_token(1); 2172 if (a == null) a = sb.makeAnnotations(comments, getContext()); clearAttributeList(); annotationsIncludeElements = false; 2173 label_21: 2174 while (true) { 2175 if (jj_2_7(2)) { 2176 ; 2177 } else { 2178 break label_21; 2179 } 2180 PrefixedAnnotationAttribute(a, false); 2181 } 2182 label_22: 2183 while (true) { 2184 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2185 case 5: 2186 case 6: 2187 case 7: 2188 case 10: 2189 case 13: 2190 case 14: 2191 case 15: 2192 case 16: 2193 case 17: 2194 case 18: 2195 case 19: 2196 case 26: 2197 case 27: 2198 case 31: 2199 case 32: 2200 case 33: 2201 case 34: 2202 case 35: 2203 case 36: 2204 case IDENTIFIER: 2205 case ESCAPED_IDENTIFIER: 2206 case PREFIXED_NAME: 2207 ; 2208 break; 2209 default: 2210 jj_la1[58] = jj_gen; 2211 break label_22; 2212 } 2213 e = AnnotationElement(false); 2214 a.addElement(e); annotationsIncludeElements = true; 2215 } 2216 a.addComment(getComments()); 2217 jj_consume_token(9); 2218 break; 2219 default: 2220 jj_la1[59] = jj_gen; 2221 ; 2222 } 2223 if (a == null && comments != null) 2224 a = sb.makeAnnotations(comments, getContext()); 2225 {if (true) return a;} 2226 throw new Error("Missing return statement in function"); 2227 } 2228 2229 final public void AnnotationAttribute(Annotations a) throws ParseException { 2230 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2231 case PREFIXED_NAME: 2232 PrefixedAnnotationAttribute(a, true); 2233 break; 2234 case 5: 2235 case 6: 2236 case 7: 2237 case 10: 2238 case 13: 2239 case 14: 2240 case 15: 2241 case 16: 2242 case 17: 2243 case 18: 2244 case 19: 2245 case 26: 2246 case 27: 2247 case 31: 2248 case 32: 2249 case 33: 2250 case 34: 2251 case 35: 2252 case 36: 2253 case IDENTIFIER: 2254 case ESCAPED_IDENTIFIER: 2255 UnprefixedAnnotationAttribute(a); 2256 break; 2257 default: 2258 jj_la1[60] = jj_gen; 2259 jj_consume_token(-1); 2260 throw new ParseException(); 2261 } 2262 } 2263 2264 final public void PrefixedAnnotationAttribute(Annotations a, boolean nested) throws ParseException { 2265 Token t; 2266 String value; 2267 t = jj_consume_token(PREFIXED_NAME); 2268 jj_consume_token(2); 2269 value = Literal(); 2270 String qn = t.image; 2271 int colon = qn.indexOf(':'); 2272 String prefix = qn.substring(0, colon); 2273 String ns = lookupPrefix(prefix, t); 2274 if (ns == this.inheritedNs) 2275 error("inherited_annotation_namespace", t); 2276 else if (ns.length() == 0 && !nested) 2277 error("unqualified_annotation_attribute", t); 2278 else if (ns.equals(WellKnownNamespaces.RELAX_NG) && !nested) 2279 error("relax_ng_namespace", t); 2280 /*else if (ns.length() == 0 2281 && qn.length() - colon - 1 == 5 2282 && qn.regionMatches(colon + 1, "xmlns", 0, 5)) 2283 error("xmlns_annotation_attribute", t);*/ 2284 else if (ns.equals(WellKnownNamespaces.XMLNS)) 2285 error("xmlns_annotation_attribute_uri", t); 2286 else { 2287 if (ns.length() == 0) 2288 prefix = null; 2289 addAttribute(a, ns, qn.substring(colon + 1), prefix, value, t); 2290 } 2291 } 2292 2293 final public void UnprefixedAnnotationAttribute(Annotations a) throws ParseException { 2294 LocatedString name; 2295 String value; 2296 name = UnprefixedName(); 2297 jj_consume_token(2); 2298 value = Literal(); 2299 if (name.getString().equals("xmlns")) 2300 error("xmlns_annotation_attribute", name.getToken()); 2301 else 2302 addAttribute(a, "", name.getString(), null, value, name.getToken()); 2303 } 2304 2305 final public ParsedElementAnnotation AnnotationElement(boolean nested) throws ParseException { 2306 ParsedElementAnnotation a; 2307 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2308 case PREFIXED_NAME: 2309 a = PrefixedAnnotationElement(nested); 2310 break; 2311 case 5: 2312 case 6: 2313 case 7: 2314 case 10: 2315 case 13: 2316 case 14: 2317 case 15: 2318 case 16: 2319 case 17: 2320 case 18: 2321 case 19: 2322 case 26: 2323 case 27: 2324 case 31: 2325 case 32: 2326 case 33: 2327 case 34: 2328 case 35: 2329 case 36: 2330 case IDENTIFIER: 2331 case ESCAPED_IDENTIFIER: 2332 a = UnprefixedAnnotationElement(); 2333 break; 2334 default: 2335 jj_la1[61] = jj_gen; 2336 jj_consume_token(-1); 2337 throw new ParseException(); 2338 } 2339 {if (true) return a;} 2340 throw new Error("Missing return statement in function"); 2341 } 2342 2343 final public ParsedElementAnnotation AnnotationElementNotKeyword() throws ParseException { 2344 ParsedElementAnnotation a; 2345 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2346 case PREFIXED_NAME: 2347 a = PrefixedAnnotationElement(false); 2348 break; 2349 case IDENTIFIER: 2350 case ESCAPED_IDENTIFIER: 2351 a = IdentifierAnnotationElement(); 2352 break; 2353 default: 2354 jj_la1[62] = jj_gen; 2355 jj_consume_token(-1); 2356 throw new ParseException(); 2357 } 2358 {if (true) return a;} 2359 throw new Error("Missing return statement in function"); 2360 } 2361 2362 final public ParsedElementAnnotation PrefixedAnnotationElement(boolean nested) throws ParseException { 2363 CommentList comments = getComments(); 2364 Token t; 2365 ElementAnnotationBuilder eab; 2366 t = jj_consume_token(PREFIXED_NAME); 2367 String qn = t.image; 2368 int colon = qn.indexOf(':'); 2369 String prefix = qn.substring(0, colon); 2370 String ns = lookupPrefix(prefix, t); 2371 if (ns == this.inheritedNs) { 2372 error("inherited_annotation_namespace", t); 2373 ns = ""; 2374 } 2375 else if (!nested && ns.equals(WellKnownNamespaces.RELAX_NG)) { 2376 error("relax_ng_namespace", t); 2377 ns = ""; 2378 } 2379 else { 2380 if (ns.length() == 0) 2381 prefix = null; 2382 } 2383 eab = sb.makeElementAnnotationBuilder(ns, qn.substring(colon + 1), prefix, 2384 makeLocation(t), comments, getContext()); 2385 AnnotationElementContent(eab); 2386 {if (true) return eab.makeElementAnnotation();} 2387 throw new Error("Missing return statement in function"); 2388 } 2389 2390 final public ParsedElementAnnotation UnprefixedAnnotationElement() throws ParseException { 2391 CommentList comments = getComments(); 2392 LocatedString name; 2393 ElementAnnotationBuilder eab; 2394 name = UnprefixedName(); 2395 eab = sb.makeElementAnnotationBuilder("", name.getString(), null, 2396 name.getLocation(), comments, getContext()); 2397 AnnotationElementContent(eab); 2398 {if (true) return eab.makeElementAnnotation();} 2399 throw new Error("Missing return statement in function"); 2400 } 2401 2402 final public ParsedElementAnnotation IdentifierAnnotationElement() throws ParseException { 2403 CommentList comments = getComments(); 2404 LocatedString name; 2405 ElementAnnotationBuilder eab; 2406 name = Identifier(); 2407 eab = sb.makeElementAnnotationBuilder("", name.getString(), null, 2408 name.getLocation(), comments, getContext()); 2409 AnnotationElementContent(eab); 2410 {if (true) return eab.makeElementAnnotation();} 2411 throw new Error("Missing return statement in function"); 2412 } 2413 2414 final public void AnnotationElementContent(ElementAnnotationBuilder eab) throws ParseException { 2415 ParsedElementAnnotation e; 2416 jj_consume_token(1); 2417 clearAttributeList(); 2418 label_23: 2419 while (true) { 2420 if (jj_2_8(2)) { 2421 ; 2422 } else { 2423 break label_23; 2424 } 2425 AnnotationAttribute(eab); 2426 } 2427 label_24: 2428 while (true) { 2429 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2430 case 5: 2431 case 6: 2432 case 7: 2433 case 10: 2434 case 13: 2435 case 14: 2436 case 15: 2437 case 16: 2438 case 17: 2439 case 18: 2440 case 19: 2441 case 26: 2442 case 27: 2443 case 31: 2444 case 32: 2445 case 33: 2446 case 34: 2447 case 35: 2448 case 36: 2449 case IDENTIFIER: 2450 case ESCAPED_IDENTIFIER: 2451 case PREFIXED_NAME: 2452 case LITERAL: 2453 ; 2454 break; 2455 default: 2456 jj_la1[63] = jj_gen; 2457 break label_24; 2458 } 2459 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2460 case LITERAL: 2461 AnnotationElementLiteral(eab); 2462 label_25: 2463 while (true) { 2464 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2465 case 8: 2466 ; 2467 break; 2468 default: 2469 jj_la1[64] = jj_gen; 2470 break label_25; 2471 } 2472 jj_consume_token(8); 2473 AnnotationElementLiteral(eab); 2474 } 2475 break; 2476 case 5: 2477 case 6: 2478 case 7: 2479 case 10: 2480 case 13: 2481 case 14: 2482 case 15: 2483 case 16: 2484 case 17: 2485 case 18: 2486 case 19: 2487 case 26: 2488 case 27: 2489 case 31: 2490 case 32: 2491 case 33: 2492 case 34: 2493 case 35: 2494 case 36: 2495 case IDENTIFIER: 2496 case ESCAPED_IDENTIFIER: 2497 case PREFIXED_NAME: 2498 e = AnnotationElement(true); 2499 eab.addElement(e); 2500 break; 2501 default: 2502 jj_la1[65] = jj_gen; 2503 jj_consume_token(-1); 2504 throw new ParseException(); 2505 } 2506 } 2507 eab.addComment(getComments()); 2508 jj_consume_token(9); 2509 } 2510 2511 final public void AnnotationElementLiteral(ElementAnnotationBuilder eab) throws ParseException { 2512 Token t; 2513 CommentList comments = getComments(); 2514 t = jj_consume_token(LITERAL); 2515 eab.addText(unquote(t.image), makeLocation(t), comments); 2516 } 2517 2518 final public String Literal() throws ParseException { 2519 Token t; 2520 String s; 2521 StringBuffer buf; 2522 t = jj_consume_token(LITERAL); 2523 s = unquote(t.image); 2524 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2525 case 8: 2526 buf = new StringBuffer(s); 2527 label_26: 2528 while (true) { 2529 jj_consume_token(8); 2530 t = jj_consume_token(LITERAL); 2531 buf.append(unquote(t.image)); 2532 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2533 case 8: 2534 ; 2535 break; 2536 default: 2537 jj_la1[66] = jj_gen; 2538 break label_26; 2539 } 2540 } 2541 s = buf.toString(); 2542 break; 2543 default: 2544 jj_la1[67] = jj_gen; 2545 ; 2546 } 2547 {if (true) return s;} 2548 throw new Error("Missing return statement in function"); 2549 } 2550 2551 final public LocatedString LocatedLiteral() throws ParseException { 2552 Token t; 2553 Token t2; 2554 String s; 2555 StringBuffer buf; 2556 t = jj_consume_token(LITERAL); 2557 s = unquote(t.image); 2558 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2559 case 8: 2560 buf = new StringBuffer(s); 2561 label_27: 2562 while (true) { 2563 jj_consume_token(8); 2564 t2 = jj_consume_token(LITERAL); 2565 buf.append(unquote(t2.image)); 2566 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2567 case 8: 2568 ; 2569 break; 2570 default: 2571 jj_la1[68] = jj_gen; 2572 break label_27; 2573 } 2574 } 2575 s = buf.toString(); 2576 break; 2577 default: 2578 jj_la1[69] = jj_gen; 2579 ; 2580 } 2581 {if (true) return new LocatedString(s, t);} 2582 throw new Error("Missing return statement in function"); 2583 } 2584 2585 final public Token Keyword() throws ParseException { 2586 Token t; 2587 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2588 case 26: 2589 t = jj_consume_token(26); 2590 break; 2591 case 27: 2592 t = jj_consume_token(27); 2593 break; 2594 case 13: 2595 t = jj_consume_token(13); 2596 break; 2597 case 31: 2598 t = jj_consume_token(31); 2599 break; 2600 case 32: 2601 t = jj_consume_token(32); 2602 break; 2603 case 10: 2604 t = jj_consume_token(10); 2605 break; 2606 case 17: 2607 t = jj_consume_token(17); 2608 break; 2609 case 18: 2610 t = jj_consume_token(18); 2611 break; 2612 case 34: 2613 t = jj_consume_token(34); 2614 break; 2615 case 33: 2616 t = jj_consume_token(33); 2617 break; 2618 case 19: 2619 t = jj_consume_token(19); 2620 break; 2621 case 5: 2622 t = jj_consume_token(5); 2623 break; 2624 case 7: 2625 t = jj_consume_token(7); 2626 break; 2627 case 14: 2628 t = jj_consume_token(14); 2629 break; 2630 case 15: 2631 t = jj_consume_token(15); 2632 break; 2633 case 35: 2634 t = jj_consume_token(35); 2635 break; 2636 case 36: 2637 t = jj_consume_token(36); 2638 break; 2639 case 16: 2640 t = jj_consume_token(16); 2641 break; 2642 case 6: 2643 t = jj_consume_token(6); 2644 break; 2645 default: 2646 jj_la1[70] = jj_gen; 2647 jj_consume_token(-1); 2648 throw new ParseException(); 2649 } 2650 {if (true) return t;} 2651 throw new Error("Missing return statement in function"); 2652 } 2653 2654 private boolean jj_2_1(int xla) { 2655 jj_la = xla; jj_lastpos = jj_scanpos = token; 2656 try { return !jj_3_1(); } 2657 catch(LookaheadSuccess ls) { return true; } 2658 finally { jj_save(0, xla); } 2659 } 2660 2661 private boolean jj_2_2(int xla) { 2662 jj_la = xla; jj_lastpos = jj_scanpos = token; 2663 try { return !jj_3_2(); } 2664 catch(LookaheadSuccess ls) { return true; } 2665 finally { jj_save(1, xla); } 2666 } 2667 2668 private boolean jj_2_3(int xla) { 2669 jj_la = xla; jj_lastpos = jj_scanpos = token; 2670 try { return !jj_3_3(); } 2671 catch(LookaheadSuccess ls) { return true; } 2672 finally { jj_save(2, xla); } 2673 } 2674 2675 private boolean jj_2_4(int xla) { 2676 jj_la = xla; jj_lastpos = jj_scanpos = token; 2677 try { return !jj_3_4(); } 2678 catch(LookaheadSuccess ls) { return true; } 2679 finally { jj_save(3, xla); } 2680 } 2681 2682 private boolean jj_2_5(int xla) { 2683 jj_la = xla; jj_lastpos = jj_scanpos = token; 2684 try { return !jj_3_5(); } 2685 catch(LookaheadSuccess ls) { return true; } 2686 finally { jj_save(4, xla); } 2687 } 2688 2689 private boolean jj_2_6(int xla) { 2690 jj_la = xla; jj_lastpos = jj_scanpos = token; 2691 try { return !jj_3_6(); } 2692 catch(LookaheadSuccess ls) { return true; } 2693 finally { jj_save(5, xla); } 2694 } 2695 2696 private boolean jj_2_7(int xla) { 2697 jj_la = xla; jj_lastpos = jj_scanpos = token; 2698 try { return !jj_3_7(); } 2699 catch(LookaheadSuccess ls) { return true; } 2700 finally { jj_save(6, xla); } 2701 } 2702 2703 private boolean jj_2_8(int xla) { 2704 jj_la = xla; jj_lastpos = jj_scanpos = token; 2705 try { return !jj_3_8(); } 2706 catch(LookaheadSuccess ls) { return true; } 2707 finally { jj_save(7, xla); } 2708 } 2709 2710 private boolean jj_3R_43() { 2711 if (jj_scan_token(1)) return true; 2712 Token xsp; 2713 while (true) { 2714 xsp = jj_scanpos; 2715 if (jj_3R_52()) { jj_scanpos = xsp; break; } 2716 } 2717 if (jj_scan_token(9)) return true; 2718 return false; 2719 } 2720 2721 private boolean jj_3R_51() { 2722 if (jj_scan_token(ESCAPED_IDENTIFIER)) return true; 2723 return false; 2724 } 2725 2726 private boolean jj_3R_50() { 2727 if (jj_scan_token(IDENTIFIER)) return true; 2728 return false; 2729 } 2730 2731 private boolean jj_3R_41() { 2732 Token xsp; 2733 xsp = jj_scanpos; 2734 if (jj_3R_50()) { 2735 jj_scanpos = xsp; 2736 if (jj_3R_51()) return true; 2737 } 2738 return false; 2739 } 2740 2741 private boolean jj_3R_47() { 2742 if (jj_scan_token(PREFIXED_NAME)) return true; 2743 if (jj_3R_56()) return true; 2744 return false; 2745 } 2746 2747 private boolean jj_3R_55() { 2748 Token xsp; 2749 xsp = jj_scanpos; 2750 if (jj_scan_token(40)) { 2751 jj_scanpos = xsp; 2752 if (jj_scan_token(43)) return true; 2753 } 2754 while (true) { 2755 xsp = jj_scanpos; 2756 if (jj_scan_token(41)) { jj_scanpos = xsp; break; } 2757 } 2758 return false; 2759 } 2760 2761 private boolean jj_3R_45() { 2762 Token xsp; 2763 if (jj_3R_55()) return true; 2764 while (true) { 2765 xsp = jj_scanpos; 2766 if (jj_3R_55()) { jj_scanpos = xsp; break; } 2767 } 2768 return false; 2769 } 2770 2771 private boolean jj_3R_38() { 2772 if (jj_3R_48()) return true; 2773 return false; 2774 } 2775 2776 private boolean jj_3R_42() { 2777 Token xsp; 2778 xsp = jj_scanpos; 2779 if (jj_scan_token(5)) { 2780 jj_scanpos = xsp; 2781 if (jj_scan_token(6)) { 2782 jj_scanpos = xsp; 2783 if (jj_scan_token(7)) return true; 2784 } 2785 } 2786 return false; 2787 } 2788 2789 private boolean jj_3R_37() { 2790 if (jj_3R_47()) return true; 2791 return false; 2792 } 2793 2794 private boolean jj_3R_54() { 2795 if (jj_3R_42()) return true; 2796 return false; 2797 } 2798 2799 private boolean jj_3R_29() { 2800 Token xsp; 2801 xsp = jj_scanpos; 2802 if (jj_3R_37()) { 2803 jj_scanpos = xsp; 2804 if (jj_3R_38()) return true; 2805 } 2806 return false; 2807 } 2808 2809 private boolean jj_3R_44() { 2810 Token xsp; 2811 xsp = jj_scanpos; 2812 if (jj_3R_53()) { 2813 jj_scanpos = xsp; 2814 if (jj_3R_54()) return true; 2815 } 2816 return false; 2817 } 2818 2819 private boolean jj_3R_53() { 2820 if (jj_3R_41()) return true; 2821 Token xsp; 2822 xsp = jj_scanpos; 2823 if (jj_scan_token(2)) { 2824 jj_scanpos = xsp; 2825 if (jj_scan_token(3)) { 2826 jj_scanpos = xsp; 2827 if (jj_scan_token(4)) return true; 2828 } 2829 } 2830 return false; 2831 } 2832 2833 private boolean jj_3R_36() { 2834 if (jj_3R_45()) return true; 2835 Token xsp; 2836 xsp = jj_scanpos; 2837 if (jj_3R_46()) jj_scanpos = xsp; 2838 if (jj_3R_44()) return true; 2839 return false; 2840 } 2841 2842 private boolean jj_3R_35() { 2843 if (jj_3R_43()) return true; 2844 if (jj_3R_44()) return true; 2845 return false; 2846 } 2847 2848 private boolean jj_3R_34() { 2849 if (jj_3R_42()) return true; 2850 return false; 2851 } 2852 2853 private boolean jj_3R_33() { 2854 if (jj_3R_41()) return true; 2855 Token xsp; 2856 xsp = jj_scanpos; 2857 if (jj_scan_token(1)) { 2858 jj_scanpos = xsp; 2859 if (jj_scan_token(2)) { 2860 jj_scanpos = xsp; 2861 if (jj_scan_token(3)) { 2862 jj_scanpos = xsp; 2863 if (jj_scan_token(4)) return true; 2864 } 2865 } 2866 } 2867 return false; 2868 } 2869 2870 private boolean jj_3_1() { 2871 if (jj_3R_28()) return true; 2872 return false; 2873 } 2874 2875 private boolean jj_3R_32() { 2876 if (jj_scan_token(PREFIXED_NAME)) return true; 2877 if (jj_scan_token(1)) return true; 2878 return false; 2879 } 2880 2881 private boolean jj_3R_28() { 2882 Token xsp; 2883 xsp = jj_scanpos; 2884 if (jj_3R_32()) { 2885 jj_scanpos = xsp; 2886 if (jj_3R_33()) { 2887 jj_scanpos = xsp; 2888 if (jj_3R_34()) { 2889 jj_scanpos = xsp; 2890 if (jj_3R_35()) { 2891 jj_scanpos = xsp; 2892 if (jj_3R_36()) return true; 2893 } 2894 } 2895 } 2896 } 2897 return false; 2898 } 2899 2900 private boolean jj_3R_59() { 2901 if (jj_3R_43()) return true; 2902 return false; 2903 } 2904 2905 private boolean jj_3_8() { 2906 if (jj_3R_31()) return true; 2907 return false; 2908 } 2909 2910 private boolean jj_3R_56() { 2911 if (jj_scan_token(1)) return true; 2912 return false; 2913 } 2914 2915 private boolean jj_3R_49() { 2916 if (jj_3R_57()) return true; 2917 if (jj_scan_token(2)) return true; 2918 return false; 2919 } 2920 2921 private boolean jj_3R_40() { 2922 if (jj_3R_49()) return true; 2923 return false; 2924 } 2925 2926 private boolean jj_3_4() { 2927 if (jj_3R_29()) return true; 2928 return false; 2929 } 2930 2931 private boolean jj_3R_48() { 2932 if (jj_3R_41()) return true; 2933 if (jj_3R_56()) return true; 2934 return false; 2935 } 2936 2937 private boolean jj_3_3() { 2938 if (jj_3R_29()) return true; 2939 return false; 2940 } 2941 2942 private boolean jj_3_6() { 2943 if (jj_3R_29()) return true; 2944 return false; 2945 } 2946 2947 private boolean jj_3R_62() { 2948 Token xsp; 2949 xsp = jj_scanpos; 2950 if (jj_scan_token(26)) { 2951 jj_scanpos = xsp; 2952 if (jj_scan_token(27)) { 2953 jj_scanpos = xsp; 2954 if (jj_scan_token(13)) { 2955 jj_scanpos = xsp; 2956 if (jj_scan_token(31)) { 2957 jj_scanpos = xsp; 2958 if (jj_scan_token(32)) { 2959 jj_scanpos = xsp; 2960 if (jj_scan_token(10)) { 2961 jj_scanpos = xsp; 2962 if (jj_scan_token(17)) { 2963 jj_scanpos = xsp; 2964 if (jj_scan_token(18)) { 2965 jj_scanpos = xsp; 2966 if (jj_scan_token(34)) { 2967 jj_scanpos = xsp; 2968 if (jj_scan_token(33)) { 2969 jj_scanpos = xsp; 2970 if (jj_scan_token(19)) { 2971 jj_scanpos = xsp; 2972 if (jj_scan_token(5)) { 2973 jj_scanpos = xsp; 2974 if (jj_scan_token(7)) { 2975 jj_scanpos = xsp; 2976 if (jj_scan_token(14)) { 2977 jj_scanpos = xsp; 2978 if (jj_scan_token(15)) { 2979 jj_scanpos = xsp; 2980 if (jj_scan_token(35)) { 2981 jj_scanpos = xsp; 2982 if (jj_scan_token(36)) { 2983 jj_scanpos = xsp; 2984 if (jj_scan_token(16)) { 2985 jj_scanpos = xsp; 2986 if (jj_scan_token(6)) return true; 2987 } 2988 } 2989 } 2990 } 2991 } 2992 } 2993 } 2994 } 2995 } 2996 } 2997 } 2998 } 2999 } 3000 } 3001 } 3002 } 3003 } 3004 } 3005 return false; 3006 } 3007 3008 private boolean jj_3R_61() { 3009 if (jj_3R_62()) return true; 3010 return false; 3011 } 3012 3013 private boolean jj_3_2() { 3014 if (jj_3R_28()) return true; 3015 return false; 3016 } 3017 3018 private boolean jj_3R_30() { 3019 if (jj_scan_token(PREFIXED_NAME)) return true; 3020 if (jj_scan_token(2)) return true; 3021 return false; 3022 } 3023 3024 private boolean jj_3R_60() { 3025 if (jj_3R_41()) return true; 3026 return false; 3027 } 3028 3029 private boolean jj_3R_58() { 3030 if (jj_3R_57()) return true; 3031 return false; 3032 } 3033 3034 private boolean jj_3R_57() { 3035 Token xsp; 3036 xsp = jj_scanpos; 3037 if (jj_3R_60()) { 3038 jj_scanpos = xsp; 3039 if (jj_3R_61()) return true; 3040 } 3041 return false; 3042 } 3043 3044 private boolean jj_3_5() { 3045 if (jj_3R_29()) return true; 3046 return false; 3047 } 3048 3049 private boolean jj_3R_31() { 3050 Token xsp; 3051 xsp = jj_scanpos; 3052 if (jj_3R_39()) { 3053 jj_scanpos = xsp; 3054 if (jj_3R_40()) return true; 3055 } 3056 return false; 3057 } 3058 3059 private boolean jj_3R_39() { 3060 if (jj_3R_30()) return true; 3061 return false; 3062 } 3063 3064 private boolean jj_3_7() { 3065 if (jj_3R_30()) return true; 3066 return false; 3067 } 3068 3069 private boolean jj_3R_46() { 3070 if (jj_3R_43()) return true; 3071 return false; 3072 } 3073 3074 private boolean jj_3R_52() { 3075 Token xsp; 3076 xsp = jj_scanpos; 3077 if (jj_scan_token(57)) { 3078 jj_scanpos = xsp; 3079 if (jj_3R_58()) { 3080 jj_scanpos = xsp; 3081 if (jj_scan_token(2)) { 3082 jj_scanpos = xsp; 3083 if (jj_scan_token(58)) { 3084 jj_scanpos = xsp; 3085 if (jj_scan_token(8)) { 3086 jj_scanpos = xsp; 3087 if (jj_3R_59()) return true; 3088 } 3089 } 3090 } 3091 } 3092 } 3093 return false; 3094 } 3095 3096 /** Generated Token Manager. */ 3097 public CompactSyntaxTokenManager token_source; 3098 JavaCharStream jj_input_stream; 3099 /** Current token. */ 3100 public Token token; 3101 /** Next token. */ 3102 public Token jj_nt; 3103 private int jj_ntk; 3104 private Token jj_scanpos, jj_lastpos; 3105 private int jj_la; 3106 private int jj_gen; 3107 final private int[] jj_la1 = new int[71]; 3108 static private int[] jj_la1_0; 3109 static private int[] jj_la1_1; 3110 static { 3111 jj_la1_init_0(); 3112 jj_la1_init_1(); 3113 } 3114 private static void jj_la1_init_0() { 3115 jj_la1_0 = new int[] {0x9c0e0402,0x1e,0x2,0xe2,0x1c,0xe0,0xe0,0x0,0x0,0x0,0x8c0fe5e6,0x8c0fe5e6,0x402,0x16000,0x16000,0x8c0fe4e0,0x6000,0x8000,0x0,0x9c0e0400,0x100000,0x200000,0x400000,0x700000,0x700000,0x3800000,0x0,0x3800000,0x9e0fe4e0,0x0,0x100000,0x100000,0x9e0fe4e0,0x9c0fe4e0,0x2000000,0x40000000,0x40000000,0xe2,0xe0,0x20,0x1c,0x800,0x62,0x60,0x8000,0x40000000,0x40000000,0x800,0x0,0x0,0x0,0x8c0fe4e0,0x8c0fe4e0,0x8c0fe4e2,0x0,0x0,0x0,0x0,0x8c0fe4e0,0x2,0x8c0fe4e0,0x8c0fe4e0,0x0,0x8c0fe4e0,0x100,0x8c0fe4e0,0x100,0x100,0x100,0x100,0x8c0fe4e0,}; 3116 } 3117 private static void jj_la1_init_1() { 3118 jj_la1_1 = new int[] {0x6c0091f,0x0,0x0,0x2c00900,0x0,0xc00000,0x0,0x900,0x200,0x900,0x6c0001f,0x6c0001f,0x900,0x0,0x0,0xc0001f,0x0,0x4000000,0x8000000,0x6c0001f,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x0,0x3c0001f,0x8000000,0x0,0x0,0x3c0001f,0x2c0001f,0x1000000,0x0,0x0,0xc00900,0xc00000,0xc00000,0x0,0x0,0xc00900,0xc00000,0x0,0x0,0x0,0x0,0x4000000,0x2000018,0xc00000,0xc0001f,0xc0001f,0xc0091f,0x900,0x200,0x900,0x900,0x2c0001f,0x0,0x2c0001f,0x2c0001f,0x2c00000,0x6c0001f,0x0,0x6c0001f,0x0,0x0,0x0,0x0,0x1f,}; 3119 } 3120 final private JJCalls[] jj_2_rtns = new JJCalls[8]; 3121 private boolean jj_rescan = false; 3122 private int jj_gc = 0; 3123 3124 /** Constructor with InputStream. */ 3125 public CompactSyntax(java.io.InputStream stream) { 3126 this(stream, null); 3127 } 3128 /** Constructor with InputStream and supplied encoding */ 3129 public CompactSyntax(java.io.InputStream stream, String encoding) { 3130 try { jj_input_stream = new JavaCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); } 3131 token_source = new CompactSyntaxTokenManager(jj_input_stream); 3132 token = new Token(); 3133 jj_ntk = -1; 3134 jj_gen = 0; 3135 for (int i = 0; i < 71; i++) jj_la1[i] = -1; 3136 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); 3137 } 3138 3139 /** Reinitialise. */ 3140 public void ReInit(java.io.InputStream stream) { 3141 ReInit(stream, null); 3142 } 3143 /** Reinitialise. */ 3144 public void ReInit(java.io.InputStream stream, String encoding) { 3145 try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); } 3146 token_source.ReInit(jj_input_stream); 3147 token = new Token(); 3148 jj_ntk = -1; 3149 jj_gen = 0; 3150 for (int i = 0; i < 71; i++) jj_la1[i] = -1; 3151 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); 3152 } 3153 3154 /** Constructor. */ 3155 public CompactSyntax(java.io.Reader stream) { 3156 jj_input_stream = new JavaCharStream(stream, 1, 1); 3157 token_source = new CompactSyntaxTokenManager(jj_input_stream); 3158 token = new Token(); 3159 jj_ntk = -1; 3160 jj_gen = 0; 3161 for (int i = 0; i < 71; i++) jj_la1[i] = -1; 3162 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); 3163 } 3164 3165 /** Reinitialise. */ 3166 public void ReInit(java.io.Reader stream) { 3167 jj_input_stream.ReInit(stream, 1, 1); 3168 token_source.ReInit(jj_input_stream); 3169 token = new Token(); 3170 jj_ntk = -1; 3171 jj_gen = 0; 3172 for (int i = 0; i < 71; i++) jj_la1[i] = -1; 3173 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); 3174 } 3175 3176 /** Constructor with generated Token Manager. */ 3177 public CompactSyntax(CompactSyntaxTokenManager tm) { 3178 token_source = tm; 3179 token = new Token(); 3180 jj_ntk = -1; 3181 jj_gen = 0; 3182 for (int i = 0; i < 71; i++) jj_la1[i] = -1; 3183 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); 3184 } 3185 3186 /** Reinitialise. */ 3187 public void ReInit(CompactSyntaxTokenManager tm) { 3188 token_source = tm; 3189 token = new Token(); 3190 jj_ntk = -1; 3191 jj_gen = 0; 3192 for (int i = 0; i < 71; i++) jj_la1[i] = -1; 3193 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); 3194 } 3195 3196 private Token jj_consume_token(int kind) throws ParseException { 3197 Token oldToken; 3198 if ((oldToken = token).next != null) token = token.next; 3199 else token = token.next = token_source.getNextToken(); 3200 jj_ntk = -1; 3201 if (token.kind == kind) { 3202 jj_gen++; 3203 if (++jj_gc > 100) { 3204 jj_gc = 0; 3205 for (int i = 0; i < jj_2_rtns.length; i++) { 3206 JJCalls c = jj_2_rtns[i]; 3207 while (c != null) { 3208 if (c.gen < jj_gen) c.first = null; 3209 c = c.next; 3210 } 3211 } 3212 } 3213 return token; 3214 } 3215 token = oldToken; 3216 jj_kind = kind; 3217 throw generateParseException(); 3218 } 3219 3220 static private final class LookaheadSuccess extends java.lang.Error { } 3221 final private LookaheadSuccess jj_ls = new LookaheadSuccess(); 3222 private boolean jj_scan_token(int kind) { 3223 if (jj_scanpos == jj_lastpos) { 3224 jj_la--; 3225 if (jj_scanpos.next == null) { 3226 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken(); 3227 } else { 3228 jj_lastpos = jj_scanpos = jj_scanpos.next; 3229 } 3230 } else { 3231 jj_scanpos = jj_scanpos.next; 3232 } 3233 if (jj_rescan) { 3234 int i = 0; Token tok = token; 3235 while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; } 3236 if (tok != null) jj_add_error_token(kind, i); 3237 } 3238 if (jj_scanpos.kind != kind) return true; 3239 if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls; 3240 return false; 3241 } 3242 3243 3244/** Get the next Token. */ 3245 final public Token getNextToken() { 3246 if (token.next != null) token = token.next; 3247 else token = token.next = token_source.getNextToken(); 3248 jj_ntk = -1; 3249 jj_gen++; 3250 return token; 3251 } 3252 3253/** Get the specific Token. */ 3254 final public Token getToken(int index) { 3255 Token t = token; 3256 for (int i = 0; i < index; i++) { 3257 if (t.next != null) t = t.next; 3258 else t = t.next = token_source.getNextToken(); 3259 } 3260 return t; 3261 } 3262 3263 private int jj_ntk() { 3264 if ((jj_nt=token.next) == null) 3265 return (jj_ntk = (token.next=token_source.getNextToken()).kind); 3266 else 3267 return (jj_ntk = jj_nt.kind); 3268 } 3269 3270 private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>(); 3271 private int[] jj_expentry; 3272 private int jj_kind = -1; 3273 private int[] jj_lasttokens = new int[100]; 3274 private int jj_endpos; 3275 3276 private void jj_add_error_token(int kind, int pos) { 3277 if (pos >= 100) return; 3278 if (pos == jj_endpos + 1) { 3279 jj_lasttokens[jj_endpos++] = kind; 3280 } else if (jj_endpos != 0) { 3281 jj_expentry = new int[jj_endpos]; 3282 for (int i = 0; i < jj_endpos; i++) { 3283 jj_expentry[i] = jj_lasttokens[i]; 3284 } 3285 jj_entries_loop: for (java.util.Iterator<?> it = jj_expentries.iterator(); it.hasNext();) { 3286 int[] oldentry = (int[])(it.next()); 3287 if (oldentry.length == jj_expentry.length) { 3288 for (int i = 0; i < jj_expentry.length; i++) { 3289 if (oldentry[i] != jj_expentry[i]) { 3290 continue jj_entries_loop; 3291 } 3292 } 3293 jj_expentries.add(jj_expentry); 3294 break jj_entries_loop; 3295 } 3296 } 3297 if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind; 3298 } 3299 } 3300 3301 /** Generate ParseException. */ 3302 public ParseException generateParseException() { 3303 jj_expentries.clear(); 3304 boolean[] la1tokens = new boolean[61]; 3305 if (jj_kind >= 0) { 3306 la1tokens[jj_kind] = true; 3307 jj_kind = -1; 3308 } 3309 for (int i = 0; i < 71; i++) { 3310 if (jj_la1[i] == jj_gen) { 3311 for (int j = 0; j < 32; j++) { 3312 if ((jj_la1_0[i] & (1<<j)) != 0) { 3313 la1tokens[j] = true; 3314 } 3315 if ((jj_la1_1[i] & (1<<j)) != 0) { 3316 la1tokens[32+j] = true; 3317 } 3318 } 3319 } 3320 } 3321 for (int i = 0; i < 61; i++) { 3322 if (la1tokens[i]) { 3323 jj_expentry = new int[1]; 3324 jj_expentry[0] = i; 3325 jj_expentries.add(jj_expentry); 3326 } 3327 } 3328 jj_endpos = 0; 3329 jj_rescan_token(); 3330 jj_add_error_token(0, 0); 3331 int[][] exptokseq = new int[jj_expentries.size()][]; 3332 for (int i = 0; i < jj_expentries.size(); i++) { 3333 exptokseq[i] = jj_expentries.get(i); 3334 } 3335 return new ParseException(token, exptokseq, tokenImage); 3336 } 3337 3338 /** Enable tracing. */ 3339 final public void enable_tracing() { 3340 } 3341 3342 /** Disable tracing. */ 3343 final public void disable_tracing() { 3344 } 3345 3346 private void jj_rescan_token() { 3347 jj_rescan = true; 3348 for (int i = 0; i < 8; i++) { 3349 try { 3350 JJCalls p = jj_2_rtns[i]; 3351 do { 3352 if (p.gen > jj_gen) { 3353 jj_la = p.arg; jj_lastpos = jj_scanpos = p.first; 3354 switch (i) { 3355 case 0: jj_3_1(); break; 3356 case 1: jj_3_2(); break; 3357 case 2: jj_3_3(); break; 3358 case 3: jj_3_4(); break; 3359 case 4: jj_3_5(); break; 3360 case 5: jj_3_6(); break; 3361 case 6: jj_3_7(); break; 3362 case 7: jj_3_8(); break; 3363 } 3364 } 3365 p = p.next; 3366 } while (p != null); 3367 } catch(LookaheadSuccess ls) { } 3368 } 3369 jj_rescan = false; 3370 } 3371 3372 private void jj_save(int index, int xla) { 3373 JJCalls p = jj_2_rtns[index]; 3374 while (p.gen > jj_gen) { 3375 if (p.next == null) { p = p.next = new JJCalls(); break; } 3376 p = p.next; 3377 } 3378 p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla; 3379 } 3380 3381 static final class JJCalls { 3382 int gen; 3383 Token first; 3384 int arg; 3385 JJCalls next; 3386 } 3387 3388} 3389