This is Info file /gnu/src/amiga/autoconf-2.1/autoconf.info, produced by Makeinfo-1.55 from the input file /gnu/src/amiga/autoconf-2.1/autoconf.texi. START-INFO-DIR-ENTRY * Autoconf: (autoconf). Create source code configuration scripts. END-INFO-DIR-ENTRY This file documents the GNU Autoconf package for creating scripts to configure source code packages using templates and an `m4' macro package. Copyright (C) 1992, 1993, 1994 Free Software Foundation, Inc. Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies. Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, except that this permission notice may be stated in a translation approved by the Foundation. File: autoconf.info, Node: Versions, Prev: Default Prefix, Up: Setup Version Numbers in `configure' ============================== The following macros manage version numbers for `configure' scripts. Using them is optional. - Macro: AC_PREREQ (VERSION) Ensure that a recent enough version of Autoconf is being used. If the version of Autoconf being used to create `configure' is earlier than VERSION, print an error message on the standard error output and do not create `configure'. For example: AC_PREREQ(1.8) This macro is useful if your `configure.in' relies on non-obvious behavior that changed between Autoconf releases. If it merely needs recently added macros, then `AC_PREREQ' is less useful, because the `autoconf' program already tells the user which macros are not found. The same thing happens if `configure.in' is processed by a version of Autoconf older than when `AC_PREREQ' was added. - Macro: AC_REVISION (REVISION-INFO) Copy revision stamp REVISION-INFO into the `configure' script, with any dollar signs or double-quotes removed. This macro lets you put a revision stamp from `configure.in' into `configure' without RCS or CVS changing it when you check in `configure'. That way, you can determine easily which revision of `configure.in' a particular `configure' corresponds to. It is a good idea to call this macro before `AC_INIT' so that the revision number is near the top of both `configure.in' and `configure'. To support doing that, the `AC_REVISION' output begins with `#!/bin/sh', like the normal start of a `configure' script does. For example, this line in `configure.in': AC_REVISION($Revision: 1.30 $)dnl produces this in `configure': #!/bin/sh # From configure.in Revision: 1.30 File: autoconf.info, Node: Existing Tests, Next: Writing Tests, Prev: Setup, Up: Top Existing Tests ************** These macros test for particular system features that packages might need or want to use. If you need to test for a kind of feature that none of these macros check for, you can probably do it by calling primitive test macros with appropriate arguments (*note Writing Tests::.). These tests print messages telling the user which feature they're checking for, and what they find. They cache their results for future `configure' runs (*note Caching Results::.). Some of these macros set output variables. *Note Makefile Substitutions::, for how to get their values. The phrase "define NAME" is used below as a shorthand to mean "define C preprocessor symbol NAME to the value 1". *Note Defining Symbols::, for how to get those symbol definitions into your program. * Menu: * Alternative Programs:: Selecting between alternative programs. * Libraries:: Library archives that might be missing. * Library Functions:: C library functions that might be missing. * Header Files:: Header files that might be missing. * Structures:: Structures or members that might be missing. * Typedefs:: `typedef's that might be missing. * Compiler Characteristics:: C compiler or machine architecture features. * System Services:: Operating system services. * UNIX Variants:: Special kludges for specific UNIX variants. File: autoconf.info, Node: Alternative Programs, Next: Libraries, Up: Existing Tests Alternative Programs ==================== These macros check for the presence or behavior of particular programs. They are used to choose between several alternative programs and to decide what to do once one has been chosen. If there is no macro specifically defined to check for a program you need, and you don't need to check for any special properties of it, then you can use one of the general program check macros. * Menu: * Particular Programs:: Special handling to find certain programs. * Generic Programs:: How to find other programs. File: autoconf.info, Node: Particular Programs, Next: Generic Programs, Up: Alternative Programs Particular Program Checks ------------------------- These macros check for particular programs--whether they exist, and in some cases whether they support certain features. - Macro: AC_DECL_YYTEXT Define `YYTEXT_POINTER' if `yytext' is a `char *' instead of a `char []'. Also set output variable `LEX_OUTPUT_ROOT' to the base of the file name that the lexer generates; usually `lex.yy', but sometimes something else. These results vary according to whether `lex' or `flex' is being used. - Macro: AC_PROG_AWK Check for `mawk', `gawk', `nawk', and `awk', in that order, and set output variable `AWK' to the first one that it finds. It tries `mawk' first because that is reported to be the fastest implementation. - Macro: AC_PROG_CC Determine a C compiler to use. If `CC' is not already set in the environment, check for `gcc', and use `cc' if it's not found. Set output variable `CC' to the name of the compiler found. If using the GNU C compiler, set shell variable `GCC' to `yes', empty otherwise. If output variable `CFLAGS' was not already set, set it to `-g -O' for the GNU C compiler (`-O' on systems where GCC does not accept `-g'), or `-g' for other compilers. - Macro: AC_PROG_CC_C_O If the C compiler does not accept the `-c' and `-o' options simultaneously, define `NO_MINUS_C_MINUS_O'. - Macro: AC_PROG_CPP Set output variable `CPP' to a command that runs the C preprocessor. If `$CC -E' doesn't work, it uses `/lib/cpp'. It is only portable to run `CPP' on files with a `.c' extension. If the current language is C (*note Language Choice::.), many of the specific test macros use the value of `CPP' indirectly by calling `AC_TRY_CPP', `AC_CHECK_HEADER', `AC_EGREP_HEADER', or `AC_EGREP_CPP'. - Macro: AC_PROG_CXX Determine a C++ compiler to use. Check if the environment variable `CXX' or `CCC' (in that order) is set; if so, set output variable `CXX' to its value. Otherwise search for a C++ compiler under likely names (`c++', `g++', `gcc', `CC', and `cxx'). If none of those checks succeed, as a last resort set `CXX' to `gcc'. If using the GNU C++ compiler, set shell variable `GXX' to `yes', empty otherwise. If output variable `CXXFLAGS' was not already set, set it to `-g -O' for the GNU C++ compiler (`-O' on systems where G++ does not accept `-g'), or `-g' for other compilers. - Macro: AC_PROG_CXXCPP Set output variable `CXXCPP' to a command that runs the C++ preprocessor. If `$CXX -E' doesn't work, it uses `/lib/cpp'. It is only portable to run `CXXCPP' on files with a `.c', `.C', or `.cc' extension. If the current language is C++ (*note Language Choice::.), many of the specific test macros use the value of `CXXCPP' indirectly by calling `AC_TRY_CPP', `AC_CHECK_HEADER', `AC_EGREP_HEADER', or `AC_EGREP_CPP'. - Macro: AC_PROG_GCC_TRADITIONAL Add `-traditional' to output variable `CC' if using the GNU C compiler and `ioctl' does not work properly without `-traditional'. That usually happens when the fixed header files have not been installed on an old system. Since recent versions of the GNU C compiler fix the header files automatically when installed, this is becoming a less prevalent problem. - Macro: AC_PROG_INSTALL Set output variable `INSTALL' to the path of a BSD compatible `install' program, if one is found in the current `PATH'. Otherwise, set `INSTALL' to `DIR/install-sh -c', checking the directories specified to `AC_CONFIG_AUX_DIR' (or its default directories) to determine DIR (*note Output::.). Also set the variable `INSTALL_PROGRAM' to `${INSTALL}' and `INSTALL_DATA' to `${INSTALL} -m 644'. This macro screens out various instances of `install' known to not work. It prefers to find a C program rather than a shell script, for speed. Instead of `install-sh', it can also use `install.sh', but that name is obsolete because some `make' programs have a rule that creates `install' from it if there is no `Makefile'. A copy of `install-sh' which you may use comes with Autoconf. If you use `AC_PROG_INSTALL', you must include either `install-sh' or `install.sh' in your distribution, or `configure' will produce an error message saying it can't find them--even if the system you're on has a good `install' program. This check is a safety measure to prevent you from accidentally leaving that file out, which would prevent your package from installing on systems that don't have a BSD-compatible `install' program. If you need to use your own installation program because it has features not found in standard `install' programs, there is no reason to use `AC_PROG_INSTALL'; just put the pathname of your program into your `Makefile.in' files. - Macro: AC_PROG_LEX If `flex' is found, set output variable `LEX' to `flex' and `LEXLIB' to `-lfl', if that library is in a standard place. Otherwise set `LEX' to `lex' and `LEXLIB' to `-ll'. - Macro: AC_PROG_LN_S If `ln -s' works on the current filesystem (the operating system and filesystem support symbolic links), set output variable `LN_S' to `ln -s', otherwise set it to `ln'. - Macro: AC_PROG_RANLIB Set output variable `RANLIB' to `ranlib' if `ranlib' is found, otherwise to `:' (do nothing). - Macro: AC_PROG_YACC If `bison' is found, set output variable `YACC' to `bison -y'. Otherwise, if `byacc' is found, set `YACC' to `byacc'. Otherwise set `YACC' to `yacc'. File: autoconf.info, Node: Generic Programs, Prev: Particular Programs, Up: Alternative Programs Generic Program Checks ---------------------- These macros are used to find programs not covered by the particular test macros. If you need to check the behavior of a program as well as find out whether it is present, you have to write your own test for it (*note Writing Tests::.). - Macro: AC_CHECK_PROG (VARIABLE, PROG-TO-CHECK-FOR, VALUE-IF-FOUND [, VALUE-IF-NOT-FOUND]) Check whether program PROG-TO-CHECK-FOR exists in `PATH'. If it is found, set VARIABLE to VALUE-IF-FOUND, otherwise to VALUE-IF-NOT-FOUND, if given. If VARIABLE was already set, do nothing. Calls `AC_SUBST' for VARIABLE. - Macro: AC_CHECK_PROGS (VARIABLE, PROGS-TO-CHECK-FOR [, VALUE-IF-NOT-FOUND]) Check for each program in the whitespace-separated list PROGS-TO-CHECK-FOR exists in `PATH'. If it is found, set VARIABLE to the name of that program. Otherwise, continue checking the next program in the list. If none of the programs in the list are found, set VARIABLE to VALUE-IF-NOT-FOUND; if VALUE-IF-NOT-FOUND is not specified, the value of VARIABLE is not changed. Calls `AC_SUBST' for VARIABLE. - Macro: AC_PATH_PROG (VARIABLE, PROG-TO-CHECK-FOR [, VALUE-IF-NOT-FOUND]) Like `AC_CHECK_PROG', but set VARIABLE to the entire path of PROG-TO-CHECK-FOR if found. - Macro: AC_PATH_PROGS (VARIABLE, PROGS-TO-CHECK-FOR [, VALUE-IF-NOT-FOUND]) Like `AC_CHECK_PROGS', but if any of PROGS-TO-CHECK-FOR are found, set VARIABLE to the entire path of the program found. File: autoconf.info, Node: Libraries, Next: Library Functions, Prev: Alternative Programs, Up: Existing Tests Library Files ============= The following macros check for the presence of certain C library archive files. - Macro: AC_CHECK_LIB (LIBRARY, FUNCTION [, ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND [, OTHER-LIBRARIES]]]) Try to ensure that C function FUNCTION is available by checking whether a test C program can be linked with the library LIBRARY to get the function. LIBRARY is the base name of the library; e.g., to check for `-lmp', use `mp' as the LIBRARY argument. ACTION-IF-FOUND is a list of shell commands to run if the link with the library succeeds; ACTION-IF-NOT-FOUND is a list of shell commands to run if the link fails. If ACTION-IF-FOUND and ACTION-IF-NOT-FOUND are not specified, the default action is to add `-lLIBRARY' to `LIBS' and define `HAVE_LIBLIBRARY' (in all capitals). If linking with LIBRARY results in unresolved symbols, which would be resolved by linking with additional libraries, give those libraries as the OTHER-LIBRARIES argument, separated by spaces: `-lX11 -lXt'. Otherwise this macro will fail to detect that LIBRARY is present, because linking the test program will always fail with unresolved symbols. - Macro: AC_HAVE_LIBRARY (LIBRARY, [, ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND [, OTHER-LIBRARIES]]]) This macro is equivalent to calling `AC_CHECK_LIB' with a FUNCTION argument of `main'. In addition, LIBRARY can be written as any of `foo', `-lfoo', or `libfoo.a'. In all of those cases, the compiler is passed `-lfoo'. However, LIBRARY can not be a shell variable; it must be a literal name. This macro is considered obsolete. File: autoconf.info, Node: Library Functions, Next: Header Files, Prev: Libraries, Up: Existing Tests Library Functions ================= The following macros check for particular C library functions. If there is no macro specifically defined to check for a function you need, and you don't need to check for any special properties of it, then you can use one of the general function check macros. * Menu: * Particular Functions:: Special handling to find certain functions. * Generic Functions:: How to find other functions. File: autoconf.info, Node: Particular Functions, Next: Generic Functions, Up: Library Functions Particular Function Checks -------------------------- These macros check for particular C functions--whether they exist, and in some cases how they respond when given certain arguments. - Macro: AC_FUNC_ALLOCA Check how to get `alloca'. Tries to get a builtin version by checking for `alloca.h' or the predefined C preprocessor macros `__GNUC__' and `_AIX'. If this macro finds `alloca.h', it defines `HAVE_ALLOCA_H'. If those attempts fail, it looks for the function in the standard C library. If any of those methods succeed, it defines `HAVE_ALLOCA'. Otherwise, it sets the output variable `ALLOCA' to `alloca.o' and defines `C_ALLOCA' (so programs can periodically call `alloca(0)' to garbage collect). This variable is separate from `LIBOBJS' so multiple programs can share the value of `ALLOCA' without needing to create an actual library, in case only some of them use the code in `LIBOBJS'. This macro does not try to get `alloca' from the System V R3 `libPW' or the System V R4 `libucb' because those libraries contain some incompatible functions that cause trouble. Some versions do not even contain `alloca' or contain a buggy version. If you still want to use their `alloca', use `ar' to extract `alloca.o' from them instead of compiling `alloca.c'. Source files that use `alloca' should start with a piece of code like the following, to declare it properly. In some versions of AIX, the declaration of `alloca' must precede everything else except for comments and preprocessor directives. The `#pragma' directive is indented so that pre-ANSI C compilers will ignore it, rather than choke on it. /* AIX requires this to be the first thing in the file. */ #ifdef __GNUC__ # define alloca __builtin_alloca #else # if HAVE_ALLOCA_H # include # else # ifdef _AIX #pragma alloca # else # ifndef alloca /* predefined by HP cc +Olibcalls */ char *alloca (); # endif # endif # endif #endif - Macro: AC_FUNC_CLOSEDIR_VOID If the `closedir' function does not return a meaningful value, define `CLOSEDIR_VOID'. Otherwise, callers ought to check its return value for an error indicator. - Macro: AC_FUNC_GETLOADAVG Check how to get the system load averages. If the system has the `getloadavg' function, this macro defines `HAVE_GETLOADAVG', and adds to `LIBS' any libraries needed to get that function. Otherwise, it adds `getloadavg.o' to the output variable `LIBOBJS', and possibly defines several other C preprocessor macros and output variables: 1. It defines `SVR4', `DGUX', `UMAX', or `UMAX4_3' if on those systems. 2. If it finds `nlist.h', it defines `NLIST_STRUCT'. 3. If `struct nlist' has an `n_un' member, it defines `NLIST_NAME_UNION'. 4. If compiling `getloadavg.c' defines `LDAV_PRIVILEGED', programs need to be installed specially on this system for `getloadavg' to work, and this macro defines `GETLOADAVG_PRIVILEGED'. 5. This macro sets the output variable `NEED_SETGID'. The value is `true' if special installation is required, `false' if not. If `NEED_SETGID' is `true', this macro sets `KMEM_GROUP' to the name of the group that should own the installed program. - Macro: AC_FUNC_GETMNTENT Check for the `getmntent' in the `sun' and `seq' libraries, for Irix 4 and PTX, respectively. Then, if `getmntent' is available, define `HAVE_GETMNTENT'. - Macro: AC_FUNC_MEMCMP If the `memcmp' function is not available, or does not work on 8-bit data (like the one on SunOS 4.1.3), add `memcmp.o' to output variable `LIBOBJS'. - Macro: AC_FUNC_MMAP If the `mmap' function exists and works correctly on memory mapped files, define `HAVE_MMAP'. - Macro: AC_FUNC_SETVBUF_REVERSED If `setvbuf' takes the buffering type as its second argument and the buffer pointer as the third, instead of the other way around, define `SETVBUF_REVERSED'. This is the case on System V before release 3. - Macro: AC_FUNC_STRCOLL If the `strcoll' function exists and works correctly, define `HAVE_STRCOLL'. This does a bit more than `AC_CHECK_FUNCS(strcoll)', because some systems have incorrect definitions of `strcoll', which should not be used. - Macro: AC_FUNC_STRFTIME Check for `strftime' in the `intl' library, for SCO UNIX. Then, if `strftime' is available, define `HAVE_STRFTIME'. - Macro: AC_FUNC_UTIME_NULL If `utime(FILE, NULL)' sets FILE's timestamp to the present, define `HAVE_UTIME_NULL'. - Macro: AC_FUNC_VFORK If `vfork.h' is found, define `HAVE_VFORK_H'. If a working `vfork' is not found, define `vfork' to be `fork'. This macro checks for several known errors in implementations of `vfork' and considers the system to not have a working `vfork' if it detects any of them. - Macro: AC_FUNC_VPRINTF If `vprintf' is found, define `HAVE_VPRINTF'. Otherwise, if `_doprnt' is found, define `HAVE_DOPRNT'. (If `vprintf' is available, you may assume that `vfprintf' and `vsprintf' are also available.) - Macro: AC_FUNC_WAIT3 If `wait3' is found and fills in the contents of its third argument (a `struct rusage *'), which HP-UX does not do, define `HAVE_WAIT3'. File: autoconf.info, Node: Generic Functions, Prev: Particular Functions, Up: Library Functions Generic Function Checks ----------------------- These macros are used to find functions not covered by the particular test macros. If the functions might be in libraries other than the default C library, first call `AC_CHECK_LIB' for those libraries. If you need to check the behavior of a function as well as find out whether it is present, you have to write your own test for it (*note Writing Tests::.). - Macro: AC_CHECK_FUNC (FUNCTION, ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]) If C function FUNCTION is available, run shell commands ACTION-IF-FOUND, otherwise ACTION-IF-NOT-FOUND. If you just want to define a symbol if the function is available, consider using `AC_CHECK_FUNCS' instead. This macro checks for functions with C linkage even when `AC_LANG_CPLUSPLUS' has been called, since C++ is more standardized than C is. (*note Language Choice::., for more information about selecting the language for checks.) - Macro: AC_CHECK_FUNCS (FUNCTION... [, ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]]) For each given FUNCTION in the whitespace-separated argument list that is available, define `HAVE_FUNCTION' (in all capitals). If ACTION-IF-FOUND is given, it is additional shell code to execute when one of the functions is found. You can give it a value of `break' to break out of the loop on the first match. If ACTION-IF-NOT-FOUND is given, it is executed when one of the functions is not found. - Macro: AC_REPLACE_FUNCS (FUNCTION-NAME...) For each given FUNCTION-NAME in the whitespace-separated argument list that is not in the C library, add `FUNCTION-NAME.o' to the value of the output variable `LIBOBJS'. File: autoconf.info, Node: Header Files, Next: Structures, Prev: Library Functions, Up: Existing Tests Header Files ============ The following macros check for the presence of certain C header files. If there is no macro specifically defined to check for a header file you need, and you don't need to check for any special properties of it, then you can use one of the general header file check macros. * Menu: * Particular Headers:: Special handling to find certain headers. * Generic Headers:: How to find other headers. File: autoconf.info, Node: Particular Headers, Next: Generic Headers, Up: Header Files 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_DECL_SYS_SIGLIST Define `SYS_SIGLIST_DECLARED' if the variable `sys_siglist' is declared in a system header file, either `signal.h' or `unistd.h'. - Macro: AC_DIR_HEADER Like calling `AC_HEADER_DIRENT' and `AC_FUNC_CLOSEDIR_VOID', but defines a different set of C preprocessor macros to indicate which header file is found. This macro and the names it defines are considered obsolete. The names it defines are: `dirent.h' `DIRENT' `sys/ndir.h' `SYSNDIR' `sys/dir.h' `SYSDIR' `ndir.h' `NDIR' In addition, if the `closedir' function does not return a meaningful value, define `VOID_CLOSEDIR'. - Macro: AC_HEADER_DIRENT Check for the following header files, and 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 the source code should look something like the following: #if HAVE_DIRENT_H # include # define NAMLEN(dirent) strlen((dirent)->d_name) #else # define dirent direct # define NAMLEN(dirent) (dirent)->d_namlen # if HAVE_SYS_NDIR_H # include # endif # if HAVE_SYS_DIR_H # include # endif # if HAVE_NDIR_H # include # endif #endif Using the above declarations, the program would declare variables to be 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. - 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_STDC Define `STDC_HEADERS' if the system has ANSI C header files. 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 ANSI C 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 ANSI C requires. Use `STDC_HEADERS' instead of `__STDC__' to determine whether the system has ANSI-compliant header files (and probably C library functions) because many systems that have GCC do not have ANSI C header files. On systems without ANSI C 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 systems contain a mix of functions ANSI and BSD; some are mostly ANSI but lack `memmove'; some define the BSD functions as macros in `string.h' or `strings.h'; some have only the BSD functions but `string.h'; some declare 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 has the ANSI versions of those then it probably has most of the others. If you put the following in `configure.in': AC_HEADER_STDC AC_CHECK_FUNCS(strchr memcpy) then, in your code, you can put declarations like this: #if STDC_HEADERS # include #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 won't suffice; 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.1, 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.1 compatible, then instead of including it, define the POSIX.1 macros with their usual interpretations. Here is an example: #include #if HAVE_SYS_WAIT_H # include #endif #ifndef WEXITSTATUS # define WEXITSTATUS(stat_val) ((unsigned)(stat_val) >> 8) #endif #ifndef WIFEXITED # define WIFEXITED(stat_val) (((stat_val) & 255) == 0) #endif - Macro: AC_MEMORY_H Define `NEED_MEMORY_H' if `memcpy', `memcmp', etc. are not declared in `string.h' and `memory.h' exists. This macro is obsolete; instead, use `AC_CHECK_HEADERS(memory.h)'. See the example for `AC_HEADER_STDC'. - Macro: AC_UNISTD_H Define `HAVE_UNISTD_H' if the system has `unistd.h'. This macro is obsolete; instead, use `AC_CHECK_HEADERS(unistd.h)'. The way to check if the system supports POSIX.1 is: #if HAVE_UNISTD_H # include # include #endif #ifdef _POSIX_VERSION /* Code for POSIX.1 systems. */ #endif `_POSIX_VERSION' is defined when `unistd.h' is included on POSIX.1 systems. If there is no `unistd.h', it is definitely not a POSIX.1 system. However, some non-POSIX.1 systems do have `unistd.h'. - Macro: AC_USG Define `USG' if the system does not have `strings.h', `rindex', `bzero', etc. This implies that it has `string.h', `strrchr', `memset', etc. The symbol `USG' is obsolete. Instead of this macro, see the example for `AC_HEADER_STDC'. File: autoconf.info, Node: Generic Headers, Prev: Particular Headers, Up: Header Files Generic Header Checks --------------------- These macros are used to find system header files not covered by the particular test macros. If you need to check the contents of a header as well as find out whether it is present, you have to write your own test for it (*note Writing Tests::.). - Macro: AC_CHECK_HEADER (HEADER-FILE, ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]) If the system header file HEADER-FILE exists, execute shell commands ACTION-IF-FOUND, otherwise execute ACTION-IF-NOT-FOUND. If you just want to define a symbol if the header file is available, consider using `AC_CHECK_HEADERS' instead. - Macro: AC_CHECK_HEADERS (HEADER-FILE... [, ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]]) For each given system header file HEADER-FILE in the whitespace-separated argument list that exists, define `HAVE_HEADER-FILE' (in all capitals). If ACTION-IF-FOUND is given, it is additional shell code to execute when one of the header files is found. You can give it a value of `break' to break out of the loop on the first match. If ACTION-IF-NOT-FOUND is given, it is executed when one of the header files is not found. File: autoconf.info, Node: Structures, Next: Typedefs, Prev: Header Files, Up: Existing Tests Structures ========== The following macros check for certain structures or structure members. To check structures not listed here, use `AC_EGREP_CPP' (*note Examining Declarations::.) or `AC_TRY_COMPILE' (*note Examining Syntax::.). - Macro: AC_HEADER_STAT If the macros `S_ISDIR', `S_ISREG' et al. 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. - Macro: AC_HEADER_TIME If a program may include both `time.h' and `sys/time.h', define `TIME_WITH_SYS_TIME'. On some older systems, `sys/time.h' includes `time.h', but `time.h' is not protected against multiple inclusion, so programs should not explicitly include both files. This macro is useful in programs that use, for example, `struct timeval' or `struct timezone' 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)'. #if TIME_WITH_SYS_TIME # include # include #else # if HAVE_SYS_TIME_H # include # else # include # endif #endif - Macro: AC_STRUCT_ST_BLKSIZE If `struct stat' contains an `st_blksize' member, define `HAVE_ST_BLKSIZE'. - Macro: AC_STRUCT_ST_BLOCKS If `struct stat' contains an `st_blocks' member, define `HAVE_ST_BLOCKS'. Otherwise, add `fileblocks.o' to the output variable `LIBOBJS'. - Macro: AC_STRUCT_ST_RDEV If `struct stat' contains an `st_rdev' member, define `HAVE_ST_RDEV'. - Macro: AC_STRUCT_TM If `time.h' does not define `struct tm', define `TM_IN_SYS_TIME', which means that including `sys/time.h' had better define `struct tm'. - Macro: AC_STRUCT_TIMEZONE Figure out how to get the current timezone. If `struct tm' has a `tm_zone' member, define `HAVE_TM_ZONE'. Otherwise, if the external array `tzname' is found, define `HAVE_TZNAME'. File: autoconf.info, Node: Typedefs, Next: Compiler Characteristics, Prev: Structures, Up: Existing Tests Typedefs ======== The following macros check for C typedefs. If there is no macro specifically defined to check for a typedef you need, and you don't need to check for any special properties of it, then you can use a general typedef check macro. * Menu: * Particular Typedefs:: Special handling to find certain types. * Generic Typedefs:: How to find other types. File: autoconf.info, Node: Particular Typedefs, Next: Generic Typedefs, Up: Typedefs Particular Typedef Checks ------------------------- These macros check for particular C typedefs in `sys/types.h' and `stdlib.h' (if it exists). - Macro: AC_TYPE_GETGROUPS Define `GETGROUPS_T' to be whichever of `gid_t' or `int' is the base type of the array argument to `getgroups'. - Macro: AC_TYPE_MODE_T If `mode_t' is not defined, define `mode_t' to be `int'. - Macro: AC_TYPE_OFF_T If `off_t' is not defined, define `off_t' to be `long'. - Macro: AC_TYPE_PID_T If `pid_t' is not defined, define `pid_t' to be `int'. - Macro: AC_TYPE_SIGNAL If `signal.h' declares `signal' as returning a pointer to a function returning `void', define `RETSIGTYPE' to be `void'; otherwise, define it to be `int'. Define signal handlers as returning type `RETSIGTYPE': RETSIGTYPE hup_handler () { ... } - Macro: AC_TYPE_SIZE_T If `size_t' is not defined, define `size_t' to be `unsigned'. - Macro: AC_TYPE_UID_T If `uid_t' is not defined, define `uid_t' to be `int' and `gid_t' to be `int'. File: autoconf.info, Node: Generic Typedefs, Prev: Particular Typedefs, Up: Typedefs Generic Typedef Checks ---------------------- This macro is used to check for typedefs not covered by the particular test macros. - Macro: AC_CHECK_TYPE (TYPE, DEFAULT) If the type TYPE is not defined in `sys/types.h' or `stdlib.h' (if it exists), define it to be the C (or C++) builtin type DEFAULT; e.g., `short' or `unsigned'. File: autoconf.info, Node: Compiler Characteristics, Next: System Services, Prev: Typedefs, Up: Existing Tests Compiler Characteristics ======================== The following macros check for C compiler or machine architecture features. To check for characteristics not listed here, use `AC_TRY_COMPILE' (*note Examining Syntax::.) or `AC_TRY_RUN' (*note Run Time::.) - Macro: AC_C_BIGENDIAN If words are stored with the most significant byte first (like Motorola and SPARC, but not Intel and VAX, CPUs), define `WORDS_BIGENDIAN'. - Macro: AC_C_CONST If the C compiler does not fully support the keyword `const', define `const' to be empty. Some C compilers that do not define `__STDC__' do support `const'; some compilers that define `__STDC__' do not completely support `const'. Programs can simply use `const' as if every C compiler supported it; for those that don't, the `Makefile' or configuration header file will define it as empty. - Macro: AC_C_INLINE If the C compiler is a version of GCC that supports the keyword `__inline' but not `inline' (such as some NeXT versions), define `inline' to be `__inline'. - Macro: AC_C_CHAR_UNSIGNED If the C type `char' is unsigned, define `__CHAR_UNSIGNED__', unless the C compiler predefines it. - Macro: AC_C_LONG_DOUBLE If the C compiler supports the `long double' type, define `HAVE_LONG_DOUBLE'. Some C compilers that do not define `__STDC__' do support the `long double' type; some compilers that define `__STDC__' do not support `long double'. - Macro: AC_CHECK_SIZEOF (TYPE) Define `SIZEOF_UCTYPE' to be the size in bytes of the C (or C++) builtin type TYPE, e.g. `int' or `char *'. If `type' is unknown to the compiler, it gets a size of 0. UCTYPE is TYPE, with lowercase converted to uppercase, spaces changed to underscores, and asterisks changed to `P'. For example, the call AC_CHECK_SIZEOF(int *) defines `SIZEOF_INT_P' to be 64 on DEC Alpha AXP systems. - Macro: AC_INT_16_BITS If the C type `int' is 16 bits wide, define `INT_16_BITS'. This macro is obsolete; it is more general to use `AC_CHECK_SIZEOF(int)' instead. - Macro: AC_LONG_64_BITS If the C type `long int' is 64 bits wide, define `LONG_64_BITS'. This macro is obsolete; it is more general to use `AC_CHECK_SIZEOF(long)' instead. File: autoconf.info, Node: System Services, Next: UNIX Variants, Prev: Compiler Characteristics, Up: Existing Tests System Services =============== The following macros check for operating system services or capabilities. - Macro: AC_SYS_INTERPRETER Check whether the system supports starting scripts with a line of the form `#!/bin/csh' to select the interpreter to use for the script. After running this macro, shell code in `configure.in' can check the variable `ac_cv_sys_interpreter'; it will be set to `yes' if the system supports `#!', `no' if not. - Macro: AC_PATH_X Try to locate the X Window System include files and libraries. If the user gave the command line options `--x-includes=DIR' and `--x-libraries=DIR', use those directories. If either or both were not given, get the missing values by running `xmkmf' on a trivial `Imakefile' and examining the `Makefile' that it produces. If that fails (such as if `xmkmf' is not present), look for them in several directories where they often reside. If either method is successful, set the shell variables `x_includes' and `x_libraries' to their locations, unless they are in directories the compiler searches by default. If both methods fail, or the user gave the command line option `--without-x', set the shell variable `no_x' to `yes'; otherwise set it to the empty string. - Macro: AC_PATH_XTRA An enhanced version of `AC_PATH_X'. Add the C compiler flags that X needs to output variable `X_CFLAGS', and the X linker flags to `X_LIBS'. If X is not available, add `-DX_DISPLAY_MISSING' to `X_CFLAGS'. Also check for special libraries that some systems need in order to compile X programs. Add any that the system needs to output variable `X_EXTRA_LIBS'. And check for special X11R6 libraries that need to be linked with before `-lX11', and add any found to the output variable `X_PRE_LIBS'. - Macro: AC_SYS_LONG_FILE_NAMES If the system supports file names longer than 14 characters, define `HAVE_LONG_FILE_NAMES'. - Macro: AC_SYS_RESTARTABLE_SYSCALLS If the system automatically restarts a system call that is interrupted by a signal, define `HAVE_RESTARTABLE_SYSCALLS'. File: autoconf.info, Node: UNIX Variants, Prev: System Services, Up: Existing Tests UNIX Variants ============= The following macros check for certain operating systems that need special treatment for some programs, due to exceptional oddities in their header files or libraries. These macros are warts; they will be replaced by a more systematic approach, based on the functions they make available or the environments they provide. - Macro: AC_AIX If on AIX, define `_ALL_SOURCE'. Allows the use of some BSD functions. Should be called before any macros that run the C compiler. - Macro: AC_DYNIX_SEQ If on Dynix/PTX (Sequent UNIX), add `-lseq' to output variable `LIBS'. This macro is obsolete; instead, use `AC_FUNC_GETMNTENT'. - Macro: AC_IRIX_SUN If on IRIX (Silicon Graphics UNIX), add `-lsun' to output variable `LIBS'. This macro is obsolete. If you were using it to get `getmntent', use `AC_FUNC_GETMNTENT' instead. If you used it for the NIS versions of the password and group functions, use `AC_CHECK_LIB(sun, getpwnam)'. - Macro: AC_ISC_POSIX If on a POSIXized ISC UNIX, define `_POSIX_SOURCE' and add `-posix' (for the GNU C compiler) or `-Xp' (for other C compilers) to output variable `CC'. This allows the use of POSIX facilities. Must be called after `AC_PROG_CC' and before any other macros that run the C compiler. - Macro: AC_MINIX If on Minix, define `_MINIX' and `_POSIX_SOURCE' and define `_POSIX_1_SOURCE' to be 2. This allows the use of POSIX facilities. Should be called before any macros that run the C compiler. - Macro: AC_SCO_INTL If on SCO UNIX, add `-lintl' to output variable `LIBS'. This macro is obsolete; instead, use `AC_FUNC_STRFTIME'. - Macro: AC_XENIX_DIR If on Xenix, add `-lx' to output variable `LIBS'. Also, if `dirent.h' is being used, add `-ldir' to `LIBS'. This macro is obsolete; use `AC_HEADER_DIRENT' instead. File: autoconf.info, Node: Writing Tests, Next: Results, Prev: Existing Tests, Up: Top Writing Tests ************* If the existing feature tests don't do something you need, you have to write new ones. These macros are the building blocks. They provide ways for other macros to check whether various kinds of features are available and report the results. This chapter contains some suggestions and some of the reasons why the existing tests are written the way they are. You can also learn a lot about how to write Autoconf tests by looking at the existing ones. If something goes wrong in one or more of the Autoconf tests, this information can help you understand the assumptions behind them, which might help you figure out how to best solve the problem. These macros check the output of the C compiler system. They do not cache the results of their tests for future use (*note Caching Results::.), because they don't know enough about the information they are checking for to generate a cache variable name. They also do not print any messages, for the same reason. The checks for particular kinds of C features call these macros and do cache their results and print messages about what they're checking for. * Menu: * Examining Declarations:: Detecting header files and declarations. * Examining Syntax:: Detecting language syntax features. * Examining Libraries:: Detecting functions and global variables. * Run Time:: Testing for run-time features. * Portable Shell:: Shell script portability pitfalls. * Testing Values and Files:: Checking strings and files. * Multiple Cases:: Tests for several possible values. * Language Choice:: Selecting which language to use for testing. File: autoconf.info, Node: Examining Declarations, Next: Examining Syntax, Up: Writing Tests Examining Declarations ====================== The macro `AC_TRY_CPP' is used to check whether particular header files exist. You can check for one at a time, or more than one if you need several header files to all exist for some purpose. - Macro: AC_TRY_CPP (INCLUDES, ACTION-IF-TRUE [, ACTION-IF-FALSE]) INCLUDES is C or C++ `#include' statements and declarations, on which shell variable, backquote, and backslash substitutions are performed. (Actually, it can be any C program, but other statements are probably not useful.) If the preprocessor produces no error messages while processing it, run shell commands ACTION-IF-TRUE. Otherwise run shell commands ACTION-IF-FALSE. This macro uses `CPPFLAGS', but not `CFLAGS', because `-g', `-O', etc. are not valid options to many C preprocessors. Here is now to find out whether a header file contains a particular declaration, such as a typedef, a structure, a structure member, or a function. Use `AC_EGREP_HEADER' instead of running `grep' directly on the header file; on some systems the symbol might be defined in another header file that the file you are checking `#include's. - Macro: AC_EGREP_HEADER (PATTERN, HEADER-FILE, ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]) If the output of running the preprocessor on the system header file HEADER-FILE matches the `egrep' regular expression PATTERN, execute shell commands ACTION-IF-FOUND, otherwise execute ACTION-IF-NOT-FOUND. To check for C preprocessor symbols, either defined by header files or predefined by the C preprocessor, use `AC_EGREP_CPP'. Here is an example of the latter: AC_EGREP_CPP(yes, [#ifdef _AIX yes #endif ], is_aix=yes, is_aix=no) - Macro: AC_EGREP_CPP (PATTERN, PROGRAM, ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]) PROGRAM is the text of a C or C++ program, on which shell variable, backquote, and backslash substitutions are performed. If the output of running the preprocessor on PROGRAM matches the `egrep' regular expression PATTERN, execute shell commands ACTION-IF-FOUND, otherwise execute ACTION-IF-NOT-FOUND. This macro calls `AC_PROG_CPP' or `AC_PROG_CXXCPP' (depending on which language is current, *note Language Choice::.), if it hasn't been called already. File: autoconf.info, Node: Examining Syntax, Next: Examining Libraries, Prev: Examining Declarations, Up: Writing Tests Examining Syntax ================ To check for a syntax feature of the C or C++ compiler, such as whether it recognizes a certain keyword, use `AC_TRY_COMPILE' to try to compile a small program that uses that feature. You can also use it to check for structures and structure members that are not present on all systems. - Macro: AC_TRY_COMPILE (INCLUDES, FUNCTION-BODY, ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]) Create a test C program to see whether a function whose body consists of FUNCTION-BODY can be compiled; INCLUDES is any `#include' statements needed by the code in FUNCTION-BODY. If the file compiles successfully, run shell commands ACTION-IF-FOUND, otherwise run ACTION-IF-NOT-FOUND. This macro uses `CFLAGS' or `CXXFLAGS', and `CPPFLAGS', when compiling. It does not try to link; use `AC_TRY_LINK' if you need to do that (*note Examining Libraries::.). File: autoconf.info, Node: Examining Libraries, Next: Run Time, Prev: Examining Syntax, Up: Writing Tests Examining Libraries =================== To check for a library, a function, or a global variable, Autoconf `configure' scripts try to compile and link a small program that uses it. This is unlike Metaconfig, which by default uses `nm' or `ar' on the C library to try to figure out which functions are available. Trying to link with the function is usually a more reliable approach because it avoids dealing with the variations in the options and output formats of `nm' and `ar' and in the location of the standard libraries. It also allows configuring for cross-compilation or checking a function's runtime behavior if needed. On the other hand, it can be slower than scanning the libraries once. A few systems have linkers that do not return a failure exit status when there are unresolved functions in the link. This bug makes the configuration scripts produced by Autoconf unusable on those systems. However, some of them can be given options that make the exit status correct. This is a problem that Autoconf does not currently handle automatically. `AC_TRY_LINK' is used to compile test programs to test for functions and global variables. It is also used (by `AC_CHECK_LIB') to check for libraries, by adding the library being checked for to `LIBS' temporarily and trying to link a small program. - Macro: AC_TRY_LINK (INCLUDES, FUNCTION-BODY, ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]) Create a test C program to see whether a function whose body consists of FUNCTION-BODY can be compiled and linked; INCLUDES is any `#include' statements needed by the code in FUNCTION-BODY. If the file compiles and links successfully, run shell commands ACTION-IF-FOUND, otherwise run ACTION-IF-NOT-FOUND. This macro uses `CFLAGS' or `CXXFLAGS', `CPPFLAGS', `LDFLAGS', and `LIBS' when compiling. - Macro: AC_COMPILE_CHECK (ECHO-TEXT, INCLUDES, FUNCTION-BODY, ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]) This is an obsolete version of `AC_TRY_LINK', with the addition that it prints `checking for ECHO-TEXT' to the standard output first, if ECHO-TEXT is non-empty. Use `AC_MSG_CHECKING' and `AC_MSG_RESULT' instead to print messages (*note Printing Messages::.).