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/27 16:23:30]

This is just to prevent '/c' -> '\\c', right? Does

  if not path.startswith('/'):
    return path.replace('/', '\\')

work as well?

[scottmg, 2012/02/28 00:01:13]

I'm using that as a "raw" prefix. For example, there's free-form fields in
msvs_settings gyp fields where the contents are supposed to be pasted literally
on to the command line. (I am also using it to avoid the /c -> \c case though).

+        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 = []

[Nico, 2012/02/27 16:23:30]

Could you just add these to the GetCflags() output?

[scottmg, 2012/02/28 00:01:13]

Hmm, I'd have to duplicate the -D/-I and escaping there then? Better? It also
sort of goes in the wrong place because there's separate $cflags $includes
$defines vars.

     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()

[Nico, 2012/02/27 16:23:30]

Would it make sense to say "ninja works only with msvc2010"? How much simpler
would that make things?

[scottmg, 2012/02/28 00:01:13]

I think just this bit of code right now. (I'm actually only testing with 2008
currently). But, I agree, if we could simplify something, or some broken tool
comes up I wouldn't hesitate to kill 2008 support for ninja.

+
+    # 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_ARCITEW6432 (which

[Nico, 2012/02/27 16:23:30]

typo PROCESSOR_ARCHITEW6432

[scottmg, 2012/02/28 00:01:13]

Done.

+    # contains the actual word size of the system when running thru WOW64).
+    if (os.environ.get('PROCESSOR_ARCHITECTURE', '').find('64') >= 0 or

[Nico, 2012/02/27 16:23:30]

if ('64' in os.environ.get('PROCESSOR_ARCHITECTURE', '') or
    '64' in os.environ.get('PROCESSOR_ARCHITEW6432', '')):

[scottmg, 2012/02/28 00:01:13]

Done.

+        os.environ.get('PROCESSOR_ARCHITEW6432', '').find('64') >= 0):
+      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'))

[Nico, 2012/02/27 16:23:30]

msdn says "The default file name for the PDB has the base name of the program
and the extension .pdb.". You want your pdb file be called foo.dll.pdb?

(note to self: msdn also says that this option is ignored if /debug isn't also
present, so it's safe to append this always)

[scottmg, 2012/02/28 00:01:13]

Yeah, we currently make a bit of a mess of our pdbs because of chrome.exe and
chrome.dll's both being called chrome.pdb. I actually "should" (?) be using
msvs_settings.ProgramDatabaseFileName, but I'm not sure if I want to use that
(similar for OutputFileName for the exe). It's a bit hard to draw a distinction
between what's "windows build" and what's "visual studio build" in some of these
cases.

     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 35 matching lines @@
     master_ninja.rule(
       'package_framework',
       description='PACKAGE FRAMEWORK $out, POSTBUILDS',
       command='$mac_tool package-framework $out $version$postbuilds '
               '&& touch $out')
   if flavor == 'win':
     master_ninja.rule(
       'stamp',
       description='STAMP $out',
       command='cmd /c copy /y nul $out>nul')
-    # TODO(scottmg): Copy fallback?
     master_ninja.rule(
       'copy',
       description='COPY $in $out',
-      command='cmd /c mklink /h $out $in >nul || mklink /h /j $out $in >nul')
+      command='cmd /c mklink /h $out $in >nul || mklink /h /j $out $in >nul || '
+              'python gyp-win-tool recursive-mirror $in $out')

[Nico, 2012/02/27 16:23:30]

also needs an `svn up`

[scottmg, 2012/02/28 00:01:13]

Done.

   else:
     master_ninja.rule(
       'stamp',
       description='STAMP $out',
       command='${postbuilds}touch $out')
     master_ninja.rule(
       'copy',
       description='COPY $in $out',
       command='ln -f $in $out 2>/dev/null || (rm -rf $out && cp -af $in $out)')
   master_ninja.newline()
 
   all_targets = set()
   for build_file in params['build_files']:
-    for target in gyp.common.AllTargets(target_list, target_dicts, build_file):
+    for target in gyp.common.AllTargets(target_list,
+                                        target_dicts,
+                                        os.path.normpath(build_file)):

[Nico, 2012/02/27 16:23:30]

this looks familiar as well

[scottmg, 2012/02/28 00:01:13]

Done.

       all_targets.add(target)
   all_outputs = set()
 
   # target_outputs is a map from qualified target name to a Target object.
   target_outputs = {}
   for qualified_target in target_list:
     # qualified_target is like: third_party/icu/icu.gyp:icui18n#target
     build_file, name, toolset = \
         gyp.common.ParseQualifiedTarget(qualified_target)
 
@@ skipping 37 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)