Skip to content

Instantly share code, notes, and snippets.

@huhlig

huhlig/HCleanBaseListener.java

Created February 22, 2013 18:51
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save huhlig/5015661 to your computer and use it in GitHub Desktop.
Save huhlig/5015661 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
HCleanBaseListener.java
// Generated from com\aol\hadoop\util\hce\HClean.g4 by ANTLR 4.0
package com.aol.hadoop.util.hce;
import org.antlr.v4.runtime.ParserRuleContext;
import org.antlr.v4.runtime.Token;
import org.antlr.v4.runtime.tree.TerminalNode;
import org.antlr.v4.runtime.tree.ErrorNode;
public class HCleanBaseListener implements HCleanListener {
@Override public void enterTimeValue(HCleanParser.TimeValueContext ctx) { }
@Override public void exitTimeValue(HCleanParser.TimeValueContext ctx) { }
@Override public void enterIntLT(HCleanParser.IntLTContext ctx) { }
@Override public void exitIntLT(HCleanParser.IntLTContext ctx) { }
@Override public void enterStringValue(HCleanParser.StringValueContext ctx) { }
@Override public void exitStringValue(HCleanParser.StringValueContext ctx) { }
@Override public void enterFilenameValue(HCleanParser.FilenameValueContext ctx) { }
@Override public void exitFilenameValue(HCleanParser.FilenameValueContext ctx) { }
@Override public void enterNowValue(HCleanParser.NowValueContext ctx) { }
@Override public void exitNowValue(HCleanParser.NowValueContext ctx) { }
@Override public void enterApathValue(HCleanParser.ApathValueContext ctx) { }
@Override public void exitApathValue(HCleanParser.ApathValueContext ctx) { }
@Override public void enterIntBEQ(HCleanParser.IntBEQContext ctx) { }
@Override public void exitIntBEQ(HCleanParser.IntBEQContext ctx) { }
@Override public void enterIntBGTE(HCleanParser.IntBGTEContext ctx) { }
@Override public void exitIntBGTE(HCleanParser.IntBGTEContext ctx) { }
@Override public void enterMtimeValue(HCleanParser.MtimeValueContext ctx) { }
@Override public void exitMtimeValue(HCleanParser.MtimeValueContext ctx) { }
@Override public void enterStrEQ(HCleanParser.StrEQContext ctx) { }
@Override public void exitStrEQ(HCleanParser.StrEQContext ctx) { }
@Override public void enterIntNE(HCleanParser.IntNEContext ctx) { }
@Override public void exitIntNE(HCleanParser.IntNEContext ctx) { }
@Override public void enterIntBLTE(HCleanParser.IntBLTEContext ctx) { }
@Override public void exitIntBLTE(HCleanParser.IntBLTEContext ctx) { }
@Override public void enterRpathValue(HCleanParser.RpathValueContext ctx) { }
@Override public void exitRpathValue(HCleanParser.RpathValueContext ctx) { }
@Override public void enterIntegerValue(HCleanParser.IntegerValueContext ctx) { }
@Override public void exitIntegerValue(HCleanParser.IntegerValueContext ctx) { }
@Override public void enterIntDiv(HCleanParser.IntDivContext ctx) { }
@Override public void exitIntDiv(HCleanParser.IntDivContext ctx) { }
@Override public void enterRuleNode(HCleanParser.RuleNodeContext ctx) { }
@Override public void exitRuleNode(HCleanParser.RuleNodeContext ctx) { }
@Override public void enterIntMult(HCleanParser.IntMultContext ctx) { }
@Override public void exitIntMult(HCleanParser.IntMultContext ctx) { }
@Override public void enterStrCN(HCleanParser.StrCNContext ctx) { }
@Override public void exitStrCN(HCleanParser.StrCNContext ctx) { }
@Override public void enterIntAdd(HCleanParser.IntAddContext ctx) { }
@Override public void exitIntAdd(HCleanParser.IntAddContext ctx) { }
@Override public void enterTrueValue(HCleanParser.TrueValueContext ctx) { }
@Override public void exitTrueValue(HCleanParser.TrueValueContext ctx) { }
@Override public void enterIntSub(HCleanParser.IntSubContext ctx) { }
@Override public void exitIntSub(HCleanParser.IntSubContext ctx) { }
@Override public void enterFalseValue(HCleanParser.FalseValueContext ctx) { }
@Override public void exitFalseValue(HCleanParser.FalseValueContext ctx) { }
@Override public void enterXorNode(HCleanParser.XorNodeContext ctx) { }
@Override public void exitXorNode(HCleanParser.XorNodeContext ctx) { }
@Override public void enterIntBLT(HCleanParser.IntBLTContext ctx) { }
@Override public void exitIntBLT(HCleanParser.IntBLTContext ctx) { }
@Override public void enterIntGT(HCleanParser.IntGTContext ctx) { }
@Override public void exitIntGT(HCleanParser.IntGTContext ctx) { }
@Override public void enterAndNode(HCleanParser.AndNodeContext ctx) { }
@Override public void exitAndNode(HCleanParser.AndNodeContext ctx) { }
@Override public void enterIntBNE(HCleanParser.IntBNEContext ctx) { }
@Override public void exitIntBNE(HCleanParser.IntBNEContext ctx) { }
@Override public void enterIntGTE(HCleanParser.IntGTEContext ctx) { }
@Override public void exitIntGTE(HCleanParser.IntGTEContext ctx) { }
@Override public void enterAtimeValue(HCleanParser.AtimeValueContext ctx) { }
@Override public void exitAtimeValue(HCleanParser.AtimeValueContext ctx) { }
@Override public void enterOrNode(HCleanParser.OrNodeContext ctx) { }
@Override public void exitOrNode(HCleanParser.OrNodeContext ctx) { }
@Override public void enterPathValue(HCleanParser.PathValueContext ctx) { }
@Override public void exitPathValue(HCleanParser.PathValueContext ctx) { }
@Override public void enterStrNE(HCleanParser.StrNEContext ctx) { }
@Override public void exitStrNE(HCleanParser.StrNEContext ctx) { }
@Override public void enterIntBGT(HCleanParser.IntBGTContext ctx) { }
@Override public void exitIntBGT(HCleanParser.IntBGTContext ctx) { }
@Override public void enterIntLTE(HCleanParser.IntLTEContext ctx) { }
@Override public void exitIntLTE(HCleanParser.IntLTEContext ctx) { }
@Override public void enterDateValue(HCleanParser.DateValueContext ctx) { }
@Override public void exitDateValue(HCleanParser.DateValueContext ctx) { }
@Override public void enterNotNode(HCleanParser.NotNodeContext ctx) { }
@Override public void exitNotNode(HCleanParser.NotNodeContext ctx) { }
@Override public void enterIntEQ(HCleanParser.IntEQContext ctx) { }
@Override public void exitIntEQ(HCleanParser.IntEQContext ctx) { }
@Override public void enterEveryRule(ParserRuleContext ctx) { }
@Override public void exitEveryRule(ParserRuleContext ctx) { }
@Override public void visitTerminal(TerminalNode node) { }
@Override public void visitErrorNode(ErrorNode node) { }
}
Raw
HCleanBaseVisitor.java
// Generated from com\aol\hadoop\util\hce\HClean.g4 by ANTLR 4.0
package com.aol.hadoop.util.hce;
import org.antlr.v4.runtime.tree.*;
import org.antlr.v4.runtime.Token;
import org.antlr.v4.runtime.ParserRuleContext;
public class HCleanBaseVisitor<T> extends AbstractParseTreeVisitor<T> implements HCleanVisitor<T> {
@Override public T visitTimeValue(HCleanParser.TimeValueContext ctx) { return visitChildren(ctx); }
@Override public T visitIntLT(HCleanParser.IntLTContext ctx) { return visitChildren(ctx); }
@Override public T visitStringValue(HCleanParser.StringValueContext ctx) { return visitChildren(ctx); }
@Override public T visitFilenameValue(HCleanParser.FilenameValueContext ctx) { return visitChildren(ctx); }
@Override public T visitNowValue(HCleanParser.NowValueContext ctx) { return visitChildren(ctx); }
@Override public T visitApathValue(HCleanParser.ApathValueContext ctx) { return visitChildren(ctx); }
@Override public T visitIntBEQ(HCleanParser.IntBEQContext ctx) { return visitChildren(ctx); }
@Override public T visitIntBGTE(HCleanParser.IntBGTEContext ctx) { return visitChildren(ctx); }
@Override public T visitMtimeValue(HCleanParser.MtimeValueContext ctx) { return visitChildren(ctx); }
@Override public T visitStrEQ(HCleanParser.StrEQContext ctx) { return visitChildren(ctx); }
@Override public T visitIntNE(HCleanParser.IntNEContext ctx) { return visitChildren(ctx); }
@Override public T visitIntBLTE(HCleanParser.IntBLTEContext ctx) { return visitChildren(ctx); }
@Override public T visitRpathValue(HCleanParser.RpathValueContext ctx) { return visitChildren(ctx); }
@Override public T visitIntegerValue(HCleanParser.IntegerValueContext ctx) { return visitChildren(ctx); }
@Override public T visitIntDiv(HCleanParser.IntDivContext ctx) { return visitChildren(ctx); }
@Override public T visitRuleNode(HCleanParser.RuleNodeContext ctx) { return visitChildren(ctx); }
@Override public T visitIntMult(HCleanParser.IntMultContext ctx) { return visitChildren(ctx); }
@Override public T visitStrCN(HCleanParser.StrCNContext ctx) { return visitChildren(ctx); }
@Override public T visitIntAdd(HCleanParser.IntAddContext ctx) { return visitChildren(ctx); }
@Override public T visitTrueValue(HCleanParser.TrueValueContext ctx) { return visitChildren(ctx); }
@Override public T visitIntSub(HCleanParser.IntSubContext ctx) { return visitChildren(ctx); }
@Override public T visitFalseValue(HCleanParser.FalseValueContext ctx) { return visitChildren(ctx); }
@Override public T visitXorNode(HCleanParser.XorNodeContext ctx) { return visitChildren(ctx); }
@Override public T visitIntBLT(HCleanParser.IntBLTContext ctx) { return visitChildren(ctx); }
@Override public T visitIntGT(HCleanParser.IntGTContext ctx) { return visitChildren(ctx); }
@Override public T visitAndNode(HCleanParser.AndNodeContext ctx) { return visitChildren(ctx); }
@Override public T visitIntBNE(HCleanParser.IntBNEContext ctx) { return visitChildren(ctx); }
@Override public T visitIntGTE(HCleanParser.IntGTEContext ctx) { return visitChildren(ctx); }
@Override public T visitAtimeValue(HCleanParser.AtimeValueContext ctx) { return visitChildren(ctx); }
@Override public T visitOrNode(HCleanParser.OrNodeContext ctx) { return visitChildren(ctx); }
@Override public T visitPathValue(HCleanParser.PathValueContext ctx) { return visitChildren(ctx); }
@Override public T visitStrNE(HCleanParser.StrNEContext ctx) { return visitChildren(ctx); }
@Override public T visitIntBGT(HCleanParser.IntBGTContext ctx) { return visitChildren(ctx); }
@Override public T visitIntLTE(HCleanParser.IntLTEContext ctx) { return visitChildren(ctx); }
@Override public T visitDateValue(HCleanParser.DateValueContext ctx) { return visitChildren(ctx); }
@Override public T visitNotNode(HCleanParser.NotNodeContext ctx) { return visitChildren(ctx); }
@Override public T visitIntEQ(HCleanParser.IntEQContext ctx) { return visitChildren(ctx); }
}
Raw
HCleanLexer.java
// Generated from com\aol\hadoop\util\hce\HClean.g4 by ANTLR 4.0
package com.aol.hadoop.util.hce;
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 HCleanLexer extends Lexer {
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
TRUE=1, FALSE=2, APATH=3, RPATH=4, ATIME=5, MTIME=6, NOW=7, FILENAME=8,
AND=9, OR=10, XOR=11, NOT=12, LPAREN=13, RPAREN=14, GT=15, GTE=16, EQ=17,
NE=18, LTE=19, LT=20, CN=21, PLUS=22, MINUS=23, MULT=24, DIV=25, LCBRACE=26,
RCBRACE=27, WS=28, INT=29, STRING=30, DATE=31, PATH=32, TIME=33, DATETIMEVAL=34,
PATHVAL=35, ID=36;
public static String[] modeNames = {
"DEFAULT_MODE"
};
public static final String[] tokenNames = {
"<INVALID>",
"'true'", "'false'", "'apath'", "'rpath'", "'atime'", "'mtime'", "'now'",
"'filename'", "'AND'", "'OR'", "'XOR'", "'!'", "'('", "')'", "'>'", "'>='",
"'=='", "'!='", "'<='", "'<'", "'<>'", "'+'", "'-'", "'*'", "'/'", "'{'",
"'}'", "WS", "INT", "STRING", "'date'", "'path'", "'time'", "DATETIMEVAL",
"PATHVAL", "ID"
};
public static final String[] ruleNames = {
"TRUE", "FALSE", "APATH", "RPATH", "ATIME", "MTIME", "NOW", "FILENAME",
"AND", "OR", "XOR", "NOT", "LPAREN", "RPAREN", "GT", "GTE", "EQ", "NE",
"LTE", "LT", "CN", "PLUS", "MINUS", "MULT", "DIV", "LCBRACE", "RCBRACE",
"WS", "INT", "STRING", "DATE", "PATH", "TIME", "DATETIMEVAL", "PATHVAL",
"ID", "DIGIT", "ESC_SEQ", "OCTAL_ESC", "UNICODE_ESC", "HEX_DIGIT"
};
public HCleanLexer(CharStream input) {
super(input);
_interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
@Override
public String getGrammarFileName() { return "HClean.g4"; }
@Override
public String[] getTokenNames() { return tokenNames; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String[] getModeNames() { return modeNames; }
@Override
public ATN getATN() { return _ATN; }
@Override
public void action(RuleContext _localctx, int ruleIndex, int actionIndex) {
switch (ruleIndex) {
case 27: WS_action((RuleContext)_localctx, actionIndex); break;
}
}
private void WS_action(RuleContext _localctx, int actionIndex) {
switch (actionIndex) {
case 0: skip(); break;
}
}
public static final String _serializedATN =
"\2\4&\u011f\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\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20"+
"\t\20\4\21\t\21\4\22\t\22\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27"+
"\t\27\4\30\t\30\4\31\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36"+
"\t\36\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4"+
"(\t(\4)\t)\4*\t*\3\2\3\2\3\2\3\2\3\2\3\3\3\3\3\3\3\3\3\3\3\3\3\4\3\4\3"+
"\4\3\4\3\4\3\4\3\5\3\5\3\5\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6\3\6\3\7\3\7"+
"\3\7\3\7\3\7\3\7\3\b\3\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3"+
"\n\3\n\3\n\3\n\3\13\3\13\3\13\3\f\3\f\3\f\3\f\3\r\3\r\3\16\3\16\3\17\3"+
"\17\3\20\3\20\3\21\3\21\3\21\3\22\3\22\3\22\3\23\3\23\3\23\3\24\3\24\3"+
"\24\3\25\3\25\3\26\3\26\3\26\3\27\3\27\3\30\3\30\3\31\3\31\3\32\3\32\3"+
"\33\3\33\3\34\3\34\3\35\6\35\u00b7\n\35\r\35\16\35\u00b8\3\35\3\35\3\36"+
"\5\36\u00be\n\36\3\36\6\36\u00c1\n\36\r\36\16\36\u00c2\3\37\3\37\3\37"+
"\7\37\u00c8\n\37\f\37\16\37\u00cb\13\37\3\37\3\37\3\37\3\37\7\37\u00d1"+
"\n\37\f\37\16\37\u00d4\13\37\3\37\5\37\u00d7\n\37\3 \3 \3 \3 \3 \3!\3"+
"!\3!\3!\3!\3\"\3\"\3\"\3\"\3\"\3#\3#\6#\u00ea\n#\r#\16#\u00eb\3#\6#\u00ef"+
"\n#\r#\16#\u00f0\3#\5#\u00f4\n#\5#\u00f6\n#\3$\6$\u00f9\n$\r$\16$\u00fa"+
"\3%\3%\7%\u00ff\n%\f%\16%\u0102\13%\3&\3&\3\'\3\'\3\'\3\'\5\'\u010a\n"+
"\'\3(\3(\3(\3(\3(\3(\3(\3(\3(\5(\u0115\n(\3)\3)\3)\3)\3)\3)\3)\3*\3*\2"+
"+\3\3\1\5\4\1\7\5\1\t\6\1\13\7\1\r\b\1\17\t\1\21\n\1\23\13\1\25\f\1\27"+
"\r\1\31\16\1\33\17\1\35\20\1\37\21\1!\22\1#\23\1%\24\1\'\25\1)\26\1+\27"+
"\1-\30\1/\31\1\61\32\1\63\33\1\65\34\1\67\35\19\36\2;\37\1= \1?!\1A\""+
"\1C#\1E$\1G%\1I&\1K\2\1M\2\1O\2\1Q\2\1S\2\1\3\2\r\4\13\f\"\"\4--//\4$"+
"$^^\4))^^\5/\60<<VV\bffjjoouuyy~~\7\'\'/;C\\aac|\5C\\aac|\6\62;C\\aac"+
"|\n$$))^^ddhhppttvv\5\62;CHch\u012c\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\17\3\2\2\2\2\21\3\2\2\2\2\23"+
"\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2\2\2\35\3\2"+
"\2\2\2\37\3\2\2\2\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2\2\'\3\2\2\2\2)\3\2"+
"\2\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2\2\61\3\2\2\2\2\63\3\2\2\2\2\65\3"+
"\2\2\2\2\67\3\2\2\2\29\3\2\2\2\2;\3\2\2\2\2=\3\2\2\2\2?\3\2\2\2\2A\3\2"+
"\2\2\2C\3\2\2\2\2E\3\2\2\2\2G\3\2\2\2\2I\3\2\2\2\3U\3\2\2\2\5Z\3\2\2\2"+
"\7`\3\2\2\2\tf\3\2\2\2\13l\3\2\2\2\rr\3\2\2\2\17x\3\2\2\2\21|\3\2\2\2"+
"\23\u0085\3\2\2\2\25\u0089\3\2\2\2\27\u008c\3\2\2\2\31\u0090\3\2\2\2\33"+
"\u0092\3\2\2\2\35\u0094\3\2\2\2\37\u0096\3\2\2\2!\u0098\3\2\2\2#\u009b"+
"\3\2\2\2%\u009e\3\2\2\2\'\u00a1\3\2\2\2)\u00a4\3\2\2\2+\u00a6\3\2\2\2"+
"-\u00a9\3\2\2\2/\u00ab\3\2\2\2\61\u00ad\3\2\2\2\63\u00af\3\2\2\2\65\u00b1"+
"\3\2\2\2\67\u00b3\3\2\2\29\u00b6\3\2\2\2;\u00bd\3\2\2\2=\u00d6\3\2\2\2"+
"?\u00d8\3\2\2\2A\u00dd\3\2\2\2C\u00e2\3\2\2\2E\u00f5\3\2\2\2G\u00f8\3"+
"\2\2\2I\u00fc\3\2\2\2K\u0103\3\2\2\2M\u0109\3\2\2\2O\u0114\3\2\2\2Q\u0116"+
"\3\2\2\2S\u011d\3\2\2\2UV\7v\2\2VW\7t\2\2WX\7w\2\2XY\7g\2\2Y\4\3\2\2\2"+
"Z[\7h\2\2[\\\7c\2\2\\]\7n\2\2]^\7u\2\2^_\7g\2\2_\6\3\2\2\2`a\7c\2\2ab"+
"\7r\2\2bc\7c\2\2cd\7v\2\2de\7j\2\2e\b\3\2\2\2fg\7t\2\2gh\7r\2\2hi\7c\2"+
"\2ij\7v\2\2jk\7j\2\2k\n\3\2\2\2lm\7c\2\2mn\7v\2\2no\7k\2\2op\7o\2\2pq"+
"\7g\2\2q\f\3\2\2\2rs\7o\2\2st\7v\2\2tu\7k\2\2uv\7o\2\2vw\7g\2\2w\16\3"+
"\2\2\2xy\7p\2\2yz\7q\2\2z{\7y\2\2{\20\3\2\2\2|}\7h\2\2}~\7k\2\2~\177\7"+
"n\2\2\177\u0080\7g\2\2\u0080\u0081\7p\2\2\u0081\u0082\7c\2\2\u0082\u0083"+
"\7o\2\2\u0083\u0084\7g\2\2\u0084\22\3\2\2\2\u0085\u0086\7C\2\2\u0086\u0087"+
"\7P\2\2\u0087\u0088\7F\2\2\u0088\24\3\2\2\2\u0089\u008a\7Q\2\2\u008a\u008b"+
"\7T\2\2\u008b\26\3\2\2\2\u008c\u008d\7Z\2\2\u008d\u008e\7Q\2\2\u008e\u008f"+
"\7T\2\2\u008f\30\3\2\2\2\u0090\u0091\7#\2\2\u0091\32\3\2\2\2\u0092\u0093"+
"\7*\2\2\u0093\34\3\2\2\2\u0094\u0095\7+\2\2\u0095\36\3\2\2\2\u0096\u0097"+
"\7@\2\2\u0097 \3\2\2\2\u0098\u0099\7@\2\2\u0099\u009a\7?\2\2\u009a\"\3"+
"\2\2\2\u009b\u009c\7?\2\2\u009c\u009d\7?\2\2\u009d$\3\2\2\2\u009e\u009f"+
"\7#\2\2\u009f\u00a0\7?\2\2\u00a0&\3\2\2\2\u00a1\u00a2\7>\2\2\u00a2\u00a3"+
"\7?\2\2\u00a3(\3\2\2\2\u00a4\u00a5\7>\2\2\u00a5*\3\2\2\2\u00a6\u00a7\7"+
">\2\2\u00a7\u00a8\7@\2\2\u00a8,\3\2\2\2\u00a9\u00aa\7-\2\2\u00aa.\3\2"+
"\2\2\u00ab\u00ac\7/\2\2\u00ac\60\3\2\2\2\u00ad\u00ae\7,\2\2\u00ae\62\3"+
"\2\2\2\u00af\u00b0\7\61\2\2\u00b0\64\3\2\2\2\u00b1\u00b2\7}\2\2\u00b2"+
"\66\3\2\2\2\u00b3\u00b4\7\177\2\2\u00b48\3\2\2\2\u00b5\u00b7\t\2\2\2\u00b6"+
"\u00b5\3\2\2\2\u00b7\u00b8\3\2\2\2\u00b8\u00b6\3\2\2\2\u00b8\u00b9\3\2"+
"\2\2\u00b9\u00ba\3\2\2\2\u00ba\u00bb\b\35\2\2\u00bb:\3\2\2\2\u00bc\u00be"+
"\t\3\2\2\u00bd\u00bc\3\2\2\2\u00bd\u00be\3\2\2\2\u00be\u00c0\3\2\2\2\u00bf"+
"\u00c1\5K&\2\u00c0\u00bf\3\2\2\2\u00c1\u00c2\3\2\2\2\u00c2\u00c0\3\2\2"+
"\2\u00c2\u00c3\3\2\2\2\u00c3<\3\2\2\2\u00c4\u00c9\7$\2\2\u00c5\u00c8\5"+
"M\'\2\u00c6\u00c8\n\4\2\2\u00c7\u00c5\3\2\2\2\u00c7\u00c6\3\2\2\2\u00c8"+
"\u00cb\3\2\2\2\u00c9\u00c7\3\2\2\2\u00c9\u00ca\3\2\2\2\u00ca\u00cc\3\2"+
"\2\2\u00cb\u00c9\3\2\2\2\u00cc\u00d7\7$\2\2\u00cd\u00d2\7)\2\2\u00ce\u00d1"+
"\5M\'\2\u00cf\u00d1\n\5\2\2\u00d0\u00ce\3\2\2\2\u00d0\u00cf\3\2\2\2\u00d1"+
"\u00d4\3\2\2\2\u00d2\u00d0\3\2\2\2\u00d2\u00d3\3\2\2\2\u00d3\u00d5\3\2"+
"\2\2\u00d4\u00d2\3\2\2\2\u00d5\u00d7\7)\2\2\u00d6\u00c4\3\2\2\2\u00d6"+
"\u00cd\3\2\2\2\u00d7>\3\2\2\2\u00d8\u00d9\7f\2\2\u00d9\u00da\7c\2\2\u00da"+
"\u00db\7v\2\2\u00db\u00dc\7g\2\2\u00dc@\3\2\2\2\u00dd\u00de\7r\2\2\u00de"+
"\u00df\7c\2\2\u00df\u00e0\7v\2\2\u00e0\u00e1\7j\2\2\u00e1B\3\2\2\2\u00e2"+
"\u00e3\7v\2\2\u00e3\u00e4\7k\2\2\u00e4\u00e5\7o\2\2\u00e5\u00e6\7g\2\2"+
"\u00e6D\3\2\2\2\u00e7\u00ea\5K&\2\u00e8\u00ea\t\6\2\2\u00e9\u00e7\3\2"+
"\2\2\u00e9\u00e8\3\2\2\2\u00ea\u00eb\3\2\2\2\u00eb\u00e9\3\2\2\2\u00eb"+
"\u00ec\3\2\2\2\u00ec\u00f6\3\2\2\2\u00ed\u00ef\5K&\2\u00ee\u00ed\3\2\2"+
"\2\u00ef\u00f0\3\2\2\2\u00f0\u00ee\3\2\2\2\u00f0\u00f1\3\2\2\2\u00f1\u00f3"+
"\3\2\2\2\u00f2\u00f4\t\7\2\2\u00f3\u00f2\3\2\2\2\u00f3\u00f4\3\2\2\2\u00f4"+
"\u00f6\3\2\2\2\u00f5\u00e9\3\2\2\2\u00f5\u00ee\3\2\2\2\u00f6F\3\2\2\2"+
"\u00f7\u00f9\t\b\2\2\u00f8\u00f7\3\2\2\2\u00f9\u00fa\3\2\2\2\u00fa\u00f8"+
"\3\2\2\2\u00fa\u00fb\3\2\2\2\u00fbH\3\2\2\2\u00fc\u0100\t\t\2\2\u00fd"+
"\u00ff\t\n\2\2\u00fe\u00fd\3\2\2\2\u00ff\u0102\3\2\2\2\u0100\u00fe\3\2"+
"\2\2\u0100\u0101\3\2\2\2\u0101J\3\2\2\2\u0102\u0100\3\2\2\2\u0103\u0104"+
"\4\62;\2\u0104L\3\2\2\2\u0105\u0106\7^\2\2\u0106\u010a\t\13\2\2\u0107"+
"\u010a\5Q)\2\u0108\u010a\5O(\2\u0109\u0105\3\2\2\2\u0109\u0107\3\2\2\2"+
"\u0109\u0108\3\2\2\2\u010aN\3\2\2\2\u010b\u010c\7^\2\2\u010c\u010d\4\62"+
"\65\2\u010d\u010e\4\629\2\u010e\u0115\4\629\2\u010f\u0110\7^\2\2\u0110"+
"\u0111\4\629\2\u0111\u0115\4\629\2\u0112\u0113\7^\2\2\u0113\u0115\4\62"+
"9\2\u0114\u010b\3\2\2\2\u0114\u010f\3\2\2\2\u0114\u0112\3\2\2\2\u0115"+
"P\3\2\2\2\u0116\u0117\7^\2\2\u0117\u0118\7w\2\2\u0118\u0119\5S*\2\u0119"+
"\u011a\5S*\2\u011a\u011b\5S*\2\u011b\u011c\5S*\2\u011cR\3\2\2\2\u011d"+
"\u011e\t\f\2\2\u011eT\3\2\2\2\24\2\u00b8\u00bd\u00c2\u00c7\u00c9\u00d0"+
"\u00d2\u00d6\u00e9\u00eb\u00f0\u00f3\u00f5\u00fa\u0100\u0109\u0114";
public static final ATN _ATN =
ATNSimulator.deserialize(_serializedATN.toCharArray());
static {
_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
}
}
Raw
HCleanListener.java
// Generated from com\aol\hadoop\util\hce\HClean.g4 by ANTLR 4.0
package com.aol.hadoop.util.hce;
import org.antlr.v4.runtime.tree.*;
import org.antlr.v4.runtime.Token;
public interface HCleanListener extends ParseTreeListener {
void enterTimeValue(HCleanParser.TimeValueContext ctx);
void exitTimeValue(HCleanParser.TimeValueContext ctx);
void enterIntLT(HCleanParser.IntLTContext ctx);
void exitIntLT(HCleanParser.IntLTContext ctx);
void enterStringValue(HCleanParser.StringValueContext ctx);
void exitStringValue(HCleanParser.StringValueContext ctx);
void enterFilenameValue(HCleanParser.FilenameValueContext ctx);
void exitFilenameValue(HCleanParser.FilenameValueContext ctx);
void enterNowValue(HCleanParser.NowValueContext ctx);
void exitNowValue(HCleanParser.NowValueContext ctx);
void enterApathValue(HCleanParser.ApathValueContext ctx);
void exitApathValue(HCleanParser.ApathValueContext ctx);
void enterIntBEQ(HCleanParser.IntBEQContext ctx);
void exitIntBEQ(HCleanParser.IntBEQContext ctx);
void enterIntBGTE(HCleanParser.IntBGTEContext ctx);
void exitIntBGTE(HCleanParser.IntBGTEContext ctx);
void enterMtimeValue(HCleanParser.MtimeValueContext ctx);
void exitMtimeValue(HCleanParser.MtimeValueContext ctx);
void enterStrEQ(HCleanParser.StrEQContext ctx);
void exitStrEQ(HCleanParser.StrEQContext ctx);
void enterIntNE(HCleanParser.IntNEContext ctx);
void exitIntNE(HCleanParser.IntNEContext ctx);
void enterIntBLTE(HCleanParser.IntBLTEContext ctx);
void exitIntBLTE(HCleanParser.IntBLTEContext ctx);
void enterRpathValue(HCleanParser.RpathValueContext ctx);
void exitRpathValue(HCleanParser.RpathValueContext ctx);
void enterIntegerValue(HCleanParser.IntegerValueContext ctx);
void exitIntegerValue(HCleanParser.IntegerValueContext ctx);
void enterIntDiv(HCleanParser.IntDivContext ctx);
void exitIntDiv(HCleanParser.IntDivContext ctx);
void enterRuleNode(HCleanParser.RuleNodeContext ctx);
void exitRuleNode(HCleanParser.RuleNodeContext ctx);
void enterIntMult(HCleanParser.IntMultContext ctx);
void exitIntMult(HCleanParser.IntMultContext ctx);
void enterStrCN(HCleanParser.StrCNContext ctx);
void exitStrCN(HCleanParser.StrCNContext ctx);
void enterIntAdd(HCleanParser.IntAddContext ctx);
void exitIntAdd(HCleanParser.IntAddContext ctx);
void enterTrueValue(HCleanParser.TrueValueContext ctx);
void exitTrueValue(HCleanParser.TrueValueContext ctx);
void enterIntSub(HCleanParser.IntSubContext ctx);
void exitIntSub(HCleanParser.IntSubContext ctx);
void enterFalseValue(HCleanParser.FalseValueContext ctx);
void exitFalseValue(HCleanParser.FalseValueContext ctx);
void enterXorNode(HCleanParser.XorNodeContext ctx);
void exitXorNode(HCleanParser.XorNodeContext ctx);
void enterIntBLT(HCleanParser.IntBLTContext ctx);
void exitIntBLT(HCleanParser.IntBLTContext ctx);
void enterIntGT(HCleanParser.IntGTContext ctx);
void exitIntGT(HCleanParser.IntGTContext ctx);
void enterAndNode(HCleanParser.AndNodeContext ctx);
void exitAndNode(HCleanParser.AndNodeContext ctx);
void enterIntBNE(HCleanParser.IntBNEContext ctx);
void exitIntBNE(HCleanParser.IntBNEContext ctx);
void enterIntGTE(HCleanParser.IntGTEContext ctx);
void exitIntGTE(HCleanParser.IntGTEContext ctx);
void enterAtimeValue(HCleanParser.AtimeValueContext ctx);
void exitAtimeValue(HCleanParser.AtimeValueContext ctx);
void enterOrNode(HCleanParser.OrNodeContext ctx);
void exitOrNode(HCleanParser.OrNodeContext ctx);
void enterPathValue(HCleanParser.PathValueContext ctx);
void exitPathValue(HCleanParser.PathValueContext ctx);
void enterStrNE(HCleanParser.StrNEContext ctx);
void exitStrNE(HCleanParser.StrNEContext ctx);
void enterIntBGT(HCleanParser.IntBGTContext ctx);
void exitIntBGT(HCleanParser.IntBGTContext ctx);
void enterIntLTE(HCleanParser.IntLTEContext ctx);
void exitIntLTE(HCleanParser.IntLTEContext ctx);
void enterDateValue(HCleanParser.DateValueContext ctx);
void exitDateValue(HCleanParser.DateValueContext ctx);
void enterNotNode(HCleanParser.NotNodeContext ctx);
void exitNotNode(HCleanParser.NotNodeContext ctx);
void enterIntEQ(HCleanParser.IntEQContext ctx);
void exitIntEQ(HCleanParser.IntEQContext ctx);
}
Raw
HCleanParser.java
// Generated from com\aol\hadoop\util\hce\HClean.g4 by ANTLR 4.0
package com.aol.hadoop.util.hce;
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 HCleanParser extends Parser {
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
TRUE=1, FALSE=2, APATH=3, RPATH=4, ATIME=5, MTIME=6, NOW=7, FILENAME=8,
AND=9, OR=10, XOR=11, NOT=12, LPAREN=13, RPAREN=14, GT=15, GTE=16, EQ=17,
NE=18, LTE=19, LT=20, CN=21, PLUS=22, MINUS=23, MULT=24, DIV=25, LCBRACE=26,
RCBRACE=27, WS=28, INT=29, STRING=30, DATE=31, PATH=32, TIME=33, DATETIMEVAL=34,
PATHVAL=35, ID=36;
public static final String[] tokenNames = {
"<INVALID>", "'true'", "'false'", "'apath'", "'rpath'", "'atime'", "'mtime'",
"'now'", "'filename'", "'AND'", "'OR'", "'XOR'", "'!'", "'('", "')'",
"'>'", "'>='", "'=='", "'!='", "'<='", "'<'", "'<>'", "'+'", "'-'", "'*'",
"'/'", "'{'", "'}'", "WS", "INT", "STRING", "'date'", "'path'", "'time'",
"DATETIMEVAL", "PATHVAL", "ID"
};
public static final int
RULE_ruleNode = 0, RULE_andNode = 1, RULE_orNode = 2, RULE_xorNode = 3,
RULE_notNode = 4, RULE_booleanValue = 5, RULE_intCompareNode = 6, RULE_intBetweenNode = 7,
RULE_intExpression = 8, RULE_stringCompareNode = 9, RULE_stringExpression = 10;
public static final String[] ruleNames = {
"ruleNode", "andNode", "orNode", "xorNode", "notNode", "booleanValue",
"intCompareNode", "intBetweenNode", "intExpression", "stringCompareNode",
"stringExpression"
};
@Override
public String getGrammarFileName() { return "HClean.g4"; }
@Override
public String[] getTokenNames() { return tokenNames; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public ATN getATN() { return _ATN; }
public HCleanParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class RuleNodeContext extends ParserRuleContext {
public OrNodeContext orNode() {
return getRuleContext(OrNodeContext.class,0);
}
public XorNodeContext xorNode() {
return getRuleContext(XorNodeContext.class,0);
}
public IntBetweenNodeContext intBetweenNode() {
return getRuleContext(IntBetweenNodeContext.class,0);
}
public IntCompareNodeContext intCompareNode() {
return getRuleContext(IntCompareNodeContext.class,0);
}
public AndNodeContext andNode() {
return getRuleContext(AndNodeContext.class,0);
}
public StringCompareNodeContext stringCompareNode() {
return getRuleContext(StringCompareNodeContext.class,0);
}
public BooleanValueContext booleanValue() {
return getRuleContext(BooleanValueContext.class,0);
}
public NotNodeContext notNode() {
return getRuleContext(NotNodeContext.class,0);
}
public RuleNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ruleNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).enterRuleNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).exitRuleNode(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof HCleanVisitor ) return ((HCleanVisitor<? extends T>)visitor).visitRuleNode(this);
else return visitor.visitChildren(this);
}
}
public final RuleNodeContext ruleNode() throws RecognitionException {
RuleNodeContext _localctx = new RuleNodeContext(_ctx, getState());
enterRule(_localctx, 0, RULE_ruleNode);
try {
setState(30);
switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(22); andNode();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(23); orNode();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(24); xorNode();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(25); notNode();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(26); booleanValue();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(27); intCompareNode();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(28); intBetweenNode();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(29); stringCompareNode();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AndNodeContext extends ParserRuleContext {
public TerminalNode RPAREN() { return getToken(HCleanParser.RPAREN, 0); }
public TerminalNode AND() { return getToken(HCleanParser.AND, 0); }
public List<RuleNodeContext> ruleNode() {
return getRuleContexts(RuleNodeContext.class);
}
public RuleNodeContext ruleNode(int i) {
return getRuleContext(RuleNodeContext.class,i);
}
public TerminalNode LPAREN() { return getToken(HCleanParser.LPAREN, 0); }
public AndNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_andNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).enterAndNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).exitAndNode(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof HCleanVisitor ) return ((HCleanVisitor<? extends T>)visitor).visitAndNode(this);
else return visitor.visitChildren(this);
}
}
public final AndNodeContext andNode() throws RecognitionException {
AndNodeContext _localctx = new AndNodeContext(_ctx, getState());
enterRule(_localctx, 2, RULE_andNode);
try {
enterOuterAlt(_localctx, 1);
{
setState(32); match(LPAREN);
setState(33); ruleNode();
setState(34); match(AND);
setState(35); ruleNode();
setState(36); match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OrNodeContext extends ParserRuleContext {
public TerminalNode RPAREN() { return getToken(HCleanParser.RPAREN, 0); }
public List<RuleNodeContext> ruleNode() {
return getRuleContexts(RuleNodeContext.class);
}
public RuleNodeContext ruleNode(int i) {
return getRuleContext(RuleNodeContext.class,i);
}
public TerminalNode LPAREN() { return getToken(HCleanParser.LPAREN, 0); }
public TerminalNode OR() { return getToken(HCleanParser.OR, 0); }
public OrNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_orNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).enterOrNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).exitOrNode(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof HCleanVisitor ) return ((HCleanVisitor<? extends T>)visitor).visitOrNode(this);
else return visitor.visitChildren(this);
}
}
public final OrNodeContext orNode() throws RecognitionException {
OrNodeContext _localctx = new OrNodeContext(_ctx, getState());
enterRule(_localctx, 4, RULE_orNode);
try {
enterOuterAlt(_localctx, 1);
{
setState(38); match(LPAREN);
setState(39); ruleNode();
setState(40); match(OR);
setState(41); ruleNode();
setState(42); match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class XorNodeContext extends ParserRuleContext {
public TerminalNode RPAREN() { return getToken(HCleanParser.RPAREN, 0); }
public TerminalNode XOR() { return getToken(HCleanParser.XOR, 0); }
public List<RuleNodeContext> ruleNode() {
return getRuleContexts(RuleNodeContext.class);
}
public RuleNodeContext ruleNode(int i) {
return getRuleContext(RuleNodeContext.class,i);
}
public TerminalNode LPAREN() { return getToken(HCleanParser.LPAREN, 0); }
public XorNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_xorNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).enterXorNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).exitXorNode(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof HCleanVisitor ) return ((HCleanVisitor<? extends T>)visitor).visitXorNode(this);
else return visitor.visitChildren(this);
}
}
public final XorNodeContext xorNode() throws RecognitionException {
XorNodeContext _localctx = new XorNodeContext(_ctx, getState());
enterRule(_localctx, 6, RULE_xorNode);
try {
enterOuterAlt(_localctx, 1);
{
setState(44); match(LPAREN);
setState(45); ruleNode();
setState(46); match(XOR);
setState(47); ruleNode();
setState(48); match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NotNodeContext extends ParserRuleContext {
public TerminalNode NOT() { return getToken(HCleanParser.NOT, 0); }
public RuleNodeContext ruleNode() {
return getRuleContext(RuleNodeContext.class,0);
}
public NotNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_notNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).enterNotNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).exitNotNode(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof HCleanVisitor ) return ((HCleanVisitor<? extends T>)visitor).visitNotNode(this);
else return visitor.visitChildren(this);
}
}
public final NotNodeContext notNode() throws RecognitionException {
NotNodeContext _localctx = new NotNodeContext(_ctx, getState());
enterRule(_localctx, 8, RULE_notNode);
try {
enterOuterAlt(_localctx, 1);
{
setState(50); match(NOT);
setState(51); ruleNode();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BooleanValueContext extends ParserRuleContext {
public BooleanValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_booleanValue; }
public BooleanValueContext() { }
public void copyFrom(BooleanValueContext ctx) {
super.copyFrom(ctx);
}
}
public static class TrueValueContext extends BooleanValueContext {
public TerminalNode TRUE() { return getToken(HCleanParser.TRUE, 0); }
public TrueValueContext(BooleanValueContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).enterTrueValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).exitTrueValue(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof HCleanVisitor ) return ((HCleanVisitor<? extends T>)visitor).visitTrueValue(this);
else return visitor.visitChildren(this);
}
}
public static class FalseValueContext extends BooleanValueContext {
public TerminalNode FALSE() { return getToken(HCleanParser.FALSE, 0); }
public FalseValueContext(BooleanValueContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).enterFalseValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).exitFalseValue(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof HCleanVisitor ) return ((HCleanVisitor<? extends T>)visitor).visitFalseValue(this);
else return visitor.visitChildren(this);
}
}
public final BooleanValueContext booleanValue() throws RecognitionException {
BooleanValueContext _localctx = new BooleanValueContext(_ctx, getState());
enterRule(_localctx, 10, RULE_booleanValue);
try {
setState(55);
switch (_input.LA(1)) {
case TRUE:
_localctx = new TrueValueContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(53); match(TRUE);
}
break;
case FALSE:
_localctx = new FalseValueContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(54); match(FALSE);
}
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 static class IntCompareNodeContext extends ParserRuleContext {
public IntCompareNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_intCompareNode; }
public IntCompareNodeContext() { }
public void copyFrom(IntCompareNodeContext ctx) {
super.copyFrom(ctx);
}
}
public static class IntNEContext extends IntCompareNodeContext {
public TerminalNode RPAREN() { return getToken(HCleanParser.RPAREN, 0); }
public IntExpressionContext intExpression(int i) {
return getRuleContext(IntExpressionContext.class,i);
}
public List<IntExpressionContext> intExpression() {
return getRuleContexts(IntExpressionContext.class);
}
public TerminalNode LPAREN() { return getToken(HCleanParser.LPAREN, 0); }
public TerminalNode NE() { return getToken(HCleanParser.NE, 0); }
public IntNEContext(IntCompareNodeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).enterIntNE(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).exitIntNE(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof HCleanVisitor ) return ((HCleanVisitor<? extends T>)visitor).visitIntNE(this);
else return visitor.visitChildren(this);
}
}
public static class IntLTContext extends IntCompareNodeContext {
public TerminalNode RPAREN() { return getToken(HCleanParser.RPAREN, 0); }
public TerminalNode LT() { return getToken(HCleanParser.LT, 0); }
public IntExpressionContext intExpression(int i) {
return getRuleContext(IntExpressionContext.class,i);
}
public List<IntExpressionContext> intExpression() {
return getRuleContexts(IntExpressionContext.class);
}
public TerminalNode LPAREN() { return getToken(HCleanParser.LPAREN, 0); }
public IntLTContext(IntCompareNodeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).enterIntLT(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).exitIntLT(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof HCleanVisitor ) return ((HCleanVisitor<? extends T>)visitor).visitIntLT(this);
else return visitor.visitChildren(this);
}
}
public static class IntGTContext extends IntCompareNodeContext {
public TerminalNode RPAREN() { return getToken(HCleanParser.RPAREN, 0); }
public TerminalNode GT() { return getToken(HCleanParser.GT, 0); }
public IntExpressionContext intExpression(int i) {
return getRuleContext(IntExpressionContext.class,i);
}
public List<IntExpressionContext> intExpression() {
return getRuleContexts(IntExpressionContext.class);
}
public TerminalNode LPAREN() { return getToken(HCleanParser.LPAREN, 0); }
public IntGTContext(IntCompareNodeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).enterIntGT(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).exitIntGT(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof HCleanVisitor ) return ((HCleanVisitor<? extends T>)visitor).visitIntGT(this);
else return visitor.visitChildren(this);
}
}
public static class IntLTEContext extends IntCompareNodeContext {
public TerminalNode RPAREN() { return getToken(HCleanParser.RPAREN, 0); }
public IntExpressionContext intExpression(int i) {
return getRuleContext(IntExpressionContext.class,i);
}
public TerminalNode LTE() { return getToken(HCleanParser.LTE, 0); }
public List<IntExpressionContext> intExpression() {
return getRuleContexts(IntExpressionContext.class);
}
public TerminalNode LPAREN() { return getToken(HCleanParser.LPAREN, 0); }
public IntLTEContext(IntCompareNodeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).enterIntLTE(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).exitIntLTE(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof HCleanVisitor ) return ((HCleanVisitor<? extends T>)visitor).visitIntLTE(this);
else return visitor.visitChildren(this);
}
}
public static class IntGTEContext extends IntCompareNodeContext {
public TerminalNode RPAREN() { return getToken(HCleanParser.RPAREN, 0); }
public IntExpressionContext intExpression(int i) {
return getRuleContext(IntExpressionContext.class,i);
}
public List<IntExpressionContext> intExpression() {
return getRuleContexts(IntExpressionContext.class);
}
public TerminalNode LPAREN() { return getToken(HCleanParser.LPAREN, 0); }
public TerminalNode GTE() { return getToken(HCleanParser.GTE, 0); }
public IntGTEContext(IntCompareNodeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).enterIntGTE(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).exitIntGTE(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof HCleanVisitor ) return ((HCleanVisitor<? extends T>)visitor).visitIntGTE(this);
else return visitor.visitChildren(this);
}
}
public static class IntEQContext extends IntCompareNodeContext {
public TerminalNode RPAREN() { return getToken(HCleanParser.RPAREN, 0); }
public IntExpressionContext intExpression(int i) {
return getRuleContext(IntExpressionContext.class,i);
}
public TerminalNode EQ() { return getToken(HCleanParser.EQ, 0); }
public List<IntExpressionContext> intExpression() {
return getRuleContexts(IntExpressionContext.class);
}
public TerminalNode LPAREN() { return getToken(HCleanParser.LPAREN, 0); }
public IntEQContext(IntCompareNodeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).enterIntEQ(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).exitIntEQ(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof HCleanVisitor ) return ((HCleanVisitor<? extends T>)visitor).visitIntEQ(this);
else return visitor.visitChildren(this);
}
}
public final IntCompareNodeContext intCompareNode() throws RecognitionException {
IntCompareNodeContext _localctx = new IntCompareNodeContext(_ctx, getState());
enterRule(_localctx, 12, RULE_intCompareNode);
try {
setState(93);
switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
case 1:
_localctx = new IntLTContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(57); match(LPAREN);
setState(58); intExpression();
setState(59); match(LT);
setState(60); intExpression();
setState(61); match(RPAREN);
}
break;
case 2:
_localctx = new IntLTEContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(63); match(LPAREN);
setState(64); intExpression();
setState(65); match(LTE);
setState(66); intExpression();
setState(67); match(RPAREN);
}
break;
case 3:
_localctx = new IntEQContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(69); match(LPAREN);
setState(70); intExpression();
setState(71); match(EQ);
setState(72); intExpression();
setState(73); match(RPAREN);
}
break;
case 4:
_localctx = new IntNEContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(75); match(LPAREN);
setState(76); intExpression();
setState(77); match(NE);
setState(78); intExpression();
setState(79); match(RPAREN);
}
break;
case 5:
_localctx = new IntGTEContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(81); match(LPAREN);
setState(82); intExpression();
setState(83); match(GTE);
setState(84); intExpression();
setState(85); match(RPAREN);
}
break;
case 6:
_localctx = new IntGTContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(87); match(LPAREN);
setState(88); intExpression();
setState(89); match(GT);
setState(90); intExpression();
setState(91); match(RPAREN);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IntBetweenNodeContext extends ParserRuleContext {
public IntBetweenNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_intBetweenNode; }
public IntBetweenNodeContext() { }
public void copyFrom(IntBetweenNodeContext ctx) {
super.copyFrom(ctx);
}
}
public static class IntBGTEContext extends IntBetweenNodeContext {
public TerminalNode RPAREN() { return getToken(HCleanParser.RPAREN, 0); }
public IntExpressionContext intExpression(int i) {
return getRuleContext(IntExpressionContext.class,i);
}
public TerminalNode GTE(int i) {
return getToken(HCleanParser.GTE, i);
}
public List<IntExpressionContext> intExpression() {
return getRuleContexts(IntExpressionContext.class);
}
public TerminalNode LPAREN() { return getToken(HCleanParser.LPAREN, 0); }
public List<TerminalNode> GTE() { return getTokens(HCleanParser.GTE); }
public IntBGTEContext(IntBetweenNodeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).enterIntBGTE(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).exitIntBGTE(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof HCleanVisitor ) return ((HCleanVisitor<? extends T>)visitor).visitIntBGTE(this);
else return visitor.visitChildren(this);
}
}
public static class IntBLTEContext extends IntBetweenNodeContext {
public TerminalNode LTE(int i) {
return getToken(HCleanParser.LTE, i);
}
public TerminalNode RPAREN() { return getToken(HCleanParser.RPAREN, 0); }
public IntExpressionContext intExpression(int i) {
return getRuleContext(IntExpressionContext.class,i);
}
public List<TerminalNode> LTE() { return getTokens(HCleanParser.LTE); }
public List<IntExpressionContext> intExpression() {
return getRuleContexts(IntExpressionContext.class);
}
public TerminalNode LPAREN() { return getToken(HCleanParser.LPAREN, 0); }
public IntBLTEContext(IntBetweenNodeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).enterIntBLTE(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).exitIntBLTE(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof HCleanVisitor ) return ((HCleanVisitor<? extends T>)visitor).visitIntBLTE(this);
else return visitor.visitChildren(this);
}
}
public static class IntBLTContext extends IntBetweenNodeContext {
public TerminalNode RPAREN() { return getToken(HCleanParser.RPAREN, 0); }
public List<TerminalNode> LT() { return getTokens(HCleanParser.LT); }
public IntExpressionContext intExpression(int i) {
return getRuleContext(IntExpressionContext.class,i);
}
public TerminalNode LT(int i) {
return getToken(HCleanParser.LT, i);
}
public List<IntExpressionContext> intExpression() {
return getRuleContexts(IntExpressionContext.class);
}
public TerminalNode LPAREN() { return getToken(HCleanParser.LPAREN, 0); }
public IntBLTContext(IntBetweenNodeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).enterIntBLT(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).exitIntBLT(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof HCleanVisitor ) return ((HCleanVisitor<? extends T>)visitor).visitIntBLT(this);
else return visitor.visitChildren(this);
}
}
public static class IntBGTContext extends IntBetweenNodeContext {
public TerminalNode RPAREN() { return getToken(HCleanParser.RPAREN, 0); }
public List<TerminalNode> GT() { return getTokens(HCleanParser.GT); }
public IntExpressionContext intExpression(int i) {
return getRuleContext(IntExpressionContext.class,i);
}
public TerminalNode GT(int i) {
return getToken(HCleanParser.GT, i);
}
public List<IntExpressionContext> intExpression() {
return getRuleContexts(IntExpressionContext.class);
}
public TerminalNode LPAREN() { return getToken(HCleanParser.LPAREN, 0); }
public IntBGTContext(IntBetweenNodeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).enterIntBGT(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).exitIntBGT(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof HCleanVisitor ) return ((HCleanVisitor<? extends T>)visitor).visitIntBGT(this);
else return visitor.visitChildren(this);
}
}
public static class IntBNEContext extends IntBetweenNodeContext {
public TerminalNode RPAREN() { return getToken(HCleanParser.RPAREN, 0); }
public TerminalNode NE(int i) {
return getToken(HCleanParser.NE, i);
}
public IntExpressionContext intExpression(int i) {
return getRuleContext(IntExpressionContext.class,i);
}
public List<IntExpressionContext> intExpression() {
return getRuleContexts(IntExpressionContext.class);
}
public TerminalNode LPAREN() { return getToken(HCleanParser.LPAREN, 0); }
public List<TerminalNode> NE() { return getTokens(HCleanParser.NE); }
public IntBNEContext(IntBetweenNodeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).enterIntBNE(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).exitIntBNE(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof HCleanVisitor ) return ((HCleanVisitor<? extends T>)visitor).visitIntBNE(this);
else return visitor.visitChildren(this);
}
}
public static class IntBEQContext extends IntBetweenNodeContext {
public TerminalNode RPAREN() { return getToken(HCleanParser.RPAREN, 0); }
public IntExpressionContext intExpression(int i) {
return getRuleContext(IntExpressionContext.class,i);
}
public List<TerminalNode> EQ() { return getTokens(HCleanParser.EQ); }
public TerminalNode EQ(int i) {
return getToken(HCleanParser.EQ, i);
}
public List<IntExpressionContext> intExpression() {
return getRuleContexts(IntExpressionContext.class);
}
public TerminalNode LPAREN() { return getToken(HCleanParser.LPAREN, 0); }
public IntBEQContext(IntBetweenNodeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).enterIntBEQ(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).exitIntBEQ(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof HCleanVisitor ) return ((HCleanVisitor<? extends T>)visitor).visitIntBEQ(this);
else return visitor.visitChildren(this);
}
}
public final IntBetweenNodeContext intBetweenNode() throws RecognitionException {
IntBetweenNodeContext _localctx = new IntBetweenNodeContext(_ctx, getState());
enterRule(_localctx, 14, RULE_intBetweenNode);
try {
setState(143);
switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) {
case 1:
_localctx = new IntBLTContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(95); match(LPAREN);
setState(96); intExpression();
setState(97); match(LT);
setState(98); intExpression();
setState(99); match(LT);
setState(100); intExpression();
setState(101); match(RPAREN);
}
break;
case 2:
_localctx = new IntBLTEContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(103); match(LPAREN);
setState(104); intExpression();
setState(105); match(LTE);
setState(106); intExpression();
setState(107); match(LTE);
setState(108); intExpression();
setState(109); match(RPAREN);
}
break;
case 3:
_localctx = new IntBEQContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(111); match(LPAREN);
setState(112); intExpression();
setState(113); match(EQ);
setState(114); intExpression();
setState(115); match(EQ);
setState(116); intExpression();
setState(117); match(RPAREN);
}
break;
case 4:
_localctx = new IntBNEContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(119); match(LPAREN);
setState(120); intExpression();
setState(121); match(NE);
setState(122); intExpression();
setState(123); match(NE);
setState(124); intExpression();
setState(125); match(RPAREN);
}
break;
case 5:
_localctx = new IntBGTEContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(127); match(LPAREN);
setState(128); intExpression();
setState(129); match(GTE);
setState(130); intExpression();
setState(131); match(GTE);
setState(132); intExpression();
setState(133); match(RPAREN);
}
break;
case 6:
_localctx = new IntBGTContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(135); match(LPAREN);
setState(136); intExpression();
setState(137); match(GT);
setState(138); intExpression();
setState(139); match(GT);
setState(140); intExpression();
setState(141); match(RPAREN);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IntExpressionContext extends ParserRuleContext {
public IntExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_intExpression; }
public IntExpressionContext() { }
public void copyFrom(IntExpressionContext ctx) {
super.copyFrom(ctx);
}
}
public static class IntAddContext extends IntExpressionContext {
public TerminalNode RPAREN() { return getToken(HCleanParser.RPAREN, 0); }
public TerminalNode PLUS() { return getToken(HCleanParser.PLUS, 0); }
public IntExpressionContext intExpression(int i) {
return getRuleContext(IntExpressionContext.class,i);
}
public List<IntExpressionContext> intExpression() {
return getRuleContexts(IntExpressionContext.class);
}
public TerminalNode LPAREN() { return getToken(HCleanParser.LPAREN, 0); }
public IntAddContext(IntExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).enterIntAdd(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).exitIntAdd(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof HCleanVisitor ) return ((HCleanVisitor<? extends T>)visitor).visitIntAdd(this);
else return visitor.visitChildren(this);
}
}
public static class MtimeValueContext extends IntExpressionContext {
public TerminalNode MTIME() { return getToken(HCleanParser.MTIME, 0); }
public MtimeValueContext(IntExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).enterMtimeValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).exitMtimeValue(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof HCleanVisitor ) return ((HCleanVisitor<? extends T>)visitor).visitMtimeValue(this);
else return visitor.visitChildren(this);
}
}
public static class IntSubContext extends IntExpressionContext {
public TerminalNode RPAREN() { return getToken(HCleanParser.RPAREN, 0); }
public IntExpressionContext intExpression(int i) {
return getRuleContext(IntExpressionContext.class,i);
}
public TerminalNode MINUS() { return getToken(HCleanParser.MINUS, 0); }
public List<IntExpressionContext> intExpression() {
return getRuleContexts(IntExpressionContext.class);
}
public TerminalNode LPAREN() { return getToken(HCleanParser.LPAREN, 0); }
public IntSubContext(IntExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).enterIntSub(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).exitIntSub(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof HCleanVisitor ) return ((HCleanVisitor<? extends T>)visitor).visitIntSub(this);
else return visitor.visitChildren(this);
}
}
public static class PathValueContext extends IntExpressionContext {
public TerminalNode PATHVAL() { return getToken(HCleanParser.PATHVAL, 0); }
public TerminalNode PATH() { return getToken(HCleanParser.PATH, 0); }
public TerminalNode RCBRACE() { return getToken(HCleanParser.RCBRACE, 0); }
public TerminalNode LCBRACE() { return getToken(HCleanParser.LCBRACE, 0); }
public PathValueContext(IntExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).enterPathValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).exitPathValue(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof HCleanVisitor ) return ((HCleanVisitor<? extends T>)visitor).visitPathValue(this);
else return visitor.visitChildren(this);
}
}
public static class TimeValueContext extends IntExpressionContext {
public TerminalNode TIME() { return getToken(HCleanParser.TIME, 0); }
public TerminalNode DATETIMEVAL() { return getToken(HCleanParser.DATETIMEVAL, 0); }
public TerminalNode RCBRACE() { return getToken(HCleanParser.RCBRACE, 0); }
public TerminalNode LCBRACE() { return getToken(HCleanParser.LCBRACE, 0); }
public TimeValueContext(IntExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).enterTimeValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).exitTimeValue(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof HCleanVisitor ) return ((HCleanVisitor<? extends T>)visitor).visitTimeValue(this);
else return visitor.visitChildren(this);
}
}
public static class IntDivContext extends IntExpressionContext {
public TerminalNode RPAREN() { return getToken(HCleanParser.RPAREN, 0); }
public IntExpressionContext intExpression(int i) {
return getRuleContext(IntExpressionContext.class,i);
}
public TerminalNode DIV() { return getToken(HCleanParser.DIV, 0); }
public List<IntExpressionContext> intExpression() {
return getRuleContexts(IntExpressionContext.class);
}
public TerminalNode LPAREN() { return getToken(HCleanParser.LPAREN, 0); }
public IntDivContext(IntExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).enterIntDiv(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).exitIntDiv(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof HCleanVisitor ) return ((HCleanVisitor<? extends T>)visitor).visitIntDiv(this);
else return visitor.visitChildren(this);
}
}
public static class IntegerValueContext extends IntExpressionContext {
public TerminalNode INT() { return getToken(HCleanParser.INT, 0); }
public IntegerValueContext(IntExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).enterIntegerValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).exitIntegerValue(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof HCleanVisitor ) return ((HCleanVisitor<? extends T>)visitor).visitIntegerValue(this);
else return visitor.visitChildren(this);
}
}
public static class IntMultContext extends IntExpressionContext {
public TerminalNode RPAREN() { return getToken(HCleanParser.RPAREN, 0); }
public IntExpressionContext intExpression(int i) {
return getRuleContext(IntExpressionContext.class,i);
}
public TerminalNode MULT() { return getToken(HCleanParser.MULT, 0); }
public List<IntExpressionContext> intExpression() {
return getRuleContexts(IntExpressionContext.class);
}
public TerminalNode LPAREN() { return getToken(HCleanParser.LPAREN, 0); }
public IntMultContext(IntExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).enterIntMult(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).exitIntMult(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof HCleanVisitor ) return ((HCleanVisitor<? extends T>)visitor).visitIntMult(this);
else return visitor.visitChildren(this);
}
}
public static class NowValueContext extends IntExpressionContext {
public TerminalNode NOW() { return getToken(HCleanParser.NOW, 0); }
public NowValueContext(IntExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).enterNowValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).exitNowValue(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof HCleanVisitor ) return ((HCleanVisitor<? extends T>)visitor).visitNowValue(this);
else return visitor.visitChildren(this);
}
}
public static class AtimeValueContext extends IntExpressionContext {
public TerminalNode ATIME() { return getToken(HCleanParser.ATIME, 0); }
public AtimeValueContext(IntExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).enterAtimeValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).exitAtimeValue(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof HCleanVisitor ) return ((HCleanVisitor<? extends T>)visitor).visitAtimeValue(this);
else return visitor.visitChildren(this);
}
}
public static class DateValueContext extends IntExpressionContext {
public TerminalNode DATETIMEVAL() { return getToken(HCleanParser.DATETIMEVAL, 0); }
public TerminalNode DATE() { return getToken(HCleanParser.DATE, 0); }
public TerminalNode RCBRACE() { return getToken(HCleanParser.RCBRACE, 0); }
public TerminalNode LCBRACE() { return getToken(HCleanParser.LCBRACE, 0); }
public DateValueContext(IntExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).enterDateValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).exitDateValue(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof HCleanVisitor ) return ((HCleanVisitor<? extends T>)visitor).visitDateValue(this);
else return visitor.visitChildren(this);
}
}
public final IntExpressionContext intExpression() throws RecognitionException {
IntExpressionContext _localctx = new IntExpressionContext(_ctx, getState());
enterRule(_localctx, 16, RULE_intExpression);
try {
setState(185);
switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
case 1:
_localctx = new IntAddContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(145); match(LPAREN);
setState(146); intExpression();
setState(147); match(PLUS);
setState(148); intExpression();
setState(149); match(RPAREN);
}
break;
case 2:
_localctx = new IntSubContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(151); match(LPAREN);
setState(152); intExpression();
setState(153); match(MINUS);
setState(154); intExpression();
setState(155); match(RPAREN);
}
break;
case 3:
_localctx = new IntMultContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(157); match(LPAREN);
setState(158); intExpression();
setState(159); match(MULT);
setState(160); intExpression();
setState(161); match(RPAREN);
}
break;
case 4:
_localctx = new IntDivContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(163); match(LPAREN);
setState(164); intExpression();
setState(165); match(DIV);
setState(166); intExpression();
setState(167); match(RPAREN);
}
break;
case 5:
_localctx = new AtimeValueContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(169); match(ATIME);
}
break;
case 6:
_localctx = new MtimeValueContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(170); match(MTIME);
}
break;
case 7:
_localctx = new DateValueContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(171); match(DATE);
setState(172); match(LCBRACE);
setState(173); match(DATETIMEVAL);
setState(174); match(RCBRACE);
}
break;
case 8:
_localctx = new PathValueContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(175); match(PATH);
setState(176); match(LCBRACE);
setState(177); match(PATHVAL);
setState(178); match(RCBRACE);
}
break;
case 9:
_localctx = new IntegerValueContext(_localctx);
enterOuterAlt(_localctx, 9);
{
setState(179); match(INT);
}
break;
case 10:
_localctx = new NowValueContext(_localctx);
enterOuterAlt(_localctx, 10);
{
setState(180); match(NOW);
}
break;
case 11:
_localctx = new TimeValueContext(_localctx);
enterOuterAlt(_localctx, 11);
{
setState(181); match(TIME);
setState(182); match(LCBRACE);
setState(183); match(DATETIMEVAL);
setState(184); match(RCBRACE);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StringCompareNodeContext extends ParserRuleContext {
public StringCompareNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_stringCompareNode; }
public StringCompareNodeContext() { }
public void copyFrom(StringCompareNodeContext ctx) {
super.copyFrom(ctx);
}
}
public static class StrEQContext extends StringCompareNodeContext {
public List<StringExpressionContext> stringExpression() {
return getRuleContexts(StringExpressionContext.class);
}
public TerminalNode RPAREN() { return getToken(HCleanParser.RPAREN, 0); }
public TerminalNode EQ() { return getToken(HCleanParser.EQ, 0); }
public StringExpressionContext stringExpression(int i) {
return getRuleContext(StringExpressionContext.class,i);
}
public TerminalNode LPAREN() { return getToken(HCleanParser.LPAREN, 0); }
public StrEQContext(StringCompareNodeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).enterStrEQ(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).exitStrEQ(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof HCleanVisitor ) return ((HCleanVisitor<? extends T>)visitor).visitStrEQ(this);
else return visitor.visitChildren(this);
}
}
public static class StrNEContext extends StringCompareNodeContext {
public List<StringExpressionContext> stringExpression() {
return getRuleContexts(StringExpressionContext.class);
}
public TerminalNode RPAREN() { return getToken(HCleanParser.RPAREN, 0); }
public StringExpressionContext stringExpression(int i) {
return getRuleContext(StringExpressionContext.class,i);
}
public TerminalNode LPAREN() { return getToken(HCleanParser.LPAREN, 0); }
public TerminalNode NE() { return getToken(HCleanParser.NE, 0); }
public StrNEContext(StringCompareNodeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).enterStrNE(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).exitStrNE(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof HCleanVisitor ) return ((HCleanVisitor<? extends T>)visitor).visitStrNE(this);
else return visitor.visitChildren(this);
}
}
public static class StrCNContext extends StringCompareNodeContext {
public List<StringExpressionContext> stringExpression() {
return getRuleContexts(StringExpressionContext.class);
}
public TerminalNode RPAREN() { return getToken(HCleanParser.RPAREN, 0); }
public StringExpressionContext stringExpression(int i) {
return getRuleContext(StringExpressionContext.class,i);
}
public TerminalNode CN() { return getToken(HCleanParser.CN, 0); }
public TerminalNode LPAREN() { return getToken(HCleanParser.LPAREN, 0); }
public StrCNContext(StringCompareNodeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).enterStrCN(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).exitStrCN(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof HCleanVisitor ) return ((HCleanVisitor<? extends T>)visitor).visitStrCN(this);
else return visitor.visitChildren(this);
}
}
public final StringCompareNodeContext stringCompareNode() throws RecognitionException {
StringCompareNodeContext _localctx = new StringCompareNodeContext(_ctx, getState());
enterRule(_localctx, 18, RULE_stringCompareNode);
try {
setState(205);
switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
case 1:
_localctx = new StrEQContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(187); match(LPAREN);
setState(188); stringExpression();
setState(189); match(EQ);
setState(190); stringExpression();
setState(191); match(RPAREN);
}
break;
case 2:
_localctx = new StrNEContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(193); match(LPAREN);
setState(194); stringExpression();
setState(195); match(NE);
setState(196); stringExpression();
setState(197); match(RPAREN);
}
break;
case 3:
_localctx = new StrCNContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(199); match(LPAREN);
setState(200); stringExpression();
setState(201); match(CN);
setState(202); stringExpression();
setState(203); match(RPAREN);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StringExpressionContext extends ParserRuleContext {
public StringExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_stringExpression; }
public StringExpressionContext() { }
public void copyFrom(StringExpressionContext ctx) {
super.copyFrom(ctx);
}
}
public static class RpathValueContext extends StringExpressionContext {
public TerminalNode RPATH() { return getToken(HCleanParser.RPATH, 0); }
public RpathValueContext(StringExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).enterRpathValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).exitRpathValue(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof HCleanVisitor ) return ((HCleanVisitor<? extends T>)visitor).visitRpathValue(this);
else return visitor.visitChildren(this);
}
}
public static class StringValueContext extends StringExpressionContext {
public TerminalNode STRING() { return getToken(HCleanParser.STRING, 0); }
public StringValueContext(StringExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).enterStringValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).exitStringValue(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof HCleanVisitor ) return ((HCleanVisitor<? extends T>)visitor).visitStringValue(this);
else return visitor.visitChildren(this);
}
}
public static class FilenameValueContext extends StringExpressionContext {
public TerminalNode FILENAME() { return getToken(HCleanParser.FILENAME, 0); }
public FilenameValueContext(StringExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).enterFilenameValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).exitFilenameValue(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof HCleanVisitor ) return ((HCleanVisitor<? extends T>)visitor).visitFilenameValue(this);
else return visitor.visitChildren(this);
}
}
public static class ApathValueContext extends StringExpressionContext {
public TerminalNode APATH() { return getToken(HCleanParser.APATH, 0); }
public ApathValueContext(StringExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).enterApathValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HCleanListener ) ((HCleanListener)listener).exitApathValue(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof HCleanVisitor ) return ((HCleanVisitor<? extends T>)visitor).visitApathValue(this);
else return visitor.visitChildren(this);
}
}
public final StringExpressionContext stringExpression() throws RecognitionException {
StringExpressionContext _localctx = new StringExpressionContext(_ctx, getState());
enterRule(_localctx, 20, RULE_stringExpression);
try {
setState(211);
switch (_input.LA(1)) {
case APATH:
_localctx = new ApathValueContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(207); match(APATH);
}
break;
case RPATH:
_localctx = new RpathValueContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(208); match(RPATH);
}
break;
case FILENAME:
_localctx = new FilenameValueContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(209); match(FILENAME);
}
break;
case STRING:
_localctx = new StringValueContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(210); match(STRING);
}
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 static final String _serializedATN =
"\2\3&\u00d8\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\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\5\2!"+
"\n\2\3\3\3\3\3\3\3\3\3\3\3\3\3\4\3\4\3\4\3\4\3\4\3\4\3\5\3\5\3\5\3\5\3"+
"\5\3\5\3\6\3\6\3\6\3\7\3\7\5\7:\n\7\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3"+
"\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b"+
"\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\5\b`\n\b\3\t\3\t\3\t\3\t\3\t"+
"\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3"+
"\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t"+
"\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\5\t\u0092\n\t\3\n\3\n\3\n\3\n\3\n\3\n"+
"\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3"+
"\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\5\n"+
"\u00bc\n\n\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13"+
"\3\13\3\13\3\13\3\13\3\13\3\13\5\13\u00d0\n\13\3\f\3\f\3\f\3\f\5\f\u00d6"+
"\n\f\3\f\2\r\2\4\6\b\n\f\16\20\22\24\26\2\2\u00ed\2 \3\2\2\2\4\"\3\2\2"+
"\2\6(\3\2\2\2\b.\3\2\2\2\n\64\3\2\2\2\f9\3\2\2\2\16_\3\2\2\2\20\u0091"+
"\3\2\2\2\22\u00bb\3\2\2\2\24\u00cf\3\2\2\2\26\u00d5\3\2\2\2\30!\5\4\3"+
"\2\31!\5\6\4\2\32!\5\b\5\2\33!\5\n\6\2\34!\5\f\7\2\35!\5\16\b\2\36!\5"+
"\20\t\2\37!\5\24\13\2 \30\3\2\2\2 \31\3\2\2\2 \32\3\2\2\2 \33\3\2\2\2"+
" \34\3\2\2\2 \35\3\2\2\2 \36\3\2\2\2 \37\3\2\2\2!\3\3\2\2\2\"#\7\17\2"+
"\2#$\5\2\2\2$%\7\13\2\2%&\5\2\2\2&\'\7\20\2\2\'\5\3\2\2\2()\7\17\2\2)"+
"*\5\2\2\2*+\7\f\2\2+,\5\2\2\2,-\7\20\2\2-\7\3\2\2\2./\7\17\2\2/\60\5\2"+
"\2\2\60\61\7\r\2\2\61\62\5\2\2\2\62\63\7\20\2\2\63\t\3\2\2\2\64\65\7\16"+
"\2\2\65\66\5\2\2\2\66\13\3\2\2\2\67:\7\3\2\28:\7\4\2\29\67\3\2\2\298\3"+
"\2\2\2:\r\3\2\2\2;<\7\17\2\2<=\5\22\n\2=>\7\26\2\2>?\5\22\n\2?@\7\20\2"+
"\2@`\3\2\2\2AB\7\17\2\2BC\5\22\n\2CD\7\25\2\2DE\5\22\n\2EF\7\20\2\2F`"+
"\3\2\2\2GH\7\17\2\2HI\5\22\n\2IJ\7\23\2\2JK\5\22\n\2KL\7\20\2\2L`\3\2"+
"\2\2MN\7\17\2\2NO\5\22\n\2OP\7\24\2\2PQ\5\22\n\2QR\7\20\2\2R`\3\2\2\2"+
"ST\7\17\2\2TU\5\22\n\2UV\7\22\2\2VW\5\22\n\2WX\7\20\2\2X`\3\2\2\2YZ\7"+
"\17\2\2Z[\5\22\n\2[\\\7\21\2\2\\]\5\22\n\2]^\7\20\2\2^`\3\2\2\2_;\3\2"+
"\2\2_A\3\2\2\2_G\3\2\2\2_M\3\2\2\2_S\3\2\2\2_Y\3\2\2\2`\17\3\2\2\2ab\7"+
"\17\2\2bc\5\22\n\2cd\7\26\2\2de\5\22\n\2ef\7\26\2\2fg\5\22\n\2gh\7\20"+
"\2\2h\u0092\3\2\2\2ij\7\17\2\2jk\5\22\n\2kl\7\25\2\2lm\5\22\n\2mn\7\25"+
"\2\2no\5\22\n\2op\7\20\2\2p\u0092\3\2\2\2qr\7\17\2\2rs\5\22\n\2st\7\23"+
"\2\2tu\5\22\n\2uv\7\23\2\2vw\5\22\n\2wx\7\20\2\2x\u0092\3\2\2\2yz\7\17"+
"\2\2z{\5\22\n\2{|\7\24\2\2|}\5\22\n\2}~\7\24\2\2~\177\5\22\n\2\177\u0080"+
"\7\20\2\2\u0080\u0092\3\2\2\2\u0081\u0082\7\17\2\2\u0082\u0083\5\22\n"+
"\2\u0083\u0084\7\22\2\2\u0084\u0085\5\22\n\2\u0085\u0086\7\22\2\2\u0086"+
"\u0087\5\22\n\2\u0087\u0088\7\20\2\2\u0088\u0092\3\2\2\2\u0089\u008a\7"+
"\17\2\2\u008a\u008b\5\22\n\2\u008b\u008c\7\21\2\2\u008c\u008d\5\22\n\2"+
"\u008d\u008e\7\21\2\2\u008e\u008f\5\22\n\2\u008f\u0090\7\20\2\2\u0090"+
"\u0092\3\2\2\2\u0091a\3\2\2\2\u0091i\3\2\2\2\u0091q\3\2\2\2\u0091y\3\2"+
"\2\2\u0091\u0081\3\2\2\2\u0091\u0089\3\2\2\2\u0092\21\3\2\2\2\u0093\u0094"+
"\7\17\2\2\u0094\u0095\5\22\n\2\u0095\u0096\7\30\2\2\u0096\u0097\5\22\n"+
"\2\u0097\u0098\7\20\2\2\u0098\u00bc\3\2\2\2\u0099\u009a\7\17\2\2\u009a"+
"\u009b\5\22\n\2\u009b\u009c\7\31\2\2\u009c\u009d\5\22\n\2\u009d\u009e"+
"\7\20\2\2\u009e\u00bc\3\2\2\2\u009f\u00a0\7\17\2\2\u00a0\u00a1\5\22\n"+
"\2\u00a1\u00a2\7\32\2\2\u00a2\u00a3\5\22\n\2\u00a3\u00a4\7\20\2\2\u00a4"+
"\u00bc\3\2\2\2\u00a5\u00a6\7\17\2\2\u00a6\u00a7\5\22\n\2\u00a7\u00a8\7"+
"\33\2\2\u00a8\u00a9\5\22\n\2\u00a9\u00aa\7\20\2\2\u00aa\u00bc\3\2\2\2"+
"\u00ab\u00bc\7\7\2\2\u00ac\u00bc\7\b\2\2\u00ad\u00ae\7!\2\2\u00ae\u00af"+
"\7\34\2\2\u00af\u00b0\7$\2\2\u00b0\u00bc\7\35\2\2\u00b1\u00b2\7\"\2\2"+
"\u00b2\u00b3\7\34\2\2\u00b3\u00b4\7%\2\2\u00b4\u00bc\7\35\2\2\u00b5\u00bc"+
"\7\37\2\2\u00b6\u00bc\7\t\2\2\u00b7\u00b8\7#\2\2\u00b8\u00b9\7\34\2\2"+
"\u00b9\u00ba\7$\2\2\u00ba\u00bc\7\35\2\2\u00bb\u0093\3\2\2\2\u00bb\u0099"+
"\3\2\2\2\u00bb\u009f\3\2\2\2\u00bb\u00a5\3\2\2\2\u00bb\u00ab\3\2\2\2\u00bb"+
"\u00ac\3\2\2\2\u00bb\u00ad\3\2\2\2\u00bb\u00b1\3\2\2\2\u00bb\u00b5\3\2"+
"\2\2\u00bb\u00b6\3\2\2\2\u00bb\u00b7\3\2\2\2\u00bc\23\3\2\2\2\u00bd\u00be"+
"\7\17\2\2\u00be\u00bf\5\26\f\2\u00bf\u00c0\7\23\2\2\u00c0\u00c1\5\26\f"+
"\2\u00c1\u00c2\7\20\2\2\u00c2\u00d0\3\2\2\2\u00c3\u00c4\7\17\2\2\u00c4"+
"\u00c5\5\26\f\2\u00c5\u00c6\7\24\2\2\u00c6\u00c7\5\26\f\2\u00c7\u00c8"+
"\7\20\2\2\u00c8\u00d0\3\2\2\2\u00c9\u00ca\7\17\2\2\u00ca\u00cb\5\26\f"+
"\2\u00cb\u00cc\7\27\2\2\u00cc\u00cd\5\26\f\2\u00cd\u00ce\7\20\2\2\u00ce"+
"\u00d0\3\2\2\2\u00cf\u00bd\3\2\2\2\u00cf\u00c3\3\2\2\2\u00cf\u00c9\3\2"+
"\2\2\u00d0\25\3\2\2\2\u00d1\u00d6\7\5\2\2\u00d2\u00d6\7\6\2\2\u00d3\u00d6"+
"\7\n\2\2\u00d4\u00d6\7 \2\2\u00d5\u00d1\3\2\2\2\u00d5\u00d2\3\2\2\2\u00d5"+
"\u00d3\3\2\2\2\u00d5\u00d4\3\2\2\2\u00d6\27\3\2\2\2\t 9_\u0091\u00bb\u00cf"+
"\u00d5";
public static final ATN _ATN =
ATNSimulator.deserialize(_serializedATN.toCharArray());
static {
_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
}
}
Raw
HCleanVisitor.java
// Generated from com\aol\hadoop\util\hce\HClean.g4 by ANTLR 4.0
package com.aol.hadoop.util.hce;
import org.antlr.v4.runtime.tree.*;
import org.antlr.v4.runtime.Token;
public interface HCleanVisitor<T> extends ParseTreeVisitor<T> {
T visitTimeValue(HCleanParser.TimeValueContext ctx);
T visitIntLT(HCleanParser.IntLTContext ctx);
T visitStringValue(HCleanParser.StringValueContext ctx);
T visitFilenameValue(HCleanParser.FilenameValueContext ctx);
T visitNowValue(HCleanParser.NowValueContext ctx);
T visitApathValue(HCleanParser.ApathValueContext ctx);
T visitIntBEQ(HCleanParser.IntBEQContext ctx);
T visitIntBGTE(HCleanParser.IntBGTEContext ctx);
T visitMtimeValue(HCleanParser.MtimeValueContext ctx);
T visitStrEQ(HCleanParser.StrEQContext ctx);
T visitIntNE(HCleanParser.IntNEContext ctx);
T visitIntBLTE(HCleanParser.IntBLTEContext ctx);
T visitRpathValue(HCleanParser.RpathValueContext ctx);
T visitIntegerValue(HCleanParser.IntegerValueContext ctx);
T visitIntDiv(HCleanParser.IntDivContext ctx);
T visitRuleNode(HCleanParser.RuleNodeContext ctx);
T visitIntMult(HCleanParser.IntMultContext ctx);
T visitStrCN(HCleanParser.StrCNContext ctx);
T visitIntAdd(HCleanParser.IntAddContext ctx);
T visitTrueValue(HCleanParser.TrueValueContext ctx);
T visitIntSub(HCleanParser.IntSubContext ctx);
T visitFalseValue(HCleanParser.FalseValueContext ctx);
T visitXorNode(HCleanParser.XorNodeContext ctx);
T visitIntBLT(HCleanParser.IntBLTContext ctx);
T visitIntGT(HCleanParser.IntGTContext ctx);
T visitAndNode(HCleanParser.AndNodeContext ctx);
T visitIntBNE(HCleanParser.IntBNEContext ctx);
T visitIntGTE(HCleanParser.IntGTEContext ctx);
T visitAtimeValue(HCleanParser.AtimeValueContext ctx);
T visitOrNode(HCleanParser.OrNodeContext ctx);
T visitPathValue(HCleanParser.PathValueContext ctx);
T visitStrNE(HCleanParser.StrNEContext ctx);
T visitIntBGT(HCleanParser.IntBGTContext ctx);
T visitIntLTE(HCleanParser.IntLTEContext ctx);
T visitDateValue(HCleanParser.DateValueContext ctx);
T visitNotNode(HCleanParser.NotNodeContext ctx);
T visitIntEQ(HCleanParser.IntEQContext ctx);
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment