Next level of changes to get more of Chrome building

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.system_test
 import gyp.xcode_emulation
+import json
 import os.path
 import re
 import subprocess
 import sys
 
 import gyp.ninja_syntax as ninja_syntax
 
 generator_default_variables = {
   'EXECUTABLE_PREFIX': '',
   'EXECUTABLE_SUFFIX': '',
@@ skipping 188 matching lines @@
     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))
 
     if self.flavor == 'win':
       # Don't use os.path.normpath here. Callers pass in './foo' and expect
-      # the result to be runnable, but normpath removes the prefix.
+      # the result to be runnable, but normpath removes the prefix. If the
+      # variable is $! prefixed on Windows, don't modify it (used for compiler
+      # flags, etc.)
+      if path.startswith('$!'):
+        return path[2:]
       return path.replace('/', '\\')
     return path
 
   def ExpandRuleVariables(self, path, root, dirname, source, ext, 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)
@@ skipping 66 matching lines @@
     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_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)
-    else:
-      self.xcode_settings = None
+    if self.flavor == 'win':
+      self.msvs_settings = gyp.msvs_emulation.MsvsSettings(spec)
 
     # 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.
@@ skipping 24 matching lines @@
     # 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:
       link_deps = self.WriteSources(
-          config_name, config, sources, compile_depends_stamp,
+          config_name, config, sources, compile_depends_stamp, spec,
           gyp.xcode_emulation.MacPrefixHeader(
               self.xcode_settings, self.GypPathToNinja,
               lambda path, lang: self.GypPathToUniqueOutput(path + '-' + lang)))
       # 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)]
 
     # Write out a link step, if needed.
     output = None
     if link_deps or self.target.actions_stamp or actions_depends:
@@ skipping 63 matching lines @@
     # Actions cd into the base directory.
     env = self.GetXcodeEnv()
     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)
       rule_name = self.WriteNewNinjaRule(name, action['action'], description,
-                                         env=env)
+                                         env=env, rule=action)
 
-      inputs = [self.GypPathToNinja(i, env) for i in action['inputs']]
+      if self.flavor == 'win':
+        inputs = [self.msvs_settings.ConvertVSMacros(i)
+                  for i in action['inputs']]
+      else:
+        inputs = actions['inputs']
+      inputs = [self.GypPathToNinja(i, env) for i in 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']]
+      if self.flavor == 'win':
+        outputs = [self.msvs_settings.ConvertVSMacros(i)
+                   for i in action['outputs']]
+      else:
+        outputs = action['outputs']
+      outputs = [self.GypPathToNinja(o, env) for o in 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):
     all_outputs = []
     for rule in rules:
       # First write out a rule for the rule action.
       name = rule['rule_name']
       args = rule['action']
       description = self.GenerateDescription(
           'RULE',
           rule.get('message', None),
           ('%s ' + generator_default_variables['RULE_INPUT_PATH']) % name)
-      rule_name = self.WriteNewNinjaRule(name, args, description)
+      rule_name = self.WriteNewNinjaRule(name, args, description, rule=rule)
 
       # 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)
 
+      is_cygwin = gyp.msvs_emulation.IsRuleRunUnderCygwin(rule)
+      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 outputs, expanding $vars if possible.
         outputs = []
         for output in rule['outputs']:
           outputs.append(self.ExpandRuleVariables(output, root, dirname,
                                                   source, ext, basename))
 
         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', root))
+            extra_bindings.append(('root', cygwin_munge(root)))
           elif var == 'dirname':
-            extra_bindings.append(('dirname', 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', source_expanded))
+            extra_bindings.append(('source', cygwin_munge(source_expanded)))
           elif var == 'ext':
-            extra_bindings.append(('ext', ext))
+            extra_bindings.append(('ext', cygwin_munge(ext)))
           elif var == 'name':
             extra_bindings.append(('name', basename))
           else:
             assert var == None, repr(var)
 
-        inputs = map(self.GypPathToNinja, rule.get('inputs', []))
+        inputs = []
+        for input in rule.get('inputs', []):
+          inputs.append(self.ExpandRuleVariables(input, root, dirname, source,
+                                                 ext, basename))
+        inputs = map(self.GypPathToNinja, inputs)
         outputs = map(self.GypPathToNinja, outputs)
         self.ninja.build(outputs, rule_name, self.GypPathToNinja(source),
                          implicit=inputs,
                          order_only=prebuild,
                          variables=extra_bindings)
 
         all_outputs.extend(outputs)
 
     return all_outputs
 
@@ skipping 39 matching lines @@
                                     variables=[('defines',defines)])
 
     env = self.GetXcodeEnv(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,
+  def WriteSources(self, config_name, config, sources, predepends, spec,
                    precompiled_header):
     """Write build rules to compile all of |sources|."""
     if self.toolset == 'target':
       self.ninja.variable('ar', '$ar_target')
       self.ninja.variable('cc', '$cc_target')
       self.ninja.variable('cxx', '$cxx_target')
       self.ninja.variable('ld', '$ld_target')
 
+    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.msvs_settings.HandleIdlFiles(
+          self.ninja, spec, sources, config_name,
+          self.GypPathToNinja,
+          self.GypPathToUniqueOutput,
+          self.ExpandRuleVariables)
     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',
         [QuoteShellArgument(ninja_syntax.escape('-D' + d), self.flavor)
-         for d in config.get('defines', [])])
+         for d in defines])
+    include_dirs = config.get('include_dirs', [])
+    if self.flavor == 'win':
+      include_dirs = self.msvs_settings.AdjustIncludeDirs(include_dirs,
+                                                          config_name)
     self.WriteVariableList('includes',
-                           ['-I' + self.GypPathToNinja(i)
-                            for i in config.get('include_dirs', [])])
+        [QuoteShellArgument('-I' + self.GypPathToNinja(i), self.flavor)
+         for i in include_dirs])
 
     pch_commands = precompiled_header.GetGchBuildCommands()
     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',
@@ skipping 14 matching lines @@
       ext = ext[1:]
       if ext in ('cc', 'cpp', 'cxx'):
         command = 'cxx'
       elif ext in ('c', 's', 'S'):
         command = 'cc'
       elif self.flavor == 'mac' and ext == 'm':
         command = 'objc'
       elif self.flavor == 'mac' and ext == 'mm':
         command = 'objcxx'
       else:
-        # TODO: should we assert here on unexpected extensions?
         continue
       input = self.GypPathToNinja(source)
       output = self.GypPathToUniqueOutput(filename + self.obj_ext)
       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)
@@ skipping 54 matching lines @@
       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':
+      ldflags = self.msvs_settings.GetLdflags(config_name, spec,
+          self.ExpandSpecial(generator_default_variables['PRODUCT_DIR']),
+          self.GypPathToNinja)
+      libflags = self.msvs_settings.GetLibFlags(config_name, spec)
+      self.WriteVariableList('libflags',
+                             gyp.common.uniquer(map(self.ExpandSpecial,
+                                                    libflags)))
     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]))
       if self.flavor == 'win':
         import_lib = output + '.lib'
         extra_bindings.append(('dll', output))
         extra_bindings.append(('implib', import_lib))
+        output = [output, import_lib]
         self.target.binary = import_lib
-        output = [output, import_lib]
 
     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
@@ skipping 181 matching lines @@
         libdir = os.path.join('lib', '%s' % self.toolset)
       return os.path.join(libdir, filename)
     else:
       return self.GypPathToUniqueOutput(filename, qualified=False)
 
   def WriteVariableList(self, var, values):
     if values is None:
       values = []
     self.ninja.variable(var, ' '.join(values))
 
-  def WriteNewNinjaRule(self, name, args, description, env={}):
+  def WriteNewNinjaRule(self, name, args, description, env={}, rule=None):
     """Write out a new ninja "rule" statement for a given command.
 
     Returns the name of the new rule."""
 
     # TODO: we shouldn't need to qualify names; we do it because
     # currently the ninja rule namespace is global, but it really
     # should be scoped to the subninja.
     rule_name = self.name
     if self.toolset == 'target':
       rule_name += '.' + self.toolset
     rule_name += '.' + name
     rule_name = rule_name.replace(' ', '_')
 
     args = args[:]
 
+    is_cygwin = rule and int(rule.get('msvs_cygwin_shell', 1))
+
     # gyp dictates that commands are run from the base directory.
     # cd into the directory before running, and adjust paths in
     # the arguments to point to the proper locations.
     if self.flavor == 'win':
-      cd = 'cmd /s /c "cd %s && ' % self.build_to_base
+      cd = 'cmd /s /c "'
+      if not is_cygwin:
+        cd += 'cd %s && ' % self.build_to_base
     else:
       cd = 'cd %s; ' % self.build_to_base
     args = [self.ExpandSpecial(arg, self.base_to_build) for arg in args]
     env = self.ComputeExportEnvString(env)
     if self.flavor == 'win':
-      # TODO(scottmg): Respect msvs_cygwin setting here.
-      # If there's no command, fake one to match the dangling |&&| above.
-      command = gyp.msvs_emulation.EncodeCmdExeList(args) or 'cmd /c'
+      if is_cygwin:
+        command = gyp.msvs_emulation.BuildCygwinBashCommandLine(
+            self.msvs_settings, rule, args, self.build_to_base, self.config_name)
+      else:
+        # If there's no command, fake one to match the dangling |&&| above.
+        command = self.msvs_settings.EncodeCmdExeList(args) or 'cmd /c'
     else:
       command = gyp.common.EncodePOSIXShellList(args)
     if env:
       # If an environment is passed in, variables in the command should be
       # read from it, instead of from ninja's internal variables.
       command = ninja_syntax.escape(command)
 
     command = cd + env + command
     # GYP rules/actions express being no-ops by not touching their outputs.
     # Avoid executing downstream dependencies in this case by specifying
@@ skipping 28 matching lines @@
     global generator_extra_sources_for_rules
     generator_extra_sources_for_rules = getattr(xcode_generator,
         'generator_extra_sources_for_rules', [])
   elif flavor == 'win':
     default_variables.setdefault('OS', 'win')
     default_variables['EXECUTABLE_SUFFIX'] = '.exe'
     default_variables['STATIC_LIB_PREFIX'] = ''
     default_variables['STATIC_LIB_SUFFIX'] = '.lib'
     default_variables['SHARED_LIB_PREFIX'] = ''
     default_variables['SHARED_LIB_SUFFIX'] = '.dll'
+    generator_flags = params.get('generator_flags', {})
+    msvs_version = gyp.msvs_emulation.GetVSVersion(generator_flags)
+
+    # Set a variable so conditions can be based on msvs_version.
+    default_variables['MSVS_VERSION'] = msvs_version.ShortName()
+
+    # To determine processor word size on Windows, in addition to checking
+    # PROCESSOR_ARCHITECTURE (which reflects the word size of the current
+    # process), it is also necessary to check PROCESSOR_ARCHITEW6432 (which
+    # contains the actual word size of the system when running thru WOW64).
+    if ('64' in os.environ.get('PROCESSOR_ARCHITECTURE', '') or
+        '64' in os.environ.get('PROCESSOR_ARCHITEW6432', '')):
+      default_variables['MSVS_OS_BITS'] = 64
+    else:
+      default_variables['MSVS_OS_BITS'] = 32
   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',
                                  os.path.join('$!PRODUCT_DIR', 'lib'))
     default_variables.setdefault('LIB_DIR', '')
 
 
 def OpenOutput(path):
   """Open |path| for writing, creating directories if necessary."""
   try:
     os.makedirs(os.path.dirname(path))
   except OSError:
     pass
   return open(path, 'w')
 
 
 def GenerateOutputForConfig(target_list, target_dicts, data, params,
                             config_name):
+  print "Generating ninja build files for %s..." % config_name
   options = params['options']
   flavor = gyp.common.GetFlavor(params)
   generator_flags = params.get('generator_flags', {})
 
   # build_dir: relative path from source root to our output files.
   # e.g. "out/Debug"
   build_dir = os.path.join(generator_flags.get('output_dir', 'out'),
                            config_name)
 
+  top_build_dir = os.path.join(options.toplevel_dir, build_dir)
   master_ninja = ninja_syntax.Writer(
-      OpenOutput(os.path.join(options.toplevel_dir, build_dir, 'build.ninja')),
+      OpenOutput(os.path.join(top_build_dir, 'build.ninja')),
       width=120)
 
   # Put build-time support tools in out/{config_name}.
-  gyp.common.CopyTool(flavor, os.path.join(options.toplevel_dir, build_dir))
+  gyp.common.CopyTool(flavor, top_build_dir)
 
   # Grab make settings for CC/CXX.
   if flavor == 'win':
-    cc = cxx = 'cl'
+    cc = cxx = gyp.msvs_emulation.GetCLPath(generator_flags)
   else:
     cc, cxx = 'gcc', 'g++'
   build_file, _, _ = gyp.common.ParseQualifiedTarget(target_list[0])
   make_global_settings = data[build_file].get('make_global_settings', [])
   build_to_root = InvertRelativePath(build_dir)
   for key, value in make_global_settings:
     if key == 'CC': cc = os.path.join(build_to_root, value)
     if key == 'CXX': cxx = os.path.join(build_to_root, value)
 
   flock = 'flock'
   if flavor == 'mac':
     flock = './gyp-mac-tool flock'
   master_ninja.variable('ar', os.environ.get('AR', 'ar'))
   master_ninja.variable('cc', os.environ.get('CC', cc))
   master_ninja.variable('cxx', os.environ.get('CXX', cxx))
   if flavor == 'win':
-    master_ninja.variable('ld', 'link')
+    master_ninja.variable('ld', gyp.msvs_emulation.GetLinkPath(generator_flags))
+    master_ninja.variable('idl',
+        gyp.msvs_emulation.GetMidlPath(generator_flags))
   else:
     master_ninja.variable('ld', flock + ' linker.lock $cxx')
 
   master_ninja.variable('ar_target', os.environ.get('AR_target', '$ar'))
   master_ninja.variable('cc_target', os.environ.get('CC_target', '$cc'))
   master_ninja.variable('cxx_target', os.environ.get('CXX_target', '$cxx'))
   if flavor == 'win':
-    master_ninja.variable('ld_target', 'link')
+    master_ninja.variable('ld_target', gyp.msvs_emulation.GetLinkPath(
+        generator_flags))
   else:
     master_ninja.variable('ld_target', flock + ' linker.lock $cxx_target')
 
   if flavor == 'mac':
     master_ninja.variable('mac_tool', os.path.join('.', 'gyp-mac-tool'))
   master_ninja.newline()
 
   if flavor != 'win':
     master_ninja.rule(
       'cc',
       description='CC $out',
       command=('$cc -MMD -MF $out.d $defines $includes $cflags $cflags_c '
               '$cflags_pch_c -c $in -o $out'),
       depfile='$out.d')
     master_ninja.rule(
       'cxx',
       description='CXX $out',
       command=('$cxx -MMD -MF $out.d $defines $includes $cflags $cflags_cc '
               '$cflags_pch_cc -c $in -o $out'),
       depfile='$out.d')
   else:
     # TODO(scottmg): Requires deplist branch of ninja for now (for
     # /showIncludes handling).
     master_ninja.rule(
       'cc',
       description='CC $out',
-      command=('cmd /c $cc /nologo /showIncludes '
-               '$defines $includes $cflags $cflags_c '
-               '$cflags_pch_c /c $in /Fo$out '
-               '| ninja-deplist-helper -f cl -o $out.dl'),
-      deplist='$out.dl')
+      command=('cmd /s /c "$cc /nologo /showIncludes '
+               '@$out.rsp '
+               '$cflags_pch_c /c $in /Fo$out /Fd$out.pdb '
+               '| ninja-deplist-helper -d .ninja_depdb -q -f cl -o $in"'),
+      depdb='$in',
+      rspfile='$out.rsp',
+      rspfile_content='$defines $includes $cflags $cflags_c')
     master_ninja.rule(
       'cxx',
       description='CXX $out',
-      command=('cmd /c $cxx /nologo /showIncludes '
-               '$defines $includes $cflags $cflags_cc '
-               '$cflags_pch_cc /c $in /Fo$out '
-               '| ninja-deplist-helper -f cl -o $out.dl'),
-      deplist='$out.dl')
+      command=('cmd /s /c "$cxx /nologo /showIncludes '
+               '@$out.rsp '
+               '$cflags_pch_cc /c $in /Fo$out /Fd$out.pdb '
+               '| ninja-deplist-helper -d .ninja_depdb -q -f cl -o $in"'),
+      depdb='$in',
+      rspfile='$out.rsp',
+      rspfile_content='$defines $includes $cflags $cflags_cc')
+    master_ninja.rule(
+      'idl',
+      description='IDL $outdir',
+      command=('python gyp-win-tool quiet-midl $outdir '
+               '$tlb $h $dlldata $iid $proxy $in '
+               '$idlflags'))
 
   if flavor != 'mac' and flavor != 'win':
     master_ninja.rule(
       'alink',
       description='AR $out',
       command='rm -f $out && $ar rcsT $out $in')
     master_ninja.rule(
       'solink',
       description='SOLINK $out',
       command=('$ld -shared $ldflags -o $out -Wl,-soname=$soname '
                '-Wl,--whole-archive $in -Wl,--no-whole-archive $libs'))
     master_ninja.rule(
       'solink_module',
       description='SOLINK(module) $out',
       command=('$ld -shared $ldflags -o $out -Wl,-soname=$soname '
                '-Wl,--start-group $in -Wl,--end-group $libs'))
     master_ninja.rule(
       'link',
       description='LINK $out',
       command=('$ld $ldflags -o $out -Wl,-rpath=\$$ORIGIN/lib '
                '-Wl,--start-group $in -Wl,--end-group $libs'))
   elif flavor == 'win':
     master_ninja.rule(
       'alink',
       description='LIB $out',
-      command='lib /nologo /OUT:$out $in')
-    master_ninja.rule(
-      'solink',
-      description='LINK(DLL) $dll',
-      command=('$ld /nologo /IMPLIB:$implib /DLL $ldflags /OUT:$dll $in $libs'))
-    master_ninja.rule(
-      'solink_module',
-      description='LINK(DLL) $dll',
-      command=('$ld /nologo /IMPLIB:$implib /DLL $ldflags /OUT:$dll $in $libs'))
+      command='lib /nologo /ignore:4221 $libflags /OUT:$out @$out.rsp',
+      rspfile='$out.rsp',
+      rspfile_content='$in')
+    # TODO(scottmg): The lib is the main output, rather than the dll. link
+    # doesn't create the import lib unless there's exports from the dll,
+    # however. This means the dependencies are wrong and the dll will always
+    # relink if it has no exports. We could touch a dummy file, but we don't
+    # want to do && touch, because that would mean we'd have to prepend cmd,
+    # which would impose a short line length on the link command line. That
+    # can be resolved by adding support for @rsp files, but neither ninja or
+    # gyp takes care of that right now. So, currently, we force the export
+    # of the entry point, and then ignore the warning that we're doing so,
+    # which causes the lib to always get generated.
+    dlldesc = 'LINK(DLL) $dll and $implib'
+    dllcmd = ('$ld /nologo /IMPLIB:$implib /DLL $ldflags /OUT:$dll '
+               '/PDB:$dll.pdb $libs @$dll.rsp')
+    master_ninja.rule('solink', description=dlldesc, command=dllcmd,
+                      rspfile='$dll.rsp', rspfile_content='$in')
+    master_ninja.rule('solink_module', description=dlldesc, command=dllcmd)
     master_ninja.rule(
       'link',
       description='LINK $out',
-      command=('$ld /nologo $ldflags /OUT:$out $in $libs'))
+      command=('$ld /nologo $ldflags /OUT:$out /PDB:$out.pdb $in $libs'))
   else:
     master_ninja.rule(
       'objc',
       description='OBJC $out',
       command=('$cc -MMD -MF $out.d $defines $includes $cflags $cflags_objc '
                '$cflags_pch_objc -c $in -o $out'),
       depfile='$out.d')
     master_ninja.rule(
       'objcxx',
       description='OBJCXX $out',
@@ skipping 38 matching lines @@
       command='$mac_tool package-framework $out $version$postbuilds '
               '&& touch $out')
   if flavor == 'win':
     master_ninja.rule(
       'stamp',
       description='STAMP $out',
       command='cmd /c copy /y nul $out>nul')
     master_ninja.rule(
       'copy',
       description='COPY $in $out',
-      command='cmd /c mklink /h $out $in >nul || mklink /h /j $out $in >nul || '
-              'python gyp-win-tool recursive-mirror $in $out')
+      command='python gyp-win-tool recursive-mirror $in $out')
   else:
     master_ninja.rule(
       'stamp',
       description='STAMP $out',
       command='${postbuilds}touch $out')
     master_ninja.rule(
       'copy',
       description='COPY $in $out',
       command='ln -f $in $out 2>/dev/null || (rm -rf $out && cp -af $in $out)')
   master_ninja.newline()
@@ skipping 22 matching lines @@
       gyp.xcode_emulation.MergeGlobalXcodeSettingsToSpec(data[build_file], spec)
 
     build_file = gyp.common.RelativePath(build_file, options.toplevel_dir)
 
     base_path = os.path.dirname(build_file)
     obj = 'obj'
     if toolset != 'target':
       obj += '.' + toolset
     output_file = os.path.join(obj, base_path, name + '.ninja')
 
-    abs_build_dir=os.path.abspath(os.path.join(options.toplevel_dir, build_dir))
+    abs_build_dir=os.path.abspath(top_build_dir)
     writer = NinjaWriter(target_outputs, base_path, build_dir,
-                         OpenOutput(os.path.join(options.toplevel_dir,
-                                                 build_dir,
-                                                 output_file)),
+                         OpenOutput(os.path.join(top_build_dir, output_file)),
                          flavor, abs_build_dir=abs_build_dir)
     master_ninja.subninja(output_file)
 
     target = writer.WriteSpec(spec, config_name)
     if target:
       target_outputs[qualified_target] = target
       if qualified_target in all_targets:
         all_outputs.add(target.FinalOutput())
 
   if all_outputs:
     master_ninja.build('all', 'phony', list(all_outputs))
 
 
 def GenerateOutput(target_list, target_dicts, data, params):
   if params['options'].generator_output:
     raise NotImplementedError, "--generator_output not implemented for ninja"
 
   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)