CSE2410 Fall 2014 Bounce

# 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 hashlib

import multiprocessing

import os.path

import re

import signal

import subprocess

import sys

import gyp

import gyp.common

import gyp.msvs_emulation

import gyp.MSVSVersion

import gyp.xcode_emulation

from gyp.common import GetEnvironFallback

import gyp.ninja_syntax as ninja_syntax

generator_default_variables = {

  'EXECUTABLE_PREFIX': '',

  'EXECUTABLE_SUFFIX': '',

  'STATIC_LIB_PREFIX': 'lib',

  'STATIC_LIB_SUFFIX': '.a',

  'SHARED_LIB_PREFIX': 'lib',

  # Gyp expects the following variables to be expandable by the build

  # system to the appropriate locations.  Ninja prefers paths to be

  # known at gyp time.  To resolve this, introduce special

  # variables starting with $! and $| (which begin with a $ so gyp knows it

  # should be treated specially, but is otherwise an invalid

  # ninja/shell variable) that are passed to gyp here but expanded

  # before writing out into the target .ninja files; see

  # ExpandSpecial.

  # $! is used for variables that represent a path and that can only appear at

  # the start of a string, while $| is used for variables that can appear

  # anywhere in a string.

  'INTERMEDIATE_DIR': '$!INTERMEDIATE_DIR',

  'SHARED_INTERMEDIATE_DIR': '$!PRODUCT_DIR/gen',

  'PRODUCT_DIR': '$!PRODUCT_DIR',

  'CONFIGURATION_NAME': '$|CONFIGURATION_NAME',

  # Special variables that may be used by gyp 'rule' targets.

  # We generate definitions for these variables on the fly when processing a

  # rule.

  'RULE_INPUT_ROOT': '${root}',

  'RULE_INPUT_DIRNAME': '${dirname}',

  'RULE_INPUT_PATH': '${source}',

  'RULE_INPUT_EXT': '${ext}',

  'RULE_INPUT_NAME': '${name}',

}

# Placates pylint.

generator_additional_non_configuration_keys = []

generator_additional_path_sections = []

generator_extra_sources_for_rules = []

# TODO: figure out how to not build extra host objects in the non-cross-compile

# case when this is enabled, and enable unconditionally.

generator_supports_multiple_toolsets = (

  os.environ.get('GYP_CROSSCOMPILE') or

  os.environ.get('AR_host') or

  os.environ.get('CC_host') or

  os.environ.get('CXX_host') or

  os.environ.get('AR_target') or

  os.environ.get('CC_target') or

  os.environ.get('CXX_target'))

def StripPrefix(arg, prefix):

  if arg.startswith(prefix):

    return arg[len(prefix):]

  return arg

def QuoteShellArgument(arg, flavor):

  """Quote a string such that it will be interpreted as a single argument

  by the shell."""

  # Rather than attempting to enumerate the bad shell characters, just

  # whitelist common OK ones and quote anything else.

  if re.match(r'^[a-zA-Z0-9_=.\\/-]+$', arg):

    return arg  # No quoting necessary.

  if flavor == 'win':

    return gyp.msvs_emulation.QuoteForRspFile(arg)

  return "'" + arg.replace("'", "'" + '"\'"' + "'")  + "'"

def Define(d, flavor):

  """Takes a preprocessor define and returns a -D parameter that's ninja- and

  shell-escaped."""

  if flavor == 'win':

    # cl.exe replaces literal # characters with = in preprocesor definitions for

    # some reason. Octal-encode to work around that.

    d = d.replace('#', '\\%03o' % ord('#'))

  return QuoteShellArgument(ninja_syntax.escape('-D' + d), flavor)

def InvertRelativePath(path):

  """Given a relative path like foo/bar, return the inverse relative path:

  the path from the relative path back to the origin dir.

  E.g. os.path.normpath(os.path.join(path, InvertRelativePath(path)))

  should always produce the empty string."""

  if not path:

    return path

  # Only need to handle relative paths into subdirectories for now.

  assert '..' not in path, path

  depth = len(path.split(os.path.sep))

  return os.path.sep.join(['..'] * depth)

class Target:

  """Target represents the paths used within a single gyp target.

  Conceptually, building a single target A is a series of steps:

  1) actions/rules/copies  generates source/resources/etc.

  2) compiles              generates .o files

  3) link                  generates a binary (library/executable)

  4) bundle                merges the above in a mac bundle

  (Any of these steps can be optional.)

  From a build ordering perspective, a dependent target B could just

  depend on the last output of this series of steps.

  But some dependent commands sometimes need to reach inside the box.

  For example, when linking B it needs to get the path to the static

  library generated by A.

  This object stores those paths.  To keep things simple, member

  variables only store concrete paths to single files, while methods

  compute derived values like "the last output of the target".

  """

  def __init__(self, type):

    # Gyp type ("static_library", etc.) of this target.

    self.type = type

    # File representing whether any input dependencies necessary for

    # dependent actions have completed.

    self.preaction_stamp = None

    # File representing whether any input dependencies necessary for

    # dependent compiles have completed.

    self.precompile_stamp = None

    # File representing the completion of actions/rules/copies, if any.

    self.actions_stamp = None

    # Path to the output of the link step, if any.

    self.binary = None

    # Path to the file representing the completion of building the bundle,

    # if any.

    self.bundle = None

    # On Windows, incremental linking requires linking against all the .objs

    # that compose a .lib (rather than the .lib itself). That list is stored

    # here.

    self.component_objs = None

    # Windows only. The import .lib is the output of a build step, but

    # because dependents only link against the lib (not both the lib and the

    # dll) we keep track of the import library here.

    self.import_lib = None

  def Linkable(self):

    """Return true if this is a target that can be linked against."""

    return self.type in ('static_library', 'shared_library')

  def UsesToc(self, flavor):

    """Return true if the target should produce a restat rule based on a TOC

    file."""

    # For bundles, the .TOC should be produced for the binary, not for

    # FinalOutput(). But the naive approach would put the TOC file into the

    # bundle, so don't do this for bundles for now.

    if flavor == 'win' or self.bundle:

      return False

    return self.type in ('shared_library', 'loadable_module')

  def PreActionInput(self, flavor):

    """Return the path, if any, that should be used as a dependency of

    any dependent action step."""

    if self.UsesToc(flavor):

      return self.FinalOutput() + '.TOC'

    return self.FinalOutput() or self.preaction_stamp

  def PreCompileInput(self):

    """Return the path, if any, that should be used as a dependency of

    any dependent compile step."""

    return self.actions_stamp or self.precompile_stamp

  def FinalOutput(self):

    """Return the last output of the target, which depends on all prior

    steps."""

    return self.bundle or self.binary or self.actions_stamp

# A small discourse on paths as used within the Ninja build:

# All files we produce (both at gyp and at build time) appear in the

# build directory (e.g. out/Debug).

#

# Paths within a given .gyp file are always relative to the directory

# containing the .gyp file.  Call these "gyp paths".  This includes

# sources as well as the starting directory a given gyp rule/action

# expects to be run from.  We call the path from the source root to

# the gyp file the "base directory" within the per-.gyp-file

# NinjaWriter code.

#

# All paths as written into the .ninja files are relative to the build

# directory.  Call these paths "ninja paths".

#

# We translate between these two notions of paths with two helper

# functions:

#

# - GypPathToNinja translates a gyp path (i.e. relative to the .gyp file)

#   into the equivalent ninja path.

#

# - GypPathToUniqueOutput translates a gyp path into a ninja path to write

#   an output file; the result can be namespaced such that it is unique

#   to the input file name as well as the output target name.

class NinjaWriter:

  def __init__(self, qualified_target, target_outputs, base_dir, build_dir,

               output_file, flavor, abs_build_dir=None):

    """

    base_dir: path from source root to directory containing this gyp file,

              by gyp semantics, all input paths are relative to this

    build_dir: path from source root to build output

    abs_build_dir: absolute path to the build directory

    """

    self.qualified_target = qualified_target

    self.target_outputs = target_outputs

    self.base_dir = base_dir

    self.build_dir = build_dir

    self.ninja = ninja_syntax.Writer(output_file)

    self.flavor = flavor

    self.abs_build_dir = abs_build_dir

    self.obj_ext = '.obj' if flavor == 'win' else '.o'

    if flavor == 'win':

      # See docstring of msvs_emulation.GenerateEnvironmentFiles().

      self.win_env = {}

      for arch in ('x86', 'x64'):

        self.win_env[arch] = 'environment.' + arch

    # Relative path from build output dir to base dir.

    self.build_to_base = os.path.join(InvertRelativePath(build_dir), base_dir)

    # Relative path from base dir to build dir.

    self.base_to_build = os.path.join(InvertRelativePath(base_dir), build_dir)

  def ExpandSpecial(self, path, product_dir=None):

    """Expand specials like $!PRODUCT_DIR in |path|.

    If |product_dir| is None, assumes the cwd is already the product

    dir.  Otherwise, |product_dir| is the relative path to the product

    dir.

    """

    PRODUCT_DIR = '$!PRODUCT_DIR'

    if PRODUCT_DIR in path:

      if product_dir:

        path = path.replace(PRODUCT_DIR, product_dir)

      else:

        path = path.replace(PRODUCT_DIR + '/', '')

        path = path.replace(PRODUCT_DIR + '\\', '')

        path = path.replace(PRODUCT_DIR, '.')

    INTERMEDIATE_DIR = '$!INTERMEDIATE_DIR'

    if INTERMEDIATE_DIR in path:

      int_dir = self.GypPathToUniqueOutput('gen')

      # GypPathToUniqueOutput generates a path relative to the product dir,

      # so insert product_dir in front if it is provided.

      path = path.replace(INTERMEDIATE_DIR,

                          os.path.join(product_dir or '', int_dir))

    CONFIGURATION_NAME = '$|CONFIGURATION_NAME'

    path = path.replace(CONFIGURATION_NAME, self.config_name)

    return path

  def ExpandRuleVariables(self, path, root, dirname, source, ext, name):

    if self.flavor == 'win':

      path = self.msvs_settings.ConvertVSMacros(

          path, config=self.config_name)

    path = path.replace(generator_default_variables['RULE_INPUT_ROOT'], root)

    path = path.replace(generator_default_variables['RULE_INPUT_DIRNAME'],

                        dirname)

    path = path.replace(generator_default_variables['RULE_INPUT_PATH'], source)

    path = path.replace(generator_default_variables['RULE_INPUT_EXT'], ext)

    path = path.replace(generator_default_variables['RULE_INPUT_NAME'], name)

    return path

  def GypPathToNinja(self, path, env=None):

    """Translate a gyp path to a ninja path, optionally expanding environment

    variable references in |path| with |env|.

    See the above discourse on path conversions."""

    if env:

      if self.flavor == 'mac':

        path = gyp.xcode_emulation.ExpandEnvVars(path, env)

      elif self.flavor == 'win':

        path = gyp.msvs_emulation.ExpandMacros(path, env)

    if path.startswith('$!'):

      expanded = self.ExpandSpecial(path)

      if self.flavor == 'win':

        expanded = os.path.normpath(expanded)

      return expanded

    if '$|' in path:

      path =  self.ExpandSpecial(path)

    assert '$' not in path, path

    return os.path.normpath(os.path.join(self.build_to_base, path))

  def GypPathToUniqueOutput(self, path, qualified=True):

    """Translate a gyp path to a ninja path for writing output.

    If qualified is True, qualify the resulting filename with the name

    of the target.  This is necessary when e.g. compiling the same

    path twice for two separate output targets.

    See the above discourse on path conversions."""

    path = self.ExpandSpecial(path)

    assert not path.startswith('$'), path

    # Translate the path following this scheme:

    #   Input: foo/bar.gyp, target targ, references baz/out.o

    #   Output: obj/foo/baz/targ.out.o (if qualified)

    #           obj/foo/baz/out.o (otherwise)

    #     (and obj.host instead of obj for cross-compiles)

    #

    # Why this scheme and not some other one?

    # 1) for a given input, you can compute all derived outputs by matching

    #    its path, even if the input is brought via a gyp file with '..'.

    # 2) simple files like libraries and stamps have a simple filename.

    obj = 'obj'

    if self.toolset != 'target':

      obj += '.' + self.toolset

    path_dir, path_basename = os.path.split(path)

    if qualified:

      path_basename = self.name + '.' + path_basename

    return os.path.normpath(os.path.join(obj, self.base_dir, path_dir,

                                         path_basename))

  def WriteCollapsedDependencies(self, name, targets):

    """Given a list of targets, return a path for a single file

    representing the result of building all the targets or None.

    Uses a stamp file if necessary."""

    assert targets == filter(None, targets), targets

    if len(targets) == 0:

      return None

    if len(targets) > 1:

      stamp = self.GypPathToUniqueOutput(name + '.stamp')

      targets = self.ninja.build(stamp, 'stamp', targets)

      self.ninja.newline()

    return targets[0]

  def WriteSpec(self, spec, config_name, generator_flags,

      case_sensitive_filesystem):

    """The main entry point for NinjaWriter: write the build rules for a spec.

    Returns a Target object, which represents the output paths for this spec.

    Returns None if there are no outputs (e.g. a settings-only 'none' type

    target)."""

    self.config_name = config_name

    self.name = spec['target_name']

    self.toolset = spec['toolset']

    config = spec['configurations'][config_name]

    self.target = Target(spec['type'])

    self.is_standalone_static_library = bool(

        spec.get('standalone_static_library', 0))

    self.is_mac_bundle = gyp.xcode_emulation.IsMacBundle(self.flavor, spec)

    self.xcode_settings = self.msvs_settings = None

    if self.flavor == 'mac':

      self.xcode_settings = gyp.xcode_emulation.XcodeSettings(spec)

    if self.flavor == 'win':

      self.msvs_settings = gyp.msvs_emulation.MsvsSettings(spec,

                                                           generator_flags)

      target_platform = self.msvs_settings.GetTargetPlatform(config_name)

      self.ninja.variable('arch', self.win_env[target_platform])

    # Compute predepends for all rules.

    # actions_depends is the dependencies this target depends on before running

    # any of its action/rule/copy steps.

    # compile_depends is the dependencies this target depends on before running

    # any of its compile steps.

    actions_depends = []

    compile_depends = []

    # TODO(evan): it is rather confusing which things are lists and which

    # are strings.  Fix these.

    if 'dependencies' in spec:

      for dep in spec['dependencies']:

        if dep in self.target_outputs:

          target = self.target_outputs[dep]

          actions_depends.append(target.PreActionInput(self.flavor))

          compile_depends.append(target.PreCompileInput())

      actions_depends = filter(None, actions_depends)

      compile_depends = filter(None, compile_depends)

      actions_depends = self.WriteCollapsedDependencies('actions_depends',

                                                        actions_depends)

      compile_depends = self.WriteCollapsedDependencies('compile_depends',

                                                        compile_depends)

      self.target.preaction_stamp = actions_depends

      self.target.precompile_stamp = compile_depends

    # Write out actions, rules, and copies.  These must happen before we

    # compile any sources, so compute a list of predependencies for sources

    # while we do it.

    extra_sources = []

    mac_bundle_depends = []

    self.target.actions_stamp = self.WriteActionsRulesCopies(

        spec, extra_sources, actions_depends, mac_bundle_depends)

    # If we have actions/rules/copies, we depend directly on those, but

    # otherwise we depend on dependent target's actions/rules/copies etc.

    # We never need to explicitly depend on previous target's link steps,

    # because no compile ever depends on them.

    compile_depends_stamp = (self.target.actions_stamp or compile_depends)

    # Write out the compilation steps, if any.

    link_deps = []

    sources = spec.get('sources', []) + extra_sources

    if sources:

      pch = None

      if self.flavor == 'win':

        gyp.msvs_emulation.VerifyMissingSources(

            sources, self.abs_build_dir, generator_flags, self.GypPathToNinja)

        pch = gyp.msvs_emulation.PrecompiledHeader(

            self.msvs_settings, config_name, self.GypPathToNinja)

      else:

        pch = gyp.xcode_emulation.MacPrefixHeader(

            self.xcode_settings, self.GypPathToNinja,

            lambda path, lang: self.GypPathToUniqueOutput(path + '-' + lang))

      link_deps = self.WriteSources(

          config_name, config, sources, compile_depends_stamp, pch,

          case_sensitive_filesystem)

      # Some actions/rules output 'sources' that are already object files.

      link_deps += [self.GypPathToNinja(f)

          for f in sources if f.endswith(self.obj_ext)]

    if self.flavor == 'win' and self.target.type == 'static_library':

      self.target.component_objs = link_deps

    # Write out a link step, if needed.

    output = None

    if link_deps or self.target.actions_stamp or actions_depends:

      output = self.WriteTarget(spec, config_name, config, link_deps,

                                self.target.actions_stamp or actions_depends)

      if self.is_mac_bundle:

        mac_bundle_depends.append(output)

    # Bundle all of the above together, if needed.

    if self.is_mac_bundle:

      output = self.WriteMacBundle(spec, mac_bundle_depends)

    if not output:

      return None

    assert self.target.FinalOutput(), output

    return self.target

  def _WinIdlRule(self, source, prebuild, outputs):

    """Handle the implicit VS .idl rule for one source file. Fills |outputs|

    with files that are generated."""

    outdir, output, vars, flags = self.msvs_settings.GetIdlBuildData(

        source, self.config_name)

    outdir = self.GypPathToNinja(outdir)

    def fix_path(path, rel=None):

      path = os.path.join(outdir, path)

      dirname, basename = os.path.split(source)

      root, ext = os.path.splitext(basename)

      path = self.ExpandRuleVariables(

          path, root, dirname, source, ext, basename)

      if rel:

        path = os.path.relpath(path, rel)

      return path

    vars = [(name, fix_path(value, outdir)) for name, value in vars]

    output = [fix_path(p) for p in output]

    vars.append(('outdir', outdir))

    vars.append(('idlflags', flags))

    input = self.GypPathToNinja(source)

    self.ninja.build(output, 'idl', input,

        variables=vars, order_only=prebuild)

    outputs.extend(output)

  def WriteWinIdlFiles(self, spec, prebuild):

    """Writes rules to match MSVS's implicit idl handling."""

    assert self.flavor == 'win'

    if self.msvs_settings.HasExplicitIdlRules(spec):

      return []

    outputs = []

    for source in filter(lambda x: x.endswith('.idl'), spec['sources']):

      self._WinIdlRule(source, prebuild, outputs)

    return outputs

  def WriteActionsRulesCopies(self, spec, extra_sources, prebuild,

                              mac_bundle_depends):

    """Write out the Actions, Rules, and Copies steps.  Return a path

    representing the outputs of these steps."""

    outputs = []

    extra_mac_bundle_resources = []

    if 'actions' in spec:

      outputs += self.WriteActions(spec['actions'], extra_sources, prebuild,

                                   extra_mac_bundle_resources)

    if 'rules' in spec:

      outputs += self.WriteRules(spec['rules'], extra_sources, prebuild,

                                 extra_mac_bundle_resources)

    if 'copies' in spec:

      outputs += self.WriteCopies(spec['copies'], prebuild)

    if 'sources' in spec and self.flavor == 'win':

      outputs += self.WriteWinIdlFiles(spec, prebuild)

    stamp = self.WriteCollapsedDependencies('actions_rules_copies', outputs)

    if self.is_mac_bundle:

      mac_bundle_resources = spec.get('mac_bundle_resources', []) + \

                             extra_mac_bundle_resources

      self.WriteMacBundleResources(mac_bundle_resources, mac_bundle_depends)

      self.WriteMacInfoPlist(mac_bundle_depends)

    return stamp

  def GenerateDescription(self, verb, message, fallback):

    """Generate and return a description of a build step.

    |verb| is the short summary, e.g. ACTION or RULE.

    |message| is a hand-written description, or None if not available.

    |fallback| is the gyp-level name of the step, usable as a fallback.

    """

    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.GetSortedXcodeEnv()

    if self.flavor == 'win':

      env = self.msvs_settings.GetVSMacroEnv(

          '$!PRODUCT_DIR', config=self.config_name)

    all_outputs = []

    for action in actions:

      # First write out a rule for the action.

      name = '%s_%s' % (action['action_name'],

                        hashlib.md5(self.qualified_target).hexdigest())

      description = self.GenerateDescription('ACTION',

                                             action.get('message', None),

                                             name)

      is_cygwin = (self.msvs_settings.IsRuleRunUnderCygwin(action)

                   if self.flavor == 'win' else False)

      args = action['action']

      rule_name, _ = self.WriteNewNinjaRule(name, args, description,

                                            is_cygwin, env=env)

      inputs = [self.GypPathToNinja(i, env) for i in action['inputs']]

      if int(action.get('process_outputs_as_sources', False)):

        extra_sources += action['outputs']

      if int(action.get('process_outputs_as_mac_bundle_resources', False)):

        extra_mac_bundle_resources += action['outputs']

      outputs = [self.GypPathToNinja(o, env) for o in action['outputs']]

      # Then write out an edge using the rule.

      self.ninja.build(outputs, rule_name, inputs,

                       order_only=prebuild)

      all_outputs += outputs

      self.ninja.newline()

    return all_outputs

  def WriteRules(self, rules, extra_sources, prebuild,

                 extra_mac_bundle_resources):

    env = self.GetSortedXcodeEnv()

    all_outputs = []

    for rule in rules:

      # First write out a rule for the rule action.

      name = '%s_%s' % (rule['rule_name'],

                        hashlib.md5(self.qualified_target).hexdigest())

      # Skip a rule with no action and no inputs.

      if 'action' not in rule and not rule.get('rule_sources', []):

        continue

      args = rule['action']

      description = self.GenerateDescription(

          'RULE',

          rule.get('message', None),

          ('%s ' + generator_default_variables['RULE_INPUT_PATH']) % name)

      is_cygwin = (self.msvs_settings.IsRuleRunUnderCygwin(rule)

                   if self.flavor == 'win' else False)

      rule_name, args = self.WriteNewNinjaRule(

          name, args, description, is_cygwin, env=env)

      # TODO: if the command references the outputs directly, we should

      # simplify it to just use $out.

      # Rules can potentially make use of some special variables which

      # must vary per source file.

      # Compute the list of variables we'll need to provide.

      special_locals = ('source', 'root', 'dirname', 'ext', 'name')

      needed_variables = set(['source'])

      for argument in args:

        for var in special_locals:

          if ('${%s}' % var) in argument:

            needed_variables.add(var)

      def cygwin_munge(path):

        if is_cygwin:

          return path.replace('\\', '/')

        return path

      # For each source file, write an edge that generates all the outputs.

      for source in rule.get('rule_sources', []):

        dirname, basename = os.path.split(source)

        root, ext = os.path.splitext(basename)

        # Gather the list of inputs and outputs, expanding $vars if possible.

        outputs = [self.ExpandRuleVariables(o, root, dirname,

                                            source, ext, basename)

                   for o in rule['outputs']]

        inputs = [self.ExpandRuleVariables(i, root, dirname,

                                           source, ext, basename)

                  for i in rule.get('inputs', [])]

        if int(rule.get('process_outputs_as_sources', False)):

          extra_sources += outputs

        if int(rule.get('process_outputs_as_mac_bundle_resources', False)):

          extra_mac_bundle_resources += outputs

        extra_bindings = []

        for var in needed_variables:

          if var == 'root':

            extra_bindings.append(('root', cygwin_munge(root)))

          elif var == 'dirname':

            extra_bindings.append(('dirname', cygwin_munge(dirname)))

          elif var == 'source':

            # '$source' is a parameter to the rule action, which means

            # it shouldn't be converted to a Ninja path.  But we don't

            # want $!PRODUCT_DIR in there either.

            source_expanded = self.ExpandSpecial(source, self.base_to_build)

            extra_bindings.append(('source', cygwin_munge(source_expanded)))

          elif var == 'ext':

            extra_bindings.append(('ext', ext))

          elif var == 'name':

            extra_bindings.append(('name', cygwin_munge(basename)))

          else:

            assert var == None, repr(var)

        inputs = [self.GypPathToNinja(i, env) for i in inputs]

        outputs = [self.GypPathToNinja(o, env) for o in outputs]

        extra_bindings.append(('unique_name',

            hashlib.md5(outputs[0]).hexdigest()))

        self.ninja.build(outputs, rule_name, self.GypPathToNinja(source),

                         implicit=inputs,

                         order_only=prebuild,

                         variables=extra_bindings)

        all_outputs.extend(outputs)

    return all_outputs

  def WriteCopies(self, copies, prebuild):

    outputs = []

    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)

    return outputs

  def WriteMacBundleResources(self, resources, bundle_depends):

    """Writes ninja edges for 'mac_bundle_resources'."""

    for output, res in gyp.xcode_emulation.GetMacBundleResources(

        self.ExpandSpecial(generator_default_variables['PRODUCT_DIR']),

        self.xcode_settings, map(self.GypPathToNinja, resources)):

      self.ninja.build(output, 'mac_tool', res,

                       variables=[('mactool_cmd', 'copy-bundle-resource')])

      bundle_depends.append(output)

  def WriteMacInfoPlist(self, bundle_depends):

    """Write build rules for bundle Info.plist files."""

    info_plist, out, defines, extra_env = gyp.xcode_emulation.GetMacInfoPlist(

        self.ExpandSpecial(generator_default_variables['PRODUCT_DIR']),

        self.xcode_settings, self.GypPathToNinja)

    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.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, case_sensitive_filesystem):

    """Write build rules to compile all of |sources|."""

    if self.toolset == 'host':

      self.ninja.variable('ar', '$ar_host')

      self.ninja.variable('cc', '$cc_host')

      self.ninja.variable('cxx', '$cxx_host')

      self.ninja.variable('ld', '$ld_host')

    extra_defines = []

    if self.flavor == 'mac':

      cflags = self.xcode_settings.GetCflags(config_name)

      cflags_c = self.xcode_settings.GetCflagsC(config_name)

      cflags_cc = self.xcode_settings.GetCflagsCC(config_name)

      cflags_objc = ['$cflags_c'] + \

                    self.xcode_settings.GetCflagsObjC(config_name)

      cflags_objcc = ['$cflags_cc'] + \

                     self.xcode_settings.GetCflagsObjCC(config_name)

    elif self.flavor == 'win':

      cflags = self.msvs_settings.GetCflags(config_name)

      cflags_c = self.msvs_settings.GetCflagsC(config_name)

      cflags_cc = self.msvs_settings.GetCflagsCC(config_name)

      extra_defines = self.msvs_settings.GetComputedDefines(config_name)

      self.WriteVariableList('pdbname', [self.name + '.pdb'])

      self.WriteVariableList('pchprefix', [self.name])

    else:

      cflags = config.get('cflags', [])

      cflags_c = config.get('cflags_c', [])

      cflags_cc = config.get('cflags_cc', [])

    defines = config.get('defines', []) + extra_defines

    self.WriteVariableList('defines', [Define(d, self.flavor) for d in defines])

    if self.flavor == 'win':

      self.WriteVariableList('rcflags',

          [QuoteShellArgument(self.ExpandSpecial(f), self.flavor)

           for f in self.msvs_settings.GetRcflags(config_name,

                                                  self.GypPathToNinja)])

    include_dirs = config.get('include_dirs', [])

    if self.flavor == 'win':

      include_dirs = self.msvs_settings.AdjustIncludeDirs(include_dirs,

                                                          config_name)

    self.WriteVariableList('includes',

        [QuoteShellArgument('-I' + self.GypPathToNinja(i), self.flavor)

         for i in include_dirs])

    pch_commands = precompiled_header.GetPchBuildCommands()

    if self.flavor == 'mac':

      self.WriteVariableList('cflags_pch_c',

                             [precompiled_header.GetInclude('c')])

      self.WriteVariableList('cflags_pch_cc',

                             [precompiled_header.GetInclude('cc')])

      self.WriteVariableList('cflags_pch_objc',

                             [precompiled_header.GetInclude('m')])

      self.WriteVariableList('cflags_pch_objcc',

                             [precompiled_header.GetInclude('mm')])

    self.WriteVariableList('cflags', map(self.ExpandSpecial, cflags))

    self.WriteVariableList('cflags_c', map(self.ExpandSpecial, cflags_c))

    self.WriteVariableList('cflags_cc', map(self.ExpandSpecial, cflags_cc))

    if self.flavor == 'mac':

      self.WriteVariableList('cflags_objc', map(self.ExpandSpecial,

                                                cflags_objc))

      self.WriteVariableList('cflags_objcc', map(self.ExpandSpecial,

                                                 cflags_objcc))

    self.ninja.newline()

    outputs = []

    for source in sources:

      filename, ext = os.path.splitext(source)

      ext = ext[1:]

      obj_ext = self.obj_ext

      if ext in ('cc', 'cpp', 'cxx'):

        command = 'cxx'

      elif ext == 'c' or (ext == 'S' and self.flavor != 'win'):

        command = 'cc'

      elif ext == 's' and self.flavor != 'win':  # Doesn't generate .o.d files.

        command = 'cc_s'

      elif (self.flavor == 'win' and ext == 'asm' and

            self.msvs_settings.GetTargetPlatform(config_name) == 'Win32'):

        # Asm files only get auto assembled for x86 (not x64).

        command = 'asm'

        # Add the _asm suffix as msvs is capable of handling .cc and

        # .asm files of the same name without collision.

        obj_ext = '_asm.obj'

      elif self.flavor == 'mac' and ext == 'm':

        command = 'objc'

      elif self.flavor == 'mac' and ext == 'mm':

        command = 'objcxx'

      elif self.flavor == 'win' and ext == 'rc':

        command = 'rc'

        obj_ext = '.res'

      else:

        # Ignore unhandled extensions.

        continue

      input = self.GypPathToNinja(source)

      output = self.GypPathToUniqueOutput(filename + obj_ext)

      # Ninja's depfile handling gets confused when the case of a filename

      # changes on a case-insensitive file system. To work around that, always

      # convert .o filenames to lowercase on such file systems. See

      # https://github.com/martine/ninja/issues/402 for details.

      if not case_sensitive_filesystem:

        output = output.lower()

      implicit = precompiled_header.GetObjDependencies([input], [output])

      self.ninja.build(output, command, input,

                       implicit=[gch for _, _, gch in implicit],

                       order_only=predepends)

      outputs.append(output)

    self.WritePchTargets(pch_commands)

    self.ninja.newline()

    return outputs

  def WritePchTargets(self, pch_commands):

    """Writes ninja rules to compile prefix headers."""

    if not pch_commands:

      return

    for gch, lang_flag, lang, input in pch_commands:

      var_name = {

        'c': 'cflags_pch_c',

        'cc': 'cflags_pch_cc',

        'm': 'cflags_pch_objc',

        'mm': 'cflags_pch_objcc',

      }[lang]

      map = { 'c': 'cc', 'cc': 'cxx', 'm': 'objc', 'mm': 'objcxx', }

      if self.flavor == 'win':

        map.update({'c': 'cc_pch', 'cc': 'cxx_pch'})

      cmd = map.get(lang)

      self.ninja.build(gch, cmd, input, variables=[(var_name, lang_flag)])

  def WriteLink(self, spec, config_name, config, link_deps):

    """Write out a link step. Fills out target.binary. """

    command = {

      'executable':      'link',

      'loadable_module': 'solink_module',

      'shared_library':  'solink',

    }[spec['type']]

    implicit_deps = set()

    solibs = set()

    if 'dependencies' in spec:

      # Two kinds of dependencies:

      # - Linkable dependencies (like a .a or a .so): add them to the link line.

      # - Non-linkable dependencies (like a rule that generates a file

      #   and writes a stamp file): add them to implicit_deps

      extra_link_deps = set()

      for dep in spec['dependencies']:

        target = self.target_outputs.get(dep)

        if not target:

          continue

        linkable = target.Linkable()

        if linkable:

          if (self.flavor == 'win' and

              target.component_objs and

              self.msvs_settings.IsUseLibraryDependencyInputs(config_name)):

            extra_link_deps |= set(target.component_objs)

          elif self.flavor == 'win' and target.import_lib:

            extra_link_deps.add(target.import_lib)

          elif target.UsesToc(self.flavor):

            solibs.add(target.binary)

            implicit_deps.add(target.binary + '.TOC')

          else:

            extra_link_deps.add(target.binary)

        final_output = target.FinalOutput()

        if not linkable or final_output != target.binary:

          implicit_deps.add(final_output)

      link_deps.extend(list(extra_link_deps))

    extra_bindings = []

    if self.is_mac_bundle:

      output = self.ComputeMacBundleBinaryOutput()

    else:

      output = self.ComputeOutput(spec)

      extra_bindings.append(('postbuilds',

                             self.GetPostbuildCommand(spec, output, output)))

    if self.flavor == 'mac':

      ldflags = self.xcode_settings.GetLdflags(config_name,

          self.ExpandSpecial(generator_default_variables['PRODUCT_DIR']),

          self.GypPathToNinja)

    elif self.flavor == 'win':

      libflags = self.msvs_settings.GetLibFlags(config_name,

                                                self.GypPathToNinja)

      self.WriteVariableList(

          'libflags', gyp.common.uniquer(map(self.ExpandSpecial, libflags)))

      is_executable = spec['type'] == 'executable'

      manifest_name = self.GypPathToUniqueOutput(

          self.ComputeOutputFileName(spec))

      ldflags, manifest_files = self.msvs_settings.GetLdflags(config_name,

          self.GypPathToNinja, self.ExpandSpecial, manifest_name, is_executable)

      self.WriteVariableList('manifests', manifest_files)

    else:

      ldflags = config.get('ldflags', [])

    self.WriteVariableList('ldflags',

                           gyp.common.uniquer(map(self.ExpandSpecial,

                                                  ldflags)))

    libraries = gyp.common.uniquer(map(self.ExpandSpecial,

                                       spec.get('libraries', [])))

    if self.flavor == 'mac':

      libraries = self.xcode_settings.AdjustLibraries(libraries)

    elif self.flavor == 'win':

      libraries = self.msvs_settings.AdjustLibraries(libraries)

    self.WriteVariableList('libs', libraries)

    self.target.binary = output

    if command in ('solink', 'solink_module'):

      extra_bindings.append(('soname', os.path.split(output)[1]))

      extra_bindings.append(('lib',

                            gyp.common.EncodePOSIXShellArgument(output)))

      if self.flavor == 'win':

        extra_bindings.append(('dll', output))

        if '/NOENTRY' not in ldflags:

          self.target.import_lib = output + '.lib'

          extra_bindings.append(('implibflag',

                                 '/IMPLIB:%s' % self.target.import_lib))

          output = [output, self.target.import_lib]

      else:

        output = [output, output + '.TOC']

    if len(solibs):

      extra_bindings.append(('solibs', gyp.common.EncodePOSIXShellList(solibs)))

    self.ninja.build(output, command, link_deps,

                     implicit=list(implicit_deps),

                     variables=extra_bindings)

  def WriteTarget(self, spec, config_name, config, link_deps, compile_deps):

    if spec['type'] == 'none':

      # TODO(evan): don't call this function for 'none' target types, as

      # it doesn't do anything, and we fake out a 'binary' with a stamp file.

      self.target.binary = compile_deps

    elif spec['type'] == 'static_library':

      self.target.binary = self.ComputeOutput(spec)

      variables = []

      postbuild = self.GetPostbuildCommand(

          spec, self.target.binary, self.target.binary)

      if postbuild:

        variables.append(('postbuilds', postbuild))

      if self.xcode_settings:

        variables.append(('libtool_flags',

                          self.xcode_settings.GetLibtoolflags(config_name)))

      if (self.flavor not in ('mac', 'win') and not

          self.is_standalone_static_library):

        self.ninja.build(self.target.binary, 'alink_thin', link_deps,

                         order_only=compile_deps, variables=variables)

      else:

        self.ninja.build(self.target.binary, 'alink', link_deps,

                         order_only=compile_deps, variables=variables)

    else:

      self.WriteLink(spec, config_name, config, link_deps)

    return self.target.binary

  def WriteMacBundle(self, spec, mac_bundle_depends):

    assert self.is_mac_bundle

    package_framework = spec['type'] in ('shared_library', 'loadable_module')

    output = self.ComputeMacBundleOutput()

    postbuild = self.GetPostbuildCommand(spec, output, self.target.binary,

                                         is_command_start=not package_framework)

    variables = []

    if postbuild:

      variables.append(('postbuilds', postbuild))

    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 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.GetSortedXcodeEnv(

        self.xcode_settings, abs_build_dir,

        os.path.join(abs_build_dir, self.build_to_base), self.config_name,

        additional_settings)

  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.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.GetSortedXcodePostbuildEnv())

    # G will be non-null if any postbuild fails. Run all postbuilds in a

    # subshell.

    commands = env + ' (F=0; ' + \