From 7314a03e1ce91f1b0ea14d969a75424645ca9d9c Mon Sep 17 00:00:00 2001 From: lbbniu Date: Thu, 22 Jun 2023 09:55:58 +0800 Subject: [PATCH 1/2] perf(gencode): gen_go optimization, adding helper functions --- tars/tools/tars2go/gencode/gen_go.go | 1428 ++++++++++++-------------- 1 file changed, 650 insertions(+), 778 deletions(-) diff --git a/tars/tools/tars2go/gencode/gen_go.go b/tars/tools/tars2go/gencode/gen_go.go index d896dc5b..034e83c9 100755 --- a/tars/tools/tars2go/gencode/gen_go.go +++ b/tars/tools/tars2go/gencode/gen_go.go @@ -4,7 +4,6 @@ import ( "bytes" "fmt" "go/format" - "io/ioutil" "os" "path/filepath" "runtime" @@ -60,8 +59,7 @@ func errString(hasRet bool) string { } return `if err != nil { ` + retStr + ` - } -` + }` } func genForHead(vc string) string { @@ -71,7 +69,7 @@ func genForHead(vc string) string { } // Gen to parse file. -func (gen *GenGo) Gen() { +func (g *GenGo) Gen() { defer func() { if err := recover(); err != nil { fmt.Println(err) @@ -80,140 +78,147 @@ func (gen *GenGo) Gen() { } }() - gen.module = parse.NewParse(gen.opt, gen.filepath, make([]string, 0)) - gen.genAll() + g.module = parse.NewParse(g.opt, g.filepath, make([]string, 0)) + g.genAll() } -func (gen *GenGo) genAll() { - if _, ok := fileMap.Load(gen.filepath); ok { +func (g *GenGo) P(v ...string) { + for _, x := range v { + fmt.Fprint(&g.code, x) + } + fmt.Fprintln(&g.code) +} + +func (g *GenGo) W(v ...string) { + for _, x := range v { + fmt.Fprint(&g.code, x) + } +} + +func (g *GenGo) genAll() { + if _, ok := fileMap.Load(g.filepath); ok { // already compiled return } - fileMap.Store(gen.filepath, struct{}{}) + fileMap.Store(g.filepath, struct{}{}) - gen.module.Rename(gen.opt.ModuleUpper) - gen.genInclude(gen.module.IncModule) + g.module.Rename(g.opt.ModuleUpper) + g.genInclude(g.module.IncModule) - gen.code.Reset() - gen.genHead() - gen.genPackage() + g.code.Reset() + g.genHead() + g.genPackage() - for _, v := range gen.module.Enum { - gen.genEnum(&v) + for _, v := range g.module.Enum { + g.genEnum(&v) } - gen.genConst(gen.module.Const) + g.genConst(g.module.Const) - for _, v := range gen.module.Struct { - gen.genStruct(&v) + for _, v := range g.module.Struct { + g.genStruct(&v) } - if len(gen.module.Enum) > 0 || len(gen.module.Const) > 0 || len(gen.module.Struct) > 0 { - gen.saveToSourceFile(utils.Path2ProtoName(gen.filepath) + ".go") + if len(g.module.Enum) > 0 || len(g.module.Const) > 0 || len(g.module.Struct) > 0 { + g.saveToSourceFile(utils.Path2ProtoName(g.filepath) + ".go") } - for _, v := range gen.module.Interface { - gen.genInterface(&v) + for _, v := range g.module.Interface { + g.genInterface(&v) } } -func (gen *GenGo) genErr(err string) { +func (g *GenGo) genErr(err string) { panic(err) } -func (gen *GenGo) saveToSourceFile(filename string) { +func (g *GenGo) saveToSourceFile(filename string) { var beauty []byte var err error - prefix := gen.prefix + prefix := g.prefix - if !gen.opt.E { - beauty, err = format.Source(gen.code.Bytes()) + if !g.opt.E { + beauty, err = format.Source(g.code.Bytes()) if err != nil { - if gen.opt.Debug { + if g.opt.Debug { fmt.Println("------------------") - fmt.Println(string(gen.code.Bytes())) + fmt.Println(string(g.code.Bytes())) fmt.Println("------------------") } - gen.genErr("go fmt fail. " + filename + " " + err.Error()) + g.genErr("go fmt fail. " + filename + " " + err.Error()) } } else { - beauty = gen.code.Bytes() + beauty = g.code.Bytes() } if filename == "stdout" { fmt.Println(string(beauty)) } else { var mkPath string - if gen.opt.ModuleCycle { - mkPath = prefix + gen.ProtoName + "/" + gen.module.Name + if g.opt.ModuleCycle { + mkPath = prefix + g.ProtoName + "/" + g.module.Name } else { - mkPath = prefix + gen.module.Name + mkPath = prefix + g.module.Name } err = os.MkdirAll(mkPath, 0766) - if err != nil { - gen.genErr(err.Error()) + g.genErr(err.Error()) } - err = ioutil.WriteFile(mkPath+"/"+filename, beauty, 0666) + err = os.WriteFile(mkPath+"/"+filename, beauty, 0666) if err != nil { - gen.genErr(err.Error()) + g.genErr(err.Error()) } } } -func (gen *GenGo) genVariableName(prefix, name string) string { +func (g *GenGo) genVariableName(prefix, name string) string { if strings.HasPrefix(name, "(*") && strings.HasSuffix(name, ")") { return strings.Trim(name, "()") } return prefix + name } -func (gen *GenGo) genHead() { - gen.code.WriteString(`// Package ` + gen.module.Name + ` comment -// This file was generated by tars2go ` + version.VERSION + ` -// Generated from ` + filepath.Base(gen.filepath) + ` -`) +func (g *GenGo) genHead() { + g.P("// Package ", g.module.Name, " comment") + g.P("// This file was generated by tars2go ", version.VERSION) + g.P("// Generated from ", filepath.Base(g.filepath)) } -func (gen *GenGo) genPackage() { - gen.code.WriteString("package " + gen.module.Name + "\n\n") - gen.code.WriteString(` -import ( - "fmt" - -`) - gen.code.WriteString(`"` + gen.opt.TarsPath + "/protocol/codec\"\n") +func (g *GenGo) genPackage() { + g.P("package ", g.module.Name) + g.P() + g.P("import (") + g.P(strconv.Quote("fmt")) + g.P() + g.P(strconv.Quote(g.opt.TarsPath + "/protocol/codec")) mImports := make(map[string]bool) - for _, st := range gen.module.Struct { - if gen.opt.ModuleCycle { + for _, st := range g.module.Struct { + if g.opt.ModuleCycle { for k, v := range st.DependModuleWithJce { - gen.genStructImport(k, v, mImports) + g.genStructImport(k, v, mImports) } } else { for k := range st.DependModule { - gen.genStructImport(k, "", mImports) + g.genStructImport(k, "", mImports) } } } for path := range mImports { - gen.code.WriteString(path + "\n") + g.P(path) } - - gen.code.WriteString(`) - - // Reference imports to suppress errors if they are not otherwise used. - var _ = fmt.Errorf - var _ = codec.FromInt8 - -`) + g.P(")") + g.P() + g.P("// Reference imports to suppress errors if they are not otherwise used.") + g.P("var _ = fmt.Errorf") + g.P("var _ = codec.FromInt8") } -func (gen *GenGo) genStructImport(module string, protoName string, mImports map[string]bool) { +func (g *GenGo) genStructImport(module string, protoName string, mImports map[string]bool) { var moduleStr string var jcePath string var moduleAlia string - if gen.opt.ModuleCycle { + if g.opt.ModuleCycle { moduleStr = module[len(protoName)+1:] jcePath = protoName + "/" moduleAlia = module + " " @@ -221,14 +226,14 @@ func (gen *GenGo) genStructImport(module string, protoName string, mImports map[ moduleStr = module } - for _, p := range gen.opt.Imports { + for _, p := range g.opt.Imports { if strings.HasSuffix(p, "/"+moduleStr) { - mImports[`"`+p+`"`] = true + mImports[strconv.Quote(p)] = true return } } - if gen.opt.ModuleUpper { + if g.opt.ModuleUpper { moduleAlia = utils.UpperFirstLetter(moduleAlia) } @@ -242,8 +247,8 @@ func (gen *GenGo) genStructImport(module string, protoName string, mImports map[ // MyApp // TarsTest/MyApp var modulePath string - if gen.opt.Module != "" { - mf := filepath.Clean(filepath.Join(gen.opt.Module, gen.prefix)) + if g.opt.Module != "" { + mf := filepath.Clean(filepath.Join(g.opt.Module, g.prefix)) if runtime.GOOS == "windows" { mf = strings.ReplaceAll(mf, string(os.PathSeparator), string('/')) } @@ -251,76 +256,77 @@ func (gen *GenGo) genStructImport(module string, protoName string, mImports map[ } else { modulePath = fmt.Sprintf("%s%s", jcePath, moduleStr) } - mImports[moduleAlia+`"`+modulePath+`"`] = true + mImports[moduleAlia+strconv.Quote(modulePath)] = true } -func (gen *GenGo) genIFPackage(itf *ast.InterfaceInfo) { - gen.code.WriteString("package " + gen.module.Name + "\n\n") - gen.code.WriteString(` -import ( - "bytes" - "context" - "fmt" - "unsafe" - "encoding/json" -`) - tarsPath := gen.opt.TarsPath - if gen.opt.AddServant { - gen.code.WriteString(`"` + tarsPath + "\"\n") - } +func (g *GenGo) genIFPackage(itf *ast.InterfaceInfo) { + g.P("package " + g.module.Name) + g.P() - gen.code.WriteString(`"` + tarsPath + "/protocol/res/requestf\"\n") - gen.code.WriteString(`m "` + tarsPath + "/model\"\n") - gen.code.WriteString(`"` + tarsPath + "/protocol/codec\"\n") - gen.code.WriteString(`"` + tarsPath + "/protocol/tup\"\n") - gen.code.WriteString(`"` + tarsPath + "/protocol/res/basef\"\n") - gen.code.WriteString(`"` + tarsPath + "/util/tools\"\n") - gen.code.WriteString(`"` + tarsPath + "/util/endpoint\"\n") - gen.code.WriteString(`"` + tarsPath + "/util/current\"\n") - if !gen.opt.WithoutTrace { - gen.code.WriteString("tarstrace \"" + tarsPath + "/util/trace\"\n") + g.P("import (") + g.P(strconv.Quote("bytes")) + g.P(strconv.Quote("context")) + g.P(strconv.Quote("encoding/json")) + g.P(strconv.Quote("fmt")) + //g.P(strconv.Quote("unsafe")) + g.P() + + tarsPath := g.opt.TarsPath + if g.opt.AddServant || !g.opt.WithoutTrace { + g.P(strconv.Quote(tarsPath)) + } + g.P(strconv.Quote(tarsPath + "/model")) + g.P(strconv.Quote(tarsPath + "/protocol/res/requestf")) + g.P(strconv.Quote(tarsPath + "/protocol/codec")) + g.P(strconv.Quote(tarsPath + "/protocol/tup")) + g.P(strconv.Quote(tarsPath + "/protocol/res/basef")) + g.P(strconv.Quote(tarsPath + "/util/tools")) + g.P(strconv.Quote(tarsPath + "/util/endpoint")) + g.P(strconv.Quote(tarsPath + "/util/current")) + if !g.opt.WithoutTrace { + g.P("tarstrace ", strconv.Quote(tarsPath+"/util/trace")) } - if gen.opt.ModuleCycle == true { + if g.opt.ModuleCycle { for k, v := range itf.DependModuleWithJce { - gen.genIFImport(k, v) + g.genIFImport(k, v) } } else { for k := range itf.DependModule { - gen.genIFImport(k, "") + g.genIFImport(k, "") } } - gen.code.WriteString(`) - // Reference imports to suppress errors if they are not otherwise used. - var ( - _ = fmt.Errorf - _ = codec.FromInt8 - _ = unsafe.Pointer(nil) - _ = bytes.ErrTooLarge - ) -`) + g.P(")") + g.P() + g.P("// Reference imports to suppress errors if they are not otherwise used.") + g.P("var (") + g.P(" _ = fmt.Errorf") + g.P(" _ = codec.FromInt8") + //g.P(" _ = unsafe.Pointer(nil)") + g.P(" _ = bytes.ErrTooLarge") + g.P(")") } -func (gen *GenGo) genIFImport(module string, protoName string) { +func (g *GenGo) genIFImport(module string, protoName string) { var moduleStr string var jcePath string var moduleAlia string - if gen.opt.ModuleCycle { + if g.opt.ModuleCycle { moduleStr = module[len(protoName)+1:] jcePath = protoName + "/" moduleAlia = module + " " } else { moduleStr = module } - for _, p := range gen.opt.Imports { + for _, p := range g.opt.Imports { if strings.HasSuffix(p, "/"+moduleStr) { - gen.code.WriteString(`"` + p + `"` + "\n") + g.P(strconv.Quote(p)) return } } - if gen.opt.ModuleUpper { + if g.opt.ModuleUpper { moduleAlia = utils.UpperFirstLetter(moduleAlia) } @@ -334,8 +340,8 @@ func (gen *GenGo) genIFImport(module string, protoName string) { // MyApp // TarsTest/MyApp var modulePath string - if gen.opt.Module != "" { - mf := filepath.Clean(filepath.Join(gen.opt.Module, gen.prefix)) + if g.opt.Module != "" { + mf := filepath.Clean(filepath.Join(g.opt.Module, g.prefix)) if runtime.GOOS == "windows" { mf = strings.ReplaceAll(mf, string(os.PathSeparator), string('/')) } @@ -343,10 +349,27 @@ func (gen *GenGo) genIFImport(module string, protoName string) { } else { modulePath = fmt.Sprintf("%s%s", jcePath, moduleStr) } - gen.code.WriteString(moduleAlia + `"` + modulePath + `"` + "\n") + g.P(moduleAlia, strconv.Quote(modulePath)) } -func (gen *GenGo) genType(ty *ast.VarType) string { +func (g *GenGo) typeDef(mb *ast.StructMember) string { + if mb.Default != "" { + return mb.Default + } + switch mb.Type.Type { + case token.TBool: + return "false" + case token.TShort, token.TInt, token.TLong, token.TFloat, token.TDouble: + return "0" + case token.TString: + return strconv.Quote("") + default: + g.genErr("typeDef unknown type") + } + return "" +} + +func (g *GenGo) genType(ty *ast.VarType) string { ret := "" switch ty.Type { case token.TBool: @@ -382,14 +405,14 @@ func (gen *GenGo) genType(ty *ast.VarType) string { case token.TString: ret = "string" case token.TVector: - ret = "[]" + gen.genType(ty.TypeK) + ret = "[]" + g.genType(ty.TypeK) case token.TMap: - ret = "map[" + gen.genType(ty.TypeK) + "]" + gen.genType(ty.TypeV) + ret = "map[" + g.genType(ty.TypeK) + "]" + g.genType(ty.TypeV) case token.Name: ret = strings.Replace(ty.TypeSt, "::", ".", -1) vec := strings.Split(ty.TypeSt, "::") for i := range vec { - if gen.opt.ModuleUpper { + if g.opt.ModuleUpper { vec[i] = utils.UpperFirstLetter(vec[i]) } else { if i == (len(vec) - 1) { @@ -399,463 +422,393 @@ func (gen *GenGo) genType(ty *ast.VarType) string { } ret = strings.Join(vec, ".") case token.TArray: - ret = "[" + fmt.Sprintf("%v", ty.TypeL) + "]" + gen.genType(ty.TypeK) + ret = "[" + fmt.Sprintf("%v", ty.TypeL) + "]" + g.genType(ty.TypeK) default: - gen.genErr("Unknown Type " + token.Value(ty.Type)) + g.genErr("Unknown Type " + token.Value(ty.Type)) } return ret } -func (gen *GenGo) genStructDefine(st *ast.StructInfo) { - c := &gen.code - c.WriteString("// " + st.Name + " struct implement\n") - c.WriteString("type " + st.Name + " struct {\n") - +func (g *GenGo) genStructDefine(st *ast.StructInfo) { + g.P("// ", st.Name, " struct implement") + g.P("type ", st.Name, " struct {") for _, v := range st.Mb { - if gen.opt.JsonOmitEmpty { - c.WriteString("\t" + v.Key + " " + gen.genType(v.Type) + " `json:\"" + v.OriginKey + ",omitempty\"`\n") + if g.opt.JsonOmitEmpty { + g.P(v.Key, " ", g.genType(v.Type), " `json:\"", v.OriginKey, ",omitempty\"`") } else { - c.WriteString("\t" + v.Key + " " + gen.genType(v.Type) + " `json:\"" + v.OriginKey + "\"`\n") + g.P(v.Key, " ", g.genType(v.Type), " `json:\"", v.OriginKey, "\"`") } } - c.WriteString("}\n") + g.P("}") } -func (gen *GenGo) genFunResetDefault(st *ast.StructInfo) { - c := &gen.code - - c.WriteString("func (st *" + st.Name + ") ResetDefault() {\n") - +func (g *GenGo) genFunResetDefault(st *ast.StructInfo) { + g.P("func (st *", st.Name, ") ResetDefault() {") for _, v := range st.Mb { if v.Type.CType == token.Struct { - c.WriteString("st." + v.Key + ".ResetDefault()\n") + g.P("st.", v.Key, ".ResetDefault()") } if v.Default == "" { continue } - c.WriteString("st." + v.Key + " = " + v.Default + "\n") + g.P("st.", v.Key, " = ", v.Default) } - c.WriteString("}\n") + g.P("}") } -func (gen *GenGo) genWriteSimpleList(mb *ast.StructMember, prefix string, hasRet bool) { - c := &gen.code +func (g *GenGo) genWriteSimpleList(mb *ast.StructMember, prefix string, hasRet bool) { tag := strconv.Itoa(int(mb.Tag)) - unsign := "Int8" + unsigned := "Int8" if mb.Type.TypeK.Unsigned { - unsign = "Uint8" + unsigned = "Uint8" } errStr := errString(hasRet) - c.WriteString(` -err = buf.WriteHead(codec.SimpleList, ` + tag + `) -` + errStr + ` -err = buf.WriteHead(codec.BYTE, 0) -` + errStr + ` -err = buf.WriteInt32(int32(len(` + gen.genVariableName(prefix, mb.Key) + `)), 0) -` + errStr + ` -err = buf.WriteSlice` + unsign + `(` + gen.genVariableName(prefix, mb.Key) + `) -` + errStr + ` -`) + g.P("err = buf.WriteHead(codec.SimpleList, ", tag, ")") + g.P(errStr) + g.P("err = buf.WriteHead(codec.BYTE, 0)") + g.P(errStr) + g.P("err = buf.WriteInt32(int32(len(", g.genVariableName(prefix, mb.Key), ")), 0)") + g.P(errStr) + g.P("err = buf.WriteSlice", unsigned, `(`, g.genVariableName(prefix, mb.Key), ")") + g.P(errStr) } -func (gen *GenGo) genWriteVector(mb *ast.StructMember, prefix string, hasRet bool) { - c := &gen.code - +func (g *GenGo) genWriteVector(mb *ast.StructMember, prefix string, hasRet bool) { // SimpleList if mb.Type.TypeK.Type == token.TByte && !mb.Type.TypeK.Unsigned { - gen.genWriteSimpleList(mb, prefix, hasRet) + g.genWriteSimpleList(mb, prefix, hasRet) return } - errStr := errString(hasRet) - + if !mb.Require { + g.P("if len(", g.genVariableName(prefix, mb.Key), ") > 0 {") + defer g.P("}") + } // LIST + errStr := errString(hasRet) tag := strconv.Itoa(int(mb.Tag)) - c.WriteString(` -err = buf.WriteHead(codec.LIST, ` + tag + `) -` + errStr + ` -err = buf.WriteInt32(int32(len(` + gen.genVariableName(prefix, mb.Key) + `)), 0) -` + errStr + ` -for _, v := range ` + gen.genVariableName(prefix, mb.Key) + ` { -`) + g.P("err = buf.WriteHead(codec.LIST, ", tag, ")") + g.P(errStr) + g.P("err = buf.WriteInt32(int32(len(", g.genVariableName(prefix, mb.Key), ")), 0)") + g.P(errStr) + g.P("for _, v := range ", g.genVariableName(prefix, mb.Key), " {") // for _, v := range can nesting for _, v := range，does not conflict, support multidimensional arrays dummy := &ast.StructMember{} dummy.Type = mb.Type.TypeK dummy.Key = "v" - gen.genWriteVar(dummy, "", hasRet) + g.genWriteVar(dummy, "", hasRet) - c.WriteString("}\n") + g.P("}") } -func (gen *GenGo) genWriteArray(mb *ast.StructMember, prefix string, hasRet bool) { - c := &gen.code - +func (g *GenGo) genWriteArray(mb *ast.StructMember, prefix string, hasRet bool) { // SimpleList if mb.Type.TypeK.Type == token.TByte && !mb.Type.TypeK.Unsigned { - gen.genWriteSimpleList(mb, prefix, hasRet) + g.genWriteSimpleList(mb, prefix, hasRet) return } - errStr := errString(hasRet) - + if !mb.Require { + g.P("if len(", g.genVariableName(prefix, mb.Key), ") > 0 {") + defer g.P("}") + } // LIST + errStr := errString(hasRet) tag := strconv.Itoa(int(mb.Tag)) - c.WriteString(` -err = buf.WriteHead(codec.LIST, ` + tag + `) -` + errStr + ` -err = buf.WriteInt32(int32(len(` + gen.genVariableName(prefix, mb.Key) + `)), 0) -` + errStr + ` -for _, v := range ` + gen.genVariableName(prefix, mb.Key) + ` { -`) + g.P("err = buf.WriteHead(codec.LIST, ", tag, ")") + g.P(errStr) + g.P("err = buf.WriteInt32(int32(len(", g.genVariableName(prefix, mb.Key), ")), 0)") + g.P(errStr) // for _, v := range can nesting for _, v := range，does not conflict, support multidimensional arrays - + g.P("for _, v := range ", g.genVariableName(prefix, mb.Key), " {") dummy := &ast.StructMember{} dummy.Type = mb.Type.TypeK dummy.Key = "v" - gen.genWriteVar(dummy, "", hasRet) - - c.WriteString("}\n") + g.genWriteVar(dummy, "", hasRet) + g.P("}") } -func (gen *GenGo) genWriteStruct(mb *ast.StructMember, prefix string, hasRet bool) { - c := &gen.code +func (g *GenGo) genWriteStruct(mb *ast.StructMember, prefix string, hasRet bool) { tag := strconv.Itoa(int(mb.Tag)) - c.WriteString(` -err = ` + prefix + mb.Key + `.WriteBlock(buf, ` + tag + `) -` + errString(hasRet) + ` -`) + g.P("err = ", prefix, mb.Key, ".WriteBlock(buf, ", tag, ")") + g.P(errString(hasRet)) } -func (gen *GenGo) genWriteMap(mb *ast.StructMember, prefix string, hasRet bool) { - c := &gen.code +func (g *GenGo) genWriteMap(mb *ast.StructMember, prefix string, hasRet bool) { + if !mb.Require { + g.P("if len(", g.genVariableName(prefix, mb.Key), ") > 0 {") + defer g.P("}") + } + tag := strconv.Itoa(int(mb.Tag)) - vc := strconv.Itoa(gen.vc) - gen.vc++ + vc := strconv.Itoa(g.vc) + g.vc++ errStr := errString(hasRet) - c.WriteString(` -err = buf.WriteHead(codec.MAP, ` + tag + `) -` + errStr + ` -err = buf.WriteInt32(int32(len(` + gen.genVariableName(prefix, mb.Key) + `)), 0) -` + errStr + ` -for k` + vc + `, v` + vc + ` := range ` + gen.genVariableName(prefix, mb.Key) + ` { -`) + g.P("err = buf.WriteHead(codec.MAP, ", tag, ")") + g.P(errStr) + g.P("err = buf.WriteInt32(int32(len(", g.genVariableName(prefix, mb.Key), ")), 0)") + g.P(errStr) + g.P("for k", vc, ", v", vc, " := range ", g.genVariableName(prefix, mb.Key), " {") // for _, v := range can nesting for _, v := range，does not conflict, support multidimensional arrays dummy := &ast.StructMember{} dummy.Type = mb.Type.TypeK dummy.Key = "k" + vc - gen.genWriteVar(dummy, "", hasRet) + g.genWriteVar(dummy, "", hasRet) dummy = &ast.StructMember{} dummy.Type = mb.Type.TypeV dummy.Key = "v" + vc dummy.Tag = 1 - gen.genWriteVar(dummy, "", hasRet) + g.genWriteVar(dummy, "", hasRet) - c.WriteString("}\n") + g.P("}") } -func (gen *GenGo) genWriteVar(v *ast.StructMember, prefix string, hasRet bool) { - c := &gen.code - +func (g *GenGo) genWriteVar(v *ast.StructMember, prefix string, hasRet bool) { switch v.Type.Type { case token.TVector: - gen.genWriteVector(v, prefix, hasRet) + g.genWriteVector(v, prefix, hasRet) case token.TArray: - gen.genWriteArray(v, prefix, hasRet) + g.genWriteArray(v, prefix, hasRet) case token.TMap: - gen.genWriteMap(v, prefix, hasRet) + g.genWriteMap(v, prefix, hasRet) case token.Name: if v.Type.CType == token.Enum { // tkEnum enumeration processing tag := strconv.Itoa(int(v.Tag)) - c.WriteString(` -err = buf.WriteInt32(int32(` + gen.genVariableName(prefix, v.Key) + `),` + tag + `) -` + errString(hasRet) + ` -`) + g.P("err = buf.WriteInt32(int32(", g.genVariableName(prefix, v.Key), "), ", tag, ")") + g.P(errString(hasRet)) } else { - gen.genWriteStruct(v, prefix, hasRet) + g.genWriteStruct(v, prefix, hasRet) } default: + if !v.Require { + g.P("if ", g.genVariableName(prefix, v.Key), " != ", g.typeDef(v), " {") + defer g.P("}") + } tag := strconv.Itoa(int(v.Tag)) - c.WriteString(` -err = buf.Write` + utils.UpperFirstLetter(gen.genType(v.Type)) + `(` + gen.genVariableName(prefix, v.Key) + `, ` + tag + `) -` + errString(hasRet) + ` -`) + g.P("err = buf.Write", utils.UpperFirstLetter(g.genType(v.Type)), "(", g.genVariableName(prefix, v.Key), ", ", tag, ")") + g.P(errString(hasRet)) } + g.P() } -func (gen *GenGo) genFunWriteBlock(st *ast.StructInfo) { - c := &gen.code - +func (g *GenGo) genFunWriteBlock(st *ast.StructInfo) { // WriteBlock function head - c.WriteString(`// WriteBlock encode struct -func (st *` + st.Name + `) WriteBlock(buf *codec.Buffer, tag byte) error { - var err error - err = buf.WriteHead(codec.StructBegin, tag) - if err != nil { - return err - } - - err = st.WriteTo(buf) - if err != nil { - return err - } - - err = buf.WriteHead(codec.StructEnd, 0) - if err != nil { - return err - } - return nil -} -`) -} - -func (gen *GenGo) genFunWriteTo(st *ast.StructInfo) { - c := &gen.code - - c.WriteString(`// WriteTo encode struct to buffer -func (st *` + st.Name + `) WriteTo(buf *codec.Buffer) (err error) { -`) + g.P("// WriteBlock encode struct") + g.P("func (st *", st.Name, ") WriteBlock(buf *codec.Buffer, tag byte) error {") + g.P("var err error") + g.P("err = buf.WriteHead(codec.StructBegin, tag)") + g.P("if err != nil {") + g.P(" return err") + g.P("}") + g.P() + g.P("err = st.WriteTo(buf)") + g.P("if err != nil {") + g.P(" return err") + g.P("}") + g.P() + g.P("err = buf.WriteHead(codec.StructEnd, 0)") + g.P("if err != nil {") + g.P(" return err") + g.P("}") + g.P("return nil") + g.P("}") +} + +func (g *GenGo) genFunWriteTo(st *ast.StructInfo) { + g.P("// WriteTo encode struct to buffer") + g.P("func (st *", st.Name, ") WriteTo(buf *codec.Buffer) (err error) {") for _, v := range st.Mb { - gen.genWriteVar(&v, "st.", false) + g.genWriteVar(&v, "st.", false) } - - c.WriteString(` - return err -} -`) + g.P() + g.P("return err") + g.P("}") } -func (gen *GenGo) genReadSimpleList(mb *ast.StructMember, prefix string, hasRet bool) { - c := &gen.code - unsign := "Int8" +func (g *GenGo) genReadSimpleList(mb *ast.StructMember, prefix string, hasRet bool) { + unsigned := "Int8" if mb.Type.TypeK.Unsigned { - unsign = "Uint8" + unsigned = "Uint8" } errStr := errString(hasRet) - - c.WriteString(` -_, err = readBuf.SkipTo(codec.BYTE, 0, true) -` + errStr + ` -err = readBuf.ReadInt32(&length, 0, true) -` + errStr + ` -err = readBuf.ReadSlice` + unsign + `(&` + prefix + mb.Key + `, length, true) -` + errStr + ` -`) + g.P("_, err = readBuf.SkipTo(codec.BYTE, 0, true)") + g.P(errStr) + g.P("err = readBuf.ReadInt32(&length, 0, true)") + g.P(errStr) + g.P("err = readBuf.ReadSlice", unsigned, `(&`, prefix, mb.Key, ", length, true)") + g.P(errStr) } -func (gen *GenGo) genReadVector(mb *ast.StructMember, prefix string, hasRet bool) { - c := &gen.code - errStr := errString(hasRet) - +func (g *GenGo) genReadVector(mb *ast.StructMember, prefix string, hasRet bool) { // LIST + errStr := errString(hasRet) tag := strconv.Itoa(int(mb.Tag)) - vc := strconv.Itoa(gen.vc) - gen.vc++ + vc := strconv.Itoa(g.vc) + g.vc++ if mb.Require { - c.WriteString(` -_, ty, err = readBuf.SkipToNoCheck(` + tag + `, true) -` + errStr + ` -`) + g.P("_, ty, err = readBuf.SkipToNoCheck(", tag, ", true)") + g.P(errStr) } else { - c.WriteString(` -have, ty, err = readBuf.SkipToNoCheck(` + tag + `, false) -` + errStr + ` -if have {`) + g.P("have, ty, err = readBuf.SkipToNoCheck(", tag, ", false)") + g.P(errStr) + g.P(`if have {`) // 结束标记 defer func() { - c.WriteString("}\n") + g.P("}") }() } - c.WriteString(` -if ty == codec.LIST { - err = readBuf.ReadInt32(&length, 0, true) - ` + errStr + ` - ` + gen.genVariableName(prefix, mb.Key) + ` = make(` + gen.genType(mb.Type) + `, length) - ` + genForHead(vc) + `{ -`) + g.P() + g.P("if ty == codec.LIST {") + g.P("err = readBuf.ReadInt32(&length, 0, true)") + g.P(errStr) + g.P(g.genVariableName(prefix, mb.Key), " = make(", g.genType(mb.Type), ", length)") + g.P(genForHead(vc), "{") dummy := &ast.StructMember{} dummy.Type = mb.Type.TypeK dummy.Key = mb.Key + "[i" + vc + "]" - gen.genReadVar(dummy, prefix, hasRet) + g.genReadVar(dummy, prefix, hasRet) - c.WriteString(`} -} else if ty == codec.SimpleList { -`) + g.P("}") + g.P("} else if ty == codec.SimpleList {") if mb.Type.TypeK.Type == token.TByte { - gen.genReadSimpleList(mb, prefix, hasRet) + g.genReadSimpleList(mb, prefix, hasRet) } else { - c.WriteString(`err = fmt.Errorf("not support SimpleList type") - ` + errStr) + g.P(`err = fmt.Errorf("not support SimpleList type")`) + g.P(errStr) } - c.WriteString(` -} else { - err = fmt.Errorf("require vector, but not") - ` + errStr + ` -} -`) + g.P("} else {") + g.P(` err = fmt.Errorf("require vector, but not")`) + g.P(errStr) + g.P("}") } -func (gen *GenGo) genReadArray(mb *ast.StructMember, prefix string, hasRet bool) { - c := &gen.code - errStr := errString(hasRet) - +func (g *GenGo) genReadArray(mb *ast.StructMember, prefix string, hasRet bool) { // LIST + errStr := errString(hasRet) tag := strconv.Itoa(int(mb.Tag)) - vc := strconv.Itoa(gen.vc) - gen.vc++ + vc := strconv.Itoa(g.vc) + g.vc++ + g.P() if mb.Require { - c.WriteString(` -_, ty, err = readBuf.SkipToNoCheck(` + tag + `, true) -` + errStr + ` -`) + g.P(`_, ty, err = readBuf.SkipToNoCheck(`, tag, `, true)`) + g.P(errStr) } else { - c.WriteString(` -have, ty, err = readBuf.SkipToNoCheck(` + tag + `, false) -` + errStr + ` -if have {`) + g.P(`have, ty, err = readBuf.SkipToNoCheck(`, tag, `, false)`) + g.P(errStr) + g.P(`if have {`) // 结束标记 defer func() { - c.WriteString("}\n") + g.P("}") }() } - c.WriteString(` -if ty == codec.LIST { - err = readBuf.ReadInt32(&length, 0, true) - ` + errStr + ` - ` + genForHead(vc) + `{ -`) - + g.P() + g.P("if ty == codec.LIST {") + g.P(" err = readBuf.ReadInt32(&length, 0, true)") + g.P(errStr) + g.P(genForHead(vc), "{") dummy := &ast.StructMember{} dummy.Type = mb.Type.TypeK dummy.Key = mb.Key + "[i" + vc + "]" - gen.genReadVar(dummy, prefix, hasRet) + g.genReadVar(dummy, prefix, hasRet) + g.P(`}`) - c.WriteString(`} -} else if ty == codec.SimpleList { -`) + g.P("} else if ty == codec.SimpleList {") if mb.Type.TypeK.Type == token.TByte { - gen.genReadSimpleList(mb, prefix, hasRet) + g.genReadSimpleList(mb, prefix, hasRet) } else { - c.WriteString(`err = fmt.Errorf("not support SimpleList type") - ` + errStr) + g.P(`err = fmt.Errorf("not support SimpleList type")`) + g.P(errStr) } - c.WriteString(` -} else { - err = fmt.Errorf("require array, but not") - ` + errStr + ` -} -`) + g.P("} else {") + g.P(` err = fmt.Errorf("require array, but not")`) + g.P(errStr) + g.P("}") } -func (gen *GenGo) genReadStruct(mb *ast.StructMember, prefix string, hasRet bool) { - c := &gen.code +func (g *GenGo) genReadStruct(mb *ast.StructMember, prefix string, hasRet bool) { tag := strconv.Itoa(int(mb.Tag)) require := "false" if mb.Require { require = "true" } - c.WriteString(` -err = ` + prefix + mb.Key + `.ReadBlock(readBuf, ` + tag + `, ` + require + `) -` + errString(hasRet) + ` -`) + g.P("err = ", prefix, mb.Key, ".ReadBlock(readBuf, ", tag, ", ", require, ")") + g.P(errString(hasRet)) } -func (gen *GenGo) genReadMap(mb *ast.StructMember, prefix string, hasRet bool) { - c := &gen.code +func (g *GenGo) genReadMap(mb *ast.StructMember, prefix string, hasRet bool) { tag := strconv.Itoa(int(mb.Tag)) errStr := errString(hasRet) - vc := strconv.Itoa(gen.vc) - gen.vc++ + vc := strconv.Itoa(g.vc) + g.vc++ if mb.Require { - c.WriteString(` -_, err = readBuf.SkipTo(codec.MAP, ` + tag + `, true) -` + errStr + ` -`) + g.P("_, err = readBuf.SkipTo(codec.MAP, ", tag, ", true)") + g.P(errStr) } else { - c.WriteString(` -have, err = readBuf.SkipTo(codec.MAP, ` + tag + `, false) -` + errStr + ` -if have {`) + g.P("have, err = readBuf.SkipTo(codec.MAP, ", tag, ", false)") + g.P(errStr) + g.P("if have {") // 结束标记 defer func() { - c.WriteString("}\n") + g.P("}") }() } - c.WriteString(` -err = readBuf.ReadInt32(&length, 0, true) -` + errStr + ` -` + gen.genVariableName(prefix, mb.Key) + ` = make(` + gen.genType(mb.Type) + `) -` + genForHead(vc) + `{ - var k` + vc + ` ` + gen.genType(mb.Type.TypeK) + ` - var v` + vc + ` ` + gen.genType(mb.Type.TypeV) + ` -`) + g.P("err = readBuf.ReadInt32(&length, 0, true)") + g.P(errStr) + g.P(g.genVariableName(prefix, mb.Key), " = make(", g.genType(mb.Type), ")") + g.P(genForHead(vc), "{") + g.P("var k", vc, " ", g.genType(mb.Type.TypeK)) + g.P("var v", vc, " ", g.genType(mb.Type.TypeV)) dummy := &ast.StructMember{} dummy.Type = mb.Type.TypeK dummy.Key = "k" + vc - gen.genReadVar(dummy, "", hasRet) + g.genReadVar(dummy, "", hasRet) dummy = &ast.StructMember{} dummy.Type = mb.Type.TypeV dummy.Key = "v" + vc dummy.Tag = 1 - gen.genReadVar(dummy, "", hasRet) - - c.WriteString(` - ` + prefix + mb.Key + `[k` + vc + `] = v` + vc + ` -} -`) + g.genReadVar(dummy, "", hasRet) + g.P(prefix, mb.Key, "[k", vc, "] = v", vc) + g.P(`}`) } -func (gen *GenGo) genReadVar(v *ast.StructMember, prefix string, hasRet bool) { - c := &gen.code - +func (g *GenGo) genReadVar(v *ast.StructMember, prefix string, hasRet bool) { switch v.Type.Type { case token.TVector: - gen.genReadVector(v, prefix, hasRet) + g.genReadVector(v, prefix, hasRet) case token.TArray: - gen.genReadArray(v, prefix, hasRet) + g.genReadArray(v, prefix, hasRet) case token.TMap: - gen.genReadMap(v, prefix, hasRet) + g.genReadMap(v, prefix, hasRet) case token.Name: if v.Type.CType == token.Enum { - require := "false" - if v.Require { - require = "true" - } + require := strconv.FormatBool(v.Require) tag := strconv.Itoa(int(v.Tag)) - c.WriteString(` -err = readBuf.ReadInt32((*int32)(&` + prefix + v.Key + `),` + tag + `, ` + require + `) -` + errString(hasRet) + ` -`) + g.P("err = readBuf.ReadInt32((*int32)(&", prefix, v.Key, "),", tag, ", ", require, ")") + g.P(errString(hasRet)) } else { - gen.genReadStruct(v, prefix, hasRet) + g.genReadStruct(v, prefix, hasRet) } default: - require := "false" - if v.Require { - require = "true" - } + require := strconv.FormatBool(v.Require) tag := strconv.Itoa(int(v.Tag)) - c.WriteString(` -err = readBuf.Read` + utils.UpperFirstLetter(gen.genType(v.Type)) + `(&` + prefix + v.Key + `, ` + tag + `, ` + require + `) -` + errString(hasRet) + ` -`) + g.P("err = readBuf.Read", utils.UpperFirstLetter(g.genType(v.Type)), "(&", prefix, v.Key, ", ", tag, ", ", require, ")") + g.P(errString(hasRet)) } } -func (gen *GenGo) genFunReadFrom(st *ast.StructInfo) { - c := &gen.code - - c.WriteString(`// ReadFrom reads from readBuf and put into struct. -func (st *` + st.Name + `) ReadFrom(readBuf *codec.Reader) error { +func (g *GenGo) genFunReadFrom(st *ast.StructInfo) { + g.P(`// ReadFrom reads from readBuf and put into struct. +func (st *`, st.Name, `) ReadFrom(readBuf *codec.Reader) error { var ( err error length int32 @@ -863,28 +816,24 @@ func (st *` + st.Name + `) ReadFrom(readBuf *codec.Reader) error { ty byte ) st.ResetDefault() - `) for _, v := range st.Mb { - gen.genReadVar(&v, "st.", false) + g.genReadVar(&v, "st.", false) } - c.WriteString(` + g.P(` _ = err _ = length _ = have _ = ty return nil +}`) } -`) -} - -func (gen *GenGo) genFunReadBlock(st *ast.StructInfo) { - c := &gen.code - c.WriteString(`// ReadBlock reads struct from the given tag , require or optional. -func (st *` + st.Name + `) ReadBlock(readBuf *codec.Reader, tag byte, require bool) error { +func (g *GenGo) genFunReadBlock(st *ast.StructInfo) { + g.P(`// ReadBlock reads struct from the given tag , require or optional. +func (st *`, st.Name, `) ReadBlock(readBuf *codec.Reader, tag byte, require bool) error { var ( err error have bool @@ -897,7 +846,7 @@ func (st *` + st.Name + `) ReadBlock(readBuf *codec.Reader, tag byte, require bo } if !have { if require { - return fmt.Errorf("require ` + st.Name + `, but not exist. tag %d", tag) + return fmt.Errorf("require `, st.Name, `, but not exist. tag %d", tag) } return nil } @@ -913,43 +862,41 @@ func (st *` + st.Name + `) ReadBlock(readBuf *codec.Reader, tag byte, require bo } _ = have return nil -} -`) +}`) } -func (gen *GenGo) genStruct(st *ast.StructInfo) { - gen.vc = 0 +func (g *GenGo) genStruct(st *ast.StructInfo) { + g.vc = 0 st.Rename() - gen.genStructDefine(st) - gen.genFunResetDefault(st) + g.genStructDefine(st) + g.genFunResetDefault(st) - gen.genFunReadFrom(st) - gen.genFunReadBlock(st) + g.genFunReadFrom(st) + g.genFunReadBlock(st) - gen.genFunWriteTo(st) - gen.genFunWriteBlock(st) + g.genFunWriteTo(st) + g.genFunWriteBlock(st) } -func (gen *GenGo) makeEnumName(en *ast.EnumInfo, mb *ast.EnumMember) string { +func (g *GenGo) makeEnumName(en *ast.EnumInfo, mb *ast.EnumMember) string { return utils.UpperFirstLetter(en.Name) + "_" + utils.UpperFirstLetter(mb.Key) } -func (gen *GenGo) genEnum(en *ast.EnumInfo) { +func (g *GenGo) genEnum(en *ast.EnumInfo) { if len(en.Mb) == 0 { return } en.Rename() - c := &gen.code - c.WriteString("type " + en.Name + " int32\n") - c.WriteString("const (\n") + g.P("type ", en.Name, " int32") + g.P("const (") var it int32 for _, v := range en.Mb { if v.Type == 0 { //use value - c.WriteString(gen.makeEnumName(en, &v) + ` = ` + strconv.Itoa(int(v.Value)) + "\n") + g.P(g.makeEnumName(en, &v), " ", en.Name, " = ", strconv.Itoa(int(v.Value))) it = v.Value + 1 } else if v.Type == 1 { // use name @@ -957,7 +904,7 @@ func (gen *GenGo) genEnum(en *ast.EnumInfo) { for _, ref := range en.Mb { if ref.Key == v.Name { find = true - c.WriteString(gen.makeEnumName(en, &v) + ` = ` + gen.makeEnumName(en, &ref) + "\n") + g.P(g.makeEnumName(en, &v), " ", en.Name, " = ", g.makeEnumName(en, &ref)) it = ref.Value + 1 break } @@ -966,162 +913,159 @@ func (gen *GenGo) genEnum(en *ast.EnumInfo) { } } if !find { - gen.genErr(v.Name + " not define before use.") + g.genErr(v.Name + " not define before use.") } } else { // use auto add - c.WriteString(gen.makeEnumName(en, &v) + ` = ` + strconv.Itoa(int(it)) + "\n") + g.P(g.makeEnumName(en, &v), " ", en.Name, " = ", strconv.Itoa(int(it))) it++ } - } - - c.WriteString(")\n") + g.P(")") } -func (gen *GenGo) genConst(cst []ast.ConstInfo) { +func (g *GenGo) genConst(cst []ast.ConstInfo) { if len(cst) == 0 { return } - c := &gen.code - c.WriteString("//const as define in tars file\n") - c.WriteString("const (\n") - - for _, v := range gen.module.Const { + g.P("//const as define in tars file") + g.P("const (") + for _, v := range g.module.Const { v.Rename() - c.WriteString(v.Name + " " + gen.genType(v.Type) + " = " + v.Value + "\n") + g.P(v.Name, " ", g.genType(v.Type), " = ", v.Value) } - - c.WriteString(")\n") + g.P(")") } -func (gen *GenGo) genInclude(modules []*ast.ModuleInfo) { +func (g *GenGo) genInclude(modules []*ast.ModuleInfo) { for _, module := range modules { - genModule := NewGenGo(gen.opt, module.Name+module.Source) + genModule := NewGenGo(g.opt, module.Name+module.Source) genModule.module = module genModule.genAll() } } -func (gen *GenGo) genInterface(itf *ast.InterfaceInfo) { - gen.code.Reset() +func (g *GenGo) genInterface(itf *ast.InterfaceInfo) { + g.code.Reset() itf.Rename() - gen.genHead() - gen.genIFPackage(itf) + g.genHead() + g.genIFPackage(itf) - gen.genIFProxy(itf) + g.genIFServer(itf) + g.P() + g.genIFServerWithContext(itf) - gen.genIFServer(itf) - gen.genIFServerWithContext(itf) + g.genIFProxy(itf) - gen.genIFDispatch(itf) + g.genIFDispatch(itf) - gen.saveToSourceFile(itf.Name + ".tars.go") + g.saveToSourceFile(itf.Name + ".tars.go") } -func (gen *GenGo) genIFProxy(itf *ast.InterfaceInfo) { - c := &gen.code - c.WriteString("// " + itf.Name + " struct\n") - c.WriteString("type " + itf.Name + ` struct { - servant m.Servant -} -`) +func (g *GenGo) genIFProxy(itf *ast.InterfaceInfo) { + g.P("// ", itf.Name, " struct") + g.P("type ", itf.Name, ` struct { + servant model.Servant +}`) - c.WriteString(`// SetServant sets servant for the service. -func (obj *` + itf.Name + `) SetServant(servant m.Servant) { + g.P(`func New`, itf.Name, `() *`, itf.Name, ` { + return new(`, itf.Name, `) +}`) + if g.opt.AddServant { + g.P() + g.P(`func New`, itf.Name, `Client(servant string, comm *tars.Communicator, option ...tars.EndpointManagerOption) *`, itf.Name, ` { + client := new(`, itf.Name, `) + comm.StringToProxy(servant, client, option...) + return client +}`) + } + + g.P(`// SetServant sets servant for the service. +func (obj *`, itf.Name, `) SetServant(servant model.Servant) { obj.servant = servant -} -`) - c.WriteString(`// TarsSetTimeout sets the timeout for the servant which is in ms. -func (obj *` + itf.Name + `) TarsSetTimeout(timeout int) { +}`) + + g.P(`// TarsSetTimeout sets the timeout for the servant which is in ms. +func (obj *`, itf.Name, `) TarsSetTimeout(timeout int) { obj.servant.TarsSetTimeout(timeout) -} -`) +}`) - c.WriteString(`// TarsSetProtocol sets the protocol for the servant. -func (obj *` + itf.Name + `) TarsSetProtocol(p m.Protocol) { + g.P(`// TarsSetProtocol sets the protocol for the servant. +func (obj *`, itf.Name, `) TarsSetProtocol(p model.Protocol) { obj.servant.TarsSetProtocol(p) -} -`) +}`) - c.WriteString(`// Endpoints returns all active endpoint.Endpoint -func (obj *` + itf.Name + `) Endpoints() []*endpoint.Endpoint { + g.P(`// Endpoints returns all active endpoint.Endpoint +func (obj *`, itf.Name, `) Endpoints() []*endpoint.Endpoint { return obj.servant.Endpoints() -} -`) +}`) - if gen.opt.AddServant { - c.WriteString(`// AddServant adds servant for the service. -func (obj *` + itf.Name + `) AddServant(imp ` + itf.Name + `Servant, servantObj string) { + if g.opt.AddServant { + g.P(`// AddServant adds servant for the service. +func (obj *`, itf.Name, `) AddServant(imp `, itf.Name, `Servant, servantObj string) { tars.AddServant(obj, imp, servantObj) -} -`) - c.WriteString(`// AddServantWithContext adds servant for the service with context. -func (obj *` + itf.Name + `) AddServantWithContext(imp ` + itf.Name + `ServantWithContext, servantObj string) { +}`) + g.P(`// AddServantWithContext adds servant for the service with context. +func (obj *`, itf.Name, `) AddServantWithContext(imp `, itf.Name, `ServantWithContext, servantObj string) { tars.AddServantWithContext(obj, imp, servantObj) -} -`) +}`) } for _, v := range itf.Fun { - gen.genIFProxyFun(itf.Name, &v, false, false) - gen.genIFProxyFun(itf.Name, &v, true, false) - gen.genIFProxyFun(itf.Name, &v, true, true) + g.genIFProxyFun(itf.Name, &v, false, false) + g.genIFProxyFun(itf.Name, &v, true, false) + g.genIFProxyFun(itf.Name, &v, true, true) } } -func (gen *GenGo) genIFProxyFun(interfName string, fun *ast.FunInfo, withContext bool, isOneWay bool) { - c := &gen.code +func (g *GenGo) genIFProxyFun(interfName string, fun *ast.FunInfo, withContext bool, isOneWay bool) { if withContext { if isOneWay { - c.WriteString("// " + fun.Name + "OneWayWithContext is the proxy function for the method defined in the tars file, with the context\n") - c.WriteString("func (obj *" + interfName + ") " + fun.Name + "OneWayWithContext(tarsCtx context.Context,") + g.P("// ", fun.Name, "OneWayWithContext is the proxy function for the method defined in the tars file, with the context") + g.W("func (obj *", interfName, ") ", fun.Name, "OneWayWithContext(tarsCtx context.Context,") } else { - c.WriteString("// " + fun.Name + "WithContext is the proxy function for the method defined in the tars file, with the context\n") - c.WriteString("func (obj *" + interfName + ") " + fun.Name + "WithContext(tarsCtx context.Context,") + g.P("// ", fun.Name, "WithContext is the proxy function for the method defined in the tars file, with the context") + g.W("func (obj *", interfName, ") ", fun.Name, "WithContext(tarsCtx context.Context,") } } else { - c.WriteString("// " + fun.Name + " is the proxy function for the method defined in the tars file, with the context\n") - c.WriteString("func (obj *" + interfName + ") " + fun.Name + "(") - } - for _, v := range fun.Args { - gen.genArgs(&v) + g.P("// ", fun.Name, " is the proxy function for the method defined in the tars file, with the context") + g.W("func (obj *", interfName, ") ", fun.Name, "(") } + g.genArgs(fun.Args) - c.WriteString(" opts ...map[string]string)") + g.W(" opts ...map[string]string)") // not WithContext caller WithContext method if !withContext { if fun.HasRet { - c.WriteString("(" + gen.genType(fun.RetType) + ", error) {\n") + g.P("(", g.genType(fun.RetType), ", error) {") } else { - c.WriteString("error { \n") + g.P("error {") } - c.WriteString("return obj." + fun.Name + "WithContext(context.Background(),") + g.W("return obj.", fun.Name, "WithContext(context.Background(), ") for _, v := range fun.Args { - c.WriteString(v.Name + ",") + g.W(v.Name, ",") } - c.WriteString(" opts ...)\n") - c.WriteString("}\n") + g.P(" opts ...)") + g.P("}") return } if fun.HasRet { - c.WriteString("(ret " + gen.genType(fun.RetType) + ", err error) {\n") + g.P("(ret ", g.genType(fun.RetType), ", err error) {") } else { - c.WriteString("(err error) {\n") + g.P("(err error) {") } - c.WriteString(` var ( + g.P(`var ( length int32 have bool ty byte - ) - `) - c.WriteString("buf := codec.NewBuffer()") + )`) + g.P("buf := codec.NewBuffer()") var isOut bool for k, v := range fun.Args { if v.IsOut { @@ -1134,64 +1078,55 @@ func (gen *GenGo) genIFProxyFun(interfName string, fun *ast.FunInfo, withContext if v.IsOut { dummy.Key = "(*" + dummy.Key + ")" } - gen.genWriteVar(dummy, "", fun.HasRet) + g.genWriteVar(dummy, "", fun.HasRet) } // empty args and below separate - c.WriteString("\n") errStr := errString(fun.HasRet) // trace - if !isOneWay && !gen.opt.WithoutTrace { - c.WriteString(` + if !isOneWay && !g.opt.WithoutTrace { + g.P(` trace, ok := current.GetTarsTrace(tarsCtx) if ok && trace.Call() { var traceParam string trace.NewSpan() traceParamFlag := trace.NeedTraceParam(tarstrace.EstCS, uint(buf.Len())) if traceParamFlag == tarstrace.EnpNormal { - value := map[string]interface{}{} -`) + value := map[string]interface{}{}`) for _, v := range fun.Args { if !v.IsOut { - c.WriteString(`value["` + v.Name + `"] = ` + v.Name + "\n") + g.P(`value["`, v.Name, `"] = `, v.Name) } } - c.WriteString(`jm, _ := json.Marshal(value) + g.P(`jm, _ := json.Marshal(value) traceParam = string(jm) - } else if traceParamFlag == tarstrace.EnpOverMaxLen { -`) - c.WriteString("traceParam = `{\"trace_param_over_max_len\":true}`") - c.WriteString(` - } - tars.Trace(trace.GetTraceKey(tarstrace.EstCS), tarstrace.AnnotationCS, tars.GetClientConfig().ModuleName, obj.servant.Name(), "` + fun.Name + `", 0, traceParam, "") + } else if traceParamFlag == tarstrace.EnpOverMaxLen {`) + g.P("traceParam = `{\"trace_param_over_max_len\":true}`") + g.P(`} + tars.Trace(trace.GetTraceKey(tarstrace.EstCS), tarstrace.AnnotationCS, tars.GetClientConfig().ModuleName, obj.servant.Name(), "`, fun.Name, `", 0, traceParam, "") }`) - c.WriteString("\n\n") - } - c.WriteString(`var statusMap map[string]string -var contextMap map[string]string -if len(opts) == 1{ - contextMap =opts[0] -}else if len(opts) == 2 { - contextMap = opts[0] - statusMap = opts[1] -} - -tarsResp := new(requestf.ResponsePacket)`) - + } + g.P() + g.P(`var statusMap map[string]string + var contextMap map[string]string + if len(opts) == 1{ + contextMap =opts[0] + }else if len(opts) == 2 { + contextMap = opts[0] + statusMap = opts[1] + } + + tarsResp := new(requestf.ResponsePacket)`) if isOneWay { - c.WriteString(` - err = obj.servant.TarsInvoke(tarsCtx, 1, "` + fun.OriginName + `", buf.ToBytes(), statusMap, contextMap, tarsResp) - ` + errStr + ` - `) + g.P(`err = obj.servant.TarsInvoke(tarsCtx, 1, "`, fun.OriginName, `", buf.ToBytes(), statusMap, contextMap, tarsResp)`) + g.P(errStr) } else { - c.WriteString(` - err = obj.servant.TarsInvoke(tarsCtx, 0, "` + fun.OriginName + `", buf.ToBytes(), statusMap, contextMap, tarsResp) - ` + errStr + ` - `) + g.P(`err = obj.servant.TarsInvoke(tarsCtx, 0, "`, fun.OriginName, `", buf.ToBytes(), statusMap, contextMap, tarsResp)`) + g.P(errStr) } if (isOut || fun.HasRet) && !isOneWay { - c.WriteString("readBuf := codec.NewReader(tools.Int8ToByte(tarsResp.SBuffer))") + g.P("readBuf := codec.NewReader(tools.Int8ToByte(tarsResp.SBuffer))") } if fun.HasRet && !isOneWay { dummy := &ast.StructMember{} @@ -1199,7 +1134,7 @@ tarsResp := new(requestf.ResponsePacket)`) dummy.Key = "ret" dummy.Tag = 0 dummy.Require = true - gen.genReadVar(dummy, "", fun.HasRet) + g.genReadVar(dummy, "", fun.HasRet) } if !isOneWay { @@ -1210,42 +1145,39 @@ tarsResp := new(requestf.ResponsePacket)`) dummy.Key = "(*" + v.Name + ")" dummy.Tag = int32(k + 1) dummy.Require = true - gen.genReadVar(dummy, "", fun.HasRet) + g.genReadVar(dummy, "", fun.HasRet) } } - if withContext && !gen.opt.WithoutTrace { + if withContext && !g.opt.WithoutTrace { traceParamFlag := "traceParamFlag := trace.NeedTraceParam(tarstrace.EstCR, uint(0))" if isOut || fun.HasRet { traceParamFlag = "traceParamFlag := trace.NeedTraceParam(tarstrace.EstCR, uint(readBuf.Len()))" } - c.WriteString(` + g.P(` if ok && trace.Call() { var traceParam string - ` + traceParamFlag + ` + `, traceParamFlag, ` if traceParamFlag == tarstrace.EnpNormal { - value := map[string]interface{}{} -`) + value := map[string]interface{}{}`) if fun.HasRet { - c.WriteString(`value[""] = ret` + "\n") + g.P(`value[""] = ret`) } for _, v := range fun.Args { if v.IsOut { - c.WriteString(`value["` + v.Name + `"] = *` + v.Name + "\n") + g.P(`value["`, v.Name, `"] = *`, v.Name) } } - c.WriteString(`jm, _ := json.Marshal(value) + g.P(`jm, _ := json.Marshal(value) traceParam = string(jm) - } else if traceParamFlag == tarstrace.EnpOverMaxLen { -`) - c.WriteString("traceParam = `{\"trace_param_over_max_len\":true}`") - c.WriteString(` - } - tars.Trace(trace.GetTraceKey(tarstrace.EstCR), tarstrace.AnnotationCR, tars.GetClientConfig().ModuleName, obj.servant.Name(), "` + fun.Name + `", tarsResp.IRet, traceParam, "") + } else if traceParamFlag == tarstrace.EnpOverMaxLen {`) + g.P("traceParam = `{\"trace_param_over_max_len\":true}`") + g.P(`} + tars.Trace(trace.GetTraceKey(tarstrace.EstCR), tarstrace.AnnotationCR, tars.GetClientConfig().ModuleName, obj.servant.Name(), "`, fun.Name, `", tarsResp.IRet, traceParam, "") }`) - c.WriteString("\n\n") + g.P() } - c.WriteString(` + g.P(` if len(opts) == 1 { for k := range(contextMap){ delete(contextMap, k) @@ -1269,86 +1201,84 @@ if ok && trace.Call() { }`) } - c.WriteString(` - _ = length - _ = have - _ = ty -`) + g.P() + g.P(`_ = length + _ = have + _ = ty`) if fun.HasRet { - c.WriteString("return ret, nil\n") + g.P("return ret, nil") } else { - c.WriteString("return nil\n") + g.P("return nil") } - - c.WriteString("}\n") + g.P("}") } -func (gen *GenGo) genArgs(arg *ast.ArgInfo) { - c := &gen.code - c.WriteString(arg.Name + " ") - if arg.IsOut || arg.Type.CType == token.Struct { - c.WriteString("*") +func (g *GenGo) genArgs(args []ast.ArgInfo) { + for _, arg := range args { + g.W(arg.Name, " ") + if arg.IsOut || arg.Type.CType == token.Struct { + g.W("*") + } + g.W(g.genType(arg.Type), ",") } +} - c.WriteString(gen.genType(arg.Type) + ",") +func (g *GenGo) genCallArgs(args []ast.ArgInfo) { + for _, arg := range args { + if arg.IsOut || arg.Type.CType == token.Struct { + g.W("&", arg.Name, ",") + } else { + g.W(arg.Name, ",") + } + } } -func (gen *GenGo) genIFServer(itf *ast.InterfaceInfo) { - c := &gen.code - c.WriteString("type " + itf.Name + "Servant interface {\n") +func (g *GenGo) genIFServer(itf *ast.InterfaceInfo) { + g.P("type ", itf.Name, "Servant interface {") for _, v := range itf.Fun { - gen.genIFServerFun(&v) + g.genIFServerFun(&v) } - c.WriteString("}\n") + g.P("}") } -func (gen *GenGo) genIFServerWithContext(itf *ast.InterfaceInfo) { - c := &gen.code - c.WriteString("type " + itf.Name + "ServantWithContext interface {\n") +func (g *GenGo) genIFServerWithContext(itf *ast.InterfaceInfo) { + g.P("type ", itf.Name, "ServantWithContext interface {") for _, v := range itf.Fun { - gen.genIFServerFunWithContext(&v) + g.genIFServerFunWithContext(&v) } - c.WriteString("} \n") + g.P("}") } -func (gen *GenGo) genIFServerFun(fun *ast.FunInfo) { - c := &gen.code - c.WriteString(fun.Name + "(") - for _, v := range fun.Args { - gen.genArgs(&v) - } - c.WriteString(")(") +func (g *GenGo) genIFServerFun(fun *ast.FunInfo) { + g.W(fun.Name, "(") + g.genArgs(fun.Args) + g.W(") (") if fun.HasRet { - c.WriteString("ret " + gen.genType(fun.RetType) + ", ") + g.W("ret ", g.genType(fun.RetType), ", ") } - c.WriteString("err error)\n") + g.P("err error)") } -func (gen *GenGo) genIFServerFunWithContext(fun *ast.FunInfo) { - c := &gen.code - c.WriteString(fun.Name + "(tarsCtx context.Context, ") - for _, v := range fun.Args { - gen.genArgs(&v) - } - c.WriteString(")(") +func (g *GenGo) genIFServerFunWithContext(fun *ast.FunInfo) { + g.W(fun.Name, "(tarsCtx context.Context, ") + g.genArgs(fun.Args) + g.W(") (") if fun.HasRet { - c.WriteString("ret " + gen.genType(fun.RetType) + ", ") + g.W("ret ", g.genType(fun.RetType), ", ") } - c.WriteString("err error)\n") + g.P("err error)") } -func (gen *GenGo) genIFDispatch(itf *ast.InterfaceInfo) { - c := &gen.code - c.WriteString("// Dispatch is used to call the server side implement for the method defined in the tars file. withContext shows using context or not. \n") - c.WriteString("func(obj *" + itf.Name + `) Dispatch(tarsCtx context.Context, val interface{}, tarsReq *requestf.RequestPacket, tarsResp *requestf.ResponsePacket, withContext bool) (err error) { +func (g *GenGo) genIFDispatch(itf *ast.InterfaceInfo) { + g.P("// Dispatch is used to call the server side implement for the method defined in the tars file. withContext shows using context or not. ") + g.P("func(obj *", itf.Name, `) Dispatch(tarsCtx context.Context, val interface{}, tarsReq *requestf.RequestPacket, tarsResp *requestf.ResponsePacket, withContext bool) (err error) { var ( length int32 have bool ty byte - ) - `) + )`) var param bool for _, v := range itf.Fun { @@ -1359,20 +1289,17 @@ func (gen *GenGo) genIFDispatch(itf *ast.InterfaceInfo) { } if param { - c.WriteString("readBuf := codec.NewReader(tools.Int8ToByte(tarsReq.SBuffer))") + g.P("readBuf := codec.NewReader(tools.Int8ToByte(tarsReq.SBuffer))") } else { - c.WriteString("readBuf := codec.NewReader(nil)") + g.P("readBuf := codec.NewReader(nil)") } - c.WriteString(` - buf := codec.NewBuffer() - switch tarsReq.SFuncName { -`) - + g.P(`buf := codec.NewBuffer() + switch tarsReq.SFuncName {`) for _, v := range itf.Fun { - gen.genSwitchCase(itf.Name, &v) + g.genSwitchCase(itf.Name, &v) } - c.WriteString(` + g.P(` default: return fmt.Errorf("func mismatch") } @@ -1402,22 +1329,19 @@ func (gen *GenGo) genIFDispatch(itf *ast.InterfaceInfo) { _ = have _ = ty return nil +}`) } -`) -} - -func (gen *GenGo) genSwitchCase(tname string, fun *ast.FunInfo) { - c := &gen.code - c.WriteString(`case "` + fun.OriginName + `":` + "\n") +func (g *GenGo) genSwitchCase(tname string, fun *ast.FunInfo) { + g.P(`case "`, fun.OriginName, `":`) inArgsCount := 0 outArgsCount := 0 for _, v := range fun.Args { - c.WriteString("var " + v.Name + " " + gen.genType(v.Type) + "\n") + g.P("var ", v.Name, " ", g.genType(v.Type)) if v.Type.Type == token.TMap { - c.WriteString(v.Name + " = make(" + gen.genType(v.Type) + ")\n") + g.P(v.Name, " = make(", g.genType(v.Type), ")") } else if v.Type.Type == token.TVector { - c.WriteString(v.Name + " = make(" + gen.genType(v.Type) + ", 0)\n") + g.P(v.Name, " = make(", g.genType(v.Type), ", 0)") } if v.IsOut { outArgsCount++ @@ -1428,161 +1352,123 @@ func (gen *GenGo) genSwitchCase(tname string, fun *ast.FunInfo) { //fmt.Println("args count, in, out:", inArgsCount, outArgsCount) - c.WriteString("\n") - if inArgsCount > 0 { - c.WriteString("if tarsReq.IVersion == basef.TARSVERSION {\n") - + g.P("if tarsReq.IVersion == basef.TARSVERSION {") for k, v := range fun.Args { - if !v.IsOut { dummy := &ast.StructMember{} dummy.Type = v.Type dummy.Key = v.Name dummy.Tag = int32(k + 1) dummy.Require = true - gen.genReadVar(dummy, "", false) + g.genReadVar(dummy, "", false) } } - c.WriteString(`} else if tarsReq.IVersion == basef.TUPVERSION { + g.P(`} else if tarsReq.IVersion == basef.TUPVERSION { reqTup := tup.NewUniAttribute() reqTup.Decode(readBuf) var tupBuffer []byte - `) for _, v := range fun.Args { if !v.IsOut { - c.WriteString("\n") - c.WriteString(`reqTup.GetBuffer("` + v.Name + `", &tupBuffer)` + "\n") - c.WriteString("readBuf.Reset(tupBuffer)") + g.P() + g.P(`reqTup.GetBuffer("`, v.Name, `", &tupBuffer)`) + g.P("readBuf.Reset(tupBuffer)") dummy := &ast.StructMember{} dummy.Type = v.Type dummy.Key = v.Name dummy.Tag = 0 dummy.Require = true - gen.genReadVar(dummy, "", false) + g.genReadVar(dummy, "", false) } } - c.WriteString(`} else if tarsReq.IVersion == basef.JSONVERSION { + g.P(`} else if tarsReq.IVersion == basef.JSONVERSION { var jsonData map[string]interface{} decoder := json.NewDecoder(bytes.NewReader(readBuf.ToBytes())) decoder.UseNumber() err = decoder.Decode(&jsonData) if err != nil { return fmt.Errorf("decode reqpacket failed, error: %+v", err) - } - `) + }`) for _, v := range fun.Args { if !v.IsOut { - c.WriteString("{\n") - c.WriteString(`jsonStr, _ := json.Marshal(jsonData["` + v.Name + `"])` + "\n") + g.P("{") + g.P(`jsonStr, _ := json.Marshal(jsonData["`, v.Name, `"])`) if v.Type.CType == token.Struct { - c.WriteString(v.Name + ".ResetDefault()\n") + g.P(v.Name, ".ResetDefault()") } - c.WriteString("if err = json.Unmarshal(jsonStr, &" + v.Name + "); err != nil {") - c.WriteString(` - return err - } - } - `) + g.P("if err = json.Unmarshal(jsonStr, &", v.Name, "); err != nil {") + g.P("return err") + g.P("}") + g.P("}") } } - c.WriteString(` - } else { + g.P(`} else { err = fmt.Errorf("decode reqpacket fail, error version: %d", tarsReq.IVersion) return err }`) - c.WriteString("\n\n") + g.P() } - if !gen.opt.WithoutTrace { - c.WriteString(` + if !g.opt.WithoutTrace { + g.P(` trace, ok := current.GetTarsTrace(tarsCtx) if ok && trace.Call() { var traceParam string traceParamFlag := trace.NeedTraceParam(tarstrace.EstSR, uint(readBuf.Len())) if traceParamFlag == tarstrace.EnpNormal { - value := map[string]interface{}{} -`) + value := map[string]interface{}{}`) for _, v := range fun.Args { if !v.IsOut { - c.WriteString(`value["` + v.Name + `"] = ` + v.Name + "\n") + g.P(`value["`, v.Name, `"] = `, v.Name) } } - c.WriteString(`jm, _ := json.Marshal(value) + g.P(`jm, _ := json.Marshal(value) traceParam = string(jm) - } else if traceParamFlag == tarstrace.EnpOverMaxLen { -`) - c.WriteString("traceParam = `{\"trace_param_over_max_len\":true}`") - c.WriteString(` - } - tars.Trace(trace.GetTraceKey(tarstrace.EstSR), tarstrace.AnnotationSR, tars.GetClientConfig().ModuleName, tarsReq.SServantName, "` + fun.OriginName + `", 0, traceParam, "") + } else if traceParamFlag == tarstrace.EnpOverMaxLen {`) + g.P("traceParam = `{\"trace_param_over_max_len\":true}`") + g.P(`} + tars.Trace(trace.GetTraceKey(tarstrace.EstSR), tarstrace.AnnotationSR, tars.GetClientConfig().ModuleName, tarsReq.SServantName, "`, fun.OriginName, `", 0, traceParam, "") }`) - c.WriteString("\n\n") + g.P() } if fun.HasRet { - c.WriteString("var funRet " + gen.genType(fun.RetType) + "\n") - - c.WriteString(`if !withContext { - imp := val.(` + tname + `Servant) - funRet, err = imp.` + fun.Name + `(`) - for _, v := range fun.Args { - if v.IsOut || v.Type.CType == token.Struct { - c.WriteString("&" + v.Name + ",") - } else { - c.WriteString(v.Name + ",") - } - } - c.WriteString(")") - - c.WriteString(` - } else { - imp := val.(` + tname + `ServantWithContext) - funRet, err = imp.` + fun.Name + `(tarsCtx ,`) - for _, v := range fun.Args { - if v.IsOut || v.Type.CType == token.Struct { - c.WriteString("&" + v.Name + ",") - } else { - c.WriteString(v.Name + ",") - } - } - c.WriteString(") \n}\n") - + g.P("var funRet ", g.genType(fun.RetType)) + g.P("if !withContext {") + g.P("imp := val.(", tname, "Servant)") + g.W("funRet, err = imp.", fun.Name, "(") + g.genCallArgs(fun.Args) + g.P(")") + + g.P("} else {") + g.P("imp := val.(", tname, "ServantWithContext)") + g.W("funRet, err = imp.", fun.Name, "(tarsCtx ,") + g.genCallArgs(fun.Args) + g.P(")") + g.P("}") } else { - c.WriteString(`if !withContext { - imp := val.(` + tname + `Servant) - err = imp.` + fun.Name + `(`) - for _, v := range fun.Args { - if v.IsOut || v.Type.CType == token.Struct { - c.WriteString("&" + v.Name + ",") - } else { - c.WriteString(v.Name + ",") - } - } - c.WriteString(")") + g.P("if !withContext {") + g.P("imp := val.(", tname, "Servant)") + g.W("err = imp.", fun.Name, "(") + g.genCallArgs(fun.Args) + g.P(")") - c.WriteString(` - } else { - imp := val.(` + tname + `ServantWithContext) - err = imp.` + fun.Name + `(tarsCtx ,`) - for _, v := range fun.Args { - if v.IsOut || v.Type.CType == token.Struct { - c.WriteString("&" + v.Name + ",") - } else { - c.WriteString(v.Name + ",") - } - } - c.WriteString(") \n}\n") + g.P("} else {") + g.P("imp := val.(", tname, "ServantWithContext)") + g.W("err = imp.", fun.Name, "(tarsCtx ,") + g.genCallArgs(fun.Args) + g.P(")") + g.P("}") } - if gen.opt.DispatchReporter { + if g.opt.DispatchReporter { var inArgStr, outArgStr, retArgStr string if fun.HasRet { retArgStr = "funRet, err" @@ -1600,29 +1486,23 @@ if ok && trace.Call() { inArgStr += prefix + v.Name + "," } } - c.WriteString(`if dp := tars.GetDispatchReporter(); dp != nil { - dp(tarsCtx, []interface{}{` + inArgStr + `}, []interface{}{` + outArgStr + `}, []interface{}{` + retArgStr + `}) - }`) - + g.P("if dp := tars.GetDispatchReporter(); dp != nil {") + g.P("dp(tarsCtx, []interface{}{", inArgStr, "}, []interface{}{", outArgStr, "}, []interface{}{", retArgStr, "})") + g.P("}") } - c.WriteString(` - if err != nil { - return err - } - `) - - c.WriteString(` - if tarsReq.IVersion == basef.TARSVERSION { - buf.Reset() - `) + g.P(errString(false)) + g.P() + g.P("if tarsReq.IVersion == basef.TARSVERSION {") + g.P("buf.Reset()") + g.P() if fun.HasRet { dummy := &ast.StructMember{} dummy.Type = fun.RetType dummy.Key = "funRet" dummy.Tag = 0 dummy.Require = true - gen.genWriteVar(dummy, "", false) + g.genWriteVar(dummy, "", false) } for k, v := range fun.Args { @@ -1632,63 +1512,60 @@ if ok && trace.Call() { dummy.Key = v.Name dummy.Tag = int32(k + 1) dummy.Require = true - gen.genWriteVar(dummy, "", false) + g.genWriteVar(dummy, "", false) } } - c.WriteString(` -} else if tarsReq.IVersion == basef.TUPVERSION { -rspTup := tup.NewUniAttribute() -`) + g.P("} else if tarsReq.IVersion == basef.TUPVERSION {") + g.P("rspTup := tup.NewUniAttribute()") + g.P() if fun.HasRet { dummy := &ast.StructMember{} dummy.Type = fun.RetType dummy.Key = "funRet" dummy.Tag = 0 dummy.Require = true - gen.genWriteVar(dummy, "", false) + g.genWriteVar(dummy, "", false) - c.WriteString(` + g.P(` rspTup.PutBuffer("", buf.ToBytes()) - rspTup.PutBuffer("tars_ret", buf.ToBytes()) -`) + rspTup.PutBuffer("tars_ret", buf.ToBytes())`) } for _, v := range fun.Args { if v.IsOut { - c.WriteString(` - buf.Reset()`) + g.P() + g.P("buf.Reset()") dummy := &ast.StructMember{} dummy.Type = v.Type dummy.Key = v.Name dummy.Tag = 0 dummy.Require = true - gen.genWriteVar(dummy, "", false) + g.genWriteVar(dummy, "", false) - c.WriteString(`rspTup.PutBuffer("` + v.Name + `", buf.ToBytes())` + "\n") + g.P(`rspTup.PutBuffer("`, v.Name, `", buf.ToBytes())`) } } - c.WriteString(` + g.P(` buf.Reset() err = rspTup.Encode(buf) if err != nil { return err } } else if tarsReq.IVersion == basef.JSONVERSION { - rspJson := map[string]interface{}{} -`) + rspJson := map[string]interface{}{}`) if fun.HasRet { - c.WriteString(`rspJson["tars_ret"] = funRet` + "\n") + g.P(`rspJson["tars_ret"] = funRet`) } for _, v := range fun.Args { if v.IsOut { - c.WriteString(`rspJson["` + v.Name + `"] = ` + v.Name + "\n") + g.P(`rspJson["`, v.Name, `"] = `, v.Name) } } - c.WriteString(` + g.P(` var rspByte []byte if rspByte, err = json.Marshal(rspJson); err != nil { return err @@ -1701,32 +1578,27 @@ rspTup := tup.NewUniAttribute() } }`) - c.WriteString("\n") - if !gen.opt.WithoutTrace { - c.WriteString(` + if !g.opt.WithoutTrace { + g.P(` if ok && trace.Call() { var traceParam string traceParamFlag := trace.NeedTraceParam(tarstrace.EstSS, uint(buf.Len())) if traceParamFlag == tarstrace.EnpNormal { - value := map[string]interface{}{} -`) + value := map[string]interface{}{}`) if fun.HasRet { - c.WriteString(`value[""] = funRet` + "\n") + g.P(`value[""] = funRet`) } for _, v := range fun.Args { if v.IsOut { - c.WriteString(`value["` + v.Name + `"] = ` + v.Name + "\n") + g.P(`value["`, v.Name, `"] = `, v.Name) } } - c.WriteString(`jm, _ := json.Marshal(value) + g.P(`jm, _ := json.Marshal(value) traceParam = string(jm) - } else if traceParamFlag == tarstrace.EnpOverMaxLen { -`) - c.WriteString("traceParam = `{\"trace_param_over_max_len\":true}`") - c.WriteString(` -} - tars.Trace(trace.GetTraceKey(tarstrace.EstSS), tarstrace.AnnotationSS, tars.GetClientConfig().ModuleName, tarsReq.SServantName, "` + fun.OriginName + `", 0, traceParam, "") -} -`) + } else if traceParamFlag == tarstrace.EnpOverMaxLen {`) + g.P("traceParam = `{\"trace_param_over_max_len\":true}`") + g.P(`} + tars.Trace(trace.GetTraceKey(tarstrace.EstSS), tarstrace.AnnotationSS, tars.GetClientConfig().ModuleName, tarsReq.SServantName, "`, fun.OriginName, `", 0, traceParam, "") +}`) } } From b4d6e181d9643d40fb3e72232adf3fdf41150ccf Mon Sep 17 00:00:00 2001 From: lbbniu Date: Thu, 22 Jun 2023 23:10:23 +0800 Subject: [PATCH 2/2] perf(gencode): for optional fields, there can be a default value, and the default value is not packed by default when encoding --- tars/tools/tars2go/gencode/gen_go.go | 325 ++++++++++++++------------- 1 file changed, 173 insertions(+), 152 deletions(-) diff --git a/tars/tools/tars2go/gencode/gen_go.go b/tars/tools/tars2go/gencode/gen_go.go index 034e83c9..8b3fff4c 100755 --- a/tars/tools/tars2go/gencode/gen_go.go +++ b/tars/tools/tars2go/gencode/gen_go.go @@ -433,10 +433,11 @@ func (g *GenGo) genStructDefine(st *ast.StructInfo) { g.P("// ", st.Name, " struct implement") g.P("type ", st.Name, " struct {") for _, v := range st.Mb { + tarsTag := `tars:"` + v.OriginKey + `,tag:` + strconv.Itoa(int(v.Tag)) + `,require:` + strconv.FormatBool(v.Require) + `"` if g.opt.JsonOmitEmpty { - g.P(v.Key, " ", g.genType(v.Type), " `json:\"", v.OriginKey, ",omitempty\"`") + g.P(v.Key, " ", g.genType(v.Type), " `json:\"", v.OriginKey, ",omitempty\" ", tarsTag, "`") } else { - g.P(v.Key, " ", g.genType(v.Type), " `json:\"", v.OriginKey, "\"`") + g.P(v.Key, " ", g.genType(v.Type), " `json:\"", v.OriginKey, "\" ", tarsTag, "`") } } g.P("}") @@ -469,20 +470,20 @@ func (g *GenGo) genWriteSimpleList(mb *ast.StructMember, prefix string, hasRet b g.P(errStr) g.P("err = buf.WriteInt32(int32(len(", g.genVariableName(prefix, mb.Key), ")), 0)") g.P(errStr) - g.P("err = buf.WriteSlice", unsigned, `(`, g.genVariableName(prefix, mb.Key), ")") + g.P("err = buf.WriteSlice", unsigned, "(", g.genVariableName(prefix, mb.Key), ")") g.P(errStr) } func (g *GenGo) genWriteVector(mb *ast.StructMember, prefix string, hasRet bool) { + if !mb.Require { + g.P("if len(", g.genVariableName(prefix, mb.Key), ") > 0 {") + defer g.P("}") + } // SimpleList if mb.Type.TypeK.Type == token.TByte && !mb.Type.TypeK.Unsigned { g.genWriteSimpleList(mb, prefix, hasRet) return } - if !mb.Require { - g.P("if len(", g.genVariableName(prefix, mb.Key), ") > 0 {") - defer g.P("}") - } // LIST errStr := errString(hasRet) tag := strconv.Itoa(int(mb.Tag)) @@ -493,24 +494,28 @@ func (g *GenGo) genWriteVector(mb *ast.StructMember, prefix string, hasRet bool) g.P("for _, v := range ", g.genVariableName(prefix, mb.Key), " {") // for _, v := range can nesting for _, v := range，does not conflict, support multidimensional arrays - dummy := &ast.StructMember{} - dummy.Type = mb.Type.TypeK - dummy.Key = "v" + dummy := &ast.StructMember{ + Require: true, + Type: mb.Type.TypeK, + Key: "v", + } g.genWriteVar(dummy, "", hasRet) g.P("}") } func (g *GenGo) genWriteArray(mb *ast.StructMember, prefix string, hasRet bool) { + if !mb.Require { + g.P("if len(", g.genVariableName(prefix, mb.Key), ") > 0 {") + defer g.P("}") + } + // SimpleList if mb.Type.TypeK.Type == token.TByte && !mb.Type.TypeK.Unsigned { g.genWriteSimpleList(mb, prefix, hasRet) return } - if !mb.Require { - g.P("if len(", g.genVariableName(prefix, mb.Key), ") > 0 {") - defer g.P("}") - } + // LIST errStr := errString(hasRet) tag := strconv.Itoa(int(mb.Tag)) @@ -520,19 +525,15 @@ func (g *GenGo) genWriteArray(mb *ast.StructMember, prefix string, hasRet bool) g.P(errStr) // for _, v := range can nesting for _, v := range，does not conflict, support multidimensional arrays g.P("for _, v := range ", g.genVariableName(prefix, mb.Key), " {") - dummy := &ast.StructMember{} - dummy.Type = mb.Type.TypeK - dummy.Key = "v" + dummy := &ast.StructMember{ + Require: true, + Type: mb.Type.TypeK, + Key: "v", + } g.genWriteVar(dummy, "", hasRet) g.P("}") } -func (g *GenGo) genWriteStruct(mb *ast.StructMember, prefix string, hasRet bool) { - tag := strconv.Itoa(int(mb.Tag)) - g.P("err = ", prefix, mb.Key, ".WriteBlock(buf, ", tag, ")") - g.P(errString(hasRet)) -} - func (g *GenGo) genWriteMap(mb *ast.StructMember, prefix string, hasRet bool) { if !mb.Require { g.P("if len(", g.genVariableName(prefix, mb.Key), ") > 0 {") @@ -550,20 +551,30 @@ func (g *GenGo) genWriteMap(mb *ast.StructMember, prefix string, hasRet bool) { g.P("for k", vc, ", v", vc, " := range ", g.genVariableName(prefix, mb.Key), " {") // for _, v := range can nesting for _, v := range，does not conflict, support multidimensional arrays - dummy := &ast.StructMember{} - dummy.Type = mb.Type.TypeK - dummy.Key = "k" + vc + dummy := &ast.StructMember{ + Require: true, + Type: mb.Type.TypeK, + Key: "k" + vc, + } g.genWriteVar(dummy, "", hasRet) - dummy = &ast.StructMember{} - dummy.Type = mb.Type.TypeV - dummy.Key = "v" + vc - dummy.Tag = 1 + dummy = &ast.StructMember{ + Tag: 1, + Require: true, + Type: mb.Type.TypeV, + Key: "v" + vc, + } g.genWriteVar(dummy, "", hasRet) g.P("}") } +func (g *GenGo) genWriteStruct(mb *ast.StructMember, prefix string, hasRet bool) { + tag := strconv.Itoa(int(mb.Tag)) + g.P("err = ", prefix, mb.Key, ".WriteBlock(buf, ", tag, ")") + g.P(errString(hasRet)) +} + func (g *GenGo) genWriteVar(v *ast.StructMember, prefix string, hasRet bool) { switch v.Type.Type { case token.TVector: @@ -590,7 +601,6 @@ func (g *GenGo) genWriteVar(v *ast.StructMember, prefix string, hasRet bool) { g.P("err = buf.Write", utils.UpperFirstLetter(g.genType(v.Type)), "(", g.genVariableName(prefix, v.Key), ", ", tag, ")") g.P(errString(hasRet)) } - g.P() } func (g *GenGo) genFunWriteBlock(st *ast.StructInfo) { @@ -621,8 +631,8 @@ func (g *GenGo) genFunWriteTo(st *ast.StructInfo) { g.P("func (st *", st.Name, ") WriteTo(buf *codec.Buffer) (err error) {") for _, v := range st.Mb { g.genWriteVar(&v, "st.", false) + g.P() } - g.P() g.P("return err") g.P("}") } @@ -653,23 +663,22 @@ func (g *GenGo) genReadVector(mb *ast.StructMember, prefix string, hasRet bool) } else { g.P("have, ty, err = readBuf.SkipToNoCheck(", tag, ", false)") g.P(errStr) - g.P(`if have {`) + g.P("if have {") // 结束标记 - defer func() { - g.P("}") - }() + defer g.P("}") } - g.P() g.P("if ty == codec.LIST {") g.P("err = readBuf.ReadInt32(&length, 0, true)") g.P(errStr) g.P(g.genVariableName(prefix, mb.Key), " = make(", g.genType(mb.Type), ", length)") g.P(genForHead(vc), "{") - dummy := &ast.StructMember{} - dummy.Type = mb.Type.TypeK - dummy.Key = mb.Key + "[i" + vc + "]" + dummy := &ast.StructMember{ + Require: true, + Type: mb.Type.TypeK, + Key: mb.Key + "[i" + vc + "]", + } g.genReadVar(dummy, prefix, hasRet) g.P("}") @@ -681,7 +690,7 @@ func (g *GenGo) genReadVector(mb *ast.StructMember, prefix string, hasRet bool) g.P(errStr) } g.P("} else {") - g.P(` err = fmt.Errorf("require vector, but not")`) + g.P(`err = fmt.Errorf("require vector, but not")`) g.P(errStr) g.P("}") } @@ -695,28 +704,27 @@ func (g *GenGo) genReadArray(mb *ast.StructMember, prefix string, hasRet bool) { g.P() if mb.Require { - g.P(`_, ty, err = readBuf.SkipToNoCheck(`, tag, `, true)`) + g.P("_, ty, err = readBuf.SkipToNoCheck(", tag, ", true)") g.P(errStr) } else { - g.P(`have, ty, err = readBuf.SkipToNoCheck(`, tag, `, false)`) + g.P("have, ty, err = readBuf.SkipToNoCheck(", tag, ", false)") g.P(errStr) - g.P(`if have {`) + g.P("if have {") // 结束标记 - defer func() { - g.P("}") - }() + defer g.P("}") } - g.P() g.P("if ty == codec.LIST {") - g.P(" err = readBuf.ReadInt32(&length, 0, true)") + g.P("err = readBuf.ReadInt32(&length, 0, true)") g.P(errStr) g.P(genForHead(vc), "{") - dummy := &ast.StructMember{} - dummy.Type = mb.Type.TypeK - dummy.Key = mb.Key + "[i" + vc + "]" + dummy := &ast.StructMember{ + Require: true, + Type: mb.Type.TypeK, + Key: mb.Key + "[i" + vc + "]", + } g.genReadVar(dummy, prefix, hasRet) - g.P(`}`) + g.P("}") g.P("} else if ty == codec.SimpleList {") if mb.Type.TypeK.Type == token.TByte { @@ -726,21 +734,11 @@ func (g *GenGo) genReadArray(mb *ast.StructMember, prefix string, hasRet bool) { g.P(errStr) } g.P("} else {") - g.P(` err = fmt.Errorf("require array, but not")`) + g.P(`err = fmt.Errorf("require array, but not")`) g.P(errStr) g.P("}") } -func (g *GenGo) genReadStruct(mb *ast.StructMember, prefix string, hasRet bool) { - tag := strconv.Itoa(int(mb.Tag)) - require := "false" - if mb.Require { - require = "true" - } - g.P("err = ", prefix, mb.Key, ".ReadBlock(readBuf, ", tag, ", ", require, ")") - g.P(errString(hasRet)) -} - func (g *GenGo) genReadMap(mb *ast.StructMember, prefix string, hasRet bool) { tag := strconv.Itoa(int(mb.Tag)) errStr := errString(hasRet) @@ -755,9 +753,7 @@ func (g *GenGo) genReadMap(mb *ast.StructMember, prefix string, hasRet bool) { g.P(errStr) g.P("if have {") // 结束标记 - defer func() { - g.P("}") - }() + defer g.P("}") } g.P("err = readBuf.ReadInt32(&length, 0, true)") @@ -767,18 +763,31 @@ func (g *GenGo) genReadMap(mb *ast.StructMember, prefix string, hasRet bool) { g.P("var k", vc, " ", g.genType(mb.Type.TypeK)) g.P("var v", vc, " ", g.genType(mb.Type.TypeV)) - dummy := &ast.StructMember{} - dummy.Type = mb.Type.TypeK - dummy.Key = "k" + vc + key := "k" + vc + dummy := &ast.StructMember{ + Require: true, + Type: mb.Type.TypeK, + Key: key, + } g.genReadVar(dummy, "", hasRet) - dummy = &ast.StructMember{} - dummy.Type = mb.Type.TypeV - dummy.Key = "v" + vc - dummy.Tag = 1 + val := "v" + vc + dummy = &ast.StructMember{ + Tag: 1, + Require: true, + Type: mb.Type.TypeV, + Key: val, + } g.genReadVar(dummy, "", hasRet) - g.P(prefix, mb.Key, "[k", vc, "] = v", vc) - g.P(`}`) + g.P(prefix, mb.Key, "[", key, "] = ", val) + g.P("}") +} + +func (g *GenGo) genReadStruct(mb *ast.StructMember, prefix string, hasRet bool) { + tag := strconv.Itoa(int(mb.Tag)) + require := strconv.FormatBool(mb.Require) + g.P("err = ", prefix, mb.Key, ".ReadBlock(readBuf, ", tag, ", ", require, ")") + g.P(errString(hasRet)) } func (g *GenGo) genReadVar(v *ast.StructMember, prefix string, hasRet bool) { @@ -791,16 +800,16 @@ func (g *GenGo) genReadVar(v *ast.StructMember, prefix string, hasRet bool) { g.genReadMap(v, prefix, hasRet) case token.Name: if v.Type.CType == token.Enum { - require := strconv.FormatBool(v.Require) tag := strconv.Itoa(int(v.Tag)) + require := strconv.FormatBool(v.Require) g.P("err = readBuf.ReadInt32((*int32)(&", prefix, v.Key, "),", tag, ", ", require, ")") g.P(errString(hasRet)) } else { g.genReadStruct(v, prefix, hasRet) } default: - require := strconv.FormatBool(v.Require) tag := strconv.Itoa(int(v.Tag)) + require := strconv.FormatBool(v.Require) g.P("err = readBuf.Read", utils.UpperFirstLetter(g.genType(v.Type)), "(&", prefix, v.Key, ", ", tag, ", ", require, ")") g.P(errString(hasRet)) } @@ -820,15 +829,15 @@ func (st *`, st.Name, `) ReadFrom(readBuf *codec.Reader) error { for _, v := range st.Mb { g.genReadVar(&v, "st.", false) + g.P() } - g.P(` - _ = err - _ = length - _ = have - _ = ty - return nil -}`) + g.P(`_ = err + _ = length + _ = have + _ = ty + return nil + }`) } func (g *GenGo) genFunReadBlock(st *ast.StructInfo) { @@ -970,11 +979,12 @@ func (g *GenGo) genIFProxy(itf *ast.InterfaceInfo) { servant model.Servant }`) + g.P("// New", itf.Name, " creates a new ", itf.Name, " servant.") g.P(`func New`, itf.Name, `() *`, itf.Name, ` { return new(`, itf.Name, `) }`) - if g.opt.AddServant { - g.P() + if g.opt.AddServant || !g.opt.WithoutTrace { + g.P("// New", itf.Name, "Client creates a new ", itf.Name, " client proxy for the given servant.") g.P(`func New`, itf.Name, `Client(servant string, comm *tars.Communicator, option ...tars.EndpointManagerOption) *`, itf.Name, ` { client := new(`, itf.Name, `) comm.StringToProxy(servant, client, option...) @@ -1004,12 +1014,12 @@ func (obj *`, itf.Name, `) Endpoints() []*endpoint.Endpoint { if g.opt.AddServant { g.P(`// AddServant adds servant for the service. -func (obj *`, itf.Name, `) AddServant(imp `, itf.Name, `Servant, servantObj string) { - tars.AddServant(obj, imp, servantObj) +func (obj *`, itf.Name, `) AddServant(imp `, itf.Name, `Servant, servant string) { + tars.AddServant(obj, imp, servant) }`) g.P(`// AddServantWithContext adds servant for the service with context. -func (obj *`, itf.Name, `) AddServantWithContext(imp `, itf.Name, `ServantWithContext, servantObj string) { - tars.AddServantWithContext(obj, imp, servantObj) +func (obj *`, itf.Name, `) AddServantWithContext(imp `, itf.Name, `ServantWithContext, servant string) { + tars.AddServantWithContext(obj, imp, servant) }`) } @@ -1071,14 +1081,17 @@ func (g *GenGo) genIFProxyFun(interfName string, fun *ast.FunInfo, withContext b if v.IsOut { isOut = true } - dummy := &ast.StructMember{} - dummy.Type = v.Type - dummy.Key = v.Name - dummy.Tag = int32(k + 1) + dummy := &ast.StructMember{ + Tag: int32(k + 1), + Require: true, + Type: v.Type, + Key: v.Name, + } if v.IsOut { dummy.Key = "(*" + dummy.Key + ")" } g.genWriteVar(dummy, "", fun.HasRet) + g.P() } // empty args and below separate errStr := errString(fun.HasRet) @@ -1095,7 +1108,7 @@ if ok && trace.Call() { value := map[string]interface{}{}`) for _, v := range fun.Args { if !v.IsOut { - g.P(`value["`, v.Name, `"] = `, v.Name) + g.P("value[", strconv.Quote(v.Name), "] = ", v.Name) } } g.P(`jm, _ := json.Marshal(value) @@ -1103,7 +1116,7 @@ if ok && trace.Call() { } else if traceParamFlag == tarstrace.EnpOverMaxLen {`) g.P("traceParam = `{\"trace_param_over_max_len\":true}`") g.P(`} - tars.Trace(trace.GetTraceKey(tarstrace.EstCS), tarstrace.AnnotationCS, tars.GetClientConfig().ModuleName, obj.servant.Name(), "`, fun.Name, `", 0, traceParam, "") + tars.Trace(trace.GetTraceKey(tarstrace.EstCS), tarstrace.AnnotationCS, tars.GetClientConfig().ModuleName, obj.servant.Name(), `, strconv.Quote(fun.OriginName), `, 0, traceParam, "") }`) } g.P() @@ -1118,33 +1131,35 @@ if ok && trace.Call() { tarsResp := new(requestf.ResponsePacket)`) if isOneWay { - g.P(`err = obj.servant.TarsInvoke(tarsCtx, 1, "`, fun.OriginName, `", buf.ToBytes(), statusMap, contextMap, tarsResp)`) - g.P(errStr) + g.P("err = obj.servant.TarsInvoke(tarsCtx, 1, ", strconv.Quote(fun.OriginName), ", buf.ToBytes(), statusMap, contextMap, tarsResp)") } else { - g.P(`err = obj.servant.TarsInvoke(tarsCtx, 0, "`, fun.OriginName, `", buf.ToBytes(), statusMap, contextMap, tarsResp)`) - g.P(errStr) + g.P("err = obj.servant.TarsInvoke(tarsCtx, 0, ", strconv.Quote(fun.OriginName), ", buf.ToBytes(), statusMap, contextMap, tarsResp)") } + g.P(errStr) if (isOut || fun.HasRet) && !isOneWay { g.P("readBuf := codec.NewReader(tools.Int8ToByte(tarsResp.SBuffer))") } if fun.HasRet && !isOneWay { - dummy := &ast.StructMember{} - dummy.Type = fun.RetType - dummy.Key = "ret" - dummy.Tag = 0 - dummy.Require = true + dummy := &ast.StructMember{ + Tag: 0, + Require: true, + Type: fun.RetType, + Key: "ret", + } g.genReadVar(dummy, "", fun.HasRet) + g.P() } if !isOneWay { for k, v := range fun.Args { if v.IsOut { - dummy := &ast.StructMember{} - dummy.Type = v.Type - dummy.Key = "(*" + v.Name + ")" - dummy.Tag = int32(k + 1) - dummy.Require = true + dummy := &ast.StructMember{ + Tag: int32(k + 1), + Require: true, + Type: v.Type, + Key: "(*" + v.Name + ")", + } g.genReadVar(dummy, "", fun.HasRet) } } @@ -1164,7 +1179,7 @@ if ok && trace.Call() { } for _, v := range fun.Args { if v.IsOut { - g.P(`value["`, v.Name, `"] = *`, v.Name) + g.P("value[", strconv.Quote(v.Name), "] = *", v.Name) } } g.P(`jm, _ := json.Marshal(value) @@ -1172,7 +1187,7 @@ if ok && trace.Call() { } else if traceParamFlag == tarstrace.EnpOverMaxLen {`) g.P("traceParam = `{\"trace_param_over_max_len\":true}`") g.P(`} - tars.Trace(trace.GetTraceKey(tarstrace.EstCR), tarstrace.AnnotationCR, tars.GetClientConfig().ModuleName, obj.servant.Name(), "`, fun.Name, `", tarsResp.IRet, traceParam, "") + tars.Trace(trace.GetTraceKey(tarstrace.EstCR), tarstrace.AnnotationCR, tars.GetClientConfig().ModuleName, obj.servant.Name(), `, strconv.Quote(fun.OriginName), `, tarsResp.IRet, traceParam, "") }`) g.P() } @@ -1333,7 +1348,7 @@ func (g *GenGo) genIFDispatch(itf *ast.InterfaceInfo) { } func (g *GenGo) genSwitchCase(tname string, fun *ast.FunInfo) { - g.P(`case "`, fun.OriginName, `":`) + g.P("case ", strconv.Quote(fun.OriginName), ":") inArgsCount := 0 outArgsCount := 0 for _, v := range fun.Args { @@ -1356,11 +1371,12 @@ func (g *GenGo) genSwitchCase(tname string, fun *ast.FunInfo) { g.P("if tarsReq.IVersion == basef.TARSVERSION {") for k, v := range fun.Args { if !v.IsOut { - dummy := &ast.StructMember{} - dummy.Type = v.Type - dummy.Key = v.Name - dummy.Tag = int32(k + 1) - dummy.Require = true + dummy := &ast.StructMember{ + Tag: int32(k + 1), + Require: true, + Type: v.Type, + Key: v.Name, + } g.genReadVar(dummy, "", false) } } @@ -1374,14 +1390,15 @@ func (g *GenGo) genSwitchCase(tname string, fun *ast.FunInfo) { for _, v := range fun.Args { if !v.IsOut { g.P() - g.P(`reqTup.GetBuffer("`, v.Name, `", &tupBuffer)`) + g.P("reqTup.GetBuffer(", strconv.Quote(v.Name), ", &tupBuffer)") g.P("readBuf.Reset(tupBuffer)") - dummy := &ast.StructMember{} - dummy.Type = v.Type - dummy.Key = v.Name - dummy.Tag = 0 - dummy.Require = true + dummy := &ast.StructMember{ + Tag: 0, + Require: true, + Type: v.Type, + Key: v.Name, + } g.genReadVar(dummy, "", false) } } @@ -1398,7 +1415,7 @@ func (g *GenGo) genSwitchCase(tname string, fun *ast.FunInfo) { for _, v := range fun.Args { if !v.IsOut { g.P("{") - g.P(`jsonStr, _ := json.Marshal(jsonData["`, v.Name, `"])`) + g.P("jsonStr, _ := json.Marshal(jsonData[", strconv.Quote(v.Name), "])") if v.Type.CType == token.Struct { g.P(v.Name, ".ResetDefault()") } @@ -1426,7 +1443,7 @@ if ok && trace.Call() { value := map[string]interface{}{}`) for _, v := range fun.Args { if !v.IsOut { - g.P(`value["`, v.Name, `"] = `, v.Name) + g.P("value[", strconv.Quote(v.Name), "] = ", v.Name) } } g.P(`jm, _ := json.Marshal(value) @@ -1434,7 +1451,7 @@ if ok && trace.Call() { } else if traceParamFlag == tarstrace.EnpOverMaxLen {`) g.P("traceParam = `{\"trace_param_over_max_len\":true}`") g.P(`} - tars.Trace(trace.GetTraceKey(tarstrace.EstSR), tarstrace.AnnotationSR, tars.GetClientConfig().ModuleName, tarsReq.SServantName, "`, fun.OriginName, `", 0, traceParam, "") + tars.Trace(trace.GetTraceKey(tarstrace.EstSR), tarstrace.AnnotationSR, tars.GetClientConfig().ModuleName, tarsReq.SServantName, `, strconv.Quote(fun.OriginName), `, 0, traceParam, "") }`) g.P() } @@ -1497,21 +1514,23 @@ if ok && trace.Call() { g.P("buf.Reset()") g.P() if fun.HasRet { - dummy := &ast.StructMember{} - dummy.Type = fun.RetType - dummy.Key = "funRet" - dummy.Tag = 0 - dummy.Require = true + dummy := &ast.StructMember{ + Tag: 0, + Require: true, + Type: fun.RetType, + Key: "funRet", + } g.genWriteVar(dummy, "", false) } for k, v := range fun.Args { if v.IsOut { - dummy := &ast.StructMember{} - dummy.Type = v.Type - dummy.Key = v.Name - dummy.Tag = int32(k + 1) - dummy.Require = true + dummy := &ast.StructMember{ + Tag: int32(k + 1), + Require: true, + Type: v.Type, + Key: v.Name, + } g.genWriteVar(dummy, "", false) } } @@ -1520,11 +1539,12 @@ if ok && trace.Call() { g.P("rspTup := tup.NewUniAttribute()") g.P() if fun.HasRet { - dummy := &ast.StructMember{} - dummy.Type = fun.RetType - dummy.Key = "funRet" - dummy.Tag = 0 - dummy.Require = true + dummy := &ast.StructMember{ + Tag: 0, + Require: true, + Type: fun.RetType, + Key: "funRet", + } g.genWriteVar(dummy, "", false) g.P(` @@ -1536,14 +1556,15 @@ if ok && trace.Call() { if v.IsOut { g.P() g.P("buf.Reset()") - dummy := &ast.StructMember{} - dummy.Type = v.Type - dummy.Key = v.Name - dummy.Tag = 0 - dummy.Require = true + dummy := &ast.StructMember{ + Tag: 0, + Require: true, + Type: v.Type, + Key: v.Name, + } g.genWriteVar(dummy, "", false) - g.P(`rspTup.PutBuffer("`, v.Name, `", buf.ToBytes())`) + g.P("rspTup.PutBuffer(", strconv.Quote(v.Name), ", buf.ToBytes())") } } @@ -1561,7 +1582,7 @@ if ok && trace.Call() { for _, v := range fun.Args { if v.IsOut { - g.P(`rspJson["`, v.Name, `"] = `, v.Name) + g.P("rspJson[", strconv.Quote(v.Name), "] = ", v.Name) } } @@ -1590,7 +1611,7 @@ if ok && trace.Call() { } for _, v := range fun.Args { if v.IsOut { - g.P(`value["`, v.Name, `"] = `, v.Name) + g.P("value[", strconv.Quote(v.Name), "] = ", v.Name) } } g.P(`jm, _ := json.Marshal(value) @@ -1598,7 +1619,7 @@ if ok && trace.Call() { } else if traceParamFlag == tarstrace.EnpOverMaxLen {`) g.P("traceParam = `{\"trace_param_over_max_len\":true}`") g.P(`} - tars.Trace(trace.GetTraceKey(tarstrace.EstSS), tarstrace.AnnotationSS, tars.GetClientConfig().ModuleName, tarsReq.SServantName, "`, fun.OriginName, `", 0, traceParam, "") + tars.Trace(trace.GetTraceKey(tarstrace.EstSS), tarstrace.AnnotationSS, tars.GetClientConfig().ModuleName, tarsReq.SServantName, `, strconv.Quote(fun.OriginName), `, 0, traceParam, "") }`) } }