Support Mac android cross compile.

pylib/gyp/generator/ninja.py

 # Copyright (c) 2012 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.
 
 import copy
 import hashlib
 import os.path
 import re
 import subprocess
 import sys
@@ skipping 199 matching lines @@
 #
 # - GypPathToNinja translates a gyp path (i.e. relative to the .gyp file)
 #   into the equivalent ninja path.
 #
 # - GypPathToUniqueOutput translates a gyp path into a ninja path to write
 #   an output file; the result can be namespaced such that it is unique
 #   to the input file name as well as the output target name.
 
 class NinjaWriter:
   def __init__(self, qualified_target, target_outputs, base_dir, build_dir,
-               output_file, flavor, abs_build_dir=None):
+               output_file, flavor, options, abs_build_dir=None):
     """
     base_dir: path from source root to directory containing this gyp file,
               by gyp semantics, all input paths are relative to this
     build_dir: path from source root to build output
     abs_build_dir: absolute path to the build directory
     """
 
     self.qualified_target = qualified_target
     self.target_outputs = target_outputs
     self.base_dir = base_dir
     self.build_dir = build_dir
     self.ninja = ninja_syntax.Writer(output_file)
     self.flavor = flavor
+    self.options = options
     self.abs_build_dir = abs_build_dir
     self.obj_ext = '.obj' if flavor == 'win' else '.o'
     if flavor == 'win':
       # See docstring of msvs_emulation.GenerateEnvironmentFiles().
       self.win_env = {}
       for arch in ('x86', 'x64'):
         self.win_env[arch] = 'environment.' + arch
 
     # Relative path from build output dir to base dir.
     self.build_to_base = os.path.join(InvertRelativePath(build_dir), base_dir)
@@ skipping 800 matching lines @@
     assert self.is_mac_bundle
     path = self.ExpandSpecial(generator_default_variables['PRODUCT_DIR'])
     return os.path.join(path, self.xcode_settings.GetExecutablePath())
 
   def ComputeOutputFileName(self, spec, type=None):
     """Compute the filename of the final output for the current target."""
     if not type:
       type = spec['type']
 
     default_variables = copy.copy(generator_default_variables)
-    CalculateVariables(default_variables, {'flavor': self.flavor})
-
+    CalculateVariables(default_variables, {'flavor': self.flavor,
+        'options': self.options })
     # Compute filename prefix: the product prefix, or a default for
     # the product type.
     DEFAULT_PREFIX = {
       'loadable_module': default_variables['SHARED_LIB_PREFIX'],
       'shared_library': default_variables['SHARED_LIB_PREFIX'],
       'static_library': default_variables['STATIC_LIB_PREFIX'],
       'executable': default_variables['EXECUTABLE_PREFIX'],
       }
     prefix = spec.get('product_prefix', DEFAULT_PREFIX.get(type, ''))
 
@@ skipping 130 matching lines @@
     self.ninja.newline()
 
     return rule_name
 
 
 def CalculateVariables(default_variables, params):
   """Calculate additional variables for use in the build (called by gyp)."""
   global generator_additional_non_configuration_keys
   global generator_additional_path_sections
   flavor = gyp.common.GetFlavor(params)
+  default_variables.setdefault('HOST_OS', gyp.common.GetHostFlavor(params))
   if flavor == 'mac':
     default_variables.setdefault('OS', 'mac')
     default_variables.setdefault('SHARED_LIB_SUFFIX', '.dylib')
     default_variables.setdefault('SHARED_LIB_DIR',
                                  generator_default_variables['PRODUCT_DIR'])
     default_variables.setdefault('LIB_DIR',
                                  generator_default_variables['PRODUCT_DIR'])
 
     # Copy additional generator configuration data from Xcode, which is shared
     # by the Mac Ninja generator.
@@ skipping 53 matching lines @@
     os.makedirs(os.path.dirname(path))
   except OSError:
     pass
   return open(path, mode)
 
 
 def GenerateOutputForConfig(target_list, target_dicts, data, params,
                             config_name):
   options = params['options']
   flavor = gyp.common.GetFlavor(params)
+  host_flavor = gyp.common.GetHostFlavor(params)
   generator_flags = params.get('generator_flags', {})
 
   # build_dir: relative path from source root to our output files.
   # e.g. "out/Debug"
   build_dir = os.path.join(generator_flags.get('output_dir', 'out'),
                            config_name)
 
   toplevel_build = os.path.join(options.toplevel_dir, build_dir)
 
   master_ninja = ninja_syntax.Writer(
       OpenOutput(os.path.join(toplevel_build, 'build.ninja')),
       width=120)
 
   # Put build-time support tools in out/{config_name}.
-  gyp.common.CopyTool(flavor, toplevel_build)
+  gyp.common.CopyTool(host_flavor, toplevel_build)
 
   # Grab make settings for CC/CXX.
   # The rules are
   # - The priority from low to high is gcc/g++, the 'make_global_settings' in
   #   gyp, the environment variable.
   # - If there is no 'make_global_settings' for CC.host/CXX.host or
   #   'CC_host'/'CXX_host' enviroment variable, cc_host/cxx_host should be set
   #   to cc/cxx.
   if flavor == 'win':
     cc = 'cl.exe'
@@ skipping 26 matching lines @@
     if key == 'CC.host':
       cc_host = os.path.join(build_to_root, value)
       cc_host_global_setting = value
     if key == 'CXX.host':
       cxx_host = os.path.join(build_to_root, value)
       cxx_host_global_setting = value
     if key == 'LD.host':
       ld_host = os.path.join(build_to_root, value)
 
   flock = 'flock'
-  if flavor == 'mac':
+  if host_flavor == 'mac':
     flock = './gyp-mac-tool flock'
   cc = GetEnvironFallback(['CC_target', 'CC'], cc)
   master_ninja.variable('cc', cc)
   cxx = GetEnvironFallback(['CXX_target', 'CXX'], cxx)
   master_ninja.variable('cxx', cxx)
   ld = GetEnvironFallback(['LD_target', 'LD'], ld)
 
   if not cc_host:
     cc_host = cc
   if not cxx_host:
@@ skipping 22 matching lines @@
     cc_host = cc_host_global_setting.replace('$(CC)', cc)
   if '$(CXX)' in cxx_host and cxx_host_global_setting:
     cxx_host = cxx_host_global_setting.replace('$(CXX)', cxx)
   master_ninja.variable('cc_host', cc_host)
   master_ninja.variable('cxx_host', cxx_host)
   if flavor == 'win':
     master_ninja.variable('ld_host', ld_host)
   else:
     master_ninja.variable('ld_host', flock + ' linker.lock ' + ld_host)
 
-  if flavor == 'mac':
+  if host_flavor == 'mac':
     master_ninja.variable('mac_tool', os.path.join('.', 'gyp-mac-tool'))
   master_ninja.newline()
 
   if flavor != 'win':
     master_ninja.rule(
       'cc',
       description='CC $out',
       command=('$cc -MMD -MF $out.d $defines $includes $cflags $cflags_c '
               '$cflags_pch_c -c $in -o $out'),
       depfile='$out.d')
@@ skipping 204 matching lines @@
       'link',
       description='LINK $out, POSTBUILDS',
       command=('$ld $ldflags -o $out '
                '$in $solibs $libs$postbuilds'))
     master_ninja.rule(
       'infoplist',
       description='INFOPLIST $out',
       command=('$cc -E -P -Wno-trigraphs -x c $defines $in -o $out && '
                'plutil -convert xml1 $out $out'))
     master_ninja.rule(
-      'mac_tool',
-      description='MACTOOL $mactool_cmd $in',
-      command='$env $mac_tool $mactool_cmd $in $out')
-    master_ninja.rule(
       'package_framework',
       description='PACKAGE FRAMEWORK $out, POSTBUILDS',
       command='$mac_tool package-framework $out $version$postbuilds '
               '&& touch $out')
+
+  if host_flavor == 'mac':
+    master_ninja.rule(
+      'mac_tool',
+      description='MACTOOL $mactool_cmd $in',
+      command='$env $mac_tool $mactool_cmd $in $out')
+
   if flavor == 'win':
     master_ninja.rule(
       'stamp',
       description='STAMP $out',
       command='%s gyp-win-tool stamp $out' % sys.executable)
     master_ninja.rule(
       'copy',
       description='COPY $in $out',
       command='%s gyp-win-tool recursive-mirror $in $out' % sys.executable)
   else:
@@ skipping 37 matching lines @@
 
     base_path = os.path.dirname(build_file)
     obj = 'obj'
     if toolset != 'target':
       obj += '.' + toolset
     output_file = os.path.join(obj, base_path, name + '.ninja')
 
     abs_build_dir = os.path.abspath(toplevel_build)
     writer = NinjaWriter(qualified_target, target_outputs, base_path, build_dir,
                          OpenOutput(os.path.join(toplevel_build, output_file)),
-                         flavor, abs_build_dir=abs_build_dir)
+                         flavor, options, abs_build_dir=abs_build_dir)
     master_ninja.subninja(output_file)
 
     target = writer.WriteSpec(spec, config_name, generator_flags)
     if target:
       if name != target.FinalOutput() and spec['toolset'] == 'target':
         target_short_names.setdefault(name, []).append(target)
       target_outputs[qualified_target] = target
       if qualified_target in all_targets:
         all_outputs.add(target.FinalOutput())
 
@@ skipping 19 matching lines @@
 
   user_config = params.get('generator_flags', {}).get('config', None)
   if user_config:
     GenerateOutputForConfig(target_list, target_dicts, data, params,
                             user_config)
   else:
     config_names = target_dicts[target_list[0]]['configurations'].keys()
     for config_name in config_names:
       GenerateOutputForConfig(target_list, target_dicts, data, params,
                               config_name)