Fix running actions and rules on make/mac

pylib/gyp/generator/make.py

 # Copyright (c) 2013 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 849 matching lines @@
       if len(dirs) > 0:
         command = 'mkdir -p %s' % ' '.join(dirs) + '; ' + command
 
       cd_action = 'cd %s; ' % Sourceify(self.path or '.')
 
       # command and cd_action get written to a toplevel variable called
       # cmd_foo. Toplevel variables can't handle things that change per
       # makefile like $(TARGET), so hardcode the target.
       command = command.replace('$(TARGET)', self.target)
       cd_action = cd_action.replace('$(TARGET)', self.target)
+      target_libraries_path = self._TargetLibrariesPath()
+      ld_library_path = self._LibraryPathVarName()
 
       # Set LD_LIBRARY_PATH in case the action runs an executable from this
       # build which links to shared libs from this build.
       # actions run on the host, so they should in theory only use host
       # libraries, but until everything is made cross-compile safe, also use
       # target libraries.
       # TODO(piman): when everything is cross-compile safe, remove lib.target
-      self.WriteLn('cmd_%s = LD_LIBRARY_PATH=$(builddir)/lib.host:'
-                   '$(builddir)/lib.target:$$LD_LIBRARY_PATH; '
-                   'export LD_LIBRARY_PATH; '
-                   '%s%s'
-                   % (name, cd_action, command))
+      self.WriteLn(
+          'cmd_%(name)s = %(ld_library_path)s=$(builddir)/lib.host:'
+          '%(target_libraries_path)s:$$%(ld_library_path)s; '
+          'export %(ld_library_path)s; '
+          '%(cd_action)s%(command)s' % {
+        'name': name,
+        'cd_action': cd_action,
+        'command': command,
+        'target_libraries_path': target_libraries_path,
+        'ld_library_path': ld_library_path})
       self.WriteLn()
       outputs = map(self.Absolutify, outputs)
       # The makefile rules are all relative to the top dir, but the gyp actions
       # are defined relative to their containing dir.  This replaces the obj
       # variable for the action rule with an absolute version so that the output
       # goes in the right place.
       # Only write the 'obj' and 'builddir' rules for the "primary" output (:1);
       # it's superfluous for the "extra outputs", and this avoids accidentally
       # writing duplicate dummy rules for those outputs.
       # Same for environment.
@@ skipping 108 matching lines @@
         # action, cd_action, and mkdirs get written to a toplevel variable
         # called cmd_foo. Toplevel variables can't handle things that change
         # per makefile like $(TARGET), so hardcode the target.
         if self.flavor == 'mac':
           action = [gyp.xcode_emulation.ExpandEnvVars(command, env)
                     for command in action]
         action = gyp.common.EncodePOSIXShellList(action)
         action = action.replace('$(TARGET)', self.target)
         cd_action = cd_action.replace('$(TARGET)', self.target)
         mkdirs = mkdirs.replace('$(TARGET)', self.target)
+        target_libraries_path = self._TargetLibrariesPath()
+        ld_library_path = self._LibraryPathVarName()
 
         # Set LD_LIBRARY_PATH in case the rule runs an executable from this
         # build which links to shared libs from this build.
         # rules run on the host, so they should in theory only use host
         # libraries, but until everything is made cross-compile safe, also use
         # target libraries.
         # TODO(piman): when everything is cross-compile safe, remove lib.target
         self.WriteLn(
-            "cmd_%(name)s_%(count)d = LD_LIBRARY_PATH="
-              "$(builddir)/lib.host:$(builddir)/lib.target:$$LD_LIBRARY_PATH; "
-              "export LD_LIBRARY_PATH; "
+            "cmd_%(name)s_%(count)d = %(ld_library_path)s="
+              "$(builddir)/lib.host:%(target_libraries_path)s:"
+              "$$%(ld_library_path)s; "
+              "export %(ld_library_path)s; "
               "%(cd_action)s%(mkdirs)s%(action)s" % {
           'action': action,
           'cd_action': cd_action,
           'count': count,
           'mkdirs': mkdirs,
           'name': name,
+          'target_libraries_path': target_libraries_path,
+          'ld_library_path': ld_library_path,
         })
         self.WriteLn(
             'quiet_cmd_%(name)s_%(count)d = RULE %(name)s_%(count)d $@' % {
           'count': count,
           'name': name,
         })
         self.WriteLn()
         count += 1
 
       outputs_variable = 'rule_%s_outputs' % name
@@ skipping 839 matching lines @@
     # 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' or self.toolset != 'target')):
       # 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)/' + self.alias
 
 
+  def _TargetLibrariesPath(self):
+    """Returns the path to shared libraries in the "target" toolset."""
+    if self.flavor == 'mac':
+       return '$(builddir)'
+    else:
+       return '$(builddir)/lib.target'
+
+  def _LibraryPathVarName(self):
+    """Returns the name of the environment variables for shared libraries."""
+    if self.flavor == 'mac':
+      return 'DYLD_LIBRARY_PATH'
+    else:
+      return 'LD_LIBRARY_PATH'
+
+
 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 254 matching lines @@
     root_makefile.write("endif\n")
   root_makefile.write('\n')
 
   if (not generator_flags.get('standalone')
       and generator_flags.get('auto_regeneration', True)):
     WriteAutoRegenerationRule(params, root_makefile, makefile_name, build_files)
 
   root_makefile.write(SHARED_FOOTER)
 
   root_makefile.close()