c++ interop in the library (just for fun)

[Adam D. Ruppe]

So now that there's a pragma(mangle), we can start hacking this 
up! I'm using Linux g++ 32 bit.

C++:
class Class {
public:
        Class() {}// printf("constructed\n"); }
        virtual void addNum(int a) { num += a; }
        virtual void addNum2(int a) { num2 += a; }

        void talk() { printf("%d %d\n", num, num2); }
        int num;
        int num2;
};


D:

        struct Class {
                extern(C++) interface Vtable {
                        void addNum(int num);
                        void addNum2(int num2);
                }
                mixin CPlusPlusObject!(Vtable, typeof(this));

                void cppCtor();

                extern(C++) void talk();
                int num;
                int num2;
        }

magic D:


        string cppMangleCtor(alias Func)() {
                import std.conv;
                string m = "_ZN";
                string cn = __traits(parent, Func).stringof;
                m ~= to!string(cn.length) ~ cn;
                m ~= "C2Ev"; // fixme: the actual argument list
                return m;
        }

        string CppCtors(T)() {
                string code;

                foreach(member; __traits(allMembers, T)) {
                        static if(member == "cppCtor") {
                                code ~= "pragma(mangle, 
`"~cppMangleCtor!(__traits(getMember, T, member))~"`) static 
extern(C++) void cppConstructor("~T.    stringof~"*);";
                                code ~= "\n";
                                code ~= "static " ~ T.stringof ~ 
" opCall() {
                                        auto c = 
"~T.stringof~".init;
                                        cppConstructor(&c);
                                        return c;
                                }";
                        }
                }
                return code;
        }

        mixin template CPlusPlusObject(Virtuals, Main) {
                void* virts;
                Virtuals getVirtuals() { return cast(Virtuals) 
&this; }
                alias getVirtuals this;

                @disable this();

                mixin(CppCtors!Main());
                pragma(msg, CppCtors!Main());
        }



Test functions, D:

extern(C++)  void doit(Class*);
extern(C++)  void whoa(Class* c) {
                import core.stdc.stdio;
                printf("whoa\n");
                c.num += (30);
                c.talk();

                c.addNum(10);
        }


void main() {
        import std.stdio;
        writeln("MOVING ON");
        auto c = Class.opCall();
        doit(&c);
        writeln("All Done!");
}


C++:


extern void whoa(Class* c);

void doit(Class* ptr) {
        if(ptr == NULL)
                ptr = new Class2();

        ptr->num = 10;
        ptr->num2 = 20;

        ptr->talk();
        whoa(ptr);
        ptr->talk();
}


Output:

$ ./testcpp
MOVING ON
constructed
10 20
whoa
40 20
50 20
All Done!



No crash! Now, normally, I'd say we should probably construct the 
objects in their native language, but I just had to try this and 
the fact that it worked I thought was pretty cool.

Here we see access to both virtual and non-virtual member 
functions of the C++ object from D, as well as direct access to 
the member variables! Liable to break? Oh yeah. Hacky? 
Definitely. But I thought this was kinda cool.

Inheritance can work too, but there's still a ways to go to make 
that right. (It works easily enough if you just access virtuals 
though, D's plain extern(C++) interface can do that.)



Maybe if we were to see this through it could be a good enough 
hack for some real world use too.