On Monday, 10 February 2014 at 23:29:25 UTC, Ola Fosheim Grøstad
wrote:
On Monday, 10 February 2014 at 23:13:56 UTC, deadalnix wrote:
You seems to knows everything in and out. You tell me. If you
aren't sure, please start parsing D to clang AST. After all,
that sound like a great idea.
No, I don't know everything, but I said "modified subset of D",
that would be a different language. Suitable for my needs (I
don't need RTTI or exceptions etc).
I know I can do it, because source-2-source compilation is not
that difficult and could be the first step. And (slow) parsers
are not so difficult to write with the tools we have today.
After looking at the SVN repositories for clang I am becoming a
bit more familiar with the source code which looked chaotic the
first time I looked at it.
The AST looks ok from skimming through the repository, I assume
I can get it through a visualization tool and generate visual
graphs of the hierarchies.
Long story short, if you want to map thing on top of clang AST,
you'll have to reduce significantly the subset of D you want to
use, or build a full fledged front end, at which point you'd
better use LLVM directly or GCC, or whatever backend suit your
desires.
For instance, static ifs, template constraints and CTFE require
full understanding of language semantic by the frontend. Runtime
reflection, is also out. That mean UDA could work but become
useless. Type inference also require almost complete
understanding of the language by the frontend.
And even with these drastic restrictions, you'll still need a
significant amount of semantic analysis in the frontend before
feeding clang. You'll have to instantiate templates yourself (or
bye bye alias parameters, string parameters and so on). Track
variables used in closures (well, on that one you can arguably
allocate every stack frame on heap and pas the whole stack frame
to C++ lambda, that should work, but that will excruciatingly
slow and memory consuming) to allocate them on heap.
With CTFE, compile time reflection and static ifs/mixins, D wraps
around itself in a way that makes it all or nothing in
implementation.
