(autoconf.info)Particular Headers


Next: Generic Headers Prev: Header Portability Up: Header Files

5.6.2 Particular Header Checks
------------------------------

These macros check for particular system header files--whether they
exist, and in some cases whether they declare certain symbols.

 -- Macro: AC_HEADER_ASSERT
     Check whether to enable assertions in the style of `assert.h'.
     Assertions are enabled by default, but the user can override this
     by invoking `configure' with the `--disable-assert' option.

 -- Macro: AC_HEADER_DIRENT
     Check for the following header files.  For the first one that is
     found and defines `DIR', define the listed C preprocessor macro:

     `dirent.h'     `HAVE_DIRENT_H'
     `sys/ndir.h'   `HAVE_SYS_NDIR_H'
     `sys/dir.h'    `HAVE_SYS_DIR_H'
     `ndir.h'       `HAVE_NDIR_H'

     The directory-library declarations in your source code should look
     something like the following:

          #include <sys/types.h>
          #ifdef HAVE_DIRENT_H
          # include <dirent.h>
          # define NAMLEN(dirent) strlen ((dirent)->d_name)
          #else
          # define dirent direct
          # define NAMLEN(dirent) ((dirent)->d_namlen)
          # ifdef HAVE_SYS_NDIR_H
          #  include <sys/ndir.h>
          # endif
          # ifdef HAVE_SYS_DIR_H
          #  include <sys/dir.h>
          # endif
          # ifdef HAVE_NDIR_H
          #  include <ndir.h>
          # endif
          #endif

     Using the above declarations, the program would declare variables
     to be of type `struct dirent', not `struct direct', and would
     access the length of a directory entry name by passing a pointer
     to a `struct dirent' to the `NAMLEN' macro.

     This macro also checks for the SCO Xenix `dir' and `x' libraries.

     This macro is obsolescent, as all current systems with directory
     libraries have `<dirent.h>'.  New programs need not use this macro.

     Also see `AC_STRUCT_DIRENT_D_INO' and `AC_STRUCT_DIRENT_D_TYPE'
     (Note: Particular Structures).

 -- Macro: AC_HEADER_MAJOR
     If `sys/types.h' does not define `major', `minor', and `makedev',
     but `sys/mkdev.h' does, define `MAJOR_IN_MKDEV'; otherwise, if
     `sys/sysmacros.h' does, define `MAJOR_IN_SYSMACROS'.

 -- Macro: AC_HEADER_RESOLV
     Checks for header `resolv.h', checking for prerequisites first.
     To properly use `resolv.h', your code should contain something like
     the following:


     #ifdef HAVE_SYS_TYPES_H
     #  include <sys/types.h>
     #endif
     #ifdef HAVE_NETINET_IN_H
     #  include <netinet/in.h>   /* inet_ functions / structs */
     #endif
     #ifdef HAVE_ARPA_NAMESER_H
     #  include <arpa/nameser.h> /* DNS HEADER struct */
     #endif
     #ifdef HAVE_NETDB_H
     #  include <netdb.h>
     #endif
     #include <resolv.h>

 -- Macro: AC_HEADER_STAT
     If the macros `S_ISDIR', `S_ISREG', etc. defined in `sys/stat.h'
     do not work properly (returning false positives), define
     `STAT_MACROS_BROKEN'.  This is the case on Tektronix UTekV, Amdahl
     UTS and Motorola System V/88.

     This macro is obsolescent, as no current systems have the bug.
     New programs need not use this macro.

 -- Macro: AC_HEADER_STDBOOL
     If `stdbool.h' exists and conforms to C99, define `HAVE_STDBOOL_H'
     to 1; if the type `_Bool' is defined, define `HAVE__BOOL' to 1.
     To fulfill the C99 requirements, your `system.h' could contain the
     following code:


     #ifdef HAVE_STDBOOL_H
     # include <stdbool.h>
     #else
     # ifndef HAVE__BOOL
     #  ifdef __cplusplus
     typedef bool _Bool;
     #  else
     #   define _Bool signed char
     #  endif
     # endif
     # define bool _Bool
     # define false 0
     # define true 1
     # define __bool_true_false_are_defined 1
     #endif

     Alternatively you can use the `stdbool' package of Gnulib (*note
     Gnulib::); it packages the above code into a replacement header
     and contains a few other bells and whistles.


 -- Macro: AC_HEADER_STDC
     Define `STDC_HEADERS' if the system has C header files conforming
     to ANSI C89 (ISO C90).  Specifically, this macro checks for
     `stdlib.h', `stdarg.h', `string.h', and `float.h'; if the system
     has those, it probably has the rest of the C89 header files.  This
     macro also checks whether `string.h' declares `memchr' (and thus
     presumably the other `mem' functions), whether `stdlib.h' declare
     `free' (and thus presumably `malloc' and other related functions),
     and whether the `ctype.h' macros work on characters with the high
     bit set, as the C standard requires.

     If you use this macro, your code can refer to `STDC_HEADERS' to
     determine whether the system has conforming header files (and
     probably C library functions).

     This macro is obsolescent, as current systems have conforming
     header files.  New programs need not use this macro.

     Nowadays `string.h' is part of the C standard and declares
     functions like `strcpy', and `strings.h' is standardized by Posix
     and declares BSD functions like `bcopy'; but historically, string
     functions were a major sticking point in this area.  If you still
     want to worry about portability to ancient systems without
     standard headers, there is so much variation that it is probably
     easier to declare the functions you use than to figure out exactly
     what the system header files declare.  Some ancient systems
     contained a mix of functions from the C standard and from BSD;
     some were mostly standard but lacked `memmove'; some defined the
     BSD functions as macros in `string.h' or `strings.h'; some had
     only the BSD functions but `string.h'; some declared the memory
     functions in `memory.h', some in `string.h'; etc.  It is probably
     sufficient to check for one string function and one memory
     function; if the library had the standard versions of those then
     it probably had most of the others.  If you put the following in
     `configure.ac':

          # This example is obsolescent.
          # Nowadays you can omit these macro calls.
          AC_HEADER_STDC
          AC_CHECK_FUNCS([strchr memcpy])

     then, in your code, you can use declarations like this:

          /* This example is obsolescent.
             Nowadays you can just #include <string.h>.  */
          #ifdef STDC_HEADERS
          # include <string.h>
          #else
          # ifndef HAVE_STRCHR
          #  define strchr index
          #  define strrchr rindex
          # endif
          char *strchr (), *strrchr ();
          # ifndef HAVE_MEMCPY
          #  define memcpy(d, s, n) bcopy ((s), (d), (n))
          #  define memmove(d, s, n) bcopy ((s), (d), (n))
          # endif
          #endif

     If you use a function like `memchr', `memset', `strtok', or
     `strspn', which have no BSD equivalent, then macros don't suffice
     to port to ancient hosts; you must provide an implementation of
     each function.  An easy way to incorporate your implementations
     only when needed (since the ones in system C libraries may be hand
     optimized) is to, taking `memchr' for example, put it in
     `memchr.c' and use `AC_REPLACE_FUNCS([memchr])'.

 -- Macro: AC_HEADER_SYS_WAIT
     If `sys/wait.h' exists and is compatible with Posix, define
     `HAVE_SYS_WAIT_H'.  Incompatibility can occur if `sys/wait.h' does
     not exist, or if it uses the old BSD `union wait' instead of `int'
     to store a status value.  If `sys/wait.h' is not Posix compatible,
     then instead of including it, define the Posix macros with their
     usual interpretations.  Here is an example:

          #include <sys/types.h>
          #ifdef HAVE_SYS_WAIT_H
          # include <sys/wait.h>
          #endif
          #ifndef WEXITSTATUS
          # define WEXITSTATUS(stat_val) ((unsigned int) (stat_val) >> 8)
          #endif
          #ifndef WIFEXITED
          # define WIFEXITED(stat_val) (((stat_val) & 255) == 0)
          #endif

     This macro is obsolescent, as current systems are compatible with
     Posix.  New programs need not use this macro.

   `_POSIX_VERSION' is defined when `unistd.h' is included on Posix
systems.  If there is no `unistd.h', it is definitely not a Posix
system.  However, some non-Posix systems do have `unistd.h'.

   The way to check whether the system supports Posix is:

     #ifdef HAVE_UNISTD_H
     # include <sys/types.h>
     # include <unistd.h>
     #endif

     #ifdef _POSIX_VERSION
     /* Code for Posix systems.  */
     #endif

 -- Macro: AC_HEADER_TIME
     If a program may include both `time.h' and `sys/time.h', define
     `TIME_WITH_SYS_TIME'.  On some ancient systems, `sys/time.h'
     included `time.h', but `time.h' was not protected against multiple
     inclusion, so programs could not explicitly include both files.
     This macro is useful in programs that use, for example, `struct
     timeval' as well as `struct tm'.  It is best used in conjunction
     with `HAVE_SYS_TIME_H', which can be checked for using
     `AC_CHECK_HEADERS([sys/time.h])'.

          #ifdef TIME_WITH_SYS_TIME
          # include <sys/time.h>
          # include <time.h>
          #else
          # ifdef HAVE_SYS_TIME_H
          #  include <sys/time.h>
          # else
          #  include <time.h>
          # endif
          #endif

     This macro is obsolescent, as current systems can include both
     files when they exist.  New programs need not use this macro.

 -- Macro: AC_HEADER_TIOCGWINSZ
     If the use of `TIOCGWINSZ' requires `<sys/ioctl.h>', then define
     `GWINSZ_IN_SYS_IOCTL'.  Otherwise `TIOCGWINSZ' can be found in
     `<termios.h>'.

     Use:

          #ifdef HAVE_TERMIOS_H
          # include <termios.h>
          #endif

          #ifdef GWINSZ_IN_SYS_IOCTL
          # include <sys/ioctl.h>
          #endif


automatically generated by info2www