vpp-api/java/jvpp/gen/jvppgen/types_gen.py

   1 #!/usr/bin/env python
   2 #
   3 # Copyright (c) 2016 Cisco and/or its affiliates.
   4 # Licensed under the Apache License, Version 2.0 (the "License");
   5 # you may not use this file except in compliance with the License.
   6 # You may obtain a copy of the License at:
   7 #
   8 #     http://www.apache.org/licenses/LICENSE-2.0
   9 #
  10 # Unless required by applicable law or agreed to in writing, software
  11 # distributed under the License is distributed on an "AS IS" BASIS,
  12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 # See the License for the specific language governing permissions and
  14 # limitations under the License.
  15
  16 import os
  17 from string import Template
  18
  19 import util
  20 import jni_gen
  21 import dto_gen
  22
  23 type_template = Template("""
  24 package $plugin_package.$type_package;
  25
  26 /**
  27  * <p>This class represents $c_type_name type definition.
  28  * <br>It was generated by types_gen.py based on $inputfile preparsed data:
  29  * <pre>
  30 $docs
  31  * </pre>
  32  */
  33 public final class $java_type_name {
  34 $fields
  35 $methods
  36 }
  37 """)
  38
  39 field_template = Template("""    public $type $name;\n""")
  40
  41
  42 def generate_type_fields(type_definition):
  43     """
  44     Generates fields for class representing typeonly definition
  45     :param type_definition: python representation of typeonly definition
  46     :return: string representing class fields
  47     """
  48     fields = ""
  49     for t in zip(type_definition['types'], type_definition['args']):
  50         field_name = util.underscore_to_camelcase(t[1])
  51         fields += field_template.substitute(type=util.jni_2_java_type_mapping[t[0]],
  52                                             name=field_name)
  53     return fields
  54
  55 object_struct_setter_template = Template("""
  56     {
  57         jclass ${field_reference_name}Class = (*env)->FindClass(env, "${class_FQN}");
  58         memset (&(mp->${c_name}), 0, sizeof (mp->${c_name}));
  59         ${struct_initialization}
  60     }
  61 """)
  62
  63 object_array_struct_setter_template = Template("""
  64     {
  65         jclass ${field_reference_name}ArrayElementClass = (*env)->FindClass(env, "${class_FQN}");
  66         if (${field_reference_name}) {
  67             size_t _i;
  68             jsize cnt = (*env)->GetArrayLength (env, ${field_reference_name});
  69             ${field_length_check}
  70             for (_i = 0; _i < cnt; _i++) {
  71                 jobject ${field_reference_name}ArrayElement = (*env)->GetObjectArrayElement(env, ${field_reference_name}, _i);
  72                 memset (&(mp->${c_name}[_i]), 0, sizeof (mp->${c_name}[_i]));
  73                 ${struct_initialization}
  74             }
  75         }
  76     }
  77 """)
  78
  79 object_dto_field_setter_template = Template("""
  80     {
  81         jclass ${field_reference_name}Class = (*env)->FindClass(env, "${class_FQN}");
  82         jmethodID ${field_reference_name}Constructor = (*env)->GetMethodID(env, ${field_reference_name}Class, "<init>", "()V");
  83         jobject ${field_reference_name} = (*env)->NewObject(env, ${field_reference_name}Class,  ${field_reference_name}Constructor);
  84         ${type_initialization}
  85         (*env)->SetObjectField(env, dto, ${field_reference_name}FieldId, ${field_reference_name});
  86     }
  87 """)
  88
  89 object_array_dto_field_setter_template = Template("""
  90     {
  91         jclass ${field_reference_name}Class = (*env)->FindClass(env, "${class_FQN}");
  92         jobjectArray ${field_reference_name} = (*env)->NewObjectArray(env, ${field_length}, ${field_reference_name}Class, 0);
  93         unsigned int _i;
  94         for (_i = 0; _i < ${field_length}; _i++) {
  95             jmethodID ${field_reference_name}Constructor = (*env)->GetMethodID(env, ${field_reference_name}Class, "<init>", "()V");
  96             jobject ${field_reference_name}ArrayElement = (*env)->NewObject(env, ${field_reference_name}Class,  ${field_reference_name}Constructor);
  97             ${type_initialization}
  98             (*env)->SetObjectArrayElement(env, ${field_reference_name}, _i, ${field_reference_name}ArrayElement);
  99         }
 100         (*env)->SetObjectField(env, dto, ${field_reference_name}FieldId, ${field_reference_name});
 101     }
 102 """)
 103
 104
 105 def generate_struct_initialization(type_def, c_name_prefix, object_name, indent):
 106     struct_initialization = ""
 107     # field identifiers
 108     for t in zip(type_def['types'], type_def['args'], type_def['lengths']):
 109         field_reference_name = "${c_name}" + util.underscore_to_camelcase_upper(t[1])
 110         field_name = util.underscore_to_camelcase(t[1])
 111         struct_initialization += jni_gen.jni_request_binding_for_type(field_type=t[0], c_name=c_name_prefix + t[1],
 112                                                                      field_reference_name=field_reference_name,
 113                                                                      field_name=field_name,
 114                                                                      field_length=t[2][0],
 115                                                                      is_variable_len_array=t[2][1],
 116                                                                      object_name=object_name)
 117     return indent + struct_initialization.replace('\n', '\n' + indent)
 118
 119
 120 def generate_type_setter(handler_name, type_def, c_name_prefix, object_name, indent):
 121     type_initialization = ""
 122     for t in zip(type_def['types'], type_def['args'], type_def['lengths']):
 123         field_length = t[2][0]
 124         is_variable_len_array = t[2][1]
 125         length_field_type = None
 126         if is_variable_len_array:
 127             length_field_type = type_def['types'][type_def['args'].index(field_length)]
 128         type_initialization += jni_gen.jni_reply_handler_for_type(handler_name=handler_name,
 129                                                                   ref_name="${field_reference_name}",
 130                                                                   field_type=t[0], c_name=c_name_prefix + t[1],
 131                                                                   field_reference_name="${c_name}" + util.underscore_to_camelcase_upper(t[1]),
 132                                                                   field_name=util.underscore_to_camelcase(t[1]),
 133                                                                   field_length=field_length,
 134                                                                   is_variable_len_array=is_variable_len_array,
 135                                                                   length_field_type=length_field_type,
 136                                                                   object_name=object_name)
 137     return indent + type_initialization.replace('\n', '\n' + indent)
 138
 139
 140 def generate_types(types_list, plugin_package, types_package, inputfile):
 141     """
 142     Generates Java representation of custom types defined in api file.
 143     """
 144
 145     #
 146     if not types_list:
 147         print "Skipping custom types generation (%s does not define custom types)." % inputfile
 148         return
 149
 150     print "Generating custom types"
 151
 152     if not os.path.exists(types_package):
 153         raise Exception("%s folder is missing" % types_package)
 154
 155     for type in types_list:
 156         c_type_name = type['name']
 157         java_type_name = util.underscore_to_camelcase_upper(type['name'])
 158         dto_path = os.path.join(types_package, java_type_name + ".java")
 159
 160         fields = generate_type_fields(type)
 161
 162         dto_file = open(dto_path, 'w')
 163         dto_file.write(type_template.substitute(plugin_package=plugin_package,
 164                                                 type_package=types_package,
 165                                                 c_type_name=c_type_name,
 166                                                 inputfile=inputfile,
 167                                                 docs=util.api_message_to_javadoc(type),
 168                                                 java_type_name=java_type_name,
 169                                                 fields=fields,
 170                                                 methods=dto_gen.generate_dto_base_methods(java_type_name, type)
 171                                                 ))
 172
 173         # update type mappings:
 174         # todo fix vpe.api to use type_name instead of vl_api_type_name_t
 175         type_name = "vl_api_" + c_type_name + "_t"
 176         java_fqn = "%s.%s.%s" % (plugin_package, types_package, java_type_name)
 177         util.vpp_2_jni_type_mapping[type_name] = "jobject"
 178         util.vpp_2_jni_type_mapping[type_name + "[]"] = "jobjectArray"
 179         util.jni_2_java_type_mapping[type_name] = java_fqn
 180         util.jni_2_java_type_mapping[type_name + "[]"] = java_fqn + "[]"
 181         jni_name = java_fqn.replace('.', "/")
 182         jni_signature = "L" + jni_name + ";"
 183         util.jni_2_signature_mapping[type_name] = "L" + jni_name + ";"
 184         util.jni_2_signature_mapping[type_name + "[]"] = "[" + jni_signature
 185         util.jni_field_accessors[type_name] = "ObjectField"
 186         util.jni_field_accessors[type_name + "[]"] = "ObjectField"
 187
 188         jni_gen.struct_setter_templates[type_name] = Template(
 189                 object_struct_setter_template.substitute(
 190                         c_name="${c_name}",
 191                         field_reference_name="${field_reference_name}",
 192                         class_FQN=jni_name,
 193                         struct_initialization=generate_struct_initialization(type, "${c_name}.",
 194                                                                            "${field_reference_name}", ' ' * 4))
 195         )
 196
 197         jni_gen.struct_setter_templates[type_name+ "[]"] = Template(
 198                 object_array_struct_setter_template.substitute(
 199                         c_name="${c_name}",
 200                         field_reference_name="${field_reference_name}",
 201                         field_length_check="${field_length_check}",
 202                         class_FQN=jni_name,
 203                         struct_initialization=generate_struct_initialization(type, "${c_name}[_i].",
 204                                                                            "${field_reference_name}ArrayElement", ' ' * 8))
 205         )
 206
 207         jni_gen.dto_field_setter_templates[type_name] = Template(
 208                 object_dto_field_setter_template.substitute(
 209                         field_reference_name="${field_reference_name}",
 210                         field_length="${field_length}",
 211                         class_FQN=jni_name,
 212                         type_initialization=generate_type_setter(c_type_name, type, "${c_name}.",
 213                                                                  "${field_reference_name}", ' ' * 4))
 214         )
 215
 216         jni_gen.dto_field_setter_templates[type_name + "[]"] = Template(
 217                 object_array_dto_field_setter_template.substitute(
 218                         field_reference_name="${field_reference_name}",
 219                         field_length="${field_length}",
 220                         class_FQN=jni_name,
 221                         type_initialization=generate_type_setter(c_type_name, type, "${c_name}[_i].",
 222                                                                  "${field_reference_name}ArrayElement", ' ' * 8))
 223         )
 224
 225         dto_file.flush()
 226         dto_file.close()
 227