metron-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ceste...@apache.org
Subject [3/6] incubator-metron git commit: METRON-362: Unify the Stellar Languages closes apache/incubator-metron#207
Date Thu, 11 Aug 2016 22:25:26 GMT
http://git-wip-us.apache.org/repos/asf/incubator-metron/blob/93054463/metron-platform/metron-common/src/main/java/org/apache/metron/common/stellar/generated/StellarParser.java
----------------------------------------------------------------------
diff --git a/metron-platform/metron-common/src/main/java/org/apache/metron/common/stellar/generated/StellarParser.java b/metron-platform/metron-common/src/main/java/org/apache/metron/common/stellar/generated/StellarParser.java
new file mode 100644
index 0000000..d3d603c
--- /dev/null
+++ b/metron-platform/metron-common/src/main/java/org/apache/metron/common/stellar/generated/StellarParser.java
@@ -0,0 +1,1793 @@
+// Generated from org/apache/metron/common/stellar/generated/Stellar.g4 by ANTLR 4.5
+package org.apache.metron.common.stellar.generated;
+
+//CHECKSTYLE:OFF
+/**
+ * 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.
+ */
+
+import org.antlr.v4.runtime.atn.*;
+import org.antlr.v4.runtime.dfa.DFA;
+import org.antlr.v4.runtime.*;
+import org.antlr.v4.runtime.misc.*;
+import org.antlr.v4.runtime.tree.*;
+import java.util.List;
+import java.util.Iterator;
+import java.util.ArrayList;
+
+@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
+public class StellarParser extends Parser {
+	static { RuntimeMetaData.checkVersion("4.5", RuntimeMetaData.VERSION); }
+
+	protected static final DFA[] _decisionToDFA;
+	protected static final PredictionContextCache _sharedContextCache =
+		new PredictionContextCache();
+	public static final int
+		COMMA=1, AND=2, OR=3, NOT=4, TRUE=5, FALSE=6, EQ=7, NEQ=8, LT=9, LTE=10, 
+		GT=11, GTE=12, QUESTION=13, COLON=14, IF=15, MINUS=16, PLUS=17, DIV=18, 
+		MUL=19, LBRACKET=20, RBRACKET=21, LPAREN=22, RPAREN=23, IN=24, NIN=25, 
+		EXISTS=26, INT_LITERAL=27, DOUBLE_LITERAL=28, IDENTIFIER=29, STRING_LITERAL=30, 
+		COMMENT=31, WS=32;
+	public static final int
+		RULE_transformation = 0, RULE_transformation_expr = 1, RULE_comparison_expr = 2, 
+		RULE_comparison_operand = 3, RULE_transformation_entity = 4, RULE_comp_operator = 5, 
+		RULE_arith_operator_addition = 6, RULE_arith_operator_mul = 7, RULE_func_args = 8, 
+		RULE_op_list = 9, RULE_list_entity = 10, RULE_arithmetic_expr = 11, RULE_arithmetic_expr_mul = 12, 
+		RULE_functions = 13, RULE_arithmetic_operands = 14, RULE_identifier_operand = 15;
+	public static final String[] ruleNames = {
+		"transformation", "transformation_expr", "comparison_expr", "comparison_operand", 
+		"transformation_entity", "comp_operator", "arith_operator_addition", "arith_operator_mul", 
+		"func_args", "op_list", "list_entity", "arithmetic_expr", "arithmetic_expr_mul", 
+		"functions", "arithmetic_operands", "identifier_operand"
+	};
+
+	private static final String[] _LITERAL_NAMES = {
+		null, "','", null, null, null, null, null, "'=='", "'!='", "'<'", "'<='", 
+		"'>'", "'>='", null, null, null, "'-'", "'+'", "'/'", "'*'", "'['", "']'", 
+		"'('", "')'", "'in'", "'not in'"
+	};
+	private static final String[] _SYMBOLIC_NAMES = {
+		null, "COMMA", "AND", "OR", "NOT", "TRUE", "FALSE", "EQ", "NEQ", "LT", 
+		"LTE", "GT", "GTE", "QUESTION", "COLON", "IF", "MINUS", "PLUS", "DIV", 
+		"MUL", "LBRACKET", "RBRACKET", "LPAREN", "RPAREN", "IN", "NIN", "EXISTS", 
+		"INT_LITERAL", "DOUBLE_LITERAL", "IDENTIFIER", "STRING_LITERAL", "COMMENT", 
+		"WS"
+	};
+	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
+
+	/**
+	 * @deprecated Use {@link #VOCABULARY} instead.
+	 */
+	@Deprecated
+	public static final String[] tokenNames;
+	static {
+		tokenNames = new String[_SYMBOLIC_NAMES.length];
+		for (int i = 0; i < tokenNames.length; i++) {
+			tokenNames[i] = VOCABULARY.getLiteralName(i);
+			if (tokenNames[i] == null) {
+				tokenNames[i] = VOCABULARY.getSymbolicName(i);
+			}
+
+			if (tokenNames[i] == null) {
+				tokenNames[i] = "<INVALID>";
+			}
+		}
+	}
+
+	@Override
+	@Deprecated
+	public String[] getTokenNames() {
+		return tokenNames;
+	}
+
+	@Override
+
+	public Vocabulary getVocabulary() {
+		return VOCABULARY;
+	}
+
+	@Override
+	public String getGrammarFileName() { return "Stellar.g4"; }
+
+	@Override
+	public String[] getRuleNames() { return ruleNames; }
+
+	@Override
+	public String getSerializedATN() { return _serializedATN; }
+
+	@Override
+	public ATN getATN() { return _ATN; }
+
+	public StellarParser(TokenStream input) {
+		super(input);
+		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
+	}
+	public static class TransformationContext extends ParserRuleContext {
+		public Transformation_exprContext transformation_expr() {
+			return getRuleContext(Transformation_exprContext.class,0);
+		}
+		public TerminalNode EOF() { return getToken(StellarParser.EOF, 0); }
+		public TransformationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_transformation; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterTransformation(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitTransformation(this);
+		}
+	}
+
+	public final TransformationContext transformation() throws RecognitionException {
+		TransformationContext _localctx = new TransformationContext(_ctx, getState());
+		enterRule(_localctx, 0, RULE_transformation);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(32);
+			transformation_expr(0);
+			setState(33);
+			match(EOF);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class Transformation_exprContext extends ParserRuleContext {
+		public Transformation_exprContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_transformation_expr; }
+	 
+		public Transformation_exprContext() { }
+		public void copyFrom(Transformation_exprContext ctx) {
+			super.copyFrom(ctx);
+		}
+	}
+	public static class ComparisonExpressionContext extends Transformation_exprContext {
+		public Comparison_exprContext comparison_expr() {
+			return getRuleContext(Comparison_exprContext.class,0);
+		}
+		public ComparisonExpressionContext(Transformation_exprContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterComparisonExpression(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitComparisonExpression(this);
+		}
+	}
+	public static class TernaryFuncContext extends Transformation_exprContext {
+		public TerminalNode IF() { return getToken(StellarParser.IF, 0); }
+		public List<Transformation_exprContext> transformation_expr() {
+			return getRuleContexts(Transformation_exprContext.class);
+		}
+		public Transformation_exprContext transformation_expr(int i) {
+			return getRuleContext(Transformation_exprContext.class,i);
+		}
+		public TerminalNode QUESTION() { return getToken(StellarParser.QUESTION, 0); }
+		public TerminalNode COLON() { return getToken(StellarParser.COLON, 0); }
+		public TernaryFuncContext(Transformation_exprContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterTernaryFunc(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitTernaryFunc(this);
+		}
+	}
+	public static class NotFuncContext extends Transformation_exprContext {
+		public TerminalNode NOT() { return getToken(StellarParser.NOT, 0); }
+		public TerminalNode LPAREN() { return getToken(StellarParser.LPAREN, 0); }
+		public Transformation_exprContext transformation_expr() {
+			return getRuleContext(Transformation_exprContext.class,0);
+		}
+		public TerminalNode RPAREN() { return getToken(StellarParser.RPAREN, 0); }
+		public NotFuncContext(Transformation_exprContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterNotFunc(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitNotFunc(this);
+		}
+	}
+	public static class TransformationEntityContext extends Transformation_exprContext {
+		public Transformation_entityContext transformation_entity() {
+			return getRuleContext(Transformation_entityContext.class,0);
+		}
+		public TransformationEntityContext(Transformation_exprContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterTransformationEntity(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitTransformationEntity(this);
+		}
+	}
+	public static class ArithExpressionContext extends Transformation_exprContext {
+		public Arithmetic_exprContext arithmetic_expr() {
+			return getRuleContext(Arithmetic_exprContext.class,0);
+		}
+		public ArithExpressionContext(Transformation_exprContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterArithExpression(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitArithExpression(this);
+		}
+	}
+	public static class TransformationExprContext extends Transformation_exprContext {
+		public TerminalNode LPAREN() { return getToken(StellarParser.LPAREN, 0); }
+		public Transformation_exprContext transformation_expr() {
+			return getRuleContext(Transformation_exprContext.class,0);
+		}
+		public TerminalNode RPAREN() { return getToken(StellarParser.RPAREN, 0); }
+		public TransformationExprContext(Transformation_exprContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterTransformationExpr(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitTransformationExpr(this);
+		}
+	}
+	public static class LogicalExpressionAndContext extends Transformation_exprContext {
+		public List<Transformation_exprContext> transformation_expr() {
+			return getRuleContexts(Transformation_exprContext.class);
+		}
+		public Transformation_exprContext transformation_expr(int i) {
+			return getRuleContext(Transformation_exprContext.class,i);
+		}
+		public TerminalNode AND() { return getToken(StellarParser.AND, 0); }
+		public LogicalExpressionAndContext(Transformation_exprContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterLogicalExpressionAnd(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitLogicalExpressionAnd(this);
+		}
+	}
+	public static class LogicalExpressionOrContext extends Transformation_exprContext {
+		public List<Transformation_exprContext> transformation_expr() {
+			return getRuleContexts(Transformation_exprContext.class);
+		}
+		public Transformation_exprContext transformation_expr(int i) {
+			return getRuleContext(Transformation_exprContext.class,i);
+		}
+		public TerminalNode OR() { return getToken(StellarParser.OR, 0); }
+		public LogicalExpressionOrContext(Transformation_exprContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterLogicalExpressionOr(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitLogicalExpressionOr(this);
+		}
+	}
+
+	public final Transformation_exprContext transformation_expr() throws RecognitionException {
+		return transformation_expr(0);
+	}
+
+	private Transformation_exprContext transformation_expr(int _p) throws RecognitionException {
+		ParserRuleContext _parentctx = _ctx;
+		int _parentState = getState();
+		Transformation_exprContext _localctx = new Transformation_exprContext(_ctx, _parentState);
+		Transformation_exprContext _prevctx = _localctx;
+		int _startState = 2;
+		enterRecursionRule(_localctx, 2, RULE_transformation_expr, _p);
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(55);
+			switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
+			case 1:
+				{
+				_localctx = new ComparisonExpressionContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+
+				setState(36);
+				comparison_expr();
+				}
+				break;
+			case 2:
+				{
+				_localctx = new TransformationExprContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(37);
+				match(LPAREN);
+				setState(38);
+				transformation_expr(0);
+				setState(39);
+				match(RPAREN);
+				}
+				break;
+			case 3:
+				{
+				_localctx = new TransformationEntityContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(41);
+				transformation_entity();
+				}
+				break;
+			case 4:
+				{
+				_localctx = new NotFuncContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(42);
+				match(NOT);
+				setState(43);
+				match(LPAREN);
+				setState(44);
+				transformation_expr(0);
+				setState(45);
+				match(RPAREN);
+				}
+				break;
+			case 5:
+				{
+				_localctx = new TernaryFuncContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(47);
+				match(IF);
+				setState(48);
+				transformation_expr(0);
+				setState(49);
+				match(QUESTION);
+				setState(50);
+				transformation_expr(0);
+				setState(51);
+				match(COLON);
+				setState(52);
+				transformation_expr(0);
+				}
+				break;
+			case 6:
+				{
+				_localctx = new ArithExpressionContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(54);
+				arithmetic_expr(0);
+				}
+				break;
+			}
+			_ctx.stop = _input.LT(-1);
+			setState(71);
+			_errHandler.sync(this);
+			_alt = getInterpreter().adaptivePredict(_input,2,_ctx);
+			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+				if ( _alt==1 ) {
+					if ( _parseListeners!=null ) triggerExitRuleEvent();
+					_prevctx = _localctx;
+					{
+					setState(69);
+					switch ( getInterpreter().adaptivePredict(_input,1,_ctx) ) {
+					case 1:
+						{
+						_localctx = new LogicalExpressionAndContext(new Transformation_exprContext(_parentctx, _parentState));
+						pushNewRecursionContext(_localctx, _startState, RULE_transformation_expr);
+						setState(57);
+						if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)");
+						setState(58);
+						match(AND);
+						setState(59);
+						transformation_expr(7);
+						}
+						break;
+					case 2:
+						{
+						_localctx = new LogicalExpressionOrContext(new Transformation_exprContext(_parentctx, _parentState));
+						pushNewRecursionContext(_localctx, _startState, RULE_transformation_expr);
+						setState(60);
+						if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
+						setState(61);
+						match(OR);
+						setState(62);
+						transformation_expr(6);
+						}
+						break;
+					case 3:
+						{
+						_localctx = new TernaryFuncContext(new Transformation_exprContext(_parentctx, _parentState));
+						pushNewRecursionContext(_localctx, _startState, RULE_transformation_expr);
+						setState(63);
+						if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
+						setState(64);
+						match(QUESTION);
+						setState(65);
+						transformation_expr(0);
+						setState(66);
+						match(COLON);
+						setState(67);
+						transformation_expr(4);
+						}
+						break;
+					}
+					} 
+				}
+				setState(73);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,2,_ctx);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			unrollRecursionContexts(_parentctx);
+		}
+		return _localctx;
+	}
+
+	public static class Comparison_exprContext extends ParserRuleContext {
+		public Comparison_exprContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_comparison_expr; }
+	 
+		public Comparison_exprContext() { }
+		public void copyFrom(Comparison_exprContext ctx) {
+			super.copyFrom(ctx);
+		}
+	}
+	public static class ComparisonExpressionParensContext extends Comparison_exprContext {
+		public TerminalNode LPAREN() { return getToken(StellarParser.LPAREN, 0); }
+		public Comparison_exprContext comparison_expr() {
+			return getRuleContext(Comparison_exprContext.class,0);
+		}
+		public TerminalNode RPAREN() { return getToken(StellarParser.RPAREN, 0); }
+		public ComparisonExpressionParensContext(Comparison_exprContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterComparisonExpressionParens(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitComparisonExpressionParens(this);
+		}
+	}
+	public static class InExpressionContext extends Comparison_exprContext {
+		public List<Identifier_operandContext> identifier_operand() {
+			return getRuleContexts(Identifier_operandContext.class);
+		}
+		public Identifier_operandContext identifier_operand(int i) {
+			return getRuleContext(Identifier_operandContext.class,i);
+		}
+		public TerminalNode IN() { return getToken(StellarParser.IN, 0); }
+		public InExpressionContext(Comparison_exprContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterInExpression(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitInExpression(this);
+		}
+	}
+	public static class ComparisonExpressionWithOperatorContext extends Comparison_exprContext {
+		public List<Comparison_operandContext> comparison_operand() {
+			return getRuleContexts(Comparison_operandContext.class);
+		}
+		public Comparison_operandContext comparison_operand(int i) {
+			return getRuleContext(Comparison_operandContext.class,i);
+		}
+		public Comp_operatorContext comp_operator() {
+			return getRuleContext(Comp_operatorContext.class,0);
+		}
+		public ComparisonExpressionWithOperatorContext(Comparison_exprContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterComparisonExpressionWithOperator(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitComparisonExpressionWithOperator(this);
+		}
+	}
+	public static class NInExpressionContext extends Comparison_exprContext {
+		public List<Identifier_operandContext> identifier_operand() {
+			return getRuleContexts(Identifier_operandContext.class);
+		}
+		public Identifier_operandContext identifier_operand(int i) {
+			return getRuleContext(Identifier_operandContext.class,i);
+		}
+		public TerminalNode NIN() { return getToken(StellarParser.NIN, 0); }
+		public NInExpressionContext(Comparison_exprContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterNInExpression(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitNInExpression(this);
+		}
+	}
+
+	public final Comparison_exprContext comparison_expr() throws RecognitionException {
+		Comparison_exprContext _localctx = new Comparison_exprContext(_ctx, getState());
+		enterRule(_localctx, 4, RULE_comparison_expr);
+		try {
+			setState(90);
+			switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) {
+			case 1:
+				_localctx = new ComparisonExpressionWithOperatorContext(_localctx);
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(74);
+				comparison_operand();
+				setState(75);
+				comp_operator();
+				setState(76);
+				comparison_operand();
+				}
+				break;
+			case 2:
+				_localctx = new InExpressionContext(_localctx);
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(78);
+				identifier_operand();
+				setState(79);
+				match(IN);
+				setState(80);
+				identifier_operand();
+				}
+				break;
+			case 3:
+				_localctx = new NInExpressionContext(_localctx);
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(82);
+				identifier_operand();
+				setState(83);
+				match(NIN);
+				setState(84);
+				identifier_operand();
+				}
+				break;
+			case 4:
+				_localctx = new ComparisonExpressionParensContext(_localctx);
+				enterOuterAlt(_localctx, 4);
+				{
+				setState(86);
+				match(LPAREN);
+				setState(87);
+				comparison_expr();
+				setState(88);
+				match(RPAREN);
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class Comparison_operandContext extends ParserRuleContext {
+		public Comparison_operandContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_comparison_operand; }
+	 
+		public Comparison_operandContext() { }
+		public void copyFrom(Comparison_operandContext ctx) {
+			super.copyFrom(ctx);
+		}
+	}
+	public static class IdentifierOperandContext extends Comparison_operandContext {
+		public Identifier_operandContext identifier_operand() {
+			return getRuleContext(Identifier_operandContext.class,0);
+		}
+		public IdentifierOperandContext(Comparison_operandContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterIdentifierOperand(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitIdentifierOperand(this);
+		}
+	}
+
+	public final Comparison_operandContext comparison_operand() throws RecognitionException {
+		Comparison_operandContext _localctx = new Comparison_operandContext(_ctx, getState());
+		enterRule(_localctx, 6, RULE_comparison_operand);
+		try {
+			_localctx = new IdentifierOperandContext(_localctx);
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(92);
+			identifier_operand();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class Transformation_entityContext extends ParserRuleContext {
+		public Identifier_operandContext identifier_operand() {
+			return getRuleContext(Identifier_operandContext.class,0);
+		}
+		public Transformation_entityContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_transformation_entity; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterTransformation_entity(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitTransformation_entity(this);
+		}
+	}
+
+	public final Transformation_entityContext transformation_entity() throws RecognitionException {
+		Transformation_entityContext _localctx = new Transformation_entityContext(_ctx, getState());
+		enterRule(_localctx, 8, RULE_transformation_entity);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(94);
+			identifier_operand();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class Comp_operatorContext extends ParserRuleContext {
+		public Comp_operatorContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_comp_operator; }
+	 
+		public Comp_operatorContext() { }
+		public void copyFrom(Comp_operatorContext ctx) {
+			super.copyFrom(ctx);
+		}
+	}
+	public static class ComparisonOpContext extends Comp_operatorContext {
+		public TerminalNode EQ() { return getToken(StellarParser.EQ, 0); }
+		public TerminalNode NEQ() { return getToken(StellarParser.NEQ, 0); }
+		public TerminalNode LT() { return getToken(StellarParser.LT, 0); }
+		public TerminalNode LTE() { return getToken(StellarParser.LTE, 0); }
+		public TerminalNode GT() { return getToken(StellarParser.GT, 0); }
+		public TerminalNode GTE() { return getToken(StellarParser.GTE, 0); }
+		public ComparisonOpContext(Comp_operatorContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterComparisonOp(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitComparisonOp(this);
+		}
+	}
+
+	public final Comp_operatorContext comp_operator() throws RecognitionException {
+		Comp_operatorContext _localctx = new Comp_operatorContext(_ctx, getState());
+		enterRule(_localctx, 10, RULE_comp_operator);
+		int _la;
+		try {
+			_localctx = new ComparisonOpContext(_localctx);
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(96);
+			_la = _input.LA(1);
+			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << EQ) | (1L << NEQ) | (1L << LT) | (1L << LTE) | (1L << GT) | (1L << GTE))) != 0)) ) {
+			_errHandler.recoverInline(this);
+			} else {
+				consume();
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class Arith_operator_additionContext extends ParserRuleContext {
+		public Arith_operator_additionContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_arith_operator_addition; }
+	 
+		public Arith_operator_additionContext() { }
+		public void copyFrom(Arith_operator_additionContext ctx) {
+			super.copyFrom(ctx);
+		}
+	}
+	public static class ArithOp_plusContext extends Arith_operator_additionContext {
+		public TerminalNode PLUS() { return getToken(StellarParser.PLUS, 0); }
+		public TerminalNode MINUS() { return getToken(StellarParser.MINUS, 0); }
+		public ArithOp_plusContext(Arith_operator_additionContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterArithOp_plus(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitArithOp_plus(this);
+		}
+	}
+
+	public final Arith_operator_additionContext arith_operator_addition() throws RecognitionException {
+		Arith_operator_additionContext _localctx = new Arith_operator_additionContext(_ctx, getState());
+		enterRule(_localctx, 12, RULE_arith_operator_addition);
+		int _la;
+		try {
+			_localctx = new ArithOp_plusContext(_localctx);
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(98);
+			_la = _input.LA(1);
+			if ( !(_la==MINUS || _la==PLUS) ) {
+			_errHandler.recoverInline(this);
+			} else {
+				consume();
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class Arith_operator_mulContext extends ParserRuleContext {
+		public Arith_operator_mulContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_arith_operator_mul; }
+	 
+		public Arith_operator_mulContext() { }
+		public void copyFrom(Arith_operator_mulContext ctx) {
+			super.copyFrom(ctx);
+		}
+	}
+	public static class ArithOp_mulContext extends Arith_operator_mulContext {
+		public TerminalNode MUL() { return getToken(StellarParser.MUL, 0); }
+		public TerminalNode DIV() { return getToken(StellarParser.DIV, 0); }
+		public ArithOp_mulContext(Arith_operator_mulContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterArithOp_mul(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitArithOp_mul(this);
+		}
+	}
+
+	public final Arith_operator_mulContext arith_operator_mul() throws RecognitionException {
+		Arith_operator_mulContext _localctx = new Arith_operator_mulContext(_ctx, getState());
+		enterRule(_localctx, 14, RULE_arith_operator_mul);
+		int _la;
+		try {
+			_localctx = new ArithOp_mulContext(_localctx);
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(100);
+			_la = _input.LA(1);
+			if ( !(_la==DIV || _la==MUL) ) {
+			_errHandler.recoverInline(this);
+			} else {
+				consume();
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class Func_argsContext extends ParserRuleContext {
+		public Op_listContext op_list() {
+			return getRuleContext(Op_listContext.class,0);
+		}
+		public Func_argsContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_func_args; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterFunc_args(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitFunc_args(this);
+		}
+	}
+
+	public final Func_argsContext func_args() throws RecognitionException {
+		Func_argsContext _localctx = new Func_argsContext(_ctx, getState());
+		enterRule(_localctx, 16, RULE_func_args);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(102);
+			op_list(0);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class Op_listContext extends ParserRuleContext {
+		public Identifier_operandContext identifier_operand() {
+			return getRuleContext(Identifier_operandContext.class,0);
+		}
+		public Op_listContext op_list() {
+			return getRuleContext(Op_listContext.class,0);
+		}
+		public TerminalNode COMMA() { return getToken(StellarParser.COMMA, 0); }
+		public Op_listContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_op_list; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterOp_list(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitOp_list(this);
+		}
+	}
+
+	public final Op_listContext op_list() throws RecognitionException {
+		return op_list(0);
+	}
+
+	private Op_listContext op_list(int _p) throws RecognitionException {
+		ParserRuleContext _parentctx = _ctx;
+		int _parentState = getState();
+		Op_listContext _localctx = new Op_listContext(_ctx, _parentState);
+		Op_listContext _prevctx = _localctx;
+		int _startState = 18;
+		enterRecursionRule(_localctx, 18, RULE_op_list, _p);
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			{
+			setState(105);
+			identifier_operand();
+			}
+			_ctx.stop = _input.LT(-1);
+			setState(112);
+			_errHandler.sync(this);
+			_alt = getInterpreter().adaptivePredict(_input,4,_ctx);
+			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+				if ( _alt==1 ) {
+					if ( _parseListeners!=null ) triggerExitRuleEvent();
+					_prevctx = _localctx;
+					{
+					{
+					_localctx = new Op_listContext(_parentctx, _parentState);
+					pushNewRecursionContext(_localctx, _startState, RULE_op_list);
+					setState(107);
+					if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
+					setState(108);
+					match(COMMA);
+					setState(109);
+					identifier_operand();
+					}
+					} 
+				}
+				setState(114);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,4,_ctx);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			unrollRecursionContexts(_parentctx);
+		}
+		return _localctx;
+	}
+
+	public static class List_entityContext extends ParserRuleContext {
+		public TerminalNode LBRACKET() { return getToken(StellarParser.LBRACKET, 0); }
+		public Op_listContext op_list() {
+			return getRuleContext(Op_listContext.class,0);
+		}
+		public TerminalNode RBRACKET() { return getToken(StellarParser.RBRACKET, 0); }
+		public List_entityContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_list_entity; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterList_entity(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitList_entity(this);
+		}
+	}
+
+	public final List_entityContext list_entity() throws RecognitionException {
+		List_entityContext _localctx = new List_entityContext(_ctx, getState());
+		enterRule(_localctx, 20, RULE_list_entity);
+		try {
+			setState(121);
+			switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(115);
+				match(LBRACKET);
+				setState(116);
+				op_list(0);
+				setState(117);
+				match(RBRACKET);
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(119);
+				match(LBRACKET);
+				setState(120);
+				match(RBRACKET);
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class Arithmetic_exprContext extends ParserRuleContext {
+		public Arithmetic_exprContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_arithmetic_expr; }
+	 
+		public Arithmetic_exprContext() { }
+		public void copyFrom(Arithmetic_exprContext ctx) {
+			super.copyFrom(ctx);
+		}
+	}
+	public static class ArithExpr_soloContext extends Arithmetic_exprContext {
+		public Arithmetic_expr_mulContext arithmetic_expr_mul() {
+			return getRuleContext(Arithmetic_expr_mulContext.class,0);
+		}
+		public ArithExpr_soloContext(Arithmetic_exprContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterArithExpr_solo(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitArithExpr_solo(this);
+		}
+	}
+	public static class ArithExpr_minusContext extends Arithmetic_exprContext {
+		public Arithmetic_exprContext arithmetic_expr() {
+			return getRuleContext(Arithmetic_exprContext.class,0);
+		}
+		public TerminalNode MINUS() { return getToken(StellarParser.MINUS, 0); }
+		public Arithmetic_expr_mulContext arithmetic_expr_mul() {
+			return getRuleContext(Arithmetic_expr_mulContext.class,0);
+		}
+		public ArithExpr_minusContext(Arithmetic_exprContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterArithExpr_minus(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitArithExpr_minus(this);
+		}
+	}
+	public static class ArithExpr_plusContext extends Arithmetic_exprContext {
+		public Arithmetic_exprContext arithmetic_expr() {
+			return getRuleContext(Arithmetic_exprContext.class,0);
+		}
+		public TerminalNode PLUS() { return getToken(StellarParser.PLUS, 0); }
+		public Arithmetic_expr_mulContext arithmetic_expr_mul() {
+			return getRuleContext(Arithmetic_expr_mulContext.class,0);
+		}
+		public ArithExpr_plusContext(Arithmetic_exprContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterArithExpr_plus(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitArithExpr_plus(this);
+		}
+	}
+
+	public final Arithmetic_exprContext arithmetic_expr() throws RecognitionException {
+		return arithmetic_expr(0);
+	}
+
+	private Arithmetic_exprContext arithmetic_expr(int _p) throws RecognitionException {
+		ParserRuleContext _parentctx = _ctx;
+		int _parentState = getState();
+		Arithmetic_exprContext _localctx = new Arithmetic_exprContext(_ctx, _parentState);
+		Arithmetic_exprContext _prevctx = _localctx;
+		int _startState = 22;
+		enterRecursionRule(_localctx, 22, RULE_arithmetic_expr, _p);
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			{
+			_localctx = new ArithExpr_soloContext(_localctx);
+			_ctx = _localctx;
+			_prevctx = _localctx;
+
+			setState(124);
+			arithmetic_expr_mul(0);
+			}
+			_ctx.stop = _input.LT(-1);
+			setState(134);
+			_errHandler.sync(this);
+			_alt = getInterpreter().adaptivePredict(_input,7,_ctx);
+			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+				if ( _alt==1 ) {
+					if ( _parseListeners!=null ) triggerExitRuleEvent();
+					_prevctx = _localctx;
+					{
+					setState(132);
+					switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) {
+					case 1:
+						{
+						_localctx = new ArithExpr_plusContext(new Arithmetic_exprContext(_parentctx, _parentState));
+						pushNewRecursionContext(_localctx, _startState, RULE_arithmetic_expr);
+						setState(126);
+						if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
+						setState(127);
+						match(PLUS);
+						setState(128);
+						arithmetic_expr_mul(0);
+						}
+						break;
+					case 2:
+						{
+						_localctx = new ArithExpr_minusContext(new Arithmetic_exprContext(_parentctx, _parentState));
+						pushNewRecursionContext(_localctx, _startState, RULE_arithmetic_expr);
+						setState(129);
+						if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
+						setState(130);
+						match(MINUS);
+						setState(131);
+						arithmetic_expr_mul(0);
+						}
+						break;
+					}
+					} 
+				}
+				setState(136);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,7,_ctx);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			unrollRecursionContexts(_parentctx);
+		}
+		return _localctx;
+	}
+
+	public static class Arithmetic_expr_mulContext extends ParserRuleContext {
+		public Arithmetic_expr_mulContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_arithmetic_expr_mul; }
+	 
+		public Arithmetic_expr_mulContext() { }
+		public void copyFrom(Arithmetic_expr_mulContext ctx) {
+			super.copyFrom(ctx);
+		}
+	}
+	public static class ArithExpr_divContext extends Arithmetic_expr_mulContext {
+		public List<Arithmetic_expr_mulContext> arithmetic_expr_mul() {
+			return getRuleContexts(Arithmetic_expr_mulContext.class);
+		}
+		public Arithmetic_expr_mulContext arithmetic_expr_mul(int i) {
+			return getRuleContext(Arithmetic_expr_mulContext.class,i);
+		}
+		public TerminalNode DIV() { return getToken(StellarParser.DIV, 0); }
+		public ArithExpr_divContext(Arithmetic_expr_mulContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterArithExpr_div(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitArithExpr_div(this);
+		}
+	}
+	public static class ArithExpr_mul_soloContext extends Arithmetic_expr_mulContext {
+		public Arithmetic_operandsContext arithmetic_operands() {
+			return getRuleContext(Arithmetic_operandsContext.class,0);
+		}
+		public ArithExpr_mul_soloContext(Arithmetic_expr_mulContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterArithExpr_mul_solo(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitArithExpr_mul_solo(this);
+		}
+	}
+	public static class ArithExpr_mulContext extends Arithmetic_expr_mulContext {
+		public List<Arithmetic_expr_mulContext> arithmetic_expr_mul() {
+			return getRuleContexts(Arithmetic_expr_mulContext.class);
+		}
+		public Arithmetic_expr_mulContext arithmetic_expr_mul(int i) {
+			return getRuleContext(Arithmetic_expr_mulContext.class,i);
+		}
+		public TerminalNode MUL() { return getToken(StellarParser.MUL, 0); }
+		public ArithExpr_mulContext(Arithmetic_expr_mulContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterArithExpr_mul(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitArithExpr_mul(this);
+		}
+	}
+
+	public final Arithmetic_expr_mulContext arithmetic_expr_mul() throws RecognitionException {
+		return arithmetic_expr_mul(0);
+	}
+
+	private Arithmetic_expr_mulContext arithmetic_expr_mul(int _p) throws RecognitionException {
+		ParserRuleContext _parentctx = _ctx;
+		int _parentState = getState();
+		Arithmetic_expr_mulContext _localctx = new Arithmetic_expr_mulContext(_ctx, _parentState);
+		Arithmetic_expr_mulContext _prevctx = _localctx;
+		int _startState = 24;
+		enterRecursionRule(_localctx, 24, RULE_arithmetic_expr_mul, _p);
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			{
+			_localctx = new ArithExpr_mul_soloContext(_localctx);
+			_ctx = _localctx;
+			_prevctx = _localctx;
+
+			setState(138);
+			arithmetic_operands();
+			}
+			_ctx.stop = _input.LT(-1);
+			setState(148);
+			_errHandler.sync(this);
+			_alt = getInterpreter().adaptivePredict(_input,9,_ctx);
+			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+				if ( _alt==1 ) {
+					if ( _parseListeners!=null ) triggerExitRuleEvent();
+					_prevctx = _localctx;
+					{
+					setState(146);
+					switch ( getInterpreter().adaptivePredict(_input,8,_ctx) ) {
+					case 1:
+						{
+						_localctx = new ArithExpr_mulContext(new Arithmetic_expr_mulContext(_parentctx, _parentState));
+						pushNewRecursionContext(_localctx, _startState, RULE_arithmetic_expr_mul);
+						setState(140);
+						if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
+						setState(141);
+						match(MUL);
+						setState(142);
+						arithmetic_expr_mul(3);
+						}
+						break;
+					case 2:
+						{
+						_localctx = new ArithExpr_divContext(new Arithmetic_expr_mulContext(_parentctx, _parentState));
+						pushNewRecursionContext(_localctx, _startState, RULE_arithmetic_expr_mul);
+						setState(143);
+						if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
+						setState(144);
+						match(DIV);
+						setState(145);
+						arithmetic_expr_mul(2);
+						}
+						break;
+					}
+					} 
+				}
+				setState(150);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,9,_ctx);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			unrollRecursionContexts(_parentctx);
+		}
+		return _localctx;
+	}
+
+	public static class FunctionsContext extends ParserRuleContext {
+		public FunctionsContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_functions; }
+	 
+		public FunctionsContext() { }
+		public void copyFrom(FunctionsContext ctx) {
+			super.copyFrom(ctx);
+		}
+	}
+	public static class TransformationFuncContext extends FunctionsContext {
+		public TerminalNode IDENTIFIER() { return getToken(StellarParser.IDENTIFIER, 0); }
+		public TerminalNode LPAREN() { return getToken(StellarParser.LPAREN, 0); }
+		public Func_argsContext func_args() {
+			return getRuleContext(Func_argsContext.class,0);
+		}
+		public TerminalNode RPAREN() { return getToken(StellarParser.RPAREN, 0); }
+		public TransformationFuncContext(FunctionsContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterTransformationFunc(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitTransformationFunc(this);
+		}
+	}
+
+	public final FunctionsContext functions() throws RecognitionException {
+		FunctionsContext _localctx = new FunctionsContext(_ctx, getState());
+		enterRule(_localctx, 26, RULE_functions);
+		try {
+			_localctx = new TransformationFuncContext(_localctx);
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(151);
+			match(IDENTIFIER);
+			setState(152);
+			match(LPAREN);
+			setState(153);
+			func_args();
+			setState(154);
+			match(RPAREN);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class Arithmetic_operandsContext extends ParserRuleContext {
+		public Arithmetic_operandsContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_arithmetic_operands; }
+	 
+		public Arithmetic_operandsContext() { }
+		public void copyFrom(Arithmetic_operandsContext ctx) {
+			super.copyFrom(ctx);
+		}
+	}
+	public static class VariableContext extends Arithmetic_operandsContext {
+		public TerminalNode IDENTIFIER() { return getToken(StellarParser.IDENTIFIER, 0); }
+		public VariableContext(Arithmetic_operandsContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterVariable(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitVariable(this);
+		}
+	}
+	public static class NumericFunctionsContext extends Arithmetic_operandsContext {
+		public FunctionsContext functions() {
+			return getRuleContext(FunctionsContext.class,0);
+		}
+		public NumericFunctionsContext(Arithmetic_operandsContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterNumericFunctions(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitNumericFunctions(this);
+		}
+	}
+	public static class ParenArithContext extends Arithmetic_operandsContext {
+		public TerminalNode LPAREN() { return getToken(StellarParser.LPAREN, 0); }
+		public Arithmetic_exprContext arithmetic_expr() {
+			return getRuleContext(Arithmetic_exprContext.class,0);
+		}
+		public TerminalNode RPAREN() { return getToken(StellarParser.RPAREN, 0); }
+		public ParenArithContext(Arithmetic_operandsContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterParenArith(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitParenArith(this);
+		}
+	}
+	public static class IntLiteralContext extends Arithmetic_operandsContext {
+		public TerminalNode INT_LITERAL() { return getToken(StellarParser.INT_LITERAL, 0); }
+		public IntLiteralContext(Arithmetic_operandsContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterIntLiteral(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitIntLiteral(this);
+		}
+	}
+	public static class DoubleLiteralContext extends Arithmetic_operandsContext {
+		public TerminalNode DOUBLE_LITERAL() { return getToken(StellarParser.DOUBLE_LITERAL, 0); }
+		public DoubleLiteralContext(Arithmetic_operandsContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterDoubleLiteral(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitDoubleLiteral(this);
+		}
+	}
+
+	public final Arithmetic_operandsContext arithmetic_operands() throws RecognitionException {
+		Arithmetic_operandsContext _localctx = new Arithmetic_operandsContext(_ctx, getState());
+		enterRule(_localctx, 28, RULE_arithmetic_operands);
+		try {
+			setState(164);
+			switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
+			case 1:
+				_localctx = new NumericFunctionsContext(_localctx);
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(156);
+				functions();
+				}
+				break;
+			case 2:
+				_localctx = new DoubleLiteralContext(_localctx);
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(157);
+				match(DOUBLE_LITERAL);
+				}
+				break;
+			case 3:
+				_localctx = new IntLiteralContext(_localctx);
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(158);
+				match(INT_LITERAL);
+				}
+				break;
+			case 4:
+				_localctx = new VariableContext(_localctx);
+				enterOuterAlt(_localctx, 4);
+				{
+				setState(159);
+				match(IDENTIFIER);
+				}
+				break;
+			case 5:
+				_localctx = new ParenArithContext(_localctx);
+				enterOuterAlt(_localctx, 5);
+				{
+				setState(160);
+				match(LPAREN);
+				setState(161);
+				arithmetic_expr(0);
+				setState(162);
+				match(RPAREN);
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class Identifier_operandContext extends ParserRuleContext {
+		public Identifier_operandContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_identifier_operand; }
+	 
+		public Identifier_operandContext() { }
+		public void copyFrom(Identifier_operandContext ctx) {
+			super.copyFrom(ctx);
+		}
+	}
+	public static class ArithmeticOperandsContext extends Identifier_operandContext {
+		public Arithmetic_exprContext arithmetic_expr() {
+			return getRuleContext(Arithmetic_exprContext.class,0);
+		}
+		public ArithmeticOperandsContext(Identifier_operandContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterArithmeticOperands(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitArithmeticOperands(this);
+		}
+	}
+	public static class StringLiteralContext extends Identifier_operandContext {
+		public TerminalNode STRING_LITERAL() { return getToken(StellarParser.STRING_LITERAL, 0); }
+		public StringLiteralContext(Identifier_operandContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterStringLiteral(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitStringLiteral(this);
+		}
+	}
+	public static class ListContext extends Identifier_operandContext {
+		public List_entityContext list_entity() {
+			return getRuleContext(List_entityContext.class,0);
+		}
+		public ListContext(Identifier_operandContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterList(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitList(this);
+		}
+	}
+	public static class LogicalConstContext extends Identifier_operandContext {
+		public TerminalNode TRUE() { return getToken(StellarParser.TRUE, 0); }
+		public TerminalNode FALSE() { return getToken(StellarParser.FALSE, 0); }
+		public LogicalConstContext(Identifier_operandContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterLogicalConst(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitLogicalConst(this);
+		}
+	}
+	public static class ExistsFuncContext extends Identifier_operandContext {
+		public TerminalNode EXISTS() { return getToken(StellarParser.EXISTS, 0); }
+		public TerminalNode LPAREN() { return getToken(StellarParser.LPAREN, 0); }
+		public TerminalNode IDENTIFIER() { return getToken(StellarParser.IDENTIFIER, 0); }
+		public TerminalNode RPAREN() { return getToken(StellarParser.RPAREN, 0); }
+		public ExistsFuncContext(Identifier_operandContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).enterExistsFunc(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof StellarListener ) ((StellarListener)listener).exitExistsFunc(this);
+		}
+	}
+
+	public final Identifier_operandContext identifier_operand() throws RecognitionException {
+		Identifier_operandContext _localctx = new Identifier_operandContext(_ctx, getState());
+		enterRule(_localctx, 30, RULE_identifier_operand);
+		int _la;
+		try {
+			setState(174);
+			switch (_input.LA(1)) {
+			case TRUE:
+			case FALSE:
+				_localctx = new LogicalConstContext(_localctx);
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(166);
+				_la = _input.LA(1);
+				if ( !(_la==TRUE || _la==FALSE) ) {
+				_errHandler.recoverInline(this);
+				} else {
+					consume();
+				}
+				}
+				break;
+			case LPAREN:
+			case INT_LITERAL:
+			case DOUBLE_LITERAL:
+			case IDENTIFIER:
+				_localctx = new ArithmeticOperandsContext(_localctx);
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(167);
+				arithmetic_expr(0);
+				}
+				break;
+			case STRING_LITERAL:
+				_localctx = new StringLiteralContext(_localctx);
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(168);
+				match(STRING_LITERAL);
+				}
+				break;
+			case LBRACKET:
+				_localctx = new ListContext(_localctx);
+				enterOuterAlt(_localctx, 4);
+				{
+				setState(169);
+				list_entity();
+				}
+				break;
+			case EXISTS:
+				_localctx = new ExistsFuncContext(_localctx);
+				enterOuterAlt(_localctx, 5);
+				{
+				setState(170);
+				match(EXISTS);
+				setState(171);
+				match(LPAREN);
+				setState(172);
+				match(IDENTIFIER);
+				setState(173);
+				match(RPAREN);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
+		switch (ruleIndex) {
+		case 1:
+			return transformation_expr_sempred((Transformation_exprContext)_localctx, predIndex);
+		case 9:
+			return op_list_sempred((Op_listContext)_localctx, predIndex);
+		case 11:
+			return arithmetic_expr_sempred((Arithmetic_exprContext)_localctx, predIndex);
+		case 12:
+			return arithmetic_expr_mul_sempred((Arithmetic_expr_mulContext)_localctx, predIndex);
+		}
+		return true;
+	}
+	private boolean transformation_expr_sempred(Transformation_exprContext _localctx, int predIndex) {
+		switch (predIndex) {
+		case 0:
+			return precpred(_ctx, 6);
+		case 1:
+			return precpred(_ctx, 5);
+		case 2:
+			return precpred(_ctx, 3);
+		}
+		return true;
+	}
+	private boolean op_list_sempred(Op_listContext _localctx, int predIndex) {
+		switch (predIndex) {
+		case 3:
+			return precpred(_ctx, 1);
+		}
+		return true;
+	}
+	private boolean arithmetic_expr_sempred(Arithmetic_exprContext _localctx, int predIndex) {
+		switch (predIndex) {
+		case 4:
+			return precpred(_ctx, 2);
+		case 5:
+			return precpred(_ctx, 1);
+		}
+		return true;
+	}
+	private boolean arithmetic_expr_mul_sempred(Arithmetic_expr_mulContext _localctx, int predIndex) {
+		switch (predIndex) {
+		case 6:
+			return precpred(_ctx, 2);
+		case 7:
+			return precpred(_ctx, 1);
+		}
+		return true;
+	}
+
+	public static final String _serializedATN =
+		"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3\"\u00b3\4\2\t\2\4"+
+		"\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
+		"\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\3\2\3\2\3"+
+		"\2\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3"+
+		"\3\3\3\3\3\3\5\3:\n\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3"+
+		"\7\3H\n\3\f\3\16\3K\13\3\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3"+
+		"\4\3\4\3\4\3\4\3\4\5\4]\n\4\3\5\3\5\3\6\3\6\3\7\3\7\3\b\3\b\3\t\3\t\3"+
+		"\n\3\n\3\13\3\13\3\13\3\13\3\13\3\13\7\13q\n\13\f\13\16\13t\13\13\3\f"+
+		"\3\f\3\f\3\f\3\f\3\f\5\f|\n\f\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\7\r"+
+		"\u0087\n\r\f\r\16\r\u008a\13\r\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16"+
+		"\3\16\7\16\u0095\n\16\f\16\16\16\u0098\13\16\3\17\3\17\3\17\3\17\3\17"+
+		"\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\5\20\u00a7\n\20\3\21\3\21\3\21"+
+		"\3\21\3\21\3\21\3\21\3\21\5\21\u00b1\n\21\3\21\2\6\4\24\30\32\22\2\4\6"+
+		"\b\n\f\16\20\22\24\26\30\32\34\36 \2\6\3\2\t\16\3\2\22\23\3\2\24\25\3"+
+		"\2\7\b\u00bb\2\"\3\2\2\2\49\3\2\2\2\6\\\3\2\2\2\b^\3\2\2\2\n`\3\2\2\2"+
+		"\fb\3\2\2\2\16d\3\2\2\2\20f\3\2\2\2\22h\3\2\2\2\24j\3\2\2\2\26{\3\2\2"+
+		"\2\30}\3\2\2\2\32\u008b\3\2\2\2\34\u0099\3\2\2\2\36\u00a6\3\2\2\2 \u00b0"+
+		"\3\2\2\2\"#\5\4\3\2#$\7\2\2\3$\3\3\2\2\2%&\b\3\1\2&:\5\6\4\2\'(\7\30\2"+
+		"\2()\5\4\3\2)*\7\31\2\2*:\3\2\2\2+:\5\n\6\2,-\7\6\2\2-.\7\30\2\2./\5\4"+
+		"\3\2/\60\7\31\2\2\60:\3\2\2\2\61\62\7\21\2\2\62\63\5\4\3\2\63\64\7\17"+
+		"\2\2\64\65\5\4\3\2\65\66\7\20\2\2\66\67\5\4\3\2\67:\3\2\2\28:\5\30\r\2"+
+		"9%\3\2\2\29\'\3\2\2\29+\3\2\2\29,\3\2\2\29\61\3\2\2\298\3\2\2\2:I\3\2"+
+		"\2\2;<\f\b\2\2<=\7\4\2\2=H\5\4\3\t>?\f\7\2\2?@\7\5\2\2@H\5\4\3\bAB\f\5"+
+		"\2\2BC\7\17\2\2CD\5\4\3\2DE\7\20\2\2EF\5\4\3\6FH\3\2\2\2G;\3\2\2\2G>\3"+
+		"\2\2\2GA\3\2\2\2HK\3\2\2\2IG\3\2\2\2IJ\3\2\2\2J\5\3\2\2\2KI\3\2\2\2LM"+
+		"\5\b\5\2MN\5\f\7\2NO\5\b\5\2O]\3\2\2\2PQ\5 \21\2QR\7\32\2\2RS\5 \21\2"+
+		"S]\3\2\2\2TU\5 \21\2UV\7\33\2\2VW\5 \21\2W]\3\2\2\2XY\7\30\2\2YZ\5\6\4"+
+		"\2Z[\7\31\2\2[]\3\2\2\2\\L\3\2\2\2\\P\3\2\2\2\\T\3\2\2\2\\X\3\2\2\2]\7"+
+		"\3\2\2\2^_\5 \21\2_\t\3\2\2\2`a\5 \21\2a\13\3\2\2\2bc\t\2\2\2c\r\3\2\2"+
+		"\2de\t\3\2\2e\17\3\2\2\2fg\t\4\2\2g\21\3\2\2\2hi\5\24\13\2i\23\3\2\2\2"+
+		"jk\b\13\1\2kl\5 \21\2lr\3\2\2\2mn\f\3\2\2no\7\3\2\2oq\5 \21\2pm\3\2\2"+
+		"\2qt\3\2\2\2rp\3\2\2\2rs\3\2\2\2s\25\3\2\2\2tr\3\2\2\2uv\7\26\2\2vw\5"+
+		"\24\13\2wx\7\27\2\2x|\3\2\2\2yz\7\26\2\2z|\7\27\2\2{u\3\2\2\2{y\3\2\2"+
+		"\2|\27\3\2\2\2}~\b\r\1\2~\177\5\32\16\2\177\u0088\3\2\2\2\u0080\u0081"+
+		"\f\4\2\2\u0081\u0082\7\23\2\2\u0082\u0087\5\32\16\2\u0083\u0084\f\3\2"+
+		"\2\u0084\u0085\7\22\2\2\u0085\u0087\5\32\16\2\u0086\u0080\3\2\2\2\u0086"+
+		"\u0083\3\2\2\2\u0087\u008a\3\2\2\2\u0088\u0086\3\2\2\2\u0088\u0089\3\2"+
+		"\2\2\u0089\31\3\2\2\2\u008a\u0088\3\2\2\2\u008b\u008c\b\16\1\2\u008c\u008d"+
+		"\5\36\20\2\u008d\u0096\3\2\2\2\u008e\u008f\f\4\2\2\u008f\u0090\7\25\2"+
+		"\2\u0090\u0095\5\32\16\5\u0091\u0092\f\3\2\2\u0092\u0093\7\24\2\2\u0093"+
+		"\u0095\5\32\16\4\u0094\u008e\3\2\2\2\u0094\u0091\3\2\2\2\u0095\u0098\3"+
+		"\2\2\2\u0096\u0094\3\2\2\2\u0096\u0097\3\2\2\2\u0097\33\3\2\2\2\u0098"+
+		"\u0096\3\2\2\2\u0099\u009a\7\37\2\2\u009a\u009b\7\30\2\2\u009b\u009c\5"+
+		"\22\n\2\u009c\u009d\7\31\2\2\u009d\35\3\2\2\2\u009e\u00a7\5\34\17\2\u009f"+
+		"\u00a7\7\36\2\2\u00a0\u00a7\7\35\2\2\u00a1\u00a7\7\37\2\2\u00a2\u00a3"+
+		"\7\30\2\2\u00a3\u00a4\5\30\r\2\u00a4\u00a5\7\31\2\2\u00a5\u00a7\3\2\2"+
+		"\2\u00a6\u009e\3\2\2\2\u00a6\u009f\3\2\2\2\u00a6\u00a0\3\2\2\2\u00a6\u00a1"+
+		"\3\2\2\2\u00a6\u00a2\3\2\2\2\u00a7\37\3\2\2\2\u00a8\u00b1\t\5\2\2\u00a9"+
+		"\u00b1\5\30\r\2\u00aa\u00b1\7 \2\2\u00ab\u00b1\5\26\f\2\u00ac\u00ad\7"+
+		"\34\2\2\u00ad\u00ae\7\30\2\2\u00ae\u00af\7\37\2\2\u00af\u00b1\7\31\2\2"+
+		"\u00b0\u00a8\3\2\2\2\u00b0\u00a9\3\2\2\2\u00b0\u00aa\3\2\2\2\u00b0\u00ab"+
+		"\3\2\2\2\u00b0\u00ac\3\2\2\2\u00b1!\3\2\2\2\169GI\\r{\u0086\u0088\u0094"+
+		"\u0096\u00a6\u00b0";
+	public static final ATN _ATN =
+		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
+	static {
+		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
+		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
+			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
+		}
+	}
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-metron/blob/93054463/metron-platform/metron-common/src/main/java/org/apache/metron/common/transformation/TransformationCompiler.java
----------------------------------------------------------------------
diff --git a/metron-platform/metron-common/src/main/java/org/apache/metron/common/transformation/TransformationCompiler.java b/metron-platform/metron-common/src/main/java/org/apache/metron/common/transformation/TransformationCompiler.java
deleted file mode 100644
index 2d9f0bd..0000000
--- a/metron-platform/metron-common/src/main/java/org/apache/metron/common/transformation/TransformationCompiler.java
+++ /dev/null
@@ -1,160 +0,0 @@
-/**
- * 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.metron.common.transformation;
-
-import com.google.common.base.Joiner;
-import org.apache.metron.common.dsl.Token;
-import org.apache.metron.common.dsl.TransformationFunctions;
-import org.apache.metron.common.dsl.FunctionMarker;
-import org.apache.metron.common.dsl.ParseException;
-import org.apache.metron.common.dsl.VariableResolver;
-import org.apache.metron.common.transformation.generated.TransformationBaseListener;
-import org.apache.metron.common.transformation.generated.TransformationParser;
-
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Stack;
-import java.util.function.Function;
-
-public class TransformationCompiler extends TransformationBaseListener {
-  private VariableResolver resolver = null;
-  private Stack<Token> tokenStack = new Stack<>();
-  public TransformationCompiler(VariableResolver resolver) {
-    this.resolver = resolver;
-  }
-
-  @Override
-  public void enterTransformation(TransformationParser.TransformationContext ctx) {
-    tokenStack.clear();
-  }
-
-
-  @Override
-  public void exitVariable(TransformationParser.VariableContext ctx) {
-    tokenStack.push(new Token<>(resolver.resolve(ctx.getText()), Object.class));
-  }
-
-  @Override
-  public void exitStringLiteral(TransformationParser.StringLiteralContext ctx) {
-    tokenStack.push(new Token<>(ctx.getText().substring(1, ctx.getText().length() - 1), String.class));
-  }
-
-
-  @Override
-  public void exitIntegerLiteral(TransformationParser.IntegerLiteralContext ctx) {
-    tokenStack.push(new Token<>(Integer.parseInt(ctx.getText()), Integer.class));
-  }
-
-
-  @Override
-  public void exitDoubleLiteral(TransformationParser.DoubleLiteralContext ctx) {
-    tokenStack.push(new Token<>(Double.parseDouble(ctx.getText()), Double.class));
-  }
-
-
-  @Override
-  public void exitTransformationFunc(TransformationParser.TransformationFuncContext ctx) {
-    String funcName = ctx.getChild(0).getText();
-    Function<List<Object>, Object> func;
-    try {
-      func = TransformationFunctions.valueOf(funcName);
-    }
-    catch(IllegalArgumentException iae) {
-      throw new ParseException("Unable to find string function " + funcName + ".  Valid functions are "
-              + Joiner.on(',').join(TransformationFunctions.values())
-      );
-    }
-    Token<?> left = popStack();
-    List<Object> argList = null;
-    if(left.getUnderlyingType().equals(List.class)) {
-      argList = (List<Object>) left.getValue();
-    }
-    else {
-      throw new ParseException("Unable to process in clause because " + left.getValue() + " is not a set");
-    }
-    Object result = func.apply(argList);
-    tokenStack.push(new Token<>(result, Object.class));
-  }
-
-
-  @Override
-  public void enterFunc_args(TransformationParser.Func_argsContext ctx) {
-    tokenStack.push(new Token<>(new FunctionMarker(), FunctionMarker.class));
-  }
-
-
-  @Override
-  public void exitFunc_args(TransformationParser.Func_argsContext ctx) {
-    LinkedList<Object> args = new LinkedList<>();
-    while(true) {
-      Token<?> token = popStack();
-      if(token.getUnderlyingType().equals(FunctionMarker.class)) {
-        break;
-      }
-      else {
-        args.addFirst(token.getValue());
-      }
-    }
-    tokenStack.push(new Token<>(args, List.class));
-  }
-
-
-  @Override
-  public void exitList_entity(TransformationParser.List_entityContext ctx) {
-    LinkedList<Object> args = new LinkedList<>();
-    while(true) {
-      Token<?> token = popStack();
-      if(token.getUnderlyingType().equals(FunctionMarker.class)) {
-        break;
-      }
-      else {
-        args.addFirst(token.getValue());
-      }
-    }
-    tokenStack.push(new Token<>(args, List.class));
-  }
-
-  @Override
-  public void enterList_entity(TransformationParser.List_entityContext ctx) {
-    tokenStack.push(new Token<>(new FunctionMarker(), FunctionMarker.class));
-  }
-
-  public Token<?> popStack() {
-    if(tokenStack.empty()) {
-      throw new ParseException("Unable to pop an empty stack");
-    }
-    return tokenStack.pop();
-  }
-
-  public Object getResult() throws ParseException {
-    if(tokenStack.empty()) {
-      throw new ParseException("Invalid predicate: Empty stack.");
-    }
-    Token<?> token = popStack();
-    if(tokenStack.empty()) {
-      return token.getValue();
-    }
-    if(tokenStack.empty()) {
-      throw new ParseException("Invalid parse, stack not empty: " + Joiner.on(',').join(tokenStack));
-    }
-    else {
-      throw new ParseException("Invalid parse, found " + token);
-    }
-  }
-}

http://git-wip-us.apache.org/repos/asf/incubator-metron/blob/93054463/metron-platform/metron-common/src/main/java/org/apache/metron/common/transformation/TransformationProcessor.java
----------------------------------------------------------------------
diff --git a/metron-platform/metron-common/src/main/java/org/apache/metron/common/transformation/TransformationProcessor.java b/metron-platform/metron-common/src/main/java/org/apache/metron/common/transformation/TransformationProcessor.java
deleted file mode 100644
index 83082c0..0000000
--- a/metron-platform/metron-common/src/main/java/org/apache/metron/common/transformation/TransformationProcessor.java
+++ /dev/null
@@ -1,70 +0,0 @@
-/**
- * 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.metron.common.transformation;
-
-import org.antlr.v4.runtime.ANTLRInputStream;
-import org.antlr.v4.runtime.CommonTokenStream;
-import org.antlr.v4.runtime.TokenStream;
-import org.apache.metron.common.dsl.ErrorListener;
-import org.apache.metron.common.dsl.ParseException;
-import org.apache.metron.common.dsl.VariableResolver;
-import org.apache.metron.common.transformation.generated.TransformationLexer;
-import org.apache.metron.common.transformation.generated.TransformationParser;
-
-import static org.apache.commons.lang3.StringUtils.isEmpty;
-
-public class TransformationProcessor {
-
-  public Object parse(String rule, VariableResolver resolver) {
-    if (rule == null || isEmpty(rule.trim())) {
-      return null;
-    }
-    ANTLRInputStream input = new ANTLRInputStream(rule);
-    TransformationLexer lexer = new TransformationLexer(input);
-    lexer.removeErrorListeners();
-    lexer.addErrorListener(new ErrorListener());
-    TokenStream tokens = new CommonTokenStream(lexer);
-    TransformationParser parser = new TransformationParser(tokens);
-
-    TransformationCompiler treeBuilder = new TransformationCompiler(resolver);
-    parser.addParseListener(treeBuilder);
-    parser.removeErrorListeners();
-    parser.addErrorListener(new ErrorListener());
-    parser.transformation();
-    return treeBuilder.getResult();
-  }
-
-  public boolean validate(String rule) throws ParseException {
-    return validate(rule, true);
-  }
-  public boolean validate(String rule, boolean throwException) throws ParseException {
-    try {
-      parse(rule, x -> null);
-      return true;
-    }
-    catch(Throwable t) {
-      if(throwException) {
-        throw new ParseException("Unable to parse " + rule + ": " + t.getMessage(), t);
-      }
-      else {
-        return false;
-      }
-    }
-  }
-}

http://git-wip-us.apache.org/repos/asf/incubator-metron/blob/93054463/metron-platform/metron-common/src/main/java/org/apache/metron/common/transformation/generated/PredicateLexer.java
----------------------------------------------------------------------
diff --git a/metron-platform/metron-common/src/main/java/org/apache/metron/common/transformation/generated/PredicateLexer.java b/metron-platform/metron-common/src/main/java/org/apache/metron/common/transformation/generated/PredicateLexer.java
deleted file mode 100644
index 321cbea..0000000
--- a/metron-platform/metron-common/src/main/java/org/apache/metron/common/transformation/generated/PredicateLexer.java
+++ /dev/null
@@ -1,146 +0,0 @@
-// Generated from org/apache/metron/common/transformation/generated/Transformation.g4 by ANTLR 4.5
-package org.apache.metron.common.transformation.generated;
-
-//CHECKSTYLE:OFF
-/**
- * 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.
- */
-
-import org.antlr.v4.runtime.Lexer;
-import org.antlr.v4.runtime.CharStream;
-import org.antlr.v4.runtime.Token;
-import org.antlr.v4.runtime.TokenStream;
-import org.antlr.v4.runtime.*;
-import org.antlr.v4.runtime.atn.*;
-import org.antlr.v4.runtime.dfa.DFA;
-import org.antlr.v4.runtime.misc.*;
-
-@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
-public class PredicateLexer extends Lexer {
-	static { RuntimeMetaData.checkVersion("4.5", RuntimeMetaData.VERSION); }
-
-	protected static final DFA[] _decisionToDFA;
-	protected static final PredictionContextCache _sharedContextCache =
-		new PredictionContextCache();
-	public static final int
-		COMMA=1, LPAREN=2, RPAREN=3, INT_LITERAL=4, DOUBLE_LITERAL=5, IDENTIFIER=6, 
-		STRING_LITERAL=7, COMMENT=8, WS=9;
-	public static String[] modeNames = {
-		"DEFAULT_MODE"
-	};
-
-	public static final String[] ruleNames = {
-		"COMMA", "LPAREN", "RPAREN", "INT_LITERAL", "DOUBLE_LITERAL", "IDENTIFIER", 
-		"SCHAR", "STRING_LITERAL", "COMMENT", "WS"
-	};
-
-	private static final String[] _LITERAL_NAMES = {
-		null, "','", "'('", "')'"
-	};
-	private static final String[] _SYMBOLIC_NAMES = {
-		null, "COMMA", "LPAREN", "RPAREN", "INT_LITERAL", "DOUBLE_LITERAL", "IDENTIFIER", 
-		"STRING_LITERAL", "COMMENT", "WS"
-	};
-	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
-
-	/**
-	 * @deprecated Use {@link #VOCABULARY} instead.
-	 */
-	@Deprecated
-	public static final String[] tokenNames;
-	static {
-		tokenNames = new String[_SYMBOLIC_NAMES.length];
-		for (int i = 0; i < tokenNames.length; i++) {
-			tokenNames[i] = VOCABULARY.getLiteralName(i);
-			if (tokenNames[i] == null) {
-				tokenNames[i] = VOCABULARY.getSymbolicName(i);
-			}
-
-			if (tokenNames[i] == null) {
-				tokenNames[i] = "<INVALID>";
-			}
-		}
-	}
-
-	@Override
-	@Deprecated
-	public String[] getTokenNames() {
-		return tokenNames;
-	}
-
-	@Override
-
-	public Vocabulary getVocabulary() {
-		return VOCABULARY;
-	}
-
-
-	public PredicateLexer(CharStream input) {
-		super(input);
-		_interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
-	}
-
-	@Override
-	public String getGrammarFileName() { return "Transformation.g4"; }
-
-	@Override
-	public String[] getRuleNames() { return ruleNames; }
-
-	@Override
-	public String getSerializedATN() { return _serializedATN; }
-
-	@Override
-	public String[] getModeNames() { return modeNames; }
-
-	@Override
-	public ATN getATN() { return _ATN; }
-
-	public static final String _serializedATN =
-		"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\2\13\\\b\1\4\2\t\2"+
-		"\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+
-		"\t\13\3\2\3\2\3\3\3\3\3\4\3\4\3\5\6\5\37\n\5\r\5\16\5 \3\6\6\6$\n\6\r"+
-		"\6\16\6%\3\6\3\6\6\6*\n\6\r\6\16\6+\3\7\3\7\7\7\60\n\7\f\7\16\7\63\13"+
-		"\7\3\b\3\b\3\t\3\t\7\t9\n\t\f\t\16\t<\13\t\3\t\3\t\3\t\7\tA\n\t\f\t\16"+
-		"\tD\13\t\3\t\5\tG\n\t\3\n\3\n\3\n\3\n\6\nM\n\n\r\n\16\nN\3\n\5\nR\n\n"+
-		"\3\n\3\n\3\13\6\13W\n\13\r\13\16\13X\3\13\3\13\3N\2\f\3\3\5\4\7\5\t\6"+
-		"\13\7\r\b\17\2\21\t\23\n\25\13\3\2\7\5\2C\\aac|\b\2\60\60\62;C\\^^aac"+
-		"|\7\2\f\f\17\17$$))^^\3\3\f\f\5\2\13\f\16\17\"\"c\2\3\3\2\2\2\2\5\3\2"+
-		"\2\2\2\7\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\21\3\2\2\2\2\23"+
-		"\3\2\2\2\2\25\3\2\2\2\3\27\3\2\2\2\5\31\3\2\2\2\7\33\3\2\2\2\t\36\3\2"+
-		"\2\2\13#\3\2\2\2\r-\3\2\2\2\17\64\3\2\2\2\21F\3\2\2\2\23H\3\2\2\2\25V"+
-		"\3\2\2\2\27\30\7.\2\2\30\4\3\2\2\2\31\32\7*\2\2\32\6\3\2\2\2\33\34\7+"+
-		"\2\2\34\b\3\2\2\2\35\37\4\62;\2\36\35\3\2\2\2\37 \3\2\2\2 \36\3\2\2\2"+
-		" !\3\2\2\2!\n\3\2\2\2\"$\4\62;\2#\"\3\2\2\2$%\3\2\2\2%#\3\2\2\2%&\3\2"+
-		"\2\2&\'\3\2\2\2\')\7\60\2\2(*\4\62;\2)(\3\2\2\2*+\3\2\2\2+)\3\2\2\2+,"+
-		"\3\2\2\2,\f\3\2\2\2-\61\t\2\2\2.\60\t\3\2\2/.\3\2\2\2\60\63\3\2\2\2\61"+
-		"/\3\2\2\2\61\62\3\2\2\2\62\16\3\2\2\2\63\61\3\2\2\2\64\65\n\4\2\2\65\20"+
-		"\3\2\2\2\66:\7$\2\2\679\5\17\b\28\67\3\2\2\29<\3\2\2\2:8\3\2\2\2:;\3\2"+
-		"\2\2;=\3\2\2\2<:\3\2\2\2=G\7$\2\2>B\7)\2\2?A\5\17\b\2@?\3\2\2\2AD\3\2"+
-		"\2\2B@\3\2\2\2BC\3\2\2\2CE\3\2\2\2DB\3\2\2\2EG\7)\2\2F\66\3\2\2\2F>\3"+
-		"\2\2\2G\22\3\2\2\2HI\7\61\2\2IJ\7\61\2\2JL\3\2\2\2KM\13\2\2\2LK\3\2\2"+
-		"\2MN\3\2\2\2NO\3\2\2\2NL\3\2\2\2OQ\3\2\2\2PR\t\5\2\2QP\3\2\2\2RS\3\2\2"+
-		"\2ST\b\n\2\2T\24\3\2\2\2UW\t\6\2\2VU\3\2\2\2WX\3\2\2\2XV\3\2\2\2XY\3\2"+
-		"\2\2YZ\3\2\2\2Z[\b\13\2\2[\26\3\2\2\2\r\2 %+\61:BFNQX\3\b\2\2";
-	public static final ATN _ATN =
-		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
-	static {
-		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
-		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
-			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
-		}
-	}
-}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-metron/blob/93054463/metron-platform/metron-common/src/main/java/org/apache/metron/common/transformation/generated/TransformationBaseListener.java
----------------------------------------------------------------------
diff --git a/metron-platform/metron-common/src/main/java/org/apache/metron/common/transformation/generated/TransformationBaseListener.java b/metron-platform/metron-common/src/main/java/org/apache/metron/common/transformation/generated/TransformationBaseListener.java
deleted file mode 100644
index d5387b6..0000000
--- a/metron-platform/metron-common/src/main/java/org/apache/metron/common/transformation/generated/TransformationBaseListener.java
+++ /dev/null
@@ -1,216 +0,0 @@
-// Generated from org/apache/metron/common/transformation/generated/Transformation.g4 by ANTLR 4.5
-package org.apache.metron.common.transformation.generated;
-
-//CHECKSTYLE:OFF
-/**
- * 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.
- */
-
-
-import org.antlr.v4.runtime.ParserRuleContext;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.tree.ErrorNode;
-import org.antlr.v4.runtime.tree.TerminalNode;
-
-/**
- * This class provides an empty implementation of {@link TransformationListener},
- * which can be extended to create a listener which only needs to handle a subset
- * of the available methods.
- */
-public class TransformationBaseListener implements TransformationListener {
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterTransformation(TransformationParser.TransformationContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitTransformation(TransformationParser.TransformationContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterTransformationExpr(TransformationParser.TransformationExprContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitTransformationExpr(TransformationParser.TransformationExprContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterTransformationEntity(TransformationParser.TransformationEntityContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitTransformationEntity(TransformationParser.TransformationEntityContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterTransformation_entity(TransformationParser.Transformation_entityContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitTransformation_entity(TransformationParser.Transformation_entityContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterFunc_args(TransformationParser.Func_argsContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitFunc_args(TransformationParser.Func_argsContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterOp_list(TransformationParser.Op_listContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitOp_list(TransformationParser.Op_listContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterList_entity(TransformationParser.List_entityContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitList_entity(TransformationParser.List_entityContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterStringLiteral(TransformationParser.StringLiteralContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitStringLiteral(TransformationParser.StringLiteralContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterIntegerLiteral(TransformationParser.IntegerLiteralContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitIntegerLiteral(TransformationParser.IntegerLiteralContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterDoubleLiteral(TransformationParser.DoubleLiteralContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitDoubleLiteral(TransformationParser.DoubleLiteralContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterVariable(TransformationParser.VariableContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitVariable(TransformationParser.VariableContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterTransformationFunc(TransformationParser.TransformationFuncContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitTransformationFunc(TransformationParser.TransformationFuncContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterList(TransformationParser.ListContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitList(TransformationParser.ListContext ctx) { }
-
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterEveryRule(ParserRuleContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitEveryRule(ParserRuleContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void visitTerminal(TerminalNode node) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void visitErrorNode(ErrorNode node) { }
-}
\ No newline at end of file



Mime
View raw message