blob: 1f9905baca14a822f37fe7154856d1d6693727f6 [file] [log] [blame]
Damjan Marion7cd468a2016-12-19 23:05:39 +01001/*
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
35FILE *ofp;
36FILE *pythonfp;
37FILE *jsonfp;
38time_t starttime;
39char *vlib_app_name;
40char *input_filename;
41node_vft_t *the_vft[NODE_N_TYPES];
42static int indent;
43static int dont_output_version;
44int dump_tree;
45static char *fixed_name;
46static char tmpbuf [MAXNAME];
47static char *current_def_name;
48static char *current_union_name;
49static char *current_type_fmt;
50static char *current_type_cast;
51static char current_id;
52static char current_is_complex;
53static char *current_endianfun;
54static char *current_type_name;
55
56void indent_me(FILE *ofp)
57{
58 int i;
59
60 for (i = 0; i < indent; i++)
61 putc(' ', ofp);
62}
63
64char *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
80char *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
96void 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
106void 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
152void node_illegal_print (node_t *this)
153{
154 fprintf(stderr, "node_illegal_print called\n");
155 exit(0);
156}
157
158void 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
164node_vft_t node_illegal_vft = {
165 node_illegal_print,
166 node_illegal_generate,
167 "illegal"
168};
169
170void node_u8_print (node_t *this)
171{
172 primtype_recursive_print(this, "u8 ");
173}
174
175void node_u8_generate (node_t *this, enum passid which, FILE *ofp)
176{
177 primtype_recursive_generate(this, which, ofp, "u8", "%u", "(unsigned)");
178}
179
180node_vft_t node_u8_vft = {
181 node_u8_print,
182 node_u8_generate,
183 NULL
184};
185
186void node_u16_print (node_t *this)
187{
188 primtype_recursive_print(this, "u16 ");
189}
190
191void node_u16_generate (node_t *this, enum passid which, FILE *ofp)
192{
193 primtype_recursive_generate(this, which, ofp, "u16", "%u", "(unsigned)");
194}
195
196node_vft_t node_u16_vft = {
197 node_u16_print,
198 node_u16_generate,
199 "clib_net_to_host_u16"
200};
201
202void node_u32_print (node_t *this)
203{
204 primtype_recursive_print(this, "u32 ");
205}
206
207void node_u32_generate (node_t *this, enum passid which, FILE *ofp)
208{
209 primtype_recursive_generate(this, which, ofp, "u32", "%u", "(unsigned)");
210}
211
212node_vft_t node_u32_vft = {
213 node_u32_print,
214 node_u32_generate,
215 "clib_net_to_host_u32",
216};
217
218void node_u64_print (node_t *this)
219{
220 primtype_recursive_print(this, "u64 ");
221}
222
223void 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
229node_vft_t node_u64_vft = {
230 node_u64_print,
231 node_u64_generate,
232 "clib_net_to_host_u64"
233};
234
235void node_i8_print (node_t *this)
236{
237 primtype_recursive_print(this, "i8 ");
238}
239
240void node_i8_generate (node_t *this, enum passid which, FILE *ofp)
241{
242 primtype_recursive_generate(this, which, ofp, "i8", "%d", "(int)");
243}
244
245node_vft_t node_i8_vft = {
246 node_i8_print,
247 node_i8_generate,
248 ""
249};
250
251void node_i16_print (node_t *this)
252{
253 primtype_recursive_print(this, "i16 ");
254}
255
256void node_i16_generate (node_t *this, enum passid which, FILE *ofp)
257{
258 primtype_recursive_generate(this, which, ofp, "i16", "%d", "(int)");
259}
260
261node_vft_t node_i16_vft = {
262 node_i16_print,
263 node_i16_generate,
264 "clib_net_to_host_u16"
265};
266
267void node_i32_print (node_t *this)
268{
269 primtype_recursive_print(this, "i32 ");
270}
271
272void node_i32_generate (node_t *this, enum passid which, FILE *ofp)
273{
274 primtype_recursive_generate(this, which, ofp, "i32", "%ld", "(long)");
275}
276
277node_vft_t node_i32_vft = {
278 node_i32_print,
279 node_i32_generate,
280 "clib_net_to_host_u32"
281};
282
283void node_i64_print (node_t *this)
284{
285 primtype_recursive_print(this, "i64 ");
286}
287
288void 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
294node_vft_t node_i64_vft = {
295 node_i64_print,
296 node_i64_generate,
297 "clib_net_to_host_u64"
298};
299
300void node_f64_print (node_t *this)
301{
302 primtype_recursive_print(this, "f64 ");
303}
304
305void 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
311node_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
318void node_packed_print (node_t *this)
319{
320 primtype_recursive_print (this, "packed ");
321}
322
323void node_packed_generate (node_t *this, enum passid which, FILE *ofp)
324{
325 primtype_recursive_generate(this, which, ofp, "PACKED", "", "");
326}
327
328node_vft_t node_packed_vft = {
329 node_packed_print,
330 node_packed_generate,
331 0,
332};
333
334void 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
345void 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);
Damjan Marion7bee80c2017-04-26 15:32:12 +0200400 fprintf (fp, "{\"crc\" : \"0x%08x\"}\n", (u32)(uword)CDATA3);
Damjan Marion7cd468a2016-12-19 23:05:39 +0100401 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
412node_vft_t node_define_vft = {
413 node_define_print,
414 node_define_generate,
415 0,
416};
417
418void node_union_print (node_t *this)
419{
420 primtype_recursive_print (this, "union ");
421}
422
423void 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
497node_vft_t node_union_vft = {
498 node_union_print,
499 node_union_generate,
500 0,
501};
502
503void node_scalar_print (node_t *this)
504{
505 fprintf(stdout, "%s", CDATA0);
506 primtype_recursive_print (this, "");
507}
508
509void 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
579node_vft_t node_scalar_vft = {
580 node_scalar_print,
581 node_scalar_generate,
582 0,
583};
584
585void node_vector_print (node_t *this)
586{
587 primtype_recursive_print (this, "vector ");
588}
589
590void 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
707node_vft_t node_vector_vft = {
708 node_vector_print,
709 node_vector_generate,
710 0,
711};
712
713void node_complex_print (node_t *this)
714{
715 primtype_recursive_print (this, "complex ");
716}
717
718void 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);
Dave Barach05472b62017-02-27 09:25:39 -0500756
Dave Baracha80ab842017-03-02 07:38:52 -0500757 if (deeper && deeper->type == NODE_VECTOR)
Dave Barach05472b62017-02-27 09:25:39 -0500758 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
Damjan Marion7cd468a2016-12-19 23:05:39 +0100764 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);
Dave Baracha80ab842017-03-02 07:38:52 -0500781 if (deeper && deeper->type == NODE_VECTOR)
Dave Barach05472b62017-02-27 09:25:39 -0500782 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);
Damjan Marion7cd468a2016-12-19 23:05:39 +0100787 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
813node_vft_t node_complex_vft = {
814 node_complex_print,
815 node_complex_generate,
816 0,
817};
818
819void node_noversion_print (node_t *this)
820{
821 primtype_recursive_print (this, "noversion ");
822}
823
824void node_noversion_generate (node_t *this, enum passid which, FILE *ofp)
825{
826 fprintf(stderr, "node_noversion_generate called...\n");
827}
828
829node_vft_t node_noversion_vft = {
830 node_noversion_print,
831 node_noversion_generate,
832 0,
833};
834
835void node_uword_print (node_t *this)
836{
837 primtype_recursive_print(this, "uword ");
838}
839
840void node_uword_generate (node_t *this, enum passid which, FILE *ofp)
841{
842 primtype_recursive_generate(this, which, ofp, "uword", "uword", "");
843}
844
845node_vft_t node_uword_vft = {
846 node_uword_print,
847 node_uword_generate,
848 "clib_net_to_host_uword",
849};
850
851node_vft_t *the_vft[NODE_N_TYPES] = {
852 &node_illegal_vft,
853 &node_u8_vft,
854 &node_u16_vft,
855 &node_u32_vft,
856 &node_u64_vft,
857 &node_i8_vft,
858 &node_i16_vft,
859 &node_i32_vft,
860 &node_i64_vft,
861 &node_f64_vft,
862 &node_packed_vft,
863 &node_define_vft,
864 &node_union_vft,
865 &node_scalar_vft,
866 &node_vector_vft,
867 &node_complex_vft,
868 &node_noversion_vft,
869 &node_uword_vft,
870};
871
872void *make_node (enum node_subclass type)
873{
874 node_t *rv;
875
876 rv = (node_t *) malloc (sizeof (*rv));
877 if (rv == 0) {
878 fprintf (stderr, "fatal: make_node out of memory\n");
879 exit (1);
880 }
881 bzero (rv, sizeof (*rv));
882 rv->type = type;
883 return ((void *) rv);
884}
885
886YYSTYPE deeper (YYSTYPE arg1, YYSTYPE arg2)
887{
888 node_t *np1 = (node_t *) arg1;
889 node_t *np2 = (node_t *) arg2;
890 node_t *hook_point;
891
892 hook_point = np1;
893
894 while (hook_point->deeper)
895 hook_point = hook_point->deeper;
896
897 hook_point->deeper = np2;
898 return (arg1);
899}
900
901YYSTYPE addpeer (YYSTYPE arg1, YYSTYPE arg2)
902{
903 node_t *np1 = (node_t *) arg1;
904 node_t *np2 = (node_t *) arg2;
905 node_t *hook_point;
906
907 hook_point = np1;
908
909 while (hook_point->peer)
910 hook_point = hook_point->peer;
911
912 hook_point->peer = np2;
913 return (arg1);
914}
915
916/*
917 * add_slist (stmt_list, stmt)
918 */
919
920YYSTYPE add_slist (YYSTYPE a1, YYSTYPE a2)
921{
922 if (a1 && a2)
923 return (addpeer(a1, a2));
924 else if(a1)
925 return(a1);
926 else
927 return(a2);
928}
929
930/*
931 * add_define (char *name, defn_list);
932 */
933YYSTYPE add_define (YYSTYPE a1, YYSTYPE a2)
934{
935 node_t *np;
936
937 np = make_node(NODE_DEFINE);
938 np->data[0] = a1;
939 np->data[3] = (void *) message_crc;
940 deeper((YYSTYPE)np, a2);
941 return ((YYSTYPE) np);
942}
943
944/*
945 * add_defbody (defn_list, new_defn)
946 */
947YYSTYPE add_defbody (YYSTYPE a1, YYSTYPE a2)
948{
949 return (addpeer(a1, a2));
950}
951
952/*
953 * add_primtype ([packed], primitive type, instance)
954 */
955
956YYSTYPE add_primtype (YYSTYPE a1, YYSTYPE a2, YYSTYPE a3)
957{
958 /* Hook instance to type node */
959 deeper (a1, a2);
960 if (a3) {
961 deeper(a1, a3);
962 }
963 return (a1);
964}
965
966/*
967 * add_complex(char *type_name, instance)
968 */
969
970YYSTYPE add_complex (YYSTYPE a1, YYSTYPE a2)
971{
972 node_t *np;
973
974 np = make_node(NODE_COMPLEX);
975 np->data[0] = (void *) a1;
976
977 deeper((YYSTYPE)np, a2);
978 return ((YYSTYPE) np);
979}
980
981/*
982 * add_union(char *type_name, definition)
983 */
984
985YYSTYPE add_union (YYSTYPE a1, YYSTYPE a2)
986{
987 node_t *np;
988
989 np = make_node(NODE_UNION);
990 np->data[0] = (void *) a1;
991
992 deeper((YYSTYPE)np, a2);
993 return ((YYSTYPE) np);
994}
995
996
997/*
998 * add_vector_vbl (node_t *variable, YYSTYPE size)
999 */
1000
1001YYSTYPE add_vector_vbl (YYSTYPE a1, YYSTYPE a2)
1002{
1003 node_t *np;
1004
1005 np = make_node(NODE_VECTOR);
1006 np->data[0] = (void *) a1;
1007 np->data[1] = (void *) a2;
1008 return ((YYSTYPE) np);
1009}
1010
1011/*
1012 * add_vector_vbl (char *vector_name, char *vector_length_var)
1013 */
1014
1015YYSTYPE add_variable_length_vector_vbl (YYSTYPE vector_name, YYSTYPE vector_length_var)
1016{
1017 node_t *np;
1018
1019 np = make_node(NODE_VECTOR);
1020 np->data[0] = (void *) vector_name;
1021 np->data[1] = (void *) 0; // vector size used for vpe.api.h generation (array of length zero)
1022 np->data[2] = (void *) vector_length_var; // name of the variable that stores vector length
1023 return ((YYSTYPE) np);
1024}
1025
1026/*
1027 * add_scalar_vbl (char *name)
1028 */
1029YYSTYPE add_scalar_vbl (YYSTYPE a1)
1030{
1031 node_t *np;
1032
1033 np = make_node(NODE_SCALAR);
1034 np->data[0] = (void *) a1;
1035 return ((YYSTYPE) np);
1036}
1037
1038/*
1039 * set_flags (int flags, msg(=0?))
1040 */
1041YYSTYPE set_flags(YYSTYPE a1, YYSTYPE a2)
1042{
1043 node_t *np;
1044 int flags;
1045
1046 np = (node_t *)a2;
1047 if (!np)
1048 return(0);
1049
1050 flags = (int)(uword) a1;
1051
1052 np->flags |= flags;
Dave Barach11b8dbf2017-04-24 10:46:54 -04001053
1054 /* Generate a foo_reply_t right here */
1055 if (flags & NODE_FLAG_AUTOREPLY)
1056 autoreply(np);
1057
Damjan Marion7cd468a2016-12-19 23:05:39 +01001058 return (a2);
1059}
1060/*
1061 * suppress_version
1062 */
1063YYSTYPE suppress_version (void)
1064{
1065 dont_output_version = 1;
1066 return (0);
1067}
1068
1069void dump(node_t *np)
1070{
1071 node_vft_t *vftp;
1072
1073 while (np) {
1074 vftp = the_vft[np->type];
1075 vftp->print(np);
1076 np = np->peer;
1077 }
1078}
1079
1080char *fixup_input_filename(void)
1081{
1082 char *cp;
1083
1084 cp = (char *)input_filename;
1085
1086 while (*cp)
1087 cp++;
1088
1089 cp--;
1090
1091 while (cp > input_filename && *cp != '/')
1092 cp--;
1093 if (*cp == '/')
1094 cp++;
1095
1096 strncpy (tmpbuf, cp, sizeof(tmpbuf)-1);
1097
1098 cp = tmpbuf;
1099
1100 while (*cp)
1101 cp++;
1102
1103 cp--;
1104
1105 while (cp > tmpbuf && *cp != '.')
1106 cp--;
1107
1108 if (*cp == '.')
1109 *cp = 0;
1110
1111 return (sxerox(tmpbuf));
1112}
1113
1114void generate_top_boilerplate(FILE *fp)
1115
1116{
Bernhard M. Wiedemann460ba3d2017-05-03 15:15:15 +02001117 time_t curtime;
1118 char *datestring;
1119 char *source_date_epoch;
1120 if ((source_date_epoch = getenv("SOURCE_DATE_EPOCH")) == NULL || (curtime = (time_t)strtol(source_date_epoch, NULL, 10)) <= 0)
1121 curtime = starttime;
1122 datestring = asctime(gmtime(&curtime));
Damjan Marion7cd468a2016-12-19 23:05:39 +01001123 fixed_name = fixup_input_filename();
1124
1125 datestring[24] = 0;
1126
1127 fprintf (fp, "/*\n");
1128 fprintf (fp, " * VLIB API definitions %s\n", datestring);
1129 fprintf (fp, " * Input file: %s\n", input_filename);
1130 fprintf (fp, " * Automatically generated: please edit the input file ");
1131 fprintf (fp, "NOT this file!\n");
1132 fprintf (fp, " */\n\n");
1133 fprintf (fp, "#if defined(vl_msg_id)||defined(vl_union_id)||");
1134 fprintf (fp, "defined(vl_printfun) \\\n ||defined(vl_endianfun)||");
1135 fprintf (fp, " defined(vl_api_version)||defined(vl_typedefs) \\\n");
1136 fprintf (fp, " ||defined(vl_msg_name)||defined(vl_msg_name_crc_list)\n");
1137 fprintf (fp, "/* ok, something was selected */\n");
1138 fprintf (fp, "#else\n");
1139 fprintf (fp, "#warning no content included from %s\n", input_filename);
1140 fprintf (fp, "#endif\n\n");
1141 fprintf (fp, "#define VL_API_PACKED(x) x __attribute__ ((packed))\n\n");
1142}
1143
1144void generate_bottom_boilerplate(FILE *fp)
1145
1146{
1147 fprintf (fp, "\n#ifdef vl_api_version\n");
1148
1149 if (dont_output_version) {
1150 fprintf (fp, "/* WARNING: API FILE VERSION CHECK DISABLED */\n");
1151 input_crc = 0;
1152 }
1153
1154 fprintf (fp, "vl_api_version(%s, 0x%08x)\n\n",
1155 fixed_name, (unsigned int)input_crc);
1156 fprintf (fp, "#endif\n\n");
1157}
1158
1159void generate_msg_ids(YYSTYPE a1, FILE *fp)
1160{
1161 node_t *np = (node_t *)a1;
1162
1163 fprintf (fp, "\n/****** Message ID / handler enum ******/\n\n");
1164 fprintf (fp, "#ifdef vl_msg_id\n");
1165
1166 while (np) {
1167 if (np->type == NODE_DEFINE) {
1168 if (!(np->flags & NODE_FLAG_TYPEONLY)) {
1169 fprintf (fp, "vl_msg_id(VL_API_%s, vl_api_%s_t_handler)\n",
1170 uppercase(np->data[0]), (i8 *)np->data[0]);
1171 } else {
1172 fprintf (fp, "/* typeonly: %s */\n", (i8 *)np->data[0]);
1173 }
1174 }
1175 np = np->peer;
1176 }
1177 fprintf (fp, "#endif\n");
1178
1179}
1180
1181void generate_msg_names(YYSTYPE a1, FILE *fp)
1182{
1183 node_t *np = (node_t *)a1;
1184
1185 fprintf (fp, "\n/****** Message names ******/\n\n");
1186
1187 fprintf (fp, "#ifdef vl_msg_name\n");
1188
1189 while (np) {
1190 if (np->type == NODE_DEFINE) {
1191 if (!(np->flags & NODE_FLAG_TYPEONLY)) {
1192 fprintf (fp, "vl_msg_name(vl_api_%s_t, %d)\n",
1193 (i8 *) np->data[0],
1194 (np->flags & NODE_FLAG_DONT_TRACE ? 0 : 1));
1195 } else {
1196 fprintf (fp, "/* typeonly: %s */\n", (i8 *)np->data[0]);
1197 }
1198 }
1199 np = np->peer;
1200 }
1201 fprintf (fp, "#endif\n\n");
1202}
1203
1204void generate_msg_name_crc_list (YYSTYPE a1, FILE *fp)
1205{
1206 node_t *np = (node_t *)a1;
1207 char *unique_suffix, *cp;
1208
1209 unique_suffix = sxerox(fixed_name);
1210
1211 cp = unique_suffix;
1212 while (*cp && (*cp != '.'))
1213 cp++;
1214 if (*cp == '.')
1215 *cp = 0;
1216
1217 fprintf (fp, "\n/****** Message name, crc list ******/\n\n");
1218
1219 fprintf (fp, "#ifdef vl_msg_name_crc_list\n");
1220 fprintf (fp, "#define foreach_vl_msg_name_crc_%s ", unique_suffix);
1221
1222 while (np) {
1223 if (np->type == NODE_DEFINE) {
1224 if (!(np->flags & NODE_FLAG_TYPEONLY)) {
1225 fprintf (fp, "\\\n_(VL_API_%s, %s, %08x) ",
1226 uppercase (np->data[0]), (i8 *) np->data[0],
Damjan Marion7bee80c2017-04-26 15:32:12 +02001227 (u32)(uword)np->data[3]);
Damjan Marion7cd468a2016-12-19 23:05:39 +01001228 }
1229 }
1230 np = np->peer;
1231 }
1232 fprintf (fp, "\n#endif\n\n");
1233 free (unique_suffix);
1234}
1235
1236void generate_typedefs(YYSTYPE a1, FILE *fp)
1237{
1238 node_t *np = (node_t *)a1;
1239 node_vft_t *vftp;
1240
1241 fprintf(fp, "\n/****** Typedefs *****/\n\n");
1242 fprintf(fp, "#ifdef vl_typedefs\n\n");
1243
1244 /* Walk the top-level node-list */
1245 while (np) {
1246 if (np->type == NODE_DEFINE) {
1247 /* Yeah, this is pedantic */
1248 vftp = the_vft[np->type];
1249 vftp->generate(np, TYPEDEF_PASS, fp);
1250 }
1251 np = np->peer;
1252 }
1253 fprintf(fp, "#endif /* vl_typedefs */\n\n");
1254}
1255
1256void union_walk_one_defn(node_t *np, FILE *fp)
1257{
1258 node_t *vblp;
1259 node_t *uelem;
1260
1261 /* Walk the list of typed objects in this msg def */
1262 while (np) {
1263 if (np->type == NODE_UNION) {
1264 current_union_name = np->data[0];
1265 uelem = np->deeper;
1266
1267 /* Walk the list of objects in this union */
1268 while (uelem) {
1269 vblp = uelem->deeper;
1270 /* Drill down on each element, find the variable name */
1271 while(vblp) {
1272 if (vblp->type == NODE_SCALAR ||
1273 vblp->type == NODE_VECTOR ||
1274 vblp->type == NODE_COMPLEX) {
1275 fprintf(ofp, "#define %s_",
1276 uppercase(current_def_name));
1277 fprintf(ofp, "%s_", uppercase(current_union_name));
1278 fprintf(ofp, "%s %d\n",uppercase(vblp->data[0]),
1279 current_id);
1280 current_id++;
1281 break;
1282 }
1283 vblp = vblp->deeper;
1284 }
1285 uelem = uelem->peer;
1286 }
1287 current_union_name = 0;
1288 current_id = 1;
1289 }
1290 np = np->peer;
1291 }
1292}
1293
1294void generate_uniondefs(YYSTYPE a1, FILE *fp)
1295{
1296 node_t *np = (node_t *)a1;
1297
1298 fprintf(fp, "/****** Discriminated Union Definitions *****/\n\n");
1299 fprintf(fp, "#ifdef vl_union_id\n\n");
1300
1301 /* Walk the top-level node-list */
1302 while (np) {
1303 if (np->type == NODE_DEFINE) {
1304 current_id = 1;
1305 current_def_name = np->data[0];
1306 union_walk_one_defn(np->deeper, fp);
1307 }
1308 np = np->peer;
1309 }
1310 fprintf(fp, "\n#endif /* vl_union_id */\n\n");
1311}
1312
1313void generate_printfun(YYSTYPE a1, FILE *fp)
1314{
1315 node_t *np = (node_t *)a1;
1316 node_vft_t *vftp;
1317
1318 fprintf(fp, "/****** Print functions *****/\n\n");
1319 fprintf(fp, "#ifdef vl_printfun\n\n");
1320
1321 fprintf(fp, "#ifdef LP64\n");
1322 fputs ("#define _uword_fmt \"%lld\"\n", fp);
1323 fputs ("#define _uword_cast (long long)\n", fp);
1324 fprintf(fp, "#else\n");
1325 fputs("#define _uword_fmt \"%ld\"\n", fp);
1326 fputs ("#define _uword_cast long\n", fp);
1327 fprintf(fp, "#endif\n\n");
1328
1329 /* Walk the top-level node-list */
1330 while (np) {
1331 if (np->type == NODE_DEFINE) {
1332 if (!(np->flags & NODE_FLAG_MANUAL_PRINT)) {
1333 fprintf(fp,
1334 "static inline void *vl_api_%s_t_print (vl_api_%s_t *a,",
1335 (i8 *)np->data[0], (i8 *) np->data[0]);
1336 fprintf(fp, "void *handle)\n{\n");
1337 /* output the message name */
1338 fprintf(fp,
1339 " vl_print(handle, \"vl_api_%s_t:\\n\");\n",
1340 (i8 *)np->data[0]);
1341
1342 indent += 4;
1343 /* Yeah, this is pedantic */
1344 vftp = the_vft[np->type];
1345 vftp->generate(np, PRINTFUN_PASS, fp);
1346 fprintf(fp, " return handle;\n");
1347 fprintf(fp, "}\n\n");
1348 indent -= 4;
1349 } else {
1350 fprintf(fp, "/***** manual: vl_api_%s_t_print *****/\n\n",
1351 (i8 *) np->data[0]);
1352 }
1353 }
1354 np = np->peer;
1355 }
1356 fprintf(fp, "#endif /* vl_printfun */\n\n");
1357}
1358
1359void generate_endianfun(YYSTYPE a1, FILE *fp)
1360{
1361 node_t *np = (node_t *)a1;
1362 node_vft_t *vftp;
1363
1364 fprintf(fp, "\n/****** Endian swap functions *****/\n\n");
1365 fprintf(fp, "#ifdef vl_endianfun\n\n");
1366 fprintf(fp, "#undef clib_net_to_host_uword\n");
1367 fprintf(fp, "#ifdef LP64\n");
1368 fprintf(fp, "#define clib_net_to_host_uword clib_net_to_host_u64\n");
1369 fprintf(fp, "#else\n");
1370 fprintf(fp, "#define clib_net_to_host_uword clib_net_to_host_u32\n");
1371 fprintf(fp, "#endif\n\n");
1372
1373 /* Walk the top-level node-list */
1374 while (np) {
1375 if (np->type == NODE_DEFINE) {
1376 if (!(np->flags & NODE_FLAG_MANUAL_ENDIAN)) {
1377 fprintf(fp,
1378 "static inline void vl_api_%s_t_endian (vl_api_%s_t *a)\n{\n",
1379 (i8 *) np->data[0], (i8 *) np->data[0]);
1380 indent += 4;
1381 /* Yeah, this is pedantic */
1382 vftp = the_vft[np->type];
1383 vftp->generate(np, ENDIANFUN_PASS, fp);
1384 fprintf(fp, "}\n\n");
1385 indent -= 4;
1386 } else {
1387 fprintf(fp, "/***** manual: vl_api_%s_t_endian *****/\n\n",
1388 (i8 *) np->data[0]);
1389 }
1390 }
1391 np = np->peer;
1392 }
1393 fprintf(fp, "#endif /* vl_endianfun */\n\n");
1394}
1395
1396void add_msg_ids(YYSTYPE a1)
1397{
1398 node_t *np = (node_t *)a1;
1399 node_t *new_u16;
1400 node_t *new_vbl;
1401
1402 /* Walk the top-level node-list */
1403 while (np) {
1404 if (np->type == NODE_DEFINE) {
1405 if (!(np->flags & NODE_FLAG_TYPEONLY)) {
1406 /* add the parse tree for "u16 _vl_msg_id" */
1407 new_u16 = make_node(NODE_U16);
1408 new_u16->peer = np->deeper;
1409 np->deeper = new_u16;
1410 new_vbl = make_node(NODE_SCALAR);
1411 new_vbl->data[0] = sxerox("_vl_msg_id");
1412 new_u16->deeper = new_vbl;
1413 }
1414 }
1415 np = np->peer;
1416 }
1417}
1418
1419void generate_python_msg_definitions(YYSTYPE a1, FILE *fp)
1420{
1421 node_t *np = (node_t *)a1;
1422 node_vft_t *vftp;
1423 fprintf (fp, "messages = [\n");
1424 /* Walk the top-level node-list */
1425 while (np) {
1426 if (np->type == NODE_DEFINE && !(np->flags & NODE_FLAG_TYPEONLY)) {
1427 /* Yeah, this is pedantic */
1428 vftp = the_vft[np->type];
1429 vftp->generate(np, PYTHON_PASS, fp);
1430 }
1431 np = np->peer;
1432 }
1433 fprintf (fp, "\n]\n");
1434}
1435
1436static bool
1437is_typeonly_check(node_t *np, bool typeonly)
1438{
1439 bool is_typeonly = (np->flags & NODE_FLAG_TYPEONLY);
1440 return (is_typeonly == typeonly);
1441}
1442
1443static void
1444generate_json_definitions(YYSTYPE a1, FILE *fp, bool typeonly)
1445{
1446 node_t *np = (node_t *)a1;
1447 node_vft_t *vftp;
1448 indent_me(fp);
1449 if (typeonly)
1450 fprintf (fp, "\"types\" : [\n");
1451 else
1452 fprintf (fp, "\"messages\" : [\n");
1453
1454 /* Walk the top-level node-list */
1455 bool comma = false;
1456 indent += 4;
1457 while (np) {
1458 if (np->type == NODE_DEFINE && is_typeonly_check(np, typeonly)) {
1459 /* Yeah, this is pedantic */
1460 vftp = the_vft[np->type];
1461 indent_me(fp);
1462 vftp->generate(np, JSON_PASS, fp);
1463 comma = true;
1464 }
1465 np = np->peer;
1466 if (comma && np &&
1467 np->type == NODE_DEFINE && is_typeonly_check(np, typeonly))
1468 fprintf (fp, ",\n");
1469
1470 }
1471 indent -= 4;
1472 fprintf (fp, "\n");
1473 indent_me(fp);
1474 fprintf(fp, "]");
1475}
1476
1477void generate_python_typeonly_definitions(YYSTYPE a1, FILE *fp)
1478{
1479 node_t *np = (node_t *)a1;
1480 node_vft_t *vftp;
1481 fprintf (fp, "types = [\n");
1482 /* Walk the top-level node-list */
1483 while (np) {
1484 if (np->type == NODE_DEFINE && (np->flags & NODE_FLAG_TYPEONLY)) {
1485 vftp = the_vft[np->type];
1486 vftp->generate(np, PYTHON_PASS, fp);
1487 }
1488 np = np->peer;
1489 }
1490 fprintf (fp, "\n]\n");
1491}
1492
1493void generate_python(YYSTYPE a1, FILE *fp)
1494{
1495 generate_python_typeonly_definitions(a1, fp);
1496 generate_python_msg_definitions(a1, fp);
1497
1498 /*
1499 * API CRC signature
1500 */
1501 fprintf (fp, "vl_api_version = 0x%08x\n\n", (unsigned int)input_crc);
1502}
1503
1504void generate_json(YYSTYPE a1, FILE *fp)
1505{
1506 fprintf (fp, "{\n");
1507 indent += 4;
1508 generate_json_definitions(a1, fp, true);
1509 fprintf (fp, ",\n");
1510 generate_json_definitions(a1, fp, false);
1511
1512 /*
1513 * API CRC signature
1514 */
1515 fprintf (fp, ",\n\"vl_api_version\" :\"0x%08x\"\n",
1516 (unsigned int)input_crc);
1517 fprintf (fp, "}\n");
1518}
1519
1520void generate(YYSTYPE a1)
1521{
1522 if (dump_tree) {
1523 dump((node_t *)a1);
1524 }
1525
1526 add_msg_ids(a1);
1527
1528 if (ofp) {
1529 generate_top_boilerplate(ofp);
1530
1531 generate_msg_ids(a1, ofp);
1532 generate_msg_names(a1, ofp);
1533 generate_msg_name_crc_list(a1, ofp);
1534 generate_typedefs(a1, ofp);
1535 generate_uniondefs(a1, ofp);
1536 generate_printfun(a1, ofp);
1537 generate_endianfun(a1, ofp);
1538
1539 generate_bottom_boilerplate(ofp);
1540 }
1541 if (pythonfp) {
1542 generate_python(a1, pythonfp);
1543 }
1544 if (jsonfp) {
1545 generate_json(a1, jsonfp);
1546 }
1547}