C Ecosystem

---

name: C Ecosystem description: This skill should be used when working with C projects, "C11", "C17", "C23", "Makefile", "gcc", "clang", "valgrind", "getopt", or C language patterns. Provides comprehensive Modern C (C11-C23) patterns, memory management, and CLI development best practices.

<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 - 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</feature>
  </features>
</standard>

</standards_evolution>

<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>

</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>

<compiler name="clang">
  <description>LLVM C compiler</description>
  <flags>
    <flag name="-std=c11">Enable C11 standard (or c17, c23)</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 linter and static analyzer clang-tidy src/.c -- -std=c11 <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 11) 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>

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

<c_libraries> </c_libraries>

<usage_patterns> resolve-library-id libraryName="cppreference" get-library-docs context7CompatibleLibraryID="/websites/cppreference_com" topic="stdatomic.h"

<pattern name="standard_library">
  <step>get-library-docs context7CompatibleLibraryID="/websites/cppreference_com" topic="malloc"</step>
</pattern>

</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 </best_practices>

<error_escalation> Compiler warning about unused variable Fix warning, maintain clean build Valgrind reports minor memory leak Track down and fix leak, verify with Valgrind AddressSanitizer detects buffer overflow Stop, fix immediately - this is a security issue Use-after-free or double-free detected Block operation, require immediate fix and review </error_escalation>

<related_agents> Memory architecture, data structure design C implementation with proper memory management Buffer overflow detection, input validation Cache optimization, memory layout, profiling with Valgrind </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>