Android: adds ptr_type to jni_generator.

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 35 matching lines @@
   def __init__(self, **kwargs):
     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']
     if self.params:
       assert type(self.params) is list
       assert type(self.params[0]) is Param
     if (self.params and
-        self.params[0].datatype == 'int' and
+        self.params[0].datatype == kwargs.get('ptr_type', 'int') and
         self.params[0].name.startswith('native')):
       self.type = 'method'
       self.p0_type = self.params[0].name[len('native'):]
       if kwargs.get('native_class_name'):
         self.p0_type = kwargs['native_class_name']
     else:
       self.type = 'function'
     self.method_id_var_name = kwargs.get('method_id_var_name', None)
 
 
@@ skipping 216 matching lines @@
 
 def ExtractFullyQualifiedJavaClassName(java_file_name, contents):
   re_package = re.compile('.*?package (.*?);')
   matches = re.findall(re_package, contents)
   if not matches:
     raise SyntaxError('Unable to find "package" line in %s' % java_file_name)
   return (matches[0].replace('.', '/') + '/' +
           os.path.splitext(os.path.basename(java_file_name))[0])
 
 
-def ExtractNatives(contents):
+def ExtractNatives(contents, options):
   """Returns a list of dict containing information about a native method."""
   contents = contents.replace('\n', '')
   natives = []
   re_native = re.compile(r'(@NativeClassQualifiedName'
                          '\(\"(?P<native_class_name>.*?)\"\))?\s*'
                          '(@NativeCall(\(\"(?P<java_class_name>.*?)\"\)))?\s*'
                          '(?P<qualifiers>\w+\s\w+|\w+|\s+)\s*?native '
                          '(?P<return_type>\S*?) '
                          '(?P<name>\w+?)\((?P<params>.*?)\);')
   for match in re.finditer(re_native, contents):
     native = NativeMethod(
         static='static' in match.group('qualifiers'),
         java_class_name=match.group('java_class_name'),
         native_class_name=match.group('native_class_name'),
         return_type=match.group('return_type'),
         name=match.group('name').replace('native', ''),
-        params=JniParams.Parse(match.group('params')))
+        params=JniParams.Parse(match.group('params')),
+        ptr_type=options.ptr_type)
     natives += [native]
   return natives
 
 
 def GetStaticCastForReturnType(return_type):
   type_map = { 'String' : 'jstring',
                'java/lang/String' : 'jstring',
                'boolean[]': 'jbooleanArray',
                'byte[]': 'jbyteArray',
                'char[]': 'jcharArray',
@@ skipping 202 matching lines @@
 
 
 class JNIFromJavaSource(object):
   """Uses the given java source file to generate the JNI header file."""
 
   def __init__(self, contents, fully_qualified_class, options):
     contents = self._RemoveComments(contents)
     JniParams.SetFullyQualifiedClass(fully_qualified_class)
     JniParams.ExtractImportsAndInnerClasses(contents)
     jni_namespace = ExtractJNINamespace(contents)
-    natives = ExtractNatives(contents)
+    natives = ExtractNatives(contents, options)

[rmcilroy, 2013/10/29 11:12:00]

nit - Unless you think other fields in the "options" object will be required
later, it might be cleaner just to pass ptr_type to this method.

[bulach, 2013/10/29 18:22:20]

good point, done.

     called_by_natives = ExtractCalledByNatives(contents)
     if len(natives) == 0 and len(called_by_natives) == 0:
       raise SyntaxError('Unable to find any JNI methods for %s.' %
                         fully_qualified_class)
     inl_header_file_generator = InlHeaderFileGenerator(
         jni_namespace, fully_qualified_class, natives, called_by_natives,
         options)
     self.content = inl_header_file_generator.GetContent()
 
   def _RemoveComments(self, contents):
@@ skipping 522 matching lines @@
                            '--input')
   option_parser.add_option('--optimize_generation', type="int",
                            default=0, help='Whether we should optimize JNI '
                            'generation by not regenerating files if they have '
                            'not changed.')
   option_parser.add_option('--jarjar',
                            help='Path to optional jarjar rules file.')
   option_parser.add_option('--script_name', default=GetScriptName(),
                            help='The name of this script in the generated '
                            'header.')
+  option_parser.add_option('--ptr_type', default='int',
+                           type='choice', choices=['int', 'long'],
+                           help='The type of "p0" to be cast to a native '

[rmcilroy, 2013/10/29 11:12:00]

nit - the reference to "p0" is a bit obscure.  How about "The type used to
represent native pointers in Java code."?

[Andrew Hayden (chromium.org), 2013/10/29 11:49:21]

Or even more explicitly:
"The type used to represent native pointers in Java code. For 32-bit, use int;
for 64-bit, use long."

[bulach, 2013/10/29 18:22:20]

Done.

+                           'pointer.')
   options, args = option_parser.parse_args(argv)
   if options.jar_file:
     input_file = ExtractJarInputFile(options.jar_file, options.input_file,
                                      options.output_dir)
   elif options.input_file:
     input_file = options.input_file
   else:
     option_parser.print_help()
     print '\nError: Must specify --jar_file or --input_file.'
     return 1
   output_file = None
   if options.output_dir:
     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))