package parser // Query import ( "fmt" "strconv" "sync" "github.com/antlr4-go/antlr/v4" ) // Suppress unused import errors var _ = fmt.Printf var _ = strconv.Itoa var _ = sync.Once{} type Query struct { *antlr.BaseParser } var QueryParserStaticData struct { once sync.Once serializedATN []int32 LiteralNames []string SymbolicNames []string RuleNames []string PredictionContextCache *antlr.PredictionContextCache atn *antlr.ATN decisionToDFA []*antlr.DFA } func queryParserInit() { staticData := &QueryParserStaticData staticData.LiteralNames = []string{ "", "'NOT'", "'AND'", "'OR'", "", "'REP'", "'IN'", "'AS'", "'CBF'", "'SELECT'", "'FROM'", "'FILTER'", "'*'", "'SAME'", "'DISTINCT'", "'('", "')'", "'@'", "", "", "'0'", } staticData.SymbolicNames = []string{ "", "NOT_OP", "AND_OP", "OR_OP", "SIMPLE_OP", "REP", "IN", "AS", "CBF", "SELECT", "FROM", "FILTER", "WILDCARD", "CLAUSE_SAME", "CLAUSE_DISTINCT", "L_PAREN", "R_PAREN", "AT", "IDENT", "NUMBER1", "ZERO", "STRING", "WS", } staticData.RuleNames = []string{ "policy", "repStmt", "cbfStmt", "selectStmt", "clause", "filterExpr", "filterStmt", "expr", "filterKey", "filterValue", "number", "keyword", "ident", "identWC", } staticData.PredictionContextCache = antlr.NewPredictionContextCache() staticData.serializedATN = []int32{ 4, 1, 22, 135, 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, 1, 0, 4, 0, 30, 8, 0, 11, 0, 12, 0, 31, 1, 0, 3, 0, 35, 8, 0, 1, 0, 5, 0, 38, 8, 0, 10, 0, 12, 0, 41, 9, 0, 1, 0, 5, 0, 44, 8, 0, 10, 0, 12, 0, 47, 9, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 55, 8, 1, 1, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 3, 3, 64, 8, 3, 1, 3, 3, 3, 67, 8, 3, 1, 3, 1, 3, 1, 3, 1, 3, 3, 3, 73, 8, 3, 1, 4, 1, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 88, 8, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 5, 5, 96, 8, 5, 10, 5, 12, 5, 99, 9, 5, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 3, 7, 112, 8, 7, 1, 8, 1, 8, 3, 8, 116, 8, 8, 1, 9, 1, 9, 1, 9, 3, 9, 121, 8, 9, 1, 10, 1, 10, 1, 11, 1, 11, 1, 12, 1, 12, 3, 12, 129, 8, 12, 1, 13, 1, 13, 3, 13, 133, 8, 13, 1, 13, 0, 1, 10, 14, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 0, 3, 1, 0, 13, 14, 1, 0, 19, 20, 2, 0, 5, 7, 9, 11, 138, 0, 29, 1, 0, 0, 0, 2, 50, 1, 0, 0, 0, 4, 56, 1, 0, 0, 0, 6, 59, 1, 0, 0, 0, 8, 74, 1, 0, 0, 0, 10, 87, 1, 0, 0, 0, 12, 100, 1, 0, 0, 0, 14, 111, 1, 0, 0, 0, 16, 115, 1, 0, 0, 0, 18, 120, 1, 0, 0, 0, 20, 122, 1, 0, 0, 0, 22, 124, 1, 0, 0, 0, 24, 128, 1, 0, 0, 0, 26, 132, 1, 0, 0, 0, 28, 30, 3, 2, 1, 0, 29, 28, 1, 0, 0, 0, 30, 31, 1, 0, 0, 0, 31, 29, 1, 0, 0, 0, 31, 32, 1, 0, 0, 0, 32, 34, 1, 0, 0, 0, 33, 35, 3, 4, 2, 0, 34, 33, 1, 0, 0, 0, 34, 35, 1, 0, 0, 0, 35, 39, 1, 0, 0, 0, 36, 38, 3, 6, 3, 0, 37, 36, 1, 0, 0, 0, 38, 41, 1, 0, 0, 0, 39, 37, 1, 0, 0, 0, 39, 40, 1, 0, 0, 0, 40, 45, 1, 0, 0, 0, 41, 39, 1, 0, 0, 0, 42, 44, 3, 12, 6, 0, 43, 42, 1, 0, 0, 0, 44, 47, 1, 0, 0, 0, 45, 43, 1, 0, 0, 0, 45, 46, 1, 0, 0, 0, 46, 48, 1, 0, 0, 0, 47, 45, 1, 0, 0, 0, 48, 49, 5, 0, 0, 1, 49, 1, 1, 0, 0, 0, 50, 51, 5, 5, 0, 0, 51, 54, 5, 19, 0, 0, 52, 53, 5, 6, 0, 0, 53, 55, 3, 24, 12, 0, 54, 52, 1, 0, 0, 0, 54, 55, 1, 0, 0, 0, 55, 3, 1, 0, 0, 0, 56, 57, 5, 8, 0, 0, 57, 58, 5, 19, 0, 0, 58, 5, 1, 0, 0, 0, 59, 60, 5, 9, 0, 0, 60, 66, 5, 19, 0, 0, 61, 63, 5, 6, 0, 0, 62, 64, 3, 8, 4, 0, 63, 62, 1, 0, 0, 0, 63, 64, 1, 0, 0, 0, 64, 65, 1, 0, 0, 0, 65, 67, 3, 24, 12, 0, 66, 61, 1, 0, 0, 0, 66, 67, 1, 0, 0, 0, 67, 68, 1, 0, 0, 0, 68, 69, 5, 10, 0, 0, 69, 72, 3, 26, 13, 0, 70, 71, 5, 7, 0, 0, 71, 73, 3, 24, 12, 0, 72, 70, 1, 0, 0, 0, 72, 73, 1, 0, 0, 0, 73, 7, 1, 0, 0, 0, 74, 75, 7, 0, 0, 0, 75, 9, 1, 0, 0, 0, 76, 77, 6, 5, -1, 0, 77, 78, 5, 1, 0, 0, 78, 79, 5, 15, 0, 0, 79, 80, 3, 10, 5, 0, 80, 81, 5, 16, 0, 0, 81, 88, 1, 0, 0, 0, 82, 83, 5, 15, 0, 0, 83, 84, 3, 10, 5, 0, 84, 85, 5, 16, 0, 0, 85, 88, 1, 0, 0, 0, 86, 88, 3, 14, 7, 0, 87, 76, 1, 0, 0, 0, 87, 82, 1, 0, 0, 0, 87, 86, 1, 0, 0, 0, 88, 97, 1, 0, 0, 0, 89, 90, 10, 4, 0, 0, 90, 91, 5, 2, 0, 0, 91, 96, 3, 10, 5, 5, 92, 93, 10, 3, 0, 0, 93, 94, 5, 3, 0, 0, 94, 96, 3, 10, 5, 4, 95, 89, 1, 0, 0, 0, 95, 92, 1, 0, 0, 0, 96, 99, 1, 0, 0, 0, 97, 95, 1, 0, 0, 0, 97, 98, 1, 0, 0, 0, 98, 11, 1, 0, 0, 0, 99, 97, 1, 0, 0, 0, 100, 101, 5, 11, 0, 0, 101, 102, 3, 10, 5, 0, 102, 103, 5, 7, 0, 0, 103, 104, 3, 24, 12, 0, 104, 13, 1, 0, 0, 0, 105, 106, 5, 17, 0, 0, 106, 112, 3, 24, 12, 0, 107, 108, 3, 16, 8, 0, 108, 109, 5, 4, 0, 0, 109, 110, 3, 18, 9, 0, 110, 112, 1, 0, 0, 0, 111, 105, 1, 0, 0, 0, 111, 107, 1, 0, 0, 0, 112, 15, 1, 0, 0, 0, 113, 116, 3, 24, 12, 0, 114, 116, 5, 21, 0, 0, 115, 113, 1, 0, 0, 0, 115, 114, 1, 0, 0, 0, 116, 17, 1, 0, 0, 0, 117, 121, 3, 24, 12, 0, 118, 121, 3, 20, 10, 0, 119, 121, 5, 21, 0, 0, 120, 117, 1, 0, 0, 0, 120, 118, 1, 0, 0, 0, 120, 119, 1, 0, 0, 0, 121, 19, 1, 0, 0, 0, 122, 123, 7, 1, 0, 0, 123, 21, 1, 0, 0, 0, 124, 125, 7, 2, 0, 0, 125, 23, 1, 0, 0, 0, 126, 129, 3, 22, 11, 0, 127, 129, 5, 18, 0, 0, 128, 126, 1, 0, 0, 0, 128, 127, 1, 0, 0, 0, 129, 25, 1, 0, 0, 0, 130, 133, 3, 24, 12, 0, 131, 133, 5, 12, 0, 0, 132, 130, 1, 0, 0, 0, 132, 131, 1, 0, 0, 0, 133, 27, 1, 0, 0, 0, 16, 31, 34, 39, 45, 54, 63, 66, 72, 87, 95, 97, 111, 115, 120, 128, 132, } 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) } } // QueryInit initializes any static state used to implement Query. By default the // static state used to implement the parser is lazily initialized during the first call to // NewQuery(). You can call this function if you wish to initialize the static state ahead // of time. func QueryInit() { staticData := &QueryParserStaticData staticData.once.Do(queryParserInit) } // NewQuery produces a new parser instance for the optional input antlr.TokenStream. func NewQuery(input antlr.TokenStream) *Query { QueryInit() this := new(Query) this.BaseParser = antlr.NewBaseParser(input) staticData := &QueryParserStaticData 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 = "Query.g4" return this } // Query tokens. const ( QueryEOF = antlr.TokenEOF QueryNOT_OP = 1 QueryAND_OP = 2 QueryOR_OP = 3 QuerySIMPLE_OP = 4 QueryREP = 5 QueryIN = 6 QueryAS = 7 QueryCBF = 8 QuerySELECT = 9 QueryFROM = 10 QueryFILTER = 11 QueryWILDCARD = 12 QueryCLAUSE_SAME = 13 QueryCLAUSE_DISTINCT = 14 QueryL_PAREN = 15 QueryR_PAREN = 16 QueryAT = 17 QueryIDENT = 18 QueryNUMBER1 = 19 QueryZERO = 20 QuerySTRING = 21 QueryWS = 22 ) // Query rules. const ( QueryRULE_policy = 0 QueryRULE_repStmt = 1 QueryRULE_cbfStmt = 2 QueryRULE_selectStmt = 3 QueryRULE_clause = 4 QueryRULE_filterExpr = 5 QueryRULE_filterStmt = 6 QueryRULE_expr = 7 QueryRULE_filterKey = 8 QueryRULE_filterValue = 9 QueryRULE_number = 10 QueryRULE_keyword = 11 QueryRULE_ident = 12 QueryRULE_identWC = 13 ) // IPolicyContext is an interface to support dynamic dispatch. type IPolicyContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures EOF() antlr.TerminalNode AllRepStmt() []IRepStmtContext RepStmt(i int) IRepStmtContext CbfStmt() ICbfStmtContext AllSelectStmt() []ISelectStmtContext SelectStmt(i int) ISelectStmtContext AllFilterStmt() []IFilterStmtContext FilterStmt(i int) IFilterStmtContext // IsPolicyContext differentiates from other interfaces. IsPolicyContext() } type PolicyContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyPolicyContext() *PolicyContext { var p = new(PolicyContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = QueryRULE_policy return p } func InitEmptyPolicyContext(p *PolicyContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = QueryRULE_policy } func (*PolicyContext) IsPolicyContext() {} func NewPolicyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PolicyContext { var p = new(PolicyContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = QueryRULE_policy return p } func (s *PolicyContext) GetParser() antlr.Parser { return s.parser } func (s *PolicyContext) EOF() antlr.TerminalNode { return s.GetToken(QueryEOF, 0) } func (s *PolicyContext) AllRepStmt() []IRepStmtContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IRepStmtContext); ok { len++ } } tst := make([]IRepStmtContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IRepStmtContext); ok { tst[i] = t.(IRepStmtContext) i++ } } return tst } func (s *PolicyContext) RepStmt(i int) IRepStmtContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IRepStmtContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IRepStmtContext) } func (s *PolicyContext) CbfStmt() ICbfStmtContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(ICbfStmtContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(ICbfStmtContext) } func (s *PolicyContext) AllSelectStmt() []ISelectStmtContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(ISelectStmtContext); ok { len++ } } tst := make([]ISelectStmtContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(ISelectStmtContext); ok { tst[i] = t.(ISelectStmtContext) i++ } } return tst } func (s *PolicyContext) SelectStmt(i int) ISelectStmtContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(ISelectStmtContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(ISelectStmtContext) } func (s *PolicyContext) AllFilterStmt() []IFilterStmtContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IFilterStmtContext); ok { len++ } } tst := make([]IFilterStmtContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IFilterStmtContext); ok { tst[i] = t.(IFilterStmtContext) i++ } } return tst } func (s *PolicyContext) FilterStmt(i int) IFilterStmtContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFilterStmtContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IFilterStmtContext) } func (s *PolicyContext) GetRuleContext() antlr.RuleContext { return s } func (s *PolicyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *PolicyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case QueryVisitor: return t.VisitPolicy(s) default: return t.VisitChildren(s) } } func (p *Query) Policy() (localctx IPolicyContext) { localctx = NewPolicyContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 0, QueryRULE_policy) var _la int p.EnterOuterAlt(localctx, 1) p.SetState(29) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for ok := true; ok; ok = _la == QueryREP { { p.SetState(28) p.RepStmt() } p.SetState(31) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } p.SetState(34) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == QueryCBF { { p.SetState(33) p.CbfStmt() } } p.SetState(39) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == QuerySELECT { { p.SetState(36) p.SelectStmt() } p.SetState(41) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } p.SetState(45) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) for _la == QueryFILTER { { p.SetState(42) p.FilterStmt() } p.SetState(47) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } { p.SetState(48) p.Match(QueryEOF) if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IRepStmtContext is an interface to support dynamic dispatch. type IRepStmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // GetCount returns the Count token. GetCount() antlr.Token // SetCount sets the Count token. SetCount(antlr.Token) // GetSelector returns the Selector rule contexts. GetSelector() IIdentContext // SetSelector sets the Selector rule contexts. SetSelector(IIdentContext) // Getter signatures REP() antlr.TerminalNode NUMBER1() antlr.TerminalNode IN() antlr.TerminalNode Ident() IIdentContext // IsRepStmtContext differentiates from other interfaces. IsRepStmtContext() } type RepStmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser Count antlr.Token Selector IIdentContext } func NewEmptyRepStmtContext() *RepStmtContext { var p = new(RepStmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = QueryRULE_repStmt return p } func InitEmptyRepStmtContext(p *RepStmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = QueryRULE_repStmt } func (*RepStmtContext) IsRepStmtContext() {} func NewRepStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RepStmtContext { var p = new(RepStmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = QueryRULE_repStmt return p } func (s *RepStmtContext) GetParser() antlr.Parser { return s.parser } func (s *RepStmtContext) GetCount() antlr.Token { return s.Count } func (s *RepStmtContext) SetCount(v antlr.Token) { s.Count = v } func (s *RepStmtContext) GetSelector() IIdentContext { return s.Selector } func (s *RepStmtContext) SetSelector(v IIdentContext) { s.Selector = v } func (s *RepStmtContext) REP() antlr.TerminalNode { return s.GetToken(QueryREP, 0) } func (s *RepStmtContext) NUMBER1() antlr.TerminalNode { return s.GetToken(QueryNUMBER1, 0) } func (s *RepStmtContext) IN() antlr.TerminalNode { return s.GetToken(QueryIN, 0) } func (s *RepStmtContext) Ident() IIdentContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIdentContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIdentContext) } func (s *RepStmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *RepStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *RepStmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case QueryVisitor: return t.VisitRepStmt(s) default: return t.VisitChildren(s) } } func (p *Query) RepStmt() (localctx IRepStmtContext) { localctx = NewRepStmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 2, QueryRULE_repStmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(50) p.Match(QueryREP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(51) var _m = p.Match(QueryNUMBER1) localctx.(*RepStmtContext).Count = _m if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(54) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == QueryIN { { p.SetState(52) p.Match(QueryIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(53) var _x = p.Ident() localctx.(*RepStmtContext).Selector = _x } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ICbfStmtContext is an interface to support dynamic dispatch. type ICbfStmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // GetBackupFactor returns the BackupFactor token. GetBackupFactor() antlr.Token // SetBackupFactor sets the BackupFactor token. SetBackupFactor(antlr.Token) // Getter signatures CBF() antlr.TerminalNode NUMBER1() antlr.TerminalNode // IsCbfStmtContext differentiates from other interfaces. IsCbfStmtContext() } type CbfStmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser BackupFactor antlr.Token } func NewEmptyCbfStmtContext() *CbfStmtContext { var p = new(CbfStmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = QueryRULE_cbfStmt return p } func InitEmptyCbfStmtContext(p *CbfStmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = QueryRULE_cbfStmt } func (*CbfStmtContext) IsCbfStmtContext() {} func NewCbfStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CbfStmtContext { var p = new(CbfStmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = QueryRULE_cbfStmt return p } func (s *CbfStmtContext) GetParser() antlr.Parser { return s.parser } func (s *CbfStmtContext) GetBackupFactor() antlr.Token { return s.BackupFactor } func (s *CbfStmtContext) SetBackupFactor(v antlr.Token) { s.BackupFactor = v } func (s *CbfStmtContext) CBF() antlr.TerminalNode { return s.GetToken(QueryCBF, 0) } func (s *CbfStmtContext) NUMBER1() antlr.TerminalNode { return s.GetToken(QueryNUMBER1, 0) } func (s *CbfStmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *CbfStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *CbfStmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case QueryVisitor: return t.VisitCbfStmt(s) default: return t.VisitChildren(s) } } func (p *Query) CbfStmt() (localctx ICbfStmtContext) { localctx = NewCbfStmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 4, QueryRULE_cbfStmt) p.EnterOuterAlt(localctx, 1) { p.SetState(56) p.Match(QueryCBF) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(57) var _m = p.Match(QueryNUMBER1) localctx.(*CbfStmtContext).BackupFactor = _m if p.HasError() { // Recognition error - abort rule goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // ISelectStmtContext is an interface to support dynamic dispatch. type ISelectStmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // GetCount returns the Count token. GetCount() antlr.Token // SetCount sets the Count token. SetCount(antlr.Token) // GetBucket returns the Bucket rule contexts. GetBucket() IIdentContext // GetFilter returns the Filter rule contexts. GetFilter() IIdentWCContext // GetName returns the Name rule contexts. GetName() IIdentContext // SetBucket sets the Bucket rule contexts. SetBucket(IIdentContext) // SetFilter sets the Filter rule contexts. SetFilter(IIdentWCContext) // SetName sets the Name rule contexts. SetName(IIdentContext) // Getter signatures SELECT() antlr.TerminalNode FROM() antlr.TerminalNode NUMBER1() antlr.TerminalNode IdentWC() IIdentWCContext IN() antlr.TerminalNode AS() antlr.TerminalNode AllIdent() []IIdentContext Ident(i int) IIdentContext Clause() IClauseContext // IsSelectStmtContext differentiates from other interfaces. IsSelectStmtContext() } type SelectStmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser Count antlr.Token Bucket IIdentContext Filter IIdentWCContext Name IIdentContext } func NewEmptySelectStmtContext() *SelectStmtContext { var p = new(SelectStmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = QueryRULE_selectStmt return p } func InitEmptySelectStmtContext(p *SelectStmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = QueryRULE_selectStmt } func (*SelectStmtContext) IsSelectStmtContext() {} func NewSelectStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectStmtContext { var p = new(SelectStmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = QueryRULE_selectStmt return p } func (s *SelectStmtContext) GetParser() antlr.Parser { return s.parser } func (s *SelectStmtContext) GetCount() antlr.Token { return s.Count } func (s *SelectStmtContext) SetCount(v antlr.Token) { s.Count = v } func (s *SelectStmtContext) GetBucket() IIdentContext { return s.Bucket } func (s *SelectStmtContext) GetFilter() IIdentWCContext { return s.Filter } func (s *SelectStmtContext) GetName() IIdentContext { return s.Name } func (s *SelectStmtContext) SetBucket(v IIdentContext) { s.Bucket = v } func (s *SelectStmtContext) SetFilter(v IIdentWCContext) { s.Filter = v } func (s *SelectStmtContext) SetName(v IIdentContext) { s.Name = v } func (s *SelectStmtContext) SELECT() antlr.TerminalNode { return s.GetToken(QuerySELECT, 0) } func (s *SelectStmtContext) FROM() antlr.TerminalNode { return s.GetToken(QueryFROM, 0) } func (s *SelectStmtContext) NUMBER1() antlr.TerminalNode { return s.GetToken(QueryNUMBER1, 0) } func (s *SelectStmtContext) IdentWC() IIdentWCContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIdentWCContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIdentWCContext) } func (s *SelectStmtContext) IN() antlr.TerminalNode { return s.GetToken(QueryIN, 0) } func (s *SelectStmtContext) AS() antlr.TerminalNode { return s.GetToken(QueryAS, 0) } func (s *SelectStmtContext) AllIdent() []IIdentContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IIdentContext); ok { len++ } } tst := make([]IIdentContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IIdentContext); ok { tst[i] = t.(IIdentContext) i++ } } return tst } func (s *SelectStmtContext) Ident(i int) IIdentContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIdentContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IIdentContext) } func (s *SelectStmtContext) Clause() IClauseContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IClauseContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IClauseContext) } func (s *SelectStmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *SelectStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *SelectStmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case QueryVisitor: return t.VisitSelectStmt(s) default: return t.VisitChildren(s) } } func (p *Query) SelectStmt() (localctx ISelectStmtContext) { localctx = NewSelectStmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 6, QueryRULE_selectStmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(59) p.Match(QuerySELECT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(60) var _m = p.Match(QueryNUMBER1) localctx.(*SelectStmtContext).Count = _m if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(66) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == QueryIN { { p.SetState(61) p.Match(QueryIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } p.SetState(63) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == QueryCLAUSE_SAME || _la == QueryCLAUSE_DISTINCT { { p.SetState(62) p.Clause() } } { p.SetState(65) var _x = p.Ident() localctx.(*SelectStmtContext).Bucket = _x } } { p.SetState(68) p.Match(QueryFROM) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(69) var _x = p.IdentWC() localctx.(*SelectStmtContext).Filter = _x } p.SetState(72) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) if _la == QueryAS { { p.SetState(70) p.Match(QueryAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(71) var _x = p.Ident() localctx.(*SelectStmtContext).Name = _x } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IClauseContext is an interface to support dynamic dispatch. type IClauseContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures CLAUSE_SAME() antlr.TerminalNode CLAUSE_DISTINCT() antlr.TerminalNode // IsClauseContext differentiates from other interfaces. IsClauseContext() } type ClauseContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyClauseContext() *ClauseContext { var p = new(ClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = QueryRULE_clause return p } func InitEmptyClauseContext(p *ClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = QueryRULE_clause } func (*ClauseContext) IsClauseContext() {} func NewClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClauseContext { var p = new(ClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = QueryRULE_clause return p } func (s *ClauseContext) GetParser() antlr.Parser { return s.parser } func (s *ClauseContext) CLAUSE_SAME() antlr.TerminalNode { return s.GetToken(QueryCLAUSE_SAME, 0) } func (s *ClauseContext) CLAUSE_DISTINCT() antlr.TerminalNode { return s.GetToken(QueryCLAUSE_DISTINCT, 0) } func (s *ClauseContext) GetRuleContext() antlr.RuleContext { return s } func (s *ClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *ClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case QueryVisitor: return t.VisitClause(s) default: return t.VisitChildren(s) } } func (p *Query) Clause() (localctx IClauseContext) { localctx = NewClauseContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 8, QueryRULE_clause) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(74) _la = p.GetTokenStream().LA(1) if !(_la == QueryCLAUSE_SAME || _la == QueryCLAUSE_DISTINCT) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFilterExprContext is an interface to support dynamic dispatch. type IFilterExprContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // GetOp returns the Op token. GetOp() antlr.Token // SetOp sets the Op token. SetOp(antlr.Token) // GetF1 returns the F1 rule contexts. GetF1() IFilterExprContext // GetInner returns the Inner rule contexts. GetInner() IFilterExprContext // GetF2 returns the F2 rule contexts. GetF2() IFilterExprContext // SetF1 sets the F1 rule contexts. SetF1(IFilterExprContext) // SetInner sets the Inner rule contexts. SetInner(IFilterExprContext) // SetF2 sets the F2 rule contexts. SetF2(IFilterExprContext) // Getter signatures L_PAREN() antlr.TerminalNode R_PAREN() antlr.TerminalNode NOT_OP() antlr.TerminalNode AllFilterExpr() []IFilterExprContext FilterExpr(i int) IFilterExprContext Expr() IExprContext AND_OP() antlr.TerminalNode OR_OP() antlr.TerminalNode // IsFilterExprContext differentiates from other interfaces. IsFilterExprContext() } type FilterExprContext struct { antlr.BaseParserRuleContext parser antlr.Parser F1 IFilterExprContext Op antlr.Token Inner IFilterExprContext F2 IFilterExprContext } func NewEmptyFilterExprContext() *FilterExprContext { var p = new(FilterExprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = QueryRULE_filterExpr return p } func InitEmptyFilterExprContext(p *FilterExprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = QueryRULE_filterExpr } func (*FilterExprContext) IsFilterExprContext() {} func NewFilterExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FilterExprContext { var p = new(FilterExprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = QueryRULE_filterExpr return p } func (s *FilterExprContext) GetParser() antlr.Parser { return s.parser } func (s *FilterExprContext) GetOp() antlr.Token { return s.Op } func (s *FilterExprContext) SetOp(v antlr.Token) { s.Op = v } func (s *FilterExprContext) GetF1() IFilterExprContext { return s.F1 } func (s *FilterExprContext) GetInner() IFilterExprContext { return s.Inner } func (s *FilterExprContext) GetF2() IFilterExprContext { return s.F2 } func (s *FilterExprContext) SetF1(v IFilterExprContext) { s.F1 = v } func (s *FilterExprContext) SetInner(v IFilterExprContext) { s.Inner = v } func (s *FilterExprContext) SetF2(v IFilterExprContext) { s.F2 = v } func (s *FilterExprContext) L_PAREN() antlr.TerminalNode { return s.GetToken(QueryL_PAREN, 0) } func (s *FilterExprContext) R_PAREN() antlr.TerminalNode { return s.GetToken(QueryR_PAREN, 0) } func (s *FilterExprContext) NOT_OP() antlr.TerminalNode { return s.GetToken(QueryNOT_OP, 0) } func (s *FilterExprContext) AllFilterExpr() []IFilterExprContext { children := s.GetChildren() len := 0 for _, ctx := range children { if _, ok := ctx.(IFilterExprContext); ok { len++ } } tst := make([]IFilterExprContext, len) i := 0 for _, ctx := range children { if t, ok := ctx.(IFilterExprContext); ok { tst[i] = t.(IFilterExprContext) i++ } } return tst } func (s *FilterExprContext) FilterExpr(i int) IFilterExprContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFilterExprContext); ok { if j == i { t = ctx.(antlr.RuleContext) break } j++ } } if t == nil { return nil } return t.(IFilterExprContext) } func (s *FilterExprContext) 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 *FilterExprContext) AND_OP() antlr.TerminalNode { return s.GetToken(QueryAND_OP, 0) } func (s *FilterExprContext) OR_OP() antlr.TerminalNode { return s.GetToken(QueryOR_OP, 0) } func (s *FilterExprContext) GetRuleContext() antlr.RuleContext { return s } func (s *FilterExprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *FilterExprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case QueryVisitor: return t.VisitFilterExpr(s) default: return t.VisitChildren(s) } } func (p *Query) FilterExpr() (localctx IFilterExprContext) { return p.filterExpr(0) } func (p *Query) filterExpr(_p int) (localctx IFilterExprContext) { var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() _parentState := p.GetState() localctx = NewFilterExprContext(p, p.GetParserRuleContext(), _parentState) var _prevctx IFilterExprContext = localctx var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. _startState := 10 p.EnterRecursionRule(localctx, 10, QueryRULE_filterExpr, _p) var _alt int p.EnterOuterAlt(localctx, 1) p.SetState(87) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case QueryNOT_OP: { p.SetState(77) var _m = p.Match(QueryNOT_OP) localctx.(*FilterExprContext).Op = _m if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(78) p.Match(QueryL_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(79) var _x = p.filterExpr(0) localctx.(*FilterExprContext).F1 = _x } { p.SetState(80) p.Match(QueryR_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case QueryL_PAREN: { p.SetState(82) p.Match(QueryL_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(83) var _x = p.filterExpr(0) localctx.(*FilterExprContext).Inner = _x } { p.SetState(84) p.Match(QueryR_PAREN) if p.HasError() { // Recognition error - abort rule goto errorExit } } case QueryREP, QueryIN, QueryAS, QuerySELECT, QueryFROM, QueryFILTER, QueryAT, QueryIDENT, QuerySTRING: { p.SetState(86) p.Expr() } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) p.SetState(97) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 10, p.GetParserRuleContext()) if p.HasError() { goto errorExit } for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { if _alt == 1 { if p.GetParseListeners() != nil { p.TriggerExitRuleEvent() } _prevctx = localctx p.SetState(95) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 9, p.GetParserRuleContext()) { case 1: localctx = NewFilterExprContext(p, _parentctx, _parentState) localctx.(*FilterExprContext).F1 = _prevctx p.PushNewRecursionContext(localctx, _startState, QueryRULE_filterExpr) p.SetState(89) if !(p.Precpred(p.GetParserRuleContext(), 4)) { p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 4)", "")) goto errorExit } { p.SetState(90) var _m = p.Match(QueryAND_OP) localctx.(*FilterExprContext).Op = _m if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(91) var _x = p.filterExpr(5) localctx.(*FilterExprContext).F2 = _x } case 2: localctx = NewFilterExprContext(p, _parentctx, _parentState) localctx.(*FilterExprContext).F1 = _prevctx p.PushNewRecursionContext(localctx, _startState, QueryRULE_filterExpr) p.SetState(92) if !(p.Precpred(p.GetParserRuleContext(), 3)) { p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", "")) goto errorExit } { p.SetState(93) var _m = p.Match(QueryOR_OP) localctx.(*FilterExprContext).Op = _m if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(94) var _x = p.filterExpr(4) localctx.(*FilterExprContext).F2 = _x } case antlr.ATNInvalidAltNumber: goto errorExit } } p.SetState(99) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 10, p.GetParserRuleContext()) if p.HasError() { goto errorExit } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.UnrollRecursionContexts(_parentctx) return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFilterStmtContext is an interface to support dynamic dispatch. type IFilterStmtContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // GetExpr returns the Expr rule contexts. GetExpr() IFilterExprContext // GetName returns the Name rule contexts. GetName() IIdentContext // SetExpr sets the Expr rule contexts. SetExpr(IFilterExprContext) // SetName sets the Name rule contexts. SetName(IIdentContext) // Getter signatures FILTER() antlr.TerminalNode AS() antlr.TerminalNode FilterExpr() IFilterExprContext Ident() IIdentContext // IsFilterStmtContext differentiates from other interfaces. IsFilterStmtContext() } type FilterStmtContext struct { antlr.BaseParserRuleContext parser antlr.Parser Expr IFilterExprContext Name IIdentContext } func NewEmptyFilterStmtContext() *FilterStmtContext { var p = new(FilterStmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = QueryRULE_filterStmt return p } func InitEmptyFilterStmtContext(p *FilterStmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = QueryRULE_filterStmt } func (*FilterStmtContext) IsFilterStmtContext() {} func NewFilterStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FilterStmtContext { var p = new(FilterStmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = QueryRULE_filterStmt return p } func (s *FilterStmtContext) GetParser() antlr.Parser { return s.parser } func (s *FilterStmtContext) GetExpr() IFilterExprContext { return s.Expr } func (s *FilterStmtContext) GetName() IIdentContext { return s.Name } func (s *FilterStmtContext) SetExpr(v IFilterExprContext) { s.Expr = v } func (s *FilterStmtContext) SetName(v IIdentContext) { s.Name = v } func (s *FilterStmtContext) FILTER() antlr.TerminalNode { return s.GetToken(QueryFILTER, 0) } func (s *FilterStmtContext) AS() antlr.TerminalNode { return s.GetToken(QueryAS, 0) } func (s *FilterStmtContext) FilterExpr() IFilterExprContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFilterExprContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFilterExprContext) } func (s *FilterStmtContext) Ident() IIdentContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIdentContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIdentContext) } func (s *FilterStmtContext) GetRuleContext() antlr.RuleContext { return s } func (s *FilterStmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *FilterStmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case QueryVisitor: return t.VisitFilterStmt(s) default: return t.VisitChildren(s) } } func (p *Query) FilterStmt() (localctx IFilterStmtContext) { localctx = NewFilterStmtContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 12, QueryRULE_filterStmt) p.EnterOuterAlt(localctx, 1) { p.SetState(100) p.Match(QueryFILTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(101) var _x = p.filterExpr(0) localctx.(*FilterStmtContext).Expr = _x } { p.SetState(102) p.Match(QueryAS) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(103) var _x = p.Ident() localctx.(*FilterStmtContext).Name = _x } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IExprContext is an interface to support dynamic dispatch. type IExprContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // GetFilter returns the Filter rule contexts. GetFilter() IIdentContext // GetKey returns the Key rule contexts. GetKey() IFilterKeyContext // GetValue returns the Value rule contexts. GetValue() IFilterValueContext // SetFilter sets the Filter rule contexts. SetFilter(IIdentContext) // SetKey sets the Key rule contexts. SetKey(IFilterKeyContext) // SetValue sets the Value rule contexts. SetValue(IFilterValueContext) // Getter signatures AT() antlr.TerminalNode Ident() IIdentContext SIMPLE_OP() antlr.TerminalNode FilterKey() IFilterKeyContext FilterValue() IFilterValueContext // IsExprContext differentiates from other interfaces. IsExprContext() } type ExprContext struct { antlr.BaseParserRuleContext parser antlr.Parser Filter IIdentContext Key IFilterKeyContext Value IFilterValueContext } func NewEmptyExprContext() *ExprContext { var p = new(ExprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = QueryRULE_expr return p } func InitEmptyExprContext(p *ExprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = QueryRULE_expr } func (*ExprContext) IsExprContext() {} func NewExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExprContext { var p = new(ExprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = QueryRULE_expr return p } func (s *ExprContext) GetParser() antlr.Parser { return s.parser } func (s *ExprContext) GetFilter() IIdentContext { return s.Filter } func (s *ExprContext) GetKey() IFilterKeyContext { return s.Key } func (s *ExprContext) GetValue() IFilterValueContext { return s.Value } func (s *ExprContext) SetFilter(v IIdentContext) { s.Filter = v } func (s *ExprContext) SetKey(v IFilterKeyContext) { s.Key = v } func (s *ExprContext) SetValue(v IFilterValueContext) { s.Value = v } func (s *ExprContext) AT() antlr.TerminalNode { return s.GetToken(QueryAT, 0) } func (s *ExprContext) Ident() IIdentContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIdentContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIdentContext) } func (s *ExprContext) SIMPLE_OP() antlr.TerminalNode { return s.GetToken(QuerySIMPLE_OP, 0) } func (s *ExprContext) FilterKey() IFilterKeyContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFilterKeyContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFilterKeyContext) } func (s *ExprContext) FilterValue() IFilterValueContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IFilterValueContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IFilterValueContext) } 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) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case QueryVisitor: return t.VisitExpr(s) default: return t.VisitChildren(s) } } func (p *Query) Expr() (localctx IExprContext) { localctx = NewExprContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 14, QueryRULE_expr) p.SetState(111) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case QueryAT: p.EnterOuterAlt(localctx, 1) { p.SetState(105) p.Match(QueryAT) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(106) var _x = p.Ident() localctx.(*ExprContext).Filter = _x } case QueryREP, QueryIN, QueryAS, QuerySELECT, QueryFROM, QueryFILTER, QueryIDENT, QuerySTRING: p.EnterOuterAlt(localctx, 2) { p.SetState(107) var _x = p.FilterKey() localctx.(*ExprContext).Key = _x } { p.SetState(108) p.Match(QuerySIMPLE_OP) if p.HasError() { // Recognition error - abort rule goto errorExit } } { p.SetState(109) var _x = p.FilterValue() localctx.(*ExprContext).Value = _x } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFilterKeyContext is an interface to support dynamic dispatch. type IFilterKeyContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Ident() IIdentContext STRING() antlr.TerminalNode // IsFilterKeyContext differentiates from other interfaces. IsFilterKeyContext() } type FilterKeyContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFilterKeyContext() *FilterKeyContext { var p = new(FilterKeyContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = QueryRULE_filterKey return p } func InitEmptyFilterKeyContext(p *FilterKeyContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = QueryRULE_filterKey } func (*FilterKeyContext) IsFilterKeyContext() {} func NewFilterKeyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FilterKeyContext { var p = new(FilterKeyContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = QueryRULE_filterKey return p } func (s *FilterKeyContext) GetParser() antlr.Parser { return s.parser } func (s *FilterKeyContext) Ident() IIdentContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIdentContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIdentContext) } func (s *FilterKeyContext) STRING() antlr.TerminalNode { return s.GetToken(QuerySTRING, 0) } func (s *FilterKeyContext) GetRuleContext() antlr.RuleContext { return s } func (s *FilterKeyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *FilterKeyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case QueryVisitor: return t.VisitFilterKey(s) default: return t.VisitChildren(s) } } func (p *Query) FilterKey() (localctx IFilterKeyContext) { localctx = NewFilterKeyContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 16, QueryRULE_filterKey) p.SetState(115) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case QueryREP, QueryIN, QueryAS, QuerySELECT, QueryFROM, QueryFILTER, QueryIDENT: p.EnterOuterAlt(localctx, 1) { p.SetState(113) p.Ident() } case QuerySTRING: p.EnterOuterAlt(localctx, 2) { p.SetState(114) p.Match(QuerySTRING) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IFilterValueContext is an interface to support dynamic dispatch. type IFilterValueContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Ident() IIdentContext Number() INumberContext STRING() antlr.TerminalNode // IsFilterValueContext differentiates from other interfaces. IsFilterValueContext() } type FilterValueContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyFilterValueContext() *FilterValueContext { var p = new(FilterValueContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = QueryRULE_filterValue return p } func InitEmptyFilterValueContext(p *FilterValueContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = QueryRULE_filterValue } func (*FilterValueContext) IsFilterValueContext() {} func NewFilterValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FilterValueContext { var p = new(FilterValueContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = QueryRULE_filterValue return p } func (s *FilterValueContext) GetParser() antlr.Parser { return s.parser } func (s *FilterValueContext) Ident() IIdentContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIdentContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIdentContext) } func (s *FilterValueContext) Number() INumberContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(INumberContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(INumberContext) } func (s *FilterValueContext) STRING() antlr.TerminalNode { return s.GetToken(QuerySTRING, 0) } func (s *FilterValueContext) GetRuleContext() antlr.RuleContext { return s } func (s *FilterValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *FilterValueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case QueryVisitor: return t.VisitFilterValue(s) default: return t.VisitChildren(s) } } func (p *Query) FilterValue() (localctx IFilterValueContext) { localctx = NewFilterValueContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 18, QueryRULE_filterValue) p.SetState(120) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case QueryREP, QueryIN, QueryAS, QuerySELECT, QueryFROM, QueryFILTER, QueryIDENT: p.EnterOuterAlt(localctx, 1) { p.SetState(117) p.Ident() } case QueryNUMBER1, QueryZERO: p.EnterOuterAlt(localctx, 2) { p.SetState(118) p.Number() } case QuerySTRING: p.EnterOuterAlt(localctx, 3) { p.SetState(119) p.Match(QuerySTRING) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // INumberContext is an interface to support dynamic dispatch. type INumberContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures ZERO() antlr.TerminalNode NUMBER1() antlr.TerminalNode // IsNumberContext differentiates from other interfaces. IsNumberContext() } type NumberContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyNumberContext() *NumberContext { var p = new(NumberContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = QueryRULE_number return p } func InitEmptyNumberContext(p *NumberContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = QueryRULE_number } func (*NumberContext) IsNumberContext() {} func NewNumberContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NumberContext { var p = new(NumberContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = QueryRULE_number return p } func (s *NumberContext) GetParser() antlr.Parser { return s.parser } func (s *NumberContext) ZERO() antlr.TerminalNode { return s.GetToken(QueryZERO, 0) } func (s *NumberContext) NUMBER1() antlr.TerminalNode { return s.GetToken(QueryNUMBER1, 0) } func (s *NumberContext) GetRuleContext() antlr.RuleContext { return s } func (s *NumberContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *NumberContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case QueryVisitor: return t.VisitNumber(s) default: return t.VisitChildren(s) } } func (p *Query) Number() (localctx INumberContext) { localctx = NewNumberContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 20, QueryRULE_number) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(122) _la = p.GetTokenStream().LA(1) if !(_la == QueryNUMBER1 || _la == QueryZERO) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IKeywordContext is an interface to support dynamic dispatch. type IKeywordContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures REP() antlr.TerminalNode IN() antlr.TerminalNode AS() antlr.TerminalNode SELECT() antlr.TerminalNode FROM() antlr.TerminalNode FILTER() antlr.TerminalNode // IsKeywordContext differentiates from other interfaces. IsKeywordContext() } type KeywordContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyKeywordContext() *KeywordContext { var p = new(KeywordContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = QueryRULE_keyword return p } func InitEmptyKeywordContext(p *KeywordContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = QueryRULE_keyword } func (*KeywordContext) IsKeywordContext() {} func NewKeywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KeywordContext { var p = new(KeywordContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = QueryRULE_keyword return p } func (s *KeywordContext) GetParser() antlr.Parser { return s.parser } func (s *KeywordContext) REP() antlr.TerminalNode { return s.GetToken(QueryREP, 0) } func (s *KeywordContext) IN() antlr.TerminalNode { return s.GetToken(QueryIN, 0) } func (s *KeywordContext) AS() antlr.TerminalNode { return s.GetToken(QueryAS, 0) } func (s *KeywordContext) SELECT() antlr.TerminalNode { return s.GetToken(QuerySELECT, 0) } func (s *KeywordContext) FROM() antlr.TerminalNode { return s.GetToken(QueryFROM, 0) } func (s *KeywordContext) FILTER() antlr.TerminalNode { return s.GetToken(QueryFILTER, 0) } func (s *KeywordContext) GetRuleContext() antlr.RuleContext { return s } func (s *KeywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *KeywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case QueryVisitor: return t.VisitKeyword(s) default: return t.VisitChildren(s) } } func (p *Query) Keyword() (localctx IKeywordContext) { localctx = NewKeywordContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 22, QueryRULE_keyword) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(124) _la = p.GetTokenStream().LA(1) if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&3808) != 0) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) p.Consume() } } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IIdentContext is an interface to support dynamic dispatch. type IIdentContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Keyword() IKeywordContext IDENT() antlr.TerminalNode // IsIdentContext differentiates from other interfaces. IsIdentContext() } type IdentContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyIdentContext() *IdentContext { var p = new(IdentContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = QueryRULE_ident return p } func InitEmptyIdentContext(p *IdentContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = QueryRULE_ident } func (*IdentContext) IsIdentContext() {} func NewIdentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IdentContext { var p = new(IdentContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = QueryRULE_ident return p } func (s *IdentContext) GetParser() antlr.Parser { return s.parser } func (s *IdentContext) Keyword() IKeywordContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IKeywordContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IKeywordContext) } func (s *IdentContext) IDENT() antlr.TerminalNode { return s.GetToken(QueryIDENT, 0) } func (s *IdentContext) GetRuleContext() antlr.RuleContext { return s } func (s *IdentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *IdentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case QueryVisitor: return t.VisitIdent(s) default: return t.VisitChildren(s) } } func (p *Query) Ident() (localctx IIdentContext) { localctx = NewIdentContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 24, QueryRULE_ident) p.SetState(128) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case QueryREP, QueryIN, QueryAS, QuerySELECT, QueryFROM, QueryFILTER: p.EnterOuterAlt(localctx, 1) { p.SetState(126) p.Keyword() } case QueryIDENT: p.EnterOuterAlt(localctx, 2) { p.SetState(127) p.Match(QueryIDENT) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } // IIdentWCContext is an interface to support dynamic dispatch. type IIdentWCContext interface { antlr.ParserRuleContext // GetParser returns the parser. GetParser() antlr.Parser // Getter signatures Ident() IIdentContext WILDCARD() antlr.TerminalNode // IsIdentWCContext differentiates from other interfaces. IsIdentWCContext() } type IdentWCContext struct { antlr.BaseParserRuleContext parser antlr.Parser } func NewEmptyIdentWCContext() *IdentWCContext { var p = new(IdentWCContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = QueryRULE_identWC return p } func InitEmptyIdentWCContext(p *IdentWCContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) p.RuleIndex = QueryRULE_identWC } func (*IdentWCContext) IsIdentWCContext() {} func NewIdentWCContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IdentWCContext { var p = new(IdentWCContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser p.RuleIndex = QueryRULE_identWC return p } func (s *IdentWCContext) GetParser() antlr.Parser { return s.parser } func (s *IdentWCContext) Ident() IIdentContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { if _, ok := ctx.(IIdentContext); ok { t = ctx.(antlr.RuleContext) break } } if t == nil { return nil } return t.(IIdentContext) } func (s *IdentWCContext) WILDCARD() antlr.TerminalNode { return s.GetToken(QueryWILDCARD, 0) } func (s *IdentWCContext) GetRuleContext() antlr.RuleContext { return s } func (s *IdentWCContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { return antlr.TreesStringTree(s, ruleNames, recog) } func (s *IdentWCContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { case QueryVisitor: return t.VisitIdentWC(s) default: return t.VisitChildren(s) } } func (p *Query) IdentWC() (localctx IIdentWCContext) { localctx = NewIdentWCContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 26, QueryRULE_identWC) p.SetState(132) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } switch p.GetTokenStream().LA(1) { case QueryREP, QueryIN, QueryAS, QuerySELECT, QueryFROM, QueryFILTER, QueryIDENT: p.EnterOuterAlt(localctx, 1) { p.SetState(130) p.Ident() } case QueryWILDCARD: p.EnterOuterAlt(localctx, 2) { p.SetState(131) p.Match(QueryWILDCARD) if p.HasError() { // Recognition error - abort rule goto errorExit } } default: p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } errorExit: if p.HasError() { v := p.GetError() localctx.SetException(v) p.GetErrorHandler().ReportError(p, v) p.GetErrorHandler().Recover(p, v) p.SetError(nil) } p.ExitRule() return localctx goto errorExit // Trick to prevent compiler error if the label is not used } func (p *Query) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool { switch ruleIndex { case 5: var t *FilterExprContext = nil if localctx != nil { t = localctx.(*FilterExprContext) } return p.FilterExpr_Sempred(t, predIndex) default: panic("No predicate with index: " + fmt.Sprint(ruleIndex)) } } func (p *Query) FilterExpr_Sempred(localctx antlr.RuleContext, predIndex int) bool { switch predIndex { case 0: return p.Precpred(p.GetParserRuleContext(), 4) case 1: return p.Precpred(p.GetParserRuleContext(), 3) default: panic("No predicate with index: " + fmt.Sprint(predIndex)) } }