Source for org.w3c.flute.parser.Parser

   1: /* Generated By:JavaCC: Do not edit this line. Parser.java */
   2: package org.w3c.flute.parser;
   3: 
   4: import java.io.*;
   5: import java.net.*;
   6: import java.util.Locale;
   7: 
   8: 
   9: import org.w3c.css.sac.ConditionFactory;
  10: import org.w3c.css.sac.Condition;
  11: import org.w3c.css.sac.SelectorFactory;
  12: import org.w3c.css.sac.SelectorList;
  13: import org.w3c.css.sac.Selector;
  14: import org.w3c.css.sac.SimpleSelector;
  15: import org.w3c.css.sac.DocumentHandler;
  16: import org.w3c.css.sac.InputSource;
  17: import org.w3c.css.sac.ErrorHandler;
  18: import org.w3c.css.sac.CSSException;
  19: import org.w3c.css.sac.CSSParseException;
  20: import org.w3c.css.sac.Locator;
  21: import org.w3c.css.sac.LexicalUnit;
  22: 
  23: import org.w3c.flute.parser.selectors.SelectorFactoryImpl;
  24: import org.w3c.flute.parser.selectors.ConditionFactoryImpl;
  25: 
  26: import org.w3c.flute.util.Encoding;
  27: 
  28: /**
  29:  * A CSS2 parser
  30:  *
  31:  * @author Philippe Le Higaret
  32:  * @version $Revision: 1.4 $
  33:  */
  34: public class Parser implements org.w3c.css.sac.Parser, ParserConstants {
  35: 
  36:     // replaces all \t, \n, etc with this StringBuffer.
  37:     static final StringBuffer SPACE = new StringBuffer(" ");
  38: 
  39:     // the document handler for the parser
  40:     protected DocumentHandler documentHandler;
  41:     // the error handler for the parser
  42:     protected ErrorHandler errorHandler;
  43:     // the input source for the parser
  44:     protected InputSource source;
  45: 
  46:     protected ConditionFactory conditionFactory;
  47:     protected SelectorFactory selectorFactory;
  48: 
  49:     // temporary place holder for pseudo-element ...
  50:     protected String pseudoElt;
  51: 
  52:     /**
  53:      * Creates a new Parser
  54:      */
  55:     public Parser() {
  56:         this((CharStream) null);
  57:     }
  58: 
  59:     /**
  60:      * @@TODO
  61:      * @exception CSSException Not yet implemented
  62:      */
  63:     public void setLocale(Locale locale) throws CSSException {
  64:         throw new CSSException(CSSException.SAC_NOT_SUPPORTED_ERR);
  65:     }
  66: 
  67:     /**
  68:      * Set the document handler for this parser
  69:      */
  70:     public void setDocumentHandler(DocumentHandler handler) {
  71:         this.documentHandler = handler;
  72:     }
  73: 
  74:     public void setSelectorFactory(SelectorFactory selectorFactory) {
  75:         this.selectorFactory = selectorFactory;
  76:     }
  77: 
  78:     public void setConditionFactory(ConditionFactory conditionFactory) {
  79:         this.conditionFactory = conditionFactory;
  80:     }
  81: 
  82:     /**
  83:      * Set the error handler for this parser
  84:      */
  85:     public void setErrorHandler(ErrorHandler error) {
  86:         this.errorHandler = error;
  87:     }
  88: 
  89:     /**
  90:      * Main parse methods
  91:      *
  92:      * @param source the source of the style sheet.
  93:      * @exception IOException the source can't be parsed.
  94:      * @exception CSSException the source is not CSS valid.
  95:      */
  96:     public void parseStyleSheet(InputSource source)
  97:             throws CSSException, IOException {
  98:         this.source = source;
  99:         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 != '\'')) {
 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 \"")
 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) == '\'')) {
 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) == '\''))
 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 {
1421: char 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;
1943: Condition 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;
2128: Token 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) == '\'') {
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 == '\\') {
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 '\n':
3159:                 case '\f':
3160:                     break;
3161:                 case '\r':
3162:                     if (index + 1 < len) {
3163:                         if (s.charAt(index + 1) == '\n') {
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:   final 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:   final private boolean jj_3R_92() {
3405:     if (jj_scan_token(PLUS)) return true;
3406:     return false;
3407:   }
3408: 
3409:   final 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:   final private boolean jj_3R_91() {
3420:     if (jj_scan_token(LBRACKET)) return true;
3421:     return false;
3422:   }
3423: 
3424:   final private boolean jj_3R_85() {
3425:     if (jj_3R_91()) return true;
3426:     return false;
3427:   }
3428: 
3429:   final 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:   final 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:   final 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:   final 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:   final private boolean jj_3R_84() {
3471:     if (jj_3R_90()) return true;
3472:     return false;
3473:   }
3474: 
3475:   final private boolean jj_3R_83() {
3476:     if (jj_3R_89()) return true;
3477:     return false;
3478:   }
3479: 
3480:   final private boolean jj_3R_96() {
3481:     if (jj_scan_token(ANY)) return true;
3482:     return false;
3483:   }
3484: 
3485:   final 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:   final private boolean jj_3R_95() {
3492:     if (jj_scan_token(NAMESPACE_IDENT)) return true;
3493:     return false;
3494:   }
3495: 
3496:   final private boolean jj_3R_82() {
3497:     if (jj_3R_88()) return true;
3498:     return false;
3499:   }
3500: 
3501:   final private boolean jj_3R_90() {
3502:     if (jj_scan_token(COLON)) return true;
3503:     return false;
3504:   }
3505: 
3506:   final private boolean jj_3R_88() {
3507:     if (jj_scan_token(HASH)) return true;
3508:     return false;
3509:   }
3510: 
3511:   final private boolean jj_3R_94() {
3512:     if (jj_scan_token(IDENT)) return true;
3513:     return false;
3514:   }
3515: 
3516:   final 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:   final private boolean jj_3R_81() {
3530:     if (jj_3R_87()) return true;
3531:     return false;
3532:   }
3533: 
3534:   final 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:   final private boolean jj_3R_93() {
3554:     if (jj_scan_token(PRECEDES)) return true;
3555:     return false;
3556:   }
3557: 
3558:   final private boolean jj_3R_89() {
3559:     if (jj_scan_token(DOT)) return true;
3560:     return false;
3561:   }
3562: 
3563:   public ParserTokenManager token_source;
3564:   public Token token, jj_nt;
3565:   private int jj_ntk;
3566:   private Token jj_scanpos, jj_lastpos;
3567:   private int jj_la;
3568:   public boolean lookingAhead = false;
3569:   private boolean jj_semLA;
3570:   private int jj_gen;
3571:   final private int[] jj_la1 = new int[118];
3572:   static private int[] jj_la1_0;
3573:   static private int[] jj_la1_1;
3574:   static private int[] jj_la1_2;
3575:   static {
3576:       jj_la1_0();
3577:       jj_la1_1();
3578:       jj_la1_2();
3579:    }
3580:    private static void jj_la1_0() {
3581:       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,};
3582:    }
3583:    private static void jj_la1_1() {
3584:       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,};
3585:    }
3586:    private static void jj_la1_2() {
3587:       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,};
3588:    }
3589:   final private JJCalls[] jj_2_rtns = new JJCalls[1];
3590:   private boolean jj_rescan = false;
3591:   private int jj_gc = 0;
3592: 
3593:   public Parser(CharStream stream) {
3594:     token_source = new ParserTokenManager(stream);
3595:     token = new Token();
3596:     jj_ntk = -1;
3597:     jj_gen = 0;
3598:     for (int i = 0; i < 118; i++) jj_la1[i] = -1;
3599:     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3600:   }
3601: 
3602:   public void ReInit(CharStream stream) {
3603:     token_source.ReInit(stream);
3604:     token = new Token();
3605:     jj_ntk = -1;
3606:     jj_gen = 0;
3607:     for (int i = 0; i < 118; i++) jj_la1[i] = -1;
3608:     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3609:   }
3610: 
3611:   public Parser(ParserTokenManager tm) {
3612:     token_source = tm;
3613:     token = new Token();
3614:     jj_ntk = -1;
3615:     jj_gen = 0;
3616:     for (int i = 0; i < 118; i++) jj_la1[i] = -1;
3617:     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3618:   }
3619: 
3620:   public void ReInit(ParserTokenManager tm) {
3621:     token_source = tm;
3622:     token = new Token();
3623:     jj_ntk = -1;
3624:     jj_gen = 0;
3625:     for (int i = 0; i < 118; i++) jj_la1[i] = -1;
3626:     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3627:   }
3628: 
3629:   final private Token jj_consume_token(int kind) throws ParseException {
3630:     Token oldToken;
3631:     if ((oldToken = token).next != null) token = token.next;
3632:     else token = token.next = token_source.getNextToken();
3633:     jj_ntk = -1;
3634:     if (token.kind == kind) {
3635:       jj_gen++;
3636:       if (++jj_gc > 100) {
3637:         jj_gc = 0;
3638:         for (int i = 0; i < jj_2_rtns.length; i++) {
3639:           JJCalls c = jj_2_rtns[i];
3640:           while (c != null) {
3641:             if (c.gen < jj_gen) c.first = null;
3642:             c = c.next;
3643:           }
3644:         }
3645:       }
3646:       return token;
3647:     }
3648:     token = oldToken;
3649:     jj_kind = kind;
3650:     throw generateParseException();
3651:   }
3652: 
3653:   static private final class LookaheadSuccess extends java.lang.Error { }
3654:   final private LookaheadSuccess jj_ls = new LookaheadSuccess();
3655:   final private boolean jj_scan_token(int kind) {
3656:     if (jj_scanpos == jj_lastpos) {
3657:       jj_la--;
3658:       if (jj_scanpos.next == null) {
3659:         jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
3660:       } else {
3661:         jj_lastpos = jj_scanpos = jj_scanpos.next;
3662:       }
3663:     } else {
3664:       jj_scanpos = jj_scanpos.next;
3665:     }
3666:     if (jj_rescan) {
3667:       int i = 0; Token tok = token;
3668:       while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
3669:       if (tok != null) jj_add_error_token(kind, i);
3670:     }
3671:     if (jj_scanpos.kind != kind) return true;
3672:     if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
3673:     return false;
3674:   }
3675: 
3676:   final public Token getNextToken() {
3677:     if (token.next != null) token = token.next;
3678:     else token = token.next = token_source.getNextToken();
3679:     jj_ntk = -1;
3680:     jj_gen++;
3681:     return token;
3682:   }
3683: 
3684:   final public Token getToken(int index) {
3685:     Token t = lookingAhead ? jj_scanpos : token;
3686:     for (int i = 0; i < index; i++) {
3687:       if (t.next != null) t = t.next;
3688:       else t = t.next = token_source.getNextToken();
3689:     }
3690:     return t;
3691:   }
3692: 
3693:   final private int jj_ntk() {
3694:     if ((jj_nt=token.next) == null)
3695:       return (jj_ntk = (token.next=token_source.getNextToken()).kind);
3696:     else
3697:       return (jj_ntk = jj_nt.kind);
3698:   }
3699: 
3700:   private java.util.Vector jj_expentries = new java.util.Vector();
3701:   private int[] jj_expentry;
3702:   private int jj_kind = -1;
3703:   private int[] jj_lasttokens = new int[100];
3704:   private int jj_endpos;
3705: 
3706:   private void jj_add_error_token(int kind, int pos) {
3707:     if (pos >= 100) return;
3708:     if (pos == jj_endpos + 1) {
3709:       jj_lasttokens[jj_endpos++] = kind;
3710:     } else if (jj_endpos != 0) {
3711:       jj_expentry = new int[jj_endpos];
3712:       for (int i = 0; i < jj_endpos; i++) {
3713:         jj_expentry[i] = jj_lasttokens[i];
3714:       }
3715:       boolean exists = false;
3716:       for (java.util.Enumeration e = jj_expentries.elements(); e.hasMoreElements();) {
3717:         int[] oldentry = (int[])(e.nextElement());
3718:         if (oldentry.length == jj_expentry.length) {
3719:           exists = true;
3720:           for (int i = 0; i < jj_expentry.length; i++) {
3721:             if (oldentry[i] != jj_expentry[i]) {
3722:               exists = false;
3723:               break;
3724:             }
3725:           }
3726:           if (exists) break;
3727:         }
3728:       }
3729:       if (!exists) jj_expentries.addElement(jj_expentry);
3730:       if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
3731:     }
3732:   }
3733: 
3734:   public ParseException generateParseException() {
3735:     jj_expentries.removeAllElements();
3736:     boolean[] la1tokens = new boolean[79];
3737:     for (int i = 0; i < 79; i++) {
3738:       la1tokens[i] = false;
3739:     }
3740:     if (jj_kind >= 0) {
3741:       la1tokens[jj_kind] = true;
3742:       jj_kind = -1;
3743:     }
3744:     for (int i = 0; i < 118; i++) {
3745:       if (jj_la1[i] == jj_gen) {
3746:         for (int j = 0; j < 32; j++) {
3747:           if ((jj_la1_0[i] & (1<<j)) != 0) {
3748:             la1tokens[j] = true;
3749:           }
3750:           if ((jj_la1_1[i] & (1<<j)) != 0) {
3751:             la1tokens[32+j] = true;
3752:           }
3753:           if ((jj_la1_2[i] & (1<<j)) != 0) {
3754:             la1tokens[64+j] = true;
3755:           }
3756:         }
3757:       }
3758:     }
3759:     for (int i = 0; i < 79; i++) {
3760:       if (la1tokens[i]) {
3761:         jj_expentry = new int[1];
3762:         jj_expentry[0] = i;
3763:         jj_expentries.addElement(jj_expentry);
3764:       }
3765:     }
3766:     jj_endpos = 0;
3767:     jj_rescan_token();
3768:     jj_add_error_token(0, 0);
3769:     int[][] exptokseq = new int[jj_expentries.size()][];
3770:     for (int i = 0; i < jj_expentries.size(); i++) {
3771:       exptokseq[i] = (int[])jj_expentries.elementAt(i);
3772:     }
3773:     return new ParseException(token, exptokseq, tokenImage);
3774:   }
3775: 
3776:   final public void enable_tracing() {
3777:   }
3778: 
3779:   final public void disable_tracing() {
3780:   }
3781: 
3782:   final private void jj_rescan_token() {
3783:     jj_rescan = true;
3784:     for (int i = 0; i < 1; i++) {
3785:     try {
3786:       JJCalls p = jj_2_rtns[i];
3787:       do {
3788:         if (p.gen > jj_gen) {
3789:           jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
3790:           switch (i) {
3791:             case 0: jj_3_1(); break;
3792:           }
3793:         }
3794:         p = p.next;
3795:       } while (p != null);
3796:       } catch(LookaheadSuccess ls) { }
3797:     }
3798:     jj_rescan = false;
3799:   }
3800: 
3801:   final private void jj_save(int index, int xla) {
3802:     JJCalls p = jj_2_rtns[index];
3803:     while (p.gen > jj_gen) {
3804:       if (p.next == null) { p = p.next = new JJCalls(); break; }
3805:       p = p.next;
3806:     }
3807:     p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
3808:   }
3809: 
3810:   static final class JJCalls {
3811:     int gen;
3812:     Token first;
3813:     int arg;
3814:     JJCalls next;
3815:   }
3816: 
3817: }