Mixed VisualD/C++ project

[Mr.Bingo]

Seems to be a bit weak. I just get a D hello world without any 
cross compilation. For the project, it would be better to have it 
setup to work properly using C++ as the master, since the other D 
projects provide the D side.

I was going to play around with using C++ and D together to see 
if I could get the best of both worlds but the test project only 
provides a bare bones D file. I created a cpp file and added it 
but I Get the error about stdafx. Seems like the project is not 
really setup properly to demonstrate using C++ and D together.

It would be better to have a small "hello world" mixed language 
demo.

In fact, what I'd like to ultimately do is provide a QT gui using 
C++ but a D business end.

The C++ file is programmed to use pre-compiled headers. Setting 
it to 'create' still has issues since none of the pch plumbing is 
taken care of.

I turned off precompiled headers and modified the code:

#include <cstdio>

void main()
{

	printf("hello world");
	getchar();
}


which gets the c++ called(renaming the D main to something else).


by externing and such I can call the D function after 
initializing the runtime.



This is the basic code I have now:


module WindowsApp2;

import std.stdio;
extern(C) int rt_init();
extern(C) int rt_term();

extern(C++) void test()
{
     rt_init();
     writeln("Hello D World!\n");
     getchar();

     rt_term();
}


and


#include <cstdio>


void test();

void main()
{

	printf("hello world");
	test();
	getchar();
}




This is what I'd like to see:

A C++/D mixed project with either the C++ or D as "master"(I 
believe this is just which one defines main) with proper 
initialization and pre-compiled headers. The above is a crude 
approximation of trying to do all that, but I'd expect it to be 
properly done.

The idea would be to provide the proper foundation of doing C++ 
and D mixed projects where very little trouble occurs and one can 
get the full benefit of each language and they interact well.

One of the key issues I think will occur, but not sure since I 
haven't done much C++ and D mixed, is cross referencing symbols 
and a lot of duplicate code must be created so the C++ side can 
see in to D and vice versa.

Maybe a tool can be automated that will take the D exports and 
automatically bring them in to C++ in a nice and easy way rather 
than duplicating code.

Maybe you could get some help of some people that do mixed C++ 
and D code to provide an optimal solution that works well? It 
would be cool if one could use C++ and D easily so that little 
work has to be done. This would alleviate many issues that D 
faces dealing with lack of proper libraries that are in C++. 
(while bindings exist they they generally rot over time and don't 
have all the flexibility that the main version has).


Also, it might be ideal to focus on such a mixed project and have 
the ability to simply set D as the "main" host. In such cases the 
project would reduce to a basic D project with the capabilities 
of adding C++ code. Even if C++ is master, which would require a 
c++ compiler, it can act just as a wrapper. (If Visual D can 
detect that no C++ file is used then it can ignore it)


The biggest thing that worries me is having to do all the 
plumbing between the two, which seems like it could be 
problematic for large projects... and it seems like a lot of this 
stuff could be automated.

e.g.,

    module testmod;

    extern(C++) test();

exports, from D, test.  In C++ we have to include test:

    void test();

this is not too much work, although it creates a dependency(if 
test is renamed then we have to rename all locations).

A few ways to solve this is to have visual D generate a list of 
all extern(C++) exports(or even use attributes to select them 
specifically) and then be able to import them in to C++

    #include "D_CppExports.h"

and D_CppExports.h is automatically created and includes void 
test();

This is not the best solution though as it would contain all the 
functions, might base it off the names of the modules:

    #include "D_CppExports_testmod.h"


Which, since it is automatically generated reduces the dependency 
issues significantly. (only if the module name changes will the 
break occur, which is an easy manual fix)

There might be better ways of doing this stuff, Some 
interlanguage libraries might be useful, for example, using a D 
template in C++ somehow and vice versa. (not sure if it is 
entirely possible but it would work in some cases)

With such a project that can act both as a C++ host and a D host 
there is really no need for the other project type. Allow for GDC 
in the project too.

Just throwing out ideas... I'm hoping getting in to the mixed 
side of things will open a lot of doors but I'm a bit weary it 
might be a lot more trouble than it's worth:

For example, https://dlang.org/spec/cpp_interface.html

using a D class E in C++ requires code duplication:

class E
{
   public:
     virtual int bar(int i, int j, int k);
};


it would be nice if Visual D could generate the C++ mapping 
automatically and then make it easy to import similar to the 
example above that imports a function.


Doing stuff like this reduces dependencies between the C++ and D 
side so that when one changes something on the D side they don't 
have to always go back and change it on the C++ side(which, at 
some point will become overwhelming). Instead, a simple utility 
handles all these dependencies in some way.




Thanks.