8 from vapi_json_parser import Field, Struct, Enum, Union, Message, JsonParser,\
9 SimpleType, StructType, Alias
14 return "vapi_type_%s" % self.name
17 if self.type.get_c_name() == 'vl_api_string_t':
19 return "u8 %s[%d];" % (self.name, self.len)
21 return "vl_api_string_t %s;" % (self.name)
23 if self.len is not None and type(self.len) != dict:
24 return "%s %s[%d];" % (self.type.get_c_name(), self.name,
27 return "%s %s;" % (self.type.get_c_name(), self.name)
29 def get_swap_to_be_code(self, struct, var):
30 if self.len is not None and type(self.len) != dict:
32 return "do { unsigned i; for (i = 0; i < %d; ++i) { %s } }"\
35 self.type.get_swap_to_be_code(struct, "%s[i]" % var))
37 if self.nelem_field.needs_byte_swap():
38 nelem_field = "%s(%s%s)" % (
39 self.nelem_field.type.get_swap_to_host_func_name(),
40 struct, self.nelem_field.name)
42 nelem_field = "%s%s" % (struct, self.nelem_field.name)
44 "do { unsigned i; for (i = 0; i < %s; ++i) { %s } }"
46 (nelem_field, self.type.get_swap_to_be_code(
47 struct, "%s[i]" % var)))
48 return self.type.get_swap_to_be_code(struct, "%s" % var)
50 def get_swap_to_host_code(self, struct, var):
51 if self.len is not None and type(self.len) != dict:
53 return "do { unsigned i; for (i = 0; i < %d; ++i) { %s } }"\
56 self.type.get_swap_to_host_code(struct, "%s[i]" % var))
58 # nelem_field already swapped to host here...
60 "do { unsigned i; for (i = 0; i < %s%s; ++i) { %s } }"
62 (struct, self.nelem_field.name,
63 self.type.get_swap_to_host_code(
64 struct, "%s[i]" % var)))
65 return self.type.get_swap_to_host_code(struct, "%s" % var)
67 def needs_byte_swap(self):
68 return self.type.needs_byte_swap()
70 def get_vla_field_length_name(self, path):
71 return "%s_%s_array_size" % ("_".join(path), self.name)
73 def get_alloc_vla_param_names(self, path):
75 result = [self.get_vla_field_length_name(path)]
78 if self.type.has_vla():
79 t = self.type.get_alloc_vla_param_names(path + [self.name])
83 def get_vla_calc_size_code(self, prefix, path):
85 result = ["sizeof(%s.%s[0]) * %s" % (
86 ".".join([prefix] + path),
88 self.get_vla_field_length_name(path))]
91 if self.type.has_vla():
92 t = self.type.get_vla_calc_size_code(prefix, path + [self.name])
96 def get_vla_assign_code(self, prefix, path):
99 result.append("%s.%s = %s" % (
100 ".".join([prefix] + path),
101 self.nelem_field.name,
102 self.get_vla_field_length_name(path)))
103 if self.type.has_vla():
104 t = self.type.get_vla_assign_code(prefix, path + [self.name])
109 class CAlias(CField):
110 def get_c_name(self):
111 return "vapi_type_%s" % self.name
114 if self.len is not None:
115 return "typedef %s vapi_type_%s[%d];" % (
116 self.type.get_c_name(), self.name, self.len)
118 return "typedef %s vapi_type_%s;" % (
119 self.type.get_c_name(), self.name)
122 class CStruct(Struct):
125 "typedef struct __attribute__((__packed__)) {\n%s" % (
126 "\n".join([" %s" % x.get_c_def()
127 for x in self.fields])),
128 "} %s;" % self.get_c_name()])
130 def get_vla_assign_code(self, prefix, path):
131 return [x for f in self.fields if f.has_vla()
132 for x in f.get_vla_assign_code(prefix, path)]
134 def get_alloc_vla_param_names(self, path):
135 return [x for f in self.fields
137 for x in f.get_alloc_vla_param_names(path)]
139 def get_vla_calc_size_code(self, prefix, path):
140 return [x for f in self.fields if f.has_vla()
141 for x in f.get_vla_calc_size_code(prefix, path)]
144 class CSimpleType (SimpleType):
147 'i16': 'htobe16', 'u16': 'htobe16',
148 'i32': 'htobe32', 'u32': 'htobe32',
149 'i64': 'htobe64', 'u64': 'htobe64',
152 swap_to_host_dict = {
153 'i16': 'be16toh', 'u16': 'be16toh',
154 'i32': 'be32toh', 'u32': 'be32toh',
155 'i64': 'be64toh', 'u64': 'be64toh',
158 __packed = "__attribute__((packed))"
160 'i8': __packed, 'u8': __packed,
161 'i16': __packed, 'u16': __packed,
164 def get_c_name(self):
167 def get_swap_to_be_func_name(self):
168 return self.swap_to_be_dict[self.name]
170 def get_swap_to_host_func_name(self):
171 return self.swap_to_host_dict[self.name]
173 def get_packed_string(self):
174 return self.pack_dict[self.name]
176 def get_swap_to_be_code(self, struct, var, cast=None):
177 x = "%s%s" % (struct, var)
178 return "%s = %s%s(%s);" % (x,
179 "(%s)" % cast if cast else "",
180 self.get_swap_to_be_func_name(), x)
182 def get_swap_to_host_code(self, struct, var, cast=None):
183 x = "%s%s" % (struct, var)
184 return "%s = %s%s(%s);" % (x,
185 "(%s)" % cast if cast else "",
186 self.get_swap_to_host_func_name(), x)
188 def needs_byte_swap(self):
190 self.get_swap_to_host_func_name()
196 def get_packed(self):
197 return self.pack_dict.get(self.name, "")
201 def get_c_name(self):
202 return "vapi_enum_%s" % self.name
205 return "typedef enum {\n%s\n} %s %s;" % (
206 "\n".join([" %s = %s," % (i, j) for i, j in self.value_pairs]),
207 self.type.get_packed(),
211 def needs_byte_swap(self):
212 return self.type.needs_byte_swap()
214 def get_swap_to_be_code(self, struct, var):
215 return self.type.get_swap_to_be_code(struct, var, self.get_c_name())
217 def get_swap_to_host_code(self, struct, var):
218 return self.type.get_swap_to_host_code(struct, var, self.get_c_name())
222 def get_c_name(self):
223 return "vapi_union_%s" % self.name
226 return "typedef union {\n%s\n} %s;" % (
227 "\n".join([" %s %s;" % (i.get_c_name(), j)
228 for i, j in self.type_pairs]),
232 def needs_byte_swap(self):
236 class CStructType (StructType, CStruct):
237 def get_c_name(self):
238 return "vapi_type_%s" % self.name
240 def get_swap_to_be_func_name(self):
241 return "%s_hton" % self.get_c_name()
243 def get_swap_to_host_func_name(self):
244 return "%s_ntoh" % self.get_c_name()
246 def get_swap_to_be_func_decl(self):
247 return "void %s(%s *msg)" % (
248 self.get_swap_to_be_func_name(), self.get_c_name())
250 def get_swap_to_be_func_def(self):
251 return "%s\n{\n%s\n}" % (
252 self.get_swap_to_be_func_decl(),
254 " %s" % p.get_swap_to_be_code("msg->", "%s" % p.name)
255 for p in self.fields if p.needs_byte_swap()]),
258 def get_swap_to_host_func_decl(self):
259 return "void %s(%s *msg)" % (
260 self.get_swap_to_host_func_name(), self.get_c_name())
262 def get_swap_to_host_func_def(self):
263 return "%s\n{\n%s\n}" % (
264 self.get_swap_to_host_func_decl(),
266 " %s" % p.get_swap_to_host_code("msg->", "%s" % p.name)
267 for p in self.fields if p.needs_byte_swap()]),
270 def get_swap_to_be_code(self, struct, var):
271 return "%s(&%s%s);" % (self.get_swap_to_be_func_name(), struct, var)
273 def get_swap_to_host_code(self, struct, var):
274 return "%s(&%s%s);" % (self.get_swap_to_host_func_name(), struct, var)
276 def needs_byte_swap(self):
277 for f in self.fields:
278 if f.needs_byte_swap():
283 class CMessage (Message):
284 def __init__(self, logger, definition, json_parser):
285 super(CMessage, self).__init__(logger, definition, json_parser)
286 self.payload_members = [
287 " %s" % p.get_c_def()
289 if p.type != self.header
292 def has_payload(self):
293 return len(self.payload_members) > 0
295 def get_msg_id_name(self):
296 return "vapi_msg_id_%s" % self.name
298 def get_c_name(self):
299 return "vapi_msg_%s" % self.name
301 def get_payload_struct_name(self):
302 return "vapi_payload_%s" % self.name
304 def get_alloc_func_name(self):
305 return "vapi_alloc_%s" % self.name
307 def get_alloc_vla_param_names(self):
308 return [x for f in self.fields
310 for x in f.get_alloc_vla_param_names([])]
312 def get_alloc_func_decl(self):
313 return "%s* %s(struct vapi_ctx_s *ctx%s)" % (
315 self.get_alloc_func_name(),
316 "".join([", size_t %s" % n for n in
317 self.get_alloc_vla_param_names()]))
319 def get_alloc_func_def(self):
321 if self.header.has_field('client_index'):
323 " msg->header.client_index = vapi_get_client_index(ctx);")
324 if self.header.has_field('context'):
325 extra.append(" msg->header.context = 0;")
327 "%s" % self.get_alloc_func_decl(),
329 " %s *msg = NULL;" % self.get_c_name(),
330 " const size_t size = sizeof(%s)%s;" % (
332 "".join([" + %s" % x for f in self.fields if f.has_vla()
333 for x in f.get_vla_calc_size_code("msg->payload",
335 " /* cast here required to play nicely with C++ world ... */",
336 " msg = (%s*)vapi_msg_alloc(ctx, size);" % self.get_c_name(),
341 " msg->header._vl_msg_id = vapi_lookup_vl_msg_id(ctx, %s);" %
342 self.get_msg_id_name(),
343 "".join([" %s;\n" % line
344 for f in self.fields if f.has_vla()
345 for line in f.get_vla_assign_code("msg->payload", [])]),
349 def get_calc_msg_size_func_name(self):
350 return "vapi_calc_%s_msg_size" % self.name
352 def get_calc_msg_size_func_decl(self):
353 return "uword %s(%s *msg)" % (
354 self.get_calc_msg_size_func_name(),
357 def get_calc_msg_size_func_def(self):
359 "%s" % self.get_calc_msg_size_func_decl(),
361 " return sizeof(*msg)%s;" %
362 "".join(["+ msg->payload.%s * sizeof(msg->payload.%s[0])" % (
366 if f.nelem_field is not None
371 def get_verify_msg_size_func_name(self):
372 return f"vapi_verify_{self.name}_msg_size"
374 def get_verify_msg_size_func_decl(self):
375 return "int %s(%s *msg, uword buf_size)" % (
376 self.get_verify_msg_size_func_name(),
379 def get_verify_msg_size_func_def(self):
380 return inspect.cleandoc(
382 {self.get_verify_msg_size_func_decl()}
384 if (sizeof({self.get_c_name()}) > buf_size)
386 VAPI_ERR("Truncated '{self.name}' msg received, received %lu"
387 "bytes, expected %lu bytes.", buf_size,
388 sizeof({self.get_c_name()}));
391 if ({self.get_calc_msg_size_func_name()}(msg) > buf_size)
393 VAPI_ERR("Truncated '{self.name}' msg received, received %lu"
394 "bytes, expected %lu bytes.", buf_size,
395 sizeof({self.get_calc_msg_size_func_name()}));
403 if self.has_payload():
405 "typedef struct __attribute__ ((__packed__)) {",
407 "\n".join(self.payload_members),
408 "} %s;" % self.get_payload_struct_name(),
410 "typedef struct __attribute__ ((__packed__)) {",
411 (" %s %s;" % (self.header.get_c_name(),
413 if self.header is not None else ""),
414 " %s payload;" % self.get_payload_struct_name(),
415 "} %s;" % self.get_c_name(), ])
418 "typedef struct __attribute__ ((__packed__)) {",
419 (" %s %s;" % (self.header.get_c_name(),
421 if self.header is not None else ""),
422 "} %s;" % self.get_c_name(), ])
424 def get_swap_payload_to_host_func_name(self):
425 return "%s_payload_ntoh" % self.get_c_name()
427 def get_swap_payload_to_be_func_name(self):
428 return "%s_payload_hton" % self.get_c_name()
430 def get_swap_payload_to_host_func_decl(self):
431 return "void %s(%s *payload)" % (
432 self.get_swap_payload_to_host_func_name(),
433 self.get_payload_struct_name())
435 def get_swap_payload_to_be_func_decl(self):
436 return "void %s(%s *payload)" % (
437 self.get_swap_payload_to_be_func_name(),
438 self.get_payload_struct_name())
440 def get_swap_payload_to_be_func_def(self):
441 return "%s\n{\n%s\n}" % (
442 self.get_swap_payload_to_be_func_decl(),
444 " %s" % p.get_swap_to_be_code("payload->", "%s" % p.name)
446 if p.needs_byte_swap() and p.type != self.header]),
449 def get_swap_payload_to_host_func_def(self):
450 return "%s\n{\n%s\n}" % (
451 self.get_swap_payload_to_host_func_decl(),
453 " %s" % p.get_swap_to_host_code("payload->", "%s" % p.name)
455 if p.needs_byte_swap() and p.type != self.header]),
458 def get_swap_to_host_func_name(self):
459 return "%s_ntoh" % self.get_c_name()
461 def get_swap_to_be_func_name(self):
462 return "%s_hton" % self.get_c_name()
464 def get_swap_to_host_func_decl(self):
465 return "void %s(%s *msg)" % (
466 self.get_swap_to_host_func_name(), self.get_c_name())
468 def get_swap_to_be_func_decl(self):
469 return "void %s(%s *msg)" % (
470 self.get_swap_to_be_func_name(), self.get_c_name())
472 def get_swap_to_be_func_def(self):
474 "%s" % self.get_swap_to_be_func_decl(),
476 (" VAPI_DBG(\"Swapping `%s'@%%p to big endian\", msg);" %
478 " %s(&msg->header);" % self.header.get_swap_to_be_func_name()
479 if self.header is not None else "",
480 " %s(&msg->payload);" % self.get_swap_payload_to_be_func_name()
481 if self.has_payload() else "",
485 def get_swap_to_host_func_def(self):
487 "%s" % self.get_swap_to_host_func_decl(),
489 (" VAPI_DBG(\"Swapping `%s'@%%p to host byte order\", msg);" %
491 " %s(&msg->header);" % self.header.get_swap_to_host_func_name()
492 if self.header is not None else "",
493 " %s(&msg->payload);" % self.get_swap_payload_to_host_func_name()
494 if self.has_payload() else "",
498 def get_op_func_name(self):
499 return "vapi_%s" % self.name
501 def get_op_func_decl(self):
502 if self.reply.has_payload():
503 return "vapi_error_e %s(%s)" % (
504 self.get_op_func_name(),
506 'struct vapi_ctx_s *ctx',
507 '%s *msg' % self.get_c_name(),
508 'vapi_error_e (*callback)(struct vapi_ctx_s *ctx',
509 ' void *callback_ctx',
513 self.reply.get_payload_struct_name(),
514 'void *callback_ctx',
518 return "vapi_error_e %s(%s)" % (
519 self.get_op_func_name(),
521 'struct vapi_ctx_s *ctx',
522 '%s *msg' % self.get_c_name(),
523 'vapi_error_e (*callback)(struct vapi_ctx_s *ctx',
524 ' void *callback_ctx',
527 'void *callback_ctx',
531 def get_op_func_def(self):
533 "%s" % self.get_op_func_decl(),
535 " if (!msg || !callback) {",
536 " return VAPI_EINVAL;",
538 " if (vapi_is_nonblocking(ctx) && vapi_requests_full(ctx)) {",
539 " return VAPI_EAGAIN;",
542 " if (VAPI_OK != (rv = vapi_producer_lock (ctx))) {",
545 " u32 req_context = vapi_gen_req_context(ctx);",
546 " msg->header.context = req_context;",
547 " %s(msg);" % self.get_swap_to_be_func_name(),
548 (" if (VAPI_OK == (rv = vapi_send_with_control_ping "
549 "(ctx, msg, req_context))) {"
550 if self.reply_is_stream else
551 " if (VAPI_OK == (rv = vapi_send (ctx, msg))) {"
553 (" vapi_store_request(ctx, req_context, %s, "
554 "(vapi_cb_t)callback, callback_ctx);" %
555 ("true" if self.reply_is_stream else "false")),
556 " if (VAPI_OK != vapi_producer_unlock (ctx)) {",
557 " abort (); /* this really shouldn't happen */",
559 " if (vapi_is_nonblocking(ctx)) {",
562 " rv = vapi_dispatch(ctx);",
565 " %s(msg);" % self.get_swap_to_host_func_name(),
566 " if (VAPI_OK != vapi_producer_unlock (ctx)) {",
567 " abort (); /* this really shouldn't happen */",
575 def get_event_cb_func_decl(self):
576 if not self.is_reply and not self.is_event:
578 "Cannot register event callback for non-reply message")
579 if self.has_payload():
581 "void vapi_set_%s_event_cb (" %
583 " struct vapi_ctx_s *ctx, ",
584 (" vapi_error_e (*callback)(struct vapi_ctx_s *ctx, "
585 "void *callback_ctx, %s *payload)," %
586 self.get_payload_struct_name()),
587 " void *callback_ctx)",
591 "void vapi_set_%s_event_cb (" %
593 " struct vapi_ctx_s *ctx, ",
594 " vapi_error_e (*callback)(struct vapi_ctx_s *ctx, "
595 "void *callback_ctx),",
596 " void *callback_ctx)",
599 def get_event_cb_func_def(self):
600 if not self.is_reply and not self.is_event:
602 "Cannot register event callback for non-reply function")
604 "%s" % self.get_event_cb_func_decl(),
606 (" vapi_set_event_cb(ctx, %s, (vapi_event_cb)callback, "
608 self.get_msg_id_name()),
611 def get_c_metadata_struct_name(self):
612 return "__vapi_metadata_%s" % self.name
614 def get_c_constructor(self):
616 if self.header is not None:
617 has_context = self.header.has_field('context')
619 'static void __attribute__((constructor)) __vapi_constructor_%s()'
622 ' static const char name[] = "%s";' % self.name,
623 ' static const char name_with_crc[] = "%s_%s";'
624 % (self.name, self.crc[2:]),
625 ' static vapi_message_desc_t %s = {' %
626 self.get_c_metadata_struct_name(),
628 ' sizeof(name) - 1,',
630 ' sizeof(name_with_crc) - 1,',
631 ' true,' if has_context else ' false,',
632 ' offsetof(%s, context),' % self.header.get_c_name()
633 if has_context else ' 0,',
634 (' offsetof(%s, payload),' % self.get_c_name())
635 if self.has_payload() else ' VAPI_INVALID_MSG_ID,',
636 ' (verify_msg_size_fn_t)%s,' %
637 self.get_verify_msg_size_func_name(),
638 ' (generic_swap_fn_t)%s,' % self.get_swap_to_be_func_name(),
639 ' (generic_swap_fn_t)%s,' % self.get_swap_to_host_func_name(),
640 ' VAPI_INVALID_MSG_ID,',
643 ' %s = vapi_register_msg(&%s);' %
644 (self.get_msg_id_name(), self.get_c_metadata_struct_name()),
645 ' VAPI_DBG("Assigned msg id %%d to %s", %s);' %
646 (self.name, self.get_msg_id_name()),
651 def emit_definition(parser, json_file, emitted, o):
654 if o.name in ("msg_header1_t", "msg_header2_t"):
656 if hasattr(o, "depends"):
658 emit_definition(parser, json_file, emitted, x)
659 if hasattr(o, "reply"):
660 emit_definition(parser, json_file, emitted, o.reply)
661 if hasattr(o, "get_c_def"):
662 if (o not in parser.enums_by_json[json_file] and
663 o not in parser.types_by_json[json_file] and
664 o not in parser.unions_by_json[json_file] and
665 o.name not in parser.messages_by_json[json_file] and
666 o not in parser.aliases_by_json[json_file]):
668 guard = "defined_%s" % o.get_c_name()
669 print("#ifndef %s" % guard)
670 print("#define %s" % guard)
671 print("%s" % o.get_c_def())
673 function_attrs = "static inline "
674 if o.name in parser.messages_by_json[json_file]:
676 print("%s%s" % (function_attrs,
677 o.get_swap_payload_to_be_func_def()))
679 print("%s%s" % (function_attrs,
680 o.get_swap_payload_to_host_func_def()))
682 print("%s%s" % (function_attrs, o.get_swap_to_be_func_def()))
684 print("%s%s" % (function_attrs, o.get_swap_to_host_func_def()))
686 print("%s%s" % (function_attrs, o.get_calc_msg_size_func_def()))
688 print("%s%s" % (function_attrs, o.get_verify_msg_size_func_def()))
689 if not o.is_reply and not o.is_event:
691 print("%s%s" % (function_attrs, o.get_alloc_func_def()))
693 print("%s%s" % (function_attrs, o.get_op_func_def()))
695 print("%s" % o.get_c_constructor())
696 if o.is_reply or o.is_event:
698 print("%s%s;" % (function_attrs, o.get_event_cb_func_def()))
699 elif hasattr(o, "get_swap_to_be_func_def"):
700 print("%s%s" % (function_attrs, o.get_swap_to_be_func_def()))
702 print("%s%s" % (function_attrs, o.get_swap_to_host_func_def()))
708 def gen_json_unified_header(parser, logger, j, io, name):
709 d, f = os.path.split(j)
710 logger.info("Generating header `%s'" % name)
711 orig_stdout = sys.stdout
713 include_guard = "__included_%s" % (
714 j.replace(".", "_").replace("/", "_").replace("-", "_").replace(
716 print("#ifndef %s" % include_guard)
717 print("#define %s" % include_guard)
719 print("#include <stdlib.h>")
720 print("#include <stddef.h>")
721 print("#include <arpa/inet.h>")
722 print("#include <vapi/vapi_internal.h>")
723 print("#include <vapi/vapi.h>")
724 print("#include <vapi/vapi_dbg.h>")
726 print("#ifdef __cplusplus")
727 print("extern \"C\" {")
729 if name == "memclnt.api.vapi.h":
731 print("static inline vapi_error_e vapi_send_with_control_ping "
732 "(vapi_ctx_t ctx, void * msg, u32 context);")
733 elif name == "vlib.api.vapi.h":
734 print("#include <vapi/memclnt.api.vapi.h>")
736 print("#include <vapi/vlib.api.vapi.h>")
738 for m in parser.messages_by_json[j].values():
739 print("extern vapi_msg_id_t %s;" % m.get_msg_id_name())
741 print("#define DEFINE_VAPI_MSG_IDS_%s\\" %
742 f.replace(".", "_").replace("/", "_").replace("-", "_").upper())
744 " vapi_msg_id_t %s;" % m.get_msg_id_name()
745 for m in parser.messages_by_json[j].values()
750 for e in parser.enums_by_json[j]:
751 emit_definition(parser, j, emitted, e)
752 for u in parser.unions_by_json[j]:
753 emit_definition(parser, j, emitted, u)
754 for t in parser.types_by_json[j]:
755 emit_definition(parser, j, emitted, t)
756 for a in parser.aliases_by_json[j]:
757 emit_definition(parser, j, emitted, a)
758 for m in parser.messages_by_json[j].values():
759 emit_definition(parser, j, emitted, m)
763 if name == "vlib.api.vapi.h":
764 vapi_send_with_control_ping_function = """
765 static inline vapi_error_e
766 vapi_send_with_control_ping (vapi_ctx_t ctx, void *msg, u32 context)
768 vapi_msg_control_ping *ping = vapi_alloc_control_ping (ctx);
773 ping->header.context = context;
774 vapi_msg_control_ping_hton (ping);
775 return vapi_send2 (ctx, msg, ping);
778 print("%s" % vapi_send_with_control_ping_function)
781 print("#ifdef __cplusplus")
786 sys.stdout = orig_stdout
789 def json_to_c_header_name(json_name):
790 if json_name.endswith(".json"):
791 return "%s.vapi.h" % os.path.splitext(json_name)[0]
792 raise Exception("Unexpected json name `%s'!" % json_name)
795 def gen_c_unified_headers(parser, logger, prefix, remove_path):
796 if prefix == "" or prefix is None:
799 prefix = "%s/" % prefix
800 for j in parser.json_files:
802 d, f = os.path.split(j)
805 with open('%s%s' % (prefix, json_to_c_header_name(f)), "w") as io:
806 gen_json_unified_header(
807 parser, logger, j, io, json_to_c_header_name(f))
810 if __name__ == '__main__':
812 verbose = int(os.getenv("V", 0))
823 logging.basicConfig(stream=sys.stdout, level=log_level)
824 logger = logging.getLogger("VAPI C GEN")
825 logger.setLevel(log_level)
827 argparser = argparse.ArgumentParser(description="VPP C API generator")
828 argparser.add_argument('files', metavar='api-file', action='append',
829 type=str, help='json api file'
830 '(may be specified multiple times)')
831 argparser.add_argument('--prefix', action='store', default=None,
833 argparser.add_argument('--remove-path', action='store_true',
834 help='remove path from filename')
835 args = argparser.parse_args()
837 jsonparser = JsonParser(logger, args.files,
838 simple_type_class=CSimpleType,
841 struct_type_class=CStructType,
843 message_class=CMessage,
846 # not using the model of having separate generated header and code files
847 # with generated symbols present in shared library (per discussion with
848 # Damjan), to avoid symbol version issues in .so
849 # gen_c_headers_and_code(jsonparser, logger, args.prefix)
851 gen_c_unified_headers(jsonparser, logger, args.prefix, args.remove_path)
853 for e in jsonparser.exceptions: