C

The registry row this page is generated from

Read at render time from the same family row the register reads, so nothing in this block can disagree with it.

Extensions

.c, .h

Registry names

c

Recorded symbols

functions · structs · enums · types

Relationship types this analyzer constructs

9 of 14 constructed, read from this analyzer's source and re-derived by the languages gate. Each row below is one of the engine's types, in the engine's own order.

9 constructed, 5 not constructed. All 5 absent types are recorded as ruled absent: the written reason and the corpus measurement behind each are in this family's completeness record. The register explains what each label means.

What this analyzer does not resolve

• C has no class heritage, so there is no extends, implements or override edge to draw. What the format does offer is containment, and it is computed from the declarations in the file.
• A macro-generated member is unrecoverable: in #define BIT(x) int x : 1 the member name depends on the replacement list, so the declaration is recorded as partly unmeasured rather than given an invented name.
• Cross-translation-unit resolution is not attempted. An allocation cast to a type declared in another header is still recorded as a call, but no size, field or signature is resolved from it.

Every line above was written against C’s own analyzer module and is named against a construct in it, so it can be checked against the source. Nothing here is inherited from a template, or from another language’s page.

Where you meet it in a repository

Recognised by extension — .c, .h. Everything below is about where those files actually sit in a working repository.

• A C project is mostly headers: one struct is declared once and used in a dozen .c files, so bb records the declaration and reads the uses as references.
• Feature detection is a wall of #if blocks, so a declaration that only exists on one platform is still parsed and published.
• Generated C — parser output, protobuf, configuration headers — is indistinguishable from a hand-written file to any static reader.

Questions this index answers

Phrased as retrievals, because that is what an index can honestly do: it holds the symbols and the edges between them, and hands them back with the evidence attached.

1. How large is this struct, and which fields does it have?
2. Which symbols does this file export to other modules?
3. Which macros does this file define?
4. Which members does this flag enum carry?

What the analyzer sees in code like this

#define BIT(x) int x : 1         // bb records: macro BIT

struct flags {                      // bb records: struct flags
    unsigned int a : 1;             // bb records: property a
    unsigned int n;                 // ...and the computed size of the struct
};

EXPORT_SYMBOL(my_init, GPL);        // bb records: my_init as an export
int my_init(void) { return 0; }

Symbols are stored with the file they came from and the bytes they span, so a hit points at a line rather than at a guess. The annotations in the sample are commentary for the reader, not strings the index would store.

Languages that turn up in the same repository

Application & systems — the count beside each name is how many relationship types that family’s analyzer constructs.

• TypeScript14 types
• JavaScript12 types
• Python11 types
• Rust14 types
• Go12 types
• Java10 types
• C++11 types
• C#11 types
• Swift11 types
• Kotlin11 types
• Dart13 types
• Zig8 types
• Objective-C11 types
• Visual Basic11 types
• VBA9 types