/// <summary>
/// Initializes a new instance of the <see cref="UWPToolchain"/> class.
/// </summary>
/// <param name="platform">The platform.</param>
/// <param name="architecture">The target architecture.</param>
/// <param name="toolsetVer">The target platform toolset version.</param>
/// <param name="sdkVer">The target platform SDK version.</param>
public UWPToolchain(UWPPlatform platform, TargetArchitecture architecture, WindowsPlatformToolset toolsetVer = WindowsPlatformToolset.Latest, WindowsPlatformSDK sdkVer = WindowsPlatformSDK.Latest)
: base(platform, architecture, toolsetVer, sdkVer)
{
var visualStudio = VisualStudioInstance.GetInstances().FirstOrDefault(x => x.Version == VisualStudioVersion.VisualStudio2017 || x.Version == VisualStudioVersion.VisualStudio2019);
if (visualStudio == null)
{
throw new Exception("Missing Visual Studio 2017 or newer. It's required to build for UWP.");
}
_usingDirs.Add(Path.Combine(visualStudio.Path, "VC", "vcpackages"));
var sdks = WindowsPlatformBase.GetSDKs();
var sdk10 = sdks.FirstOrDefault(x => x.Key != WindowsPlatformSDK.v8_1).Value;
if (sdk10 == null)
{
throw new Exception("Missing Windows 10 SDK. It's required to build for UWP.");
}
var sdk10Ver = WindowsPlatformBase.GetSDKVersion(SDK).ToString();
_usingDirs.Add(Path.Combine(sdk10, "References"));
_usingDirs.Add(Path.Combine(sdk10, "References", sdk10Ver));
_usingDirs.Add(Path.Combine(sdk10, "References", "CommonConfiguration", "Neutral"));
_usingDirs.Add(Path.Combine(sdk10, "UnionMetadata", sdk10Ver));
}
/// <summary>
/// Gets the path to the 64-bit tool binaries.
/// </summary>
/// <param name="toolset">The version of the toolset to use.</param>
/// <returns>The directory containing the 64-bit toolchain binaries.</returns>
public static string GetVCToolPath64(WindowsPlatformToolset toolset)
{
var toolsets = GetToolsets();
var vcToolChainDir = toolsets[toolset];
switch (toolset)
{
case WindowsPlatformToolset.v140:
{
// Use the native 64-bit compiler if present
string nativeCompilerPath = Path.Combine(vcToolChainDir, "bin", "amd64", "cl.exe");
if (File.Exists(nativeCompilerPath))
{
return(Path.GetDirectoryName(nativeCompilerPath));
}
// Otherwise use the x64-on-x86 compiler
string crossCompilerPath = Path.Combine(vcToolChainDir, "bin", "x86_amd64", "cl.exe");
if (File.Exists(crossCompilerPath))
{
return(Path.GetDirectoryName(crossCompilerPath));
}
throw new Exception(string.Format("No 64-bit compiler toolchain found in {0} or {1}", nativeCompilerPath, crossCompilerPath));
}
case WindowsPlatformToolset.v141:
case WindowsPlatformToolset.v142:
{
// Use the native 64-bit compiler if present
string nativeCompilerPath = Path.Combine(vcToolChainDir, "bin", "HostX64", "x64", "cl.exe");
if (File.Exists(nativeCompilerPath))
{
return(Path.GetDirectoryName(nativeCompilerPath));
}
// Otherwise try the x64-on-x86 compiler
string crossCompilerPath = Path.Combine(vcToolChainDir, "bin", "HostX86", "x64", "cl.exe");
if (File.Exists(crossCompilerPath))
{
return(Path.GetDirectoryName(crossCompilerPath));
}
throw new Exception(string.Format("No 64-bit compiler toolchain found in {0} or {1}", nativeCompilerPath, crossCompilerPath));
}
default: throw new ArgumentOutOfRangeException(nameof(toolset), toolset, null);
}
}
/// <summary>
/// Gets the path to the 32-bit tool binaries.
/// </summary>
/// <param name="toolset">The version of the toolset to use.</param>
/// <returns>The directory containing the 64-bit toolchain binaries.</returns>
public static string GetVCToolPath32(WindowsPlatformToolset toolset)
{
var toolsets = GetToolsets();
var vcToolChainDir = toolsets[toolset];
switch (toolset)
{
case WindowsPlatformToolset.v140:
{
string compilerPath = Path.Combine(vcToolChainDir, "bin", "cl.exe");
if (File.Exists(compilerPath))
{
return(Path.GetDirectoryName(compilerPath));
}
throw new Exception(string.Format("No 32-bit compiler toolchain found in {0}", compilerPath));
}
case WindowsPlatformToolset.v141:
case WindowsPlatformToolset.v142:
case WindowsPlatformToolset.v143:
{
/*
* string crossCompilerPath = Path.Combine(vcToolChainDir, "bin", "HostX64", "x86", "cl.exe");
* if (File.Exists(crossCompilerPath))
* {
* return Path.GetDirectoryName(crossCompilerPath);
* }
*/
string nativeCompilerPath = Path.Combine(vcToolChainDir, "bin", "HostX86", "x86", "cl.exe");
if (File.Exists(nativeCompilerPath))
{
return(Path.GetDirectoryName(nativeCompilerPath));
}
//throw new Exception(string.Format("No 32-bit compiler toolchain found in {0} or {1}", crossCompilerPath, nativeCompilerPath));
throw new Exception(string.Format("No 32-bit compiler toolchain found in {0}", nativeCompilerPath));
}
default: throw new ArgumentOutOfRangeException(nameof(toolset), toolset, null);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="WindowsToolchainBase"/> class.
/// </summary>
/// <param name="platform">The platform.</param>
/// <param name="architecture">The target architecture.</param>
/// <param name="toolsetVer">The target platform toolset version.</param>
/// <param name="sdkVer">The target platform SDK version.</param>
protected WindowsToolchainBase(WindowsPlatformBase platform, TargetArchitecture architecture, WindowsPlatformToolset toolsetVer, WindowsPlatformSDK sdkVer)
: base(platform, architecture)
{
var toolsets = WindowsPlatformBase.GetToolsets();
var sdks = WindowsPlatformBase.GetSDKs();
// Pick the overriden toolset
if (Configuration.Compiler != null)
{
if (Enum.TryParse(Configuration.Compiler, out WindowsPlatformToolset compiler))
{
toolsetVer = compiler;
}
}
// Pick the newest installed Visual Studio version if using the default toolset
if (toolsetVer == WindowsPlatformToolset.Default)
{
if (VisualStudioInstance.HasIDE(VisualStudioVersion.VisualStudio2019))
{
toolsetVer = WindowsPlatformToolset.v142;
}
else if (VisualStudioInstance.HasIDE(VisualStudioVersion.VisualStudio2017))
{
toolsetVer = WindowsPlatformToolset.v141;
}
else
{
toolsetVer = WindowsPlatformToolset.v140;
}
}
// Pick the latest toolset
else if (toolsetVer == WindowsPlatformToolset.Latest)
{
toolsetVer = toolsets.Keys.Max();
}
// Pick the latest SDK
if (sdkVer == WindowsPlatformSDK.Latest)
{
sdkVer = sdks.Keys.Max();
}
// Get tools
Toolset = toolsetVer;
SDK = sdkVer;
if (!toolsets.ContainsKey(Toolset))
{
throw new Exception(string.Format("Missing toolset {0} for platform Windows", Toolset));
}
if (!sdks.ContainsKey(SDK))
{
throw new Exception(string.Format("Missing SDK {0} for platform Windows", SDK));
}
// Get the tools paths
string vcToolPath;
if (Architecture == TargetArchitecture.x64)
{
vcToolPath = WindowsPlatformBase.GetVCToolPath64(Toolset);
}
else
{
vcToolPath = WindowsPlatformBase.GetVCToolPath32(Toolset);
}
_vcToolPath = vcToolPath;
_compilerPath = Path.Combine(vcToolPath, "cl.exe");
_linkerPath = Path.Combine(vcToolPath, "link.exe");
_libToolPath = Path.Combine(vcToolPath, "lib.exe");
_xdcmakePath = Path.Combine(vcToolPath, "xdcmake.exe");
// Add Visual C++ toolset include and library paths
var vcToolChainDir = toolsets[Toolset];
SystemIncludePaths.Add(Path.Combine(vcToolChainDir, "include"));
switch (Toolset)
{
case WindowsPlatformToolset.v140:
{
switch (Architecture)
{
case TargetArchitecture.AnyCPU: break;
case TargetArchitecture.ARM:
SystemLibraryPaths.Add(Path.Combine(vcToolChainDir, "lib", "arm"));
break;
case TargetArchitecture.ARM64:
SystemLibraryPaths.Add(Path.Combine(vcToolChainDir, "lib", "arm64"));
break;
case TargetArchitecture.x86:
SystemLibraryPaths.Add(Path.Combine(vcToolChainDir, "lib"));
break;
case TargetArchitecture.x64:
SystemLibraryPaths.Add(Path.Combine(vcToolChainDir, "lib", "amd64"));
break;
default: throw new InvalidArchitectureException(architecture);
}
// When using Visual Studio 2015 toolset and using pre-Windows 10 SDK, find a Windows 10 SDK and add the UCRT include paths
if (SDK == WindowsPlatformSDK.v8_1)
{
var sdk = sdks.FirstOrDefault(x => x.Key != WindowsPlatformSDK.v8_1);
if (sdk.Value == null)
{
throw new Exception("Combination of Windows Toolset v140 and Windows SDK 8.1 requires the Universal CRT to be installed.");
}
var sdkVersionName = WindowsPlatformBase.GetSDKVersion(sdk.Key).ToString();
string includeRootDir = Path.Combine(sdk.Value, "include", sdkVersionName);
SystemIncludePaths.Add(Path.Combine(includeRootDir, "ucrt"));
string libraryRootDir = Path.Combine(sdk.Value, "lib", sdkVersionName);
switch (Architecture)
{
case TargetArchitecture.AnyCPU: break;
case TargetArchitecture.ARM:
SystemLibraryPaths.Add(Path.Combine(libraryRootDir, "ucrt", "arm"));
break;
case TargetArchitecture.ARM64:
SystemLibraryPaths.Add(Path.Combine(libraryRootDir, "ucrt", "arm64"));
break;
case TargetArchitecture.x86:
SystemLibraryPaths.Add(Path.Combine(libraryRootDir, "ucrt", "x86"));
break;
case TargetArchitecture.x64:
SystemLibraryPaths.Add(Path.Combine(libraryRootDir, "ucrt", "x64"));
break;
default: throw new InvalidArchitectureException(architecture);
}
}
break;
}
case WindowsPlatformToolset.v141:
case WindowsPlatformToolset.v142:
{
switch (Architecture)
{
case TargetArchitecture.AnyCPU: break;
case TargetArchitecture.ARM:
SystemLibraryPaths.Add(Path.Combine(vcToolChainDir, "lib", "arm"));
break;
case TargetArchitecture.ARM64:
SystemLibraryPaths.Add(Path.Combine(vcToolChainDir, "lib", "arm64"));
break;
case TargetArchitecture.x86:
SystemLibraryPaths.Add(Path.Combine(vcToolChainDir, "lib", "x86"));
break;
case TargetArchitecture.x64:
SystemLibraryPaths.Add(Path.Combine(vcToolChainDir, "lib", "x64"));
break;
default: throw new InvalidArchitectureException(architecture);
}
break;
}
default: throw new ArgumentOutOfRangeException();
}
// Add Windows SDK include and library paths
var windowsSdkDir = sdks[SDK];
switch (SDK)
{
case WindowsPlatformSDK.v8_1:
{
string includeRootDir = Path.Combine(windowsSdkDir, "include");
SystemIncludePaths.Add(Path.Combine(includeRootDir, "shared"));
SystemIncludePaths.Add(Path.Combine(includeRootDir, "um"));
SystemIncludePaths.Add(Path.Combine(includeRootDir, "winrt"));
SystemIncludePaths.Add(Path.Combine(includeRootDir, "ucrt"));
string libraryRootDir = Path.Combine(windowsSdkDir, "lib", "winv6.3");
switch (Architecture)
{
case TargetArchitecture.AnyCPU: break;
case TargetArchitecture.ARM:
{
SystemLibraryPaths.Add(Path.Combine(libraryRootDir, "um", "arm"));
break;
}
case TargetArchitecture.ARM64:
{
SystemLibraryPaths.Add(Path.Combine(libraryRootDir, "um", "arm64"));
break;
}
case TargetArchitecture.x86:
{
SystemLibraryPaths.Add(Path.Combine(libraryRootDir, "um", "x86"));
SystemLibraryPaths.Add(Path.Combine(libraryRootDir, "ucrt", "x86"));
var binRootDir = Path.Combine(windowsSdkDir, "bin", "x86");
_resourceCompilerPath = Path.Combine(binRootDir, "rc.exe");
_makepriPath = Path.Combine(binRootDir, "makepri.exe");
break;
}
case TargetArchitecture.x64:
{
SystemLibraryPaths.Add(Path.Combine(libraryRootDir, "um", "x64"));
SystemLibraryPaths.Add(Path.Combine(libraryRootDir, "ucrt", "x64"));
var binRootDir = Path.Combine(windowsSdkDir, "bin", "x64");
_resourceCompilerPath = Path.Combine(binRootDir, "rc.exe");
_makepriPath = Path.Combine(binRootDir, "makepri.exe");
break;
}
default: throw new InvalidArchitectureException(architecture);
}
break;
}
case WindowsPlatformSDK.v10_0_10240_0:
case WindowsPlatformSDK.v10_0_10586_0:
case WindowsPlatformSDK.v10_0_14393_0:
case WindowsPlatformSDK.v10_0_15063_0:
case WindowsPlatformSDK.v10_0_16299_0:
case WindowsPlatformSDK.v10_0_17134_0:
case WindowsPlatformSDK.v10_0_17763_0:
case WindowsPlatformSDK.v10_0_18362_0:
case WindowsPlatformSDK.v10_0_19041_0:
{
var sdkVersionName = WindowsPlatformBase.GetSDKVersion(SDK).ToString();
string includeRootDir = Path.Combine(windowsSdkDir, "include", sdkVersionName);
SystemIncludePaths.Add(Path.Combine(includeRootDir, "ucrt"));
SystemIncludePaths.Add(Path.Combine(includeRootDir, "shared"));
SystemIncludePaths.Add(Path.Combine(includeRootDir, "um"));
SystemIncludePaths.Add(Path.Combine(includeRootDir, "winrt"));
string libraryRootDir = Path.Combine(windowsSdkDir, "lib", sdkVersionName);
switch (Architecture)
{
case TargetArchitecture.AnyCPU: break;
case TargetArchitecture.ARM:
{
SystemLibraryPaths.Add(Path.Combine(libraryRootDir, "ucrt", "arm"));
SystemLibraryPaths.Add(Path.Combine(libraryRootDir, "um", "arm"));
break;
}
case TargetArchitecture.ARM64:
{
SystemLibraryPaths.Add(Path.Combine(libraryRootDir, "ucrt", "arm64"));
SystemLibraryPaths.Add(Path.Combine(libraryRootDir, "um", "arm64"));
break;
}
case TargetArchitecture.x86:
{
SystemLibraryPaths.Add(Path.Combine(libraryRootDir, "ucrt", "x86"));
SystemLibraryPaths.Add(Path.Combine(libraryRootDir, "um", "x86"));
var binRootDir = Path.Combine(windowsSdkDir, "bin", sdkVersionName, "x86");
_resourceCompilerPath = Path.Combine(binRootDir, "rc.exe");
_makepriPath = Path.Combine(binRootDir, "makepri.exe");
break;
}
case TargetArchitecture.x64:
{
SystemLibraryPaths.Add(Path.Combine(libraryRootDir, "ucrt", "x64"));
SystemLibraryPaths.Add(Path.Combine(libraryRootDir, "um", "x64"));
var binRootDir = Path.Combine(windowsSdkDir, "bin", sdkVersionName, "x64");
_resourceCompilerPath = Path.Combine(binRootDir, "rc.exe");
_makepriPath = Path.Combine(binRootDir, "makepri.exe");
break;
}
default: throw new InvalidArchitectureException(architecture);
}
break;
}
default: throw new ArgumentOutOfRangeException(nameof(SDK));
}
}
