vppapigen/node.c

   1 /*
   2  *------------------------------------------------------------------
   3  * node.c - the api generator's semantic back-end
   4  *
   5  * Copyright (c) 2004-2009 Cisco and/or its affiliates.
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at:
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *------------------------------------------------------------------
  18  */
  19
  20 #include <stdio.h>
  21 #include <stdbool.h>
  22 #include <ctype.h>
  23 #include <time.h>
  24 #include <string.h>
  25 #include <unistd.h>
  26 #include <stdlib.h>
  27 #include <vppinfra/vec.h>
  28 #include <vppinfra/hash.h>
  29
  30 #include "lex.h"
  31 #include "node.h"
  32
  33 #define YYSTYPE void *
  34
  35 FILE *ofp;
  36 FILE *pythonfp;
  37 FILE *jsonfp;
  38 time_t starttime;
  39 char *vlib_app_name;
  40 char *input_filename;
  41 node_vft_t *the_vft[NODE_N_TYPES];
  42 static int indent;
  43 static int dont_output_version;
  44 int dump_tree;
  45 static char *fixed_name;
  46 static char tmpbuf [MAXNAME];
  47 static char *current_def_name;
  48 static char *current_union_name;
  49 static char *current_type_fmt;
  50 static char *current_type_cast;
  51 static char current_id;
  52 static char current_is_complex;
  53 static char *current_endianfun;
  54 static char *current_type_name;
  55
  56 void indent_me(FILE *ofp)
  57 {
  58     int i;
  59
  60     for (i = 0; i < indent; i++)
  61         putc(' ', ofp);
  62 }
  63
  64 char *uppercase (char *s)
  65 {
  66     char *cp;
  67
  68     cp = tmpbuf;
  69
  70     while (*s && (cp < tmpbuf + (sizeof(tmpbuf)-1))) {
  71         if (*s >= 'a' && *s <= 'z')
  72             *cp++ = *s++ - ('a' - 'A');
  73         else
  74             *cp++ = *s++;
  75     }
  76     *cp = 0;
  77     return(tmpbuf);
  78 }
  79
  80 char *lowercase (char *s)
  81 {
  82     char *cp;
  83
  84     cp = tmpbuf;
  85
  86     while (*s && (cp < tmpbuf + (sizeof(tmpbuf)-1))) {
  87         if (*s >= 'A' && *s <= 'Z')
  88             *cp++ = *s++ + ('a' - 'A');
  89         else
  90             *cp++ = *s++;
  91     }
  92     *cp = 0;
  93     return(tmpbuf);
  94 }
  95
  96 void primtype_recursive_print(node_t *this, i8 *fmt)
  97 {
  98     fputs((char *)fmt, stdout);
  99
 100     if (this->deeper) {
 101         node_vft_t *vftp = the_vft[this->deeper->type];
 102         vftp->print(this->deeper);
 103     }
 104 }
 105
 106 void primtype_recursive_generate(node_t *this, enum passid which, FILE *ofp,
 107                                  i8 *type_name, i8 *type_fmt, i8 *type_cast)
 108 {
 109     node_vft_t *vftp;
 110
 111     current_type_name = (char *)type_name;
 112     current_type_cast = (char *)type_cast;
 113
 114     switch(which) {
 115     case TYPEDEF_PASS:
 116         fputs((char *)type_name, ofp);
 117         fputs(" ", ofp);
 118         break;
 119
 120     case PRINTFUN_PASS:
 121         current_type_fmt = (char *)type_fmt;
 122         break;
 123
 124     case ENDIANFUN_PASS:
 125         vftp = the_vft[this->type];
 126         current_endianfun = vftp->endian_converter;
 127         break;
 128
 129     case PYTHON_PASS:
 130         fputs("('", pythonfp);
 131         fputs((char *)type_name, pythonfp);
 132         fputs("', ", pythonfp);
 133         break;
 134
 135     case JSON_PASS:
 136         fputs("[\"", jsonfp);
 137         fputs((char *)type_name, jsonfp);
 138         fputs("\", ", jsonfp);
 139         break;
 140
 141     default:
 142         fprintf(stderr, "primtype_recursive_generate: unimp pass %d\n", which);
 143         break;
 144     }
 145
 146     if (this->deeper) {
 147         vftp = the_vft[this->deeper->type];
 148         vftp->generate(this->deeper, which, ofp);
 149     }
 150 }
 151
 152 void node_illegal_print (node_t *this)
 153 {
 154     fprintf(stderr, "node_illegal_print called\n");
 155     exit(0);
 156 }
 157
 158 void node_illegal_generate (node_t *this, enum passid notused, FILE *ofp)
 159 {
 160     fprintf(stderr, "node_illegal_generate called\n");
 161     exit(0);
 162 }
 163
 164 node_vft_t node_illegal_vft = {
 165     node_illegal_print,
 166     node_illegal_generate,
 167     "illegal"
 168 };
 169
 170 void node_u8_print (node_t *this)
 171 {
 172     primtype_recursive_print(this, "u8 ");
 173 }
 174
 175 void node_u8_generate (node_t *this, enum passid which, FILE *ofp)
 176 {
 177     primtype_recursive_generate(this, which, ofp, "u8", "%u", "(unsigned)");
 178 }
 179
 180 node_vft_t node_u8_vft = {
 181     node_u8_print,
 182     node_u8_generate,
 183     NULL
 184 };
 185
 186 void node_u16_print (node_t *this)
 187 {
 188     primtype_recursive_print(this, "u16 ");
 189 }
 190
 191 void node_u16_generate (node_t *this, enum passid which, FILE *ofp)
 192 {
 193     primtype_recursive_generate(this, which, ofp, "u16", "%u", "(unsigned)");
 194 }
 195
 196 node_vft_t node_u16_vft = {
 197     node_u16_print,
 198     node_u16_generate,
 199     "clib_net_to_host_u16"
 200 };
 201
 202 void node_u32_print (node_t *this)
 203 {
 204     primtype_recursive_print(this, "u32 ");
 205 }
 206
 207 void node_u32_generate (node_t *this, enum passid which, FILE *ofp)
 208 {
 209     primtype_recursive_generate(this, which, ofp, "u32", "%u", "(unsigned)");
 210 }
 211
 212 node_vft_t node_u32_vft = {
 213     node_u32_print,
 214     node_u32_generate,
 215     "clib_net_to_host_u32",
 216 };
 217
 218 void node_u64_print (node_t *this)
 219 {
 220     primtype_recursive_print(this, "u64 ");
 221 }
 222
 223 void node_u64_generate (node_t *this, enum passid which, FILE *ofp)
 224 {
 225     primtype_recursive_generate(this, which, ofp, "u64", "%llu",
 226                                 "(long long)");
 227 }
 228
 229 node_vft_t node_u64_vft = {
 230     node_u64_print,
 231     node_u64_generate,
 232     "clib_net_to_host_u64"
 233 };
 234
 235 void node_i8_print (node_t *this)
 236 {
 237     primtype_recursive_print(this, "i8 ");
 238 }
 239
 240 void node_i8_generate (node_t *this, enum passid which, FILE *ofp)
 241 {
 242     primtype_recursive_generate(this, which, ofp, "i8", "%d", "(int)");
 243 }
 244
 245 node_vft_t node_i8_vft = {
 246     node_i8_print,
 247     node_i8_generate,
 248     ""
 249 };
 250
 251 void node_i16_print (node_t *this)
 252 {
 253     primtype_recursive_print(this, "i16 ");
 254 }
 255
 256 void node_i16_generate (node_t *this, enum passid which, FILE *ofp)
 257 {
 258     primtype_recursive_generate(this, which, ofp, "i16", "%d", "(int)");
 259 }
 260
 261 node_vft_t node_i16_vft = {
 262     node_i16_print,
 263     node_i16_generate,
 264     "clib_net_to_host_u16"
 265 };
 266
 267 void node_i32_print (node_t *this)
 268 {
 269     primtype_recursive_print(this, "i32 ");
 270 }
 271
 272 void node_i32_generate (node_t *this, enum passid which, FILE *ofp)
 273 {
 274     primtype_recursive_generate(this, which, ofp, "i32", "%ld", "(long)");
 275 }
 276
 277 node_vft_t node_i32_vft = {
 278     node_i32_print,
 279     node_i32_generate,
 280     "clib_net_to_host_u32"
 281 };
 282
 283 void node_i64_print (node_t *this)
 284 {
 285     primtype_recursive_print(this, "i64 ");
 286 }
 287
 288 void node_i64_generate (node_t *this, enum passid which, FILE *ofp)
 289 {
 290     primtype_recursive_generate(this, which, ofp, "i64", "%lld",
 291                                 "(long long)");
 292 }
 293
 294 node_vft_t node_i64_vft = {
 295     node_i64_print,
 296     node_i64_generate,
 297     "clib_net_to_host_u64"
 298 };
 299
 300 void node_f64_print (node_t *this)
 301 {
 302     primtype_recursive_print(this, "f64 ");
 303 }
 304
 305 void node_f64_generate (node_t *this, enum passid which, FILE *ofp)
 306 {
 307     primtype_recursive_generate(this, which, ofp, "f64", "%.2f",
 308                                 "(double)");
 309 }
 310
 311 node_vft_t node_f64_vft = {
 312     node_f64_print,
 313     node_f64_generate,
 314     " ",                        /* FP numbers are sent in host byte order */
 315 };
 316
 317
 318 void node_packed_print (node_t *this)
 319 {
 320     primtype_recursive_print (this, "packed ");
 321 }
 322
 323 void node_packed_generate (node_t *this, enum passid which, FILE *ofp)
 324 {
 325     primtype_recursive_generate(this, which, ofp, "PACKED", "", "");
 326 }
 327
 328 node_vft_t node_packed_vft = {
 329     node_packed_print,
 330     node_packed_generate,
 331     0,
 332 };
 333
 334 void node_define_print (node_t *this)
 335 {
 336     fprintf(stdout, "define %s {\n", CDATA0);
 337     if (this->deeper) {
 338         node_vft_t *vftp = the_vft[this->deeper->type];
 339         fprintf(stdout, "    ");
 340         vftp->print(this->deeper);
 341     }
 342     fprintf(stdout, "};\n");
 343 }
 344
 345 void node_define_generate (node_t *this, enum passid which, FILE *fp)
 346 {
 347     node_t *child, *save_child;
 348
 349     switch(which) {
 350     case TYPEDEF_PASS:
 351         fprintf(fp, "typedef VL_API_PACKED(struct _vl_api_%s {\n", CDATA0);
 352         child = this->deeper;
 353         indent += 4;
 354         while (child) {
 355             node_vft_t *vftp = the_vft[child->type];
 356             indent_me(fp);
 357             vftp->generate(child, which, fp);
 358             child = child->peer;
 359         }
 360         indent -= 4;
 361         fprintf(fp, "}) vl_api_%s_t;\n\n", CDATA0);
 362         break;
 363
 364     case ENDIANFUN_PASS:
 365     case PRINTFUN_PASS:
 366         child = this->deeper;
 367         while (child) {
 368             node_vft_t *vftp = the_vft[child->type];
 369             vftp->generate(child, which, fp);
 370             child = child->peer;
 371         }
 372         break;
 373
 374     case PYTHON_PASS:
 375       fprintf(fp, "('%s',\n", CDATA0);
 376         child = this->deeper;
 377         indent += 4;
 378         while (child) {
 379             node_vft_t *vftp = the_vft[child->type];
 380             indent_me(fp);
 381             vftp->generate(child, which, fp);
 382             child = child->peer;
 383         }
 384         indent -= 4;
 385         fprintf(fp, "),\n\n");
 386         break;
 387
 388     case JSON_PASS:
 389         fprintf(fp, "[\"%s\",\n", CDATA0);
 390         child = this->deeper;
 391         indent += 4;
 392         while (child) {
 393             node_vft_t *vftp = the_vft[child->type];
 394             indent_me(fp);
 395             vftp->generate(child, which, fp);
 396             child = child->peer;
 397             fprintf(fp, ",\n");
 398         }
 399         indent_me(fp);
 400         fprintf (fp, "{\"crc\" : \"0x%08x\"}\n", (u32)(u64)CDATA3);
 401         indent -= 4;
 402         indent_me(fp);
 403         fprintf(fp, "]");
 404         break;
 405
 406     default:
 407         fprintf(stderr, "node_define_generate: unimp pass %d\n", which);
 408         break;
 409     }
 410 }
 411
 412 node_vft_t node_define_vft = {
 413     node_define_print,
 414     node_define_generate,
 415     0,
 416 };
 417
 418 void node_union_print (node_t *this)
 419 {
 420     primtype_recursive_print (this, "union ");
 421 }
 422
 423 void node_union_generate (node_t *this, enum passid which, FILE *fp)
 424 {
 425     node_t *child;
 426     node_t *uelem;
 427     int case_id=1;
 428
 429     switch(which) {
 430     case TYPEDEF_PASS:
 431         fprintf(fp, "u8 _%s_which;\n", CDATA0);
 432         indent_me(fp);
 433         fprintf(fp, "union _%s {\n", CDATA0);
 434         child = this->deeper;
 435         indent += 4;
 436
 437         while (child) {
 438             node_vft_t *vftp = the_vft[child->type];
 439             indent_me(fp);
 440             vftp->generate(child, which, fp);
 441             child = child->peer;
 442         }
 443         indent -= 4;
 444         indent_me(fp);
 445         fprintf(fp, "} %s;\n", CDATA0);
 446         break;
 447
 448     case PRINTFUN_PASS:
 449     case ENDIANFUN_PASS:
 450         uelem = this->deeper;
 451
 452         indent_me(fp);
 453         fprintf(fp, "switch(a->_%s_which) {\n",
 454                 CDATA0);
 455         indent += 4;
 456         current_union_name = CDATA0;
 457
 458         /* Walk the list of objects in this union */
 459         while (uelem) {
 460             node_vft_t *vftp = the_vft[uelem->type];
 461             indent -= 4;
 462             indent_me(fp);
 463             fprintf(fp, "case %d:\n", case_id);
 464             case_id++;
 465             indent += 4;
 466             /* Drill down on each element */
 467             vftp->generate(uelem, which, fp);
 468             indent_me(fp);
 469             fprintf(fp, "break;\n");
 470             uelem = uelem->peer;
 471         }
 472         current_union_name = 0;
 473         indent -= 4;
 474         indent_me(fp);
 475         fprintf(fp, "default:\n");
 476         indent += 4;
 477         indent_me(fp);
 478         if (which == PRINTFUN_PASS) {
 479             fprintf(fp,
 480                     "vl_print(handle, \"WARNING: _%s_which not set.\\n\");\n",
 481                     CDATA0);
 482         }
 483         indent_me(fp);
 484         fprintf(fp, "break;\n");
 485         indent -= 4;
 486         indent_me(fp);
 487         fprintf(fp, "}\n");
 488         break;
 489
 490     default:
 491         fprintf(stderr, "node_union_generate: unimp pass %d\n", which);
 492         break;
 493     }
 494 }
 495
 496
 497 node_vft_t node_union_vft = {
 498     node_union_print,
 499     node_union_generate,
 500     0,
 501 };
 502
 503 void node_scalar_print (node_t *this)
 504 {
 505     fprintf(stdout, "%s", CDATA0);
 506     primtype_recursive_print (this, "");
 507 }
 508
 509 void node_scalar_generate (node_t *this, enum passid which, FILE *fp)
 510 {
 511     char *union_prefix = "";
 512
 513     if (current_union_name) {
 514         sprintf(tmpbuf, "%s.", current_union_name);
 515         union_prefix = tmpbuf;
 516     }
 517
 518     switch(which) {
 519     case TYPEDEF_PASS:
 520         fprintf(fp, "%s;\n", CDATA0);
 521         break;
 522
 523     case PRINTFUN_PASS:
 524         indent_me(fp);
 525         if (current_is_complex) {
 526             fprintf(fp, "vl_api_%s_t_print(a->%s%s, handle);\n",
 527                     current_type_name, union_prefix, CDATA0);
 528         } else {
 529             if (!strcmp(current_type_fmt, "uword")) {
 530                 fprintf(fp,
 531            "vl_print(handle, \"%s%s: \" _uword_fmt \"\\n\", %s a->%s%s);\n",
 532                         union_prefix, CDATA0, "(_uword_cast)",
 533                         union_prefix, CDATA0);
 534             } else {
 535                 fprintf(fp,
 536                         "vl_print(handle, \"%s%s: %s\\n\", %s a->%s%s);\n",
 537                         union_prefix, CDATA0,
 538                         current_type_fmt, current_type_cast,
 539                         union_prefix, CDATA0);
 540             }
 541         }
 542         break;
 543
 544     case ENDIANFUN_PASS:
 545         indent_me(fp);
 546         if (current_is_complex) {
 547             fprintf(fp, "vl_api%s_t_endian(a->%s%s);\n",
 548                     current_type_name, union_prefix, CDATA0);
 549         } else {
 550             /* Current_endianfun == NULL means e.g. it's a u8... */
 551             if (current_endianfun) {
 552                 fprintf(fp, "a->%s%s = %s(a->%s%s);\n", union_prefix,
 553                         CDATA0, current_endianfun,
 554                         union_prefix, CDATA0);
 555             } else {
 556                 fprintf(fp, "/* a->%s%s = a->%s%s (no-op) */\n",
 557                         union_prefix, CDATA0,
 558                         union_prefix, CDATA0);
 559             }
 560         }
 561         break;
 562     case PYTHON_PASS:
 563         fprintf(fp, "'%s'),\n", CDATA0);
 564         break;
 565
 566     case JSON_PASS:
 567         fprintf(fp, "\"%s\"]", CDATA0);
 568         break;
 569
 570     default:
 571         fprintf(stderr, "node_scalar_generate: unimp pass %d\n", which);
 572     }
 573     if (this->deeper) {
 574         fprintf(stderr, "broken recursion in node_scalar_generate\n");
 575     }
 576 }
 577
 578
 579 node_vft_t node_scalar_vft = {
 580     node_scalar_print,
 581     node_scalar_generate,
 582     0,
 583 };
 584
 585 void node_vector_print (node_t *this)
 586 {
 587     primtype_recursive_print (this, "vector ");
 588 }
 589
 590 void node_vector_generate (node_t *this, enum passid which, FILE *fp)
 591 {
 592     char *union_prefix = "";
 593
 594     if (current_union_name) {
 595         sprintf(tmpbuf, "%s.", current_union_name);
 596         union_prefix = tmpbuf;
 597     }
 598
 599     switch(which) {
 600     case TYPEDEF_PASS:
 601         fprintf(fp, "%s[%d];\n", CDATA0, IDATA1);
 602         break;
 603
 604     case PRINTFUN_PASS:
 605         /* Don't bother about "u8 data [0];" et al. */
 606         if (IDATA1 == 0)
 607             break;
 608
 609         indent_me(fp);
 610         fprintf(fp, "{\n");
 611         indent += 4;
 612         indent_me(fp);
 613         fprintf(fp, "int _i;\n");
 614         indent_me(fp);
 615         fprintf(fp, "for (_i = 0; _i < %d; _i++) {\n",
 616                 IDATA1);
 617         indent += 4;
 618         indent_me(fp);
 619         if (current_is_complex) {
 620             fprintf(fp, "vl_print(handle, \"%s%s[%%d]: ",
 621                     union_prefix, CDATA0);
 622             fprintf(fp,
 623                     "vl_print_%s (handle, a->%s%s[_i]);\n",
 624                     CDATA0, union_prefix, CDATA0);
 625         } else {
 626             fprintf(fp,
 627          "vl_print(handle, \"%s%s[%%d]: %s\\n\", _i, a->%s%s[_i]);\n",
 628                     union_prefix, CDATA0,
 629                     current_type_fmt,
 630                     union_prefix, CDATA0);
 631         }
 632         indent -= 4;
 633         indent_me(fp);
 634         fprintf(fp, "}\n");
 635         indent -= 4;
 636         indent_me(fp);
 637         fprintf(fp, "}\n");
 638         break;
 639
 640     case ENDIANFUN_PASS:
 641         /* Don't bother about "u8 data [0];" et al. */
 642         if (IDATA1 == 0)
 643             break;
 644         /* If this is a simple endian swap, but the endian swap method is a no-op,
 645          * then indicate this is a no-op in a comment.
 646          */
 647         if (!current_is_complex && current_endianfun == NULL) {
 648             indent_me(fp);
 649             fprintf(fp, "/* a->%s%s[0..%d] = a->%s%s[0..%d] (no-op) */\n",
 650                     union_prefix, CDATA0, IDATA1 - 1,
 651                     union_prefix, CDATA0, IDATA1 - 1);
 652             break;
 653         }
 654
 655         indent_me(fp);
 656         fprintf(fp, "{\n");
 657         indent += 4;
 658         indent_me(fp);
 659         fprintf(fp, "int _i;\n");
 660         indent_me(fp);
 661         fprintf(fp, "for (_i = 0; _i < %d; _i++) {\n",
 662                 IDATA1);
 663         indent += 4;
 664         indent_me(fp);
 665         if (current_is_complex) {
 666             fprintf(fp,
 667                     "vl_api_%s_t_endian (a->%s%s[_i]);\n",
 668                     current_type_name, union_prefix, CDATA0);
 669         } else {
 670             fprintf(fp,
 671                     "a->%s%s[_i] = %s(a->%s%s[_i]);\n",
 672                     union_prefix, CDATA0,
 673                     current_endianfun,
 674                     union_prefix, CDATA0);
 675         }
 676         indent -= 4;
 677         indent_me(fp);
 678         fprintf(fp, "}\n");
 679         indent -= 4;
 680         indent_me(fp);
 681         fprintf(fp, "}\n");
 682         break;
 683     case PYTHON_PASS:
 684         if (CDATA2 != 0) { // variable length vector
 685             fprintf(fp, "'%s', '%d', '%s'),\n", CDATA0, IDATA1, CDATA2);
 686         } else {
 687             fprintf(fp, "'%s', '%d'),\n", CDATA0, IDATA1);
 688         }
 689         break;
 690
 691     case JSON_PASS:
 692       if (CDATA2 != 0) { /* variable length vector */
 693             fprintf(fp, "\"%s\", %d, \"%s\"]", CDATA0, IDATA1, CDATA2);
 694         } else {
 695             fprintf(fp, "\"%s\", %d]", CDATA0, IDATA1);
 696         }
 697         break;
 698
 699     default:
 700         fprintf(stderr, "node_vector_generate: unimp pass %d\n", which);
 701     }
 702     if (this->deeper) {
 703         fprintf(stderr, "broken recursion in node_vector_generate\n");
 704     }
 705 }
 706
 707 node_vft_t node_vector_vft = {
 708     node_vector_print,
 709     node_vector_generate,
 710     0,
 711 };
 712
 713 void node_complex_print (node_t *this)
 714 {
 715     primtype_recursive_print (this, "complex ");
 716 }
 717
 718 void node_complex_generate (node_t *this, enum passid which, FILE *fp)
 719 {
 720     node_t *deeper;
 721     node_vft_t *vftp;
 722     char *member_name = "broken!";
 723     char *union_prefix = "";
 724
 725     if (current_union_name) {
 726         sprintf(tmpbuf, "%s.", current_union_name);
 727         union_prefix = tmpbuf;
 728     }
 729
 730     current_is_complex++;
 731
 732     switch(which) {
 733     case TYPEDEF_PASS:
 734         fprintf(fp, "%s ", CDATA0);
 735         deeper = this->deeper;
 736         if (deeper) {
 737             vftp = the_vft[deeper->type];
 738             vftp->generate(deeper, which, fp);
 739         }
 740         break;
 741
 742     case PRINTFUN_PASS:
 743         deeper = this->deeper;
 744         while (deeper) {
 745             if (deeper->type == NODE_SCALAR ||
 746                 deeper->type == NODE_VECTOR) {
 747                 member_name = deeper->data[0];
 748                 break;
 749             }
 750             deeper = deeper->deeper;
 751         }
 752         indent_me(fp);
 753         fprintf(fp, "vl_print(handle, \"%s%s ----- \\n\");\n",
 754                 union_prefix, member_name);
 755         indent_me(fp);
 756         fprintf(fp, "%s_print(&a->%s%s, handle);\n",
 757                 CDATA0, union_prefix, member_name);
 758         indent_me(fp);
 759         fprintf(fp, "vl_print(handle, \"%s%s ----- END \\n\");\n",
 760                 union_prefix, member_name);
 761         break;
 762
 763     case ENDIANFUN_PASS:
 764         deeper = this->deeper;
 765         while (deeper) {
 766             if (deeper->type == NODE_SCALAR ||
 767                 deeper->type == NODE_VECTOR) {
 768                 member_name = deeper->data[0];
 769                 break;
 770             }
 771             deeper = deeper->deeper;
 772         }
 773
 774         indent_me(fp);
 775         fprintf(fp, "%s_endian(&a->%s%s);\n",
 776                 CDATA0, union_prefix, member_name);
 777         break;
 778     case PYTHON_PASS:
 779         fprintf(fp, "('%s',", CDATA0);
 780         deeper = this->deeper;
 781         if (deeper) {
 782             vftp = the_vft[deeper->type];
 783             vftp->generate(deeper, which, fp);
 784         }
 785         break;
 786
 787     case JSON_PASS:
 788         fprintf(fp, "[\"%s\", ", CDATA0);
 789         deeper = this->deeper;
 790         if (deeper) {
 791             vftp = the_vft[deeper->type];
 792             vftp->generate(deeper, which, fp);
 793         }
 794         break;
 795
 796     default:
 797         fprintf(stderr, "node_complex_generate unimp pass %d...\n", which);
 798         break;
 799     }
 800     current_is_complex--;
 801 }
 802
 803 node_vft_t node_complex_vft = {
 804     node_complex_print,
 805     node_complex_generate,
 806     0,
 807 };
 808
 809 void node_noversion_print (node_t *this)
 810 {
 811     primtype_recursive_print (this, "noversion ");
 812 }
 813
 814 void node_noversion_generate (node_t *this, enum passid which, FILE *ofp)
 815 {
 816     fprintf(stderr, "node_noversion_generate called...\n");
 817 }
 818
 819 node_vft_t node_noversion_vft = {
 820     node_noversion_print,
 821     node_noversion_generate,
 822     0,
 823 };
 824
 825 void node_uword_print (node_t *this)
 826 {
 827     primtype_recursive_print(this, "uword ");
 828 }
 829
 830 void node_uword_generate (node_t *this, enum passid which, FILE *ofp)
 831 {
 832     primtype_recursive_generate(this, which, ofp, "uword", "uword", "");
 833 }
 834
 835 node_vft_t node_uword_vft = {
 836     node_uword_print,
 837     node_uword_generate,
 838     "clib_net_to_host_uword",
 839 };
 840
 841 node_vft_t *the_vft[NODE_N_TYPES] = {
 842     &node_illegal_vft,
 843     &node_u8_vft,
 844     &node_u16_vft,
 845     &node_u32_vft,
 846     &node_u64_vft,
 847     &node_i8_vft,
 848     &node_i16_vft,
 849     &node_i32_vft,
 850     &node_i64_vft,
 851     &node_f64_vft,
 852     &node_packed_vft,
 853     &node_define_vft,
 854     &node_union_vft,
 855     &node_scalar_vft,
 856     &node_vector_vft,
 857     &node_complex_vft,
 858     &node_noversion_vft,
 859     &node_uword_vft,
 860 };
 861
 862 void *make_node (enum node_subclass type)
 863 {
 864     node_t *rv;
 865
 866     rv = (node_t *) malloc (sizeof (*rv));
 867     if (rv == 0) {
 868         fprintf (stderr, "fatal: make_node out of memory\n");
 869         exit (1);
 870     }
 871     bzero (rv, sizeof (*rv));
 872     rv->type = type;
 873     return ((void *) rv);
 874 }
 875
 876 YYSTYPE deeper (YYSTYPE arg1, YYSTYPE arg2)
 877 {
 878     node_t *np1 = (node_t *) arg1;
 879     node_t *np2 = (node_t *) arg2;
 880     node_t *hook_point;
 881
 882     hook_point = np1;
 883
 884     while (hook_point->deeper)
 885         hook_point = hook_point->deeper;
 886
 887     hook_point->deeper = np2;
 888     return (arg1);
 889 }
 890
 891 YYSTYPE addpeer (YYSTYPE arg1, YYSTYPE arg2)
 892 {
 893     node_t *np1 = (node_t *) arg1;
 894     node_t *np2 = (node_t *) arg2;
 895     node_t *hook_point;
 896
 897     hook_point = np1;
 898
 899     while (hook_point->peer)
 900         hook_point = hook_point->peer;
 901
 902     hook_point->peer = np2;
 903     return (arg1);
 904 }
 905
 906 /*
 907  * add_slist (stmt_list, stmt)
 908  */
 909
 910 YYSTYPE add_slist (YYSTYPE a1, YYSTYPE a2)
 911 {
 912     if (a1 && a2)
 913         return (addpeer(a1, a2));
 914     else if(a1)
 915         return(a1);
 916     else
 917         return(a2);
 918 }
 919
 920 /*
 921  * add_define (char *name, defn_list);
 922  */
 923 YYSTYPE add_define (YYSTYPE a1, YYSTYPE a2)
 924 {
 925     node_t *np;
 926
 927     np = make_node(NODE_DEFINE);
 928     np->data[0] = a1;
 929     np->data[3] = (void *) message_crc;
 930     deeper((YYSTYPE)np, a2);
 931     return ((YYSTYPE) np);
 932 }
 933
 934 /*
 935  * add_defbody (defn_list, new_defn)
 936  */
 937 YYSTYPE add_defbody (YYSTYPE a1, YYSTYPE a2)
 938 {
 939     return (addpeer(a1, a2));
 940 }
 941
 942 /*
 943  * add_primtype ([packed], primitive type, instance)
 944  */
 945
 946 YYSTYPE add_primtype (YYSTYPE a1, YYSTYPE a2, YYSTYPE a3)
 947 {
 948     node_t *np1;
 949
 950     np1 = (node_t *)a1;
 951
 952     /* Hook instance to type node */
 953     deeper (a1, a2);
 954     if (a3) {
 955         deeper(a1, a3);
 956     }
 957     return (a1);
 958 }
 959
 960 /*
 961  * add_complex(char *type_name, instance)
 962  */
 963
 964 YYSTYPE add_complex (YYSTYPE a1, YYSTYPE a2)
 965 {
 966     node_t *np;
 967
 968     np = make_node(NODE_COMPLEX);
 969     np->data[0] = (void *) a1;
 970
 971     deeper((YYSTYPE)np, a2);
 972     return ((YYSTYPE) np);
 973 }
 974
 975 /*
 976  * add_union(char *type_name, definition)
 977  */
 978
 979 YYSTYPE add_union (YYSTYPE a1, YYSTYPE a2)
 980 {
 981     node_t *np;
 982
 983     np = make_node(NODE_UNION);
 984     np->data[0] = (void *) a1;
 985
 986     deeper((YYSTYPE)np, a2);
 987     return ((YYSTYPE) np);
 988 }
 989
 990
 991 /*
 992  * add_vector_vbl (node_t *variable, YYSTYPE size)
 993  */
 994
 995 YYSTYPE add_vector_vbl (YYSTYPE a1, YYSTYPE a2)
 996 {
 997     node_t *np;
 998
 999     np = make_node(NODE_VECTOR);
1000     np->data[0] = (void *) a1;
1001     np->data[1] = (void *) a2;
1002     return ((YYSTYPE) np);
1003 }
1004
1005 /*
1006  * add_vector_vbl (char *vector_name, char *vector_length_var)
1007  */
1008
1009 YYSTYPE add_variable_length_vector_vbl (YYSTYPE vector_name, YYSTYPE vector_length_var)
1010 {
1011     node_t *np;
1012
1013     np = make_node(NODE_VECTOR);
1014     np->data[0] = (void *) vector_name;
1015     np->data[1] = (void *) 0; // vector size used for vpe.api.h generation (array of length zero)
1016     np->data[2] = (void *) vector_length_var; // name of the variable that stores vector length
1017     return ((YYSTYPE) np);
1018 }
1019
1020 /*
1021  * add_scalar_vbl (char *name)
1022  */
1023 YYSTYPE add_scalar_vbl (YYSTYPE a1)
1024 {
1025     node_t *np;
1026
1027     np = make_node(NODE_SCALAR);
1028     np->data[0] = (void *) a1;
1029     return ((YYSTYPE) np);
1030 }
1031
1032 /*
1033  * set_flags (int flags, msg(=0?))
1034  */
1035 YYSTYPE set_flags(YYSTYPE a1, YYSTYPE a2)
1036 {
1037     node_t *np;
1038     int flags;
1039
1040     np = (node_t *)a2;
1041     if (!np)
1042         return(0);
1043
1044     flags = (int)(uword) a1;
1045
1046     np->flags |= flags;
1047     return (a2);
1048 }
1049 /*
1050  * suppress_version
1051  */
1052 YYSTYPE suppress_version (void)
1053 {
1054     dont_output_version = 1;
1055     return (0);
1056 }
1057
1058 void dump(node_t *np)
1059 {
1060     node_vft_t *vftp;
1061
1062     while (np) {
1063         vftp = the_vft[np->type];
1064         vftp->print(np);
1065         np = np->peer;
1066     }
1067 }
1068
1069 char *fixup_input_filename(void)
1070 {
1071     char *cp;
1072
1073     cp = (char *)input_filename;
1074
1075     while (*cp)
1076         cp++;
1077
1078     cp--;
1079
1080     while (cp > input_filename && *cp != '/')
1081         cp--;
1082     if (*cp == '/')
1083         cp++;
1084
1085     strncpy (tmpbuf, cp, sizeof(tmpbuf)-1);
1086
1087     cp = tmpbuf;
1088
1089     while (*cp)
1090         cp++;
1091
1092     cp--;
1093
1094     while (cp > tmpbuf && *cp != '.')
1095         cp--;
1096
1097     if (*cp == '.')
1098         *cp = 0;
1099
1100     return (sxerox(tmpbuf));
1101 }
1102
1103 void generate_top_boilerplate(FILE *fp)
1104
1105 {
1106     char *datestring = ctime(&starttime);
1107     fixed_name = fixup_input_filename();
1108
1109     datestring[24] = 0;
1110
1111     fprintf (fp, "/*\n");
1112     fprintf (fp, " * VLIB API definitions %s\n", datestring);
1113     fprintf (fp, " * Input file: %s\n", input_filename);
1114     fprintf (fp, " * Automatically generated: please edit the input file ");
1115     fprintf (fp, "NOT this file!\n");
1116     fprintf (fp, " */\n\n");
1117     fprintf (fp, "#if defined(vl_msg_id)||defined(vl_union_id)||");
1118     fprintf (fp, "defined(vl_printfun) \\\n ||defined(vl_endianfun)||");
1119     fprintf (fp, " defined(vl_api_version)||defined(vl_typedefs) \\\n");
1120     fprintf (fp, " ||defined(vl_msg_name)||defined(vl_msg_name_crc_list)\n");
1121     fprintf (fp, "/* ok, something was selected */\n");
1122     fprintf (fp, "#else\n");
1123     fprintf (fp, "#warning no content included from %s\n", input_filename);
1124     fprintf (fp, "#endif\n\n");
1125     fprintf (fp, "#define VL_API_PACKED(x) x __attribute__ ((packed))\n\n");
1126 }
1127
1128 void generate_bottom_boilerplate(FILE *fp)
1129
1130 {
1131     fprintf (fp, "\n#ifdef vl_api_version\n");
1132
1133     if (dont_output_version) {
1134         fprintf (fp, "/* WARNING: API FILE VERSION CHECK DISABLED */\n");
1135         input_crc = 0;
1136     }
1137
1138     fprintf (fp, "vl_api_version(%s, 0x%08x)\n\n",
1139              fixed_name, (unsigned int)input_crc);
1140     fprintf (fp, "#endif\n\n");
1141 }
1142
1143 void generate_msg_ids(YYSTYPE a1, FILE *fp)
1144 {
1145     node_t *np = (node_t *)a1;
1146
1147     fprintf (fp, "\n/****** Message ID / handler enum ******/\n\n");
1148     fprintf (fp, "#ifdef vl_msg_id\n");
1149
1150     while (np) {
1151         if (np->type == NODE_DEFINE) {
1152             if (!(np->flags & NODE_FLAG_TYPEONLY)) {
1153                 fprintf (fp, "vl_msg_id(VL_API_%s, vl_api_%s_t_handler)\n",
1154                          uppercase(np->data[0]), (i8 *)np->data[0]);
1155             } else {
1156                 fprintf (fp, "/* typeonly: %s */\n", (i8 *)np->data[0]);
1157             }
1158         }
1159         np = np->peer;
1160     }
1161     fprintf (fp, "#endif\n");
1162
1163 }
1164
1165 void generate_msg_names(YYSTYPE a1, FILE *fp)
1166 {
1167     node_t *np = (node_t *)a1;
1168
1169     fprintf (fp, "\n/****** Message names ******/\n\n");
1170
1171     fprintf (fp, "#ifdef vl_msg_name\n");
1172
1173     while (np) {
1174         if (np->type == NODE_DEFINE) {
1175             if (!(np->flags & NODE_FLAG_TYPEONLY)) {
1176                 fprintf (fp, "vl_msg_name(vl_api_%s_t, %d)\n",
1177                          (i8 *) np->data[0],
1178                          (np->flags & NODE_FLAG_DONT_TRACE ? 0 : 1));
1179             } else {
1180                 fprintf (fp, "/* typeonly: %s */\n", (i8 *)np->data[0]);
1181             }
1182         }
1183         np = np->peer;
1184     }
1185     fprintf (fp, "#endif\n\n");
1186 }
1187
1188 void generate_msg_name_crc_list (YYSTYPE a1, FILE *fp)
1189 {
1190     node_t *np = (node_t *)a1;
1191     char *unique_suffix, *cp;
1192
1193     unique_suffix = sxerox(fixed_name);
1194
1195     cp = unique_suffix;
1196     while (*cp && (*cp != '.'))
1197         cp++;
1198     if (*cp == '.')
1199         *cp = 0;
1200
1201     fprintf (fp, "\n/****** Message name, crc list ******/\n\n");
1202
1203     fprintf (fp, "#ifdef vl_msg_name_crc_list\n");
1204     fprintf (fp, "#define foreach_vl_msg_name_crc_%s ", unique_suffix);
1205
1206     while (np) {
1207         if (np->type == NODE_DEFINE) {
1208             if (!(np->flags & NODE_FLAG_TYPEONLY)) {
1209                 fprintf (fp, "\\\n_(VL_API_%s, %s, %08x) ",
1210                          uppercase (np->data[0]), (i8 *) np->data[0],
1211                          (u32)(u64)np->data[3]);
1212             }
1213         }
1214         np = np->peer;
1215     }
1216     fprintf (fp, "\n#endif\n\n");
1217     free (unique_suffix);
1218 }
1219
1220 void generate_typedefs(YYSTYPE a1, FILE *fp)
1221 {
1222     node_t *np = (node_t *)a1;
1223     node_vft_t *vftp;
1224
1225     fprintf(fp, "\n/****** Typedefs *****/\n\n");
1226     fprintf(fp, "#ifdef vl_typedefs\n\n");
1227
1228     /* Walk the top-level node-list */
1229     while (np) {
1230         if (np->type == NODE_DEFINE) {
1231             /* Yeah, this is pedantic */
1232             vftp = the_vft[np->type];
1233             vftp->generate(np, TYPEDEF_PASS, fp);
1234         }
1235         np = np->peer;
1236     }
1237     fprintf(fp, "#endif /* vl_typedefs */\n\n");
1238 }
1239
1240 void union_walk_one_defn(node_t *np, FILE *fp)
1241 {
1242     node_t *vblp;
1243     node_t *uelem;
1244
1245     /* Walk the list of typed objects in this msg def */
1246     while (np) {
1247         if (np->type == NODE_UNION) {
1248             current_union_name = np->data[0];
1249             uelem = np->deeper;
1250
1251             /* Walk the list of objects in this union */
1252             while (uelem) {
1253                 vblp = uelem->deeper;
1254                 /* Drill down on each element, find the variable name */
1255                 while(vblp) {
1256                     if (vblp->type == NODE_SCALAR ||
1257                         vblp->type == NODE_VECTOR ||
1258                         vblp->type == NODE_COMPLEX) {
1259                         fprintf(ofp, "#define %s_",
1260                                 uppercase(current_def_name));
1261                         fprintf(ofp, "%s_", uppercase(current_union_name));
1262                         fprintf(ofp, "%s %d\n",uppercase(vblp->data[0]),
1263                                 current_id);
1264                         current_id++;
1265                         break;
1266                     }
1267                     vblp = vblp->deeper;
1268                 }
1269                 uelem = uelem->peer;
1270             }
1271             current_union_name = 0;
1272             current_id = 1;
1273         }
1274         np = np->peer;
1275     }
1276 }
1277
1278 void generate_uniondefs(YYSTYPE a1, FILE *fp)
1279 {
1280     node_t *np = (node_t *)a1;
1281
1282     fprintf(fp, "/****** Discriminated Union Definitions *****/\n\n");
1283     fprintf(fp, "#ifdef vl_union_id\n\n");
1284
1285     /* Walk the top-level node-list */
1286     while (np) {
1287         if (np->type == NODE_DEFINE) {
1288             current_id = 1;
1289             current_def_name = np->data[0];
1290             union_walk_one_defn(np->deeper, fp);
1291         }
1292         np = np->peer;
1293     }
1294     fprintf(fp, "\n#endif /* vl_union_id */\n\n");
1295 }
1296
1297 void generate_printfun(YYSTYPE a1, FILE *fp)
1298 {
1299     node_t *np = (node_t *)a1;
1300     node_vft_t *vftp;
1301
1302     fprintf(fp, "/****** Print functions *****/\n\n");
1303     fprintf(fp, "#ifdef vl_printfun\n\n");
1304
1305     fprintf(fp, "#ifdef LP64\n");
1306     fputs ("#define _uword_fmt \"%lld\"\n", fp);
1307     fputs ("#define _uword_cast (long long)\n", fp);
1308     fprintf(fp, "#else\n");
1309     fputs("#define _uword_fmt \"%ld\"\n", fp);
1310     fputs ("#define _uword_cast long\n", fp);
1311     fprintf(fp, "#endif\n\n");
1312
1313     /* Walk the top-level node-list */
1314     while (np) {
1315         if (np->type == NODE_DEFINE) {
1316             if (!(np->flags & NODE_FLAG_MANUAL_PRINT)) {
1317                 fprintf(fp,
1318        "static inline void *vl_api_%s_t_print (vl_api_%s_t *a,",
1319                         (i8 *)np->data[0], (i8 *) np->data[0]);
1320                 fprintf(fp, "void *handle)\n{\n");
1321                 /* output the message name */
1322                 fprintf(fp,
1323                     "    vl_print(handle, \"vl_api_%s_t:\\n\");\n",
1324                         (i8 *)np->data[0]);
1325
1326                 indent += 4;
1327                 /* Yeah, this is pedantic */
1328                 vftp = the_vft[np->type];
1329                 vftp->generate(np, PRINTFUN_PASS, fp);
1330                 fprintf(fp, "    return handle;\n");
1331                 fprintf(fp, "}\n\n");
1332                 indent -= 4;
1333             } else {
1334                 fprintf(fp, "/***** manual: vl_api_%s_t_print  *****/\n\n",
1335                         (i8 *) np->data[0]);
1336             }
1337         }
1338         np = np->peer;
1339     }
1340     fprintf(fp, "#endif /* vl_printfun */\n\n");
1341 }
1342
1343 void generate_endianfun(YYSTYPE a1, FILE *fp)
1344 {
1345     node_t *np = (node_t *)a1;
1346     node_vft_t *vftp;
1347
1348     fprintf(fp, "\n/****** Endian swap functions *****/\n\n");
1349     fprintf(fp, "#ifdef vl_endianfun\n\n");
1350     fprintf(fp, "#undef clib_net_to_host_uword\n");
1351     fprintf(fp, "#ifdef LP64\n");
1352     fprintf(fp, "#define clib_net_to_host_uword clib_net_to_host_u64\n");
1353     fprintf(fp, "#else\n");
1354     fprintf(fp, "#define clib_net_to_host_uword clib_net_to_host_u32\n");
1355     fprintf(fp, "#endif\n\n");
1356
1357     /* Walk the top-level node-list */
1358     while (np) {
1359         if (np->type == NODE_DEFINE) {
1360             if (!(np->flags & NODE_FLAG_MANUAL_ENDIAN)) {
1361                 fprintf(fp,
1362                "static inline void vl_api_%s_t_endian (vl_api_%s_t *a)\n{\n",
1363                         (i8 *) np->data[0], (i8 *) np->data[0]);
1364                 indent += 4;
1365                 /* Yeah, this is pedantic */
1366                 vftp = the_vft[np->type];
1367                 vftp->generate(np, ENDIANFUN_PASS, fp);
1368                 fprintf(fp, "}\n\n");
1369                 indent -= 4;
1370             } else {
1371                 fprintf(fp, "/***** manual: vl_api_%s_t_endian  *****/\n\n",
1372                         (i8 *) np->data[0]);
1373             }
1374         }
1375         np = np->peer;
1376     }
1377     fprintf(fp, "#endif /* vl_endianfun */\n\n");
1378 }
1379
1380 void add_msg_ids(YYSTYPE a1)
1381 {
1382     node_t *np = (node_t *)a1;
1383     node_t *new_u16;
1384     node_t *new_vbl;
1385
1386     /* Walk the top-level node-list */
1387     while (np) {
1388         if (np->type == NODE_DEFINE) {
1389             if (!(np->flags & NODE_FLAG_TYPEONLY)) {
1390                 /* add the parse tree for "u16 _vl_msg_id" */
1391                 new_u16 = make_node(NODE_U16);
1392                 new_u16->peer = np->deeper;
1393                 np->deeper = new_u16;
1394                 new_vbl = make_node(NODE_SCALAR);
1395                 new_vbl->data[0] = sxerox("_vl_msg_id");
1396                 new_u16->deeper = new_vbl;
1397             }
1398         }
1399         np = np->peer;
1400     }
1401 }
1402
1403 void generate_python_msg_definitions(YYSTYPE a1, FILE *fp)
1404 {
1405     node_t *np = (node_t *)a1;
1406     node_vft_t *vftp;
1407     fprintf (fp, "messages = [\n");
1408     /* Walk the top-level node-list */
1409     while (np) {
1410       if (np->type == NODE_DEFINE && !(np->flags & NODE_FLAG_TYPEONLY)) {
1411         /* Yeah, this is pedantic */
1412         vftp = the_vft[np->type];
1413         vftp->generate(np, PYTHON_PASS, fp);
1414       }
1415       np = np->peer;
1416     }
1417     fprintf (fp, "\n]\n");
1418 }
1419
1420 static bool
1421 is_typeonly_check(node_t *np, bool typeonly)
1422 {
1423   bool is_typeonly = (np->flags & NODE_FLAG_TYPEONLY);
1424   return (is_typeonly == typeonly);
1425 }
1426
1427 static void
1428 generate_json_definitions(YYSTYPE a1, FILE *fp, bool typeonly)
1429 {
1430     node_t *np = (node_t *)a1;
1431     node_vft_t *vftp;
1432     indent_me(fp);
1433     if (typeonly)
1434       fprintf (fp, "\"types\" : [\n");
1435     else
1436       fprintf (fp, "\"messages\" : [\n");
1437
1438     /* Walk the top-level node-list */
1439     bool comma = false;
1440     indent += 4;
1441     while (np) {
1442       if (np->type == NODE_DEFINE && is_typeonly_check(np, typeonly)) {
1443         /* Yeah, this is pedantic */
1444         vftp = the_vft[np->type];
1445         indent_me(fp);
1446         vftp->generate(np, JSON_PASS, fp);
1447         comma = true;
1448       }
1449       np = np->peer;
1450       if (comma && np &&
1451           np->type == NODE_DEFINE && is_typeonly_check(np, typeonly))
1452         fprintf (fp, ",\n");
1453
1454     }
1455     indent -= 4;
1456     fprintf (fp, "\n");
1457     indent_me(fp);
1458     fprintf(fp, "]");
1459 }
1460
1461 void generate_python_typeonly_definitions(YYSTYPE a1, FILE *fp)
1462 {
1463     node_t *np = (node_t *)a1;
1464     node_vft_t *vftp;
1465     fprintf (fp, "types = [\n");
1466     /* Walk the top-level node-list */
1467     while (np) {
1468       if (np->type == NODE_DEFINE && (np->flags & NODE_FLAG_TYPEONLY)) {
1469         vftp = the_vft[np->type];
1470         vftp->generate(np, PYTHON_PASS, fp);
1471       }
1472       np = np->peer;
1473     }
1474     fprintf (fp, "\n]\n");
1475 }
1476
1477 void generate_python(YYSTYPE a1, FILE *fp)
1478 {
1479     generate_python_typeonly_definitions(a1, fp);
1480     generate_python_msg_definitions(a1, fp);
1481
1482     /*
1483      * API CRC signature
1484      */
1485     fprintf (fp, "vl_api_version = 0x%08x\n\n", (unsigned int)input_crc);
1486 }
1487
1488 void generate_json(YYSTYPE a1, FILE *fp)
1489 {
1490     fprintf (fp, "{\n");
1491     indent += 4;
1492     generate_json_definitions(a1, fp, true);
1493     fprintf (fp, ",\n");
1494     generate_json_definitions(a1, fp, false);
1495
1496     /*
1497      * API CRC signature
1498      */
1499     fprintf (fp, ",\n\"vl_api_version\" :\"0x%08x\"\n",
1500              (unsigned int)input_crc);
1501     fprintf (fp, "}\n");
1502 }
1503
1504 void generate(YYSTYPE a1)
1505 {
1506     if (dump_tree) {
1507         dump((node_t *)a1);
1508     }
1509
1510     add_msg_ids(a1);
1511
1512     if (ofp) {
1513         generate_top_boilerplate(ofp);
1514
1515         generate_msg_ids(a1, ofp);
1516         generate_msg_names(a1, ofp);
1517         generate_msg_name_crc_list(a1, ofp);
1518         generate_typedefs(a1, ofp);
1519         generate_uniondefs(a1, ofp);
1520         generate_printfun(a1, ofp);
1521         generate_endianfun(a1, ofp);
1522
1523         generate_bottom_boilerplate(ofp);
1524     }
1525     if (pythonfp) {
1526       generate_python(a1, pythonfp);
1527     }
1528     if (jsonfp) {
1529       generate_json(a1, jsonfp);
1530     }
1531 }