--- /dev/null
+// Copyright (c) 2020 Cisco and/or its affiliates.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at:
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package binapigen
+
+import (
+ "fmt"
+ "path"
+ "sort"
+ "strings"
+
+ "git.fd.io/govpp.git/binapigen/vppapi"
+)
+
+type File struct {
+ vppapi.File
+
+ Generate bool
+
+ PackageName string
+ Imports []string
+
+ Enums []*Enum
+ Unions []*Union
+ Structs []*Struct
+ Aliases []*Alias
+ Messages []*Message
+
+ imports map[string]string
+ refmap map[string]string
+}
+
+func newFile(gen *Generator, apifile *vppapi.File) (*File, error) {
+ file := &File{
+ File: *apifile,
+ PackageName: sanitizedName(apifile.Name),
+ imports: make(map[string]string),
+ refmap: make(map[string]string),
+ }
+
+ sortFileObjects(&file.File)
+
+ for _, imp := range apifile.Imports {
+ file.Imports = append(file.Imports, normalizeImport(imp))
+ }
+ for _, enum := range apifile.EnumTypes {
+ file.Enums = append(file.Enums, newEnum(gen, file, enum))
+ }
+ for _, alias := range apifile.AliasTypes {
+ file.Aliases = append(file.Aliases, newAlias(gen, file, alias))
+ }
+ for _, structType := range apifile.StructTypes {
+ file.Structs = append(file.Structs, newStruct(gen, file, structType))
+ }
+ for _, union := range apifile.UnionTypes {
+ file.Unions = append(file.Unions, newUnion(gen, file, union))
+ }
+ for _, msg := range apifile.Messages {
+ file.Messages = append(file.Messages, newMessage(gen, file, msg))
+ }
+
+ return file, nil
+}
+
+func (file *File) isTypes() bool {
+ return strings.HasSuffix(file.File.Name, "_types")
+}
+
+func (file *File) hasService() bool {
+ return file.Service != nil && len(file.Service.RPCs) > 0
+}
+
+func (file *File) addRef(typ string, name string, ref interface{}) {
+ apiName := toApiType(name)
+ if _, ok := file.refmap[apiName]; ok {
+ logf("%s type %v already in refmap", typ, apiName)
+ return
+ }
+ file.refmap[apiName] = name
+}
+
+func (file *File) importedFiles(gen *Generator) []*File {
+ var files []*File
+ for _, imp := range file.Imports {
+ impFile, ok := gen.FilesByName[imp]
+ if !ok {
+ logf("file %s import %s not found API files", file.Name, imp)
+ continue
+ }
+ //if gen.ImportTypes || impFile.Generate {
+ files = append(files, impFile)
+ //}
+ }
+ return files
+}
+
+func (file *File) loadTypeImports(gen *Generator, typeFiles []*File) {
+ if len(typeFiles) == 0 {
+ return
+ }
+ for _, t := range file.Structs {
+ for _, imp := range typeFiles {
+ if _, ok := file.imports[t.Name]; ok {
+ break
+ }
+ for _, at := range imp.File.StructTypes {
+ if at.Name != t.Name {
+ continue
+ }
+ if len(at.Fields) != len(t.Fields) {
+ continue
+ }
+ file.imports[t.Name] = imp.PackageName
+ }
+ }
+ }
+ for _, t := range file.AliasTypes {
+ for _, imp := range typeFiles {
+ if _, ok := file.imports[t.Name]; ok {
+ break
+ }
+ for _, at := range imp.File.AliasTypes {
+ if at.Name != t.Name {
+ continue
+ }
+ if at.Length != t.Length {
+ continue
+ }
+ if at.Type != t.Type {
+ continue
+ }
+ file.imports[t.Name] = imp.PackageName
+ }
+ }
+ }
+ for _, t := range file.EnumTypes {
+ for _, imp := range typeFiles {
+ if _, ok := file.imports[t.Name]; ok {
+ break
+ }
+ for _, at := range imp.File.EnumTypes {
+ if at.Name != t.Name {
+ continue
+ }
+ if at.Type != t.Type {
+ continue
+ }
+ file.imports[t.Name] = imp.PackageName
+ }
+ }
+ }
+ for _, t := range file.UnionTypes {
+ for _, imp := range typeFiles {
+ if _, ok := file.imports[t.Name]; ok {
+ break
+ }
+ for _, at := range imp.File.UnionTypes {
+ if at.Name != t.Name {
+ continue
+ }
+ file.imports[t.Name] = imp.PackageName
+ /*if gen.ImportTypes {
+ imp.Generate = true
+ }*/
+ }
+ }
+ }
+}
+
+type Enum struct {
+ vppapi.EnumType
+
+ GoName string
+}
+
+func newEnum(gen *Generator, file *File, apitype vppapi.EnumType) *Enum {
+ typ := &Enum{
+ EnumType: apitype,
+ GoName: camelCaseName(apitype.Name),
+ }
+ gen.enumsByName[fmt.Sprintf("%s.%s", file.Name, typ.Name)] = typ
+ file.addRef("enum", typ.Name, typ)
+ return typ
+}
+
+type Alias struct {
+ vppapi.AliasType
+
+ GoName string
+}
+
+func newAlias(gen *Generator, file *File, apitype vppapi.AliasType) *Alias {
+ typ := &Alias{
+ AliasType: apitype,
+ GoName: camelCaseName(apitype.Name),
+ }
+ gen.aliasesByName[fmt.Sprintf("%s.%s", file.Name, typ.Name)] = typ
+ file.addRef("alias", typ.Name, typ)
+ return typ
+}
+
+type Struct struct {
+ vppapi.StructType
+
+ GoName string
+
+ Fields []*Field
+}
+
+func newStruct(gen *Generator, file *File, apitype vppapi.StructType) *Struct {
+ typ := &Struct{
+ StructType: apitype,
+ GoName: camelCaseName(apitype.Name),
+ }
+ for _, fieldType := range apitype.Fields {
+ field := newField(gen, file, fieldType)
+ field.ParentStruct = typ
+ typ.Fields = append(typ.Fields, field)
+ }
+ gen.structsByName[fmt.Sprintf("%s.%s", file.Name, typ.Name)] = typ
+ file.addRef("struct", typ.Name, typ)
+ return typ
+}
+
+type Union struct {
+ vppapi.UnionType
+
+ GoName string
+
+ Fields []*Field
+}
+
+func newUnion(gen *Generator, file *File, apitype vppapi.UnionType) *Union {
+ typ := &Union{
+ UnionType: apitype,
+ GoName: camelCaseName(apitype.Name),
+ }
+ gen.unionsByName[fmt.Sprintf("%s.%s", file.Name, typ.Name)] = typ
+ for _, fieldType := range apitype.Fields {
+ field := newField(gen, file, fieldType)
+ field.ParentUnion = typ
+ typ.Fields = append(typ.Fields, field)
+ }
+ file.addRef("union", typ.Name, typ)
+ return typ
+}
+
+type Message struct {
+ vppapi.Message
+
+ GoName string
+
+ Fields []*Field
+}
+
+func newMessage(gen *Generator, file *File, apitype vppapi.Message) *Message {
+ msg := &Message{
+ Message: apitype,
+ GoName: camelCaseName(apitype.Name),
+ }
+ for _, fieldType := range apitype.Fields {
+ field := newField(gen, file, fieldType)
+ field.ParentMessage = msg
+ msg.Fields = append(msg.Fields, field)
+ }
+ return msg
+}
+
+type Field struct {
+ vppapi.Field
+
+ GoName string
+
+ // Field parent
+ ParentMessage *Message
+ ParentStruct *Struct
+ ParentUnion *Union
+
+ // Type reference
+ Enum *Enum
+ Alias *Alias
+ Struct *Struct
+ Union *Union
+}
+
+func newField(gen *Generator, file *File, apitype vppapi.Field) *Field {
+ typ := &Field{
+ Field: apitype,
+ GoName: camelCaseName(apitype.Name),
+ }
+ return typ
+}
+
+func (f *Field) resolveType(gen *Generator) error {
+ switch {
+
+ }
+ return nil
+}
+
+type Service = vppapi.Service
+type RPC = vppapi.RPC
+
+func sortFileObjects(file *vppapi.File) {
+ // sort imports
+ sort.SliceStable(file.Imports, func(i, j int) bool {
+ return file.Imports[i] < file.Imports[j]
+ })
+ // sort enum types
+ sort.SliceStable(file.EnumTypes, func(i, j int) bool {
+ return file.EnumTypes[i].Name < file.EnumTypes[j].Name
+ })
+ // sort alias types
+ sort.Slice(file.AliasTypes, func(i, j int) bool {
+ return file.AliasTypes[i].Name < file.AliasTypes[j].Name
+ })
+ // sort struct types
+ sort.SliceStable(file.StructTypes, func(i, j int) bool {
+ return file.StructTypes[i].Name < file.StructTypes[j].Name
+ })
+ // sort union types
+ sort.SliceStable(file.UnionTypes, func(i, j int) bool {
+ return file.UnionTypes[i].Name < file.UnionTypes[j].Name
+ })
+ // sort messages
+ sort.SliceStable(file.Messages, func(i, j int) bool {
+ return file.Messages[i].Name < file.Messages[j].Name
+ })
+ // sort services
+ if file.Service != nil {
+ sort.Slice(file.Service.RPCs, func(i, j int) bool {
+ // dumps first
+ if file.Service.RPCs[i].Stream != file.Service.RPCs[j].Stream {
+ return file.Service.RPCs[i].Stream
+ }
+ return file.Service.RPCs[i].RequestMsg < file.Service.RPCs[j].RequestMsg
+ })
+ }
+}
+
+func sanitizedName(name string) string {
+ switch name {
+ case "interface":
+ return "interfaces"
+ case "map":
+ return "maps"
+ default:
+ return name
+ }
+}
+
+func normalizeImport(imp string) string {
+ imp = path.Base(imp)
+ if idx := strings.Index(imp, "."); idx >= 0 {
+ imp = imp[:idx]
+ }
+ return imp
+}
Code Review / govpp.git / blobdiff