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; // 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); } 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 void AddRange(OrderableStrings collection, int outerOrderNumber = 0, OrderResolve resolveMethod = OrderResolve.None) { List <StringEntry> existingEntriesToAdd = null; foreach (var entry in collection._list) { var newEntry = new StringEntry(entry.StringValue, entry.OrderNumber + outerOrderNumber); if (_hashSet.Add(entry.StringValue)) { _list.Add(newEntry); } else if (newEntry.OrderNumber != 0) // make sure to have orderNumber { if (existingEntriesToAdd == null) { existingEntriesToAdd = new List <StringEntry>(); } existingEntriesToAdd.Add(newEntry); } } if (existingEntriesToAdd != null) { Dictionary <string, int> dict = GetStringToOrderNumberDictionary(existingEntriesToAdd); for (int i = 0; i < _list.Count; ++i) { int orderNumber; if (dict.TryGetValue(_list[i].StringValue, out orderNumber)) { if (_list[i].OrderNumber == 0) { _list[i] = new StringEntry(_list[i].StringValue, orderNumber); } else if (_list[i].OrderNumber != orderNumber) { if (resolveMethod == OrderResolve.Less) { if (orderNumber < _list[i].OrderNumber) { _list[i] = new StringEntry(_list[i].StringValue, orderNumber); } } else if (resolveMethod == OrderResolve.Greater) { if (orderNumber > _list[i].OrderNumber) { _list[i] = new StringEntry(_list[i].StringValue, orderNumber); } } else { throw new Error( "Cannot specify 2 different non-zero order number for \"" + _list[i].StringValue + "\": " + _list[i].OrderNumber + " and " + orderNumber); } } } } } }
internal static void ResolvePathAndFixCase(string root, ref OrderableStrings paths) { for (int i = 0; i < paths.Count; ++i) { string fixedCase = ResolvePathAndFixCase(root, paths[i]); i = paths.SetOrRemoveAtIndex(i, fixedCase); } paths.Sort(); }
public static void ResolvePath(string root, ref OrderableStrings paths) { for (int i = 0; i < paths.Count; ++i) { string resolvedPath = ResolvePath(root, paths[i]); i = paths.SetOrRemoveAtIndex(i, resolvedPath); } paths.Sort(); }
protected virtual IEnumerable<string> GetResourceIncludePathsImpl(IGenerationContext context) { var resourceIncludePaths = new OrderableStrings(); resourceIncludePaths.AddRange(context.Configuration.ResourceIncludePrivatePaths); resourceIncludePaths.AddRange(context.Configuration.ResourceIncludePaths); resourceIncludePaths.AddRange(context.Configuration.DependenciesResourceIncludePaths); return resourceIncludePaths; }
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 static OrderableStrings PathGetRelative(string sourceFullPath, IEnumerable <string> destFullPaths, bool ignoreCase = false) { OrderableStrings result = new OrderableStrings(destFullPaths); for (int i = 0; i < result.Count; ++i) { result[i] = PathGetRelative(sourceFullPath, result[i], ignoreCase); } return(result); }
public static OrderableStrings PathGetCapitalized(OrderableStrings fullPaths) { OrderableStrings result = new OrderableStrings(fullPaths); for (int i = 0; i < result.Count; ++i) { result[i] = GetCapitalizedPath(result[i]); } return(result); }
protected virtual IEnumerable<string> GetIncludePathsImpl(IGenerationContext context) { var includePaths = new OrderableStrings(); includePaths.AddRange(context.Configuration.IncludePrivatePaths); includePaths.AddRange(context.Configuration.IncludePaths); includePaths.AddRange(context.Configuration.DependenciesIncludePaths); includePaths.Sort(); return includePaths; }
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); }
protected override IEnumerable <string> GetIncludePathsImpl(IGenerationContext context) { var includePaths1 = new OrderableStrings(); var includePaths2 = new OrderableStrings(); includePaths2.AddRange(context.Configuration.IncludePrivatePaths); includePaths2.AddRange(context.Configuration.IncludePaths); includePaths2.AddRange(context.Configuration.DependenciesIncludePaths); Options.Vc.RemoteBuild.RelativeDirectory relativeDirectoryOption = Options.GetObject <Options.Vc.RemoteBuild.RelativeDirectory>(context.Configuration); if (relativeDirectoryOption != null) { string basePath = relativeDirectoryOption.Value.TrimEnd(Util.WindowsSeparator); Options.Vc.RemoteBuild.ProjectDirectory projectDirectoryOption = Options.GetObject <Options.Vc.RemoteBuild.ProjectDirectory>(context.Configuration); if (projectDirectoryOption != null) { basePath += Util.WindowsSeparator + projectDirectoryOption.Value.TrimEnd(Util.WindowsSeparator); } for (int i = 0; i < includePaths2.Count; ++i) { string includePath = includePaths2[i]; foreach (var variable in Options.GetObjects <Options.Vc.RemoteBuild.Variable>(context.Configuration)) { includePath = includePath.Replace(@"$(" + variable.Key + @")", variable.Value); } string remotePath = Util.PathGetRelative(basePath, includePath.TrimEnd(Util.WindowsSeparator)); if (remotePath != includePath) { includePaths1.Add(remotePath); } } } includePaths1.AddRange(includePaths2); return(includePaths1); }
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(); } } 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 OrderableStrings(OrderableStrings other) { _list.AddRange(other._list); _hashSet.UnionWith(other._hashSet); }
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; } } } }
public override void SelectPlatformAdditionalDependenciesOptions(IGenerationContext context) { context.Options["AdditionalLibraryDirectories"] = FileGeneratorUtilities.RemoveLineTag; context.Options["AdditionalDependencies"] = FileGeneratorUtilities.RemoveLineTag; context.Options["LibraryDependencies"] = FileGeneratorUtilities.RemoveLineTag; context.CommandLineOptions["AdditionalDependencies"] = FileGeneratorUtilities.RemoveLineTag; context.CommandLineOptions["AdditionalLibraryDirectories"] = FileGeneratorUtilities.RemoveLineTag; context.CommandLineOptions["LibraryDependencies"] = FileGeneratorUtilities.RemoveLineTag; var dependencies = new List <Project.Configuration>(); dependencies.AddRange(context.Configuration.ResolvedPublicDependencies); // Sort by the number of dependencies to get a good starting point dependencies.Sort((Project.Configuration d0, Project.Configuration d1) => { return(d1.ProjectGuidDependencies.Count.CompareTo(d0.ProjectGuidDependencies.Count)); }); var libPaths = new OrderableStrings(); var libFiles = new OrderableStrings(); foreach (var dependency in dependencies) { string outputFileName = dependency.TargetFileName; string outputPrefix = GetOutputFileNamePrefix(context, dependency.Output); if (!string.IsNullOrEmpty(outputPrefix)) { outputFileName = outputPrefix + outputFileName; } string outputExtension = GetDefaultOutputExtension(dependency.Output); if (!string.IsNullOrEmpty(outputExtension)) { outputFileName = outputFileName + "." + outputExtension; } string libPath = dependency.IntermediatePath + Util.WindowsSeparator + outputFileName; foreach (var variable in Options.GetObjects <Options.Vc.RemoteBuild.Variable>(context.Configuration)) { libPath = libPath.Replace(@"$(" + variable.Key + @")", variable.Value); } string remotePath = Util.PathGetRelative(dependency.ProjectPath.TrimEnd(Util.WindowsSeparator), libPath.TrimEnd(Util.WindowsSeparator)); Options.Vc.RemoteBuild.ProjectDirectory projectDirectoryOption = Options.GetObject <Options.Vc.RemoteBuild.ProjectDirectory>(dependency); if (projectDirectoryOption != null) { remotePath = projectDirectoryOption.Value.TrimEnd(Util.WindowsSeparator) + Util.WindowsSeparator + remotePath; // Unlike the include paths, this needs the RemoteRootDir variable and unix separators remotePath = @"$(RemoteRootDir)" + Util.UnixSeparator + remotePath.Replace(Util.WindowsSeparator, Util.UnixSeparator); libPaths.Add(remotePath); } } foreach (var file in context.Configuration.LibraryFiles) { if (file.Contains(Util.WindowsSeparator.ToString())) { string libPath = file; Options.Vc.RemoteBuild.RelativeDirectory relativeDirectoryOption = Options.GetObject <Options.Vc.RemoteBuild.RelativeDirectory>(context.Configuration); if (relativeDirectoryOption != null) { string basePath = relativeDirectoryOption.Value.TrimEnd(Util.WindowsSeparator); foreach (var variable in Options.GetObjects <Options.Vc.RemoteBuild.Variable>(context.Configuration)) { libPath = libPath.Replace(@"$(" + variable.Key + @")", variable.Value); } string remotePath = Util.PathGetRelative(basePath, libPath.TrimEnd(Util.WindowsSeparator)); remotePath = @"$(RemoteRootDir)" + Util.UnixSeparator + remotePath.Replace(Util.WindowsSeparator, Util.UnixSeparator); libPaths.Add(remotePath); } } else { libFiles.Add(file); } } context.Options["AdditionalDependencies"] = string.Join(";", libPaths); context.Options["LibraryDependencies"] = string.Join(";", libFiles); }