ninja windows: fix expansion of some VS macros

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 182 matching lines @@
     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'
 
     # 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 _WinCase(self, path):

[Nico, 2012/04/25 23:18:23]

Method name is improvable, also docstring

[scottmg, 2012/04/26 03:06:46]

Turns out it already exists as os.path.normcase!

+    if self.flavor == 'win':
+      path = path.lower()

[Nico, 2012/04/25 23:18:23]

Maybe kernel32.GetLongPathName(kernel32.GetShortPathName(file_path)) to get the
"native" case?

+    return path
+
   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:
@@ skipping 30 matching lines @@
 
     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)
+        expanded = self._WinCase(os.path.normpath(expanded))
       return expanded
     assert '$' not in path, path
-    return os.path.normpath(os.path.join(self.build_to_base, path))
+    return self._WinCase(
+        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."""
 
@@ skipping 11 matching lines @@
     #    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))
+    return self._WinCase(
+        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
@@ skipping 109 matching lines @@
         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
+      return self._WinCase(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):
@@ skipping 60 matching lines @@
       # 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)
                    if self.flavor == 'win' else False)
       rule_name = self.WriteNewNinjaRule(name, action['action'], description,
                                          is_cygwin, env=env)
 
-      inputs = [self.GypPathToNinja(i, env) for i in action['inputs']]
+      def reldir(path):
+        qualified = os.path.join(self.build_dir, path)
+        return self._WinCase(
+            os.path.normpath(os.path.relpath(qualified, self.build_dir)))

[Nico, 2012/04/25 23:18:23]

What does this do?

[scottmg, 2012/04/26 03:06:46]

Makes one's head hurt. :/

It was trying to be a build-dir-relative-normpath. Because the actions run in
the base dir, they have to be gyp->ninja'd, and when the paths contain VS
$(OutDir) macros, they ended up looking like "..\..\out\Debug\BLAH", when they
should just be "BLAH".  So this function was compensating for that. But, a much
better fix is to not retrieve a base-relative environment above instead (but
instead make it build-relative). So, it's gone now, thankfully.

In short: OMG WAT.

Also added to test for this.

+
+      inputs = [reldir(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']]
+      outputs = [reldir(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
 
@@ skipping 143 matching lines @@
       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('pdbname', [self.name.lower() + '.pdb'])
     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 defines])
     if self.flavor == 'win':
@@ skipping 311 matching lines @@
 
     if 'product_name' in spec:
       # If we were given an explicit name, use that.
       target = spec['product_name']
     else:
       # Otherwise, derive a name from the target name.
       target = spec['target_name']
       if prefix == 'lib':
         # Snip out an extra 'lib' from libs if appropriate.
         target = StripPrefix(target, 'lib')
+    target = self._WinCase(target)
 
     if type in ('static_library', 'loadable_module', 'shared_library',
                         'executable'):
       return '%s%s%s' % (prefix, target, extension)
     elif type == 'none':
       return '%s.stamp' % target
     else:
       raise 'Unhandled output type', type
 
   def ComputeOutput(self, spec, type=None):
     """Compute the path for the final output of the spec."""
     assert not self.is_mac_bundle or type
 
     if not type:
       type = spec['type']
 
     if self.flavor == 'win':
       overridden_name = self.msvs_settings.GetOutputName(spec, self.config_name)
       if overridden_name:
-        return self.ExpandSpecial(overridden_name, self.base_to_build)
+        return self._WinCase(
+            self.ExpandSpecial(overridden_name, self.base_to_build))
 
     if self.flavor == 'mac' and type in (
         'static_library', 'executable', 'shared_library', 'loadable_module'):
       filename = self.xcode_settings.GetExecutablePath()
     else:
       filename = self.ComputeOutputFileName(spec, type)
 
     if 'product_dir' in spec:
       path = os.path.join(spec['product_dir'], filename)
       return self.ExpandSpecial(path)
@@ skipping 160 matching lines @@
   out.write('@call "%s"\n' % vsvars_path)
   out.close()
 
 
 def GenerateOutputForConfig(target_list, target_dicts, data, params,
                             config_name):
   options = params['options']
   flavor = gyp.common.GetFlavor(params)
   generator_flags = params.get('generator_flags', {})
 
+  def wincase(path):

[Nico, 2012/04/25 23:18:23]

Make the function at the top global, then you don't need this. Maybe even move
it to msvs_emul

+    if flavor == 'win':
+      path = path.lower()
+    return path
+
   # 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)
 
-  toplevel_build = os.path.join(options.toplevel_dir, build_dir)
+  toplevel_build = wincase(os.path.join(options.toplevel_dir, build_dir))
 
   master_ninja = ninja_syntax.Writer(
       OpenOutput(os.path.join(toplevel_build, 'build.ninja')),
       width=120)
 
   # Put build-time support tools in out/{config_name}.
   gyp.common.CopyTool(flavor, toplevel_build)
 
   # Grab make settings for CC/CXX.
   if flavor == 'win':
@@ skipping 53 matching lines @@
       depfile='$out.d')
   else:
     # TODO(scottmg): Requires fork of ninja for dependency and linking
     # support: https://github.com/sgraham/ninja
     master_ninja.rule(
       'cc',
       description='CC $out',
       command=('cmd /s /c "$cc /nologo /showIncludes '
                '@$out.rsp '
                '$cflags_pch_c /c $in /Fo$out /Fd$pdbname '
-               '| ninja-deplist-helper -q -f cl -o $out.dl"'),
+               '| ninja-deplist-helper -r . -q -f cl -o $out.dl"'),
       deplist='$out.dl',
       rspfile='$out.rsp',
       rspfile_content='$defines $includes $cflags $cflags_c')
     master_ninja.rule(
       'cxx',
       description='CXX $out',
       command=('cmd /s /c "$cxx /nologo /showIncludes '
                '@$out.rsp '
                '$cflags_pch_cc /c $in /Fo$out /Fd$pdbname '
-               '| ninja-deplist-helper -q -f cl -o $out.dl"'),
+               '| ninja-deplist-helper -r . -q -f cl -o $out.dl"'),
       deplist='$out.dl',
       rspfile='$out.rsp',
       rspfile_content='$defines $includes $cflags $cflags_cc')
     master_ninja.rule(
       'idl',
       description='IDL $in',
       command=('python gyp-win-tool midl-wrapper $outdir '
                '$tlb $h $dlldata $iid $proxy $in '
                '$idlflags'))
     master_ninja.rule(
@@ skipping 139 matching lines @@
     spec = target_dicts[qualified_target]
     if flavor == 'mac':
       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')
+    output_file = wincase(os.path.join(obj, base_path, name + '.ninja'))
 
     abs_build_dir = os.path.abspath(toplevel_build)
     writer = NinjaWriter(target_outputs, base_path, build_dir,
                          OpenOutput(os.path.join(toplevel_build, output_file)),
                          flavor, abs_build_dir=abs_build_dir)
     master_ninja.subninja(output_file)
 
     target = writer.WriteSpec(spec, config_name, generator_flags)
     if target:
       target_outputs[qualified_target] = target
@@ skipping 10 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)