Fix parsing default meta parameter

[govpp.git] / cmd / binapi-generator / parse.go

diff --git a/cmd/binapi-generator/parse.go b/cmd/binapi-generator/parse.go
index 602b17f..175fe50 100644 (file)
--- a/cmd/binapi-generator/parse.go
+++ b/cmd/binapi-generator/parse.go
@@ -63,7 +63,8 @@ const (
 
 // field meta info
 const (
-       fieldMetaLimit = "limit"
+       fieldMetaLimit   = "limit"
+       fieldMetaDefault = "default"
 )
 
 // module options
@@ -74,6 +75,7 @@ const (
 // parsePackage parses provided JSON data into objects prepared for code generation
 func parsePackage(ctx *context, jsonRoot *jsongo.JSONNode) (*Package, error) {
        pkg := Package{
+               Name:   ctx.packageName,
                RefMap: make(map[string]string),
        }
 
@@ -89,20 +91,15 @@ func parsePackage(ctx *context, jsonRoot *jsongo.JSONNode) (*Package, error) {
                }
        }
 
-       logf("parsing package %s (version: %s, CRC: %s) contains: %d services, %d messages, %d types, %d enums, %d unions, %d aliases",
-               ctx.packageName,
-               pkg.Version, pkg.CRC,
-               jsonRoot.Map(objServices).Len(),
-               jsonRoot.Map(objMessages).Len(),
-               jsonRoot.Map(objTypes).Len(),
-               jsonRoot.Map(objEnums).Len(),
-               jsonRoot.Map(objUnions).Len(),
-               jsonRoot.Map(objAliases).Len(),
-       )
+       logf("parsing package %s (version: %s, CRC: %s)", pkg.Name, pkg.Version, pkg.CRC)
+       logf(" consists of:")
+       for _, key := range jsonRoot.GetKeys() {
+               logf("  - %d %s", jsonRoot.At(key).Len(), key)
+       }
 
        // parse enums
        enums := jsonRoot.Map(objEnums)
-       pkg.Enums = make([]Enum, enums.Len())
+       pkg.Enums = make([]Enum, 0)
        for i := 0; i < enums.Len(); i++ {
                enumNode := enums.At(i)
 
@@ -110,8 +107,14 @@ func parsePackage(ctx *context, jsonRoot *jsongo.JSONNode) (*Package, error) {
                if err != nil {
                        return nil, err
                }
-               pkg.Enums[i] = *enum
-               pkg.RefMap[toApiType(enum.Name)] = enum.Name
+
+               enumApi := toApiType(enum.Name)
+               if _, ok := pkg.RefMap[enumApi]; ok {
+                       logf("enum %v already known", enumApi)
+                       continue
+               }
+               pkg.RefMap[enumApi] = enum.Name
+               pkg.Enums = append(pkg.Enums, *enum)
        }
        // sort enums
        sort.SliceStable(pkg.Enums, func(i, j int) bool {
@@ -121,16 +124,22 @@ func parsePackage(ctx *context, jsonRoot *jsongo.JSONNode) (*Package, error) {
        // parse aliases
        aliases := jsonRoot.Map(objAliases)
        if aliases.GetType() == jsongo.TypeMap {
-               pkg.Aliases = make([]Alias, aliases.Len())
-               for i, key := range aliases.GetKeys() {
+               pkg.Aliases = make([]Alias, 0)
+               for _, key := range aliases.GetKeys() {
                        aliasNode := aliases.At(key)
 
                        alias, err := parseAlias(ctx, key.(string), aliasNode)
                        if err != nil {
                                return nil, err
                        }
-                       pkg.Aliases[i] = *alias
-                       pkg.RefMap[toApiType(alias.Name)] = alias.Name
+
+                       aliasApi := toApiType(alias.Name)
+                       if _, ok := pkg.RefMap[aliasApi]; ok {
+                               logf("alias %v already known", aliasApi)
+                               continue
+                       }
+                       pkg.RefMap[aliasApi] = alias.Name
+                       pkg.Aliases = append(pkg.Aliases, *alias)
                }
        }
        // sort aliases to ensure consistent order
@@ -140,7 +149,7 @@ func parsePackage(ctx *context, jsonRoot *jsongo.JSONNode) (*Package, error) {
 
        // parse types
        types := jsonRoot.Map(objTypes)
-       pkg.Types = make([]Type, types.Len())
+       pkg.Types = make([]Type, 0)
        for i := 0; i < types.Len(); i++ {
                typNode := types.At(i)
 
@@ -148,8 +157,14 @@ func parsePackage(ctx *context, jsonRoot *jsongo.JSONNode) (*Package, error) {
                if err != nil {
                        return nil, err
                }
-               pkg.Types[i] = *typ
-               pkg.RefMap[toApiType(typ.Name)] = typ.Name
+
+               typApi := toApiType(typ.Name)
+               if _, ok := pkg.RefMap[typApi]; ok {
+                       logf("type %v already known", typApi)
+                       continue
+               }
+               pkg.RefMap[typApi] = typ.Name
+               pkg.Types = append(pkg.Types, *typ)
        }
        // sort types
        sort.SliceStable(pkg.Types, func(i, j int) bool {
@@ -158,7 +173,7 @@ func parsePackage(ctx *context, jsonRoot *jsongo.JSONNode) (*Package, error) {
 
        // parse unions
        unions := jsonRoot.Map(objUnions)
-       pkg.Unions = make([]Union, unions.Len())
+       pkg.Unions = make([]Union, 0)
        for i := 0; i < unions.Len(); i++ {
                unionNode := unions.At(i)
 
@@ -166,8 +181,14 @@ func parsePackage(ctx *context, jsonRoot *jsongo.JSONNode) (*Package, error) {
                if err != nil {
                        return nil, err
                }
-               pkg.Unions[i] = *union
-               pkg.RefMap[toApiType(union.Name)] = union.Name
+
+               unionApi := toApiType(union.Name)
+               if _, ok := pkg.RefMap[unionApi]; ok {
+                       logf("union %v already known", unionApi)
+                       continue
+               }
+               pkg.RefMap[unionApi] = union.Name
+               pkg.Unions = append(pkg.Unions, *union)
        }
        // sort unions
        sort.SliceStable(pkg.Unions, func(i, j int) bool {
@@ -428,13 +449,16 @@ func parseField(ctx *context, field *jsongo.JSONNode) (*Field, error) {
        }
 
        if field.Len() >= 3 {
-               if field.At(2).GetType() == jsongo.TypeValue {
+               switch field.At(2).GetType() {
+               case jsongo.TypeValue:
                        fieldLength, ok := field.At(2).Get().(float64)
                        if !ok {
                                return nil, fmt.Errorf("field length is %T, not float64", field.At(2).Get())
                        }
                        f.Length = int(fieldLength)
-               } else if field.At(2).GetType() == jsongo.TypeMap {
+                       f.SpecifiedLen = true
+
+               case jsongo.TypeMap:
                        fieldMeta := field.At(2)
 
                        for _, key := range fieldMeta.GetKeys() {
@@ -443,11 +467,13 @@ func parseField(ctx *context, field *jsongo.JSONNode) (*Field, error) {
                                switch metaName := key.(string); metaName {
                                case fieldMetaLimit:
                                        f.Meta.Limit = int(metaNode.Get().(float64))
+                               case fieldMetaDefault:
+                                       f.Meta.Default = fmt.Sprint(metaNode.Get())
                                default:
                                        logrus.Warnf("unknown meta info (%s) for field (%s)", metaName, fieldName)
                                }
                        }
-               } else {
+               default:
                        return nil, errors.New("invalid JSON for field specified")
                }
        }