This change supports Android NDK.

pylib/gyp/generator/make.py

 #!/usr/bin/python
 
 # Copyright (c) 2009 Google Inc. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 # Notes:
 #
 # This is all roughly based on the Makefile system used by the Linux
 # kernel, but is a non-recursive make -- we put the entire dependency
@@ skipping 485 matching lines @@
 # Used in building shared-library-based executables.
 target_link_deps = {}
 
 
 class MakefileWriter:
   """MakefileWriter packages up the writing of one target-specific foobar.mk.
 
   Its only real entry point is Write(), and is mostly used for namespacing.
   """
 
-  def __init__(self):
+  def __init__(self, generator_flags):
+    self.generator_flags = generator_flags
     # Keep track of the total number of outputs for this makefile.
     self._num_outputs = 0
 
 
   def NumOutputs(self):
     return self._num_outputs
 
 
   def Write(self, qualified_target, base_path, output_filename, spec, configs,
             part_of_all):
@@ skipping 80 matching lines @@
     target_outputs[qualified_target] = install_path
 
     # Update global list of link dependencies.
     if self.type == 'static_library':
       target_link_deps[qualified_target] = [self.output]
     elif self.type == 'shared_library':
       # Anyone that uses us transitively depend on all of our link
       # dependencies.
       target_link_deps[qualified_target] = [self.output] + link_deps
 
+    # Currently any versions have the same effect, but in future the behavior
+    # could be different.
+    if self.generator_flags.get('android_ndk_version', None):
+      self.WriteAndroidNdkModuleRule(self.target, all_sources, link_deps)
+
     self.fp.close()
 
 
   def WriteSubMake(self, output_filename, makefile_path, targets, build_dir):
     """Write a "sub-project" Makefile.
 
     This is a small, wrapper Makefile that calls the top-level Makefile to build
     the targets from a single gyp file (i.e. a sub-project).
 
     Arguments:
@@ skipping 522 matching lines @@
       # we'll have generated all the outputs and we're done.
       self.WriteLn('%s: %s' % (' '.join(outputs[1:]), outputs[0]))
       # Add a dummy command to the "extra outputs" rule, otherwise make seems to
       # think these outputs haven't (couldn't have?) changed, and thus doesn't
       # flag them as changed (i.e. include in '$?') when evaluating dependent
       # rules, which in turn causes do_cmd() to skip running dependent commands.
       self.WriteLn('%s: ;' % (' '.join(outputs[1:])))
     self.WriteLn()
 
 
+  def WriteAndroidNdkModuleRule(self, module_name, all_sources, link_deps):
+    """Write a set of LOCAL_XXX definitions for Android NDK.
+
+    These variable definitions will be used by Android NDK but do nothing for
+    non-Android applications.
+
+    Arguments:
+      module_name: Android NDK module name, which must be unique among all
+          module names.
+      all_sources: A list of source files (will be filtered by Compilable).
+      link_deps: A list of link dependencies, which must be sorted in
+          the order from dependencies to dependents.
+    """
+    if self.type not in ('executable', 'shared_library', 'static_library'):
+      return
+
+    self.WriteLn('# Variable definitions for Android applications')
+    self.WriteLn('include $(CLEAR_VARS)')
+    self.WriteLn('LOCAL_MODULE := ' + module_name)
+    self.WriteLn('LOCAL_CFLAGS := $(CFLAGS_$(BUILDTYPE)) '
+                 '$(DEFS_$(BUILDTYPE)) '
+                 # LOCAL_CFLAGS is applied to both of C and C++.  There is
+                 # no way to specify $(CFLAGS_C_$(BUILDTYPE)) only for C
+                 # sources.
+                 '$(CFLAGS_C_$(BUILDTYPE)) '
+                 # $(INCS_$(BUILDTYPE)) includes the prefix '-I' while
+                 # LOCAL_C_INCLUDES does not expect it.  So put it in
+                 # LOCAL_CFLAGS.
+                 '$(INCS_$(BUILDTYPE))')
+    # LOCAL_CXXFLAGS is obsolete and LOCAL_CPPFLAGS is preferred.
+    self.WriteLn('LOCAL_CPPFLAGS := $(CFLAGS_CC_$(BUILDTYPE))')
+    self.WriteLn('LOCAL_C_INCLUDES :=')
+    self.WriteLn('LOCAL_LDLIBS := $(LDFLAGS_$(BUILDTYPE)) $(LIBS)')
+
+    # Detect the C++ extension.
+    cpp_ext = {'.cc': 0, '.cpp': 0, '.cxx': 0}
+    default_cpp_ext = '.cpp'
+    for filename in all_sources:
+      ext = os.path.splitext(filename)[1]
+      if ext in cpp_ext:
+        cpp_ext[ext] += 1
+        if cpp_ext[ext] > cpp_ext[default_cpp_ext]:
+          default_cpp_ext = ext
+    self.WriteLn('LOCAL_CPP_EXTENSION := ' + default_cpp_ext)
+
+    self.WriteList(map(self.Absolutify, filter(Compilable, all_sources)),
+                   'LOCAL_SRC_FILES')
+
+    # Filter out those which do not match prefix and suffix and produce
+    # the resulting list without prefix and suffix.
+    def DepsToModules(deps, prefix, suffix):
+      modules = []
+      for filepath in deps:
+        filename = os.path.basename(filepath)
+        if filename.startswith(prefix) and filename.endswith(suffix):
+          modules.append(filename[len(prefix):-len(suffix)])
+      return modules
+
+    self.WriteList(
+        DepsToModules(link_deps,
+                      generator_default_variables['SHARED_LIB_PREFIX'],
+                      generator_default_variables['SHARED_LIB_SUFFIX']),
+        'LOCAL_SHARED_LIBRARIES')
+    self.WriteList(
+        DepsToModules(link_deps,
+                      generator_default_variables['STATIC_LIB_PREFIX'],
+                      generator_default_variables['STATIC_LIB_SUFFIX']),
+        'LOCAL_STATIC_LIBRARIES')
+
+    if self.type == 'executable':
+      self.WriteLn('include $(BUILD_EXECUTABLE)')
+    elif self.type == 'shared_library':
+      self.WriteLn('include $(BUILD_SHARED_LIBRARY)')
+    elif self.type == 'static_library':
+      self.WriteLn('include $(BUILD_STATIC_LIBRARY)')
+    self.WriteLn()
+
+
   def WriteLn(self, text=''):
     self.fp.write(text + '\n')
 
 
   def Objectify(self, path):
     """Convert a path to its output directory form."""
     if '$(' in path:
       path = path.replace('$(obj)/', '$(obj).%s/$(TARGET)/' % self.toolset)
       return path
     return '$(obj).%s/$(TARGET)/%s' % (self.toolset, path)
 
+
   def Absolutify(self, path):
     """Convert a subdirectory-relative path into a base-relative path.
     Skips over paths that contain variables."""
     if '$(' in path:
       return path
     return os.path.normpath(os.path.join(self.path, path))
 
 
   def FixupArgPath(self, arg):
     if '/' in arg or '.h.' in arg:
@@ skipping 93 matching lines @@
   """Calculate additional variables for use in the build (called by gyp)."""
   cc_target = os.environ.get('CC.target', os.environ.get('CC', 'cc'))
   default_variables['LINKER_SUPPORTS_ICF'] = \
       gyp.system_test.TestLinkerSupportsICF(cc_command=cc_target)
 
 
 def GenerateOutput(target_list, target_dicts, data, params):
   options = params['options']
   generator_flags = params.get('generator_flags', {})
   builddir_name = generator_flags.get('output_dir', 'out')
+  android_ndk_version = generator_flags.get('android_ndk_version', None)
 
   def CalculateMakefilePath(build_file, base_name):
     """Determine where to write a Makefile for a given gyp file."""
     # Paths in gyp files are relative to the .gyp file, but we want
     # paths relative to the source root for the master makefile.  Grab
     # the path of the .gyp file as the base to relativize against.
     # E.g. "foo/bar" when we're constructing targets for "foo/bar/baz.gyp".
     base_path = gyp.common.RelativePath(os.path.dirname(build_file),
                                         options.depth)
     # We write the file in the base_path directory.
@@ skipping 29 matching lines @@
   header_params = {
       'srcdir': srcdir,
       'builddir': builddir_name,
       'default_configuration': default_configuration,
     }
   header_params.update(RunSystemTests())
 
   ensure_directory_exists(makefile_path)
   root_makefile = open(makefile_path, 'w')
   root_makefile.write(SHARED_HEADER % header_params)
+  # Currently any versions have the same effect, but in future the behavior
+  # could be different.
+  if android_ndk_version:
+    root_makefile.write(
+        '# Define LOCAL_PATH for build of Android applications.\n'
+        'LOCAL_PATH := $(call my-dir)\n'
+        '\n')
   for toolset in toolsets:
     root_makefile.write('TOOLSET := %s\n' % toolset)
     root_makefile.write(ROOT_HEADER_SUFFIX_RULES)
 
   # Find the list of targets that derive from the gyp file(s) being built.
   needed_targets = set()
   for build_file in params['build_files']:
     for target in gyp.common.AllTargets(target_list, target_dicts, build_file):
       needed_targets.add(target)
 
@@ skipping 20 matching lines @@
         build_files.add(abs_include_file)
       else:
         build_files.add(relative_include_file)
 
     base_path, output_file = CalculateMakefilePath(build_file,
         target + '.' + toolset + options.suffix + '.mk')
 
     spec = target_dicts[qualified_target]
     configs = spec['configurations']
 
-    writer = MakefileWriter()
+    writer = MakefileWriter(generator_flags)
     writer.Write(qualified_target, base_path, output_file, spec, configs,
                  part_of_all=qualified_target in needed_targets)
     num_outputs += writer.NumOutputs()
 
     # Our root_makefile lives at the source root.  Compute the relative path
     # from there to the output_file for including.
     mkfile_rel_path = gyp.common.RelativePath(output_file,
                                               os.path.dirname(makefile_path))
     include_list.add(mkfile_rel_path)
 
@@ skipping 48 matching lines @@
   # Add a check to make sure we tried to process all the .d files.
   all_deps += """
   ifneq ($(word %(last)d,$(d_files)),)
     $(error Found unprocessed dependency files (gyp didn't generate enough rules!))
   endif
 """ % { 'last': ((num_outputs / 1000) + 1) * 1000 + 1 }
 
   root_makefile.write(SHARED_FOOTER % { 'generate_all_deps': all_deps })
 
   root_makefile.close()