On Tuesday, 25 May 2021 at 11:38:03 UTC, evilrat wrote:
I did some basic testing with code above, it seems class layout
is recursively linear at least on Windows, and D follows C++
rules close enough, at least it works if one comments out all
but the first base, and the rest can be hand crafted using
structs and templates.
With this code it is possible to pass back C++ class received
from C++ code and call it.
So it seems support for multiple inheritance shouldn't be that
hard to implement (for Windows), no idea how it works on Linux
though.
Maybe I'll be able to create templated base class that does all
this stuff with mixins and templates.
like this
```d
extern(C++)
abstract class MultipleInheritance(T...)
{
// implementation //
}
class Derived : MultipleInheritance!(Base1, Base2)
{ ... }
```
Oh this is brilliant! Absolutely incredible work + findings!
Is this conceptually similar at all to this bit of code that adr
had given to me?
```d
// Same thing repeated for Abstract2
interface Abstract1 {
/* virtual */ void overrideMe1();
void sayHello();
mixin template Abstract1Impl() {
void sayHello() { import std.stdio; writeln("Hello"); }
}
}
class MyClass : Abstract1, Abstract2 {
mixin Abstract1Impl; mixin Abstract2Impl;
override void overrideMe1() { writeln("overrode 1"); }
override void overrideMe2() { writeln("overrode 2"); }
}
void main() {
auto it = new MyClass();
it.sayHello(); it.sayGoodbye();
it.overrideMe1(); it.overrideMe2();
}
```
---
Also, I wonder if there's a good way to build a quick CLI
visualization + debugging tool for this using D's `.vtble[]`
method. I would find it really useful for learning =D
There are also some automatic ABI compliance checker
tools/libraries, which could be good for programmatically
verifying that the class produced by D is valid with the ABI of a
method/class from a C++ library file.
(I know for example, that Qt does this with their Python codegen
tool, `Shiboken`, for auto-testing the generated code)
-
https://sourceware.org/libabigail/manual/libabigail-overview.html
- https://github.com/lvc/abi-compliance-checker (this is what
Shiboken is/was using)
... libabigail provides facilities to perform deep comparisons
of two ABIs. That is, it can compare the types of two sets of
functions or variables and represents the result in a way that
allows it to emit textual reports about the differences.
This allows us to write tools like `abidiff` that can compare
the ABI of two shared libraries and represent the result in a
meaningful enough way to help us spot ABI incompatibilities.
There are several other tools that are built using the Abigail
framwork.
```sh
$ g++ -g -Wall -shared -o libtest-v0.so test-v0.cc
$ g++ -g -Wall -shared -o libtest-v1.so test-v1.cc
$
$ ../build/tools/abidiff libtest-v0.so libtest-v1.so
Functions changes summary: 0 Removed, 1 Changed, 0 Added function
Variables changes summary: 0 Removed, 0 Changed, 0 Added variable
1 function with some indirect sub-type change:
[C]'function void foo(S0&)' has some indirect sub-type changes:
parameter 0 of type 'S0&' has sub-type changes:
in referenced type 'struct S0':
size changed from 32 to 64 bits
1 data member insertion:
'char S0::inserted_member', at offset 0 (in bits)
1 data member change:
'int S0::m0' offset changed from 0 to 32
```
