API: Add support for type aliases

[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 7995424..3eb5d36 100644 (file)
--- a/src/vpp-api/vapi/vapi_json_parser.py
+++ b/src/vpp-api/vapi/vapi_json_parser.py
@@ -28,13 +28,25 @@ class Field(object):
 
     def __str__(self):
         if self.len is None:
-            return "name: %s, type: %s" % (self.name, self.type)
+            return "Field(name: %s, type: %s)" % (self.name, self.type)
         elif self.len > 0:
-            return "name: %s, type: %s, length: %s" % (self.name, self.type,
-                                                       self.len)
+            return "Field(name: %s, type: %s, length: %s)" % (self.name,
+                                                              self.type,
+                                                              self.len)
         else:
-            return ("name: %s, type: %s, variable length stored in: %s" %
-                    (self.name, self.type, self.nelem_field))
+            return (
+                "Field(name: %s, type: %s, variable length stored in: %s)" %
+                (self.name, self.type, self.nelem_field))
+
+    def is_vla(self):
+        return self.nelem_field is not None
+
+    def has_vla(self):
+        return self.is_vla() or self.type.has_vla()
+
+
+class Alias(Field):
+    pass
 
 
 class Type(object):
@@ -47,11 +59,8 @@ 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
 
 
 def get_msg_header_defs(struct_type_class, field_class, json_parser, logger):
@@ -83,6 +92,12 @@ class Struct(object):
     def __str__(self):
         return "[%s]" % "], [".join([str(f) for f in self.fields])
 
+    def has_vla(self):
+        for f in self.fields:
+            if f.has_vla():
+                return True
+        return False
+
 
 class Enum(SimpleType):
     def __init__(self, name, value_pairs, enumtype):
@@ -110,6 +125,9 @@ class Union(Type):
             "], [" .join(["%s %s" % (i, j) for i, j in self.type_pairs])
         )
 
+    def has_vla(self):
+        return False
+
 
 class Message(object):
 
@@ -190,6 +208,13 @@ class Message(object):
                 fields.append(p)
         self.fields = fields
         self.depends = [f.type for f in self.fields]
+        logger.debug("Parsed message: %s" % self)
+
+    def __str__(self):
+        return "Message(%s, [%s], {crc: %s}" % \
+            (self.name,
+             "], [".join([str(f) for f in self.fields]),
+             self.crc)
 
 
 class StructType (Type, Struct):
@@ -263,11 +288,12 @@ 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',
@@ -283,6 +309,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 = []
@@ -290,6 +317,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:
@@ -302,6 +330,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)
@@ -342,6 +371,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
@@ -366,6 +408,7 @@ class JsonParser(object):
                 if progress <= last_progress:
                     # cannot make forward progress
                     self.exceptions.extend(exceptions)
+                    break
                 exceptions = []
                 last_progress = progress
                 progress = 0
@@ -401,12 +444,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))