/****************************************************************************
|
**
|
** Copyright (C) 2016 The Qt Company Ltd.
|
** Contact: https://www.qt.io/licensing/
|
**
|
** This file is part of the Qt VS Tools.
|
**
|
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
|
** Commercial License Usage
|
** Licensees holding valid commercial Qt licenses may use this file in
|
** accordance with the commercial license agreement provided with the
|
** Software or, alternatively, in accordance with the terms contained in
|
** a written agreement between you and The Qt Company. For licensing terms
|
** and conditions see https://www.qt.io/terms-conditions. For further
|
** information use the contact form at https://www.qt.io/contact-us.
|
**
|
** GNU General Public License Usage
|
** Alternatively, this file may be used under the terms of the GNU
|
** General Public License version 3 as published by the Free Software
|
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
|
** included in the packaging of this file. Please review the following
|
** information to ensure the GNU General Public License requirements will
|
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
|
**
|
** $QT_END_LICENSE$
|
**
|
****************************************************************************/
|
|
using EnvDTE;
|
using Microsoft.VisualStudio.VCProjectEngine;
|
using Microsoft.Win32;
|
using QtVsTools.Core.QtMsBuild;
|
using System;
|
using System.Collections.Generic;
|
using System.Diagnostics;
|
using System.Drawing;
|
using System.IO;
|
using System.Linq;
|
using System.Reflection;
|
using System.Text;
|
using System.Text.RegularExpressions;
|
using System.Windows.Forms;
|
|
using Process = System.Diagnostics.Process;
|
|
namespace QtVsTools.Core
|
{
|
public static class HelperFunctions
|
{
|
public static string FindQtDirWithTools(Project project)
|
{
|
var versionManager = QtVersionManager.The();
|
string projectQtVersion = null;
|
if (IsQtProject(project))
|
projectQtVersion = versionManager.GetProjectQtVersion(project);
|
return FindQtDirWithTools(projectQtVersion);
|
}
|
|
public static string FindQtDirWithTools(string projectQtVersion)
|
{
|
string tool = null;
|
return FindQtDirWithTools(tool, projectQtVersion);
|
}
|
|
public static string FindQtDirWithTools(string tool, string projectQtVersion)
|
{
|
if (!string.IsNullOrEmpty(tool)) {
|
if (!tool.StartsWith("\\bin\\", StringComparison.OrdinalIgnoreCase))
|
tool = "\\bin\\" + tool;
|
if (!tool.EndsWith(".exe", StringComparison.OrdinalIgnoreCase))
|
tool += ".exe";
|
}
|
|
var versionManager = QtVersionManager.The();
|
string qtDir = null;
|
if (projectQtVersion != null)
|
qtDir = versionManager.GetInstallPath(projectQtVersion);
|
|
if (qtDir == null)
|
qtDir = Environment.GetEnvironmentVariable("QTDIR");
|
|
var found = false;
|
if (tool == null) {
|
found = File.Exists(qtDir + "\\bin\\designer.exe")
|
&& File.Exists(qtDir + "\\bin\\linguist.exe");
|
} else {
|
found = File.Exists(qtDir + tool);
|
}
|
if (!found) {
|
VersionInformation exactlyMatchingVersion = null;
|
VersionInformation matchingVersion = null;
|
VersionInformation somehowMatchingVersion = null;
|
var viProjectQtVersion = versionManager.GetVersionInfo(projectQtVersion);
|
foreach (var qtVersion in versionManager.GetVersions()) {
|
var vi = versionManager.GetVersionInfo(qtVersion);
|
if (tool == null) {
|
found = File.Exists(vi.qtDir + "\\bin\\designer.exe")
|
&& File.Exists(vi.qtDir + "\\bin\\linguist.exe");
|
} else {
|
found = File.Exists(vi.qtDir + tool);
|
}
|
if (!found)
|
continue;
|
|
if (viProjectQtVersion != null
|
&& vi.qtMajor == viProjectQtVersion.qtMajor
|
&& vi.qtMinor == viProjectQtVersion.qtMinor) {
|
exactlyMatchingVersion = vi;
|
break;
|
}
|
if (matchingVersion == null
|
&& viProjectQtVersion != null
|
&& vi.qtMajor == viProjectQtVersion.qtMajor) {
|
matchingVersion = vi;
|
}
|
if (somehowMatchingVersion == null)
|
somehowMatchingVersion = vi;
|
}
|
|
if (exactlyMatchingVersion != null)
|
qtDir = exactlyMatchingVersion.qtDir;
|
else if (matchingVersion != null)
|
qtDir = matchingVersion.qtDir;
|
else if (somehowMatchingVersion != null)
|
qtDir = somehowMatchingVersion.qtDir;
|
else
|
qtDir = null;
|
}
|
return qtDir;
|
}
|
|
static readonly HashSet<string> _sources = new HashSet<string>(new[] { ".c", ".cpp", ".cxx" },
|
StringComparer.OrdinalIgnoreCase);
|
static public bool IsSourceFile(string fileName)
|
{
|
return _sources.Contains(Path.GetExtension(fileName));
|
}
|
|
static readonly HashSet<string> _headers = new HashSet<string>(new[] { ".h", ".hpp", ".hxx" },
|
StringComparer.OrdinalIgnoreCase);
|
static public bool IsHeaderFile(string fileName)
|
{
|
return _headers.Contains(Path.GetExtension(fileName));
|
}
|
|
public static bool IsUicFile(string fileName)
|
{
|
return ".ui".Equals(Path.GetExtension(fileName), StringComparison.OrdinalIgnoreCase);
|
}
|
|
public static bool IsMocFile(string fileName)
|
{
|
return ".moc".Equals(Path.GetExtension(fileName), StringComparison.OrdinalIgnoreCase);
|
}
|
|
public static bool IsQrcFile(string fileName)
|
{
|
return ".qrc".Equals(Path.GetExtension(fileName), StringComparison.OrdinalIgnoreCase);
|
}
|
|
public static bool IsWinRCFile(string fileName)
|
{
|
return ".rc".Equals(Path.GetExtension(fileName), StringComparison.OrdinalIgnoreCase);
|
}
|
|
public static bool IsTranslationFile(string fileName)
|
{
|
return ".ts".Equals(Path.GetExtension(fileName), StringComparison.OrdinalIgnoreCase);
|
}
|
|
public static bool IsQmlFile(string fileName)
|
{
|
return ".qml".Equals(Path.GetExtension(fileName), StringComparison.OrdinalIgnoreCase);
|
}
|
|
static public void SetDebuggingEnvironment(Project prj)
|
{
|
SetDebuggingEnvironment(prj, string.Empty);
|
}
|
|
static public void SetDebuggingEnvironment(Project prj, string solutionConfig)
|
{
|
SetDebuggingEnvironment(prj, "PATH=$(QTDIR)\\bin;$(PATH)", false, solutionConfig);
|
}
|
|
static public void SetDebuggingEnvironment(Project prj, string envpath, bool overwrite)
|
{
|
SetDebuggingEnvironment(prj, envpath, overwrite, string.Empty);
|
}
|
|
static public void SetDebuggingEnvironment(Project prj, string envpath, bool overwrite, string solutionConfig)
|
{
|
if (QtProject.GetFormatVersion(prj) >= Resources.qtMinFormatVersion_Settings)
|
return;
|
|
// Get platform name from given solution configuration
|
// or if not available take the active configuration
|
var activePlatformName = string.Empty;
|
if (string.IsNullOrEmpty(solutionConfig)) {
|
// First get active configuration cause not given as parameter
|
try {
|
var activeConf = prj.ConfigurationManager.ActiveConfiguration;
|
activePlatformName = activeConf.PlatformName;
|
} catch {
|
Messages.Print("Could not get the active platform name.");
|
}
|
} else {
|
activePlatformName = solutionConfig.Split('|')[1];
|
}
|
|
var vcprj = prj.Object as VCProject;
|
foreach (VCConfiguration conf in vcprj.Configurations as IVCCollection) {
|
// Set environment only for active (or given) platform
|
var currentPlatform = conf.Platform as VCPlatform;
|
if (currentPlatform == null || currentPlatform.Name != activePlatformName)
|
continue;
|
|
var de = conf.DebugSettings as VCDebugSettings;
|
if (de == null)
|
continue;
|
|
// See: https://connect.microsoft.com/VisualStudio/feedback/details/619702
|
// Project | Properties | Configuration Properties | Debugging | Environment
|
//
|
// Issue: Substitution of ";" to "%3b"
|
// Answer: This behavior currently is by design as ';' is a special MSBuild
|
// character and needs to be escaped. In the Project Properties we show this
|
// escaped value, but it should be the original when we use it.
|
envpath = envpath.Replace("%3b", ";");
|
de.Environment = de.Environment.Replace("%3b", ";");
|
|
var index = envpath.LastIndexOf(";$(PATH)", StringComparison.Ordinal);
|
var withoutPath = (index >= 0 ? envpath.Remove(index) : envpath);
|
|
if (overwrite || string.IsNullOrEmpty(de.Environment))
|
de.Environment = envpath;
|
else if (!de.Environment.Contains(envpath) && !de.Environment.Contains(withoutPath)) {
|
var m = Regex.Match(de.Environment, "PATH\\s*=\\s*");
|
if (m.Success) {
|
de.Environment = Regex.Replace(de.Environment, "PATH\\s*=\\s*", withoutPath + ";");
|
if (!de.Environment.Contains("$(PATH)") && !de.Environment.Contains("%PATH%")) {
|
if (!de.Environment.EndsWith(";", StringComparison.Ordinal))
|
de.Environment = de.Environment + ";";
|
de.Environment += "$(PATH)";
|
}
|
} else {
|
if (!string.IsNullOrEmpty(de.Environment))
|
de.Environment += "\n";
|
de.Environment += envpath;
|
}
|
}
|
}
|
}
|
|
public static bool IsProjectInSolution(DTE dteObject, string fullName)
|
{
|
var fi = new FileInfo(fullName);
|
|
foreach (var p in ProjectsInSolution(dteObject)) {
|
if (p.FullName.ToLower() == fi.FullName.ToLower())
|
return true;
|
}
|
return false;
|
}
|
|
/// <summary>
|
/// Returns the normalized file path of a given file.
|
/// </summary>
|
/// <param name="name">file name</param>
|
static public string NormalizeFilePath(string name)
|
{
|
var fi = new FileInfo(name);
|
return fi.FullName;
|
}
|
|
static public string NormalizeRelativeFilePath(string path)
|
{
|
if (path == null)
|
return ".\\";
|
|
path = path.Trim();
|
path = path.Replace("/", "\\");
|
|
var tmp = string.Empty;
|
while (tmp != path) {
|
tmp = path;
|
path = path.Replace("\\\\", "\\");
|
}
|
|
path = path.Replace("\"", "");
|
|
if (path != "." && !IsAbsoluteFilePath(path) && !path.StartsWith(".\\", StringComparison.Ordinal)
|
&& !path.StartsWith("$", StringComparison.Ordinal))
|
path = ".\\" + path;
|
|
if (path.EndsWith("\\", StringComparison.Ordinal))
|
path = path.Substring(0, path.Length - 1);
|
|
return path;
|
}
|
|
static public bool IsAbsoluteFilePath(string path)
|
{
|
path = path.Trim();
|
if (path.Length >= 2 && path[1] == ':')
|
return true;
|
if (path.StartsWith("\\", StringComparison.Ordinal) || path.StartsWith("/", StringComparison.Ordinal))
|
return true;
|
|
return false;
|
}
|
|
/// <summary>
|
/// Reads lines from a .pro file that is opened with a StreamReader
|
/// and concatenates strings that end with a backslash.
|
/// </summary>
|
/// <param name="streamReader"></param>
|
/// <returns>the composite string</returns>
|
static private string ReadProFileLine(StreamReader streamReader)
|
{
|
var line = streamReader.ReadLine();
|
if (line == null)
|
return null;
|
|
line = line.TrimEnd(' ', '\t');
|
while (line.EndsWith("\\", StringComparison.Ordinal)) {
|
line = line.Remove(line.Length - 1);
|
var appendix = streamReader.ReadLine();
|
if (appendix != null)
|
line += appendix.TrimEnd(' ', '\t');
|
}
|
return line;
|
}
|
|
/// <summary>
|
/// Reads a .pro file and returns true if it is a subdirs template.
|
/// </summary>
|
/// <param name="profile">full name of .pro file to read</param>
|
/// <returns>true if this is a subdirs file</returns>
|
static public bool IsSubDirsFile(string profile)
|
{
|
StreamReader sr = null;
|
try {
|
sr = new StreamReader(profile);
|
|
var line = string.Empty;
|
while ((line = ReadProFileLine(sr)) != null) {
|
line = line.Replace(" ", string.Empty).Replace("\t", string.Empty);
|
if (line.StartsWith("TEMPLATE", StringComparison.Ordinal))
|
return line.StartsWith("TEMPLATE=subdirs", StringComparison.Ordinal);
|
}
|
} catch (Exception e) {
|
Messages.DisplayErrorMessage(e);
|
} finally {
|
if (sr != null)
|
sr.Dispose();
|
}
|
return false;
|
}
|
|
/// <summary>
|
/// Returns the relative path between a given file and a path.
|
/// </summary>
|
/// <param name="path">absolute path</param>
|
/// <param name="file">absolute file name</param>
|
public static string GetRelativePath(string path, string file)
|
{
|
if (file == null || path == null)
|
return "";
|
var fi = new FileInfo(file);
|
var di = new DirectoryInfo(path);
|
|
char[] separator = { '\\' };
|
var fiArray = fi.FullName.Split(separator);
|
var dir = di.FullName;
|
while (dir.EndsWith("\\", StringComparison.Ordinal))
|
dir = dir.Remove(dir.Length - 1, 1);
|
var diArray = dir.Split(separator);
|
|
var minLen = fiArray.Length < diArray.Length ? fiArray.Length : diArray.Length;
|
int i = 0, j = 0, commonParts = 0;
|
|
while (i < minLen && fiArray[i].ToLower() == diArray[i].ToLower()) {
|
commonParts++;
|
i++;
|
}
|
|
if (commonParts < 1)
|
return fi.FullName;
|
|
var result = string.Empty;
|
|
for (j = i; j < fiArray.Length; j++) {
|
if (j == i)
|
result = fiArray[j];
|
else
|
result += "\\" + fiArray[j];
|
}
|
while (i < diArray.Length) {
|
result = "..\\" + result;
|
i++;
|
}
|
//MessageBox.Show(path + "\n" + file + "\n" + result);
|
if (result.StartsWith("..\\", StringComparison.Ordinal))
|
return result;
|
return ".\\" + result;
|
}
|
|
/// <summary>
|
/// Replaces a string in the commandLine, description, outputs and additional dependencies
|
/// in all Custom build tools of the project
|
/// </summary>
|
/// <param name="project">Project</param>
|
/// <param name="oldString">String, which is going to be replaced</param>
|
/// <param name="oldString">String, which is going to replace the other one</param>
|
/// <returns></returns>
|
public static void ReplaceInCustomBuildTools(Project project, string oldString, string replaceString)
|
{
|
var vcPro = (VCProject)project.Object;
|
if (vcPro == null)
|
return;
|
|
var qtMsBuild = new QtMsBuildContainer(new VCPropertyStorageProvider());
|
qtMsBuild.BeginSetItemProperties();
|
foreach (VCFile vcfile in (IVCCollection)vcPro.Files) {
|
foreach (VCFileConfiguration config in (IVCCollection)vcfile.FileConfigurations) {
|
try {
|
if (vcfile.ItemType == "CustomBuild") {
|
var tool = GetCustomBuildTool(config);
|
if (tool == null)
|
continue;
|
|
tool.CommandLine = tool.CommandLine
|
.Replace(oldString, replaceString,
|
StringComparison.OrdinalIgnoreCase);
|
tool.Description = tool.Description
|
.Replace(oldString, replaceString,
|
StringComparison.OrdinalIgnoreCase);
|
tool.Outputs = tool.Outputs
|
.Replace(oldString, replaceString,
|
StringComparison.OrdinalIgnoreCase);
|
tool.AdditionalDependencies = tool.AdditionalDependencies
|
.Replace(oldString, replaceString,
|
StringComparison.OrdinalIgnoreCase);
|
} else {
|
var tool = new QtCustomBuildTool(config, qtMsBuild);
|
tool.CommandLine = tool.CommandLine
|
.Replace(oldString, replaceString,
|
StringComparison.OrdinalIgnoreCase);
|
}
|
} catch (Exception) {
|
}
|
}
|
}
|
qtMsBuild.EndSetItemProperties();
|
}
|
|
/// <summary>
|
/// Since VS2010 it is possible to have VCCustomBuildTools without commandlines
|
/// for certain filetypes. We are not interested in them and thus try to read the
|
/// tool's commandline. If this causes an exception, we ignore it.
|
/// There does not seem to be another way for checking which kind of tool it is.
|
/// </summary>
|
/// <param name="config">File configuration</param>
|
/// <returns></returns>
|
static public VCCustomBuildTool GetCustomBuildTool(VCFileConfiguration config)
|
{
|
var file = config.File as VCFile;
|
if (file == null || file.ItemType != "CustomBuild")
|
return null;
|
|
var tool = config.Tool as VCCustomBuildTool;
|
if (tool == null)
|
return null;
|
|
try {
|
// TODO: The return value is not used at all?
|
var cmdLine = tool.CommandLine;
|
} catch {
|
return null;
|
}
|
return tool;
|
}
|
|
/// <summary>
|
/// Since VS2010 we have to ensure, that a custom build tool is present
|
/// if we want to use it. In order to do so, the ProjectItem's ItemType
|
/// has to be "CustomBuild"
|
/// </summary>
|
/// <param name="projectItem">Project Item which needs to have custom build tool</param>
|
static public void EnsureCustomBuildToolAvailable(ProjectItem projectItem)
|
{
|
foreach (Property prop in projectItem.Properties) {
|
if (prop.Name == "ItemType") {
|
if ((string)prop.Value != "CustomBuild")
|
prop.Value = "CustomBuild";
|
break;
|
}
|
}
|
}
|
|
/// <summary>
|
/// As Qmake -tp vc Adds the full path to the additional dependencies
|
/// we need to do the same when toggling project kind to qmake generated.
|
/// </summary>
|
/// <returns></returns>
|
private static string AddFullPathToAdditionalDependencies(string qtDir, string additionalDependencies)
|
{
|
var returnString = additionalDependencies;
|
returnString =
|
Regex.Replace(returnString, "Qt(\\S+5?)\\.lib", qtDir + "\\lib\\Qt${1}.lib");
|
returnString =
|
Regex.Replace(returnString, "(qtmaind?5?)\\.lib", qtDir + "\\lib\\${1}.lib");
|
returnString =
|
Regex.Replace(returnString, "(enginiod?5?)\\.lib", qtDir + "\\lib\\${1}.lib");
|
return returnString;
|
}
|
|
/// <summary>
|
/// Toggles the kind of a project. If the project is a QMake generated project (qmake -tp vc)
|
/// it is transformed to an Qt VS Tools project and vice versa.
|
/// </summary>
|
/// <param name="project">Project</param>
|
/// <returns></returns>
|
public static void ToggleProjectKind(Project project)
|
{
|
if (QtProject.GetFormatVersion(project) >= Resources.qtMinFormatVersion_Settings)
|
return;
|
|
string qtDir = null;
|
var vcPro = (VCProject)project.Object;
|
if (!IsQMakeProject(project))
|
return;
|
if (IsQtProject(project)) {
|
// TODO: qtPro is never used.
|
var qtPro = QtProject.Create(project);
|
var vm = QtVersionManager.The();
|
qtDir = vm.GetInstallPath(project);
|
|
foreach (var global in (string[])project.Globals.VariableNames) {
|
if (global.StartsWith("Qt5Version", StringComparison.Ordinal))
|
project.Globals.set_VariablePersists(global, false);
|
}
|
|
foreach (VCConfiguration config in (IVCCollection)vcPro.Configurations) {
|
var compiler = CompilerToolWrapper.Create(config);
|
var linker = (VCLinkerTool)((IVCCollection)config.Tools).Item("VCLinkerTool");
|
var librarian = (VCLibrarianTool)((IVCCollection)config.Tools).Item("VCLibrarianTool");
|
if (compiler != null) {
|
var additionalIncludes = compiler.GetAdditionalIncludeDirectories();
|
additionalIncludes = additionalIncludes.Replace("$(QTDIR)", qtDir,
|
StringComparison.OrdinalIgnoreCase);
|
compiler.SetAdditionalIncludeDirectories(additionalIncludes);
|
}
|
if (linker != null) {
|
linker.AdditionalLibraryDirectories = linker.AdditionalLibraryDirectories.
|
Replace("$(QTDIR)", qtDir, StringComparison.OrdinalIgnoreCase);
|
linker.AdditionalDependencies = AddFullPathToAdditionalDependencies(qtDir, linker.AdditionalDependencies);
|
} else {
|
librarian.AdditionalLibraryDirectories = librarian.AdditionalLibraryDirectories
|
.Replace("$(QTDIR)", qtDir, StringComparison.OrdinalIgnoreCase);
|
librarian.AdditionalDependencies = AddFullPathToAdditionalDependencies(qtDir, librarian.AdditionalDependencies);
|
}
|
}
|
|
ReplaceInCustomBuildTools(project, "$(QTDIR)", qtDir);
|
} else {
|
qtDir = GetQtDirFromQMakeProject(project);
|
|
var vm = QtVersionManager.The();
|
var qtVersion = vm.GetQtVersionFromInstallDir(qtDir);
|
if (qtVersion == null)
|
qtVersion = vm.GetDefaultVersion();
|
if (qtDir == null)
|
qtDir = vm.GetInstallPath(qtVersion);
|
var vi = vm.GetVersionInfo(qtVersion);
|
var platformName = vi.GetVSPlatformName();
|
vm.SaveProjectQtVersion(project, qtVersion, platformName);
|
var qtPro = QtProject.Create(project);
|
if (!qtPro.SelectSolutionPlatform(platformName) || !qtPro.HasPlatform(platformName)) {
|
var newProject = false;
|
qtPro.CreatePlatform("Win32", platformName, null, vi, ref newProject);
|
if (!qtPro.SelectSolutionPlatform(platformName))
|
Messages.Print("Can't select the platform " + platformName + ".");
|
}
|
|
var activeConfig = project.ConfigurationManager.ActiveConfiguration.ConfigurationName;
|
var activeVCConfig = (VCConfiguration)((IVCCollection)qtPro.VCProject.Configurations).Item(activeConfig);
|
if (activeVCConfig.ConfigurationType == ConfigurationTypes.typeDynamicLibrary) {
|
var compiler = CompilerToolWrapper.Create(activeVCConfig);
|
var linker = (VCLinkerTool)((IVCCollection)activeVCConfig.Tools).Item("VCLinkerTool");
|
var ppdefs = compiler.GetPreprocessorDefinitions();
|
if (ppdefs != null
|
&& ppdefs.IndexOf("QT_PLUGIN", StringComparison.Ordinal) > -1
|
&& ppdefs.IndexOf("QDESIGNER_EXPORT_WIDGETS", StringComparison.Ordinal) > -1
|
&& ppdefs.IndexOf("QtDesigner", StringComparison.Ordinal) > -1
|
&& linker.AdditionalDependencies != null
|
&& linker.AdditionalDependencies.IndexOf("QtDesigner", StringComparison.Ordinal) > -1) {
|
qtPro.MarkAsDesignerPluginProject();
|
}
|
}
|
|
CleanupQMakeDependencies(project);
|
|
foreach (VCConfiguration config in (IVCCollection)vcPro.Configurations) {
|
var compiler = CompilerToolWrapper.Create(config);
|
var linker = (VCLinkerTool)((IVCCollection)config.Tools).Item("VCLinkerTool");
|
|
if (compiler != null) {
|
var additionalIncludes = compiler.AdditionalIncludeDirectories;
|
if (additionalIncludes != null) {
|
ReplaceDirectory(ref additionalIncludes, qtDir, "$(QTDIR)", project);
|
compiler.AdditionalIncludeDirectories = additionalIncludes;
|
}
|
}
|
if (linker != null) {
|
var linkerToolWrapper = new LinkerToolWrapper(linker);
|
var paths = linkerToolWrapper.AdditionalLibraryDirectories;
|
if (paths != null) {
|
ReplaceDirectory(ref paths, qtDir, "$(QTDIR)", project);
|
linkerToolWrapper.AdditionalLibraryDirectories = paths;
|
}
|
}
|
}
|
|
ReplaceInCustomBuildTools(project, qtDir, "$(QTDIR)");
|
qtPro.TranslateFilterNames();
|
}
|
project.Save(project.FullName);
|
}
|
|
/// <summary>
|
/// Replaces every occurrence of oldDirectory with replacement in the array of strings.
|
/// Parameter oldDirectory must be an absolute path.
|
/// This function converts relative directories to absolute paths internally
|
/// and replaces them, if necessary. If no replacement is done, the path isn't altered.
|
/// </summary>
|
/// <param name="project">The project is needed to convert relative paths to absolute paths.</param>
|
private static void ReplaceDirectory(ref List<string> paths, string oldDirectory, string replacement, Project project)
|
{
|
for (var i = 0; i < paths.Count; ++i) {
|
var dirName = paths[i];
|
if (dirName.StartsWith("\"", StringComparison.Ordinal) && dirName.EndsWith("\"", StringComparison.Ordinal)) {
|
dirName = dirName.Substring(1, dirName.Length - 2);
|
}
|
if (!Path.IsPathRooted(dirName)) {
|
// convert to absolute path
|
dirName = Path.Combine(Path.GetDirectoryName(project.FullName), dirName);
|
dirName = Path.GetFullPath(dirName);
|
var alteredDirName = dirName.Replace(oldDirectory, replacement, StringComparison
|
.OrdinalIgnoreCase);
|
if (alteredDirName == dirName)
|
continue;
|
dirName = alteredDirName;
|
} else {
|
dirName = dirName.Replace(oldDirectory, replacement, StringComparison
|
.OrdinalIgnoreCase);
|
}
|
paths[i] = dirName;
|
}
|
}
|
|
public static string GetQtDirFromQMakeProject(Project project)
|
{
|
var vcProject = project.Object as VCProject;
|
if (vcProject == null)
|
return null;
|
|
try {
|
foreach (VCConfiguration projectConfig in vcProject.Configurations as IVCCollection) {
|
var compiler = CompilerToolWrapper.Create(projectConfig);
|
if (compiler != null) {
|
var additionalIncludeDirectories = compiler.AdditionalIncludeDirectories;
|
if (additionalIncludeDirectories != null) {
|
foreach (var dir in additionalIncludeDirectories) {
|
var subdir = Path.GetFileName(dir);
|
if (subdir != "QtCore" && subdir != "QtGui") // looking for Qt include directories
|
continue;
|
var dirName = Path.GetDirectoryName(dir); // cd ..
|
dirName = Path.GetDirectoryName(dirName); // cd ..
|
if (!Path.IsPathRooted(dirName)) {
|
var projectDir = Path.GetDirectoryName(project.FullName);
|
dirName = Path.Combine(projectDir, dirName);
|
dirName = Path.GetFullPath(dirName);
|
}
|
return dirName;
|
}
|
}
|
}
|
|
var linker = (VCLinkerTool)((IVCCollection)projectConfig.Tools).Item("VCLinkerTool");
|
if (linker != null) {
|
var linkerWrapper = new LinkerToolWrapper(linker);
|
var linkerPaths = linkerWrapper.AdditionalDependencies;
|
if (linkerPaths != null) {
|
foreach (var library in linkerPaths) {
|
var idx = library.IndexOf("\\lib\\qtmain.lib", StringComparison.OrdinalIgnoreCase);
|
if (idx == -1)
|
idx = library.IndexOf("\\lib\\qtmaind.lib", StringComparison.OrdinalIgnoreCase);
|
if (idx == -1)
|
idx = library.IndexOf("\\lib\\qtcore5.lib", StringComparison.OrdinalIgnoreCase);
|
if (idx == -1)
|
idx = library.IndexOf("\\lib\\qtcored5.lib", StringComparison.OrdinalIgnoreCase);
|
if (idx == -1)
|
continue;
|
|
var dirName = Path.GetDirectoryName(library);
|
dirName = Path.GetDirectoryName(dirName); // cd ..
|
if (!Path.IsPathRooted(dirName)) {
|
var projectDir = Path.GetDirectoryName(project.FullName);
|
dirName = Path.Combine(projectDir, dirName);
|
dirName = Path.GetFullPath(dirName);
|
}
|
|
return dirName;
|
}
|
}
|
|
linkerPaths = linkerWrapper.AdditionalLibraryDirectories;
|
if (linkerPaths != null) {
|
foreach (var libDir in linkerPaths) {
|
var dirName = libDir;
|
if (!Path.IsPathRooted(dirName)) {
|
var projectDir = Path.GetDirectoryName(project.FullName);
|
dirName = Path.Combine(projectDir, dirName);
|
dirName = Path.GetFullPath(dirName);
|
}
|
|
if (File.Exists(dirName + "\\qtmain.lib") ||
|
File.Exists(dirName + "\\qtmaind.lib") ||
|
File.Exists(dirName + "\\QtCore5.lib") ||
|
File.Exists(dirName + "\\QtCored5.lib")) {
|
return Path.GetDirectoryName(dirName);
|
}
|
}
|
}
|
}
|
}
|
} catch { }
|
|
return null;
|
}
|
|
/// <summary>
|
/// Return true if the project is a Qt project, otherwise false.
|
/// </summary>
|
/// <param name="proj">project</param>
|
/// <returns></returns>
|
public static bool IsQtProject(VCProject proj)
|
{
|
if (!IsQMakeProject(proj))
|
return false;
|
|
if (QtProject.GetFormatVersion(proj) >= Resources.qtMinFormatVersion_Settings)
|
return true;
|
|
var envPro = proj.Object as Project;
|
if (envPro.Globals == null || envPro.Globals.VariableNames == null)
|
return false;
|
|
foreach (var global in envPro.Globals.VariableNames as string[]) {
|
if (global.StartsWith("Qt5Version", StringComparison.Ordinal) && envPro.Globals.get_VariablePersists(global))
|
return true;
|
}
|
return false;
|
}
|
|
/// <summary>
|
/// Returns true if the specified project is a Qt Project.
|
/// </summary>
|
/// <param name="proj">project</param>
|
public static bool IsQtProject(Project proj)
|
{
|
try {
|
if (proj != null && proj.Kind == "{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}")
|
return IsQtProject(proj.Object as VCProject);
|
} catch { }
|
return false;
|
}
|
|
/// <summary>
|
/// Return true if the project is a QMake -tp vc project, otherwise false.
|
/// </summary>
|
/// <param name="proj">project</param>
|
/// <returns></returns>
|
public static bool IsQMakeProject(VCProject proj)
|
{
|
if (proj == null)
|
return false;
|
var keyword = proj.keyword;
|
if (keyword == null ||
|
(!keyword.StartsWith(Resources.qtProjectV2Keyword, StringComparison.Ordinal)
|
&& !keyword.StartsWith(Resources.qtProjectKeyword, StringComparison.Ordinal))) {
|
return false;
|
}
|
|
return true;
|
}
|
|
/// <summary>
|
/// Returns true if the specified project is a QMake -tp vc Project.
|
/// </summary>
|
/// <param name="proj">project</param>
|
public static bool IsQMakeProject(Project proj)
|
{
|
try {
|
if (proj != null && proj.Kind == "{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}")
|
return IsQMakeProject(proj.Object as VCProject);
|
} catch { }
|
return false;
|
}
|
|
public static void CleanupQMakeDependencies(Project project)
|
{
|
var vcPro = (VCProject)project.Object;
|
// clean up qmake mess
|
var rxp1 = new Regex("\\bQt\\w+d?5?\\.lib\\b");
|
var rxp2 = new Regex("\\bQAx\\w+\\.lib\\b");
|
var rxp3 = new Regex("\\bqtmaind?.lib\\b");
|
var rxp4 = new Regex("\\benginiod?.lib\\b");
|
foreach (VCConfiguration cfg in (IVCCollection)vcPro.Configurations) {
|
var linker = (VCLinkerTool)((IVCCollection)cfg.Tools).Item("VCLinkerTool");
|
if (linker == null || linker.AdditionalDependencies == null)
|
continue;
|
var linkerWrapper = new LinkerToolWrapper(linker);
|
var deps = linkerWrapper.AdditionalDependencies;
|
var newDeps = new List<string>();
|
foreach (var lib in deps) {
|
var m1 = rxp1.Match(lib);
|
var m2 = rxp2.Match(lib);
|
var m3 = rxp3.Match(lib);
|
var m4 = rxp4.Match(lib);
|
if (m1.Success)
|
newDeps.Add(m1.ToString());
|
else if (m2.Success)
|
newDeps.Add(m2.ToString());
|
else if (m3.Success)
|
newDeps.Add(m3.ToString());
|
else if (m4.Success)
|
newDeps.Add(m4.ToString());
|
else
|
newDeps.Add(lib);
|
}
|
// Remove Duplicates
|
var uniques = new Dictionary<string, int>();
|
foreach (var dep in newDeps)
|
uniques[dep] = 1;
|
var uniqueList = new List<string>(uniques.Keys);
|
linkerWrapper.AdditionalDependencies = uniqueList;
|
}
|
}
|
|
/// <summary>
|
/// Deletes the file's directory if it is empty (not deleting the file itself so it must
|
/// have been deleted before) and every empty parent directory until the first, non-empty
|
/// directory is found.
|
/// </summary>
|
/// <param term='file'>Start point of the deletion</param>
|
public static void DeleteEmptyParentDirs(VCFile file)
|
{
|
var dir = file.FullPath.Remove(file.FullPath.LastIndexOf(Path.DirectorySeparatorChar));
|
DeleteEmptyParentDirs(dir);
|
}
|
|
/// <summary>
|
/// Deletes the directory if it is empty and every empty parent directory until the first,
|
/// non-empty directory is found.
|
/// </summary>
|
/// <param term='file'>Start point of the deletion</param>
|
public static void DeleteEmptyParentDirs(string directory)
|
{
|
var dirInfo = new DirectoryInfo(directory);
|
while (dirInfo.Exists && dirInfo.GetFileSystemInfos().Length == 0) {
|
var tmp = dirInfo;
|
dirInfo = dirInfo.Parent;
|
tmp.Delete();
|
}
|
}
|
|
public static bool HasQObjectDeclaration(VCFile file)
|
{
|
return CxxFileContainsNotCommented(file,
|
new[]
|
{
|
"Q_OBJECT",
|
"Q_GADGET",
|
"Q_NAMESPACE"
|
},
|
StringComparison.Ordinal, true);
|
}
|
|
public static bool CxxFileContainsNotCommented(VCFile file, string str,
|
StringComparison comparisonType, bool suppressStrings)
|
{
|
return CxxFileContainsNotCommented(file, new[] { str }, comparisonType, suppressStrings);
|
}
|
|
public static bool CxxFileContainsNotCommented(VCFile file, string[] searchStrings,
|
StringComparison comparisonType, bool suppressStrings)
|
{
|
// Small optimization, we first read the whole content as a string and look for the
|
// search strings. Once we found at least one, ...
|
bool found = false;
|
var content = string.Empty;
|
try {
|
using (StreamReader sr = new StreamReader(file.FullPath))
|
content = sr.ReadToEnd();
|
|
foreach (var key in searchStrings) {
|
if (content.IndexOf(key, comparisonType) >= 0) {
|
found = true;
|
break;
|
}
|
}
|
} catch { }
|
|
if (!found)
|
return false;
|
|
// ... we will start parsing the file again to see if the actual string is commented
|
// or not. The combination of string.IndexOf(...) and string.Split(...) seems to be
|
// way faster then reading the file line by line.
|
found = false;
|
CxxStreamReader cxxSr = null;
|
try {
|
cxxSr = new CxxStreamReader(content.Split(new[] { "\n", "\r\n" },
|
StringSplitOptions.RemoveEmptyEntries));
|
string strLine;
|
while (!found && (strLine = cxxSr.ReadLine(suppressStrings)) != null) {
|
foreach (var str in searchStrings) {
|
if (strLine.IndexOf(str, comparisonType) != -1) {
|
found = true;
|
break;
|
}
|
}
|
}
|
cxxSr.Close();
|
} catch (Exception) {
|
if (cxxSr != null)
|
cxxSr.Close();
|
}
|
return found;
|
}
|
|
public static void SetEnvironmentVariableEx(string environmentVariable, string variableValue)
|
{
|
try {
|
Environment.SetEnvironmentVariable(environmentVariable, variableValue);
|
} catch {
|
throw new QtVSException(SR.GetString("HelperFunctions_CannotWriteEnvQTDIR"));
|
}
|
}
|
|
public static string ChangePathFormat(string path)
|
{
|
return path.Replace('\\', '/');
|
}
|
|
public static string RemoveFileNameExtension(FileInfo fi)
|
{
|
var lastIndex = fi.Name.LastIndexOf(fi.Extension, StringComparison.Ordinal);
|
return fi.Name.Remove(lastIndex, fi.Extension.Length);
|
}
|
|
public static bool IsInFilter(VCFile vcfile, FakeFilter filter)
|
{
|
var item = (VCProjectItem)vcfile;
|
|
while ((item.Parent != null) && (item.Kind != "VCProject")) {
|
item = (VCProjectItem)item.Parent;
|
|
if (item.Kind == "VCFilter") {
|
var f = (VCFilter)item;
|
if (f.UniqueIdentifier != null
|
&& f.UniqueIdentifier.ToLower() == filter.UniqueIdentifier.ToLower())
|
return true;
|
}
|
}
|
return false;
|
}
|
|
public static void CollapseFilter(UIHierarchyItem item, UIHierarchy hierarchy, string nodeToCollapseFilter)
|
{
|
if (string.IsNullOrEmpty(nodeToCollapseFilter))
|
return;
|
|
foreach (UIHierarchyItem innerItem in item.UIHierarchyItems) {
|
if (innerItem.Name == nodeToCollapseFilter)
|
CollapseFilter(innerItem, hierarchy);
|
else if (innerItem.UIHierarchyItems.Count > 0)
|
CollapseFilter(innerItem, hierarchy, nodeToCollapseFilter);
|
}
|
}
|
|
public static void CollapseFilter(UIHierarchyItem item, UIHierarchy hierarchy)
|
{
|
var subItems = item.UIHierarchyItems;
|
if (subItems != null) {
|
foreach (UIHierarchyItem innerItem in subItems) {
|
if (innerItem.UIHierarchyItems.Count > 0) {
|
CollapseFilter(innerItem, hierarchy);
|
|
if (innerItem.UIHierarchyItems.Expanded) {
|
innerItem.UIHierarchyItems.Expanded = false;
|
if (innerItem.UIHierarchyItems.Expanded) {
|
innerItem.Select(vsUISelectionType.vsUISelectionTypeSelect);
|
hierarchy.DoDefaultAction();
|
}
|
}
|
}
|
}
|
}
|
if (item.UIHierarchyItems.Expanded) {
|
item.UIHierarchyItems.Expanded = false;
|
if (item.UIHierarchyItems.Expanded) {
|
item.Select(vsUISelectionType.vsUISelectionTypeSelect);
|
hierarchy.DoDefaultAction();
|
}
|
}
|
}
|
|
// returns true if some exception occurs
|
public static bool IsGenerated(VCFile vcfile)
|
{
|
try {
|
return IsInFilter(vcfile, Filters.GeneratedFiles());
|
} catch (Exception e) {
|
MessageBox.Show(e.ToString());
|
return true;
|
}
|
}
|
|
// returns false if some exception occurs
|
public static bool IsResource(VCFile vcfile)
|
{
|
try {
|
return IsInFilter(vcfile, Filters.ResourceFiles());
|
} catch (Exception) {
|
return false;
|
}
|
}
|
|
public static List<string> GetProjectFiles(Project pro, FilesToList filter)
|
{
|
var fileList = new List<string>();
|
|
VCProject vcpro;
|
try {
|
vcpro = (VCProject)pro.Object;
|
} catch (Exception e) {
|
Messages.DisplayErrorMessage(e);
|
return null;
|
}
|
|
var configurationName = pro.ConfigurationManager.ActiveConfiguration.ConfigurationName;
|
|
foreach (VCFile vcfile in (IVCCollection)vcpro.Files) {
|
// Why project files are also returned?
|
if (vcfile.ItemName.EndsWith(".vcxproj.filters", StringComparison.Ordinal))
|
continue;
|
var excluded = false;
|
var fileConfigurations = (IVCCollection)vcfile.FileConfigurations;
|
foreach (VCFileConfiguration config in fileConfigurations) {
|
if (config.ExcludedFromBuild && config.MatchName(configurationName, false)) {
|
excluded = true;
|
break;
|
}
|
}
|
|
if (excluded)
|
continue;
|
|
// can be in any filter
|
if (IsTranslationFile(vcfile.Name) && (filter == FilesToList.FL_Translation))
|
fileList.Add(ChangePathFormat(vcfile.RelativePath));
|
|
// can also be in any filter
|
if (IsWinRCFile(vcfile.Name) && (filter == FilesToList.FL_WinResource))
|
fileList.Add(ChangePathFormat(vcfile.RelativePath));
|
|
if (IsGenerated(vcfile)) {
|
if (filter == FilesToList.FL_Generated)
|
fileList.Add(ChangePathFormat(vcfile.RelativePath));
|
continue;
|
}
|
|
if (IsResource(vcfile)) {
|
if (filter == FilesToList.FL_Resources)
|
fileList.Add(ChangePathFormat(vcfile.RelativePath));
|
continue;
|
}
|
|
switch (filter) {
|
case FilesToList.FL_UiFiles: // form files
|
if (IsUicFile(vcfile.Name))
|
fileList.Add(ChangePathFormat(vcfile.RelativePath));
|
break;
|
case FilesToList.FL_HFiles:
|
if (IsHeaderFile(vcfile.Name))
|
fileList.Add(ChangePathFormat(vcfile.RelativePath));
|
break;
|
case FilesToList.FL_CppFiles:
|
if (IsSourceFile(vcfile.Name))
|
fileList.Add(ChangePathFormat(vcfile.RelativePath));
|
break;
|
case FilesToList.FL_QmlFiles:
|
if (IsQmlFile(vcfile.Name))
|
fileList.Add(ChangePathFormat(vcfile.RelativePath));
|
break;
|
}
|
}
|
|
return fileList;
|
}
|
|
/// <summary>
|
/// Removes a file reference from the project and moves the file to the "Deleted" folder.
|
/// </summary>
|
/// <param name="vcpro"></param>
|
/// <param name="fileName"></param>
|
public static void RemoveFileInProject(VCProject vcpro, string fileName)
|
{
|
var qtProj = QtProject.Create(vcpro);
|
var fi = new FileInfo(fileName);
|
|
foreach (VCFile vcfile in (IVCCollection)vcpro.Files) {
|
if (vcfile.FullPath.ToLower() == fi.FullName.ToLower()) {
|
vcpro.RemoveFile(vcfile);
|
qtProj.MoveFileToDeletedFolder(vcfile);
|
}
|
}
|
}
|
|
public static Project GetSelectedProject(DTE dteObject)
|
{
|
if (dteObject == null)
|
return null;
|
Array prjs = null;
|
try {
|
prjs = (Array)dteObject.ActiveSolutionProjects;
|
} catch {
|
// When VS2010 is started from the command line,
|
// we may catch a "Unspecified error" here.
|
}
|
if (prjs == null || prjs.Length < 1)
|
return null;
|
|
// don't handle multiple selection... use the first one
|
if (prjs.GetValue(0) is Project)
|
return (Project)prjs.GetValue(0);
|
return null;
|
}
|
|
public static Project GetActiveDocumentProject(DTE dteObject)
|
{
|
if (dteObject == null)
|
return null;
|
var doc = dteObject.ActiveDocument;
|
if (doc == null)
|
return null;
|
|
if (doc.ProjectItem == null)
|
return null;
|
|
return doc.ProjectItem.ContainingProject;
|
}
|
|
public static Project GetSingleProjectInSolution(DTE dteObject)
|
{
|
var projectList = ProjectsInSolution(dteObject);
|
if (dteObject == null || dteObject.Solution == null ||
|
projectList.Count != 1)
|
return null; // no way to know which one to select
|
|
return projectList[0];
|
}
|
|
/// <summary>
|
/// Returns the the current selected Qt Project. If not project
|
/// is selected or if the selected project is not a Qt project
|
/// this function returns null.
|
/// </summary>
|
public static Project GetSelectedQtProject(DTE dteObject)
|
{
|
// can happen sometimes shortly after starting VS
|
if (dteObject == null || dteObject.Solution == null
|
|| ProjectsInSolution(dteObject).Count == 0)
|
return null;
|
|
Project pro;
|
|
if ((pro = GetSelectedProject(dteObject)) == null) {
|
if ((pro = GetSingleProjectInSolution(dteObject)) == null)
|
pro = GetActiveDocumentProject(dteObject);
|
}
|
return IsQtProject(pro) ? pro : null;
|
}
|
|
public static VCFile[] GetSelectedFiles(DTE dteObject)
|
{
|
if (GetSelectedQtProject(dteObject) == null)
|
return null;
|
|
if (dteObject.SelectedItems.Count <= 0)
|
return null;
|
|
var items = dteObject.SelectedItems;
|
|
var files = new VCFile[items.Count + 1];
|
for (var i = 1; i <= items.Count; ++i) {
|
var item = items.Item(i);
|
if (item.ProjectItem == null)
|
continue;
|
|
VCProjectItem vcitem;
|
try {
|
vcitem = (VCProjectItem)item.ProjectItem.Object;
|
} catch (Exception) {
|
return null;
|
}
|
|
if (vcitem.Kind == "VCFile")
|
files[i - 1] = (VCFile)vcitem;
|
}
|
files[items.Count] = null;
|
return files;
|
}
|
|
public static Image GetSharedImage(string name)
|
{
|
Image image = null;
|
var a = Assembly.GetExecutingAssembly();
|
using (var imgStream = a.GetManifestResourceStream(name)) {
|
if (imgStream != null)
|
image = Image.FromStream(imgStream);
|
}
|
return image;
|
}
|
|
public static RccOptions ParseRccOptions(string cmdLine, VCFile qrcFile)
|
{
|
var pro = VCProjectToProject((VCProject)qrcFile.project);
|
|
var rccOpts = new RccOptions(pro, qrcFile);
|
|
if (cmdLine.Length > 0) {
|
var cmdSplit = cmdLine.Split(' ', '\t');
|
for (var i = 0; i < cmdSplit.Length; ++i) {
|
var lowercmdSplit = cmdSplit[i].ToLower();
|
if (lowercmdSplit.Equals("-threshold")) {
|
rccOpts.CompressFiles = true;
|
rccOpts.CompressThreshold = int.Parse(cmdSplit[i + 1]);
|
} else if (lowercmdSplit.Equals("-compress")) {
|
rccOpts.CompressFiles = true;
|
rccOpts.CompressLevel = int.Parse(cmdSplit[i + 1]);
|
}
|
}
|
}
|
return rccOpts;
|
}
|
|
public static Project VCProjectToProject(VCProject vcproj)
|
{
|
return (Project)vcproj.Object;
|
}
|
|
public static List<Project> ProjectsInSolution(DTE dteObject)
|
{
|
var projects = new List<Project>();
|
var solution = dteObject.Solution;
|
if (solution != null) {
|
var c = solution.Count;
|
for (var i = 1; i <= c; ++i) {
|
try {
|
var prj = solution.Projects.Item(i);
|
if (prj == null)
|
continue;
|
addSubProjects(prj, ref projects);
|
} catch {
|
// Ignore this exception... maybe the next project is ok.
|
// This happens for example for Intel VTune projects.
|
}
|
}
|
}
|
return projects;
|
}
|
|
private static void addSubProjects(Project prj, ref List<Project> projects)
|
{
|
// If the actual object of the project is null then the project was probably unloaded.
|
if (prj.Object == null)
|
return;
|
|
if (prj.ConfigurationManager != null &&
|
// Is this a Visual C++ project?
|
prj.Kind == "{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") {
|
projects.Add(prj);
|
} else {
|
// In this case, prj is a solution folder
|
addSubProjects(prj.ProjectItems, ref projects);
|
}
|
}
|
|
private static void addSubProjects(ProjectItems subItems, ref List<Project> projects)
|
{
|
if (subItems == null)
|
return;
|
|
foreach (ProjectItem item in subItems) {
|
Project subprj = null;
|
try {
|
subprj = item.SubProject;
|
} catch {
|
// The property "SubProject" might not be implemented.
|
// This is the case for Intel Fortran projects. (QTBUG-11567)
|
}
|
if (subprj != null)
|
addSubProjects(subprj, ref projects);
|
}
|
}
|
|
public static int GetMaximumCommandLineLength()
|
{
|
var epsilon = 10; // just to be sure :)
|
var os = Environment.OSVersion;
|
if (os.Version.Major >= 6 ||
|
(os.Version.Major == 5 && os.Version.Minor >= 1))
|
return 8191 - epsilon; // Windows XP and above
|
return 2047 - epsilon;
|
}
|
|
/// <summary>
|
/// Translates the machine type given as command line argument to the linker
|
/// to the internal enum type VCProjectEngine.machineTypeOption.
|
/// </summary>
|
public static machineTypeOption TranslateMachineType(string cmdLineMachine)
|
{
|
switch (cmdLineMachine.ToUpper()) {
|
case "AM33":
|
return machineTypeOption.machineAM33;
|
case "X64":
|
return machineTypeOption.machineAMD64;
|
case "ARM":
|
return machineTypeOption.machineARM;
|
case "EBC":
|
return machineTypeOption.machineEBC;
|
case "IA-64":
|
return machineTypeOption.machineIA64;
|
case "M32R":
|
return machineTypeOption.machineM32R;
|
case "MIPS":
|
return machineTypeOption.machineMIPS;
|
case "MIPS16":
|
return machineTypeOption.machineMIPS16;
|
case "MIPSFPU":
|
return machineTypeOption.machineMIPSFPU;
|
case "MIPSFPU16":
|
return machineTypeOption.machineMIPSFPU16;
|
case "MIPS41XX":
|
return machineTypeOption.machineMIPSR41XX;
|
case "SH3":
|
return machineTypeOption.machineSH3;
|
case "SH3DSP":
|
return machineTypeOption.machineSH3DSP;
|
case "SH4":
|
return machineTypeOption.machineSH4;
|
case "SH5":
|
return machineTypeOption.machineSH5;
|
case "THUMB":
|
return machineTypeOption.machineTHUMB;
|
case "X86":
|
return machineTypeOption.machineX86;
|
default:
|
return machineTypeOption.machineNotSet;
|
}
|
}
|
|
public static bool ArraysEqual(Array array1, Array array2)
|
{
|
if (array1 == array2)
|
return true;
|
|
if (array1 == null || array2 == null)
|
return false;
|
|
if (array1.Length != array2.Length)
|
return false;
|
|
for (var i = 0; i < array1.Length; i++) {
|
if (!Equals(array1.GetValue(i), array2.GetValue(i)))
|
return false;
|
}
|
return true;
|
}
|
|
public static string FindFileInPATH(string fileName)
|
{
|
var envPATH = Environment.ExpandEnvironmentVariables("%PATH%");
|
var directories = envPATH.Split(';');
|
foreach (var directory in directories) {
|
var fullFilePath = directory;
|
if (!fullFilePath.EndsWith("\\", StringComparison.Ordinal))
|
fullFilePath += '\\';
|
fullFilePath += fileName;
|
if (File.Exists(fullFilePath))
|
return fullFilePath;
|
}
|
return null;
|
}
|
|
/// <summary>
|
/// This method copies the specified directory and all its child directories and files to
|
/// the specified destination. The destination directory is created if it does not exist.
|
/// </summary>
|
public static void CopyDirectory(string directory, string targetPath)
|
{
|
var sourceDir = new DirectoryInfo(directory);
|
if (!sourceDir.Exists)
|
return;
|
|
try {
|
if (!Directory.Exists(targetPath))
|
Directory.CreateDirectory(targetPath);
|
|
var files = sourceDir.GetFiles();
|
foreach (var file in files) {
|
try {
|
file.CopyTo(Path.Combine(targetPath, file.Name), true);
|
} catch { }
|
}
|
} catch { }
|
|
var subDirs = sourceDir.GetDirectories();
|
foreach (var subDir in subDirs)
|
CopyDirectory(subDir.FullName, Path.Combine(targetPath, subDir.Name));
|
}
|
|
/// <summary>
|
/// Performs an in-place expansion of MS Build properties in the form $(PropertyName)
|
/// and project item metadata in the form %(MetadataName).<para/>
|
/// Returns: 'true' if expansion was successful, 'false' otherwise<para/>
|
/// <paramref name="stringToExpand"/>: The string containing properties and/or metadata to
|
/// expand. This string is passed by ref and expansion is performed in-place.<para/>
|
/// <paramref name="project"/>: Current project.<para/>
|
/// <paramref name="configName"/>: Name of selected configuration (e.g. "Debug").<para/>
|
/// <paramref name="platformName"/>: Name of selected platform (e.g. "x64").<para/>
|
/// <paramref name="filePath"/>(optional): Evaluation context.<para/>
|
/// </summary>
|
public static bool ExpandString(
|
ref string stringToExpand,
|
EnvDTE.Project project,
|
string configName,
|
string platformName,
|
string filePath = null)
|
{
|
if (project == null
|
|| string.IsNullOrEmpty(configName)
|
|| string.IsNullOrEmpty(platformName))
|
return false;
|
|
var vcProject = project.Object as VCProject;
|
|
if (filePath == null) {
|
var vcConfig = (from VCConfiguration _config
|
in (IVCCollection)vcProject.Configurations
|
where _config.Name == configName + "|" + platformName
|
select _config).FirstOrDefault();
|
return ExpandString(ref stringToExpand, vcConfig);
|
} else {
|
var vcFile = (from VCFile _file in (IVCCollection)vcProject.Files
|
where _file.FullPath == filePath
|
select _file).FirstOrDefault();
|
if (vcFile == null)
|
return false;
|
|
var vcFileConfig = (from VCFileConfiguration _config
|
in (IVCCollection)vcFile.FileConfigurations
|
where _config.Name == configName + "|" + platformName
|
select _config).FirstOrDefault();
|
return ExpandString(ref stringToExpand, vcFileConfig);
|
}
|
}
|
|
/// <summary>
|
/// Performs an in-place expansion of MS Build properties in the form $(PropertyName)
|
/// and project item metadata in the form %(MetadataName).<para/>
|
/// Returns: 'true' if expansion was successful, 'false' otherwise<para/>
|
/// <paramref name="stringToExpand"/>: The string containing properties and/or metadata to
|
/// expand. This string is passed by ref and expansion is performed in-place.<para/>
|
/// <paramref name="config"/>: Either a VCConfiguration or VCFileConfiguration object to
|
/// use as provider of property expansion (through Evaluate()). Cannot be null.<para/>
|
/// </summary>
|
public static bool ExpandString(
|
ref string stringToExpand,
|
object config)
|
{
|
if (config == null)
|
return false;
|
|
/* try property expansion through VCConfiguration.Evaluate()
|
* or VCFileConfiguration.Evaluate() */
|
string expanded = stringToExpand;
|
VCProject vcProj = null;
|
VCFile vcFile = null;
|
string configName = "", platformName = "";
|
var vcConfig = config as VCConfiguration;
|
if (vcConfig != null) {
|
vcProj = vcConfig.project as VCProject;
|
configName = vcConfig.ConfigurationName;
|
var vcPlatform = vcConfig.Platform as VCPlatform;
|
if (vcPlatform != null)
|
platformName = vcPlatform.Name;
|
try {
|
expanded = vcConfig.Evaluate(expanded);
|
} catch { }
|
} else {
|
var vcFileConfig = config as VCFileConfiguration;
|
if (vcFileConfig == null)
|
return false;
|
vcFile = vcFileConfig.File as VCFile;
|
if (vcFile != null)
|
vcProj = vcFile.project as VCProject;
|
var vcProjConfig = vcFileConfig.ProjectConfiguration as VCConfiguration;
|
if (vcProjConfig != null) {
|
configName = vcProjConfig.ConfigurationName;
|
var vcPlatform = vcProjConfig.Platform as VCPlatform;
|
if (vcPlatform != null)
|
platformName = vcPlatform.Name;
|
}
|
try {
|
expanded = vcFileConfig.Evaluate(expanded);
|
} catch { }
|
}
|
|
/* fail-safe */
|
foreach (Match propNameMatch in Regex.Matches(expanded, @"\$\(([^\)]+)\)")) {
|
string propName = propNameMatch.Groups[1].Value;
|
string propValue = "";
|
switch (propName) {
|
case "Configuration":
|
case "ConfigurationName":
|
if (string.IsNullOrEmpty(configName))
|
return false;
|
propValue = configName;
|
break;
|
case "Platform":
|
case "PlatformName":
|
if (string.IsNullOrEmpty(platformName))
|
return false;
|
propValue = platformName;
|
break;
|
default:
|
return false;
|
}
|
expanded = expanded.Replace(string.Format("$({0})", propName), propValue);
|
}
|
|
/* because item metadata is not expanded in Evaluate() */
|
foreach (Match metaNameMatch in Regex.Matches(expanded, @"\%\(([^\)]+)\)")) {
|
string metaName = metaNameMatch.Groups[1].Value;
|
string metaValue = "";
|
switch (metaName) {
|
case "FullPath":
|
if (vcFile == null)
|
return false;
|
metaValue = vcFile.FullPath;
|
break;
|
case "RootDir":
|
if (vcFile == null)
|
return false;
|
metaValue = Path.GetPathRoot(vcFile.FullPath);
|
break;
|
case "Filename":
|
if (vcFile == null)
|
return false;
|
metaValue = Path.GetFileNameWithoutExtension(vcFile.FullPath);
|
break;
|
case "Extension":
|
if (vcFile == null)
|
return false;
|
metaValue = Path.GetExtension(vcFile.FullPath);
|
break;
|
case "RelativeDir":
|
if (vcProj == null || vcFile == null)
|
return false;
|
metaValue = Path.GetDirectoryName(GetRelativePath(
|
Path.GetDirectoryName(vcProj.ProjectFile),
|
vcFile.FullPath));
|
if (!metaValue.EndsWith("\\"))
|
metaValue += "\\";
|
if (metaValue.StartsWith(".\\"))
|
metaValue = metaValue.Substring(2);
|
break;
|
case "Directory":
|
if (vcFile == null)
|
return false;
|
metaValue = Path.GetDirectoryName(GetRelativePath(
|
Path.GetPathRoot(vcFile.FullPath),
|
vcFile.FullPath));
|
if (!metaValue.EndsWith("\\"))
|
metaValue += "\\";
|
if (metaValue.StartsWith(".\\"))
|
metaValue = metaValue.Substring(2);
|
break;
|
case "Identity":
|
if (vcProj == null || vcFile == null)
|
return false;
|
metaValue = GetRelativePath(
|
Path.GetDirectoryName(vcProj.ProjectFile),
|
vcFile.FullPath);
|
if (metaValue.StartsWith(".\\"))
|
metaValue = metaValue.Substring(2);
|
break;
|
case "RecursiveDir":
|
case "ModifiedTime":
|
case "CreatedTime":
|
case "AccessedTime":
|
return false;
|
default:
|
var vcFileConfig = config as VCFileConfiguration;
|
if (vcFileConfig == null)
|
return false;
|
var propStoreTool = vcFileConfig.Tool as IVCRulePropertyStorage;
|
if (propStoreTool == null)
|
return false;
|
try {
|
metaValue = propStoreTool.GetEvaluatedPropertyValue(metaName);
|
} catch {
|
return false;
|
}
|
break;
|
}
|
expanded = expanded.Replace(string.Format("%({0})", metaName), metaValue);
|
}
|
|
stringToExpand = expanded;
|
return true;
|
}
|
|
private static string GetRegistrySoftwareString(string subKeyName, string valueName)
|
{
|
var keyName = new StringBuilder();
|
keyName.Append(@"SOFTWARE\");
|
if (System.Environment.Is64BitOperatingSystem && IntPtr.Size == 4)
|
keyName.Append(@"WOW6432Node\");
|
keyName.Append(subKeyName);
|
|
try {
|
using (var key = Registry.LocalMachine.OpenSubKey(keyName.ToString(), false)) {
|
if (key == null)
|
return ""; //key not found
|
|
RegistryValueKind valueKind = key.GetValueKind(valueName);
|
if (valueKind != RegistryValueKind.String
|
&& valueKind != RegistryValueKind.ExpandString) {
|
return ""; //wrong value kind
|
}
|
|
Object objValue = key.GetValue(valueName);
|
if (objValue == null)
|
return ""; //error getting value
|
|
return objValue.ToString();
|
}
|
} catch {
|
return "";
|
}
|
}
|
|
public static string GetWindows10SDKVersion()
|
{
|
#if VS2019 || VS2022
|
// In Visual Studio 2019: WindowsTargetPlatformVersion=10.0
|
// will be treated as "use latest installed Windows 10 SDK".
|
// https://developercommunity.visualstudio.com/comments/407752/view.html
|
return "10.0";
|
#else
|
string versionWin10SDK = HelperFunctions.GetRegistrySoftwareString(
|
@"Microsoft\Microsoft SDKs\Windows\v10.0", "ProductVersion");
|
if (string.IsNullOrEmpty(versionWin10SDK))
|
return versionWin10SDK;
|
while (versionWin10SDK.Split(new char[] { '.' }).Length < 4)
|
versionWin10SDK = versionWin10SDK + ".0";
|
return versionWin10SDK;
|
#endif
|
}
|
|
static string _VCPath;
|
public static string VCPath
|
{
|
set { _VCPath = value; }
|
get
|
{
|
if (!string.IsNullOrEmpty(_VCPath))
|
return _VCPath;
|
else
|
return GetVCPathFromRegistry();
|
}
|
}
|
|
private static string GetVCPathFromRegistry()
|
{
|
#if VS2022
|
Debug.Assert(false, "VCPath for VS2022 is not available through the registry");
|
string vcPath = string.Empty;
|
#elif VS2019
|
Debug.Assert(false, "VCPath for VS2019 is not available through the registry");
|
string vcPath = string.Empty;
|
#elif VS2017
|
string vsPath = GetRegistrySoftwareString(@"Microsoft\VisualStudio\SxS\VS7", "15.0");
|
if (string.IsNullOrEmpty(vsPath))
|
return "";
|
string vcPath = Path.Combine(vsPath, "VC");
|
#endif
|
return vcPath;
|
}
|
|
public static bool SetVCVars(ProcessStartInfo startInfo)
|
{
|
return SetVCVars(null, startInfo);
|
}
|
|
public static bool SetVCVars(VersionInformation VersionInfo, ProcessStartInfo startInfo)
|
{
|
if (VersionInfo == null) {
|
VersionInfo = QtVersionManager.The().GetVersionInfo(
|
QtVersionManager.The().GetDefaultVersion());
|
}
|
bool isOS64Bit = System.Environment.Is64BitOperatingSystem;
|
bool isQt64Bit = VersionInfo.is64Bit();
|
|
string vcPath = VCPath;
|
if (vcPath == "")
|
return false;
|
|
string comspecPath = Environment.GetEnvironmentVariable("COMSPEC");
|
string vcVarsCmd = "";
|
string vcVarsArg = "";
|
if (isOS64Bit && isQt64Bit)
|
vcVarsCmd = Path.Combine(vcPath, @"Auxiliary\Build\vcvars64.bat");
|
else if (!isOS64Bit && !isQt64Bit)
|
vcVarsCmd = Path.Combine(vcPath, @"Auxiliary\Build\vcvars32.bat");
|
else if (isOS64Bit && !isQt64Bit)
|
vcVarsCmd = Path.Combine(vcPath, @"Auxiliary\Build\vcvarsamd64_x86.bat");
|
else if (!isOS64Bit && isQt64Bit)
|
vcVarsCmd = Path.Combine(vcPath, @"Auxiliary\Build\vcvarsx86_amd64.bat");
|
|
Messages.Print($"vcvars: {vcVarsCmd}");
|
|
const string markSTX = ":@:@:@";
|
const string markEOL = ":#:#:#";
|
string command =
|
string.Format("/c \"{0}\" {1} && echo {2} && set", vcVarsCmd, vcVarsArg, markSTX);
|
var vcVarsStartInfo = new ProcessStartInfo(comspecPath, command);
|
vcVarsStartInfo.CreateNoWindow = true;
|
vcVarsStartInfo.UseShellExecute = false;
|
vcVarsStartInfo.RedirectStandardError = true;
|
vcVarsStartInfo.RedirectStandardOutput = true;
|
|
var process = Process.Start(vcVarsStartInfo);
|
StringBuilder stdOut = new StringBuilder();
|
|
process.OutputDataReceived += (object sender, DataReceivedEventArgs e) =>
|
stdOut.AppendFormat("{0}\n{1}\n", e.Data, markEOL);
|
process.BeginOutputReadLine();
|
|
process.WaitForExit();
|
bool ok = (process.ExitCode == 0);
|
process.Close();
|
if (!ok)
|
return false;
|
|
SortedDictionary<string, List<string>> vcVars =
|
new SortedDictionary<string, List<string>>();
|
string[] split =
|
stdOut.ToString().Split(new string[] { "\n", "=", ";" }, StringSplitOptions.None);
|
int i = 0;
|
for (; i < split.Length && split[i].Trim() != markSTX; i++) {
|
//Skip to start of data
|
}
|
i++; //Advance to next item
|
for (; i < split.Length && split[i].Trim() != markEOL; i++) {
|
//Skip to end of line
|
}
|
i++; //Advance to next item
|
for (; i < split.Length; i++) {
|
//Process first item (variable name)
|
string key = split[i].ToUpper().Trim();
|
i++; //Advance to next item
|
List<string> vcVarValue = vcVars[key] = new List<string>();
|
for (; i < split.Length && split[i].Trim() != markEOL; i++) {
|
//Process items up to end of line (variable value(s))
|
vcVarValue.Add(split[i].Trim());
|
}
|
}
|
|
foreach (var vcVar in vcVars) {
|
if (vcVar.Value.Count == 1) {
|
startInfo.EnvironmentVariables[vcVar.Key] = vcVar.Value[0];
|
} else {
|
if (!startInfo.EnvironmentVariables.ContainsKey(vcVar.Key)) {
|
foreach (var vcVarValue in vcVar.Value) {
|
if (!string.IsNullOrWhiteSpace(vcVarValue)) {
|
startInfo.EnvironmentVariables[vcVar.Key] += vcVarValue + ";";
|
}
|
}
|
} else {
|
string[] startInfoVariableValues = startInfo.EnvironmentVariables[vcVar.Key]
|
.Split(new string[] { ";" }, StringSplitOptions.None);
|
foreach (var vcVarValue in vcVar.Value) {
|
if (!string.IsNullOrWhiteSpace(vcVarValue)
|
&& !startInfoVariableValues.Any(s => s.Trim().Equals(
|
vcVarValue,
|
StringComparison.OrdinalIgnoreCase))) {
|
if (!startInfo.EnvironmentVariables[vcVar.Key].EndsWith(";"))
|
startInfo.EnvironmentVariables[vcVar.Key] += ";";
|
startInfo.EnvironmentVariables[vcVar.Key] += vcVarValue + ";";
|
}
|
}
|
}
|
}
|
}
|
string envPath = startInfo.EnvironmentVariables["PATH"];
|
string clPath = envPath.Split(';')
|
.Select(path => Path.Combine(path, "cl.exe"))
|
.Where(pathToCl => File.Exists(pathToCl))
|
.FirstOrDefault();
|
Messages.Print($"cl: {clPath ?? "NOT FOUND"}");
|
|
return true;
|
}
|
|
/// <summary>
|
/// Rooted canonical path is the absolute path for the specified path string
|
/// (cf. Path.GetFullPath()) without a trailing path separator.
|
/// </summary>
|
static string RootedCanonicalPath(string path)
|
{
|
try {
|
return Path
|
.GetFullPath(path)
|
.TrimEnd(new char[] {
|
Path.DirectorySeparatorChar,
|
Path.AltDirectorySeparatorChar
|
});
|
} catch {
|
return "";
|
}
|
}
|
|
/// <summary>
|
/// If the given path is relative and a sub-path of the current directory, returns
|
/// a "relative canonical path", containing only the steps beyond the current directory.
|
/// Otherwise, returns the absolute ("rooted") canonical path.
|
/// </summary>
|
public static string CanonicalPath(string path)
|
{
|
string canonicalPath = RootedCanonicalPath(path);
|
if (!Path.IsPathRooted(path)) {
|
string currentCanonical = RootedCanonicalPath(".");
|
if (canonicalPath.StartsWith(currentCanonical,
|
StringComparison.InvariantCultureIgnoreCase)) {
|
return canonicalPath
|
.Substring(currentCanonical.Length)
|
.TrimStart(new char[] {
|
Path.DirectorySeparatorChar,
|
Path.AltDirectorySeparatorChar
|
});
|
} else {
|
return canonicalPath;
|
}
|
} else {
|
return canonicalPath;
|
}
|
}
|
|
public static bool PathEquals(string path1, string path2)
|
{
|
return (CanonicalPath(path1).Equals(CanonicalPath(path2),
|
StringComparison.InvariantCultureIgnoreCase));
|
}
|
|
public static bool PathIsRelativeTo(string path, string subPath)
|
{
|
return CanonicalPath(path).EndsWith(CanonicalPath(subPath),
|
StringComparison.InvariantCultureIgnoreCase);
|
}
|
|
public static string Unquote(string text)
|
{
|
text = text.Trim();
|
if (string.IsNullOrEmpty(text)
|
|| text.Length < 3
|
|| !text.StartsWith("\"")
|
|| !text.EndsWith("\"")) {
|
return text;
|
}
|
return text.Substring(1, text.Length - 2);
|
}
|
|
public static string NewProjectGuid()
|
{
|
return string.Format("{{{0}}}", Guid.NewGuid().ToString().ToUpper());
|
}
|
|
public static string SafePath(string path)
|
{
|
if (string.IsNullOrEmpty(path))
|
return null;
|
path = path.Replace("\"", "");
|
if (!path.Contains(' '))
|
return path;
|
if (path.EndsWith("\\"))
|
path += "\\";
|
return string.Format("\"{0}\"", path);
|
}
|
}
|
}
|
