cpputils-cmake.el (v0.4.14)

cpputils-cmake automatically enable real time syntax check (Flymake) and IntelliSense (auto-complete+auto-complete-clang, company-mode) if you use CMake.

It does all the configuration dirty job automatically for you. So you can use Flymake, Flycheck, auto-complete, auto-complete-clang, company-mode, compile, ff-find-other-file (if you press `C-x C-o` in C/C++ file, ff-find-other-file will open correct header file under cursor) with almost no configuration.

Key points before you continue:

• It’s lightweight.
• easy to use, copy the elisp code from “Set up” section into you ~/.emacs. DONE! Use Emacs as usual and ignore advanced tips in remaining sections.
• cpputils-cmake will configure many third party plugins automatically for you. But it’s NOT dependent on those plugins. Only CMake is required.

Install

easy way

cpputils-cmake is available at https://github.com/milkypostman/melpa.

The best way to install is using Emacs package manager.

manual way

If you don’t use package manager, you only need download cpputils-cmake.el and put it somewhere (say ~/.emacs/lisp), then add below code into your .emacs:

(add-to-list 'load-path "~/.emacs.d/lisp/")
(require 'cpputils-cmake)

Set up

Paste below code into your .emacs:

(add-hook 'c-mode-common-hook
          (lambda ()
            (if (derived-mode-p 'c-mode 'c++-mode)
                (cppcm-reload-all)
              )))
;; OPTIONAL, somebody reported that they can use this package with Fortran
(add-hook 'c90-mode-hook (lambda () (cppcm-reload-all)))
;; OPTIONAL, avoid typing full path when starting gdb
(global-set-key (kbd "C-c C-g")
 '(lambda ()(interactive) (gud-gdb (concat "gdb --fullname " (cppcm-get-exe-path-current-buffer)))))
;; OPTIONAL, some users need specify extra flags forwarded to compiler
(setq cppcm-extra-preprocss-flags-from-user '("-I/usr/src/linux/include" "-DNDEBUG"))

WARNING: cpputils-cmake assumes that CMakeLists.txt contains a rule to create executable.

The rule is either “add_executable” or “add_library”.

You can include some common.cmake in CMakeLists.txt. But don’t put “add_executable” or “add_library” into common.cmake because cpputils-cmake will ignore any included *.cmake.

A sample CMakeLists.txt:

set(TGT "main")
add_executable(${TGT} ${SOURCES})

Another CMakeLists.txt:

project(main)
add_executable(${PROJECT_NAME} ${SOURCES})

One minute step by step tutorial

one line bash to create “hello” project

mkdir -p hello/src;printf "#include <stdio.h>\nint main(void) {\nprintf(\"hello world\");\nreturn 0;\n}" > hello/src/main.cpp;printf "cmake_minimum_required(VERSION 2.6)\nadd_executable(main main.cpp)" > hello/src/CMakeLists.txt

use cmake as usual

Please note you need run “Make” at least once before using cpputils-cmake:

mkdir hello/build;cd hello/build;cmake ../src;make clean;make

If you use another directory name like “mybuild” instead of “build”, you must add following line into your .emacs:

(setq cppcm-build-dirname "mybuild")

flymake

Open C++ file. Run “M-x flymake-mode”. Please note all commands are available ONLY when you editing/debugging C/C++ code!

Now typing some random C++ code and watch the real time hint on your syntax errors.

If you don’t want to use flymake, you can tell cpputils-cmake NOT to create Makefile for flyemake by inserting below code into ~/.emacs:

(setq cppcm-write-flymake-makefile nil)

flycheck

See https://github.com/flycheck/flycheck for flycheck setup. No set up needed here.

compile

Compile the program: `M-x compile`

You can see the default command line displayed in minibuffer is `make -C ~/your-projects-blah-blah/hello/build`

BTW, you can also run the command `M-x cppcm-compile` to compile the current excutable only.

You can see the actual command displayed in minibuffer is `make -C ~/your-project-blah-blah/hello/build/sub-project-dir-if-your-are-editing-its-cpp-file`

start gdb

Press hot key `C-c C-g` (suppose you’ve copied my configuration from previous section).

You can see the gud-gdb starts and the executable “~/your-projects-blah-blah/hello/build/main” is loaded automatically.

auto-complete & auto-complete-clang (OPTIONAL)

Use them as usual. You can see that the Intellisense/auto-complete is more precise.

company-mode (OPTIONAL)

Use them as usual. You can see that the Intellisense/auto-complete is more precise.

open header file

Press the hot key `C-x C-o` or `M-x ff-find-other-file`. The corresponding header file is opened correctly.

This is the default feature of Emacs. What cpputils-cmake does is set up the directories of those header files for you automatically so that the header files could be found by Emacs.

Tips

avoid scanning when opening system header files

cpputils-cmake scanning is light weight enough so below code is optional:

(add-hook 'c-mode-common-hook
          (lambda ()
            (if (derived-mode-p 'c-mode 'c++-mode)
                (if  (not (or (string-match "^/usr/local/include/.*" buffer-file-name)
                              (string-match "^/usr/src/linux/include/.*" buffer-file-name)))
                    (cppcm-reload-all))
              )))

get full path of target

The command “cppcm-get-exe-path-current-buffer” will copy current executable into kill ring AND OS clipboard.

You need install `xsel` under Linux to support OS clipboard.

This could be useful if you need access the executable’s directory.

You can yank (paste) the full path to eshell or minibuffer and press “M-backspace” to get the directory name.

reload cpputils-cmake

You can always `M-x cppcm-reload-all` at any time.

There is also `cppcm-reload-all-hook` which will be called after `cppcm-reload-all`. This give you a chance to tweak or override the set up.

Here is the list of global variables third party plugins will use (and you can tweak):

variable name	plugin/command name
ac-clang-flags	auto-complete-clang
company-clang-arguments	company-mode
cc-search-directories	ff-find-other-file
flycheck-clang-include-path	flycheck

compile only current target

“M-x cppcm-compile”.

Please press “C-h v cppcm-compile-list” for other compile options.

make clean && make

“M-x cppcm-recompile”

Credits

• David Ojeda (AKA dojeda) developed the algorithm to locate the top level project.
• Ernesto Rodriguez Reina (AKA erreina) added the command “cppcm-recompile”.
• Jack Morrison (AKA chachi) added support for Flycheck

Bug Report

Check https://github.com/redguardtoo/cpputils-cmake.

Here is the steps to send bug report:

• open cpp file in your real project
• `M-x eval-expression`
• paste (setq cppcm-debug t) into mini-buffer and press ENTER
• `M-x cppcm-reload-all` and send me the output in Message buffer
• `C-h v cppcm-hash` and send me the output
• `M-x cppcm-version` and send the output

Besides, I still need general environment information like Emacs version and OS version.

License

Copyright (C) 2012 Chen Bin

Author: Chen Bin <chenbin DOT sh AT gmail DOT com> Keywords: flymake IntelliSense cmake

This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.