#!/usr/bin/env python3 import argparse import inspect import os import sys import logging from vapi_json_parser import ( Field, Struct, Enum, Union, Message, JsonParser, SimpleType, StructType, Alias, ) class CField(Field): def get_c_name(self): return "vapi_type_%s" % self.name def get_c_def(self): if self.type.get_c_name() == "string": if self.len: return "u8 %s[%d];" % (self.name, self.len) else: return "vl_api_string_t %s;" % (self.name) else: if self.len is not None and type(self.len) != dict: return "%s %s[%d];" % (self.type.get_c_name(), self.name, self.len) else: return "%s %s;" % (self.type.get_c_name(), self.name) def get_swap_to_be_code(self, struct, var): if self.len is not None and type(self.len) != dict: if self.len > 0: return ( "do { unsigned i; for (i = 0; i < %d; ++i) { %s } }" " while(0);" % (self.len, self.type.get_swap_to_be_code(struct, "%s[i]" % var)) ) else: if self.nelem_field.needs_byte_swap(): nelem_field = "%s(%s%s)" % ( self.nelem_field.type.get_swap_to_host_func_name(), struct, self.nelem_field.name, ) else: nelem_field = "%s%s" % (struct, self.nelem_field.name) return ( "do { unsigned i; for (i = 0; i < %s; ++i) { %s } }" " while(0);" % ( nelem_field, self.type.get_swap_to_be_code(struct, "%s[i]" % var), ) ) return self.type.get_swap_to_be_code(struct, "%s" % var) def get_swap_to_host_code(self, struct, var): if self.len is not None and type(self.len) != dict: if self.len > 0: return ( "do { unsigned i; for (i = 0; i < %d; ++i) { %s } }" " while(0);" % (self.len, self.type.get_swap_to_host_code(struct, "%s[i]" % var)) ) else: # nelem_field already swapped to host here... return ( "do { unsigned i; for (i = 0; i < %s%s; ++i) { %s } }" " while(0);" % ( struct, self.nelem_field.name, self.type.get_swap_to_host_code(struct, "%s[i]" % var), ) ) return self.type.get_swap_to_host_code(struct, "%s" % var) def needs_byte_swap(self): return self.type.needs_byte_swap() def get_vla_parameter_name(self, path): return "%s_%s_array_size" % ("_".join(path), self.name) def get_vla_field_name(self, path): return ".".join(path + [self.nelem_field.name]) def get_alloc_vla_param_names(self, path): if self.is_vla(): result = [self.get_vla_parameter_name(path)] else: result = [] if self.type.has_vla(): t = self.type.get_alloc_vla_param_names(path + [self.name]) result.extend(t) return result def get_vla_calc_size_code(self, prefix, path, is_alloc): if self.is_vla(): result = [ "sizeof(%s.%s[0]) * %s" % ( ".".join([prefix] + path), self.name, self.get_vla_parameter_name(path) if is_alloc else "%s.%s" % (prefix, self.get_vla_field_name(path)), ) ] else: result = [] if self.type.has_vla(): t = self.type.get_vla_calc_size_code(prefix, path + [self.name], is_alloc) result.extend(t) return result def get_vla_assign_code(self, prefix, path): result = [] if self.is_vla(): result.append( "%s.%s = %s" % ( ".".join([prefix] + path), self.nelem_field.name, self.get_vla_parameter_name(path), ) ) if self.type.has_vla(): t = self.type.get_vla_assign_code(prefix, path + [self.name]) result.extend(t) return result class CAlias(CField): def get_c_name(self): return "vapi_type_%s" % self.name def get_c_def(self): if self.len is not None: return "typedef %s vapi_type_%s[%d];" % ( self.type.get_c_name(), self.name, self.len, ) else: return "typedef %s vapi_type_%s;" % (self.type.get_c_name(), self.name) class CStruct(Struct): def get_c_def(self): return "\n".join( [ "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_vla_assign_code(self, prefix, path): return [ x for f in self.fields if f.has_vla() for x in f.get_vla_assign_code(prefix, path) ] def get_alloc_vla_param_names(self, path): return [ x for f in self.fields if f.has_vla() for x in f.get_alloc_vla_param_names(path) ] def get_vla_calc_size_code(self, prefix, path, is_alloc): return [ x for f in self.fields if f.has_vla() for x in f.get_vla_calc_size_code(prefix, path, is_alloc) ] class CSimpleType(SimpleType): swap_to_be_dict = { "i16": "htobe16", "u16": "htobe16", "i32": "htobe32", "u32": "htobe32", "i64": "htobe64", "u64": "htobe64", } swap_to_host_dict = { "i16": "be16toh", "u16": "be16toh", "i32": "be32toh", "u32": "be32toh", "i64": "be64toh", "u64": "be64toh", } __packed = "__attribute__((packed))" pack_dict = { "i8": __packed, "u8": __packed, "i16": __packed, "u16": __packed, } def get_c_name(self): return self.name def get_swap_to_be_func_name(self): return self.swap_to_be_dict[self.name] def get_swap_to_host_func_name(self): return self.swap_to_host_dict[self.name] def get_packed_string(self): return self.pack_dict[self.name] def get_swap_to_be_code(self, struct, var, cast=None): x = "%s%s" % (struct, var) 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, cast=None): x = "%s%s" % (struct, var) 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: self.get_swap_to_host_func_name() return True except KeyError: pass return False def get_packed(self): return self.pack_dict.get(self.name, "") 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 %s;" % ( "\n".join([" %s = %s," % (i, j) for i, j in self.value_pairs]), self.type.get_packed(), 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): if self.name == "vl_api_string_t": return "vl_api_string_t" return "vapi_type_%s" % self.name def get_swap_to_be_func_name(self): return "%s_hton" % self.get_c_name() def get_swap_to_host_func_name(self): return "%s_ntoh" % self.get_c_name() def get_swap_to_be_func_decl(self): return "void %s(%s *msg)" % (self.get_swap_to_be_func_name(), self.get_c_name()) def get_swap_to_be_func_def(self): return "%s\n{\n%s\n}" % ( self.get_swap_to_be_func_decl(), "\n".join( [ " %s" % p.get_swap_to_be_code("msg->", "%s" % p.name) for p in self.fields if p.needs_byte_swap() ] ), ) def get_swap_to_host_func_decl(self): return "void %s(%s *msg)" % ( self.get_swap_to_host_func_name(), self.get_c_name(), ) def get_swap_to_host_func_def(self): return "%s\n{\n%s\n}" % ( self.get_swap_to_host_func_decl(), "\n".join( [ " %s" % p.get_swap_to_host_code("msg->", "%s" % p.name) for p in self.fields if p.needs_byte_swap() ] ), ) def get_swap_to_be_code(self, struct, var): return "%s(&%s%s);" % (self.get_swap_to_be_func_name(), struct, var) def get_swap_to_host_code(self, struct, var): return "%s(&%s%s);" % (self.get_swap_to_host_func_name(), struct, var) def needs_byte_swap(self): for f in self.fields: if f.needs_byte_swap(): return True return False class CMessage(Message): 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 if p.type != self.header ] def has_payload(self): return len(self.payload_members) > 0 def get_msg_id_name(self): return "vapi_msg_id_%s" % self.name def get_c_name(self): return "vapi_msg_%s" % self.name def get_payload_struct_name(self): return "vapi_payload_%s" % self.name def get_alloc_func_name(self): return "vapi_alloc_%s" % self.name def get_alloc_vla_param_names(self): return [ x for f in self.fields if f.has_vla() for x in f.get_alloc_vla_param_names([]) ] def get_alloc_func_decl(self): return "%s* %s(struct vapi_ctx_s *ctx%s)" % ( self.get_c_name(), self.get_alloc_func_name(), "".join([", size_t %s" % n for n in self.get_alloc_vla_param_names()]), ) def get_alloc_func_def(self): extra = [] if self.header.has_field("client_index"): extra.append(" msg->header.client_index = vapi_get_client_index(ctx);") if self.header.has_field("context"): extra.append(" msg->header.context = 0;") return "\n".join( [ "%s" % self.get_alloc_func_decl(), "{", " %s *msg = NULL;" % self.get_c_name(), " const size_t size = sizeof(%s)%s;" % ( self.get_c_name(), "".join( [ " + %s" % x for f in self.fields if f.has_vla() for x in f.get_vla_calc_size_code( "msg->payload", [], is_alloc=True ) ] ), ), " /* cast here required to play nicely with C++ world ... */", " msg = (%s*)vapi_msg_alloc(ctx, size);" % self.get_c_name(), " if (!msg) {", " return NULL;", " }", ] + extra + [ " msg->header._vl_msg_id = vapi_lookup_vl_msg_id(ctx, %s);" % self.get_msg_id_name(), "".join( [ " %s;\n" % line for f in self.fields if f.has_vla() for line in f.get_vla_assign_code("msg->payload", []) ] ), " return msg;", "}", ] ) def get_calc_msg_size_func_name(self): return "vapi_calc_%s_msg_size" % self.name def get_calc_msg_size_func_decl(self): return "uword %s(%s *msg)" % ( self.get_calc_msg_size_func_name(), self.get_c_name(), ) def get_calc_msg_size_func_def(self): return "\n".join( [ "%s" % self.get_calc_msg_size_func_decl(), "{", " return sizeof(*msg)%s;" % "".join( [ " + %s" % x for f in self.fields if f.has_vla() for x in f.get_vla_calc_size_code( "msg->payload", [], is_alloc=False ) ] ), "}", ] ) def get_verify_msg_size_func_name(self): return f"vapi_verify_{self.name}_msg_size" def get_verify_msg_size_func_decl(self): return "int %s(%s *msg, uword buf_size)" % ( self.get_verify_msg_size_func_name(), self.get_c_name(), ) def get_verify_msg_size_func_def(self): return inspect.cleandoc( f""" {self.get_verify_msg_size_func_decl()} {{ if (sizeof({self.get_c_name()}) > buf_size) {{ VAPI_ERR("Truncated '{self.name}' msg received, received %lu" "bytes, expected %lu bytes.", buf_size, sizeof({self.get_c_name()})); return -1; }} if ({self.get_calc_msg_size_func_name()}(msg) > buf_size) {{ VAPI_ERR("Truncated '{self.name}' msg received, received %lu" "bytes, expected %lu bytes.", buf_size, {self.get_calc_msg_size_func_name()}(msg)); return -1; }} return 0; }} """ ) def get_c_def(self): if self.has_payload(): return "\n".join( [ "typedef struct __attribute__ ((__packed__)) {", "%s " % "\n".join(self.payload_members), "} %s;" % self.get_payload_struct_name(), "", "typedef struct __attribute__ ((__packed__)) {", ( " %s %s;" % (self.header.get_c_name(), self.fields[0].name) if self.header is not None else "" ), " %s payload;" % self.get_payload_struct_name(), "} %s;" % self.get_c_name(), ] ) else: return "\n".join( [ "typedef struct __attribute__ ((__packed__)) {", ( " %s %s;" % (self.header.get_c_name(), self.fields[0].name) if self.header is not None else "" ), "} %s;" % self.get_c_name(), ] ) def get_swap_payload_to_host_func_name(self): return "%s_payload_ntoh" % self.get_c_name() def get_swap_payload_to_be_func_name(self): return "%s_payload_hton" % self.get_c_name() def get_swap_payload_to_host_func_decl(self): return "void %s(%s *payload)" % ( self.get_swap_payload_to_host_func_name(), self.get_payload_struct_name(), ) def get_swap_payload_to_be_func_decl(self): return "void %s(%s *payload)" % ( self.get_swap_payload_to_be_func_name(), self.get_payload_struct_name(), ) def get_swap_payload_to_be_func_def(self): return "%s\n{\n%s\n}" % ( self.get_swap_payload_to_be_func_decl(), "\n".join( [ " %s" % p.get_swap_to_be_code("payload->", "%s" % p.name) for p in self.fields if p.needs_byte_swap() and p.type != self.header ] ), ) def get_swap_payload_to_host_func_def(self): return "%s\n{\n%s\n}" % ( self.get_swap_payload_to_host_func_decl(), "\n".join( [ " %s" % p.get_swap_to_host_code("payload->", "%s" % p.name) for p in self.fields if p.needs_byte_swap() and p.type != self.header ] ), ) def get_swap_to_host_func_name(self): return "%s_ntoh" % self.get_c_name() def get_swap_to_be_func_name(self): return "%s_hton" % self.get_c_name() def get_swap_to_host_func_decl(self): return "void %s(%s *msg)" % ( self.get_swap_to_host_func_name(), self.get_c_name(), ) def get_swap_to_be_func_decl(self): return "void %s(%s *msg)" % (self.get_swap_to_be_func_name(), self.get_c_name()) def get_swap_to_be_func_def(self): return "\n".join( [ "%s" % self.get_swap_to_be_func_decl(), "{", ( ' VAPI_DBG("Swapping `%s\'@%%p to big endian", msg);' % self.get_c_name() ), " %s(&msg->header);" % self.header.get_swap_to_be_func_name() if self.header is not None else "", " %s(&msg->payload);" % self.get_swap_payload_to_be_func_name() if self.has_payload() else "", "}", ] ) def get_swap_to_host_func_def(self): return "\n".join( [ "%s" % self.get_swap_to_host_func_decl(), "{", ( ' VAPI_DBG("Swapping `%s\'@%%p to host byte order", msg);' % self.get_c_name() ), " %s(&msg->header);" % self.header.get_swap_to_host_func_name() if self.header is not None else "", " %s(&msg->payload);" % self.get_swap_payload_to_host_func_name() if self.has_payload() else "", "}", ] ) def get_op_func_name(self): return "vapi_%s" % self.name def get_op_func_decl(self): stream_param_lines = [] if self.has_stream_msg: stream_param_lines = [ "vapi_error_e (*details_callback)(struct vapi_ctx_s *ctx", " void *callback_ctx", " vapi_error_e rv", " bool is_last", " %s *details)" % self.stream_msg.get_payload_struct_name(), "void *details_callback_ctx", ] return "vapi_error_e %s(%s)" % ( self.get_op_func_name(), ",\n ".join( [ "struct vapi_ctx_s *ctx", "%s *msg" % self.get_c_name(), "vapi_error_e (*reply_callback)(struct vapi_ctx_s *ctx", " void *callback_ctx", " vapi_error_e rv", " bool is_last", " %s *reply)" % self.reply.get_payload_struct_name(), ] + [ "void *reply_callback_ctx", ] + stream_param_lines ), ) def get_op_func_def(self): param_check_lines = [" if (!msg || !reply_callback) {"] store_request_lines = [ " vapi_store_request(ctx, req_context, %s, %s, " % ( self.reply.get_msg_id_name(), "VAPI_REQUEST_DUMP" if self.reply_is_stream else "VAPI_REQUEST_REG", ), " (vapi_cb_t)reply_callback, reply_callback_ctx);", ] if self.has_stream_msg: param_check_lines = [ " if (!msg || !reply_callback || !details_callback) {" ] store_request_lines = [ f" vapi_store_request(ctx, req_context, {self.stream_msg.get_msg_id_name()}, VAPI_REQUEST_STREAM, ", " (vapi_cb_t)details_callback, details_callback_ctx);", f" vapi_store_request(ctx, req_context, {self.reply.get_msg_id_name()}, VAPI_REQUEST_REG, ", " (vapi_cb_t)reply_callback, reply_callback_ctx);", ] return "\n".join( [ "%s" % self.get_op_func_decl(), "{", ] + param_check_lines + [ " return VAPI_EINVAL;", " }", " if (vapi_is_nonblocking(ctx) && vapi_requests_full(ctx)) {", " return VAPI_EAGAIN;", " }", " vapi_error_e rv;", " if (VAPI_OK != (rv = vapi_producer_lock (ctx))) {", " return rv;", " }", " u32 req_context = vapi_gen_req_context(ctx);", " msg->header.context = req_context;", " %s(msg);" % self.get_swap_to_be_func_name(), ( " if (VAPI_OK == (rv = vapi_send_with_control_ping " "(ctx, msg, req_context))) {" if (self.reply_is_stream and not self.has_stream_msg) else " if (VAPI_OK == (rv = vapi_send (ctx, msg))) {" ), ] + store_request_lines + [ " if (VAPI_OK != vapi_producer_unlock (ctx)) {", " abort (); /* this really shouldn't happen */", " }", " if (vapi_is_nonblocking(ctx)) {", " rv = VAPI_OK;", " } else {", " rv = vapi_dispatch(ctx);", " }", " } else {", " %s(msg);" % self.get_swap_to_host_func_name(), " if (VAPI_OK != vapi_producer_unlock (ctx)) {", " abort (); /* this really shouldn't happen */", " }", " }", " return rv;", "}", "", ] ) def get_event_cb_func_decl(self): if not self.is_reply and not self.is_event: raise Exception("Cannot register event callback for non-reply message") if self.has_payload(): return "\n".join( [ "void vapi_set_%s_event_cb (" % self.get_c_name(), " struct vapi_ctx_s *ctx, ", ( " vapi_error_e (*callback)(struct vapi_ctx_s *ctx, " "void *callback_ctx, %s *payload)," % self.get_payload_struct_name() ), " void *callback_ctx)", ] ) else: return "\n".join( [ "void vapi_set_%s_event_cb (" % self.get_c_name(), " struct vapi_ctx_s *ctx, ", " vapi_error_e (*callback)(struct vapi_ctx_s *ctx, " "void *callback_ctx),", " void *callback_ctx)", ] ) def get_event_cb_func_def(self): if not self.is_reply and not self.is_event: raise Exception("Cannot register event callback for non-reply function") return "\n".join( [ "%s" % self.get_event_cb_func_decl(), "{", ( " vapi_set_event_cb(ctx, %s, (vapi_event_cb)callback, " "callback_ctx);" % self.get_msg_id_name() ), "}", ] ) def get_c_metadata_struct_name(self): return "__vapi_metadata_%s" % self.name def get_c_constructor(self): has_context = False if self.header is not None: has_context = self.header.has_field("context") return "\n".join( [ "static void __attribute__((constructor)) __vapi_constructor_%s()" % self.name, "{", ' static const char name[] = "%s";' % self.name, ' static const char name_with_crc[] = "%s_%s";' % (self.name, self.crc[2:]), " static vapi_message_desc_t %s = {" % self.get_c_metadata_struct_name(), " name,", " sizeof(name) - 1,", " name_with_crc,", " sizeof(name_with_crc) - 1,", " true," if has_context else " false,", " offsetof(%s, context)," % self.header.get_c_name() if has_context else " 0,", (" offsetof(%s, payload)," % self.get_c_name()) if self.has_payload() else " VAPI_INVALID_MSG_ID,", " (verify_msg_size_fn_t)%s," % self.get_verify_msg_size_func_name(), " (generic_swap_fn_t)%s," % self.get_swap_to_be_func_name(), " (generic_swap_fn_t)%s," % self.get_swap_to_host_func_name(), " VAPI_INVALID_MSG_ID,", " };", "", " %s = vapi_register_msg(&%s);" % (self.get_msg_id_name(), self.get_c_metadata_struct_name()), ' VAPI_DBG("Assigned msg id %%d to %s", %s);' % (self.name, self.get_msg_id_name()), "}", ] ) def emit_definition(parser, json_file, emitted, o): if o in emitted: return 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) if hasattr(o, "reply"): emit_definition(parser, json_file, emitted, o.reply) if hasattr(o, "stream_msg"): emit_definition(parser, json_file, emitted, o.stream_msg) 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] and o not in parser.aliases_by_json[json_file] ): return 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]: if 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("") print("%s%s" % (function_attrs, o.get_verify_msg_size_func_def())) if not o.is_reply and not o.is_event and not o.is_stream: print("") 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()) if (o.is_reply or o.is_event) and not o.is_stream: print("") print("%s%s;" % (function_attrs, o.get_event_cb_func_def())) 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("#endif") print("") 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) orig_stdout = sys.stdout sys.stdout = io include_guard = "__included_%s" % ( j.replace(".", "_") .replace("/", "_") .replace("-", "_") .replace("+", "_") .replace("@", "_") ) print("#ifndef %s" % include_guard) print("#define %s" % include_guard) print("") print("#include <stdlib.h>") print("#include <stddef.h>") print("#include <arpa/inet.h>") print("#include <vapi/vapi_internal.h>") print("#include <vapi/vapi.h>") print("#include <vapi/vapi_dbg.h>") print("") print("#ifdef __cplusplus") print('extern "C" {') print("#endif") print("#ifndef __vl_api_string_swap_fns_defined__") print("#define __vl_api_string_swap_fns_defined__") print("") print("#include <vlibapi/api_types.h>") print("") function_attrs = "static inline " o = parser.types["vl_api_string_t"] 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 //__vl_api_string_swap_fns_defined__") if name == "memclnt.api.vapi.h": print("") print( "static inline vapi_error_e vapi_send_with_control_ping " "(vapi_ctx_t ctx, void * msg, u32 context);" ) elif name == "vlib.api.vapi.h": print("#include <vapi/memclnt.api.vapi.h>") else: print("#include <vapi/vlib.api.vapi.h>") print("") for m in parser.messages_by_json[j].values(): print("extern vapi_msg_id_t %s;" % m.get_msg_id_name()) print("") print( "#define DEFINE_VAPI_MSG_IDS_%s\\" % f.replace(".", "_").replace("/", "_").replace("-", "_").upper() ) print( "\\\n".join( [ " vapi_msg_id_t %s;" % m.get_msg_id_name() for m in parser.messages_by_json[j].values() ] ) ) print("") print("") emitted = [] for e in parser.enums_by_json[j]: emit_definition(parser, j, emitted, e) for u in parser.unions_by_json[j]: emit_definition(parser, j, emitted, u) for t in parser.types_by_json[j]: emit_definition(parser, j, emitted, t) for a in parser.aliases_by_json[j]: emit_definition(parser, j, emitted, a) for m in parser.messages_by_json[j].values(): emit_definition(parser, j, emitted, m) print("") if name == "vlib.api.vapi.h": vapi_send_with_control_ping_function = """ static inline vapi_error_e vapi_send_with_control_ping (vapi_ctx_t ctx, void *msg, u32 context) { vapi_msg_control_ping *ping = vapi_alloc_control_ping (ctx); if (!ping) { return VAPI_ENOMEM; } ping->header.context = context; vapi_msg_control_ping_hton (ping); return vapi_send2 (ctx, msg, ping); } """ print("%s" % vapi_send_with_control_ping_function) print("") print("#ifdef __cplusplus") print("}") print("#endif") print("") print("#endif") sys.stdout = orig_stdout def json_to_c_header_name(json_name): if json_name.endswith(".json"): return "%s.vapi.h" % os.path.splitext(json_name)[0] raise Exception("Unexpected json name `%s'!" % json_name) def gen_c_unified_headers(parser, logger, prefix, remove_path): if prefix == "" or prefix is None: prefix = "" else: prefix = "%s/" % prefix for j in parser.json_files: if remove_path: d, f = os.path.split(j) else: f = j with open("%s%s" % (prefix, json_to_c_header_name(f)), "w") as io: gen_json_unified_header(parser, logger, j, io, json_to_c_header_name(f)) if __name__ == "__main__": try: verbose = int(os.getenv("V", 0)) except: verbose = 0 if verbose >= 2: log_level = 10 elif verbose == 1: log_level = 20 else: log_level = 40 logging.basicConfig(stream=sys.stdout, level=log_level) logger = logging.getLogger("VAPI C GEN") logger.setLevel(log_level) argparser = argparse.ArgumentParser(description="VPP C API generator") argparser.add_argument( "files", metavar="api-file", action="append", type=str, help="json api file" "(may be specified multiple times)", ) argparser.add_argument("--prefix", action="store", default=None, help="path prefix") argparser.add_argument( "--remove-path", action="store_true", help="remove path from filename" ) args = argparser.parse_args() 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, alias_class=CAlias, ) # not using the model of having separate generated header and code files # with generated symbols present in shared library (per discussion with # Damjan), to avoid symbol version issues in .so # gen_c_headers_and_code(jsonparser, logger, args.prefix) gen_c_unified_headers(jsonparser, logger, args.prefix, args.remove_path) for e in jsonparser.exceptions: logger.warning(e)