--- /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 (
+ "strings"
+
+ "github.com/sirupsen/logrus"
+)
+
+// define api
+const (
+ defineApiPrefix = "vl_api_"
+ defineApiSuffix = "_t"
+)
+
+// BaseType represents base types in VPP binary API.
+type BaseType int
+
+const (
+ U8 BaseType = iota + 1
+ I8
+ U16
+ I16
+ U32
+ I32
+ U64
+ I64
+ F64
+ BOOL
+ STRING
+)
+
+var (
+ BaseTypes = map[BaseType]string{
+ U8: "u8",
+ I8: "i8",
+ U16: "u16",
+ I16: "i16",
+ U32: "u32",
+ I32: "i32",
+ U64: "u64",
+ I64: "i64",
+ F64: "f64",
+ BOOL: "bool",
+ STRING: "string",
+ }
+ BaseTypeNames = map[string]BaseType{
+ "u8": U8,
+ "i8": I8,
+ "u16": U16,
+ "i16": I16,
+ "u32": U32,
+ "i32": I32,
+ "u64": U64,
+ "i64": I64,
+ "f64": F64,
+ "bool": BOOL,
+ "string": STRING,
+ }
+)
+
+var BaseTypeSizes = map[BaseType]int{
+ U8: 1,
+ I8: 1,
+ U16: 2,
+ I16: 2,
+ U32: 4,
+ I32: 4,
+ U64: 8,
+ I64: 8,
+ F64: 8,
+ BOOL: 1,
+ STRING: 1,
+}
+
+type Kind int
+
+const (
+ _ = iota
+ Uint8Kind
+ Int8Kind
+ Uint16Kind
+ Int16Kind
+ Uint32Kind
+ Int32Kind
+ Uint64Kind
+ Int64Kind
+ Float64Kind
+ BoolKind
+ StringKind
+ EnumKind
+ AliasKind
+ StructKind
+ UnionKind
+ MessageKind
+)
+
+// toApiType returns name that is used as type reference in VPP binary API
+func toApiType(name string) string {
+ return defineApiPrefix + name + defineApiSuffix
+}
+
+func fromApiType(typ string) string {
+ name := typ
+ name = strings.TrimPrefix(name, defineApiPrefix)
+ name = strings.TrimSuffix(name, defineApiSuffix)
+ return name
+}
+
+func getSizeOfType(module *File, typ *Struct) (size int) {
+ for _, field := range typ.Fields {
+ enum := getEnumByRef(module, field.Type)
+ if enum != nil {
+ size += getSizeOfBinapiTypeLength(enum.Type, field.Length)
+ continue
+ }
+ size += getSizeOfBinapiTypeLength(field.Type, field.Length)
+ }
+ return size
+}
+
+func getEnumByRef(file *File, ref string) *Enum {
+ for _, typ := range file.Enums {
+ if ref == toApiType(typ.Name) {
+ return typ
+ }
+ }
+ return nil
+}
+
+func getTypeByRef(file *File, ref string) *Struct {
+ for _, typ := range file.Structs {
+ if ref == toApiType(typ.Name) {
+ return typ
+ }
+ }
+ return nil
+}
+
+func getAliasByRef(file *File, ref string) *Alias {
+ for _, alias := range file.Aliases {
+ if ref == toApiType(alias.Name) {
+ return alias
+ }
+ }
+ return nil
+}
+
+func getUnionByRef(file *File, ref string) *Union {
+ for _, union := range file.Unions {
+ if ref == toApiType(union.Name) {
+ return union
+ }
+ }
+ return nil
+}
+
+func getBinapiTypeSize(binapiType string) (size int) {
+ typName := BaseTypeNames[binapiType]
+ return BaseTypeSizes[typName]
+}
+
+// binapiTypes is a set of types used VPP binary API for translation to Go types
+var binapiTypes = map[string]string{
+ "u8": "uint8",
+ "i8": "int8",
+ "u16": "uint16",
+ "i16": "int16",
+ "u32": "uint32",
+ "i32": "int32",
+ "u64": "uint64",
+ "i64": "int64",
+ "f64": "float64",
+}
+var BaseTypesGo = map[BaseType]string{
+ U8: "uint8",
+ I8: "int8",
+ U16: "uint16",
+ I16: "int16",
+ U32: "uint32",
+ I32: "int32",
+ U64: "uint64",
+ I64: "int64",
+ F64: "float64",
+ BOOL: "bool",
+ STRING: "string",
+}
+
+func getActualType(file *File, typ string) (actual string) {
+ for _, enum := range file.Enums {
+ if enum.GoName == typ {
+ return enum.Type
+ }
+ }
+ for _, alias := range file.Aliases {
+ if alias.GoName == typ {
+ return alias.Type
+ }
+ }
+ return typ
+}
+
+// convertToGoType translates the VPP binary API type into Go type
+func convertToGoType(file *File, binapiType string) (typ string) {
+ if t, ok := binapiTypes[binapiType]; ok {
+ // basic types
+ typ = t
+ } else if r, ok := file.refmap[binapiType]; ok {
+ // specific types (enums/types/unions)
+ typ = camelCaseName(r)
+ } else {
+ switch binapiType {
+ case "bool", "string":
+ typ = binapiType
+ default:
+ // fallback type
+ logrus.Warnf("found unknown VPP binary API type %q, using byte", binapiType)
+ typ = "byte"
+ }
+ }
+ return typ
+}
+
+func getSizeOfBinapiTypeLength(typ string, length int) (size int) {
+ if n := getBinapiTypeSize(typ); n > 0 {
+ if length > 0 {
+ return n * length
+ } else {
+ return n
+ }
+ }
+
+ return
+}
+
+func getUnionSize(file *File, union *Union) (maxSize int) {
+ for _, field := range union.Fields {
+ typ := getTypeByRef(file, field.Type)
+ if typ != nil {
+ if size := getSizeOfType(file, typ); size > maxSize {
+ maxSize = size
+ }
+ continue
+ }
+ alias := getAliasByRef(file, field.Type)
+ if alias != nil {
+ if size := getSizeOfBinapiTypeLength(alias.Type, alias.Length); size > maxSize {
+ maxSize = size
+ }
+ continue
+ } else {
+ logf("no type or alias found for union %s field type %q", union.Name, field.Type)
+ continue
+ }
+ }
+ logf("getUnionSize: %s %+v max=%v", union.Name, union.Fields, maxSize)
+ return
+}
Code Review / govpp.git / blobdiff