# 匹配跨行的函数定义
cat > .ctags.d/multiline.ctags << 'EOF'
--langdef=CSharp
--map-CSharp=+.cs

# 多行匹配：特性和函数
--mline-regex-CSharp=/^\[([A-Z]\w+)\]/\1/a,attribute/{mgroup=1}
--mline-regex-CSharp=/^(public|private|protected|internal)\s+(\w+)\s+(\w+)\s*\([^)]*\)\s*{/\3/m,method/{mgroup=1}{scope=push}
EOF

# 使用 \1, \2 等捕获组作为标签名
--regex-Python=/^class\s+(\w+)[:(]/\1/c,class/{scope=push}

# 使用命名捕获组（PCRE2 模式下）
--regex-Python=/^class\s+(?P<name>\w+)/\1/c,class/{scope=push}

# 多个捕获组
--regex-C=/^(static\s+)?(inline\s+)?(\w[\w\s\*]+)\s+(\w+)\s*\(/\4/f,function/{_autoFQTag}
# \4 捕获函数名

# {scope=push}  — 创建新的作用域层级
--regex-Python=/^class\s+(\w+)/\1/c/{scope=push}

# {scope=pop}   — 退出当前作用域
# 通常不需要显式 pop，Universal Ctags 会自动管理

# {scope=set}   — 设置当前作用域（不推入栈）
--regex-Markdown=/^#\s+(.+)/\1/h,heading/{scope=set}

# {scope=ref}   — 引用当前作用域（符号属于当前作用域）
--regex-Python=/^\s+def\s+(\w+)/\1/m,member/{scope=ref}

# {scope=clear} — 清空作用域栈
--regex-Go=/^package\s+(\w+)/\1/p,package/{scope=clear}

# {exclusive}   — 排除性正则（匹配此模式后，不再尝试其他正则）
--regex-Makefile=/^(\w+)\s*[:+?]?=/\1/v/{exclusive}

# {icase}       — 不区分大小写
--regex-Ruby=/^module\s+(\w+)/\1/m/{icase}

# {placeholder} — 占位标签（不输出到标签文件）
--regex-Go=/^import\s+(?:(\w+)\s+)?"([^"]+)"/\1/i/{placeholder}

# {_autoFQTag}  — 自动生成完全限定名
--regex-Python=/^class\s+(\w+)/\1/c/{_autoFQTag}{scope=push}

# 查看当前正则引擎
ctags --list-features
# 输出中应包含 "pcre2" 或 "regex"

# 使用 POSIX 正则（默认）
--_table-regex-C=...

# 使用 PCRE2（编译时需要 --enable-pcre2）
--_table-regex-C=/.../  # 自动选择

# PCRE2 优势：
# - 支持 \d, \w, \s 等速记字符类
# - 支持前瞻/后顾断言
# - 支持命名捕获组
# - 支持非贪婪匹配 (*?, +?)

# 查看所有语言的 kinds
ctags --list-kinds

# 查看特定语言的 kinds（含详细说明）
ctags --list-kinds-full=C

# 启用某个 kind
--kinds-C=+l        # 启用局部变量

# 禁用某个 kind
--kinds-C=-h        # 禁用头文件

# 同时启用和禁用
--kinds-C=+l-h      # 启用局部变量，禁用头文件

# 只启用指定 kinds（禁用所有其他）
--kinds-C=f+v       # 只要函数和变量

# 使用通配符
--kinds-C=*         # 启用所有 kinds
--kinds-C=*-l       # 启用所有 kinds，除局部变量

# 使用 kind 名称（需要完整名称）
--kinds-C=+function-local

# 使用 + 无参数表示启用所有默认关闭的 kinds
--kinds-C=+

# kind 长名称用于 --fields=+K（大写 K）
ctags -f --fields=+K src/main.c
# 输出：main	main.c	/^int main(){$/;"	function

# kind 缩写用于 --fields=+k（小写 k）
ctags -f --fields=+k src/main.c
# 输出：main	main.c	/^int main(){$/;"	f

# 全栈项目的 Kind 配置
cat > .ctags.d/kinds.ctags << 'EOF'
# C/C++：包含所有常用 kinds
--kinds-C=+d+e+f+g+h+l+m+p+s+t+u+v
--kinds-C++=+c+d+e+f+g+h+l+m+n+p+s+t+u+v

# Python：包含 import
--kinds-Python=+i

# JavaScript：包含变量和常量
--kinds-JavaScript=+C+c+f+g+m+p+v

# Go：包含接口和结构体
--kinds-Go=+p+f+c+t+v+m+i

# Rust：包含 trait 和 impl
--kinds-Rust=+M+c+f+g+i+I+m+P+s+t+v+T+U
EOF

# 查看所有字段
ctags --list-fields

# 启用行号字段
--fields=+n

# 启用签名字段
--fields=+S

# 启用作用域字段
--fields=+s

# 启用类型引用
--fields=+t

# 禁用模式字段（减小标签文件大小）
--fields=-P

# 只输出 name, file, line, kind, signature
--fields=nFksS

# 推荐组合
--fields=+S+s+n-K
# S: signature
# s: scope
# n: line number
# K: use compact kind letter instead of long form

# Python 特有字段
--fields-Python=+{defval}

# 启用后，Python 函数的默认参数值会被记录
# 示例输出：
# def foo(x=10):  →  signature:(x=10)  defval:x=10

# C++ 特有字段
--fields-C++=+{template}

# 记录模板信息
# template<class T> void foo(T x);
# →  template:<class T>

# 查看某种语言的特有字段
ctags --list-fields=Python
ctags --list-fields=C++

# 查看语言的继承关系
ctags --list-languages --with-list-header=yes

# 定义新语言并继承现有语言
cat > .ctags.d/mylang.ctags << 'EOF'
--langdef=MyLang
--map-MyLang=+.ml

# 继承 Python 的某些特性
--_table-MyLang=MyLang_main
--regex-MyLang=...
EOF

# 1. 只索引需要的语言
--languages=C,C++,Python

# 2. 排除大型第三方目录
--exclude=vendor
--exclude=node_modules
--exclude=third_party

# 3. 使用 git ls-files（只索引跟踪的文件）
git ls-files | ctags -L -

# 4. 排除测试文件（如果不需要索引测试）
--exclude='*_test.go'
--exclude='test_*.py'

# 1. 禁用不必要的字段
--fields=-P    # 禁用模式字段（最大节省）
--fields=-r    # 禁用角色字段

# 2. 禁用不必要的 extras
--extras=-f    # 不包含文件局部符号

# 3. 关闭不需要的 kinds
--kinds-C=-l-h-x   # 不包含局部变量、头文件、外部变量

# 4. 不排序（牺牲查找速度换生成速度）
--sort=no

# 测试生成时间
time ctags -R .

# 测试标签文件大小
ls -lh tags

# 测试行数
wc -l tags

# 对比不同配置的效率
time ctags -R --fields=+S+s+n .        # 推荐配置
time ctags -R --fields='*' .            # 全字段
time ctags -R --fields=-P .             # 无模式字段

# Linux 内核示例（约 7 万文件）
# 完整配置：~30s，~100MB 标签文件
# 仅 C/C++ 函数：~10s，~20MB 标签文件

# 增量更新单个文件
ctags --append=yes -o tags src/modified.c

# 注意：增量更新不会删除旧标签
# 如果文件中的符号被删除或移动，旧标签仍留在文件中

# 推荐：定期全量重建
# crontab 示例：每天凌晨全量重建
0 0 * * * cd /path/to/project && ctags -R .

# 或使用文件监视器自动增量更新
inotifywait -m -r -e modify,create,delete src/ | while read event; do
    ctags --append=yes -o tags "$(echo "$event" | cut -d' ' -f1)"
done

ctags -x src/main.c

# 输出：
# main             function     15 src/main.c        int main() {
# config           variable     23 src/main.c        static Config config;

# 不排序（按文件顺序输出）
ctags --sort=no -f tags .

# 生成函数索引（只包含函数定义）
ctags -R -x --kinds-C=f . | sort

# 合并多个标签文件
cat tags1 tags2 | grep -v '^!_' | sort -u > tags_merged

# 或使用 --append
cp tags1 tags_merged
ctags --append=yes -o tags_merged --languages=Python .

# 查看安全特性
ctags --list-features
# 可能包含 "sandbox"（seccomp 沙箱支持）

# 启用沙箱模式（限制文件系统访问）
ctags --sandbox .

# 沙箱模式限制：
# - 只能读取当前目录下的文件
# - 不能执行外部命令
# - 不能访问网络

# 详细输出模式
ctags -V . 2>&1 | head -50

# 显示统计信息
ctags -R --statistics=yes .

# 输出示例：
# 52 files added
# 1053 tags added
# 15 tags from C parser
# 893 tags from C++ parser
# 145 tags from Python parser

# 标签排序验证
head -50 tags | awk -F'\t' '{
    if (NR > 10) {  # 跳过头部伪标签
        if ($1 < prev) print "NOT SORTED:", prev, $1
        prev = $1
    }
}'

# 检查标签文件完整性
grep -c '^!_' tags    # 伪标签数
grep -cv '^!_' tags   # 实际标签数
grep -cv '^!_' tags | head -1  # 总标签数