6 def msg_is_reply(name):
7 return name.endswith('_reply') or name.endswith('_details') \
8 or name.endswith('_event') or name.endswith('_counters')
11 class ParseError (Exception):
15 magic_prefix = "vl_api_"
19 def remove_magic(what):
20 if what.startswith(magic_prefix) and what.endswith(magic_suffix):
21 return what[len(magic_prefix): - len(magic_suffix)]
33 self.name = field_name
34 self.type = field_type
36 self.nelem_field = nelem_field
40 return "name: %s, type: %s" % (self.name, self.type)
42 return "name: %s, type: %s, length: %s" % (self.name, self.type,
45 return ("name: %s, type: %s, variable length stored in: %s" %
46 (self.name, self.type, self.nelem_field))
50 def __init__(self, name):
57 class SimpleType (Type):
59 def __init__(self, name):
60 super(SimpleType, self).__init__(name)
66 def get_msg_header_defs(struct_type_class, field_class, typedict, logger):
68 struct_type_class(['msg_header1_t',
69 ['u16', '_vl_msg_id'],
72 typedict, field_class, logger
74 struct_type_class(['msg_header2_t',
75 ['u16', '_vl_msg_id'],
76 ['u32', 'client_index'],
79 typedict, field_class, logger
86 def __init__(self, name, fields):
89 self.field_names = [n.name for n in self.fields]
92 return "[%s]" % "], [".join([str(f) for f in self.fields])
95 class Message(object):
97 def __init__(self, logger, definition, typedict,
98 struct_type_class, simple_type_class, field_class):
102 logger.debug("Parsing message definition `%s'" % m)
105 logger.debug("Message name is `%s'" % name)
109 for header in get_msg_header_defs(struct_type_class, field_class,
111 logger.debug("Probing header `%s'" % header.name)
112 if header.is_part_of_def(m[1:]):
114 logger.debug("Found header `%s'" % header.name)
115 fields.append(field_class(field_name='header',
116 field_type=self.header))
119 if ignore and not msg_is_reply(name):
120 raise ParseError("While parsing message `%s': could not find all "
121 "common header fields" % name)
123 if len(field) == 1 and 'crc' in field:
124 self.crc = field['crc']
125 logger.debug("Found CRC `%s'" % self.crc)
128 field_type = field[0]
129 if field_type in typedict:
130 field_type = typedict[field_type]
132 mundane_field_type = remove_magic(field_type)
133 if mundane_field_type in typedict:
134 field_type = typedict[mundane_field_type]
137 "While parsing message `%s': could not find "
138 "type by magic name `%s' nor by mundane name "
139 "`%s'" % (name, field_type, mundane_field_type))
140 logger.debug("Parsing message field `%s'" % field)
142 if self.header is not None and\
143 self.header.has_field(field[1]):
145 p = field_class(field_name=field[1],
146 field_type=field_type)
147 elif len(field) == 3:
150 "While parsing message `%s': variable length "
151 "array `%s' doesn't have reference to member "
152 "containing the actual length" % (
156 field_type=field_type,
158 elif len(field) == 4:
161 if f.name == field[3]:
163 if nelem_field is None:
165 "While parsing message `%s': couldn't find "
166 "variable length array `%s' member containing "
167 "the actual length `%s'" % (
168 name, field[1], field[3]))
171 field_type=field_type,
173 nelem_field=nelem_field)
175 raise Exception("Don't know how to parse message "
176 "definition for message `%s': `%s'" %
178 logger.debug("Parsed field `%s'" % p)
183 return self.name.endswith('_dump')
186 return msg_is_reply(self.name)
189 class StructType (Type, Struct):
191 def __init__(self, definition, typedict, field_class, logger):
193 logger.debug("Parsing struct definition `%s'" % t)
197 if len(field) == 1 and 'crc' in field:
198 self.crc = field['crc']
200 field_type = field[0]
201 if field_type in typedict:
202 field_type = typedict[field_type]
204 mundane_field_type = remove_magic(field_type)
205 if mundane_field_type in typedict:
206 field_type = typedict[mundane_field_type]
209 "While parsing message `%s': could not find "
210 "type by magic name `%s' nor by mundane name "
211 "`%s'" % (name, field_type, mundane_field_type))
212 logger.debug("Parsing type field `%s'" % field)
214 p = field_class(field_name=field[1],
215 field_type=field_type)
216 elif len(field) == 3:
218 raise ParseError("While parsing type `%s': array `%s' has "
219 "variable length" % (name, field[1]))
220 p = field_class(field_name=field[1],
221 field_type=field_type,
223 elif len(field) == 4:
226 if f.name == field[3]:
228 if nelem_field is None:
230 "While parsing message `%s': couldn't find "
231 "variable length array `%s' member containing "
232 "the actual length `%s'" % (
233 name, field[1], field[3]))
234 p = field_class(field_name=field[1],
235 field_type=field_type,
237 nelem_field=nelem_field)
240 "Don't know how to parse field `%s' of type definition "
241 "for type `%s'" % (field, t))
243 Type.__init__(self, name)
244 Struct.__init__(self, name, fields)
247 return "StructType(%s, %s)" % (Type.__str__(self),
248 Struct.__str__(self))
250 def has_field(self, name):
251 return name in self.field_names
253 def is_part_of_def(self, definition):
254 for idx in range(len(self.fields)):
255 field = definition[idx]
257 if field[1] != p.name:
259 if field[0] != p.type.name:
261 "Unexpected field type `%s' (should be `%s'), "
262 "while parsing msg/def/field `%s/%s/%s'" %
263 (field[0], p.type, p.name, definition, field))
267 class JsonParser(object):
268 def __init__(self, logger, files, simple_type_class=SimpleType,
269 struct_type_class=StructType, field_class=Field,
270 message_class=Message):
273 x: simple_type_class(x) for x in [
274 'i8', 'i16', 'i32', 'i64',
275 'u8', 'u16', 'u32', 'u64',
280 self.simple_type_class = simple_type_class
281 self.struct_type_class = struct_type_class
282 self.field_class = field_class
283 self.message_class = message_class
287 self.types_by_json = {}
288 self.messages_by_json = {}
291 self.parse_json_file(f)
292 self.finalize_parsing()
294 def parse_json_file(self, path):
295 self.logger.info("Parsing json api file: `%s'" % path)
296 self.json_files.append(path)
297 self.types_by_json[path] = []
298 self.messages_by_json[path] = {}
299 with open(path) as f:
303 type_ = self.struct_type_class(t, self.types,
306 if type_.name in self.types:
307 raise ParseError("Duplicate type `%s'" % type_.name)
308 except ParseError as e:
309 self.exceptions.append(e)
311 self.types[type_.name] = type_
312 self.types_by_json[path].append(type_)
313 self.logger.debug("Parsed type: %s" % type_)
314 prev_length = len(self.messages)
318 for m in j['messages']:
322 msg = self.message_class(self.logger, m, self.types,
323 self.struct_type_class,
324 self.simple_type_class,
326 if msg.name in self.messages:
328 "Duplicate message `%s'" % msg.name)
329 except ParseError as e:
332 self.messages[msg.name] = msg
333 self.messages_by_json[path][msg.name] = msg
335 if prev_length == len(self.messages):
336 # cannot make forward progress ...
337 self.exceptions.extend(exceptions)
339 prev_length = len(self.messages)
341 def get_reply(self, message):
342 if self.messages[message].is_dump():
343 return self.messages["%s_details" % message[:-len("_dump")]]
344 return self.messages["%s_reply" % message]
346 def finalize_parsing(self):
347 if len(self.messages) == 0:
348 for e in self.exceptions:
350 for jn, j in self.messages_by_json.items():
352 for n, m in j.items():
356 m.reply = self.get_reply(n)
360 "Cannot find reply to message `%s'" % n)
361 except ParseError as e:
362 self.exceptions.append(e)
365 self.messages_by_json[jn] = {
366 k: v for k, v in j.items() if k not in remove}