# for several, dot-call the script or use -Command:
# .\setup-windows-no-uac.ps1 -Skip BinSkim,GitConfig
# powershell -File .\setup-windows-no-uac.ps1 -Skip BinSkim
- [ValidateSet('WinMerge', 'VsWhere', 'BinSkim', 'GitConfig', 'ArchAudit')]
+ [ValidateSet('WinMerge', 'VsWhere', 'BinSkim', 'GitConfig', 'NinjaPath', 'ArchAudit')]
[string[]] $Skip = @()
)
Write-Host "`n==> $Msg" -ForegroundColor Cyan
}
-function Add-ToUserPath([string]$Dir) {
+function Add-ToUserPath {
# HKCU PATH, not the process PATH: this must outlive the script. Idempotent,
# and re-applied on every run so an entry lost to an unrelated PATH edit is
# repaired without re-doing the install that put it there.
+ #
+ # -Prepend puts the directory FIRST and moves it there if it is already
+ # present further down, which is the difference between "on the PATH" and
+ # "the one that wins". Only for entries where that matters; appending is the
+ # polite default and stays the default.
+ param(
+ [string] $Dir,
+ [switch] $Prepend
+ )
$user = [Environment]::GetEnvironmentVariable('Path', 'User')
if (-not $user) { $user = '' }
- if (($user -split ';') -contains $Dir) {
- Write-Host " $Dir already in user PATH."
+ # Compare trailing-backslash-insensitively: C:\x and C:\x\ are the same
+ # directory, and adding a second spelling of one is just noise.
+ $norm = { param($s) $s.Trim().TrimEnd('\') }
+ $entries = @($user -split ';' | Where-Object { $_.Trim() })
+ $already = $entries | Where-Object { (& $norm $_) -eq (& $norm $Dir) }
+
+ if (-not $Prepend) {
+ if ($already) { Write-Host " $Dir already in user PATH."; return }
+ $new = if ($user.Trim()) { $user.TrimEnd(';') + ';' + $Dir } else { $Dir }
+ [Environment]::SetEnvironmentVariable('Path', $new, 'User')
+ Write-Host " Added $Dir to user PATH (restart your shell to pick it up)."
+ return
+ }
+
+ if ($already -and (& $norm $entries[0]) -eq (& $norm $Dir)) {
+ Write-Host " $Dir already first in user PATH."
return
}
- $new = if ($user.Trim()) { $user.TrimEnd(';') + ';' + $Dir } else { $Dir }
- [Environment]::SetEnvironmentVariable('Path', $new, 'User')
- Write-Host " Added $Dir to user PATH (restart your shell to pick it up)."
+ $rest = $entries | Where-Object { (& $norm $_) -ne (& $norm $Dir) }
+ [Environment]::SetEnvironmentVariable('Path', (@($Dir) + $rest) -join ';', 'User')
+ if ($already) {
+ Write-Host " Moved $Dir to the front of the user PATH (restart your shell to pick it up)."
+ } else {
+ Write-Host " Added $Dir to the front of the user PATH (restart your shell to pick it up)."
+ }
}
function Add-WinMergeToUserPath {
Write-Host " $version"
}
+function Set-NativeNinjaFirst {
+ # Make the native ninja.exe the one that wins, including inside a Visual
+ # Studio Developer Command Prompt.
+ #
+ # WHY THIS IS INSURANCE RATHER THAN THE FIX. VS ships an x64 ninja.exe even on
+ # ARM64 and puts it on the PATH from
+ # Common7\Tools\vsdevcmd\ext\cmake.bat, which does:
+ # set "PATH=%PATH%;...\CMake\bin;...\CMake\Ninja"
+ # That APPENDS - the VS directories land at the very end of the composed
+ # PATH, behind every machine and user entry. So a native ninja installed
+ # anywhere on the user PATH already beats it, and measurement on an ARM64 box
+ # confirms it does. (An earlier revision of this script claimed VsDevCmd
+ # prepends and that the VS copy therefore always won; that was wrong.)
+ #
+ # It is still worth pinning the order explicitly: winget appends its package
+ # directory to the user PATH, so the margin depends on nothing more than two
+ # append orders staying as they are, in a file Microsoft owns and revises.
+ # Putting the directory first costs nothing and removes the dependency.
+ #
+ # Ninja is worth this attention where a one-off tool would not be: it is
+ # re-invoked for every edge in the build graph, so it is the one place an
+ # emulated binary is paid over and over rather than once.
+ Write-Step 'Native ninja ahead of the Visual Studio copy'
+
+ $candidates = @()
+ $candidates += Get-ChildItem (Join-Path $env:LOCALAPPDATA 'Microsoft\WinGet\Packages') `
+ -Filter 'ninja.exe' -Recurse -Depth 2 -ErrorAction SilentlyContinue |
+ ForEach-Object { $_.FullName }
+ $candidates += @(
+ (Join-Path $env:ProgramFiles 'Ninja\ninja.exe')
+ (Join-Path $env:LOCALAPPDATA 'Programs\Ninja\ninja.exe')
+ )
+ # A ninja already on the PATH counts too - but only if it is not the VS one,
+ # which is the binary this step exists to get out in front of.
+ $onPath = (Get-Command ninja.exe -ErrorAction SilentlyContinue | Select-Object -First 1).Source
+ if ($onPath -and $onPath -notmatch 'CommonExtensions\\Microsoft\\CMake') { $candidates += $onPath }
+
+ $native = $null
+ foreach ($c in ($candidates | Where-Object { $_ -and (Test-Path $_) } | Select-Object -Unique)) {
+ $m = Get-PEMachine $c
+ if ($m -eq $(if ($IsArm64) { 'ARM64' } else { 'x64' })) { $native = $c; break }
+ }
+
+ if (-not $native) {
+ Write-Warning 'No native ninja.exe found. Install it with: winget install Ninja-build.Ninja'
+ Write-Warning 'Until then a build using the Ninja generator gets the x64 ninja Visual Studio bundles.'
+ return
+ }
+
+ Write-Host " native ninja: $native ($(Get-PEMachine $native))"
+ Add-ToUserPath (Split-Path $native -Parent) -Prepend
+}
+
function Get-PEMachine {
# Architecture of a PE, read straight from the COFF header: the 2 bytes at
# the e_lfanew offset + 4. Cheap, and it answers the only question that
# either native or a known, listed exception.
Write-Step "Architecture audit (host: $HostArch)"
+ # Resolve against the PATH a NEW shell would get, not this process's.
+ #
+ # The steps above write the HKCU PATH, which a running process never sees -
+ # so auditing $env:PATH would report the state from before this script ran and
+ # warn about a problem it had just fixed. Compose machine + user from the
+ # registry (the order Windows itself uses), then append anything extra this
+ # process happens to carry: that tail is where a Developer Command Prompt's VS
+ # directories live, and keeping it last mirrors how VsDevCmd appends them.
+ $composed = @()
+ foreach ($scope in 'Machine', 'User') {
+ $v = [Environment]::GetEnvironmentVariable('Path', $scope)
+ if ($v) { $composed += ($v -split ';' | Where-Object { $_.Trim() }) }
+ }
+ $composed += ($env:PATH -split ';' | Where-Object { $_.Trim() })
+ $seen = New-Object 'System.Collections.Generic.HashSet[string]' ([StringComparer]::OrdinalIgnoreCase)
+ $searchPath = @($composed | Where-Object { $seen.Add($_.Trim().TrimEnd('\')) })
+
+ function Resolve-OnPath([string]$Exe) {
+ foreach ($d in $searchPath) {
+ $p = Join-Path $d $Exe
+ if (Test-Path $p -PathType Leaf) { return $p }
+ }
+ return $null
+ }
+
# Tools with no native ARM64 build available anywhere, with the reason. These
# print as expected rather than as problems - see the README's ARM64 section.
$KnownEmulated = @{
# it. Printed with the finding so the log carries the remedy, not just the
# complaint.
#
- # ninja is the one that actually bites. Visual Studio bundles an x64 ninja.exe
- # even on ARM64, and VsDevCmd.bat PREPENDS the VS directories to PATH - so
- # inside a Developer Command Prompt the emulated one wins over the native
- # winget copy, and that is exactly the shell C++ builds happen in. It matters
- # more than a one-off tool because ninja is re-invoked for every edge in the
- # build graph.
+ # ninja is the one that actually bites: Visual Studio bundles an x64 ninja.exe
+ # even on ARM64, and it is re-invoked for every edge in the build graph, so
+ # an emulated one is paid over and over rather than once. The NinjaPath step
+ # puts the native copy first; this is the check that it worked.
$Remedies = @{
- 'ninja.exe' = 'Visual Studio bundles an x64 ninja and VsDevCmd prepends its directory. Pass -DCMAKE_MAKE_PROGRAM to the native one (winget install Ninja-build.Ninja), or put its directory ahead of the VS one.'
+ 'ninja.exe' = 'Visual Studio bundles an x64 ninja. Install the native one (winget install Ninja-build.Ninja) and re-run - the NinjaPath step puts its directory at the front of the user PATH.'
'cmake.exe' = 'Install the native build with: winget install Kitware.CMake'
'clang-cl.exe' = 'Install the upstream native LLVM with: winget install LLVM.LLVM'
}
# PATH first - that is the binary a build would actually invoke - then the
# explicit candidates. The bare exe name is stripped of any " (label)".
$exe = ($name -split ' ')[0]
- $path = (Get-Command $exe -ErrorAction SilentlyContinue |
- Select-Object -First 1).Source
+ $path = Resolve-OnPath $exe
if (-not $path) { $path = $targets[$name] | Where-Object { $_ -and (Test-Path $_) } | Select-Object -First 1 }
if (-not $path) { Write-Host (" {0,-22} {1}" -f $name, '- not installed') -ForegroundColor DarkGray; continue }
VsWhere = { Add-VsWhereToUserPath }
BinSkim = { Install-BinSkim }
GitConfig = { Set-GlobalGitConfig }
+ NinjaPath = { Set-NativeNinjaFirst }
# Last on purpose: it reports on what the steps above (and the winget installs
# in setup-windows.bat) actually put on the box.
ArchAudit = { Invoke-ArchAudit }
vilimpoc.org / repos / dotfiles / blobdiff