Honor $CC/$CC_host and friends in make generator.

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 42 matching lines @@
 generator_wants_sorted_dependencies = False
 
 # 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)
   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
@@ skipping 174 matching lines @@
 #
 # Note: flock is used to seralize linking. Linking is a memory-intensive
 # process so running parallel links can often lead to thrashing.  To disable
 # the serialization, override LINK via an envrionment variable as follows:
 #
 #   export LINK=g++
 #
 # This will allow make to invoke N linker processes as specified in -jN.
 LINK ?= %(flock)s $(builddir)/linker.lock $(CXX)
 
-CC.target ?= $(CC)
+CC.target ?= %(CC.target)s
 CFLAGS.target ?= $(CFLAGS)
-CXX.target ?= $(CXX)
+CXX.target ?= %(CXX.target)s
 CXXFLAGS.target ?= $(CXXFLAGS)
-LINK.target ?= $(LINK)
+LINK.target ?= %(LINK.target)s
 LDFLAGS.target ?= $(LDFLAGS)
 AR.target ?= $(AR)
 ARFLAGS.target ?= %(ARFLAGS.target)s
 
 # N.B.: the logic of which commands to run should match the computation done
 # in gyp's make.py where ARFLAGS.host etc. is computed.
 # TODO(evan): move all cross-compilation logic to gyp-time so we don't need
 # to replicate this environment fallback in make as well.
-CC.host ?= gcc
+CC.host ?= %(CC.host)s
 CFLAGS.host ?=
-CXX.host ?= g++
+CXX.host ?= %(CXX.host)s
 CXXFLAGS.host ?=
-LINK.host ?= g++
+LINK.host ?= %(LINK.host)s
 LDFLAGS.host ?=
-AR.host ?= ar
+AR.host ?= %(AR.host)s
 ARFLAGS.host := %(ARFLAGS.host)s
 
 # Define a dir function that can handle spaces.
 # http://www.gnu.org/software/make/manual/make.html#Syntax-of-Functions
 # "leading spaces cannot appear in the text of the first argument as written.
 # These characters can be put into the argument value by variable substitution."
 empty :=
 space := $(empty) $(empty)
 
 # http://stackoverflow.com/questions/1189781/using-make-dir-or-notdir-on-a-path-with-spaces
@@ skipping 1597 matching lines @@
   """Run tests against the system to compute default settings for commands.
 
   Returns:
     dictionary of settings matching the block of command-lines used in
     SHARED_HEADER.  E.g. the dictionary will contain a ARFLAGS.target
     key for the default ARFLAGS for the target ar command.
   """
   # Compute flags used for building static archives.
   # N.B.: this fallback logic should match the logic in SHARED_HEADER.
   # See comment there for more details.
-  ar_target = os.environ.get('AR.target', os.environ.get('AR', 'ar'))
-  cc_target = os.environ.get('CC.target', os.environ.get('CC', 'cc'))
+  ar_target = GetEnv(('AR_target', 'AR'), 'ar')
+  cc_target = GetEnv(('CC_target', 'CC'), 'cc')
   arflags_target = 'crs'
   # ar -T enables thin archives on Linux. OS X's ar supports a -T flag, but it
   # does something useless (it limits filenames in the archive to 15 chars).
   if flavor != 'mac' and gyp.system_test.TestArSupportsT(ar_command=ar_target,
                                                          cc_command=cc_target):
     arflags_target = 'crsT'
 
-  ar_host = os.environ.get('AR.host', 'ar')
-  cc_host = os.environ.get('CC.host', 'gcc')
+  ar_host = os.environ.get('AR_host', 'ar')
+  cc_host = os.environ.get('CC_host', 'gcc')
   arflags_host = 'crs'
   # It feels redundant to compute this again given that most builds aren't
-  # cross-compiles, but due to quirks of history CC.host defaults to 'gcc'
-  # while CC.target defaults to 'cc', so the commands really are different
+  # cross-compiles, but due to quirks of history CC_host defaults to 'gcc'
+  # while CC_target defaults to 'cc', so the commands really are different
   # even though they're nearly guaranteed to run the same code underneath.
   if flavor != 'mac' and gyp.system_test.TestArSupportsT(ar_command=ar_host,
                                                          cc_command=cc_host):
     arflags_host = 'crsT'
 
   return { 'ARFLAGS.target': arflags_target,
            'ARFLAGS.host': arflags_host }
 
 
+def GetEnv(possible_keys, default):
+  """Look up a key in the environment, falling back to a secondary key
+  and finally falling back to a default value."""
+  for key in possible_keys:
+    if key in os.environ:
+      return os.environ[key]
+
+  return default
+
 def GenerateOutput(target_list, target_dicts, data, params):
   options = params['options']
   flavor = gyp.common.GetFlavor(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."""
@@ skipping 59 matching lines @@
   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))
+  header_params.update({
+    'CC.target':   GetEnv(('CC_target', 'CC'), '$(CC)'),
+    'AR.target':   GetEnv(('AR_target', 'AR'), '$(AR)'),
+    'CXX.target':  GetEnv(('CXX_target', 'CXX'), '$(CXX)'),
+    'LINK.target': GetEnv(('LD_target', 'LD'), '$(LINK)'),

[Nico, 2012/08/08 21:26:08]

If I understood michaelbai right, the _target stuff in the ninja generator is
only there transitionally for now and will go away eventually. Do we have to add
it to make?

[Sam Clegg, 2012/08/10 00:43:58]

I will remove this.

+    'CC.host':     GetEnv(('CC_host',), 'gcc'),
+    'AR.host':     GetEnv(('AR_host',), 'ar'),
+    'CXX.host':    GetEnv(('CXX_host',), 'g++'),
+    'LINK.host':   GetEnv(('LD_host',), 'g++'),

[Nico, 2012/08/08 21:26:08]

This part is fine, but it's overridden by make_global_settings below. In the
ninja generator, stuff from the env now wins over compilers in
make_global_settings

+  })
 
   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))
@@ skipping 115 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()