The 80s were a dark era of shoddy vendor compilers and shifting standards for pre-ANSI C, but some implementers did interesting things with their compilers to set them apart from the crowd. MetaWare's High C Compiler, in addition to a bunch of nice quality-of-life extensions, had closures and generators with non-local returns, 30-odd years ago!
https://duriansoftware.com/joe/the-lost-language-extensions-of-metaware's-high-c-compiler
Sep 25, 2024, 5:53 AM@joe I remember buying and using it on a Vax.
For anyone eagle eyed: Yes, that does say "DirectToSOM Developers Guide" on that book.
If you want *really* interesting things that people did with their compilers, one of the big ones with #MetaWare #HighC (strictly speaking High C++) was the idea that one could compile C++ classes (with a couple of _Pragmas to annotate things) directly into code that works with IBM's System Object Model, rather than using all of the messy C-style macros.
Sep 25, 2024, 11:54 PM
@erisceleste 👀is there something being proposed now?
@joe coroutines are on my todo for next year (quite a full schedule for this year already)
that's what i was actually referring to, although several of these things are in different levels of progress
@erisceleste that's awesome! would this be a compiler state machine transform style design, like the C++ coroutines, or something more traditional involving swapping stacks etc.?
@joe hopefully a bit of both!
im not a fan of the decisions C++ made here (and it isn't very C-friendly as-is anyway), and do think the heavier-weight design is of more user-facing value in practice, but C is also the language where folks want absolute control, so ... im looking forward to re-litigating all of these choices lol
Sep 25, 2024, 3:05 PM@a @Gte Yeah, the yielded values were typed. You declare a generator with `void generator(ArgType a) -> (YieldType)` to say it yields `YieldType`. That desugars to a closure parameter `void yield(YieldType)`, and the `for` loop syntax desugars to passing the for loop body as a closure argument to the `yield` parameter
Sep 25, 2024, 3:40 PM@joe gonna switch from C99 to High C cause this is *great*
fun fact, it's actually possible to write coroutines in ANSI C abusing __LINE__ and mismatched parenthesis in macros.
https://www.chiark.greenend.org.uk/~sgtatham/coroutines.html
Nowhere near as nice as the that High C thing though.
Sep 25, 2024, 4:47 PM@oblomov @joe much cleaner to use computed gotos, although those aren't universally available https://cohost.org/eniko/post/394049-coroutines-using-com
@oblomov @eniko one limitation with the High C generator design is that it's only sugar over a higher-order function, so you can't pass the generator around and next() it like you would be able to a true coroutine (at least, not without playing hijinks with multiple stacks and setjmp/longjmp)
though it is cool that by supporting nonlocal exits out of nested functions it can still support break/return/continue out of the sugared for loop
I wrote up the #MetaWare iterator-driven for back in 2011, because it was one of those things that had been long-since forgotten about; along with what it would look like were it to be incorporated into the (then) C++ standard.
I am fortunate enough to own a copy of the High C/C++ Language Reference in English; on a shelf right behind me. (-:
http://jdebp.uk/FGA/metaware-iterator-driven-for.html
@JdeBP Nice! What version of the language reference do you have? I've seen a few later versions online, but the Fujitsu docs in Japanese are only ones I've been able to find for the version 1.7 that comes with the TOWNS SDK
(it could also be that Fujitsu re-versioned the compiler when they adopted it, tbf)
@joe closures are not a new thing by a far stretch. But yeah, it took a while for mainstream languages to get them.
But FM Towns was already 1990s, wasn’t it? So already past C89?
All that being said: awesome discovery!
@root42 the first TOWNS models came out February 1989, right before C89 was finalized. So it does have most of the ANSI features like prototypes, `const`, etc. but still refers to the "upcoming" standard
@joe loved the blog post! Do you happen to have the book about TownsGEAR the Visual Basic-like thing on FM Towns?
@gingerbeardman not a full set but I do have the TownsGEAR Dictionary
@joe cool!
@gingerbeardman i'm not really set up here to do full book scans but if you need to look something up let me know
@joe Re case ranges, I believe @erisceleste's https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3354.htm has been accepted for the next version of the standard
@cjwatson @erisceleste awesome!
