More slash fixes for Windows ninja, and some work on actions.

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 59 matching lines @@
   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 '/'.join(['..'] * depth)
+  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)
@@ skipping 103 matching lines @@
     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))
 
@@ skipping 690 matching lines @@
     # dir, and everything else goes into the normal place.
     type_in_output_root = ['executable', 'loadable_module']
     if self.flavor == 'mac' and self.toolset == 'target':
       type_in_output_root += ['shared_library', 'static_library']
 
     if type in type_in_output_root:
       return filename
     elif type == 'shared_library':
       libdir = 'lib'
       if self.toolset != 'target':
-        libdir = 'lib/%s' % self.toolset
+        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={}):
     """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[:]
 
     # 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.
-    cd = 'cd %s; ' % self.build_to_base
+    if self.flavor == 'win':
+      cd = 'cmd /s /c "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)
-    command = gyp.common.EncodePOSIXShellList(args)
+    if self.flavor == 'win':
+      # TODO(scottmg): Really don't want encourage cygwin, but I'm not sure
+      # how much sh is depended upon. For now, double quote args to make most
+      # things work.

[Evan Martin, 2012/02/16 16:10:33]

I think there's a gyp attribute related to whether cygwin is required for a
given attribute.  Grep for cygwin in *.gyp*.

+      command = args[0] + ' "' + '" "'.join(args[1:]) + '""'
+    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
     # restat=1 to ninja.
     self.ninja.rule(rule_name, command, description, restat=True)
@@ skipping 31 matching lines @@
     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('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')
@@ skipping 94 matching lines @@
                '-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')
+      command='lib /nologo /OUT:$out $in')
     master_ninja.rule(
       'solink',
       description='SOLINK $out',
       command=('$ld /nologo /DLL $ldflags /OUT:$out $in $libs'))
     master_ninja.rule(
       'solink_module',
       description='SOLINK(module) $out',
       command=('$ld /nologo /DLL $ldflags /OUT:$out $in $libs'))
     master_ninja.rule(
       'link',
@@ skipping 119 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)