api: revert use string type for strings in memclnt.api

[vpp.git] / src / vpp-api / vapi / vapi_json_parser.py

diff --git a/src/vpp-api/vapi/vapi_json_parser.py b/src/vpp-api/vapi/vapi_json_parser.py
index 8728a1a..a9d2c81 100644 (file)
--- a/src/vpp-api/vapi/vapi_json_parser.py
+++ b/src/vpp-api/vapi/vapi_json_parser.py
@@ -45,6 +45,10 @@ class Field(object):
         return self.is_vla() or self.type.has_vla()
 
 
+class Alias(Field):
+    pass
+
+
 class Type(object):
     def __init__(self, name):
         self.name = name
@@ -55,12 +59,6 @@ class Type(object):
 
 class SimpleType (Type):
 
-    def __init__(self, name):
-        super(SimpleType, self).__init__(name)
-
-    def __str__(self):
-        return self.name
-
     def has_vla(self):
         return False
 
@@ -169,13 +167,16 @@ class Message(object):
             else:
                 field_type = json_parser.lookup_type_like_id(field[0])
                 logger.debug("Parsing message field `%s'" % field)
-                if len(field) == 2:
+                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 len(field) == 3:
+                elif l == 3:
                     if field[2] == 0:
                         raise ParseError(
                             "While parsing message `%s': variable length "
@@ -186,7 +187,7 @@ class Message(object):
                         field_name=field[1],
                         field_type=field_type,
                         array_len=field[2])
-                elif len(field) == 4:
+                elif l == 4:
                     nelem_field = None
                     for f in fields:
                         if f.name == field[3]:
@@ -290,19 +291,21 @@ class JsonParser(object):
     def __init__(self, logger, files, simple_type_class=SimpleType,
                  enum_class=Enum, union_class=Union,
                  struct_type_class=StructType, field_class=Field,
-                 message_class=Message):
+                 message_class=Message, alias_class=Alias):
         self.services = {}
         self.messages = {}
         self.enums = {}
         self.unions = {}
+        self.aliases = {}
         self.types = {
             x: simple_type_class(x) for x in [
                 'i8', 'i16', 'i32', 'i64',
                 'u8', 'u16', 'u32', 'u64',
-                'f64'
+                'f64', 'bool'
             ]
         }
 
+        self.types['string'] = simple_type_class('vl_api_string_t')
         self.replies = set()
         self.events = set()
         self.simple_type_class = simple_type_class
@@ -310,6 +313,7 @@ class JsonParser(object):
         self.union_class = union_class
         self.struct_type_class = struct_type_class
         self.field_class = field_class
+        self.alias_class = alias_class
         self.message_class = message_class
 
         self.exceptions = []
@@ -317,6 +321,7 @@ class JsonParser(object):
         self.types_by_json = {}
         self.enums_by_json = {}
         self.unions_by_json = {}
+        self.aliases_by_json = {}
         self.messages_by_json = {}
         self.logger = logger
         for f in files:
@@ -329,6 +334,7 @@ class JsonParser(object):
         self.types_by_json[path] = []
         self.enums_by_json[path] = []
         self.unions_by_json[path] = []
+        self.aliases_by_json[path] = []
         self.messages_by_json[path] = {}
         with open(path) as f:
             j = json.load(f)
@@ -359,9 +365,8 @@ class JsonParser(object):
                         continue
                     try:
                         type_pairs = [[self.lookup_type_like_id(t), n]
-                                      for t, n in u[1:-1]]
-                        crc = u[-1]["crc"]
-                        union = self.union_class(name, type_pairs, crc)
+                                      for t, n in u[1:]]
+                        union = self.union_class(name, type_pairs, 0)
                         progress = progress + 1
                     except ParseError as e:
                         exceptions.append(e)
@@ -369,6 +374,19 @@ class JsonParser(object):
                     self.unions[union.name] = union
                     self.logger.debug("Parsed union: %s" % union)
                     self.unions_by_json[path].append(union)
+                for name, body in j['aliases'].iteritems():
+                    if name in self.aliases:
+                        progress = progress + 1
+                        continue
+                    if 'length' in body:
+                        array_len = body['length']
+                    else:
+                        array_len = None
+                    t = self.types[body['type']]
+                    alias = self.alias_class(name, t, array_len)
+                    self.aliases[name] = alias
+                    self.logger.debug("Parsed alias: %s" % alias)
+                    self.aliases_by_json[path].append(alias)
                 for t in j['types']:
                     if t[0] in self.types:
                         progress = progress + 1
@@ -393,6 +411,7 @@ class JsonParser(object):
                 if progress <= last_progress:
                     # cannot make forward progress
                     self.exceptions.extend(exceptions)
+                    break
                 exceptions = []
                 last_progress = progress
                 progress = 0
@@ -428,12 +447,16 @@ class JsonParser(object):
             return self.enums[name]
         elif name in self.unions:
             return self.unions[name]
+        elif name in self.aliases:
+            return self.aliases[name]
         elif mundane_name in self.types:
             return self.types[mundane_name]
         elif mundane_name in self.enums:
             return self.enums[mundane_name]
         elif mundane_name in self.unions:
             return self.unions[mundane_name]
+        elif mundane_name in self.aliases:
+            return self.aliases[mundane_name]
         raise ParseError(
             "Could not find type, enum or union by magic name `%s' nor by "
             "mundane name `%s'" % (name, mundane_name))