
Lisp macros for C - wooby
https://github.com/eudoxia0/cmacro
======
skolos
> Why? Because a language without macros is a tool: You write applications
> with it. A language with macros is building material: You shape it and grow
> it into your application.

Very nice! If only this could work with C++.

------
veli_joza
This is very interesting way to breathe new life into C. I can already think
of few places where powerful macros would come in handy and eliminate some
pains. On the other hand, I'm not sure if I'd want to read other people's low-
level code sprinkled with high-level constructs. Perhaps Nim would serve this
purpose better?

~~~
B1FF_PSUVM
> I'm not sure if I'd want to read other people's low-level code

Write-only languages, yay.

------
yorwba
TIL: You can use typeof(expr) as a type in variable declarations. C has type
inference! A plain old C macro like

    
    
        #define AUTO(var, expr) typeof(expr) var = expr
    

might be handy sometimes.

~~~
smitherfield
`typeof()` is a common compiler extension, not standard C. (C++11 irritatingly
standardized it as `decltype()`).

~~~
lifthrasiir
> [...] irritatingly [...]

Or correctly; it is so common and so different (and incomplete) across
implementations, so a new name with the exact semantics has been invented [1].

[1]
[http://www.stroustrup.com/C++11FAQ.html#decltype](http://www.stroustrup.com/C++11FAQ.html#decltype)

~~~
smitherfield
I understand the reasoning, I just think it's wrong. The point of a standard
is to, well, standardize. And each new version of the standard breaks plenty
of existing (and strictly standards-compliant!) code, often intentionally.

Now a type deduction operator is never going to come to standard C because any
proposal will get buried under endless bikeshedding about whether to call it
`typeof()` or `decltype()`.

~~~
mikeash
I'm not sure about C++, but C tries pretty hard _not_ to break code that
complies with a previous standard unless it's absolutely necessary, and they
put some effort into avoiding breaking common extensions too.

This is why, for example, the language-level boolean type introduced in C99 is
`_Bool`, and then you can include a standard header that will typedef it to
`bool`. Identifiers that begin with an underscore and an uppercase letter are
reserved for the implementation, so no compliant code will be using _Bool
anywhere for itself. And since old code won't include `stdbool.h`, there's no
conflict if it happens to define its own `bool`.

Given this, it seems like the best approach would be to call it `_Typeof` or
similar, with a standard header that does `#define typeof(x) _Typeof(x)` to
make it nicer to use.

------
MrZipf
Thanks for sharing. The documentation is well done, looking forward to
checking out the code.

------
petters
This way of adding metaprogramming to C does not improve performance. The
compiler will still be unable to inline the comparisons in the qsort example.
C++ will continue to be much faster.

~~~
nialv7
It does. It's just no one has come around to write a qsort in macros yet. (And
only then the comparison would be fair)

