Support Mac android cross compile.

pylib/gyp/generator/make.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.
 
 # 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
 # graph in front of make and let it figure it out.
 #
@@ skipping 44 matching lines @@
 # Placates pylint.
 generator_additional_non_configuration_keys = []
 generator_additional_path_sections = []
 generator_extra_sources_for_rules = []
 
 
 def CalculateVariables(default_variables, params):
   """Calculate additional variables for use in the build (called by gyp)."""
   cc_target = os.environ.get('CC.target', os.environ.get('CC', 'cc'))
   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 Make generator.
@@ skipping 1837 matching lines @@
                                                          cc_command=cc_host):
     arflags_host = 'crsT'
 
   return { 'ARFLAGS.target': arflags_target,
            'ARFLAGS.host': arflags_host }
 
 
 def GenerateOutput(target_list, target_dicts, data, params):
   options = params['options']
   flavor = gyp.common.GetFlavor(params)
+  host_flavor = gyp.common.GetHostFlavor(params)
   generator_flags = params.get('generator_flags', {})
   builddir_name = generator_flags.get('output_dir', 'out')
   android_ndk_version = generator_flags.get('android_ndk_version', None)
   default_target = generator_flags.get('default_target', 'all')
 
   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.
@@ skipping 34 matching lines @@
   header_params = {
       'default_target': default_target,
       'builddir': builddir_name,
       'default_configuration': default_configuration,
       'flock': flock_command,
       'flock_index': 1,
       'link_commands': LINK_COMMANDS_LINUX,
       'extra_commands': '',
       'srcdir': srcdir,
     }
-  if flavor == 'mac':
+  if host_flavor == 'mac':
     flock_command = './gyp-mac-tool flock'
     header_params.update({
         'flock': flock_command,
         'flock_index': 2,
+    })
+  elif host_flavor == 'solaris':
+    flock_command = './gyp-sun-tool flock',
+    header_params.update({
+        'flock': flock_command,
+        'flock_index': 2,
+    })
+  elif host_flavor == 'freebsd':
+    flock_command = 'lockf',
+    header_params.update({
+        'flock': flock_command,
+    })
+
+  if flavor == 'mac':
+    header_params.update({
         'link_commands': LINK_COMMANDS_MAC,
         'extra_commands': SHARED_HEADER_MAC_COMMANDS,
     })
   elif flavor == 'android':
     header_params.update({
         'link_commands': LINK_COMMANDS_ANDROID,
     })
   elif flavor == 'solaris':
     header_params.update({
-        'flock': './gyp-sun-tool flock',
-        'flock_index': 2,
         'extra_commands': SHARED_HEADER_SUN_COMMANDS,
     })
-  elif flavor == 'freebsd':
-    header_params.update({
-        'flock': 'lockf',
-    })
+
   header_params.update(RunSystemTests(flavor))
 
   build_file, _, _ = gyp.common.ParseQualifiedTarget(target_list[0])
   make_global_settings_dict = data[build_file].get('make_global_settings', {})
   make_global_settings = ''
   for key, value in make_global_settings_dict:
     if value[0] != '$':
       value = '$(abspath %s)' % value
     if key == 'LINK':
       make_global_settings += ('%s ?= %s $(builddir)/linker.lock %s\n' %
                                (key, flock_command, value))
-    elif key in ['CC', 'CXX']:
+    elif key in ['CC', 'CXX', 'AR', 'LD', 'RANLIB']:

[Torne, 2012/08/14 11:04:01]

This still doesn't make any sense. AR should probably be added because that's
actually referred to by the generated makefiles but LD and RANLIB are never
referred to in any gyp files or any part of gyp. This logic doesn't even apply
unless the variables are set in make_global_settings.

       make_global_settings += (
           'ifneq (,$(filter $(origin %s), undefined default))\n' % key)
       # Let gyp-time envvars win over global settings.
       if key in os.environ:
         value = os.environ[key]
       make_global_settings += '  %s = %s\n' % (key, value)
       make_global_settings += 'endif\n'
     else:
       make_global_settings += '%s ?= %s\n' % (key, value)
   header_params['make_global_settings'] = make_global_settings
 
   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)
     WriteRootHeaderSuffixRules(root_makefile)
 
   # Put build-time support tools next to the root Makefile.
   dest_path = os.path.dirname(makefile_path)
-  gyp.common.CopyTool(flavor, dest_path)
+  gyp.common.CopyTool(host_flavor, dest_path)
 
   # 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)
 
   build_files = set()
   include_list = set()
   for qualified_target in target_list:
@@ skipping 76 matching lines @@
     root_makefile.write("  include " + include_file + "\n")
     root_makefile.write("endif\n")
   root_makefile.write('\n')
 
   if generator_flags.get('auto_regeneration', True):
     WriteAutoRegenerationRule(params, root_makefile, makefile_name, build_files)
 
   root_makefile.write(SHARED_FOOTER)
 
   root_makefile.close()