Hi,
I'm calling a C library through a D wrapper. The situation is
like this:
C library has:
struct A { ... };
A* create_a() { ... }
void foo(A*) { ... }
D wrapper declares:
extern (C) {
struct A {}
A* create_a();
void foo(A*);
}
My D usercode:
const A* a = create_a();
foo(cast(A*) a);
We know that const is transitive in D and the compiler may
optimize around it. If we cast away const, it's our
responsibility that, e.g., the optimized caching from const will
not cause bugs.
The memory of the A is allocated by the C library. All the D code
ever sees is a pointer, an opaque handle to the resource. How
will the compiler optimizations behave around this:
Question 1. Is that cast still safe in usercode if foo(a) changes
some internal values in *a that are undetectable through the C
API?
Question 2. If yes, can the wrapper sanely declare foo(const A*)
instead of foo(A*)?
My use case: My const-heavy D usercode calls Allegro 5, a C
game/multimedia library without any const in its API, through the
D bindings DAllegro5. I'm considering to make a PR implementing
question 2. Github issue:
https://github.com/SiegeLord/DAllegro5/issues/42
-- Simon
