make: don't use .target in paths or printouts

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 16 matching lines @@
 import os
 import re
 import sys
 
 generator_default_variables = {
   'EXECUTABLE_PREFIX': '',
   'EXECUTABLE_SUFFIX': '',
   'STATIC_LIB_PREFIX': 'lib',
   'SHARED_LIB_PREFIX': 'lib',
   'STATIC_LIB_SUFFIX': '.a',
-  'INTERMEDIATE_DIR': '$(obj).$(TOOLSET)/$(TARGET)/geni',
+  'INTERMEDIATE_DIR': '$(obj)$(TOOLSET)/$(TARGET)/geni',
   'SHARED_INTERMEDIATE_DIR': '$(obj)/gen',
   'PRODUCT_DIR': '$(builddir)',
   'RULE_INPUT_ROOT': '%(INPUT_ROOT)s',  # This gets expanded by Python.
   'RULE_INPUT_DIRNAME': '%(INPUT_DIRNAME)s',  # This gets expanded by Python.
   'RULE_INPUT_PATH': '$(abspath $<)',
   'RULE_INPUT_EXT': '$(suffix $<)',
   'RULE_INPUT_NAME': '$(notdir $<)',
 
   # This appears unused --- ?
   'CONFIGURATION_NAME': '$(BUILDTYPE)',
@@ skipping 31 matching lines @@
     generator_extra_sources_for_rules = getattr(xcode_generator,
         'generator_extra_sources_for_rules', [])
     global COMPILABLE_EXTENSIONS
     COMPILABLE_EXTENSIONS.update({'.m': 'objc', '.mm' : 'objcxx'})
   else:
     operating_system = flavor
     if flavor == 'android':
       operating_system = 'linux'  # Keep this legacy behavior for now.
     default_variables.setdefault('OS', operating_system)
     default_variables.setdefault('SHARED_LIB_SUFFIX', '.so')
-    default_variables.setdefault('SHARED_LIB_DIR','$(builddir)/lib.$(TOOLSET)')
-    default_variables.setdefault('LIB_DIR', '$(obj).$(TOOLSET)')
+    default_variables.setdefault('SHARED_LIB_DIR','$(builddir)/lib$(TOOLSET)')
+    default_variables.setdefault('LIB_DIR', '$(obj)$(TOOLSET)')
 
 
 def CalculateGeneratorInputInfo(params):
   """Calculate the generator specific info that gets fed to input (called by
   gyp)."""
   generator_flags = params.get('generator_flags', {})
   android_ndk_version = generator_flags.get('android_ndk_version', None)
   # Android NDK requires a strict link order.
   if android_ndk_version:
     global generator_wants_sorted_dependencies
@@ skipping 13 matching lines @@
 # correctly, the .d files have spaces replaced with another character. The .d
 # file for
 #     Chromium\ Framework.framework/foo
 # is for example
 #     out/Release/.deps/out/Release/Chromium?Framework.framework/foo
 # This is the replacement character.
 SPACE_REPLACEMENT = '?'
 
 
 LINK_COMMANDS_LINUX = """\
-quiet_cmd_alink = AR($(TOOLSET)) $@
-cmd_alink = rm -f $@ && $(AR.$(TOOLSET)) crs $@ $(filter %.o,$^)
+quiet_cmd_alink = AR$(QUIET_TOOLSET) $@
+cmd_alink = rm -f $@ && $(AR$(TOOLSET)) crs $@ $(filter %.o,$^)
 
 # Due to circular dependencies between libraries :(, we wrap the
 # special "figure out circular dependencies" flags around the entire
 # input list during linking.
-quiet_cmd_link = LINK($(TOOLSET)) $@
-cmd_link = $(LINK.$(TOOLSET)) $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ -Wl,--start-group $(LD_INPUTS) -Wl,--end-group $(LIBS)
+quiet_cmd_link = LINK$(QUIET_TOOLSET) $@
+cmd_link = $(LINK$(TOOLSET)) $(GYP_LDFLAGS) $(LDFLAGS$(TOOLSET)) -o $@ -Wl,--start-group $(LD_INPUTS) -Wl,--end-group $(LIBS)
 
 # We support two kinds of shared objects (.so):
 # 1) shared_library, which is just bundling together many dependent libraries
 # into a link line.
 # 2) loadable_module, which is generating a module intended for dlopen().
 #
 # They differ only slightly:
 # In the former case, we want to package all dependent code into the .so.
 # In the latter case, we want to package just the API exposed by the
 # outermost module.
 # This means shared_library uses --whole-archive, while loadable_module doesn't.
 # (Note that --whole-archive is incompatible with the --start-group used in
 # normal linking.)
 
 # Other shared-object link notes:
 # - Set SONAME to the library filename so our binaries don't reference
 # the local, absolute paths used on the link command-line.
-quiet_cmd_solink = SOLINK($(TOOLSET)) $@
-cmd_solink = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -Wl,-soname=$(@F) -o $@ -Wl,--whole-archive $(LD_INPUTS) -Wl,--no-whole-archive $(LIBS)
+quiet_cmd_solink = SOLINK$(QUIET_TOOLSET) $@
+cmd_solink = $(LINK$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS$(TOOLSET)) -Wl,-soname=$(@F) -o $@ -Wl,--whole-archive $(LD_INPUTS) -Wl,--no-whole-archive $(LIBS)
 
-quiet_cmd_solink_module = SOLINK_MODULE($(TOOLSET)) $@
-cmd_solink_module = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -Wl,-soname=$(@F) -o $@ -Wl,--start-group $(filter-out FORCE_DO_CMD, $^) -Wl,--end-group $(LIBS)
+quiet_cmd_solink_module = SOLINK_MODULE$(QUIET_TOOLSET) $@
+cmd_solink_module = $(LINK$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS$(TOOLSET)) -Wl,-soname=$(@F) -o $@ -Wl,--start-group $(filter-out FORCE_DO_CMD, $^) -Wl,--end-group $(LIBS)
 """
 
 LINK_COMMANDS_MAC = """\
 quiet_cmd_alink = LIBTOOL-STATIC $@
 cmd_alink = rm -f $@ && ./gyp-mac-tool filter-libtool libtool -static -o $@ $(filter %.o,$^)
 
-quiet_cmd_link = LINK($(TOOLSET)) $@
-cmd_link = $(LINK.$(TOOLSET)) $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o "$@" $(LD_INPUTS) $(LIBS)
+quiet_cmd_link = LINK$(QUIET_TOOLSET) $@
+cmd_link = $(LINK$(TOOLSET)) $(GYP_LDFLAGS) $(LDFLAGS$(TOOLSET)) -o "$@" $(LD_INPUTS) $(LIBS)
 
 # TODO(thakis): Find out and document the difference between shared_library and
 # loadable_module on mac.
-quiet_cmd_solink = SOLINK($(TOOLSET)) $@
-cmd_solink = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o "$@" $(LD_INPUTS) $(LIBS)
+quiet_cmd_solink = SOLINK$(QUIET_TOOLSET) $@
+cmd_solink = $(LINK$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS$(TOOLSET)) -o "$@" $(LD_INPUTS) $(LIBS)
 
 # TODO(thakis): The solink_module rule is likely wrong. Xcode seems to pass
 # -bundle -single_module here (for osmesa.so).
-quiet_cmd_solink_module = SOLINK_MODULE($(TOOLSET)) $@
-cmd_solink_module = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ $(filter-out FORCE_DO_CMD, $^) $(LIBS)
+quiet_cmd_solink_module = SOLINK_MODULE$(QUIET_TOOLSET) $@
+cmd_solink_module = $(LINK$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS$(TOOLSET)) -o $@ $(filter-out FORCE_DO_CMD, $^) $(LIBS)
 """
 
 LINK_COMMANDS_ANDROID = """\
-quiet_cmd_alink = AR($(TOOLSET)) $@
-cmd_alink = rm -f $@ && $(AR.$(TOOLSET)) crs $@ $(filter %.o,$^)
+quiet_cmd_alink = AR$(QUIET_TOOLSET) $@
+cmd_alink = rm -f $@ && $(AR$(TOOLSET)) crs $@ $(filter %.o,$^)
 
 # Due to circular dependencies between libraries :(, we wrap the
 # special "figure out circular dependencies" flags around the entire
 # input list during linking.
-quiet_cmd_link = LINK($(TOOLSET)) $@
-quiet_cmd_link_host = LINK($(TOOLSET)) $@
-cmd_link = $(LINK.$(TOOLSET)) $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ -Wl,--start-group $(LD_INPUTS) -Wl,--end-group $(LIBS)
-cmd_link_host = $(LINK.$(TOOLSET)) $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ $(LD_INPUTS) $(LIBS)
+quiet_cmd_link = LINK$(QUIET_TOOLSET) $@
+quiet_cmd_link_host = LINK$(QUIET_TOOLSET) $@
+cmd_link = $(LINK$(TOOLSET)) $(GYP_LDFLAGS) $(LDFLAGS$(TOOLSET)) -o $@ -Wl,--start-group $(LD_INPUTS) -Wl,--end-group $(LIBS)
+cmd_link_host = $(LINK$(TOOLSET)) $(GYP_LDFLAGS) $(LDFLAGS$(TOOLSET)) -o $@ $(LD_INPUTS) $(LIBS)
 
 # Other shared-object link notes:
 # - Set SONAME to the library filename so our binaries don't reference
 # the local, absolute paths used on the link command-line.
-quiet_cmd_solink = SOLINK($(TOOLSET)) $@
-cmd_solink = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -Wl,-soname=$(@F) -o $@ -Wl,--whole-archive $(LD_INPUTS) -Wl,--no-whole-archive $(LIBS)
+quiet_cmd_solink = SOLINK$(QUIET_TOOLSET) $@
+cmd_solink = $(LINK$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS$(TOOLSET)) -Wl,-soname=$(@F) -o $@ -Wl,--whole-archive $(LD_INPUTS) -Wl,--no-whole-archive $(LIBS)
 
-quiet_cmd_solink_module = SOLINK_MODULE($(TOOLSET)) $@
-cmd_solink_module = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -Wl,-soname=$(@F) -o $@ -Wl,--start-group $(filter-out FORCE_DO_CMD, $^) -Wl,--end-group $(LIBS)
-quiet_cmd_solink_module_host = SOLINK_MODULE($(TOOLSET)) $@
-cmd_solink_module_host = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -Wl,-soname=$(@F) -o $@ $(filter-out FORCE_DO_CMD, $^) $(LIBS)
+quiet_cmd_solink_module = SOLINK_MODULE$(QUIET_TOOLSET) $@
+cmd_solink_module = $(LINK$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS$(TOOLSET)) -Wl,-soname=$(@F) -o $@ -Wl,--start-group $(filter-out FORCE_DO_CMD, $^) -Wl,--end-group $(LIBS)
+quiet_cmd_solink_module_host = SOLINK_MODULE$(QUIET_TOOLSET) $@
+cmd_solink_module_host = $(LINK$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS$(TOOLSET)) -Wl,-soname=$(@F) -o $@ $(filter-out FORCE_DO_CMD, $^) $(LIBS)
 """
 
 
 # Header of toplevel Makefile.
 # This should go into the build tree, but it's easier to keep it here for now.
 SHARED_HEADER = ("""\
 # We borrow heavily from the kernel build setup, though we are simpler since
 # we don't have Kconfig tweaking settings on us.
 
 # The implicit make rules have it looking for RCS files, among other things.
@@ skipping 118 matching lines @@
   sed -e 1d -e 's|$$|:|'                     \
     >> $(depfile)
 rm $(depfile).raw
 endef
 """
 """
 # Command definitions:
 # - cmd_foo is the actual command to run;
 # - quiet_cmd_foo is the brief-output summary of the command.
 
-quiet_cmd_cc = CC($(TOOLSET)) $@
-cmd_cc = $(CC.$(TOOLSET)) $(GYP_CFLAGS) $(DEPFLAGS) $(CFLAGS.$(TOOLSET)) -c -o $@ $<
+quiet_cmd_cc = CC$(QUIET_TOOLSET) $@
+cmd_cc = $(CC$(TOOLSET)) $(GYP_CFLAGS) $(DEPFLAGS) $(CFLAGS$(TOOLSET)) -c -o $@ $<
 
-quiet_cmd_cxx = CXX($(TOOLSET)) $@
-cmd_cxx = $(CXX.$(TOOLSET)) $(GYP_CXXFLAGS) $(DEPFLAGS) $(CXXFLAGS.$(TOOLSET)) -c -o $@ $<
+quiet_cmd_cxx = CXX$(QUIET_TOOLSET) $@
+cmd_cxx = $(CXX$(TOOLSET)) $(GYP_CXXFLAGS) $(DEPFLAGS) $(CXXFLAGS$(TOOLSET)) -c -o $@ $<
 %(extra_commands)s
 quiet_cmd_touch = TOUCH $@
 cmd_touch = touch $@
 
 quiet_cmd_copy = COPY $@
 # send stderr to /dev/null to ignore messages when linking directories.
 cmd_copy = ln -f "$<" "$@" 2>/dev/null || (rm -rf "$@" && cp -af "$<" "$@")
 
 %(link_commands)s
 """
@@ skipping 85 matching lines @@
 %(default_target)s:
 
 # Use FORCE_DO_CMD to force a target to run.  Should be coupled with
 # do_cmd.
 .PHONY: FORCE_DO_CMD
 FORCE_DO_CMD:
 
 """)
 
 SHARED_HEADER_MAC_COMMANDS = """
-quiet_cmd_objc = CXX($(TOOLSET)) $@
-cmd_objc = $(CC.$(TOOLSET)) $(GYP_OBJCFLAGS) $(DEPFLAGS) -c -o $@ $<
+quiet_cmd_objc = CXX$(QUIET_TOOLSET) $@
+cmd_objc = $(CC$(TOOLSET)) $(GYP_OBJCFLAGS) $(DEPFLAGS) -c -o $@ $<
 
-quiet_cmd_objcxx = CXX($(TOOLSET)) $@
-cmd_objcxx = $(CXX.$(TOOLSET)) $(GYP_OBJCXXFLAGS) $(DEPFLAGS) -c -o $@ $<
+quiet_cmd_objcxx = CXX$(QUIET_TOOLSET) $@
+cmd_objcxx = $(CXX$(TOOLSET)) $(GYP_OBJCXXFLAGS) $(DEPFLAGS) -c -o $@ $<
 
 # Commands for precompiled header files.
-quiet_cmd_pch_c = CXX($(TOOLSET)) $@
-cmd_pch_c = $(CC.$(TOOLSET)) $(GYP_PCH_CFLAGS) $(DEPFLAGS) $(CXXFLAGS.$(TOOLSET)) -c -o $@ $<
-quiet_cmd_pch_cc = CXX($(TOOLSET)) $@
-cmd_pch_cc = $(CC.$(TOOLSET)) $(GYP_PCH_CXXFLAGS) $(DEPFLAGS) $(CXXFLAGS.$(TOOLSET)) -c -o $@ $<
-quiet_cmd_pch_m = CXX($(TOOLSET)) $@
-cmd_pch_m = $(CC.$(TOOLSET)) $(GYP_PCH_OBJCFLAGS) $(DEPFLAGS) -c -o $@ $<
-quiet_cmd_pch_mm = CXX($(TOOLSET)) $@
-cmd_pch_mm = $(CC.$(TOOLSET)) $(GYP_PCH_OBJCXXFLAGS) $(DEPFLAGS) -c -o $@ $<
+quiet_cmd_pch_c = CXX$(QUIET_TOOLSET) $@
+cmd_pch_c = $(CC$(TOOLSET)) $(GYP_PCH_CFLAGS) $(DEPFLAGS) $(CXXFLAGS$(TOOLSET)) -c -o $@ $<
+quiet_cmd_pch_cc = CXX$(QUIET_TOOLSET) $@
+cmd_pch_cc = $(CC$(TOOLSET)) $(GYP_PCH_CXXFLAGS) $(DEPFLAGS) $(CXXFLAGS$(TOOLSET)) -c -o $@ $<
+quiet_cmd_pch_m = CXX$(QUIET_TOOLSET) $@
+cmd_pch_m = $(CC$(TOOLSET)) $(GYP_PCH_OBJCFLAGS) $(DEPFLAGS) -c -o $@ $<
+quiet_cmd_pch_mm = CXX$(QUIET_TOOLSET) $@
+cmd_pch_mm = $(CC$(TOOLSET)) $(GYP_PCH_OBJCXXFLAGS) $(DEPFLAGS) -c -o $@ $<
 
 # gyp-mac-tool is written next to the root Makefile by gyp.
 # Use $(4) for the command, since $(2) and $(3) are used as flag by do_cmd
 # already.
 quiet_cmd_mac_tool = MACTOOL $(4) $<
 cmd_mac_tool = ./gyp-mac-tool $(4) $< "$@"
 
 quiet_cmd_mac_package_framework = PACKAGE FRAMEWORK $@
 cmd_mac_package_framework = ./gyp-mac-tool package-framework "$@" $(4)
 
 quiet_cmd_infoplist = INFOPLIST $@
-cmd_infoplist = $(CC.$(TOOLSET)) -E -P -Wno-trigraphs -x c $(INFOPLIST_DEFINES) "$<" -o "$@"
+cmd_infoplist = $(CC$(TOOLSET)) -E -P -Wno-trigraphs -x c $(INFOPLIST_DEFINES) "$<" -o "$@"
 """
 
 SHARED_HEADER_SUN_COMMANDS = """
 # gyp-sun-tool is written next to the root Makefile by gyp.
 # Use $(4) for the command, since $(2) and $(3) are used as flag by do_cmd
 # already.
 quiet_cmd_sun_tool = SUNTOOL $(4) $<
 cmd_sun_tool = ./gyp-sun-tool $(4) $< "$@"
 """
 
 
 def WriteRootHeaderSuffixRules(writer):
   extensions = sorted(COMPILABLE_EXTENSIONS.keys(), key=str.lower)
 
   writer.write('# Suffix rules, putting all outputs into $(obj).\n')
   for ext in extensions:
-    writer.write('$(obj).$(TOOLSET)/%%.o: $(srcdir)/%%%s FORCE_DO_CMD\n' % ext)
+    writer.write('$(obj)$(TOOLSET)/%%.o: $(srcdir)/%%%s FORCE_DO_CMD\n' % ext)
     writer.write('\t@$(call do_cmd,%s,1)\n' % COMPILABLE_EXTENSIONS[ext])
 
   writer.write('\n# Try building from generated source, too.\n')
   for ext in extensions:
     writer.write(
-        '$(obj).$(TOOLSET)/%%.o: $(obj).$(TOOLSET)/%%%s FORCE_DO_CMD\n' % ext)
+        '$(obj)$(TOOLSET)/%%.o: $(obj)$(TOOLSET)/%%%s FORCE_DO_CMD\n' % ext)
     writer.write('\t@$(call do_cmd,%s,1)\n' % COMPILABLE_EXTENSIONS[ext])
   writer.write('\n')
   for ext in extensions:
-    writer.write('$(obj).$(TOOLSET)/%%.o: $(obj)/%%%s FORCE_DO_CMD\n' % ext)
+    writer.write('$(obj)$(TOOLSET)/%%.o: $(obj)/%%%s FORCE_DO_CMD\n' % ext)
     writer.write('\t@$(call do_cmd,%s,1)\n' % COMPILABLE_EXTENSIONS[ext])
   writer.write('\n')
 
 
 SHARED_HEADER_SUFFIX_RULES_COMMENT1 = ("""\
 # Suffix rules, putting all outputs into $(obj).
 """)
 
 
 SHARED_HEADER_SUFFIX_RULES_COMMENT2 = ("""\
@@ skipping 129 matching lines @@
     self._num_outputs = 0
 
     self.suffix_rules_srcdir = {}
     self.suffix_rules_objdir1 = {}
     self.suffix_rules_objdir2 = {}
 
     # Generate suffix rules for all compilable extensions.
     for ext in COMPILABLE_EXTENSIONS.keys():
       # Suffix rules for source folder.
       self.suffix_rules_srcdir.update({ext: ("""\
-$(obj).$(TOOLSET)/$(TARGET)/%%.o: $(srcdir)/%%%s FORCE_DO_CMD
+$(obj)$(TOOLSET)/$(TARGET)/%%.o: $(srcdir)/%%%s FORCE_DO_CMD
         @$(call do_cmd,%s,1)
 """ % (ext, COMPILABLE_EXTENSIONS[ext]))})
 
       # Suffix rules for generated source files.
       self.suffix_rules_objdir1.update({ext: ("""\
-$(obj).$(TOOLSET)/$(TARGET)/%%.o: $(obj).$(TOOLSET)/%%%s FORCE_DO_CMD
+$(obj)$(TOOLSET)/$(TARGET)/%%.o: $(obj)$(TOOLSET)/%%%s FORCE_DO_CMD
         @$(call do_cmd,%s,1)
 """ % (ext, COMPILABLE_EXTENSIONS[ext]))})
       self.suffix_rules_objdir2.update({ext: ("""\
-$(obj).$(TOOLSET)/$(TARGET)/%%.o: $(obj)/%%%s FORCE_DO_CMD
+$(obj)$(TOOLSET)/$(TARGET)/%%.o: $(obj)/%%%s FORCE_DO_CMD
         @$(call do_cmd,%s,1)
 """ % (ext, COMPILABLE_EXTENSIONS[ext]))})
 
 
   def NumOutputs(self):
     return self._num_outputs
 
 
   def Write(self, qualified_target, base_path, output_filename, spec, configs,
             part_of_all):
@@ skipping 43 matching lines @@
 
     self._INSTALLABLE_TARGETS = ('executable', 'loadable_module',
                                  'shared_library')
     if self.type in self._INSTALLABLE_TARGETS:
       self.alias = os.path.basename(self.output)
       install_path = self._InstallableTargetInstallPath()
     else:
       self.alias = self.output
       install_path = self.output
 
-    self.WriteLn("TOOLSET := " + self.toolset)
+    if self.toolset == 'target':
+      self.WriteLn("QUIET_TOOLSET :=")
+      self.WriteLn("TOOLSET :=")
+    else:
+      self.WriteLn("QUIET_TOOLSET := (%s)" % self.toolset)
+      self.WriteLn("TOOLSET := %s" % self._ToolsetSuffix())
     self.WriteLn("TARGET := " + self.target)
 
     # Actions must come first, since they can generate more OBJs for use below.
     if 'actions' in spec:
       self.WriteActions(spec['actions'], extra_sources, extra_outputs,
                         extra_mac_bundle_resources, part_of_all)
 
     # Rules must be early like actions.
     if 'rules' in spec:
       self.WriteRules(spec['rules'], extra_sources, extra_outputs,
@@ skipping 347 matching lines @@
 
   def WriteMacInfoPlist(self, bundle_deps):
     """Write Makefile code for bundle Info.plist files."""
     info_plist, out, defines, extra_env = gyp.xcode_emulation.GetMacInfoPlist(
         generator_default_variables['PRODUCT_DIR'], self.xcode_settings,
         self.Absolutify)
     if not info_plist:
       return
     if defines:
       # Create an intermediate file to store preprocessed results.
-      intermediate_plist = ('$(obj).$(TOOLSET)/$(TARGET)/' +
+      intermediate_plist = ('$(obj)$(TOOLSET)/$(TARGET)/' +
           os.path.basename(info_plist))
       self.WriteList(defines, intermediate_plist + ': INFOPLIST_DEFINES', '-D',
           quoter=EscapeCppDefine)
       self.WriteMakeRule([intermediate_plist], [info_plist],
           ['$(call do_cmd,infoplist)',
            # "Convert" the plist so that any weird whitespace changes from the
            # preprocessor do not affect the XML parser in mac_tool.
            '@plutil -convert xml1 $@ $@'])
       info_plist = intermediate_plist
     # plists can contain envvars and substitute them into the file.
@@ skipping 207 matching lines @@
 
 
   def ComputeOutput(self, spec):
     """Return the 'output' (full output path) of a gyp spec.
 
     E.g., the loadable module 'foobar' in directory 'baz' will produce
       '$(obj)/baz/libfoobar.so'
     """
     assert not self.is_mac_bundle
 
-    path = os.path.join('$(obj).' + self.toolset, self.path)
+    path = os.path.join('$(obj)' + self._ToolsetSuffix(), self.path)
     if self.type == 'executable' or self._InstallImmediately():
       path = '$(builddir)'
     path = spec.get('product_dir', path)
     return os.path.join(path, self.ComputeOutputBasename(spec))
 
 
   def ComputeMacBundleOutput(self, spec):
     """Return the 'output' (full output path) to a bundle output directory."""
     assert self.is_mac_bundle
     path = generator_default_variables['PRODUCT_DIR']
@@ skipping 68 matching lines @@
               QuoteSpaces(self.output),
               QuoteSpaces(self.output_binary))
           if target_postbuild:
             target_postbuilds[configname] = target_postbuild
         else:
           ldflags = config.get('ldflags', [])
           # Compute an rpath for this output if needed.
           if any(dep.endswith('.so') for dep in deps):
             # We want to get the literal string "$ORIGIN" into the link command,
             # so we need lots of escaping.
-            ldflags.append(r'-Wl,-rpath=\$$ORIGIN/lib.%s/' % self.toolset)
-            ldflags.append(r'-Wl,-rpath-link=\$(builddir)/lib.%s/' %
-                           self.toolset)
+            ldflags.append(r'-Wl,-rpath=\$$ORIGIN/lib%s/' % self._ToolsetSuffix())
+            ldflags.append(r'-Wl,-rpath-link=\$(builddir)/lib%s/' %
+                           self._ToolsetSuffix())
         self.WriteList(ldflags, 'LDFLAGS_%s' % configname)
       libraries = spec.get('libraries')
       if libraries:
         # Remove duplicate entries
         libraries = gyp.common.uniquer(libraries)
         if self.flavor == 'mac':
           libraries = self.xcode_settings.AdjustLibraries(libraries)
       self.WriteList(libraries, 'LIBS')
       self.WriteLn('%s: GYP_LDFLAGS := $(LDFLAGS_$(BUILDTYPE))' %
           QuoteSpaces(self.output_binary))
@@ skipping 373 matching lines @@
       # the escaped space does the right thing. For
       #  export foo := a\ b
       # it does not -- the backslash is written to the env as literal character.
       # So don't escape spaces in |env[k]|.
       self.WriteLn('%s: export %s := %s' % (QuoteSpaces(target), k, env[k]))
 
 
   def Objectify(self, path):
     """Convert a path to its output directory form."""
     if '$(' in path:
-      path = path.replace('$(obj)/', '$(obj).%s/$(TARGET)/' % self.toolset)
+      path = path.replace('$(obj)/', '$(obj)%s/$(TARGET)/' % self._ToolsetSuffix())

[Nico, 2012/02/16 20:30:08]

80 COLS!!!!!!!!!!!!

       return path
-    return '$(obj).%s/$(TARGET)/%s' % (self.toolset, path)
+    return '$(obj)%s/$(TARGET)/%s' % (self._ToolsetSuffix(), path)
 
 
   def Pchify(self, path, lang):
     """Convert a prefix header path to its output directory form."""
     path = self.Absolutify(path)
     if '$(' in path:
-      path = path.replace('$(obj)/', '$(obj).%s/$(TARGET)/pch-%s' %
-                          (self.toolset, lang))
+      path = path.replace('$(obj)/', '$(obj)%s/$(TARGET)/pch-%s' %
+                          (self._ToolsetSuffix(), lang))
       return path
-    return '$(obj).%s/$(TARGET)/pch-%s/%s' % (self.toolset, lang, path)
+    return '$(obj)%s/$(TARGET)/pch-%s/%s' % (self._ToolsetSuffix(), lang, path)
 
 
   def Absolutify(self, path):
     """Convert a subdirectory-relative path into a base-relative path.
     Skips over paths that contain variables."""
     if '$(' in path:
       # path is no existing file in this case, but calling normpath is still
       # important for trimming trailing slashes.
       return os.path.normpath(path)
     return os.path.normpath(os.path.join(self.path, path))
@@ skipping 15 matching lines @@
     return path
 
 
   def _InstallableTargetInstallPath(self):
     """Returns the location of the final output for an installable target."""
     # Xcode puts shared_library results into PRODUCT_DIR, and some gyp files
     # rely on this. Emulate this behavior for mac.
     if self.type == 'shared_library' and self.flavor != 'mac':
       # Install all shared libs into a common directory (per toolset) for
       # convenient access with LD_LIBRARY_PATH.
-      return '$(builddir)/lib.%s/%s' % (self.toolset, self.alias)
+      return '$(builddir)/lib%s/%s' % (self._ToolsetSuffix(), self.alias)
     return '$(builddir)/' + self.alias
 
+  def _ToolsetSuffix(self):
+    """Return a suffix suitable for a path that is unique to the current
+    toolset."""
+    assert self.toolset  # 'target' maps to '', so don't allow '' as input.

[Nico, 2012/02/16 20:30:08]

s/#/, "/ maybe 

+    if self.toolset == 'target':
+      return ''
+    return '.' + self.toolset
 
 def WriteAutoRegenerationRule(params, root_makefile, makefile_name,
                               build_files):
   """Write the target to regenerate the Makefile."""
   options = params['options']
   build_files_args = [gyp.common.RelativePath(filename, options.toplevel_dir)
                       for filename in params['build_files_arg']]
   gyp_binary = gyp.common.FixIfRelativePath(params['gyp_binary'],
                                             options.toplevel_dir)
   if not gyp_binary.startswith(os.sep):
@@ skipping 236 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()