protected override IEnumerable <IncludeWithPrefix> GetPlatformIncludePathsWithPrefixImpl(IGenerationContext context)
{
var includes = new List <IncludeWithPrefix>();
string includePrefix = "/I";
if (Options.GetObject <Options.Vc.General.PlatformToolset>(context.Configuration).IsLLVMToolchain() && Options.GetObject <Options.Vc.LLVM.UseClangCl>(context.Configuration) == Options.Vc.LLVM.UseClangCl.Enable)
{
includePrefix = "/clang:-isystem";
string clangIncludePath = ClangForWindows.GetWindowsClangIncludePath();
includes.Add(new IncludeWithPrefix(includePrefix, clangIncludePath));
}
// when using clang-cl, mark MSVC includes, so they are properly recognized
IEnumerable <string> msvcIncludePaths = EnumerateSemiColonSeparatedString(context.DevelopmentEnvironment.GetWindowsIncludePath());
includes.AddRange(msvcIncludePaths.Select(path => new IncludeWithPrefix(includePrefix, path)));
// Additional system includes
OrderableStrings SystemIncludes = new OrderableStrings(context.Configuration.DependenciesIncludeSystemPaths);
SystemIncludes.AddRange(context.Configuration.IncludeSystemPaths);
if (SystemIncludes.Count > 0)
{
SystemIncludes.Sort();
includes.AddRange(SystemIncludes.Select(path => new IncludeWithPrefix(includePrefix, path)));
}
return(includes);
}
public override void SetupSdkOptions(IGenerationContext context)
{
var conf = context.Configuration;
var devEnv = context.DevelopmentEnvironment;
// vs2012 and vs2013 do not support overriding windows kits using the underlying variables
// so we need to change the VC++ directories path.
// We need to override the executable path for vs2015 because WindowsKit UAP.props does not
// correctly set the WindowsSDK_ExecutablePath to the bin folder of its current version.
if ((devEnv == DevEnv.vs2012 || devEnv == DevEnv.vs2013 || devEnv == DevEnv.vs2015) && !KitsRootPaths.UsesDefaultKitRoot(devEnv))
{
var options = context.Options;
options["ExecutablePath"] = devEnv.GetWindowsExecutablePath(conf.Platform);
if (devEnv != DevEnv.vs2015)
{
options["IncludePath"] = devEnv.GetWindowsIncludePath();
options["LibraryPath"] = devEnv.GetWindowsLibraryPath(conf.Platform, Util.IsDotNet(conf) ? conf.Target.GetFragment <DotNetFramework>() : default(DotNetFramework?));
options["ExcludePath"] = devEnv.GetWindowsIncludePath();
}
}
if (Options.GetObject <Options.Vc.General.PlatformToolset>(conf).IsLLVMToolchain())
{
context.Options["ExecutablePath"] = ClangForWindows.GetWindowsClangExecutablePath() + ";" + devEnv.GetWindowsExecutablePath(conf.Platform);
if (Options.GetObject <Options.Vc.LLVM.UseClangCl>(conf) == Options.Vc.LLVM.UseClangCl.Enable)
{
context.Options["IncludePath"] = ClangForWindows.GetWindowsClangIncludePath() + ";" + devEnv.GetWindowsIncludePath();
context.Options["LibraryPath"] = ClangForWindows.GetWindowsClangLibraryPath() + ";" + devEnv.GetWindowsLibraryPath(conf.Platform, Util.IsDotNet(conf) ? conf.Target.GetFragment <DotNetFramework>() : default(DotNetFramework?));
}
}
}
public override void SetupSdkOptions(IGenerationContext context)
{
var conf = context.Configuration;
var devEnv = context.DevelopmentEnvironment;
// vs2012 and vs2013 do not support overriding windows kits using the underlying variables
// so we need to change the VC++ directories path.
// We need to override the executable path for vs2015 because WindowsKit UAP.props does not
// correctly set the WindowsSDK_ExecutablePath to the bin folder of its current version.
if ((devEnv == DevEnv.vs2012 || devEnv == DevEnv.vs2013 || devEnv == DevEnv.vs2015) && !KitsRootPaths.UsesDefaultKitRoot(devEnv))
{
var options = context.Options;
options["ExecutablePath"] = devEnv.GetWindowsExecutablePath(conf.Platform);
if (devEnv != DevEnv.vs2015)
{
options["IncludePath"] = devEnv.GetWindowsIncludePath();
options["LibraryPath"] = devEnv.GetWindowsLibraryPath(conf.Platform, Util.IsDotNet(conf) ? conf.Target.GetFragment <DotNetFramework>() : default(DotNetFramework?));
options["ExcludePath"] = devEnv.GetWindowsIncludePath();
}
}
Options.Vc.General.PlatformToolset platformToolset = Options.GetObject <Options.Vc.General.PlatformToolset>(conf);
if (platformToolset.IsLLVMToolchain())
{
Options.Vc.General.PlatformToolset overridenPlatformToolset = Options.Vc.General.PlatformToolset.Default;
if (Options.WithArgOption <Options.Vc.General.PlatformToolset> .Get <Options.Clang.Compiler.LLVMVcPlatformToolset>(conf, ref overridenPlatformToolset))
{
platformToolset = overridenPlatformToolset;
}
devEnv = platformToolset.GetDefaultDevEnvForToolset() ?? devEnv;
context.Options["ExecutablePath"] = ClangForWindows.GetWindowsClangExecutablePath() + ";" + devEnv.GetWindowsExecutablePath(conf.Platform);
if (Options.GetObject <Options.Vc.LLVM.UseClangCl>(conf) == Options.Vc.LLVM.UseClangCl.Enable)
{
context.Options["IncludePath"] = ClangForWindows.GetWindowsClangIncludePath() + ";" + devEnv.GetWindowsIncludePath();
context.Options["LibraryPath"] = ClangForWindows.GetWindowsClangLibraryPath() + ";" + devEnv.GetWindowsLibraryPath(conf.Platform, Util.IsDotNet(conf) ? conf.Target.GetFragment <DotNetFramework>() : default(DotNetFramework?));
}
}
var systemIncludes = new OrderableStrings(conf.DependenciesIncludeSystemPaths);
systemIncludes.AddRange(conf.IncludeSystemPaths);
if (systemIncludes.Count > 0)
{
systemIncludes.Sort();
if (context.Options["IncludePath"] == FileGeneratorUtilities.RemoveLineTag)
{
context.Options["IncludePath"] = "$(VC_IncludePath);$(WindowsSDK_IncludePath);" + systemIncludes.JoinStrings(";");
}
else
{
context.Options["IncludePath"] += ";" + systemIncludes.JoinStrings(";");
}
}
}
public override void GeneratePlatformSpecificProjectDescription(IVcxprojGenerationContext context, IFileGenerator generator)
{
if (!ClangForWindows.Settings.OverridenLLVMInstallDir)
{
return;
}
if (context.DevelopmentEnvironmentsRange.MinDevEnv != context.DevelopmentEnvironmentsRange.MaxDevEnv)
{
throw new Error("Different vs versions not supported in the same vcxproj");
}
DevEnv uniqueDevEnv = context.DevelopmentEnvironmentsRange.MinDevEnv;
using (generator.Declare("platformName", SimplePlatformString))
{
generator.Write(Vcxproj.Template.Project.ProjectDescriptionStartPlatformConditional);
{
switch (uniqueDevEnv)
{
case DevEnv.vs2017:
{
string platformFolder = MSBuildGlobalSettings.GetCppPlatformFolder(context.DevelopmentEnvironmentsRange.MinDevEnv, Platform.win64);
if (!string.IsNullOrEmpty(platformFolder))
{
using (generator.Declare("platformFolder", Util.EnsureTrailingSeparator(platformFolder))) // _PlatformFolder require the path to end with a "\"
generator.Write(Vcxproj.Template.Project.PlatformFolderOverride);
}
}
break;
case DevEnv.vs2019:
{
// Note1: _PlatformFolder override is deprecated starting with vs2019, so we write AdditionalVCTargetsPath instead
// Note2: MSBuildGlobalSettings.SetCppPlatformFolder for vs2019 is no more the valid way to handle it. Older buildtools packages can anyway contain it, and need upgrade.
if (!string.IsNullOrEmpty(MSBuildGlobalSettings.GetCppPlatformFolder(uniqueDevEnv, Platform.win64)))
{
throw new Error("SetCppPlatformFolder is not supported by VS2019 correctly: use of MSBuildGlobalSettings.SetCppPlatformFolder should be replaced by use of MSBuildGlobalSettings.SetAdditionalVCTargetsPath.");
}
// vs2019 use AdditionalVCTargetsPath
string additionalVCTargetsPath = MSBuildGlobalSettings.GetAdditionalVCTargetsPath(uniqueDevEnv, Platform.win64);
using (generator.Declare("additionalVCTargetsPath", Util.EnsureTrailingSeparator(additionalVCTargetsPath))) // the path shall end with a "\"
generator.Write(Vcxproj.Template.Project.AdditionalVCTargetsPath);
}
break;
default:
throw new Error(uniqueDevEnv + " is not supported.");
}
ClangForWindows.WriteLLVMOverrides(context, generator);
}
generator.Write(Vcxproj.Template.Project.PropertyGroupEnd);
}
}
private CompilerSettings GetMasterCompilerSettings(IDictionary <string, CompilerSettings> masterCompilerSettings, string compilerName, DevEnv devEnv, string projectRootPath, bool useCCompiler)
{
CompilerSettings compilerSettings;
if (masterCompilerSettings.ContainsKey(compilerName))
{
compilerSettings = masterCompilerSettings[compilerName];
}
else
{
var fastBuildSettings = PlatformRegistry.Get <IFastBuildCompilerSettings>(Platform.linux);
string binPath;
if (!fastBuildSettings.BinPath.TryGetValue(devEnv, out binPath))
{
binPath = ClangForWindows.GetWindowsClangExecutablePath();
}
string pathToCompiler = Util.GetCapitalizedPath(Util.PathGetAbsolute(projectRootPath, binPath));
Strings extraFiles = new Strings();
{
Strings userExtraFiles;
if (fastBuildSettings.ExtraFiles.TryGetValue(devEnv, out userExtraFiles))
{
extraFiles.AddRange(userExtraFiles);
}
}
var compilerFamily = Sharpmake.CompilerFamily.Clang;
var compilerFamilyKey = new FastBuildCompilerKey(devEnv);
if (!fastBuildSettings.CompilerFamily.TryGetValue(compilerFamilyKey, out compilerFamily))
{
compilerFamily = Sharpmake.CompilerFamily.Clang;
}
string executable = useCCompiler ? @"$ExecutableRootPath$\clang.exe" : @"$ExecutableRootPath$\clang++.exe";
compilerSettings = new CompilerSettings(compilerName, compilerFamily, Platform.linux, extraFiles, executable, pathToCompiler, devEnv, new Dictionary <string, CompilerSettings.Configuration>());
masterCompilerSettings.Add(compilerName, compilerSettings);
}
return(compilerSettings);
}
protected override IEnumerable <IncludeWithPrefix> GetPlatformIncludePathsWithPrefixImpl(IGenerationContext context)
{
const string cmdLineIncludePrefix = "/I";
IEnumerable <string> msvcIncludePaths = EnumerateSemiColonSeparatedString(context.DevelopmentEnvironment.GetWindowsIncludePath());
if (Options.GetObject <Options.Vc.General.PlatformToolset>(context.Configuration).IsLLVMToolchain() && Options.GetObject <Options.Vc.LLVM.UseClangCl>(context.Configuration) == Options.Vc.LLVM.UseClangCl.Enable)
{
var includes = new List <IncludeWithPrefix>();
string clangIncludePath = ClangForWindows.GetWindowsClangIncludePath();
includes.Add(new IncludeWithPrefix(cmdLineIncludePrefix, clangIncludePath));
// when using clang-cl, mark MSVC includes, so they are properly recognized
const string msvcCmdLineIncludePrefix = "/imsvc";
includes.AddRange(msvcIncludePaths.Select(msvcIncludePath => new IncludeWithPrefix(msvcCmdLineIncludePrefix, msvcIncludePath)));
return(includes);
}
return(msvcIncludePaths.Select(includePath => new IncludeWithPrefix(cmdLineIncludePrefix, includePath)));
}
public override void GeneratePlatformSpecificProjectDescription(IVcxprojGenerationContext context, IFileGenerator generator)
{
string propertyGroups = string.Empty;
// MSBuild override when mixing devenvs in the same vcxproj is not supported,
// but before throwing an exception check if we have some override
for (DevEnv devEnv = context.DevelopmentEnvironmentsRange.MinDevEnv; devEnv <= context.DevelopmentEnvironmentsRange.MaxDevEnv; devEnv = (DevEnv)((int)devEnv << 1))
{
switch (devEnv)
{
case DevEnv.vs2015:
case DevEnv.vs2017:
{
string platformFolder = MSBuildGlobalSettings.GetCppPlatformFolder(devEnv, Platform.win64);
if (!string.IsNullOrEmpty(platformFolder))
{
using (generator.Declare("platformFolder", Util.EnsureTrailingSeparator(platformFolder))) // _PlatformFolder require the path to end with a "\"
propertyGroups += generator.Resolver.Resolve(Vcxproj.Template.Project.PlatformFolderOverride);
}
}
break;
case DevEnv.vs2019:
case DevEnv.vs2022:
{
// Note1: _PlatformFolder override is deprecated starting with vs2019, so we write AdditionalVCTargetsPath instead
// Note2: MSBuildGlobalSettings.SetCppPlatformFolder for vs2019 and above is no more the valid way to handle it.
if (!string.IsNullOrEmpty(MSBuildGlobalSettings.GetCppPlatformFolder(devEnv, Platform.win64)))
{
throw new Error($"SetCppPlatformFolder is not supported by {devEnv}: use of MSBuildGlobalSettings.SetCppPlatformFolder should be replaced by use of MSBuildGlobalSettings.SetAdditionalVCTargetsPath.");
}
// vs2019 and up use AdditionalVCTargetsPath
string additionalVCTargetsPath = MSBuildGlobalSettings.GetAdditionalVCTargetsPath(devEnv, Platform.win64);
if (!string.IsNullOrEmpty(additionalVCTargetsPath))
{
using (generator.Declare("additionalVCTargetsPath", Util.EnsureTrailingSeparator(additionalVCTargetsPath))) // the path shall end with a "\"
propertyGroups += generator.Resolver.Resolve(Vcxproj.Template.Project.AdditionalVCTargetsPath);
}
}
break;
}
}
string llvmOverrideSection = ClangForWindows.GetLLVMOverridesSection(context, generator.Resolver);
if (!string.IsNullOrEmpty(llvmOverrideSection))
{
propertyGroups += llvmOverrideSection;
}
if (!string.IsNullOrEmpty(propertyGroups))
{
if (context.DevelopmentEnvironmentsRange.MinDevEnv != context.DevelopmentEnvironmentsRange.MaxDevEnv)
{
throw new Error("Different vs versions not supported in the same vcxproj");
}
using (generator.Declare("platformName", SimplePlatformString))
{
generator.Write(Vcxproj.Template.Project.ProjectDescriptionStartPlatformConditional);
generator.WriteVerbatim(propertyGroups);
generator.Write(Vcxproj.Template.Project.PropertyGroupEnd);
}
}
}
protected override IEnumerable <IncludeWithPrefix> GetPlatformIncludePathsWithPrefixImpl(IGenerationContext context)
{
var includes = new List <IncludeWithPrefix>();
string includePrefix = "/I";
var platformToolset = Options.GetObject <Options.Vc.General.PlatformToolset>(context.Configuration);
DevEnv devEnv = platformToolset.GetDefaultDevEnvForToolset() ?? context.DevelopmentEnvironment;
if (platformToolset.IsLLVMToolchain() && Options.GetObject <Options.Vc.LLVM.UseClangCl>(context.Configuration) == Options.Vc.LLVM.UseClangCl.Enable)
{
// when using clang-cl, mark MSVC includes, so they are properly recognized
includePrefix = "/clang:-isystem";
Options.Vc.General.PlatformToolset overridenPlatformToolset = Options.Vc.General.PlatformToolset.Default;
if (Options.WithArgOption <Options.Vc.General.PlatformToolset> .Get <Options.Clang.Compiler.LLVMVcPlatformToolset>(context.Configuration, ref overridenPlatformToolset))
{
platformToolset = overridenPlatformToolset;
devEnv = platformToolset.GetDefaultDevEnvForToolset() ?? context.DevelopmentEnvironment;
}
string clangIncludePath = platformToolset == Options.Vc.General.PlatformToolset.ClangCL ? ClangForWindows.GetWindowsClangIncludePath(devEnv) : ClangForWindows.GetWindowsClangIncludePath();
includes.Add(new IncludeWithPrefix(includePrefix, clangIncludePath));
}
else
{
// this option is mandatory when using /external:I with msvc, so if the user has selected it
// we consider that the vcxproj supports ExternalIncludePath
if (Options.HasOption <Options.Vc.General.ExternalWarningLevel>(context.Configuration))
{
includePrefix = "/external:I";
}
}
IEnumerable <string> msvcIncludePaths = EnumerateSemiColonSeparatedString(devEnv.GetWindowsIncludePath());
includes.AddRange(msvcIncludePaths.Select(path => new IncludeWithPrefix(includePrefix, path)));
// Additional system includes
OrderableStrings SystemIncludes = new OrderableStrings(context.Configuration.DependenciesIncludeSystemPaths);
SystemIncludes.AddRange(context.Configuration.IncludeSystemPaths);
if (SystemIncludes.Count > 0)
{
SystemIncludes.Sort();
includes.AddRange(SystemIncludes.Select(path => new IncludeWithPrefix(includePrefix, path)));
}
return(includes);
}
public override void SetupSdkOptions(IGenerationContext context)
{
var conf = context.Configuration;
var devEnv = context.DevelopmentEnvironment;
// We need to override the executable path for vs2015 because WindowsKit UAP.props does not
// correctly set the WindowsSDK_ExecutablePath to the bin folder of its current version.
if (devEnv == DevEnv.vs2015 && !KitsRootPaths.UsesDefaultKitRoot(devEnv))
{
context.Options["ExecutablePath"] = devEnv.GetWindowsExecutablePath(conf.Platform);
}
Options.Vc.General.PlatformToolset platformToolset = Options.GetObject <Options.Vc.General.PlatformToolset>(conf);
if (Options.Vc.General.PlatformToolset.LLVM == platformToolset)
{
Options.Vc.General.PlatformToolset overridenPlatformToolset = Options.Vc.General.PlatformToolset.Default;
if (Options.WithArgOption <Options.Vc.General.PlatformToolset> .Get <Options.Clang.Compiler.LLVMVcPlatformToolset>(conf, ref overridenPlatformToolset))
{
platformToolset = overridenPlatformToolset;
}
devEnv = platformToolset.GetDefaultDevEnvForToolset() ?? devEnv;
context.Options["ExecutablePath"] = ClangForWindows.GetWindowsClangExecutablePath() + ";" + devEnv.GetWindowsExecutablePath(conf.Platform);
if (Options.GetObject <Options.Vc.LLVM.UseClangCl>(conf) == Options.Vc.LLVM.UseClangCl.Enable)
{
context.Options["IncludePath"] = ClangForWindows.GetWindowsClangIncludePath() + ";" + devEnv.GetWindowsIncludePath();
context.Options["LibraryPath"] = ClangForWindows.GetWindowsClangLibraryPath() + ";" + devEnv.GetWindowsLibraryPath(conf.Platform, Util.IsDotNet(conf) ? conf.Target.GetFragment <DotNetFramework>() : default(DotNetFramework?));
}
}
var systemIncludes = new OrderableStrings(conf.DependenciesIncludeSystemPaths);
systemIncludes.AddRange(conf.IncludeSystemPaths);
if (systemIncludes.Count > 0)
{
systemIncludes.Sort();
string systemIncludesString = Util.PathGetRelative(context.ProjectDirectory, systemIncludes).JoinStrings(";");
// this option is mandatory when using /external:I with msvc, so if the user has selected it
// we consider that the vcxproj supports ExternalIncludePath
if (Options.HasOption <Options.Vc.General.ExternalWarningLevel>(conf))
{
if (context.Options["ExternalIncludePath"] == FileGeneratorUtilities.RemoveLineTag)
{
context.Options["ExternalIncludePath"] = systemIncludesString;
}
else
{
context.Options["ExternalIncludePath"] += ";" + systemIncludesString;
}
}
else
{
if (context.Options["IncludePath"] == FileGeneratorUtilities.RemoveLineTag)
{
context.Options["IncludePath"] = "$(VC_IncludePath);$(WindowsSDK_IncludePath);" + systemIncludesString;
}
else
{
context.Options["IncludePath"] += ";" + systemIncludesString;
}
}
}
}
protected void GetLinkerExecutableInfo(Project.Configuration conf, out string linkerPathOverride, out string linkerExeOverride, out string librarianExeOverride)
{
linkerPathOverride = null;
linkerExeOverride = null;
librarianExeOverride = null;
var platformToolset = Options.GetObject <Options.Vc.General.PlatformToolset>(conf);
var useLldLink = Options.GetObject <Options.Vc.LLVM.UseLldLink>(conf);
if (useLldLink == Options.Vc.LLVM.UseLldLink.Enable ||
(useLldLink == Options.Vc.LLVM.UseLldLink.Default && platformToolset.IsLLVMToolchain()))
{
linkerPathOverride = platformToolset == Options.Vc.General.PlatformToolset.ClangCL ? ClangForWindows.GetWindowsClangExecutablePath(conf.Target.GetFragment <DevEnv>()) : ClangForWindows.GetWindowsClangExecutablePath();
linkerExeOverride = "lld-link.exe";
librarianExeOverride = "llvm-lib.exe";
}
}
