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