src/vpp-api/vapi/vapi_c_gen.py

   1 #!/usr/bin/env python2
   2
   3 import argparse
   4 import os
   5 import sys
   6 import logging
   7 from vapi_json_parser import Field, Struct, Enum, Union, Message, JsonParser,\
   8     SimpleType, StructType, Alias
   9
  10
  11 class CField(Field):
  12     def get_c_name(self):
  13         return "vapi_type_%s" % self.name
  14
  15     def get_c_def(self):
  16         if self.len is not None:
  17             try:
  18                 return "%s %s[%d];" % (self.type.get_c_name(), self.name, self.len)
  19             except:
  20                 raise Exception("%s %s[%s];" % (self.type.get_c_name(), self.name, self.len))
  21         else:
  22             return "%s %s;" % (self.type.get_c_name(), self.name)
  23
  24     def get_swap_to_be_code(self, struct, var):
  25         if self.len is not None:
  26             if self.len > 0:
  27                 return "do { unsigned i; for (i = 0; i < %d; ++i) { %s } }"\
  28                     " while(0);" % (
  29                         self.len,
  30                         self.type.get_swap_to_be_code(struct, "%s[i]" % var))
  31             else:
  32                 if self.nelem_field.needs_byte_swap():
  33                     nelem_field = "%s(%s%s)" % (
  34                         self.nelem_field.type.get_swap_to_host_func_name(),
  35                         struct, self.nelem_field.name)
  36                 else:
  37                     nelem_field = "%s%s" % (struct, self.nelem_field.name)
  38                 return (
  39                     "do { unsigned i; for (i = 0; i < %s; ++i) { %s } }"
  40                     " while(0);" %
  41                     (nelem_field, self.type.get_swap_to_be_code(
  42                         struct, "%s[i]" % var)))
  43         return self.type.get_swap_to_be_code(struct, "%s" % var)
  44
  45     def get_swap_to_host_code(self, struct, var):
  46         if self.len is not None:
  47             if self.len > 0:
  48                 return "do { unsigned i; for (i = 0; i < %d; ++i) { %s } }"\
  49                     " while(0);" % (
  50                         self.len,
  51                         self.type.get_swap_to_host_code(struct, "%s[i]" % var))
  52             else:
  53                 # nelem_field already swapped to host here...
  54                 return (
  55                     "do { unsigned i; for (i = 0; i < %s%s; ++i) { %s } }"
  56                     " while(0);" %
  57                     (struct, self.nelem_field.name,
  58                      self.type.get_swap_to_host_code(
  59                          struct, "%s[i]" % var)))
  60         return self.type.get_swap_to_host_code(struct, "%s" % var)
  61
  62     def needs_byte_swap(self):
  63         return self.type.needs_byte_swap()
  64
  65     def get_vla_field_length_name(self, path):
  66         return "%s_%s_array_size" % ("_".join(path), self.name)
  67
  68     def get_alloc_vla_param_names(self, path):
  69         if self.is_vla():
  70             result = [self.get_vla_field_length_name(path)]
  71         else:
  72             result = []
  73         if self.type.has_vla():
  74             t = self.type.get_alloc_vla_param_names(path + [self.name])
  75             result.extend(t)
  76         return result
  77
  78     def get_vla_calc_size_code(self, prefix, path):
  79         if self.is_vla():
  80             result = ["sizeof(%s.%s[0]) * %s" % (
  81                 ".".join([prefix] + path),
  82                 self.name,
  83                 self.get_vla_field_length_name(path))]
  84         else:
  85             result = []
  86         if self.type.has_vla():
  87             t = self.type.get_vla_calc_size_code(prefix, path + [self.name])
  88             result.extend(t)
  89         return result
  90
  91     def get_vla_assign_code(self, prefix, path):
  92         result = []
  93         if self.is_vla():
  94             result.append("%s.%s = %s" % (
  95                 ".".join([prefix] + path),
  96                 self.nelem_field.name,
  97                 self.get_vla_field_length_name(path)))
  98         if self.type.has_vla():
  99             t = self.type.get_vla_assign_code(prefix, path + [self.name])
 100             result.extend(t)
 101         return result
 102
 103
 104 class CAlias(CField):
 105     def get_c_name(self):
 106         return "vapi_type_%s" % self.name
 107
 108     def get_c_def(self):
 109         if self.len is not None:
 110             return "typedef %s vapi_type_%s[%d];" % (
 111                 self.type.get_c_name(), self.name, self.len)
 112         else:
 113             return "typedef %s vapi_type_%s;" % (
 114                 self.type.get_c_name(), self.name)
 115
 116
 117 class CStruct(Struct):
 118     def get_c_def(self):
 119         return "\n".join([
 120             "typedef struct __attribute__((__packed__)) {\n%s" % (
 121                 "\n".join(["  %s" % x.get_c_def()
 122                            for x in self.fields])),
 123             "} %s;" % self.get_c_name()])
 124
 125     def get_vla_assign_code(self, prefix, path):
 126         return [x for f in self.fields if f.has_vla()
 127                 for x in f.get_vla_assign_code(prefix, path)]
 128
 129     def get_alloc_vla_param_names(self, path):
 130         return [x for f in self.fields
 131                 if f.has_vla()
 132                 for x in f.get_alloc_vla_param_names(path)]
 133
 134     def get_vla_calc_size_code(self, prefix, path):
 135         return [x for f in self.fields if f.has_vla()
 136                 for x in f.get_vla_calc_size_code(prefix, path)]
 137
 138
 139 class CSimpleType (SimpleType):
 140
 141     swap_to_be_dict = {
 142         'i16': 'htobe16', 'u16': 'htobe16',
 143         'i32': 'htobe32', 'u32': 'htobe32',
 144         'i64': 'htobe64', 'u64': 'htobe64',
 145     }
 146
 147     swap_to_host_dict = {
 148         'i16': 'be16toh', 'u16': 'be16toh',
 149         'i32': 'be32toh', 'u32': 'be32toh',
 150         'i64': 'be64toh', 'u64': 'be64toh',
 151     }
 152
 153     def get_c_name(self):
 154         return self.name
 155
 156     def get_swap_to_be_func_name(self):
 157         return self.swap_to_be_dict[self.name]
 158
 159     def get_swap_to_host_func_name(self):
 160         return self.swap_to_host_dict[self.name]
 161
 162     def get_swap_to_be_code(self, struct, var, cast=None):
 163         x = "%s%s" % (struct, var)
 164         return "%s = %s%s(%s);" % (x,
 165                                    "(%s)" % cast if cast else "",
 166                                    self.get_swap_to_be_func_name(), x)
 167
 168     def get_swap_to_host_code(self, struct, var, cast=None):
 169         x = "%s%s" % (struct, var)
 170         return "%s = %s%s(%s);" % (x,
 171                                    "(%s)" % cast if cast else "",
 172                                    self.get_swap_to_host_func_name(), x)
 173
 174     def needs_byte_swap(self):
 175         try:
 176             self.get_swap_to_host_func_name()
 177             return True
 178         except KeyError:
 179             pass
 180         return False
 181
 182
 183 class CEnum(Enum):
 184     def get_c_name(self):
 185         return "vapi_enum_%s" % self.name
 186
 187     def get_c_def(self):
 188         return "typedef enum {\n%s\n} %s;" % (
 189             "\n".join(["  %s = %s," % (i, j) for i, j in self.value_pairs]),
 190             self.get_c_name()
 191         )
 192
 193     def needs_byte_swap(self):
 194         return self.type.needs_byte_swap()
 195
 196     def get_swap_to_be_code(self, struct, var):
 197         return self.type.get_swap_to_be_code(struct, var, self.get_c_name())
 198
 199     def get_swap_to_host_code(self, struct, var):
 200         return self.type.get_swap_to_host_code(struct, var, self.get_c_name())
 201
 202
 203 class CUnion(Union):
 204     def get_c_name(self):
 205         return "vapi_union_%s" % self.name
 206
 207     def get_c_def(self):
 208         return "typedef union {\n%s\n} %s;" % (
 209             "\n".join(["  %s %s;" % (i.get_c_name(), j)
 210                        for i, j in self.type_pairs]),
 211             self.get_c_name()
 212         )
 213
 214     def needs_byte_swap(self):
 215         return False
 216
 217
 218 class CStructType (StructType, CStruct):
 219     def get_c_name(self):
 220         return "vapi_type_%s" % self.name
 221
 222     def get_swap_to_be_func_name(self):
 223         return "%s_hton" % self.get_c_name()
 224
 225     def get_swap_to_host_func_name(self):
 226         return "%s_ntoh" % self.get_c_name()
 227
 228     def get_swap_to_be_func_decl(self):
 229         return "void %s(%s *msg)" % (
 230             self.get_swap_to_be_func_name(), self.get_c_name())
 231
 232     def get_swap_to_be_func_def(self):
 233         return "%s\n{\n%s\n}" % (
 234             self.get_swap_to_be_func_decl(),
 235             "\n".join([
 236                 "  %s" % p.get_swap_to_be_code("msg->", "%s" % p.name)
 237                 for p in self.fields if p.needs_byte_swap()]),
 238         )
 239
 240     def get_swap_to_host_func_decl(self):
 241         return "void %s(%s *msg)" % (
 242             self.get_swap_to_host_func_name(), self.get_c_name())
 243
 244     def get_swap_to_host_func_def(self):
 245         return "%s\n{\n%s\n}" % (
 246             self.get_swap_to_host_func_decl(),
 247             "\n".join([
 248                 "  %s" % p.get_swap_to_host_code("msg->", "%s" % p.name)
 249                 for p in self.fields if p.needs_byte_swap()]),
 250         )
 251
 252     def get_swap_to_be_code(self, struct, var):
 253         return "%s(&%s%s);" % (self.get_swap_to_be_func_name(), struct, var)
 254
 255     def get_swap_to_host_code(self, struct, var):
 256         return "%s(&%s%s);" % (self.get_swap_to_host_func_name(), struct, var)
 257
 258     def needs_byte_swap(self):
 259         for f in self.fields:
 260             if f.needs_byte_swap():
 261                 return True
 262         return False
 263
 264
 265 class CMessage (Message):
 266     def __init__(self, logger, definition, json_parser):
 267         super(CMessage, self).__init__(logger, definition, json_parser)
 268         self.payload_members = [
 269             "  %s" % p.get_c_def()
 270             for p in self.fields
 271             if p.type != self.header
 272         ]
 273
 274     def has_payload(self):
 275         return len(self.payload_members) > 0
 276
 277     def get_msg_id_name(self):
 278         return "vapi_msg_id_%s" % self.name
 279
 280     def get_c_name(self):
 281         return "vapi_msg_%s" % self.name
 282
 283     def get_payload_struct_name(self):
 284         return "vapi_payload_%s" % self.name
 285
 286     def get_alloc_func_name(self):
 287         return "vapi_alloc_%s" % self.name
 288
 289     def get_alloc_vla_param_names(self):
 290         return [x for f in self.fields
 291                 if f.has_vla()
 292                 for x in f.get_alloc_vla_param_names([])]
 293
 294     def get_alloc_func_decl(self):
 295         return "%s* %s(struct vapi_ctx_s *ctx%s)" % (
 296             self.get_c_name(),
 297             self.get_alloc_func_name(),
 298             "".join([", size_t %s" % n for n in
 299                      self.get_alloc_vla_param_names()]))
 300
 301     def get_alloc_func_def(self):
 302         extra = []
 303         if self.header.has_field('client_index'):
 304             extra.append(
 305                 "  msg->header.client_index = vapi_get_client_index(ctx);")
 306         if self.header.has_field('context'):
 307             extra.append("  msg->header.context = 0;")
 308         return "\n".join([
 309             "%s" % self.get_alloc_func_decl(),
 310             "{",
 311             "  %s *msg = NULL;" % self.get_c_name(),
 312             "  const size_t size = sizeof(%s)%s;" % (
 313                 self.get_c_name(),
 314                 "".join([" + %s" % x for f in self.fields if f.has_vla()
 315                          for x in f.get_vla_calc_size_code("msg->payload",
 316                                                            [])])),
 317             "  /* cast here required to play nicely with C++ world ... */",
 318             "  msg = (%s*)vapi_msg_alloc(ctx, size);" % self.get_c_name(),
 319             "  if (!msg) {",
 320             "    return NULL;",
 321             "  }",
 322         ] + extra + [
 323             "  msg->header._vl_msg_id = vapi_lookup_vl_msg_id(ctx, %s);" %
 324             self.get_msg_id_name(),
 325             "".join(["  %s;\n" % line
 326                      for f in self.fields if f.has_vla()
 327                      for line in f.get_vla_assign_code("msg->payload", [])]),
 328             "  return msg;",
 329             "}"])
 330
 331     def get_calc_msg_size_func_name(self):
 332         return "vapi_calc_%s_msg_size" % self.name
 333
 334     def get_calc_msg_size_func_decl(self):
 335         return "uword %s(%s *msg)" % (
 336             self.get_calc_msg_size_func_name(),
 337             self.get_c_name())
 338
 339     def get_calc_msg_size_func_def(self):
 340         return "\n".join([
 341             "%s" % self.get_calc_msg_size_func_decl(),
 342             "{",
 343             "  return sizeof(*msg)%s;" %
 344             "".join(["+ msg->payload.%s * sizeof(msg->payload.%s[0])" % (
 345                     f.nelem_field.name,
 346                     f.name)
 347                 for f in self.fields
 348                 if f.nelem_field is not None
 349             ]),
 350             "}",
 351         ])
 352
 353     def get_c_def(self):
 354         if self.has_payload():
 355             return "\n".join([
 356                 "typedef struct __attribute__ ((__packed__)) {",
 357                 "%s " %
 358                 "\n".join(self.payload_members),
 359                 "} %s;" % self.get_payload_struct_name(),
 360                 "",
 361                 "typedef struct __attribute__ ((__packed__)) {",
 362                 ("  %s %s;" % (self.header.get_c_name(),
 363                                self.fields[0].name)
 364                     if self.header is not None else ""),
 365                 "  %s payload;" % self.get_payload_struct_name(),
 366                 "} %s;" % self.get_c_name(), ])
 367         else:
 368             return "\n".join([
 369                 "typedef struct __attribute__ ((__packed__)) {",
 370                 ("  %s %s;" % (self.header.get_c_name(),
 371                                self.fields[0].name)
 372                     if self.header is not None else ""),
 373                 "} %s;" % self.get_c_name(), ])
 374
 375     def get_swap_payload_to_host_func_name(self):
 376         return "%s_payload_ntoh" % self.get_c_name()
 377
 378     def get_swap_payload_to_be_func_name(self):
 379         return "%s_payload_hton" % self.get_c_name()
 380
 381     def get_swap_payload_to_host_func_decl(self):
 382         return "void %s(%s *payload)" % (
 383             self.get_swap_payload_to_host_func_name(),
 384             self.get_payload_struct_name())
 385
 386     def get_swap_payload_to_be_func_decl(self):
 387         return "void %s(%s *payload)" % (
 388             self.get_swap_payload_to_be_func_name(),
 389             self.get_payload_struct_name())
 390
 391     def get_swap_payload_to_be_func_def(self):
 392         return "%s\n{\n%s\n}" % (
 393             self.get_swap_payload_to_be_func_decl(),
 394             "\n".join([
 395                 "  %s" % p.get_swap_to_be_code("payload->", "%s" % p.name)
 396                 for p in self.fields
 397                 if p.needs_byte_swap() and p.type != self.header]),
 398         )
 399
 400     def get_swap_payload_to_host_func_def(self):
 401         return "%s\n{\n%s\n}" % (
 402             self.get_swap_payload_to_host_func_decl(),
 403             "\n".join([
 404                 "  %s" % p.get_swap_to_host_code("payload->", "%s" % p.name)
 405                 for p in self.fields
 406                 if p.needs_byte_swap() and p.type != self.header]),
 407         )
 408
 409     def get_swap_to_host_func_name(self):
 410         return "%s_ntoh" % self.get_c_name()
 411
 412     def get_swap_to_be_func_name(self):
 413         return "%s_hton" % self.get_c_name()
 414
 415     def get_swap_to_host_func_decl(self):
 416         return "void %s(%s *msg)" % (
 417             self.get_swap_to_host_func_name(), self.get_c_name())
 418
 419     def get_swap_to_be_func_decl(self):
 420         return "void %s(%s *msg)" % (
 421             self.get_swap_to_be_func_name(), self.get_c_name())
 422
 423     def get_swap_to_be_func_def(self):
 424         return "\n".join([
 425             "%s" % self.get_swap_to_be_func_decl(),
 426             "{",
 427             ("  VAPI_DBG(\"Swapping `%s'@%%p to big endian\", msg);" %
 428                 self.get_c_name()),
 429             "  %s(&msg->header);" % self.header.get_swap_to_be_func_name()
 430             if self.header is not None else "",
 431             "  %s(&msg->payload);" % self.get_swap_payload_to_be_func_name()
 432             if self.has_payload() else "",
 433             "}",
 434         ])
 435
 436     def get_swap_to_host_func_def(self):
 437         return "\n".join([
 438             "%s" % self.get_swap_to_host_func_decl(),
 439             "{",
 440             ("  VAPI_DBG(\"Swapping `%s'@%%p to host byte order\", msg);" %
 441                 self.get_c_name()),
 442             "  %s(&msg->header);" % self.header.get_swap_to_host_func_name()
 443             if self.header is not None else "",
 444             "  %s(&msg->payload);" % self.get_swap_payload_to_host_func_name()
 445             if self.has_payload() else "",
 446             "}",
 447         ])
 448
 449     def get_op_func_name(self):
 450         return "vapi_%s" % self.name
 451
 452     def get_op_func_decl(self):
 453         if self.reply.has_payload():
 454             return "vapi_error_e %s(%s)" % (
 455                 self.get_op_func_name(),
 456                 ",\n  ".join([
 457                     'struct vapi_ctx_s *ctx',
 458                     '%s *msg' % self.get_c_name(),
 459                     'vapi_error_e (*callback)(struct vapi_ctx_s *ctx',
 460                     '                         void *callback_ctx',
 461                     '                         vapi_error_e rv',
 462                     '                         bool is_last',
 463                     '                         %s *reply)' %
 464                     self.reply.get_payload_struct_name(),
 465                     'void *callback_ctx',
 466                 ])
 467             )
 468         else:
 469             return "vapi_error_e %s(%s)" % (
 470                 self.get_op_func_name(),
 471                 ",\n  ".join([
 472                     'struct vapi_ctx_s *ctx',
 473                     '%s *msg' % self.get_c_name(),
 474                     'vapi_error_e (*callback)(struct vapi_ctx_s *ctx',
 475                     '                         void *callback_ctx',
 476                     '                         vapi_error_e rv',
 477                     '                         bool is_last)',
 478                     'void *callback_ctx',
 479                 ])
 480             )
 481
 482     def get_op_func_def(self):
 483         return "\n".join([
 484             "%s" % self.get_op_func_decl(),
 485             "{",
 486             "  if (!msg || !callback) {",
 487             "    return VAPI_EINVAL;",
 488             "  }",
 489             "  if (vapi_is_nonblocking(ctx) && vapi_requests_full(ctx)) {",
 490             "    return VAPI_EAGAIN;",
 491             "  }",
 492             "  vapi_error_e rv;",
 493             "  if (VAPI_OK != (rv = vapi_producer_lock (ctx))) {",
 494             "    return rv;",
 495             "  }",
 496             "  u32 req_context = vapi_gen_req_context(ctx);",
 497             "  msg->header.context = req_context;",
 498             "  %s(msg);" % self.get_swap_to_be_func_name(),
 499             ("  if (VAPI_OK == (rv = vapi_send_with_control_ping "
 500                 "(ctx, msg, req_context))) {"
 501                 if self.reply_is_stream else
 502                 "  if (VAPI_OK == (rv = vapi_send (ctx, msg))) {"
 503              ),
 504             ("    vapi_store_request(ctx, req_context, %s, "
 505              "(vapi_cb_t)callback, callback_ctx);" %
 506              ("true" if self.reply_is_stream else "false")),
 507             "    if (VAPI_OK != vapi_producer_unlock (ctx)) {",
 508             "      abort (); /* this really shouldn't happen */",
 509             "    }",
 510             "    if (vapi_is_nonblocking(ctx)) {",
 511             "      rv = VAPI_OK;",
 512             "    } else {",
 513             "      rv = vapi_dispatch(ctx);",
 514             "    }",
 515             "  } else {",
 516             "    %s(msg);" % self.get_swap_to_host_func_name(),
 517             "    if (VAPI_OK != vapi_producer_unlock (ctx)) {",
 518             "      abort (); /* this really shouldn't happen */",
 519             "    }",
 520             "  }",
 521             "  return rv;",
 522             "}",
 523             "",
 524         ])
 525
 526     def get_event_cb_func_decl(self):
 527         if not self.is_reply and not self.is_event:
 528             raise Exception(
 529                 "Cannot register event callback for non-reply message")
 530         if self.has_payload():
 531             return "\n".join([
 532                 "void vapi_set_%s_event_cb (" %
 533                 self.get_c_name(),
 534                 "  struct vapi_ctx_s *ctx, ",
 535                 ("  vapi_error_e (*callback)(struct vapi_ctx_s *ctx, "
 536                  "void *callback_ctx, %s *payload)," %
 537                  self.get_payload_struct_name()),
 538                 "  void *callback_ctx)",
 539             ])
 540         else:
 541             return "\n".join([
 542                 "void vapi_set_%s_event_cb (" %
 543                 self.get_c_name(),
 544                 "  struct vapi_ctx_s *ctx, ",
 545                 "  vapi_error_e (*callback)(struct vapi_ctx_s *ctx, "
 546                 "void *callback_ctx),",
 547                 "  void *callback_ctx)",
 548             ])
 549
 550     def get_event_cb_func_def(self):
 551         if not self.is_reply and not self.is_event:
 552             raise Exception(
 553                 "Cannot register event callback for non-reply function")
 554         return "\n".join([
 555             "%s" % self.get_event_cb_func_decl(),
 556             "{",
 557             ("  vapi_set_event_cb(ctx, %s, (vapi_event_cb)callback, "
 558              "callback_ctx);" %
 559              self.get_msg_id_name()),
 560             "}"])
 561
 562     def get_c_metadata_struct_name(self):
 563         return "__vapi_metadata_%s" % self.name
 564
 565     def get_c_constructor(self):
 566         has_context = False
 567         if self.header is not None:
 568             has_context = self.header.has_field('context')
 569         return '\n'.join([
 570             'static void __attribute__((constructor)) __vapi_constructor_%s()'
 571             % self.name,
 572             '{',
 573             '  static const char name[] = "%s";' % self.name,
 574             '  static const char name_with_crc[] = "%s_%s";'
 575             % (self.name, self.crc[2:]),
 576             '  static vapi_message_desc_t %s = {' %
 577             self.get_c_metadata_struct_name(),
 578             '    name,',
 579             '    sizeof(name) - 1,',
 580             '    name_with_crc,',
 581             '    sizeof(name_with_crc) - 1,',
 582             '    true,' if has_context else '    false,',
 583             '    offsetof(%s, context),' % self.header.get_c_name()
 584             if has_context else '    0,',
 585             ('    offsetof(%s, payload),' % self.get_c_name())
 586             if self.has_payload() else '    VAPI_INVALID_MSG_ID,',
 587             '    sizeof(%s),' % self.get_c_name(),
 588             '    (generic_swap_fn_t)%s,' % self.get_swap_to_be_func_name(),
 589             '    (generic_swap_fn_t)%s,' % self.get_swap_to_host_func_name(),
 590             '    VAPI_INVALID_MSG_ID,',
 591             '  };',
 592             '',
 593             '  %s = vapi_register_msg(&%s);' %
 594             (self.get_msg_id_name(), self.get_c_metadata_struct_name()),
 595             '  VAPI_DBG("Assigned msg id %%d to %s", %s);' %
 596             (self.name, self.get_msg_id_name()),
 597             '}',
 598         ])
 599
 600
 601 vapi_send_with_control_ping = """
 602 static inline vapi_error_e
 603 vapi_send_with_control_ping (vapi_ctx_t ctx, void *msg, u32 context)
 604 {
 605   vapi_msg_control_ping *ping = vapi_alloc_control_ping (ctx);
 606   if (!ping)
 607     {
 608       return VAPI_ENOMEM;
 609     }
 610   ping->header.context = context;
 611   vapi_msg_control_ping_hton (ping);
 612   return vapi_send2 (ctx, msg, ping);
 613 }
 614 """
 615
 616
 617 def emit_definition(parser, json_file, emitted, o):
 618     if o in emitted:
 619         return
 620     if o.name in ("msg_header1_t", "msg_header2_t"):
 621         return
 622     if hasattr(o, "depends"):
 623         for x in o.depends:
 624             emit_definition(parser, json_file, emitted, x)
 625     if hasattr(o, "reply"):
 626         emit_definition(parser, json_file, emitted, o.reply)
 627     if hasattr(o, "get_c_def"):
 628         if (o not in parser.enums_by_json[json_file] and
 629                 o not in parser.types_by_json[json_file] and
 630                 o not in parser.unions_by_json[json_file] and
 631                 o.name not in parser.messages_by_json[json_file] and
 632                 o not in parser.aliases_by_json[json_file]):
 633             return
 634         guard = "defined_%s" % o.get_c_name()
 635         print("#ifndef %s" % guard)
 636         print("#define %s" % guard)
 637         print("%s" % o.get_c_def())
 638         print("")
 639         function_attrs = "static inline "
 640         if o.name in parser.messages_by_json[json_file]:
 641             if o.has_payload():
 642                 print("%s%s" % (function_attrs,
 643                                 o.get_swap_payload_to_be_func_def()))
 644                 print("")
 645                 print("%s%s" % (function_attrs,
 646                                 o.get_swap_payload_to_host_func_def()))
 647                 print("")
 648             print("%s%s" % (function_attrs, o.get_swap_to_be_func_def()))
 649             print("")
 650             print("%s%s" % (function_attrs, o.get_swap_to_host_func_def()))
 651             print("")
 652             print("%s%s" % (function_attrs, o.get_calc_msg_size_func_def()))
 653             if not o.is_reply and not o.is_event:
 654                 print("")
 655                 print("%s%s" % (function_attrs, o.get_alloc_func_def()))
 656                 print("")
 657                 print("%s%s" % (function_attrs, o.get_op_func_def()))
 658             print("")
 659             print("%s" % o.get_c_constructor())
 660             if o.is_reply or o.is_event:
 661                 print("")
 662                 print("%s%s;" % (function_attrs, o.get_event_cb_func_def()))
 663         elif hasattr(o, "get_swap_to_be_func_def"):
 664             print("%s%s" % (function_attrs, o.get_swap_to_be_func_def()))
 665             print("")
 666             print("%s%s" % (function_attrs, o.get_swap_to_host_func_def()))
 667         print("#endif")
 668         print("")
 669     emitted.append(o)
 670
 671
 672 def gen_json_unified_header(parser, logger, j, io, name):
 673     d, f = os.path.split(j)
 674     logger.info("Generating header `%s'" % name)
 675     orig_stdout = sys.stdout
 676     sys.stdout = io
 677     include_guard = "__included_%s" % (
 678         j.replace(".", "_").replace("/", "_").replace("-", "_"))
 679     print("#ifndef %s" % include_guard)
 680     print("#define %s" % include_guard)
 681     print("")
 682     print("#include <stdlib.h>")
 683     print("#include <stddef.h>")
 684     print("#include <arpa/inet.h>")
 685     print("#include <vapi/vapi_internal.h>")
 686     print("#include <vapi/vapi.h>")
 687     print("#include <vapi/vapi_dbg.h>")
 688     print("")
 689     print("#ifdef __cplusplus")
 690     print("extern \"C\" {")
 691     print("#endif")
 692     if name == "vpe.api.vapi.h":
 693         print("")
 694         print("static inline vapi_error_e vapi_send_with_control_ping "
 695               "(vapi_ctx_t ctx, void * msg, u32 context);")
 696     else:
 697         print("#include <vapi/vpe.api.vapi.h>")
 698     print("")
 699     for m in parser.messages_by_json[j].values():
 700         print("extern vapi_msg_id_t %s;" % m.get_msg_id_name())
 701     print("")
 702     print("#define DEFINE_VAPI_MSG_IDS_%s\\" %
 703           f.replace(".", "_").replace("/", "_").replace("-", "_").upper())
 704     print("\\\n".join([
 705         "  vapi_msg_id_t %s;" % m.get_msg_id_name()
 706         for m in parser.messages_by_json[j].values()
 707     ]))
 708     print("")
 709     print("")
 710     emitted = []
 711     for e in parser.enums_by_json[j]:
 712         emit_definition(parser, j, emitted, e)
 713     for a in parser.aliases_by_json[j]:
 714         emit_definition(parser, j, emitted, a)
 715     for u in parser.unions_by_json[j]:
 716         emit_definition(parser, j, emitted, u)
 717     for t in parser.types_by_json[j]:
 718         emit_definition(parser, j, emitted, t)
 719     for m in parser.messages_by_json[j].values():
 720         emit_definition(parser, j, emitted, m)
 721
 722     print("")
 723
 724     if name == "vpe.api.vapi.h":
 725         print("%s" % vapi_send_with_control_ping)
 726         print("")
 727
 728     print("#ifdef __cplusplus")
 729     print("}")
 730     print("#endif")
 731     print("")
 732     print("#endif")
 733     sys.stdout = orig_stdout
 734
 735
 736 def json_to_c_header_name(json_name):
 737     if json_name.endswith(".json"):
 738         return "%s.vapi.h" % os.path.splitext(json_name)[0]
 739     raise Exception("Unexpected json name `%s'!" % json_name)
 740
 741
 742 def gen_c_unified_headers(parser, logger, prefix, remove_path):
 743     if prefix == "" or prefix is None:
 744         prefix = ""
 745     else:
 746         prefix = "%s/" % prefix
 747     for j in parser.json_files:
 748         if remove_path:
 749             d, f = os.path.split(j)
 750         else:
 751             f = j
 752         with open('%s%s' % (prefix, json_to_c_header_name(f)), "w") as io:
 753             gen_json_unified_header(
 754                 parser, logger, j, io, json_to_c_header_name(f))
 755
 756
 757 if __name__ == '__main__':
 758     try:
 759         verbose = int(os.getenv("V", 0))
 760     except:
 761         verbose = 0
 762
 763     if verbose >= 2:
 764         log_level = 10
 765     elif verbose == 1:
 766         log_level = 20
 767     else:
 768         log_level = 40
 769
 770     logging.basicConfig(stream=sys.stdout, level=log_level)
 771     logger = logging.getLogger("VAPI C GEN")
 772     logger.setLevel(log_level)
 773
 774     argparser = argparse.ArgumentParser(description="VPP C API generator")
 775     argparser.add_argument('files', metavar='api-file', action='append',
 776                            type=str, help='json api file'
 777                            '(may be specified multiple times)')
 778     argparser.add_argument('--prefix', action='store', default=None,
 779                            help='path prefix')
 780     argparser.add_argument('--remove-path', action='store_true',
 781                            help='remove path from filename')
 782     args = argparser.parse_args()
 783
 784     jsonparser = JsonParser(logger, args.files,
 785                             simple_type_class=CSimpleType,
 786                             enum_class=CEnum,
 787                             union_class=CUnion,
 788                             struct_type_class=CStructType,
 789                             field_class=CField,
 790                             message_class=CMessage,
 791                             alias_class=CAlias)
 792
 793     # not using the model of having separate generated header and code files
 794     # with generated symbols present in shared library (per discussion with
 795     # Damjan), to avoid symbol version issues in .so
 796     # gen_c_headers_and_code(jsonparser, logger, args.prefix)
 797
 798     gen_c_unified_headers(jsonparser, logger, args.prefix, args.remove_path)
 799
 800     for e in jsonparser.exceptions:
 801         logger.warning(e)