RTags 使用

M-: (load-file "rtags.el") RET

M-x set-variable RET rtags-path RET "../bin" RET

M-x rtags-find-symbol-at-point RET

当前未知就是 Server::instance() 的定义。

ninja -t compdb cxx cc > compile_commands.json
rc -J

With ninja it’s also possible to pipe the commands directly to rc.

使用 ninja 可以使用管道命令直接输出到 rc。

ninja -t commands | rc -c -
# Parse commands for a specific target only
ninja -t commands rdm | rc -c -

cmake can generate a compile_commands.json file as well.

cmake 也能生成 compile_commands.json。

cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=1 .
rc -J

For other projects you can use bear to generate a compile_commands.json file. However, if you are cross-compiling you probably need to adjust the command entries in the compile_commands.json file to match the correct compiler. Furthermore, make sure you clean your project before invoking bear.

对于其他项目也可以使用 bear 生成 compile_commands.json 文件。然而，交叉编译可能需要调整 compile_command.json 文件中的命令条目来匹配正确的编译器。此外，调用 bear 之前确保清理了工程。

make clean
bear make
rc -J
# Parse commands for a specific target only
make clean
bear make rdm
rc -J

You can ask make to only print the recipes without actually doing something. This way may be perfectly fine for not too complex Makefiles.

可以让 make 只打印信息而不执行任何事情。这种方式可能对于不是很复杂的 makefile 有用。

make clean
make -nk | rc -c -

There are very likely similar things you can do with other build systems that we’re unfamiliar with, please let us know if you do.

其他一些我们不熟悉的构建系统很可能做类似的事情，如果愿意的话，请告诉我们。

A different approach to get your files indexed is the man-in-the-middle

索引文件的另一种方法是中间人，可以这样做：

ln -s /path/to/rtags/bin/gcc-rtags-wrapper.sh /somewhere/that/is/in/your/path/before/usr/bin/gcc
ln -s /path/to/rtags/bin/gcc-rtags-wrapper.sh /somewhere/that/is/in/your/path/before/usr/bin/c++
ln -s /path/to/rtags/bin/gcc-rtags-wrapper.sh /somewhere/that/is/in/your/path/before/usr/bin/cc
ln -s /path/to/rtags/bin/gcc-rtags-wrapper.sh /somewhere/that/is/in/your/path/before/usr/bin/g++

例如：

which -a gcc | xargs file
/home/abakken/bin/gcc: symbolic link to `/home/abakken/dev/rtags/bin/gcc-rtags-wrapper.sh'
/usr/bin/gcc:         symbolic link to `gcc-4.7'

Now every time you compile a file with which gcc rc will get its grubby hands all over your command line and make sure RTags knows about it.

现在每次使用 which gcc 编译文件，rc 都会处理你所有的命令行，以确保 RTage 知道。

RTags will group source files into projects based on some heuristics.

RTags 基于一些启发式会将工程中的源码文件分组。

Essentially it will look for certain files/dirs (like configure/CMakeLists.txt/scons.1/.git) etc to try to determine the likely project root for each source file. For generated source files that end up in the build directory we try to find the source root based on similar heuristics around config.status/CMakeCache.txt etc. Usually this works out reasonably well. If it doesn’t for you, you can pass –project-root /path/to/the/project/root to rc.

本质上它会查看特定文件/目录（比如 configure/CMakeLists.txt/scons.1/.git）等来尝试确定每个源码文件的可能的项目根目录。也会尝试根据源码在编译目录中生成的 config.status/CMakeCache.txt 等找到源码根目录。这通常可以很好的解决问题。如果不适合你，可以给 rc 传递 --project-root /path/to/the/project/root 。

RTags only gives you information about current project when you ask for things by name. You can explicitly change the current project using:

当通过名字查询时，Rtags 只会给出和当前工程有关的信息。使用如下命令可以显示改变当前工程：

rc -w foobar

We try to do it automatically for you by passing along information about the current buffer when we call rc from elisp so that rdm can update its current project on demand.

当从 elisp 调用 rc 时，将尝试自动传递当前 buffer 的信息，以便 rdm 可以根据需求自动更新它当前的项目，

RTags keeps a cache of indexed data so you don’t have to reindex everything if you restart it.

RTags 缓存了索引数据，因而重启后无需重建索引。

The location of this data is by default ~/.rtags but can be overridden by passing –data-dir other/dir to rdm or putting something like this in your ~.rdmrc:

数据的默认位置 ~/.rtags ，但是通过给 rdm 传递 --data-dir /other/dir ，或者在 ~/.rdmrc 中写入类似的内容进行覆盖，。

   $ cat ~/.rdmrc
   --data-dir=/other/dir

On GNU/Linux distributions based on the systemd service manager, rdm can also be socket acivated.

基于 systemd 服务管理的 GNU/Linux 发行版中，rdm 可以通过 socket 激活。

Add the following to ~/.config/systemd/user/rdm.socket

将下面的代码写入 ~/.config/systemd/user/rdm.socket

   [Unit]
   Description=RTags daemon socket

   [Socket]
   ListenStream=%h/.rdm

   [Install]
   WantedBy=multi-user.target

Add the following to ~/.config/systemd/user/rdm.service

   [Unit]
   Description=RTags daemon

   Requires=rdm.socketp

   [Service]
   Type=simple
   ExecStart=$RDM -v --inactivity-timeout 300

Replace $RDM with the path to your copy of rdm, and add any command line parameters you might usually use.

将 $RDM 替换为 rdm 的路径，添加可能使用的任何命令行参数。

You have to use absolute paths here. %h is expanded to your home directory. Environment variables are not expanded inside strings.

这里必须使用绝对路径。%h 将会扩展为 home 目录，字符串中的环境变量不会扩展。

Run the following command from the terminal:

从终端运行如下命令：

 systemctl --user enable rdm.socket
 systemctl --user start rdm.socket

Systemd will create the rdm socket automatically.

Systemd 将会自动创建 rdm 套接字。

如果你更喜欢使用 SystemV，可以这样使用：

#!/bin/bash
#
# chkconfig: 35 90 12
# description: Foo server
#

# Get function from functions library
. /etc/init.d/functions

# Start the service FOO
start() {
        initlog -c "echo -n Starting FOO server: "
        /path/to/FOO &
        ### Create the lock file ###
        touch /var/lock/subsys/FOO
        success $"FOO server startup"
        echo
}

# Restart the service FOO
stop() {
        initlog -c "echo -n Stopping FOO server: "
        killproc FOO
        ### Now, delete the lock file ###
        rm -f /var/lock/subsys/FOO
        echo
}

### main logic ###
case "$1" in
  start)
        start
        ;;
  stop)
        stop
        ;;
  status)
        status FOO
        ;;
  restart|reload|condrestart)
        stop
        start
        ;;
  *)
        echo $"Usage: $0 {start|stop|restart|reload|status}"
        exit 1
esac

exit 0

(rtags-start-process-unless-running)

Start the rdm process unless the process is already running. You may create hook to automatically call this function upon entering, e.g. c-mode or c++mode.

启动 rdm 进程，除非该进程已经运行。可以创建钩子函数在输入时自动调用该函数，例如 c-mode 或 c++-mode 中。例如：

(add-hook 'c-mode-hook 'rtags-start-process-unless-running)
(add-hook 'c++-mode-hook 'rtags-start-process-unless-running)
(add-hook 'objc-mode-hook 'rtags-start-process-unless-running)

(rtags-restart-process)

Restart the rdm process.

重启 rdm 进程。

 (rtags-find-symbol-at-point)

Follow symbol under cursor. For references this goes to the definition (or declaration if no definition is known of the symbol. For declarations it goes to the definition and vice versa. For definitions of variables/parameters with constructors it goes to the constructor in question. If you pass a prefix argument, limit to current source file, if you pass a prefix argument and have narrowed the current file, limit to the narrowed region. This prefix argument is the same for: rtags-find-references-at-point, rtags-find-symbol, rtags-find-references

跟踪 cursor 下的符号。对于引用会跳转到定义（如果该符号没有定义则跳转到声明。对于声明跳转到定义。对于有构造函数的变量/参数的定义跳转到构造函数。如果传递前缀参数，限制在当前源码文件，如果传递前缀参数并 narrow 了当前文件，会限制于 narrowed 区域。前缀参数同样适用于 rtags-find-references-at-point, rtags-find-symbol, rtags-find-references）

 (rtags-find-references-at-point)

Find all references to symbol under cursor. If symbol is itself a reference it will find all references to the referenced symbol。

查找当前 cursor 下符号的所有引用。如果符号本身是一个引用，将会查找该符号的所有引用。

(rtags-find-symbol)

Prompt for name of symbol to go to. Imagine the following code:

提示想要跳转的符号，考虑下面的代码：

       namespace N
       {
           class C
           {
           public:
               int func(int);
           };
       };

       using namespace N;
       int C::func(int val)
       {
           return val * 2;
       }

int N::C::func(int) will now be accessible by the following names:

通过下面的代码可以访问到 int N::C::func(int) ：

func
func(int)
C::func(int)
C::func
N::C::func(int)
N::C::func

(rtags-find-references)

Prompt for name of symbol to find references to. Same as above but find references to symbol rather than declarations and definitions.

提示要查找引用的符号。除了是查找引用而不是声明和定义，和上面没差别。

(rtags-diagnostics)

Start an async process in a buffer to receive warnings/errors from clang whenever a file gets reindexed. It integrates with flymake to put highlighting on code with warnings and errors。

重新索引文件时，在 buffer 中启用异步进程接收来自 clang 的警告/错误。它和 flymake 整合在一起，高亮带有警告和错误的代码。

(rtags-enable-standard-keybindings)

Sets up a ton of standard keybindings under C-c r. If you pass a mode to the function it will set it up on that mode, otherwise it will use c-mode-base-map). You can choose a different prefix than C-c r like this:

在 C-c r 下建立大量的标准键绑定。如果给该函数传递一个模式，将会设置在该模式下，否则使用 c-mode-base-map。可以这样选择不同于 C-c r 的前缀：

(rtags-enable-standard-keybindings c-mode-base-map "\C-xr")

(rtags-find-file)

Lets you jump to file by name (partial or full, concept kinda stolen from gtags.el) with completion in the project. This includes all files under what we determine to be the root of the project, not just source files.

在项目补全时通过名字（部分或全部，概念有点来自 gtags.el）跳转到文件。包括项目根目录下面的所有文件，不只是源码文件。

(rtags-find-virtuals-at-point)

For virtual functions, show the various reimplementations of the function at point。

对于虚函数，显示当前 point 处函数的各种实现。

(rtags-fixit)

Apply clang’s automatic fixits in current file. If you pass a prefix arg use ediff to apply it. See (http://clang.llvm.org/diagnostics.html) for more info.

在当前文件应用 clang 的自动修正。如果传递前缀参数，使用 ediff 来应用它。

(rtags-imenu)

Provides an ido-based imenu like interface to a subset of the symbols in the current file. Note that it does not actually use imenu infrastructure.

为当前文件中的部分符号提供基于 ido 的类似 imenu 的接口。注意，它并不会使用 imenu 功能。

(rtags-location-stack-back)
(rtags-location-stack-forward)

Whenever RTags jumps somewhere it pushes a location onto its stack. Jump back and forward in this stack。

RTags 跳转时都会将位置压栈。可以在栈中前后跳转。

(rtags-next-match)
(rtags-previous-match)

For functions that return more than one match, jump to the next/previous one.

对于返回多个匹配的函数，跳转到下一个或下一个。

(rtags-preprocess-file)

Preprocess current file according to known C(XX)Flags and show the result in a buffer. If region is active only display the preprocessed output for that region.

通过已知的 C(XX)标识预处理当前文件，在 buffer 中显示结果。如果激活了区域则只显示区域的处理结果。

(rtags-print-symbol-info)

Print some info about symbol under cursor

打印 cursor 下符号的一些信息

(rtags-symbol-type)

Print the type of the symbol under cursor.

打印 cursor 下符号的类型

(rtags-print-dependencies)

Open a buffer showing files that depend on current file/files that current file depends on.

打开 buffer 显示当前文件所依赖的文件。

(rtags-print-enum-value-at-point)

Print integral value of enum value at point

打印 point 处枚举变量的整数值。

(rtags-quit-rdm)

Shut down rdm

关闭 rdm

(rtags-rename-symbol)

Rename symbol under cursor. Make sure all files are saved and fully indexed before using.

重命名 cursor 下的符号。使用之前确保所有的文件已保存并全部被索引。

(rtags-reparse-file)

Explicitly trigger a reparse of current file. Mostly for debugging. Unless we have bugs it should not be necessary.

显示触发重新解析当前文件。多用于调试。除非我们有不必要的 bug。

(rtags-show-rtags-buffer)

Switch to *RTags* buffer. This is the buffer where a number of functions display their alternatives when they have more than one match.

切换到 *RTags* buffer。如果在该 buffer 中显示函数的多个匹配。

(rtags-include-file)

Insert selected or entered include, e.g. “string.h”/<string.h> in current buffer, either at the top, after the first include statement or with prefix argument (C-u) at current point.

在当前 buffer 插入选中或输入的头文件，比如“string.h”/<string.h>，在顶部第一个头文件声明之后插入，使用前缀参数(C-u)在当前 point 处插入。

(rtags-get-include-file-for-symbol)

Insert include for entered symbol or symbol under courser in current buffer, either at the top, after the first include statement or with prefix argument (C-u) at current point.

插入正在输入的符号或 cursor 下符号对应的头文件，在顶部第一个头文件声明之后插入，使用前缀参数(C-u)在当前 point 处插入。

Path to rc/rdm if they’re not in $PATH.

如果 rc/rdm 不在 $PATH 中，改变量说明它们的路径。

Similar to compilation-auto-jump-to-first-error. Whether to jump to the first match automatically when there’s more than one.

类似 compilation-auto-jump-to-first-error。当有多个匹配时，是否自动跳转到第一个匹配。

Whether to match files case-insensitively

匹配文件是否区分大小写。

Whether to exclude partial matches for file names when an exact match is found. E.g. /foobar.cpp /bar.cpp If rtags-find-file-prefer-exact-match is t a query for bar.cpp would only return /bar.cpp, otherwise both foobar.cpp and bar.cpp would be returned.

是否在找到完全匹配时排除文件名的部分匹配。 例如。 /foobar.cpp /bar.cpp 如果 rtags-find-file-prefer-exact-match 是 t，查询 bar.cpp，则只会返回 / bar.cpp，否则将返回 foobar.cpp 和 bar.cpp。

You may explicitly select the RTags Flycheck checker for some major modes for better experience.

可以为某些 major mode 显式选择 RTags Flycheck 检查以获得的更好体验。

At the moment there is no customize option available to choose between rtags-diagnostics overlays or Flycheck overlays, nor is it planned right now. We recommend setting flycheck-highlighting-mode locally to nil as the RTags overlays are more accurate.

目前没有可用的定制选项选择 rtags-diagnostics overlays or Flycheck overlays，现在也不计划这么做。推荐局部设置 flycheck-highlighting-mode 为 nil，因为 RTags overlays 更准确。

Further, Flycheck will trigger automatically, based on events, the syntax checker for the current buffer, this is however, pretty useless in conjunction with RTags. We trigger it manually because we find it gives you a better experience. To turn off the automatic Flycheck syntax checking, set the variable flycheck-check-syntax-automatically locally to nil.

此外，Flycheck 将根据事件自动激活针对当前 buffer 的语法检查器，然而这与 RTags 结合在一起显得相当无用。手动激活它将会有更好的体验。将 flycheck-check-syntax-automatically 局部设置为 nil 关闭 Flycheck 自动语法检查。

(defun my-flycheck-rtags-setup ()
  (flycheck-select-checker 'rtags)
  (setq-local flycheck-highlighting-mode nil) ;; RTags creates more accurate overlays.
  (setq-local flycheck-check-syntax-automatically nil))
;; c-mode-common-hook is also called by c++-mode
(add-hook 'c-mode-common-hook #'my-flycheck-rtags-setup)