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

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

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

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

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

_Atomic int counter = 0;

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

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

_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

<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

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

<staticanalysis> Clang-based linter and static analyzer clang-tidy src/.c -- -std=c11 <filereference>.clang-tidy</file_reference> Checks: > -, bugprone-, clang-analyzer-, misc-, performance-, readability-*, -readability-identifier-length

WarningsAsErrors: '*'

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"

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