@fazelstudio/codemirror-lang-c

Native C language support for CodeMirror 6 using a dedicated Lezer grammar.

Overview

This package provides native CodeMirror 6 support for the C programming language. It is:

• Not a C++ wrapper
• Not a CodeMirror 5 mode wrapper
• Not a thin alias around @codemirror/legacy-modes

Instead, it uses a purpose-built Lezer grammar that provides:

• Syntax highlighting
• Code indentation
• Code folding
• Incremental parsing
• Useful syntax tree structure

Installation

npm install @fazelstudio/codemirror-lang-c

Usage

import {EditorState} from "@codemirror/state"
import {EditorView} from "@codemirror/view"
import {basicSetup} from "codemirror"
import {c} from "@fazelstudio/codemirror-lang-c"

const state = EditorState.create({
  doc: `#include <stdio.h>

struct User {
  int id;
  const char *name;
};

int main(void) {
  struct User user = {1, "Fazel"};
  printf("%s\\n", user.name);
  return 0;
}`,
  extensions: [
    basicSetup,
    c(),
  ],
})

new EditorView({
  state,
  parent: document.body,
})

API

cLanguage

The LRLanguage instance for C. Can be used directly for advanced use cases:

import {cLanguage} from "@fazelstudio/codemirror-lang-c"

// Access the underlying parser
const parser = cLanguage.parser

c()

Creates a LanguageSupport instance with C language support:

import {c} from "@fazelstudio/codemirror-lang-c"

const support = c()

Supported C Standard

Baseline: ISO C17 (ISO/IEC 9899:2018)

The parser targets C17 core syntax. The following C23 features are recognized where cleanly implementable:

• _Static_assert (actually C11 but widely used)
• _Noreturn
• _Alignas / _Alignof
• _Atomic
• _Thread_local
• Generic selection (_Generic)

Not claimed as full C23 support - specific features are documented individually.

Supported Extensions

The parser tolerates common compiler extensions:

• __attribute__((...))
• __declspec(...)
• typeof(...) / __typeof__
• __asm__ / asm(...)

These are recognized but not deeply integrated into semantic highlighting.

Limitations

This package is a syntax parser, not a full C compiler:

1. Semantic ambiguity: Some constructs (e.g., foo * bar;) require semantic information to distinguish declaration from expression.

2. Macro expansion: Preprocessor directives are recognized and highlighted, but macros are not expanded.

3. Type tracking: The parser doesn't track typedef declarations or struct tags for semantic highlighting.

4. Complete C23: Not all C23 features are implemented.

Differences from Related Packages

| Package | Relationship | |---------|---------------| | @codemirror/lang-cpp | C++ support only, not C | | @codemirror/legacy-modes | CodeMirror 5 API, not native CM6 |

This package is specifically for C and uses a dedicated Lezer grammar.

Development

# Install dependencies
npm install

# Build the grammar
npm run build:grammar

# Build the package
npm run build

# Run tests
npm test

# Watch mode
npm run watch

License

MIT