src/vpp-api/java/jvpp/gen/jvppgen/jni_gen.py

   1 #!/usr/bin/env python2
   2 #
   3 # Copyright (c) 2016,2018 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 from string import Template
  17
  18 from jni_impl_gen import generate_jni_impl
  19 from jni_msg_handlers_gen import generate_jni_handlers
  20 from jni_type_handlers_gen import generate_type_handlers
  21 from jvpp_model import is_control_ping, is_dump, is_request, is_control_ping_reply
  22
  23
  24 def generate_jni(work_dir, model, logger):
  25     logger.debug("Generating jvpp C for %s" % model.json_api_files)
  26     plugin_name = model.plugin_name
  27     messages = model.messages
  28
  29     with open("%s/jvpp_%s_gen.h" % (work_dir, plugin_name), "w") as f:
  30         f.write(_JVPP_C_TEMPLATE.substitute(
  31             json_filename=model.json_api_files,
  32             class_cache=_generate_class_cache(plugin_name, messages),
  33             api_verification=_generate_api_verification(messages),
  34             type_handlers=generate_type_handlers(model, logger),
  35             jni_implementations=generate_jni_impl(model),
  36             msg_handlers=generate_jni_handlers(model),
  37             handler_registration=_generate_handler_registration(messages)))
  38
  39 _JVPP_C_TEMPLATE = Template("""/**
  40  * This file contains JNI bindings for jvpp Java API.
  41  * It was generated by jvpp_jni_gen.py based on $json_filename.
  42  */
  43 $class_cache
  44
  45 $api_verification
  46
  47 // Type handlers
  48 $type_handlers
  49
  50 // JNI bindings
  51 $jni_implementations
  52
  53 // Message handlers
  54 $msg_handlers
  55
  56 $handler_registration
  57 """)
  58
  59
  60 def _generate_class_cache(plugin_name, messages):
  61     references = []
  62     for msg in messages:
  63         if is_control_ping(msg) or is_control_ping_reply(msg):
  64             # Skip control_ping managed by jvpp registry.
  65             continue
  66         references.append((
  67             msg.java_name_lower,
  68             'io/fd/vpp/jvpp/%s/dto/%s' % (plugin_name, msg.java_name_upper)
  69         ))
  70
  71     references.append(('callbackException', 'io/fd/vpp/jvpp/VppCallbackException'))
  72
  73     return _CLASS_CACHE_TEMPLATE.substitute(
  74         class_references=_generate_class_references(references),
  75         create_references=_generate_create_references(references),
  76         delete_references=_generate_delete_references(references)
  77     )
  78
  79 _CLASS_CACHE_TEMPLATE = Template("""
  80 // JAVA class reference cache
  81 $class_references
  82
  83 static int cache_class_references(JNIEnv* env) {
  84 $create_references
  85     return 0;
  86 }
  87
  88 static void delete_class_references(JNIEnv* env) {
  89 $delete_references
  90 }""")
  91
  92
  93 def _generate_class_references(references):
  94     return "\n".join("jclass %sClass;" % r[0] for r in references)
  95
  96
  97 def _generate_create_references(references):
  98     items = []
  99     for r in references:
 100         items.append(_CREATE_GLOBAL_REF_TEMPLATE.substitute(
 101             ref_name=r[0],
 102             fqn_name=r[1]
 103         ))
 104     return "".join(items)
 105
 106 _CREATE_GLOBAL_REF_TEMPLATE = Template("""
 107     ${ref_name}Class = (jclass)(*env)->NewGlobalRef(env, (*env)->FindClass(env, "${fqn_name}"));
 108     if ((*env)->ExceptionCheck(env)) {
 109         (*env)->ExceptionDescribe(env);
 110         return JNI_ERR;
 111     }""")
 112
 113
 114 def _generate_delete_references(references):
 115     items = []
 116     for r in references:
 117         items.append(_DELETE_CLASS_INVOCATION_TEMPLATE.substitute(ref_name=r[0]))
 118     return "".join(items)
 119
 120 _DELETE_CLASS_INVOCATION_TEMPLATE = Template("""
 121     if (${ref_name}Class) {
 122         (*env)->DeleteGlobalRef(env, ${ref_name}Class);
 123     }""")
 124
 125
 126 def _generate_api_verification(messages):
 127     items = []
 128     for msg in messages:
 129         items.append("_(%s_%s) \\" % (msg.name, msg.crc))
 130     return _API_VERIFICATION_TEMPLATE.substitute(messages="\n".join(items))
 131
 132 _API_VERIFICATION_TEMPLATE = Template("""
 133 // List of supported API messages used for verification
 134 #define foreach_supported_api_message \\
 135 $messages
 136 """)
 137
 138
 139 def _generate_handler_registration(messages):
 140     """
 141     Generates msg handler registration for all messages except for dumps and requests.
 142     :param messages: collection of VPP API messages.
 143     """
 144     handlers = []
 145     for msg in messages:
 146         if is_control_ping(msg) or is_control_ping_reply(msg):
 147             # Skip control_ping managed by jvpp registry.
 148             continue
 149         if is_dump(msg) or is_request(msg):
 150             continue
 151         name = msg.name
 152         crc = msg.crc
 153         handlers.append("_(%s_%s, %s) \\" % (name, crc, name))
 154     return _HANDLER_REGISTRATION_TEMPLATE.substitute(handlers="\n".join(handlers))
 155
 156 _HANDLER_REGISTRATION_TEMPLATE = Template("""
 157 // Registration of message handlers in vlib
 158 #define foreach_api_reply_handler \\
 159 $handlers
 160 """)