Hasty Briefsbeta

All tags

c programming

22 stories total

Bilingual

Getopt() but Friendlier
2 months ago
- The article proposes a friendlier CLI argument parser in C that improves upon POSIX getopt() by allowing flags before or after positional arguments, using consistent separators for long options, and supporting short option chaining.
- The author implements an iterator-based parser using a struct to hold state (avoiding global variables) and a tagged union for argument types, achieving re-entrancy and a simpler loop structure.
- The parser is provided as a C23 single-header library with macros for convenient argument matching (e.g., ARG_SHORT, ARG_LONG, ARG_POS) and error handling.
- The discussion reflects on C's poor ergonomics and the value of reexamining established conventions, with the author noting C as a 'comfort language' despite its flaws.
The C ``Clockwise/Spiral Rule''
2 months ago
- The Clockwise/Spiral Rule is a technique for parsing any C declaration in your head.
- It involves three steps: start with the identifier, move clockwise (or spirally) through the declaration, and interpret each symbol as you encounter it.
- Examples illustrate how to parse declarations like arrays of pointers, function pointers, and combinations with const and volatile.
- The same rule applies to const and volatile qualifiers, treating them as part of the type.
The Ten Commandments for C Programmers from Henry Spencer (Unix/Plan 9 – 1987)
2 months ago
- Run lint frequently and study its output carefully.
- Never dereference a null pointer.
- Cast function arguments to expected types explicitly.
- Declare library function return types if headers are missing.
- Check array bounds and avoid using gets().
- Always check error return codes from functions.
- Study and reuse libraries instead of reinventing them.
- Use the K&R brace style for clarity and consistency.
- Ensure external identifiers are unique in the first six characters.
- Write portable code; avoid assuming a specific architecture.
I Rewrote Json2xml in C–After Making It Fast with Rust
2 months ago
- The author created json2xml-c as a standalone C library and CLI, not to replace the Python/Rust version but to offer a dependency-free alternative.
- Benchmarks show the C pipeline is 1.51x to 5.39x faster than the Python/Rust full pipeline, but this is due to narrower product boundaries, not language superiority.
- The C version owns the entire conversion path from JSON bytes to XML output, with features like UTF-8 handling, XML validation, and pretty-printing.
- The release includes pre-built binaries for multiple platforms, comprehensive testing with 100% line/function coverage, and deterministic allocation-failure tests.
A Fast, Growable Array With Stable Pointers in C
2 months ago
- The segment array provides constant time indexing, stable pointers, and works well with arena allocators.
- It stores pointers to fixed-size segments that double in size, avoiding memory relocation and holes.
- Fixed-size segment array (e.g., 26 segments) ensures cache efficiency and supports up to 4,294,967,232 items.
- Bit shift operations and compiler intrinsics enable fast index calculation, resulting in approximately 10 x86-64 instructions.
- The data structure can be type-checked using macros without relying on `typeof()` if desired.
- Compared to other list structures, the segment array offers full support for growth, stable pointers, random access, and contiguity.
- It is most beneficial in conjunction with arena allocators and for central arrays storing many entities or samples.
The surprising struggle to get a UNIX Epoch time from a UTC string in C or C++ - Bert Hubert's writings
2 months ago
- Converting UTC time strings to UNIX epoch timestamps in C/C++ is surprisingly difficult due to quirks in POSIX time functions like `mktime()` and `strptime()`.
- `mktime()` ignores `tm_gmtoff` and `tm_zone`, always interprets input as local time, and normalizes `struct tm` with side effects; reusing `tm_isdst` requires resetting to -1.
- `strptime()` with `%z` or `%Z` is unreliable for timezone parsing, and its behavior depends on locale; calling `setlocale()` can break English-only time string parsing.
- The recommended approach for UTC parsing is to use `timegm()` (or `mkgmtime()` on Windows) instead of manipulating TZ environment variable or relying on `mktime()`.
- C++ offers better solutions: `std::get_time` with per-stream locale for locale-independent parsing, and the C++20 timezone library (Howard Hinnant's tz) for robust timezone conversions.
"No way to prevent this" say users of only language where this regularly happens
2 months ago
- A critical vulnerability (CVE-2026-55200) in libssh2 causes heap corruption and remote code execution due to a missing upper bound check in the C code.
- The article satirically notes that such vulnerabilities occur only in C, which is responsible for 90% of memory safety vulnerabilities over the last 50 years.
- Programmers using C describe the situation as helpless, with no way to prevent these issues, echoing a common sentiment among the language's users.
Workarounds for C11 _Generic
2 months ago
- C11's _Generic allows compile-time type-based selection but requires all unselected branches to be semantically valid, limiting its usefulness.
- The main bug is that unselected output expressions must compile without errors, preventing direct use of type-specific operations like field access.
- A workaround is to select only function names inside _Generic and apply arguments afterward, as done in <tgmath.h>.
- When function selection isn't possible, type coercion via nested _Generic with dummy values can maintain semantic validity.
- For multi-type switches, combining types into arrays via type IDs or function pointer types provides a workaround.
- Chaining _Generic with default clauses handles conflicts between standard and typedef integer types.
- Complex workarounds lead to poor error messages with opaque types and exponential macro expansion, potentially causing slow compilation or crashes.
- Despite limitations, _Generic is useful for deliberate compile-time error checking during refactoring (e.g., blocking incorrect free calls).
Making a 3D Modeler, in C, in a Week
2 months ago
- Participated in the Wheel Reinvention Jam and built a 3D modeler called ShapeUp.
- Pivoted from a TypeScript subset to a 3D project using ray marched signed distance fields (SDFs) for a more compelling demo.
- Chose C for its simplicity, fast compilation, and easy WebAssembly compilation; used a static array for shapes to avoid dynamic allocation issues.
- Implemented an immediate mode UI (IMGUI) with an enum for controls, which simplified debugging and layout.
- Criticized raylib for poor parameter validation, use of ints instead of enums, unhelpful bug reports, and lack of responsibility for dependencies like GLFW.
- Followed a layered development approach ensuring the modeler was always functional, building progressively like a pyramid.
- Final project totaled 2024 lines of C and 250 lines of GLSL, capable of exporting .obj files and running on multiple platforms.
Type Safe Generic Data Structures in C
2 months ago
- The article presents a type-safe generic data structure technique in C using unions and macros, avoiding void* and multiple #include approaches.
- A union with a 'payload' member enforces type safety at compile time, catching errors when adding wrong types to structures like linked lists.
- Flexible Array Members (FAM) solve memory and performance issues of void* by storing data within nodes, reducing allocations and cache misses.
- Macros like list_prepend automatically handle size and type enforcement using the ternary operator, with __typeof__() for return type casting.
- Using typedef with the List macro avoids compiler errors from structurally identical union types, though newer compilers may address this.
Beej's Bit Bucket
2 months ago
- Cooperative multitasking lets tasks yield control voluntarily, while preemptive multitasking forcibly takes control after a time slice.
- Function pointers in C store the address of a function and allow indirect calls, with a syntax like `int (*fp)(const char*)`.
- Function pointers are used in standard library functions like `qsort()` and `bsearch()` to pass custom comparison functions.
- A simple cooperative multitasking system can be implemented using an array of function pointers, where each task is a function that runs briefly and returns.
- The example defines three tasks (manatee, goat, bat) and dispatches them in a round-robin loop, demonstrating basic cooperative multitasking.
- Potential improvements include passing data to tasks, using different scheduling algorithms, and dynamic task creation/destruction.
Modern C++ for C Programmers: part 1 - Bert Hubert's writings
2 months ago
- C and C++ are closely related; C code often compiles as valid C++ and C++ includes the entire C library.
- C++ follows the zero-overhead principle: you don't pay for features you don't use, and hand-coded equivalents are not better.
- C++ std::sort outperforms C qsort by 40% due to template inlining and lambda expressions; parallel sort further speeds up sorting.
- C++ std::string offers easy concatenation, searching, and interoperates with C via c_str().
- Modern std::string uses Small String Optimization (SSO) to store short strings without heap allocation, improving cache performance.
- The article encourages C programmers to adopt these C++ features incrementally without overwhelming complexity.
Modern C++ for C Programmers: introduction - Bert Hubert's writings
2 months ago
- Programming languages involve tradeoffs between speed, simplicity, completeness, expressiveness, and safety; perfect languages don't exist.
- Modern C++ (2017 era) is complex but offers a simpler subset that benefits C programmers without using all features.
- The series focuses on C++14 (with some C++17) and selectively covers useful parts like sorting, strings, classes, smart pointers, lambdas, and containers.
- Topics intentionally excluded include multiple inheritance, template metaprogramming, iostreams (except output), locales, user-defined literals, and exotics.
- The goal is to help C programmers consider modern C++ for new projects by learning incrementally, 'one line at a time'.
The Sword Juggling Fallacy
2 months ago
- Sword juggling is simple to explain but difficult to perform safely, serving as an allegory for C programming.
- C is a simple language with a small standard, but programming in C is hard, especially for ensuring correctness.
- Pointers in C are simple in theory but complex in practice, requiring careful management of ownership, lifetime, and memory.
- Rust's complex reference semantics, lifetimes, and borrow checker make it easier to write correct code compared to C.
- Unsafe Rust is compared to juggling chainsaws, highlighting the risks of low-level memory manipulation.
C
2 months ago
- C uses #include to insert entire file contents, not import modules.
- #define and #ifdef are used for constant definitions and conditional compilation.
- The 'static' keyword provides file-scope privacy, similar to private in other languages.
- Pointers store memory addresses; functions can modify variables via pointers.
- Array indexing (a[0]) is equivalent to pointer dereference (*a) and other forms like *(a+0), *(0+a), and 0[a].
- Assigning an array (not an element) to an integer variable causes a compilation error.
Getting silly with C, part &((int*)-8)[3]
2 months ago
- C function definitions can exploit GCC glitches like unnamed parameters and multiple void arguments to bypass modern compiler errors.
- Operator precedence tricks involve empty attributes, typedef rearrangements, and the dual use of && as a label address operator and Boolean AND.
- Goto statements in C can leverage GNU extensions for computed jumps and comma operators to obscure control flow.
- Counting and addition examples demonstrate undefined behavior with unspecified evaluation order of function parameters and zero-sized union types.
- Zero-sized unions allow pointer arithmetic that disregards numerical operands, differing from behavior with void pointers.
Why malloc always does more than I asked for?
2 months ago
- A simple bump allocator works by moving a cursor forward but cannot free individual allocations.
- To support free(), metadata (header) is stored before the user memory to record size and alignment.
- Alignment requirements cause variable padding between header and user memory, making it impossible to locate the header by simple subtraction.
- A back pointer (stored at a fixed offset before user memory) points to the header, solving the alignment-distance problem.
- Internal fragmentation occurs because padding bytes between metadata and user memory are allocated but never used.
- A free list (linked list of freed blocks) enables reuse; first-fit search finds the first suitable block.
- Splitting large free blocks into smaller pieces avoids wasting memory, but leftover fragments must be large enough to hold their own metadata.
- Coalescing merges adjacent free blocks by having both a header and a footer (size stored at both ends of a block).
- Bugs often arise from misalignment of metadata (e.g., FreeNode), or forgetting to write footers on every size change.
Now You Can Work in C with Only BASIC Knowledge
2 months ago
- C Source, Inc. was founded in 1983 and dissolved in 1996, with Gene W. Brown as president and Tom Hogan as a senior programmer and marketing VP.
- BASIC_C was a library for C compilers (Lattice, DeSmet, Computer Innovations) that implemented over 80 BASIC-like functions to help BASIC programmers learn C.
- The library included familiar BASIC commands like INPUT, LPRINT, LOCATE, and INKEY, and came with a well-written manual comparing BASIC and C.
- A 1984 review by Ernest Tello noted that BASIC_C eased the transition to C but warned that line-by-line translations from BASIC might not produce optimal C code.
- The library had some bugs (e.g., the COLOR function did not match IBM BASIC behavior) and lacked math functions, but offered unique functions like BLOAD, BSAVE, and SWAP.
- The product required some C knowledge and was not a full automatic converter; it was a learning aid and conversion tool for BASIC programmers.
C Craft
2 months ago
- Size 0 arrays in GNU C serve as flexible arrays, with C99 supporting similar but disallowing explicit zero size declarations.
- Size 1 arrays can mimic flexible arrays where size 0 is disallowed or enable uniform stack/heap interface with pointer-like syntax.
- Using 'do...while(0)' in macros ensures safe inclusion in conditionals; GNU C's expression statements offer alternatives.
- C's boolean logic, returning 0 or 1, enables Iverson brackets for concise conditions, contrasting with C99's boolean type.
- Tagged pointers leverage alignment bits for metadata storage, requiring masking during dereferencing but can be over-optimized.
- GNU C's nested functions provide closures, simplifying APIs like factorization callbacks, though trampolining may be restricted.
- Goto statements are useful in specific cases like implementing efficient virtual machines (computed goto), inner loops, and coroutines.
- Information hiding via file scope (opaque structs) separates interface from implementation; exposing structs can optimize performance.
- Memory-mapped files allow direct file access via arrays, leveraging kernel paging for efficiency, with 'die' functions for error handling.
- Little languages (e.g., expression interpreters) and metaprogramming (code generators) extend C's capabilities for domain-specific problems.
A bunch of stuff I used to not know about K&R C
2 months ago
- C's grammar is context-sensitive due to single-pass compiler design and lack of function prototype scope in K&R C.
- The 'void' keyword and type qualifiers like 'const' were ANSI inventions; pre-ANSI C used 'int' for returns and had mutable string literals.
- Pre-ANSI C lacked 'signed' specifier, limited type combinations (e.g., no 'unsigned char'), and used 'long float' as synonym for 'double'.
- Integer promotion rules diverged: 'unsigned preserving' vs. 'value preserving' (standardized), with no 'U' suffix and unsigned constants having 'int' type if fitting.
- Octal constants allowed digits 8 and 9; missing escape sequences like '\a', and '\"' was effectively valid via backslash dropping.
- Preprocessor lacked '##', '#', '#elif', 'defined' operator, and predefined macros; line continuations restricted to certain contexts.
- Function declarators lacked typed parameter lists, preventing variadic function declarations; parameters with function types disallowed.
- Structs/unions were limited: no assignments, function parameters/returns, or compound initializers for 'auto' structs/unions.
- Compound assignment operators lexed as two tokens (e.g., '+ ='); original '=+' was single token but obsolete.
- Control reaching 'main' end was implied successful pre-standard, made UB in C89, and special-cased in C99 with implicit return 0.

firstprev0next

c programming

Getopt() but Friendlier

The C ``Clockwise/Spiral Rule''

The Ten Commandments for C Programmers from Henry Spencer (Unix/Plan 9 – 1987)

I Rewrote Json2xml in C–After Making It Fast with Rust

A Fast, Growable Array With Stable Pointers in C

The surprising struggle to get a UNIX Epoch time from a UTC string in C or C++ - Bert Hubert's writings

"No way to prevent this" say users of only language where this regularly happens

Workarounds for C11 _Generic

Making a 3D Modeler, in C, in a Week

Type Safe Generic Data Structures in C

Beej's Bit Bucket

Modern C++ for C Programmers: part 1 - Bert Hubert's writings

Modern C++ for C Programmers: introduction - Bert Hubert's writings

The Sword Juggling Fallacy

C

Getting silly with C, part &((int*)-8)[3]

Why malloc always does more than I asked for?

Now You Can Work in C with Only BASIC Knowledge

C Craft

A bunch of stuff I used to not know about K&R C