This shows many pitfalls regarding conversion of 32 bit code to 64, some of
them are relevant for D code too:
http://www.gamedev.net/reference/articles/article2767.asp
On 32 bit D systems this compiles with no errors, while on 64 bit D this
probably requires a cast:
size_t foo() { return -1; }
void main() {
uint r = foo();
}
I'd like D to be designed to make 32=>64 porting as bug-free as possible, so
dmd may guard against some possible 64bit troubles even if the code is compiled
in 32 bit mode. So I think size_t=>uint may require a cast on 32 bit systems
too, so when the code gets compiled with the 64 bit dmd this error isn't
present.
---------------
With the 32 bit DMD this code works:
void main() {
int x;
int* ptr = &x;
uint y = cast(uint)ptr;
// ... usage of y
}
The cast() silences the compiler on 64 bit systems too, but on 64 bit systems
this may be more correct:
size_t value = cast(size_t)ptr;
A cast() is a way for the programmer to express the desire to punch a hole in
the type system, but in my opinion not all casts are equally unsafe. Some of
them are _more_ bug-prone than others. On 64 bit systems a pointer=>uint cast
is less safe than a pointer=>size_t cast or a pointer=>ptrdiff_t cast, because
it's a lossless transformation.
(In practice I think that a pointer=>uint is a bad thing even in 32 bit code,
when a sign is really necessary it's probably better to use ptrdiff_t on 32 bit
systems too).
So 64 bit DMD may show a warning for pointer=>uint casts, I don't know.
Bye,
bearophile
