cmacro

Couple of others: c-mera: https://github.com/kiselgra/c-mera cmacro: https://github.com/eudoxia0/cmacro (This one one is implemented in Common Lisp for its semantics, but doesn't use a S-exp surface syntax for the code.) sxc: https://github.com/burtonsamograd/sxc (incomplete) MetaC: https://github.com/mcallester/MetaC (References Lisp in readme; doesn't use it for implementation or notation, but references ideas. Source code seems to be a core of .c files, and the rest self-hosted in its own .mc language. Somehow provides a REPL.)

>Looking for prior implementations of this idea I’ve found magma (2014), where it is called doto. It is a macro for the cmacro[0] pre-processor Hey, that's me! I wrote cmacro. I'm glad someone has built a newer and better alternative (cmacro is a big mess inside and has some significant parser errors :P). Related to the backstitch operator, I've wondered about implementing a transform to turn code like: type_t value = allocate(); operate(value); operate(value); destroy(value); Into: type_t value = allocate(); type_t tmp1 = operate(value); type_t tmp2 = operate(tmp1); destroy(tmp2); To implement something like linear types[1] in C, such that each instance of type_t must be used once and only once. But I imagine this would require too much integration with the type system and code analysis. I wish binary inclusion was prov

Some well-known existing work in this exact area: https://github.com/kiselgra/c-mera https://github.com/eudoxia0/cmacro (Written in Common Lisp, doesn't use S-exp syntax) https://github.com/tomhrr/dale (Prev disc: https://news.ycombinator.com/item?id=14079573) Newer stuff: https://github.com/saman-pasha/lcc (No mention of meta-programming) Lesser known: https://github.com/deplinenoise/c-amplify (No docs, no update since 2010)

James Gosling, 1989: https://swtch.com/gosling89ace.pdf Fernando Boretti: https://github.com/eudoxia0/cmacro

How is it different from https://github.com/eudoxia0/cmacro and https://github.com/eudoxia0/magma ?

There's L++: https://bitbucket.org/ktg/l And, for people who refuse to let go of curly braces, there's this shameless plug: https://github.com/eudoxia0/cmacro

I implemented my own, but I'll definitely check out jemalloc. I happen to have a use case for allocating large chunks aligned on large boundaries (high-performance garbage collector). jemalloc is common enough that I suppose it's not a particularly bad dependency. Adding Lisp-style AST macros to C is never gonna happen[1], though it would be cool. I'm of the opinion that text macros and ‘real’ macros complement each other anyway. One of these days I'll get around to implementing a less-portable-more-cool-C. There's Jai[2], but I don't really agree with all of its design (understandable, since I'm not a game developer). -- 1. Just kidding, people have done it already; e.g. https://github.com/eudoxia0/cmacro but it'll probably never be part of the standard. 2. https://github.com/BSVino/JaiPrimer/blob/master/JaiPrimer.md

There is a project by Fernando Borretti for Lisp-style macros in C, with macro expander written in Common Lisp: https://github.com/eudoxia0/cmacro, and a collection of basic macros: https://github.com/eudoxia0/magma This way he has already added lambdas, lazy evaluation, types, anaphoric macros, with- macros.

> Firstly, Racket is not a Scheme. Did I talk about Racket anywhere? > Does this look like S-expressions to you? "MiniPacal implemented in Racket" Are you really arguing that implementing some other language is the way to go? https://github.com/eudoxia0/cmacro http://research.swtch.com/shmacro Totally legit "C".

implemented with a Common Lisp preprocessor: https://github.com/eudoxia0/cmacro

I wrote cmacro[0] and magma[1] with the goal of a augmenting C while keeping it C-like. [0]: https://github.com/eudoxia0/cmacro [1]: https://github.com/eudoxia0/magma