qcdx 0.1.0__py3-none-any.whl

qcdx/__init__.py

@@ -0,0 +1,5 @@
+"""QCDX: create, build, test, package and release C and C++ projects."""
+
+from .resources import version as _version
+
+__version__ = _version()

qcdx/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

qcdx/_commit.py

@@ -0,0 +1 @@
+COMMIT = "5b7e37c25528c05ec84e1be4a7c21d4c9a6168e1"

qcdx/cli.py

@@ -0,0 +1,105 @@
+"""The global 'pk' command.
+
+Outside a project it creates one ('pk new'). Inside a project every command
+runs that project's own scripts/pk.py, so the kit version the project
+vendored decides what 'pk build' does, never the installed QCDX version.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+from typing import List, Optional
+
+from . import new, resources
+
+HELP = """\
+pk - QCDX {version}: create and build C and C++ projects with CMake and Conan
+
+usage:
+  pk new NAME [DIR] [flag...]   create a project ('pk new --help')
+  pk cmake-dir                  print the QCDX CMake package directory, for
+                                -DQCDX_DIR=... or CMAKE_PREFIX_PATH
+  pk --version                  QCDX version, and the kit version of this project
+
+Inside a project every other command (build, run, test, sync, ...) runs the
+project's own scripts/pk.py; 'pk help' there lists them all.{where}"""
+
+
+def find_project(start: Path) -> Optional[Path]:
+    for directory in (start, *start.parents):
+        if (directory / "scripts" / "pk.py").is_file() and (directory / "CMakePresets.json").is_file():
+            return directory
+    return None
+
+
+def project_kit_version(project: Path) -> str:
+    try:
+        return (project / "cmake" / "projectkit" / "VERSION").read_text(encoding="utf-8").strip()
+    except OSError:
+        return "unknown (older than 0.1.0)"
+
+
+def tool_path(env: dict) -> None:
+    """Append this Python's scripts folder to PATH, as a fallback.
+
+    pipx and uv keep a package's dependencies in a private environment, so
+    the conan, cmake and ninja of "qcdx[tools]" are only reachable this way.
+    Appended, not prepended: tools the user installed always win.
+    """
+    folder = os.path.dirname(os.path.abspath(sys.executable))
+    found = [name for name in ("conan", "cmake", "ninja")
+             if any(os.path.isfile(os.path.join(folder, name + ext)) for ext in ("", ".exe"))]
+    paths = env.get("PATH", "").split(os.pathsep)
+    if found and folder not in paths:
+        env["PATH"] = os.pathsep.join([*paths, folder])
+
+
+def delegate(project: Path, argv: List[str]) -> int:
+    env = dict(os.environ, PK_SELF_NAME="pk")
+    tool_path(env)
+    script = str(project / "scripts" / "pk.py")
+    try:
+        return subprocess.call([sys.executable, script, *argv], env=env)
+    except KeyboardInterrupt:
+        return 130
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    try:
+        return run(list(sys.argv[1:] if argv is None else argv))
+    except BrokenPipeError:  # 'pk ... | head'
+        os.dup2(os.open(os.devnull, os.O_WRONLY), sys.stdout.fileno())
+        return 141
+    except KeyboardInterrupt:
+        return 130
+
+
+def run(argv: List[str]) -> int:
+    project = find_project(Path.cwd())
+    command = argv[0] if argv else ""
+
+    if command == "new":
+        return new.main(argv[1:])
+    if command in ("--version", "-V", "version"):
+        print(f"QCDX {resources.version()}")
+        if project is not None:
+            print(f"kit {project_kit_version(project)} in {project}")
+        return 0
+    if command == "cmake-dir":
+        print(resources.cmake_dir())
+        return 0
+    if project is not None:
+        return delegate(project, argv)
+    if command in ("", "help", "-h", "--help"):
+        print(HELP.format(version=resources.version(), where="\n\n(no project here)"))
+        return 0
+    sys.stderr.write(f"pk: '{command}' needs a project, and there is none in {Path.cwd()} or above.\n"
+                     "     'pk new NAME' creates one.\n")
+    return 2
+
+
+if __name__ == "__main__":
+    sys.exit(main())

qcdx/data/kit/.github/actions/pk-setup/action.yml

@@ -0,0 +1,157 @@
+name: pk-setup
+description: >-
+  Toolchain, Conan and the Conan cache for a verify/release target. Used by
+  verify.yml and release.yml to only have to set up target once in one place.
+
+inputs:
+  target:
+    description: A target name from cmake/projectkit/scripts/pklib/targets.py.
+    required: true
+  msystem:
+    description: MSYS2 environment (UCRT64, CLANG64, CLANGARM64), Windows only.
+    default: ''
+  cache:
+    description: "'save' restores & saves Conan cache, 'restore' doesn't save."
+    default: save
+  conan-version:
+    default: '2.33.0'
+  llvm-mingw-tag:
+    default: '20260616'
+  llvm-mingw-asset:
+    # Linux x86_64 UCRT build of the pinned release.
+    default: llvm-mingw-20260616-ucrt-ubuntu-22.04-x86_64.tar.xz
+  llvm-mingw-sha256:
+    default: 534b92e067b22a6b4441f48ae9240a3341b17825d04d577eab0cf85c44b4deda
+
+runs:
+  using: composite
+  steps:
+    # -------------------------------------------------------------------------
+    #  Linux and macOS
+    # -------------------------------------------------------------------------
+
+    - if: runner.os != 'Windows'
+      uses: lukka/get-cmake@fffaaafeea488556c2c12dad60690008bc1caacb # v4.4.2
+
+    - if: runner.os != 'Windows'
+      uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+      with:
+        python-version: '3.12'
+
+    - name: Install Conan
+      if: runner.os != 'Windows'
+      shell: bash
+      run: python -m pip install --disable-pip-version-check "conan==${{ inputs.conan-version }}"
+
+    # Conan only accepts compiler.cstd=23 from GCC 14. apt should only run when
+    # something is missing.
+    - name: Install Linux packages
+      if: runner.os == 'Linux'
+      shell: bash
+      env:
+        TARGET: ${{ inputs.target }}
+      run: |
+        packages=()
+        command -v g++-14 >/dev/null || packages+=(g++-14)
+        case "$TARGET" in
+          cross-x86_64-mingw-w64)  packages+=(g++-mingw-w64-x86-64) ;;
+          cross-aarch64-linux-gnu) command -v aarch64-linux-gnu-gcc >/dev/null || packages+=(g++-aarch64-linux-gnu) ;;
+          cross-x86_64-linux-gnu)  command -v x86_64-linux-gnu-gcc  >/dev/null || packages+=(g++-x86-64-linux-gnu) ;;
+        esac
+        if [ ${#packages[@]} -gt 0 ]; then
+          sudo apt-get update -qq
+          sudo apt-get install -y -qq --no-install-recommends "${packages[@]}"
+        fi
+        if [ "$TARGET" = cross-x86_64-mingw-w64 ]; then
+          sudo update-alternatives --set x86_64-w64-mingw32-gcc /usr/bin/x86_64-w64-mingw32-gcc-posix
+          sudo update-alternatives --set x86_64-w64-mingw32-g++ /usr/bin/x86_64-w64-mingw32-g++-posix
+        fi
+        echo "CC=gcc-14" >> "$GITHUB_ENV"
+        echo "CXX=g++-14" >> "$GITHUB_ENV"
+
+    - name: Install llvm-mingw
+      if: inputs.target == 'cross-aarch64-mingw-llvm-w64'
+      shell: bash
+      env:
+        TAG: ${{ inputs.llvm-mingw-tag }}
+        ASSET: ${{ inputs.llvm-mingw-asset }}
+        SHA256: ${{ inputs.llvm-mingw-sha256 }}
+      run: |
+        archive="$RUNNER_TEMP/$ASSET"
+        curl -fsSL -o "$archive" "https://github.com/mstorsjo/llvm-mingw/releases/download/${TAG}/${ASSET}"
+        echo "${SHA256}  ${archive}" | sha256sum -c -
+        mkdir -p "$RUNNER_TEMP/llvm-mingw"
+        tar -xJf "$archive" -C "$RUNNER_TEMP/llvm-mingw" --strip-components=1
+        rm -f "$archive"
+        echo "$RUNNER_TEMP/llvm-mingw/bin" >> "$GITHUB_PATH"
+
+    - name: Point Conan at the runner temp directory
+      if: runner.os != 'Windows'
+      shell: bash
+      run: echo "CONAN_HOME=$RUNNER_TEMP/conan2" >> "$GITHUB_ENV"
+
+    # -------------------------------------------------------------------------
+    # Windows (MSYS2)
+    # -------------------------------------------------------------------------
+
+    - if: runner.os == 'Windows'
+      uses: msys2/setup-msys2@66cd2cce69caa17b53920067426061ca1de3a884 # v2.32.0
+      with:
+        msystem: ${{ inputs.msystem }}
+        update: true
+        install: git
+        pacboy: >-
+          toolchain:p
+          cmake:p
+          ninja:p
+          python-pip:p
+          pkgconf:p
+
+    # Visual Studio is installed on the runner used, Conan prefers
+    # MSVC on Windows, CC/CXX override it.
+    - name: Select the MSYS2 compiler
+      if: runner.os == 'Windows'
+      shell: pwsh
+      env:
+        MSYSTEM_NAME: ${{ inputs.msystem }}
+      run: |
+        if ($env:MSYSTEM_NAME -like 'CLANG*') { $cc = 'clang'; $cxx = 'clang++' } else { $cc = 'gcc'; $cxx = 'g++' }
+        "CC=$cc" >> $env:GITHUB_ENV
+        "CXX=$cxx" >> $env:GITHUB_ENV
+        "CONAN_HOME=$env:RUNNER_TEMP\conan2" >> $env:GITHUB_ENV
+
+    - name: Install Conan
+      if: runner.os == 'Windows'
+      shell: msys2 {0}
+      run: python -m pip install --disable-pip-version-check --break-system-packages "conan==${{ inputs.conan-version }}"
+
+    # -------------------------------------------------------------------------
+    # Conan cache
+    # -------------------------------------------------------------------------
+
+    # The key is shared with verify.yml, and caches saved on main can be read
+    # from every branch and tag: release runs will reuse verify's packages,
+    # NEVER storing a wasteful second copy.
+    - if: inputs.cache == 'save'
+      uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
+      with:
+        path: ${{ runner.temp }}/conan2/p
+        key: conan-${{ inputs.target }}-${{ hashFiles('conanfile.py', 'deps.json', 'conan.lock', 'profiles/**') }}
+        restore-keys: conan-${{ inputs.target }}-
+
+    - if: inputs.cache == 'restore'
+      uses: actions/cache/restore@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
+      with:
+        path: ${{ runner.temp }}/conan2/p
+        key: conan-${{ inputs.target }}-${{ hashFiles('conanfile.py', 'deps.json', 'conan.lock', 'profiles/**') }}
+        restore-keys: conan-${{ inputs.target }}-
+
+    - name: Detect the default Conan profile
+      if: runner.os != 'Windows'
+      shell: bash
+      run: conan profile detect --force
+
+    - name: Detect the default Conan profile
+      if: runner.os == 'Windows'
+      shell: msys2 {0}
+      run: conan profile detect --force

qcdx/data/kit/cmake/QCDXConfig.cmake

@@ -0,0 +1,17 @@
+# find_package(QCDX) puts ProjectKit on the module path:
+#
+#   find_package(QCDX 0.1 REQUIRED)
+#   include(ProjectKit)
+#
+# The same file works installed (share/qcdx/cmake), inside the Python package
+# ('pk cmake-dir') and in a source tree or FetchContent download (cmake/), since
+# everything is found relative to this file.
+
+get_filename_component(QCDX_MODULE_DIR "${CMAKE_CURRENT_LIST_DIR}/projectkit" ABSOLUTE)
+file(STRINGS "${QCDX_MODULE_DIR}/VERSION" QCDX_VERSION LIMIT_COUNT 1)
+
+if(NOT QCDX_MODULE_DIR IN_LIST CMAKE_MODULE_PATH)
+  list(APPEND CMAKE_MODULE_PATH "${QCDX_MODULE_DIR}")
+endif()
+
+set(QCDX_FOUND TRUE)

qcdx/data/kit/cmake/QCDXConfigVersion.cmake

@@ -0,0 +1,46 @@
+# Version check for find_package(QCDX ...). Before 1.0 a minor release may
+# break things, so 0.1 matches 0.1.x only; from 1.0 the major version decides.
+# Version ranges (find_package(QCDX 0.1...<0.3)) are checked against the bounds.
+
+file(STRINGS "${CMAKE_CURRENT_LIST_DIR}/projectkit/VERSION" PACKAGE_VERSION LIMIT_COUNT 1)
+
+set(PACKAGE_VERSION_COMPATIBLE FALSE)
+set(PACKAGE_VERSION_EXACT FALSE)
+
+if(PACKAGE_FIND_VERSION_RANGE)
+  set(_qcdx_ok TRUE)
+  if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN)
+    set(_qcdx_ok FALSE)
+  endif()
+  if(PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE")
+    if(PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX)
+      set(_qcdx_ok FALSE)
+    endif()
+  elseif(PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX)
+    set(_qcdx_ok FALSE)
+  endif()
+  set(PACKAGE_VERSION_COMPATIBLE ${_qcdx_ok})
+  unset(_qcdx_ok)
+elseif(NOT PACKAGE_FIND_VERSION)
+  set(PACKAGE_VERSION_COMPATIBLE TRUE)
+elseif(PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION)
+  string(REGEX MATCH "^[0-9]+" _qcdx_major "${PACKAGE_VERSION}")
+  string(REGEX MATCH "^[0-9]+\\.[0-9]+" _qcdx_minor "${PACKAGE_VERSION}")
+  if(_qcdx_major STREQUAL "0")
+    set(_qcdx_have "${_qcdx_minor}")
+    set(_qcdx_want "${PACKAGE_FIND_VERSION_MAJOR}.${PACKAGE_FIND_VERSION_MINOR}")
+  else()
+    set(_qcdx_have "${_qcdx_major}")
+    set(_qcdx_want "${PACKAGE_FIND_VERSION_MAJOR}")
+  endif()
+  if(_qcdx_have STREQUAL _qcdx_want)
+    set(PACKAGE_VERSION_COMPATIBLE TRUE)
+  endif()
+  if(PACKAGE_VERSION VERSION_EQUAL PACKAGE_FIND_VERSION)
+    set(PACKAGE_VERSION_EXACT TRUE)
+  endif()
+  unset(_qcdx_major)
+  unset(_qcdx_minor)
+  unset(_qcdx_have)
+  unset(_qcdx_want)
+endif()

qcdx/data/kit/cmake/projectkit/ApplicationCreator.cmake

@@ -0,0 +1,262 @@
+include_guard(GLOBAL)
+
+function(pk_create_app)
+  set(options
+    DEFAULT_DIRS
+    REQUIRE_SOURCES
+    REQUIRE_PUBLIC_HEADERS
+    REQUIRE_PRIVATE_HEADERS
+    NO_DEFAULT_LINKS
+    NO_INSTALL)
+
+  set(one_value_args
+    NAME
+    LANGUAGE
+    SOURCE_DIR
+    INCLUDE_DIR)
+
+  set(multi_value_args
+    TARGET_NAME
+    OUTPUT_NAME
+    SOURCES
+    PUBLIC_HEADERS
+    PRIVATE_HEADERS
+    LINK_PRIVATE
+    LINK_INTERFACE
+    DEPS)
+
+  cmake_parse_arguments(ARG
+    "${options}" "${one_value_args}" "${multi_value_args}" ${ARGN})
+
+  pk_project_prefix(prefix)
+
+  if(NOT ARG_NAME)
+    message(FATAL_ERROR "pk_create_app requires a 'NAME' argument.")
+  endif()
+  if(ARG_UNPARSED_ARGUMENTS)
+    message(FATAL_ERROR
+      "pk_create_app (func): unrecognized arguments for '${ARG_NAME}': "
+      "${ARG_UNPARSED_ARGUMENTS}")
+  endif()
+
+  if(NOT ARG_TARGET_NAME)
+    set(ARG_TARGET_NAME "${ARG_NAME}_app")
+  endif()
+  list(LENGTH ARG_TARGET_NAME target_count)
+
+  if(NOT ARG_OUTPUT_NAME)
+    if(target_count EQUAL 1)
+      set(ARG_OUTPUT_NAME "${ARG_NAME}")
+    else()
+      set(ARG_OUTPUT_NAME ${ARG_TARGET_NAME})
+    endif()
+  endif()
+  list(LENGTH ARG_OUTPUT_NAME output_count)
+
+  if(NOT output_count EQUAL target_count)
+    message(FATAL_ERROR
+      "pk_create_app (func): '${ARG_NAME}' has ${target_count} "
+      "'TARGET_NAME' values but ${output_count} 'OUTPUT_NAME' values, one "
+      "'OUTPUT_NAME' is required per target.")
+  endif()
+
+  set(unique_targets ${ARG_TARGET_NAME})
+  set(unique_outputs ${ARG_OUTPUT_NAME})
+  list(REMOVE_DUPLICATES unique_targets)
+  list(REMOVE_DUPLICATES unique_outputs)
+  list(LENGTH unique_targets unique_target_count)
+  list(LENGTH unique_outputs unique_output_count)
+
+  if(NOT unique_target_count EQUAL target_count)
+    message(FATAL_ERROR
+      "pk_create_app (func): '${ARG_NAME}' has duplicate 'TARGET_NAME' "
+      "values: ${ARG_TARGET_NAME}")
+  endif()
+  if(NOT unique_output_count EQUAL output_count)
+    message(FATAL_ERROR
+      "pk_create_app (func): '${ARG_NAME}' has duplicate 'OUTPUT_NAME' "
+      "values: ${ARG_OUTPUT_NAME}")
+  endif()
+
+  pk_resolve_files(ARG_SOURCES "'${ARG_NAME}' SOURCES"
+    "\\.(c|cc|cpp|cxx)$" ${ARG_SOURCES})
+  pk_resolve_files(ARG_PUBLIC_HEADERS "'${ARG_NAME}' PUBLIC_HEADERS"
+    "\\.(h|hh|hpp|hxx)$" ${ARG_PUBLIC_HEADERS})
+  pk_resolve_files(ARG_PRIVATE_HEADERS "'${ARG_NAME}' PRIVATE_HEADERS"
+    "\\.(h|hh|hpp|hxx)$" ${ARG_PRIVATE_HEADERS})
+
+  foreach(header IN LISTS ARG_PUBLIC_HEADERS)
+    if(header IN_LIST ARG_PRIVATE_HEADERS)
+      message(FATAL_ERROR
+        "pk_create_app (func): '${ARG_NAME}' header passed as both "
+        "'PUBLIC_HEADERS' and 'PRIVATE_HEADERS': '${header}'.")
+    endif()
+  endforeach()
+
+  set(source_dir_given FALSE)
+  set(include_dir_given FALSE)
+
+  if(ARG_SOURCE_DIR)
+    cmake_path(ABSOLUTE_PATH ARG_SOURCE_DIR
+      BASE_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" NORMALIZE)
+    string(REGEX REPLACE "(.)/+$" "\\1" ARG_SOURCE_DIR "${ARG_SOURCE_DIR}")
+    if(NOT IS_DIRECTORY "${ARG_SOURCE_DIR}")
+      message(FATAL_ERROR
+        "pk_create_app (func): 'SOURCE_DIR' for '${ARG_NAME}' is not a "
+        "directory: '${ARG_SOURCE_DIR}'.")
+    endif()
+    set(source_dir_given TRUE)
+  elseif(ARG_DEFAULT_DIRS)
+    set(ARG_SOURCE_DIR "${PROJECT_SOURCE_DIR}/apps/${ARG_NAME}")
+  else()
+    set(ARG_SOURCE_DIR "")
+  endif()
+
+  if(ARG_INCLUDE_DIR)
+    cmake_path(ABSOLUTE_PATH ARG_INCLUDE_DIR
+      BASE_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" NORMALIZE)
+    string(REGEX REPLACE "(.)/+$" "\\1" ARG_INCLUDE_DIR "${ARG_INCLUDE_DIR}")
+    if(NOT IS_DIRECTORY "${ARG_INCLUDE_DIR}")
+      message(FATAL_ERROR
+        "pk_create_app (func): 'INCLUDE_DIR' for '${ARG_NAME}' is not a "
+        "directory: '${ARG_INCLUDE_DIR}'.")
+    endif()
+    set(include_dir_given TRUE)
+  else()
+    set(ARG_INCLUDE_DIR "")
+  endif()
+
+  if(ARG_SOURCE_DIR)
+    set(source_where "'${ARG_SOURCE_DIR}'")
+  else()
+    set(source_where "no 'SOURCE_DIR'")
+  endif()
+  if(ARG_INCLUDE_DIR)
+    set(include_where "'${ARG_INCLUDE_DIR}'")
+  else()
+    set(include_where "no 'INCLUDE_DIR'")
+  endif()
+
+  pk_collect_components(${ARG_NAME}
+    SOURCE_DIR "${ARG_SOURCE_DIR}"
+    INCLUDE_DIR "${ARG_INCLUDE_DIR}"
+    OUT_SOURCES globbed_sources
+    OUT_PUBLIC_HEADERS globbed_public_headers
+    OUT_PRIVATE_HEADERS globbed_private_headers)
+
+  if(source_dir_given AND NOT globbed_sources AND NOT globbed_private_headers)
+    message(FATAL_ERROR
+      "pk_create_app (func): 'SOURCE_DIR' for '${ARG_NAME}' contains no "
+      "sources or headers: '${ARG_SOURCE_DIR}'.")
+  endif()
+  if(include_dir_given AND NOT globbed_public_headers)
+    message(FATAL_ERROR
+      "pk_create_app (func): 'INCLUDE_DIR' for '${ARG_NAME}' contains no "
+      "headers: '${ARG_INCLUDE_DIR}'.")
+  endif()
+
+  set(explicit_files ${ARG_SOURCES} ${ARG_PUBLIC_HEADERS} ${ARG_PRIVATE_HEADERS})
+  if(explicit_files)
+    foreach(globbed IN ITEMS
+        globbed_sources globbed_public_headers globbed_private_headers)
+      if(${globbed})
+        list(REMOVE_ITEM ${globbed} ${explicit_files})
+      endif()
+    endforeach()
+  endif()
+
+  list(APPEND ARG_SOURCES ${globbed_sources})
+  list(APPEND ARG_PUBLIC_HEADERS ${globbed_public_headers})
+  list(APPEND ARG_PRIVATE_HEADERS ${globbed_private_headers})
+
+  if(NOT ARG_SOURCES)
+    message(FATAL_ERROR
+      "pk_create_app (func): No sources found for '${ARG_NAME}' in "
+      "${source_where} and none were given via 'SOURCES'.")
+  endif()
+  if(ARG_REQUIRE_PUBLIC_HEADERS AND NOT ARG_PUBLIC_HEADERS)
+    message(FATAL_ERROR
+      "pk_create_app (func): Public headers are required for "
+      "'${ARG_NAME}', yet none were found in ${include_where} and none were "
+      "given via 'PUBLIC_HEADERS'.")
+  endif()
+  if(ARG_REQUIRE_PRIVATE_HEADERS AND NOT ARG_PRIVATE_HEADERS)
+    message(FATAL_ERROR
+      "pk_create_app (func): Private headers are required for "
+      "'${ARG_NAME}', yet none were found in ${source_where} and none were "
+      "given via 'PRIVATE_HEADERS'.")
+  endif()
+
+  pk_resolve_language(language source_languages "application '${ARG_NAME}'"
+    "${ARG_LANGUAGE}" ${ARG_SOURCES})
+
+  set(app_languages ${language} ${source_languages})
+  list(REMOVE_DUPLICATES app_languages)
+
+  set(std_C "c_std_${${prefix}_C_STANDARD}")
+  set(std_CXX "cxx_std_${${prefix}_CXX_STANDARD}")
+
+  foreach(target output IN ZIP_LISTS ARG_TARGET_NAME ARG_OUTPUT_NAME)
+    add_executable(${target} ${ARG_SOURCES})
+
+    set_target_properties(${target} PROPERTIES
+      OUTPUT_NAME "${output}")
+
+    if(ARG_PUBLIC_HEADERS)
+      target_sources(${target}
+        PRIVATE
+          FILE_SET    ${ARG_NAME}_app_public_headers
+          TYPE        HEADERS
+          BASE_DIRS   "${PROJECT_SOURCE_DIR}/include"
+          FILES       ${ARG_PUBLIC_HEADERS})
+    endif()
+
+    if(ARG_PRIVATE_HEADERS)
+      target_sources(${target}
+        PRIVATE
+          FILE_SET    ${ARG_NAME}_app_private_headers
+          TYPE        HEADERS
+          BASE_DIRS   "${PROJECT_SOURCE_DIR}/apps"
+          FILES       ${ARG_PRIVATE_HEADERS})
+    endif()
+
+    foreach(app_language IN LISTS app_languages)
+      target_compile_features(${target} PRIVATE ${std_${app_language}})
+    endforeach()
+
+    target_compile_definitions(${target} PRIVATE
+      ${prefix}_VERSION_STRING="${PROJECT_VERSION}")
+  endforeach()
+
+  if(ARG_NO_DEFAULT_LINKS)
+    set(default_links NO_DEFAULT_LINKS)
+  else()
+    set(default_links "")
+  endif()
+
+  pk_link_targets(
+    ${default_links}
+    TARGETS ${ARG_TARGET_NAME}
+    LINK_PRIVATE ${ARG_LINK_PRIVATE}
+    LINK_INTERFACE ${ARG_LINK_INTERFACE})
+
+  pk_deps_link(
+    ROLE APPLICATION
+    TARGETS ${ARG_TARGET_NAME}
+    PRIVATE ${ARG_DEPS})
+
+  foreach(target IN LISTS ARG_TARGET_NAME)
+    pk_enable_static_analysis(${target})
+  endforeach()
+
+  if(${prefix}_INSTALL AND NOT ARG_NO_INSTALL)
+    install(TARGETS ${ARG_TARGET_NAME}
+      RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}")
+  endif()
+
+  pk_register_targets(APPLICATION TARGETS ${ARG_TARGET_NAME})
+
+  string(JOIN "', '" target_list ${ARG_TARGET_NAME})
+  message(STATUS "${PROJECT_NAME}: Application built for '${ARG_NAME}' "
+    "with executable target(s) named '${target_list}'.")
+endfunction()

qcdx/data/kit/cmake/projectkit/CompilerWarnings.cmake

@@ -0,0 +1,54 @@
+include_guard(GLOBAL)
+
+function(pk_add_warnings_target)
+  pk_project_prefix(prefix)
+  set(target "${PROJECT_NAME}_warnings")
+
+  add_library(${target} INTERFACE)
+  add_library(${PROJECT_NAME}::warnings ALIAS ${target})
+  set_target_properties(${target} PROPERTIES EXPORT_NAME warnings)
+
+  set(gnu_ids "GNU,Clang,AppleClang,IntelLLVM")
+
+  set(gnu_common
+    -Wall
+    -Wextra
+    -Wpedantic
+    -Wshadow
+    -Wcast-align
+    -Wsign-conversion
+    -Wnull-dereference
+    -Wdouble-promotion
+    -Wformat=2
+    -Wimplicit-fallthrough)
+
+  set(gnu_c ${gnu_common}
+    -Wstrict-prototypes
+    -Wmissing-prototypes)
+
+  set(gnu_cxx ${gnu_common}
+    -Wnon-virtual-dtor
+    -Wold-style-cast)
+
+  set(msvc_c
+    /W4
+    /w14826)
+
+  set(msvc_cxx ${msvc_c}
+    /permissive-
+    /w14640)
+
+  target_compile_options(${target} INTERFACE
+    "$<$<COMPILE_LANG_AND_ID:C,${gnu_ids}>:${gnu_c}>"
+    "$<$<COMPILE_LANG_AND_ID:CXX,${gnu_ids}>:${gnu_cxx}>"
+    "$<$<COMPILE_LANG_AND_ID:C,MSVC>:${msvc_c}>"
+    "$<$<COMPILE_LANG_AND_ID:CXX,MSVC>:${msvc_cxx}>")
+
+  if(${prefix}_WERROR)
+    target_compile_options(${target} INTERFACE
+      "$<$<COMPILE_LANG_AND_ID:C,${gnu_ids}>:-Werror>"
+      "$<$<COMPILE_LANG_AND_ID:CXX,${gnu_ids}>:-Werror>"
+      "$<$<COMPILE_LANG_AND_ID:C,MSVC>:/WX>"
+      "$<$<COMPILE_LANG_AND_ID:CXX,MSVC>:/WX>")
+  endif()
+endfunction()