Get ninja working for nacl.

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 232 matching lines @@
     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))
     return path
 
   def ExpandRuleVariables(self, path, root, dirname, source, ext, name):
     if self.flavor == 'win':
-      path = self.msvs_settings.ConvertVSMacros(path)
+      path = self.msvs_settings.ConvertVSMacros(
+          path, config=self.config_name)
     path = path.replace(generator_default_variables['RULE_INPUT_ROOT'], root)
     path = path.replace(generator_default_variables['RULE_INPUT_DIRNAME'],
                         dirname)
     path = path.replace(generator_default_variables['RULE_INPUT_PATH'], source)
     path = path.replace(generator_default_variables['RULE_INPUT_EXT'], ext)
     path = path.replace(generator_default_variables['RULE_INPUT_NAME'], name)
     return path
 
   def GypPathToNinja(self, path, env=None):
     """Translate a gyp path to a ninja path, optionally expanding environment
@@ skipping 74 matching lines @@
     config = spec['configurations'][config_name]
     self.target = Target(spec['type'])
 
     self.is_mac_bundle = gyp.xcode_emulation.IsMacBundle(self.flavor, spec)
     self.xcode_settings = self.msvs_settings = None
     if self.flavor == 'mac':
       self.xcode_settings = gyp.xcode_emulation.XcodeSettings(spec)
     if self.flavor == 'win':
       self.msvs_settings = gyp.msvs_emulation.MsvsSettings(spec,
                                                            generator_flags)
-      # TODO(scottmg): x64 support.
-      self.ninja.variable('arch', self.win_env['x86'])
+      target_platform = self.msvs_settings.GetTargetPlatform(config_name)
+      self.ninja.variable('arch', self.win_env[target_platform])
 
     # Compute predepends for all rules.
     # actions_depends is the dependencies this target depends on before running
     # any of its action/rule/copy steps.
     # compile_depends is the dependencies this target depends on before running
     # any of its compile steps.
     actions_depends = []
     compile_depends = []
     # TODO(evan): it is rather confusing which things are lists and which
     # are strings.  Fix these.
@@ skipping 140 matching lines @@
     if message:
       return '%s %s' % (verb, self.ExpandSpecial(message))
     else:
       return '%s %s: %s' % (verb, self.name, fallback)
 
   def WriteActions(self, actions, extra_sources, prebuild,
                    extra_mac_bundle_resources):
     # Actions cd into the base directory.
     env = self.GetSortedXcodeEnv()
     if self.flavor == 'win':
-      env = self.msvs_settings.GetVSMacroEnv('$!PRODUCT_DIR')
+      env = self.msvs_settings.GetVSMacroEnv(
+          '$!PRODUCT_DIR', config=self.config_name)
     all_outputs = []
     for action in actions:
       # First write out a rule for the action.
       name = '%s_%s' % (action['action_name'],
                         hashlib.md5(self.qualified_target).hexdigest())
       description = self.GenerateDescription('ACTION',
                                              action.get('message', None),
                                              name)
       is_cygwin = (self.msvs_settings.IsRuleRunUnderCygwin(action)
                    if self.flavor == 'win' else False)
       args = action['action']
-      args = [self.msvs_settings.ConvertVSMacros(arg, self.base_to_build)
+      args = [self.msvs_settings.ConvertVSMacros(
+                  arg, self.base_to_build, config=self.config_name)
               for arg in args] if self.flavor == 'win' else args
       rule_name = self.WriteNewNinjaRule(name, args, description,
                                          is_cygwin, 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']]
@@ skipping 17 matching lines @@
       # Skip a rule with no action and no inputs.
       if 'action' not in rule and not rule.get('rule_sources', []):
         continue
       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)
-      args = [self.msvs_settings.ConvertVSMacros(arg, self.base_to_build)
+      args = [self.msvs_settings.ConvertVSMacros(
+                  arg, self.base_to_build, config=self.config_name)
               for arg in args] if self.flavor == 'win' else args
       rule_name = self.WriteNewNinjaRule(name, args, description, is_cygwin)
 
       # 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')
@@ skipping 172 matching lines @@
                                                  cflags_objcc))
     self.ninja.newline()
     outputs = []
     for source in sources:
       filename, ext = os.path.splitext(source)
       ext = ext[1:]
       obj_ext = self.obj_ext
       if ext in ('cc', 'cpp', 'cxx'):
         command = 'cxx'
       elif ext == 'c' or (ext in ('s', 'S') and self.flavor != 'win'):
-        # TODO(scottmg): .s files won't be handled by the Windows compiler.
-        # We could add support for .asm, though that's only supported on
-        # x86. Currently not used in Chromium in favor of other third-party
-        # assemblers.
         command = 'cc'
+      elif (self.flavor == 'win' and ext == 'asm' and
+            self.msvs_settings.GetTargetPlatform(config_name) == 'Win32'):
+        # Asm files only get auto assembled for x86 (not x64).
+        command = 'asm'
+        # Add the _asm suffix as msvs is capable of handling .cc and
+        # .asm files of the same name without collision.
+        obj_ext = '_asm.obj'
       elif self.flavor == 'mac' and ext == 'm':
         command = 'objc'
       elif self.flavor == 'mac' and ext == 'mm':
         command = 'objcxx'
       elif self.flavor == 'win' and ext == 'rc':
         command = 'rc'
         obj_ext = '.res'
       else:
         # Ignore unhandled extensions.
         continue
@@ skipping 334 matching lines @@
     # should be scoped to the subninja.
     rule_name = self.name
     if self.toolset == 'target':
       rule_name += '.' + self.toolset
     rule_name += '.' + name
     rule_name = re.sub('[^a-zA-Z0-9_]', '_', rule_name)
 
     args = args[:]
 
     if self.flavor == 'win':
-      description = self.msvs_settings.ConvertVSMacros(description)
+      description = self.msvs_settings.ConvertVSMacros(
+          description, config=self.config_name)
 
     # 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.
     rspfile = None
     rspfile_content = None
     args = [self.ExpandSpecial(arg, self.base_to_build) for arg in args]
     if self.flavor == 'win':
       rspfile = rule_name + '.$unique_name.rsp'
       # The cygwin case handles this inside the bash sub-shell.
@@ skipping 136 matching lines @@
   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))
   if flavor == 'win':
     master_ninja.variable('ld', 'link.exe')
     master_ninja.variable('idl', 'midl.exe')
     master_ninja.variable('ar', 'lib.exe')
     master_ninja.variable('rc', 'rc.exe')
+    master_ninja.variable('asm', 'ml.exe')
   else:
     master_ninja.variable('ld', flock + ' linker.lock $cxx')
     master_ninja.variable('ar', os.environ.get('AR', 'ar'))
 
   master_ninja.variable('ar_target', os.environ.get('AR_target', '$ar'))
   master_ninja.variable('cc_target', os.environ.get('CC_target', '$cc'))
   master_ninja.variable('cxx_target', os.environ.get('CXX_target', '$cxx'))
   if flavor == 'win':
     master_ninja.variable('ld_target', os.environ.get('LD_target', '$ld'))
   else:
@@ skipping 67 matching lines @@
       command=('%s gyp-win-tool midl-wrapper $arch $outdir '
                '$tlb $h $dlldata $iid $proxy $in '
                '$idlflags' % sys.executable))
     master_ninja.rule(
       'rc',
       description='RC $in',
       # Note: $in must be last otherwise rc.exe complains.
       command=('%s gyp-win-tool rc-wrapper '
                '$arch $rc $defines $includes $rcflags /fo$out $in' %
                sys.executable))
+    master_ninja.rule(
+      'asm',
+      description='ASM $in',
+      command=('%s gyp-win-tool asm-wrapper '
+               '$arch $asm $defines $includes /c /Fo $out $in' %
+               sys.executable))
 
   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 '
@@ skipping 179 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)