• 4.6 标识符列表
    • 标签系统
    • 语义系统
    • 基于标签的标识符列表

    4.6 标识符列表

    本节之前的内容，虽说与代码开发有些关系，但最多也只能算作用户体验层面的，真正提升生产效率的内容将从此开始。

    本文主题是探讨如何将 vim 打造成高效的 C/C++ 开发环境，希望实现标识符列表、定义跳转、声明提示、实时诊断、代码补全等等系列功能，这些都需要 vim 能够很好地理解我们的代码（不论是 vim 自身还是借助插件甚至第三方工具），如何帮助 vim 理解代码？基本上，有两种主流方式：标签系统和语义系统。至于优劣，简单来说，标签系统配置简单，而语义系统效果精准，后者是趋势。目前对于高阶 IDE 功能，部分已经有对应基于语义的插件支撑，而部分仍只能通过基于标签的方式实现，若同个功能既有语义插件又有标签插件，优选语义。

    标签系统

    代码中的类、结构、类成员、函数、对象、宏等等这些统称为标识符，每个标识符的定义、所在文件中的行位置、所在文件的路径等等信息就是标签（tag）。

    Exuberant Ctags（http://ctags.sourceforge.net/ ，后简称 ctags）就是一款经典的用于生成代码标签信息的工具 。ctags 最初只支持生成 C/C++ 语言，目前已支持 41 种语言，具体列表运行如下命令获取：

    1. ctags --list-languages

    学习知识最好方式就是动手实践。我们以 main.cpp、my_class.h、my_class.cpp 三个文件为例：

    第一步，准备代码文件。创建演示目录 /data/workplace/example/、库子目录 /data/workplace/example/lib/，创建如下内容的 main.cpp：

    1. #include <iostring> 
    2. #include <string> 
    3. #include "lib/my_class.h" 
    4. using namespace std; 
    5. int g_num = 128; 
    6. // 重载函数 
    7. static void 
    8. printMsg (char ch) 
    9. { 
    10.     std::cout << ch << std::endl; 
    11. } 
    12. int 
    13. main (void) 
    14. { 
    15.     // 局部对象
    16.     const string    name = "yangyang.gnu"; 
    17.     // 类 
    18.     MyClass    one; 
    19.     // 成员函数 
    20.     one.printMsg(); 
    21.     // 使用局部对象 
    22.     cout << g_num << name << endl; 
    23.     return    (EXIT_SUCCESS); 
    24. }

    创建如下内容的 my_class.h：

    1. #pragma once 
    2. class MyClass 
    3. { 
    4.     public: 
    5.         void printMsg(void);      
    6.     private: 
    7.         ; 
    8. };

    创建如下内容的 my_class.cpp：

    1. #include "my_class.h" 
    2. // 重载函数 
    3. static void 
    4. printMsg (int i) 
    5. { 
    6.     std::cout << i << std::endl; 
    7. } 
    8. void 
    9. MyClass::printMsg (void) 
    10. { 
    11.     std::cout << "I'M MyClass!" << std::endl; 
    12. }

    第二步，生成标签文件。现在运行 ctags 生成标签文件：

    1. cd /data/workplace/example/
    2. ctags -R --c++-kinds=+p+l+x+c+d+e+f+g+m+n+s+t+u+v --fields=+liaS --extra=+q --language-force=c++

    命令行参数较多，主要关注 —c++-kinds，ctags 默认并不会提取所有标签，运行

    1. ctags --list-kinds=c++

    可看到 ctags 支持生成标签类型的全量列表：

    1. c  classes 
    2. d  macro definitions 
    3. e  enumerators (values inside an enumeration) 
    4. f  function definitions 
    5. g  enumeration names 
    6. l  local variables [off] 
    7. m  class, struct, and union members 
    8. n  namespaces 
    9. p  function prototypes [off] 
    10. s  structure names 
    11. t  typedefs 
    12. u  union names 
    13. v  variable definitions 
    14. x  external and forward variable declarations [off]

    其中，标为 off 的局部对象、函数声明、外部对象等类型默认不会生成标签，所以我显式加上所有类型。运行完后，example/ 下多了个文件 tags，内容大致如下：

    1. !_TAG_FILE_FORMAT    2    /extended format; --format=1 will not append ;" to lines/ 
    2. !_TAG_FILE_SORTED    1    /0=unsorted, 1=sorted, 2=foldcase/ 
    3. !_TAG_PROGRAM_AUTHOR    Darren Hiebert    /dhiebert@users.sourceforge.net/ 
    4. !_TAG_PROGRAM_NAME    Exuberant Ctags    // 
    5. !_TAG_PROGRAM_URL    http://ctags.sourceforge.net    /official site/ 
    6. !_TAG_PROGRAM_VERSION    5.8    // 
    7. MyClass    lib/my_class.h    /^class MyClass $/;"    c 
    8. MyClass::printMsg    lib/my_class.cpp    /^MyClass::printMsg (void) $/;"    f    class:MyClass    signature:(void) 
    9. MyClass::printMsg    lib/my_class.h    /^        void printMsg(void);$/;"    p    class:MyClass    access:public    signature:(void) 
    10. endl    lib/my_class.cpp    /^    std::cout << "I'M MyClass!" << std::endl;$/;"    m    class:std    file: 
    11. endl    lib/my_class.cpp    /^    std::cout << i << std::endl;$/;"    m    class:std    file: 
    12. endl    main.cpp    /^    cout << g_num << name << endl;$/;"    l 
    13. endl    main.cpp    /^    std::cout << ch << std::endl;$/;"    m    class:std    file: 
    14. g_num    main.cpp    /^int g_num = 128;$/;"    v 
    15. main    main.cpp    /^main (void) $/;"    f    signature:(void) 
    16. name    main.cpp    /^    const string    name = "yangyang.gnu";$/;"    l 
    17. one    main.cpp    /^    MyClass    one;$/;"    l 
    18. printMsg    lib/my_class.cpp    /^MyClass::printMsg (void) $/;"    f    class:MyClass    signature:(void) 
    19. printMsg    lib/my_class.cpp    /^printMsg (int i) $/;"    f    file:    signature:(int i) 
    20. printMsg    lib/my_class.h    /^        void printMsg(void);$/;"    p    class:MyClass    access:public    signature:(void) 
    21. printMsg    main.cpp    /^    one.printMsg();$/;"    p    file:    signature:() 
    22. printMsg    main.cpp    /^printMsg (char ch) $/;"    f    file:    signature:(char ch) 
    23. std::endl    lib/my_class.cpp    /^    std::cout << "I'M MyClass!" << std::endl;$/;"    m    class:std    file: 
    24. std::endl    lib/my_class.cpp    /^    std::cout << i << std::endl;$/;"    m    class:std    file: 
    25. std::endl    main.cpp    /^    std::cout << ch << std::endl;$/;"    m    class:std    file:

    其中，! 开头的几行是 ctags 生成的软件信息忽略之，下面的就是我们需要的标签，每个标签项至少有如下字段（命令行参数不同标签项的字段数不同）：标识符名、标识符所在的文件名（也是该文件的相对路径）、标识符所在行的内容、标识符类型（如，l 表示局部对象），另外，若是函数，则有函数签名字段，若是成员函数，则有访问属型字段等等。

    语义系统

    通过 ctags 这类标签系统在一定程度上助力 vim 理解我们的代码，对于 C 语言这类简单语言来说，差不多也够了。近几年，随着 C++11/14 的推出，诸如类型推导、lamda 表达式、模版等等新特性，标签系统显得有心无力，这个星球最了解代码的工具非编译器莫属，如果编译器能在语义这个高度帮助 vim 理解代码，那么我们需要的各项 IDE 功能肯定能达到另一个高度。

    语义系统，编译器必不可少。GCC 和 clang 两大主流 C/C++ 编译器，作为语义系统的支撑工具，我选择后者，除了 clang 对新标准支持及时、错误诊断信息清晰这些优点之外，更重要的是，它在高内聚、低耦合方面做得非常好，各类插件可以调用 libclang 获取非常完整的代码分析结果，从而轻松且优雅地实现高阶 IDE 功能。你对语义系统肯定还是比较懵懂，紧接着的“基于语义的声明/定义跳转”会让你有更为直观的了解，现在，请跳转至“7.1 编译器/构建工具集成”，一是了解 clang 相较 GCC 的优势，二是安装好最新版 clang 及其标准库，之后再回来。

    基于标签的标识符列表

    在阅读代码时，经常分析指定函数实现细节，我希望有个插件能把从当前代码文件中提取出的所有标识符放在一个侧边子窗口中，并且能能按语法规则将标识符进行归类，tagbar （https://github.com/majutsushi/tagbar ）是一款基于标签的标识符列表插件，它自动周期性调用 ctags 获取标签信息（仅保留在内存，不落地成文件）。安装完 tagbar 后，在 .vimrc 中增加如下信息：

    1. " 设置 tagbar 子窗口的位置出现在主编辑区的左边 
    2. let tagbar_left=1 
    3. " 设置显示／隐藏标签列表子窗口的快捷键。速记：identifier list by tag
    4. nnoremap <Leader>ilt :TagbarToggle<CR> 
    5. " 设置标签子窗口的宽度 
    6. let tagbar_width=32 
    7. " tagbar 子窗口中不显示冗余帮助信息 
    8. let g:tagbar_compact=1
    9. " 设置 ctags 对哪些代码标识符生成标签
    10. let g:tagbar_type_cpp = {
    11.     \ 'kinds' : [
    12.          \ 'c:classes:0:1',
    13.          \ 'd:macros:0:1',
    14.          \ 'e:enumerators:0:0', 
    15.          \ 'f:functions:0:1',
    16.          \ 'g:enumeration:0:1',
    17.          \ 'l:local:0:1',
    18.          \ 'm:members:0:1',
    19.          \ 'n:namespaces:0:1',
    20.          \ 'p:functions_prototypes:0:1',
    21.          \ 's:structs:0:1',
    22.          \ 't:typedefs:0:1',
    23.          \ 'u:unions:0:1',
    24.          \ 'v:global:0:1',
    25.          \ 'x:external:0:1'
    26.      \ ],
    27.      \ 'sro'        : '::',
    28.      \ 'kind2scope' : {
    29.          \ 'g' : 'enum',
    30.          \ 'n' : 'namespace',
    31.          \ 'c' : 'class',
    32.          \ 's' : 'struct',
    33.          \ 'u' : 'union'
    34.      \ },
    35.      \ 'scope2kind' : {
    36.          \ 'enum'      : 'g',
    37.          \ 'namespace' : 'n',
    38.          \ 'class'     : 'c',
    39.          \ 'struct'    : 's',
    40.          \ 'union'     : 'u'
    41.      \ }
    42. \ }

    前面提过，ctags 默认并不会提取局部对象、函数声明、外部对象等类型的标签，我必须让 tagbar 告诉 ctags 改变默认参数，这是 tagbar_type_cpp 变量存在的主要目的，所以前面的配置信息中将局部对象、函数声明、外部对象等显式将其加进该变量的 kinds 域中。具体格式为

    1. {short}:{long}[:{fold}[:{stl}]]

    用于描述函数、变量、结构体等等不同类型的标识符，每种类型对应一行。其中，short 将作为 ctags 的 —c++-kinds 命令行选项的参数，类似：

    1. --c++-kinds=+p+l+x+c+d+e+f+g+m+n+s+t+u+v

    long 将作为 short 的简要描述展示在 vim 的 tagbar 子窗口中；fold 表示这种类型的标识符是否折叠显示；stl 指定是否在 vim 状态栏中显示附加信息。

    重启 vim 后，打开一个 C/C++ 源码文件，键入 ilt，将在左侧的 tagbar 窗口中将可看到标签列表：

    4.6 标识符列表 - 图1（基于标签的标识符列表）
    从上图可知 tagbar 的几个特点： 按作用域归类不同标签。按名字空间 n_foo、类 Foo 进行归类，在内部有声明、有定义； 显示标签类型。名字空间、类、函数等等； 显示完整函数原型； 图形化显示共有成员（+）、私有成员（-）、保护成员（#）；
    在标识符列表中选中对应标识符后回车即可跳至源码中对应位置；在源码中停顿几秒，tagbar 将高亮对应标识符；每次保存文件时或者切换到不同代码文件时 tagbar 自动调用 ctags 更是标签数据库；tagbar 有两种排序方式，一是按标签名字母先后顺序、一是按标签在源码中出现的先后顺序，在 .vimrc 中我配置选用后者，键入 s 切换不同不同排序方式。