Björkus "No time_t to Die" Dorkus

@thephd.dev

💀 The C Standard Cannot Be Replaced And Will Never Be Destroyed. 💀 ✍ Writing: http://thephd.dev 📷 Avatar KIINGKISMET (https://kiingkiismet.com/) 🖼 Banner WusdisWusdat (https://wusdiswusdat.crd.co/)

An image of a potato growing through a wall, its reddish roots climbed up all past the corner of the desk against the wall and spiraling out in all sorts of directions in search of nutrients and water. The text above sets the wall-puncturing, overgrown potato in contrast with its normal counterparts as a metaphor for C++ modularized code:

Normal modules: "You must store us in the right folder next to all our other source files unless you provide an explicit mapping that is also documented by the specification."

C++ modules: "WHERE'S MY TRANSLATION UNITS ?"

$A code snippet which reads: ``cpp #include <stdio.h> #define V0_DEPRECATED 1 const char* v1_name = "treehouse.systems!"; #if defined(V0_DEPRECATED) && (V0_DEPRECATED != 0) [[deprecated("v0_name will be removed in version 2, please upgrade")]] #endif _Alias v0_name = v1_name; _Alias v2_name = v0_name; int main () { printf("v1: %s\n", v1_name); printf("v0: %s\n", v0_name); // diagnostic encouraged printf("v2: %s\n", v2_name); // diagnostic encouraged } ```$

$C code that reads: #include <stdio.h> #define bar(x) _Generic(x, \ int v: v, \ const double: (int)2.0,\ const int v: v * 2,\ struct foo v: v.name \ ) struct foo { char* name; }; extern int x; int fn(void) { return x += 1; } double fnd(void) { return (double)(x += 1); } int main() { struct foo f = { "test" }; int v1 = _Generic(3, int v [[maybe_unused]]: 3); printf("%d (expected: 3)\n", v1); int v2 = _Generic(x, int v [[maybe_unused]]: v, double v: (int)v); printf("%d (expected: 20)\n", v2); bar(f) = "something"; printf("%s (expected: something)\n", f.name); printf("(part 1, x before = %d)\n", x); int v3 = _Generic(fn(), int v: 0, double v: (int)v); printf("%d (expected: 0)\n", v3); printf("(part 1, x after = %d)\n", x); printf("(part 2, x before = %d)\n", x); int v4 = _Generic(fn(), int v: v * v, double v: (int)v); printf("%d (expected: 484)\n", v4); printf("(part 2, x after = %d)\n", x); printf("(part 3, x before = %d)\n", x); int v5 = _Generic(fnd(), int v: v * v, double: 3.0); printf("%d (expected: 3)\n", v5); printf("(part 3, x after = %d)\n", x); const int xc = 20; int v6 = _Generic(xc, int v: v * v, double: 3.0 ); printf("%d (expected: 400)\n", v6); return 0; } int x = 20;$

$Command and console output: cat ./main2.c++ && ./main2.c++.exe || echo return result value: $? #include <embed> #depend "MAINTAINERS" int main () { static constexpr std::span<const unsigned char> data = std::embed<unsigned char>("MAINTAINERS", 0, 1); static constexpr std::span<const std::byte> data2 = std::embed<std::byte>("MAINTAINERS", 3, 1); static constexpr std::span<const char> data3 = std::embed<char>("MAINTAINERS", 6, 2); static_assert(data.size() == 1); static_assert(data[0] == 'N'); static_assert(data2.size() == 1); static_assert((unsigned char)(data2[0]) == 'e'); static_assert(data3.size() == 2); static_assert(data3[0] == '='); static_assert(data3[1] == '='); return (int)data2[0]; } return result value: 101$

Built-in Function: template <typename Ty, typename Ch>
consteval Ty const * __builtin_std_embed (
unsigned int locus, int &sstatus, size_t &out_size, Ty const *indicator_ptr,
size_t resource_name_size, Ch const *resource_name, size_t offset[, size_t limit])

Returns a pointer to backing storage suitably-sized to access out_size elements of a contiguous sequence of const T objects. The signature above is not exact and the builtin does not behave exactly as a function template with Ty and Ch template types, but is a decent approximation for a regular function that can infer Ty and Ch from what is passed in. Template arguments cannot be passed in explicitly and will result in a parsing errors.

locus is broken down as do-local-search = (locus & 0x1) and call-stack-distance = (locus >> 1). do-local-search is whether a local file location-based search should be performed at all. call-stack-distance is the distance that this builtin call is removed from where a normal user would be interfacing with this builtin for aforementioned file-based local search. For example, from within the depths of a std::embed call, locus would likely be 0b101 or 0b111.

Note: The locus argument should typically be 1 (do quoted search) and is typically significant for implementers wrapping this builtin. If you are asking the question "am I an implementer?", then you should probably be passing in a value equivalent to 1 (do quoted search) or 0 (do not do quoted search). Complex recursive calls may require the use of locus with extra depth. In general, it is not advisable to rely on local file-based search: use --embed-dir=... to provide a proper directory and #depend <...> to rely on that directory, with appropriate * or ** markers in the #depend as needed.

The limit argument is optional.

$A code snippet using a new feature of _Generic selection in C, which reads: #include <stdio.h> #define bar(x) _Generic(x, \ int v: v, \ struct foo v: v.name \ ) struct foo { char* name; }; int main() { struct foo f = { "test" }; bar(3); bar(f) = "something"; puts(f.name); // prints "something" }$

A screenshot of an editor open, where a file nam ed "art.txt" has an ASCII-art sheep that's 10 rows tall and 35 columns wide.

$Some beautiful macros: #define expand_if_necessary(ptr, size, idx, small_buf) if (idx == size) { char *new_ptr = XCNEWVEC(char, size * 2); memcpy(new_ptr, ptr, size * 2); if (ptr != small_buf) { free(ptr); } ptr = new_ptr; size *= 2; } #define safe_push(ptr, size, idx, c, small_buf) { expand_if_necessary(ptr, size, idx, small_buf); ptr[idx] = c; ++idx; } #define safe_append(ptr, size, idx, cfirst, csize, small_buf) { for(unsigned int i = 0; i < csize; ++i) { safe_push(ptr, size, idx, cfirst[i], small_buf); } }$

$A screenshot of of a "main.d" file, showing dependencies from a Lua file parsed at compile-time. The full file contents read: main.exe: main.c++ zres\base.lua zres\main.lua$

$A screenshot of a piece of Lua code being processed at compile-time in C++. Notably, it's also able to pull in data from a "requires" clause...! ```cpp int main() { constexpr auto original_file_span = std::embed<char>("zres/main.lua"); constexpr auto original_file = comptime_make_array<original_file_span.size(), true>(original_file_span); constexpr big_buffer glob = recursive_parse("zres/main.lua"); std::printf("original file (\"%s\"):\n\n%s", "zres/main.lua", original_file.data()); std::printf("\n\n=================================================================================\n"); std::printf("`consteval recursive_parse` result:\n\n%s", glob.data()); return 0; } ``` Output: ```sh function main() return 1 + base.value; end ================================================================================= `consteval recursive_parse` result: -- base.lua base = { ["value"] = 30 } function main() return 1 + base.value; end ```$

"...
Implemented the defer draft Technical Specification (WG14 N3734); it is enabled in C mode by passing -fdefer-ts. Note, the details of this feature are subject to change given that the Technical Specification is not yet ratified.
...."

A screenshot of a bug due to unspecified order of operations, where this code works on Windows but fails on non-Windows platforms:

int a = (B_self_transport = x4, x4->B());
int b = (B_self_transport = x5, x5->B());
return a + b;

$Example C2y code showing how a proposed enhancement to _Generic works: #include <stdio.h> #define bar(x) _Generic(x, \ int v: v, \ struct foo v: v.name \ ) struct foo { char* name; }; int main() { struct foo f = { "test" }; bar(3); bar(f) = "something"; puts(f.name); // prints "something" }$

$A code snippet using Apple Blocks in C that reads: static int a(int k, fn_t ^ x1, fn_t ^ x2, fn_t ^ x3, fn_t ^ x4, fn_t ^ x5) { fn_t ^ b = ^(void) { return a(k - 1, b, x1, x2, x3, x4); }; return k <= 0 ? x4() + x5() : b(); }$

An arrow points to a man with an expensive watch and a suit on, with a thick gem-encrusted ring and a diamond earring. He's listening to people's pitches, and the big caption over the top-right of the image is:

"I'M OUT!"
1.3 seconds

showing that he's leaving extremely early and not putting up with this.

A screenshot of the landing page at: https://github.com/llvm/llvm-project/pull/162848

A screenshot of a mail sent to the gcc-patches mailing list on August 2nd, 2025, with the subject:

[PATCH 0/4] implement defer statements as per ts 25755

https://gcc.gnu.org/pipermail/gcc-patches/2025-August/691461.html

A man, panicking, looking around confusedly and saying "No no no no no...".

A brief pause while they keep looking, before their eyes go even wider and they say "wait wait WAIT WAIT WAIT!", trying to prevent the inevitable....

An anthropomorphic sheep is pressed against the window of a stranger's house, looking in as a crescent moon shines above. Their eyebrows are slanted down, half-moon glasses rest on the bridge of their noise and their mouth is curved up in a gleefully sadistic grin. Across their black shirt is emblazoned one word in all caps, detailing them for what they are:

"SICKOS".

They speak as they observe, enjoying every minute of what they're seeing inside the stranger's house: "Yes... Haha HA.... YES!"

A screenshot of the localhost on port 19006, which are the defaults for the Bluesky Webapp service.

A screenshot to the bottom of the design section of the paper, showing an HTML table with a comparison of "C Lambdas" against "Capture Functions".

A screenshot of a table showing various properties of different solutions for functions-with-data. The table and all of the prose can be found at: https://thephd.dev/_vendor/future_cxx/papers/C%20-%20Functional%20Functions.html#intro.solutions

The text is too long to fit into the ALT text, but can be read verbatim here: https://thephd.dev/_vendor/future_cxx/papers/C%20-%20Functional%20Functions.html#intro-nested.functions-security-popularity

A picture of the WINNER OF THE DEMOCRACTIC PRIMARY ZOHRAN MAMDANI with a photoshopped hand offering you a BLUNT BAYBEEEE.

A two-part comic from SUNNY STREET that's been modified.

The first panel is labeled "KNOW THE WORK RULES: APPROPRIATE". A handsome man -- called "Library Vendors" -- in a suit is making a suave pointing gesture with one hand while the other is in his perfectly-ironed grey suit pants. With a smiling smirk, he says "Careful ! Realloc is Dangerous !" to a lady in a red-blouse over a collared white shirt. She responds "Aww, You're Sweet!" While a red heart floats up near her.

Later, A portly man -- called "WG14" -- wearing a sweater-vest with a white button-up, collared shirt, glasses, a brown belt and gold-beige pants stands in the same place as the "Library Vendors" man. He says "Careful ! Realloc is Dangerous !" and the same woman from before immediately grabs her phone and clutches her chest, saying "Hello, Human Resources ?!"

Thanos sits down on his abandoned planet, farming after having destroyed half of the planet.

... Wait a second, this implies that I'm Thanos, doesn't it...?

$A screenshot of the following testing code: extern int n; extern void f(void); #define LO 0 #define HI 50 #if HAVE_CONSTEXPR constexpr int lo = 60; constexpr int hi = 99; #endif #if HAVE_CONSTANTS static const int lo_impl = 100; static const int hi_impl = 241; #endif int main () { switch(n) { #if HAVE_CONSTANTS case hi_impl...lo_impl-1: // Minneapolis 2024 recommendation: DO NOT diagnose!! #endif case HI...LO-1: // Minneapolis 2024 recommendation: DO NOT diagnose!! #if HAVE_CONSTEXPR case hi...lo-1: // Minneapolis 2024 recommendation: DO NOT diagnose!! #endif f(); break; } #if 0 switch(n) { case HI..<LO: // mistake: constraint violated! case hi..<lo: // mistake: constraint violated! f(); break; } #endif return 0; }$

$A screenshot of the following code: _Thread_local static const int x = 1; int main () { _Thread_local static const int y = 1; static_assert(x == 1); static_assert(y == 1); return x + y; }$

$EXAMPLE The following is correct for all implementations where a pointer to void and a pointer to any object type have representational equivalence on a hosted implementation: #include <stdio.h> int main () { static_assert(__STDC_PTR_COMPAT_OBJECT_AND_VOID__ == __STDC_PTR_REPR_EQUIVALENT__, "Representational equivalence is required."); struct toto* p = nullptr; printf("%p\n", p); return 0; }$

$A screenshot of ztd.idk GitHub Actions showing a fraction of tests running and going green$

Everything is now green on the CI -- all four entries.

A screenshot of the landing page for https://ztdthread.readthedocs.io/en/latest/

A screenshot of the full program available at: https://github.com/soasis/thread/blob/main/examples/source/handle_unknown_attribute.c#L47-L89

$A screenshot of a program, showing the output: thread id: 0 thread name: meow?! thread id: 1 thread name: bark?!?! It comes from the following program: #include <ztd/idk/threads.h> #include <ztd/idk/size.h> #include <stdio.h> extern "C" inline int thrd_main(void* arg) { int t_id = *(int*)arg; char name_buf[128] = {}; pthread_getname_np(thrd_current(), name_buf, sizeof(name_buf)); const char* t_name = name_buf; printf("thread id: %d\n", t_id); printf("thread name: %s\n", t_name); printf("\n"); thrd_exit(t_id); } int main() { thrd_t t0 = {}; thrd_t t1 = {}; ztdc_thrd_attr_name name_attr = { // format .kind = ztdc_thrd_attr_kind_name, .name = "meow?!" }; ztdc_thrd_attr_stack_size stack_size_attr = { .kind = ztdc_thrd_attr_kind_stack_size, .size = 1'024, }; struct ztdc_thrd_attr_priority { ztdc_thrd_attr_kind kind; int priority; } priority_attr = { // some custom attribute or whatever .kind = ztdc_thrd_attr_kind_impl_def_priority, .priority = INT_MAX, }; ztdc_thrd_attr_kind* attrs[] = { &priority_attr.kind, &stack_size_attr.kind, &name_attr.kind, }; int t0_id = 0; ztdc_thrd_create_attrs(&t0, thrd_main, &t0_id, ztdc_c_array_size(attrs), attrs); name_attr.name = "bark?!?!"; int t1_id = 1; ztdc_thrd_create_attrs(&t1, thrd_main, &t1_id, ztdc_c_array_size(attrs), attrs); int res0 = 0; int res1 = 0; thrd_join(t0, &res0); thrd_join(t1, &res1); return res0 + res1; }$

An anthropomorphic sheep with their hands held up near their face, fingers pointing up. Their head is leaned forward just a tiny bit, their eyebrows are up high, their eyes are open very wide even while their pupils are very constricted and beady just over their half-spectacles. They look very bothered, and are saying

"Listen Motherfucker,"

A picture of Björkus in Waluigi Cosplay, and Aria in Wario Cosplay. They definitely look like they have nefarious intentions, and could easily force-wario you....

A screenshot of the presentation "A small Attempt at Unicode". There's a frantic handdrawn underline on part of the screen which reads:

"1st priority: figure out how to interact with the committee - do this with less-important std::embed(...) proposal (unrelated)".

There's then a frantic green circle around the top of the screen showing the date of the presentation, which is 2018.03 -- or March 2018. Fuck!

A picture of Inigo Montoya in the later scene of the film The Princess Bride. The subtitle under his picture reads:

"Hello. My name is Inigo Montoya. You killed my father. Prepare to die."

And beneath that is a brown-background, white-text explainer of:

"Inigo's Guide to Networking Success.

1. Polite Greeting
2. Name
3. Relevant Personal Link
4. Manage Expectations"

A word cloud showing all the cities where people submitted survey entries from. It's got places from almost every continent on there, from Prague to Seattle to Rio de Janeiro to Gdynia to Vancouver, even the Hague!

$A code screenshot, which reads: #include <stdio.h> int main () { THE_WHOLE_DAMN_LOOP: for (int i = 0; i < 20; ++i) { switch (i %2) { case 0: break; case 1: break THE_WHOLE_DAMN_LOOP; } printf("after switch, end of for: %d", i); } }$