private static async Task <SourceFile> createSourceFileAsync(string filePath, Configuration configuration, Project project)
{
try
{
await Instance.JoinableTaskFactory.SwitchToMainThreadAsync();
Debug.Assert(isVisualCppProjectKind(project.Kind));
VCProject vcProject = project.Object as VCProject;
VCConfiguration vcconfig = vcProject.ActiveConfiguration;
string toolSetName = ((dynamic)vcconfig).PlatformToolsetFriendlyName;
string projectDirectory = vcProject.ProjectDirectory;
string projectName = project.Name;
SourceFile sourceForAnalysis = null;
dynamic toolsCollection = vcconfig.Tools;
foreach (var tool in toolsCollection)
{
// Project-specific includes
if (implementsInterface(tool, "Microsoft.VisualStudio.VCProjectEngine.VCCLCompilerTool"))
{
if (sourceForAnalysis == null)
{
sourceForAnalysis = new SourceFile(filePath, projectDirectory, projectName, toolSetName);
}
string includes = tool.FullIncludePath;
string definitions = tool.PreprocessorDefinitions;
string macrosToUndefine = tool.UndefinePreprocessorDefinitions;
string[] includePaths = includes.Split(';');
for (int i = 0; i < includePaths.Length; ++i)
{
includePaths[i] = Environment.ExpandEnvironmentVariables(vcconfig.Evaluate(includePaths[i]));
}
;
sourceForAnalysis.addIncludePaths(includePaths);
sourceForAnalysis.addMacros(definitions.Split(';'));
sourceForAnalysis.addMacrosToUndefine(macrosToUndefine.Split(';'));
}
}
return(sourceForAnalysis);
}
catch (Exception ex)
{
DebugTracer.Trace(ex);
return(null);
}
}
private static async Task <SourceFile> createSourceFileAsync(string filePath, Configuration targetConfig, dynamic project)
{
// TODO:
//Debug.Assert(isVisualCppProject((object)project));
try
{
await Instance.JoinableTaskFactory.SwitchToMainThreadAsync();
var configurationName = targetConfig.ConfigurationName;
dynamic config = project.Configurations.Item(configurationName);
String toolSetName = config.PlatformToolsetShortName;
if (String.IsNullOrEmpty(toolSetName))
{
toolSetName = config.PlatformToolsetFriendlyName;
}
String projectDirectory = project.ProjectDirectory;
String projectName = project.Name;
SourceFile sourceForAnalysis = new SourceFile(filePath, projectDirectory, projectName, toolSetName);
dynamic toolsCollection = config.Tools;
foreach (var tool in toolsCollection)
{
// Project-specific includes
if (implementsInterface(tool, "Microsoft.VisualStudio.VCProjectEngine.VCCLCompilerTool"))
{
String includes = tool.FullIncludePath;
String definitions = tool.PreprocessorDefinitions;
String macrosToUndefine = tool.UndefinePreprocessorDefinitions;
String[] includePaths = includes.Split(';');
for (int i = 0; i < includePaths.Length; ++i)
{
includePaths[i] = Environment.ExpandEnvironmentVariables(config.Evaluate(includePaths[i]));
}
;
sourceForAnalysis.addIncludePaths(includePaths);
sourceForAnalysis.addMacros(definitions.Split(';'));
sourceForAnalysis.addMacrosToUndefine(macrosToUndefine.Split(';'));
break;
}
}
return(sourceForAnalysis);
}
catch (Exception ex)
{
DebugTracer.Trace(ex);
return(null);
}
}
public void abortThreadIfAny()
{
if (_thread != null)
{
try
{
_terminateThread = true;
_thread.Join();
}
catch (Exception ex)
{
DebugTracer.Trace(ex);
}
_thread = null;
}
}
SourceFile createSourceFile(string filePath, Configuration targetConfig, dynamic project)
{
Debug.Assert(isVisualCppProject((object)project));
try
{
var configurationName = targetConfig.ConfigurationName;
dynamic config = project.Configurations.Item(configurationName);
String toolSetName = config.PlatformToolsetShortName;
if (String.IsNullOrEmpty(toolSetName))
{
toolSetName = config.PlatformToolsetFriendlyName;
}
String projectDirectory = project.ProjectDirectory;
String projectName = project.Name;
SourceFile sourceForAnalysis = new SourceFile(filePath, projectDirectory, projectName, toolSetName);
dynamic toolsCollection = config.Tools;
foreach (var tool in toolsCollection)
{
// Project-specific includes
Type toolType = tool.GetType();
var compilerToolInterface = toolType.GetInterface("Microsoft.VisualStudio.VCProjectEngine.VCCLCompilerTool");
if (compilerToolInterface != null)
{
String includes = tool.FullIncludePath;
String definitions = tool.PreprocessorDefinitions;
String macrosToUndefine = tool.UndefinePreprocessorDefinitions;
String[] includePaths = includes.Split(';');
for (int i = 0; i < includePaths.Length; ++i)
{
includePaths[i] = config.Evaluate(includePaths[i]);
}
sourceForAnalysis.addIncludePaths(includePaths);
sourceForAnalysis.addMacros(definitions.Split(';'));
sourceForAnalysis.addMacrosToUndefine(macrosToUndefine.Split(';'));
break;
}
}
return(sourceForAnalysis);
}
catch (System.Exception ex)
{
DebugTracer.Trace(ex);
return(null);
}
}
private void startAnalyzerProcess(string analyzerExePath, string arguments)
{
System.Diagnostics.Process process = null;
try
{
Debug.Assert(!String.IsNullOrEmpty(analyzerExePath));
Debug.Assert(!String.IsNullOrEmpty(arguments));
process = new System.Diagnostics.Process();
process.StartInfo.FileName = analyzerExePath;
process.StartInfo.WorkingDirectory = Path.GetDirectoryName(analyzerExePath);
process.StartInfo.Arguments = arguments;
process.StartInfo.CreateNoWindow = true;
// Set UseShellExecute to false for output redirection.
process.StartInfo.UseShellExecute = false;
// Redirect the standard output of the command.
process.StartInfo.RedirectStandardOutput = true;
process.StartInfo.RedirectStandardError = true;
// Set our event handler to asynchronously read the sort output.
process.OutputDataReceived += new DataReceivedEventHandler(this.analyzerOutputHandler);
process.ErrorDataReceived += new DataReceivedEventHandler(this.analyzerOutputHandler);
_ = CPPCheckPluginPackage.AddTextToOutputWindowAsync("Starting analyzer with arguments: " + arguments + "\n");
var timer = Stopwatch.StartNew();
// Start the process.
process.Start();
try
{
process.PriorityClass = ProcessPriorityClass.Idle;
}
catch (System.InvalidOperationException)
{
}
onProgressUpdated(0);
// Start the asynchronous read of the sort output stream.
process.BeginOutputReadLine();
process.BeginErrorReadLine();
// Wait for analysis completion
while (!process.WaitForExit(500))
{
if (_terminateThread)
{
// finally block will run anyway and do the cleanup
return;
}
}
timer.Stop();
analysisFinished(arguments);
if (process.ExitCode != 0)
{
_ = CPPCheckPluginPackage.AddTextToOutputWindowAsync(analyzerExePath + " has exited with code " + process.ExitCode.ToString() + "\n");
}
else
{
double timeElapsed = Math.Round(timer.Elapsed.TotalSeconds, 3);
_ = CPPCheckPluginPackage.AddTextToOutputWindowAsync("Analysis completed in " + timeElapsed.ToString() + " seconds\n");
}
process.Close();
process = null;
}
catch (Exception ex)
{
DebugTracer.Trace(ex);
}
finally
{
onProgressUpdated(100);
if (process != null)
{
try
{
process.Kill();
}
catch (Exception ex)
{
DebugTracer.Trace(ex);
}
process.Dispose();
}
}
}
private void documentSaved(Document document)
{
if (document == null || document.Language != "C/C++")
{
return;
}
if (Properties.Settings.Default.CheckSavedFilesHasValue && Properties.Settings.Default.CheckSavedFiles == false)
{
return;
}
if (document.ActiveWindow == null)
{
// We get here when new files are being created and added to the project and
// then trying to obtain document.ProjectItem yields an exception. Will just skip this.
return;
}
try
{
dynamic project = document.ProjectItem.ContainingProject.Object;
if (!isVisualCppProject(project))
{
return;
}
Configuration currentConfig = null;
try { currentConfig = document.ProjectItem.ConfigurationManager.ActiveConfiguration; }
catch (Exception) { currentConfig = null; }
if (currentConfig == null)
{
MessageBox.Show("Cannot perform check - no valid configuration selected", "Cppcheck error");
return;
}
SourceFile sourceForAnalysis = createSourceFile(document.FullName, currentConfig, project);
if (sourceForAnalysis == null)
{
return;
}
if (!Properties.Settings.Default.CheckSavedFilesHasValue)
{
askCheckSavedFiles();
if (!Properties.Settings.Default.CheckSavedFiles)
{
return;
}
}
MainToolWindow.Instance.showIfWindowNotCreated();
MainToolWindow.Instance.ContentsType = ICodeAnalyzer.AnalysisType.DocumentSavedAnalysis;
runSavedFileAnalysis(sourceForAnalysis, currentConfig, _outputPane);
}
catch (System.Exception ex)
{
if (_outputPane != null)
{
_outputPane.Clear();
_outputPane.OutputString("Exception occurred in cppcheck add-in: " + ex.Message);
}
DebugTracer.Trace(ex);
}
}
private void documentSavedSync(Document document)
{
JoinableTaskFactory.Run(async() =>
{
await JoinableTaskFactory.SwitchToMainThreadAsync();
if (document == null || document.Language != "C/C++")
{
return;
}
if (Settings.Default.CheckSavedFilesHasValue && Settings.Default.CheckSavedFiles == false)
{
return;
}
if (document.ActiveWindow == null)
{
// We get here when new files are being created and added to the project and
// then trying to obtain document.ProjectItem yields an exception. Will just skip this.
return;
}
try
{
var kind = document.ProjectItem.ContainingProject.Kind;
if (!isVisualCppProjectKind(document.ProjectItem.ContainingProject.Kind))
{
return;
}
Configuration currentConfig = null;
try { currentConfig = document.ProjectItem.ConfigurationManager.ActiveConfiguration; }
catch (Exception) { currentConfig = null; }
if (currentConfig == null)
{
MessageBox.Show("Cannot perform check - no valid configuration selected", "Cppcheck error");
return;
}
//dynamic project = document.ProjectItem.ContainingProject.Object;
Project project = document.ProjectItem.ContainingProject;
SourceFile sourceForAnalysis = await createSourceFileAsync(document.FullName, currentConfig, project);
if (sourceForAnalysis == null)
{
return;
}
if (!Settings.Default.CheckSavedFilesHasValue)
{
askCheckSavedFiles();
if (!Settings.Default.CheckSavedFiles)
{
return;
}
}
MainToolWindow.Instance.showIfWindowNotCreated();
MainToolWindow.Instance.ContentsType = ICodeAnalyzer.AnalysisType.DocumentSavedAnalysis;
runSavedFileAnalysis(sourceForAnalysis, currentConfig);
}
catch (Exception ex)
{
if (_outputPane != null)
{
_outputPane.Clear();
_ = AddTextToOutputWindowAsync("Exception occurred in cppcheck add-in: " + ex.Message);
}
DebugTracer.Trace(ex);
}
});
}
private static async Task <SourceFile> createSourceFileAsync(ProjectItem item)
{
try
{
await Instance.JoinableTaskFactory.SwitchToMainThreadAsync();
Debug.Assert(isVisualCppProjectKind(item.ContainingProject.Kind));
VCFile vcFile = item.Object as VCFile;
VCProject vcProject = item.ContainingProject.Object as VCProject;
VCConfiguration vcconfig = vcProject.ActiveConfiguration;
VCFileConfiguration fileConfig = vcFile.FileConfigurations.Item(vcconfig.Name);
string toolSetName = ((dynamic)vcconfig).PlatformToolsetFriendlyName;
string projectDirectory = vcProject.ProjectDirectory;
string projectName = vcProject.Name;
SourceFile sourceForAnalysis = null;
if (item.FileCount > 0)
{
bool bInheritDefs = true, bInheritUndefs = true;
string[] includePaths = { };
// Do the file-level first in case it disables inheritance. Include files don't have file-level config.
if (implementsInterface(fileConfig.Tool, "Microsoft.VisualStudio.VCProjectEngine.VCCLCompilerTool"))
{
sourceForAnalysis = new SourceFile(item.FileNames[1], projectDirectory, projectName, toolSetName);
includePaths = fileConfig.Tool.FullIncludePath.Split(';');
// Other details may be gathered from the file, project or any inherited property sheets.
recursiveAddToolDetails(sourceForAnalysis, vcconfig, fileConfig.Tool, null, ref bInheritDefs, ref bInheritUndefs);
}
// Now get the full include path
VCCLCompilerTool projectTool = (VCCLCompilerTool)vcconfig.Tools.Item("VCCLCompilerTool");
if (projectTool != null && implementsInterface(projectTool, "Microsoft.VisualStudio.VCProjectEngine.VCCLCompilerTool"))
{
if (sourceForAnalysis == null)
{
sourceForAnalysis = new SourceFile(item.FileNames[1], projectDirectory, projectName, toolSetName);
includePaths = projectTool.FullIncludePath.Split(';');
}
// Take the full include path from file level, which is already fully resolved.
for (int i = 0; i < includePaths.Length; ++i)
{
includePaths[i] = Environment.ExpandEnvironmentVariables(vcconfig.Evaluate(includePaths[i]));
}
sourceForAnalysis.addIncludePaths(includePaths);
recursiveAddToolDetails(sourceForAnalysis, vcconfig, projectTool, vcconfig.PropertySheets, ref bInheritDefs, ref bInheritUndefs);
}
}
return(sourceForAnalysis);
}
catch (Exception ex)
{
DebugTracer.Trace(ex);
return(null);
}
}