• Home
• org.apache.royale.compiler
• compiler
• 0.9.1
• source code

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

yale.compiler.compiler.0.9.1.source-code.CSSParser Maven / Gradle / Ivy

// $ANTLR 3.5.2 CSS.g 2018-02-08 10:27:25

/*
 *
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 */

package org.apache.royale.compiler.internal.css;

import java.util.Map;
import java.util.HashMap;
import org.apache.royale.compiler.problems.CSSParserProblem;


import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;

import org.antlr.runtime.tree.*;


/**
 * This is a grammar for advanced CSS in Royale. It parses the CSS document and
 * generate DOM objects.
 */
@SuppressWarnings("all")
public class CSSParser extends Parser {
	public static final String[] tokenNames = new String[] {
		"", "", "", "", "ALPHA_VALUE", "ARGUMENTS", "AT_FONT_FACE", 
		"AT_KEYFRAMES", "AT_MEDIA", "AT_NAMESPACE", "AT_WEBKIT_KEYFRAMES", "BEGINS_WITH", 
		"BLOCK_END", "BLOCK_OPEN", "CALC", "CHILD", "CLASS_REFERENCE", "COLON", 
		"COMMA", "COMMENT", "CONTAINS", "DIGIT", "DOT", "DOUBLE_COLON", "EMBED", 
		"ENDS_WITH", "EQUALS", "ESCAPED_HEX", "FORMAT", "FUNCTIONS", "HASH_WORD", 
		"HEX_DIGIT", "HREFLANG_MATCH", "ID", "IMPORTANT", "I_ARRAY", "I_CHILD_SELECTOR", 
		"I_DECL", "I_MEDIUM_CONDITIONS", "I_MULTIVALUE", "I_PRECEDED_SELECTOR", 
		"I_RULE", "I_RULES", "I_SELECTOR", "I_SELECTOR_GROUP", "I_SIBLING_SELECTOR", 
		"I_SIMPLE_SELECTOR", "LETTER", "LIST_MATCH", "LOCAL", "NOT", "NULL", "NUMBER", 
		"NUMBER_WITH_PERCENT", "NUMBER_WITH_UNIT", "ONLY", "OPERATOR", "PERCENT", 
		"PIPE", "PRECEDED", "PROPERTY_REFERENCE", "RECT_VALUE", "RGB", "RGBA", 
		"ROTATE_VALUE", "SCALE", "SCALE_VALUE", "SEMI_COLONS", "SQUARE_END", "SQUARE_OPEN", 
		"STAR", "STRING", "STRING_QUOTE", "TILDE", "TRANSLATE3D_VALUE", "URL", 
		"WS", "'and'"
	};
	public static final int EOF=-1;
	public static final int T__77=77;
	public static final int ALPHA_VALUE=4;
	public static final int ARGUMENTS=5;
	public static final int AT_FONT_FACE=6;
	public static final int AT_KEYFRAMES=7;
	public static final int AT_MEDIA=8;
	public static final int AT_NAMESPACE=9;
	public static final int AT_WEBKIT_KEYFRAMES=10;
	public static final int BEGINS_WITH=11;
	public static final int BLOCK_END=12;
	public static final int BLOCK_OPEN=13;
	public static final int CALC=14;
	public static final int CHILD=15;
	public static final int CLASS_REFERENCE=16;
	public static final int COLON=17;
	public static final int COMMA=18;
	public static final int COMMENT=19;
	public static final int CONTAINS=20;
	public static final int DIGIT=21;
	public static final int DOT=22;
	public static final int DOUBLE_COLON=23;
	public static final int EMBED=24;
	public static final int ENDS_WITH=25;
	public static final int EQUALS=26;
	public static final int ESCAPED_HEX=27;
	public static final int FORMAT=28;
	public static final int FUNCTIONS=29;
	public static final int HASH_WORD=30;
	public static final int HEX_DIGIT=31;
	public static final int HREFLANG_MATCH=32;
	public static final int ID=33;
	public static final int IMPORTANT=34;
	public static final int I_ARRAY=35;
	public static final int I_CHILD_SELECTOR=36;
	public static final int I_DECL=37;
	public static final int I_MEDIUM_CONDITIONS=38;
	public static final int I_MULTIVALUE=39;
	public static final int I_PRECEDED_SELECTOR=40;
	public static final int I_RULE=41;
	public static final int I_RULES=42;
	public static final int I_SELECTOR=43;
	public static final int I_SELECTOR_GROUP=44;
	public static final int I_SIBLING_SELECTOR=45;
	public static final int I_SIMPLE_SELECTOR=46;
	public static final int LETTER=47;
	public static final int LIST_MATCH=48;
	public static final int LOCAL=49;
	public static final int NOT=50;
	public static final int NULL=51;
	public static final int NUMBER=52;
	public static final int NUMBER_WITH_PERCENT=53;
	public static final int NUMBER_WITH_UNIT=54;
	public static final int ONLY=55;
	public static final int OPERATOR=56;
	public static final int PERCENT=57;
	public static final int PIPE=58;
	public static final int PRECEDED=59;
	public static final int PROPERTY_REFERENCE=60;
	public static final int RECT_VALUE=61;
	public static final int RGB=62;
	public static final int RGBA=63;
	public static final int ROTATE_VALUE=64;
	public static final int SCALE=65;
	public static final int SCALE_VALUE=66;
	public static final int SEMI_COLONS=67;
	public static final int SQUARE_END=68;
	public static final int SQUARE_OPEN=69;
	public static final int STAR=70;
	public static final int STRING=71;
	public static final int STRING_QUOTE=72;
	public static final int TILDE=73;
	public static final int TRANSLATE3D_VALUE=74;
	public static final int URL=75;
	public static final int WS=76;

	// delegates
	public Parser[] getDelegates() {
		return new Parser[] {};
	}

	// delegators


	public CSSParser(TokenStream input) {
		this(input, new RecognizerSharedState());
	}
	public CSSParser(TokenStream input, RecognizerSharedState state) {
		super(input, state);
	}

	protected TreeAdaptor adaptor = new CommonTreeAdaptor();

	public void setTreeAdaptor(TreeAdaptor adaptor) {
		this.adaptor = adaptor;
	}
	public TreeAdaptor getTreeAdaptor() {
		return adaptor;
	}
	@Override public String[] getTokenNames() { return CSSParser.tokenNames; }
	@Override public String getGrammarFileName() { return "CSS.g"; }



	/**
	 * Parser problems.
	 */
	protected List problems = new ArrayList();

	/**
	 * Collect parser problems.
	 */
	@Override
	public void displayRecognitionError(String[] tokenNames, RecognitionException e)
	{
	    problems.add(CSSParserProblem.create(this, tokenNames, e));
	}

	/**
	 * Check if the cursor is at the end of a simple selector.
	 * @return -1 if not end
	 * @return 0 if end
	 * @return 1 if ended by Child combinator
	 * @return 2 if ended by Preceded combinator
	 * @return 3 if ended by Sibling combinator
	 */
	private final int endOfSimpleSelector()
	{
	    final CommonToken nextToken = (CommonToken) getTokenStream().LT(1);
	    if (nextToken == null)
	        return 0;
	    
	    final int nextType = nextToken.getType();

	    if (nextType == CHILD) 
	    { 
	        getTokenStream().consume();
	        return 1;
	    }
	    if (nextType == PRECEDED)
	    {
	        getTokenStream().consume();
	        return 2;
	    }
	    if (nextType == TILDE)
	    {
	        getTokenStream().consume();
	        return 3;
	    }

	    // Check if there's white space between the previous token and the next token.
	    final CommonToken lastToken = (CommonToken) getTokenStream().LT(-1);
	    if (lastToken != null && nextToken != null)
	    {
	        final int lastStop = lastToken.getStopIndex();
	        final int nextStart = nextToken.getStartIndex();
	        if (lastStop + 1 < nextStart)
	        {
	            return 0;
	        }
	    }
	    
	    // If the next token is "{" or ",", it's also end of a selector.
	    if (nextType == BLOCK_OPEN || nextType == COMMA)
	    {
	        return 0;
	    }
	    
	    return -1;
	}



	public static class stylesheet_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "stylesheet"
	// CSS.g:167:1: stylesheet : ( namespaceStatement | fontFace | keyframes | mediaQuery | ruleset )* ;
	public final CSSParser.stylesheet_return stylesheet() throws RecognitionException {
		CSSParser.stylesheet_return retval = new CSSParser.stylesheet_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		ParserRuleReturnScope namespaceStatement1 =null;
		ParserRuleReturnScope fontFace2 =null;
		ParserRuleReturnScope keyframes3 =null;
		ParserRuleReturnScope mediaQuery4 =null;
		ParserRuleReturnScope ruleset5 =null;


		try {
			// CSS.g:168:5: ( ( namespaceStatement | fontFace | keyframes | mediaQuery | ruleset )* )
			// CSS.g:168:9: ( namespaceStatement | fontFace | keyframes | mediaQuery | ruleset )*
			{
			root_0 = (Object)adaptor.nil();


			// CSS.g:168:9: ( namespaceStatement | fontFace | keyframes | mediaQuery | ruleset )*
			loop1:
			while (true) {
				int alt1=6;
				switch ( input.LA(1) ) {
				case AT_NAMESPACE:
					{
					alt1=1;
					}
					break;
				case AT_FONT_FACE:
					{
					alt1=2;
					}
					break;
				case AT_KEYFRAMES:
				case AT_WEBKIT_KEYFRAMES:
					{
					alt1=3;
					}
					break;
				case AT_MEDIA:
					{
					alt1=4;
					}
					break;
				case COLON:
				case DOT:
				case DOUBLE_COLON:
				case HASH_WORD:
				case ID:
				case NUMBER_WITH_PERCENT:
				case SQUARE_OPEN:
				case STAR:
					{
					alt1=5;
					}
					break;
				}
				switch (alt1) {
				case 1 :
					// CSS.g:168:11: namespaceStatement
					{
					pushFollow(FOLLOW_namespaceStatement_in_stylesheet149);
					namespaceStatement1=namespaceStatement();
					state._fsp--;

					adaptor.addChild(root_0, namespaceStatement1.getTree());

					}
					break;
				case 2 :
					// CSS.g:168:32: fontFace
					{
					pushFollow(FOLLOW_fontFace_in_stylesheet153);
					fontFace2=fontFace();
					state._fsp--;

					adaptor.addChild(root_0, fontFace2.getTree());

					}
					break;
				case 3 :
					// CSS.g:168:43: keyframes
					{
					pushFollow(FOLLOW_keyframes_in_stylesheet157);
					keyframes3=keyframes();
					state._fsp--;

					adaptor.addChild(root_0, keyframes3.getTree());

					}
					break;
				case 4 :
					// CSS.g:168:55: mediaQuery
					{
					pushFollow(FOLLOW_mediaQuery_in_stylesheet161);
					mediaQuery4=mediaQuery();
					state._fsp--;

					adaptor.addChild(root_0, mediaQuery4.getTree());

					}
					break;
				case 5 :
					// CSS.g:168:68: ruleset
					{
					pushFollow(FOLLOW_ruleset_in_stylesheet165);
					ruleset5=ruleset();
					state._fsp--;

					adaptor.addChild(root_0, ruleset5.getTree());

					}
					break;

				default :
					break loop1;
				}
			}

			}

			retval.stop = input.LT(-1);

			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "stylesheet"


	public static class namespaceStatement_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "namespaceStatement"
	// CSS.g:180:1: namespaceStatement : AT_NAMESPACE ( ID )? STRING SEMI_COLONS -> ^( AT_NAMESPACE ( ID )? STRING ) ;
	public final CSSParser.namespaceStatement_return namespaceStatement() throws RecognitionException {
		CSSParser.namespaceStatement_return retval = new CSSParser.namespaceStatement_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token AT_NAMESPACE6=null;
		Token ID7=null;
		Token STRING8=null;
		Token SEMI_COLONS9=null;

		Object AT_NAMESPACE6_tree=null;
		Object ID7_tree=null;
		Object STRING8_tree=null;
		Object SEMI_COLONS9_tree=null;
		RewriteRuleTokenStream stream_STRING=new RewriteRuleTokenStream(adaptor,"token STRING");
		RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
		RewriteRuleTokenStream stream_SEMI_COLONS=new RewriteRuleTokenStream(adaptor,"token SEMI_COLONS");
		RewriteRuleTokenStream stream_AT_NAMESPACE=new RewriteRuleTokenStream(adaptor,"token AT_NAMESPACE");

		try {
			// CSS.g:181:5: ( AT_NAMESPACE ( ID )? STRING SEMI_COLONS -> ^( AT_NAMESPACE ( ID )? STRING ) )
			// CSS.g:181:9: AT_NAMESPACE ( ID )? STRING SEMI_COLONS
			{
			AT_NAMESPACE6=(Token)match(input,AT_NAMESPACE,FOLLOW_AT_NAMESPACE_in_namespaceStatement189);  
			stream_AT_NAMESPACE.add(AT_NAMESPACE6);

			// CSS.g:181:22: ( ID )?
			int alt2=2;
			int LA2_0 = input.LA(1);
			if ( (LA2_0==ID) ) {
				alt2=1;
			}
			switch (alt2) {
				case 1 :
					// CSS.g:181:22: ID
					{
					ID7=(Token)match(input,ID,FOLLOW_ID_in_namespaceStatement191);  
					stream_ID.add(ID7);

					}
					break;

			}

			STRING8=(Token)match(input,STRING,FOLLOW_STRING_in_namespaceStatement194);  
			stream_STRING.add(STRING8);

			SEMI_COLONS9=(Token)match(input,SEMI_COLONS,FOLLOW_SEMI_COLONS_in_namespaceStatement196);  
			stream_SEMI_COLONS.add(SEMI_COLONS9);

			// AST REWRITE
			// elements: AT_NAMESPACE, STRING, ID
			// token labels: 
			// rule labels: retval
			// token list labels: 
			// rule list labels: 
			// wildcard labels: 
			retval.tree = root_0;
			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

			root_0 = (Object)adaptor.nil();
			// 182:6: -> ^( AT_NAMESPACE ( ID )? STRING )
			{
				// CSS.g:182:9: ^( AT_NAMESPACE ( ID )? STRING )
				{
				Object root_1 = (Object)adaptor.nil();
				root_1 = (Object)adaptor.becomeRoot(stream_AT_NAMESPACE.nextNode(), root_1);
				// CSS.g:182:24: ( ID )?
				if ( stream_ID.hasNext() ) {
					adaptor.addChild(root_1, stream_ID.nextNode());
				}
				stream_ID.reset();

				adaptor.addChild(root_1, stream_STRING.nextNode());
				adaptor.addChild(root_0, root_1);
				}

			}


			retval.tree = root_0;

			}

			retval.stop = input.LT(-1);

			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "namespaceStatement"


	public static class keyframes_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "keyframes"
	// CSS.g:193:1: keyframes : ( AT_KEYFRAMES ID BLOCK_OPEN ( ruleset )* BLOCK_END -> ^( AT_KEYFRAMES ID ( ruleset )* ) | AT_WEBKIT_KEYFRAMES ID BLOCK_OPEN ( ruleset )* BLOCK_END -> ^( AT_WEBKIT_KEYFRAMES ID ( ruleset )* ) );
	public final CSSParser.keyframes_return keyframes() throws RecognitionException {
		CSSParser.keyframes_return retval = new CSSParser.keyframes_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token AT_KEYFRAMES10=null;
		Token ID11=null;
		Token BLOCK_OPEN12=null;
		Token BLOCK_END14=null;
		Token AT_WEBKIT_KEYFRAMES15=null;
		Token ID16=null;
		Token BLOCK_OPEN17=null;
		Token BLOCK_END19=null;
		ParserRuleReturnScope ruleset13 =null;
		ParserRuleReturnScope ruleset18 =null;

		Object AT_KEYFRAMES10_tree=null;
		Object ID11_tree=null;
		Object BLOCK_OPEN12_tree=null;
		Object BLOCK_END14_tree=null;
		Object AT_WEBKIT_KEYFRAMES15_tree=null;
		Object ID16_tree=null;
		Object BLOCK_OPEN17_tree=null;
		Object BLOCK_END19_tree=null;
		RewriteRuleTokenStream stream_BLOCK_OPEN=new RewriteRuleTokenStream(adaptor,"token BLOCK_OPEN");
		RewriteRuleTokenStream stream_BLOCK_END=new RewriteRuleTokenStream(adaptor,"token BLOCK_END");
		RewriteRuleTokenStream stream_AT_WEBKIT_KEYFRAMES=new RewriteRuleTokenStream(adaptor,"token AT_WEBKIT_KEYFRAMES");
		RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
		RewriteRuleTokenStream stream_AT_KEYFRAMES=new RewriteRuleTokenStream(adaptor,"token AT_KEYFRAMES");
		RewriteRuleSubtreeStream stream_ruleset=new RewriteRuleSubtreeStream(adaptor,"rule ruleset");

		try {
			// CSS.g:194:5: ( AT_KEYFRAMES ID BLOCK_OPEN ( ruleset )* BLOCK_END -> ^( AT_KEYFRAMES ID ( ruleset )* ) | AT_WEBKIT_KEYFRAMES ID BLOCK_OPEN ( ruleset )* BLOCK_END -> ^( AT_WEBKIT_KEYFRAMES ID ( ruleset )* ) )
			int alt5=2;
			int LA5_0 = input.LA(1);
			if ( (LA5_0==AT_KEYFRAMES) ) {
				alt5=1;
			}
			else if ( (LA5_0==AT_WEBKIT_KEYFRAMES) ) {
				alt5=2;
			}

			else {
				NoViableAltException nvae =
					new NoViableAltException("", 5, 0, input);
				throw nvae;
			}

			switch (alt5) {
				case 1 :
					// CSS.g:194:9: AT_KEYFRAMES ID BLOCK_OPEN ( ruleset )* BLOCK_END
					{
					AT_KEYFRAMES10=(Token)match(input,AT_KEYFRAMES,FOLLOW_AT_KEYFRAMES_in_keyframes239);  
					stream_AT_KEYFRAMES.add(AT_KEYFRAMES10);

					ID11=(Token)match(input,ID,FOLLOW_ID_in_keyframes241);  
					stream_ID.add(ID11);

					BLOCK_OPEN12=(Token)match(input,BLOCK_OPEN,FOLLOW_BLOCK_OPEN_in_keyframes243);  
					stream_BLOCK_OPEN.add(BLOCK_OPEN12);

					// CSS.g:194:36: ( ruleset )*
					loop3:
					while (true) {
						int alt3=2;
						int LA3_0 = input.LA(1);
						if ( (LA3_0==COLON||(LA3_0 >= DOT && LA3_0 <= DOUBLE_COLON)||LA3_0==HASH_WORD||LA3_0==ID||LA3_0==NUMBER_WITH_PERCENT||(LA3_0 >= SQUARE_OPEN && LA3_0 <= STAR)) ) {
							alt3=1;
						}

						switch (alt3) {
						case 1 :
							// CSS.g:194:36: ruleset
							{
							pushFollow(FOLLOW_ruleset_in_keyframes245);
							ruleset13=ruleset();
							state._fsp--;

							stream_ruleset.add(ruleset13.getTree());
							}
							break;

						default :
							break loop3;
						}
					}

					BLOCK_END14=(Token)match(input,BLOCK_END,FOLLOW_BLOCK_END_in_keyframes248);  
					stream_BLOCK_END.add(BLOCK_END14);

					// AST REWRITE
					// elements: AT_KEYFRAMES, ruleset, ID
					// token labels: 
					// rule labels: retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					retval.tree = root_0;
					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

					root_0 = (Object)adaptor.nil();
					// 195:6: -> ^( AT_KEYFRAMES ID ( ruleset )* )
					{
						// CSS.g:195:9: ^( AT_KEYFRAMES ID ( ruleset )* )
						{
						Object root_1 = (Object)adaptor.nil();
						root_1 = (Object)adaptor.becomeRoot(stream_AT_KEYFRAMES.nextNode(), root_1);
						adaptor.addChild(root_1, stream_ID.nextNode());
						// CSS.g:195:27: ( ruleset )*
						while ( stream_ruleset.hasNext() ) {
							adaptor.addChild(root_1, stream_ruleset.nextTree());
						}
						stream_ruleset.reset();

						adaptor.addChild(root_0, root_1);
						}

					}


					retval.tree = root_0;

					}
					break;
				case 2 :
					// CSS.g:196:9: AT_WEBKIT_KEYFRAMES ID BLOCK_OPEN ( ruleset )* BLOCK_END
					{
					AT_WEBKIT_KEYFRAMES15=(Token)match(input,AT_WEBKIT_KEYFRAMES,FOLLOW_AT_WEBKIT_KEYFRAMES_in_keyframes274);  
					stream_AT_WEBKIT_KEYFRAMES.add(AT_WEBKIT_KEYFRAMES15);

					ID16=(Token)match(input,ID,FOLLOW_ID_in_keyframes276);  
					stream_ID.add(ID16);

					BLOCK_OPEN17=(Token)match(input,BLOCK_OPEN,FOLLOW_BLOCK_OPEN_in_keyframes278);  
					stream_BLOCK_OPEN.add(BLOCK_OPEN17);

					// CSS.g:196:43: ( ruleset )*
					loop4:
					while (true) {
						int alt4=2;
						int LA4_0 = input.LA(1);
						if ( (LA4_0==COLON||(LA4_0 >= DOT && LA4_0 <= DOUBLE_COLON)||LA4_0==HASH_WORD||LA4_0==ID||LA4_0==NUMBER_WITH_PERCENT||(LA4_0 >= SQUARE_OPEN && LA4_0 <= STAR)) ) {
							alt4=1;
						}

						switch (alt4) {
						case 1 :
							// CSS.g:196:43: ruleset
							{
							pushFollow(FOLLOW_ruleset_in_keyframes280);
							ruleset18=ruleset();
							state._fsp--;

							stream_ruleset.add(ruleset18.getTree());
							}
							break;

						default :
							break loop4;
						}
					}

					BLOCK_END19=(Token)match(input,BLOCK_END,FOLLOW_BLOCK_END_in_keyframes283);  
					stream_BLOCK_END.add(BLOCK_END19);

					// AST REWRITE
					// elements: AT_WEBKIT_KEYFRAMES, ID, ruleset
					// token labels: 
					// rule labels: retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					retval.tree = root_0;
					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

					root_0 = (Object)adaptor.nil();
					// 197:6: -> ^( AT_WEBKIT_KEYFRAMES ID ( ruleset )* )
					{
						// CSS.g:197:9: ^( AT_WEBKIT_KEYFRAMES ID ( ruleset )* )
						{
						Object root_1 = (Object)adaptor.nil();
						root_1 = (Object)adaptor.becomeRoot(stream_AT_WEBKIT_KEYFRAMES.nextNode(), root_1);
						adaptor.addChild(root_1, stream_ID.nextNode());
						// CSS.g:197:34: ( ruleset )*
						while ( stream_ruleset.hasNext() ) {
							adaptor.addChild(root_1, stream_ruleset.nextTree());
						}
						stream_ruleset.reset();

						adaptor.addChild(root_0, root_1);
						}

					}


					retval.tree = root_0;

					}
					break;

			}
			retval.stop = input.LT(-1);

			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "keyframes"


	public static class mediaQuery_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "mediaQuery"
	// CSS.g:208:1: mediaQuery : AT_MEDIA medium BLOCK_OPEN ( ruleset )* BLOCK_END -> ^( AT_MEDIA medium ( ruleset )* ) ;
	public final CSSParser.mediaQuery_return mediaQuery() throws RecognitionException {
		CSSParser.mediaQuery_return retval = new CSSParser.mediaQuery_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token AT_MEDIA20=null;
		Token BLOCK_OPEN22=null;
		Token BLOCK_END24=null;
		ParserRuleReturnScope medium21 =null;
		ParserRuleReturnScope ruleset23 =null;

		Object AT_MEDIA20_tree=null;
		Object BLOCK_OPEN22_tree=null;
		Object BLOCK_END24_tree=null;
		RewriteRuleTokenStream stream_BLOCK_OPEN=new RewriteRuleTokenStream(adaptor,"token BLOCK_OPEN");
		RewriteRuleTokenStream stream_BLOCK_END=new RewriteRuleTokenStream(adaptor,"token BLOCK_END");
		RewriteRuleTokenStream stream_AT_MEDIA=new RewriteRuleTokenStream(adaptor,"token AT_MEDIA");
		RewriteRuleSubtreeStream stream_ruleset=new RewriteRuleSubtreeStream(adaptor,"rule ruleset");
		RewriteRuleSubtreeStream stream_medium=new RewriteRuleSubtreeStream(adaptor,"rule medium");

		try {
			// CSS.g:209:5: ( AT_MEDIA medium BLOCK_OPEN ( ruleset )* BLOCK_END -> ^( AT_MEDIA medium ( ruleset )* ) )
			// CSS.g:209:9: AT_MEDIA medium BLOCK_OPEN ( ruleset )* BLOCK_END
			{
			AT_MEDIA20=(Token)match(input,AT_MEDIA,FOLLOW_AT_MEDIA_in_mediaQuery322);  
			stream_AT_MEDIA.add(AT_MEDIA20);

			pushFollow(FOLLOW_medium_in_mediaQuery324);
			medium21=medium();
			state._fsp--;

			stream_medium.add(medium21.getTree());
			BLOCK_OPEN22=(Token)match(input,BLOCK_OPEN,FOLLOW_BLOCK_OPEN_in_mediaQuery326);  
			stream_BLOCK_OPEN.add(BLOCK_OPEN22);

			// CSS.g:209:36: ( ruleset )*
			loop6:
			while (true) {
				int alt6=2;
				int LA6_0 = input.LA(1);
				if ( (LA6_0==COLON||(LA6_0 >= DOT && LA6_0 <= DOUBLE_COLON)||LA6_0==HASH_WORD||LA6_0==ID||LA6_0==NUMBER_WITH_PERCENT||(LA6_0 >= SQUARE_OPEN && LA6_0 <= STAR)) ) {
					alt6=1;
				}

				switch (alt6) {
				case 1 :
					// CSS.g:209:36: ruleset
					{
					pushFollow(FOLLOW_ruleset_in_mediaQuery328);
					ruleset23=ruleset();
					state._fsp--;

					stream_ruleset.add(ruleset23.getTree());
					}
					break;

				default :
					break loop6;
				}
			}

			BLOCK_END24=(Token)match(input,BLOCK_END,FOLLOW_BLOCK_END_in_mediaQuery331);  
			stream_BLOCK_END.add(BLOCK_END24);

			// AST REWRITE
			// elements: AT_MEDIA, ruleset, medium
			// token labels: 
			// rule labels: retval
			// token list labels: 
			// rule list labels: 
			// wildcard labels: 
			retval.tree = root_0;
			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

			root_0 = (Object)adaptor.nil();
			// 210:6: -> ^( AT_MEDIA medium ( ruleset )* )
			{
				// CSS.g:210:9: ^( AT_MEDIA medium ( ruleset )* )
				{
				Object root_1 = (Object)adaptor.nil();
				root_1 = (Object)adaptor.becomeRoot(stream_AT_MEDIA.nextNode(), root_1);
				adaptor.addChild(root_1, stream_medium.nextTree());
				// CSS.g:210:27: ( ruleset )*
				while ( stream_ruleset.hasNext() ) {
					adaptor.addChild(root_1, stream_ruleset.nextTree());
				}
				stream_ruleset.reset();

				adaptor.addChild(root_0, root_1);
				}

			}


			retval.tree = root_0;

			}

			retval.stop = input.LT(-1);

			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "mediaQuery"


	public static class medium_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "medium"
	// CSS.g:217:1: medium : mediumCondition ( 'and' mediumCondition | mediumCondition )* -> ^( I_MEDIUM_CONDITIONS ( mediumCondition )* ) ;
	public final CSSParser.medium_return medium() throws RecognitionException {
		CSSParser.medium_return retval = new CSSParser.medium_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token string_literal26=null;
		ParserRuleReturnScope mediumCondition25 =null;
		ParserRuleReturnScope mediumCondition27 =null;
		ParserRuleReturnScope mediumCondition28 =null;

		Object string_literal26_tree=null;
		RewriteRuleTokenStream stream_77=new RewriteRuleTokenStream(adaptor,"token 77");
		RewriteRuleSubtreeStream stream_mediumCondition=new RewriteRuleSubtreeStream(adaptor,"rule mediumCondition");

		try {
			// CSS.g:218:5: ( mediumCondition ( 'and' mediumCondition | mediumCondition )* -> ^( I_MEDIUM_CONDITIONS ( mediumCondition )* ) )
			// CSS.g:218:9: mediumCondition ( 'and' mediumCondition | mediumCondition )*
			{
			pushFollow(FOLLOW_mediumCondition_in_medium371);
			mediumCondition25=mediumCondition();
			state._fsp--;

			stream_mediumCondition.add(mediumCondition25.getTree());
			// CSS.g:219:9: ( 'and' mediumCondition | mediumCondition )*
			loop7:
			while (true) {
				int alt7=3;
				int LA7_0 = input.LA(1);
				if ( (LA7_0==77) ) {
					alt7=1;
				}
				else if ( (LA7_0==ARGUMENTS||LA7_0==COMMA||LA7_0==ID||LA7_0==ONLY) ) {
					alt7=2;
				}

				switch (alt7) {
				case 1 :
					// CSS.g:221:13: 'and' mediumCondition
					{
					string_literal26=(Token)match(input,77,FOLLOW_77_in_medium414);  
					stream_77.add(string_literal26);

					pushFollow(FOLLOW_mediumCondition_in_medium429);
					mediumCondition27=mediumCondition();
					state._fsp--;

					stream_mediumCondition.add(mediumCondition27.getTree());
					}
					break;
				case 2 :
					// CSS.g:223:15: mediumCondition
					{
					pushFollow(FOLLOW_mediumCondition_in_medium445);
					mediumCondition28=mediumCondition();
					state._fsp--;

					stream_mediumCondition.add(mediumCondition28.getTree());
					}
					break;

				default :
					break loop7;
				}
			}

			// AST REWRITE
			// elements: mediumCondition
			// token labels: 
			// rule labels: retval
			// token list labels: 
			// rule list labels: 
			// wildcard labels: 
			retval.tree = root_0;
			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

			root_0 = (Object)adaptor.nil();
			// 225:9: -> ^( I_MEDIUM_CONDITIONS ( mediumCondition )* )
			{
				// CSS.g:225:12: ^( I_MEDIUM_CONDITIONS ( mediumCondition )* )
				{
				Object root_1 = (Object)adaptor.nil();
				root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(I_MEDIUM_CONDITIONS, "I_MEDIUM_CONDITIONS"), root_1);
				// CSS.g:225:34: ( mediumCondition )*
				while ( stream_mediumCondition.hasNext() ) {
					adaptor.addChild(root_1, stream_mediumCondition.nextTree());
				}
				stream_mediumCondition.reset();

				adaptor.addChild(root_0, root_1);
				}

			}


			retval.tree = root_0;

			}

			retval.stop = input.LT(-1);

			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "medium"


	public static class mediumCondition_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "mediumCondition"
	// CSS.g:232:1: mediumCondition : ( ID | ONLY ID | ARGUMENTS | COMMA );
	public final CSSParser.mediumCondition_return mediumCondition() throws RecognitionException {
		CSSParser.mediumCondition_return retval = new CSSParser.mediumCondition_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token ID29=null;
		Token ONLY30=null;
		Token ID31=null;
		Token ARGUMENTS32=null;
		Token COMMA33=null;

		Object ID29_tree=null;
		Object ONLY30_tree=null;
		Object ID31_tree=null;
		Object ARGUMENTS32_tree=null;
		Object COMMA33_tree=null;

		try {
			// CSS.g:233:5: ( ID | ONLY ID | ARGUMENTS | COMMA )
			int alt8=4;
			switch ( input.LA(1) ) {
			case ID:
				{
				alt8=1;
				}
				break;
			case ONLY:
				{
				alt8=2;
				}
				break;
			case ARGUMENTS:
				{
				alt8=3;
				}
				break;
			case COMMA:
				{
				alt8=4;
				}
				break;
			default:
				NoViableAltException nvae =
					new NoViableAltException("", 8, 0, input);
				throw nvae;
			}
			switch (alt8) {
				case 1 :
					// CSS.g:233:9: ID
					{
					root_0 = (Object)adaptor.nil();


					ID29=(Token)match(input,ID,FOLLOW_ID_in_mediumCondition496); 
					ID29_tree = (Object)adaptor.create(ID29);
					adaptor.addChild(root_0, ID29_tree);

					}
					break;
				case 2 :
					// CSS.g:234:9: ONLY ID
					{
					root_0 = (Object)adaptor.nil();


					ONLY30=(Token)match(input,ONLY,FOLLOW_ONLY_in_mediumCondition506); 
					ONLY30_tree = (Object)adaptor.create(ONLY30);
					adaptor.addChild(root_0, ONLY30_tree);

					ID31=(Token)match(input,ID,FOLLOW_ID_in_mediumCondition508); 
					ID31_tree = (Object)adaptor.create(ID31);
					adaptor.addChild(root_0, ID31_tree);

					}
					break;
				case 3 :
					// CSS.g:235:9: ARGUMENTS
					{
					root_0 = (Object)adaptor.nil();


					ARGUMENTS32=(Token)match(input,ARGUMENTS,FOLLOW_ARGUMENTS_in_mediumCondition522); 
					ARGUMENTS32_tree = (Object)adaptor.create(ARGUMENTS32);
					adaptor.addChild(root_0, ARGUMENTS32_tree);

					}
					break;
				case 4 :
					// CSS.g:236:9: COMMA
					{
					root_0 = (Object)adaptor.nil();


					COMMA33=(Token)match(input,COMMA,FOLLOW_COMMA_in_mediumCondition532); 
					COMMA33_tree = (Object)adaptor.create(COMMA33);
					adaptor.addChild(root_0, COMMA33_tree);

					}
					break;

			}
			retval.stop = input.LT(-1);

			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "mediumCondition"


	public static class fontFace_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "fontFace"
	// CSS.g:250:1: fontFace : AT_FONT_FACE declarationsBlock -> ^( AT_FONT_FACE declarationsBlock ) ;
	public final CSSParser.fontFace_return fontFace() throws RecognitionException {
		CSSParser.fontFace_return retval = new CSSParser.fontFace_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token AT_FONT_FACE34=null;
		ParserRuleReturnScope declarationsBlock35 =null;

		Object AT_FONT_FACE34_tree=null;
		RewriteRuleTokenStream stream_AT_FONT_FACE=new RewriteRuleTokenStream(adaptor,"token AT_FONT_FACE");
		RewriteRuleSubtreeStream stream_declarationsBlock=new RewriteRuleSubtreeStream(adaptor,"rule declarationsBlock");

		try {
			// CSS.g:251:5: ( AT_FONT_FACE declarationsBlock -> ^( AT_FONT_FACE declarationsBlock ) )
			// CSS.g:251:9: AT_FONT_FACE declarationsBlock
			{
			AT_FONT_FACE34=(Token)match(input,AT_FONT_FACE,FOLLOW_AT_FONT_FACE_in_fontFace561);  
			stream_AT_FONT_FACE.add(AT_FONT_FACE34);

			pushFollow(FOLLOW_declarationsBlock_in_fontFace563);
			declarationsBlock35=declarationsBlock();
			state._fsp--;

			stream_declarationsBlock.add(declarationsBlock35.getTree());
			// AST REWRITE
			// elements: declarationsBlock, AT_FONT_FACE
			// token labels: 
			// rule labels: retval
			// token list labels: 
			// rule list labels: 
			// wildcard labels: 
			retval.tree = root_0;
			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

			root_0 = (Object)adaptor.nil();
			// 251:40: -> ^( AT_FONT_FACE declarationsBlock )
			{
				// CSS.g:251:43: ^( AT_FONT_FACE declarationsBlock )
				{
				Object root_1 = (Object)adaptor.nil();
				root_1 = (Object)adaptor.becomeRoot(stream_AT_FONT_FACE.nextNode(), root_1);
				adaptor.addChild(root_1, stream_declarationsBlock.nextTree());
				adaptor.addChild(root_0, root_1);
				}

			}


			retval.tree = root_0;

			}

			retval.stop = input.LT(-1);

			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "fontFace"


	public static class ruleset_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "ruleset"
	// CSS.g:257:1: ruleset : selectorGroup declarationsBlock -> ^( I_RULE selectorGroup declarationsBlock ) ;
	public final CSSParser.ruleset_return ruleset() throws RecognitionException {
		CSSParser.ruleset_return retval = new CSSParser.ruleset_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		ParserRuleReturnScope selectorGroup36 =null;
		ParserRuleReturnScope declarationsBlock37 =null;

		RewriteRuleSubtreeStream stream_selectorGroup=new RewriteRuleSubtreeStream(adaptor,"rule selectorGroup");
		RewriteRuleSubtreeStream stream_declarationsBlock=new RewriteRuleSubtreeStream(adaptor,"rule declarationsBlock");

		try {
			// CSS.g:258:5: ( selectorGroup declarationsBlock -> ^( I_RULE selectorGroup declarationsBlock ) )
			// CSS.g:258:9: selectorGroup declarationsBlock
			{
			pushFollow(FOLLOW_selectorGroup_in_ruleset594);
			selectorGroup36=selectorGroup();
			state._fsp--;

			stream_selectorGroup.add(selectorGroup36.getTree());
			pushFollow(FOLLOW_declarationsBlock_in_ruleset596);
			declarationsBlock37=declarationsBlock();
			state._fsp--;

			stream_declarationsBlock.add(declarationsBlock37.getTree());
			// AST REWRITE
			// elements: declarationsBlock, selectorGroup
			// token labels: 
			// rule labels: retval
			// token list labels: 
			// rule list labels: 
			// wildcard labels: 
			retval.tree = root_0;
			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

			root_0 = (Object)adaptor.nil();
			// 259:9: -> ^( I_RULE selectorGroup declarationsBlock )
			{
				// CSS.g:259:12: ^( I_RULE selectorGroup declarationsBlock )
				{
				Object root_1 = (Object)adaptor.nil();
				root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(I_RULE, "I_RULE"), root_1);
				adaptor.addChild(root_1, stream_selectorGroup.nextTree());
				adaptor.addChild(root_1, stream_declarationsBlock.nextTree());
				adaptor.addChild(root_0, root_1);
				}

			}


			retval.tree = root_0;

			}

			retval.stop = input.LT(-1);

			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "ruleset"


	public static class selectorGroup_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "selectorGroup"
	// CSS.g:265:1: selectorGroup : compoundSelector ( COMMA compoundSelector )* -> ^( I_SELECTOR_GROUP ( compoundSelector )+ ) ;
	public final CSSParser.selectorGroup_return selectorGroup() throws RecognitionException {
		CSSParser.selectorGroup_return retval = new CSSParser.selectorGroup_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token COMMA39=null;
		ParserRuleReturnScope compoundSelector38 =null;
		ParserRuleReturnScope compoundSelector40 =null;

		Object COMMA39_tree=null;
		RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
		RewriteRuleSubtreeStream stream_compoundSelector=new RewriteRuleSubtreeStream(adaptor,"rule compoundSelector");

		try {
			// CSS.g:266:2: ( compoundSelector ( COMMA compoundSelector )* -> ^( I_SELECTOR_GROUP ( compoundSelector )+ ) )
			// CSS.g:266:4: compoundSelector ( COMMA compoundSelector )*
			{
			pushFollow(FOLLOW_compoundSelector_in_selectorGroup630);
			compoundSelector38=compoundSelector();
			state._fsp--;

			stream_compoundSelector.add(compoundSelector38.getTree());
			// CSS.g:266:21: ( COMMA compoundSelector )*
			loop9:
			while (true) {
				int alt9=2;
				int LA9_0 = input.LA(1);
				if ( (LA9_0==COMMA) ) {
					alt9=1;
				}

				switch (alt9) {
				case 1 :
					// CSS.g:266:23: COMMA compoundSelector
					{
					COMMA39=(Token)match(input,COMMA,FOLLOW_COMMA_in_selectorGroup634);  
					stream_COMMA.add(COMMA39);

					pushFollow(FOLLOW_compoundSelector_in_selectorGroup636);
					compoundSelector40=compoundSelector();
					state._fsp--;

					stream_compoundSelector.add(compoundSelector40.getTree());
					}
					break;

				default :
					break loop9;
				}
			}

			// AST REWRITE
			// elements: compoundSelector
			// token labels: 
			// rule labels: retval
			// token list labels: 
			// rule list labels: 
			// wildcard labels: 
			retval.tree = root_0;
			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

			root_0 = (Object)adaptor.nil();
			// 267:9: -> ^( I_SELECTOR_GROUP ( compoundSelector )+ )
			{
				// CSS.g:267:12: ^( I_SELECTOR_GROUP ( compoundSelector )+ )
				{
				Object root_1 = (Object)adaptor.nil();
				root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(I_SELECTOR_GROUP, "I_SELECTOR_GROUP"), root_1);
				if ( !(stream_compoundSelector.hasNext()) ) {
					throw new RewriteEarlyExitException();
				}
				while ( stream_compoundSelector.hasNext() ) {
					adaptor.addChild(root_1, stream_compoundSelector.nextTree());
				}
				stream_compoundSelector.reset();

				adaptor.addChild(root_0, root_1);
				}

			}


			retval.tree = root_0;

			}

			retval.stop = input.LT(-1);

			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "selectorGroup"


	public static class compoundSelector_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "compoundSelector"
	// CSS.g:278:1: compoundSelector : (l= simpleSelectorFraction )+ -> ^( I_SELECTOR ) ;
	public final CSSParser.compoundSelector_return compoundSelector() throws RecognitionException {
		CSSParser.compoundSelector_return retval = new CSSParser.compoundSelector_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		ParserRuleReturnScope l =null;

		RewriteRuleSubtreeStream stream_simpleSelectorFraction=new RewriteRuleSubtreeStream(adaptor,"rule simpleSelectorFraction");


			final List