Bison/Flex Language Support

Full-featured language support for GNU Bison (.y, .yy) and Flex/RE-flex (.l, .ll) in Visual Studio Code.

Build parsers and lexers with confidence — get syntax highlighting with embedded C/C++, real-time error detection, intelligent autocompletion, and inline documentation for every directive.

Features

Syntax Highlighting

Section-aware highlighting that understands the structure of Bison and Flex files: declarations, rules, and epilogue/user code sections are each highlighted differently.

• Bison: directives (%token, %type, %define, %code...), rule definitions, $$/$1/@$ semantic values, <type> annotations, %prec, | alternatives
• Flex: directives (%option, %x, %s), <SC_NAME> start conditions, {abbreviation} references, <<EOF>>, regex character classes [a-z], escape sequences
• Embedded C/C++: full C++ highlighting inside %{ %}, %code { }, %top{ %}, %class{ }, and action blocks { ... } — powered by VS Code's built-in C++ grammar

Diagnostics

Real-time error detection as you type:

Every diagnostic carries a source field (bison / flex), a code slug (e.g. bison/unused-token), and where available a link to the GNU documentation — rendered as a clickable [bison/unused-token] link in the Problems panel. Unused symbols are rendered greyed-out via DiagnosticTag.Unnecessary.

Fix-it Hints (Quick Fixes)

22 code actions available via the lightbulb (Ctrl+.) or directly from the Problems panel:

Bison (11 fixes):

• Insert missing %% separator
• Declare undeclared %token
• Insert %empty for empty production
• Remove unused token declaration
• Remove unknown directive
• Add rule stub for missing non-terminal
• Add %type <todo> declaration
• Remove invalid %start / Add %start directive
• Close unclosed %{ block
• Migrate Yacc legacy directives (%error-verbose → %define parse.error verbose, %name-prefix, %pure-parser, %binary)

Flex (11 fixes):

• Insert missing %% separator
• Define abbreviation stub
• Remove unused abbreviation
• Remove unused start condition
• Remove unknown directive
• Declare %x SC_NAME for undefined start condition
• Remove unused %option
• Remove duplicate <<EOF>> rule
• Add %option noyywrap
• Close unclosed %{ block
• Remove inaccessible rule

Source ↔ Generated File Navigation

Jump between Bison/Flex grammar sources and their generated C files using #line directives:

• Bison/Flex: Show in Source — from a generated .tab.c / lex.yy.c file, reads the nearest #line N "file.y" directive above the cursor and opens the grammar source at the correct line. Appears in the context menu only when a generated file is detected.
• Bison/Flex: Show in Generated File — from a .y / .l source, locates the generated file and navigates to the matching line. Searches bisonFlex.buildDirectory, then CMake/Makefile detection, then the same directory, then a workspace-wide scan. A QuickPick is shown when multiple candidates are found.

Autocompletion

Context-aware suggestions triggered as you type:

• All Bison directives (30+): %token, %type, %define, %left, %right, %nonassoc, %precedence, %code, %skeleton, %glr-parser, %expect, %require, %language, %locations, %printer, %destructor, %param...
• All %define variables: api.value.type, api.token.prefix, api.namespace, api.parser.class, api.token.constructor, parse.error, parse.lac, lr.type...
• All Flex %option values (20+): noyywrap, bison-complete, bison-cc-parser, bison-locations, reentrant, debug, yylineno, stack...
• Token and non-terminal names from your declarations (in the rules section)
• Semantic values: $$, $1–$9, @$, @1–@9
• Start conditions and abbreviation names (Flex, in rules)
• Code snippets: full grammar/scanner skeletons, rule templates, comment/string handlers

Hover Documentation

Hover over any directive or keyword to see its documentation:

• Signature, description, and usage example for every Bison directive
• Documentation for all %define configuration variables
• Explanation of semantic value references ($$, $1, @$, @1)
• Flex %option value descriptions (including RE-flex-specific options)
• Built-in function docs: start(), text(), BEGIN, ECHO, REJECT, <<EOF>>
• Token and non-terminal info from your own declarations

Snippets

Ready-to-use templates to speed up your workflow:

Bison (14 snippets):

• bison-skeleton — Complete grammar file template
• rule — Grammar rule with action
• %token, %type, %code requires, %define, %left, %right, %nonassoc
• %empty, %prec, %{

Flex (12 snippets):

• flex-skeleton — Complete Flex scanner template
• reflex-skeleton — Complete RE-flex scanner template
• comment-handler — Nested comment handler with start conditions
• string-handler — String literal handler with escape sequences
• rule, rule-sc, %option, %x, %top, %class, eof-handler

Code Lens

Reference counts and entry-point indicators appear above every Bison rule and Flex start condition:

• N reference(s) — click to open Find All References at that symbol
• ⬪ entry point — marks the grammar's start symbol

Toggle with bisonFlex.enableCodeLens.

Document Symbols & Workspace Search

• Outline (Ctrl+Shift+O): collapsible tree of declarations, rules, and epilogue for Bison; definitions, patterns, and user code for Flex
• Workspace Symbols (Ctrl+T): fuzzy search across all open Bison and Flex files — tokens, rules, start conditions, abbreviations

Inlay Hints

Inline type annotations for $$, $1, @$, etc. resolved from %type and %token declarations. Toggle with bisonFlex.showInlayHints.

CMake Integration

The extension detects CMakeLists.txt files up to 6 directories above the current file:

• Diagnostic warning when a .y/.l file has no BISON_TARGET/FLEX_TARGET referencing it
• Bison/Flex: Add CMake Target command — appends the correct CMake snippet automatically

Toggle with bisonFlex.enableCmakeDiagnostics.

Grammar Tools

• Bison: Show Grammar Graph — interactive D3.js force-directed graph of the grammar; click a node to navigate to the rule; left/right recursive rules highlighted
• Bison: Show Parse Table — displays the Bison .output parse table in a side panel
• Bison: Explain Conflict — detailed shift/reduce conflict analysis with derivations and fix suggestions
• Bison: Generate AST Skeleton — generates a complete C++ AST header with visitor pattern
• Flex: Test Rule — interactive regex tester for the pattern on the current line

Compile Integration

• Bison: Compile / Flex: Compile — run the compiler on the current file and surface errors as VS Code diagnostics
• Bison/Flex: Initialize tasks.json — auto-generates .vscode/tasks.json with problem matchers; detects CMake and Makefile projects

Screenshots

Syntax Highlighting

Hover Documentation

Autocompletion

Diagnostics

Snippets

Supported File Types

Installation

From the Marketplace

Search for "Bison/Flex Language Support" in the VS Code Extensions panel (Ctrl+Shift+X).

From VSIX

code --install-extension bison-flex-lang-1.1.0.vsix

From Source

git clone https://github.com/theodevelop/bison-flex-lang.git
cd bison-flex-lang
npm install
npm run compile

Then press F5 in VS Code to launch the Extension Development Host.

Configuration

Build Integration (tasks.json)

Drop this .vscode/tasks.json into your Bison/Flex project to get Ctrl+Shift+B build support with problem matchers:

{
  "version": "2.0.0",
  "tasks": [
    {
      "label": "Build (Bison + Flex + Make)",
      "type": "shell",
      "command": "make",
      "group": { "kind": "build", "isDefault": true },
      "presentation": { "reveal": "always", "panel": "shared" },
      "problemMatcher": [
        {
          "owner": "bison",
          "fileLocation": ["relative", "${workspaceFolder}"],
          "pattern": {
            "regexp": "^(.+?):(\\d+)(?:\\.(\\d+))?:\\s+(warning|error):\\s+(.+)$",
            "file": 1, "line": 2, "column": 3, "severity": 4, "message": 5
          }
        },
        {
          "owner": "flex",
          "fileLocation": ["relative", "${workspaceFolder}"],
          "pattern": {
            "regexp": "^(.+?):(\\d+):\\s+(warning|error):\\s+(.+)$",
            "file": 1, "line": 2, "severity": 3, "message": 4
          }
        }
      ]
    },
    {
      "label": "Bison: Compile current file",
      "type": "shell",
      "command": "bison",
      "args": ["-d", "-v", "${file}"],
      "group": "build",
      "problemMatcher": []
    },
    {
      "label": "Flex: Compile current file",
      "type": "shell",
      "command": "flex",
      "args": ["-o", "${fileBasenameNoExtension}.c", "${file}"],
      "group": "build",
      "problemMatcher": []
    }
  ]
}

Tip: bison -d generates the .tab.h header; -v produces the .output report with the parse table.

Architecture

The extension uses a Language Server Protocol (LSP) architecture:

• Client (client/): thin VS Code extension that starts the language server
• Server (server/): Node.js process that provides diagnostics, completion, and hover
  • Hand-written parsers for Bison and Flex files (line-by-line, section-aware)
  • Document model cached per file, re-parsed on every change
• Grammars (syntaxes/): TextMate grammars with embedded C++ delegation

Community

Contributing

Contributions are welcome! See CONTRIBUTING.md for full details.

Quick start:

1. Fork the repository and branch off dev
2. npm install && npm run compile
3. Press F5 to test in the Extension Development Host
4. Add or update tests, then open a PR against dev

Running Tests

npx ts-node --project server/tsconfig.json tests/test-parsers.ts
TS_NODE_PROJECT=tsconfig.base.json npx ts-node tests/test-diagnostic-codes.ts
TS_NODE_PROJECT=tsconfig.base.json npx ts-node tests/test-version-settings.ts
TS_NODE_PROJECT=tsconfig.base.json npx ts-node tests/test-fix-it-hints.ts

Building for Production

npm run compile
npx vsce package         # Create .vsix file

Known Limitations

• Diagnostics are based on static analysis of the grammar file structure, not on running Bison/Flex. Some valid constructs may trigger warnings.
• Embedded C/C++ highlighting relies on VS Code's built-in C++ grammar. Complex template expressions may occasionally confuse the highlighter.
• Brace depth tracking in action blocks uses a simplified scanner that does not fully parse C++ strings and comments — deeply nested code blocks with unbalanced braces in string literals may cause highlighting drift.

License

MIT