1
2 package org.daisy.pipeline.css.sass.impl;
3
4 import org.antlr.runtime.*;
5 import java.util.Stack;
6 import java.util.List;
7 import java.util.ArrayList;
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24 @SuppressWarnings("all")
25 public class SassPostProcessParser extends Parser {
26 public static final String[] tokenNames = new String[] {
27 "<invalid>", "<EOR>", "<DOWN>", "<UP>", "ANY", "APOS", "ASTERISK", "AT",
28 "BAR", "COLON", "COMMA", "COMMENT", "COMMENT_MACR", "ESCAPE_CHAR", "GREATER",
29 "HAS", "HASH", "IDENT", "IDENT_START", "LBRACE", "LCURLY", "LPAREN", "MEDIA",
30 "NAME", "NAME_CHAR", "NEWLINE_CHAR", "NON_ASCII", "NOT", "PERIOD", "PLUS",
31 "QUOT", "RBRACE", "RCURLY", "RPAREN", "SEMICOLON", "SPACE", "SPACE_CHAR",
32 "STRING", "STRING_CHAR", "STRING_MACR", "TILDE", "XML_COMMENT_CLOSE",
33 "XML_COMMENT_OPEN"
34 };
35 public static final int EOF=-1;
36 public static final int ANY=4;
37 public static final int APOS=5;
38 public static final int ASTERISK=6;
39 public static final int AT=7;
40 public static final int BAR=8;
41 public static final int COLON=9;
42 public static final int COMMA=10;
43 public static final int COMMENT=11;
44 public static final int COMMENT_MACR=12;
45 public static final int ESCAPE_CHAR=13;
46 public static final int GREATER=14;
47 public static final int HAS=15;
48 public static final int HASH=16;
49 public static final int IDENT=17;
50 public static final int IDENT_START=18;
51 public static final int LBRACE=19;
52 public static final int LCURLY=20;
53 public static final int LPAREN=21;
54 public static final int MEDIA=22;
55 public static final int NAME=23;
56 public static final int NAME_CHAR=24;
57 public static final int NEWLINE_CHAR=25;
58 public static final int NON_ASCII=26;
59 public static final int NOT=27;
60 public static final int PERIOD=28;
61 public static final int PLUS=29;
62 public static final int QUOT=30;
63 public static final int RBRACE=31;
64 public static final int RCURLY=32;
65 public static final int RPAREN=33;
66 public static final int SEMICOLON=34;
67 public static final int SPACE=35;
68 public static final int SPACE_CHAR=36;
69 public static final int STRING=37;
70 public static final int STRING_CHAR=38;
71 public static final int STRING_MACR=39;
72 public static final int TILDE=40;
73 public static final int XML_COMMENT_CLOSE=41;
74 public static final int XML_COMMENT_OPEN=42;
75
76
77 public Parser[] getDelegates() {
78 return new Parser[] {};
79 }
80
81
82
83
84 public SassPostProcessParser(TokenStream input) {
85 this(input, new RecognizerSharedState());
86 }
87 public SassPostProcessParser(TokenStream input, RecognizerSharedState state) {
88 super(input, state);
89 }
90
91 @Override public String[] getTokenNames() { return SassPostProcessParser.tokenNames; }
92 @Override public String getGrammarFileName() { return "org/daisy/pipeline/css/sass/impl/SassPostProcess.g"; }
93
94
95 private static class StringBuilder {
96 protected java.lang.StringBuilder sb = new java.lang.StringBuilder();
97 protected java.util.List<Object> list = new java.util.ArrayList<>();
98 public void append(Token token) {
99 append(token.getText());
100 list.add(token);
101 }
102 public void append(Object o) {
103 sb.append(o);
104 list.add(o);
105 }
106 @Override
107 public String toString() {
108 return sb.toString();
109 }
110 }
111 private static class SelectorRule extends StringBuilder {
112 private boolean hasSelector = false;
113 public void append(SelectorGroup selector) {
114 if (!selector.invalid()) {
115 hasSelector = true;
116 super.append(selector);
117 }
118 }
119 public void append(Object o) {
120 if (hasSelector)
121 super.append(o);
122 }
123 public boolean invalid() {
124 return !hasSelector;
125 }
126 }
127 private static class SelectorGroup extends StringBuilder {
128 private String pendingSeparator = null;
129 private boolean skipSeparator = true;
130 public void append(Token separator) {
131 if (!skipSeparator) {
132 if (pendingSeparator == null)
133 pendingSeparator = separator.getText();
134 else
135 pendingSeparator += separator.getText();
136 }
137 }
138 public void append(Selector selector) {
139 if (!selector.invalid()) {
140 if (pendingSeparator != null)
141 append(pendingSeparator);
142 super.append(selector);
143 skipSeparator = false;
144 }
145 pendingSeparator = null;
146 }
147 public boolean invalid() {
148 return sb.length() == 0;
149 }
150 }
151 private static class Selector extends StringBuilder {
152 private boolean invalid = false;
153 protected Combinator lastCombinator = null;
154 public void append(Combinator combinator) {
155 lastCombinator = combinator;
156 }
157 public void append(SimpleSelector selector) {
158 invalid |= selector.invalid();
159
160 if (selector.isPseudoElement()) {
161 if (lastCombinator == null || lastCombinator.type != Combinator.CHILD)
162 invalid = true;
163 else
164
165 sb = new java.lang.StringBuilder(sb.toString().replaceAll("\\s+$", ""));
166 } else if (lastCombinator != null)
167 super.append(lastCombinator);
168 lastCombinator = null;
169 super.append(selector);
170 }
171 public boolean invalid() {
172 return invalid || sb.length() == 0;
173 }
174 }
175 private static class RelativeSelector extends Selector {
176 public void append(Selector selector) {
177 for (Object o : selector.list)
178 if (o instanceof Combinator)
179 append((Combinator)o);
180 else if (o instanceof SimpleSelector)
181 append((SimpleSelector)o);
182 }
183 }
184 private static class Combinator extends StringBuilder {
185 public static final int CHILD = GREATER;
186 public static final int DESCENDANT = SPACE;
187 public static final int ADJACENT = PLUS;
188 public static final int SIBLING = TILDE;
189 public final int type;
190 public Combinator(int type) {
191 this.type = type;
192 }
193 public Combinator(Token token) {
194 this(token.getType());
195 append(token);
196 }
197 }
198 private static class SimpleSelector extends StringBuilder {
199 private int size = 0;
200 private PseudoElement pseudoElement = null;
201 private boolean hasEmptyNegationSelector = false;
202 private boolean hasOnlyPseudoClasses = true;
203 private boolean invalid = false;
204 public void append(SelectorPart selector) {
205
206 if (selector instanceof NegationSelector
207 && ((NegationSelector)selector).invalid())
208 hasEmptyNegationSelector = true;
209 else if (selector instanceof RelationalSelector
210 && ((RelationalSelector)selector).invalid())
211 invalid = true;
212 else {
213 size++;
214
215
216
217 if (selector instanceof PseudoElement) {
218 invalid |= !hasOnlyPseudoClasses;
219 pseudoElement = (PseudoElement)selector;
220 } else if (!(selector instanceof PseudoClass)) {
221 hasOnlyPseudoClasses = false;
222 invalid |= (pseudoElement != null);
223 }
224 super.append(selector);
225 }
226 }
227 public boolean invalid() {
228 return invalid || (size == 0 && !hasEmptyNegationSelector);
229 }
230 public boolean isPseudoElement() {
231 return !invalid && pseudoElement != null;
232 }
233 @Override
234 public String toString() {
235 if (size == 0 && !invalid())
236 return "*";
237 else if (pseudoElement == null || size == 1)
238 return super.toString();
239 else {
240
241
242 String s = pseudoElement.toString();
243 for (Object o : list)
244 if (o instanceof PseudoClass)
245 s += o.toString();
246 else if (o instanceof Token)
247
248 s += ((Token)o).getText();
249 return s;
250 }
251 }
252 }
253 private static class NegationSelector extends PseudoClass {
254 private SelectorGroup selector = null;
255 public void append(SimpleSelector ss) {
256 if (selector == null)
257 selector = new SelectorGroup();
258 Selector s = new Selector();
259 s.append(ss);
260 selector.append(s);
261 }
262 public void append(Token t) {
263 if (selector == null)
264
265 super.append(t);
266 else if (t.getType() == RPAREN)
267 ;
268 else
269
270 selector.append(t);
271 }
272 public boolean invalid() {
273 return selector != null ? selector.invalid() : true;
274 }
275 @Override
276 public String toString() {
277 String s = super.toString();
278 if (selector != null) {
279 s += selector.toString();
280 s += ")";
281 }
282 return s;
283 }
284 }
285 private static class RelationalSelector extends PseudoClass {
286 private SelectorGroup selector = null;
287 public void append(RelativeSelector s) {
288 if (selector == null)
289 selector = new SelectorGroup();
290 selector.append(s);
291 }
292 public void append(Token t) {
293 if (selector == null)
294
295 super.append(t);
296 else if (t.getType() == RPAREN)
297 ;
298 else
299
300 selector.append(t);
301 }
302 public boolean invalid() {
303 return selector != null ? selector.invalid() : true;
304 }
305 @Override
306 public String toString() {
307 String s = super.toString();
308 if (selector != null) {
309 s += selector.toString();
310 s += ")";
311 }
312 return s;
313 }
314 }
315 private static class SelectorPart extends StringBuilder {}
316 private static class PseudoElement extends SelectorPart {}
317 private static class PseudoClass extends SelectorPart {}
318
319
320
321
322
323 public final void start() throws RecognitionException {
324 try {
325
326
327 {
328 pushFollow(FOLLOW_stylesheet_in_start48);
329 stylesheet();
330 state._fsp--;
331
332 }
333
334 }
335 catch (RecognitionException re) {
336 reportError(re);
337 recover(input,re);
338 }
339 finally {
340
341 }
342 }
343
344
345
346 protected static class stylesheet_scope {
347 StringBuilder sb;
348 }
349 protected Stack<stylesheet_scope> stylesheet_stack = new Stack<stylesheet_scope>();
350
351
352
353
354 public final String stylesheet() throws RecognitionException {
355 stylesheet_stack.push(new stylesheet_scope());
356 String str = null;
357
358
359 Token t=null;
360 SelectorRule r =null;
361
362
363 stylesheet_stack.peek().sb = new StringBuilder();
364
365 try {
366
367
368 {
369
370 loop1:
371 while (true) {
372 int alt1=6;
373 switch ( input.LA(1) ) {
374 case SPACE:
375 case XML_COMMENT_CLOSE:
376 case XML_COMMENT_OPEN:
377 {
378 alt1=1;
379 }
380 break;
381 case COMMENT:
382 {
383 alt1=2;
384 }
385 break;
386 case MEDIA:
387 {
388 alt1=3;
389 }
390 break;
391 case AT:
392 {
393 alt1=4;
394 }
395 break;
396 case ASTERISK:
397 case BAR:
398 case COLON:
399 case HAS:
400 case HASH:
401 case IDENT:
402 case LBRACE:
403 case NOT:
404 case PERIOD:
405 {
406 alt1=5;
407 }
408 break;
409 }
410 switch (alt1) {
411 case 1 :
412
413 {
414 t=input.LT(1);
415 if ( input.LA(1)==SPACE||(input.LA(1) >= XML_COMMENT_CLOSE && input.LA(1) <= XML_COMMENT_OPEN) ) {
416 input.consume();
417 state.errorRecovery=false;
418 }
419 else {
420 MismatchedSetException mse = new MismatchedSetException(null,input);
421 throw mse;
422 }
423 stylesheet_stack.peek().sb.append(t);
424 }
425 break;
426 case 2 :
427
428 {
429 t=(Token)match(input,COMMENT,FOLLOW_COMMENT_in_stylesheet126);
430 stylesheet_stack.peek().sb.append(t);
431 }
432 break;
433 case 3 :
434
435 {
436 pushFollow(FOLLOW_media_rule_in_stylesheet150);
437 media_rule();
438 state._fsp--;
439
440 }
441 break;
442 case 4 :
443
444 {
445 pushFollow(FOLLOW_at_rule_in_stylesheet160);
446 at_rule();
447 state._fsp--;
448
449 }
450 break;
451 case 5 :
452
453 {
454
455
456 {
457 pushFollow(FOLLOW_selector_rule_in_stylesheet174);
458 r=selector_rule();
459 state._fsp--;
460
461 if (!r.invalid())
462 stylesheet_stack.peek().sb.append(r);
463 }
464
465 }
466 break;
467
468 default :
469 break loop1;
470 }
471 }
472
473 }
474
475
476 str = stylesheet_stack.peek().sb.toString();
477
478 }
479 catch (RecognitionException re) {
480 reportError(re);
481 recover(input,re);
482 }
483 finally {
484
485 stylesheet_stack.pop();
486 }
487 return str;
488 }
489
490
491
492
493
494
495 public final void at_rule() throws RecognitionException {
496 Token t=null;
497
498 try {
499
500
501 {
502
503
504 {
505 t=(Token)match(input,AT,FOLLOW_AT_in_at_rule212);
506 stylesheet_stack.peek().sb.append(t);
507 }
508
509
510 int cnt2=0;
511 loop2:
512 while (true) {
513 int alt2=2;
514 int LA2_0 = input.LA(1);
515 if ( ((LA2_0 >= ANY && LA2_0 <= LBRACE)||(LA2_0 >= LPAREN && LA2_0 <= RPAREN)||(LA2_0 >= SPACE && LA2_0 <= XML_COMMENT_OPEN)) ) {
516 alt2=1;
517 }
518
519 switch (alt2) {
520 case 1 :
521
522 {
523 t=input.LT(1);
524 if ( (input.LA(1) >= ANY && input.LA(1) <= LBRACE)||(input.LA(1) >= LPAREN && input.LA(1) <= RPAREN)||(input.LA(1) >= SPACE && input.LA(1) <= XML_COMMENT_OPEN) ) {
525 input.consume();
526 state.errorRecovery=false;
527 }
528 else {
529 MismatchedSetException mse = new MismatchedSetException(null,input);
530 throw mse;
531 }
532 stylesheet_stack.peek().sb.append(t);
533 }
534 break;
535
536 default :
537 if ( cnt2 >= 1 ) break loop2;
538 EarlyExitException eee = new EarlyExitException(2, input);
539 throw eee;
540 }
541 cnt2++;
542 }
543
544
545 int alt4=2;
546 int LA4_0 = input.LA(1);
547 if ( (LA4_0==SEMICOLON) ) {
548 alt4=1;
549 }
550 else if ( (LA4_0==LCURLY) ) {
551 alt4=2;
552 }
553
554 else {
555 NoViableAltException nvae =
556 new NoViableAltException("", 4, 0, input);
557 throw nvae;
558 }
559
560 switch (alt4) {
561 case 1 :
562
563 {
564
565
566 {
567 t=(Token)match(input,SEMICOLON,FOLLOW_SEMICOLON_in_at_rule291);
568 stylesheet_stack.peek().sb.append(t);
569 }
570
571 }
572 break;
573 case 2 :
574
575 {
576
577
578 {
579 t=(Token)match(input,LCURLY,FOLLOW_LCURLY_in_at_rule318);
580 stylesheet_stack.peek().sb.append(t);
581 }
582
583
584 loop3:
585 while (true) {
586 int alt3=3;
587 int LA3_0 = input.LA(1);
588 if ( (LA3_0==AT) ) {
589 alt3=1;
590 }
591 else if ( ((LA3_0 >= ANY && LA3_0 <= ASTERISK)||(LA3_0 >= BAR && LA3_0 <= RBRACE)||(LA3_0 >= RPAREN && LA3_0 <= XML_COMMENT_OPEN)) ) {
592 alt3=2;
593 }
594
595 switch (alt3) {
596 case 1 :
597
598 {
599 pushFollow(FOLLOW_at_rule_in_at_rule346);
600 at_rule();
601 state._fsp--;
602
603 }
604 break;
605 case 2 :
606
607 {
608
609
610 {
611 t=input.LT(1);
612 if ( (input.LA(1) >= ANY && input.LA(1) <= ASTERISK)||(input.LA(1) >= BAR && input.LA(1) <= RBRACE)||(input.LA(1) >= RPAREN && input.LA(1) <= XML_COMMENT_OPEN) ) {
613 input.consume();
614 state.errorRecovery=false;
615 }
616 else {
617 MismatchedSetException mse = new MismatchedSetException(null,input);
618 throw mse;
619 }
620 stylesheet_stack.peek().sb.append(t);
621 }
622
623 }
624 break;
625
626 default :
627 break loop3;
628 }
629 }
630
631
632
633 {
634 t=(Token)match(input,RCURLY,FOLLOW_RCURLY_in_at_rule420);
635 stylesheet_stack.peek().sb.append(t);
636 }
637
638 }
639 break;
640
641 }
642
643 }
644
645 }
646 catch (RecognitionException re) {
647 reportError(re);
648 recover(input,re);
649 }
650 finally {
651
652 }
653 }
654
655
656
657
658
659
660 public final void media_rule() throws RecognitionException {
661 Token t=null;
662 String s =null;
663
664 try {
665
666
667 {
668
669
670 {
671 t=(Token)match(input,MEDIA,FOLLOW_MEDIA_in_media_rule466);
672 stylesheet_stack.peek().sb.append(t);
673 }
674
675
676 int cnt5=0;
677 loop5:
678 while (true) {
679 int alt5=2;
680 int LA5_0 = input.LA(1);
681 if ( ((LA5_0 >= ANY && LA5_0 <= LBRACE)||(LA5_0 >= LPAREN && LA5_0 <= XML_COMMENT_OPEN)) ) {
682 alt5=1;
683 }
684
685 switch (alt5) {
686 case 1 :
687
688 {
689 t=input.LT(1);
690 if ( (input.LA(1) >= ANY && input.LA(1) <= LBRACE)||(input.LA(1) >= LPAREN && input.LA(1) <= XML_COMMENT_OPEN) ) {
691 input.consume();
692 state.errorRecovery=false;
693 }
694 else {
695 MismatchedSetException mse = new MismatchedSetException(null,input);
696 throw mse;
697 }
698 stylesheet_stack.peek().sb.append(t);
699 }
700 break;
701
702 default :
703 if ( cnt5 >= 1 ) break loop5;
704 EarlyExitException eee = new EarlyExitException(5, input);
705 throw eee;
706 }
707 cnt5++;
708 }
709
710
711
712 {
713 t=(Token)match(input,LCURLY,FOLLOW_LCURLY_in_media_rule528);
714 stylesheet_stack.peek().sb.append(t);
715 }
716
717
718
719 {
720 pushFollow(FOLLOW_stylesheet_in_media_rule558);
721 s=stylesheet();
722 state._fsp--;
723
724 stylesheet_stack.peek().sb.append(s);
725 }
726
727
728
729 {
730 t=(Token)match(input,RCURLY,FOLLOW_RCURLY_in_media_rule584);
731 stylesheet_stack.peek().sb.append(t);
732 }
733
734 }
735
736 }
737 catch (RecognitionException re) {
738 reportError(re);
739 recover(input,re);
740 }
741 finally {
742
743 }
744 }
745
746
747
748
749
750
751 public final SelectorRule selector_rule() throws RecognitionException {
752 SelectorRule rule = null;
753
754
755 Token t=null;
756 SelectorGroup s =null;
757
758
759 rule = new SelectorRule();
760
761 try {
762
763
764 {
765
766
767 {
768 pushFollow(FOLLOW_selector_group_in_selector_rule631);
769 s=selector_group();
770 state._fsp--;
771
772 rule.append(s);
773 }
774
775
776
777 {
778 t=(Token)match(input,LCURLY,FOLLOW_LCURLY_in_selector_rule651);
779 rule.append(t);
780 }
781
782
783 loop6:
784 while (true) {
785 int alt6=2;
786 int LA6_0 = input.LA(1);
787 if ( ((LA6_0 >= ANY && LA6_0 <= RBRACE)||(LA6_0 >= RPAREN && LA6_0 <= XML_COMMENT_OPEN)) ) {
788 alt6=1;
789 }
790
791 switch (alt6) {
792 case 1 :
793
794 {
795 t=input.LT(1);
796 if ( (input.LA(1) >= ANY && input.LA(1) <= RBRACE)||(input.LA(1) >= RPAREN && input.LA(1) <= XML_COMMENT_OPEN) ) {
797 input.consume();
798 state.errorRecovery=false;
799 }
800 else {
801 MismatchedSetException mse = new MismatchedSetException(null,input);
802 throw mse;
803 }
804 rule.append(t);
805 }
806 break;
807
808 default :
809 break loop6;
810 }
811 }
812
813
814
815 {
816 t=(Token)match(input,RCURLY,FOLLOW_RCURLY_in_selector_rule708);
817 rule.append(t);
818 }
819
820 }
821
822 }
823 catch (RecognitionException re) {
824 reportError(re);
825 recover(input,re);
826 }
827 finally {
828
829 }
830 return rule;
831 }
832
833
834
835
836
837
838 public final SelectorGroup selector_group() throws RecognitionException {
839 SelectorGroup sel = null;
840
841
842 Token t=null;
843 Selector s =null;
844
845
846 sel = new SelectorGroup();
847
848 try {
849
850
851 {
852
853
854 {
855 pushFollow(FOLLOW_selector_in_selector_group754);
856 s=selector();
857 state._fsp--;
858
859 sel.append(s);
860 }
861
862
863 loop8:
864 while (true) {
865 int alt8=2;
866 int LA8_0 = input.LA(1);
867 if ( (LA8_0==COMMA) ) {
868 alt8=1;
869 }
870
871 switch (alt8) {
872 case 1 :
873
874 {
875
876
877 {
878 t=(Token)match(input,COMMA,FOLLOW_COMMA_in_selector_group782);
879 sel.append(t);
880 }
881
882
883 int alt7=2;
884 int LA7_0 = input.LA(1);
885 if ( (LA7_0==SPACE) ) {
886 alt7=1;
887 }
888 switch (alt7) {
889 case 1 :
890
891 {
892 t=(Token)match(input,SPACE,FOLLOW_SPACE_in_selector_group811);
893 sel.append(t);
894 }
895 break;
896
897 }
898
899
900
901 {
902 pushFollow(FOLLOW_selector_in_selector_group841);
903 s=selector();
904 state._fsp--;
905
906 sel.append(s);
907 }
908
909 }
910 break;
911
912 default :
913 break loop8;
914 }
915 }
916
917 }
918
919 }
920 catch (RecognitionException re) {
921 reportError(re);
922 recover(input,re);
923 }
924 finally {
925
926 }
927 return sel;
928 }
929
930
931
932
933
934
935 public final Selector selector() throws RecognitionException {
936 Selector sel = null;
937
938
939 SimpleSelector s =null;
940 Combinator c =null;
941
942
943 sel = new Selector();
944
945 try {
946
947
948 {
949
950
951 {
952 pushFollow(FOLLOW_simple_selector_in_selector894);
953 s=simple_selector();
954 state._fsp--;
955
956 sel.append(s);
957 }
958
959
960 loop9:
961 while (true) {
962 int alt9=2;
963 int LA9_0 = input.LA(1);
964 if ( (LA9_0==GREATER||LA9_0==PLUS||LA9_0==SPACE||LA9_0==TILDE) ) {
965 alt9=1;
966 }
967
968 switch (alt9) {
969 case 1 :
970
971 {
972
973
974 {
975 pushFollow(FOLLOW_combinator_in_selector915);
976 c=combinator();
977 state._fsp--;
978
979 sel.append(c);
980 }
981
982
983
984 {
985 pushFollow(FOLLOW_simple_selector_in_selector939);
986 s=simple_selector();
987 state._fsp--;
988
989 sel.append(s);
990 }
991
992 }
993 break;
994
995 default :
996 break loop9;
997 }
998 }
999
1000 }
1001
1002 }
1003 catch (RecognitionException re) {
1004 reportError(re);
1005 recover(input,re);
1006 }
1007 finally {
1008
1009 }
1010 return sel;
1011 }
1012
1013
1014
1015
1016
1017
1018 public final Combinator combinator() throws RecognitionException {
1019 Combinator c = null;
1020
1021
1022 Token t=null;
1023
1024 try {
1025
1026 int alt11=2;
1027 int LA11_0 = input.LA(1);
1028 if ( (LA11_0==GREATER||LA11_0==PLUS||LA11_0==TILDE) ) {
1029 alt11=1;
1030 }
1031 else if ( (LA11_0==SPACE) ) {
1032 alt11=2;
1033 }
1034
1035 else {
1036 NoViableAltException nvae =
1037 new NoViableAltException("", 11, 0, input);
1038 throw nvae;
1039 }
1040
1041 switch (alt11) {
1042 case 1 :
1043
1044 {
1045
1046
1047 {
1048 t=input.LT(1);
1049 if ( input.LA(1)==GREATER||input.LA(1)==PLUS||input.LA(1)==TILDE ) {
1050 input.consume();
1051 state.errorRecovery=false;
1052 }
1053 else {
1054 MismatchedSetException mse = new MismatchedSetException(null,input);
1055 throw mse;
1056 }
1057 c = new Combinator(t);
1058 }
1059
1060
1061 int alt10=2;
1062 int LA10_0 = input.LA(1);
1063 if ( (LA10_0==SPACE) ) {
1064 alt10=1;
1065 }
1066 switch (alt10) {
1067 case 1 :
1068
1069 {
1070 t=(Token)match(input,SPACE,FOLLOW_SPACE_in_combinator1035);
1071 c.append(t);
1072 }
1073 break;
1074
1075 }
1076
1077 }
1078 break;
1079 case 2 :
1080
1081 {
1082
1083
1084 {
1085 t=(Token)match(input,SPACE,FOLLOW_SPACE_in_combinator1065);
1086 c = new Combinator(t);
1087 }
1088
1089 }
1090 break;
1091
1092 }
1093 }
1094 catch (RecognitionException re) {
1095 reportError(re);
1096 recover(input,re);
1097 }
1098 finally {
1099
1100 }
1101 return c;
1102 }
1103
1104
1105
1106
1107
1108
1109 public final RelativeSelector relative_selector() throws RecognitionException {
1110 RelativeSelector sel = null;
1111
1112
1113 Token t=null;
1114 Selector s =null;
1115
1116
1117 sel = new RelativeSelector();
1118 Combinator c = null;
1119
1120 try {
1121
1122
1123 {
1124
1125 int alt13=2;
1126 int LA13_0 = input.LA(1);
1127 if ( (LA13_0==GREATER||LA13_0==PLUS||LA13_0==TILDE) ) {
1128 alt13=1;
1129 }
1130 switch (alt13) {
1131 case 1 :
1132
1133 {
1134
1135
1136 {
1137 t=input.LT(1);
1138 if ( input.LA(1)==GREATER||input.LA(1)==PLUS||input.LA(1)==TILDE ) {
1139 input.consume();
1140 state.errorRecovery=false;
1141 }
1142 else {
1143 MismatchedSetException mse = new MismatchedSetException(null,input);
1144 throw mse;
1145 }
1146 c = new Combinator(t);
1147 }
1148
1149
1150 int alt12=2;
1151 int LA12_0 = input.LA(1);
1152 if ( (LA12_0==SPACE) ) {
1153 alt12=1;
1154 }
1155 switch (alt12) {
1156 case 1 :
1157
1158 {
1159 t=(Token)match(input,SPACE,FOLLOW_SPACE_in_relative_selector1173);
1160 c.append(t);
1161 }
1162 break;
1163
1164 }
1165
1166 }
1167 break;
1168
1169 }
1170
1171
1172
1173 {
1174 pushFollow(FOLLOW_selector_in_relative_selector1212);
1175 s=selector();
1176 state._fsp--;
1177
1178 if (c == null)
1179 c = new Combinator(SPACE);
1180 sel.append(c);
1181 sel.append(s);
1182 }
1183
1184 }
1185
1186 }
1187 catch (RecognitionException re) {
1188 reportError(re);
1189 recover(input,re);
1190 }
1191 finally {
1192
1193 }
1194 return sel;
1195 }
1196
1197
1198
1199
1200
1201
1202 public final SimpleSelector simple_selector() throws RecognitionException {
1203 SimpleSelector sel = null;
1204
1205
1206 Token t=null;
1207 SelectorPart s =null;
1208
1209
1210 sel = new SimpleSelector();
1211
1212 try {
1213
1214
1215 {
1216
1217 int alt16=2;
1218 int LA16_0 = input.LA(1);
1219 if ( (LA16_0==ASTERISK||LA16_0==BAR||LA16_0==IDENT) ) {
1220 alt16=1;
1221 }
1222 else if ( (LA16_0==COLON||(LA16_0 >= HAS && LA16_0 <= HASH)||LA16_0==LBRACE||(LA16_0 >= NOT && LA16_0 <= PERIOD)) ) {
1223 alt16=2;
1224 }
1225
1226 else {
1227 NoViableAltException nvae =
1228 new NoViableAltException("", 16, 0, input);
1229 throw nvae;
1230 }
1231
1232 switch (alt16) {
1233 case 1 :
1234
1235 {
1236
1237
1238 {
1239 pushFollow(FOLLOW_type_selector_in_simple_selector1258);
1240 s=type_selector();
1241 state._fsp--;
1242
1243 sel.append(s);
1244 }
1245
1246
1247 loop14:
1248 while (true) {
1249 int alt14=2;
1250 int LA14_0 = input.LA(1);
1251 if ( (LA14_0==COLON||(LA14_0 >= HAS && LA14_0 <= HASH)||LA14_0==LBRACE||(LA14_0 >= NOT && LA14_0 <= PERIOD)) ) {
1252 alt14=1;
1253 }
1254
1255 switch (alt14) {
1256 case 1 :
1257
1258 {
1259 pushFollow(FOLLOW_selector_part_in_simple_selector1279);
1260 s=selector_part();
1261 state._fsp--;
1262
1263 sel.append(s);
1264 }
1265 break;
1266
1267 default :
1268 break loop14;
1269 }
1270 }
1271
1272 }
1273 break;
1274 case 2 :
1275
1276 {
1277
1278 int cnt15=0;
1279 loop15:
1280 while (true) {
1281 int alt15=2;
1282 int LA15_0 = input.LA(1);
1283 if ( (LA15_0==COLON||(LA15_0 >= HAS && LA15_0 <= HASH)||LA15_0==LBRACE||(LA15_0 >= NOT && LA15_0 <= PERIOD)) ) {
1284 alt15=1;
1285 }
1286
1287 switch (alt15) {
1288 case 1 :
1289
1290 {
1291 pushFollow(FOLLOW_selector_part_in_simple_selector1301);
1292 s=selector_part();
1293 state._fsp--;
1294
1295 sel.append(s);
1296 }
1297 break;
1298
1299 default :
1300 if ( cnt15 >= 1 ) break loop15;
1301 EarlyExitException eee = new EarlyExitException(15, input);
1302 throw eee;
1303 }
1304 cnt15++;
1305 }
1306
1307 }
1308 break;
1309
1310 }
1311
1312
1313 int alt17=2;
1314 int LA17_0 = input.LA(1);
1315 if ( (LA17_0==SPACE) ) {
1316 int LA17_1 = input.LA(2);
1317 if ( (LA17_1==COMMA||LA17_1==GREATER||LA17_1==LCURLY||LA17_1==PLUS||LA17_1==RPAREN||LA17_1==SPACE||LA17_1==TILDE) ) {
1318 alt17=1;
1319 }
1320 }
1321 switch (alt17) {
1322 case 1 :
1323
1324 {
1325 t=(Token)match(input,SPACE,FOLLOW_SPACE_in_simple_selector1329);
1326 sel.append(t);
1327 }
1328 break;
1329
1330 }
1331
1332 }
1333
1334 }
1335 catch (RecognitionException re) {
1336 reportError(re);
1337 recover(input,re);
1338 }
1339 finally {
1340
1341 }
1342 return sel;
1343 }
1344
1345
1346
1347
1348
1349
1350 public final SelectorPart selector_part() throws RecognitionException {
1351 SelectorPart sel = null;
1352
1353
1354 SelectorPart s =null;
1355
1356 try {
1357
1358 int alt18=5;
1359 switch ( input.LA(1) ) {
1360 case HASH:
1361 {
1362 alt18=1;
1363 }
1364 break;
1365 case PERIOD:
1366 {
1367 alt18=2;
1368 }
1369 break;
1370 case LBRACE:
1371 {
1372 alt18=3;
1373 }
1374 break;
1375 case COLON:
1376 {
1377 int LA18_4 = input.LA(2);
1378 if ( (LA18_4==COLON) ) {
1379 alt18=4;
1380 }
1381 else if ( (LA18_4==IDENT||LA18_4==NAME) ) {
1382 alt18=5;
1383 }
1384
1385 else {
1386 int nvaeMark = input.mark();
1387 try {
1388 input.consume();
1389 NoViableAltException nvae =
1390 new NoViableAltException("", 18, 4, input);
1391 throw nvae;
1392 } finally {
1393 input.rewind(nvaeMark);
1394 }
1395 }
1396
1397 }
1398 break;
1399 case HAS:
1400 case NOT:
1401 {
1402 alt18=5;
1403 }
1404 break;
1405 default:
1406 NoViableAltException nvae =
1407 new NoViableAltException("", 18, 0, input);
1408 throw nvae;
1409 }
1410 switch (alt18) {
1411 case 1 :
1412
1413 {
1414
1415
1416 {
1417 pushFollow(FOLLOW_id_selector_in_selector_part1372);
1418 s=id_selector();
1419 state._fsp--;
1420
1421 sel = s;
1422 }
1423
1424 }
1425 break;
1426 case 2 :
1427
1428 {
1429
1430
1431 {
1432 pushFollow(FOLLOW_class_selector_in_selector_part1395);
1433 s=class_selector();
1434 state._fsp--;
1435
1436 sel = s;
1437 }
1438
1439 }
1440 break;
1441 case 3 :
1442
1443 {
1444
1445
1446 {
1447 pushFollow(FOLLOW_attribute_selector_in_selector_part1415);
1448 s=attribute_selector();
1449 state._fsp--;
1450
1451 sel = s;
1452 }
1453
1454 }
1455 break;
1456 case 4 :
1457
1458 {
1459
1460
1461 {
1462 pushFollow(FOLLOW_pseudo_element_in_selector_part1431);
1463 s=pseudo_element();
1464 state._fsp--;
1465
1466 sel = s;
1467 }
1468
1469 }
1470 break;
1471 case 5 :
1472
1473 {
1474
1475
1476 {
1477 pushFollow(FOLLOW_pseudo_class_in_selector_part1451);
1478 s=pseudo_class();
1479 state._fsp--;
1480
1481 sel = s;
1482 }
1483
1484 }
1485 break;
1486
1487 }
1488 }
1489 catch (RecognitionException re) {
1490 reportError(re);
1491 recover(input,re);
1492 }
1493 finally {
1494
1495 }
1496 return sel;
1497 }
1498
1499
1500
1501
1502
1503
1504 public final SelectorPart type_selector() throws RecognitionException {
1505 SelectorPart sel = null;
1506
1507
1508 Token t=null;
1509
1510
1511 sel = new SelectorPart();
1512
1513 try {
1514
1515
1516 {
1517
1518 int alt19=2;
1519 int LA19_0 = input.LA(1);
1520 if ( (LA19_0==ASTERISK||LA19_0==IDENT) ) {
1521 int LA19_1 = input.LA(2);
1522 if ( (LA19_1==BAR) ) {
1523 alt19=1;
1524 }
1525 }
1526 else if ( (LA19_0==BAR) ) {
1527 alt19=1;
1528 }
1529 switch (alt19) {
1530 case 1 :
1531
1532 {
1533 pushFollow(FOLLOW_prefix_in_type_selector1487);
1534 prefix();
1535 state._fsp--;
1536
1537 }
1538 break;
1539
1540 }
1541
1542
1543
1544 {
1545 t=input.LT(1);
1546 if ( input.LA(1)==ASTERISK||input.LA(1)==IDENT ) {
1547 input.consume();
1548 state.errorRecovery=false;
1549 }
1550 else {
1551 MismatchedSetException mse = new MismatchedSetException(null,input);
1552 throw mse;
1553 }
1554 sel.append(t);
1555 }
1556
1557 }
1558
1559 }
1560 catch (RecognitionException re) {
1561 reportError(re);
1562 recover(input,re);
1563 }
1564 finally {
1565
1566 }
1567 return sel;
1568 }
1569
1570
1571
1572
1573
1574
1575 public final String prefix() throws RecognitionException {
1576 String str = null;
1577
1578
1579 Token t=null;
1580
1581
1582 StringBuilder sb = new StringBuilder();
1583
1584 try {
1585
1586
1587 {
1588
1589 int alt20=2;
1590 int LA20_0 = input.LA(1);
1591 if ( (LA20_0==ASTERISK||LA20_0==IDENT) ) {
1592 alt20=1;
1593 }
1594 switch (alt20) {
1595 case 1 :
1596
1597 {
1598 t=input.LT(1);
1599 if ( input.LA(1)==ASTERISK||input.LA(1)==IDENT ) {
1600 input.consume();
1601 state.errorRecovery=false;
1602 }
1603 else {
1604 MismatchedSetException mse = new MismatchedSetException(null,input);
1605 throw mse;
1606 }
1607 sb.append(t);
1608 }
1609 break;
1610
1611 }
1612
1613
1614
1615 {
1616 t=(Token)match(input,BAR,FOLLOW_BAR_in_prefix1595);
1617 sb.append(t);
1618 }
1619
1620 }
1621
1622
1623 str = sb.toString();
1624
1625 }
1626 catch (RecognitionException re) {
1627 reportError(re);
1628 recover(input,re);
1629 }
1630 finally {
1631
1632 }
1633 return str;
1634 }
1635
1636
1637
1638
1639
1640
1641 public final SelectorPart id_selector() throws RecognitionException {
1642 SelectorPart sel = null;
1643
1644
1645 Token t=null;
1646
1647
1648 sel = new SelectorPart();
1649
1650 try {
1651
1652
1653 {
1654
1655
1656 {
1657 t=(Token)match(input,HASH,FOLLOW_HASH_in_id_selector1643);
1658 sel.append(t);
1659 }
1660
1661
1662
1663 {
1664 t=input.LT(1);
1665 if ( input.LA(1)==IDENT||input.LA(1)==NAME ) {
1666 input.consume();
1667 state.errorRecovery=false;
1668 }
1669 else {
1670 MismatchedSetException mse = new MismatchedSetException(null,input);
1671 throw mse;
1672 }
1673 sel.append(t);
1674 }
1675
1676 }
1677
1678 }
1679 catch (RecognitionException re) {
1680 reportError(re);
1681 recover(input,re);
1682 }
1683 finally {
1684
1685 }
1686 return sel;
1687 }
1688
1689
1690
1691
1692
1693
1694 public final SelectorPart class_selector() throws RecognitionException {
1695 SelectorPart sel = null;
1696
1697
1698 Token t=null;
1699
1700
1701 sel = new SelectorPart();
1702
1703 try {
1704
1705
1706 {
1707
1708
1709 {
1710 t=(Token)match(input,PERIOD,FOLLOW_PERIOD_in_class_selector1715);
1711 sel.append(t);
1712 }
1713
1714
1715
1716 {
1717 t=(Token)match(input,IDENT,FOLLOW_IDENT_in_class_selector1742);
1718 sel.append(t);
1719 }
1720
1721 }
1722
1723 }
1724 catch (RecognitionException re) {
1725 reportError(re);
1726 recover(input,re);
1727 }
1728 finally {
1729
1730 }
1731 return sel;
1732 }
1733
1734
1735
1736
1737
1738
1739 public final SelectorPart attribute_selector() throws RecognitionException {
1740 SelectorPart sel = null;
1741
1742
1743 Token t=null;
1744
1745
1746 sel = new SelectorPart();
1747
1748 try {
1749
1750
1751 {
1752
1753
1754 {
1755 t=(Token)match(input,LBRACE,FOLLOW_LBRACE_in_attribute_selector1788);
1756 sel.append(t);
1757 }
1758
1759
1760 int cnt21=0;
1761 loop21:
1762 while (true) {
1763 int alt21=2;
1764 int LA21_0 = input.LA(1);
1765 if ( ((LA21_0 >= ANY && LA21_0 <= QUOT)||(LA21_0 >= RCURLY && LA21_0 <= XML_COMMENT_OPEN)) ) {
1766 alt21=1;
1767 }
1768
1769 switch (alt21) {
1770 case 1 :
1771
1772 {
1773 t=input.LT(1);
1774 if ( (input.LA(1) >= ANY && input.LA(1) <= QUOT)||(input.LA(1) >= RCURLY && input.LA(1) <= XML_COMMENT_OPEN) ) {
1775 input.consume();
1776 state.errorRecovery=false;
1777 }
1778 else {
1779 MismatchedSetException mse = new MismatchedSetException(null,input);
1780 throw mse;
1781 }
1782 sel.append(t);
1783 }
1784 break;
1785
1786 default :
1787 if ( cnt21 >= 1 ) break loop21;
1788 EarlyExitException eee = new EarlyExitException(21, input);
1789 throw eee;
1790 }
1791 cnt21++;
1792 }
1793
1794
1795
1796 {
1797 t=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_attribute_selector1843);
1798 sel.append(t);
1799 }
1800
1801 }
1802
1803 }
1804 catch (RecognitionException re) {
1805 reportError(re);
1806 recover(input,re);
1807 }
1808 finally {
1809
1810 }
1811 return sel;
1812 }
1813
1814
1815
1816
1817
1818
1819 public final SelectorPart pseudo_element() throws RecognitionException {
1820 SelectorPart sel = null;
1821
1822
1823 Token t=null;
1824
1825
1826 sel = new PseudoElement();
1827
1828 try {
1829
1830
1831 {
1832
1833
1834 {
1835 t=(Token)match(input,COLON,FOLLOW_COLON_in_pseudo_element1888);
1836 sel.append(t);
1837 }
1838
1839
1840
1841 {
1842 t=(Token)match(input,COLON,FOLLOW_COLON_in_pseudo_element1916);
1843 sel.append(t);
1844 }
1845
1846
1847
1848 {
1849 t=input.LT(1);
1850 if ( input.LA(1)==IDENT||input.LA(1)==NAME ) {
1851 input.consume();
1852 state.errorRecovery=false;
1853 }
1854 else {
1855 MismatchedSetException mse = new MismatchedSetException(null,input);
1856 throw mse;
1857 }
1858 sel.append(t);
1859 }
1860
1861
1862 int alt23=2;
1863 int LA23_0 = input.LA(1);
1864 if ( (LA23_0==LPAREN) ) {
1865 alt23=1;
1866 }
1867 switch (alt23) {
1868 case 1 :
1869
1870 {
1871
1872
1873 {
1874 t=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_pseudo_element1971);
1875 sel.append(t);
1876 }
1877
1878
1879 loop22:
1880 while (true) {
1881 int alt22=2;
1882 int LA22_0 = input.LA(1);
1883 if ( ((LA22_0 >= ANY && LA22_0 <= RCURLY)||(LA22_0 >= SEMICOLON && LA22_0 <= XML_COMMENT_OPEN)) ) {
1884 alt22=1;
1885 }
1886
1887 switch (alt22) {
1888 case 1 :
1889
1890 {
1891 t=input.LT(1);
1892 if ( (input.LA(1) >= ANY && input.LA(1) <= RCURLY)||(input.LA(1) >= SEMICOLON && input.LA(1) <= XML_COMMENT_OPEN) ) {
1893 input.consume();
1894 state.errorRecovery=false;
1895 }
1896 else {
1897 MismatchedSetException mse = new MismatchedSetException(null,input);
1898 throw mse;
1899 }
1900 sel.append(t);
1901 }
1902 break;
1903
1904 default :
1905 break loop22;
1906 }
1907 }
1908
1909
1910
1911 {
1912 t=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_pseudo_element2026);
1913 sel.append(t);
1914 }
1915
1916 }
1917 break;
1918
1919 }
1920
1921 }
1922
1923 }
1924 catch (RecognitionException re) {
1925 reportError(re);
1926 recover(input,re);
1927 }
1928 finally {
1929
1930 }
1931 return sel;
1932 }
1933
1934
1935
1936
1937
1938
1939 public final SelectorPart pseudo_class() throws RecognitionException {
1940 SelectorPart sel = null;
1941
1942
1943 Token t=null;
1944 NegationSelector ns =null;
1945 RelationalSelector rs =null;
1946
1947
1948 sel = new PseudoClass();
1949
1950 try {
1951
1952 int alt26=3;
1953 switch ( input.LA(1) ) {
1954 case NOT:
1955 {
1956 alt26=1;
1957 }
1958 break;
1959 case HAS:
1960 {
1961 alt26=2;
1962 }
1963 break;
1964 case COLON:
1965 {
1966 alt26=3;
1967 }
1968 break;
1969 default:
1970 NoViableAltException nvae =
1971 new NoViableAltException("", 26, 0, input);
1972 throw nvae;
1973 }
1974 switch (alt26) {
1975 case 1 :
1976
1977 {
1978
1979
1980 {
1981 pushFollow(FOLLOW_negation_selector_in_pseudo_class2080);
1982 ns=negation_selector();
1983 state._fsp--;
1984
1985 sel = ns;
1986 }
1987
1988 }
1989 break;
1990 case 2 :
1991
1992 {
1993
1994
1995 {
1996 pushFollow(FOLLOW_relational_selector_in_pseudo_class2099);
1997 rs=relational_selector();
1998 state._fsp--;
1999
2000 sel = rs;
2001 }
2002
2003 }
2004 break;
2005 case 3 :
2006
2007 {
2008
2009
2010 {
2011 t=(Token)match(input,COLON,FOLLOW_COLON_in_pseudo_class2116);
2012 sel.append(t);
2013 }
2014
2015
2016
2017 {
2018 t=input.LT(1);
2019 if ( input.LA(1)==IDENT||input.LA(1)==NAME ) {
2020 input.consume();
2021 state.errorRecovery=false;
2022 }
2023 else {
2024 MismatchedSetException mse = new MismatchedSetException(null,input);
2025 throw mse;
2026 }
2027 sel.append(t);
2028 }
2029
2030
2031 int alt25=2;
2032 int LA25_0 = input.LA(1);
2033 if ( (LA25_0==LPAREN) ) {
2034 alt25=1;
2035 }
2036 switch (alt25) {
2037 case 1 :
2038
2039 {
2040
2041
2042 {
2043 t=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_pseudo_class2179);
2044 sel.append(t);
2045 }
2046
2047
2048 loop24:
2049 while (true) {
2050 int alt24=2;
2051 int LA24_0 = input.LA(1);
2052 if ( ((LA24_0 >= ANY && LA24_0 <= RCURLY)||(LA24_0 >= SEMICOLON && LA24_0 <= XML_COMMENT_OPEN)) ) {
2053 alt24=1;
2054 }
2055
2056 switch (alt24) {
2057 case 1 :
2058
2059 {
2060 t=input.LT(1);
2061 if ( (input.LA(1) >= ANY && input.LA(1) <= RCURLY)||(input.LA(1) >= SEMICOLON && input.LA(1) <= XML_COMMENT_OPEN) ) {
2062 input.consume();
2063 state.errorRecovery=false;
2064 }
2065 else {
2066 MismatchedSetException mse = new MismatchedSetException(null,input);
2067 throw mse;
2068 }
2069 sel.append(t);
2070 }
2071 break;
2072
2073 default :
2074 break loop24;
2075 }
2076 }
2077
2078
2079
2080 {
2081 t=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_pseudo_class2242);
2082 sel.append(t);
2083 }
2084
2085 }
2086 break;
2087
2088 }
2089
2090 }
2091 break;
2092
2093 }
2094 }
2095 catch (RecognitionException re) {
2096 reportError(re);
2097 recover(input,re);
2098 }
2099 finally {
2100
2101 }
2102 return sel;
2103 }
2104
2105
2106
2107
2108
2109
2110 public final NegationSelector negation_selector() throws RecognitionException {
2111 NegationSelector sel = null;
2112
2113
2114 Token t=null;
2115 SimpleSelector s =null;
2116
2117
2118 sel = new NegationSelector();
2119
2120 try {
2121
2122
2123 {
2124
2125
2126 {
2127 t=(Token)match(input,NOT,FOLLOW_NOT_in_negation_selector2300);
2128 sel.append(t);
2129 }
2130
2131
2132 int alt27=2;
2133 int LA27_0 = input.LA(1);
2134 if ( (LA27_0==SPACE) ) {
2135 alt27=1;
2136 }
2137 switch (alt27) {
2138 case 1 :
2139
2140 {
2141 t=(Token)match(input,SPACE,FOLLOW_SPACE_in_negation_selector2332);
2142 sel.append(t);
2143 }
2144 break;
2145
2146 }
2147
2148
2149
2150 {
2151 pushFollow(FOLLOW_simple_selector_in_negation_selector2363);
2152 s=simple_selector();
2153 state._fsp--;
2154
2155 sel.append(s);
2156 }
2157
2158
2159 loop29:
2160 while (true) {
2161 int alt29=2;
2162 int LA29_0 = input.LA(1);
2163 if ( (LA29_0==COMMA) ) {
2164 alt29=1;
2165 }
2166
2167 switch (alt29) {
2168 case 1 :
2169
2170 {
2171
2172
2173 {
2174 t=(Token)match(input,COMMA,FOLLOW_COMMA_in_negation_selector2385);
2175 sel.append(t);
2176 }
2177
2178
2179 int alt28=2;
2180 int LA28_0 = input.LA(1);
2181 if ( (LA28_0==SPACE) ) {
2182 alt28=1;
2183 }
2184 switch (alt28) {
2185 case 1 :
2186
2187 {
2188 t=(Token)match(input,SPACE,FOLLOW_SPACE_in_negation_selector2415);
2189 sel.append(t);
2190 }
2191 break;
2192
2193 }
2194
2195
2196
2197 {
2198 pushFollow(FOLLOW_simple_selector_in_negation_selector2446);
2199 s=simple_selector();
2200 state._fsp--;
2201
2202 sel.append(s);
2203 }
2204
2205 }
2206 break;
2207
2208 default :
2209 break loop29;
2210 }
2211 }
2212
2213
2214
2215 {
2216 t=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_negation_selector2475);
2217 sel.append(t);
2218 }
2219
2220 }
2221
2222 }
2223 catch (RecognitionException re) {
2224 reportError(re);
2225 recover(input,re);
2226 }
2227 finally {
2228
2229 }
2230 return sel;
2231 }
2232
2233
2234
2235
2236
2237
2238 public final RelationalSelector relational_selector() throws RecognitionException {
2239 RelationalSelector sel = null;
2240
2241
2242 Token t=null;
2243 RelativeSelector s =null;
2244
2245
2246 sel = new RelationalSelector();
2247
2248 try {
2249
2250
2251 {
2252
2253
2254 {
2255 t=(Token)match(input,HAS,FOLLOW_HAS_in_relational_selector2522);
2256 sel.append(t);
2257 }
2258
2259
2260 int alt30=2;
2261 int LA30_0 = input.LA(1);
2262 if ( (LA30_0==SPACE) ) {
2263 alt30=1;
2264 }
2265 switch (alt30) {
2266 case 1 :
2267
2268 {
2269 t=(Token)match(input,SPACE,FOLLOW_SPACE_in_relational_selector2554);
2270 sel.append(t);
2271 }
2272 break;
2273
2274 }
2275
2276
2277
2278 {
2279 pushFollow(FOLLOW_relative_selector_in_relational_selector2585);
2280 s=relative_selector();
2281 state._fsp--;
2282
2283 sel.append(s);
2284 }
2285
2286
2287 loop32:
2288 while (true) {
2289 int alt32=2;
2290 int LA32_0 = input.LA(1);
2291 if ( (LA32_0==COMMA) ) {
2292 alt32=1;
2293 }
2294
2295 switch (alt32) {
2296 case 1 :
2297
2298 {
2299
2300
2301 {
2302 t=(Token)match(input,COMMA,FOLLOW_COMMA_in_relational_selector2605);
2303 sel.append(t);
2304 }
2305
2306
2307 int alt31=2;
2308 int LA31_0 = input.LA(1);
2309 if ( (LA31_0==SPACE) ) {
2310 alt31=1;
2311 }
2312 switch (alt31) {
2313 case 1 :
2314
2315 {
2316 t=(Token)match(input,SPACE,FOLLOW_SPACE_in_relational_selector2635);
2317 sel.append(t);
2318 }
2319 break;
2320
2321 }
2322
2323
2324
2325 {
2326 pushFollow(FOLLOW_relative_selector_in_relational_selector2666);
2327 s=relative_selector();
2328 state._fsp--;
2329
2330 sel.append(s);
2331 }
2332
2333 }
2334 break;
2335
2336 default :
2337 break loop32;
2338 }
2339 }
2340
2341
2342
2343 {
2344 t=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_relational_selector2693);
2345 sel.append(t);
2346 }
2347
2348 }
2349
2350 }
2351 catch (RecognitionException re) {
2352 reportError(re);
2353 recover(input,re);
2354 }
2355 finally {
2356
2357 }
2358 return sel;
2359 }
2360
2361
2362
2363
2364
2365
2366 public static final BitSet FOLLOW_stylesheet_in_start48 = new BitSet(new long[]{0x0000000000000002L});
2367 public static final BitSet FOLLOW_set_in_stylesheet84 = new BitSet(new long[]{0x00000608184B8BC2L});
2368 public static final BitSet FOLLOW_COMMENT_in_stylesheet126 = new BitSet(new long[]{0x00000608184B8BC2L});
2369 public static final BitSet FOLLOW_media_rule_in_stylesheet150 = new BitSet(new long[]{0x00000608184B8BC2L});
2370 public static final BitSet FOLLOW_at_rule_in_stylesheet160 = new BitSet(new long[]{0x00000608184B8BC2L});
2371 public static final BitSet FOLLOW_selector_rule_in_stylesheet174 = new BitSet(new long[]{0x00000608184B8BC2L});
2372 public static final BitSet FOLLOW_AT_in_at_rule212 = new BitSet(new long[]{0x000007FBFFEFFFF0L});
2373 public static final BitSet FOLLOW_set_in_at_rule246 = new BitSet(new long[]{0x000007FFFFFFFFF0L});
2374 public static final BitSet FOLLOW_SEMICOLON_in_at_rule291 = new BitSet(new long[]{0x0000000000000002L});
2375 public static final BitSet FOLLOW_LCURLY_in_at_rule318 = new BitSet(new long[]{0x000007FFFFFFFFF0L});
2376 public static final BitSet FOLLOW_at_rule_in_at_rule346 = new BitSet(new long[]{0x000007FFFFFFFFF0L});
2377 public static final BitSet FOLLOW_set_in_at_rule362 = new BitSet(new long[]{0x000007FFFFFFFFF0L});
2378 public static final BitSet FOLLOW_RCURLY_in_at_rule420 = new BitSet(new long[]{0x0000000000000002L});
2379 public static final BitSet FOLLOW_MEDIA_in_media_rule466 = new BitSet(new long[]{0x000007FFFFEFFFF0L});
2380 public static final BitSet FOLLOW_set_in_media_rule497 = new BitSet(new long[]{0x000007FFFFFFFFF0L});
2381 public static final BitSet FOLLOW_LCURLY_in_media_rule528 = new BitSet(new long[]{0x00000609184B8BC0L});
2382 public static final BitSet FOLLOW_stylesheet_in_media_rule558 = new BitSet(new long[]{0x0000000100000000L});
2383 public static final BitSet FOLLOW_RCURLY_in_media_rule584 = new BitSet(new long[]{0x0000000000000002L});
2384 public static final BitSet FOLLOW_selector_group_in_selector_rule631 = new BitSet(new long[]{0x0000000000100000L});
2385 public static final BitSet FOLLOW_LCURLY_in_selector_rule651 = new BitSet(new long[]{0x000007FFFFFFFFF0L});
2386 public static final BitSet FOLLOW_set_in_selector_rule679 = new BitSet(new long[]{0x000007FFFFFFFFF0L});
2387 public static final BitSet FOLLOW_RCURLY_in_selector_rule708 = new BitSet(new long[]{0x0000000000000002L});
2388 public static final BitSet FOLLOW_selector_in_selector_group754 = new BitSet(new long[]{0x0000000000000402L});
2389 public static final BitSet FOLLOW_COMMA_in_selector_group782 = new BitSet(new long[]{0x00000008180B8340L});
2390 public static final BitSet FOLLOW_SPACE_in_selector_group811 = new BitSet(new long[]{0x00000000180B8340L});
2391 public static final BitSet FOLLOW_selector_in_selector_group841 = new BitSet(new long[]{0x0000000000000402L});
2392 public static final BitSet FOLLOW_simple_selector_in_selector894 = new BitSet(new long[]{0x0000010820004002L});
2393 public static final BitSet FOLLOW_combinator_in_selector915 = new BitSet(new long[]{0x00000000180B8340L});
2394 public static final BitSet FOLLOW_simple_selector_in_selector939 = new BitSet(new long[]{0x0000010820004002L});
2395 public static final BitSet FOLLOW_set_in_combinator980 = new BitSet(new long[]{0x0000000800000002L});
2396 public static final BitSet FOLLOW_SPACE_in_combinator1035 = new BitSet(new long[]{0x0000000000000002L});
2397 public static final BitSet FOLLOW_SPACE_in_combinator1065 = new BitSet(new long[]{0x0000000000000002L});
2398 public static final BitSet FOLLOW_set_in_relative_selector1114 = new BitSet(new long[]{0x00000008180B8340L});
2399 public static final BitSet FOLLOW_SPACE_in_relative_selector1173 = new BitSet(new long[]{0x00000000180B8340L});
2400 public static final BitSet FOLLOW_selector_in_relative_selector1212 = new BitSet(new long[]{0x0000000000000002L});
2401 public static final BitSet FOLLOW_type_selector_in_simple_selector1258 = new BitSet(new long[]{0x0000000818098202L});
2402 public static final BitSet FOLLOW_selector_part_in_simple_selector1279 = new BitSet(new long[]{0x0000000818098202L});
2403 public static final BitSet FOLLOW_selector_part_in_simple_selector1301 = new BitSet(new long[]{0x0000000818098202L});
2404 public static final BitSet FOLLOW_SPACE_in_simple_selector1329 = new BitSet(new long[]{0x0000000000000002L});
2405 public static final BitSet FOLLOW_id_selector_in_selector_part1372 = new BitSet(new long[]{0x0000000000000002L});
2406 public static final BitSet FOLLOW_class_selector_in_selector_part1395 = new BitSet(new long[]{0x0000000000000002L});
2407 public static final BitSet FOLLOW_attribute_selector_in_selector_part1415 = new BitSet(new long[]{0x0000000000000002L});
2408 public static final BitSet FOLLOW_pseudo_element_in_selector_part1431 = new BitSet(new long[]{0x0000000000000002L});
2409 public static final BitSet FOLLOW_pseudo_class_in_selector_part1451 = new BitSet(new long[]{0x0000000000000002L});
2410 public static final BitSet FOLLOW_prefix_in_type_selector1487 = new BitSet(new long[]{0x0000000000020040L});
2411 public static final BitSet FOLLOW_set_in_type_selector1494 = new BitSet(new long[]{0x0000000000000002L});
2412 public static final BitSet FOLLOW_set_in_prefix1556 = new BitSet(new long[]{0x0000000000000100L});
2413 public static final BitSet FOLLOW_BAR_in_prefix1595 = new BitSet(new long[]{0x0000000000000002L});
2414 public static final BitSet FOLLOW_HASH_in_id_selector1643 = new BitSet(new long[]{0x0000000000820000L});
2415 public static final BitSet FOLLOW_set_in_id_selector1672 = new BitSet(new long[]{0x0000000000000002L});
2416 public static final BitSet FOLLOW_PERIOD_in_class_selector1715 = new BitSet(new long[]{0x0000000000020000L});
2417 public static final BitSet FOLLOW_IDENT_in_class_selector1742 = new BitSet(new long[]{0x0000000000000002L});
2418 public static final BitSet FOLLOW_LBRACE_in_attribute_selector1788 = new BitSet(new long[]{0x000007FF7FFFFFF0L});
2419 public static final BitSet FOLLOW_set_in_attribute_selector1815 = new BitSet(new long[]{0x000007FFFFFFFFF0L});
2420 public static final BitSet FOLLOW_RBRACE_in_attribute_selector1843 = new BitSet(new long[]{0x0000000000000002L});
2421 public static final BitSet FOLLOW_COLON_in_pseudo_element1888 = new BitSet(new long[]{0x0000000000000200L});
2422 public static final BitSet FOLLOW_COLON_in_pseudo_element1916 = new BitSet(new long[]{0x0000000000820000L});
2423 public static final BitSet FOLLOW_set_in_pseudo_element1944 = new BitSet(new long[]{0x0000000000200002L});
2424 public static final BitSet FOLLOW_LPAREN_in_pseudo_element1971 = new BitSet(new long[]{0x000007FFFFFFFFF0L});
2425 public static final BitSet FOLLOW_set_in_pseudo_element1998 = new BitSet(new long[]{0x000007FFFFFFFFF0L});
2426 public static final BitSet FOLLOW_RPAREN_in_pseudo_element2026 = new BitSet(new long[]{0x0000000000000002L});
2427 public static final BitSet FOLLOW_negation_selector_in_pseudo_class2080 = new BitSet(new long[]{0x0000000000000002L});
2428 public static final BitSet FOLLOW_relational_selector_in_pseudo_class2099 = new BitSet(new long[]{0x0000000000000002L});
2429 public static final BitSet FOLLOW_COLON_in_pseudo_class2116 = new BitSet(new long[]{0x0000000000820000L});
2430 public static final BitSet FOLLOW_set_in_pseudo_class2148 = new BitSet(new long[]{0x0000000000200002L});
2431 public static final BitSet FOLLOW_LPAREN_in_pseudo_class2179 = new BitSet(new long[]{0x000007FFFFFFFFF0L});
2432 public static final BitSet FOLLOW_set_in_pseudo_class2210 = new BitSet(new long[]{0x000007FFFFFFFFF0L});
2433 public static final BitSet FOLLOW_RPAREN_in_pseudo_class2242 = new BitSet(new long[]{0x0000000000000002L});
2434 public static final BitSet FOLLOW_NOT_in_negation_selector2300 = new BitSet(new long[]{0x00000008180B8340L});
2435 public static final BitSet FOLLOW_SPACE_in_negation_selector2332 = new BitSet(new long[]{0x00000000180B8340L});
2436 public static final BitSet FOLLOW_simple_selector_in_negation_selector2363 = new BitSet(new long[]{0x0000000200000400L});
2437 public static final BitSet FOLLOW_COMMA_in_negation_selector2385 = new BitSet(new long[]{0x00000008180B8340L});
2438 public static final BitSet FOLLOW_SPACE_in_negation_selector2415 = new BitSet(new long[]{0x00000000180B8340L});
2439 public static final BitSet FOLLOW_simple_selector_in_negation_selector2446 = new BitSet(new long[]{0x0000000200000400L});
2440 public static final BitSet FOLLOW_RPAREN_in_negation_selector2475 = new BitSet(new long[]{0x0000000000000002L});
2441 public static final BitSet FOLLOW_HAS_in_relational_selector2522 = new BitSet(new long[]{0x00000108380BC340L});
2442 public static final BitSet FOLLOW_SPACE_in_relational_selector2554 = new BitSet(new long[]{0x00000100380BC340L});
2443 public static final BitSet FOLLOW_relative_selector_in_relational_selector2585 = new BitSet(new long[]{0x0000000200000400L});
2444 public static final BitSet FOLLOW_COMMA_in_relational_selector2605 = new BitSet(new long[]{0x00000108380BC340L});
2445 public static final BitSet FOLLOW_SPACE_in_relational_selector2635 = new BitSet(new long[]{0x00000100380BC340L});
2446 public static final BitSet FOLLOW_relative_selector_in_relational_selector2666 = new BitSet(new long[]{0x0000000200000400L});
2447 public static final BitSet FOLLOW_RPAREN_in_relational_selector2693 = new BitSet(new long[]{0x0000000000000002L});
2448 }