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 C23 and modern C patterns, memory management, and CLI development best practices.
version	2.0.0

Provide comprehensive patterns for C23 and modern C language, memory management, toolchain configuration, and CLI tool development. GNU Compiler Collection. GCC 15: C23 (gnu23) is the default mode. C23 support is essentially feature-complete. GCC 8-14 defaulted to C17 (gnu17). Enable C23 standard (recommended default) C23 with GNU extensions (GCC 15 default) Comprehensive warnings Treat warnings as errors Warn on variable shadowing Warn on implicit conversions Require function prototypes Static analysis (GCC 10+)

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

Memory error detection (buffer overflow, use-after-free) -fsanitize=address -fno-omit-frame-pointer gcc -fsanitize=address -fno-omit-frame-pointer -g -o myapp myapp.c

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

What testing style do you prefer? Use Check or Unity Use cmocka Use Unity (smallest footprint)

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

Basic Makefile for C projects CC := gcc CFLAGS := -std=c23 -Wall -Wextra -Wpedantic -g LDFLAGS := LDLIBS :=

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)

Modern CMake for C projects cmake_minimum_required(VERSION 3.30) project(myapp VERSION 1.0.0 LANGUAGES C)

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

Meson build for C projects # meson.build project('myapp', 'c', version: '1.0.0', default_options: [ 'c_std=c23', 'warning_level=3', 'werror=true', ] )

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>

Do you need thread-safe operations? Use _Atomic for simple counters, pthreads for complex synchronization Single-threaded sequential execution

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

Standard malloc/calloc/realloc/free patterns #include <stdlib.h> #include <string.h>

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

Bulk allocation with single-point deallocation typedef struct { char *base; size_t size; size_t offset; } Arena;

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>

Fixed-size object allocation with O(1) alloc/free typedef struct PoolBlock { struct PoolBlock *next; } PoolBlock;

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>

Resource cleanup with goto for error handling int process_file(const char *path) { int result = -1; FILE *fp = NULL; char *buffer = NULL;

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>

POSIX standard option parsing #include <unistd.h> #include <stdio.h> #include <stdlib.h>

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;

}

GNU extension for long options #include <getopt.h> #include <stdio.h> #include <stdlib.h>

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;

}

Standard exit code conventions Successful execution General error Command line usage error Command found but not executable Command not found Terminated by signal N #include <stdlib.h> #include <sysexits.h> // EX_USAGE, EX_DATAERR, etc.

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;

}

Graceful signal handling for clean shutdown #include <signal.h> #include <stdio.h> #include <stdlib.h> #include <stdatomic.h>

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

Consistent error message format #include <errno.h> #include <stdarg.h> #include <stdio.h> #include <string.h>

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 get-library-docs context7CompatibleLibraryID="/websites/cppreference_com" topic="stdatomic.h" Workflow guidance Step completed

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

get-library-docs context7CompatibleLibraryID="/websites/cppreference_com" topic="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>

Understand C code requirements 1. Check for existing code patterns and conventions Workflow guidance Step completed 2. Identify memory ownership requirements Workflow guidance Step completed 3. Review header dependencies Workflow guidance Step completed Write safe, portable C code 1. Use C23 as the default standard (C11 minimum for legacy compatibility) Workflow guidance Step completed 2. Follow memory management patterns Workflow guidance Step completed 3. Handle all error conditions Workflow guidance Step completed Verify C code correctness 1. Compile with warnings enabled Workflow guidance Step completed 2. Run with sanitizers Workflow guidance Step completed 3. Test with Valgrind Workflow guidance Step completed

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

Read relevant source files and docs Search for patterns and references Apply this skill when task keywords and domain match Use the canonical workflow and verify with project conventions

<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 for this domain Review implementation quality against this skill guidance </related_agents>

Check all allocation return values Use bounded string functions (snprintf, strncpy) Enable compiler warnings Run sanitizers during development Using gets(), sprintf(), or other unsafe functions Using NULL instead of nullptr in C23 code Implicit function declarations (always include headers or forward-declare) Raw pointer arithmetic without bounds checking Implicit type conversions that may lose data Global mutable state when possible

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