<compiler name="clang">
  <description>LLVM C compiler. Clang 18+: supports -std=c23. Clang 19+: supports -std=c2y (post-C23).</description>
  <flags>
    <flag name="-std=c23">Enable C23 standard (recommended default, Clang 18+)</flag>
    <flag name="-std=c2y">Enable post-C23 draft standard (Clang 19+)</flag>
    <flag name="-Wall -Wextra -Wpedantic">Comprehensive warnings</flag>
    <flag name="-Werror">Treat warnings as errors</flag>
    <flag name="-Weverything">All warnings (use selectively)</flag>
  </flags>
</compiler>

<sanitizer name="UndefinedBehaviorSanitizer">
  <description>Undefined behavior detection</description>
  <flags>-fsanitize=undefined</flags>
  <example>

gcc -fsanitize=undefined -g -o myapp myapp.c

<sanitizer name="ThreadSanitizer">
  <description>Data race detection</description>
  <flags>-fsanitize=thread</flags>
  <note>Cannot be combined with AddressSanitizer</note>
</sanitizer>

<sanitizer name="MemorySanitizer">
  <description>Uninitialized memory read detection (Clang only)</description>
  <flags>-fsanitize=memory</flags>
</sanitizer>

<static_analysis> Clang-based code formatter for consistent style clang-format -i src/.c include/.h <file_reference>.clang-format</file_reference> BasedOnStyle: LLVM IndentWidth: 4 ColumnLimit: 100 SortIncludes: CaseInsensitive

<tool name="clang-tidy">
  <description>Clang-based linter and static analyzer</description>
  <usage>clang-tidy src/*.c -- -std=c23</usage>
  <configuration>
    <file_reference>.clang-tidy</file_reference>

Checks: > -*, bugprone-, clang-analyzer-, misc-, performance-, readability-*, -readability-identifier-length

WarningsAsErrors: '*'

<tool name="cppcheck">
  <description>Static analysis tool for C/C++</description>
  <usage>cppcheck --enable=all --error-exitcode=1 src/</usage>
</tool>

<tool name="valgrind">
  <description>Runtime memory error detection</description>
  <usage>valgrind --leak-check=full --show-leak-kinds=all ./myapp</usage>
  <tools>
    <tool name="memcheck">Memory error detection (default)</tool>
    <tool name="helgrind">Thread error detection</tool>
    <tool name="cachegrind">Cache profiling</tool>
    <tool name="callgrind">Call graph profiling</tool>
  </tools>
</tool>

</static_analysis>

<framework name="Check">
  <description>Unit testing framework for C</description>
  <example>

#include <check.h>

START_TEST(test_addition) { ck_assert_int_eq(1 + 1, 2); } END_TEST

Suite *math_suite(void) { Suite *s = suite_create("Math"); TCase *tc = tcase_create("Core"); tcase_add_test(tc, test_addition); suite_add_tcase(s, tc); return s; }

int main(void) { Suite *s = math_suite(); SRunner *sr = srunner_create(s); srunner_run_all(sr, CK_NORMAL); int failed = srunner_ntests_failed(sr); srunner_free(sr); return failed ? EXIT_FAILURE : EXIT_SUCCESS; }

<build_systems> <decision_tree name="build_system_selection"> What is your project's complexity and portability needs? Use Make Use CMake or Meson Use Meson </decision_tree>

SRCS := $(wildcard src/*.c) OBJS := $(SRCS:.c=.o) TARGET := myapp

.PHONY: all clean

all: $(TARGET)

$(TARGET): $(OBJS) $(CC) $(LDFLAGS) -o $@ $^ $(LDLIBS)

%.o: %.c $(CC) $(CFLAGS) -c -o $@ $<

clean: rm -f $(OBJS) $(TARGET)

set(CMAKE_C_STANDARD 23) set(CMAKE_C_STANDARD_REQUIRED ON) set(CMAKE_C_EXTENSIONS OFF)

add_executable(myapp src/main.c src/utils.c) target_include_directories(myapp PRIVATE include)

target_compile_options(myapp PRIVATE $<$<C_COMPILER_ID:GNU,Clang>: -Wall -Wextra -Wpedantic -Werror > ) For detailed CMake patterns, see cplusplus-ecosystem skill

src = files('src/main.c', 'src/utils.c') inc = include_directories('include')

executable('myapp', src, include_directories: inc) </build_systems>

<c_language> <standards_evolution> ISO/IEC 9899:2011 - Major modernization with threading and type-generic features Type-generic selection for polymorphic macros Atomic types and operations for lock-free programming Thread-local storage duration Compile-time assertions Alignment specifier for variables and types Query alignment requirements Function that does not return Unnamed struct/union members

<standard name="C17">
  <description>ISO/IEC 9899:2018 - Bug fix release with no new features</description>
  <changes>
    <change>__STDC_VERSION__ updated to 201710L</change>
    <change>Defect reports resolved</change>
    <change>ATOMIC_VAR_INIT deprecated</change>
  </changes>
</standard>

<standard name="C23">
  <description>ISO/IEC 9899:2024 - Published October 31, 2024. Current C standard. Default in GCC 15 (gnu23). Significant modernization with C++ alignment.</description>
  <features>
    <feature name="nullptr">Null pointer constant with nullptr_t type</feature>
    <feature name="typeof">Type inference operator</feature>
    <feature name="constexpr">Compile-time constant objects</feature>
    <feature name="auto">Type inference for variables</feature>
    <feature name="binary_literals">0b prefix for binary literals</feature>
    <feature name="digit_separators">Single quote separator in numeric literals</feature>
    <feature name="attributes">[[nodiscard]], [[maybe_unused]], [[deprecated]], [[fallthrough]], [[noreturn]]</feature>
    <feature name="bool_true_false">bool, true, false as keywords</feature>
    <feature name="embed">#embed directive for binary resource inclusion</feature>
    <feature name="static_assert">Single argument form (no message required)</feature>
    <feature name="typeof_unqual">typeof_unqual for unqualified type inference</feature>
    <feature name="elifdef">#elifdef and #elifndef preprocessor directives</feature>
    <feature name="labels_end_of_block">Labels allowed at end of compound statements</feature>
  </features>
</standard>

</standards_evolution>

<c23_features> C23 (ISO/IEC 9899:2024) is the current C standard. Default in GCC 15. #embed directive for binary resource inclusion and __has_embed for availability checking. const unsigned char icon[] = { #embed "icon.png" }; auto keyword now causes type inference (in addition to storage class specifier). auto x = 42; // x is int Zero initialization with {} for any type including VLAs. int arr[10] = {}; typeof and typeof_unqual operators standardized. nullptr constant and nullptr_t type (replacing NULL macro ambiguity). bool, true, false are now keywords (no longer macros from stdbool.h). #elifdef and #elifndef preprocessor directives. constexpr for object definitions (compile-time constants). Unlike C++, only applies to objects, not functions. constexpr int MAX_SIZE = 1024; Standard attributes: [[nodiscard]], [[maybe_unused]], [[deprecated]], [[fallthrough]], [[noreturn]], [[reproducible]], [[unsequenced]]. [[nodiscard]] int compute(int x); [[maybe_unused]] static void helper(void) { } [[deprecated("use new_func instead")]] void old_func(void); static_assert with single argument (no message string required). static_assert(sizeof(int) >= 4); Single quote as digit separator in numeric literals for readability. int million = 1'000'000; unsigned hex = 0xFF'FF'FF'FF; Labels are now allowed at end of compound statements (before closing brace). void f(void) { goto done; // ... done: } </c23_features>

<type_system> Fixed-width integer types from stdint.h Exact-width signed integers Exact-width unsigned integers Pointer-sized integers Unsigned size type for memory operations Signed pointer difference type #include <stdint.h> #include <stddef.h>

uint32_t compute_hash(const uint8_t *data, size_t len);

<concept name="type_generic_selection">
  <description>_Generic for type-based dispatch (C11)</description>
  <example>

#define print_value(x) _Generic((x),
int: print_int,
double: print_double,
char *: print_string,
default: print_unknown
)(x) <use_case>Implement type-safe generic interfaces without void pointers</use_case>

<concept name="compound_literals">
  <description>Anonymous compound literals for in-place struct/array creation</description>
  <example>

struct point { int x, y; }; void draw(struct point p);

draw((struct point){.x = 10, .y = 20});

int *arr = (int[]){1, 2, 3, 4, 5};

<concept name="designated_initializers">
  <description>Named field initialization for structs and arrays</description>
  <example>

struct config { int timeout; bool verbose; const char *name; };

struct config cfg = { .name = "myapp", .timeout = 30, .verbose = true, }; </type_system>

<concept name="atomics">
  <description>Lock-free atomic operations (C11)</description>
  <example>

#include <stdatomic.h>

_Atomic int counter = 0;

void increment(void) { atomic_fetch_add(&counter, 1); }

int get_count(void) { return atomic_load(&counter); }

<concept name="thread_local">
  <description>Thread-local storage (C11)</description>
  <example>

#include <threads.h>

_Thread_local int errno_local;

<undefined_behavior> Common undefined behavior to avoid in C Null pointer dereference, use-after-free, buffer overflow, double-free Signed integer overflow, division by zero, shift beyond type width Strict aliasing violations, type punning without union Modifying variable twice between sequence points Use sanitizers (ASan, UBSan) during development to detect UB </undefined_behavior>

<anti_patterns> Overusing void* for generic programming Use _Generic macros or code generation

<avoid name="magic_numbers">
  <description>Hardcoded numeric values without explanation</description>
  <instead>Use named constants with define or enum</instead>
</avoid>

<avoid name="strcpy_strcat">
  <description>Using unbounded string functions</description>
  <instead>Use snprintf for strings. Note: strncpy does NOT null-terminate if source exceeds size</instead>
</avoid>

<avoid name="sprintf">
  <description>Using sprintf without bounds checking</description>
  <instead>Use snprintf with explicit buffer size</instead>
</avoid>

<avoid name="gets">
  <description>Using gets() which has no bounds checking</description>
  <instead>Use fgets() with explicit buffer size</instead>
</avoid>

<avoid name="scanf_unbounded">
  <description>Using scanf with unbounded %s format</description>
  <instead>Use %Ns with explicit width or fgets followed by sscanf</instead>
</avoid>

<avoid name="unchecked_malloc">
  <description>Not checking malloc return value</description>
  <instead>Always check for NULL after allocation</instead>
</avoid>

<avoid name="format_string_vuln">
  <description>Using user input as format string (printf(user_input))</description>
  <instead>Always use printf("%s", user_input) or puts()</instead>
</avoid>

<avoid name="null_macro">
  <description>Using NULL macro instead of nullptr (C23)</description>
  <instead>Use nullptr for null pointer constants (type-safe, no integer ambiguity)</instead>
</avoid>

<avoid name="implicit_function_declarations">
  <description>Calling functions without prior declaration or prototype</description>
  <instead>Always include proper headers or forward-declare functions. Implicit declarations were removed in C99 and are errors in C23.</instead>
</avoid>

<avoid name="manual_memory_no_ownership">
  <description>Manual memory management without clear ownership semantics</description>
  <instead>Document ownership in function comments (caller-owned vs callee-owned). Use naming conventions like _new/_free pairs.</instead>
</avoid>

</anti_patterns> </c_language>

<memory_management> <decision_tree name="allocation_strategy"> What is the lifetime and access pattern of the memory? Use stack allocation or VLA (with size limit) Use malloc/free with clear ownership Use arena allocator Use pool allocator </decision_tree>

char *duplicate_string(const char *src) { if (!src) return NULL;

size_t len = strlen(src) + 1; char *dst = malloc(len); if (!dst) return NULL;

memcpy(dst, src, len); return dst;

} Always check malloc/calloc/realloc return value for NULL Use calloc for zero-initialized memory After realloc, use the returned pointer (original may be invalid) Set pointer to NULL after free to prevent use-after-free

Arena arena_create(size_t size) { Arena a = {0}; a.base = malloc(size); if (a.base) a.size = size; return a; }

void *arena_alloc(Arena *a, size_t bytes) { size_t aligned = (bytes + 7) & ~7; // 8-byte alignment if (a->offset + aligned > a->size) return NULL; void *ptr = a->base + a->offset; a->offset += aligned; return ptr; }

void arena_reset(Arena *a) { a->offset = 0; }

void arena_destroy(Arena *a) { free(a->base); *a = (Arena){0}; } <use_case>Parsing, compilers, request handling - many allocations freed together</use_case>

typedef struct { PoolBlock *free_list; char *memory; size_t object_size; size_t capacity; } Pool;

Pool pool_create(size_t object_size, size_t count) { Pool p = {0}; size_t size = object_size > sizeof(PoolBlock) ? object_size : sizeof(PoolBlock); p.memory = malloc(size * count); if (!p.memory) return p;

p.object_size = size; p.capacity = count;

// Build free list for (size_t i = 0; i < count; i++) { PoolBlock *block = (PoolBlock *)(p.memory + i * size); block->next = p.free_list; p.free_list = block; } return p;

}

void *pool_alloc(Pool *p) { if (!p->free_list) return NULL; PoolBlock *block = p->free_list; p->free_list = block->next; return block; }

void pool_free(Pool *p, void *ptr) { PoolBlock *block = ptr; block->next = p->free_list; p->free_list = block; }

void pool_destroy(Pool *p) { free(p->memory); *p = (Pool){0}; } <use_case>Game entities, network connections, fixed-size records</use_case>

fp = fopen(path, "r"); if (!fp) goto cleanup;

buffer = malloc(BUFFER_SIZE); if (!buffer) goto cleanup;

// ... process file ...

result = 0; // Success

cleanup: free(buffer); if (fp) fclose(fp); return result; } Single cleanup point prevents resource leaks on error paths

<anti_patterns> Forgetting to free allocated memory Use Valgrind/ASan, establish clear ownership rules

<avoid name="double_free">
  <description>Freeing the same pointer twice</description>
  <instead>Set pointer to NULL after free, use ownership tracking</instead>
</avoid>

<avoid name="use_after_free">
  <description>Accessing memory after it has been freed</description>
  <instead>Clear pointers after free, use ASan for detection</instead>
</avoid>

<avoid name="buffer_overflow">
  <description>Writing beyond allocated buffer bounds</description>
  <instead>Always track buffer sizes, use bounded functions</instead>
</avoid>

</anti_patterns> </memory_management>

<cli_development> <decision_tree name="argument_parsing"> What complexity of argument parsing is needed? Use getopt() Use getopt_long() Use argp (GNU extension) </decision_tree>

int main(int argc, char *argv[]) { int verbose = 0; const char *output = NULL; int opt;

while ((opt = getopt(argc, argv, "vo:h")) != -1) { switch (opt) { case 'v': verbose = 1; break; case 'o': output = optarg; break; case 'h': printf("Usage: %s [-v] [-o output] [file...]\n", argv[0]); return 0; default: fprintf(stderr, "Usage: %s [-v] [-o output] [file...]\n", argv[0]); return 1; } }

// Remaining arguments: argv[optind] to argv[argc-1] for (int i = optind; i < argc; i++) { printf("Processing: %s\n", argv[i]); }

return 0;

}

static struct option long_options[] = { {"verbose", no_argument, NULL, 'v'}, {"output", required_argument, NULL, 'o'}, {"help", no_argument, NULL, 'h'}, {NULL, 0, NULL, 0 } };

int main(int argc, char *argv[]) { int verbose = 0; const char *output = NULL; int opt;

while ((opt = getopt_long(argc, argv, "vo:h", long_options, NULL)) != -1) { switch (opt) { case 'v': verbose = 1; break; case 'o': output = optarg; break; case 'h': printf("Usage: %s [--verbose] [--output FILE] [file...]\n", argv[0]); return 0; default: return 1; } }

return 0;

}

int main(int argc, char *argv[]) { if (argc < 2) { fprintf(stderr, "Usage: %s <file>\n", argv[0]); return EX_USAGE; // 64 }

FILE *fp = fopen(argv[1], "r"); if (!fp) { perror(argv[1]); return EX_NOINPUT; // 66 }

// ...

return EXIT_SUCCESS;

}

static atomic_int running = 1;

static void handle_signal(int sig) { (void)sig; running = 0; }

int main(void) { struct sigaction sa = {0}; sa.sa_handler = handle_signal; sigemptyset(&sa.sa_mask); sa.sa_flags = 0;

sigaction(SIGINT, &sa, NULL); sigaction(SIGTERM, &sa, NULL);

while (running) { // Main loop work }

printf("Shutting down gracefully...\n"); return 0;

} Use sigaction() instead of signal() for portability Keep signal handlers minimal - set flag only Use volatile sig_atomic_t or atomic types for signal flags

static const char *progname = "myapp";

void set_progname(const char *argv0) { const char *p = strrchr(argv0, '/'); progname = p ? p + 1 : argv0; }

void error(const char *fmt, ...) { fprintf(stderr, "%s: ", progname); va_list ap; va_start(ap, fmt); vfprintf(stderr, fmt, ap); va_end(ap); fprintf(stderr, "\n"); }

void error_errno(const char *fmt, ...) { int saved_errno = errno; fprintf(stderr, "%s: ", progname); va_list ap; va_start(ap, fmt); vfprintf(stderr, fmt, ap); va_end(ap); fprintf(stderr, ": %s\n", strerror(saved_errno)); } </cli_development>

<context7_integration> Use Context7 MCP for up-to-date C documentation

<c_libraries> </c_libraries>

<usage_patterns> resolve-library-id libraryName="cppreference" Workflow guidance Step completed query-docs libraryId="/websites/cppreference_com" query="stdatomic.h" Workflow guidance Step completed

<pattern name="standard_library">
  <step order="1">

query-docs libraryId="/websites/cppreference_com" query="malloc" Workflow guidance Step completed </usage_patterns> </context7_integration>

<best_practices> Always check return values of malloc/calloc/realloc Enable -Wall -Wextra -Werror for all builds Run with AddressSanitizer during development Use Valgrind before release Use fixed-width integer types from stdint.h Prefer snprintf over sprintf for buffer safety Use designated initializers for struct clarity Document ownership semantics in function comments Use static for file-local functions and variables Prefer const for read-only parameters Use enum for related constants instead of define Include what you use - minimize header dependencies Use nullptr instead of NULL in C23 code Use [[nodiscard]] on functions whose return value must be checked Use clang-format for consistent code formatting </best_practices>

<error_escalation> Compiler warning about unused variable Valgrind reports minor memory leak AddressSanitizer detects buffer overflow Use-after-free or double-free detected </error_escalation>

<decision_tree name="skill_activation"> Does the task clearly match this skill domain? Use this skill workflow and constraints Use a more appropriate domain skill </decision_tree>

<related_agents> Locate code patterns and references in this skill domain Review implementation quality against this skill guidance Analyze code complexity and suggest refactoring improvements </related_agents>

<related_skills> Navigate C codebases and header hierarchies C documentation via /websites/cppreference_com CMake patterns and clang-tidy configuration Debugging with Valgrind, GDB, and sanitizers </related_skills>

C Ecosystem