Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   // Generated from org/tinygroup/template/parser/grammer/TinyTemplateParser.g4 by ANTLR 4.2.2
   package org.tinygroup.template.parser.grammer;
   import java.util.List;
   import java.util.Iterator;
  
  @SuppressWarnings({"all""warnings""unchecked""unused""cast"})
  public class TinyTemplateParser extends Parser {
  	protected static final DFA[] _decisionToDFA;
  	protected static final PredictionContextCache _sharedContextCache =
  	public static final int
  		AT=85, PARA_SPLITER=8, RIGHT_PARENTHESE=48, IN=53, DIRECTIVE_CALL=20, 
  	public static final String[] tokenNames = {
  		"<INVALID>""COMMENT_LINE""COMMENT_BLOCK2""COMMENT_BLOCK1""TEXT_PLAIN"
  		"TEXT_CDATA""TEXT_ESCAPED_CHAR""TEXT_SINGLE_CHAR""PARA_SPLITER"
  		"'$${'""'${'""'$!{'""DIRECTIVE_OPEN_SET""DIRECTIVE_OPEN_IF""DIRECTIVE_OPEN_ELSEIF"
  		"DIRECTIVE_OPEN_FOR""DIRECTIVE_OPEN_BREAK""DIRECTIVE_OPEN_CONTINUE"
  		"DIRECTIVE_OPEN_STOP""DIRECTIVE_OPEN_INCLUDE""DIRECTIVE_CALL""DIRECTIVE_OPEN_CALL"
  		"DIRECTIVE_OPEN_LAYOUT_IMPL""DIRECTIVE_OPEN_MACRO""DIRECTIVE_OPEN_LAYOUT"
  		"DIRECTIVE_SET""'#if'""'#elseif'""'#for'""'#include'""'#break'"
  		"'#continue'""'#stop'""'#macro'""DIRECTIVE_ELSE""DIRECTIVE_END"
  		"DIRECTIVE_BLANK""DIRECTIVE_END_OF_LINE""DIRECTIVE_TABS""DIRECTIVE_TABS_INDENT"
  		"DIRECTIVE_TABS_DENT""DIRECTIVE_BODYCONTENT""DIRECTIVE_IMPORT""DIRECTIVE_MACRO_INVOKE"
  		"DIRECTIVE_OPEN_MACRO_INVOKE""TEXT_DIRECTIVE_LIKE""WHITESPACE""'('"
  		"')'""'['""']'""'{'""'}'""'in'""'='""'..'""'.'""'?.'"
  		"'=='""'!='""'>'""'<'""'>='""'<='""'&&'""'||'""'!'""'+'"
  		"'-'""'*'""'/'""'%'""'++'""'--'""'&'""'|'""'~'""'^'"
  		"'<<'""'>>'""'>>>'""'?'""'?:'""','""':'""'@'""'true'"
  		"'false'""'null'""IDENTIFIER""INTEGER""INTEGER_HEX""FLOATING_POINT"
  		"STRING_DOUBLE""STRING_SINGLE"
  	};
  	public static final int
  		RULE_template = 0, RULE_block = 1, RULE_text = 2, RULE_comment = 3, RULE_value = 4, 
  	public static final String[] ruleNames = {
  		"template""block""text""comment""value""directive""identify_list"
  		"define_expression_list""para_expression_list""para_expression""define_expression"
  		"set_directive""set_expression""endofline_directive""tabs_directive"
  		"blank_directive""indent_directive""dent_directive""if_directive"
  		"elseif_directive""else_directive""for_directive""for_expression"
  		"break_directive""import_directive""continue_directive""stop_directive"
  		"include_directive""macro_directive""layout_directive""call_block_directive"
  		"layout_impl_directive""call_directive""call_macro_block_directive"
  		"bodycontent_directive""call_macro_directive""invalid_directive"
  		"expression""constant""expression_list""hash_map_entry_list""expression_range"
  	};
  
  	public String getGrammarFileName() { return "TinyTemplateParser.g4"; }
  
  	public String[] getTokenNames() { return ; }
  
  	public String[] getRuleNames() { return ; }
  
  	public String getSerializedATN() { return ; }
 
 	public ATN getATN() { return ; }
 
 	public TinyTemplateParser(TokenStream input) {
 		super(input);
 	}
 	public static class TemplateContext extends ParserRuleContext {
 		public BlockContext block() {
 			return getRuleContext(BlockContext.class,0);
 		}
 		public TemplateContext(ParserRuleContext parentint invokingState) {
 			super(parentinvokingState);
 		}
 		@Override public int getRuleIndex() { return ; }
 		public void enterRule(ParseTreeListener listener) {
 			if ( listener instanceof TinyTemplateParserListener ) ((TinyTemplateParserListener)listener).enterTemplate(this);
 		}
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof TinyTemplateParserListener ) ((TinyTemplateParserListener)listener).exitTemplate(this);
 		}
 		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
 			if ( visitor instanceof TinyTemplateParserVisitor ) return ((TinyTemplateParserVisitor<? extends T>)visitor).visitTemplate(this);
 			else return visitor.visitChildren(this);
 		}
 	}
 
 	public final TemplateContext template() throws RecognitionException {
 		TemplateContext _localctx = new TemplateContext(getState());
 		enterRule(_localctx, 0, );
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
 			setState(84); block();
 			}
 		}
 		catch (RecognitionException re) {
 			_localctx.exception = re;
 			.recover(thisre);
 		}
 		finally {
 		}
 		return _localctx;
 	}
 
 	public static class BlockContext extends ParserRuleContext {
 		public List<TextContexttext() {
 			return getRuleContexts(TextContext.class);
 		}
 		public ValueContext value(int i) {
 			return getRuleContext(ValueContext.class,i);
 		}
 		public List<CommentContextcomment() {
 		}
 		public DirectiveContext directive(int i) {
 			return getRuleContext(DirectiveContext.class,i);
 		}
 		public List<ValueContextvalue() {
 			return getRuleContexts(ValueContext.class);
 		}
 		public TextContext text(int i) {
 			return getRuleContext(TextContext.class,i);
 		}
 		}
 		public CommentContext comment(int i) {
 			return getRuleContext(CommentContext.class,i);
 		}
 		public BlockContext(ParserRuleContext parentint invokingState) {
 			super(parentinvokingState);
 		}
 		@Override public int getRuleIndex() { return ; }
 		public void enterRule(ParseTreeListener listener) {
 			if ( listener instanceof TinyTemplateParserListener ) ((TinyTemplateParserListener)listener).enterBlock(this);
 		}
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof TinyTemplateParserListener ) ((TinyTemplateParserListener)listener).exitBlock(this);
 		}
 		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
 			if ( visitor instanceof TinyTemplateParserVisitor ) return ((TinyTemplateParserVisitor<? extends T>)visitor).visitBlock(this);
 			else return visitor.visitChildren(this);
 		}
 	}
 
 	public final BlockContext block() throws RecognitionException {
 		BlockContext _localctx = new BlockContext(getState());
 		enterRule(_localctx, 2, );
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
 			setState(92);
 			_la = .LA(1);
 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ))) != 0)) {
 				{
 				setState(90);
 				switch ( getInterpreter().adaptivePredict(,0,) ) {
 				case 1:
 					{
 					setState(86); comment();
 					}
 					break;
 
 				case 2:
 					{
 					}
 					break;
 
 				case 3:
 					{
 					setState(88); text();
 					}
 					break;
 
 				case 4:
 					{
 					setState(89); value();
 					}
 					break;
 				}
 				}
 				setState(94);
 				_la = .LA(1);
 			}
 			}
 		}
 		catch (RecognitionException re) {
 			_localctx.exception = re;
 			.recover(thisre);
 		}
 		finally {
 		}
 		return _localctx;
 	}
 
 	public static class TextContext extends ParserRuleContext {
 		public TextContext(ParserRuleContext parentint invokingState) {
 			super(parentinvokingState);
 		}
 		@Override public int getRuleIndex() { return ; }
 		public void enterRule(ParseTreeListener listener) {
 			if ( listener instanceof TinyTemplateParserListener ) ((TinyTemplateParserListener)listener).enterText(this);
 		}
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof TinyTemplateParserListener ) ((TinyTemplateParserListener)listener).exitText(this);
 		}
 		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
 			if ( visitor instanceof TinyTemplateParserVisitor ) return ((TinyTemplateParserVisitor<? extends T>)visitor).visitText(this);
 			else return visitor.visitChildren(this);
 		}
 	}
 
 	public final TextContext text() throws RecognitionException {
 		TextContext _localctx = new TextContext(getState());
 		enterRule(_localctx, 4, );
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
 			setState(95);
 			_la = .LA(1);
 			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ) | (1L << ))) != 0)) ) {
 			}
 			}
 		}
 		catch (RecognitionException re) {
 			_localctx.exception = re;
 			.recover(thisre);
 		}
 		finally {
 		}
 		return _localctx;
 	}
 
 	public static class CommentContext extends ParserRuleContext {
 		public CommentContext(ParserRuleContext parentint invokingState) {
 			super(parentinvokingState);
 		}
 		@Override public int getRuleIndex() { return ; }
 		public void enterRule(ParseTreeListener listener) {
 			if ( listener instanceof TinyTemplateParserListener ) ((TinyTemplateParserListener)listener).enterComment(this);
 		}
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof TinyTemplateParserListener ) ((TinyTemplateParserListener)listener).exitComment(this);
 		}
 		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
 			if ( visitor instanceof TinyTemplateParserVisitor ) return ((TinyTemplateParserVisitor<? extends T>)visitor).visitComment(this);
 			else return visitor.visitChildren(this);
 		}
 	}
 
 	public final CommentContext comment() throws RecognitionException {
 		CommentContext _localctx = new CommentContext(getState());
 		enterRule(_localctx, 6, );
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
 			setState(97);
 			_la = .LA(1);
 			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ) | (1L << ) | (1L << ))) != 0)) ) {
 			}
 			}
 		}
 		catch (RecognitionException re) {
 			_localctx.exception = re;
 			.recover(thisre);
 		}
 		finally {
 		}
 		return _localctx;
 	}
 
 	public static class ValueContext extends ParserRuleContext {
 		}
 		}
 		public ValueContext(ParserRuleContext parentint invokingState) {
 			super(parentinvokingState);
 		}
 		@Override public int getRuleIndex() { return ; }
 		public void enterRule(ParseTreeListener listener) {
 			if ( listener instanceof TinyTemplateParserListener ) ((TinyTemplateParserListener)listener).enterValue(this);
 		}
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof TinyTemplateParserListener ) ((TinyTemplateParserListener)listener).exitValue(this);
 		}
 		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
 			if ( visitor instanceof TinyTemplateParserVisitor ) return ((TinyTemplateParserVisitor<? extends T>)visitor).visitValue(this);
 			else return visitor.visitChildren(this);
 		}
 	}
 
 	public final ValueContext value() throws RecognitionException {
 		ValueContext _localctx = new ValueContext(getState());
 		enterRule(_localctx, 8, );
 		try {
 			setState(111);
 			switch (.LA(1)) {
 			case :
 				enterOuterAlt(_localctx, 1);
 				{
 				setState(100); expression(0);
 				}
 				break;
 				enterOuterAlt(_localctx, 2);
 				{
 				setState(104); expression(0);
 				}
 				break;
 			case :
 				enterOuterAlt(_localctx, 3);
 				{
 				}
 				break;
 			default:
 				throw new NoViableAltException(this);
 			}
 		}
 		catch (RecognitionException re) {
 			_localctx.exception = re;
 			.recover(thisre);
 		}
 		finally {
 		}
 		return _localctx;
 	}
 
 	public static class DirectiveContext extends ParserRuleContext {
 		}
 		}
 		}
 		}
 		}
 		}
 		}
 		}
 		}
 		}
 		}
 		}
 		}
 		}
 		}
 		}
 		}
 		}
 		}
 		}
 		}
 		}
 		public DirectiveContext(ParserRuleContext parentint invokingState) {
 			super(parentinvokingState);
 		}
 		@Override public int getRuleIndex() { return ; }
 		public void enterRule(ParseTreeListener listener) {
 			if ( listener instanceof TinyTemplateParserListener ) ((TinyTemplateParserListener)listener).enterDirective(this);
 		}
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof TinyTemplateParserListener ) ((TinyTemplateParserListener)listener).exitDirective(this);
 		}
 		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
 			if ( visitor instanceof TinyTemplateParserVisitor ) return ((TinyTemplateParserVisitor<? extends T>)visitor).visitDirective(this);
 			else return visitor.visitChildren(this);
 		}
 	}
 
 	public final DirectiveContext directive() throws RecognitionException {
 		DirectiveContext _localctx = new DirectiveContext(getState());
 		enterRule(_localctx, 10, );
 		try {
 			setState(135);
 			switch (.LA(1)) {
 				enterOuterAlt(_localctx, 1);
 				{
 				}
 				break;
 				enterOuterAlt(_localctx, 2);
 				{
 				}
 				break;
 				enterOuterAlt(_localctx, 3);
 				{
 				}
 				break;
 				enterOuterAlt(_localctx, 4);
 				{
 				}
 				break;
 				enterOuterAlt(_localctx, 5);
 				{
 				}
 				break;
 				enterOuterAlt(_localctx, 6);
 				{
 				}
 				break;
 				enterOuterAlt(_localctx, 7);
 				{
 				}
 				break;
 				enterOuterAlt(_localctx, 8);
 				{
 				}
 				break;
 				enterOuterAlt(_localctx, 9);
 				{
 				}
 				break;
 				enterOuterAlt(_localctx, 10);
 				{
 				}
 				break;
 				enterOuterAlt(_localctx, 11);
 				{
 				}
 				break;
 				enterOuterAlt(_localctx, 12);
 				{
 				}
 				break;
 				enterOuterAlt(_localctx, 13);
 				{
 				}
 				break;
 				enterOuterAlt(_localctx, 14);
 				{
 				}
 				break;
 				enterOuterAlt(_localctx, 15);
 				{
 				}
 				break;
 				enterOuterAlt(_localctx, 16);
 				{
 				}
 				break;
 				enterOuterAlt(_localctx, 17);
 				{
 				}
 				break;
 				enterOuterAlt(_localctx, 18);
 				{
 				}
 				break;
 				enterOuterAlt(_localctx, 19);
 				{
 				}
 				break;
 				enterOuterAlt(_localctx, 20);
 				{
 				}
 				break;
 				enterOuterAlt(_localctx, 21);
 				{
 				}
 				break;
 			case :
 				enterOuterAlt(_localctx, 22);
 				{
 				}
 				break;
 			default:
 				throw new NoViableAltException(this);
 			}
 		}
 		catch (RecognitionException re) {
 			_localctx.exception = re;
 			.recover(thisre);
 		}
 		finally {
 		}
 		return _localctx;
 	}
 
 	public static class Identify_listContext extends ParserRuleContext {
 		public TerminalNode IDENTIFIER(int i) {
 		}
 		public Identify_listContext(ParserRuleContext parentint invokingState) {
 			super(parentinvokingState);
 		}
 		@Override public int getRuleIndex() { return ; }
 		public void enterRule(ParseTreeListener listener) {
 			if ( listener instanceof TinyTemplateParserListener ) ((TinyTemplateParserListener)listener).enterIdentify_list(this);
 		}
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof TinyTemplateParserListener ) ((TinyTemplateParserListener)listener).exitIdentify_list(this);
 		}
 		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
 			if ( visitor instanceof TinyTemplateParserVisitor ) return ((TinyTemplateParserVisitor<? extends T>)visitor).visitIdentify_list(this);
 			else return visitor.visitChildren(this);
 		}
 	}
 
 		enterRule(_localctx, 12, );
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
 			setState(142);
 			_la = .LA(1);
 			while (_la==) {
 				{
 				{
 				}
 				}
 				setState(144);
 				_la = .LA(1);
 			}
 			}
 		}
 		catch (RecognitionException re) {
 			_localctx.exception = re;
 			.recover(thisre);
 		}
 		finally {
 		}
 		return _localctx;
 	}
 
 	public static class Define_expression_listContext extends ParserRuleContext {
 		}
 		}
 		public Define_expression_listContext(ParserRuleContext parentint invokingState) {
 			super(parentinvokingState);
 		}
 		@Override public int getRuleIndex() { return ; }
 		public void enterRule(ParseTreeListener listener) {
 			if ( listener instanceof TinyTemplateParserListener ) ((TinyTemplateParserListener)listener).enterDefine_expression_list(this);
 		}
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof TinyTemplateParserListener ) ((TinyTemplateParserListener)listener).exitDefine_expression_list(this);
 		}
 		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
 			if ( visitor instanceof TinyTemplateParserVisitor ) return ((TinyTemplateParserVisitor<? extends T>)visitor).visitDefine_expression_list(this);
 			else return visitor.visitChildren(this);
 		}
 	}
 
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
 			setState(152);
 			_la = .LA(1);
 			while (_la== || _la==) {
 				{
 				{
 				setState(147);
 				_la = .LA(1);
 				if (_la==) {
 					{
 					setState(146); match();
 					}
 				}
 
 				}
 				}
 				setState(154);
 				_la = .LA(1);
 			}
 			}
 		}
 		catch (RecognitionException re) {
 			_localctx.exception = re;
 			.recover(thisre);
 		}
 		finally {
 		}
 		return _localctx;
 	}
 
 	public static class Para_expression_listContext extends ParserRuleContext {
 		}
 		}
 		public Para_expression_listContext(ParserRuleContext parentint invokingState) {
 			super(parentinvokingState);
 		}
 		@Override public int getRuleIndex() { return ; }
 		public void enterRule(ParseTreeListener listener) {
 			if ( listener instanceof TinyTemplateParserListener ) ((TinyTemplateParserListener)listener).enterPara_expression_list(this);
 		}
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof TinyTemplateParserListener ) ((TinyTemplateParserListener)listener).exitPara_expression_list(this);
 		}
 		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
 			if ( visitor instanceof TinyTemplateParserVisitor ) return ((TinyTemplateParserVisitor<? extends T>)visitor).visitPara_expression_list(this);
 			else return visitor.visitChildren(this);
 		}
 	}
 
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
 			setState(162);
 			_la = .LA(1);
 			while (((((_la - 47)) & ~0x3f) == 0 && ((1L << (_la - 47)) & ((1L << ( - 47)) | (1L << ( - 47)) | (1L << ( - 47)) | (1L << ( - 47)) | (1L << ( - 47)) | (1L << ( - 47)) | (1L << ( - 47)) | (1L << ( - 47)) | (1L << ( - 47)) | (1L << ( - 47)) | (1L << ( - 47)) | (1L << ( - 47)) | (1L << ( - 47)) | (1L << ( - 47)) | (1L << ( - 47)) | (1L << ( - 47)) | (1L << ( - 47)) | (1L << ( - 47)) | (1L << ( - 47)))) != 0)) {
 				{
 				{
 				setState(157);
 				_la = .LA(1);
 				if (_la==) {
 					{
 					setState(156); match();
 					}
 				}
 
 				}
 				}
 				setState(164);
 				_la = .LA(1);
 			}
 			}
 		}
 		catch (RecognitionException re) {
 			_localctx.exception = re;
 			.recover(thisre);
 		}
 		finally {
 		}
 		return _localctx;
 	}
 
 	public static class Para_expressionContext extends ParserRuleContext {
 		}
 		public Para_expressionContext(ParserRuleContext parentint invokingState) {
 			super(parentinvokingState);
 		}
 		@Override public int getRuleIndex() { return ; }
 		public void enterRule(ParseTreeListener listener) {
 			if ( listener instanceof TinyTemplateParserListener ) ((TinyTemplateParserListener)listener).enterPara_expression(this);
 		}
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof TinyTemplateParserListener ) ((TinyTemplateParserListener)listener).exitPara_expression(this);
 		}
 		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
 			if ( visitor instanceof TinyTemplateParserVisitor ) return ((TinyTemplateParserVisitor<? extends T>)visitor).visitPara_expression(this);
 			else return visitor.visitChildren(this);
 		}
 	}
 
 		enterRule(_localctx, 18, );
 		try {
 			setState(169);
 			switch ( getInterpreter().adaptivePredict(,9,) ) {
 			case 1:
 				enterOuterAlt(_localctx, 1);
 				{
 				setState(167); expression(0);
 				}
 				break;
 
 			case 2:
 				enterOuterAlt(_localctx, 2);
 				{
 				setState(168); expression(0);
 				}
 				break;
 			}
 		}
 		catch (RecognitionException re) {
 			_localctx.exception = re;
 			.recover(thisre);
 		}
 		finally {
 		}
 		return _localctx;
 	}
 
 	public static class Define_expressionContext extends ParserRuleContext {
 		}
 		public Define_expressionContext(ParserRuleContext parentint invokingState) {
 			super(parentinvokingState);
 		}
 		@Override public int getRuleIndex() { return ; }
 		public void enterRule(ParseTreeListener listener) {
 			if ( listener instanceof TinyTemplateParserListener ) ((TinyTemplateParserListener)listener).enterDefine_expression(this);
 		}
 		public void