c4 VS neat

The C4 compiler [https://github.com/rswier/c4] is a self-hosting compiler for a subset of the C programming language that produces executable x86 code. You can understand and audit this code in a couple of hours (its 528 lines).

It could be an interesting exercise to bootstrap up from something like this to a working linux environment based solely on source code compilation : no binary inputs. Of course a full linux environment has way too much source code for one person or team to audit, but at least it rules out RoTT style binary compiler contamination.

I was surprised to see nodes still have two pointers ("references") given that you now know that that the first pointer will always point exactly to the next node. I've see https://github.com/rswier/c4 use that. Granted it doesn't make for the most readable code, but it's even smaller and faster.

VMs with simple instruction sets is a fun topic. Some years ago I got inspired by the amazing rswier/c4 compiler by Robert Swierczek and explored the smallest instruction set I could get away with to create VMs that could run non-trivial workloads.

C4 comes to mind (C in 4 functions), https://github.com/rswier/c4.

have you considered adding a backend for LLVM? perhaps a bit heavyweight, but it could be a good way to get C/C++, fortran, rust, etc. if that's something you'd like!

I use Alpine Linux (no GNU bloat btw), dwm (Sucks less!), and I edit all my C (no bloat language) through busybox ed and compile my programs with (c4)[https://github.com/rswier/c4]

Keep in mind you can create a "usable" C compiler by yourself, and is doable in surprisingly low amount of code. Try https://github.com/rswier/c4/blob/master/c4.c

It runs on plain C ABI, so you can just define C functions as `extern(C)`, just as you would in D. But you can also use `std.macro.cimport` to import C headers directly. Check out the Dragon demo, https://github.com/Neat-Lang/neat/blob/master/demos/dragon.n... :

    macro import std.macro.cimport;

Funny sidestory: The way my compiler ( https://github.com/neat-lang/neat ) used to build is, two years ago there was an initial compiler that was written in D. And every time you checked it out on a new system, there was a file with a list of breaking commits, and it would:

- git clone itself in a subfolder

Sure, but keep in mind it's pre-pre-alpha and the current released version is kind of outdated (ping me if you actually want to try it):

https://github.com/neat-lang/neat

This is more a D-like than a C-like, but it only breaks C syntax in areas where IMO C straight up made the wrong call, like the inside-out type syntax.

The thing I'm most proud of is the full-powered macro system, which is really more of a compile-time compiler plugin system.

A good example of a macro would be listcomprehensions: https://github.com/Neat-Lang/neat/blob/master/src/neat/macro...

You can tell it's just compiler code that happens to be loaded at project compiletime.

`compiler.$expr xxx` is itself a macro, that parses an expression `xxx` and returns an expression that creates a syntax tree that, when compiled, is equivalent to having written `xxx`. It's effectively the opposite of `eval`. In that expression, `$identifier` is expanded to a variable reference to "identifier".

So `ASTSymbol test = compiler.$expr $where && $test;` is equivalent to `ASTSymbol test = new ASTBinary("&&", where, test)`. (This shows its worth as expressions become more expansive.)

All in all, this lets you write `bool b = [all a == 5 for a in array]`, and it's exactly equivalent to a plain for loop. You can see the exact for loop at line 103 in that file. `({ })` is stolen from gcc; google "statement expression".