Android: fixes for JNI with javap for java7.

base/android/jni_generator/jni_generator.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Extracts native methods from a Java file and generates the JNI bindings.
 If you change this, please run and update the tests."""
 
 import collections
 import errno
@@ skipping 58 matching lines @@
 
   def __init__(self, **kwargs):
     self.system_class = kwargs['system_class']
     self.unchecked = kwargs['unchecked']
     self.static = kwargs['static']
     self.java_class_name = kwargs['java_class_name']
     self.return_type = kwargs['return_type']
     self.name = kwargs['name']
     self.params = kwargs['params']
     self.method_id_var_name = kwargs.get('method_id_var_name', None)
+    self.signature = kwargs.get('signature')
     self.is_constructor = kwargs.get('is_constructor', False)
     self.env_call = GetEnvCall(self.is_constructor, self.static,
                                self.return_type)
     self.static_cast = GetStaticCastForReturnType(self.return_type)
 
 
 def JavaDataTypeToC(java_type):
   """Returns a C datatype for the given java type."""
   java_pod_type_map = {
       'int': 'jint',
@@ skipping 45 matching lines @@
       JniParams._imports += ['L' + match.group('class').replace('.', '/')]
 
     re_inner = re.compile(r'(class|interface)\s+?(?P<name>\w+?)\W')
     for match in re.finditer(re_inner, contents):
       inner = match.group('name')
       if not JniParams._fully_qualified_class.endswith(inner):
         JniParams._inner_classes += [JniParams._fully_qualified_class + '$' +
                                      inner]
 
   @staticmethod
+  def ParseJavaPSignature(signature_line):
+    prefix = 'Signature: '
+    return '"%s"' % signature_line[signature_line.index(prefix) + len(prefix):]
+
+  @staticmethod
   def JavaToJni(param):
     """Converts a java param into a JNI signature type."""
     pod_param_map = {
         'int': 'I',
         'boolean': 'Z',
         'char': 'C',
         'short': 'S',
         'long': 'J',
         'double': 'D',
         'float': 'F',
@@ skipping 305 matching lines @@
     # Java 7's javap includes type parameters in output, like HashSet<T>. Strip
     # away the <...> and use the raw class name that Java 6 would've given us.
     self.fully_qualified_class = self.fully_qualified_class.split('<', 1)[0]
     JniParams.SetFullyQualifiedClass(self.fully_qualified_class)
     self.java_class_name = self.fully_qualified_class.split('/')[-1]
     if not self.namespace:
       self.namespace = 'JNI_' + self.java_class_name
     re_method = re.compile('(?P<prefix>.*?)(?P<return_type>\S+?) (?P<name>\w+?)'
                            '\((?P<params>.*?)\)')
     self.called_by_natives = []
-    for content in contents[2:]:
+    for lineno, content in enumerate(contents[2:], 2):
       match = re.match(re_method, content)
       if not match:
         continue
       self.called_by_natives += [CalledByNative(
           system_class=True,
           unchecked=False,
           static='static' in match.group('prefix'),
           java_class_name='',
           return_type=match.group('return_type').replace('.', '/'),
           name=match.group('name'),
-          params=JniParams.Parse(match.group('params').replace('.', '/')))]
-    re_constructor = re.compile('.*? public ' +
+          params=JniParams.Parse(match.group('params').replace('.', '/')),
+          signature=JniParams.ParseJavaPSignature(contents[lineno + 1]))]
+    re_constructor = re.compile('(.*?)public ' +
                                 self.fully_qualified_class.replace('/', '.') +
                                 '\((?P<params>.*?)\)')
-    for content in contents[2:]:
+    for lineno, content in enumerate(contents[2:], 2):
       match = re.match(re_constructor, content)
       if not match:
         continue
       self.called_by_natives += [CalledByNative(
           system_class=True,
           unchecked=False,
           static=False,
           java_class_name='',
           return_type=self.fully_qualified_class,
           name='Constructor',
           params=JniParams.Parse(match.group('params').replace('.', '/')),
+          signature=JniParams.ParseJavaPSignature(contents[lineno + 1]),
           is_constructor=True)]
     self.called_by_natives = MangleCalledByNatives(self.called_by_natives)
     self.inl_header_file_generator = InlHeaderFileGenerator(
         self.namespace, self.fully_qualified_class, [],
         self.called_by_natives, options)
 
   def GetContent(self):
     return self.inl_header_file_generator.GetContent()
 
   @staticmethod
   def CreateFromClass(class_file, options):
     class_name = os.path.splitext(os.path.basename(class_file))[0]
-    p = subprocess.Popen(args=['javap', class_name],
+    p = subprocess.Popen(args=['javap', '-s', class_name],
                          cwd=os.path.dirname(class_file),
                          stdout=subprocess.PIPE,
                          stderr=subprocess.PIPE)
     stdout, _ = p.communicate()
     jni_from_javap = JNIFromJavaP(stdout.split('\n'), options)
     return jni_from_javap
 
 
 class JNIFromJavaSource(object):
   """Uses the given java source file to generate the JNI header file."""
@@ skipping 405 matching lines @@
       env, g_${JAVA_CLASS}_clazz,
       "${JNI_NAME}",
       ${JNI_SIGNATURE},
       &g_${JAVA_CLASS}_${METHOD_ID_VAR_NAME});
 """)
     jni_name = called_by_native.name
     jni_return_type = called_by_native.return_type
     if called_by_native.is_constructor:
       jni_name = '<init>'
       jni_return_type = 'void'
+    if called_by_native.signature:
+      signature = called_by_native.signature
+    else:
+      signature = JniParams.Signature(called_by_native.params,
+                                      jni_return_type,
+                                      True)
     values = {
         'JAVA_CLASS': called_by_native.java_class_name or self.class_name,
         'JNI_NAME': jni_name,
         'METHOD_ID_VAR_NAME': called_by_native.method_id_var_name,
         'STATIC': 'STATIC' if called_by_native.static else 'INSTANCE',
-        'JNI_SIGNATURE': JniParams.Signature(called_by_native.params,
-                                             jni_return_type,
-                                             True)
+        'JNI_SIGNATURE': signature,
     }
     return template.substitute(values)
 
 
 def WrapOutput(output):
   ret = []
   for line in output.splitlines():
     # Do not wrap lines under 80 characters or preprocessor directives.
     if len(line) < 80 or line.lstrip()[:1] == '#':
       stripped = line.rstrip()
@@ skipping 124 matching lines @@
     root_name = os.path.splitext(os.path.basename(input_file))[0]
     output_file = os.path.join(options.output_dir, root_name) + '_jni.h'
   if options.jarjar:
     with open(options.jarjar) as f:
       JniParams.SetJarJarMappings(f.read())
   GenerateJNIHeader(input_file, output_file, options)
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))