beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-26 09:30:24 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 7
ladybird/Meta/Lagom/CMakeLists.txt

792 lines
29 KiB
Text
Raw Normal View History

Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
cmake_minimum_required (VERSION 3.16)
project(
Lagom
VERSION 0.0.0
DESCRIPTION "Host build of SerenityOS libraries and applications"
HOMEPAGE_URL "https://github.com/SerenityOS/serenity"
LANGUAGES C CXX
)
Lagom: Import the beginnings of a "port" of Serenity libs for the outside. The C++ facilities of Serenity are getting pretty comfortable, and I'd like to take them with me to projects outside the system. Let's make it a bit easier to do that by bundling AK and LibCore (for now) into a portable library called "Lagom". :^)
2019-07-25 09:56:08 +00:00
Lagom: Update GCC version check in CMakeLists.txt This was forgotten in bc2ebcadc0eb695605051c9d362c3f5dc184c63c.
2022-10-31 14:08:39 +00:00
if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS "12")
Meta: Switch to a SuperBuild that splits host and target builds Replace the old logic where we would start with a host build, and swap all the CMake compiler and target variables underneath it to trick CMake into building for Serenity after we configured and built the Lagom code generators. The SuperBuild creates two ExternalProjects, one for Lagom and one for Serenity. The Serenity project depends on the install stage for the Lagom build. The SuperBuild also generates a CMakeToolchain file for the Serenity build to use that replaces the old toolchain file that was only used for Ports. To ensure that code generators are rebuilt when core libraries such as AK and LibCore are modified, developers will need to direct their manual `ninja` invocations to the SuperBuild's binary directory instead of the Serenity binary directory. This commit includes warning coalescing and option style cleanup for the affected CMakeLists in the Kernel, top level, and runtime support libraries. A large part of the cleanup is replacing USE_CLANG_TOOLCHAIN with the proper CMAKE_CXX_COMPILER_ID variable, which will no longer be confused by a host clang compiler.
2021-09-07 08:21:36 +00:00
message(FATAL_ERROR
Lagom: Update GCC version check in CMakeLists.txt This was forgotten in bc2ebcadc0eb695605051c9d362c3f5dc184c63c.
2022-10-31 14:08:39 +00:00
"A GCC version less than 12 was detected (${CMAKE_CXX_COMPILER_VERSION}), this is unsupported.\n"
Meta: Switch to a SuperBuild that splits host and target builds Replace the old logic where we would start with a host build, and swap all the CMake compiler and target variables underneath it to trick CMake into building for Serenity after we configured and built the Lagom code generators. The SuperBuild creates two ExternalProjects, one for Lagom and one for Serenity. The Serenity project depends on the install stage for the Lagom build. The SuperBuild also generates a CMakeToolchain file for the Serenity build to use that replaces the old toolchain file that was only used for Ports. To ensure that code generators are rebuilt when core libraries such as AK and LibCore are modified, developers will need to direct their manual `ninja` invocations to the SuperBuild's binary directory instead of the Serenity binary directory. This commit includes warning coalescing and option style cleanup for the affected CMakeLists in the Kernel, top level, and runtime support libraries. A large part of the cleanup is replacing USE_CLANG_TOOLCHAIN with the proper CMAKE_CXX_COMPILER_ID variable, which will no longer be confused by a host clang compiler.
2021-09-07 08:21:36 +00:00
"Please re-read the build instructions documentation, and upgrade your host compiler.\n")
Meta: Add BUILD_SHARED_LIBS option for Lagom builds This standard CMake option controls whether add_library() calls will use STATIC or SHARED by default. The flag is set to on by default since that's what we want for normal CI jobs and local builds and the test262 runner, but disabled for oss-fuzz builds. This should finally fix the oss-fuzz build after it was broken in #9017 oss-fuzz un-breakage was verified by running the following commands in the oss-fuzz repo: python infra/helper.py build_image serenity python infra/helper.py build_fuzzers --sanitizer address --engine afl \ --architecture x86_64 serenity /path/to/local/checkout/Meta/Lagom python infra/helper.py check_build --sanitizer address --engine afl \ --architecture x86_64 serenity
2021-08-01 10:37:28 +00:00
endif()
Meta: Add LibUnicode (and its tests) to Lagom This is primarily to allow using LibUnicode within LibJS and its REPL. Note: this seems to be the first time that a Lagom dependency requires generated source files. For this to work, some of Lagom's CMakeLists.txt commands needed to be re-organized to include the CMake files that fetch and parse UnicodeData.txt. The paths required to invoke the generator also differ depending on what is currently building (SerenityOS vs. Lagom as part of the Serenity build vs. a standalone Lagom build).
2021-07-25 19:15:47 +00:00
# This is required for CMake (when invoked for a Lagom-only build) to
# ignore any files downloading during the build, e.g. UnicodeData.txt.
# https://cmake.org/cmake/help/latest/policy/CMP0058.html
cmake_policy(SET CMP0058 NEW)
Meta: Link Lagom with LLD by default and allow configuring the linker This ports over the `LADYBIRD_USE_LLD` option from the standalone Ladybird build and generalizes it to work for mold as well: the `LAGOM_USE_LINKER` variable can be set to the desired name of the linker. If it's empty, we default to trying LLD and Mold on ELF platforms (in this order).
2023-09-05 05:40:57 +00:00
# Make CMAKE_EXE_LINKER_FLAGS have an effect on `try_compile()` jobs.
# This is required if we want to have the `LAGOM_USE_LINKER` option
# take effect in `check_linker_flag` checks.
cmake_policy(SET CMP0056 NEW)
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
get_filename_component(
SERENITY_PROJECT_ROOT "${PROJECT_SOURCE_DIR}/../.."
ABSOLUTE CACHE
)
Meta: Build select Services in Lagom Add overrides for serenity_bin and serenity_lib to allow the actual CMakeLists.txt from Userland to be used to build as many services as possible without adding more clutter to Meta/Lagom/CMakeLists.txt
2022-07-04 16:08:01 +00:00
set(SerenityOS_SOURCE_DIR "${SERENITY_PROJECT_ROOT}" CACHE STRING "")
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
Meta: Add Meta/CMake to the CMAKE_MODULE_PATH for Serenity and Lagom This makes it so we don't need to specify the full path to all the helper scripts we include() from different places in the codebase and feels a lot cleaner.
2021-09-07 07:50:09 +00:00
list(APPEND CMAKE_MODULE_PATH "${SERENITY_PROJECT_ROOT}/Meta/CMake")
Meta: Move all options to targetname_options.cmake files This common strategy of having a serenity_option() macro defined in either the Lagom or top level CMakeLists.txt allows us to do two things: First, we can more clearly see which options are Serenity-specific, Lagom-specific, or common between the target and host builds. Second, it enables the upcoming SuperBuild changes to set() the options in the SuperBuild's CMake cache and forward each target's options to the corresponding ExternalProject.
2021-09-07 08:08:54 +00:00
if(NOT COMMAND serenity_option)
macro(serenity_option)
set(${ARGV})
endmacro()
endif()
Meta: Error out on find_program errors with CMake less than 3.18 We have seen some cases where the build fails for folks, and they are missing unzip/tar/gzip etc. We can catch some of these in CMake itself, so lets make sure to handle that uniformly across the build system. The REQUIRED flag to `find_program` was only added on in CMake 3.18 and above, so we can't rely on that to actually halt the program execution.
2022-03-18 11:31:36 +00:00
include(check_for_dependencies)
Meta: Link Lagom with LLD by default and allow configuring the linker This ports over the `LADYBIRD_USE_LLD` option from the standalone Ladybird build and generalizes it to work for mold as well: the `LAGOM_USE_LINKER` variable can be set to the desired name of the linker. If it's empty, we default to trying LLD and Mold on ELF platforms (in this order).
2023-09-05 05:40:57 +00:00
include(use_linker)
CMake: Pass NO_POLICY_SCOPE to options cmake helpers Tell CMake to not create a new policy scope for the (lagom|serenity|common)_options.cmake helpers, and lets us set common policies for both projects in common_options.cmake that actually apply to the rest of the project, instead of just common_options.cmake itself.
2022-12-14 01:57:01 +00:00
include(lagom_options NO_POLICY_SCOPE)
Meta: Move all options to targetname_options.cmake files This common strategy of having a serenity_option() macro defined in either the Lagom or top level CMakeLists.txt allows us to do two things: First, we can more clearly see which options are Serenity-specific, Lagom-specific, or common between the target and host builds. Second, it enables the upcoming SuperBuild changes to set() the options in the SuperBuild's CMake cache and forward each target's options to the corresponding ExternalProject.
2021-09-07 08:08:54 +00:00
Meta: Switch to a SuperBuild that splits host and target builds Replace the old logic where we would start with a host build, and swap all the CMake compiler and target variables underneath it to trick CMake into building for Serenity after we configured and built the Lagom code generators. The SuperBuild creates two ExternalProjects, one for Lagom and one for Serenity. The Serenity project depends on the install stage for the Lagom build. The SuperBuild also generates a CMakeToolchain file for the Serenity build to use that replaces the old toolchain file that was only used for Ports. To ensure that code generators are rebuilt when core libraries such as AK and LibCore are modified, developers will need to direct their manual `ninja` invocations to the SuperBuild's binary directory instead of the Serenity binary directory. This commit includes warning coalescing and option style cleanup for the affected CMakeLists in the Kernel, top level, and runtime support libraries. A large part of the cleanup is replacing USE_CLANG_TOOLCHAIN with the proper CMAKE_CXX_COMPILER_ID variable, which will no longer be confused by a host clang compiler.
2021-09-07 08:21:36 +00:00
if(ENABLE_ALL_THE_DEBUG_MACROS)
include(all_the_debug_macros)
endif()
Lagom: Add option to build Ladybird as part of a Lagom build This means that Ladybird can be built with either Meta/Lagom or Ladybird as the top-level source directory. This setup is a bit awkward, but will preserve the packaging story for Ladybird until we come up with a more permanent solution.
2022-12-23 18:36:45 +00:00
# FIXME: Is it worth inventing `serenity_dependent_option` ?
if (ENABLE_LAGOM_LADYBIRD)
set(ENABLE_LAGOM_LIBWEB ON CACHE BOOL "" FORCE)
endif()
Meta: Add FIXME for not setting BUILD_SHARED_LIBS in Lagom build This is really the business of the consuming project. We will need to make changes to libjs-test262 and to oss-fuzz to address this properly.
2021-09-07 00:06:46 +00:00
# FIXME: BUILD_SHARED_LIBS has a default of OFF, as it's intended to be set by the
Meta: Define LagomMain outside of the BUILD_LAGOM branch This allows code generators to use LagomMain. Otherwise, during CI, they are built during the superbuild without BUILD_LAGOM=ON.
2021-11-23 17:34:31 +00:00
# user when configuring the project. We should instead change libjs-test262
Meta: Add FIXME for not setting BUILD_SHARED_LIBS in Lagom build This is really the business of the consuming project. We will need to make changes to libjs-test262 and to oss-fuzz to address this properly.
2021-09-07 00:06:46 +00:00
# and oss-fuzz to set this option on their end, and enable it by default in
Lagom: Add two-stage build for Fuzzers to enable fuzzing generated code This allows us to fuzz the generated unicode and timezone database helpers, and to fuzz things like LibJS using Fuzzilli to get proper coverage of our unicode handling code. Update the Azure CI to use the new two-stage build as well, and cleanup some unused CMake options there.
2022-02-19 23:09:40 +00:00
# Meta/serenity.sh. This is #9867.
Meta: Switch to a SuperBuild that splits host and target builds Replace the old logic where we would start with a host build, and swap all the CMake compiler and target variables underneath it to trick CMake into building for Serenity after we configured and built the Lagom code generators. The SuperBuild creates two ExternalProjects, one for Lagom and one for Serenity. The Serenity project depends on the install stage for the Lagom build. The SuperBuild also generates a CMakeToolchain file for the Serenity build to use that replaces the old toolchain file that was only used for Ports. To ensure that code generators are rebuilt when core libraries such as AK and LibCore are modified, developers will need to direct their manual `ninja` invocations to the SuperBuild's binary directory instead of the Serenity binary directory. This commit includes warning coalescing and option style cleanup for the affected CMakeLists in the Kernel, top level, and runtime support libraries. A large part of the cleanup is replacing USE_CLANG_TOOLCHAIN with the proper CMAKE_CXX_COMPILER_ID variable, which will no longer be confused by a host clang compiler.
2021-09-07 08:21:36 +00:00
option(BUILD_SHARED_LIBS "Build shared libraries instead of static libraries" ON)
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
find_package(Threads REQUIRED)
Meta/Lagom: Link Threads::Threads This is required for me to be able to build both Serenity and Ladybird from the same repo. Without this the two builds seem to stomp on each other, then fail to link.
2023-01-05 14:47:27 +00:00
# FIXME: This global link libraries is required to workaround linker issues (on some systems)
# from the Ladybird import. See https://github.com/SerenityOS/serenity/issues/16847
link_libraries(Threads::Threads)
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
Meta: Semi-automatically detect ccache for Lagom builds The top-level CMakeLists.txt already automatically detects ccache, but CI will invoke CMake with Lagom's CMakeLists.txt. Add an option to Lagom to do the same detection.
2021-08-17 02:10:34 +00:00
if (ENABLE_LAGOM_CCACHE)
Meta: Separate ccache setup into its own component
2022-12-06 21:57:20 +00:00
include(setup_ccache)
Meta: Semi-automatically detect ccache for Lagom builds The top-level CMakeLists.txt already automatically detects ccache, but CI will invoke CMake with Lagom's CMakeLists.txt. Add an option to Lagom to do the same detection.
2021-08-17 02:10:34 +00:00
endif()
CMake: Allow building fuzzing targets without libFuzzer or OSS-Fuzz
2022-03-21 10:36:41 +00:00
if (ENABLE_FUZZERS_LIBFUZZER OR ENABLE_FUZZERS_OSSFUZZ)
set(ENABLE_FUZZERS ON)
endif()
CMake+Userland: Use CMakeLists from Userland to build Lagom Libraries Also do this for Shell. This greatly simplifies the CMakeLists in Lagom, replacing many glob patterns with a big list of libraries. There are still a few special libraries that need some help to conform to the pattern, like LibELF and LibWebView. It also lets us remove essentially all of the Serenity or Lagom binary directory detection logic from code generators, as now both projects directories enter the generator logic from the same place.
2022-10-14 02:14:36 +00:00
# We need to make sure not to build code generators for Fuzzer builds, as they already have their own main.cpp
# Instead, we import them from a previous install of Lagom. This mandates a two-stage build for fuzzers.
# The same concern goes for cross-compile builds, where we need the tools built for the host
set(BUILD_LAGOM_TOOLS ON)
if (ENABLE_FUZZERS OR CMAKE_CROSSCOMPILING)
find_package(LagomTools REQUIRED)
set(BUILD_LAGOM_TOOLS OFF)
endif()
Meta+Tests: Allow running FLAC spec tests The FLAC "spec tests", or rather the test suite by xiph that exercises weird FLAC features and edge cases, can be found at https://github.com/ietf-wg-cellar/flac-test-files and is a good challenge for our FLAC decoder to become more spec compliant. Running these tests is similar to LibWasm spec tests, you need to pass INCLUDE_FLAC_SPEC_TESTS to CMake. As of integrating these tests, 23 out of 63 fail. :yakplus:
2022-07-25 11:28:16 +00:00
include(flac_spec_tests)
Meta: Move compiler flags into standalone CMake files This way we can have all of them in a single place, similar to how we structure options added via the serenity_option() macro.
2022-05-14 13:07:12 +00:00
include(lagom_compile_options)
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
Lagom: Enable compile_commands.json for the lagom build directory This allows a developer who only wants to look at Lagom to have their IDE find source files and headers properly.
2022-10-17 05:55:04 +00:00
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
Everywhere: Add support for compilation under emscripten Co-Authored-By: Andrew Kaster <akaster@serenityos.org>
2022-11-20 03:23:14 +00:00
if (EMSCRIPTEN)
set(CMAKE_EXECUTABLE_SUFFIX ".js")
add_compile_options(-gsource-map)
add_link_options(--emrun "SHELL:-s ALLOW_MEMORY_GROWTH")
endif()
Lagom: Enable sanitizer builds with gcc Previously the CMake options for -fsanitize=address, thread and undefined were gated behind clang, which was unecessary. Only -fsanitize=fuzzer is clang-only.
2021-05-12 11:49:19 +00:00
if (ENABLE_ADDRESS_SANITIZER)
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
add_compile_options(-fsanitize=address -fno-omit-frame-pointer)
Lagom: Enable sanitizer builds with gcc Previously the CMake options for -fsanitize=address, thread and undefined were gated behind clang, which was unecessary. Only -fsanitize=fuzzer is clang-only.
2021-05-12 11:49:19 +00:00
set(LINKER_FLAGS "${LINKER_FLAGS} -fsanitize=address")
endif()
Lagom: Add clang address/memory/undefined-behavior analyzer support Adding the ability to turn on Clang analyzer support in the Lagom build. Right now the following are working warning free on the LibJS test suite: -DENABLE_MEMORY_SANITIZER:BOOL=ON -DENABLE_ADDRESS_SANITIZER:BOOL=ON The following analyzer produces errors when running the LibJS test suite: -DENABLE_UNDEFINED_SANITIZER:BOOL=ON
2020-04-05 10:21:03 +00:00
Lagom: Enable sanitizer builds with gcc Previously the CMake options for -fsanitize=address, thread and undefined were gated behind clang, which was unecessary. Only -fsanitize=fuzzer is clang-only.
2021-05-12 11:49:19 +00:00
if (ENABLE_MEMORY_SANITIZER)
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
add_compile_options(-fsanitize=memory -fsanitize-memory-track-origins -fno-omit-frame-pointer)
Lagom: Enable sanitizer builds with gcc Previously the CMake options for -fsanitize=address, thread and undefined were gated behind clang, which was unecessary. Only -fsanitize=fuzzer is clang-only.
2021-05-12 11:49:19 +00:00
set(LINKER_FLAGS "${LINKER_FLAGS} -fsanitize=memory -fsanitize-memory-track-origins")
endif()
Lagom: Add clang address/memory/undefined-behavior analyzer support Adding the ability to turn on Clang analyzer support in the Lagom build. Right now the following are working warning free on the LibJS test suite: -DENABLE_MEMORY_SANITIZER:BOOL=ON -DENABLE_ADDRESS_SANITIZER:BOOL=ON The following analyzer produces errors when running the LibJS test suite: -DENABLE_UNDEFINED_SANITIZER:BOOL=ON
2020-04-05 10:21:03 +00:00
Lagom: Enable sanitizer builds with gcc Previously the CMake options for -fsanitize=address, thread and undefined were gated behind clang, which was unecessary. Only -fsanitize=fuzzer is clang-only.
2021-05-12 11:49:19 +00:00
if (ENABLE_UNDEFINED_SANITIZER)
Meta: Enable vptr sanitation by default for Lagom UBSAN builds
2022-09-14 20:33:46 +00:00
add_compile_options(-fsanitize=undefined -fno-omit-frame-pointer)
CMake: Add `UNDEFINED_BEHAVIOR_IS_FATAL` configure option This is mainly intended for use on CI, as UBSan instrumentation results in a serious load and execution time penalty there. See the previous commit for more details. With this enabled, the size of LibWeb, built for x86-64 with Clang 17 as of 0b91d36a is reduced as follows: FILE SIZE VM SIZE -------------- -------------- +18% +2.99Mi [ = ] 0 .debug_info +14% +758Ki [ = ] 0 .debug_addr +2.6% +7.92Ki [ = ] 0 .debug_abbrev +129% +2.66Ki [ = ] 0 [Unmapped] -0.2% -208 -0.2% -208 .plt -0.2% -312 -0.2% -312 .rela.plt -0.1% -336 -0.1% -336 .dynsym -0.0% -647 -0.0% -513 [8 Others] -0.1% -1.14Ki -0.1% -1.14Ki .dynstr -20.1% -53.5Ki -20.1% -53.5Ki .eh_frame_hdr -7.2% -56.8Ki [ = ] 0 .debug_str_offsets -7.1% -156Ki [ = ] 0 .debug_str -15.0% -160Ki [ = ] 0 .symtab -63.6% -245Ki -63.6% -245Ki .relr.dyn -25.4% -357Ki -25.4% -357Ki .eh_frame -27.7% -1.09Mi [ = ] 0 .strtab -59.3% -10.0Mi [ = ] 0 .debug_rnglists -41.3% -11.0Mi [ = ] 0 .debug_line -70.0% -12.0Mi -70.0% -12.0Mi .rodata -65.2% -15.1Mi -65.2% -15.1Mi .data -53.0% -15.7Mi -53.0% -15.7Mi .text -41.7% -62.1Mi -57.7% -43.4Mi TOTAL
2023-08-12 13:39:22 +00:00
if (UNDEFINED_BEHAVIOR_IS_FATAL)
add_compile_options(-fno-sanitize-recover=undefined)
endif()
Meta: Enable vptr sanitation by default for Lagom UBSAN builds
2022-09-14 20:33:46 +00:00
set(LINKER_FLAGS "${LINKER_FLAGS} -fsanitize=undefined")
Lagom: Enable sanitizer builds with gcc Previously the CMake options for -fsanitize=address, thread and undefined were gated behind clang, which was unecessary. Only -fsanitize=fuzzer is clang-only.
2021-05-12 11:49:19 +00:00
endif()
Lagom: Add clang address/memory/undefined-behavior analyzer support Adding the ability to turn on Clang analyzer support in the Lagom build. Right now the following are working warning free on the LibJS test suite: -DENABLE_MEMORY_SANITIZER:BOOL=ON -DENABLE_ADDRESS_SANITIZER:BOOL=ON The following analyzer produces errors when running the LibJS test suite: -DENABLE_UNDEFINED_SANITIZER:BOOL=ON
2020-04-05 10:21:03 +00:00
Meta: Support enabling compile-time format string checking on Lagom
2023-07-05 19:01:56 +00:00
if (ENABLE_COMPILETIME_FORMAT_CHECK)
add_compile_definitions(ENABLE_COMPILETIME_FORMAT_CHECK)
endif()
Meta+Ladybird: Add some extra definitions for Haiku
2023-08-27 18:53:47 +00:00
if (HAIKU)
# Haiku needs some extra compile definitions to make important stuff in its headers available.
add_compile_definitions(_DEFAULT_SOURCE)
add_compile_definitions(_GNU_SOURCE)
add_compile_definitions(__USE_GNU)
endif()
CMake: Allow building fuzzing targets without libFuzzer or OSS-Fuzz
2022-03-21 10:36:41 +00:00
if (ENABLE_FUZZERS)
add_compile_options(-fno-omit-frame-pointer)
endif()
Lagom: Add option to build Ladybird as part of a Lagom build This means that Ladybird can be built with either Meta/Lagom or Ladybird as the top-level source directory. This setup is a bit awkward, but will preserve the packaging story for Ladybird until we come up with a more permanent solution.
2022-12-23 18:36:45 +00:00
if (ENABLE_LAGOM_LADYBIRD AND (ENABLE_FUZZERS OR ENABLE_COMPILER_EXPLORER_BUILD))
message(FATAL_ERROR
"Ladybird build not supported for Fuzzers or Compiler Explorer."
"Disable ENABLE_LAGOM_LADYBIRD and try again."
)
endif()
LibAudio: Create a playback class with a PulseAudio implementation This adds an abstract `Audio::PlaybackStream` class to allow cross- platform audio playback to be done in an opaque manner by applications in both Serenity and Lagom. Currently, the only supported audio API is PulseAudio, but a Serenity implementation should be added shortly as well.
2023-07-04 09:55:53 +00:00
CHECK_INCLUDE_FILE(pulse/pulseaudio.h HAVE_PULSEAUDIO)
Meta: Switch to a SuperBuild that splits host and target builds Replace the old logic where we would start with a host build, and swap all the CMake compiler and target variables underneath it to trick CMake into building for Serenity after we configured and built the Lagom code generators. The SuperBuild creates two ExternalProjects, one for Lagom and one for Serenity. The Serenity project depends on the install stage for the Lagom build. The SuperBuild also generates a CMakeToolchain file for the Serenity build to use that replaces the old toolchain file that was only used for Ports. To ensure that code generators are rebuilt when core libraries such as AK and LibCore are modified, developers will need to direct their manual `ninja` invocations to the SuperBuild's binary directory instead of the Serenity binary directory. This commit includes warning coalescing and option style cleanup for the affected CMakeLists in the Kernel, top level, and runtime support libraries. A large part of the cleanup is replacing USE_CLANG_TOOLCHAIN with the proper CMAKE_CXX_COMPILER_ID variable, which will no longer be confused by a host clang compiler.
2021-09-07 08:21:36 +00:00
if (CMAKE_CXX_COMPILER_ID MATCHES "Clang$")
Meta: Move more common flags to common_compile_options.cmake For the most part no behavior change, except that we now pass -Wno-implicit-const-int-float-conversion and -Wno-literal-suffix only to clang and gcc each in both lagom and serenity builds, while we previously passed them to both in lagom builds (and passed them to one each in serenity builds). The former is a clang flag, the latter a gcc flag, but since we also use -Wno-unknown-warning-option it doesn't really matter.
2023-04-17 23:50:53 +00:00
add_compile_options(-Wno-overloaded-virtual)
Lagom: Disable the unused-private-field warning on Lagom's clang builds With the compilation of LibWeb, there's now quite a few cases where this warning gets triggered. Rather than trying to fix them all right away, we simply disable the warning for now. This workaround was proposed by Andrew Kaster and BertalanD who promised to open an issue about it!
2022-04-30 18:04:30 +00:00
# FIXME: Re-enable this check when the warning stops triggering, or document why we can't stop it from triggering.
# For now, there is a lot of unused private fields in LibWeb that trigger this that could be removed.
# See issue #14137 for details
add_compile_options(-Wno-unused-private-field)
Lagom: Add clang address/memory/undefined-behavior analyzer support Adding the ability to turn on Clang analyzer support in the Lagom build. Right now the following are working warning free on the LibJS test suite: -DENABLE_MEMORY_SANITIZER:BOOL=ON -DENABLE_ADDRESS_SANITIZER:BOOL=ON The following analyzer produces errors when running the LibJS test suite: -DENABLE_UNDEFINED_SANITIZER:BOOL=ON
2020-04-05 10:21:03 +00:00
Meta: Rename Fuzzer flags to `ENABLE_FUZZERS_{LIBFUZZER,OSSFUZZ}`
2022-03-29 14:31:51 +00:00
if (ENABLE_FUZZERS_LIBFUZZER)
CMake: Allow building fuzzing targets without libFuzzer or OSS-Fuzz
2022-03-21 10:36:41 +00:00
add_compile_options(-fsanitize=fuzzer)
Lagom: Use -fsanitize=fuzzer, not -fsanitize=fuzzer-no-link Fuzzers don't link for me without this change.
2020-11-13 20:47:32 +00:00
set(LINKER_FLAGS "${LINKER_FLAGS} -fsanitize=fuzzer")
Lagom: Add fuzz testing for LibJS using libFuzzer (#1692) Note: clang only (see https://llvm.org/docs/LibFuzzer.html) - add FuzzJs which will run the LibJS parser on random javascript inputs - added a basic dictionary of javascript tokens To use fuzzer: CC=/usr/bin/clang CXX=/usr/bin/clang++ cmake -DENABLE_FUZZER_SANITIZER=1 .. Fuzzers/FuzzJs -dict=../Fuzzers/FuzzJs.dict
2020-04-08 08:40:02 +00:00
endif()
Meta: Switch to a SuperBuild that splits host and target builds Replace the old logic where we would start with a host build, and swap all the CMake compiler and target variables underneath it to trick CMake into building for Serenity after we configured and built the Lagom code generators. The SuperBuild creates two ExternalProjects, one for Lagom and one for Serenity. The Serenity project depends on the install stage for the Lagom build. The SuperBuild also generates a CMakeToolchain file for the Serenity build to use that replaces the old toolchain file that was only used for Ports. To ensure that code generators are rebuilt when core libraries such as AK and LibCore are modified, developers will need to direct their manual `ninja` invocations to the SuperBuild's binary directory instead of the Serenity binary directory. This commit includes warning coalescing and option style cleanup for the affected CMakeLists in the Kernel, top level, and runtime support libraries. A large part of the cleanup is replacing USE_CLANG_TOOLCHAIN with the proper CMAKE_CXX_COMPILER_ID variable, which will no longer be confused by a host clang compiler.
2021-09-07 08:21:36 +00:00
elseif (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
Meta: Rename Fuzzer flags to `ENABLE_FUZZERS_{LIBFUZZER,OSSFUZZ}`
2022-03-29 14:31:51 +00:00
if (ENABLE_FUZZERS_LIBFUZZER)
Lagom: Add two-stage build for Fuzzers to enable fuzzing generated code This allows us to fuzz the generated unicode and timezone database helpers, and to fuzz things like LibJS using Fuzzilli to get proper coverage of our unicode handling code. Update the Azure CI to use the new two-stage build as well, and cleanup some unused CMake options there.
2022-02-19 23:09:40 +00:00
message(FATAL_ERROR
"Fuzzer Sanitizer (-fsanitize=fuzzer) is only supported for Fuzzer targets with LLVM. "
CMake: Allow building fuzzing targets without libFuzzer or OSS-Fuzz
2022-03-21 10:36:41 +00:00
"Reconfigure CMake with -DCMAKE_C_COMPILER and -DCMAKE_CXX_COMPILER pointing to a clang-based toolchain "
"or build binaries without built-in fuzzing support by setting -DENABLE_FUZZERS instead."
Lagom: Add two-stage build for Fuzzers to enable fuzzing generated code This allows us to fuzz the generated unicode and timezone database helpers, and to fuzz things like LibJS using Fuzzilli to get proper coverage of our unicode handling code. Update the Azure CI to use the new two-stage build as well, and cleanup some unused CMake options there.
2022-02-19 23:09:40 +00:00
)
endif()
Lagom: Let's not hard-code the compiler. Add compiler-relevant flags though. I'm still getting the hang of this CMake thing.
2019-07-26 09:02:47 +00:00
endif()
Lagom: Import the beginnings of a "port" of Serenity libs for the outside. The C++ facilities of Serenity are getting pretty comfortable, and I'd like to take them with me to projects outside the system. Let's make it a bit easier to do that by bundling AK and LibCore (for now) into a portable library called "Lagom". :^)
2019-07-25 09:56:08 +00:00
Lagom: Enable sanitizer builds with gcc Previously the CMake options for -fsanitize=address, thread and undefined were gated behind clang, which was unecessary. Only -fsanitize=fuzzer is clang-only.
2021-05-12 11:49:19 +00:00
# These are here to support Fuzzili builds further down the directory stack
set(ORIGINAL_CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS}")
set(ORIGINAL_CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS}")
set(ORIGINAL_CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS}")
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${LINKER_FLAGS}")
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${LINKER_FLAGS}")
set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${LINKER_FLAGS}")
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
configure_file(../../AK/Debug.h.in AK/Debug.h @ONLY)
Meta: Add LibUnicode (and its tests) to Lagom This is primarily to allow using LibUnicode within LibJS and its REPL. Note: this seems to be the first time that a Lagom dependency requires generated source files. For this to work, some of Lagom's CMakeLists.txt commands needed to be re-organized to include the CMake files that fetch and parse UnicodeData.txt. The paths required to invoke the generator also differ depending on what is currently building (SerenityOS vs. Lagom as part of the Serenity build vs. a standalone Lagom build).
2021-07-25 19:15:47 +00:00
include_directories(../../)
include_directories(../../Userland/)
include_directories(../../Userland/Libraries/)
Meta: Build select Services in Lagom Add overrides for serenity_bin and serenity_lib to allow the actual CMakeLists.txt from Userland to be used to build as many services as possible without adding more clutter to Meta/Lagom/CMakeLists.txt
2022-07-04 16:08:01 +00:00
include_directories(../../Userland/Services)
Meta: Add LibUnicode (and its tests) to Lagom This is primarily to allow using LibUnicode within LibJS and its REPL. Note: this seems to be the first time that a Lagom dependency requires generated source files. For this to work, some of Lagom's CMakeLists.txt commands needed to be re-organized to include the CMake files that fetch and parse UnicodeData.txt. The paths required to invoke the generator also differ depending on what is currently building (SerenityOS vs. Lagom as part of the Serenity build vs. a standalone Lagom build).
2021-07-25 19:15:47 +00:00
include_directories(${CMAKE_BINARY_DIR})
include_directories(${CMAKE_CURRENT_BINARY_DIR})
CMake+Userland: Use CMakeLists from Userland to build Lagom Libraries Also do this for Shell. This greatly simplifies the CMakeLists in Lagom, replacing many glob patterns with a big list of libraries. There are still a few special libraries that need some help to conform to the pattern, like LibELF and LibWebView. It also lets us remove essentially all of the Serenity or Lagom binary directory detection logic from code generators, as now both projects directories enter the generator logic from the same place.
2022-10-14 02:14:36 +00:00
include_directories(${CMAKE_CURRENT_BINARY_DIR}/Userland/Libraries)
include_directories(${CMAKE_CURRENT_BINARY_DIR}/Userland/Services)
Meta: Add LibUnicode (and its tests) to Lagom This is primarily to allow using LibUnicode within LibJS and its REPL. Note: this seems to be the first time that a Lagom dependency requires generated source files. For this to work, some of Lagom's CMakeLists.txt commands needed to be re-organized to include the CMake files that fetch and parse UnicodeData.txt. The paths required to invoke the generator also differ depending on what is currently building (SerenityOS vs. Lagom as part of the Serenity build vs. a standalone Lagom build).
2021-07-25 19:15:47 +00:00
Lagom: Add proper install rules Create the proper export files to allow Lagom to be a well-behaved ExternalProject, based on the example project from the cmake-init project generator here: https://github.com/friendlyanon/cmake-init-shared-static
2021-07-28 00:22:12 +00:00
# install rules, think about moving to its own helper cmake file
Meta: Switch to a SuperBuild that splits host and target builds Replace the old logic where we would start with a host build, and swap all the CMake compiler and target variables underneath it to trick CMake into building for Serenity after we configured and built the Lagom code generators. The SuperBuild creates two ExternalProjects, one for Lagom and one for Serenity. The Serenity project depends on the install stage for the Lagom build. The SuperBuild also generates a CMakeToolchain file for the Serenity build to use that replaces the old toolchain file that was only used for Ports. To ensure that code generators are rebuilt when core libraries such as AK and LibCore are modified, developers will need to direct their manual `ninja` invocations to the SuperBuild's binary directory instead of the Serenity binary directory. This commit includes warning coalescing and option style cleanup for the affected CMakeLists in the Kernel, top level, and runtime support libraries. A large part of the cleanup is replacing USE_CLANG_TOOLCHAIN with the proper CMAKE_CXX_COMPILER_ID variable, which will no longer be confused by a host clang compiler.
2021-09-07 08:21:36 +00:00
include(CMakePackageConfigHelpers)
# find_package(<package>) call for consumers to find this project
Meta: Add Android cross-compile support to Lagom This is a start to properly letting us cross-compile Lagom where both the Tools and the BUILD_LAGOM=ON build are using Lagom CMakeLists. The initial cut allows an Android build to succeed, more or less. But there are issues with namespace clashes when using FetchContent with this approach.
2022-07-11 07:07:47 +00:00
set(package Lagom CACHE STRING "")
Meta: Switch to a SuperBuild that splits host and target builds Replace the old logic where we would start with a host build, and swap all the CMake compiler and target variables underneath it to trick CMake into building for Serenity after we configured and built the Lagom code generators. The SuperBuild creates two ExternalProjects, one for Lagom and one for Serenity. The Serenity project depends on the install stage for the Lagom build. The SuperBuild also generates a CMakeToolchain file for the Serenity build to use that replaces the old toolchain file that was only used for Ports. To ensure that code generators are rebuilt when core libraries such as AK and LibCore are modified, developers will need to direct their manual `ninja` invocations to the SuperBuild's binary directory instead of the Serenity binary directory. This commit includes warning coalescing and option style cleanup for the affected CMakeLists in the Kernel, top level, and runtime support libraries. A large part of the cleanup is replacing USE_CLANG_TOOLCHAIN with the proper CMAKE_CXX_COMPILER_ID variable, which will no longer be confused by a host clang compiler.
2021-09-07 08:21:36 +00:00
# Allow package maintainers to freely override the path for the configs
set(Lagom_INSTALL_CMAKEDIR "${CMAKE_INSTALL_DATADIR}/${package}"
CACHE PATH "CMake package config location relative to the install prefix")
mark_as_advanced(Lagom_INSTALL_CMAKEDIR)
install(
Meta: Update jakt build support for fully bootstrapped compiler Remove the Corrosion dependency, and use the now-builtin add_jakt_executable function from the Jakt install rules to build our example application. By using find_package(Jakt), we now have to set ENABLE_JAKT manually on both serenity and Lagom at the same time, so the preferred method to do this for now is: cmake -B Build/superbuild<arch><toolchain> \ -S Meta/CMake/Superbuild \ -DENABLE_JAKT=ON \ -DJAKT_SOURCE_DIR=/path/to/jakt Where omitting JAKT_SOURCE_DIR will still pull from the main branch of SerenityOS/jakt. This can be done after runing Meta/serenity.sh run.
2022-08-28 23:47:03 +00:00
FILES "${SERENITY_PROJECT_ROOT}/Meta/CMake/lagom-install-config.cmake"
Meta: Switch to a SuperBuild that splits host and target builds Replace the old logic where we would start with a host build, and swap all the CMake compiler and target variables underneath it to trick CMake into building for Serenity after we configured and built the Lagom code generators. The SuperBuild creates two ExternalProjects, one for Lagom and one for Serenity. The Serenity project depends on the install stage for the Lagom build. The SuperBuild also generates a CMakeToolchain file for the Serenity build to use that replaces the old toolchain file that was only used for Ports. To ensure that code generators are rebuilt when core libraries such as AK and LibCore are modified, developers will need to direct their manual `ninja` invocations to the SuperBuild's binary directory instead of the Serenity binary directory. This commit includes warning coalescing and option style cleanup for the affected CMakeLists in the Kernel, top level, and runtime support libraries. A large part of the cleanup is replacing USE_CLANG_TOOLCHAIN with the proper CMAKE_CXX_COMPILER_ID variable, which will no longer be confused by a host clang compiler.
2021-09-07 08:21:36 +00:00
DESTINATION "${Lagom_INSTALL_CMAKEDIR}"
Meta: Update jakt build support for fully bootstrapped compiler Remove the Corrosion dependency, and use the now-builtin add_jakt_executable function from the Jakt install rules to build our example application. By using find_package(Jakt), we now have to set ENABLE_JAKT manually on both serenity and Lagom at the same time, so the preferred method to do this for now is: cmake -B Build/superbuild<arch><toolchain> \ -S Meta/CMake/Superbuild \ -DENABLE_JAKT=ON \ -DJAKT_SOURCE_DIR=/path/to/jakt Where omitting JAKT_SOURCE_DIR will still pull from the main branch of SerenityOS/jakt. This can be done after runing Meta/serenity.sh run.
2022-08-28 23:47:03 +00:00
RENAME "${package}Config.cmake"
Meta: Switch to a SuperBuild that splits host and target builds Replace the old logic where we would start with a host build, and swap all the CMake compiler and target variables underneath it to trick CMake into building for Serenity after we configured and built the Lagom code generators. The SuperBuild creates two ExternalProjects, one for Lagom and one for Serenity. The Serenity project depends on the install stage for the Lagom build. The SuperBuild also generates a CMakeToolchain file for the Serenity build to use that replaces the old toolchain file that was only used for Ports. To ensure that code generators are rebuilt when core libraries such as AK and LibCore are modified, developers will need to direct their manual `ninja` invocations to the SuperBuild's binary directory instead of the Serenity binary directory. This commit includes warning coalescing and option style cleanup for the affected CMakeLists in the Kernel, top level, and runtime support libraries. A large part of the cleanup is replacing USE_CLANG_TOOLCHAIN with the proper CMAKE_CXX_COMPILER_ID variable, which will no longer be confused by a host clang compiler.
2021-09-07 08:21:36 +00:00
COMPONENT Lagom_Development
)
Lagom: Add proper install rules Create the proper export files to allow Lagom to be a well-behaved ExternalProject, based on the example project from the cmake-init project generator here: https://github.com/friendlyanon/cmake-init-shared-static
2021-07-28 00:22:12 +00:00
Meta: Switch to a SuperBuild that splits host and target builds Replace the old logic where we would start with a host build, and swap all the CMake compiler and target variables underneath it to trick CMake into building for Serenity after we configured and built the Lagom code generators. The SuperBuild creates two ExternalProjects, one for Lagom and one for Serenity. The Serenity project depends on the install stage for the Lagom build. The SuperBuild also generates a CMakeToolchain file for the Serenity build to use that replaces the old toolchain file that was only used for Ports. To ensure that code generators are rebuilt when core libraries such as AK and LibCore are modified, developers will need to direct their manual `ninja` invocations to the SuperBuild's binary directory instead of the Serenity binary directory. This commit includes warning coalescing and option style cleanup for the affected CMakeLists in the Kernel, top level, and runtime support libraries. A large part of the cleanup is replacing USE_CLANG_TOOLCHAIN with the proper CMAKE_CXX_COMPILER_ID variable, which will no longer be confused by a host clang compiler.
2021-09-07 08:21:36 +00:00
install(
EXPORT LagomTargets
NAMESPACE Lagom::
DESTINATION "${Lagom_INSTALL_CMAKEDIR}"
COMPONENT Lagom_Development
)
Lagom: Add proper install rules Create the proper export files to allow Lagom to be a well-behaved ExternalProject, based on the example project from the cmake-init project generator here: https://github.com/friendlyanon/cmake-init-shared-static
2021-07-28 00:22:12 +00:00
Lagom: Make lagom_lib take names prefixed with Lib This matches serenity_lib, and consolidates the logic to strip Lib from the front of the library name for the Lagom export name into one place at the top of lagom_lib.
2022-10-17 05:48:14 +00:00
function(lagom_lib target_name fs_name)
Lagom+LibCore: Build LibCore, AK, and LibMain with add_subdirectory By deferring to the CMakeLists in each of these libraries' directories, we can get rid of a lot of curious GLOB patterns and list removals in the Lagom CMakeLists.
2022-10-13 20:07:09 +00:00
cmake_parse_arguments(LAGOM_LIBRARY "" "LIBRARY_TYPE" "SOURCES;LIBS" ${ARGN})
Lagom: Make lagom_lib take names prefixed with Lib This matches serenity_lib, and consolidates the logic to strip Lib from the front of the library name for the Lagom export name into one place at the top of lagom_lib.
2022-10-17 05:48:14 +00:00
string(REPLACE "Lib" "" library ${target_name})
Lagom+LibCore: Build LibCore, AK, and LibMain with add_subdirectory By deferring to the CMakeLists in each of these libraries' directories, we can get rid of a lot of curious GLOB patterns and list removals in the Lagom CMakeLists.
2022-10-13 20:07:09 +00:00
if (NOT LAGOM_LIBRARY_LIBRARY_TYPE)
set(LAGOM_LIBRARY_LIBRARY_TYPE "")
Lagom: Link LibMain statically This matches how LibMain is used within Serenity. This commit makes it possible to build Lagom with LTO. Previously, `serenity_main` functions would be dead-stripped away, as the linker could prove that nothing from the executable ever called them.
2022-10-01 14:08:26 +00:00
endif()
Lagom+LibCore: Build LibCore, AK, and LibMain with add_subdirectory By deferring to the CMakeLists in each of these libraries' directories, we can get rid of a lot of curious GLOB patterns and list removals in the Lagom CMakeLists.
2022-10-13 20:07:09 +00:00
add_library(${target_name} ${LAGOM_LIBRARY_LIBRARY_TYPE} ${LAGOM_LIBRARY_SOURCES})
Lagom: Add two-stage build for Fuzzers to enable fuzzing generated code This allows us to fuzz the generated unicode and timezone database helpers, and to fuzz things like LibJS using Fuzzilli to get proper coverage of our unicode handling code. Update the Azure CI to use the new two-stage build as well, and cleanup some unused CMake options there.
2022-02-19 23:09:40 +00:00
# Don't make alias when we're going to import a previous build for Tools
# FIXME: Is there a better way to write this?
Meta: Add Android cross-compile support to Lagom This is a start to properly letting us cross-compile Lagom where both the Tools and the BUILD_LAGOM=ON build are using Lagom CMakeLists. The initial cut allows an Android build to succeed, more or less. But there are issues with namespace clashes when using FetchContent with this approach.
2022-07-11 07:07:47 +00:00
if (NOT ENABLE_FUZZERS AND NOT CMAKE_CROSSCOMPILING)
Lagom: Add two-stage build for Fuzzers to enable fuzzing generated code This allows us to fuzz the generated unicode and timezone database helpers, and to fuzz things like LibJS using Fuzzilli to get proper coverage of our unicode handling code. Update the Azure CI to use the new two-stage build as well, and cleanup some unused CMake options there.
2022-02-19 23:09:40 +00:00
# alias for parity with exports
add_library(Lagom::${library} ALIAS ${target_name})
endif()
Lagom: Add proper install rules Create the proper export files to allow Lagom to be a well-behaved ExternalProject, based on the example project from the cmake-init project generator here: https://github.com/friendlyanon/cmake-init-shared-static
2021-07-28 00:22:12 +00:00
set_target_properties(
${target_name} PROPERTIES
VERSION "${PROJECT_VERSION}"
SOVERSION "${PROJECT_VERSION_MAJOR}"
EXPORT_NAME ${library}
OUTPUT_NAME lagom-${fs_name}
)
Everywhere: Mark dependencies of most targets as PRIVATE Otherwise, we end up propagating those dependencies into targets that link against that library, which creates unnecessary link-time dependencies. Also included are changes to readd now missing dependencies to tools that actually need them.
2022-10-21 19:43:56 +00:00
target_link_libraries(${target_name} PRIVATE ${LAGOM_LIBRARY_LIBS})
Meta: Rename Lagom library target names from LagomFoo to LibFoo This matches the target names for the main serenity build, and will make simplifying the Lagom build much easier going forward. The LagomFoo name came from a time when we had both library builds in the same CMake generated project and needed to deconflict the names.
2022-07-04 14:48:19 +00:00
if (NOT ${target_name} STREQUAL "LibCore")
Everywhere: Mark dependencies of most targets as PRIVATE Otherwise, we end up propagating those dependencies into targets that link against that library, which creates unnecessary link-time dependencies. Also included are changes to readd now missing dependencies to tools that actually need them.
2022-10-21 19:43:56 +00:00
target_link_libraries(${target_name} PRIVATE LibCore)
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
endif()
Lagom: Include all generated installed files on library targets Do this with INSTALL_INTERFACE genex include directory rules. We should really standardize where the generated headers *actually* get installed to though.
2023-10-04 01:20:14 +00:00
# FIXME: Clean these up so that we don't need so many include dirs
target_include_directories(${target_name} INTERFACE
$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/Services>
$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/Userland/Libraries>
$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/Userland/Services>
)
Meta: Switch to a SuperBuild that splits host and target builds Replace the old logic where we would start with a host build, and swap all the CMake compiler and target variables underneath it to trick CMake into building for Serenity after we configured and built the Lagom code generators. The SuperBuild creates two ExternalProjects, one for Lagom and one for Serenity. The Serenity project depends on the install stage for the Lagom build. The SuperBuild also generates a CMakeToolchain file for the Serenity build to use that replaces the old toolchain file that was only used for Ports. To ensure that code generators are rebuilt when core libraries such as AK and LibCore are modified, developers will need to direct their manual `ninja` invocations to the SuperBuild's binary directory instead of the Serenity binary directory. This commit includes warning coalescing and option style cleanup for the affected CMakeLists in the Kernel, top level, and runtime support libraries. A large part of the cleanup is replacing USE_CLANG_TOOLCHAIN with the proper CMAKE_CXX_COMPILER_ID variable, which will no longer be confused by a host clang compiler.
2021-09-07 08:21:36 +00:00
install(
TARGETS ${target_name}
EXPORT LagomTargets
RUNTIME #
COMPONENT Lagom_Runtime
LIBRARY #
COMPONENT Lagom_Runtime
NAMELINK_COMPONENT Lagom_Development
ARCHIVE #
Lagom: Add proper install rules Create the proper export files to allow Lagom to be a well-behaved ExternalProject, based on the example project from the cmake-init project generator here: https://github.com/friendlyanon/cmake-init-shared-static
2021-07-28 00:22:12 +00:00
COMPONENT Lagom_Development
Meta: Switch to a SuperBuild that splits host and target builds Replace the old logic where we would start with a host build, and swap all the CMake compiler and target variables underneath it to trick CMake into building for Serenity after we configured and built the Lagom code generators. The SuperBuild creates two ExternalProjects, one for Lagom and one for Serenity. The Serenity project depends on the install stage for the Lagom build. The SuperBuild also generates a CMakeToolchain file for the Serenity build to use that replaces the old toolchain file that was only used for Ports. To ensure that code generators are rebuilt when core libraries such as AK and LibCore are modified, developers will need to direct their manual `ninja` invocations to the SuperBuild's binary directory instead of the Serenity binary directory. This commit includes warning coalescing and option style cleanup for the affected CMakeLists in the Kernel, top level, and runtime support libraries. A large part of the cleanup is replacing USE_CLANG_TOOLCHAIN with the proper CMAKE_CXX_COMPILER_ID variable, which will no longer be confused by a host clang compiler.
2021-09-07 08:21:36 +00:00
INCLUDES #
Lagom: Add proper install rules Create the proper export files to allow Lagom to be a well-behaved ExternalProject, based on the example project from the cmake-init project generator here: https://github.com/friendlyanon/cmake-init-shared-static
2021-07-28 00:22:12 +00:00
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
Meta: Switch to a SuperBuild that splits host and target builds Replace the old logic where we would start with a host build, and swap all the CMake compiler and target variables underneath it to trick CMake into building for Serenity after we configured and built the Lagom code generators. The SuperBuild creates two ExternalProjects, one for Lagom and one for Serenity. The Serenity project depends on the install stage for the Lagom build. The SuperBuild also generates a CMakeToolchain file for the Serenity build to use that replaces the old toolchain file that was only used for Ports. To ensure that code generators are rebuilt when core libraries such as AK and LibCore are modified, developers will need to direct their manual `ninja` invocations to the SuperBuild's binary directory instead of the Serenity binary directory. This commit includes warning coalescing and option style cleanup for the affected CMakeLists in the Kernel, top level, and runtime support libraries. A large part of the cleanup is replacing USE_CLANG_TOOLCHAIN with the proper CMAKE_CXX_COMPILER_ID variable, which will no longer be confused by a host clang compiler.
2021-09-07 08:21:36 +00:00
)
Lagom+LibCore: Build LibCore, AK, and LibMain with add_subdirectory By deferring to the CMakeLists in each of these libraries' directories, we can get rid of a lot of curious GLOB patterns and list removals in the Lagom CMakeLists.
2022-10-13 20:07:09 +00:00
# FIXME: Move this to serenity_install_headers
Meta: Switch to a SuperBuild that splits host and target builds Replace the old logic where we would start with a host build, and swap all the CMake compiler and target variables underneath it to trick CMake into building for Serenity after we configured and built the Lagom code generators. The SuperBuild creates two ExternalProjects, one for Lagom and one for Serenity. The Serenity project depends on the install stage for the Lagom build. The SuperBuild also generates a CMakeToolchain file for the Serenity build to use that replaces the old toolchain file that was only used for Ports. To ensure that code generators are rebuilt when core libraries such as AK and LibCore are modified, developers will need to direct their manual `ninja` invocations to the SuperBuild's binary directory instead of the Serenity binary directory. This commit includes warning coalescing and option style cleanup for the affected CMakeLists in the Kernel, top level, and runtime support libraries. A large part of the cleanup is replacing USE_CLANG_TOOLCHAIN with the proper CMAKE_CXX_COMPILER_ID variable, which will no longer be confused by a host clang compiler.
2021-09-07 08:21:36 +00:00
install(
DIRECTORY "${SERENITY_PROJECT_ROOT}/Userland/Libraries/Lib${library}"
COMPONENT Lagom_Development
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
FILES_MATCHING PATTERN "*.h"
)
Lagom+CMake: Propagate dependencies for generated custom targets We have logic for serenity_generated_sources which works well for source files that are specified in GENERATED_SOURCES prior to calling serenity_lib or serenity_bin. However, code generated with invoke_generator, and the LibWeb generators do not always follow the pattern of the IDL and GML files. For the LibWeb generators, we can just add_dependencies to LibWeb at the time we declare the generate_Foo custom target. However for LibLocale, LibTimeZone, and LibUnicode, we don't have the name of the target available, so export the name in a variable to set into GENERATED_SOURCES. To make this work for Lagom, we need to make sure that lagom_lib and serenity_bin in Lagom/CMakeLists.txt call serenity_generated_sources on the target. This enables the Xcode generator on macOS hosts, at least for Lagom.
2022-10-17 05:49:52 +00:00
serenity_generated_sources(${target_name})
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
endfunction()
function(lagom_test source)
Lagom: Add argument `WORKING_DIRECTORY` to `lagom_test(...)` So far the working directory was set in some cases using `set_tests_properties(...)`, but this requires to know which name is picked by `lagom_test(...)` when calling `add_test(...)`. In case of adding multiple test cases using a globbing pattern this would require to duplicate code to construct the test name from the file name.
2021-11-21 20:18:27 +00:00
cmake_parse_arguments(LAGOM_TEST "" "WORKING_DIRECTORY" "LIBS" ${ARGN})
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
get_filename_component(name ${source} NAME_WE)
Lagom: Remove unecessary _lagom suffix from test and executable names We needed this back when we included Lagom into the main serenity build, but it has been unecessary since the superbuild.
2022-10-14 02:34:34 +00:00
add_executable(${name} ${source})
Everywhere: Use `LibFileSystem` where trivial
2023-03-21 15:35:30 +00:00
target_link_libraries(${name} PRIVATE LibCore LibFileSystem LibTest LibTestMain ${LAGOM_TEST_LIBS})
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
add_test(
Meta: Set the Lagom test working directory for run-lagom-target When we call add_test() from each test's CMakeLists.txt, we specify the working directory to be that of the CMakeList.txt file itself. Create a property to store that directory and reference it when run-lagom-target is invoked by serenity.sh. Note that for non-test Lagom targets which do not set this property, the working directory will be Build/lagom (because the property will be the empty string, which CMake resolves relative to the current build path).
2023-02-01 13:36:15 +00:00
NAME ${name}
COMMAND ${name}
WORKING_DIRECTORY ${LAGOM_TEST_WORKING_DIRECTORY}
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
)
Meta: Set the Lagom test working directory for run-lagom-target When we call add_test() from each test's CMakeLists.txt, we specify the working directory to be that of the CMakeList.txt file itself. Create a property to store that directory and reference it when run-lagom-target is invoked by serenity.sh. Note that for non-test Lagom targets which do not set this property, the working directory will be Build/lagom (because the property will be the empty string, which CMake resolves relative to the current build path).
2023-02-01 13:36:15 +00:00
set_target_properties(${name} PROPERTIES LAGOM_WORKING_DIRECTORY "${LAGOM_TEST_WORKING_DIRECTORY}")
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
endfunction()
Meta: Use existing test-sources lists for Lagom instead of globbing ...mostly. This creates and uses an override for the `serenity_test()` function, so that Lagom can make use of the existing `Tests/LibFoo/CMakeLists.txt` files instead of having to GLOB for test source files and manually copy any data files. Some GLOBs remain but this is most of them. Co-authored-by: Andrew Kaster <akaster@serenityos.org>
2023-01-16 15:35:40 +00:00
function(serenity_test test_src sub_dir)
cmake_parse_arguments(PARSE_ARGV 2 SERENITY_TEST "MAIN_ALREADY_DEFINED" "CUSTOM_MAIN" "LIBS")
# FIXME: Pass MAIN_ALREADY_DEFINED and CUSTOM_MAIN to support tests that use them.
lagom_test(${test_src} LIBS ${SERENITY_TEST_LIBS} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
endfunction()
Meta: Build select Services in Lagom Add overrides for serenity_bin and serenity_lib to allow the actual CMakeLists.txt from Userland to be used to build as many services as possible without adding more clutter to Meta/Lagom/CMakeLists.txt
2022-07-04 16:08:01 +00:00
function(serenity_bin name)
add_executable(${name} ${SOURCES} ${GENERATED_SOURCES})
add_executable(Lagom::${name} ALIAS ${name})
install(
TARGETS ${target_name}
EXPORT LagomTargets
RUNTIME #
COMPONENT Lagom_Runtime
LIBRARY #
COMPONENT Lagom_Runtime
NAMELINK_COMPONENT Lagom_Development
ARCHIVE #
COMPONENT Lagom_Development
INCLUDES #
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
)
Lagom+CMake: Propagate dependencies for generated custom targets We have logic for serenity_generated_sources which works well for source files that are specified in GENERATED_SOURCES prior to calling serenity_lib or serenity_bin. However, code generated with invoke_generator, and the LibWeb generators do not always follow the pattern of the IDL and GML files. For the LibWeb generators, we can just add_dependencies to LibWeb at the time we declare the generate_Foo custom target. However for LibLocale, LibTimeZone, and LibUnicode, we don't have the name of the target available, so export the name in a variable to set into GENERATED_SOURCES. To make this work for Lagom, we need to make sure that lagom_lib and serenity_bin in Lagom/CMakeLists.txt call serenity_generated_sources on the target. This enables the Xcode generator on macOS hosts, at least for Lagom.
2022-10-17 05:49:52 +00:00
serenity_generated_sources(${name})
Meta: Build select Services in Lagom Add overrides for serenity_bin and serenity_lib to allow the actual CMakeLists.txt from Userland to be used to build as many services as possible without adding more clutter to Meta/Lagom/CMakeLists.txt
2022-07-04 16:08:01 +00:00
endfunction()
function(serenity_lib name fs_name)
Lagom: Make lagom_lib take names prefixed with Lib This matches serenity_lib, and consolidates the logic to strip Lib from the front of the library name for the Lagom export name into one place at the top of lagom_lib.
2022-10-17 05:48:14 +00:00
lagom_lib(${name} ${fs_name} SOURCES ${SOURCES} ${GENERATED_SOURCES})
Lagom+LibCore: Build LibCore, AK, and LibMain with add_subdirectory By deferring to the CMakeLists in each of these libraries' directories, we can get rid of a lot of curious GLOB patterns and list removals in the Lagom CMakeLists.
2022-10-13 20:07:09 +00:00
endfunction()
function(serenity_lib_static name fs_name)
Lagom: Make lagom_lib take names prefixed with Lib This matches serenity_lib, and consolidates the logic to strip Lib from the front of the library name for the Lagom export name into one place at the top of lagom_lib.
2022-10-17 05:48:14 +00:00
lagom_lib(${name} ${fs_name} LIBRARY_TYPE STATIC SOURCES ${SOURCES} ${GENERATED_SOURCES})
Lagom+LibCore: Build LibCore, AK, and LibMain with add_subdirectory By deferring to the CMakeLists in each of these libraries' directories, we can get rid of a lot of curious GLOB patterns and list removals in the Lagom CMakeLists.
2022-10-13 20:07:09 +00:00
endfunction()
function(serenity_install_headers dir)
Meta: Build select Services in Lagom Add overrides for serenity_bin and serenity_lib to allow the actual CMakeLists.txt from Userland to be used to build as many services as possible without adding more clutter to Meta/Lagom/CMakeLists.txt
2022-07-04 16:08:01 +00:00
endfunction()
Lagom+LibCore: Build LibCore, AK, and LibMain with add_subdirectory By deferring to the CMakeLists in each of these libraries' directories, we can get rid of a lot of curious GLOB patterns and list removals in the Lagom CMakeLists.
2022-10-13 20:07:09 +00:00
function(serenity_install_sources dir)
endfunction()
macro(add_serenity_subdirectory path)
add_subdirectory("${SERENITY_PROJECT_ROOT}/${path}" "${CMAKE_CURRENT_BINARY_DIR}/${path}")
endmacro()
Meta: Build select Services in Lagom Add overrides for serenity_bin and serenity_lib to allow the actual CMakeLists.txt from Userland to be used to build as many services as possible without adding more clutter to Meta/Lagom/CMakeLists.txt
2022-07-04 16:08:01 +00:00
add_custom_target(components ALL)
option(BUILD_EVERYTHING "Build all optional components" ON)
LibTimeZone+Meta: Add plumbing for an IANA Time Zone Database generator The IANA Time Zone Database contains data needed, at least, for various JavaScript objects. This adds plumbing for a parser and code generator for this data. The generated data will be made available by LibTimeZone, much like how UCD and CLDR data is available through LibUnicode.
2021-12-22 21:33:38 +00:00
if (NOT TARGET all_generated)
# Meta target to run all code-gen steps in the build.
add_custom_target(all_generated)
endif()
Lagom+LibCore: Build LibCore, AK, and LibMain with add_subdirectory By deferring to the CMakeLists in each of these libraries' directories, we can get rid of a lot of curious GLOB patterns and list removals in the Lagom CMakeLists.
2022-10-13 20:07:09 +00:00
# Create mostly empty targets for system libraries we don't need to build for Lagom
add_library(LibC INTERFACE)
add_library(LibCrypt INTERFACE)
Lagom: Link the system's LibSystem on SerenityOS
2022-10-23 22:05:33 +00:00
add_library(LibSystem INTERFACE)
Meta: Don't link LibCrypt to native libcrypt on Haiku
2023-08-27 18:58:53 +00:00
if (NOT APPLE AND NOT ANDROID AND NOT EMSCRIPTEN AND NOT ${CMAKE_SYSTEM_NAME} MATCHES "OpenBSD" AND NOT HAIKU)
Lagom+LibCore: Build LibCore, AK, and LibMain with add_subdirectory By deferring to the CMakeLists in each of these libraries' directories, we can get rid of a lot of curious GLOB patterns and list removals in the Lagom CMakeLists.
2022-10-13 20:07:09 +00:00
target_link_libraries(LibCrypt INTERFACE crypt) # LibCore::Account uses crypt() but it's not in libcrypt on macOS
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
endif()
Lagom: Link the system's LibSystem on SerenityOS
2022-10-23 22:05:33 +00:00
if (SERENITYOS)
# Serenity only allows syscalls from LibSystem, so if someone asks for that on Lagom,
# we need to pass that through to the system's LibSystem.
target_link_libraries(LibSystem INTERFACE system)
endif()
Lagom+LibCore: Build LibCore, AK, and LibMain with add_subdirectory By deferring to the CMakeLists in each of these libraries' directories, we can get rid of a lot of curious GLOB patterns and list removals in the Lagom CMakeLists.
2022-10-13 20:07:09 +00:00
add_library(NoCoverage INTERFACE)
# "install" these special targets to placate CMake
Lagom: Link the system's LibSystem on SerenityOS
2022-10-23 22:05:33 +00:00
install(TARGETS LibC LibCrypt LibSystem NoCoverage EXPORT LagomTargets)
Lagom+LibCore: Build LibCore, AK, and LibMain with add_subdirectory By deferring to the CMakeLists in each of these libraries' directories, we can get rid of a lot of curious GLOB patterns and list removals in the Lagom CMakeLists.
2022-10-13 20:07:09 +00:00
# AK/LibCore
# Note: AK is included in LibCore for the host build instead of LibC per the target build
add_serenity_subdirectory(AK)
add_serenity_subdirectory(Userland/Libraries/LibCore)
Everywhere: Mark dependencies of most targets as PRIVATE Otherwise, we end up propagating those dependencies into targets that link against that library, which creates unnecessary link-time dependencies. Also included are changes to readd now missing dependencies to tools that actually need them.
2022-10-21 19:43:56 +00:00
target_link_libraries(LibCore PRIVATE Threads::Threads)
LibCore: Add support for NetBSD in anon_create
2023-02-20 15:29:50 +00:00
if (${CMAKE_SYSTEM_NAME} MATCHES "NetBSD")
# NetBSD has its shm_open and shm_unlink functions in librt so we need to link that
target_link_libraries(LibCore PRIVATE librt.so)
endif()
Meta: Link to libnsl and libsocket on Solaris in Lagom CMakeLists
2023-02-25 18:10:57 +00:00
if (${CMAKE_SYSTEM_NAME} MATCHES "SunOS")
# Solaris has socket and networking related functions in two extra libraries
target_link_libraries(LibCore PRIVATE nsl socket)
endif()
AK: Add support for backtraces on Haiku
2023-09-18 18:34:14 +00:00
if (${CMAKE_SYSTEM_NAME} MATCHES "BSD$" OR HAIKU)
# BSD Platforms and Haiku have backtrace(3) in a separate library
AK: Always use our assertion failure method, and add backtrace to it On platforms that support it, enable using ``<execinfo.h>`` to get backtrace(3) to dump a backtrace on assertion failure. This should make debugging things like WebContent crashes in Lagom much easier.
2023-08-30 14:54:33 +00:00
target_link_libraries(LibCore PRIVATE execinfo)
endif()
Meta+Ladybird: Link to libnetwork on Haiku
2023-08-27 18:57:10 +00:00
if (HAIKU)
# Haiku has networking related functions in the network library
target_link_libraries(LibCore PRIVATE network)
endif()
Lagom+LibCore: Build LibCore, AK, and LibMain with add_subdirectory By deferring to the CMakeLists in each of these libraries' directories, we can get rid of a lot of curious GLOB patterns and list removals in the Lagom CMakeLists.
2022-10-13 20:07:09 +00:00
target_sources(LibCore PRIVATE ${AK_SOURCES})
Lagom: Import the beginnings of a "port" of Serenity libs for the outside. The C++ facilities of Serenity are getting pretty comfortable, and I'd like to take them with me to projects outside the system. Let's make it a bit easier to do that by bundling AK and LibCore (for now) into a portable library called "Lagom". :^)
2019-07-25 09:56:08 +00:00
Meta: Rename Lagom library target names from LagomFoo to LibFoo This matches the target names for the main serenity build, and will make simplifying the Lagom build much easier going forward. The LagomFoo name came from a time when we had both library builds in the same CMake generated project and needed to deconflict the names.
2022-07-04 14:48:19 +00:00
# LibMain
Lagom+LibCore: Build LibCore, AK, and LibMain with add_subdirectory By deferring to the CMakeLists in each of these libraries' directories, we can get rid of a lot of curious GLOB patterns and list removals in the Lagom CMakeLists.
2022-10-13 20:07:09 +00:00
add_serenity_subdirectory(Userland/Libraries/LibMain)
Meta: Define LagomMain outside of the BUILD_LAGOM branch This allows code generators to use LagomMain. Otherwise, during CI, they are built during the superbuild without BUILD_LAGOM=ON.
2021-11-23 17:34:31 +00:00
Everywhere: Use `LibFileSystem` where trivial
2023-03-21 15:35:30 +00:00
# LibFileSystem
# This is needed even if Lagom is not enabled because it is depended upon by code generators.
add_serenity_subdirectory(Userland/Libraries/LibFileSystem)
Meta: Rename Lagom library target names from LagomFoo to LibFoo This matches the target names for the main serenity build, and will make simplifying the Lagom build much easier going forward. The LagomFoo name came from a time when we had both library builds in the same CMake generated project and needed to deconflict the names.
2022-07-04 14:48:19 +00:00
# LibTimeZone
LibTimeZone+Meta: Add plumbing for an IANA Time Zone Database generator The IANA Time Zone Database contains data needed, at least, for various JavaScript objects. This adds plumbing for a parser and code generator for this data. The generated data will be made available by LibTimeZone, much like how UCD and CLDR data is available through LibUnicode.
2021-12-22 21:33:38 +00:00
# This is needed even if Lagom is not enabled because it is depended upon by code generators.
Meta: Use add_serenity_directory for LibTimeZone This lets us eliminate the "meta prefix" for the LibTimeZone generators.
2022-10-13 21:54:06 +00:00
add_serenity_subdirectory(Userland/Libraries/LibTimeZone)
# We need an install rule for LibTimeZone b/c it is a manual OBJECT library instead of serenity_lib
install(TARGETS LibTimeZone EXPORT LagomTargets)
LibTimeZone+Meta: Add plumbing for an IANA Time Zone Database generator The IANA Time Zone Database contains data needed, at least, for various JavaScript objects. This adds plumbing for a parser and code generator for this data. The generated data will be made available by LibTimeZone, much like how UCD and CLDR data is available through LibUnicode.
2021-12-22 21:33:38 +00:00
LibIDL+WrapperGenerator: Move IDL code into a library IDL function overload resolution requires knowing each IDL function's parameters and their types at runtime. The simplest way to do that is just to make the types the generator uses available to the runtime. Parsing has moved to LibIDL, but code generation has not, since that is very specific to WrapperGenerator.
2022-08-22 13:50:06 +00:00
# LibIDL
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 17:22:16 +00:00
# This is used by the BindingsGenerator so needs to always be built.
CMake+Userland: Use CMakeLists from Userland to build Lagom Libraries Also do this for Shell. This greatly simplifies the CMakeLists in Lagom, replacing many glob patterns with a big list of libraries. There are still a few special libraries that need some help to conform to the pattern, like LibELF and LibWebView. It also lets us remove essentially all of the Serenity or Lagom binary directory detection logic from code generators, as now both projects directories enter the generator logic from the same place.
2022-10-14 02:14:36 +00:00
add_serenity_subdirectory(Userland/Libraries/LibIDL)
LibIDL+WrapperGenerator: Move IDL code into a library IDL function overload resolution requires knowing each IDL function's parameters and their types at runtime. The simplest way to do that is just to make the types the generator uses available to the runtime. Parsing has moved to LibIDL, but code generation has not, since that is very specific to WrapperGenerator.
2022-08-22 13:50:06 +00:00
Meta+Userland: Allow generating C++ initializer code from GML This does the exact same thing as the runtime initializer, except it is faster and can catch some errors much earlier. The code generator includes these important features: - Automatic include generation where necessary - Special-casing for TabWidget and ScrollableContainerWidget - No use of DeprecatedString where possible
2023-08-11 13:16:51 +00:00
# LibGUI - only GML
# This is used by the GML compiler and therefore always needed.
set(LIBGUI_GML_SOURCES
GML/Lexer.cpp
GML/Parser.cpp
)
list(TRANSFORM LIBGUI_GML_SOURCES PREPEND "${SERENITY_PROJECT_ROOT}/Userland/Libraries/LibGUI/")
lagom_lib(LibGUI_GML gui_gml
SOURCES ${LIBGUI_GML_SOURCES}
)
Meta: Switch to a SuperBuild that splits host and target builds Replace the old logic where we would start with a host build, and swap all the CMake compiler and target variables underneath it to trick CMake into building for Serenity after we configured and built the Lagom code generators. The SuperBuild creates two ExternalProjects, one for Lagom and one for Serenity. The Serenity project depends on the install stage for the Lagom build. The SuperBuild also generates a CMakeToolchain file for the Serenity build to use that replaces the old toolchain file that was only used for Ports. To ensure that code generators are rebuilt when core libraries such as AK and LibCore are modified, developers will need to direct their manual `ninja` invocations to the SuperBuild's binary directory instead of the Serenity binary directory. This commit includes warning coalescing and option style cleanup for the affected CMakeLists in the Kernel, top level, and runtime support libraries. A large part of the cleanup is replacing USE_CLANG_TOOLCHAIN with the proper CMAKE_CXX_COMPILER_ID variable, which will no longer be confused by a host clang compiler.
2021-09-07 08:21:36 +00:00
# Manually install AK headers
install(
DIRECTORY "${SERENITY_PROJECT_ROOT}/AK"
COMPONENT Lagom_Development
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
FILES_MATCHING PATTERN "*.h"
)
CMake: Make sure to install generated sources and header files We weren't installing a lot of generated sources for the top level Lagom build or for LibWeb, making it impossible to use LibWeb from a find_package. ...And also Kernel/API/KeyCode.h, which is included by no less than 8 different files in Userland/Libraries. We also weren't installing any Ladybird header files.
2023-08-08 04:14:22 +00:00
install(FILES
${Lagom_BINARY_DIR}/AK/Debug.h
COMPONENT Lagom_Development
DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/AK"
)
Meta: Switch to a SuperBuild that splits host and target builds Replace the old logic where we would start with a host build, and swap all the CMake compiler and target variables underneath it to trick CMake into building for Serenity after we configured and built the Lagom code generators. The SuperBuild creates two ExternalProjects, one for Lagom and one for Serenity. The Serenity project depends on the install stage for the Lagom build. The SuperBuild also generates a CMakeToolchain file for the Serenity build to use that replaces the old toolchain file that was only used for Ports. To ensure that code generators are rebuilt when core libraries such as AK and LibCore are modified, developers will need to direct their manual `ninja` invocations to the SuperBuild's binary directory instead of the Serenity binary directory. This commit includes warning coalescing and option style cleanup for the affected CMakeLists in the Kernel, top level, and runtime support libraries. A large part of the cleanup is replacing USE_CLANG_TOOLCHAIN with the proper CMAKE_CXX_COMPILER_ID variable, which will no longer be confused by a host clang compiler.
2021-09-07 08:21:36 +00:00
Everywhere: Move all host tools into the Lagom/Tools subdirectory This allows us to remove all the add_subdirectory calls from the top level CMakeLists.txt that referred to targets linking LagomCore. Segregating the host tools and Serenity targets helps us get to a place where the main Serenity build can simply use a CMake toolchain file rather than swapping all the compiler/sysroot variables after building host libraries and tools.
2021-08-08 07:31:23 +00:00
# Code Generators and other host tools
CMake+Userland: Use CMakeLists from Userland to build Lagom Libraries Also do this for Shell. This greatly simplifies the CMakeLists in Lagom, replacing many glob patterns with a big list of libraries. There are still a few special libraries that need some help to conform to the pattern, like LibELF and LibWebView. It also lets us remove essentially all of the Serenity or Lagom binary directory detection logic from code generators, as now both projects directories enter the generator logic from the same place.
2022-10-14 02:14:36 +00:00
if (BUILD_LAGOM_TOOLS)
Everywhere: Move all host tools into the Lagom/Tools subdirectory This allows us to remove all the add_subdirectory calls from the top level CMakeLists.txt that referred to targets linking LagomCore. Segregating the host tools and Serenity targets helps us get to a place where the main Serenity build can simply use a CMake toolchain file rather than swapping all the compiler/sysroot variables after building host libraries and tools.
2021-08-08 07:31:23 +00:00
add_subdirectory(Tools)
endif()
Build: Switch to CMake :^) Closes https://github.com/SerenityOS/serenity/issues/2080
2020-05-06 15:40:06 +00:00
if (BUILD_LAGOM)
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
# Lagom Libraries
CMake+Userland: Use CMakeLists from Userland to build Lagom Libraries Also do this for Shell. This greatly simplifies the CMakeLists in Lagom, replacing many glob patterns with a big list of libraries. There are still a few special libraries that need some help to conform to the pattern, like LibELF and LibWebView. It also lets us remove essentially all of the Serenity or Lagom binary directory detection logic from code generators, as now both projects directories enter the generator logic from the same place.
2022-10-14 02:14:36 +00:00
set(lagom_standard_libraries
Archive
Audio
Compress
Crypto
Meta: Build LibCpp for Lagom
2023-06-17 19:11:06 +00:00
Cpp
CMake+Userland: Use CMakeLists from Userland to build Lagom Libraries Also do this for Shell. This greatly simplifies the CMakeLists in Lagom, replacing many glob patterns with a big list of libraries. There are still a few special libraries that need some help to conform to the pattern, like LibELF and LibWebView. It also lets us remove essentially all of the Serenity or Lagom binary directory detection logic from code generators, as now both projects directories enter the generator logic from the same place.
2022-10-14 02:14:36 +00:00
DNS
headless-browser: Print a diff when a test failure occurs This will make it a lot easier to understand what went wrong, especially when the failure occurs on CI but not at home. And of course, use LibDiff to generate the diff! :^)
2023-05-28 18:55:32 +00:00
Diff
CMake+Userland: Use CMakeLists from Userland to build Lagom Libraries Also do this for Shell. This greatly simplifies the CMakeLists in Lagom, replacing many glob patterns with a big list of libraries. There are still a few special libraries that need some help to conform to the pattern, like LibELF and LibWebView. It also lets us remove essentially all of the Serenity or Lagom binary directory detection logic from code generators, as now both projects directories enter the generator logic from the same place.
2022-10-14 02:14:36 +00:00
Gemini
Gfx
GL
LibGLSL: Add LibGLSL This adds a new library, LibGLSL for parsing and compiling GLSL programs to LibGPU IR. Currently the compiler consists only of stubs.
2022-08-28 17:23:30 +00:00
GLSL
CMake+Userland: Use CMakeLists from Userland to build Lagom Libraries Also do this for Shell. This greatly simplifies the CMakeLists in Lagom, replacing many glob patterns with a big list of libraries. There are still a few special libraries that need some help to conform to the pattern, like LibELF and LibWebView. It also lets us remove essentially all of the Serenity or Lagom binary directory detection logic from code generators, as now both projects directories enter the generator logic from the same place.
2022-10-14 02:14:36 +00:00
GPU
HTTP
IMAP
Lagom: Port LibImageDecoderClient to Lagom This library offers tools to communicate with an ImageDecoder server through IPC. There is currently no such executable for Lagom but that shouldn't take long :^)
2023-09-20 13:19:25 +00:00
ImageDecoderClient
CMake+Userland: Use CMakeLists from Userland to build Lagom Libraries Also do this for Shell. This greatly simplifies the CMakeLists in Lagom, replacing many glob patterns with a big list of libraries. There are still a few special libraries that need some help to conform to the pattern, like LibELF and LibWebView. It also lets us remove essentially all of the Serenity or Lagom binary directory detection logic from code generators, as now both projects directories enter the generator logic from the same place.
2022-10-14 02:14:36 +00:00
IPC
LibJIT+LibJS: Move JIT::Assembler into a new LibJIT library This will allow other parts of the system to generate machine code at runtime. :^)
2023-10-26 13:18:28 +00:00
JIT
CMake+Userland: Use CMakeLists from Userland to build Lagom Libraries Also do this for Shell. This greatly simplifies the CMakeLists in Lagom, replacing many glob patterns with a big list of libraries. There are still a few special libraries that need some help to conform to the pattern, like LibELF and LibWebView. It also lets us remove essentially all of the Serenity or Lagom binary directory detection logic from code generators, as now both projects directories enter the generator logic from the same place.
2022-10-14 02:14:36 +00:00
JS
Line
Locale
markdown-check: Allow generating a manpage link graph Using the cross-page links, we can generate a directed graph showing the topology of which pages refer to other pages. This is not just for fun: the links show how often a page is linked (since links are not deduplicated on purpose), which pairs of pages only have links in one direction (where a link in the other direction may be useful), which groups of closely-interlinked pages exist, and which pages have few or no links to other pages. The EXTRA_MARKDOWN_CHECK_ARGS argument to the check-markdown script can be used to inject the -g flag for generating the graph on all manpages.
2023-07-02 11:20:23 +00:00
Manual
CMake+Userland: Use CMakeLists from Userland to build Lagom Libraries Also do this for Shell. This greatly simplifies the CMakeLists in Lagom, replacing many glob patterns with a big list of libraries. There are still a few special libraries that need some help to conform to the pattern, like LibELF and LibWebView. It also lets us remove essentially all of the Serenity or Lagom binary directory detection logic from code generators, as now both projects directories enter the generator logic from the same place.
2022-10-14 02:14:36 +00:00
Markdown
PDF
Ladybird: Add RequestServer process to optionally replace Qt Networking LibTLS still can't access many parts of the web, so let's hide this behind a flag (with all the plumbing that entails). Hopefully this can encourage folks to improve LibTLS's algorithm support :^).
2023-08-01 20:39:19 +00:00
Protocol
CMake+Userland: Use CMakeLists from Userland to build Lagom Libraries Also do this for Shell. This greatly simplifies the CMakeLists in Lagom, replacing many glob patterns with a big list of libraries. There are still a few special libraries that need some help to conform to the pattern, like LibELF and LibWebView. It also lets us remove essentially all of the Serenity or Lagom binary directory detection logic from code generators, as now both projects directories enter the generator logic from the same place.
2022-10-14 02:14:36 +00:00
Regex
SoftGPU
SQL
Syntax
TextCodec
Threading
TLS
Unicode
Video
Wasm
WebSocket
XML
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
)
Meta: Fix ENABLE_LAGOM_LIBWEB CMake configuration
2023-08-12 16:01:28 +00:00
# These are needed for both LibWeb and LibProtocol.
Meta: Replace Lagom's LibWebView setup with LibWebView's CMakeLists.txt This lets us add new sources to LibWebView in a single location.
2023-08-30 11:27:45 +00:00
compile_ipc(${SERENITY_PROJECT_ROOT}/Userland/Services/RequestServer/RequestClient.ipc Userland/Services/RequestServer/RequestClientEndpoint.h)
compile_ipc(${SERENITY_PROJECT_ROOT}/Userland/Services/RequestServer/RequestServer.ipc Userland/Services/RequestServer/RequestServerEndpoint.h)
compile_ipc(${SERENITY_PROJECT_ROOT}/Userland/Services/WebSocket/WebSocketClient.ipc Userland/Services/WebSocket/WebSocketClientEndpoint.h)
compile_ipc(${SERENITY_PROJECT_ROOT}/Userland/Services/WebSocket/WebSocketServer.ipc Userland/Services/WebSocket/WebSocketServerEndpoint.h)
Meta: Fix ENABLE_LAGOM_LIBWEB CMake configuration
2023-08-12 16:01:28 +00:00
Meta: Add Lagom option to disable building LibWeb Compiling LibWeb for Lagom can add quite a bit of compile time. Add a CMake option to disable it locally.
2022-09-12 19:35:54 +00:00
if (ENABLE_LAGOM_LIBWEB)
Meta: Replace Lagom's LibWebView setup with LibWebView's CMakeLists.txt This lets us add new sources to LibWebView in a single location.
2023-08-30 11:27:45 +00:00
list(APPEND lagom_standard_libraries Web WebView)
LibWebView: Allow using native/user style sheets on Lagom Move the methods to set the native/user style sheets to the base ViewImplementation class. We must also generate the native style sheet explicitly for now, as LibWebView on Lagom isn't able to include the main LibWebView CMakeLists.txt file yet.
2023-08-26 17:34:59 +00:00
Meta: Replace Lagom's LibWebView setup with LibWebView's CMakeLists.txt This lets us add new sources to LibWebView in a single location.
2023-08-30 11:27:45 +00:00
compile_ipc(${SERENITY_PROJECT_ROOT}/Userland/Services/WebContent/WebContentServer.ipc Userland/Services/WebContent/WebContentServerEndpoint.h)
compile_ipc(${SERENITY_PROJECT_ROOT}/Userland/Services/WebContent/WebContentClient.ipc Userland/Services/WebContent/WebContentClientEndpoint.h)
compile_ipc(${SERENITY_PROJECT_ROOT}/Userland/Services/WebContent/WebDriverClient.ipc Userland/Services/WebContent/WebDriverClientEndpoint.h)
compile_ipc(${SERENITY_PROJECT_ROOT}/Userland/Services/WebContent/WebDriverServer.ipc Userland/Services/WebContent/WebDriverServerEndpoint.h)
Meta: Hide WebView behind ENABLE_LAGOM_LIBWEB CMake option If ENABLE_LAGOM_LIBWEB is OFF, this will fail to build.
2022-10-06 12:09:45 +00:00
endif()
Lagom: Build DOMTreeModel from LibWebView This will be used in Ladybird.
2022-09-25 10:10:28 +00:00
Lagom: Build LibELF on arm64 This seems to build fine now on Arm Macs.
2023-02-25 04:35:31 +00:00
if (NOT EMSCRIPTEN)
CMake+Userland: Use CMakeLists from Userland to build Lagom Libraries Also do this for Shell. This greatly simplifies the CMakeLists in Lagom, replacing many glob patterns with a big list of libraries. There are still a few special libraries that need some help to conform to the pattern, like LibELF and LibWebView. It also lets us remove essentially all of the Serenity or Lagom binary directory detection logic from code generators, as now both projects directories enter the generator logic from the same place.
2022-10-14 02:14:36 +00:00
# FIXME: Create a LIBELF_SOURCES macro similar to AK
file(GLOB LIBELF_SOURCES CONFIGURE_DEPENDS "../../Userland/Libraries/LibELF/*.cpp")
# There's no way we can reliably make the dynamic loading classes cross platform
list(FILTER LIBELF_SOURCES EXCLUDE REGEX ".*Dynamic.*.cpp$")
Lagom: Make lagom_lib take names prefixed with Lib This matches serenity_lib, and consolidates the logic to strip Lib from the front of the library name for the Lagom export name into one place at the top of lagom_lib.
2022-10-17 05:48:14 +00:00
lagom_lib(LibELF elf
CMake+Userland: Use CMakeLists from Userland to build Lagom Libraries Also do this for Shell. This greatly simplifies the CMakeLists in Lagom, replacing many glob patterns with a big list of libraries. There are still a few special libraries that need some help to conform to the pattern, like LibELF and LibWebView. It also lets us remove essentially all of the Serenity or Lagom binary directory detection logic from code generators, as now both projects directories enter the generator logic from the same place.
2022-10-14 02:14:36 +00:00
SOURCES ${LIBELF_SOURCES}
Lagom: Exclude libraries with X86 code when building for macOS on Arm The CMakeLists.txt for Lagom contains a few libraries and executables with X86-specific code. By excluding those libraries, Lagom builds for macOS on Arm as well. The places are marked FIXME to be removed when the libraries will build for Arm.
2022-01-17 23:54:36 +00:00
)
CMake+Userland: Use CMakeLists from Userland to build Lagom Libraries Also do this for Shell. This greatly simplifies the CMakeLists in Lagom, replacing many glob patterns with a big list of libraries. There are still a few special libraries that need some help to conform to the pattern, like LibELF and LibWebView. It also lets us remove essentially all of the Serenity or Lagom binary directory detection logic from code generators, as now both projects directories enter the generator logic from the same place.
2022-10-14 02:14:36 +00:00
list(APPEND lagom_standard_libraries X86)
Lagom: Exclude libraries with X86 code when building for macOS on Arm The CMakeLists.txt for Lagom contains a few libraries and executables with X86-specific code. By excluding those libraries, Lagom builds for macOS on Arm as well. The places are marked FIXME to be removed when the libraries will build for Arm.
2022-01-17 23:54:36 +00:00
endif()
Lagom: Add a Shell parser fuzzer
2020-11-29 12:49:13 +00:00
CMake+Userland: Use CMakeLists from Userland to build Lagom Libraries Also do this for Shell. This greatly simplifies the CMakeLists in Lagom, replacing many glob patterns with a big list of libraries. There are still a few special libraries that need some help to conform to the pattern, like LibELF and LibWebView. It also lets us remove essentially all of the Serenity or Lagom binary directory detection logic from code generators, as now both projects directories enter the generator logic from the same place.
2022-10-14 02:14:36 +00:00
foreach(lib IN LISTS lagom_standard_libraries)
add_serenity_subdirectory("Userland/Libraries/Lib${lib}")
endforeach()
# GUI
set(LIBGUI_SOURCES
GML/Lexer.cpp
GML/Parser.cpp
GML/SyntaxHighlighter.cpp
Icon.cpp
Model.cpp
ModelIndex.cpp
)
list(TRANSFORM LIBGUI_SOURCES PREPEND "${SERENITY_PROJECT_ROOT}/Userland/Libraries/LibGUI/")
Lagom: Make lagom_lib take names prefixed with Lib This matches serenity_lib, and consolidates the logic to strip Lib from the front of the library name for the Lagom export name into one place at the top of lagom_lib.
2022-10-17 05:48:14 +00:00
lagom_lib(LibGUI gui
CMake+Userland: Use CMakeLists from Userland to build Lagom Libraries Also do this for Shell. This greatly simplifies the CMakeLists in Lagom, replacing many glob patterns with a big list of libraries. There are still a few special libraries that need some help to conform to the pattern, like LibELF and LibWebView. It also lets us remove essentially all of the Serenity or Lagom binary directory detection logic from code generators, as now both projects directories enter the generator logic from the same place.
2022-10-14 02:14:36 +00:00
SOURCES ${LIBGUI_SOURCES}
LIBS LibGfx LibSyntax)
CMake: Make sure to install generated sources and header files We weren't installing a lot of generated sources for the top level Lagom build or for LibWeb, making it impossible to use LibWeb from a find_package. ...And also Kernel/API/KeyCode.h, which is included by no less than 8 different files in Userland/Libraries. We also weren't installing any Ladybird header files.
2023-08-08 04:14:22 +00:00
# FIXME: How about we don't include Kernel/API from random high-level libraries?
install(FILES ${SERENITY_PROJECT_ROOT}/Kernel/API/KeyCode.h DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/Kernel/API")
CMake+Userland: Use CMakeLists from Userland to build Lagom Libraries Also do this for Shell. This greatly simplifies the CMakeLists in Lagom, replacing many glob patterns with a big list of libraries. There are still a few special libraries that need some help to conform to the pattern, like LibELF and LibWebView. It also lets us remove essentially all of the Serenity or Lagom binary directory detection logic from code generators, as now both projects directories enter the generator logic from the same place.
2022-10-14 02:14:36 +00:00
# FIXME: LibLocaleData is an object lib in Lagom, because the weak symbol trick we use on serenity
# straight up isn't supposed to work per ELF rules
Everywhere: Mark dependencies of most targets as PRIVATE Otherwise, we end up propagating those dependencies into targets that link against that library, which creates unnecessary link-time dependencies. Also included are changes to readd now missing dependencies to tools that actually need them.
2022-10-21 19:43:56 +00:00
target_link_libraries(LibLocale PRIVATE LibTimeZone)
LibUnicode: Fix compilation when the UCD download is disabled
2022-12-13 15:07:23 +00:00
if (ENABLE_UNICODE_DATABASE_DOWNLOAD)
install(TARGETS LibLocaleData EXPORT LagomTargets)
endif()
CMake+Userland: Use CMakeLists from Userland to build Lagom Libraries Also do this for Shell. This greatly simplifies the CMakeLists in Lagom, replacing many glob patterns with a big list of libraries. There are still a few special libraries that need some help to conform to the pattern, like LibELF and LibWebView. It also lets us remove essentially all of the Serenity or Lagom binary directory detection logic from code generators, as now both projects directories enter the generator logic from the same place.
2022-10-14 02:14:36 +00:00
add_serenity_subdirectory(Userland/Shell)
LibXML: Add a fairly basic XML parser Currently this can parse XML and resolve external resources/references, and read a DTD (but not apply or verify its rules). That's good enough for _most_ XHTML documents as the HTML 5 spec enforces its own rules about document well-formedness, and does not make use of XML DTDs (aside from a list of predefined entities). An accompanying `xml` utility is provided that can read and dump XML documents, and can also run the XML conformance test suite.
2022-03-26 17:02:57 +00:00
CI+Lagom: Add Lagom Android CI for arm64-v8a on NDK 24 with API level 30 This will let us validate that we aren't breaking any library compile steps for arm64.
2022-07-20 06:13:12 +00:00
if (NOT ENABLE_FUZZERS AND NOT ENABLE_COMPILER_EXPLORER_BUILD AND NOT ANDROID)
Meta: Build select Services in Lagom Add overrides for serenity_bin and serenity_lib to allow the actual CMakeLists.txt from Userland to be used to build as many services as possible without adding more clutter to Meta/Lagom/CMakeLists.txt
2022-07-04 16:08:01 +00:00
# Lagom Services
CMake+Userland: Use CMakeLists from Userland to build Lagom Libraries Also do this for Shell. This greatly simplifies the CMakeLists in Lagom, replacing many glob patterns with a big list of libraries. There are still a few special libraries that need some help to conform to the pattern, like LibELF and LibWebView. It also lets us remove essentially all of the Serenity or Lagom binary directory detection logic from code generators, as now both projects directories enter the generator logic from the same place.
2022-10-14 02:14:36 +00:00
add_serenity_subdirectory(Userland/Services)
Meta: Build select Services in Lagom Add overrides for serenity_bin and serenity_lib to allow the actual CMakeLists.txt from Userland to be used to build as many services as possible without adding more clutter to Meta/Lagom/CMakeLists.txt
2022-07-04 16:08:01 +00:00
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
# Lagom Utilities
Meta: Build abench on Lagom This makes it possible to test audio decoding without much I/O overhead.
2023-05-18 08:45:57 +00:00
add_executable(abench ../../Userland/Utilities/abench.cpp)
target_link_libraries(abench LibCore LibMain LibFileSystem LibAudio)
Meta: Add aconv as a Lagom tool
2023-05-01 19:14:44 +00:00
add_executable(aconv ../../Userland/Utilities/aconv.cpp)
Lagom: Link `aconv` with LibFileSystem
2023-06-22 20:27:03 +00:00
target_link_libraries(aconv LibCore LibMain LibFileSystem LibAudio)
Meta: Add aconv as a Lagom tool
2023-05-01 19:14:44 +00:00
Everywhere: Add support for compilation under emscripten Co-Authored-By: Andrew Kaster <akaster@serenityos.org>
2022-11-20 03:23:14 +00:00
if (NOT EMSCRIPTEN)
add_executable(adjtime ../../Userland/Utilities/adjtime.cpp)
target_link_libraries(adjtime LibCore LibMain)
endif()
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
Meta: Add a CPack installation target for js(1) This adds a CPack configuration to generate a release package for js(1). Our current CMake requirement is 3.16, which doesn't have a great story for automatically installing a binary target's library dependencies. If we eventually require CMake 3.21 or above, we can remove the helper .cmake file added here in lieu of RUNTIME_DEPENDENCIES.
2022-02-08 16:11:03 +00:00
# FIXME: Excluding arm64 is a temporary hack to circumvent a build problem
Lagom: Exclude libraries with X86 code when building for macOS on Arm The CMakeLists.txt for Lagom contains a few libraries and executables with X86-specific code. By excluding those libraries, Lagom builds for macOS on Arm as well. The places are marked FIXME to be removed when the libraries will build for Arm.
2022-01-17 23:54:36 +00:00
# for Lagom on Apple M1
Everywhere: Add support for compilation under emscripten Co-Authored-By: Andrew Kaster <akaster@serenityos.org>
2022-11-20 03:23:14 +00:00
if (NOT CMAKE_SYSTEM_PROCESSOR MATCHES "arm64" AND NOT EMSCRIPTEN)
Lagom: Remove unecessary _lagom suffix from test and executable names We needed this back when we included Lagom into the main serenity build, but it has been unecessary since the superbuild.
2022-10-14 02:34:34 +00:00
add_executable(disasm ../../Userland/Utilities/disasm.cpp)
target_link_libraries(disasm LibCore LibELF LibX86 LibMain)
Lagom: Exclude libraries with X86 code when building for macOS on Arm The CMakeLists.txt for Lagom contains a few libraries and executables with X86-specific code. By excluding those libraries, Lagom builds for macOS on Arm as well. The places are marked FIXME to be removed when the libraries will build for Arm.
2022-01-17 23:54:36 +00:00
endif()
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
Lagom: Build `file` in lagom builds
2023-02-25 04:36:02 +00:00
if (NOT EMSCRIPTEN)
# LibELF is part of LibC in SerenityOS builds, but not in Lagom.
add_executable(file ../../Userland/Utilities/file.cpp)
Userland: Teach the file utility about zip files It now shows a short description with a file and directory counts, and the total content size uncompressed.
2023-07-03 14:45:59 +00:00
target_link_libraries(file LibAudio LibArchive LibCompress LibCore LibELF LibGfx LibIPC LibMain)
Lagom: Build `file` in lagom builds
2023-02-25 04:36:02 +00:00
endif()
Lagom: Remove unecessary _lagom suffix from test and executable names We needed this back when we included Lagom into the main serenity build, but it has been unecessary since the superbuild.
2022-10-14 02:34:34 +00:00
add_executable(gml-format ../../Userland/Utilities/gml-format.cpp)
target_link_libraries(gml-format LibCore LibGUI LibMain)
Lagom: Various fixes to make Lagom run on OSS-Fuzz (#4176)
2020-11-27 22:57:02 +00:00
Meta: Add "gunzip" and "gzip" to lagom build This makes it easy to compare the performance of Serenity's deflate implementation to the host system implementation. On my M1 Max MBP: % time gunzip -c \ /Users/thakis/Downloads/trace_bug.json.gz > /dev/null takes between 0.064s and 0.082s. % time Build/lagom/gunzip -c \ /Users/thakis/Downloads/trace_bug.json.gz > /dev/null on the other hand takes 4 seconds. (That .gz file is a 5.8M file -- the largest .gz file that happend to be in my Downloads folder.)
2023-03-25 17:04:22 +00:00
add_executable(gunzip ../../Userland/Utilities/gunzip.cpp)
target_link_libraries(gunzip LibCompress LibCore LibMain)
add_executable(gzip ../../Userland/Utilities/gzip.cpp)
target_link_libraries(gzip LibCompress LibCore LibMain)
Meta+CI: Disable Ladybird for fuzzer, compiler explorer and Android And move it after the declaration of headless-browser, since WebDriver depends on headless-browser.
2023-02-02 10:57:06 +00:00
if (ENABLE_LAGOM_LADYBIRD)
add_serenity_subdirectory(Ladybird)
endif()
MacPDF: Make buildable from CMake Use `Meta/serenity.sh build lagom MacPDF` to build, and either of `open Build/lagom/bin/MacPDF.app` or `Build/lagom/bin/MacPDF.app/Contents/MacOS/MacPDF` to run. Xcode used to insert a bunch of things to Info.plist. Now it can no longer do that, so manually put them there
2023-09-29 23:59:22 +00:00
if (APPLE)
add_serenity_subdirectory(Meta/Lagom/Contrib/MacPDF)
endif()
LibGfx: Start adding a utility for handling ICC color profiles For now, this dumps file version and device class. https://github.com/saucecontrol/compact-icc-profiles has good test inputs.
2022-12-26 13:21:54 +00:00
add_executable(icc ../../Userland/Utilities/icc.cpp)
target_link_libraries(icc LibCore LibGfx LibMain)
Userland: Add an `image` utility At the moment, all it can do is read all image formats that LibGfx can read and save to any image format that LibGfx can write (currently bmp, png, qoi). Currently, it drops all image metadata (including color profiles). Over time, this could learn tricks like keeping color profiles, converting an image to a different color profile, cropping out a part of an image, and so on.
2023-03-12 00:33:17 +00:00
add_executable(image ../../Userland/Utilities/image.cpp)
target_link_libraries(image LibCore LibGfx LibMain)
LibGfx: Add initial ISO BMFF parsing and a utility to print file info Currently, the `isobmff` utility will only print the media file type info from the FileTypeBox (major brand and compatible brands), as well as the names and sizes of top-level boxes.
2023-02-18 23:46:27 +00:00
add_executable(isobmff ../../Userland/Utilities/isobmff.cpp)
target_link_libraries(isobmff LibCore LibGfx LibMain)
Utilities: Add ttfdisasm for disassembling OpenType instructions This utility when given a .tff font provides options for disassembling: - The 'fpgm' table, this a program that's run once when the font is loaded. It's used to define instructions and functions used by used by other programs. - The 'prep' table, this is a general program that's run when ever the font size (or other properties) changes. - And the programs associated with any individual glyph. The disassembly is printed in a format that matches the examples from: https://learn.microsoft.com/en-us/typography/opentype/spec/tt_instructions I'm mainly adding this because I think it's neat to be able to look at these things, and think it'll be helpful for debugging an interpreter. With this you can see that all of the LiberationSerif-XXX.tff fonts in Serenity have these programs ready to go.
2023-01-08 23:03:39 +00:00
add_executable(ttfdisasm ../../Userland/Utilities/ttfdisasm.cpp)
target_link_libraries(ttfdisasm LibGfx LibMain)
Lagom: Remove unecessary _lagom suffix from test and executable names We needed this back when we included Lagom into the main serenity build, but it has been unecessary since the superbuild.
2022-10-14 02:34:34 +00:00
add_executable(js ../../Userland/Utilities/js.cpp)
Everywhere: Mark dependencies of most targets as PRIVATE Otherwise, we end up propagating those dependencies into targets that link against that library, which creates unnecessary link-time dependencies. Also included are changes to readd now missing dependencies to tools that actually need them.
2022-10-21 19:43:56 +00:00
target_link_libraries(js LibCrypto LibJS LibLine LibLocale LibMain LibTextCodec Threads::Threads)
Meta: Add a js REPL wasm target ...and build it only with emscripten.
2022-11-20 03:23:41 +00:00
if (EMSCRIPTEN)
add_executable(libjs Wasm/js_repl.cpp)
Meta: Explicitly link generated compile-time data into the WASM JS REPL Without this, we were in a weird state where LibTimeZone believed it had TZDB data, but that data wasn't actually available to it. This caused functions like JS::get_named_time_zone_offset_nanoseconds() to trip an assertion when entering "new Date();" into the REPL.
2022-12-05 21:49:32 +00:00
target_link_libraries(libjs LibJS LibLocale LibTimeZone LibUnicode)
Meta: Add a js REPL wasm target ...and build it only with emscripten.
2022-11-20 03:23:41 +00:00
target_link_options(libjs PRIVATE
-sEXPORTED_FUNCTIONS=_initialize_repl,_execute
-sEXPORTED_RUNTIME_METHODS=allocateUTF8
-sERROR_ON_UNDEFINED_SYMBOLS=0
-sENVIRONMENT=web)
endif()
Lagom: Various fixes to make Lagom run on OSS-Fuzz (#4176)
2020-11-27 22:57:02 +00:00
Lagom: Add targets for `lzcat`, `xzcat` and `tar`
2023-03-28 23:38:54 +00:00
add_executable(lzcat ../../Userland/Utilities/lzcat.cpp)
target_link_libraries(lzcat LibCompress LibCore LibMain)
Lagom: Remove unecessary _lagom suffix from test and executable names We needed this back when we included Lagom into the main serenity build, but it has been unecessary since the superbuild.
2022-10-14 02:34:34 +00:00
add_executable(markdown-check ../../Userland/Utilities/markdown-check.cpp)
markdown-check: Allow generating a manpage link graph Using the cross-page links, we can generate a directed graph showing the topology of which pages refer to other pages. This is not just for fun: the links show how often a page is linked (since links are not deduplicated on purpose), which pairs of pages only have links in one direction (where a link in the other direction may be useful), which groups of closely-interlinked pages exist, and which pages have few or no links to other pages. The EXTRA_MARKDOWN_CHECK_ARGS argument to the check-markdown script can be used to inject the -g flag for generating the graph on all manpages.
2023-07-02 11:20:23 +00:00
target_link_libraries(markdown-check LibFileSystem LibMarkdown LibMain LibManual)
markdown-checker: New tool that checks document links
2021-09-10 19:37:42 +00:00
Everywhere: Add support for compilation under emscripten Co-Authored-By: Andrew Kaster <akaster@serenityos.org>
2022-11-20 03:23:14 +00:00
if (NOT EMSCRIPTEN)
add_executable(ntpquery ../../Userland/Utilities/ntpquery.cpp)
target_link_libraries(ntpquery LibCore LibMain)
endif()
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
Utilities: Add a `pdf` utility This utility will learn tricks such as extracting images from PDFs and dumping tables from PDFs so that we can create code from specs. It also allows testing LibPDF things in lagom, and allows testing reading large amounts of PDFs using a shell script.
2023-06-27 00:42:10 +00:00
add_executable(pdf ../../Userland/Utilities/pdf.cpp)
pdf: Add function to render a page of a PDF to a bitmap Use like so: Build/lagom/bin/pdf --render foo.png --page=50 path/to.pdf
2023-07-11 17:25:36 +00:00
target_link_libraries(pdf LibCore LibGfx LibPDF LibMain)
Utilities: Add a `pdf` utility This utility will learn tricks such as extracting images from PDFs and dumping tables from PDFs so that we can create code from specs. It also allows testing LibPDF things in lagom, and allows testing reading large amounts of PDFs using a shell script.
2023-06-27 00:42:10 +00:00
sql: Support running the sql REPL on Lagom
2022-12-09 22:09:08 +00:00
add_executable(sql ../../Userland/Utilities/sql.cpp)
Everywhere: Use `LibFileSystem` where trivial
2023-03-21 15:35:30 +00:00
target_link_libraries(sql LibCore LibFileSystem LibIPC LibLine LibMain LibSQL)
sql: Support running the sql REPL on Lagom
2022-12-09 22:09:08 +00:00
Lagom: Add targets for `lzcat`, `xzcat` and `tar`
2023-03-28 23:38:54 +00:00
add_executable(tar ../../Userland/Utilities/tar.cpp)
target_link_libraries(tar LibArchive LibCompress LibCore LibFileSystem LibMain)
Lagom: Remove unecessary _lagom suffix from test and executable names We needed this back when we included Lagom into the main serenity build, but it has been unecessary since the superbuild.
2022-10-14 02:34:34 +00:00
add_executable(test262-runner ../../Tests/LibJS/test262-runner.cpp)
Everywhere: Use `LibFileSystem` where trivial
2023-03-21 15:35:30 +00:00
target_link_libraries(test262-runner LibJS LibCore LibFileSystem)
LibJS: Import the libjs-test262-runner from linusg/libjs-test262 For now this is a lagom only application as it is not compatible with serenity in its current state. The only change is that it is released under a different license with permission from all the authors.
2022-09-11 07:14:32 +00:00
Meta+test262-runner: Check for signature of __assert_fail in CMake Rather than trying to assume the only two C libraries on Linux are musl and glibc, this solution fixes musl builds by explicitly checking for the one C library function we are overwriting. That being said, we should find another solution to retrieving this error information from crashing tests. Possibly just overriding the SIGABRT handler would work. The full solution might require checking stderr as well as stdout in the test driver though.
2022-12-18 16:07:15 +00:00
if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
include(CheckCSourceCompiles)
# Check for musl's declaration of __assert_fail
check_c_source_compiles(
"
#include <assert.h>
__attribute__((__noreturn__)) void __assert_fail(char const* assertion, char const* file, int line, char const* function) {}
int main() {}
"
ASSERT_FAIL_HAS_INT
)
endif()
if (ASSERT_FAIL_HAS_INT OR EMSCRIPTEN)
target_compile_definitions(test262-runner PRIVATE ASSERT_FAIL_HAS_INT)
endif()
Lagom: Remove unecessary _lagom suffix from test and executable names We needed this back when we included Lagom into the main serenity build, but it has been unecessary since the superbuild.
2022-10-14 02:34:34 +00:00
add_executable(wasm ../../Userland/Utilities/wasm.cpp)
Everywhere: Use `LibFileSystem` where trivial
2023-03-21 15:35:30 +00:00
target_link_libraries(wasm LibCore LibFileSystem LibWasm LibLine LibMain LibJS)
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
Lagom: Remove unecessary _lagom suffix from test and executable names We needed this back when we included Lagom into the main serenity build, but it has been unecessary since the superbuild.
2022-10-14 02:34:34 +00:00
add_executable(xml ../../Userland/Utilities/xml.cpp)
xml: Prefer LibFileSystem over DeprecatedFile
2023-05-20 08:43:37 +00:00
target_link_libraries(xml LibCore LibFileSystem LibMain LibXML)
LibXML: Add a fairly basic XML parser Currently this can parse XML and resolve external resources/references, and read a DTD (but not apply or verify its rules). That's good enough for _most_ XHTML documents as the HTML 5 spec enforces its own rules about document well-formedness, and does not make use of XML DTDs (aside from a list of predefined entities). An accompanying `xml` utility is provided that can read and dump XML documents, and can also run the XML conformance test suite.
2022-03-26 17:02:57 +00:00
Lagom: Add targets for `lzcat`, `xzcat` and `tar`
2023-03-28 23:38:54 +00:00
add_executable(xzcat ../../Userland/Utilities/xzcat.cpp)
target_link_libraries(xzcat LibCompress LibCore LibMain)
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
enable_testing()
# LibTest
file(GLOB LIBTEST_SOURCES CONFIGURE_DEPENDS "../../Userland/Libraries/LibTest/*.cpp")
list(FILTER LIBTEST_SOURCES EXCLUDE REGEX ".*Main.cpp$")
add_library(
Meta: Rename Lagom library target names from LagomFoo to LibFoo This matches the target names for the main serenity build, and will make simplifying the Lagom build much easier going forward. The LagomFoo name came from a time when we had both library builds in the same CMake generated project and needed to deconflict the names.
2022-07-04 14:48:19 +00:00
LibTest
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
${LIBTEST_SOURCES}
)
Everywhere: Use `LibFileSystem` where trivial
2023-03-21 15:35:30 +00:00
target_link_libraries(LibTest PRIVATE LibCore LibFileSystem)
Meta: Rename Lagom library target names from LagomFoo to LibFoo This matches the target names for the main serenity build, and will make simplifying the Lagom build much easier going forward. The LagomFoo name came from a time when we had both library builds in the same CMake generated project and needed to deconflict the names.
2022-07-04 14:48:19 +00:00
set_target_properties(LibTest PROPERTIES OUTPUT_NAME lagom-test)
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
add_library(
Meta: Rename Lagom library target names from LagomFoo to LibFoo This matches the target names for the main serenity build, and will make simplifying the Lagom build much easier going forward. The LagomFoo name came from a time when we had both library builds in the same CMake generated project and needed to deconflict the names.
2022-07-04 14:48:19 +00:00
LibTestMain
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
OBJECT
"${SERENITY_PROJECT_ROOT}/Userland/Libraries/LibTest/TestMain.cpp"
)
# LibTest tests from Tests/
Meta: Use existing test-sources lists for Lagom instead of globbing ...mostly. This creates and uses an override for the `serenity_test()` function, so that Lagom can make use of the existing `Tests/LibFoo/CMakeLists.txt` files instead of having to GLOB for test source files and manually copy any data files. Some GLOBs remain but this is most of them. Co-authored-by: Andrew Kaster <akaster@serenityos.org>
2023-01-16 15:35:40 +00:00
set(TEST_DIRECTORIES
AK
LibCrypto
LibCompress
LibGL
Meta: Build and run Tests/LibGfx in lagom builds They can be run using Meta/serenity.sh test lagom TestFontHandling which will build _all_ test binaries and then run TestFontHandling. There's also Meta/serenity.sh run lagom TestFontHandling which will build just TestFontHandling and run it, but currently in a way that it doesn't pass. Finally, manually doing Meta/serenity.sh build lagom TestFontHandling followed by (cd Tests/LibGfx; ../../Build/lagom/Tests/LibGfx/TestFontHandling) will build and then run just that one test in a way that makes the test pass.
2023-01-31 19:00:43 +00:00
LibGfx
LibIMAP+Mail: Implement RFC2047 message header encoding This enables us to display email subject fields with non-ASCII characters in Mail :^)
2023-07-31 16:47:17 +00:00
LibIMAP
Meta: Use existing test-sources lists for Lagom instead of globbing ...mostly. This creates and uses an override for the `serenity_test()` function, so that Lagom can make use of the existing `Tests/LibFoo/CMakeLists.txt` files instead of having to GLOB for test source files and manually copy any data files. Some GLOBs remain but this is most of them. Co-authored-by: Andrew Kaster <akaster@serenityos.org>
2023-01-16 15:35:40 +00:00
LibLocale
LibMarkdown
LibPDF
LibSQL
LibTest: Add a suite of tests for the generators
2023-10-23 23:47:26 +00:00
LibTest
Meta: Use existing test-sources lists for Lagom instead of globbing ...mostly. This creates and uses an override for the `serenity_test()` function, so that Lagom can make use of the existing `Tests/LibFoo/CMakeLists.txt` files instead of having to GLOB for test source files and manually copy any data files. Some GLOBs remain but this is most of them. Co-authored-by: Andrew Kaster <akaster@serenityos.org>
2023-01-16 15:35:40 +00:00
LibTextCodec
LibTTF
LibTimeZone
LibUnicode
LibVideo
LibWebView: Protect URL highlighting against partially-typed URLs The current helpers assume that a valid URL is a full URL (i.e. contains the "://" separator between the scheme and domain). This isn't true, as "file:" alone is parsed as a valid URL. We must also avoid simply searching for the parsed public suffix in the original URL string. For example, "com" is a public suffix. If we search for that in the URL "com.com", we will think the public suffix starts at index 0.
2023-10-28 13:31:24 +00:00
LibWebView
Meta: Test LibXML on Lagom
2023-07-23 04:14:21 +00:00
LibXML
Meta: Use existing test-sources lists for Lagom instead of globbing ...mostly. This creates and uses an override for the `serenity_test()` function, so that Lagom can make use of the existing `Tests/LibFoo/CMakeLists.txt` files instead of having to GLOB for test source files and manually copy any data files. Some GLOBs remain but this is most of them. Co-authored-by: Andrew Kaster <akaster@serenityos.org>
2023-01-16 15:35:40 +00:00
)
if (ENABLE_LAGOM_LIBWEB)
list(APPEND TEST_DIRECTORIES LibWeb)
endif()
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
Meta: Use existing test-sources lists for Lagom instead of globbing ...mostly. This creates and uses an override for the `serenity_test()` function, so that Lagom can make use of the existing `Tests/LibFoo/CMakeLists.txt` files instead of having to GLOB for test source files and manually copy any data files. Some GLOBs remain but this is most of them. Co-authored-by: Andrew Kaster <akaster@serenityos.org>
2023-01-16 15:35:40 +00:00
foreach (dir IN LISTS TEST_DIRECTORIES)
add_serenity_subdirectory("Tests/${dir}")
Meta+Tests: Allow running FLAC spec tests The FLAC "spec tests", or rather the test suite by xiph that exercises weird FLAC features and edge cases, can be found at https://github.com/ietf-wg-cellar/flac-test-files and is a good challenge for our FLAC decoder to become more spec compliant. Running these tests is similar to LibWasm spec tests, you need to pass INCLUDE_FLAC_SPEC_TESTS to CMake. As of integrating these tests, 23 out of 63 fail. :yakplus:
2022-07-25 11:28:16 +00:00
endforeach()
Meta: Download cacert.pem at build time
2023-03-14 13:12:58 +00:00
# LibTLS needs a special working directory to find cacert.pem
lagom_test(../../Tests/LibTLS/TestTLSHandshake.cpp LibTLS LIBS LibTLS LibCrypto)
LibTLS: Don't attempt to read past EOF when parsing TBSCertificate This allows the decoder to fail gracefully when reading a partial or malformed TBSCertificate. We also now ensure that the certificate data is valid before making a copy of it.
2023-10-05 16:51:29 +00:00
lagom_test(../../Tests/LibTLS/TestTLSCertificateParser.cpp LibTLS LIBS LibTLS)
Meta: Download cacert.pem at build time
2023-03-14 13:12:58 +00:00
Meta: Specify a working directory for the FLAC spec test on Lagom The serenity_test function cannot set this up as it has no purpose on Serenity itself.
2023-03-14 18:52:16 +00:00
# The FLAC tests need a special working directory to find the test files
lagom_test(../../Tests/LibAudio/TestFLACSpec.cpp LIBS LibAudio WORKING_DIRECTORY "${FLAC_TEST_PATH}/..")
LibAudio: Add a test for creating and destructing a PlaybackStream This will ensure that we don't leak any memory while playing back audio. There is an expectation value in the test that is only set to true when PulseAudio is present for the moment. When any new implementation is added for other libraries/platforms, we should hopefully get a CI failure due to unexpected success in creating the `PlaybackStream`. To ensure that we clean up our PulseAudio connection whenever audio output is not needed, add `PulseAudioContext::weak_instance()` to allow us to check whether an instance exists without creating one.
2023-08-06 06:59:47 +00:00
lagom_test(../../Tests/LibAudio/TestPlaybackStream.cpp LIBS LibAudio)
if (HAVE_PULSEAUDIO)
target_compile_definitions(TestPlaybackStream PRIVATE HAVE_PULSEAUDIO=1)
endif()
Meta: Rename Lagom library target names from LagomFoo to LibFoo This matches the target names for the main serenity build, and will make simplifying the Lagom build much easier going forward. The LagomFoo name came from a time when we had both library builds in the same CMake generated project and needed to deconflict the names.
2022-07-04 14:48:19 +00:00
# LibCore
LibCore: Implement FileWatcher for macOS The macOS FileWatcher depends on macOS dispatch queues, which run on a different thread than the Core::EventLoop. This implementation handles filesystem events on its dispatch queue, then forwards the event back to the main Core::EventLoop for notifying the FileWatcher owner.
2023-01-18 19:03:14 +00:00
if ((LINUX OR APPLE) AND NOT EMSCRIPTEN)
LibCore: Implement FileWatcher for Linux This implements FileWatcher using inotify filesystem events. Serenity's InodeWatcher is remarkably similar to inotify, so this is almost an identical implementation. The existing TestLibCoreFileWatcher test is added to Lagom (currently just for Linux). This does not implement BlockingFileWatcher as that is currently not used anywhere but on Serenity.
2023-01-17 19:43:36 +00:00
lagom_test(../../Tests/LibCore/TestLibCoreFileWatcher.cpp)
LibCore: Add a class for thread-safe promises Since the existing Promise class is designed with deferred tasks on the main thread only, we need a new class that will ensure we can handle promises that are resolved/rejected off the main thread. This new class ensures that the callbacks are only called on the same thread that the promise is fulfilled from. If the callbacks are not set before the thread tries to fulfill the promise, it will spin until they are so that they will run on that thread.
2023-07-12 01:48:56 +00:00
lagom_test(../../Tests/LibCore/TestLibCorePromise.cpp LIBS LibThreading)
LibCore: Implement FileWatcher for Linux This implements FileWatcher using inotify filesystem events. Serenity's InodeWatcher is remarkably similar to inotify, so this is almost an identical implementation. The existing TestLibCoreFileWatcher test is added to Lagom (currently just for Linux). This does not implement BlockingFileWatcher as that is currently not used anywhere but on Serenity.
2023-01-17 19:43:36 +00:00
endif()
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
# RegexLibC test POSIX <regex.h> and contains many Serenity extensions
Meta: Use existing test-sources lists for Lagom instead of globbing ...mostly. This creates and uses an override for the `serenity_test()` function, so that Lagom can make use of the existing `Tests/LibFoo/CMakeLists.txt` files instead of having to GLOB for test source files and manually copy any data files. Some GLOBs remain but this is most of them. Co-authored-by: Andrew Kaster <akaster@serenityos.org>
2023-01-16 15:35:40 +00:00
# It is therefore not reasonable to run it on Lagom, and we only run the Regex test
lagom_test(../../Tests/LibRegex/Regex.cpp LIBS LibRegex WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/../../Tests/LibRegex)
LibWeb: Run tests in lagom if ENABLE_LAGOM_LIBWEB is set
2023-01-09 21:29:39 +00:00
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
# JavaScriptTestRunner + LibTest tests
# test-js
Lagom: Remove unecessary _lagom suffix from test and executable names We needed this back when we included Lagom into the main serenity build, but it has been unecessary since the superbuild.
2022-10-14 02:34:34 +00:00
add_executable(test-js
LibJS+LibTest: Move out the test-js test runner into LibTest
2021-05-18 14:15:12 +00:00
../../Tests/LibJS/test-js.cpp
../../Userland/Libraries/LibTest/JavaScriptTestRunnerMain.cpp)
Everywhere: Use `LibFileSystem` where trivial
2023-03-21 15:35:30 +00:00
target_link_libraries(test-js LibCore LibFileSystem LibTest LibJS)
Meta: Run test-js and test-compress as CTest executables Reduces the number of steps in the Actions workflow this way :^)
2021-02-28 22:06:42 +00:00
add_test(
NAME JS
Lagom: Remove unecessary _lagom suffix from test and executable names We needed this back when we included Lagom into the main serenity build, but it has been unecessary since the superbuild.
2022-10-14 02:34:34 +00:00
COMMAND test-js --show-progress=false
Shell: Build as part of Lagom as well Bringing the Serenity Shell to your very own host system :^)
2020-06-25 12:45:23 +00:00
)
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
set_tests_properties(JS PROPERTIES ENVIRONMENT SERENITY_SOURCE_DIR=${SERENITY_PROJECT_ROOT})
Lagom: Various fixes to make Lagom run on OSS-Fuzz (#4176)
2020-11-27 22:57:02 +00:00
Tests+LibJS: Add very simple bytecode LibJS tests These tests are not meant as a replacement to test-js with the -b option but are meant to test simple cases until that works. Before this it was very easy to accidentally break bytecode since no tests were run in bytecode mode. This hopefully makes it easier to spot such regressions :^).
2022-01-22 13:27:53 +00:00
# Extra tests from Tests/LibJS
Meta: Rename Lagom library target names from LagomFoo to LibFoo This matches the target names for the main serenity build, and will make simplifying the Lagom build much easier going forward. The LagomFoo name came from a time when we had both library builds in the same CMake generated project and needed to deconflict the names.
2022-07-04 14:48:19 +00:00
lagom_test(../../Tests/LibJS/test-invalid-unicode-js.cpp LIBS LibJS)
LibJS: Allow negative pointers in Value Also ensure that all a nullptr input gives null object and you don't accidentally dereference a nullptr.
2022-09-06 23:14:23 +00:00
lagom_test(../../Tests/LibJS/test-value-js.cpp LIBS LibJS)
LibJS: Add a specific test for invalid unicode characters in the lexer Also fixes that it tried to make substrings past the end of the source if we overran the source length.
2021-10-03 11:10:35 +00:00
LibTest+Spreadsheet: Add some basic spreadsheet runtime behaviour tests As there's a somewhat active development going on, let's keep the expected behaviour under tests to make sure nothing blows up :^)
2022-02-22 04:19:04 +00:00
# Spreadsheet
Lagom: Remove unecessary _lagom suffix from test and executable names We needed this back when we included Lagom into the main serenity build, but it has been unecessary since the superbuild.
2022-10-14 02:34:34 +00:00
add_executable(test-spreadsheet
LibTest+Spreadsheet: Add some basic spreadsheet runtime behaviour tests As there's a somewhat active development going on, let's keep the expected behaviour under tests to make sure nothing blows up :^)
2022-02-22 04:19:04 +00:00
../../Tests/Spreadsheet/test-spreadsheet.cpp
../../Userland/Libraries/LibTest/JavaScriptTestRunnerMain.cpp)
Everywhere: Use `LibFileSystem` where trivial
2023-03-21 15:35:30 +00:00
target_link_libraries(test-spreadsheet LibCore LibFileSystem LibTest LibJS)
LibTest+Spreadsheet: Add some basic spreadsheet runtime behaviour tests As there's a somewhat active development going on, let's keep the expected behaviour under tests to make sure nothing blows up :^)
2022-02-22 04:19:04 +00:00
add_test(
NAME Spreadsheet
Lagom: Remove unecessary _lagom suffix from test and executable names We needed this back when we included Lagom into the main serenity build, but it has been unecessary since the superbuild.
2022-10-14 02:34:34 +00:00
COMMAND test-spreadsheet --show-progress=false
LibTest+Spreadsheet: Add some basic spreadsheet runtime behaviour tests As there's a somewhat active development going on, let's keep the expected behaviour under tests to make sure nothing blows up :^)
2022-02-22 04:19:04 +00:00
)
set_tests_properties(Spreadsheet PROPERTIES ENVIRONMENT SERENITY_SOURCE_DIR=${SERENITY_PROJECT_ROOT})
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
# test-wasm
Lagom: Remove unecessary _lagom suffix from test and executable names We needed this back when we included Lagom into the main serenity build, but it has been unecessary since the superbuild.
2022-10-14 02:34:34 +00:00
add_executable(test-wasm
LibWasm+Meta: Add test-wasm and optionally test the conformance tests This only tests "can it be parsed", but the goal of this commit is to provide a test framework that can be built upon :) The conformance tests are downloaded, compiled* and installed only if the INCLUDE_WASM_SPEC_TESTS cmake option is enabled. (*) Since we do not yet have a wast parser, the compilation is delegated to an external tool from binaryen, `wasm-as`, which is required for the test suite download/install to succeed. This *does* run the tests in CI, but it currently does not include the spec conformance tests.
2021-05-04 03:06:59 +00:00
../../Tests/LibWasm/test-wasm.cpp
../../Userland/Libraries/LibTest/JavaScriptTestRunnerMain.cpp)
LibWasm+LibWeb: Parse and validate all Wasm SIMD instructions
2023-06-12 09:34:22 +00:00
target_link_libraries(test-wasm LibCore LibFileSystem LibTest LibWasm LibJS LibCrypto)
LibWasm+Meta: Add test-wasm and optionally test the conformance tests This only tests "can it be parsed", but the goal of this commit is to provide a test framework that can be built upon :) The conformance tests are downloaded, compiled* and installed only if the INCLUDE_WASM_SPEC_TESTS cmake option is enabled. (*) Since we do not yet have a wast parser, the compilation is delegated to an external tool from binaryen, `wasm-as`, which is required for the test suite download/install to succeed. This *does* run the tests in CI, but it currently does not include the spec conformance tests.
2021-05-04 03:06:59 +00:00
add_test(
NAME WasmParser
CI+Lagom: Use the same options for running test-wasm in ctest and CI Make sure that we set SERENITY_SOURCE_DIR in ctest, and make sure to pass the test root to the CI job. More overhaul of test-js 'test root' finding is needed however.
2023-02-23 00:31:35 +00:00
COMMAND test-wasm --show-progress=false ${CMAKE_CURRENT_BINARY_DIR}/Userland/Libraries/LibWasm/Tests
)
set_tests_properties(WasmParser PROPERTIES
SKIP_RETURN_CODE 1
ENVIRONMENT SERENITY_SOURCE_DIR=${SERENITY_PROJECT_ROOT}
LibWasm+Meta: Add test-wasm and optionally test the conformance tests This only tests "can it be parsed", but the goal of this commit is to provide a test framework that can be built upon :) The conformance tests are downloaded, compiled* and installed only if the INCLUDE_WASM_SPEC_TESTS cmake option is enabled. (*) Since we do not yet have a wast parser, the compilation is delegated to an external tool from binaryen, `wasm-as`, which is required for the test suite download/install to succeed. This *does* run the tests in CI, but it currently does not include the spec conformance tests.
2021-05-04 03:06:59 +00:00
)
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
# Tests that are not LibTest based
# Shell
file(GLOB SHELL_TESTS CONFIGURE_DEPENDS "../../Userland/Shell/Tests/*.sh")
Lagom: Various fixes to make Lagom run on OSS-Fuzz (#4176)
2020-11-27 22:57:02 +00:00
foreach(TEST_PATH ${SHELL_TESTS})
get_filename_component(TEST_NAME ${TEST_PATH} NAME_WE)
add_test(
NAME "Shell-${TEST_NAME}"
CMake+Userland: Use CMakeLists from Userland to build Lagom Libraries Also do this for Shell. This greatly simplifies the CMakeLists in Lagom, replacing many glob patterns with a big list of libraries. There are still a few special libraries that need some help to conform to the pattern, like LibELF and LibWebView. It also lets us remove essentially all of the Serenity or Lagom binary directory detection logic from code generators, as now both projects directories enter the generator logic from the same place.
2022-10-14 02:14:36 +00:00
COMMAND Shell --skip-shellrc "${TEST_PATH}"
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
WORKING_DIRECTORY ${SERENITY_PROJECT_ROOT}/Userland/Shell/Tests
Lagom: Various fixes to make Lagom run on OSS-Fuzz (#4176)
2020-11-27 22:57:02 +00:00
)
Shell: Make tests use PASS/FAIL instead of exit codes There's no guarantee that the last executed command will have a zero exit code, and so the shell exit code may or may not be zero, even if all the tests pass. Also changes the `test || echo fail && exit` to `if not test { echo fail && exit }`, since that's nicer-looking.
2021-01-18 06:38:30 +00:00
set_tests_properties("Shell-${TEST_NAME}" PROPERTIES
TIMEOUT 10
FAIL_REGULAR_EXPRESSION "FAIL"
Lagom: CMakeLists.txt housekeeping - Remove unused LIBM_SOURCES - Some cosmetic and whitespace changes
2021-02-27 11:36:11 +00:00
PASS_REGULAR_EXPRESSION "PASS"
)
Lagom: Various fixes to make Lagom run on OSS-Fuzz (#4176)
2020-11-27 22:57:02 +00:00
endforeach()
Meta: Add a CPack installation target for js(1) This adds a CPack configuration to generate a release package for js(1). Our current CMake requirement is 3.16, which doesn't have a great story for automatically installing a binary target's library dependencies. If we eventually require CMake 3.21 or above, we can remove the helper .cmake file added here in lieu of RUNTIME_DEPENDENCIES.
2022-02-08 16:11:03 +00:00
# FIXME: When we are using CMake >= 3.21, the library installations can be replaced with RUNTIME_DEPENDENCIES.
# https://cmake.org/cmake/help/latest/command/install.html
include(get_linked_lagom_libraries.cmake)
Lagom: Remove unecessary _lagom suffix from test and executable names We needed this back when we included Lagom into the main serenity build, but it has been unecessary since the superbuild.
2022-10-14 02:34:34 +00:00
get_linked_lagom_libraries(js js_libraries)
Meta: Add a CPack installation target for js(1) This adds a CPack configuration to generate a release package for js(1). Our current CMake requirement is 3.16, which doesn't have a great story for automatically installing a binary target's library dependencies. If we eventually require CMake 3.21 or above, we can remove the helper .cmake file added here in lieu of RUNTIME_DEPENDENCIES.
2022-02-08 16:11:03 +00:00
Lagom: Remove unecessary _lagom suffix from test and executable names We needed this back when we included Lagom into the main serenity build, but it has been unecessary since the superbuild.
2022-10-14 02:34:34 +00:00
install(TARGETS js ${js_libraries} COMPONENT js)
Meta: Add a CPack installation target for js(1) This adds a CPack configuration to generate a release package for js(1). Our current CMake requirement is 3.16, which doesn't have a great story for automatically installing a binary target's library dependencies. If we eventually require CMake 3.21 or above, we can remove the helper .cmake file added here in lieu of RUNTIME_DEPENDENCIES.
2022-02-08 16:11:03 +00:00
set(CPACK_GENERATOR "TGZ")
set(CPACK_STRIP_FILES TRUE)
set(CPACK_ARCHIVE_COMPONENT_INSTALL ON)
set(CPACK_COMPONENTS_ALL js)
Meta+CI: Add CI job specifically for bundling serenity-js artifacts These are used by esvu, and it is sad that we don't have macOS binaries availble for consumption by esvu users. Add a matrix job to handle this separately from the test262 results.
2022-12-01 09:08:12 +00:00
if (APPLE)
if("arm64" IN_LIST CMAKE_OSX_ARCHITECTURES AND "x86_64" IN_LIST CMAKE_OSX_ARCHITECTURES)
set(CPACK_SYSTEM_NAME "macOS-universal2")
Meta: Explicitly link generated compile-time data into the WASM JS REPL Without this, we were in a weird state where LibTimeZone believed it had TZDB data, but that data wasn't actually available to it. This caused functions like JS::get_named_time_zone_offset_nanoseconds() to trip an assertion when entering "new Date();" into the REPL.
2022-12-05 21:49:32 +00:00
else()
Meta+CI: Add CI job specifically for bundling serenity-js artifacts These are used by esvu, and it is sad that we don't have macOS binaries availble for consumption by esvu users. Add a matrix job to handle this separately from the test262 results.
2022-12-01 09:08:12 +00:00
set(CPACK_SYSTEM_NAME "macOS-${CMAKE_SYSTEM_PROCESSOR}")
endif()
else()
set(CPACK_SYSTEM_NAME "${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_PROCESSOR}")
endif()
set(CPACK_ARCHIVE_JS_FILE_NAME "serenity-js-${CPACK_SYSTEM_NAME}")
set(CPACK_PACKAGE_FILE_NAME "serenity-js-${CPACK_SYSTEM_NAME}")
Meta: Add a CPack installation target for js(1) This adds a CPack configuration to generate a release package for js(1). Our current CMake requirement is 3.16, which doesn't have a great story for automatically installing a binary target's library dependencies. If we eventually require CMake 3.21 or above, we can remove the helper .cmake file added here in lieu of RUNTIME_DEPENDENCIES.
2022-02-08 16:11:03 +00:00
include(CPack)
Lagom: Various fixes to make Lagom run on OSS-Fuzz (#4176)
2020-11-27 22:57:02 +00:00
endif()
Build: Switch to CMake :^) Closes https://github.com/SerenityOS/serenity/issues/2080
2020-05-06 15:40:06 +00:00
endif()
LibX86: Add an X86 instruction decoder library + basic disassembler This will be very useful for developer tools like ProfileView, and also for future tools like debuggers and such. :^)
2020-04-11 11:16:17 +00:00
CMake: Allow building fuzzing targets without libFuzzer or OSS-Fuzz
2022-03-21 10:36:41 +00:00
if (ENABLE_FUZZERS)
Lagom: Add fuzz testing for LibJS using libFuzzer (#1692) Note: clang only (see https://llvm.org/docs/LibFuzzer.html) - add FuzzJs which will run the LibJS parser on random javascript inputs - added a basic dictionary of javascript tokens To use fuzzer: CC=/usr/bin/clang CXX=/usr/bin/clang++ cmake -DENABLE_FUZZER_SANITIZER=1 .. Fuzzers/FuzzJs -dict=../Fuzzers/FuzzJs.dict
2020-04-08 08:40:02 +00:00
add_subdirectory(Fuzzers)
Meta: Build select Services in Lagom Add overrides for serenity_bin and serenity_lib to allow the actual CMakeLists.txt from Userland to be used to build as many services as possible without adding more clutter to Meta/Lagom/CMakeLists.txt
2022-07-04 16:08:01 +00:00
else()
export_components("${CMAKE_BINARY_DIR}/components.ini")
Lagom: Add fuzz testing for LibJS using libFuzzer (#1692) Note: clang only (see https://llvm.org/docs/LibFuzzer.html) - add FuzzJs which will run the LibJS parser on random javascript inputs - added a basic dictionary of javascript tokens To use fuzzer: CC=/usr/bin/clang CXX=/usr/bin/clang++ cmake -DENABLE_FUZZER_SANITIZER=1 .. Fuzzers/FuzzJs -dict=../Fuzzers/FuzzJs.dict
2020-04-08 08:40:02 +00:00
endif()
Meta: Allow running Lagom tests with "serenity.sh run lagom <target>" After 5ac57f9, we could no longer run "serenity.sh run lagom TestString" because the TestString binary now lives in a subdirectory under Build/lagom. Thus the existing method of running "$BUILD_DIR/TestString" could not work. This adds a "run-lagom-target" custom target to Lagom, to run a command and pass arguments to that invocation. It turns out there really isn't a "pretty" way of doing this with CMake or Ninja. But we can pass these as environment variables for CMake to interpret. We just must be careful to massage arguments into a CMake list.
2023-01-25 19:46:44 +00:00
if (NOT "$ENV{LAGOM_TARGET}" STREQUAL "")
add_custom_target(run-lagom-target
Meta: Set LD_LIBRARY_PATH to Build/lagom for Lagom test targets Some tests, such as those under LibGL, try to load shared libraries at runtime which are stored in Build/lagom. Because all tests' working directory is that of their CMakeLists.txt file, they fail to find those shared libraries at runtime. Set LD_LIBRARY_PATH to Build/lagom so the tests may find the shared libraries. This fixes, for example, both of these commands: ./Meta/serenity.sh test lagom TestAPI ./Meta/serenity.sh run lagom TestAPI
2023-02-01 13:42:31 +00:00
COMMAND "${CMAKE_COMMAND}"
Meta+Lagom: Enable CMAKE_BUILD_WITH_INSTALL_RPATH On macOS, CMake incorrectly tries to add and/or remove rpaths from files that it has already processed when it performs installation. Setting the rpaths during the build process ensures that they are only set once, and as a bonus, makes installation slightly more performant. Fixes #10055.
2023-03-18 15:23:35 +00:00
-E env "SERENITY_SOURCE_DIR=${SERENITY_PROJECT_ROOT}" "$<TARGET_FILE:$ENV{LAGOM_TARGET}>"
$ENV{LAGOM_ARGS}
Meta: Set LD_LIBRARY_PATH to Build/lagom for Lagom test targets Some tests, such as those under LibGL, try to load shared libraries at runtime which are stored in Build/lagom. Because all tests' working directory is that of their CMakeLists.txt file, they fail to find those shared libraries at runtime. Set LD_LIBRARY_PATH to Build/lagom so the tests may find the shared libraries. This fixes, for example, both of these commands: ./Meta/serenity.sh test lagom TestAPI ./Meta/serenity.sh run lagom TestAPI
2023-02-01 13:42:31 +00:00
Meta: Set the Lagom test working directory for run-lagom-target When we call add_test() from each test's CMakeLists.txt, we specify the working directory to be that of the CMakeList.txt file itself. Create a property to store that directory and reference it when run-lagom-target is invoked by serenity.sh. Note that for non-test Lagom targets which do not set this property, the working directory will be Build/lagom (because the property will be the empty string, which CMake resolves relative to the current build path).
2023-02-01 13:36:15 +00:00
WORKING_DIRECTORY "$<TARGET_PROPERTY:$ENV{LAGOM_TARGET},LAGOM_WORKING_DIRECTORY>"
Meta: Allow running Lagom tests with "serenity.sh run lagom <target>" After 5ac57f9, we could no longer run "serenity.sh run lagom TestString" because the TestString binary now lives in a subdirectory under Build/lagom. Thus the existing method of running "$BUILD_DIR/TestString" could not work. This adds a "run-lagom-target" custom target to Lagom, to run a command and pass arguments to that invocation. It turns out there really isn't a "pretty" way of doing this with CMake or Ninja. But we can pass these as environment variables for CMake to interpret. We just must be careful to massage arguments into a CMake list.
2023-01-25 19:46:44 +00:00
DEPENDS "$<TARGET_FILE:$ENV{LAGOM_TARGET}>"
USES_TERMINAL
VERBATIM
)
endif()
Meta: Download cacert.pem at build time
2023-03-14 13:12:58 +00:00
include(ca_certificates_data)
Reference in a new issue Copy permalink