Compiler Explorer

c++ source #3

Compiler

Options

Source code

c++ source #5

Compiler

Options

Source code

include("${CMAKE_CURRENT_LIST_DIR}/JEGPUtilities.cmake")

macro(_jegp_parse_arguments_structure)
  macro(set_structure)
    if(desc MATCHES "(.+){(.+)}")
      set(keyword ${CMAKE_MATCH_1})
      set(domain ${CMAKE_MATCH_2})
      string(REPLACE "|" #[[WITH]] ";" #[[TO]] domain #[[IN]] "${domain}")
    elseif(desc MATCHES "(.+)=(.*)")
      set(keyword ${CMAKE_MATCH_1})
      set(default ${CMAKE_MATCH_2})
    else()
      set(keyword ${desc})
    endif()
  endmacro()

macro(unset_structure)
    unset(keyword)
    unset(default)
    unset(domain)
  endmacro()

foreach(desc IN LISTS keyword_descriptions)
    set_structure()
    use_structure()
    unset_structure()
  endforeach()
endmacro()

function(_jegp_parse_arguments_values prefix keyword_descriptions)
  function(assert_domain)
    list(TRANSFORM domain REPLACE "=(.+)" "\\1")
    foreach(value IN LISTS ${parsed_keyword})
      list(FIND domain ${value} index)
      if(index EQUAL -1)
        message(FATAL_ERROR "${keyword} ${value} not in ${domain}.")
      endif()
    endforeach()
  endfunction()

macro(set_domain_defaults)
    foreach(value IN LISTS domain)
      if(value MATCHES "=(.+)")
        list(APPEND default_values ${CMAKE_MATCH_1})
      endif()
    endforeach()

if(default_values)
      set(${parsed_keyword} ${default_values} PARENT_SCOPE)
    endif()

unset(default_values)
  endmacro()

macro(use_structure)
    set(parsed_keyword "${prefix}_${keyword}")
    if(DEFINED "${parsed_keyword}" AND domain)
      assert_domain()
    elseif(NOT DEFINED "${parsed_keyword}")
      if(domain)
        set_domain_defaults()
      elseif(default)
        set(${parsed_keyword} ${default} PARENT_SCOPE)
      endif()
    endif()
  endmacro()

_jegp_parse_arguments_structure()
endfunction()

function(_jegp_parse_arguments_keywords keyword_descriptions out_list)
  macro(use_structure)
    list(APPEND keyword_list ${keyword})
  endmacro()

_jegp_parse_arguments_structure()

set(${out_list} ${keyword_list} PARENT_SCOPE)
endfunction()

function(_jegp_parse_arguments prefix options one_value_keyword_descriptions multi_value_keyword_descriptions)
  _jegp_parse_arguments_keywords("${one_value_keyword_descriptions}" one_value_keywords)
  _jegp_parse_arguments_keywords("${multi_value_keyword_descriptions}" multi_value_keywords)

cmake_parse_arguments("${prefix}" "${options}" "${one_value_keywords}" "${multi_value_keywords}" ${ARGN})

_jegp_parse_arguments_values("${prefix}" "${one_value_keyword_descriptions}")
  _jegp_parse_arguments_values("${prefix}" "${multi_value_keyword_descriptions}")

set(implicit_backward_vars UNPARSED_ARGUMENTS KEYWORDS_MISSING_VALUES)
  set(backward_lists options one_value_keywords multi_value_keywords implicit_backward_vars)
  foreach(list IN LISTS backward_lists)
    list(TRANSFORM ${list} PREPEND ${prefix}_)
  endforeach()

foreach(var IN LISTS ${backward_lists})
    _jegp_backward(${var})
  endforeach()
endfunction()

c++ source #4

Compiler

Options

Source code

c++ source #6

Compiler

Options

Source code

c++ source #7

Compiler

Options

Source code

include("${CMAKE_CURRENT_LIST_DIR}/JEGPUtilities.cmake")

# Set the parent directory of scripts to `_jegp_set_script_command` as-if by a variable in the invoker's scope.
function(_jegp_set_script_directory dir)
  set(_jegp_script_dir "${dir}" PARENT_SCOPE)
endfunction()

# Set `${script}` as a command to run `${script}.cmake` with the given variables and the latest policies.
function(_jegp_set_script_command script #[[<variable=value>...]])
  cmake_parse_arguments("" "" "" "--" ${ARGN})
  list(JOIN _-- ";-D;" unparsed_options)
  list(JOIN _UNPARSED_ARGUMENTS ";-D;" defined_variables)

_jegp_assert(defined_variables "The following implementation requires at least one defined variable to prepend `-D`.")

# cmake-format: off
  set("${script}"
      "${CMAKE_COMMAND}" -D "_JEGP_SCRIPT=${_jegp_script_dir}/${script}.cmake"
                         -D ${defined_variables}
                         -P "${CMAKE_CURRENT_FUNCTION_LIST_DIR}/JEGPIncludeScript.cmake"
                         ${unparsed_options}
      PARENT_SCOPE) # cmake-format: on
endfunction()

c++ source #8

Compiler

Options

Source code

c++ source #9

Compiler

Options

Source code

include("${CMAKE_CURRENT_LIST_DIR}/JEGPAddTarget.cmake")
include("${CMAKE_CURRENT_LIST_DIR}/JEGPParseArguments.cmake")
include("${CMAKE_CURRENT_LIST_DIR}/JEGPSetScript.cmake")

function(jegp_add_module name)
  _jegp_parse_arguments("" "" "" "SOURCES=${name}.cpp;COMPILE_OPTIONS;LINK_LIBRARIES" ${ARGN})
  include("${CMAKE_CURRENT_FUNCTION_LIST_DIR}/JEGPDefineVariables.cmake")

_jegp_add_target(
    ${name}
    TYPE STATIC_LIBRARY
    SOURCES ${_SOURCES}
    COMPILE_OPTIONS ${_COMPILE_OPTIONS}
    LINK_LIBRARIES ${_LINK_LIBRARIES})

set(script_dir "${CMAKE_CURRENT_FUNCTION_LIST_DIR}")
  if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
    include("${script_dir}/GNUModuleMapper.cmake")

target_compile_options(${name} PUBLIC -fmodules-ts INTERFACE "${jegp_gnu_module_mapper_option}")

set(gcm_filename "${CMAKE_CURRENT_BINARY_DIR}/gcm.cache/${name}.gcm")

jegp_gnu_module_mapper_add_mapping("${name}" "${gcm_filename}")

set_source_files_properties(${_SOURCES} PROPERTIES OBJECT_OUTPUTS "${gcm_filename}")
  elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
    set(pcm "${CMAKE_CURRENT_BINARY_DIR}/${name}.pcm")

target_compile_options(${name} PUBLIC -fmodules -fbuiltin-module-map PRIVATE -Xclang -emit-module-interface
                           INTERFACE -fmodule-file=${pcm})

_jegp_set_script_directory("${script_dir}")
    _jegp_set_script_command(SymlinkClangObjectAsPCM "INPUT=$<TARGET_OBJECTS:${name}>" "OUTPUT=${pcm}")
    add_custom_command(TARGET ${name} POST_BUILD COMMAND ${SymlinkClangObjectAsPCM})
  endif()
endfunction()

c++ source #10

Compiler

Options

Source code

c++ source #11

Compiler

Options

Source code

c++ source #12

Compiler

Options

Source code

c++ source #13

Compiler

Options

Source code

c++ source #14

Compiler

Options

Source code

{
  "version": 2,
  "configurePresets": [
    {
      "name": "common",
      "hidden": true,
      "warnings": {
        "dev": true
      }
    },
    {
      "name": "cpp-common",
      "hidden": true,
      "inherits": [ "common" ],
      "generator": "Unix Makefiles",
      "cacheVariables": {
        "CMAKE_CXX_STANDARD": "23",
        "CMAKE_CXX_STANDARD_REQUIRED": "TRUE",
        "CMAKE_CXX_EXTENSIONS": "FALSE",
      },
      "environment": {
        "CXXFLAGS": "$env{STDLIB_LIBCPP_CXXFLAG} -pedantic -Wall -Wextra -Wconversion"
      }
    },
    {
      "name": "gcc",
      "inherits": [ "cpp-common" ],
      "displayName": "GCC configuration"
    },
    {
      "name": "clang",
      "inherits": [ "cpp-common" ],
      "displayName": "Clang configuration",
      "environment": {
        "LDFLAGS": "-lc++abi",
        "STDLIB_LIBCPP_CXXFLAG": "-stdlib=libc++"
      }
    }
  ],
  "buildPresets": [
    {
      "name": "gcc",
      "displayName": "GCC build",
      "configurePreset": "gcc",
      "configuration": "Release"
    },
    {
      "name": "clang",
      "displayName": "Clang build",
      "configurePreset": "clang",
      "configuration": "Release"
    }
  ]
}