576 строки
22 KiB
Python
576 строки
22 KiB
Python
# Copyright (c) 2013 The Chromium Authors. All rights reserved.
|
|
# Use of this source code is governed by a BSD-style license that can be
|
|
# found in the LICENSE file.
|
|
|
|
# This file copies the logic from GYP to find the MSVC configuration. It's not
|
|
# currently used because it is too slow. We will probably build this
|
|
# functionality into the C++ code in the future.
|
|
|
|
"""Handle version information related to Visual Stuio."""
|
|
|
|
import errno
|
|
import os
|
|
import re
|
|
import subprocess
|
|
import sys
|
|
|
|
class VisualStudioVersion(object):
|
|
"""Information regarding a version of Visual Studio."""
|
|
|
|
def __init__(self, short_name, description,
|
|
solution_version, project_version, flat_sln, uses_vcxproj,
|
|
path, sdk_based, default_toolset=None):
|
|
self.short_name = short_name
|
|
self.description = description
|
|
self.solution_version = solution_version
|
|
self.project_version = project_version
|
|
self.flat_sln = flat_sln
|
|
self.uses_vcxproj = uses_vcxproj
|
|
self.path = path
|
|
self.sdk_based = sdk_based
|
|
self.default_toolset = default_toolset
|
|
|
|
def ShortName(self):
|
|
return self.short_name
|
|
|
|
def Description(self):
|
|
"""Get the full description of the version."""
|
|
return self.description
|
|
|
|
def SolutionVersion(self):
|
|
"""Get the version number of the sln files."""
|
|
return self.solution_version
|
|
|
|
def ProjectVersion(self):
|
|
"""Get the version number of the vcproj or vcxproj files."""
|
|
return self.project_version
|
|
|
|
def FlatSolution(self):
|
|
return self.flat_sln
|
|
|
|
def UsesVcxproj(self):
|
|
"""Returns true if this version uses a vcxproj file."""
|
|
return self.uses_vcxproj
|
|
|
|
def ProjectExtension(self):
|
|
"""Returns the file extension for the project."""
|
|
return self.uses_vcxproj and '.vcxproj' or '.vcproj'
|
|
|
|
def Path(self):
|
|
"""Returns the path to Visual Studio installation."""
|
|
return self.path
|
|
|
|
def ToolPath(self, tool):
|
|
"""Returns the path to a given compiler tool. """
|
|
return os.path.normpath(os.path.join(self.path, "VC/bin", tool))
|
|
|
|
def DefaultToolset(self):
|
|
"""Returns the msbuild toolset version that will be used in the absence
|
|
of a user override."""
|
|
return self.default_toolset
|
|
|
|
def SetupScript(self, target_arch):
|
|
"""Returns a command (with arguments) to be used to set up the
|
|
environment."""
|
|
# Check if we are running in the SDK command line environment and use
|
|
# the setup script from the SDK if so. |target_arch| should be either
|
|
# 'x86' or 'x64'.
|
|
assert target_arch in ('x86', 'x64')
|
|
sdk_dir = os.environ.get('WindowsSDKDir')
|
|
if self.sdk_based and sdk_dir:
|
|
return [os.path.normpath(os.path.join(sdk_dir, 'Bin/SetEnv.Cmd')),
|
|
'/' + target_arch]
|
|
else:
|
|
# We don't use VC/vcvarsall.bat for x86 because vcvarsall calls
|
|
# vcvars32, which it can only find if VS??COMNTOOLS is set, which it
|
|
# isn't always.
|
|
if target_arch == 'x86':
|
|
return [os.path.normpath(
|
|
os.path.join(self.path, 'Common7/Tools/vsvars32.bat'))]
|
|
else:
|
|
assert target_arch == 'x64'
|
|
arg = 'x86_amd64'
|
|
if (os.environ.get('PROCESSOR_ARCHITECTURE') == 'AMD64' or
|
|
os.environ.get('PROCESSOR_ARCHITEW6432') == 'AMD64'):
|
|
# Use the 64-on-64 compiler if we can.
|
|
arg = 'amd64'
|
|
return [os.path.normpath(
|
|
os.path.join(self.path, 'VC/vcvarsall.bat')), arg]
|
|
|
|
|
|
def _RegistryQueryBase(sysdir, key, value):
|
|
"""Use reg.exe to read a particular key.
|
|
|
|
While ideally we might use the win32 module, we would like gyp to be
|
|
python neutral, so for instance cygwin python lacks this module.
|
|
|
|
Arguments:
|
|
sysdir: The system subdirectory to attempt to launch reg.exe from.
|
|
key: The registry key to read from.
|
|
value: The particular value to read.
|
|
Return:
|
|
stdout from reg.exe, or None for failure.
|
|
"""
|
|
# Skip if not on Windows or Python Win32 setup issue
|
|
if sys.platform not in ('win32', 'cygwin'):
|
|
return None
|
|
# Setup params to pass to and attempt to launch reg.exe
|
|
cmd = [os.path.join(os.environ.get('WINDIR', ''), sysdir, 'reg.exe'),
|
|
'query', key]
|
|
if value:
|
|
cmd.extend(['/v', value])
|
|
p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
|
# Obtain the stdout from reg.exe, reading to the end so p.returncode is valid
|
|
# Note that the error text may be in [1] in some cases
|
|
text = p.communicate()[0]
|
|
# Check return code from reg.exe; officially 0==success and 1==error
|
|
if p.returncode:
|
|
return None
|
|
return text
|
|
|
|
|
|
def _RegistryQuery(key, value=None):
|
|
"""Use reg.exe to read a particular key through _RegistryQueryBase.
|
|
|
|
First tries to launch from %WinDir%\Sysnative to avoid WoW64 redirection. If
|
|
that fails, it falls back to System32. Sysnative is available on Vista and
|
|
up and available on Windows Server 2003 and XP through KB patch 942589. Note
|
|
that Sysnative will always fail if using 64-bit python due to it being a
|
|
virtual directory and System32 will work correctly in the first place.
|
|
|
|
KB 942589 - http://support.microsoft.com/kb/942589/en-us.
|
|
|
|
Arguments:
|
|
key: The registry key.
|
|
value: The particular registry value to read (optional).
|
|
Return:
|
|
stdout from reg.exe, or None for failure.
|
|
"""
|
|
text = None
|
|
try:
|
|
text = _RegistryQueryBase('Sysnative', key, value)
|
|
except OSError, e:
|
|
if e.errno == errno.ENOENT:
|
|
text = _RegistryQueryBase('System32', key, value)
|
|
else:
|
|
raise
|
|
return text
|
|
|
|
|
|
def _RegistryGetValue(key, value):
|
|
"""Use reg.exe to obtain the value of a registry key.
|
|
|
|
Args:
|
|
key: The registry key.
|
|
value: The particular registry value to read.
|
|
Return:
|
|
contents of the registry key's value, or None on failure.
|
|
"""
|
|
text = _RegistryQuery(key, value)
|
|
if not text:
|
|
return None
|
|
# Extract value.
|
|
match = re.search(r'REG_\w+\s+([^\r]+)\r\n', text)
|
|
if not match:
|
|
return None
|
|
return match.group(1)
|
|
|
|
|
|
def _RegistryKeyExists(key):
|
|
"""Use reg.exe to see if a key exists.
|
|
|
|
Args:
|
|
key: The registry key to check.
|
|
Return:
|
|
True if the key exists
|
|
"""
|
|
if not _RegistryQuery(key):
|
|
return False
|
|
return True
|
|
|
|
|
|
def _CreateVersion(name, path, sdk_based=False):
|
|
"""Sets up MSVS project generation.
|
|
|
|
Setup is based off the GYP_MSVS_VERSION environment variable or whatever is
|
|
autodetected if GYP_MSVS_VERSION is not explicitly specified. If a version is
|
|
passed in that doesn't match a value in versions python will throw a error.
|
|
"""
|
|
if path:
|
|
path = os.path.normpath(path)
|
|
versions = {
|
|
'2013': VisualStudioVersion('2013',
|
|
'Visual Studio 2013',
|
|
solution_version='13.00',
|
|
project_version='4.0',
|
|
flat_sln=False,
|
|
uses_vcxproj=True,
|
|
path=path,
|
|
sdk_based=sdk_based,
|
|
default_toolset='v110'),
|
|
'2013e': VisualStudioVersion('2013e',
|
|
'Visual Studio 2013',
|
|
solution_version='13.00',
|
|
project_version='4.0',
|
|
flat_sln=True,
|
|
uses_vcxproj=True,
|
|
path=path,
|
|
sdk_based=sdk_based,
|
|
default_toolset='v110'),
|
|
'2012': VisualStudioVersion('2012',
|
|
'Visual Studio 2012',
|
|
solution_version='12.00',
|
|
project_version='4.0',
|
|
flat_sln=False,
|
|
uses_vcxproj=True,
|
|
path=path,
|
|
sdk_based=sdk_based,
|
|
default_toolset='v110'),
|
|
'2012e': VisualStudioVersion('2012e',
|
|
'Visual Studio 2012',
|
|
solution_version='12.00',
|
|
project_version='4.0',
|
|
flat_sln=True,
|
|
uses_vcxproj=True,
|
|
path=path,
|
|
sdk_based=sdk_based,
|
|
default_toolset='v110'),
|
|
'2010': VisualStudioVersion('2010',
|
|
'Visual Studio 2010',
|
|
solution_version='11.00',
|
|
project_version='4.0',
|
|
flat_sln=False,
|
|
uses_vcxproj=True,
|
|
path=path,
|
|
sdk_based=sdk_based),
|
|
'2010e': VisualStudioVersion('2010e',
|
|
'Visual Studio 2010',
|
|
solution_version='11.00',
|
|
project_version='4.0',
|
|
flat_sln=True,
|
|
uses_vcxproj=True,
|
|
path=path,
|
|
sdk_based=sdk_based),
|
|
'2008': VisualStudioVersion('2008',
|
|
'Visual Studio 2008',
|
|
solution_version='10.00',
|
|
project_version='9.00',
|
|
flat_sln=False,
|
|
uses_vcxproj=False,
|
|
path=path,
|
|
sdk_based=sdk_based),
|
|
'2008e': VisualStudioVersion('2008e',
|
|
'Visual Studio 2008',
|
|
solution_version='10.00',
|
|
project_version='9.00',
|
|
flat_sln=True,
|
|
uses_vcxproj=False,
|
|
path=path,
|
|
sdk_based=sdk_based),
|
|
'2005': VisualStudioVersion('2005',
|
|
'Visual Studio 2005',
|
|
solution_version='9.00',
|
|
project_version='8.00',
|
|
flat_sln=False,
|
|
uses_vcxproj=False,
|
|
path=path,
|
|
sdk_based=sdk_based),
|
|
'2005e': VisualStudioVersion('2005e',
|
|
'Visual Studio 2005',
|
|
solution_version='9.00',
|
|
project_version='8.00',
|
|
flat_sln=True,
|
|
uses_vcxproj=False,
|
|
path=path,
|
|
sdk_based=sdk_based),
|
|
}
|
|
return versions[str(name)]
|
|
|
|
|
|
def _ConvertToCygpath(path):
|
|
"""Convert to cygwin path if we are using cygwin."""
|
|
if sys.platform == 'cygwin':
|
|
p = subprocess.Popen(['cygpath', path], stdout=subprocess.PIPE)
|
|
path = p.communicate()[0].strip()
|
|
return path
|
|
|
|
|
|
def _DetectVisualStudioVersions(versions_to_check, force_express):
|
|
"""Collect the list of installed visual studio versions.
|
|
|
|
Returns:
|
|
A list of visual studio versions installed in descending order of
|
|
usage preference.
|
|
Base this on the registry and a quick check if devenv.exe exists.
|
|
Only versions 8-10 are considered.
|
|
Possibilities are:
|
|
2005(e) - Visual Studio 2005 (8)
|
|
2008(e) - Visual Studio 2008 (9)
|
|
2010(e) - Visual Studio 2010 (10)
|
|
2012(e) - Visual Studio 2012 (11)
|
|
2013(e) - Visual Studio 2013 (11)
|
|
Where (e) is e for express editions of MSVS and blank otherwise.
|
|
"""
|
|
version_to_year = {
|
|
'8.0': '2005',
|
|
'9.0': '2008',
|
|
'10.0': '2010',
|
|
'11.0': '2012',
|
|
'12.0': '2013',
|
|
}
|
|
versions = []
|
|
for version in versions_to_check:
|
|
# Old method of searching for which VS version is installed
|
|
# We don't use the 2010-encouraged-way because we also want to get the
|
|
# path to the binaries, which it doesn't offer.
|
|
keys = [r'HKLM\Software\Microsoft\VisualStudio\%s' % version,
|
|
r'HKLM\Software\Wow6432Node\Microsoft\VisualStudio\%s' % version,
|
|
r'HKLM\Software\Microsoft\VCExpress\%s' % version,
|
|
r'HKLM\Software\Wow6432Node\Microsoft\VCExpress\%s' % version]
|
|
for index in range(len(keys)):
|
|
path = _RegistryGetValue(keys[index], 'InstallDir')
|
|
if not path:
|
|
continue
|
|
path = _ConvertToCygpath(path)
|
|
# Check for full.
|
|
full_path = os.path.join(path, 'devenv.exe')
|
|
express_path = os.path.join(path, 'vcexpress.exe')
|
|
if not force_express and os.path.exists(full_path):
|
|
# Add this one.
|
|
versions.append(_CreateVersion(version_to_year[version],
|
|
os.path.join(path, '..', '..')))
|
|
# Check for express.
|
|
elif os.path.exists(express_path):
|
|
# Add this one.
|
|
versions.append(_CreateVersion(version_to_year[version] + 'e',
|
|
os.path.join(path, '..', '..')))
|
|
|
|
# The old method above does not work when only SDK is installed.
|
|
keys = [r'HKLM\Software\Microsoft\VisualStudio\SxS\VC7',
|
|
r'HKLM\Software\Wow6432Node\Microsoft\VisualStudio\SxS\VC7']
|
|
for index in range(len(keys)):
|
|
path = _RegistryGetValue(keys[index], version)
|
|
if not path:
|
|
continue
|
|
path = _ConvertToCygpath(path)
|
|
versions.append(_CreateVersion(version_to_year[version] + 'e',
|
|
os.path.join(path, '..'), sdk_based=True))
|
|
|
|
return versions
|
|
|
|
|
|
def SelectVisualStudioVersion(version='auto'):
|
|
"""Select which version of Visual Studio projects to generate.
|
|
|
|
Arguments:
|
|
version: Hook to allow caller to force a particular version (vs auto).
|
|
Returns:
|
|
An object representing a visual studio project format version.
|
|
"""
|
|
# In auto mode, check environment variable for override.
|
|
if version == 'auto':
|
|
version = os.environ.get('GYP_MSVS_VERSION', 'auto')
|
|
version_map = {
|
|
'auto': ('10.0', '9.0', '8.0', '11.0'),
|
|
'2005': ('8.0',),
|
|
'2005e': ('8.0',),
|
|
'2008': ('9.0',),
|
|
'2008e': ('9.0',),
|
|
'2010': ('10.0',),
|
|
'2010e': ('10.0',),
|
|
'2012': ('11.0',),
|
|
'2012e': ('11.0',),
|
|
'2013': ('12.0',),
|
|
'2013e': ('12.0',),
|
|
}
|
|
override_path = os.environ.get('GYP_MSVS_OVERRIDE_PATH')
|
|
if override_path:
|
|
msvs_version = os.environ.get('GYP_MSVS_VERSION')
|
|
if not msvs_version or 'e' not in msvs_version:
|
|
raise ValueError('GYP_MSVS_OVERRIDE_PATH requires GYP_MSVS_VERSION to be '
|
|
'set to an "e" version (e.g. 2010e)')
|
|
return _CreateVersion(msvs_version, override_path, sdk_based=True)
|
|
version = str(version)
|
|
versions = _DetectVisualStudioVersions(version_map[version], 'e' in version)
|
|
if not versions:
|
|
if version == 'auto':
|
|
# Default to 2005 if we couldn't find anything
|
|
return _CreateVersion('2005', None)
|
|
else:
|
|
return _CreateVersion(version, None)
|
|
return versions[0]
|
|
|
|
def GenerateEnvironmentFiles(toplevel_build_dir, generator_flags, open_out):
|
|
"""It's not sufficient to have the absolute path to the compiler, linker,
|
|
etc. on Windows, as those tools rely on .dlls being in the PATH. We also
|
|
need to support both x86 and x64 compilers within the same build (to support
|
|
msvs_target_platform hackery). Different architectures require a different
|
|
compiler binary, and different supporting environment variables (INCLUDE,
|
|
LIB, LIBPATH). So, we extract the environment here, wrap all invocations
|
|
of compiler tools (cl, link, lib, rc, midl, etc.) via win_tool.py which
|
|
sets up the environment, and then we do not prefix the compiler with
|
|
an absolute path, instead preferring something like "cl.exe" in the rule
|
|
which will then run whichever the environment setup has put in the path.
|
|
When the following procedure to generate environment files does not
|
|
meet your requirement (e.g. for custom toolchains), you can pass
|
|
"-G ninja_use_custom_environment_files" to the gyp to suppress file
|
|
generation and use custom environment files prepared by yourself."""
|
|
archs = ('x86', 'x64')
|
|
if generator_flags.get('ninja_use_custom_environment_files', 0):
|
|
cl_paths = {}
|
|
for arch in archs:
|
|
cl_paths[arch] = 'cl.exe'
|
|
return cl_paths
|
|
vs = GetVSVersion(generator_flags)
|
|
cl_paths = {}
|
|
for arch in archs:
|
|
# Extract environment variables for subprocesses.
|
|
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()
|
|
|
|
# Find cl.exe location for this architecture.
|
|
args = vs.SetupScript(arch)
|
|
args.extend(('&&',
|
|
'for', '%i', 'in', '(cl.exe)', 'do', '@echo', 'LOC:%~$PATH:i'))
|
|
popen = subprocess.Popen(args, shell=True, stdout=subprocess.PIPE)
|
|
output, _ = popen.communicate()
|
|
cl_paths[arch] = _ExtractCLPath(output)
|
|
return cl_paths
|
|
|
|
def OpenOutput(path, mode='w'):
|
|
"""Open |path| for writing, creating directories if necessary."""
|
|
try:
|
|
os.makedirs(os.path.dirname(path))
|
|
except OSError:
|
|
pass
|
|
return open(path, mode)
|
|
|
|
vs_version = None
|
|
def GetVSVersion(generator_flags):
|
|
global vs_version
|
|
if not vs_version:
|
|
vs_version = SelectVisualStudioVersion(
|
|
generator_flags.get('msvs_version', 'auto'))
|
|
return vs_version
|
|
|
|
def _ExtractImportantEnvironment(output_of_set):
|
|
"""Extracts environment variables required for the toolchain to run from
|
|
a textual dump output by the cmd.exe 'set' command."""
|
|
envvars_to_save = (
|
|
'goma_.*', # TODO(scottmg): This is ugly, but needed for goma.
|
|
'include',
|
|
'lib',
|
|
'libpath',
|
|
'path',
|
|
'pathext',
|
|
'systemroot',
|
|
'temp',
|
|
'tmp',
|
|
)
|
|
env = {}
|
|
for line in output_of_set.splitlines():
|
|
for envvar in envvars_to_save:
|
|
if re.match(envvar + '=', line.lower()):
|
|
var, setting = line.split('=', 1)
|
|
if envvar == 'path':
|
|
# Our own rules (for running gyp-win-tool) and other actions in
|
|
# Chromium rely on python being in the path. Add the path to this
|
|
# python here so that if it's not in the path when ninja is run
|
|
# later, python will still be found.
|
|
setting = os.path.dirname(sys.executable) + os.pathsep + setting
|
|
env[var.upper()] = setting
|
|
break
|
|
for required in ('SYSTEMROOT', 'TEMP', 'TMP'):
|
|
if required not in env:
|
|
raise Exception('Environment variable "%s" '
|
|
'required to be set to valid path' % required)
|
|
return env
|
|
|
|
def _FormatAsEnvironmentBlock(envvar_dict):
|
|
"""Format as an 'environment block' directly suitable for CreateProcess.
|
|
Briefly this is a list of key=value\0, terminated by an additional \0. See
|
|
CreateProcess documentation for more details."""
|
|
block = ''
|
|
nul = '\0'
|
|
for key, value in envvar_dict.iteritems():
|
|
block += key + '=' + value + nul
|
|
block += nul
|
|
return block
|
|
|
|
|
|
def GenerateEnvironmentFiles(toplevel_build_dir, generator_flags):
|
|
"""It's not sufficient to have the absolute path to the compiler, linker,
|
|
etc. on Windows, as those tools rely on .dlls being in the PATH. We also
|
|
need to support both x86 and x64 compilers within the same build (to support
|
|
msvs_target_platform hackery). Different architectures require a different
|
|
compiler binary, and different supporting environment variables (INCLUDE,
|
|
LIB, LIBPATH). So, we extract the environment here, wrap all invocations
|
|
of compiler tools (cl, link, lib, rc, midl, etc.) via win_tool.py which
|
|
sets up the environment, and then we do not prefix the compiler with
|
|
an absolute path, instead preferring something like "cl.exe" in the rule
|
|
which will then run whichever the environment setup has put in the path.
|
|
When the following procedure to generate environment files does not
|
|
meet your requirement (e.g. for custom toolchains), you can pass
|
|
"-G ninja_use_custom_environment_files" to the gyp to suppress file
|
|
generation and use custom environment files prepared by yourself."""
|
|
archs = ('x86', 'x64')
|
|
if generator_flags.get('ninja_use_custom_environment_files', 0):
|
|
cl_paths = {}
|
|
for arch in archs:
|
|
cl_paths[arch] = 'cl.exe'
|
|
return cl_paths
|
|
vs = GetVSVersion(generator_flags)
|
|
cl_paths = {}
|
|
for arch in archs:
|
|
# Extract environment variables for subprocesses.
|
|
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 = OpenOutput(os.path.join(toplevel_build_dir, 'environment.' + arch), 'wb')
|
|
f.write(env_block)
|
|
f.close()
|
|
|
|
# Find cl.exe location for this architecture.
|
|
args = vs.SetupScript(arch)
|
|
args.extend(('&&',
|
|
'for', '%i', 'in', '(cl.exe)', 'do', '@echo', 'LOC:%~$PATH:i'))
|
|
popen = subprocess.Popen(args, shell=True, stdout=subprocess.PIPE)
|
|
output, _ = popen.communicate()
|
|
cl_paths[arch] = _ExtractCLPath(output)
|
|
return cl_paths
|
|
|
|
def _ExtractCLPath(output_of_where):
|
|
"""Gets the path to cl.exe based on the output of calling the environment
|
|
setup batch file, followed by the equivalent of `where`."""
|
|
# Take the first line, as that's the first found in the PATH.
|
|
for line in output_of_where.strip().splitlines():
|
|
if line.startswith('LOC:'):
|
|
return line[len('LOC:'):].strip()
|
|
|
|
#print SelectVisualStudioVersion().DefaultToolset()
|
|
#GenerateEnvironmentFiles("D:\\src\\src1\\src\\out\\gn\\eraseme", {})
|
|
#print '"', GetVSVersion({}).Path(), '"'
|
|
print '"', GetVSVersion({}).sdk_based, '"'
|
|
|
|
#-------------------------------------------------------------------------------
|
|
|
|
version_info = {
|
|
'2010': {
|
|
'includes': [
|
|
'VC\\atlmfc\\include',
|
|
],
|
|
},
|
|
}
|