wsba-hockey 1.0.3__py3-none-any.whl → 1.0.4__py3-none-any.whl

wsba_hockey/evidence/weakside-breakout/node_modules/sqlite3/node_modules/node-gyp/gyp/pylib/gyp/msvs_emulation.py

@@ -0,0 +1,1271 @@
+# Copyright (c) 2012 Google Inc. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""
+This module helps emulate Visual Studio 2008 behavior on top of other
+build systems, primarily ninja.
+"""
+
+import collections
+import os
+import re
+import subprocess
+import sys
+
+from gyp.common import OrderedSet
+import gyp.MSVSUtil
+import gyp.MSVSVersion
+
+windows_quoter_regex = re.compile(r'(\\*)"')
+
+
+def QuoteForRspFile(arg, quote_cmd=True):
+    """Quote a command line argument so that it appears as one argument when
+    processed via cmd.exe and parsed by CommandLineToArgvW (as is typical for
+    Windows programs)."""
+    # See http://goo.gl/cuFbX and http://goo.gl/dhPnp including the comment
+    # threads. This is actually the quoting rules for CommandLineToArgvW, not
+    # for the shell, because the shell doesn't do anything in Windows. This
+    # works more or less because most programs (including the compiler, etc.)
+    # use that function to handle command line arguments.
+
+    # Use a heuristic to try to find args that are paths, and normalize them
+    if arg.find("/") > 0 or arg.count("/") > 1:
+        arg = os.path.normpath(arg)
+
+    # For a literal quote, CommandLineToArgvW requires 2n+1 backslashes
+    # preceding it, and results in n backslashes + the quote. So we substitute
+    # in 2* what we match, +1 more, plus the quote.
+    if quote_cmd:
+        arg = windows_quoter_regex.sub(lambda mo: 2 * mo.group(1) + '\\"', arg)
+
+    # %'s also need to be doubled otherwise they're interpreted as batch
+    # positional arguments. Also make sure to escape the % so that they're
+    # passed literally through escaping so they can be singled to just the
+    # original %. Otherwise, trying to pass the literal representation that
+    # looks like an environment variable to the shell (e.g. %PATH%) would fail.
+    arg = arg.replace("%", "%%")
+
+    # These commands are used in rsp files, so no escaping for the shell (via ^)
+    # is necessary.
+
+    # As a workaround for programs that don't use CommandLineToArgvW, gyp
+    # supports msvs_quote_cmd=0, which simply disables all quoting.
+    if quote_cmd:
+        # Finally, wrap the whole thing in quotes so that the above quote rule
+        # applies and whitespace isn't a word break.
+        return f'"{arg}"'
+
+    return arg
+
+
+def EncodeRspFileList(args, quote_cmd):
+    """Process a list of arguments using QuoteCmdExeArgument."""
+    # Note that the first argument is assumed to be the command. Don't add
+    # quotes around it because then built-ins like 'echo', etc. won't work.
+    # Take care to normpath only the path in the case of 'call ../x.bat' because
+    # otherwise the whole thing is incorrectly interpreted as a path and not
+    # normalized correctly.
+    if not args:
+        return ""
+    if args[0].startswith("call "):
+        call, program = args[0].split(" ", 1)
+        program = call + " " + os.path.normpath(program)
+    else:
+        program = os.path.normpath(args[0])
+    return (program + " "
+            + " ".join(QuoteForRspFile(arg, quote_cmd) for arg in args[1:]))
+
+
+def _GenericRetrieve(root, default, path):
+    """Given a list of dictionary keys |path| and a tree of dicts |root|, find
+    value at path, or return |default| if any of the path doesn't exist."""
+    if not root:
+        return default
+    if not path:
+        return root
+    return _GenericRetrieve(root.get(path[0]), default, path[1:])
+
+
+def _AddPrefix(element, prefix):
+    """Add |prefix| to |element| or each subelement if element is iterable."""
+    if element is None:
+        return element
+    # Note, not Iterable because we don't want to handle strings like that.
+    if isinstance(element, list) or isinstance(element, tuple):
+        return [prefix + e for e in element]
+    else:
+        return prefix + element
+
+
+def _DoRemapping(element, map):
+    """If |element| then remap it through |map|. If |element| is iterable then
+    each item will be remapped. Any elements not found will be removed."""
+    if map is not None and element is not None:
+        if not callable(map):
+            map = map.get  # Assume it's a dict, otherwise a callable to do the remap.
+        if isinstance(element, list) or isinstance(element, tuple):
+            element = filter(None, [map(elem) for elem in element])
+        else:
+            element = map(element)
+    return element
+
+
+def _AppendOrReturn(append, element):
+    """If |append| is None, simply return |element|. If |append| is not None,
+    then add |element| to it, adding each item in |element| if it's a list or
+    tuple."""
+    if append is not None and element is not None:
+        if isinstance(element, list) or isinstance(element, tuple):
+            append.extend(element)
+        else:
+            append.append(element)
+    else:
+        return element
+
+
+def _FindDirectXInstallation():
+    """Try to find an installation location for the DirectX SDK. Check for the
+    standard environment variable, and if that doesn't exist, try to find
+    via the registry. May return None if not found in either location."""
+    # Return previously calculated value, if there is one
+    if hasattr(_FindDirectXInstallation, "dxsdk_dir"):
+        return _FindDirectXInstallation.dxsdk_dir
+
+    dxsdk_dir = os.environ.get("DXSDK_DIR")
+    if not dxsdk_dir:
+        # Setup params to pass to and attempt to launch reg.exe.
+        cmd = ["reg.exe", "query", r"HKLM\Software\Microsoft\DirectX", "/s"]
+        p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        stdout = p.communicate()[0].decode("utf-8")
+        for line in stdout.splitlines():
+            if "InstallPath" in line:
+                dxsdk_dir = line.split("    ")[3] + "\\"
+
+    # Cache return value
+    _FindDirectXInstallation.dxsdk_dir = dxsdk_dir
+    return dxsdk_dir
+
+
+def GetGlobalVSMacroEnv(vs_version):
+    """Get a dict of variables mapping internal VS macro names to their gyp
+    equivalents. Returns all variables that are independent of the target."""
+    env = {}
+    # '$(VSInstallDir)' and '$(VCInstallDir)' are available when and only when
+    # Visual Studio is actually installed.
+    if vs_version.Path():
+        env["$(VSInstallDir)"] = vs_version.Path()
+        env["$(VCInstallDir)"] = os.path.join(vs_version.Path(), "VC") + "\\"
+    # Chromium uses DXSDK_DIR in include/lib paths, but it may or may not be
+    # set. This happens when the SDK is sync'd via src-internal, rather than
+    # by typical end-user installation of the SDK. If it's not set, we don't
+    # want to leave the unexpanded variable in the path, so simply strip it.
+    dxsdk_dir = _FindDirectXInstallation()
+    env["$(DXSDK_DIR)"] = dxsdk_dir if dxsdk_dir else ""
+    # Try to find an installation location for the Windows DDK by checking
+    # the WDK_DIR environment variable, may be None.
+    env["$(WDK_DIR)"] = os.environ.get("WDK_DIR", "")
+    return env
+
+
+def ExtractSharedMSVSSystemIncludes(configs, generator_flags):
+    """Finds msvs_system_include_dirs that are common to all targets, removes
+    them from all targets, and returns an OrderedSet containing them."""
+    all_system_includes = OrderedSet(configs[0].get("msvs_system_include_dirs", []))
+    for config in configs[1:]:
+        system_includes = config.get("msvs_system_include_dirs", [])
+        all_system_includes = all_system_includes & OrderedSet(system_includes)
+    if not all_system_includes:
+        return None
+    # Expand macros in all_system_includes.
+    env = GetGlobalVSMacroEnv(GetVSVersion(generator_flags))
+    expanded_system_includes = OrderedSet(
+        [ExpandMacros(include, env) for include in all_system_includes]
+    )
+    if any(["$" in include for include in expanded_system_includes]):
+        # Some path relies on target-specific variables, bail.
+        return None
+
+    # Remove system includes shared by all targets from the targets.
+    for config in configs:
+        includes = config.get("msvs_system_include_dirs", [])
+        if includes:  # Don't insert a msvs_system_include_dirs key if not needed.
+            # This must check the unexpanded includes list:
+            new_includes = [i for i in includes if i not in all_system_includes]
+            config["msvs_system_include_dirs"] = new_includes
+    return expanded_system_includes
+
+
+class MsvsSettings:
+    """A class that understands the gyp 'msvs_...' values (especially the
+    msvs_settings field). They largely correpond to the VS2008 IDE DOM. This
+    class helps map those settings to command line options."""
+
+    def __init__(self, spec, generator_flags):
+        self.spec = spec
+        self.vs_version = GetVSVersion(generator_flags)
+
+        supported_fields = [
+            ("msvs_configuration_attributes", dict),
+            ("msvs_settings", dict),
+            ("msvs_system_include_dirs", list),
+            ("msvs_disabled_warnings", list),
+            ("msvs_precompiled_header", str),
+            ("msvs_precompiled_source", str),
+            ("msvs_configuration_platform", str),
+            ("msvs_target_platform", str),
+        ]
+        configs = spec["configurations"]
+        for field, default in supported_fields:
+            setattr(self, field, {})
+            for configname, config in configs.items():
+                getattr(self, field)[configname] = config.get(field, default())
+
+        self.msvs_cygwin_dirs = spec.get("msvs_cygwin_dirs", ["."])
+
+        unsupported_fields = [
+            "msvs_prebuild",
+            "msvs_postbuild",
+        ]
+        unsupported = []
+        for field in unsupported_fields:
+            for config in configs.values():
+                if field in config:
+                    unsupported += [
+                        "{} not supported (target {}).".format(
+                            field, spec["target_name"]
+                        )
+                    ]
+        if unsupported:
+            raise Exception("\n".join(unsupported))
+
+    def GetExtension(self):
+        """Returns the extension for the target, with no leading dot.
+
+        Uses 'product_extension' if specified, otherwise uses MSVS defaults based on
+        the target type.
+        """
+        ext = self.spec.get("product_extension", None)
+        if ext:
+            return ext
+        return gyp.MSVSUtil.TARGET_TYPE_EXT.get(self.spec["type"], "")
+
+    def GetVSMacroEnv(self, base_to_build=None, config=None):
+        """Get a dict of variables mapping internal VS macro names to their gyp
+        equivalents."""
+        target_arch = self.GetArch(config)
+        if target_arch == "x86":
+            target_platform = "Win32"
+        else:
+            target_platform = target_arch
+        target_name = self.spec.get("product_prefix", "") + self.spec.get(
+            "product_name", self.spec["target_name"]
+        )
+        target_dir = base_to_build + "\\" if base_to_build else ""
+        target_ext = "." + self.GetExtension()
+        target_file_name = target_name + target_ext
+
+        replacements = {
+            "$(InputName)": "${root}",
+            "$(InputPath)": "${source}",
+            "$(IntDir)": "$!INTERMEDIATE_DIR",
+            "$(OutDir)\\": target_dir,
+            "$(PlatformName)": target_platform,
+            "$(ProjectDir)\\": "",
+            "$(ProjectName)": self.spec["target_name"],
+            "$(TargetDir)\\": target_dir,
+            "$(TargetExt)": target_ext,
+            "$(TargetFileName)": target_file_name,
+            "$(TargetName)": target_name,
+            "$(TargetPath)": os.path.join(target_dir, target_file_name),
+        }
+        replacements.update(GetGlobalVSMacroEnv(self.vs_version))
+        return replacements
+
+    def ConvertVSMacros(self, s, base_to_build=None, config=None):
+        """Convert from VS macro names to something equivalent."""
+        env = self.GetVSMacroEnv(base_to_build, config=config)
+        return ExpandMacros(s, env)
+
+    def AdjustLibraries(self, libraries):
+        """Strip -l from library if it's specified with that."""
+        libs = [lib[2:] if lib.startswith("-l") else lib for lib in libraries]
+        return [
+            lib + ".lib"
+            if not lib.lower().endswith(".lib") and not lib.lower().endswith(".obj")
+            else lib
+            for lib in libs
+        ]
+
+    def _GetAndMunge(self, field, path, default, prefix, append, map):
+        """Retrieve a value from |field| at |path| or return |default|. If
+        |append| is specified, and the item is found, it will be appended to that
+        object instead of returned. If |map| is specified, results will be
+        remapped through |map| before being returned or appended."""
+        result = _GenericRetrieve(field, default, path)
+        result = _DoRemapping(result, map)
+        result = _AddPrefix(result, prefix)
+        return _AppendOrReturn(append, result)
+
+    class _GetWrapper:
+        def __init__(self, parent, field, base_path, append=None):
+            self.parent = parent
+            self.field = field
+            self.base_path = [base_path]
+            self.append = append
+
+        def __call__(self, name, map=None, prefix="", default=None):
+            return self.parent._GetAndMunge(
+                self.field,
+                self.base_path + [name],
+                default=default,
+                prefix=prefix,
+                append=self.append,
+                map=map,
+            )
+
+    def GetArch(self, config):
+        """Get architecture based on msvs_configuration_platform and
+        msvs_target_platform. Returns either 'x86' or 'x64'."""
+        configuration_platform = self.msvs_configuration_platform.get(config, "")
+        platform = self.msvs_target_platform.get(config, "")
+        if not platform:  # If no specific override, use the configuration's.
+            platform = configuration_platform
+        # Map from platform to architecture.
+        return {"Win32": "x86", "x64": "x64", "ARM64": "arm64"}.get(platform, "x86")
+
+    def _TargetConfig(self, config):
+        """Returns the target-specific configuration."""
+        # There's two levels of architecture/platform specification in VS. The
+        # first level is globally for the configuration (this is what we consider
+        # "the" config at the gyp level, which will be something like 'Debug' or
+        # 'Release'), VS2015 and later only use this level
+        if int(self.vs_version.short_name) >= 2015:
+            return config
+        # and a second target-specific configuration, which is an
+        # override for the global one. |config| is remapped here to take into
+        # account the local target-specific overrides to the global configuration.
+        arch = self.GetArch(config)
+        if arch == "x64" and not config.endswith("_x64"):
+            config += "_x64"
+        if arch == "x86" and config.endswith("_x64"):
+            config = config.rsplit("_", 1)[0]
+        return config
+
+    def _Setting(self, path, config, default=None, prefix="", append=None, map=None):
+        """_GetAndMunge for msvs_settings."""
+        return self._GetAndMunge(
+            self.msvs_settings[config], path, default, prefix, append, map
+        )
+
+    def _ConfigAttrib(
+        self, path, config, default=None, prefix="", append=None, map=None
+    ):
+        """_GetAndMunge for msvs_configuration_attributes."""
+        return self._GetAndMunge(
+            self.msvs_configuration_attributes[config],
+            path,
+            default,
+            prefix,
+            append,
+            map,
+        )
+
+    def AdjustIncludeDirs(self, include_dirs, config):
+        """Updates include_dirs to expand VS specific paths, and adds the system
+        include dirs used for platform SDK and similar."""
+        config = self._TargetConfig(config)
+        includes = include_dirs + self.msvs_system_include_dirs[config]
+        includes.extend(
+            self._Setting(
+                ("VCCLCompilerTool", "AdditionalIncludeDirectories"), config, default=[]
+            )
+        )
+        return [self.ConvertVSMacros(p, config=config) for p in includes]
+
+    def AdjustMidlIncludeDirs(self, midl_include_dirs, config):
+        """Updates midl_include_dirs to expand VS specific paths, and adds the
+        system include dirs used for platform SDK and similar."""
+        config = self._TargetConfig(config)
+        includes = midl_include_dirs + self.msvs_system_include_dirs[config]
+        includes.extend(
+            self._Setting(
+                ("VCMIDLTool", "AdditionalIncludeDirectories"), config, default=[]
+            )
+        )
+        return [self.ConvertVSMacros(p, config=config) for p in includes]
+
+    def GetComputedDefines(self, config):
+        """Returns the set of defines that are injected to the defines list based
+        on other VS settings."""
+        config = self._TargetConfig(config)
+        defines = []
+        if self._ConfigAttrib(["CharacterSet"], config) == "1":
+            defines.extend(("_UNICODE", "UNICODE"))
+        if self._ConfigAttrib(["CharacterSet"], config) == "2":
+            defines.append("_MBCS")
+        defines.extend(
+            self._Setting(
+                ("VCCLCompilerTool", "PreprocessorDefinitions"), config, default=[]
+            )
+        )
+        return defines
+
+    def GetCompilerPdbName(self, config, expand_special):
+        """Get the pdb file name that should be used for compiler invocations, or
+        None if there's no explicit name specified."""
+        config = self._TargetConfig(config)
+        pdbname = self._Setting(("VCCLCompilerTool", "ProgramDataBaseFileName"), config)
+        if pdbname:
+            pdbname = expand_special(self.ConvertVSMacros(pdbname))
+        return pdbname
+
+    def GetMapFileName(self, config, expand_special):
+        """Gets the explicitly overridden map file name for a target or returns None
+        if it's not set."""
+        config = self._TargetConfig(config)
+        map_file = self._Setting(("VCLinkerTool", "MapFileName"), config)
+        if map_file:
+            map_file = expand_special(self.ConvertVSMacros(map_file, config=config))
+        return map_file
+
+    def GetOutputName(self, config, expand_special):
+        """Gets the explicitly overridden output name for a target or returns None
+        if it's not overridden."""
+        config = self._TargetConfig(config)
+        type = self.spec["type"]
+        root = "VCLibrarianTool" if type == "static_library" else "VCLinkerTool"
+        # TODO(scottmg): Handle OutputDirectory without OutputFile.
+        output_file = self._Setting((root, "OutputFile"), config)
+        if output_file:
+            output_file = expand_special(
+                self.ConvertVSMacros(output_file, config=config)
+            )
+        return output_file
+
+    def GetPDBName(self, config, expand_special, default):
+        """Gets the explicitly overridden pdb name for a target or returns
+        default if it's not overridden, or if no pdb will be generated."""
+        config = self._TargetConfig(config)
+        output_file = self._Setting(("VCLinkerTool", "ProgramDatabaseFile"), config)
+        generate_debug_info = self._Setting(
+            ("VCLinkerTool", "GenerateDebugInformation"), config
+        )
+        if generate_debug_info == "true":
+            if output_file:
+                return expand_special(self.ConvertVSMacros(output_file, config=config))
+            else:
+                return default
+        else:
+            return None
+
+    def GetNoImportLibrary(self, config):
+        """If NoImportLibrary: true, ninja will not expect the output to include
+        an import library."""
+        config = self._TargetConfig(config)
+        noimplib = self._Setting(("NoImportLibrary",), config)
+        return noimplib == "true"
+
+    def GetAsmflags(self, config):
+        """Returns the flags that need to be added to ml invocations."""
+        config = self._TargetConfig(config)
+        asmflags = []
+        safeseh = self._Setting(("MASM", "UseSafeExceptionHandlers"), config)
+        if safeseh == "true":
+            asmflags.append("/safeseh")
+        return asmflags
+
+    def GetCflags(self, config):
+        """Returns the flags that need to be added to .c and .cc compilations."""
+        config = self._TargetConfig(config)
+        cflags = []
+        cflags.extend(["/wd" + w for w in self.msvs_disabled_warnings[config]])
+        cl = self._GetWrapper(
+            self, self.msvs_settings[config], "VCCLCompilerTool", append=cflags
+        )
+        cl(
+            "Optimization",
+            map={"0": "d", "1": "1", "2": "2", "3": "x"},
+            prefix="/O",
+            default="2",
+        )
+        cl("InlineFunctionExpansion", prefix="/Ob")
+        cl("DisableSpecificWarnings", prefix="/wd")
+        cl("StringPooling", map={"true": "/GF"})
+        cl("EnableFiberSafeOptimizations", map={"true": "/GT"})
+        cl("OmitFramePointers", map={"false": "-", "true": ""}, prefix="/Oy")
+        cl("EnableIntrinsicFunctions", map={"false": "-", "true": ""}, prefix="/Oi")
+        cl("FavorSizeOrSpeed", map={"1": "t", "2": "s"}, prefix="/O")
+        cl(
+            "FloatingPointModel",
+            map={"0": "precise", "1": "strict", "2": "fast"},
+            prefix="/fp:",
+            default="0",
+        )
+        cl("CompileAsManaged", map={"false": "", "true": "/clr"})
+        cl("WholeProgramOptimization", map={"true": "/GL"})
+        cl("WarningLevel", prefix="/W")
+        cl("WarnAsError", map={"true": "/WX"})
+        cl(
+            "CallingConvention",
+            map={"0": "d", "1": "r", "2": "z", "3": "v"},
+            prefix="/G",
+        )
+        cl("DebugInformationFormat", map={"1": "7", "3": "i", "4": "I"}, prefix="/Z")
+        cl("RuntimeTypeInfo", map={"true": "/GR", "false": "/GR-"})
+        cl("EnableFunctionLevelLinking", map={"true": "/Gy", "false": "/Gy-"})
+        cl("MinimalRebuild", map={"true": "/Gm"})
+        cl("BufferSecurityCheck", map={"true": "/GS", "false": "/GS-"})
+        cl("BasicRuntimeChecks", map={"1": "s", "2": "u", "3": "1"}, prefix="/RTC")
+        cl(
+            "RuntimeLibrary",
+            map={"0": "T", "1": "Td", "2": "D", "3": "Dd"},
+            prefix="/M",
+        )
+        cl("ExceptionHandling", map={"1": "sc", "2": "a"}, prefix="/EH")
+        cl("DefaultCharIsUnsigned", map={"true": "/J"})
+        cl(
+            "TreatWChar_tAsBuiltInType",
+            map={"false": "-", "true": ""},
+            prefix="/Zc:wchar_t",
+        )
+        cl("EnablePREfast", map={"true": "/analyze"})
+        cl("AdditionalOptions", prefix="")
+        cl(
+            "EnableEnhancedInstructionSet",
+            map={"1": "SSE", "2": "SSE2", "3": "AVX", "4": "IA32", "5": "AVX2"},
+            prefix="/arch:",
+        )
+        cflags.extend(
+            [
+                "/FI" + f
+                for f in self._Setting(
+                    ("VCCLCompilerTool", "ForcedIncludeFiles"), config, default=[]
+                )
+            ]
+        )
+        if float(self.vs_version.project_version) >= 12.0:
+            # New flag introduced in VS2013 (project version 12.0) Forces writes to
+            # the program database (PDB) to be serialized through MSPDBSRV.EXE.
+            # https://msdn.microsoft.com/en-us/library/dn502518.aspx
+            cflags.append("/FS")
+        # ninja handles parallelism by itself, don't have the compiler do it too.
+        cflags = [x for x in cflags if not x.startswith("/MP")]
+        return cflags
+
+    def _GetPchFlags(self, config, extension):
+        """Get the flags to be added to the cflags for precompiled header support."""
+        config = self._TargetConfig(config)
+        # The PCH is only built once by a particular source file. Usage of PCH must
+        # only be for the same language (i.e. C vs. C++), so only include the pch
+        # flags when the language matches.
+        if self.msvs_precompiled_header[config]:
+            source_ext = os.path.splitext(self.msvs_precompiled_source[config])[1]
+            if _LanguageMatchesForPch(source_ext, extension):
+                pch = self.msvs_precompiled_header[config]
+                pchbase = os.path.split(pch)[1]
+                return ["/Yu" + pch, "/FI" + pch, "/Fp${pchprefix}." + pchbase + ".pch"]
+        return []
+
+    def GetCflagsC(self, config):
+        """Returns the flags that need to be added to .c compilations."""
+        config = self._TargetConfig(config)
+        return self._GetPchFlags(config, ".c")
+
+    def GetCflagsCC(self, config):
+        """Returns the flags that need to be added to .cc compilations."""
+        config = self._TargetConfig(config)
+        return ["/TP"] + self._GetPchFlags(config, ".cc")
+
+    def _GetAdditionalLibraryDirectories(self, root, config, gyp_to_build_path):
+        """Get and normalize the list of paths in AdditionalLibraryDirectories
+        setting."""
+        config = self._TargetConfig(config)
+        libpaths = self._Setting(
+            (root, "AdditionalLibraryDirectories"), config, default=[]
+        )
+        libpaths = [
+            os.path.normpath(gyp_to_build_path(self.ConvertVSMacros(p, config=config)))
+            for p in libpaths
+        ]
+        return ['/LIBPATH:"' + p + '"' for p in libpaths]
+
+    def GetLibFlags(self, config, gyp_to_build_path):
+        """Returns the flags that need to be added to lib commands."""
+        config = self._TargetConfig(config)
+        libflags = []
+        lib = self._GetWrapper(
+            self, self.msvs_settings[config], "VCLibrarianTool", append=libflags
+        )
+        libflags.extend(
+            self._GetAdditionalLibraryDirectories(
+                "VCLibrarianTool", config, gyp_to_build_path
+            )
+        )
+        lib("LinkTimeCodeGeneration", map={"true": "/LTCG"})
+        lib(
+            "TargetMachine",
+            map={"1": "X86", "17": "X64", "3": "ARM"},
+            prefix="/MACHINE:",
+        )
+        lib("AdditionalOptions")
+        return libflags
+
+    def GetDefFile(self, gyp_to_build_path):
+        """Returns the .def file from sources, if any.  Otherwise returns None."""
+        spec = self.spec
+        if spec["type"] in ("shared_library", "loadable_module", "executable"):
+            def_files = [
+                s for s in spec.get("sources", []) if s.lower().endswith(".def")
+            ]
+            if len(def_files) == 1:
+                return gyp_to_build_path(def_files[0])
+            elif len(def_files) > 1:
+                raise Exception("Multiple .def files")
+        return None
+
+    def _GetDefFileAsLdflags(self, ldflags, gyp_to_build_path):
+        """.def files get implicitly converted to a ModuleDefinitionFile for the
+        linker in the VS generator. Emulate that behaviour here."""
+        def_file = self.GetDefFile(gyp_to_build_path)
+        if def_file:
+            ldflags.append('/DEF:"%s"' % def_file)
+
+    def GetPGDName(self, config, expand_special):
+        """Gets the explicitly overridden pgd name for a target or returns None
+        if it's not overridden."""
+        config = self._TargetConfig(config)
+        output_file = self._Setting(("VCLinkerTool", "ProfileGuidedDatabase"), config)
+        if output_file:
+            output_file = expand_special(
+                self.ConvertVSMacros(output_file, config=config)
+            )
+        return output_file
+
+    def GetLdflags(
+        self,
+        config,
+        gyp_to_build_path,
+        expand_special,
+        manifest_base_name,
+        output_name,
+        is_executable,
+        build_dir,
+    ):
+        """Returns the flags that need to be added to link commands, and the
+        manifest files."""
+        config = self._TargetConfig(config)
+        ldflags = []
+        ld = self._GetWrapper(
+            self, self.msvs_settings[config], "VCLinkerTool", append=ldflags
+        )
+        self._GetDefFileAsLdflags(ldflags, gyp_to_build_path)
+        ld("GenerateDebugInformation", map={"true": "/DEBUG"})
+        # TODO: These 'map' values come from machineTypeOption enum,
+        # and does not have an official value for ARM64 in VS2017 (yet).
+        # It needs to verify the ARM64 value when machineTypeOption is updated.
+        ld(
+            "TargetMachine",
+            map={"1": "X86", "17": "X64", "3": "ARM", "18": "ARM64"},
+            prefix="/MACHINE:",
+        )
+        ldflags.extend(
+            self._GetAdditionalLibraryDirectories(
+                "VCLinkerTool", config, gyp_to_build_path
+            )
+        )
+        ld("DelayLoadDLLs", prefix="/DELAYLOAD:")
+        ld("TreatLinkerWarningAsErrors", prefix="/WX", map={"true": "", "false": ":NO"})
+        out = self.GetOutputName(config, expand_special)
+        if out:
+            ldflags.append("/OUT:" + out)
+        pdb = self.GetPDBName(config, expand_special, output_name + ".pdb")
+        if pdb:
+            ldflags.append("/PDB:" + pdb)
+        pgd = self.GetPGDName(config, expand_special)
+        if pgd:
+            ldflags.append("/PGD:" + pgd)
+        map_file = self.GetMapFileName(config, expand_special)
+        ld("GenerateMapFile", map={"true": "/MAP:" + map_file if map_file else "/MAP"})
+        ld("MapExports", map={"true": "/MAPINFO:EXPORTS"})
+        ld("AdditionalOptions", prefix="")
+
+        minimum_required_version = self._Setting(
+            ("VCLinkerTool", "MinimumRequiredVersion"), config, default=""
+        )
+        if minimum_required_version:
+            minimum_required_version = "," + minimum_required_version
+        ld(
+            "SubSystem",
+            map={
+                "1": "CONSOLE%s" % minimum_required_version,
+                "2": "WINDOWS%s" % minimum_required_version,
+            },
+            prefix="/SUBSYSTEM:",
+        )
+
+        stack_reserve_size = self._Setting(
+            ("VCLinkerTool", "StackReserveSize"), config, default=""
+        )
+        if stack_reserve_size:
+            stack_commit_size = self._Setting(
+                ("VCLinkerTool", "StackCommitSize"), config, default=""
+            )
+            if stack_commit_size:
+                stack_commit_size = "," + stack_commit_size
+            ldflags.append(f"/STACK:{stack_reserve_size}{stack_commit_size}")
+
+        ld("TerminalServerAware", map={"1": ":NO", "2": ""}, prefix="/TSAWARE")
+        ld("LinkIncremental", map={"1": ":NO", "2": ""}, prefix="/INCREMENTAL")
+        ld("BaseAddress", prefix="/BASE:")
+        ld("FixedBaseAddress", map={"1": ":NO", "2": ""}, prefix="/FIXED")
+        ld("RandomizedBaseAddress", map={"1": ":NO", "2": ""}, prefix="/DYNAMICBASE")
+        ld("DataExecutionPrevention", map={"1": ":NO", "2": ""}, prefix="/NXCOMPAT")
+        ld("OptimizeReferences", map={"1": "NOREF", "2": "REF"}, prefix="/OPT:")
+        ld("ForceSymbolReferences", prefix="/INCLUDE:")
+        ld("EnableCOMDATFolding", map={"1": "NOICF", "2": "ICF"}, prefix="/OPT:")
+        ld(
+            "LinkTimeCodeGeneration",
+            map={"1": "", "2": ":PGINSTRUMENT", "3": ":PGOPTIMIZE", "4": ":PGUPDATE"},
+            prefix="/LTCG",
+        )
+        ld("IgnoreDefaultLibraryNames", prefix="/NODEFAULTLIB:")
+        ld("ResourceOnlyDLL", map={"true": "/NOENTRY"})
+        ld("EntryPointSymbol", prefix="/ENTRY:")
+        ld("Profile", map={"true": "/PROFILE"})
+        ld("LargeAddressAware", map={"1": ":NO", "2": ""}, prefix="/LARGEADDRESSAWARE")
+        # TODO(scottmg): This should sort of be somewhere else (not really a flag).
+        ld("AdditionalDependencies", prefix="")
+
+        if self.GetArch(config) == "x86":
+            safeseh_default = "true"
+        else:
+            safeseh_default = None
+        ld(
+            "ImageHasSafeExceptionHandlers",
+            map={"false": ":NO", "true": ""},
+            prefix="/SAFESEH",
+            default=safeseh_default,
+        )
+
+        # If the base address is not specifically controlled, DYNAMICBASE should
+        # be on by default.
+        if not any("DYNAMICBASE" in flag or flag == "/FIXED" for flag in ldflags):
+            ldflags.append("/DYNAMICBASE")
+
+        # If the NXCOMPAT flag has not been specified, default to on. Despite the
+        # documentation that says this only defaults to on when the subsystem is
+        # Vista or greater (which applies to the linker), the IDE defaults it on
+        # unless it's explicitly off.
+        if not any("NXCOMPAT" in flag for flag in ldflags):
+            ldflags.append("/NXCOMPAT")
+
+        have_def_file = any(flag.startswith("/DEF:") for flag in ldflags)
+        (
+            manifest_flags,
+            intermediate_manifest,
+            manifest_files,
+        ) = self._GetLdManifestFlags(
+            config,
+            manifest_base_name,
+            gyp_to_build_path,
+            is_executable and not have_def_file,
+            build_dir,
+        )
+        ldflags.extend(manifest_flags)
+        return ldflags, intermediate_manifest, manifest_files
+
+    def _GetLdManifestFlags(
+        self, config, name, gyp_to_build_path, allow_isolation, build_dir
+    ):
+        """Returns a 3-tuple:
+        - the set of flags that need to be added to the link to generate
+          a default manifest
+        - the intermediate manifest that the linker will generate that should be
+          used to assert it doesn't add anything to the merged one.
+        - the list of all the manifest files to be merged by the manifest tool and
+          included into the link."""
+        generate_manifest = self._Setting(
+            ("VCLinkerTool", "GenerateManifest"), config, default="true"
+        )
+        if generate_manifest != "true":
+            # This means not only that the linker should not generate the intermediate
+            # manifest but also that the manifest tool should do nothing even when
+            # additional manifests are specified.
+            return ["/MANIFEST:NO"], [], []
+
+        output_name = name + ".intermediate.manifest"
+        flags = [
+            "/MANIFEST",
+            "/ManifestFile:" + output_name,
+        ]
+
+        # Instead of using the MANIFESTUAC flags, we generate a .manifest to
+        # include into the list of manifests. This allows us to avoid the need to
+        # do two passes during linking. The /MANIFEST flag and /ManifestFile are
+        # still used, and the intermediate manifest is used to assert that the
+        # final manifest we get from merging all the additional manifest files
+        # (plus the one we generate here) isn't modified by merging the
+        # intermediate into it.
+
+        # Always NO, because we generate a manifest file that has what we want.
+        flags.append("/MANIFESTUAC:NO")
+
+        config = self._TargetConfig(config)
+        enable_uac = self._Setting(
+            ("VCLinkerTool", "EnableUAC"), config, default="true"
+        )
+        manifest_files = []
+        generated_manifest_outer = (
+            "<?xml version='1.0' encoding='UTF-8' standalone='yes'?>"
+            "<assembly xmlns='urn:schemas-microsoft-com:asm.v1' manifestVersion='1.0'>"
+            "%s</assembly>"
+        )
+        if enable_uac == "true":
+            execution_level = self._Setting(
+                ("VCLinkerTool", "UACExecutionLevel"), config, default="0"
+            )
+            execution_level_map = {
+                "0": "asInvoker",
+                "1": "highestAvailable",
+                "2": "requireAdministrator",
+            }
+
+            ui_access = self._Setting(
+                ("VCLinkerTool", "UACUIAccess"), config, default="false"
+            )
+
+            inner = """
+<trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
+  <security>
+    <requestedPrivileges>
+      <requestedExecutionLevel level='{}' uiAccess='{}' />
+    </requestedPrivileges>
+  </security>
+</trustInfo>""".format(
+                execution_level_map[execution_level],
+                ui_access,
+            )
+        else:
+            inner = ""
+
+        generated_manifest_contents = generated_manifest_outer % inner
+        generated_name = name + ".generated.manifest"
+        # Need to join with the build_dir here as we're writing it during
+        # generation time, but we return the un-joined version because the build
+        # will occur in that directory. We only write the file if the contents
+        # have changed so that simply regenerating the project files doesn't
+        # cause a relink.
+        build_dir_generated_name = os.path.join(build_dir, generated_name)
+        gyp.common.EnsureDirExists(build_dir_generated_name)
+        f = gyp.common.WriteOnDiff(build_dir_generated_name)
+        f.write(generated_manifest_contents)
+        f.close()
+        manifest_files = [generated_name]
+
+        if allow_isolation:
+            flags.append("/ALLOWISOLATION")
+
+        manifest_files += self._GetAdditionalManifestFiles(config, gyp_to_build_path)
+        return flags, output_name, manifest_files
+
+    def _GetAdditionalManifestFiles(self, config, gyp_to_build_path):
+        """Gets additional manifest files that are added to the default one
+        generated by the linker."""
+        files = self._Setting(
+            ("VCManifestTool", "AdditionalManifestFiles"), config, default=[]
+        )
+        if isinstance(files, str):
+            files = files.split(";")
+        return [
+            os.path.normpath(gyp_to_build_path(self.ConvertVSMacros(f, config=config)))
+            for f in files
+        ]
+
+    def IsUseLibraryDependencyInputs(self, config):
+        """Returns whether the target should be linked via Use Library Dependency
+        Inputs (using component .objs of a given .lib)."""
+        config = self._TargetConfig(config)
+        uldi = self._Setting(("VCLinkerTool", "UseLibraryDependencyInputs"), config)
+        return uldi == "true"
+
+    def IsEmbedManifest(self, config):
+        """Returns whether manifest should be linked into binary."""
+        config = self._TargetConfig(config)
+        embed = self._Setting(
+            ("VCManifestTool", "EmbedManifest"), config, default="true"
+        )
+        return embed == "true"
+
+    def IsLinkIncremental(self, config):
+        """Returns whether the target should be linked incrementally."""
+        config = self._TargetConfig(config)
+        link_inc = self._Setting(("VCLinkerTool", "LinkIncremental"), config)
+        return link_inc != "1"
+
+    def GetRcflags(self, config, gyp_to_ninja_path):
+        """Returns the flags that need to be added to invocations of the resource
+        compiler."""
+        config = self._TargetConfig(config)
+        rcflags = []
+        rc = self._GetWrapper(
+            self, self.msvs_settings[config], "VCResourceCompilerTool", append=rcflags
+        )
+        rc("AdditionalIncludeDirectories", map=gyp_to_ninja_path, prefix="/I")
+        rcflags.append("/I" + gyp_to_ninja_path("."))
+        rc("PreprocessorDefinitions", prefix="/d")
+        # /l arg must be in hex without leading '0x'
+        rc("Culture", prefix="/l", map=lambda x: hex(int(x))[2:])
+        return rcflags
+
+    def BuildCygwinBashCommandLine(self, args, path_to_base):
+        """Build a command line that runs args via cygwin bash. We assume that all
+        incoming paths are in Windows normpath'd form, so they need to be
+        converted to posix style for the part of the command line that's passed to
+        bash. We also have to do some Visual Studio macro emulation here because
+        various rules use magic VS names for things. Also note that rules that
+        contain ninja variables cannot be fixed here (for example ${source}), so
+        the outer generator needs to make sure that the paths that are written out
+        are in posix style, if the command line will be used here."""
+        cygwin_dir = os.path.normpath(
+            os.path.join(path_to_base, self.msvs_cygwin_dirs[0])
+        )
+        cd = ("cd %s" % path_to_base).replace("\\", "/")
+        args = [a.replace("\\", "/").replace('"', '\\"') for a in args]
+        args = ["'%s'" % a.replace("'", "'\\''") for a in args]
+        bash_cmd = " ".join(args)
+        cmd = (
+            'call "%s\\setup_env.bat" && set CYGWIN=nontsec && ' % cygwin_dir
+            + f'bash -c "{cd} ; {bash_cmd}"'
+        )
+        return cmd
+
+    RuleShellFlags = collections.namedtuple("RuleShellFlags", ["cygwin", "quote"])
+
+    def GetRuleShellFlags(self, rule):
+        """Return RuleShellFlags about how the given rule should be run. This
+        includes whether it should run under cygwin (msvs_cygwin_shell), and
+        whether the commands should be quoted (msvs_quote_cmd)."""
+        # If the variable is unset, or set to 1 we use cygwin
+        cygwin = int(rule.get("msvs_cygwin_shell",
+                              self.spec.get("msvs_cygwin_shell", 1))) != 0
+        # Default to quoting. There's only a few special instances where the
+        # target command uses non-standard command line parsing and handle quotes
+        # and quote escaping differently.
+        quote_cmd = int(rule.get("msvs_quote_cmd", 1))
+        assert quote_cmd != 0 or cygwin != 1, \
+               "msvs_quote_cmd=0 only applicable for msvs_cygwin_shell=0"
+        return MsvsSettings.RuleShellFlags(cygwin, quote_cmd)
+
+    def _HasExplicitRuleForExtension(self, spec, extension):
+        """Determine if there's an explicit rule for a particular extension."""
+        for rule in spec.get("rules", []):
+            if rule["extension"] == extension:
+                return True
+        return False
+
+    def _HasExplicitIdlActions(self, spec):
+        """Determine if an action should not run midl for .idl files."""
+        return any(
+            [action.get("explicit_idl_action", 0) for action in spec.get("actions", [])]
+        )
+
+    def HasExplicitIdlRulesOrActions(self, spec):
+        """Determine if there's an explicit rule or action for idl files. When
+        there isn't we need to generate implicit rules to build MIDL .idl files."""
+        return self._HasExplicitRuleForExtension(
+            spec, "idl"
+        ) or self._HasExplicitIdlActions(spec)
+
+    def HasExplicitAsmRules(self, spec):
+        """Determine if there's an explicit rule for asm files. When there isn't we
+        need to generate implicit rules to assemble .asm files."""
+        return self._HasExplicitRuleForExtension(spec, "asm")
+
+    def GetIdlBuildData(self, source, config):
+        """Determine the implicit outputs for an idl file. Returns output
+        directory, outputs, and variables and flags that are required."""
+        config = self._TargetConfig(config)
+        midl_get = self._GetWrapper(self, self.msvs_settings[config], "VCMIDLTool")
+
+        def midl(name, default=None):
+            return self.ConvertVSMacros(midl_get(name, default=default), config=config)
+
+        tlb = midl("TypeLibraryName", default="${root}.tlb")
+        header = midl("HeaderFileName", default="${root}.h")
+        dlldata = midl("DLLDataFileName", default="dlldata.c")
+        iid = midl("InterfaceIdentifierFileName", default="${root}_i.c")
+        proxy = midl("ProxyFileName", default="${root}_p.c")
+        # Note that .tlb is not included in the outputs as it is not always
+        # generated depending on the content of the input idl file.
+        outdir = midl("OutputDirectory", default="")
+        output = [header, dlldata, iid, proxy]
+        variables = [
+            ("tlb", tlb),
+            ("h", header),
+            ("dlldata", dlldata),
+            ("iid", iid),
+            ("proxy", proxy),
+        ]
+        # TODO(scottmg): Are there configuration settings to set these flags?
+        target_platform = self.GetArch(config)
+        if target_platform == "x86":
+            target_platform = "win32"
+        flags = ["/char", "signed", "/env", target_platform, "/Oicf"]
+        return outdir, output, variables, flags
+
+
+def _LanguageMatchesForPch(source_ext, pch_source_ext):
+    c_exts = (".c",)
+    cc_exts = (".cc", ".cxx", ".cpp")
+    return (source_ext in c_exts and pch_source_ext in c_exts) or (
+        source_ext in cc_exts and pch_source_ext in cc_exts
+    )
+
+
+class PrecompiledHeader:
+    """Helper to generate dependencies and build rules to handle generation of
+    precompiled headers. Interface matches the GCH handler in xcode_emulation.py.
+    """
+
+    def __init__(
+        self, settings, config, gyp_to_build_path, gyp_to_unique_output, obj_ext
+    ):
+        self.settings = settings
+        self.config = config
+        pch_source = self.settings.msvs_precompiled_source[self.config]
+        self.pch_source = gyp_to_build_path(pch_source)
+        filename, _ = os.path.splitext(pch_source)
+        self.output_obj = gyp_to_unique_output(filename + obj_ext).lower()
+
+    def _PchHeader(self):
+        """Get the header that will appear in an #include line for all source
+        files."""
+        return self.settings.msvs_precompiled_header[self.config]
+
+    def GetObjDependencies(self, sources, objs, arch):
+        """Given a list of sources files and the corresponding object files,
+        returns a list of the pch files that should be depended upon. The
+        additional wrapping in the return value is for interface compatibility
+        with make.py on Mac, and xcode_emulation.py."""
+        assert arch is None
+        if not self._PchHeader():
+            return []
+        pch_ext = os.path.splitext(self.pch_source)[1]
+        for source in sources:
+            if _LanguageMatchesForPch(os.path.splitext(source)[1], pch_ext):
+                return [(None, None, self.output_obj)]
+        return []
+
+    def GetPchBuildCommands(self, arch):
+        """Not used on Windows as there are no additional build steps required
+        (instead, existing steps are modified in GetFlagsModifications below)."""
+        return []
+
+    def GetFlagsModifications(
+        self, input, output, implicit, command, cflags_c, cflags_cc, expand_special
+    ):
+        """Get the modified cflags and implicit dependencies that should be used
+        for the pch compilation step."""
+        if input == self.pch_source:
+            pch_output = ["/Yc" + self._PchHeader()]
+            if command == "cxx":
+                return (
+                    [("cflags_cc", map(expand_special, cflags_cc + pch_output))],
+                    self.output_obj,
+                    [],
+                )
+            elif command == "cc":
+                return (
+                    [("cflags_c", map(expand_special, cflags_c + pch_output))],
+                    self.output_obj,
+                    [],
+                )
+        return [], output, implicit
+
+
+vs_version = None
+
+
+def GetVSVersion(generator_flags):
+    global vs_version
+    if not vs_version:
+        vs_version = gyp.MSVSVersion.SelectVisualStudioVersion(
+            generator_flags.get("msvs_version", "auto"), allow_fallback=False
+        )
+    return vs_version
+
+
+def _GetVsvarsSetupArgs(generator_flags, arch):
+    vs = GetVSVersion(generator_flags)
+    return vs.SetupScript()
+
+
+def ExpandMacros(string, expansions):
+    """Expand $(Variable) per expansions dict. See MsvsSettings.GetVSMacroEnv
+    for the canonical way to retrieve a suitable dict."""
+    if "$" in string:
+        for old, new in expansions.items():
+            assert "$(" not in new, new
+            string = string.replace(old, new)
+    return string
+
+
+def _ExtractImportantEnvironment(output_of_set):
+    """Extracts environment variables required for the toolchain to run from
+    a textual dump output by the cmd.exe 'set' command."""
+    envvars_to_save = (
+        "goma_.*",  # TODO(scottmg): This is ugly, but needed for goma.
+        "include",
+        "lib",
+        "libpath",
+        "path",
+        "pathext",
+        "systemroot",
+        "temp",
+        "tmp",
+    )
+    env = {}
+    # This occasionally happens and leads to misleading SYSTEMROOT error messages
+    # if not caught here.
+    if output_of_set.count("=") == 0:
+        raise Exception("Invalid output_of_set. Value is:\n%s" % output_of_set)
+    for line in output_of_set.splitlines():
+        for envvar in envvars_to_save:
+            if re.match(envvar + "=", line.lower()):
+                var, setting = line.split("=", 1)
+                if envvar == "path":
+                    # Our own rules (for running gyp-win-tool) and other actions in
+                    # Chromium rely on python being in the path. Add the path to this
+                    # python here so that if it's not in the path when ninja is run
+                    # later, python will still be found.
+                    setting = os.path.dirname(sys.executable) + os.pathsep + setting
+                env[var.upper()] = setting
+                break
+    for required in ("SYSTEMROOT", "TEMP", "TMP"):
+        if required not in env:
+            raise Exception(
+                'Environment variable "%s" '
+                "required to be set to valid path" % required
+            )
+    return env
+
+
+def _FormatAsEnvironmentBlock(envvar_dict):
+    """Format as an 'environment block' directly suitable for CreateProcess.
+    Briefly this is a list of key=value\0, terminated by an additional \0. See
+    CreateProcess documentation for more details."""
+    block = ""
+    nul = "\0"
+    for key, value in envvar_dict.items():
+        block += key + "=" + value + nul
+    block += nul
+    return block
+
+
+def _ExtractCLPath(output_of_where):
+    """Gets the path to cl.exe based on the output of calling the environment
+    setup batch file, followed by the equivalent of `where`."""
+    # Take the first line, as that's the first found in the PATH.
+    for line in output_of_where.strip().splitlines():
+        if line.startswith("LOC:"):
+            return line[len("LOC:") :].strip()
+
+
+def GenerateEnvironmentFiles(
+    toplevel_build_dir, generator_flags, system_includes, open_out
+):
+    """It's not sufficient to have the absolute path to the compiler, linker,
+    etc. on Windows, as those tools rely on .dlls being in the PATH. We also
+    need to support both x86 and x64 compilers within the same build (to support
+    msvs_target_platform hackery). Different architectures require a different
+    compiler binary, and different supporting environment variables (INCLUDE,
+    LIB, LIBPATH). So, we extract the environment here, wrap all invocations
+    of compiler tools (cl, link, lib, rc, midl, etc.) via win_tool.py which
+    sets up the environment, and then we do not prefix the compiler with
+    an absolute path, instead preferring something like "cl.exe" in the rule
+    which will then run whichever the environment setup has put in the path.
+    When the following procedure to generate environment files does not
+    meet your requirement (e.g. for custom toolchains), you can pass
+    "-G ninja_use_custom_environment_files" to the gyp to suppress file
+    generation and use custom environment files prepared by yourself."""
+    archs = ("x86", "x64")
+    if generator_flags.get("ninja_use_custom_environment_files", 0):
+        cl_paths = {}
+        for arch in archs:
+            cl_paths[arch] = "cl.exe"
+        return cl_paths
+    vs = GetVSVersion(generator_flags)
+    cl_paths = {}
+    for arch in archs:
+        # Extract environment variables for subprocesses.
+        args = vs.SetupScript(arch)
+        args.extend(("&&", "set"))
+        popen = subprocess.Popen(
+            args, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT
+        )
+        variables = popen.communicate()[0].decode("utf-8")
+        if popen.returncode != 0:
+            raise Exception('"%s" failed with error %d' % (args, popen.returncode))
+        env = _ExtractImportantEnvironment(variables)
+
+        # Inject system includes from gyp files into INCLUDE.
+        if system_includes:
+            system_includes = system_includes | OrderedSet(
+                env.get("INCLUDE", "").split(";")
+            )
+            env["INCLUDE"] = ";".join(system_includes)
+
+        env_block = _FormatAsEnvironmentBlock(env)
+        f = open_out(os.path.join(toplevel_build_dir, "environment." + arch), "w")
+        f.write(env_block)
+        f.close()
+
+        # Find cl.exe location for this architecture.
+        args = vs.SetupScript(arch)
+        args.extend(
+            ("&&", "for", "%i", "in", "(cl.exe)", "do", "@echo", "LOC:%~$PATH:i")
+        )
+        popen = subprocess.Popen(args, shell=True, stdout=subprocess.PIPE)
+        output = popen.communicate()[0].decode("utf-8")
+        cl_paths[arch] = _ExtractCLPath(output)
+    return cl_paths
+
+
+def VerifyMissingSources(sources, build_dir, generator_flags, gyp_to_ninja):
+    """Emulate behavior of msvs_error_on_missing_sources present in the msvs
+    generator: Check that all regular source files, i.e. not created at run time,
+    exist on disk. Missing files cause needless recompilation when building via
+    VS, and we want this check to match for people/bots that build using ninja,
+    so they're not surprised when the VS build fails."""
+    if int(generator_flags.get("msvs_error_on_missing_sources", 0)):
+        no_specials = filter(lambda x: "$" not in x, sources)
+        relative = [os.path.join(build_dir, gyp_to_ninja(s)) for s in no_specials]
+        missing = [x for x in relative if not os.path.exists(x)]
+        if missing:
+            # They'll look like out\Release\..\..\stuff\things.cc, so normalize the
+            # path for a slightly less crazy looking output.
+            cleaned_up = [os.path.normpath(x) for x in missing]
+            raise Exception("Missing input files:\n%s" % "\n".join(cleaned_up))
+
+
+# Sets some values in default_variables, which are required for many
+# generators, run on Windows.
+def CalculateCommonVariables(default_variables, params):
+    generator_flags = params.get("generator_flags", {})
+
+    # Set a variable so conditions can be based on msvs_version.
+    msvs_version = gyp.msvs_emulation.GetVSVersion(generator_flags)
+    default_variables["MSVS_VERSION"] = msvs_version.ShortName()
+
+    # To determine processor word size on Windows, in addition to checking
+    # PROCESSOR_ARCHITECTURE (which reflects the word size of the current
+    # process), it is also necessary to check PROCESSOR_ARCHITEW6432 (which
+    # contains the actual word size of the system when running thru WOW64).
+    if "64" in os.environ.get("PROCESSOR_ARCHITECTURE", "") or "64" in os.environ.get(
+        "PROCESSOR_ARCHITEW6432", ""
+    ):
+        default_variables["MSVS_OS_BITS"] = 64
+    else:
+        default_variables["MSVS_OS_BITS"] = 32