001/* Generated By:JavaCC: Do not edit this line. Parser.java */ 002package org.w3c.flute.parser; 003 004import java.io.*; 005import java.net.*; 006import java.util.Locale; 007 008 009import org.w3c.css.sac.ConditionFactory; 010import org.w3c.css.sac.Condition; 011import org.w3c.css.sac.SelectorFactory; 012import org.w3c.css.sac.SelectorList; 013import org.w3c.css.sac.Selector; 014import org.w3c.css.sac.SimpleSelector; 015import org.w3c.css.sac.DocumentHandler; 016import org.w3c.css.sac.InputSource; 017import org.w3c.css.sac.ErrorHandler; 018import org.w3c.css.sac.CSSException; 019import org.w3c.css.sac.CSSParseException; 020import org.w3c.css.sac.Locator; 021import org.w3c.css.sac.LexicalUnit; 022 023import org.w3c.flute.parser.selectors.SelectorFactoryImpl; 024import org.w3c.flute.parser.selectors.ConditionFactoryImpl; 025 026import org.w3c.flute.util.Encoding; 027 028/** 029 * A CSS2 parser 030 * 031 * @author Philippe Le H?garet 032 * @version $Revision: 1.4 $ 033 */ 034public class Parser implements org.w3c.css.sac.Parser, ParserConstants { 035 036 // replaces all \t, \n, etc with this StringBuffer. 037 static final StringBuilder SPACE = new StringBuilder(" "); 038 039 // the document handler for the parser 040 protected DocumentHandler documentHandler; 041 // the error handler for the parser 042 protected ErrorHandler errorHandler; 043 // the input source for the parser 044 protected InputSource source; 045 046 protected ConditionFactory conditionFactory; 047 protected SelectorFactory selectorFactory; 048 049 // temporary place holder for pseudo-element ... 050 protected String pseudoElt; 051 052 /** 053 * Creates a new Parser 054 */ 055 public Parser() { 056 this((CharStream) null); 057 } 058 059 /** 060 * @@TODO 061 * @exception CSSException Not yet implemented 062 */ 063 public void setLocale(Locale locale) throws CSSException { 064 throw new CSSException(CSSException.SAC_NOT_SUPPORTED_ERR); 065 } 066 067 /** 068 * Set the document handler for this parser 069 */ 070 public void setDocumentHandler(DocumentHandler handler) { 071 this.documentHandler = handler; 072 } 073 074 public void setSelectorFactory(SelectorFactory selectorFactory) { 075 this.selectorFactory = selectorFactory; 076 } 077 078 public void setConditionFactory(ConditionFactory conditionFactory) { 079 this.conditionFactory = conditionFactory; 080 } 081 082 /** 083 * Set the error handler for this parser 084 */ 085 public void setErrorHandler(ErrorHandler error) { 086 this.errorHandler = error; 087 } 088 089 /** 090 * Main parse methods 091 * 092 * @param source the source of the style sheet. 093 * @exception IOException the source can't be parsed. 094 * @exception CSSException the source is not CSS valid. 095 */ 096 public void parseStyleSheet(InputSource source) 097 throws CSSException, IOException { 098 this.source = source; 099 ReInit(getCharStreamWithLurk(source)); 100 if (selectorFactory == null) { 101 selectorFactory = new SelectorFactoryImpl(); 102 } 103 if (conditionFactory == null) { 104 conditionFactory = new ConditionFactoryImpl(); 105 } 106 107 parserUnit(); 108 } 109 110 /** 111 * Convenient method for URIs. 112 * 113 * @param systemId the fully resolved URI of the style sheet. 114 * @exception IOException the source can't be parsed. 115 * @exception CSSException the source is not CSS valid. 116 */ 117 public void parseStyleSheet(String systemId) 118 throws CSSException, IOException { 119 parseStyleSheet(new InputSource(systemId)); 120 } 121 122 /** 123 * This method parses only one rule (style rule or at-rule, except @charset). 124 * 125 * @param source the source of the rule. 126 * @exception IOException the source can't be parsed. 127 * @exception CSSException the source is not CSS valid. 128 */ 129 public void parseRule(InputSource source) 130 throws CSSException, IOException { 131 this.source = source; 132 ReInit(getCharStreamWithLurk(source)); 133 134 if (selectorFactory == null) { 135 selectorFactory = new SelectorFactoryImpl(); 136 } 137 if (conditionFactory == null) { 138 conditionFactory = new ConditionFactoryImpl(); 139 } 140 _parseRule(); 141 } 142 143 /** 144 * This method parses a style declaration (including the surrounding curly 145 * braces). 146 * 147 * @param source the source of the style declaration. 148 * @exception IOException the source can't be parsed. 149 * @exception CSSException the source is not CSS valid. 150 */ 151 public void parseStyleDeclaration(InputSource source) 152 throws CSSException, IOException { 153 this.source = source; 154 ReInit(getCharStreamWithLurk(source)); 155 156 if (selectorFactory == null) { 157 selectorFactory = new SelectorFactoryImpl(); 158 } 159 if (conditionFactory == null) { 160 conditionFactory = new ConditionFactoryImpl(); 161 } 162 _parseDeclarationBlock(); 163 } 164 165 /** 166 * This methods returns "http://www.w3.org/TR/REC-CSS2". 167 * @return the string "http://www.w3.org/TR/REC-CSS2". 168 */ 169 public String getParserVersion() { 170 return "http://www.w3.org/TR/REC-CSS2"; 171 } 172 173 /** 174 * Parse methods used by DOM Level 2 implementation. 175 */ 176 public void parseImportRule(InputSource source) 177 throws CSSException, IOException { 178 this.source = source; 179 ReInit(getCharStreamWithLurk(source)); 180 181 if (selectorFactory == null) { 182 selectorFactory = new SelectorFactoryImpl(); 183 } 184 if (conditionFactory == null) { 185 conditionFactory = new ConditionFactoryImpl(); 186 } 187 _parseImportRule(); 188 } 189 190 public void parseMediaRule(InputSource source) 191 throws CSSException, IOException { 192 this.source = source; 193 ReInit(getCharStreamWithLurk(source)); 194 195 if (selectorFactory == null) { 196 selectorFactory = new SelectorFactoryImpl(); 197 } 198 if (conditionFactory == null) { 199 conditionFactory = new ConditionFactoryImpl(); 200 } 201 _parseMediaRule(); 202 } 203 204 public SelectorList parseSelectors(InputSource source) 205 throws CSSException, IOException { 206 this.source = source; 207 ReInit(getCharStreamWithLurk(source)); 208 209 if (selectorFactory == null) { 210 selectorFactory = new SelectorFactoryImpl(); 211 } 212 if (conditionFactory == null) { 213 conditionFactory = new ConditionFactoryImpl(); 214 } 215 return _parseSelectors(); 216 } 217 218 219 public String parseNamespaceToken(InputSource source) 220 throws CSSException, IOException { 221 this.source = source; 222 ReInit(getCharStreamWithLurk(source)); 223 224 if (selectorFactory == null) { 225 selectorFactory = new SelectorFactoryImpl(); 226 } 227 if (conditionFactory == null) { 228 conditionFactory = new ConditionFactoryImpl(); 229 } 230 return _parseNamespaceToken(); 231 } 232 233 public LexicalUnit parsePropertyValue(InputSource source) 234 throws CSSException, IOException { 235 this.source = source; 236 ReInit(getCharStreamWithLurk(source)); 237 238 return expr(); 239 } 240 241 public boolean parsePriority(InputSource source) 242 throws CSSException, IOException { 243 this.source = source; 244 ReInit(getCharStreamWithLurk(source)); 245 246 return prio(); 247 } 248 249 /** 250 * Convert the source into a Reader. Used only by DOM Level 2 parser methods. 251 */ 252 private Reader getReader(InputSource source) throws IOException { 253 if (source.getCharacterStream() != null) { 254 return source.getCharacterStream(); 255 } else if (source.getByteStream() != null) { 256 // My DOM level 2 implementation doesn't use this case. 257 if (source.getEncoding() == null) { 258 // unknown encoding, use ASCII as default. 259 return new InputStreamReader(source.getByteStream(), "ASCII"); 260 } else { 261 return new InputStreamReader(source.getByteStream(), 262 source.getEncoding()); 263 } 264 } else { 265 // systemId 266 // @@TODO 267 throw new CSSException("not yet implemented"); 268 } 269 } 270 271 /** 272 * Convert the source into a CharStream with encoding informations. 273 * The encoding can be found in the InputSource or in the CSS document. 274 * Since this method marks the reader and make a reset after looking for 275 * the charset declaration, you'll find the charset declaration into the 276 * stream. 277 */ 278 private CharStream getCharStreamWithLurk(InputSource source) 279 throws CSSException, IOException { 280 if (source.getCharacterStream() != null) { 281 // all encoding are supposed to be resolved by the user 282 // return the reader 283 return new Generic_CharStream(source.getCharacterStream(), 1, 1); 284 } else if (source.getByteStream() == null) { 285 // @@CONTINUE ME. see also getReader() with systemId 286 try { 287 source.setByteStream(new URL(source.getURI()).openStream()); 288 } catch (Exception e) { 289 try { 290 source.setByteStream(new FileInputStream(source.getURI())); 291 } catch (IOException ex) { 292 throw new CSSException("invalid url ?"); 293 } 294 } 295 } 296 String encoding = "ASCII"; 297 InputStream input = source.getByteStream(); 298 char c = ' '; 299 300 if (!input.markSupported()) { 301 input = new BufferedInputStream(input); 302 source.setByteStream(input); 303 } 304 input.mark(100); 305 c = (char) input.read(); 306 307 if (c == '@') { 308 // hum, is it a charset ? 309 int size = 100; 310 byte[] buf = new byte[size]; 311 input.read(buf, 0, 7); 312 String keyword = new String(buf, 0, 7); 313 if (keyword.equals("charset")) { 314 // Yes, this is the charset declaration ! 315 316 // here I don't use the right declaration : white space are ' '. 317 while ((c = (char) input.read()) == ' ') { 318 // find the first quote 319 } 320 char endChar = c; 321 int i = 0; 322 323 if ((endChar != '"') && (endChar != '\u005c'')) { 324 // hum this is not a quote. 325 throw new CSSException("invalid charset declaration"); 326 } 327 328 while ((c = (char) input.read()) != endChar) { 329 buf[i++] = (byte) c; 330 if (i == size) { 331 byte[] old = buf; 332 buf = new byte[size + 100]; 333 System.arraycopy(old, 0, buf, 0, size); 334 size += 100; 335 } 336 } 337 while ((c = (char) input.read()) == ' ') { 338 // find the next relevant character 339 } 340 if (c != ';') { 341 // no semi colon at the end ? 342 throw new CSSException("invalid charset declaration: " 343 + "missing semi colon"); 344 } 345 encoding = new String(buf, 0, i); 346 if (source.getEncoding() != null) { 347 // compare the two encoding informations. 348 // For example, I don't accept to have ASCII and after UTF-8. 349 // Is it really good ? That is the question. 350 if (!encoding.equals(source.getEncoding())) { 351 throw new CSSException("invalid encoding information."); 352 } 353 } 354 } // else no charset declaration available 355 } 356 // ok set the real encoding of this source. 357 source.setEncoding(encoding); 358 // set the real reader of this source. 359 source.setCharacterStream(new InputStreamReader(source.getByteStream(), 360 Encoding.getJavaEncoding(encoding))); 361 // reset the stream (leave the charset declaration in the stream). 362 input.reset(); 363 364 return new Generic_CharStream(source.getCharacterStream(), 1, 1); 365 } 366 367 private LocatorImpl currentLocator; 368 private Locator getLocator() { 369 if (currentLocator == null) { 370 currentLocator = new LocatorImpl(this); 371 return currentLocator; 372 } 373 return currentLocator.reInit(this); 374 } 375 private LocatorImpl getLocator(Token save) { 376 if (currentLocator == null) { 377 currentLocator = new LocatorImpl(this, save); 378 return currentLocator; 379 } 380 return currentLocator.reInit(this, save); 381 } 382 383 private void reportError(Locator l, Exception e) { 384 if (errorHandler != null) { 385 if (e instanceof ParseException) { 386 // construct a clean error message. 387 ParseException pe = (ParseException) e; 388 if (pe.specialConstructor) { 389 StringBuffer errorM = new StringBuffer(); 390 if (pe.currentToken != null) { 391 errorM.append("encountered \u005c"") 392 .append(pe.currentToken.next); 393 } 394 errorM.append('"'); 395 if (pe.expectedTokenSequences.length != 0) { 396 errorM.append(". Was expecting one of: "); 397 for (int i = 0; i < pe.expectedTokenSequences.length; i++) { 398 for (int j = 0; j < pe.expectedTokenSequences[i].length; j++) { 399 int kind = pe.expectedTokenSequences[i][j]; 400 if (kind != S) { 401 errorM.append(pe.tokenImage[kind]); 402 errorM.append(' '); 403 } 404 } 405 } 406 } 407 errorHandler.error(new CSSParseException(errorM.toString(), 408 l, e)); 409 } else { 410 errorHandler.error(new CSSParseException(e.getMessage(), 411 l, e)); 412 } 413 } else if (e == null) { 414 errorHandler.error(new CSSParseException("error", l, null)); 415 } else { 416 errorHandler.error(new CSSParseException(e.getMessage(), l, e)); 417 } 418 } 419 } 420 421 private void reportWarningSkipText(Locator l, String text) { 422 if (errorHandler != null && text != null) { 423 errorHandler.warning(new CSSParseException("Skipping: " + text, l)); 424 } 425 } 426 427/* 428 * The grammar of CSS2 429 */ 430 431/** 432 * The main entry for the parser. 433 * 434 * @exception ParseException exception during the parse 435 */ 436 final public void parserUnit() throws ParseException { 437 try { 438 documentHandler.startDocument(source); 439 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 440 case CHARSET_SYM: 441 charset(); 442 break; 443 default: 444 jj_la1[0] = jj_gen; 445 ; 446 } 447 label_1: 448 while (true) { 449 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 450 case S: 451 case CDO: 452 case CDC: 453 case ATKEYWORD: 454 ; 455 break; 456 default: 457 jj_la1[1] = jj_gen; 458 break label_1; 459 } 460 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 461 case S: 462 jj_consume_token(S); 463 break; 464 case CDO: 465 case CDC: 466 case ATKEYWORD: 467 ignoreStatement(); 468 break; 469 default: 470 jj_la1[2] = jj_gen; 471 jj_consume_token(-1); 472 throw new ParseException(); 473 } 474 } 475 label_2: 476 while (true) { 477 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 478 case IMPORT_SYM: 479 ; 480 break; 481 default: 482 jj_la1[3] = jj_gen; 483 break label_2; 484 } 485 importDeclaration(); 486 label_3: 487 while (true) { 488 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 489 case CDO: 490 case CDC: 491 case ATKEYWORD: 492 ; 493 break; 494 default: 495 jj_la1[4] = jj_gen; 496 break label_3; 497 } 498 ignoreStatement(); 499 label_4: 500 while (true) { 501 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 502 case S: 503 ; 504 break; 505 default: 506 jj_la1[5] = jj_gen; 507 break label_4; 508 } 509 jj_consume_token(S); 510 } 511 } 512 } 513 label_5: 514 while (true) { 515 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 516 case NAMESPACE_SYM: 517 ; 518 break; 519 default: 520 jj_la1[6] = jj_gen; 521 break label_5; 522 } 523 namespaceDeclaration(); 524 label_6: 525 while (true) { 526 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 527 case CDO: 528 case CDC: 529 case ATKEYWORD: 530 ; 531 break; 532 default: 533 jj_la1[7] = jj_gen; 534 break label_6; 535 } 536 ignoreStatement(); 537 label_7: 538 while (true) { 539 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 540 case S: 541 ; 542 break; 543 default: 544 jj_la1[8] = jj_gen; 545 break label_7; 546 } 547 jj_consume_token(S); 548 } 549 } 550 } 551 afterImportDeclaration(); 552 jj_consume_token(0); 553 } finally { 554 documentHandler.endDocument(source); 555 } 556 } 557 558 final public void charset() throws ParseException { 559 Token n; 560 try { 561 jj_consume_token(CHARSET_SYM); 562 label_8: 563 while (true) { 564 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 565 case S: 566 ; 567 break; 568 default: 569 jj_la1[9] = jj_gen; 570 break label_8; 571 } 572 jj_consume_token(S); 573 } 574 n = jj_consume_token(STRING); 575 label_9: 576 while (true) { 577 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 578 case S: 579 ; 580 break; 581 default: 582 jj_la1[10] = jj_gen; 583 break label_9; 584 } 585 jj_consume_token(S); 586 } 587 jj_consume_token(SEMICOLON); 588 } catch (ParseException e) { 589 reportError(getLocator(e.currentToken.next), e); 590 skipStatement(); 591 // reportWarningSkipText(getLocator(), skipStatement()); 592 593 } catch (Exception e) { 594 reportError(getLocator(), e); 595 skipStatement(); 596 // reportWarningSkipText(getLocator(), skipStatement()); 597 598 } 599 } 600 601 final public void afterImportDeclaration() throws ParseException { 602 String ret; 603 Locator l; 604 label_10: 605 while (true) { 606 ; 607 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 608 case LBRACKET: 609 case ANY: 610 case DOT: 611 case COLON: 612 case IDENT: 613 case NAMESPACE_IDENT: 614 case HASH: 615 styleRule(); 616 break; 617 case MEDIA_SYM: 618 media(); 619 break; 620 case PAGE_SYM: 621 page(); 622 break; 623 case FONT_FACE_SYM: 624 fontFace(); 625 break; 626 default: 627 jj_la1[11] = jj_gen; 628 l = getLocator(); 629 ret = skipStatement(); 630 if ((ret == null) || (ret.length() == 0)) { 631 {if (true) return;} 632 } 633 reportWarningSkipText(l, ret); 634 if (ret.charAt(0) == '@') { 635 documentHandler.ignorableAtRule(ret); 636 } 637 } 638 label_11: 639 while (true) { 640 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 641 case CDO: 642 case CDC: 643 case ATKEYWORD: 644 ; 645 break; 646 default: 647 jj_la1[12] = jj_gen; 648 break label_11; 649 } 650 ignoreStatement(); 651 label_12: 652 while (true) { 653 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 654 case S: 655 ; 656 break; 657 default: 658 jj_la1[13] = jj_gen; 659 break label_12; 660 } 661 jj_consume_token(S); 662 } 663 } 664 } 665 } 666 667 final public void ignoreStatement() throws ParseException { 668 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 669 case CDO: 670 jj_consume_token(CDO); 671 break; 672 case CDC: 673 jj_consume_token(CDC); 674 break; 675 case ATKEYWORD: 676 atRuleDeclaration(); 677 break; 678 default: 679 jj_la1[14] = jj_gen; 680 jj_consume_token(-1); 681 throw new ParseException(); 682 } 683 } 684 685/** 686 * The import statement 687 * 688 * @exception ParseException exception during the parse 689 */ 690 final public void importDeclaration() throws ParseException { 691 Token n; 692 String uri; 693 MediaListImpl ml = new MediaListImpl(); 694 try { 695 jj_consume_token(IMPORT_SYM); 696 label_13: 697 while (true) { 698 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 699 case S: 700 ; 701 break; 702 default: 703 jj_la1[15] = jj_gen; 704 break label_13; 705 } 706 jj_consume_token(S); 707 } 708 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 709 case STRING: 710 n = jj_consume_token(STRING); 711 uri = convertStringIndex(n.image, 1, 712 n.image.length() -1); 713 break; 714 case URL: 715 n = jj_consume_token(URL); 716 uri = n.image.substring(4, n.image.length()-1).trim(); 717 if ((uri.charAt(0) == '"') 718 || (uri.charAt(0) == '\u005c'')) { 719 uri = uri.substring(1, uri.length()-1); 720 } 721 break; 722 default: 723 jj_la1[16] = jj_gen; 724 jj_consume_token(-1); 725 throw new ParseException(); 726 } 727 label_14: 728 while (true) { 729 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 730 case S: 731 ; 732 break; 733 default: 734 jj_la1[17] = jj_gen; 735 break label_14; 736 } 737 jj_consume_token(S); 738 } 739 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 740 case IDENT: 741 mediaStatement(ml); 742 break; 743 default: 744 jj_la1[18] = jj_gen; 745 ; 746 } 747 jj_consume_token(SEMICOLON); 748 label_15: 749 while (true) { 750 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 751 case S: 752 ; 753 break; 754 default: 755 jj_la1[19] = jj_gen; 756 break label_15; 757 } 758 jj_consume_token(S); 759 } 760 if (ml.getLength() == 0) { 761 // see section 6.3 of the CSS2 recommandation. 762 ml.addItem("all"); 763 } 764 documentHandler.importStyle(uri, ml, null); 765 } catch (ParseException e) { 766 reportError(getLocator(), e); 767 skipStatement(); 768 // reportWarningSkipText(getLocator(), skipStatement()); 769 770 } 771 } 772 773/** 774 * The namespace statement 775 * 776 * @exception ParseException exception during the parse 777 */ 778 final public void namespaceDeclaration() throws ParseException { 779 Token n; 780 Token prefix = null; 781 String uri; 782 try { 783 jj_consume_token(NAMESPACE_SYM); 784 label_16: 785 while (true) { 786 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 787 case S: 788 ; 789 break; 790 default: 791 jj_la1[20] = jj_gen; 792 break label_16; 793 } 794 jj_consume_token(S); 795 } 796 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 797 case IDENT: 798 prefix = jj_consume_token(IDENT); 799 label_17: 800 while (true) { 801 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 802 case S: 803 ; 804 break; 805 default: 806 jj_la1[21] = jj_gen; 807 break label_17; 808 } 809 jj_consume_token(S); 810 } 811 break; 812 default: 813 jj_la1[22] = jj_gen; 814 ; 815 } 816 n = jj_consume_token(URL); 817 uri = n.image.substring(4, n.image.length()-1).trim(); 818 if ((uri.charAt(0) == '"') || (uri.charAt(0) == '\u005c'')) 819 { 820 uri = uri.substring(1, uri.length()-1); 821 } 822 jj_consume_token(SEMICOLON); 823 label_18: 824 while (true) { 825 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 826 case S: 827 ; 828 break; 829 default: 830 jj_la1[23] = jj_gen; 831 break label_18; 832 } 833 jj_consume_token(S); 834 } 835 if (prefix == null) 836 { 837 this.documentHandler.namespaceDeclaration("", uri); 838 } 839 else 840 { 841 this.documentHandler.namespaceDeclaration(prefix.image, uri); 842 } 843 } catch (ParseException e) { 844 reportError(getLocator(), e); 845 skipStatement(); 846 // reportWarningSkipText(getLocator(), skipStatement()); 847 848 } 849 } 850 851/** 852 * @exception ParseException exception during the parse 853 */ 854 final public void media() throws ParseException { 855 boolean start = false; 856 String ret; 857 MediaListImpl ml = new MediaListImpl(); 858 try { 859 jj_consume_token(MEDIA_SYM); 860 label_19: 861 while (true) { 862 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 863 case S: 864 ; 865 break; 866 default: 867 jj_la1[24] = jj_gen; 868 break label_19; 869 } 870 jj_consume_token(S); 871 } 872 mediaStatement(ml); 873 start = true; documentHandler.startMedia(ml); 874 jj_consume_token(LBRACE); 875 label_20: 876 while (true) { 877 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 878 case S: 879 ; 880 break; 881 default: 882 jj_la1[25] = jj_gen; 883 break label_20; 884 } 885 jj_consume_token(S); 886 } 887 label_21: 888 while (true) { 889 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 890 case CDO: 891 case LBRACE: 892 case DASHMATCH: 893 case INCLUDES: 894 case PLUS: 895 case MINUS: 896 case COMMA: 897 case SEMICOLON: 898 case PRECEDES: 899 case LBRACKET: 900 case ANY: 901 case DOT: 902 case COLON: 903 case NONASCII: 904 case STRING: 905 case IDENT: 906 case NUMBER: 907 case URL: 908 case NAMESPACE_IDENT: 909 case PERCENTAGE: 910 case HASH: 911 case IMPORT_SYM: 912 case MEDIA_SYM: 913 case CHARSET_SYM: 914 case PAGE_SYM: 915 case FONT_FACE_SYM: 916 case ATKEYWORD: 917 case IMPORTANT_SYM: 918 case UNICODERANGE: 919 case FUNCTION: 920 case UNKNOWN: 921 ; 922 break; 923 default: 924 jj_la1[26] = jj_gen; 925 break label_21; 926 } 927 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 928 case LBRACKET: 929 case ANY: 930 case DOT: 931 case COLON: 932 case IDENT: 933 case NAMESPACE_IDENT: 934 case HASH: 935 styleRule(); 936 break; 937 case CDO: 938 case LBRACE: 939 case DASHMATCH: 940 case INCLUDES: 941 case PLUS: 942 case MINUS: 943 case COMMA: 944 case SEMICOLON: 945 case PRECEDES: 946 case NONASCII: 947 case STRING: 948 case NUMBER: 949 case URL: 950 case PERCENTAGE: 951 case IMPORT_SYM: 952 case MEDIA_SYM: 953 case CHARSET_SYM: 954 case PAGE_SYM: 955 case FONT_FACE_SYM: 956 case ATKEYWORD: 957 case IMPORTANT_SYM: 958 case UNICODERANGE: 959 case FUNCTION: 960 case UNKNOWN: 961 skipUnknownRule(); 962 break; 963 default: 964 jj_la1[27] = jj_gen; 965 jj_consume_token(-1); 966 throw new ParseException(); 967 } 968 } 969 jj_consume_token(RBRACE); 970 label_22: 971 while (true) { 972 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 973 case S: 974 ; 975 break; 976 default: 977 jj_la1[28] = jj_gen; 978 break label_22; 979 } 980 jj_consume_token(S); 981 } 982 } catch (ParseException e) { 983 reportError(getLocator(), e); 984 skipStatement(); 985 // reportWarningSkipText(getLocator(), skipStatement()); 986 987 } finally { 988 if (start) { 989 documentHandler.endMedia(ml); 990 } 991 } 992 } 993 994 final public void mediaStatement(MediaListImpl ml) throws ParseException { 995 String m; 996 m = medium(); 997 label_23: 998 while (true) { 999 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1000 case COMMA: 1001 ; 1002 break; 1003 default: 1004 jj_la1[29] = jj_gen; 1005 break label_23; 1006 } 1007 jj_consume_token(COMMA); 1008 label_24: 1009 while (true) { 1010 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1011 case S: 1012 ; 1013 break; 1014 default: 1015 jj_la1[30] = jj_gen; 1016 break label_24; 1017 } 1018 jj_consume_token(S); 1019 } 1020 ml.addItem(m); 1021 m = medium(); 1022 } 1023 ml.addItem(m); 1024 } 1025 1026/** 1027 * @exception ParseException exception during the parse 1028 */ 1029 final public String medium() throws ParseException { 1030 Token n; 1031 n = jj_consume_token(IDENT); 1032 label_25: 1033 while (true) { 1034 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1035 case S: 1036 ; 1037 break; 1038 default: 1039 jj_la1[31] = jj_gen; 1040 break label_25; 1041 } 1042 jj_consume_token(S); 1043 } 1044 {if (true) return convertIdent(n.image);} 1045 throw new Error("Missing return statement in function"); 1046 } 1047 1048/** 1049 * @exception ParseException exception during the parse 1050 */ 1051 final public void page() throws ParseException { 1052 boolean start = false; 1053 Token n = null; 1054 String page = null; 1055 String pseudo = null; 1056 try { 1057 jj_consume_token(PAGE_SYM); 1058 label_26: 1059 while (true) { 1060 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1061 case S: 1062 ; 1063 break; 1064 default: 1065 jj_la1[32] = jj_gen; 1066 break label_26; 1067 } 1068 jj_consume_token(S); 1069 } 1070 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1071 case IDENT: 1072 n = jj_consume_token(IDENT); 1073 label_27: 1074 while (true) { 1075 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1076 case S: 1077 ; 1078 break; 1079 default: 1080 jj_la1[33] = jj_gen; 1081 break label_27; 1082 } 1083 jj_consume_token(S); 1084 } 1085 break; 1086 default: 1087 jj_la1[34] = jj_gen; 1088 ; 1089 } 1090 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1091 case COLON: 1092 pseudo = pseudo_page(); 1093 break; 1094 default: 1095 jj_la1[35] = jj_gen; 1096 ; 1097 } 1098 if (n != null) { 1099 page = convertIdent(n.image); 1100 } 1101 jj_consume_token(LBRACE); 1102 label_28: 1103 while (true) { 1104 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1105 case S: 1106 ; 1107 break; 1108 default: 1109 jj_la1[36] = jj_gen; 1110 break label_28; 1111 } 1112 jj_consume_token(S); 1113 } 1114 start = true; 1115 documentHandler.startPage(page, pseudo); 1116 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1117 case IDENT: 1118 declaration(); 1119 break; 1120 default: 1121 jj_la1[37] = jj_gen; 1122 ; 1123 } 1124 label_29: 1125 while (true) { 1126 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1127 case SEMICOLON: 1128 ; 1129 break; 1130 default: 1131 jj_la1[38] = jj_gen; 1132 break label_29; 1133 } 1134 jj_consume_token(SEMICOLON); 1135 label_30: 1136 while (true) { 1137 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1138 case S: 1139 ; 1140 break; 1141 default: 1142 jj_la1[39] = jj_gen; 1143 break label_30; 1144 } 1145 jj_consume_token(S); 1146 } 1147 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1148 case IDENT: 1149 declaration(); 1150 break; 1151 default: 1152 jj_la1[40] = jj_gen; 1153 ; 1154 } 1155 } 1156 label_31: 1157 while (true) { 1158 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1159 case ATKEYWORD: 1160 ; 1161 break; 1162 default: 1163 jj_la1[41] = jj_gen; 1164 break label_31; 1165 } 1166 atRuleDeclaration(); 1167 } 1168 jj_consume_token(RBRACE); 1169 label_32: 1170 while (true) { 1171 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1172 case S: 1173 ; 1174 break; 1175 default: 1176 jj_la1[42] = jj_gen; 1177 break label_32; 1178 } 1179 jj_consume_token(S); 1180 } 1181 } catch (ParseException e) { 1182 if (errorHandler != null) { 1183 LocatorImpl li = new LocatorImpl(this, 1184 e.currentToken.next.beginLine, 1185 e.currentToken.next.beginColumn-1); 1186 reportError(li, e); 1187 skipStatement(); 1188 // reportWarningSkipText(li, skipStatement()); 1189 } else { 1190 skipStatement(); 1191 } 1192 } finally { 1193 if (start) { 1194 documentHandler.endPage(page, pseudo); 1195 } 1196 } 1197 } 1198 1199 final public String pseudo_page() throws ParseException { 1200 Token n; 1201 jj_consume_token(COLON); 1202 n = jj_consume_token(IDENT); 1203 label_33: 1204 while (true) { 1205 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1206 case S: 1207 ; 1208 break; 1209 default: 1210 jj_la1[43] = jj_gen; 1211 break label_33; 1212 } 1213 jj_consume_token(S); 1214 } 1215 {if (true) return convertIdent(n.image);} 1216 throw new Error("Missing return statement in function"); 1217 } 1218 1219 final public void fontFace() throws ParseException { 1220 boolean start = false; 1221 try { 1222 jj_consume_token(FONT_FACE_SYM); 1223 label_34: 1224 while (true) { 1225 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1226 case S: 1227 ; 1228 break; 1229 default: 1230 jj_la1[44] = jj_gen; 1231 break label_34; 1232 } 1233 jj_consume_token(S); 1234 } 1235 jj_consume_token(LBRACE); 1236 label_35: 1237 while (true) { 1238 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1239 case S: 1240 ; 1241 break; 1242 default: 1243 jj_la1[45] = jj_gen; 1244 break label_35; 1245 } 1246 jj_consume_token(S); 1247 } 1248 start = true; documentHandler.startFontFace(); 1249 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1250 case IDENT: 1251 declaration(); 1252 break; 1253 default: 1254 jj_la1[46] = jj_gen; 1255 ; 1256 } 1257 label_36: 1258 while (true) { 1259 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1260 case SEMICOLON: 1261 ; 1262 break; 1263 default: 1264 jj_la1[47] = jj_gen; 1265 break label_36; 1266 } 1267 jj_consume_token(SEMICOLON); 1268 label_37: 1269 while (true) { 1270 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1271 case S: 1272 ; 1273 break; 1274 default: 1275 jj_la1[48] = jj_gen; 1276 break label_37; 1277 } 1278 jj_consume_token(S); 1279 } 1280 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1281 case IDENT: 1282 declaration(); 1283 break; 1284 default: 1285 jj_la1[49] = jj_gen; 1286 ; 1287 } 1288 } 1289 jj_consume_token(RBRACE); 1290 label_38: 1291 while (true) { 1292 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1293 case S: 1294 ; 1295 break; 1296 default: 1297 jj_la1[50] = jj_gen; 1298 break label_38; 1299 } 1300 jj_consume_token(S); 1301 } 1302 } catch (ParseException e) { 1303 reportError(getLocator(), e); 1304 skipStatement(); 1305 // reportWarningSkipText(getLocator(), skipStatement()); 1306 1307 } finally { 1308 if (start) { 1309 documentHandler.endFontFace(); 1310 } 1311 } 1312 } 1313 1314/** 1315 * @exception ParseException exception during the parse 1316 */ 1317 final public void atRuleDeclaration() throws ParseException { 1318 Token n; 1319 String ret; 1320 n = jj_consume_token(ATKEYWORD); 1321 ret=skipStatementNoSemicolon(); 1322 reportWarningSkipText(getLocator(), ret); 1323 if ((ret != null) && (ret.charAt(0) == '@')) { 1324 documentHandler.ignorableAtRule(ret); 1325 } 1326 } 1327 1328 final public void skipUnknownRule() throws ParseException { 1329 Token n; 1330 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1331 case ATKEYWORD: 1332 n = jj_consume_token(ATKEYWORD); 1333 break; 1334 case CDO: 1335 n = jj_consume_token(CDO); 1336 break; 1337 case CHARSET_SYM: 1338 n = jj_consume_token(CHARSET_SYM); 1339 break; 1340 case COMMA: 1341 n = jj_consume_token(COMMA); 1342 break; 1343 case DASHMATCH: 1344 n = jj_consume_token(DASHMATCH); 1345 break; 1346 case FONT_FACE_SYM: 1347 n = jj_consume_token(FONT_FACE_SYM); 1348 break; 1349 case FUNCTION: 1350 n = jj_consume_token(FUNCTION); 1351 break; 1352 case IMPORTANT_SYM: 1353 n = jj_consume_token(IMPORTANT_SYM); 1354 break; 1355 case IMPORT_SYM: 1356 n = jj_consume_token(IMPORT_SYM); 1357 break; 1358 case INCLUDES: 1359 n = jj_consume_token(INCLUDES); 1360 break; 1361 case LBRACE: 1362 n = jj_consume_token(LBRACE); 1363 break; 1364 case MEDIA_SYM: 1365 n = jj_consume_token(MEDIA_SYM); 1366 break; 1367 case NONASCII: 1368 n = jj_consume_token(NONASCII); 1369 break; 1370 case NUMBER: 1371 n = jj_consume_token(NUMBER); 1372 break; 1373 case PAGE_SYM: 1374 n = jj_consume_token(PAGE_SYM); 1375 break; 1376 case PERCENTAGE: 1377 n = jj_consume_token(PERCENTAGE); 1378 break; 1379 case STRING: 1380 n = jj_consume_token(STRING); 1381 break; 1382 case UNICODERANGE: 1383 n = jj_consume_token(UNICODERANGE); 1384 break; 1385 case URL: 1386 n = jj_consume_token(URL); 1387 break; 1388 case SEMICOLON: 1389 n = jj_consume_token(SEMICOLON); 1390 break; 1391 case PLUS: 1392 n = jj_consume_token(PLUS); 1393 break; 1394 case PRECEDES: 1395 n = jj_consume_token(PRECEDES); 1396 break; 1397 case MINUS: 1398 n = jj_consume_token(MINUS); 1399 break; 1400 case UNKNOWN: 1401 n = jj_consume_token(UNKNOWN); 1402 break; 1403 default: 1404 jj_la1[51] = jj_gen; 1405 jj_consume_token(-1); 1406 throw new ParseException(); 1407 } 1408 String ret; 1409 Locator loc = getLocator(); 1410 ret=skipStatement(); 1411 reportWarningSkipText(loc, ret); 1412 if ((ret != null) && (n.image.charAt(0) == '@')) { 1413 documentHandler.ignorableAtRule(ret); 1414 } 1415 } 1416 1417/** 1418 * @exception ParseException exception during the parse 1419 */ 1420 final public char combinator() throws ParseException { 1421char connector = ' '; 1422 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1423 case PLUS: 1424 jj_consume_token(PLUS); 1425 label_39: 1426 while (true) { 1427 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1428 case S: 1429 ; 1430 break; 1431 default: 1432 jj_la1[52] = jj_gen; 1433 break label_39; 1434 } 1435 jj_consume_token(S); 1436 } 1437 {if (true) return '+';} 1438 break; 1439 case PRECEDES: 1440 jj_consume_token(PRECEDES); 1441 label_40: 1442 while (true) { 1443 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1444 case S: 1445 ; 1446 break; 1447 default: 1448 jj_la1[53] = jj_gen; 1449 break label_40; 1450 } 1451 jj_consume_token(S); 1452 } 1453 {if (true) return '>';} 1454 break; 1455 case S: 1456 jj_consume_token(S); 1457 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1458 case PLUS: 1459 case PRECEDES: 1460 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1461 case PLUS: 1462 jj_consume_token(PLUS); 1463 connector = '+'; 1464 break; 1465 case PRECEDES: 1466 jj_consume_token(PRECEDES); 1467 connector = '>'; 1468 break; 1469 default: 1470 jj_la1[54] = jj_gen; 1471 jj_consume_token(-1); 1472 throw new ParseException(); 1473 } 1474 label_41: 1475 while (true) { 1476 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1477 case S: 1478 ; 1479 break; 1480 default: 1481 jj_la1[55] = jj_gen; 1482 break label_41; 1483 } 1484 jj_consume_token(S); 1485 } 1486 break; 1487 default: 1488 jj_la1[56] = jj_gen; 1489 ; 1490 } 1491 {if (true) return connector;} 1492 break; 1493 default: 1494 jj_la1[57] = jj_gen; 1495 jj_consume_token(-1); 1496 throw new ParseException(); 1497 } 1498 throw new Error("Missing return statement in function"); 1499 } 1500 1501/** 1502 * @exception ParseException exception during the parse 1503 */ 1504 final public String property() throws ParseException { 1505 Token n; 1506 n = jj_consume_token(IDENT); 1507 label_42: 1508 while (true) { 1509 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1510 case S: 1511 ; 1512 break; 1513 default: 1514 jj_la1[58] = jj_gen; 1515 break label_42; 1516 } 1517 jj_consume_token(S); 1518 } 1519 {if (true) return convertIdent(n.image);} 1520 throw new Error("Missing return statement in function"); 1521 } 1522 1523/** 1524 * @exception ParseException exception during the parse 1525 */ 1526 final public void styleRule() throws ParseException { 1527 boolean start = false; 1528 SelectorList l = null; 1529 Token save; 1530 Locator loc; 1531 try { 1532 l = selectorList(); 1533 save = token; 1534 jj_consume_token(LBRACE); 1535 label_43: 1536 while (true) { 1537 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1538 case S: 1539 ; 1540 break; 1541 default: 1542 jj_la1[59] = jj_gen; 1543 break label_43; 1544 } 1545 jj_consume_token(S); 1546 } 1547 start = true; 1548 documentHandler.startSelector(l); 1549 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1550 case IDENT: 1551 declaration(); 1552 break; 1553 default: 1554 jj_la1[60] = jj_gen; 1555 ; 1556 } 1557 label_44: 1558 while (true) { 1559 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1560 case SEMICOLON: 1561 ; 1562 break; 1563 default: 1564 jj_la1[61] = jj_gen; 1565 break label_44; 1566 } 1567 jj_consume_token(SEMICOLON); 1568 label_45: 1569 while (true) { 1570 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1571 case S: 1572 ; 1573 break; 1574 default: 1575 jj_la1[62] = jj_gen; 1576 break label_45; 1577 } 1578 jj_consume_token(S); 1579 } 1580 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1581 case IDENT: 1582 declaration(); 1583 break; 1584 default: 1585 jj_la1[63] = jj_gen; 1586 ; 1587 } 1588 } 1589 jj_consume_token(RBRACE); 1590 label_46: 1591 while (true) { 1592 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1593 case S: 1594 ; 1595 break; 1596 default: 1597 jj_la1[64] = jj_gen; 1598 break label_46; 1599 } 1600 jj_consume_token(S); 1601 } 1602 } catch (ThrowedParseException e) { 1603 if (errorHandler != null) { 1604 LocatorImpl li = new LocatorImpl(this, 1605 e.e.currentToken.next.beginLine, 1606 e.e.currentToken.next.beginColumn-1); 1607 reportError(li, e.e); 1608 } 1609 } catch (ParseException e) { 1610 reportError(getLocator(), e); 1611 skipStatement(); 1612 // reportWarningSkipText(getLocator(), skipStatement()); 1613 1614 } catch (TokenMgrError e) { 1615 reportWarningSkipText(getLocator(), skipStatement()); 1616 } finally { 1617 if (start) { 1618 documentHandler.endSelector(l); 1619 } 1620 } 1621 } 1622 1623 final public SelectorList selectorList() throws ParseException { 1624 SelectorListImpl selectors = new SelectorListImpl(); 1625 Selector selector; 1626 selector = selector(); 1627 label_47: 1628 while (true) { 1629 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1630 case COMMA: 1631 ; 1632 break; 1633 default: 1634 jj_la1[65] = jj_gen; 1635 break label_47; 1636 } 1637 jj_consume_token(COMMA); 1638 label_48: 1639 while (true) { 1640 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1641 case S: 1642 ; 1643 break; 1644 default: 1645 jj_la1[66] = jj_gen; 1646 break label_48; 1647 } 1648 jj_consume_token(S); 1649 } 1650 selectors.addSelector(selector); 1651 selector = selector(); 1652 } 1653 selectors.addSelector(selector); 1654 {if (true) return selectors;} 1655 throw new Error("Missing return statement in function"); 1656 } 1657 1658/** 1659 * @exception ParseException exception during the parse 1660 */ 1661 final public Selector selector() throws ParseException { 1662 Selector selector; 1663 char comb; 1664 try { 1665 selector = simple_selector(null, ' '); 1666 label_49: 1667 while (true) { 1668 if (jj_2_1(2)) { 1669 ; 1670 } else { 1671 break label_49; 1672 } 1673 comb = combinator(); 1674 selector = simple_selector(selector, comb); 1675 } 1676 label_50: 1677 while (true) { 1678 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1679 case S: 1680 ; 1681 break; 1682 default: 1683 jj_la1[67] = jj_gen; 1684 break label_50; 1685 } 1686 jj_consume_token(S); 1687 } 1688 {if (true) return selector;} 1689 } catch (ParseException e) { 1690 /* 1691 Token t = getToken(1); 1692 StringBuffer s = new StringBuffer(); 1693 s.append(getToken(0).image); 1694 while ((t.kind != COMMA) && (t.kind != SEMICOLON) 1695 && (t.kind != LBRACE) && (t.kind != EOF)) { 1696 s.append(t.image); 1697 getNextToken(); 1698 t = getToken(1); 1699 } 1700 reportWarningSkipText(getLocator(), s.toString()); 1701 */ 1702 Token t = getToken(1); 1703 while ((t.kind != COMMA) && (t.kind != SEMICOLON) 1704 && (t.kind != LBRACE) && (t.kind != EOF)) { 1705 getNextToken(); 1706 t = getToken(1); 1707 } 1708 1709 {if (true) throw new ThrowedParseException(e);} 1710 } 1711 throw new Error("Missing return statement in function"); 1712 } 1713 1714/** 1715 * @exception ParseException exception during the parse 1716 */ 1717 final public Selector simple_selector(Selector selector, char comb) throws ParseException { 1718 SimpleSelector simple_current = null; 1719 Condition cond = null; 1720 1721 pseudoElt = null; 1722 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1723 case ANY: 1724 case IDENT: 1725 case NAMESPACE_IDENT: 1726 simple_current = element_name(); 1727 label_51: 1728 while (true) { 1729 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1730 case LBRACKET: 1731 case DOT: 1732 case COLON: 1733 case HASH: 1734 ; 1735 break; 1736 default: 1737 jj_la1[68] = jj_gen; 1738 break label_51; 1739 } 1740 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1741 case HASH: 1742 cond = hash(cond); 1743 break; 1744 case DOT: 1745 cond = _class(cond); 1746 break; 1747 case LBRACKET: 1748 cond = attrib(cond); 1749 break; 1750 case COLON: 1751 cond = pseudo(cond); 1752 break; 1753 default: 1754 jj_la1[69] = jj_gen; 1755 jj_consume_token(-1); 1756 throw new ParseException(); 1757 } 1758 } 1759 break; 1760 case HASH: 1761 cond = hash(cond); 1762 label_52: 1763 while (true) { 1764 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1765 case LBRACKET: 1766 case DOT: 1767 case COLON: 1768 ; 1769 break; 1770 default: 1771 jj_la1[70] = jj_gen; 1772 break label_52; 1773 } 1774 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1775 case DOT: 1776 cond = _class(cond); 1777 break; 1778 case LBRACKET: 1779 cond = attrib(cond); 1780 break; 1781 case COLON: 1782 cond = pseudo(cond); 1783 break; 1784 default: 1785 jj_la1[71] = jj_gen; 1786 jj_consume_token(-1); 1787 throw new ParseException(); 1788 } 1789 } 1790 break; 1791 case DOT: 1792 cond = _class(cond); 1793 label_53: 1794 while (true) { 1795 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1796 case LBRACKET: 1797 case DOT: 1798 case COLON: 1799 case HASH: 1800 ; 1801 break; 1802 default: 1803 jj_la1[72] = jj_gen; 1804 break label_53; 1805 } 1806 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1807 case HASH: 1808 cond = hash(cond); 1809 break; 1810 case DOT: 1811 cond = _class(cond); 1812 break; 1813 case LBRACKET: 1814 cond = attrib(cond); 1815 break; 1816 case COLON: 1817 cond = pseudo(cond); 1818 break; 1819 default: 1820 jj_la1[73] = jj_gen; 1821 jj_consume_token(-1); 1822 throw new ParseException(); 1823 } 1824 } 1825 break; 1826 case COLON: 1827 cond = pseudo(cond); 1828 label_54: 1829 while (true) { 1830 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1831 case LBRACKET: 1832 case DOT: 1833 case COLON: 1834 case HASH: 1835 ; 1836 break; 1837 default: 1838 jj_la1[74] = jj_gen; 1839 break label_54; 1840 } 1841 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1842 case HASH: 1843 cond = hash(cond); 1844 break; 1845 case DOT: 1846 cond = _class(cond); 1847 break; 1848 case LBRACKET: 1849 cond = attrib(cond); 1850 break; 1851 case COLON: 1852 cond = pseudo(cond); 1853 break; 1854 default: 1855 jj_la1[75] = jj_gen; 1856 jj_consume_token(-1); 1857 throw new ParseException(); 1858 } 1859 } 1860 break; 1861 case LBRACKET: 1862 cond = attrib(cond); 1863 label_55: 1864 while (true) { 1865 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1866 case LBRACKET: 1867 case DOT: 1868 case COLON: 1869 case HASH: 1870 ; 1871 break; 1872 default: 1873 jj_la1[76] = jj_gen; 1874 break label_55; 1875 } 1876 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1877 case HASH: 1878 cond = hash(cond); 1879 break; 1880 case DOT: 1881 cond = _class(cond); 1882 break; 1883 case LBRACKET: 1884 cond = attrib(cond); 1885 break; 1886 case COLON: 1887 cond = pseudo(cond); 1888 break; 1889 default: 1890 jj_la1[77] = jj_gen; 1891 jj_consume_token(-1); 1892 throw new ParseException(); 1893 } 1894 } 1895 break; 1896 default: 1897 jj_la1[78] = jj_gen; 1898 jj_consume_token(-1); 1899 throw new ParseException(); 1900 } 1901 if (simple_current == null) { 1902 simple_current = selectorFactory.createElementSelector(null, null); 1903 } 1904 if (cond != null) { 1905 simple_current = selectorFactory.createConditionalSelector(simple_current, 1906 cond); 1907 } 1908 if (selector != null) { 1909 switch (comb) { 1910 case ' ': 1911 selector = selectorFactory.createDescendantSelector(selector, 1912 simple_current); 1913 break; 1914 case '+': 1915 selector = 1916 selectorFactory.createDirectAdjacentSelector((short) 1, 1917 selector, 1918 simple_current); 1919 break; 1920 case '>': 1921 selector = selectorFactory.createChildSelector(selector, 1922 simple_current); 1923 break; 1924 default: 1925 {if (true) throw new ParseException("invalid state. send a bug report");} 1926 } 1927 } else { 1928 selector= simple_current; 1929 } 1930 if (pseudoElt != null) { 1931 selector = selectorFactory.createChildSelector(selector, 1932 selectorFactory.createPseudoElementSelector(null, pseudoElt)); 1933 } 1934 {if (true) return selector;} 1935 throw new Error("Missing return statement in function"); 1936 } 1937 1938/** 1939 * @exception ParseException exception during the parse 1940 */ 1941 final public Condition _class(Condition pred) throws ParseException { 1942 Token n; 1943Condition c; 1944 jj_consume_token(DOT); 1945 n = jj_consume_token(IDENT); 1946 c = conditionFactory.createClassCondition(null, n.image); 1947 if (pred == null) { 1948 {if (true) return c;} 1949 } else { 1950 {if (true) return conditionFactory.createAndCondition(pred, c);} 1951 } 1952 throw new Error("Missing return statement in function"); 1953 } 1954 1955/** 1956 * @exception ParseException exception during the parse 1957 */ 1958 final public SimpleSelector element_name() throws ParseException { 1959 Token n; 1960 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1961 case IDENT: 1962 n = jj_consume_token(IDENT); 1963 {if (true) return selectorFactory.createElementSelector(null, convertIdent(n.image));} 1964 break; 1965 case NAMESPACE_IDENT: 1966 n = jj_consume_token(NAMESPACE_IDENT); 1967 {if (true) return selectorFactory.createElementSelector(null, convertIdent(n.image));} 1968 break; 1969 case ANY: 1970 jj_consume_token(ANY); 1971 {if (true) return selectorFactory.createElementSelector(null, null);} 1972 break; 1973 default: 1974 jj_la1[79] = jj_gen; 1975 jj_consume_token(-1); 1976 throw new ParseException(); 1977 } 1978 throw new Error("Missing return statement in function"); 1979 } 1980 1981/** 1982 * @exception ParseException exception during the parse 1983 */ 1984 final public Condition attrib(Condition pred) throws ParseException { 1985 int cases = 0; 1986 Token att = null; 1987 Token val = null; 1988 String attValue = null; 1989 jj_consume_token(LBRACKET); 1990 label_56: 1991 while (true) { 1992 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1993 case S: 1994 ; 1995 break; 1996 default: 1997 jj_la1[80] = jj_gen; 1998 break label_56; 1999 } 2000 jj_consume_token(S); 2001 } 2002 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2003 case IDENT: 2004 att = jj_consume_token(IDENT); 2005 break; 2006 case NAMESPACE_IDENT: 2007 att = jj_consume_token(NAMESPACE_IDENT); 2008 break; 2009 default: 2010 jj_la1[81] = jj_gen; 2011 jj_consume_token(-1); 2012 throw new ParseException(); 2013 } 2014 label_57: 2015 while (true) { 2016 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2017 case S: 2018 ; 2019 break; 2020 default: 2021 jj_la1[82] = jj_gen; 2022 break label_57; 2023 } 2024 jj_consume_token(S); 2025 } 2026 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2027 case DASHMATCH: 2028 case INCLUDES: 2029 case EQ: 2030 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2031 case EQ: 2032 jj_consume_token(EQ); 2033 cases = 1; 2034 break; 2035 case INCLUDES: 2036 jj_consume_token(INCLUDES); 2037 cases = 2; 2038 break; 2039 case DASHMATCH: 2040 jj_consume_token(DASHMATCH); 2041 cases = 3; 2042 break; 2043 default: 2044 jj_la1[83] = jj_gen; 2045 jj_consume_token(-1); 2046 throw new ParseException(); 2047 } 2048 label_58: 2049 while (true) { 2050 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2051 case S: 2052 ; 2053 break; 2054 default: 2055 jj_la1[84] = jj_gen; 2056 break label_58; 2057 } 2058 jj_consume_token(S); 2059 } 2060 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2061 case IDENT: 2062 val = jj_consume_token(IDENT); 2063 attValue = val.image; 2064 break; 2065 case STRING: 2066 val = jj_consume_token(STRING); 2067 attValue = convertStringIndex(val.image, 1, val.image.length() -1); 2068 break; 2069 default: 2070 jj_la1[85] = jj_gen; 2071 jj_consume_token(-1); 2072 throw new ParseException(); 2073 } 2074 label_59: 2075 while (true) { 2076 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2077 case S: 2078 ; 2079 break; 2080 default: 2081 jj_la1[86] = jj_gen; 2082 break label_59; 2083 } 2084 jj_consume_token(S); 2085 } 2086 break; 2087 default: 2088 jj_la1[87] = jj_gen; 2089 ; 2090 } 2091 jj_consume_token(RBRACKET); 2092 String name = convertIdent(att.image); 2093 Condition c; 2094 switch (cases) { 2095 case 0: 2096 c = conditionFactory.createAttributeCondition(name, null, false, null); 2097 break; 2098 case 1: 2099 c = conditionFactory.createAttributeCondition(name, null, false, 2100 attValue); 2101 break; 2102 case 2: 2103 c = conditionFactory.createOneOfAttributeCondition(name, null, false, 2104 attValue); 2105 break; 2106 case 3: 2107 c = conditionFactory.createBeginHyphenAttributeCondition(name, null, 2108 false, 2109 attValue); 2110 break; 2111 default: 2112 // never reached. 2113 c = null; 2114 } 2115 if (pred == null) { 2116 {if (true) return c;} 2117 } else { 2118 {if (true) return conditionFactory.createAndCondition(pred, c);} 2119 } 2120 throw new Error("Missing return statement in function"); 2121 } 2122 2123/** 2124 * @exception ParseException exception during the parse 2125 */ 2126 final public Condition pseudo(Condition pred) throws ParseException { 2127 Token n; 2128Token language; 2129 jj_consume_token(COLON); 2130 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2131 case IDENT: 2132 n = jj_consume_token(IDENT); 2133 String s = convertIdent(n.image); 2134 if (s.equals("first-letter") || s.equals("first-line")) { 2135 if (pseudoElt != null) { 2136 {if (true) throw new CSSParseException("duplicate pseudo element definition " 2137 + s, getLocator());} 2138 } else { 2139 pseudoElt = s; 2140 {if (true) return pred;} 2141 } 2142 } else { 2143 Condition c = 2144 conditionFactory.createPseudoClassCondition(null, s); 2145 if (pred == null) { 2146 {if (true) return c;} 2147 } else { 2148 {if (true) return conditionFactory.createAndCondition(pred, c);} 2149 } 2150 } 2151 break; 2152 case FUNCTION: 2153 n = jj_consume_token(FUNCTION); 2154 label_60: 2155 while (true) { 2156 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2157 case S: 2158 ; 2159 break; 2160 default: 2161 jj_la1[88] = jj_gen; 2162 break label_60; 2163 } 2164 jj_consume_token(S); 2165 } 2166 language = jj_consume_token(IDENT); 2167 label_61: 2168 while (true) { 2169 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2170 case S: 2171 ; 2172 break; 2173 default: 2174 jj_la1[89] = jj_gen; 2175 break label_61; 2176 } 2177 jj_consume_token(S); 2178 } 2179 jj_consume_token(LPARAN); 2180 String f = convertIdent(n.image); 2181 if (f.equals("lang(")) { 2182 Condition d = 2183 conditionFactory.createLangCondition(convertIdent(language.image)); 2184 if (pred == null) { 2185 {if (true) return d;} 2186 } else { 2187 {if (true) return conditionFactory.createAndCondition(pred, d);} 2188 } 2189 } else { 2190 {if (true) throw new CSSParseException("invalid pseudo function name " 2191 + f, getLocator());} 2192 } 2193 break; 2194 default: 2195 jj_la1[90] = jj_gen; 2196 jj_consume_token(-1); 2197 throw new ParseException(); 2198 } 2199 throw new Error("Missing return statement in function"); 2200 } 2201 2202/** 2203 * @exception ParseException exception during the parse 2204 */ 2205 final public Condition hash(Condition pred) throws ParseException { 2206 Token n; 2207 n = jj_consume_token(HASH); 2208 Condition d = 2209 conditionFactory.createIdCondition(n.image.substring(1)); 2210 if (pred == null) { 2211 {if (true) return d;} 2212 } else { 2213 {if (true) return conditionFactory.createAndCondition(pred, d);} 2214 } 2215 throw new Error("Missing return statement in function"); 2216 } 2217 2218/** 2219 * @exception ParseException exception during the parse 2220 */ 2221 final public void declaration() throws ParseException { 2222 boolean important = false; 2223 String name; 2224 LexicalUnit exp; 2225 Token save; 2226 try { 2227 name = property(); 2228 save = token; 2229 jj_consume_token(COLON); 2230 label_62: 2231 while (true) { 2232 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2233 case S: 2234 ; 2235 break; 2236 default: 2237 jj_la1[91] = jj_gen; 2238 break label_62; 2239 } 2240 jj_consume_token(S); 2241 } 2242 exp = expr(); 2243 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2244 case IMPORTANT_SYM: 2245 important = prio(); 2246 break; 2247 default: 2248 jj_la1[92] = jj_gen; 2249 ; 2250 } 2251 documentHandler.property(name, exp, important); 2252 } catch (JumpException e) { 2253 skipAfterExpression(); 2254 // reportWarningSkipText(getLocator(), skipAfterExpression()); 2255 2256 } catch (NumberFormatException e) { 2257 if (errorHandler != null) { 2258 errorHandler.error(new CSSParseException("Invalid number " 2259 + e.getMessage(), 2260 getLocator(), 2261 e)); 2262 } 2263 reportWarningSkipText(getLocator(), skipAfterExpression()); 2264 } catch (ParseException e) { 2265 if (errorHandler != null) { 2266 if (e.currentToken != null) { 2267 LocatorImpl li = new LocatorImpl(this, 2268 e.currentToken.next.beginLine, 2269 e.currentToken.next.beginColumn-1); 2270 reportError(li, e); 2271 } else { 2272 reportError(getLocator(), e); 2273 } 2274 skipAfterExpression(); 2275 /* 2276 LocatorImpl loc = (LocatorImpl) getLocator(); 2277 loc.column--; 2278 reportWarningSkipText(loc, skipAfterExpression()); 2279 */ 2280 } else { 2281 skipAfterExpression(); 2282 } 2283 } 2284 } 2285 2286/** 2287 * @exception ParseException exception during the parse 2288 */ 2289 final public boolean prio() throws ParseException { 2290 jj_consume_token(IMPORTANT_SYM); 2291 label_63: 2292 while (true) { 2293 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2294 case S: 2295 ; 2296 break; 2297 default: 2298 jj_la1[93] = jj_gen; 2299 break label_63; 2300 } 2301 jj_consume_token(S); 2302 } 2303 {if (true) return true;} 2304 throw new Error("Missing return statement in function"); 2305 } 2306 2307/** 2308 * @exception ParseException exception during the parse 2309 */ 2310 final public LexicalUnitImpl operator(LexicalUnitImpl prev) throws ParseException { 2311 Token n; 2312 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2313 case DIV: 2314 n = jj_consume_token(DIV); 2315 label_64: 2316 while (true) { 2317 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2318 case S: 2319 ; 2320 break; 2321 default: 2322 jj_la1[94] = jj_gen; 2323 break label_64; 2324 } 2325 jj_consume_token(S); 2326 } 2327 {if (true) return LexicalUnitImpl.createSlash(n.beginLine, 2328 n.beginColumn, 2329 prev);} 2330 break; 2331 case COMMA: 2332 n = jj_consume_token(COMMA); 2333 label_65: 2334 while (true) { 2335 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2336 case S: 2337 ; 2338 break; 2339 default: 2340 jj_la1[95] = jj_gen; 2341 break label_65; 2342 } 2343 jj_consume_token(S); 2344 } 2345 {if (true) return LexicalUnitImpl.createComma(n.beginLine, 2346 n.beginColumn, 2347 prev);} 2348 break; 2349 default: 2350 jj_la1[96] = jj_gen; 2351 jj_consume_token(-1); 2352 throw new ParseException(); 2353 } 2354 throw new Error("Missing return statement in function"); 2355 } 2356 2357/** 2358 * @exception ParseException exception during the parse 2359 */ 2360 final public LexicalUnit expr() throws ParseException { 2361 LexicalUnitImpl first, res; 2362 char op; 2363 first = term(null); 2364 res = first; 2365 label_66: 2366 while (true) { 2367 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2368 case PLUS: 2369 case MINUS: 2370 case COMMA: 2371 case DIV: 2372 case STRING: 2373 case IDENT: 2374 case NUMBER: 2375 case URL: 2376 case NAMESPACE_IDENT: 2377 case PERCENTAGE: 2378 case PT: 2379 case MM: 2380 case CM: 2381 case PC: 2382 case IN: 2383 case PX: 2384 case EMS: 2385 case EXS: 2386 case DEG: 2387 case RAD: 2388 case GRAD: 2389 case MS: 2390 case SECOND: 2391 case HZ: 2392 case KHZ: 2393 case DIMEN: 2394 case HASH: 2395 case UNICODERANGE: 2396 case FUNCTION: 2397 ; 2398 break; 2399 default: 2400 jj_la1[97] = jj_gen; 2401 break label_66; 2402 } 2403 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2404 case COMMA: 2405 case DIV: 2406 res = operator(res); 2407 break; 2408 default: 2409 jj_la1[98] = jj_gen; 2410 ; 2411 } 2412 res = term(res); 2413 } 2414 {if (true) return first;} 2415 throw new Error("Missing return statement in function"); 2416 } 2417 2418/** 2419 * @exception ParseException exception during the parse 2420 */ 2421 final public char unaryOperator() throws ParseException { 2422 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2423 case MINUS: 2424 jj_consume_token(MINUS); 2425 {if (true) return '-';} 2426 break; 2427 case PLUS: 2428 jj_consume_token(PLUS); 2429 {if (true) return '+';} 2430 break; 2431 default: 2432 jj_la1[99] = jj_gen; 2433 jj_consume_token(-1); 2434 throw new ParseException(); 2435 } 2436 throw new Error("Missing return statement in function"); 2437 } 2438 2439/** 2440 * @exception ParseException exception during the parse 2441 */ 2442 final public LexicalUnitImpl term(LexicalUnitImpl prev) throws ParseException { 2443 LexicalUnitImpl result = null; 2444 Token n = null; 2445 char op = ' '; 2446 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2447 case PLUS: 2448 case MINUS: 2449 case NUMBER: 2450 case PERCENTAGE: 2451 case PT: 2452 case MM: 2453 case CM: 2454 case PC: 2455 case IN: 2456 case PX: 2457 case EMS: 2458 case EXS: 2459 case DEG: 2460 case RAD: 2461 case GRAD: 2462 case MS: 2463 case SECOND: 2464 case HZ: 2465 case KHZ: 2466 case DIMEN: 2467 case FUNCTION: 2468 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2469 case PLUS: 2470 case MINUS: 2471 op = unaryOperator(); 2472 break; 2473 default: 2474 jj_la1[100] = jj_gen; 2475 ; 2476 } 2477 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2478 case NUMBER: 2479 n = jj_consume_token(NUMBER); 2480 result = LexicalUnitImpl.createNumber(n.beginLine, n.beginColumn, 2481 prev, number(op, n, 0)); 2482 break; 2483 case PERCENTAGE: 2484 n = jj_consume_token(PERCENTAGE); 2485 result = LexicalUnitImpl.createPercentage(n.beginLine, n.beginColumn, 2486 prev, number(op, n, 1)); 2487 break; 2488 case PT: 2489 n = jj_consume_token(PT); 2490 result = LexicalUnitImpl.createPT(n.beginLine, n.beginColumn, 2491 prev, number(op, n, 2)); 2492 break; 2493 case CM: 2494 n = jj_consume_token(CM); 2495 result = LexicalUnitImpl.createCM(n.beginLine, n.beginColumn, 2496 prev, number(op, n, 2)); 2497 break; 2498 case MM: 2499 n = jj_consume_token(MM); 2500 result = LexicalUnitImpl.createMM(n.beginLine, n.beginColumn, 2501 prev, number(op, n, 2)); 2502 break; 2503 case PC: 2504 n = jj_consume_token(PC); 2505 result = LexicalUnitImpl.createPC(n.beginLine, n.beginColumn, 2506 prev, number(op, n, 2)); 2507 break; 2508 case IN: 2509 n = jj_consume_token(IN); 2510 result = LexicalUnitImpl.createIN(n.beginLine, n.beginColumn, 2511 prev, number(op, n, 2)); 2512 break; 2513 case PX: 2514 n = jj_consume_token(PX); 2515 result = LexicalUnitImpl.createPX(n.beginLine, n.beginColumn, 2516 prev, number(op, n, 2)); 2517 break; 2518 case EMS: 2519 n = jj_consume_token(EMS); 2520 result = LexicalUnitImpl.createEMS(n.beginLine, n.beginColumn, 2521 prev, number(op, n, 2)); 2522 break; 2523 case EXS: 2524 n = jj_consume_token(EXS); 2525 result = LexicalUnitImpl.createEXS(n.beginLine, n.beginColumn, 2526 prev, number(op, n, 2)); 2527 break; 2528 case DEG: 2529 n = jj_consume_token(DEG); 2530 result = LexicalUnitImpl.createDEG(n.beginLine, n.beginColumn, 2531 prev, number(op, n, 3)); 2532 break; 2533 case RAD: 2534 n = jj_consume_token(RAD); 2535 result = LexicalUnitImpl.createRAD(n.beginLine, n.beginColumn, 2536 prev, number(op, n, 3)); 2537 break; 2538 case GRAD: 2539 n = jj_consume_token(GRAD); 2540 result = LexicalUnitImpl.createGRAD(n.beginLine, n.beginColumn, 2541 prev, number(op, n, 3)); 2542 break; 2543 case SECOND: 2544 n = jj_consume_token(SECOND); 2545 result = LexicalUnitImpl.createS(n.beginLine, n.beginColumn, 2546 prev, number(op, n, 1)); 2547 break; 2548 case MS: 2549 n = jj_consume_token(MS); 2550 result = LexicalUnitImpl.createMS(n.beginLine, n.beginColumn, 2551 prev, number(op, n, 2)); 2552 break; 2553 case HZ: 2554 n = jj_consume_token(HZ); 2555 result = LexicalUnitImpl.createHZ(n.beginLine, n.beginColumn, 2556 prev, number(op, n, 2)); 2557 break; 2558 case KHZ: 2559 n = jj_consume_token(KHZ); 2560 result = LexicalUnitImpl.createKHZ(n.beginLine, n.beginColumn, 2561 prev, number(op, n, 3)); 2562 break; 2563 case DIMEN: 2564 n = jj_consume_token(DIMEN); 2565 String s = n.image; 2566 int i = 0; 2567 while (i < s.length() 2568 && (Character.isDigit(s.charAt(i)) || (s.charAt(i) == '.'))) { 2569 i++; 2570 } 2571 result = LexicalUnitImpl.createDimen(n.beginLine, n.beginColumn, prev, 2572 Float.valueOf(s.substring(0, i)).floatValue(), 2573 s.substring(i)); 2574 break; 2575 case FUNCTION: 2576 result = function(op, prev); 2577 break; 2578 default: 2579 jj_la1[101] = jj_gen; 2580 jj_consume_token(-1); 2581 throw new ParseException(); 2582 } 2583 break; 2584 case STRING: 2585 case IDENT: 2586 case URL: 2587 case NAMESPACE_IDENT: 2588 case HASH: 2589 case UNICODERANGE: 2590 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2591 case STRING: 2592 n = jj_consume_token(STRING); 2593 result = LexicalUnitImpl.createString 2594 (n.beginLine, n.beginColumn, prev, 2595 convertStringIndex(n.image, 1, 2596 n.image.length() -1)); 2597 break; 2598 case NAMESPACE_IDENT: 2599 n = jj_consume_token(NAMESPACE_IDENT); 2600 result = LexicalUnitImpl.createIdent 2601 (n.beginLine, n.beginColumn, prev, convertIdent(n.image)); 2602 break; 2603 case IDENT: 2604 n = jj_consume_token(IDENT); 2605 String s = convertIdent(n.image); 2606 if ("inherit".equals(s)) 2607 { 2608 result = LexicalUnitImpl.createInherit 2609 (n.beginLine, n.beginColumn, prev); 2610 } 2611 else 2612 { 2613 result = LexicalUnitImpl.createIdent 2614 (n.beginLine, n.beginColumn, prev, s); 2615 } 2616 2617 /* / 2618 Auto correction code used in the CSS Validator but must not 2619 be used by a conformant CSS2 parser. 2620 * Common error : 2621 * H1 { 2622 * color : black 2623 * background : white 2624 * } 2625 * 2626 Token t = getToken(1); 2627 Token semicolon = new Token(); 2628 semicolon.kind = SEMICOLON; 2629 semicolon.image = ";"; 2630 if (t.kind == COLON) { 2631 // @@SEEME. (generate a warning?) 2632 // @@SEEME if expression is a single ident, 2633 generate an error ? 2634 rejectToken(semicolon); 2635 2636 result = prev; 2637 } 2638 / */ 2639 2640 break; 2641 case HASH: 2642 result = hexcolor(prev); 2643 break; 2644 case URL: 2645 result = url(prev); 2646 break; 2647 case UNICODERANGE: 2648 result = unicode(prev); 2649 break; 2650 default: 2651 jj_la1[102] = jj_gen; 2652 jj_consume_token(-1); 2653 throw new ParseException(); 2654 } 2655 break; 2656 default: 2657 jj_la1[103] = jj_gen; 2658 jj_consume_token(-1); 2659 throw new ParseException(); 2660 } 2661 label_67: 2662 while (true) { 2663 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2664 case S: 2665 ; 2666 break; 2667 default: 2668 jj_la1[104] = jj_gen; 2669 break label_67; 2670 } 2671 jj_consume_token(S); 2672 } 2673 {if (true) return result;} 2674 throw new Error("Missing return statement in function"); 2675 } 2676 2677/** 2678 * Handle all CSS2 functions. 2679 * @exception ParseException exception during the parse 2680 */ 2681 final public LexicalUnitImpl function(char operator, LexicalUnitImpl prev) throws ParseException { 2682 Token n; 2683 LexicalUnit params = null; 2684 n = jj_consume_token(FUNCTION); 2685 label_68: 2686 while (true) { 2687 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2688 case S: 2689 ; 2690 break; 2691 default: 2692 jj_la1[105] = jj_gen; 2693 break label_68; 2694 } 2695 jj_consume_token(S); 2696 } 2697 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2698 case PLUS: 2699 case MINUS: 2700 case STRING: 2701 case IDENT: 2702 case NUMBER: 2703 case URL: 2704 case NAMESPACE_IDENT: 2705 case PERCENTAGE: 2706 case PT: 2707 case MM: 2708 case CM: 2709 case PC: 2710 case IN: 2711 case PX: 2712 case EMS: 2713 case EXS: 2714 case DEG: 2715 case RAD: 2716 case GRAD: 2717 case MS: 2718 case SECOND: 2719 case HZ: 2720 case KHZ: 2721 case DIMEN: 2722 case HASH: 2723 case UNICODERANGE: 2724 case FUNCTION: 2725 params = expr(); 2726 break; 2727 default: 2728 jj_la1[106] = jj_gen; 2729 ; 2730 } 2731 jj_consume_token(LPARAN); 2732 if (operator != ' ') { 2733 {if (true) throw new CSSParseException("invalid operator before a function.", 2734 getLocator());} 2735 } 2736 String f = convertIdent(n.image); 2737 LexicalUnitImpl l = (LexicalUnitImpl) params; 2738 boolean loop = true; 2739 if ("rgb(".equals(f)) { 2740 // this is a RGB declaration (e.g. rgb(255, 50%, 0) ) 2741 int i = 0; 2742 while (loop && l != null && i < 5) { 2743 switch (i) { 2744 case 0: 2745 case 2: 2746 case 4: 2747 if ((l.getLexicalUnitType() != LexicalUnit.SAC_INTEGER) 2748 && (l.getLexicalUnitType() != LexicalUnit.SAC_PERCENTAGE)) { 2749 loop = false; 2750 } 2751 break; 2752 case 1: 2753 case 3: 2754 if (l.getLexicalUnitType() != LexicalUnit.SAC_OPERATOR_COMMA) { 2755 loop = false; 2756 } 2757 break; 2758 default: 2759 {if (true) throw new ParseException("implementation error");} 2760 } 2761 if (loop) { 2762 l = (LexicalUnitImpl) l.getNextLexicalUnit(); 2763 i ++; 2764 } 2765 } 2766 if ((i == 5) && loop && (l == null)) { 2767 {if (true) return LexicalUnitImpl.createRGBColor(n.beginLine, 2768 n.beginColumn, 2769 prev, params);} 2770 } else { 2771 if (errorHandler != null) { 2772 String errorText; 2773 Locator loc; 2774 if (i < 5) { 2775 if (params == null) { 2776 loc = new LocatorImpl(this, n.beginLine, 2777 n.beginColumn-1); 2778 errorText = "not enough parameters."; 2779 } else if (l == null) { 2780 loc = new LocatorImpl(this, n.beginLine, 2781 n.beginColumn-1); 2782 errorText = "not enough parameters: " 2783 + params.toString(); 2784 } else { 2785 loc = new LocatorImpl(this, l.getLineNumber(), 2786 l.getColumnNumber()); 2787 errorText = "invalid parameter: " 2788 + l.toString(); 2789 } 2790 } else { 2791 loc = new LocatorImpl(this, l.getLineNumber(), 2792 l.getColumnNumber()); 2793 errorText = "too many parameters: " 2794 + l.toString(); 2795 } 2796 errorHandler.error(new CSSParseException(errorText, loc)); 2797 } 2798 2799 {if (true) throw new JumpException();} 2800 } 2801 } else if ("counter".equals(f)) { 2802 int i = 0; 2803 while (loop && l != null && i < 3) { 2804 switch (i) { 2805 case 0: 2806 case 2: 2807 if (l.getLexicalUnitType() != LexicalUnit.SAC_IDENT) { 2808 loop = false; 2809 } 2810 break; 2811 case 1: 2812 if (l.getLexicalUnitType() != LexicalUnit.SAC_OPERATOR_COMMA) { 2813 loop = false; 2814 } 2815 break; 2816 default: 2817 {if (true) throw new ParseException("implementation error");} 2818 } 2819 l = (LexicalUnitImpl) l.getNextLexicalUnit(); 2820 i ++; 2821 } 2822 if (((i == 1) || (i == 3)) && loop && (l == null)) { 2823 {if (true) return LexicalUnitImpl.createCounter(n.beginLine, n.beginColumn, 2824 prev, params);} 2825 } 2826 2827 } else if ("counters(".equals(f)) { 2828 2829 int i = 0; 2830 while (loop && l != null && i < 5) { 2831 switch (i) { 2832 case 0: 2833 case 4: 2834 if (l.getLexicalUnitType() != LexicalUnit.SAC_IDENT) { 2835 loop = false; 2836 } 2837 break; 2838 case 2: 2839 if (l.getLexicalUnitType() != LexicalUnit.SAC_STRING_VALUE) { 2840 loop = false; 2841 } 2842 break; 2843 case 1: 2844 case 3: 2845 if (l.getLexicalUnitType() != LexicalUnit.SAC_OPERATOR_COMMA) { 2846 loop = false; 2847 } 2848 break; 2849 default: 2850 {if (true) throw new ParseException("implementation error");} 2851 } 2852 l = (LexicalUnitImpl) l.getNextLexicalUnit(); 2853 i ++; 2854 } 2855 if (((i == 3) || (i == 5)) && loop && (l == null)) { 2856 {if (true) return LexicalUnitImpl.createCounters(n.beginLine, n.beginColumn, 2857 prev, params);} 2858 } 2859 } else if ("attr(".equals(f)) { 2860 if ((l != null) 2861 && (l.getNextLexicalUnit() == null) 2862 && (l.getLexicalUnitType() == LexicalUnit.SAC_IDENT)) { 2863 {if (true) return LexicalUnitImpl.createAttr(l.getLineNumber(), 2864 l.getColumnNumber(), 2865 prev, l.getStringValue());} 2866 } 2867 } else if ("rect(".equals(f)) { 2868 int i = 0; 2869 while (loop && l != null && i < 7) { 2870 switch (i) { 2871 case 0: 2872 case 2: 2873 case 4: 2874 case 6: 2875 switch (l.getLexicalUnitType()) { 2876 case LexicalUnit.SAC_INTEGER: 2877 if (l.getIntegerValue() != 0) { 2878 loop = false; 2879 } 2880 break; 2881 case LexicalUnit.SAC_IDENT: 2882 if (!l.getStringValue().equals("auto")) { 2883 loop = false; 2884 } 2885 break; 2886 case LexicalUnit.SAC_EM: 2887 case LexicalUnit.SAC_EX: 2888 case LexicalUnit.SAC_PIXEL: 2889 case LexicalUnit.SAC_CENTIMETER: 2890 case LexicalUnit.SAC_MILLIMETER: 2891 case LexicalUnit.SAC_INCH: 2892 case LexicalUnit.SAC_POINT: 2893 case LexicalUnit.SAC_PICA: 2894 // nothing 2895 break; 2896 default: 2897 loop = false; 2898 } 2899 break; 2900 case 1: 2901 case 3: 2902 case 5: 2903 if (l.getLexicalUnitType() != LexicalUnit.SAC_OPERATOR_COMMA) { 2904 loop = false; 2905 } 2906 break; 2907 default: 2908 {if (true) throw new ParseException("implementation error");} 2909 } 2910 l = (LexicalUnitImpl) l.getNextLexicalUnit(); 2911 i ++; 2912 } 2913 if ((i == 7) && loop && (l == null)) { 2914 {if (true) return LexicalUnitImpl.createRect(n.beginLine, n.beginColumn, 2915 prev, params);} 2916 } 2917 } 2918 {if (true) return LexicalUnitImpl.createFunction(n.beginLine, n.beginColumn, prev, 2919 f.substring(0, 2920 f.length() -1), 2921 params);} 2922 throw new Error("Missing return statement in function"); 2923 } 2924 2925 final public LexicalUnitImpl unicode(LexicalUnitImpl prev) throws ParseException { 2926 Token n; 2927 n = jj_consume_token(UNICODERANGE); 2928 LexicalUnitImpl params = null; 2929 String s = n.image.substring(2); 2930 int index = s.indexOf('-'); 2931 if (index == -1) { 2932 params = LexicalUnitImpl.createInteger(n.beginLine, n.beginColumn, 2933 params, Integer.parseInt(s, 16)); 2934 } else { 2935 String s1 = s.substring(0, index); 2936 String s2 = s.substring(index); 2937 2938 params = LexicalUnitImpl.createInteger(n.beginLine, n.beginColumn, 2939 params, Integer.parseInt(s1, 16)); 2940 params = LexicalUnitImpl.createInteger(n.beginLine, n.beginColumn, 2941 params, Integer.parseInt(s2, 16)); 2942 } 2943 2944 {if (true) return LexicalUnitImpl.createUnicodeRange(n.beginLine, n.beginColumn, 2945 prev, params);} 2946 throw new Error("Missing return statement in function"); 2947 } 2948 2949 final public LexicalUnitImpl url(LexicalUnitImpl prev) throws ParseException { 2950 Token n; 2951 n = jj_consume_token(URL); 2952 String urlname = n.image.substring(4, n.image.length()-1).trim(); 2953 if (urlname.charAt(0) == '"' 2954 || urlname.charAt(0) == '\u005c'') { 2955 urlname = urlname.substring(1, urlname.length()-1); 2956 } 2957 {if (true) return LexicalUnitImpl.createURL(n.beginLine, n.beginColumn, prev, urlname);} 2958 throw new Error("Missing return statement in function"); 2959 } 2960 2961/** 2962 * @exception ParseException exception during the parse 2963 */ 2964 final public LexicalUnitImpl hexcolor(LexicalUnitImpl prev) throws ParseException { 2965 Token n; 2966 n = jj_consume_token(HASH); 2967 int r; 2968 LexicalUnitImpl first, params = null; 2969 String s = n.image.substring(1); 2970 2971 if (s.length() == 3) { 2972 String sh = s.substring(0,1); 2973 r = Integer.parseInt(sh+sh, 16); 2974 first = params = LexicalUnitImpl.createInteger(n.beginLine, n.beginColumn, 2975 params, r); 2976 params = LexicalUnitImpl.createComma(n.beginLine, n.beginColumn, 2977 params); 2978 sh = s.substring(1,2); 2979 r = Integer.parseInt(sh+sh, 16); 2980 params = LexicalUnitImpl.createInteger(n.beginLine, n.beginColumn, 2981 params, r); 2982 params = LexicalUnitImpl.createComma(n.beginLine, n.beginColumn, 2983 params); 2984 sh = s.substring(2,3); 2985 r = Integer.parseInt(sh+sh, 16); 2986 params = LexicalUnitImpl.createInteger(n.beginLine, n.beginColumn, 2987 params, r); 2988 } else if (s.length() == 6) { 2989 r = Integer.parseInt(s.substring(0,2), 16); 2990 first = params = LexicalUnitImpl.createInteger(n.beginLine, 2991 n.beginColumn, 2992 params, r); 2993 params = LexicalUnitImpl.createComma(n.beginLine, n.beginColumn, 2994 params); 2995 r = Integer.parseInt(s.substring(2,4), 16); 2996 params = LexicalUnitImpl.createInteger(n.beginLine, n.beginColumn, 2997 params, r); 2998 params = LexicalUnitImpl.createComma(n.beginLine, n.beginColumn, 2999 params); 3000 r = Integer.parseInt(s.substring(4,6), 16); 3001 params = LexicalUnitImpl.createInteger(n.beginLine, n.beginColumn, 3002 params, r); 3003 } else { 3004 first = null; 3005 {if (true) throw new CSSParseException("invalid hexadecimal notation for RGB: " + s, 3006 getLocator());} 3007 } 3008 {if (true) return LexicalUnitImpl.createRGBColor(n.beginLine, n.beginColumn, 3009 prev, first);} 3010 throw new Error("Missing return statement in function"); 3011 } 3012 3013 float number(char operator, Token n, int lengthUnit) throws ParseException { 3014 String image = n.image; 3015 float f = 0; 3016 3017 if (lengthUnit != 0) { 3018 image = image.substring(0, image.length() - lengthUnit); 3019 } 3020 f = Float.valueOf(image).floatValue(); 3021 return (operator == '-')? -f: f; 3022 } 3023 3024 String skipStatementNoSemicolon() throws ParseException { 3025 StringBuffer s = new StringBuffer(); 3026 Token tok = getToken(0); 3027 if (tok.image != null) { 3028 s.append(tok.image); 3029 } 3030 while (true) { 3031 tok = getToken(1); 3032 if (tok.kind == EOF) { 3033 return null; 3034 } 3035 s.append(tok.image); 3036 if (tok.kind == LBRACE) { 3037 getNextToken(); 3038 s.append(skip_to_matching_brace()); 3039 getNextToken(); 3040 tok = getToken(1); 3041 break; 3042 } 3043 getNextToken(); 3044 } 3045 3046 // skip white space 3047 while (true) { 3048 if (tok.kind != S) { 3049 break; 3050 } 3051 tok = getNextToken(); 3052 tok = getToken(1); 3053 } 3054 3055 return s.toString().trim(); 3056 } 3057 3058 String skipStatement() throws ParseException { 3059 StringBuffer s = new StringBuffer(); 3060 Token tok = getToken(0); 3061 if (tok.image != null) { 3062 s.append(tok.image); 3063 } 3064 while (true) { 3065 tok = getToken(1); 3066 if (tok.kind == EOF) { 3067 return null; 3068 } 3069 s.append(tok.image); 3070 if (tok.kind == LBRACE) { 3071 getNextToken(); 3072 s.append(skip_to_matching_brace()); 3073 getNextToken(); 3074 tok = getToken(1); 3075 break; 3076 } else if (tok.kind == RBRACE) { 3077 getNextToken(); 3078 tok = getToken(1); 3079 break; 3080 } else if (tok.kind == SEMICOLON) { 3081 getNextToken(); 3082 tok = getToken(1); 3083 break; 3084 } 3085 getNextToken(); 3086 } 3087 3088 // skip white space 3089 while (true) { 3090 if (tok.kind != S) { 3091 break; 3092 } 3093 tok = getNextToken(); 3094 tok = getToken(1); 3095 } 3096 3097 return s.toString().trim(); 3098 } 3099 3100 String skip_to_matching_brace() throws ParseException { 3101 StringBuffer s = new StringBuffer(); 3102 Token tok; 3103 int nesting = 1; 3104 while (true) { 3105 tok = getToken(1); 3106 if (tok.kind == EOF) { 3107 break; 3108 } 3109 s.append(tok.image); 3110 if (tok.kind == LBRACE) { 3111 nesting++; 3112 } else if (tok.kind == RBRACE) { 3113 nesting--; 3114 if (nesting == 0) { 3115 break; 3116 } 3117 } 3118 getNextToken(); 3119 } 3120 return s.toString(); 3121 } 3122 3123 String convertStringIndex(String s, int start, int len) throws ParseException { 3124 StringBuffer buf = new StringBuffer(len); 3125 int index = start; 3126 3127 while (index < len) { 3128 char c = s.charAt(index); 3129 if (c == '\u005c\u005c') { 3130 if (++index < len) { 3131 c = s.charAt(index); 3132 switch (c) { 3133 case '0': case '1': case '2': case '3': case '4': 3134 case '5': case '6': case '7': case '8': case '9': 3135 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': 3136 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': 3137 int numValue = Character.digit(c, 16); 3138 int count = 0; 3139 int p = 16; 3140 3141 while (index + 1 < len && count < 6) { 3142 c = s.charAt(index+1); 3143 3144 if (Character.digit(c, 16) != -1) { 3145 numValue = (numValue * 16) + Character.digit(c, 16); 3146 p *= 16; 3147 index++; 3148 } else { 3149 if (c == ' ') { 3150 // skip the latest white space 3151 index++; 3152 } 3153 break; 3154 } 3155 } 3156 buf.append((char) numValue); 3157 break; 3158 case '\u005cn': 3159 case '\u005cf': 3160 break; 3161 case '\u005cr': 3162 if (index + 1 < len) { 3163 if (s.charAt(index + 1) == '\u005cn') { 3164 index ++; 3165 } 3166 } 3167 break; 3168 default: 3169 buf.append(c); 3170 } 3171 } else { 3172 throw new CSSParseException("invalid string " + s, getLocator()); 3173 } 3174 } else { 3175 buf.append(c); 3176 } 3177 index++; 3178 } 3179 3180 return buf.toString(); 3181 } 3182 3183 String convertIdent(String s) throws ParseException { 3184 return convertStringIndex(s, 0, s.length()); 3185 } 3186 3187 String convertString(String s) throws ParseException { 3188 return convertStringIndex(s, 0, s.length()); 3189 } 3190 3191 void rejectToken(Token t) throws ParseException { 3192 Token fakeToken = new Token(); 3193 t.next = token; 3194 fakeToken.next = t; 3195 token = fakeToken; 3196 } 3197 3198 String skipAfterExpression() throws ParseException { 3199 Token t = getToken(1); 3200 StringBuffer s = new StringBuffer(); 3201 s.append(getToken(0).image); 3202 3203 while ((t.kind != RBRACE) && (t.kind != SEMICOLON) && (t.kind != EOF)) { 3204 s.append(t.image); 3205 getNextToken(); 3206 t = getToken(1); 3207 } 3208 3209 return s.toString(); 3210 } 3211 3212/** 3213 * The following functions are useful for a DOM CSS implementation only and are 3214 * not part of the general CSS2 parser. 3215 */ 3216 final public void _parseRule() throws ParseException { 3217 String ret = null; 3218 label_69: 3219 while (true) { 3220 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 3221 case S: 3222 ; 3223 break; 3224 default: 3225 jj_la1[107] = jj_gen; 3226 break label_69; 3227 } 3228 jj_consume_token(S); 3229 } 3230 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 3231 case IMPORT_SYM: 3232 importDeclaration(); 3233 break; 3234 case LBRACKET: 3235 case ANY: 3236 case DOT: 3237 case COLON: 3238 case IDENT: 3239 case NAMESPACE_IDENT: 3240 case HASH: 3241 styleRule(); 3242 break; 3243 case MEDIA_SYM: 3244 media(); 3245 break; 3246 case PAGE_SYM: 3247 page(); 3248 break; 3249 case FONT_FACE_SYM: 3250 fontFace(); 3251 break; 3252 default: 3253 jj_la1[108] = jj_gen; 3254 ret = skipStatement(); 3255 if ((ret == null) || (ret.length() == 0)) { 3256 {if (true) return;} 3257 } 3258 if (ret.charAt(0) == '@') { 3259 documentHandler.ignorableAtRule(ret); 3260 } else { 3261 {if (true) throw new CSSParseException("unrecognize rule: " + ret, 3262 getLocator());} 3263 } 3264 } 3265 } 3266 3267 final public void _parseImportRule() throws ParseException { 3268 label_70: 3269 while (true) { 3270 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 3271 case S: 3272 ; 3273 break; 3274 default: 3275 jj_la1[109] = jj_gen; 3276 break label_70; 3277 } 3278 jj_consume_token(S); 3279 } 3280 importDeclaration(); 3281 } 3282 3283 final public void _parseMediaRule() throws ParseException { 3284 label_71: 3285 while (true) { 3286 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 3287 case S: 3288 ; 3289 break; 3290 default: 3291 jj_la1[110] = jj_gen; 3292 break label_71; 3293 } 3294 jj_consume_token(S); 3295 } 3296 media(); 3297 } 3298 3299 final public void _parseDeclarationBlock() throws ParseException { 3300 label_72: 3301 while (true) { 3302 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 3303 case S: 3304 ; 3305 break; 3306 default: 3307 jj_la1[111] = jj_gen; 3308 break label_72; 3309 } 3310 jj_consume_token(S); 3311 } 3312 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 3313 case IDENT: 3314 declaration(); 3315 break; 3316 default: 3317 jj_la1[112] = jj_gen; 3318 ; 3319 } 3320 label_73: 3321 while (true) { 3322 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 3323 case SEMICOLON: 3324 ; 3325 break; 3326 default: 3327 jj_la1[113] = jj_gen; 3328 break label_73; 3329 } 3330 jj_consume_token(SEMICOLON); 3331 label_74: 3332 while (true) { 3333 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 3334 case S: 3335 ; 3336 break; 3337 default: 3338 jj_la1[114] = jj_gen; 3339 break label_74; 3340 } 3341 jj_consume_token(S); 3342 } 3343 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 3344 case IDENT: 3345 declaration(); 3346 break; 3347 default: 3348 jj_la1[115] = jj_gen; 3349 ; 3350 } 3351 } 3352 } 3353 3354 final public SelectorList _parseSelectors() throws ParseException { 3355 SelectorList p = null; 3356 try { 3357 label_75: 3358 while (true) { 3359 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 3360 case S: 3361 ; 3362 break; 3363 default: 3364 jj_la1[116] = jj_gen; 3365 break label_75; 3366 } 3367 jj_consume_token(S); 3368 } 3369 p = selectorList(); 3370 {if (true) return p;} 3371 } catch (ThrowedParseException e) { 3372 {if (true) throw (ParseException) e.e;}//.fillInStackTrace(); 3373 3374 } 3375 throw new Error("Missing return statement in function"); 3376 } 3377 3378 final public String _parseNamespaceToken() throws ParseException { 3379 Token retval = null; 3380 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 3381 case NAMESPACE_IDENT: 3382 retval = jj_consume_token(NAMESPACE_IDENT); 3383 {if (true) return retval.image;} 3384 break; 3385 case IDENT: 3386 retval = jj_consume_token(IDENT); 3387 {if (true) return retval.image;} 3388 break; 3389 default: 3390 jj_la1[117] = jj_gen; 3391 jj_consume_token(-1); 3392 throw new ParseException(); 3393 } 3394 throw new Error("Missing return statement in function"); 3395 } 3396 3397 private boolean jj_2_1(int xla) { 3398 jj_la = xla; jj_lastpos = jj_scanpos = token; 3399 try { return !jj_3_1(); } 3400 catch(LookaheadSuccess ls) { return true; } 3401 finally { jj_save(0, xla); } 3402 } 3403 3404 private boolean jj_3R_92() { 3405 if (jj_scan_token(PLUS)) return true; 3406 return false; 3407 } 3408 3409 private boolean jj_3R_86() { 3410 Token xsp; 3411 xsp = jj_scanpos; 3412 if (jj_3R_92()) { 3413 jj_scanpos = xsp; 3414 if (jj_3R_93()) return true; 3415 } 3416 return false; 3417 } 3418 3419 private boolean jj_3R_85() { 3420 if (jj_3R_91()) return true; 3421 return false; 3422 } 3423 3424 private boolean jj_3R_91() { 3425 if (jj_scan_token(LBRACKET)) return true; 3426 return false; 3427 } 3428 3429 private boolean jj_3R_79() { 3430 if (jj_scan_token(PRECEDES)) return true; 3431 Token xsp; 3432 while (true) { 3433 xsp = jj_scanpos; 3434 if (jj_scan_token(1)) { jj_scanpos = xsp; break; } 3435 } 3436 return false; 3437 } 3438 3439 private boolean jj_3R_80() { 3440 if (jj_scan_token(S)) return true; 3441 Token xsp; 3442 xsp = jj_scanpos; 3443 if (jj_3R_86()) jj_scanpos = xsp; 3444 return false; 3445 } 3446 3447 private boolean jj_3R_78() { 3448 if (jj_scan_token(PLUS)) return true; 3449 Token xsp; 3450 while (true) { 3451 xsp = jj_scanpos; 3452 if (jj_scan_token(1)) { jj_scanpos = xsp; break; } 3453 } 3454 return false; 3455 } 3456 3457 private boolean jj_3R_76() { 3458 Token xsp; 3459 xsp = jj_scanpos; 3460 if (jj_3R_78()) { 3461 jj_scanpos = xsp; 3462 if (jj_3R_79()) { 3463 jj_scanpos = xsp; 3464 if (jj_3R_80()) return true; 3465 } 3466 } 3467 return false; 3468 } 3469 3470 private boolean jj_3R_84() { 3471 if (jj_3R_90()) return true; 3472 return false; 3473 } 3474 3475 private boolean jj_3R_83() { 3476 if (jj_3R_89()) return true; 3477 return false; 3478 } 3479 3480 private boolean jj_3R_96() { 3481 if (jj_scan_token(ANY)) return true; 3482 return false; 3483 } 3484 3485 private boolean jj_3_1() { 3486 if (jj_3R_76()) return true; 3487 if (jj_3R_77()) return true; 3488 return false; 3489 } 3490 3491 private boolean jj_3R_95() { 3492 if (jj_scan_token(NAMESPACE_IDENT)) return true; 3493 return false; 3494 } 3495 3496 private boolean jj_3R_90() { 3497 if (jj_scan_token(COLON)) return true; 3498 return false; 3499 } 3500 3501 private boolean jj_3R_82() { 3502 if (jj_3R_88()) return true; 3503 return false; 3504 } 3505 3506 private boolean jj_3R_88() { 3507 if (jj_scan_token(HASH)) return true; 3508 return false; 3509 } 3510 3511 private boolean jj_3R_94() { 3512 if (jj_scan_token(IDENT)) return true; 3513 return false; 3514 } 3515 3516 private boolean jj_3R_87() { 3517 Token xsp; 3518 xsp = jj_scanpos; 3519 if (jj_3R_94()) { 3520 jj_scanpos = xsp; 3521 if (jj_3R_95()) { 3522 jj_scanpos = xsp; 3523 if (jj_3R_96()) return true; 3524 } 3525 } 3526 return false; 3527 } 3528 3529 private boolean jj_3R_81() { 3530 if (jj_3R_87()) return true; 3531 return false; 3532 } 3533 3534 private boolean jj_3R_77() { 3535 Token xsp; 3536 xsp = jj_scanpos; 3537 if (jj_3R_81()) { 3538 jj_scanpos = xsp; 3539 if (jj_3R_82()) { 3540 jj_scanpos = xsp; 3541 if (jj_3R_83()) { 3542 jj_scanpos = xsp; 3543 if (jj_3R_84()) { 3544 jj_scanpos = xsp; 3545 if (jj_3R_85()) return true; 3546 } 3547 } 3548 } 3549 } 3550 return false; 3551 } 3552 3553 private boolean jj_3R_93() { 3554 if (jj_scan_token(PRECEDES)) return true; 3555 return false; 3556 } 3557 3558 private boolean jj_3R_89() { 3559 if (jj_scan_token(DOT)) return true; 3560 return false; 3561 } 3562 3563 /** Generated Token Manager. */ 3564 public ParserTokenManager token_source; 3565 /** Current token. */ 3566 public Token token; 3567 /** Next token. */ 3568 public Token jj_nt; 3569 private int jj_ntk; 3570 private Token jj_scanpos, jj_lastpos; 3571 private int jj_la; 3572 private int jj_gen; 3573 final private int[] jj_la1 = new int[118]; 3574 static private int[] jj_la1_0; 3575 static private int[] jj_la1_1; 3576 static private int[] jj_la1_2; 3577 static { 3578 jj_la1_init_0(); 3579 jj_la1_init_1(); 3580 jj_la1_init_2(); 3581 } 3582 private static void jj_la1_init_0() { 3583 jj_la1_0 = new int[] {0x0,0x62,0x62,0x0,0x60,0x2,0x0,0x60,0x2,0x2,0x2,0x1340000,0x60,0x2,0x60,0x2,0x0,0x2,0x0,0x2,0x2,0x2,0x0,0x2,0x2,0x2,0x335f6a0,0x335f6a0,0x2,0x4000,0x2,0x2,0x2,0x2,0x0,0x1000000,0x2,0x0,0x8000,0x2,0x0,0x0,0x2,0x2,0x2,0x2,0x0,0x8000,0x2,0x0,0x2,0x201f6a0,0x2,0x2,0x11000,0x2,0x11000,0x11002,0x2,0x2,0x0,0x8000,0x2,0x0,0x2,0x4000,0x2,0x2,0x1240000,0x1240000,0x1240000,0x1240000,0x1240000,0x1240000,0x1240000,0x1240000,0x1240000,0x1240000,0x1340000,0x100000,0x2,0x0,0x2,0xe00,0x2,0x0,0x2,0xe00,0x2,0x2,0x0,0x2,0x0,0x2,0x2,0x2,0x24000,0x27000,0x24000,0x3000,0x3000,0x0,0x0,0x3000,0x2,0x2,0x3000,0x2,0x1340000,0x2,0x2,0x2,0x0,0x8000,0x2,0x0,0x2,0x0,}; 3584 } 3585 private static void jj_la1_init_1() { 3586 jj_la1_1 = new int[] {0x20000000,0x0,0x0,0x8000000,0x0,0x0,0x80000000,0x0,0x0,0x0,0x0,0x54000110,0x0,0x0,0x0,0x0,0x88,0x0,0x10,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x7c0003b8,0x7c0003b8,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x10,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x10,0x0,0x780002a8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x4000000,0x4000000,0x0,0x0,0x4000000,0x4000000,0x4000000,0x4000000,0x4000000,0x4000000,0x4000110,0x110,0x0,0x110,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x7ffffb8,0x0,0x0,0x0,0x3fffe20,0x4000198,0x7ffffb8,0x0,0x0,0x7ffffb8,0x0,0x5c000110,0x0,0x0,0x0,0x10,0x0,0x0,0x10,0x0,0x110,}; 3587 } 3588 private static void jj_la1_init_2() { 3589 jj_la1_2 = new int[] {0x0,0x2,0x2,0x0,0x2,0x0,0x0,0x2,0x0,0x0,0x0,0x1,0x2,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7007,0x7007,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7007,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000,0x0,0x4,0x0,0x0,0x0,0x0,0x3000,0x0,0x0,0x0,0x2000,0x1000,0x3000,0x0,0x0,0x3000,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,}; 3590 } 3591 final private JJCalls[] jj_2_rtns = new JJCalls[1]; 3592 private boolean jj_rescan = false; 3593 private int jj_gc = 0; 3594 3595 /** Constructor with user supplied CharStream. */ 3596 public Parser(CharStream stream) { 3597 token_source = new ParserTokenManager(stream); 3598 token = new Token(); 3599 jj_ntk = -1; 3600 jj_gen = 0; 3601 for (int i = 0; i < 118; i++) jj_la1[i] = -1; 3602 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); 3603 } 3604 3605 /** Reinitialise. */ 3606 public void ReInit(CharStream stream) { 3607 token_source.ReInit(stream); 3608 token = new Token(); 3609 jj_ntk = -1; 3610 jj_gen = 0; 3611 for (int i = 0; i < 118; i++) jj_la1[i] = -1; 3612 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); 3613 } 3614 3615 /** Constructor with generated Token Manager. */ 3616 public Parser(ParserTokenManager tm) { 3617 token_source = tm; 3618 token = new Token(); 3619 jj_ntk = -1; 3620 jj_gen = 0; 3621 for (int i = 0; i < 118; i++) jj_la1[i] = -1; 3622 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); 3623 } 3624 3625 /** Reinitialise. */ 3626 public void ReInit(ParserTokenManager tm) { 3627 token_source = tm; 3628 token = new Token(); 3629 jj_ntk = -1; 3630 jj_gen = 0; 3631 for (int i = 0; i < 118; i++) jj_la1[i] = -1; 3632 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); 3633 } 3634 3635 private Token jj_consume_token(int kind) throws ParseException { 3636 Token oldToken; 3637 if ((oldToken = token).next != null) token = token.next; 3638 else token = token.next = token_source.getNextToken(); 3639 jj_ntk = -1; 3640 if (token.kind == kind) { 3641 jj_gen++; 3642 if (++jj_gc > 100) { 3643 jj_gc = 0; 3644 for (int i = 0; i < jj_2_rtns.length; i++) { 3645 JJCalls c = jj_2_rtns[i]; 3646 while (c != null) { 3647 if (c.gen < jj_gen) c.first = null; 3648 c = c.next; 3649 } 3650 } 3651 } 3652 return token; 3653 } 3654 token = oldToken; 3655 jj_kind = kind; 3656 throw generateParseException(); 3657 } 3658 3659 static private final class LookaheadSuccess extends java.lang.Error { } 3660 final private LookaheadSuccess jj_ls = new LookaheadSuccess(); 3661 private boolean jj_scan_token(int kind) { 3662 if (jj_scanpos == jj_lastpos) { 3663 jj_la--; 3664 if (jj_scanpos.next == null) { 3665 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken(); 3666 } else { 3667 jj_lastpos = jj_scanpos = jj_scanpos.next; 3668 } 3669 } else { 3670 jj_scanpos = jj_scanpos.next; 3671 } 3672 if (jj_rescan) { 3673 int i = 0; Token tok = token; 3674 while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; } 3675 if (tok != null) jj_add_error_token(kind, i); 3676 } 3677 if (jj_scanpos.kind != kind) return true; 3678 if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls; 3679 return false; 3680 } 3681 3682 3683/** Get the next Token. */ 3684 final public Token getNextToken() { 3685 if (token.next != null) token = token.next; 3686 else token = token.next = token_source.getNextToken(); 3687 jj_ntk = -1; 3688 jj_gen++; 3689 return token; 3690 } 3691 3692/** Get the specific Token. */ 3693 final public Token getToken(int index) { 3694 Token t = token; 3695 for (int i = 0; i < index; i++) { 3696 if (t.next != null) t = t.next; 3697 else t = t.next = token_source.getNextToken(); 3698 } 3699 return t; 3700 } 3701 3702 private int jj_ntk() { 3703 if ((jj_nt=token.next) == null) 3704 return (jj_ntk = (token.next=token_source.getNextToken()).kind); 3705 else 3706 return (jj_ntk = jj_nt.kind); 3707 } 3708 3709 private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>(); 3710 private int[] jj_expentry; 3711 private int jj_kind = -1; 3712 private int[] jj_lasttokens = new int[100]; 3713 private int jj_endpos; 3714 3715 private void jj_add_error_token(int kind, int pos) { 3716 if (pos >= 100) return; 3717 if (pos == jj_endpos + 1) { 3718 jj_lasttokens[jj_endpos++] = kind; 3719 } else if (jj_endpos != 0) { 3720 jj_expentry = new int[jj_endpos]; 3721 for (int i = 0; i < jj_endpos; i++) { 3722 jj_expentry[i] = jj_lasttokens[i]; 3723 } 3724 jj_entries_loop: for (java.util.Iterator<?> it = jj_expentries.iterator(); it.hasNext();) { 3725 int[] oldentry = (int[])(it.next()); 3726 if (oldentry.length == jj_expentry.length) { 3727 for (int i = 0; i < jj_expentry.length; i++) { 3728 if (oldentry[i] != jj_expentry[i]) { 3729 continue jj_entries_loop; 3730 } 3731 } 3732 jj_expentries.add(jj_expentry); 3733 break jj_entries_loop; 3734 } 3735 } 3736 if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind; 3737 } 3738 } 3739 3740 /** Generate ParseException. */ 3741 public ParseException generateParseException() { 3742 jj_expentries.clear(); 3743 boolean[] la1tokens = new boolean[79]; 3744 if (jj_kind >= 0) { 3745 la1tokens[jj_kind] = true; 3746 jj_kind = -1; 3747 } 3748 for (int i = 0; i < 118; i++) { 3749 if (jj_la1[i] == jj_gen) { 3750 for (int j = 0; j < 32; j++) { 3751 if ((jj_la1_0[i] & (1<<j)) != 0) { 3752 la1tokens[j] = true; 3753 } 3754 if ((jj_la1_1[i] & (1<<j)) != 0) { 3755 la1tokens[32+j] = true; 3756 } 3757 if ((jj_la1_2[i] & (1<<j)) != 0) { 3758 la1tokens[64+j] = true; 3759 } 3760 } 3761 } 3762 } 3763 for (int i = 0; i < 79; i++) { 3764 if (la1tokens[i]) { 3765 jj_expentry = new int[1]; 3766 jj_expentry[0] = i; 3767 jj_expentries.add(jj_expentry); 3768 } 3769 } 3770 jj_endpos = 0; 3771 jj_rescan_token(); 3772 jj_add_error_token(0, 0); 3773 int[][] exptokseq = new int[jj_expentries.size()][]; 3774 for (int i = 0; i < jj_expentries.size(); i++) { 3775 exptokseq[i] = jj_expentries.get(i); 3776 } 3777 return new ParseException(token, exptokseq, tokenImage); 3778 } 3779 3780 /** Enable tracing. */ 3781 final public void enable_tracing() { 3782 } 3783 3784 /** Disable tracing. */ 3785 final public void disable_tracing() { 3786 } 3787 3788 private void jj_rescan_token() { 3789 jj_rescan = true; 3790 for (int i = 0; i < 1; i++) { 3791 try { 3792 JJCalls p = jj_2_rtns[i]; 3793 do { 3794 if (p.gen > jj_gen) { 3795 jj_la = p.arg; jj_lastpos = jj_scanpos = p.first; 3796 switch (i) { 3797 case 0: jj_3_1(); break; 3798 } 3799 } 3800 p = p.next; 3801 } while (p != null); 3802 } catch(LookaheadSuccess ls) { } 3803 } 3804 jj_rescan = false; 3805 } 3806 3807 private void jj_save(int index, int xla) { 3808 JJCalls p = jj_2_rtns[index]; 3809 while (p.gen > jj_gen) { 3810 if (p.next == null) { p = p.next = new JJCalls(); break; } 3811 p = p.next; 3812 } 3813 p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla; 3814 } 3815 3816 static final class JJCalls { 3817 int gen; 3818 Token first; 3819 int arg; 3820 JJCalls next; 3821 } 3822 3823}