Adding ANSI C11 C compiler to D so it can import and compile C files directly

Lol, he is a paid hype man for the Dlang community, and you should ask him about Symmetry Investments and if they are hiring.

====

make

dmd -c -O -inline -release -ofwarp.o cmdline.d constexpr.d context.d directive.d expanded.d file.d id.d lexer.d loc.d macros.d main.d number.d outdeps.d ranges.d skip.d sources.d stringlit.d textbuf.d charclass.d

util.d(20): Error: function `loc.Loc.write(File* f)` is not callable using argument types `(File function() nothrow @nogc @property ref @system)`

util.d(20): cannot pass argument `& makeGlobal` of type `File function() nothrow @nogc @property ref @system` to parameter `File* f`

directive.d(470): Error: template instance `util.err_warning!(string, string)` error instantiating

context.d(264): instantiated from here: `parseDirective!(Lexer!(Context!(LockingTextWriter)))`

main.d(39): instantiated from here: `Context!(LockingTextWriter)`

Makefile:44: recipe for target 'warp.o' failed

make: * [warp.o] Error 1

====

Not mocking the spelling of the previous post; it's a strange term anyway and in this instance either spelling works.

Marshal = mariscalcus = "horse servant", compare mare and seneschal. Martial = from Mars, god of war.

https://en.wiktionary.org/wiki/marshal

    echo hello.c
    int printf(const char*,...);
    int main() { printf("hello world\n"); }

    dmd hello.c

    ./hello
    hello world

https://github.com/dlang/dmd/pull/12507/files#diff-b94776a02...

Scroll down a bit and you'll see it executes C functions at compile time. I decided to flirt with heresy and leave this in, because it sure makes adding tests convenient!

I'm less sure about adding unittests to the C compiler. Certainly, you can always add the unittests to the D code that is importing the C code. This will probably hold the charges of abomination to a minimum.

1. Even though I have written a C++ compiler, it's a C++98 compiler and C++, like the Winchester House, accretes new features constantly, meaning keeping it up to date is impractical.

2. C++ semantics are different enough from D that it is impractical to mechanically map C++ to D. You can do bits and pieces, and dpp does that, but seamlessly doing the bulk of it isn't going to work. (C can be mapped nearly 100% to D.)

dpp uses libclang to try and map what it can to D.

For me currently D provides a good level of balance between those worlds, but the aforementioned GC isn't an issue for me at all so I have it easy.

I think D should latch and promote more on the idea of having on-demand performance when it's necessary with GC convenience for the rest of the application. Soon having borrow checker capability ala rust and cyclone will only strengthen the narrative.

There are a lot of people in 2021 who - for whatever reason - feel like they need to program personal computers without using GC. As you point history shows that's a lot less true than people think, but nevertheless - that is the sentiment.

Dlang tries spends a lot of effort trying to attract these people, by making more and more of the stdlib nogc, having @nogc annotations, experimenting with deterministic manual memory management etc etc. But I feel like they'll never convert most of them.