# 列出所有支持的语言
ctags --list-languages

# 输出示例（部分）：
# Ant
# Asm
# Asp
# Awk
# Basic
# C
# C#
# C++
# Clojure
# Cobol
# CSS
# D
# Dart
# Elixir
# Erlang
# Fortran
# Go
# HTML
# Java
# JavaScript
# JSON
# Julia
# Kotlin
# Lisp
# Lua
# Make
# Markdown
# ObjectiveC
# Pascal
# Perl
# PHP
# Python
# R
# Ruby
# Rust
# Scala
# Shell
# SQL
# Swift
# Tcl
# TypeScript
# Vera
# Verilog
# VHDL
# Vim
# XML
# YAML
# Yacc

# 查看某种语言的 kind 列表
ctags --list-kinds=C

# 输出：
# d  macro definitions      [off]
# e  enumerators (values inside an enumeration) [on]
# f  function definitions   [on]
# g  enum names             [on]
# h  included header files  [off]
# l  local variables        [off]
# m  struct/union members   [on]
# n  namespaces             [on]
# p  function prototypes    [on]
# s  structure names        [on]
# t  typedef names          [on]
# u  union names            [on]
# v  variable definitions   [on]
# x  external variable declarations [off]

# 查看某种语言的字段列表
ctags --list-fields=C

# 输出：
# N  name         on   NONE             s--    no    tag name
# F  file         on   NONE             s--    no    file name
# P  pattern      on   NONE             s--    no    pattern
# C  compact      off  NONE             s--    no    compact kind letter
# K  kind         on   NONE             s--    no    kind (long form)
# S  signature    on   NONE             s--    no    signature
# ...

# 列出所有语言的扩展名映射
ctags --list-map-extensions

# 查看特定语言的扩展名
ctags --list-map-extensions=Python
# 输出：.py .pyw .pyx

# 查看文件名模式映射
ctags --list-map-patterns

# 查看 C 语言支持的 kinds
ctags --list-kinds=C

# 查看 C++ 语言支持的 kinds
ctags --list-kinds=C++

ctags --list-kinds=Python

# 输出：
# c  classes              [on]
# f  functions            [on]
# m  class members        [on]
# v  variables            [on]
# i  imports              [off]
# l  local variables      [off]
# x  unknown              [on]
# z  parameters           [off]
# I  aliases of names     [off]

class MyClass:                    # → c (class)
    def method(self):             # → m (member)
        local_var = 10            # → v (variable) - 默认关闭

def func():                       # → f (function)
    pass

import os                         # → i (import) - 默认关闭
from sys import argv              # → i (import) - 默认关闭

# 包含 import 信息
ctags -R --kinds-python=+i .

# 查看 Python 类型引用字段
ctags -f - --fields-Python=+{defval}{section}{parameterDecoration} src/*.py

ctags --list-kinds=JavaScript

# 输出：
# C  constants            [on]
# c  classes              [on]
# f  functions            [on]
# g  generators           [on]
# m  methods              [on]
# p  properties           [on]
# v  variables            [on]
# G  global variables     [on]
# E  exported variables   [on]

ctags --list-kinds=TypeScript

# 输出：
# C  constants            [on]
# c  classes              [on]
# e  enumerators          [on]
# f  functions            [on]
# g  enums                [on]
# i  interfaces           [on]
# m  methods              [on]
# n  namespaces           [on]
# p  properties           [on]
# v  variables            [on]
# z  generic types        [on]

# HTML 内嵌 JavaScript 可以独立解析
ctags --map-HTML=+.vue .

# JSX 支持
ctags --languages=JavaScript --kinds-JavaScript=+g src/*.jsx

ctags --list-kinds=Go

# 输出：
# p  packages             [on]
# f  functions            [on]
# c  constants            [on]
# t  types                [on]
# v  variables            [on]
# m  struct members       [on]
# i  imports              [on]
# n  unknowns             [on]
# s  aliases of types     [on]
# e  unknowns             [on]
# u  unknowns             [on]

ctags --list-kinds=Rust

# 输出：
# M  modules              [on]
# n  modules              [on]
# c  implementations      [on]
# f  functions            [on]
# g  enum types           [on]
# i  trait items          [on]
# I  implementations      [on]
# m  struct members       [on]
# e  enumerators          [on]
# P  methods              [on]
# s  struct types         [on]
# t  type aliases         [on]
# v  variables            [on]
# G  enum variants        [on]
# T  traits               [on]
# U  unions               [on]
# N  implementations      [on]
# F  method declarations  [on]

# 查看当前映射
ctags --list-map-extensions=C
# 输出: .c .h

# 添加新的扩展名映射
ctags --map-C=+.ec --map-C=+.pg .

# 移除扩展名映射
ctags --map-C=--.h .

# 使用配置文件设置（永久）
# ~/.config/ctags/default.ctags
# --map-C=+.ec

# 查看文件名模式
ctags --list-map-patterns=Sh

# 输出：
# Sh .sh .bash .bashrc .bash_profile .bash_login .profile

# 添加自定义文件名模式
ctags --map-Sh=+.zshrc --map-Sh=+.zshenv .

# 某些文件名被直接映射到语言
# 例如 Makefile → Make, Rakefile → Ruby

# 添加新的文件名映射
ctags --map-Make=+Makefile.local .

# 将 .inc 文件映射为 PHP
ctags --map-PHP=+.inc .

# 将 .h 文件同时映射到 C 和 C++（联合解析）
ctags --map-C++=+.h .

# Vue 文件映射为 HTML（内嵌 JS/CSS 会被子解析器处理）
ctags --map-HTML=+.vue .

# Dockerfile 作为配置文件解析
ctags --map-Make=+Dockerfile .

# 为配置文件格式创建解析器
cat > ~/.config/ctags/myconf.ctags << 'EOF'
# 定义新语言
--langdef=conf

# 映射文件扩展名
--map-conf=+.conf

# section 头: [section_name]
--regex-conf=/^\[([a-zA-Z_][a-zA-Z0-9_]*)\]/\1/s,section/{scope=push}

# key = value
--regex-conf=/^([a-zA-Z_][a-zA-Z0-9_]*)\s*=/\1/k,key/{scope=ref}
EOF

# 测试
ctags -f - --options=myconf test.conf

cat > ~/.config/ctags/markdown-heading.ctags << 'EOF'
# Markdown 标题解析
--regex-Markdown=/^#{1,6}\s+(.+)/\1/c,chapter,heading/{scope=set}
EOF

# 测试
echo '# My Chapter' | ctags -f - --options=markdown-heading.ctags -L -

cat > ~/.config/ctags/ansible.ctags << 'EOF'
--langdef=ansible
--map-ansible=+.yml
--map-ansible=+.yaml

# Ansible task name
--regex-ansible=/^  - name:\s*(.+)/\1/t,task/{exclusive}
--regex-ansible=/^- hosts:\s*(.+)/\1/h,host/{exclusive}
EOF

cat > ~/.config/ctags/ini.ctags << 'EOF'
--langdef=ini
--map-ini=+.ini

# [section] 推入作用域
--regex-ini=/^\[([^\]]+)\]/\1/s,section/{scope=push}{_autoFQTag}

# key = value 引用当前作用域
--regex-ini=/^([a-zA-Z0-9_.-]+)\s*=/\1/k,key/{scope=ref}

# 空行或新 section 弹出作用域
--regex-ini=/^\[/\0/s,section/{scope=pop}{exclusive}{placeholder}
EOF

# 生成的标签会包含作用域信息
ctags -f - --fields=+S test.ini

# 查看子语言配置
ctags --list-subparsers=HTML

# 禁用子语言解析
ctags --submap-HTML=-JavaScript .

# 只解析 HTML 中的 JavaScript
ctags --submap-HTML=+JavaScript --submap-HTML=-CSS .

# 只包含函数定义（C 语言）
ctags --kinds-C=f .

# 排除局部变量（C 语言）
ctags --kinds-C=-l .

# 包含通常关闭的 kinds
ctags --kinds-C=+d+h+x+l .

# Python：包含 import
ctags --kinds-python=+i .

# 查看默认开启的 kinds
ctags --list-kinds=C

# 启用所有 kinds，再禁用局部变量
ctags --kinds-C='*-l' .

# 只启用函数和变量
ctags --kinds-C='f+v' .

# 为每种语言生成单独的标签文件
ctags -R -o tags.c --languages=C .
ctags -R -o tags.python --languages=Python .
ctags -R -o tags.js --languages=JavaScript .

# 或使用一个脚本自动化
cat > gen_tags.sh << 'SCRIPT'
#!/bin/bash
for lang in C C++ Python JavaScript Go; do
    lower=$(echo "$lang" | tr '[:upper:]' '[:lower:]')
    ctags -R -o ".tags.$lower" --languages="$lang" .
    echo "Generated .tags.$lower"
done
SCRIPT
chmod +x gen_tags.sh

# 一个 Web 项目的 .ctags 配置
cat > .ctags.d/web-project.ctags << 'EOF'
# 只索引这些语言
--languages=Python,JavaScript,TypeScript,HTML,CSS,SQL,Sh

# 排除第三方代码
--exclude=node_modules
--exclude=vendor
--exclude=.venv
--exclude=dist
--exclude=build

# JavaScript/TypeScript
--kinds-JavaScript=+v-g

# Python：包含类型注解信息
--fields-Python=+{defval}

# 默认字段
--fields=+S
--sort=yes
EOF

/* 自定义语言解析器的基本结构 (parsers/mylang.c) */
#include "general.h"
#include "entry.h"
#include "parse.h"

static tagRegexTable mylangTagRegexTable[] = {
    {"^(function)\\s+(\\w+)","\\2","f,function,functions",
     "{scope=push}"},
};

/* 注册语言 */
extern parserDefinition* MylangParser(void)
{
    parserDefinition* def = parserNew("MyLang");
    def->extensions = stringNew("ml");
    def->tagRegexTable = mylangTagRegexTable;
    def->tagRegexCount = ARRAY_SIZE(mylangTagRegexTable);
    def->method        = METHOD_NOT_CRAFTED | METHOD_REGEX;
    return def;
}