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

pylib/gyp/generator/ninja.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.
 
 import copy
 import gyp
 import gyp.common
 import gyp.msvs_emulation
 import gyp.MSVSVersion
 import gyp.system_test
@@ skipping 485 matching lines @@
     if self.toolset != 'target':
       verb += '(%s)' % self.toolset
     if message:
       return '%s %s' % (verb, self.ExpandSpecial(message))
     else:
       return '%s %s: %s' % (verb, self.name, fallback)
 
   def WriteActions(self, actions, extra_sources, prebuild,
                    extra_mac_bundle_resources):
     # Actions cd into the base directory.
-    env = self.GetXcodeEnv()
+    env = self.GetSortedXcodeEnv()
     if self.flavor == 'win':
       env = self.msvs_settings.GetVSMacroEnv('$!PRODUCT_DIR')
     all_outputs = []
     for action in actions:
       # First write out a rule for the action.
       name = re.sub(r'[ {}$]', '_', action['action_name'])
       description = self.GenerateDescription('ACTION',
                                              action.get('message', None),
                                              name)
       is_cygwin = (self.msvs_settings.IsRuleRunUnderCygwin(action)
@@ skipping 98 matching lines @@
                          implicit=inputs,
                          order_only=prebuild,
                          variables=extra_bindings)
 
         all_outputs.extend(outputs)
 
     return all_outputs
 
   def WriteCopies(self, copies, prebuild):
     outputs = []
-    env = self.GetXcodeEnv()
+    env = self.GetSortedXcodeEnv()
     for copy in copies:
       for path in copy['files']:
         # Normalize the path so trailing slashes don't confuse us.
         path = os.path.normpath(path)
         basename = os.path.split(path)[1]
         src = self.GypPathToNinja(path, env)
         dst = self.GypPathToNinja(os.path.join(copy['destination'], basename),
                                   env)
         outputs += self.ninja.build(dst, 'copy', src, order_only=prebuild)
 
@@ skipping 16 matching lines @@
     if not info_plist:
       return
     if defines:
       # Create an intermediate file to store preprocessed results.
       intermediate_plist = self.GypPathToUniqueOutput(
           os.path.basename(info_plist))
       defines = ' '.join([Define(d, self.flavor) for d in defines])
       info_plist = self.ninja.build(intermediate_plist, 'infoplist', info_plist,
                                     variables=[('defines',defines)])
 
-    env = self.GetXcodeEnv(additional_settings=extra_env)
+    env = self.GetSortedXcodeEnv(additional_settings=extra_env)
     env = self.ComputeExportEnvString(env)
 
     self.ninja.build(out, 'mac_tool', info_plist,
                      variables=[('mactool_cmd', 'copy-info-plist'),
                                 ('env', env)])
     bundle_depends.append(out)
 
   def WriteSources(self, config_name, config, sources, predepends,
                    precompiled_header):
     """Write build rules to compile all of |sources|."""
@@ skipping 226 matching lines @@
     if package_framework:
       variables.append(('version', self.xcode_settings.GetFrameworkVersion()))
       self.ninja.build(output, 'package_framework', mac_bundle_depends,
                        variables=variables)
     else:
       self.ninja.build(output, 'stamp', mac_bundle_depends,
                        variables=variables)
     self.target.bundle = output
     return output
 
-  def GetXcodeEnv(self, additional_settings=None):
+  def GetSortedXcodeEnv(self, additional_settings=None):
     """Returns the variables Xcode would set for build steps."""
     assert self.abs_build_dir
     abs_build_dir = self.abs_build_dir
-    return gyp.xcode_emulation.GetXcodeEnv(
+    return gyp.xcode_emulation.GetSortedXcodeEnv(
         self.xcode_settings, abs_build_dir,
         os.path.join(abs_build_dir, self.build_to_base), self.config_name,
         additional_settings)
 
-  def GetXcodePostbuildEnv(self):
+  def GetSortedXcodePostbuildEnv(self):
     """Returns the variables Xcode would set for postbuild steps."""
     postbuild_settings = {}
     # 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')
     if strip_save_file:
       postbuild_settings['CHROMIUM_STRIP_SAVE_FILE'] = strip_save_file
-    return self.GetXcodeEnv(additional_settings=postbuild_settings)
+    return self.GetSortedXcodeEnv(additional_settings=postbuild_settings)
 
   def GetPostbuildCommand(self, spec, output, output_binary,
                           is_command_start=False):
     """Returns a shell command that runs all the postbuilds, and removes
     |output| if any of them fails. If |is_command_start| is False, then the
     returned string will start with ' && '."""
     if not self.xcode_settings or spec['type'] == 'none' or not output:
       return ''
     output = QuoteShellArgument(output, self.flavor)
     target_postbuilds = self.xcode_settings.GetTargetPostbuilds(
         self.config_name,
         os.path.normpath(os.path.join(self.base_to_build, output)),
         QuoteShellArgument(
             os.path.normpath(os.path.join(self.base_to_build, output_binary)),
             self.flavor),
         quiet=True)
     postbuilds = gyp.xcode_emulation.GetSpecPostbuildCommands(spec, quiet=True)
     postbuilds = target_postbuilds + postbuilds
     if not postbuilds:
       return ''
     # 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.build_to_base]))
-    env = self.ComputeExportEnvString(self.GetXcodePostbuildEnv())
+    env = self.ComputeExportEnvString(self.GetSortedXcodePostbuildEnv())
     # G will be non-null if any postbuild fails. Run all postbuilds in a
     # subshell.
     commands = env + ' (F=0; ' + \
         ' '.join([ninja_syntax.escape(command) + ' || F=$$?;'
                                  for command in postbuilds])
     command_string = (commands + ' exit $$F); G=$$?; '
                       # Remove the final output if any postbuild failed.
                       '((exit $$G) || rm -rf %s) ' % output + '&& exit $$G)')
     if is_command_start:
       return '(' + command_string + ' && '
     else:
       return '$ && (' + command_string
 
   def ComputeExportEnvString(self, env):
     """Given an environment, returns a string looking like
         'export FOO=foo; export BAR="${FOO} bar;'
     that exports |env| to the shell."""
     export_str = []
-    for k in gyp.xcode_emulation.TopologicallySortedEnvVarKeys(env):
+    for k, v in env:
       export_str.append('export %s=%s;' %
-          (k, ninja_syntax.escape(gyp.common.EncodePOSIXShellArgument(env[k]))))
+          (k, ninja_syntax.escape(gyp.common.EncodePOSIXShellArgument(v))))
     return ' '.join(export_str)
 
   def ComputeMacBundleOutput(self):
     """Return the 'output' (full output path) to a bundle output directory."""
     assert self.is_mac_bundle
     path = self.ExpandSpecial(generator_default_variables['PRODUCT_DIR'])
     return os.path.join(path, self.xcode_settings.GetWrapperName())
 
   def ComputeMacBundleBinaryOutput(self):
     """Return the 'output' (full output path) to the binary in a bundle."""
@@ skipping 544 matching lines @@
 
   user_config = params.get('generator_flags', {}).get('config', None)
   if user_config:
     GenerateOutputForConfig(target_list, target_dicts, data, params,
                             user_config)
   else:
     config_names = target_dicts[target_list[0]]['configurations'].keys()
     for config_name in config_names:
       GenerateOutputForConfig(target_list, target_dicts, data, params,
                               config_name)