src/tools/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;
 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
 757         if (deeper && deeper->type == NODE_VECTOR)
 758             fprintf(fp, "%s_print(a->%s%s, handle);\n",
 759                     CDATA0, union_prefix, member_name);
 760         else
 761             fprintf(fp, "%s_print(&a->%s%s, handle);\n",
 762                     CDATA0, union_prefix, member_name);
 763
 764         indent_me(fp);
 765         fprintf(fp, "vl_print(handle, \"%s%s ----- END \\n\");\n",
 766                 union_prefix, member_name);
 767         break;
 768
 769     case ENDIANFUN_PASS:
 770         deeper = this->deeper;
 771         while (deeper) {
 772             if (deeper->type == NODE_SCALAR ||
 773                 deeper->type == NODE_VECTOR) {
 774                 member_name = deeper->data[0];
 775                 break;
 776             }
 777             deeper = deeper->deeper;
 778         }
 779
 780         indent_me(fp);
 781         if (deeper && deeper->type == NODE_VECTOR)
 782             fprintf(fp, "%s_endian(a->%s%s);\n",
 783                     CDATA0, union_prefix, member_name);
 784         else
 785             fprintf(fp, "%s_endian(&a->%s%s);\n",
 786                     CDATA0, union_prefix, member_name);
 787         break;
 788     case PYTHON_PASS:
 789         fprintf(fp, "('%s',", CDATA0);
 790         deeper = this->deeper;
 791         if (deeper) {
 792             vftp = the_vft[deeper->type];
 793             vftp->generate(deeper, which, fp);
 794         }
 795         break;
 796
 797     case JSON_PASS:
 798         fprintf(fp, "[\"%s\", ", CDATA0);
 799         deeper = this->deeper;
 800         if (deeper) {
 801             vftp = the_vft[deeper->type];
 802             vftp->generate(deeper, which, fp);
 803         }
 804         break;
 805
 806     default:
 807         fprintf(stderr, "node_complex_generate unimp pass %d...\n", which);
 808         break;
 809     }
 810     current_is_complex--;
 811 }
 812
 813 node_vft_t node_complex_vft = {
 814     node_complex_print,
 815     node_complex_generate,
 816     0,
 817 };
 818
 819 void node_noversion_print (node_t *this)
 820 {
 821     primtype_recursive_print (this, "noversion ");
 822 }
 823
 824 void node_noversion_generate (node_t *this, enum passid which, FILE *ofp)
 825 {
 826     fprintf(stderr, "node_noversion_generate called...\n");
 827 }
 828
 829 node_vft_t node_noversion_vft = {
 830     node_noversion_print,
 831     node_noversion_generate,
 832     0,
 833 };
 834
 835 void node_uword_print (node_t *this)
 836 {
 837     primtype_recursive_print(this, "uword ");
 838 }
 839
 840 void node_uword_generate (node_t *this, enum passid which, FILE *ofp)
 841 {
 842     primtype_recursive_generate(this, which, ofp, "uword", "uword", "");
 843 }
 844
 845 node_vft_t node_uword_vft = {
 846     node_uword_print,
 847     node_uword_generate,
 848     "clib_net_to_host_uword",
 849 };
 850
 851 node_vft_t *the_vft[NODE_N_TYPES] = {
 852     &node_illegal_vft,
 853     &node_u8_vft,
 854     &node_u16_vft,
 855     &node_u32_vft,
 856     &node_u64_vft,
 857     &node_i8_vft,
 858     &node_i16_vft,
 859     &node_i32_vft,
 860     &node_i64_vft,
 861     &node_f64_vft,
 862     &node_packed_vft,
 863     &node_define_vft,
 864     &node_union_vft,
 865     &node_scalar_vft,
 866     &node_vector_vft,
 867     &node_complex_vft,
 868     &node_noversion_vft,
 869     &node_uword_vft,
 870 };
 871
 872 void *make_node (enum node_subclass type)
 873 {
 874     node_t *rv;
 875
 876     rv = (node_t *) malloc (sizeof (*rv));
 877     if (rv == 0) {
 878         fprintf (stderr, "fatal: make_node out of memory\n");
 879         exit (1);
 880     }
 881     bzero (rv, sizeof (*rv));
 882     rv->type = type;
 883     return ((void *) rv);
 884 }
 885
 886 YYSTYPE deeper (YYSTYPE arg1, YYSTYPE arg2)
 887 {
 888     node_t *np1 = (node_t *) arg1;
 889     node_t *np2 = (node_t *) arg2;
 890     node_t *hook_point;
 891
 892     hook_point = np1;
 893
 894     while (hook_point->deeper)
 895         hook_point = hook_point->deeper;
 896
 897     hook_point->deeper = np2;
 898     return (arg1);
 899 }
 900
 901 YYSTYPE addpeer (YYSTYPE arg1, YYSTYPE arg2)
 902 {
 903     node_t *np1 = (node_t *) arg1;
 904     node_t *np2 = (node_t *) arg2;
 905     node_t *hook_point;
 906
 907     hook_point = np1;
 908
 909     while (hook_point->peer)
 910         hook_point = hook_point->peer;
 911
 912     hook_point->peer = np2;
 913     return (arg1);
 914 }
 915
 916 /*
 917  * add_slist (stmt_list, stmt)
 918  */
 919
 920 YYSTYPE add_slist (YYSTYPE a1, YYSTYPE a2)
 921 {
 922     if (a1 && a2)
 923         return (addpeer(a1, a2));
 924     else if(a1)
 925         return(a1);
 926     else
 927         return(a2);
 928 }
 929
 930 /*
 931  * add_define (char *name, defn_list);
 932  */
 933 YYSTYPE add_define (YYSTYPE a1, YYSTYPE a2)
 934 {
 935     node_t *np;
 936
 937     np = make_node(NODE_DEFINE);
 938     np->data[0] = a1;
 939     np->data[3] = (void *) message_crc;
 940     deeper((YYSTYPE)np, a2);
 941     return ((YYSTYPE) np);
 942 }
 943
 944 /*
 945  * add_defbody (defn_list, new_defn)
 946  */
 947 YYSTYPE add_defbody (YYSTYPE a1, YYSTYPE a2)
 948 {
 949     return (addpeer(a1, a2));
 950 }
 951
 952 /*
 953  * add_primtype ([packed], primitive type, instance)
 954  */
 955
 956 YYSTYPE add_primtype (YYSTYPE a1, YYSTYPE a2, YYSTYPE a3)
 957 {
 958     /* Hook instance to type node */
 959     deeper (a1, a2);
 960     if (a3) {
 961         deeper(a1, a3);
 962     }
 963     return (a1);
 964 }
 965
 966 /*
 967  * add_complex(char *type_name, instance)
 968  */
 969
 970 YYSTYPE add_complex (YYSTYPE a1, YYSTYPE a2)
 971 {
 972     node_t *np;
 973
 974     np = make_node(NODE_COMPLEX);
 975     np->data[0] = (void *) a1;
 976
 977     deeper((YYSTYPE)np, a2);
 978     return ((YYSTYPE) np);
 979 }
 980
 981 /*
 982  * add_union(char *type_name, definition)
 983  */
 984
 985 YYSTYPE add_union (YYSTYPE a1, YYSTYPE a2)
 986 {
 987     node_t *np;
 988
 989     np = make_node(NODE_UNION);
 990     np->data[0] = (void *) a1;
 991
 992     deeper((YYSTYPE)np, a2);
 993     return ((YYSTYPE) np);
 994 }
 995
 996
 997 /*
 998  * add_vector_vbl (node_t *variable, YYSTYPE size)
 999  */
1000
1001 YYSTYPE add_vector_vbl (YYSTYPE a1, YYSTYPE a2)
1002 {
1003     node_t *np;
1004
1005     np = make_node(NODE_VECTOR);
1006     np->data[0] = (void *) a1;
1007     np->data[1] = (void *) a2;
1008     return ((YYSTYPE) np);
1009 }
1010
1011 /*
1012  * add_vector_vbl (char *vector_name, char *vector_length_var)
1013  */
1014
1015 YYSTYPE add_variable_length_vector_vbl (YYSTYPE vector_name, YYSTYPE vector_length_var)
1016 {
1017     node_t *np;
1018
1019     np = make_node(NODE_VECTOR);
1020     np->data[0] = (void *) vector_name;
1021     np->data[1] = (void *) 0; // vector size used for vpe.api.h generation (array of length zero)
1022     np->data[2] = (void *) vector_length_var; // name of the variable that stores vector length
1023     return ((YYSTYPE) np);
1024 }
1025
1026 /*
1027  * add_scalar_vbl (char *name)
1028  */
1029 YYSTYPE add_scalar_vbl (YYSTYPE a1)
1030 {
1031     node_t *np;
1032
1033     np = make_node(NODE_SCALAR);
1034     np->data[0] = (void *) a1;
1035     return ((YYSTYPE) np);
1036 }
1037
1038 /*
1039  * set_flags (int flags, msg(=0?))
1040  */
1041 YYSTYPE set_flags(YYSTYPE a1, YYSTYPE a2)
1042 {
1043     node_t *np;
1044     int flags;
1045
1046     np = (node_t *)a2;
1047     if (!np)
1048         return(0);
1049
1050     flags = (int)(uword) a1;
1051
1052     np->flags |= flags;
1053     return (a2);
1054 }
1055 /*
1056  * suppress_version
1057  */
1058 YYSTYPE suppress_version (void)
1059 {
1060     dont_output_version = 1;
1061     return (0);
1062 }
1063
1064 void dump(node_t *np)
1065 {
1066     node_vft_t *vftp;
1067
1068     while (np) {
1069         vftp = the_vft[np->type];
1070         vftp->print(np);
1071         np = np->peer;
1072     }
1073 }
1074
1075 char *fixup_input_filename(void)
1076 {
1077     char *cp;
1078
1079     cp = (char *)input_filename;
1080
1081     while (*cp)
1082         cp++;
1083
1084     cp--;
1085
1086     while (cp > input_filename && *cp != '/')
1087         cp--;
1088     if (*cp == '/')
1089         cp++;
1090
1091     strncpy (tmpbuf, cp, sizeof(tmpbuf)-1);
1092
1093     cp = tmpbuf;
1094
1095     while (*cp)
1096         cp++;
1097
1098     cp--;
1099
1100     while (cp > tmpbuf && *cp != '.')
1101         cp--;
1102
1103     if (*cp == '.')
1104         *cp = 0;
1105
1106     return (sxerox(tmpbuf));
1107 }
1108
1109 void generate_top_boilerplate(FILE *fp)
1110
1111 {
1112     char *datestring = ctime(&starttime);
1113     fixed_name = fixup_input_filename();
1114
1115     datestring[24] = 0;
1116
1117     fprintf (fp, "/*\n");
1118     fprintf (fp, " * VLIB API definitions %s\n", datestring);
1119     fprintf (fp, " * Input file: %s\n", input_filename);
1120     fprintf (fp, " * Automatically generated: please edit the input file ");
1121     fprintf (fp, "NOT this file!\n");
1122     fprintf (fp, " */\n\n");
1123     fprintf (fp, "#if defined(vl_msg_id)||defined(vl_union_id)||");
1124     fprintf (fp, "defined(vl_printfun) \\\n ||defined(vl_endianfun)||");
1125     fprintf (fp, " defined(vl_api_version)||defined(vl_typedefs) \\\n");
1126     fprintf (fp, " ||defined(vl_msg_name)||defined(vl_msg_name_crc_list)\n");
1127     fprintf (fp, "/* ok, something was selected */\n");
1128     fprintf (fp, "#else\n");
1129     fprintf (fp, "#warning no content included from %s\n", input_filename);
1130     fprintf (fp, "#endif\n\n");
1131     fprintf (fp, "#define VL_API_PACKED(x) x __attribute__ ((packed))\n\n");
1132 }
1133
1134 void generate_bottom_boilerplate(FILE *fp)
1135
1136 {
1137     fprintf (fp, "\n#ifdef vl_api_version\n");
1138
1139     if (dont_output_version) {
1140         fprintf (fp, "/* WARNING: API FILE VERSION CHECK DISABLED */\n");
1141         input_crc = 0;
1142     }
1143
1144     fprintf (fp, "vl_api_version(%s, 0x%08x)\n\n",
1145              fixed_name, (unsigned int)input_crc);
1146     fprintf (fp, "#endif\n\n");
1147 }
1148
1149 void generate_msg_ids(YYSTYPE a1, FILE *fp)
1150 {
1151     node_t *np = (node_t *)a1;
1152
1153     fprintf (fp, "\n/****** Message ID / handler enum ******/\n\n");
1154     fprintf (fp, "#ifdef vl_msg_id\n");
1155
1156     while (np) {
1157         if (np->type == NODE_DEFINE) {
1158             if (!(np->flags & NODE_FLAG_TYPEONLY)) {
1159                 fprintf (fp, "vl_msg_id(VL_API_%s, vl_api_%s_t_handler)\n",
1160                          uppercase(np->data[0]), (i8 *)np->data[0]);
1161             } else {
1162                 fprintf (fp, "/* typeonly: %s */\n", (i8 *)np->data[0]);
1163             }
1164         }
1165         np = np->peer;
1166     }
1167     fprintf (fp, "#endif\n");
1168
1169 }
1170
1171 void generate_msg_names(YYSTYPE a1, FILE *fp)
1172 {
1173     node_t *np = (node_t *)a1;
1174
1175     fprintf (fp, "\n/****** Message names ******/\n\n");
1176
1177     fprintf (fp, "#ifdef vl_msg_name\n");
1178
1179     while (np) {
1180         if (np->type == NODE_DEFINE) {
1181             if (!(np->flags & NODE_FLAG_TYPEONLY)) {
1182                 fprintf (fp, "vl_msg_name(vl_api_%s_t, %d)\n",
1183                          (i8 *) np->data[0],
1184                          (np->flags & NODE_FLAG_DONT_TRACE ? 0 : 1));
1185             } else {
1186                 fprintf (fp, "/* typeonly: %s */\n", (i8 *)np->data[0]);
1187             }
1188         }
1189         np = np->peer;
1190     }
1191     fprintf (fp, "#endif\n\n");
1192 }
1193
1194 void generate_msg_name_crc_list (YYSTYPE a1, FILE *fp)
1195 {
1196     node_t *np = (node_t *)a1;
1197     char *unique_suffix, *cp;
1198
1199     unique_suffix = sxerox(fixed_name);
1200
1201     cp = unique_suffix;
1202     while (*cp && (*cp != '.'))
1203         cp++;
1204     if (*cp == '.')
1205         *cp = 0;
1206
1207     fprintf (fp, "\n/****** Message name, crc list ******/\n\n");
1208
1209     fprintf (fp, "#ifdef vl_msg_name_crc_list\n");
1210     fprintf (fp, "#define foreach_vl_msg_name_crc_%s ", unique_suffix);
1211
1212     while (np) {
1213         if (np->type == NODE_DEFINE) {
1214             if (!(np->flags & NODE_FLAG_TYPEONLY)) {
1215                 fprintf (fp, "\\\n_(VL_API_%s, %s, %08x) ",
1216                          uppercase (np->data[0]), (i8 *) np->data[0],
1217                          (u32)(u64)np->data[3]);
1218             }
1219         }
1220         np = np->peer;
1221     }
1222     fprintf (fp, "\n#endif\n\n");
1223     free (unique_suffix);
1224 }
1225
1226 void generate_typedefs(YYSTYPE a1, FILE *fp)
1227 {
1228     node_t *np = (node_t *)a1;
1229     node_vft_t *vftp;
1230
1231     fprintf(fp, "\n/****** Typedefs *****/\n\n");
1232     fprintf(fp, "#ifdef vl_typedefs\n\n");
1233
1234     /* Walk the top-level node-list */
1235     while (np) {
1236         if (np->type == NODE_DEFINE) {
1237             /* Yeah, this is pedantic */
1238             vftp = the_vft[np->type];
1239             vftp->generate(np, TYPEDEF_PASS, fp);
1240         }
1241         np = np->peer;
1242     }
1243     fprintf(fp, "#endif /* vl_typedefs */\n\n");
1244 }
1245
1246 void union_walk_one_defn(node_t *np, FILE *fp)
1247 {
1248     node_t *vblp;
1249     node_t *uelem;
1250
1251     /* Walk the list of typed objects in this msg def */
1252     while (np) {
1253         if (np->type == NODE_UNION) {
1254             current_union_name = np->data[0];
1255             uelem = np->deeper;
1256
1257             /* Walk the list of objects in this union */
1258             while (uelem) {
1259                 vblp = uelem->deeper;
1260                 /* Drill down on each element, find the variable name */
1261                 while(vblp) {
1262                     if (vblp->type == NODE_SCALAR ||
1263                         vblp->type == NODE_VECTOR ||
1264                         vblp->type == NODE_COMPLEX) {
1265                         fprintf(ofp, "#define %s_",
1266                                 uppercase(current_def_name));
1267                         fprintf(ofp, "%s_", uppercase(current_union_name));
1268                         fprintf(ofp, "%s %d\n",uppercase(vblp->data[0]),
1269                                 current_id);
1270                         current_id++;
1271                         break;
1272                     }
1273                     vblp = vblp->deeper;
1274                 }
1275                 uelem = uelem->peer;
1276             }
1277             current_union_name = 0;
1278             current_id = 1;
1279         }
1280         np = np->peer;
1281     }
1282 }
1283
1284 void generate_uniondefs(YYSTYPE a1, FILE *fp)
1285 {
1286     node_t *np = (node_t *)a1;
1287
1288     fprintf(fp, "/****** Discriminated Union Definitions *****/\n\n");
1289     fprintf(fp, "#ifdef vl_union_id\n\n");
1290
1291     /* Walk the top-level node-list */
1292     while (np) {
1293         if (np->type == NODE_DEFINE) {
1294             current_id = 1;
1295             current_def_name = np->data[0];
1296             union_walk_one_defn(np->deeper, fp);
1297         }
1298         np = np->peer;
1299     }
1300     fprintf(fp, "\n#endif /* vl_union_id */\n\n");
1301 }
1302
1303 void generate_printfun(YYSTYPE a1, FILE *fp)
1304 {
1305     node_t *np = (node_t *)a1;
1306     node_vft_t *vftp;
1307
1308     fprintf(fp, "/****** Print functions *****/\n\n");
1309     fprintf(fp, "#ifdef vl_printfun\n\n");
1310
1311     fprintf(fp, "#ifdef LP64\n");
1312     fputs ("#define _uword_fmt \"%lld\"\n", fp);
1313     fputs ("#define _uword_cast (long long)\n", fp);
1314     fprintf(fp, "#else\n");
1315     fputs("#define _uword_fmt \"%ld\"\n", fp);
1316     fputs ("#define _uword_cast long\n", fp);
1317     fprintf(fp, "#endif\n\n");
1318
1319     /* Walk the top-level node-list */
1320     while (np) {
1321         if (np->type == NODE_DEFINE) {
1322             if (!(np->flags & NODE_FLAG_MANUAL_PRINT)) {
1323                 fprintf(fp,
1324        "static inline void *vl_api_%s_t_print (vl_api_%s_t *a,",
1325                         (i8 *)np->data[0], (i8 *) np->data[0]);
1326                 fprintf(fp, "void *handle)\n{\n");
1327                 /* output the message name */
1328                 fprintf(fp,
1329                     "    vl_print(handle, \"vl_api_%s_t:\\n\");\n",
1330                         (i8 *)np->data[0]);
1331
1332                 indent += 4;
1333                 /* Yeah, this is pedantic */
1334                 vftp = the_vft[np->type];
1335                 vftp->generate(np, PRINTFUN_PASS, fp);
1336                 fprintf(fp, "    return handle;\n");
1337                 fprintf(fp, "}\n\n");
1338                 indent -= 4;
1339             } else {
1340                 fprintf(fp, "/***** manual: vl_api_%s_t_print  *****/\n\n",
1341                         (i8 *) np->data[0]);
1342             }
1343         }
1344         np = np->peer;
1345     }
1346     fprintf(fp, "#endif /* vl_printfun */\n\n");
1347 }
1348
1349 void generate_endianfun(YYSTYPE a1, FILE *fp)
1350 {
1351     node_t *np = (node_t *)a1;
1352     node_vft_t *vftp;
1353
1354     fprintf(fp, "\n/****** Endian swap functions *****/\n\n");
1355     fprintf(fp, "#ifdef vl_endianfun\n\n");
1356     fprintf(fp, "#undef clib_net_to_host_uword\n");
1357     fprintf(fp, "#ifdef LP64\n");
1358     fprintf(fp, "#define clib_net_to_host_uword clib_net_to_host_u64\n");
1359     fprintf(fp, "#else\n");
1360     fprintf(fp, "#define clib_net_to_host_uword clib_net_to_host_u32\n");
1361     fprintf(fp, "#endif\n\n");
1362
1363     /* Walk the top-level node-list */
1364     while (np) {
1365         if (np->type == NODE_DEFINE) {
1366             if (!(np->flags & NODE_FLAG_MANUAL_ENDIAN)) {
1367                 fprintf(fp,
1368                "static inline void vl_api_%s_t_endian (vl_api_%s_t *a)\n{\n",
1369                         (i8 *) np->data[0], (i8 *) np->data[0]);
1370                 indent += 4;
1371                 /* Yeah, this is pedantic */
1372                 vftp = the_vft[np->type];
1373                 vftp->generate(np, ENDIANFUN_PASS, fp);
1374                 fprintf(fp, "}\n\n");
1375                 indent -= 4;
1376             } else {
1377                 fprintf(fp, "/***** manual: vl_api_%s_t_endian  *****/\n\n",
1378                         (i8 *) np->data[0]);
1379             }
1380         }
1381         np = np->peer;
1382     }
1383     fprintf(fp, "#endif /* vl_endianfun */\n\n");
1384 }
1385
1386 void add_msg_ids(YYSTYPE a1)
1387 {
1388     node_t *np = (node_t *)a1;
1389     node_t *new_u16;
1390     node_t *new_vbl;
1391
1392     /* Walk the top-level node-list */
1393     while (np) {
1394         if (np->type == NODE_DEFINE) {
1395             if (!(np->flags & NODE_FLAG_TYPEONLY)) {
1396                 /* add the parse tree for "u16 _vl_msg_id" */
1397                 new_u16 = make_node(NODE_U16);
1398                 new_u16->peer = np->deeper;
1399                 np->deeper = new_u16;
1400                 new_vbl = make_node(NODE_SCALAR);
1401                 new_vbl->data[0] = sxerox("_vl_msg_id");
1402                 new_u16->deeper = new_vbl;
1403             }
1404         }
1405         np = np->peer;
1406     }
1407 }
1408
1409 void generate_python_msg_definitions(YYSTYPE a1, FILE *fp)
1410 {
1411     node_t *np = (node_t *)a1;
1412     node_vft_t *vftp;
1413     fprintf (fp, "messages = [\n");
1414     /* Walk the top-level node-list */
1415     while (np) {
1416       if (np->type == NODE_DEFINE && !(np->flags & NODE_FLAG_TYPEONLY)) {
1417         /* Yeah, this is pedantic */
1418         vftp = the_vft[np->type];
1419         vftp->generate(np, PYTHON_PASS, fp);
1420       }
1421       np = np->peer;
1422     }
1423     fprintf (fp, "\n]\n");
1424 }
1425
1426 static bool
1427 is_typeonly_check(node_t *np, bool typeonly)
1428 {
1429   bool is_typeonly = (np->flags & NODE_FLAG_TYPEONLY);
1430   return (is_typeonly == typeonly);
1431 }
1432
1433 static void
1434 generate_json_definitions(YYSTYPE a1, FILE *fp, bool typeonly)
1435 {
1436     node_t *np = (node_t *)a1;
1437     node_vft_t *vftp;
1438     indent_me(fp);
1439     if (typeonly)
1440       fprintf (fp, "\"types\" : [\n");
1441     else
1442       fprintf (fp, "\"messages\" : [\n");
1443
1444     /* Walk the top-level node-list */
1445     bool comma = false;
1446     indent += 4;
1447     while (np) {
1448       if (np->type == NODE_DEFINE && is_typeonly_check(np, typeonly)) {
1449         /* Yeah, this is pedantic */
1450         vftp = the_vft[np->type];
1451         indent_me(fp);
1452         vftp->generate(np, JSON_PASS, fp);
1453         comma = true;
1454       }
1455       np = np->peer;
1456       if (comma && np &&
1457           np->type == NODE_DEFINE && is_typeonly_check(np, typeonly))
1458         fprintf (fp, ",\n");
1459
1460     }
1461     indent -= 4;
1462     fprintf (fp, "\n");
1463     indent_me(fp);
1464     fprintf(fp, "]");
1465 }
1466
1467 void generate_python_typeonly_definitions(YYSTYPE a1, FILE *fp)
1468 {
1469     node_t *np = (node_t *)a1;
1470     node_vft_t *vftp;
1471     fprintf (fp, "types = [\n");
1472     /* Walk the top-level node-list */
1473     while (np) {
1474       if (np->type == NODE_DEFINE && (np->flags & NODE_FLAG_TYPEONLY)) {
1475         vftp = the_vft[np->type];
1476         vftp->generate(np, PYTHON_PASS, fp);
1477       }
1478       np = np->peer;
1479     }
1480     fprintf (fp, "\n]\n");
1481 }
1482
1483 void generate_python(YYSTYPE a1, FILE *fp)
1484 {
1485     generate_python_typeonly_definitions(a1, fp);
1486     generate_python_msg_definitions(a1, fp);
1487
1488     /*
1489      * API CRC signature
1490      */
1491     fprintf (fp, "vl_api_version = 0x%08x\n\n", (unsigned int)input_crc);
1492 }
1493
1494 void generate_json(YYSTYPE a1, FILE *fp)
1495 {
1496     fprintf (fp, "{\n");
1497     indent += 4;
1498     generate_json_definitions(a1, fp, true);
1499     fprintf (fp, ",\n");
1500     generate_json_definitions(a1, fp, false);
1501
1502     /*
1503      * API CRC signature
1504      */
1505     fprintf (fp, ",\n\"vl_api_version\" :\"0x%08x\"\n",
1506              (unsigned int)input_crc);
1507     fprintf (fp, "}\n");
1508 }
1509
1510 void generate(YYSTYPE a1)
1511 {
1512     if (dump_tree) {
1513         dump((node_t *)a1);
1514     }
1515
1516     add_msg_ids(a1);
1517
1518     if (ofp) {
1519         generate_top_boilerplate(ofp);
1520
1521         generate_msg_ids(a1, ofp);
1522         generate_msg_names(a1, ofp);
1523         generate_msg_name_crc_list(a1, ofp);
1524         generate_typedefs(a1, ofp);
1525         generate_uniondefs(a1, ofp);
1526         generate_printfun(a1, ofp);
1527         generate_endianfun(a1, ofp);
1528
1529         generate_bottom_boilerplate(ofp);
1530     }
1531     if (pythonfp) {
1532       generate_python(a1, pythonfp);
1533     }
1534     if (jsonfp) {
1535       generate_json(a1, jsonfp);
1536     }
1537 }