Full Code of Caphyon/clang-power-tools for AI

Repository: Caphyon/clang-power-tools
Branch: master
Commit: 511648a27cf8
Files: 390
Total size: 1.5 MB

Directory structure:
gitextract_1cs8fm3_/

├── .gitattributes
├── .github/
│   └── workflows/
│       ├── Build-ClangPowerTools.yml
│       └── Run-ClangPowerTools-tests.yml
├── .gitignore
├── ClangPowerTools/
│   ├── Automation/
│   │   ├── full-llvm-update-instructions.md
│   │   ├── get-tidy-checks-and-format.ps1
│   │   ├── input_checks.txt
│   │   └── update_clang-format.ps1
│   ├── CPTReleases/
│   │   └── IncrementRevisionNumber.ps1
│   ├── ClangPowerTools/
│   │   ├── ClangPowerTools.csproj
│   │   ├── ClangPowerTools.csproj.bak
│   │   ├── ClangPowerTools.vsct
│   │   ├── ClangPowerToolsPackage.cs
│   │   ├── Key.snk
│   │   ├── Properties/
│   │   │   ├── AssemblyInfo.cs
│   │   │   ├── Resource.Designer.cs
│   │   │   └── Resource.resx
│   │   ├── Tooling/
│   │   │   └── v1/
│   │   │       ├── clang-build.ps1
│   │   │       └── psClang/
│   │   │           ├── get-header-references.ps1
│   │   │           ├── get-llvm-helper.ps1
│   │   │           ├── get-llvm.ps1
│   │   │           ├── io.ps1
│   │   │           ├── itemdefinition-context.ps1
│   │   │           ├── jsondb-export.ps1
│   │   │           ├── msbuild-expression-eval.ps1
│   │   │           ├── msbuild-project-cache-repository.ps1
│   │   │           ├── msbuild-project-data.ps1
│   │   │           ├── msbuild-project-load.ps1
│   │   │           └── visualstudio-detection.ps1
│   │   ├── VSPackage.resx
│   │   ├── cpt.config
│   │   └── source.extension.vsixmanifest
│   ├── ClangPowerTools.aip
│   ├── ClangPowerTools.sln
│   ├── ClangPowerToolsLib16/
│   │   ├── ClangPowerToolsLib16.csproj
│   │   ├── Key.snk
│   │   └── Properties/
│   │       ├── AssemblyInfo.cs
│   │       ├── Resource.Designer.cs
│   │       └── Resource.resx
│   ├── ClangPowerToolsLib17/
│   │   ├── ClangPowerToolsLib17.csproj
│   │   ├── Key.snk
│   │   └── Properties/
│   │       ├── AssemblyInfo.cs
│   │       ├── Resource.Designer.cs
│   │       └── Resource.resx
│   ├── ClangPowerToolsShared/
│   │   ├── Attributes/
│   │   │   ├── ClangCheckAttribute.cs
│   │   │   ├── ClangFormatPathAttribute.cs
│   │   │   └── ClangTidyPathAttribute.cs
│   │   ├── Builder/
│   │   │   ├── IAsyncBuilder.cs
│   │   │   └── IBuilder.cs
│   │   ├── CMake/
│   │   │   └── CMakeBuilder.cs
│   │   ├── ClangPowerToolsPackage.cs
│   │   ├── ClangPowerToolsPackageImpl.cs
│   │   ├── ClangPowerToolsShared.projitems
│   │   ├── ClangPowerToolsShared.projitems.bak
│   │   ├── ClangPowerToolsShared.shproj
│   │   ├── Commands/
│   │   │   ├── BackgroundTidy/
│   │   │   │   ├── BackgroundTidy.cs
│   │   │   │   ├── DataProcessor.cs
│   │   │   │   └── PowerShellWrapperBackground.cs
│   │   │   ├── BasicCommand.cs
│   │   │   ├── ClangCommand.cs
│   │   │   ├── CommandController.cs
│   │   │   ├── CommandControllerInstance.cs
│   │   │   ├── CommandIds.cs
│   │   │   ├── CommandUILocation.cs
│   │   │   ├── CompileCommand.cs
│   │   │   ├── DocumentationHtmlCommand.cs
│   │   │   ├── DocumentationMdCommand.cs
│   │   │   ├── DocumentationYamlCommand.cs
│   │   │   ├── FindCommand.cs
│   │   │   ├── FindCommandIds.cs
│   │   │   ├── FindViewMenuCommand.cs
│   │   │   ├── FormatCommand.cs
│   │   │   ├── IgnoreCommand.cs
│   │   │   ├── IgnoreCompileCommand.cs
│   │   │   ├── IgnoreFormatCommand.cs
│   │   │   ├── JsonCompilationDatabaseCommand.cs
│   │   │   ├── LookInMenu.cs
│   │   │   ├── Models/
│   │   │   │   └── CacheProjectsItemsModel.cs
│   │   │   ├── OptimizeIncludesCommand.cs
│   │   │   ├── RunController.cs
│   │   │   ├── SettingsCommand.cs
│   │   │   ├── StopCommand.cs
│   │   │   ├── TidyCommand.cs
│   │   │   └── VsCommands.cs
│   │   ├── Convertors/
│   │   │   ├── BooleanToGridLengthConverter.cs
│   │   │   ├── BooleanToVisibilityConverter.cs
│   │   │   ├── ClangFormatFallbackStyleConverter.cs
│   │   │   ├── ClangFormatStyleConverter.cs
│   │   │   ├── ClangGeneralAdditionalIncludesConvertor.cs
│   │   │   ├── ClangTidyHeaderFiltersConvertor.cs
│   │   │   └── ClangTidyUseChecksFromConvertor.cs
│   │   ├── Error/
│   │   │   ├── ErrorDetector.cs
│   │   │   ├── ErrorFormatter.cs
│   │   │   ├── ErrorParserConstants.cs
│   │   │   ├── ErrorWindowController.cs
│   │   │   ├── TaskErrorModel.cs
│   │   │   ├── TaskErrorModelBuilder.cs
│   │   │   └── TaskErrorViewModel.cs
│   │   ├── Events/
│   │   │   ├── ActiveDocumentEventArgs.cs
│   │   │   ├── BoolEventArgs.cs
│   │   │   ├── ClangCommandEventArgs.cs
│   │   │   ├── CleanErrorListEventArgs.cs
│   │   │   ├── CloseDataConnectionEventArgs.cs
│   │   │   ├── CloseDataStreamingEventArgs.cs
│   │   │   ├── ErrorDetectedEventArgs.cs
│   │   │   ├── FormatCommandEventArgs.cs
│   │   │   ├── HasEncodingErrorEventArgs.cs
│   │   │   ├── JsonFilePathArgs.cs
│   │   │   └── VsHierarchyDetectedEventArgs.cs
│   │   ├── Executables/
│   │   │   └── Clang Format Editor.msi
│   │   ├── Export Config/
│   │   │   └── TidyConfigFile.cs
│   │   ├── Extensions/
│   │   │   ├── IntExtension.cs
│   │   │   ├── ObjectExtension.cs
│   │   │   ├── StringExtension.cs
│   │   │   └── TaskExtensions.cs
│   │   ├── Files Operations/
│   │   │   ├── FileChangerWatcher.cs
│   │   │   ├── FileOpener.cs
│   │   │   └── FilePathCollector.cs
│   │   ├── Helpers/
│   │   │   ├── ActiveWindowProperties.cs
│   │   │   ├── ApiUtility.cs
│   │   │   ├── AutomationUtil.cs
│   │   │   ├── ClangTidyCleaner.cs
│   │   │   ├── DocumentHandler.cs
│   │   │   ├── FileSystem.cs
│   │   │   ├── FormatEditorUtility.cs
│   │   │   ├── GenerateDocumentation.cs
│   │   │   ├── JoinUtility.cs
│   │   │   ├── LaunchCompilationDbProgrammatically.cs
│   │   │   ├── ManageEncoding.cs
│   │   │   ├── NetworkUtility.cs
│   │   │   ├── PCHCleaner.cs
│   │   │   ├── PackageUtility.cs
│   │   │   ├── ProjectConfigurationHandler.cs
│   │   │   ├── PropertyHandler.cs
│   │   │   ├── RegistryUtility.cs
│   │   │   ├── RunningDocTableEvents.cs
│   │   │   ├── ScriptGenerator.cs
│   │   │   ├── SettingsApi.cs
│   │   │   ├── SettingsPathBuilder.cs
│   │   │   ├── SolutionInfo.cs
│   │   │   ├── StatusBarHandler.cs
│   │   │   ├── UIUpdater.cs
│   │   │   ├── VsWindowController.cs
│   │   │   └── Vsix.cs
│   │   ├── IgnoreActions/
│   │   │   └── IgnoreItem.cs
│   │   ├── Items/
│   │   │   ├── CurrentDocument.cs
│   │   │   ├── CurrentProject.cs
│   │   │   ├── CurrentProjectItem.cs
│   │   │   ├── CurrentSolution.cs
│   │   │   ├── IItem.cs
│   │   │   └── ItemsCollector.cs
│   │   ├── MVVM/
│   │   │   ├── .clang-format
│   │   │   ├── AutoCompleteHistory/
│   │   │   │   ├── ASTMatchers.cs
│   │   │   │   └── AutoCompleteBehavior.cs
│   │   │   ├── CollectionElementsCounter.cs
│   │   │   ├── Command/
│   │   │   │   └── RelayCommand.cs
│   │   │   ├── Commands/
│   │   │   │   ├── FileCommand.cs
│   │   │   │   ├── RelayCommand.cs
│   │   │   │   ├── TidyDiffCommand.cs
│   │   │   │   └── VSThemeCommand.cs
│   │   │   ├── CommonSettingsFunctionality.cs
│   │   │   ├── Constants/
│   │   │   │   ├── CPPKeywords.cs
│   │   │   │   ├── ComboBoxConstants.cs
│   │   │   │   ├── EncodingConstants.cs
│   │   │   │   ├── FormatEditorConstants.cs
│   │   │   │   ├── IconResourceConstants.cs
│   │   │   │   ├── LLVMVersionsAlternate.cs
│   │   │   │   ├── LlvmConstants.cs
│   │   │   │   ├── LlvmVersions.cs
│   │   │   │   ├── MatchConstants.cs
│   │   │   │   ├── PathConstants.cs
│   │   │   │   ├── PsUpdaterConstants.cs
│   │   │   │   ├── ResourceConstants.cs
│   │   │   │   ├── ThemeConstants.cs
│   │   │   │   ├── TidyConstants.cs
│   │   │   │   └── UIElementsConstants.cs
│   │   │   ├── Controllers/
│   │   │   │   ├── AccountController.cs
│   │   │   │   ├── FindController.cs
│   │   │   │   ├── FormatEditorController.cs
│   │   │   │   ├── FreeTrialController.cs
│   │   │   │   ├── LicenseController.cs
│   │   │   │   ├── LlvmController.cs
│   │   │   │   ├── LookInMenuController.cs
│   │   │   │   └── TidyToolWindowController.cs
│   │   │   ├── FindToolWindowHandler.cs
│   │   │   ├── Interfaces/
│   │   │   │   ├── IAccountValidator.cs
│   │   │   │   ├── IDownload.cs
│   │   │   │   ├── IInstall.cs
│   │   │   │   ├── ILicense.cs
│   │   │   │   ├── IView.cs
│   │   │   │   └── IViewMatche.cs
│   │   │   ├── LicenseValidation/
│   │   │   │   ├── CommercialLicenseValidator.cs
│   │   │   │   ├── LicenseType.cs
│   │   │   │   ├── LocalLicenseValidator.cs
│   │   │   │   ├── PersonalLicenseValidator.cs
│   │   │   │   └── Token.cs
│   │   │   ├── LlvmUri.cs
│   │   │   ├── Models/
│   │   │   │   ├── AccountApiModel.cs
│   │   │   │   ├── AccountModel.cs
│   │   │   │   ├── CompilerSettingsModel.cs
│   │   │   │   ├── FileModel.cs
│   │   │   │   ├── FormatSettingsModel.cs
│   │   │   │   ├── GeneralSettingsModel.cs
│   │   │   │   ├── InputDataModel.cs
│   │   │   │   ├── LicenseModel.cs
│   │   │   │   ├── LlvmModel.cs
│   │   │   │   ├── LlvmSettingsModel.cs
│   │   │   │   ├── MessageModel.cs
│   │   │   │   ├── SelectedFileModel.cs
│   │   │   │   ├── TidyCheckModel.cs
│   │   │   │   ├── TidySettingsModel.cs
│   │   │   │   ├── ToggleModel.cs
│   │   │   │   ├── TokenModel.cs
│   │   │   │   ├── ToolWindowModels/
│   │   │   │   │   ├── AutoCompleteHistoryModel.cs
│   │   │   │   │   ├── ComponentVisibility.cs
│   │   │   │   │   ├── CountStateFilesModel.cs
│   │   │   │   │   ├── CustomMatchesModel.cs
│   │   │   │   │   ├── DefaultArgsModel.cs
│   │   │   │   │   ├── FileType.cs
│   │   │   │   │   ├── FindControllerModel.cs
│   │   │   │   │   ├── FindToolWindowModel.cs
│   │   │   │   │   ├── IconModel.cs
│   │   │   │   │   └── TidyToolWindowModel.cs
│   │   │   │   └── UserModel.cs
│   │   │   ├── OldSettings/
│   │   │   │   ├── ClangFormatPathValue.cs
│   │   │   │   ├── ClangTidyPathValue.cs
│   │   │   │   ├── HeaderFiltersValue.cs
│   │   │   │   └── OldModels/
│   │   │   │       ├── ClangFormatOptions.cs
│   │   │   │       ├── ClangOptions.cs
│   │   │   │       ├── ClangTidyOptions.cs
│   │   │   │       └── DefaultOptions.cs
│   │   │   ├── PreinstalledLlvm.cs
│   │   │   ├── Provider/
│   │   │   │   ├── FindToolWindowProvider.cs
│   │   │   │   └── SettingsProvider.cs
│   │   │   ├── SettingsHandler.cs
│   │   │   ├── SettingsTooltips.cs
│   │   │   ├── TextManipulation.cs
│   │   │   ├── TidyChecks.cs
│   │   │   ├── TidyChecksDefault.cs
│   │   │   ├── ViewModels/
│   │   │   │   ├── AboutSettingsViewModel.cs
│   │   │   │   ├── AutoCompleteHistoryViewModel.cs
│   │   │   │   ├── CompilerSettingsViewModel.cs
│   │   │   │   ├── DetectedStyleInfoViewModel.cs
│   │   │   │   ├── EncodingErrorViewModel.cs
│   │   │   │   ├── FeedbackViewModel.cs
│   │   │   │   ├── FindToolWindowViewModel.cs
│   │   │   │   ├── FolderExplorerViewModel.cs
│   │   │   │   ├── FormatSettingsViewModel.cs
│   │   │   │   ├── InputDataViewModel.cs
│   │   │   │   ├── InputMultipleDataViewModel.cs
│   │   │   │   ├── LicenseViewModel.cs
│   │   │   │   ├── LlvmSettingsViewModel.cs
│   │   │   │   ├── LoginViewModel.cs
│   │   │   │   ├── ReleaseNotesViewModel.cs
│   │   │   │   ├── SettingsViewModel.cs
│   │   │   │   ├── TidyChecksViewModel.cs
│   │   │   │   ├── TidySettingsViewModel.cs
│   │   │   │   ├── TidyToolWindowViewModel.cs
│   │   │   │   ├── ToggleMultipleDataViewModel.cs
│   │   │   │   └── TrialExpiredViewModel.cs
│   │   │   ├── Views/
│   │   │   │   ├── AboutSettingsView.xaml
│   │   │   │   ├── AboutSettingsView.xaml.cs
│   │   │   │   ├── CMakeBetaWarning.xaml
│   │   │   │   ├── CMakeBetaWarning.xaml.cs
│   │   │   │   ├── CompilerSettingsView.xaml
│   │   │   │   ├── CompilerSettingsView.xaml.cs
│   │   │   │   ├── Components/
│   │   │   │   │   ├── BuyNowFooter.xaml
│   │   │   │   │   ├── BuyNowFooter.xaml.cs
│   │   │   │   │   ├── InputList.xaml
│   │   │   │   │   ├── InputList.xaml.cs
│   │   │   │   │   ├── MessageBanner.xaml
│   │   │   │   │   ├── MessageBanner.xaml.cs
│   │   │   │   │   ├── ThreePieceButton.xaml
│   │   │   │   │   ├── ThreePieceButton.xaml.cs
│   │   │   │   │   ├── ThreePieceComponent.xaml
│   │   │   │   │   └── ThreePieceComponent.xaml.cs
│   │   │   │   ├── DialogWindow.cs
│   │   │   │   ├── EncodingErrorView.xaml
│   │   │   │   ├── EncodingErrorView.xaml.cs
│   │   │   │   ├── FeedbackView.xaml
│   │   │   │   ├── FeedbackView.xaml.cs
│   │   │   │   ├── FindToolWindowView.xaml
│   │   │   │   ├── FindToolWindowView.xaml.cs
│   │   │   │   ├── FolderExplorerView.xaml
│   │   │   │   ├── FolderExplorerView.xaml.cs
│   │   │   │   ├── FormatEditorWarning.xaml
│   │   │   │   ├── FormatEditorWarning.xaml.cs
│   │   │   │   ├── FormatSettingsView.xaml
│   │   │   │   ├── FormatSettingsView.xaml.cs
│   │   │   │   ├── InputDataView.xaml
│   │   │   │   ├── InputDataView.xaml.cs
│   │   │   │   ├── LicenseView.xaml
│   │   │   │   ├── LicenseView.xaml.cs
│   │   │   │   ├── LlvmSettingsView.xaml
│   │   │   │   ├── LlvmSettingsView.xaml.cs
│   │   │   │   ├── LoginView.xaml
│   │   │   │   ├── LoginView.xaml.cs
│   │   │   │   ├── ReleaseNotesView.xaml
│   │   │   │   ├── ReleaseNotesView.xaml.cs
│   │   │   │   ├── SearchBoxView.xaml
│   │   │   │   ├── SearchBoxView.xaml.cs
│   │   │   │   ├── SettingsView.xaml
│   │   │   │   ├── SettingsView.xaml.cs
│   │   │   │   ├── Styles/
│   │   │   │   │   ├── AppResources.xaml
│   │   │   │   │   ├── HyperlinkStyle.xaml
│   │   │   │   │   ├── ImageResources.xaml
│   │   │   │   │   ├── SettingsButtonStyle.xaml
│   │   │   │   │   ├── SettingsComboBoxStyle.xaml
│   │   │   │   │   ├── ToggleStyle.xaml
│   │   │   │   │   └── YellowButtonStyle.xaml
│   │   │   │   ├── TidyChecksView.xaml
│   │   │   │   ├── TidyChecksView.xaml.cs
│   │   │   │   ├── TidySettingsView.xaml
│   │   │   │   ├── TidySettingsView.xaml.cs
│   │   │   │   ├── TidyToolWindowView.xaml
│   │   │   │   ├── TidyToolWindowView.xaml.cs
│   │   │   │   ├── ToolWindows/
│   │   │   │   │   ├── FindToolWindow.cs
│   │   │   │   │   └── TidyToolWindow.cs
│   │   │   │   ├── TrialExpiredView.xaml
│   │   │   │   └── TrialExpiredView.xaml.cs
│   │   │   ├── WebApi/
│   │   │   │   └── WebApiUrl.cs
│   │   │   └── XmlSerializer.cs
│   │   ├── Output/
│   │   │   ├── OutputContentModel.cs
│   │   │   ├── OutputProcessor.cs
│   │   │   ├── OutputWindowBuilder.cs
│   │   │   ├── OutputWindowConstants.cs
│   │   │   ├── OutputWindowController.cs
│   │   │   └── OutputWindowModel.cs
│   │   ├── Resources/
│   │   │   └── LICENSE.txt
│   │   ├── Script/
│   │   │   ├── ClangTidyModeParametersFactory.cs
│   │   │   ├── GenericScriptBuilder.cs
│   │   │   ├── ItemRelatedScriptBuilder.cs
│   │   │   ├── PowerShellWrapper.cs
│   │   │   ├── RunModeScriptBuilder.cs
│   │   │   ├── RunningProcesses.cs
│   │   │   ├── ScriptConstants.cs
│   │   │   └── VerbosityScriptBuilder.cs
│   │   ├── Services/
│   │   │   ├── PowerShellService.cs
│   │   │   └── VsServiceProvider.cs
│   │   ├── SilentFile/
│   │   │   ├── SilentFileChangerBuilder.cs
│   │   │   ├── SilentFileChangerController.cs
│   │   │   ├── SilentFileChangerEqualityComparer.cs
│   │   │   └── SilentFileChangerModel.cs
│   │   ├── Squiggle/
│   │   │   ├── SquiggleErrorTag.cs
│   │   │   ├── SquiggleErrorTagger.cs
│   │   │   ├── SquiggleErrorTaggerProvider.cs
│   │   │   ├── SquiggleModel.cs
│   │   │   ├── SquiggleViewModel.cs
│   │   │   └── SquigglesFactory.cs
│   │   ├── TextOperationsInterfaces/
│   │   │   ├── IDetector.cs
│   │   │   └── ITextFormatter.cs
│   │   └── Tooling/
│   │       └── v1/
│   │           ├── clang-build.ps1
│   │           └── psClang/
│   │               ├── get-header-references.ps1
│   │               ├── get-llvm-helper.ps1
│   │               ├── get-llvm.ps1
│   │               ├── integration-project.tests.ps1
│   │               ├── integration-projects/
│   │               │   ├── CptIntegrationProjects.sln
│   │               │   └── itemgroups/
│   │               │       └── test.vcxproj
│   │               ├── io.ps1
│   │               ├── io.tests.ps1
│   │               ├── itemdefinition-context.ps1
│   │               ├── jsondb-export.ps1
│   │               ├── jsondb-export.tests.ps1
│   │               ├── msbuild-expression-eval.ps1
│   │               ├── msbuild-expression-eval.tests.ps1
│   │               ├── msbuild-project-cache-repository.ps1
│   │               ├── msbuild-project-cache-repository.tests.ps1
│   │               ├── msbuild-project-data.ps1
│   │               ├── msbuild-project-data.tests.ps1
│   │               ├── msbuild-project-load.ps1
│   │               ├── msbuild-project-load.tests.ps1
│   │               ├── visualstudio-detection.ps1
│   │               ├── visualstudio-detection.tests.ps1
│   │               └── ~advinst.tests.ps1
│   ├── ClangPowerToolsUnitTests/
│   │   ├── ClangCommandTests/
│   │   │   ├── IgnoreCompileCommandTests.cs
│   │   │   ├── IgnoreFormatCommandTests.cs
│   │   │   └── ScriptTests.cs
│   │   ├── ClangPowerToolsUnitTests.csproj
│   │   ├── Constants/
│   │   │   └── IgnoreCommand.cs
│   │   ├── PackageTests/
│   │   │   └── AsyncPackageTests.cs
│   │   ├── Settings Tests/
│   │   │   ├── CompilerSettingsTests.cs
│   │   │   ├── FormatSettingsTests.cs
│   │   │   ├── GeneralSettingsTests.cs
│   │   │   └── TidySettingsTests.cs
│   │   ├── VSVersionTests.cs
│   │   └── VsServiceProviderTests.cs
│   ├── VsixAI/
│   │   └── InfoDocument.txt
│   └── cert.pfx
├── LICENSE.TXT
└── README.md

================================================
FILE CONTENTS
================================================

================================================
FILE: .gitattributes
================================================
# Auto detect text files and perform LF normalization
* text=auto


================================================
FILE: .github/workflows/Build-ClangPowerTools.yml
================================================
# This is a basic workflow to help you get started with Actions

name: Build Clang Power Tools and generate vsix with Advenced Installer

# Controls when the workflow will run
on:
  # Triggers the workflow on push or pull request events but only for the master branch
  push:
    branches: [ master ]
  pull_request:
    branches: [ master ]

  # Allows you to run this workflow manually from the Actions tab
  workflow_dispatch:

# A workflow run is made up of one or more jobs that can run sequentially or in parallel
jobs:
  # This workflow contains a single job called "build"
  build:
    # The type of runner that the job will run on
    runs-on: windows-latest

    # Steps represent a sequence of tasks that will be executed as part of the job
    steps:
      # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
      - uses: actions/checkout@v2
        
      - name: Add msbuild to PATH
        uses: microsoft/setup-msbuild@v1.1
        
      - name: Restore dependencies
        run: dotnet restore ClangPowerTools\ClangPowerTools.sln

      - name: Build app for release
        run: msbuild ${{ github.workspace }}\ClangPowerTools\ClangPowerTools.sln -t:rebuild -property:Configuration=Release

  generate-aip:
    runs-on: windows-latest
    needs: build
    if: github.ref == 'refs/heads/master'
    steps:
      - uses: actions/checkout@v2
      - name: Add msbuild to PATH
        uses: microsoft/setup-msbuild@v1.1
        
      - name: Restore dependencies
        run: dotnet restore ClangPowerTools\ClangPowerTools.sln

      - name: Build app for release
        run: msbuild ${{ github.workspace }}\ClangPowerTools\ClangPowerTools.sln -t:rebuild -property:Configuration=Release
      - name: Create ClangPowerTools.vsix- build AIP
        uses: caphyon/advinst-github-action@v1.0
        with:
          advinst-license: ${{ secrets.ADVINST_LICENSE_KEY }}
          advinst-enable-automation: 'true'
          aip-path: ${{ github.workspace }}\ClangPowerTools\ClangPowerTools.aip
      - run: |
          AdvancedInstaller.com /edit ${{ github.workspace }}\ClangPowerTools\ClangPowerTools.aip /SetProperty Identifier="Caphyon.9ce239f2-d27a-432c-906c-1d55a123dbfd"
          AdvancedInstaller.com /edit ${{ github.workspace }}\ClangPowerTools\ClangPowerTools.aip /SetProperty Name="Clang Power Tools 2022"
          AdvancedInstaller.com /edit ${{ github.workspace }}\ClangPowerTools\ClangPowerTools.aip /SetPackageName ClangPowerTools2022

      - name: Create ClangPowerTools2022.vsix - build AIP
        uses: caphyon/advinst-github-action@v1.0
        with:
          advinst-license: ${{ secrets.ADVINST_LICENSE_KEY }}
          advinst-enable-automation: 'true'
          aip-path: ${{ github.workspace }}\ClangPowerTools\ClangPowerTools.aip

     
      - name: Archive production ClangPowerTools artifacts (cpt generated with advanced installer)
        uses: actions/upload-artifact@v4
        with:
          name: VsixAI
          path: ${{ github.workspace }}\ClangPowerTools\VsixAI\ClangPowerTools.vsix

      - name: Archive production ClangPowerTools 2022 artifacts (cpt 2022 generated with advanced installer)
        uses: actions/upload-artifact@v4
        with:
          name: VsixAI2022
          path: ${{ github.workspace }}\ClangPowerTools\VsixAI\ClangPowerTools2022.vsix
      




================================================
FILE: .github/workflows/Run-ClangPowerTools-tests.yml
================================================
name: Run script tests

# Controls when the workflow will run
on:
  # Triggers the workflow on push or pull request events but only for the master branch
  push:
    branches: [ master ]
  pull_request:
    branches: [ master ]

  # Allows you to run this workflow manually from the Actions tab
  workflow_dispatch:

# A workflow run is made up of one or more jobs that can run sequentially or in parallel
jobs:
  # This workflow contains a single job called "run-script-tests"
  run-script-tests:
    # The type of runner that the job will run on
    runs-on: windows-latest

    # Steps represent a sequence of tasks that will be executed as part of the job
    steps:
      # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
      - name: Check out repository code
        uses: actions/checkout@v2

      - name: Perform Pester tests from the command-line
        shell: pwsh
        run: Invoke-Pester

================================================
FILE: .gitignore
================================================
## Ignore Visual Studio temporary files, build results, and
## files generated by popular Visual Studio add-ons.

# User-specific files
*.suo
*.user
*.userosscache
*.sln.docstates

# Build results
[Dd]ebug/
[Dd]ebugPublic/
[Rr]elease/
[Rr]eleases/
x64/
x86/
build/
bld/
[Bb]in/
[Oo]bj/

#Nuget
[Pp]ackages

# Visual Studio cache/options directory

.vs/
.DS_Store
ClangPowerTools/ClangPowerTools/ClangPowerToolsLib16.dll
ClangPowerTools/ClangPowerTools/ClangPowerToolsLib17.dll
ClangPowerTools/CPTReleases/ClangPowerTools2022.vsix
ClangPowerTools/CPTReleases/ClangPowerTools.vsix
ClangPowerTools/ClangPowerToolsShared/Tooling/.vscode/launch.json


================================================
FILE: ClangPowerTools/Automation/full-llvm-update-instructions.md
================================================

# Copilot recipe – Update clang-format & LLVM metadata

When the user says something like:

> Update clang-format and LLVM version to `<NEW_LLVM_VERSION>` with CPT previous release tag `<CPT_PREVIOUS_RELEASE_TAG>`

you must do **all** of the following steps from the **repo root** (`clang-power-tools`).

> ⚠️ **Important:**  
> The value of `kCptGithubLlvm` is **the Clang Power Tools GitHub release that contains the previous assets**  
> (`#Url to assets (clang++ and clang-tidy) from previous release made by Clang Power Tools on github`).  
> If the user did **not** provide `<CPT_PREVIOUS_RELEASE_TAG>`, you **must ask the user** for it before editing
> `get-llvm-helper.ps1`. Do **not** guess it.

---

## 1. Run the PowerShell updater

From the **repo root**, run:

```powershell
& ".\ClangPowerTools\Tidy_Checks_Automation\update-clang-format.ps1" -LlvmVersion <NEW_LLVM_VERSION>
```

Example for LLVM 21.1.6:

```powershell
& ".\ClangPowerTools\Tidy_Checks_Automation\update-clang-format.ps1" -LlvmVersion 21.1.6
```

This downloads:

```
https://github.com/llvm/llvm-project/releases/download/llvmorg-<NEW_LLVM_VERSION>/LLVM-<NEW_LLVM_VERSION>-win64.exe
```

runs the installer into a temporary folder, then copies the new `clang-format.exe` to:

```
ClangPowerTools/ClangPowerToolsShared/Executables/clang-format.exe
```

You do **not** need to manually edit the EXE; just ensure this path is updated.

---

## 2. Update C# version lists

### 2.1 File: `ClangPowerTools/ClangPowerToolsShared/MVVM/Constants/LLVMVersionsAlternate.cs`

In the `VersionAlternateUri` list, insert the new version **at the top** (as the first element), keeping the rest unchanged.

Pattern:

```diff
public static List<string> VersionAlternateUri { get; } = new List<string>
{
+  "<NEW_LLVM_VERSION>",
   "18.1.2",
   "17.0.1",
   "16.0.6",
   // ...
};
```

---

### 2.2 File: `ClangPowerTools/ClangPowerToolsShared/MVVM/Constants/LlvmVersions.cs`

In the `Versions` list, insert the new version **at the top** (first element), keeping the rest unchanged.

Pattern:

```diff
public static List<string> Versions { get; } = new List<string>
{
+  "<NEW_LLVM_VERSION>",
   "18.1.2",
   "17.0.1",
   "16.0.6",
   // ...
};
```

---

## 3. Update the PowerShell helper script

### File: `ClangPowerTools/ClangPowerToolsShared/Tooling/v1/psClang/get-llvm-helper.ps1`

At the top of this file there is a comment:

```powershell
#Url to assets (clang++ and clang-tidy) from previous release made by Clang Power Tools on github
```

This means:

- `kCptGithubLlvm` must point to the **previous Clang Power Tools GitHub release** that contains the clang++/clang-tidy assets.
- `kCptGithubLlvmVersion` is a human-readable description for the LLVM version.

> 🔴 **Rule for Copilot:**  
> If the user did **not** provide `<CPT_PREVIOUS_RELEASE_TAG>`, you must ask:  
> *“What is the Clang Power Tools GitHub release tag that contains the previous clang++/clang-tidy assets (for kCptGithubLlvm)?”*  
> Only after the user answers, update `kCptGithubLlvm`.

Once the user has provided `<CPT_PREVIOUS_RELEASE_TAG>`, update both variables like this:

```diff
-Set-Variable -name kCptGithubLlvm -value "https://github.com/Caphyon/clang-power-tools/releases/download/v2023.9.0" `
+Set-Variable -name kCptGithubLlvm -value "https://github.com/Caphyon/clang-power-tools/releases/download/<CPT_PREVIOUS_RELEASE_TAG>" `
                                   -option Constant
-Set-Variable -name kCptGithubLlvmVersion -value "18.1.2 (LLVM 18.1.2)" -Option Constant
+Set-Variable -name kCptGithubLlvmVersion -value "<NEW_LLVM_VERSION> (LLVM <NEW_LLVM_VERSION>)" -Option Constant
```

---

## 4. Summary for Copilot

When asked to update LLVM to `<NEW_LLVM_VERSION>`:

1. **Run the update script** from the repo root:

```powershell
& ".\ClangPowerTools\Tidy_Checks_Automation\update-clang-format.ps1" -LlvmVersion <NEW_LLVM_VERSION>
```

2. **Edit** `ClangPowerTools/ClangPowerToolsShared/MVVM/Constants/LLVMVersionsAlternate.cs`:
   - Insert `<NEW_LLVM_VERSION>` as the first element in `VersionAlternateUri`.

3. **Edit** `ClangPowerTools/ClangPowerToolsShared/MVVM/Constants/LlvmVersions.cs`:
   - Insert `<NEW_LLVM_VERSION>` as the first element in `Versions`.

4. **Edit** `get-llvm-helper.ps1`:
   - If `<CPT_PREVIOUS_RELEASE_TAG>` is **not provided**, ask the user for it.
   - After receiving it, update:
     - `kCptGithubLlvm` → `"https://github.com/Caphyon/clang-power-tools/releases/download/<CPT_PREVIOUS_RELEASE_TAG>"`
     - `kCptGithubLlvmVersion` → `"<NEW_LLVM_VERSION> (LLVM <NEW_LLVM_VERSION>)"`

5. After all changes, show diffs for:
   - `LLVMVersionsAlternate.cs`
   - `LlvmVersions.cs`
   - `get-llvm-helper.ps1`
   - Confirm the script replaced `clang-format.exe`.


================================================
FILE: ClangPowerTools/Automation/get-tidy-checks-and-format.ps1
================================================
param(
    [string]$OutFile = "input_checks.txt",
    [string]$Url     = "https://clang.llvm.org/extra/clang-tidy/checks/list.html"
)

# Make sure TLS is OK on older PowerShells
[Net.ServicePointManager]::SecurityProtocol =
    [Net.SecurityProtocolType]::Tls12 -bor [Net.SecurityProtocolType]::Tls13

# Download HTML
$response = Invoke-WebRequest -Uri $Url
$html = $response.Content

# Regex:
# <a class="reference internal" ...>
#   <span class="doc">CHECK-NAME</span>
# </a>
$pattern = '<a[^>]*class=["'']reference internal["''][^>]*>\s*<span[^>]*class=["'']doc["''][^>]*>([^<]+)</span>\s*</a>'

$matches = [regex]::Matches(
    $html,
    $pattern,
    [System.Text.RegularExpressions.RegexOptions]::IgnoreCase
)

$checks = @()

foreach ($m in $matches) {
    $name = $m.Groups[1].Value.Trim()
    if ([string]::IsNullOrWhiteSpace($name)) { continue }

    # Names can contain letters, digits, -, _, .
    if ($name -match '^[A-Za-z0-9_.-]+$') {
        $checks += $name
    }
}

# Sort & dedupe
$checks = $checks | Sort-Object -Unique

# Write to file
$checks | Set-Content -Path $OutFile -Encoding UTF8

Write-Host "$($checks.Count) checks written to '$OutFile'"


#-------------------------------------------------------------- Format here --------------------------------------------------------------------------------------------------------

# Will convert bugprone-empty-catch list in new TidyCheckModel { Name = "bugprone-empty-catch", IsChecked = false }, and remove dublicates

# Input and output file paths
$inputFilePath = "input_checks.txt"
$outputFilePath = "output_checks.txt"

# Read checks from input file
$checks = Get-Content $inputFilePath

# Sort the checks alphabetically
$sortedChecks = $checks | Sort-Object

# Create a hashtable to store unique checks
$uniqueChecks = @{}

# Format and add each unique check to the hashtable
foreach ($check in $sortedChecks) {
    if (-not $uniqueChecks.ContainsKey($check)) {
        $uniqueChecks[$check] = "new TidyCheckModel { Name = `"$check`", IsChecked = false },"
    }
}

# Sort the unique checks alphabetically again
$sortedUniqueChecks = $uniqueChecks.Values | Sort-Object

# Write sorted unique checks to output file
$sortedUniqueChecks | Out-File $outputFilePath

Write-Host "Formatted unique checks written to $outputFilePath"


================================================
FILE: ClangPowerTools/Automation/input_checks.txt
================================================
abseil-cleanup-ctad
abseil-duration-addition
abseil-duration-comparison
abseil-duration-conversion-cast
abseil-duration-division
abseil-duration-factory-float
abseil-duration-factory-scale
abseil-duration-subtraction
abseil-duration-unnecessary-conversion
abseil-faster-strsplit-delimiter
abseil-no-internal-dependencies
abseil-no-namespace
abseil-redundant-strcat-calls
abseil-str-cat-append
abseil-string-find-startswith
abseil-string-find-str-contains
abseil-time-comparison
abseil-time-subtraction
abseil-upgrade-duration-conversions
altera-id-dependent-backward-branch
altera-kernel-name-restriction
altera-single-work-item-barrier
altera-struct-pack-align
altera-unroll-loops
android-cloexec-accept
android-cloexec-accept4
android-cloexec-creat
android-cloexec-dup
android-cloexec-epoll-create
android-cloexec-epoll-create1
android-cloexec-fopen
android-cloexec-inotify-init
android-cloexec-inotify-init1
android-cloexec-memfd-create
android-cloexec-open
android-cloexec-pipe
android-cloexec-pipe2
android-cloexec-socket
android-comparison-in-temp-failure-retry
boost-use-ranges
boost-use-to-string
bugprone-argument-comment
bugprone-assert-side-effect
bugprone-assignment-in-if-condition
bugprone-bad-signal-to-kill-thread
bugprone-bitwise-pointer-cast
bugprone-bool-pointer-implicit-conversion
bugprone-branch-clone
bugprone-capturing-this-in-member-variable
bugprone-casting-through-void
bugprone-chained-comparison
bugprone-command-processor
bugprone-compare-pointer-to-member-virtual-function
bugprone-copy-constructor-init
bugprone-copy-constructor-mutates-argument
bugprone-crtp-constructor-accessibility
bugprone-dangling-handle
bugprone-default-operator-new-on-overaligned-type
bugprone-derived-method-shadowing-base-method
bugprone-dynamic-static-initializers
bugprone-easily-swappable-parameters
bugprone-empty-catch
bugprone-exception-copy-constructor-throws
bugprone-exception-escape
bugprone-float-loop-counter
bugprone-fold-init-type
bugprone-forward-declaration-namespace
bugprone-forwarding-reference-overload
bugprone-implicit-widening-of-multiplication-result
bugprone-inaccurate-erase
bugprone-inc-dec-in-conditions
bugprone-incorrect-enable-if
bugprone-incorrect-enable-shared-from-this
bugprone-incorrect-roundings
bugprone-infinite-loop
bugprone-integer-division
bugprone-invalid-enum-default-initialization
bugprone-lambda-function-name
bugprone-macro-parentheses
bugprone-macro-repeated-side-effects
bugprone-misleading-setter-of-reference
bugprone-misplaced-operator-in-strlen-in-alloc
bugprone-misplaced-pointer-arithmetic-in-alloc
bugprone-misplaced-widening-cast
bugprone-move-forwarding-reference
bugprone-multi-level-implicit-pointer-conversion
bugprone-multiple-new-in-one-expression
bugprone-multiple-statement-macro
bugprone-narrowing-conversions
bugprone-no-escape
bugprone-nondeterministic-pointer-iteration-order
bugprone-non-zero-enum-to-bool-conversion
bugprone-not-null-terminated-result
bugprone-optional-value-conversion
bugprone-parent-virtual-call
bugprone-pointer-arithmetic-on-polymorphic-object
bugprone-posix-return
bugprone-random-generator-seed
bugprone-raw-memory-call-on-non-trivial-type
bugprone-redundant-branch-condition
bugprone-reserved-identifier
bugprone-return-const-ref-from-parameter
bugprone-shared-ptr-array-mismatch
bugprone-signal-handler
bugprone-signed-char-misuse
bugprone-sizeof-container
bugprone-sizeof-expression
bugprone-spuriously-wake-up-functions
bugprone-standalone-empty
bugprone-std-namespace-modification
bugprone-string-constructor
bugprone-string-integer-assignment
bugprone-string-literal-with-embedded-nul
bugprone-stringview-nullptr
bugprone-suspicious-enum-usage
bugprone-suspicious-include
bugprone-suspicious-memory-comparison
bugprone-suspicious-memset-usage
bugprone-suspicious-missing-comma
bugprone-suspicious-realloc-usage
bugprone-suspicious-semicolon
bugprone-suspicious-string-compare
bugprone-suspicious-stringview-data-usage
bugprone-swapped-arguments
bugprone-switch-missing-default-case
bugprone-tagged-union-member-count
bugprone-terminating-continue
bugprone-throwing-static-initialization
bugprone-throw-keyword-missing
bugprone-too-small-loop-variable
bugprone-unchecked-optional-access
bugprone-unchecked-string-to-number-conversion
bugprone-undefined-memory-manipulation
bugprone-undelegated-constructor
bugprone-unhandled-exception-at-new
bugprone-unhandled-self-assignment
bugprone-unintended-char-ostream-output
bugprone-unique-ptr-array-mismatch
bugprone-unsafe-functions
bugprone-unused-local-non-trivial-variable
bugprone-unused-raii
bugprone-unused-return-value
bugprone-use-after-move
bugprone-virtual-near-miss
cert-arr39-c
cert-con36-c
cert-con54-cpp
cert-ctr56-cpp
cert-dcl03-c
cert-dcl16-c
cert-dcl37-c
cert-dcl50-cpp
cert-dcl51-cpp
cert-dcl54-cpp
cert-dcl58-cpp
cert-dcl59-cpp
cert-env33-c
cert-err09-cpp
cert-err33-c
cert-err34-c
cert-err52-cpp
cert-err58-cpp
cert-err60-cpp
cert-err61-cpp
cert-exp42-c
cert-fio38-c
cert-flp30-c
cert-flp37-c
cert-int09-c
cert-mem57-cpp
cert-msc24-c
cert-msc30-c
cert-msc32-c
cert-msc33-c
cert-msc50-cpp
cert-msc51-cpp
cert-msc54-cpp
cert-oop11-cpp
cert-oop54-cpp
cert-oop57-cpp
cert-oop58-cpp
cert-pos44-c
cert-pos47-c
cert-sig30-c
cert-str34-c
clang-analyzer-core.BitwiseShift
clang-analyzer-core.CallAndMessage
clang-analyzer-core.DivideZero
clang-analyzer-core.NonNullParamChecker
clang-analyzer-core.NullDereference
clang-analyzer-core.StackAddressEscape
clang-analyzer-core.UndefinedBinaryOperatorResult
clang-analyzer-core.uninitialized.ArraySubscript
clang-analyzer-core.uninitialized.Assign
clang-analyzer-core.uninitialized.Branch
clang-analyzer-core.uninitialized.CapturedBlockVariable
clang-analyzer-core.uninitialized.NewArraySize
clang-analyzer-core.uninitialized.UndefReturn
clang-analyzer-core.VLASize
clang-analyzer-cplusplus.ArrayDelete
clang-analyzer-cplusplus.InnerPointer
clang-analyzer-cplusplus.Move
clang-analyzer-cplusplus.NewDelete
clang-analyzer-cplusplus.NewDeleteLeaks
clang-analyzer-cplusplus.PlacementNew
clang-analyzer-cplusplus.SelfAssignment
clang-analyzer-cplusplus.StringChecker
clang-analyzer-deadcode.DeadStores
clang-analyzer-fuchsia.HandleChecker
clang-analyzer-nullability.NullableDereferenced
clang-analyzer-nullability.NullablePassedToNonnull
clang-analyzer-nullability.NullableReturnedFromNonnull
clang-analyzer-nullability.NullPassedToNonnull
clang-analyzer-nullability.NullReturnedFromNonnull
clang-analyzer-optin.core.EnumCastOutOfRange
clang-analyzer-optin.cplusplus.UninitializedObject
clang-analyzer-optin.cplusplus.VirtualCall
clang-analyzer-optin.mpi.MPI-Checker
clang-analyzer-optin.osx.cocoa.localizability.EmptyLocalizationContextChecker
clang-analyzer-optin.osx.cocoa.localizability.NonLocalizedStringChecker
clang-analyzer-optin.performance.GCDAntipattern
clang-analyzer-optin.performance.Padding
clang-analyzer-optin.portability.UnixAPI
clang-analyzer-optin.taint.TaintedAlloc
clang-analyzer-osx.API
clang-analyzer-osx.cocoa.AtSync
clang-analyzer-osx.cocoa.AutoreleaseWrite
clang-analyzer-osx.cocoa.ClassRelease
clang-analyzer-osx.cocoa.Dealloc
clang-analyzer-osx.cocoa.IncompatibleMethodTypes
clang-analyzer-osx.cocoa.Loops
clang-analyzer-osx.cocoa.MissingSuperCall
clang-analyzer-osx.cocoa.NilArg
clang-analyzer-osx.cocoa.NonNilReturnValue
clang-analyzer-osx.cocoa.NSAutoreleasePool
clang-analyzer-osx.cocoa.NSError
clang-analyzer-osx.cocoa.ObjCGenerics
clang-analyzer-osx.cocoa.RetainCount
clang-analyzer-osx.cocoa.RunLoopAutoreleaseLeak
clang-analyzer-osx.cocoa.SelfInit
clang-analyzer-osx.cocoa.SuperDealloc
clang-analyzer-osx.cocoa.UnusedIvars
clang-analyzer-osx.cocoa.VariadicMethodTypes
clang-analyzer-osx.coreFoundation.CFError
clang-analyzer-osx.coreFoundation.CFNumber
clang-analyzer-osx.coreFoundation.CFRetainRelease
clang-analyzer-osx.coreFoundation.containers.OutOfBounds
clang-analyzer-osx.coreFoundation.containers.PointerSizedValues
clang-analyzer-osx.NumberObjectConversion
clang-analyzer-osx.ObjCProperty
clang-analyzer-osx.SecKeychainAPI
clang-analyzer-security.cert.env.InvalidPtr
clang-analyzer-security.FloatLoopCounter
clang-analyzer-security.insecureAPI.bcmp
clang-analyzer-security.insecureAPI.bcopy
clang-analyzer-security.insecureAPI.bzero
clang-analyzer-security.insecureAPI.decodeValueOfObjCType
clang-analyzer-security.insecureAPI.DeprecatedOrUnsafeBufferHandling
clang-analyzer-security.insecureAPI.getpw
clang-analyzer-security.insecureAPI.gets
clang-analyzer-security.insecureAPI.mkstemp
clang-analyzer-security.insecureAPI.mktemp
clang-analyzer-security.insecureAPI.rand
clang-analyzer-security.insecureAPI.strcpy
clang-analyzer-security.insecureAPI.UncheckedReturn
clang-analyzer-security.insecureAPI.vfork
clang-analyzer-security.PutenvStackArray
clang-analyzer-security.SetgidSetuidOrder
clang-analyzer-unix.API
clang-analyzer-unix.BlockInCriticalSection
clang-analyzer-unix.cstring.BadSizeArg
clang-analyzer-unix.cstring.NullArg
clang-analyzer-unix.Errno
clang-analyzer-unix.Malloc
clang-analyzer-unix.MallocSizeof
clang-analyzer-unix.MismatchedDeallocator
clang-analyzer-unix.StdCLibraryFunctions
clang-analyzer-unix.Stream
clang-analyzer-unix.Vfork
clang-analyzer-webkit.NoUncountedMemberChecker
clang-analyzer-webkit.RefCntblBaseVirtualDtor
clang-analyzer-webkit.UncountedLambdaCapturesChecker
concurrency-mt-unsafe
concurrency-thread-canceltype-asynchronous
cppcoreguidelines-avoid-capturing-lambda-coroutines
cppcoreguidelines-avoid-c-arrays
cppcoreguidelines-avoid-const-or-ref-data-members
cppcoreguidelines-avoid-do-while
cppcoreguidelines-avoid-goto
cppcoreguidelines-avoid-magic-numbers
cppcoreguidelines-avoid-non-const-global-variables
cppcoreguidelines-avoid-reference-coroutine-parameters
cppcoreguidelines-c-copy-assignment-signature
cppcoreguidelines-explicit-virtual-functions
cppcoreguidelines-init-variables
cppcoreguidelines-interfaces-global-init
cppcoreguidelines-macro-to-enum
cppcoreguidelines-macro-usage
cppcoreguidelines-misleading-capture-default-by-value
cppcoreguidelines-missing-std-forward
cppcoreguidelines-narrowing-conversions
cppcoreguidelines-noexcept-destructor
cppcoreguidelines-noexcept-move-operations
cppcoreguidelines-noexcept-swap
cppcoreguidelines-no-malloc
cppcoreguidelines-non-private-member-variables-in-classes
cppcoreguidelines-no-suspend-with-lock
cppcoreguidelines-owning-memory
cppcoreguidelines-prefer-member-initializer
cppcoreguidelines-pro-bounds-array-to-pointer-decay
cppcoreguidelines-pro-bounds-avoid-unchecked-container-access
cppcoreguidelines-pro-bounds-constant-array-index
cppcoreguidelines-pro-bounds-pointer-arithmetic
cppcoreguidelines-pro-type-const-cast
cppcoreguidelines-pro-type-cstyle-cast
cppcoreguidelines-pro-type-member-init
cppcoreguidelines-pro-type-reinterpret-cast
cppcoreguidelines-pro-type-static-cast-downcast
cppcoreguidelines-pro-type-union-access
cppcoreguidelines-pro-type-vararg
cppcoreguidelines-rvalue-reference-param-not-moved
cppcoreguidelines-slicing
cppcoreguidelines-special-member-functions
cppcoreguidelines-use-default-member-init
cppcoreguidelines-use-enum-class
cppcoreguidelines-virtual-class-destructor
darwin-avoid-spinlock
darwin-dispatch-once-nonstatic
fuchsia-default-arguments-calls
fuchsia-default-arguments-declarations
fuchsia-header-anon-namespaces
fuchsia-multiple-inheritance
fuchsia-overloaded-operator
fuchsia-statically-constructed-objects
fuchsia-temporary-objects
fuchsia-trailing-return
fuchsia-virtual-inheritance
google-build-explicit-make-pair
google-build-namespaces
google-build-using-namespace
google-default-arguments
google-explicit-constructor
google-global-names-in-headers
google-objc-avoid-nsobject-new
google-objc-avoid-throwing-exception
google-objc-function-naming
google-objc-global-variable-declaration
google-readability-avoid-underscore-in-googletest-name
google-readability-braces-around-statements
google-readability-casting
google-readability-function-size
google-readability-namespace-comments
google-readability-todo
google-runtime-float
google-runtime-int
google-runtime-operator
google-upgrade-googletest-case
hicpp-avoid-c-arrays
hicpp-avoid-goto
hicpp-braces-around-statements
hicpp-deprecated-headers
hicpp-exception-baseclass
hicpp-explicit-conversions
hicpp-function-size
hicpp-ignored-remove-result
hicpp-invalid-access-moved
hicpp-member-init
hicpp-move-const-arg
hicpp-multiway-paths-covered
hicpp-named-parameter
hicpp-new-delete-operators
hicpp-no-array-decay
hicpp-no-assembler
hicpp-noexcept-move
hicpp-no-malloc
hicpp-signed-bitwise
hicpp-special-member-functions
hicpp-static-assert
hicpp-undelegated-constructor
hicpp-uppercase-literal-suffix
hicpp-use-auto
hicpp-use-emplace
hicpp-use-equals-default
hicpp-use-equals-delete
hicpp-use-noexcept
hicpp-use-nullptr
hicpp-use-override
hicpp-vararg
linuxkernel-must-check-errs
llvm-else-after-return
llvm-header-guard
llvm-include-order
llvmlibc-callee-namespace
llvmlibc-implementation-in-namespace
llvmlibc-inline-function-decl
llvmlibc-restrict-system-libc-headers
llvm-namespace-comment
llvm-prefer-isa-or-dyn-cast-in-conditionals
llvm-prefer-register-over-unsigned
llvm-prefer-static-over-anonymous-namespace
llvm-qualified-auto
llvm-twine-local
llvm-use-new-mlir-op-builder
llvm-use-ranges
misc-confusable-identifiers
misc-const-correctness
misc-coroutine-hostile-raii
misc-definitions-in-headers
misc-header-include-cycle
misc-include-cleaner
misc-misleading-bidirectional
misc-misleading-identifier
misc-misplaced-const
misc-new-delete-overloads
misc-non-copyable-objects
misc-non-private-member-variables-in-classes
misc-no-recursion
misc-override-with-different-visibility
misc-predictable-rand
misc-redundant-expression
misc-static-assert
misc-throw-by-value-catch-by-reference
misc-unconventional-assign-operator
misc-uniqueptr-reset-release
misc-unused-alias-decls
misc-unused-parameters
misc-unused-using-decls
misc-use-anonymous-namespace
misc-use-internal-linkage
modernize-avoid-bind
modernize-avoid-c-arrays
modernize-avoid-setjmp-longjmp
modernize-avoid-variadic-functions
modernize-concat-nested-namespaces
modernize-deprecated-headers
modernize-deprecated-ios-base-aliases
modernize-loop-convert
modernize-macro-to-enum
modernize-make-shared
modernize-make-unique
modernize-min-max-use-initializer-list
modernize-pass-by-value
modernize-raw-string-literal
modernize-redundant-void-arg
modernize-replace-auto-ptr
modernize-replace-disallow-copy-and-assign-macro
modernize-replace-random-shuffle
modernize-return-braced-init-list
modernize-shrink-to-fit
modernize-type-traits
modernize-unary-static-assert
modernize-use-auto
modernize-use-bool-literals
modernize-use-constraints
modernize-use-default-member-init
modernize-use-designated-initializers
modernize-use-emplace
modernize-use-equals-default
modernize-use-equals-delete
modernize-use-integer-sign-comparison
modernize-use-nodiscard
modernize-use-noexcept
modernize-use-nullptr
modernize-use-override
modernize-use-ranges
modernize-use-scoped-lock
modernize-use-starts-ends-with
modernize-use-std-format
modernize-use-std-numbers
modernize-use-std-print
modernize-use-trailing-return-type
modernize-use-transparent-functors
modernize-use-uncaught-exceptions
modernize-use-using
mpi-buffer-deref
mpi-type-mismatch
objc-assert-equals
objc-avoid-nserror-init
objc-dealloc-in-category
objc-forbidden-subclassing
objc-missing-hash
objc-nsdate-formatter
objc-nsinvocation-argument-lifetime
objc-property-declaration
objc-super-self
openmp-exception-escape
openmp-use-default-none
performance-avoid-endl
performance-enum-size
performance-faster-string-find
performance-for-range-copy
performance-implicit-conversion-in-loop
performance-inefficient-algorithm
performance-inefficient-string-concatenation
performance-inefficient-vector-operation
performance-move-const-arg
performance-move-constructor-init
performance-no-automatic-move
performance-noexcept-destructor
performance-noexcept-move-constructor
performance-noexcept-swap
performance-no-int-to-ptr
performance-trivially-destructible
performance-type-promotion-in-math-fn
performance-unnecessary-copy-initialization
performance-unnecessary-value-param
portability-avoid-pragma-once
portability-restrict-system-includes
portability-simd-intrinsics
portability-std-allocator-const
portability-template-virtual-member-function
readability-ambiguous-smartptr-reset-call
readability-avoid-const-params-in-decls
readability-avoid-nested-conditional-operator
readability-avoid-return-with-void-value
readability-avoid-unconditional-preprocessor-if
readability-braces-around-statements
readability-const-return-type
readability-container-contains
readability-container-data-pointer
readability-container-size-empty
readability-convert-member-functions-to-static
readability-delete-null-pointer
readability-duplicate-include
readability-else-after-return
readability-enum-initial-value
readability-function-cognitive-complexity
readability-function-size
readability-identifier-length
readability-identifier-naming
readability-implicit-bool-conversion
readability-inconsistent-declaration-parameter-name
readability-isolate-declaration
readability-magic-numbers
readability-make-member-function-const
readability-math-missing-parentheses
readability-misleading-indentation
readability-misplaced-array-index
readability-named-parameter
readability-non-const-parameter
readability-operators-representation
readability-qualified-auto
readability-redundant-access-specifiers
readability-redundant-casting
readability-redundant-control-flow
readability-redundant-declaration
readability-redundant-function-ptr-dereference
readability-redundant-inline-specifier
readability-redundant-member-init
readability-redundant-parentheses
readability-redundant-preprocessor
readability-redundant-smartptr-get
readability-redundant-string-cstr
readability-redundant-string-init
readability-redundant-typename
readability-reference-to-constructed-temporary
readability-simplify-boolean-expr
readability-simplify-subscript-expr
readability-static-accessed-through-instance
readability-static-definition-in-anonymous-namespace
readability-string-compare
readability-suspicious-call-argument
readability-uniqueptr-delete-release
readability-uppercase-literal-suffix
readability-use-anyofallof
readability-use-concise-preprocessor-directives
readability-use-std-min-max
zircon-temporary-objects


================================================
FILE: ClangPowerTools/Automation/update_clang-format.ps1
================================================
<#
.SYNOPSIS
  Download and update clang-format.exe for a given LLVM version.

.DESCRIPTION
  - Downloads the official LLVM Windows installer from GitHub releases:
      https://github.com/llvm/llvm-project/releases/download/llvmorg-<VERSION>/LLVM-<VERSION>-win64.exe
  - Runs the installer silently into a temporary folder.
  - Locates clang-format.exe in the installed tree.
  - Replaces:
      ClangPowerTools/ClangPowerToolsShared/Executables/clang-format.exe

.PARAMETER LlvmVersion
  LLVM version, e.g. "20.1.0" or "21.1.6".

.PARAMETER RepoRoot
  (Optional) Path to the repository root.
  Defaults to one level above the script location.

.EXAMPLE
  .\update-clang-format.ps1 -LlvmVersion 21.1.6
#>

[CmdletBinding()]
param (
    [Parameter(Mandatory = $true)]
    [string] $LlvmVersion,

    [Parameter(Mandatory = $false)]
    [string] $RepoRoot = (Resolve-Path (Join-Path $PSScriptRoot "..")).Path
)

# -------- Config --------

# GitHub tag prefix
$GithubTagPrefix = "llvmorg"

# Asset file name pattern
# Example: LLVM-21.1.6-win64.exe
$AssetFileName = "LLVM-$LlvmVersion-win64.exe"

# Target clang-format path (relative to repo root)
$TargetRelativePath = "ClangPowerTools\ClangPowerToolsShared\Executables\clang-format.exe"

# -------- Derived paths & URLs --------

$tag = "$GithubTagPrefix-$LlvmVersion"
$baseDownloadUrl = "https://github.com/llvm/llvm-project/releases/download/$tag"
$downloadUrl = "$baseDownloadUrl/$AssetFileName"

$targetPath = Join-Path $RepoRoot $TargetRelativePath

# Temp folder for download & installation
$tempRoot = Join-Path ([System.IO.Path]::GetTempPath()) "cpt-update-clang-format-$($LlvmVersion.Replace('.','-'))"
$null = New-Item -ItemType Directory -Path $tempRoot -Force

$downloadPath = Join-Path $tempRoot $AssetFileName
$installDir   = Join-Path $tempRoot "install"

Write-Host "LLVM version      : $LlvmVersion"
Write-Host "GitHub tag        : $tag"
Write-Host "Download URL      : $downloadUrl"
Write-Host "Repository root   : $RepoRoot"
Write-Host "Target exe path   : $targetPath"
Write-Host ""

try {
    # -------- Download installer --------
    Write-Host "Downloading LLVM installer..."
    Invoke-WebRequest -Uri $downloadUrl -OutFile $downloadPath -UseBasicParsing

    if (-not (Test-Path $downloadPath)) {
        throw "Download failed: file not found at $downloadPath"
    }

    # -------- Run installer silently into temp folder --------
    Write-Host "Running installer silently into: $installDir"
    $null = New-Item -ItemType Directory -Path $installDir -Force

    # LLVM Windows installers are NSIS-based, which typically support:
    #   /S              = silent
    #   /D=<path>       = install directory (no quotes, path must be last arg)
    #
    # We pass arguments as a single string where /D= is last.
    $installArgs = "/S /D=$installDir"

    $process = Start-Process -FilePath $downloadPath `
                             -ArgumentList $installArgs `
                             -Wait `
                             -PassThru

    if ($process.ExitCode -ne 0) {
        throw "Installer exited with code $($process.ExitCode)"
    }

    # -------- Locate clang-format.exe --------
    Write-Host "Searching for clang-format.exe in installed files..."
    $clangFormat = Get-ChildItem -Path $installDir -Recurse -Filter "clang-format.exe" |
                   Select-Object -First 1

    if (-not $clangFormat) {
        throw "clang-format.exe not found under $installDir"
    }

    Write-Host "Found clang-format.exe at: $($clangFormat.FullName)"

    # -------- Replace target file --------
    $targetDir = Split-Path $targetPath -Parent
    if (-not (Test-Path $targetDir)) {
        Write-Host "Creating target directory: $targetDir"
        $null = New-Item -ItemType Directory -Path $targetDir -Force
    }

    Write-Host "Copying new clang-format.exe to target..."
    Copy-Item -Path $clangFormat.FullName -Destination $targetPath -Force

    Write-Host ""
    Write-Host " clang-format.exe updated successfully."
    Write-Host "   Version: $LlvmVersion"
    Write-Host "   Location: $targetPath"
}
catch {
    Write-Error " Failed to update clang-format.exe: $_"
}
finally {
    if (Test-Path $tempRoot) {
        Write-Host "Cleaning up temp folder: $tempRoot"
        Remove-Item -Path $tempRoot -Recurse -Force -ErrorAction SilentlyContinue
    }
}


================================================
FILE: ClangPowerTools/CPTReleases/IncrementRevisionNumber.ps1
================================================
param([Parameter(Mandatory=$true, HelpMessage="Increments revision number in manifest file")][string] $loc)

#Get version from xml and increment revision value
$filepath = "$loc\..\ClangPowerTools\source.extension.vsixmanifest"
$filepathToAip = "$loc\..\ClangPowerTools.aip"
if((Test-Path $filepath) -and (Test-Path $filepathToAip))
{
    #Get xml data from manifest file
    [xml] $data = Get-Content $filepath
    $currentVersion = [Version]::new($data.PackageManifest.Metadata.Identity.Version.ToString())
    
    #Get xml data from aip file
    [xml] $aipData = Get-Content $filepathToAip
		
    #Replace old version with new one in manifest
    $data.PackageManifest.Metadata.Identity.Version = $currentVersion.ToString()
    $data.Save("$filepath")

    #Replace old version with new one in aip file
    $aipData.DOCUMENT.COMPONENT[0].ROW[7].Value = $currentVersion.ToString()
    $aipData.Save("$filepathToAip")
    $resultData = Get-Content $filepathToAip -Encoding utf8
    $result = $resultData -replace " />", "/>"
    # $result > $filepathToAip
    $Utf8NoBomEncoding = New-Object System.Text.UTF8Encoding($False)
    [System.IO.File]::WriteAllLines($filepathToAip, $result, $Utf8NoBomEncoding)
}
else 
{
    Write-Error "Invalid manifest file path"    
}




================================================
FILE: ClangPowerTools/ClangPowerTools/ClangPowerTools.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="17.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <MinimumVisualStudioVersion>17.0</MinimumVisualStudioVersion>
    <VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
  </PropertyGroup>
  <PropertyGroup>
    <RuntimeIdentifiers>win</RuntimeIdentifiers>
  </PropertyGroup>
  <PropertyGroup>
    <LangVersion>latest</LangVersion>
  </PropertyGroup>
  <PropertyGroup>
    <SignAssembly>true</SignAssembly>
  </PropertyGroup>
  <PropertyGroup>
    <AssemblyOriginatorKeyFile>Key.snk</AssemblyOriginatorKeyFile>
  </PropertyGroup>
  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
  <PropertyGroup>
    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
    <SchemaVersion>2.0</SchemaVersion>
    <ProjectTypeGuids>{82b43b9b-a64c-4715-b499-d71e9ca2bd60};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
    <ProjectGuid>{51237463-9F4D-44DE-8BC0-587384B9E8B8}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>ClangPowerTools</RootNamespace>
    <AssemblyName>ClangPowerTools</AssemblyName>
    <TargetFrameworkVersion>v4.7.2</TargetFrameworkVersion>
    <GeneratePkgDefFile>true</GeneratePkgDefFile>
    <UseCodebase>true</UseCodebase>
    <IncludeAssemblyInVSIXContainer>true</IncludeAssemblyInVSIXContainer>
    <IncludeDebugSymbolsInVSIXContainer>false</IncludeDebugSymbolsInVSIXContainer>
    <IncludeDebugSymbolsInLocalVSIXDeployment>false</IncludeDebugSymbolsInLocalVSIXDeployment>
    <CopyBuildOutputToOutputDirectory>true</CopyBuildOutputToOutputDirectory>
    <CopyOutputSymbolsToOutputDirectory>true</CopyOutputSymbolsToOutputDirectory>
    <StartAction>Program</StartAction>
    <StartProgram Condition="'$(DevEnvDir)' != ''">$(DevEnvDir)devenv.exe</StartProgram>
    <StartArguments>/rootsuffix Exp</StartArguments>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
    <DebugSymbols>true</DebugSymbols>
    <DebugType>full</DebugType>
    <Optimize>false</Optimize>
    <OutputPath>bin\Debug\</OutputPath>
    <DefineConstants>DEBUG;TRACE</DefineConstants>
    <ErrorReport>prompt</ErrorReport>
    <WarningLevel>4</WarningLevel>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
    <DebugType>pdbonly</DebugType>
    <Optimize>true</Optimize>
    <OutputPath>bin\Release\</OutputPath>
    <DefineConstants>TRACE</DefineConstants>
    <ErrorReport>prompt</ErrorReport>
    <WarningLevel>4</WarningLevel>
  </PropertyGroup>
  <ItemGroup>
    <Compile Include="..\ClangPowerToolsShared\MVVM\Views\ToolWindows\TidyToolWindow.cs">
      <Link>MVVM\Views\TidyToolWindow.cs</Link>
    </Compile>
    <Compile Include="..\ClangPowerToolsShared\MVVM\Views\ToolWindows\FindToolWindow.cs">
      <Link>MVVM\Views\FindToolWindow.cs</Link>
    </Compile>
    <Compile Include="ClangPowerToolsPackage.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
    <Compile Include="Properties\Resource.Designer.cs">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>Resource.resx</DependentUpon>
    </Compile>
  </ItemGroup>
  <ItemGroup>
    <Resource Include="..\ClangPowerToolsShared\Resources\[CPT]OptimizeIncludes.png">
      <Link>Resources\[CPT]OptimizeIncludes.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\TidyToolWindow\[CPT]Pinned.png">
      <Link>Resources\TidyToolWindow\[CPT]Pinned.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\TidyToolWindow\[CPT]UnPinned.png">
      <Link>Resources\TidyToolWindow\[CPT]UnPinned.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\TidyToolWindow\[CTP]Pinned_dark.png">
      <Link>Resources\TidyToolWindow\[CTP]Pinned_dark.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\TidyToolWindow\[CTP]UnPinned_dark.png">
      <Link>Resources\TidyToolWindow\[CTP]UnPinned_dark.png</Link>
    </Resource>
    <Content Include="Resources\[CPT]Find.png" />
    <Resource Include="..\ClangPowerToolsShared\Resources\TidyToolWindow\[CPT]Diff2.png">
      <Link>Resources\TidyToolWindow\[CPT]Diff2.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\TidyToolWindow\[CPT]Diff_dark.png">
      <Link>Resources\TidyToolWindow\[CPT]Diff_dark.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\TidyToolWindow\[CPT]Diff_disabled.png">
      <Link>Resources\TidyToolWindow\[CPT]Diff_disabled.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\TidyToolWindow\[CPT]Fix.png">
      <Link>Resources\TidyToolWindow\[CPT]Fix.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\TidyToolWindow\[CPT]Fix_dark.png">
      <Link>Resources\TidyToolWindow\[CPT]Fix_dark.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\TidyToolWindow\[CPT]Fix_disabled.png">
      <Link>Resources\TidyToolWindow\[CPT]Fix_disabled.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\TidyToolWindow\[CPT]Refresh-Tidy.png">
      <Link>Resources\TidyToolWindow\[CPT]Refresh-Tidy.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\TidyToolWindow\[CPT]Refresh_dark.png">
      <Link>Resources\TidyToolWindow\[CPT]Refresh_dark.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\TidyToolWindow\[CPT]Refresh_disabled.png">
      <Link>Resources\TidyToolWindow\[CPT]Refresh_disabled.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\TidyToolWindow\[CPT]Remove.png">
      <Link>Resources\TidyToolWindow\[CPT]Remove.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\TidyToolWindow\[CPT]RemoveFix.png">
      <Link>Resources\TidyToolWindow\[CPT]RemoveFix.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\TidyToolWindow\[CPT]RemoveFix_dark.png">
      <Link>Resources\TidyToolWindow\[CPT]RemoveFix_dark.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\TidyToolWindow\[CPT]RemoveFix_disabled.png">
      <Link>Resources\TidyToolWindow\[CPT]RemoveFix_disabled.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\TidyToolWindow\[CPT]Remove_dark.png">
      <Link>Resources\TidyToolWindow\[CPT]Remove_dark.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\TidyToolWindow\[CPT]Remove_disabled.png">
      <Link>Resources\TidyToolWindow\[CPT]Remove_disabled.png</Link>
    </Resource>
    <Content Include="ClangPowerToolsLib16.dll">
      <IncludeInVSIX>true</IncludeInVSIX>
      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
    </Content>
    <Content Include="ClangPowerToolsLib17.dll">
      <IncludeInVSIX>true</IncludeInVSIX>
      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
    </Content>
    <Resource Include="..\ClangPowerToolsShared\Resources\SettingsBackground.png">
      <Link>Resources\SettingsBackground.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\AccountAvatarIcon.png">
      <Link>Resources\AccountAvatarIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\AccountIcon.png">
      <Link>Resources\AccountIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\AddInput.png">
      <Link>Resources\AddInput.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\BannerInfo.png">
      <Link>Resources\BannerInfo.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\BannersError.png">
      <Link>Resources\BannersError.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\bannerWarning.png">
      <Link>Resources\bannerWarning.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\Browse.png">
      <Link>Resources\Browse.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\ClangFormatIcon.png">
      <Link>Resources\ClangFormatIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\ClangPowerToolsIco.ico">
      <Link>Resources\ClangPowerToolsIco.ico</Link>
      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\ClangSplitBackground.png">
      <Link>Resources\ClangSplitBackground.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\CleanSearchIcon.PNG">
      <Link>Resources\CleanSearchIcon.PNG</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\CloudIcon.png">
      <Link>Resources\CloudIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\CodeInputIcon.png">
      <Link>Resources\CodeInputIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\CompileIcon.png">
      <Link>Resources\CompileIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\CPTLogo.png">
      <Link>Resources\CPTLogo.png</Link>
    </Resource>
    <Content Include="..\ClangPowerToolsShared\Executables\clang-format.exe">
      <Link>Executables\clang-format.exe</Link>
      <IncludeInVSIX>true</IncludeInVSIX>
      <VSIXSubPath>.</VSIXSubPath>
    </Content>
    <Content Include="..\ClangPowerToolsShared\Executables\Clang Format Editor.msi">
      <Link>Executables\Clang Format Editor.msi</Link>
      <IncludeInVSIX>true</IncludeInVSIX>
      <VSIXSubPath>.</VSIXSubPath>
    </Content>
    <Content Include="..\ClangPowerToolsShared\Resources\CPTLogoManageExtensionVS.png">
      <Link>Resources\CPTLogoManageExtensionVS.png</Link>
      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
      <IncludeInVSIX>true</IncludeInVSIX>
    </Content>
    <Resource Include="..\ClangPowerToolsShared\Resources\DetectOnFileIcon.png">
      <Link>Resources\DetectOnFileIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\EmptyIcon.png">
      <Link>Resources\EmptyIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\ErrorIcon.png">
      <Link>Resources\ErrorIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\FeedbackIcon.png">
      <Link>Resources\FeedbackIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\FileIcon.png">
      <Link>Resources\FileIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\GenerateClangFormatFile.png">
      <Link>Resources\GenerateClangFormatFile.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\GitHubMark.png">
      <Link>Resources\GitHubMark.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\iconCommercial.png">
      <Link>Resources\iconCommercial.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\iconFreeTrial.png">
      <Link>Resources\iconFreeTrial.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\iconPersonal.png">
      <Link>Resources\iconPersonal.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\IgnoreIcon.png">
      <Link>Resources\IgnoreIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\InfoIcon.png">
      <Link>Resources\InfoIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\JsonCompilationDatabase.png">
      <Link>Resources\JsonCompilationDatabase.png</Link>
    </Resource>
    <Content Include="..\ClangPowerToolsShared\Resources\LICENSE.txt">
      <Link>Resources\LICENSE.txt</Link>
      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
      <IncludeInVSIX>true</IncludeInVSIX>
    </Content>
    <Resource Include="..\ClangPowerToolsShared\Resources\LoginBackground.png">
      <Link>Resources\LoginBackground.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\LogoutIcon.png">
      <Link>Resources\LogoutIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\PreviewWhiteIcon.png">
      <Link>Resources\PreviewWhiteIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\ProjectFilesIcon.png">
      <Link>Resources\ProjectFilesIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\ReleaseNotesBackground.png">
      <Link>Resources\ReleaseNotesBackground.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\RemoveInputHover.png">
      <Link>Resources\RemoveInputHover.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\RemoveInputIdle.png">
      <Link>Resources\RemoveInputIdle.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\ResetIcon.png">
      <Link>Resources\ResetIcon.png</Link>
    </Resource>
    <Content Include="..\ClangPowerToolsShared\Resources\RunPowerShellCommandPackage.ico">
      <Link>Resources\RunPowerShellCommandPackage.ico</Link>
      <IncludeInVSIX>true</IncludeInVSIX>
    </Content>
    <Resource Include="..\ClangPowerToolsShared\Resources\SearchIcon.PNG">
      <Link>Resources\SearchIcon.PNG</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\SettingsIcon.png">
      <Link>Resources\SettingsIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\SettingsLLVM.png">
      <Link>Resources\SettingsLLVM.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\StopCommandIcon.png">
      <Link>Resources\StopCommandIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\StorageIcon.png">
      <Link>Resources\StorageIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\TidyIcon.png">
      <Link>Resources\TidyIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\WarningIcon.png">
      <Link>Resources\WarningIcon.png</Link>
    </Resource>
    <Content Include="..\ClangPowerToolsShared\Tooling\v1\clang-build.ps1">
      <Link>Tooling\v1\clang-build.ps1</Link>
      <IncludeInVSIX>true</IncludeInVSIX>
    </Content>
    <Content Include="..\ClangPowerToolsShared\Tooling\v1\psClang\get-llvm-helper.ps1">
      <Link>Tooling\v1\psClang\get-llvm-helper.ps1</Link>
      <IncludeInVSIX>true</IncludeInVSIX>
    </Content>
    <Content Include="..\ClangPowerToolsShared\Tooling\v1\psClang\get-llvm.ps1">
      <Link>Tooling\v1\psClang\get-llvm.ps1</Link>
      <IncludeInVSIX>true</IncludeInVSIX>
    </Content>
    <Content Include="..\ClangPowerToolsShared\Tooling\v1\psClang\get-header-references.ps1">
      <Link>Tooling\v1\psClang\get-header-references.ps1</Link>
      <IncludeInVSIX>true</IncludeInVSIX>
    </Content>
    <Content Include="..\ClangPowerToolsShared\Tooling\v1\psClang\io.ps1">
      <Link>Tooling\v1\psClang\io.ps1</Link>
      <IncludeInVSIX>true</IncludeInVSIX>
    </Content>
    <Content Include="..\ClangPowerToolsShared\Tooling\v1\psClang\itemdefinition-context.ps1">
      <Link>Tooling\v1\psClang\itemdefinition-context.ps1</Link>
      <IncludeInVSIX>true</IncludeInVSIX>
    </Content>
    <Content Include="..\ClangPowerToolsShared\Tooling\v1\psClang\jsondb-export.ps1">
      <Link>Tooling\v1\psClang\jsondb-export.ps1</Link>
      <IncludeInVSIX>true</IncludeInVSIX>
    </Content>
    <Content Include="..\ClangPowerToolsShared\Tooling\v1\psClang\msbuild-expression-eval.ps1">
      <Link>Tooling\v1\psClang\msbuild-expression-eval.ps1</Link>
      <IncludeInVSIX>true</IncludeInVSIX>
    </Content>
    <Content Include="..\ClangPowerToolsShared\Tooling\v1\psClang\msbuild-project-data.ps1">
      <Link>Tooling\v1\psClang\msbuild-project-data.ps1</Link>
      <IncludeInVSIX>true</IncludeInVSIX>
    </Content>
    <Content Include="..\ClangPowerToolsShared\Tooling\v1\psClang\msbuild-project-load.ps1">
      <Link>Tooling\v1\psClang\msbuild-project-load.ps1</Link>
      <IncludeInVSIX>true</IncludeInVSIX>
    </Content>
    <Content Include="..\ClangPowerToolsShared\Tooling\v1\psClang\visualstudio-detection.ps1">
      <Link>Tooling\v1\psClang\visualstudio-detection.ps1</Link>
      <IncludeInVSIX>true</IncludeInVSIX>
    </Content>
    <Content Include="..\ClangPowerToolsShared\Tooling\v1\psclang\msbuild-project-cache-repository.ps1">
      <Link>Tooling\v1\psClang\msbuild-project-cache-repository.ps1</Link>
      <IncludeInVSIX>true</IncludeInVSIX>
    </Content>
    <None Include="Key.snk" />
    <None Include="source.extension.vsixmanifest">
      <SubType>Designer</SubType>
    </None>
  </ItemGroup>
  <ItemGroup>
    <Reference Include="PresentationCore" />
    <Reference Include="PresentationFramework" />
    <Reference Include="System" />
    <Reference Include="System.Data" />
    <Reference Include="System.Design" />
    <Reference Include="System.Runtime.Serialization" />
    <Reference Include="System.Windows" />
    <Reference Include="System.Windows.Forms" />
    <Reference Include="System.Xaml" />
    <Reference Include="System.Xml" />
    <Reference Include="System.Xml.Linq" />
    <Reference Include="WindowsBase" />
  </ItemGroup>
  <ItemGroup>
    <PackageReference Include="Microsoft.VisualStudio.SDK" Version="15.0.1" />
    <PackageReference Include="Microsoft.VisualStudio.Shell.Framework" Version="15.9.28307" />
    <PackageReference Include="Microsoft.VSSDK.BuildTools" Version="17.3.2094">
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
      <PrivateAssets>all</PrivateAssets>
    </PackageReference>
    <PackageReference Include="System.ComponentModel.Annotations">
      <Version>5.0.0</Version>
    </PackageReference>
    <PackageReference Include="System.Management">
      <Version>5.0.0</Version>
    </PackageReference>
  </ItemGroup>
  <ItemGroup>
    <VSCTCompile Include="ClangPowerTools.vsct">
      <ResourceName>Menus.ctmenu</ResourceName>
      <SubType>Designer</SubType>
    </VSCTCompile>
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="Properties\Resource.resx">
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>Resource.Designer.cs</LastGenOutput>
      <SubType>Designer</SubType>
    </EmbeddedResource>
    <EmbeddedResource Include="VSPackage.resx">
      <SubType>Designer</SubType>
    </EmbeddedResource>
  </ItemGroup>
  <ItemGroup>
    <Page Include="..\ClangPowerToolsShared\MVVM\Views\Styles\AppResources.xaml">
      <Link>MVVM\Views\Styles\AppResources.xaml</Link>
      <Generator>MSBuild:Compile</Generator>
      <SubType>Designer</SubType>
    </Page>
    <Page Include="..\ClangPowerToolsShared\MVVM\Views\Styles\HyperlinkStyle.xaml">
      <Link>MVVM\Views\Styles\HyperlinkStyle.xaml</Link>
      <Generator>MSBuild:Compile</Generator>
      <SubType>Designer</SubType>
    </Page>
    <Page Include="..\ClangPowerToolsShared\MVVM\Views\Styles\ImageResources.xaml">
      <Link>MVVM\Views\Styles\ImageResources.xaml</Link>
      <Generator>MSBuild:Compile</Generator>
      <SubType>Designer</SubType>
    </Page>
    <Page Include="..\ClangPowerToolsShared\MVVM\Views\Styles\SettingsButtonStyle.xaml">
      <Link>MVVM\Views\Styles\SettingsButtonStyle.xaml</Link>
      <Generator>MSBuild:Compile</Generator>
      <SubType>Designer</SubType>
    </Page>
    <Page Include="..\ClangPowerToolsShared\MVVM\Views\Styles\SettingsComboBoxStyle.xaml">
      <Link>MVVM\Views\Styles\SettingsComboBoxStyle.xaml</Link>
      <Generator>MSBuild:Compile</Generator>
      <SubType>Designer</SubType>
    </Page>
    <Page Include="..\ClangPowerToolsShared\MVVM\Views\Styles\ToggleStyle.xaml">
      <Link>MVVM\Views\Styles\ToggleStyle.xaml</Link>
      <Generator>MSBuild:Compile</Generator>
      <SubType>Designer</SubType>
    </Page>
    <Page Include="..\ClangPowerToolsShared\MVVM\Views\Styles\YellowButtonStyle.xaml">
      <Link>MVVM\Views\Styles\YellowButtonStyle.xaml</Link>
      <Generator>MSBuild:Compile</Generator>
      <SubType>Designer</SubType>
    </Page>
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  <Import Project="$(VSToolsPath)\VSSDK\Microsoft.VsSDK.targets" Condition="'$(VSToolsPath)' != ''" />
  <PropertyGroup>
    <PostBuildEvent>
    </PostBuildEvent>
  </PropertyGroup>
  <PropertyGroup>
    <PostBuildEvent>
    </PostBuildEvent>
  </PropertyGroup>
  <PropertyGroup>
    <PreBuildEvent>powershell.exe -executionPolicy Bypass -WindowStyle Hidden -file "$(SolutionDir)CPTReleases\IncrementRevisionNumber.ps1" -loc "$(SolutionDir)CPTReleases"</PreBuildEvent>
  </PropertyGroup>
</Project>

================================================
FILE: ClangPowerTools/ClangPowerTools/ClangPowerTools.csproj.bak
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="17.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <MinimumVisualStudioVersion>17.0</MinimumVisualStudioVersion>
    <VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
  </PropertyGroup>
  <PropertyGroup>
    <RuntimeIdentifiers>win</RuntimeIdentifiers>
  </PropertyGroup>
  <PropertyGroup>
    <LangVersion>latest</LangVersion>
  </PropertyGroup>
  <PropertyGroup>
    <SignAssembly>true</SignAssembly>
  </PropertyGroup>
  <PropertyGroup>
    <AssemblyOriginatorKeyFile>Key.snk</AssemblyOriginatorKeyFile>
  </PropertyGroup>
  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
  <PropertyGroup>
    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
    <SchemaVersion>2.0</SchemaVersion>
    <ProjectTypeGuids>{82b43b9b-a64c-4715-b499-d71e9ca2bd60};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
    <ProjectGuid>{51237463-9F4D-44DE-8BC0-587384B9E8B8}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>ClangPowerTools</RootNamespace>
    <AssemblyName>ClangPowerTools</AssemblyName>
    <TargetFrameworkVersion>v4.7.2</TargetFrameworkVersion>
    <GeneratePkgDefFile>true</GeneratePkgDefFile>
    <UseCodebase>true</UseCodebase>
    <IncludeAssemblyInVSIXContainer>true</IncludeAssemblyInVSIXContainer>
    <IncludeDebugSymbolsInVSIXContainer>false</IncludeDebugSymbolsInVSIXContainer>
    <IncludeDebugSymbolsInLocalVSIXDeployment>false</IncludeDebugSymbolsInLocalVSIXDeployment>
    <CopyBuildOutputToOutputDirectory>true</CopyBuildOutputToOutputDirectory>
    <CopyOutputSymbolsToOutputDirectory>true</CopyOutputSymbolsToOutputDirectory>
    <StartAction>Program</StartAction>
    <StartProgram Condition="'$(DevEnvDir)' != ''">$(DevEnvDir)devenv.exe</StartProgram>
    <StartArguments>/rootsuffix Exp</StartArguments>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
    <DebugSymbols>true</DebugSymbols>
    <DebugType>full</DebugType>
    <Optimize>false</Optimize>
    <OutputPath>bin\Debug\</OutputPath>
    <DefineConstants>DEBUG;TRACE</DefineConstants>
    <ErrorReport>prompt</ErrorReport>
    <WarningLevel>4</WarningLevel>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
    <DebugType>pdbonly</DebugType>
    <Optimize>true</Optimize>
    <OutputPath>bin\Release\</OutputPath>
    <DefineConstants>TRACE</DefineConstants>
    <ErrorReport>prompt</ErrorReport>
    <WarningLevel>4</WarningLevel>
  </PropertyGroup>
  <ItemGroup>
    <Compile Include="..\ClangPowerToolsShared\MVVM\Views\ToolWindows\TidyToolWindow.cs">
      <Link>MVVM\Views\TidyToolWindow.cs</Link>
    </Compile>
    <Compile Include="ClangPowerToolsPackage.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
    <Compile Include="Properties\Resource.Designer.cs">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>Resource.resx</DependentUpon>
    </Compile>
  </ItemGroup>
  <ItemGroup>
    <Content Include="Resources\[CPT]GenerateDocumentation.png" />
    <Resource Include="..\ClangPowerToolsShared\Resources\TidyToolWindow\[CPT]Diff2.png">
      <Link>Resources\TidyToolWindow\[CPT]Diff2.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\TidyToolWindow\[CPT]Diff_dark.png">
      <Link>Resources\TidyToolWindow\[CPT]Diff_dark.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\TidyToolWindow\[CPT]Diff_disabled.png">
      <Link>Resources\TidyToolWindow\[CPT]Diff_disabled.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\TidyToolWindow\[CPT]Fix.png">
      <Link>Resources\TidyToolWindow\[CPT]Fix.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\TidyToolWindow\[CPT]Fix_dark.png">
      <Link>Resources\TidyToolWindow\[CPT]Fix_dark.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\TidyToolWindow\[CPT]Fix_disabled.png">
      <Link>Resources\TidyToolWindow\[CPT]Fix_disabled.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\TidyToolWindow\[CPT]Refresh-Tidy.png">
      <Link>Resources\TidyToolWindow\[CPT]Refresh-Tidy.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\TidyToolWindow\[CPT]Refresh_dark.png">
      <Link>Resources\TidyToolWindow\[CPT]Refresh_dark.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\TidyToolWindow\[CPT]Refresh_disabled.png">
      <Link>Resources\TidyToolWindow\[CPT]Refresh_disabled.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\TidyToolWindow\[CPT]Remove.png">
      <Link>Resources\TidyToolWindow\[CPT]Remove.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\TidyToolWindow\[CPT]RemoveFix.png">
      <Link>Resources\TidyToolWindow\[CPT]RemoveFix.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\TidyToolWindow\[CPT]RemoveFix_dark.png">
      <Link>Resources\TidyToolWindow\[CPT]RemoveFix_dark.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\TidyToolWindow\[CPT]RemoveFix_disabled.png">
      <Link>Resources\TidyToolWindow\[CPT]RemoveFix_disabled.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\TidyToolWindow\[CPT]Remove_dark.png">
      <Link>Resources\TidyToolWindow\[CPT]Remove_dark.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\TidyToolWindow\[CPT]Remove_disabled.png">
      <Link>Resources\TidyToolWindow\[CPT]Remove_disabled.png</Link>
    </Resource>
    <Content Include="ClangPowerToolsLib16.dll">
      <IncludeInVSIX>true</IncludeInVSIX>
      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
    </Content>
    <Content Include="ClangPowerToolsLib17.dll">
      <IncludeInVSIX>true</IncludeInVSIX>
      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
    </Content>
    <Resource Include="..\ClangPowerToolsShared\Resources\SettingsBackground.png">
      <Link>Resources\SettingsBackground.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\AccountAvatarIcon.png">
      <Link>Resources\AccountAvatarIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\AccountIcon.png">
      <Link>Resources\AccountIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\AddInput.png">
      <Link>Resources\AddInput.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\BannerInfo.png">
      <Link>Resources\BannerInfo.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\BannersError.png">
      <Link>Resources\BannersError.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\bannerWarning.png">
      <Link>Resources\bannerWarning.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\Browse.png">
      <Link>Resources\Browse.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\ClangFormatIcon.png">
      <Link>Resources\ClangFormatIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\ClangPowerToolsIco.ico">
      <Link>Resources\ClangPowerToolsIco.ico</Link>
      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\ClangSplitBackground.png">
      <Link>Resources\ClangSplitBackground.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\CleanSearchIcon.PNG">
      <Link>Resources\CleanSearchIcon.PNG</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\CloudIcon.png">
      <Link>Resources\CloudIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\CodeInputIcon.png">
      <Link>Resources\CodeInputIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\CompileIcon.png">
      <Link>Resources\CompileIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\CPTLogo.png">
      <Link>Resources\CPTLogo.png</Link>
    </Resource>
    <Content Include="..\ClangPowerToolsShared\Executables\clang-format.exe">
      <Link>Executables\clang-format.exe</Link>
      <IncludeInVSIX>true</IncludeInVSIX>
      <VSIXSubPath>.</VSIXSubPath>
    </Content>
    <Content Include="..\ClangPowerToolsShared\Executables\ClangFormatEditor.exe">
      <Link>Executables\ClangFormatEditor.exe</Link>
      <IncludeInVSIX>true</IncludeInVSIX>
      <VSIXSubPath>.</VSIXSubPath>
    </Content>
    <Content Include="..\ClangPowerToolsShared\Resources\CPTLogoManageExtensionVS.png">
      <Link>Resources\CPTLogoManageExtensionVS.png</Link>
      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
      <IncludeInVSIX>true</IncludeInVSIX>
    </Content>
    <Resource Include="..\ClangPowerToolsShared\Resources\DetectOnFileIcon.png">
      <Link>Resources\DetectOnFileIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\EmptyIcon.png">
      <Link>Resources\EmptyIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\ErrorIcon.png">
      <Link>Resources\ErrorIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\FeedbackIcon.png">
      <Link>Resources\FeedbackIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\FileIcon.png">
      <Link>Resources\FileIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\GenerateClangFormatFile.png">
      <Link>Resources\GenerateClangFormatFile.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\GitHubMark.png">
      <Link>Resources\GitHubMark.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\iconCommercial.png">
      <Link>Resources\iconCommercial.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\iconFreeTrial.png">
      <Link>Resources\iconFreeTrial.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\iconPersonal.png">
      <Link>Resources\iconPersonal.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\IgnoreIcon.png">
      <Link>Resources\IgnoreIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\InfoIcon.png">
      <Link>Resources\InfoIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\JsonCompilationDatabase.png">
      <Link>Resources\JsonCompilationDatabase.png</Link>
    </Resource>
    <Content Include="..\ClangPowerToolsShared\Resources\LICENSE.txt">
      <Link>Resources\LICENSE.txt</Link>
      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
      <IncludeInVSIX>true</IncludeInVSIX>
    </Content>
    <Resource Include="..\ClangPowerToolsShared\Resources\LoginBackground.png">
      <Link>Resources\LoginBackground.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\LogoutIcon.png">
      <Link>Resources\LogoutIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\PreviewWhiteIcon.png">
      <Link>Resources\PreviewWhiteIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\ProjectFilesIcon.png">
      <Link>Resources\ProjectFilesIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\ReleaseNotesBackground.png">
      <Link>Resources\ReleaseNotesBackground.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\RemoveInputHover.png">
      <Link>Resources\RemoveInputHover.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\RemoveInputIdle.png">
      <Link>Resources\RemoveInputIdle.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\ResetIcon.png">
      <Link>Resources\ResetIcon.png</Link>
    </Resource>
    <Content Include="..\ClangPowerToolsShared\Resources\RunPowerShellCommandPackage.ico">
      <Link>Resources\RunPowerShellCommandPackage.ico</Link>
      <IncludeInVSIX>true</IncludeInVSIX>
    </Content>
    <Resource Include="..\ClangPowerToolsShared\Resources\SearchIcon.PNG">
      <Link>Resources\SearchIcon.PNG</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\SettingsIcon.png">
      <Link>Resources\SettingsIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\SettingsLLVM.png">
      <Link>Resources\SettingsLLVM.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\StopCommandIcon.png">
      <Link>Resources\StopCommandIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\StorageIcon.png">
      <Link>Resources\StorageIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\TeamIcon.png">
      <Link>Resources\TeamIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\TidyIcon.png">
      <Link>Resources\TidyIcon.png</Link>
    </Resource>
    <Resource Include="..\ClangPowerToolsShared\Resources\WarningIcon.png">
      <Link>Resources\WarningIcon.png</Link>
    </Resource>
    <Content Include="..\ClangPowerToolsShared\Tooling\v1\clang-build.ps1">
      <Link>Tooling\v1\clang-build.ps1</Link>
      <IncludeInVSIX>true</IncludeInVSIX>
    </Content>
    <Content Include="..\ClangPowerToolsShared\Tooling\v1\psClang\get-llvm-helper.ps1">
      <Link>Tooling\v1\psClang\get-llvm-helper.ps1</Link>
      <IncludeInVSIX>true</IncludeInVSIX>
    </Content>
    <Content Include="..\ClangPowerToolsShared\Tooling\v1\psClang\get-llvm.ps1">
      <Link>Tooling\v1\psClang\get-llvm.ps1</Link>
      <IncludeInVSIX>true</IncludeInVSIX>
    </Content>
    <Content Include="..\ClangPowerToolsShared\Tooling\v1\psClang\get-header-references.ps1">
      <Link>Tooling\v1\psClang\get-header-references.ps1</Link>
      <IncludeInVSIX>true</IncludeInVSIX>
    </Content>
    <Content Include="..\ClangPowerToolsShared\Tooling\v1\psClang\io.ps1">
      <Link>Tooling\v1\psClang\io.ps1</Link>
      <IncludeInVSIX>true</IncludeInVSIX>
    </Content>
    <Content Include="..\ClangPowerToolsShared\Tooling\v1\psClang\itemdefinition-context.ps1">
      <Link>Tooling\v1\psClang\itemdefinition-context.ps1</Link>
      <IncludeInVSIX>true</IncludeInVSIX>
    </Content>
    <Content Include="..\ClangPowerToolsShared\Tooling\v1\psClang\jsondb-export.ps1">
      <Link>Tooling\v1\psClang\jsondb-export.ps1</Link>
      <IncludeInVSIX>true</IncludeInVSIX>
    </Content>
    <Content Include="..\ClangPowerToolsShared\Tooling\v1\psClang\msbuild-expression-eval.ps1">
      <Link>Tooling\v1\psClang\msbuild-expression-eval.ps1</Link>
      <IncludeInVSIX>true</IncludeInVSIX>
    </Content>
    <Content Include="..\ClangPowerToolsShared\Tooling\v1\psClang\msbuild-project-data.ps1">
      <Link>Tooling\v1\psClang\msbuild-project-data.ps1</Link>
      <IncludeInVSIX>true</IncludeInVSIX>
    </Content>
    <Content Include="..\ClangPowerToolsShared\Tooling\v1\psClang\msbuild-project-load.ps1">
      <Link>Tooling\v1\psClang\msbuild-project-load.ps1</Link>
      <IncludeInVSIX>true</IncludeInVSIX>
    </Content>
    <Content Include="..\ClangPowerToolsShared\Tooling\v1\psClang\visualstudio-detection.ps1">
      <Link>Tooling\v1\psClang\visualstudio-detection.ps1</Link>
      <IncludeInVSIX>true</IncludeInVSIX>
    </Content>
    <Content Include="..\ClangPowerToolsShared\Tooling\v1\psclang\msbuild-project-cache-repository.ps1">
      <Link>Tooling\v1\psClang\msbuild-project-cache-repository.ps1</Link>
      <IncludeInVSIX>true</IncludeInVSIX>
    </Content>
    <None Include="Key.snk" />
    <None Include="source.extension.vsixmanifest">
      <SubType>Designer</SubType>
    </None>
  </ItemGroup>
  <ItemGroup>
    <Reference Include="PresentationCore" />
    <Reference Include="PresentationFramework" />
    <Reference Include="System" />
    <Reference Include="System.Data" />
    <Reference Include="System.Design" />
    <Reference Include="System.Runtime.Serialization" />
    <Reference Include="System.Windows" />
    <Reference Include="System.Windows.Forms" />
    <Reference Include="System.Xaml" />
    <Reference Include="System.Xml" />
    <Reference Include="System.Xml.Linq" />
    <Reference Include="WindowsBase" />
  </ItemGroup>
  <ItemGroup>
    <PackageReference Include="Microsoft.VisualStudio.SDK" Version="15.0.1" />
    <PackageReference Include="Microsoft.VisualStudio.Shell.Framework" Version="15.9.28307" />
    <PackageReference Include="Microsoft.VSSDK.BuildTools" Version="17.0.3155-preview3">
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
      <PrivateAssets>all</PrivateAssets>
    </PackageReference>
    <PackageReference Include="System.ComponentModel.Annotations">
      <Version>5.0.0</Version>
    </PackageReference>
    <PackageReference Include="System.Management">
      <Version>5.0.0</Version>
    </PackageReference>
  </ItemGroup>
  <ItemGroup>
    <VSCTCompile Include="ClangPowerTools.vsct">
      <ResourceName>Menus.ctmenu</ResourceName>
      <SubType>Designer</SubType>
    </VSCTCompile>
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="Properties\Resource.resx">
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>Resource.Designer.cs</LastGenOutput>
    </EmbeddedResource>
    <EmbeddedResource Include="VSPackage.resx">
      <SubType>Designer</SubType>
    </EmbeddedResource>
  </ItemGroup>
  <ItemGroup>
    <Page Include="..\ClangPowerToolsShared\MVVM\Views\Styles\AppResources.xaml">
      <Link>MVVM\Views\Styles\AppResources.xaml</Link>
      <Generator>MSBuild:Compile</Generator>
      <SubType>Designer</SubType>
    </Page>
    <Page Include="..\ClangPowerToolsShared\MVVM\Views\Styles\HyperlinkStyle.xaml">
      <Link>MVVM\Views\Styles\HyperlinkStyle.xaml</Link>
      <Generator>MSBuild:Compile</Generator>
      <SubType>Designer</SubType>
    </Page>
    <Page Include="..\ClangPowerToolsShared\MVVM\Views\Styles\ImageResources.xaml">
      <Link>MVVM\Views\Styles\ImageResources.xaml</Link>
      <Generator>MSBuild:Compile</Generator>
      <SubType>Designer</SubType>
    </Page>
    <Page Include="..\ClangPowerToolsShared\MVVM\Views\Styles\SettingsButtonStyle.xaml">
      <Link>MVVM\Views\Styles\SettingsButtonStyle.xaml</Link>
      <Generator>MSBuild:Compile</Generator>
      <SubType>Designer</SubType>
    </Page>
    <Page Include="..\ClangPowerToolsShared\MVVM\Views\Styles\SettingsComboBoxStyle.xaml">
      <Link>MVVM\Views\Styles\SettingsComboBoxStyle.xaml</Link>
      <Generator>MSBuild:Compile</Generator>
      <SubType>Designer</SubType>
    </Page>
    <Page Include="..\ClangPowerToolsShared\MVVM\Views\Styles\ToggleStyle.xaml">
      <Link>MVVM\Views\Styles\ToggleStyle.xaml</Link>
      <Generator>MSBuild:Compile</Generator>
      <SubType>Designer</SubType>
    </Page>
    <Page Include="..\ClangPowerToolsShared\MVVM\Views\Styles\YellowButtonStyle.xaml">
      <Link>MVVM\Views\Styles\YellowButtonStyle.xaml</Link>
      <Generator>MSBuild:Compile</Generator>
      <SubType>Designer</SubType>
    </Page>
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  <Import Project="$(VSToolsPath)\VSSDK\Microsoft.VsSDK.targets" Condition="'$(VSToolsPath)' != ''" />
  <PropertyGroup>
    <PostBuildEvent>
    </PostBuildEvent>
  </PropertyGroup>
  <PropertyGroup>
    <PostBuildEvent>
    </PostBuildEvent>
  </PropertyGroup>
  <PropertyGroup>
    <PreBuildEvent>powershell.exe -executionPolicy Bypass -WindowStyle Hidden -file "$(SolutionDir)CPTReleases\IncrementRevisionNumber.ps1" -loc "$(SolutionDir)CPTReleases"</PreBuildEvent>
  </PropertyGroup>
</Project>

================================================
FILE: ClangPowerTools/ClangPowerTools/ClangPowerTools.vsct
================================================
<?xml version="1.0" encoding="utf-8"?>
<CommandTable xmlns="http://schemas.microsoft.com/VisualStudio/2005-10-18/CommandTable" xmlns:xs="http://www.w3.org/2001/XMLSchema">

	<Extern href="stdidcmd.h" />
	<Extern href="vsshlids.h" />
	<Commands package="guidClangPowerToolsPackage">

		<Menus>
			<!--Context menu-->
			<Menu guid="guidClangPowerToolsPackageCmdSet" id="Submenu" priority="0x0000" type="Menu">
				<Parent guid="guidClangPowerToolsPackageCmdSet" id="GroupForSubmenu" />
				<Strings>
					<ButtonText>Clang Power Tools</ButtonText>
				</Strings>
			</Menu>

			<!--Toolbar menu-->
			<Menu guid="guidClangPowerToolsPackageCmdSet" id="Toolbar" type="Toolbar">
				<CommandFlag>DefaultDocked</CommandFlag>
				<Strings>
					<ButtonText>Clang Power Tools</ButtonText>
					<CommandName>Clang Power Tools</CommandName>
				</Strings>
			</Menu>

			<!--Tidy Drop-Down Menu-->
			<Menu guid="guidClangPowerToolsPackageCmdSet" id="DromDownMenu" type="MenuController" priority="0x0001">
				<Parent guid="guidClangPowerToolsPackageCmdSet" id="ToolbarGroup" />
				<CommandFlag>TextChanges</CommandFlag>
				<Strings>
					<ButtonText>Clang Tidy</ButtonText>
					<CommandName>Clang Power Tools</CommandName>
				</Strings>
			</Menu>

      <!--Documentation Drop-Down Menu-->
      <Menu guid="guidClangPowerToolsPackageCmdSet" id="DromDownDocumentationMenu" type="MenuController" priority="0x0102">
        <Parent guid="guidClangPowerToolsPackageCmdSet" id="GroupForJsonDatabase" />
        <CommandFlag>DefaultDocked</CommandFlag>
        <Strings>
          <ButtonText>Generate Documentation</ButtonText>
          <CommandName>Generate Documentation</CommandName>
        </Strings>
      </Menu>
		</Menus>


		<!-- Goups declarations -->
		<!-- All the command buttons must be placed inside of a group -->
		<Groups>

			<!-- Submenus groups -->

			<Group guid="guidClangPowerToolsPackageCmdSet" id="GroupForSubmenu" priority="0x0000" />

      <Group guid="guidClangPowerToolsPackageCmdSet" id="FindToolWindowGroup" priority="0x0600">
        <Parent guid="guidSHLMainMenu" id="IDM_VS_MENU_VIEW" />
      </Group>

			<Group guid="guidClangPowerToolsPackageCmdSet" id="ToolbarGroup" priority="0x0000">
				<Parent guid="guidClangPowerToolsPackageCmdSet" id="Toolbar" />
			</Group>
      
      <Group guid="guidClangPowerToolsPackageCmdSet" id="DromDownDocumentationMenuGroup" priority="0x0000">
        <Parent guid="guidClangPowerToolsPackageCmdSet" id="DromDownDocumentationMenu" />
      </Group>

			<!-- Context Menu groups-->
			<Group guid="guidClangPowerToolsPackageCmdSet" id="GroupForCommands" priority="0x0000" />
			<Group guid="guidClangPowerToolsPackageCmdSet" id="GroupForIgnore" priority="0x0002" />
			<Group guid="guidClangPowerToolsPackageCmdSet" id="GroupForJsonDatabase" priority="0x0003" />
			<Group guid="guidClangPowerToolsPackageCmdSet" id="GroupForSettings" priority="0x0004" />

		</Groups>


		<!-- Commands declaration -->
		<!-- Each button coresponds to a specific custom command from VS Extension -->
		<Buttons>

			<!-- Context Menu buttons -->


			<!-- Clang Compile Context Menu button -->
			<Button guid="guidClangPowerToolsPackageCmdSet" id="CompileId" priority="0x0000" type="Button">
				<Parent guid="guidClangPowerToolsPackageCmdSet" id="GroupForCommands" />
				<Icon guid="guidImageCompile" id="Compile" />
				<CommandFlag>DefaultDisabled</CommandFlag>
				<Strings>
					<ButtonText>Compile</ButtonText>
				</Strings>
			</Button>

			<!--Clang Tidy button -->
			<Button guid="guidClangPowerToolsPackageCmdSet" id="TidyId" priority="0x0001" type="Button">
				<Parent guid="guidClangPowerToolsPackageCmdSet" id="GroupForCommands" />
				<Icon guid="guidImageTidy" id="Tidy" />
				<CommandFlag>DefaultDisabled</CommandFlag>
				<CommandFlag>TextChanges</CommandFlag>
				<Strings>
					<ButtonText>Tidy</ButtonText>
				</Strings>
			</Button>

			<!-- Clang Tidy-Fix context menu button  -->
			<!--
      <Button guid="guidClangPowerToolsPackageCmdSet" id="TidyFixId" priority="0x0003" type="Button">
        <Parent guid="guidClangPowerToolsPackageCmdSet" id="GroupForCommands" />
        <Icon guid="guidImageEmpty" id="Empty" />
        <CommandFlag>DefaultDisabled</CommandFlag>
        <Strings>
          <ButtonText>Tidy-Fix</ButtonText>
        </Strings>
      </Button>-->

			<!-- Clang Format Context Menu button -->
			<Button guid="guidClangPowerToolsPackageCmdSet" id="ClangFormatId" priority="0x0004" type="Button">
				<Parent guid="guidClangPowerToolsPackageCmdSet" id="GroupForCommands" />
				<Icon guid="guidImageFormat" id="Format" />
				<CommandFlag>DefaultDisabled</CommandFlag>
				<Strings>
					<ButtonText>Format</ButtonText>
				</Strings>
			</Button>

      <!-- Clang Find Context Menu button -->
      <Button guid="guidClangPowerToolsPackageCmdSet" id="FindId" priority="0x0004" type="Button">
        <Parent guid="guidClangPowerToolsPackageCmdSet" id="GroupForCommands" />
        <Icon guid="guidImageFind" id="Find" />
        <CommandFlag>DefaultDisabled</CommandFlag>
        <Strings>
          <ButtonText>Find</ButtonText>
        </Strings>
      </Button>

      <!-- Clang Optimize Includes Context Menu button -->
      <Button guid="guidClangPowerToolsPackageCmdSet" id="OptimizeIncludesId" priority="0x0005" type="Button">
        <Parent guid="guidClangPowerToolsPackageCmdSet" id="GroupForCommands" />
        <Icon guid="guidImageOptimizeIncludes" id="OptimizeIncludes" />
        <CommandFlag>DefaultDisabled</CommandFlag>
        <Strings>
          <ButtonText>Optimize Includes (BETA)</ButtonText>
        </Strings>
      </Button>

			<!-- Stop Clang execution Context Menu button -->
			<Button guid="guidClangPowerToolsPackageCmdSet" id="StopClangId" priority="0x0006" type="Button">
				<Parent guid="guidClangPowerToolsPackageCmdSet" id="GroupForCommands" />
				<Icon guid="guidImageStopClang" id="StopClang" />
				<CommandFlag>DefaultDisabled</CommandFlag>
				<Strings>
					<ButtonText>Stop</ButtonText>
				</Strings>
			</Button>

			<!-- Ignore file for clang compile Context Menu button -->
			<Button guid="guidClangPowerToolsPackageCmdSet" id="IgnoreCompileId" priority="0x0007" type="Button">
				<Parent guid="guidClangPowerToolsPackageCmdSet" id="GroupForIgnore" />
				<Icon guid="guidImageIgnoreFormat" id="IgnoreFormat" />
				<CommandFlag>DefaultDisabled</CommandFlag>
				<Strings>
					<ButtonText>Ignore at Compile</ButtonText>
				</Strings>
			</Button>

			<!-- Ignore file for clang format Context Menu button -->
			<Button guid="guidClangPowerToolsPackageCmdSet" id="IgnoreFormatId" priority="0x0008" type="Button">
				<Parent guid="guidClangPowerToolsPackageCmdSet" id="GroupForIgnore" />
				<Icon guid="guidImageEmpty" id="Empty" />
				<CommandFlag>DefaultDisabled</CommandFlag>
				<Strings>
					<ButtonText>Ignore at Format</ButtonText>
				</Strings>
			</Button>
      
      <!-- Find Command from view menu -->
      <Button guid="guidClangPowerToolsPackageCmdSet" id="FindToolWindowId" priority="0x0100" type="Button">
        <Parent guid="guidClangPowerToolsPackageCmdSet" id="FindToolWindowGroup" />
        <Icon guid="guidImageFind" id="Find" />
        <CommandFlag>DynamicVisibility</CommandFlag>
        <Strings>
          <ButtonText>Find Tool Window - Clang Power Tools</ButtonText>
        </Strings>
      </Button>

			<!-- Export JSON Compilation Database Context Menu button -->
			<Button guid="guidClangPowerToolsPackageCmdSet" id="JsonCompilationDatabaseId" priority="0x0008" type="Button">
				<Parent guid="guidClangPowerToolsPackageCmdSet" id="GroupForJsonDatabase" />
				<Icon guid="guidImageJsonCompilationDb" id="JsonCompilationDb" />
				<CommandFlag>DefaultDisabled</CommandFlag>
				<Strings>
					<ButtonText>Export Compilation Database</ButtonText>
				</Strings>
			</Button>

      <!-- Generate documentation yaml Context Menu button -->
      <Button guid="guidClangPowerToolsPackageCmdSet" id="DocumentationYamlId" priority="0x0000" type="Button">
        <Parent guid="guidClangPowerToolsPackageCmdSet" id="DromDownDocumentationMenuGroup" />
        <Icon guid="guidImageDocumentation" id="Documentation" />
        <CommandFlag>DefaultDisabled</CommandFlag>
        <Strings>
          <ButtonText>Yaml</ButtonText>
        </Strings>
      </Button>

      <!-- Generate documentation html Context Menu button -->
      <Button guid="guidClangPowerToolsPackageCmdSet" id="DocumentationHtmlId" priority="0x0001" type="Button">
        <Parent guid="guidClangPowerToolsPackageCmdSet" id="DromDownDocumentationMenuGroup" />
        <Icon guid="guidImageDocumentation" id="Documentation" />
        <CommandFlag>DefaultDisabled</CommandFlag>
        <Strings>
          <ButtonText>Html</ButtonText>
        </Strings>
      </Button>


      <!-- Generate documentation md Context Menu button -->
      <Button guid="guidClangPowerToolsPackageCmdSet" id="DocumentationMdId" priority="0x0002" type="Button">
        <Parent guid="guidClangPowerToolsPackageCmdSet" id="DromDownDocumentationMenuGroup" />
        <Icon guid="guidImageDocumentation" id="Documentation" />
        <CommandFlag>DefaultDisabled</CommandFlag>
        <Strings>
          <ButtonText>Markdown</ButtonText>
        </Strings>
      </Button>
      

			<!-- Clang Settings Context Menu button -->
			<Button guid="guidClangPowerToolsPackageCmdSet" id="SettingsId" priority="0x000A" type="Button">
				<Parent guid="guidClangPowerToolsPackageCmdSet" id="GroupForSettings" />
				<Icon guid="guidImageSettings" id="Settings" />
				<CommandFlag>DefaultDisabled</CommandFlag>
				<Strings>
					<ButtonText>Settings</ButtonText>
				</Strings>
			</Button>


			<!-- Toolbar Buttons -->

			<!-- Clang Compile toolbar button -->
			<Button guid="guidClangPowerToolsPackageCmdSet" id="CompileToolbarId" priority="0x0000" type="Button">
				<Parent guid="guidClangPowerToolsPackageCmdSet" id="ToolbarGroup" />
				<Icon guid="guidImageCompile" id="Compile" />
				<CommandFlag>DefaultDisabled</CommandFlag>
				<Strings>
					<ButtonText>Compile</ButtonText>
				</Strings>
			</Button>

			<!-- Clang Tidy & Clang Tidy Fix Drop Down submenu in toolbar-->

			<!-- Clang Tidy-Fix toolbar button  -->
			<!--
      <Button guid="guidClangPowerToolsPackageCmdSet" id="TidyFixToolbarId" priority="0x0003" type="Button">
        <Icon guid="guidImageTidy" id="Tidy" />
        <CommandFlag>DefaultDisabled</CommandFlag>
        <Strings>
          <ButtonText>Tidy-Fix</ButtonText>
        </Strings>
      </Button>-->

			<Button guid="guidClangPowerToolsPackageCmdSet" id="TidyToolbarId" priority="0x0001" type="Button">
				<Parent guid="guidClangPowerToolsPackageCmdSet" id="ToolbarGroup" />
				<Icon guid="guidImageTidy" id="Tidy" />
				<CommandFlag>DefaultDisabled</CommandFlag>
				<CommandFlag>TextChanges</CommandFlag>
				<Strings>
					<ButtonText>Tidy</ButtonText>
				</Strings>
			</Button>

			<!--<Button guid="guidClangPowerToolsPackageCmdSet" id="TidyFixToolbarId" priority="0x0003" type="Button">
        <Parent guid="guidClangPowerToolsPackageCmdSet" id="DropDownToolbarMenuGroup" />
        <Strings>
          <ButtonText>Tidy-Fix</ButtonText>
        </Strings>
      </Button>-->

			<Button guid="guidClangPowerToolsPackageCmdSet" id="ClangFormatToolbarId" priority="0x0003" type="Button">
				<Parent guid="guidClangPowerToolsPackageCmdSet" id="ToolbarGroup" />
				<Icon guid="guidImageFormat" id="Format" />
				<CommandFlag>DefaultDisabled</CommandFlag>
				<Strings>
					<ButtonText>Format</ButtonText>
				</Strings>
			</Button>

			<Button guid="guidClangPowerToolsPackageCmdSet" id="StopClangId" priority="0x0004" type="Button">
				<Parent guid="guidClangPowerToolsPackageCmdSet" id="ToolbarGroup" />
				<Strings>
					<ButtonText>Stop</ButtonText>
				</Strings>
			</Button>

			<Button guid="guidClangPowerToolsPackageCmdSet" id="SettingsId" priority="0x0006" type="Button">
				<Parent guid="guidClangPowerToolsPackageCmdSet" id="ToolbarGroup" />
				<CommandFlag>DefaultDisabled</CommandFlag>
				<Strings>
					<ButtonText>Settings</ButtonText>
				</Strings>
			</Button>

		</Buttons>

		<!--Declare all the image resources -->
		<Bitmaps>
			<Bitmap guid="guidImages" href="..\ClangPowerToolsShared\Resources\CPTLogo.png" usedList="bmpPic1" />
			<Bitmap guid="guidImageTidy" href="..\ClangPowerToolsShared\Resources\TidyIcon.png" usedList="Tidy" />
			<Bitmap guid="guidImageCompile" href="..\ClangPowerToolsShared\Resources\CompileIcon.png" usedList="Compile" />
			<Bitmap guid="guidImageFormat" href="..\ClangPowerToolsShared\Resources\ClangFormatIcon.png" usedList="Format" />
			<Bitmap guid="guidImageFind" href="..\ClangPowerToolsShared\Resources\[CPT]Find.png" usedList="Find" />
			<Bitmap guid="guidImageOptimizeIncludes" href="..\ClangPowerToolsShared\Resources\[CPT]OptimizeIncludes.png" usedList="OptimizeIncludes" />
			<Bitmap guid="guidImageStopClang" href="..\ClangPowerToolsShared\Resources\StopCommandIcon.png" usedList="StopClang" />
			<Bitmap guid="guidImageSettings" href="..\ClangPowerToolsShared\Resources\SettingsIcon.png" usedList="Settings" />
			<Bitmap guid="guidImageIgnoreFormat" href="..\ClangPowerToolsShared\Resources\IgnoreIcon.png" usedList="IgnoreFormat" />
			<Bitmap guid="guidImageEmpty" href="..\ClangPowerToolsShared\Resources\EmptyIcon.png" usedList="Empty" />
			<Bitmap guid="guidImageJsonCompilationDb" href="..\ClangPowerToolsShared\Resources\JsonCompilationDatabase.png" usedList="JsonCompilationDb" />
			<Bitmap guid="guidImageDocumentation" href="..\ClangPowerToolsShared\Resources\[CPT]GenerateDocumentation.png" usedList="Documentation" />
		</Bitmaps>

	</Commands>

	<!-- Shortcuts for commands-->
	<KeyBindings>
		<KeyBinding guid="guidClangPowerToolsPackageCmdSet" id="CompileToolbarId" editor="guidVSStd97"
                key1="U" mod1="ALT" />

		<KeyBinding guid="guidClangPowerToolsPackageCmdSet" id="TidyToolbarId" editor="guidVSStd97"
                    key1="Y" mod1="ALT" />

		<!--<KeyBinding guid="guidClangPowerToolsPackageCmdSet" id="TidyFixToolbarId" editor="guidVSStd97"
                key1="X" mod1="ALT" />-->

		<KeyBinding guid="guidClangPowerToolsPackageCmdSet" id="ClangFormatToolbarId" editor="guidVSStd97"
                key1="M" mod1="ALT" />

		<KeyBinding guid="guidClangPowerToolsPackageCmdSet" id="StopClangId" editor="guidVSStd97"
                key1="O" mod1="ALT" />
	</KeyBindings>

	<!-- Placement for commands. The parent of a command is always a group, never a menu, context menu or toolbar.-->

	<CommandPlacements>

		<!-- Add the Clang Power Tools submenu(the subpenu contains all the commands) 
      in context menu of solution, project, folder, file and tab editor -->

		<CommandPlacement guid="guidClangPowerToolsPackageCmdSet" id="GroupForSubmenu" priority="0x08FF">
			<!-- The parent of the group will be the solution context menu -->
			<Parent guid="guidSHLMainMenu" id="IDM_VS_CTXT_SOLNNODE" />
		</CommandPlacement>

		<CommandPlacement guid="guidClangPowerToolsPackageCmdSet" id="GroupForSubmenu" priority="0x07FF">
			<!-- The parent of the group will be the project context menu -->
			<Parent guid="guidSHLMainMenu" id="IDM_VS_CTXT_PROJNODE" />
		</CommandPlacement>

		<CommandPlacement guid="guidClangPowerToolsPackageCmdSet" id="GroupForSubmenu" priority="0x0500">
			<!-- The parent of the group will be the folder context menu -->
			<Parent guid="guidSHLMainMenu" id="IDM_VS_CTXT_FOLDERNODE" />
		</CommandPlacement>

		<CommandPlacement guid="guidClangPowerToolsPackageCmdSet" id="GroupForSubmenu" priority="0x0600">
			<!-- The parent of the group will be the file context menu -->
			<Parent guid="guidSHLMainMenu" id="IDM_VS_CTXT_ITEMNODE" />
		</CommandPlacement>

		<!--The parent of the group will be the tab file context menu -->
		<!--<CommandPlacement guid="guidClangPowerToolsPackageCmdSet" id="GroupForSubmenu" priority="0xFFFF">
     <Parent guid="guidSHLMainMenu" id="IDM_VS_CTXT_EZDOCWINTAB" /> 
    </CommandPlacement> -->

		<!-- Define which groups will be placed in the Clang Power Tools submenu  -->
		<!-- By placing a group automatically each section it will be delimited by a separator -->
		<CommandPlacement guid="guidClangPowerToolsPackageCmdSet" id="GroupForCommands" priority="0x0001">
			<Parent guid="guidClangPowerToolsPackageCmdSet" id="Submenu" />
		</CommandPlacement>

		<CommandPlacement guid="guidClangPowerToolsPackageCmdSet" id="GroupForIgnore" priority="0x0002">
			<Parent guid="guidClangPowerToolsPackageCmdSet" id="Submenu" />
		</CommandPlacement>

		<CommandPlacement guid="guidClangPowerToolsPackageCmdSet" id="GroupForJsonDatabase" priority="0x0003">
			<Parent guid="guidClangPowerToolsPackageCmdSet" id="Submenu" />
		</CommandPlacement>

		<CommandPlacement guid="guidClangPowerToolsPackageCmdSet" id="GroupForSettings" priority="0x0004">
			<Parent guid="guidClangPowerToolsPackageCmdSet" id="Submenu" />
		</CommandPlacement>

	</CommandPlacements>


	<!--Contains all the unique identifires and symbols declaration-->
	<Symbols>
		<GuidSymbol name="guidClangPowerToolsPackage" value="{f564f9d3-01ae-493e-883b-18deebdb975e}" />


		<!-- Define the unique identifires for commands, groups, menu and toolbar -->
		<GuidSymbol name="guidClangPowerToolsPackageCmdSet" value="{498fdff5-5217-4da9-88d2-edad44ba3874}">

			<!-- Define the unique identifires for groups -->
			<IDSymbol name="GroupForSubmenu" value="0x1020" />
			<IDSymbol name="GroupForCommands" value="0x1021" />
			<IDSymbol name="GroupForSettings" value="0x1022" />
			<IDSymbol name="GroupForIgnore" value="0x1023" />
			<IDSymbol name="GroupForJsonDatabase" value="0x1024" />
			<IDSymbol name="ToolbarGroup" value="0x1050" />
			<IDSymbol name="GroupForToolbarMenu" value="0x1030" />
			<!--<IDSymbol name ="DropDownToolbarMenuGroup" value="0x0110"/>-->
      
      <!-- Find Command from view menu -->
      <IDSymbol name="FindToolWindowGroup" value="0x000D" />
      <IDSymbol name="FindToolWindowId" value="0x1A20" />


			<!-- Define the unique identifires for menus -->
			<IDSymbol name="Submenu" value="0x0100" />
			<IDSymbol name="DromDownMenu" value="0x0200" />
			<IDSymbol name="DromDownDocumentationMenu" value="0x020A" />
			<IDSymbol name="DromDownDocumentationMenuGroup" value="0x010A" />

			<!-- Define the unique identifires for commands -->
			<IDSymbol name="CompileId" value="0x0102" />
			<IDSymbol name="CompileToolbarId" value="0x1100" />

			<IDSymbol name="TidyId" value="0x0101" />
			<!--<IDSymbol name="TidyFixId" value="0x0109" />-->

			<IDSymbol name="TidyToolbarId" value="0x1101" />
			<!--<IDSymbol name="TidyFixToolbarId" value="0x1102" />-->

			<IDSymbol name="ClangFormatId" value="0x0105" />
			<IDSymbol name="ClangFormatToolbarId" value="0x1103" />
			<IDSymbol name="FindId" value="0x0115" />
      <IDSymbol name="OptimizeIncludesId" value="0x01A7" />

			<IDSymbol name="StopClangId" value="0x0104" />
			<IDSymbol name="IgnoreFormatId" value="0x0107" />
			<IDSymbol name="IgnoreCompileId" value="0x0108" />

			<IDSymbol name="JsonCompilationDatabaseId" value="0x0106" />
			<IDSymbol name="DocumentationYamlId" value="0x0216" />
			<IDSymbol name="DocumentationHtmlId" value="0x0116" />
			<IDSymbol name="DocumentationMdId" value="0x0126" />

			<IDSymbol name="SettingsId" value="0x0103" />
			<IDSymbol name="TidyExportConfigId" value="0x1032" />
			<IDSymbol name="LogoutId" value="0x1033" />

			<!-- Define the unique identifires for toolbar -->
			<IDSymbol name="Toolbar" value="0x1000" />
		</GuidSymbol>

		<!--Icon for preview image and main icon-->
		<GuidSymbol name="guidImages" value="{6ef146ba-e044-43ab-989d-c4a1d6d5c70a}">
			<IDSymbol name="bmpPic1" value="1" />
		</GuidSymbol>

		<!-- Define the image for each command -->

		<!-- Define clang tidy image -->
		<GuidSymbol name="guidImageTidy" value="{6ef146ba-e044-43ab-989d-c4a1d6d5c70d}">
			<IDSymbol name="Tidy" value="1" />
		</GuidSymbol>

		<!-- Define clang compile image -->
		<GuidSymbol name="guidImageCompile" value="{6ef146ba-e044-43ab-989d-c4a1d6d5c70e}">
			<IDSymbol name="Compile" value="1" />
		</GuidSymbol>

		<!-- Define clang stop image -->
		<GuidSymbol name="guidImageStopClang" value="{6ef146ba-e044-43ab-989d-c4a1d6d5c700}">
			<IDSymbol name="StopClang" value="1" />
		</GuidSymbol>

		<!-- Define clang  ignore format image -->
		<GuidSymbol name="guidImageIgnoreFormat" value="{6ef146ba-e044-43ab-989d-c4a1d6d5c708}">
			<IDSymbol name="IgnoreFormat" value="1" />
		</GuidSymbol>

		<!-- Define empty image -->
		<GuidSymbol name="guidImageEmpty" value="{6ef146ba-e044-43ab-989d-c4a1d6d5c705}">
			<IDSymbol name="Empty" value="1" />
		</GuidSymbol>

		<!-- Define clang settigns image -->
		<GuidSymbol name="guidImageSettings" value="{6ef146ba-e044-43ab-989d-c4a1d6d5c70f}">
			<IDSymbol name="Settings" value="1" />
		</GuidSymbol>

		<!-- Define clang format image -->
		<GuidSymbol name="guidImageFormat" value="{6ef146ba-e044-43ab-989d-c4a1d6d5c71a}">
			<IDSymbol name="Format" value="1" />
		</GuidSymbol>

    <!-- Define clang find image -->
    <GuidSymbol name="guidImageFind" value="{d46b5b3e-8c5a-4a6d-972f-37146878a106}">
      <IDSymbol name="Find" value="1" />
    </GuidSymbol>

    <!-- Define clang optimize includes image -->
    <GuidSymbol name="guidImageOptimizeIncludes" value="{6a7c3b9d-5f2e-4a8c-9d1b-e79f2d4c1a35}">
      <IDSymbol name="OptimizeIncludes" value="1" />
    </GuidSymbol>

		<!-- Define Logout image -->
		<GuidSymbol name="guidImageLogout" value="{6ef146ba-e044-43ab-989d-c4a1d6d5c72a}">
			<IDSymbol name="Logout" value="1" />
		</GuidSymbol>

		<GuidSymbol name="guidImageJsonCompilationDb" value="{6ef146ba-e044-43ab-989d-c4a1d6d5c73a}">
			<IDSymbol name="JsonCompilationDb" value="1" />
		</GuidSymbol>
    
    <!-- Define Documentation image -->
    <GuidSymbol name="guidImageDocumentation" value="{6ef146ba-e044-43ab-989d-c4a1d6d5c74a}">
      <IDSymbol name="Documentation" value="1" />
    </GuidSymbol>

	</Symbols>

</CommandTable>


================================================
FILE: ClangPowerTools/ClangPowerTools/ClangPowerToolsPackage.cs
================================================
using ClangPowerToolsShared.MVVM.Views.ToolWindows;
using Microsoft.VisualStudio;
using Microsoft.VisualStudio.Shell;
using Microsoft.VisualStudio.Shell.Interop;
using System;
using System.IO;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Threading;
using Task = System.Threading.Tasks.Task;

namespace ClangPowerTools
{
  /// <summary>
  /// This is the class that implements the package exposed by this assembly.
  /// </summary>
  /// <remarks>
  /// <para>
  /// The minimum requirement for a class to be considered a valid package for Visual Studio
  /// is to implement the IVsPackage interface and register itself with the shell.
  /// This package uses the helper classes defined inside the Managed Package Framework (MPF)
  /// to do it: it derives from the Package class that provides the implementation of the
  /// IVsPackage interface and uses the registration attributes defined in the framework to
  /// register itself and its components with the shell. These attributes tell the pkgdef creation
  /// utility what data to put into .pkgdef file.
  /// </para>
  /// <para>
  /// To get loaded into VS, the package must be referred by &lt;Asset Type="Microsoft.VisualStudio.VsPackage" ...&gt; in .vsixmanifest file.
  /// </para>
  /// </remarks>
  [PackageRegistration(UseManagedResourcesOnly = true, AllowsBackgroundLoading = true)]
  [InstalledProductRegistration("#110", "#112", "1.0", IconResourceID = 400)] // Info on this package for Help/About
  [ProvideMenuResource("Menus.ctmenu", 1)]
  [ProvideAutoLoad(VSConstants.UICONTEXT.SolutionExistsAndFullyLoaded_string, PackageAutoLoadFlags.BackgroundLoad)]
  [ProvideAutoLoad(VSConstants.UICONTEXT.NoSolution_string, PackageAutoLoadFlags.BackgroundLoad)]
  [ProvideMenuResource("Menus.ctmenu", 1)]
  [ProvideToolWindow(typeof(TidyToolWindow), Style = VsDockStyle.Tabbed, DockedWidth = 300, Window = "DocumentWell", Orientation = ToolWindowOrientation.Left, Transient = true)]
  [ProvideToolWindow(typeof(FindToolWindow), Style = VsDockStyle.Tabbed, DockedWidth = 300, Window = "DocumentWell", Orientation = ToolWindowOrientation.Left, Transient = true)]
  [Guid(PackageGuidString)]
  public sealed class RunClangPowerToolsPackage2 : AsyncPackage
  {
    #region Members

    Object mClangPackageImpl;

    /// <summary>
    /// RunPowerShellCommandPackage GUID string.
    /// </summary>
    public const string PackageGuidString = "f564f9d3-01ae-493e-883b-18deebdb975e";
    private const string cptLib16 = "ClangPowerToolsLib16.dll";
    private const string cptLib17 = "ClangPowerToolsLib17.dll";
    private const string WPFTextBoxAutoComplete = "WPFTextBoxAutoComplete.dll";
    private const string cptNamespace = "ClangPowerTools.ClangPowerToolsPackageImpl";
    private const string initializeAsync = "InitializeAsync";

    #endregion


    #region Constructor


    /// <summary>
    /// Initializes a new instance of the <see cref="TidyCommand"/> class.
    /// </summary>
    public RunClangPowerToolsPackage2()
    {

    }

    #endregion


    #region Initialize Package


    /// <summary>
    /// Initialization of the package; this method is called right after the package is sited, so this is the place
    /// where you can put all the initialization code that rely on services provided by VisualStudio.
    /// </summary>
    protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress<ServiceProgressData> progress)
    {
      // Switches to the UI thread in order to consume some services used in command initialization
      await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);

      var shellService = (IVsShell)await GetServiceAsync(typeof(SVsShell));
      object releaseVersionObj = "";
      shellService.GetProperty(-9068, out releaseVersionObj);
      string releaseVersion = (string)releaseVersionObj;
      releaseVersion = releaseVersion.Substring(0, releaseVersion.IndexOf('.')) + ".0";
      string assemblyName = new Version(releaseVersion) < new Version("17.0")
          ? cptLib16
          : cptLib17;

      string currentDir = Path.GetDirectoryName(GetType().Assembly.Location);
      Assembly assembly = Assembly.LoadFile(Path.Combine(currentDir, assemblyName));

      Type type = assembly.GetType(cptNamespace);
      mClangPackageImpl = Activator.CreateInstance(type, this);
      MethodInfo method = type.GetMethod(initializeAsync);

      await (Task)method.Invoke(mClangPackageImpl, null);



      await base.InitializeAsync(cancellationToken, progress);
    }

    #endregion

  }
}


================================================
FILE: ClangPowerTools/ClangPowerTools/Properties/AssemblyInfo.cs
================================================
using System.Reflection;
using System.Runtime.InteropServices;

// General Information about an assembly is controlled through the following 
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("ClangPowerTools")]
[assembly: AssemblyDescription("A tool bringing clang-tidy magic to Visual Studio C++ developers.")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Caphyon")]
[assembly: AssemblyProduct("ClangPowerTools")]
[assembly: AssemblyCopyright("")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]

// Setting ComVisible to false makes the types in this assembly not visible 
// to COM components.  If you need to access a type in this assembly from 
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]

// Version information for an assembly consists of the following four values:
//
//      Major Version
//      Minor Version 
//      Build Number
//      Revision
//
// You can specify all the values or you can default the Build and Revision Numbers 
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]


================================================
FILE: ClangPowerTools/ClangPowerTools/Properties/Resource.Designer.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.42000
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace ClangPowerTools.Properties {
    using System;
    
    
    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class Resource {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal Resource() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("ClangPowerTools.Properties.Resource", typeof(Resource).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }
        
        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Deselect all.
        /// </summary>
        internal static string DeselectAllTooltipText {
            get {
                return ResourceManager.GetString("DeselectAllTooltipText", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Encoding Converter.
        /// </summary>
        internal static string EncodingConverterWindowTitle {
            get {
                return ResourceManager.GetString("EncodingConverterWindowTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to encoding is not supported.
        /// </summary>
        internal static string EncodingError {
            get {
                return ResourceManager.GetString("EncodingError", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The following files are not encoded in UTF-8. Do you want to change their encoding?.
        /// </summary>
        internal static string EncodingErrorText {
            get {
                return ResourceManager.GetString("EncodingErrorText", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Select all.
        /// </summary>
        internal static string SelectAllTooltipText {
            get {
                return ResourceManager.GetString("SelectAllTooltipText", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unicode (UTF-8).
        /// </summary>
        internal static string UTF8Encoding {
            get {
                return ResourceManager.GetString("UTF8Encoding", resourceCulture);
            }
        }
    }
}


================================================
FILE: ClangPowerTools/ClangPowerTools/Properties/Resource.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <data name="DeselectAllTooltipText" xml:space="preserve">
    <value>Deselect all</value>
  </data>
  <data name="EncodingConverterWindowTitle" xml:space="preserve">
    <value>Encoding Converter</value>
  </data>
  <data name="EncodingError" xml:space="preserve">
    <value>encoding is not supported</value>
  </data>
  <data name="EncodingErrorText" xml:space="preserve">
    <value>The following files are not encoded in UTF-8. Do you want to change their encoding?</value>
  </data>
  <data name="SelectAllTooltipText" xml:space="preserve">
    <value>Select all</value>
  </data>
  <data name="UTF8Encoding" xml:space="preserve">
    <value>Unicode (UTF-8)</value>
  </data>
</root>

================================================
FILE: ClangPowerTools/ClangPowerTools/Tooling/v1/clang-build.ps1
================================================
<#
.SYNOPSIS
    Compiles or tidies up code from Visual Studio .vcxproj project files.

.DESCRIPTION
    This PowerShell script scans for all .vcxproj Visual Studio projects inside a source directory.
    One or more of these projects will be compiled or tidied up (modernized), using Clang.

.PARAMETER aSolutionsPath
    Alias 'dir'. Source directory to find sln files.
                 Projects will be extracted from each sln.

    Important: You can pass an absolute path to a sln. This way, no file searching will be done, and
               only the projects from this solution file will be taken into account.

.PARAMETER aVcxprojToCompile
    Alias 'proj'. Array of project(s) to compile. If empty, all projects found in solutions are compiled.
    Regex matching is supported, using the [regex] prefix (e.g. [regex]'.*components').

    Absolute disk paths to vcxproj files are accepted.

    Can be passed as comma separated values.

.PARAMETER aVcxprojToIgnore
    Alias 'proj-ignore'. Array of project(s) to ignore, from the matched ones.
    If empty, all already matched projects are compiled.
    Regex matching is supported, using the [regex] prefix (e.g. [regex]'.*components').

    Can be passed as comma separated values.

.PARAMETER aVcxprojConfigPlatform
    Alias 'active-config'. Array of configuration-platform pairs, each pair being separated by |,
    to be used when processing project files.

    E.g. "Debug|Win32", "Debug|x64".
    If not specified, the first configuration-platform found in the current project is used.
    Projects will be processed for each configuration-platform specified, the ones that are missing will be skipped.

.PARAMETER aCppToCompile
    Alias 'file'. What cpp(s) to compile from the found project(s). If empty, all CPPs are compiled.
    Regex matching is supported, using the [regex] prefix (e.g. [regex]'.*table').

    Note: If any headers are given then all translation units that include them will be processed.

.PARAMETER aCppToIgnore
    Alias 'file-ignore'. Array of file(s) to ignore, from the matched ones.
    Regex matching is supported, using the [regex] prefix (e.g. [regex]'.*table').

    Can be passed as comma separated values.

.PARAMETER aUseParallelCompile
    Alias 'parallel'. Switch to run in parallel mode, on all logical CPU cores.

.PARAMETER aContinueOnError
     Alias 'continue'. Switch to continue project compilation even when errors occur.

.PARAMETER aTreatAdditionalIncludesAsSystemIncludes
     Alias 'treat-sai'. Switch to treat project additional include directories as system includes.

.PARAMETER aClangCompileFlags
     Alias 'clang-flags'. Flags given to clang++ when compiling project,
     alongside project-specific defines.

.PARAMETER aTidyFlags
      Alias 'tidy'. If not empty clang-tidy will be called with given flags, instead of clang++.
      The tidy operation is applied to whole translation units, meaning all directory headers
      included in the CPP will be tidied up too. Changes will not be applied, only simulated.

      If aTidyFixFlags is present, it takes precedence over this parameter.

      If '.clang-tidy' value is given, configuration will be read from .clang-tidy file
      in the closest parent directory.

.PARAMETER aTidyFixFlags
      Alias 'tidy-fix'. If not empty clang-tidy will be called with given flags, instead of clang++.
      The tidy operation is applied to whole translation units, meaning all directory headers
      included in the CPP will be tidied up too. Changes will be applied to the file(s).

      If present, this parameter takes precedence over aTidyFlags.

      If '.clang-tidy' value is given, configuration will be read from .clang-tidy file
      in the closest parent directory.

.PARAMETER aAfterTidyFixFormatStyle
      Alias 'format-style'. Used in combination with 'tidy-fix'. If present, clang-tidy will
      also format the fixed file(s), using the specified style.
      Possible values: - not present, no formatting will be done
                       - 'file'
                           Literally 'file', not a placeholder.
                           Uses .clang-format file in the closest parent directory.
                       - 'llvm'
                       - 'google'
                       - 'webkit'
                       - 'mozilla'

.PARAMETER aVisualStudioVersion
      Alias 'vs-ver'. Version of Visual Studio (VC++) installed and that'll be used for
      standard library include directories. E.g. 2017.

      Optional. If not given, it will be inferred based on the project toolset version.

.PARAMETER aVisualStudioSku
      Alias 'vs-sku'. Sku of Visual Studio (VC++) installed and that'll be used for
      standard library include directories. E.g. Professional.

      If not given, the first detected Visual Studio SKU will be used.

.NOTES
    Author: Gabriel Diaconita
#>
#Requires -Version 5
param( [alias("proj")]
       [Parameter(Mandatory=$false, HelpMessage="Filter project(s) to compile/tidy")]
       [System.Object[]] $aVcxprojToCompile = @()

     , [alias("dir")]
       [Parameter(Mandatory=$false, HelpMessage="Source directory for finding solutions; projects will be found from each sln")]
       [string] $aSolutionsPath

     , [alias("proj-ignore")]
       [Parameter(Mandatory=$false, HelpMessage="Specify projects to ignore")]
       [System.Object[]] $aVcxprojToIgnore = @()

     , [alias("active-config")]
       [Parameter(Mandatory=$false, HelpMessage="Config/platform to be used, e.g. Debug|Win32")]
       [string[]] $aVcxprojConfigPlatform = @()

     , [alias("file")]
       [Parameter(Mandatory=$false, HelpMessage="Filter file(s) to compile/tidy")]
       [System.Object[]] $aCppToCompile = @()

     , [alias("file-ignore")]
       [Parameter(Mandatory=$false, HelpMessage="Specify file(s) to ignore")]
       [System.Object[]] $aCppToIgnore = @()

     , [alias("parallel")]
       [Parameter(Mandatory=$false, HelpMessage="Compile/tidy/tidy-fix projects in parallel")]
       [switch]   $aUseParallelCompile

     , [alias("continue")]
       [Parameter(Mandatory=$false, HelpMessage="Allow CPT to continue immediately after encountering an error")]
       [switch]   $aContinueOnError

     , [alias("resume")]
       [Parameter(Mandatory=$false, HelpMessage="Allow CPT to resume the last session (start from last active project / file number).")]
       [switch]   $aResumeAfterError

     , [alias("treat-sai")]
       [Parameter(Mandatory=$false, HelpMessage="Treat project additional include directories as system includes")]
       [switch]   $aTreatAdditionalIncludesAsSystemIncludes

     , [alias("clang-flags")]
       [Parameter(Mandatory=$false, HelpMessage="Specify compilation flags to CLANG")]
       [string[]] $aClangCompileFlags = @()

     , [alias("tidy")]
       [Parameter(Mandatory=$false, HelpMessage="Specify flags to CLANG TIDY")]
       [string]   $aTidyFlags

     , [alias("tidy-fix")]
       [Parameter(Mandatory=$false, HelpMessage="Specify flags to CLANG TIDY & FIX")]
       [string]   $aTidyFixFlags

     , [alias("header-filter")]
       [Parameter(Mandatory=$false, HelpMessage="Enable Clang-Tidy to run on header files")]
       [string]   $aTidyHeaderFilter

     , [alias("format-style")]
       [Parameter(Mandatory=$false, HelpMessage="Used with 'tidy-fix'; tells CLANG TIDY-FIX to also format the fixed file(s)")]
       [string]   $aAfterTidyFixFormatStyle

     , [alias("vs-ver")]
       [Parameter(Mandatory=$false, HelpMessage="Version of Visual Studio toolset to use for loading project")]
       [string]   $aVisualStudioVersion

     , [alias("vs-sku")]
       [Parameter(Mandatory=$false, HelpMessage="Edition of Visual Studio toolset to use for loading project")]
       [string]   $aVisualStudioSku
       
     , [alias("export-jsondb")]
       [Parameter(Mandatory=$false, HelpMessage="Switch to generate a JSON compilation database file, in the current working directory")]
       [switch]   $aExportJsonDB
      
     , [alias("export-doc")]
       [Parameter(Mandatory=$false, HelpMessage="If present, specifies the type of documentation to generate, in the current working direcotory")]
       [ValidateSet("yaml", "md", "html")]
       [string]   $aDocumentationExportFormat
     )

Set-StrictMode -version latest
$ErrorActionPreference = 'Continue'

# System Architecture Constants
# ------------------------------------------------------------------------------------------------

Set-Variable -name kCptGithubRepoBase -value `
"https://raw.githubusercontent.com/Caphyon/clang-power-tools/master/ClangPowerTools/ClangPowerToolsShared/Tooling/v1/" `
                                      -option Constant
Set-Variable -name kPsMajorVersion    -value (Get-Host).Version.Major   -Option Constant 
# ------------------------------------------------------------------------------------------------
# Return Value Constants

Set-Variable -name kScriptFailsExitCode      -value  47                 -option Constant

# ------------------------------------------------------------------------------------------------
# File System Constants

Set-Variable -name kExtensionVcxproj         -value ".vcxproj"          -option Constant
Set-Variable -name kExtensionSolution        -value ".sln"              -option Constant
Set-Variable -name kExtensionYaml            -value ".yaml"             -option Constant
Set-Variable -name kExtensionClangPch        -value ".clang.pch"        -option Constant
Set-Variable -name kExtensionC               -value ".c"                -option Constant


# ------------------------------------------------------------------------------------------------
# Envinroment Variables for controlling logic

Set-Variable -name kVarEnvClangTidyPath     -value "CLANG_TIDY_PATH"-option Constant

# ------------------------------------------------------------------------------------------------
# Clang-Related Constants

Set-Variable -name kClangFlagSupressLINK    -value @("-fsyntax-only")   -option Constant
Set-Variable -name kClangFlagIncludePch     -value "-include-pch"       -option Constant
Set-Variable -name kClangFlagFasterPch      -value "-fpch-instantiate-templates" -option Constant
Set-Variable -name kClangFlagMinusO         -value "-o"                 -option Constant

Set-Variable -name kClangDefinePrefix       -value "-D"                 -option Constant
Set-Variable -name kClangFlagNoUnusedArg    -value "-Wno-unused-command-line-argument" `
                                                                        -option Constant
Set-Variable -name kClangFlagNoMsInclude    -value "-Wno-microsoft-include" `
                                                                        -Option Constant
Set-Variable -name kClangFlagFileIsCPP      -value "-x c++"             -option Constant
Set-Variable -name kClangFlagFileIsC        -value "-x c"               -option Constant
Set-Variable -name kClangFlagForceInclude   -value "-include"           -option Constant
Set-Variable -name kClangTidyFixExportFixes -value "--export-fixes="    -option Constant


Set-Variable -name kClangCompiler           -value "clang++.exe"        -option Constant

Set-Variable -name kClangTidyFlags            -value @("-quiet"
                                                      ,"--")            -option Constant
Set-Variable -name kClangTidyFlagHeaderFilter -value "-header-filter="  -option Constant
Set-Variable -name kClangTidyFlagChecks       -value "-checks="         -option Constant
Set-Variable -name kClangTidyUseFile          -value ".clang-tidy"      -option Constant
Set-Variable -name kClangTidyFormatStyle      -value "-format-style="   -option Constant

Set-Variable -name kClangTidyFlagTempFile     -value ""

Set-Variable -name kCptRegHiveSettings         -value "HKCU:SOFTWARE\Caphyon\Clang Power Tools"             -option Constant
Set-Variable -name kCptVsixSettings            -value "${env:APPDATA}\ClangPowerTools\settings.json"        -option Constant
Set-Variable -name kCptTidyFixReplacementsDir  -value "${env:APPDATA}\ClangPowerTools\TidyFixReplacements" -option Constant

# ------------------------------------------------------------------------------------------------

Function cpt:getSetting([string] $name)
{
  if ((Test-Path $kCptVsixSettings))
  {
    $settingsJson = ( (Get-Content -Raw -Path $kCptVsixSettings) | ConvertFrom-Json)
    $settingField = $settingsJson.Where{ $_ | Get-Member $name }
    if (!$settingField)
    {
      return $null
    }
    
    return $settingField.$name
  }
  return $null
}

# We define this separately from the implementation in io.ps1 because that may not yet be present and 
# in order to download it we need the connection-status greenlight.
Function cpt:testInternetConnectivity
{  
  $resp = Get-WmiObject -Class Win32_PingStatus -Filter 'Address="github.com" and Timeout=100' | Select-Object ResponseTime
  [bool] $hasInternetConnectivity = ($resp.ResponseTime -and $resp.ResponseTime -gt 0)
  return $hasInternetConnectivity
}

# Include required scripts, or download them from Github, if necessary

Function cpt:ensureScriptExists( [Parameter(Mandatory=$true)] [string] $scriptName
                               , [Parameter(Mandatory=$false)][bool]   $forceRedownload
                               )
{
  [string] $scriptFilePath = "$PSScriptRoot/psClang/$scriptName"
  if ( $forceRedownload -or (! (Test-Path $scriptFilePath)) )
  {
    Write-Verbose "Download required script $scriptName ..."
    [string] $request = "$kCptGithubRepoBase/psClang/$scriptName"

    if ( ! (Test-Path "$PSScriptRoot/psClang"))
    {
      New-Item "$PSScriptRoot/psClang" -ItemType Directory > $null
    }

    # Invoke-WebRequest has an issue when displaying progress on PowerShell 7, it won't go away
    # and will keep nagging the user, and on PS5 it causes slow transfers  => we supress it.
    
    $prevPreference = $progressPreference
    $ProgressPreference = "SilentlyContinue"
    
    Invoke-WebRequest -Uri $request -OutFile $scriptFilePath
    (Get-Content $scriptFilePath -Raw).Replace("`n","`r`n") | Set-Content $scriptFilePath -Force -NoNewline

    $ProgressPreference = $prevPreference
    
    if (! (Test-Path $scriptFilePath))
    {
      Write-Error "Could not download required script file ($scriptName). Aborting..."
      exit 1
    }
  }

  return $scriptFilePath
}

[bool] $shouldRedownloadForcefully = $false
[Version] $cptVsixVersion = cpt:getSetting "Version"
Write-Verbose "Current Clang Power Tools VSIX version: $cptVsixVersion"

$kLogicalCoreCount = 4;
if($Env:NUMBER_OF_PROCESSORS -match "^\d+$")
{
  $kLogicalCoreCount = $Env:NUMBER_OF_PROCESSORS
  if($Env:CPT_CPULIMIT -match "^\d+$")
  {
    $kLogicalCoreCount = $Env:CPT_CPULIMIT
  }
  #Set-Variable -name kLogicalCoreCount -value $Env:CPT_CPULIMIT   -option Constant
}

# If the main script has been updated meanwhile, we invalidate all other scripts, and force
# them to update from github. We need to watch for this because older CPT VS Extensions (before v7.9)
# did not updated all helper scripts, but a list of predefined ones; we need to update the new ones as well.
if ( ( ![string]::IsNullOrWhiteSpace($cptVsixVersion) -and 
        [Version]::new($cptVsixVersion) -lt [Version]::new(7, 9, 0) ) -and
     (Test-Path $kCptRegHiveSettings) )
{
  Write-Verbose "Checking to see if we should redownload script helpers..."
  $regHive = Get-Item -LiteralPath $kCptRegHiveSettings
  $currentHash = (Get-FileHash $PSCommandPath -Algorithm "SHA1").Hash
  $savedHash = $regHive.GetValue('ScriptContentHash');

  # we used to rely on timestamps but it's unreliable so make sure to clean up the reg value
  if ($regHive.GetValue('ScriptTimestamp'))
  {
    Remove-ItemProperty -path $kCptRegHiveSettings -name 'ScriptTimestamp'
  }

  if (! (cpt:testInternetConnectivity) )
  {
    Write-Verbose "No internet connectivity. Postponing helper scripts update from github..."
  }
  
  [string] $featureDisableValue = '42'
  if ( (cpt:testInternetConnectivity) -and 
      ($savedHash -ne $currentHash) -and
      ($savedHash -ne $featureDisableValue) )
  {
    Write-Verbose "Detected changes in main script. Will redownload helper scripts from Github..."
    Write-Verbose "Current main script SHA1: $currentHash. Saved SHA1: $savedHash"
    Set-ItemProperty -path $kCptRegHiveSettings -name 'ScriptContentHash' -value $currentHash
    $shouldRedownloadForcefully = $true
  }
}

@( "io.ps1"
 , "visualstudio-detection.ps1"
 , "msbuild-expression-eval.ps1"
 , "msbuild-project-data.ps1"
 , "msbuild-project-load.ps1"
 , "msbuild-project-cache-repository.ps1"
 , "get-header-references.ps1"
 , "itemdefinition-context.ps1"
 , "jsondb-export.ps1"
 , "get-llvm-helper.ps1"
)                                                                        |
ForEach-Object { cpt:ensureScriptExists $_ $shouldRedownloadForcefully } |
ForEach-Object { . $_ }

Write-InformationTimed "Imported scripts"

#-------------------------------------------------------------------------------------------------
# do not include in list above because it is an invokable script, dot-sourcing does not work.

cpt:ensureScriptExists "get-llvm.ps1" $shouldRedownloadForcefully | Out-Null

#-------------------------------------------------------------------------------------------------
# we may have a custom path for Clang-Tidy. Use it if that's the case.

[string] $customTidyPath = (Get-QuotedPath -path ([Environment]::GetEnvironmentVariable($kVarEnvClangTidyPath)))
if (![string]::IsNullOrWhiteSpace($customTidyPath))
{
  Set-Variable -name kClangTidy                         -value $customTidyPath                    -option Constant
}
else
{
  Set-Variable -name kClangTidy                         -value "clang-tidy.exe"                   -option Constant
  Set-Variable -name kClangApplyReplacements            -value "clang-apply-replacements.exe"     -option Constant
}

Set-Variable -name kCacheRepositorySaveIsNeeded -value $false 

#-------------------------------------------------------------------------------------------------
# Custom Types


Write-InformationTimed "Before .NET enum types"

if ($kPsMajorVersion -lt 5)
{
Add-Type -TypeDefinition @"
  public enum WorkloadType
  {
    Compile,
    Tidy,
    TidyFix
  }
"@

Add-Type -TypeDefinition @"
  public enum StopReason
  {
    Unknown,
    ConfigurationNotFound
  }
"@
}
else 
{
  # this is much faster if PowerShell supports enums, we will save some time
  Invoke-Expression @"
  enum WorkloadType 
  {
    Compile
    Tidy
    TidyFix
  }

  enum StopReason 
  {
    Unknown
    ConfigurationNotFound
  }
"@
}

Write-InformationTimed "Created .NET enum types"
#-------------------------------------------------------------------------------------------------
# Global variables

# temporary files created during project processing (e.g. PCH files)
[System.Collections.ArrayList] $global:FilesToDeleteWhenScriptQuits = @()

# filePath-fileData for SLN files located in source directory
[System.Collections.Generic.Dictionary[String,String]] $global:slnFiles = @{}

# flag to signal when errors are encounteres during project processing
[Boolean]                      $global:FoundErrors                  = $false

# directory path where tidy fix replacement files will be stored
[string] $global:tidyFixReplacementDirPath = ""

# default ClangPowerTools version of visual studio to use
[string] $global:cptDefaultVisualStudioVersion = "2017"

[string[]] $global:cptIgnoredFilesPool = @()

# holds file items to process and their contextual properties (inherited + locally defined)
[System.Collections.Hashtable] $global:cptFilesToProcess = @{}

#-------------------------------------------------------------------------------------------------
# Global functions

Function Exit-Script([Parameter(Mandatory=$false)][int] $code = 0)
{
  Write-Verbose-Array -array $global:FilesToDeleteWhenScriptQuits `
                      -name "Cleaning up PCH temporaries"
  # Clean-up
  foreach ($file in $global:FilesToDeleteWhenScriptQuits)
  {
    Remove-Item -LiteralPath $file -ErrorAction SilentlyContinue > $null
  }

  if ($aTidyFixFlags)
  {
    Write-Verbose "Cleaning up temporaries tidy-fix replacements"
    Remove-Item -path $global:tidyFixReplacementDirPath -Recurse -ErrorAction SilentlyContinue > $null
  }
    
  # Restore working directory
  Pop-Location

  exit $code
}

Function Fail-Script([parameter(Mandatory=$false)][string] $msg = "Got errors.")
{
  if (![string]::IsNullOrEmpty($msg))
  {
    Write-Err $msg
  }
  Exit-Script($kScriptFailsExitCode)
}

Function Apply-TidyFixReplacements([Parameter(Mandatory=$true) ][WorkloadType] $workloadType)
{
  if ($workloadType -eq [WorkloadType]::TidyFix -and 
  (Test-Path -LiteralPath $global:tidyFixReplacementDirPath))
  {
    Write-Verbose "Apply tidy-fix replacements"
    [string] $pathToBinary =  (Join-Path -path $global:llvmLocation `
                                         -ChildPath $kClangApplyReplacements)
    & $pathToBinary $global:tidyFixReplacementDirPath
    Wait-AndProcessBuildJobs
  }
}

Function Get-SourceDirectory()
{
  [bool] $isDirectory = ($(Get-Item -LiteralPath $aSolutionsPath) -is [System.IO.DirectoryInfo])
  if ($isDirectory)
  {
    return $aSolutionsPath
  }
  else
  {
    return (Get-FileDirectory -filePath $aSolutionsPath)
  }
}

function Load-Solutions()
{
   Write-Verbose "Scanning for solution files"
   [string] $pathToCheck = $aSolutionsPath
   if ($kPsMajorVersion -lt 6)
   {
     # we need not bother with long path support in PowerShell 6+
     # only in Windows PowerShell
     $pathToCheck = "\\?\$aSolutionsPath"
   }

   $slns = Get-ChildItem -recurse -LiteralPath $pathToCheck -Filter "*$kExtensionSolution"
   foreach ($sln in $slns)
   {
     Write-Verbose "Caching solution file $sln"
     $slnPath = $sln.FullName

     # remove the UNC long path prefix
     $slnPath = $slnPath.Replace('\\?\', '')
     $global:slnFiles[$slnPath] = (Get-Content -LiteralPath $slnPath)
     
     Write-Verbose "Solution full path: $slnPath"
     Write-Verbose "Solution data length: $($global:slnFiles[$slnPath].Length)"
   }

   Write-Verbose-Array -array $global:slnFiles.Keys  -name "Solution file paths"
}

function Get-SolutionProjects([Parameter(Mandatory=$true)][string] $slnPath)
{
  Write-Verbose "Retrieving project list for solution $slnPath"
  [string] $slnDirectory = Get-FileDirectory -file $slnPath

  Write-Verbose "Solution directory: $slnDirectory"
  $matches = [regex]::Matches($global:slnFiles[$slnPath], 'Project\([{}\"A-Z0-9\-]+\) = \".*?\",\s\"(.*?)\"')

  Write-Verbose "Intermediate solution project matches count: $($matches.Count)"
  foreach ($match in $matches)
  {
    Write-Verbose $match.Groups[1].Value
  }

  [string[]] $projectAbsolutePaths = @()
  foreach ($projPathMatch in $matches)
  {
    [string] $matchValue = $projPathMatch.Groups[1].Value.Replace('"','')
    if ([string]::IsNullOrWhiteSpace($matchValue))
    {
      continue
    }

    $projExpandedPath = [Environment]::ExpandEnvironmentVariables($matchValue)
    if ( ! $projExpandedPath.EndsWith($kExtensionVcxproj))
    {
      continue
    }

    # canonize-path is smart enough to figure out if this is a relative path or not
    $projExpandedPath = Canonize-Path -base $slnDirectory -child $projExpandedPath -ignoreErrors
  
    $projectAbsolutePaths += @($projExpandedPath)
  }
  Write-Verbose-Array -array $projectAbsolutePaths -name "Resolved project paths for solution $slnPath"
  return $projectAbsolutePaths
}

function Get-ProjectSolution()
{
  foreach ($slnPath in $global:slnFiles.Keys)
  {
    [string[]] $solutionProjectPaths = @(Get-SolutionProjects $slnPath)
    if ($solutionProjectPaths -and $solutionProjectPaths -contains $global:vcxprojPath)
    {
      return $slnPath
    }
  }
  return ""
}

Function Get-Projects()
{
  [string[]] $projects = @()

  foreach ($slnPath in $global:slnFiles.Keys)
  {
    [string[]] $solutionProjects = @(Get-SolutionProjects -slnPath $slnPath)
    if ($solutionProjects -and $solutionProjects.Count -gt 0)
    {
      $projects += $solutionProjects
    }
  }

  return ($projects | Select -Unique);
}

Function Get-ClangIncludeDirectories( [Parameter(Mandatory=$false)][string[]] $includeDirectories
                                    , [Parameter(Mandatory=$false)][string[]] $additionalIncludeDirectories
                                    )
{
  [string[]] $returnDirs = @()

  foreach ($includeDir in $includeDirectories)
  {
    $returnDirs += ("-isystem" + (Get-QuotedPath $includeDir))
  }
  foreach ($includeDir in $additionalIncludeDirectories)
  {
    if ($aTreatAdditionalIncludesAsSystemIncludes)
    {
      $returnDirs += ("-isystem" + (Get-QuotedPath $includeDir))
    }
    else
    {
      $returnDirs += ("-I"+ (Get-QuotedPath $includeDir))
    }
  }

  return $returnDirs
}

Function Get-ProjectFileLanguageFlag([Parameter(Mandatory=$true)] [string]   $fileFullName)
{
  [bool] $isCpp = $true
  if ($fileFullName.EndsWith($kExtensionC))
  {
    $isCpp = $false
  }

  try
  {
    [string] $compileAsVal = (Get-ProjectFileSetting -fileFullName $fileFullName -propertyName "CompileAs")
    [bool] $isDefault = [string]::IsNullOrWhiteSpace($compileAsVal) -or $compileAsVal -ieq "Default"
    if ($isDefault)
    {
      $isCpp = ! $fileFullName.EndsWith($kExtensionC)
    }
    else 
    {
      $isCpp = $compileAsVal -ine $kCProjectCompile
    }
  }  
  catch {}

  [string] $languageFlag = If ($isCpp) { $kClangFlagFileIsCPP } else { $kClangFlagFileIsC }

  return $languageFlag
}

Function Generate-Pch( [Parameter(Mandatory=$true)] [string]   $stdafxDir
                     , [Parameter(Mandatory=$true)] [string]   $stdafxCpp
                     , [Parameter(Mandatory=$false)][string[]] $includeDirectories
                     , [Parameter(Mandatory=$false)][string[]] $additionalIncludeDirectories
                     , [Parameter(Mandatory=$true)] [string]   $stdafxHeaderName
                     , [Parameter(Mandatory=$false)][string[]] $preprocessorDefinitions)
{
  [string] $stdafxSource = (Canonize-Path -base $stdafxDir -child $stdafxHeaderName)
  [string] $stdafx = $stdafxSource + ".hpp"

  # Clients using Perforce will have their source checked-out as readonly files, so the 
  # PCH copy would be, by-default, readonly as well, which would present problems. Make sure to remove the RO attribute.
  Copy-Item -LiteralPath $stdafxSource -Destination $stdafx -PassThru | Set-ItemProperty -name isreadonly -Value $false

  $global:FilesToDeleteWhenScriptQuits.Add($stdafx) > $null

  [string] $vcxprojShortName = [System.IO.Path]::GetFileNameWithoutExtension($global:vcxprojPath);
  [string] $stdafxPch = (Join-Path -path (Get-SourceDirectory) `
                                   -ChildPath "$vcxprojShortName$kExtensionClangPch")
  Remove-Item -LiteralPath "$stdafxPch" -ErrorAction SilentlyContinue > $null

  $global:FilesToDeleteWhenScriptQuits.Add($stdafxPch) > $null

  [string] $languageFlag = (Get-ProjectFileLanguageFlag -fileFullName $stdafxCpp)

  [string[]] $compilationFlags = @((Get-QuotedPath $stdafx)
                                  ,$kClangFlagMinusO
                                  ,(Get-QuotedPath $stdafxPch)
                                  ,$languageFlag
                                  ,(Get-ClangCompileFlags -isCpp ($languageFlag -ieq $kClangFlagFileIsCPP))
                                  ,$kClangFlagNoUnusedArg
                                  ,$preprocessorDefinitions
                                  )
  if ($kLLVMVersion -ge 11)
  {
    # this flag gets around 15% faster PCH compilation times
    # https://www.phoronix.com/scan.php?page=news_item&px=LLVM-Clang-11-PCH-Instant-Temp
    $compilationFlags += $kClangFlagFasterPch
  }

  $compilationFlags += Get-ClangIncludeDirectories -includeDirectories           $includeDirectories `
                                                   -additionalIncludeDirectories $additionalIncludeDirectories

  # Remove empty arguments from the list because Start-Process will complain
  $compilationFlags = $compilationFlags | Where-Object { $_ } | Select -Unique

  [string] $exeToCallVerbosePath  = $kClangCompiler
  if (![string]::IsNullOrWhiteSpace($global:llvmLocation))
  {
    $exeToCallVerbosePath = "$($global:llvmLocation)\$exeToCallVerbosePath"
  }
  Write-Verbose "INVOKE: $exeToCallVerbosePath $compilationFlags"

  $kClangWorkingDir = "$(Get-SourceDirectory)" -replace '\[', '`[' -replace ']', '`]'
  # We could skip the WorkingDir parameter as all paths are absolute but 
  # Powershell 3-5 has a bug when calling Start-Process from a directory containing square brackets
  # in its path. This can be overcome by providing escaped brackets in the WorkingDirectory arg.
  # Powershell 7 does not have this limitation.
  [System.Diagnostics.Process] $processInfo = Start-Process -FilePath $kClangCompiler `
                                                            -ArgumentList $compilationFlags `
                                                            -WorkingDirectory $kClangWorkingDir `
                                                            -NoNewWindow `
                                                            -Wait `
                                                            -PassThru
  if (($processInfo.ExitCode -ne 0) -and (!$aContinueOnError))
  {
    Fail-Script "Errors encountered during PCH creation"
  }

  if (Test-Path -LiteralPath $stdafxPch)
  {
    return $stdafxPch
  }
  else
  {
    return ""
  }
}

Function Get-ExeToCall([Parameter(Mandatory=$true)][WorkloadType] $workloadType)
{
  switch ($workloadType)
  {
     "Compile"  { return $kClangCompiler }
     "Tidy"     { return $kClangTidy     }
     "TidyFix"  { return $kClangTidy     }
  }
}

Function Get-CompileCallArguments( [Parameter(Mandatory=$false)][string[]] $preprocessorDefinitions
                                 , [Parameter(Mandatory=$false)][string[]] $includeDirectories
                                 , [Parameter(Mandatory=$false)][string[]] $additionalIncludeDirectories
                                 , [Parameter(Mandatory=$false)][string[]] $forceIncludeFiles
                                 , [Parameter(Mandatory=$false)][string]   $pchFilePath
                                 , [Parameter(Mandatory=$true)][string]    $fileToCompile)
{
  [string[]] $projectCompileArgs = @()
  if (! [string]::IsNullOrEmpty($pchFilePath) -and ! $fileToCompile.EndsWith($kExtensionC))
  {
    $projectCompileArgs += @($kClangFlagIncludePch , (Get-QuotedPath $pchFilePath))
  }

  [string] $languageFlag = (Get-ProjectFileLanguageFlag -fileFullName $fileToCompile)

  $projectCompileArgs += @( $languageFlag
                          , (Get-QuotedPath $fileToCompile)
                          , @(Get-ClangCompileFlags -isCpp ($languageFlag -ieq $kClangFlagFileIsCPP))
                          , $kClangFlagSupressLINK
                          , $preprocessorDefinitions
                          )

  $projectCompileArgs += Get-ClangIncludeDirectories -includeDirectories           $includeDirectories `
                                                     -additionalIncludeDirectories $additionalIncludeDirectories

  if ($forceIncludeFiles)
  {
    $projectCompileArgs += $kClangFlagNoMsInclude;

    foreach ($file in $forceIncludeFiles)
    {
      $projectCompileArgs += "$kClangFlagForceInclude $(Get-QuotedPath $file)"
    }
  }

  return $projectCompileArgs
}

Function Get-TidyCallArguments( [Parameter(Mandatory=$false)][string[]] $preprocessorDefinitions
                              , [Parameter(Mandatory=$false)][string[]] $includeDirectories
                              , [Parameter(Mandatory=$false)][string[]] $additionalIncludeDirectories
                              , [Parameter(Mandatory=$false)][string[]] $forceIncludeFiles
                              , [Parameter(Mandatory=$true)][string]   $fileToTidy
                              , [Parameter(Mandatory=$false)][string]  $pchFilePath
                              , [Parameter(Mandatory=$false)][switch]  $fix)
{
  [string[]] $tidyArgs = @()
  if ($fix)
  {
    # Map tidy-fix replacements temprorary file path to original file path
    if(![string]::IsNullOrEmpty($fileToTidy))
    {
      [string] $tidyFixReplacementYamlPath = Join-Path  -Path ($global:tidyFixReplacementDirPath) `
                                                        -ChildPath ([guid]::NewGuid().ToString() + $kExtensionYaml)
      $tidyArgs += $kClangTidyFixExportFixes + @((Get-QuotedPath $tidyFixReplacementYamlPath))
    }
  }

  $tidyArgs += (Get-QuotedPath $fileToTidy)
  if (![string]::IsNullOrWhiteSpace($aTidyFlags) -and ($aTidyFlags -ne $kClangTidyUseFile) -and !(Test-Path $aTidyFlags))
  {
    $tidyArgs += "$kClangTidyFlagChecks`"$aTidyFlags`""
  }  
  if (![string]::IsNullOrWhiteSpace($aTidyFixFlags) -and ($aTidyFixFlags -ne $kClangTidyUseFile) -and !(Test-Path $aTidyFixFlags))
  {
    $tidyArgs += "$kClangTidyFlagChecks`"$aTidyFixFlags`""
  }

  # The header-filter flag enables clang-tidy to run on headers too.
  if (![string]::IsNullOrEmpty($aTidyHeaderFilter))
  {
    if ($aTidyHeaderFilter -eq '_')
    {
      [string] $fileNameMatch = """$(Get-FileName -path $fileToTidy -noext).*"""
      $tidyArgs += "$kClangTidyFlagHeaderFilter$fileNameMatch"
    }
    else
    {
      $tidyArgs += "$kClangTidyFlagHeaderFilter""$aTidyHeaderFilter"""
    }
  }

  if ($fix)
  {
    if (![string]::IsNullOrEmpty($aAfterTidyFixFormatStyle))
    {
      $tidyArgs += "$kClangTidyFormatStyle$aAfterTidyFixFormatStyle"
    }
  }
  $tidyArgs += $kClangTidyFlags

  $tidyArgs += Get-ClangIncludeDirectories -includeDirectories           $includeDirectories `
                                           -additionalIncludeDirectories $additionalIncludeDirectories

  [string] $languageFlag = (Get-ProjectFileLanguageFlag -fileFullName $fileToTidy)

  # We reuse flags used for compilation and preprocessor definitions.
  $tidyArgs += @(Get-ClangCompileFlags -isCpp ($languageFlag -ieq $kClangFlagFileIsCPP))
  $tidyArgs += $preprocessorDefinitions
  $tidyArgs += $languageFlag

  if (! [string]::IsNullOrEmpty($pchFilePath) -and ! $fileToTidy.EndsWith($kExtensionC))
  {
    $tidyArgs += @($kClangFlagIncludePch , (Get-QuotedPath $pchFilePath))
  }

  if ($forceIncludeFiles)
  {
    $tidyArgs += $kClangFlagNoMsInclude;

    foreach ($file in $forceIncludeFiles)
    {
      $tidyArgs += "$kClangFlagForceInclude $file"
    }
  }

  return $tidyArgs
}

Function Get-ExeCallArguments( [Parameter(Mandatory=$false)][string]       $pchFilePath
                             , [Parameter(Mandatory=$false)][string[]]     $includeDirectories
                             , [Parameter(Mandatory=$false)][string[]]     $additionalIncludeDirectories
                             , [Parameter(Mandatory=$false)][string[]]     $preprocessorDefinitions
                             , [Parameter(Mandatory=$false)][string[]]     $forceIncludeFiles
                             , [Parameter(Mandatory=$true) ][string]       $currentFile
                             , [Parameter(Mandatory=$true) ][WorkloadType] $workloadType)
{
  switch ($workloadType)
  {
    Compile { return Get-CompileCallArguments -preprocessorDefinitions       $preprocessorDefinitions `
                                              -includeDirectories            $includeDirectories `
                                              -additionalIncludeDirectories  $additionalIncludeDirectories `
                                              -forceIncludeFiles             $forceIncludeFiles `
                                              -pchFilePath                   $pchFilePath `
                                              -fileToCompile                 $currentFile }
    Tidy    { return Get-TidyCallArguments -preprocessorDefinitions       $preprocessorDefinitions `
                                           -includeDirectories            $includeDirectories `
                                           -additionalIncludeDirectories  $additionalIncludeDirectories `
                                           -forceIncludeFiles             $forceIncludeFiles `
                                           -pchFilePath                   $pchFilePath `
                                           -fileToTidy                    $currentFile }
    TidyFix { return Get-TidyCallArguments -preprocessorDefinitions       $preprocessorDefinitions `
                                           -includeDirectories            $includeDirectories `
                                           -additionalIncludeDirectories  $additionalIncludeDirectories `
                                           -forceIncludeFiles             $forceIncludeFiles `
                                           -pchFilePath                   $pchFilePath `
                                           -fileToTidy                    $currentFile `
                                           -fix}
  }
}

Function Process-ProjectResult($compileResult)
{
  $global:cptCurrentClangJobCounter = $compileResult.JobCounter
  Write-Debug "Receiving results for clang job $($global:cptCurrentClangJobCounter)"

  if (!$compileResult.Success)
  {
    Write-Err ($compileResult.Output)

    if (!$aContinueOnError)
    {
      # Wait for other workers to finish. They have a lock on the PCH file
      Get-Job -state Running | Wait-Job | Remove-Job > $null
      Fail-Script
    }

    $global:FoundErrors = $true
  }
  else
  {
    if ( $compileResult.Output.Length -gt 0)
    {
      Write-Output $compileResult.Output
    }
  }
}

Function Wait-AndProcessBuildJobs([switch]$any)
{
  $runningJobs = @(Get-Job -state Running)

  if ($any)
  {
    $runningJobs | Wait-Job -Any > $null
  }
  else
  {
    $runningJobs | Wait-Job > $null
  }

  $jobData = Get-Job -State Completed
  foreach ($job in $jobData)
  {
    $buildResult = Receive-Job $job
    Process-ProjectResult -compileResult $buildResult
  }

  Remove-Job -State Completed
}

Function Wait-ForWorkerJobSlot()
{
  # We allow as many background workers as we have logical CPU cores
  $runningJobs = @(Get-Job -State Running)

  if ($runningJobs.Count -ge $kLogicalCoreCount)
  {
    Wait-AndProcessBuildJobs -any
  }
}

Function Run-ClangJobs( [Parameter(Mandatory=$true)] $clangJobs
                      , [Parameter(Mandatory=$true)][WorkloadType] $workloadType
                      )
{
  # Script block (lambda) for logic to be used when running a clang job.
  $jobWorkToBeDone = `
  {
    param( $job )

    Push-Location -LiteralPath $job.WorkingDirectory

    # This temp file will hold compilation args for clang++ and clang-tidy, not to be
    # confused with check-flags for clang-tidy.
    [string] $clangConfigFile = [System.IO.Path]::GetTempFileName()

    [string] $clangConfigContent = ""
    if ($job.FilePath -like '*tidy*')
    {
      # We have to separate Clang args from Tidy args
      $splitparams = $job.ArgumentList -split " -- "
      $clangConfigContent = $splitparams[1]

      # We may have an explicit .clang-tidy check-flag config file to be used
      if (![string]::IsNullOrWhiteSpace($job.TidyFlagsTempFile) -and (Test-Path -LiteralPath $job.TidyFlagsTempFile))
      {
        $splitparams[0] += " --config-file=""$($job.TidyFlagsTempFile)"" "
      }

      $job.ArgumentList = "$($splitparams[0]) -- --config ""$clangConfigFile"""
    }
    else
    {
      # Tell Clang to take its compilation args from a config file
      $clangConfigContent = $job.ArgumentList
      $job.ArgumentList = "--config ""$clangConfigFile"""
    }

    # escape slashes for file paths
    # make sure escaped double quotes are not messed up
    $clangConfigContent = $clangConfigContent -replace '\\([^"])', '\\$1'

    # save compilation arguments to clang config file
    $clangConfigContent > $clangConfigFile

    # When PowerShell encounters errors, the first one is handled differently from consecutive ones
    # To circumvent this, do not execute the job directly, but execute it via cmd.exe
    # See also https://stackoverflow.com/a/35980675
    
    $callOutput = cmd /c "$($job.FilePath) $($job.ArgumentList) 2>&1" | Out-String

    $callSuccess = $LASTEXITCODE -eq 0
    if (!$callSuccess)
    {
    }

    Remove-Item $clangConfigFile
    Pop-Location

    return New-Object PsObject -Prop @{ "File"    = $job.File
                                      ; "Success" = $callSuccess
                                      ; "Output"  = $callOutput
                                      ; "JobCounter" = $job.JobCounter
                                      }
  }

  if (!$aResumeAfterError)
  {
    $global:cptCurrentClangJobCounter = $clangJobs.Count
  }
  else
  {
    if (!(VariableExists 'cptCurrentClangJobCounter'))
    {
      Write-Warning "Can't resume. Previous state is unreliable. Processing all files..."
      $global:cptCurrentClangJobCounter = $clangJobs.Count
    }
    else
    {
      if ($global:cptCurrentClangJobCounter -gt 0)
      {
        Write-Output "Resuming from file #$($global:cptCurrentClangJobCounter)"
      }
    }
  }

  [int] $crtJobCount = $clangJobs.Count

  foreach ($job in $clangJobs)
  {
    if ($global:cptCurrentClangJobCounter -ge 0 -and $crtJobCount -gt $global:cptCurrentClangJobCounter)
    {
      $crtJobCount--
      continue
    }

    $job.JobCounter = $crtJobCount

    # Check if we must wait for background jobs to complete
    Wait-ForWorkerJobSlot

    # Inform console what CPP we are processing next
    Write-Output "$($crtJobCount): $($job.File)"

    if ($aUseParallelCompile)
    {
      Start-Job -ScriptBlock  $jobWorkToBeDone `
                -ArgumentList $job `
                -ErrorAction Continue > $null
    }
    else
    {
      $compileResult = Invoke-Command -ScriptBlock  $jobWorkToBeDone `
                                      -ArgumentList $job
      Process-ProjectResult -compileResult $compileResult
      $global:cptCurrentClangJobCounter = $compileResult.JobCounter
    }

    $crtJobCount -= 1
  }

  Wait-AndProcessBuildJobs

  $global:cptCurrentClangJobCounter = -1 # stop the mechanism after one project
}

Function Get-ProjectFileSetting( [Parameter(Mandatory=$true)] [string] $fileFullName
                               , [Parameter(Mandatory=$true)] [string] $propertyName
                               , [Parameter(Mandatory=$false)][string] $defaultValue)
{
  if (!$global:cptFilesToProcess.ContainsKey($fileFullName))
  {
    throw "File $aFileFullName is not in processing queue."
  }

  if ($global:cptFilesToProcess[$fileFullName].Properties -and
      $global:cptFilesToProcess[$fileFullName].Properties.ContainsKey($propertyName))
  {
    return $global:cptFilesToProcess[$fileFullName].Properties[$propertyName]
  }

  if ($defaultValue -ne $null)
  {
    return $defaultValue
  }

  throw "Could not find $propertyName for $fileFullName. No default value specified."
}

Function Process-Project( [Parameter(Mandatory=$true)] [string]       $vcxprojPath
                        , [Parameter(Mandatory=$true)] [WorkloadType] $workloadType
                        , [Parameter(Mandatory=$false)][string]       $platformConfig
                        )
{
  #-----------------------------------------------------------------------------------------------
  $global:cptCurrentConfigPlatform = $platformConfig

  $projCounter = $global:cptProjectCounter
  [string] $projectOutputString = ("PROJECT$(if ($projCounter -gt 1) { " #$projCounter" } else { } ): " + $vcxprojPath)
  
  [bool] $loadedFromCache = $false
  try
  { 
    Set-Variable 'kCacheRepositorySaveIsNeeded' -value $false
    Write-InformationTimed "Before project load"
    
    if (Is-CacheLoadingEnabled)
    {
      Write-InformationTimed "Trying to load project from cache"
      $loadedFromCache = Load-ProjectFromCache $vcxprojPath
      
      if (!$loadedFromCache)
      {
        LoadProject $vcxprojPath
        Set-Variable 'kCacheRepositorySaveIsNeeded' -value $true
      }
    }
    else 
    {
      LoadProject $vcxprojPath
    }
    
    Write-InformationTimed "After project load"
    Write-Output "$projectOutputString [$($global:cptCurrentConfigPlatform)]"
  }
  catch [ProjectConfigurationNotFound]
  {
    [string] $configPlatform = ([ProjectConfigurationNotFound]$_.Exception).ConfigPlatform
    
    Write-Output "$projectOutputString [$($global:cptCurrentConfigPlatform)]"
    Write-Output ("Skipped. Configuration not present: " + $configPlatform);
    
    Pop-Location
    return
  }
  
  Write-InformationTimed "Detecting toolset"

  #-----------------------------------------------------------------------------------------------
  # DETECT PLATFORM TOOLSET

  if (! $loadedFromCache)
  {
    [string] $global:platformToolset = Get-ProjectPlatformToolset
    Write-Verbose "Platform toolset: $platformToolset"
    Add-ToProjectSpecificVariables 'platformToolset'

    if ( $platformToolset -match "^v\d+(_xp)?$" )
    {
      [int] $toolsetVersion = [int]$platformToolset.Remove(0, 1).Replace("_xp", "")

      [string] $desiredVisualStudioVer = ""

      # toolsets attached to specific Visual Studio versions
      if ($toolsetVersion -le 120)
      {
        $desiredVisualStudioVer = "2013"
      }
      elseif ($toolsetVersion -eq 140)
      {
        $desiredVisualStudioVer = "2015"
      }
      elseif ($toolsetVersion -eq 141)
      {
        $desiredVisualStudioVer = "2017"
      }
      elseif ($toolsetVersion -eq 142)
      {
        $desiredVisualStudioVer = "2019";
      }
      elseif ($toolsetVersion -eq 143)
      {
        $desiredVisualStudioVer = "2022";
      }

      [string] $desiredVisualStudioVerNumber = (Get-VisualStudio-VersionNumber $desiredVisualStudioVer)
      if ($VisualStudioVersion -ne $desiredVisualStudioVerNumber)
      {
        [bool] $shouldReload = $false

        if ([double]::Parse($VisualStudioVersion) -gt [double]::Parse($desiredVisualStudioVerNumber))
        {
          # in this case we may have a newer Visual Studio with older toolsets installed
          [string[]] $supportedVsToolsets = Get-VisualStudioToolsets
    
          if ($supportedVsToolsets -notcontains $toolsetVersion)
          {
              $shouldReload = $true
          }
          else 
          {
            Write-Verbose "[ INFO ] Detected project using older toolset ($toolsetVersion)"
            Write-Verbose "Loading using Visual Studio $VisualStudioVersion with toolset $toolsetVersion"
          }
        }
        else 
        {
          # project uses a newer VS version, clearly we should reload using the newer version
          $shouldReload = $true
        }

        if ($shouldReload)
        {
          # We need to reload everything and use the VS version we decided upon above
          Write-Verbose "[ RELOAD ] Project will reload because of toolset requirements change..."
          Write-Verbose "Current = $VisualStudioVersion. Required = $desiredVisualStudioVerNumber."

          $global:cptVisualStudioVersion = $desiredVisualStudioVer
          LoadProject($vcxprojPath)
          
          Write-InformationTimed "Project reloaded"
        }
      }
    }
  
    Write-InformationTimed "Detected toolset"

    #-----------------------------------------------------------------------------------------------
    # FIND FORCE INCLUDES

    [string[]] $global:forceIncludeFiles = @(Get-ProjectForceIncludes)
    Write-Verbose-Array -array $forceIncludeFiles -name "Force includes"
    Add-ToProjectSpecificVariables 'forceIncludeFiles'

    #-----------------------------------------------------------------------------------------------
    # DETECT PROJECT PREPROCESSOR DEFINITIONS

    [string[]] $global:preprocessorDefinitions = @(Get-ProjectPreprocessorDefines)
    if ([int]$global:cptVisualStudioVersion -ge 2017)
    {
      # [HACK] pch generation crashes on VS 15.5 because of STL library, known bug.
      # Triggered by addition of line directives to improve std::function debugging.
      # There's a definition that supresses line directives.

      $preprocessorDefinitions += @('"-D_DEBUG_FUNCTIONAL_MACHINERY"')
    }
    Add-ToProjectSpecificVariables 'preprocessorDefinitions'
    
    Write-InformationTimed "Detected preprocessor definitions"

    Write-Verbose-Array -array $preprocessorDefinitions -name "Preprocessor definitions"

    #-----------------------------------------------------------------------------------------------
    # DETECT PROJECT ADDITIONAL INCLUDE DIRECTORIES AND CONSTRUCT INCLUDE PATHS

    [string[]] $global:additionalIncludeDirectories = @(Get-ProjectAdditionalIncludes)
    Write-Verbose-Array -array $additionalIncludeDirectories -name "Additional include directories"
    Add-ToProjectSpecificVariables 'additionalIncludeDirectories'

    [string[]] $includeDirectories = @(Get-ProjectIncludeDirectories)
    Write-Verbose-Array -array $includeDirectories -name "Include directories"
    Add-ToProjectSpecificVariables 'includeDirectories'

    Write-InformationTimed "Detected include directories"

    #-----------------------------------------------------------------------------------------------
    # FIND LIST OF CPPs TO PROCESS

    $global:projectAllCpps = @{}
    foreach ($fileToCompileInfo in (Get-ProjectFilesToCompile))
    {
      if ($fileToCompileInfo.File)
      {
        $global:projectAllCpps[$fileToCompileInfo.File] = $fileToCompileInfo
      }
    }
    
    Add-ToProjectSpecificVariables 'projectAllCpps'
    
    Write-InformationTimed "Detected cpps to process"
  } # past the caching boundary here, we must see what else needs to be computed live 
  
  $global:cptFilesToProcess = $global:projectAllCpps # reset to full project cpp list
  
  #-----------------------------------------------------------------------------------------------
  # LOCATE STDAFX.H DIRECTORY

  [string] $stdafxCpp    = ""
  [string] $stdafxDir    = ""
  [string] $stdafxHeader = ""
  [string] $stdafxHeaderFullPath = ""

  [bool] $kPchIsNeeded = $global:cptFilesToProcess.Keys.Count -ge 2
  if ($kPchIsNeeded)
  {
    # if we have only one rooted file in the script parameters, then we don't need to detect PCH
    if ($aCppToCompile.Count -eq 1 -and [System.IO.Path]::IsPathRooted($aCppToCompile[0]))
    {
      $kPchIsNeeded = $false
    }
  }

  foreach ($projCpp in $global:cptFilesToProcess.Keys)
  {
    if ( (Get-ProjectFileSetting -fileFullName $projCpp -propertyName 'PrecompiledHeader') -ieq 'Create')
    {
      $stdafxCpp = $projCpp
    }
  }

  if (![string]::IsNullOrEmpty($stdafxCpp))
  {
    Write-Verbose "PCH cpp name: $stdafxCpp"

    if ($forceIncludeFiles.Count -gt 0)
    {
      $stdafxHeader = $forceIncludeFiles[0]
    }

    if (!$stdafxHeader)
    {
      $stdafxHeader = Get-PchCppIncludeHeader -pchCppFile $stdafxCpp
    }

    if (!$stdafxHeader)
    {
      try
      {
        $stdafxHeader = Get-ProjectFileSetting -fileFullName $stdafxCpp -propertyName 'PrecompiledHeaderFile'
      }
      catch {}
    }

    Write-Verbose "PCH header name: $stdafxHeader"
    $stdafxDir = Get-ProjectStdafxDir -pchHeaderName                $stdafxHeader       `
                                      -includeDirectories           $includeDirectories `
                                      -additionalIncludeDirectories $additionalIncludeDirectories
  }

  if ([string]::IsNullOrEmpty($stdafxDir))
  {
    Write-Verbose ("No PCH information for this project!")
    $kPchIsNeeded = $false
  }
  else
  {
    Write-Verbose ("PCH directory: $stdafxDir")

    $includeDirectories = @(Remove-PathTrailingSlash -path $stdafxDir) + $includeDirectories

    $stdafxHeaderFullPath = Canonize-Path -base $stdafxDir -child $stdafxHeader -ignoreErrors

    if (!$kPchIsNeeded)
    {
      Write-Verbose "PCH is disabled for this project. Will not generate."
    }
  }
  
  Write-InformationTimed "Detected PCH information"


  #-----------------------------------------------------------------------------------------------
  # FILTER LIST OF CPPs TO PROCESS
  if ($global:cptFilesToProcess.Count -gt 0 -and $aCppToIgnore.Count -gt 0)
  {
    [System.Collections.Hashtable] $filteredCpps = @{}
    foreach ($cpp in $global:cptFilesToProcess.Keys)
    {
      if ( ! (Should-IgnoreFile -file $cpp) )
      {
        $filteredCpps[$cpp] = $global:cptFilesToProcess[$cpp]
      }
    }
    $global:cptFilesToProcess = $filteredCpps
  }

  if ($global:cptFilesToProcess.Count -gt 0 -and $aCppToCompile.Count -gt 0)
  {
    [System.Collections.Hashtable] $filteredCpps = @{}
    [bool] $dirtyStdafx = $false
    foreach ($cpp in $aCppToCompile)
    {
      if ($cpp -ieq $stdafxHeaderFullPath)
      {
        # stdafx modified => compile all
        $dirtyStdafx = $true
        break
      }

      if (![string]::IsNullOrEmpty($cpp))
      {
        if ([System.IO.Path]::IsPathRooted($cpp))
        {
          if ($global:cptFilesToProcess.ContainsKey($cpp))
          {
            # really fast, use cache
            $filteredCpps[$cpp] = $global:cptFilesToProcess[$cpp]
          }
        }
        else
        {
          # take the slow road and check if it matches
          $global:cptFilesToProcess.Keys | Where-Object {  IsFileMatchingName -filePath $_ -matchName $cpp } | `
                                           ForEach-Object { $filteredCpps[$_] = $global:cptFilesToProcess[$_] }
        }
      }
    }

    if (!$dirtyStdafx)
    {
      $global:cptFilesToProcess = $filteredCpps
    }
    else
    {
      Write-Verbose "PCH header has been targeted as dirty. Building entire project"
    }
  }
  
  Write-InformationTimed "Filtered out CPPs from bucket"

  Write-Verbose ("Processing " + $global:cptFilesToProcess.Count + " cpps")

  #-----------------------------------------------------------------------------------------------
  # CREATE PCH IF NEED BE, ONLY FOR TWO CPPS OR MORE
  #
  # JSON Compilation Database file will outlive this execution run, while the PCH is temporary 
  # so we disable PCH creation for that case as well.

  if ($kPchIsNeeded -and $global:cptFilesToProcess.Count -lt 2)
  {
    $kPchIsNeeded = $false
  }

  [string] $pchFilePath = ""
  if ($kPchIsNeeded -and !$aExportJsonDB)
  {
    # COMPILE PCH
    Write-Verbose "Generating PCH..."
    $pchFilePath = Generate-Pch -stdafxDir        $stdafxDir    `
                                -stdafxCpp        $stdafxCpp    `
                                -stdafxHeaderName $stdafxHeader `
                                -preprocessorDefinitions $preprocessorDefinitions `
                                -includeDirectories $includeDirectories `
                                -additionalIncludeDirectories $additionalIncludeDirectories
    Write-Verbose "PCH: $pchFilePath"
    if ([string]::IsNullOrEmpty($pchFilePath) -and $aContinueOnError)
    {
      Write-Output "Skipping project. Reason: cannot create PCH."
      return
    }
    Write-InformationTimed "Created PCH"
  }  

  if ($kCacheRepositorySaveIsNeeded)
  {
    Write-InformationTimed "Before serializing project"
    Save-ProjectToCacheRepo
    Write-InformationTimed "After serializing project"
  }

  #-----------------------------------------------------------------------------------------------
  # PROCESS CPP FILES. CONSTRUCT COMMAND LINE JOBS TO BE INVOKED

  $clangJobs = @()

  # Create directory where to store tidy fix replacements
  if ($aTidyFixFlags)
  {
    $global:tidyFixReplacementDirPath = (Join-Path -path $kCptTidyFixReplacementsDir `
                                                   -ChildPath (Split-Path (Get-SourceDirectory) -Leaf)) `
                                                   + "_" + ([guid]::NewGuid().ToString())
    # check if SolutionDir for tidy fix replacements already exists
    if (Test-Path -LiteralPath $global:tidyFixReplacementDirPath)
    {
      Remove-Item $global:tidyFixReplacementDirPath -Recurse
      New-Item -Path $global:tidyFixReplacementDirPath -ItemType "directory" > $null
    }
    else
    {
      New-Item -Path $global:tidyFixReplacementDirPath -ItemType "directory" > $null
    }
  }

  foreach ($cpp in $global:cptFilesToProcess.Keys)
  {
    [string] $cppPchSetting = Get-ProjectFileSetting -propertyName 'PrecompiledHeader' -fileFullName $cpp -defaultValue 'Use'

    if ($cppPchSetting -ieq 'Create')
    {
        continue # no point in compiling the PCH CPP
    }

    [string[]] $cppForceIncludes = Get-FileForceIncludes -fileFullName $cpp
    [string] $exeToCall = Get-ExeToCall -workloadType $workloadType

    [string] $finalPchPath = $pchFilePath
    if ($cppPchSetting -ieq 'NotUsing')
    {
      $finalPchPath = ""
      Write-Verbose "`n[PCH] Will ignore precompiled headers for $cpp`n"
    }

    [string] $exeArgs   = Get-ExeCallArguments -workloadType            $workloadType `
                                               -pchFilePath             $finalPchPath `
                                               -preprocessorDefinitions $preprocessorDefinitions `
                                               -forceIncludeFiles       $cppForceIncludes `
                                               -currentFile             $cpp `
                                               -includeDirectories      $includeDirectories `
                                               -additionalIncludeDirectories $additionalIncludeDirectories

    $newJob = New-Object PsObject -Prop @{ 'FilePath'          = $exeToCall
                                         ; 'WorkingDirectory'  = Get-SourceDirectory
                                         ; 'ArgumentList'      = $exeArgs
                                         ; 'File'              = $cpp
                                         ; 'JobCounter'        = 0 <# will be lazy initialized #>
                                         ; 'TidyFlagsTempFile' = $kClangTidyFlagTempFile
                                         }
    $clangJobs += $newJob
  }
  
  Write-InformationTimed "Created job workers"

  #-----------------------------------------------------------------------------------------------
  # PRINT DIAGNOSTICS

  if ($clangJobs.Count -ge 1)
  {
    [string] $exeToCallVerbosePath  = $exeToCall
    if (![string]::IsNullOrWhiteSpace($global:llvmLocation))
    {
      $exeToCallVerbosePath = "$($global:llvmLocation)\$exeToCallVerbosePath"
    }
    Write-Verbose "INVOKE: $exeToCallVerbosePath $($clangJobs[0].ArgumentList)"
  }

  Write-InformationTimed "Running workers"

  #-----------------------------------------------------------------------------------------------
  # RUN CLANG JOBS
  
  if ($aExportJsonDB)
  {
   foreach ($job in $clangJobs)
   {
     [string] $clangToolPath = $job.FilePath
     if (Exists-Command $clangToolPath)
     {
       # see precisely what path the tool has, to prevent ambiguities.
       $clangToolPath = (Get-Command $job.FilePath).Source
     }
     [string] $clangCommand = """$clangToolPath"" $($job.ArgumentList)"
     JsonDB-Push -directory $job.WorkingDirectory -file $job.File -command $clangCommand
   }
  }
  else 
  {
    Run-ClangJobs -clangJobs $clangJobs -workloadType $workloadType
    Apply-TidyFixReplacements -workloadType $workloadType
  }
}

#-------------------------------------------------------------------------------------------------
# Script entry point

Clear-Host # clears console

Write-InformationTimed "Cleared console. Let's begin..."

#-------------------------------------------------------------------------------------------------
# If we didn't get a location to run CPT at, use the current working directory

if (!$aSolutionsPath)
{
  $aSolutionsPath = (Get-Location).Path
}

# ------------------------------------------------------------------------------------------------
# Load param values from configuration file (if exists)

Update-ParametersFromConfigFile
Write-InformationTimed "Updated script parameters from cpt.config"

# ------------------------------------------------------------------------------------------------
# Initialize the Visual Studio version variable

$global:cptVisualStudioVersion = If ( $aVisualStudioVersion ) `
                                    { $aVisualStudioVersion } Else `
                                    { $global:cptDefaultVisualStudioVersion }

#-------------------------------------------------------------------------------------------------
# Print script parameters

Print-InvocationArguments
Write-InformationTimed "Print args"

[WorkloadType] $workloadType = [WorkloadType]::Compile

if (![string]::IsNullOrEmpty($aTidyFlags))
{
   $workloadType = [WorkloadType]::Tidy
   if (Test-Path -LiteralPath $aTidyFlags)
   {
     $kClangTidyFlagTempFile = $aTidyFlags
   }
}

if (![string]::IsNullOrEmpty($aTidyFixFlags))
{
   $workloadType = [WorkloadType]::TidyFix
   if (Test-Path -LiteralPath $aTidyFixFlags)
   {
     $kClangTidyFlagTempFile = $aTidyFixFlags
   }
}

#-------------------------------------------------------------------------------------------------
# Script entry point

Write-Verbose "CPU logical core count: $kLogicalCoreCount"

# If LLVM is not in PATH try to detect it automatically
[string] $global:llvmLocation = ""

$clangToolWeNeed = Get-ExeToCall -workloadType $workloadType

$global:llvmLocation = Ensure-LLVMTool-IsPresent $clangToolWeNeed
if ($aTidyFixFlags)
{
  Ensure-LLVMTool-IsPresent $kClangApplyReplacements
}
if (![string]::IsNullOrEmpty($global:llvmLocation))
{
  $env:Path += ";" + $global:llvmLocation
}
Set-Variable -name "kLLVMVersion" -value (Get-ClangVersion $clangToolWeNeed) -scope Global

# initialize JSON compilation db support, if required
if ($aExportJsonDB) 
{ 
  JsonDB-Init 
}

Push-Location -LiteralPath (Get-SourceDirectory)

Write-InformationTimed "Searching for solutions"

# fetch .sln paths and data
Load-Solutions

Write-InformationTimed "End solution search"

# This PowerShell process may already have completed jobs. Discard them.
Remove-Job -State Completed
Write-InformationTimed "Discarded already finished jobs"

Write-Verbose "Source directory: $(Get-SourceDirectory)"
Write-Verbose "Scanning for project files"

Write-InformationTimed "Searching for project files"
[System.IO.FileInfo[]] $projects = @(Get-Projects)
[int] $initialProjectCount       = $projects.Count
Write-Verbose ("Found $($projects.Count) projects")
Write-InformationTimed "End project files search"

# ------------------------------------------------------------------------------------------------
# If we get headers in the -file arg we have to detect CPPs that include that header

if ($aCppToCompile -and $aCppToCompile.Count -gt 0)
{
  # We've been given particular files to compile. If headers are among them
  # we'll find all source files that include them and tag them for processing.
  Write-Progress -Activity "#Include discovery" -Status "Detecting CPPs which include the specified headers..."
  [string[]] $headerRefs = @(Get-HeaderReferences -files $aCppToCompile)
  Write-Progress -Activity "#Include discovery" -Completed
  if ($headerRefs.Count -gt 0)
  {
    Write-Verbose-Array -name "Detected referenced source files to process" -array $headerRefs

    $aCppToCompile += @($headerRefs | Where-Object { ![string]::IsNullOrWhiteSpace($_) })
  }
}

if ($aCppToIgnore -and $aCppToIgnore.Count -gt 0)
{
  # We've been given particular files to ignore. If headers are among them
  # we'll find all source files that include them and tag them to be ignored.

  Write-Progress -Activity "CPP Ignore Detection" -Status "Detecting CPPs which include the specified ignore-headers..."
  [string[]] $headerRefs = @(Get-HeaderReferences -files $aCppToIgnore)
  Write-Progress -Activity "CPP Ignore Detection" -Completed

  if ($headerRefs.Count -gt 0)
  {
    Write-Verbose-Array -name "Detected referenced source files to ignore" -array $headerRefs

    $global:cptIgnoredFilesPool += @($headerRefs | Where-Object { ![string]::IsNullOrWhiteSpace($_) })
  }
}

# ------------------------------------------------------------------------------------------------

Write-InformationTimed "Starting projects"

[System.IO.FileInfo[]] $projectsToProcess = @()
[System.IO.FileInfo[]] $ignoredProjects   = @()

if (!$aVcxprojToCompile -and !$aVcxprojToIgnore)
{
  $projectsToProcess = $projects # we process all projects
}
else
{
  # some filtering has to be done

  if ($aVcxprojToCompile)
  {
    $projects = $projects | Where-Object { Should-CompileProject -vcxprojPath $_.FullName }
    $projectsToProcess = @($projects)
  }

  if ($aVcxprojToIgnore)
  {
    $projectsToProcess = @($projects | `
                         Where-Object { !(Should-IgnoreProject  -vcxprojPath $_.FullName ) })

    $ignoredProjects = ($projects | Where-Object { $projectsToProcess -notcontains $_ })
  }
}

if ($projectsToProcess.Count -eq 0)
{
  Write-Err "Cannot find given project(s)"
}

if ($aCppToCompile -and $projectsToProcess.Count -gt 1)
{
  # We've been given particular files to compile, we can narrow down
  # the projects to be processed (those that include any of the particular files)

  # For obvious performance reasons, no filtering is done when there's only one project to process.
  [System.IO.FileInfo[]] $projectsThatIncludeFiles = @(Get-SourceCodeIncludeProjects -projectPool $projectsToProcess `
                                                                                     -files $aCppToCompile)
  Write-Verbose-Array -name "Detected projects" -array $projectsThatIncludeFiles

  # some projects include files using wildcards, we won't match anything in them
  # so when matching nothing we don't do filtering at all
  if ($projectsThatIncludeFiles)
  {
    $projectsToProcess = $projectsThatIncludeFiles
  }
}

if ($projectsToProcess.Count -eq $initialProjectCount)
{
  Write-Verbose "PROCESSING ALL PROJECTS"
}
else
{
  if ($projectsToProcess.Count -gt 1)
  {
      Write-Array -name "PROJECTS" -array $projectsToProcess
  }

  if ($ignoredProjects)
  {
    Write-Array -name "IGNORED PROJECTS" -array $ignoredProjects
  }
}

# ------------------------------------------------------------------------------------------------

if (!$aResumeAfterError)
{
  $global:cptProjectCounter = $projectsToProcess.Length
}
else
{
  if (!(VariableExists 'cptProjectCounter') -or !(VariableExists 'cptProjectsBucket'))
  {
    Write-Warning "Can't resume. Previous state is unreliable. Processing all projects..."
    $global:cptProjectCounter = $projectsToProcess.Length
  }
  elseif ((Compare-Object $projectsToProcess $global:cptProjectsBucket))
  {
    Write-Warning "Can't resume. Previous state is unreliable. Processing all projects...`n`nREMINDER: Don't change arguments when adding -resume.`n`n"
    $global:cptProjectCounter = $projectsToProcess.Length
  }
  else
  {
    Write-Output "Resuming from project #$($global:cptProjectCounter)"
  }
}

[System.IO.FileInfo[]] $global:cptProjectsBucket = $projectsToProcess

[int] $localProjectCounter = $projectsToProcess.Length;
foreach ($project in $projectsToProcess)
{
  if ($localProjectCounter -gt $global:cptProjectCounter)
  {
    $localProjectCounter--;
    continue
  }

  [string] $vcxprojPath = $project.FullName;
  

  [string[]] $configPlatforms = $aVcxprojConfigPlatform
  if ($configPlatforms.Count -eq 0)
  {
    $configPlatforms += @("")
  }

  foreach ($crtPlatformConfig in $configPlatforms)
  {    
    Write-InformationTimed "Before project process"
    Process-Project -vcxprojPath $vcxprojPath -workloadType $workloadType -platformConfig $crtPlatformConfig
    Write-InformationTimed "After project process"

    Write-Output "" # empty line separator
  }

  $localProjectCounter -= 1
  $global:cptProjectCounter = $localProjectCounter
}

if ($aExportJsonDB) 
{ 
  JsonDB-Finalize
}


Write-InformationTimed "Goodbye"

if ($global:FoundErrors)
{
  Fail-Script
}
else
{
  Exit-Script
}


================================================
FILE: ClangPowerTools/ClangPowerTools/Tooling/v1/psClang/get-header-references.ps1
================================================
# line limit for scanning files for #include
[int] $global:cpt_header_include_line_limit = 30

# after the line limit, if any includes are still found we
# extend the limit with this value
[int] $global:cpt_header_include_line_extension = 10

[string[]] $global:headerExtensions = @('h', 'hh', 'hpp', 'hxx')
[string[]] $global:sourceExtensions = @('c', 'cc', 'cpp', 'cxx')

Function detail:FindHeaderReferences( [Parameter(Mandatory = $false)] [string[]] $headers
                                    , [Parameter(Mandatory = $false)] [System.IO.FileInfo[]] $filePool
                                    , [Parameter(Mandatory = $false)] [System.Collections.Hashtable] $alreadyFound = @{}
                                    )
{
    if (!$headers)
    {
        return @()
    }

    [string] $regexHeaders = @($headers | ForEach-Object { ([System.IO.FileInfo]$_).BaseName } `
                                       | Select-Object -Unique `
                                       | Where-Object { $_ -ine "stdafx" -and $_ -ine "resource" } `
                              ) -join '|'

    if ($regexHeaders.Length -eq 0)
    {
        return @()
    }

    [string] $regex = "[/""]($regexHeaders)\.($($global:headerExtensions -join '|'))"""
    Write-Debug "Regex for header reference find: $regex`n"

    [string[]] $returnRefs = @()
    if (!$filePool)
    {
        # initialize pool of files that we look into
        [string[]] $allFileExts = @(($global:sourceExtensions + `
                                     $global:headerExtensions) | ForEach-Object { "*.$_" })
        $filePool = Get-ChildItem -recurse -include $allFileExts
    }

    foreach ($file in $filePool)
    {
        if ($alreadyFound.ContainsKey($file.FullName))
        {
            continue
        }

        [int] $lineCount = 0
        [int] $lineLimit = $global:cpt_header_include_line_limit
        foreach($line in [System.IO.File]::ReadLines($file))
        {
            if ([string]::IsNullOrWhiteSpace($line))
            {
                # skip empty lines
                continue
            }

            if ($line -match $regex)
            {
                if ( ! $alreadyFound.ContainsKey($file.FullName))
                {
                    $alreadyFound[$file.FullName] = $true
                    $returnRefs += $file.FullName
                }

                if ($lineCount -eq $lineLimit)
                {
                    # we still have includes to scan
                    $lineLimit += $global:cpt_header_include_line_extension
                }
            }

            if ( (++$lineCount) -gt $lineLimit)
            {
                break
            }
        }
    }

    if ($returnRefs.Count -gt 0)
    {
        [string[]] $headersLeftToSearch = @($returnRefs | Where-Object `
                                            { FileHasExtension -filePath $_ `
                                                               -ext $global:headerExtensions } )
        if ($headersLeftToSearch.Count -gt 0)
        {
            Write-Debug "[!] Recursive reference detection in progress for: "
            Write-Debug ($headersLeftToSearch -join "`n")
            $returnRefs += detail:FindHeaderReferences -headers      $headersLeftToSearch `
                                                       -filePool     $filePool `
                                                       -alreadyFound $alreadyFound
        }
    }

    $returnRefs = $returnRefs | Select-Object -Unique
    Write-Debug "Found header refs (regex $regex)"
    Write-Debug ($returnRefs -join "`n")
    return $returnRefs
}

<#
.SYNOPSIS
Detects source files that reference given headers.

Returns an array with full paths of files that reference the header(s).
.DESCRIPTION
When modifying a header, all translation units that include that header
have to compiled. This function detects those files that include it.
.PARAMETER files
Header files of which we want references to be found
Any files that are not headers will be ignored.
#>
Function Get-HeaderReferences([Parameter(Mandatory = $false)][string[]] $files)
{
    if ($files.Count -eq 0)
    {
        return @()
    }

    # we take interest only in files that reference headers
    $files = @($files | Where-Object { FileHasExtension -filePath $_ `
                                                        -ext $global:headerExtensions })
    if ($files.Count -eq 0)
    {
        return @()
    }

    [string[]] $refs = @()

    if ($files.Count -gt 0)
    {
        Write-Verbose-Timed "Headers changed. Detecting which source files to process..."
        $refs = detail:FindHeaderReferences -headers $files
        Write-Verbose-Timed "Finished detecting source files."

        $refs = $refs | Where-Object { ! [string]::IsNullOrWhiteSpace($_) }
    }

    return $refs
}

<#
.SYNOPSIS
Detects projects that reference given source files (i.e. cpps).

Returns an array with full paths of detected projects.
.DESCRIPTION
When modifying a file, only projects that reference that file should be recompiled.
.PARAMETER projectPool
Projects in which to look
.PARAMETER files
Source files to be found in projects.
#>
Function Get-SourceCodeIncludeProjects([Parameter(Mandatory = $false)][System.IO.FileInfo[]] $projectPool,
                                       [Parameter(Mandatory = $false)][string[]] $files)
{
    [System.Collections.Hashtable] $fileCache = @{}
    foreach ($file in $files)
    {
        if ($file)
        {
            $fileCache[$file.Trim().ToLower()] = $true
        }
    }

    [System.IO.FileInfo[]] $matchedProjects = @()

    [string] $clPrefix    = '<ClCompile Include="'
    [string] $clSuffix    = '" />'
    [string] $endGroupTag = '</ItemGroup>'

    foreach ($proj in $projectPool)
    {
        [string] $projDir  = $proj.Directory.FullName

        [bool] $inClIncludeSection = $false
        foreach($line in [System.IO.File]::ReadLines($proj.FullName))
        {
            $line = $line.Trim()

            if ($line.StartsWith($clPrefix))
            {
                if (!$inClIncludeSection)
                {
                    $inClIncludeSection = $true
                }

                [string] $filePath = $line.Substring($clPrefix.Length, `
                                                     $line.Length - $clPrefix.Length - $clSuffix.Length)
                if (![System.IO.Path]::IsPathRooted($filePath))
                {
                    $filePath = Canonize-Path -base $projDir -child $filePath -ignoreErrors
                }
                if ([string]::IsNullOrEmpty($filePath))
                {
                    continue
                }

                [System.IO.FileInfo] $sourceFile = $filePath
                if ($fileCache.ContainsKey($sourceFile.FullName.Trim().ToLower()) -or `
                    $fileCache.ContainsKey($sourceFile.Name.Trim().ToLower()))
                {
                    $matchedProjects += $proj
                    break
                }
            }

            if ($inClIncludeSection -and $line -eq $endGroupTag)
            {
                # nothing more to check in this project
                break
            }
        }
    }

    return $matchedProjects
}


================================================
FILE: ClangPowerTools/ClangPowerTools/Tooling/v1/psClang/get-llvm-helper.ps1
================================================
# This helper makes sure we have the LLVM tool we require present on disk.
# If it's not available then we download it from GitHub.
 
# REQUIRES "io.ps1" to be included

# ------------------------------------------------------------------------------------------------
# Default install locations of LLVM. If present there, we automatically use it

Set-Variable -name kLLVMInstallLocations    -value @("${Env:ProgramW6432}\LLVM\bin"
                                                    ,"${Env:ProgramFiles(x86)}\LLVM\bin"
                                                    )                   -option Constant
#Url to assets (clang++ and clang-tidy) from previous release made by Clang Power Tools on github 
Set-Variable -name kCptGithubLlvm -value "https://github.com/Caphyon/clang-power-tools/releases/download/v2023.6.0" `
                                  -option Constant
Set-Variable -name kCptGithubLlvmVersion -value "16.0.6 (LLVM 16.0.6)" -Option Constant

# Clang Constants

Set-Variable -name kCss            -value "clang-doc-default-stylesheet.css"       -option Constant
Set-Variable -name kClangDoc       -value "clang-doc.exe"                          -option Constant
Set-Variable -name kIndex          -value "index.js"                               -option Constant

Function Move-Tool-To-LlvmBin([Parameter(Mandatory = $true)][string] $clangToolWeNeed,
                              [Parameter(Mandatory = $true)][string] $llvmLiteBinDir)
{

  $llvmLiteDir = (get-item $llvmLiteBinDir).Parent.FullName

  if(Test-Path "$llvmLiteDir\$clangToolWeNeed")
  {
    Move-Item -Path "$llvmLiteDir\$clangToolWeNeed" -Destination "$llvmLiteBinDir\$clangToolWeNeed"
  }

}

Function Ensure-LLVMTool-IsPresent([Parameter(Mandatory = $true)][string] $clangToolWeNeed) {
  [string] $ret = ""

  # see if we can reach the tool through PATH
  if (Exists-Command $clangToolWeNeed )
  {
    [System.IO.FileInfo] $toolPath = (Get-Command $clangToolWeNeed).Source
    return $toolPath.Directory.FullName
  }
  
  # search in predefined locations
  foreach ($locationLLVM in $kLLVMInstallLocations)
  {
    if (Test-Path -LiteralPath "$locationLLVM\$clangToolWeNeed")
    {
      return $locationLLVM
    }
  }
  # download read-to-use binary from github

  [string] $llvmLiteDirParent = "${env:APPDATA}\ClangPowerTools"
  [string] $llvmLiteDir       = "$llvmLiteDirParent\LLVM_Lite\Bin"

  [string] $llvmLiteToolPath = "$llvmLiteDir\$clangToolWeNeed"
  if (Test-Path $llvmLiteToolPath)
  {
    $versionPresent = (Get-Item $llvmLiteToolPath).VersionInfo.ProductVersion
    if ($versionPresent -eq $kCptGithubLlvmVersion)
    {
      # we already have downloaded the latest standalone tool, reuse it
      return $llvmLiteDir
    }
  }

  if (Test-InternetConnectivity)
  {
    if ([string]::IsNullOrEmpty($ret))
    {
      if (!(Test-Path $llvmLiteDirParent))
      {
        New-Item -Path $llvmLiteDirParent -ItemType Directory | Out-Null
      }
      if (!(Test-Path $llvmLiteDir))
      {
        New-Item -Path $llvmLiteDir -ItemType Directory | Out-Null
      }
      
      # check if tool already exists Llvm_lite folder, to move it in Llvm_lite/bin
      Move-Tool-To-LlvmBin $clangToolWeNeed $llvmLiteDir

      # the displayed progress slows downloads considerably, so disable it
      $prevPreference = $ProgressPreference
      $ProgressPreference = 'SilentlyContinue'
      [string] $clangCompilerWebPath = "$kCptGithubLlvm/$clangToolWeNeed"
      
      if (Test-Path  $llvmLiteToolPath)
      {
        # we have an older version downloaded, remove it first
        Remove-Item $llvmLiteToolPath -Force
      }

      Write-Verbose "Downloading $clangToolWeNeed $kCptGithubLlvmVersion ..."
      # grab ready-to-use LLVM binaries from Github
      Invoke-WebRequest -Uri $clangCompilerWebPath -OutFile $llvmLiteToolPath
      # download css file if needed tool is clang-doc.exe
      if($clangToolWeNeed -eq $kClangDoc)
      {
        [string] $parentDirLite = (get-item $llvmLiteDir ).Parent.FullName
        [string] $llvmLiteCssFolderPath = "$parentDirLite\share\clang"
        if (!(Test-Path $llvmLiteCssFolderPath))
        {
          New-Item $llvmLiteCssFolderPath -ItemType Directory | Out-Null
        }
        Invoke-WebRequest -Uri "$kCptGithubLlvm/$kCss" -OutFile "$llvmLiteCssFolderPath\$kCss"
        Invoke-WebRequest -Uri "$kCptGithubLlvm/$kIndex" -OutFile "$llvmLiteCssFolderPath\$kIndex"
      } 
      $ProgressPreference = $prevPreference

      $ret = $llvmLiteDir
    }
  }
  return $ret
}


================================================
FILE: ClangPowerTools/ClangPo