Android: upstream few more jni_generator changes.

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 300 matching lines @@
 
 def ExtractNatives(contents, ptr_type):
   """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>.*?)\);')
+                         '(?P<name>native\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')),
         ptr_type=ptr_type)
     natives += [native]
@@ skipping 194 matching lines @@
     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', '-s', class_name],
+    p = subprocess.Popen(args=[options.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."""
 
   def __init__(self, contents, fully_qualified_class, options):
-    contents = self._RemoveComments(contents)
+    contents = self._RemoveComments(contents, options)
     JniParams.SetFullyQualifiedClass(fully_qualified_class)
     JniParams.ExtractImportsAndInnerClasses(contents)
     jni_namespace = ExtractJNINamespace(contents) or options.namespace
     natives = ExtractNatives(contents, options.ptr_type)
     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):
+  def _RemoveComments(self, contents, options):
     # We need to support both inline and block comments, and we need to handle
     # strings that contain '//' or '/*'. Rather than trying to do all that with
     # regexps, we just pipe the contents through the C preprocessor. We tell cpp
     # the file has already been preprocessed, so it just removes comments and
     # doesn't try to parse #include, #pragma etc.
     #
     # TODO(husky): This is a bit hacky. It would be cleaner to use a real Java
     # parser. Maybe we could ditch JNIFromJavaSource and just always use
     # JNIFromJavaP; or maybe we could rewrite this script in Java and use APT.
     # http://code.google.com/p/chromium/issues/detail?id=138941
-    p = subprocess.Popen(args=['cpp', '-fpreprocessed'],
+    p = subprocess.Popen(args=[options.cpp, '-fpreprocessed'],
                          stdin=subprocess.PIPE,
                          stdout=subprocess.PIPE,
                          stderr=subprocess.PIPE)
     stdout, _ = p.communicate(contents)
     return stdout
 
   def GetContent(self):
     return self.content
 
   @staticmethod
@@ skipping 13 matching lines @@
     self.fully_qualified_class = fully_qualified_class
     self.class_name = self.fully_qualified_class.split('/')[-1]
     self.natives = natives
     self.called_by_natives = called_by_natives
     self.header_guard = fully_qualified_class.replace('/', '_') + '_JNI'
     self.options = options
     self.init_native = self.ExtractInitNative(options)
 
   def ExtractInitNative(self, options):
     for native in self.natives:
-      if options.jni_init_native_name == native.name:
+      if options.jni_init_native_name == 'native' + native.name:
         self.natives.remove(native)
         return native
     return None
 
   def GetContent(self):
     """Returns the content of the JNI binding file."""
     template = Template("""\
 // 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.
@@ skipping 205 matching lines @@
 extern "C" JNIEXPORT bool JNICALL
 Java_${FULLY_QUALIFIED_CLASS}_${INIT_NATIVE_NAME}(JNIEnv* env, jclass clazz) {
   return ${NAMESPACE}RegisterNativesImpl(env, clazz);
 }
 """)
     fully_qualified_class = self.fully_qualified_class.replace('/', '_')
     namespace = ''
     if self.namespace:
       namespace = self.namespace + '::'
     values = {'FULLY_QUALIFIED_CLASS': fully_qualified_class,
-              'INIT_NATIVE_NAME': self.init_native.name,
+              'INIT_NATIVE_NAME': 'native' + self.init_native.name,
               'NAMESPACE': namespace,
               'REGISTER_NATIVES_IMPL': self.GetRegisterNativesImplString()
              }
     return template.substitute(values)
 
   def GetOpenNamespaceString(self):
     if self.namespace:
       all_namespaces = ['namespace %s {' % ns
                         for ns in self.namespace.split('::')]
       return '\n'.join(all_namespaces)
@@ skipping 418 matching lines @@
                            'method with this name is not present in the Java '
                            'source file, setting this option is a no-op. When '
                            'a method with this name is found however, the '
                            'naming convention Java_<packageName>_<className> '
                            'will limit the initialization to only the '
                            'top-level class.')
   option_parser.add_option('--eager_called_by_natives',
                            action='store_true', dest='eager_called_by_natives',
                            help='When true, the called-by-native methods will '
                            'be initialized in a non-atomic way.')
+  option_parser.add_option('--cpp', default='cpp',
+                           help='The path to cpp command.')
+  option_parser.add_option('--javap', default='javap',
+                           help='The path to javap command.')
   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))