You are viewing the documentation for the develop branch. The documentation for the release version is here .

CMake layer

Table of ContentsClose

1. Description
- 1.1. Features:
2. Install
3. Configuration
- 3.1. Choosing a backend
  - 3.1.1. Company-cmake
  - 3.1.2. LSP
- 3.2. CMake-ide
4. Key bindings

1. Description

This layer adds support CMake scripts.

1.1. Features:

Syntax highlighting
Auto-completion
Support for CMake configure/build (with limited support for other build systems) and automatic generation of compile_commands.json (compile flags).
Run selected test using Helm interface via helm-ctest.
Extraction of compile parameters from compile_commands.json with cmake-ide

2. Install

To use this configuration layer, add it to your ~/.spacemacs. You will need to add cmake to the existing dotspacemacs-configuration-layers list in this file.

3. Configuration

All layer configurations can be done by setting layer variables in your dotfile. No custom user config lines are necessary

3.1. Choosing a backend

This layer provides two alternative backends to choose from.

3.1.1. Company-cmake

This is the default choice if nothing is set and no lsp layer is loaded in your dotfile. This mode only provides very limited IDE capabilities. Used best if only small scripts are edited. To set explicitly set the following in your dotfile:

(cmake :variables cmake-backend 'company-cmake)

3.1.2. LSP

For proper IDE support this backend should be used. It is based on an external server which will be started automatically by emacs, once a cmake file is opened. The key bindings are the same for all lsp modes so if you are already familiar with one you should be able to work the same in all modes.

To set explicitly do the following in your dotfile:

(cmake :variables
        cmake-backend 'lsp)

For this to work you will also need to obtain the latest version of the lsp server from here.

You can also simply install it with pip:

pip install cmake-language-server

NOTE: Key bindings for LSP are defined in the LSP layer. Also it is advisable to have a look at the autocomplete layer for an optimal intellisense config for LSP.

3.2. CMake-ide

To enable CMake projects support set the layer variable cmake-enable-cmake-ide-support to t in your dotfile:

(setq-default dotspacemacs-configuration-layers
  '((cmake :variables cmake-enable-cmake-ide-support t)))

cmake-ide plugin has several useful configuration options. Normally all should just work well as long as there is a standard cmake compilation database available. If not some manual configuration may be necessary. Details can be found below.

To configure a project you need to create .dir-locals.el file. In case of using make as CMake backend you can use helm-make to select required build target.

Here is a sample configuration. This configuration forces cmake-ide to use the local directory and pass that directory to helm-make. Such config allows to build your project with SPC c c key binding.

Additionally it's possible to configure helm-ctest in the same way via defining helm-ctest-dir. Trailing slash is required.

((nil .
      ((cmake-ide-project-dir . "~/Project")
       (cmake-ide-build-dir . "~/Project/build")
       (cmake-ide-cmake-opts . "-DCMAKE_BUILD_TYPE=Debug")
       (helm-make-build-dir . "build")
       (helm-make-arguments . "-j7")
       (helm-ctest-dir . "~/Project/build/")
       )))

In case of projectile it's possible to configure project like:

((nil . ((eval . (setq
                  projectile-project-test-cmd #'helm-ctest
                  projectile-project-compilation-cmd #'helm-make-projectile
                  projectile-project-compilation-dir "build"
                  helm-make-build-dir (projectile-compilation-dir)
                  helm-ctest-dir (projectile-compilation-dir)
                  ))
         (projectile-project-name . "My Cool Project")
         (projectile-project-run-cmd . "./run.sh")
         (projectile-project-configure-cmd . "cmake -DCMAKE_BUILD_TYPE=Debug -DCMAKE_EXPORT_COMPILE_COMMANDS=ON ..")
         (helm-make-arguments . "-j7"))))

4. Key bindings

Key binding	Description
`SPC m p c`	Run CMake and set compiler flags for auto-completion and flycheck
`SPC m p C`	Run CMake if compilation database JSON file is not found
`SPC m p d`	Remove file connected to current buffer and kill buffer, then run CMake
`SPC m p t`	Run CTest