Suppose that I have a signed integer type coming from a header
file, and that I already know that this integer type is a 64-bit
type. (Think off_t, for example.) If I'm using gcc on a machine
where both long and long long also have 64 bits, is there any
simple C99 (+ gcc extension) code that will allow me to figure
out whether this type is ultimately defined as long or long long?
The original motivation was to avoid gcc -Wall warnings when
doing:
off_t my_offset;
...
printf("%lld", my_offset);
If off_t is defined as long rather than long long then this will
give a warning, even though the sizes match. (So of course,
this actually gives a programmatic way to distinguish: have
a configure script do a test compilation with -Wall -Werror.
But I'm looking for a simple C expression or function that
could detect the difference.)
It seems that some LP64 platforms (e.g., OS X 10.6) define
off_t to be long long, while others (e.g., Linux/x86_64, or at least
the three different flavours of Linux that I tested) define off_t
to be long.
Of course, the solution to avoiding printf warnings is as easy
as adding a cast:
printf("%lld", (long long)my_offset);
so in this particular motivating case there isn't really
any problem. But I'm still curious to know
whether there's a simple way for a gcc *user* to distinguish
between long and long long when both are 64 bits. typeof
doesn't seem to help here. I guess I'm really after some
imaginary extension 'rank_of' that lets me do
if (rank_of(off_t) == rank_of(long long))
< code using %lld >
else
< code using %ld >
...
Mark
