7 from vapi_json_parser import Field, Struct, Enum, Union, Message, JsonParser,\
8 SimpleType, StructType, Alias
13 return "vapi_type_%s" % self.name
16 if self.type.get_c_name() == 'vl_api_string_t':
18 return "u8 %s[%d];" % (self.name, self.len)
20 return "vl_api_string_t %s;" % (self.name)
22 if self.len is not None and type(self.len) != dict:
23 return "%s %s[%d];" % (self.type.get_c_name(), self.name, self.len)
25 return "%s %s;" % (self.type.get_c_name(), self.name)
27 def get_swap_to_be_code(self, struct, var):
28 if self.len is not None and type(self.len) != dict:
30 return "do { unsigned i; for (i = 0; i < %d; ++i) { %s } }"\
33 self.type.get_swap_to_be_code(struct, "%s[i]" % var))
35 if self.nelem_field.needs_byte_swap():
36 nelem_field = "%s(%s%s)" % (
37 self.nelem_field.type.get_swap_to_host_func_name(),
38 struct, self.nelem_field.name)
40 nelem_field = "%s%s" % (struct, self.nelem_field.name)
42 "do { unsigned i; for (i = 0; i < %s; ++i) { %s } }"
44 (nelem_field, self.type.get_swap_to_be_code(
45 struct, "%s[i]" % var)))
46 return self.type.get_swap_to_be_code(struct, "%s" % var)
48 def get_swap_to_host_code(self, struct, var):
49 if self.len is not None and type(self.len) != dict:
51 return "do { unsigned i; for (i = 0; i < %d; ++i) { %s } }"\
54 self.type.get_swap_to_host_code(struct, "%s[i]" % var))
56 # nelem_field already swapped to host here...
58 "do { unsigned i; for (i = 0; i < %s%s; ++i) { %s } }"
60 (struct, self.nelem_field.name,
61 self.type.get_swap_to_host_code(
62 struct, "%s[i]" % var)))
63 return self.type.get_swap_to_host_code(struct, "%s" % var)
65 def needs_byte_swap(self):
66 return self.type.needs_byte_swap()
68 def get_vla_field_length_name(self, path):
69 return "%s_%s_array_size" % ("_".join(path), self.name)
71 def get_alloc_vla_param_names(self, path):
73 result = [self.get_vla_field_length_name(path)]
76 if self.type.has_vla():
77 t = self.type.get_alloc_vla_param_names(path + [self.name])
81 def get_vla_calc_size_code(self, prefix, path):
83 result = ["sizeof(%s.%s[0]) * %s" % (
84 ".".join([prefix] + path),
86 self.get_vla_field_length_name(path))]
89 if self.type.has_vla():
90 t = self.type.get_vla_calc_size_code(prefix, path + [self.name])
94 def get_vla_assign_code(self, prefix, path):
97 result.append("%s.%s = %s" % (
98 ".".join([prefix] + path),
99 self.nelem_field.name,
100 self.get_vla_field_length_name(path)))
101 if self.type.has_vla():
102 t = self.type.get_vla_assign_code(prefix, path + [self.name])
107 class CAlias(CField):
108 def get_c_name(self):
109 return "vapi_type_%s" % self.name
112 if self.len is not None:
113 return "typedef %s vapi_type_%s[%d];" % (
114 self.type.get_c_name(), self.name, self.len)
116 return "typedef %s vapi_type_%s;" % (
117 self.type.get_c_name(), self.name)
120 class CStruct(Struct):
123 "typedef struct __attribute__((__packed__)) {\n%s" % (
124 "\n".join([" %s" % x.get_c_def()
125 for x in self.fields])),
126 "} %s;" % self.get_c_name()])
128 def get_vla_assign_code(self, prefix, path):
129 return [x for f in self.fields if f.has_vla()
130 for x in f.get_vla_assign_code(prefix, path)]
132 def get_alloc_vla_param_names(self, path):
133 return [x for f in self.fields
135 for x in f.get_alloc_vla_param_names(path)]
137 def get_vla_calc_size_code(self, prefix, path):
138 return [x for f in self.fields if f.has_vla()
139 for x in f.get_vla_calc_size_code(prefix, path)]
142 class CSimpleType (SimpleType):
145 'i16': 'htobe16', 'u16': 'htobe16',
146 'i32': 'htobe32', 'u32': 'htobe32',
147 'i64': 'htobe64', 'u64': 'htobe64',
150 swap_to_host_dict = {
151 'i16': 'be16toh', 'u16': 'be16toh',
152 'i32': 'be32toh', 'u32': 'be32toh',
153 'i64': 'be64toh', 'u64': 'be64toh',
156 __packed = "__attribute__((packed))"
158 'i8': __packed, 'u8': __packed,
159 'i16': __packed, 'u16': __packed,
162 def get_c_name(self):
165 def get_swap_to_be_func_name(self):
166 return self.swap_to_be_dict[self.name]
168 def get_swap_to_host_func_name(self):
169 return self.swap_to_host_dict[self.name]
171 def get_packed_string(self):
172 return self.pack_dict[self.name]
174 def get_swap_to_be_code(self, struct, var, cast=None):
175 x = "%s%s" % (struct, var)
176 return "%s = %s%s(%s);" % (x,
177 "(%s)" % cast if cast else "",
178 self.get_swap_to_be_func_name(), x)
180 def get_swap_to_host_code(self, struct, var, cast=None):
181 x = "%s%s" % (struct, var)
182 return "%s = %s%s(%s);" % (x,
183 "(%s)" % cast if cast else "",
184 self.get_swap_to_host_func_name(), x)
186 def needs_byte_swap(self):
188 self.get_swap_to_host_func_name()
194 def get_packed(self):
195 return self.pack_dict.get(self.name, "")
199 def get_c_name(self):
200 return "vapi_enum_%s" % self.name
203 return "typedef enum {\n%s\n} %s %s;" % (
204 "\n".join([" %s = %s," % (i, j) for i, j in self.value_pairs]),
205 self.type.get_packed(),
209 def needs_byte_swap(self):
210 return self.type.needs_byte_swap()
212 def get_swap_to_be_code(self, struct, var):
213 return self.type.get_swap_to_be_code(struct, var, self.get_c_name())
215 def get_swap_to_host_code(self, struct, var):
216 return self.type.get_swap_to_host_code(struct, var, self.get_c_name())
220 def get_c_name(self):
221 return "vapi_union_%s" % self.name
224 return "typedef union {\n%s\n} %s;" % (
225 "\n".join([" %s %s;" % (i.get_c_name(), j)
226 for i, j in self.type_pairs]),
230 def needs_byte_swap(self):
234 class CStructType (StructType, CStruct):
235 def get_c_name(self):
236 return "vapi_type_%s" % self.name
238 def get_swap_to_be_func_name(self):
239 return "%s_hton" % self.get_c_name()
241 def get_swap_to_host_func_name(self):
242 return "%s_ntoh" % self.get_c_name()
244 def get_swap_to_be_func_decl(self):
245 return "void %s(%s *msg)" % (
246 self.get_swap_to_be_func_name(), self.get_c_name())
248 def get_swap_to_be_func_def(self):
249 return "%s\n{\n%s\n}" % (
250 self.get_swap_to_be_func_decl(),
252 " %s" % p.get_swap_to_be_code("msg->", "%s" % p.name)
253 for p in self.fields if p.needs_byte_swap()]),
256 def get_swap_to_host_func_decl(self):
257 return "void %s(%s *msg)" % (
258 self.get_swap_to_host_func_name(), self.get_c_name())
260 def get_swap_to_host_func_def(self):
261 return "%s\n{\n%s\n}" % (
262 self.get_swap_to_host_func_decl(),
264 " %s" % p.get_swap_to_host_code("msg->", "%s" % p.name)
265 for p in self.fields if p.needs_byte_swap()]),
268 def get_swap_to_be_code(self, struct, var):
269 return "%s(&%s%s);" % (self.get_swap_to_be_func_name(), struct, var)
271 def get_swap_to_host_code(self, struct, var):
272 return "%s(&%s%s);" % (self.get_swap_to_host_func_name(), struct, var)
274 def needs_byte_swap(self):
275 for f in self.fields:
276 if f.needs_byte_swap():
281 class CMessage (Message):
282 def __init__(self, logger, definition, json_parser):
283 super(CMessage, self).__init__(logger, definition, json_parser)
284 self.payload_members = [
285 " %s" % p.get_c_def()
287 if p.type != self.header
290 def has_payload(self):
291 return len(self.payload_members) > 0
293 def get_msg_id_name(self):
294 return "vapi_msg_id_%s" % self.name
296 def get_c_name(self):
297 return "vapi_msg_%s" % self.name
299 def get_payload_struct_name(self):
300 return "vapi_payload_%s" % self.name
302 def get_alloc_func_name(self):
303 return "vapi_alloc_%s" % self.name
305 def get_alloc_vla_param_names(self):
306 return [x for f in self.fields
308 for x in f.get_alloc_vla_param_names([])]
310 def get_alloc_func_decl(self):
311 return "%s* %s(struct vapi_ctx_s *ctx%s)" % (
313 self.get_alloc_func_name(),
314 "".join([", size_t %s" % n for n in
315 self.get_alloc_vla_param_names()]))
317 def get_alloc_func_def(self):
319 if self.header.has_field('client_index'):
321 " msg->header.client_index = vapi_get_client_index(ctx);")
322 if self.header.has_field('context'):
323 extra.append(" msg->header.context = 0;")
325 "%s" % self.get_alloc_func_decl(),
327 " %s *msg = NULL;" % self.get_c_name(),
328 " const size_t size = sizeof(%s)%s;" % (
330 "".join([" + %s" % x for f in self.fields if f.has_vla()
331 for x in f.get_vla_calc_size_code("msg->payload",
333 " /* cast here required to play nicely with C++ world ... */",
334 " msg = (%s*)vapi_msg_alloc(ctx, size);" % self.get_c_name(),
339 " msg->header._vl_msg_id = vapi_lookup_vl_msg_id(ctx, %s);" %
340 self.get_msg_id_name(),
341 "".join([" %s;\n" % line
342 for f in self.fields if f.has_vla()
343 for line in f.get_vla_assign_code("msg->payload", [])]),
347 def get_calc_msg_size_func_name(self):
348 return "vapi_calc_%s_msg_size" % self.name
350 def get_calc_msg_size_func_decl(self):
351 return "uword %s(%s *msg)" % (
352 self.get_calc_msg_size_func_name(),
355 def get_calc_msg_size_func_def(self):
357 "%s" % self.get_calc_msg_size_func_decl(),
359 " return sizeof(*msg)%s;" %
360 "".join(["+ msg->payload.%s * sizeof(msg->payload.%s[0])" % (
364 if f.nelem_field is not None
370 if self.has_payload():
372 "typedef struct __attribute__ ((__packed__)) {",
374 "\n".join(self.payload_members),
375 "} %s;" % self.get_payload_struct_name(),
377 "typedef struct __attribute__ ((__packed__)) {",
378 (" %s %s;" % (self.header.get_c_name(),
380 if self.header is not None else ""),
381 " %s payload;" % self.get_payload_struct_name(),
382 "} %s;" % self.get_c_name(), ])
385 "typedef struct __attribute__ ((__packed__)) {",
386 (" %s %s;" % (self.header.get_c_name(),
388 if self.header is not None else ""),
389 "} %s;" % self.get_c_name(), ])
391 def get_swap_payload_to_host_func_name(self):
392 return "%s_payload_ntoh" % self.get_c_name()
394 def get_swap_payload_to_be_func_name(self):
395 return "%s_payload_hton" % self.get_c_name()
397 def get_swap_payload_to_host_func_decl(self):
398 return "void %s(%s *payload)" % (
399 self.get_swap_payload_to_host_func_name(),
400 self.get_payload_struct_name())
402 def get_swap_payload_to_be_func_decl(self):
403 return "void %s(%s *payload)" % (
404 self.get_swap_payload_to_be_func_name(),
405 self.get_payload_struct_name())
407 def get_swap_payload_to_be_func_def(self):
408 return "%s\n{\n%s\n}" % (
409 self.get_swap_payload_to_be_func_decl(),
411 " %s" % p.get_swap_to_be_code("payload->", "%s" % p.name)
413 if p.needs_byte_swap() and p.type != self.header]),
416 def get_swap_payload_to_host_func_def(self):
417 return "%s\n{\n%s\n}" % (
418 self.get_swap_payload_to_host_func_decl(),
420 " %s" % p.get_swap_to_host_code("payload->", "%s" % p.name)
422 if p.needs_byte_swap() and p.type != self.header]),
425 def get_swap_to_host_func_name(self):
426 return "%s_ntoh" % self.get_c_name()
428 def get_swap_to_be_func_name(self):
429 return "%s_hton" % self.get_c_name()
431 def get_swap_to_host_func_decl(self):
432 return "void %s(%s *msg)" % (
433 self.get_swap_to_host_func_name(), self.get_c_name())
435 def get_swap_to_be_func_decl(self):
436 return "void %s(%s *msg)" % (
437 self.get_swap_to_be_func_name(), self.get_c_name())
439 def get_swap_to_be_func_def(self):
441 "%s" % self.get_swap_to_be_func_decl(),
443 (" VAPI_DBG(\"Swapping `%s'@%%p to big endian\", msg);" %
445 " %s(&msg->header);" % self.header.get_swap_to_be_func_name()
446 if self.header is not None else "",
447 " %s(&msg->payload);" % self.get_swap_payload_to_be_func_name()
448 if self.has_payload() else "",
452 def get_swap_to_host_func_def(self):
454 "%s" % self.get_swap_to_host_func_decl(),
456 (" VAPI_DBG(\"Swapping `%s'@%%p to host byte order\", msg);" %
458 " %s(&msg->header);" % self.header.get_swap_to_host_func_name()
459 if self.header is not None else "",
460 " %s(&msg->payload);" % self.get_swap_payload_to_host_func_name()
461 if self.has_payload() else "",
465 def get_op_func_name(self):
466 return "vapi_%s" % self.name
468 def get_op_func_decl(self):
469 if self.reply.has_payload():
470 return "vapi_error_e %s(%s)" % (
471 self.get_op_func_name(),
473 'struct vapi_ctx_s *ctx',
474 '%s *msg' % self.get_c_name(),
475 'vapi_error_e (*callback)(struct vapi_ctx_s *ctx',
476 ' void *callback_ctx',
480 self.reply.get_payload_struct_name(),
481 'void *callback_ctx',
485 return "vapi_error_e %s(%s)" % (
486 self.get_op_func_name(),
488 'struct vapi_ctx_s *ctx',
489 '%s *msg' % self.get_c_name(),
490 'vapi_error_e (*callback)(struct vapi_ctx_s *ctx',
491 ' void *callback_ctx',
494 'void *callback_ctx',
498 def get_op_func_def(self):
500 "%s" % self.get_op_func_decl(),
502 " if (!msg || !callback) {",
503 " return VAPI_EINVAL;",
505 " if (vapi_is_nonblocking(ctx) && vapi_requests_full(ctx)) {",
506 " return VAPI_EAGAIN;",
509 " if (VAPI_OK != (rv = vapi_producer_lock (ctx))) {",
512 " u32 req_context = vapi_gen_req_context(ctx);",
513 " msg->header.context = req_context;",
514 " %s(msg);" % self.get_swap_to_be_func_name(),
515 (" if (VAPI_OK == (rv = vapi_send_with_control_ping "
516 "(ctx, msg, req_context))) {"
517 if self.reply_is_stream else
518 " if (VAPI_OK == (rv = vapi_send (ctx, msg))) {"
520 (" vapi_store_request(ctx, req_context, %s, "
521 "(vapi_cb_t)callback, callback_ctx);" %
522 ("true" if self.reply_is_stream else "false")),
523 " if (VAPI_OK != vapi_producer_unlock (ctx)) {",
524 " abort (); /* this really shouldn't happen */",
526 " if (vapi_is_nonblocking(ctx)) {",
529 " rv = vapi_dispatch(ctx);",
532 " %s(msg);" % self.get_swap_to_host_func_name(),
533 " if (VAPI_OK != vapi_producer_unlock (ctx)) {",
534 " abort (); /* this really shouldn't happen */",
542 def get_event_cb_func_decl(self):
543 if not self.is_reply and not self.is_event:
545 "Cannot register event callback for non-reply message")
546 if self.has_payload():
548 "void vapi_set_%s_event_cb (" %
550 " struct vapi_ctx_s *ctx, ",
551 (" vapi_error_e (*callback)(struct vapi_ctx_s *ctx, "
552 "void *callback_ctx, %s *payload)," %
553 self.get_payload_struct_name()),
554 " void *callback_ctx)",
558 "void vapi_set_%s_event_cb (" %
560 " struct vapi_ctx_s *ctx, ",
561 " vapi_error_e (*callback)(struct vapi_ctx_s *ctx, "
562 "void *callback_ctx),",
563 " void *callback_ctx)",
566 def get_event_cb_func_def(self):
567 if not self.is_reply and not self.is_event:
569 "Cannot register event callback for non-reply function")
571 "%s" % self.get_event_cb_func_decl(),
573 (" vapi_set_event_cb(ctx, %s, (vapi_event_cb)callback, "
575 self.get_msg_id_name()),
578 def get_c_metadata_struct_name(self):
579 return "__vapi_metadata_%s" % self.name
581 def get_c_constructor(self):
583 if self.header is not None:
584 has_context = self.header.has_field('context')
586 'static void __attribute__((constructor)) __vapi_constructor_%s()'
589 ' static const char name[] = "%s";' % self.name,
590 ' static const char name_with_crc[] = "%s_%s";'
591 % (self.name, self.crc[2:]),
592 ' static vapi_message_desc_t %s = {' %
593 self.get_c_metadata_struct_name(),
595 ' sizeof(name) - 1,',
597 ' sizeof(name_with_crc) - 1,',
598 ' true,' if has_context else ' false,',
599 ' offsetof(%s, context),' % self.header.get_c_name()
600 if has_context else ' 0,',
601 (' offsetof(%s, payload),' % self.get_c_name())
602 if self.has_payload() else ' VAPI_INVALID_MSG_ID,',
603 ' sizeof(%s),' % self.get_c_name(),
604 ' (generic_swap_fn_t)%s,' % self.get_swap_to_be_func_name(),
605 ' (generic_swap_fn_t)%s,' % self.get_swap_to_host_func_name(),
606 ' VAPI_INVALID_MSG_ID,',
609 ' %s = vapi_register_msg(&%s);' %
610 (self.get_msg_id_name(), self.get_c_metadata_struct_name()),
611 ' VAPI_DBG("Assigned msg id %%d to %s", %s);' %
612 (self.name, self.get_msg_id_name()),
617 vapi_send_with_control_ping = """
618 static inline vapi_error_e
619 vapi_send_with_control_ping (vapi_ctx_t ctx, void *msg, u32 context)
621 vapi_msg_control_ping *ping = vapi_alloc_control_ping (ctx);
626 ping->header.context = context;
627 vapi_msg_control_ping_hton (ping);
628 return vapi_send2 (ctx, msg, ping);
633 def emit_definition(parser, json_file, emitted, o):
636 if o.name in ("msg_header1_t", "msg_header2_t"):
638 if hasattr(o, "depends"):
640 emit_definition(parser, json_file, emitted, x)
641 if hasattr(o, "reply"):
642 emit_definition(parser, json_file, emitted, o.reply)
643 if hasattr(o, "get_c_def"):
644 if (o not in parser.enums_by_json[json_file] and
645 o not in parser.types_by_json[json_file] and
646 o not in parser.unions_by_json[json_file] and
647 o.name not in parser.messages_by_json[json_file] and
648 o not in parser.aliases_by_json[json_file]):
650 guard = "defined_%s" % o.get_c_name()
651 print("#ifndef %s" % guard)
652 print("#define %s" % guard)
653 print("%s" % o.get_c_def())
655 function_attrs = "static inline "
656 if o.name in parser.messages_by_json[json_file]:
658 print("%s%s" % (function_attrs,
659 o.get_swap_payload_to_be_func_def()))
661 print("%s%s" % (function_attrs,
662 o.get_swap_payload_to_host_func_def()))
664 print("%s%s" % (function_attrs, o.get_swap_to_be_func_def()))
666 print("%s%s" % (function_attrs, o.get_swap_to_host_func_def()))
668 print("%s%s" % (function_attrs, o.get_calc_msg_size_func_def()))
669 if not o.is_reply and not o.is_event:
671 print("%s%s" % (function_attrs, o.get_alloc_func_def()))
673 print("%s%s" % (function_attrs, o.get_op_func_def()))
675 print("%s" % o.get_c_constructor())
676 if o.is_reply or o.is_event:
678 print("%s%s;" % (function_attrs, o.get_event_cb_func_def()))
679 elif hasattr(o, "get_swap_to_be_func_def"):
680 print("%s%s" % (function_attrs, o.get_swap_to_be_func_def()))
682 print("%s%s" % (function_attrs, o.get_swap_to_host_func_def()))
688 def gen_json_unified_header(parser, logger, j, io, name):
689 d, f = os.path.split(j)
690 logger.info("Generating header `%s'" % name)
691 orig_stdout = sys.stdout
693 include_guard = "__included_%s" % (
694 j.replace(".", "_").replace("/", "_").replace("-", "_").replace("+", "_"))
695 print("#ifndef %s" % include_guard)
696 print("#define %s" % include_guard)
698 print("#include <stdlib.h>")
699 print("#include <stddef.h>")
700 print("#include <arpa/inet.h>")
701 print("#include <vapi/vapi_internal.h>")
702 print("#include <vapi/vapi.h>")
703 print("#include <vapi/vapi_dbg.h>")
705 print("#ifdef __cplusplus")
706 print("extern \"C\" {")
708 if name == "memclnt.api.vapi.h":
710 print("static inline vapi_error_e vapi_send_with_control_ping "
711 "(vapi_ctx_t ctx, void * msg, u32 context);")
713 print("#include <vapi/vlib.api.vapi.h>")
715 for m in parser.messages_by_json[j].values():
716 print("extern vapi_msg_id_t %s;" % m.get_msg_id_name())
718 print("#define DEFINE_VAPI_MSG_IDS_%s\\" %
719 f.replace(".", "_").replace("/", "_").replace("-", "_").upper())
721 " vapi_msg_id_t %s;" % m.get_msg_id_name()
722 for m in parser.messages_by_json[j].values()
727 for e in parser.enums_by_json[j]:
728 emit_definition(parser, j, emitted, e)
729 for u in parser.unions_by_json[j]:
730 emit_definition(parser, j, emitted, u)
731 for t in parser.types_by_json[j]:
732 emit_definition(parser, j, emitted, t)
733 for a in parser.aliases_by_json[j]:
734 emit_definition(parser, j, emitted, a)
735 for m in parser.messages_by_json[j].values():
736 emit_definition(parser, j, emitted, m)
740 if name == "vlib.api.vapi.h":
741 print("%s" % vapi_send_with_control_ping)
744 print("#ifdef __cplusplus")
749 sys.stdout = orig_stdout
752 def json_to_c_header_name(json_name):
753 if json_name.endswith(".json"):
754 return "%s.vapi.h" % os.path.splitext(json_name)[0]
755 raise Exception("Unexpected json name `%s'!" % json_name)
758 def gen_c_unified_headers(parser, logger, prefix, remove_path):
759 if prefix == "" or prefix is None:
762 prefix = "%s/" % prefix
763 for j in parser.json_files:
765 d, f = os.path.split(j)
768 with open('%s%s' % (prefix, json_to_c_header_name(f)), "w") as io:
769 gen_json_unified_header(
770 parser, logger, j, io, json_to_c_header_name(f))
773 if __name__ == '__main__':
775 verbose = int(os.getenv("V", 0))
786 logging.basicConfig(stream=sys.stdout, level=log_level)
787 logger = logging.getLogger("VAPI C GEN")
788 logger.setLevel(log_level)
790 argparser = argparse.ArgumentParser(description="VPP C API generator")
791 argparser.add_argument('files', metavar='api-file', action='append',
792 type=str, help='json api file'
793 '(may be specified multiple times)')
794 argparser.add_argument('--prefix', action='store', default=None,
796 argparser.add_argument('--remove-path', action='store_true',
797 help='remove path from filename')
798 args = argparser.parse_args()
800 jsonparser = JsonParser(logger, args.files,
801 simple_type_class=CSimpleType,
804 struct_type_class=CStructType,
806 message_class=CMessage,
809 # not using the model of having separate generated header and code files
810 # with generated symbols present in shared library (per discussion with
811 # Damjan), to avoid symbol version issues in .so
812 # gen_c_headers_and_code(jsonparser, logger, args.prefix)
814 gen_c_unified_headers(jsonparser, logger, args.prefix, args.remove_path)
816 for e in jsonparser.exceptions: