Beginnings of some msvs_... emulation (windows ninja)

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
 import gyp.xcode_emulation
 import os.path
 import re
 import subprocess
 import sys
 
 import gyp.ninja_syntax as ninja_syntax
 
 generator_default_variables = {
@@ skipping 187 matching lines @@
         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))
-
-    if self.flavor == 'win':
-      # Don't use os.path.normpath here. Callers pass in './foo' and expect
-      # the result to be runnable, but normpath removes the prefix.
-      return path.replace('/', '\\')
     return path
 
   def ExpandRuleVariables(self, path, root, dirname, source, ext, 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
     variable references in |path| with |env|.
 
     See the above discourse on path conversions."""
     if env:
       path = gyp.xcode_emulation.ExpandEnvVars(path, env)
     if path.startswith('$!'):
-      return self.ExpandSpecial(path)
+      expanded = self.ExpandSpecial(path)
+      if self.flavor == 'win':
+        expanded = os.path.normpath(expanded)
+      return expanded
     assert '$' not in path, path
     return os.path.normpath(os.path.join(self.build_to_base, path))
 
   def GypPathToUniqueOutput(self, path, qualified=True):
     """Translate a gyp path to a ninja path for writing output.
 
     If qualified is True, qualify the resulting filename with the name
     of the target.  This is necessary when e.g. compiling the same
     path twice for two separate output targets.
 
@@ skipping 45 matching lines @@
     Returns None if there are no outputs (e.g. a settings-only 'none' type
     target)."""
 
     self.config_name = config_name
     self.name = spec['target_name']
     self.toolset = spec['toolset']
     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)
-    else:
-      self.xcode_settings = None
+    if self.flavor == 'win':
+      self.msvs_settings = gyp.msvs_emulation.MsvsSettings(spec)
 
     # 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 256 matching lines @@
 
   def WriteSources(self, config_name, config, sources, predepends,
                    precompiled_header):
     """Write build rules to compile all of |sources|."""
     if self.toolset == 'target':
       self.ninja.variable('ar', '$ar_target')
       self.ninja.variable('cc', '$cc_target')
       self.ninja.variable('cxx', '$cxx_target')
       self.ninja.variable('ld', '$ld_target')
 
+    extra_includes = []
+    extra_defines = []

[Nico, 2012/03/13 14:55:27]

nit: swap these two lines, they are used in the swapped order below

[scottmg, 2012/03/14 00:57:56]

Done.

     if self.flavor == 'mac':
       cflags = self.xcode_settings.GetCflags(config_name)
       cflags_c = self.xcode_settings.GetCflagsC(config_name)
       cflags_cc = self.xcode_settings.GetCflagsCC(config_name)
       cflags_objc = ['$cflags_c'] + \
                     self.xcode_settings.GetCflagsObjC(config_name)
       cflags_objcc = ['$cflags_cc'] + \
                      self.xcode_settings.GetCflagsObjCC(config_name)
+    elif self.flavor == 'win':
+      cflags = self.msvs_settings.GetCflags(config_name)
+      cflags_c = self.msvs_settings.GetCflagsC(config_name)
+      cflags_cc = self.msvs_settings.GetCflagsCC(config_name)
+      extra_includes = self.msvs_settings.GetSystemIncludes(config_name)
+      extra_defines = self.msvs_settings.GetComputedDefines(config_name)

[Nico, 2012/03/13 14:55:27]

nit: swap here, too

[scottmg, 2012/03/14 00:57:56]

Done.

     else:
       cflags = config.get('cflags', [])
       cflags_c = config.get('cflags_c', [])
       cflags_cc = config.get('cflags_cc', [])
 
+    defines = config.get('defines', []) + extra_defines
     self.WriteVariableList('defines',
         [QuoteShellArgument(ninja_syntax.escape('-D' + d), self.flavor)
-         for d in config.get('defines', [])])
+         for d in defines])
+    include_dirs = config.get('include_dirs', []) + extra_includes
     self.WriteVariableList('includes',
-                           ['-I' + self.GypPathToNinja(i)
-                            for i in config.get('include_dirs', [])])
+        [QuoteShellArgument('-I' + self.GypPathToNinja(i), self.flavor)
+         for i in include_dirs])
 
     pch_commands = precompiled_header.GetGchBuildCommands()
     if self.flavor == 'mac':
       self.WriteVariableList('cflags_pch_c',
                              [precompiled_header.GetInclude('c')])
       self.WriteVariableList('cflags_pch_cc',
                              [precompiled_header.GetInclude('cc')])
       self.WriteVariableList('cflags_pch_objc',
                              [precompiled_header.GetInclude('m')])
       self.WriteVariableList('cflags_pch_objcc',
@@ skipping 89 matching lines @@
       output = self.ComputeMacBundleBinaryOutput()
     else:
       output = self.ComputeOutput(spec)
       extra_bindings.append(('postbuilds',
                              self.GetPostbuildCommand(spec, output, output)))
 
     if self.flavor == 'mac':
       ldflags = self.xcode_settings.GetLdflags(config_name,
           self.ExpandSpecial(generator_default_variables['PRODUCT_DIR']),
           self.GypPathToNinja)
+    elif self.flavor == 'win':
+      ldflags = self.msvs_settings.GetLdflags(config_name,
+          self.ExpandSpecial(generator_default_variables['PRODUCT_DIR']),
+          self.GypPathToNinja)
     else:
       ldflags = config.get('ldflags', [])
     self.WriteVariableList('ldflags',
                            gyp.common.uniquer(map(self.ExpandSpecial,
                                                   ldflags)))
 
     libraries = gyp.common.uniquer(map(self.ExpandSpecial,
                                        spec.get('libraries', [])))
     if self.flavor == 'mac':
       libraries = self.xcode_settings.AdjustLibraries(libraries)
@@ skipping 280 matching lines @@
     global generator_extra_sources_for_rules
     generator_extra_sources_for_rules = getattr(xcode_generator,
         'generator_extra_sources_for_rules', [])
   elif flavor == 'win':
     default_variables.setdefault('OS', 'win')
     default_variables['EXECUTABLE_SUFFIX'] = '.exe'
     default_variables['STATIC_LIB_PREFIX'] = ''
     default_variables['STATIC_LIB_SUFFIX'] = '.lib'
     default_variables['SHARED_LIB_PREFIX'] = ''
     default_variables['SHARED_LIB_SUFFIX'] = '.dll'
+    generator_flags = params.get('generator_flags', {})
+    msvs_version = gyp.MSVSVersion.SelectVisualStudioVersion(
+        generator_flags.get('msvs_version', 'auto'))
+    # Stash msvs_version for later (so we don't have to probe the system twice).
+    params['msvs_version'] = msvs_version
+
+    # Set a variable so conditions can be based on msvs_version.
+    default_variables['MSVS_VERSION'] = msvs_version.ShortName()
+
+    # To determine processor word size on Windows, in addition to checking
+    # PROCESSOR_ARCHITECTURE (which reflects the word size of the current
+    # process), it is also necessary to check PROCESSOR_ARCHITEW6432 (which
+    # contains the actual word size of the system when running thru WOW64).
+    if ('64' in os.environ.get('PROCESSOR_ARCHITECTURE', '') or
+        '64' in os.environ.get('PROCESSOR_ARCHITEW6432', '')):
+      default_variables['MSVS_OS_BITS'] = 64
+    else:
+      default_variables['MSVS_OS_BITS'] = 32
   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',
                                  os.path.join('$!PRODUCT_DIR', 'lib'))
     default_variables.setdefault('LIB_DIR', '')
 
@@ skipping 75 matching lines @@
       depfile='$out.d')
   else:
     # TODO(scottmg): Requires deplist branch of ninja for now (for
     # /showIncludes handling).
     master_ninja.rule(
       'cc',
       description='CC $out',
       command=('cmd /c $cc /nologo /showIncludes '
                '$defines $includes $cflags $cflags_c '
                '$cflags_pch_c /c $in /Fo$out '
-               '| ninja-deplist-helper -f cl -o $out.dl'),
+               '| ninja-deplist-helper -q -f cl -o $out.dl'),
       deplist='$out.dl')
     master_ninja.rule(
       'cxx',
       description='CXX $out',
       command=('cmd /c $cxx /nologo /showIncludes '
                '$defines $includes $cflags $cflags_cc '
                '$cflags_pch_cc /c $in /Fo$out '
-               '| ninja-deplist-helper -f cl -o $out.dl'),
+               '| ninja-deplist-helper -q -f cl -o $out.dl'),
       deplist='$out.dl')
 
   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',
@@ skipping 10 matching lines @@
       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='LIB $out',
       command='lib /nologo /OUT:$out $in')
     master_ninja.rule(
       'solink',
       description='LINK(DLL) $dll',
-      command=('$ld /nologo /IMPLIB:$implib /DLL $ldflags /OUT:$dll $in $libs'))
+      command=('$ld /nologo /IMPLIB:$implib /DLL $ldflags /OUT:$dll '
+               '/PDB:$dll.pdb $in $libs'))
     master_ninja.rule(
       'solink_module',
       description='LINK(DLL) $dll',
-      command=('$ld /nologo /IMPLIB:$implib /DLL $ldflags /OUT:$dll $in $libs'))
+      command=('$ld /nologo /IMPLIB:$implib /DLL $ldflags /OUT:$dll '
+               '/PDB:$dll.pdb $in $libs'))
     master_ninja.rule(
       'link',
       description='LINK $out',
-      command=('$ld /nologo $ldflags /OUT:$out $in $libs'))
+      command=('$ld /nologo $ldflags /OUT:$out /PDB:$out.pdb $in $libs'))
   else:
     master_ninja.rule(
       'objc',
       description='OBJC $out',
       command=('$cc -MMD -MF $out.d $defines $includes $cflags $cflags_objc '
                '$cflags_pch_objc -c $in -o $out'),
       depfile='$out.d')
     master_ninja.rule(
       'objcxx',
       description='OBJCXX $out',
@@ skipping 113 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)