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 find_class_template = Template("""
  35     ${ref_name}Class = (jclass)(*env)->NewGlobalRef(env, (*env)->FindClass(env, "${class_name}"));
  36     if ((*env)->ExceptionCheck(env)) {
  37         (*env)->ExceptionDescribe(env);
  38         return JNI_ERR;
  39     }""")
  40
  41 class_cache_template = Template("""
  42 $class_references
  43 static int cache_class_references(JNIEnv* env) {
  44     $find_class_invocations
  45     return 0;
  46 }""")
  47
  48 def generate_class_cache(func_list):
  49     class_references = []
  50     find_class_invocations = []
  51     for f in func_list:
  52         c_name = f['name']
  53         class_name = util.underscore_to_camelcase_upper(c_name)
  54         ref_name = util.underscore_to_camelcase(c_name)
  55
  56         if util.is_ignored(c_name):
  57             continue
  58
  59         if util.is_reply(class_name):
  60             class_references.append(class_reference_template.substitute(
  61                 ref_name=ref_name))
  62             find_class_invocations.append(find_class_invocation_template.substitute(
  63                 ref_name=ref_name,
  64                 class_name=class_name))
  65         elif util.is_notification(c_name):
  66             class_references.append(class_reference_template.substitute(
  67                 ref_name=util.add_notification_suffix(ref_name)))
  68             find_class_invocations.append(find_class_invocation_template.substitute(
  69                 ref_name=util.add_notification_suffix(ref_name),
  70                 class_name=util.add_notification_suffix(class_name)))
  71
  72     # add exception class to class cache
  73     ref_name = 'callbackException'
  74     class_name = 'org/openvpp/jvpp/VppCallbackException'
  75     class_references.append(class_reference_template.substitute(
  76         ref_name=ref_name))
  77     find_class_invocations.append(find_class_template.substitute(
  78             ref_name=ref_name,
  79             class_name=class_name))
  80     return class_cache_template.substitute(
  81         class_references="".join(class_references), find_class_invocations="".join(find_class_invocations))
  82
  83
  84 # TODO: cache method and field identifiers to achieve better performance
  85 # https://jira.fd.io/browse/HONEYCOMB-42
  86 request_class_template = Template("""
  87     jclass requestClass = (*env)->FindClass(env, "org/openvpp/jvpp/dto/${java_name_upper}");""")
  88
  89 request_field_identifier_template = Template("""
  90     jfieldID ${java_name}FieldId = (*env)->GetFieldID(env, requestClass, "${java_name}", "${jni_signature}");
  91     ${jni_type} ${java_name} = (*env)->Get${jni_getter}(env, request, ${java_name}FieldId);
  92     """)
  93
  94 u8_struct_setter_template = Template("""
  95     mp->${c_name} = ${java_name};""")
  96
  97 u16_struct_setter_template = Template("""
  98     mp->${c_name} = clib_host_to_net_u16(${java_name});""")
  99
 100 u32_struct_setter_template = Template("""
 101     mp->${c_name} = clib_host_to_net_u32(${java_name});""")
 102
 103 i32_struct_setter_template = Template("""
 104     mp->${c_name} = clib_host_to_net_i32(${java_name});!""")
 105
 106 u64_struct_setter_template = Template("""
 107     mp->${c_name} = clib_host_to_net_u64(${java_name});""")
 108
 109 u8_array_struct_setter_template = Template("""
 110     {
 111         jsize cnt = (*env)->GetArrayLength (env, ${java_name});
 112         size_t max_size = ${field_length};
 113         if (max_size != 0 && cnt > max_size) cnt = max_size;
 114         (*env)->GetByteArrayRegion(env, ${java_name}, 0, cnt, (jbyte *)mp->${c_name});
 115     }
 116 """)
 117
 118 u32_array_struct_setter_template = Template("""
 119     jint * ${java_name}ArrayElements = (*env)->GetIntArrayElements(env, ${java_name}, NULL);
 120     {
 121         size_t _i;
 122         jsize cnt = (*env)->GetArrayLength (env, ${java_name});
 123         size_t max_size = ${field_length};
 124         if (max_size != 0 && cnt > max_size) cnt = max_size;
 125         for (_i = 0; _i < cnt; _i++) {
 126             mp->${c_name}[_i] = clib_host_to_net_u32(${java_name}ArrayElements[_i]);
 127         }
 128     }
 129     (*env)->ReleaseIntArrayElements (env, ${java_name}, ${java_name}ArrayElements, 0);
 130     """)
 131
 132 u16_array_struct_setter_template = Template("""
 133     jint * ${java_name}ArrayElements = (*env)->GetIntArrayElements(env, ${java_name}, NULL);
 134     {
 135         size_t _i;
 136         jsize cnt = (*env)->GetArrayLength (env, ${java_name});
 137         size_t max_size = ${field_length};
 138         if (max_size != 0 && cnt > max_size) cnt = max_size;
 139         for (_i = 0; _i < cnt; _i++) {
 140             mp->${c_name}[_i] = clib_host_to_net_u16(${java_name}ArrayElements[_i]);
 141         }
 142     }
 143     (*env)->ReleaseIntArrayElements (env, ${java_name}, ${java_name}ArrayElements, 0);
 144     """)
 145
 146 vl_api_ip4_fib_counter_t_array_struct_setter_template = Template("""
 147     // vl_api_ip4_fib_counter_t_array_field_setter_template FIXME""")
 148
 149 vl_api_ip6_fib_counter_t_array_struct_setter_template = Template("""
 150     // vl_api_ip6_fib_counter_t_array_field_setter_template FIXME""")
 151
 152 struct_setter_templates = {'u8': u8_struct_setter_template,
 153                           'u16': u16_struct_setter_template,
 154                           'u32': u32_struct_setter_template,
 155                           'i32': u32_struct_setter_template,
 156                           'u64': u64_struct_setter_template,
 157                           'u8[]': u8_array_struct_setter_template,
 158                           'u16[]': u16_array_struct_setter_template,
 159                           'u32[]': u32_array_struct_setter_template,
 160                           'vl_api_ip4_fib_counter_t[]': vl_api_ip4_fib_counter_t_array_struct_setter_template,
 161                           'vl_api_ip6_fib_counter_t[]': vl_api_ip6_fib_counter_t_array_struct_setter_template
 162                   }
 163
 164 jni_impl_template = Template("""
 165 /**
 166  * JNI binding for sending ${c_name} vpe.api message.
 167  * Generated based on $inputfile preparsed data:
 168 $api_data
 169  */
 170 JNIEXPORT jint JNICALL Java_org_openvpp_jvpp_JVppImpl_${java_name}0
 171 (JNIEnv * env, jclass clazz$args) {
 172     vppjni_main_t *jm = &vppjni_main;
 173     vl_api_${c_name}_t * mp;
 174     u32 my_context_id;
 175     int rv;
 176     rv = vppjni_sanity_check (jm);
 177     if (rv) return rv;
 178     my_context_id = vppjni_get_context_id (jm);
 179     $request_class
 180     $field_identifiers
 181     M(${c_name_uppercase}, ${c_name});
 182     mp->context = clib_host_to_net_u32 (my_context_id);
 183     $struct_setters
 184     S;
 185     if ((*env)->ExceptionCheck(env)) {
 186         return JNI_ERR;
 187     }
 188     return my_context_id;
 189 }""")
 190
 191 def generate_jni_impl(func_list, inputfile):
 192     jni_impl = []
 193     for f in func_list:
 194         f_name = f['name']
 195         camel_case_function_name = util.underscore_to_camelcase(f_name)
 196         if is_manually_generated(f_name) or util.is_reply(camel_case_function_name) \
 197                 or util.is_ignored(f_name) or util.is_just_notification(f_name):
 198             continue
 199
 200         arguments = ''
 201         request_class = ''
 202         field_identifiers = ''
 203         struct_setters = ''
 204         f_name_uppercase = f_name.upper()
 205
 206         if f['args']:
 207             arguments = ', jobject request'
 208             camel_case_function_name_upper = util.underscore_to_camelcase_upper(f_name)
 209
 210             request_class = request_class_template.substitute(java_name_upper=camel_case_function_name_upper)
 211
 212             # field identifiers
 213             for t in zip(f['types'], f['args']):
 214                 jni_type = t[0]
 215                 java_field_name = util.underscore_to_camelcase(t[1])
 216                 jni_signature = util.jni_2_signature_mapping[jni_type]
 217                 jni_getter = util.jni_field_accessors[jni_type]
 218                 field_identifiers += request_field_identifier_template.substitute(
 219                         jni_type=jni_type,
 220                         java_name=java_field_name,
 221                         jni_signature=jni_signature,
 222                         jni_getter=jni_getter)
 223
 224             # field setters
 225             for t in zip(f['c_types'], f['args'], f['lengths']):
 226                 c_type = t[0]
 227                 c_name = t[1]
 228                 field_length = t[2][0]
 229
 230                 # check if we are processing variable length array:
 231                 if t[2][1]:
 232                     field_length = util.underscore_to_camelcase(t[2][0])
 233
 234                 java_field_name = util.underscore_to_camelcase(c_name)
 235
 236                 struct_setter_template = struct_setter_templates[c_type]
 237
 238                 struct_setters += struct_setter_template.substitute(
 239                         c_name=c_name,
 240                         java_name=java_field_name,
 241                         field_length=field_length)
 242
 243         jni_impl.append(jni_impl_template.substitute(
 244                 inputfile=inputfile,
 245                 api_data=util.api_message_to_javadoc(f),
 246                 java_name=camel_case_function_name,
 247                 c_name_uppercase=f_name_uppercase,
 248                 c_name=f_name,
 249                 request_class=request_class,
 250                 field_identifiers=field_identifiers,
 251                 struct_setters=struct_setters,
 252                 args=arguments))
 253
 254     return "\n".join(jni_impl)
 255
 256
 257 dto_field_id_template = Template("""
 258     jfieldID ${java_name}FieldId = (*env)->GetFieldID(env, ${class_ref_name}Class, "${java_name}", "${jni_signature}");""")
 259
 260 default_dto_field_setter_template = Template("""
 261     (*env)->Set${jni_setter}(env, dto, ${java_name}FieldId, mp->${c_name});
 262 """)
 263
 264 variable_length_array_value_template = Template("""mp->${length_var_name}""")
 265 variable_length_array_template = Template("""clib_net_to_host_${length_field_type}(${value})""")
 266
 267 u16_dto_field_setter_template = Template("""
 268     (*env)->Set${jni_setter}(env, dto, ${java_name}FieldId, clib_net_to_host_u16(mp->${c_name}));
 269 """)
 270
 271 u32_dto_field_setter_template = Template("""
 272     (*env)->Set${jni_setter}(env, dto, ${java_name}FieldId, clib_net_to_host_u32(mp->${c_name}));
 273 """)
 274
 275 u64_dto_field_setter_template = Template("""
 276     (*env)->Set${jni_setter}(env, dto, ${java_name}FieldId, clib_net_to_host_u64(mp->${c_name}));
 277 """)
 278
 279 u8_array_dto_field_setter_template = Template("""
 280     jbyteArray ${java_name} = (*env)->NewByteArray(env, ${field_length});
 281     (*env)->SetByteArrayRegion(env, ${java_name}, 0, ${field_length}, (const jbyte*)mp->${c_name});
 282     (*env)->SetObjectField(env, dto, ${java_name}FieldId, ${java_name});
 283 """)
 284
 285 u32_array_dto_field_setter_template = Template("""
 286     {
 287         jintArray ${java_name} = (*env)->NewIntArray(env, ${field_length});
 288         jint * ${java_name}ArrayElements = (*env)->GetIntArrayElements(env, ${java_name}, NULL);
 289         unsigned int _i;
 290         for (_i = 0; _i < ${field_length}; _i++) {
 291             ${java_name}ArrayElements[_i] = clib_net_to_host_u32(mp->${c_name}[_i]);
 292         }
 293
 294         (*env)->ReleaseIntArrayElements(env,  ${java_name}, ${java_name}ArrayElements, 0);
 295         (*env)->SetObjectField(env, dto, ${java_name}FieldId, ${java_name});
 296     }
 297 """)
 298
 299 # For each u64 array we get its elements. Then we convert values to host byte order.
 300 # All changes to  jlong* buffer are written to jlongArray (isCopy is set to NULL)
 301 u64_array_dto_field_setter_template = Template("""
 302     {
 303         jlongArray ${java_name} = (*env)->NewLongArray(env, ${field_length});
 304         jlong * ${java_name}ArrayElements = (*env)->GetLongArrayElements(env, ${java_name}, NULL);
 305         unsigned int _i;
 306         for (_i = 0; _i < ${field_length}; _i++) {
 307             ${java_name}ArrayElements[_i] = clib_net_to_host_u64(mp->${c_name}[_i]);
 308         }
 309
 310         (*env)->ReleaseLongArrayElements(env,  ${java_name}, ${java_name}ArrayElements, 0);
 311         (*env)->SetObjectField(env, dto, ${java_name}FieldId, ${java_name});
 312     }
 313 """)
 314
 315 dto_field_setter_templates = {'u8': default_dto_field_setter_template,
 316                       'u16': u16_dto_field_setter_template,
 317                       'u32': u32_dto_field_setter_template,
 318                       'i32': u32_dto_field_setter_template,
 319                       'u64': u64_dto_field_setter_template,
 320                       'f64': default_dto_field_setter_template, #fixme
 321                       'u8[]': u8_array_dto_field_setter_template,
 322                       'u32[]': u32_array_dto_field_setter_template,
 323                       'u64[]': u64_array_dto_field_setter_template
 324                       }
 325
 326 # code fragment for checking result of the operation before sending request reply
 327 callback_err_handler_template = Template("""
 328     // for negative result don't send callback message but send error callback
 329     if (mp->retval<0) {
 330         CallOnError("${handler_name}",mp->context,mp->retval);
 331         return;
 332     }
 333     if (mp->retval == VNET_API_ERROR_IN_PROGRESS) {
 334         clib_warning("Result in progress");
 335         return;
 336     }
 337 """)
 338
 339 msg_handler_template = Template("""
 340 /**
 341  * Handler for ${handler_name} vpe.api message.
 342  * Generated based on $inputfile preparsed data:
 343 $api_data
 344  */
 345 static void vl_api_${handler_name}_t_handler (vl_api_${handler_name}_t * mp)
 346 {
 347     vppjni_main_t * jm = &vppjni_main;
 348     JNIEnv *env = jm->jenv;
 349     $err_handler
 350
 351     jmethodID constructor = (*env)->GetMethodID(env, ${class_ref_name}Class, "<init>", "()V");
 352     jmethodID callbackMethod = (*env)->GetMethodID(env, jm->callbackClass, "on${dto_name}", "(Lorg/openvpp/jvpp/dto/${dto_name};)V");
 353
 354     jobject dto = (*env)->NewObject(env, ${class_ref_name}Class, constructor);
 355     $dto_setters
 356     (*env)->CallVoidMethod(env, jm->callback, callbackMethod, dto);
 357 }""")
 358
 359 def generate_msg_handlers(func_list, inputfile):
 360     handlers = []
 361     for f in func_list:
 362         handler_name = f['name']
 363         dto_name = util.underscore_to_camelcase_upper(handler_name)
 364         ref_name = util.underscore_to_camelcase(handler_name)
 365
 366         if is_manually_generated(handler_name) or util.is_ignored(handler_name):
 367             continue
 368
 369         if not util.is_reply(dto_name) and not util.is_notification(handler_name):
 370             continue
 371
 372         if util.is_notification(handler_name):
 373             dto_name = util.add_notification_suffix(dto_name)
 374             ref_name = util.add_notification_suffix(ref_name)
 375
 376         dto_setters = ''
 377         err_handler = ''
 378         # dto setters
 379         for t in zip(f['c_types'], f['types'], f['args'], f['lengths']):
 380             c_type = t[0]
 381             jni_type = t[1]
 382             c_name = t[2]
 383             field_length = t[3][0]
 384
 385             # check if we are processing variable length array
 386             if t[3][1]:
 387                 length_var_name = t[3][0]
 388                 length_field_type = f['c_types'][f['args'].index(length_var_name)]
 389                 field_length = variable_length_array_value_template.substitute(length_var_name=length_var_name)
 390                 if length_field_type != 'u8':  # we need net to host conversion:
 391                     field_length = variable_length_array_template.substitute(
 392                         length_field_type=length_field_type, value=field_length)
 393
 394             # for retval don't generate setters and generate retval check
 395             if util.is_retval_field(c_name):
 396                 err_handler = callback_err_handler_template.substitute(
 397                     handler_name=handler_name
 398                 )
 399                 continue
 400
 401             java_field_name = util.underscore_to_camelcase(c_name)
 402             jni_signature = util.jni_2_signature_mapping[jni_type]
 403             jni_setter = util.jni_field_accessors[jni_type]
 404
 405             dto_setters += dto_field_id_template.substitute(
 406                     java_name=java_field_name,
 407                     class_ref_name=ref_name,
 408                     jni_signature=jni_signature)
 409
 410             dto_setter_template = dto_field_setter_templates[c_type]
 411
 412             dto_setters += dto_setter_template.substitute(
 413                     java_name=java_field_name,
 414                     jni_signature=jni_signature,
 415                     c_name=c_name,
 416                     jni_setter=jni_setter,
 417                     field_length=field_length)
 418
 419         handlers.append(msg_handler_template.substitute(
 420             inputfile=inputfile,
 421             api_data=util.api_message_to_javadoc(f),
 422             handler_name=handler_name,
 423             dto_name=dto_name,
 424             class_ref_name=ref_name,
 425             dto_setters=dto_setters,
 426             err_handler=err_handler))
 427
 428     return "\n".join(handlers)
 429
 430
 431 handler_registration_template = Template("""_(${upercase_name}, ${name}) \\
 432 """)
 433
 434
 435 def generate_handler_registration(func_list):
 436     handler_registration = ["#define foreach_vpe_api_msg \\\n"]
 437     for f in func_list:
 438         name = f['name']
 439         camelcase_name = util.underscore_to_camelcase(f['name'])
 440
 441         if (not util.is_reply(camelcase_name) and not util.is_notification(name)) or util.is_ignored(name):
 442             continue
 443
 444         handler_registration.append(handler_registration_template.substitute(
 445             name=name,
 446             upercase_name=name.upper()))
 447
 448     return "".join(handler_registration)
 449
 450
 451 jvpp_c_template = Template("""/**
 452  * This file contains JNI bindings for jvpp Java API.
 453  * It was generated by jvpp_c_gen.py based on $inputfile
 454  * (python representation of vpe.api generated by vppapigen).
 455  */
 456
 457 void CallOnError(const char* call, int context, int retval);
 458
 459 // JAVA class reference cache
 460 $class_cache
 461
 462 // JNI bindings
 463 $jni_implementations
 464
 465 // Message handlers
 466 $msg_handlers
 467
 468 // Registration of message handlers in vlib
 469 $handler_registration
 470 """)
 471
 472 def generate_jvpp(func_list, inputfile):
 473     """ Generates jvpp C file """
 474     print "Generating jvpp C"
 475
 476     class_cache = generate_class_cache(func_list)
 477     jni_impl = generate_jni_impl(func_list, inputfile)
 478     msg_handlers = generate_msg_handlers(func_list, inputfile)
 479     handler_registration = generate_handler_registration(func_list)
 480
 481     jvpp_c_file = open("jvpp_gen.h", 'w')
 482     jvpp_c_file.write(jvpp_c_template.substitute(
 483             inputfile=inputfile,
 484             class_cache=class_cache,
 485             jni_implementations=jni_impl,
 486             msg_handlers=msg_handlers,
 487             handler_registration=handler_registration))
 488     jvpp_c_file.flush()
 489     jvpp_c_file.close()
 490