8 from vapi_json_parser import (
23 return "vapi_type_%s" % self.name
26 if self.type.get_c_name() == "string":
28 return "u8 %s[%d];" % (self.name, self.len)
30 return "vl_api_string_t %s;" % (self.name)
32 if self.len is not None and type(self.len) != dict:
33 return "%s %s[%d];" % (self.type.get_c_name(), self.name, self.len)
35 return "%s %s;" % (self.type.get_c_name(), self.name)
37 def get_swap_to_be_code(self, struct, var):
38 if self.len is not None and type(self.len) != dict:
41 "do { unsigned i; for (i = 0; i < %d; ++i) { %s } }"
43 % (self.len, self.type.get_swap_to_be_code(struct, "%s[i]" % var))
46 if self.nelem_field.needs_byte_swap():
47 nelem_field = "%s(%s%s)" % (
48 self.nelem_field.type.get_swap_to_host_func_name(),
50 self.nelem_field.name,
53 nelem_field = "%s%s" % (struct, self.nelem_field.name)
55 "do { unsigned i; for (i = 0; i < %s; ++i) { %s } }"
59 self.type.get_swap_to_be_code(struct, "%s[i]" % var),
62 return self.type.get_swap_to_be_code(struct, "%s" % var)
64 def get_swap_to_host_code(self, struct, var):
65 if self.len is not None and type(self.len) != dict:
68 "do { unsigned i; for (i = 0; i < %d; ++i) { %s } }"
70 % (self.len, self.type.get_swap_to_host_code(struct, "%s[i]" % var))
73 # nelem_field already swapped to host here...
75 "do { unsigned i; for (i = 0; i < %s%s; ++i) { %s } }"
79 self.nelem_field.name,
80 self.type.get_swap_to_host_code(struct, "%s[i]" % var),
83 return self.type.get_swap_to_host_code(struct, "%s" % var)
85 def needs_byte_swap(self):
86 return self.type.needs_byte_swap()
88 def get_vla_parameter_name(self, path):
89 return "%s_%s_array_size" % ("_".join(path), self.name)
91 def get_vla_field_name(self, path):
92 return ".".join(path + [self.nelem_field.name])
94 def get_alloc_vla_param_names(self, path):
96 result = [self.get_vla_parameter_name(path)]
99 if self.type.has_vla():
100 t = self.type.get_alloc_vla_param_names(path + [self.name])
104 def get_vla_calc_size_code(self, prefix, path, is_alloc):
107 "sizeof(%s.%s[0]) * %s"
109 ".".join([prefix] + path),
112 self.get_vla_parameter_name(path)
114 else "%s.%s" % (prefix, self.get_vla_field_name(path))
120 if self.type.has_vla():
121 t = self.type.get_vla_calc_size_code(prefix, path + [self.name], is_alloc)
125 def get_vla_assign_code(self, prefix, path):
131 ".".join([prefix] + path),
132 self.nelem_field.name,
133 self.get_vla_parameter_name(path),
136 if self.type.has_vla():
137 t = self.type.get_vla_assign_code(prefix, path + [self.name])
142 class CAlias(CField):
143 def get_c_name(self):
144 return "vapi_type_%s" % self.name
147 if self.len is not None:
148 return "typedef %s vapi_type_%s[%d];" % (
149 self.type.get_c_name(),
154 return "typedef %s vapi_type_%s;" % (self.type.get_c_name(), self.name)
157 class CStruct(Struct):
161 "typedef struct __attribute__((__packed__)) {\n%s"
162 % ("\n".join([" %s" % x.get_c_def() for x in self.fields])),
163 "} %s;" % self.get_c_name(),
167 def get_vla_assign_code(self, prefix, path):
172 for x in f.get_vla_assign_code(prefix, path)
175 def get_alloc_vla_param_names(self, path):
180 for x in f.get_alloc_vla_param_names(path)
183 def get_vla_calc_size_code(self, prefix, path, is_alloc):
188 for x in f.get_vla_calc_size_code(prefix, path, is_alloc)
192 class CSimpleType(SimpleType):
202 swap_to_host_dict = {
211 __packed = "__attribute__((packed))"
219 def get_c_name(self):
222 def get_swap_to_be_func_name(self):
223 return self.swap_to_be_dict[self.name]
225 def get_swap_to_host_func_name(self):
226 return self.swap_to_host_dict[self.name]
228 def get_packed_string(self):
229 return self.pack_dict[self.name]
231 def get_swap_to_be_code(self, struct, var, cast=None):
232 x = "%s%s" % (struct, var)
233 return "%s = %s%s(%s);" % (
235 "(%s)" % cast if cast else "",
236 self.get_swap_to_be_func_name(),
240 def get_swap_to_host_code(self, struct, var, cast=None):
241 x = "%s%s" % (struct, var)
242 return "%s = %s%s(%s);" % (
244 "(%s)" % cast if cast else "",
245 self.get_swap_to_host_func_name(),
249 def needs_byte_swap(self):
251 self.get_swap_to_host_func_name()
257 def get_packed(self):
258 return self.pack_dict.get(self.name, "")
262 def get_c_name(self):
263 return "vapi_enum_%s" % self.name
266 return "typedef enum {\n%s\n} %s %s;" % (
267 "\n".join([" %s = %s," % (i, j) for i, j in self.value_pairs]),
268 self.type.get_packed(),
272 def needs_byte_swap(self):
273 return self.type.needs_byte_swap()
275 def get_swap_to_be_code(self, struct, var):
276 return self.type.get_swap_to_be_code(struct, var, self.get_c_name())
278 def get_swap_to_host_code(self, struct, var):
279 return self.type.get_swap_to_host_code(struct, var, self.get_c_name())
283 def get_c_name(self):
284 return "vapi_union_%s" % self.name
287 return "typedef union {\n%s\n} %s;" % (
288 "\n".join([" %s %s;" % (i.get_c_name(), j) for i, j in self.type_pairs]),
292 def needs_byte_swap(self):
296 class CStructType(StructType, CStruct):
297 def get_c_name(self):
298 if self.name == "vl_api_string_t":
299 return "vl_api_string_t"
300 return "vapi_type_%s" % self.name
302 def get_swap_to_be_func_name(self):
303 return "%s_hton" % self.get_c_name()
305 def get_swap_to_host_func_name(self):
306 return "%s_ntoh" % self.get_c_name()
308 def get_swap_to_be_func_decl(self):
309 return "void %s(%s *msg)" % (self.get_swap_to_be_func_name(), self.get_c_name())
311 def get_swap_to_be_func_def(self):
312 return "%s\n{\n%s\n}" % (
313 self.get_swap_to_be_func_decl(),
316 " %s" % p.get_swap_to_be_code("msg->", "%s" % p.name)
318 if p.needs_byte_swap()
323 def get_swap_to_host_func_decl(self):
324 return "void %s(%s *msg)" % (
325 self.get_swap_to_host_func_name(),
329 def get_swap_to_host_func_def(self):
330 return "%s\n{\n%s\n}" % (
331 self.get_swap_to_host_func_decl(),
334 " %s" % p.get_swap_to_host_code("msg->", "%s" % p.name)
336 if p.needs_byte_swap()
341 def get_swap_to_be_code(self, struct, var):
342 return "%s(&%s%s);" % (self.get_swap_to_be_func_name(), struct, var)
344 def get_swap_to_host_code(self, struct, var):
345 return "%s(&%s%s);" % (self.get_swap_to_host_func_name(), struct, var)
347 def needs_byte_swap(self):
348 for f in self.fields:
349 if f.needs_byte_swap():
354 class CMessage(Message):
355 def __init__(self, logger, definition, json_parser):
356 super(CMessage, self).__init__(logger, definition, json_parser)
357 self.payload_members = [
358 " %s" % p.get_c_def() for p in self.fields if p.type != self.header
361 def has_payload(self):
362 return len(self.payload_members) > 0
364 def get_msg_id_name(self):
365 return "vapi_msg_id_%s" % self.name
367 def get_c_name(self):
368 return "vapi_msg_%s" % self.name
370 def get_payload_struct_name(self):
371 return "vapi_payload_%s" % self.name
373 def get_alloc_func_name(self):
374 return "vapi_alloc_%s" % self.name
376 def get_alloc_vla_param_names(self):
381 for x in f.get_alloc_vla_param_names([])
384 def get_alloc_func_decl(self):
385 return "%s* %s(struct vapi_ctx_s *ctx%s)" % (
387 self.get_alloc_func_name(),
388 "".join([", size_t %s" % n for n in self.get_alloc_vla_param_names()]),
391 def get_alloc_func_def(self):
393 if self.header.has_field("client_index"):
394 extra.append(" msg->header.client_index = vapi_get_client_index(ctx);")
395 if self.header.has_field("context"):
396 extra.append(" msg->header.context = 0;")
399 "%s" % self.get_alloc_func_decl(),
401 " %s *msg = NULL;" % self.get_c_name(),
402 " const size_t size = sizeof(%s)%s;"
410 for x in f.get_vla_calc_size_code(
411 "msg->payload", [], is_alloc=True
416 " /* cast here required to play nicely with C++ world ... */",
417 " msg = (%s*)vapi_msg_alloc(ctx, size);" % self.get_c_name(),
424 " msg->header._vl_msg_id = vapi_lookup_vl_msg_id(ctx, %s);"
425 % self.get_msg_id_name(),
431 for line in f.get_vla_assign_code("msg->payload", [])
439 def get_calc_msg_size_func_name(self):
440 return "vapi_calc_%s_msg_size" % self.name
442 def get_calc_msg_size_func_decl(self):
443 return "uword %s(%s *msg)" % (
444 self.get_calc_msg_size_func_name(),
448 def get_calc_msg_size_func_def(self):
451 "%s" % self.get_calc_msg_size_func_decl(),
453 " return sizeof(*msg)%s;"
459 for x in f.get_vla_calc_size_code(
460 "msg->payload", [], is_alloc=False
468 def get_verify_msg_size_func_name(self):
469 return f"vapi_verify_{self.name}_msg_size"
471 def get_verify_msg_size_func_decl(self):
472 return "int %s(%s *msg, uword buf_size)" % (
473 self.get_verify_msg_size_func_name(),
477 def get_verify_msg_size_func_def(self):
478 return inspect.cleandoc(
480 {self.get_verify_msg_size_func_decl()}
482 if (sizeof({self.get_c_name()}) > buf_size)
484 VAPI_ERR("Truncated '{self.name}' msg received, received %lu"
485 "bytes, expected %lu bytes.", buf_size,
486 sizeof({self.get_c_name()}));
489 if ({self.get_calc_msg_size_func_name()}(msg) > buf_size)
491 VAPI_ERR("Truncated '{self.name}' msg received, received %lu"
492 "bytes, expected %lu bytes.", buf_size,
493 {self.get_calc_msg_size_func_name()}(msg));
502 if self.has_payload():
505 "typedef struct __attribute__ ((__packed__)) {",
506 "%s " % "\n".join(self.payload_members),
507 "} %s;" % self.get_payload_struct_name(),
509 "typedef struct __attribute__ ((__packed__)) {",
511 " %s %s;" % (self.header.get_c_name(), self.fields[0].name)
512 if self.header is not None
515 " %s payload;" % self.get_payload_struct_name(),
516 "} %s;" % self.get_c_name(),
522 "typedef struct __attribute__ ((__packed__)) {",
524 " %s %s;" % (self.header.get_c_name(), self.fields[0].name)
525 if self.header is not None
528 "} %s;" % self.get_c_name(),
532 def get_swap_payload_to_host_func_name(self):
533 return "%s_payload_ntoh" % self.get_c_name()
535 def get_swap_payload_to_be_func_name(self):
536 return "%s_payload_hton" % self.get_c_name()
538 def get_swap_payload_to_host_func_decl(self):
539 return "void %s(%s *payload)" % (
540 self.get_swap_payload_to_host_func_name(),
541 self.get_payload_struct_name(),
544 def get_swap_payload_to_be_func_decl(self):
545 return "void %s(%s *payload)" % (
546 self.get_swap_payload_to_be_func_name(),
547 self.get_payload_struct_name(),
550 def get_swap_payload_to_be_func_def(self):
551 return "%s\n{\n%s\n}" % (
552 self.get_swap_payload_to_be_func_decl(),
555 " %s" % p.get_swap_to_be_code("payload->", "%s" % p.name)
557 if p.needs_byte_swap() and p.type != self.header
562 def get_swap_payload_to_host_func_def(self):
563 return "%s\n{\n%s\n}" % (
564 self.get_swap_payload_to_host_func_decl(),
567 " %s" % p.get_swap_to_host_code("payload->", "%s" % p.name)
569 if p.needs_byte_swap() and p.type != self.header
574 def get_swap_to_host_func_name(self):
575 return "%s_ntoh" % self.get_c_name()
577 def get_swap_to_be_func_name(self):
578 return "%s_hton" % self.get_c_name()
580 def get_swap_to_host_func_decl(self):
581 return "void %s(%s *msg)" % (
582 self.get_swap_to_host_func_name(),
586 def get_swap_to_be_func_decl(self):
587 return "void %s(%s *msg)" % (self.get_swap_to_be_func_name(), self.get_c_name())
589 def get_swap_to_be_func_def(self):
592 "%s" % self.get_swap_to_be_func_decl(),
595 ' VAPI_DBG("Swapping `%s\'@%%p to big endian", msg);'
599 " %s(&msg->header);" % self.header.get_swap_to_be_func_name()
600 if self.header is not None
604 " %s(&msg->payload);" % self.get_swap_payload_to_be_func_name()
605 if self.has_payload()
612 def get_swap_to_host_func_def(self):
615 "%s" % self.get_swap_to_host_func_decl(),
618 ' VAPI_DBG("Swapping `%s\'@%%p to host byte order", msg);'
622 " %s(&msg->header);" % self.header.get_swap_to_host_func_name()
623 if self.header is not None
627 " %s(&msg->payload);" % self.get_swap_payload_to_host_func_name()
628 if self.has_payload()
635 def get_op_func_name(self):
636 return "vapi_%s" % self.name
638 def get_op_func_decl(self):
639 stream_param_lines = []
640 if self.has_stream_msg:
641 stream_param_lines = [
642 "vapi_error_e (*details_callback)(struct vapi_ctx_s *ctx",
643 " void *callback_ctx",
647 % self.stream_msg.get_payload_struct_name(),
648 "void *details_callback_ctx",
651 return "vapi_error_e %s(%s)" % (
652 self.get_op_func_name(),
655 "struct vapi_ctx_s *ctx",
656 "%s *msg" % self.get_c_name(),
657 "vapi_error_e (*reply_callback)(struct vapi_ctx_s *ctx",
658 " void *callback_ctx",
662 % self.reply.get_payload_struct_name(),
665 "void *reply_callback_ctx",
671 def get_op_func_def(self):
672 param_check_lines = [" if (!msg || !reply_callback) {"]
673 store_request_lines = [
674 " vapi_store_request(ctx, req_context, %s, %s, "
676 self.reply.get_msg_id_name(),
677 "VAPI_REQUEST_DUMP" if self.reply_is_stream else "VAPI_REQUEST_REG",
679 " (vapi_cb_t)reply_callback, reply_callback_ctx);",
681 if self.has_stream_msg:
682 param_check_lines = [
683 " if (!msg || !reply_callback || !details_callback) {"
685 store_request_lines = [
686 f" vapi_store_request(ctx, req_context, {self.stream_msg.get_msg_id_name()}, VAPI_REQUEST_STREAM, ",
687 " (vapi_cb_t)details_callback, details_callback_ctx);",
688 f" vapi_store_request(ctx, req_context, {self.reply.get_msg_id_name()}, VAPI_REQUEST_REG, ",
689 " (vapi_cb_t)reply_callback, reply_callback_ctx);",
694 "%s" % self.get_op_func_decl(),
699 " return VAPI_EINVAL;",
701 " if (vapi_is_nonblocking(ctx) && vapi_requests_full(ctx)) {",
702 " return VAPI_EAGAIN;",
705 " if (VAPI_OK != (rv = vapi_producer_lock (ctx))) {",
708 " u32 req_context = vapi_gen_req_context(ctx);",
709 " msg->header.context = req_context;",
710 " %s(msg);" % self.get_swap_to_be_func_name(),
712 " if (VAPI_OK == (rv = vapi_send_with_control_ping "
713 "(ctx, msg, req_context))) {"
714 if (self.reply_is_stream and not self.has_stream_msg)
715 else " if (VAPI_OK == (rv = vapi_send (ctx, msg))) {"
718 + store_request_lines
720 " if (VAPI_OK != vapi_producer_unlock (ctx)) {",
721 " abort (); /* this really shouldn't happen */",
723 " if (vapi_is_nonblocking(ctx)) {",
726 " rv = vapi_dispatch(ctx);",
729 " %s(msg);" % self.get_swap_to_host_func_name(),
730 " if (VAPI_OK != vapi_producer_unlock (ctx)) {",
731 " abort (); /* this really shouldn't happen */",
740 def get_event_cb_func_decl(self):
741 if not self.is_reply and not self.is_event:
742 raise Exception("Cannot register event callback for non-reply message")
743 if self.has_payload():
746 "void vapi_set_%s_event_cb (" % self.get_c_name(),
747 " struct vapi_ctx_s *ctx, ",
749 " vapi_error_e (*callback)(struct vapi_ctx_s *ctx, "
750 "void *callback_ctx, %s *payload),"
751 % self.get_payload_struct_name()
753 " void *callback_ctx)",
759 "void vapi_set_%s_event_cb (" % self.get_c_name(),
760 " struct vapi_ctx_s *ctx, ",
761 " vapi_error_e (*callback)(struct vapi_ctx_s *ctx, "
762 "void *callback_ctx),",
763 " void *callback_ctx)",
767 def get_event_cb_func_def(self):
768 if not self.is_reply and not self.is_event:
769 raise Exception("Cannot register event callback for non-reply function")
772 "%s" % self.get_event_cb_func_decl(),
775 " vapi_set_event_cb(ctx, %s, (vapi_event_cb)callback, "
776 "callback_ctx);" % self.get_msg_id_name()
782 def get_c_metadata_struct_name(self):
783 return "__vapi_metadata_%s" % self.name
785 def get_c_constructor(self):
787 if self.header is not None:
788 has_context = self.header.has_field("context")
791 "static void __attribute__((constructor)) __vapi_constructor_%s()"
794 ' static const char name[] = "%s";' % self.name,
795 ' static const char name_with_crc[] = "%s_%s";'
796 % (self.name, self.crc[2:]),
797 " static vapi_message_desc_t %s = {"
798 % self.get_c_metadata_struct_name(),
800 " sizeof(name) - 1,",
802 " sizeof(name_with_crc) - 1,",
803 " true," if has_context else " false,",
805 " offsetof(%s, context)," % self.header.get_c_name()
810 (" offsetof(%s, payload)," % self.get_c_name())
811 if self.has_payload()
812 else " VAPI_INVALID_MSG_ID,"
814 " (verify_msg_size_fn_t)%s," % self.get_verify_msg_size_func_name(),
815 " (generic_swap_fn_t)%s," % self.get_swap_to_be_func_name(),
816 " (generic_swap_fn_t)%s," % self.get_swap_to_host_func_name(),
817 " VAPI_INVALID_MSG_ID,",
820 " %s = vapi_register_msg(&%s);"
821 % (self.get_msg_id_name(), self.get_c_metadata_struct_name()),
822 ' VAPI_DBG("Assigned msg id %%d to %s", %s);'
823 % (self.name, self.get_msg_id_name()),
829 def emit_definition(parser, json_file, emitted, o):
832 if o.name in ("msg_header1_t", "msg_header2_t"):
834 if hasattr(o, "depends"):
836 emit_definition(parser, json_file, emitted, x)
837 if hasattr(o, "reply"):
838 emit_definition(parser, json_file, emitted, o.reply)
839 if hasattr(o, "stream_msg"):
840 emit_definition(parser, json_file, emitted, o.stream_msg)
841 if hasattr(o, "get_c_def"):
843 o not in parser.enums_by_json[json_file]
844 and o not in parser.types_by_json[json_file]
845 and o not in parser.unions_by_json[json_file]
846 and o.name not in parser.messages_by_json[json_file]
847 and o not in parser.aliases_by_json[json_file]
850 guard = "defined_%s" % o.get_c_name()
851 print("#ifndef %s" % guard)
852 print("#define %s" % guard)
853 print("%s" % o.get_c_def())
855 function_attrs = "static inline "
856 if o.name in parser.messages_by_json[json_file]:
858 print("%s%s" % (function_attrs, o.get_swap_payload_to_be_func_def()))
860 print("%s%s" % (function_attrs, o.get_swap_payload_to_host_func_def()))
862 print("%s%s" % (function_attrs, o.get_swap_to_be_func_def()))
864 print("%s%s" % (function_attrs, o.get_swap_to_host_func_def()))
866 print("%s%s" % (function_attrs, o.get_calc_msg_size_func_def()))
868 print("%s%s" % (function_attrs, o.get_verify_msg_size_func_def()))
869 if not o.is_reply and not o.is_event and not o.is_stream:
871 print("%s%s" % (function_attrs, o.get_alloc_func_def()))
873 print("%s%s" % (function_attrs, o.get_op_func_def()))
875 print("%s" % o.get_c_constructor())
876 if (o.is_reply or o.is_event) and not o.is_stream:
878 print("%s%s;" % (function_attrs, o.get_event_cb_func_def()))
879 elif hasattr(o, "get_swap_to_be_func_def"):
880 print("%s%s" % (function_attrs, o.get_swap_to_be_func_def()))
882 print("%s%s" % (function_attrs, o.get_swap_to_host_func_def()))
888 def gen_json_unified_header(parser, logger, j, io, name):
889 d, f = os.path.split(j)
890 logger.info("Generating header `%s'" % name)
891 orig_stdout = sys.stdout
893 include_guard = "__included_%s" % (
900 print("#ifndef %s" % include_guard)
901 print("#define %s" % include_guard)
903 print("#include <stdlib.h>")
904 print("#include <stddef.h>")
905 print("#include <arpa/inet.h>")
906 print("#include <vapi/vapi_internal.h>")
907 print("#include <vapi/vapi.h>")
908 print("#include <vapi/vapi_dbg.h>")
910 print("#ifdef __cplusplus")
911 print('extern "C" {')
914 print("#ifndef __vl_api_string_swap_fns_defined__")
915 print("#define __vl_api_string_swap_fns_defined__")
917 print("#include <vlibapi/api_types.h>")
919 function_attrs = "static inline "
920 o = parser.types["vl_api_string_t"]
921 print("%s%s" % (function_attrs, o.get_swap_to_be_func_def()))
923 print("%s%s" % (function_attrs, o.get_swap_to_host_func_def()))
925 print("#endif //__vl_api_string_swap_fns_defined__")
927 if name == "memclnt.api.vapi.h":
930 "static inline vapi_error_e vapi_send_with_control_ping "
931 "(vapi_ctx_t ctx, void * msg, u32 context);"
933 elif name == "vlib.api.vapi.h":
934 print("#include <vapi/memclnt.api.vapi.h>")
936 print("#include <vapi/vlib.api.vapi.h>")
938 for m in parser.messages_by_json[j].values():
939 print("extern vapi_msg_id_t %s;" % m.get_msg_id_name())
942 "#define DEFINE_VAPI_MSG_IDS_%s\\"
943 % f.replace(".", "_").replace("/", "_").replace("-", "_").upper()
948 " vapi_msg_id_t %s;" % m.get_msg_id_name()
949 for m in parser.messages_by_json[j].values()
956 for e in parser.enums_by_json[j]:
957 emit_definition(parser, j, emitted, e)
958 for u in parser.unions_by_json[j]:
959 emit_definition(parser, j, emitted, u)
960 for t in parser.types_by_json[j]:
961 emit_definition(parser, j, emitted, t)
962 for a in parser.aliases_by_json[j]:
963 emit_definition(parser, j, emitted, a)
964 for m in parser.messages_by_json[j].values():
965 emit_definition(parser, j, emitted, m)
969 if name == "vlib.api.vapi.h":
970 vapi_send_with_control_ping_function = """
971 static inline vapi_error_e
972 vapi_send_with_control_ping (vapi_ctx_t ctx, void *msg, u32 context)
974 vapi_msg_control_ping *ping = vapi_alloc_control_ping (ctx);
979 ping->header.context = context;
980 vapi_msg_control_ping_hton (ping);
981 return vapi_send2 (ctx, msg, ping);
984 print("%s" % vapi_send_with_control_ping_function)
987 print("#ifdef __cplusplus")
992 sys.stdout = orig_stdout
995 def json_to_c_header_name(json_name):
996 if json_name.endswith(".json"):
997 return "%s.vapi.h" % os.path.splitext(json_name)[0]
998 raise Exception("Unexpected json name `%s'!" % json_name)
1001 def gen_c_unified_headers(parser, logger, prefix, remove_path):
1002 if prefix == "" or prefix is None:
1005 prefix = "%s/" % prefix
1006 for j in parser.json_files:
1008 d, f = os.path.split(j)
1011 with open("%s%s" % (prefix, json_to_c_header_name(f)), "w") as io:
1012 gen_json_unified_header(parser, logger, j, io, json_to_c_header_name(f))
1015 if __name__ == "__main__":
1017 verbose = int(os.getenv("V", 0))
1028 logging.basicConfig(stream=sys.stdout, level=log_level)
1029 logger = logging.getLogger("VAPI C GEN")
1030 logger.setLevel(log_level)
1032 argparser = argparse.ArgumentParser(description="VPP C API generator")
1033 argparser.add_argument(
1038 help="json api file" "(may be specified multiple times)",
1040 argparser.add_argument("--prefix", action="store", default=None, help="path prefix")
1041 argparser.add_argument(
1042 "--remove-path", action="store_true", help="remove path from filename"
1044 args = argparser.parse_args()
1046 jsonparser = JsonParser(
1049 simple_type_class=CSimpleType,
1052 struct_type_class=CStructType,
1054 message_class=CMessage,
1058 # not using the model of having separate generated header and code files
1059 # with generated symbols present in shared library (per discussion with
1060 # Damjan), to avoid symbol version issues in .so
1061 # gen_c_headers_and_code(jsonparser, logger, args.prefix)
1063 gen_c_unified_headers(jsonparser, logger, args.prefix, args.remove_path)
1065 for e in jsonparser.exceptions: