CMake functions

I’m tying to move my project from CMake to Meson; I currently use a CMake function to automatically compile some ODB headers; what it basically does is giving some paths and options to the ODB compiler and saving in a variable passed as parameter the generated source files, as well as exporting variables such as required libraries and include directories. Here’s some ugly CMake code

list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/OdbCmake/cmake/Modules")
find_package(ODB REQUIRED COMPONENTS pgsql)
include(${ODB_USE_FILE})
set(PROJECT_SOURCES src/main.cpp)
set(ODB_HEADERS src/table.hpp)
odb_compile(PROJECT_SOURCES FILES ${ODB_HEADERS} DB pgsql STANDARD "c++17")

target_link_libraries(project_name ${ODB_LIBRARIES})
target_include_directories(project_name ${ODB_INCLUDE_DIRS} ${ODB_COMPILE_OUTPUT_DIR})
target_compile_definitions(project_name DATABASE_PGSQL)

Unfortunately the documentations only describes how to compile subprojects, and is silent about executing CMake functions directly from the main project. Is this even possible?

[mensinda]

No, we won’t add support for calling CMake code from meson (besides the CMake subprojects and dependencies). Passing stuff from meson to CMake and then letting meson figure out what to do with the CMake output would be to error-prone and most likely more hassle for the user to set up than just using mesons custom_target.

[eli-schwartz]

If the cmake function is doing something non-trivial that many people might want to use in their projects, then the recommended way to handle this in meson is to submit a PR containing, either:

for looking up how to link stuff without pkg-config, https://mesonbuild.com/Dependencies.html#dependencies-with-custom-lookup-functionality

for helpers to use e.g. a special compiler for generating sources, a module, usable via

mod = import('foo')
mod.somefunction()

Modules must be built into meson because meson wishes to avoid custom functions and macros since it makes build systems hard to reason about when everyone reinvents the same wheel in vendored cmake snippets. Core modules get reviewed, achieve (hopefully) a well-thought-out API surface, and benefit everyone automatically.