How to use String method of parser Package

Best Gauge code snippet using parser.String

apiparser_parser2.go

Source:apiparser_parser2.go

...12}13func (s *ImportValueContext) GetRuleContext() antlr.RuleContext {14	return s15}16func (s *ImportValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {17	return antlr.TreesStringTree(s, ruleNames, recog)18}19func (s *ImportValueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {20	switch t := visitor.(type) {21	case ApiParserVisitor:22		return t.VisitImportValue(s)23	default:24		return t.VisitChildren(s)25	}26}27func (p *ApiParserParser) ImportValue() (localctx IImportValueContext) {28	localctx = NewImportValueContext(p, p.GetParserRuleContext(), p.GetState())29	p.EnterRule(localctx, 14, ApiParserParserRULE_importValue)30	defer func() {31		p.ExitRule()32	}()33	defer func() {34		if err := recover(); err != nil {35			if v, ok := err.(antlr.RecognitionException); ok {36				localctx.SetException(v)37				p.GetErrorHandler().ReportError(p, v)38				p.GetErrorHandler().Recover(p, v)39			} else {40				panic(err)41			}42		}43	}()44	p.EnterOuterAlt(localctx, 1)45	checkImportValue(p)46	{47		p.SetState(114)48		p.Match(ApiParserParserSTRING)49	}50	return localctx51}52// IInfoSpecContext is an interface to support dynamic dispatch.53type IInfoSpecContext interface {54	antlr.ParserRuleContext55	// GetParser returns the parser.56	GetParser() antlr.Parser57	// GetInfoToken returns the infoToken token.58	GetInfoToken() antlr.Token59	// GetLp returns the lp token.60	GetLp() antlr.Token61	// GetRp returns the rp token.62	GetRp() antlr.Token63	// SetInfoToken sets the infoToken token.64	SetInfoToken(antlr.Token)65	// SetLp sets the lp token.66	SetLp(antlr.Token)67	// SetRp sets the rp token.68	SetRp(antlr.Token)69	// IsInfoSpecContext differentiates from other interfaces.70	IsInfoSpecContext()71}72type InfoSpecContext struct {73	*antlr.BaseParserRuleContext74	parser    antlr.Parser75	infoToken antlr.Token76	lp        antlr.Token77	rp        antlr.Token78}79func NewEmptyInfoSpecContext() *InfoSpecContext {80	var p = new(InfoSpecContext)81	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)82	p.RuleIndex = ApiParserParserRULE_infoSpec83	return p84}85func (*InfoSpecContext) IsInfoSpecContext() {}86func NewInfoSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InfoSpecContext {87	var p = new(InfoSpecContext)88	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)89	p.parser = parser90	p.RuleIndex = ApiParserParserRULE_infoSpec91	return p92}93func (s *InfoSpecContext) GetParser() antlr.Parser { return s.parser }94func (s *InfoSpecContext) GetInfoToken() antlr.Token { return s.infoToken }95func (s *InfoSpecContext) GetLp() antlr.Token { return s.lp }96func (s *InfoSpecContext) GetRp() antlr.Token { return s.rp }97func (s *InfoSpecContext) SetInfoToken(v antlr.Token) { s.infoToken = v }98func (s *InfoSpecContext) SetLp(v antlr.Token) { s.lp = v }99func (s *InfoSpecContext) SetRp(v antlr.Token) { s.rp = v }100func (s *InfoSpecContext) ID() antlr.TerminalNode {101	return s.GetToken(ApiParserParserID, 0)102}103func (s *InfoSpecContext) AllKvLit() []IKvLitContext {104	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IKvLitContext)(nil)).Elem())105	var tst = make([]IKvLitContext, len(ts))106	for i, t := range ts {107		if t != nil {108			tst[i] = t.(IKvLitContext)109		}110	}111	return tst112}113func (s *InfoSpecContext) KvLit(i int) IKvLitContext {114	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKvLitContext)(nil)).Elem(), i)115	if t == nil {116		return nil117	}118	return t.(IKvLitContext)119}120func (s *InfoSpecContext) GetRuleContext() antlr.RuleContext {121	return s122}123func (s *InfoSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {124	return antlr.TreesStringTree(s, ruleNames, recog)125}126func (s *InfoSpecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {127	switch t := visitor.(type) {128	case ApiParserVisitor:129		return t.VisitInfoSpec(s)130	default:131		return t.VisitChildren(s)132	}133}134func (p *ApiParserParser) InfoSpec() (localctx IInfoSpecContext) {135	localctx = NewInfoSpecContext(p, p.GetParserRuleContext(), p.GetState())136	p.EnterRule(localctx, 16, ApiParserParserRULE_infoSpec)137	var _la int138	defer func() {139		p.ExitRule()140	}()141	defer func() {142		if err := recover(); err != nil {143			if v, ok := err.(antlr.RecognitionException); ok {144				localctx.SetException(v)145				p.GetErrorHandler().ReportError(p, v)146				p.GetErrorHandler().Recover(p, v)147			} else {148				panic(err)149			}150		}151	}()152	p.EnterOuterAlt(localctx, 1)153	match(p, "info")154	{155		p.SetState(117)156		var _m = p.Match(ApiParserParserID)157		localctx.(*InfoSpecContext).infoToken = _m158	}159	{160		p.SetState(118)161		var _m = p.Match(ApiParserParserT__1)162		localctx.(*InfoSpecContext).lp = _m163	}164	p.SetState(120)165	p.GetErrorHandler().Sync(p)166	for ok := true; ok; ok = _la == ApiParserParserID {167		{168			p.SetState(119)169			p.KvLit()170		}171		p.SetState(122)172		p.GetErrorHandler().Sync(p)173		_la = p.GetTokenStream().LA(1)174	}175	{176		p.SetState(124)177		var _m = p.Match(ApiParserParserT__2)178		localctx.(*InfoSpecContext).rp = _m179	}180	return localctx181}182// ITypeSpecContext is an interface to support dynamic dispatch.183type ITypeSpecContext interface {184	antlr.ParserRuleContext185	// GetParser returns the parser.186	GetParser() antlr.Parser187	// IsTypeSpecContext differentiates from other interfaces.188	IsTypeSpecContext()189}190type TypeSpecContext struct {191	*antlr.BaseParserRuleContext192	parser antlr.Parser193}194func NewEmptyTypeSpecContext() *TypeSpecContext {195	var p = new(TypeSpecContext)196	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)197	p.RuleIndex = ApiParserParserRULE_typeSpec198	return p199}200func (*TypeSpecContext) IsTypeSpecContext() {}201func NewTypeSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeSpecContext {202	var p = new(TypeSpecContext)203	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)204	p.parser = parser205	p.RuleIndex = ApiParserParserRULE_typeSpec206	return p207}208func (s *TypeSpecContext) GetParser() antlr.Parser { return s.parser }209func (s *TypeSpecContext) TypeLit() ITypeLitContext {210	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeLitContext)(nil)).Elem(), 0)211	if t == nil {212		return nil213	}214	return t.(ITypeLitContext)215}216func (s *TypeSpecContext) TypeBlock() ITypeBlockContext {217	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeBlockContext)(nil)).Elem(), 0)218	if t == nil {219		return nil220	}221	return t.(ITypeBlockContext)222}223func (s *TypeSpecContext) GetRuleContext() antlr.RuleContext {224	return s225}226func (s *TypeSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {227	return antlr.TreesStringTree(s, ruleNames, recog)228}229func (s *TypeSpecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {230	switch t := visitor.(type) {231	case ApiParserVisitor:232		return t.VisitTypeSpec(s)233	default:234		return t.VisitChildren(s)235	}236}237func (p *ApiParserParser) TypeSpec() (localctx ITypeSpecContext) {238	localctx = NewTypeSpecContext(p, p.GetParserRuleContext(), p.GetState())239	p.EnterRule(localctx, 18, ApiParserParserRULE_typeSpec)240	defer func() {241		p.ExitRule()242	}()243	defer func() {244		if err := recover(); err != nil {245			if v, ok := err.(antlr.RecognitionException); ok {246				localctx.SetException(v)247				p.GetErrorHandler().ReportError(p, v)248				p.GetErrorHandler().Recover(p, v)249			} else {250				panic(err)251			}252		}253	}()254	p.SetState(128)255	p.GetErrorHandler().Sync(p)256	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 5, p.GetParserRuleContext()) {257	case 1:258		p.EnterOuterAlt(localctx, 1)259		{260			p.SetState(126)261			p.TypeLit()262		}263	case 2:264		p.EnterOuterAlt(localctx, 2)265		{266			p.SetState(127)267			p.TypeBlock()268		}269	}270	return localctx271}272// ITypeLitContext is an interface to support dynamic dispatch.273type ITypeLitContext interface {274	antlr.ParserRuleContext275	// GetParser returns the parser.276	GetParser() antlr.Parser277	// GetTypeToken returns the typeToken token.278	GetTypeToken() antlr.Token279	// SetTypeToken sets the typeToken token.280	SetTypeToken(antlr.Token)281	// IsTypeLitContext differentiates from other interfaces.282	IsTypeLitContext()283}284type TypeLitContext struct {285	*antlr.BaseParserRuleContext286	parser    antlr.Parser287	typeToken antlr.Token288}289func NewEmptyTypeLitContext() *TypeLitContext {290	var p = new(TypeLitContext)291	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)292	p.RuleIndex = ApiParserParserRULE_typeLit293	return p294}295func (*TypeLitContext) IsTypeLitContext() {}296func NewTypeLitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeLitContext {297	var p = new(TypeLitContext)298	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)299	p.parser = parser300	p.RuleIndex = ApiParserParserRULE_typeLit301	return p302}303func (s *TypeLitContext) GetParser() antlr.Parser { return s.parser }304func (s *TypeLitContext) GetTypeToken() antlr.Token { return s.typeToken }305func (s *TypeLitContext) SetTypeToken(v antlr.Token) { s.typeToken = v }306func (s *TypeLitContext) TypeLitBody() ITypeLitBodyContext {307	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeLitBodyContext)(nil)).Elem(), 0)308	if t == nil {309		return nil310	}311	return t.(ITypeLitBodyContext)312}313func (s *TypeLitContext) ID() antlr.TerminalNode {314	return s.GetToken(ApiParserParserID, 0)315}316func (s *TypeLitContext) GetRuleContext() antlr.RuleContext {317	return s318}319func (s *TypeLitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {320	return antlr.TreesStringTree(s, ruleNames, recog)321}322func (s *TypeLitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {323	switch t := visitor.(type) {324	case ApiParserVisitor:325		return t.VisitTypeLit(s)326	default:327		return t.VisitChildren(s)328	}329}330func (p *ApiParserParser) TypeLit() (localctx ITypeLitContext) {331	localctx = NewTypeLitContext(p, p.GetParserRuleContext(), p.GetState())332	p.EnterRule(localctx, 20, ApiParserParserRULE_typeLit)333	defer func() {334		p.ExitRule()335	}()336	defer func() {337		if err := recover(); err != nil {338			if v, ok := err.(antlr.RecognitionException); ok {339				localctx.SetException(v)340				p.GetErrorHandler().ReportError(p, v)341				p.GetErrorHandler().Recover(p, v)342			} else {343				panic(err)344			}345		}346	}()347	p.EnterOuterAlt(localctx, 1)348	match(p, "type")349	{350		p.SetState(131)351		var _m = p.Match(ApiParserParserID)352		localctx.(*TypeLitContext).typeToken = _m353	}354	{355		p.SetState(132)356		p.TypeLitBody()357	}358	return localctx359}360// ITypeBlockContext is an interface to support dynamic dispatch.361type ITypeBlockContext interface {362	antlr.ParserRuleContext363	// GetParser returns the parser.364	GetParser() antlr.Parser365	// GetTypeToken returns the typeToken token.366	GetTypeToken() antlr.Token367	// GetLp returns the lp token.368	GetLp() antlr.Token369	// GetRp returns the rp token.370	GetRp() antlr.Token371	// SetTypeToken sets the typeToken token.372	SetTypeToken(antlr.Token)373	// SetLp sets the lp token.374	SetLp(antlr.Token)375	// SetRp sets the rp token.376	SetRp(antlr.Token)377	// IsTypeBlockContext differentiates from other interfaces.378	IsTypeBlockContext()379}380type TypeBlockContext struct {381	*antlr.BaseParserRuleContext382	parser    antlr.Parser383	typeToken antlr.Token384	lp        antlr.Token385	rp        antlr.Token386}387func NewEmptyTypeBlockContext() *TypeBlockContext {388	var p = new(TypeBlockContext)389	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)390	p.RuleIndex = ApiParserParserRULE_typeBlock391	return p392}393func (*TypeBlockContext) IsTypeBlockContext() {}394func NewTypeBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeBlockContext {395	var p = new(TypeBlockContext)396	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)397	p.parser = parser398	p.RuleIndex = ApiParserParserRULE_typeBlock399	return p400}401func (s *TypeBlockContext) GetParser() antlr.Parser { return s.parser }402func (s *TypeBlockContext) GetTypeToken() antlr.Token { return s.typeToken }403func (s *TypeBlockContext) GetLp() antlr.Token { return s.lp }404func (s *TypeBlockContext) GetRp() antlr.Token { return s.rp }405func (s *TypeBlockContext) SetTypeToken(v antlr.Token) { s.typeToken = v }406func (s *TypeBlockContext) SetLp(v antlr.Token) { s.lp = v }407func (s *TypeBlockContext) SetRp(v antlr.Token) { s.rp = v }408func (s *TypeBlockContext) ID() antlr.TerminalNode {409	return s.GetToken(ApiParserParserID, 0)410}411func (s *TypeBlockContext) AllTypeBlockBody() []ITypeBlockBodyContext {412	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ITypeBlockBodyContext)(nil)).Elem())413	var tst = make([]ITypeBlockBodyContext, len(ts))414	for i, t := range ts {415		if t != nil {416			tst[i] = t.(ITypeBlockBodyContext)417		}418	}419	return tst420}421func (s *TypeBlockContext) TypeBlockBody(i int) ITypeBlockBodyContext {422	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeBlockBodyContext)(nil)).Elem(), i)423	if t == nil {424		return nil425	}426	return t.(ITypeBlockBodyContext)427}428func (s *TypeBlockContext) GetRuleContext() antlr.RuleContext {429	return s430}431func (s *TypeBlockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {432	return antlr.TreesStringTree(s, ruleNames, recog)433}434func (s *TypeBlockContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {435	switch t := visitor.(type) {436	case ApiParserVisitor:437		return t.VisitTypeBlock(s)438	default:439		return t.VisitChildren(s)440	}441}442func (p *ApiParserParser) TypeBlock() (localctx ITypeBlockContext) {443	localctx = NewTypeBlockContext(p, p.GetParserRuleContext(), p.GetState())444	p.EnterRule(localctx, 22, ApiParserParserRULE_typeBlock)445	var _la int446	defer func() {...

apiparser_parser1.go

Source:apiparser_parser1.go

...21}22func (s *SyntaxLitContext) GetRuleContext() antlr.RuleContext {23	return s24}25func (s *SyntaxLitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {26	return antlr.TreesStringTree(s, ruleNames, recog)27}28func (s *SyntaxLitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {29	switch t := visitor.(type) {30	case ApiParserVisitor:31		return t.VisitSyntaxLit(s)32	default:33		return t.VisitChildren(s)34	}35}36func (p *ApiParserParser) SyntaxLit() (localctx ISyntaxLitContext) {37	localctx = NewSyntaxLitContext(p, p.GetParserRuleContext(), p.GetState())38	p.EnterRule(localctx, 4, ApiParserParserRULE_syntaxLit)39	defer func() {40		p.ExitRule()41	}()42	defer func() {43		if err := recover(); err != nil {44			if v, ok := err.(antlr.RecognitionException); ok {45				localctx.SetException(v)46				p.GetErrorHandler().ReportError(p, v)47				p.GetErrorHandler().Recover(p, v)48			} else {49				panic(err)50			}51		}52	}()53	p.EnterOuterAlt(localctx, 1)54	match(p, "syntax")55	{56		p.SetState(88)57		var _m = p.Match(ApiParserParserID)58		localctx.(*SyntaxLitContext).syntaxToken = _m59	}60	{61		p.SetState(89)62		var _m = p.Match(ApiParserParserT__0)63		localctx.(*SyntaxLitContext).assign = _m64	}65	checkVersion(p)66	{67		p.SetState(91)68		var _m = p.Match(ApiParserParserSTRING)69		localctx.(*SyntaxLitContext).version = _m70	}71	return localctx72}73// IImportSpecContext is an interface to support dynamic dispatch.74type IImportSpecContext interface {75	antlr.ParserRuleContext76	// GetParser returns the parser.77	GetParser() antlr.Parser78	// IsImportSpecContext differentiates from other interfaces.79	IsImportSpecContext()80}81type ImportSpecContext struct {82	*antlr.BaseParserRuleContext83	parser antlr.Parser84}85func NewEmptyImportSpecContext() *ImportSpecContext {86	var p = new(ImportSpecContext)87	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)88	p.RuleIndex = ApiParserParserRULE_importSpec89	return p90}91func (*ImportSpecContext) IsImportSpecContext() {}92func NewImportSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportSpecContext {93	var p = new(ImportSpecContext)94	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)95	p.parser = parser96	p.RuleIndex = ApiParserParserRULE_importSpec97	return p98}99func (s *ImportSpecContext) GetParser() antlr.Parser { return s.parser }100func (s *ImportSpecContext) ImportLit() IImportLitContext {101	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImportLitContext)(nil)).Elem(), 0)102	if t == nil {103		return nil104	}105	return t.(IImportLitContext)106}107func (s *ImportSpecContext) ImportBlock() IImportBlockContext {108	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImportBlockContext)(nil)).Elem(), 0)109	if t == nil {110		return nil111	}112	return t.(IImportBlockContext)113}114func (s *ImportSpecContext) GetRuleContext() antlr.RuleContext {115	return s116}117func (s *ImportSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {118	return antlr.TreesStringTree(s, ruleNames, recog)119}120func (s *ImportSpecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {121	switch t := visitor.(type) {122	case ApiParserVisitor:123		return t.VisitImportSpec(s)124	default:125		return t.VisitChildren(s)126	}127}128func (p *ApiParserParser) ImportSpec() (localctx IImportSpecContext) {129	localctx = NewImportSpecContext(p, p.GetParserRuleContext(), p.GetState())130	p.EnterRule(localctx, 6, ApiParserParserRULE_importSpec)131	defer func() {132		p.ExitRule()133	}()134	defer func() {135		if err := recover(); err != nil {136			if v, ok := err.(antlr.RecognitionException); ok {137				localctx.SetException(v)138				p.GetErrorHandler().ReportError(p, v)139				p.GetErrorHandler().Recover(p, v)140			} else {141				panic(err)142			}143		}144	}()145	p.SetState(95)146	p.GetErrorHandler().Sync(p)147	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 2, p.GetParserRuleContext()) {148	case 1:149		p.EnterOuterAlt(localctx, 1)150		{151			p.SetState(93)152			p.ImportLit()153		}154	case 2:155		p.EnterOuterAlt(localctx, 2)156		{157			p.SetState(94)158			p.ImportBlock()159		}160	}161	return localctx162}163// IImportLitContext is an interface to support dynamic dispatch.164type IImportLitContext interface {165	antlr.ParserRuleContext166	// GetParser returns the parser.167	GetParser() antlr.Parser168	// GetImportToken returns the importToken token.169	GetImportToken() antlr.Token170	// SetImportToken sets the importToken token.171	SetImportToken(antlr.Token)172	// IsImportLitContext differentiates from other interfaces.173	IsImportLitContext()174}175type ImportLitContext struct {176	*antlr.BaseParserRuleContext177	parser      antlr.Parser178	importToken antlr.Token179}180func NewEmptyImportLitContext() *ImportLitContext {181	var p = new(ImportLitContext)182	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)183	p.RuleIndex = ApiParserParserRULE_importLit184	return p185}186func (*ImportLitContext) IsImportLitContext() {}187func NewImportLitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportLitContext {188	var p = new(ImportLitContext)189	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)190	p.parser = parser191	p.RuleIndex = ApiParserParserRULE_importLit192	return p193}194func (s *ImportLitContext) GetParser() antlr.Parser { return s.parser }195func (s *ImportLitContext) GetImportToken() antlr.Token { return s.importToken }196func (s *ImportLitContext) SetImportToken(v antlr.Token) { s.importToken = v }197func (s *ImportLitContext) ImportValue() IImportValueContext {198	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImportValueContext)(nil)).Elem(), 0)199	if t == nil {200		return nil201	}202	return t.(IImportValueContext)203}204func (s *ImportLitContext) ID() antlr.TerminalNode {205	return s.GetToken(ApiParserParserID, 0)206}207func (s *ImportLitContext) GetRuleContext() antlr.RuleContext {208	return s209}210func (s *ImportLitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {211	return antlr.TreesStringTree(s, ruleNames, recog)212}213func (s *ImportLitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {214	switch t := visitor.(type) {215	case ApiParserVisitor:216		return t.VisitImportLit(s)217	default:218		return t.VisitChildren(s)219	}220}221func (p *ApiParserParser) ImportLit() (localctx IImportLitContext) {222	localctx = NewImportLitContext(p, p.GetParserRuleContext(), p.GetState())223	p.EnterRule(localctx, 8, ApiParserParserRULE_importLit)224	defer func() {225		p.ExitRule()226	}()227	defer func() {228		if err := recover(); err != nil {229			if v, ok := err.(antlr.RecognitionException); ok {230				localctx.SetException(v)231				p.GetErrorHandler().ReportError(p, v)232				p.GetErrorHandler().Recover(p, v)233			} else {234				panic(err)235			}236		}237	}()238	p.EnterOuterAlt(localctx, 1)239	match(p, "import")240	{241		p.SetState(98)242		var _m = p.Match(ApiParserParserID)243		localctx.(*ImportLitContext).importToken = _m244	}245	{246		p.SetState(99)247		p.ImportValue()248	}249	return localctx250}251// IImportBlockContext is an interface to support dynamic dispatch.252type IImportBlockContext interface {253	antlr.ParserRuleContext254	// GetParser returns the parser.255	GetParser() antlr.Parser256	// GetImportToken returns the importToken token.257	GetImportToken() antlr.Token258	// SetImportToken sets the importToken token.259	SetImportToken(antlr.Token)260	// IsImportBlockContext differentiates from other interfaces.261	IsImportBlockContext()262}263type ImportBlockContext struct {264	*antlr.BaseParserRuleContext265	parser      antlr.Parser266	importToken antlr.Token267}268func NewEmptyImportBlockContext() *ImportBlockContext {269	var p = new(ImportBlockContext)270	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)271	p.RuleIndex = ApiParserParserRULE_importBlock272	return p273}274func (*ImportBlockContext) IsImportBlockContext() {}275func NewImportBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportBlockContext {276	var p = new(ImportBlockContext)277	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)278	p.parser = parser279	p.RuleIndex = ApiParserParserRULE_importBlock280	return p281}282func (s *ImportBlockContext) GetParser() antlr.Parser { return s.parser }283func (s *ImportBlockContext) GetImportToken() antlr.Token { return s.importToken }284func (s *ImportBlockContext) SetImportToken(v antlr.Token) { s.importToken = v }285func (s *ImportBlockContext) ID() antlr.TerminalNode {286	return s.GetToken(ApiParserParserID, 0)287}288func (s *ImportBlockContext) AllImportBlockValue() []IImportBlockValueContext {289	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IImportBlockValueContext)(nil)).Elem())290	var tst = make([]IImportBlockValueContext, len(ts))291	for i, t := range ts {292		if t != nil {293			tst[i] = t.(IImportBlockValueContext)294		}295	}296	return tst297}298func (s *ImportBlockContext) ImportBlockValue(i int) IImportBlockValueContext {299	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImportBlockValueContext)(nil)).Elem(), i)300	if t == nil {301		return nil302	}303	return t.(IImportBlockValueContext)304}305func (s *ImportBlockContext) GetRuleContext() antlr.RuleContext {306	return s307}308func (s *ImportBlockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {309	return antlr.TreesStringTree(s, ruleNames, recog)310}311func (s *ImportBlockContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {312	switch t := visitor.(type) {313	case ApiParserVisitor:314		return t.VisitImportBlock(s)315	default:316		return t.VisitChildren(s)317	}318}319func (p *ApiParserParser) ImportBlock() (localctx IImportBlockContext) {320	localctx = NewImportBlockContext(p, p.GetParserRuleContext(), p.GetState())321	p.EnterRule(localctx, 10, ApiParserParserRULE_importBlock)322	var _la int323	defer func() {324		p.ExitRule()325	}()326	defer func() {327		if err := recover(); err != nil {328			if v, ok := err.(antlr.RecognitionException); ok {329				localctx.SetException(v)330				p.GetErrorHandler().ReportError(p, v)331				p.GetErrorHandler().Recover(p, v)332			} else {333				panic(err)334			}335		}336	}()337	p.EnterOuterAlt(localctx, 1)338	match(p, "import")339	{340		p.SetState(102)341		var _m = p.Match(ApiParserParserID)342		localctx.(*ImportBlockContext).importToken = _m343	}344	{345		p.SetState(103)346		p.Match(ApiParserParserT__1)347	}348	p.SetState(105)349	p.GetErrorHandler().Sync(p)350	for ok := true; ok; ok = _la == ApiParserParserSTRING {351		{352			p.SetState(104)353			p.ImportBlockValue()354		}355		p.SetState(107)356		p.GetErrorHandler().Sync(p)357		_la = p.GetTokenStream().LA(1)358	}359	{360		p.SetState(109)361		p.Match(ApiParserParserT__2)362	}363	return localctx364}365// IImportBlockValueContext is an interface to support dynamic dispatch.366type IImportBlockValueContext interface {367	antlr.ParserRuleContext368	// GetParser returns the parser.369	GetParser() antlr.Parser370	// IsImportBlockValueContext differentiates from other interfaces.371	IsImportBlockValueContext()372}373type ImportBlockValueContext struct {374	*antlr.BaseParserRuleContext375	parser antlr.Parser376}377func NewEmptyImportBlockValueContext() *ImportBlockValueContext {378	var p = new(ImportBlockValueContext)379	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)380	p.RuleIndex = ApiParserParserRULE_importBlockValue381	return p382}383func (*ImportBlockValueContext) IsImportBlockValueContext() {}384func NewImportBlockValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportBlockValueContext {385	var p = new(ImportBlockValueContext)386	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)387	p.parser = parser388	p.RuleIndex = ApiParserParserRULE_importBlockValue389	return p390}391func (s *ImportBlockValueContext) GetParser() antlr.Parser { return s.parser }392func (s *ImportBlockValueContext) ImportValue() IImportValueContext {393	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImportValueContext)(nil)).Elem(), 0)394	if t == nil {395		return nil396	}397	return t.(IImportValueContext)398}399func (s *ImportBlockValueContext) GetRuleContext() antlr.RuleContext {400	return s401}402func (s *ImportBlockValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {403	return antlr.TreesStringTree(s, ruleNames, recog)404}405func (s *ImportBlockValueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {406	switch t := visitor.(type) {407	case ApiParserVisitor:408		return t.VisitImportBlockValue(s)409	default:410		return t.VisitChildren(s)411	}412}413func (p *ApiParserParser) ImportBlockValue() (localctx IImportBlockValueContext) {414	localctx = NewImportBlockValueContext(p, p.GetParserRuleContext(), p.GetState())415	p.EnterRule(localctx, 12, ApiParserParserRULE_importBlockValue)416	defer func() {417		p.ExitRule()...

portalDecompress.go

Source:portalDecompress.go

...33	}34	return nil35}36func decompressInternalResources(portal *unstructured.Data) error {37	portalName, err := portal.UnsafeGetField("name").StringValue()38	if err != nil {39		return err40	}41	resources, err := portal.GetByPointer(portalInternalResourcesPath)42	if err != nil {43		// this will happen if the portal doesn't have internal resources. just return44		return nil45	}46	keys, err := resources.Keys()47	if err != nil {48		return err49	}50	for _, id := range keys {51		resourceData, err := resources.GetByPointer("/" + id)52		if err != nil {53			return err54		}55		resourceName, err := resourceData.UnsafeGetField("name").StringValue()56		if err != nil {57			return err58		}59		if err := writeInternalResource(portalName, resourceName, &resourceData); err != nil {60			return err61		}62	}63	portalConfig, err := portal.GetByPointer(portalConfigPath)64	if err != nil {65		return err66	}67	if err = portalConfig.SetField("internalResources", "./"+portalConfigDirectory+"/"+internalResourcesDirectory); err != nil {68		return err69	}70	return nil71}72func decompressDatasources(portal *unstructured.Data) error {73	portalName, err := portal.UnsafeGetField("name").StringValue()74	if err != nil {75		return err76	}77	d, err := portal.GetByPointer(portalDatasourcesPath)78	if err != nil {79		// this will happen if the portal doesn't have datasources. just return80		return nil81	}82	datasources, err := d.ObValue()83	if err != nil {84		return err85	}86	for _, ds := range datasources {87		dataSourceData := ds.(map[string]interface{})88		dataSourceName := dataSourceData["name"].(string)89		if err := writeDatasource(portalName, dataSourceName, dataSourceData); err != nil {90			return err91		}92	}93	portalConfig, err := portal.GetByPointer(portalConfigPath)94	if err != nil {95		return err96	}97	if err = portalConfig.SetField("datasources", "./"+portalConfigDirectory+"/"+datasourceDirectory); err != nil {98		return err99	}100	return nil101}102func writeDatasource(portalName, dataSourceName string, data map[string]interface{}) error {103	myDatasourceDir := filepath.Join(portalsDir, portalName, portalConfigDirectory, datasourceDirectory, dataSourceName)104	if err := os.MkdirAll(myDatasourceDir, 0777); err != nil {105		return err106	}107	settings, ok := data["settings"].(map[string]interface{})108	if !ok {109		return fmt.Errorf("No datasource settings for '%s'", dataSourceName)110	}111	dsParser := getDatasourceParser(settings)112	if dsParser != "" {113		settings[datasourceParserKey] = "./" + datasourceParserFileName114		if err := writeFile(myDatasourceDir+"/"+datasourceParserFileName, dsParser); err != nil {115			return err116		}117	}118	return writeEntity(myDatasourceDir, "meta", data)119}120func decompressWidgets(portal *unstructured.Data) error {121	portalName, err := portal.UnsafeGetField("name").StringValue()122	if err != nil {123		return err124	}125	w, err := portal.GetByPointer(portalWidgetsPath)126	if err != nil {127		// this will happen if the portal doesn't have widgets. just return128		return nil129	}130	widgets, err := w.ObValue()131	if err != nil {132		return err133	}134	for id := range widgets {135		widgetData, err := portal.GetByPointer(portalWidgetsPath + "/" + id)136		if err != nil {137			return err138		}139		widgetName := getOrGenerateWidgetName(widgetData)140		if err := writeWidget(portalName, widgetName, &widgetData); err != nil {141			return err142		}143	}144	portalConfig, err := portal.GetByPointer(portalConfigPath)145	if err != nil {146		return err147	}148	portalConfig.SetField("widgets", "./"+portalConfigDirectory+"/"+widgetsDirectory)149	return nil150}151func getOrGenerateWidgetName(widgetData unstructured.Data) string {152	widgetID, _ := widgetData.UnsafeGetField("id").StringValue()153	widgetType, _ := widgetData.UnsafeGetField("type").StringValue()154	name := fmt.Sprintf("%s"+"_"+"%v", widgetType, widgetID)155	return name156}157// currentWidgetRelativePath = portals/empty/config/widgets/HTML_WIDGET_COMPONENT_brand158// parserSettingRelativePath = parsers/html159func writeParserBasedOnDataType(dataType string, setting *unstructured.Data, currentWidgetRelativePath, parserSettingRelativePath string) error {160	found := false161	if setting.HasKey(incomingParserKey) {162		raw, _ := setting.GetByPointer("/" + incomingParserKey)163		ip := &raw164		found = true165		if dataType != dynamicDataType && setting.HasKey("value") {166			ip = setting167		}168		if err := writeParserFiles(ip, currentWidgetRelativePath, filepath.Join(parserSettingRelativePath, incomingParserKey)); err != nil {169			return err170		}171	}172	if setting.HasKey(outgoingParserKey) {173		found = true174		raw, _ := setting.GetByPointer("/" + outgoingParserKey)175		op := &raw176		if dataType != dynamicDataType && setting.HasKey("value") {177			op = setting178		}179		if err := writeParserFiles(op, currentWidgetRelativePath, filepath.Join(parserSettingRelativePath, outgoingParserKey)); err != nil {180			return err181		}182	}183	if !found {184		if setting.HasKey("value") {185			if err := writeParserFiles(setting, currentWidgetRelativePath, filepath.Join(parserSettingRelativePath, incomingParserKey)); err != nil {186				return err187			}188		}189	}190	return nil191}192func writeWidgetMeta(widgetDir string, widgetConfig *unstructured.Data) error {193	keys, err := widgetConfig.Keys()194	if err != nil {195		return err196	}197	meta := make(map[string]interface{})198	// grab all the keys except for "props" aka settings199	for _, k := range keys {200		if k != "props" {201			meta[k] = widgetConfig.UnsafeGetField(k).RawValue()202		}203	}204	return writeFile(filepath.Join(widgetDir, portalWidgetMetaFile), meta)205}206func writeWidgetSettings(widgetDir string, widgetConfig *unstructured.Data) error {207	return writeFile(filepath.Join(widgetDir, portalWidgetSettingsFile), widgetConfig.UnsafeGetField("props").RawValue())208}209func createInternalResourceMeta(resourceData *unstructured.Data) (map[string]interface{}, error) {210	keys, err := resourceData.Keys()211	if err != nil {212		return nil, err213	}214	rtn := make(map[string]interface{})215	for _, k := range keys {216		if k == "file" {217			fileName, err := resourceData.UnsafeGetField("name").StringValue()218			if err != nil {219				return nil, err220			}221			rtn[k] = "./" + fileName222		} else {223			rtn[k] = resourceData.UnsafeGetField(k).RawValue()224		}225	}226	return rtn, nil227}228func writeInternalResource(portalName, resourceName string, resourceData *unstructured.Data) error {229	// write the parser file230	currResourceDir := filepath.Join(portalsDir, portalName, portalInternalResourcesPath, resourceName)231	file := resourceData.UnsafeGetField("file")232	fileStr, err := file.StringValue()233	if err != nil {234		return err235	}236	if err := writeFile(currResourceDir+"/"+resourceName, fileStr); err != nil {237		return err238	}239	meta, err := createInternalResourceMeta(resourceData)240	if err != nil {241		return err242	}243	if err := writeFile(currResourceDir+"/"+portalInternalResourceMetaFile, meta); err != nil {244		return err245	}246	return nil247}248func writeWidget(portalName, widgetName string, widgetData *unstructured.Data) error {249	currWidgetDir := filepath.Join(portalsDir, portalName, portalConfigDirectory, widgetsDirectory, widgetName)250	widgetDataMap, err := widgetData.UnsafeGetField("props").ObValue()251	if err != nil {252		return err253	}254	if err := actOnParserSettings(widgetDataMap, func(settingName, dataType string) error {255		parserSetting, err := widgetData.GetByPointer("/props/" + settingName)256		if err != nil {257			return err258		}259		if err := writeParserBasedOnDataType(dataType, &parserSetting, currWidgetDir, filepath.Join(parsersDirectory, settingName)); err != nil {260			return err261		}262		return nil263	}); err != nil {264		return err265	}266	if err := writeWidgetMeta(currWidgetDir, widgetData); err != nil {267		return err268	}269	if err := writeWidgetSettings(currWidgetDir, widgetData); err != nil {270		return err271	}272	return nil273}274func writeParserFiles(parserData *unstructured.Data, currWidgetDir, parserDir string) error {275	keysToIgnoreInData := map[string]interface{}{}276	path := filepath.Join(currWidgetDir, parserDir, outFile)277	if parserData.HasKey("value") {278		value := parserData.UnsafeGetField("value")279		switch value.RawValue().(type) {280		case string:281			str, _ := value.StringValue()282			if err := writeFile(path+jsFileSuffix, str); err != nil {283				return err284			}285			if err := parserData.SetField("value", "./"+filepath.Join(parserDir, outFile)+jsFileSuffix); err != nil {286				return err287			}288		case map[string]interface{}:289			mapp, _ := value.ObValue()290			if err := writeHTMLFiles(path, mapp, keysToIgnoreInData); err != nil {291				return err292			}293			if err := parserData.SetField("value", map[string]interface{}{"CSS": "./" + filepath.Join(parserDir, outFile) + ".css", "HTML": "./" + filepath.Join(parserDir, outFile) + ".html", "JavaScript": "./" + filepath.Join(parserDir, outFile) + ".js"}); err != nil {294				return err295			}...

types.go

Source:types.go

...94		return "", fmt.Errorf("unsupported database type: %v", dataBaseType)95	}96	return mayConvertNullType(tp, isDefaultNull), nil97}98// ConvertStringDataType converts mysql column type into golang type99func ConvertStringDataType(dataBaseType string, isDefaultNull bool) (string, error) {100	tp, ok := commonMysqlDataTypeMap2[strings.ToLower(dataBaseType)]101	if !ok {102		return "", fmt.Errorf("unsupported database type: %s", dataBaseType)103	}104	return mayConvertNullType(tp, isDefaultNull), nil105}106func mayConvertNullType(goDataType string, isDefaultNull bool) string {107	if !isDefaultNull {108		return goDataType109	}110	switch goDataType {111	case "int64":112		return "sql.NullInt64"113	case "int32":114		return "sql.NullInt32"115	case "float64":116		return "sql.NullFloat64"117	case "bool":118		return "sql.NullBool"119	case "string":120		return "sql.NullString"121	case "time.Time":122		return "sql.NullTime"123	default:124		return goDataType125	}126}...

portalUtils.go

Source:portalUtils.go

...66func getPortalInternalResourceMetaFile(internalResourceDir string) (map[string]interface{}, error) {67	return getDict(internalResourceDir + "/" + portalInternalResourceMetaFile)68}69func getPortalInternalResourceCode(internalResourceDir, fileName string) (string, error) {70	return readFileAsString(internalResourceDir + "/" + fileName)71}72func isInsideDirectory(dir, currentPath string) bool {73	split := strings.Split(currentPath, string(os.PathSeparator))74	return split[len(split)-2] == dir75}76func hasDatasourceParser(settings map[string]interface{}) bool {77	useParser, ok := settings[datasourceUseParserKey].(bool)78	return ok && useParser79}80func getDatasourceParser(settings map[string]interface{}) string {81	if hasDatasourceParser(settings) {82		return settings[datasourceParserKey].(string)83	}84	return ""...

run.go

Source:run.go

...14)15//Run å¯å¨app16func Run() {17	utils.PrintStr()18	mode := flag.String("mode", "dev", "eventment")19	flag.Parse()20	mysql, err := getMysql(*mode)21	if err != nil {22		panic(err)23	}24	dbs.RunMysql(mysql)25	app, err := getApp(*mode)26	fmt.Println("app", app)27	if err != nil {28		panic(err)29	}30	Uxiaowechat, err := getQyChartInfo(*mode)31	if err != nil {32		panic(err)33	}34	wechat.GetQyInfo(Uxiaowechat)35	fmt.Println("Uxiaowechat", Uxiaowechat)36	u1 := uuid.NewV4()37	fmt.Printf("UUIDv4: %s\n", u1)38	fmt.Println("uuid type", reflect.TypeOf(u1))39	router := apiRouter.Router(app)40	router.Run(app.Port)41}42func readIni(mode string) (iniParser config.IniParser, err error) {43	confFileName := "dev.ini"44	if mode == "prod" {45		confFileName = "prod.ini"46	}47	//iniParser = conf.IniParser{}48	dir, _ := os.Getwd()49	pathName := dir + `/config/` + confFileName50	err = iniParser.Load(pathName)51	return iniParser, err52}53func getApp(mode string) (app config.App, err error) {54	iniParser, err := readIni(mode)55	if err != nil {56		return app, err57	}58	app = config.App{59		Mode: mode,60		Port: iniParser.GetString("app", "port"),61	}62	return app, nil63}64func getMysql(mode string) (mysql config.Mysql, err error) {65	iniParser, err := readIni(mode)66	if err != nil {67		return mysql, err68	}69	mysql = config.Mysql{70		User:     iniParser.GetString("mysql", "user"),71		Password: iniParser.GetString("mysql", "password"),72		Host:     iniParser.GetString("mysql", "host"),73		Port:     iniParser.GetString("mysql", "port"),74		Database: iniParser.GetString("mysql", "database"),75	}76	return mysql, err77}78func getQyChartInfo(mode string) (wechat config.Uxiaowechat, err error) {79	iniParser, err := readIni(mode)80	if err != nil {81		return wechat, err82	}83	wechat = config.Uxiaowechat{84		CorpID:         iniParser.GetString("Uxiaowechat", "CorpID"),85		Corpsecret:     iniParser.GetString("Uxiaowechat", "Corpsecret"),86		TokenURL:       iniParser.GetString("Uxiaowechat", "TokenURL"),87		AgentID:        iniParser.GetString("Uxiaowechat", "AgentID"),88		CreateChatURL:  iniParser.GetString("Uxiaowechat", "CreateChatURL"),89		SendInfoURL:    iniParser.GetString("Uxiaowechat", "SendInfoURL"),90		SendMemberURL:  iniParser.GetString("Uxiaowechat", "SendInfoURL"),91		QYChatInfo:     iniParser.GetString("Uxiaowechat", "QYChatInfo"),92		QYChatUserInfo: iniParser.GetString("Uxiaowechat", "QYChatUserInfo"),93	}94	return wechat, err95}...

String

Using AI Code Generation

1import (2type BaseListener struct {3}4func (bl *BaseListener) EnterEveryRule(ctx antlr.ParserRuleContext) {5	fmt.Println("EnterEveryRule")6}7func (bl *BaseListener) ExitEveryRule(ctx antlr.ParserRuleContext) {8	fmt.Println("ExitEveryRule")9}10func main() {11	is := antlr.NewInputStream("a = 1")12	lexer := parser.NewparserLexer(is)13	stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)14	p := parser.NewparserParser(stream)15	p.Start()16}

String

Using AI Code Generation

1import (2func main() {3 fmt.Println("Hello World!")4 p := parser.New()5 fmt.Println(p.String())6}

String

Using AI Code Generation

1import "fmt"2import "parser"3func main() {4 p := parser.New("Hello, World!")5 fmt.Println(p.String())6}

String

Using AI Code Generation

1import (2var (3func PrintVersion() {4	fmt.Printf("Version: %s\n", Version)5	fmt.Printf("BuildDate: %s\n", BuildDate)6	fmt.Printf("GitCommit: %s\n", GitCommit)7	fmt.Printf("GoVersion: %s\n", runtime.Version())8	fmt.Printf("NumCPU: %d\n", runtime.NumCPU())9}10func PrintUsage() {11	fmt.Println("Usage: 1 [OPTIONS] [ARGS]")12	fmt.Println("")13	fmt.Println("Options:")14	fmt.Println("  -h, --help    Print this help message.")15	fmt.Println("      --version Print the version of the program.")16	fmt.Println("")17	fmt.Println("  -a, --all     List all services.")18	fmt.Println("  -d, --detail  Print detailed information.")19	fmt.Println("  -r, --running List only running services.")20	fmt.Println("  -s, --stopped List only stopped services.")21	fmt.Println("  -f, --failed  List only failed services.")22	fmt.Println("  -t, --tail    Tail the logs of the service.")23	fmt.Println("  -l, --logs    Print the logs of the service.")24	fmt.Println("  -p, --pid     Print the PID of the service.")25	fmt.Println("  -u, --user    Print the user of the service.")26	fmt.Println("  -c, --count   Print the number of services.")27	fmt.Println("  -i, --init    Print the init system.")28	fmt.Println("")29	fmt.Println("  -o, --output  Print the output of the command.")30	fmt.Println("")31	fmt.Println("  -n, --name    Filter by name.")32	fmt.Println("  -m, --match   Filter by match.")33	fmt.Println("  -b, --before  Filter by before.")

String

Using AI Code Generation

1import (2func main() {3	str := "a + b * (c + d) + e * f"4	p := parser.NewParser()5	tree := p.Parse(str)6	str2 := p.String(tree)7	fmt.Println(str2)8}

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.