vpp-api/java/jvpp/gen/jvpp_c_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 # l
  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
  17 import os, util
  18 from string import Template
  19
  20 def is_manually_generated(f_name):
  21     return f_name in {'control_ping_reply'}
  22
  23
  24 class_reference_template = Template("""jclass ${ref_name}Class;
  25 """)
  26
  27 find_class_invocation_template = Template("""
  28     ${ref_name}Class = (jclass)(*env)->NewGlobalRef(env, (*env)->FindClass(env, "org/openvpp/jvpp/dto/${class_name}"));
  29     if ((*env)->ExceptionCheck(env)) {
  30         (*env)->ExceptionDescribe(env);
  31         return JNI_ERR;
  32     }""")
  33
  34 class_cache_template = Template("""
  35 $class_references
  36 static int cache_class_references(JNIEnv* env) {
  37     $find_class_invocations
  38     return 0;
  39 }""")
  40
  41 def generate_class_cache(func_list):
  42     class_references = []
  43     find_class_invocations = []
  44     for f in func_list:
  45         c_name = f['name']
  46         class_name = util.underscore_to_camelcase_upper(c_name)
  47         ref_name = util.underscore_to_camelcase(c_name)
  48
  49         if not util.is_reply(class_name) or util.is_ignored(c_name) or util.is_notification(c_name):
  50             # TODO handle notifications
  51             continue
  52
  53         class_references.append(class_reference_template.substitute(
  54                 ref_name=ref_name))
  55
  56         find_class_invocations.append(find_class_invocation_template.substitute(
  57                 ref_name=ref_name,
  58                 class_name=class_name))
  59
  60     return class_cache_template.substitute(
  61             class_references="".join(class_references), find_class_invocations="".join(find_class_invocations))
  62
  63
  64 # TODO: cache method and field identifiers to achieve better performance
  65 # https://jira.fd.io/browse/HONEYCOMB-42
  66 request_class_template = Template("""
  67     jclass requestClass = (*env)->FindClass(env, "org/openvpp/jvpp/dto/${java_name_upper}");""")
  68
  69 request_field_identifier_template = Template("""
  70     jfieldID ${java_name}FieldId = (*env)->GetFieldID(env, requestClass, "${java_name}", "${jni_signature}");
  71     ${jni_type} ${java_name} = (*env)->Get${jni_getter}(env, request, ${java_name}FieldId);
  72     """)
  73
  74 u8_struct_setter_template = Template("""
  75     mp->${c_name} = ${java_name};""")
  76
  77 u16_struct_setter_template = Template("""
  78     mp->${c_name} = clib_host_to_net_u16(${java_name});""")
  79
  80 u32_struct_setter_template = Template("""
  81     mp->${c_name} = clib_host_to_net_u32(${java_name});""")
  82
  83 i32_struct_setter_template = Template("""
  84     mp->${c_name} = clib_host_to_net_i32(${java_name});!""")
  85
  86 u64_struct_setter_template = Template("""
  87     mp->${c_name} = clib_host_to_net_u64(${java_name});""")
  88
  89 u8_array_struct_setter_template = Template("""
  90     {
  91         jsize cnt = (*env)->GetArrayLength (env, ${java_name});
  92         if (cnt > sizeof(mp->${c_name})) cnt = sizeof(mp->${c_name});
  93         (*env)->GetByteArrayRegion(env, ${java_name}, 0, cnt, (jbyte *)mp->${c_name});
  94     }
  95 """)
  96
  97 u32_array_struct_setter_template = Template("""
  98     jint * ${java_name}ArrayElements = (*env)->GetIntArrayElements(env, ${java_name}, NULL);
  99     {
 100         int _i;
 101         for (_i = 0; _i < 0; _i++) {
 102             mp->${c_name}[_i] = clib_host_to_net_u32(${java_name}ArrayElements[_i]);
 103         }
 104     }
 105     (*env)->ReleaseIntArrayElements (env, ${java_name}, ${java_name}ArrayElements, 0);
 106     """)
 107
 108 vl_api_ip4_fib_counter_t_array_struct_setter_template = Template("""
 109     // vl_api_ip4_fib_counter_t_array_field_setter_template FIXME""")
 110
 111 vl_api_ip6_fib_counter_t_array_struct_setter_template = Template("""
 112     // vl_api_ip6_fib_counter_t_array_field_setter_template FIXME""")
 113
 114 struct_setter_templates = {'u8': u8_struct_setter_template,
 115                           'u16': u32_struct_setter_template,
 116                           'u32': u32_struct_setter_template,
 117                           'i32': u32_struct_setter_template,
 118                           'u64': u64_struct_setter_template,
 119                           'u8[]': u8_array_struct_setter_template,
 120                           'u32[]': u32_array_struct_setter_template,
 121                           'vl_api_ip4_fib_counter_t[]': vl_api_ip4_fib_counter_t_array_struct_setter_template,
 122                           'vl_api_ip6_fib_counter_t[]': vl_api_ip6_fib_counter_t_array_struct_setter_template
 123                   }
 124
 125 jni_impl_template = Template("""
 126 /**
 127  * JNI binding for sending ${c_name} vpe.api message.
 128  * Generated based on $inputfile preparsed data:
 129 $api_data
 130  */
 131 JNIEXPORT jint JNICALL Java_org_openvpp_jvpp_JVppImpl_${java_name}0
 132 (JNIEnv * env, jclass clazz$args) {
 133     vppjni_main_t *jm = &vppjni_main;
 134     vl_api_${c_name}_t * mp;
 135     u32 my_context_id;
 136     int rv;
 137     rv = vppjni_sanity_check (jm);
 138     if (rv) return rv;
 139     my_context_id = vppjni_get_context_id (jm);
 140     $request_class
 141     $field_identifiers
 142     M(${c_name_uppercase}, ${c_name});
 143     mp->context = clib_host_to_net_u32 (my_context_id);
 144     $struct_setters
 145     S;
 146     return my_context_id;
 147 }""")
 148
 149 def generate_jni_impl(func_list, inputfile):
 150     jni_impl = []
 151     for f in func_list:
 152         f_name = f['name']
 153         camel_case_function_name = util.underscore_to_camelcase(f_name)
 154         if is_manually_generated(f_name) or util.is_reply(camel_case_function_name) \
 155                 or util.is_ignored(f_name) or util.is_notification(f_name):
 156             continue
 157
 158         arguments = ''
 159         request_class = ''
 160         field_identifiers = ''
 161         struct_setters = ''
 162         f_name_uppercase = f_name.upper()
 163
 164         if f['args']:
 165             arguments = ', jobject request'
 166             camel_case_function_name_upper = util.underscore_to_camelcase_upper(f_name)
 167
 168             request_class = request_class_template.substitute(java_name_upper=camel_case_function_name_upper)
 169
 170             # field identifiers
 171             for t in zip(f['types'], f['args']):
 172                 jni_type = t[0]
 173                 java_field_name = util.underscore_to_camelcase(t[1])
 174                 jni_signature = util.jni_2_signature_mapping[jni_type]
 175                 jni_getter = util.jni_field_accessors[jni_type]
 176                 field_identifiers += request_field_identifier_template.substitute(
 177                         jni_type=jni_type,
 178                         java_name=java_field_name,
 179                         jni_signature=jni_signature,
 180                         jni_getter=jni_getter)
 181
 182             # field setters
 183             for t in zip(f['c_types'], f['args']):
 184                 c_type = t[0]
 185                 c_name = t[1]
 186                 java_field_name = util.underscore_to_camelcase(c_name)
 187
 188                 struct_setter_template = struct_setter_templates[c_type]
 189
 190                 struct_setters += struct_setter_template.substitute(
 191                         c_name=c_name,
 192                         java_name=java_field_name)
 193
 194         jni_impl.append(jni_impl_template.substitute(
 195                 inputfile=inputfile,
 196                 api_data=util.api_message_to_javadoc(f),
 197                 java_name=camel_case_function_name,
 198                 c_name_uppercase=f_name_uppercase,
 199                 c_name=f_name,
 200                 request_class=request_class,
 201                 field_identifiers=field_identifiers,
 202                 struct_setters=struct_setters,
 203                 args=arguments))
 204
 205     return "\n".join(jni_impl)
 206
 207
 208 dto_field_id_template = Template("""
 209     jfieldID ${java_name}FieldId = (*env)->GetFieldID(env, ${class_ref_name}Class, "${java_name}", "${jni_signature}");""")
 210
 211 default_dto_field_setter_template = Template("""
 212     (*env)->Set${jni_setter}(env, dto, ${java_name}FieldId, mp->${c_name});
 213 """)
 214
 215 u32_dto_field_setter_template = Template("""
 216     (*env)->Set${jni_setter}(env, dto, ${java_name}FieldId, clib_net_to_host_u32(mp->${c_name}));
 217 """)
 218
 219 u64_dto_field_setter_template = Template("""
 220     (*env)->Set${jni_setter}(env, dto, ${java_name}FieldId, clib_net_to_host_u64(mp->${c_name}));
 221 """)
 222
 223 u8_array_dto_field_setter_template = Template("""
 224     jbyteArray ${java_name} = (*env)->NewByteArray(env, sizeof(mp->${c_name}));
 225     (*env)->SetByteArrayRegion(env, ${java_name}, 0, sizeof(mp->${c_name}), (const jbyte*)mp->${c_name});
 226     (*env)->SetObjectField(env, dto, ${java_name}FieldId, ${java_name});
 227 """)
 228
 229 # For each u64 array we get its elements. Then we convert values to host byte order.
 230 # All changes to  jint* buffer are written to jlongArray (isCopy is set to NULL)
 231 u64_array_dto_field_setter_template = Template("""
 232     jlongArray ${java_name} = (*env)->NewLongArray(env, sizeof(mp->${c_name}));
 233     {
 234         jlong * ${java_name}ArrayElements = (*env)->GetLongArrayElements(env, ${java_name}, NULL);
 235         int _i;
 236         for (_i = 0; _i < 0; _i++) {
 237             ${java_name}ArrayElements[_i] = clib_net_to_host_u64(mp->${c_name}[_i]);
 238         }
 239     }
 240     (*env)->SetObjectField(env, dto, ${java_name}FieldId, ${java_name});
 241 """)
 242
 243 dto_field_setter_templates = {'u8': default_dto_field_setter_template,
 244                       'u16': u32_dto_field_setter_template,
 245                       'u32': u32_dto_field_setter_template,
 246                       'i32': u32_dto_field_setter_template,
 247                       'u64': u64_dto_field_setter_template,
 248                       'f64': default_dto_field_setter_template,
 249                       'u64[]': u64_array_dto_field_setter_template,
 250                       'u8[]': u8_array_dto_field_setter_template
 251                       }
 252
 253 msg_handler_template = Template("""
 254 /**
 255  * Handler for ${handler_name} vpe.api message.
 256  * Generated based on $inputfile preparsed data:
 257 $api_data
 258  */
 259 static void vl_api_${handler_name}_t_handler (vl_api_${handler_name}_t * mp)
 260 {
 261     vppjni_main_t * jm = &vppjni_main;
 262     JNIEnv *env = jm->jenv;
 263
 264     jmethodID constructor = (*env)->GetMethodID(env, ${class_ref_name}Class, "<init>", "()V");
 265     jmethodID callbackMethod = (*env)->GetMethodID(env, jm->callbackClass, "on${dto_name}", "(Lorg/openvpp/jvpp/dto/${dto_name};)V");
 266
 267     jobject dto = (*env)->NewObject(env, ${class_ref_name}Class, constructor);
 268     $dto_setters
 269     (*env)->CallVoidMethod(env, jm->callback, callbackMethod, dto);
 270 }""")
 271
 272 def generate_msg_handlers(func_list, inputfile):
 273     handlers = []
 274     for f in func_list:
 275         handler_name = f['name']
 276         dto_name = util.underscore_to_camelcase_upper(handler_name)
 277         ref_name = util.underscore_to_camelcase(handler_name)
 278
 279         if is_manually_generated(handler_name) or not util.is_reply(dto_name) or util.is_ignored(handler_name) or util.is_notification(handler_name):
 280             # TODO handle notifications
 281             continue
 282
 283         dto_setters = ''
 284         # dto setters
 285         for t in zip(f['c_types'], f['types'], f['args']):
 286             c_type = t[0]
 287             jni_type = t[1]
 288             c_name = t[2]
 289
 290             java_field_name = util.underscore_to_camelcase(c_name)
 291             jni_signature = util.jni_2_signature_mapping[jni_type]
 292             jni_setter = util.jni_field_accessors[jni_type]
 293
 294             dto_setters += dto_field_id_template.substitute(
 295                     java_name=java_field_name,
 296                     class_ref_name=ref_name,
 297                     jni_signature=jni_signature)
 298
 299             dto_setter_template = dto_field_setter_templates[c_type]
 300
 301             dto_setters += dto_setter_template.substitute(
 302                     java_name=java_field_name,
 303                     jni_signature=jni_signature,
 304                     c_name=c_name,
 305                     jni_setter=jni_setter)
 306
 307         handlers.append(msg_handler_template.substitute(
 308                 inputfile=inputfile,
 309                 api_data=util.api_message_to_javadoc(f),
 310                 handler_name=handler_name,
 311                 dto_name=dto_name,
 312                 class_ref_name=ref_name,
 313                 dto_setters=dto_setters))
 314
 315     return "\n".join(handlers)
 316
 317
 318 handler_registration_template = Template("""_(${upercase_name}, ${name}) \\
 319 """)
 320
 321
 322 def generate_handler_registration(func_list):
 323     handler_registration = ["#define foreach_vpe_api_msg \\\n"]
 324     for f in func_list:
 325         name = f['name']
 326         camelcase_name = util.underscore_to_camelcase(f['name'])
 327
 328         if not util.is_reply(camelcase_name) or util.is_ignored(name) or util.is_notification(name):
 329             # TODO handle notifications
 330             continue
 331
 332         handler_registration.append(handler_registration_template.substitute(
 333                 name=name,
 334                 upercase_name=name.upper()))
 335
 336     return "".join(handler_registration)
 337
 338
 339 jvpp_c_template = Template("""/**
 340  * This file contains JNI bindings for jvpp Java API.
 341  * It was generated by jvpp_c_gen.py based on $inputfile
 342  * (python representation of vpe.api generated by vppapigen).
 343  */
 344
 345 // JAVA class reference cache
 346 $class_cache
 347
 348 // JNI bindings
 349 $jni_implementations
 350
 351 // Message handlers
 352 $msg_handlers
 353
 354 // Registration of message handlers in vlib
 355 $handler_registration
 356 """)
 357
 358 def generate_jvpp(func_list, inputfile):
 359     """ Generates jvpp C file """
 360     print "Generating jvpp C"
 361
 362     class_cache = generate_class_cache(func_list)
 363     jni_impl = generate_jni_impl(func_list, inputfile)
 364     msg_handlers = generate_msg_handlers(func_list, inputfile)
 365     handler_registration = generate_handler_registration(func_list)
 366
 367     jvpp_c_file = open("jvpp_gen.h", 'w')
 368     jvpp_c_file.write(jvpp_c_template.substitute(
 369             inputfile=inputfile,
 370             class_cache=class_cache,
 371             jni_implementations=jni_impl,
 372             msg_handlers=msg_handlers,
 373             handler_registration=handler_registration))
 374     jvpp_c_file.flush()
 375     jvpp_c_file.close()
 376
 377