Accessing C++ code from D

[James Dunne]

Walter Bright wrote:
> I want to sum up some issues that would have to be resolved in order for 
> D code to call some arbitrary C++ code that is presumed to be 
> unmodifiable. This list certainly isn't complete, I just write it to 
> show the scope of the difficulties involved.
> 
> 1) D source code is unicode, C++'s is ascii with code pages. Or not. 
> It's unspecified. This impacts the contents of string literals.
> 
> 2) std::string cannot deal with multibyte UTF.
> 
> 3) C++ has a tag name space. D does not. Some sort of renaming would 
> have to happen.
> 
> 4) C++ code often relies on compiler specific extensions.
> 
> 5) C++ has namespaces. D has modules. There is no obvious mapping 
> between the two.
> 
> 6) C++ views source code as one gigantic file (after preprocessing). D 
> sees source code as a hierarchy of modules and packages.
> 
> 7) Enum name scoping rules behave differently.
> 
> 8) C++ code, despite decades of attempts to replace macro features with 
> inbuilt ones, relies more heavily than ever on layer after layer of 
> arbitrary macros. There is no D analog for token pasting or stringizing.
> 
> 9) Macro names have global scope across #include files, but are local to 
> the gigantic source files.
> 
> 10) C++ has arbitrary multiple inheritance and virtual base classes. D 
> does not.
> 
> 11) C++ does not distinguish between in, out and inout parameters.
> 
> 12) The C++ name mangling varies from compiler to compiler.
> 
> 13) C++ throws exceptions of arbitrary type, not just descendents of 
> Object.
> 
> 14) C++ overloads based on const and volatile. D does not.
> 
> 15) C++ overloads operators in significantly different ways - for 
> example, operator[]() overloading for lvalue and rvalue is based on 
> const overloading and a proxy class.
> 
> 16) C++ overloads operators like < completely independently of >.
> 
> 17) C++ overloads indirection (operator*).
> 
> 18) C++ does not distinguish between a class and a struct object.
> 
> 19) The vtbl[] location and layout is different between C++ and D.
> 
> 20) The way RTTI is done is completely different. C++ has no classinfo.
> 
> 21) D does not allow overloading of assignment.
> 
> 22) D does not have constructors or destructors for struct objects.
> 
> 23) D does not have two phase lookup, nor does it have Koenig (ADL) lookup.
> 
> 24) C++ relates classes with the 'friend' system, D uses packages and 
> modules.
> 
> 25) C++ class design tends to revolve around explicit memory allocation 
> issues, D's do not.
> 
> 26) D's template system is very different.
> 
> 27) C++ has 'exception specifications'.
> 
> 28) C++ has global operator overloading.
> 
> The bottom line is the language features affect the design of the code. 
> C++ designs just don't fit with D. Even if you could find a way to 
> automatically adapt between the two, the result will be about as 
> enticing as the left side of a honda welded to the right side of a camaro.

And if that wasn't enough to turn you off to the idea, then you could 
try to use Lightweight C++ 
<http://students.ceid.upatras.gr/~sxanth/lwc/> to translate your 
extremely-dumbed-down C++ code into C code.  For best interoperability 
with DMD, you'd have to compile the C code with DMC.

Slight caveat: "To compile the generated C you need gcc or another 
compiler with support for: C99 designators, compound statements in 
expressions and typeof."  Does DMC fit this bill?

Disclaimer:  I realize this is to the point of absurdity, but I would 
try to make the point that it is no more absurd than to expect any more 
out of a language (C++) that has designed itself into a corner.

-- 
-----BEGIN GEEK CODE BLOCK-----
Version: 3.1
GCS/MU/S d-pu s:+ a-->? C++++$ UL+++ P--- L+++ !E W-- N++ o? K? w--- O 
M--@ V? PS PE Y+ PGP- t+ 5 X+ !R tv-->!tv b- DI++(+) D++ G e++>e 
h>--->++ r+++ y+++
------END GEEK CODE BLOCK------

James Dunne