# MIT License
#
# Copyright The SCons Foundation
#
# Permission is hereby granted, free of charge, to any person obtaining
# a copy of this software and associated documentation files (the
# "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish,
# distribute, sublicense, and/or sell copies of the Software, and to
# permit persons to whom the Software is furnished to do so, subject to
# the following conditions:
#
# The above copyright notice and this permission notice shall be included
# in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

"""
MS Compilers: Visual C/C++ detection and configuration.

# TODO:
#   * supported arch for versions: for old versions of batch file without
#     argument, giving bogus argument cannot be detected, so we have to hardcode
#     this here
#   * print warning when msvc version specified but not found
#   * find out why warning do not print
#   * test on 64 bits XP +  VS 2005 (and VS 6 if possible)
#   * SDK
#   * Assembly
"""

import SCons.compat

import subprocess
import os
import platform
import sysconfig
from pathlib import Path
from string import digits as string_digits
from subprocess import PIPE
import re
from collections import (
    namedtuple,
    OrderedDict,
)
import json
from functools import cmp_to_key
import enum

import SCons.Util
import SCons.Warnings
from SCons.Tool import find_program_path

from . import common
from .common import (
    CONFIG_CACHE,
    debug,
)
from .sdk import get_installed_sdks

from . import MSVC

from .MSVC.Exceptions import (
    VisualCException,
    MSVCInternalError,
    MSVCUserError,
    MSVCArgumentError,
    MSVCToolsetVersionNotFound,
)

# external exceptions

class MSVCUnsupportedHostArch(VisualCException):
    pass

class MSVCUnsupportedTargetArch(VisualCException):
    pass

class MSVCScriptNotFound(MSVCUserError):
    pass

class MSVCUseScriptError(MSVCUserError):
    pass

class MSVCUseSettingsError(MSVCUserError):
    pass

class VSWhereUserError(MSVCUserError):
    pass

# internal exceptions

class UnsupportedVersion(VisualCException):
    pass

class BatchFileExecutionError(VisualCException):
    pass

# undefined object for dict.get() in case key exists and value is None
UNDEFINED = object()

# powershell error sending telemetry for arm32 process on arm64 host (VS2019+):
#    True:  force VSCMD_SKIP_SENDTELEMETRY=1 (if necessary)
#    False: do nothing
_ARM32_ON_ARM64_SKIP_SENDTELEMETRY = True

# MSVC 9.0 preferred query order:
#     True:  VCForPython, VisualStudio
#     False: VisualStudio, VCForPython
_VC90_Prefer_VCForPython = False

# Dict to 'canonalize' the arch
_ARCH_TO_CANONICAL = {
    "amd64"     : "amd64",
    "emt64"     : "amd64",
    "i386"      : "x86",
    "i486"      : "x86",
    "i586"      : "x86",
    "i686"      : "x86",
    "ia64"      : "ia64",      # deprecated
    "itanium"   : "ia64",      # deprecated
    "x86"       : "x86",
    "x86_64"    : "amd64",
    "arm"       : "arm",
    "arm64"     : "arm64",
    "aarch64"   : "arm64",
}

# The msvc batch files report errors via stdout.  The following
# regular expression attempts to match known msvc error messages
# written to stdout.
re_script_output_error = re.compile(
    r'^(' + r'|'.join([
        r'VSINSTALLDIR variable is not set',             # 2002-2003
        r'The specified configuration type is missing',  # 2005+
        r'Error in script usage',                        # 2005+
        r'ERROR\:',                                      # 2005+
        r'\!ERROR\!',                                    # 2015-2015
        r'\[ERROR\:',                                    # 2017+
        r'\[ERROR\]',                                    # 2017+
        r'Syntax\:',                                     # 2017+
    ]) + r')'
)

# Lists of compatible host/target combinations are derived from a set of defined
# constant data structures for each host architecture. The derived data structures
# implicitly handle the differences in full versions and express versions of visual
# studio. The host/target combination search lists are contructed in order of
# preference. The construction of the derived data structures is independent of actual
# visual studio installations.  The host/target configurations are used in both the
# initial msvc detection and when finding a valid batch file for a given host/target
# combination.
#
# HostTargetConfig description:
#
#     label:
#         Name used for identification.
#
#     host_all_hosts:
#         Defined list of compatible architectures for each host architecture.
#
#     host_all_targets:
#         Defined list of target architectures for each host architecture.
#
#     host_def_targets:
#         Defined list of default target architectures for each host architecture.
#
#     all_pairs:
#         Derived list of all host/target combination tuples.
#
#     host_target_map:
#         Derived list of all compatible host/target combinations for each
#         supported host/target combination.
#
#     host_all_targets_map:
#         Derived list of all compatible host/target combinations for each
#         supported host.  This is used in the initial check that cl.exe exists
#         in the requisite visual studio vc host/target directory for a given host.
#
#     host_def_targets_map:
#         Derived list of default compatible host/target combinations for each
#         supported host.  This is used for a given host when the user does not
#         request a target archicture.
#
#     target_host_map:
#         Derived list of compatible host/target combinations for each supported
#         target/host combination.  This is used for a given host and target when
#         the user requests a target architecture.

_HOST_TARGET_CONFIG_NT = namedtuple("HostTargetConfig", [
    # defined
    "label",                # name for debugging/output
    "host_all_hosts",       # host_all_hosts[host] -> host_list
    "host_all_targets",     # host_all_targets[host] -> target_list
    "host_def_targets",     # host_def_targets[host] -> target_list
    # derived
    "all_pairs",            # host_target_list
    "host_target_map",      # host_target_map[host][target] -> host_target_list
    "host_all_targets_map", # host_all_targets_map[host][target] -> host_target_list
    "host_def_targets_map", # host_def_targets_map[host][target] -> host_target_list
    "target_host_map",      # target_host_map[target][host] -> host_target_list
])

def _host_target_config_factory(*, label, host_all_hosts, host_all_targets, host_def_targets):

    def _make_host_target_map(all_hosts, all_targets):
        # host_target_map[host][target] -> host_target_list
        host_target_map = {}
        for host, host_list in all_hosts.items():
            host_target_map[host] = {}
            for host_platform in host_list:
                for target_platform in all_targets[host_platform]:
                    if target_platform not in host_target_map[host]:
                        host_target_map[host][target_platform] = []
                    host_target_map[host][target_platform].append((host_platform, target_platform))
        return host_target_map

    def _make_host_all_targets_map(all_hosts, host_target_map, all_targets):
        # host_all_target_map[host] -> host_target_list
        # special host key '_all_' contains all (host,target) combinations
        all = '_all_'
        host_all_targets_map = {}
        host_all_targets_map[all] = []
        for host, host_list in all_hosts.items():
            host_all_targets_map[host] = []
            for host_platform in host_list:
                # all_targets[host_platform]: all targets for compatible host
                for target in all_targets[host_platform]:
                    for host_target in host_target_map[host_platform][target]:
                        for host_key in (host, all):
                            if host_target not in host_all_targets_map[host_key]:
                                host_all_targets_map[host_key].append(host_target)
        return host_all_targets_map

    def _make_host_def_targets_map(all_hosts, host_target_map, def_targets):
        # host_def_targets_map[host] -> host_target_list
        host_def_targets_map = {}
        for host, host_list in all_hosts.items():
            host_def_targets_map[host] = []
            for host_platform in host_list:
                # def_targets[host]: default targets for true host
                for target in def_targets[host]:
                    for host_target in host_target_map[host_platform][target]:
                        if host_target not in host_def_targets_map[host]:
                            host_def_targets_map[host].append(host_target)
        return host_def_targets_map

    def _make_target_host_map(all_hosts, host_all_targets_map):
        # target_host_map[target][host] -> host_target_list
        target_host_map = {}
        for host_platform in all_hosts.keys():
            for host_target in host_all_targets_map[host_platform]:
                _, target = host_target
                if target not in target_host_map:
                    target_host_map[target] = {}
                if host_platform not in target_host_map[target]:
                    target_host_map[target][host_platform] = []
                if host_target not in target_host_map[target][host_platform]:
                    target_host_map[target][host_platform].append(host_target)
        return target_host_map

    host_target_map = _make_host_target_map(host_all_hosts, host_all_targets)
    host_all_targets_map = _make_host_all_targets_map(host_all_hosts, host_target_map, host_all_targets)
    host_def_targets_map = _make_host_def_targets_map(host_all_hosts, host_target_map, host_def_targets)
    target_host_map = _make_target_host_map(host_all_hosts, host_all_targets_map)

    all_pairs = host_all_targets_map['_all_']
    del host_all_targets_map['_all_']

    host_target_cfg = _HOST_TARGET_CONFIG_NT(
        label = label,
        host_all_hosts = dict(host_all_hosts),
        host_all_targets = host_all_targets,
        host_def_targets = host_def_targets,
        all_pairs = all_pairs,
        host_target_map = host_target_map,
        host_all_targets_map = host_all_targets_map,
        host_def_targets_map = host_def_targets_map,
        target_host_map = target_host_map,
    )

    return host_target_cfg

# 14.1 (VS2017) and later

# Given a (host, target) tuple, return a tuple containing the batch file to
# look for and a tuple of path components to find cl.exe. We can't rely on returning
# an arg to use for vcvarsall.bat, because that script will run even if given
# a host/target pair that isn't installed.
#
# Starting with 14.1 (VS2017), the batch files are located in directory
# <VSROOT>/VC/Auxiliary/Build.  The batch file name is the first value of the
# stored tuple.
#
# The build tools are organized by host and target subdirectories under each toolset
# version directory.  For example,  <VSROOT>/VC/Tools/MSVC/14.31.31103/bin/Hostx64/x64.
# The cl path fragment under the toolset version folder is the second value of
# the stored tuple.

# 14.3 (VS2022) and later

_GE2022_HOST_TARGET_BATCHFILE_CLPATHCOMPS = {

    ('amd64', 'amd64') : ('vcvars64.bat',          ('bin', 'Hostx64', 'x64')),
    ('amd64', 'x86')   : ('vcvarsamd64_x86.bat',   ('bin', 'Hostx64', 'x86')),
    ('amd64', 'arm')   : ('vcvarsamd64_arm.bat',   ('bin', 'Hostx64', 'arm')),
    ('amd64', 'arm64') : ('vcvarsamd64_arm64.bat', ('bin', 'Hostx64', 'arm64')),

    ('x86',   'amd64') : ('vcvarsx86_amd64.bat',   ('bin', 'Hostx86', 'x64')),
    ('x86',   'x86')   : ('vcvars32.bat',          ('bin', 'Hostx86', 'x86')),
    ('x86',   'arm')   : ('vcvarsx86_arm.bat',     ('bin', 'Hostx86', 'arm')),
    ('x86',   'arm64') : ('vcvarsx86_arm64.bat',   ('bin', 'Hostx86', 'arm64')),

    ('arm64', 'amd64') : ('vcvarsarm64_amd64.bat', ('bin', 'Hostarm64', 'arm64_amd64')),
    ('arm64', 'x86')   : ('vcvarsarm64_x86.bat',   ('bin', 'Hostarm64', 'arm64_x86')),
    ('arm64', 'arm')   : ('vcvarsarm64_arm.bat',   ('bin', 'Hostarm64', 'arm64_arm')),
    ('arm64', 'arm64') : ('vcvarsarm64.bat',       ('bin', 'Hostarm64', 'arm64')),

}

_GE2022_HOST_TARGET_CFG = _host_target_config_factory(

    label = 'GE2022',

    host_all_hosts = OrderedDict([
        ('amd64', ['amd64', 'x86']),
        ('x86',   ['x86']),
        ('arm64', ['arm64', 'amd64', 'x86']),
        ('arm',   ['x86']),
    ]),

    host_all_targets = {
        'amd64': ['amd64', 'x86', 'arm64', 'arm'],
        'x86':   ['x86', 'amd64', 'arm', 'arm64'],
        'arm64': ['arm64', 'amd64', 'arm', 'x86'],
        'arm':   [],
    },

    host_def_targets = {
        'amd64': ['amd64', 'x86'],
        'x86':   ['x86'],
        'arm64': ['arm64', 'amd64', 'arm', 'x86'],
        'arm':   ['arm'],
    },

)

# debug("_GE2022_HOST_TARGET_CFG: %s", _GE2022_HOST_TARGET_CFG)

# 14.2 (VS2019) to 14.1 (VS2017)

_LE2019_HOST_TARGET_BATCHFILE_CLPATHCOMPS = {

    ('amd64', 'amd64') : ('vcvars64.bat',          ('bin', 'Hostx64', 'x64')),
    ('amd64', 'x86')   : ('vcvarsamd64_x86.bat',   ('bin', 'Hostx64', 'x86')),
    ('amd64', 'arm')   : ('vcvarsamd64_arm.bat',   ('bin', 'Hostx64', 'arm')),
    ('amd64', 'arm64') : ('vcvarsamd64_arm64.bat', ('bin', 'Hostx64', 'arm64')),

    ('x86',   'amd64') : ('vcvarsx86_amd64.bat',   ('bin', 'Hostx86', 'x64')),
    ('x86',   'x86')   : ('vcvars32.bat',          ('bin', 'Hostx86', 'x86')),
    ('x86',   'arm')   : ('vcvarsx86_arm.bat',     ('bin', 'Hostx86', 'arm')),
    ('x86',   'arm64') : ('vcvarsx86_arm64.bat',   ('bin', 'Hostx86', 'arm64')),

    ('arm64', 'amd64') : ('vcvars64.bat',          ('bin', 'Hostx64', 'x64')),
    ('arm64', 'x86')   : ('vcvarsamd64_x86.bat',   ('bin', 'Hostx64', 'x86')),
    ('arm64', 'arm')   : ('vcvarsamd64_arm.bat',   ('bin', 'Hostx64', 'arm')),
    ('arm64', 'arm64') : ('vcvarsamd64_arm64.bat', ('bin', 'Hostx64', 'arm64')),

}

_LE2019_HOST_TARGET_CFG = _host_target_config_factory(

    label = 'LE2019',

    host_all_hosts = OrderedDict([
        ('amd64', ['amd64', 'x86']),
        ('x86',   ['x86']),
        ('arm64', ['amd64', 'x86']),
        ('arm',   ['x86']),
    ]),

    host_all_targets = {
        'amd64': ['amd64', 'x86', 'arm64', 'arm'],
        'x86':   ['x86', 'amd64', 'arm', 'arm64'],
        'arm64': ['arm64', 'amd64', 'arm', 'x86'],
        'arm':   [],
    },

    host_def_targets = {
        'amd64': ['amd64', 'x86'],
        'x86':   ['x86'],
        'arm64': ['arm64', 'amd64', 'arm', 'x86'],
        'arm':   ['arm'],
    },

)

# debug("_LE2019_HOST_TARGET_CFG: %s", _LE2019_HOST_TARGET_CFG)

# 14.0 (VS2015) to 10.0 (VS2010)

# Given a (host, target) tuple, return a tuple containing the argument for
# the batch file and a tuple of the path components to find cl.exe.
#
# In 14.0 (VS2015) and earlier, the original x86 tools are in the tools
# bin directory (i.e., <VSROOT>/VC/bin).  Any other tools are in subdirectory
# named for the the host/target pair or a single name if the host==target.

_LE2015_HOST_TARGET_BATCHARG_BATCHFILE_CLPATHCOMPS = {

    ('amd64', 'amd64') : ('amd64',     'vcvars64.bat',         ('bin', 'amd64')),
    ('amd64', 'x86')   : ('amd64_x86', 'vcvarsamd64_x86.bat',  ('bin', 'amd64_x86')),
    ('amd64', 'arm')   : ('amd64_arm', 'vcvarsamd64_arm.bat',  ('bin', 'amd64_arm')),

    ('x86',   'amd64') : ('x86_amd64', 'vcvarsx86_amd64.bat',  ('bin', 'x86_amd64')),
    ('x86',   'x86')   : ('x86',       'vcvars32.bat',         ('bin', )),
    ('x86',   'arm')   : ('x86_arm',   'vcvarsx86_arm.bat',    ('bin', 'x86_arm')),
    ('x86',   'ia64')  : ('x86_ia64',  'vcvarsx86_ia64.bat',   ('bin', 'x86_ia64')),

    ('arm64', 'amd64') : ('amd64',     'vcvars64.bat',         ('bin', 'amd64')),
    ('arm64', 'x86')   : ('amd64_x86', 'vcvarsamd64_x86.bat',  ('bin', 'amd64_x86')),
    ('arm64', 'arm')   : ('amd64_arm', 'vcvarsamd64_arm.bat',  ('bin', 'amd64_arm')),

    ('arm',   'arm')   : ('arm',       'vcvarsarm.bat',        ('bin', 'arm')),
    ('ia64',  'ia64')  : ('ia64',      'vcvars64.bat',         ('bin', 'ia64')),

}

_LE2015_HOST_TARGET_CFG = _host_target_config_factory(

    label = 'LE2015',

    host_all_hosts = OrderedDict([
        ('amd64', ['amd64', 'x86']),
        ('x86',   ['x86']),
        ('arm64', ['amd64', 'x86']),
        ('arm',   ['arm']),
        ('ia64',  ['ia64']),
    ]),

    host_all_targets = {
        'amd64': ['amd64', 'x86', 'arm'],
        'x86':   ['x86', 'amd64', 'arm', 'ia64'],
        'arm64': ['amd64', 'x86', 'arm'],
        'arm':   ['arm'],
        'ia64':  ['ia64'],
    },

    host_def_targets = {
        'amd64': ['amd64', 'x86'],
        'x86':   ['x86'],
        'arm64': ['amd64', 'arm', 'x86'],
        'arm':   ['arm'],
        'ia64':  ['ia64'],
    },

)

# debug("_LE2015_HOST_TARGET_CFG: %s", _LE2015_HOST_TARGET_CFG)

# 9.0 (VS2008) to 8.0 (VS2005)

_LE2008_HOST_TARGET_BATCHARG_BATCHFILE_CLPATHCOMPS = {

    ('amd64', 'amd64') : ('amd64',     'vcvarsamd64.bat',      ('bin', 'amd64')),
    ('amd64', 'x86') :   ('x86',       'vcvars32.bat',         ('bin', )),

    ('x86',   'amd64') : ('x86_amd64', 'vcvarsx86_amd64.bat',  ('bin', 'x86_amd64')),
    ('x86',   'x86')   : ('x86',       'vcvars32.bat',         ('bin', )),
    ('x86',   'ia64')  : ('x86_ia64',  'vcvarsx86_ia64.bat',   ('bin', 'x86_ia64')),

    ('arm64', 'amd64') : ('amd64',     'vcvarsamd64.bat',      ('bin', 'amd64')),
    ('arm64', 'x86') :   ('x86',       'vcvars32.bat',         ('bin', )),

    ('ia64',  'ia64')  : ('ia64',      'vcvarsia64.bat',       ('bin', 'ia64')),

}

_LE2008_HOST_TARGET_CFG = _host_target_config_factory(

    label = 'LE2008',

    host_all_hosts = OrderedDict([
        ('amd64', ['amd64', 'x86']),
        ('x86',   ['x86']),
        ('arm64', ['amd64', 'x86']),
        ('ia64',  ['ia64']),
    ]),

    host_all_targets = {
        'amd64': ['amd64', 'x86'],
        'x86':   ['x86', 'amd64', 'ia64'],
        'arm64': ['amd64', 'x86'],
        'ia64':  ['ia64'],
    },

    host_def_targets = {
        'amd64': ['amd64', 'x86'],
        'x86':   ['x86'],
        'arm64': ['amd64', 'x86'],
        'ia64':  ['ia64'],
    },

)

# debug("_LE2008_HOST_TARGET_CFG: %s", _LE2008_HOST_TARGET_CFG)

# 7.1 (VS2003) and earlier

# For 7.1 (VS2003) and earlier, there are only x86 targets and the batch files
# take no arguments.

_LE2003_HOST_TARGET_CFG = _host_target_config_factory(

    label = 'LE2003',

    host_all_hosts = OrderedDict([
        ('amd64', ['x86']),
        ('x86',   ['x86']),
        ('arm64', ['x86']),
    ]),

    host_all_targets = {
        'amd64': ['x86'],
        'x86':   ['x86'],
        'arm64': ['x86'],
    },

    host_def_targets = {
        'amd64': ['x86'],
        'x86':   ['x86'],
        'arm64': ['x86'],
    },

)

# debug("_LE2003_HOST_TARGET_CFG: %s", _LE2003_HOST_TARGET_CFG)

_CL_EXE_NAME = 'cl.exe'

_VSWHERE_EXE = 'vswhere.exe'

def get_msvc_version_numeric(msvc_version):
    """Get the raw version numbers from a MSVC_VERSION string, so it
    could be cast to float or other numeric values. For example, '14.0Exp'
    would get converted to '14.0'.

    Args:
        msvc_version: str
            string representing the version number, could contain non
            digit characters

    Returns:
        str: the value converted to a numeric only string

    """
    return ''.join([x for x in msvc_version if x in string_digits + '.'])

def get_host_platform(host_platform):

    host_platform = host_platform.lower()

    # Solaris returns i86pc for both 32 and 64 bit architectures
    if host_platform == 'i86pc':
        if platform.architecture()[0] == "64bit":
            host_platform = "amd64"
        else:
            host_platform = "x86"

    try:
        host =_ARCH_TO_CANONICAL[host_platform]
    except KeyError:
        msg = "Unrecognized host architecture %s"
        raise MSVCUnsupportedHostArch(msg % repr(host_platform)) from None

    return host

_native_host_architecture = None

def get_native_host_architecture():
    """Return the native host architecture."""
    global _native_host_architecture

    if _native_host_architecture is None:

        try:
            arch = common.read_reg(
                r'SYSTEM\CurrentControlSet\Control\Session Manager\Environment\PROCESSOR_ARCHITECTURE'
            )
        except OSError:
            arch = None

        if not arch:
            arch = platform.machine()

        _native_host_architecture = arch

    return _native_host_architecture

_native_host_platform = None

def get_native_host_platform():
    global _native_host_platform

    if _native_host_platform is None:
        arch = get_native_host_architecture()
        _native_host_platform = get_host_platform(arch)

    return _native_host_platform

def get_host_target(env, msvc_version, all_host_targets=False):

    vernum = float(get_msvc_version_numeric(msvc_version))
    vernum_int = int(vernum * 10)

    if vernum_int >= 143:
        # 14.3 (VS2022) and later
        host_target_cfg = _GE2022_HOST_TARGET_CFG
    elif 143 > vernum_int >= 141:
        # 14.2 (VS2019) to 14.1 (VS2017)
        host_target_cfg = _LE2019_HOST_TARGET_CFG
    elif 141 > vernum_int >= 100:
        # 14.0 (VS2015) to 10.0 (VS2010)
        host_target_cfg = _LE2015_HOST_TARGET_CFG
    elif 100 > vernum_int >= 80:
        # 9.0 (VS2008) to 8.0 (VS2005)
        host_target_cfg = _LE2008_HOST_TARGET_CFG
    else: # 80 > vernum_int
        # 7.1 (VS2003) and earlier
        host_target_cfg = _LE2003_HOST_TARGET_CFG

    host_arch = env.get('HOST_ARCH') if env else None
    debug("HOST_ARCH:%s", str(host_arch))

    if host_arch:
        host_platform = get_host_platform(host_arch)
    else:
        host_platform = get_native_host_platform()

    target_arch = env.get('TARGET_ARCH') if env else None
    debug("TARGET_ARCH:%s", str(target_arch))

    if target_arch:

        try:
            target_platform = _ARCH_TO_CANONICAL[target_arch.lower()]
        except KeyError:
            all_archs = str(list(_ARCH_TO_CANONICAL.keys()))
            raise MSVCUnsupportedTargetArch(
                "Unrecognized target architecture %s\n\tValid architectures: %s"
                % (repr(target_arch), all_archs)
            ) from None

        target_host_map = host_target_cfg.target_host_map

        try:
            host_target_list = target_host_map[target_platform][host_platform]
        except KeyError:
            host_target_list = []
            warn_msg = "unsupported host, target combination ({}, {}) for MSVC version {}".format(
                repr(host_platform), repr(target_platform), msvc_version
            )
            SCons.Warnings.warn(SCons.Warnings.VisualCMissingWarning, warn_msg)
            debug(warn_msg)

    else:

        target_platform = None

        if all_host_targets:
            host_targets_map = host_target_cfg.host_all_targets_map
        else:
            host_targets_map = host_target_cfg.host_def_targets_map

        try:
            host_target_list = host_targets_map[host_platform]
        except KeyError:
            msg = "Unrecognized host architecture %s for version %s"
            raise MSVCUnsupportedHostArch(msg % (repr(host_platform), msvc_version)) from None

    return host_platform, target_platform, host_target_list

_arm32_process_arm64_host = None

def is_arm32_process_arm64_host():
    global _arm32_process_arm64_host

    if _arm32_process_arm64_host is None:

        host = get_native_host_architecture()
        host = _ARCH_TO_CANONICAL.get(host.lower(),'')
        host_isarm64 = host == 'arm64'

        process = sysconfig.get_platform()
        process_isarm32 = process == 'win-arm32'

        _arm32_process_arm64_host = host_isarm64 and process_isarm32

    return _arm32_process_arm64_host

_check_skip_sendtelemetry = None

def _skip_sendtelemetry(env):
    global _check_skip_sendtelemetry

    if _check_skip_sendtelemetry is None:

        if _ARM32_ON_ARM64_SKIP_SENDTELEMETRY and is_arm32_process_arm64_host():
            _check_skip_sendtelemetry = True
        else:
            _check_skip_sendtelemetry = False

    if not _check_skip_sendtelemetry:
        return False

    msvc_version = env.get('MSVC_VERSION') if env else None
    if not msvc_version:
        msvc_version = msvc_default_version(env)

    if not msvc_version:
        return False

    vernum = float(get_msvc_version_numeric(msvc_version))
    if vernum < 14.2:  # VS2019
        return False

    # arm32 process, arm64 host, VS2019+
    return True

# If you update this, update SupportedVSList in Tool/MSCommon/vs.py, and the
# MSVC_VERSION documentation in Tool/msvc.xml.
_VCVER = [
    "14.5",
    "14.3",
    "14.2",
    "14.1", "14.1Exp",
    "14.0", "14.0Exp",
    "12.0", "12.0Exp",
    "11.0", "11.0Exp",
    "10.0", "10.0Exp",
    "9.0", "9.0Exp",
    "8.0", "8.0Exp",
    "7.1",
    "7.0",
    "6.0"]

# VS2017 and later: use a single vswhere json query to find all installations

# vswhere query:
#    map vs major version to vc version (no suffix)
#    build set of supported vc versions (including suffix)

_VSWHERE_VSMAJOR_TO_VCVERSION = {}
_VSWHERE_SUPPORTED_VCVER = set()

for vs_major, vc_version, vc_ver_list in (
    ('18', '14.5', None),
    ('17', '14.3', None),
    ('16', '14.2', None),
    ('15', '14.1', ['14.1Exp']),
):
    _VSWHERE_VSMAJOR_TO_VCVERSION[vs_major] = vc_version
    _VSWHERE_SUPPORTED_VCVER.add(vc_version)
    if vc_ver_list:
        for vc_ver in vc_ver_list:
            _VSWHERE_SUPPORTED_VCVER.add(vc_ver)

# vwhere query:
#    build of set of candidate component ids
#    preferred ranking: Enterprise, Professional, Community, BuildTools, Express
#      Ent, Pro, Com, BT, Exp are in the same list
#      Exp also has it's own list
#    currently, only the express (Exp) suffix is expected

_VSWHERE_COMPONENTID_CANDIDATES = set()
_VSWHERE_COMPONENTID_RANKING = {}
_VSWHERE_COMPONENTID_SUFFIX = {}
_VSWHERE_COMPONENTID_SCONS_SUFFIX = {}

for component_id, component_rank, component_suffix, scons_suffix in (
    ('Enterprise',   140, 'Ent', ''),
    ('Professional', 130, 'Pro', ''),
    ('Community',    120, 'Com', ''),
    ('BuildTools',   110, 'BT',  ''),
    ('WDExpress',    100, 'Exp', 'Exp'),
):
    _VSWHERE_COMPONENTID_CANDIDATES.add(component_id)
    _VSWHERE_COMPONENTID_RANKING[component_id] = component_rank
    _VSWHERE_COMPONENTID_SUFFIX[component_id] = component_suffix
    _VSWHERE_COMPONENTID_SCONS_SUFFIX[component_id] = scons_suffix

# VS2015 and earlier: configure registry queries to probe for installed VC editions
_VCVER_TO_PRODUCT_DIR = {
    '14.0': [
        (SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\VisualStudio\14.0\Setup\VC\ProductDir')
    ],
    '14.0Exp': [
        (SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\WDExpress\14.0\Setup\VS\ProductDir'),
        (SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\VCExpress\14.0\Setup\VC\ProductDir'),
        (SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\VisualStudio\14.0\Setup\VC\ProductDir')
    ],
    '12.0': [
        (SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\VisualStudio\12.0\Setup\VC\ProductDir'),
    ],
    '12.0Exp': [
        (SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\WDExpress\12.0\Setup\VS\ProductDir'),
        (SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\VCExpress\12.0\Setup\VC\ProductDir'),
    ],
    '11.0': [
        (SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\VisualStudio\11.0\Setup\VC\ProductDir'),
    ],
    '11.0Exp': [
        (SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\WDExpress\11.0\Setup\VS\ProductDir'),
        (SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\VCExpress\11.0\Setup\VC\ProductDir'),
    ],
    '10.0': [
        (SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\VisualStudio\10.0\Setup\VC\ProductDir'),
    ],
    '10.0Exp': [
        (SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\VCExpress\10.0\Setup\VC\ProductDir'),
    ],
    '9.0': [
        (SCons.Util.HKEY_CURRENT_USER, r'Microsoft\DevDiv\VCForPython\9.0\installdir',),  # vs root
        (SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\DevDiv\VCForPython\9.0\installdir',),  # vs root
        (SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\VisualStudio\9.0\Setup\VC\ProductDir',),
    ] if _VC90_Prefer_VCForPython else [
        (SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\VisualStudio\9.0\Setup\VC\ProductDir',),
        (SCons.Util.HKEY_CURRENT_USER, r'Microsoft\DevDiv\VCForPython\9.0\installdir',),  # vs root
        (SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\DevDiv\VCForPython\9.0\installdir',),  # vs root
    ],
    '9.0Exp': [
        (SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\VCExpress\9.0\Setup\VC\ProductDir'),
    ],
    '8.0': [
        (SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\VisualStudio\8.0\Setup\VC\ProductDir'),
        (SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\VCExpress\8.0\Setup\VC\ProductDir'),
    ],
    '8.0Exp': [
        (SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\VCExpress\8.0\Setup\VC\ProductDir'),
    ],
    '7.1': [
        (SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\VisualStudio\7.1\Setup\VC\ProductDir'),
    ],
    '7.0': [
        (SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\VisualStudio\7.0\Setup\VC\ProductDir'),
    ],
    '6.0': [
        (SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\VisualStudio\6.0\Setup\Microsoft Visual C++\ProductDir'),
    ]
}

# detect ide binaries

VS2026_VS2002_DEV = (
    MSVC.Kind.IDE_PROGRAM_DEVENV_COM,  # devenv.com
)

VS1998_DEV = (
    MSVC.Kind.IDE_PROGRAM_MSDEV_COM,  # MSDEV.COM
)

VS2017_EXP = (
    MSVC.Kind.IDE_PROGRAM_WDEXPRESS_EXE,  # WDExpress.exe
)

VS2015_VS2012_EXP = (
    MSVC.Kind.IDE_PROGRAM_WDEXPRESS_EXE,     # WDExpress.exe [Desktop]
    MSVC.Kind.IDE_PROGRAM_VSWINEXPRESS_EXE,  # VSWinExpress.exe [Windows]
    MSVC.Kind.IDE_PROGRAM_VWDEXPRESS_EXE,    # VWDExpress.exe [Web]
)

VS2010_VS2005_EXP = (
    MSVC.Kind.IDE_PROGRAM_VCEXPRESS_EXE,
)

# detect productdir kind

_DETECT = MSVC.Kind.VCVER_KIND_DETECT

_VCVER_KIND_DETECT = {

    #   'VCVer':   (relpath from pdir to vsroot, path from vsroot to ide binaries, ide binaries)

    '14.5':    _DETECT(root='..', path=r'Common7\IDE', programs=VS2026_VS2002_DEV),  # 2026
    '14.3':    _DETECT(root='..', path=r'Common7\IDE', programs=VS2026_VS2002_DEV),  # 2022
    '14.2':    _DETECT(root='..', path=r'Common7\IDE', programs=VS2026_VS2002_DEV),  # 2019
    '14.1':    _DETECT(root='..', path=r'Common7\IDE', programs=VS2026_VS2002_DEV + VS2017_EXP),  # 2017
    '14.1Exp': _DETECT(root='..', path=r'Common7\IDE', programs=VS2026_VS2002_DEV + VS2017_EXP),  # 2017

    '14.0':    _DETECT(root='..', path=r'Common7\IDE', programs=VS2026_VS2002_DEV + VS2015_VS2012_EXP),  # 2015
    '14.0Exp': _DETECT(root='..', path=r'Common7\IDE', programs=VS2026_VS2002_DEV + VS2015_VS2012_EXP),  # 2015
    '12.0':    _DETECT(root='..', path=r'Common7\IDE', programs=VS2026_VS2002_DEV + VS2015_VS2012_EXP),  # 2013
    '12.0Exp': _DETECT(root='..', path=r'Common7\IDE', programs=VS2026_VS2002_DEV + VS2015_VS2012_EXP),  # 2013
    '11.0':    _DETECT(root='..', path=r'Common7\IDE', programs=VS2026_VS2002_DEV + VS2015_VS2012_EXP),  # 2012
    '11.0Exp': _DETECT(root='..', path=r'Common7\IDE', programs=VS2026_VS2002_DEV + VS2015_VS2012_EXP),  # 2012

    '10.0':    _DETECT(root='..', path=r'Common7\IDE', programs=VS2026_VS2002_DEV + VS2010_VS2005_EXP),  # 2010
    '10.0Exp': _DETECT(root='..', path=r'Common7\IDE', programs=VS2026_VS2002_DEV + VS2010_VS2005_EXP),  # 2010
    '9.0':     _DETECT(root='..', path=r'Common7\IDE', programs=VS2026_VS2002_DEV + VS2010_VS2005_EXP),  # 2008
    '9.0Exp':  _DETECT(root='..', path=r'Common7\IDE', programs=VS2026_VS2002_DEV + VS2010_VS2005_EXP),  # 2008
    '8.0':     _DETECT(root='..', path=r'Common7\IDE', programs=VS2026_VS2002_DEV + VS2010_VS2005_EXP),  # 2005
    '8.0Exp':  _DETECT(root='..', path=r'Common7\IDE', programs=VS2026_VS2002_DEV + VS2010_VS2005_EXP),  # 2005

    '7.1':     _DETECT(root='..', path=r'Common7\IDE', programs=VS2026_VS2002_DEV),  # 2003
    '7.0':     _DETECT(root='..', path=r'Common7\IDE', programs=VS2026_VS2002_DEV),  # 2001

    '6.0':     _DETECT(root='..', path=r'Common\MSDev98\Bin', programs=VS1998_DEV),  # 1998
}

def msvc_version_to_maj_min(msvc_version):
    msvc_version_numeric = get_msvc_version_numeric(msvc_version)

    t = msvc_version_numeric.split(".")
    if not len(t) == 2:
        raise ValueError("Unrecognized version %s (%s)" % (msvc_version,msvc_version_numeric))
    try:
        maj = int(t[0])
        min = int(t[1])
        return maj, min
    except ValueError:
        raise ValueError("Unrecognized version %s (%s)" % (msvc_version,msvc_version_numeric)) from None


_VSWHERE_EXEGROUP_MSVS = [os.path.join(p, _VSWHERE_EXE) for p in [
    # For bug 3333: support default location of vswhere for both
    # 64 and 32 bit windows installs.
    # For bug 3542: also accommodate not being on C: drive.
    os.path.expandvars(r"%ProgramFiles(x86)%\Microsoft Visual Studio\Installer"),
    os.path.expandvars(r"%ProgramFiles%\Microsoft Visual Studio\Installer"),
]]

_VSWHERE_EXEGROUP_PKGMGR = [os.path.join(p, _VSWHERE_EXE) for p in [
    os.path.expandvars(r"%ChocolateyInstall%\bin"),
    os.path.expandvars(r"%LOCALAPPDATA%\Microsoft\WinGet\Links"),
    os.path.expanduser(r"~\scoop\shims"),
    os.path.expandvars(r"%SCOOP%\shims"),
]]

_VSWhereBinary = namedtuple('_VSWhereBinary', [
    'vswhere_exe',
    'vswhere_norm',
])

class VSWhereBinary(_VSWhereBinary, MSVC.Util.AutoInitialize):

    _UNDEFINED_VSWHERE_BINARY = None

    _cache_vswhere_paths = {}

    @classmethod
    def _initialize(cls):
        vswhere_binary = cls(
            vswhere_exe=None,
            vswhere_norm=None,
        )
        cls._UNDEFINED_VSWHERE_BINARY = vswhere_binary
        for symbol in (None, ''):
            cls._cache_vswhere_paths[symbol] = vswhere_binary

    @classmethod
    def factory(cls, vswhere_exe):

        if not vswhere_exe:
            return cls._UNDEFINED_VSWHERE_BINARY

        vswhere_binary = cls._cache_vswhere_paths.get(vswhere_exe)
        if vswhere_binary:
            return vswhere_binary

        vswhere_norm = MSVC.Util.normalize_path(vswhere_exe)

        vswhere_binary = cls._cache_vswhere_paths.get(vswhere_norm)
        if vswhere_binary:
            return vswhere_binary

        vswhere_binary = cls(
            vswhere_exe=vswhere_exe,
            vswhere_norm=vswhere_norm,
        )

        cls._cache_vswhere_paths[vswhere_exe] = vswhere_binary
        cls._cache_vswhere_paths[vswhere_norm] = vswhere_binary

        return vswhere_binary

class _VSWhereExecutable(MSVC.Util.AutoInitialize):

    debug_extra = None

    class _VSWhereUserPriority(enum.IntEnum):
        HIGH = 0               # before msvs locations
        DEFAULT = enum.auto()  # after msvs locations and before pkgmgr locations
        LOW = enum.auto()      # after pkgmgr locations

    priority_default = _VSWhereUserPriority.DEFAULT
    priority_map = {}
    priority_symbols = []
    priority_indmap = {}

    for e in _VSWhereUserPriority:
        for symbol in (e.name.lower(), e.name.lower().capitalize(), e.name):
            priority_map[symbol] = e.value
            priority_symbols.append(symbol)
        priority_indmap[e.value] = e.name

    UNDEFINED_VSWHERE_BINARY = VSWhereBinary.factory(None)

    @classmethod
    def reset(cls):

        cls._vswhere_exegroups = None
        cls._vswhere_exegroups_user = None
        cls._vswhere_exegroup_msvs = None
        cls._vswhere_exegroup_pkgmgr = None

        cls.vswhere_frozen_flag = False
        cls.vswhere_frozen_binary = None

    @classmethod
    def _initialize(cls):
        cls.debug_extra = common.debug_extra(cls)
        cls.reset()

    @classmethod
    def _vswhere_exegroup_binaries(cls, vswhere_exe_list, label):
        vswhere_binaries = []
        for vswhere_exe in vswhere_exe_list:
            if not os.path.exists(vswhere_exe):
                continue
            vswhere_binary = VSWhereBinary.factory(vswhere_exe)
            vswhere_binaries.append(vswhere_binary)
            debug(
                "insert exegroup=%s, vswhere_binary=%s",
                label, vswhere_binary, extra=cls.debug_extra
            )
        return vswhere_binaries

    @classmethod
    def _get_vswhere_exegroups(cls):

        if cls._vswhere_exegroups is None:

            cls._vswhere_exegroup_msvs = cls._vswhere_exegroup_binaries(_VSWHERE_EXEGROUP_MSVS, 'MSVS')
            cls._vswhere_exegroup_pkgmgr = cls._vswhere_exegroup_binaries(_VSWHERE_EXEGROUP_PKGMGR, 'PKGMGR')

            cls._vswhere_exegroups_user = [
                [] for e in cls._VSWhereUserPriority
            ]

            vswhere_exegroups = [
                cls._vswhere_exegroups_user[cls._VSWhereUserPriority.HIGH],
                cls._vswhere_exegroup_msvs,
                cls._vswhere_exegroups_user[cls._VSWhereUserPriority.DEFAULT],
                cls._vswhere_exegroup_pkgmgr,
                cls._vswhere_exegroups_user[cls._VSWhereUserPriority.LOW],
            ]

            cls._vswhere_exegroups = vswhere_exegroups

        return cls._vswhere_exegroups

    @classmethod
    def _get_vswhere_exegroups_user(cls):

        if cls._vswhere_exegroups_user is None:
            cls._get_vswhere_exegroups()

        return cls._vswhere_exegroups_user

    @classmethod
    def _vswhere_exegroup_binary(cls, exegroup):
        # first vswhere binary in group or UNDEFINED_VSWHERE_BINARY
        vswhere_binary = exegroup[0] if exegroup else cls.UNDEFINED_VSWHERE_BINARY
        return vswhere_binary

    @classmethod
    def _vswhere_current_binary(cls):
        # first vswhere binary in priority order or UNDEFINED_VSWHERE_BINARY
        vswhere_binary = cls.UNDEFINED_VSWHERE_BINARY
        vswhere_exegroups = cls._get_vswhere_exegroups()
        for exegroup in vswhere_exegroups:
            binary = cls._vswhere_exegroup_binary(exegroup)
            if binary == cls.UNDEFINED_VSWHERE_BINARY:
                continue
            vswhere_binary = binary
            break
        return vswhere_binary

    @classmethod
    def _vswhere_all_executables(cls):
        # unique vswhere executables in priority order
        vswhere_exe_list = []
        vswhere_norm_set = set()
        vswhere_exegroups = cls._get_vswhere_exegroups()
        for exegroup in vswhere_exegroups:
            for vswhere_binary in exegroup:
                if vswhere_binary.vswhere_norm in vswhere_norm_set:
                    continue
                vswhere_norm_set.add(vswhere_binary.vswhere_norm)
                vswhere_exe_list.append(vswhere_binary.vswhere_exe)
        return vswhere_exe_list

    @classmethod
    def is_frozen(cls):
        rval = bool(cls.vswhere_frozen_flag)
        return rval

    @classmethod
    def freeze_vswhere_binary(cls):
        if not cls.vswhere_frozen_flag:
            cls.vswhere_frozen_flag = True
            cls.vswhere_frozen_binary = cls._vswhere_current_binary()
            debug("freeze=%s", cls.vswhere_frozen_binary, extra=cls.debug_extra)
        return cls.vswhere_frozen_binary

    @classmethod
    def freeze_vswhere_executable(cls):
        vswhere_binary = cls.freeze_vswhere_binary()
        vswhere_exe = vswhere_binary.vswhere_exe
        return vswhere_exe

    @classmethod
    def get_vswhere_executable(cls):
        if cls.vswhere_frozen_flag:
            vswhere_binary = cls.vswhere_frozen_binary
        else:
            vswhere_binary = cls._vswhere_current_binary()
        vswhere_exe = vswhere_binary.vswhere_exe
        debug("vswhere_exe=%s", repr(vswhere_exe), extra=cls.debug_extra)
        return vswhere_exe

    @classmethod
    def _vswhere_priority_group(cls, priority):
        if not priority:
            group = cls.priority_default
        else:
            group = cls.priority_map.get(priority)
            if group is None:
                msg = f'Value specified for vswhere executable priority is not supported: {priority!r}:\n' \
                      f'  Valid values are: {cls.priority_symbols}'
                debug(f'VSWhereUserError: {msg}', extra=cls.debug_extra)
                raise VSWhereUserError(msg)
        return group

    @classmethod
    def register_vswhere_executable(cls, vswhere_exe, priority=None):

        vswhere_binary = cls.UNDEFINED_VSWHERE_BINARY

        if not vswhere_exe:
            # ignore: None or empty
            return vswhere_binary

        if not os.path.exists(vswhere_exe):
            msg = f'Specified vswhere executable not found: {vswhere_exe!r}.'
            debug(f'VSWhereUserError: {msg}', extra=cls.debug_extra)
            raise VSWhereUserError(msg)

        group = cls._vswhere_priority_group(priority)

        vswhere_binary = VSWhereBinary.factory(vswhere_exe)

        if cls.vswhere_frozen_flag:

            if vswhere_binary.vswhere_norm == cls.vswhere_frozen_binary.vswhere_norm:
                # ignore: user executable == frozen executable
                return vswhere_binary

            msg = 'A different vswhere execuable cannot be requested after initial detetection:\n' \
                  f'  initial vswhere executable:  {cls.vswhere_frozen_binary.vswhere_exe!r}\n' \
                  f'  request vswhere executable: {vswhere_binary.vswhere_exe!r}'

            debug(f'VSWhereUserError: {msg}', extra=cls.debug_extra)
            raise VSWhereUserError(msg)

        vswhere_exegroups_user = cls._get_vswhere_exegroups_user()

        exegroup = vswhere_exegroups_user[group]
        group_binary = cls._vswhere_exegroup_binary(exegroup)

        if vswhere_binary.vswhere_norm == group_binary.vswhere_norm:
            # ignore: user executable == exegroup[0] executable
            return vswhere_binary

        exegroup.insert(0, vswhere_binary)
        debug(
            "insert exegroup=user[%s], vswhere_binary=%s",
            cls.priority_indmap[group], vswhere_binary, extra=cls.debug_extra
        )

        return vswhere_binary

    @classmethod
    def vswhere_freeze_executable(cls, vswhere_exe):
        vswhere_binary = cls.register_vswhere_executable(vswhere_exe, priority='high')
        frozen_binary = cls.freeze_vswhere_binary()
        return frozen_binary, vswhere_binary

    @classmethod
    def vswhere_freeze_env(cls, env):

        if env is None:
            # no environment, VSWHERE undefined
            vswhere_exe = None
            write_vswhere = False
        elif not env.get('VSWHERE'):
            # environment, VSWHERE undefined/none/empty
            vswhere_exe = None
            write_vswhere = True
        else:
            # environment, VSWHERE defined
            vswhere_exe = env.subst('$VSWHERE')
            write_vswhere = False

        frozen_binary, vswhere_binary = cls.vswhere_freeze_executable(vswhere_exe)

        if write_vswhere and frozen_binary.vswhere_norm != vswhere_binary.vswhere_norm:
            env['VSWHERE'] = frozen_binary.vswhere_exe
            debug(
                "env['VSWHERE']=%s",
                repr(frozen_binary.vswhere_exe), extra=cls.debug_extra
            )

        return frozen_binary, vswhere_binary

# external use

def vswhere_register_executable(vswhere_exe, priority=None, freeze=False):
    debug(
        'register vswhere_exe=%s, priority=%s, freeze=%s',
        repr(vswhere_exe), repr(priority), repr(freeze)
    )
    _VSWhereExecutable.register_vswhere_executable(vswhere_exe, priority=priority)
    if freeze:
        _VSWhereExecutable.freeze_vswhere_executable()
    rval = _VSWhereExecutable.get_vswhere_executable()
    debug('current vswhere_exe=%s, is_frozen=%s', repr(rval), _VSWhereExecutable.is_frozen())
    return vswhere_exe

def vswhere_get_executable():
    debug('')
    vswhere_exe = _VSWhereExecutable.get_vswhere_executable()
    return vswhere_exe

def vswhere_freeze_executable():
    debug('')
    vswhere_exe = _VSWhereExecutable.freeze_vswhere_executable()
    return vswhere_exe

# internal use only
vswhere_freeze_env = _VSWhereExecutable.vswhere_freeze_env

def msvc_find_vswhere():
    """ Find the location of vswhere """
    # NB: this gets called from testsuite on non-Windows platforms.
    # Whether that makes sense or not, don't break it for those.
    vswhere_path = _VSWhereExecutable.get_vswhere_executable()
    return vswhere_path

_MSVCInstance = namedtuple('_MSVCInstance', [
    'vc_path',
    'vc_version',
    'vc_version_numeric',
    'vc_version_scons',
    'vc_release',
    'vc_component_id',
    'vc_component_rank',
    'vc_component_suffix',
])

class MSVCInstance(_MSVCInstance):

    @staticmethod
    def msvc_instances_default_order(a, b):
        # vc version numeric: descending order
        if a.vc_version_numeric != b.vc_version_numeric:
            return 1 if a.vc_version_numeric < b.vc_version_numeric else -1
        # vc release: descending order (release, preview)
        if a.vc_release != b.vc_release:
            return 1 if a.vc_release < b.vc_release else -1
        # component rank: descending order
        if a.vc_component_rank != b.vc_component_rank:
            return 1 if a.vc_component_rank < b.vc_component_rank else -1
        return 0

class _VSWhere(MSVC.Util.AutoInitialize):

    debug_extra = None

    @classmethod
    def reset(cls):

        cls.seen_vswhere = set()
        cls.seen_root = set()

        cls.msvc_instances = []
        cls.msvc_map = {}

    @classmethod
    def _initialize(cls):
        cls.debug_extra = common.debug_extra(cls)
        cls.reset()

    @classmethod
    def _filter_vswhere_binary(cls, vswhere_binary):

        vswhere_norm = None

        if vswhere_binary.vswhere_norm not in cls.seen_vswhere:
            cls.seen_vswhere.add(vswhere_binary.vswhere_norm)
            vswhere_norm = vswhere_binary.vswhere_norm

        return vswhere_norm

    @classmethod
    def _new_roots_discovered(cls):
        if len(cls.seen_vswhere) > 1:
            raise MSVCInternalError(f'vswhere discovered new msvc installations after initial detection')

    @classmethod
    def _vswhere_query_json_output(cls, vswhere_exe, vswhere_args):

        vswhere_json = None

        once = True
        while once:
            once = False
            # using break for single exit (unless exception)

            vswhere_cmd = [vswhere_exe] + vswhere_args + ['-format', 'json', '-utf8']
            debug("running: %s", vswhere_cmd, extra=cls.debug_extra)

            try:
                cp = subprocess.run(vswhere_cmd, stdout=PIPE, stderr=PIPE, check=True)
            except OSError as e:
                errmsg = str(e)
                debug("%s: %s", type(e).__name__, errmsg, extra=cls.debug_extra)
                break
            except Exception as e:
                errmsg = str(e)
                debug("%s: %s", type(e).__name__, errmsg, extra=cls.debug_extra)
                raise

            if not cp.stdout:
                debug("no vswhere information returned", extra=cls.debug_extra)
                break

            vswhere_output = cp.stdout.decode('utf8', errors='replace')
            if not vswhere_output:
                debug("no vswhere information output", extra=cls.debug_extra)
                break

            try:
                vswhere_output_json = json.loads(vswhere_output)
            except json.decoder.JSONDecodeError:
                debug("json decode exception loading vswhere output", extra=cls.debug_extra)
                break

            vswhere_json = vswhere_output_json
            break

        debug(
            'vswhere_json=%s, vswhere_exe=%s',
            bool(vswhere_json), repr(vswhere_exe), extra=cls.debug_extra
        )

        return vswhere_json

    @classmethod
    def vswhere_update_msvc_map(cls, vswhere_exe):

        frozen_binary, vswhere_binary = _VSWhereExecutable.vswhere_freeze_executable(vswhere_exe)

        vswhere_norm = cls._filter_vswhere_binary(frozen_binary)
        if not vswhere_norm:
            return cls.msvc_map

        debug('vswhere_norm=%s', repr(vswhere_norm), extra=cls.debug_extra)

        vswhere_json = cls._vswhere_query_json_output(
            vswhere_norm,
            ['-all', '-products', '*']
        )

        if not vswhere_json:
            return cls.msvc_map

        n_instances = len(cls.msvc_instances)

        for instance in vswhere_json:

            #print(json.dumps(instance, indent=4, sort_keys=True))

            installation_path = instance.get('installationPath')
            if not installation_path or not os.path.exists(installation_path):
                continue

            vc_path = os.path.join(installation_path, 'VC')
            if not os.path.exists(vc_path):
                continue

            vc_root = MSVC.Util.normalize_path(vc_path)
            if vc_root in cls.seen_root:
                continue
            cls.seen_root.add(vc_root)

            installation_version = instance.get('installationVersion')
            if not installation_version:
                continue

            vs_major = installation_version.split('.')[0]
            if not vs_major in _VSWHERE_VSMAJOR_TO_VCVERSION:
                debug('ignore vs_major: %s', vs_major, extra=cls.debug_extra)
                continue

            vc_version = _VSWHERE_VSMAJOR_TO_VCVERSION[vs_major]

            product_id = instance.get('productId')
            if not product_id:
                continue

            component_id = product_id.split('.')[-1]
            if component_id not in _VSWHERE_COMPONENTID_CANDIDATES:
                debug('ignore component_id: %s', component_id, extra=cls.debug_extra)
                continue

            component_rank = _VSWHERE_COMPONENTID_RANKING.get(component_id,0)
            if component_rank == 0:
                raise MSVCInternalError(f'unknown component_rank for component_id: {component_id!r}')

            scons_suffix = _VSWHERE_COMPONENTID_SCONS_SUFFIX[component_id]

            if scons_suffix:
                vc_version_scons = vc_version + scons_suffix
            else:
                vc_version_scons = vc_version

            is_prerelease = True if instance.get('isPrerelease', False) else False
            is_release = False if is_prerelease else True

            msvc_instance = MSVCInstance(
                vc_path = vc_path,
                vc_version = vc_version,
                vc_version_numeric = float(vc_version),
                vc_version_scons = vc_version_scons,
                vc_release = is_release,
                vc_component_id = component_id,
                vc_component_rank = component_rank,
                vc_component_suffix = component_suffix,
            )

            cls.msvc_instances.append(msvc_instance)

        new_roots = bool(len(cls.msvc_instances) > n_instances)
        if new_roots:

            cls.msvc_instances = sorted(
                cls.msvc_instances,
                key=cmp_to_key(MSVCInstance.msvc_instances_default_order)
            )

            cls.msvc_map = {}

            for msvc_instance in cls.msvc_instances:

                debug(
                    'msvc instance: msvc_version=%s, is_release=%s, component_id=%s, vc_path=%s',
                    repr(msvc_instance.vc_version_scons), msvc_instance.vc_release,
                    repr(msvc_instance.vc_component_id), repr(msvc_instance.vc_path),
                    extra=cls.debug_extra
                )

                key = (msvc_instance.vc_version_scons, msvc_instance.vc_release)
                cls.msvc_map.setdefault(key,[]).append(msvc_instance)

                if msvc_instance.vc_version_scons == msvc_instance.vc_version:
                    continue

                key = (msvc_instance.vc_version, msvc_instance.vc_release)
                cls.msvc_map.setdefault(key,[]).append(msvc_instance)

            cls._new_roots_discovered()

        debug(
            'new_roots=%s, msvc_instances=%s',
            new_roots, len(cls.msvc_instances), extra=cls.debug_extra
        )

        return cls.msvc_map

_cache_pdir_vswhere_queries = {}

def _find_vc_pdir_vswhere(msvc_version, vswhere_exe):
    """ Find the MSVC product directory using the vswhere program.

    Args:
        msvc_version: MSVC version to search for
        vswhere_exe: vswhere executable or None

    Returns:
        MSVC install dir or None

    Raises:
        UnsupportedVersion: if the version is not known by this file

    """
    global _cache_pdir_vswhere_queries

    msvc_map = _VSWhere.vswhere_update_msvc_map(vswhere_exe)
    if not msvc_map:
        return None

    rval = _cache_pdir_vswhere_queries.get(msvc_version, UNDEFINED)
    if rval != UNDEFINED:
        debug('msvc_version=%s, pdir=%s', repr(msvc_version), repr(rval))
        return rval

    if msvc_version not in _VSWHERE_SUPPORTED_VCVER:
        debug("Unknown version of MSVC: %s", msvc_version)
        raise UnsupportedVersion("Unknown version %s" % msvc_version)

    is_release = True
    key = (msvc_version, is_release)

    msvc_instances = msvc_map.get(key, UNDEFINED)
    if msvc_instances == UNDEFINED:
        debug(
            'msvc instances lookup failed: msvc_version=%s, is_release=%s',
            repr(msvc_version), repr(is_release)
        )
        msvc_instances = []

    save_pdir_kind = []

    pdir = None
    kind_t = None

    for msvc_instance in msvc_instances:

        vcdir = msvc_instance.vc_path

        vckind_t = MSVC.Kind.msvc_version_pdir_vswhere_kind(msvc_version, vcdir, _VCVER_KIND_DETECT[msvc_version])
        if vckind_t.skip:
            if vckind_t.save:
                debug('save kind: msvc_version=%s, pdir=%s', repr(msvc_version), repr(vcdir))
                save_pdir_kind.append((vcdir, vckind_t))
            else:
                debug('skip kind: msvc_version=%s, pdir=%s', repr(msvc_version), repr(vcdir))
            continue

        pdir = vcdir
        kind_t = vckind_t
        break

    if not pdir and not kind_t:
        if save_pdir_kind:
            pdir, kind_t = save_pdir_kind[0]

    MSVC.Kind.msvc_version_register_kind(msvc_version, kind_t)

    debug('msvc_version=%s, pdir=%s', repr(msvc_version), repr(pdir))
    _cache_pdir_vswhere_queries[msvc_version] = pdir

    return pdir

_cache_pdir_registry_queries = {}

def _find_vc_pdir_registry(msvc_version):
    """ Find the MSVC product directory using the registry.

    Args:
        msvc_version: MSVC version to search for

    Returns:
        MSVC install dir or None

    Raises:
        UnsupportedVersion: if the version is not known by this file

    """
    global _cache_pdir_registry_queries

    rval = _cache_pdir_registry_queries.get(msvc_version, UNDEFINED)
    if rval != UNDEFINED:
        debug('msvc_version=%s, pdir=%s', repr(msvc_version), repr(rval))
        return rval

    try:
        regkeys = _VCVER_TO_PRODUCT_DIR[msvc_version]
    except KeyError:
        debug("Unknown version of MSVC: %s", msvc_version)
        raise UnsupportedVersion("Unknown version %s" % msvc_version) from None

    save_pdir_kind = []

    is_win64 = common.is_win64()

    pdir = None
    kind_t = None

    root = 'Software\\'
    for hkroot, key in regkeys:

        if not hkroot or not key:
            continue

        if is_win64:
            msregkeys = [root + 'Wow6432Node\\' + key, root + key]
        else:
            msregkeys = [root + key]

        vcdir = None
        for msregkey in msregkeys:
            debug('trying VC registry key %s', repr(msregkey))
            try:
                vcdir = common.read_reg(msregkey, hkroot)
            except OSError:
                continue
            if vcdir:
                break

        if not vcdir:
            debug('no VC registry key %s', repr(key))
            continue

        is_vcforpython = False

        is_vsroot = False
        if msvc_version == '9.0' and key.lower().endswith('\\vcforpython\\9.0\\installdir'):
            # Visual C++ for Python registry key is VS installdir (root) not VC productdir
            is_vsroot = True
            is_vcforpython = True
        elif msvc_version in ('14.0Exp', '12.0Exp', '11.0Exp') and key.lower().endswith('\\setup\\vs\\productdir'):
            # Visual Studio 2015/2013/2012 Express is VS productdir (root) not VC productdir
            is_vsroot = True

        if is_vsroot:
            vcdir = os.path.join(vcdir, 'VC')
            debug('convert vs root to vc dir: %s', repr(vcdir))

        if not os.path.exists(vcdir):
            debug('reg says dir is %s, but it does not exist. (ignoring)', repr(vcdir))
            continue

        vckind_t = MSVC.Kind.msvc_version_pdir_registry_kind(msvc_version, vcdir, _VCVER_KIND_DETECT[msvc_version], is_vcforpython)
        if vckind_t.skip:
            if vckind_t.save:
                debug('save kind: msvc_version=%s, pdir=%s', repr(msvc_version), repr(vcdir))
                save_pdir_kind.append((vcdir, vckind_t))
            else:
                debug('skip kind: msvc_version=%s, pdir=%s', repr(msvc_version), repr(vcdir))
            continue

        pdir = vcdir
        kind_t = vckind_t
        break

    if not pdir and not kind_t:
        if save_pdir_kind:
            pdir, kind_t = save_pdir_kind[0]

    MSVC.Kind.msvc_version_register_kind(msvc_version, kind_t)

    debug('msvc_version=%s, pdir=%s', repr(msvc_version), repr(pdir))
    _cache_pdir_registry_queries[msvc_version] = pdir

    return pdir

def _find_vc_pdir(msvc_version, vswhere_exe):
    """Find the MSVC product directory for the given version.

    Args:
        msvc_version: str
            msvc version (major.minor, e.g. 10.0)

        vswhere_exe: str
            vswhere executable or None

    Returns:
        str: Path found in registry, or None

    Raises:
        UnsupportedVersion: if the version is not known by this file.

        UnsupportedVersion inherits from VisualCException.

    """

    if msvc_version in _VSWHERE_SUPPORTED_VCVER:

        pdir = _find_vc_pdir_vswhere(msvc_version, vswhere_exe)
        if pdir:
            debug('VC found: %s, dir=%s', repr(msvc_version), repr(pdir))
            return pdir

    elif msvc_version in _VCVER_TO_PRODUCT_DIR:

        pdir = _find_vc_pdir_registry(msvc_version)
        if pdir:
            debug('VC found: %s, dir=%s', repr(msvc_version), repr(pdir))
            return pdir

    else:

        debug("Unknown version of MSVC: %s", repr(msvc_version))
        raise UnsupportedVersion("Unknown version %s" % repr(msvc_version)) from None

    debug('no VC found for version %s', repr(msvc_version))
    return None

def find_vc_pdir(msvc_version, env=None):
    """Find the MSVC product directory for the given version.

    Args:
        msvc_version: str
            msvc version (major.minor, e.g. 10.0)
        env:
            optional to look up VSWHERE variable

    Returns:
        str: Path found in registry, or None

    Raises:
        UnsupportedVersion: if the version is not known by this file.

        UnsupportedVersion inherits from VisualCException.

    """

    frozen_binary, _ = _VSWhereExecutable.vswhere_freeze_env(env)

    pdir = _find_vc_pdir(msvc_version, frozen_binary.vswhere_exe)
    debug('pdir=%s', repr(pdir))

    return pdir

# register find_vc_pdir function with Kind routines
# in case of unknown msvc_version (just in case)
MSVC.Kind.register_msvc_version_pdir_func(find_vc_pdir)

def _reset_vc_pdir():
    debug('reset pdir caches')
    global _cache_pdir_vswhere_queries
    global _cache_pdir_registry_queries
    _cache_pdir_vswhere_queries = {}
    _cache_pdir_registry_queries = {}

def find_batch_file(msvc_version, host_arch, target_arch, pdir):
    """
    Find the location of the batch script which should set up the compiler
    for any TARGET_ARCH whose compilers were installed by Visual Studio/VCExpress

    In newer (2017+) compilers, make use of the fact there are vcvars
    scripts named with a host_target pair that calls vcvarsall.bat properly,
    so use that and return an empty argument.
    """

    # filter out e.g. "Exp" from the version name
    vernum = float(get_msvc_version_numeric(msvc_version))
    vernum_int = int(vernum * 10)

    sdk_pdir = pdir

    arg = ''
    vcdir = None
    clexe = None
    depbat = None

    if vernum_int >= 143:
        # 14.3 (VS2022) and later
        batfiledir = os.path.join(pdir, "Auxiliary", "Build")
        batfile, _ = _GE2022_HOST_TARGET_BATCHFILE_CLPATHCOMPS[(host_arch, target_arch)]
        batfilename = os.path.join(batfiledir, batfile)
        vcdir = pdir
    elif 143 > vernum_int >= 141:
        # 14.2 (VS2019) to 14.1 (VS2017)
        batfiledir = os.path.join(pdir, "Auxiliary", "Build")
        batfile, _ = _LE2019_HOST_TARGET_BATCHFILE_CLPATHCOMPS[(host_arch, target_arch)]
        batfilename = os.path.join(batfiledir, batfile)
        vcdir = pdir
    elif 141 > vernum_int >= 100:
        # 14.0 (VS2015) to 10.0 (VS2010)
        arg, batfile, cl_path_comps = _LE2015_HOST_TARGET_BATCHARG_BATCHFILE_CLPATHCOMPS[(host_arch, target_arch)]
        batfilename = os.path.join(pdir, "vcvarsall.bat")
        depbat = os.path.join(pdir, *cl_path_comps, batfile)
        clexe = os.path.join(pdir, *cl_path_comps, _CL_EXE_NAME)
    elif 100 > vernum_int >= 80:
        # 9.0 (VS2008) to 8.0 (VS2005)
        arg, batfile, cl_path_comps = _LE2008_HOST_TARGET_BATCHARG_BATCHFILE_CLPATHCOMPS[(host_arch, target_arch)]
        if vernum_int == 90 and MSVC.Kind.msvc_version_is_vcforpython(msvc_version):
            # 9.0 (VS2008) Visual C++ for Python:
            #     sdk batch files do not point to the VCForPython installation
            #     vcvarsall batch file is in installdir not productdir (e.g., vc\..\vcvarsall.bat)
            #     dependency batch files are not called from vcvarsall.bat
            sdk_pdir = None
            batfilename = os.path.join(pdir, os.pardir, "vcvarsall.bat")
            depbat = None
        else:
            batfilename = os.path.join(pdir, "vcvarsall.bat")
            depbat = os.path.join(pdir, *cl_path_comps, batfile)
        clexe = os.path.join(pdir, *cl_path_comps, _CL_EXE_NAME)
    else:  # 80 > vernum_int
        # 7.1 (VS2003) and earlier
        pdir = os.path.join(pdir, "Bin")
        batfilename = os.path.join(pdir, "vcvars32.bat")
        clexe = os.path.join(pdir, _CL_EXE_NAME)

    if not os.path.exists(batfilename):
        debug("batch file not found: %s", batfilename)
        batfilename = None

    if clexe and not os.path.exists(clexe):
        debug("%s not found: %s", _CL_EXE_NAME, clexe)
        batfilename = None

    if depbat and not os.path.exists(depbat):
        debug("dependency batch file not found: %s", depbat)
        batfilename = None

    return batfilename, arg, vcdir, sdk_pdir

def find_batch_file_sdk(host_arch, target_arch, sdk_pdir):
    """
    Find the location of the sdk batch script which should set up the compiler
    for any TARGET_ARCH whose compilers were installed by Visual Studio/VCExpress
    """

    installed_sdks = get_installed_sdks()
    for _sdk in installed_sdks:
        sdk_bat_file = _sdk.get_sdk_vc_script(host_arch, target_arch)
        if not sdk_bat_file:
            debug("sdk batch file not found:%s", _sdk)
        else:
            sdk_bat_file_path = os.path.join(sdk_pdir, sdk_bat_file)
            if os.path.exists(sdk_bat_file_path):
                debug('sdk_bat_file_path:%s', sdk_bat_file_path)
                return sdk_bat_file_path

    return None

__INSTALLED_VCS_RUN = None

def _reset_installed_vcs():
    global __INSTALLED_VCS_RUN
    debug('reset __INSTALLED_VCS_RUN')
    __INSTALLED_VCS_RUN = None

_VC_TOOLS_VERSION_FILE_PATH = ['Auxiliary', 'Build', 'Microsoft.VCToolsVersion.default.txt']
_VC_TOOLS_VERSION_FILE = os.sep.join(_VC_TOOLS_VERSION_FILE_PATH)

def _check_files_exist_in_vc_dir(env, vc_dir, msvc_version):
    """Return status of finding batch file and cl.exe to use.

    Locates required vcvars batch files and cl in the vc_dir depending on
    TARGET_ARCH, HOST_ARCH and the msvc version. TARGET_ARCH and HOST_ARCH
    can be extracted from the passed env, unless the env is None, in which
    case the native platform is assumed for the host and all associated
    targets.

    Args:
        env: Environment
            a construction environment, usually if this is passed its
            because there is a desired TARGET_ARCH to be used when searching
            for a cl.exe
        vc_dir: str
            the path to the VC dir in the MSVC installation
        msvc_version: str
            msvc version (major.minor, e.g. 10.0)

    Returns:
        bool:

    """

    # Find the host, target, and all candidate (host, target) platform combinations:
    platforms = get_host_target(env, msvc_version, all_host_targets=True)
    debug("host_platform %s, target_platform %s host_target_list %s", *platforms)
    host_platform, target_platform, host_target_list = platforms

    vernum = float(get_msvc_version_numeric(msvc_version))
    vernum_int = int(vernum * 10)

    # make sure the cl.exe exists meaning the tool is installed
    if vernum_int >= 141:
        # 14.1 (VS2017) and later
        # 2017 and newer allowed multiple versions of the VC toolset to be
        # installed at the same time. This changes the layout.
        # Just get the default tool version for now
        # TODO: support setting a specific minor VC version
        default_toolset_file = os.path.join(vc_dir, _VC_TOOLS_VERSION_FILE)
        try:
            with open(default_toolset_file) as f:
                vc_specific_version = f.readlines()[0].strip()
        except OSError:
            debug('failed to read %s', default_toolset_file)
            return False
        except IndexError:
            debug('failed to find MSVC version in %s', default_toolset_file)
            return False

        if vernum_int >= 143:
            # 14.3 (VS2022) and later
            host_target_batchfile_clpathcomps = _GE2022_HOST_TARGET_BATCHFILE_CLPATHCOMPS
        else:
            # 14.2 (VS2019) to 14.1 (VS2017)
            host_target_batchfile_clpathcomps = _LE2019_HOST_TARGET_BATCHFILE_CLPATHCOMPS

        for host_platform, target_platform in host_target_list:

            debug('host platform %s, target platform %s for version %s', host_platform, target_platform, msvc_version)

            batchfile_clpathcomps = host_target_batchfile_clpathcomps.get((host_platform, target_platform), None)
            if batchfile_clpathcomps is None:
                debug('unsupported host/target platform combo: (%s,%s)', host_platform, target_platform)
                continue

            batfile, cl_path_comps = batchfile_clpathcomps

            batfile_path = os.path.join(vc_dir, "Auxiliary", "Build", batfile)
            if not os.path.exists(batfile_path):
                debug("batch file not found: %s", batfile_path)
                continue

            cl_path = os.path.join(vc_dir, 'Tools', 'MSVC', vc_specific_version, *cl_path_comps, _CL_EXE_NAME)
            if not os.path.exists(cl_path):
                debug("%s not found: %s", _CL_EXE_NAME, cl_path)
                continue

            debug('%s found: %s', _CL_EXE_NAME, cl_path)
            return True

    elif 141 > vernum_int >= 80:
        # 14.0 (VS2015) to 8.0 (VS2005)

        if vernum_int >= 100:
            # 14.0 (VS2015) to 10.0 (VS2010)
            host_target_batcharg_batchfile_clpathcomps = _LE2015_HOST_TARGET_BATCHARG_BATCHFILE_CLPATHCOMPS
        else:
            # 9.0 (VS2008) to 8.0 (VS2005)
            host_target_batcharg_batchfile_clpathcomps = _LE2008_HOST_TARGET_BATCHARG_BATCHFILE_CLPATHCOMPS

        if vernum_int == 90 and MSVC.Kind.msvc_version_is_vcforpython(msvc_version):
            # 9.0 (VS2008) Visual C++ for Python:
            #     vcvarsall batch file is in installdir not productdir (e.g., vc\..\vcvarsall.bat)
            #     dependency batch files are not called from vcvarsall.bat
            batfile_path = os.path.join(vc_dir, os.pardir, "vcvarsall.bat")
            check_depbat = False
        else:
            batfile_path = os.path.join(vc_dir, "vcvarsall.bat")
            check_depbat = True

        if not os.path.exists(batfile_path):
            debug("batch file not found: %s", batfile_path)
            return False

        for host_platform, target_platform in host_target_list:

            debug('host platform %s, target platform %s for version %s', host_platform, target_platform, msvc_version)

            batcharg_batchfile_clpathcomps = host_target_batcharg_batchfile_clpathcomps.get(
                (host_platform, target_platform), None
            )

            if batcharg_batchfile_clpathcomps is None:
                debug('unsupported host/target platform combo: (%s,%s)', host_platform, target_platform)
                continue

            _, batfile, cl_path_comps = batcharg_batchfile_clpathcomps

            if check_depbat:
                batfile_path = os.path.join(vc_dir, *cl_path_comps, batfile)
                if not os.path.exists(batfile_path):
                    debug("batch file not found: %s", batfile_path)
                    continue

            cl_path = os.path.join(vc_dir, *cl_path_comps, _CL_EXE_NAME)
            if not os.path.exists(cl_path):
                debug("%s not found: %s", _CL_EXE_NAME, cl_path)
                continue

            debug('%s found: %s', _CL_EXE_NAME, cl_path)
            return True

    elif 80 > vernum_int >= 60:
        # 7.1 (VS2003) to 6.0 (VS6)

        # quick check for vc_dir/bin and vc_dir/ before walk
        # need to check root as the walk only considers subdirectories
        for cl_dir in ('bin', ''):
            cl_path = os.path.join(vc_dir, cl_dir, _CL_EXE_NAME)
            if os.path.exists(cl_path):
                debug('%s found %s', _CL_EXE_NAME, cl_path)
                return True
        # not in bin or root: must be in a subdirectory
        for cl_root, cl_dirs, _ in os.walk(vc_dir):
            for cl_dir in cl_dirs:
                cl_path = os.path.join(cl_root, cl_dir, _CL_EXE_NAME)
                if os.path.exists(cl_path):
                    debug('%s found: %s', _CL_EXE_NAME, cl_path)
                    return True
        return False

    else:
        # version not supported return false
        debug('unsupported MSVC version: %s', str(vernum))

    return False

def get_installed_vcs(env=None):
    global __INSTALLED_VCS_RUN

    _VSWhereExecutable.vswhere_freeze_env(env)

    if __INSTALLED_VCS_RUN is not None:
        return __INSTALLED_VCS_RUN

    save_target_arch = env.get('TARGET_ARCH', UNDEFINED) if env else None
    force_target = env and save_target_arch and save_target_arch != UNDEFINED

    if force_target:
        del env['TARGET_ARCH']
        debug("delete env['TARGET_ARCH']")

    installed_versions = []

    for ver in _VCVER:
        debug('trying to find VC %s', ver)
        try:
            VC_DIR = find_vc_pdir(ver, env)
            if VC_DIR:
                debug('found VC %s', ver)
                if _check_files_exist_in_vc_dir(env, VC_DIR, ver):
                    installed_versions.append(ver)
                else:
                    debug('no compiler found %s', ver)
            else:
                debug('return None for ver %s', ver)
        except (MSVCUnsupportedTargetArch, MSVCUnsupportedHostArch, VSWhereUserError):
            # Allow these exceptions to propagate further as it should cause
            # SCons to exit with an error code
            raise
        except VisualCException as e:
            debug('did not find VC %s: caught exception %s', ver, str(e))

    if force_target:
        env['TARGET_ARCH'] = save_target_arch
        debug("restore env['TARGET_ARCH']=%s", save_target_arch)

    __INSTALLED_VCS_RUN = installed_versions
    debug("__INSTALLED_VCS_RUN=%s", __INSTALLED_VCS_RUN)
    return __INSTALLED_VCS_RUN

def reset_installed_vcs():
    """Make it try again to find VC.  This is just for the tests."""
    _reset_installed_vcs()
    _reset_vc_pdir()
    _VSWhereExecutable.reset()
    _VSWhere.reset()
    MSVC._reset()

def msvc_default_version(env=None):
    """Get default msvc version."""
    vcs = get_installed_vcs(env)
    msvc_version = vcs[0] if vcs else None
    debug('msvc_version=%s', repr(msvc_version))
    return msvc_version

def get_installed_vcs_components(env=None):
    """Test suite convenience function: return list of installed msvc version component tuples"""
    vcs = get_installed_vcs(env)
    msvc_version_component_defs = [MSVC.Util.msvc_version_components(vcver) for vcver in vcs]
    return msvc_version_component_defs

def _check_cl_exists_in_script_env(data):
    """Find cl.exe in the script environment path."""
    cl_path = None
    if data and 'PATH' in data:
        for p in data['PATH']:
            cl_exe = os.path.join(p, _CL_EXE_NAME)
            if os.path.exists(cl_exe):
                cl_path = cl_exe
                break
    have_cl = True if cl_path else False
    debug('have_cl: %s, cl_path: %s', have_cl, cl_path)
    return have_cl, cl_path

# Running these batch files isn't cheap: most of the time spent in
# msvs.generate() is due to vcvars*.bat.  In a build that uses "tools='msvs'"
# in multiple environments, for example:
#    env1 = Environment(tools='msvs')
#    env2 = Environment(tools='msvs')
# we can greatly improve the speed of the second and subsequent Environment
# (or Clone) calls by memoizing the environment variables set by vcvars*.bat.
#
# Updated: by 2018, vcvarsall.bat had gotten so expensive (vs2017 era)
# it was breaking CI builds because the test suite starts scons so many
# times and the existing memo logic only helped with repeated calls
# within the same scons run. Windows builds on the CI system were split
# into chunks to get around single-build time limits.
# With VS2019 it got even slower and an optional persistent cache file
# was introduced. The cache now also stores only the parsed vars,
# not the entire output of running the batch file - saves a bit
# of time not parsing every time.

script_env_cache = {}

def script_env(env, script, version, args=None):
    global script_env_cache

    if version not in script_env_cache:
        script_env_cache[version] = common.read_script_env_cache(version=version)
    current_env_cache = script_env_cache[version]

    cache_key = (script, args if args else None)
    cache_data = current_env_cache.get(cache_key, None)
    if cache_data is None:
        miss_reason = "No cache entry for this script/args"
    else:
        miss_reason = None

    # Brief sanity check: if we got a value for the key,
    # see if it has a VCToolsInstallDir entry that is not empty.
    # If so, and that path does not exist, invalidate the entry.
    # If empty, this is an old compiler, just leave it alone.
    if cache_data is not None:
        try:
            toolsdir = cache_data["VCToolsInstallDir"]
        except KeyError:
            # we write this value, so should not happen
            pass
        else:
            if toolsdir:
                toolpath = Path(toolsdir[0])
                if not toolpath.exists():
                    cache_data = None
                    miss_reason = "VCToolsInstallDir %s does not exist" % toolpath

    # Nuitka: We use a very much enhanced algorithm here for checking that the
    # cache is still valid.
    if cache_data is not None:
        if "script_mtime" not in cache_data:
             cache_data = None
             miss_reason = "script_mtime missing in cache"
        else:
            try:
                if int(os.path.getmtime(script)) != int(cache_data["script_mtime"]):
                     cache_data = None
                     miss_reason = "Script modified (mtime mismatch)"
                elif isinstance(cache_data["script_mtime"], float):
                     cache_data = None
                     miss_reason = "Script mtime is float (legacy checking)"
            except (OSError, ValueError):
                 cache_data = None
                 miss_reason = "Error checking script mtime"

    if cache_data is not None:
        # Check that all the INCLUDE and LIB paths still exist.
        for env_var in ("INCLUDE", "LIB"):
            if env_var not in cache_data:
                continue

            for path in cache_data[env_var]:
                if not os.path.exists(path):
                    cache_data = None
                    miss_reason = "Path %s in %s does not exist" % (path, env_var)
                    break

            if cache_data is None:
                break

    if cache_data is not None:
         # Check if there is a newer SDK version
        if "WindowsSdkDir" in cache_data and "WindowsSDKVersion" in cache_data:
            windows_sdk_dir = None
            for candidate in cache_data["WindowsSdkDir"]:
                 if os.path.isdir(os.path.join(candidate, "Include")):
                      windows_sdk_dir = candidate
                      break

            windows_sdk_version = None
            for candidate in cache_data["WindowsSDKVersion"]:
                 if candidate.startswith("10.0."):
                      windows_sdk_version = candidate
                      break

            if windows_sdk_dir and windows_sdk_version:
                windows_sdk_dir = windows_sdk_dir.rstrip("\\/")
                windows_sdk_version = windows_sdk_version.rstrip("\\/")
                windows_sdk_include_dir = os.path.join(windows_sdk_dir, "Include")

                if os.path.isdir(windows_sdk_include_dir):
                     found_newer_version = False

                     try:
                         cached_tuple = tuple(int(d) for d in windows_sdk_version.split("."))
                     except ValueError:
                         # If cached version is invalid (e.g. contains chars), we can't reliably compare.
                         # Fallback or assume valid? Assuming valid or skip logic.
                         # However, we filtered earlier for "10.0.", so likely valid.
                         cached_tuple = None

                     if cached_tuple:
                         for entry in os.listdir(windows_sdk_include_dir):
                              if entry == windows_sdk_version:
                                  continue

                              if not entry.startswith("10.0."):
                                  continue

                              # Compare versions as tuples of integers to handle "10.0.10.0" > "10.0.9.0" correctly.
                              try:
                                   entry_tuple = tuple(int(d) for d in entry.split("."))
                              except ValueError:
                                   continue

                              if entry_tuple > cached_tuple:
                                   found_newer_version = True
                                   break

                     if found_newer_version:
                          cache_data = None
                          miss_reason = "Newer SDK version found"

    if cache_data is not None:
         if os.environ.get("NUITKA_SCONS_CHECK_MSVC_CACHE"):
              print("Nuitka-Scons: MSVC Environment Cache Hit (version %s)" % version)

    if cache_data is None:
        if os.environ.get("NUITKA_SCONS_CHECK_MSVC_CACHE"):
             print("Nuitka-Scons: MSVC Environment Cache Miss (version %s): %s" % (version, miss_reason))

        skip_sendtelemetry = _skip_sendtelemetry(env)
        stdout = common.get_output(script, args, skip_sendtelemetry=skip_sendtelemetry)
        cache_data = common.parse_output(stdout)

        try:
             cache_data["script_mtime"] = int(os.path.getmtime(script))
        except OSError:
             pass

        # debug(stdout)
        olines = stdout.splitlines()

        # process stdout: batch file errors (not necessarily first line)
        script_errlog = []
        for line in olines:
            if re_script_output_error.match(line):
                if not script_errlog:
                    script_errlog.append('vc script errors detected:')
                script_errlog.append(line)

        if script_errlog:
            script_errmsg = '\n'.join(script_errlog)

            have_cl, _ = _check_cl_exists_in_script_env(cache_data)

            debug(
                'script=%s args=%s have_cl=%s, errors=%s',
                repr(script), repr(args), repr(have_cl), script_errmsg
            )
            MSVC.Policy.msvc_scripterror_handler(env, script_errmsg)

            if not have_cl:
                # detected errors, cl.exe not on path
                raise BatchFileExecutionError(script_errmsg)

        # once we updated cache, give a chance to write out if user wanted
        # once we updated cache, give a chance to write out if user wanted
        current_env_cache[cache_key] = cache_data
        common.write_script_env_cache(current_env_cache, version=version)

    return cache_data

def get_default_version(env):
    msvc_version = env.get('MSVC_VERSION')
    msvs_version = env.get('MSVS_VERSION')
    debug('msvc_version:%s msvs_version:%s', msvc_version, msvs_version)

    if msvs_version and not msvc_version:
        SCons.Warnings.warn(
                SCons.Warnings.DeprecatedWarning,
                "MSVS_VERSION is deprecated: please use MSVC_VERSION instead ")
        return msvs_version
    elif msvc_version and msvs_version:
        if not msvc_version == msvs_version:
            SCons.Warnings.warn(
                    SCons.Warnings.VisualVersionMismatch,
                    "Requested msvc version (%s) and msvs version (%s) do "
                    "not match: please use MSVC_VERSION only to request a "
                    "visual studio version, MSVS_VERSION is deprecated"
                    % (msvc_version, msvs_version))
        return msvs_version

    if not msvc_version:
        msvc_version = msvc_default_version(env)
        if not msvc_version:
            #SCons.Warnings.warn(SCons.Warnings.VisualCMissingWarning, msg)
            debug('No installed VCs')
            return None
        debug('using default installed MSVC version %s', repr(msvc_version))
    else:
        debug('using specified MSVC version %s', repr(msvc_version))

    return msvc_version

def msvc_setup_env_once(env, tool=None):
    try:
        has_run = env["MSVC_SETUP_RUN"]
    except KeyError:
        has_run = False

    if not has_run:
        MSVC.SetupEnvDefault.register_setup(env, msvc_exists)
        msvc_setup_env(env)
        env["MSVC_SETUP_RUN"] = True

    req_tools = MSVC.SetupEnvDefault.register_iserror(env, tool, msvc_exists)
    if req_tools:
        msg = "No versions of the MSVC compiler were found.\n" \
              "  Visual Studio C/C++ compilers may not be set correctly.\n" \
              "  Requested tool(s) are: {}".format(req_tools)
        MSVC.Policy.msvc_notfound_handler(env, msg)

def msvc_find_valid_batch_script(env, version):
    """Find and execute appropriate batch script to set up build env.

    The MSVC build environment depends heavily on having the shell
    environment set.  SCons does not inherit that, and does not count
    on that being set up correctly anyway, so it tries to find the right
    MSVC batch script, or the right arguments to the generic batch script
    vcvarsall.bat, and run that, so we have a valid environment to build in.
    There are dragons here: the batch scripts don't fail (see comments
    elsewhere), they just leave you with a bad setup, so try hard to
    get it right.
    """

    # Find the product directory
    pdir = None
    try:
        pdir = find_vc_pdir(version, env)
    except UnsupportedVersion:
        # Unsupported msvc version (raise MSVCArgumentError?)
        pass
    debug('product directory: version=%s, pdir=%s', version, pdir)

    # Find the host, target, and all candidate (host, target) platform combinations:
    platforms = get_host_target(env, version)
    debug("host_platform %s, target_platform %s host_target_list %s", *platforms)
    host_platform, target_platform, host_target_list = platforms

    d = None
    version_installed = False

    if pdir:

        # Query all candidate sdk (host, target, sdk_pdir) after vc_script pass if necessary
        sdk_queries = []

        for host_arch, target_arch, in host_target_list:
            # Set to current arch.
            env['TARGET_ARCH'] = target_arch
            arg = ''

            # Try to locate a batch file for this host/target platform combo
            try:
                (vc_script, arg, vc_dir, sdk_pdir) = find_batch_file(version, host_arch, target_arch, pdir)
                debug('vc_script:%s vc_script_arg:%s', vc_script, arg)
                version_installed = True
            except VisualCException as e:
                msg = str(e)
                debug('Caught exception while looking for batch file (%s)', msg)
                version_installed = False
                continue

            # Save (host, target, sdk_pdir) platform combo for sdk queries
            if sdk_pdir:
                sdk_query = (host_arch, target_arch, sdk_pdir)
                if sdk_query not in sdk_queries:
                    debug('save sdk_query host=%s, target=%s, sdk_pdir=%s', host_arch, target_arch, sdk_pdir)
                    sdk_queries.append(sdk_query)

            if not vc_script:
                continue

            if not target_platform and MSVC.ScriptArguments.msvc_script_arguments_has_uwp(env):
                # no target arch specified and is a store/uwp build
                if MSVC.Kind.msvc_version_skip_uwp_target(env, version):
                    # store/uwp may not be supported for all express targets (prevent constraint error)
                    debug('skip uwp target arch: version=%s, target=%s', repr(version), repr(target_arch))
                    continue

            # Try to use the located batch file for this host/target platform combo
            arg = MSVC.ScriptArguments.msvc_script_arguments(env, version, vc_dir, arg)
            debug('trying vc_script:%s, vc_script_args:%s', repr(vc_script), arg)
            try:
                d = script_env(env, vc_script, args=arg, version=version)
            except BatchFileExecutionError as e:
                debug('failed vc_script:%s, vc_script_args:%s, error:%s', repr(vc_script), arg, e)
                vc_script = None
                continue

            have_cl, _ = _check_cl_exists_in_script_env(d)
            if not have_cl:
                debug('skip cl.exe not found vc_script:%s, vc_script_args:%s', repr(vc_script), arg)
                continue

            debug("Found a working script/target: %s/%s", repr(vc_script), arg)
            break # We've found a working target_platform, so stop looking

        if not d:
            for host_arch, target_arch, sdk_pdir in sdk_queries:
                # Set to current arch.
                env['TARGET_ARCH'] = target_arch

                sdk_script = find_batch_file_sdk(host_arch, target_arch, sdk_pdir)
                if not sdk_script:
                    continue

                # Try to use the sdk batch file for this (host, target, sdk_pdir) combo
                debug('trying sdk_script:%s', repr(sdk_script))
                try:
                    d = script_env(env, sdk_script, version=version)
                    version_installed = True
                except BatchFileExecutionError as e:
                    debug('failed sdk_script:%s, error=%s', repr(sdk_script), e)
                    continue

                have_cl, _ = _check_cl_exists_in_script_env(d)
                if not have_cl:
                    debug('skip cl.exe not found sdk_script:%s', repr(sdk_script))
                    continue

                debug("Found a working script/target: %s", repr(sdk_script))
                break # We've found a working script, so stop looking

    # If we cannot find a viable installed compiler, reset the TARGET_ARCH
    # To it's initial value
    if not d:
        env['TARGET_ARCH'] = target_platform

        if version_installed:
            msg = "MSVC version '{}' working host/target script was not found.\n" \
                  "  Host = '{}', Target = '{}'\n" \
                  "  Visual Studio C/C++ compilers may not be set correctly".format(
                     version, host_platform, target_platform
                  )
        else:
            installed_vcs = get_installed_vcs(env)
            if installed_vcs:
                msg = "MSVC version '{}' was not found.\n" \
                      "  Visual Studio C/C++ compilers may not be set correctly.\n" \
                      "  Installed versions are: {}".format(version, installed_vcs)
            else:
                msg = "MSVC version '{}' was not found.\n" \
                      "  No versions of the MSVC compiler were found.\n" \
                      "  Visual Studio C/C++ compilers may not be set correctly".format(version)

        MSVC.Policy.msvc_notfound_handler(env, msg)

    return d

def get_use_script_use_settings(env):

    #   use_script  use_settings   return values   action
    #     value       ignored      (value, None)   use script or bypass detection
    #   undefined  value not None  (False, value)  use dictionary
    #   undefined  undefined/None  (True,  None)   msvc detection

    # None (documentation) or evaluates False (code): bypass detection
    # need to distinguish between undefined and None
    use_script = env.get('MSVC_USE_SCRIPT', UNDEFINED)

    if use_script != UNDEFINED:
        # use_script defined, use_settings ignored (not type checked)
        return use_script, None

    # undefined or None: use_settings ignored
    use_settings = env.get('MSVC_USE_SETTINGS', None)

    if use_settings is not None:
        # use script undefined, use_settings defined and not None (type checked)
        return False, use_settings

    # use script undefined, use_settings undefined or None
    return True, None

def msvc_setup_env(env):
    debug('called')

    _VSWhereExecutable.vswhere_freeze_env(env)

    version = get_default_version(env)
    if version is None:
        if not msvc_setup_env_user(env):
            MSVC.SetupEnvDefault.set_nodefault()
        return None

    # XXX: we set-up both MSVS version for backward
    # compatibility with the msvs tool
    env['MSVC_VERSION'] = version
    env['MSVS_VERSION'] = version
    env['MSVS'] = {}

    use_script, use_settings = get_use_script_use_settings(env)
    if SCons.Util.is_String(use_script):
        use_script = use_script.strip()
        if not os.path.exists(use_script):
            raise MSVCScriptNotFound(f'Script specified by MSVC_USE_SCRIPT not found: "{use_script}"')
        args = env.subst('$MSVC_USE_SCRIPT_ARGS')
        debug('use_script 1 %s %s', repr(use_script), repr(args))
        d = script_env(env, use_script, args)
    elif use_script:
        d = msvc_find_valid_batch_script(env,version)
        debug('use_script 2 %s', d)
        if not d:
            return d
    elif use_settings is not None:
        if not SCons.Util.is_Dict(use_settings):
            error_msg = f'MSVC_USE_SETTINGS type error: expected a dictionary, found {type(use_settings).__name__}'
            raise MSVCUseSettingsError(error_msg)
        d = use_settings
        debug('use_settings %s', d)
    else:
        debug('MSVC_USE_SCRIPT set to False')
        warn_msg = "MSVC_USE_SCRIPT set to False, assuming environment " \
                   "set correctly."
        # Nuitka: We use this on purpose.
        # SCons.Warnings.warn(SCons.Warnings.VisualCMissingWarning, warn_msg)
        return None

    found_cl_path = None
    found_cl_envpath = None

    seen_path = False
    for k, v in d.items():
        # Nuitka: Make the Windows SDK version visible in environment.
        if k == "WindowsSDKVersion":
            # Always just a single version if any.
            if len(v) == 1:
                env["WindowsSDKVersion"] = v[0].rstrip('\\')
            elif len(v) == 0:
                env["WindowsSDKVersion"] = None
            else:
                assert False, v

            continue

        if not seen_path and k == 'PATH':
            seen_path = True
            found_cl_path = SCons.Util.WhereIs('cl', v)
            found_cl_envpath = SCons.Util.WhereIs('cl', env['ENV'].get(k, []))
        env.PrependENVPath(k, v, delete_existing=True)
        debug("env['ENV']['%s'] = %s", k, env['ENV'][k])

    debug("cl paths: d['PATH']=%s, ENV['PATH']=%s", repr(found_cl_path), repr(found_cl_envpath))

    # final check to issue a warning if the requested compiler is not present
    if not found_cl_path:
        warn_msg = "Could not find requested MSVC compiler 'cl'."
        if CONFIG_CACHE:
            warn_msg += f" SCONS_CACHE_MSVC_CONFIG caching enabled, remove cache file {CONFIG_CACHE} if out of date."
        else:
            warn_msg += " It may need to be installed separately with Visual Studio."
        if found_cl_envpath:
            warn_msg += " A 'cl' was found on the scons ENV path which may be erroneous."
        debug(warn_msg)
        SCons.Warnings.warn(SCons.Warnings.VisualCMissingWarning, warn_msg)

def msvc_exists(env=None, version=None):
    vcs = get_installed_vcs(env)
    if version is None:
        rval = len(vcs) > 0
    else:
        rval = version in vcs
    debug('version=%s, return=%s', repr(version), rval)
    return rval

def msvc_setup_env_user(env=None):
    rval = False
    if env:

        # Intent is to use msvc tools:
        #     MSVC_VERSION:         defined and evaluates True
        #     MSVS_VERSION:         defined and evaluates True
        #     MSVC_USE_SCRIPT:      defined and (is string or evaluates False)
        #     MSVC_USE_SETTINGS:    defined and is not None

        # defined and is True
        for key in ['MSVC_VERSION', 'MSVS_VERSION']:
            if key in env and env[key]:
                rval = True
                debug('key=%s, return=%s', repr(key), rval)
                return rval

        # defined and (is string or is False)
        for key in ['MSVC_USE_SCRIPT']:
            if key in env and (SCons.Util.is_String(env[key]) or not env[key]):
                rval = True
                debug('key=%s, return=%s', repr(key), rval)
                return rval

        # defined and is not None
        for key in ['MSVC_USE_SETTINGS']:
            if key in env and env[key] is not None:
                rval = True
                debug('key=%s, return=%s', repr(key), rval)
                return rval

    debug('return=%s', rval)
    return rval

def msvc_setup_env_tool(env=None, version=None, tool=None):
    MSVC.SetupEnvDefault.register_tool(env, tool, msvc_exists)
    rval = False
    if not rval and msvc_exists(env, version):
        rval = True
    if not rval and msvc_setup_env_user(env):
        rval = True
    return rval

def msvc_sdk_versions(version=None, msvc_uwp_app=False):
    debug('version=%s, msvc_uwp_app=%s', repr(version), repr(msvc_uwp_app))

    rval = []

    if not version:
        version = msvc_default_version()

    if not version:
        debug('no msvc versions detected')
        return rval

    version_def = MSVC.Util.msvc_extended_version_components(version)
    if not version_def:
        msg = f'Unsupported version {version!r}'
        raise MSVCArgumentError(msg)

    rval = MSVC.WinSDK.get_msvc_sdk_version_list(version_def.msvc_version, msvc_uwp_app)
    return rval

def msvc_toolset_versions(msvc_version=None, full=True, sxs=False, vswhere_exe=None):
    debug(
        'msvc_version=%s, full=%s, sxs=%s, vswhere_exe=%s',
        repr(msvc_version), repr(full), repr(sxs), repr(vswhere_exe)
    )

    _VSWhereExecutable.vswhere_freeze_executable(vswhere_exe)

    rval = []

    if not msvc_version:
        msvc_version = msvc_default_version()

    if not msvc_version:
        debug('no msvc versions detected')
        return rval

    if msvc_version not in _VCVER:
        msg = f'Unsupported msvc version {msvc_version!r}'
        raise MSVCArgumentError(msg)

    vc_dir = _find_vc_pdir(msvc_version, vswhere_exe)
    if not vc_dir:
        debug('VC folder not found for version %s', repr(msvc_version))
        return rval

    rval = MSVC.ScriptArguments._msvc_toolset_versions_internal(msvc_version, vc_dir, full=full, sxs=sxs)
    return rval

def msvc_toolset_versions_spectre(msvc_version=None, vswhere_exe=None):
    debug('msvc_version=%s, vswhere_exe=%s', repr(msvc_version), repr(vswhere_exe))

    _VSWhereExecutable.vswhere_freeze_executable(vswhere_exe)

    rval = []

    if not msvc_version:
        msvc_version = msvc_default_version()

    if not msvc_version:
        debug('no msvc versions detected')
        return rval

    if msvc_version not in _VCVER:
        msg = f'Unsupported msvc version {msvc_version!r}'
        raise MSVCArgumentError(msg)

    vc_dir = _find_vc_pdir(msvc_version, vswhere_exe)
    if not vc_dir:
        debug('VC folder not found for version %s', repr(msvc_version))
        return rval

    rval = MSVC.ScriptArguments._msvc_toolset_versions_spectre_internal(msvc_version, vc_dir)
    return rval

_InstalledVersionToolset = namedtuple('_InstalledVersionToolset', [
    'msvc_version_def',
    'toolset_version_def',
])

_InstalledVCSToolsetsComponents = namedtuple('_InstalledVCSToolsetComponents', [
    'sxs_map',
    'toolset_vcs',
    'msvc_toolset_component_defs',
])

def get_installed_vcs_toolsets_components(vswhere_exe=None):
    debug('vswhere_exe=%s', repr(vswhere_exe))

    _VSWhereExecutable.vswhere_freeze_executable(vswhere_exe)

    sxs_map = {}
    toolset_vcs = set()
    msvc_toolset_component_defs = []

    vcs = get_installed_vcs()
    for msvc_version in vcs:

        vc_dir = _find_vc_pdir(msvc_version, vswhere_exe)
        if not vc_dir:
            continue

        msvc_version_def = MSVC.Util.msvc_version_components(msvc_version)
        toolset_vcs.add(msvc_version_def.msvc_version)

        if msvc_version_def.msvc_vernum > 14.0:

            toolsets_sxs, toolsets_full = MSVC.ScriptArguments._msvc_version_toolsets_internal(
                msvc_version, vc_dir
            )

            debug('msvc_version=%s, toolset_sxs=%s', repr(msvc_version), repr(toolsets_sxs))
            sxs_map.update(toolsets_sxs)

        else:

            toolsets_full = [msvc_version_def.msvc_verstr]

        for toolset_version in toolsets_full:
            debug('msvc_version=%s, toolset_version=%s', repr(msvc_version), repr(toolset_version))

            toolset_version_def = MSVC.Util.msvc_extended_version_components(toolset_version)
            if not toolset_version_def:
                continue
            toolset_vcs.add(toolset_version_def.msvc_version)

            rval = _InstalledVersionToolset(
                msvc_version_def=msvc_version_def,
                toolset_version_def=toolset_version_def,
            )
            msvc_toolset_component_defs.append(rval)

    installed_vcs_toolsets_components = _InstalledVCSToolsetsComponents(
        sxs_map=sxs_map,
        toolset_vcs=toolset_vcs,
        msvc_toolset_component_defs=msvc_toolset_component_defs,
    )

    return installed_vcs_toolsets_components

def msvc_query_version_toolset(version=None, prefer_newest=True, vswhere_exe=None):
    """
    Return an msvc version and a toolset version given a version
    specification.

    This is an EXPERIMENTAL proxy for using a toolset version to perform
    msvc instance selection.  This function will be removed when
    toolset version is taken into account during msvc instance selection.

    This function searches for an installed Visual Studio instance that
    contains the requested version. A component suffix (e.g., Exp) is not
    supported for toolset version specifications (e.g., 14.39).

    An MSVCArgumentError is raised when argument validation fails. An
    MSVCToolsetVersionNotFound exception is raised when the requested
    version is not found.

    For Visual Studio 2015 and earlier, the msvc version is returned and
    the toolset version is None.  For Visual Studio 2017 and later, the
    selected toolset version is returned.

    Args:

        version: str
            The version specification may be an msvc version or a toolset
            version.

        prefer_newest: bool
            True:  prefer newer Visual Studio instances.
            False: prefer the "native" Visual Studio instance first. If
                   the native Visual Studio instance is not detected, prefer
                   newer Visual Studio instances.

        vswhere_exe: str
            A vswhere executable location or None.

    Returns:
        tuple: A tuple containing the msvc version and the msvc toolset version.
               The msvc toolset version may be None.

    Raises:
        MSVCToolsetVersionNotFound: when the specified version is not found.
        MSVCArgumentError: when argument validation fails.
    """
    debug(
        'version=%s, prefer_newest=%s, vswhere_exe=%s',
        repr(version), repr(prefer_newest), repr(vswhere_exe)
    )

    _VSWhereExecutable.vswhere_freeze_executable(vswhere_exe)

    msvc_version = None
    msvc_toolset_version = None

    with MSVC.Policy.msvc_notfound_policy_contextmanager('suppress'):

        vcs = get_installed_vcs()

        if not version:
            version = msvc_default_version()

        if not version:
            msg = f'No versions of the MSVC compiler were found'
            debug(f'MSVCToolsetVersionNotFound: {msg}')
            raise MSVCToolsetVersionNotFound(msg)

        version_def = MSVC.Util.msvc_extended_version_components(version)

        if not version_def:
            msg = f'Unsupported MSVC version {version!r}'
            debug(f'MSVCArgumentError: {msg}')
            raise MSVCArgumentError(msg)

        msvc_version = version_def.msvc_version

        if version_def.msvc_suffix:

            if version_def.msvc_verstr != version_def.msvc_toolset_version:
                # toolset version with component suffix
                msg = f'Unsupported MSVC toolset version {version!r}'
                debug(f'MSVCArgumentError: {msg}')
                raise MSVCArgumentError(msg)

            if msvc_version not in vcs:
                msg = f'MSVC version {msvc_version!r} not found'
                debug(f'MSVCToolsetVersionNotFound: {msg}')
                raise MSVCToolsetVersionNotFound(msg)

            if msvc_version not in MSVC.Config.MSVC_VERSION_TOOLSET_SEARCH_MAP:
                debug(
                    'suffix: msvc_version=%s, msvc_toolset_version=%s',
                    repr(msvc_version), repr(msvc_toolset_version)
                )
                return msvc_version, msvc_toolset_version

        if version_def.msvc_vernum > 14.0:
            # VS2017 and later
            force_toolset_msvc_version = False
        else:
            # VS2015 and earlier
            force_toolset_msvc_version = True
            extended_version = version_def.msvc_verstr + '0.00000'
            if not extended_version.startswith(version_def.msvc_toolset_version):
                # toolset not equivalent to msvc version
                msg = 'Unsupported MSVC toolset version {} (expected {})'.format(
                    repr(version), repr(extended_version)
                )
                debug(f'MSVCArgumentError: {msg}')
                raise MSVCArgumentError(msg)

        if msvc_version not in MSVC.Config.MSVC_VERSION_TOOLSET_SEARCH_MAP:

            # VS2013 and earlier

            if msvc_version not in vcs:
                msg = f'MSVC version {version!r} not found'
                debug(f'MSVCToolsetVersionNotFound: {msg}')
                raise MSVCToolsetVersionNotFound(msg)

            debug(
                'earlier: msvc_version=%s, msvc_toolset_version=%s',
                repr(msvc_version), repr(msvc_toolset_version)
            )
            return msvc_version, msvc_toolset_version

        if force_toolset_msvc_version:
            query_msvc_toolset_version = version_def.msvc_verstr
        else:
            query_msvc_toolset_version = version_def.msvc_toolset_version

        if prefer_newest:
            query_version_list = MSVC.Config.MSVC_VERSION_TOOLSET_SEARCH_MAP[msvc_version]
        else:
            query_version_list = MSVC.Config.MSVC_VERSION_TOOLSET_DEFAULTS_MAP[msvc_version] + \
                                 MSVC.Config.MSVC_VERSION_TOOLSET_SEARCH_MAP[msvc_version]

        seen_msvc_version = set()
        for query_msvc_version in query_version_list:

            if query_msvc_version in seen_msvc_version:
                continue
            seen_msvc_version.add(query_msvc_version)

            vc_dir = _find_vc_pdir(query_msvc_version, vswhere_exe)
            if not vc_dir:
                continue

            if query_msvc_version.startswith('14.0'):
                # VS2015 does not support toolset version argument
                msvc_toolset_version = None
                debug(
                    'found: msvc_version=%s, msvc_toolset_version=%s',
                    repr(query_msvc_version), repr(msvc_toolset_version)
                )
                return query_msvc_version, msvc_toolset_version

            try:
                toolset_vcvars = MSVC.ScriptArguments._msvc_toolset_internal(query_msvc_version, query_msvc_toolset_version, vc_dir)
                if toolset_vcvars:
                    msvc_toolset_version = toolset_vcvars
                    debug(
                        'found: msvc_version=%s, msvc_toolset_version=%s',
                        repr(query_msvc_version), repr(msvc_toolset_version)
                    )
                    return query_msvc_version, msvc_toolset_version

            except MSVCToolsetVersionNotFound:
                pass

        msvc_toolset_version = query_msvc_toolset_version

    debug(
        'not found: msvc_version=%s, msvc_toolset_version=%s',
        repr(msvc_version), repr(msvc_toolset_version)
    )

    msg = f'MSVC toolset version {version!r} not found'
    debug(f'MSVCToolsetVersionNotFound: {msg}')
    raise MSVCToolsetVersionNotFound(msg)


# internal consistency check (should be last)
MSVC._verify()
