home *** CD-ROM | disk | FTP | other *** search
/ PC-Online 1996 May / PCOnline_05_1996.bin / linux / source / extra-st / gnu / autoconf.8 / autoconf / autoconf-1.8 / autoconf.info < prev    next >
Encoding:
GNU Info File  |  1994-04-15  |  120.6 KB  |  2,883 lines
  1. This is Info file autoconf.info, produced by Makeinfo-1.55 from the
  2. input file ./autoconf.texi.
  3.  
  4. START-INFO-DIR-ENTRY
  5. * autoconf: (autoconf).    The Autoconf configuration system.
  6. END-INFO-DIR-ENTRY
  7.  
  8.    This file documents the GNU Autoconf package for creating scripts to
  9. configure source code packages using templates and an `m4' macro
  10. package.
  11.  
  12.    Copyright (C) 1992, 1993, 1994 Free Software Foundation, Inc.
  13.  
  14.    Permission is granted to make and distribute verbatim copies of this
  15. manual provided the copyright notice and this permission notice are
  16. preserved on all copies.
  17.  
  18.    Permission is granted to copy and distribute modified versions of
  19. this manual under the conditions for verbatim copying, provided that
  20. the entire resulting derived work is distributed under the terms of a
  21. permission notice identical to this one.
  22.  
  23.    Permission is granted to copy and distribute translations of this
  24. manual into another language, under the above conditions for modified
  25. versions, except that this permission notice may be stated in a
  26. translation approved by the Foundation.
  27.  
  28. 
  29. File: autoconf.info,  Node: Top,  Next: Introduction,  Up: (dir)
  30.  
  31.    This file documents the GNU Autoconf package for creating scripts to
  32. configure source code packages using templates and an `m4' macro
  33. package.  This is edition 1.8, for Autoconf version 1.8.
  34.  
  35. * Menu:
  36.  
  37. * Introduction::        Autoconf's purpose, strengths, and weaknesses.
  38. * Distributing::        Legal restrictions on Autoconf output.
  39. * Making configure Scripts::    How to organize and produce Autoconf scripts.
  40. * Specific Tests::        Macros that check for particular features.
  41. * General Purpose Macros::    Macros that check for kinds of features.
  42. * Writing Macros::        How to add your own macros to Autoconf.
  43. * Makefiles::            Information Autoconf uses in `Makefile's.
  44. * Invoking configure::      How to use the Autoconf output.
  45. * Example::            Sample Autoconf input files.
  46. * Preprocessor Symbol Index::    Index of C preprocessor symbols defined.
  47. * Macro Index::            Index of Autoconf macros.
  48.  
  49.  -- The Detailed Node Listing --
  50.  
  51. Making `configure' Scripts
  52.  
  53. * Writing configure.in::    What to put in an Autoconf input file.
  54. * Invoking autoconf::        How to create configuration scripts.
  55. * Invoking autoheader::        How to create configuration header files.
  56.  
  57. Specific Tests
  58.  
  59. * Alternative Programs::    Selecting between alternative programs.
  60. * Header Files::        Header files that might be missing.
  61. * Typedefs::            `typedef's that might be missing.
  62. * Library Functions::        C library functions that might be missing.
  63. * Structures::            Structures or members that might be missing.
  64. * Compiler Characteristics::    C compiler or machine architecture features.
  65. * System Services::        Operating system services.
  66. * UNIX Variants::        Special cases for specific UNIX variants.
  67.  
  68. General Purpose Macros
  69.  
  70. * Setup::            Controlling Autoconf operation.
  71. * General Feature Tests::    Checking for kinds of features.
  72. * Command Line::                Checking command line arguments.
  73. * Setting Variables::        Setting shell and `make' variables.
  74. * Printing Messages::           Notifying users of progress or problems.
  75. * Language Choice::             Selecting which language to use for testing.
  76. * Macro Ordering::        Enforcing ordering constraints.
  77.  
  78. Writing Macros
  79.  
  80. * Macro Format::        Basic format of an Autoconf macro.
  81. * Quoting::            Protecting macros from unwanted expansion.
  82. * Dependencies Between Macros::    What to do when macros depend on other macros.
  83. * Checking for Files::        Finding whether a file exists.
  84. * Checking for Symbols::    Finding whether a symbol is defined.
  85. * Test Programs::        Writing programs to test for features.
  86. * Multiple Cases::        Tests for several possible values.
  87.  
  88. Dependencies Between Macros
  89.  
  90. * Prerequisite Macros::        Ensuring required information.
  91. * Suggested Ordering::        Warning about possible ordering problems.
  92.  
  93. Test Programs
  94.  
  95. * Guidelines::            General rules for writing test programs.
  96. * Tricks::            Special ways to work around problems.
  97.  
  98. Makefiles
  99.  
  100. * Predefined Variables::    Heavily used `make' variables.
  101. * Installation Prefixes::    A special variable substitution.
  102. * VPATH Substitutions::        Compiling in a different directory.
  103. * Automatic Remaking::        Makefile rules for configuring.
  104.  
  105. Running `configure' Scripts
  106.  
  107. * Overriding variables::        Workarounds for unusual systems.
  108. * Invoking config.status::      Recreating a configuration.
  109.  
  110. An Example
  111.  
  112. * Sample configure.in::        An example of a `configure' template.
  113. * Sample Makefile.in::        An example of a `Makefile' template.
  114.  
  115. 
  116. File: autoconf.info,  Node: Introduction,  Next: Distributing,  Prev: Top,  Up: Top
  117.  
  118. Introduction
  119. ************
  120.  
  121.    Autoconf is a tool for producing shell scripts that automatically
  122. configure software source code packages to adapt to many kinds of
  123. UNIX-like systems.  The configuration scripts produced by Autoconf are
  124. independent of Autoconf when they are run, so their users do not need to
  125. have Autoconf.
  126.  
  127.    The configuration scripts produced by Autoconf normally require no
  128. manual user intervention when run; they do not even take an argument
  129. specifying the system type.  Instead, they test for the presence of each
  130. feature that the software package they are for might need individually.
  131. (Before each check, they print a one-line message stating what they are
  132. checking for, so the user doesn't get too bored while waiting for the
  133. script to finish.)  As a result, they deal well with systems that are
  134. hybrids or customized from the more common UNIX variants.  There is no
  135. need to maintain files that list the features supported by each release
  136. of each variant of UNIX.
  137.  
  138.    For each software package that Autoconf is used with, it creates a
  139. configuration script from a template file that lists the operating
  140. system features that the package can use.  After the shell code to
  141. recognize and respond to an operating system feature has been written,
  142. Autoconf allows it to be shared by many software packages that can use
  143. (or need) that feature.  If it later turns out that the shell code
  144. needs adjustment for some reason, it needs to be changed in only one
  145. place; all of the the configuration scripts can be regenerated
  146. automatically to take advantage of the updated code.
  147.  
  148.    Larry Wall's Metaconfig package is similar in purpose to Autoconf,
  149. but is more general.  The scripts it produces require manual user
  150. intervention, which is quite inconvenient when configuring large source
  151. trees.
  152.  
  153.    Unlike Metaconfig scripts, Autoconf scripts can support
  154. cross-compiling, if some care is taken in writing them.  They should
  155. avoid executing test programs, since test programs compiled with a
  156. cross-compiler can not be executed on the host system.  Also, they
  157. shouldn't do anything that tests features of the host system instead of
  158. the target system.
  159.  
  160.    Autoconf imposes some restrictions on the names of macros used with
  161. `#ifdef' in C programs (*note Preprocessor Symbol Index::.).
  162.  
  163.    Autoconf requires GNU `m4' in order to generate the scripts.  It
  164. uses features that some UNIX versions of `m4' do not have; it is also
  165. reported to overflow internal limits of some versions of `m4'.
  166.  
  167.    Autoconf does not work well with GNU C library releases before 1.06.
  168. The GNU C library contains stubs (which always return an error) for
  169. functions that are not available instead of omitting them from the
  170. library.  As a result, Autoconf scripts are fooled into thinking that
  171. those functions are available.  This problem does not exist with
  172. releases 1.06 and later of the GNU C library, which define C
  173. preprocessor macros that the Autoconf macros `AC_FUNC_CHECK' and
  174. `AC_REPLACE_FUNCS' test, indicating that certain functions are stubs
  175. (*note General Feature Tests::., for more information on checking for
  176. functions).
  177.  
  178.    Autoconf was written by David MacKenzie, with help from Franc,ois
  179. Pinard, Karl Berry, Richard Pixley, Ian Lance Taylor, Roland McGrath,
  180. Noah Friedman, and david d zuhn.  It was inspired by Brian Fox's
  181. automatic configuration system for Bash, by Larry Wall's Metaconfig, and
  182. by Richard Stallman, Richard Pixley, and John Gilmore's configuration
  183. tools for the GNU compiler and object file utilities.
  184.  
  185.    Mail suggestions and bug reports for Autoconf to
  186. `bug-gnu-utils@prep.ai.mit.edu'.  Please include the Autoconf version
  187. number, which you can get by running `autoconf --version'.
  188.  
  189. 
  190. File: autoconf.info,  Node: Distributing,  Next: Making configure Scripts,  Prev: Introduction,  Up: Top
  191.  
  192. Distributing Autoconf Output
  193. ****************************
  194.  
  195.    The configuration scripts that Autoconf produces are covered by the
  196. GNU General Public License.  This is because they consist almost
  197. entirely of parts of Autoconf itself, rearranged somewhat, and Autoconf
  198. is distributed under the terms of the GPL.  As applied to Autoconf, the
  199. GPL just means that you need to distribute `configure.in', and
  200. `aclocal.m4', `acconfig.h', and `CONFIG.h.top' if you use them, along
  201. with `configure'.
  202.  
  203.    Programs that use Autoconf scripts to configure themselves do not
  204. automatically come under the GPL.  Distributing an Autoconf
  205. configuration script as part of a program is considered to be *mere
  206. aggregation* of that work with the Autoconf script.  Such programs are
  207. not derivative works based on Autoconf; only their configuration scripts
  208. are.  We still encourage software authors to distribute their work under
  209. terms like those of the GPL, but doing so is not required to use
  210. Autoconf.
  211.  
  212. 
  213. File: autoconf.info,  Node: Making configure Scripts,  Next: Specific Tests,  Prev: Distributing,  Up: Top
  214.  
  215. Making `configure' Scripts
  216. **************************
  217.  
  218.    The configuration scripts that Autoconf produces are by convention
  219. called `configure'.  When run, `configure' creates several files,
  220. replacing configuration parameters in them with values appropriate for
  221. the system being configured.  The files that `configure' creates are:
  222.  
  223.    * one or more `Makefile' files (one in each subdirectory of the
  224.      package), from template `Makefile.in' files (*note Makefiles::.);
  225.  
  226.    * optionally, a C header file, the name of which is configurable,
  227.      containing `#define' statements (*note Setup::.);
  228.  
  229.    * a shell script called `config.status' that, when run, will recreate
  230.      the files listed above (*note Invoking config.status::.).
  231.  
  232.    To create a `configure' script with Autoconf, you need to write an
  233. Autoconf input file and run Autoconf on it to produce the script.  And,
  234. of course, test the resulting script.
  235.  
  236.    Here is a diagram showing how the files that can be used in
  237. configuration are produced:
  238.  
  239.      aclocal.m4  \
  240.      acgeneral.m4 \                          Makefile.in \
  241.      acspecific.m4 \                                      \
  242.      autoconf*     -> m4* -> configure* -> config.status* -> Makefile \
  243.      configure.in  /                          |    |                   \
  244.        |    |                                 |    |             make* -> your
  245.        |    |                                 |    |                   /package
  246.        |    |                              config.status* -> config.h /
  247.      configure.in \                                       /
  248.      acspecific.m4 \                                    /
  249.      acgeneral.m4   \                                 /
  250.      aclocal.m4      \                              /
  251.      autoheader*     -> m4* - - - --> config.h.in /
  252.      acconfig.h      /
  253.      config.h.top   /
  254.  
  255. Executables are suffixed by `*'.  Files appearing twice are linked with
  256. lines of `|'.
  257.  
  258. * Menu:
  259.  
  260. * Writing configure.in::    What to put in an Autoconf input file.
  261. * Invoking autoconf::        How to create configuration scripts.
  262. * Invoking autoheader::        How to create configuration header files.
  263.  
  264. 
  265. File: autoconf.info,  Node: Writing configure.in,  Next: Invoking autoconf,  Up: Making configure Scripts
  266.  
  267. Writing `configure.in'
  268. ======================
  269.  
  270.    To produce a `configure' script for a software package, create a
  271. file called `configure.in' that contains invocations of the Autoconf
  272. macros that test the system features your package needs or can use.
  273. Autoconf macros already exist to check for many features; see *Note
  274. Specific Tests::, for their descriptions.  For most other features, you
  275. can use Autoconf template macros to produce custom checks; see *Note
  276. General Feature Tests::, for information about them.  For especially
  277. tricky or specialized features, `configure.in' might need to contain
  278. some hand-crafted shell commands.  *Note Writing Macros::, for
  279. guidelines on writing tests from scratch.
  280.  
  281.    Every `configure.in' must begin with a call to `AC_INIT' and end
  282. with a call to `AC_OUTPUT' (*note Setup::.).  Other than that, the
  283. order in which `configure.in' calls the Autoconf macros is generally
  284. not important, except that some macros rely on other macros having been
  285. called first, because they check previously set values of some
  286. variables to decide what to do.  These macros are noted in the
  287. individual descriptions (*note Specific Tests::.).
  288.  
  289.    To encourage consistency, here is a suggested order for calling the
  290. Autoconf macros.  A few macros need to be called in a different order
  291. from the one given here; they are noted in their individual descriptions
  292. (*note Specific Tests::.).  Note that there must not be any space
  293. between the macro name and the open parentheses.
  294.  
  295.      `AC_INIT(FILE)'
  296.      checks for alternative programs
  297.      checks for UNIX variants that set C preprocessor variables
  298.      checks for header files
  299.      checks for typedefs
  300.      checks for library functions
  301.      checks for structures
  302.      checks for compiler characteristics
  303.      checks for system services
  304.      other checks for UNIX variants
  305.      `AC_OUTPUT([FILE...])'
  306.  
  307.    You can include comments in `configure.in' files by starting them
  308. with the `m4' predefined macro `dnl', which discards text up through
  309. the next newline.  These comments do not appear in the generated
  310. `configure' scripts.  For example, it is helpful to begin
  311. `configure.in' files with a line like this:
  312.  
  313.      dnl Process this file with autoconf to produce a configure script.
  314.  
  315.    *Note Sample configure.in::, for an example of a real `configure.in'
  316. script.
  317.  
  318. 
  319. File: autoconf.info,  Node: Invoking autoconf,  Next: Invoking autoheader,  Prev: Writing configure.in,  Up: Making configure Scripts
  320.  
  321. Invoking `autoconf'
  322. ===================
  323.  
  324.    To create `configure' from `configure.in', run the `autoconf'
  325. program with no arguments.  `autoconf' processes `configure.in' with
  326. the `m4' macro processor, using the Autoconf macros.  If you give
  327. `autoconf' an argument, it reads that file instead of `configure.in'
  328. and writes the configuration script to the standard output instead of
  329. to `configure'.  If you give `autoconf' the argument `-', it reads the
  330. standard input instead of `configure.in' and writes the configuration
  331. script on the standard output.
  332.  
  333.    The Autoconf macros are defined in two or more files.  Two of the
  334. files are distributed with Autoconf: `autoconf' first reads
  335. `acgeneral.m4' (*note General Purpose Macros::.), then `acspecific.m4'
  336. (*note Specific Tests::.).  After reading them, `autoconf' looks for an
  337. optional file called `aclocal.m4', first in the directory that contains
  338. other installed Autoconf macro files, and then in the current
  339. directory.  If both files exist, it uses both of them.  Those files can
  340. contain your site's own locally written Autoconf macro definitions
  341. (*note Writing Macros::., for more information).  If a macro is defined
  342. in more than one of the files that `autoconf' reads, the last
  343. definition it reads overrides the earlier ones.
  344.  
  345.    You can override the directory where `autoconf' looks for the
  346. installed macro files by setting the `AC_MACRODIR' environment variable
  347. to a different directory.  You can also give `autoconf' the
  348. `--macrodir' option, which overrides `AC_MACRODIR'.
  349.  
  350.    `autoconf' also accepts the options `--version', which prints the
  351. Autoconf version number and exits, and `--help', which prints a summary
  352. of the command-line options and exits.
  353.  
  354. 
  355. File: autoconf.info,  Node: Invoking autoheader,  Prev: Invoking autoconf,  Up: Making configure Scripts
  356.  
  357. Invoking `autoheader'
  358. =====================
  359.  
  360.    You can use the `autoheader' program to create a template file of C
  361. `#define' statements for `configure' to use.  By default, the file that
  362. `autoheader' creates is called `config.h.in'; if `configure.in' invokes
  363. `AC_CONFIG_HEADER(FILE)', `autoheader' creates `FILE.in'.
  364.  
  365.    `autoheader' scans `configure.in' and figures out which C
  366. preprocessor symbols it might define.  It copies comments and `#define'
  367. and `#undef' statements from a file called `acconfig.h', which comes
  368. with and is installed with Autoconf.  It also uses a file called
  369. `acconfig.h' in the current directory, if present; you must create that
  370. file to contain entries for any additional symbols that you
  371. `AC_DEFINE'.  For symbols defined by `AC_HAVE_HEADERS',
  372. `AC_HAVE_FUNCS', or `AC_HAVE_LIBRARY', `autoheader' generates comments
  373. and `#undef' statements itself rather than copying them from a file,
  374. since the possible symbols are effectively limitless.
  375.  
  376.    The file that `autoheader' creates usually contains only `#define'
  377. and `#undef' statements and their accompanying comments.  However, if a
  378. file called `FILE.top' (typically `config.h.top') exists in the current
  379. directory, `autoheader' copies that file to the beginning of its output.
  380.  
  381.    If you give `autoheader' an argument, it uses that file instead of
  382. `configure.in' and writes the header file to the standard output
  383. instead of to `config.h.in'.  If you give `autoheader' an argument of
  384. `-', it reads the standard input instead of `configure.in' and writes
  385. the header file to the standard output.
  386.  
  387.    You can override the directory where `autoheader' looks for the
  388. installed macro and `acconfig.h' files by setting the `AC_MACRODIR'
  389. environment variable to a different directory.  You can also give
  390. `autoheader' the `--macrodir' option, which overrides `AC_MACRODIR'.
  391.  
  392.    `autoheader' also accepts the options `--version', which prints the
  393. Autoconf version number and exits, and `--help', which prints a summary
  394. of the command-line options and exits.
  395.  
  396. 
  397. File: autoconf.info,  Node: Specific Tests,  Next: General Purpose Macros,  Prev: Making configure Scripts,  Up: Top
  398.  
  399. Specific Tests
  400. **************
  401.  
  402.    These macros test for particular operating system features that
  403. packages might need or want to use.  If you need to test for a feature
  404. that none of these macros check for, you can probably do it by calling
  405. one of the general purpose test macros with appropriate arguments
  406. (*note General Feature Tests::.).
  407.  
  408.    All of these macros that set `make' variables call `AC_SUBST' on
  409. those variables (*note Setting Variables::., for details about
  410. `AC_SUBST').  The phrase "define NAME" is used below as a shorthand to
  411. mean either add `-DNAME=1' to the `make' variable `DEFS', or put
  412. `#define NAME 1' in the configuration header file, depending on whether
  413. `AC_CONFIG_HEADER' has been called.  *Note Setting Variables::, for
  414. more information.
  415.  
  416.    Within each section below, the macros are listed in alphabetical
  417. order.  The macros are generally named for the `make' variables or C
  418. preprocessor macros that they define; those names are based largely on
  419. what existing GNU programs use.  These macros are defined in the file
  420. `acspecific.m4'.
  421.  
  422. * Menu:
  423.  
  424. * Alternative Programs::    Selecting between alternative programs.
  425. * Header Files::        Header files that might be missing.
  426. * Typedefs::            `typedef's that might be missing.
  427. * Library Functions::        C library functions that might be missing.
  428. * Structures::            Structures or members that might be missing.
  429. * Compiler Characteristics::    C compiler or machine architecture features.
  430. * System Services::        Operating system services.
  431. * UNIX Variants::        Special cases for specific UNIX variants.
  432.  
  433. 
  434. File: autoconf.info,  Node: Alternative Programs,  Next: Header Files,  Up: Specific Tests
  435.  
  436. Alternative Programs
  437. ====================
  438.  
  439.    The following macros check for the presence or behavior of particular
  440. programs:
  441.  
  442.  - Macro: AC_GCC_TRADITIONAL
  443.      Add `-traditional' to `make' variable `CC' if using the GNU C
  444.      compiler and `ioctl' does not work properly without
  445.      `-traditional'.  This macro calls `AC_PROG_CC' and `AC_PROG_CPP'
  446.      if they haven't been called already.
  447.  
  448.  - Macro: AC_LN_S
  449.      If `ln -s' works on the current filesystem (the O.S. and filesystem
  450.      support symbolic links), set shell and `make' variable `LN_S' to
  451.      `ln -s', otherwise set it to `ln'.
  452.  
  453.  - Macro: AC_MINUS_C_MINUS_O
  454.      If the C compiler does not accept the `-c' and `-o' options
  455.      simultaneously, define `NO_MINUS_C_MINUS_O'.
  456.  
  457.  - Macro: AC_PROG_AWK
  458.      Check for `mawk', `gawk', `nawk', and `awk', in that order, and
  459.      set `make' variable `AWK' to the first one that it finds.
  460.  
  461.  - Macro: AC_PROG_CC
  462.      If `gcc' is found, set `make' variable `CC' to `gcc', and set
  463.      shell variable `GCC' to 1 for use by macros such as
  464.      `AC_GCC_TRADITIONAL'.
  465.  
  466.  - Macro: AC_PROG_CPP
  467.      Set shell and `make' variable `CPP' to a command that runs the C
  468.      preprocessor.  If `$CC -E' doesn't work, it uses `/lib/cpp'.
  469.  
  470.      If the current language is C (*note Language Choice::.), many of
  471.      the specific test macros use the value of `CPP' indirectly by
  472.      calling `AC_TEST_CPP', `AC_HEADER_CHECK', `AC_HEADER_EGREP', or
  473.      `AC_PROGRAM_EGREP'.  Those macros call this macro first if it
  474.      hasn't been called already.  It calls `AC_PROG_CC' if it hasn't
  475.      been called already.
  476.  
  477.  - Macro: AC_PROG_CXX
  478.      Determine a C++ compiler to use.  Check if the environment variable
  479.      CXX or CCC (in that order) is set; if so, set `make' variable
  480.      `CXX' to its value.  Otherwise search for a C++ compiler under
  481.      likely names (`c++', `g++', `gcc', and `CC').  If none of those
  482.      checks succeed, as a last resort set `CXX' to `gcc'.
  483.  
  484.  - Macro: AC_PROG_CXXCPP
  485.      Set shell and `make' variable `CXXCPP' to a command that runs the
  486.      C++ preprocessor.  If `$CXX -E' doesn't work, it uses `/lib/cpp'.
  487.  
  488.      If the current language is C++ (*note Language Choice::.), many of
  489.      the specific test macros use the value of `CXXCPP' indirectly by
  490.      calling `AC_TEST_CPP', `AC_HEADER_CHECK', `AC_HEADER_EGREP', or
  491.      `AC_PROGRAM_EGREP'.  Those macros call this macro first if it
  492.      hasn't been called already.  It macro calls `AC_PROG_CXX' if it
  493.      hasn't been called already.
  494.  
  495.  - Macro: AC_PROG_INSTALL
  496.      Set `make' variable `INSTALL' to `install -c' if `install' is
  497.      found and is compatible with the BSD and GNU versions.  Otherwise,
  498.      set `INSTALL' to `@top_srcdir@/install.sh -c' if that script
  499.      exists, or to `cp' as a last resort.  Screens out the false
  500.      matches `/etc/install', `/usr/sbin/install', and other instances
  501.      of `install' known not to work.  Also sets the variable
  502.      `INSTALL_PROGRAM' to `${INSTALL}' and `INSTALL_DATA' to
  503.      `${INSTALL} -m 644'.
  504.  
  505.      If you need to use your own `install.sh' because it has features
  506.      not found in standard `install' programs, there is no reason to use
  507.      `AC_PROG_INSTALL'; just put the pathname of your script into your
  508.      `Makefile.in' files.
  509.  
  510.  - Macro: AC_PROG_LEX
  511.      If `flex' is found, set `make' variable `LEX' to `flex' and
  512.      `LEXLIB' to `-lfl', if that library is in a standard place.
  513.      Otherwise set `LEX' to `lex' and `LEXLIB' to `-ll'.
  514.  
  515.  - Macro: AC_PROG_RANLIB
  516.      Set `make' variable `RANLIB' to `ranlib' if `ranlib' is found,
  517.      otherwise to `:' (do nothing).
  518.  
  519.  - Macro: AC_PROG_YACC
  520.      If `bison' is found, set `make' variable `YACC' to `bison -y'.
  521.      Otherwise, if `byacc' is found, set `YACC' to `byacc'.  Otherwise
  522.      set `YACC' to `yacc'.
  523.  
  524.  - Macro: AC_RSH
  525.      If a remote shell is available, put `rtapelib.o' in `make'
  526.      variable `RTAPELIB'.  Otherwise, also do so if `netdb.h' exists
  527.      (implying the `rexec' function), and in addition define
  528.      `HAVE_NETDB_H'.  If neither a remote shell nor `rexec' is
  529.      available, define `NO_REMOTE'.
  530.  
  531.  - Macro: AC_SET_MAKE
  532.      If `make' predefines the variable `MAKE', define `make' variable
  533.      `SET_MAKE' to be empty.  Otherwise, define `SET_MAKE' to contain
  534.      `MAKE=make'.  Calls `AC_SUBST' for `SET_MAKE'.
  535.  
  536.      In recent versions of `make', the variable `MAKE' contains the
  537.      name of the `make' program plus options it was given.  It is used
  538.      when running `make' recursively in subdirectories.  But some old
  539.      versions of `make' don't set the `MAKE' variable.  This macro
  540.      allows use of `MAKE' on all systems.
  541.  
  542.      If you use this macro, simply place a line like this in your
  543.      `Makefile.in' file(s):
  544.  
  545.           @SET_MAKE@
  546.  
  547. 
  548. File: autoconf.info,  Node: Header Files,  Next: Typedefs,  Prev: Alternative Programs,  Up: Specific Tests
  549.  
  550. Header Files
  551. ============
  552.  
  553.    The following macros check for the presence of certain C header
  554. files:
  555.  
  556.  - Macro: AC_DIR_HEADER
  557.      If the system has `dirent.h', define `DIRENT'; otherwise, if it
  558.      has `sys/ndir.h', define `SYSNDIR'; otherwise, if it has
  559.      `sys/dir.h', define `SYSDIR'; otherwise, if it has `ndir.h',
  560.      define `NDIR'.  Also, if the directory library header file
  561.      contains a declaration of the `closedir' function with a `void'
  562.      return type, define `VOID_CLOSEDIR'.
  563.  
  564.      The directory library declarations in the source code should look
  565.      something like the following, which assumes that you have also
  566.      called `AC_HAVE_HEADERS(unistd.h)':
  567.  
  568.           #ifdef HAVE_UNISTD_H
  569.           #include <sys/types.h>
  570.           #include <unistd.h>
  571.           #endif
  572.           
  573.           /* unistd.h defines _POSIX_VERSION on POSIX.1 systems.  */
  574.           #if defined(DIRENT) || defined(_POSIX_VERSION)
  575.           #include <dirent.h>
  576.           #define NLENGTH(dirent) (strlen((dirent)->d_name))
  577.           #else /* not (DIRENT or _POSIX_VERSION) */
  578.           #define dirent direct
  579.           #define NLENGTH(dirent) ((dirent)->d_namlen)
  580.           #ifdef SYSNDIR
  581.           #include <sys/ndir.h>
  582.           #endif /* SYSNDIR */
  583.           #ifdef SYSDIR
  584.           #include <sys/dir.h>
  585.           #endif /* SYSDIR */
  586.           #ifdef NDIR
  587.           #include <ndir.h>
  588.           #endif /* NDIR */
  589.           #endif /* not (DIRENT or _POSIX_VERSION) */
  590.  
  591.      Using the above declarations, the program would declare variables
  592.      to be type `struct dirent', not `struct direct', and would access
  593.      the length of a directory entry name by passing a pointer to a
  594.      `struct dirent' to the `NLENGTH' macro.
  595.  
  596.  - Macro: AC_MAJOR_HEADER
  597.      If `sys/types.h' does not define `major', `minor', and `makedev',
  598.      but `sys/mkdev.h' does, define `MAJOR_IN_MKDEV'; otherwise, if
  599.      `sys/sysmacros.h' does, define `MAJOR_IN_SYSMACROS'.
  600.  
  601.  - Macro: AC_MEMORY_H
  602.      Define `NEED_MEMORY_H' if `memcpy', `memcmp', etc. are not
  603.      declared in `string.h' and `memory.h' exists.  This macro is
  604.      obsolete; instead, use `AC_HAVE_HEADERS(memory.h)'.  See the
  605.      example for `AC_STDC_HEADERS'.
  606.  
  607.  - Macro: AC_STDC_HEADERS
  608.      Define `STDC_HEADERS' if the system has ANSI C header files.
  609.      Specifically, this macro checks for `stdlib.h', `stdarg.h',
  610.      `string.h', and `float.h'; if the system has those, it probably
  611.      has the rest of the ANSI C header files.  This macro also checks
  612.      whether `string.h' declares `memchr' (and thus presumably the
  613.      other `mem' functions), whether `stdlib.h' declare `free' (and
  614.      thus presumably `malloc' and other related functions), and whether
  615.      the `ctype.h' macros work on characters with the high bit set, as
  616.      ANSI C requires.
  617.  
  618.      Use `STDC_HEADERS' instead of `__STDC__' to determine whether the
  619.      system has ANSI-compliant header files (and probably C library
  620.      functions) because many systems that have GCC do not have ANSI C
  621.      header files.
  622.  
  623.      To check whether to use the System V/ANSI C string functions and
  624.      header file, you can put the following in `configure.in':
  625.  
  626.           AC_STDC_HEADERS
  627.           AC_HAVE_HEADERS(string.h memory.h)
  628.  
  629.      Then, in the code, use a test like this:
  630.  
  631.           #if STDC_HEADERS || HAVE_STRING_H
  632.           #include <string.h>
  633.           /* An ANSI string.h and pre-ANSI memory.h might conflict.  */
  634.           #if !STDC_HEADERS && HAVE_MEMORY_H
  635.           #include <memory.h>
  636.           #endif /* not STDC_HEADERS and HAVE_MEMORY_H */
  637.           #define index strchr
  638.           #define rindex strrchr
  639.           #define bcopy(s, d, n) memcpy ((d), (s), (n))
  640.           #define bcmp(s1, s2, n) memcmp ((s1), (s2), (n))
  641.           #define bzero(s, n) memset ((s), 0, (n))
  642.           #else /* not STDC_HEADERS and not HAVE_STRING_H */
  643.           #include <strings.h>
  644.           /* memory.h and strings.h conflict on some systems.  */
  645.           #endif /* not STDC_HEADERS and not HAVE_STRING_H */
  646.  
  647.      This example asssumes that your code uses the BSD style functions.
  648.      If you use the System V/ANSI C style functions, you will need to
  649.      replace the macro definitions with ones that go in the other
  650.      direction.
  651.  
  652.      This macro calls `AC_PROG_CPP' or `AC_PROG_CXXCPP' (depending on
  653.      which language is current, *note Language Choice::.), if it hasn't
  654.      been called already.
  655.  
  656.  - Macro: AC_UNISTD_H
  657.      Define `HAVE_UNISTD_H' if the system has `unistd.h'.  This macro
  658.      is obsolete; instead, use `AC_HAVE_HEADERS(unistd.h)'.
  659.  
  660.      The way to check if the system supports POSIX.1 is:
  661.  
  662.           #if HAVE_UNISTD_H
  663.           #include <sys/types.h>
  664.           #include <unistd.h>
  665.           #endif
  666.           
  667.           #ifdef _POSIX_VERSION
  668.           /* Code for POSIX.1 systems.  */
  669.           #endif
  670.  
  671.      `_POSIX_VERSION' is defined when `unistd.h' is included on POSIX.1
  672.      systems.  If there is no `unistd.h', it is definitely not a
  673.      POSIX.1 system.  However, some non-POSIX.1 systems do have
  674.      `unistd.h'.
  675.  
  676.  - Macro: AC_USG
  677.      Define `USG' if the system does not have `strings.h', `rindex',
  678.      `bzero', etc.  This implies that it has `string.h', `strrchr',
  679.      `memset', etc.
  680.  
  681.      The symbol `USG' is obsolete.  Instead of this macro, use
  682.      `AC_HAVE_HEADERS(string.h)' and use `HAVE_STRING_H' in your code.
  683.      See the example for `AC_STDC_HEADERS'.
  684.  
  685.  - Macro: AC_SYS_SIGLIST_DECLARED
  686.      Define `SYS_SIGLIST_DECLARED' if the variable `sys_siglist' is
  687.      declared in a system header file, either `signal.h' or `unistd.h'.
  688.  
  689. 
  690. File: autoconf.info,  Node: Typedefs,  Next: Library Functions,  Prev: Header Files,  Up: Specific Tests
  691.  
  692. Typedefs
  693. ========
  694.  
  695.    The following macros check for predefined C types:
  696.  
  697.  - Macro: AC_GETGROUPS_T
  698.      Define `GETGROUPS_T' to be whichever of `gid_t' or `int' is the
  699.      base type of the array argument to `getgroups'.
  700.  
  701.  - Macro: AC_MODE_T
  702.      If `mode_t' is not defined in `sys/types.h', define `mode_t' to be
  703.      `int'.
  704.  
  705.  - Macro: AC_OFF_T
  706.      If `off_t' is not defined in `sys/types.h', define `off_t' to be
  707.      `long'.
  708.  
  709.  - Macro: AC_PID_T
  710.      If `pid_t' is not defined in `sys/types.h', define `pid_t' to be
  711.      `int'.
  712.  
  713.  - Macro: AC_RETSIGTYPE
  714.      If `signal.h' declares `signal' as returning a pointer to a
  715.      function returning `void', define `RETSIGTYPE' to be `void';
  716.      otherwise, define it to be `int'.
  717.  
  718.      Define signal handlers as returning type `RETSIGTYPE':
  719.  
  720.           RETSIGTYPE
  721.           hup_handler ()
  722.           {
  723.           ...
  724.           }
  725.  
  726.  - Macro: AC_SIZE_T
  727.      If `size_t' is not defined in `sys/types.h', define `size_t' to be
  728.      `unsigned'.
  729.  
  730.  - Macro: AC_UID_T
  731.      If `uid_t' is not defined in `sys/types.h', define `uid_t' to be
  732.      `int' and `gid_t' to be `int'.
  733.  
  734. 
  735. File: autoconf.info,  Node: Library Functions,  Next: Structures,  Prev: Typedefs,  Up: Specific Tests
  736.  
  737. Library Functions
  738. =================
  739.  
  740.    The following macros check for particular C library functions:
  741.  
  742.  - Macro: AC_ALLOCA
  743.      Check how to get `alloca'.  Tries to get a builtin version by
  744.      checking for `alloca.h' or the predefined C preprocessor macros
  745.      `__GNUC__' and `_AIX'.  If that fails, it looks for a function in
  746.      the standard C library.  If that fails, it sets the `make'
  747.      variable `ALLOCA' to `alloca.o' and defines `C_ALLOCA' (so
  748.      programs can periodically call `alloca(0)' to garbage collect).
  749.      This variable is separate from `LIBOBJS' so multiple programs can
  750.      share the value of `ALLOCA' without needing to create an actual
  751.      library, in case only some of them use the code in `LIBOBJS'.
  752.  
  753.      If this macro finds `alloca.h', it defines `HAVE_ALLOCA_H'.
  754.  
  755.      This macro does not try to get `alloca' from the SVR3 `libPW' or
  756.      the SVR4 `libucb' because those libraries contain some
  757.      incompatible functions that cause trouble.  Some versions do not
  758.      even contain `alloca' or contain a buggy version.  If you still
  759.      want to use their `alloca', use `ar' to extract `alloca.o' from
  760.      them instead of compiling `alloca.c'.
  761.  
  762.      Source files that use `alloca' should start with a piece of code
  763.      like the following, to declare it properly.  Note that in some
  764.      versions of AIX, the declaration of `alloca' must precede
  765.      everything else except for comments and preprocessor directives.
  766.      The `#pragma' directive is indented so that pre-ANSI C compilers
  767.      will ignore it, rather than choke on it.
  768.  
  769.           /* AIX requires this to be the first thing in the file.  */
  770.           #ifdef __GNUC__
  771.           #define alloca __builtin_alloca
  772.           #else /* not __GNUC__ */
  773.           #if HAVE_ALLOCA_H
  774.           #include <alloca.h>
  775.           #else /* not HAVE_ALLOCA_H */
  776.           #ifdef _AIX
  777.            #pragma alloca
  778.           #else /* not _AIX */
  779.           char *alloca ();
  780.           #endif /* not _AIX */
  781.           #endif /* not HAVE_ALLOCA_H */
  782.           #endif /* not __GNUC__ */
  783.  
  784.  - Macro: AC_GETLOADAVG
  785.      Check how to get the system load averages.  If the system has the
  786.      `getloadavg' function, this macro defines `HAVE_GETLOADAVG', and
  787.      adds to `LIBS' any libraries needed to get that function.
  788.  
  789.      Otherwise, it adds `getloadavg.o' to the `make' variable
  790.      `LIBOBJS', and possibly defines several other C preprocessor
  791.      macros and `make' variables:
  792.  
  793.        1. It defines `SVR4', `DGUX', `UMAX', or `UMAX4_3' if on those
  794.           systems.
  795.  
  796.        2. If it finds `nlist.h', it defines `NLIST_STRUCT'.
  797.  
  798.        3. If `struct nlist' has an `n_un' member, it defines
  799.           `NLIST_NAME_UNION'.
  800.  
  801.        4. If compiling `getloadavg.c' defines `LDAV_PRIVILEGED',
  802.           programs need to be installed specially on this system for
  803.           `getloadavg' to work, and this macro defines
  804.           `GETLOADAVG_PRIVILEGED'.
  805.  
  806.        5. This macro always defines `NEED_SETGID', for `make'.  The
  807.           value is `true' if special installation is required, `false'
  808.           if not.  If `NEED_SETGID' is `true', it sets `KMEM_GROUP' to
  809.           the name of the group that should own the installed program.
  810.  
  811.  - Macro: AC_MMAP
  812.      If the `mmap' function exists and works correctly, define
  813.      `HAVE_MMAP'.
  814.  
  815.  - Macro: AC_SETVBUF_REVERSED
  816.      If `setvbuf' takes the buffering type as its second argument and
  817.      the buffer pointer as the third, instead of the other way around,
  818.      define `SETVBUF_REVERSED'.  This is the case on System V before
  819.      release 3.
  820.  
  821.  - Macro: AC_STRCOLL
  822.      If the `strcoll' function exists and works correctly, define
  823.      `HAVE_STRCOLL'.  This does a bit more than
  824.      `AC_HAVE_FUNCS(strcoll)', because some systems have incorrect
  825.      definitions of `strcoll', which should not be used.
  826.  
  827.  - Macro: AC_UTIME_NULL
  828.      If `utime(FILE, NULL)' sets FILE's timestamp to the present,
  829.      define `HAVE_UTIME_NULL'.
  830.  
  831.  - Macro: AC_VFORK
  832.      If `vfork.h' is found, define `HAVE_VFORK_H'.  If a working
  833.      `vfork' is not found, define `vfork' to be `fork'.  This macro
  834.      checks for several known errors in implementations of `vfork' and
  835.      considers the system to not have a working `vfork' if it detects
  836.      any of them.
  837.  
  838.  - Macro: AC_VPRINTF
  839.      If `vprintf' is found, define `HAVE_VPRINTF'.  Otherwise, if
  840.      `_doprnt' is found, define `HAVE_DOPRNT'.  (If `vprintf' is
  841.      available, you may assume that `vfprintf' and `vsprintf' are also
  842.      available.)
  843.  
  844.  - Macro: AC_WAIT3
  845.      If `wait3' is found and fills in the contents of its third argument
  846.      (a `struct rusage *'), which HP-UX does not do, define
  847.      `HAVE_WAIT3'.
  848.  
  849. 
  850. File: autoconf.info,  Node: Structures,  Next: Compiler Characteristics,  Prev: Library Functions,  Up: Specific Tests
  851.  
  852. Structures
  853. ==========
  854.  
  855.    The following macros check for certain structures or structure
  856. members:
  857.  
  858.  - Macro: AC_STAT_MACROS_BROKEN
  859.      If the macros `S_ISDIR', `S_ISREG' et al. defined in `sys/stat.h'
  860.      do not work properly (returning false positives), define
  861.      `STAT_MACROS_BROKEN'.  This is the case on Tektronix UTekV, Amdahl
  862.      UTS and Motorola System V/88.
  863.  
  864.  - Macro: AC_ST_BLKSIZE
  865.      If `struct stat' contains an `st_blksize' member, define
  866.      `HAVE_ST_BLKSIZE'.
  867.  
  868.  - Macro: AC_ST_BLOCKS
  869.      If `struct stat' contains an `st_blocks' member, define
  870.      `HAVE_ST_BLOCKS'.  Otherwise, add `fileblocks.o' to the `make'
  871.      variable `LIBOBJS'.
  872.  
  873.  - Macro: AC_ST_RDEV
  874.      If `struct stat' contains an `st_rdev' member, define
  875.      `HAVE_ST_RDEV'.
  876.  
  877.  - Macro: AC_TIME_WITH_SYS_TIME
  878.      If a program may include both `time.h' and `sys/time.h', define
  879.      `TIME_WITH_SYS_TIME'.  On some older systems, `sys/time.h'
  880.      includes `time.h', but `time.h' is not protected against multiple
  881.      inclusion, so programs should not explicitly include both files.
  882.      This macro is useful in programs that use, for example, `struct
  883.      timeval' or `struct timezone' as well as `struct tm'.  It is best
  884.      used in conjunction with `HAVE_SYS_TIME_H'.
  885.  
  886.           #ifdef TIME_WITH_SYS_TIME
  887.           #include <sys/time.h>
  888.           #include <time.h>
  889.           #else
  890.           #ifdef HAVE_SYS_TIME_H
  891.           #include <sys/time.h>
  892.           #else
  893.           #include <time.h>
  894.           #endif
  895.           #endif
  896.  
  897.  - Macro: AC_STRUCT_TM
  898.      If `time.h' does not define `struct tm', define `TM_IN_SYS_TIME',
  899.      which means that including `sys/time.h' defines `struct tm'.
  900.  
  901.  - Macro: AC_TIMEZONE
  902.      Figure out how to get the current timezone.  If `struct tm' has a
  903.      `tm_zone' member, define `HAVE_TM_ZONE'.  Otherwise, if the
  904.      external array `tzname' is found, define `HAVE_TZNAME'.  This
  905.      macro calls `AC_STRUCT_TM' if it hasn't been called already.
  906.  
  907. 
  908. File: autoconf.info,  Node: Compiler Characteristics,  Next: System Services,  Prev: Structures,  Up: Specific Tests
  909.  
  910. Compiler Characteristics
  911. ========================
  912.  
  913.    The following macros check for C compiler or machine architecture
  914. features:
  915.  
  916.  - Macro: AC_ARG_ARRAY
  917.      If the address of an argument to a C function can not be used like
  918.      the start of an array, define `NO_ARG_ARRAY'.  This ability allows
  919.      a sequence of arguments with the same type to be accessed as if
  920.      they were an array of values.
  921.  
  922.  - Macro: AC_CROSS_CHECK
  923.      If the C compiler being used does not produce executables that can
  924.      run on the system where `configure' is being run, set the shell
  925.      variable `cross_compiling' to 1.  This information can be used by
  926.      `AC_TEST_PROGRAM' to determine whether to take a default action
  927.      instead of trying to run a test program (*note General Feature
  928.      Tests::.).
  929.  
  930.  - Macro: AC_CHAR_UNSIGNED
  931.      If the C type `char' is unsigned, define `__CHAR_UNSIGNED__',
  932.      unless the C compiler predefines it.
  933.  
  934.  - Macro: AC_CONST
  935.      If the C compiler does not fully support the keyword `const',
  936.      define `const' to be empty.  Some C compilers that do not define
  937.      `__STDC__' do support `const'; some compilers that define
  938.      `__STDC__' do not completely support `const'.  Programs can simply
  939.      use `const' as if every C compiler supported it; for those that
  940.      don't, the `Makefile' or configuration header file will define it
  941.      as empty.  (If using a configuration header file, the program
  942.      should include it before any other header files, to prevent
  943.      inconsistencies in declarations.)
  944.  
  945.  - Macro: AC_INLINE
  946.      If the C compiler is a version of GCC that supports the keyword
  947.      `__inline' but not `inline' (such as some NeXT versions), define
  948.      `inline' to be `__inline'.  This macro calls `AC_PROG_CC' if it
  949.      hasn't been called already.
  950.  
  951.  - Macro: AC_INT_16_BITS
  952.      If the C type `int' is 16 bits wide, define `INT_16_BITS'.  This
  953.      macro is obsolete; it is more general to use `AC_SIZEOF_TYPE(int,
  954.      SIZEVAR)' instead (*note General Feature Tests::.), and define a
  955.      symbol based on the size returned in SIZEVAR.
  956.  
  957.  - Macro: AC_LONG_64_BITS
  958.      If the C type `long int' is 64 bits wide, define `LONG_64_BITS'.
  959.      This macro is obsolete; it is more general to use
  960.      `AC_SIZEOF_TYPE(long, SIZEVAR)' instead (*note General Feature
  961.      Tests::.), and define a symbol based on the size returned in
  962.      SIZEVAR.
  963.  
  964.  - Macro: AC_LONG_DOUBLE
  965.      If the C compiler supports the `long double' type, define
  966.      `HAVE_LONG_DOUBLE'.  Some C compilers that do not define
  967.      `__STDC__' do support the `long double' type; some compilers that
  968.      define `__STDC__' do not support `long double'.
  969.  
  970.  - Macro: AC_WORDS_BIGENDIAN
  971.      If words are stored with the most significant byte first (like
  972.      Motorola and SPARC, but not Intel and VAX, CPUs), define
  973.      `WORDS_BIGENDIAN'.
  974.  
  975. 
  976. File: autoconf.info,  Node: System Services,  Next: UNIX Variants,  Prev: Compiler Characteristics,  Up: Specific Tests
  977.  
  978. System Services
  979. ===============
  980.  
  981.    The following macros check for operating system services:
  982.  
  983.  - Macro: AC_FIND_X
  984.      Try to locate the X Window System include files and libraries.  Try
  985.      first by running `xmkmf' on a trivial `Imakefile' and examining
  986.      the `Makefile' that it produces.  If that fails (such as if
  987.      `xmkmf' is not present), look for them in several directories
  988.      where they often reside.  If either method is successful, set the
  989.      shell variables `x_includes' and `x_libraries' to their locations,
  990.      unless they are in directories the compiler searches by default.
  991.      If both methods fail, set the shell variable `no_x' to `true';
  992.      otherwise set it to the empty string.
  993.  
  994.      The command line options `--x-includes=DIR' and
  995.      `--x-libraries=DIR' override the values chosen by this macro.
  996.  
  997.  - Macro: AC_FIND_XTRA
  998.      Check for special options and X libraries that some systems need in
  999.      order to compile X programs.  Add any that the system needs to
  1000.      `make' variables `X_CFLAGS' and `X_LIBS'.  This macro calls
  1001.      `AC_FIND_X' and `AC_ISC_POSIX' (*note UNIX Variants::.) if they
  1002.      have not already been called.
  1003.  
  1004.  - Macro: AC_HAVE_POUNDBANG (ACTION-IF-SUPPORTED [,
  1005.           ACTION-IF-UNSUPPORTED])
  1006.      Check whether the system supports starting shell scripts with a
  1007.      line of the form `#!/bin/csh' to select the shell to use.  If `#!'
  1008.      works, execute shell commands ACTION-IF-SUPPORTED; if not, execute
  1009.      ACTION-IF-NOT-SUPPORTED.
  1010.  
  1011.  - Macro: AC_LONG_FILE_NAMES
  1012.      If the system supports file names longer than 14 characters, define
  1013.      `HAVE_LONG_FILE_NAMES'.
  1014.  
  1015.  - Macro: AC_REMOTE_TAPE
  1016.      If BSD tape drive ioctls are available, define `HAVE_SYS_MTIO_H',
  1017.      and if sockets are available add `rmt' to `make' variable `PROGS'.
  1018.  
  1019.  - Macro: AC_RESTARTABLE_SYSCALLS
  1020.      If the system automatically restarts a system call that is
  1021.      interrupted by a signal, define `HAVE_RESTARTABLE_SYSCALLS'.
  1022.  
  1023. 
  1024. File: autoconf.info,  Node: UNIX Variants,  Prev: System Services,  Up: Specific Tests
  1025.  
  1026. UNIX Variants
  1027. =============
  1028.  
  1029.    The following macros check for certain operating systems that need
  1030. special treatment for some programs, due to exceptional oddities in
  1031. their header files or libraries:
  1032.  
  1033.  - Macro: AC_AIX
  1034.      If on AIX, define `_ALL_SOURCE'.  Allows the use of some BSD
  1035.      functions.  Should be called before any macros that run the C
  1036.      compiler.
  1037.  
  1038.  - Macro: AC_DYNIX_SEQ
  1039.      If on DYNIX/ptx (Sequent UNIX), add `-lseq' to `make' variable
  1040.      `LIBS'.  Allows use of some BSD system calls and `getmntent'.
  1041.  
  1042.  - Macro: AC_IRIX_SUN
  1043.      If on IRIX (Silicon Graphics UNIX), add `-lsun' to `make' variable
  1044.      `LIBS'.  Needed to get `getmntent'.  At sites using Yellow
  1045.      Pages/NIS, it is also needed to get properly working `gethostby*',
  1046.      `getpw*', `getgr*', `getnetby*', and so on.
  1047.  
  1048.  - Macro: AC_ISC_POSIX
  1049.      If on a POSIXized ISC UNIX, define `_POSIX_SOURCE' and add
  1050.      `-posix' (for the GNU C compiler) or `-Xp' (for other C compilers)
  1051.      to `make' variable `CC'.  This allows the use of POSIX facilities.
  1052.      Must be called after `AC_PROG_CC' and before any other macros
  1053.      that run the C compiler.
  1054.  
  1055.  - Macro: AC_MINIX
  1056.      If on Minix, define `_MINIX' and `_POSIX_SOURCE' and define
  1057.      `_POSIX_1_SOURCE' to be 2.  This allows the use of POSIX
  1058.      facilities.  Should be called before any macros that run the C
  1059.      compiler.
  1060.  
  1061.  - Macro: AC_SCO_INTL
  1062.      If on SCO UNIX, add `-lintl' to `make' variable `LIBS'.  Used to
  1063.      get `strftime'.  It must be called before checking for `strftime'.
  1064.  
  1065.  - Macro: AC_XENIX_DIR
  1066.      If on Xenix, define `VOID_CLOSEDIR' and add `-lx' to `make'
  1067.      variable `LIBS'.  Also, if `sys/ndir.h' is not being used, add
  1068.      `-ldir' to `LIBS'.  Needed when using the directory reading
  1069.      functions.  This macro must be called after `AC_DIR_HEADER'.
  1070.  
  1071. 
  1072. File: autoconf.info,  Node: General Purpose Macros,  Next: Writing Macros,  Prev: Specific Tests,  Up: Top
  1073.  
  1074. General Purpose Macros
  1075. **********************
  1076.  
  1077.    These macros provide ways for other macros to control the kind of
  1078. output that Autoconf produces or to check whether various kinds of
  1079. features are available.  They all take arguments.  When calling these
  1080. macros, there must not be any blank space between the macro name and
  1081. the open parentheses.
  1082.  
  1083.    Arguments to these macros can be more than one line long if they are
  1084. enclosed within the `m4' quote characters `[' and `]'.
  1085.  
  1086.    Within each section below, the macros are listed in alphabetical
  1087. order.  These macros are defined in the file `acgeneral.m4'.
  1088.  
  1089. * Menu:
  1090.  
  1091. * Setup::            Controlling Autoconf operation.
  1092. * General Feature Tests::    Checking for kinds of features.
  1093. * Command Line::                Checking command line arguments.
  1094. * Setting Variables::        Setting shell and `make' variables.
  1095. * Printing Messages::           Notifying users of progress or problems.
  1096. * Language Choice::             Selecting which language to use for testing.
  1097. * Macro Ordering::        Enforcing ordering constraints.
  1098.  
  1099. 
  1100. File: autoconf.info,  Node: Setup,  Next: General Feature Tests,  Up: General Purpose Macros
  1101.  
  1102. Controlling Autoconf Setup
  1103. ==========================
  1104.  
  1105.    The following macros control the kind of output that Autoconf
  1106. produces.
  1107.  
  1108.  - Macro: AC_CONFIG_HEADER (HEADER-TO-CREATE ...)
  1109.      Make `AC_OUTPUT' create the file(s) in the whitespace-separated
  1110.      list HEADER-TO-CREATE containing C preprocessor `#define'
  1111.      statements and replace `@DEFS@' in generated files with
  1112.      `-DHAVE_CONFIG_H' instead of the value of `DEFS'.  This macro
  1113.      should be called right after `AC_INIT'.  The usual name for
  1114.      HEADER-TO-CREATE is `config.h'.
  1115.  
  1116.      If HEADER-TO-CREATE already exists and its contents are identical
  1117.      to what `AC_OUTPUT' would put in it, it is left alone.  Doing this
  1118.      allows some changes in configuration without needlessly causing
  1119.      object files that depend on the header file to be recompiled.
  1120.  
  1121.      Your distribution should contain a file `HEADER-TO-CREATE.in' that
  1122.      looks as you want the final header file to look, including
  1123.      comments, with default values in the `#define' statements.  A
  1124.      default value can be to `#undef' the variable instead of to define
  1125.      it to a value, if your code tests for configuration options using
  1126.      `#ifdef' instead of `#if'.
  1127.  
  1128.      You can use the program `autoheader' to create
  1129.      `HEADER-TO-CREATE.in' (*note Invoking autoheader::.).
  1130.  
  1131.  - Macro: AC_INIT (UNIQUE-FILE-IN-SOURCE-DIR)
  1132.      Process the command-line arguments and find the source code
  1133.      directory.  UNIQUE-FILE-IN-SOURCE-DIR is some file that is in the
  1134.      package's source directory; `configure' checks for this file's
  1135.      existence to make sure that the directory that it is told contains
  1136.      the source code in fact does (*note Invoking configure::., for
  1137.      more information).
  1138.  
  1139.  - Macro: AC_OUTPUT ([FILE...] [,EXTRA-CMDS])
  1140.      Create output files (typically one or more `Makefile's) and
  1141.      `config.status'.  If `AC_CONFIG_HEADER' has been called, also
  1142.      create the header file that was named as its argument.  The
  1143.      argument is a whitespace-separated list of files to create; if it
  1144.      is omitted, no files are created.  `AC_OUTPUT' creates each file
  1145.      `FILE' in the list by copying `FILE.in', substituting the variable
  1146.      values that have been selected by calling `AC_SUBST'.  It creates
  1147.      the directory that each file is in if it doesn't exist (but not the
  1148.      parents of that directory).  A plausible value for the argument to
  1149.      `AC_OUTPUT' is `Makefile src/Makefile man/Makefile X/Imakefile'.
  1150.  
  1151.      If you pass EXTRA-CMDS, those commands will be inserted into
  1152.      `config.status' to be run after all its other processing.
  1153.  
  1154.  - Macro: AC_PREPARE (UNIQUE-FILE-IN-SOURCE-DIR)
  1155.      Find the source code directory and set up shell variables
  1156.      necessary for other Autoconf macros to work.
  1157.      uNIQUE-FILE-IN-SOURCE-DIR is some file that is in the package's
  1158.      source directory; `configure' checks for this file's existence to
  1159.      make sure that the directory that it is told contains the source
  1160.      code in fact does (*note Invoking configure::., for more
  1161.      information).  `AC_PREPARE' is the last thing done by `AC_INIT'.
  1162.      Use `AC_PREPARE' instead of `AC_INIT' if you want to do argument
  1163.      parsing yourself; never use both.
  1164.  
  1165.  - Macro: AC_PREREQ (VERSION)
  1166.      Ensure that a recent enough version of Autoconf is being used.  If
  1167.      the version of Autoconf being used to create `configure' is earlier
  1168.      than VERSION (e.g., `1.8'), print an error message on the standard
  1169.      error output and do not create `configure'.
  1170.  
  1171.      This macro is useful if your `configure.in' relies on non-obvious
  1172.      behavior that changed between Autoconf releases.  If it merely
  1173.      needs recently added macros, then `AC_PREREQ' is less useful,
  1174.      because the `autoconf' program already tells the user which macros
  1175.      are not found.  The same thing happens if `configure.in' is
  1176.      processed by a version of Autoconf older than when `AC_PREREQ' was
  1177.      added.
  1178.  
  1179.  - Macro: AC_REVISION (REVISION-INFO)
  1180.      Copy revision stamp REVISION-INFO into the `configure' script,
  1181.      with any dollar signs or double-quotes removed.  This macro lets
  1182.      you put a revision stamp from `configure.in' into `configure'
  1183.      without RCS or CVS changing it when you check in `configure'.  That
  1184.      way, you can determine easily which revision of `configure.in' a
  1185.      particular `configure' corresponds to.
  1186.  
  1187.      It is a good idea to call this macro before `AC_INIT' so that the
  1188.      revision number is near the top of both `configure.in' and
  1189.      `configure'.  To support doing that, the `AC_REVISION' output
  1190.      begins with `#!/bin/sh', like the normal start of a `configure'
  1191.      script does.
  1192.  
  1193.      For example, this line in `configure.in':
  1194.  
  1195.           AC_REVISION($Revision: 1.30 $)dnl
  1196.  
  1197.      produces this in `configure':
  1198.  
  1199.           #!/bin/sh
  1200.           # From configure.in Revision: 1.30
  1201.  
  1202. 
  1203. File: autoconf.info,  Node: General Feature Tests,  Next: Command Line,  Prev: Setup,  Up: General Purpose Macros
  1204.  
  1205. Checking for Kinds of Features
  1206. ==============================
  1207.  
  1208.    These macros are templates that, when called with actual parameters,
  1209. check for various kinds of features.  Many of these macros handle two
  1210. cases: what to do if the given condition is met, and what to do if the
  1211. condition is not met.  In some places you you might want to do something
  1212. if a condition is true but do nothing if it's false, or vice versa.  To
  1213. omit the true case, pass an empty value for the ACTION-IF-FOUND
  1214. argument to the macro.  To omit the false case, omit the
  1215. ACTION-IF-NOT-FOUND argument to the macro, including the comma before
  1216. it.
  1217.  
  1218.    One shell programming construction that you should not use in the
  1219. action arguments to these macros is `VAR=${VAR:-VALUE}'.  Old BSD
  1220. shells, including the Ultrix `sh', don't understand the colon, and
  1221. complain and die.  If you omit the colon, it works fine:
  1222. `VAR=${VAR-VALUE}'.
  1223.  
  1224.    *Note Writing Macros::, for more information on how best to use these
  1225. macros.
  1226.  
  1227.  - Macro: AC_COMPILE_CHECK (ECHO-TEXT, INCLUDES, FUNCTION-BODY,
  1228.           ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND])
  1229.      Print `checking for ECHO-TEXT' to the standard output (using
  1230.      `AC_CHECKING', *note Printing Messages::.).  Create a test C
  1231.      program to see whether a function whose body consists of
  1232.      FUNCTION-BODY can be compiled and linked; INCLUDES is any
  1233.      `#include' statements needed by the code in FUNCTION-BODY.  If the
  1234.      file compiles and links successfully, run shell commands
  1235.      ACTION-IF-FOUND, otherwise run ACTION-IF-NOT-FOUND.
  1236.  
  1237.  - Macro: AC_FUNC_CHECK (FUNCTION, ACTION-IF-FOUND [,
  1238.           ACTION-IF-NOT-FOUND])
  1239.      If FUNCTION is available, run shell commands ACTION-IF-FOUND,
  1240.      otherwise ACTION-IF-NOT-FOUND.  If the functions might be in
  1241.      libraries other than the default C library, first call
  1242.      `AC_HAVE_LIBRARY' for those libraries.  If you just want to define
  1243.      a symbol if the function is available, consider using
  1244.      `AC_HAVE_FUNCS' instead.
  1245.  
  1246.  - Macro: AC_HAVE_FUNCS (FUNCTION...)
  1247.      For each given FUNCTION in the whitespace-separated argument list
  1248.      that is available, define `HAVE_FUNCTION' (in all caps).  *Note
  1249.      Specific Tests::, for a precise definition of "define" as it is
  1250.      used here.  If the functions might be in libraries other than the
  1251.      default C library, first call `AC_HAVE_LIBRARY' for those
  1252.      libraries.
  1253.  
  1254.  - Macro: AC_HAVE_HEADERS (HEADER-FILE...)
  1255.      For each given HEADER-FILE in the whitespace-separated argument
  1256.      list that exists, define `HAVE_HEADER-FILE' (in all caps).  *Note
  1257.      Specific Tests::, for a precise definition of "define" as it is
  1258.      used here.
  1259.  
  1260.  - Macro: AC_HAVE_LIBRARY (LIBRARY [, ACTION-IF-FOUND [,
  1261.           ACTION-IF-NOT-FOUND]])
  1262.      Create a test C program to see whether that program can be linked
  1263.      with the specified library.  ACTION-IF-FOUND is a list of shell
  1264.      commands to run if the link succeeds (which means that the library
  1265.      is present); ACTION-IF-NOT-FOUND is a list of shell commands to run
  1266.      if the link fails.  If ACTION-IF-FOUND and ACTION-IF-NOT-FOUND are
  1267.      not specified, the default action is to add `-lfoo' to `LIBS' and
  1268.      define `HAVE_LIBfoo' for library `foo'.  LIBRARY can be written as
  1269.      any of `foo', `-lfoo', or `libfoo.a'.  In all of those cases, the
  1270.      compiler is passed `-lfoo'.
  1271.  
  1272.  - Macro: AC_HEADER_CHECK (HEADER-FILE, ACTION-IF-FOUND [,
  1273.           ACTION-IF-NOT-FOUND])
  1274.      If HEADER-FILE exists, execute shell commands ACTION-IF-FOUND,
  1275.      otherwise execute ACTION-IF-NOT-FOUND.  If you just want to define
  1276.      a symbol if the header file is available, consider using
  1277.      `AC_HAVE_HEADERS' instead.
  1278.  
  1279.  - Macro: AC_HEADER_EGREP (PATTERN, HEADER-FILE, ACTION-IF-FOUND [,
  1280.           ACTION-IF-NOT-FOUND])
  1281.      If the output of running the preprocessor on HEADER-FILE contains
  1282.      the `egrep' regular expression PATTERN, execute shell commands
  1283.      ACTION-IF-FOUND, otherwise execute
  1284.  
  1285.      This macro calls `AC_PROG_CPP' or `AC_PROG_CXXCPP' (depending on
  1286.      which language is current, *note Language Choice::.), if it hasn't
  1287.      been called already.  ACTION-IF-NOT-FOUND.
  1288.  
  1289.      You can not check whether preprocessor symbols are defined this
  1290.      way, because they get expanded before `egrep' sees them.  But you
  1291.      can almost always detect them by simply using `#ifdef' directives
  1292.      in your programs.
  1293.  
  1294.  - Macro: AC_PROGRAM_CHECK (VARIABLE, PROG-TO-CHECK-FOR,
  1295.           VALUE-IF-FOUND, VALUE-IF-NOT-FOUND)
  1296.      Check whether program PROG-TO-CHECK-FOR exists in `PATH'.  If it
  1297.      is found, set VARIABLE to VALUE-IF-FOUND, otherwise to
  1298.      VALUE-IF-NOT-FOUND.  Calls `AC_SUBST' for VARIABLE.
  1299.  
  1300.  - Macro: AC_PROGRAM_EGREP (PATTERN, PROGRAM, ACTION-IF-FOUND [,
  1301.           ACTION-IF-NOT-FOUND])
  1302.      PROGRAM is the text of a C or C++ program, on which shell variable
  1303.      and backquote substitutions are performed.  If the output of
  1304.      running the preprocessor on PROGRAM contains the `egrep' regular
  1305.      expression PATTERN, execute shell commands ACTION-IF-FOUND,
  1306.      otherwise execute ACTION-IF-NOT-FOUND.  (It is an unfortunate
  1307.      oversight that we use the word `PROGRAM' in Autoconf macro names to
  1308.      sometimes mean C or C++ source code and sometimes mean a UNIX
  1309.      command.)
  1310.  
  1311.      This macro calls `AC_PROG_CPP' or `AC_PROG_CXXCPP' (depending on
  1312.      which language is current, *note Language Choice::.), if it hasn't
  1313.      been called already.
  1314.  
  1315.  - Macro: AC_PROGRAM_PATH (VARIABLE, PROG-TO-CHECK-FOR,
  1316.           VALUE-IF-NOT-FOUND)
  1317.      Similar to `AC_PROGRAM_CHECK', but set VARIABLE to the entire path
  1318.      of PROG-TO-CHECK-FOR if found.  Otherwise, set VARIABLE to the
  1319.      value VALUE-IF-NOT-FOUND and perform no path checking.  Calls
  1320.      `AC_SUBST' for VARIABLE.
  1321.  
  1322.  - Macro: AC_PROGRAMS_CHECK (VARIABLE, PROGS-TO-CHECK-FOR [,
  1323.           VALUE-IF-NOT-FOUND])
  1324.      Check for each program in the whitespace-separated list
  1325.      PROGS-TO-CHECK-FOR exists in `PATH'.  If it is found, set VARIABLE
  1326.      to the name of that program.  Otherwise, continue checking the
  1327.      next program in the list.  If none of the programs in the list are
  1328.      found, set VARIABLE to VALUE-IF-NOT-FOUND; if VALUE-IF-NOT-FOUND
  1329.      is not specified, the value of VARIABLE will not be changed.
  1330.      Calls `AC_SUBST' for VARIABLE.
  1331.  
  1332.  - Macro: AC_PROGRAMS_PATH (VARIABLE, PROGS-TO-CHECK-FOR [,
  1333.           VALUE-IF-NOT-FOUND])
  1334.      Like `AC_PROGRAMS_CHECK', but if any of PROGS-TO-CHECK-FOR are
  1335.      found, set VARIABLE to the entire pathname of the program found.
  1336.  
  1337.  - Macro: AC_REPLACE_FUNCS (FUNCTION-NAME...)
  1338.      For each given FUNCTION-NAME in the whitespace-separated argument
  1339.      list that is not in the C library, add `FUNCTION-NAME.o' to the
  1340.      value of the `make' variable `LIBOBJS'.  If the functions might be
  1341.      in libraries other than the default C library, first call
  1342.      `AC_HAVE_LIBRARY' for those libraries.
  1343.  
  1344.  - Macro: AC_SIZEOF_TYPE (TYPE, SIZE-VAR)
  1345.      Assign to shell variable SIZE-VAR the size (in bytes) of the C (or
  1346.      C++) builtin type TYPE, e.g. `int' or `char *'.  If `type' is
  1347.      unknown to the compiler, assign 0 to SIZE-VAR.  The caller will
  1348.      likely use `AC_DEFINE' to define a symbol in the package being
  1349.      configured, based on the value of SIZE-VAR.  For example,
  1350.  
  1351.           AC_SIZEOF_TYPE(char *, psize)
  1352.           if test $psize -eq 8; then
  1353.             AC_DEFINE(BIG_POINTERS)
  1354.           fi
  1355.  
  1356.  - Macro: AC_TEST_PROGRAM (PROGRAM, ACTION-IF-TRUE [, ACTION-IF-FALSE
  1357.           [, ACTION-IF-CROSS-COMPILING]])
  1358.      PROGRAM is the text of a C program, on which shell variable and
  1359.      backquote substitutions are performed.  If it compiles and links
  1360.      successfully and returns an exit status of 0 when executed, run
  1361.      shell commands ACTION-IF-TRUE.  Otherwise run shell commands
  1362.      ACTION-IF-FALSE.
  1363.  
  1364.      If the optional argument ACTION-IF-CROSS-COMPILING is given and
  1365.      the C compiler being used does not produce executables that run on
  1366.      the system where `configure' is being run, then the test program
  1367.      is not run.  Instead, the shell commands ACTION-IF-CROSS-COMPILING
  1368.      are run.  If that argument is given, this macro calls
  1369.      `AC_CROSS_CHECK' if it has not already been called (*note Compiler
  1370.      Characteristics::.).
  1371.  
  1372.  - Macro: AC_TEST_CPP (INCLUDES, ACTION-IF-TRUE [, ACTION-IF-FALSE])
  1373.      INCLUDES is C or C++ `#include' statements and declarations, on
  1374.      which shell variable and backquote substitutions are performed.
  1375.      (Actually, it can be any C program, but other statements are
  1376.      probably not useful.)  If the preprocessor produces no error
  1377.      messages while processing it, run shell commands ACTION-IF-TRUE.
  1378.      Otherwise run shell commands ACTION-IF-FALSE.
  1379.  
  1380.      This macro calls `AC_PROG_CPP' or `AC_PROG_CXXCPP' (depending on
  1381.      which language is current, *note Language Choice::.), if it hasn't
  1382.      been called already.
  1383.  
  1384. 
  1385. File: autoconf.info,  Node: Command Line,  Next: Setting Variables,  Prev: General Feature Tests,  Up: General Purpose Macros
  1386.  
  1387. Checking Command Line Arguments
  1388. ===============================
  1389.  
  1390.    These macros check whether the user gave `configure' various command
  1391. line arguments.  Like the general feature tests (*note General Feature
  1392. Tests::.),  they may take an argument to use if the argument was given
  1393. and one for if it was not given.
  1394.  
  1395.  - Macro: AC_ENABLE (FEATURE, ACTION-IF-TRUE [, ACTION-IF-FALSE])
  1396.      If the user gave `configure' the option `--enable-FEATURE' or
  1397.      `--disable-FEATURE', run shell commands ACTION-IF-TRUE.  Otherwise
  1398.      run shell commands ACTION-IF-FALSE.  The name FEATURE should
  1399.      consist only of alphanumeric characters and dashes.
  1400.  
  1401.      The FEATURE indicates an optional user-level facility.  This
  1402.      option allows users to choose which optional features to build and
  1403.      install.  `--enable-FEATURE' options should never make a feature
  1404.      behave differently or cause one feature to replace another.  They
  1405.      should only cause parts of the program to be built rather than left
  1406.      out.
  1407.  
  1408.      The user can give an argument by following the feature name with
  1409.      `=' and the argument.  Giving an argument of `no' indicates that
  1410.      the feature is *not* available.  A feature with an argument looks
  1411.      like `--enable-debug=stabs'.
  1412.  
  1413.      The argument is available to the shell commands ACTION-IF-TRUE in
  1414.      the shell variable `enableval'.  If no argument was given to
  1415.      `--enable-FEATURE', `enableval' is `yes'.  `--disable-FEATURE' is
  1416.      equivalent to `--enable-FEATURE=no'.  At present, arguments
  1417.      containing blanks are not handled correctly; if you need an
  1418.      argument to contain a list, require the items to be separated by
  1419.      commas instead.  (This restriction might disappear in the future.)
  1420.  
  1421.  - Macro: AC_PREFIX (PROGRAM)
  1422.      If the user did not specify an installation prefix (using the
  1423.      `--prefix' option), guess a value for it by looking for PROGRAM in
  1424.      `PATH', the way the shell does.  If PROGRAM is found, set the
  1425.      prefix to the parent of the directory containing PROGRAM;
  1426.      otherwise leave the prefix specified in `Makefile.in' unchanged.
  1427.      For example, if PROGRAM is `gcc' and the `PATH' contains
  1428.      `/usr/local/gnu/bin/gcc', set the prefix to `/usr/local/gnu'.
  1429.  
  1430.  - Macro: AC_WITH (PACKAGE, ACTION-IF-TRUE [, ACTION-IF-FALSE])
  1431.      If the user gave `configure' the option `--with-PACKAGE' or
  1432.      `--without-PACKAGE', run shell commands ACTION-IF-TRUE.  Otherwise
  1433.      run shell commands ACTION-IF-FALSE.  The name PACKAGE should
  1434.      consist only of alphanumeric characters and dashes.
  1435.  
  1436.      The PACKAGE indicates another software package that this program
  1437.      should work with.  For example, `--with-gnu-ld' means work with the
  1438.      GNU linker instead of some other linker.  `--with-x11' means work
  1439.      with X11.
  1440.  
  1441.      The user can give an argument by following the package name with
  1442.      `=' and the argument.  Giving an argument of `no' is for packages
  1443.      that would be used by default; it says to *not* use the package.
  1444.      An argument that is neither `yes' nor `no' could include a name or
  1445.      number of a version of the other package, to specify more
  1446.      precisely which other package this program is supposed to work
  1447.      with.
  1448.  
  1449.      The argument is available to the shell commands ACTION-IF-TRUE in
  1450.      the shell variable `withval'.  If no argument was given to
  1451.      `--with-PACKAGE', `withval' is `yes'.  `--without-PACKAGE' is
  1452.      equivalent to `--with-PACKAGE=no'.  At present, arguments
  1453.      containing blanks are not handled correctly; if you need an
  1454.      argument to contain a list, require the items to be separated by
  1455.      commas instead.  (This restriction might disappear in the future.)
  1456.  
  1457. 
  1458. File: autoconf.info,  Node: Setting Variables,  Next: Printing Messages,  Prev: Command Line,  Up: General Purpose Macros
  1459.  
  1460. Setting Variables
  1461. =================
  1462.  
  1463.    These macros help other macros to define shell and `make' variables.
  1464.  
  1465.  - Macro: AC_DEFINE (VARIABLE [, VALUE])
  1466.      Define C preprocessor variable VARIABLE.  If VALUE is given, set
  1467.      VARIABLE to that value, otherwise set it to 1.  To use a shell
  1468.      variable as the value, use `AC_DEFINE_UNQUOTED' instead.  Precede
  1469.      double quotes in the value with backslashes.
  1470.  
  1471.      This macro adds to the shell variable `DEFS'.  `AC_OUTPUT' later
  1472.      substitutes the values in `DEFS' into the file(s) that it
  1473.      generates (typically `Makefile').  Alternately, if
  1474.      `AC_CONFIG_HEADER' has been called, `AC_OUTPUT' creates a header
  1475.      file by substituting the correct values into `#define' statements
  1476.      in a template file.
  1477.  
  1478.      For example, suppose your `configure.in' calls
  1479.      `AC_CONFIG_HEADER(conf.h)' and `AC_HAVE_HEADERS(unistd.h)'.  You
  1480.      could have code like this in `conf.h.in':
  1481.  
  1482.           /* Define as 1 if you have unistd.h.  */
  1483.           #define HAVE_UNISTD_H 0
  1484.  
  1485.      On systems that have `unistd.h', `configure' will change the 0 to
  1486.      a 1.  On other systems, it will leave the line unchanged.
  1487.      Alternately, if you prefer to use `#ifdef', your `conf.h.in' could
  1488.      have code like this:
  1489.  
  1490.           /* Define if you have unistd.h.  */
  1491.           #undef HAVE_UNISTD_H
  1492.  
  1493.      On systems that have `unistd.h', `configure' will change the
  1494.      second line to read `#define HAVE_UNISTD_H 1'.  On other systems,
  1495.      it will comment that line out (in case the system predefines that
  1496.      symbol).
  1497.  
  1498.      Due to the syntactical bizarreness of the Bourne shell, do not use
  1499.      semicolons to separate `AC_DEFINE' calls from other macro calls or
  1500.      shell code; that can cause syntax errors in the resulting
  1501.      `configure' script.  Use either spaces or newlines.  That is, do
  1502.      this:
  1503.  
  1504.           AC_HEADER_CHECK(elf.h, AC_DEFINE(SVR4) LIBS="$LIBS -lelf")
  1505.  
  1506.      or this:
  1507.  
  1508.           AC_HEADER_CHECK(elf.h,
  1509.             AC_DEFINE(SVR4)
  1510.             LIBS="$LIBS -lelf")
  1511.  
  1512.      instead of this:
  1513.  
  1514.           AC_HEADER_CHECK(elf.h, AC_DEFINE(SVR4); LIBS="$LIBS -lelf")
  1515.  
  1516.  - Macro: AC_DEFINE_UNQUOTED (VARIABLE [, VALUE])
  1517.      Like `AC_DEFINE', but it does nothing to quote VALUE from various
  1518.      shell and `sed' expansions it will undergo.  VALUE will be used in
  1519.      many different contexts requiring different quoting, and it is up
  1520.      to you to make sure it works right.  Use this macro instead of
  1521.      `AC_DEFINE' when VALUE contains a shell variable.  For example:
  1522.  
  1523.           AC_DEFINE_UNQUOTED(config_machfile,  ${machfile})
  1524.  
  1525.  - Macro: AC_SUBST (VARIABLE)
  1526.      Substitute the variable VARIABLE when creating the output files
  1527.      (typically one or more `Makefile's).  This means replace instances
  1528.      of `@VARIABLE@', e.g. in `Makefile.in', with the current value of
  1529.      the shell variable VARIABLE.  If this macro were not called, the
  1530.      value of VARIABLE would not be set in the output files, even
  1531.      though `configure' had figured out a value for it.
  1532.  
  1533.      You can set or add to the value of VARIABLE in the usual shell
  1534.      way.  For example, to add `-ltermcap' to the value of the variable
  1535.      `LIBS':
  1536.  
  1537.           LIBS="$LIBS -ltermcap"
  1538.  
  1539. 
  1540. File: autoconf.info,  Node: Printing Messages,  Next: Language Choice,  Prev: Setting Variables,  Up: General Purpose Macros
  1541.  
  1542. Printing Messages
  1543. =================
  1544.  
  1545.    `configure' scripts need to give users running them several kinds of
  1546. information.  The following macros print messages in ways appropriate
  1547. for different kinds of information.  The arguments to all of them get
  1548. enclosed in shell double quotes, so the shell performs variable and
  1549. backquote substitution on them.
  1550.  
  1551.    These macros are all wrappers around the `echo' shell command.
  1552. Other macros should rarely need to run `echo' directly to print
  1553. messages for the `configure' user.  Using these macros makes it easy to
  1554. change how and when each kind of message is printed; such changes need
  1555. only be made to the macro definitions, and all of the callers change
  1556. automatically.
  1557.  
  1558.  - Macro: AC_CHECKING (FEATURE-DESCRIPTION)
  1559.      Notify the user that `configure' is checking for a particular
  1560.      feature.  This macro prints a message that starts with `checking '.
  1561.      It prints nothing if `configure' is run with the `--silent' or
  1562.      `--quiet' option.  The FEATURE-DESCRIPTION should be something
  1563.      like `whether the Fortran compiler accepts C++ comments' or `for
  1564.      c89'.
  1565.  
  1566.  - Macro: AC_ERROR (ERROR-DESCRIPTION)
  1567.      Notify the user of an error that prevents `configure' from
  1568.      completing.  This macro prints an error message on the standard
  1569.      error stream and exits `configure' with a nonzero status.
  1570.      eRROR-DESCRIPTION should be something like `invalid value for
  1571.      \$HOME'.
  1572.  
  1573.  - Macro: AC_VERBOSE (RESULT-DESCRIPTION)
  1574.      Notify the user of the results of a check.  This information is
  1575.      only printed if `configure' is run with the `--verbose' option.
  1576.      rESULT-DESCRIPTION should be something like `setting ADA to $ADA'.
  1577.  
  1578.  - Macro: AC_WARN (PROBLEM-DESCRIPTION)
  1579.      Notify the `configure' user of a possible problem.  This macro
  1580.      prints the message on the standard error stream; `configure'
  1581.      continues running afterward, so macros that call `AC_WARN' should
  1582.      provide a default (back-up) behavior for the situations they warn
  1583.      about.  PROBLEM-DESCRIPTION should be something like `ln -s seems
  1584.      to make hard links'.
  1585.  
  1586. 
  1587. File: autoconf.info,  Node: Language Choice,  Next: Macro Ordering,  Prev: Printing Messages,  Up: General Purpose Macros
  1588.  
  1589. Language Choice
  1590. ===============
  1591.  
  1592.    Packages that use both C and C++ need to test features of both
  1593. compilers.  Autoconf-generated `configure' scripts check for C features
  1594. by default.  The following macros determine which language's compiler
  1595. is used in tests that follow in `configure.in'.
  1596.  
  1597.  - Macro: AC_LANG_C
  1598.      Do compilation tests using `CC' and `CPP' and use extension `.c'
  1599.      for test programs.
  1600.  
  1601.      This is the initial state.
  1602.  
  1603.  - Macro: AC_LANG_CPLUSPLUS
  1604.      Do compilation tests using `CXX' and `CXXCPP' and use extension
  1605.      `.C' for test programs.
  1606.  
  1607.  - Macro: AC_LANG_RESTORE
  1608.      Select the language that is saved on the top of the stack, as set
  1609.      by `AC_LANG_SAVE', and remove it from the stack.  This macro is
  1610.      equivalent to either `AC_LANG_C' or `AC_LANG_CPLUSPLUS', whichever
  1611.      had been run most recently when `AC_LANG_SAVE' was last called.
  1612.  
  1613.      Do not call this macro more times than `AC_LANG_SAVE'.
  1614.  
  1615.  - Macro: AC_LANG_SAVE
  1616.      Remember the current language (as set by `AC_LANG_C' or
  1617.      `AC_LANG_CPLUSPLUS') on a stack.  Does not change which language is
  1618.      current.  Use this macro and `AC_LANG_RESTORE' in macros that need
  1619.      to temporarily switch to a particular language.
  1620.  
  1621.  - Macro: AC_REQUIRE_CPP
  1622.      Ensure that whichever preprocessor would currently be used for
  1623.      tests has been found.  Calls `AC_REQUIRE' (*note Macro
  1624.      Ordering::.) with an argument of either `AC_PROG_CPP' or
  1625.      `AC_PROG_CXXCPP', depending on which language is current.
  1626.  
  1627. 
  1628. File: autoconf.info,  Node: Macro Ordering,  Prev: Language Choice,  Up: General Purpose Macros
  1629.  
  1630. Macro Ordering
  1631. ==============
  1632.  
  1633.    These macros provide ways for other macros to make sure that they are
  1634. called in the correct order.
  1635.  
  1636.  - Macro: AC_BEFORE (THIS-MACRO-NAME, CALLED-MACRO-NAME)
  1637.      Make `m4' print a warning message on the standard error output if
  1638.      CALLED-MACRO-NAME has already been called.  THIS-MACRO-NAME should
  1639.      be the name of the macro that is calling `AC_BEFORE'.  The macro
  1640.      CALLED-MACRO-NAME must contain a call to `AC_PROVIDE' to indicate
  1641.      that it has been called.
  1642.  
  1643.      This macro should be used when one macro makes changes that might
  1644.      affect another macro, so that the other macro should probably not
  1645.      be called first.  For example, `AC_PROG_CPP' checks whether the C
  1646.      compiler can run the C preprocessor when given the `-E' option.
  1647.      It should therefore be called after any macros that change which C
  1648.      compiler is being used, such as `AC_PROG_CC'.  So `AC_PROG_CC'
  1649.      contains:
  1650.  
  1651.           AC_BEFORE([$0], [AC_PROG_CPP])
  1652.  
  1653.      This warns the user if a call to `AC_PROG_CPP' has already occurred
  1654.      when `AC_PROG_CC' is called.
  1655.  
  1656.  - Macro: AC_OBSOLETE (THIS-MACRO-NAME [, SUGGESTION])
  1657.      Make `m4' print a message on the standard error output warning that
  1658.      THIS-MACRO-NAME is obsolete, and giving the file and line number
  1659.      where it was called.  THIS-MACRO-NAME should be the name of the
  1660.      macro that is calling `AC_BEFORE'.  If SUGGESTION is given, it is
  1661.      printed at the end of the warning message; for example, it can be
  1662.      a suggestion for what to use instead of THIS-MACRO-NAME.
  1663.  
  1664.      A sample call is:
  1665.  
  1666.           AC_OBSOLETE([$0], [; use AC_HAVE_HEADERS(unistd.h) instead])
  1667.  
  1668.  - Macro: AC_PROVIDE (MACRO-NAME)
  1669.      Set a flag recording that MACRO-NAME has been called.  The
  1670.      argument should be the name of the macro that is calling
  1671.      `AC_PROVIDE'.  An easy way to get it is from the `m4' builtin
  1672.      variable `$0', like this:
  1673.  
  1674.           AC_PROVIDE([$0])
  1675.  
  1676.  - Macro: AC_REQUIRE (MACRO-NAME)
  1677.      If the `m4' macro MACRO-NAME has not already been called, call it
  1678.      (without any arguments).  Make sure to quote MACRO-NAME with
  1679.      square brackets.  The body of MACRO-NAME must contain a call to
  1680.      `AC_PROVIDE' to indicate that it has been called.
  1681.  
  1682.      Macros that need some other macro to be called before they are
  1683.      called can use `AC_REQUIRE' to ensure that it has been, in case
  1684.      the person who made `configure.in' forgot or didn't know to do it.
  1685.      `AC_REQUIRE' and `AC_PROVIDE' together can ensure that a macro is
  1686.      only called if it is needed, and only called once.  *Note
  1687.      Dependencies Between Macros::, for more information.
  1688.  
  1689. 
  1690. File: autoconf.info,  Node: Writing Macros,  Next: Makefiles,  Prev: General Purpose Macros,  Up: Top
  1691.  
  1692. Writing Macros
  1693. **************
  1694.  
  1695.    If your package needs to test for some feature that none of the
  1696. macros supplied with Autoconf handles, you'll need to write one or more
  1697. new Autoconf macros.  Here are some suggestions and some of the
  1698. rationale behind why the existing macros are written the way they are.
  1699. You can also learn a lot about how to write Autoconf macros by looking
  1700. at the existing ones.  If something goes wrong in one or more of the
  1701. Autoconf tests, this information can help you understand why they work
  1702. the way they do and the assumptions behind them, which might help you
  1703. figure out how to best solve the problem.
  1704.  
  1705.    If you add macros that you think would be useful to other people, or
  1706. find problems with the distributed macros, please send electronic mail
  1707. to `bug-gnu-utils@prep.ai.mit.edu', so we can consider them for future
  1708. releases of Autoconf.  Please include the Autoconf version number,
  1709. which you can get by running `autoconf --version'.
  1710.  
  1711. * Menu:
  1712.  
  1713. * Macro Format::        Basic format of an Autoconf macro.
  1714. * Quoting::            Protecting macros from unwanted expansion.
  1715. * Dependencies Between Macros::    What to do when macros depend on other macros.
  1716. * Checking for Files::        Finding whether a file exists.
  1717. * Checking for Symbols::    Finding whether a symbol is defined.
  1718. * Test Programs::        Writing programs to test for features.
  1719. * Multiple Cases::        Tests for several possible values.
  1720.  
  1721. 
  1722. File: autoconf.info,  Node: Macro Format,  Next: Quoting,  Up: Writing Macros
  1723.  
  1724. Macro Format
  1725. ============
  1726.  
  1727.    Autoconf macros are defined as arguments to the `m4' builtin command
  1728. `define'.  Their overall structure looks like this:
  1729.  
  1730.      define(MACRO-NAME, [MACRO-BODY])dnl
  1731.  
  1732. The square brackets here do not indicate optional text: they should
  1733. literally be present in the macro definition.
  1734.  
  1735.    All of the Autoconf macros have names starting with `AC_' to prevent
  1736. them from accidentally conflicting with other text.  All shell
  1737. variables that they use for internal purposes have names starting with
  1738. `ac_'.  To ensure that your macros don't conflict with present or
  1739. future Autoconf macros, you should prefix your own macro names and any
  1740. shell variables they use with some other sequence.  Possibilities
  1741. include your initials, or an abbreviation for the name of your
  1742. organization or software package.
  1743.  
  1744.    The `m4' builtin `dnl' prevents a newline from being inserted in the
  1745. output where the macro is defined; without it, the generated
  1746. `configure' script would begin with dozens of blank lines.  `dnl' is
  1747. also used to introduce comments in `m4'; it causes `m4' to discard the
  1748. rest of the input line.
  1749.  
  1750.    You should quote the entire macro body with square brackets to avoid
  1751. macro expansion problems (*note Quoting::.).  You can refer to any
  1752. arguments passed to the macro as `$1', `$2', etc.
  1753.  
  1754.    *Note How to define new macros: (m4.info)Definitions, for more
  1755. complete information on writing `m4' macros.
  1756.  
  1757. 
  1758. File: autoconf.info,  Node: Quoting,  Next: Dependencies Between Macros,  Prev: Macro Format,  Up: Writing Macros
  1759.  
  1760. Quoting
  1761. =======
  1762.  
  1763.    Macros that are called by other macros are evaluated by `m4' several
  1764. times; each evaluation might require another layer of quotes to prevent
  1765. unwanted expansions of macros or `m4' builtins, such as `define' and
  1766. `$1'.  Quotes are also required around macro arguments that contain
  1767. commas, since commas separate the arguments from each other.
  1768.  
  1769.    Autoconf (in `acgeneral.m4') changes the `m4' quote characters from
  1770. the default ``' and `'' to `[' and `]', because many of the macros use
  1771. ``' and `'', mismatched.  However, in a few places the macros need to
  1772. use brackets.  In those places, they use the `m4' builtin command
  1773. `changequote' to temporarily disable quoting before the code that uses
  1774. brackets, like this:
  1775.  
  1776.      changequote(,)dnl
  1777.  
  1778. Then they turn quoting back on again with another call to `changequote':
  1779.  
  1780.      changequote([,])dnl
  1781.  
  1782.    When you create a `configure' script using newly written macros,
  1783. examine it carefully to check whether you need to add more quotes in
  1784. your macros.  If one or more words have disappeared in the `m4' output,
  1785. you need more quotes.  When in doubt, quote.
  1786.  
  1787.    However, it's also possible to put on too many layers of quotes.  If
  1788. this happens, the resulting `configure' script will contain unexpanded
  1789. macros.  The `autoconf' program checks for this problem by doing `grep
  1790. AC_ configure'.
  1791.  
  1792. 
  1793. File: autoconf.info,  Node: Dependencies Between Macros,  Next: Checking for Files,  Prev: Quoting,  Up: Writing Macros
  1794.  
  1795. Dependencies Between Macros
  1796. ===========================
  1797.  
  1798.    Some Autoconf macros depend on other macros having been called first
  1799. in order to work correctly.  Autoconf provides a way to ensure that
  1800. certain macros are called if needed and a way to warn the user if
  1801. macros are called in an order that might cause incorrect operation.
  1802.  
  1803. * Menu:
  1804.  
  1805. * Prerequisite Macros::        Ensuring required information.
  1806. * Suggested Ordering::        Warning about possible ordering problems.
  1807.  
  1808. 
  1809. File: autoconf.info,  Node: Prerequisite Macros,  Next: Suggested Ordering,  Up: Dependencies Between Macros
  1810.  
  1811. Prerequisite Macros
  1812. -------------------
  1813.  
  1814.    A macro that you write might need to use values that have previously
  1815. been computed by other macros.  For example, if you write a new macro
  1816. that uses the C preprocessor, it depends on `AC_PROG_CPP' having been
  1817. called first to set the shell variable `CPP' (*note Alternative
  1818. Programs::.).
  1819.  
  1820.    Rather than forcing the user of the macros to keep track of all of
  1821. the dependencies between them, you can use the macros `AC_PROVIDE' and
  1822. `AC_REQUIRE' to do it automatically.  *Note Macro Ordering::, for more
  1823. information on their syntax.
  1824.  
  1825.    The new macro that runs the C preprocessor should contain, somewhere
  1826. before `CPP' is used, the statement
  1827.  
  1828.      AC_REQUIRE([AC_PROG_CPP])
  1829.  
  1830. and the macro `AC_PROG_CPP' should contain the statement (anywhere in
  1831. its body)
  1832.  
  1833.      AC_PROVIDE([$0])
  1834.  
  1835. Then, when the new macro is run, it will invoke `AC_PROG_CPP' if and
  1836. only if `AC_PROG_CPP' has not already been run.
  1837.  
  1838. 
  1839. File: autoconf.info,  Node: Suggested Ordering,  Prev: Prerequisite Macros,  Up: Dependencies Between Macros
  1840.  
  1841. Suggested Ordering
  1842. ------------------
  1843.  
  1844.    Some macros should be run before another macro if both are called,
  1845. but neither requires the other to be called.  For example, a macro like
  1846. `AC_AIX' that changes the behavior of the C compiler (*note UNIX
  1847. Variants::.) should be called before any macros that run the C compiler.
  1848. Many of these dependencies are noted in the documentation.
  1849.  
  1850.    Autoconf provides a way to warn users when macros with this kind of
  1851. dependency appear out of order in a `configure.in' file.  The warning
  1852. occurs when creating `configure' from `configure.in', not when running
  1853. `configure'.  It is not a fatal error; `configure' is created as usual.
  1854.  
  1855.    The `AC_BEFORE' macro causes `m4' to print a warning message on the
  1856. standard error output when a macro is used before another macro which
  1857. might change its behavior.  The macro which should come first should
  1858. contain a call to `AC_BEFORE' and the macro which should come later
  1859. should contain a call to `AC_PROVIDE'.
  1860.  
  1861.    For example, `AC_AIX' contains
  1862.  
  1863.      AC_BEFORE([$0], [AC_COMPILE_CHECK])
  1864.  
  1865. and `AC_COMPILE_CHECK' contains
  1866.  
  1867.      AC_PROVIDE([$0])
  1868.  
  1869. As a result, if `AC_AIX' is called after `AC_COMPILE_CHECK', it will
  1870. note that `AC_COMPILE_CHECK' has already been called and print a
  1871. warning message.
  1872.  
  1873. 
  1874. File: autoconf.info,  Node: Checking for Files,  Next: Checking for Symbols,  Prev: Dependencies Between Macros,  Up: Writing Macros
  1875.  
  1876. Checking for Files
  1877. ==================
  1878.  
  1879.    If you need to check whether a file other than a C header file
  1880. exists, use `test -f FILENAME'.  If you need to make multiple checks
  1881. using `test', combine them with the shell operators `&&' and `||'
  1882. instead of using the `test' operators `-a' and `-o'.  On System V, the
  1883. precedence of `-a' and `-o' is wrong relative to the unary operators;
  1884. consequently, POSIX does not specify them, so using them is
  1885. nonportable.  If you combine `&&' and `||' in the same statement, keep
  1886. in mind that they have equal precedence.
  1887.  
  1888.    Do not use `test -x', because 4.3BSD does not have it.  Use `test
  1889. -f' or `test -r' instead.
  1890.  
  1891. 
  1892. File: autoconf.info,  Node: Checking for Symbols,  Next: Test Programs,  Prev: Checking for Files,  Up: Writing Macros
  1893.  
  1894. Checking for Symbols
  1895. ====================
  1896.  
  1897.    If you need to check whether a symbol is defined in a C header file,
  1898. you can use `AC_HEADER_EGREP' if the symbol is not a C preprocessor
  1899. macro (*note General Feature Tests::.), or compile a small test program
  1900. that includes the file and references the symbol (*note Test
  1901. Programs::.).  Don't directly `grep' for the symbol in the file,
  1902. because on some systems it might be defined in another header file that
  1903. the file you are checking `#include's.
  1904.  
  1905.    However, if you need to check for a particular UNIX variant which is
  1906. distinguished by having certain text in a certain file, then use `grep'
  1907. (or `egrep').  But don't use `grep -s' to suppress output, because
  1908. `grep -s' on System V does not suppress output, only error messages.
  1909. Instead, redirect the standard output and standard error (in case the
  1910. file doesn't exist) of `grep' to `/dev/null'.  Check the exit status of
  1911. `grep' to determine whether it found a match.
  1912.  
  1913.    To check whether the Autoconf macros have already defined a certain C
  1914. preprocessor symbol, you can use a `case' statement like this:
  1915.  
  1916.      case "$DEFS" in
  1917.        *HAVE_FOO*) ;;
  1918.        *) LIBOBJS="$LIBOBJS foo.o" ;;
  1919.      esac
  1920.  
  1921. Make sure to enclose the variable name you are checking (usually
  1922. `DEFS') in double quotes, because otherwise some old versions of `bash'
  1923. misinterpret the statement.
  1924.  
  1925. 
  1926. File: autoconf.info,  Node: Test Programs,  Next: Multiple Cases,  Prev: Checking for Symbols,  Up: Writing Macros
  1927.  
  1928. Test Programs
  1929. =============
  1930.  
  1931.    Autoconf checks for many features by compiling small test programs.
  1932. To find out whether a library function is available, Autoconf tries to
  1933. compile a small program that uses it.  This is unlike Larry Wall's
  1934. Metaconfig, which uses `nm' or `ar' on the C library to try to figure
  1935. out which functions are available.  Trying to link with the function is
  1936. usually a more reliable and flexible approach because it avoids dealing
  1937. with the variations in the options and output formats of `nm' and `ar'
  1938. and in the location of the standard libraries.  It also allows
  1939. `configure' to check aspects of the function's runtime behavior if
  1940. needed.  On the other hand, it is sometimes slower than scanning the
  1941. libraries.
  1942.  
  1943.    If you need to check for a condition other than whether some symbol
  1944. exists on the system or has a certain value, then you can't use
  1945. `AC_COMPILE_CHECK' (*note General Feature Tests::.).  You have to write
  1946. a test program by hand.  You can compile and run it using
  1947. `AC_TEST_PROGRAM' (*note General Feature Tests::.).
  1948.  
  1949.    Try to avoid writing test programs if possible, because using them
  1950. prevents people from configuring your package for cross-compiling.  If
  1951. it's really best that you test for a run-time behavior, try to provide a
  1952. default "worst case" value to use when cross-compiling makes run-time
  1953. tests impossible.  You do this by passing the optional last argument to
  1954. `AC_TEST_PROGRAM'.
  1955.  
  1956. * Menu:
  1957.  
  1958. * Guidelines::            General rules for writing test programs.
  1959. * Tricks::            Special ways to work around problems.
  1960.  
  1961. 
  1962. File: autoconf.info,  Node: Guidelines,  Next: Tricks,  Up: Test Programs
  1963.  
  1964. Guidelines for Test Programs
  1965. ----------------------------
  1966.  
  1967.    Test programs should return 0 if the test succeeds, nonzero
  1968. otherwise, so that success can be distinguished easily from a core dump
  1969. or other failure; segmentation violations and other failures produce a
  1970. nonzero exit status.  Test programs should `exit', not `return', from
  1971. `main', because on some systems the argument to `return' in `main' is
  1972. ignored.  They should not write anything to the standard output.
  1973.  
  1974.    Test programs can use `#if' or `#ifdef' to check the values of
  1975. preprocessor macros defined by tests that have already run.  For
  1976. example, if you call `AC_STDC_HEADERS', then later on in `configure.in'
  1977. you can have a test program that includes an ANSI C header file
  1978. conditionally:
  1979.  
  1980.      #if STDC_HEADERS
  1981.      #include <stdlib.h>
  1982.      #endif
  1983.  
  1984.    If a test program needs to use or create a data file, give it a name
  1985. that starts with `conftest', such as `conftestdata'.  The `configure'
  1986. script cleans up by running `rm -rf conftest*' after running test
  1987. programs and if the script is interrupted.
  1988.  
  1989. 
  1990. File: autoconf.info,  Node: Tricks,  Prev: Guidelines,  Up: Test Programs
  1991.  
  1992. Tricks for Test Programs
  1993. ------------------------
  1994.  
  1995.    If a test program calls a function with invalid parameters (just to
  1996. see whether it exists), organize the program to ensure that it never
  1997. invokes that function.  You can do this by calling it in another
  1998. function that is never invoked.  You can't do it by putting it after a
  1999. call to `exit', because GCC version 2 knows that `exit' never returns
  2000. and optimizes out any code that follows it in the same block.
  2001.  
  2002.    If you include any header files, make sure to call the functions
  2003. relevant to them with the correct number of arguments, even if they are
  2004. just 0, to avoid compilation errors due to prototypes.  GCC version 2
  2005. has internal prototypes for several functions that it automatically
  2006. inlines; for example, `memcpy'.  To avoid errors when checking for
  2007. them, either pass them the correct number of arguments or redeclare them
  2008. with a different return type (such as `char').
  2009.  
  2010. 
  2011. File: autoconf.info,  Node: Multiple Cases,  Prev: Test Programs,  Up: Writing Macros
  2012.  
  2013. Multiple Cases
  2014. ==============
  2015.  
  2016.    Some operations are accomplished in several possible ways, depending
  2017. on the UNIX variant.  Checking for them essentially requires a "case
  2018. statement".  Autoconf does not directly provide one; however, it is
  2019. easy to simulate by using a shell variable to keep track of whether a
  2020. way to perform the operation has been found yet.
  2021.  
  2022.    Here is an example excerpted from the `configure.in' for GNU `find'.
  2023. It uses the shell variable `fstype' to keep track of whether the
  2024. remaining cases need to be checked.  There are several more cases which
  2025. are not shown here but follow the same pattern.
  2026.  
  2027.      echo checking how to get filesystem type
  2028.      # SVR4.
  2029.      AC_TEST_CPP([#include <sys/statvfs.h>
  2030.      #include <sys/fstyp.h>], AC_DEFINE(FSTYPE_STATVFS) fstype=1)
  2031.      if test -z "$fstype"; then
  2032.      # SVR3.
  2033.      AC_TEST_CPP([#include <sys/statfs.h>
  2034.      #include <sys/fstyp.h>], AC_DEFINE(FSTYPE_USG_STATFS) fstype=1)
  2035.      fi
  2036.      if test -z "$fstype"; then
  2037.      # AIX.
  2038.      AC_TEST_CPP([#include <sys/statfs.h>
  2039.      #include <sys/vmount.h>], AC_DEFINE(FSTYPE_AIX_STATFS) fstype=1)
  2040.      fi
  2041.  
  2042. 
  2043. File: autoconf.info,  Node: Makefiles,  Next: Invoking configure,  Prev: Writing Macros,  Up: Top
  2044.  
  2045. Makefiles
  2046. *********
  2047.  
  2048.    Each subdirectory in a distribution should come with a file
  2049. `Makefile.in', from which `configure' will produce a `Makefile' in that
  2050. directory.  Most of the substitutions that `configure' does are simple:
  2051. for each configuration variable that the package uses, it just replaces
  2052. occurrences of `@VARIABLE@' with the value that `configure' has
  2053. determined for that variable.  Any occurrences of `@VARIABLE@' for
  2054. variables that `configure' does not know about are passed through
  2055. unchanged.
  2056.  
  2057.    There is no point in checking for the correct value to give a
  2058. variable that is never used.  Every variable that the `configure' script
  2059. might set a value for should appear in a `@VARIABLE@' reference in at
  2060. least one `Makefile.in'.  If `AC_CONFIG_HEADER' is called, `configure'
  2061. replaces `@DEFS@' with `-DHAVE_CONFIG_H', since the contents of `DEFS'
  2062. would be redundant.
  2063.  
  2064.    *Note Makefile Conventions: (standards.info)Makefiles, for more
  2065. information on what to put in Makefiles.  *Note Sample Makefile.in::,
  2066. for an example of a real `Makefile.in'.
  2067.  
  2068. * Menu:
  2069.  
  2070. * Predefined Variables::    Heavily used `make' variables.
  2071. * Installation Prefixes::    A special variable substitution.
  2072. * VPATH Substitutions::        Compiling in a different directory.
  2073. * Automatic Remaking::        Makefile rules for configuring.
  2074.  
  2075. 
  2076. File: autoconf.info,  Node: Predefined Variables,  Next: Installation Prefixes,  Up: Makefiles
  2077.  
  2078. Predefined Variables
  2079. ====================
  2080.  
  2081.    Some `make' variables are predefined by the Autoconf macros.
  2082. `AC_SUBST' is called for them automatically (*note Setting
  2083. Variables::.), so in your `Makefile.in' files you can get their values
  2084. by enclosing their names in `@' characters.  *Note Makefiles::, for
  2085. more information on `@' substitutions.  The variables that are defined
  2086. by the general purpose Autoconf macros are:
  2087.  
  2088.  - Variable: exec_prefix
  2089.      The installation prefix for architecture-specific files.
  2090.  
  2091.  - Variable: prefix
  2092.      The installation prefix for architecture-independent files.  *Note
  2093.      Installation Prefixes::, for an alternate way to set this variable.
  2094.  
  2095.  - Variable: srcdir
  2096.      The directory that contains the source code for that `Makefile'.
  2097.      *Note Installation Prefixes::, for an alternate way to set this
  2098.      variable.
  2099.  
  2100.  - Variable: top_srcdir
  2101.      The top-level source code directory for the package.  In the
  2102.      top-level directory, this is the same as `srcdir'.
  2103.  
  2104.  - Variable: DEFS
  2105.      `-D' options to pass to the C compiler.  If `AC_CONFIG_HEADER' is
  2106.      called, `configure' replaces `@DEFS@' with `-DHAVE_CONFIG_H',
  2107.      since the contents of `DEFS' would be redundant.
  2108.  
  2109.  - Variable: LIBS
  2110.      `-l' and `-L' options to pass to the linker.
  2111.  
  2112.  - Variable: LIBOBJS
  2113.      Names of object files (ending in `.o').  Set by `AC_REPLACE_FUNCS'
  2114.      (*note General Feature Tests::.).
  2115.  
  2116. 
  2117. File: autoconf.info,  Node: Installation Prefixes,  Next: VPATH Substitutions,  Prev: Predefined Variables,  Up: Makefiles
  2118.  
  2119. Installation Prefixes
  2120. =====================
  2121.  
  2122.    Autoconf-generated `configure' scripts support an alternate method
  2123. for substituting two particular variables, for compatibility with
  2124. Cygnus `configure'.  This method is not recommended.
  2125.  
  2126.    If `configure' has figured out a value for the installation prefix,
  2127. either by the user supplying one on the command line (*note Invoking
  2128. configure::.) or with `AC_PREFIX' (*note General Feature Tests::.),
  2129. then it substitutes that value in `Makefile's that it creates.
  2130. Wherever a `Makefile.in' contains lines like
  2131.  
  2132.      prefix = /usr/local
  2133.      exec_prefix = ${prefix}
  2134.  
  2135. `configure' substitutes the value it figured out.  The substitution
  2136. only occurs if the word `prefix' or `exec_prefix' is not preceded by
  2137. any other characters on the line, and `configure' has figured out a
  2138. value for the prefix.
  2139.  
  2140.    There can be separate installation prefixes for architecture-specific
  2141. files (`exec_prefix') and architecture-independent files (`prefix').
  2142. *Note Invoking configure::, for more information on setting them.
  2143.  
  2144.    Autoconf `configure' scripts replace these two variables without
  2145. requiring them to be enclosed in `@' characters, and only if they have
  2146. been set, because the Cygnus `configure' does so.  In retrospect, being
  2147. compatible in this way was a bad decision, because it created an
  2148. inconsistency in Autoconf without giving significant benefits.
  2149.  
  2150. 
  2151. File: autoconf.info,  Node: VPATH Substitutions,  Next: Automatic Remaking,  Prev: Installation Prefixes,  Up: Makefiles
  2152.  
  2153. `VPATH' Substitutions
  2154. =====================
  2155.  
  2156.    You might want to compile a software package in a different directory
  2157. from the one that contains the source code.  Doing this allows you to
  2158. compile the package for several architectures simultaneously from the
  2159. same copy of the source code and keep multiple sets of object files on
  2160. disk.
  2161.  
  2162.    To support doing this, `make' uses the `VPATH' variable to find the
  2163. files that are in the source directory.  GNU `make' and most other
  2164. recent `make' programs can do this.  Older `make' programs do not
  2165. support `VPATH'; when using them, the source code must be in the same
  2166. directory as the object files.
  2167.  
  2168.    To support `VPATH', each `Makefile.in' should contain two lines that
  2169. look like:
  2170.  
  2171.      srcdir = @srcdir@
  2172.      VPATH = @srcdir@
  2173.  
  2174.    Do not set `VPATH' to the value of another variable, for example
  2175. `VPATH = $(srcdir)', because some versions of `make' do not do variable
  2176. substitutions on the value of `VPATH'.
  2177.  
  2178.    `configure' substitutes in the correct value for `srcdir' when it
  2179. produces `Makefile.in'.
  2180.  
  2181.    Do not use the `make' variable `$<', which expands to the pathname
  2182. of the file in the source directory (found with `VPATH'), except in
  2183. implicit rules.  (An implicit rule is one such as `.c.o', which tells
  2184. how to create a `.o' file from a `.c' file.)  Some versions of `make'
  2185. do not set `$<' in explicit rules; they expand it to an empty value.
  2186.  
  2187.    Instead, `Makefile' command lines should always refer to source
  2188. files by prefixing them with `$(srcdir)/'.  For example:
  2189.  
  2190.      time.info: time.texinfo
  2191.              $(MAKEINFO) $(srcdir)/time.texinfo
  2192.  
  2193. 
  2194. File: autoconf.info,  Node: Automatic Remaking,  Prev: VPATH Substitutions,  Up: Makefiles
  2195.  
  2196. Automatic Remaking
  2197. ==================
  2198.  
  2199.    You can put rules like the following in the top-level `Makefile.in'
  2200. for a package to automatically update the configuration information when
  2201. you change the configuration files.  This example includes all of the
  2202. optional files, such as `aclocal.m4' and those related to configuration
  2203. header files.  Omit from the `Makefile.in' rules any of these files
  2204. that your package does not use.
  2205.  
  2206.    The `stamp-' files are necessary because the timestamps of
  2207. `config.h.in' and `config.h' will not be changed if remaking them does
  2208. not change their contents.  This feature avoids unnecessary
  2209. recompilation.  You should include the file `stamp-h.in' your package's
  2210. distribution, so `make' will consider `config.h.in' up to date.
  2211.  
  2212.      configure: configure.in aclocal.m4
  2213.              cd ${srcdir}; autoconf
  2214.      
  2215.      # autoheader might not change config.h.in
  2216.      config.h.in: stamp-h.in
  2217.      stamp-h.in: configure.in aclocal.m4 acconfig.h config.h.top
  2218.              cd ${srcdir}; autoheader
  2219.              touch ${srcdir}/stamp-h.in
  2220.      
  2221.      # config.status might not change config.h
  2222.      config.h: stamp-h
  2223.      stamp-h: config.h.in config.status
  2224.              ./config.status
  2225.              touch stamp-h
  2226.      
  2227.      Makefile: Makefile.in config.status
  2228.              ./config.status
  2229.      
  2230.      config.status: configure
  2231.              ./config.status --recheck
  2232.  
  2233.    *Note Invoking config.status::, for more information on handling
  2234. configuration-related dependencies.
  2235.  
  2236. 
  2237. File: autoconf.info,  Node: Invoking configure,  Next: Example,  Prev: Makefiles,  Up: Top
  2238.  
  2239. Running `configure' Scripts
  2240. ***************************
  2241.  
  2242.    A software package that uses a `configure' script should be
  2243. distributed with a file `Makefile.in', but no `Makefile'; that way, the
  2244. user has to properly configure the package for the local system before
  2245. compiling it.  Here is how to configure a package that uses a
  2246. `configure' script.
  2247.  
  2248.    Normally, you just `cd' to the directory containing the package's
  2249. source code and type `./configure'.  If you're using `csh' on an old
  2250. version of System V, you might need to type `sh configure' instead to
  2251. prevent `csh' from trying to execute `configure' itself.
  2252.  
  2253.    Running `configure' takes a minute or two.  While it is running, it
  2254. prints some messages that tell what it is doing.  If you don't want to
  2255. see any messages, run `configure' with its standard output redirected
  2256. to `/dev/null'; for example, `./configure >/dev/null'.
  2257.  
  2258.    To compile the package in a different directory from the one
  2259. containing the source code, you must use a version of `make' that
  2260. supports the `VPATH' variable, such as GNU `make'.  `cd' to the
  2261. directory where you want the object files and executables to go and run
  2262. the `configure' script.  `configure' automatically checks for the
  2263. source code in the directory that `configure' is in and in `..'.  If
  2264. for some reason `configure' is not in the source code directory that
  2265. you are configuring, then it will report that it can't find the source
  2266. code.  In that case, run `configure' with the option `--srcdir=DIR',
  2267. where DIR is the directory that contains the source code.
  2268.  
  2269.    By default, `make install' will install the package's files in
  2270. `/usr/local/bin', `/usr/local/man', etc.  You can specify an
  2271. installation prefix other than `/usr/local' by giving `configure' the
  2272. option `--prefix=PATH'.  Alternately, you can do so by consistently
  2273. giving a value for the `prefix' variable when you run `make', e.g.,
  2274.      make prefix=/usr/gnu
  2275.      make prefix=/usr/gnu install
  2276.  
  2277.    You can specify separate installation prefixes for
  2278. architecture-specific files and architecture-independent files.  If you
  2279. give `configure' the option `--exec-prefix=PATH' or set the `make'
  2280. variable `exec_prefix' to PATH, the package will use PATH as the prefix
  2281. for installing programs and libraries.  Data files and documentation
  2282. will still use the regular prefix.  Normally, all files are installed
  2283. using the same prefix.
  2284.  
  2285.    Some packages pay attention to `--with-PACKAGE' options to
  2286. `configure', where PACKAGE is something like `gnu-as' or `x' (for the X
  2287. Window System).  They may also pay attention to `--enable-FEATURE'
  2288. options, where FEATURE indicates an optional part of the package.  The
  2289. README should mention any `--with-' and `--enable-' options that the
  2290. package recognizes.
  2291.  
  2292.    `configure' also recognizes the following options:
  2293.  
  2294. `--help'
  2295.      Print a summary of the options to `configure', and exit.
  2296.  
  2297. `--quiet'
  2298. `--silent'
  2299.      Do not print messages saying which checks are being made.
  2300.  
  2301. `--verbose'
  2302.      Print the results of the checks.
  2303.  
  2304. `--version'
  2305.      Print the version of Autoconf used to generate the `configure'
  2306.      script, and exit.
  2307.  
  2308. `--x-includes=DIR'
  2309.      X include files are in DIR.
  2310.  
  2311. `--x-libraries=DIR'
  2312.      X library files are in DIR.
  2313.  
  2314.    `configure' also accepts and ignores some other options.
  2315.  
  2316. * Menu:
  2317.  
  2318. * Overriding variables::        Workarounds for unusual systems.
  2319. * Invoking config.status::      Recreating a configuration.
  2320.  
  2321. 
  2322. File: autoconf.info,  Node: Overriding variables,  Next: Invoking config.status,  Up: Invoking configure
  2323.  
  2324. Overriding variables
  2325. ====================
  2326.  
  2327.    On systems that require unusual options for compilation or linking
  2328. that the package's `configure' script does not know about, you can give
  2329. `configure' initial values for variables by setting them in the
  2330. environment.  In Bourne-compatible shells, you can do that on the
  2331. command line like this:
  2332.  
  2333.      CC='gcc -traditional' LIBS=-lposix ./configure
  2334.  
  2335. On systems that have the `env' program, you can do it like this:
  2336.  
  2337.      env CC='gcc -traditional' LIBS=-lposix ./configure
  2338.  
  2339.    Here are the `make' variables that you might want to override with
  2340. environment variables when running `configure'.
  2341.  
  2342.    For these variables, any value given in the environment overrides the
  2343. value that `configure' would choose:
  2344.  
  2345.  - Variable: CC
  2346.      C compiler program.  The default is `cc'.
  2347.  
  2348.  - Variable: INSTALL
  2349.      Program to use to install files.  The default is `install' if you
  2350.      have it, `cp' otherwise.
  2351.  
  2352.    For these variables, any value given in the environment is added to
  2353. the value that `configure' chooses:
  2354.  
  2355.  - Variable: DEFS
  2356.      Configuration options, in the form `-Dfoo -Dbar...'.  Do not use
  2357.      this variable in packages that create a configuration header file.
  2358.  
  2359.  - Variable: LIBS
  2360.      Libraries to link with, in the form `-lfoo -lbar...'.
  2361.  
  2362.    In the long term, most problems requiring manual intervention should
  2363. be fixed by updating either the Autoconf macros or the `configure.in'
  2364. file for that package.  *Note Making configure Scripts::, for a
  2365. discussion of that subject.
  2366.  
  2367. 
  2368. File: autoconf.info,  Node: Invoking config.status,  Prev: Overriding variables,  Up: Invoking configure
  2369.  
  2370. Recreating a Configuration
  2371. ==========================
  2372.  
  2373.    The `configure' script creates a file named `config.status' which
  2374. describes which configuration options were specified when the package
  2375. was last configured.  This file is a shell script which, if run, will
  2376. recreate the same configuration.
  2377.  
  2378.    You can give `config.status' the `--recheck' option to update
  2379. itself.  This option is useful if you change `configure', so that the
  2380. results of some tests might be different from the previous run.  The
  2381. `--recheck' option re-runs `configure' with the same arguments you used
  2382. before, plus the `--no-create' option, which prevents `configure' from
  2383. running `config.status' and creating `Makefile' and other files.  (This
  2384. is so other `Makefile' rules can run `config.status' when it changes;
  2385. *note Automatic Remaking::., for an example).
  2386.  
  2387.    `config.status' also accepts the options `--help', which prints a
  2388. summary of the options to `config.status', and `--version', which
  2389. prints the version of Autoconf used to create the `configure' script
  2390. that generated `config.status'.
  2391.  
  2392.    `config.status' checks several optional environment variables that
  2393. can alter its behavior:
  2394.  
  2395.  - Variable: CONFIG_SHELL
  2396.      The shell with which to run `configure' for the `--recheck'
  2397.      option.  The default is `/bin/sh'.
  2398.  
  2399.    The following two variables provide one way for separately
  2400. distributed packages to share the values computed by `configure'.
  2401. Doing so can be useful if some of the packages need a superset of the
  2402. features that one of them, perhaps a common library, does.  These
  2403. variables allow a `config.status' file to create files other than the
  2404. ones that its `configure.in' specifies, so it can be used for a
  2405. different package.
  2406.  
  2407.  - Variable: CONFIG_FILES
  2408.      The files in which to perform `@VARIABLE@' substitutions.  The
  2409.      default is the arguments given to `AC_OUTPUT' in `configure.in'.
  2410.  
  2411.  - Variable: CONFIG_HEADERS
  2412.      The files in which to substitute C `#define' statements.  The
  2413.      default is the arguments given to `AC_CONFIG_HEADER'; if that
  2414.      macro was not called, `config.status' ignores this variable.
  2415.  
  2416.    These variables also allow you to write `Makefile' rules that
  2417. regenerate only some of the files.  For example, in the dependencies
  2418. given above (*note Automatic Remaking::.), `config.status' is run twice
  2419. when `configure.in' has changed.  If that bothers you, you can make
  2420. each run only regenerate the files for that rule:
  2421.  
  2422.      # config.status might not change config.h
  2423.      config.h: stamp-h
  2424.      stamp-h: config.h.in config.status
  2425.              CONFIG_FILES= CONFIG_HEADERS=config.h ./config.status
  2426.              touch stamp-h
  2427.      
  2428.      Makefile: Makefile.in config.status
  2429.              CONFIG_FILES=Makefile CONFIG_HEADERS= ./config.status
  2430.  
  2431. (If `configure.in' does not call `AC_CONFIG_HEADER', there is no need
  2432. to set `CONFIG_HEADERS' in the `make' rules.)
  2433.  
  2434. 
  2435. File: autoconf.info,  Node: Example,  Next: Preprocessor Symbol Index,  Prev: Invoking configure,  Up: Top
  2436.  
  2437. An Example
  2438. **********
  2439.  
  2440.    Here are sample `configure.in' and `Makefile.in' files, to give a
  2441. real illustration of using Autoconf.  They are from the GNU `cpio'
  2442. package, which also includes the `mt' and `rmt' programs.  This package
  2443. does not use a configuration header file; it passes `-D' options to the
  2444. C compiler on the command line.
  2445.  
  2446. * Menu:
  2447.  
  2448. * Sample configure.in::        An example of a `configure' template.
  2449. * Sample Makefile.in::        An example of a `Makefile' template.
  2450.  
  2451. 
  2452. File: autoconf.info,  Node: Sample configure.in,  Next: Sample Makefile.in,  Up: Example
  2453.  
  2454. Sample `configure.in'
  2455. =====================
  2456.  
  2457. Here is `configure.in' from GNU `cpio'.  The `dnl' macro after
  2458. `AC_SUBST' is suppresses an extra (though harmless) newline in the
  2459. generated `configure' script (because the `AC_SUBST' macro does not
  2460. produce any output where it is called).
  2461.  
  2462.      dnl Process this file with autoconf to produce a configure script.
  2463.      AC_INIT(cpio.h)
  2464.      PROGS="cpio"
  2465.      AC_SUBST(PROGS)dnl
  2466.      AC_PROG_CC
  2467.      AC_PROG_CPP
  2468.      AC_GCC_TRADITIONAL
  2469.      AC_PROG_INSTALL
  2470.      AC_AIX
  2471.      AC_MINIX
  2472.      AC_ISC_POSIX
  2473.      AC_RETSIGTYPE
  2474.      AC_MAJOR_HEADER
  2475.      AC_REMOTE_TAPE
  2476.      test -n "$have_mtio" && PROGS="$PROGS mt"
  2477.      AC_RSH
  2478.      AC_CONST
  2479.      AC_UID_T
  2480.      AC_STDC_HEADERS
  2481.      AC_HAVE_HEADERS(string.h fcntl.h utime.h unistd.h sys/io/trioctl.h)
  2482.      AC_REPLACE_FUNCS(fnmatch bcopy mkdir strdup)
  2483.      AC_HAVE_FUNCS(strerror lchown)
  2484.      AC_VPRINTF
  2485.      AC_ALLOCA
  2486.      AC_XENIX_DIR
  2487.      AC_HAVE_LIBRARY(socket, [LIBS="$LIBS -lsocket"])
  2488.      AC_HAVE_LIBRARY(nsl, [LIBS="$LIBS -lnsl"])
  2489.      AC_OUTPUT(Makefile)
  2490.  
  2491. 
  2492. File: autoconf.info,  Node: Sample Makefile.in,  Prev: Sample configure.in,  Up: Example
  2493.  
  2494. Sample `Makefile.in'
  2495. ====================
  2496.  
  2497. Here is `Makefile.in' from GNU `cpio', with some irrelevant lines
  2498. omitted, for brevity.
  2499.  
  2500.      srcdir = @srcdir@
  2501.      VPATH = @srcdir@
  2502.      
  2503.      CC = @CC@
  2504.      
  2505.      INSTALL = @INSTALL@
  2506.      INSTALL_PROGRAM = @INSTALL_PROGRAM@
  2507.      INSTALL_DATA = @INSTALL_DATA@
  2508.      
  2509.      DEFS = @DEFS@
  2510.      LIBS = @LIBS@
  2511.      RTAPELIB = @RTAPELIB@
  2512.      
  2513.      CFLAGS = -g
  2514.      LDFLAGS = -g
  2515.      
  2516.      prefix = /usr/local
  2517.      exec_prefix = $(prefix)
  2518.      binprefix =
  2519.      manprefix =
  2520.      
  2521.      bindir = $(exec_prefix)/bin
  2522.      libdir = $(exec_prefix)/lib
  2523.      mandir = $(prefix)/man/man1
  2524.      manext = 1
  2525.      
  2526.      SHELL = /bin/sh
  2527.      
  2528.      SRCS = copyin.c copyout.c copypass.c defer.c dstring.c global.c \
  2529.      main.c tar.c util.c error.c getopt.c getopt1.c filemode.c version.c \
  2530.      rtapelib.c dirname.c idcache.c makepath.c xmalloc.c stripslash.c \
  2531.      userspec.c xstrdup.c bcopy.c fnmatch.c mkdir.c strdup.c
  2532.      OBJS = copyin.o copyout.o copypass.o defer.o dstring.o global.o \
  2533.      main.o tar.o util.o error.o getopt.o getopt1.o filemode.o version.o \
  2534.      $(RTAPELIB) dirname.o idcache.o makepath.o xmalloc.o stripslash.o \
  2535.      userspec.o xstrdup.o @LIBOBJS@ @ALLOCA@
  2536.      # mt source files not shared with cpio.
  2537.      MT_SRCS = mt.c argmatch.c
  2538.      MT_OBJS = mt.o argmatch.o error.o getopt.o getopt1.o \
  2539.      xmalloc.o version.o $(RTAPELIB) @ALLOCA@
  2540.      HDRS = cpio.h cpiohdr.h tar.h tarhdr.h defer.h dstring.h extern.h filetypes.h \
  2541.      system.h fnmatch.h getopt.h rmt.h
  2542.      DISTFILES = $(SRCS) $(HDRS) COPYING COPYING.LIB ChangeLog Makefile.in \
  2543.      README NEWS INSTALL cpio.1 mt.1 makefile.pc makefile.os2 cpio.def \
  2544.      configure configure.in mkinstalldirs $(MT_SRCS) rmt.c tcexparg.c alloca.c
  2545.      
  2546.      all: @PROGS@
  2547.      
  2548.      .c.o:
  2549.              $(CC) -c $(CPPFLAGS) $(DEFS) -I$(srcdir) $(CFLAGS) $<
  2550.      
  2551.      install: installdirs all $(srcdir)/cpio.1 $(srcdir)/mt.1
  2552.              $(INSTALL_PROGRAM) cpio $(bindir)/$(binprefix)cpio
  2553.              test ! -f mt || $(INSTALL_PROGRAM) mt $(bindir)/$(binprefix)mt
  2554.              -test ! -f rmt || $(INSTALL_PROGRAM) rmt $(libdir)/rmt
  2555.              $(INSTALL_DATA) $(srcdir)/cpio.1 $(mandir)/$(manprefix)cpio.$(manext)
  2556.              test ! -f mt || \
  2557.              $(INSTALL_DATA) $(srcdir)/mt.1 $(mandir)/$(manprefix)mt.$(manext)
  2558.      
  2559.      installdirs:
  2560.              $(srcdir)/mkinstalldirs $(bindir) $(libdir) $(mandir)
  2561.      
  2562.      uninstall:
  2563.              cd $(bindir); rm -f $(binprefix)cpio $(binprefix)mt
  2564.              -rm -f $(libdir)/rmt
  2565.              cd $(mandir); rm -f $(manprefix)cpio.$(manext) $(manprefix)mt.$(manext)
  2566.      
  2567.      check:
  2568.              @echo No tests are supplied.
  2569.      
  2570.      cpio: $(OBJS)
  2571.              $(CC) $(LDFLAGS) -o $@ $(OBJS) $(LIBS)
  2572.      
  2573.      rmt: rmt.o
  2574.              $(CC) $(LDFLAGS) -o $@ rmt.o $(LIBS)
  2575.      
  2576.      mt: $(MT_OBJS)
  2577.              $(CC) $(LDFLAGS) -o $@ $(MT_OBJS) $(LIBS)
  2578.      
  2579.      Makefile: Makefile.in config.status
  2580.              $(SHELL) config.status
  2581.      config.status: configure
  2582.              $(SHELL) config.status --recheck
  2583.      configure: configure.in
  2584.              cd $(srcdir); autoconf
  2585.      
  2586.      TAGS: $(SRCS)
  2587.              etags $(SRCS)
  2588.      
  2589.      clean:
  2590.              rm -f cpio rmt mt *.o core
  2591.      
  2592.      mostlyclean: clean
  2593.      
  2594.      distclean: clean
  2595.              rm -f Makefile config.status
  2596.      
  2597.      realclean: distclean
  2598.              rm -f TAGS
  2599.      
  2600.      dist: $(DISTFILES)
  2601.              echo cpio-`sed -e '/version_string/!d' \
  2602.              -e 's/[^0-9.]*\([0-9.]*\).*/\1/' -e q version.c` > .fname
  2603.              rm -rf `cat .fname`
  2604.              mkdir `cat .fname`
  2605.              -ln $(DISTFILES) `cat .fname`
  2606.              for file in $(DISTFILES); do \
  2607.                test -r `cat .fname`/$$file || cp -p $$file `cat .fname`; \
  2608.              done
  2609.              tar chzf `cat .fname`.tar.gz `cat .fname`
  2610.              rm -rf `cat .fname` .fname
  2611.  
  2612. 
  2613. File: autoconf.info,  Node: Preprocessor Symbol Index,  Next: Macro Index,  Prev: Example,  Up: Top
  2614.  
  2615. Preprocessor Symbol Index
  2616. *************************
  2617.  
  2618.    This is an alphabetical list of the C preprocessor symbols that the
  2619. Autoconf macros define.  To work with Autoconf, C source code needs to
  2620. use these names in `#if' directives.
  2621.  
  2622. * Menu:
  2623.  
  2624. * CC:                                   Overriding variables.
  2625. * CONFIG_FILES:                         Invoking config.status.
  2626. * CONFIG_HEADERS:                       Invoking config.status.
  2627. * CONFIG_SHELL:                         Invoking config.status.
  2628. * const:                                Compiler Characteristics.
  2629. * C_ALLOCA:                             Library Functions.
  2630. * DEFS:                                 Overriding variables.
  2631. * DEFS:                                 Predefined Variables.
  2632. * DGUX:                                 Library Functions.
  2633. * DIRENT:                               Header Files.
  2634. * exec_prefix:                          Predefined Variables.
  2635. * GETGROUPS_T:                          Typedefs.
  2636. * GETLODAVG_PRIVILEGED:                 Library Functions.
  2637. * gid_t:                                Typedefs.
  2638. * HAVE_FUNCTION:                        General Feature Tests.
  2639. * HAVE_HEADER:                          General Feature Tests.
  2640. * HAVE_ALLOCA_H:                        Library Functions.
  2641. * HAVE_CONFIG_H:                        Setup.
  2642. * HAVE_DOPRNT:                          Library Functions.
  2643. * HAVE_LONG_DOUBLE:                     Compiler Characteristics.
  2644. * HAVE_LONG_FILE_NAMES:                 System Services.
  2645. * HAVE_MMAP:                            Library Functions.
  2646. * HAVE_NETDB_H:                         Alternative Programs.
  2647. * HAVE_RESTARTABLE_SYSCALLS:            System Services.
  2648. * HAVE_STRCOLL:                         Library Functions.
  2649. * HAVE_ST_BLKSIZE:                      Structures.
  2650. * HAVE_ST_BLOCKS:                       Structures.
  2651. * HAVE_ST_RDEV:                         Structures.
  2652. * HAVE_SYS_MTIO_H:                      System Services.
  2653. * HAVE_TM_ZONE:                         Structures.
  2654. * HAVE_TZNAME:                          Structures.
  2655. * HAVE_UNISTD_H:                        Header Files.
  2656. * HAVE_UTIME_NULL:                      Library Functions.
  2657. * HAVE_VFORK_H:                         Library Functions.
  2658. * HAVE_VPRINTF:                         Library Functions.
  2659. * HAVE_WAIT3:                           Library Functions.
  2660. * inline:                               Compiler Characteristics.
  2661. * INSTALL:                              Overriding variables.
  2662. * INT_16_BITS:                          Compiler Characteristics.
  2663. * LIBOBJS:                              Predefined Variables.
  2664. * LIBS:                                 Overriding variables.
  2665. * LIBS:                                 Predefined Variables.
  2666. * LONG_64_BITS:                         Compiler Characteristics.
  2667. * MAJOR_IN_MKDEV:                       Header Files.
  2668. * MAJOR_IN_SYSMACROS:                   Header Files.
  2669. * mode_t:                               Typedefs.
  2670. * NDIR:                                 Header Files.
  2671. * NEED_MEMORY_H:                        Header Files.
  2672. * NEED_SETGID:                          Library Functions.
  2673. * NLIST_NAME_UNION:                     Library Functions.
  2674. * NLIST_STRUCT:                         Library Functions.
  2675. * NO_ARG_ARRAY:                         Compiler Characteristics.
  2676. * NO_MINUS_C_MINUS_O:                   Alternative Programs.
  2677. * NO_REMOTE:                            Alternative Programs.
  2678. * off_t:                                Typedefs.
  2679. * pid_t:                                Typedefs.
  2680. * prefix:                               Predefined Variables.
  2681. * RETSIGTYPE:                           Typedefs.
  2682. * SETVBUF_REVERSED:                     Library Functions.
  2683. * size_t:                               Typedefs.
  2684. * srcdir:                               Predefined Variables.
  2685. * STDC_HEADERS:                         Header Files.
  2686. * SVR4:                                 Library Functions.
  2687. * SYSDIR:                               Header Files.
  2688. * SYSNDIR:                              Header Files.
  2689. * SYS_SIGLIST_DECLARED:                 Header Files.
  2690. * TIME_WITH_SYS_TIME:                   Structures.
  2691. * TM_IN_SYS_TIME:                       Structures.
  2692. * top_srcdir:                           Predefined Variables.
  2693. * uid_t:                                Typedefs.
  2694. * UMAX:                                 Library Functions.
  2695. * UMAX4_3:                              Library Functions.
  2696. * USG:                                  Header Files.
  2697. * vfork:                                Library Functions.
  2698. * VOID_CLOSEDIR:                        UNIX Variants.
  2699. * VOID_CLOSEDIR:                        Header Files.
  2700. * WORDS_BIGENDIAN:                      Compiler Characteristics.
  2701. * _ALL_SOURCE:                          UNIX Variants.
  2702. * _MINIX:                               UNIX Variants.
  2703. * _POSIX_1_SOURCE:                      UNIX Variants.
  2704. * _POSIX_SOURCE:                        UNIX Variants.
  2705. * _POSIX_SOURCE:                        UNIX Variants.
  2706. * _POSIX_VERSION:                       Header Files.
  2707. * __CHAR_UNSIGNED__:                    Compiler Characteristics.
  2708.  
  2709. 
  2710. File: autoconf.info,  Node: Macro Index,  Prev: Preprocessor Symbol Index,  Up: Top
  2711.  
  2712. Macro Index
  2713. ***********
  2714.  
  2715.    This is an alphabetical list of the Autoconf macros.  To make the
  2716. list easier to use, the macros are listed without their preceding `AC_'.
  2717.  
  2718. * Menu:
  2719.  
  2720. * AIX:                                  UNIX Variants.
  2721. * ALLOCA:                               Library Functions.
  2722. * ARG_ARRAY:                            Compiler Characteristics.
  2723. * BEFORE:                               Macro Ordering.
  2724. * CHAR_UNSIGNED:                        Compiler Characteristics.
  2725. * CHECKING:                             Printing Messages.
  2726. * COMPILE_CHECK:                        General Feature Tests.
  2727. * CONFIG_HEADER:                        Setup.
  2728. * CONST:                                Compiler Characteristics.
  2729. * CROSS_CHECK:                          Compiler Characteristics.
  2730. * DEFINE:                               Setting Variables.
  2731. * DEFINE_UNQUOTED:                      Setting Variables.
  2732. * DIR_HEADER:                           Header Files.
  2733. * DYNIX_SEQ:                            UNIX Variants.
  2734. * ENABLE:                               Command Line.
  2735. * ERROR:                                Printing Messages.
  2736. * FIND_X:                               System Services.
  2737. * FIND_XTRA:                            System Services.
  2738. * FUNC_CHECK:                           General Feature Tests.
  2739. * GCC_TRADITIONAL:                      Alternative Programs.
  2740. * GETGROUPS_T:                          Typedefs.
  2741. * GETLOADAVG:                           Library Functions.
  2742. * HAVE_FUNCS:                           General Feature Tests.
  2743. * HAVE_HEADERS:                         General Feature Tests.
  2744. * HAVE_LIBRARY:                         General Feature Tests.
  2745. * HAVE_LONG_DOUBLE:                     Compiler Characteristics.
  2746. * HAVE_POUNDBANG:                       System Services.
  2747. * HEADER_CHECK:                         General Feature Tests.
  2748. * HEADER_EGREP:                         General Feature Tests.
  2749. * INIT:                                 Setup.
  2750. * INLINE:                               Compiler Characteristics.
  2751. * INT_16_BITS:                          Compiler Characteristics.
  2752. * IRIX_SUN:                             UNIX Variants.
  2753. * ISC_POSIX:                            UNIX Variants.
  2754. * LANG_C:                               Language Choice.
  2755. * LANG_CPLUSPLUS:                       Language Choice.
  2756. * LANG_RESTORE:                         Language Choice.
  2757. * LANG_SAVE:                            Language Choice.
  2758. * LN_S:                                 Alternative Programs.
  2759. * LONG_64_BITS:                         Compiler Characteristics.
  2760. * LONG_FILE_NAMES:                      System Services.
  2761. * MAJOR_HEADER:                         Header Files.
  2762. * MEMORY_H:                             Header Files.
  2763. * MINIX:                                UNIX Variants.
  2764. * MINUS_C_MINUS_O:                      Alternative Programs.
  2765. * MMAP:                                 Library Functions.
  2766. * MODE_T:                               Typedefs.
  2767. * OBSOLETE:                             Macro Ordering.
  2768. * OFF_T:                                Typedefs.
  2769. * OUTPUT:                               Setup.
  2770. * PID_T:                                Typedefs.
  2771. * PREFIX:                               Command Line.
  2772. * PREPARE:                              Setup.
  2773. * PREREQ:                               Setup.
  2774. * PROGRAMS_CHECK:                       General Feature Tests.
  2775. * PROGRAMS_PATH:                        General Feature Tests.
  2776. * PROGRAM_CHECK:                        General Feature Tests.
  2777. * PROGRAM_EGREP:                        General Feature Tests.
  2778. * PROGRAM_PATH:                         General Feature Tests.
  2779. * PROG_AWK:                             Alternative Programs.
  2780. * PROG_CC:                              Alternative Programs.
  2781. * PROG_CPP:                             Alternative Programs.
  2782. * PROG_CXX:                             Alternative Programs.
  2783. * PROG_CXXCPP:                          Alternative Programs.
  2784. * PROG_INSTALL:                         Alternative Programs.
  2785. * PROG_LEX:                             Alternative Programs.
  2786. * PROG_RANLIB:                          Alternative Programs.
  2787. * PROG_YACC:                            Alternative Programs.
  2788. * PROVIDE:                              Macro Ordering.
  2789. * REMOTE_TAPE:                          System Services.
  2790. * REPLACE_FUNCS:                        General Feature Tests.
  2791. * REQUIRE:                              Macro Ordering.
  2792. * REQUIRE_CPP:                          Language Choice.
  2793. * RESTARTABLE_SYSCALLS:                 System Services.
  2794. * RETSIGTYPE:                           Typedefs.
  2795. * REVISION:                             Setup.
  2796. * RSH:                                  Alternative Programs.
  2797. * SCO_INTL:                             UNIX Variants.
  2798. * SETVBUF_REVERSED:                     Library Functions.
  2799. * SET_MAKE:                             Alternative Programs.
  2800. * SIZEOF_TYPE:                          General Feature Tests.
  2801. * SIZE_T:                               Typedefs.
  2802. * STAT_MACROS_BROKEN:                   Structures.
  2803. * STAT_MACROS_BROKEN:                   Structures.
  2804. * STDC_HEADERS:                         Header Files.
  2805. * STRCOLL:                              Library Functions.
  2806. * STRUCT_TM:                            Structures.
  2807. * ST_BLKSIZE:                           Structures.
  2808. * ST_BLOCKS:                            Structures.
  2809. * ST_RDEV:                              Structures.
  2810. * SUBST:                                Setting Variables.
  2811. * SYS_SIGLIST_DECLARED:                 Header Files.
  2812. * TEST_CPP:                             General Feature Tests.
  2813. * TEST_PROGRAM:                         General Feature Tests.
  2814. * TIMEZONE:                             Structures.
  2815. * TIME_WITH_SYS_TIME:                   Structures.
  2816. * UID_T:                                Typedefs.
  2817. * UNISTD_H:                             Header Files.
  2818. * USG:                                  Header Files.
  2819. * UTIME_NULL:                           Library Functions.
  2820. * VERBOSE:                              Printing Messages.
  2821. * VFORK:                                Library Functions.
  2822. * VPRINTF:                              Library Functions.
  2823. * WAIT3:                                Library Functions.
  2824. * WARN:                                 Printing Messages.
  2825. * WITH:                                 Command Line.
  2826. * WORDS_BIGENDIAN:                      Compiler Characteristics.
  2827. * XENIX_DIR:                            UNIX Variants.
  2828.  
  2829.  
  2830. 
  2831. Tag Table:
  2832. Node: Top1070
  2833. Node: Introduction4456
  2834. Node: Distributing8238
  2835. Node: Making configure Scripts9327
  2836. Node: Writing configure.in11572
  2837. Node: Invoking autoconf14005
  2838. Node: Invoking autoheader15854
  2839. Node: Specific Tests17989
  2840. Node: Alternative Programs19661
  2841. Node: Header Files24506
  2842. Node: Typedefs30191
  2843. Node: Library Functions31408
  2844. Node: Structures36179
  2845. Node: Compiler Characteristics38269
  2846. Node: System Services41232
  2847. Node: UNIX Variants43320
  2848. Node: General Purpose Macros45228
  2849. Node: Setup46379
  2850. Node: General Feature Tests51333
  2851. Node: Command Line60328
  2852. Node: Setting Variables64142
  2853. Node: Printing Messages67472
  2854. Node: Language Choice69694
  2855. Node: Macro Ordering71315
  2856. Node: Writing Macros74061
  2857. Node: Macro Format75557
  2858. Node: Quoting77054
  2859. Node: Dependencies Between Macros78512
  2860. Node: Prerequisite Macros79099
  2861. Node: Suggested Ordering80148
  2862. Node: Checking for Files81527
  2863. Node: Checking for Symbols82313
  2864. Node: Test Programs83792
  2865. Node: Guidelines85457
  2866. Node: Tricks86600
  2867. Node: Multiple Cases87603
  2868. Node: Makefiles88807
  2869. Node: Predefined Variables90208
  2870. Node: Installation Prefixes91716
  2871. Node: VPATH Substitutions93226
  2872. Node: Automatic Remaking94947
  2873. Node: Invoking configure96527
  2874. Node: Overriding variables100024
  2875. Node: Invoking config.status101647
  2876. Node: Example104626
  2877. Node: Sample configure.in105206
  2878. Node: Sample Makefile.in106343
  2879. Node: Preprocessor Symbol Index110328
  2880. Node: Macro Index115523
  2881. 
  2882. End Tag Table
  2883.