7 from vapi_json_parser import Field, Struct, Enum, Union, Message, JsonParser,\
8 SimpleType, StructType, Alias
16 if self.len is not None:
17 return "%s %s[%d];" % (self.type.get_c_name(), self.name, self.len)
19 return "%s %s;" % (self.type.get_c_name(), self.name)
21 def get_swap_to_be_code(self, struct, var):
22 if self.len is not None:
24 return "do { unsigned i; for (i = 0; i < %d; ++i) { %s } }"\
27 self.type.get_swap_to_be_code(struct, "%s[i]" % var))
29 if self.nelem_field.needs_byte_swap():
30 nelem_field = "%s(%s%s)" % (
31 self.nelem_field.type.get_swap_to_host_func_name(),
32 struct, self.nelem_field.name)
34 nelem_field = "%s%s" % (struct, self.nelem_field.name)
36 "do { unsigned i; for (i = 0; i < %s; ++i) { %s } }"
38 (nelem_field, self.type.get_swap_to_be_code(
39 struct, "%s[i]" % var)))
40 return self.type.get_swap_to_be_code(struct, "%s" % var)
42 def get_swap_to_host_code(self, struct, var):
43 if self.len is not None:
45 return "do { unsigned i; for (i = 0; i < %d; ++i) { %s } }"\
48 self.type.get_swap_to_host_code(struct, "%s[i]" % var))
50 # nelem_field already swapped to host here...
52 "do { unsigned i; for (i = 0; i < %s%s; ++i) { %s } }"
54 (struct, self.nelem_field.name,
55 self.type.get_swap_to_host_code(
56 struct, "%s[i]" % var)))
57 return self.type.get_swap_to_host_code(struct, "%s" % var)
59 def needs_byte_swap(self):
60 return self.type.needs_byte_swap()
62 def get_vla_field_length_name(self, path):
63 return "%s_%s_array_size" % ("_".join(path), self.name)
65 def get_alloc_vla_param_names(self, path):
67 result = [self.get_vla_field_length_name(path)]
70 if self.type.has_vla():
71 t = self.type.get_alloc_vla_param_names(path + [self.name])
75 def get_vla_calc_size_code(self, prefix, path):
77 result = ["sizeof(%s.%s[0]) * %s" % (
78 ".".join([prefix] + path),
80 self.get_vla_field_length_name(path))]
83 if self.type.has_vla():
84 t = self.type.get_vla_calc_size_code(prefix, path + [self.name])
88 def get_vla_assign_code(self, prefix, path):
91 result.append("%s.%s = %s" % (
92 ".".join([prefix] + path),
93 self.nelem_field.name,
94 self.get_vla_field_length_name(path)))
95 if self.type.has_vla():
96 t = self.type.get_vla_assign_code(prefix, path + [self.name])
101 class CAlias(CField):
102 def get_c_name(self):
106 return "typedef %s" % super(CAlias, self).get_c_def()
107 # if self.len is not None:
108 # return "typedef %s %s[%d];" % (self.type.get_c_name(), self.name, self.len)
110 # return "typedef %s %s;" % (self.type.get_c_name(), self.name)
112 # def needs_byte_swap
115 class CStruct(Struct):
118 "typedef struct __attribute__((__packed__)) {\n%s" % (
119 "\n".join([" %s" % x.get_c_def()
120 for x in self.fields])),
121 "} %s;" % self.get_c_name()])
123 def get_vla_assign_code(self, prefix, path):
124 return [x for f in self.fields if f.has_vla()
125 for x in f.get_vla_assign_code(prefix, path)]
127 def get_alloc_vla_param_names(self, path):
128 return [x for f in self.fields
130 for x in f.get_alloc_vla_param_names(path)]
132 def get_vla_calc_size_code(self, prefix, path):
133 return [x for f in self.fields if f.has_vla()
134 for x in f.get_vla_calc_size_code(prefix, path)]
137 class CSimpleType (SimpleType):
140 'i16': 'htobe16', 'u16': 'htobe16',
141 'i32': 'htobe32', 'u32': 'htobe32',
142 'i64': 'htobe64', 'u64': 'htobe64',
145 swap_to_host_dict = {
146 'i16': 'be16toh', 'u16': 'be16toh',
147 'i32': 'be32toh', 'u32': 'be32toh',
148 'i64': 'be64toh', 'u64': 'be64toh',
151 def get_c_name(self):
154 def get_swap_to_be_func_name(self):
155 return self.swap_to_be_dict[self.name]
157 def get_swap_to_host_func_name(self):
158 return self.swap_to_host_dict[self.name]
160 def get_swap_to_be_code(self, struct, var, cast=None):
161 x = "%s%s" % (struct, var)
162 return "%s = %s%s(%s);" % (x,
163 "(%s)" % cast if cast else "",
164 self.get_swap_to_be_func_name(), x)
166 def get_swap_to_host_code(self, struct, var, cast=None):
167 x = "%s%s" % (struct, var)
168 return "%s = %s%s(%s);" % (x,
169 "(%s)" % cast if cast else "",
170 self.get_swap_to_host_func_name(), x)
172 def needs_byte_swap(self):
174 self.get_swap_to_host_func_name()
182 def get_c_name(self):
183 return "vapi_enum_%s" % self.name
186 return "typedef enum {\n%s\n} %s;" % (
187 "\n".join([" %s = %s," % (i, j) for i, j in self.value_pairs]),
191 def needs_byte_swap(self):
192 return self.type.needs_byte_swap()
194 def get_swap_to_be_code(self, struct, var):
195 return self.type.get_swap_to_be_code(struct, var, self.get_c_name())
197 def get_swap_to_host_code(self, struct, var):
198 return self.type.get_swap_to_host_code(struct, var, self.get_c_name())
202 def get_c_name(self):
203 return "vapi_union_%s" % self.name
206 return "typedef union {\n%s\n} %s;" % (
207 "\n".join([" %s %s;" % (i.get_c_name(), j)
208 for i, j in self.type_pairs]),
212 def needs_byte_swap(self):
216 class CStructType (StructType, CStruct):
217 def get_c_name(self):
218 return "vapi_type_%s" % self.name
220 def get_swap_to_be_func_name(self):
221 return "%s_hton" % self.get_c_name()
223 def get_swap_to_host_func_name(self):
224 return "%s_ntoh" % self.get_c_name()
226 def get_swap_to_be_func_decl(self):
227 return "void %s(%s *msg)" % (
228 self.get_swap_to_be_func_name(), self.get_c_name())
230 def get_swap_to_be_func_def(self):
231 return "%s\n{\n%s\n}" % (
232 self.get_swap_to_be_func_decl(),
234 " %s" % p.get_swap_to_be_code("msg->", "%s" % p.name)
235 for p in self.fields if p.needs_byte_swap()]),
238 def get_swap_to_host_func_decl(self):
239 return "void %s(%s *msg)" % (
240 self.get_swap_to_host_func_name(), self.get_c_name())
242 def get_swap_to_host_func_def(self):
243 return "%s\n{\n%s\n}" % (
244 self.get_swap_to_host_func_decl(),
246 " %s" % p.get_swap_to_host_code("msg->", "%s" % p.name)
247 for p in self.fields if p.needs_byte_swap()]),
250 def get_swap_to_be_code(self, struct, var):
251 return "%s(&%s%s);" % (self.get_swap_to_be_func_name(), struct, var)
253 def get_swap_to_host_code(self, struct, var):
254 return "%s(&%s%s);" % (self.get_swap_to_host_func_name(), struct, var)
256 def needs_byte_swap(self):
257 for f in self.fields:
258 if f.needs_byte_swap():
263 class CMessage (Message):
264 def __init__(self, logger, definition, json_parser):
265 super(CMessage, self).__init__(logger, definition, json_parser)
266 self.payload_members = [
267 " %s" % p.get_c_def()
269 if p.type != self.header
272 def has_payload(self):
273 return len(self.payload_members) > 0
275 def get_msg_id_name(self):
276 return "vapi_msg_id_%s" % self.name
278 def get_c_name(self):
279 return "vapi_msg_%s" % self.name
281 def get_payload_struct_name(self):
282 return "vapi_payload_%s" % self.name
284 def get_alloc_func_name(self):
285 return "vapi_alloc_%s" % self.name
287 def get_alloc_vla_param_names(self):
288 return [x for f in self.fields
290 for x in f.get_alloc_vla_param_names([])]
292 def get_alloc_func_decl(self):
293 return "%s* %s(struct vapi_ctx_s *ctx%s)" % (
295 self.get_alloc_func_name(),
296 "".join([", size_t %s" % n for n in
297 self.get_alloc_vla_param_names()]))
299 def get_alloc_func_def(self):
301 if self.header.has_field('client_index'):
303 " msg->header.client_index = vapi_get_client_index(ctx);")
304 if self.header.has_field('context'):
305 extra.append(" msg->header.context = 0;")
307 "%s" % self.get_alloc_func_decl(),
309 " %s *msg = NULL;" % self.get_c_name(),
310 " const size_t size = sizeof(%s)%s;" % (
312 "".join([" + %s" % x for f in self.fields if f.has_vla()
313 for x in f.get_vla_calc_size_code("msg->payload",
315 " /* cast here required to play nicely with C++ world ... */",
316 " msg = (%s*)vapi_msg_alloc(ctx, size);" % self.get_c_name(),
321 " msg->header._vl_msg_id = vapi_lookup_vl_msg_id(ctx, %s);" %
322 self.get_msg_id_name(),
323 "".join([" %s;\n" % line
324 for f in self.fields if f.has_vla()
325 for line in f.get_vla_assign_code("msg->payload", [])]),
329 def get_calc_msg_size_func_name(self):
330 return "vapi_calc_%s_msg_size" % self.name
332 def get_calc_msg_size_func_decl(self):
333 return "uword %s(%s *msg)" % (
334 self.get_calc_msg_size_func_name(),
337 def get_calc_msg_size_func_def(self):
339 "%s" % self.get_calc_msg_size_func_decl(),
341 " return sizeof(*msg)%s;" %
342 "".join(["+ msg->payload.%s * sizeof(msg->payload.%s[0])" % (
346 if f.nelem_field is not None
352 if self.has_payload():
354 "typedef struct __attribute__ ((__packed__)) {",
356 "\n".join(self.payload_members),
357 "} %s;" % self.get_payload_struct_name(),
359 "typedef struct __attribute__ ((__packed__)) {",
360 (" %s %s;" % (self.header.get_c_name(),
362 if self.header is not None else ""),
363 " %s payload;" % self.get_payload_struct_name(),
364 "} %s;" % self.get_c_name(), ])
367 "typedef struct __attribute__ ((__packed__)) {",
368 (" %s %s;" % (self.header.get_c_name(),
370 if self.header is not None else ""),
371 "} %s;" % self.get_c_name(), ])
373 def get_swap_payload_to_host_func_name(self):
374 return "%s_payload_ntoh" % self.get_c_name()
376 def get_swap_payload_to_be_func_name(self):
377 return "%s_payload_hton" % self.get_c_name()
379 def get_swap_payload_to_host_func_decl(self):
380 return "void %s(%s *payload)" % (
381 self.get_swap_payload_to_host_func_name(),
382 self.get_payload_struct_name())
384 def get_swap_payload_to_be_func_decl(self):
385 return "void %s(%s *payload)" % (
386 self.get_swap_payload_to_be_func_name(),
387 self.get_payload_struct_name())
389 def get_swap_payload_to_be_func_def(self):
390 return "%s\n{\n%s\n}" % (
391 self.get_swap_payload_to_be_func_decl(),
393 " %s" % p.get_swap_to_be_code("payload->", "%s" % p.name)
395 if p.needs_byte_swap() and p.type != self.header]),
398 def get_swap_payload_to_host_func_def(self):
399 return "%s\n{\n%s\n}" % (
400 self.get_swap_payload_to_host_func_decl(),
402 " %s" % p.get_swap_to_host_code("payload->", "%s" % p.name)
404 if p.needs_byte_swap() and p.type != self.header]),
407 def get_swap_to_host_func_name(self):
408 return "%s_ntoh" % self.get_c_name()
410 def get_swap_to_be_func_name(self):
411 return "%s_hton" % self.get_c_name()
413 def get_swap_to_host_func_decl(self):
414 return "void %s(%s *msg)" % (
415 self.get_swap_to_host_func_name(), self.get_c_name())
417 def get_swap_to_be_func_decl(self):
418 return "void %s(%s *msg)" % (
419 self.get_swap_to_be_func_name(), self.get_c_name())
421 def get_swap_to_be_func_def(self):
423 "%s" % self.get_swap_to_be_func_decl(),
425 (" VAPI_DBG(\"Swapping `%s'@%%p to big endian\", msg);" %
427 " %s(&msg->header);" % self.header.get_swap_to_be_func_name()
428 if self.header is not None else "",
429 " %s(&msg->payload);" % self.get_swap_payload_to_be_func_name()
430 if self.has_payload() else "",
434 def get_swap_to_host_func_def(self):
436 "%s" % self.get_swap_to_host_func_decl(),
438 (" VAPI_DBG(\"Swapping `%s'@%%p to host byte order\", msg);" %
440 " %s(&msg->header);" % self.header.get_swap_to_host_func_name()
441 if self.header is not None else "",
442 " %s(&msg->payload);" % self.get_swap_payload_to_host_func_name()
443 if self.has_payload() else "",
447 def get_op_func_name(self):
448 return "vapi_%s" % self.name
450 def get_op_func_decl(self):
451 if self.reply.has_payload():
452 return "vapi_error_e %s(%s)" % (
453 self.get_op_func_name(),
455 'struct vapi_ctx_s *ctx',
456 '%s *msg' % self.get_c_name(),
457 'vapi_error_e (*callback)(struct vapi_ctx_s *ctx',
458 ' void *callback_ctx',
462 self.reply.get_payload_struct_name(),
463 'void *callback_ctx',
467 return "vapi_error_e %s(%s)" % (
468 self.get_op_func_name(),
470 'struct vapi_ctx_s *ctx',
471 '%s *msg' % self.get_c_name(),
472 'vapi_error_e (*callback)(struct vapi_ctx_s *ctx',
473 ' void *callback_ctx',
476 'void *callback_ctx',
480 def get_op_func_def(self):
482 "%s" % self.get_op_func_decl(),
484 " if (!msg || !callback) {",
485 " return VAPI_EINVAL;",
487 " if (vapi_is_nonblocking(ctx) && vapi_requests_full(ctx)) {",
488 " return VAPI_EAGAIN;",
491 " if (VAPI_OK != (rv = vapi_producer_lock (ctx))) {",
494 " u32 req_context = vapi_gen_req_context(ctx);",
495 " msg->header.context = req_context;",
496 " %s(msg);" % self.get_swap_to_be_func_name(),
497 (" if (VAPI_OK == (rv = vapi_send_with_control_ping "
498 "(ctx, msg, req_context))) {"
499 if self.reply_is_stream else
500 " if (VAPI_OK == (rv = vapi_send (ctx, msg))) {"
502 (" vapi_store_request(ctx, req_context, %s, "
503 "(vapi_cb_t)callback, callback_ctx);" %
504 ("true" if self.reply_is_stream else "false")),
505 " if (VAPI_OK != vapi_producer_unlock (ctx)) {",
506 " abort (); /* this really shouldn't happen */",
508 " if (vapi_is_nonblocking(ctx)) {",
511 " rv = vapi_dispatch(ctx);",
514 " %s(msg);" % self.get_swap_to_host_func_name(),
515 " if (VAPI_OK != vapi_producer_unlock (ctx)) {",
516 " abort (); /* this really shouldn't happen */",
524 def get_event_cb_func_decl(self):
525 if not self.is_reply and not self.is_event:
527 "Cannot register event callback for non-reply message")
528 if self.has_payload():
530 "void vapi_set_%s_event_cb (" %
532 " struct vapi_ctx_s *ctx, ",
533 (" vapi_error_e (*callback)(struct vapi_ctx_s *ctx, "
534 "void *callback_ctx, %s *payload)," %
535 self.get_payload_struct_name()),
536 " void *callback_ctx)",
540 "void vapi_set_%s_event_cb (" %
542 " struct vapi_ctx_s *ctx, ",
543 " vapi_error_e (*callback)(struct vapi_ctx_s *ctx, "
544 "void *callback_ctx),",
545 " void *callback_ctx)",
548 def get_event_cb_func_def(self):
549 if not self.is_reply and not self.is_event:
551 "Cannot register event callback for non-reply function")
553 "%s" % self.get_event_cb_func_decl(),
555 (" vapi_set_event_cb(ctx, %s, (vapi_event_cb)callback, "
557 self.get_msg_id_name()),
560 def get_c_metadata_struct_name(self):
561 return "__vapi_metadata_%s" % self.name
563 def get_c_constructor(self):
565 if self.header is not None:
566 has_context = self.header.has_field('context')
568 'static void __attribute__((constructor)) __vapi_constructor_%s()'
571 ' static const char name[] = "%s";' % self.name,
572 ' static const char name_with_crc[] = "%s_%s";'
573 % (self.name, self.crc[2:]),
574 ' static vapi_message_desc_t %s = {' %
575 self.get_c_metadata_struct_name(),
577 ' sizeof(name) - 1,',
579 ' sizeof(name_with_crc) - 1,',
580 ' true,' if has_context else ' false,',
581 ' offsetof(%s, context),' % self.header.get_c_name()
582 if has_context else ' 0,',
583 (' offsetof(%s, payload),' % self.get_c_name())
584 if self.has_payload() else ' VAPI_INVALID_MSG_ID,',
585 ' sizeof(%s),' % self.get_c_name(),
586 ' (generic_swap_fn_t)%s,' % self.get_swap_to_be_func_name(),
587 ' (generic_swap_fn_t)%s,' % self.get_swap_to_host_func_name(),
588 ' VAPI_INVALID_MSG_ID,',
591 ' %s = vapi_register_msg(&%s);' %
592 (self.get_msg_id_name(), self.get_c_metadata_struct_name()),
593 ' VAPI_DBG("Assigned msg id %%d to %s", %s);' %
594 (self.name, self.get_msg_id_name()),
599 vapi_send_with_control_ping = """
600 static inline vapi_error_e
601 vapi_send_with_control_ping (vapi_ctx_t ctx, void *msg, u32 context)
603 vapi_msg_control_ping *ping = vapi_alloc_control_ping (ctx);
608 ping->header.context = context;
609 vapi_msg_control_ping_hton (ping);
610 return vapi_send2 (ctx, msg, ping);
615 def emit_definition(parser, json_file, emitted, o):
618 if o.name in ("msg_header1_t", "msg_header2_t"):
620 if hasattr(o, "depends"):
622 emit_definition(parser, json_file, emitted, x)
623 if hasattr(o, "reply"):
624 emit_definition(parser, json_file, emitted, o.reply)
625 if hasattr(o, "get_c_def"):
626 if (o not in parser.enums_by_json[json_file] and
627 o not in parser.types_by_json[json_file] and
628 o not in parser.unions_by_json[json_file] and
629 o.name not in parser.messages_by_json[json_file] and
630 o not in parser.aliases_by_json[json_file]):
632 guard = "defined_%s" % o.get_c_name()
633 print("#ifndef %s" % guard)
634 print("#define %s" % guard)
635 print("%s" % o.get_c_def())
637 function_attrs = "static inline "
638 if o.name in parser.messages_by_json[json_file]:
640 print("%s%s" % (function_attrs,
641 o.get_swap_payload_to_be_func_def()))
643 print("%s%s" % (function_attrs,
644 o.get_swap_payload_to_host_func_def()))
646 print("%s%s" % (function_attrs, o.get_swap_to_be_func_def()))
648 print("%s%s" % (function_attrs, o.get_swap_to_host_func_def()))
650 print("%s%s" % (function_attrs, o.get_calc_msg_size_func_def()))
651 if not o.is_reply and not o.is_event:
653 print("%s%s" % (function_attrs, o.get_alloc_func_def()))
655 print("%s%s" % (function_attrs, o.get_op_func_def()))
657 print("%s" % o.get_c_constructor())
658 if o.is_reply or o.is_event:
660 print("%s%s;" % (function_attrs, o.get_event_cb_func_def()))
661 elif hasattr(o, "get_swap_to_be_func_def"):
662 print("%s%s" % (function_attrs, o.get_swap_to_be_func_def()))
664 print("%s%s" % (function_attrs, o.get_swap_to_host_func_def()))
670 def gen_json_unified_header(parser, logger, j, io, name):
671 d, f = os.path.split(j)
672 logger.info("Generating header `%s'" % name)
673 orig_stdout = sys.stdout
675 include_guard = "__included_%s" % (
676 j.replace(".", "_").replace("/", "_").replace("-", "_"))
677 print("#ifndef %s" % include_guard)
678 print("#define %s" % include_guard)
680 print("#include <stdlib.h>")
681 print("#include <stddef.h>")
682 print("#include <arpa/inet.h>")
683 print("#include <vapi/vapi_internal.h>")
684 print("#include <vapi/vapi.h>")
685 print("#include <vapi/vapi_dbg.h>")
687 print("#ifdef __cplusplus")
688 print("extern \"C\" {")
690 if name == "vpe.api.vapi.h":
692 print("static inline vapi_error_e vapi_send_with_control_ping "
693 "(vapi_ctx_t ctx, void * msg, u32 context);")
695 print("#include <vapi/vpe.api.vapi.h>")
697 for m in parser.messages_by_json[j].values():
698 print("extern vapi_msg_id_t %s;" % m.get_msg_id_name())
700 print("#define DEFINE_VAPI_MSG_IDS_%s\\" %
701 f.replace(".", "_").replace("/", "_").replace("-", "_").upper())
703 " vapi_msg_id_t %s;" % m.get_msg_id_name()
704 for m in parser.messages_by_json[j].values()
709 for e in parser.enums_by_json[j]:
710 emit_definition(parser, j, emitted, e)
711 for a in parser.aliases_by_json[j]:
712 emit_definition(parser, j, emitted, a)
713 for u in parser.unions_by_json[j]:
714 emit_definition(parser, j, emitted, u)
715 for t in parser.types_by_json[j]:
716 emit_definition(parser, j, emitted, t)
717 for m in parser.messages_by_json[j].values():
718 emit_definition(parser, j, emitted, m)
722 if name == "vpe.api.vapi.h":
723 print("%s" % vapi_send_with_control_ping)
726 print("#ifdef __cplusplus")
731 sys.stdout = orig_stdout
734 def json_to_c_header_name(json_name):
735 if json_name.endswith(".json"):
736 return "%s.vapi.h" % os.path.splitext(json_name)[0]
737 raise Exception("Unexpected json name `%s'!" % json_name)
740 def gen_c_unified_headers(parser, logger, prefix, remove_path):
741 if prefix == "" or prefix is None:
744 prefix = "%s/" % prefix
745 for j in parser.json_files:
747 d, f = os.path.split(j)
750 with open('%s%s' % (prefix, json_to_c_header_name(f)), "w") as io:
751 gen_json_unified_header(
752 parser, logger, j, io, json_to_c_header_name(f))
755 if __name__ == '__main__':
757 verbose = int(os.getenv("V", 0))
768 logging.basicConfig(stream=sys.stdout, level=log_level)
769 logger = logging.getLogger("VAPI C GEN")
770 logger.setLevel(log_level)
772 argparser = argparse.ArgumentParser(description="VPP C API generator")
773 argparser.add_argument('files', metavar='api-file', action='append',
774 type=str, help='json api file'
775 '(may be specified multiple times)')
776 argparser.add_argument('--prefix', action='store', default=None,
778 argparser.add_argument('--remove-path', action='store_true',
779 help='remove path from filename')
780 args = argparser.parse_args()
782 jsonparser = JsonParser(logger, args.files,
783 simple_type_class=CSimpleType,
786 struct_type_class=CStructType,
788 message_class=CMessage,
791 # not using the model of having separate generated header and code files
792 # with generated symbols present in shared library (per discussion with
793 # Damjan), to avoid symbol version issues in .so
794 # gen_c_headers_and_code(jsonparser, logger, args.prefix)
796 gen_c_unified_headers(jsonparser, logger, args.prefix, args.remove_path)
798 for e in jsonparser.exceptions: