name: CMake Build Matrix

on:
  push:
    paths-ignore:
      - 'dist/**'
      - 'doc/**'

env:
  QT_VERSION: 6.5.0
  MACOS_DEPLOYMENT_TARGET: 10.15
  CLANG_VERSION: 16.0.0
  ELFUTILS_VERSION: 0.175
  CMAKE_VERSION: 3.21.1
  NINJA_VERSION: 1.10.2
  BUILD_TYPE: Release
  CCACHE_VERSION: 4.6
  QT_MIRRORS: download.qt.io;mirrors.ocf.berkeley.edu/qt;ftp.fau.de/qtproject;mirror.bit.edu.cn/qtproject

jobs:
  build:
    name: ${{ matrix.config.name }}
    runs-on: ${{ matrix.config.os }}
    outputs:
        tag: ${{ steps.git.outputs.tag }}
    strategy:
      fail-fast: false
      matrix:
        config:
        - {
            name: "Windows Latest MSVC", artifact: "windows-x64-msvc",
            os: windows-latest,
            cc: "cl", cxx: "cl",
            environment_script: "C:/Program Files/Microsoft Visual Studio/2022/Enterprise/VC/Auxiliary/Build/vcvars64.bat",
            is_msvc: true
          }
        - {
            name: "Windows Latest MinGW", artifact: "windows-x64-mingw",
            os: windows-latest,
            toolchain: "https://github.com/cristianadam/mingw-builds/releases/download/v11.2.0-rev1/x86_64-11.2.0-release-posix-seh-rt_v9-rev1.7z",
            toolchain_path: "mingw64/bin",
            cc: "gcc", cxx: "g++",
            is_msvc: false
          }
        - {
            name: "Ubuntu Latest GCC", artifact: "linux-x64",
            os: ubuntu-latest,
            cc: "gcc", cxx: "g++"
          }
        - {
            name: "macOS Latest Clang", artifact: "macos-universal",
            os: macos-latest,
            cc: "clang", cxx: "clang++"
          }

    steps:
    - uses: actions/checkout@v3
    - name: Checkout submodules
      id: git
      shell: cmake -P {0}
      run: |
        execute_process(COMMAND git submodule set-url -- perfparser https://code.qt.io/qt-creator/perfparser.git)
        execute_process(COMMAND git submodule update --init --recursive)
        file(MAKE_DIRECTORY release)
        if (${{github.ref}} MATCHES "tags/v(.*)")
            file(APPEND "$ENV{GITHUB_OUTPUT}" "tag=${CMAKE_MATCH_1}\n")
            file(READ "dist/changelog/changes-${CMAKE_MATCH_1}.md" changelog_md)
            file(WRITE "release/changelog.md" "These packages are not officially supported, for official packages please check out https://download.qt.io/official_releases/qtcreator\n\n")
            file(APPEND "release/changelog.md" "${changelog_md}")
        else()
            file(APPEND "$ENV{GITHUB_OUTPUT}" "tag=${{github.run_id}}\n")
        endif()


    - name: Download Ninja and CMake
      shell: cmake -P {0}
      run: |
        set(cmake_version "$ENV{CMAKE_VERSION}")
        set(ninja_version "$ENV{NINJA_VERSION}")

        if ("${{ runner.os }}" STREQUAL "Windows")
          set(ninja_suffix "win.zip")
          set(cmake_suffix "windows-x86_64.zip")
          set(cmake_dir "cmake-${cmake_version}-windows-x86_64/bin")
        elseif ("${{ runner.os }}" STREQUAL "Linux")
          set(ninja_suffix "linux.zip")
          set(cmake_suffix "linux-x86_64.tar.gz")
          set(cmake_dir "cmake-${cmake_version}-linux-x86_64/bin")
        elseif ("${{ runner.os }}" STREQUAL "macOS")
          set(ninja_suffix "mac.zip")
          set(cmake_suffix "macos-universal.tar.gz")
          set(cmake_dir "cmake-${cmake_version}-macos-universal/CMake.app/Contents/bin")
        endif()

        set(ninja_url "https://github.com/ninja-build/ninja/releases/download/v${ninja_version}/ninja-${ninja_suffix}")
        foreach(retry RANGE 10)
          file(DOWNLOAD "${ninja_url}" ./ninja.zip SHOW_PROGRESS)
          file(SIZE ./ninja.zip fileSize)
          if (fileSize GREATER 0)
            break()
          endif()
        endforeach()

        execute_process(COMMAND ${CMAKE_COMMAND} -E tar xvf ./ninja.zip)

        set(cmake_url "https://github.com/Kitware/CMake/releases/download/v${cmake_version}/cmake-${cmake_version}-${cmake_suffix}")
        foreach(retry RANGE 10)
          file(DOWNLOAD "${cmake_url}" ./cmake.zip SHOW_PROGRESS)
          file(SIZE ./cmake.zip fileSize)
          if (fileSize GREATER 0)
            break()
          endif()
        endforeach()
        execute_process(COMMAND ${CMAKE_COMMAND} -E tar xvf ./cmake.zip)

        # Add to PATH environment variable
        file(TO_CMAKE_PATH "$ENV{GITHUB_WORKSPACE}/${cmake_dir}" cmake_dir)
        set(path_separator ":")
        if ("${{ runner.os }}" STREQUAL "Windows")
          set(path_separator ";")
        endif()
        file(APPEND "$ENV{GITHUB_PATH}" "$ENV{GITHUB_WORKSPACE}${path_separator}${cmake_dir}")

        if (NOT "${{ runner.os }}" STREQUAL "Windows")
          execute_process(
            COMMAND chmod +x ninja
            COMMAND chmod +x ${cmake_dir}/cmake
          )
        endif()

    - name: Install system libs
      shell: cmake -P {0}
      run: |
        if ("${{ runner.os }}" STREQUAL "Linux")
          execute_process(
            COMMAND sudo apt update
          )
          execute_process(
            COMMAND
              sudo apt install chrpath
                               libgl1-mesa-dev libvulkan-dev libxcb-xinput-dev libxcb-xinerama0-dev libxkbcommon-dev libxkbcommon-x11-dev
                               libxcb-image0 libxcb-keysyms1 libxcb-render-util0 libxcb-xkb1 libxcb-randr0 libxcb-icccm4
                               xvfb
            RESULT_VARIABLE result
          )
          if (NOT result EQUAL 0)
            message(FATAL_ERROR "Failed to install dependencies")
          endif()
        endif()

        if ("${{ runner.os }}" STREQUAL "Windows")
          file(MAKE_DIRECTORY build/build/bin)
          foreach(retry RANGE 10)
            file(DOWNLOAD "https://download.qt.io/development_releases/prebuilt/llvmpipe/windows/opengl32sw-64.7z" ./opengl32sw-64.7z SHOW_PROGRESS)
            file(SIZE ./opengl32sw-64.7z fileSize)
            if (fileSize GREATER 0)
              break()
            endif()
          endforeach()
          execute_process(COMMAND ${CMAKE_COMMAND} -E tar xvf ../../../opengl32sw-64.7z WORKING_DIRECTORY build/build/bin)
        endif()

        if (NOT "x${{ matrix.config.toolchain }}" STREQUAL "x")
          foreach(retry RANGE 10)
            file(DOWNLOAD "${{ matrix.config.toolchain }}" ./toolchain.7z SHOW_PROGRESS)
            file(SIZE ./toolchain.7z fileSize)
            if (fileSize GREATER 0)
              break()
            endif()
          endforeach()
          execute_process(COMMAND ${CMAKE_COMMAND} -E tar xvf ./toolchain.7z)
        endif()

        # For tests update the docker image
        find_program(docker_executable docker)
        if (docker_executable)
          execute_process(COMMAND ${docker_executable} pull alpine:latest COMMAND_ECHO STDOUT)
        endif()

    - name: Download Qt
      id: qt
      shell: cmake -P {0}
      run: |
        set(qt_version "$ENV{QT_VERSION}")

        string(REPLACE "." "" qt_version_dotless "${qt_version}")
        if ("${{ runner.os }}" STREQUAL "Windows")
          set(url_os "windows_x86")
          if ("x${{ matrix.config.environment_script }}" STREQUAL "x")
            set(qt_package_arch_suffix "win64_mingw")
            set(qt_dir_prefix "${qt_version}/mingw_64")
            set(qt_package_suffix "-Windows-Windows_10_22H2-Mingw-Windows-Windows_10_22H2-X86_64")
          elseif ("${{ matrix.config.environment_script }}" MATCHES "vcvars64.bat")
            set(qt_package_arch_suffix "win64_msvc2019_64")
            set(qt_dir_prefix "${qt_version}/msvc2019_64")
            set(qt_package_suffix "-Windows-Windows_10_22H2-MSVC2019-Windows-Windows_10_22H2-X86_64")
          endif()
        elseif ("${{ runner.os }}" STREQUAL "Linux")
          set(url_os "linux_x64")
          set(qt_package_arch_suffix "gcc_64")
          set(qt_dir_prefix "${qt_version}/gcc_64")
          set(qt_package_suffix "-Linux-RHEL_8_4-GCC-Linux-RHEL_8_4-X86_64")
        elseif ("${{ runner.os }}" STREQUAL "macOS")
          set(url_os "mac_x64")
          set(qt_package_arch_suffix "clang_64")
          set(qt_dir_prefix "${qt_version}/macos")
          set(qt_package_suffix "-MacOS-MacOS_12-Clang-MacOS-MacOS_12-X86_64-ARM64")
        endif()

        set(qt_base_url "https://\${qt_mirror}/online/qtsdkrepository/${url_os}/desktop/qt6_${qt_version_dotless}")
        foreach(qt_mirror $ENV{QT_MIRRORS})
          cmake_language(EVAL CODE "
            message(\"Downloading: ${qt_base_url}/Updates.xml\")
            file(DOWNLOAD \"${qt_base_url}/Updates.xml\" ./Updates.xml)
          ")
          file(SIZE ./Updates.xml fileSize)
          if (fileSize GREATER 0)
            break()
          endif()
        endforeach()

        file(READ ./Updates.xml updates_xml)
        string(REGEX MATCH "<Name>qt.qt6.*<Version>([0-9+-.]+)</Version>" updates_xml_output "${updates_xml}")
        set(qt_package_version ${CMAKE_MATCH_1})

        file(MAKE_DIRECTORY qt6)

        # Save the path for other steps
        file(TO_CMAKE_PATH "$ENV{GITHUB_WORKSPACE}/qt6/${qt_dir_prefix}" qt_dir)
        file(APPEND "$ENV{GITHUB_OUTPUT}" "qt_dir=${qt_dir}")

        function(downloadAndExtract url archive)
          foreach(qt_mirror $ENV{QT_MIRRORS})
            cmake_language(EVAL CODE "
              message(\"Downloading ${url}\")
              file(DOWNLOAD \"${url}\" ./${archive})
            ")
            file(SIZE ./${archive} fileSize)
            if (fileSize GREATER 0)
              break()
            endif()
          endforeach()
          execute_process(COMMAND ${CMAKE_COMMAND} -E tar xvf ../${archive} WORKING_DIRECTORY qt6)
        endfunction()

        foreach(package qtbase qtdeclarative qttools qtsvg qttranslations)
          downloadAndExtract(
            "${qt_base_url}/qt.qt6.${qt_version_dotless}.${qt_package_arch_suffix}/${qt_package_version}${package}${qt_package_suffix}.7z"
            ${package}.7z
          )
        endforeach()

        foreach(package qtimageformats qtserialport)
          downloadAndExtract(
            "${qt_base_url}/qt.qt6.${qt_version_dotless}.addons.${package}.${qt_package_arch_suffix}/${qt_package_version}${package}${qt_package_suffix}.7z"
            ${package}.7z
          )
        endforeach()

        foreach(package qtquicktimeline qtquick3d qt5compat qtshadertools)
          downloadAndExtract(
            "${qt_base_url}/qt.qt6.${qt_version_dotless}.${package}.${qt_package_arch_suffix}/${qt_package_version}${package}${qt_package_suffix}.7z"
            ${package}.7z
          )
        endforeach()

        # uic depends on libicu56.so
        if ("${{ runner.os }}" STREQUAL "Linux")
          downloadAndExtract(
            "${qt_base_url}/qt.qt6.${qt_version_dotless}.${qt_package_arch_suffix}/${qt_package_version}icu-linux-Rhel7.2-x64.7z"
            icu.7z
          )
        endif()

        file(READ "qt6/${qt_dir_prefix}/mkspecs/qconfig.pri" qtconfig)
        string(REPLACE "Enterprise" "OpenSource" qtconfig "${qtconfig}")
        string(REPLACE "licheck.exe" "" qtconfig "${qtconfig}")
        string(REPLACE "licheck64" "" qtconfig "${qtconfig}")
        string(REPLACE "licheck_mac" "" qtconfig "${qtconfig}")
        file(WRITE "qt6/${qt_dir_prefix}/mkspecs/qconfig.pri" "${qtconfig}")

        if ("${{ runner.os }}" STREQUAL "Windows")
          # deploy "system" runtimes into Qt, so they get deployed as well
          if ("x${{ matrix.config.environment_script }}" STREQUAL "x")
            # deploy MinGW
            foreach(file libwinpthread-1.dll libstdc++-6.dll libgcc_s_seh-1.dll)
              file(INSTALL "$ENV{GITHUB_WORKSPACE}/${{ matrix.config.toolchain_path }}/${file}"
                   DESTINATION "qt6/${qt_dir_prefix}/bin"
                   USE_SOURCE_PERMISSIONS)
            endforeach()
          else()
            # deploy MSVC
            foreach(file vcruntime140.dll concrt140.dll msvcp140_1.dll msvcp140_2.dll
                         msvcp140_codecvt_ids.dll vcruntime140_1.dll msvcp140.dll)
              file(INSTALL "C:/Windows/System32/${file}"
                   DESTINATION "qt6/${qt_dir_prefix}/bin")
            endforeach()
          endif()
        endif()

    - name: Download OpenSSL
      shell: cmake -P {0}
      run: |
        if ("${{ runner.os }}" STREQUAL "Windows")
          set(url_os "windows_x86")
          set(openssl_localdir "Tools/OpenSSL/Win_x64/bin")
          set(openssl_dest_dir "${{ steps.qt.outputs.qt_dir }}/bin")
          set(shared_suffix ".dll")
        elseif ("${{ runner.os }}" STREQUAL "Linux")
          set(url_os "linux_x64")
          set(openssl_localdir "Tools/OpenSSL/binary/lib")
          set(openssl_dest_dir "${{ steps.qt.outputs.qt_dir }}/lib/Qt/lib")
          set(shared_suffix ".so*")
        elseif ("${{ runner.os }}" STREQUAL "macOS")
          # Not needed on macOS
          return()
        endif()

        set(openssl_base_url "https://\${qt_mirror}/online/qtsdkrepository/${url_os}/desktop/tools_openssl_x64")
        foreach(qt_mirror $ENV{QT_MIRRORS})
          cmake_language(EVAL CODE "
            message(\"Downloading ${openssl_base_url}/Updates.xml}\")
            file(DOWNLOAD \"${openssl_base_url}/Updates.xml\" ./Updates.xml)
          ")
          file(SIZE ./Updates.xml fileSize)
          if (fileSize GREATER 0)
            break()
          endif()
        endforeach()

        file(READ ./Updates.xml updates_xml)
        string(REGEX MATCH
          "<Name>(qt.tools.openssl.*)</Name>.*<Version>([0-9+-.]+)</Version>.*<DownloadableArchives>(.*)</DownloadableArchives>" updates_xml_output "${updates_xml}")

        set(openssl_directory ${CMAKE_MATCH_1})
        set(openssl_version ${CMAKE_MATCH_2})
        set(openssl_archive ${CMAKE_MATCH_3})

        set(url "${openssl_base_url}/${openssl_directory}/${openssl_version}${openssl_archive}")

        file(MAKE_DIRECTORY openssl)
        file(MAKE_DIRECTORY ${openssl_dest_dir})

        foreach(qt_mirror $ENV{QT_MIRRORS})
          cmake_language(EVAL CODE "
            message(\"Downloading ${url}\")
            file(DOWNLOAD \"${url}\" ./openssl.7z)
          ")
          file(SIZE ./openssl.7z fileSize)
          if (fileSize GREATER 0)
            break()
          endif()
        endforeach()
        execute_process(COMMAND ${CMAKE_COMMAND} -E tar xvf ../openssl.7z WORKING_DIRECTORY openssl)

        file(GLOB openssl_shared_objects "openssl/${openssl_localdir}/*${shared_suffix}")
        execute_process(
          COMMAND ${CMAKE_COMMAND} -E copy ${openssl_shared_objects} ${openssl_dest_dir})

    - name: Download libclang
      id: libclang
      shell: cmake -P {0}
      run: |
        set(clang_version "$ENV{CLANG_VERSION}")

        if ("${{ runner.os }}" STREQUAL "Windows")
          if ("x${{ matrix.config.environment_script }}" STREQUAL "x")
            set(libclang "libclang-release_${clang_version}-based-windows-mingw_64.7z")
          elseif ("${{ matrix.config.environment_script }}" MATCHES "vcvars64.bat")
            set(libclang "libclang-release_${clang_version}-based-windows-vs2019_64.7z")
          elseif ("${{ matrix.config.environment_script }}" MATCHES "vcvars32.bat")
            set(libclang "libclang-release_${clang_version}-based-windows-vs2019_32.7z")
          endif()
        elseif ("${{ runner.os }}" STREQUAL "Linux")
          set(libclang "libclang-release_${clang_version}-based-linux-Ubuntu20.04-gcc9.3-x86_64.7z")
        elseif ("${{ runner.os }}" STREQUAL "macOS")
          set(libclang "libclang-release_${clang_version}-based-macos-universal.7z")
        endif()

        set(libclang_url "https://\${qt_mirror}/development_releases/prebuilt/libclang/${libclang}")
        foreach(qt_mirror $ENV{QT_MIRRORS})
          cmake_language(EVAL CODE "
            message(\"Downloading ${libclang_url}\")
            file(DOWNLOAD \"${libclang_url}\" ./libclang.7z)
          ")
          file(SIZE ./libclang.7z fileSize)
          if (fileSize GREATER 0)
            break()
          endif()
        endforeach()

        # Comes with libclang inside the archive
        execute_process(COMMAND ${CMAKE_COMMAND} -E tar xvf ./libclang.7z)

        # Save the path for other steps
        file(TO_CMAKE_PATH "$ENV{GITHUB_WORKSPACE}/libclang" libclang_dir)
        file(APPEND "$ENV{GITHUB_OUTPUT}" "libclang_dir=${libclang_dir}")

    - name: Download elfutils
      if: runner.os == 'Windows' && matrix.config.is_msvc || runner.os == 'Linux'
      id: elfutils
      shell: cmake -P {0}
      run: |
        set(elfutils_version "$ENV{ELFUTILS_VERSION}")

        if ("${{ runner.os }}" STREQUAL "Windows")
          if ("${{ matrix.config.environment_script }}" MATCHES "vcvars64.bat")
            set(elfutils "elfutils-release_${elfutils_version}qt-windows-x86_64.7z")
          elseif ("${{ matrix.config.environment_script }}" MATCHES "vcvars32.bat")
            set(elfutils "elfutils-release_${elfutils_version}qt-windows-i686.7z")
          endif()
        elseif ("${{ runner.os }}" STREQUAL "Linux")
          set(elfutils "elfutils-release_${elfutils_version}qt-linux-x86_64.7z")
        endif()

        set(elfutils_url "https://\${qt_mirror}/development_releases/prebuilt/elfutils/${elfutils}")

        foreach(qt_mirror $ENV{QT_MIRRORS})
          cmake_language(EVAL CODE "
            message(\"Downloading ${elfutils_url}\")
            file(DOWNLOAD \"${elfutils_url}\" ./elfutils.7z)
          ")
          file(SIZE ./elfutils.7z fileSize)
          if (fileSize GREATER 0)
            break()
          endif()
        endforeach()
        file(MAKE_DIRECTORY elfutils)
        execute_process(COMMAND ${CMAKE_COMMAND} -E tar xvf ../elfutils.7z WORKING_DIRECTORY elfutils)

        # Save the path for other steps
        file(TO_CMAKE_PATH "$ENV{GITHUB_WORKSPACE}/elfutils" elfutils_dir)
        file(APPEND "$ENV{GITHUB_OUTPUT}" "elfutils_dir=${elfutils_dir}")

    - name: Download ccache
      shell: cmake -P {0}
      run: |
        set(ccache_url "https://github.com/cristianadam/ccache/releases/download/v$ENV{CCACHE_VERSION}/${{ runner.os }}.tar.xz")
        foreach(retry RANGE 10)
          file(DOWNLOAD "${ccache_url}" ./ccache.tar.xz SHOW_PROGRESS)
          file(SIZE ./ccache.tar.xz fileSize)
          if (fileSize GREATER 0)
            break()
          endif()
        endforeach()
        execute_process(COMMAND ${CMAKE_COMMAND} -E tar xvf ./ccache.tar.xz)

    - name: Prepare ccache archive name
      id: ccache
      shell: cmake -P {0}
      run: |
        file(TO_CMAKE_PATH "$ENV{GITHUB_WORKSPACE}" github_workspace)
        include(${github_workspace}/cmake/QtCreatorIDEBranding.cmake)
        string(REPLACE "." ";" IDE_VERSION_LIST ${IDE_VERSION_DISPLAY})
        list(GET IDE_VERSION_LIST 0 IDE_VERSION_MAJOR)
        file(APPEND "$ENV{GITHUB_OUTPUT}" "archive_name=ccache-${{ matrix.config.os }}-${{ matrix.config.cc }}-qtc${IDE_VERSION_MAJOR}")

    - name: Download ccache archive
      shell: cmake -P {0}
      run: |
        file(WRITE $ENV{GITHUB_WORKSPACE}/netrc.txt
          "default login runneradmin password ${{ secrets.GITHUB_TOKEN }}")

        foreach(page_id RANGE 1 10)
          file(
            DOWNLOAD "https://api.github.com/repos/${{ github.repository }}/actions/artifacts?per_page=100&page=${page_id}"
            HTTPHEADER "Accept: application/vnd.github.v3+json"
            NETRC_FILE "$ENV{GITHUB_WORKSPACE}/netrc.txt"
            NETRC REQUIRED
            SHOW_PROGRESS
            artifacts.json)
          file(READ artifacts.json artifacts_json)

          string(JSON artifacts_length LENGTH "${artifacts_json}" "artifacts")
          math(EXPR artifacts_length "${artifacts_length} - 1")
          if(${artifacts_length} GREATER_EQUAL 0)
            foreach(idx RANGE 0 ${artifacts_length})
              string(JSON artifact_js GET "${artifacts_json}" "artifacts" ${idx})
              string(JSON name GET "${artifact_js}" "name")
              if ("${name}" STREQUAL "${{ steps.ccache.outputs.archive_name }}")
                string(JSON download_url GET "${artifact_js}" "archive_download_url")

                foreach(retry RANGE 10)
                  file(DOWNLOAD "${download_url}"
                    "${{ steps.ccache.outputs.archive_name }}.zip"
                    NETRC_FILE "$ENV{GITHUB_WORKSPACE}/netrc.txt"
                    NETRC REQUIRED
                    SHOW_PROGRESS)
                  file(SIZE "${{ steps.ccache.outputs.archive_name }}.zip" fileSize)
                  if (fileSize GREATER 0)
                    break()
                  endif()
                endforeach()

                execute_process(COMMAND ${CMAKE_COMMAND} -E tar xvf "${{ steps.ccache.outputs.archive_name }}.zip")
                file(MAKE_DIRECTORY .ccache)
                execute_process(COMMAND ${CMAKE_COMMAND} -E tar xf "../${{ steps.ccache.outputs.archive_name }}.tar" WORKING_DIRECTORY .ccache)

                return()
              endif()
            endforeach()
          endif()
        endforeach()

    - name: Build
      shell: cmake -P {0}
      run: |
        set(ENV{CC} ${{ matrix.config.cc }})
        set(ENV{CXX} ${{ matrix.config.cxx }})
        set(ENV{MACOSX_DEPLOYMENT_TARGET} "${{ env.MACOS_DEPLOYMENT_TARGET }}")

        if ("${{ runner.os }}" STREQUAL "Windows" AND NOT "x${{ matrix.config.environment_script }}" STREQUAL "x")
          execute_process(
            COMMAND "${{ matrix.config.environment_script }}" && set
            OUTPUT_FILE environment_script_output.txt
          )
          file(STRINGS environment_script_output.txt output_lines)
          foreach(line IN LISTS output_lines)
            if (line MATCHES "^([a-zA-Z0-9_-]+)=(.*)$")
              set(ENV{${CMAKE_MATCH_1}} "${CMAKE_MATCH_2}")
            endif()
          endforeach()
        endif()

        set(ENV{NINJA_STATUS} "[%f/%t %o/sec] ")

        file(TO_CMAKE_PATH "$ENV{GITHUB_WORKSPACE}" ccache_basedir)
        set(ENV{CCACHE_BASEDIR} "${ccache_basedir}")
        set(ENV{CCACHE_DIR} "${ccache_basedir}/.ccache")
        set(ENV{CCACHE_SLOPPINESS} "pch_defines,time_macros")
        set(ENV{CCACHE_COMPRESS} "true")
        set(ENV{CCACHE_COMPRESSLEVEL} "9")
        set(ENV{CCACHE_MAXSIZE} "400M")
        if ("${{ matrix.config.cxx }}" STREQUAL "cl")
          set(ENV{CCACHE_MAXSIZE} "600M")
        endif()

        execute_process(
          COMMAND git log --format=%B -n 1 ${{ github.event.after }}
          OUTPUT_VARIABLE git_commit_msg
        )
        if ("${git_commit_msg}" MATCHES "ccache:[ ]*clea[r|n]")
          execute_process(COMMAND ccache --clear COMMAND_ECHO STDOUT)
        endif()

        execute_process(COMMAND ccache -p)
        execute_process(COMMAND ccache -z)

        if ("x${{ matrix.config.environment_script }}" STREQUAL "x")
          set(CDB_OPTION "--no-cdb")
        else()
          set(CDB_OPTION)
        endif()

        if (NOT "${{ steps.elfutils.outputs.elfutils_dir }}" STREQUAL "")
          set(ELFUTILS_OPTION "--elfutils-path;${{ steps.elfutils.outputs.elfutils_dir }}")
        else()
          set(ELFUTILS_OPTION)
        endif()

        find_package(Python3 REQUIRED COMPONENTS Interpreter)
        string(REPLACE "x86" "x64" Python3_EXECUTABLE "${Python3_EXECUTABLE}")

        set(WITH_TESTS "--with-tests")
        set(NO_DMG "--no-dmg")
        if (${{github.ref}} MATCHES "tags/v")
          unset(WITH_TESTS)
          unset(NO_DMG)
        endif()

        if (NOT "x${{ matrix.config.toolchain_path }}" STREQUAL "x")
          set(path_separator ":")
          if ("${{ runner.os }}" STREQUAL "Windows")
            set(path_separator ";")
          endif()
          set(ENV{PATH} "$ENV{GITHUB_WORKSPACE}/${{ matrix.config.toolchain_path }}${path_separator}$ENV{PATH}")
        endif()

        if ("${{ runner.os }}" STREQUAL "macOS")
            if (${{github.ref}} MATCHES "tags/v(.*)")
                set(ENV{CMAKE_OSX_ARCHITECTURES} "x86_64;arm64")
            else()
                set(ENV{CMAKE_OSX_ARCHITECTURES} "x86_64")
            endif()
        endif()

        execute_process(
          COMMAND python
            -u
            scripts/build.py
            --build-type Release
            --src .
            --build build
            --qt-path "${{ steps.qt.outputs.qt_dir }}"
            --llvm-path "${{ steps.libclang.outputs.libclang_dir }}"
            --python3 "${Python3_EXECUTABLE}"
            ${WITH_TESTS}
            ${CDB_OPTION}
            ${ELFUTILS_OPTION}
            ${NO_DMG}
            --add-config=-DCMAKE_C_COMPILER_LAUNCHER=ccache
            --add-config=-DCMAKE_CXX_COMPILER_LAUNCHER=ccache
            --add-config=-DIDE_REVISION_URL=https://github.com/$ENV{GITHUB_REPOSITORY}/commits/$ENV{GITHUB_SHA}
            --zip-infix=-${{ matrix.config.artifact }}-${{ steps.git.outputs.tag }}
            --no-qbs
            --with-cpack
          RESULT_VARIABLE result
          COMMAND_ECHO STDOUT
          OUTPUT_VARIABLE output
          ERROR_VARIABLE output
          ECHO_OUTPUT_VARIABLE ECHO_ERROR_VARIABLE
        )
        if (NOT result EQUAL 0)
          string(REGEX MATCH "FAILED:.*$" error_message "${output}")
          string(REPLACE "\n" "%0A" error_message "${error_message}")
          message("::error::${error_message}")
          message(FATAL_ERROR "Build failed")
        endif()

    - name: ccache statistics
      shell: cmake -P {0}
      run: |
        file(TO_CMAKE_PATH "$ENV{GITHUB_WORKSPACE}" ccache_basedir)
        set(ENV{CCACHE_BASEDIR} "${ccache_basedir}")
        set(ENV{CCACHE_DIR} "${ccache_basedir}/.ccache")
        set(ENV{CCACHE_SLOPPINESS} "pch_defines,time_macros")
        set(ENV{CCACHE_COMPRESS} "true")
        set(ENV{CCACHE_COMPRESSLEVEL} "9")
        set(ENV{CCACHE_MAXSIZE} "400M")
        if ("${{ matrix.config.cxx }}" STREQUAL "cl")
          set(ENV{CCACHE_MAXSIZE} "600M")
        endif()
        execute_process(COMMAND ccache -s)

    - name: Run tests
      shell: cmake -P {0}
      run: |
        include(ProcessorCount)
        ProcessorCount(N)

        set(ENV{CTEST_OUTPUT_ON_FAILURE} "ON")

        if ("${{ runner.os }}" STREQUAL "Linux")
          set(ENV{DISPLAY} ":1")
          set(ENV{LIBGL_ALWAYS_SOFTWARE} "1")
          set(ctest_launcher xvfb-run --auto-servernum --server-num=1)
        elseif ("${{ runner.os }}" STREQUAL "Windows")
          set(ENV{QT_OPENGL} "software")
          set(ENV{QT_ASSUME_STDERR_HAS_CONSOLE} "1")
        endif()

        execute_process(
          COMMAND ${ctest_launcher} ctest -j ${N} --timeout 300 --label-exclude exclude_from_precheck --exclude-regex tst_perfdata
          WORKING_DIRECTORY build/build
          RESULT_VARIABLE result
          OUTPUT_VARIABLE output
          ERROR_VARIABLE output
          ECHO_OUTPUT_VARIABLE ECHO_ERROR_VARIABLE
          TIMEOUT 600
        )
        if (NOT result EQUAL 0)
          string(REGEX MATCH "[0-9]+% tests.*[0-9.]+ sec.*$" test_results "${output}")
          string(REPLACE "\n" "%0A" test_results "${test_results}")
          # Do not fail on ctest failure
          message("::warning::${test_results}")
        endif()

    - name: Upload
      uses: actions/upload-artifact@v3
      with:
        path: build/qtcreator-${{ matrix.config.artifact }}-${{ steps.git.outputs.tag }}.7z
        name: qtcreator-${{ matrix.config.artifact }}-${{ steps.git.outputs.tag }}.7z

    - name: Upload Devel
      uses: actions/upload-artifact@v3
      with:
        path: build/qtcreator-${{ matrix.config.artifact }}-${{ steps.git.outputs.tag }}_dev.7z
        name: qtcreator-${{ matrix.config.artifact }}-${{ steps.git.outputs.tag }}_dev.7z

    - name: Upload wininterrupt
      if: runner.os == 'Windows'
      uses: actions/upload-artifact@v3
      with:
        path: build/wininterrupt-${{ matrix.config.artifact }}-${{ steps.git.outputs.tag }}.7z
        name: wininterrupt-${{ matrix.config.artifact }}-${{ steps.git.outputs.tag }}.7z

    - name: Upload qtcreatorcdbext
      if: runner.os == 'Windows' && matrix.config.is_msvc
      uses: actions/upload-artifact@v3
      with:
        path: build/qtcreatorcdbext-${{ matrix.config.artifact }}-${{ steps.git.outputs.tag }}.7z
        name: qtcreatorcdbext-${{ matrix.config.artifact }}-${{ steps.git.outputs.tag }}.7z

    - name: Upload Debian package
      if: runner.os == 'Linux'
      uses: actions/upload-artifact@v3
      with:
        path: build/build/qtcreator-${{ matrix.config.artifact }}-${{ steps.git.outputs.tag }}.deb
        name: qtcreator-${{ matrix.config.artifact }}-${{ steps.git.outputs.tag }}.deb

    - name: Upload disk image
      if: runner.os == 'macOS' && contains(github.ref, 'tags/v')
      uses: actions/upload-artifact@v3
      with:
        path: build/qt-creator-${{ matrix.config.artifact }}-${{ steps.git.outputs.tag }}.dmg
        name: qt-creator-${{ matrix.config.artifact }}-${{ steps.git.outputs.tag }}.dmg

    - name: Create ccache archive
      working-directory: .ccache
      run: cmake -E tar cf ../${{ steps.ccache.outputs.archive_name }}.tar .

    - name: Upload ccache archive
      uses: actions/upload-artifact@v3
      with:
        path: ./${{ steps.ccache.outputs.archive_name }}.tar
        name: ${{ steps.ccache.outputs.archive_name }}

    - name: Upload Release Changelog
      if: contains(github.ref, 'tags/v')
      uses: actions/upload-artifact@v3
      with:
        path: ./release/changelog.md
        name: changelog.md

  release:
    if: contains(github.ref, 'tags/v')
    runs-on: ubuntu-latest
    needs: build

    steps:
    - name: Download artifacts
      uses: actions/download-artifact@v3
      with:
        path: release-with-dirs

    - name: Fixup artifacts
      run: |
        mkdir release
        mv release-with-dirs/*/* release/
        rm release/ccache*

    - name: Create Release
      id: create_release
      uses: softprops/action-gh-release@v1
      env:
        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
      with:
        tag_name: v${{ needs.build.outputs.tag }}
        body_path: release/changelog.md
        files: release/*
        draft: false
        prerelease: false