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 190 matching lines @@
     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.
+      # the result to be runnable, but normpath removes the prefix. If the
+      # variable is $! prefixed on Windows, don't modify it (used for compiler
+      # flags, etc.)
+      if path.startswith('$!'):

[Nico, 2012/02/29 19:44:18]

Almost all of this CL looks really good. The only thing I'm fairly unhappy with
is this.

This function used to do one thang, and one thang only: Strip PRODUCT_DIR and
INTERMEDIATE_DIR ("I'll come in again").

Then you added the / -> \ bit on windows, but now it's clear that's not always
desired, so now you're adding an escape for that. Which isn't terrible in
itself, but the escaped case seems to be the common path, and most of the
options in the _emulation.py file have $! prefixes.

Can you think of a way to not have $! prefixes on most flags in the
_emulation.py file? Maybe don't do the / -> \ translation in this function, but
somewhere else?

[scottmg, 2012/03/01 18:09:04]

Heresy in ExpandSpecial!
The best way would be to fix the / paths in gyp files to be \, and then the
Linux/Mac code can deal with the problem rather than implicitly having things
work. ;)

Fundamentally, the bug seems to be that strings containing both paths and flags
are treated the same way throughout the generator. Paths are specified in posix
format in gyp files, except in the VS parts, where paths use \ and flags use /.
But in the ninja generator these parts collide.

Looking at it now (actually, not so much this change, but the pipelined change
that adds the rest of the Windows-specific things
http://chromiumcodereview.appspot.com/9460049/), I wonder if perhaps it was a
mistake to try to share the code at this level. I'm wondering if pulling out
some utility functions or making it a base class would be better. The if
self.flavor == 'mac' elif self.flavor == 'win' blocks kind of suck too, not to
mention the various Cygwin and Xcode stuff that ends up in here.

Anyway, that's a lot of typing to say that I'm not sure how to avoid this
without restructuring a bunch, so I'll have to have a think.

+        return path[2:]
       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)
@@ skipping 66 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 = []
     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)
     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)