src/vpp-api/vapi/vapi_c_gen.py

#!/usr/bin/env python3

import argparse
import inspect
import os
import sys
import logging
from vapi_json_parser import (
    Field,
    Struct,
    Enum,
    Union,
    Message,
    JsonParser,
    SimpleType,
    StructType,
    Alias,
)


class CField(Field):
    def get_c_name(self):
        return "vapi_type_%s" % self.name

    def get_c_def(self):
        if self.type.get_c_name() == "string":
            if self.len:
                return "u8 %s[%d];" % (self.name, self.len)
            else:
                return "vl_api_string_t %s;" % (self.name)
        else:
            if self.len is not None and type(self.len) != dict:
                return "%s %s[%d];" % (self.type.get_c_name(), self.name, self.len)
            else:
                return "%s %s;" % (self.type.get_c_name(), self.name)

    def get_swap_to_be_code(self, struct, var):
        if self.len is not None and type(self.len) != dict:
            if self.len > 0:
                return (
                    "do { unsigned i; for (i = 0; i < %d; ++i) { %s } }"
                    " while(0);"
                    % (self.len, self.type.get_swap_to_be_code(struct, "%s[i]" % var))
                )
            else:
                if self.nelem_field.needs_byte_swap():
                    nelem_field = "%s(%s%s)" % (
                        self.nelem_field.type.get_swap_to_host_func_name(),
                        struct,
                        self.nelem_field.name,
                    )
                else:
                    nelem_field = "%s%s" % (struct, self.nelem_field.name)
                return (
                    "do { unsigned i; for (i = 0; i < %s; ++i) { %s } }"
                    " while(0);"
                    % (
                        nelem_field,
                        self.type.get_swap_to_be_code(struct, "%s[i]" % var),
                    )
                )
        return self.type.get_swap_to_be_code(struct, "%s" % var)

    def get_swap_to_host_code(self, struct, var):
        if self.len is not None and type(self.len) != dict:
            if self.len > 0:
                return (
                    "do { unsigned i; for (i = 0; i < %d; ++i) { %s } }"
                    " while(0);"
                    % (self.len, self.type.get_swap_to_host_code(struct, "%s[i]" % var))
                )
            else:
                # nelem_field already swapped to host here...
                return (
                    "do { unsigned i; for (i = 0; i < %s%s; ++i) { %s } }"
                    " while(0);"
                    % (
                        struct,
                        self.nelem_field.name,
                        self.type.get_swap_to_host_code(struct, "%s[i]" % var),
                    )
                )
        return self.type.get_swap_to_host_code(struct, "%s" % var)

    def needs_byte_swap(self):
        return self.type.needs_byte_swap()

    def get_vla_parameter_name(self, path):
        return "%s_%s_array_size" % ("_".join(path), self.name)

    def get_vla_field_name(self, path):
        return ".".join(path + [self.nelem_field.name])

    def get_alloc_vla_param_names(self, path):
        if self.is_vla():
            result = [self.get_vla_parameter_name(path)]
        else:
            result = []
        if self.type.has_vla():
            t = self.type.get_alloc_vla_param_names(path + [self.name])
            result.extend(t)
        return result

    def get_vla_calc_size_code(self, prefix, path, is_alloc):
        if self.is_vla():
            result = [
                "sizeof(%s.%s[0]) * %s"
                % (
                    ".".join([prefix] + path),
                    self.name,
                    self.get_vla_parameter_name(path)
                    if is_alloc
                    else "%s.%s" % (prefix, self.get_vla_field_name(path)),
                )
            ]
        else:
            result = []
        if self.type.has_vla():
            t = self.type.get_vla_calc_size_code(prefix, path + [self.name], is_alloc)
            result.extend(t)
        return result

    def get_vla_assign_code(self, prefix, path):
        result = []
        if self.is_vla():
            result.append(
                "%s.%s = %s"
                % (
                    ".".join([prefix] + path),
                    self.nelem_field.name,
                    self.get_vla_parameter_name(path),
                )
            )
        if self.type.has_vla():
            t = self.type.get_vla_assign_code(prefix, path + [self.name])
            result.extend(t)
        return result


class CAlias(CField):
    def get_c_name(self):
        return "vapi_type_%s" % self.name

    def get_c_def(self):
        if self.len is not None:
            return "typedef %s vapi_type_%s[%d];" % (
                self.type.get_c_name(),
                self.name,
                self.len,
            )
        else:
            return "typedef %s vapi_type_%s;" % (self.type.get_c_name(), self.name)


class CStruct(Struct):
    def get_c_def(self):
        return "\n".join(
            [
                "typedef struct __attribute__((__packed__)) {\n%s"
                % ("\n".join(["  %s" % x.get_c_def() for x in self.fields])),
                "} %s;" % self.get_c_name(),
            ]
        )

    def get_vla_assign_code(self, prefix, path):
        return [
            x
            for f in self.fields
            if f.has_vla()
            for x in f.get_vla_assign_code(prefix, path)
        ]

    def get_alloc_vla_param_names(self, path):
        return [
            x
            for f in self.fields
            if f.has_vla()
            for x in f.get_alloc_vla_param_names(path)
        ]

    def get_vla_calc_size_code(self, prefix, path, is_alloc):
        return [
            x
            for f in self.fields
            if f.has_vla()
            for x in f.get_vla_calc_size_code(prefix, path, is_alloc)
        ]


class CSimpleType(SimpleType):
    swap_to_be_dict = {
        "i16": "htobe16",
        "u16": "htobe16",
        "i32": "htobe32",
        "u32": "htobe32",
        "i64": "htobe64",
        "u64": "htobe64",
    }

    swap_to_host_dict = {
        "i16": "be16toh",
        "u16": "be16toh",
        "i32": "be32toh",
        "u32": "be32toh",
        "i64": "be64toh",
        "u64": "be64toh",
    }

    __packed = "__attribute__((packed))"
    pack_dict = {
        "i8": __packed,
        "u8": __packed,
        "i16": __packed,
        "u16": __packed,
    }

    def get_c_name(self):
        return self.name

    def get_swap_to_be_func_name(self):
        return self.swap_to_be_dict[self.name]

    def get_swap_to_host_func_name(self):
        return self.swap_to_host_dict[self.name]

    def get_packed_string(self):
        return self.pack_dict[self.name]

    def get_swap_to_be_code(self, struct, var, cast=None):
        x = "%s%s" % (struct, var)
        return "%s = %s%s(%s);" % (
            x,
            "(%s)" % cast if cast else "",
            self.get_swap_to_be_func_name(),
            x,
        )

    def get_swap_to_host_code(self, struct, var, cast=None):
        x = "%s%s" % (struct, var)
        return "%s = %s%s(%s);" % (
            x,
            "(%s)" % cast if cast else "",
            self.get_swap_to_host_func_name(),
            x,
        )

    def needs_byte_swap(self):
        try:
            self.get_swap_to_host_func_name()
            return True
        except KeyError:
            pass
        return False

    def get_packed(self):
        return self.pack_dict.get(self.name, "")


class CEnum(Enum):
    def get_c_name(self):
        return "vapi_enum_%s" % self.name

    def get_c_def(self):
        return "typedef enum {\n%s\n} %s %s;" % (
            "\n".join(["  %s = %s," % (i, j) for i, j in self.value_pairs]),
            self.type.get_packed(),
            self.get_c_name(),
        )

    def needs_byte_swap(self):
        return self.type.needs_byte_swap()

    def get_swap_to_be_code(self, struct, var):
        return self.type.get_swap_to_be_code(struct, var, self.get_c_name())

    def get_swap_to_host_code(self, struct, var):
        return self.type.get_swap_to_host_code(struct, var, self.get_c_name())


class CUnion(Union):
    def get_c_name(self):
        return "vapi_union_%s" % self.name

    def get_c_def(self):
        return "typedef union {\n%s\n} %s;" % (
            "\n".join(["  %s %s;" % (i.get_c_name(), j) for i, j in self.type_pairs]),
            self.get_c_name(),
        )

    def needs_byte_swap(self):
        return False


class CStructType(StructType, CStruct):
    def get_c_name(self):
        if self.name == "vl_api_string_t":
            return "vl_api_string_t"
        return "vapi_type_%s" % self.name

    def get_swap_to_be_func_name(self):
        return "%s_hton" % self.get_c_name()

    def get_swap_to_host_func_name(self):
        return "%s_ntoh" % self.get_c_name()

    def get_swap_to_be_func_decl(self):
        return "void %s(%s *msg)" % (self.get_swap_to_be_func_name(), self.get_c_name())

    def get_swap_to_be_func_def(self):
        return "%s\n{\n%s\n}" % (
            self.get_swap_to_be_func_decl(),
            "\n".join(
                [
                    "  %s" % p.get_swap_to_be_code("msg->", "%s" % p.name)
                    for p in self.fields
                    if p.needs_byte_swap()
                ]
            ),
        )

    def get_swap_to_host_func_decl(self):
        return "void %s(%s *msg)" % (
            self.get_swap_to_host_func_name(),
            self.get_c_name(),
        )

    def get_swap_to_host_func_def(self):
        return "%s\n{\n%s\n}" % (
            self.get_swap_to_host_func_decl(),
            "\n".join(
                [
                    "  %s" % p.get_swap_to_host_code("msg->", "%s" % p.name)
                    for p in self.fields
                    if p.needs_byte_swap()
                ]
            ),
        )

    def get_swap_to_be_code(self, struct, var):
        return "%s(&%s%s);" % (self.get_swap_to_be_func_name(), struct, var)

    def get_swap_to_host_code(self, struct, var):
        return "%s(&%s%s);" % (self.get_swap_to_host_func_name(), struct, var)

    def needs_byte_swap(self):
        for f in self.fields:
            if f.needs_byte_swap():
                return True
        return False


class CMessage(Message):
    def __init__(self, logger, definition, json_parser):
        super(CMessage, self).__init__(logger, definition, json_parser)
        self.payload_members = [
            "  %s" % p.get_c_def() for p in self.fields if p.type != self.header
        ]

    def has_payload(self):
        return len(self.payload_members) > 0

    def get_msg_id_name(self):
        return "vapi_msg_id_%s" % self.name

    def get_c_name(self):
        return "vapi_msg_%s" % self.name

    def get_payload_struct_name(self):
        return "vapi_payload_%s" % self.name

    def get_alloc_func_name(self):
        return "vapi_alloc_%s" % self.name

    def get_alloc_vla_param_names(self):
        return [
            x
            for f in self.fields
            if f.has_vla()
            for x in f.get_alloc_vla_param_names([])
        ]

    def get_alloc_func_decl(self):
        return "%s* %s(struct vapi_ctx_s *ctx%s)" % (
            self.get_c_name(),
            self.get_alloc_func_name(),
            "".join([", size_t %s" % n for n in self.get_alloc_vla_param_names()]),
        )

    def get_alloc_func_def(self):
        extra = []
        if self.header.has_field("client_index"):
            extra.append("  msg->header.client_index = vapi_get_client_index(ctx);")
        if self.header.has_field("context"):
            extra.append("  msg->header.context = 0;")
        return "\n".join(
            [
                "%s" % self.get_alloc_func_decl(),
                "{",
                "  %s *msg = NULL;" % self.get_c_name(),
                "  const size_t size = sizeof(%s)%s;"
                % (
                    self.get_c_name(),
                    "".join(
                        [
                            " + %s" % x
                            for f in self.fields
                            if f.has_vla()
                            for x in f.get_vla_calc_size_code(
                                "msg->payload", [], is_alloc=True
                            )
                        ]
                    ),
                ),
                "  /* cast here required to play nicely with C++ world ... */",
                "  msg = (%s*)vapi_msg_alloc(ctx, size);" % self.get_c_name(),
                "  if (!msg) {",
                "    return NULL;",
                "  }",
            ]
            + extra
            + [
                "  msg->header._vl_msg_id = vapi_lookup_vl_msg_id(ctx, %s);"
                % self.get_msg_id_name(),
                "".join(
                    [
                        "  %s;\n" % line
                        for f in self.fields
                        if f.has_vla()
                        for line in f.get_vla_assign_code("msg->payload", [])
                    ]
                ),
                "  return msg;",
                "}",
            ]
        )

    def get_calc_msg_size_func_name(self):
        return "vapi_calc_%s_msg_size" % self.name

    def get_calc_msg_size_func_decl(self):
        return "uword %s(%s *msg)" % (
            self.get_calc_msg_size_func_name(),
            self.get_c_name(),
        )

    def get_calc_msg_size_func_def(self):
        return "\n".join(
            [
                "%s" % self.get_calc_msg_size_func_decl(),
                "{",
                "  return sizeof(*msg)%s;"
                % "".join(
                    [
                        " + %s" % x
                        for f in self.fields
                        if f.has_vla()
                        for x in f.get_vla_calc_size_code(
                            "msg->payload", [], is_alloc=False
                        )
                    ]
                ),
                "}",
            ]
        )

    def get_verify_msg_size_func_name(self):
        return f"vapi_verify_{self.name}_msg_size"

    def get_verify_msg_size_func_decl(self):
        return "int %s(%s *msg, uword buf_size)" % (
            self.get_verify_msg_size_func_name(),
            self.get_c_name(),
        )

    def get_verify_msg_size_func_def(self):
        return inspect.cleandoc(
            f"""
            {self.get_verify_msg_size_func_decl()}
            {{
              if (sizeof({self.get_c_name()}) > buf_size)
                {{
                  VAPI_ERR("Truncated '{self.name}' msg received, received %lu"
                    "bytes, expected %lu bytes.", buf_size,
                    sizeof({self.get_c_name()}));
                  return -1;
                }}
              if ({self.get_calc_msg_size_func_name()}(msg) > buf_size)
                {{
                  VAPI_ERR("Truncated '{self.name}' msg received, received %lu"
                    "bytes, expected %lu bytes.", buf_size,
                    {self.get_calc_msg_size_func_name()}(msg));
                  return -1;
                }}
              return 0;
            }}
        """
        )

    def get_c_def(self):
        if self.has_payload():
            return "\n".join(
                [
                    "typedef struct __attribute__ ((__packed__)) {",
                    "%s " % "\n".join(self.payload_members),
                    "} %s;" % self.get_payload_struct_name(),
                    "",
                    "typedef struct __attribute__ ((__packed__)) {",
                    (
                        "  %s %s;" % (self.header.get_c_name(), self.fields[0].name)
                        if self.header is not None
                        else ""
                    ),
                    "  %s payload;" % self.get_payload_struct_name(),
                    "} %s;" % self.get_c_name(),
                ]
            )
        else:
            return "\n".join(
                [
                    "typedef struct __attribute__ ((__packed__)) {",
                    (
                        "  %s %s;" % (self.header.get_c_name(), self.fields[0].name)
                        if self.header is not None
                        else ""
                    ),
                    "} %s;" % self.get_c_name(),
                ]
            )

    def get_swap_payload_to_host_func_name(self):
        return "%s_payload_ntoh" % self.get_c_name()

    def get_swap_payload_to_be_func_name(self):
        return "%s_payload_hton" % self.get_c_name()

    def get_swap_payload_to_host_func_decl(self):
        return "void %s(%s *payload)" % (
            self.get_swap_payload_to_host_func_name(),
            self.get_payload_struct_name(),
        )

    def get_swap_payload_to_be_func_decl(self):
        return "void %s(%s *payload)" % (
            self.get_swap_payload_to_be_func_name(),
            self.get_payload_struct_name(),
        )

    def get_swap_payload_to_be_func_def(self):
        return "%s\n{\n%s\n}" % (
            self.get_swap_payload_to_be_func_decl(),
            "\n".join(
                [
                    "  %s" % p.get_swap_to_be_code("payload->", "%s" % p.name)
                    for p in self.fields
                    if p.needs_byte_swap() and p.type != self.header
                ]
            ),
        )

    def get_swap_payload_to_host_func_def(self):
        return "%s\n{\n%s\n}" % (
            self.get_swap_payload_to_host_func_decl(),
            "\n".join(
                [
                    "  %s" % p.get_swap_to_host_code("payload->", "%s" % p.name)
                    for p in self.fields
                    if p.needs_byte_swap() and p.type != self.header
                ]
            ),
        )

    def get_swap_to_host_func_name(self):
        return "%s_ntoh" % self.get_c_name()

    def get_swap_to_be_func_name(self):
        return "%s_hton" % self.get_c_name()

    def get_swap_to_host_func_decl(self):
        return "void %s(%s *msg)" % (
            self.get_swap_to_host_func_name(),
            self.get_c_name(),
        )

    def get_swap_to_be_func_decl(self):
        return "void %s(%s *msg)" % (self.get_swap_to_be_func_name(), self.get_c_name())

    def get_swap_to_be_func_def(self):
        return "\n".join(
            [
                "%s" % self.get_swap_to_be_func_decl(),
                "{",
                (
                    '  VAPI_DBG("Swapping `%s\'@%%p to big endian", msg);'
                    % self.get_c_name()
                ),
                "  %s(&msg->header);" % self.header.get_swap_to_be_func_name()
                if self.header is not None
                else "",
                "  %s(&msg->payload);" % self.get_swap_payload_to_be_func_name()
                if self.has_payload()
                else "",
                "}",
            ]
        )

    def get_swap_to_host_func_def(self):
        return "\n".join(
            [
                "%s" % self.get_swap_to_host_func_decl(),
                "{",
                (
                    '  VAPI_DBG("Swapping `%s\'@%%p to host byte order", msg);'
                    % self.get_c_name()
                ),
                "  %s(&msg->header);" % self.header.get_swap_to_host_func_name()
                if self.header is not None
                else "",
                "  %s(&msg->payload);" % self.get_swap_payload_to_host_func_name()
                if self.has_payload()
                else "",
                "}",
            ]
        )

    def get_op_func_name(self):
        return "vapi_%s" % self.name

    def get_op_func_decl(self):
        stream_param_lines = []
        if self.has_stream_msg:
            stream_param_lines = [
                "vapi_error_e (*details_callback)(struct vapi_ctx_s *ctx",
                "                                 void *callback_ctx",
                "                                 vapi_error_e rv",
                "                                 bool is_last",
                "                                 %s *details)"
                % self.stream_msg.get_payload_struct_name(),
                "void *details_callback_ctx",
            ]

        return "vapi_error_e %s(%s)" % (
            self.get_op_func_name(),
            ",\n  ".join(
                [
                    "struct vapi_ctx_s *ctx",
                    "%s *msg" % self.get_c_name(),
                    "vapi_error_e (*reply_callback)(struct vapi_ctx_s *ctx",
                    "                               void *callback_ctx",
                    "                               vapi_error_e rv",
                    "                               bool is_last",
                    "                               %s *reply)"
                    % self.reply.get_payload_struct_name(),
                ]
                + [
                    "void *reply_callback_ctx",
                ]
                + stream_param_lines
            ),
        )

    def get_op_func_def(self):
        param_check_lines = ["  if (!msg || !reply_callback) {"]
        store_request_lines = [
            "    vapi_store_request(ctx, req_context, %s, %s, "
            % (
                self.reply.get_msg_id_name(),
                "VAPI_REQUEST_DUMP" if self.reply_is_stream else "VAPI_REQUEST_REG",
            ),
            "                       (vapi_cb_t)reply_callback, reply_callback_ctx);",
        ]
        if self.has_stream_msg:
            param_check_lines = [
                "  if (!msg || !reply_callback || !details_callback) {"
            ]
            store_request_lines = [
                f"    vapi_store_request(ctx, req_context, {self.stream_msg.get_msg_id_name()}, VAPI_REQUEST_STREAM, ",
                "                       (vapi_cb_t)details_callback, details_callback_ctx);",
                f"    vapi_store_request(ctx, req_context, {self.reply.get_msg_id_name()}, VAPI_REQUEST_REG, ",
                "                       (vapi_cb_t)reply_callback, reply_callback_ctx);",
            ]

        return "\n".join(
            [
                "%s" % self.get_op_func_decl(),
                "{",
            ]
            + param_check_lines
            + [
                "    return VAPI_EINVAL;",
                "  }",
                "  if (vapi_is_nonblocking(ctx) && vapi_requests_full(ctx)) {",
                "    return VAPI_EAGAIN;",
                "  }",
                "  vapi_error_e rv;",
                "  if (VAPI_OK != (rv = vapi_producer_lock (ctx))) {",
                "    return rv;",
                "  }",
                "  u32 req_context = vapi_gen_req_context(ctx);",
                "  msg->header.context = req_context;",
                "  %s(msg);" % self.get_swap_to_be_func_name(),
                (
                    "  if (VAPI_OK == (rv = vapi_send_with_control_ping "
                    "(ctx, msg, req_context))) {"
                    if (self.reply_is_stream and not self.has_stream_msg)
                    else "  if (VAPI_OK == (rv = vapi_send (ctx, msg))) {"
                ),
            ]
            + store_request_lines
            + [
                "    if (VAPI_OK != vapi_producer_unlock (ctx)) {",
                "      abort (); /* this really shouldn't happen */",
                "    }",
                "    if (vapi_is_nonblocking(ctx)) {",
                "      rv = VAPI_OK;",
                "    } else {",
                "      rv = vapi_dispatch(ctx);",
                "    }",
                "  } else {",
                "    %s(msg);" % self.get_swap_to_host_func_name(),
                "    if (VAPI_OK != vapi_producer_unlock (ctx)) {",
                "      abort (); /* this really shouldn't happen */",
                "    }",
                "  }",
                "  return rv;",
                "}",
                "",
            ]
        )

    def get_event_cb_func_decl(self):
        if not self.is_reply and not self.is_event:
            raise Exception("Cannot register event callback for non-reply message")
        if self.has_payload():
            return "\n".join(
                [
                    "void vapi_set_%s_event_cb (" % self.get_c_name(),
                    "  struct vapi_ctx_s *ctx, ",
                    (
                        "  vapi_error_e (*callback)(struct vapi_ctx_s *ctx, "
                        "void *callback_ctx, %s *payload),"
                        % self.get_payload_struct_name()
                    ),
                    "  void *callback_ctx)",
                ]
            )
        else:
            return "\n".join(
                [
                    "void vapi_set_%s_event_cb (" % self.get_c_name(),
                    "  struct vapi_ctx_s *ctx, ",
                    "  vapi_error_e (*callback)(struct vapi_ctx_s *ctx, "
                    "void *callback_ctx),",
                    "  void *callback_ctx)",
                ]
            )

    def get_event_cb_func_def(self):
        if not self.is_reply and not self.is_event:
            raise Exception("Cannot register event callback for non-reply function")
        return "\n".join(
            [
                "%s" % self.get_event_cb_func_decl(),
                "{",
                (
                    "  vapi_set_event_cb(ctx, %s, (vapi_event_cb)callback, "
                    "callback_ctx);" % self.get_msg_id_name()
                ),
                "}",
            ]
        )

    def get_c_metadata_struct_name(self):
        return "__vapi_metadata_%s" % self.name

    def get_c_constructor(self):
        has_context = False
        if self.header is not None:
            has_context = self.header.has_field("context")
        return "\n".join(
            [
                "static void __attribute__((constructor)) __vapi_constructor_%s()"
                % self.name,
                "{",
                '  static const char name[] = "%s";' % self.name,
                '  static const char name_with_crc[] = "%s_%s";'
                % (self.name, self.crc[2:]),
                "  static vapi_message_desc_t %s = {"
                % self.get_c_metadata_struct_name(),
                "    name,",
                "    sizeof(name) - 1,",
                "    name_with_crc,",
                "    sizeof(name_with_crc) - 1,",
                "    true," if has_context else "    false,",
                "    offsetof(%s, context)," % self.header.get_c_name()
                if has_context
                else "    0,",
                ("    offsetof(%s, payload)," % self.get_c_name())
                if self.has_payload()
                else "    VAPI_INVALID_MSG_ID,",
                "    (verify_msg_size_fn_t)%s," % self.get_verify_msg_size_func_name(),
                "    (generic_swap_fn_t)%s," % self.get_swap_to_be_func_name(),
                "    (generic_swap_fn_t)%s," % self.get_swap_to_host_func_name(),
                "    VAPI_INVALID_MSG_ID,",
                "  };",
                "",
                "  %s = vapi_register_msg(&%s);"
                % (self.get_msg_id_name(), self.get_c_metadata_struct_name()),
                '  VAPI_DBG("Assigned msg id %%d to %s", %s);'
                % (self.name, self.get_msg_id_name()),
                "}",
            ]
        )


def emit_definition(parser, json_file, emitted, o):
    if o in emitted:
        return
    if o.name in ("msg_header1_t", "msg_header2_t"):
        return
    if hasattr(o, "depends"):
        for x in o.depends:
            emit_definition(parser, json_file, emitted, x)
    if hasattr(o, "reply"):
        emit_definition(parser, json_file, emitted, o.reply)
    if hasattr(o, "stream_msg"):
        emit_definition(parser, json_file, emitted, o.stream_msg)
    if hasattr(o, "get_c_def"):
        if (
            o not in parser.enums_by_json[json_file]
            and o not in parser.types_by_json[json_file]
            and o not in parser.unions_by_json[json_file]
            and o.name not in parser.messages_by_json[json_file]
            and o not in parser.aliases_by_json[json_file]
        ):
            return
        guard = "defined_%s" % o.get_c_name()
        print("#ifndef %s" % guard)
        print("#define %s" % guard)
        print("%s" % o.get_c_def())
        print("")
        function_attrs = "static inline "
        if o.name in parser.messages_by_json[json_file]:
            if o.has_payload():
                print("%s%s" % (function_attrs, o.get_swap_payload_to_be_func_def()))
                print("")
                print("%s%s" % (function_attrs, o.get_swap_payload_to_host_func_def()))
                print("")
            print("%s%s" % (function_attrs, o.get_swap_to_be_func_def()))
            print("")
            print("%s%s" % (function_attrs, o.get_swap_to_host_func_def()))
            print("")
            print("%s%s" % (function_attrs, o.get_calc_msg_size_func_def()))
            print("")
            print("%s%s" % (function_attrs, o.get_verify_msg_size_func_def()))
            if not o.is_reply and not o.is_event and not o.is_stream:
                print("")
                print("%s%s" % (function_attrs, o.get_alloc_func_def()))
                print("")
                print("%s%s" % (function_attrs, o.get_op_func_def()))
            print("")
            print("%s" % o.get_c_constructor())
            if (o.is_reply or o.is_event) and not o.is_stream:
                print("")
                print("%s%s;" % (function_attrs, o.get_event_cb_func_def()))
        elif hasattr(o, "get_swap_to_be_func_def"):
            print("%s%s" % (function_attrs, o.get_swap_to_be_func_def()))
            print("")
            print("%s%s" % (function_attrs, o.get_swap_to_host_func_def()))
        print("#endif")
        print("")
    emitted.append(o)


def gen_json_unified_header(parser, logger, j, io, name):
    d, f = os.path.split(j)
    logger.info("Generating header `%s'" % name)
    orig_stdout = sys.stdout
    sys.stdout = io
    include_guard = "__included_%s" % (
        j.replace(".", "_")
        .replace("/", "_")
        .replace("-", "_")
        .replace("+", "_")
        .replace("@", "_")
    )
    print("#ifndef %s" % include_guard)
    print("#define %s" % include_guard)
    print("")
    print("#include <stdlib.h>")
    print("#include <stddef.h>")
    print("#include <arpa/inet.h>")
    print("#include <vapi/vapi_internal.h>")
    print("#include <vapi/vapi.h>")
    print("#include <vapi/vapi_dbg.h>")
    print("")
    print("#ifdef __cplusplus")
    print('extern "C" {')
    print("#endif")

    print("#ifndef __vl_api_string_swap_fns_defined__")
    print("#define __vl_api_string_swap_fns_defined__")
    print("")
    print("#include <vlibapi/api_types.h>")
    print("")
    function_attrs = "static inline "
    o = parser.types["vl_api_string_t"]
    print("%s%s" % (function_attrs, o.get_swap_to_be_func_def()))
    print("")
    print("%s%s" % (function_attrs, o.get_swap_to_host_func_def()))
    print("")
    print("#endif //__vl_api_string_swap_fns_defined__")

    if name == "memclnt.api.vapi.h":
        print("")
        print(
            "static inline vapi_error_e vapi_send_with_control_ping "
            "(vapi_ctx_t ctx, void * msg, u32 context);"
        )
    elif name == "vlib.api.vapi.h":
        print("#include <vapi/memclnt.api.vapi.h>")
    else:
        print("#include <vapi/vlib.api.vapi.h>")
    print("")
    for m in parser.messages_by_json[j].values():
        print("extern vapi_msg_id_t %s;" % m.get_msg_id_name())
    print("")
    print(
        "#define DEFINE_VAPI_MSG_IDS_%s\\"
        % f.replace(".", "_").replace("/", "_").replace("-", "_").upper()
    )
    print(
        "\\\n".join(
            [
                "  vapi_msg_id_t %s;" % m.get_msg_id_name()
                for m in parser.messages_by_json[j].values()
            ]
        )
    )
    print("")
    print("")
    emitted = []
    for e in parser.enums_by_json[j]:
        emit_definition(parser, j, emitted, e)
    for u in parser.unions_by_json[j]:
        emit_definition(parser, j, emitted, u)
    for t in parser.types_by_json[j]:
        emit_definition(parser, j, emitted, t)
    for a in parser.aliases_by_json[j]:
        emit_definition(parser, j, emitted, a)
    for m in parser.messages_by_json[j].values():
        emit_definition(parser, j, emitted, m)

    print("")

    if name == "vlib.api.vapi.h":
        vapi_send_with_control_ping_function = """
static inline vapi_error_e
vapi_send_with_control_ping (vapi_ctx_t ctx, void *msg, u32 context)
{
  vapi_msg_control_ping *ping = vapi_alloc_control_ping (ctx);
  if (!ping)
    {
      return VAPI_ENOMEM;
    }
  ping->header.context = context;
  vapi_msg_control_ping_hton (ping);
  return vapi_send2 (ctx, msg, ping);
}
"""
        print("%s" % vapi_send_with_control_ping_function)
        print("")

    print("#ifdef __cplusplus")
    print("}")
    print("#endif")
    print("")
    print("#endif")
    sys.stdout = orig_stdout


def json_to_c_header_name(json_name):
    if json_name.endswith(".json"):
        return "%s.vapi.h" % os.path.splitext(json_name)[0]
    raise Exception("Unexpected json name `%s'!" % json_name)


def gen_c_unified_headers(parser, logger, prefix, remove_path):
    if prefix == "" or prefix is None:
        prefix = ""
    else:
        prefix = "%s/" % prefix
    for j in parser.json_files:
        if remove_path:
            d, f = os.path.split(j)
        else:
            f = j
        with open("%s%s" % (prefix, json_to_c_header_name(f)), "w") as io:
            gen_json_unified_header(parser, logger, j, io, json_to_c_header_name(f))


if __name__ == "__main__":
    try:
        verbose = int(os.getenv("V", 0))
    except:
        verbose = 0

    if verbose >= 2:
        log_level = 10
    elif verbose == 1:
        log_level = 20
    else:
        log_level = 40

    logging.basicConfig(stream=sys.stdout, level=log_level)
    logger = logging.getLogger("VAPI C GEN")
    logger.setLevel(log_level)

    argparser = argparse.ArgumentParser(description="VPP C API generator")
    argparser.add_argument(
        "files",
        metavar="api-file",
        action="append",
        type=str,
        help="json api file" "(may be specified multiple times)",
    )
    argparser.add_argument("--prefix", action="store", default=None, help="path prefix")
    argparser.add_argument(
        "--remove-path", action="store_true", help="remove path from filename"
    )
    args = argparser.parse_args()

    jsonparser = JsonParser(
        logger,
        args.files,
        simple_type_class=CSimpleType,
        enum_class=CEnum,
        union_class=CUnion,
        struct_type_class=CStructType,
        field_class=CField,
        message_class=CMessage,
        alias_class=CAlias,
    )

    # not using the model of having separate generated header and code files
    # with generated symbols present in shared library (per discussion with
    # Damjan), to avoid symbol version issues in .so
    # gen_c_headers_and_code(jsonparser, logger, args.prefix)

    gen_c_unified_headers(jsonparser, logger, args.prefix, args.remove_path)

    for e in jsonparser.exceptions:
        logger.warning(e)