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