Get ninja working for nacl.

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 os
@@ skipping 127 matching lines @@
     # the WDK_DIR environment variable, may be None.
     self.wdk_dir = os.environ.get('WDK_DIR')
 
     supported_fields = [
         ('msvs_configuration_attributes', dict),
         ('msvs_settings', dict),
         ('msvs_system_include_dirs', list),
         ('msvs_disabled_warnings', list),
         ('msvs_precompiled_header', str),
         ('msvs_precompiled_source', str),
+        ('msvs_target_platform', str),
         ]
     configs = spec['configurations']
     for field, default in supported_fields:
       setattr(self, field, {})
       for configname, config in configs.iteritems():
         getattr(self, field)[configname] = config.get(field, default())
 
     self.msvs_cygwin_dirs = spec.get('msvs_cygwin_dirs', ['.'])
 
-  def GetVSMacroEnv(self, base_to_build=None):
+  def GetVSMacroEnv(self, base_to_build=None, config=None):
     """Get a dict of variables mapping internal VS macro names to their gyp
     equivalents."""
+    target_platform = self.GetTargetPlatform(config)
+    target_platform = {'x86': 'Win32'}.get(target_platform, target_platform)
     replacements = {
         '$(VSInstallDir)': self.vs_version.Path(),
         '$(VCInstallDir)': os.path.join(self.vs_version.Path(), 'VC') + '\\',
         '$(OutDir)\\': base_to_build + '\\' if base_to_build else '',
         '$(IntDir)': '$!INTERMEDIATE_DIR',
         '$(InputPath)': '${source}',
         '$(InputName)': '${root}',
         '$(ProjectName)': self.spec['target_name'],
-        '$(PlatformName)': 'Win32', # TODO(scottmg): Support for x64 toolchain.
+        '$(PlatformName)': target_platform,
     }
     # Chromium uses DXSDK_DIR in include/lib paths, but it may or may not be
     # set. This happens when the SDK is sync'd via src-internal, rather than
     # by typical end-user installation of the SDK. If it's not set, we don't
     # want to leave the unexpanded variable in the path, so simply strip it.
     replacements['$(DXSDK_DIR)'] = self.dxsdk_dir if self.dxsdk_dir else ''
     replacements['$(WDK_DIR)'] = self.wdk_dir if self.wdk_dir else ''
     return replacements
 
-  def ConvertVSMacros(self, s, base_to_build=None):
+  def ConvertVSMacros(self, s, base_to_build=None, config=None):
     """Convert from VS macro names to something equivalent."""
-    env = self.GetVSMacroEnv(base_to_build)
+    env = self.GetVSMacroEnv(base_to_build, config=config)
     return ExpandMacros(s, env)
 
   def AdjustLibraries(self, libraries):
     """Strip -l from library if it's specified with that."""
     return [lib[2:] if lib.startswith('-l') else lib for lib in libraries]
 
   def _GetAndMunge(self, field, path, default, prefix, append, map):
     """Retrieve a value from |field| at |path| or return |default|. If
     |append| is specified, and the item is found, it will be appended to that
     object instead of returned. If |map| is specified, results will be
     remapped through |map| before being returned or appended."""
     result = _GenericRetrieve(field, default, path)
     result = _DoRemapping(result, map)
     result = _AddPrefix(result, prefix)
     return _AppendOrReturn(append, result)
 
   class _GetWrapper(object):
     def __init__(self, parent, field, base_path, append=None):
       self.parent = parent
       self.field = field
       self.base_path = [base_path]
       self.append = append
     def __call__(self, name, map=None, prefix='', default=None):
       return self.parent._GetAndMunge(self.field, self.base_path + [name],
           default=default, prefix=prefix, append=self.append, map=map)
 
+  def GetTargetPlatform(self, config):
+    target_platform = self.msvs_target_platform.get(config, '')
+    if not target_platform:
+      target_platform = 'Win32'
+    return {'Win32': 'x86'}.get(target_platform, target_platform)
+
+  def _RealConfig(self, config):
+    target_platform = self.GetTargetPlatform(config)
+    if target_platform == 'x64' and not config.endswith('_x64'):
+      config += '_x64'
+    return config
+
   def _Setting(self, path, config,
               default=None, prefix='', append=None, map=None):
     """_GetAndMunge for msvs_settings."""
+    config = self._RealConfig(config)
     return self._GetAndMunge(
         self.msvs_settings[config], path, default, prefix, append, map)
 
   def _ConfigAttrib(self, path, config,
                    default=None, prefix='', append=None, map=None):
     """_GetAndMunge for msvs_configuration_attributes."""
+    config = self._RealConfig(config)
     return self._GetAndMunge(
         self.msvs_configuration_attributes[config],
         path, default, prefix, append, map)
 
   def AdjustIncludeDirs(self, include_dirs, config):
     """Updates include_dirs to expand VS specific paths, and adds the system
     include dirs used for platform SDK and similar."""
+    config = self._RealConfig(config)
     includes = include_dirs + self.msvs_system_include_dirs[config]
     includes.extend(self._Setting(
       ('VCCLCompilerTool', 'AdditionalIncludeDirectories'), config, default=[]))
-    return [self.ConvertVSMacros(p) for p in includes]
+    return [self.ConvertVSMacros(p, config=config) for p in includes]
 
   def GetComputedDefines(self, config):
     """Returns the set of defines that are injected to the defines list based
     on other VS settings."""
+    config = self._RealConfig(config)
     defines = []
     if self._ConfigAttrib(['CharacterSet'], config) == '1':
       defines.extend(('_UNICODE', 'UNICODE'))
     if self._ConfigAttrib(['CharacterSet'], config) == '2':
       defines.append('_MBCS')
     defines.extend(self._Setting(
         ('VCCLCompilerTool', 'PreprocessorDefinitions'), config, default=[]))
     return defines
 
   def GetOutputName(self, config, expand_special):
     """Gets the explicitly overridden output name for a target or returns None
     if it's not overridden."""
+    config = self._RealConfig(config)
     type = self.spec['type']
     root = 'VCLibrarianTool' if type == 'static_library' else 'VCLinkerTool'
     # TODO(scottmg): Handle OutputDirectory without OutputFile.
     output_file = self._Setting((root, 'OutputFile'), config)
     if output_file:
-      output_file = expand_special(self.ConvertVSMacros(output_file))
+      output_file = expand_special(self.ConvertVSMacros(
+          output_file, config=config))
     return output_file
 
   def GetCflags(self, config):
     """Returns the flags that need to be added to .c and .cc compilations."""
+    config = self._RealConfig(config)
     cflags = []
     cflags.extend(['/wd' + w for w in self.msvs_disabled_warnings[config]])
     cl = self._GetWrapper(self, self.msvs_settings[config],
                           'VCCLCompilerTool', append=cflags)
     cl('Optimization',
        map={'0': 'd', '1': '1', '2': '2', '3': 'x'}, prefix='/O')
     cl('InlineFunctionExpansion', prefix='/Ob')
     cl('OmitFramePointers', map={'false': '-', 'true': ''}, prefix='/Oy')
     cl('FavorSizeOrSpeed', map={'1': 't', '2': 's'}, prefix='/O')
     cl('WholeProgramOptimization', map={'true': '/GL'})
@@ skipping 10 matching lines @@
         map={'0': 'T', '1': 'Td', '2': 'D', '3': 'Dd'}, prefix='/M')
     cl('ExceptionHandling', map={'1': 'sc','2': 'a'}, prefix='/EH')
     cl('AdditionalOptions', prefix='')
     # ninja handles parallelism by itself, don't have the compiler do it too.
     cflags = filter(lambda x: not x.startswith('/MP'), cflags)
     return cflags
 
   def GetPrecompiledHeader(self, config, gyp_to_build_path):
     """Returns an object that handles the generation of precompiled header
     build steps."""
+    config = self._RealConfig(config)
     return _PchHelper(self, config, gyp_to_build_path)
 
   def _GetPchFlags(self, config, extension):
     """Get the flags to be added to the cflags for precompiled header support.
     """
+    config = self._RealConfig(config)
     # The PCH is only built once by a particular source file. Usage of PCH must
     # only be for the same language (i.e. C vs. C++), so only include the pch
     # flags when the language matches.
     if self.msvs_precompiled_header[config]:
       source_ext = os.path.splitext(self.msvs_precompiled_source[config])[1]
       if _LanguageMatchesForPch(source_ext, extension):
         pch = os.path.split(self.msvs_precompiled_header[config])[1]
         return ['/Yu' + pch, '/FI' + pch, '/Fp${pchprefix}.' + pch + '.pch']
     return  []
 
   def GetCflagsC(self, config):
     """Returns the flags that need to be added to .c compilations."""
+    config = self._RealConfig(config)
     return self._GetPchFlags(config, '.c')
 
   def GetCflagsCC(self, config):
     """Returns the flags that need to be added to .cc compilations."""
+    config = self._RealConfig(config)
     return ['/TP'] + self._GetPchFlags(config, '.cc')
 
   def _GetAdditionalLibraryDirectories(self, root, config, gyp_to_build_path):
     """Get and normalize the list of paths in AdditionalLibraryDirectories
     setting."""
+    config = self._RealConfig(config)
     libpaths = self._Setting((root, 'AdditionalLibraryDirectories'),
                              config, default=[])
-    libpaths = [os.path.normpath(gyp_to_build_path(self.ConvertVSMacros(p)))
+    libpaths = [os.path.normpath(
+                    gyp_to_build_path(self.ConvertVSMacros(p, config=config)))
                 for p in libpaths]
     return ['/LIBPATH:"' + p + '"' for p in libpaths]
 
   def GetLibFlags(self, config, gyp_to_build_path):
     """Returns the flags that need to be added to lib commands."""
+    config = self._RealConfig(config)
     libflags = []
     lib = self._GetWrapper(self, self.msvs_settings[config],
                           'VCLibrarianTool', append=libflags)
     libflags.extend(self._GetAdditionalLibraryDirectories(
         'VCLibrarianTool', config, gyp_to_build_path))
     lib('AdditionalOptions')
     return libflags
 
   def _GetDefFileAsLdflags(self, spec, ldflags, gyp_to_build_path):
     """.def files get implicitly converted to a ModuleDefinitionFile for the
     linker in the VS generator. Emulate that behaviour here."""
     def_file = ''
     if spec['type'] in ('shared_library', 'loadable_module', 'executable'):
       def_files = [s for s in spec.get('sources', []) if s.endswith('.def')]
       if len(def_files) == 1:
         ldflags.append('/DEF:"%s"' % gyp_to_build_path(def_files[0]))
       elif len(def_files) > 1:
         raise Exception("Multiple .def files")
 
   def GetLdflags(self, config, gyp_to_build_path, expand_special):
     """Returns the flags that need to be added to link commands."""
+    config = self._RealConfig(config)
     ldflags = []
     ld = self._GetWrapper(self, self.msvs_settings[config],
                           'VCLinkerTool', append=ldflags)
     self._GetDefFileAsLdflags(self.spec, ldflags, gyp_to_build_path)
     ld('GenerateDebugInformation', map={'true': '/DEBUG'})
     ld('TargetMachine', map={'1': 'X86', '17': 'X64'}, prefix='/MACHINE:')
     ldflags.extend(self._GetAdditionalLibraryDirectories(
         'VCLinkerTool', config, gyp_to_build_path))
     ld('DelayLoadDLLs', prefix='/DELAYLOAD:')
     out = self.GetOutputName(config, expand_special)
@@ skipping 32 matching lines @@
     # Vista or greater (which applies to the linker), the IDE defaults it on
     # unless it's explicitly off.
     if not filter(lambda x: 'NXCOMPAT' in x, ldflags):
       ldflags.append('/NXCOMPAT')
 
     return ldflags
 
   def IsUseLibraryDependencyInputs(self, config):
     """Returns whether the target should be linked via Use Library Dependency
     Inputs (using component .objs of a given .lib)."""
+    config = self._RealConfig(config)
     uldi = self._Setting(('VCLinkerTool', 'UseLibraryDependencyInputs'), config)
     return uldi == 'true'
 
   def GetRcflags(self, config, gyp_to_ninja_path):
     """Returns the flags that need to be added to invocations of the resource
     compiler."""
+    config = self._RealConfig(config)
     rcflags = []
     rc = self._GetWrapper(self, self.msvs_settings[config],
         'VCResourceCompilerTool', append=rcflags)
     rc('AdditionalIncludeDirectories', map=gyp_to_ninja_path, prefix='/I')
     rcflags.append('/I' + gyp_to_ninja_path('.'))
     rc('PreprocessorDefinitions', prefix='/d')
     # /l arg must be in hex without leading '0x'
     rc('Culture', prefix='/l', map=lambda x: hex(int(x))[2:])
     return rcflags
 
@@ skipping 27 matching lines @@
     """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):
     """Determine the implicit outputs for an idl file. Returns output
     directory, outputs, and variables and flags that are required."""
+    config = self._RealConfig(config)
     midl_get = self._GetWrapper(self, self.msvs_settings[config], 'VCMIDLTool')
     def midl(name, default=None):
-      return self.ConvertVSMacros(midl_get(name, default=default))
+      return self.ConvertVSMacros(midl_get(name, default=default),
+                                  config=config)
     tlb = midl('TypeLibraryName', default='${root}.tlb')
     header = midl('HeaderFileName', default='${root}.h')
     dlldata = midl('DLLDataFileName', default='dlldata.c')
     iid = midl('InterfaceIdentifierFileName', default='${root}_i.c')
     proxy = midl('ProxyFileName', default='${root}_p.c')
     # Note that .tlb is not included in the outputs as it is not always
     # generated depending on the content of the input idl file.
     outdir = midl('OutputDirectory', default='')
     output = [header, dlldata, iid, proxy]
     variables = [('tlb', tlb),
@@ skipping 139 matching lines @@
     args = vs.SetupScript(arch)
     args.extend(('&&', 'set'))
     popen = subprocess.Popen(
         args, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
     variables, _ = popen.communicate()
     env = _ExtractImportantEnvironment(variables)
     env_block = _FormatAsEnvironmentBlock(env)
     f = open_out(os.path.join(toplevel_build_dir, 'environment.' + arch), 'wb')
     f.write(env_block)
     f.close()