kevin/neovim
1
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2024-12-24 05:05:00 -07:00
Code Issues Packages Projects Releases Wiki Activity
4ddd999f65
neovim/CMakeLists.txt

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

323 lines
11 KiB
CMake
Raw Normal View History

doc: job/channel, misc #7783 doc: termios defaults. ref #6992 doc: :help shell-powershell doc: provider: Python minimum version is 2.7, 3.4 doc: remove :!start special-case. #5844 doc: mention #7917 change which accepts empty Array for Dictionary parameter doc: <Cmd> pseudokey doc: lmap change #5658 doc: -s, -es
2017-12-27 11:30:23 -07:00
# CMAKE REFERENCE
# intro: https://codingnest.com/basic-cmake/
# best practices (3.0+): https://gist.github.com/mbinna/c61dbb39bca0e4fb7d1f73b0d66a4fd1
docs: various #12823 - increase python line-length limit from 88 => 100. - gen_help_html: fix bug in "tag" case (tbl_count => tbl_contains) ref #15632 fix #18215 fix #18479 fix #20527 fix #20532 Co-authored-by: Ben Weedon <ben@weedon.email>
2022-10-09 05:21:52 -07:00
# pitfalls: https://izzys.casa/2019/02/everything-you-never-wanted-to-know-about-cmake/
doc: job/channel, misc #7783 doc: termios defaults. ref #6992 doc: :help shell-powershell doc: provider: Python minimum version is 2.7, 3.4 doc: remove :!start special-case. #5844 doc: mention #7917 change which accepts empty Array for Dictionary parameter doc: <Cmd> pseudokey doc: lmap change #5658 doc: -s, -es
2017-12-27 11:30:23 -07:00
ci: split ci.yml into a test workflow and a build test workflow (#22302) Having a workflow that only builds neovim without running all of the tests is a cheap way to test the build still works without burning too much CI time.
2023-02-18 02:47:22 -07:00
# Version should match the tested CMAKE_URL in .github/workflows/build.yml.
build: bump minimum cmake version to 3.13 The benefits are primarily being able to use FetchContent, which allows for a more flexible dependency handling. Other various quality-of-life features such as `-B` and `-S` flags are also included. This also removes broken `--version` generation as it does not work for version 3.10 and 3.11 due to the `JOIN` generator expression. Reference: https://github.com/neovim/neovim/issues/24004
2023-10-14 04:12:48 -07:00
cmake_minimum_required(VERSION 3.13)
ci(windows): treat compiler warnings as errors Reduce the warning level from 3 to 1 and fix all warnings.
2022-11-12 05:34:14 -07:00
# Can be removed once minimum version is at least 3.15
if(POLICY CMP0092)
cmake_policy(SET CMP0092 NEW)
endif()
cmake: Explicitly declare C as the project language There's a mix of CXX and C related variables being set/referenced in our CMake files. Since we only use C, use an explicit language list of "C" instead of the implicit "C CXX" and replace all uses of CXX variables with their C counterparts
2018-06-15 05:33:07 -07:00
project(nvim C)
Import vim from changeset v5628:c9cad40b4181 - Cleanup source tree, leaving only files necessary for compilation/testing - Process files through unifdef to remove tons of FEAT_* macros - Process files through uncrustify to normalize source code formatting. - Port the build system to cmake
2014-01-31 06:39:15 -07:00
build: bundle uncrustify Uncrustify is sensitive to version changes, which causes friction for contributors that doesn't have that exact version. It's also simpler to download and install the correct version than to have bespoke version checking.
2023-05-18 07:27:47 -07:00
if(POLICY CMP0135)
cmake_policy(SET CMP0135 NEW)
endif()
build: get rid of warnings with `cmake --debug-output` (#11131)
2019-10-01 18:44:57 -07:00
add custom CMake module path
2014-02-24 13:54:45 -07:00
# Point CMake at any custom modules we may ship
build: fix CMAKE_MODULE_PATH usage Fixes #1447. `CMAKE_MODULE_PATH` is meant to be a list of directories, and as such, is not the proper way to launch our scripts. Let's use `${PROJECT_SOURCE_DIR}/cmake` instead. Also, let's not outright set `CMAKE_MODULE_PATH`, but instead append our location to the list.
2014-11-10 17:26:01 -07:00
list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake")
add custom CMake module path
2014-02-24 13:54:45 -07:00
build: use modern cmake (#21589) Replace old-school cmake with the so-called "Modern CMake", meaning preferring using targets and properties over directory settings and variables. This allows greater flexibility, robustness and clarity over how the code works. The following deprecated commands will be replaced with their modern alternatives that operates on a specific target, rather than all targets in the current directory: - add_compile_options -> target_compile_options - include_directories -> target_include_directories - link_libraries -> target_link_libraries - add_definitions -> target_compile_definitions There are mainly four main targets that we currently use: nvim, libnvim, nvim-test (used by unittests) and ${texe} (used by check-single-includes). The goal is to explicitly define the dependencies of each target fully, rather than having everything be dependent on everything else.
2023-01-10 10:49:57 -07:00
include(CheckCCompilerFlag)
include(CheckCSourceCompiles)
build: cmake cleanup - Simplify error checking when using execute_process. - Set BUILD_SHARED_LIBS to OFF when building dependencies. This is normally not needed, but msgpack interprets an unset BUILD_SHARED_LIBS to build a shared library, which is the opposite of the cmake behavior. - Move function check_lua_module to Util.cmake. - Remove unnecessary code. - Make variable naming more consistent
2023-05-13 03:12:29 -07:00
include(CheckLibraryExists)
build: bundle uncrustify Uncrustify is sensitive to version changes, which causes friction for contributors that doesn't have that exact version. It's also simpler to download and install the correct version than to have bespoke version checking.
2023-05-18 07:27:47 -07:00
include(ExternalProject)
build: remove libfindmacros library (#22423) Large parts the library weren't being used, and the parts that were was overly abstracted for our use case. Additionally, part of its use case was to abstract pkgconfig boilerplate, which is no longer needed as pkgconfig has been removed in favor of relying on cmake alone in 09118052cee5aef978d6075db5287c1b6c27381a.
2023-03-02 02:22:41 -07:00
include(FindPackageHandleStandardArgs)
build: cmake cleanup - Simplify error checking when using execute_process. - Set BUILD_SHARED_LIBS to OFF when building dependencies. This is normally not needed, but msgpack interprets an unset BUILD_SHARED_LIBS to build a shared library, which is the opposite of the cmake behavior. - Move function check_lua_module to Util.cmake. - Remove unnecessary code. - Make variable naming more consistent
2023-05-13 03:12:29 -07:00
include(GNUInstallDirs)
build: bundle uncrustify Uncrustify is sensitive to version changes, which causes friction for contributors that doesn't have that exact version. It's also simpler to download and install the correct version than to have bespoke version checking.
2023-05-18 07:27:47 -07:00
include(Deps)
build: adjust how find order is prioritized Ensure bundled libraries and include directories are always searched first before any others. This will provide a more consistent experience as the search order of the builtin find_ functions can vary depending on system. This should make the build process faster when building with bundled deps as we limit the search to only the .deps directory. Separating the search between .deps and everything makes debugging find_-related problems simpler if you need to check how dependencies are found. For libraries, we divide the search process into the following order: 1. Only search in .deps directory and only search for static libraries. 2. Only search in .deps directory and search for all libraries. 3. Search everywhere and search for all libraries. Make an exception for FindLibintl.cmake as changing the search order seems to break some tests on macos.
2023-10-10 14:18:45 -07:00
include(Find)
build: use modern cmake (#21589) Replace old-school cmake with the so-called "Modern CMake", meaning preferring using targets and properties over directory settings and variables. This allows greater flexibility, robustness and clarity over how the code works. The following deprecated commands will be replaced with their modern alternatives that operates on a specific target, rather than all targets in the current directory: - add_compile_options -> target_compile_options - include_directories -> target_include_directories - link_libraries -> target_link_libraries - add_definitions -> target_compile_definitions There are mainly four main targets that we currently use: nvim, libnvim, nvim-test (used by unittests) and ${texe} (used by check-single-includes). The goal is to explicitly define the dependencies of each target fully, rather than having everything be dependent on everything else.
2023-01-10 10:49:57 -07:00
include(InstallHelpers)
build: prevent in-tree builds for the time being, as it's not supported
2016-10-11 15:35:02 -07:00
include(PreventInTreeBuilds)
feat(build): add_glob_target runs only on changed files #19070 The general idea is that add_glob_targets creates a "touch file", a dummy file that acts as a dependency in order to check which files are outdated since the last time the target was run. Remove RunUncrustify.cmake as it's no longer necessary. It was initially introduced to silence its noisy output. The per-file targets will suppress the noisy output from uncrustify, except for the very first run. Also remove DefCmdTarget.cmake since add_glob_target already incorporates its functionality.
2022-06-30 05:10:05 -07:00
include(Util)
build: various improvements - Use `#pragma once` for `cmake.config/config.h.in` - Remove unused variable `CACHED_GENERATED_DIR` - Reorganize and sort variables - Introduce `STYLUA_DIRS` variable to ensure the `formatlua` and `lintlua-stylua` operates on the same files. - Adjust variable scope to avoid using hacky directory properties. - Add more necessary runtime files as test dependencies
2023-12-17 07:40:09 -07:00
#-------------------------------------------------------------------------------
# Variables
#-------------------------------------------------------------------------------
set(FUNCS_DATA ${PROJECT_BINARY_DIR}/funcs_data.mpack)
set(TOUCHES_DIR ${PROJECT_BINARY_DIR}/touches)
build: move luarocks and rocks installation to main build This will ensure luacheck and busted are only installed when they're actually needed. This cuts total build time by over 50%. Closes https://github.com/neovim/neovim/issues/22797.
2023-05-21 11:57:39 -07:00
set_directory_properties(PROPERTIES
EP_PREFIX "${DEPS_BUILD_DIR}")
build: enable ccache project-wide (#22045) Currently, only the nvim target uses ccache but not libnvim or unittests. It is generally a good idea to operate on targets rather than globally, but this is an exception as there isn't a target where we don't want to use ccache on.
2023-01-29 09:02:34 -07:00
find_program(CCACHE_PRG ccache)
if(CCACHE_PRG)
set(CMAKE_C_COMPILER_LAUNCHER ${CMAKE_COMMAND} -E env CCACHE_SLOPPINESS=pch_defines,time_macros ${CCACHE_PRG})
endif()
build: don't print installed files locally It takes a significant amount of time to install neovim, and doubly so on Windows, due to the sheer amount of files neovim ships with. On CI this information may be important though, so we enable it if the CI_ENABLE option is set to ON.
2023-04-14 10:19:49 -07:00
if(NOT CI_BUILD)
set(CMAKE_INSTALL_MESSAGE NEVER)
endif()
build: reorganize cmake files Also add _GNU_SOURCE compiler definition for all non MSVC compilers. Closes https://github.com/neovim/neovim/issues/26087.
2023-11-20 08:49:48 -07:00
if(${CMAKE_VERSION} VERSION_LESS 3.20)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
endif()
build: create separate targets for nvim with and without runtime files This distinction is important for correct dependency management, as the nvim binary is used to create some runtime files. The nvim binary (and the target to build it) is thus called `nvim_bin` and the target to build all of nvim (binary+runtime) is called `nvim`.
2024-01-19 05:21:25 -07:00
if(${CMAKE_VERSION} VERSION_GREATER_EQUAL 3.26)
set(COPY_DIRECTORY copy_directory_if_different)
else()
set(COPY_DIRECTORY copy_directory)
endif()
Revamp the build system. This achieves several goals: * Less reliance on scripts so we have better portability to Windows (though we still have a ways to go for proper Windows support). Luajit, luarocks, moonscript, and busted are all installed via CMake now. * Trying to make use of pkg-config to get the correct libraries. The latest libuv is still broken in this regard, but we'll at least be in a position to use it. * Allow the use of Ninja or make. The former runs faster in many environments, and automatically makes use of parallel builds. This also allows for system installed dependencies--though not through the Makefile just yet--and adds support for FreeBSD. This also make us build libuv and luajit as static libraries only, since we're only concerned about having static libraries for our bundled dependencies.
2014-03-03 08:09:06 -07:00
# Prefer our bundled versions of dependencies.
build: respect $DEPS_BUILD_DIR Without this, the CI_TARGET=lint travis job cant't find the cached deps (in $HOME/nvim-deps), nor can it update the cache.
2018-03-11 05:15:42 -07:00
if(DEFINED ENV{DEPS_BUILD_DIR})
build: remove pkgconfig-related code (#22422) Cmake should already be able to find everything on its own.
2023-02-26 14:32:08 -07:00
set(DEPS_PREFIX "$ENV{DEPS_BUILD_DIR}/usr" CACHE PATH "Path prefix for finding dependencies")
build: respect $DEPS_BUILD_DIR Without this, the CI_TARGET=lint travis job cant't find the cached deps (in $HOME/nvim-deps), nor can it update the cache.
2018-03-11 05:15:42 -07:00
else()
build: remove pkgconfig-related code (#22422) Cmake should already be able to find everything on its own.
2023-02-26 14:32:08 -07:00
set(DEPS_PREFIX "${CMAKE_CURRENT_SOURCE_DIR}/.deps/usr" CACHE PATH "Path prefix for finding dependencies")
deps: Build bundled dependencies automatically for IDEs Environment variables are used to detect when the project is being built from within Clion or Visual Studio, so that the build process can be simplified by automatically building the bundled dependencies for them.
2018-06-10 07:57:12 -07:00
# When running from within CLion or Visual Studio,
# build bundled dependencies automatically.
if(NOT EXISTS ${DEPS_PREFIX}
AND (DEFINED ENV{CLION_IDE}
OR DEFINED ENV{VisualStudioEdition}))
message(STATUS "Building dependencies...")
set(DEPS_BUILD_DIR ${PROJECT_BINARY_DIR}/.deps)
file(MAKE_DIRECTORY ${DEPS_BUILD_DIR})
execute_process(
COMMAND ${CMAKE_COMMAND} -G ${CMAKE_GENERATOR}
build: prefer -D <variable>=<value> over -D<variable>=<value> (#22164) This makes it easier to see that -D is referring to the entire "<variable>=<value>", rather than only <variable>. It also help syntax highlighters highlight built-in variables.
2023-02-08 03:00:16 -07:00
-D CMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}
-D CMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
-D CMAKE_C_COMPILER=${CMAKE_C_COMPILER}
-D CMAKE_C_FLAGS=${CMAKE_C_FLAGS}
-D CMAKE_C_FLAGS_DEBUG=${CMAKE_C_FLAGS_DEBUG}
-D CMAKE_C_FLAGS_MINSIZEREL=${CMAKE_C_FLAGS_MINSIZEREL}
-D CMAKE_C_FLAGS_RELWITHDEBINFO=${CMAKE_C_FLAGS_RELWITHDEBINFO}
-D CMAKE_C_FLAGS_RELEASE=${CMAKE_C_FLAGS_RELEASE}
-D CMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}
build: rename build-related dirs Problem: Dirs "config", "packaging", and "third-party" are all closely related but this is not obvious from the layout. This adds friction for new contributors. Solution: - rename config/ to cmake.config/ - rename test/config/ to test/cmakeconfig/ because it is used in Lua tests: require('test.cmakeconfig.paths'). - rename packaging/ to cmake.packaging/ - rename third-party/ to cmake.deps/ (parallel with .deps/)
2022-06-27 03:08:59 -07:00
${PROJECT_SOURCE_DIR}/cmake.deps
deps: Build bundled dependencies automatically for IDEs Environment variables are used to detect when the project is being built from within Clion or Visual Studio, so that the build process can be simplified by automatically building the bundled dependencies for them.
2018-06-10 07:57:12 -07:00
WORKING_DIRECTORY ${DEPS_BUILD_DIR})
execute_process(
COMMAND ${CMAKE_COMMAND} --build ${DEPS_BUILD_DIR}
--config ${CMAKE_BUILD_TYPE})
set(DEPS_PREFIX ${DEPS_BUILD_DIR}/usr)
endif()
build: respect $DEPS_BUILD_DIR Without this, the CI_TARGET=lint travis job cant't find the cached deps (in $HOME/nvim-deps), nor can it update the cache.
2018-03-11 05:15:42 -07:00
endif()
deps: Build bundled dependencies automatically for IDEs Environment variables are used to detect when the project is being built from within Clion or Visual Studio, so that the build process can be simplified by automatically building the bundled dependencies for them.
2018-06-10 07:57:12 -07:00
build: remove CMAKE_CROSSCOMPILING code #18914 This is rarely, if ever, used and certainly not tested. It's likely this isn't functional anymore.
2022-06-12 15:11:14 -07:00
list(INSERT CMAKE_PREFIX_PATH 0 ${DEPS_PREFIX})
Revamp the build system. This achieves several goals: * Less reliance on scripts so we have better portability to Windows (though we still have a ways to go for proper Windows support). Luajit, luarocks, moonscript, and busted are all installed via CMake now. * Trying to make use of pkg-config to get the correct libraries. The latest libuv is still broken in this regard, but we'll at least be in a position to use it. * Allow the use of Ninja or make. The former runs faster in many environments, and automatically makes use of parallel builds. This also allows for system installed dependencies--though not through the Makefile just yet--and adds support for FreeBSD. This also make us build libuv and luajit as static libraries only, since we're only concerned about having static libraries for our bundled dependencies.
2014-03-03 08:09:06 -07:00
build: cmake cleanup (#22251) - Remove unused code - Use consistent casing. Variable names such as LibLuV_LIBRARIES is needlessly jarring, even if the name might be technically correct. - Use title casing for packages. find_package(unibilium) requires the find_module to be named "Findunibilium.cmake", which makes it harder to spot when scanning the files. Instead, use "Unibilium".
2023-03-02 14:50:43 -07:00
if(APPLE)
build(macos): use consistent MACOSX_DEPLOYMENT_TARGET (#19430) Use the same logic for both deps (including LuaJIT, for which setting this variable is mandatory) and Nvim: either the eponymous environment variable if set, or the current software version if not. Removes annoying warnings when building locally on macOS.
2022-07-19 07:10:59 -07:00
# If the macOS deployment target is not set manually (via $MACOSX_DEPLOYMENT_TARGET),
# fall back to local system version. Needs to be done both here and in cmake.deps.
if(NOT CMAKE_OSX_DEPLOYMENT_TARGET)
execute_process(COMMAND sw_vers -productVersion
OUTPUT_VARIABLE MACOS_VERSION
OUTPUT_STRIP_TRAILING_WHITESPACE)
set(CMAKE_OSX_DEPLOYMENT_TARGET "${MACOS_VERSION}")
endif()
build: use modern cmake (#21589) Replace old-school cmake with the so-called "Modern CMake", meaning preferring using targets and properties over directory settings and variables. This allows greater flexibility, robustness and clarity over how the code works. The following deprecated commands will be replaced with their modern alternatives that operates on a specific target, rather than all targets in the current directory: - add_compile_options -> target_compile_options - include_directories -> target_include_directories - link_libraries -> target_link_libraries - add_definitions -> target_compile_definitions There are mainly four main targets that we currently use: nvim, libnvim, nvim-test (used by unittests) and ${texe} (used by check-single-includes). The goal is to explicitly define the dependencies of each target fully, rather than having everything be dependent on everything else.
2023-01-10 10:49:57 -07:00
message(STATUS "Using deployment target ${CMAKE_OSX_DEPLOYMENT_TARGET}")
win: Define USE_FNAME_CASE (#5962)
2017-01-17 08:32:41 -07:00
endif()
CMakeLists: enable USE_FNAME_CASE on Mac
2015-03-26 20:30:45 -07:00
build: cmake cleanup (#22251) - Remove unused code - Use consistent casing. Variable names such as LibLuV_LIBRARIES is needlessly jarring, even if the name might be technically correct. - Use title casing for packages. find_package(unibilium) requires the find_module to be named "Findunibilium.cmake", which makes it harder to spot when scanning the files. Instead, use "Unibilium".
2023-03-02 14:50:43 -07:00
if(WIN32 OR APPLE)
option: fix problem with fileignorecase not being set properly
2021-02-23 21:54:12 -07:00
# Ignore case when comparing filenames on Windows and Mac.
set(CASE_INSENSITIVE_FILENAME TRUE)
win: Define USE_FNAME_CASE (#5962)
2017-01-17 08:32:41 -07:00
# Enable fixing case-insensitive filenames for Windows and Mac.
CMakeLists: enable USE_FNAME_CASE on Mac
2015-03-26 20:30:45 -07:00
set(USE_FNAME_CASE TRUE)
build: give priority to /sw and /opt/local on Mac OS X Unfortunately, we can't force the specific inclusion of a header file. So if anything add /opt/local/include to the include path--such as libintl--then other dependencies might be drawn from /opt/local at compile time, even though we detected them elsewhere at configure time. This, in turn, causes issues with mixed versions, such as the iconv.h header being pulled from /opt/local/include, but linked against the library in /usr/lib--which can be mismatched versions. So, despite CMake's best effort to treat /sw and /opt/local as just another system area, we really need to give them preferential treatment. To do this, we add them to CMAKE_PREFIX_PATH. This fixes an issue discovered while re-enabling iconv in #1370.
2014-11-08 14:16:39 -07:00
endif()
revert: "ci: remove mingw job #18580" This partially reverts commit f8af81445bb48966d54f4a956842d935d009d275. The mingw parts of cmake was removed to see if it was still used (ref: https://github.com/neovim/neovim/pull/18580). It turns out it is, so this will fix that. Closes: https://github.com/neovim/neovim/issues/18597
2022-05-17 06:08:24 -07:00
if (MINGW)
# Disable LTO by default as it may not compile
# See https://github.com/Alexpux/MINGW-packages/issues/3516
# and https://github.com/neovim/neovim/pull/8654#issuecomment-402316672
option(ENABLE_LTO "enable link time optimization" OFF)
else()
option(ENABLE_LTO "enable link time optimization" ON)
endif()
ci: disable libintl on mac release The releases doesn't work on intel mac as libintl isn't available on the system by default. This makes `:language` not work for the shipped macos releases, though the reduction in build system complexity most likely outweighs that.
2023-12-26 14:46:10 -07:00
option(ENABLE_LIBINTL "enable libintl" ON)
build/CMake: find_package(… REQUIRED) "Always use `find_package` with `REQUIRED`." - We make an exception for LuaJit (not REQUIRED): the `nvim-test` target is included only if we can find LuaJit. This is partially a cargo-cult (reference below), but it uncovered at least one problem: `find_package(LibIntl REQUIRED)` fails on my vanilla ubuntu 16.04 system. ref: https://schneide.blog/2017/11/06/4-tips-for-better-cmake/ > optional dependencies is nice, but skipping on REQUIRED is not the way > you want to do it. In the worst case, some of your features will just > not work if those packages are not found, with no explanation > whatsoever. Instead, use explicit feature-toggles (e.g. using option()) > that either skip the find_package call or use it with REQUIRED, so the > user will know that another lib is needed for this feature.
2018-06-01 11:17:24 -07:00
build/CMakeLists.txt: group related logic - Group CMAKE_BUILD_TYPE-related logic together. - Print the MIN_LOG_LEVEL message (in the build-log) next to the CMAKE_BUILD_TYPE message.
2019-02-15 13:18:16 -07:00
message(STATUS "CMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX}")
build: consistently set build type regardless of generator or platform #19760 Change the default build type to always be Debug, and allow only four predefined build types: Debug, Release, RelWithDebInfo and MinRelSize. Furthermore, flags meant for single-configuration generator (make, ninja) will not be used for multi-configuration generators (visual studio, Xcode), and flags meant for multi-configuration generators will not be used for single-configuration generators. This will allow Debug builds to be built with MSVC which requires that all dependencies are also built with the Debug build type to avoid runtime library mismatch. The correct way to specify build type (for example Release) for single-configuration generators (Make and Ninja) is to run cmake -B build -D CMAKE_BUILD_TYPE=Release cmake --build build while for multi-configuration generators (Visual Studio, Xcode and Ninja Multi-Config) is to run cmake -B build cmake --build build --config Release Passing CMAKE_BUILD_TYPE for multi-config generators will now not only not be used, but also generate a warning for the user. Co-authored-by: dundargoc <gocundar@gmail.com>
2022-09-06 07:52:39 -07:00
set_default_buildtype()
build: bundle uncrustify Uncrustify is sensitive to version changes, which causes friction for contributors that doesn't have that exact version. It's also simpler to download and install the correct version than to have bespoke version checking.
2023-05-18 07:27:47 -07:00
get_property(isMultiConfig GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
if(NOT isMultiConfig)
# Unlike build dependencies in cmake.deps, we assume we want dev dependencies
# such as Uncrustify to always be built with Release.
list(APPEND DEPS_CMAKE_ARGS -D CMAKE_BUILD_TYPE=Release)
endif()
CMake: Defer setting CACHE CMAKE_BUILD_TYPE. The Visual Studio CMake generator fails to configure if CACHE CMAKE_BUILD_TYPE is set before CMAKE_BUILD_TYPE.
2015-12-19 20:58:47 -07:00
version: semver.org compliance We use `git describe` to stamp pre-release versions (dev builds). But `git describe` uses the result of the most-recent tag (the current _release_ version)--so we must munge it with the _next_ (i.e. unreleased) version. Also fix non-git builds: do not invoke git_describe(NVIM_VERSION_MEDIUM) if we're not in a git tree, else it gets the dummy value "HEAD-HASH-NOTFOUND". Example :version output in non-git build: NVIM 0.1.2-dev Example :version output in git build: NVIM v0.1.2-176-g9c3c2b5
2015-12-13 10:29:02 -07:00
# If not in a git repo (e.g., a tarball) these tokens define the complete
api: api_info()['version'] API level is disconnected from NVIM version. The API metadata holds the current API level, and the lowest backwards-compatible level supported by this instance. Release 0.1.6 is the first release that reports the Nvim version and API level. metadata['version'] = { major: 0, minor: 1, patch: 6, api_level: 1, api_compatible: 0, api_prerelease: false, } The API level may remain unchanged across Nvim releases if the API has not changed. When changing the API, - set NVIM_API_PRERELEASE to true - increment NVIM_API_LEVEL (at most once per Nvim version) - adjust NVIM_API_LEVEL_COMPAT if backwards-compatibility was broken api_level_0.mpack was generated from Nvim 0.1.5 with: nvim --api-info
2016-10-26 06:20:00 -07:00
# version string, else they are combined with the result of `git describe`.
version: report commit hash as "build number" in long version string
2014-10-04 15:32:47 -07:00
set(NVIM_VERSION_MAJOR 0)
version bump
2023-04-07 04:35:22 -07:00
set(NVIM_VERSION_MINOR 10)
version bump
2018-12-30 16:44:49 -07:00
set(NVIM_VERSION_PATCH 0)
version bump
2023-04-07 04:35:22 -07:00
set(NVIM_VERSION_PRERELEASE "-dev") # for package maintainers
version: Prepare for releases. * Hide commit information from --version if we can't find any (e.g. when building from tarball). To define a release in CMake, set NVIM_VERSION_PRERELEASE to "". This will modify --version output to: * Show annotated Git tag instead of commit hash (NVIM_VERSION_COMMIT). * Hide commit date (NVIM_VERSION_BUILD).
2015-09-28 03:17:19 -07:00
api: api_info()['version'] API level is disconnected from NVIM version. The API metadata holds the current API level, and the lowest backwards-compatible level supported by this instance. Release 0.1.6 is the first release that reports the Nvim version and API level. metadata['version'] = { major: 0, minor: 1, patch: 6, api_level: 1, api_compatible: 0, api_prerelease: false, } The API level may remain unchanged across Nvim releases if the API has not changed. When changing the API, - set NVIM_API_PRERELEASE to true - increment NVIM_API_LEVEL (at most once per Nvim version) - adjust NVIM_API_LEVEL_COMPAT if backwards-compatibility was broken api_level_0.mpack was generated from Nvim 0.1.5 with: nvim --api-info
2016-10-26 06:20:00 -07:00
# API level
feat(api): add nvim_win_text_height (#24236) It uses the same code as "scroll_delta" of "win_viewport" UI event to calculate text height, but is more flexible.
2023-07-10 16:15:46 -07:00
set(NVIM_API_LEVEL 12) # Bump this after any API change.
api: api_info()['version'] API level is disconnected from NVIM version. The API metadata holds the current API level, and the lowest backwards-compatible level supported by this instance. Release 0.1.6 is the first release that reports the Nvim version and API level. metadata['version'] = { major: 0, minor: 1, patch: 6, api_level: 1, api_compatible: 0, api_prerelease: false, } The API level may remain unchanged across Nvim releases if the API has not changed. When changing the API, - set NVIM_API_PRERELEASE to true - increment NVIM_API_LEVEL (at most once per Nvim version) - adjust NVIM_API_LEVEL_COMPAT if backwards-compatibility was broken api_level_0.mpack was generated from Nvim 0.1.5 with: nvim --api-info
2016-10-26 06:20:00 -07:00
set(NVIM_API_LEVEL_COMPAT 0) # Adjust this after a _breaking_ API change.
feat(api): add nvim_win_text_height (#24236) It uses the same code as "scroll_delta" of "win_viewport" UI event to calculate text height, but is more flexible.
2023-07-10 16:15:46 -07:00
set(NVIM_API_PRERELEASE true)
api: Nvim version, API level #5386 The API level is disconnected from the NVIM version. The API metadata holds the current API level, and the lowest backwards-compatible level supported by this instance. Release 0.1.6 will be the first release reporting the Nvim version and API level. metadata['version'] = { major: 0, minor: 1, patch: 6, prerelease: true, api_level: 1, api_compatible: 0, } The API level may remain unchanged across Neovim releases if the API has not changed. When changing the API the CMake variable NVIM_API_PRERELEASE is set to true, and NVIM_API_CURRENT/NVIM_API_COMPATIBILITY are incremented accordingly. The functional tests check the API table against fixtures of past versions of Neovim. It compares all the functions in the old table with the new one, it does ignore some metadata attributes that do not alter the function signature or were removed since 0.1.5. Currently the only fixture is 0.mpack, generated from Neovim 0.1.5 with nvim --api-info.
2016-09-25 10:46:37 -07:00
build: set MIN_LOG_LEVEL correctly (#7419) closes #7283 regression by 42d892913daa215c27e41b2255e96c1ce09ea56c - Don't need to explicitly put "-O2 -g" in RelWithDebInfo; CMake does that already. That was left-over from 42d892913daa2 which removed the "Dev" custom build-type, but repurposed the logic for RelWithDebInfo. - `if(DEFINED MIN_LOG_LEVEL)` doesn't work. - `if(${MIN_LOG_LEVEL} MATCHES "^$")` doesn't work if -DMIN_LOG_LEVEL is omitted. - `if(MIN_LOG_LEVEL)` also isn't what we want: it would be true if MIN_LOG_LEVEL=0.
2017-10-20 17:30:21 -07:00
# Build-type: RelWithDebInfo
refactor(build): graduate -Wvla, -fno-common and -Og "features" These are in gcc 4.9+ which we require anyway. -Og is safe on clang as well (reserved for a future debug-optimize mode, and currently does the same as -O1 which is reasonable)
2023-02-27 12:14:10 -07:00
# /Og means something different in MSVC
if(CMAKE_C_COMPILER_ID MATCHES "GNU" OR CMAKE_C_COMPILER_ID MATCHES "Clang")
set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} -Og -g")
build: set MIN_LOG_LEVEL correctly (#7419) closes #7283 regression by 42d892913daa215c27e41b2255e96c1ce09ea56c - Don't need to explicitly put "-O2 -g" in RelWithDebInfo; CMake does that already. That was left-over from 42d892913daa2 which removed the "Dev" custom build-type, but repurposed the logic for RelWithDebInfo. - `if(DEFINED MIN_LOG_LEVEL)` doesn't work. - `if(${MIN_LOG_LEVEL} MATCHES "^$")` doesn't work if -DMIN_LOG_LEVEL is omitted. - `if(MIN_LOG_LEVEL)` also isn't what we want: it would be true if MIN_LOG_LEVEL=0.
2017-10-20 17:30:21 -07:00
endif()
# We _want_ assertions in RelWithDebInfo build-type.
if(CMAKE_C_FLAGS_RELWITHDEBINFO MATCHES DNDEBUG)
cmake: Remove custom "Dev" build-type. (#6932) The main purpose of this build-type was to avoid unwanted ~/.nvimlog files (which could get really big, and also affects performance) for non-devs. But that is no longer necessary since the log system now avoids non-critical logging by default (#6827). This essentially reverts 87e5a4131666e44354f280538cbc6bbe52225092
2017-06-29 00:29:40 -07:00
string(REPLACE "-DNDEBUG" "" CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO}")
build(MSVC): enable assertions on RelWithDebInfo build type (#22326)
2023-02-19 07:06:53 -07:00
string(REPLACE "/DNDEBUG" "" CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO}")
build: show build type specific compiler flags when using --version The build type specific flags are defined in the variables CMAKE_C_FLAGS_<CONFIG>, where <CONFIG> can be DEBUG, RELEASE, RELWITHDEBINFO and MINSIZEREL.
2023-03-04 12:04:01 -07:00
string(REPLACE " " " " CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO}") # Remove duplicate whitespace
CMake: Add custom Dev build type. Introduce new build type Dev that replaces RelWithDebInfo for development builds off master and has optimizations, debug info, and logging enabled. Keep assertions enabled for RelWithDebInfo.
2015-09-28 03:14:38 -07:00
endif()
build!: rename sanitizer options from CLANG_* to ENABLE_*
2023-03-16 11:24:04 -07:00
option(ENABLE_ASAN_UBSAN "Enable Clang address & undefined behavior sanitizer for nvim binary." OFF)
option(ENABLE_MSAN "Enable Clang memory sanitizer for nvim binary." OFF)
option(ENABLE_TSAN "Enable Clang thread sanitizer for nvim binary." OFF)
CMake: Add option for Clang TSan, rename option ASAN -> ASAN_UBSAN.
2015-06-09 01:43:22 -07:00
build!: rename sanitizer options from CLANG_* to ENABLE_*
2023-03-16 11:24:04 -07:00
if((ENABLE_ASAN_UBSAN AND ENABLE_MSAN)
OR (ENABLE_ASAN_UBSAN AND ENABLE_TSAN)
OR (ENABLE_MSAN AND ENABLE_TSAN))
build: adjust some messages (#9087)
2018-10-06 09:45:34 -07:00
message(FATAL_ERROR "Sanitizers cannot be enabled simultaneously")
CMake: Add option for Clang MSan.
2015-06-08 09:49:23 -07:00
endif()
CMake: Add option for Clang TSan, rename option ASAN -> ASAN_UBSAN.
2015-06-09 01:43:22 -07:00
Fix build output paths for Visual Studio generator The Visual Studio cmake generator creates subdirectories inside the build path for different build configuration. But this breaks some of our cmake scripts, like the help tags installer, that assume the targets are built in that location. Updated CMakeLists.txt to remove extra paths.
2016-01-08 19:40:57 -07:00
# Place targets in bin/ or lib/ for all build configurations
Revamp the build system. This achieves several goals: * Less reliance on scripts so we have better portability to Windows (though we still have a ways to go for proper Windows support). Luajit, luarocks, moonscript, and busted are all installed via CMake now. * Trying to make use of pkg-config to get the correct libraries. The latest libuv is still broken in this regard, but we'll at least be in a position to use it. * Allow the use of Ninja or make. The former runs faster in many environments, and automatically makes use of parallel builds. This also allows for system installed dependencies--though not through the Makefile just yet--and adds support for FreeBSD. This also make us build libuv and luajit as static libraries only, since we're only concerned about having static libraries for our bundled dependencies.
2014-03-03 08:09:06 -07:00
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
Allow building as a static -fPIC library
2014-11-30 19:22:46 -07:00
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
Fix build output paths for Visual Studio generator The Visual Studio cmake generator creates subdirectories inside the build path for different build configuration. But this breaks some of our cmake scripts, like the help tags installer, that assume the targets are built in that location. Updated CMakeLists.txt to remove extra paths.
2016-01-08 19:40:57 -07:00
foreach(CFGNAME ${CMAKE_CONFIGURATION_TYPES})
string(TOUPPER ${CFGNAME} CFGNAME)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_${CFGNAME} ${CMAKE_BINARY_DIR}/bin)
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_${CFGNAME} ${CMAKE_BINARY_DIR}/lib)
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_${CFGNAME} ${CMAKE_BINARY_DIR}/lib)
endforeach()
Changed binary output directory from src/ to bin/
2014-02-22 08:30:50 -07:00
build: enforce PREFER_LUA Only search for luajit if PREFER_LUA=OFF. If PREFER_LUA is OFF, then always prioritize luajit first and then fall back to lua.
2023-11-12 14:04:15 -07:00
if(NOT PREFER_LUA)
find_program(LUA_PRG NAMES luajit)
endif()
find_program(LUA_PRG NAMES lua5.1 lua5.2 lua)
refactor(build): include lpeg as a library
2023-04-20 04:19:38 -07:00
if(NOT LUA_PRG)
build: adjust some messages (#9087)
2018-10-06 09:45:34 -07:00
message(FATAL_ERROR "Failed to find a Lua 5.1-compatible interpreter")
Add checks for lpeg/cmsgpack lua packages These checks will stop the build process with meaningful error messages if any of those packages are not installed.
2014-04-13 03:06:35 -07:00
endif()
build: adjust some messages (#9087)
2018-10-06 09:45:34 -07:00
message(STATUS "Using Lua interpreter: ${LUA_PRG}")
Add checks for lpeg/cmsgpack lua packages These checks will stop the build process with meaningful error messages if any of those packages are not installed.
2014-04-13 03:06:35 -07:00
build: make generated source files reproducible #21586 Problem: Build is not reproducible, because generated source files (.c/.h/) are not deterministic, mostly because Lua pairs() is unordered by design (for security). https://github.com/LuaJIT/LuaJIT/issues/626#issuecomment-707005671 https://www.lua.org/manual/5.1/manual.html#pdf-next > The order in which the indices are enumerated is not specified [...] > >> The hardening of the VM deliberately randomizes string hashes. This in >> turn randomizes the iteration order of tables with string keys. Solution: - Update the code generation scripts to be deterministic. - That is only a partial solution: the exported function (funcs_metadata.generated.h) and ui event (ui_events_metadata.generated.h) metadata have some mpack'ed tables, which are not serialized deterministically. - As a workaround, introduce `PRG_GEN_LUA` cmake setting, so you can inject a modified build of luajit (with LUAJIT_SECURITY_PRN=0) that preserves table order. - Longer-term we should change the mpack'ed data structure so it no longer uses tables keyed by strings. Closes #20124 Co-Authored-By: dundargoc <gocdundar@gmail.com> Co-Authored-By: Arnout Engelen <arnout@bzzt.net>
2023-01-23 02:26:46 -07:00
# Some of the code generation still relies on stable table ordering in order to
# produce reproducible output - specifically the msgpack'ed data in
# funcs_metadata.generated.h and ui_events_metadata.generated.h. This should
# ideally be fixed in the generators, but until then as a workaround you may provide
# a specific lua implementation that provides the needed stability by setting LUA_GEN_PRG:
if(NOT LUA_GEN_PRG)
set(LUA_GEN_PRG "${LUA_PRG}" CACHE FILEPATH "Path to the lua used for code generation.")
endif()
message(STATUS "Using Lua interpreter for code generation: ${LUA_GEN_PRG}")
fix(build): don't disable byte precompilation on debug builds This special casing is redundant since long, as you can disable the binary cache regardless of build type with the --luamod-dev flag
2022-06-25 10:24:48 -07:00
option(COMPILE_LUA "Pre-compile Lua sources into bytecode (for sources that are included in the binary)" ON)
chore(build): add option to disable Lua bytecode compilation (#16722) Include a build option to explicitly disable Lua bytecode compilation. This is needed in some situations where the existing checks are not sufficient (e.g. cross compilation).
2021-12-19 14:00:53 -07:00
if(COMPILE_LUA AND NOT WIN32)
perf: pre-compile embedded Lua source into bytecode (#16631) The Lua modules that make up vim.lua are embedded as raw source files into the nvim binary. These sources are loaded by the Lua runtime on startuptime. We can pre-compile these sources into Lua bytecode before embedding them into the binary, which minimizes the size of the binary and improves startuptime.
2021-12-16 09:27:39 -07:00
if(PREFER_LUA)
foreach(CURRENT_LUAC_PRG luac5.1 luac)
find_program(_CHECK_LUAC_PRG ${CURRENT_LUAC_PRG})
if(_CHECK_LUAC_PRG)
set(LUAC_PRG "${_CHECK_LUAC_PRG} -s -o - %s" CACHE STRING "Format for compiling to Lua bytecode")
break()
endif()
endforeach()
elseif(LUA_PRG MATCHES "luajit")
fix(build): check that LuaJIT has required modules for compilation (#16714) Apparently some installations of LuaJIT do not have the "jit.bcsave" module which is required for pre-compilation. Check that this module exists before using LuaJIT as luac and if it doesn't, skip compiling bytecode.
2021-12-18 20:59:02 -07:00
check_lua_module(${LUA_PRG} "jit.bcsave" LUAJIT_HAS_JIT_BCSAVE)
if(LUAJIT_HAS_JIT_BCSAVE)
set(LUAC_PRG "${LUA_PRG} -b -s %s -" CACHE STRING "Format for compiling to Lua bytecode")
endif()
perf: pre-compile embedded Lua source into bytecode (#16631) The Lua modules that make up vim.lua are embedded as raw source files into the nvim binary. These sources are loaded by the Lua runtime on startuptime. We can pre-compile these sources into Lua bytecode before embedding them into the binary, which minimizes the size of the binary and improves startuptime.
2021-12-16 09:27:39 -07:00
endif()
endif()
if(LUAC_PRG)
message(STATUS "Using Lua compiler: ${LUAC_PRG}")
endif()
build(lint): fix luacheck not found #18940 Problem: Since 6d57bb89c1ee #18543, luacheck is not found on some systems when running the "lintlua" target. Solution: - Move the find_program() to the top-level CMakeLists.txt - Define a def_cmd_target() function with fewer assumptions than the old lint() function. - Move "lintuncrustify" to src/nvim/CMakeLists.txt so it can reuse the $LINT_NVIM_SOURCES already defined there. - Make the lint targets _fatal_ by default. There is little reason for the "lint" umbrella target defined in Makefile to exist if it's going to ignore the absence of the actual linters. - For now, keep the uncrustify call in a separate cmake script so that it can be silenced (too noisy).
2022-06-12 15:08:01 -07:00
# Lint
ci: introduce CI_LINT option This will abort if lint programs are not found, and is meant primarily for the lint job in CI. Supersedes the REQUIRED argument in add_glob_target as it's a superior replacement by being a built-in solution.
2023-06-23 15:29:53 -07:00
option(CI_LINT "Abort if lint programs not found" OFF)
if(CI_LINT)
set(LINT_REQUIRED "REQUIRED")
endif()
find_program(SHELLCHECK_PRG shellcheck ${LINT_REQUIRED})
find_program(STYLUA_PRG stylua ${LINT_REQUIRED})
feat(build): add_glob_target runs only on changed files #19070 The general idea is that add_glob_targets creates a "touch file", a dummy file that acts as a dependency in order to check which files are outdated since the last time the target was run. Remove RunUncrustify.cmake as it's no longer necessary. It was initially introduced to silence its noisy output. The per-file targets will suppress the noisy output from uncrustify, except for the very first run. Also remove DefCmdTarget.cmake since add_glob_target already incorporates its functionality.
2022-06-30 05:10:05 -07:00
build: various build improvements - remove "ran-" prefix from touch files as it's redundant since the they're already in the directory named `touches`. - Include `contrib` when formatting with `make formatlua`. - Use TARGET_FILE generator expression instead of assuming the executable location. - reuse logic that determines whether to use lua or luajit. - add translations to the `nvim` target. Makefile improvements: - rename variable `CMAKE_PRG` to `CMAKE` to make it more consistent with the builtin `MAKE` variable. - stop propagating flags to generator. Users should use cmake for non-standard use cases. - remove `+` prefix from targets. If the user for whatever reason wants to dry-run a target then they should be able to.
2024-01-01 05:08:56 -07:00
set(STYLUA_DIRS runtime scripts src test contrib)
build: various improvements - Use `#pragma once` for `cmake.config/config.h.in` - Remove unused variable `CACHED_GENERATED_DIR` - Reorganize and sort variables - Introduce `STYLUA_DIRS` variable to ensure the `formatlua` and `lintlua-stylua` operates on the same files. - Adjust variable scope to avoid using hacky directory properties. - Add more necessary runtime files as test dependencies
2023-12-17 07:40:09 -07:00
build: add EXCLUDE option to add_glob_target EXCLUDE filters out all elements containing regex, meaning it works on both files and directories. Also rename add_glob_targets to add_glob_target since only one target is being created.
2022-11-01 06:29:17 -07:00
add_glob_target(
feat(build): add_glob_target runs only on changed files #19070 The general idea is that add_glob_targets creates a "touch file", a dummy file that acts as a dependency in order to check which files are outdated since the last time the target was run. Remove RunUncrustify.cmake as it's no longer necessary. It was initially introduced to silence its noisy output. The per-file targets will suppress the noisy output from uncrustify, except for the very first run. Also remove DefCmdTarget.cmake since add_glob_target already incorporates its functionality.
2022-06-30 05:10:05 -07:00
TARGET lintlua-luacheck
build: create separate targets for nvim with and without runtime files This distinction is important for correct dependency management, as the nvim binary is used to create some runtime files. The nvim binary (and the target to build it) is thus called `nvim_bin` and the target to build all of nvim (binary+runtime) is called `nvim`.
2024-01-19 05:21:25 -07:00
COMMAND $<TARGET_FILE:nvim_bin>
refactor(build): derocksify luacheck
2023-09-05 02:49:08 -07:00
FLAGS -ll ${PROJECT_SOURCE_DIR}/test/lua_runner.lua ${CMAKE_BINARY_DIR}/usr luacheck -q
build: various improvements - Use `#pragma once` for `cmake.config/config.h.in` - Remove unused variable `CACHED_GENERATED_DIR` - Reorganize and sort variables - Introduce `STYLUA_DIRS` variable to ensure the `formatlua` and `lintlua-stylua` operates on the same files. - Adjust variable scope to avoid using hacky directory properties. - Add more necessary runtime files as test dependencies
2023-12-17 07:40:09 -07:00
GLOB_DIRS runtime scripts src test
feat(build): add_glob_target runs only on changed files #19070 The general idea is that add_glob_targets creates a "touch file", a dummy file that acts as a dependency in order to check which files are outdated since the last time the target was run. Remove RunUncrustify.cmake as it's no longer necessary. It was initially introduced to silence its noisy output. The per-file targets will suppress the noisy output from uncrustify, except for the very first run. Also remove DefCmdTarget.cmake since add_glob_target already incorporates its functionality.
2022-06-30 05:10:05 -07:00
GLOB_PAT *.lua
build: enable lintlua for test/ dir Problem: Not all Lua code is checked by stylua. Automating code-style is an important mechanism for reducing time spent on accidental (non-essential) complexity. Solution: - Enable stylua for entire `test/` directory. - Exclude these high-churn files until this issue is resolved: https://github.com/JohnnyMorganz/StyLua/issues/829 ``` test/functional/ui/decorations_spec.lua | 3560 ++++++++++++++++++++++++++++++++++++---------------- test/functional/ui/float_spec.lua | 5826 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------------------------- test/functional/ui/multigrid_spec.lua | 1349 ++++++++++++++------ ``` - Make surgical changes to these files (or add `stylua: ignore` in some small scopes) to improve the result: ``` test/functional/vimscript/msgpack_functions_spec.lua | 1414 +++++++++++++++------ test/functional/api/buffer_spec.lua | 1389 +++++++++++---------- test/functional/api/vim_spec.lua | 2740 +++++++++++++++++++++++----------------- ``` - These "high churn" files are NOT excluded because the changes are largely an improvement: ``` test/functional/plugin/lsp_spec.lua | 2198 ++++++++++++++++++--------------- test/functional/plugin/shada_spec.lua | 4078 +++++++++++++++++++++++++++++++++++------------------------- test/functional/ui/cmdline_spec.lua | 1199 +++++++++++------- test/functional/ui/popupmenu_spec.lua | 1267 +++++++++++-------- test/functional/ui/messages_spec.lua | 1643 +++++++++++++++--------- ``` - TODO: how to check "all directories"? With `GLOB_DIRS *` and `/.deps/` (or `.deps/`) in `.styluaignore`, Lua code in `.deps/` is still checked...
2023-12-07 04:19:35 -07:00
TOUCH_STRATEGY PER_DIR)
refactor(build): derocksify luacheck
2023-09-05 02:49:08 -07:00
add_dependencies(lintlua-luacheck lua-dev-deps)
feat(build): add_glob_target runs only on changed files #19070 The general idea is that add_glob_targets creates a "touch file", a dummy file that acts as a dependency in order to check which files are outdated since the last time the target was run. Remove RunUncrustify.cmake as it's no longer necessary. It was initially introduced to silence its noisy output. The per-file targets will suppress the noisy output from uncrustify, except for the very first run. Also remove DefCmdTarget.cmake since add_glob_target already incorporates its functionality.
2022-06-30 05:10:05 -07:00
build: use stylua with add_glob_target stylua version 0.19.0 has added the flag `--respect-ignores` which unbreaks stylua when used with add_glob_target. See eecddd24164c3c4a250aec25dbd760b283849981 for more context.
2023-11-12 09:20:39 -07:00
add_glob_target(
TARGET lintlua-stylua
COMMAND ${STYLUA_PRG}
FLAGS --color=always --check --respect-ignores
build: various improvements - Use `#pragma once` for `cmake.config/config.h.in` - Remove unused variable `CACHED_GENERATED_DIR` - Reorganize and sort variables - Introduce `STYLUA_DIRS` variable to ensure the `formatlua` and `lintlua-stylua` operates on the same files. - Adjust variable scope to avoid using hacky directory properties. - Add more necessary runtime files as test dependencies
2023-12-17 07:40:09 -07:00
GLOB_DIRS ${STYLUA_DIRS}
build: use stylua with add_glob_target stylua version 0.19.0 has added the flag `--respect-ignores` which unbreaks stylua when used with add_glob_target. See eecddd24164c3c4a250aec25dbd760b283849981 for more context.
2023-11-12 09:20:39 -07:00
GLOB_PAT *.lua
build: enable lintlua for test/ dir Problem: Not all Lua code is checked by stylua. Automating code-style is an important mechanism for reducing time spent on accidental (non-essential) complexity. Solution: - Enable stylua for entire `test/` directory. - Exclude these high-churn files until this issue is resolved: https://github.com/JohnnyMorganz/StyLua/issues/829 ``` test/functional/ui/decorations_spec.lua | 3560 ++++++++++++++++++++++++++++++++++++---------------- test/functional/ui/float_spec.lua | 5826 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------------------------- test/functional/ui/multigrid_spec.lua | 1349 ++++++++++++++------ ``` - Make surgical changes to these files (or add `stylua: ignore` in some small scopes) to improve the result: ``` test/functional/vimscript/msgpack_functions_spec.lua | 1414 +++++++++++++++------ test/functional/api/buffer_spec.lua | 1389 +++++++++++---------- test/functional/api/vim_spec.lua | 2740 +++++++++++++++++++++++----------------- ``` - These "high churn" files are NOT excluded because the changes are largely an improvement: ``` test/functional/plugin/lsp_spec.lua | 2198 ++++++++++++++++++--------------- test/functional/plugin/shada_spec.lua | 4078 +++++++++++++++++++++++++++++++++++------------------------- test/functional/ui/cmdline_spec.lua | 1199 +++++++++++------- test/functional/ui/popupmenu_spec.lua | 1267 +++++++++++-------- test/functional/ui/messages_spec.lua | 1643 +++++++++++++++--------- ``` - TODO: how to check "all directories"? With `GLOB_DIRS *` and `/.deps/` (or `.deps/`) in `.styluaignore`, Lua code in `.deps/` is still checked...
2023-12-07 04:19:35 -07:00
TOUCH_STRATEGY PER_DIR)
build: use stylua with add_glob_target stylua version 0.19.0 has added the flag `--respect-ignores` which unbreaks stylua when used with add_glob_target. See eecddd24164c3c4a250aec25dbd760b283849981 for more context.
2023-11-12 09:20:39 -07:00
feat(build): add_glob_target runs only on changed files #19070 The general idea is that add_glob_targets creates a "touch file", a dummy file that acts as a dependency in order to check which files are outdated since the last time the target was run. Remove RunUncrustify.cmake as it's no longer necessary. It was initially introduced to silence its noisy output. The per-file targets will suppress the noisy output from uncrustify, except for the very first run. Also remove DefCmdTarget.cmake since add_glob_target already incorporates its functionality.
2022-06-30 05:10:05 -07:00
add_custom_target(lintlua)
add_dependencies(lintlua lintlua-luacheck lintlua-stylua)
build(lint): fix luacheck not found #18940 Problem: Since 6d57bb89c1ee #18543, luacheck is not found on some systems when running the "lintlua" target. Solution: - Move the find_program() to the top-level CMakeLists.txt - Define a def_cmd_target() function with fewer assumptions than the old lint() function. - Move "lintuncrustify" to src/nvim/CMakeLists.txt so it can reuse the $LINT_NVIM_SOURCES already defined there. - Make the lint targets _fatal_ by default. There is little reason for the "lint" umbrella target defined in Makefile to exist if it's going to ignore the absence of the actual linters. - For now, keep the uncrustify call in a separate cmake script so that it can be silenced (too noisy).
2022-06-12 15:08:01 -07:00
build: add EXCLUDE option to add_glob_target EXCLUDE filters out all elements containing regex, meaning it works on both files and directories. Also rename add_glob_targets to add_glob_target since only one target is being created.
2022-11-01 06:29:17 -07:00
add_glob_target(
feat(build): add_glob_target runs only on changed files #19070 The general idea is that add_glob_targets creates a "touch file", a dummy file that acts as a dependency in order to check which files are outdated since the last time the target was run. Remove RunUncrustify.cmake as it's no longer necessary. It was initially introduced to silence its noisy output. The per-file targets will suppress the noisy output from uncrustify, except for the very first run. Also remove DefCmdTarget.cmake since add_glob_target already incorporates its functionality.
2022-06-30 05:10:05 -07:00
TARGET lintsh
COMMAND ${SHELLCHECK_PRG}
build(lint): add more shell scripts to lintsh
2022-10-30 05:50:41 -07:00
FLAGS -x -a
build: cmake cleanup (#22251) - Remove unused code - Use consistent casing. Variable names such as LibLuV_LIBRARIES is needlessly jarring, even if the name might be technically correct. - Use title casing for packages. find_package(unibilium) requires the find_module to be named "Findunibilium.cmake", which makes it harder to spot when scanning the files. Instead, use "Unibilium".
2023-03-02 14:50:43 -07:00
GLOB_DIRS scripts
build(lint): add more shell scripts to lintsh
2022-10-30 05:50:41 -07:00
GLOB_PAT *.sh
build: enable lintlua for test/ dir Problem: Not all Lua code is checked by stylua. Automating code-style is an important mechanism for reducing time spent on accidental (non-essential) complexity. Solution: - Enable stylua for entire `test/` directory. - Exclude these high-churn files until this issue is resolved: https://github.com/JohnnyMorganz/StyLua/issues/829 ``` test/functional/ui/decorations_spec.lua | 3560 ++++++++++++++++++++++++++++++++++++---------------- test/functional/ui/float_spec.lua | 5826 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------------------------- test/functional/ui/multigrid_spec.lua | 1349 ++++++++++++++------ ``` - Make surgical changes to these files (or add `stylua: ignore` in some small scopes) to improve the result: ``` test/functional/vimscript/msgpack_functions_spec.lua | 1414 +++++++++++++++------ test/functional/api/buffer_spec.lua | 1389 +++++++++++---------- test/functional/api/vim_spec.lua | 2740 +++++++++++++++++++++++----------------- ``` - These "high churn" files are NOT excluded because the changes are largely an improvement: ``` test/functional/plugin/lsp_spec.lua | 2198 ++++++++++++++++++--------------- test/functional/plugin/shada_spec.lua | 4078 +++++++++++++++++++++++++++++++++++------------------------- test/functional/ui/cmdline_spec.lua | 1199 +++++++++++------- test/functional/ui/popupmenu_spec.lua | 1267 +++++++++++-------- test/functional/ui/messages_spec.lua | 1643 +++++++++++++++--------- ``` - TODO: how to check "all directories"? With `GLOB_DIRS *` and `/.deps/` (or `.deps/`) in `.styluaignore`, Lua code in `.deps/` is still checked...
2023-12-07 04:19:35 -07:00
TOUCH_STRATEGY PER_DIR)
build: install with the correct permissions The install() command will create the parent directories, but it does so with the user's umask. We want to do our best to make sure the correct permissions are being set, without clobbering existing permissions. To do this, this commit introduces an install_helper(), which is similar in signature to the install() command, to help ensure that directories are created ahead of the actual install() command. This will attempt to use 0644 permissions for files and 0755 permissions for directories by default--though they can be overridden. To make this work correctly, without trying to introduce some mechanism with setting the umask, it meant that there's a small portion that makes use of an "internal" version of the file() command. It has been tested on CMake 2.8.11, 2.8.12, and 3.0.2, and works correctly on all versions. This fixes #1201 and #1086.
2014-09-19 04:37:22 -07:00
build: move lint target to cmake #19169 This will ensure less verbose output and faster linting.
2022-07-01 09:15:04 -07:00
add_custom_target(lintcommit
build: create separate targets for nvim with and without runtime files This distinction is important for correct dependency management, as the nvim binary is used to create some runtime files. The nvim binary (and the target to build it) is thus called `nvim_bin` and the target to build all of nvim (binary+runtime) is called `nvim`.
2024-01-19 05:21:25 -07:00
COMMAND $<TARGET_FILE:nvim_bin> -u NONE -l ${PROJECT_SOURCE_DIR}/scripts/lintcommit.lua main)
add_dependencies(lintcommit nvim_bin)
build: move lint target to cmake #19169 This will ensure less verbose output and faster linting.
2022-07-01 09:15:04 -07:00
add_custom_target(lint)
build(docs): separate lint job to validate vimdoc #27227 Summary: Separate the lint job (`make lintdoc`) to validate runtime/doc, it is no longer as a part of functionaltest (help_spec). Build (cmake) and CI: - `make lintdoc`: validate vimdoc files and test-generate HTML docs. CI will run this as a part of the "docs" workflow. - `scripts/lintdoc.lua` is added as an entry point (executable script) for validating vimdoc files. scripts/gen_help_html.lua: - Move the tests for validating docs and generating HTMLs from `help_spec.lua` to `gen_help_html`. Added: - `gen_help_html.run_validate()`. - `gen_help_html.test_gen()`. - Do not hard-code `help_dir` to `build/runtime/doc`, but resolve from `$VIMRUNTIME`. Therefore, the `make lintdoc` job will check doc files on `./runtime/doc`, not on `./build/runtime/doc`. - Add type annotations for gen_help_html.
2024-01-28 15:22:39 -07:00
add_dependencies(lint lintc lintlua lintsh lintcommit lintdoc)
build: move lint target to cmake #19169 This will ensure less verbose output and faster linting.
2022-07-01 09:15:04 -07:00
build: add formatting targets for c and lua files (#19488) The targets will only format files that have been changed in current branch compared to the master branch. This includes unstaged, staged and committed files. Add following make and cmake targets: formatc - format changed c files formatlua - format changed lua files format - run formatc and formatlua Remove scripts/uncrustify.sh as this deprecates it.
2022-08-02 03:32:57 -07:00
# Format
build: rework formatting to use add_glob_target This will ensure that we can pass flags and make adjustments from the top level cmake file instead of digging through the cmake directory. More importantly, this will only format files that have been changed. This has a slightly higher initial cost compared to previous solution as all files must be initially formatted, but the gained speed up should more than make up for it quickly. `make formatlua` is always run due to a quirk of stylua of always changing modification time of the file regardless if there were any changes. This is not a major blocker as stylua is very fast.
2023-12-04 12:21:38 -07:00
add_glob_target(
TARGET formatlua
COMMAND ${STYLUA_PRG}
FLAGS --respect-ignores
build: various improvements - Use `#pragma once` for `cmake.config/config.h.in` - Remove unused variable `CACHED_GENERATED_DIR` - Reorganize and sort variables - Introduce `STYLUA_DIRS` variable to ensure the `formatlua` and `lintlua-stylua` operates on the same files. - Adjust variable scope to avoid using hacky directory properties. - Add more necessary runtime files as test dependencies
2023-12-17 07:40:09 -07:00
GLOB_DIRS ${STYLUA_DIRS}
build: enable lintlua for test/ dir Problem: Not all Lua code is checked by stylua. Automating code-style is an important mechanism for reducing time spent on accidental (non-essential) complexity. Solution: - Enable stylua for entire `test/` directory. - Exclude these high-churn files until this issue is resolved: https://github.com/JohnnyMorganz/StyLua/issues/829 ``` test/functional/ui/decorations_spec.lua | 3560 ++++++++++++++++++++++++++++++++++++---------------- test/functional/ui/float_spec.lua | 5826 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------------------------- test/functional/ui/multigrid_spec.lua | 1349 ++++++++++++++------ ``` - Make surgical changes to these files (or add `stylua: ignore` in some small scopes) to improve the result: ``` test/functional/vimscript/msgpack_functions_spec.lua | 1414 +++++++++++++++------ test/functional/api/buffer_spec.lua | 1389 +++++++++++---------- test/functional/api/vim_spec.lua | 2740 +++++++++++++++++++++++----------------- ``` - These "high churn" files are NOT excluded because the changes are largely an improvement: ``` test/functional/plugin/lsp_spec.lua | 2198 ++++++++++++++++++--------------- test/functional/plugin/shada_spec.lua | 4078 +++++++++++++++++++++++++++++++++++------------------------- test/functional/ui/cmdline_spec.lua | 1199 +++++++++++------- test/functional/ui/popupmenu_spec.lua | 1267 +++++++++++-------- test/functional/ui/messages_spec.lua | 1643 +++++++++++++++--------- ``` - TODO: how to check "all directories"? With `GLOB_DIRS *` and `/.deps/` (or `.deps/`) in `.styluaignore`, Lua code in `.deps/` is still checked...
2023-12-07 04:19:35 -07:00
GLOB_PAT *.lua
TOUCH_STRATEGY PER_DIR)
build: add formatting targets for c and lua files (#19488) The targets will only format files that have been changed in current branch compared to the master branch. This includes unstaged, staged and committed files. Add following make and cmake targets: formatc - format changed c files formatlua - format changed lua files format - run formatc and formatlua Remove scripts/uncrustify.sh as this deprecates it.
2022-08-02 03:32:57 -07:00
add_custom_target(format)
add_dependencies(format formatc formatlua)
Build: Use GNUInstallDirs, install man pages #2649 For now, only install man pages matching "nvim*.1": we don't want to install xxd.1 as it might conflict with that of a user's Vim installation. closes #1826 Reviewed-by: Florian Walch <florian@fwalch.com> Helped-by: John Szakmeister <john@szakmeister.net>
2015-05-17 11:45:30 -07:00
install_helper(
build: move man/ to src/man/ #19119 Problem: man/ contains source files for manpage generation, it doesn't need to live at the project root. Solution: Move it to src/man/.
2022-06-27 01:02:02 -07:00
FILES ${CMAKE_SOURCE_DIR}/src/man/nvim.1
Build: Use GNUInstallDirs, install man pages #2649 For now, only install man pages matching "nvim*.1": we don't want to install xxd.1 as it might conflict with that of a user's Vim installation. closes #1826 Reviewed-by: Florian Walch <florian@fwalch.com> Helped-by: John Szakmeister <john@szakmeister.net>
2015-05-17 11:45:30 -07:00
DESTINATION ${CMAKE_INSTALL_MANDIR}/man1)
build: create separate targets for nvim with and without runtime files This distinction is important for correct dependency management, as the nvim binary is used to create some runtime files. The nvim binary (and the target to build it) is thus called `nvim_bin` and the target to build all of nvim (binary+runtime) is called `nvim`.
2024-01-19 05:21:25 -07:00
add_custom_target(nvim ALL)
add_dependencies(nvim nvim_bin nvim_runtime_deps nvim_runtime)
build: install with the correct permissions The install() command will create the parent directories, but it does so with the user's umask. We want to do our best to make sure the correct permissions are being set, without clobbering existing permissions. To do this, this commit introduces an install_helper(), which is similar in signature to the install() command, to help ensure that directories are created ahead of the actual install() command. This will attempt to use 0644 permissions for files and 0755 permissions for directories by default--though they can be overridden. To make this work correctly, without trying to introduce some mechanism with setting the umask, it meant that there's a small portion that makes use of an "internal" version of the file() command. It has been tested on CMake 2.8.11, 2.8.12, and 3.0.2, and works correctly on all versions. This fixes #1201 and #1086.
2014-09-19 04:37:22 -07:00
add_subdirectory(src/nvim)
build: rename build-related dirs Problem: Dirs "config", "packaging", and "third-party" are all closely related but this is not obvious from the layout. This adds friction for new contributors. Solution: - rename config/ to cmake.config/ - rename test/config/ to test/cmakeconfig/ because it is used in Lua tests: require('test.cmakeconfig.paths'). - rename packaging/ to cmake.packaging/ - rename third-party/ to cmake.deps/ (parallel with .deps/)
2022-06-27 03:08:59 -07:00
add_subdirectory(cmake.config)
cmake: Generate tags and some vim syntax elements
2015-04-02 09:45:34 -07:00
add_subdirectory(runtime)
build: create test/CMakeLists.txt and move test-related code (#22179) Having a clear separation between build code and test code makes it easier to get a higher-level understanding of how the neovim build works.
2023-02-08 15:46:39 -07:00
add_subdirectory(test)
job: Allow spawning jobs connected to pseudo terminals
2015-02-23 08:34:20 -07:00
build(cmake): simplify and speed up the uninstall target More specifically, replace exec_program with file(REMOVE ...) so that the uninstall target is run during the build stage instead of the configure stage, significantly speeding up the target. The code snippet that was removed is taken from the cmake FAQ https://gitlab.kitware.com/cmake/community/-/wikis/FAQ#can-i-do-make-uninstall-with-cmake. However, this uses undocumented features such as IMMEDIATE when calling configure_file, which is an artifact from cmake 2.x (it's so old it's difficult to find information on it). Similarly, this particular code snippet has been around for a long time and originated from the cmake mailing lists. Based on this I believe the in-file was a workaround for the limitations of cmake back then and that it's not required anymore.
2022-06-17 05:11:08 -07:00
add_custom_target(uninstall
COMMAND ${CMAKE_COMMAND} -P ${PROJECT_SOURCE_DIR}/cmake/UninstallHelper.cmake)
ci: improved cpack packaging Addresses: #12571 - Added the following installers through CMake files: - Windows NSIS. - Windows MSI. - Windows zip. - MacOs tarball. - Linux tarball. - Linux Deb package. - Tweaked pipeline CPack commands to build using new CMakeLists.txt configuration file. - Added icons and relevant packaging files. - Updated notes.md to reflect new installation instructions. This isn't meant to be the perfect solution, it's simply a first pass at using a simple packaging system to build Windows installers. A Debian package has also been added since it's very easy but other packages have been left out due to limiting the scope. Hopefully we can build further upon this and improve it over time with code signing, better icons and more user-friendly installation graphics and so on.
2022-02-07 13:49:09 -07:00
if(${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_CURRENT_SOURCE_DIR})
build: rename build-related dirs Problem: Dirs "config", "packaging", and "third-party" are all closely related but this is not obvious from the layout. This adds friction for new contributors. Solution: - rename config/ to cmake.config/ - rename test/config/ to test/cmakeconfig/ because it is used in Lua tests: require('test.cmakeconfig.paths'). - rename packaging/ to cmake.packaging/ - rename third-party/ to cmake.deps/ (parallel with .deps/)
2022-06-27 03:08:59 -07:00
add_subdirectory(cmake.packaging)
ci: improved cpack packaging Addresses: #12571 - Added the following installers through CMake files: - Windows NSIS. - Windows MSI. - Windows zip. - MacOs tarball. - Linux tarball. - Linux Deb package. - Tweaked pipeline CPack commands to build using new CMakeLists.txt configuration file. - Added icons and relevant packaging files. - Updated notes.md to reflect new installation instructions. This isn't meant to be the perfect solution, it's simply a first pass at using a simple packaging system to build Windows installers. A Debian package has also been added since it's very easy but other packages have been left out due to limiting the scope. Hopefully we can build further upon this and improve it over time with code signing, better icons and more user-friendly installation graphics and so on.
2022-02-07 13:49:09 -07:00
endif()
build: bundle uncrustify Uncrustify is sensitive to version changes, which causes friction for contributors that doesn't have that exact version. It's also simpler to download and install the correct version than to have bespoke version checking.
2023-05-18 07:27:47 -07:00
ExternalProject_Add(uncrustify
build: bump uncrustify to version 0.78.1
2023-11-20 07:11:44 -07:00
URL https://github.com/uncrustify/uncrustify/archive/uncrustify-0.78.1.tar.gz
URL_HASH SHA256=ecaf4c0adca14c36dfffa30bc28e69865115ecd602c90eb16a8cddccb41caad2
build: bundle uncrustify Uncrustify is sensitive to version changes, which causes friction for contributors that doesn't have that exact version. It's also simpler to download and install the correct version than to have bespoke version checking.
2023-05-18 07:27:47 -07:00
DOWNLOAD_DIR ${DEPS_DOWNLOAD_DIR}/uncrustify
CMAKE_ARGS ${DEPS_CMAKE_ARGS}
CMAKE_CACHE_ARGS ${DEPS_CMAKE_CACHE_ARGS}
build: cmake fixes - add EXTERNALPROJECT_OPTIONS variable to main build - use `REQUIRED` keyword for IWYU. - remove check_c_compiler_flag checks when `ENABLE_COMPILER_SUGGESTIONS` is `ON`. If we explicitly enable it then we probably want it to give an error if it doesn't exist, rather than silently skip it. - Move dependency interface libraries to their find module and use them as a pseudo-imported target. - Remove BUSTED_OUTPUT_TYPE. It's not used and we can reintroduce it again if something similar is needed. - Use LINK_OPTIONS intead of LINK_FLAGS when generating the `--version` output.
2023-11-24 05:28:15 -07:00
EXCLUDE_FROM_ALL TRUE
${EXTERNALPROJECT_OPTIONS})
build: move luarocks and rocks installation to main build This will ensure luacheck and busted are only installed when they're actually needed. This cuts total build time by over 50%. Closes https://github.com/neovim/neovim/issues/22797.
2023-05-21 11:57:39 -07:00
build: various cmake fixes - Correct MSVC warning suppression. The C4003 warning is issued during file generation and not for the actual source files. - Remove non-existent "scripts/pvscheck.sh" file from `lintsh` target. - Remove spaces inside for loops with uncrustify. - Point dependencies to use a git tag rather than releases, as releases might have changes that deviate from the actual source code. - Automatically update uncrustify config before formatting or linting.
2023-11-07 01:52:20 -07:00
option(USE_BUNDLED_BUSTED "Use bundled busted" ON)
build: allow using system rocks This allow distributions and other interested parties to use a system busted rather than the on neovim bundles by passing the -D USE_BUNDLED_BUSTED=ON flag to cmake when building. Closes https://github.com/neovim/neovim/issues/23814.
2023-05-29 09:45:08 -07:00
if(USE_BUNDLED_BUSTED)
ExternalProject_Add(lua-dev-deps
URL https://github.com/neovim/deps/raw/5a1f71cceb24990a0b15fd9a472a5f549f019248/opt/lua-dev-deps.tar.gz
URL_HASH SHA256=27db2495f5eddc7fc191701ec9b291486853530c6125609d3197d03481e8d5a2
DOWNLOAD_DIR ${DEPS_DOWNLOAD_DIR}/lua-dev-deps
SOURCE_DIR ${DEPS_SHARE_DIR}
CONFIGURE_COMMAND ""
BUILD_COMMAND ""
INSTALL_COMMAND ""
build: cmake fixes - add EXTERNALPROJECT_OPTIONS variable to main build - use `REQUIRED` keyword for IWYU. - remove check_c_compiler_flag checks when `ENABLE_COMPILER_SUGGESTIONS` is `ON`. If we explicitly enable it then we probably want it to give an error if it doesn't exist, rather than silently skip it. - Move dependency interface libraries to their find module and use them as a pseudo-imported target. - Remove BUSTED_OUTPUT_TYPE. It's not used and we can reintroduce it again if something similar is needed. - Use LINK_OPTIONS intead of LINK_FLAGS when generating the `--version` output.
2023-11-24 05:28:15 -07:00
EXCLUDE_FROM_ALL TRUE
${EXTERNALPROJECT_OPTIONS})
build: allow using system rocks This allow distributions and other interested parties to use a system busted rather than the on neovim bundles by passing the -D USE_BUNDLED_BUSTED=ON flag to cmake when building. Closes https://github.com/neovim/neovim/issues/23814.
2023-05-29 09:45:08 -07:00
else()
add_custom_target(lua-dev-deps)
endif()
Reference in New Issue Copy Permalink