8 from vapi_json_parser import (
23 return "vapi_type_%s" % self.name
26 if self.type.get_c_name() == "vl_api_string_t":
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_field_length_name(self, path):
89 return "%s_%s_array_size" % ("_".join(path), self.name)
91 def get_alloc_vla_param_names(self, path):
93 result = [self.get_vla_field_length_name(path)]
96 if self.type.has_vla():
97 t = self.type.get_alloc_vla_param_names(path + [self.name])
101 def get_vla_calc_size_code(self, prefix, path):
104 "sizeof(%s.%s[0]) * %s"
106 ".".join([prefix] + path),
108 self.get_vla_field_length_name(path),
113 if self.type.has_vla():
114 t = self.type.get_vla_calc_size_code(prefix, path + [self.name])
118 def get_vla_assign_code(self, prefix, path):
124 ".".join([prefix] + path),
125 self.nelem_field.name,
126 self.get_vla_field_length_name(path),
129 if self.type.has_vla():
130 t = self.type.get_vla_assign_code(prefix, path + [self.name])
135 class CAlias(CField):
136 def get_c_name(self):
137 return "vapi_type_%s" % self.name
140 if self.len is not None:
141 return "typedef %s vapi_type_%s[%d];" % (
142 self.type.get_c_name(),
147 return "typedef %s vapi_type_%s;" % (self.type.get_c_name(), self.name)
150 class CStruct(Struct):
154 "typedef struct __attribute__((__packed__)) {\n%s"
155 % ("\n".join([" %s" % x.get_c_def() for x in self.fields])),
156 "} %s;" % self.get_c_name(),
160 def get_vla_assign_code(self, prefix, path):
165 for x in f.get_vla_assign_code(prefix, path)
168 def get_alloc_vla_param_names(self, path):
173 for x in f.get_alloc_vla_param_names(path)
176 def get_vla_calc_size_code(self, prefix, path):
181 for x in f.get_vla_calc_size_code(prefix, path)
185 class CSimpleType(SimpleType):
195 swap_to_host_dict = {
204 __packed = "__attribute__((packed))"
212 def get_c_name(self):
215 def get_swap_to_be_func_name(self):
216 return self.swap_to_be_dict[self.name]
218 def get_swap_to_host_func_name(self):
219 return self.swap_to_host_dict[self.name]
221 def get_packed_string(self):
222 return self.pack_dict[self.name]
224 def get_swap_to_be_code(self, struct, var, cast=None):
225 x = "%s%s" % (struct, var)
226 return "%s = %s%s(%s);" % (
228 "(%s)" % cast if cast else "",
229 self.get_swap_to_be_func_name(),
233 def get_swap_to_host_code(self, struct, var, cast=None):
234 x = "%s%s" % (struct, var)
235 return "%s = %s%s(%s);" % (
237 "(%s)" % cast if cast else "",
238 self.get_swap_to_host_func_name(),
242 def needs_byte_swap(self):
244 self.get_swap_to_host_func_name()
250 def get_packed(self):
251 return self.pack_dict.get(self.name, "")
255 def get_c_name(self):
256 return "vapi_enum_%s" % self.name
259 return "typedef enum {\n%s\n} %s %s;" % (
260 "\n".join([" %s = %s," % (i, j) for i, j in self.value_pairs]),
261 self.type.get_packed(),
265 def needs_byte_swap(self):
266 return self.type.needs_byte_swap()
268 def get_swap_to_be_code(self, struct, var):
269 return self.type.get_swap_to_be_code(struct, var, self.get_c_name())
271 def get_swap_to_host_code(self, struct, var):
272 return self.type.get_swap_to_host_code(struct, var, self.get_c_name())
276 def get_c_name(self):
277 return "vapi_union_%s" % self.name
280 return "typedef union {\n%s\n} %s;" % (
281 "\n".join([" %s %s;" % (i.get_c_name(), j) for i, j in self.type_pairs]),
285 def needs_byte_swap(self):
289 class CStructType(StructType, CStruct):
290 def get_c_name(self):
291 return "vapi_type_%s" % self.name
293 def get_swap_to_be_func_name(self):
294 return "%s_hton" % self.get_c_name()
296 def get_swap_to_host_func_name(self):
297 return "%s_ntoh" % self.get_c_name()
299 def get_swap_to_be_func_decl(self):
300 return "void %s(%s *msg)" % (self.get_swap_to_be_func_name(), self.get_c_name())
302 def get_swap_to_be_func_def(self):
303 return "%s\n{\n%s\n}" % (
304 self.get_swap_to_be_func_decl(),
307 " %s" % p.get_swap_to_be_code("msg->", "%s" % p.name)
309 if p.needs_byte_swap()
314 def get_swap_to_host_func_decl(self):
315 return "void %s(%s *msg)" % (
316 self.get_swap_to_host_func_name(),
320 def get_swap_to_host_func_def(self):
321 return "%s\n{\n%s\n}" % (
322 self.get_swap_to_host_func_decl(),
325 " %s" % p.get_swap_to_host_code("msg->", "%s" % p.name)
327 if p.needs_byte_swap()
332 def get_swap_to_be_code(self, struct, var):
333 return "%s(&%s%s);" % (self.get_swap_to_be_func_name(), struct, var)
335 def get_swap_to_host_code(self, struct, var):
336 return "%s(&%s%s);" % (self.get_swap_to_host_func_name(), struct, var)
338 def needs_byte_swap(self):
339 for f in self.fields:
340 if f.needs_byte_swap():
345 class CMessage(Message):
346 def __init__(self, logger, definition, json_parser):
347 super(CMessage, self).__init__(logger, definition, json_parser)
348 self.payload_members = [
349 " %s" % p.get_c_def() for p in self.fields if p.type != self.header
352 def has_payload(self):
353 return len(self.payload_members) > 0
355 def get_msg_id_name(self):
356 return "vapi_msg_id_%s" % self.name
358 def get_c_name(self):
359 return "vapi_msg_%s" % self.name
361 def get_payload_struct_name(self):
362 return "vapi_payload_%s" % self.name
364 def get_alloc_func_name(self):
365 return "vapi_alloc_%s" % self.name
367 def get_alloc_vla_param_names(self):
372 for x in f.get_alloc_vla_param_names([])
375 def get_alloc_func_decl(self):
376 return "%s* %s(struct vapi_ctx_s *ctx%s)" % (
378 self.get_alloc_func_name(),
379 "".join([", size_t %s" % n for n in self.get_alloc_vla_param_names()]),
382 def get_alloc_func_def(self):
384 if self.header.has_field("client_index"):
385 extra.append(" msg->header.client_index = vapi_get_client_index(ctx);")
386 if self.header.has_field("context"):
387 extra.append(" msg->header.context = 0;")
390 "%s" % self.get_alloc_func_decl(),
392 " %s *msg = NULL;" % self.get_c_name(),
393 " const size_t size = sizeof(%s)%s;"
401 for x in f.get_vla_calc_size_code("msg->payload", [])
405 " /* cast here required to play nicely with C++ world ... */",
406 " msg = (%s*)vapi_msg_alloc(ctx, size);" % self.get_c_name(),
413 " msg->header._vl_msg_id = vapi_lookup_vl_msg_id(ctx, %s);"
414 % self.get_msg_id_name(),
420 for line in f.get_vla_assign_code("msg->payload", [])
428 def get_calc_msg_size_func_name(self):
429 return "vapi_calc_%s_msg_size" % self.name
431 def get_calc_msg_size_func_decl(self):
432 return "uword %s(%s *msg)" % (
433 self.get_calc_msg_size_func_name(),
437 def get_calc_msg_size_func_def(self):
440 "%s" % self.get_calc_msg_size_func_decl(),
442 " return sizeof(*msg)%s;"
445 "+ msg->payload.%s * sizeof(msg->payload.%s[0])"
446 % (f.nelem_field.name, f.name)
448 if f.nelem_field is not None
455 def get_verify_msg_size_func_name(self):
456 return f"vapi_verify_{self.name}_msg_size"
458 def get_verify_msg_size_func_decl(self):
459 return "int %s(%s *msg, uword buf_size)" % (
460 self.get_verify_msg_size_func_name(),
464 def get_verify_msg_size_func_def(self):
465 return inspect.cleandoc(
467 {self.get_verify_msg_size_func_decl()}
469 if (sizeof({self.get_c_name()}) > buf_size)
471 VAPI_ERR("Truncated '{self.name}' msg received, received %lu"
472 "bytes, expected %lu bytes.", buf_size,
473 sizeof({self.get_c_name()}));
476 if ({self.get_calc_msg_size_func_name()}(msg) > buf_size)
478 VAPI_ERR("Truncated '{self.name}' msg received, received %lu"
479 "bytes, expected %lu bytes.", buf_size,
480 {self.get_calc_msg_size_func_name()}(msg));
489 if self.has_payload():
492 "typedef struct __attribute__ ((__packed__)) {",
493 "%s " % "\n".join(self.payload_members),
494 "} %s;" % self.get_payload_struct_name(),
496 "typedef struct __attribute__ ((__packed__)) {",
498 " %s %s;" % (self.header.get_c_name(), self.fields[0].name)
499 if self.header is not None
502 " %s payload;" % self.get_payload_struct_name(),
503 "} %s;" % self.get_c_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;" % self.get_c_name(),
519 def get_swap_payload_to_host_func_name(self):
520 return "%s_payload_ntoh" % self.get_c_name()
522 def get_swap_payload_to_be_func_name(self):
523 return "%s_payload_hton" % self.get_c_name()
525 def get_swap_payload_to_host_func_decl(self):
526 return "void %s(%s *payload)" % (
527 self.get_swap_payload_to_host_func_name(),
528 self.get_payload_struct_name(),
531 def get_swap_payload_to_be_func_decl(self):
532 return "void %s(%s *payload)" % (
533 self.get_swap_payload_to_be_func_name(),
534 self.get_payload_struct_name(),
537 def get_swap_payload_to_be_func_def(self):
538 return "%s\n{\n%s\n}" % (
539 self.get_swap_payload_to_be_func_decl(),
542 " %s" % p.get_swap_to_be_code("payload->", "%s" % p.name)
544 if p.needs_byte_swap() and p.type != self.header
549 def get_swap_payload_to_host_func_def(self):
550 return "%s\n{\n%s\n}" % (
551 self.get_swap_payload_to_host_func_decl(),
554 " %s" % p.get_swap_to_host_code("payload->", "%s" % p.name)
556 if p.needs_byte_swap() and p.type != self.header
561 def get_swap_to_host_func_name(self):
562 return "%s_ntoh" % self.get_c_name()
564 def get_swap_to_be_func_name(self):
565 return "%s_hton" % self.get_c_name()
567 def get_swap_to_host_func_decl(self):
568 return "void %s(%s *msg)" % (
569 self.get_swap_to_host_func_name(),
573 def get_swap_to_be_func_decl(self):
574 return "void %s(%s *msg)" % (self.get_swap_to_be_func_name(), self.get_c_name())
576 def get_swap_to_be_func_def(self):
579 "%s" % self.get_swap_to_be_func_decl(),
582 ' VAPI_DBG("Swapping `%s\'@%%p to big endian", msg);'
585 " %s(&msg->header);" % self.header.get_swap_to_be_func_name()
586 if self.header is not None
588 " %s(&msg->payload);" % self.get_swap_payload_to_be_func_name()
589 if self.has_payload()
595 def get_swap_to_host_func_def(self):
598 "%s" % self.get_swap_to_host_func_decl(),
601 ' VAPI_DBG("Swapping `%s\'@%%p to host byte order", msg);'
604 " %s(&msg->header);" % self.header.get_swap_to_host_func_name()
605 if self.header is not None
607 " %s(&msg->payload);" % self.get_swap_payload_to_host_func_name()
608 if self.has_payload()
614 def get_op_func_name(self):
615 return "vapi_%s" % self.name
617 def get_op_func_decl(self):
618 stream_param_lines = []
619 if self.has_stream_msg:
620 stream_param_lines = [
621 "vapi_error_e (*details_callback)(struct vapi_ctx_s *ctx",
622 " void *callback_ctx",
626 % self.stream_msg.get_payload_struct_name(),
627 "void *details_callback_ctx",
630 return "vapi_error_e %s(%s)" % (
631 self.get_op_func_name(),
634 "struct vapi_ctx_s *ctx",
635 "%s *msg" % self.get_c_name(),
636 "vapi_error_e (*reply_callback)(struct vapi_ctx_s *ctx",
637 " void *callback_ctx",
641 % self.reply.get_payload_struct_name(),
644 "void *reply_callback_ctx",
650 def get_op_func_def(self):
651 param_check_lines = [" if (!msg || !reply_callback) {"]
652 store_request_lines = [
653 " vapi_store_request(ctx, req_context, %s, %s, "
655 self.reply.get_msg_id_name(),
656 "VAPI_REQUEST_DUMP" if self.reply_is_stream else "VAPI_REQUEST_REG",
658 " (vapi_cb_t)reply_callback, reply_callback_ctx);",
660 if self.has_stream_msg:
661 param_check_lines = [
662 " if (!msg || !reply_callback || !details_callback) {"
664 store_request_lines = [
665 f" vapi_store_request(ctx, req_context, {self.stream_msg.get_msg_id_name()}, VAPI_REQUEST_STREAM, ",
666 " (vapi_cb_t)details_callback, details_callback_ctx);",
667 f" vapi_store_request(ctx, req_context, {self.reply.get_msg_id_name()}, VAPI_REQUEST_REG, ",
668 " (vapi_cb_t)reply_callback, reply_callback_ctx);",
673 "%s" % self.get_op_func_decl(),
678 " return VAPI_EINVAL;",
680 " if (vapi_is_nonblocking(ctx) && vapi_requests_full(ctx)) {",
681 " return VAPI_EAGAIN;",
684 " if (VAPI_OK != (rv = vapi_producer_lock (ctx))) {",
687 " u32 req_context = vapi_gen_req_context(ctx);",
688 " msg->header.context = req_context;",
689 " %s(msg);" % self.get_swap_to_be_func_name(),
691 " if (VAPI_OK == (rv = vapi_send_with_control_ping "
692 "(ctx, msg, req_context))) {"
693 if (self.reply_is_stream and not self.has_stream_msg)
694 else " if (VAPI_OK == (rv = vapi_send (ctx, msg))) {"
697 + store_request_lines
699 " if (VAPI_OK != vapi_producer_unlock (ctx)) {",
700 " abort (); /* this really shouldn't happen */",
702 " if (vapi_is_nonblocking(ctx)) {",
705 " rv = vapi_dispatch(ctx);",
708 " %s(msg);" % self.get_swap_to_host_func_name(),
709 " if (VAPI_OK != vapi_producer_unlock (ctx)) {",
710 " abort (); /* this really shouldn't happen */",
719 def get_event_cb_func_decl(self):
720 if not self.is_reply and not self.is_event:
721 raise Exception("Cannot register event callback for non-reply message")
722 if self.has_payload():
725 "void vapi_set_%s_event_cb (" % self.get_c_name(),
726 " struct vapi_ctx_s *ctx, ",
728 " vapi_error_e (*callback)(struct vapi_ctx_s *ctx, "
729 "void *callback_ctx, %s *payload),"
730 % self.get_payload_struct_name()
732 " void *callback_ctx)",
738 "void vapi_set_%s_event_cb (" % self.get_c_name(),
739 " struct vapi_ctx_s *ctx, ",
740 " vapi_error_e (*callback)(struct vapi_ctx_s *ctx, "
741 "void *callback_ctx),",
742 " void *callback_ctx)",
746 def get_event_cb_func_def(self):
747 if not self.is_reply and not self.is_event:
748 raise Exception("Cannot register event callback for non-reply function")
751 "%s" % self.get_event_cb_func_decl(),
754 " vapi_set_event_cb(ctx, %s, (vapi_event_cb)callback, "
755 "callback_ctx);" % self.get_msg_id_name()
761 def get_c_metadata_struct_name(self):
762 return "__vapi_metadata_%s" % self.name
764 def get_c_constructor(self):
766 if self.header is not None:
767 has_context = self.header.has_field("context")
770 "static void __attribute__((constructor)) __vapi_constructor_%s()"
773 ' static const char name[] = "%s";' % self.name,
774 ' static const char name_with_crc[] = "%s_%s";'
775 % (self.name, self.crc[2:]),
776 " static vapi_message_desc_t %s = {"
777 % self.get_c_metadata_struct_name(),
779 " sizeof(name) - 1,",
781 " sizeof(name_with_crc) - 1,",
782 " true," if has_context else " false,",
783 " offsetof(%s, context)," % self.header.get_c_name()
786 (" offsetof(%s, payload)," % self.get_c_name())
787 if self.has_payload()
788 else " VAPI_INVALID_MSG_ID,",
789 " (verify_msg_size_fn_t)%s," % self.get_verify_msg_size_func_name(),
790 " (generic_swap_fn_t)%s," % self.get_swap_to_be_func_name(),
791 " (generic_swap_fn_t)%s," % self.get_swap_to_host_func_name(),
792 " VAPI_INVALID_MSG_ID,",
795 " %s = vapi_register_msg(&%s);"
796 % (self.get_msg_id_name(), self.get_c_metadata_struct_name()),
797 ' VAPI_DBG("Assigned msg id %%d to %s", %s);'
798 % (self.name, self.get_msg_id_name()),
804 def emit_definition(parser, json_file, emitted, o):
807 if o.name in ("msg_header1_t", "msg_header2_t"):
809 if hasattr(o, "depends"):
811 emit_definition(parser, json_file, emitted, x)
812 if hasattr(o, "reply"):
813 emit_definition(parser, json_file, emitted, o.reply)
814 if hasattr(o, "stream_msg"):
815 emit_definition(parser, json_file, emitted, o.stream_msg)
816 if hasattr(o, "get_c_def"):
818 o not in parser.enums_by_json[json_file]
819 and o not in parser.types_by_json[json_file]
820 and o not in parser.unions_by_json[json_file]
821 and o.name not in parser.messages_by_json[json_file]
822 and o not in parser.aliases_by_json[json_file]
825 guard = "defined_%s" % o.get_c_name()
826 print("#ifndef %s" % guard)
827 print("#define %s" % guard)
828 print("%s" % o.get_c_def())
830 function_attrs = "static inline "
831 if o.name in parser.messages_by_json[json_file]:
833 print("%s%s" % (function_attrs, o.get_swap_payload_to_be_func_def()))
835 print("%s%s" % (function_attrs, o.get_swap_payload_to_host_func_def()))
837 print("%s%s" % (function_attrs, o.get_swap_to_be_func_def()))
839 print("%s%s" % (function_attrs, o.get_swap_to_host_func_def()))
841 print("%s%s" % (function_attrs, o.get_calc_msg_size_func_def()))
843 print("%s%s" % (function_attrs, o.get_verify_msg_size_func_def()))
844 if not o.is_reply and not o.is_event and not o.is_stream:
846 print("%s%s" % (function_attrs, o.get_alloc_func_def()))
848 print("%s%s" % (function_attrs, o.get_op_func_def()))
850 print("%s" % o.get_c_constructor())
851 if (o.is_reply or o.is_event) and not o.is_stream:
853 print("%s%s;" % (function_attrs, o.get_event_cb_func_def()))
854 elif hasattr(o, "get_swap_to_be_func_def"):
855 print("%s%s" % (function_attrs, o.get_swap_to_be_func_def()))
857 print("%s%s" % (function_attrs, o.get_swap_to_host_func_def()))
863 def gen_json_unified_header(parser, logger, j, io, name):
864 d, f = os.path.split(j)
865 logger.info("Generating header `%s'" % name)
866 orig_stdout = sys.stdout
868 include_guard = "__included_%s" % (
875 print("#ifndef %s" % include_guard)
876 print("#define %s" % include_guard)
878 print("#include <stdlib.h>")
879 print("#include <stddef.h>")
880 print("#include <arpa/inet.h>")
881 print("#include <vapi/vapi_internal.h>")
882 print("#include <vapi/vapi.h>")
883 print("#include <vapi/vapi_dbg.h>")
885 print("#ifdef __cplusplus")
886 print('extern "C" {')
888 if name == "memclnt.api.vapi.h":
891 "static inline vapi_error_e vapi_send_with_control_ping "
892 "(vapi_ctx_t ctx, void * msg, u32 context);"
894 elif name == "vlib.api.vapi.h":
895 print("#include <vapi/memclnt.api.vapi.h>")
897 print("#include <vapi/vlib.api.vapi.h>")
899 for m in parser.messages_by_json[j].values():
900 print("extern vapi_msg_id_t %s;" % m.get_msg_id_name())
903 "#define DEFINE_VAPI_MSG_IDS_%s\\"
904 % f.replace(".", "_").replace("/", "_").replace("-", "_").upper()
909 " vapi_msg_id_t %s;" % m.get_msg_id_name()
910 for m in parser.messages_by_json[j].values()
917 for e in parser.enums_by_json[j]:
918 emit_definition(parser, j, emitted, e)
919 for u in parser.unions_by_json[j]:
920 emit_definition(parser, j, emitted, u)
921 for t in parser.types_by_json[j]:
922 emit_definition(parser, j, emitted, t)
923 for a in parser.aliases_by_json[j]:
924 emit_definition(parser, j, emitted, a)
925 for m in parser.messages_by_json[j].values():
926 emit_definition(parser, j, emitted, m)
930 if name == "vlib.api.vapi.h":
931 vapi_send_with_control_ping_function = """
932 static inline vapi_error_e
933 vapi_send_with_control_ping (vapi_ctx_t ctx, void *msg, u32 context)
935 vapi_msg_control_ping *ping = vapi_alloc_control_ping (ctx);
940 ping->header.context = context;
941 vapi_msg_control_ping_hton (ping);
942 return vapi_send2 (ctx, msg, ping);
945 print("%s" % vapi_send_with_control_ping_function)
948 print("#ifdef __cplusplus")
953 sys.stdout = orig_stdout
956 def json_to_c_header_name(json_name):
957 if json_name.endswith(".json"):
958 return "%s.vapi.h" % os.path.splitext(json_name)[0]
959 raise Exception("Unexpected json name `%s'!" % json_name)
962 def gen_c_unified_headers(parser, logger, prefix, remove_path):
963 if prefix == "" or prefix is None:
966 prefix = "%s/" % prefix
967 for j in parser.json_files:
969 d, f = os.path.split(j)
972 with open("%s%s" % (prefix, json_to_c_header_name(f)), "w") as io:
973 gen_json_unified_header(parser, logger, j, io, json_to_c_header_name(f))
976 if __name__ == "__main__":
978 verbose = int(os.getenv("V", 0))
989 logging.basicConfig(stream=sys.stdout, level=log_level)
990 logger = logging.getLogger("VAPI C GEN")
991 logger.setLevel(log_level)
993 argparser = argparse.ArgumentParser(description="VPP C API generator")
994 argparser.add_argument(
999 help="json api file" "(may be specified multiple times)",
1001 argparser.add_argument("--prefix", action="store", default=None, help="path prefix")
1002 argparser.add_argument(
1003 "--remove-path", action="store_true", help="remove path from filename"
1005 args = argparser.parse_args()
1007 jsonparser = JsonParser(
1010 simple_type_class=CSimpleType,
1013 struct_type_class=CStructType,
1015 message_class=CMessage,
1019 # not using the model of having separate generated header and code files
1020 # with generated symbols present in shared library (per discussion with
1021 # Damjan), to avoid symbol version issues in .so
1022 # gen_c_headers_and_code(jsonparser, logger, args.prefix)
1024 gen_c_unified_headers(jsonparser, logger, args.prefix, args.remove_path)
1026 for e in jsonparser.exceptions: