| # |
| # Copyright (c) 2020 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. |
| # |
| |
| # |
| # Provide two classes FromJSON and TOJSON that converts between JSON and VPP's |
| # binary API format |
| # |
| |
| ''' |
| This module creates C code for core VPP, VPP plugins and client side VAT and |
| VAT2 tests. |
| ''' |
| |
| import datetime |
| import os |
| import time |
| import sys |
| from io import StringIO |
| import shutil |
| |
| process_imports = False |
| |
| |
| ############################################################################### |
| class ToJSON(): |
| '''Class to generate functions converting from VPP binary API to JSON.''' |
| _dispatch = {} |
| noprint_fields = {'_vl_msg_id': None, |
| 'client_index': None, |
| 'context': None} |
| is_number = {'u8': None, |
| 'i8': None, |
| 'u16': None, |
| 'i16': None, |
| 'u32': None, |
| 'i32': None, |
| 'u64': None, |
| 'i64': None, |
| 'f64': None, |
| } |
| |
| def __init__(self, module, types, defines, imported_types, stream): |
| self.stream = stream |
| self.module = module |
| self.defines = defines |
| self.types = types |
| self.types_hash = {'vl_api_'+d.name+'_t': |
| d for d in types + imported_types} |
| self.defines_hash = {d.name: d for d in defines} |
| |
| def header(self): |
| '''Output the top boilerplate.''' |
| write = self.stream.write |
| write('#ifndef included_{}_api_tojson_h\n'.format(self.module)) |
| write('#define included_{}_api_tojson_h\n'.format(self.module)) |
| write('#include <vppinfra/cJSON.h>\n\n') |
| write('#include <vat2/jsonconvert.h>\n\n') |
| |
| def footer(self): |
| '''Output the bottom boilerplate.''' |
| write = self.stream.write |
| write('#endif\n') |
| |
| def get_base_type(self, t): |
| vt_type = None |
| try: |
| vt = self.types_hash[t] |
| if vt.type == 'Using' and 'length' not in vt.alias: |
| vt_type = vt.alias['type'] |
| except KeyError: |
| vt = t |
| return vt, vt_type |
| |
| def get_json_func(self, t): |
| '''Given the type, returns the function to use to create a |
| cJSON object''' |
| vt, vt_type = self.get_base_type(t) |
| |
| if t in self.is_number or vt_type in self.is_number: |
| return 'cJSON_AddNumberToObject', '', False |
| if t == 'bool': |
| return 'cJSON_AddBoolToObject', '', False |
| |
| # Lookup type name check if it's enum |
| if vt.type == 'Enum' or vt.type == 'EnumFlag': |
| return '{t}_tojson'.format(t=t), '', True |
| return '{t}_tojson'.format(t=t), '&', True |
| |
| def get_json_array_func(self, t): |
| '''Given a type returns the function to create a cJSON object |
| for arrays.''' |
| if t in self.is_number: |
| return 'cJSON_CreateNumber', '' |
| if t == 'bool': |
| return 'cJSON_CreateBool', '' |
| vt, vt_type = self.get_base_type(t) |
| if vt.type == 'Enum' or vt.type == 'EnumFlag': |
| return '{t}_tojson'.format(t=t), '' |
| return '{t}_tojson'.format(t=t), '&' |
| |
| def print_string(self, o): |
| '''Create cJSON object from vl_api_string_t''' |
| write = self.stream.write |
| if o.modern_vla: |
| write(' vl_api_string_cJSON_AddToObject(o, "{n}", &a->{n});\n' |
| .format(n=o.fieldname)) |
| else: |
| |
| write(' cJSON_AddStringToObject(o, "{n}", (char *)a->{n});\n' |
| .format(n=o.fieldname)) |
| |
| def print_field(self, o): |
| '''Called for every field in a typedef or define.''' |
| write = self.stream.write |
| if o.fieldname in self.noprint_fields: |
| return |
| |
| f, p, newobj = self.get_json_func(o.fieldtype) |
| |
| if newobj: |
| write(' cJSON_AddItemToObject(o, "{n}", {f}({p}a->{n}));\n' |
| .format(f=f, p=p, n=o.fieldname)) |
| else: |
| write(' {f}(o, "{n}", {p}a->{n});\n' |
| .format(f=f, p=p, n=o.fieldname)) |
| |
| _dispatch['Field'] = print_field |
| |
| def print_array(self, o): |
| '''Converts a VPP API array to cJSON array.''' |
| write = self.stream.write |
| |
| forloop = '''\ |
| {{ |
| int i; |
| cJSON *array = cJSON_AddArrayToObject(o, "{n}"); |
| for (i = 0; i < {lfield}; i++) {{ |
| cJSON_AddItemToArray(array, {f}({p}a->{n}[i])); |
| }} |
| }} |
| ''' |
| |
| if o.fieldtype == 'string': |
| self.print_string(o) |
| return |
| |
| lfield = 'a->' + o.lengthfield if o.lengthfield else o.length |
| if o.fieldtype == 'u8': |
| write(' {\n') |
| # What is length field doing here? |
| write(' u8 *s = format(0, "0x%U", format_hex_bytes, ' |
| '&a->{n}, {lfield});\n' |
| .format(n=o.fieldname, lfield=lfield)) |
| write(' cJSON_AddStringToObject(o, "{n}", (char *)s);\n' |
| .format(n=o.fieldname)) |
| write(' vec_free(s);\n') |
| write(' }\n') |
| return |
| |
| f, p = self.get_json_array_func(o.fieldtype) |
| write(forloop.format(lfield=lfield, |
| t=o.fieldtype, |
| n=o.fieldname, |
| f=f, |
| p=p)) |
| |
| _dispatch['Array'] = print_array |
| |
| def print_enum(self, o): |
| '''Create cJSON object (string) for VPP API enum''' |
| write = self.stream.write |
| write('static inline cJSON *vl_api_{name}_t_tojson ' |
| '(vl_api_{name}_t a) {{\n'.format(name=o.name)) |
| |
| write(" switch(a) {\n") |
| for b in o.block: |
| write(" case %s:\n" % b[1]) |
| write(' return cJSON_CreateString("{}");\n'.format(b[0])) |
| write(' default: return cJSON_CreateString("Invalid ENUM");\n') |
| write(' }\n') |
| write(' return 0;\n') |
| write('}\n') |
| |
| _dispatch['Enum'] = print_enum |
| |
| def print_enum_flag(self, o): |
| '''Create cJSON object (string) for VPP API enum''' |
| write = self.stream.write |
| write('static inline cJSON *vl_api_{name}_t_tojson ' |
| '(vl_api_{name}_t a) {{\n'.format(name=o.name)) |
| write(' cJSON *array = cJSON_CreateArray();\n') |
| |
| for b in o.block: |
| write(' if (a & {})\n'.format(b[0])) |
| write(' cJSON_AddItemToArray(array, cJSON_CreateString("{}"));\n'.format(b[0])) |
| write(' return array;\n') |
| write('}\n') |
| |
| _dispatch['EnumFlag'] = print_enum_flag |
| |
| def print_typedef(self, o): |
| '''Create cJSON (dictionary) object from VPP API typedef''' |
| write = self.stream.write |
| write('static inline cJSON *vl_api_{name}_t_tojson ' |
| '(vl_api_{name}_t *a) {{\n'.format(name=o.name)) |
| write(' cJSON *o = cJSON_CreateObject();\n') |
| |
| for t in o.block: |
| self._dispatch[t.type](self, t) |
| |
| write(' return o;\n') |
| write('}\n') |
| |
| def print_define(self, o): |
| '''Create cJSON (dictionary) object from VPP API define''' |
| write = self.stream.write |
| write('static inline cJSON *vl_api_{name}_t_tojson ' |
| '(vl_api_{name}_t *a) {{\n'.format(name=o.name)) |
| write(' cJSON *o = cJSON_CreateObject();\n') |
| write(' cJSON_AddStringToObject(o, "_msgname", "{}");\n' |
| .format(o.name)) |
| |
| for t in o.block: |
| self._dispatch[t.type](self, t) |
| |
| write(' return o;\n') |
| write('}\n') |
| |
| def print_using(self, o): |
| '''Create cJSON (dictionary) object from VPP API aliased type''' |
| if o.manual_print: |
| return |
| |
| write = self.stream.write |
| write('static inline cJSON *vl_api_{name}_t_tojson ' |
| '(vl_api_{name}_t *a) {{\n'.format(name=o.name)) |
| |
| write(' u8 *s = format(0, "%U", format_vl_api_{}_t, a);\n' |
| .format(o.name)) |
| write(' cJSON *o = cJSON_CreateString((char *)s);\n') |
| write(' vec_free(s);\n') |
| write(' return o;\n') |
| write('}\n') |
| |
| _dispatch['Typedef'] = print_typedef |
| _dispatch['Define'] = print_define |
| _dispatch['Using'] = print_using |
| _dispatch['Union'] = print_typedef |
| |
| def generate_function(self, t): |
| '''Main entry point''' |
| write = self.stream.write |
| if t.manual_print: |
| write('/* Manual print {} */\n'.format(t.name)) |
| return |
| self._dispatch[t.type](self, t) |
| |
| def generate_types(self): |
| '''Main entry point''' |
| for t in self.types: |
| self.generate_function(t) |
| |
| def generate_defines(self): |
| '''Main entry point''' |
| for t in self.defines: |
| self.generate_function(t) |
| |
| |
| class FromJSON(): |
| ''' |
| Parse JSON objects into VPP API binary message structures. |
| ''' |
| _dispatch = {} |
| noprint_fields = {'_vl_msg_id': None, |
| 'client_index': None, |
| 'context': None} |
| is_number = {'u8': None, |
| 'i8': None, |
| 'u16': None, |
| 'i16': None, |
| 'u32': None, |
| 'i32': None, |
| 'u64': None, |
| 'i64': None, |
| 'f64': None, |
| } |
| |
| def __init__(self, module, types, defines, imported_types, stream): |
| self.stream = stream |
| self.module = module |
| self.defines = defines |
| self.types = types |
| self.types_hash = {'vl_api_'+d.name+'_t': |
| d for d in types + imported_types} |
| self.defines_hash = {d.name: d for d in defines} |
| |
| def header(self): |
| '''Output the top boilerplate.''' |
| write = self.stream.write |
| write('#ifndef included_{}_api_fromjson_h\n'.format(self.module)) |
| write('#define included_{}_api_fromjson_h\n'.format(self.module)) |
| write('#include <vppinfra/cJSON.h>\n\n') |
| write('#include <vat2/jsonconvert.h>\n\n') |
| write('#pragma GCC diagnostic ignored "-Wunused-label"\n') |
| |
| def is_base_type(self, t): |
| '''Check if a type is one of the VPP API base types''' |
| if t in self.is_number: |
| return True |
| if t == 'bool': |
| return True |
| return False |
| |
| def footer(self): |
| '''Output the bottom boilerplate.''' |
| write = self.stream.write |
| write('#endif\n') |
| |
| def print_string(self, o, toplevel=False): |
| '''Convert JSON string to vl_api_string_t''' |
| write = self.stream.write |
| |
| msgvar = "a" if toplevel else "*mp" |
| msgsize = "l" if toplevel else "*len" |
| |
| if o.modern_vla: |
| write(' char *p = cJSON_GetStringValue(item);\n') |
| write(' size_t plen = strlen(p);\n') |
| write(' {msgvar} = realloc({msgvar}, {msgsize} + plen);\n' |
| .format(msgvar=msgvar, msgsize=msgsize)) |
| write(' if ({msgvar} == 0) goto error;\n'.format(msgvar=msgvar)) |
| write(' vl_api_c_string_to_api_string(p, (void *){msgvar} + ' |
| '{msgsize} - sizeof(vl_api_string_t));\n' |
| .format(msgvar=msgvar, msgsize=msgsize)) |
| write(' {msgsize} += plen;\n'.format(msgsize=msgsize)) |
| else: |
| write(' strncpy_s((char *)a->{n}, sizeof(a->{n}), ' |
| 'cJSON_GetStringValue(item), sizeof(a->{n}) - 1);\n' |
| .format(n=o.fieldname)) |
| |
| def print_field(self, o, toplevel=False): |
| '''Called for every field in a typedef or define.''' |
| write = self.stream.write |
| if o.fieldname in self.noprint_fields: |
| return |
| is_bt = self.is_base_type(o.fieldtype) |
| t = 'vl_api_{}'.format(o.fieldtype) if is_bt else o.fieldtype |
| |
| msgvar = "(void **)&a" if toplevel else "mp" |
| msgsize = "&l" if toplevel else "len" |
| |
| if is_bt: |
| write(' vl_api_{t}_fromjson(item, &a->{n});\n' |
| .format(t=o.fieldtype, n=o.fieldname)) |
| else: |
| write(' if ({t}_fromjson({msgvar}, ' |
| '{msgsize}, item, &a->{n}) < 0) goto error;\n' |
| .format(t=t, n=o.fieldname, msgvar=msgvar, msgsize=msgsize)) |
| |
| _dispatch['Field'] = print_field |
| |
| def print_array(self, o, toplevel=False): |
| '''Convert JSON array to VPP API array''' |
| write = self.stream.write |
| |
| forloop = '''\ |
| {{ |
| int i; |
| cJSON *array = cJSON_GetObjectItem(o, "{n}"); |
| int size = cJSON_GetArraySize(array); |
| if (size != {lfield}) goto error; |
| for (i = 0; i < size; i++) {{ |
| cJSON *e = cJSON_GetArrayItem(array, i); |
| {call} |
| }} |
| }} |
| ''' |
| forloop_vla = '''\ |
| {{ |
| int i; |
| cJSON *array = cJSON_GetObjectItem(o, "{n}"); |
| int size = cJSON_GetArraySize(array); |
| {lfield} = size; |
| {realloc} = realloc({realloc}, {msgsize} + sizeof({t}) * size); |
| {t} *d = (void *){realloc} + {msgsize}; |
| {msgsize} += sizeof({t}) * size; |
| for (i = 0; i < size; i++) {{ |
| cJSON *e = cJSON_GetArrayItem(array, i); |
| {call} |
| }} |
| }} |
| ''' |
| t = o.fieldtype |
| if o.fieldtype == 'string': |
| self.print_string(o, toplevel) |
| return |
| |
| lfield = 'a->' + o.lengthfield if o.lengthfield else o.length |
| msgvar = "(void **)&a" if toplevel else "mp" |
| realloc = "a" if toplevel else "*mp" |
| msgsize = "l" if toplevel else "*len" |
| |
| if o.fieldtype == 'u8': |
| if o.lengthfield: |
| write(' s = u8string_fromjson(o, "{}");\n' |
| .format(o.fieldname)) |
| write(' if (!s) goto error;\n') |
| write(' {} = vec_len(s);\n'.format(lfield)) |
| |
| write(' {realloc} = realloc({realloc}, {msgsize} + ' |
| 'vec_len(s));\n'.format(msgvar=msgvar, msgsize=msgsize, realloc=realloc)) |
| write(' memcpy((void *){realloc} + {msgsize}, s, ' |
| 'vec_len(s));\n'.format(realloc=realloc, msgsize=msgsize)) |
| write(' {msgsize} += vec_len(s);\n'.format(msgsize=msgsize)) |
| |
| write(' vec_free(s);\n') |
| else: |
| write(' if (u8string_fromjson2(o, "{n}", a->{n}) < 0) goto error;\n' |
| .format(n=o.fieldname)) |
| return |
| |
| is_bt = self.is_base_type(o.fieldtype) |
| |
| if o.lengthfield: |
| if is_bt: |
| call = ('vl_api_{t}_fromjson(e, &d[i]);' |
| .format(t=o.fieldtype)) |
| else: |
| call = ('if ({t}_fromjson({msgvar}, len, e, &d[i]) < 0) goto error; ' |
| .format(t=o.fieldtype, msgvar=msgvar)) |
| write(forloop_vla.format(lfield=lfield, |
| t=o.fieldtype, |
| n=o.fieldname, |
| call=call, |
| realloc=realloc, |
| msgsize=msgsize)) |
| else: |
| if is_bt: |
| call = ('vl_api_{t}_fromjson(e, &a->{n}[i]);' |
| .format(t=t, n=o.fieldname)) |
| else: |
| call = ('if ({}_fromjson({}, len, e, &a->{}[i]) < 0) goto error;' |
| .format(t, msgvar, o.fieldname)) |
| write(forloop.format(lfield=lfield, |
| t=t, |
| n=o.fieldname, |
| call=call, |
| msgvar=msgvar, |
| realloc=realloc, |
| msgsize=msgsize)) |
| |
| _dispatch['Array'] = print_array |
| |
| def print_enum(self, o): |
| '''Convert to JSON enum(string) to VPP API enum (int)''' |
| write = self.stream.write |
| write('static inline int vl_api_{n}_t_fromjson' |
| '(void **mp, int *len, cJSON *o, vl_api_{n}_t *a) {{\n' |
| .format(n=o.name)) |
| write(' char *p = cJSON_GetStringValue(o);\n') |
| for b in o.block: |
| write(' if (strcmp(p, "{}") == 0) {{*a = {}; return 0;}}\n' |
| .format(b[0], b[1])) |
| write(' *a = 0;\n') |
| write(' return -1;\n') |
| write('}\n') |
| |
| _dispatch['Enum'] = print_enum |
| |
| def print_enum_flag(self, o): |
| '''Convert to JSON enum(string) to VPP API enum (int)''' |
| write = self.stream.write |
| write('static inline int vl_api_{n}_t_fromjson ' |
| '(void **mp, int *len, cJSON *o, vl_api_{n}_t *a) {{\n' |
| .format(n=o.name)) |
| write(' int i;\n') |
| write(' *a = 0;\n') |
| write(' for (i = 0; i < cJSON_GetArraySize(o); i++) {\n') |
| write(' cJSON *e = cJSON_GetArrayItem(o, i);\n') |
| write(' char *p = cJSON_GetStringValue(e);\n') |
| write(' if (!p) return -1;\n') |
| for b in o.block: |
| write(' if (strcmp(p, "{}") == 0) *a |= {};\n' |
| .format(b[0], b[1])) |
| write(' }\n') |
| write(' return 0;\n') |
| write('}\n') |
| |
| _dispatch['EnumFlag'] = print_enum_flag |
| |
| def print_typedef(self, o): |
| '''Convert from JSON object to VPP API binary representation''' |
| write = self.stream.write |
| |
| write('static inline int vl_api_{name}_t_fromjson (void **mp, ' |
| 'int *len, cJSON *o, vl_api_{name}_t *a) {{\n' |
| .format(name=o.name)) |
| write(' cJSON *item __attribute__ ((unused));\n') |
| write(' u8 *s __attribute__ ((unused));\n') |
| for t in o.block: |
| if t.type == 'Field' and t.is_lengthfield: |
| continue |
| write('\n item = cJSON_GetObjectItem(o, "{}");\n' |
| .format(t.fieldname)) |
| write(' if (!item) goto error;\n') |
| self._dispatch[t.type](self, t) |
| |
| write('\n return 0;\n') |
| write('\n error:\n') |
| write(' return -1;\n') |
| write('}\n') |
| |
| def print_union(self, o): |
| '''Convert JSON object to VPP API binary union''' |
| write = self.stream.write |
| |
| write('static inline int vl_api_{name}_t_fromjson (void **mp, ' |
| 'int *len, cJSON *o, vl_api_{name}_t *a) {{\n' |
| .format(name=o.name)) |
| write(' cJSON *item __attribute__ ((unused));\n') |
| write(' u8 *s __attribute__ ((unused));\n') |
| for t in o.block: |
| if t.type == 'Field' and t.is_lengthfield: |
| continue |
| write(' item = cJSON_GetObjectItem(o, "{}");\n' |
| .format(t.fieldname)) |
| write(' if (item) {\n') |
| self._dispatch[t.type](self, t) |
| write(' };\n') |
| write('\n return 0;\n') |
| write('\n error:\n') |
| write(' return -1;\n') |
| write('}\n') |
| |
| def print_define(self, o): |
| '''Convert JSON object to VPP API message''' |
| write = self.stream.write |
| error = 0 |
| write('static inline vl_api_{name}_t *vl_api_{name}_t_fromjson ' |
| '(cJSON *o, int *len) {{\n'.format(name=o.name)) |
| write(' cJSON *item __attribute__ ((unused));\n') |
| write(' u8 *s __attribute__ ((unused));\n') |
| write(' int l = sizeof(vl_api_{}_t);\n'.format(o.name)) |
| write(' vl_api_{}_t *a = malloc(l);\n'.format(o.name)) |
| write('\n') |
| |
| for t in o.block: |
| if t.fieldname in self.noprint_fields: |
| continue |
| if t.type == 'Field' and t.is_lengthfield: |
| continue |
| write(' item = cJSON_GetObjectItem(o, "{}");\n' |
| .format(t.fieldname)) |
| write(' if (!item) goto error;\n') |
| error += 1 |
| self._dispatch[t.type](self, t, toplevel=True) |
| write('\n') |
| |
| write(' *len = l;\n') |
| write(' return a;\n') |
| |
| if error: |
| write('\n error:\n') |
| write(' free(a);\n') |
| write(' return 0;\n') |
| write('}\n') |
| |
| def print_using(self, o): |
| '''Convert JSON field to VPP type alias''' |
| write = self.stream.write |
| |
| if o.manual_print: |
| return |
| |
| t = o.using |
| write('static inline int vl_api_{name}_t_fromjson (void **mp, ' |
| 'int *len, cJSON *o, vl_api_{name}_t *a) {{\n' |
| .format(name=o.name)) |
| if 'length' in o.alias: |
| if t.fieldtype != 'u8': |
| raise ValueError("Error in processing type {} for {}" |
| .format(t.fieldtype, o.name)) |
| write(' vl_api_u8_string_fromjson(o, (u8 *)a, {});\n' |
| .format(o.alias['length'])) |
| else: |
| write(' vl_api_{t}_fromjson(o, ({t} *)a);\n' |
| .format(t=t.fieldtype)) |
| |
| write(' return 0;\n') |
| write('}\n') |
| |
| _dispatch['Typedef'] = print_typedef |
| _dispatch['Define'] = print_define |
| _dispatch['Using'] = print_using |
| _dispatch['Union'] = print_union |
| |
| def generate_function(self, t): |
| '''Main entry point''' |
| write = self.stream.write |
| if t.manual_print: |
| write('/* Manual print {} */\n'.format(t.name)) |
| return |
| self._dispatch[t.type](self, t) |
| |
| def generate_types(self): |
| '''Main entry point''' |
| for t in self.types: |
| self.generate_function(t) |
| |
| def generate_defines(self): |
| '''Main entry point''' |
| for t in self.defines: |
| self.generate_function(t) |
| |
| |
| def generate_tojson(s, modulename, stream): |
| '''Generate all functions to convert from API to JSON''' |
| write = stream.write |
| |
| write('/* Imported API files */\n') |
| for i in s['Import']: |
| f = i.filename.replace('plugins/', '') |
| write('#include <{}_tojson.h>\n'.format(f)) |
| |
| pp = ToJSON(modulename, s['types'], s['Define'], s['imported']['types'], |
| stream) |
| pp.header() |
| pp.generate_types() |
| pp.generate_defines() |
| pp.footer() |
| return '' |
| |
| |
| def generate_fromjson(s, modulename, stream): |
| '''Generate all functions to convert from JSON to API''' |
| write = stream.write |
| write('/* Imported API files */\n') |
| for i in s['Import']: |
| f = i.filename.replace('plugins/', '') |
| write('#include <{}_fromjson.h>\n'.format(f)) |
| |
| pp = FromJSON(modulename, s['types'], s['Define'], s['imported']['types'], |
| stream) |
| pp.header() |
| pp.generate_types() |
| pp.generate_defines() |
| pp.footer() |
| |
| return '' |
| |
| ############################################################################### |
| |
| |
| DATESTRING = datetime.datetime.utcfromtimestamp( |
| int(os.environ.get('SOURCE_DATE_EPOCH', time.time()))) |
| TOP_BOILERPLATE = '''\ |
| /* |
| * VLIB API definitions {datestring} |
| * Input file: {input_filename} |
| * Automatically generated: please edit the input file NOT this file! |
| */ |
| |
| #include <stdbool.h> |
| #if defined(vl_msg_id)||defined(vl_union_id) \\ |
| || defined(vl_printfun) ||defined(vl_endianfun) \\ |
| || defined(vl_api_version)||defined(vl_typedefs) \\ |
| || defined(vl_msg_name)||defined(vl_msg_name_crc_list) \\ |
| || defined(vl_api_version_tuple) |
| /* ok, something was selected */ |
| #else |
| #warning no content included from {input_filename} |
| #endif |
| |
| #define VL_API_PACKED(x) x __attribute__ ((packed)) |
| ''' |
| |
| BOTTOM_BOILERPLATE = '''\ |
| /****** API CRC (whole file) *****/ |
| |
| #ifdef vl_api_version |
| vl_api_version({input_filename}, {file_crc:#08x}) |
| |
| #endif |
| ''' |
| |
| |
| def msg_ids(s): |
| '''Generate macro to map API message id to handler''' |
| output = '''\ |
| |
| /****** Message ID / handler enum ******/ |
| |
| #ifdef vl_msg_id |
| ''' |
| |
| for t in s['Define']: |
| output += "vl_msg_id(VL_API_%s, vl_api_%s_t_handler)\n" % \ |
| (t.name.upper(), t.name) |
| output += "#endif" |
| |
| return output |
| |
| |
| def msg_names(s): |
| '''Generate calls to name mapping macro''' |
| output = '''\ |
| |
| /****** Message names ******/ |
| |
| #ifdef vl_msg_name |
| ''' |
| |
| for t in s['Define']: |
| dont_trace = 0 if t.dont_trace else 1 |
| output += "vl_msg_name(vl_api_%s_t, %d)\n" % (t.name, dont_trace) |
| output += "#endif" |
| |
| return output |
| |
| |
| def msg_name_crc_list(s, suffix): |
| '''Generate list of names to CRC mappings''' |
| output = '''\ |
| |
| /****** Message name, crc list ******/ |
| |
| #ifdef vl_msg_name_crc_list |
| ''' |
| output += "#define foreach_vl_msg_name_crc_%s " % suffix |
| |
| for t in s['Define']: |
| output += "\\\n_(VL_API_%s, %s, %08x) " % \ |
| (t.name.upper(), t.name, t.crc) |
| output += "\n#endif" |
| |
| return output |
| |
| |
| def api2c(fieldtype): |
| '''Map between API type names and internal VPP type names''' |
| mappingtable = {'string': 'vl_api_string_t', } |
| if fieldtype in mappingtable: |
| return mappingtable[fieldtype] |
| return fieldtype |
| |
| |
| def typedefs(filename): |
| '''Include in the main files to the types file''' |
| output = '''\ |
| |
| /****** Typedefs ******/ |
| |
| #ifdef vl_typedefs |
| #include "{include}.api_types.h" |
| #endif |
| '''.format(include=filename) |
| return output |
| |
| |
| FORMAT_STRINGS = {'u8': '%u', |
| 'bool': '%u', |
| 'i8': '%d', |
| 'u16': '%u', |
| 'i16': '%d', |
| 'u32': '%u', |
| 'i32': '%ld', |
| 'u64': '%llu', |
| 'i64': '%lld', |
| 'f64': '%.2f'} |
| |
| |
| class Printfun(): |
| '''Functions for pretty printing VPP API messages''' |
| _dispatch = {} |
| noprint_fields = {'_vl_msg_id': None, |
| 'client_index': None, |
| 'context': None} |
| |
| def __init__(self, stream): |
| self.stream = stream |
| |
| @staticmethod |
| def print_string(o, stream): |
| '''Pretty print a vl_api_string_t''' |
| write = stream.write |
| if o.modern_vla: |
| write(' if (vl_api_string_len(&a->{f}) > 0) {{\n' |
| .format(f=o.fieldname)) |
| write(' s = format(s, "\\n%U{f}: %U", ' |
| 'format_white_space, indent, ' |
| 'vl_api_format_string, (&a->{f}));\n'.format(f=o.fieldname)) |
| write(' } else {\n') |
| write(' s = format(s, "\\n%U{f}:", ' |
| 'format_white_space, indent);\n'.format(f=o.fieldname)) |
| write(' }\n') |
| else: |
| write(' s = format(s, "\\n%U{f}: %s", ' |
| 'format_white_space, indent, a->{f});\n' |
| .format(f=o.fieldname)) |
| |
| def print_field(self, o, stream): |
| '''Pretty print API field''' |
| write = stream.write |
| if o.fieldname in self.noprint_fields: |
| return |
| if o.fieldtype in FORMAT_STRINGS: |
| f = FORMAT_STRINGS[o.fieldtype] |
| write(' s = format(s, "\\n%U{n}: {f}", ' |
| 'format_white_space, indent, a->{n});\n' |
| .format(n=o.fieldname, f=f)) |
| else: |
| write(' s = format(s, "\\n%U{n}: %U", ' |
| 'format_white_space, indent, ' |
| 'format_{t}, &a->{n}, indent);\n' |
| .format(n=o.fieldname, t=o.fieldtype)) |
| |
| _dispatch['Field'] = print_field |
| |
| def print_array(self, o, stream): |
| '''Pretty print API array''' |
| write = stream.write |
| |
| forloop = '''\ |
| for (i = 0; i < {lfield}; i++) {{ |
| s = format(s, "\\n%U{n}: %U", |
| format_white_space, indent, format_{t}, &a->{n}[i], indent); |
| }} |
| ''' |
| |
| forloop_format = '''\ |
| for (i = 0; i < {lfield}; i++) {{ |
| s = format(s, "\\n%U{n}: {t}", |
| format_white_space, indent, a->{n}[i]); |
| }} |
| ''' |
| |
| if o.fieldtype == 'string': |
| self.print_string(o, stream) |
| return |
| |
| if o.fieldtype == 'u8': |
| if o.lengthfield: |
| write(' s = format(s, "\\n%U{n}: %U", format_white_space, ' |
| 'indent, format_hex_bytes, a->{n}, a->{lfield});\n' |
| .format(n=o.fieldname, lfield=o.lengthfield)) |
| else: |
| write(' s = format(s, "\\n%U{n}: %U", format_white_space, ' |
| 'indent, format_hex_bytes, a, {lfield});\n' |
| .format(n=o.fieldname, lfield=o.length)) |
| return |
| |
| lfield = 'a->' + o.lengthfield if o.lengthfield else o.length |
| if o.fieldtype in FORMAT_STRINGS: |
| write(forloop_format.format(lfield=lfield, |
| t=FORMAT_STRINGS[o.fieldtype], |
| n=o.fieldname)) |
| else: |
| write(forloop.format(lfield=lfield, t=o.fieldtype, n=o.fieldname)) |
| |
| _dispatch['Array'] = print_array |
| |
| @staticmethod |
| def print_alias(k, v, stream): |
| '''Pretty print type alias''' |
| write = stream.write |
| if ('length' in v.alias and v.alias['length'] and |
| v.alias['type'] == 'u8'): |
| write(' return format(s, "%U", format_hex_bytes, a, {});\n' |
| .format(v.alias['length'])) |
| elif v.alias['type'] in FORMAT_STRINGS: |
| write(' return format(s, "{}", *a);\n' |
| .format(FORMAT_STRINGS[v.alias['type']])) |
| else: |
| write(' return format(s, "{} (print not implemented)");\n' |
| .format(k)) |
| |
| @staticmethod |
| def print_enum(o, stream): |
| '''Pretty print API enum''' |
| write = stream.write |
| write(" switch(*a) {\n") |
| for b in o: |
| write(" case %s:\n" % b[1]) |
| write(' return format(s, "{}");\n'.format(b[0])) |
| write(' }\n') |
| |
| _dispatch['Enum'] = print_enum |
| _dispatch['EnumFlag'] = print_enum |
| |
| def print_obj(self, o, stream): |
| '''Entry point''' |
| write = stream.write |
| |
| if o.type in self._dispatch: |
| self._dispatch[o.type](self, o, stream) |
| else: |
| write(' s = format(s, "\\n{} {} {} (print not implemented");\n' |
| .format(o.type, o.fieldtype, o.fieldname)) |
| |
| |
| def printfun(objs, stream, modulename): |
| '''Main entry point for pretty print function generation''' |
| write = stream.write |
| |
| h = '''\ |
| /****** Print functions *****/ |
| #ifdef vl_printfun |
| #ifndef included_{module}_printfun |
| #define included_{module}_printfun |
| |
| #ifdef LP64 |
| #define _uword_fmt \"%lld\" |
| #define _uword_cast (long long) |
| #else |
| #define _uword_fmt \"%ld\" |
| #define _uword_cast long |
| #endif |
| |
| ''' |
| |
| signature = '''\ |
| static inline void *vl_api_{name}_t_print (vl_api_{name}_t *a, void *handle) |
| {{ |
| u8 *s = 0; |
| u32 indent __attribute__((unused)) = 2; |
| int i __attribute__((unused)); |
| ''' |
| |
| h = h.format(module=modulename) |
| write(h) |
| |
| pp = Printfun(stream) |
| for t in objs: |
| if t.manual_print: |
| write("/***** manual: vl_api_%s_t_print *****/\n\n" % t.name) |
| continue |
| write(signature.format(name=t.name)) |
| write(' /* Message definition: vl_api_{}_t: */\n'.format(t.name)) |
| write(" s = format(s, \"vl_api_%s_t:\");\n" % t.name) |
| for o in t.block: |
| pp.print_obj(o, stream) |
| write(' vec_add1(s, 0);\n') |
| write(' vl_print (handle, (char *)s);\n') |
| write(' vec_free (s);\n') |
| write(' return handle;\n') |
| write('}\n\n') |
| |
| write("\n#endif") |
| write("\n#endif /* vl_printfun */\n") |
| |
| return '' |
| |
| |
| def printfun_types(objs, stream, modulename): |
| '''Pretty print API types''' |
| write = stream.write |
| pp = Printfun(stream) |
| |
| h = '''\ |
| /****** Print functions *****/ |
| #ifdef vl_printfun |
| #ifndef included_{module}_printfun_types |
| #define included_{module}_printfun_types |
| |
| ''' |
| h = h.format(module=modulename) |
| write(h) |
| |
| signature = '''\ |
| static inline u8 *format_vl_api_{name}_t (u8 *s, va_list * args) |
| {{ |
| vl_api_{name}_t *a = va_arg (*args, vl_api_{name}_t *); |
| u32 indent __attribute__((unused)) = va_arg (*args, u32); |
| int i __attribute__((unused)); |
| indent += 2; |
| ''' |
| |
| for t in objs: |
| if t.__class__.__name__ == 'Enum' or t.__class__.__name__ == 'EnumFlag': |
| write(signature.format(name=t.name)) |
| pp.print_enum(t.block, stream) |
| write(' return s;\n') |
| write('}\n\n') |
| continue |
| |
| if t.manual_print: |
| write("/***** manual: vl_api_%s_t_print *****/\n\n" % t.name) |
| continue |
| |
| if t.__class__.__name__ == 'Using': |
| write(signature.format(name=t.name)) |
| pp.print_alias(t.name, t, stream) |
| write('}\n\n') |
| continue |
| |
| write(signature.format(name=t.name)) |
| for o in t.block: |
| pp.print_obj(o, stream) |
| |
| write(' return s;\n') |
| write('}\n\n') |
| |
| write("\n#endif") |
| write("\n#endif /* vl_printfun_types */\n") |
| |
| |
| def generate_imports(imports): |
| '''Add #include matching the API import statements''' |
| output = '/* Imported API files */\n' |
| output += '#ifndef vl_api_version\n' |
| |
| for i in imports: |
| s = i.filename.replace('plugins/', '') |
| output += '#include <{}.h>\n'.format(s) |
| output += '#endif\n' |
| return output |
| |
| |
| ENDIAN_STRINGS = { |
| 'u16': 'clib_net_to_host_u16', |
| 'u32': 'clib_net_to_host_u32', |
| 'u64': 'clib_net_to_host_u64', |
| 'i16': 'clib_net_to_host_i16', |
| 'i32': 'clib_net_to_host_i32', |
| 'i64': 'clib_net_to_host_i64', |
| 'f64': 'clib_net_to_host_f64', |
| } |
| |
| |
| def endianfun_array(o): |
| '''Generate endian functions for arrays''' |
| forloop = '''\ |
| for (i = 0; i < {length}; i++) {{ |
| a->{name}[i] = {format}(a->{name}[i]); |
| }} |
| ''' |
| |
| forloop_format = '''\ |
| for (i = 0; i < {length}; i++) {{ |
| {type}_endian(&a->{name}[i]); |
| }} |
| ''' |
| |
| output = '' |
| if o.fieldtype == 'u8' or o.fieldtype == 'string' or o.fieldtype == 'bool': |
| output += ' /* a->{n} = a->{n} (no-op) */\n'.format(n=o.fieldname) |
| else: |
| lfield = 'a->' + o.lengthfield if o.lengthfield else o.length |
| if o.fieldtype in ENDIAN_STRINGS: |
| output += (forloop |
| .format(length=lfield, |
| format=ENDIAN_STRINGS[o.fieldtype], |
| name=o.fieldname)) |
| else: |
| output += (forloop_format |
| .format(length=lfield, type=o.fieldtype, |
| name=o.fieldname)) |
| return output |
| |
| |
| NO_ENDIAN_CONVERSION = {'client_index': None} |
| |
| |
| def endianfun_obj(o): |
| '''Generate endian conversion function for type''' |
| output = '' |
| if o.type == 'Array': |
| return endianfun_array(o) |
| if o.type != 'Field': |
| output += (' s = format(s, "\\n{} {} {} (print not implemented");\n' |
| .format(o.type, o.fieldtype, o.fieldname)) |
| return output |
| if o.fieldname in NO_ENDIAN_CONVERSION: |
| output += ' /* a->{n} = a->{n} (no-op) */\n'.format(n=o.fieldname) |
| return output |
| if o.fieldtype in ENDIAN_STRINGS: |
| output += (' a->{name} = {format}(a->{name});\n' |
| .format(name=o.fieldname, |
| format=ENDIAN_STRINGS[o.fieldtype])) |
| elif o.fieldtype.startswith('vl_api_'): |
| output += (' {type}_endian(&a->{name});\n' |
| .format(type=o.fieldtype, name=o.fieldname)) |
| else: |
| output += ' /* a->{n} = a->{n} (no-op) */\n'.format(n=o.fieldname) |
| |
| return output |
| |
| |
| def endianfun(objs, modulename): |
| '''Main entry point for endian function generation''' |
| output = '''\ |
| |
| /****** Endian swap functions *****/\n\ |
| #ifdef vl_endianfun |
| #ifndef included_{module}_endianfun |
| #define included_{module}_endianfun |
| |
| #undef clib_net_to_host_uword |
| #ifdef LP64 |
| #define clib_net_to_host_uword clib_net_to_host_u64 |
| #else |
| #define clib_net_to_host_uword clib_net_to_host_u32 |
| #endif |
| |
| ''' |
| output = output.format(module=modulename) |
| |
| signature = '''\ |
| static inline void vl_api_{name}_t_endian (vl_api_{name}_t *a) |
| {{ |
| int i __attribute__((unused)); |
| ''' |
| |
| for t in objs: |
| if t.__class__.__name__ == 'Enum' or t.__class__.__name__ == 'EnumFlag' : |
| output += signature.format(name=t.name) |
| if t.enumtype in ENDIAN_STRINGS: |
| output += (' *a = {}(*a);\n' |
| .format(ENDIAN_STRINGS[t.enumtype])) |
| else: |
| output += (' /* a->{name} = a->{name} (no-op) */\n' |
| .format(name=t.name)) |
| |
| output += '}\n\n' |
| continue |
| |
| if t.manual_endian: |
| output += "/***** manual: vl_api_%s_t_endian *****/\n\n" % t.name |
| continue |
| |
| if t.__class__.__name__ == 'Using': |
| output += signature.format(name=t.name) |
| if ('length' in t.alias and t.alias['length'] and |
| t.alias['type'] == 'u8'): |
| output += (' /* a->{name} = a->{name} (no-op) */\n' |
| .format(name=t.name)) |
| elif t.alias['type'] in FORMAT_STRINGS: |
| output += (' *a = {}(*a);\n' |
| .format(ENDIAN_STRINGS[t.alias['type']])) |
| else: |
| output += ' /* Not Implemented yet {} */'.format(t.name) |
| output += '}\n\n' |
| continue |
| |
| output += signature.format(name=t.name) |
| |
| for o in t.block: |
| output += endianfun_obj(o) |
| output += '}\n\n' |
| |
| output += "\n#endif" |
| output += "\n#endif /* vl_endianfun */\n\n" |
| |
| return output |
| |
| |
| def version_tuple(s, module): |
| '''Generate semantic version string''' |
| output = '''\ |
| /****** Version tuple *****/ |
| |
| #ifdef vl_api_version_tuple |
| |
| ''' |
| if 'version' in s['Option']: |
| v = s['Option']['version'] |
| (major, minor, patch) = v.split('.') |
| output += "vl_api_version_tuple(%s, %s, %s, %s)\n" % \ |
| (module, major, minor, patch) |
| |
| output += "\n#endif /* vl_api_version_tuple */\n\n" |
| |
| return output |
| |
| |
| def generate_include_enum(s, module, stream): |
| '''Generate <name>.api_enum.h''' |
| write = stream.write |
| |
| if 'Define' in s: |
| write('typedef enum {\n') |
| for t in s['Define']: |
| write(' VL_API_{},\n'.format(t.name.upper())) |
| write(' VL_MSG_{}_LAST\n'.format(module.upper())) |
| write('}} vl_api_{}_enum_t;\n'.format(module)) |
| |
| |
| def generate_include_counters(s, stream): |
| '''Include file for the counter data model types.''' |
| write = stream.write |
| |
| for counters in s: |
| csetname = counters.name |
| write('typedef enum {\n') |
| for c in counters.block: |
| write(' {}_ERROR_{},\n' |
| .format(csetname.upper(), c['name'].upper())) |
| write(' {}_N_ERROR\n'.format(csetname.upper())) |
| write('}} vl_counter_{}_enum_t;\n'.format(csetname)) |
| |
| write('extern vlib_error_desc_t {}_error_counters[];\n'.format(csetname)) |
| |
| |
| def generate_include_types(s, module, stream): |
| '''Generate separate API _types file.''' |
| write = stream.write |
| |
| write('#ifndef included_{module}_api_types_h\n'.format(module=module)) |
| write('#define included_{module}_api_types_h\n'.format(module=module)) |
| |
| if 'version' in s['Option']: |
| v = s['Option']['version'] |
| (major, minor, patch) = v.split('.') |
| write('#define VL_API_{m}_API_VERSION_MAJOR {v}\n' |
| .format(m=module.upper(), v=major)) |
| write('#define VL_API_{m}_API_VERSION_MINOR {v}\n' |
| .format(m=module.upper(), v=minor)) |
| write('#define VL_API_{m}_API_VERSION_PATCH {v}\n' |
| .format(m=module.upper(), v=patch)) |
| |
| if 'Import' in s: |
| write('/* Imported API files */\n') |
| for i in s['Import']: |
| filename = i.filename.replace('plugins/', '') |
| write('#include <{}_types.h>\n'.format(filename)) |
| |
| for o in s['types'] + s['Define']: |
| tname = o.__class__.__name__ |
| if tname == 'Using': |
| if 'length' in o.alias: |
| write('typedef %s vl_api_%s_t[%s];\n' % |
| (o.alias['type'], o.name, o.alias['length'])) |
| else: |
| write('typedef %s vl_api_%s_t;\n' % (o.alias['type'], o.name)) |
| elif tname == 'Enum' or tname == 'EnumFlag': |
| if o.enumtype == 'u32': |
| write("typedef enum {\n") |
| else: |
| write("typedef enum __attribute__((packed)) {\n") |
| |
| for b in o.block: |
| write(" %s = %s,\n" % (b[0], b[1])) |
| write('} vl_api_%s_t;\n' % o.name) |
| if o.enumtype != 'u32': |
| size1 = 'sizeof(vl_api_%s_t)' % o.name |
| size2 = 'sizeof(%s)' % o.enumtype |
| err_str = 'size of API enum %s is wrong' % o.name |
| write('STATIC_ASSERT(%s == %s, "%s");\n' |
| % (size1, size2, err_str)) |
| else: |
| if tname == 'Union': |
| write("typedef union __attribute__ ((packed)) _vl_api_%s {\n" |
| % o.name) |
| else: |
| write(("typedef struct __attribute__ ((packed)) _vl_api_%s {\n") |
| % o.name) |
| for b in o.block: |
| if b.type == 'Option': |
| continue |
| if b.type == 'Field': |
| write(" %s %s;\n" % (api2c(b.fieldtype), |
| b.fieldname)) |
| elif b.type == 'Array': |
| if b.lengthfield: |
| write(" %s %s[0];\n" % (api2c(b.fieldtype), |
| b.fieldname)) |
| else: |
| # Fixed length strings decay to nul terminated u8 |
| if b.fieldtype == 'string': |
| if b.modern_vla: |
| write(' {} {};\n' |
| .format(api2c(b.fieldtype), |
| b.fieldname)) |
| else: |
| write(' u8 {}[{}];\n' |
| .format(b.fieldname, b.length)) |
| else: |
| write(" %s %s[%s];\n" % |
| (api2c(b.fieldtype), b.fieldname, |
| b.length)) |
| else: |
| raise ValueError("Error in processing type {} for {}" |
| .format(b, o.name)) |
| |
| write('} vl_api_%s_t;\n' % o.name) |
| |
| for t in s['Define']: |
| write('#define VL_API_{ID}_CRC "{n}_{crc:08x}"\n' |
| .format(n=t.name, ID=t.name.upper(), crc=t.crc)) |
| |
| write("\n#endif\n") |
| |
| |
| def generate_c_boilerplate(services, defines, counters, file_crc, |
| module, stream): |
| '''VPP side plugin.''' |
| write = stream.write |
| define_hash = {d.name: d for d in defines} |
| |
| hdr = '''\ |
| #define vl_endianfun /* define message structures */ |
| #include "{module}.api.h" |
| #undef vl_endianfun |
| |
| /* instantiate all the print functions we know about */ |
| #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__) |
| #define vl_printfun |
| #include "{module}.api.h" |
| #undef vl_printfun |
| |
| ''' |
| |
| write(hdr.format(module=module)) |
| write('static u16\n') |
| write('setup_message_id_table (void) {\n') |
| write(' api_main_t *am = my_api_main;\n') |
| write(' vl_msg_api_msg_config_t c;\n') |
| write(' u16 msg_id_base = vl_msg_api_get_msg_ids ("{}_{crc:08x}", ' |
| 'VL_MSG_{m}_LAST);\n' |
| .format(module, crc=file_crc, m=module.upper())) |
| |
| for d in defines: |
| write(' vl_msg_api_add_msg_name_crc (am, "{n}_{crc:08x}",\n' |
| ' VL_API_{ID} + msg_id_base);\n' |
| .format(n=d.name, ID=d.name.upper(), crc=d.crc)) |
| for s in services: |
| d = define_hash[s.caller] |
| write(' c = (vl_msg_api_msg_config_t) ' |
| ' {{.id = VL_API_{ID} + msg_id_base,\n' |
| ' .name = "{n}",\n' |
| ' .handler = vl_api_{n}_t_handler,\n' |
| ' .cleanup = vl_noop_handler,\n' |
| ' .endian = vl_api_{n}_t_endian,\n' |
| ' .print = vl_api_{n}_t_print,\n' |
| ' .is_autoendian = {auto}}};\n' |
| .format(n=s.caller, ID=s.caller.upper(), |
| auto=d.autoendian)) |
| write(' vl_msg_api_config (&c);\n') |
| try: |
| d = define_hash[s.reply] |
| write(' c = (vl_msg_api_msg_config_t) ' |
| '{{.id = VL_API_{ID} + msg_id_base,\n' |
| ' .name = "{n}",\n' |
| ' .handler = 0,\n' |
| ' .cleanup = vl_noop_handler,\n' |
| ' .endian = vl_api_{n}_t_endian,\n' |
| ' .print = vl_api_{n}_t_print,\n' |
| ' .is_autoendian = {auto}}};\n' |
| .format(n=s.reply, ID=s.reply.upper(), |
| auto=d.autoendian)) |
| write(' vl_msg_api_config (&c);\n') |
| except KeyError: |
| pass |
| |
| write(' return msg_id_base;\n') |
| write('}\n') |
| |
| severity = {'error': 'VL_COUNTER_SEVERITY_ERROR', |
| 'info': 'VL_COUNTER_SEVERITY_INFO', |
| 'warn': 'VL_COUNTER_SEVERITY_WARN'} |
| |
| for cnt in counters: |
| csetname = cnt.name |
| write('vlib_error_desc_t {}_error_counters[] = {{\n'.format(csetname)) |
| for c in cnt.block: |
| write(' {\n') |
| write(' .name = "{}",\n'.format(c['name'])) |
| write(' .desc = "{}",\n'.format(c['description'])) |
| write(' .severity = {},\n'.format(severity[c['severity']])) |
| write(' },\n') |
| write('};\n') |
| |
| |
| def generate_c_test_boilerplate(services, defines, file_crc, module, plugin, |
| stream): |
| '''Generate code for legacy style VAT. To be deleted.''' |
| write = stream.write |
| |
| define_hash = {d.name: d for d in defines} |
| |
| hdr = '''\ |
| #define vl_endianfun /* define message structures */ |
| #include "{module}.api.h" |
| #undef vl_endianfun |
| |
| /* instantiate all the print functions we know about */ |
| #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__) |
| #define vl_printfun |
| #include "{module}.api.h" |
| #undef vl_printfun |
| |
| ''' |
| |
| write(hdr.format(module=module)) |
| for s in services: |
| try: |
| d = define_hash[s.reply] |
| except KeyError: |
| continue |
| if d.manual_print: |
| write('/*\n' |
| ' * Manual definition requested for: \n' |
| ' * vl_api_{n}_t_handler()\n' |
| ' */\n' |
| .format(n=s.reply)) |
| continue |
| if not define_hash[s.caller].autoreply: |
| write('/* Generation not supported (vl_api_{n}_t_handler()) */\n' |
| .format(n=s.reply)) |
| continue |
| write('#ifndef VL_API_{n}_T_HANDLER\n'.format(n=s.reply.upper())) |
| write('static void\n') |
| write('vl_api_{n}_t_handler (vl_api_{n}_t * mp) {{\n' |
| .format(n=s.reply)) |
| write(' vat_main_t * vam = {}_test_main.vat_main;\n'.format(module)) |
| write(' i32 retval = ntohl(mp->retval);\n') |
| write(' if (vam->async_mode) {\n') |
| write(' vam->async_errors += (retval < 0);\n') |
| write(' } else {\n') |
| write(' vam->retval = retval;\n') |
| write(' vam->result_ready = 1;\n') |
| write(' }\n') |
| write('}\n') |
| write('#endif\n') |
| |
| for e in s.events: |
| if define_hash[e].manual_print: |
| continue |
| write('static void\n') |
| write('vl_api_{n}_t_handler (vl_api_{n}_t * mp) {{\n'.format(n=e)) |
| write(' vl_print(0, "{n} event called:");\n'.format(n=e)) |
| write(' vl_api_{n}_t_print(mp, 0);\n'.format(n=e)) |
| write('}\n') |
| |
| write('static void\n') |
| write('setup_message_id_table (vat_main_t * vam, u16 msg_id_base) {\n') |
| for s in services: |
| write(' vl_msg_api_set_handlers(VL_API_{ID} + msg_id_base, ' |
| ' "{n}",\n' |
| ' vl_api_{n}_t_handler, ' |
| ' vl_noop_handler,\n' |
| ' vl_api_{n}_t_endian, ' |
| ' vl_api_{n}_t_print,\n' |
| ' sizeof(vl_api_{n}_t), 1);\n' |
| .format(n=s.reply, ID=s.reply.upper())) |
| write(' hash_set_mem (vam->function_by_name, "{n}", api_{n});\n' |
| .format(n=s.caller)) |
| try: |
| write(' hash_set_mem (vam->help_by_name, "{n}", "{help}");\n' |
| .format(n=s.caller, |
| help=define_hash[s.caller].options['vat_help'])) |
| except KeyError: |
| pass |
| |
| # Events |
| for e in s.events: |
| write(' vl_msg_api_set_handlers(VL_API_{ID} + msg_id_base, ' |
| ' "{n}",\n' |
| ' vl_api_{n}_t_handler, ' |
| ' vl_noop_handler,\n' |
| ' vl_api_{n}_t_endian, ' |
| ' vl_api_{n}_t_print,\n' |
| ' sizeof(vl_api_{n}_t), 1);\n' |
| .format(n=e, ID=e.upper())) |
| |
| write('}\n') |
| if plugin: |
| write('clib_error_t * vat_plugin_register (vat_main_t *vam)\n') |
| else: |
| write('clib_error_t * vat_{}_plugin_register (vat_main_t *vam)\n' |
| .format(module)) |
| write('{\n') |
| write(' {n}_test_main_t * mainp = &{n}_test_main;\n'.format(n=module)) |
| write(' mainp->vat_main = vam;\n') |
| write(' mainp->msg_id_base = vl_client_get_first_plugin_msg_id ' |
| ' ("{n}_{crc:08x}");\n' |
| .format(n=module, crc=file_crc)) |
| write(' if (mainp->msg_id_base == (u16) ~0)\n') |
| write(' return clib_error_return (0, "{} plugin not loaded...");\n' |
| .format(module)) |
| write(' setup_message_id_table (vam, mainp->msg_id_base);\n') |
| write('#ifdef VL_API_LOCAL_SETUP_MESSAGE_ID_TABLE\n') |
| write(' VL_API_LOCAL_SETUP_MESSAGE_ID_TABLE(vam);\n') |
| write('#endif\n') |
| write(' return 0;\n') |
| write('}\n') |
| |
| |
| def apifunc(func): |
| '''Check if a method is generated already.''' |
| def _f(module, d, processed, *args): |
| if d.name in processed: |
| return None |
| processed[d.name] = True |
| return func(module, d, *args) |
| return _f |
| |
| |
| def c_test_api_service(s, dump, stream): |
| '''Generate JSON code for a service.''' |
| write = stream.write |
| |
| req_reply_template = '''\ |
| static cJSON * |
| api_{n} (cJSON *o) |
| {{ |
| vl_api_{n}_t *mp; |
| int len; |
| if (!o) return 0; |
| mp = vl_api_{n}_t_fromjson(o, &len); |
| if (!mp) {{ |
| fprintf(stderr, "Failed converting JSON to API\\n"); |
| return 0; |
| }} |
| |
| mp->_vl_msg_id = vac_get_msg_index(VL_API_{N}_CRC); |
| vl_api_{n}_t_endian(mp); |
| vac_write((char *)mp, len); |
| free(mp); |
| |
| /* Read reply */ |
| char *p; |
| int l; |
| vac_read(&p, &l, 5); // XXX: Fix timeout |
| if (p == 0 || l == 0) return 0; |
| // XXX Will fail in case of event received. Do loop |
| if (ntohs(*((u16 *)p)) != vac_get_msg_index(VL_API_{R}_CRC)) {{ |
| fprintf(stderr, "Mismatched reply\\n"); |
| return 0; |
| }} |
| vl_api_{r}_t *rmp = (vl_api_{r}_t *)p; |
| vl_api_{r}_t_endian(rmp); |
| return vl_api_{r}_t_tojson(rmp); |
| }} |
| |
| ''' |
| dump_details_template = '''\ |
| static cJSON * |
| api_{n} (cJSON *o) |
| {{ |
| u16 msg_id = vac_get_msg_index(VL_API_{N}_CRC); |
| int len; |
| if (!o) return 0; |
| vl_api_{n}_t *mp = vl_api_{n}_t_fromjson(o, &len); |
| if (!mp) {{ |
| fprintf(stderr, "Failed converting JSON to API\\n"); |
| return 0; |
| }} |
| mp->_vl_msg_id = msg_id; |
| vl_api_{n}_t_endian(mp); |
| vac_write((char *)mp, len); |
| free(mp); |
| |
| vat2_control_ping(123); // FIX CONTEXT |
| cJSON *reply = cJSON_CreateArray(); |
| |
| u16 ping_reply_msg_id = vac_get_msg_index(VL_API_CONTROL_PING_REPLY_CRC); |
| u16 details_msg_id = vac_get_msg_index(VL_API_{R}_CRC); |
| |
| while (1) {{ |
| /* Read reply */ |
| char *p; |
| int l; |
| vac_read(&p, &l, 5); // XXX: Fix timeout |
| if (p == 0 || l == 0) {{ |
| cJSON_free(reply); |
| return 0; |
| }} |
| |
| /* Message can be one of [_details, control_ping_reply |
| * or unrelated event] |
| */ |
| u16 reply_msg_id = ntohs(*((u16 *)p)); |
| if (reply_msg_id == ping_reply_msg_id) {{ |
| break; |
| }} |
| |
| if (reply_msg_id == details_msg_id) {{ |
| if (l < sizeof(vl_api_{r}_t)) {{ |
| cJSON_free(reply); |
| return 0; |
| }} |
| vl_api_{r}_t *rmp = (vl_api_{r}_t *)p; |
| vl_api_{r}_t_endian(rmp); |
| cJSON_AddItemToArray(reply, vl_api_{r}_t_tojson(rmp)); |
| }} |
| }} |
| return reply; |
| }} |
| |
| ''' |
| gets_details_reply_template = '''\ |
| static cJSON * |
| api_{n} (cJSON *o) |
| {{ |
| u16 msg_id = vac_get_msg_index(VL_API_{N}_CRC); |
| int len = 0; |
| if (!o) return 0; |
| vl_api_{n}_t *mp = vl_api_{n}_t_fromjson(o, &len); |
| if (!mp) {{ |
| fprintf(stderr, "Failed converting JSON to API\\n"); |
| return 0; |
| }} |
| mp->_vl_msg_id = msg_id; |
| |
| vl_api_{n}_t_endian(mp); |
| vac_write((char *)mp, len); |
| free(mp); |
| |
| cJSON *reply = cJSON_CreateArray(); |
| |
| u16 reply_msg_id = vac_get_msg_index(VL_API_{R}_CRC); |
| u16 details_msg_id = vac_get_msg_index(VL_API_{D}_CRC); |
| |
| while (1) {{ |
| /* Read reply */ |
| char *p; |
| int l; |
| vac_read(&p, &l, 5); // XXX: Fix timeout |
| |
| /* Message can be one of [_details, control_ping_reply |
| * or unrelated event] |
| */ |
| u16 msg_id = ntohs(*((u16 *)p)); |
| if (msg_id == reply_msg_id) {{ |
| vl_api_{r}_t *rmp = (vl_api_{r}_t *)p; |
| vl_api_{r}_t_endian(rmp); |
| cJSON_AddItemToArray(reply, vl_api_{r}_t_tojson(rmp)); |
| break; |
| }} |
| |
| if (msg_id == details_msg_id) {{ |
| vl_api_{d}_t *rmp = (vl_api_{d}_t *)p; |
| vl_api_{d}_t_endian(rmp); |
| cJSON_AddItemToArray(reply, vl_api_{d}_t_tojson(rmp)); |
| }} |
| }} |
| return reply; |
| }} |
| |
| ''' |
| |
| if dump: |
| if s.stream_message: |
| write(gets_details_reply_template |
| .format(n=s.caller, r=s.reply, N=s.caller.upper(), |
| R=s.reply.upper(), d=s.stream_message, |
| D=s.stream_message.upper())) |
| else: |
| write(dump_details_template.format(n=s.caller, r=s.reply, |
| N=s.caller.upper(), |
| R=s.reply.upper())) |
| else: |
| write(req_reply_template.format(n=s.caller, r=s.reply, |
| N=s.caller.upper(), |
| R=s.reply.upper())) |
| |
| |
| def generate_c_test2_boilerplate(services, defines, module, stream): |
| '''Generate code for VAT2 plugin.''' |
| write = stream.write |
| |
| define_hash = {d.name: d for d in defines} |
| # replies = {} |
| |
| hdr = '''\ |
| #include <vlibapi/api.h> |
| #include <vlibmemory/api.h> |
| #include <vppinfra/error.h> |
| #include <vnet/ip/ip_format_fns.h> |
| #include <vnet/ethernet/ethernet_format_fns.h> |
| |
| #define vl_typedefs /* define message structures */ |
| #include <vpp/api/vpe_all_api_h.h> |
| #undef vl_typedefs |
| |
| #include "{module}.api_enum.h" |
| #include "{module}.api_types.h" |
| |
| #define vl_endianfun /* define message structures */ |
| #include "{module}.api.h" |
| #undef vl_endianfun |
| |
| #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__) |
| #define vl_printfun |
| #include "{module}.api.h" |
| #undef vl_printfun |
| |
| #include "{module}.api_tojson.h" |
| #include "{module}.api_fromjson.h" |
| #include <vpp-api/client/vppapiclient.h> |
| |
| #include <vat2/vat2_helpers.h> |
| |
| ''' |
| |
| write(hdr.format(module=module)) |
| |
| for s in services: |
| if s.reply not in define_hash: |
| continue |
| c_test_api_service(s, s.stream, stream) |
| |
| write('void vat2_register_function(char *, cJSON * (*)(cJSON *));\n') |
| # write('__attribute__((constructor))') |
| write('clib_error_t *\n') |
| write('vat2_register_plugin (void) {\n') |
| for s in services: |
| write(' vat2_register_function("{n}", api_{n});\n' |
| .format(n=s.caller)) |
| write(' return 0;\n') |
| write('}\n') |
| |
| |
| # |
| # Plugin entry point |
| # |
| def run(args, apifilename, s): |
| '''Main plugin entry point.''' |
| stream = StringIO() |
| |
| if not args.outputdir: |
| sys.stderr.write('Missing --outputdir argument') |
| return None |
| |
| basename = os.path.basename(apifilename) |
| filename, _ = os.path.splitext(basename) |
| modulename = filename.replace('.', '_') |
| filename_enum = os.path.join(args.outputdir + '/' + basename + '_enum.h') |
| filename_types = os.path.join(args.outputdir + '/' + basename + '_types.h') |
| filename_c = os.path.join(args.outputdir + '/' + basename + '.c') |
| filename_c_test = os.path.join(args.outputdir + '/' + basename + '_test.c') |
| filename_c_test2 = (os.path.join(args.outputdir + '/' + basename + |
| '_test2.c')) |
| filename_c_tojson = (os.path.join(args.outputdir + |
| '/' + basename + '_tojson.h')) |
| filename_c_fromjson = (os.path.join(args.outputdir + '/' + |
| basename + '_fromjson.h')) |
| |
| # Generate separate types file |
| st = StringIO() |
| generate_include_types(s, modulename, st) |
| with open(filename_types, 'w') as fd: |
| st.seek(0) |
| shutil.copyfileobj(st, fd) |
| st.close() |
| |
| # Generate separate enum file |
| st = StringIO() |
| st.write('#ifndef included_{}_api_enum_h\n'.format(modulename)) |
| st.write('#define included_{}_api_enum_h\n'.format(modulename)) |
| generate_include_enum(s, modulename, st) |
| generate_include_counters(s['Counters'], st) |
| st.write('#endif\n') |
| with open(filename_enum, 'w') as fd: |
| st.seek(0) |
| shutil.copyfileobj(st, fd) |
| st.close() |
| |
| # Generate separate C file |
| st = StringIO() |
| generate_c_boilerplate(s['Service'], s['Define'], s['Counters'], |
| s['file_crc'], modulename, st) |
| with open(filename_c, 'w') as fd: |
| st.seek(0) |
| shutil.copyfileobj(st, fd) |
| st.close() |
| |
| # Generate separate C test file |
| st = StringIO() |
| plugin = bool('plugin' in apifilename) |
| generate_c_test_boilerplate(s['Service'], s['Define'], |
| s['file_crc'], |
| modulename, plugin, st) |
| with open(filename_c_test, 'w') as fd: |
| st.seek(0) |
| shutil.copyfileobj(st, fd) |
| st.close() |
| |
| # Fully autogenerated VATv2 C test file |
| st = StringIO() |
| generate_c_test2_boilerplate(s['Service'], s['Define'], |
| modulename, st) |
| with open(filename_c_test2, 'w') as fd: |
| st.seek(0) |
| shutil.copyfileobj(st, fd) |
| st.close() # |
| |
| # Generate separate JSON file |
| st = StringIO() |
| generate_tojson(s, modulename, st) |
| with open(filename_c_tojson, 'w') as fd: |
| st.seek(0) |
| shutil.copyfileobj(st, fd) |
| st.close() |
| st = StringIO() |
| generate_fromjson(s, modulename, st) |
| with open(filename_c_fromjson, 'w') as fd: |
| st.seek(0) |
| shutil.copyfileobj(st, fd) |
| st.close() |
| |
| output = TOP_BOILERPLATE.format(datestring=DATESTRING, |
| input_filename=basename) |
| output += generate_imports(s['Import']) |
| output += msg_ids(s) |
| output += msg_names(s) |
| output += msg_name_crc_list(s, filename) |
| output += typedefs(modulename) |
| printfun_types(s['types'], stream, modulename) |
| printfun(s['Define'], stream, modulename) |
| output += stream.getvalue() |
| stream.close() |
| output += endianfun(s['types'] + s['Define'], modulename) |
| output += version_tuple(s, basename) |
| output += BOTTOM_BOILERPLATE.format(input_filename=basename, |
| file_crc=s['file_crc']) |
| |
| return output |