You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
682 lines
16 KiB
Go
682 lines
16 KiB
Go
package api
|
|
|
|
import (
|
|
"reflect"
|
|
|
|
"github.com/zeromicro/antlr"
|
|
)
|
|
|
|
// Part 1
|
|
// The apiparser_parser.go file was split into multiple files because it
|
|
// was too large and caused a possible memory overflow during goctl installation.
|
|
|
|
func (s *SyntaxLitContext) STRING() antlr.TerminalNode {
|
|
return s.GetToken(ApiParserParserSTRING, 0)
|
|
}
|
|
|
|
func (s *SyntaxLitContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *SyntaxLitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *SyntaxLitContext) Accept(visitor antlr.ParseTreeVisitor) any {
|
|
switch t := visitor.(type) {
|
|
case ApiParserVisitor:
|
|
return t.VisitSyntaxLit(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *ApiParserParser) SyntaxLit() (localctx ISyntaxLitContext) {
|
|
localctx = NewSyntaxLitContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 4, ApiParserParserRULE_syntaxLit)
|
|
|
|
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)
|
|
match(p, "syntax")
|
|
{
|
|
p.SetState(90)
|
|
|
|
var _m = p.Match(ApiParserParserID)
|
|
|
|
localctx.(*SyntaxLitContext).syntaxToken = _m
|
|
}
|
|
{
|
|
p.SetState(91)
|
|
|
|
var _m = p.Match(ApiParserParserT__0)
|
|
|
|
localctx.(*SyntaxLitContext).assign = _m
|
|
}
|
|
checkVersion(p)
|
|
{
|
|
p.SetState(93)
|
|
|
|
var _m = p.Match(ApiParserParserSTRING)
|
|
|
|
localctx.(*SyntaxLitContext).version = _m
|
|
}
|
|
|
|
return localctx
|
|
}
|
|
|
|
// IImportSpecContext is an interface to support dynamic dispatch.
|
|
type IImportSpecContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// IsImportSpecContext differentiates from other interfaces.
|
|
IsImportSpecContext()
|
|
}
|
|
|
|
type ImportSpecContext struct {
|
|
*antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyImportSpecContext() *ImportSpecContext {
|
|
var p = new(ImportSpecContext)
|
|
p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
|
|
p.RuleIndex = ApiParserParserRULE_importSpec
|
|
return p
|
|
}
|
|
|
|
func (*ImportSpecContext) IsImportSpecContext() {}
|
|
|
|
func NewImportSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportSpecContext {
|
|
var p = new(ImportSpecContext)
|
|
|
|
p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = ApiParserParserRULE_importSpec
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ImportSpecContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ImportSpecContext) ImportLit() IImportLitContext {
|
|
var t = s.GetTypedRuleContext(reflect.TypeOf((*IImportLitContext)(nil)).Elem(), 0)
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IImportLitContext)
|
|
}
|
|
|
|
func (s *ImportSpecContext) ImportBlock() IImportBlockContext {
|
|
var t = s.GetTypedRuleContext(reflect.TypeOf((*IImportBlockContext)(nil)).Elem(), 0)
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IImportBlockContext)
|
|
}
|
|
|
|
func (s *ImportSpecContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ImportSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ImportSpecContext) Accept(visitor antlr.ParseTreeVisitor) any {
|
|
switch t := visitor.(type) {
|
|
case ApiParserVisitor:
|
|
return t.VisitImportSpec(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *ApiParserParser) ImportSpec() (localctx IImportSpecContext) {
|
|
localctx = NewImportSpecContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 6, ApiParserParserRULE_importSpec)
|
|
|
|
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(97)
|
|
p.GetErrorHandler().Sync(p)
|
|
switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 2, p.GetParserRuleContext()) {
|
|
case 1:
|
|
p.EnterOuterAlt(localctx, 1)
|
|
{
|
|
p.SetState(95)
|
|
p.ImportLit()
|
|
}
|
|
|
|
case 2:
|
|
p.EnterOuterAlt(localctx, 2)
|
|
{
|
|
p.SetState(96)
|
|
p.ImportBlock()
|
|
}
|
|
|
|
}
|
|
|
|
return localctx
|
|
}
|
|
|
|
// IImportLitContext is an interface to support dynamic dispatch.
|
|
type IImportLitContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetImportToken returns the importToken token.
|
|
GetImportToken() antlr.Token
|
|
|
|
// SetImportToken sets the importToken token.
|
|
SetImportToken(antlr.Token)
|
|
|
|
// IsImportLitContext differentiates from other interfaces.
|
|
IsImportLitContext()
|
|
}
|
|
|
|
type ImportLitContext struct {
|
|
*antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
importToken antlr.Token
|
|
}
|
|
|
|
func NewEmptyImportLitContext() *ImportLitContext {
|
|
var p = new(ImportLitContext)
|
|
p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
|
|
p.RuleIndex = ApiParserParserRULE_importLit
|
|
return p
|
|
}
|
|
|
|
func (*ImportLitContext) IsImportLitContext() {}
|
|
|
|
func NewImportLitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportLitContext {
|
|
var p = new(ImportLitContext)
|
|
|
|
p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = ApiParserParserRULE_importLit
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ImportLitContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ImportLitContext) GetImportToken() antlr.Token { return s.importToken }
|
|
|
|
func (s *ImportLitContext) SetImportToken(v antlr.Token) { s.importToken = v }
|
|
|
|
func (s *ImportLitContext) ImportValue() IImportValueContext {
|
|
var t = s.GetTypedRuleContext(reflect.TypeOf((*IImportValueContext)(nil)).Elem(), 0)
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IImportValueContext)
|
|
}
|
|
|
|
func (s *ImportLitContext) ID() antlr.TerminalNode {
|
|
return s.GetToken(ApiParserParserID, 0)
|
|
}
|
|
|
|
func (s *ImportLitContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ImportLitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ImportLitContext) Accept(visitor antlr.ParseTreeVisitor) any {
|
|
switch t := visitor.(type) {
|
|
case ApiParserVisitor:
|
|
return t.VisitImportLit(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *ApiParserParser) ImportLit() (localctx IImportLitContext) {
|
|
localctx = NewImportLitContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 8, ApiParserParserRULE_importLit)
|
|
|
|
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)
|
|
match(p, "import")
|
|
{
|
|
p.SetState(100)
|
|
|
|
var _m = p.Match(ApiParserParserID)
|
|
|
|
localctx.(*ImportLitContext).importToken = _m
|
|
}
|
|
{
|
|
p.SetState(101)
|
|
p.ImportValue()
|
|
}
|
|
|
|
return localctx
|
|
}
|
|
|
|
// IImportBlockContext is an interface to support dynamic dispatch.
|
|
type IImportBlockContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetImportToken returns the importToken token.
|
|
GetImportToken() antlr.Token
|
|
|
|
// SetImportToken sets the importToken token.
|
|
SetImportToken(antlr.Token)
|
|
|
|
// IsImportBlockContext differentiates from other interfaces.
|
|
IsImportBlockContext()
|
|
}
|
|
|
|
type ImportBlockContext struct {
|
|
*antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
importToken antlr.Token
|
|
}
|
|
|
|
func NewEmptyImportBlockContext() *ImportBlockContext {
|
|
var p = new(ImportBlockContext)
|
|
p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
|
|
p.RuleIndex = ApiParserParserRULE_importBlock
|
|
return p
|
|
}
|
|
|
|
func (*ImportBlockContext) IsImportBlockContext() {}
|
|
|
|
func NewImportBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportBlockContext {
|
|
var p = new(ImportBlockContext)
|
|
|
|
p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = ApiParserParserRULE_importBlock
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ImportBlockContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ImportBlockContext) GetImportToken() antlr.Token { return s.importToken }
|
|
|
|
func (s *ImportBlockContext) SetImportToken(v antlr.Token) { s.importToken = v }
|
|
|
|
func (s *ImportBlockContext) ID() antlr.TerminalNode {
|
|
return s.GetToken(ApiParserParserID, 0)
|
|
}
|
|
|
|
func (s *ImportBlockContext) AllImportBlockValue() []IImportBlockValueContext {
|
|
var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IImportBlockValueContext)(nil)).Elem())
|
|
var tst = make([]IImportBlockValueContext, len(ts))
|
|
|
|
for i, t := range ts {
|
|
if t != nil {
|
|
tst[i] = t.(IImportBlockValueContext)
|
|
}
|
|
}
|
|
|
|
return tst
|
|
}
|
|
|
|
func (s *ImportBlockContext) ImportBlockValue(i int) IImportBlockValueContext {
|
|
var t = s.GetTypedRuleContext(reflect.TypeOf((*IImportBlockValueContext)(nil)).Elem(), i)
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IImportBlockValueContext)
|
|
}
|
|
|
|
func (s *ImportBlockContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ImportBlockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ImportBlockContext) Accept(visitor antlr.ParseTreeVisitor) any {
|
|
switch t := visitor.(type) {
|
|
case ApiParserVisitor:
|
|
return t.VisitImportBlock(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *ApiParserParser) ImportBlock() (localctx IImportBlockContext) {
|
|
localctx = NewImportBlockContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 10, ApiParserParserRULE_importBlock)
|
|
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)
|
|
match(p, "import")
|
|
{
|
|
p.SetState(104)
|
|
|
|
var _m = p.Match(ApiParserParserID)
|
|
|
|
localctx.(*ImportBlockContext).importToken = _m
|
|
}
|
|
{
|
|
p.SetState(105)
|
|
p.Match(ApiParserParserT__1)
|
|
}
|
|
p.SetState(107)
|
|
p.GetErrorHandler().Sync(p)
|
|
_la = p.GetTokenStream().LA(1)
|
|
|
|
for ok := true; ok; ok = _la == ApiParserParserSTRING {
|
|
{
|
|
p.SetState(106)
|
|
p.ImportBlockValue()
|
|
}
|
|
|
|
p.SetState(109)
|
|
p.GetErrorHandler().Sync(p)
|
|
_la = p.GetTokenStream().LA(1)
|
|
}
|
|
{
|
|
p.SetState(111)
|
|
p.Match(ApiParserParserT__2)
|
|
}
|
|
|
|
return localctx
|
|
}
|
|
|
|
// IImportBlockValueContext is an interface to support dynamic dispatch.
|
|
type IImportBlockValueContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// IsImportBlockValueContext differentiates from other interfaces.
|
|
IsImportBlockValueContext()
|
|
}
|
|
|
|
type ImportBlockValueContext struct {
|
|
*antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyImportBlockValueContext() *ImportBlockValueContext {
|
|
var p = new(ImportBlockValueContext)
|
|
p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
|
|
p.RuleIndex = ApiParserParserRULE_importBlockValue
|
|
return p
|
|
}
|
|
|
|
func (*ImportBlockValueContext) IsImportBlockValueContext() {}
|
|
|
|
func NewImportBlockValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportBlockValueContext {
|
|
var p = new(ImportBlockValueContext)
|
|
|
|
p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = ApiParserParserRULE_importBlockValue
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ImportBlockValueContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ImportBlockValueContext) ImportValue() IImportValueContext {
|
|
var t = s.GetTypedRuleContext(reflect.TypeOf((*IImportValueContext)(nil)).Elem(), 0)
|
|
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
|
|
return t.(IImportValueContext)
|
|
}
|
|
|
|
func (s *ImportBlockValueContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ImportBlockValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ImportBlockValueContext) Accept(visitor antlr.ParseTreeVisitor) any {
|
|
switch t := visitor.(type) {
|
|
case ApiParserVisitor:
|
|
return t.VisitImportBlockValue(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *ApiParserParser) ImportBlockValue() (localctx IImportBlockValueContext) {
|
|
localctx = NewImportBlockValueContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 12, ApiParserParserRULE_importBlockValue)
|
|
|
|
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(113)
|
|
p.ImportValue()
|
|
}
|
|
|
|
return localctx
|
|
}
|
|
|
|
// IImportValueContext is an interface to support dynamic dispatch.
|
|
type IImportValueContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// IsImportValueContext differentiates from other interfaces.
|
|
IsImportValueContext()
|
|
}
|
|
|
|
type ImportValueContext struct {
|
|
*antlr.BaseParserRuleContext
|
|
parser antlr.Parser
|
|
}
|
|
|
|
func NewEmptyImportValueContext() *ImportValueContext {
|
|
var p = new(ImportValueContext)
|
|
p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
|
|
p.RuleIndex = ApiParserParserRULE_importValue
|
|
return p
|
|
}
|
|
|
|
func (*ImportValueContext) IsImportValueContext() {}
|
|
|
|
func NewImportValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportValueContext {
|
|
var p = new(ImportValueContext)
|
|
|
|
p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
|
|
|
|
p.parser = parser
|
|
p.RuleIndex = ApiParserParserRULE_importValue
|
|
|
|
return p
|
|
}
|
|
|
|
func (s *ImportValueContext) GetParser() antlr.Parser { return s.parser }
|
|
|
|
func (s *ImportValueContext) STRING() antlr.TerminalNode {
|
|
return s.GetToken(ApiParserParserSTRING, 0)
|
|
}
|
|
|
|
func (s *ImportValueContext) GetRuleContext() antlr.RuleContext {
|
|
return s
|
|
}
|
|
|
|
func (s *ImportValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
|
|
return antlr.TreesStringTree(s, ruleNames, recog)
|
|
}
|
|
|
|
func (s *ImportValueContext) Accept(visitor antlr.ParseTreeVisitor) any {
|
|
switch t := visitor.(type) {
|
|
case ApiParserVisitor:
|
|
return t.VisitImportValue(s)
|
|
|
|
default:
|
|
return t.VisitChildren(s)
|
|
}
|
|
}
|
|
|
|
func (p *ApiParserParser) ImportValue() (localctx IImportValueContext) {
|
|
localctx = NewImportValueContext(p, p.GetParserRuleContext(), p.GetState())
|
|
p.EnterRule(localctx, 14, ApiParserParserRULE_importValue)
|
|
|
|
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)
|
|
checkImportValue(p)
|
|
{
|
|
p.SetState(116)
|
|
p.Match(ApiParserParserSTRING)
|
|
}
|
|
|
|
return localctx
|
|
}
|
|
|
|
// IInfoSpecContext is an interface to support dynamic dispatch.
|
|
type IInfoSpecContext interface {
|
|
antlr.ParserRuleContext
|
|
|
|
// GetParser returns the parser.
|
|
GetParser() antlr.Parser
|
|
|
|
// GetInfoToken returns the infoToken token.
|
|
GetInfoToken() antlr.Token
|
|
|
|
// GetLp returns the lp token.
|
|
GetLp() antlr.Token
|
|
|
|
// GetRp returns the rp token.
|
|
GetRp() antlr.Token
|
|
|
|
// SetInfoToken sets the infoToken token.
|
|
SetInfoToken(antlr.Token)
|
|
|
|
// SetLp sets the lp token.
|
|
SetLp(antlr.Token)
|
|
|
|
// SetRp sets the rp token.
|
|
SetRp(antlr.Token)
|
|
|
|
// IsInfoSpecContext differentiates from other interfaces.
|
|
IsInfoSpecContext()
|
|
}
|