# Generated from STIXPattern.g4 by ANTLR 4.9.2 # encoding: utf-8 from antlr4 import * from io import StringIO import sys if sys.version_info[1] > 5: from typing import TextIO else: from typing.io import TextIO def serializedATN(): with StringIO() as buf: buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\38") buf.write("\u00eb\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7") buf.write("\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") buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23") buf.write("\3\2\3\2\3\2\3\3\3\3\3\3\3\3\3\3\3\3\7\3\60\n\3\f\3\16") buf.write("\3\63\13\3\3\4\3\4\3\4\3\4\3\4\3\4\7\4;\n\4\f\4\16\4>") buf.write("\13\4\3\5\3\5\3\5\3\5\3\5\3\5\7\5F\n\5\f\5\16\5I\13\5") buf.write("\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\5\6T\n\6\3\6\3\6") buf.write("\3\6\3\6\3\6\3\6\7\6\\\n\6\f\6\16\6_\13\6\3\7\3\7\3\7") buf.write("\3\7\3\7\3\7\7\7g\n\7\f\7\16\7j\13\7\3\b\3\b\3\b\3\b\3") buf.write("\b\3\b\7\br\n\b\f\b\16\bu\13\b\3\t\3\t\5\ty\n\t\3\t\3") buf.write("\t\3\t\3\t\3\t\5\t\u0080\n\t\3\t\3\t\3\t\3\t\3\t\5\t\u0087") buf.write("\n\t\3\t\3\t\3\t\3\t\3\t\5\t\u008e\n\t\3\t\3\t\3\t\3\t") buf.write("\3\t\5\t\u0095\n\t\3\t\3\t\3\t\3\t\3\t\5\t\u009c\n\t\3") buf.write("\t\3\t\3\t\3\t\3\t\5\t\u00a3\n\t\3\t\3\t\3\t\3\t\3\t\3") buf.write("\t\3\t\3\t\3\t\5\t\u00ae\n\t\3\n\3\n\3\n\3\n\3\n\3\13") buf.write("\3\13\3\13\3\13\3\f\3\f\3\f\3\f\3\r\3\r\3\r\3\r\5\r\u00c1") buf.write("\n\r\3\16\3\16\3\17\3\17\3\20\3\20\3\20\3\20\3\20\3\20") buf.write("\5\20\u00cd\n\20\3\20\3\20\7\20\u00d1\n\20\f\20\16\20") buf.write("\u00d4\13\20\3\21\3\21\3\21\3\21\3\21\3\21\7\21\u00dc") buf.write("\n\21\f\21\16\21\u00df\13\21\3\21\3\21\5\21\u00e3\n\21") buf.write("\3\22\3\22\5\22\u00e7\n\22\3\23\3\23\3\23\2\t\4\6\b\n") buf.write("\f\16\36\24\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"") buf.write("$\2\t\3\2!\"\3\2#&\4\2\4\4\6\6\3\2\37 \4\2\t\t\37\37\4") buf.write("\2\3\4\64\64\4\2\3\t\13\13\2\u00f6\2&\3\2\2\2\4)\3\2\2") buf.write("\2\6\64\3\2\2\2\b?\3\2\2\2\nS\3\2\2\2\f`\3\2\2\2\16k\3") buf.write("\2\2\2\20\u00ad\3\2\2\2\22\u00af\3\2\2\2\24\u00b4\3\2") buf.write("\2\2\26\u00b8\3\2\2\2\30\u00bc\3\2\2\2\32\u00c2\3\2\2") buf.write("\2\34\u00c4\3\2\2\2\36\u00cc\3\2\2\2 \u00e2\3\2\2\2\"") buf.write("\u00e6\3\2\2\2$\u00e8\3\2\2\2&\'\5\4\3\2\'(\7\2\2\3(\3") buf.write("\3\2\2\2)*\b\3\1\2*+\5\6\4\2+\61\3\2\2\2,-\f\4\2\2-.\7") buf.write("\17\2\2.\60\5\4\3\5/,\3\2\2\2\60\63\3\2\2\2\61/\3\2\2") buf.write("\2\61\62\3\2\2\2\62\5\3\2\2\2\63\61\3\2\2\2\64\65\b\4") buf.write("\1\2\65\66\5\b\5\2\66<\3\2\2\2\678\f\4\2\289\7\r\2\29") buf.write(";\5\6\4\5:\67\3\2\2\2;>\3\2\2\2<:\3\2\2\2<=\3\2\2\2=\7") buf.write("\3\2\2\2><\3\2\2\2?@\b\5\1\2@A\5\n\6\2AG\3\2\2\2BC\f\4") buf.write("\2\2CD\7\f\2\2DF\5\b\5\5EB\3\2\2\2FI\3\2\2\2GE\3\2\2\2") buf.write("GH\3\2\2\2H\t\3\2\2\2IG\3\2\2\2JK\b\6\1\2KL\7.\2\2LM\5") buf.write("\f\7\2MN\7-\2\2NT\3\2\2\2OP\7,\2\2PQ\5\4\3\2QR\7+\2\2") buf.write("RT\3\2\2\2SJ\3\2\2\2SO\3\2\2\2T]\3\2\2\2UV\f\5\2\2V\\") buf.write("\5\22\n\2WX\f\4\2\2X\\\5\24\13\2YZ\f\3\2\2Z\\\5\26\f\2") buf.write("[U\3\2\2\2[W\3\2\2\2[Y\3\2\2\2\\_\3\2\2\2][\3\2\2\2]^") buf.write("\3\2\2\2^\13\3\2\2\2_]\3\2\2\2`a\b\7\1\2ab\5\16\b\2bh") buf.write("\3\2\2\2cd\f\4\2\2de\7\r\2\2eg\5\f\7\5fc\3\2\2\2gj\3\2") buf.write("\2\2hf\3\2\2\2hi\3\2\2\2i\r\3\2\2\2jh\3\2\2\2kl\b\b\1") buf.write("\2lm\5\20\t\2ms\3\2\2\2no\f\4\2\2op\7\f\2\2pr\5\16\b\5") buf.write("qn\3\2\2\2ru\3\2\2\2sq\3\2\2\2st\3\2\2\2t\17\3\2\2\2u") buf.write("s\3\2\2\2vx\5\30\r\2wy\7\16\2\2xw\3\2\2\2xy\3\2\2\2yz") buf.write("\3\2\2\2z{\t\2\2\2{|\5\"\22\2|\u00ae\3\2\2\2}\177\5\30") buf.write("\r\2~\u0080\7\16\2\2\177~\3\2\2\2\177\u0080\3\2\2\2\u0080") buf.write("\u0081\3\2\2\2\u0081\u0082\t\3\2\2\u0082\u0083\5$\23\2") buf.write("\u0083\u00ae\3\2\2\2\u0084\u0086\5\30\r\2\u0085\u0087") buf.write("\7\16\2\2\u0086\u0085\3\2\2\2\u0086\u0087\3\2\2\2\u0087") buf.write("\u0088\3\2\2\2\u0088\u0089\7\26\2\2\u0089\u008a\5 \21") buf.write("\2\u008a\u00ae\3\2\2\2\u008b\u008d\5\30\r\2\u008c\u008e") buf.write("\7\16\2\2\u008d\u008c\3\2\2\2\u008d\u008e\3\2\2\2\u008e") buf.write("\u008f\3\2\2\2\u008f\u0090\7\20\2\2\u0090\u0091\7\t\2") buf.write("\2\u0091\u00ae\3\2\2\2\u0092\u0094\5\30\r\2\u0093\u0095") buf.write("\7\16\2\2\u0094\u0093\3\2\2\2\u0094\u0095\3\2\2\2\u0095") buf.write("\u0096\3\2\2\2\u0096\u0097\7\21\2\2\u0097\u0098\7\t\2") buf.write("\2\u0098\u00ae\3\2\2\2\u0099\u009b\5\30\r\2\u009a\u009c") buf.write("\7\16\2\2\u009b\u009a\3\2\2\2\u009b\u009c\3\2\2\2\u009c") buf.write("\u009d\3\2\2\2\u009d\u009e\7\23\2\2\u009e\u009f\7\t\2") buf.write("\2\u009f\u00ae\3\2\2\2\u00a0\u00a2\5\30\r\2\u00a1\u00a3") buf.write("\7\16\2\2\u00a2\u00a1\3\2\2\2\u00a2\u00a3\3\2\2\2\u00a3") buf.write("\u00a4\3\2\2\2\u00a4\u00a5\7\22\2\2\u00a5\u00a6\7\t\2") buf.write("\2\u00a6\u00ae\3\2\2\2\u00a7\u00a8\7,\2\2\u00a8\u00a9") buf.write("\5\f\7\2\u00a9\u00aa\7+\2\2\u00aa\u00ae\3\2\2\2\u00ab") buf.write("\u00ac\7\24\2\2\u00ac\u00ae\5\30\r\2\u00adv\3\2\2\2\u00ad") buf.write("}\3\2\2\2\u00ad\u0084\3\2\2\2\u00ad\u008b\3\2\2\2\u00ad") buf.write("\u0092\3\2\2\2\u00ad\u0099\3\2\2\2\u00ad\u00a0\3\2\2\2") buf.write("\u00ad\u00a7\3\2\2\2\u00ad\u00ab\3\2\2\2\u00ae\21\3\2") buf.write("\2\2\u00af\u00b0\7\27\2\2\u00b0\u00b1\7\13\2\2\u00b1\u00b2") buf.write("\7\30\2\2\u00b2\u00b3\7\13\2\2\u00b3\23\3\2\2\2\u00b4") buf.write("\u00b5\7\34\2\2\u00b5\u00b6\t\4\2\2\u00b6\u00b7\7\31\2") buf.write("\2\u00b7\25\3\2\2\2\u00b8\u00b9\7\35\2\2\u00b9\u00ba\7") buf.write("\4\2\2\u00ba\u00bb\7\36\2\2\u00bb\27\3\2\2\2\u00bc\u00bd") buf.write("\5\32\16\2\u00bd\u00be\7(\2\2\u00be\u00c0\5\34\17\2\u00bf") buf.write("\u00c1\5\36\20\2\u00c0\u00bf\3\2\2\2\u00c0\u00c1\3\2\2") buf.write("\2\u00c1\31\3\2\2\2\u00c2\u00c3\t\5\2\2\u00c3\33\3\2\2") buf.write("\2\u00c4\u00c5\t\6\2\2\u00c5\35\3\2\2\2\u00c6\u00c7\b") buf.write("\20\1\2\u00c7\u00c8\7)\2\2\u00c8\u00cd\t\6\2\2\u00c9\u00ca") buf.write("\7.\2\2\u00ca\u00cb\t\7\2\2\u00cb\u00cd\7-\2\2\u00cc\u00c6") buf.write("\3\2\2\2\u00cc\u00c9\3\2\2\2\u00cd\u00d2\3\2\2\2\u00ce") buf.write("\u00cf\f\5\2\2\u00cf\u00d1\5\36\20\6\u00d0\u00ce\3\2\2") buf.write("\2\u00d1\u00d4\3\2\2\2\u00d2\u00d0\3\2\2\2\u00d2\u00d3") buf.write("\3\2\2\2\u00d3\37\3\2\2\2\u00d4\u00d2\3\2\2\2\u00d5\u00d6") buf.write("\7,\2\2\u00d6\u00e3\7+\2\2\u00d7\u00d8\7,\2\2\u00d8\u00dd") buf.write("\5\"\22\2\u00d9\u00da\7*\2\2\u00da\u00dc\5\"\22\2\u00db") buf.write("\u00d9\3\2\2\2\u00dc\u00df\3\2\2\2\u00dd\u00db\3\2\2\2") buf.write("\u00dd\u00de\3\2\2\2\u00de\u00e0\3\2\2\2\u00df\u00dd\3") buf.write("\2\2\2\u00e0\u00e1\7+\2\2\u00e1\u00e3\3\2\2\2\u00e2\u00d5") buf.write("\3\2\2\2\u00e2\u00d7\3\2\2\2\u00e3!\3\2\2\2\u00e4\u00e7") buf.write("\5$\23\2\u00e5\u00e7\7\n\2\2\u00e6\u00e4\3\2\2\2\u00e6") buf.write("\u00e5\3\2\2\2\u00e7#\3\2\2\2\u00e8\u00e9\t\b\2\2\u00e9") buf.write("%\3\2\2\2\30\61", "", "", "", "", "", "", "", "", "", "'AND'", "'OR'", "'NOT'", "'FOLLOWEDBY'", "'LIKE'", "'MATCHES'", "'ISSUPERSET'", "'ISSUBSET'", "'EXISTS'", "'LAST'", "'IN'", "'START'", "'STOP'", "'SECONDS'", "'true'", "'false'", "'WITHIN'", "'REPEATS'", "'TIMES'", "", "", "", "", "'<'", "'<='", "'>'", "'>='", "'''", "':'", "'.'", "','", "')'", "'('", "']'", "'['", "'+'", "", "'-'", "'^'", "'/'", "'*'" ] symbolicNames = [ "", "IntNegLiteral", "IntPosLiteral", "FloatNegLiteral", "FloatPosLiteral", "HexLiteral", "BinaryLiteral", "StringLiteral", "BoolLiteral", "TimestampLiteral", "AND", "OR", "NOT", "FOLLOWEDBY", "LIKE", "MATCHES", "ISSUPERSET", "ISSUBSET", "EXISTS", "LAST", "IN", "START", "STOP", "SECONDS", "TRUE", "FALSE", "WITHIN", "REPEATS", "TIMES", "IdentifierWithoutHyphen", "IdentifierWithHyphen", "EQ", "NEQ", "LT", "LE", "GT", "GE", "QUOTE", "COLON", "DOT", "COMMA", "RPAREN", "LPAREN", "RBRACK", "LBRACK", "PLUS", "HYPHEN", "MINUS", "POWER_OP", "DIVIDE", "ASTERISK", "WS", "COMMENT", "LINE_COMMENT", "InvalidCharacter" ] RULE_pattern = 0 RULE_observationExpressions = 1 RULE_observationExpressionOr = 2 RULE_observationExpressionAnd = 3 RULE_observationExpression = 4 RULE_comparisonExpression = 5 RULE_comparisonExpressionAnd = 6 RULE_propTest = 7 RULE_startStopQualifier = 8 RULE_withinQualifier = 9 RULE_repeatedQualifier = 10 RULE_objectPath = 11 RULE_objectType = 12 RULE_firstPathComponent = 13 RULE_objectPathComponent = 14 RULE_setLiteral = 15 RULE_primitiveLiteral = 16 RULE_orderableLiteral = 17 ruleNames = [ "pattern", "observationExpressions", "observationExpressionOr", "observationExpressionAnd", "observationExpression", "comparisonExpression", "comparisonExpressionAnd", "propTest", "startStopQualifier", "withinQualifier", "repeatedQualifier", "objectPath", "objectType", "firstPathComponent", "objectPathComponent", "setLiteral", "primitiveLiteral", "orderableLiteral" ] EOF = Token.EOF IntNegLiteral=1 IntPosLiteral=2 FloatNegLiteral=3 FloatPosLiteral=4 HexLiteral=5 BinaryLiteral=6 StringLiteral=7 BoolLiteral=8 TimestampLiteral=9 AND=10 OR=11 NOT=12 FOLLOWEDBY=13 LIKE=14 MATCHES=15 ISSUPERSET=16 ISSUBSET=17 EXISTS=18 LAST=19 IN=20 START=21 STOP=22 SECONDS=23 TRUE=24 FALSE=25 WITHIN=26 REPEATS=27 TIMES=28 IdentifierWithoutHyphen=29 IdentifierWithHyphen=30 EQ=31 NEQ=32 LT=33 LE=34 GT=35 GE=36 QUOTE=37 COLON=38 DOT=39 COMMA=40 RPAREN=41 LPAREN=42 RBRACK=43 LBRACK=44 PLUS=45 HYPHEN=46 MINUS=47 POWER_OP=48 DIVIDE=49 ASTERISK=50 WS=51 COMMENT=52 LINE_COMMENT=53 InvalidCharacter=54 def __init__(self, input:TokenStream, output:TextIO = sys.stdout): super().__init__(input, output) self.checkVersion("4.9.2") self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache) self._predicates = None class PatternContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def observationExpressions(self): return self.getTypedRuleContext(STIXPatternParser.ObservationExpressionsContext,0) def EOF(self): return self.getToken(STIXPatternParser.EOF, 0) def getRuleIndex(self): return STIXPatternParser.RULE_pattern def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterPattern" ): listener.enterPattern(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitPattern" ): listener.exitPattern(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitPattern" ): return visitor.visitPattern(self) else: return visitor.visitChildren(self) def pattern(self): localctx = STIXPatternParser.PatternContext(self, self._ctx, self.state) self.enterRule(localctx, 0, self.RULE_pattern) try: self.enterOuterAlt(localctx, 1) self.state = 36 self.observationExpressions(0) self.state = 37 self.match(STIXPatternParser.EOF) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class ObservationExpressionsContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def observationExpressionOr(self): return self.getTypedRuleContext(STIXPatternParser.ObservationExpressionOrContext,0) def observationExpressions(self, i:int=None): if i is None: return self.getTypedRuleContexts(STIXPatternParser.ObservationExpressionsContext) else: return self.getTypedRuleContext(STIXPatternParser.ObservationExpressionsContext,i) def FOLLOWEDBY(self): return self.getToken(STIXPatternParser.FOLLOWEDBY, 0) def getRuleIndex(self): return STIXPatternParser.RULE_observationExpressions def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterObservationExpressions" ): listener.enterObservationExpressions(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitObservationExpressions" ): listener.exitObservationExpressions(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitObservationExpressions" ): return visitor.visitObservationExpressions(self) else: return visitor.visitChildren(self) def observationExpressions(self, _p:int=0): _parentctx = self._ctx _parentState = self.state localctx = STIXPatternParser.ObservationExpressionsContext(self, self._ctx, _parentState) _prevctx = localctx _startState = 2 self.enterRecursionRule(localctx, 2, self.RULE_observationExpressions, _p) try: self.enterOuterAlt(localctx, 1) self.state = 40 self.observationExpressionOr(0) self._ctx.stop = self._input.LT(-1) self.state = 47 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,0,self._ctx) while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: if _alt==1: if self._parseListeners is not None: self.triggerExitRuleEvent() _prevctx = localctx localctx = STIXPatternParser.ObservationExpressionsContext(self, _parentctx, _parentState) self.pushNewRecursionContext(localctx, _startState, self.RULE_observationExpressions) self.state = 42 if not self.precpred(self._ctx, 2): from antlr4.error.Errors import FailedPredicateException raise FailedPredicateException(self, "self.precpred(self._ctx, 2)") self.state = 43 self.match(STIXPatternParser.FOLLOWEDBY) self.state = 44 self.observationExpressions(3) self.state = 49 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,0,self._ctx) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.unrollRecursionContexts(_parentctx) return localctx class ObservationExpressionOrContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def observationExpressionAnd(self): return self.getTypedRuleContext(STIXPatternParser.ObservationExpressionAndContext,0) def observationExpressionOr(self, i:int=None): if i is None: return self.getTypedRuleContexts(STIXPatternParser.ObservationExpressionOrContext) else: return self.getTypedRuleContext(STIXPatternParser.ObservationExpressionOrContext,i) def OR(self): return self.getToken(STIXPatternParser.OR, 0) def getRuleIndex(self): return STIXPatternParser.RULE_observationExpressionOr def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterObservationExpressionOr" ): listener.enterObservationExpressionOr(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitObservationExpressionOr" ): listener.exitObservationExpressionOr(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitObservationExpressionOr" ): return visitor.visitObservationExpressionOr(self) else: return visitor.visitChildren(self) def observationExpressionOr(self, _p:int=0): _parentctx = self._ctx _parentState = self.state localctx = STIXPatternParser.ObservationExpressionOrContext(self, self._ctx, _parentState) _prevctx = localctx _startState = 4 self.enterRecursionRule(localctx, 4, self.RULE_observationExpressionOr, _p) try: self.enterOuterAlt(localctx, 1) self.state = 51 self.observationExpressionAnd(0) self._ctx.stop = self._input.LT(-1) self.state = 58 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,1,self._ctx) while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: if _alt==1: if self._parseListeners is not None: self.triggerExitRuleEvent() _prevctx = localctx localctx = STIXPatternParser.ObservationExpressionOrContext(self, _parentctx, _parentState) self.pushNewRecursionContext(localctx, _startState, self.RULE_observationExpressionOr) self.state = 53 if not self.precpred(self._ctx, 2): from antlr4.error.Errors import FailedPredicateException raise FailedPredicateException(self, "self.precpred(self._ctx, 2)") self.state = 54 self.match(STIXPatternParser.OR) self.state = 55 self.observationExpressionOr(3) self.state = 60 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,1,self._ctx) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.unrollRecursionContexts(_parentctx) return localctx class ObservationExpressionAndContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def observationExpression(self): return self.getTypedRuleContext(STIXPatternParser.ObservationExpressionContext,0) def observationExpressionAnd(self, i:int=None): if i is None: return self.getTypedRuleContexts(STIXPatternParser.ObservationExpressionAndContext) else: return self.getTypedRuleContext(STIXPatternParser.ObservationExpressionAndContext,i) def AND(self): return self.getToken(STIXPatternParser.AND, 0) def getRuleIndex(self): return STIXPatternParser.RULE_observationExpressionAnd def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterObservationExpressionAnd" ): listener.enterObservationExpressionAnd(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitObservationExpressionAnd" ): listener.exitObservationExpressionAnd(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitObservationExpressionAnd" ): return visitor.visitObservationExpressionAnd(self) else: return visitor.visitChildren(self) def observationExpressionAnd(self, _p:int=0): _parentctx = self._ctx _parentState = self.state localctx = STIXPatternParser.ObservationExpressionAndContext(self, self._ctx, _parentState) _prevctx = localctx _startState = 6 self.enterRecursionRule(localctx, 6, self.RULE_observationExpressionAnd, _p) try: self.enterOuterAlt(localctx, 1) self.state = 62 self.observationExpression(0) self._ctx.stop = self._input.LT(-1) self.state = 69 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,2,self._ctx) while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: if _alt==1: if self._parseListeners is not None: self.triggerExitRuleEvent() _prevctx = localctx localctx = STIXPatternParser.ObservationExpressionAndContext(self, _parentctx, _parentState) self.pushNewRecursionContext(localctx, _startState, self.RULE_observationExpressionAnd) self.state = 64 if not self.precpred(self._ctx, 2): from antlr4.error.Errors import FailedPredicateException raise FailedPredicateException(self, "self.precpred(self._ctx, 2)") self.state = 65 self.match(STIXPatternParser.AND) self.state = 66 self.observationExpressionAnd(3) self.state = 71 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,2,self._ctx) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.unrollRecursionContexts(_parentctx) return localctx class ObservationExpressionContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def getRuleIndex(self): return STIXPatternParser.RULE_observationExpression def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) class ObservationExpressionRepeatedContext(ObservationExpressionContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a STIXPatternParser.ObservationExpressionContext super().__init__(parser) self.copyFrom(ctx) def observationExpression(self): return self.getTypedRuleContext(STIXPatternParser.ObservationExpressionContext,0) def repeatedQualifier(self): return self.getTypedRuleContext(STIXPatternParser.RepeatedQualifierContext,0) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterObservationExpressionRepeated" ): listener.enterObservationExpressionRepeated(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitObservationExpressionRepeated" ): listener.exitObservationExpressionRepeated(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitObservationExpressionRepeated" ): return visitor.visitObservationExpressionRepeated(self) else: return visitor.visitChildren(self) class ObservationExpressionSimpleContext(ObservationExpressionContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a STIXPatternParser.ObservationExpressionContext super().__init__(parser) self.copyFrom(ctx) def LBRACK(self): return self.getToken(STIXPatternParser.LBRACK, 0) def comparisonExpression(self): return self.getTypedRuleContext(STIXPatternParser.ComparisonExpressionContext,0) def RBRACK(self): return self.getToken(STIXPatternParser.RBRACK, 0) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterObservationExpressionSimple" ): listener.enterObservationExpressionSimple(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitObservationExpressionSimple" ): listener.exitObservationExpressionSimple(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitObservationExpressionSimple" ): return visitor.visitObservationExpressionSimple(self) else: return visitor.visitChildren(self) class ObservationExpressionCompoundContext(ObservationExpressionContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a STIXPatternParser.ObservationExpressionContext super().__init__(parser) self.copyFrom(ctx) def LPAREN(self): return self.getToken(STIXPatternParser.LPAREN, 0) def observationExpressions(self): return self.getTypedRuleContext(STIXPatternParser.ObservationExpressionsContext,0) def RPAREN(self): return self.getToken(STIXPatternParser.RPAREN, 0) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterObservationExpressionCompound" ): listener.enterObservationExpressionCompound(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitObservationExpressionCompound" ): listener.exitObservationExpressionCompound(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitObservationExpressionCompound" ): return visitor.visitObservationExpressionCompound(self) else: return visitor.visitChildren(self) class ObservationExpressionWithinContext(ObservationExpressionContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a STIXPatternParser.ObservationExpressionContext super().__init__(parser) self.copyFrom(ctx) def observationExpression(self): return self.getTypedRuleContext(STIXPatternParser.ObservationExpressionContext,0) def withinQualifier(self): return self.getTypedRuleContext(STIXPatternParser.WithinQualifierContext,0) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterObservationExpressionWithin" ): listener.enterObservationExpressionWithin(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitObservationExpressionWithin" ): listener.exitObservationExpressionWithin(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitObservationExpressionWithin" ): return visitor.visitObservationExpressionWithin(self) else: return visitor.visitChildren(self) class ObservationExpressionStartStopContext(ObservationExpressionContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a STIXPatternParser.ObservationExpressionContext super().__init__(parser) self.copyFrom(ctx) def observationExpression(self): return self.getTypedRuleContext(STIXPatternParser.ObservationExpressionContext,0) def startStopQualifier(self): return self.getTypedRuleContext(STIXPatternParser.StartStopQualifierContext,0) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterObservationExpressionStartStop" ): listener.enterObservationExpressionStartStop(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitObservationExpressionStartStop" ): listener.exitObservationExpressionStartStop(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitObservationExpressionStartStop" ): return visitor.visitObservationExpressionStartStop(self) else: return visitor.visitChildren(self) def observationExpression(self, _p:int=0): _parentctx = self._ctx _parentState = self.state localctx = STIXPatternParser.ObservationExpressionContext(self, self._ctx, _parentState) _prevctx = localctx _startState = 8 self.enterRecursionRule(localctx, 8, self.RULE_observationExpression, _p) try: self.enterOuterAlt(localctx, 1) self.state = 81 self._errHandler.sync(self) token = self._input.LA(1) if token in [STIXPatternParser.LBRACK]: localctx = STIXPatternParser.ObservationExpressionSimpleContext(self, localctx) self._ctx = localctx _prevctx = localctx self.state = 73 self.match(STIXPatternParser.LBRACK) self.state = 74 self.comparisonExpression(0) self.state = 75 self.match(STIXPatternParser.RBRACK) pass elif token in [STIXPatternParser.LPAREN]: localctx = STIXPatternParser.ObservationExpressionCompoundContext(self, localctx) self._ctx = localctx _prevctx = localctx self.state = 77 self.match(STIXPatternParser.LPAREN) self.state = 78 self.observationExpressions(0) self.state = 79 self.match(STIXPatternParser.RPAREN) pass else: raise NoViableAltException(self) self._ctx.stop = self._input.LT(-1) self.state = 91 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,5,self._ctx) while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: if _alt==1: if self._parseListeners is not None: self.triggerExitRuleEvent() _prevctx = localctx self.state = 89 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,4,self._ctx) if la_ == 1: localctx = STIXPatternParser.ObservationExpressionStartStopContext(self, STIXPatternParser.ObservationExpressionContext(self, _parentctx, _parentState)) self.pushNewRecursionContext(localctx, _startState, self.RULE_observationExpression) self.state = 83 if not self.precpred(self._ctx, 3): from antlr4.error.Errors import FailedPredicateException raise FailedPredicateException(self, "self.precpred(self._ctx, 3)") self.state = 84 self.startStopQualifier() pass elif la_ == 2: localctx = STIXPatternParser.ObservationExpressionWithinContext(self, STIXPatternParser.ObservationExpressionContext(self, _parentctx, _parentState)) self.pushNewRecursionContext(localctx, _startState, self.RULE_observationExpression) self.state = 85 if not self.precpred(self._ctx, 2): from antlr4.error.Errors import FailedPredicateException raise FailedPredicateException(self, "self.precpred(self._ctx, 2)") self.state = 86 self.withinQualifier() pass elif la_ == 3: localctx = STIXPatternParser.ObservationExpressionRepeatedContext(self, STIXPatternParser.ObservationExpressionContext(self, _parentctx, _parentState)) self.pushNewRecursionContext(localctx, _startState, self.RULE_observationExpression) self.state = 87 if not self.precpred(self._ctx, 1): from antlr4.error.Errors import FailedPredicateException raise FailedPredicateException(self, "self.precpred(self._ctx, 1)") self.state = 88 self.repeatedQualifier() pass self.state = 93 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,5,self._ctx) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.unrollRecursionContexts(_parentctx) return localctx class ComparisonExpressionContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def comparisonExpressionAnd(self): return self.getTypedRuleContext(STIXPatternParser.ComparisonExpressionAndContext,0) def comparisonExpression(self, i:int=None): if i is None: return self.getTypedRuleContexts(STIXPatternParser.ComparisonExpressionContext) else: return self.getTypedRuleContext(STIXPatternParser.ComparisonExpressionContext,i) def OR(self): return self.getToken(STIXPatternParser.OR, 0) def getRuleIndex(self): return STIXPatternParser.RULE_comparisonExpression def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterComparisonExpression" ): listener.enterComparisonExpression(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitComparisonExpression" ): listener.exitComparisonExpression(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitComparisonExpression" ): return visitor.visitComparisonExpression(self) else: return visitor.visitChildren(self) def comparisonExpression(self, _p:int=0): _parentctx = self._ctx _parentState = self.state localctx = STIXPatternParser.ComparisonExpressionContext(self, self._ctx, _parentState) _prevctx = localctx _startState = 10 self.enterRecursionRule(localctx, 10, self.RULE_comparisonExpression, _p) try: self.enterOuterAlt(localctx, 1) self.state = 95 self.comparisonExpressionAnd(0) self._ctx.stop = self._input.LT(-1) self.state = 102 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,6,self._ctx) while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: if _alt==1: if self._parseListeners is not None: self.triggerExitRuleEvent() _prevctx = localctx localctx = STIXPatternParser.ComparisonExpressionContext(self, _parentctx, _parentState) self.pushNewRecursionContext(localctx, _startState, self.RULE_comparisonExpression) self.state = 97 if not self.precpred(self._ctx, 2): from antlr4.error.Errors import FailedPredicateException raise FailedPredicateException(self, "self.precpred(self._ctx, 2)") self.state = 98 self.match(STIXPatternParser.OR) self.state = 99 self.comparisonExpression(3) self.state = 104 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,6,self._ctx) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.unrollRecursionContexts(_parentctx) return localctx class ComparisonExpressionAndContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def propTest(self): return self.getTypedRuleContext(STIXPatternParser.PropTestContext,0) def comparisonExpressionAnd(self, i:int=None): if i is None: return self.getTypedRuleContexts(STIXPatternParser.ComparisonExpressionAndContext) else: return self.getTypedRuleContext(STIXPatternParser.ComparisonExpressionAndContext,i) def AND(self): return self.getToken(STIXPatternParser.AND, 0) def getRuleIndex(self): return STIXPatternParser.RULE_comparisonExpressionAnd def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterComparisonExpressionAnd" ): listener.enterComparisonExpressionAnd(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitComparisonExpressionAnd" ): listener.exitComparisonExpressionAnd(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitComparisonExpressionAnd" ): return visitor.visitComparisonExpressionAnd(self) else: return visitor.visitChildren(self) def comparisonExpressionAnd(self, _p:int=0): _parentctx = self._ctx _parentState = self.state localctx = STIXPatternParser.ComparisonExpressionAndContext(self, self._ctx, _parentState) _prevctx = localctx _startState = 12 self.enterRecursionRule(localctx, 12, self.RULE_comparisonExpressionAnd, _p) try: self.enterOuterAlt(localctx, 1) self.state = 106 self.propTest() self._ctx.stop = self._input.LT(-1) self.state = 113 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,7,self._ctx) while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: if _alt==1: if self._parseListeners is not None: self.triggerExitRuleEvent() _prevctx = localctx localctx = STIXPatternParser.ComparisonExpressionAndContext(self, _parentctx, _parentState) self.pushNewRecursionContext(localctx, _startState, self.RULE_comparisonExpressionAnd) self.state = 108 if not self.precpred(self._ctx, 2): from antlr4.error.Errors import FailedPredicateException raise FailedPredicateException(self, "self.precpred(self._ctx, 2)") self.state = 109 self.match(STIXPatternParser.AND) self.state = 110 self.comparisonExpressionAnd(3) self.state = 115 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,7,self._ctx) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.unrollRecursionContexts(_parentctx) return localctx class PropTestContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def getRuleIndex(self): return STIXPatternParser.RULE_propTest def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) class PropTestExistsContext(PropTestContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a STIXPatternParser.PropTestContext super().__init__(parser) self.copyFrom(ctx) def EXISTS(self): return self.getToken(STIXPatternParser.EXISTS, 0) def objectPath(self): return self.getTypedRuleContext(STIXPatternParser.ObjectPathContext,0) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterPropTestExists" ): listener.enterPropTestExists(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitPropTestExists" ): listener.exitPropTestExists(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitPropTestExists" ): return visitor.visitPropTestExists(self) else: return visitor.visitChildren(self) class PropTestRegexContext(PropTestContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a STIXPatternParser.PropTestContext super().__init__(parser) self.copyFrom(ctx) def objectPath(self): return self.getTypedRuleContext(STIXPatternParser.ObjectPathContext,0) def MATCHES(self): return self.getToken(STIXPatternParser.MATCHES, 0) def StringLiteral(self): return self.getToken(STIXPatternParser.StringLiteral, 0) def NOT(self): return self.getToken(STIXPatternParser.NOT, 0) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterPropTestRegex" ): listener.enterPropTestRegex(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitPropTestRegex" ): listener.exitPropTestRegex(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitPropTestRegex" ): return visitor.visitPropTestRegex(self) else: return visitor.visitChildren(self) class PropTestOrderContext(PropTestContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a STIXPatternParser.PropTestContext super().__init__(parser) self.copyFrom(ctx) def objectPath(self): return self.getTypedRuleContext(STIXPatternParser.ObjectPathContext,0) def orderableLiteral(self): return self.getTypedRuleContext(STIXPatternParser.OrderableLiteralContext,0) def GT(self): return self.getToken(STIXPatternParser.GT, 0) def LT(self): return self.getToken(STIXPatternParser.LT, 0) def GE(self): return self.getToken(STIXPatternParser.GE, 0) def LE(self): return self.getToken(STIXPatternParser.LE, 0) def NOT(self): return self.getToken(STIXPatternParser.NOT, 0) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterPropTestOrder" ): listener.enterPropTestOrder(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitPropTestOrder" ): listener.exitPropTestOrder(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitPropTestOrder" ): return visitor.visitPropTestOrder(self) else: return visitor.visitChildren(self) class PropTestLikeContext(PropTestContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a STIXPatternParser.PropTestContext super().__init__(parser) self.copyFrom(ctx) def objectPath(self): return self.getTypedRuleContext(STIXPatternParser.ObjectPathContext,0) def LIKE(self): return self.getToken(STIXPatternParser.LIKE, 0) def StringLiteral(self): return self.getToken(STIXPatternParser.StringLiteral, 0) def NOT(self): return self.getToken(STIXPatternParser.NOT, 0) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterPropTestLike" ): listener.enterPropTestLike(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitPropTestLike" ): listener.exitPropTestLike(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitPropTestLike" ): return visitor.visitPropTestLike(self) else: return visitor.visitChildren(self) class PropTestEqualContext(PropTestContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a STIXPatternParser.PropTestContext super().__init__(parser) self.copyFrom(ctx) def objectPath(self): return self.getTypedRuleContext(STIXPatternParser.ObjectPathContext,0) def primitiveLiteral(self): return self.getTypedRuleContext(STIXPatternParser.PrimitiveLiteralContext,0) def EQ(self): return self.getToken(STIXPatternParser.EQ, 0) def NEQ(self): return self.getToken(STIXPatternParser.NEQ, 0) def NOT(self): return self.getToken(STIXPatternParser.NOT, 0) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterPropTestEqual" ): listener.enterPropTestEqual(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitPropTestEqual" ): listener.exitPropTestEqual(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitPropTestEqual" ): return visitor.visitPropTestEqual(self) else: return visitor.visitChildren(self) class PropTestSetContext(PropTestContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a STIXPatternParser.PropTestContext super().__init__(parser) self.copyFrom(ctx) def objectPath(self): return self.getTypedRuleContext(STIXPatternParser.ObjectPathContext,0) def IN(self): return self.getToken(STIXPatternParser.IN, 0) def setLiteral(self): return self.getTypedRuleContext(STIXPatternParser.SetLiteralContext,0) def NOT(self): return self.getToken(STIXPatternParser.NOT, 0) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterPropTestSet" ): listener.enterPropTestSet(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitPropTestSet" ): listener.exitPropTestSet(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitPropTestSet" ): return visitor.visitPropTestSet(self) else: return visitor.visitChildren(self) class PropTestIsSubsetContext(PropTestContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a STIXPatternParser.PropTestContext super().__init__(parser) self.copyFrom(ctx) def objectPath(self): return self.getTypedRuleContext(STIXPatternParser.ObjectPathContext,0) def ISSUBSET(self): return self.getToken(STIXPatternParser.ISSUBSET, 0) def StringLiteral(self): return self.getToken(STIXPatternParser.StringLiteral, 0) def NOT(self): return self.getToken(STIXPatternParser.NOT, 0) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterPropTestIsSubset" ): listener.enterPropTestIsSubset(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitPropTestIsSubset" ): listener.exitPropTestIsSubset(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitPropTestIsSubset" ): return visitor.visitPropTestIsSubset(self) else: return visitor.visitChildren(self) class PropTestParenContext(PropTestContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a STIXPatternParser.PropTestContext super().__init__(parser) self.copyFrom(ctx) def LPAREN(self): return self.getToken(STIXPatternParser.LPAREN, 0) def comparisonExpression(self): return self.getTypedRuleContext(STIXPatternParser.ComparisonExpressionContext,0) def RPAREN(self): return self.getToken(STIXPatternParser.RPAREN, 0) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterPropTestParen" ): listener.enterPropTestParen(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitPropTestParen" ): listener.exitPropTestParen(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitPropTestParen" ): return visitor.visitPropTestParen(self) else: return visitor.visitChildren(self) class PropTestIsSupersetContext(PropTestContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a STIXPatternParser.PropTestContext super().__init__(parser) self.copyFrom(ctx) def objectPath(self): return self.getTypedRuleContext(STIXPatternParser.ObjectPathContext,0) def ISSUPERSET(self): return self.getToken(STIXPatternParser.ISSUPERSET, 0) def StringLiteral(self): return self.getToken(STIXPatternParser.StringLiteral, 0) def NOT(self): return self.getToken(STIXPatternParser.NOT, 0) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterPropTestIsSuperset" ): listener.enterPropTestIsSuperset(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitPropTestIsSuperset" ): listener.exitPropTestIsSuperset(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitPropTestIsSuperset" ): return visitor.visitPropTestIsSuperset(self) else: return visitor.visitChildren(self) def propTest(self): localctx = STIXPatternParser.PropTestContext(self, self._ctx, self.state) self.enterRule(localctx, 14, self.RULE_propTest) self._la = 0 # Token type try: self.state = 171 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,15,self._ctx) if la_ == 1: localctx = STIXPatternParser.PropTestEqualContext(self, localctx) self.enterOuterAlt(localctx, 1) self.state = 116 self.objectPath() self.state = 118 self._errHandler.sync(self) _la = self._input.LA(1) if _la==STIXPatternParser.NOT: self.state = 117 self.match(STIXPatternParser.NOT) self.state = 120 _la = self._input.LA(1) if not(_la==STIXPatternParser.EQ or _la==STIXPatternParser.NEQ): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() self.state = 121 self.primitiveLiteral() pass elif la_ == 2: localctx = STIXPatternParser.PropTestOrderContext(self, localctx) self.enterOuterAlt(localctx, 2) self.state = 123 self.objectPath() self.state = 125 self._errHandler.sync(self) _la = self._input.LA(1) if _la==STIXPatternParser.NOT: self.state = 124 self.match(STIXPatternParser.NOT) self.state = 127 _la = self._input.LA(1) if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << STIXPatternParser.LT) | (1 << STIXPatternParser.LE) | (1 << STIXPatternParser.GT) | (1 << STIXPatternParser.GE))) != 0)): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() self.state = 128 self.orderableLiteral() pass elif la_ == 3: localctx = STIXPatternParser.PropTestSetContext(self, localctx) self.enterOuterAlt(localctx, 3) self.state = 130 self.objectPath() self.state = 132 self._errHandler.sync(self) _la = self._input.LA(1) if _la==STIXPatternParser.NOT: self.state = 131 self.match(STIXPatternParser.NOT) self.state = 134 self.match(STIXPatternParser.IN) self.state = 135 self.setLiteral() pass elif la_ == 4: localctx = STIXPatternParser.PropTestLikeContext(self, localctx) self.enterOuterAlt(localctx, 4) self.state = 137 self.objectPath() self.state = 139 self._errHandler.sync(self) _la = self._input.LA(1) if _la==STIXPatternParser.NOT: self.state = 138 self.match(STIXPatternParser.NOT) self.state = 141 self.match(STIXPatternParser.LIKE) self.state = 142 self.match(STIXPatternParser.StringLiteral) pass elif la_ == 5: localctx = STIXPatternParser.PropTestRegexContext(self, localctx) self.enterOuterAlt(localctx, 5) self.state = 144 self.objectPath() self.state = 146 self._errHandler.sync(self) _la = self._input.LA(1) if _la==STIXPatternParser.NOT: self.state = 145 self.match(STIXPatternParser.NOT) self.state = 148 self.match(STIXPatternParser.MATCHES) self.state = 149 self.match(STIXPatternParser.StringLiteral) pass elif la_ == 6: localctx = STIXPatternParser.PropTestIsSubsetContext(self, localctx) self.enterOuterAlt(localctx, 6) self.state = 151 self.objectPath() self.state = 153 self._errHandler.sync(self) _la = self._input.LA(1) if _la==STIXPatternParser.NOT: self.state = 152 self.match(STIXPatternParser.NOT) self.state = 155 self.match(STIXPatternParser.ISSUBSET) self.state = 156 self.match(STIXPatternParser.StringLiteral) pass elif la_ == 7: localctx = STIXPatternParser.PropTestIsSupersetContext(self, localctx) self.enterOuterAlt(localctx, 7) self.state = 158 self.objectPath() self.state = 160 self._errHandler.sync(self) _la = self._input.LA(1) if _la==STIXPatternParser.NOT: self.state = 159 self.match(STIXPatternParser.NOT) self.state = 162 self.match(STIXPatternParser.ISSUPERSET) self.state = 163 self.match(STIXPatternParser.StringLiteral) pass elif la_ == 8: localctx = STIXPatternParser.PropTestParenContext(self, localctx) self.enterOuterAlt(localctx, 8) self.state = 165 self.match(STIXPatternParser.LPAREN) self.state = 166 self.comparisonExpression(0) self.state = 167 self.match(STIXPatternParser.RPAREN) pass elif la_ == 9: localctx = STIXPatternParser.PropTestExistsContext(self, localctx) self.enterOuterAlt(localctx, 9) self.state = 169 self.match(STIXPatternParser.EXISTS) self.state = 170 self.objectPath() pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class StartStopQualifierContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def START(self): return self.getToken(STIXPatternParser.START, 0) def TimestampLiteral(self, i:int=None): if i is None: return self.getTokens(STIXPatternParser.TimestampLiteral) else: return self.getToken(STIXPatternParser.TimestampLiteral, i) def STOP(self): return self.getToken(STIXPatternParser.STOP, 0) def getRuleIndex(self): return STIXPatternParser.RULE_startStopQualifier def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterStartStopQualifier" ): listener.enterStartStopQualifier(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitStartStopQualifier" ): listener.exitStartStopQualifier(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitStartStopQualifier" ): return visitor.visitStartStopQualifier(self) else: return visitor.visitChildren(self) def startStopQualifier(self): localctx = STIXPatternParser.StartStopQualifierContext(self, self._ctx, self.state) self.enterRule(localctx, 16, self.RULE_startStopQualifier) try: self.enterOuterAlt(localctx, 1) self.state = 173 self.match(STIXPatternParser.START) self.state = 174 self.match(STIXPatternParser.TimestampLiteral) self.state = 175 self.match(STIXPatternParser.STOP) self.state = 176 self.match(STIXPatternParser.TimestampLiteral) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class WithinQualifierContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def WITHIN(self): return self.getToken(STIXPatternParser.WITHIN, 0) def SECONDS(self): return self.getToken(STIXPatternParser.SECONDS, 0) def IntPosLiteral(self): return self.getToken(STIXPatternParser.IntPosLiteral, 0) def FloatPosLiteral(self): return self.getToken(STIXPatternParser.FloatPosLiteral, 0) def getRuleIndex(self): return STIXPatternParser.RULE_withinQualifier def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterWithinQualifier" ): listener.enterWithinQualifier(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitWithinQualifier" ): listener.exitWithinQualifier(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitWithinQualifier" ): return visitor.visitWithinQualifier(self) else: return visitor.visitChildren(self) def withinQualifier(self): localctx = STIXPatternParser.WithinQualifierContext(self, self._ctx, self.state) self.enterRule(localctx, 18, self.RULE_withinQualifier) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 178 self.match(STIXPatternParser.WITHIN) self.state = 179 _la = self._input.LA(1) if not(_la==STIXPatternParser.IntPosLiteral or _la==STIXPatternParser.FloatPosLiteral): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() self.state = 180 self.match(STIXPatternParser.SECONDS) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class RepeatedQualifierContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def REPEATS(self): return self.getToken(STIXPatternParser.REPEATS, 0) def IntPosLiteral(self): return self.getToken(STIXPatternParser.IntPosLiteral, 0) def TIMES(self): return self.getToken(STIXPatternParser.TIMES, 0) def getRuleIndex(self): return STIXPatternParser.RULE_repeatedQualifier def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterRepeatedQualifier" ): listener.enterRepeatedQualifier(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitRepeatedQualifier" ): listener.exitRepeatedQualifier(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitRepeatedQualifier" ): return visitor.visitRepeatedQualifier(self) else: return visitor.visitChildren(self) def repeatedQualifier(self): localctx = STIXPatternParser.RepeatedQualifierContext(self, self._ctx, self.state) self.enterRule(localctx, 20, self.RULE_repeatedQualifier) try: self.enterOuterAlt(localctx, 1) self.state = 182 self.match(STIXPatternParser.REPEATS) self.state = 183 self.match(STIXPatternParser.IntPosLiteral) self.state = 184 self.match(STIXPatternParser.TIMES) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class ObjectPathContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def objectType(self): return self.getTypedRuleContext(STIXPatternParser.ObjectTypeContext,0) def COLON(self): return self.getToken(STIXPatternParser.COLON, 0) def firstPathComponent(self): return self.getTypedRuleContext(STIXPatternParser.FirstPathComponentContext,0) def objectPathComponent(self): return self.getTypedRuleContext(STIXPatternParser.ObjectPathComponentContext,0) def getRuleIndex(self): return STIXPatternParser.RULE_objectPath def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterObjectPath" ): listener.enterObjectPath(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitObjectPath" ): listener.exitObjectPath(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitObjectPath" ): return visitor.visitObjectPath(self) else: return visitor.visitChildren(self) def objectPath(self): localctx = STIXPatternParser.ObjectPathContext(self, self._ctx, self.state) self.enterRule(localctx, 22, self.RULE_objectPath) try: self.enterOuterAlt(localctx, 1) self.state = 186 self.objectType() self.state = 187 self.match(STIXPatternParser.COLON) self.state = 188 self.firstPathComponent() self.state = 190 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,16,self._ctx) if la_ == 1: self.state = 189 self.objectPathComponent(0) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class ObjectTypeContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def IdentifierWithoutHyphen(self): return self.getToken(STIXPatternParser.IdentifierWithoutHyphen, 0) def IdentifierWithHyphen(self): return self.getToken(STIXPatternParser.IdentifierWithHyphen, 0) def getRuleIndex(self): return STIXPatternParser.RULE_objectType def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterObjectType" ): listener.enterObjectType(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitObjectType" ): listener.exitObjectType(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitObjectType" ): return visitor.visitObjectType(self) else: return visitor.visitChildren(self) def objectType(self): localctx = STIXPatternParser.ObjectTypeContext(self, self._ctx, self.state) self.enterRule(localctx, 24, self.RULE_objectType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 192 _la = self._input.LA(1) if not(_la==STIXPatternParser.IdentifierWithoutHyphen or _la==STIXPatternParser.IdentifierWithHyphen): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class FirstPathComponentContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def IdentifierWithoutHyphen(self): return self.getToken(STIXPatternParser.IdentifierWithoutHyphen, 0) def StringLiteral(self): return self.getToken(STIXPatternParser.StringLiteral, 0) def getRuleIndex(self): return STIXPatternParser.RULE_firstPathComponent def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterFirstPathComponent" ): listener.enterFirstPathComponent(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitFirstPathComponent" ): listener.exitFirstPathComponent(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitFirstPathComponent" ): return visitor.visitFirstPathComponent(self) else: return visitor.visitChildren(self) def firstPathComponent(self): localctx = STIXPatternParser.FirstPathComponentContext(self, self._ctx, self.state) self.enterRule(localctx, 26, self.RULE_firstPathComponent) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 194 _la = self._input.LA(1) if not(_la==STIXPatternParser.StringLiteral or _la==STIXPatternParser.IdentifierWithoutHyphen): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class ObjectPathComponentContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def getRuleIndex(self): return STIXPatternParser.RULE_objectPathComponent def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) class IndexPathStepContext(ObjectPathComponentContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a STIXPatternParser.ObjectPathComponentContext super().__init__(parser) self.copyFrom(ctx) def LBRACK(self): return self.getToken(STIXPatternParser.LBRACK, 0) def RBRACK(self): return self.getToken(STIXPatternParser.RBRACK, 0) def IntPosLiteral(self): return self.getToken(STIXPatternParser.IntPosLiteral, 0) def IntNegLiteral(self): return self.getToken(STIXPatternParser.IntNegLiteral, 0) def ASTERISK(self): return self.getToken(STIXPatternParser.ASTERISK, 0) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterIndexPathStep" ): listener.enterIndexPathStep(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitIndexPathStep" ): listener.exitIndexPathStep(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitIndexPathStep" ): return visitor.visitIndexPathStep(self) else: return visitor.visitChildren(self) class PathStepContext(ObjectPathComponentContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a STIXPatternParser.ObjectPathComponentContext super().__init__(parser) self.copyFrom(ctx) def objectPathComponent(self, i:int=None): if i is None: return self.getTypedRuleContexts(STIXPatternParser.ObjectPathComponentContext) else: return self.getTypedRuleContext(STIXPatternParser.ObjectPathComponentContext,i) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterPathStep" ): listener.enterPathStep(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitPathStep" ): listener.exitPathStep(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitPathStep" ): return visitor.visitPathStep(self) else: return visitor.visitChildren(self) class KeyPathStepContext(ObjectPathComponentContext): def __init__(self, parser, ctx:ParserRuleContext): # actually a STIXPatternParser.ObjectPathComponentContext super().__init__(parser) self.copyFrom(ctx) def DOT(self): return self.getToken(STIXPatternParser.DOT, 0) def IdentifierWithoutHyphen(self): return self.getToken(STIXPatternParser.IdentifierWithoutHyphen, 0) def StringLiteral(self): return self.getToken(STIXPatternParser.StringLiteral, 0) def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterKeyPathStep" ): listener.enterKeyPathStep(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitKeyPathStep" ): listener.exitKeyPathStep(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitKeyPathStep" ): return visitor.visitKeyPathStep(self) else: return visitor.visitChildren(self) def objectPathComponent(self, _p:int=0): _parentctx = self._ctx _parentState = self.state localctx = STIXPatternParser.ObjectPathComponentContext(self, self._ctx, _parentState) _prevctx = localctx _startState = 28 self.enterRecursionRule(localctx, 28, self.RULE_objectPathComponent, _p) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 202 self._errHandler.sync(self) token = self._input.LA(1) if token in [STIXPatternParser.DOT]: localctx = STIXPatternParser.KeyPathStepContext(self, localctx) self._ctx = localctx _prevctx = localctx self.state = 197 self.match(STIXPatternParser.DOT) self.state = 198 _la = self._input.LA(1) if not(_la==STIXPatternParser.StringLiteral or _la==STIXPatternParser.IdentifierWithoutHyphen): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() pass elif token in [STIXPatternParser.LBRACK]: localctx = STIXPatternParser.IndexPathStepContext(self, localctx) self._ctx = localctx _prevctx = localctx self.state = 199 self.match(STIXPatternParser.LBRACK) self.state = 200 _la = self._input.LA(1) if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << STIXPatternParser.IntNegLiteral) | (1 << STIXPatternParser.IntPosLiteral) | (1 << STIXPatternParser.ASTERISK))) != 0)): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() self.state = 201 self.match(STIXPatternParser.RBRACK) pass else: raise NoViableAltException(self) self._ctx.stop = self._input.LT(-1) self.state = 208 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,18,self._ctx) while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: if _alt==1: if self._parseListeners is not None: self.triggerExitRuleEvent() _prevctx = localctx localctx = STIXPatternParser.PathStepContext(self, STIXPatternParser.ObjectPathComponentContext(self, _parentctx, _parentState)) self.pushNewRecursionContext(localctx, _startState, self.RULE_objectPathComponent) self.state = 204 if not self.precpred(self._ctx, 3): from antlr4.error.Errors import FailedPredicateException raise FailedPredicateException(self, "self.precpred(self._ctx, 3)") self.state = 205 self.objectPathComponent(4) self.state = 210 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,18,self._ctx) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.unrollRecursionContexts(_parentctx) return localctx class SetLiteralContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def LPAREN(self): return self.getToken(STIXPatternParser.LPAREN, 0) def RPAREN(self): return self.getToken(STIXPatternParser.RPAREN, 0) def primitiveLiteral(self, i:int=None): if i is None: return self.getTypedRuleContexts(STIXPatternParser.PrimitiveLiteralContext) else: return self.getTypedRuleContext(STIXPatternParser.PrimitiveLiteralContext,i) def COMMA(self, i:int=None): if i is None: return self.getTokens(STIXPatternParser.COMMA) else: return self.getToken(STIXPatternParser.COMMA, i) def getRuleIndex(self): return STIXPatternParser.RULE_setLiteral def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterSetLiteral" ): listener.enterSetLiteral(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitSetLiteral" ): listener.exitSetLiteral(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitSetLiteral" ): return visitor.visitSetLiteral(self) else: return visitor.visitChildren(self) def setLiteral(self): localctx = STIXPatternParser.SetLiteralContext(self, self._ctx, self.state) self.enterRule(localctx, 30, self.RULE_setLiteral) self._la = 0 # Token type try: self.state = 224 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,20,self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 211 self.match(STIXPatternParser.LPAREN) self.state = 212 self.match(STIXPatternParser.RPAREN) pass elif la_ == 2: self.enterOuterAlt(localctx, 2) self.state = 213 self.match(STIXPatternParser.LPAREN) self.state = 214 self.primitiveLiteral() self.state = 219 self._errHandler.sync(self) _la = self._input.LA(1) while _la==STIXPatternParser.COMMA: self.state = 215 self.match(STIXPatternParser.COMMA) self.state = 216 self.primitiveLiteral() self.state = 221 self._errHandler.sync(self) _la = self._input.LA(1) self.state = 222 self.match(STIXPatternParser.RPAREN) pass except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class PrimitiveLiteralContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def orderableLiteral(self): return self.getTypedRuleContext(STIXPatternParser.OrderableLiteralContext,0) def BoolLiteral(self): return self.getToken(STIXPatternParser.BoolLiteral, 0) def getRuleIndex(self): return STIXPatternParser.RULE_primitiveLiteral def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterPrimitiveLiteral" ): listener.enterPrimitiveLiteral(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitPrimitiveLiteral" ): listener.exitPrimitiveLiteral(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitPrimitiveLiteral" ): return visitor.visitPrimitiveLiteral(self) else: return visitor.visitChildren(self) def primitiveLiteral(self): localctx = STIXPatternParser.PrimitiveLiteralContext(self, self._ctx, self.state) self.enterRule(localctx, 32, self.RULE_primitiveLiteral) try: self.state = 228 self._errHandler.sync(self) token = self._input.LA(1) if token in [STIXPatternParser.IntNegLiteral, STIXPatternParser.IntPosLiteral, STIXPatternParser.FloatNegLiteral, STIXPatternParser.FloatPosLiteral, STIXPatternParser.HexLiteral, STIXPatternParser.BinaryLiteral, STIXPatternParser.StringLiteral, STIXPatternParser.TimestampLiteral]: self.enterOuterAlt(localctx, 1) self.state = 226 self.orderableLiteral() pass elif token in [STIXPatternParser.BoolLiteral]: self.enterOuterAlt(localctx, 2) self.state = 227 self.match(STIXPatternParser.BoolLiteral) pass else: raise NoViableAltException(self) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx class OrderableLiteralContext(ParserRuleContext): __slots__ = 'parser' def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser def IntPosLiteral(self): return self.getToken(STIXPatternParser.IntPosLiteral, 0) def IntNegLiteral(self): return self.getToken(STIXPatternParser.IntNegLiteral, 0) def FloatPosLiteral(self): return self.getToken(STIXPatternParser.FloatPosLiteral, 0) def FloatNegLiteral(self): return self.getToken(STIXPatternParser.FloatNegLiteral, 0) def StringLiteral(self): return self.getToken(STIXPatternParser.StringLiteral, 0) def BinaryLiteral(self): return self.getToken(STIXPatternParser.BinaryLiteral, 0) def HexLiteral(self): return self.getToken(STIXPatternParser.HexLiteral, 0) def TimestampLiteral(self): return self.getToken(STIXPatternParser.TimestampLiteral, 0) def getRuleIndex(self): return STIXPatternParser.RULE_orderableLiteral def enterRule(self, listener:ParseTreeListener): if hasattr( listener, "enterOrderableLiteral" ): listener.enterOrderableLiteral(self) def exitRule(self, listener:ParseTreeListener): if hasattr( listener, "exitOrderableLiteral" ): listener.exitOrderableLiteral(self) def accept(self, visitor:ParseTreeVisitor): if hasattr( visitor, "visitOrderableLiteral" ): return visitor.visitOrderableLiteral(self) else: return visitor.visitChildren(self) def orderableLiteral(self): localctx = STIXPatternParser.OrderableLiteralContext(self, self._ctx, self.state) self.enterRule(localctx, 34, self.RULE_orderableLiteral) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 230 _la = self._input.LA(1) if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << STIXPatternParser.IntNegLiteral) | (1 << STIXPatternParser.IntPosLiteral) | (1 << STIXPatternParser.FloatNegLiteral) | (1 << STIXPatternParser.FloatPosLiteral) | (1 << STIXPatternParser.HexLiteral) | (1 << STIXPatternParser.BinaryLiteral) | (1 << STIXPatternParser.StringLiteral) | (1 << STIXPatternParser.TimestampLiteral))) != 0)): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) self._errHandler.recover(self, re) finally: self.exitRule() return localctx def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int): if self._predicates == None: self._predicates = dict() self._predicates[1] = self.observationExpressions_sempred self._predicates[2] = self.observationExpressionOr_sempred self._predicates[3] = self.observationExpressionAnd_sempred self._predicates[4] = self.observationExpression_sempred self._predicates[5] = self.comparisonExpression_sempred self._predicates[6] = self.comparisonExpressionAnd_sempred self._predicates[14] = self.objectPathComponent_sempred pred = self._predicates.get(ruleIndex, None) if pred is None: raise Exception("No predicate with index:" + str(ruleIndex)) else: return pred(localctx, predIndex) def observationExpressions_sempred(self, localctx:ObservationExpressionsContext, predIndex:int): if predIndex == 0: return self.precpred(self._ctx, 2) def observationExpressionOr_sempred(self, localctx:ObservationExpressionOrContext, predIndex:int): if predIndex == 1: return self.precpred(self._ctx, 2) def observationExpressionAnd_sempred(self, localctx:ObservationExpressionAndContext, predIndex:int): if predIndex == 2: return self.precpred(self._ctx, 2) def observationExpression_sempred(self, localctx:ObservationExpressionContext, predIndex:int): if predIndex == 3: return self.precpred(self._ctx, 3) if predIndex == 4: return self.precpred(self._ctx, 2) if predIndex == 5: return self.precpred(self._ctx, 1) def comparisonExpression_sempred(self, localctx:ComparisonExpressionContext, predIndex:int): if predIndex == 6: return self.precpred(self._ctx, 2) def comparisonExpressionAnd_sempred(self, localctx:ComparisonExpressionAndContext, predIndex:int): if predIndex == 7: return self.precpred(self._ctx, 2) def objectPathComponent_sempred(self, localctx:ObjectPathComponentContext, predIndex:int): if predIndex == 8: return self.precpred(self._ctx, 3)