diff options
Diffstat (limited to 'vppapigen/node.c')
| -rw-r--r-- | vppapigen/node.c | 1997 |
1 files changed, 1997 insertions, 0 deletions
diff --git a/vppapigen/node.c b/vppapigen/node.c new file mode 100644 index 00000000000..b82816e2fcf --- /dev/null +++ b/vppapigen/node.c @@ -0,0 +1,1997 @@ +/* + *------------------------------------------------------------------ + * node.c - the api generator's semantic back-end + * + * Copyright (c) 2004-2009 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + *------------------------------------------------------------------ + */ + +#include <stdio.h> +#include <ctype.h> +#include <time.h> +#include <string.h> +#include <unistd.h> +#include <stdlib.h> +#include <vppinfra/vec.h> +#include <vppinfra/hash.h> + +#include "lex.h" +#include "node.h" + +#define YYSTYPE void * + +FILE *ofp; +FILE *javafp; +FILE *jnifp; +char *java_class; +time_t starttime; +char *vlib_app_name; +char *input_filename; +node_vft_t *the_vft[NODE_N_TYPES]; +static int indent; +static int dont_output_version; +int dump_tree; +static char *fixed_name; +static char tmpbuf [MAXNAME]; +static char *current_def_name; +static char *current_union_name; +static char *current_type_fmt; +static char *current_type_cast; +static char current_id; +static char current_is_complex; +static char *current_endianfun; +static char *current_type_name; +static int current_java_parameter_number; +static int current_java_emitted_parameter; +static int current_java_parameter_need_comma_space; +void *current_java_methodfun; +void *current_java_jnifun; + +void indent_me(FILE *ofp) +{ + int i; + + for (i = 0; i < indent; i++) + putc(' ', ofp); +} + +char *uppercase (char *s) +{ + char *cp; + + cp = tmpbuf; + + while (*s && (cp < tmpbuf + (sizeof(tmpbuf)-1))) { + if (*s >= 'a' && *s <= 'z') + *cp++ = *s++ - ('a' - 'A'); + else + *cp++ = *s++; + } + *cp = 0; + return(tmpbuf); +} + +char *lowercase (char *s) +{ + char *cp; + + cp = tmpbuf; + + while (*s && (cp < tmpbuf + (sizeof(tmpbuf)-1))) { + if (*s >= 'A' && *s <= 'Z') + *cp++ = *s++ + ('a' - 'A'); + else + *cp++ = *s++; + } + *cp = 0; + return(tmpbuf); +} + +/* + * javah maps foo_bar to foo_1bar for whatever freakin' reason + * So, adjust java names accordingly. + */ +char *java_name_mangle (void * name_arg) +{ + char * name = name_arg; + static u8 * s; + int i; + + vec_reset_length (s); + + s = format (s, "%s%c", name, 0); + + for (i = 0; i < vec_len(s); i++) + if (s[i] == '_') { + vec_delete (s, 1, i); + if (s[i] >= 'a' && s[i] <= 'z') + s[i] -= ('a' - 'A'); + } + vec_add1 (s, 0); + + return ((char *) s); +} + +void primtype_recursive_print(node_t *this, i8 *fmt) +{ + fputs((char *)fmt, stdout); + + if (this->deeper) { + node_vft_t *vftp = the_vft[this->deeper->type]; + vftp->print(this->deeper); + } +} + +void primtype_recursive_generate(node_t *this, enum passid which, FILE *ofp, + i8 *type_name, i8 *type_fmt, i8 *type_cast) +{ + node_vft_t *vftp; + + current_type_name = (char *)type_name; + current_type_cast = (char *)type_cast; + + switch(which) { + case TYPEDEF_PASS: + fputs((char *)type_name, ofp); + fputs(" ", ofp); + break; + + case PRINTFUN_PASS: + current_type_fmt = (char *)type_fmt; + break; + + case ENDIANFUN_PASS: + vftp = the_vft[this->type]; + current_endianfun = vftp->endian_converter; + break; + + case JAVA_METHOD_PASS: + vftp = the_vft[this->type]; + current_java_methodfun = vftp->java_method_function; + break; + + default: + fprintf(stderr, "primtype_recursive_generate: unimp pass %d\n", which); + break; + } + + if (this->deeper) { + vftp = the_vft[this->deeper->type]; + vftp->generate(this->deeper, which, ofp); + } +} + +void primtype_java_method (node_t * this, enum passid which, FILE *ofp, + char *java_type_name) +{ + node_t * deeper; + + deeper = this->deeper; + + /* We'll take care of _msg_id, client_index, and context ourselves */ + if (current_java_parameter_number++ < 3) { + if (!strncmp ((char *)(deeper->data[0]), "client_index", 12)) + return; + else if (!strncmp ((char *)(deeper->data[0]), "context", 7)) + return; + else if (!strncmp ((char *)(deeper->data[0]), "_vl_msg_id", 10)) + return; + } + + if (deeper->type == NODE_SCALAR) + fprintf (ofp, "%s %s", java_type_name, + java_name_mangle(deeper->data[0])); + else + fprintf (ofp, "%s [] %s", java_type_name, + java_name_mangle(deeper->data[0])); + + current_java_emitted_parameter = 1; +} + +void primtype_java_parameter (node_t * this, enum passid which, FILE *ofp, + char *java_type_name) +{ + node_t * deeper; + + deeper = this->deeper; + + /* We'll take care of _msg_id, client_index, and context ourselves */ + if (current_java_parameter_number++ < 3) { + if (!strncmp ((char *)(deeper->data[0]), "client_index", 12)) + return; + else if (!strncmp ((char *)(deeper->data[0]), "context", 7)) + return; + else if (!strncmp ((char *)(deeper->data[0]), "_vl_msg_id", 10)) + return; + } + if (current_java_parameter_need_comma_space) { + current_java_parameter_need_comma_space = 0; + fputs (", ", ofp); + } + + if (deeper->type == NODE_SCALAR) + fprintf (ofp, "%s %s", java_type_name, (char *)(deeper->data[0])); + else + fprintf (ofp, "%sArray %s", java_type_name, (char *)(deeper->data[0])); + + current_java_emitted_parameter = 1; +} + +void primtype_java_setup (node_t * this, enum passid which, FILE *ofp, + char *java_type_name, char *array_element_name) +{ + node_t * deeper; + + deeper = this->deeper; + + /* We'll take care of _msg_id, client_index, and context ourselves */ + if (current_java_parameter_number++ < 3) { + if (!strncmp ((char *)(deeper->data[0]), "client_index", 12)) + return; + else if (!strncmp ((char *)(deeper->data[0]), "context", 7)) + return; + else if (!strncmp ((char *)(deeper->data[0]), "_vl_msg_id", 10)) + return; + } + + if (deeper->type == NODE_VECTOR) { + indent_me(ofp); + fprintf (ofp, + "%s * %sP = (*env)->Get%sArrayElements (env, %s, NULL);\n", + java_type_name, (char *)(deeper->data[0]), + array_element_name, (char *)(deeper->data[0])); + } + + current_java_emitted_parameter = 1; +} + +void primtype_java_code (node_t * this, enum passid which, FILE *ofp, + char *java_type_name, char * swapper) +{ + node_t * deeper; + char * s; + + deeper = this->deeper; + + /* We'll take care of _msg_id, client_index, and context ourselves */ + if (current_java_parameter_number++ < 3) { + if (!strncmp ((char *)(deeper->data[0]), "client_index", 12)) + return; + else if (!strncmp ((char *)(deeper->data[0]), "context", 7)) + return; + else if (!strncmp ((char *)(deeper->data[0]), "_vl_msg_id", 10)) + return; + } + + indent_me(ofp); + + s = (char *)(deeper->data[0]); + + if (swapper == 0) { + if (deeper->type == NODE_VECTOR) + fprintf (ofp, "memcpy (mp->%s, %sP, sizeof (mp->%s));\n", + s, s, s); + else + fprintf (ofp, "mp->%s = %s;\n", s, s); + } else { + if (deeper->type == NODE_VECTOR) { + fprintf(ofp, "{\n"); + indent += 4; + indent_me(ofp); + fprintf(ofp, "int _i;\n"); + indent_me(ofp); + fprintf(ofp, "for (_i = 0; _i < %d; _i++) {\n", + (int)(u64)(deeper->data[1])); + indent += 4; + indent_me(ofp); + fprintf(ofp, "mp->%s[_i] = %s(%sP[_i]);\n", + s, swapper, s); + indent -= 4; + indent_me(ofp); + fprintf(ofp, "}\n"); + indent -= 4; + indent_me(ofp); + fprintf(ofp, "}\n"); + } else { + fprintf (ofp, "mp->%s = %s(%s);\n", s, swapper, s); + } + } + + current_java_emitted_parameter = 1; +} + +void primtype_java_teardown (node_t * this, enum passid which, FILE *ofp, + char * array_element_name) +{ + node_t * deeper; + + deeper = this->deeper; + + /* We'll take care of _msg_id, client_index, and context ourselves */ + if (current_java_parameter_number++ < 3) { + if (!strncmp ((char *)(deeper->data[0]), "client_index", 12)) + return; + else if (!strncmp ((char *)(deeper->data[0]), "context", 7)) + return; + else if (!strncmp ((char *)(deeper->data[0]), "_vl_msg_id", 10)) + return; + } + + if (deeper->type == NODE_VECTOR) { + indent_me(ofp); + fprintf (ofp, + "(*env)->Release%sArrayElements (env, %s, %sP, 0);\n", + array_element_name, + (char *)(deeper->data[0]), + (char *)(deeper->data[0])); + } + + current_java_emitted_parameter = 1; +} + +void node_illegal_print (node_t *this) +{ + fprintf(stderr, "node_illegal_print called\n"); + exit(0); +} + +void node_illegal_generate (node_t *this, enum passid notused, FILE *ofp) +{ + fprintf(stderr, "node_illegal_generate called\n"); + exit(0); +} + +void node_illegal_java_method (node_t *this, enum passid notused, FILE *ofp) +{ + fprintf(stderr, "node_illegal_java_method called\n"); + exit(0); +} + +void node_illegal_java_jni (node_t *this, enum passid notused, FILE *ofp) +{ + fprintf(stderr, "node_illegal_java_jni called\n"); + exit(0); +} + +node_vft_t node_illegal_vft = { + node_illegal_print, + node_illegal_generate, + "illegal", + node_illegal_java_method, + node_illegal_java_jni, +}; + +void node_u8_print (node_t *this) +{ + primtype_recursive_print(this, "u8 "); +} + +void node_u8_generate (node_t *this, enum passid which, FILE *ofp) +{ + primtype_recursive_generate(this, which, ofp, "u8", "%u", "(unsigned)"); +} + +void node_u8_java_method (node_t *this, enum passid which, FILE *ofp) +{ + primtype_java_method (this, which, ofp, "byte"); +} + +void node_u8_java_parameter (node_t *this, enum passid which, FILE *ofp) +{ + primtype_java_parameter (this, which, ofp, "jbyte"); +} + +void node_u8_java_setup (node_t *this, enum passid which, FILE *ofp) +{ + primtype_java_setup (this, which, ofp, "jbyte", "Byte"); +} + +void node_u8_java_code (node_t *this, enum passid which, FILE *ofp) +{ + primtype_java_code (this, which, ofp, "jbyte", 0 /* swapper */); +} + +void node_u8_java_teardown (node_t *this, enum passid which, FILE *ofp) +{ + primtype_java_teardown (this, which, ofp, "Byte"); +} + +node_vft_t node_u8_vft = { + node_u8_print, + node_u8_generate, + "", + node_u8_java_method, + node_u8_java_parameter, + node_u8_java_setup, + node_u8_java_code, + node_u8_java_teardown, +}; + +void node_u16_print (node_t *this) +{ + primtype_recursive_print(this, "u16 "); +} + +void node_u16_generate (node_t *this, enum passid which, FILE *ofp) +{ + primtype_recursive_generate(this, which, ofp, "u16", "%u", "(unsigned)"); +} + +void node_u16_java_method (node_t *this, enum passid which, FILE *ofp) +{ + primtype_java_method (this, which, ofp, "short"); +} + +void node_u16_java_parameter (node_t *this, enum passid which, FILE *ofp) +{ + primtype_java_parameter (this, which, ofp, "jshort"); +} + +void node_u16_java_setup (node_t *this, enum passid which, FILE *ofp) +{ + primtype_java_setup (this, which, ofp, "jshort", "Short"); +} + +void node_u16_java_code (node_t *this, enum passid which, FILE *ofp) +{ + primtype_java_code (this, which, ofp, "jshort", "clib_host_to_net_u16"); +} + +void node_u16_java_teardown (node_t *this, enum passid which, FILE *ofp) +{ + primtype_java_teardown (this, which, ofp, "Short"); +} + +node_vft_t node_u16_vft = { + node_u16_print, + node_u16_generate, + "clib_net_to_host_u16", + node_u16_java_method, + node_u16_java_parameter, + node_u16_java_setup, + node_u16_java_code, + node_u16_java_teardown, +}; + +void node_u32_print (node_t *this) +{ + primtype_recursive_print(this, "u32 "); +} + +void node_u32_generate (node_t *this, enum passid which, FILE *ofp) +{ + primtype_recursive_generate(this, which, ofp, "u32", "%u", "(unsigned)"); +} + +void node_u32_java_method (node_t *this, enum passid which, FILE *ofp) +{ + primtype_java_method (this, which, ofp, "int"); +} + +void node_u32_java_parameter (node_t *this, enum passid which, FILE *ofp) +{ + primtype_java_parameter (this, which, ofp, "jint"); +} + +void node_u32_java_setup (node_t *this, enum passid which, FILE *ofp) +{ + primtype_java_setup (this, which, ofp, "jint", "Int"); +} + +void node_u32_java_code (node_t *this, enum passid which, FILE *ofp) +{ + primtype_java_code (this, which, ofp, "jint", "clib_host_to_net_u32"); +} + +void node_u32_java_teardown (node_t *this, enum passid which, FILE *ofp) +{ + primtype_java_teardown (this, which, ofp, "Int"); +} + +node_vft_t node_u32_vft = { + node_u32_print, + node_u32_generate, + "clib_net_to_host_u32", + node_u32_java_method, + node_u32_java_parameter, + node_u32_java_setup, + node_u32_java_code, + node_u32_java_teardown, +}; + +void node_u64_print (node_t *this) +{ + primtype_recursive_print(this, "u64 "); +} + +void node_u64_generate (node_t *this, enum passid which, FILE *ofp) +{ + primtype_recursive_generate(this, which, ofp, "u64", "%llu", + "(long long)"); +} + +void node_u64_java_method (node_t *this, enum passid which, FILE *ofp) +{ + primtype_java_method (this, which, ofp, "long"); +} + +void node_u64_java_parameter (node_t *this, enum passid which, FILE *ofp) +{ + primtype_java_parameter (this, which, ofp, "jlong"); +} + +void node_u64_java_setup (node_t *this, enum passid which, FILE *ofp) +{ + primtype_java_setup (this, which, ofp, "jlong", "Long"); +} + +void node_u64_java_code (node_t *this, enum passid which, FILE *ofp) +{ + primtype_java_code (this, which, ofp, "jlong", "clib_host_to_net_u64"); +} + +void node_u64_java_teardown (node_t *this, enum passid which, FILE *ofp) +{ + primtype_java_teardown (this, which, ofp, "Long"); +} + +node_vft_t node_u64_vft = { + node_u64_print, + node_u64_generate, + "clib_net_to_host_u64", + node_u64_java_method, + node_u64_java_parameter, + node_u64_java_setup, + node_u64_java_code, + node_u64_java_teardown, +}; + +void node_i8_print (node_t *this) +{ + primtype_recursive_print(this, "i8 "); +} + +void node_i8_generate (node_t *this, enum passid which, FILE *ofp) +{ + primtype_recursive_generate(this, which, ofp, "i8", "%d", "(int)"); +} + +node_vft_t node_i8_vft = { + node_i8_print, + node_i8_generate, + "", + node_u8_java_method, + node_u8_java_parameter, + node_u8_java_setup, + node_u8_java_code, + node_u8_java_teardown, +}; + +void node_i16_print (node_t *this) +{ + primtype_recursive_print(this, "i16 "); +} + +void node_i16_generate (node_t *this, enum passid which, FILE *ofp) +{ + primtype_recursive_generate(this, which, ofp, "i16", "%d", "(int)"); +} + +node_vft_t node_i16_vft = { + node_i16_print, + node_i16_generate, + "clib_net_to_host_u16", + node_u16_java_method, + node_u16_java_parameter, + node_u16_java_setup, + node_u16_java_code, + node_u16_java_teardown, +}; + +void node_i32_print (node_t *this) +{ + primtype_recursive_print(this, "i32 "); +} + +void node_i32_generate (node_t *this, enum passid which, FILE *ofp) +{ + primtype_recursive_generate(this, which, ofp, "i32", "%ld", "(long)"); +} + +node_vft_t node_i32_vft = { + node_i32_print, + node_i32_generate, + "clib_net_to_host_u32", + node_u32_java_method, + node_u32_java_parameter, + node_u32_java_setup, + node_u32_java_code, + node_u32_java_teardown, +}; + +void node_i64_print (node_t *this) +{ + primtype_recursive_print(this, "i64 "); +} + +void node_i64_generate (node_t *this, enum passid which, FILE *ofp) +{ + primtype_recursive_generate(this, which, ofp, "i64", "%lld", + "(long long)"); +} + +node_vft_t node_i64_vft = { + node_i64_print, + node_i64_generate, + "clib_net_to_host_u64", + node_u64_java_method, + node_u64_java_parameter, + node_u64_java_setup, + node_u64_java_code, + node_u64_java_teardown, +}; + +void node_f64_print (node_t *this) +{ + primtype_recursive_print(this, "f64 "); +} + +void node_f64_generate (node_t *this, enum passid which, FILE *ofp) +{ + primtype_recursive_generate(this, which, ofp, "f64", "%.2f", + "(double)"); +} +void node_f64_java_method (node_t *this, enum passid which, FILE *ofp) +{ + primtype_java_method (this, which, ofp, "double"); +} + +void node_f64_java_parameter (node_t *this, enum passid which, FILE *ofp) +{ + primtype_java_parameter (this, which, ofp, "jdouble"); +} + +void node_f64_java_setup (node_t *this, enum passid which, FILE *ofp) +{ + primtype_java_setup (this, which, ofp, "jdouble", "Double"); +} + +void node_f64_java_code (node_t *this, enum passid which, FILE *ofp) +{ + /* + * Current API code doesn't try to endian-swap doubles + * FP formats aren't portable yadda yadda yadda + */ + primtype_java_code (this, which, ofp, "jdouble", 0 /* $$$ */); +} + +void node_f64_java_teardown (node_t *this, enum passid which, FILE *ofp) +{ + primtype_java_teardown (this, which, ofp, "Double"); +} + +node_vft_t node_f64_vft = { + node_f64_print, + node_f64_generate, + " ", /* FP numbers are sent in host byte order */ + node_f64_java_method, + node_f64_java_parameter, + node_f64_java_setup, + node_f64_java_code, + node_f64_java_teardown, +}; + + +void node_packed_print (node_t *this) +{ + primtype_recursive_print (this, "packed "); +} + +void node_packed_generate (node_t *this, enum passid which, FILE *ofp) +{ + primtype_recursive_generate(this, which, ofp, "PACKED", "", ""); +} + +node_vft_t node_packed_vft = { + node_packed_print, + node_packed_generate, + 0, +}; + +void node_define_print (node_t *this) +{ + fprintf(stdout, "define %s {\n", CDATA0); + if (this->deeper) { + node_vft_t *vftp = the_vft[this->deeper->type]; + fprintf(stdout, " "); + vftp->print(this->deeper); + } + fprintf(stdout, "};\n"); +} + +void node_define_generate (node_t *this, enum passid which, FILE *fp) +{ + node_t *child, *save_child; + + switch(which) { + case TYPEDEF_PASS: + fprintf(fp, "typedef VL_API_PACKED(struct _vl_api_%s {\n", CDATA0); + child = this->deeper; + indent += 4; + while (child) { + node_vft_t *vftp = the_vft[child->type]; + indent_me(fp); + vftp->generate(child, which, fp); + child = child->peer; + } + indent -= 4; + fprintf(fp, "}) vl_api_%s_t;\n\n", CDATA0); + break; + + case ENDIANFUN_PASS: + case PRINTFUN_PASS: + child = this->deeper; + while (child) { + node_vft_t *vftp = the_vft[child->type]; + vftp->generate(child, which, fp); + child = child->peer; + } + break; + + case JAVA_METHOD_PASS: + indent += 4; + indent_me(fp); + fprintf (fp, "public native int %s (", + java_name_mangle(CDATA0)); + child = this->deeper; + while (child) { + node_vft_t *vftp = the_vft[child->type]; + current_java_emitted_parameter = 0; + vftp->java_method_function(child, which, fp); + child = child->peer; + if (child && current_java_emitted_parameter) + fputs (", ", fp); + } + fprintf (fp, ");\n"); + indent -= 4; + break; + + case JAVA_JNI_PASS: + /* Generate function prototype */ + fprintf (fp, "JNIEXPORT jint JNICALL Java_org_openvpp_vppjapi_%s_%s\n", + java_class, java_name_mangle(CDATA0)); + + fprintf (fp, "(JNIEnv * env, jobject obj"); + current_java_parameter_need_comma_space = 1; + child = this->deeper; + save_child = child; + while (child) { + node_vft_t *vftp = the_vft[child->type]; + current_java_emitted_parameter = 0; + vftp->java_jni_parameter(child, which, fp); + child = child->peer; + if (child && current_java_emitted_parameter) + fputs (", ", fp); + } + fprintf (fp, ")\n{\n"); + indent += 4; + + /* define the api message pointer */ + indent_me(fp); + fprintf (fp, "vppjni_main_t *jm = &vppjni_main;\n"); + indent_me(fp); + fprintf (fp, "vl_api_%s_t * mp;\n", current_def_name); + indent_me(fp); + fprintf (fp, "u32 my_context_id;\n"); + indent_me(fp); + fprintf (fp, "int rv;\n"); + + indent_me(fp); + fprintf (fp, "rv = vppjni_sanity_check (jm);\n"); + indent_me(fp); + fprintf (fp, "if (rv) return rv;\n"); + + indent_me(fp); + fprintf (fp, "my_context_id = vppjni_get_context_id (jm);\n"); + + /* Generate array setups, if any */ + child = save_child; + while (child) { + node_vft_t *vftp = the_vft[child->type]; + current_java_parameter_number = 0; + current_java_emitted_parameter = 0; + vftp->java_jni_setup(child, which, fp); + child = child->peer; + } + + /* Setup the API message */ + indent_me(fp); + fprintf (fp, "M(%s, %s);\n", uppercase(current_def_name), + current_def_name); + indent_me(fp); + fprintf (fp, "mp->context = clib_host_to_net_u32 (my_context_id);\n"); + /* $$$ Set up context hash table or some such... */ + + /* Generate code */ + child = save_child; + while (child) { + node_vft_t *vftp = the_vft[child->type]; + current_java_parameter_number = 0; + current_java_emitted_parameter = 0; + vftp->java_jni_code(child, which, fp); + child = child->peer; + } + + /* Generate array teardowns */ + child = save_child; + while (child) { + node_vft_t *vftp = the_vft[child->type]; + current_java_parameter_number = 0; + current_java_emitted_parameter = 0; + vftp->java_jni_teardown(child, which, fp); + child = child->peer; + } + + /* Send the message, return context_id */ + indent_me (fp); + fprintf (fp, "S;\n"); + indent_me (fp); + fprintf (fp, "return my_context_id;\n"); + + indent -= 4; + fprintf (fp, "}\n\n"); + break; + + default: + fprintf(stderr, "node_define_generate: unimp pass %d\n", which); + break; + } +} + +node_vft_t node_define_vft = { + node_define_print, + node_define_generate, + 0, +}; + +void node_union_print (node_t *this) +{ + primtype_recursive_print (this, "union "); +} + +void node_union_generate (node_t *this, enum passid which, FILE *fp) +{ + node_t *child; + node_t *uelem; + int case_id=1; + + switch(which) { + case TYPEDEF_PASS: + fprintf(fp, "u8 _%s_which;\n", CDATA0); + indent_me(fp); + fprintf(fp, "union _%s {\n", CDATA0); + child = this->deeper; + indent += 4; + + while (child) { + node_vft_t *vftp = the_vft[child->type]; + indent_me(fp); + vftp->generate(child, which, fp); + child = child->peer; + } + indent -= 4; + indent_me(fp); + fprintf(fp, "} %s;\n", CDATA0); + break; + + case PRINTFUN_PASS: + case ENDIANFUN_PASS: + uelem = this->deeper; + + indent_me(fp); + fprintf(fp, "switch(a->_%s_which) {\n", + CDATA0); + indent += 4; + current_union_name = CDATA0; + + /* Walk the list of objects in this union */ + while (uelem) { + node_vft_t *vftp = the_vft[uelem->type]; + indent -= 4; + indent_me(fp); + fprintf(fp, "case %d:\n", case_id); + case_id++; + indent += 4; + /* Drill down on each element */ + vftp->generate(uelem, which, fp); + indent_me(fp); + fprintf(fp, "break;\n"); + uelem = uelem->peer; + } + current_union_name = 0; + indent -= 4; + indent_me(fp); + fprintf(fp, "default:\n"); + indent += 4; + indent_me(fp); + if (which == PRINTFUN_PASS) { + fprintf(fp, + "vl_print(handle, \"WARNING: _%s_which not set.\\n\");\n", + CDATA0); + } + indent_me(fp); + fprintf(fp, "break;\n"); + indent -= 4; + indent_me(fp); + fprintf(fp, "}\n"); + break; + + default: + fprintf(stderr, "node_union_generate: unimp pass %d\n", which); + break; + } +} + + +node_vft_t node_union_vft = { + node_union_print, + node_union_generate, + 0, +}; + +void node_scalar_print (node_t *this) +{ + fprintf(stdout, "%s", CDATA0); + primtype_recursive_print (this, ""); +} + +void node_scalar_generate (node_t *this, enum passid which, FILE *fp) +{ + char *union_prefix = ""; + + if (current_union_name) { + sprintf(tmpbuf, "%s.", current_union_name); + union_prefix = tmpbuf; + } + + switch(which) { + case TYPEDEF_PASS: + fprintf(fp, "%s;\n", CDATA0); + break; + + case PRINTFUN_PASS: + indent_me(fp); + if (current_is_complex) { + fprintf(fp, "vl_api_%s_t_print(a->%s%s, handle);\n", + current_type_name, union_prefix, CDATA0); + } else { + if (!strcmp(current_type_fmt, "uword")) { + fprintf(fp, + "vl_print(handle, \"%s%s: \" _uword_fmt \"\\n\", %s a->%s%s);\n", + union_prefix, CDATA0, "(_uword_cast)", + union_prefix, CDATA0); + } else { + fprintf(fp, + "vl_print(handle, \"%s%s: %s\\n\", %s a->%s%s);\n", + union_prefix, CDATA0, + current_type_fmt, current_type_cast, + union_prefix, CDATA0); + } + } + break; + + case ENDIANFUN_PASS: + indent_me(fp); + if (current_is_complex) { + fprintf(fp, "vl_api%s_t_endian(a->%s%s);\n", + current_type_name, union_prefix, CDATA0); + } else { + /* Current_endianfun == NULL means e.g. it's a u8... */ + if (current_endianfun) { + fprintf(fp, "a->%s%s = %s(a->%s%s);\n", union_prefix, + CDATA0, current_endianfun, + union_prefix, CDATA0); + } else { + fprintf(fp, "/* a->%s%s = a->%s%s */\n", + union_prefix, CDATA0, + union_prefix, CDATA0); + } + } + break; + + default: + fprintf(stderr, "node_scalar_generate: unimp pass %d\n", which); + } + if (this->deeper) { + fprintf(stderr, "broken recursion in node_scalar_generate\n"); + } +} + + +node_vft_t node_scalar_vft = { + node_scalar_print, + node_scalar_generate, + 0, +}; + +void node_vector_print (node_t *this) +{ + primtype_recursive_print (this, "vector "); +} + +void node_vector_generate (node_t *this, enum passid which, FILE *fp) +{ + char *union_prefix = ""; + + if (current_union_name) { + sprintf(tmpbuf, "%s.", current_union_name); + union_prefix = tmpbuf; + } + + switch(which) { + case TYPEDEF_PASS: + fprintf(fp, "%s[%d];\n", CDATA0, IDATA1); + break; + + case PRINTFUN_PASS: + /* Don't bother about "u8 data [0];" et al. */ + if (IDATA1 == 0) + break; + + indent_me(fp); + fprintf(fp, "{\n"); + indent += 4; + indent_me(fp); + fprintf(fp, "int _i;\n"); + indent_me(fp); + fprintf(fp, "for (_i = 0; _i < %d; _i++) {\n", + IDATA1); + indent += 4; + indent_me(fp); + if (current_is_complex) { + fprintf(fp, "vl_print(handle, \"%s%s[%%d]: ", + union_prefix, CDATA0); + fprintf(fp, + "vl_print_%s (handle, a->%s%s[_i]);\n", + CDATA0, union_prefix, CDATA0); + } else { + fprintf(fp, + "vl_print(handle, \"%s%s[%%d]: %s\\n\", _i, a->%s%s[_i]);\n", + union_prefix, CDATA0, + current_type_fmt, + union_prefix, CDATA0); + } + indent -= 4; + indent_me(fp); + fprintf(fp, "}\n"); + indent -= 4; + indent_me(fp); + fprintf(fp, "}\n"); + break; + + case ENDIANFUN_PASS: + /* Don't bother about "u8 data [0];" et al. */ + if (IDATA1 == 0) + break; + + indent_me(fp); + fprintf(fp, "{\n"); + indent += 4; + indent_me(fp); + fprintf(fp, "int _i;\n"); + indent_me(fp); + fprintf(fp, "for (_i = 0; _i < %d; _i++) {\n", + IDATA1); + indent += 4; + indent_me(fp); + if (current_is_complex) { + fprintf(fp, + "vl_api_%s_t_endian (a->%s%s[_i]);\n", + current_type_name, union_prefix, CDATA0); + } else { + fprintf(fp, + "a->%s%s[_i] = %s(a->%s%s[_i]);\n", + union_prefix, CDATA0, + current_endianfun, + union_prefix, CDATA0); + } + indent -= 4; + indent_me(fp); + fprintf(fp, "}\n"); + indent -= 4; + indent_me(fp); + fprintf(fp, "}\n"); + break; + + default: + fprintf(stderr, "node_vector_generate: unimp pass %d\n", which); + } + if (this->deeper) { + fprintf(stderr, "broken recursion in node_vector_generate\n"); + } +} + +node_vft_t node_vector_vft = { + node_vector_print, + node_vector_generate, + 0, +}; + +void node_complex_print (node_t *this) +{ + primtype_recursive_print (this, "complex "); +} + +void node_complex_generate (node_t *this, enum passid which, FILE *fp) +{ + node_t *deeper; + node_vft_t *vftp; + char *member_name = "broken!"; + char *union_prefix = ""; + + if (current_union_name) { + sprintf(tmpbuf, "%s.", current_union_name); + union_prefix = tmpbuf; + } + + current_is_complex++; + + switch(which) { + case TYPEDEF_PASS: + fprintf(fp, "%s ", CDATA0); + deeper = this->deeper; + if (deeper) { + vftp = the_vft[deeper->type]; + vftp->generate(deeper, which, fp); + } + break; + + case PRINTFUN_PASS: + deeper = this->deeper; + while (deeper) { + if (deeper->type == NODE_SCALAR || + deeper->type == NODE_VECTOR) { + member_name = deeper->data[0]; + break; + } + deeper = deeper->deeper; + } + indent_me(fp); + fprintf(fp, "vl_print(handle, \"%s%s ----- \\n\");\n", + union_prefix, member_name); + indent_me(fp); + fprintf(fp, "%s_print(&a->%s%s, handle);\n", + CDATA0, union_prefix, member_name); + indent_me(fp); + fprintf(fp, "vl_print(handle, \"%s%s ----- END \\n\");\n", + union_prefix, member_name); + break; + + case ENDIANFUN_PASS: + deeper = this->deeper; + while (deeper) { + if (deeper->type == NODE_SCALAR || + deeper->type == NODE_VECTOR) { + member_name = deeper->data[0]; + break; + } + deeper = deeper->deeper; + } + + indent_me(fp); + fprintf(fp, "%s_endian(&a->%s%s);\n", + CDATA0, union_prefix, member_name); + break; + + default: + fprintf(stderr, "node_complex_generate unimp pass %d...\n", which); + break; + } + current_is_complex--; +} + +node_vft_t node_complex_vft = { + node_complex_print, + node_complex_generate, + 0, +}; + +void node_noversion_print (node_t *this) +{ + primtype_recursive_print (this, "noversion "); +} + +void node_noversion_generate (node_t *this, enum passid which, FILE *ofp) +{ + fprintf(stderr, "node_noversion_generate called...\n"); +} + +node_vft_t node_noversion_vft = { + node_noversion_print, + node_noversion_generate, + 0, +}; + +void node_uword_print (node_t *this) +{ + primtype_recursive_print(this, "uword "); +} + +void node_uword_generate (node_t *this, enum passid which, FILE *ofp) +{ + primtype_recursive_generate(this, which, ofp, "uword", "uword", ""); +} + +node_vft_t node_uword_vft = { + node_uword_print, + node_uword_generate, + "clib_net_to_host_uword", +}; + +node_vft_t *the_vft[NODE_N_TYPES] = { + &node_illegal_vft, + &node_u8_vft, + &node_u16_vft, + &node_u32_vft, + &node_u64_vft, + &node_i8_vft, + &node_i16_vft, + &node_i32_vft, + &node_i64_vft, + &node_f64_vft, + &node_packed_vft, + &node_define_vft, + &node_union_vft, + &node_scalar_vft, + &node_vector_vft, + &node_complex_vft, + &node_noversion_vft, + &node_uword_vft, +}; + +void *make_node (enum node_subclass type) +{ + node_t *rv; + + rv = (node_t *) malloc (sizeof (*rv)); + if (rv == 0) { + fprintf (stderr, "fatal: make_node out of memory\n"); + exit (1); + } + bzero (rv, sizeof (*rv)); + rv->type = type; + return ((void *) rv); +} + +YYSTYPE deeper (YYSTYPE arg1, YYSTYPE arg2) +{ + node_t *np1 = (node_t *) arg1; + node_t *np2 = (node_t *) arg2; + node_t *hook_point; + + hook_point = np1; + + while (hook_point->deeper) + hook_point = hook_point->deeper; + + hook_point->deeper = np2; + return (arg1); +} + +YYSTYPE addpeer (YYSTYPE arg1, YYSTYPE arg2) +{ + node_t *np1 = (node_t *) arg1; + node_t *np2 = (node_t *) arg2; + node_t *hook_point; + + hook_point = np1; + + while (hook_point->peer) + hook_point = hook_point->peer; + + hook_point->peer = np2; + return (arg1); +} + +/* + * add_slist (stmt_list, stmt) + */ + +YYSTYPE add_slist (YYSTYPE a1, YYSTYPE a2) +{ + if (a1 && a2) + return (addpeer(a1, a2)); + else if(a1) + return(a1); + else + return(a2); +} + +/* + * add_define (char *name, defn_list); + */ +YYSTYPE add_define (YYSTYPE a1, YYSTYPE a2) +{ + node_t *np; + + np = make_node(NODE_DEFINE); + np->data[0] = a1; + deeper((YYSTYPE)np, a2); + return ((YYSTYPE) np); +} + +/* + * add_defbody (defn_list, new_defn) + */ +YYSTYPE add_defbody (YYSTYPE a1, YYSTYPE a2) +{ + return (addpeer(a1, a2)); +} + +/* + * add_primtype ([packed], primitive type, instance) + */ + +YYSTYPE add_primtype (YYSTYPE a1, YYSTYPE a2, YYSTYPE a3) +{ + node_t *np1; + + np1 = (node_t *)a1; + + /* Hook instance to type node */ + deeper (a1, a2); + if (a3) { + deeper(a1, a3); + } + return (a1); +} + +/* + * add_complex(char *type_name, instance) + */ + +YYSTYPE add_complex (YYSTYPE a1, YYSTYPE a2) +{ + node_t *np; + + np = make_node(NODE_COMPLEX); + np->data[0] = (void *) a1; + + deeper((YYSTYPE)np, a2); + return ((YYSTYPE) np); +} + +/* + * add_union(char *type_name, definition) + */ + +YYSTYPE add_union (YYSTYPE a1, YYSTYPE a2) +{ + node_t *np; + + np = make_node(NODE_UNION); + np->data[0] = (void *) a1; + + deeper((YYSTYPE)np, a2); + return ((YYSTYPE) np); +} + + +/* + * add_vector_vbl (node_t *variable, YYSTYPE size) + */ + +YYSTYPE add_vector_vbl (YYSTYPE a1, YYSTYPE a2) +{ + node_t *np; + + np = make_node(NODE_VECTOR); + np->data[0] = (void *) a1; + np->data[1] = (void *) a2; + return ((YYSTYPE) np); +} + +/* + * add_scalar_vbl (char *name) + */ +YYSTYPE add_scalar_vbl (YYSTYPE a1) +{ + node_t *np; + + np = make_node(NODE_SCALAR); + np->data[0] = (void *) a1; + return ((YYSTYPE) np); +} + +/* + * set_flags (int flags, msg(=0?)) + */ +YYSTYPE set_flags(YYSTYPE a1, YYSTYPE a2) +{ + node_t *np; + int flags; + + np = (node_t *)a2; + if (!np) + return(0); + + flags = (int)(uword) a1; + + np->flags |= flags; + return (a2); +} +/* + * suppress_version + */ +YYSTYPE suppress_version (void) +{ + dont_output_version = 1; + return (0); +} + +void dump(node_t *np) +{ + node_vft_t *vftp; + + while (np) { + vftp = the_vft[np->type]; + vftp->print(np); + np = np->peer; + } +} + +char *fixup_input_filename(void) +{ + char *cp; + + cp = (char *)input_filename; + + while (*cp) + cp++; + + cp--; + + while (cp > input_filename && *cp != '/') + cp--; + if (*cp == '/') + cp++; + + strcpy (tmpbuf, cp); + + cp = tmpbuf; + + while (*cp) + cp++; + + cp--; + + while (cp > tmpbuf && *cp != '.') + cp--; + + if (*cp == '.') + *cp = 0; + + return (sxerox(tmpbuf)); +} + +void generate_top_boilerplate(FILE *fp) + +{ + char *datestring = ctime(&starttime); + fixed_name = fixup_input_filename(); + + datestring[24] = 0; + + fprintf (fp, "/*\n"); + fprintf (fp, " * VLIB API definitions %s\n", datestring); + fprintf (fp, " * Input file: %s\n", input_filename); + fprintf (fp, " * Automatically generated: please edit the input file "); + fprintf (fp, "NOT this file!\n"); + + /* Moron Acme trigger workaround */ + fprintf (fp, " * %syright (c) %s by Cisco Systems, Inc.\n", "Cop", + &datestring[20]); + fprintf (fp, " */\n\n"); + fprintf (fp, "#if defined(vl_msg_id)||defined(vl_union_id)||"); + fprintf (fp, "defined(vl_printfun) \\\n ||defined(vl_endianfun)||"); + fprintf (fp, " defined(vl_api_version)||defined(vl_typedefs) \\\n"); + fprintf (fp, " ||defined(vl_msg_name)\n"); + fprintf (fp, "/* ok, something was selected */\n"); + fprintf (fp, "#else\n"); + fprintf (fp, "#warning no content included from %s\n", input_filename); + fprintf (fp, "#endif\n\n"); + fprintf (fp, "#define VL_API_PACKED(x) x __attribute__ ((packed))\n\n"); +} + +void generate_bottom_boilerplate(FILE *fp) + +{ + fprintf (fp, "\n#ifdef vl_api_version\n"); + + if (dont_output_version) { + fprintf (fp, "/* WARNING: API FILE VERSION CHECK DISABLED */\n"); + input_crc = 0; + } + + fprintf (fp, "vl_api_version(%s, 0x%08x)\n\n", + fixed_name, (unsigned int)input_crc); + fprintf (fp, "#endif\n\n"); +} + +void generate_msg_ids(YYSTYPE a1, FILE *fp) +{ + node_t *np = (node_t *)a1; + + fprintf (fp, "\n/****** Message ID / handler enum ******/\n\n"); + fprintf (fp, "#ifdef vl_msg_id\n"); + + while (np) { + if (np->type == NODE_DEFINE) { + if (!(np->flags & NODE_FLAG_TYPEONLY)) { + fprintf (fp, "vl_msg_id(VL_API_%s, vl_api_%s_t_handler)\n", + uppercase(np->data[0]), (i8 *)np->data[0]); + } else { + fprintf (fp, "/* typeonly: %s */\n", (i8 *)np->data[0]); + } + } + np = np->peer; + } + fprintf (fp, "#endif\n"); + +} + +void generate_msg_names(YYSTYPE a1, FILE *fp) +{ + node_t *np = (node_t *)a1; + + fprintf (fp, "\n/****** Message names ******/\n\n"); + + fprintf (fp, "#ifdef vl_msg_name\n"); + + while (np) { + if (np->type == NODE_DEFINE) { + if (!(np->flags & NODE_FLAG_TYPEONLY)) { + fprintf (fp, "vl_msg_name(vl_api_%s_t, %d)\n", + (i8 *) np->data[0], + (np->flags & NODE_FLAG_DONT_TRACE ? 0 : 1)); + } else { + fprintf (fp, "/* typeonly: %s */\n", (i8 *)np->data[0]); + } + } + np = np->peer; + } + fprintf (fp, "#endif\n\n"); +} + +void generate_typedefs(YYSTYPE a1, FILE *fp) +{ + node_t *np = (node_t *)a1; + node_vft_t *vftp; + + fprintf(fp, "\n/****** Typedefs *****/\n\n"); + fprintf(fp, "#ifdef vl_typedefs\n\n"); + + /* Walk the top-level node-list */ + while (np) { + if (np->type == NODE_DEFINE) { + /* Yeah, this is pedantic */ + vftp = the_vft[np->type]; + vftp->generate(np, TYPEDEF_PASS, fp); + } + np = np->peer; + } + fprintf(fp, "#endif /* vl_typedefs */\n\n"); +} + +void union_walk_one_defn(node_t *np, FILE *fp) +{ + node_t *vblp; + node_t *uelem; + + /* Walk the list of typed objects in this msg def */ + while (np) { + if (np->type == NODE_UNION) { + current_union_name = np->data[0]; + uelem = np->deeper; + + /* Walk the list of objects in this union */ + while (uelem) { + vblp = uelem->deeper; + /* Drill down on each element, find the variable name */ + while(vblp) { + if (vblp->type == NODE_SCALAR || + vblp->type == NODE_VECTOR || + vblp->type == NODE_COMPLEX) { + fprintf(ofp, "#define %s_", + uppercase(current_def_name)); + fprintf(ofp, "%s_", uppercase(current_union_name)); + fprintf(ofp, "%s %d\n",uppercase(vblp->data[0]), + current_id); + current_id++; + break; + } + vblp = vblp->deeper; + } + uelem = uelem->peer; + } + current_union_name = 0; + current_id = 1; + } + np = np->peer; + } +} + +void generate_uniondefs(YYSTYPE a1, FILE *fp) +{ + node_t *np = (node_t *)a1; + + fprintf(fp, "/****** Discriminated Union Definitions *****/\n\n"); + fprintf(fp, "#ifdef vl_union_id\n\n"); + + /* Walk the top-level node-list */ + while (np) { + if (np->type == NODE_DEFINE) { + current_id = 1; + current_def_name = np->data[0]; + union_walk_one_defn(np->deeper, fp); + } + np = np->peer; + } + fprintf(fp, "\n#endif /* vl_union_id */\n\n"); +} + +void generate_printfun(YYSTYPE a1, FILE *fp) +{ + node_t *np = (node_t *)a1; + node_vft_t *vftp; + + fprintf(fp, "/****** Print functions *****/\n\n"); + fprintf(fp, "#ifdef vl_printfun\n\n"); + + fprintf(fp, "#ifdef LP64\n"); + fputs ("#define _uword_fmt \"%lld\"\n", fp); + fputs ("#define _uword_cast (long long)\n", fp); + fprintf(fp, "#else\n"); + fputs("#define _uword_fmt \"%ld\"\n", fp); + fputs ("#define _uword_cast long\n", fp); + fprintf(fp, "#endif\n\n"); + + /* Walk the top-level node-list */ + while (np) { + if (np->type == NODE_DEFINE) { + if (!(np->flags & NODE_FLAG_MANUAL_PRINT)) { + fprintf(fp, + "static inline void *vl_api_%s_t_print (vl_api_%s_t *a,", + (i8 *)np->data[0], (i8 *) np->data[0]); + fprintf(fp, "void *handle)\n{\n"); + /* output the message name */ + fprintf(fp, + " vl_print(handle, \"vl_api_%s_t:\\n\");\n", + (i8 *)np->data[0]); + + indent += 4; + /* Yeah, this is pedantic */ + vftp = the_vft[np->type]; + vftp->generate(np, PRINTFUN_PASS, fp); + fprintf(fp, " return handle;\n"); + fprintf(fp, "}\n\n"); + indent -= 4; + } else { + fprintf(fp, "/***** manual: vl_api_%s_t_print *****/\n\n", + (i8 *) np->data[0]); + } + } + np = np->peer; + } + fprintf(fp, "#endif /* vl_printfun */\n\n"); +} + +void generate_endianfun(YYSTYPE a1, FILE *fp) +{ + node_t *np = (node_t *)a1; + node_vft_t *vftp; + + fprintf(fp, "\n/****** Endian swap functions *****/\n\n"); + fprintf(fp, "#ifdef vl_endianfun\n\n"); + fprintf(fp, "#undef clib_net_to_host_uword\n"); + fprintf(fp, "#ifdef LP64\n"); + fprintf(fp, "#define clib_net_to_host_uword clib_net_to_host_u64\n"); + fprintf(fp, "#else\n"); + fprintf(fp, "#define clib_net_to_host_uword clib_net_to_host_u32\n"); + fprintf(fp, "#endif\n\n"); + + /* Walk the top-level node-list */ + while (np) { + if (np->type == NODE_DEFINE) { + if (!(np->flags & NODE_FLAG_MANUAL_ENDIAN)) { + fprintf(fp, + "static inline void vl_api_%s_t_endian (vl_api_%s_t *a)\n{\n", + (i8 *) np->data[0], (i8 *) np->data[0]); + indent += 4; + /* Yeah, this is pedantic */ + vftp = the_vft[np->type]; + vftp->generate(np, ENDIANFUN_PASS, fp); + fprintf(fp, "}\n\n"); + indent -= 4; + } else { + fprintf(fp, "/***** manual: vl_api_%s_t_endian *****/\n\n", + (i8 *) np->data[0]); + } + } + np = np->peer; + } + fprintf(fp, "#endif /* vl_endianfun */\n\n"); +} + +void add_msg_ids(YYSTYPE a1) +{ + node_t *np = (node_t *)a1; + node_t *new_u16; + node_t *new_vbl; + + /* Walk the top-level node-list */ + while (np) { + if (np->type == NODE_DEFINE) { + if (!(np->flags & NODE_FLAG_TYPEONLY)) { + /* add the parse tree for "u16 _vl_msg_id" */ + new_u16 = make_node(NODE_U16); + new_u16->peer = np->deeper; + np->deeper = new_u16; + new_vbl = make_node(NODE_SCALAR); + new_vbl->data[0] = sxerox("_vl_msg_id"); + new_u16->deeper = new_vbl; + } + } + np = np->peer; + } +} + +void generate_java_top_boilerplate(FILE *fp) + +{ + char *datestring = ctime(&starttime); + fixed_name = fixup_input_filename(); + + datestring[24] = 0; + + fprintf (fp, "/*\n"); + fprintf (fp, " * VLIB API java binding %s\n", datestring); + fprintf (fp, " * Input file: %s\n", input_filename); + fprintf (fp, " * Automatically generated: please edit the input file "); + fprintf (fp, "NOT this file!\n"); + fprintf (fp, " */\n\n"); + + fprintf (fp, "package org.openvpp.vppjapi;\n\n"); + fprintf (fp, "import org.openvpp.vppjapi.vppConn;\n\n"); + fprintf (fp, "public class %s extends vppConn {\n\n", + java_class); +} + +void generate_java_bottom_boilerplate(FILE *fp) +{ + fprintf (fp, "}\n"); +} + + +void generate_java_class_definition (YYSTYPE a1, FILE *fp) +{ + node_t *np = (node_t *)a1; + node_vft_t *vftp; + + fprintf(fp, "/****** API methods *****/\n\n"); + + /* Walk the top-level node-list */ + while (np) { + if (np->type == NODE_DEFINE) { + if (!(np->flags & (NODE_FLAG_MANUAL_JAVA | NODE_FLAG_TYPEONLY))) { + /* Suppress messages named "xyz_reply" */ + char * cp = (char *) np->data[0]; + while (*cp) + cp++; + cp -= 6; + if (strncmp (cp, "_reply", 6)) { + current_java_parameter_number = 0; + vftp = the_vft[np->type]; + vftp->generate(np, JAVA_METHOD_PASS, fp); + } + } + } + np = np->peer; + } + + fprintf(fp, "\n/****** end of API methods *****/\n"); +} + +void generate_jni_reply_handler_list (YYSTYPE a1, FILE *fp) +{ + node_t *np = (node_t *)a1; + node_vft_t *vftp; + + fprintf (fp, "#define foreach_api_reply_handler \\\n"); + + /* Walk the top-level node-list */ + while (np) { + if (np->type == NODE_DEFINE) { + if (!(np->flags & (NODE_FLAG_MANUAL_JAVA | NODE_FLAG_TYPEONLY))) { + /* emit messages named "xyz_reply" */ + char * cp = (char *) np->data[0]; + while (*cp) + cp++; + cp -= 6; + if (!strncmp (cp, "_reply", 6)) { + fprintf (fp, "_(%s, %s) \\\n", + uppercase(np->data[0]), (char *)(np->data[0])); + } + } + } + np = np->peer; + } + + fprintf (fp, "\n\n"); +} + +char * m_macro_boilerplate = +"#define M(T,t) \\\n" +"do { \\\n" +" api_result_ready = 0; \\\n" +" mp = vl_msg_api_alloc(sizeof(*mp)); \\\n" +" memset (mp, 0, sizeof (*mp)); \\\n" +" mp->_vl_msg_id = ntohs (VL_API_##T); \\\n" +" mp->client_index = api_main.my_client_index; \\\n" +"} while(0);\n\n" +"#define M2(T,t,n) \\\n" +"do { \\\n" +" api_result_ready = 0; \\\n" +" mp = vl_msg_api_alloc(sizeof(*mp)+(n)); \\\n" +" memset (mp, 0, sizeof (*mp)); \\\n" +" mp->_vl_msg_id = ntohs (VL_API_##T); \\\n" +" mp->client_index = api_main.my_client_index; \\\n" +"} while(0);\n\n"; + +char * s_macro_boilerplate = +"#define S (vl_msg_api_send_shmem (api_main.shmem_hdr->vl_input_queue, \\\n" +"(u8 *)&mp));\n\n"; + +char * w_macro_boilerplate = +"#define W \\\n" +"do { \\\n" +" timeout = clib_time_now (&clib_time) + 1.0; \\\n" +" \\\n" +" while (clib_time_now (&clib_time) < timeout) { \\\n" +" if (api_result_ready == 1) { \\\n" +" return ((jint) api_result); \\\n" +" } \\\n" +" } \\\n" +" return -99; \\\n" +"} while(0);\n\n"; + +void generate_jni_top_boilerplate(FILE *fp) + +{ + char *datestring = ctime(&starttime); + fixed_name = fixup_input_filename(); + + datestring[24] = 0; + + fprintf (fp, "/*\n"); + fprintf (fp, " * VLIB Java native code %s\n", datestring); + fprintf (fp, " * Input file: %s\n", input_filename); + fprintf (fp, " * Automatically generated: please edit the input file "); + fprintf (fp, "NOT this file!\n"); + fprintf (fp, " */\n\n"); + + fprintf (fp, "#include <japi/vppjni.h>\n"); + + fprintf (fp, + "#define vl_api_version(n,v) static u32 %s_api_version %s = v;\n", + vlib_app_name, "__attribute__((unused))"); + fprintf (fp, "#include <api/%s.api.h>\n", vlib_app_name); + fprintf (fp, "#undef vl_api_version\n\n"); + + fprintf (fp, "#include <japi/org_openvpp_vppjapi_vppConn.h>\n"); + fprintf (fp, "#include <japi/org_openvpp_vppjapi_%s.h>\n\n", java_class); + + fprintf (fp, "#include <api/%s_msg_enum.h>\n", vlib_app_name); + fprintf (fp, "#define vl_typedefs /* define message structures */\n"); + fprintf (fp, "#include <api/%s_all_api_h.h> \n", vlib_app_name); + fprintf (fp, "#undef vl_typedefs\n\n"); + + fprintf (fp, "#define vl_endianfun \n"); + fprintf (fp, "#include <api/%s_all_api_h.h> \n", vlib_app_name); + fprintf (fp, "#undef vl_endianfun\n\n"); + + fprintf (fp, "#define vl_print(handle, ...)\n"); + fprintf (fp, "#define vl_printfun\n"); + fprintf (fp, "#include <api/%s_all_api_h.h>\n", vlib_app_name); + fprintf (fp, "#undef vl_printfun\n\n"); +} + +void generate_jni_code (YYSTYPE a1, FILE *fp) +{ + node_t *np = (node_t *)a1; + node_vft_t *vftp; + + /* Walk the top-level node-list */ + while (np) { + if (np->type == NODE_DEFINE) { + if (!(np->flags & (NODE_FLAG_MANUAL_JAVA | NODE_FLAG_TYPEONLY))) { + /* Suppress messages named "xyz_reply" */ + char * cp = (char *) np->data[0]; + while (*cp) + cp++; + cp -= 6; + if (strncmp (cp, "_reply", 6)) { + current_def_name = np->data[0]; + current_java_parameter_number = 0; + vftp = the_vft[np->type]; + vftp->generate(np, JAVA_JNI_PASS, fp); + } + } + } + np = np->peer; + } +} + +char *hookup_boilerplate = +"void vl_msg_reply_handler_hookup (void)\n" +"{\n" +"#define _(N,n) \\\n" +" vl_msg_api_set_handlers (VL_API_##N, #n, \\\n" +" vl_api_generic_reply_handler, \\\n" +" vl_noop_handler, \\\n" +" vl_api_##n##_t_endian, \\\n" +" vl_api_##n##_t_print, \\\n" +" sizeof(vl_api_##n##_t), 1); \n" +" foreach_api_reply_handler;\n" +"#undef _\n\n" +"}\n\n"; + +void generate_jni_bottom_boilerplate(FILE *fp) +{ + fputs (hookup_boilerplate, fp); +} + +void generate(YYSTYPE a1) +{ + if (dump_tree) { + dump((node_t *)a1); + } + + add_msg_ids(a1); + + if (ofp) { + generate_top_boilerplate(ofp); + + generate_msg_ids(a1, ofp); + generate_msg_names(a1, ofp); + generate_typedefs(a1, ofp); + generate_uniondefs(a1, ofp); + generate_printfun(a1, ofp); + generate_endianfun(a1, ofp); + + generate_bottom_boilerplate(ofp); + } + + if (javafp) { + generate_java_top_boilerplate(javafp); + generate_java_class_definition(a1, javafp); + generate_java_bottom_boilerplate(javafp); + } + if (jnifp) { + generate_jni_top_boilerplate(jnifp); + generate_jni_reply_handler_list (a1, jnifp); + generate_jni_code(a1, jnifp); + generate_jni_bottom_boilerplate(jnifp); + } +} |