1:
2: package ;
3:
4: import ;
5: import ;
6: import ;
7:
8:
9: import ;
10: import ;
11: import ;
12: import ;
13: import ;
14: import ;
15: import ;
16: import ;
17: import ;
18: import ;
19: import ;
20: import ;
21: import ;
22:
23: import ;
24: import ;
25:
26: import ;
27:
28:
34: public class Parser implements org.w3c.css.sac.Parser, ParserConstants {
35:
36:
37: static final StringBuffer SPACE = new StringBuffer(" ");
38:
39:
40: protected DocumentHandler documentHandler;
41:
42: protected ErrorHandler errorHandler;
43:
44: protected InputSource source;
45:
46: protected ConditionFactory conditionFactory;
47: protected SelectorFactory selectorFactory;
48:
49:
50: protected String pseudoElt;
51:
52:
55: public Parser() {
56: this((CharStream) null);
57: }
58:
59:
63: public void setLocale(Locale locale) throws CSSException {
64: throw new CSSException(CSSException.SAC_NOT_SUPPORTED_ERR);
65: }
66:
67:
70: public void setDocumentHandler(DocumentHandler handler) {
71: this.documentHandler = handler;
72: }
73:
74: public void setSelectorFactory(SelectorFactory selectorFactory) {
75: this.selectorFactory = selectorFactory;
76: }
77:
78: public void setConditionFactory(ConditionFactory conditionFactory) {
79: this.conditionFactory = conditionFactory;
80: }
81:
82:
85: public void setErrorHandler(ErrorHandler error) {
86: this.errorHandler = error;
87: }
88:
89:
96: public void parseStyleSheet(InputSource source)
97: throws CSSException, IOException {
98: this.source = source;
99: ReInit(getCharStreamWithLurk(source));
100: if (selectorFactory == null) {
101: selectorFactory = new SelectorFactoryImpl();
102: }
103: if (conditionFactory == null) {
104: conditionFactory = new ConditionFactoryImpl();
105: }
106:
107: parserUnit();
108: }
109:
110:
117: public void parseStyleSheet(String systemId)
118: throws CSSException, IOException {
119: parseStyleSheet(new InputSource(systemId));
120: }
121:
122:
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:
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:
169: public String getParserVersion() {
170: return "http://www.w3.org/TR/REC-CSS2";
171: }
172:
173:
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:
252: private Reader getReader(InputSource source) throws IOException {
253: if (source.getCharacterStream() != null) {
254: return source.getCharacterStream();
255: } else if (source.getByteStream() != null) {
256:
257: if (source.getEncoding() == null) {
258:
259: return new InputStreamReader(source.getByteStream(), "ASCII");
260: } else {
261: return new InputStreamReader(source.getByteStream(),
262: source.getEncoding());
263: }
264: } else {
265:
266:
267: throw new CSSException("not yet implemented");
268: }
269: }
270:
271:
278: private CharStream getCharStreamWithLurk(InputSource source)
279: throws CSSException, IOException {
280: if (source.getCharacterStream() != null) {
281:
282:
283: return new Generic_CharStream(source.getCharacterStream(), 1, 1);
284: } else if (source.getByteStream() == null) {
285:
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:
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:
315:
316:
317: while ((c = (char) input.read()) == ' ') {
318:
319: }
320: char endChar = c;
321: int i = 0;
322:
323: if ((endChar != '"') && (endChar != '\'')) {
324:
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:
339: }
340: if (c != ';') {
341:
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:
348:
349:
350: if (!encoding.equals(source.getEncoding())) {
351: throw new CSSException("invalid encoding information.");
352: }
353: }
354: }
355: }
356:
357: source.setEncoding(encoding);
358:
359: source.setCharacterStream(new InputStreamReader(source.getByteStream(),
360: Encoding.getJavaEncoding(encoding)));
361:
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:
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:
430:
431:
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:
592:
593: } catch (Exception e) {
594: reportError(getLocator(), e);
595: skipStatement();
596:
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:
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:
762: ml.addItem("all");
763: }
764: documentHandler.importStyle(uri, ml, null);
765: } catch (ParseException e) {
766: reportError(getLocator(), e);
767: skipStatement();
768:
769:
770: }
771: }
772:
773:
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:
847:
848: }
849: }
850:
851:
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:
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:
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:
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:
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:
1306:
1307: } finally {
1308: if (start) {
1309: documentHandler.endFontFace();
1310: }
1311: }
1312: }
1313:
1314:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
2280: } else {
2281: skipAfterExpression();
2282: }
2283: }
2284: }
2285:
2286:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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;}
3373:
3374: }
3375: throw new Error("Missing return statement in function");
3376: }
3377:
3378: final public String _parseNamespaceToken() throws ParseException {
3379: Token retval = null;
3380: switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3381: case NAMESPACE_IDENT:
3382: retval = jj_consume_token(NAMESPACE_IDENT);
3383: {if (true) return retval.image;}
3384: break;
3385: case IDENT:
3386: retval = jj_consume_token(IDENT);
3387: {if (true) return retval.image;}
3388: break;
3389: default:
3390: jj_la1[117] = jj_gen;
3391: jj_consume_token(-1);
3392: throw new ParseException();
3393: }
3394: throw new Error("Missing return statement in function");
3395: }
3396:
3397: final private boolean jj_2_1(int xla) {
3398: jj_la = xla; jj_lastpos = jj_scanpos = token;
3399: try { return !jj_3_1(); }
3400: catch(LookaheadSuccess ls) { return true; }
3401: finally { jj_save(0, xla); }
3402: }
3403:
3404: final private boolean jj_3R_92() {
3405: if (jj_scan_token(PLUS)) return true;
3406: return false;
3407: }
3408:
3409: final private boolean jj_3R_86() {
3410: Token xsp;
3411: xsp = jj_scanpos;
3412: if (jj_3R_92()) {
3413: jj_scanpos = xsp;
3414: if (jj_3R_93()) return true;
3415: }
3416: return false;
3417: }
3418:
3419: final private boolean jj_3R_91() {
3420: if (jj_scan_token(LBRACKET)) return true;
3421: return false;
3422: }
3423:
3424: final private boolean jj_3R_85() {
3425: if (jj_3R_91()) return true;
3426: return false;
3427: }
3428:
3429: final private boolean jj_3R_79() {
3430: if (jj_scan_token(PRECEDES)) return true;
3431: Token xsp;
3432: while (true) {
3433: xsp = jj_scanpos;
3434: if (jj_scan_token(1)) { jj_scanpos = xsp; break; }
3435: }
3436: return false;
3437: }
3438:
3439: final private boolean jj_3R_80() {
3440: if (jj_scan_token(S)) return true;
3441: Token xsp;
3442: xsp = jj_scanpos;
3443: if (jj_3R_86()) jj_scanpos = xsp;
3444: return false;
3445: }
3446:
3447: final private boolean jj_3R_78() {
3448: if (jj_scan_token(PLUS)) return true;
3449: Token xsp;
3450: while (true) {
3451: xsp = jj_scanpos;
3452: if (jj_scan_token(1)) { jj_scanpos = xsp; break; }
3453: }
3454: return false;
3455: }
3456:
3457: final private boolean jj_3R_76() {
3458: Token xsp;
3459: xsp = jj_scanpos;
3460: if (jj_3R_78()) {
3461: jj_scanpos = xsp;
3462: if (jj_3R_79()) {
3463: jj_scanpos = xsp;
3464: if (jj_3R_80()) return true;
3465: }
3466: }
3467: return false;
3468: }
3469:
3470: final private boolean jj_3R_84() {
3471: if (jj_3R_90()) return true;
3472: return false;
3473: }
3474:
3475: final private boolean jj_3R_83() {
3476: if (jj_3R_89()) return true;
3477: return false;
3478: }
3479:
3480: final private boolean jj_3R_96() {
3481: if (jj_scan_token(ANY)) return true;
3482: return false;
3483: }
3484:
3485: final private boolean jj_3_1() {
3486: if (jj_3R_76()) return true;
3487: if (jj_3R_77()) return true;
3488: return false;
3489: }
3490:
3491: final private boolean jj_3R_95() {
3492: if (jj_scan_token(NAMESPACE_IDENT)) return true;
3493: return false;
3494: }
3495:
3496: final private boolean jj_3R_82() {
3497: if (jj_3R_88()) return true;
3498: return false;
3499: }
3500:
3501: final private boolean jj_3R_90() {
3502: if (jj_scan_token(COLON)) return true;
3503: return false;
3504: }
3505:
3506: final private boolean jj_3R_88() {
3507: if (jj_scan_token(HASH)) return true;
3508: return false;
3509: }
3510:
3511: final private boolean jj_3R_94() {
3512: if (jj_scan_token(IDENT)) return true;
3513: return false;
3514: }
3515:
3516: final private boolean jj_3R_87() {
3517: Token xsp;
3518: xsp = jj_scanpos;
3519: if (jj_3R_94()) {
3520: jj_scanpos = xsp;
3521: if (jj_3R_95()) {
3522: jj_scanpos = xsp;
3523: if (jj_3R_96()) return true;
3524: }
3525: }
3526: return false;
3527: }
3528:
3529: final private boolean jj_3R_81() {
3530: if (jj_3R_87()) return true;
3531: return false;
3532: }
3533:
3534: final private boolean jj_3R_77() {
3535: Token xsp;
3536: xsp = jj_scanpos;
3537: if (jj_3R_81()) {
3538: jj_scanpos = xsp;
3539: if (jj_3R_82()) {
3540: jj_scanpos = xsp;
3541: if (jj_3R_83()) {
3542: jj_scanpos = xsp;
3543: if (jj_3R_84()) {
3544: jj_scanpos = xsp;
3545: if (jj_3R_85()) return true;
3546: }
3547: }
3548: }
3549: }
3550: return false;
3551: }
3552:
3553: final private boolean jj_3R_93() {
3554: if (jj_scan_token(PRECEDES)) return true;
3555: return false;
3556: }
3557:
3558: final private boolean jj_3R_89() {
3559: if (jj_scan_token(DOT)) return true;
3560: return false;
3561: }
3562:
3563: public ParserTokenManager token_source;
3564: public Token token, jj_nt;
3565: private int jj_ntk;
3566: private Token jj_scanpos, jj_lastpos;
3567: private int jj_la;
3568: public boolean lookingAhead = false;
3569: private boolean jj_semLA;
3570: private int jj_gen;
3571: final private int[] jj_la1 = new int[118];
3572: static private int[] jj_la1_0;
3573: static private int[] jj_la1_1;
3574: static private int[] jj_la1_2;
3575: static {
3576: jj_la1_0();
3577: jj_la1_1();
3578: jj_la1_2();
3579: }
3580: private static void jj_la1_0() {
3581: jj_la1_0 = new int[] {0x0,0x62,0x62,0x0,0x60,0x2,0x0,0x60,0x2,0x2,0x2,0x1340000,0x60,0x2,0x60,0x2,0x0,0x2,0x0,0x2,0x2,0x2,0x0,0x2,0x2,0x2,0x335f6a0,0x335f6a0,0x2,0x4000,0x2,0x2,0x2,0x2,0x0,0x1000000,0x2,0x0,0x8000,0x2,0x0,0x0,0x2,0x2,0x2,0x2,0x0,0x8000,0x2,0x0,0x2,0x201f6a0,0x2,0x2,0x11000,0x2,0x11000,0x11002,0x2,0x2,0x0,0x8000,0x2,0x0,0x2,0x4000,0x2,0x2,0x1240000,0x1240000,0x1240000,0x1240000,0x1240000,0x1240000,0x1240000,0x1240000,0x1240000,0x1240000,0x1340000,0x100000,0x2,0x0,0x2,0xe00,0x2,0x0,0x2,0xe00,0x2,0x2,0x0,0x2,0x0,0x2,0x2,0x2,0x24000,0x27000,0x24000,0x3000,0x3000,0x0,0x0,0x3000,0x2,0x2,0x3000,0x2,0x1340000,0x2,0x2,0x2,0x0,0x8000,0x2,0x0,0x2,0x0,};
3582: }
3583: private static void jj_la1_1() {
3584: jj_la1_1 = new int[] {0x20000000,0x0,0x0,0x8000000,0x0,0x0,0x80000000,0x0,0x0,0x0,0x0,0x54000110,0x0,0x0,0x0,0x0,0x88,0x0,0x10,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x7c0003b8,0x7c0003b8,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x10,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x10,0x0,0x780002a8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x4000000,0x4000000,0x0,0x0,0x4000000,0x4000000,0x4000000,0x4000000,0x4000000,0x4000000,0x4000110,0x110,0x0,0x110,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x7ffffb8,0x0,0x0,0x0,0x3fffe20,0x4000198,0x7ffffb8,0x0,0x0,0x7ffffb8,0x0,0x5c000110,0x0,0x0,0x0,0x10,0x0,0x0,0x10,0x0,0x110,};
3585: }
3586: private static void jj_la1_2() {
3587: jj_la1_2 = new int[] {0x0,0x2,0x2,0x0,0x2,0x0,0x0,0x2,0x0,0x0,0x0,0x1,0x2,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7007,0x7007,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7007,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000,0x0,0x4,0x0,0x0,0x0,0x0,0x3000,0x0,0x0,0x0,0x2000,0x1000,0x3000,0x0,0x0,0x3000,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
3588: }
3589: final private JJCalls[] jj_2_rtns = new JJCalls[1];
3590: private boolean jj_rescan = false;
3591: private int jj_gc = 0;
3592:
3593: public Parser(CharStream stream) {
3594: token_source = new ParserTokenManager(stream);
3595: token = new Token();
3596: jj_ntk = -1;
3597: jj_gen = 0;
3598: for (int i = 0; i < 118; i++) jj_la1[i] = -1;
3599: for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3600: }
3601:
3602: public void ReInit(CharStream stream) {
3603: token_source.ReInit(stream);
3604: token = new Token();
3605: jj_ntk = -1;
3606: jj_gen = 0;
3607: for (int i = 0; i < 118; i++) jj_la1[i] = -1;
3608: for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3609: }
3610:
3611: public Parser(ParserTokenManager tm) {
3612: token_source = tm;
3613: token = new Token();
3614: jj_ntk = -1;
3615: jj_gen = 0;
3616: for (int i = 0; i < 118; i++) jj_la1[i] = -1;
3617: for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3618: }
3619:
3620: public void ReInit(ParserTokenManager tm) {
3621: token_source = tm;
3622: token = new Token();
3623: jj_ntk = -1;
3624: jj_gen = 0;
3625: for (int i = 0; i < 118; i++) jj_la1[i] = -1;
3626: for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3627: }
3628:
3629: final private Token jj_consume_token(int kind) throws ParseException {
3630: Token oldToken;
3631: if ((oldToken = token).next != null) token = token.next;
3632: else token = token.next = token_source.getNextToken();
3633: jj_ntk = -1;
3634: if (token.kind == kind) {
3635: jj_gen++;
3636: if (++jj_gc > 100) {
3637: jj_gc = 0;
3638: for (int i = 0; i < jj_2_rtns.length; i++) {
3639: JJCalls c = jj_2_rtns[i];
3640: while (c != null) {
3641: if (c.gen < jj_gen) c.first = null;
3642: c = c.next;
3643: }
3644: }
3645: }
3646: return token;
3647: }
3648: token = oldToken;
3649: jj_kind = kind;
3650: throw generateParseException();
3651: }
3652:
3653: static private final class LookaheadSuccess extends java.lang.Error { }
3654: final private LookaheadSuccess jj_ls = new LookaheadSuccess();
3655: final private boolean jj_scan_token(int kind) {
3656: if (jj_scanpos == jj_lastpos) {
3657: jj_la--;
3658: if (jj_scanpos.next == null) {
3659: jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
3660: } else {
3661: jj_lastpos = jj_scanpos = jj_scanpos.next;
3662: }
3663: } else {
3664: jj_scanpos = jj_scanpos.next;
3665: }
3666: if (jj_rescan) {
3667: int i = 0; Token tok = token;
3668: while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
3669: if (tok != null) jj_add_error_token(kind, i);
3670: }
3671: if (jj_scanpos.kind != kind) return true;
3672: if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
3673: return false;
3674: }
3675:
3676: final public Token getNextToken() {
3677: if (token.next != null) token = token.next;
3678: else token = token.next = token_source.getNextToken();
3679: jj_ntk = -1;
3680: jj_gen++;
3681: return token;
3682: }
3683:
3684: final public Token getToken(int index) {
3685: Token t = lookingAhead ? jj_scanpos : token;
3686: for (int i = 0; i < index; i++) {
3687: if (t.next != null) t = t.next;
3688: else t = t.next = token_source.getNextToken();
3689: }
3690: return t;
3691: }
3692:
3693: final private int jj_ntk() {
3694: if ((jj_nt=token.next) == null)
3695: return (jj_ntk = (token.next=token_source.getNextToken()).kind);
3696: else
3697: return (jj_ntk = jj_nt.kind);
3698: }
3699:
3700: private java.util.Vector jj_expentries = new java.util.Vector();
3701: private int[] jj_expentry;
3702: private int jj_kind = -1;
3703: private int[] jj_lasttokens = new int[100];
3704: private int jj_endpos;
3705:
3706: private void jj_add_error_token(int kind, int pos) {
3707: if (pos >= 100) return;
3708: if (pos == jj_endpos + 1) {
3709: jj_lasttokens[jj_endpos++] = kind;
3710: } else if (jj_endpos != 0) {
3711: jj_expentry = new int[jj_endpos];
3712: for (int i = 0; i < jj_endpos; i++) {
3713: jj_expentry[i] = jj_lasttokens[i];
3714: }
3715: boolean exists = false;
3716: for (java.util.Enumeration e = jj_expentries.elements(); e.hasMoreElements();) {
3717: int[] oldentry = (int[])(e.nextElement());
3718: if (oldentry.length == jj_expentry.length) {
3719: exists = true;
3720: for (int i = 0; i < jj_expentry.length; i++) {
3721: if (oldentry[i] != jj_expentry[i]) {
3722: exists = false;
3723: break;
3724: }
3725: }
3726: if (exists) break;
3727: }
3728: }
3729: if (!exists) jj_expentries.addElement(jj_expentry);
3730: if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
3731: }
3732: }
3733:
3734: public ParseException generateParseException() {
3735: jj_expentries.removeAllElements();
3736: boolean[] la1tokens = new boolean[79];
3737: for (int i = 0; i < 79; i++) {
3738: la1tokens[i] = false;
3739: }
3740: if (jj_kind >= 0) {
3741: la1tokens[jj_kind] = true;
3742: jj_kind = -1;
3743: }
3744: for (int i = 0; i < 118; i++) {
3745: if (jj_la1[i] == jj_gen) {
3746: for (int j = 0; j < 32; j++) {
3747: if ((jj_la1_0[i] & (1<<j)) != 0) {
3748: la1tokens[j] = true;
3749: }
3750: if ((jj_la1_1[i] & (1<<j)) != 0) {
3751: la1tokens[32+j] = true;
3752: }
3753: if ((jj_la1_2[i] & (1<<j)) != 0) {
3754: la1tokens[64+j] = true;
3755: }
3756: }
3757: }
3758: }
3759: for (int i = 0; i < 79; i++) {
3760: if (la1tokens[i]) {
3761: jj_expentry = new int[1];
3762: jj_expentry[0] = i;
3763: jj_expentries.addElement(jj_expentry);
3764: }
3765: }
3766: jj_endpos = 0;
3767: jj_rescan_token();
3768: jj_add_error_token(0, 0);
3769: int[][] exptokseq = new int[jj_expentries.size()][];
3770: for (int i = 0; i < jj_expentries.size(); i++) {
3771: exptokseq[i] = (int[])jj_expentries.elementAt(i);
3772: }
3773: return new ParseException(token, exptokseq, tokenImage);
3774: }
3775:
3776: final public void enable_tracing() {
3777: }
3778:
3779: final public void disable_tracing() {
3780: }
3781:
3782: final private void jj_rescan_token() {
3783: jj_rescan = true;
3784: for (int i = 0; i < 1; i++) {
3785: try {
3786: JJCalls p = jj_2_rtns[i];
3787: do {
3788: if (p.gen > jj_gen) {
3789: jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
3790: switch (i) {
3791: case 0: jj_3_1(); break;
3792: }
3793: }
3794: p = p.next;
3795: } while (p != null);
3796: } catch(LookaheadSuccess ls) { }
3797: }
3798: jj_rescan = false;
3799: }
3800:
3801: final private void jj_save(int index, int xla) {
3802: JJCalls p = jj_2_rtns[index];
3803: while (p.gen > jj_gen) {
3804: if (p.next == null) { p = p.next = new JJCalls(); break; }
3805: p = p.next;
3806: }
3807: p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
3808: }
3809:
3810: static final class JJCalls {
3811: int gen;
3812: Token first;
3813: int arg;
3814: JJCalls next;
3815: }
3816:
3817: }