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