/protoc-gen-go/generator/generator.go
Go | 1478 lines | 1077 code | 129 blank | 272 comment | 234 complexity | 0332d03da0924c1a92cea59152499719 MD5 | raw file
Possible License(s): BSD-3-Clause
- // Go support for Protocol Buffers - Google's data interchange format
- //
- // Copyright 2010 Google Inc. All rights reserved.
- // http://code.google.com/p/goprotobuf/
- //
- // Redistribution and use in source and binary forms, with or without
- // modification, are permitted provided that the following conditions are
- // met:
- //
- // * Redistributions of source code must retain the above copyright
- // notice, this list of conditions and the following disclaimer.
- // * Redistributions in binary form must reproduce the above
- // copyright notice, this list of conditions and the following disclaimer
- // in the documentation and/or other materials provided with the
- // distribution.
- // * Neither the name of Google Inc. nor the names of its
- // contributors may be used to endorse or promote products derived from
- // this software without specific prior written permission.
- //
- // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- /*
- The code generator for the plugin for the Google protocol buffer compiler.
- It generates Go code from the protocol buffer description files read by the
- main routine.
- */
- package generator
- import (
- "bytes"
- "fmt"
- "go/parser"
- "go/printer"
- "go/token"
- "log"
- "os"
- "path"
- "strconv"
- "strings"
- "code.google.com/p/goprotobuf/proto"
- descriptor "code.google.com/p/goprotobuf/protoc-gen-go/descriptor"
- plugin "code.google.com/p/goprotobuf/protoc-gen-go/plugin"
- )
- // A Plugin provides functionality to add to the output during Go code generation,
- // such as to produce RPC stubs.
- type Plugin interface {
- // Name identifies the plugin.
- Name() string
- // Init is called once after data structures are built but before
- // code generation begins.
- Init(g *Generator)
- // Generate produces the code generated by the plugin for this file,
- // except for the imports, by calling the generator's methods P, In, and Out.
- Generate(file *FileDescriptor)
- // GenerateImports produces the import declarations for this file.
- // It is called after Generate.
- GenerateImports(file *FileDescriptor)
- }
- var plugins []Plugin
- // RegisterPlugin installs a (second-order) plugin to be run when the Go output is generated.
- // It is typically called during initialization.
- func RegisterPlugin(p Plugin) {
- plugins = append(plugins, p)
- }
- // Each type we import as a protocol buffer (other than FileDescriptorProto) needs
- // a pointer to the FileDescriptorProto that represents it. These types achieve that
- // wrapping by placing each Proto inside a struct with the pointer to its File. The
- // structs have the same names as their contents, with "Proto" removed.
- // FileDescriptor is used to store the things that it points to.
- // The file and package name method are common to messages and enums.
- type common struct {
- file *descriptor.FileDescriptorProto // File this object comes from.
- }
- // PackageName is name in the package clause in the generated file.
- func (c *common) PackageName() string { return uniquePackageOf(c.file) }
- func (c *common) File() *descriptor.FileDescriptorProto { return c.file }
- // Descriptor represents a protocol buffer message.
- type Descriptor struct {
- common
- *descriptor.DescriptorProto
- parent *Descriptor // The containing message, if any.
- nested []*Descriptor // Inner messages, if any.
- ext []*ExtensionDescriptor // Extensions, if any.
- typename []string // Cached typename vector.
- }
- // TypeName returns the elements of the dotted type name.
- // The package name is not part of this name.
- func (d *Descriptor) TypeName() []string {
- if d.typename != nil {
- return d.typename
- }
- n := 0
- for parent := d; parent != nil; parent = parent.parent {
- n++
- }
- s := make([]string, n, n)
- for parent := d; parent != nil; parent = parent.parent {
- n--
- s[n] = proto.GetString(parent.Name)
- }
- d.typename = s
- return s
- }
- // EnumDescriptor describes an enum. If it's at top level, its parent will be nil.
- // Otherwise it will be the descriptor of the message in which it is defined.
- type EnumDescriptor struct {
- common
- *descriptor.EnumDescriptorProto
- parent *Descriptor // The containing message, if any.
- typename []string // Cached typename vector.
- }
- // TypeName returns the elements of the dotted type name.
- // The package name is not part of this name.
- func (e *EnumDescriptor) TypeName() (s []string) {
- if e.typename != nil {
- return e.typename
- }
- name := proto.GetString(e.Name)
- if e.parent == nil {
- s = make([]string, 1)
- } else {
- pname := e.parent.TypeName()
- s = make([]string, len(pname)+1)
- copy(s, pname)
- }
- s[len(s)-1] = name
- e.typename = s
- return s
- }
- // Everything but the last element of the full type name, CamelCased.
- // The values of type Foo.Bar are call Foo_value1... not Foo_Bar_value1... .
- func (e *EnumDescriptor) prefix() string {
- typeName := e.TypeName()
- ccPrefix := CamelCaseSlice(typeName[0:len(typeName)-1]) + "_"
- if e.parent == nil {
- // If the enum is not part of a message, the prefix is just the type name.
- ccPrefix = CamelCase(*e.Name) + "_"
- }
- return ccPrefix
- }
- // The integer value of the named constant in this enumerated type.
- func (e *EnumDescriptor) integerValueAsString(name string) string {
- for _, c := range e.Value {
- if proto.GetString(c.Name) == name {
- return fmt.Sprint(proto.GetInt32(c.Number))
- }
- }
- log.Fatal("cannot find value for enum constant")
- return ""
- }
- // ExtensionDescriptor describes an extension. If it's at top level, its parent will be nil.
- // Otherwise it will be the descriptor of the message in which it is defined.
- type ExtensionDescriptor struct {
- common
- *descriptor.FieldDescriptorProto
- parent *Descriptor // The containing message, if any.
- }
- // TypeName returns the elements of the dotted type name.
- // The package name is not part of this name.
- func (e *ExtensionDescriptor) TypeName() (s []string) {
- name := proto.GetString(e.Name)
- if e.parent == nil {
- // top-level extension
- s = make([]string, 1)
- } else {
- pname := e.parent.TypeName()
- s = make([]string, len(pname)+1)
- copy(s, pname)
- }
- s[len(s)-1] = name
- return s
- }
- // DescName returns the variable name used for the generated descriptor.
- func (e *ExtensionDescriptor) DescName() string {
- // The full type name.
- typeName := e.TypeName()
- // Each scope of the extension is individually CamelCased, and all are joined with "_" with an "E_" prefix.
- for i, s := range typeName {
- typeName[i] = CamelCase(s)
- }
- return "E_" + strings.Join(typeName, "_")
- }
- // ImportedDescriptor describes a type that has been publicly imported from another file.
- type ImportedDescriptor struct {
- common
- o Object
- }
- func (id *ImportedDescriptor) TypeName() []string { return id.o.TypeName() }
- // FileDescriptor describes an protocol buffer descriptor file (.proto).
- // It includes slices of all the messages and enums defined within it.
- // Those slices are constructed by WrapTypes.
- type FileDescriptor struct {
- *descriptor.FileDescriptorProto
- desc []*Descriptor // All the messages defined in this file.
- enum []*EnumDescriptor // All the enums defined in this file.
- ext []*ExtensionDescriptor // All the top-level extensions defined in this file.
- imp []*ImportedDescriptor // All types defined in files publicly imported by this file.
- // The full list of symbols that are exported,
- // as a map from the exported object to its symbols.
- // This is used for supporting public imports.
- exported map[Object][]Symbol
- }
- // PackageName is the package name we'll use in the generated code to refer to this file.
- func (d *FileDescriptor) PackageName() string { return uniquePackageOf(d.FileDescriptorProto) }
- // The package named defined in the input for this file, possibly dotted.
- // If the file does not define a package, use the base of the file name.
- func (d *FileDescriptor) originalPackageName() string {
- // Does the file have a package clause?
- if pkg := proto.GetString(d.Package); pkg != "" {
- return pkg
- }
- // Use the file base name.
- return BaseName(proto.GetString(d.Name))
- }
- func (d *FileDescriptor) addExport(obj Object, symbol Symbol) {
- d.exported[obj] = append(d.exported[obj], symbol)
- }
- // Symbol is an interface representing an exported Go symbol.
- type Symbol interface {
- // GenerateAlias should generate an appropriate alias
- // for the symbol from the named package.
- GenerateAlias(g *Generator, pkg string)
- }
- type messageSymbol struct {
- sym string
- hasExtensions, isMessageSet bool
- }
- func (ms messageSymbol) GenerateAlias(g *Generator, pkg string) {
- remoteSym := pkg + "." + ms.sym
- g.P("type ", ms.sym, " ", remoteSym)
- g.P("func (this *", ms.sym, ") Reset() { (*", remoteSym, ")(this).Reset() }")
- g.P("func (this *", ms.sym, ") String() string { return (*", remoteSym, ")(this).String() }")
- if ms.hasExtensions {
- g.P("func (*", ms.sym, ") ExtensionRangeArray() []", g.ProtoPkg, ".ExtensionRange ",
- "{ return (*", remoteSym, ")(nil).ExtensionRangeArray() }")
- g.P("func (this *", ms.sym, ") ExtensionMap() map[int32]", g.ProtoPkg, ".Extension ",
- "{ return (*", remoteSym, ")(this).ExtensionMap() }")
- if ms.isMessageSet {
- g.P("func (this *", ms.sym, ") Marshal() ([]byte, error) ",
- "{ return (*", remoteSym, ")(this).Marshal() }")
- g.P("func (this *", ms.sym, ") Unmarshal(buf []byte) error ",
- "{ return (*", remoteSym, ")(this).Unmarshal(buf) }")
- }
- }
- }
- type enumSymbol string
- func (es enumSymbol) GenerateAlias(g *Generator, pkg string) {
- s := string(es)
- g.P("type ", s, " ", pkg, ".", s)
- g.P("var ", s, "_name = ", pkg, ".", s, "_name")
- g.P("var ", s, "_value = ", pkg, ".", s, "_value")
- g.P("func New", s, "(x ", s, ") *", s, " { e := ", s, "(x); return &e }")
- }
- type constOrVarSymbol struct {
- sym string
- typ string // either "const" or "var"
- }
- func (cs constOrVarSymbol) GenerateAlias(g *Generator, pkg string) {
- g.P(cs.typ, " ", cs.sym, " = ", pkg, ".", cs.sym)
- }
- // Object is an interface abstracting the abilities shared by enums, messages, extensions and imported objects.
- type Object interface {
- PackageName() string // The name we use in our output (a_b_c), possibly renamed for uniqueness.
- TypeName() []string
- File() *descriptor.FileDescriptorProto
- }
- // Each package name we generate must be unique. The package we're generating
- // gets its own name but every other package must have a unique name that does
- // not conflict in the code we generate. These names are chosen globally (although
- // they don't have to be, it simplifies things to do them globally).
- func uniquePackageOf(fd *descriptor.FileDescriptorProto) string {
- s, ok := uniquePackageName[fd]
- if !ok {
- log.Fatal("internal error: no package name defined for", proto.GetString(fd.Name))
- }
- return s
- }
- // Generator is the type whose methods generate the output, stored in the associated response structure.
- type Generator struct {
- *bytes.Buffer
- Request *plugin.CodeGeneratorRequest // The input.
- Response *plugin.CodeGeneratorResponse // The output.
- Param map[string]string // Command-line parameters.
- ImportPrefix string // String to prefix to imported package file names.
- ImportMap map[string]string // Mapping from import name to generated name
- ProtoPkg string // The name under which we import the library's package proto.
- packageName string // What we're calling ourselves.
- allFiles []*FileDescriptor // All files in the tree
- genFiles []*FileDescriptor // Those files we will generate output for.
- file *FileDescriptor // The file we are compiling now.
- usedPackages map[string]bool // Names of packages used in current file.
- typeNameToObject map[string]Object // Key is a fully-qualified name in input syntax.
- indent string
- }
- // New creates a new generator and allocates the request and response protobufs.
- func New() *Generator {
- g := new(Generator)
- g.Buffer = new(bytes.Buffer)
- g.Request = new(plugin.CodeGeneratorRequest)
- g.Response = new(plugin.CodeGeneratorResponse)
- return g
- }
- // Error reports a problem, including an error, and exits the program.
- func (g *Generator) Error(err error, msgs ...string) {
- s := strings.Join(msgs, " ") + ":" + err.Error()
- log.Println("protoc-gen-go: error:", s)
- g.Response.Error = proto.String(s)
- os.Exit(1)
- }
- // Fail reports a problem and exits the program.
- func (g *Generator) Fail(msgs ...string) {
- s := strings.Join(msgs, " ")
- log.Println("protoc-gen-go: error:", s)
- g.Response.Error = proto.String(s)
- os.Exit(1)
- }
- // CommandLineParameters breaks the comma-separated list of key=value pairs
- // in the parameter (a member of the request protobuf) into a key/value map.
- // It then sets file name mappings defined by those entries.
- func (g *Generator) CommandLineParameters(parameter string) {
- g.Param = make(map[string]string)
- for _, p := range strings.Split(parameter, ",") {
- if i := strings.Index(p, "="); i < 0 {
- g.Param[p] = ""
- } else {
- g.Param[p[0:i]] = p[i+1:]
- }
- }
- g.ImportMap = make(map[string]string)
- for k, v := range g.Param {
- if k == "import_prefix" {
- g.ImportPrefix = v
- } else if len(k) > 0 && k[0] == 'M' {
- g.ImportMap[k[1:]] = v
- }
- }
- }
- // DefaultPackageName returns the package name printed for the object.
- // If its file is in a different package, it returns the package name we're using for this file, plus ".".
- // Otherwise it returns the empty string.
- func (g *Generator) DefaultPackageName(obj Object) string {
- pkg := obj.PackageName()
- if pkg == g.packageName {
- return ""
- }
- return pkg + "."
- }
- // For each input file, the unique package name to use, underscored.
- var uniquePackageName = make(map[*descriptor.FileDescriptorProto]string)
- // Package names already registered. Key is the name from the .proto file;
- // value is the name that appears in the generated code.
- var pkgNamesInUse = make(map[string]bool)
- // Create and remember a guaranteed unique package name for this file descriptor.
- // Pkg is the candidate name. If f is nil, it's a builtin package like "proto" and
- // has no file descriptor.
- func RegisterUniquePackageName(pkg string, f *FileDescriptor) string {
- // Convert dots to underscores before finding a unique alias.
- pkg = strings.Map(DotToUnderscore, pkg)
- for i, orig := 1, pkg; pkgNamesInUse[pkg]; i++ {
- // It's a duplicate; must rename.
- pkg = orig + strconv.Itoa(i)
- }
- // Install it.
- pkgNamesInUse[pkg] = true
- if f != nil {
- uniquePackageName[f.FileDescriptorProto] = pkg
- }
- return pkg
- }
- // SetPackageNames sets the package name for this run.
- // The package name must agree across all files being generated.
- // It also defines unique package names for all imported files.
- func (g *Generator) SetPackageNames() {
- // Register the name for this package. It will be the first name
- // registered so is guaranteed to be unmodified.
- pkg := g.genFiles[0].originalPackageName()
- g.packageName = RegisterUniquePackageName(pkg, g.genFiles[0])
- // Register the proto package name. It might collide with the
- // name of a package we import.
- g.ProtoPkg = RegisterUniquePackageName("proto", nil)
- // Verify that we are generating output for a single package.
- for _, f := range g.genFiles {
- thisPkg := f.originalPackageName()
- if thisPkg != pkg {
- g.Fail("inconsistent package names:", thisPkg, pkg)
- }
- }
- AllFiles:
- for _, f := range g.allFiles {
- for _, genf := range g.genFiles {
- if f == genf {
- // In this package already.
- uniquePackageName[f.FileDescriptorProto] = g.packageName
- continue AllFiles
- }
- }
- // The file is a dependency, so we want to ignore its go_package option
- // because that is only relevant for its specific generated output.
- pkg := proto.GetString(f.Package)
- if pkg == "" {
- pkg = BaseName(*f.Name)
- }
- RegisterUniquePackageName(pkg, f)
- }
- }
- // WrapTypes walks the incoming data, wrapping DescriptorProtos, EnumDescriptorProtos
- // and FileDescriptorProtos into file-referenced objects within the Generator.
- // It also creates the list of files to generate and so should be called before GenerateAllFiles.
- func (g *Generator) WrapTypes() {
- g.allFiles = make([]*FileDescriptor, len(g.Request.ProtoFile))
- for i, f := range g.Request.ProtoFile {
- // We must wrap the descriptors before we wrap the enums
- descs := wrapDescriptors(f)
- g.buildNestedDescriptors(descs)
- enums := wrapEnumDescriptors(f, descs)
- exts := wrapExtensions(f)
- imps := wrapImported(f, g)
- g.allFiles[i] = &FileDescriptor{
- FileDescriptorProto: f,
- desc: descs,
- enum: enums,
- ext: exts,
- imp: imps,
- exported: make(map[Object][]Symbol),
- }
- }
- g.genFiles = make([]*FileDescriptor, len(g.Request.FileToGenerate))
- FindFiles:
- for i, fileName := range g.Request.FileToGenerate {
- // Search the list. This algorithm is n^2 but n is tiny.
- for _, file := range g.allFiles {
- if fileName == proto.GetString(file.Name) {
- g.genFiles[i] = file
- continue FindFiles
- }
- }
- g.Fail("could not find file named", fileName)
- }
- g.Response.File = make([]*plugin.CodeGeneratorResponse_File, len(g.genFiles))
- }
- // Scan the descriptors in this file. For each one, build the slice of nested descriptors
- func (g *Generator) buildNestedDescriptors(descs []*Descriptor) {
- for _, desc := range descs {
- if len(desc.NestedType) != 0 {
- desc.nested = make([]*Descriptor, len(desc.NestedType))
- n := 0
- for _, nest := range descs {
- if nest.parent == desc {
- desc.nested[n] = nest
- n++
- }
- }
- if n != len(desc.NestedType) {
- g.Fail("internal error: nesting failure for", proto.GetString(desc.Name))
- }
- }
- }
- }
- // Construct the Descriptor and add it to the slice
- func addDescriptor(sl []*Descriptor, desc *descriptor.DescriptorProto, parent *Descriptor, file *descriptor.FileDescriptorProto) []*Descriptor {
- d := &Descriptor{common{file}, desc, parent, nil, nil, nil}
- d.ext = make([]*ExtensionDescriptor, len(desc.Extension))
- for i, field := range desc.Extension {
- d.ext[i] = &ExtensionDescriptor{common{file}, field, d}
- }
- return append(sl, d)
- }
- // Return a slice of all the Descriptors defined within this file
- func wrapDescriptors(file *descriptor.FileDescriptorProto) []*Descriptor {
- sl := make([]*Descriptor, 0, len(file.MessageType)+10)
- for _, desc := range file.MessageType {
- sl = wrapThisDescriptor(sl, desc, nil, file)
- }
- return sl
- }
- // Wrap this Descriptor, recursively
- func wrapThisDescriptor(sl []*Descriptor, desc *descriptor.DescriptorProto, parent *Descriptor, file *descriptor.FileDescriptorProto) []*Descriptor {
- sl = addDescriptor(sl, desc, parent, file)
- me := sl[len(sl)-1]
- for _, nested := range desc.NestedType {
- sl = wrapThisDescriptor(sl, nested, me, file)
- }
- return sl
- }
- // Construct the EnumDescriptor and add it to the slice
- func addEnumDescriptor(sl []*EnumDescriptor, desc *descriptor.EnumDescriptorProto, parent *Descriptor, file *descriptor.FileDescriptorProto) []*EnumDescriptor {
- return append(sl, &EnumDescriptor{common{file}, desc, parent, nil})
- }
- // Return a slice of all the EnumDescriptors defined within this file
- func wrapEnumDescriptors(file *descriptor.FileDescriptorProto, descs []*Descriptor) []*EnumDescriptor {
- sl := make([]*EnumDescriptor, 0, len(file.EnumType)+10)
- // Top-level enums.
- for _, enum := range file.EnumType {
- sl = addEnumDescriptor(sl, enum, nil, file)
- }
- // Enums within messages. Enums within embedded messages appear in the outer-most message.
- for _, nested := range descs {
- for _, enum := range nested.EnumType {
- sl = addEnumDescriptor(sl, enum, nested, file)
- }
- }
- return sl
- }
- // Return a slice of all the top-level ExtensionDescriptors defined within this file.
- func wrapExtensions(file *descriptor.FileDescriptorProto) []*ExtensionDescriptor {
- sl := make([]*ExtensionDescriptor, len(file.Extension))
- for i, field := range file.Extension {
- sl[i] = &ExtensionDescriptor{common{file}, field, nil}
- }
- return sl
- }
- // Return a slice of all the types that are publicly imported into this file.
- func wrapImported(file *descriptor.FileDescriptorProto, g *Generator) (sl []*ImportedDescriptor) {
- for _, index := range file.PublicDependency {
- df := g.fileByName(file.Dependency[index])
- for _, d := range df.desc {
- sl = append(sl, &ImportedDescriptor{common{file}, d})
- }
- for _, e := range df.enum {
- sl = append(sl, &ImportedDescriptor{common{file}, e})
- }
- for _, ext := range df.ext {
- sl = append(sl, &ImportedDescriptor{common{file}, ext})
- }
- }
- return
- }
- // BuildTypeNameMap builds the map from fully qualified type names to objects.
- // The key names for the map come from the input data, which puts a period at the beginning.
- // It should be called after SetPackageNames and before GenerateAllFiles.
- func (g *Generator) BuildTypeNameMap() {
- g.typeNameToObject = make(map[string]Object)
- for _, f := range g.allFiles {
- // The names in this loop are defined by the proto world, not us, so the
- // package name may be empty. If so, the dotted package name of X will
- // be ".X"; otherwise it will be ".pkg.X".
- dottedPkg := "." + proto.GetString(f.Package)
- if dottedPkg != "." {
- dottedPkg += "."
- }
- for _, enum := range f.enum {
- name := dottedPkg + dottedSlice(enum.TypeName())
- g.typeNameToObject[name] = enum
- }
- for _, desc := range f.desc {
- name := dottedPkg + dottedSlice(desc.TypeName())
- g.typeNameToObject[name] = desc
- }
- }
- }
- // ObjectNamed, given a fully-qualified input type name as it appears in the input data,
- // returns the descriptor for the message or enum with that name.
- func (g *Generator) ObjectNamed(typeName string) Object {
- o, ok := g.typeNameToObject[typeName]
- if !ok {
- g.Fail("can't find object with type", typeName)
- }
- // If the file of this object isn't a direct dependency of the current file,
- // or in the current file, then this object has been publicly imported into
- // a dependency of the current file.
- // We should return the ImportedDescriptor object for it instead.
- direct := *o.File().Name == *g.file.Name
- if !direct {
- for _, dep := range g.file.Dependency {
- if *g.fileByName(dep).Name == *o.File().Name {
- direct = true
- break
- }
- }
- }
- if !direct {
- found := false
- Loop:
- for _, dep := range g.file.Dependency {
- df := g.fileByName(*g.fileByName(dep).Name)
- for _, td := range df.imp {
- if td.o == o {
- // Found it!
- o = td
- found = true
- break Loop
- }
- }
- }
- if !found {
- log.Printf("protoc-gen-go: WARNING: failed finding publicly imported dependency for %v, used in %v", typeName, *g.file.Name)
- }
- }
- return o
- }
- // P prints the arguments to the generated output. It handles strings and int32s, plus
- // handling indirections because they may be *string, etc.
- func (g *Generator) P(str ...interface{}) {
- g.WriteString(g.indent)
- for _, v := range str {
- switch s := v.(type) {
- case string:
- g.WriteString(s)
- case *string:
- g.WriteString(*s)
- case bool:
- g.WriteString(fmt.Sprintf("%t", s))
- case *bool:
- g.WriteString(fmt.Sprintf("%t", *s))
- case *int32:
- g.WriteString(fmt.Sprintf("%d", *s))
- case float64:
- g.WriteString(fmt.Sprintf("%g", s))
- case *float64:
- g.WriteString(fmt.Sprintf("%g", *s))
- default:
- g.Fail(fmt.Sprintf("unknown type in printer: %T", v))
- }
- }
- g.WriteByte('\n')
- }
- // In Indents the output one tab stop.
- func (g *Generator) In() { g.indent += "\t" }
- // Out unindents the output one tab stop.
- func (g *Generator) Out() {
- if len(g.indent) > 0 {
- g.indent = g.indent[1:]
- }
- }
- // GenerateAllFiles generates the output for all the files we're outputting.
- func (g *Generator) GenerateAllFiles() {
- // Initialize the plugins
- for _, p := range plugins {
- p.Init(g)
- }
- // Generate the output. The generator runs for every file, even the files
- // that we don't generate output for, so that we can collate the full list
- // of exported symbols to support public imports.
- genFileMap := make(map[*FileDescriptor]bool, len(g.genFiles))
- for _, file := range g.genFiles {
- genFileMap[file] = true
- }
- i := 0
- for _, file := range g.allFiles {
- g.Reset()
- g.generate(file)
- if _, ok := genFileMap[file]; !ok {
- continue
- }
- g.Response.File[i] = new(plugin.CodeGeneratorResponse_File)
- g.Response.File[i].Name = proto.String(goFileName(*file.Name))
- g.Response.File[i].Content = proto.String(g.String())
- i++
- }
- }
- // Run all the plugins associated with the file.
- func (g *Generator) runPlugins(file *FileDescriptor) {
- for _, p := range plugins {
- p.Generate(file)
- }
- }
- // FileOf return the FileDescriptor for this FileDescriptorProto.
- func (g *Generator) FileOf(fd *descriptor.FileDescriptorProto) *FileDescriptor {
- for _, file := range g.allFiles {
- if file.FileDescriptorProto == fd {
- return file
- }
- }
- g.Fail("could not find file in table:", proto.GetString(fd.Name))
- return nil
- }
- // Fill the response protocol buffer with the generated output for all the files we're
- // supposed to generate.
- func (g *Generator) generate(file *FileDescriptor) {
- g.file = g.FileOf(file.FileDescriptorProto)
- g.usedPackages = make(map[string]bool)
- for _, td := range g.file.imp {
- g.generateImported(td)
- }
- for _, enum := range g.file.enum {
- g.generateEnum(enum)
- }
- for _, desc := range g.file.desc {
- g.generateMessage(desc)
- }
- for _, ext := range g.file.ext {
- g.generateExtension(ext)
- }
- g.generateInitFunction()
- // Run the plugins before the imports so we know which imports are necessary.
- g.runPlugins(file)
- // Generate header and imports last, though they appear first in the output.
- rem := g.Buffer
- g.Buffer = new(bytes.Buffer)
- g.generateHeader()
- g.generateImports()
- g.Write(rem.Bytes())
- // Reformat generated code.
- fset := token.NewFileSet()
- ast, err := parser.ParseFile(fset, "", g, parser.ParseComments)
- if err != nil {
- g.Fail("bad Go source code was generated:", err.Error())
- return
- }
- g.Reset()
- err = (&printer.Config{printer.TabIndent | printer.UseSpaces, 8}).Fprint(g, fset, ast)
- if err != nil {
- g.Fail("generated Go source code could not be reformatted:", err.Error())
- }
- }
- // Generate the header, including package definition and imports
- func (g *Generator) generateHeader() {
- g.P("// Code generated by protoc-gen-go from ", Quote(*g.file.Name))
- g.P("// DO NOT EDIT!")
- g.P()
- g.P("package ", g.file.PackageName())
- g.P()
- }
- func (g *Generator) fileByName(filename string) *FileDescriptor {
- for _, fd := range g.allFiles {
- if proto.GetString(fd.Name) == filename {
- return fd
- }
- }
- return nil
- }
- // weak returns whether the ith import of the current file is a weak import.
- func (g *Generator) weak(i int32) bool {
- for _, j := range g.file.WeakDependency {
- if j == i {
- return true
- }
- }
- return false
- }
- // Generate the header, including package definition and imports
- func (g *Generator) generateImports() {
- // We almost always need a proto import. Rather than computing when we
- // do, which is tricky when there's a plugin, just import it and
- // reference it later. The same argument applies to the math package,
- // for handling bit patterns for floating-point numbers.
- g.P("import " + g.ProtoPkg + " " + Quote(g.ImportPrefix+"code.google.com/p/goprotobuf/proto"))
- g.P(`import "math"`)
- for i, s := range g.file.Dependency {
- fd := g.fileByName(s)
- // Do not import our own package.
- if fd.PackageName() == g.packageName {
- continue
- }
- filename := goFileName(s)
- if substitution, ok := g.ImportMap[s]; ok {
- filename = substitution
- }
- filename = g.ImportPrefix + filename
- if strings.HasSuffix(filename, ".go") {
- filename = filename[0 : len(filename)-3]
- }
- // Skip weak imports.
- if g.weak(int32(i)) {
- g.P("// skipping weak import ", fd.PackageName(), " ", Quote(filename))
- continue
- }
- if _, ok := g.usedPackages[fd.PackageName()]; ok {
- g.P("import ", fd.PackageName(), " ", Quote(filename))
- } else {
- // TODO: Re-enable this when we are more feature-complete.
- // For instance, some protos use foreign field extensions, which we don't support.
- // Until then, this is just annoying spam.
- //log.Printf("protoc-gen-go: discarding unused import from %v: %v", *g.file.Name, s)
- g.P("// discarding unused import ", fd.PackageName(), " ", Quote(filename))
- }
- }
- g.P()
- // TODO: may need to worry about uniqueness across plugins
- for _, p := range plugins {
- p.GenerateImports(g.file)
- g.P()
- }
- g.P("// Reference proto and math imports to suppress error if they are not otherwise used.")
- g.P("var _ = ", g.ProtoPkg, ".GetString")
- g.P("var _ = math.Inf")
- g.P()
- }
- func (g *Generator) generateImported(id *ImportedDescriptor) {
- // Don't generate public import symbols for files that we are generating
- // code for, since those symbols will already be in this package.
- // We can't simply avoid creating the ImportedDescriptor objects,
- // because g.genFiles isn't populated at that stage.
- tn := id.TypeName()
- sn := tn[len(tn)-1]
- df := g.FileOf(id.o.File())
- filename := *df.Name
- for _, fd := range g.genFiles {
- if *fd.Name == filename {
- g.P("// Ignoring public import of ", sn, " from ", filename)
- g.P()
- return
- }
- }
- g.P("// ", sn, " from public import ", filename)
- g.usedPackages[df.PackageName()] = true
- for _, sym := range df.exported[id.o] {
- sym.GenerateAlias(g, df.PackageName())
- }
- g.P()
- }
- // Generate the enum definitions for this EnumDescriptor.
- func (g *Generator) generateEnum(enum *EnumDescriptor) {
- // The full type name
- typeName := enum.TypeName()
- // The full type name, CamelCased.
- ccTypeName := CamelCaseSlice(typeName)
- ccPrefix := enum.prefix()
- g.P("type ", ccTypeName, " int32")
- g.file.addExport(enum, enumSymbol(ccTypeName))
- g.P("const (")
- g.In()
- for _, e := range enum.Value {
- name := ccPrefix + *e.Name
- g.P(name, " ", ccTypeName, " = ", e.Number)
- g.file.addExport(enum, constOrVarSymbol{name, "const"})
- }
- g.Out()
- g.P(")")
- g.P("var ", ccTypeName, "_name = map[int32]string{")
- g.In()
- generated := make(map[int32]bool) // avoid duplicate values
- for _, e := range enum.Value {
- duplicate := ""
- if _, present := generated[*e.Number]; present {
- duplicate = "// Duplicate value: "
- }
- g.P(duplicate, e.Number, ": ", Quote(*e.Name), ",")
- generated[*e.Number] = true
- }
- g.Out()
- g.P("}")
- g.P("var ", ccTypeName, "_value = map[string]int32{")
- g.In()
- for _, e := range enum.Value {
- g.P(Quote(*e.Name), ": ", e.Number, ",")
- }
- g.Out()
- g.P("}")
- g.P("func New", ccTypeName, "(x ", ccTypeName, ") *", ccTypeName, " {")
- g.In()
- g.P("e := ", ccTypeName, "(x)")
- g.P("return &e")
- g.Out()
- g.P("}")
- g.P("func (x ", ccTypeName, ") String() string {")
- g.In()
- g.P("return ", g.ProtoPkg, ".EnumName(", ccTypeName, "_name, int32(x))")
- g.Out()
- g.P("}")
- g.P()
- }
- // The tag is a string like "varint,2,opt,name=fieldname,def=7" that
- // identifies details of the field for the protocol buffer marshaling and unmarshaling
- // code. The fields are:
- // wire encoding
- // protocol tag number
- // opt,req,rep for optional, required, or repeated
- // packed whether the encoding is "packed" (optional; repeated primitives only)
- // name= the original declared name
- // enum= the name of the enum type if it is an enum-typed field.
- // def= string representation of the default value, if any.
- // The default value must be in a representation that can be used at run-time
- // to generate the default value. Thus bools become 0 and 1, for instance.
- func (g *Generator) goTag(field *descriptor.FieldDescriptorProto, wiretype string) string {
- optrepreq := ""
- switch {
- case isOptional(field):
- optrepreq = "opt"
- case isRequired(field):
- optrepreq = "req"
- case isRepeated(field):
- optrepreq = "rep"
- }
- defaultValue := proto.GetString(field.DefaultValue)
- if defaultValue != "" {
- switch *field.Type {
- case descriptor.FieldDescriptorProto_TYPE_BOOL:
- if defaultValue == "true" {
- defaultValue = "1"
- } else {
- defaultValue = "0"
- }
- case descriptor.FieldDescriptorProto_TYPE_STRING,
- descriptor.FieldDescriptorProto_TYPE_BYTES:
- // Nothing to do. Quoting is done for the whole tag.
- case descriptor.FieldDescriptorProto_TYPE_ENUM:
- // For enums we need to provide the integer constant.
- obj := g.ObjectNamed(proto.GetString(field.TypeName))
- enum, ok := obj.(*EnumDescriptor)
- if !ok {
- g.Fail("enum type inconsistent for", CamelCaseSlice(obj.TypeName()))
- }
- defaultValue = enum.integerValueAsString(defaultValue)
- }
- defaultValue = ",def=" + defaultValue
- }
- enum := ""
- if *field.Type == descriptor.FieldDescriptorProto_TYPE_ENUM {
- // We avoid using obj.PackageName(), because we want to use the
- // original (proto-world) package name.
- obj := g.ObjectNamed(proto.GetString(field.TypeName))
- enum = ",enum="
- if pkg := proto.GetString(obj.File().Package); pkg != "" {
- enum += pkg + "."
- }
- enum += CamelCaseSlice(obj.TypeName())
- }
- packed := ""
- if field.Options != nil && proto.GetBool(field.Options.Packed) {
- packed = ",packed"
- }
- fieldName := proto.GetString(field.Name)
- name := fieldName
- if *field.Type == descriptor.FieldDescriptorProto_TYPE_GROUP {
- // We must use the type name for groups instead of
- // the field name to preserve capitalization.
- // type_name in FieldDescriptorProto is fully-qualified,
- // but we only want the local part.
- name = *field.TypeName
- if i := strings.LastIndex(name, "."); i >= 0 {
- name = name[i+1:]
- }
- }
- if name == CamelCase(fieldName) {
- name = ""
- } else {
- name = ",name=" + name
- }
- return Quote(fmt.Sprintf("%s,%d,%s%s%s%s%s",
- wiretype,
- proto.GetInt32(field.Number),
- optrepreq,
- packed,
- name,
- enum,
- defaultValue))
- }
- func needsStar(typ descriptor.FieldDescriptorProto_Type) bool {
- switch typ {
- case descriptor.FieldDescriptorProto_TYPE_GROUP:
- return false
- case descriptor.FieldDescriptorProto_TYPE_MESSAGE:
- return false
- case descriptor.FieldDescriptorProto_TYPE_BYTES:
- return false
- }
- return true
- }
- // TypeName is the printed name appropriate for an item. If the object is in the current file,
- // TypeName drops the package name and underscores the rest.
- // Otherwise the object is from another package; and the result is the underscored
- // package name followed by the item name.
- // The result always has an initial capital.
- func (g *Generator) TypeName(obj Object) string {
- return g.DefaultPackageName(obj) + CamelCaseSlice(obj.TypeName())
- }
- // TypeNameWithPackage is like TypeName, but always includes the package
- // name even if the object is in our own package.
- func (g *Generator) TypeNameWithPackage(obj Object) string {
- return obj.PackageName() + CamelCaseSlice(obj.TypeName())
- }
- // GoType returns a string representing the type name, and the wire type
- func (g *Generator) GoType(message *Descriptor, field *descriptor.FieldDescriptorProto) (typ string, wire string) {
- // TODO: Options.
- switch *field.Type {
- case descriptor.FieldDescriptorProto_TYPE_DOUBLE:
- typ, wire = "float64", "fixed64"
- case descriptor.FieldDescriptorProto_TYPE_FLOAT:
- typ, wire = "float32", "fixed32"
- case descriptor.FieldDescriptorProto_TYPE_INT64:
- typ, wire = "int64", "varint"
- case descriptor.FieldDescriptorProto_TYPE_UINT64:
- typ, wire = "uint64", "varint"
- case descriptor.FieldDescriptorProto_TYPE_INT32:
- typ, wire = "int32", "varint"
- case descriptor.FieldDescriptorProto_TYPE_UINT32:
- typ, wire = "uint32", "varint"
- case descriptor.FieldDescriptorProto_TYPE_FIXED64:
- typ, wire = "uint64", "fixed64"
- case descriptor.FieldDescriptorProto_TYPE_FIXED32:
- typ, wire = "uint32", "fixed32"
- case descriptor.FieldDescriptorProto_TYPE_BOOL:
- typ, wire = "bool", "varint"
- case descriptor.FieldDescriptorProto_TYPE_STRING:
- typ, wire = "string", "bytes"
- case descriptor.FieldDescriptorProto_TYPE_GROUP:
- desc := g.ObjectNamed(proto.GetString(field.TypeName))
- typ, wire = "*"+g.TypeName(desc), "group"
- case descriptor.FieldDescriptorProto_TYPE_MESSAGE:
- desc := g.ObjectNamed(proto.GetString(field.TypeName))
- typ, wire = "*"+g.TypeName(desc), "bytes"
- case descriptor.FieldDescriptorProto_TYPE_BYTES:
- typ, wire = "[]byte", "bytes"
- case descriptor.FieldDescriptorProto_TYPE_ENUM:
- desc := g.ObjectNamed(proto.GetString(field.TypeName))
- typ, wire = g.TypeName(desc), "varint"
- case descriptor.FieldDescriptorProto_TYPE_SFIXED32:
- typ, wire = "int32", "fixed32"
- case descriptor.FieldDescriptorProto_TYPE_SFIXED64:
- typ, wire = "int64", "fixed64"
- case descriptor.FieldDescriptorProto_TYPE_SINT32:
- typ, wire = "int32", "zigzag32"
- case descriptor.FieldDescriptorProto_TYPE_SINT64:
- typ, wire = "int64", "zigzag64"
- default:
- g.Fail("unknown type for", proto.GetString(field.Name))
- }
- if isRepeated(field) {
- typ = "[]" + typ
- } else if needsStar(*field.Type) {
- typ = "*" + typ
- }
- return
- }
- func (g *Generator) RecordTypeUse(t string) {
- if obj, ok := g.typeNameToObject[t]; ok {
- // Call ObjectNamed to get the true object to record the use.
- obj = g.ObjectNamed(t)
- g.usedPackages[obj.PackageName()] = true
- }
- }
- // Method names that may be generated. Fields with these names get an
- // underscore appended.
- var methodNames = [...]string{
- "Reset",
- "String",
- "Marshal",
- "Unmarshal",
- "ExtensionRangeArray",
- "ExtensionMap",
- }
- // Generate the type and default constant definitions for this Descriptor.
- func (g *Generator) generateMessage(message *Descriptor) {
- // The full type name
- typeName := message.TypeName()
- // The full type name, CamelCased.
- ccTypeName := CamelCaseSlice(typeName)
- usedNames := make(map[string]bool)
- for _, n := range methodNames {
- usedNames[n] = true
- }
- g.P("type ", ccTypeName, " struct {")
- g.In()
- for _, field := range message.Field {
- fieldname := CamelCase(*field.Name)
- for usedNames[fieldname] {
- fieldname += "_"
- }
- usedNames[fieldname] = true
- typename, wiretype := g.GoType(message, field)
- jsonName := *field.Name
- // This is a hack that is going away. TODO: remove this.
- if field.Options != nil && proto.GetBool(field.Options.Weak) {
- typename = "[]byte"
- }
- tag := fmt.Sprintf("`protobuf:%s json:%q`", g.goTag(field, wiretype), jsonName+",omitempty")
- g.P(fieldname, "\t", typename, "\t", tag)
- g.RecordTypeUse(proto.GetString(field.TypeName))
- }
- if len(message.ExtensionRange) > 0 {
- g.P("XXX_extensions\t\tmap[int32]", g.ProtoPkg, ".Extension `json:\"-\"`")
- }
- g.P("XXX_unrecognized\t[]byte `json:\"-\"`")
- g.Out()
- g.P("}")
- // Reset and String functions
- g.P("func (this *", ccTypeName, ") Reset() { *this = ", ccTypeName, "{} }")
- g.P("func (this *", ccTypeName, ") String() string { return ", g.ProtoPkg, ".CompactTextString(this) }")
- // Extension support methods
- var hasExtensions, isMessageSet bool
- if len(message.ExtensionRange) > 0 {
- hasExtensions = true
- // message_set_wire_format only makes sense when extensions are defined.
- if opts := message.Options; opts != nil && proto.GetBool(opts.MessageSetWireFormat) {
- isMessageSet = true
- g.P()
- g.P("func (this *", ccTypeName, ") Marshal() ([]byte, error) {")
- g.In()
- g.P("return ", g.ProtoPkg, ".MarshalMessageSet(this.ExtensionMap())")
- g.Out()
- g.P("}")
- g.P("func (this *", ccTypeName, ") Unmarshal(buf []byte) error {")
- g.In()
- g.P("return ", g.ProtoPkg, ".UnmarshalMessageSet(buf, this.ExtensionMap())")
- g.Out()
- g.P("}")
- g.P("// ensure ", ccTypeName, " satisfies proto.Marshaler and proto.Unmarshaler")
- g.P("var _ ", g.ProtoPkg, ".Marshaler = (*", ccTypeName, ")(nil)")
- g.P("var _ ", g.ProtoPkg, ".Unmarshaler = (*", ccTypeName, ")(nil)")
- }
- g.P()
- g.P("var extRange_", ccTypeName, " = []", g.ProtoPkg, ".ExtensionRange{")
- g.In()
- for _, r := range message.ExtensionRange {
- end := fmt.Sprint(*r.End - 1) // make range inclusive on both ends
- g.P("{", r.Start, ", ", end, "},")
- }
- g.Out()
- g.P("}")
- g.P("func (*", ccTypeName, ") ExtensionRangeArray() []", g.ProtoPkg, ".ExtensionRange {")
- g.In()
- g.P("return extRange_", ccTypeName)
- g.Out()
- g.P("}")
- g.P("func (this *", ccTypeName, ") ExtensionMap() map[int32]", g.ProtoPkg, ".Extension {")
- g.In()
- g.P("if this.XXX_extensions == nil {")
- g.In()
- g.P("this.XXX_extensions = make(map[int32]", g.ProtoPkg, ".Extension)")
- g.Out()
- g.P("}")
- g.P("return this.XXX_extensions")
- g.Out()
- g.P("}")
- }
- g.file.addExport(message, messageSymbol{ccTypeName, hasExtensions, isMessageSet})
- // Default constants
- for _, field := range message.Field {
- def := proto.GetString(field.DefaultValue)
- if def == "" {
- continue
- }
- fieldname := "Default_" + ccTypeName + "_" + CamelCase(*field.Name)
- typename, _ := g.GoType(message, field)
- if typename[0] == '*' {
- typename = typename[1:]
- }
- kind := "const "
- switch {
- case typename == "bool":
- case typename == "string":
- def = Quote(def)
- case typename == "[]byte":
- def = "[]byte(" + Quote(def) + ")"
- kind = "var "
- case def == "inf", def == "-inf", def == "nan":
- // These names are known to, and defined by, the protocol language.
- switch def {
- case "inf":
- def = "math.Inf(1)"
- case "-inf":
- def = "math.Inf(-1)"
- case "nan":
- def = "math.NaN()"
- }
- if *field.Type == descriptor.FieldDescriptorProto_TYPE_FLOAT {
- def = "float32(" + def + ")"
- }
- kind = "var "
- case *field.Type == descriptor.FieldDescriptorProto_TYPE_ENUM:
- // Must be an enum. Need to construct the prefixed name.
- obj := g.ObjectNamed(proto.GetString(field.TypeName))
- enum, ok := obj.(*EnumDescriptor)
- if !ok {
- log.Println("don't know how to generate constant for", fieldname)
- continue
- }
- def = g.DefaultPackageName(enum) + enum.prefix() + def
- }
- g.P(kind, fieldname, " ", typename, " = ", def)
- g.file.addExport(message, constOrVarSymbol{fieldname, kind})
- }
- g.P()
- for _, ext := range message.ext {
- g.generateExtension(ext)
- }
- }
- func (g *Generator) generateExtension(ext *ExtensionDescriptor) {
- ccTypeName := ext.DescName()
- extendedType := "*" + g.TypeName(g.ObjectNamed(*ext.Extendee))
- field := ext.FieldDescriptorProto
- fieldType, wireType := g.GoType(ext.parent, field)
- tag := g.goTag(field, wireType)
- g.RecordTypeUse(*ext.Extendee)
- if n := ext.FieldDescriptorProto.TypeName; n != nil {
- // foreign extension type
- g.RecordTypeUse(*n)
- }
- typeName := ext.TypeName()
- // Special case for proto2 message sets: If this extension is extending
- // proto2_bridge.MessageSet, and its final name component is "message_set_extension",
- // then drop that last component.
- if extendedType == "*proto2_bridge.MessageSet" && typeName[len(typeName)-1] == "message_set_extension" {
- typeName = typeName[:len(typeName)-1]
- }
- // For text formatting, the package must be exactly what the .proto file declares,
- // ignoring overrides such as the go_package option, and with no dot/underscore mapping.
- extName := strings.Join(typeName, ".")
- if g.file.Package != nil {
- extName = *g.file.Package + "." + extName
- }
- g.P("var ", ccTypeName, " = &", g.ProtoPkg, ".ExtensionDesc{")
- g.In()
- g.P("ExtendedType: (", extendedType, ")(nil),")
- g.P("ExtensionType: (", fieldType, ")(nil),")
- g.P("Field: ", field.Number, ",")
- g.P(`Name: "`, extName, `",`)
- g.P("Tag: ", tag, ",")
- g.Out()
- g.P("}")
- g.P()
- g.file.addExport(ext, constOrVarSymbol{ccTypeName, "var"})
- }
- func (g *Generator) generateInitFunction() {
- g.P("func init() {")
- g.In()
- for _, enum := range g.file.enum {
- g.generateEnumRegistration(enum)
- }
- for _, d := range g.file.desc {
- for _, ext := range d.ext {
- g.generateExtensionRegistration(ext)
- }
- }
- for _, ext := range g.file.ext {
- g.generateExtensionRegistration(ext)
- }
- g.Out()
- g.P("}")
- }
- func (g *Generator) generateEnumRegistration(enum *EnumDescriptor) {
- // // We always print the full (proto-world) package name here.
- pkg := proto.GetString(enum.File().Package)
- if pkg != "" {
- pkg += "."
- }
- // The full type name
- typeName := enum.TypeName()
- // The full type name, CamelCased.
- ccTypeName := CamelCaseSlice(typeName)
- g.P(g.ProtoPkg+".RegisterEnum(", Quote(pkg+ccTypeName), ", ", ccTypeName+"_name, ", ccTypeName+"_value)")
- }
- func (g *Generator) generateExtensionRegistration(ext *ExtensionDescriptor) {
- g.P(g.ProtoPkg+".RegisterExtension(", ext.DescName(), ")")
- }
- // And now lots of helper functions.
- // Is c an ASCII lower-case letter?
- func isASCIILower(c byte) bool {
- return 'a' <= c && c <= 'z'
- }
- // Is c an ASCII digit?
- func isASCIIDigit(c byte) bool {
- return '0' <= c && c <= '9'
- }
- // CamelCase returns the CamelCased name.
- // If there is an interior underscore followed by a lower case letter,
- // drop the underscore and convert the letter to upper case.
- // There is a remote possibility of this rewrite causing a name collision,
- // but it's so remote we're prepared to pretend it's nonexistent - since the
- // C++ generator lowercases names, it's extremely unlikely to have two fields
- // with different capitalizations.
- // In short, _my_field_name_2 becomes XMyFieldName2.
- func CamelCase(s string) string {
- if s == "" {
- return ""
- }
- t := make([]byte, 0, 32)
- i := 0
- if s[0] == '_' {
- // Need a capital letter; drop the '_'.
- t = append(t, 'X')
- i++
- }
- // Invariant: if the next letter is lower case, it must be converted
- // to upper case.
- // That is, we process a word at a time, where words are marked by _ or
- // upper case letter. Digits are treated as words.
- for ; i < len(s); i++ {
- c := s[i]
- if c == '_' && i+1 < len(s) && isASCIILower(s[i+1]) {
- continue // Skip the underscore in s.
- }
- if isASCIIDigit(c) {
- t = append(t, c)
- continue
- }
- // Assume we have a letter now - if not, it's a bogus identifier.
- // The next word is a sequence of characters that must start upper case.
- if isASCIILower(c) {
- c ^= ' ' // Make it a capital letter.
- }
- t = append(t, c) // Guaranteed not lower case.
- // Accept lower case sequence that follows.
- for i+1 < len(s) && isASCIILower(s[i+1]) {
- i++
- t = append(t, s[i])
- }
- }
- return string(t)
- }
- // CamelCaseSlice is like CamelCase, but the argument is a slice of strings to
- // be joined with "_".
- func CamelCaseSlice(elem []string) string { return CamelCase(strings.Join(elem, "_")) }
- // dottedSlice turns a sliced name into a dotted name.
- func dottedSlice(elem []string) string { return strings.Join(elem, ".") }
- // Quote returns a Go-source quoted string representation of s.
- func Quote(s string) string { return fmt.Sprintf("%q", s) }
- // Given a .proto file name, return the output name for the generated Go program.
- func goFileName(name string) string {
- ext := path.Ext(name)
- if ext == ".proto" || ext == ".protodevel" {
- name = name[0 : len(name)-len(ext)]
- }
- return name + ".pb.go"
- }
- // Is this field optional?
- func isOptional(field *descriptor.FieldDescriptorProto) bool {
- return field.Label != nil && *field.Label == descriptor.FieldDescriptorProto_LABEL_OPTIONAL
- }
- // Is this field required?
- func isRequired(field *descriptor.FieldDescriptorProto) bool {
- return field.Label != nil && *field.Label == descriptor.FieldDescriptorProto_LABEL_REQUIRED
- }
- // Is this field repeated?
- func isRepeated(field *descriptor.FieldDescriptorProto) bool {
- return field.Label != nil && *field.Label == descriptor.FieldDescriptorProto_LABEL_REPEATED
- }
- // DotToUnderscore is the mapping function used to generate Go names from package names,
- // which can be dotted in the input .proto file. It maps dots to underscores.
- // Because we also get here from package names generated from file names, it also maps
- // minus signs to underscores.
- func DotToUnderscore(r rune) rune {
- switch r {
- case '.', '-':
- return '_'
- }
- return r
- }
- // BaseName returns the last path element of the name, with the last dotted suffix removed.
- func BaseName(name string) string {
- // First, find the last element
- if i := strings.LastIndex(name, "/"); i >= 0 {
- name = name[i+1:]
- }
- // Now drop the suffix
- if i := strings.LastIndex(name, "."); i >= 0 {
- name = name[0:i]
- }
- return name
- }