ninja windows: support msvs_quote_cmd support

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 475 matching lines @@
     env = self.GetXcodeEnv()
     if self.flavor == 'win':
       env = self.msvs_settings.GetVSMacroEnv('$!PRODUCT_DIR')
     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)
-      is_cygwin = (self.msvs_settings.IsRuleRunUnderCygwin(action)
-                   if self.flavor == 'win' else False)
+      win_shell_flags = (self.msvs_settings.GetRuleShellFlags(action)
+                         if self.flavor == 'win' else None)
       args = action['action']
       args = [self.msvs_settings.ConvertVSMacros(arg, self.base_to_build)
               for arg in args] if self.flavor == 'win' else args
       rule_name = self.WriteNewNinjaRule(name, args, description,
-                                         is_cygwin, env=env)
+                                         win_shell_flags, 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):
     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)
-      is_cygwin = (self.msvs_settings.IsRuleRunUnderCygwin(rule)
-                   if self.flavor == 'win' else False)
+      win_shell_flags = (self.msvs_settings.GetRuleShellFlags(rule)
+                         if self.flavor == 'win' else None)
       args = [self.msvs_settings.ConvertVSMacros(arg, self.base_to_build)
               for arg in args] if self.flavor == 'win' else args
-      rule_name = self.WriteNewNinjaRule(name, args, description, is_cygwin)
+      rule_name = self.WriteNewNinjaRule(
+          name, args, description, win_shell_flags)
 
       # 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:
+        if win_shell_flags and win_shell_flags.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,
@@ skipping 494 matching lines @@
       return os.path.join(libdir, filename)
     else:
       return self.GypPathToUniqueOutput(filename, qualified=False)
 
   def WriteVariableList(self, var, values):
     assert not isinstance(values, str)
     if values is None:
       values = []
     self.ninja.variable(var, ' '.join(values))
 
-  def WriteNewNinjaRule(self, name, args, description, is_cygwin, env={}):
+  def WriteNewNinjaRule(self, name, args, description, win_shell_flags, 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.translate(string.maketrans(' ()', '___'))
 
     args = args[:]
 
     if self.flavor == 'win':
       description = self.msvs_settings.ConvertVSMacros(description)
 
     # 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 "'
-      if not is_cygwin:
+      if not win_shell_flags.cygwin:
         # cd command added by BuildCygwinBashCommandLine in cygwin case.
         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' else ''
     if self.flavor == 'win':
-      if is_cygwin:
+      if win_shell_flags.cygwin:
         command = self.msvs_settings.BuildCygwinBashCommandLine(
             args, self.build_to_base)
       else:
         # If there's no command, fake one to match the dangling |&&| above.
-        command = gyp.msvs_emulation.EncodeRspFileList(args) or 'cmd /c'
+        command = gyp.msvs_emulation.EncodeRspFileList(
+            args, win_shell_flags.quote) or 'cmd /c'
       command += '"' # Close quote opened in |cd|.
     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.
@@ skipping 373 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)