Most usual functions can either be missing, or be buggy, or be limited on some architectures. This section tries to make an inventory of these portability issues. By definition, this list always requires additions. Please help us keeping it as complete as possible.
exit
exit
returned int
.
This is because exit
predates void
, and there was a long
tradition of it returning int
.
On current hosts, the problem more likely is that exit
is not
declared, due to C++ problems of some sort or another. For this reason
we suggest that test programs not invoke exit
, but return from
main
instead.
free
free (NULL)
does nothing, but
some old systems don't support this (e.g., NextStep).
isinf
isnan
isinf
and isnan
are
macros. On some systems just macros are available
(e.g., HP-UX and Solaris 10), on
some systems both macros and functions (e.g., glibc 2.3.2), and on some
systems only functions (e.g., IRIX 6 and Solaris 9). In some cases
these functions are declared in nonstandard headers like
<sunmath.h>
and defined in non-default libraries like
-lm or -lsunmath.
The C99 isinf
and isnan
macros work correctly with
long double
arguments, but pre-C99 systems that use functions
typically assume double
arguments. On such a system,
isinf
incorrectly returns true for a finite long double
argument that is outside the range of double
.
The best workaround for these issues is to use gnulib modules
isinf
and isnan
(see Gnulib). But a lighter weight
solution involves code like the following.
#include <math.h> #ifndef isnan # define isnan(x) \ (sizeof (x) == sizeof (long double) ? isnan_ld (x) \ : sizeof (x) == sizeof (double) ? isnan_d (x) \ : isnan_f (x)) static inline int isnan_f (float x) { return x != x; } static inline int isnan_d (double x) { return x != x; } static inline int isnan_ld (long double x) { return x != x; } #endif #ifndef isinf # define isinf(x) \ (sizeof (x) == sizeof (long double) ? isinf_ld (x) \ : sizeof (x) == sizeof (double) ? isinf_d (x) \ : isinf_f (x)) static inline int isinf_f (float x) { return !isnan (x) && isnan (x - x); } static inline int isinf_d (double x) { return !isnan (x) && isnan (x - x); } static inline int isinf_ld (long double x) { return !isnan (x) && isnan (x - x); } #endif
Use AC_C_INLINE
(see C Compiler) so that this code works on
compilers that lack the inline
keyword. Some optimizing
compilers mishandle these definitions, but systems with that bug
typically have many other floating point corner-case compliance problems
anyway, so it's probably not worth worrying about.
malloc
malloc (0)
is implementation
dependent. It can return either NULL
or a new non-null pointer.
The latter is more common (e.g., the GNU C Library) but is by
no means universal. AC_FUNC_MALLOC
can be used to insist on non-NULL
(see Particular Functions).
putenv
setenv
to putenv
; among other things,
putenv
is not required of all Posix implementations, but
setenv
is.
Posix specifies that putenv
puts the given string directly in
environ
, but some systems make a copy of it instead (e.g.,
glibc 2.0, or BSD). And when a copy is made, unsetenv
might
not free it, causing a memory leak (e.g., FreeBSD 4).
On some systems putenv ("FOO")
removes ‘FOO’ from the
environment, but this is not standard usage and it dumps core
on some systems (e.g., AIX).
On MinGW, a call putenv ("FOO=")
removes ‘FOO’ from the
environment, rather than inserting it with an empty value.
realloc
realloc (NULL, size)
is equivalent
to malloc (size)
, but some old systems don't support this (e.g.,
NextStep).
signal
handlersignal
takes a handler function with a return type of
void
, but some old systems required int
instead. Any
actual int
value returned is not used; this is only a
difference in the function prototype demanded.
All systems we know of in current use return void
. The
int
was to support K&R C, where of course void
is not
available. The obsolete macro AC_TYPE_SIGNAL
(see AC_TYPE_SIGNAL) can be used to establish the correct type in
all cases.
In most cases, it is more robust to use sigaction
when it is
available, rather than signal
.
snprintf
snprintf
and vsnprintf
truncate the output and return the number of bytes that ought to have
been produced. Some older systems return the truncated length (e.g.,
GNU C Library 2.0.x or irix 6.5), some a negative value
(e.g., earlier GNU C Library versions), and some the buffer
length without truncation (e.g., 32-bit Solaris 7). Also, some buggy
older systems ignore the length and overrun the buffer (e.g., 64-bit
Solaris 7).
sprintf
sprintf
and vsprintf
return the
number of bytes written. On some ancient systems (SunOS 4 for
instance) they return the buffer pointer instead, but these no
longer need to be worried about.
sscanf
sscanf
requires
that its
input string be writable (though it doesn't actually change it). This
can be a problem when using gcc since it normally puts
constant strings in read-only memory (see Incompatibilities of GCC). Apparently in some cases even
having format strings read-only can be a problem.
strerror_r
strerror_r
returns an int
, but many
systems (e.g., GNU C Library version 2.2.4) provide a
different version returning a char *
. AC_FUNC_STRERROR_R
can detect which is in use (see Particular Functions).
strnlen
strnlen ("foobar", 0) = 0 strnlen ("foobar", 1) = 3 strnlen ("foobar", 2) = 2 strnlen ("foobar", 3) = 1 strnlen ("foobar", 4) = 0 strnlen ("foobar", 5) = 6 strnlen ("foobar", 6) = 6 strnlen ("foobar", 7) = 6 strnlen ("foobar", 8) = 6 strnlen ("foobar", 9) = 6
sysconf
_SC_PAGESIZE
is standard, but some older systems (e.g., HP-UX
9) have _SC_PAGE_SIZE
instead. This can be tested with
#ifdef
.
unlink
unlink
causes the given file to be
removed only after there are no more open file handles for it. Some
non-Posix hosts have trouble with this requirement, though,
and some DOS variants even corrupt the file system.
unsetenv
unsetenv
is not available, but a variable ‘FOO’
can be removed with a call putenv ("FOO=")
, as described under
putenv
above.
va_copy
va_copy
for copying
va_list
variables. It may be available in older environments
too, though possibly as __va_copy
(e.g., gcc in strict
pre-C99 mode). These can be tested with #ifdef
. A fallback to
memcpy (&dst, &src, sizeof (va_list))
gives maximum
portability.
va_list
va_list
is not necessarily just a pointer. It can be a
struct
(e.g., gcc on Alpha), which means NULL
is
not portable. Or it can be an array (e.g., gcc in some
PowerPC configurations), which means as a function parameter it can be
effectively call-by-reference and library routines might modify the
value back in the caller (e.g., vsnprintf
in the GNU C Library
2.1).
>>
>>
right shift of a signed type replicates the
high bit, giving a so-called “arithmetic” shift. But care should be
taken since Standard C doesn't require that behavior. On those
few processors without a native arithmetic shift (for instance Cray
vector systems) zero bits may be shifted in, the same as a shift of an
unsigned type.
/