Android: improvements to make jni_generator work outside of chromium

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 431 matching lines @@
   for line1, line2 in zip(unmatched_lines, unmatched_lines[1:]):
     if '@CalledByNative' in line1:
       raise ParseError('could not parse @CalledByNative method signature',
                        line1, line2)
   return MangleCalledByNatives(called_by_natives)
 
 
 class JNIFromJavaP(object):
   """Uses 'javap' to parse a .class file and generate the JNI header file."""
 
-  def __init__(self, contents, namespace):
+  def __init__(self, contents, options):
     self.contents = contents
-    self.namespace = namespace
+    self.namespace = options.namespace
     self.fully_qualified_class = re.match(
         '.*?(class|interface) (?P<class_name>.*?)( |{)',
         contents[1]).group('class_name')
     self.fully_qualified_class = self.fully_qualified_class.replace('.', '/')
     # 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:
@@ skipping 24 matching lines @@
           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('.', '/')),
           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)
+        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, namespace):
+  def CreateFromClass(class_file, options):
     class_name = os.path.splitext(os.path.basename(class_file))[0]
     p = subprocess.Popen(args=['javap', class_name],
                          cwd=os.path.dirname(class_file),
                          stdout=subprocess.PIPE,
                          stderr=subprocess.PIPE)
     stdout, _ = p.communicate()
-    jni_from_javap = JNIFromJavaP(stdout.split('\n'), namespace)
+    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):
+  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)
     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)
+        jni_namespace, fully_qualified_class, natives, called_by_natives,
+        options)
     self.content = inl_header_file_generator.GetContent()
 
   def _RemoveComments(self, contents):
     # 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'],
                          stdin=subprocess.PIPE,
                          stdout=subprocess.PIPE,
                          stderr=subprocess.PIPE)
     stdout, _ = p.communicate(contents)
     return stdout
 
   def GetContent(self):
     return self.content
 
   @staticmethod
-  def CreateFromFile(java_file_name):
+  def CreateFromFile(java_file_name, options):
     contents = file(java_file_name).read()
     fully_qualified_class = ExtractFullyQualifiedJavaClassName(java_file_name,
                                                                contents)
-    return JNIFromJavaSource(contents, fully_qualified_class)
+    return JNIFromJavaSource(contents, fully_qualified_class, options)
 
 
 class InlHeaderFileGenerator(object):
   """Generates an inline header file for JNI integration."""
 
   def __init__(self, namespace, fully_qualified_class, natives,
-               called_by_natives):
+               called_by_natives, options):
     self.namespace = namespace
     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.script_name = options.script_name
 
   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.
 
 
 // This file is autogenerated by
@@ skipping 26 matching lines @@
 
 // Step 3: RegisterNatives.
 
 static bool RegisterNativesImpl(JNIEnv* env) {
 $REGISTER_NATIVES_IMPL
   return true;
 }
 $CLOSE_NAMESPACE
 #endif  // ${HEADER_GUARD}
 """)
-    script_components = os.path.abspath(sys.argv[0]).split(os.path.sep)
-    base_index = script_components.index('base')
-    script_name = os.sep.join(script_components[base_index:])
     values = {
-        'SCRIPT_NAME': script_name,
+        'SCRIPT_NAME': self.script_name,
         'FULLY_QUALIFIED_CLASS': self.fully_qualified_class,
         'CLASS_PATH_DEFINITIONS': self.GetClassPathDefinitionsString(),
         'FORWARD_DECLARATIONS': self.GetForwardDeclarationsString(),
         'METHOD_STUBS': self.GetMethodStubsString(),
         'OPEN_NAMESPACE': self.GetOpenNamespaceString(),
         'REGISTER_NATIVES_IMPL': self.GetRegisterNativesImplString(),
         'CLOSE_NAMESPACE': self.GetCloseNamespaceString(),
         'HEADER_GUARD': self.header_guard,
     }
     return WrapOutput(template.substitute(values))
@@ skipping 352 matching lines @@
   except OSError as e:
     if e.errno != errno.EEXIST:
       raise
   extracted_file_name = os.path.join(out_dir, os.path.basename(input_file))
   with open(extracted_file_name, 'w') as outfile:
     outfile.write(jar_file.read(input_file))
 
   return extracted_file_name
 
 
-def GenerateJNIHeader(input_file, output_file, namespace, skip_if_same):
+def GenerateJNIHeader(input_file, output_file, options):
   try:
     if os.path.splitext(input_file)[1] == '.class':
-      jni_from_javap = JNIFromJavaP.CreateFromClass(input_file, namespace)
+      jni_from_javap = JNIFromJavaP.CreateFromClass(input_file, options)
       content = jni_from_javap.GetContent()
     else:
-      jni_from_java_source = JNIFromJavaSource.CreateFromFile(input_file)
+      jni_from_java_source = JNIFromJavaSource.CreateFromFile(
+          input_file, options)
       content = jni_from_java_source.GetContent()
   except ParseError, e:
     print e
     sys.exit(1)
   if output_file:
     if not os.path.exists(os.path.dirname(os.path.abspath(output_file))):
       os.makedirs(os.path.dirname(os.path.abspath(output_file)))
-    if skip_if_same and os.path.exists(output_file):
+    if options.optimize_generation and os.path.exists(output_file):
       with file(output_file, 'r') as f:
         existing_content = f.read()
         if existing_content == content:
           return
     with file(output_file, 'w') as f:
       f.write(content)
   else:
     print output
 
 
+def GetScriptName():
+  script_components = os.path.abspath(sys.argv[0]).split(os.path.sep)
+  base_index = 0
+  for idx, value in enumerate(script_components):
+    if value == 'base' or value == 'third_party':
+      base_index = idx
+      break
+  return os.sep.join(script_components[base_index:])
+
+
 def main(argv):
   usage = """usage: %prog [OPTIONS]
 This script will parse the given java source code extracting the native
 declarations and print the header file to stdout (or a file).
 See SampleForTests.java for more details.
   """
   option_parser = optparse.OptionParser(usage=usage)
   option_parser.add_option('-j', dest='jar_file',
                            help='Extract the list of input files from'
                            ' a specified jar file.'
                            ' Uses javap to extract the methods from a'
                            ' pre-compiled class. --input should point'
                            ' to pre-compiled Java .class files.')
   option_parser.add_option('-n', dest='namespace',
                            help='Uses as a namespace in the generated header,'
                            ' instead of the javap class name.')
   option_parser.add_option('--input_file',
                            help='Single input file name. The output file name '
                            'will be derived from it. Must be used with '
                            '--output_dir.')
   option_parser.add_option('--output_dir',
                            help='The output directory. Must be used with '
                            '--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.')
   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:
-    input_file = options.input_file
+    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.namespace,
-                    options.optimize_generation)
+  GenerateJNIHeader(input_file, output_file, options)
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))