spacemacs/layers/+lang/c-c++/README.org

C/C++ layer

• Description
  • Features:
• Install
  • Layer
  • Default mode for header files
  • Enable Clang support
    • clang-format
    • Company-clang and flycheck
  • CMake configuration
• Key Bindings
  • Debugger (realgud)

Description

This layer adds configuration for C/C++ language as well support for CMake scripts.

Features:

• Support syntax checking via flycheck with Clang.
• Support for disassembly of code with disaster.
• Support code reformatting with clang-format.
• Display function or variable definition at the bottom. (when semantic layer is included)
• Display current function cursor is in at the top. See stickyfunc-demos for demos in some programming languages. (when semantic layer is included)
• Support common refactoring with semantic-refactor . See srefactor-demos for demonstration of refactoring features. (when semantic layer is included)
• Support code navigation via cscope (when cscope layer is included) and gtags.
• Support auto-completion (when auto-completion layer is included) via company-clang (when c-c++-enable-clang-support is turned on), or company-ycmd (when ycmd layer is included).
• Support for realgud debugger.
• Support for CMake configure/build (with limited support for other build systems), automatic generation of compile_commands.json (compile flags), on-the-fly configuration of flycheck, company-clang and RTags (if installed) with cmake-ide .

Install

Layer

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

Note: semantic-refactor is only available for Emacs 24.4+

Default mode for header files

By default header files are opened in c-mode, you can open them in c++-mode by setting the variable c-c++-default-mode-for-headers to c++-mode.

  (setq-default dotspacemacs-configuration-layers
    '((c-c++ :variables
             c-c++-default-mode-for-headers 'c++-mode)))

Note: To set the variable for a given project, create a directory local variable at the root of your project. More info on directory local variables can be found in the dir-locals.

Enable Clang support

To enable Clang support set the layer variable c-c++-enable-clang-support to t in the dotfile:

  (setq-default dotspacemacs-configuration-layers
    '((c-c++ :variables c-c++-enable-clang-support t)))

clang-format

clang-format allows reformatting either a selected region of code (clang-format-region) or a whole buffer (clang-format-buffer) to make it conform to a style defined in a .clang-format file. This file is either located in the same directory as the file being edited, or in any of its parent directories (otherwise a default style will be used).

You can add snippets similar to the following to bind clang-format to either a particular mode or all modes in your dotspacemacs/user-config (within your ~/.spacemacs):

  ;; Bind clang-format-region to C-M-tab in all modes:
  (global-set-key [C-M-tab] 'clang-format-region)
  ;; Bind clang-format-buffer to tab on the c++-mode only:
  (add-hook 'c++-mode-hook 'clang-format-bindings
            (defun clang-format-bindings ()
              (define-key c++-mode-map [tab] 'clang-format-buffer)))

To enable automatic buffer formatting on save, set the variable c-c++-enable-clang-format-on-save to t:

  (setq-default dotspacemacs-configuration-layers '(
    (c-c++ :variables c-c++-enable-clang-format-on-save t)))

Company-clang and flycheck

This layer adds some fancy improvements to company-clang. It includes a hook to load a projects .clang_complete file, which is just a text file with one clang flag per line, a format also used by other text editor clang plugins.

Not only does this allow proper autocomplete on projects with extra includes and flags, but there is also support for flycheck so that it doesn't complain about missing header files.

CMake configuration

cmake-ide plugin works out of the box, but there are few useful configuration options.

To configure 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.

((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"))))

Key Bindings

Key Binding	Description
SPC m g a	open matching file (e.g. switch between .cpp and .h)
SPC m g A	open matching file in another window (e.g. switch between .cpp and .h)
SPC m D	disaster: disassemble c/c++ code
SPC m r	srefactor: refactor thing at point.
SPC m p c	Run CMake and set compiler flags for auto-completionand 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 c c	Compile project

Note: semantic-refactor is only available for Emacs 24.4+

Debugger (realgud)

Key Binding	Description
SPC m d d	open cmd buffer
SPC m d e	eval variable
s	step over
i	step into
b	set break
B	unset break
o	step out
c	continue
e	eval variable
r	restart
q	quit debug
S	goto cmd buffer