mac ninja/make: Do topological sort only once instead of at each access.

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 880 matching lines @@
       # 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.
       self.WriteLn("%s: obj := $(abs_obj)" % QuoteSpaces(outputs[0]))
       self.WriteLn("%s: builddir := $(abs_builddir)" % QuoteSpaces(outputs[0]))
-      self.WriteXcodeEnv(outputs[0], self.GetXcodeEnv())
+      self.WriteSortedXcodeEnv(outputs[0], self.GetSortedXcodeEnv())
 
       for input in inputs:
         assert ' ' not in input, (
             "Spaces in action input filenames not supported (%s)"  % input)
       for output in outputs:
         assert ' ' not in output, (
             "Spaces in action output filenames not supported (%s)"  % output)
 
       # See the comment in WriteCopies about expanding env vars.
-      env = self.GetXcodeEnv()
+      env = self.GetSortedXcodeEnv()
       outputs = [gyp.xcode_emulation.ExpandEnvVars(o, env) for o in outputs]
       inputs = [gyp.xcode_emulation.ExpandEnvVars(i, env) for i in inputs]
 
       self.WriteDoCmd(outputs, map(Sourceify, map(self.Absolutify, inputs)),
                       part_of_all=part_of_all, command=name)
 
       # Stuff the outputs in a variable so we can refer to them later.
       outputs_variable = 'action_%s_outputs' % name
       self.WriteLn('%s := %s' % (outputs_variable, ' '.join(outputs)))
       extra_outputs.append('$(%s)' % outputs_variable)
@@ skipping 140 matching lines @@
 
         # If the output path has variables in it, which happens in practice for
         # 'copies', writing the environment as target-local doesn't work,
         # because the variables are already needed for the target name.
         # Copying the environment variables into global make variables doesn't
         # work either, because then the .d files will potentially contain spaces
         # after variable expansion, and .d file handling cannot handle spaces.
         # As a workaround, manually expand variables at gyp time. Since 'copies'
         # can't run scripts, there's no need to write the env then.
         # WriteDoCmd() will escape spaces for .d files.
-        env = self.GetXcodeEnv()
+        env = self.GetSortedXcodeEnv()
         output = gyp.xcode_emulation.ExpandEnvVars(output, env)
         path = gyp.xcode_emulation.ExpandEnvVars(path, env)
         self.WriteDoCmd([output], [path], 'copy', part_of_all)
         outputs.append(output)
     self.WriteLn('%s = %s' % (variable, ' '.join(map(QuoteSpaces, outputs))))
     extra_outputs.append('$(%s)' % variable)
     self.WriteLn()
 
 
   def WriteMacBundleResources(self, resources, bundle_deps):
@@ skipping 21 matching lines @@
           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.
-    self.WriteXcodeEnv(out, self.GetXcodeEnv(additional_settings=extra_env))
+    self.WriteSortedXcodeEnv(
+        out, self.GetSortedXcodeEnv(additional_settings=extra_env))
     self.WriteDoCmd([out], [info_plist], 'mac_tool,,,copy-info-plist',
                     part_of_all=True)
     bundle_deps.append(out)
 
 
   def WriteSources(self, configs, deps, sources,
                    extra_outputs, extra_link_deps,
                    part_of_all, precompiled_header):
     """Write Makefile code for any 'sources' from the gyp input.
     These are source files necessary to build the current target.
@@ skipping 316 matching lines @@
     if self.flavor == 'mac':
       if target_postbuilds:
         postbuilds.append('$(TARGET_POSTBUILDS_$(BUILDTYPE))')
       postbuilds.extend(
           gyp.xcode_emulation.GetSpecPostbuildCommands(spec))
 
     if postbuilds:
       # Envvars may be referenced by TARGET_POSTBUILDS_$(BUILDTYPE),
       # so we must output its definition first, since we declare variables
       # using ":=".
-      self.WriteXcodeEnv(self.output, self.GetXcodePostbuildEnv())
+      self.WriteSortedXcodeEnv(self.output, self.GetSortedXcodePostbuildEnv())
 
       for configname in target_postbuilds:
         self.WriteLn('%s: TARGET_POSTBUILDS_%s := %s' %
             (QuoteSpaces(self.output),
              configname,
              gyp.common.EncodePOSIXShellList(target_postbuilds[configname])))
 
       # Postbuilds expect to be run in the gyp file's directory, so insert an
       # implicit postbuild to cd to there.
       postbuilds.insert(0, gyp.common.EncodePOSIXShellList(['cd', self.path]))
@@ skipping 314 matching lines @@
       self.WriteLn('include $(BUILD_SHARED_LIBRARY)')
     elif self.type == 'static_library':
       self.WriteLn('include $(BUILD_STATIC_LIBRARY)')
     self.WriteLn()
 
 
   def WriteLn(self, text=''):
     self.fp.write(text + '\n')
 
 
-  def GetXcodeEnv(self, additional_settings=None):
-    return gyp.xcode_emulation.GetXcodeEnv(
+  def GetSortedXcodeEnv(self, additional_settings=None):
+    return gyp.xcode_emulation.GetSortedXcodeEnv(
         self.xcode_settings, "$(abs_builddir)",
         os.path.join("$(abs_srcdir)", self.path), "$(BUILDTYPE)",
         additional_settings)
 
 
-  def GetXcodePostbuildEnv(self):
+  def GetSortedXcodePostbuildEnv(self):
     # CHROMIUM_STRIP_SAVE_FILE is a chromium-specific hack.
     # TODO(thakis): It would be nice to have some general mechanism instead.
     strip_save_file = self.xcode_settings.GetPerTargetSetting(
         'CHROMIUM_STRIP_SAVE_FILE', '')
     # Even if strip_save_file is empty, explicitly write it. Else a postbuild
     # might pick up an export from an earlier target.
-    return self.GetXcodeEnv(
+    return self.GetSortedXcodeEnv(
         additional_settings={'CHROMIUM_STRIP_SAVE_FILE': strip_save_file})
 
 
-  def WriteXcodeEnv(self, target, env):
-    for k in gyp.xcode_emulation.TopologicallySortedEnvVarKeys(env):
+  def WriteSortedXcodeEnv(self, target, env):
+    for k, v in env:
       # For
       #  foo := a\ b
       # 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]))
+      self.WriteLn('%s: export %s := %s' % (QuoteSpaces(target), k, v))
 
 
   def Objectify(self, path):
     """Convert a path to its output directory form."""
     if '$(' in path:
       path = path.replace('$(obj)/', '$(obj).%s/$(TARGET)/' % self.toolset)
       return path
     return '$(obj).%s/$(TARGET)/%s' % (self.toolset, path)
 
 
@@ skipping 311 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()