// Code generated from SLQ.g4 by ANTLR 4.12.0. DO NOT EDIT. package slq // SLQ import ( "fmt" "strconv" "sync" "github.com/antlr/antlr4/runtime/Go/antlr/v4" ) // Suppress unused import errors var _ = fmt.Printf var _ = strconv.Itoa var _ = sync.Once{} type SLQParser struct { *antlr.BaseParser } var slqParserStaticData struct { once sync.Once serializedATN []int32 literalNames []string symbolicNames []string ruleNames []string predictionContextCache *antlr.PredictionContextCache atn *antlr.ATN decisionToDFA []*antlr.DFA } func slqParserInit() { staticData := &slqParserStaticData staticData.literalNames = []string{ "", "';'", "'*'", "'join'", "'JOIN'", "'j'", "'group'", "'GROUP'", "'g'", "'.['", "'sum'", "'SUM'", "'avg'", "'AVG'", "'count'", "'COUNT'", "'where'", "'WHERE'", "'||'", "'/'", "'%'", "'<<'", "'>>'", "'&'", "'&&'", "'~'", "'!'", "'+'", "'-'", "", "", "", "'('", "')'", "'['", "']'", "','", "'|'", "':'", "", "", "", "'<='", "'<'", "'>='", "'>'", "'!='", "'=='", } staticData.symbolicNames = []string{ "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "ORDER_ASC", "ORDER_DESC", "ORDER_BY", "ID", "WS", "LPAR", "RPAR", "LBRA", "RBRA", "COMMA", "PIPE", "COLON", "NULL", "NN", "NUMBER", "LT_EQ", "LT", "GT_EQ", "GT", "NEQ", "EQ", "NAME", "HANDLE", "STRING", "LINECOMMENT", } staticData.ruleNames = []string{ "stmtList", "query", "segment", "element", "cmpr", "fn", "fnElement", "join", "joinConstraint", "group", "orderByTerm", "orderBy", "selector", "selectorElement", "alias", "handleTable", "handle", "rowRange", "fnName", "expr", "literal", "unaryOperator", } staticData.predictionContextCache = antlr.NewPredictionContextCache() staticData.serializedATN = []int32{ 4, 1, 51, 231, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 1, 0, 5, 0, 46, 8, 0, 10, 0, 12, 0, 49, 9, 0, 1, 0, 1, 0, 4, 0, 53, 8, 0, 11, 0, 12, 0, 54, 1, 0, 5, 0, 58, 8, 0, 10, 0, 12, 0, 61, 9, 0, 1, 0, 5, 0, 64, 8, 0, 10, 0, 12, 0, 67, 9, 0, 1, 1, 1, 1, 1, 1, 5, 1, 72, 8, 1, 10, 1, 12, 1, 75, 9, 1, 1, 2, 1, 2, 1, 2, 5, 2, 80, 8, 2, 10, 2, 12, 2, 83, 9, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 3, 3, 94, 8, 3, 1, 4, 1, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 5, 5, 103, 8, 5, 10, 5, 12, 5, 106, 9, 5, 1, 5, 3, 5, 109, 8, 5, 1, 5, 1, 5, 1, 6, 1, 6, 3, 6, 115, 8, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 3, 8, 127, 8, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 5, 9, 134, 8, 9, 10, 9, 12, 9, 137, 9, 9, 1, 9, 1, 9, 1, 10, 1, 10, 3, 10, 143, 8, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 5, 11, 150, 8, 11, 10, 11, 12, 11, 153, 9, 11, 1, 11, 1, 11, 1, 12, 1, 12, 3, 12, 159, 8, 12, 1, 13, 1, 13, 3, 13, 163, 8, 13, 1, 14, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 182, 8, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 3, 19, 195, 8, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 3, 19, 216, 8, 19, 1, 19, 1, 19, 1, 19, 1, 19, 5, 19, 222, 8, 19, 10, 19, 12, 19, 225, 9, 19, 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, 0, 1, 38, 22, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 0, 10, 1, 0, 42, 47, 1, 0, 3, 5, 1, 0, 6, 8, 1, 0, 27, 28, 1, 0, 10, 17, 2, 0, 2, 2, 19, 20, 1, 0, 21, 23, 1, 0, 42, 45, 2, 0, 39, 41, 50, 50, 1, 0, 25, 28, 248, 0, 47, 1, 0, 0, 0, 2, 68, 1, 0, 0, 0, 4, 76, 1, 0, 0, 0, 6, 93, 1, 0, 0, 0, 8, 95, 1, 0, 0, 0, 10, 97, 1, 0, 0, 0, 12, 112, 1, 0, 0, 0, 14, 116, 1, 0, 0, 0, 16, 126, 1, 0, 0, 0, 18, 128, 1, 0, 0, 0, 20, 140, 1, 0, 0, 0, 22, 144, 1, 0, 0, 0, 24, 156, 1, 0, 0, 0, 26, 160, 1, 0, 0, 0, 28, 164, 1, 0, 0, 0, 30, 167, 1, 0, 0, 0, 32, 170, 1, 0, 0, 0, 34, 172, 1, 0, 0, 0, 36, 185, 1, 0, 0, 0, 38, 194, 1, 0, 0, 0, 40, 226, 1, 0, 0, 0, 42, 228, 1, 0, 0, 0, 44, 46, 5, 1, 0, 0, 45, 44, 1, 0, 0, 0, 46, 49, 1, 0, 0, 0, 47, 45, 1, 0, 0, 0, 47, 48, 1, 0, 0, 0, 48, 50, 1, 0, 0, 0, 49, 47, 1, 0, 0, 0, 50, 59, 3, 2, 1, 0, 51, 53, 5, 1, 0, 0, 52, 51, 1, 0, 0, 0, 53, 54, 1, 0, 0, 0, 54, 52, 1, 0, 0, 0, 54, 55, 1, 0, 0, 0, 55, 56, 1, 0, 0, 0, 56, 58, 3, 2, 1, 0, 57, 52, 1, 0, 0, 0, 58, 61, 1, 0, 0, 0, 59, 57, 1, 0, 0, 0, 59, 60, 1, 0, 0, 0, 60, 65, 1, 0, 0, 0, 61, 59, 1, 0, 0, 0, 62, 64, 5, 1, 0, 0, 63, 62, 1, 0, 0, 0, 64, 67, 1, 0, 0, 0, 65, 63, 1, 0, 0, 0, 65, 66, 1, 0, 0, 0, 66, 1, 1, 0, 0, 0, 67, 65, 1, 0, 0, 0, 68, 73, 3, 4, 2, 0, 69, 70, 5, 37, 0, 0, 70, 72, 3, 4, 2, 0, 71, 69, 1, 0, 0, 0, 72, 75, 1, 0, 0, 0, 73, 71, 1, 0, 0, 0, 73, 74, 1, 0, 0, 0, 74, 3, 1, 0, 0, 0, 75, 73, 1, 0, 0, 0, 76, 81, 3, 6, 3, 0, 77, 78, 5, 36, 0, 0, 78, 80, 3, 6, 3, 0, 79, 77, 1, 0, 0, 0, 80, 83, 1, 0, 0, 0, 81, 79, 1, 0, 0, 0, 81, 82, 1, 0, 0, 0, 82, 5, 1, 0, 0, 0, 83, 81, 1, 0, 0, 0, 84, 94, 3, 30, 15, 0, 85, 94, 3, 32, 16, 0, 86, 94, 3, 26, 13, 0, 87, 94, 3, 14, 7, 0, 88, 94, 3, 18, 9, 0, 89, 94, 3, 22, 11, 0, 90, 94, 3, 34, 17, 0, 91, 94, 3, 12, 6, 0, 92, 94, 3, 38, 19, 0, 93, 84, 1, 0, 0, 0, 93, 85, 1, 0, 0, 0, 93, 86, 1, 0, 0, 0, 93, 87, 1, 0, 0, 0, 93, 88, 1, 0, 0, 0, 93, 89, 1, 0, 0, 0, 93, 90, 1, 0, 0, 0, 93, 91, 1, 0, 0, 0, 93, 92, 1, 0, 0, 0, 94, 7, 1, 0, 0, 0, 95, 96, 7, 0, 0, 0, 96, 9, 1, 0, 0, 0, 97, 98, 3, 36, 18, 0, 98, 108, 5, 32, 0, 0, 99, 104, 3, 38, 19, 0, 100, 101, 5, 36, 0, 0, 101, 103, 3, 38, 19, 0, 102, 100, 1, 0, 0, 0, 103, 106, 1, 0, 0, 0, 104, 102, 1, 0, 0, 0, 104, 105, 1, 0, 0, 0, 105, 109, 1, 0, 0, 0, 106, 104, 1, 0, 0, 0, 107, 109, 5, 2, 0, 0, 108, 99, 1, 0, 0, 0, 108, 107, 1, 0, 0, 0, 108, 109, 1, 0, 0, 0, 109, 110, 1, 0, 0, 0, 110, 111, 5, 33, 0, 0, 111, 11, 1, 0, 0, 0, 112, 114, 3, 10, 5, 0, 113, 115, 3, 28, 14, 0, 114, 113, 1, 0, 0, 0, 114, 115, 1, 0, 0, 0, 115, 13, 1, 0, 0, 0, 116, 117, 7, 1, 0, 0, 117, 118, 5, 32, 0, 0, 118, 119, 3, 16, 8, 0, 119, 120, 5, 33, 0, 0, 120, 15, 1, 0, 0, 0, 121, 122, 3, 24, 12, 0, 122, 123, 3, 8, 4, 0, 123, 124, 3, 24, 12, 0, 124, 127, 1, 0, 0, 0, 125, 127, 3, 24, 12, 0, 126, 121, 1, 0, 0, 0, 126, 125, 1, 0, 0, 0, 127, 17, 1, 0, 0, 0, 128, 129, 7, 2, 0, 0, 129, 130, 5, 32, 0, 0, 130, 135, 3, 24, 12, 0, 131, 132, 5, 36, 0, 0, 132, 134, 3, 24, 12, 0, 133, 131, 1, 0, 0, 0, 134, 137, 1, 0, 0, 0, 135, 133, 1, 0, 0, 0, 135, 136, 1, 0, 0, 0, 136, 138, 1, 0, 0, 0, 137, 135, 1, 0, 0, 0, 138, 139, 5, 33, 0, 0, 139, 19, 1, 0, 0, 0, 140, 142, 3, 24, 12, 0, 141, 143, 7, 3, 0, 0, 142, 141, 1, 0, 0, 0, 142, 143, 1, 0, 0, 0, 143, 21, 1, 0, 0, 0, 144, 145, 5, 29, 0, 0, 145, 146, 5, 32, 0, 0, 146, 151, 3, 20, 10, 0, 147, 148, 5, 36, 0, 0, 148, 150, 3, 20, 10, 0, 149, 147, 1, 0, 0, 0, 150, 153, 1, 0, 0, 0, 151, 149, 1, 0, 0, 0, 151, 152, 1, 0, 0, 0, 152, 154, 1, 0, 0, 0, 153, 151, 1, 0, 0, 0, 154, 155, 5, 33, 0, 0, 155, 23, 1, 0, 0, 0, 156, 158, 5, 48, 0, 0, 157, 159, 5, 48, 0, 0, 158, 157, 1, 0, 0, 0, 158, 159, 1, 0, 0, 0, 159, 25, 1, 0, 0, 0, 160, 162, 3, 24, 12, 0, 161, 163, 3, 28, 14, 0, 162, 161, 1, 0, 0, 0, 162, 163, 1, 0, 0, 0, 163, 27, 1, 0, 0, 0, 164, 165, 5, 38, 0, 0, 165, 166, 5, 30, 0, 0, 166, 29, 1, 0, 0, 0, 167, 168, 5, 49, 0, 0, 168, 169, 5, 48, 0, 0, 169, 31, 1, 0, 0, 0, 170, 171, 5, 49, 0, 0, 171, 33, 1, 0, 0, 0, 172, 181, 5, 9, 0, 0, 173, 174, 5, 40, 0, 0, 174, 175, 5, 38, 0, 0, 175, 182, 5, 40, 0, 0, 176, 177, 5, 40, 0, 0, 177, 182, 5, 38, 0, 0, 178, 179, 5, 38, 0, 0, 179, 182, 5, 40, 0, 0, 180, 182, 5, 40, 0, 0, 181, 173, 1, 0, 0, 0, 181, 176, 1, 0, 0, 0, 181, 178, 1, 0, 0, 0, 181, 180, 1, 0, 0, 0, 181, 182, 1, 0, 0, 0, 182, 183, 1, 0, 0, 0, 183, 184, 5, 35, 0, 0, 184, 35, 1, 0, 0, 0, 185, 186, 7, 4, 0, 0, 186, 37, 1, 0, 0, 0, 187, 188, 6, 19, -1, 0, 188, 195, 3, 24, 12, 0, 189, 195, 3, 40, 20, 0, 190, 191, 3, 42, 21, 0, 191, 192, 3, 38, 19, 9, 192, 195, 1, 0, 0, 0, 193, 195, 3, 10, 5, 0, 194, 187, 1, 0, 0, 0, 194, 189, 1, 0, 0, 0, 194, 190, 1, 0, 0, 0, 194, 193, 1, 0, 0, 0, 195, 223, 1, 0, 0, 0, 196, 197, 10, 8, 0, 0, 197, 198, 5, 18, 0, 0, 198, 222, 3, 38, 19, 9, 199, 200, 10, 7, 0, 0, 200, 201, 7, 5, 0, 0, 201, 222, 3, 38, 19, 8, 202, 203, 10, 6, 0, 0, 203, 204, 7, 3, 0, 0, 204, 222, 3, 38, 19, 7, 205, 206, 10, 5, 0, 0, 206, 207, 7, 6, 0, 0, 207, 222, 3, 38, 19, 6, 208, 209, 10, 4, 0, 0, 209, 210, 7, 7, 0, 0, 210, 222, 3, 38, 19, 5, 211, 215, 10, 3, 0, 0, 212, 216, 5, 47, 0, 0, 213, 216, 5, 46, 0, 0, 214, 216, 1, 0, 0, 0, 215, 212, 1, 0, 0, 0, 215, 213, 1, 0, 0, 0, 215, 214, 1, 0, 0, 0, 216, 217, 1, 0, 0, 0, 217, 222, 3, 38, 19, 4, 218, 219, 10, 2, 0, 0, 219, 220, 5, 24, 0, 0, 220, 222, 3, 38, 19, 3, 221, 196, 1, 0, 0, 0, 221, 199, 1, 0, 0, 0, 221, 202, 1, 0, 0, 0, 221, 205, 1, 0, 0, 0, 221, 208, 1, 0, 0, 0, 221, 211, 1, 0, 0, 0, 221, 218, 1, 0, 0, 0, 222, 225, 1, 0, 0, 0, 223, 221, 1, 0, 0, 0, 223, 224, 1, 0, 0, 0, 224, 39, 1, 0, 0, 0, 225, 223, 1, 0, 0, 0, 226, 227, 7, 8, 0, 0, 227, 41, 1, 0, 0, 0, 228, 229, 7, 9, 0, 0, 229, 43, 1, 0, 0, 0, 21, 47, 54, 59, 65, 73, 81, 93, 104, 108, 114, 126, 135, 142, 151, 158, 162, 181, 194, 215, 221, 223, } deserializer := antlr.NewATNDeserializer(nil) staticData.atn = deserializer.Deserialize(staticData.serializedATN) atn := staticData.atn staticData.decisionToDFA = make([]*antlr.DFA, len(atn.DecisionToState)) decisionToDFA := staticData.decisionToDFA for index, state := range atn.DecisionToState { decisionToDFA[index] = antlr.NewDFA(state, index) } } // SLQParserInit initializes any static state used to implement SLQParser. By default the // static state used to implement the parser is lazily initialized during the first call to // NewSLQParser(). You can call this function if you wish to initialize the static state ahead // of time. func SLQParserInit() { staticData := &slqParserStaticData staticData.once.Do(slqParserInit) } // NewSLQParser produces a new parser instance for the optional input antlr.TokenStream. func NewSLQParser(input antlr.TokenStream) *SLQParser { SLQParserInit() this := new(SLQParser) this.BaseParser = antlr.NewBaseParser(input) staticData := &slqParserStaticData this.Interpreter = antlr.NewParserATNSimulator(this, staticData.atn, staticData.decisionToDFA, staticData.predictionContextCache) this.RuleNames = staticData.ruleNames this.LiteralNames = staticData.literalNames this.SymbolicNames = staticData.symbolicNames this.GrammarFileName = "SLQ.g4" return this } // SLQParser tokens. const ( SLQParserEOF = antlr.TokenEOF SLQParserT__0 = 1 SLQParserT__1 = 2 SLQParserT__2 = 3 SLQParserT__3 = 4 SLQParserT__4 = 5 SLQParserT__5 = 6 SLQParserT__6 = 7 SLQParserT__7 = 8 SLQParserT__8 = 9 SLQParserT__9 = 10 SLQParserT__10 = 11 SLQParserT__11 = 12 SLQParserT__12 = 13 SLQParserT__13 = 14 SLQParserT__14 = 15 SLQParserT__15 = 16 SLQParserT__16 = 17 SLQParserT__17 = 18 SLQParserT__18 = 19 SLQParserT__19 = 20 SLQParserT__20 = 21 SLQParserT__21 = 22 SLQParserT__22 = 23 SLQParserT__23 = 24 SLQParserT__24 = 25 SLQParserT__25 = 26 SLQParserORDER_ASC = 27 SLQParserORDER_DESC = 28 SLQParserORDER_BY = 29 SLQParserID = 30 SLQParserWS = 31 SLQParserLPAR = 32 SLQParserRPAR = 33 SLQParserLBRA = 34 SLQParserRBRA = 35 SLQParserCOMMA = 36 SLQParserPIPE = 37 SLQParserCOLON = 38 SLQParserNULL = 39 SLQParserNN = 40 SLQParserNUMBER = 41 SLQParserLT_EQ = 42 SLQParserLT = 43 SLQParserGT_EQ = 44 SLQParserGT = 45 SLQParserNEQ = 46 SLQParserEQ = 47 SLQParserNAME = 48 SLQParserHANDLE = 49 SLQParserSTRING = 50 SLQParserLINECOMMENT = 51 ) // SLQParser rules. const ( SLQParserRULE_stmtList = 0 SLQParserRULE_query = 1 SLQParserRULE_segment = 2 SLQParserRULE_element = 3 SLQParserRULE_cmpr = 4 SLQParserRULE_fn = 5 SLQParserRULE_fnElement = 6 SLQParserRULE_join = 7 SLQParserRULE_joinConstraint = 8 SLQParserRULE_group = 9 SLQParserRULE_orderByTerm = 10 SLQParserRULE_orderBy = 11 SLQParserRULE_selector = 12 SLQParserRULE_selectorElement = 13 SLQParserRULE_alias = 14 SLQParserRULE_handleTable = 15 SLQParserRULE_handle = 16 SLQParserRULE_rowRange = 17 SLQParserRULE_fnName = 18 SLQParserRULE_expr = 19 SLQParserRULE_literal = 20 SLQParserRULE_unaryOperator = 21 ) // IStmtListContext is an interface to support dynamic dispatch. type IStmtListContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllQuery() []IQueryContext Query(i int) IQueryContext // IsStmtListContext differentiates from other interfaces. IsStmtListContext() } type StmtListContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyStmtListContext() *StmtListContext { var p = new(StmtListContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = SLQParserRULE_stmtList return p } func (*StmtListContext) IsStmtListContext() {} func NewStmtListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StmtListContext { var p = new(StmtListContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = SLQParserRULE_stmtList return p } func (s *StmtListContext) GetParser() antlr.Parser { return s.parser } func (s *StmtListContext) AllQuery() []IQueryContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IQueryContext); ok { len++ } } tst := make([]IQueryContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IQueryContext); ok { tst[i] = t.(IQueryContext) i++ } } return tst } func (s *StmtListContext) Query(i int) IQueryContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IQueryContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IQueryContext) } func (s *StmtListContext) GetRuleContext() antlr.RuleContext { return s } func (s *StmtListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *StmtListContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.EnterStmtList(s) } } func (s *StmtListContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.ExitStmtList(s) } } func (s *StmtListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case SLQVisitor: return t.VisitStmtList(s) default: return t.VisitChildren(s) } } func (p *SLQParser) StmtList() (localctx IStmtListContext) { this := p _ = this localctx = NewStmtListContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 0, SLQParserRULE_stmtList) var _la int defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() var _alt int p.EnterOuterAlt(localctx, 1) p.SetState(47) p.GetErrorHandler().Sync(p) _la = p.GetTokenStream().LA(1) for _la == SLQParserT__0 { { p.SetState(44) p.Match(SLQParserT__0) } p.SetState(49) p.GetErrorHandler().Sync(p) _la = p.GetTokenStream().LA(1) } { p.SetState(50) p.Query() } p.SetState(59) p.GetErrorHandler().Sync(p) _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 2, p.GetParserRuleContext()) for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { if _alt == 1 { p.SetState(52) p.GetErrorHandler().Sync(p) _la = p.GetTokenStream().LA(1) for ok := true; ok; ok = _la == SLQParserT__0 { { p.SetState(51) p.Match(SLQParserT__0) } p.SetState(54) p.GetErrorHandler().Sync(p) _la = p.GetTokenStream().LA(1) } { p.SetState(56) p.Query() } } p.SetState(61) p.GetErrorHandler().Sync(p) _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 2, p.GetParserRuleContext()) } p.SetState(65) p.GetErrorHandler().Sync(p) _la = p.GetTokenStream().LA(1) for _la == SLQParserT__0 { { p.SetState(62) p.Match(SLQParserT__0) } p.SetState(67) p.GetErrorHandler().Sync(p) _la = p.GetTokenStream().LA(1) } return localctx } // IQueryContext is an interface to support dynamic dispatch. type IQueryContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllSegment() []ISegmentContext Segment(i int) ISegmentContext AllPIPE() []antlr.TerminalNode PIPE(i int) antlr.TerminalNode // IsQueryContext differentiates from other interfaces. IsQueryContext() } type QueryContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyQueryContext() *QueryContext { var p = new(QueryContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = SLQParserRULE_query return p } func (*QueryContext) IsQueryContext() {} func NewQueryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *QueryContext { var p = new(QueryContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = SLQParserRULE_query return p } func (s *QueryContext) GetParser() antlr.Parser { return s.parser } func (s *QueryContext) AllSegment() []ISegmentContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ISegmentContext); ok { len++ } } tst := make([]ISegmentContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ISegmentContext); ok { tst[i] = t.(ISegmentContext) i++ } } return tst } func (s *QueryContext) Segment(i int) ISegmentContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISegmentContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ISegmentContext) } func (s *QueryContext) AllPIPE() []antlr.TerminalNode { return s.GetTokens(SLQParserPIPE) } func (s *QueryContext) PIPE(i int) antlr.TerminalNode { return s.GetToken(SLQParserPIPE, i) } func (s *QueryContext) GetRuleContext() antlr.RuleContext { return s } func (s *QueryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *QueryContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.EnterQuery(s) } } func (s *QueryContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.ExitQuery(s) } } func (s *QueryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case SLQVisitor: return t.VisitQuery(s) default: return t.VisitChildren(s) } } func (p *SLQParser) Query() (localctx IQueryContext) { this := p _ = this localctx = NewQueryContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 2, SLQParserRULE_query) var _la int defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.EnterOuterAlt(localctx, 1) { p.SetState(68) p.Segment() } p.SetState(73) p.GetErrorHandler().Sync(p) _la = p.GetTokenStream().LA(1) for _la == SLQParserPIPE { { p.SetState(69) p.Match(SLQParserPIPE) } { p.SetState(70) p.Segment() } p.SetState(75) p.GetErrorHandler().Sync(p) _la = p.GetTokenStream().LA(1) } return localctx } // ISegmentContext is an interface to support dynamic dispatch. type ISegmentContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllElement() []IElementContext Element(i int) IElementContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsSegmentContext differentiates from other interfaces. IsSegmentContext() } type SegmentContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySegmentContext() *SegmentContext { var p = new(SegmentContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = SLQParserRULE_segment return p } func (*SegmentContext) IsSegmentContext() {} func NewSegmentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SegmentContext { var p = new(SegmentContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = SLQParserRULE_segment return p } func (s *SegmentContext) GetParser() antlr.Parser { return s.parser } func (s *SegmentContext) AllElement() []IElementContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IElementContext); ok { len++ } } tst := make([]IElementContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IElementContext); ok { tst[i] = t.(IElementContext) i++ } } return tst } func (s *SegmentContext) Element(i int) IElementContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IElementContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IElementContext) } func (s *SegmentContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(SLQParserCOMMA) } func (s *SegmentContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(SLQParserCOMMA, i) } func (s *SegmentContext) GetRuleContext() antlr.RuleContext { return s } func (s *SegmentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *SegmentContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.EnterSegment(s) } } func (s *SegmentContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.ExitSegment(s) } } func (s *SegmentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case SLQVisitor: return t.VisitSegment(s) default: return t.VisitChildren(s) } } func (p *SLQParser) Segment() (localctx ISegmentContext) { this := p _ = this localctx = NewSegmentContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 4, SLQParserRULE_segment) var _la int defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.EnterOuterAlt(localctx, 1) { p.SetState(76) p.Element() } p.SetState(81) p.GetErrorHandler().Sync(p) _la = p.GetTokenStream().LA(1) for _la == SLQParserCOMMA { { p.SetState(77) p.Match(SLQParserCOMMA) } { p.SetState(78) p.Element() } p.SetState(83) p.GetErrorHandler().Sync(p) _la = p.GetTokenStream().LA(1) } return localctx } // IElementContext is an interface to support dynamic dispatch. type IElementContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures HandleTable() IHandleTableContext Handle() IHandleContext SelectorElement() ISelectorElementContext Join() IJoinContext Group() IGroupContext OrderBy() IOrderByContext RowRange() IRowRangeContext FnElement() IFnElementContext Expr() IExprContext // IsElementContext differentiates from other interfaces. IsElementContext() } type ElementContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyElementContext() *ElementContext { var p = new(ElementContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = SLQParserRULE_element return p } func (*ElementContext) IsElementContext() {} func NewElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ElementContext { var p = new(ElementContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = SLQParserRULE_element return p } func (s *ElementContext) GetParser() antlr.Parser { return s.parser } func (s *ElementContext) HandleTable() IHandleTableContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IHandleTableContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IHandleTableContext) } func (s *ElementContext) Handle() IHandleContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IHandleContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IHandleContext) } func (s *ElementContext) SelectorElement() ISelectorElementContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelectorElementContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISelectorElementContext) } func (s *ElementContext) Join() IJoinContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IJoinContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IJoinContext) } func (s *ElementContext) Group() IGroupContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IGroupContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IGroupContext) } func (s *ElementContext) OrderBy() IOrderByContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOrderByContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IOrderByContext) } func (s *ElementContext) RowRange() IRowRangeContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRowRangeContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IRowRangeContext) } func (s *ElementContext) FnElement() IFnElementContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFnElementContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFnElementContext) } func (s *ElementContext) Expr() IExprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IExprContext) } func (s *ElementContext) GetRuleContext() antlr.RuleContext { return s } func (s *ElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ElementContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.EnterElement(s) } } func (s *ElementContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.ExitElement(s) } } func (s *ElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case SLQVisitor: return t.VisitElement(s) default: return t.VisitChildren(s) } } func (p *SLQParser) Element() (localctx IElementContext) { this := p _ = this localctx = NewElementContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 6, SLQParserRULE_element) defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.SetState(93) p.GetErrorHandler().Sync(p) switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 6, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(84) p.HandleTable() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(85) p.Handle() } case 3: p.EnterOuterAlt(localctx, 3) { p.SetState(86) p.SelectorElement() } case 4: p.EnterOuterAlt(localctx, 4) { p.SetState(87) p.Join() } case 5: p.EnterOuterAlt(localctx, 5) { p.SetState(88) p.Group() } case 6: p.EnterOuterAlt(localctx, 6) { p.SetState(89) p.OrderBy() } case 7: p.EnterOuterAlt(localctx, 7) { p.SetState(90) p.RowRange() } case 8: p.EnterOuterAlt(localctx, 8) { p.SetState(91) p.FnElement() } case 9: p.EnterOuterAlt(localctx, 9) { p.SetState(92) p.expr(0) } } return localctx } // ICmprContext is an interface to support dynamic dispatch. type ICmprContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures LT_EQ() antlr.TerminalNode LT() antlr.TerminalNode GT_EQ() antlr.TerminalNode GT() antlr.TerminalNode EQ() antlr.TerminalNode NEQ() antlr.TerminalNode // IsCmprContext differentiates from other interfaces. IsCmprContext() } type CmprContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyCmprContext() *CmprContext { var p = new(CmprContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = SLQParserRULE_cmpr return p } func (*CmprContext) IsCmprContext() {} func NewCmprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CmprContext { var p = new(CmprContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = SLQParserRULE_cmpr return p } func (s *CmprContext) GetParser() antlr.Parser { return s.parser } func (s *CmprContext) LT_EQ() antlr.TerminalNode { return s.GetToken(SLQParserLT_EQ, 0) } func (s *CmprContext) LT() antlr.TerminalNode { return s.GetToken(SLQParserLT, 0) } func (s *CmprContext) GT_EQ() antlr.TerminalNode { return s.GetToken(SLQParserGT_EQ, 0) } func (s *CmprContext) GT() antlr.TerminalNode { return s.GetToken(SLQParserGT, 0) } func (s *CmprContext) EQ() antlr.TerminalNode { return s.GetToken(SLQParserEQ, 0) } func (s *CmprContext) NEQ() antlr.TerminalNode { return s.GetToken(SLQParserNEQ, 0) } func (s *CmprContext) GetRuleContext() antlr.RuleContext { return s } func (s *CmprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CmprContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.EnterCmpr(s) } } func (s *CmprContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.ExitCmpr(s) } } func (s *CmprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case SLQVisitor: return t.VisitCmpr(s) default: return t.VisitChildren(s) } } func (p *SLQParser) Cmpr() (localctx ICmprContext) { this := p _ = this localctx = NewCmprContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 8, SLQParserRULE_cmpr) var _la int defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.EnterOuterAlt(localctx, 1) { p.SetState(95) _la = p.GetTokenStream().LA(1) if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&277076930199552) != 0) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } return localctx } // IFnContext is an interface to support dynamic dispatch. type IFnContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures FnName() IFnNameContext LPAR() antlr.TerminalNode RPAR() antlr.TerminalNode AllExpr() []IExprContext Expr(i int) IExprContext AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsFnContext differentiates from other interfaces. IsFnContext() } type FnContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFnContext() *FnContext { var p = new(FnContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = SLQParserRULE_fn return p } func (*FnContext) IsFnContext() {} func NewFnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FnContext { var p = new(FnContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = SLQParserRULE_fn return p } func (s *FnContext) GetParser() antlr.Parser { return s.parser } func (s *FnContext) FnName() IFnNameContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFnNameContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFnNameContext) } func (s *FnContext) LPAR() antlr.TerminalNode { return s.GetToken(SLQParserLPAR, 0) } func (s *FnContext) RPAR() antlr.TerminalNode { return s.GetToken(SLQParserRPAR, 0) } func (s *FnContext) AllExpr() []IExprContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IExprContext); ok { len++ } } tst := make([]IExprContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IExprContext); ok { tst[i] = t.(IExprContext) i++ } } return tst } func (s *FnContext) Expr(i int) IExprContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExprContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IExprContext) } func (s *FnContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(SLQParserCOMMA) } func (s *FnContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(SLQParserCOMMA, i) } func (s *FnContext) GetRuleContext() antlr.RuleContext { return s } func (s *FnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *FnContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.EnterFn(s) } } func (s *FnContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.ExitFn(s) } } func (s *FnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case SLQVisitor: return t.VisitFn(s) default: return t.VisitChildren(s) } } func (p *SLQParser) Fn() (localctx IFnContext) { this := p _ = this localctx = NewFnContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 10, SLQParserRULE_fn) var _la int defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.EnterOuterAlt(localctx, 1) { p.SetState(97) p.FnName() } { p.SetState(98) p.Match(SLQParserLPAR) } p.SetState(108) p.GetErrorHandler().Sync(p) switch p.GetTokenStream().LA(1) { case SLQParserT__9, SLQParserT__10, SLQParserT__11, SLQParserT__12, SLQParserT__13, SLQParserT__14, SLQParserT__15, SLQParserT__16, SLQParserT__24, SLQParserT__25, SLQParserORDER_ASC, SLQParserORDER_DESC, SLQParserNULL, SLQParserNN, SLQParserNUMBER, SLQParserNAME, SLQParserSTRING: { p.SetState(99) p.expr(0) } p.SetState(104) p.GetErrorHandler().Sync(p) _la = p.GetTokenStream().LA(1) for _la == SLQParserCOMMA { { p.SetState(100) p.Match(SLQParserCOMMA) } { p.SetState(101) p.expr(0) } p.SetState(106) p.GetErrorHandler().Sync(p) _la = p.GetTokenStream().LA(1) } case SLQParserT__1: { p.SetState(107) p.Match(SLQParserT__1) } case SLQParserRPAR: default: } { p.SetState(110) p.Match(SLQParserRPAR) } return localctx } // IFnElementContext is an interface to support dynamic dispatch. type IFnElementContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Fn() IFnContext Alias() IAliasContext // IsFnElementContext differentiates from other interfaces. IsFnElementContext() } type FnElementContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFnElementContext() *FnElementContext { var p = new(FnElementContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = SLQParserRULE_fnElement return p } func (*FnElementContext) IsFnElementContext() {} func NewFnElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FnElementContext { var p = new(FnElementContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = SLQParserRULE_fnElement return p } func (s *FnElementContext) GetParser() antlr.Parser { return s.parser } func (s *FnElementContext) Fn() IFnContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFnContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFnContext) } func (s *FnElementContext) Alias() IAliasContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAliasContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAliasContext) } func (s *FnElementContext) GetRuleContext() antlr.RuleContext { return s } func (s *FnElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *FnElementContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.EnterFnElement(s) } } func (s *FnElementContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.ExitFnElement(s) } } func (s *FnElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case SLQVisitor: return t.VisitFnElement(s) default: return t.VisitChildren(s) } } func (p *SLQParser) FnElement() (localctx IFnElementContext) { this := p _ = this localctx = NewFnElementContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 12, SLQParserRULE_fnElement) var _la int defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.EnterOuterAlt(localctx, 1) { p.SetState(112) p.Fn() } p.SetState(114) p.GetErrorHandler().Sync(p) _la = p.GetTokenStream().LA(1) if _la == SLQParserCOLON { { p.SetState(113) p.Alias() } } return localctx } // IJoinContext is an interface to support dynamic dispatch. type IJoinContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures LPAR() antlr.TerminalNode JoinConstraint() IJoinConstraintContext RPAR() antlr.TerminalNode // IsJoinContext differentiates from other interfaces. IsJoinContext() } type JoinContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyJoinContext() *JoinContext { var p = new(JoinContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = SLQParserRULE_join return p } func (*JoinContext) IsJoinContext() {} func NewJoinContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *JoinContext { var p = new(JoinContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = SLQParserRULE_join return p } func (s *JoinContext) GetParser() antlr.Parser { return s.parser } func (s *JoinContext) LPAR() antlr.TerminalNode { return s.GetToken(SLQParserLPAR, 0) } func (s *JoinContext) JoinConstraint() IJoinConstraintContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IJoinConstraintContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IJoinConstraintContext) } func (s *JoinContext) RPAR() antlr.TerminalNode { return s.GetToken(SLQParserRPAR, 0) } func (s *JoinContext) GetRuleContext() antlr.RuleContext { return s } func (s *JoinContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *JoinContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.EnterJoin(s) } } func (s *JoinContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.ExitJoin(s) } } func (s *JoinContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case SLQVisitor: return t.VisitJoin(s) default: return t.VisitChildren(s) } } func (p *SLQParser) Join() (localctx IJoinContext) { this := p _ = this localctx = NewJoinContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 14, SLQParserRULE_join) var _la int defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.EnterOuterAlt(localctx, 1) { p.SetState(116) _la = p.GetTokenStream().LA(1) if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&56) != 0) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } { p.SetState(117) p.Match(SLQParserLPAR) } { p.SetState(118) p.JoinConstraint() } { p.SetState(119) p.Match(SLQParserRPAR) } return localctx } // IJoinConstraintContext is an interface to support dynamic dispatch. type IJoinConstraintContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllSelector() []ISelectorContext Selector(i int) ISelectorContext Cmpr() ICmprContext // IsJoinConstraintContext differentiates from other interfaces. IsJoinConstraintContext() } type JoinConstraintContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyJoinConstraintContext() *JoinConstraintContext { var p = new(JoinConstraintContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = SLQParserRULE_joinConstraint return p } func (*JoinConstraintContext) IsJoinConstraintContext() {} func NewJoinConstraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *JoinConstraintContext { var p = new(JoinConstraintContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = SLQParserRULE_joinConstraint return p } func (s *JoinConstraintContext) GetParser() antlr.Parser { return s.parser } func (s *JoinConstraintContext) AllSelector() []ISelectorContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ISelectorContext); ok { len++ } } tst := make([]ISelectorContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ISelectorContext); ok { tst[i] = t.(ISelectorContext) i++ } } return tst } func (s *JoinConstraintContext) Selector(i int) ISelectorContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelectorContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ISelectorContext) } func (s *JoinConstraintContext) Cmpr() ICmprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICmprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICmprContext) } func (s *JoinConstraintContext) GetRuleContext() antlr.RuleContext { return s } func (s *JoinConstraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *JoinConstraintContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.EnterJoinConstraint(s) } } func (s *JoinConstraintContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.ExitJoinConstraint(s) } } func (s *JoinConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case SLQVisitor: return t.VisitJoinConstraint(s) default: return t.VisitChildren(s) } } func (p *SLQParser) JoinConstraint() (localctx IJoinConstraintContext) { this := p _ = this localctx = NewJoinConstraintContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 16, SLQParserRULE_joinConstraint) defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.SetState(126) p.GetErrorHandler().Sync(p) switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 10, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { p.SetState(121) p.Selector() } { p.SetState(122) p.Cmpr() } { p.SetState(123) p.Selector() } case 2: p.EnterOuterAlt(localctx, 2) { p.SetState(125) p.Selector() } } return localctx } // IGroupContext is an interface to support dynamic dispatch. type IGroupContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures LPAR() antlr.TerminalNode AllSelector() []ISelectorContext Selector(i int) ISelectorContext RPAR() antlr.TerminalNode AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsGroupContext differentiates from other interfaces. IsGroupContext() } type GroupContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyGroupContext() *GroupContext { var p = new(GroupContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = SLQParserRULE_group return p } func (*GroupContext) IsGroupContext() {} func NewGroupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GroupContext { var p = new(GroupContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = SLQParserRULE_group return p } func (s *GroupContext) GetParser() antlr.Parser { return s.parser } func (s *GroupContext) LPAR() antlr.TerminalNode { return s.GetToken(SLQParserLPAR, 0) } func (s *GroupContext) AllSelector() []ISelectorContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ISelectorContext); ok { len++ } } tst := make([]ISelectorContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ISelectorContext); ok { tst[i] = t.(ISelectorContext) i++ } } return tst } func (s *GroupContext) Selector(i int) ISelectorContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelectorContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ISelectorContext) } func (s *GroupContext) RPAR() antlr.TerminalNode { return s.GetToken(SLQParserRPAR, 0) } func (s *GroupContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(SLQParserCOMMA) } func (s *GroupContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(SLQParserCOMMA, i) } func (s *GroupContext) GetRuleContext() antlr.RuleContext { return s } func (s *GroupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *GroupContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.EnterGroup(s) } } func (s *GroupContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.ExitGroup(s) } } func (s *GroupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case SLQVisitor: return t.VisitGroup(s) default: return t.VisitChildren(s) } } func (p *SLQParser) Group() (localctx IGroupContext) { this := p _ = this localctx = NewGroupContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 18, SLQParserRULE_group) var _la int defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.EnterOuterAlt(localctx, 1) { p.SetState(128) _la = p.GetTokenStream().LA(1) if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&448) != 0) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } { p.SetState(129) p.Match(SLQParserLPAR) } { p.SetState(130) p.Selector() } p.SetState(135) p.GetErrorHandler().Sync(p) _la = p.GetTokenStream().LA(1) for _la == SLQParserCOMMA { { p.SetState(131) p.Match(SLQParserCOMMA) } { p.SetState(132) p.Selector() } p.SetState(137) p.GetErrorHandler().Sync(p) _la = p.GetTokenStream().LA(1) } { p.SetState(138) p.Match(SLQParserRPAR) } return localctx } // IOrderByTermContext is an interface to support dynamic dispatch. type IOrderByTermContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Selector() ISelectorContext ORDER_ASC() antlr.TerminalNode ORDER_DESC() antlr.TerminalNode // IsOrderByTermContext differentiates from other interfaces. IsOrderByTermContext() } type OrderByTermContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOrderByTermContext() *OrderByTermContext { var p = new(OrderByTermContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = SLQParserRULE_orderByTerm return p } func (*OrderByTermContext) IsOrderByTermContext() {} func NewOrderByTermContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OrderByTermContext { var p = new(OrderByTermContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = SLQParserRULE_orderByTerm return p } func (s *OrderByTermContext) GetParser() antlr.Parser { return s.parser } func (s *OrderByTermContext) Selector() ISelectorContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelectorContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISelectorContext) } func (s *OrderByTermContext) ORDER_ASC() antlr.TerminalNode { return s.GetToken(SLQParserORDER_ASC, 0) } func (s *OrderByTermContext) ORDER_DESC() antlr.TerminalNode { return s.GetToken(SLQParserORDER_DESC, 0) } func (s *OrderByTermContext) GetRuleContext() antlr.RuleContext { return s } func (s *OrderByTermContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *OrderByTermContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.EnterOrderByTerm(s) } } func (s *OrderByTermContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.ExitOrderByTerm(s) } } func (s *OrderByTermContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case SLQVisitor: return t.VisitOrderByTerm(s) default: return t.VisitChildren(s) } } func (p *SLQParser) OrderByTerm() (localctx IOrderByTermContext) { this := p _ = this localctx = NewOrderByTermContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 20, SLQParserRULE_orderByTerm) var _la int defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.EnterOuterAlt(localctx, 1) { p.SetState(140) p.Selector() } p.SetState(142) p.GetErrorHandler().Sync(p) _la = p.GetTokenStream().LA(1) if _la == SLQParserORDER_ASC || _la == SLQParserORDER_DESC { { p.SetState(141) _la = p.GetTokenStream().LA(1) if !(_la == SLQParserORDER_ASC || _la == SLQParserORDER_DESC) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } } return localctx } // IOrderByContext is an interface to support dynamic dispatch. type IOrderByContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ORDER_BY() antlr.TerminalNode LPAR() antlr.TerminalNode AllOrderByTerm() []IOrderByTermContext OrderByTerm(i int) IOrderByTermContext RPAR() antlr.TerminalNode AllCOMMA() []antlr.TerminalNode COMMA(i int) antlr.TerminalNode // IsOrderByContext differentiates from other interfaces. IsOrderByContext() } type OrderByContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyOrderByContext() *OrderByContext { var p = new(OrderByContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = SLQParserRULE_orderBy return p } func (*OrderByContext) IsOrderByContext() {} func NewOrderByContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OrderByContext { var p = new(OrderByContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = SLQParserRULE_orderBy return p } func (s *OrderByContext) GetParser() antlr.Parser { return s.parser } func (s *OrderByContext) ORDER_BY() antlr.TerminalNode { return s.GetToken(SLQParserORDER_BY, 0) } func (s *OrderByContext) LPAR() antlr.TerminalNode { return s.GetToken(SLQParserLPAR, 0) } func (s *OrderByContext) AllOrderByTerm() []IOrderByTermContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IOrderByTermContext); ok { len++ } } tst := make([]IOrderByTermContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IOrderByTermContext); ok { tst[i] = t.(IOrderByTermContext) i++ } } return tst } func (s *OrderByContext) OrderByTerm(i int) IOrderByTermContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IOrderByTermContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IOrderByTermContext) } func (s *OrderByContext) RPAR() antlr.TerminalNode { return s.GetToken(SLQParserRPAR, 0) } func (s *OrderByContext) AllCOMMA() []antlr.TerminalNode { return s.GetTokens(SLQParserCOMMA) } func (s *OrderByContext) COMMA(i int) antlr.TerminalNode { return s.GetToken(SLQParserCOMMA, i) } func (s *OrderByContext) GetRuleContext() antlr.RuleContext { return s } func (s *OrderByContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *OrderByContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.EnterOrderBy(s) } } func (s *OrderByContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.ExitOrderBy(s) } } func (s *OrderByContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case SLQVisitor: return t.VisitOrderBy(s) default: return t.VisitChildren(s) } } func (p *SLQParser) OrderBy() (localctx IOrderByContext) { this := p _ = this localctx = NewOrderByContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 22, SLQParserRULE_orderBy) var _la int defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.EnterOuterAlt(localctx, 1) { p.SetState(144) p.Match(SLQParserORDER_BY) } { p.SetState(145) p.Match(SLQParserLPAR) } { p.SetState(146) p.OrderByTerm() } p.SetState(151) p.GetErrorHandler().Sync(p) _la = p.GetTokenStream().LA(1) for _la == SLQParserCOMMA { { p.SetState(147) p.Match(SLQParserCOMMA) } { p.SetState(148) p.OrderByTerm() } p.SetState(153) p.GetErrorHandler().Sync(p) _la = p.GetTokenStream().LA(1) } { p.SetState(154) p.Match(SLQParserRPAR) } return localctx } // ISelectorContext is an interface to support dynamic dispatch. type ISelectorContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures AllNAME() []antlr.TerminalNode NAME(i int) antlr.TerminalNode // IsSelectorContext differentiates from other interfaces. IsSelectorContext() } type SelectorContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySelectorContext() *SelectorContext { var p = new(SelectorContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = SLQParserRULE_selector return p } func (*SelectorContext) IsSelectorContext() {} func NewSelectorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectorContext { var p = new(SelectorContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = SLQParserRULE_selector return p } func (s *SelectorContext) GetParser() antlr.Parser { return s.parser } func (s *SelectorContext) AllNAME() []antlr.TerminalNode { return s.GetTokens(SLQParserNAME) } func (s *SelectorContext) NAME(i int) antlr.TerminalNode { return s.GetToken(SLQParserNAME, i) } func (s *SelectorContext) GetRuleContext() antlr.RuleContext { return s } func (s *SelectorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *SelectorContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.EnterSelector(s) } } func (s *SelectorContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.ExitSelector(s) } } func (s *SelectorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case SLQVisitor: return t.VisitSelector(s) default: return t.VisitChildren(s) } } func (p *SLQParser) Selector() (localctx ISelectorContext) { this := p _ = this localctx = NewSelectorContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 24, SLQParserRULE_selector) defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.EnterOuterAlt(localctx, 1) { p.SetState(156) p.Match(SLQParserNAME) } p.SetState(158) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 14, p.GetParserRuleContext()) == 1 { { p.SetState(157) p.Match(SLQParserNAME) } } return localctx } // ISelectorElementContext is an interface to support dynamic dispatch. type ISelectorElementContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Selector() ISelectorContext Alias() IAliasContext // IsSelectorElementContext differentiates from other interfaces. IsSelectorElementContext() } type SelectorElementContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptySelectorElementContext() *SelectorElementContext { var p = new(SelectorElementContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = SLQParserRULE_selectorElement return p } func (*SelectorElementContext) IsSelectorElementContext() {} func NewSelectorElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectorElementContext { var p = new(SelectorElementContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = SLQParserRULE_selectorElement return p } func (s *SelectorElementContext) GetParser() antlr.Parser { return s.parser } func (s *SelectorElementContext) Selector() ISelectorContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelectorContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISelectorContext) } func (s *SelectorElementContext) Alias() IAliasContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IAliasContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IAliasContext) } func (s *SelectorElementContext) GetRuleContext() antlr.RuleContext { return s } func (s *SelectorElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *SelectorElementContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.EnterSelectorElement(s) } } func (s *SelectorElementContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.ExitSelectorElement(s) } } func (s *SelectorElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case SLQVisitor: return t.VisitSelectorElement(s) default: return t.VisitChildren(s) } } func (p *SLQParser) SelectorElement() (localctx ISelectorElementContext) { this := p _ = this localctx = NewSelectorElementContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 26, SLQParserRULE_selectorElement) var _la int defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.EnterOuterAlt(localctx, 1) { p.SetState(160) p.Selector() } p.SetState(162) p.GetErrorHandler().Sync(p) _la = p.GetTokenStream().LA(1) if _la == SLQParserCOLON { { p.SetState(161) p.Alias() } } return localctx } // IAliasContext is an interface to support dynamic dispatch. type IAliasContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures COLON() antlr.TerminalNode ID() antlr.TerminalNode // IsAliasContext differentiates from other interfaces. IsAliasContext() } type AliasContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyAliasContext() *AliasContext { var p = new(AliasContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = SLQParserRULE_alias return p } func (*AliasContext) IsAliasContext() {} func NewAliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AliasContext { var p = new(AliasContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = SLQParserRULE_alias return p } func (s *AliasContext) GetParser() antlr.Parser { return s.parser } func (s *AliasContext) COLON() antlr.TerminalNode { return s.GetToken(SLQParserCOLON, 0) } func (s *AliasContext) ID() antlr.TerminalNode { return s.GetToken(SLQParserID, 0) } func (s *AliasContext) GetRuleContext() antlr.RuleContext { return s } func (s *AliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *AliasContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.EnterAlias(s) } } func (s *AliasContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.ExitAlias(s) } } func (s *AliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case SLQVisitor: return t.VisitAlias(s) default: return t.VisitChildren(s) } } func (p *SLQParser) Alias() (localctx IAliasContext) { this := p _ = this localctx = NewAliasContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 28, SLQParserRULE_alias) defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.EnterOuterAlt(localctx, 1) { p.SetState(164) p.Match(SLQParserCOLON) } { p.SetState(165) p.Match(SLQParserID) } return localctx } // IHandleTableContext is an interface to support dynamic dispatch. type IHandleTableContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures HANDLE() antlr.TerminalNode NAME() antlr.TerminalNode // IsHandleTableContext differentiates from other interfaces. IsHandleTableContext() } type HandleTableContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyHandleTableContext() *HandleTableContext { var p = new(HandleTableContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = SLQParserRULE_handleTable return p } func (*HandleTableContext) IsHandleTableContext() {} func NewHandleTableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HandleTableContext { var p = new(HandleTableContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = SLQParserRULE_handleTable return p } func (s *HandleTableContext) GetParser() antlr.Parser { return s.parser } func (s *HandleTableContext) HANDLE() antlr.TerminalNode { return s.GetToken(SLQParserHANDLE, 0) } func (s *HandleTableContext) NAME() antlr.TerminalNode { return s.GetToken(SLQParserNAME, 0) } func (s *HandleTableContext) GetRuleContext() antlr.RuleContext { return s } func (s *HandleTableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *HandleTableContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.EnterHandleTable(s) } } func (s *HandleTableContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.ExitHandleTable(s) } } func (s *HandleTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case SLQVisitor: return t.VisitHandleTable(s) default: return t.VisitChildren(s) } } func (p *SLQParser) HandleTable() (localctx IHandleTableContext) { this := p _ = this localctx = NewHandleTableContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 30, SLQParserRULE_handleTable) defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.EnterOuterAlt(localctx, 1) { p.SetState(167) p.Match(SLQParserHANDLE) } { p.SetState(168) p.Match(SLQParserNAME) } return localctx } // IHandleContext is an interface to support dynamic dispatch. type IHandleContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures HANDLE() antlr.TerminalNode // IsHandleContext differentiates from other interfaces. IsHandleContext() } type HandleContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyHandleContext() *HandleContext { var p = new(HandleContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = SLQParserRULE_handle return p } func (*HandleContext) IsHandleContext() {} func NewHandleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HandleContext { var p = new(HandleContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = SLQParserRULE_handle return p } func (s *HandleContext) GetParser() antlr.Parser { return s.parser } func (s *HandleContext) HANDLE() antlr.TerminalNode { return s.GetToken(SLQParserHANDLE, 0) } func (s *HandleContext) GetRuleContext() antlr.RuleContext { return s } func (s *HandleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *HandleContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.EnterHandle(s) } } func (s *HandleContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.ExitHandle(s) } } func (s *HandleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case SLQVisitor: return t.VisitHandle(s) default: return t.VisitChildren(s) } } func (p *SLQParser) Handle() (localctx IHandleContext) { this := p _ = this localctx = NewHandleContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 32, SLQParserRULE_handle) defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.EnterOuterAlt(localctx, 1) { p.SetState(170) p.Match(SLQParserHANDLE) } return localctx } // IRowRangeContext is an interface to support dynamic dispatch. type IRowRangeContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures RBRA() antlr.TerminalNode AllNN() []antlr.TerminalNode NN(i int) antlr.TerminalNode COLON() antlr.TerminalNode // IsRowRangeContext differentiates from other interfaces. IsRowRangeContext() } type RowRangeContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyRowRangeContext() *RowRangeContext { var p = new(RowRangeContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = SLQParserRULE_rowRange return p } func (*RowRangeContext) IsRowRangeContext() {} func NewRowRangeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RowRangeContext { var p = new(RowRangeContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = SLQParserRULE_rowRange return p } func (s *RowRangeContext) GetParser() antlr.Parser { return s.parser } func (s *RowRangeContext) RBRA() antlr.TerminalNode { return s.GetToken(SLQParserRBRA, 0) } func (s *RowRangeContext) AllNN() []antlr.TerminalNode { return s.GetTokens(SLQParserNN) } func (s *RowRangeContext) NN(i int) antlr.TerminalNode { return s.GetToken(SLQParserNN, i) } func (s *RowRangeContext) COLON() antlr.TerminalNode { return s.GetToken(SLQParserCOLON, 0) } func (s *RowRangeContext) GetRuleContext() antlr.RuleContext { return s } func (s *RowRangeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *RowRangeContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.EnterRowRange(s) } } func (s *RowRangeContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.ExitRowRange(s) } } func (s *RowRangeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case SLQVisitor: return t.VisitRowRange(s) default: return t.VisitChildren(s) } } func (p *SLQParser) RowRange() (localctx IRowRangeContext) { this := p _ = this localctx = NewRowRangeContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 34, SLQParserRULE_rowRange) defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.EnterOuterAlt(localctx, 1) { p.SetState(172) p.Match(SLQParserT__8) } p.SetState(181) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 16, p.GetParserRuleContext()) == 1 { { p.SetState(173) p.Match(SLQParserNN) } { p.SetState(174) p.Match(SLQParserCOLON) } { p.SetState(175) p.Match(SLQParserNN) } } else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 16, p.GetParserRuleContext()) == 2 { { p.SetState(176) p.Match(SLQParserNN) } { p.SetState(177) p.Match(SLQParserCOLON) } } else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 16, p.GetParserRuleContext()) == 3 { { p.SetState(178) p.Match(SLQParserCOLON) } { p.SetState(179) p.Match(SLQParserNN) } } else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 16, p.GetParserRuleContext()) == 4 { { p.SetState(180) p.Match(SLQParserNN) } } { p.SetState(183) p.Match(SLQParserRBRA) } return localctx } // IFnNameContext is an interface to support dynamic dispatch. type IFnNameContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // IsFnNameContext differentiates from other interfaces. IsFnNameContext() } type FnNameContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFnNameContext() *FnNameContext { var p = new(FnNameContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = SLQParserRULE_fnName return p } func (*FnNameContext) IsFnNameContext() {} func NewFnNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FnNameContext { var p = new(FnNameContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = SLQParserRULE_fnName return p } func (s *FnNameContext) GetParser() antlr.Parser { return s.parser } func (s *FnNameContext) GetRuleContext() antlr.RuleContext { return s } func (s *FnNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *FnNameContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.EnterFnName(s) } } func (s *FnNameContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.ExitFnName(s) } } func (s *FnNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case SLQVisitor: return t.VisitFnName(s) default: return t.VisitChildren(s) } } func (p *SLQParser) FnName() (localctx IFnNameContext) { this := p _ = this localctx = NewFnNameContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 36, SLQParserRULE_fnName) var _la int defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.EnterOuterAlt(localctx, 1) { p.SetState(185) _la = p.GetTokenStream().LA(1) if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&261120) != 0) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } return localctx } // IExprContext is an interface to support dynamic dispatch. type IExprContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Selector() ISelectorContext Literal() ILiteralContext UnaryOperator() IUnaryOperatorContext AllExpr() []IExprContext Expr(i int) IExprContext Fn() IFnContext ORDER_ASC() antlr.TerminalNode ORDER_DESC() antlr.TerminalNode LT() antlr.TerminalNode LT_EQ() antlr.TerminalNode GT() antlr.TerminalNode GT_EQ() antlr.TerminalNode EQ() antlr.TerminalNode NEQ() antlr.TerminalNode // IsExprContext differentiates from other interfaces. IsExprContext() } type ExprContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyExprContext() *ExprContext { var p = new(ExprContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = SLQParserRULE_expr return p } func (*ExprContext) IsExprContext() {} func NewExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExprContext { var p = new(ExprContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = SLQParserRULE_expr return p } func (s *ExprContext) GetParser() antlr.Parser { return s.parser } func (s *ExprContext) Selector() ISelectorContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelectorContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ISelectorContext) } func (s *ExprContext) Literal() ILiteralContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ILiteralContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ILiteralContext) } func (s *ExprContext) UnaryOperator() IUnaryOperatorContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IUnaryOperatorContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IUnaryOperatorContext) } func (s *ExprContext) AllExpr() []IExprContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IExprContext); ok { len++ } } tst := make([]IExprContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IExprContext); ok { tst[i] = t.(IExprContext) i++ } } return tst } func (s *ExprContext) Expr(i int) IExprContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IExprContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IExprContext) } func (s *ExprContext) Fn() IFnContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFnContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFnContext) } func (s *ExprContext) ORDER_ASC() antlr.TerminalNode { return s.GetToken(SLQParserORDER_ASC, 0) } func (s *ExprContext) ORDER_DESC() antlr.TerminalNode { return s.GetToken(SLQParserORDER_DESC, 0) } func (s *ExprContext) LT() antlr.TerminalNode { return s.GetToken(SLQParserLT, 0) } func (s *ExprContext) LT_EQ() antlr.TerminalNode { return s.GetToken(SLQParserLT_EQ, 0) } func (s *ExprContext) GT() antlr.TerminalNode { return s.GetToken(SLQParserGT, 0) } func (s *ExprContext) GT_EQ() antlr.TerminalNode { return s.GetToken(SLQParserGT_EQ, 0) } func (s *ExprContext) EQ() antlr.TerminalNode { return s.GetToken(SLQParserEQ, 0) } func (s *ExprContext) NEQ() antlr.TerminalNode { return s.GetToken(SLQParserNEQ, 0) } func (s *ExprContext) GetRuleContext() antlr.RuleContext { return s } func (s *ExprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ExprContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.EnterExpr(s) } } func (s *ExprContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.ExitExpr(s) } } func (s *ExprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case SLQVisitor: return t.VisitExpr(s) default: return t.VisitChildren(s) } } func (p *SLQParser) Expr() (localctx IExprContext) { return p.expr(0) } func (p *SLQParser) expr(_p int) (localctx IExprContext) { this := p _ = this var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() _parentState := p.GetState() localctx = NewExprContext(p, p.GetParserRuleContext(), _parentState) var _prevctx IExprContext = localctx var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. _startState := 38 p.EnterRecursionRule(localctx, 38, SLQParserRULE_expr, _p) var _la int defer func() { p.UnrollRecursionContexts(_parentctx) }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() var _alt int p.EnterOuterAlt(localctx, 1) p.SetState(194) p.GetErrorHandler().Sync(p) switch p.GetTokenStream().LA(1) { case SLQParserNAME: { p.SetState(188) p.Selector() } case SLQParserNULL, SLQParserNN, SLQParserNUMBER, SLQParserSTRING: { p.SetState(189) p.Literal() } case SLQParserT__24, SLQParserT__25, SLQParserORDER_ASC, SLQParserORDER_DESC: { p.SetState(190) p.UnaryOperator() } { p.SetState(191) p.expr(9) } case SLQParserT__9, SLQParserT__10, SLQParserT__11, SLQParserT__12, SLQParserT__13, SLQParserT__14, SLQParserT__15, SLQParserT__16: { p.SetState(193) p.Fn() } default: panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) } p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) p.SetState(223) p.GetErrorHandler().Sync(p) _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 20, p.GetParserRuleContext()) for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { if _alt == 1 { if p.GetParseListeners() != nil { p.TriggerExitRuleEvent() } _prevctx = localctx p.SetState(221) p.GetErrorHandler().Sync(p) switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 19, p.GetParserRuleContext()) { case 1: localctx = NewExprContext(p, _parentctx, _parentState) p.PushNewRecursionContext(localctx, _startState, SLQParserRULE_expr) p.SetState(196) if !(p.Precpred(p.GetParserRuleContext(), 8)) { panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 8)", "")) } { p.SetState(197) p.Match(SLQParserT__17) } { p.SetState(198) p.expr(9) } case 2: localctx = NewExprContext(p, _parentctx, _parentState) p.PushNewRecursionContext(localctx, _startState, SLQParserRULE_expr) p.SetState(199) if !(p.Precpred(p.GetParserRuleContext(), 7)) { panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 7)", "")) } { p.SetState(200) _la = p.GetTokenStream().LA(1) if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&1572868) != 0) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } { p.SetState(201) p.expr(8) } case 3: localctx = NewExprContext(p, _parentctx, _parentState) p.PushNewRecursionContext(localctx, _startState, SLQParserRULE_expr) p.SetState(202) if !(p.Precpred(p.GetParserRuleContext(), 6)) { panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 6)", "")) } { p.SetState(203) _la = p.GetTokenStream().LA(1) if !(_la == SLQParserORDER_ASC || _la == SLQParserORDER_DESC) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } { p.SetState(204) p.expr(7) } case 4: localctx = NewExprContext(p, _parentctx, _parentState) p.PushNewRecursionContext(localctx, _startState, SLQParserRULE_expr) p.SetState(205) if !(p.Precpred(p.GetParserRuleContext(), 5)) { panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 5)", "")) } { p.SetState(206) _la = p.GetTokenStream().LA(1) if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&14680064) != 0) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } { p.SetState(207) p.expr(6) } case 5: localctx = NewExprContext(p, _parentctx, _parentState) p.PushNewRecursionContext(localctx, _startState, SLQParserRULE_expr) p.SetState(208) if !(p.Precpred(p.GetParserRuleContext(), 4)) { panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 4)", "")) } { p.SetState(209) _la = p.GetTokenStream().LA(1) if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&65970697666560) != 0) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } { p.SetState(210) p.expr(5) } case 6: localctx = NewExprContext(p, _parentctx, _parentState) p.PushNewRecursionContext(localctx, _startState, SLQParserRULE_expr) p.SetState(211) if !(p.Precpred(p.GetParserRuleContext(), 3)) { panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", "")) } p.SetState(215) p.GetErrorHandler().Sync(p) switch p.GetTokenStream().LA(1) { case SLQParserEQ: { p.SetState(212) p.Match(SLQParserEQ) } case SLQParserNEQ: { p.SetState(213) p.Match(SLQParserNEQ) } case SLQParserT__9, SLQParserT__10, SLQParserT__11, SLQParserT__12, SLQParserT__13, SLQParserT__14, SLQParserT__15, SLQParserT__16, SLQParserT__24, SLQParserT__25, SLQParserORDER_ASC, SLQParserORDER_DESC, SLQParserNULL, SLQParserNN, SLQParserNUMBER, SLQParserNAME, SLQParserSTRING: default: panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) } { p.SetState(217) p.expr(4) } case 7: localctx = NewExprContext(p, _parentctx, _parentState) p.PushNewRecursionContext(localctx, _startState, SLQParserRULE_expr) p.SetState(218) if !(p.Precpred(p.GetParserRuleContext(), 2)) { panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", "")) } { p.SetState(219) p.Match(SLQParserT__23) } { p.SetState(220) p.expr(3) } } } p.SetState(225) p.GetErrorHandler().Sync(p) _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 20, p.GetParserRuleContext()) } return localctx } // ILiteralContext is an interface to support dynamic dispatch. type ILiteralContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures NN() antlr.TerminalNode NUMBER() antlr.TerminalNode STRING() antlr.TerminalNode NULL() antlr.TerminalNode // IsLiteralContext differentiates from other interfaces. IsLiteralContext() } type LiteralContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyLiteralContext() *LiteralContext { var p = new(LiteralContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = SLQParserRULE_literal return p } func (*LiteralContext) IsLiteralContext() {} func NewLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LiteralContext { var p = new(LiteralContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = SLQParserRULE_literal return p } func (s *LiteralContext) GetParser() antlr.Parser { return s.parser } func (s *LiteralContext) NN() antlr.TerminalNode { return s.GetToken(SLQParserNN, 0) } func (s *LiteralContext) NUMBER() antlr.TerminalNode { return s.GetToken(SLQParserNUMBER, 0) } func (s *LiteralContext) STRING() antlr.TerminalNode { return s.GetToken(SLQParserSTRING, 0) } func (s *LiteralContext) NULL() antlr.TerminalNode { return s.GetToken(SLQParserNULL, 0) } func (s *LiteralContext) GetRuleContext() antlr.RuleContext { return s } func (s *LiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *LiteralContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.EnterLiteral(s) } } func (s *LiteralContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.ExitLiteral(s) } } func (s *LiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case SLQVisitor: return t.VisitLiteral(s) default: return t.VisitChildren(s) } } func (p *SLQParser) Literal() (localctx ILiteralContext) { this := p _ = this localctx = NewLiteralContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 40, SLQParserRULE_literal) var _la int defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.EnterOuterAlt(localctx, 1) { p.SetState(226) _la = p.GetTokenStream().LA(1) if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&1129748197539840) != 0) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } return localctx } // IUnaryOperatorContext is an interface to support dynamic dispatch. type IUnaryOperatorContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ORDER_DESC() antlr.TerminalNode ORDER_ASC() antlr.TerminalNode // IsUnaryOperatorContext differentiates from other interfaces. IsUnaryOperatorContext() } type UnaryOperatorContext struct { *antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyUnaryOperatorContext() *UnaryOperatorContext { var p = new(UnaryOperatorContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) p.RuleIndex = SLQParserRULE_unaryOperator return p } func (*UnaryOperatorContext) IsUnaryOperatorContext() {} func NewUnaryOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnaryOperatorContext { var p = new(UnaryOperatorContext) p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) p.parser = parser p.RuleIndex = SLQParserRULE_unaryOperator return p } func (s *UnaryOperatorContext) GetParser() antlr.Parser { return s.parser } func (s *UnaryOperatorContext) ORDER_DESC() antlr.TerminalNode { return s.GetToken(SLQParserORDER_DESC, 0) } func (s *UnaryOperatorContext) ORDER_ASC() antlr.TerminalNode { return s.GetToken(SLQParserORDER_ASC, 0) } func (s *UnaryOperatorContext) GetRuleContext() antlr.RuleContext { return s } func (s *UnaryOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *UnaryOperatorContext) EnterRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.EnterUnaryOperator(s) } } func (s *UnaryOperatorContext) ExitRule(listener antlr.ParseTreeListener) { if listenerT, ok := listener.(SLQListener); ok { listenerT.ExitUnaryOperator(s) } } func (s *UnaryOperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case SLQVisitor: return t.VisitUnaryOperator(s) default: return t.VisitChildren(s) } } func (p *SLQParser) UnaryOperator() (localctx IUnaryOperatorContext) { this := p _ = this localctx = NewUnaryOperatorContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 42, SLQParserRULE_unaryOperator) var _la int defer func() { p.ExitRule() }() defer func() { if err := recover(); err != nil { if v, ok := err.(antlr.RecognitionException); ok { localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) } else { panic(err) } } }() p.EnterOuterAlt(localctx, 1) { p.SetState(228) _la = p.GetTokenStream().LA(1) if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&503316480) != 0) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } return localctx } func (p *SLQParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool { switch ruleIndex { case 19: var t *ExprContext = nil if localctx != nil { t = localctx.(*ExprContext) } return p.Expr_Sempred(t, predIndex) default: panic("No predicate with index: " + fmt.Sprint(ruleIndex)) } } func (p *SLQParser) Expr_Sempred(localctx antlr.RuleContext, predIndex int) bool { this := p _ = this switch predIndex { case 0: return p.Precpred(p.GetParserRuleContext(), 8) case 1: return p.Precpred(p.GetParserRuleContext(), 7) case 2: return p.Precpred(p.GetParserRuleContext(), 6) case 3: return p.Precpred(p.GetParserRuleContext(), 5) case 4: return p.Precpred(p.GetParserRuleContext(), 4) case 5: return p.Precpred(p.GetParserRuleContext(), 3) case 6: return p.Precpred(p.GetParserRuleContext(), 2) default: panic("No predicate with index: " + fmt.Sprint(predIndex)) } }