on interfacing w/C++

[Ellery Newcomer]

(Putting this out there because it sounds like I'm going to get 
scooped in the near future)

So last week I was dinking around with the idea of a library to 
support calling C++ functions. So I wrote some ct code to emulate 
g++ 4.8.2's mangling scheme, and wrote a bit more code to wrap 
it, and calling conventions seemed to work out, and this is what 
I got:

for the C++:

class X {
     public:
         int i;

         X();
         int y();
         void z(int j);

         static int abu(int j);
};

do this:

mixin CppClass!("X",
     typeof(new class {
         int i;
         int y();
         void z(int j);

         static int abu(int j);
     }));
mixin(X.Externs); // waa, issue 12575


it generates something like

struct X {
     int i;
     int y() {
         return _ZN1X1yEv(&this);
     }
     void z(int j) {
         _ZN1X1zEi(&this, j);
     }
     static int abu(int j) {
         return _ZN1X3abuEi(j);
     }
}
extern(C) int _ZN1X1yEv(X*);
extern(C) void _ZN1X1zEi(X*,int);
extern(C) int _ZN1X3abuEi(int);


And it all seems to work. pointer params, reference params, 
variadic params, operators, templates all seem within ready reach.

virtual functions are going to be difficult - I guess you'd have 
to have a complete and accurate list of all fields in the class 
and all its superclasses. And all virtual functions. But g++ 
inserts a vtable symbol for classes with virtual functions - does 
anyone know what the heck that is?

Same for constructing a C++ object from within D - you need a 
valid sizeof.

other compilers won't work as above, the mangling scheme used by 
eg DMC doesn't produce valid D identifiers. Is there a pragma or 
anything to get around this?

And I totally spaced on exceptions until I looked on this forum a 
few minutes ago.

So my plan is to get all these bits implemented, then build a 
tool to validate the C++ and D sides match up, then build a tool 
to generate the D side from C++ headers. And then start expanding 
the list of supported C++ compilers.

Does this sound like a reasonable project? The points of concern 
I am worried about most are:

safety associated with supporting virtual functions
if a c++ mangler is stateful, that would shut me down pretty 
quick.
it requires the C++ compiler/version be specified at a library 
level
exceptions probably won't work