home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 2 / goldfish_vol2_cd1.bin / gnu / info / autoconf.info-2 (.txt) < prev    next >
GNU Info File  |  1994-11-17  |  50KB  |  949 lines
  1. This is Info file /gnu/src/amiga/autoconf-2.1/autoconf.info, produced
  2. by Makeinfo-1.55 from the input file
  3. /gnu/src/amiga/autoconf-2.1/autoconf.texi.
  4. START-INFO-DIR-ENTRY
  5. * Autoconf: (autoconf).         Create source code configuration scripts.
  6. END-INFO-DIR-ENTRY
  7.    This file documents the GNU Autoconf package for creating scripts to
  8. configure source code packages using templates and an `m4' macro
  9. package.
  10.    Copyright (C) 1992, 1993, 1994 Free Software Foundation, Inc.
  11.    Permission is granted to make and distribute verbatim copies of this
  12. manual provided the copyright notice and this permission notice are
  13. preserved on all copies.
  14.    Permission is granted to copy and distribute modified versions of
  15. this manual under the conditions for verbatim copying, provided that
  16. the entire resulting derived work is distributed under the terms of a
  17. permission notice identical to this one.
  18.    Permission is granted to copy and distribute translations of this
  19. manual into another language, under the above conditions for modified
  20. versions, except that this permission notice may be stated in a
  21. translation approved by the Foundation.
  22. File: autoconf.info,  Node: Versions,  Prev: Default Prefix,  Up: Setup
  23. Version Numbers in `configure'
  24. ==============================
  25.    The following macros manage version numbers for `configure' scripts.
  26. Using them is optional.
  27.  - Macro: AC_PREREQ (VERSION)
  28.      Ensure that a recent enough version of Autoconf is being used.  If
  29.      the version of Autoconf being used to create `configure' is earlier
  30.      than VERSION, print an error message on the standard error output
  31.      and do not create `configure'.  For example:
  32.           AC_PREREQ(1.8)
  33.      This macro is useful if your `configure.in' relies on non-obvious
  34.      behavior that changed between Autoconf releases.  If it merely
  35.      needs recently added macros, then `AC_PREREQ' is less useful,
  36.      because the `autoconf' program already tells the user which macros
  37.      are not found.  The same thing happens if `configure.in' is
  38.      processed by a version of Autoconf older than when `AC_PREREQ' was
  39.      added.
  40.  - Macro: AC_REVISION (REVISION-INFO)
  41.      Copy revision stamp REVISION-INFO into the `configure' script,
  42.      with any dollar signs or double-quotes removed.  This macro lets
  43.      you put a revision stamp from `configure.in' into `configure'
  44.      without RCS or CVS changing it when you check in `configure'.  That
  45.      way, you can determine easily which revision of `configure.in' a
  46.      particular `configure' corresponds to.
  47.      It is a good idea to call this macro before `AC_INIT' so that the
  48.      revision number is near the top of both `configure.in' and
  49.      `configure'.  To support doing that, the `AC_REVISION' output
  50.      begins with `#!/bin/sh', like the normal start of a `configure'
  51.      script does.
  52.      For example, this line in `configure.in':
  53.           AC_REVISION($Revision: 1.30 $)dnl
  54.      produces this in `configure':
  55.           #!/bin/sh
  56.           # From configure.in Revision: 1.30
  57. File: autoconf.info,  Node: Existing Tests,  Next: Writing Tests,  Prev: Setup,  Up: Top
  58. Existing Tests
  59. **************
  60.    These macros test for particular system features that packages might
  61. need or want to use.  If you need to test for a kind of feature that
  62. none of these macros check for, you can probably do it by calling
  63. primitive test macros with appropriate arguments (*note Writing
  64. Tests::.).
  65.    These tests print messages telling the user which feature they're
  66. checking for, and what they find.  They cache their results for future
  67. `configure' runs (*note Caching Results::.).
  68.    Some of these macros set output variables.  *Note Makefile
  69. Substitutions::, for how to get their values.  The phrase "define NAME"
  70. is used below as a shorthand to mean "define C preprocessor symbol NAME
  71. to the value 1".  *Note Defining Symbols::, for how to get those symbol
  72. definitions into your program.
  73. * Menu:
  74. * Alternative Programs::    Selecting between alternative programs.
  75. * Libraries::                   Library archives that might be missing.
  76. * Library Functions::        C library functions that might be missing.
  77. * Header Files::        Header files that might be missing.
  78. * Structures::            Structures or members that might be missing.
  79. * Typedefs::            `typedef's that might be missing.
  80. * Compiler Characteristics::    C compiler or machine architecture features.
  81. * System Services::        Operating system services.
  82. * UNIX Variants::        Special kludges for specific UNIX variants.
  83. File: autoconf.info,  Node: Alternative Programs,  Next: Libraries,  Up: Existing Tests
  84. Alternative Programs
  85. ====================
  86.    These macros check for the presence or behavior of particular
  87. programs.  They are used to choose between several alternative programs
  88. and to decide what to do once one has been chosen.  If there is no
  89. macro specifically defined to check for a program you need, and you
  90. don't need to check for any special properties of it, then you can use
  91. one of the general program check macros.
  92. * Menu:
  93. * Particular Programs::         Special handling to find certain programs.
  94. * Generic Programs::            How to find other programs.
  95. File: autoconf.info,  Node: Particular Programs,  Next: Generic Programs,  Up: Alternative Programs
  96. Particular Program Checks
  97. -------------------------
  98.    These macros check for particular programs--whether they exist, and
  99. in some cases whether they support certain features.
  100.  - Macro: AC_DECL_YYTEXT
  101.      Define `YYTEXT_POINTER' if `yytext' is a `char *' instead of a
  102.      `char []'.  Also set output variable `LEX_OUTPUT_ROOT' to the base
  103.      of the file name that the lexer generates; usually `lex.yy', but
  104.      sometimes something else.  These results vary according to whether
  105.      `lex' or `flex' is being used.
  106.  - Macro: AC_PROG_AWK
  107.      Check for `mawk', `gawk', `nawk', and `awk', in that order, and
  108.      set output variable `AWK' to the first one that it finds.  It
  109.      tries `mawk' first because that is reported to be the fastest
  110.      implementation.
  111.  - Macro: AC_PROG_CC
  112.      Determine a C compiler to use.  If `CC' is not already set in the
  113.      environment, check for `gcc', and use `cc' if it's not found.  Set
  114.      output variable `CC' to the name of the compiler found.
  115.      If using the GNU C compiler, set shell variable `GCC' to `yes',
  116.      empty otherwise.  If output variable `CFLAGS' was not already set,
  117.      set it to `-g -O' for the GNU C compiler (`-O' on systems where
  118.      GCC does not accept `-g'), or `-g' for other compilers.
  119.  - Macro: AC_PROG_CC_C_O
  120.      If the C compiler does not accept the `-c' and `-o' options
  121.      simultaneously, define `NO_MINUS_C_MINUS_O'.
  122.  - Macro: AC_PROG_CPP
  123.      Set output variable `CPP' to a command that runs the C
  124.      preprocessor.  If `$CC -E' doesn't work, it uses `/lib/cpp'.  It
  125.      is only portable to run `CPP' on files with a `.c' extension.
  126.      If the current language is C (*note Language Choice::.), many of
  127.      the specific test macros use the value of `CPP' indirectly by
  128.      calling `AC_TRY_CPP', `AC_CHECK_HEADER', `AC_EGREP_HEADER', or
  129.      `AC_EGREP_CPP'.
  130.  - Macro: AC_PROG_CXX
  131.      Determine a C++ compiler to use.  Check if the environment variable
  132.      `CXX' or `CCC' (in that order) is set; if so, set output variable
  133.      `CXX' to its value.  Otherwise search for a C++ compiler under
  134.      likely names (`c++', `g++', `gcc', `CC', and `cxx').  If none of
  135.      those checks succeed, as a last resort set `CXX' to `gcc'.
  136.      If using the GNU C++ compiler, set shell variable `GXX' to `yes',
  137.      empty otherwise.  If output variable `CXXFLAGS' was not already
  138.      set, set it to `-g -O' for the GNU C++ compiler (`-O' on systems
  139.      where G++ does not accept `-g'), or `-g' for other compilers.
  140.  - Macro: AC_PROG_CXXCPP
  141.      Set output variable `CXXCPP' to a command that runs the C++
  142.      preprocessor.  If `$CXX -E' doesn't work, it uses `/lib/cpp'.  It
  143.      is only portable to run `CXXCPP' on files with a `.c', `.C', or
  144.      `.cc' extension.
  145.      If the current language is C++ (*note Language Choice::.), many of
  146.      the specific test macros use the value of `CXXCPP' indirectly by
  147.      calling `AC_TRY_CPP', `AC_CHECK_HEADER', `AC_EGREP_HEADER', or
  148.      `AC_EGREP_CPP'.
  149.  - Macro: AC_PROG_GCC_TRADITIONAL
  150.      Add `-traditional' to output variable `CC' if using the GNU C
  151.      compiler and `ioctl' does not work properly without
  152.      `-traditional'.  That usually happens when the fixed header files
  153.      have not been installed on an old system.  Since recent versions
  154.      of the GNU C compiler fix the header files automatically when
  155.      installed, this is becoming a less prevalent problem.
  156.  - Macro: AC_PROG_INSTALL
  157.      Set output variable `INSTALL' to the path of a BSD compatible
  158.      `install' program, if one is found in the current `PATH'.
  159.      Otherwise, set `INSTALL' to `DIR/install-sh -c', checking the
  160.      directories specified to `AC_CONFIG_AUX_DIR' (or its default
  161.      directories) to determine DIR (*note Output::.).  Also set the
  162.      variable `INSTALL_PROGRAM' to `${INSTALL}' and `INSTALL_DATA' to
  163.      `${INSTALL} -m 644'.
  164.      This macro screens out various instances of `install' known to not
  165.      work.  It prefers to find a C program rather than a shell script,
  166.      for speed.  Instead of `install-sh', it can also use `install.sh',
  167.      but that name is obsolete because some `make' programs have a rule
  168.      that creates `install' from it if there is no `Makefile'.
  169.      A copy of `install-sh' which you may use comes with Autoconf.  If
  170.      you use `AC_PROG_INSTALL', you must include either `install-sh' or
  171.      `install.sh' in your distribution, or `configure' will produce an
  172.      error message saying it can't find them--even if the system you're
  173.      on has a good `install' program.  This check is a safety measure
  174.      to prevent you from accidentally leaving that file out, which
  175.      would prevent your package from installing on systems that don't
  176.      have a BSD-compatible `install' program.
  177.      If you need to use your own installation program because it has
  178.      features not found in standard `install' programs, there is no
  179.      reason to use `AC_PROG_INSTALL'; just put the pathname of your
  180.      program into your `Makefile.in' files.
  181.  - Macro: AC_PROG_LEX
  182.      If `flex' is found, set output variable `LEX' to `flex' and
  183.      `LEXLIB' to `-lfl', if that library is in a standard place.
  184.      Otherwise set `LEX' to `lex' and `LEXLIB' to `-ll'.
  185.  - Macro: AC_PROG_LN_S
  186.      If `ln -s' works on the current filesystem (the operating system
  187.      and filesystem support symbolic links), set output variable `LN_S'
  188.      to `ln -s', otherwise set it to `ln'.
  189.  - Macro: AC_PROG_RANLIB
  190.      Set output variable `RANLIB' to `ranlib' if `ranlib' is found,
  191.      otherwise to `:' (do nothing).
  192.  - Macro: AC_PROG_YACC
  193.      If `bison' is found, set output variable `YACC' to `bison -y'.
  194.      Otherwise, if `byacc' is found, set `YACC' to `byacc'.  Otherwise
  195.      set `YACC' to `yacc'.
  196. File: autoconf.info,  Node: Generic Programs,  Prev: Particular Programs,  Up: Alternative Programs
  197. Generic Program Checks
  198. ----------------------
  199.    These macros are used to find programs not covered by the particular
  200. test macros.  If you need to check the behavior of a program as well as
  201. find out whether it is present, you have to write your own test for it
  202. (*note Writing Tests::.).
  203.  - Macro: AC_CHECK_PROG (VARIABLE, PROG-TO-CHECK-FOR, VALUE-IF-FOUND [,
  204.           VALUE-IF-NOT-FOUND])
  205.      Check whether program PROG-TO-CHECK-FOR exists in `PATH'.  If it
  206.      is found, set VARIABLE to VALUE-IF-FOUND, otherwise to
  207.      VALUE-IF-NOT-FOUND, if given.  If VARIABLE was already set, do
  208.      nothing.  Calls `AC_SUBST' for VARIABLE.
  209.  - Macro: AC_CHECK_PROGS (VARIABLE, PROGS-TO-CHECK-FOR [,
  210.           VALUE-IF-NOT-FOUND])
  211.      Check for each program in the whitespace-separated list
  212.      PROGS-TO-CHECK-FOR exists in `PATH'.  If it is found, set VARIABLE
  213.      to the name of that program.  Otherwise, continue checking the
  214.      next program in the list.  If none of the programs in the list are
  215.      found, set VARIABLE to VALUE-IF-NOT-FOUND; if VALUE-IF-NOT-FOUND
  216.      is not specified, the value of VARIABLE is not changed.  Calls
  217.      `AC_SUBST' for VARIABLE.
  218.  - Macro: AC_PATH_PROG (VARIABLE, PROG-TO-CHECK-FOR [,
  219.           VALUE-IF-NOT-FOUND])
  220.      Like `AC_CHECK_PROG', but set VARIABLE to the entire path of
  221.      PROG-TO-CHECK-FOR if found.
  222.  - Macro: AC_PATH_PROGS (VARIABLE, PROGS-TO-CHECK-FOR [,
  223.           VALUE-IF-NOT-FOUND])
  224.      Like `AC_CHECK_PROGS', but if any of PROGS-TO-CHECK-FOR are found,
  225.      set VARIABLE to the entire path of the program found.
  226. File: autoconf.info,  Node: Libraries,  Next: Library Functions,  Prev: Alternative Programs,  Up: Existing Tests
  227. Library Files
  228. =============
  229.    The following macros check for the presence of certain C library
  230. archive files.
  231.  - Macro: AC_CHECK_LIB (LIBRARY, FUNCTION [, ACTION-IF-FOUND [,
  232.           ACTION-IF-NOT-FOUND [, OTHER-LIBRARIES]]])
  233.      Try to ensure that C function FUNCTION is available by checking
  234.      whether a test C program can be linked with the library LIBRARY to
  235.      get the function.  LIBRARY is the base name of the library; e.g.,
  236.      to check for `-lmp', use `mp' as the LIBRARY argument.
  237.      ACTION-IF-FOUND is a list of shell commands to run if the link
  238.      with the library succeeds; ACTION-IF-NOT-FOUND is a list of shell
  239.      commands to run if the link fails.  If ACTION-IF-FOUND and
  240.      ACTION-IF-NOT-FOUND are not specified, the default action is to
  241.      add `-lLIBRARY' to `LIBS' and define `HAVE_LIBLIBRARY' (in all
  242.      capitals).
  243.      If linking with LIBRARY results in unresolved symbols, which would
  244.      be resolved by linking with additional libraries, give those
  245.      libraries as the OTHER-LIBRARIES argument, separated by spaces:
  246.      `-lX11 -lXt'.  Otherwise this macro will fail to detect that
  247.      LIBRARY is present, because linking the test program will always
  248.      fail with unresolved symbols.
  249.  - Macro: AC_HAVE_LIBRARY (LIBRARY, [, ACTION-IF-FOUND [,
  250.           ACTION-IF-NOT-FOUND [, OTHER-LIBRARIES]]])
  251.      This macro is equivalent to calling `AC_CHECK_LIB' with a FUNCTION
  252.      argument of `main'.  In addition, LIBRARY can be written as any of
  253.      `foo', `-lfoo', or `libfoo.a'.  In all of those cases, the
  254.      compiler is passed `-lfoo'.  However, LIBRARY can not be a shell
  255.      variable; it must be a literal name.  This macro is considered
  256.      obsolete.
  257. File: autoconf.info,  Node: Library Functions,  Next: Header Files,  Prev: Libraries,  Up: Existing Tests
  258. Library Functions
  259. =================
  260.    The following macros check for particular C library functions.  If
  261. there is no macro specifically defined to check for a function you need,
  262. and you don't need to check for any special properties of it, then you
  263. can use one of the general function check macros.
  264. * Menu:
  265. * Particular Functions::        Special handling to find certain functions.
  266. * Generic Functions::           How to find other functions.
  267. File: autoconf.info,  Node: Particular Functions,  Next: Generic Functions,  Up: Library Functions
  268. Particular Function Checks
  269. --------------------------
  270.    These macros check for particular C functions--whether they exist,
  271. and in some cases how they respond when given certain arguments.
  272.  - Macro: AC_FUNC_ALLOCA
  273.      Check how to get `alloca'.  Tries to get a builtin version by
  274.      checking for `alloca.h' or the predefined C preprocessor macros
  275.      `__GNUC__' and `_AIX'.  If this macro finds `alloca.h', it defines
  276.      `HAVE_ALLOCA_H'.
  277.      If those attempts fail, it looks for the function in the standard C
  278.      library.  If any of those methods succeed, it defines
  279.      `HAVE_ALLOCA'.  Otherwise, it sets the output variable `ALLOCA' to
  280.      `alloca.o' and defines `C_ALLOCA' (so programs can periodically
  281.      call `alloca(0)' to garbage collect).  This variable is separate
  282.      from `LIBOBJS' so multiple programs can share the value of
  283.      `ALLOCA' without needing to create an actual library, in case only
  284.      some of them use the code in `LIBOBJS'.
  285.      This macro does not try to get `alloca' from the System V R3
  286.      `libPW' or the System V R4 `libucb' because those libraries
  287.      contain some incompatible functions that cause trouble.  Some
  288.      versions do not even contain `alloca' or contain a buggy version.
  289.      If you still want to use their `alloca', use `ar' to extract
  290.      `alloca.o' from them instead of compiling `alloca.c'.
  291.      Source files that use `alloca' should start with a piece of code
  292.      like the following, to declare it properly.  In some versions of
  293.      AIX, the declaration of `alloca' must precede everything else
  294.      except for comments and preprocessor directives.  The `#pragma'
  295.      directive is indented so that pre-ANSI C compilers will ignore it,
  296.      rather than choke on it.
  297.           /* AIX requires this to be the first thing in the file.  */
  298.           #ifdef __GNUC__
  299.           # define alloca __builtin_alloca
  300.           #else
  301.           # if HAVE_ALLOCA_H
  302.           #  include <alloca.h>
  303.           # else
  304.           #  ifdef _AIX
  305.            #pragma alloca
  306.           #  else
  307.           #   ifndef alloca /* predefined by HP cc +Olibcalls */
  308.           char *alloca ();
  309.           #   endif
  310.           #  endif
  311.           # endif
  312.           #endif
  313.  - Macro: AC_FUNC_CLOSEDIR_VOID
  314.      If the `closedir' function does not return a meaningful value,
  315.      define `CLOSEDIR_VOID'.  Otherwise, callers ought to check its
  316.      return value for an error indicator.
  317.  - Macro: AC_FUNC_GETLOADAVG
  318.      Check how to get the system load averages.  If the system has the
  319.      `getloadavg' function, this macro defines `HAVE_GETLOADAVG', and
  320.      adds to `LIBS' any libraries needed to get that function.
  321.      Otherwise, it adds `getloadavg.o' to the output variable
  322.      `LIBOBJS', and possibly defines several other C preprocessor
  323.      macros and output variables:
  324.        1. It defines `SVR4', `DGUX', `UMAX', or `UMAX4_3' if on those
  325.           systems.
  326.        2. If it finds `nlist.h', it defines `NLIST_STRUCT'.
  327.        3. If `struct nlist' has an `n_un' member, it defines
  328.           `NLIST_NAME_UNION'.
  329.        4. If compiling `getloadavg.c' defines `LDAV_PRIVILEGED',
  330.           programs need to be installed specially on this system for
  331.           `getloadavg' to work, and this macro defines
  332.           `GETLOADAVG_PRIVILEGED'.
  333.        5. This macro sets the output variable `NEED_SETGID'.  The value
  334.           is `true' if special installation is required, `false' if not.
  335.           If `NEED_SETGID' is `true', this macro sets `KMEM_GROUP' to
  336.           the name of the group that should own the installed program.
  337.  - Macro: AC_FUNC_GETMNTENT
  338.      Check for the `getmntent' in the `sun' and `seq' libraries, for
  339.      Irix 4 and PTX, respectively.  Then, if `getmntent' is available,
  340.      define `HAVE_GETMNTENT'.
  341.  - Macro: AC_FUNC_MEMCMP
  342.      If the `memcmp' function is not available, or does not work on
  343.      8-bit data (like the one on SunOS 4.1.3), add `memcmp.o' to output
  344.      variable `LIBOBJS'.
  345.  - Macro: AC_FUNC_MMAP
  346.      If the `mmap' function exists and works correctly on memory mapped
  347.      files, define `HAVE_MMAP'.
  348.  - Macro: AC_FUNC_SETVBUF_REVERSED
  349.      If `setvbuf' takes the buffering type as its second argument and
  350.      the buffer pointer as the third, instead of the other way around,
  351.      define `SETVBUF_REVERSED'.  This is the case on System V before
  352.      release 3.
  353.  - Macro: AC_FUNC_STRCOLL
  354.      If the `strcoll' function exists and works correctly, define
  355.      `HAVE_STRCOLL'.  This does a bit more than
  356.      `AC_CHECK_FUNCS(strcoll)', because some systems have incorrect
  357.      definitions of `strcoll', which should not be used.
  358.  - Macro: AC_FUNC_STRFTIME
  359.      Check for `strftime' in the `intl' library, for SCO UNIX.  Then,
  360.      if `strftime' is available, define `HAVE_STRFTIME'.
  361.  - Macro: AC_FUNC_UTIME_NULL
  362.      If `utime(FILE, NULL)' sets FILE's timestamp to the present,
  363.      define `HAVE_UTIME_NULL'.
  364.  - Macro: AC_FUNC_VFORK
  365.      If `vfork.h' is found, define `HAVE_VFORK_H'.  If a working
  366.      `vfork' is not found, define `vfork' to be `fork'.  This macro
  367.      checks for several known errors in implementations of `vfork' and
  368.      considers the system to not have a working `vfork' if it detects
  369.      any of them.
  370.  - Macro: AC_FUNC_VPRINTF
  371.      If `vprintf' is found, define `HAVE_VPRINTF'.  Otherwise, if
  372.      `_doprnt' is found, define `HAVE_DOPRNT'.  (If `vprintf' is
  373.      available, you may assume that `vfprintf' and `vsprintf' are also
  374.      available.)
  375.  - Macro: AC_FUNC_WAIT3
  376.      If `wait3' is found and fills in the contents of its third argument
  377.      (a `struct rusage *'), which HP-UX does not do, define
  378.      `HAVE_WAIT3'.
  379. File: autoconf.info,  Node: Generic Functions,  Prev: Particular Functions,  Up: Library Functions
  380. Generic Function Checks
  381. -----------------------
  382.    These macros are used to find functions not covered by the particular
  383. test macros.  If the functions might be in libraries other than the
  384. default C library, first call `AC_CHECK_LIB' for those libraries.  If
  385. you need to check the behavior of a function as well as find out
  386. whether it is present, you have to write your own test for it (*note
  387. Writing Tests::.).
  388.  - Macro: AC_CHECK_FUNC (FUNCTION, ACTION-IF-FOUND [,
  389.           ACTION-IF-NOT-FOUND])
  390.      If C function FUNCTION is available, run shell commands
  391.      ACTION-IF-FOUND, otherwise ACTION-IF-NOT-FOUND.  If you just want
  392.      to define a symbol if the function is available, consider using
  393.      `AC_CHECK_FUNCS' instead.  This macro checks for functions with C
  394.      linkage even when `AC_LANG_CPLUSPLUS' has been called, since C++ is
  395.      more standardized than C is.  (*note Language Choice::., for more
  396.      information about selecting the language for checks.)
  397.  - Macro: AC_CHECK_FUNCS (FUNCTION... [, ACTION-IF-FOUND [,
  398.           ACTION-IF-NOT-FOUND]])
  399.      For each given FUNCTION in the whitespace-separated argument list
  400.      that is available, define `HAVE_FUNCTION' (in all capitals).  If
  401.      ACTION-IF-FOUND is given, it is additional shell code to execute
  402.      when one of the functions is found.  You can give it a value of
  403.      `break' to break out of the loop on the first match.  If
  404.      ACTION-IF-NOT-FOUND is given, it is executed when one of the
  405.      functions is not found.
  406.  - Macro: AC_REPLACE_FUNCS (FUNCTION-NAME...)
  407.      For each given FUNCTION-NAME in the whitespace-separated argument
  408.      list that is not in the C library, add `FUNCTION-NAME.o' to the
  409.      value of the output variable `LIBOBJS'.
  410. File: autoconf.info,  Node: Header Files,  Next: Structures,  Prev: Library Functions,  Up: Existing Tests
  411. Header Files
  412. ============
  413.    The following macros check for the presence of certain C header
  414. files.  If there is no macro specifically defined to check for a header
  415. file you need, and you don't need to check for any special properties of
  416. it, then you can use one of the general header file check macros.
  417. * Menu:
  418. * Particular Headers::          Special handling to find certain headers.
  419. * Generic Headers::             How to find other headers.
  420. File: autoconf.info,  Node: Particular Headers,  Next: Generic Headers,  Up: Header Files
  421. Particular Header Checks
  422. ------------------------
  423.    These macros check for particular system header files--whether they
  424. exist, and in some cases whether they declare certain symbols.
  425.  - Macro: AC_DECL_SYS_SIGLIST
  426.      Define `SYS_SIGLIST_DECLARED' if the variable `sys_siglist' is
  427.      declared in a system header file, either `signal.h' or `unistd.h'.
  428.  - Macro: AC_DIR_HEADER
  429.      Like calling `AC_HEADER_DIRENT' and `AC_FUNC_CLOSEDIR_VOID', but
  430.      defines a different set of C preprocessor macros to indicate which
  431.      header file is found.  This macro and the names it defines are
  432.      considered obsolete.  The names it defines are:
  433.     `dirent.h'
  434.           `DIRENT'
  435.     `sys/ndir.h'
  436.           `SYSNDIR'
  437.     `sys/dir.h'
  438.           `SYSDIR'
  439.     `ndir.h'
  440.           `NDIR'
  441.      In addition, if the `closedir' function does not return a
  442.      meaningful value, define `VOID_CLOSEDIR'.
  443.  - Macro: AC_HEADER_DIRENT
  444.      Check for the following header files, and for the first one that is
  445.      found and defines `DIR', define the listed C preprocessor macro:
  446.     `dirent.h'
  447.           `HAVE_DIRENT_H'
  448.     `sys/ndir.h'
  449.           `HAVE_SYS_NDIR_H'
  450.     `sys/dir.h'
  451.           `HAVE_SYS_DIR_H'
  452.     `ndir.h'
  453.           `HAVE_NDIR_H'
  454.      The directory library declarations in the source code should look
  455.      something like the following:
  456.           #if HAVE_DIRENT_H
  457.           # include <dirent.h>
  458.           # define NAMLEN(dirent) strlen((dirent)->d_name)
  459.           #else
  460.           # define dirent direct
  461.           # define NAMLEN(dirent) (dirent)->d_namlen
  462.           # if HAVE_SYS_NDIR_H
  463.           #  include <sys/ndir.h>
  464.           # endif
  465.           # if HAVE_SYS_DIR_H
  466.           #  include <sys/dir.h>
  467.           # endif
  468.           # if HAVE_NDIR_H
  469.           #  include <ndir.h>
  470.           # endif
  471.           #endif
  472.      Using the above declarations, the program would declare variables
  473.      to be type `struct dirent', not `struct direct', and would access
  474.      the length of a directory entry name by passing a pointer to a
  475.      `struct dirent' to the `NAMLEN' macro.
  476.      This macro also checks for the SCO Xenix `dir' and `x' libraries.
  477.  - Macro: AC_HEADER_MAJOR
  478.      If `sys/types.h' does not define `major', `minor', and `makedev',
  479.      but `sys/mkdev.h' does, define `MAJOR_IN_MKDEV'; otherwise, if
  480.      `sys/sysmacros.h' does, define `MAJOR_IN_SYSMACROS'.
  481.  - Macro: AC_HEADER_STDC
  482.      Define `STDC_HEADERS' if the system has ANSI C header files.
  483.      Specifically, this macro checks for `stdlib.h', `stdarg.h',
  484.      `string.h', and `float.h'; if the system has those, it probably
  485.      has the rest of the ANSI C header files.  This macro also checks
  486.      whether `string.h' declares `memchr' (and thus presumably the
  487.      other `mem' functions), whether `stdlib.h' declare `free' (and
  488.      thus presumably `malloc' and other related functions), and whether
  489.      the `ctype.h' macros work on characters with the high bit set, as
  490.      ANSI C requires.
  491.      Use `STDC_HEADERS' instead of `__STDC__' to determine whether the
  492.      system has ANSI-compliant header files (and probably C library
  493.      functions) because many systems that have GCC do not have ANSI C
  494.      header files.
  495.      On systems without ANSI C headers, there is so much variation that
  496.      it is probably easier to declare the functions you use than to
  497.      figure out exactly what the system header files declare.  Some
  498.      systems contain a mix of functions ANSI and BSD; some are mostly
  499.      ANSI but lack `memmove'; some define the BSD functions as macros in
  500.      `string.h' or `strings.h'; some have only the BSD functions but
  501.      `string.h'; some declare the memory functions in `memory.h', some
  502.      in `string.h'; etc.  It is probably sufficient to check for one
  503.      string function and one memory function; if the library has the
  504.      ANSI versions of those then it probably has most of the others.
  505.      If you put the following in `configure.in':
  506.           AC_HEADER_STDC
  507.           AC_CHECK_FUNCS(strchr memcpy)
  508.      then, in your code, you can put declarations like this:
  509.           #if STDC_HEADERS
  510.           # include <string.h>
  511.           #else
  512.           # ifndef HAVE_STRCHR
  513.           #  define strchr index
  514.           #  define strrchr rindex
  515.           # endif
  516.           char *strchr (), *strrchr ();
  517.           # ifndef HAVE_MEMCPY
  518.           #  define memcpy(d, s, n) bcopy ((s), (d), (n))
  519.           #  define memmove(d, s, n) bcopy ((s), (d), (n))
  520.           # endif
  521.           #endif
  522.      If you use a function like `memchr', `memset', `strtok', or
  523.      `strspn', which have no BSD equivalent, then macros won't suffice;
  524.      you must provide an implementation of each function.  An easy way
  525.      to incorporate your implementations only when needed (since the
  526.      ones in system C libraries may be hand optimized) is to, taking
  527.      `memchr' for example, put it in `memchr.c' and use
  528.      `AC_REPLACE_FUNCS(memchr)'.
  529.  - Macro: AC_HEADER_SYS_WAIT
  530.      If `sys/wait.h' exists and is compatible with POSIX.1, define
  531.      `HAVE_SYS_WAIT_H'.  Incompatibility can occur if `sys/wait.h' does
  532.      not exist, or if it uses the old BSD `union wait' instead of `int'
  533.      to store a status value.  If `sys/wait.h' is not POSIX.1
  534.      compatible, then instead of including it, define the POSIX.1
  535.      macros with their usual interpretations.  Here is an example:
  536.           #include <sys/types.h>
  537.           #if HAVE_SYS_WAIT_H
  538.           # include <sys/wait.h>
  539.           #endif
  540.           #ifndef WEXITSTATUS
  541.           # define WEXITSTATUS(stat_val) ((unsigned)(stat_val) >> 8)
  542.           #endif
  543.           #ifndef WIFEXITED
  544.           # define WIFEXITED(stat_val) (((stat_val) & 255) == 0)
  545.           #endif
  546.  - Macro: AC_MEMORY_H
  547.      Define `NEED_MEMORY_H' if `memcpy', `memcmp', etc. are not
  548.      declared in `string.h' and `memory.h' exists.  This macro is
  549.      obsolete; instead, use `AC_CHECK_HEADERS(memory.h)'.  See the
  550.      example for `AC_HEADER_STDC'.
  551.  - Macro: AC_UNISTD_H
  552.      Define `HAVE_UNISTD_H' if the system has `unistd.h'.  This macro
  553.      is obsolete; instead, use `AC_CHECK_HEADERS(unistd.h)'.
  554.      The way to check if the system supports POSIX.1 is:
  555.           #if HAVE_UNISTD_H
  556.           # include <sys/types.h>
  557.           # include <unistd.h>
  558.           #endif
  559.           
  560.           #ifdef _POSIX_VERSION
  561.           /* Code for POSIX.1 systems.  */
  562.           #endif
  563.      `_POSIX_VERSION' is defined when `unistd.h' is included on POSIX.1
  564.      systems.  If there is no `unistd.h', it is definitely not a
  565.      POSIX.1 system.  However, some non-POSIX.1 systems do have
  566.      `unistd.h'.
  567.  - Macro: AC_USG
  568.      Define `USG' if the system does not have `strings.h', `rindex',
  569.      `bzero', etc.  This implies that it has `string.h', `strrchr',
  570.      `memset', etc.
  571.      The symbol `USG' is obsolete.  Instead of this macro, see the
  572.      example for `AC_HEADER_STDC'.
  573. File: autoconf.info,  Node: Generic Headers,  Prev: Particular Headers,  Up: Header Files
  574. Generic Header Checks
  575. ---------------------
  576.    These macros are used to find system header files not covered by the
  577. particular test macros.  If you need to check the contents of a header
  578. as well as find out whether it is present, you have to write your own
  579. test for it (*note Writing Tests::.).
  580.  - Macro: AC_CHECK_HEADER (HEADER-FILE, ACTION-IF-FOUND [,
  581.           ACTION-IF-NOT-FOUND])
  582.      If the system header file HEADER-FILE exists, execute shell
  583.      commands ACTION-IF-FOUND, otherwise execute ACTION-IF-NOT-FOUND.
  584.      If you just want to define a symbol if the header file is
  585.      available, consider using `AC_CHECK_HEADERS' instead.
  586.  - Macro: AC_CHECK_HEADERS (HEADER-FILE... [, ACTION-IF-FOUND [,
  587.           ACTION-IF-NOT-FOUND]])
  588.      For each given system header file HEADER-FILE in the
  589.      whitespace-separated argument list that exists, define
  590.      `HAVE_HEADER-FILE' (in all capitals).  If ACTION-IF-FOUND is
  591.      given, it is additional shell code to execute when one of the
  592.      header files is found.  You can give it a value of `break' to
  593.      break out of the loop on the first match.  If ACTION-IF-NOT-FOUND
  594.      is given, it is executed when one of the header files is not found.
  595. File: autoconf.info,  Node: Structures,  Next: Typedefs,  Prev: Header Files,  Up: Existing Tests
  596. Structures
  597. ==========
  598.    The following macros check for certain structures or structure
  599. members.  To check structures not listed here, use `AC_EGREP_CPP'
  600. (*note Examining Declarations::.) or `AC_TRY_COMPILE' (*note Examining
  601. Syntax::.).
  602.  - Macro: AC_HEADER_STAT
  603.      If the macros `S_ISDIR', `S_ISREG' et al. defined in `sys/stat.h'
  604.      do not work properly (returning false positives), define
  605.      `STAT_MACROS_BROKEN'.  This is the case on Tektronix UTekV, Amdahl
  606.      UTS and Motorola System V/88.
  607.  - Macro: AC_HEADER_TIME
  608.      If a program may include both `time.h' and `sys/time.h', define
  609.      `TIME_WITH_SYS_TIME'.  On some older systems, `sys/time.h'
  610.      includes `time.h', but `time.h' is not protected against multiple
  611.      inclusion, so programs should not explicitly include both files.
  612.      This macro is useful in programs that use, for example, `struct
  613.      timeval' or `struct timezone' as well as `struct tm'.  It is best
  614.      used in conjunction with `HAVE_SYS_TIME_H', which can be checked
  615.      for using `AC_CHECK_HEADERS(sys/time.h)'.
  616.           #if TIME_WITH_SYS_TIME
  617.           # include <sys/time.h>
  618.           # include <time.h>
  619.           #else
  620.           # if HAVE_SYS_TIME_H
  621.           #  include <sys/time.h>
  622.           # else
  623.           #  include <time.h>
  624.           # endif
  625.           #endif
  626.  - Macro: AC_STRUCT_ST_BLKSIZE
  627.      If `struct stat' contains an `st_blksize' member, define
  628.      `HAVE_ST_BLKSIZE'.
  629.  - Macro: AC_STRUCT_ST_BLOCKS
  630.      If `struct stat' contains an `st_blocks' member, define
  631.      `HAVE_ST_BLOCKS'.  Otherwise, add `fileblocks.o' to the output
  632.      variable `LIBOBJS'.
  633.  - Macro: AC_STRUCT_ST_RDEV
  634.      If `struct stat' contains an `st_rdev' member, define
  635.      `HAVE_ST_RDEV'.
  636.  - Macro: AC_STRUCT_TM
  637.      If `time.h' does not define `struct tm', define `TM_IN_SYS_TIME',
  638.      which means that including `sys/time.h' had better define `struct
  639.      tm'.
  640.  - Macro: AC_STRUCT_TIMEZONE
  641.      Figure out how to get the current timezone.  If `struct tm' has a
  642.      `tm_zone' member, define `HAVE_TM_ZONE'.  Otherwise, if the
  643.      external array `tzname' is found, define `HAVE_TZNAME'.
  644. File: autoconf.info,  Node: Typedefs,  Next: Compiler Characteristics,  Prev: Structures,  Up: Existing Tests
  645. Typedefs
  646. ========
  647.    The following macros check for C typedefs.  If there is no macro
  648. specifically defined to check for a typedef you need, and you don't need
  649. to check for any special properties of it, then you can use a general
  650. typedef check macro.
  651. * Menu:
  652. * Particular Typedefs::         Special handling to find certain types.
  653. * Generic Typedefs::            How to find other types.
  654. File: autoconf.info,  Node: Particular Typedefs,  Next: Generic Typedefs,  Up: Typedefs
  655. Particular Typedef Checks
  656. -------------------------
  657.    These macros check for particular C typedefs in `sys/types.h' and
  658. `stdlib.h' (if it exists).
  659.  - Macro: AC_TYPE_GETGROUPS
  660.      Define `GETGROUPS_T' to be whichever of `gid_t' or `int' is the
  661.      base type of the array argument to `getgroups'.
  662.  - Macro: AC_TYPE_MODE_T
  663.      If `mode_t' is not defined, define `mode_t' to be `int'.
  664.  - Macro: AC_TYPE_OFF_T
  665.      If `off_t' is not defined, define `off_t' to be `long'.
  666.  - Macro: AC_TYPE_PID_T
  667.      If `pid_t' is not defined, define `pid_t' to be `int'.
  668.  - Macro: AC_TYPE_SIGNAL
  669.      If `signal.h' declares `signal' as returning a pointer to a
  670.      function returning `void', define `RETSIGTYPE' to be `void';
  671.      otherwise, define it to be `int'.
  672.      Define signal handlers as returning type `RETSIGTYPE':
  673.           RETSIGTYPE
  674.           hup_handler ()
  675.           {
  676.           ...
  677.           }
  678.  - Macro: AC_TYPE_SIZE_T
  679.      If `size_t' is not defined, define `size_t' to be `unsigned'.
  680.  - Macro: AC_TYPE_UID_T
  681.      If `uid_t' is not defined, define `uid_t' to be `int' and `gid_t'
  682.      to be `int'.
  683. File: autoconf.info,  Node: Generic Typedefs,  Prev: Particular Typedefs,  Up: Typedefs
  684. Generic Typedef Checks
  685. ----------------------
  686.    This macro is used to check for typedefs not covered by the
  687. particular test macros.
  688.  - Macro: AC_CHECK_TYPE (TYPE, DEFAULT)
  689.      If the type TYPE is not defined in `sys/types.h' or `stdlib.h' (if
  690.      it exists), define it to be the C (or C++) builtin type DEFAULT;
  691.      e.g., `short' or `unsigned'.
  692. File: autoconf.info,  Node: Compiler Characteristics,  Next: System Services,  Prev: Typedefs,  Up: Existing Tests
  693. Compiler Characteristics
  694. ========================
  695.    The following macros check for C compiler or machine architecture
  696. features.  To check for characteristics not listed here, use
  697. `AC_TRY_COMPILE' (*note Examining Syntax::.) or `AC_TRY_RUN' (*note Run
  698. Time::.)
  699.  - Macro: AC_C_BIGENDIAN
  700.      If words are stored with the most significant byte first (like
  701.      Motorola and SPARC, but not Intel and VAX, CPUs), define
  702.      `WORDS_BIGENDIAN'.
  703.  - Macro: AC_C_CONST
  704.      If the C compiler does not fully support the keyword `const',
  705.      define `const' to be empty.  Some C compilers that do not define
  706.      `__STDC__' do support `const'; some compilers that define
  707.      `__STDC__' do not completely support `const'.  Programs can simply
  708.      use `const' as if every C compiler supported it; for those that
  709.      don't, the `Makefile' or configuration header file will define it
  710.      as empty.
  711.  - Macro: AC_C_INLINE
  712.      If the C compiler is a version of GCC that supports the keyword
  713.      `__inline' but not `inline' (such as some NeXT versions), define
  714.      `inline' to be `__inline'.
  715.  - Macro: AC_C_CHAR_UNSIGNED
  716.      If the C type `char' is unsigned, define `__CHAR_UNSIGNED__',
  717.      unless the C compiler predefines it.
  718.  - Macro: AC_C_LONG_DOUBLE
  719.      If the C compiler supports the `long double' type, define
  720.      `HAVE_LONG_DOUBLE'.  Some C compilers that do not define
  721.      `__STDC__' do support the `long double' type; some compilers that
  722.      define `__STDC__' do not support `long double'.
  723.  - Macro: AC_CHECK_SIZEOF (TYPE)
  724.      Define `SIZEOF_UCTYPE' to be the size in bytes of the C (or C++)
  725.      builtin type TYPE, e.g. `int' or `char *'.  If `type' is unknown
  726.      to the compiler, it gets a size of 0.  UCTYPE is TYPE, with
  727.      lowercase converted to uppercase, spaces changed to underscores,
  728.      and asterisks changed to `P'.  For example, the call
  729.           AC_CHECK_SIZEOF(int *)
  730.      defines `SIZEOF_INT_P' to be 64 on DEC Alpha AXP systems.
  731.  - Macro: AC_INT_16_BITS
  732.      If the C type `int' is 16 bits wide, define `INT_16_BITS'.  This
  733.      macro is obsolete; it is more general to use
  734.      `AC_CHECK_SIZEOF(int)' instead.
  735.  - Macro: AC_LONG_64_BITS
  736.      If the C type `long int' is 64 bits wide, define `LONG_64_BITS'.
  737.      This macro is obsolete; it is more general to use
  738.      `AC_CHECK_SIZEOF(long)' instead.
  739. File: autoconf.info,  Node: System Services,  Next: UNIX Variants,  Prev: Compiler Characteristics,  Up: Existing Tests
  740. System Services
  741. ===============
  742.    The following macros check for operating system services or
  743. capabilities.
  744.  - Macro: AC_SYS_INTERPRETER
  745.      Check whether the system supports starting scripts with a line of
  746.      the form `#!/bin/csh' to select the interpreter to use for the
  747.      script.  After running this macro, shell code in `configure.in'
  748.      can check the variable `ac_cv_sys_interpreter'; it will be set to
  749.      `yes' if the system supports `#!', `no' if not.
  750.  - Macro: AC_PATH_X
  751.      Try to locate the X Window System include files and libraries.  If
  752.      the user gave the command line options `--x-includes=DIR' and
  753.      `--x-libraries=DIR', use those directories.  If either or both
  754.      were not given, get the missing values by running `xmkmf' on a
  755.      trivial `Imakefile' and examining the `Makefile' that it produces.
  756.      If that fails (such as if `xmkmf' is not present), look for them
  757.      in several directories where they often reside.  If either method
  758.      is successful, set the shell variables `x_includes' and
  759.      `x_libraries' to their locations, unless they are in directories
  760.      the compiler searches by default.
  761.      If both methods fail, or the user gave the command line option
  762.      `--without-x', set the shell variable `no_x' to `yes'; otherwise
  763.      set it to the empty string.
  764.  - Macro: AC_PATH_XTRA
  765.      An enhanced version of `AC_PATH_X'.  Add the C compiler flags that
  766.      X needs to output variable `X_CFLAGS', and the X linker flags to
  767.      `X_LIBS'.  If X is not available, add `-DX_DISPLAY_MISSING' to
  768.      `X_CFLAGS'.
  769.      Also check for special libraries that some systems need in order to
  770.      compile X programs.  Add any that the system needs to output
  771.      variable `X_EXTRA_LIBS'.  And check for special X11R6 libraries
  772.      that need to be linked with before `-lX11', and add any found to
  773.      the output variable `X_PRE_LIBS'.
  774.  - Macro: AC_SYS_LONG_FILE_NAMES
  775.      If the system supports file names longer than 14 characters, define
  776.      `HAVE_LONG_FILE_NAMES'.
  777.  - Macro: AC_SYS_RESTARTABLE_SYSCALLS
  778.      If the system automatically restarts a system call that is
  779.      interrupted by a signal, define `HAVE_RESTARTABLE_SYSCALLS'.
  780. File: autoconf.info,  Node: UNIX Variants,  Prev: System Services,  Up: Existing Tests
  781. UNIX Variants
  782. =============
  783.    The following macros check for certain operating systems that need
  784. special treatment for some programs, due to exceptional oddities in
  785. their header files or libraries.  These macros are warts; they will be
  786. replaced by a more systematic approach, based on the functions they make
  787. available or the environments they provide.
  788.  - Macro: AC_AIX
  789.      If on AIX, define `_ALL_SOURCE'.  Allows the use of some BSD
  790.      functions.  Should be called before any macros that run the C
  791.      compiler.
  792.  - Macro: AC_DYNIX_SEQ
  793.      If on Dynix/PTX (Sequent UNIX), add `-lseq' to output variable
  794.      `LIBS'.  This macro is obsolete; instead, use `AC_FUNC_GETMNTENT'.
  795.  - Macro: AC_IRIX_SUN
  796.      If on IRIX (Silicon Graphics UNIX), add `-lsun' to output variable
  797.      `LIBS'.  This macro is obsolete.  If you were using it to get
  798.      `getmntent', use `AC_FUNC_GETMNTENT' instead.  If you used it for
  799.      the NIS versions of the password and group functions, use
  800.      `AC_CHECK_LIB(sun, getpwnam)'.
  801.  - Macro: AC_ISC_POSIX
  802.      If on a POSIXized ISC UNIX, define `_POSIX_SOURCE' and add
  803.      `-posix' (for the GNU C compiler) or `-Xp' (for other C compilers)
  804.      to output variable `CC'.  This allows the use of POSIX facilities.
  805.      Must be called after `AC_PROG_CC' and before any other macros
  806.      that run the C compiler.
  807.  - Macro: AC_MINIX
  808.      If on Minix, define `_MINIX' and `_POSIX_SOURCE' and define
  809.      `_POSIX_1_SOURCE' to be 2.  This allows the use of POSIX
  810.      facilities.  Should be called before any macros that run the C
  811.      compiler.
  812.  - Macro: AC_SCO_INTL
  813.      If on SCO UNIX, add `-lintl' to output variable `LIBS'.  This
  814.      macro is obsolete; instead, use `AC_FUNC_STRFTIME'.
  815.  - Macro: AC_XENIX_DIR
  816.      If on Xenix, add `-lx' to output variable `LIBS'.  Also, if
  817.      `dirent.h' is being used, add `-ldir' to `LIBS'.  This macro is
  818.      obsolete; use `AC_HEADER_DIRENT' instead.
  819. File: autoconf.info,  Node: Writing Tests,  Next: Results,  Prev: Existing Tests,  Up: Top
  820. Writing Tests
  821. *************
  822.    If the existing feature tests don't do something you need, you have
  823. to write new ones.  These macros are the building blocks.  They provide
  824. ways for other macros to check whether various kinds of features are
  825. available and report the results.
  826.    This chapter contains some suggestions and some of the reasons why
  827. the existing tests are written the way they are.  You can also learn a
  828. lot about how to write Autoconf tests by looking at the existing ones.
  829. If something goes wrong in one or more of the Autoconf tests, this
  830. information can help you understand the assumptions behind them, which
  831. might help you figure out how to best solve the problem.
  832.    These macros check the output of the C compiler system.  They do not
  833. cache the results of their tests for future use (*note Caching
  834. Results::.), because they don't know enough about the information they
  835. are checking for to generate a cache variable name.  They also do not
  836. print any messages, for the same reason.  The checks for particular
  837. kinds of C features call these macros and do cache their results and
  838. print messages about what they're checking for.
  839. * Menu:
  840. * Examining Declarations::    Detecting header files and declarations.
  841. * Examining Syntax::            Detecting language syntax features.
  842. * Examining Libraries::         Detecting functions and global variables.
  843. * Run Time::                Testing for run-time features.
  844. * Portable Shell::              Shell script portability pitfalls.
  845. * Testing Values and Files::    Checking strings and files.
  846. * Multiple Cases::        Tests for several possible values.
  847. * Language Choice::             Selecting which language to use for testing.
  848. File: autoconf.info,  Node: Examining Declarations,  Next: Examining Syntax,  Up: Writing Tests
  849. Examining Declarations
  850. ======================
  851.    The macro `AC_TRY_CPP' is used to check whether particular header
  852. files exist.  You can check for one at a time, or more than one if you
  853. need several header files to all exist for some purpose.
  854.  - Macro: AC_TRY_CPP (INCLUDES, ACTION-IF-TRUE [, ACTION-IF-FALSE])
  855.      INCLUDES is C or C++ `#include' statements and declarations, on
  856.      which shell variable, backquote, and backslash substitutions are
  857.      performed.  (Actually, it can be any C program, but other
  858.      statements are probably not useful.)  If the preprocessor produces
  859.      no error messages while processing it, run shell commands
  860.      ACTION-IF-TRUE.  Otherwise run shell commands ACTION-IF-FALSE.
  861.      This macro uses `CPPFLAGS', but not `CFLAGS', because `-g', `-O',
  862.      etc. are not valid options to many C preprocessors.
  863.    Here is now to find out whether a header file contains a particular
  864. declaration, such as a typedef, a structure, a structure member, or a
  865. function.  Use `AC_EGREP_HEADER' instead of running `grep' directly on
  866. the header file; on some systems the symbol might be defined in another
  867. header file that the file you are checking `#include's.
  868.  - Macro: AC_EGREP_HEADER (PATTERN, HEADER-FILE, ACTION-IF-FOUND [,
  869.           ACTION-IF-NOT-FOUND])
  870.      If the output of running the preprocessor on the system header file
  871.      HEADER-FILE matches the `egrep' regular expression PATTERN,
  872.      execute shell commands ACTION-IF-FOUND, otherwise execute
  873.      ACTION-IF-NOT-FOUND.
  874.    To check for C preprocessor symbols, either defined by header files
  875. or predefined by the C preprocessor, use `AC_EGREP_CPP'.  Here is an
  876. example of the latter:
  877.      AC_EGREP_CPP(yes,
  878.      [#ifdef _AIX
  879.        yes
  880.      #endif
  881.      ], is_aix=yes, is_aix=no)
  882.  - Macro: AC_EGREP_CPP (PATTERN, PROGRAM, ACTION-IF-FOUND [,
  883.           ACTION-IF-NOT-FOUND])
  884.      PROGRAM is the text of a C or C++ program, on which shell
  885.      variable, backquote, and backslash substitutions are performed.
  886.      If the output of running the preprocessor on PROGRAM matches the
  887.      `egrep' regular expression PATTERN, execute shell commands
  888.      ACTION-IF-FOUND, otherwise execute ACTION-IF-NOT-FOUND.
  889.      This macro calls `AC_PROG_CPP' or `AC_PROG_CXXCPP' (depending on
  890.      which language is current, *note Language Choice::.), if it hasn't
  891.      been called already.
  892. File: autoconf.info,  Node: Examining Syntax,  Next: Examining Libraries,  Prev: Examining Declarations,  Up: Writing Tests
  893. Examining Syntax
  894. ================
  895.    To check for a syntax feature of the C or C++ compiler, such as
  896. whether it recognizes a certain keyword, use `AC_TRY_COMPILE' to try to
  897. compile a small program that uses that feature.  You can also use it to
  898. check for structures and structure members that are not present on all
  899. systems.
  900.  - Macro: AC_TRY_COMPILE (INCLUDES, FUNCTION-BODY, ACTION-IF-FOUND [,
  901.           ACTION-IF-NOT-FOUND])
  902.      Create a test C program to see whether a function whose body
  903.      consists of FUNCTION-BODY can be compiled; INCLUDES is any
  904.      `#include' statements needed by the code in FUNCTION-BODY.  If the
  905.      file compiles successfully, run shell commands ACTION-IF-FOUND,
  906.      otherwise run ACTION-IF-NOT-FOUND.  This macro uses `CFLAGS' or
  907.      `CXXFLAGS', and `CPPFLAGS', when compiling.  It does not try to
  908.      link; use `AC_TRY_LINK' if you need to do that (*note Examining
  909.      Libraries::.).
  910. File: autoconf.info,  Node: Examining Libraries,  Next: Run Time,  Prev: Examining Syntax,  Up: Writing Tests
  911. Examining Libraries
  912. ===================
  913.    To check for a library, a function, or a global variable, Autoconf
  914. `configure' scripts try to compile and link a small program that uses
  915. it.  This is unlike Metaconfig, which by default uses `nm' or `ar' on
  916. the C library to try to figure out which functions are available.
  917. Trying to link with the function is usually a more reliable approach
  918. because it avoids dealing with the variations in the options and output
  919. formats of `nm' and `ar' and in the location of the standard libraries.
  920. It also allows configuring for cross-compilation or checking a
  921. function's runtime behavior if needed.  On the other hand, it can be
  922. slower than scanning the libraries once.
  923.    A few systems have linkers that do not return a failure exit status
  924. when there are unresolved functions in the link.  This bug makes the
  925. configuration scripts produced by Autoconf unusable on those systems.
  926. However, some of them can be given options that make the exit status
  927. correct.  This is a problem that Autoconf does not currently handle
  928. automatically.
  929.    `AC_TRY_LINK' is used to compile test programs to test for functions
  930. and global variables.  It is also used (by `AC_CHECK_LIB') to check for
  931. libraries, by adding the library being checked for to `LIBS'
  932. temporarily and trying to link a small program.
  933.  - Macro: AC_TRY_LINK (INCLUDES, FUNCTION-BODY, ACTION-IF-FOUND [,
  934.           ACTION-IF-NOT-FOUND])
  935.      Create a test C program to see whether a function whose body
  936.      consists of FUNCTION-BODY can be compiled and linked; INCLUDES is
  937.      any `#include' statements needed by the code in FUNCTION-BODY.  If
  938.      the file compiles and links successfully, run shell commands
  939.      ACTION-IF-FOUND, otherwise run ACTION-IF-NOT-FOUND.  This macro
  940.      uses `CFLAGS' or `CXXFLAGS', `CPPFLAGS', `LDFLAGS', and `LIBS'
  941.      when compiling.
  942.  - Macro: AC_COMPILE_CHECK (ECHO-TEXT, INCLUDES, FUNCTION-BODY,
  943.           ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND])
  944.      This is an obsolete version of `AC_TRY_LINK', with the addition
  945.      that it prints `checking for ECHO-TEXT' to the standard output
  946.      first, if ECHO-TEXT is non-empty.  Use `AC_MSG_CHECKING' and
  947.      `AC_MSG_RESULT' instead to print messages (*note Printing
  948.      Messages::.).
  949.