ninja windows: support msvs_quote_cmd support

pylib/gyp/msvs_emulation.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.
 
 """
 This module helps emulate Visual Studio 2008 behavior on top of other
 build systems, primarily ninja.
 """
 
+import collections
 import os
 import re
 import subprocess
 import sys
 
 import gyp.MSVSVersion
 
 windows_quoter_regex = re.compile(r'(\\*)"')
 
-def QuoteForRspFile(arg):
+def QuoteForRspFile(arg, quote_cmd=True):
   """Quote a command line argument so that it appears as one argument when
   processed via cmd.exe and parsed by CommandLineToArgvW (as is typical for
   Windows programs)."""
   # See http://goo.gl/cuFbX and http://goo.gl/dhPnp including the comment
   # threads. This is actually the quoting rules for CommandLineToArgvW, not
   # for the shell, because the shell doesn't do anything in Windows. This
   # works more or less because most programs (including the compiler, etc.)
   # use that function to handle command line arguments.
 
   # For a literal quote, CommandLineToArgvW requires 2n+1 backslashes
   # preceding it, and results in n backslashes + the quote. So we substitute
   # in 2* what we match, +1 more, plus the quote.
-  arg = windows_quoter_regex.sub(lambda mo: 2 * mo.group(1) + '\\"', arg)
+  if quote_cmd:
+    arg = windows_quoter_regex.sub(lambda mo: 2 * mo.group(1) + '\\"', arg)
 
   # %'s also need to be doubled otherwise they're interpreted as batch
   # positional arguments. Also make sure to escape the % so that they're
   # passed literally through escaping so they can be singled to just the
   # original %. Otherwise, trying to pass the literal representation that
   # looks like an environment variable to the shell (e.g. %PATH%) would fail.
   arg = arg.replace('%', '%%')
 
   # These commands are used in rsp files, so no escaping for the shell (via ^)
   # is necessary.
 
-  # Finally, wrap the whole thing in quotes so that the above quote rule
-  # applies and whitespace isn't a word break.
-  return '"' + arg + '"'
+  # As a workaround for programs that don't use CommandLineToArgvW, gyp
+  # supports msvs_quote_cmd=0, which simply disables all quoting.
+  if quote_cmd:
+    # Finally, wrap the whole thing in quotes so that the above quote rule
+    # applies and whitespace isn't a word break.
+    arg = '"' + arg + '"'
 
+  return arg
 
-def EncodeRspFileList(args):
+def EncodeRspFileList(args, quote_cmd):
   """Process a list of arguments using QuoteCmdExeArgument."""
   # Note that the first argument is assumed to be the command. Don't add
   # quotes around it because then built-ins like 'echo', etc. won't work.
   # Take care to normpath only the path in the case of 'call ../x.bat' because
   # otherwise the whole thing is incorrectly interpreted as a path and not
   # normalized correctly.
   if not args: return ''
   if args[0].startswith('call '):
     call, program = args[0].split(' ', 1)
     program = call + ' ' + os.path.normpath(program)
   else:
     program = os.path.normpath(args[0])
-  return program + ' ' + ' '.join(QuoteForRspFile(arg) for arg in args[1:])
+  return (program + ' ' +
+          ' '.join(QuoteForRspFile(arg, quote_cmd) for arg in args[1:]))
 
 
 def _GenericRetrieve(root, default, path):
   """Given a list of dictionary keys |path| and a tree of dicts |root|, find
   value at path, or return |default| if any of the path doesn't exist."""
   if not root:
     return default
   if not path:
     return root
   return _GenericRetrieve(root.get(path[0]), default, path[1:])
@@ skipping 318 matching lines @@
         os.path.join(path_to_base, self.msvs_cygwin_dirs[0]))
     cd = ('cd %s' % path_to_base).replace('\\', '/')
     args = [a.replace('\\', '/') for a in args]
     args = ["'%s'" % a.replace("'", "\\'") for a in args]
     bash_cmd = ' '.join(args)
     cmd = (
         'call "%s\\setup_env.bat" && set CYGWIN=nontsec && ' % cygwin_dir +
         'bash -c "%s ; %s"' % (cd, bash_cmd))
     return cmd
 
-  def IsRuleRunUnderCygwin(self, rule):
-    """Determine if an action should be run under cygwin. If the variable is
-    unset, or set to 1 we use cygwin."""
-    return int(rule.get('msvs_cygwin_shell',
-                        self.spec.get('msvs_cygwin_shell', 1))) != 0
+  RuleShellFlags = collections.namedtuple('RuleShellFlags', ['cygwin', 'quote'])
+
+  def GetRuleShellFlags(self, rule):
+    """Return RuleShellFlags about how the given rule should be run. This
+    includes whether it should run under cygwin (msvs_cygwin_shell), and
+    whether the commands should be quoted (msvs_quote_cmd)."""
+    # If the variable is unset, or set to 1 we use cygwin
+    cygwin = int(rule.get('msvs_cygwin_shell',
+                          self.spec.get('msvs_cygwin_shell', 1))) != 0
+    # Default to quoting. There's only a few special instances where the
+    # target command uses non-standard command line parsing and handle quotes
+    # and quote escaping differently.
+    quote_cmd = int(rule.get('msvs_quote_cmd', 1))
+    assert not (quote_cmd == 0 and cygwin == 1), \
+           'msvs_quote_cmd=0 only applicable for msvs_cygwin_shell=0'
+    return MsvsSettings.RuleShellFlags(cygwin, quote_cmd)
 
   def HasExplicitIdlRules(self, spec):
     """Determine if there's an explicit rule for idl files. When there isn't we
     need to generate implicit rules to build MIDL .idl files."""
     for rule in spec.get('rules', []):
       if rule['extension'] == 'idl' and int(rule.get('msvs_external_rule', 0)):
         return True
     return False
 
   def GetIdlBuildData(self, source, config):
@@ skipping 52 matching lines @@
   return vs.SetupScript()
 
 def ExpandMacros(string, expansions):
   """Expand $(Variable) per expansions dict. See MsvsSettings.GetVSMacroEnv
   for the canonical way to retrieve a suitable dict."""
   if '$' in string:
     for old, new in expansions.iteritems():
       assert '$(' not in new, new
       string = string.replace(old, new)
   return string