import os
import sys
import logging
-from vapi_json_parser import Field, Struct, Message, JsonParser,\
+from vapi_json_parser import Field, Struct, Enum, Union, Message, JsonParser,\
SimpleType, StructType
class CStruct(Struct):
- def duplicate_barrier(func):
- def func_wrapper(self):
- name = self.get_c_name()
- return "#ifndef defined_{}\n#define defined_{}\n{}\n#endif".format(name, name, func(self))
- return func_wrapper
-
- @duplicate_barrier
def get_c_def(self):
return "\n".join([
- "typedef struct __attribute__((__packed__)) {",
- "%s;" % ";\n".join([" %s" % x.get_c_def()
- for x in self.fields]),
+ "typedef struct __attribute__((__packed__)) {\n%s;" % (
+ ";\n".join([" %s" % x.get_c_def()
+ for x in self.fields])),
"} %s;" % self.get_c_name()])
def get_swap_to_host_func_name(self):
return self.swap_to_host_dict[self.name]
- def get_swap_to_be_code(self, struct, var):
+ def get_swap_to_be_code(self, struct, var, cast=None):
x = "%s%s" % (struct, var)
- return "%s = %s(%s);" % (x, self.get_swap_to_be_func_name(), x)
+ return "%s = %s%s(%s);" % (x,
+ "(%s)" % cast if cast else "",
+ self.get_swap_to_be_func_name(), x)
- def get_swap_to_host_code(self, struct, var):
+ def get_swap_to_host_code(self, struct, var, cast=None):
x = "%s%s" % (struct, var)
- return "%s = %s(%s);" % (x, self.get_swap_to_host_func_name(), x)
+ return "%s = %s%s(%s);" % (x,
+ "(%s)" % cast if cast else "",
+ self.get_swap_to_host_func_name(), x)
def needs_byte_swap(self):
try:
return False
+class CEnum(Enum):
+ def get_c_name(self):
+ return "vapi_enum_%s" % self.name
+
+ def get_c_def(self):
+ return "typedef enum {\n%s\n} %s;" % (
+ "\n".join([" %s = %s," % (i, j) for i, j in self.value_pairs]),
+ self.get_c_name()
+ )
+
+ def needs_byte_swap(self):
+ return self.type.needs_byte_swap()
+
+ def get_swap_to_be_code(self, struct, var):
+ return self.type.get_swap_to_be_code(struct, var, self.get_c_name())
+
+ def get_swap_to_host_code(self, struct, var):
+ return self.type.get_swap_to_host_code(struct, var, self.get_c_name())
+
+
+class CUnion(Union):
+ def get_c_name(self):
+ return "vapi_union_%s" % self.name
+
+ def get_c_def(self):
+ return "typedef union {\n%s\n} %s;" % (
+ "\n".join([" %s %s;" % (i.get_c_name(), j)
+ for i, j in self.type_pairs]),
+ self.get_c_name()
+ )
+
+ def needs_byte_swap(self):
+ return False
+
+
class CStructType (StructType, CStruct):
def get_c_name(self):
return "vapi_type_%s" % self.name
class CMessage (Message):
- def __init__(self, logger, definition, typedict,
- struct_type_class, simple_type_class, field_class):
- super(CMessage, self).__init__(logger, definition, typedict,
- struct_type_class, simple_type_class,
- field_class)
+ def __init__(self, logger, definition, json_parser):
+ super(CMessage, self).__init__(logger, definition, json_parser)
self.payload_members = [
" %s" % p.get_c_def()
for p in self.fields
"}",
])
- def duplicate_barrier(func):
- def func_wrapper(self):
- name = self.get_payload_struct_name()
- return "#ifndef defined_{}\n#define defined_{}\n{}\n#endif".format(name, name, func(self))
- return func_wrapper
-
- @duplicate_barrier
def get_c_def(self):
if self.has_payload():
return "\n".join([
" %s(msg);" % self.get_swap_to_be_func_name(),
(" if (VAPI_OK == (rv = vapi_send_with_control_ping "
"(ctx, msg, req_context))) {"
- if self.is_dump() else
+ if self.reply_is_stream else
" if (VAPI_OK == (rv = vapi_send (ctx, msg))) {"
),
(" vapi_store_request(ctx, req_context, %s, "
"(vapi_cb_t)callback, callback_ctx);" %
- ("true" if self.is_dump() else "false")),
+ ("true" if self.reply_is_stream else "false")),
" if (VAPI_OK != vapi_producer_unlock (ctx)) {",
" abort (); /* this really shouldn't happen */",
" }",
])
def get_event_cb_func_decl(self):
- if not self.is_reply():
+ if not self.is_reply and not self.is_event:
raise Exception(
"Cannot register event callback for non-reply message")
if self.has_payload():
])
def get_event_cb_func_def(self):
- if not self.is_reply():
+ if not self.is_reply and not self.is_event:
raise Exception(
"Cannot register event callback for non-reply function")
return "\n".join([
"""
+def emit_definition(parser, json_file, emitted, o, logger):
+ if o in emitted:
+ return
+ logger.debug("emit definition for %s" % o)
+ if o.name in ("msg_header1_t", "msg_header2_t"):
+ return
+ if hasattr(o, "depends"):
+ for x in o.depends:
+ emit_definition(parser, json_file, emitted, x, logger)
+ if hasattr(o, "reply"):
+ emit_definition(parser, json_file, emitted, o.reply, logger)
+ if hasattr(o, "get_c_def"):
+ if (o not in parser.enums_by_json[json_file] and
+ o not in parser.types_by_json[json_file] and
+ o not in parser.unions_by_json[json_file] and
+ o.name not in parser.messages_by_json[json_file]):
+ return
+ logger.debug("writing def")
+ guard = "defined_%s" % o.get_c_name()
+ print("#ifndef %s" % guard)
+ print("#define %s" % guard)
+ print("%s" % o.get_c_def())
+ print("")
+ function_attrs = "static inline "
+ if o.name in parser.messages_by_json[json_file]:
+ logger.debug("o is %s" % o.name)
+ if o.has_payload():
+ logger.debug("o has payload ")
+ print("%s%s" % (function_attrs,
+ o.get_swap_payload_to_be_func_def()))
+ print("")
+ print("%s%s" % (function_attrs,
+ o.get_swap_payload_to_host_func_def()))
+ print("")
+ print("%s%s" % (function_attrs, o.get_swap_to_be_func_def()))
+ print("")
+ print("%s%s" % (function_attrs, o.get_swap_to_host_func_def()))
+ print("")
+ print("%s%s" % (function_attrs, o.get_calc_msg_size_func_def()))
+ print("")
+ if not o.is_reply and not o.is_event:
+ print("%s%s" % (function_attrs, o.get_alloc_func_def()))
+ print("")
+ print("%s%s" % (function_attrs, o.get_op_func_def()))
+ print("")
+ print("%s" % o.get_c_constructor())
+ print("")
+ if o.is_reply and not o.is_event:
+ print("%s%s;" % (function_attrs, o.get_event_cb_func_def()))
+ print("")
+ elif hasattr(o, "get_swap_to_be_func_def"):
+ print("%s%s" % (function_attrs, o.get_swap_to_be_func_def()))
+ print("")
+ print("%s%s" % (function_attrs, o.get_swap_to_host_func_def()))
+ print("")
+ print("#endif")
+ emitted.append(o)
+
+
def gen_json_unified_header(parser, logger, j, io, name):
d, f = os.path.split(j)
logger.info("Generating header `%s'" % name)
]))
print("")
print("")
+ emitted = []
+ for e in parser.enums_by_json[j]:
+ emit_definition(parser, j, emitted, e, logger)
+ for u in parser.unions_by_json[j]:
+ emit_definition(parser, j, emitted, u, logger)
for t in parser.types_by_json[j]:
- try:
- print("%s" % t.get_c_def())
- print("")
- except:
- pass
+ emit_definition(parser, j, emitted, t, logger)
for m in parser.messages_by_json[j].values():
- print("%s" % m.get_c_def())
- print("")
+ emit_definition(parser, j, emitted, m, logger)
print("")
- function_attrs = "static inline "
- for t in parser.types_by_json[j]:
- print("#ifndef defined_inline_%s" % t.get_c_name())
- print("#define defined_inline_%s" % t.get_c_name())
- print("%s%s" % (function_attrs, t.get_swap_to_be_func_def()))
- print("")
- print("%s%s" % (function_attrs, t.get_swap_to_host_func_def()))
- print("#endif")
- print("")
- for m in parser.messages_by_json[j].values():
- if m.has_payload():
- print("%s%s" % (function_attrs,
- m.get_swap_payload_to_be_func_def()))
- print("")
- print("%s%s" % (function_attrs,
- m.get_swap_payload_to_host_func_def()))
- print("")
- print("%s%s" % (function_attrs, m.get_calc_msg_size_func_def()))
- print("")
- print("%s%s" % (function_attrs, m.get_swap_to_be_func_def()))
- print("")
- print("%s%s" % (function_attrs, m.get_swap_to_host_func_def()))
- print("")
- for m in parser.messages_by_json[j].values():
- if m.is_reply():
- continue
- print("%s%s" % (function_attrs, m.get_alloc_func_def()))
- print("")
- print("%s%s" % (function_attrs, m.get_op_func_def()))
- print("")
- print("")
- for m in parser.messages_by_json[j].values():
- print("%s" % m.get_c_constructor())
- print("")
- print("")
- for m in parser.messages_by_json[j].values():
- if not m.is_reply():
- continue
- print("%s%s;" % (function_attrs, m.get_event_cb_func_def()))
- print("")
- print("")
if name == "vpe.api.vapi.h":
print("%s" % vapi_send_with_control_ping)
jsonparser = JsonParser(logger, args.files,
simple_type_class=CSimpleType,
+ enum_class=CEnum,
+ union_class=CUnion,
struct_type_class=CStructType,
field_class=CField,
message_class=CMessage)
import os
import sys
import logging
-from vapi_c_gen import CField, CStruct, CSimpleType, CStructType, CMessage, \
- json_to_c_header_name
+from vapi_c_gen import CField, CEnum, CStruct, CSimpleType, CStructType,\
+ CMessage, json_to_c_header_name
from vapi_json_parser import JsonParser
pass
+class CppEnum(CEnum):
+ pass
+
+
class CppSimpleType (CSimpleType):
pass
return "%s%s" % (self.name[0].upper(), self.name[1:])
def get_req_template_name(self):
- if self.is_dump():
+ if self.reply_is_stream:
template = "Dump"
else:
template = "Request"
print("/* m.get_cpp_constructor() */")
print("%s" % m.get_cpp_constructor())
print("")
- if not m.is_reply():
+ if not m.is_reply and not m.is_event:
if add_debug_comments:
print("/* m.get_alloc_template_instantiation() */")
print("%s" % m.get_alloc_template_instantiation())
print("/* m.get_msg_class_instantiation() */")
print("%s" % m.get_msg_class_instantiation())
print("")
- if m.is_reply():
+ if m.is_reply or m.is_event:
if add_debug_comments:
print("/* m.get_reply_type_alias() */")
print("%s" % m.get_reply_type_alias())
simple_type_class=CppSimpleType,
struct_type_class=CppStructType,
field_class=CppField,
+ enum_class=CppEnum,
message_class=CppMessage)
gen_cpp_headers(jsonparser, logger, args.prefix, args.gen_h_prefix,
import json
-def msg_is_reply(name):
- return name.endswith('_reply') or name.endswith('_details') \
- or name.endswith('_event') or name.endswith('_counters')
-
-
class ParseError (Exception):
pass
class Field(object):
- def __init__(
- self,
- field_name,
- field_type,
- array_len=None,
- nelem_field=None):
+ def __init__(self, field_name, field_type, array_len=None,
+ nelem_field=None):
self.name = field_name
self.type = field_type
self.len = array_len
return self.name
-def get_msg_header_defs(struct_type_class, field_class, typedict, logger):
+def get_msg_header_defs(struct_type_class, field_class, json_parser, logger):
return [
struct_type_class(['msg_header1_t',
['u16', '_vl_msg_id'],
['u32', 'context'],
],
- typedict, field_class, logger
+ json_parser, field_class, logger
),
struct_type_class(['msg_header2_t',
['u16', '_vl_msg_id'],
['u32', 'client_index'],
['u32', 'context'],
],
- typedict, field_class, logger
+ json_parser, field_class, logger
),
]
self.name = name
self.fields = fields
self.field_names = [n.name for n in self.fields]
+ self.depends = [f.type for f in self.fields]
def __str__(self):
return "[%s]" % "], [".join([str(f) for f in self.fields])
+class Enum(SimpleType):
+ def __init__(self, name, value_pairs, enumtype):
+ super(Enum, self).__init__(name)
+ self.type = enumtype
+ self.value_pairs = value_pairs
+
+ def __str__(self):
+ return "Enum(%s, [%s])" % (
+ self.name,
+ "], [" .join(["%s => %s" % (i, j) for i, j in self.value_pairs])
+ )
+
+
+class Union(Type):
+ def __init__(self, name, type_pairs, crc):
+ Type.__init__(self, name)
+ self.crc = crc
+ self.type_pairs = type_pairs
+ self.depends = [t for t, _ in self.type_pairs]
+
+ def __str__(self):
+ return "Union(%s, [%s])" % (
+ self.name,
+ "], [" .join(["%s %s" % (i, j) for i, j in self.type_pairs])
+ )
+
+
class Message(object):
- def __init__(self, logger, definition, typedict,
- struct_type_class, simple_type_class, field_class):
+ def __init__(self, logger, definition, json_parser):
+ struct_type_class = json_parser.struct_type_class
+ field_class = json_parser.field_class
self.request = None
self.logger = logger
m = definition
logger.debug("Message name is `%s'" % name)
ignore = True
self.header = None
+ self.is_reply = json_parser.is_reply(self.name)
+ self.is_event = json_parser.is_event(self.name)
fields = []
for header in get_msg_header_defs(struct_type_class, field_class,
- typedict, logger):
+ json_parser, logger):
logger.debug("Probing header `%s'" % header.name)
if header.is_part_of_def(m[1:]):
self.header = header
field_type=self.header))
ignore = False
break
- if ignore and not msg_is_reply(name):
+ if ignore and not self.is_event and not self.is_reply:
raise ParseError("While parsing message `%s': could not find all "
"common header fields" % name)
for field in m[1:]:
logger.debug("Found CRC `%s'" % self.crc)
continue
else:
- field_type = field[0]
- if field_type in typedict:
- field_type = typedict[field_type]
- else:
- mundane_field_type = remove_magic(field_type)
- if mundane_field_type in typedict:
- field_type = typedict[mundane_field_type]
- else:
- raise ParseError(
- "While parsing message `%s': could not find "
- "type by magic name `%s' nor by mundane name "
- "`%s'" % (name, field_type, mundane_field_type))
+ field_type = json_parser.lookup_type_like_id(field[0])
logger.debug("Parsing message field `%s'" % field)
if len(field) == 2:
if self.header is not None and\
logger.debug("Parsed field `%s'" % p)
fields.append(p)
self.fields = fields
-
- def is_dump(self):
- return self.name.endswith('_dump')
-
- def is_reply(self):
- return msg_is_reply(self.name)
+ self.depends = [f.type for f in self.fields]
class StructType (Type, Struct):
- def __init__(self, definition, typedict, field_class, logger):
+ def __init__(self, definition, json_parser, field_class, logger):
t = definition
logger.debug("Parsing struct definition `%s'" % t)
name = t[0]
if len(field) == 1 and 'crc' in field:
self.crc = field['crc']
continue
- field_type = field[0]
- if field_type in typedict:
- field_type = typedict[field_type]
- else:
- mundane_field_type = remove_magic(field_type)
- if mundane_field_type in typedict:
- field_type = typedict[mundane_field_type]
- else:
- raise ParseError(
- "While parsing message `%s': could not find "
- "type by magic name `%s' nor by mundane name "
- "`%s'" % (name, field_type, mundane_field_type))
+ 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],
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):
+ self.services = {}
self.messages = {}
+ self.enums = {}
+ self.unions = {}
self.types = {
x: simple_type_class(x) for x in [
'i8', 'i16', 'i32', 'i64',
]
}
+ self.replies = set()
+ self.events = set()
self.simple_type_class = simple_type_class
+ self.enum_class = enum_class
+ self.union_class = union_class
self.struct_type_class = struct_type_class
self.field_class = field_class
self.message_class = message_class
self.exceptions = []
self.json_files = []
self.types_by_json = {}
+ self.enums_by_json = {}
+ self.unions_by_json = {}
self.messages_by_json = {}
self.logger = logger
for f in files:
self.logger.info("Parsing json api file: `%s'" % path)
self.json_files.append(path)
self.types_by_json[path] = []
+ self.enums_by_json[path] = []
+ self.unions_by_json[path] = []
self.messages_by_json[path] = {}
with open(path) as f:
j = json.load(f)
- for t in j['types']:
- try:
- type_ = self.struct_type_class(t, self.types,
- self.field_class,
- self.logger)
- if type_.name in self.types:
- raise ParseError("Duplicate type `%s'" % type_.name)
- except ParseError as e:
- self.exceptions.append(e)
- continue
- self.types[type_.name] = type_
- self.types_by_json[path].append(type_)
- self.logger.debug("Parsed type: %s" % type_)
+ for k in j['services']:
+ if k in self.services:
+ raise ParseError("Duplicate service `%s'" % k)
+ self.services[k] = j['services'][k]
+ self.replies.add(self.services[k]["reply"])
+ if "events" in self.services[k]:
+ for x in self.services[k]["events"]:
+ self.events.add(x)
+ for e in j['enums']:
+ name = e[0]
+ value_pairs = e[1:-1]
+ enumtype = self.types[e[-1]["enumtype"]]
+ enum = self.enum_class(name, value_pairs, enumtype)
+ self.enums[enum.name] = enum
+ self.logger.debug("Parsed enum: %s" % enum)
+ self.enums_by_json[path].append(enum)
+ exceptions = []
+ progress = 0
+ last_progress = 0
+ while True:
+ for u in j['unions']:
+ name = u[0]
+ if name in self.unions:
+ progress = progress + 1
+ 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)
+ progress = progress + 1
+ except ParseError as e:
+ exceptions.append(e)
+ continue
+ self.unions[union.name] = union
+ self.logger.debug("Parsed union: %s" % union)
+ self.unions_by_json[path].append(union)
+ for t in j['types']:
+ if t[0] in self.types:
+ progress = progress + 1
+ continue
+ try:
+ type_ = self.struct_type_class(t, self,
+ self.field_class,
+ self.logger)
+ if type_.name in self.types:
+ raise ParseError(
+ "Duplicate type `%s'" % type_.name)
+ progress = progress + 1
+ except ParseError as e:
+ exceptions.append(e)
+ continue
+ self.types[type_.name] = type_
+ self.types_by_json[path].append(type_)
+ self.logger.debug("Parsed type: %s" % type_)
+ if not exceptions:
+ # finished parsing
+ break
+ if progress <= last_progress:
+ # cannot make forward progress
+ self.exceptions.extend(exceptions)
+ exceptions = []
+ last_progress = progress
+ progress = 0
prev_length = len(self.messages)
processed = []
while True:
if m in processed:
continue
try:
- msg = self.message_class(self.logger, m, self.types,
- self.struct_type_class,
- self.simple_type_class,
- self.field_class)
+ msg = self.message_class(self.logger, m, self)
if msg.name in self.messages:
raise ParseError(
"Duplicate message `%s'" % msg.name)
break
prev_length = len(self.messages)
+ def lookup_type_like_id(self, name):
+ mundane_name = remove_magic(name)
+ if name in self.types:
+ return self.types[name]
+ elif name in self.enums:
+ return self.enums[name]
+ elif name in self.unions:
+ return self.unions[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]
+ raise ParseError(
+ "Could not find type, enum or union by magic name `%s' nor by "
+ "mundane name `%s'" % (name, mundane_name))
+
+ def is_reply(self, message):
+ return message in self.replies
+
+ def is_event(self, message):
+ return message in self.events
+
def get_reply(self, message):
- if self.messages[message].is_dump():
- return self.messages["%s_details" % message[:-len("_dump")]]
- return self.messages["%s_reply" % message]
+ return self.messages[self.services[message]['reply']]
def finalize_parsing(self):
if len(self.messages) == 0:
remove = []
for n, m in j.items():
try:
- if not m.is_reply():
+ if not m.is_reply and not m.is_event:
try:
m.reply = self.get_reply(n)
+ if "stream" in self.services[m.name]:
+ m.reply_is_stream = \
+ self.services[m.name]["stream"]
+ else:
+ m.reply_is_stream = False
m.reply.request = m
except:
raise ParseError(
Code Review / vpp.git / commitdiff