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