api: use string type for strings in memclnt.api

Explicitly using string type in API allows for autogenerating tools to print
strings instead of hex-dumping byte strings.

Type: fix
Signed-off-by: Ole Troan <ot@cisco.com>
Signed-off-by: Klement Sekera <ksekera@cisco.com>
Change-Id: I573962d6b34d5d10aab9dc6a5fdf101c9b12a6a6
Signed-off-by: Ole Troan <ot@cisco.com>

1 files changed, 47 insertions, 72 deletions

diff --git a/src/vpp-api/vapi/vapi_json_parser.py b/src/vpp-api/vapi/vapi_json_parser.py
index a9d2c8186bc..d0f8de03617 100644
--- a/src/vpp-api/vapi/vapi_json_parser.py
+++ b/src/vpp-api/vapi/vapi_json_parser.py
@@ -167,48 +167,9 @@ class Message(object):
             else:
                 field_type = json_parser.lookup_type_like_id(field[0])
                 logger.debug("Parsing message field `%s'" % field)
-                l = len(field)
-                if any(type(n) is dict for n in field):
-                    l -= 1
-                if l == 2:
-                    if self.header is not None and\
-                            self.header.has_field(field[1]):
-                        continue
-                    p = field_class(field_name=field[1],
-                                    field_type=field_type)
-                elif l == 3:
-                    if field[2] == 0:
-                        raise ParseError(
-                            "While parsing message `%s': variable length "
-                            "array `%s' doesn't have reference to member "
-                            "containing the actual length" % (
-                                name, field[1]))
-                    p = field_class(
-                        field_name=field[1],
-                        field_type=field_type,
-                        array_len=field[2])
-                elif l == 4:
-                    nelem_field = None
-                    for f in fields:
-                        if f.name == field[3]:
-                            nelem_field = f
-                    if nelem_field is None:
-                        raise ParseError(
-                            "While parsing message `%s': couldn't find "
-                            "variable length array `%s' member containing "
-                            "the actual length `%s'" % (
-                                name, field[1], field[3]))
-                    p = field_class(
-                        field_name=field[1],
-                        field_type=field_type,
-                        array_len=field[2],
-                        nelem_field=nelem_field)
-                else:
-                    raise Exception("Don't know how to parse message "
-                                    "definition for message `%s': `%s'" %
-                                    (m, m[1:]))
-                logger.debug("Parsed field `%s'" % p)
-                fields.append(p)
+                f = parse_field(field_class, fields, field, field_type)
+                logger.debug("Parsed field `%s'" % f)
+                fields.append(f)
         self.fields = fields
         self.depends = [f.type for f in self.fields]
         logger.debug("Parsed message: %s" % self)
@@ -220,6 +181,48 @@ class Message(object):
              self.crc)
 
 
+def parse_field(field_class, fields, field, field_type):
+    l = len(field)
+    if l > 2:
+        if type(field[2]) is dict:
+            if "limit" in field[2]:
+                array_len = field[2]["limit"]
+            else:
+                l -= 1
+        else:
+            array_len = field[2]
+
+    if l == 2:
+        return field_class(field_name=field[1],
+                           field_type=field_type)
+    elif l == 3:
+        if field[2] == 0:
+            raise ParseError("While parsing type `%s': array `%s' has "
+                             "variable length" % (name, field[1]))
+        return field_class(field_name=field[1],
+                           field_type=field_type,
+                           array_len=array_len)
+    elif l == 4:
+        nelem_field = None
+        for f in fields:
+            if f.name == field[3]:
+                nelem_field = f
+        if nelem_field is None:
+            raise ParseError(
+                "While parsing message `%s': couldn't find "
+                "variable length array `%s' member containing "
+                "the actual length `%s'" % (
+                    name, field[1], field[3]))
+        return field_class(field_name=field[1],
+                           field_type=field_type,
+                           array_len=array_len,
+                           nelem_field=nelem_field)
+    else:
+        raise ParseError(
+            "Don't know how to parse field `%s' of type definition "
+            "for type `%s'" % (field, t))
+
+
 class StructType (Type, Struct):
 
     def __init__(self, definition, json_parser, field_class, logger):
@@ -233,36 +236,8 @@ class StructType (Type, Struct):
                 continue
             field_type = json_parser.lookup_type_like_id(field[0])
             logger.debug("Parsing type field `%s'" % field)
-            if len(field) == 2:
-                p = field_class(field_name=field[1],
-                                field_type=field_type)
-            elif len(field) == 3:
-                if field[2] == 0:
-                    raise ParseError("While parsing type `%s': array `%s' has "
-                                     "variable length" % (name, field[1]))
-                p = field_class(field_name=field[1],
-                                field_type=field_type,
-                                array_len=field[2])
-            elif len(field) == 4:
-                nelem_field = None
-                for f in fields:
-                    if f.name == field[3]:
-                        nelem_field = f
-                if nelem_field is None:
-                    raise ParseError(
-                        "While parsing message `%s': couldn't find "
-                        "variable length array `%s' member containing "
-                        "the actual length `%s'" % (
-                            name, field[1], field[3]))
-                p = field_class(field_name=field[1],
-                                field_type=field_type,
-                                array_len=field[2],
-                                nelem_field=nelem_field)
-            else:
-                raise ParseError(
-                    "Don't know how to parse field `%s' of type definition "
-                    "for type `%s'" % (field, t))
-            fields.append(p)
+            f = parse_field(field_class, fields, field, field_type)
+            fields.append(f)
         Type.__init__(self, name)
         Struct.__init__(self, name, fields)