path: root/action.yml

name: Install Clang
description: Install Clang & LLVM

inputs:
  platform:
    description: Target platform
    required: false
    default: x64
  cygwin:
    description: Install inside Cygwin
    required: false
    default: 0

runs:
  using: composite
  steps:
    - run: |
        New-Variable os -Value '${{ runner.os }}' -Option Constant

        New-Variable linux_host -Value ($os -eq 'Linux') -Option Constant
        New-Variable cygwin_host -Value ('${{ inputs.cygwin }}' -eq '1') -Option Constant
        New-Variable windows_host -Value ($os -eq 'Windows' -and !$cygwin) -Option Constant

        New-Variable x64 -Value ('${{ inputs.platform }}' -eq 'x64') -Option Constant

        function Locate-Choco {
            $path = Get-Command 'choco' -ErrorAction SilentlyContinue
            if ($path) {
                $path.Path
            } else {
                Join-Path ${env:ProgramData} 'chocolatey' 'bin' 'choco'
            }
        }

        function Install-Package {
            param(
                [Parameter(Mandatory=$true, ValueFromRemainingArguments=$true)]
                [string[]] $Packages
            )

            if ($script:linux_host) {
                sudo apt-get update -yq
                sudo apt-get install -yq --no-install-recommends $Packages
            } elseif ($script:cygwin_host) {
                $choco = Locate-Choco
                & $choco install -y --no-progress --source=cygwin $Packages
            } elseif ($script:windows_host) {
                $choco = Locate-Choco
                & $choco install -y --no-progress $Packages
            } else {
                throw "Sorry, installing packages is unsupported on $script:os"
            }
        }

        function Link-Exe {
            param(
                [Parameter(Mandatory=$true)]
                [string] $ExeName,
                [Parameter(Mandatory=$true)]
                [string] $LinkName
            )

            # Full executable path, including the extension:
            $exe_path = (Get-Command $ExeName).Path
            $exe_dir = Split-Path $exe_path
            $exe_name = Split-Path $exe_path -Leaf
            $exe_ext = [System.IO.Path]::GetExtension($exe_name)

            $link_dir = if ($script:linux_host) { '/usr/local/bin' } else { $exe_dir }
            $link_name = $LinkName
            # On Windows, append .exe if required:
            if (!$script:linux_host -and [System.IO.Path]::GetExtension($link_name) -ne $exe_ext) {
                $link_name += $exe_ext
            }
            $link_path = Join-Path $link_dir $link_name

            echo "Creating link '$link_path', pointing to '$exe_path'"
            if ($script:linux_host) {
                sudo rm -f -- $link_path
                sudo ln -s -- $exe_path $link_path
            } else {
                if (Test-Path $link_path) {
                    Remove-Item $link_path -Force
                }
                New-Item -ItemType HardLink -Path $link_path -Value $exe_path | Out-Null
            }
        }

        function Convert-CygwinPath {
            # Like cygpath -wa, but don't resolve symlinks.
            param(
                [Parameter(Mandatory=$true)]
                [string] $Path
            )

            $realpath = realpath.exe --no-symlinks -- $Path
            $dirname = dirname.exe -- $realpath
            $dirname = cygpath.exe -wa $dirname
            Join-Path $dirname (Split-Path $realpath -Leaf)
        }

        function Fix-CygwinLink {
            # Replace a Cygwin symlink with a hardlink.
            param(
                [Parameter(Mandatory=$true)]
                [string] $Path
            )

            $link_path = $Path
            $link_winpath = Convert-CygwinPath $link_path
            $link_ext = [System.IO.Path]::GetExtension($link_path)

            $dest_path = readlink.exe --canonicalize-existing -- $link_path
            $dest_winpath = Convert-CygwinPath $dest_path
            $dest_ext = [System.IO.Path]::GetExtension($dest_path)

            echo "Removing symlink: $link_winpath"
            Remove-Item $link_winpath -Force

            if ($dest_ext.ToLower() -ne $link_ext.ToLower()) {
                $link_winpath += $dest_ext
            }
            echo "Creating hardlink '$link_winpath', pointing to '$dest_winpath'"
            New-Item -ItemType HardLink -Path $link_winpath -Value $dest_winpath | Out-Null
        }

        if ($linux_host) {
            if ($x64) {
                $pkgs = 'clang','g++','llvm'
            } else {
                $pkgs = 'clang','g++-multilib','llvm'
            }
            Install-Package $pkgs

            Link-Exe -Exe clang -LinkName cc
            Link-Exe -Exe clang++ -LinkName c++
        } elseif ($cygwin_host) {
            if (!$x64) {
                echo @'
        ::warning ::
        32-bit-targeting Clang is unavailable on 64-bit Cygwin.
        Please use 32-bit Cygwin instead.
        If you _are_ using 32-bit Cygwin, please ignore this message.
        '@
            }

            # IDK why, but without libiconv-devel, even a "Hello, world!"
            # C++ app cannot be compiled as of December 2020. Also, libstdc++
            # is required; it's simpler to install gcc-g++ for all the
            # dependencies.
            Install-Package clang gcc-g++ libiconv-devel llvm

            # clang/clang++ are Cygwin symlinks, pointing to clang-X.exe. It's
            # convenient to make proper executables instead so that they can be
            # called from Windows' command prompt.
            find.exe /usr/bin -type l -a '-(' -iname 'clang*' -o -iname 'llvm*' '-)' | %{ Fix-CygwinLink $_ }

            Link-Exe -Exe clang -LinkName cc
            Link-Exe -Exe clang++ -LinkName c++
        } elseif ($windows_host) {
            Install-Package llvm

            $bin_dir = Join-Path $env:ProgramFiles LLVM bin
            echo $bin_dir >> $env:GITHUB_PATH

            Link-Exe -Exe (Join-Path $bin_dir clang) -LinkName cc
            Link-Exe -Exe (Join-Path $bin_dir clang++) -LinkName c++
        } else {
            throw "Sorry, installing Clang is unsupported on $os"
        }
      shell: pwsh

branding:
  icon: star
  color: green