universal-ctags/ctags

Features

• Source Code Indexing - Scans source code across multiple languages to create searchable catalogs of functions, classes, and variables.
• Source Code Indexing - Scans source files to generate a tag file of definitions and declarations.
• Symbol Index Generation - Universal Ctags creates an index file of language objects to enable rapid navigation via client tools.
• Symbol Indexing - Generates symbol maps for function definitions and call sites to enable rapid navigation across diverse languages.
• Cross-Language Symbol Indexing - Implements indexing processes that resolve symbols across multiple programming languages in a unified map.
• Index Definitions - Defines which kinds of language objects, fields, and metadata are extracted and stored in the index.
• Code Navigation Utilities - Provides a system for jumping between symbol references and definitions to facilitate source code navigation.
• Custom Language Definitions - Creates new language parsers using regular expressions via a command line interface.
• Custom Parser Definitions - Specifies how to recognize language objects using regex or external definitions to support specialized languages.
• Custom Tagging Rules - Supports custom tagging rules for new languages by specifying regular expressions and capture groups.
• Embedded Code Parsing - Executes a secondary parser on delimited blocks to extract tags from a different language.
• Guest Parser Delegation - Implements guest parser delegation to extract objects from a guest language embedded within a host language.
• Language Support Extensions - Implements custom parsers by defining recognition patterns, tag types, and parsing routines.
• Regex-Based Language Definitions - Provides the ability to define programming language grammars and symbol categories using regular expressions.
• Symbol Index Entries - Creates tag entries containing symbol definitions, line numbers, and file positions for codebase navigation.
• Tag File Querying - Locates specific tags within a generated index file to find corresponding source code definitions.
• C-Based Parser APIs - Provides a C-based framework and API for implementing high-performance language parsers.
• Guest Parser Delegation - Runs guest parsers on specific areas of a file to identify objects from different embedded languages.
• Language Object Extraction - Universal Ctags reads input streams using character or line interfaces to scan for language objects.
• State-Based Parsing - Uses state-based parsing to switch between regex tables, allowing the engine to handle nested structures and complex states.
• Symbol Scope Tracking - Maintains a nested hierarchy of scopes to generate fully qualified names for symbols in structured languages.
• Symbol-to-Scope Mapping - Records the hierarchical relationship between a language object and its parent scope using a managed API.
• Regular Expression-Based Parsing - Uses regular expressions and custom rules to extract symbols from programming languages not supported by default.
• Regex-Based Symbol Definitions - Uses configurable regular expressions to identify and extract source code symbols and metadata from files.
• Regex-Based Parsers - Implements a parsing engine that utilizes regular expressions to identify and categorize language objects in source code.
• Symbol Index Exports - Produces identified language objects in JSON format for consumption by external analysis tools.
• Assembly Language Indexing - Universal Ctags parses assembly source files to identify and catalog language objects for fast navigation.
• JSON Data Exports - Generates index data in JSON format for programmatic processing of language objects.
• Multi-Format Exports - Exports index files in various formats to maintain compatibility with different editor standards.
• Regex Extraction Utilities - Uses regular expressions to identify and extract language objects from unsupported files.
• Object Hierarchy Navigation - Creates reverse mappings between parents and children to iterate through objects within a specific scope.
• Indexing Exclusion Filters - Provides complex conditions and filters to include or exclude specific tags from the generated index.
• Output Filtering - Applies expressions to the output to sort or remove tags based on custom criteria.
• Multi-Directory Indexers - Traverses directory hierarchies with depth limits and exclusion rules before executing language extraction.
• Analysis File Filters - Universal Ctags excludes specific files or directories using shell wildcards and allows specific exceptions to be included.
• Extra Entry Flags - Uses global or language-specific flags to control the inclusion of optional or additional tag entries.
• Static Analysis Tools - Exports source code metadata as JSON or tabular data for use in external scripts and analysis tools.
• Language Extension Subparsers - Defines subparsers based on existing languages to add new symbol kinds without naming conflicts.
• Dynamic Regex Parsers - Uses single-line or multi-line regular expressions with replacement patterns to capture symbol names and locations.
• Command-Line Regex Definition - Allows users to specify new language search patterns using regular expressions directly from the command line.
• Tag Metadata Extensions - Attaches additional structured metadata like visibility and signatures to indexed symbol entries.
• Custom Indexing Rules - Enables the creation of custom symbol indexing rules via regular expressions defined in configuration files.
• File Exclusion Patterns - Allows users to ignore specific files or directories during the indexing process using wildcards.
• File Extension Language Mappings - Assigns programming languages to source files based on their extensions or filename patterns.
• Index Entry Filtering - Universal Ctags filters tags using name matches or complex expressions involving logical operators.
• Notebook Cell Indexing - Extracts cell definitions from Python notebooks to enable navigation between computational blocks.
• Multi-Format Index Exports - Generates index files in multiple formats, including JSON and tabular cross-references.
• Multi-line Symbol Matching - Scans across multiple lines to capture symbols that span several lines or require surrounding context.
• Runtime Parser Loading - Imports parser configurations from external files to streamline the setup of custom language indexing rules.
• Source Cross-References - Generates tabular cross-reference lists of language objects including names, kinds, and locations.
• Symbol Kind Definitions - Assigns short identifiers and descriptive names to different types of code elements for categorization.
• Symbol Visibility Scoping - Universal Ctags identifies globally visible tags versus file-limited tags based on header file extensions and language modifiers.
• Tag File Hierarchies - Universal Ctags creates local, global, or nested tag files to manage indexing across directory structures.
• C Preprocessor Emulation - Provides emulation of C preprocessor macro expansion to ensure accurate symbol indexing for C and C++ source code.
• C++ Source Indexing - Provides a specialized parser to index definitions and declarations in C++ source code.
• Class Hierarchies - Identifies classes and records their inheritance relationships to map the structural hierarchy of the code.
• CMake Project Indexing - Extracts functions, macros, and targets from CMake files to create a searchable symbol index.
• CUDA Source Indexing - Identifies definitions and declarations within CUDA files for rapid symbol lookup.
• Emacs Lisp Source Indexing - Identifies and maps language objects within Emacs Lisp files to enable fast navigation.
• Fortran Source Indexing - Identifies and catalogues definitions and declarations within Fortran files.
• Function Metadata Extraction - Captures modifiers such as virtual and static as metadata fields for indexed functions and variables.
• GDScript Object Indexing - Identifies functions, variables, and classes in GDScript source code and maps them to definitions.
• GDScript Source Indexing - Identifies and catalogs classes and methods within GDScript files for fast navigation.
• HTML Object Indexing - Extracts tags and headings from HTML files using a lexical and syntax analyzer.
• Import Resolution Tracking - Tracks Python imported modules and symbols, distinguishing between direct and aliased namespaces.
• Inko Source Indexing - Extracts definitions for objects, traits, and methods from Inko source files.
• JavaScript Class Indexing - Identifies class definitions and functions to map constructors and prototypes in JavaScript.
• Julia Object Indexing - Identifies modules, imports, and namespaces within Julia source code.
• Kconfig File Indexing - Scans Kconfig files to identify and catalog language objects for navigation tools.
• Macro Expansion Engines - Implements logic to expand macros within source files to ensure all generated symbols are indexed.
• Lex Source Indexing - Scans Lex source files to identify and index language objects for fast navigation.
• Linker Script Indexing - Identifies and records definitions and declarations within linker script files.
• Lisp Source Indexing - Identifies and catalogs classes, methods, and types to enable quick navigation of Lisp projects.
• Makefile Indexing - Extracts macro definitions and build targets from makefiles to create a searchable index.
• Embedded Language Tagging - Implements guest-parser delegation to index language objects within embedded code blocks.
• Parser Delegation Hierarchies - Employs a base parser and dependent subparsers to identify both low-level and high-level definitions.
• Parser Implementation Frameworks - Provides a C-based framework and API for implementing high-performance language parsers.
• Parser Parameter Tuning - Adjusts internal parser behavior using named parameter arguments to refine the extraction of symbols.
• Parser-to-File Mapping - Associates file extensions and patterns with specific language parsers to ensure correct symbol extraction.
• Parser Delegation - Implements a mechanism to trigger secondary parsers for extracting symbols from languages embedded within a host file.
• Qualified Name Resolution - Creates complete path identifiers for language objects based on their recorded scope information.
• Fully Qualified Name Generation - Prefixes symbol names with their scope hierarchy to create unique, fully qualified identifiers.
• Source Metadata Extraction - Extracts metadata decorators and modifiers from source code and stores them as associated fields in the index.
• Symbol Reference Indexing - Collects locations where a language object is referenced in addition to its definition.
• Symbol Qualification - Creates class-qualified identifiers for members in structured languages like C++ and Java.
• Type Signature Extractions - Universal Ctags captures type names and function parameter lists from source code as metadata.
• Process Sandboxing - Uses Seccomp BPF to restrict system calls during inline code processing for improved security.
• Parser Coordination Frameworks - Coordinates parsing of complex formats by connecting base parsers to subparsers via a method table.
• Recursive Directory Traversers - Traverses directory trees to find source files with configurable depth limits and symbolic link options.
• Parsing Behavior Parameters - Creates language-specific parameters that can be modified at runtime to influence how source code is indexed.
• Stack-Oriented Parsing Scripts - Executes stack-based code fragments during parsing to manage complex state and symbol tagging logic.
• Tag Location Resolution - Universal Ctags chooses between using line numbers, search patterns, or a combination of both to locate objects.
• Metadata Field Toggles - Enables or disables specific metadata fields for individual languages or across all supported parsers.

Star history