On Saturday, 4 November 2023 at 12:21:45 UTC, Johan wrote:
On Saturday, 4 November 2023 at 12:01:11 UTC, Emmanuel Danso
Nyarko wrote:
On Saturday, 4 November 2023 at 11:18:02 UTC, Dadoum wrote:
```d
extern (C) void hello(string arg) {
import std.stdio;
writeln(arg);
}
```
Compiles fine with dmd, ldc2 and gdc.
```d
extern (C++) void hello(string arg) {
import std.stdio;
writeln(arg);
}
```
Doesn't compile.
DMD: `Internal Compiler Error: type `string` cannot be mapped
to C++`
GDC and LDC2: `function 'example.hello' cannot have parameter
of type 'string' because its linkage is 'extern(C++)'`
And I am wondering why the type can be mapped to a template
in C but not in C++. (you can see the template used when you
compile with `-H --HCf=./header.h`
So C-strings are just an array of characters that are governed
by simple functions and D strings also defined the same.
This is not true. D string (=slice) variables store the length
of the string in addition to the reference to the array of
characters.
The reason this "works" with `extern (C)` is because the C
mangling of a function name does not include the type of the
parameters. Note that C does not have a `string` type, so to
call the function from C you will have to write a different
function signature in C (you'll see that `char[]` will not
work).
It does not work with `extern(C++)` because the C++ mangling of
a function _does_ include the type of the parameters, and there
is no built-in C++ type that is equivalent to D's `string`.
-Johan
You're right but that's not what he's looking for I think. He
wants to understand why it doesn't compile at all. One major
cause of failed compilation is syntax disagreements And my main
point is that because C++ doesn't know independent 'string' and
that the string in C++ is a standard template library, the D
compiler decides to stop any symbol generated interaction with
string because C++ syntatically doesn't know 'string'.
Maybe the compiler team could provide a better answer to him but
that's what I think.
