On Friday, 23 January 2015 at 11:04:12 UTC, Walter Bright wrote:
Mandatory reddit link:
There's been a lot of interest in this topic.
I wonder if two things could happen:
1. A tool could be written to generate the interfacing code in D
from the C++ code?
2. If, in your stl example, the default argument could be
automatically inferred from the mangling?
What I mean is, Do we really need to know the default arguments
or are we just having to explicitly use them to make the name
If it is the latter, then surely couldn't the D compiler sort of
have a "wild card" type of default parameter where the compiler
allows any such argument to work?
i.e., unless we are actually explicitly needed the default
argument in some way it seems that we can just derive it's
"mangled" version from the C++ object data and use that directly
in the D mangled version?
Essentially the D compiler mangles what it can then substitutes
the part of the mangled name in C++ for "unknown things" into the
D mangled name.
I just see that if we are "linking" then why would one have to
"implement" anything? Just essentially "Copy" the mangling from
C++ object data.
3. Hopefully a mapping table is used instead of having to
actually have implementations for very compiler?
essentially implement a standard ABI in D, map each C++ compilers
mangling version to that instead of implementing each C++
It seems that 99% of the problem is translation in nature and
that one can auto generate D interfaces from C++ mangled names.
(in fact, one could go a "step" further then and simply reverse
C++ object code into D code)