Very preliminary work for ninja on Windows

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 gyp
 import gyp.common
 import gyp.system_test
 import gyp.xcode_emulation
 import os.path
 import re
@@ skipping 58 matching lines @@
   """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('/'))
+  depth = len(path.split(os.path.sep))
   return '/'.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
@@ skipping 83 matching lines @@
     build_dir: path from source root to build output
     abs_build_dir: absolute path to the build directory
     """
 
     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'
 
     # 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
@@ skipping 148 matching lines @@
     # 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,
           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('.o')]
+      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:
       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.
@@ skipping 258 matching lines @@
       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 + '.o')
+      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)
 
     self.ninja.newline()
     return outputs
@@ skipping 318 matching lines @@
     import gyp.generator.xcode as xcode_generator
     global generator_additional_non_configuration_keys
     generator_additional_non_configuration_keys = getattr(xcode_generator,
         'generator_additional_non_configuration_keys', [])
     global generator_additional_path_sections
     generator_additional_path_sections = getattr(xcode_generator,
         'generator_additional_path_sections', [])
     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('EXECUTABLE_SUFFIX', '.exe')
+    default_variables.setdefault('STATIC_LIB_PREFIX', '')
+    default_variables.setdefault('STATIC_LIB_SUFFIX', '.lib')
+    default_variables.setdefault('SHARED_LIB_PREFIX', '')
+    default_variables.setdefault('SHARED_LIB_SUFFIX', '.dll')
   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', '$!PRODUCT_DIR/lib')
     default_variables.setdefault('LIB_DIR', '')
 
 
@@ skipping 18 matching lines @@
                            config_name)
 
   master_ninja = ninja_syntax.Writer(
       OpenOutput(os.path.join(options.toplevel_dir, 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))
 
   # Grab make settings for CC/CXX.
-  cc, cxx = 'gcc', 'g++'
+  if flavor == 'win':
+    cc = cxx = 'cl'
+  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('cc', os.environ.get('CC', cc))
   master_ninja.variable('cxx', os.environ.get('CXX', cxx))
-  master_ninja.variable('ld', flock + ' linker.lock $cxx')
+  if flavor == 'win':
+    master_ninja.variable('ld', 'link')
+  else:
+    master_ninja.variable('ld', flock + ' linker.lock $cxx')
   master_ninja.variable('cc_host', '$cc')
   master_ninja.variable('cxx_host', '$cxx')
   if flavor == 'mac':
     master_ninja.variable('mac_tool', os.path.join('.', 'gyp-mac-tool'))
   master_ninja.newline()
 
-  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')
-  if flavor != 'mac':
+  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): Decide how /showIncludes handling should work in ninja.
+    master_ninja.rule(
+      'cc',
+      description='CC $out',
+      command=('$cc /nologo $defines $includes $cflags $cflags_c '
+              '$cflags_pch_c /c $in /Fo$out'),
+      depfile='$out.d')
+    master_ninja.rule(
+      'cxx',
+      description='CXX $out',
+      command=('$cxx /nologo $defines $includes $cflags $cflags_cc '
+              '$cflags_pch_cc /c $in /Fo$out'),
+      depfile='$out.d')
+
+  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='AR $out',
+      command='lib /nologo /OUT:$out.lib $in')
+    master_ninja.rule(
+      'solink',
+      description='SOLINK $out',
+      command=('$ld /nologo /DLL $ldflags /OUT:$out.dll $in $libs'))
+    master_ninja.rule(
+      'solink_module',
+      description='SOLINK(module) $out',
+      command=('$ld /nologo /DLL $ldflags /OUT:$out.dll $in $libs'))
+    master_ninja.rule(
+      'link',
+      description='LINK $out',
+      command=('$ld /nologo $ldflags /OUT:$out.exe $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 34 matching lines @@
       command='$env $mac_tool $mactool_cmd $in $out')
     master_ninja.rule(
       'package_framework',
       description='PACKAGE FRAMEWORK $out, POSTBUILDS',
       command='$mac_tool package-framework $out $version$postbuilds '
               '&& touch $out')
   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)')
+  if flavor == 'win':
+    # TODO(scottmg): Copy fallback?
+    master_ninja.rule(
+      'copy',
+      description='COPY $in $out',
+      command='mklink /h $out $in >nul')
+  else:
+    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()
 
   all_targets = set()
   for build_file in params['build_files']:
     for target in gyp.common.AllTargets(target_list, target_dicts, build_file):
       all_targets.add(target)
   all_outputs = set()
 
   # target_outputs is a map from qualified target name to a Target object.
   target_outputs = {}
@@ skipping 42 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)