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